Cet article concerne le Symbol()
, fourni avec des exemples réels que j'ai pu trouver / faire et des faits et définitions que j'ai pu trouver.
TLDR;
C'est Symbol()
le type de données, introduit avec la sortie d'ECMAScript 6 (ES6).
Il y a deux faits curieux sur le symbole.
le premier type de données et le seul type de données en JavaScript qui n'a pas de littéral
toute variable, définie avec Symbol()
, obtient un contenu unique, mais ce n'est pas vraiment privé .
toutes les données ont leur propre symbole, et pour les mêmes données, les symboles seraient les mêmes . Plus d'informations dans le paragraphe suivant, sinon ce n'est pas un TLRD; :)
Comment initialiser le symbole?
1. Pour obtenir un identifiant unique avec une valeur débogable
Vous pouvez le faire de cette façon:
var mySymbol1 = Symbol();
Ou de cette façon:
var mySymbol2 = Symbol("some text here");
le "some text here"
chaîne ne peut pas être extraite du symbole, c'est juste une description à des fins de débogage. Cela ne change en rien le comportement du symbole. Bien que vous puissiez le console.log
faire (ce qui est juste, car la valeur est pour le débogage, afin de ne pas confondre ce journal avec une autre entrée de journal):
console.log(mySymbol2);
// Symbol(some text here)
2. Pour obtenir un symbole pour certaines données de chaîne
Dans ce cas, la valeur du symbole est réellement prise en compte et de cette façon, deux symboles peuvent être non uniques.
var a1 = Symbol.for("test");
var a2 = Symbol.for("test");
console.log(a1 == a2); //true!
Appelons ces symboles des symboles de "deuxième type". Ils ne se croisent pas avec les symboles de "premier type" (c'est-à-dire ceux définis avecSymbol(data)
en aucune façon les ).
Les deux paragraphes suivants ne concernent que le symbole de premier type .
Comment puis-je bénéficier de l'utilisation de Symbol au lieu des anciens types de données?
Prenons d'abord un objet, un type de données standard. Nous pourrions y définir des paires clé-valeur et avoir accès aux valeurs en spécifiant la clé.
var persons = {"peter":"pan","jon":"doe"};
console.log(persons.peter);
// pan
Et si nous avons deux personnes du nom de Peter?
Ce faisant:
var persons = {"peter":"first", "peter":"pan"};
n'aurait pas beaucoup de sens.
Il semble donc que deux personnes absolument différentes aient le même nom. Parlons alors de nouveau Symbol()
. C'est comme une personne dans la vraie vie - toute personne est unique , mais leurs noms peuvent être égaux. Définissons deux "personnes".
var a = Symbol("peter");
var b = Symbol("peter");
Maintenant, nous avons deux personnes différentes portant le même nom. Nos personnes sont-elles vraiment différentes? Elles sont; vous pouvez vérifier ceci:
console.log(a == b);
// false
Comment en bénéficions-nous?
Nous pouvons faire deux entrées dans votre objet pour les différentes personnes et elles ne peuvent en aucun cas être confondues.
var firstPerson = Symbol("peter");
var secondPerson = Symbol("peter");
var persons = {[firstPerson]:"first", [secondPerson]:"pan"};
Remarque:
Il convient de noter, cependant, que la stringification de l'objet JSON.stringify
supprimera toutes les paires initialisées avec un symbole comme clé.
L'exécution Object.keys
ne retournera pas non plus de telles Symbol()->value
paires.
En utilisant cette initialisation, il est absolument impossible de confondre les entrées pour les première et deuxième personnes. Les appeler console.log
affichera correctement leurs seconds noms.
console.log(persons[a]);
// first
console.log(persons[b]);
// pan
Lorsqu'il est utilisé dans un objet, en quoi est-il différent de la définition d'une propriété non énumérable?
En effet, il existait déjà un moyen de définir une propriété à cacher Object.keys
et à énumérer. C'est ici:
var anObject = {};
var fruit = "apple";
Object.defineProperty( anObject, fruit, {
enumerable: false,
value: "green"
});
Quelle différence Symbol()
y apporte-t-il? La différence est que vous pouvez toujours obtenir la propriété définie avec Object.defineProperty
de la manière habituelle:
console.log(anObject[fruit]); //green
console.log(anObject["apple"]); //green
console.log(anObject.apple); //green
Et si défini avec Symbol comme dans le paragraphe précédent:
fruit = Symbol("apple");
Vous n'aurez la possibilité de recevoir sa valeur que si vous connaissez sa variable, c'est-à-dire
console.log(anObject[fruit]); //green
console.log(anObject["apple"]); //undefined
console.log(anObject.apple); //undefined
De plus, la définition d'une autre propriété sous la clé "apple"
fera en sorte que l'objet supprime l'ancienne (et s'il est codé en dur, il pourrait générer une erreur). Alors, plus de pommes! C'est dommage. Se référant au paragraphe précédent, les symboles sont uniques et définissent une clé commeSymbol()
qui la rendra unique.
Conversion de type et vérification
Contrairement à d'autres types de données, il est impossible de convertir le Symbol()
en n'importe quel autre type de données.
Il est possible de "créer" un symbole basé sur le type de données primitif en appelant Symbol(data)
.
En termes de vérification du type, rien ne change.
function isSymbol ( variable ) {
return typeof someSymbol === "symbol";
}
var a_Symbol = Symbol("hey!");
var totally_Not_A_Symbol = "hey";
console.log(isSymbol(a_Symbol)); //true
console.log(isSymbol(totally_Not_A_Symbol)); //false