Cómo comenzar rápidamente con VUE3.0: ¿Aprenda
Símbolo (símbolo) es un nuevo tipo de datos en ES6. Los símbolos son valores primitivos (el tipo de datos subyacente) y las instancias de símbolos son únicas e inmutables. Se genera porque se utiliza para marcar de forma única y luego usarse como atributos de objeto en forma que no sea una cadena. Es para garantizar que los atributos de objeto utilicen identificadores únicos y no haya peligro de conflictos de atributos.
Los símbolos de uso básico deben inicializarse utilizando la función Symbol(). Debido a que los símbolos en sí son tipos primitivos, el operador typeof devuelve símbolo por símbolos.
let sym = Símbolo(); console.log(typeof sym); // símbolo
La función Symbol() puede recibir un parámetro de cadena para describir y luego puede usar esta cadena para depurar el código. Pero vale la pena señalar que incluso si varias funciones Symbol() aceptan los mismos parámetros, sus valores no son iguales.
let genericSymbol = Símbolo();
let otherGenericSymbol = Símbolo();
let fooSymbol = Símbolo("foo");
let otherFooSymbol = Símbolo("foo");
console.log(genericSymbol == otherGenericSymbol);
console.log(fooSymbol == otherFooSymbol); // false Si necesita utilizar la misma instancia de símbolo en varios lugares del código, puede pasar una cadena y luego utilizar Symbol.for(. ) para crear un símbolo reutilizable, similar al modo singleton. Cuando se usa Symbol.for() por primera vez, buscará globalmente si se debe usar Symbol.for() para crearlo en función de los parámetros pasados. Lo mismo. se ha pasado la instancia, si existe, reutilícela, si no, cree
una nueva let fooGlobalSymbol = Symbol.for("foo"); // Crea un nuevo símbolo let otherFooGlobalSymbol = Symbol.for("foo"); / Reutilizarlo Firmado console.log(fooGlobalSymbol === otherFooGlobalSymbol); // true La diferencia entre la instancia creada por Symbol.for() y la instancia creada por Symbol(): La instancia creada por Symbol() es siempre única y no cambiará debido a que los parámetros de entrada son los mismos e iguales a otras instancias, pero las instancias creadas por Symbol.for() serán iguales si los parámetros son los mismos, porque compartirán la misma instancia de Symbol
let fooSymbol = Símbolo("foo");
let otherFooSymbol = Símbolo("foo");
console.log(fooSymbol == otroFooSymbol);
let fooGlobalSymbol = Symbol.for("foo"); // Crea un nuevo símbolo let otherFooGlobalSymbol = Symbol.for("foo"); // Reutiliza un símbolo existente console.log(fooGlobalSymbol === otherFooGlobalSymbol); Los atributos en los objetos generalmente tienen forma de cadenas, pero de hecho también puedes usar instancias de Símbolo como atributos. La ventaja de esto es que tus nuevos atributos no sobrescribirán ningún atributo anterior
. "foo"),
s2 = Símbolo("barra"),
s3 = Símbolo("baz"),
s4 = Símbolo("qux");
sea o = {
[s1]: "foo val",
};
// Esto también funciona: o[s1] = 'foo val';
consola.log(o);
// {Símbolo(foo): foo val}
Object.defineProperty(o, s2, {valor: "valor de barra"});
consola.log(o);
// {Símbolo(foo): foo val, Símbolo(barra): bar val}
Objeto.defineProperties(o, {
[s3]: { valor: "baz val" },
[s4]: { valor: "qux val" },
});
consola.log(o);
// {Símbolo(foo): foo val, Símbolo(barra): bar val,
// Símbolo(baz): baz val, Símbolo(qux): qux val} Nota: Al crear una instancia de Símbolo como atributo de objeto, si cambia el símbolo sin declarar una variable para recibirlo al principio, deberá atravesar posteriormente todos los símbolos de la propiedad del objeto para encontrar la clave de propiedad correspondiente:
sea o = {.
[Símbolo("foo")]: "foo val",
[Símbolo("barra")]: "valor de barra",
};
consola.log(o);
// {Símbolo(foo): "foo val", Símbolo(barra): "barra val"}
let barSymbol = Object.getOwnPropertySymbols(o).find(symbol => symbol.toString().match(/bar/));
console.log(barSymbol);
// Símbolo (barra) ES6 también introduce una serie de símbolos integrados de uso común (símbolos conocidos) para exponer el comportamiento interno del lenguaje y los desarrolladores pueden acceder a ellos, reescribirlos o simularlos directamente. comportamientos. Si se modifican estos atributos predeterminados, se pueden cambiar los resultados finales de la ejecución de algunas operaciones. Por ejemplo, un bucle for-of utilizará la propiedad Symbol.iterator en el objeto relevante, por lo que puede cambiar el comportamiento de for-of al iterar el objeto redefiniendo el valor de Symbol.iterator en el objeto personalizado.
es en realidad un generador que devuelve una promesa, generalmente usado con espera de
Según la especificación ECMAScript, este símbolo como atributo representa "un método que devuelve el AsyncIterator predeterminado del objeto. Por- await -of declaración usando ". En otras palabras, este símbolo representa una función que implementa la API del iterador asíncrono.
Esta propiedad está definida en el prototipo de función. Todos sabemos que el operador instancia de se puede utilizar para determinar si una instancia de objeto pertenece a un determinado constructor. El principio es que el operador instancia de utilizará la función Symbol.hasInstance para determinar la
función de relación Foo() {}
let f = nuevo Foo();
console.log(f instanciade Foo); // verdadero
barra de clase {}
let b = nueva barra();
console.log(b instanciade Bar); // verdaderoSi redefine la propiedad Symbol.hasInstance de una función, puede hacer que el método instanciade devuelva algo inesperado
class Bar {}
clase Baz extiende Bar {
estático [Símbolo.hasInstance]() {
devolver falso;
}
}
let b = nuevo Baz();
console.log(Bar[Symbol.hasInstance](b)); // verdadero
console.log(b instanciade Bar); // verdadero
console.log(Baz[Symbol.hasInstance](b)); // falso
console.log(b instanciade Baz); // false Esta propiedad está definida en el prototipo de Array
. Según la especificación ECMAScript, este símbolo como propiedad representa "un valor booleano. Si es verdadero, significa que el objeto debe usar Array. prototipo.concat() aplana sus elementos de matriz". El método Array.prototype.concat() en ES6 elegirá cómo unir un objeto similar a una matriz (pseudomatriz) en una instancia de matriz según el tipo de objeto recibido. Entonces, modificar el valor de Symbol.isConcatSpreadable puede modificar este comportamiento.
es falso: agrega un objeto completo a la matriz. verdadero: agrega un par completo a la matriz
let inicial = ["foo"];
let matriz = ["barra"];
console.log(array[Symbol.isConcatSpreadable]); // indefinido
console.log(initial.concat(array)); // ['foo', 'bar']
matriz[Symbol.isConcatSpreadable] = false;
console.log(initial.concat(matriz)); // ['foo', Matriz(1)]
let arrayLikeObject = {longitud: 1, 0: "baz" };
console.log(arrayLikeObject[Symbol.isConcatSpreadable] // indefinido
console.log(initial.concat(arrayLikeObject)); // ['foo', {...}]
arrayLikeObject[Symbol.isConcatSpreadable] = verdadero;
console.log(initial.concat(arrayLikeObject)); // ['foo', 'baz']
let otherObject = new Set().add("qux");
console.log(otherObject[Symbol.isConcatSpreadable]); // indefinido
console.log(initial.concat(otroObjeto)); // ['foo', Set(1)]
otherObject[Symbol.isConcatSpreadable] = verdadero;
console.log(initial.concat(otherObject)); // ['foo'] Según la especificación ECMAScript, este símbolo como atributo representa "un método que devuelve el iterador predeterminado del objeto. Usado por for- La declaración of usa "
Este atributo devolverá una función Generador, y for of llamará al método next() a su vez. Es por eso que for of se puede usar en ciertos objetos.
clase emisor {
constructor(máximo) {
this.max = máximo;
este.idx = 0;
}
*[Símbolo.iterador]() {
mientras (este.idx 9. Symbol.match
Según la especificación ECMAScript, este símbolo como atributo representa "un método de expresión regular que utiliza una expresión regular para hacer coincidir una cadena. Utilizado por el método String.prototype.match()".
El método String.prototype.match() evalúa una expresión regular utilizando una función codificada por Symbol.match. Entonces, cambiar el atributo Symbol.match de una expresión regular permite que String.prototype.match() obtenga el valor que desea
console.log(RegExp.prototype[Symbol.match]);
// ƒ [Symbol.match]() { [código nativo] }
console.log("foobar".match(/bar/));
// ["barra", índice: 3, entrada: "foobar", grupos: indefinido]
clase FooMatcher {
estático [Símbolo.partido](objetivo) {
return target.includes("foo");
}
}
console.log("foobar".match(FooMatcher)); // verdadero
console.log("barbaz".match(FooMatcher)); // falso
clase StringMatcher {
constructor(cadena) {
this.str = cadena;
}
[Símbolo.coincidencia](objetivo) {
return target.includes(this.str);
}
}
console.log("foobar".match(new StringMatcher("foo"))) // verdadero
console.log("barbaz".match(new StringMatcher("qux"))); // false 11. Symbol.search
Este símbolo como atributo representa "un método de expresión regular que devuelve la expresión regular coincidente en el índice de cadena de la fórmula utilizada por el método String.prototype.search()"
12. Symbol.species
Este símbolo como atributo representa "un valor de función que sirve como constructor para crear objetos derivados".
13. Symbol.split
Este símbolo como atributo representa "un método de expresión regular que divide una cadena en la posición del índice que coincide con la expresión regular. Utilizado por el método String.prototype.split()".
14. Symbol.toPrimitive
Este símbolo como atributo representa "un método que convierte un objeto al valor primitivo correspondiente. Utilizado por la operación abstracta ToPrimitive"
15. Symbol.toStringTag
Este símbolo como atributo representa "una cadena para la que String se utiliza cree la descripción de cadena predeterminada del objeto Utilizada por el método incorporado Object.prototype.toString()."
16. Symbol.unscopables
Este símbolo representa un objeto como una propiedad, y todas las propiedades heredadas y del objeto se derivarán. del asociado Excluido del objeto con enlace de entorno