Comment démarrer rapidement avec VUE3.0 : découvrez
Le symbole (symbole) est un nouveau type de données dans ES6. Les symboles sont des valeurs primitives (le type de données sous-jacent) et les instances de symboles sont uniques et immuables. Il est généré car il est utilisé pour marquer de manière unique puis être utilisé comme attributs d'objet sous forme non chaîne. Il permet de garantir que les attributs d'objet utilisent des identifiants uniques et qu'il n'y a aucun risque de conflits d'attributs.
Les symboles d'utilisation de base doivent être initialisés à l'aide de la fonction Symbol(). Étant donné que les symboles eux-mêmes sont des types primitifs, l'opérateur typeof renvoie symbole pour symboles.
laissez sym = Symbole(); console.log(typeof sym); //
La fonction symbol Symbol() peut recevoir un paramètre de chaîne à décrire, puis vous pouvez utiliser cette chaîne pour déboguer le code. Mais il convient de noter que même si plusieurs fonctions Symbol() acceptent les mêmes paramètres, leurs valeurs ne sont pas égales.
laissez genericSymbol = Symbol();
laissez otherGenericSymbol = Symbol();
laissez fooSymbol = Symbol("foo");
let otherFooSymbol = Symbol("foo");
console.log(genericSymbol == otherGenericSymbol); // false
console.log(fooSymbol == otherFooSymbol); // false Si vous devez utiliser la même instance de Symbol à plusieurs endroits dans le code, vous pouvez transmettre une chaîne, puis utiliser Symbol.for(. ) pour créer un symbole réutilisable, similaire au mode singleton. Lors de la première utilisation de Symbol.for(), il recherchera globalement s'il faut utiliser Symbol.for() pour le créer en fonction des paramètres transmis. instance a été passée, si elle existe, réutilisez-la, sinon créez-en
une nouvelle let fooGlobalSymbol = Symbol.for("foo"); // Créer un nouveau symbole let otherFooGlobalSymbol = Symbol.for("foo"); / Réutilisez-le Signé console.log(fooGlobalSymbol === otherFooGlobalSymbol); // true La différence entre l'instance créée par Symbol.for() et l'instance créée par Symbol() : L'instance créée par Symbol() est toujours unique et ne changera pas car les paramètres d'entrée sont les mêmes et sont égaux aux autres instances, mais les instances créées par Symbol.for() seront égales si les paramètres sont les mêmes, car elles partageront la même instance de Symbol
let fooSymbol = Symbole("foo");
let otherFooSymbol = Symbol("foo");
console.log(fooSymbol == autreFooSymbol); // false
let fooGlobalSymbol = Symbol.for("foo"); // Créer un nouveau symbole let otherFooGlobalSymbol = Symbol.for("foo"); // Réutiliser un symbole existant console.log(fooGlobalSymbol === otherFooGlobalSymbol); Les attributs dans les objets se présentent généralement sous la forme de chaînes, mais en fait, vous pouvez également utiliser des instances de Symbol comme attributs. L'avantage est que vos nouveaux attributs n'écraseront aucun attribut précédent,
soit s1 = Symbol (. "foo"),
s2 = Symbole("barre"),
s3 = Symbole("baz"),
s4 = Symbole("qux");
soit o = {
[s1] : "foo val",
} ;
// Cela fonctionne aussi : o[s1] = 'foo val';
console.log(o);
// {Symbole(foo) : foo val}
Object.defineProperty(o, s2, { valeur : "bar val" });
console.log(o);
// {Symbole(foo) : foo val, Symbole(bar) : bar val}
Objet.defineProperties(o, {
[s3] : { valeur : "baz val" },
[s4] : { valeur : "qux val" },
});
console.log(o);
// {Symbole(foo) : foo val, Symbole(bar) : bar val,
// Symbol(baz) : baz val, Symbol(qux) : qux val} Remarque : Lors de la création d'une instance de Symbol en tant qu'attribut d'objet, si vous modifiez le symbole sans déclarer de variable pour la recevoir au début, vous devez ensuite parcourir tous les symboles de la propriété pour trouver la clé de propriété correspondante :
soit o = {
[Symbole("foo")] : "foo val",
[Symbole("bar")] : "bar val",
} ;
console.log(o);
// {Symbole(foo) : "foo val", Symbole(bar) : "bar val"}
laissez barSymbol = Object.getOwnPropertySymbols(o).find(symbol => symbol.toString().match(/bar/));
console.log(barSymbol);
// Symbole(bar) ES6 introduit également un certain nombre de symboles intégrés couramment utilisés (symboles bien connus) pour exposer le comportement interne du langage. Les développeurs peuvent directement y accéder, les réécrire ou les simuler. comportements. Si ces attributs par défaut sont modifiés, les résultats finaux d'exécution de certaines opérations peuvent être modifiés. Par exemple, une boucle for-of utilisera la propriété Symbol.iterator sur l'objet concerné, vous pouvez donc modifier le comportement de for-of lors de l'itération de l'objet en redéfinissant la valeur de Symbol.iterator sur l'objet personnalisé.
est en fait un générateur qui renvoie une promesse, généralement utilisé avec une attente de
Selon la spécification ECMAScript, ce symbole en tant qu'attribut représente "une méthode qui renvoie l'AsyncIterator par défaut de l'objet. Par for- wait -of instruction utilisant ". En d’autres termes, ce symbole représente une fonction qui implémente l’API d’itérateur asynchrone.
Cette propriété est définie sur le prototype de fonction. Nous savons tous que l'opérateur instanceof peut être utilisé pour déterminer si une instance d'objet appartient à un certain constructeur. Le principe est que l'opérateur instanceof va utiliser la fonction Symbol.hasInstance pour déterminer la relation
function Foo() {}
soit f = new Foo();
console.log (f instance de Foo); // vrai
barre de classe {}
soit b = new Bar();
console.log(b instanceof Bar); // trueSi vous redéfinissez la propriété Symbol.hasInstance d'une fonction, vous pouvez demander à la méthode instanceof de renvoyer quelque chose d'inattendu
class Bar {}
la classe Baz étend Bar {
statique [Symbol.hasInstance]() {
renvoie faux ;
}
}
soit b = new Baz();
console.log(Bar[Symbol.hasInstance](b)); // vrai
console.log (b instance de Bar); // vrai
console.log(Baz[Symbol.hasInstance](b)); // false
console.log(b instanceof Baz); // false Cette propriété est définie sur le prototype de Array
Selon la spécification ECMAScript, ce symbole en tant que propriété représente "une valeur booléenne. Si c'est vrai, cela signifie que. l'objet doit utiliser Array. prototype.concat() aplatit ses éléments de tableau". La méthode Array.prototype.concat() dans ES6 choisira comment fusionner un objet de type tableau (pseudo-tableau) en une instance de tableau en fonction du type d'objet reçu. Ainsi, modifier la valeur de Symbol.isConcatSpreadable peut modifier ce comportement.
est faux : ajoutez un objet entier au tableau true : ajoutez une paire entière au tableau
let initial = ["foo"];
let array = ["bar"];
console.log(array[Symbol.isConcatSpreadable]); // non défini
console.log(initial.concat(array)); // ['foo', 'bar']
array[Symbol.isConcatSpreadable] = false;
console.log(initial.concat(array)); // ['foo', Array(1)]
let arrayLikeObject = { longueur : 1, 0 : "baz" } ;
console.log(arrayLikeObject[Symbol.isConcatSpreadable]); // non défini
console.log(initial.concat(arrayLikeObject)); // ['foo', {...}]
arrayLikeObject[Symbol.isConcatSpreadable] = true;
console.log(initial.concat(arrayLikeObject)); // ['foo', 'baz']
let otherObject = new Set().add("qux");
console.log(otherObject[Symbol.isConcatSpreadable]); // non défini
console.log(initial.concat(autreObject)); // ['foo', Set(1)]
otherObject[Symbol.isConcatSpreadable] = true;
console.log(initial.concat(otherObject)); // ['foo'] Selon la spécification ECMAScript, ce symbole en tant qu'attribut représente "une méthode qui renvoie l'itérateur par défaut de l'objet. Utilisé par for- L'instruction of utilise "
Cet attribut renverra une fonction Générateur, et for of appellera à son tour la méthode next(). C'est pourquoi for of peut être utilisé sur certains objets.
classe Émetteur {
constructeur (max) {
ceci.max = max;
ceci.idx = 0 ;
}
*[Symbol.iterator]() {
tandis que (this.idx < this.max) {
donne ceci.idx++;
}
}
}
fonction compte() {
laissez émetteur = nouvel émetteur (5);
pour (const x de l'émetteur) {
console.log(x);
}
}
compter();
// 0
// 1
// 2
// 3
// 4 Selon la spécification ECMAScript, ce symbole en tant qu'attribut représente "une méthode d'expression régulière qui utilise une expression régulière pour faire correspondre une chaîne. Utilisé par la méthode String.prototype.match()."
La méthode String.prototype.match() évalue une expression régulière à l'aide d'une fonction saisie par Symbol.match. Ainsi, changer l'attribut Symbol.match d'une expression régulière permet à String.prototype.match() d'obtenir la valeur souhaitée
console.log(RegExp.prototype[Symbol.match]);
// ƒ [Symbol.match]() { [code natif] }
console.log("foobar".match(/bar/));
// ["bar", index : 3, entrée : "foobar", groupes : non défini]
classe FooMatcher {
statique [Symbol.match] (cible) {
return target.includes("foo");
}
}
console.log("foobar".match(FooMatcher)); // vrai
console.log("barbaz".match(FooMatcher)); // faux
classe StringMatcher {
constructeur (str) {
this.str = str;
}
[Symbol.match](cible) {
return target.includes(this.str);
}
}
console.log("foobar".match(new StringMatcher("foo")));
console.log("barbaz".match(new StringMatcher("qux"))); // false Ce symbole en tant qu'attribut représente "une méthode d'expression régulière qui renvoie l'expression régulière correspondante dans la chaîne Index de la formule. Utilisé par la méthode String.prototype.search()"
Ce symbole en tant qu'attribut représente "une valeur de fonction qui sert de constructeur pour créer des objets dérivés."
Ce symbole en tant qu'attribut représente "une méthode d'expression régulière qui divise une chaîne à la position d'index qui correspond à l'expression régulière. Utilisé par la méthode String.prototype.split()."
Ce symbole en tant qu'attribut représente "une méthode qui convertit un objet en la valeur primitive correspondante. Utilisé par l'opération abstraite ToPrimitive"
Ce symbole en tant qu'attribut représente "une chaîne que String est utilisée pour crée la description de chaîne par défaut de l'objet. Utilisé par la méthode intégrée Object.prototype.toString()."
Ce symbole représente un objet en tant que propriété, et toutes les propriétés de l'objet et héritées seront dérivées. de l'objet Exclus de l'objet associé avec la liaison d'environnement