Como começar rapidamente com VUE3.0: Aprenda
Símbolo (símbolo) é um novo tipo de dados no ES6. Os símbolos são valores primitivos (o tipo de dados subjacente) e as instâncias de símbolos são únicas e imutáveis. Ele é gerado porque é usado para marcar exclusivamente e depois ser usado como atributos de objeto em formato não-string. É para garantir que os atributos do objeto usem identificadores exclusivos e não haja perigo de conflitos de atributos.
Os símbolos de uso básico precisam ser inicializados usando a função Symbol(). Como os próprios símbolos são tipos primitivos, o operador typeof retorna símbolo para símbolos.
deixe sym = Símbolo(); console.log(typeof sym); // símbolo
A função Symbol() pode receber um parâmetro de string para descrever e então você pode usar essa string para depurar o código. Mas é importante notar que mesmo que múltiplas funções Symbol() aceitem os mesmos parâmetros, seus valores não são iguais.
deixe genéricoSymbol = Símbolo();
deixe outroGenericSymbol = Símbolo();
deixe fooSymbol = Símbolo("foo");
deixe otherFooSymbol = Símbolo("foo");
console.log(genericSymbol == otherGenericSymbol);
console.log(fooSymbol == otherFooSymbol); // false Se você precisar usar a mesma instância de Symbol em vários lugares no código, você pode passar uma string e então usar Symbol.for(. ) para criar um símbolo reutilizável, semelhante ao modo singleton Ao usar Symbol.for() pela primeira vez, ele pesquisará globalmente se deve usar Symbol.for() para criá-lo com base nos parâmetros passados. instância foi passada, se existir, reutilize-a, caso contrário, crie
uma nova let fooGlobalSymbol = Symbol.for("foo"); // Crie um novo símbolo let otherFooGlobalSymbol = Symbol.for("foo"); / Reutilizá-lo Assinado console.log(fooGlobalSymbol === otherFooGlobalSymbol); // true A diferença entre a instância criada por Symbol.for() e a instância criada por Symbol(): A instância criada por Symbol() é sempre única e não mudará porque os parâmetros de entrada são iguais e iguais a outras instâncias, mas as instâncias criadas por Symbol.for() serão iguais se os parâmetros forem iguais, porque eles compartilharão a mesma instância de Símbolo,
deixe fooSymbol = Símbolo("foo");
deixe otherFooSymbol = Símbolo("foo");
console.log(fooSymbol == otherFooSymbol);
let fooGlobalSymbol = Symbol.for("foo"); // Crie um novo símbolo let otherFooGlobalSymbol = Symbol.for("foo"); // Reutilize um símbolo existente console.log(fooGlobalSymbol === otherFooGlobalSymbol); Os atributos em objetos geralmente estão na forma de strings, mas na verdade você também pode usar instâncias de Símbolo como atributos. A vantagem disso é que seus novos atributos não substituirão nenhum atributo anterior,
deixe s1 = Símbolo (. "foo"),
s2 = Símbolo("barra"),
s3 = Símbolo("baz"),
s4 = Símbolo("qux");
seja o = {
[s1]: "fooval",
};
// Isso também funciona: o[s1] = 'foo val';
console.log(o);
// {Símbolo(foo): foo val}
Object.defineProperty(o, s2, { valor: "bar val" });
console.log(o);
// {Symbol(foo): foo val, Símbolo(barra): bar val}
Object.defineProperties(o, {
[s3]: {valor: "baz val" },
[s4]: {valor: "qux val" },
});
console.log(o);
// {Symbol(foo): foo val, Símbolo(barra): bar val,
// Símbolo(baz): baz val, Símbolo(qux): qux val} Nota: Ao criar uma instância de Símbolo como um atributo de objeto, se você alterar o símbolo sem declarar uma variável para recebê-lo no início, você deverá percorrer posteriormente todos os símbolos da propriedade do objeto para encontrar a chave da propriedade correspondente:
let o = {.
[Símbolo("foo")]: "foo val",
[Símbolo("barra")]: "valor da barra",
};
console.log(o);
// {Symbol(foo): "foo val", Símbolo(bar): "bar val"}
deixe barSymbol = Object.getOwnPropertySymbols(o).find(symbol => symbol.toString().match(/bar/));
console.log(barSymbol);
// Símbolo (barra) O ES6 também introduz uma série de símbolos integrados comumente usados (símbolos bem conhecidos) para expor o comportamento interno da linguagem. Os desenvolvedores podem acessá-los, reescrevê-los ou simulá-los diretamente. comportamentos. Se esses atributos padrão forem modificados, os resultados finais da execução de algumas operações poderão ser alterados. Por exemplo, um loop for-of usará a propriedade Symbol.iterator no objeto relevante, para que você possa alterar o comportamento de for-of ao iterar o objeto, redefinindo o valor de Symbol.iterator no objeto personalizado.
é na verdade um Generator que retorna uma Promise, geralmente usado com for await de
De acordo com a especificação ECMAScript, este símbolo como um atributo representa "um método que retorna o AsyncIterator padrão do objeto. Por for- aguarde a instrução -of usando ". Em outras palavras, este símbolo representa uma função que implementa a API do iterador assíncrono.
Esta propriedade é definida no protótipo Function. Todos sabemos que o operador instanceof pode ser usado para determinar se uma instância de objeto pertence a um determinado construtor. O princípio é que o operador instanceof usará a função Symbol.hasInstance para determinar a
função de relacionamento Foo() {}
deixe f = new Foo();
console.log(f instância de Foo);
classe Barra {}
deixe b = nova Barra();
console.log(b instanceof Bar); // trueSe você redefinir a propriedade Symbol.hasInstance de uma função, poderá fazer com que o método instanceof retorne algo inesperado
class Bar {}
classe Baz estende Barra {
estático [Symbol.hasInstance]() {
retornar falso;
}
}
deixe b = novo Baz();
console.log(Bar[Symbol.hasInstance](b));
console.log(b instância da barra);
console.log(Baz[Symbol.hasInstance](b));
console.log(b instanceof Baz); // false Esta propriedade é definida no protótipo de Array
. De acordo com a especificação ECMAScript, este símbolo como propriedade representa "um valor booleano. Se for verdadeiro, significa que o objeto deve usar Array. protótipo.concat() nivela seus elementos do array ". O método Array.prototype.concat() no ES6 escolherá como unir um objeto semelhante a um array (pseudo-array) em uma instância de array com base no tipo de objeto recebido. Portanto, modificar o valor de Symbol.isConcatSpreadable pode modificar esse comportamento.
é falso: adicione um objeto inteiro ao array true: adicione um par inteiro ao array
let inicial = ["foo"];
deixe array = ["barra"];
console.log(array[Symbol.isConcatSpreadable]);
console.log(initial.concat(array)); // ['foo', 'barra']
array[Symbol.isConcatSpreadable] = falso;
console.log(initial.concat(array)); // ['foo', Array(1)]
deixe arrayLikeObject = { comprimento: 1, 0: "baz" };
console.log(arrayLikeObject[Symbol.isConcatSpreadable]);
console.log(initial.concat(arrayLikeObject)); // ['foo', {...}]
arrayLikeObject[Symbol.isConcatSpreadable] = verdadeiro;
console.log(initial.concat(arrayLikeObject)); // ['foo', 'baz']
deixe outroObjeto = new Set().add("qux");
console.log(otherObject[Symbol.isConcatSpreadable]);
console.log(initial.concat(outroObject)); // ['foo', Set(1)]
otherObject[Symbol.isConcatSpreadable] = verdadeiro;
console.log(initial.concat(otherObject)); // ['foo'] De acordo com a especificação ECMAScript, este símbolo como um atributo representa "um método que retorna o iterador padrão do objeto. Usado por for- A instrução of usa "
Este atributo retornará uma função Geradora, e for of chamará o método next() por sua vez. É por isso que for of pode ser usado em certos objetos.
classe Emissor {
construtor(máx.) {
isto.max = max;
isto.idx = 0;
}
*[Symbol.iterador]() {
enquanto (este.idx <este.max) {
produza isto.idx++;
}
}
}
contagem de funções() {
deixe emissor = novo Emissor(5);
for (const x do emissor) {
console.log(x);
}
}
contar();
//0
//1
//2
//3
// 4 De acordo com a especificação ECMAScript, este símbolo como um atributo representa "um método de expressão regular que usa uma expressão regular para corresponder a uma string. Usado pelo método String.prototype.match()."
O método String.prototype.match() avalia uma expressão regular usando uma função digitada por Symbol.match. Portanto, alterar o atributo Symbol.match de uma expressão regular permite que String.prototype.match() obtenha o valor desejado
console.log(RegExp.prototype[Symbol.match]);
// ƒ [Symbol.match]() { [código nativo] }
console.log("foobar".match(/bar/));
// ["bar", índice: 3, entrada: "foobar", grupos: indefinido]
classeFooMatcher {
estático [Symbol.match](alvo) {
return target.includes("foo");
}
}
console.log("foobar".match(FooMatcher));
console.log("barbaz".match(FooMatcher));
classeStringMatcher {
construtor(str) {
isto.str = str;
}
[Symbol.match](alvo) {
retornar alvo.includes(this.str);
}
}
console.log("foobar".match(new StringMatcher("foo")));
console.log("barbaz".match(new StringMatcher("qux"))); // false Este símbolo como um atributo representa "um método de expressão regular que retorna a expressão regular correspondente na string Índice de a fórmula. Usado pelo método String.prototype.search()"
Este símbolo como um atributo representa "um valor de função que serve como construtor para criar objetos derivados."
Este símbolo como atributo representa "um método de expressão regular que divide uma string na posição do índice que corresponde à expressão regular. Usado pelo método String.prototype.split()."
Este símbolo como um atributo representa "um método que converte um objeto no valor primitivo correspondente. Usado pela operação abstrata ToPrimitive"
Este símbolo como um atributo representa "uma string que String é usada para crie a descrição de string padrão do objeto. Usado pelo método integrado Object.prototype.toString()."
Este símbolo representa um objeto como uma propriedade, e todas as propriedades do objeto e herdadas serão derivadas. do associado Excluído dos objetos com ligação de ambiente