Как быстро начать работу с VUE3.0: узнайте,
Символ (symbol) — новый тип данных в ES6. Символы представляют собой примитивные значения (основной тип данных), а экземпляры символов уникальны и неизменяемы. Он создается, поскольку используется для уникальной маркировки, а затем используется в качестве атрибутов объекта в нестроковой форме. Это делается для того, чтобы гарантировать, что атрибуты объекта используют уникальные идентификаторы и нет опасности конфликтов атрибутов.
символы использования необходимо инициализировать с помощью функции Symbol(). Поскольку символы сами по себе являются примитивными типами, оператор typeof возвращает символ для символов.
пусть sym = Символ(); console.log(typeof sym); // символ
Функция Symbol() может получить строковый параметр для описания, а затем вы можете использовать эту строку для отладки кода. Но стоит отметить, что даже если несколько функций Symbol() принимают одни и те же параметры, их значения не равны.
пусть genericSymbol = Символ();
пусть другойGenericSymbol = Символ();
пусть fooSymbol = Символ("foo");
letotherFooSymbol = Символ("foo");
console.log(genericSymbol == OtherGenericSymbol); // ложь;
console.log(fooSymbol ==otherFooSymbol); // false Если вам нужно использовать один и тот же экземпляр символа в нескольких местах кода, вы можете передать строку, а затем использовать символ.for(. ) для создания повторно используемого символа, аналогично одноэлементному режиму. При первом использовании символа.for() он будет глобально искать, следует ли использовать символ.for() для его создания, на основе переданных параметров. То же самое. экземпляр передан, если он существует, используйте его повторно, если нет, создайте
новый let fooGlobalSymbol = Symbol.for("foo"); // Создайте новый символ letotherFooGlobalSymbol = Symbol.for("foo"); / Используйте его повторно Signed console.log(fooGlobalSymbol ===otherFooGlobalSymbol // true Разница между экземпляром, созданным с помощью символа.for(), и экземпляром, созданным с помощью символа(): экземпляр, созданный с помощью символа(), всегда уникален и не изменится, поскольку входные параметры одинаковы и равны другим экземплярам, но экземпляры, созданные с помощью Symbol.for(), будут равны, если параметры одинаковы, поскольку они будут использовать один и тот же экземпляр символа,
пусть fooSymbol = Символ("фу");
letotherFooSymbol = Символ("foo");
console.log(fooSymbol == OtherFooSymbol); // ложь;
let fooGlobalSymbol = Symbol.for("foo"); // Создаём новый символ letotherFooGlobalSymbol = Symbol.for("foo"); // Повторно используем существующий символ console.log(fooGlobalSymbol ===otherFooGlobalSymbol); // true; Атрибуты в объектах обычно имеют форму строк, но на самом деле вы также можете использовать экземпляры символов в качестве атрибутов. Преимущество этого подхода заключается в том, что ваши новые атрибуты не будут перезаписывать предыдущие атрибуты,
пусть s1 = Символ (. "фу"),
s2 = Символ("бар"),
s3 = Символ("баз"),
s4 = Символ("qux");
пусть о = {
[s1]: "фу вал",
};
// Это тоже работает: o[s1] = 'foo val';
console.log(о);
// {Символ(foo): foo val}
Object.defineProperty(o, s2, { value: "bar val" });
console.log(о);
// {Symbol(foo): foo val, Символ(bar): bar val}
Object.defineProperties(o, {
[s3]: {value: "баз вал" },
[s4]: {значение: "qux val" },
});
console.log(о);
// {Symbol(foo): foo val, Символ(bar): bar val,
// Символ(baz): baz val, Символ(qux): qux val} Примечание. При создании экземпляра Символа в качестве атрибута объекта, если вы измените символ без объявления переменной для его получения в начале, вам придется впоследствии пройти все символы свойства объекта, чтобы найти соответствующий ключ свойства:
let o = {
[Symbol("foo")]: "foo val",
[Symbol("bar")]: "бар val",
};
console.log(о);
// {Symbol(foo): "foo val", Symbol(bar): "bar val"}
let barSymbol = Object.getOwnPropertySymbols(o).find(symbol =>symbol.toString().match(/bar/));
console.log(барСимвол);
// Символ(бар) ES6 также вводит ряд часто используемых встроенных символов (хорошо известных символов) для демонстрации внутреннего поведения языка. Разработчики могут напрямую обращаться к ним, переписывать или моделировать их. поведение. Если эти атрибуты по умолчанию изменены, конечные результаты выполнения некоторых операций могут быть изменены. Например, цикл for-of будет использовать свойство символа.iterator соответствующего объекта, поэтому вы можете изменить поведение for-of при итерации объекта, переопределив значение символа.iterator в пользовательском объекте.
на самом деле является генератором, возвращающим обещание, обычно используемое для ожидания
Согласно спецификации ECMAScript, этот символ в качестве атрибута представляет собой «метод, который возвращает AsyncIterator объекта по умолчанию. await -of оператор с использованием ". Другими словами, этот символ представляет собой функцию, реализующую API асинхронного итератора.
Это свойство определено в прототипе функции. Все мы знаем, что оператор экземпляра можно использовать для определения принадлежности экземпляра объекта определенному конструктору. Принцип заключается в том, что оператор экземпляра будет использовать функцию Symbol.hasInstance для определения
функции связи Foo() {}
пусть f = новый Foo();
console.log(f экземпляр Foo // true);
класс Бар {}
пусть b = новый бар();
console.log(b instanceof Bar); // trueЕсли вы переопределите свойство символа.hasInstance функции, вы можете заставить метод экземпляра возвращать что-то неожиданное
класса Bar {}
класс Baz расширяет Bar {
статический [Symbol.hasInstance]() {
вернуть ложь;
}
}
пусть b = новый Baz();
console.log(Bar[Symbol.hasInstance](b)); // true
console.log(b экземпляр Бар // правда);
console.log(Baz[Symbol.hasInstance](b)); // ложь
console.log(b instanceof Baz); // false Это свойство определено в прототипе Array
. Согласно спецификации ECMAScript, этот символ как свойство представляет собой «логическое значение». Если оно истинно, это означает, что объект должен использовать Array.prototype.concat() выравнивает элементы массива». Метод Array.prototype.concat() в ES6 выбирает, как объединить объект, подобный массиву (псевдомассив), в экземпляр массива на основе полученного типа объекта. Таким образом, изменение значения Symbol.isConcatSpreadable может изменить это поведение.
равен false: добавить весь объект в массив true: добавить целую пару в массив
let Initial = ["foo"];
пусть массив = ["бар"];
console.log(array[Symbol.isConcatSpreadable]); // не определено
console.log(initial.concat(array)); // ['foo', 'bar']
массив [Symbol.isConcatSpreadable] = ложь;
console.log(initial.concat(array)); // ['foo', Array(1)]
let arrayLikeObject = { length: 1, 0: "baz" };
console.log(arrayLikeObject[Symbol.isConcatSpreadable]); // не определено
console.log(initial.concat(arrayLikeObject)); // ['foo', {...}]
arrayLikeObject[Symbol.isConcatSpreadable] = true;
console.log(initial.concat(arrayLikeObject)); // ['foo', 'baz']
letotherObject = new Set().add("qux");
console.log(otherObject[Symbol.isConcatSpreadable]); // не определено
console.log(initial.concat(otherObject)); // ['foo', Set(1)]
другойОбъект[Symbol.isConcatSpreadable] = правда;
console.log(initial.concat(otherObject)); // ['foo'] Согласно спецификации ECMAScript, этот символ в качестве атрибута представляет собой «метод, который возвращает итератор объекта по умолчанию. Используется for- Оператор of использует: «
Этот атрибут вернет функцию-генератор, а for of в свою очередь вызовет метод next(). Вот почему for of можно использовать для определенных объектов.
класс Эмиттер {
конструктор (макс) {
this.max = макс;
это.idx = 0;
}
*[Symbol.iterator]() {
в то время как (this.idx < this.max) {
дать this.idx++;
}
}
}
функция счетчик() {
пусть эмиттер = новый эмиттер (5);
for (const x эмиттера) {
console.log(х);
}
}
считать();
// 0
// 1
// 2
// 3
// 4 Согласно спецификации ECMAScript, этот символ в качестве атрибута представляет собой «метод регулярного выражения, который использует регулярное выражение для сопоставления со строкой. Используется методом String.prototype.match()».
Метод String.prototype.match() оценивает регулярное выражение, используя функцию, связанную с символом.match. Таким образом, изменение атрибута символа.match регулярного выражения позволяет String.prototype.match() получить нужное значение
console.log(RegExp.prototype[Symbol.match]);
// ƒ [Symbol.match]() { [собственный код] }
console.log("foobar".match(/bar/));
// ["bar", индекс: 3, ввод: "foobar", группы: не определены]
класс FooMatcher {
статический [Symbol.match](цель) {
вернуть target.includes("foo");
}
}
console.log("foobar".match(FooMatcher)); // true
console.log("barbaz".match(FooMatcher)); // ложь
класс StringMatcher {
конструктор(строка) {
this.str = стр;
}
[Symbol.match](цель) {
вернуть target.includes(this.str);
}
}
console.log("foobar".match(new StringMatcher("foo"))) // true
console.log("barbaz".match(new StringMatcher("qux"))); // false Этот символ в качестве атрибута представляет собой «метод регулярного выражения, который возвращает соответствующее регулярное выражение в индексе строки». формула. Используется методом String.prototype.search()».
Этот символ в качестве атрибута представляет собой «значение функции, которое служит конструктором для создания производных объектов».
Этот символ в качестве атрибута представляет собой «метод регулярного выражения, который разбивает строку по позиции индекса, соответствующей регулярному выражению. Используется методом String.prototype.split()».
Этот символ в качестве атрибута представляет собой «метод, который преобразует объект в соответствующее примитивное значение. Используется абстрактной операцией ToPrimitive».
Этот символ в качестве атрибута представляет «строку, для которой используется строка String
».создать строковое описание объекта по умолчанию. Используется встроенным методом Object.prototype.toString()».
Этот символ представляет объект как свойство, и все его и унаследованные свойства будут производными. из связанного объекта «Исключено из» с привязкой к среде