Was ist die Motivation, Symbole auf ES6 zu bringen?

UPDATE : Kürzlich erschien ein brillanter Artikel von Mozilla . Lesen Sie es, wenn Sie neugierig sind.

Wie Sie vielleicht wissen, planen sie, einen neuen primitiven Symboltyp in ECMAScript 6 aufzunehmen (ganz zu schweigen von einigen anderen verrückten Dingen). Ich habe immer gedacht, dass der :symbolBegriff in Ruby unnötig ist; Wir könnten stattdessen leicht einfache Zeichenfolgen verwenden, wie wir es in JavaScript tun. Und jetzt beschließen sie, die Dinge in JS damit zu komplizieren.

Ich verstehe die Motivation nicht. Könnte mir jemand erklären, ob wir wirklich Symbole in JavaScript brauchen?

Die ursprüngliche Motivation für die Einführung von Symbolen in Javascript bestand darin, private Immobilien zu ermöglichen .

Leider wurden sie stark herabgestuft. Sie sind nicht mehr privat, da Sie sie beispielsweise durch Reflektion finden könnenObject.getOwnPropertySymbols oder Proxys finden können.

Sie sind jetzt als einzigartig bekannt Symbole bezeichnet und dienen nur dazu, Namenskonflikte zwischen Eigenschaften zu vermeiden. Beispielsweise kann ECMAScript selbst jetzt Erweiterungs-Hooks über bestimmte Methoden einführen, die Sie Objekten zuweisen können (z. B. um deren Iterationsprotokoll zu definieren), ohne dass das Risiko besteht, dass sie mit Benutzernamen in Konflikt geraten.

Ob dies stark genug ist, um der Sprache Symbole hinzuzufügen, ist umstritten.

Symbole garantieren keine echte Privatsphäre, können jedoch verwendet werden, um öffentliche und interne Eigenschaften von Objekten zu trennen. Nehmen wir ein Beispiel, in dem wir Symbolprivate Immobilien haben können.

Nehmen wir ein Beispiel, in dem eine Eigenschaft eines Objekts nicht privat ist.

var Pet = (function() {
  function Pet(type) {
    this.type = type;
  }
  Pet.prototype.getType = function() {
    return this.type;
  }
  return Pet;
}());

var a = new Pet('dog');
console.log(a.getType());//Output: dog
a.type = null;
//Modified outside
console.log(a.getType());//Output: null

Oben ist die PetKlasseneigenschaft typenicht privat. Um es privat zu machen, müssen wir einen Verschluss erstellen. Das folgende Beispiel zeigt, wie wir typemit einem Verschluss privat machen können .

var Pet = (function() {
  function Pet(type) {
    this.getType = function(){
      return type;
    };
  }
  return Pet;
}());

var b = new Pet('dog');
console.log(b.getType());//dog
b.type = null;
//Stays private
console.log(b.getType());//dog

Nachteil des obigen Ansatzes: Wir führen für jede Peterstellte Instanz einen zusätzlichen Abschluss ein , der die Leistung beeinträchtigen kann.

Jetzt stellen wir vor Symbol. Dies kann uns helfen, eine Immobilie privat zu machen, ohne zusätzliche unnötige Schließungen zu verwenden. Codebeispiel unten:

var Pet = (function() {
  var typeSymbol = Symbol('type');
  function Pet(type) {
    this[typeSymbol] = type;
  }
  Pet.prototype.getType = function(){
    return this[typeSymbol];
  }
  return Pet;
}());

var a = new Pet('dog');
console.log(a.getType());//Output: dog
a.type = null;
//Stays private
console.log(a.getType());//Output: dog

Symbolssind eine neue, spezielle Art von Objekt, das als eindeutiger Eigenschaftsname in Objekten verwendet werden kann. Durch die Verwendung von Symbolanstelle von string's können verschiedene Module Eigenschaften erstellen, die nicht miteinander in Konflikt stehen. Symbolskann auch privat gemacht werden, so dass niemand auf seine Eigenschaften zugreifen kann, der noch keinen direkten Zugriff auf die hat Symbol.

Symbolssind ein neues Primitiv . Genau wie die number, stringund booleanPrimitiven Symbolhaben sie eine Funktion, mit der sie erstellt werden können. SymbolsHaben Sie im Gegensatz zu den anderen Grundelementen keine wörtliche Syntax (z. B. wie stringhaben '') - die einzige Möglichkeit, sie zu erstellen, besteht darin, den SymbolKonstruktor folgendermaßen zu verwenden:

let symbol = Symbol();

In Wirklichkeit ist Symboles nur eine etwas andere Art, Eigenschaften an ein Objekt anzuhängen - Sie könnten leicht die bekannten SymbolsStandardmethoden bereitstellen , wie sie Object.prototype.hasOwnPropertyin allem, was von ihnen erbt, vorkommen Object.

Hier sind einige der Vorteile des Symbolprimitiven Typs.

Symbols Debuggabilität eingebaut haben

Symbols kann eine Beschreibung gegeben werden, die wirklich nur zum Debuggen verwendet wird, um das Leben ein wenig einfacher zu machen, wenn sie an einer Konsole protokolliert werden.

Symbolskann als ObjectSchlüssel verwendet werden

Hier wird Symboles wirklich interessant. Sie sind stark mit Objekten verflochten. Symbolkann als Schlüssel für Objekte zugewiesen werden, dh Sie können Symboleinem Objekt eine unbegrenzte Anzahl von eindeutigen Elementen zuweisen und sicherstellen, dass diese niemals mit stringSchlüsseln oder anderen eindeutigen Schlüsseln in Konflikt stehen Symbols.

Symbols kann als eindeutiger Wert verwendet werden.

Nehmen wir an , Sie eine Logging - Bibliothek, die mehrere Protokollebenen wie beinhaltet logger.levels.DEBUG, logger.levels.INFO, logger.levels.WARNund so weiter. Im ES5-Code möchten Sie diese strings (so logger.levels.DEBUG === 'debug') oder numbers ( logger.levels.DEBUG === 10) erstellen . Beide sind nicht ideal, da diese Werte keine eindeutigen Werte sind, aber Symbols! So wird logger.levelseinfach:

log.levels = {
  DEBUG: Symbol('debug'),
  INFO: Symbol('info'),
  WARN: Symbol('warn'),
};
log(log.levels.DEBUG, 'debug message');
log(log.levels.INFO, 'info message');

Lesen Sie mehr in diesem großartigen Artikel .

In diesem Beitrag geht es um die Symbol() , mit tatsächlichen Beispielen, die ich finden / machen konnte, und Fakten und Definitionen, die ich finden konnte.

TLDR;

Dies Symbol()ist der Datentyp, der mit der Veröffentlichung von ECMAScript 6 (ES6) eingeführt wurde.

Es gibt zwei merkwürdige Fakten über das Symbol.

• Der erste Datentyp und der einzige Datentyp in JavaScript, der kein Literal enthält

• Jede Variable, die mit definiert ist Symbol(), erhält eindeutigen Inhalt, ist jedoch nicht wirklich privat .

• Alle Daten haben ein eigenes Symbol, und für dieselben Daten wären die Symbole dieselben . Weitere Informationen im folgenden Absatz, ansonsten handelt es sich nicht um eine TLRD. :) :)

Wie initialisiere ich das Symbol?

1. Um eine eindeutige Kennung mit einem debuggbaren Wert zu erhalten

Sie können es entweder so machen:

var mySymbol1 = Symbol();

Oder so:

var mySymbol2 = Symbol("some text here");

Das "some text here" Zeichenfolge kann nicht aus dem Symbol extrahiert werden, sondern ist nur eine Beschreibung für Debugging-Zwecke. Es ändert in keiner Weise das Verhalten des Symbols. Obwohl Sie es könnten console.log(was fair ist, da der Wert für das Debuggen ist, um dieses Protokoll nicht mit einem anderen Protokolleintrag zu verwechseln):

console.log(mySymbol2);
// Symbol(some text here)

2. Um ein Symbol für einige Zeichenfolgendaten zu erhalten

In diesem Fall wird der Wert des Symbols tatsächlich berücksichtigt, und auf diese Weise können zwei Symbole nicht eindeutig sein.

var a1 = Symbol.for("test");
var a2 = Symbol.for("test");
console.log(a1 == a2); //true!

Nennen wir diese Symbole "Symbole vom zweiten Typ". Sie überschneiden sich nicht mit den Symbolen des "ersten Typs" (dh denjenigen, die mit definiert sindSymbol(data) in keiner Weise ).

Die nächsten beiden Absätze beziehen sich nur auf die Symbol ersten Typ .

Wie profitiere ich von der Verwendung von Symbol anstelle der älteren Datentypen?

Betrachten wir zunächst ein Objekt, einen Standarddatentyp. Wir könnten dort einige Schlüssel-Wert-Paare definieren und durch Angabe des Schlüssels auf die Werte zugreifen.

var persons = {"peter":"pan","jon":"doe"};
console.log(persons.peter);
// pan

Was ist, wenn wir zwei Personen mit dem Namen Peter haben?

Dies tun:

var persons = {"peter":"first", "peter":"pan"};

würde nicht viel Sinn machen.

Es scheint also ein Problem von zwei absolut unterschiedlichen Personen mit demselben Namen zu sein. Lassen Sie uns dann neu verweisen Symbol(). Es ist wie eine Person im wirklichen Leben - jede Person ist einzigartig , aber ihre Namen können gleich sein. Definieren wir zwei "Personen".

 var a = Symbol("peter");
 var b = Symbol("peter");

Jetzt haben wir zwei verschiedene Personen mit dem gleichen Namen. Sind unsere Personen wirklich anders? Sie sind; Sie können dies überprüfen:

 console.log(a == b);
 // false

Wie profitieren wir dort?

Wir können zwei Einträge in Ihrem Objekt für die verschiedenen Personen vornehmen, und sie können in keiner Weise verwechselt werden.

 var firstPerson = Symbol("peter");
 var secondPerson = Symbol("peter");
 var persons = {[firstPerson]:"first", [secondPerson]:"pan"};

Hinweis:
Es ist jedoch zu beachten, dass beim Stringing des Objekts JSON.stringifyalle Paare gelöscht werden, die mit einem Symbol als Schlüssel initialisiert wurden.
Beim Ausführen Object.keyswerden solche Symbol()->valuePaare auch nicht zurückgegeben.

Mit dieser Initialisierung ist es absolut unmöglich, die Einträge mit der ersten und zweiten Person zu verwechseln. Wenn Sie console.lognach ihnen rufen, werden ihre zweiten Namen korrekt ausgegeben.

 console.log(persons[a]);
 // first
 console.log(persons[b]);
 // pan

Wie unterscheidet es sich bei der Verwendung in Objekten von der Definition nicht aufzählbarer Eigenschaften?

In der Tat gab es bereits eine Möglichkeit, eine zu versteckende Eigenschaft Object.keysund eine Aufzählung zu definieren . Hier ist es:

var anObject = {};
var fruit = "apple";    

Object.defineProperty( anObject, fruit, {
    enumerable: false,
    value: "green"
});

Welchen Unterschied Symbol()bringt es dort? Der Unterschied besteht darin, dass Sie die Eigenschaft weiterhin Object.definePropertyauf die übliche Weise definieren können:

console.log(anObject[fruit]); //green
console.log(anObject["apple"]); //green
console.log(anObject.apple); //green

Und wenn mit Symbol wie im vorherigen Absatz definiert:

fruit = Symbol("apple");

Sie können den Wert nur erhalten, wenn Sie die Variable kennen, d. H.

console.log(anObject[fruit]); //green
console.log(anObject["apple"]); //undefined
console.log(anObject.apple); //undefined

"apple"Wenn Sie eine andere Eigenschaft unter dem Schlüssel definieren, wird das ältere Objekt gelöscht (und wenn es fest codiert ist, kann es einen Fehler auslösen). Also keine Äpfel mehr! Das ist schade. Unter Bezugnahme auf den vorherigen Absatz sind die Symbole eindeutig und definieren einen Schlüssel Symbol(), der ihn eindeutig macht.

Typkonvertierung und -prüfung

• Im Gegensatz zu anderen Datentypen ist es unmöglich, den Symbol()in einen anderen Datentyp zu konvertieren .

• Es ist möglich, ein Symbol basierend auf dem primitiven Datentyp durch Aufrufen zu "erstellen" Symbol(data).

• An der Überprüfung des Typs ändert sich nichts.

  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

So sehe ich das. Symbole bieten ein zusätzliches Maß an Datenschutz, indem sie verhindern, dass die Schlüssel / Eigenschaften eines Objekts durch einige gängige Methoden wie Object.keys () und JSON.stringify () verfügbar gemacht werden.

var age = Symbol();  // declared in another module perhaps?
class Person {
   constructor(n,a){
      this.name = n;
      this[age] = a;  
   }
   introduce(){
       console.log(`My name is ${this.name}. I am ${this[age]-10}.`);
   }
}
var j = new Person('Jane',45);
j.introduce();  // My name is Jane. I am 35.
console.log(JSON.stringify(j)); // {"name":"Jane"}
console.log(Object.keys(j)); // ["name"]
console.log(j[age]); // 45   (well…only if you know the age in the first place…)

Obwohl ein Objekt an sich gegeben ist, können solche Eigenschaften dennoch durch Reflection, Proxy, Object.getOwnPropertySymbols () usw. verfügbar gemacht werden. Es gibt jedoch keine natürlichen Mittel, um über einige direkte Methoden auf sie zuzugreifen, was manchmal aus OOP-Sicht ausreichend sein kann.

Ein JS-Symbol ist ein neuer primitiver Datentyp. Dies sind Token, die als eindeutige IDs dienen . Mit dem SymbolKonstruktor kann ein Symbol erstellt werden . Nehmen Sie zum Beispiel diesen Ausschnitt aus MDN:

// The symbol constructor takes one optional argument, 
// the descriptions which is used for debugging only.
// Here are two symbols with the same description
let Sym1 = Symbol("Sym");
let Sym2 = Symbol("Sym");
  
console.log(Sym1 == Sym2); // returns "false"
// Symbols are guaranteed to be unique.
// Even if we create many symbols with the same description,
// they are different values.

Es ist oft praktisch, Symbole als eindeutige Objekteigenschaftsschlüssel zu verwenden, zum Beispiel:

let obj = {};
let prop = Symbol();

obj[prop] = 123;  // the symbol prop is assigned 123
obj.prop  = 456;  // the string prop is assigned 456

console.log(obj.prop, obj[prop]); // logs 456, 123

Symbole haben zwei Hauptanwendungsfälle:

1. "Versteckte" Objekteigenschaften. Wenn wir einem Objekt, das zu einem anderen Skript oder einer Bibliothek gehört, eine Eigenschaft hinzufügen möchten, können wir ein Symbol erstellen und es als Eigenschaftsschlüssel verwenden. Eine symbolische Eigenschaft wird in nicht angezeigtfor..in , sodass sie nicht versehentlich zusammen mit anderen Eigenschaften verarbeitet wird. Es wird auch nicht direkt darauf zugegriffen, da ein anderes Skript unser Symbol nicht hat. So wird das Eigentum vor versehentlichem Gebrauch oder Überschreiben geschützt.

   So können wir etwas „verdeckt“ in Objekten verstecken, die wir brauchen, aber andere sollten es nicht sehen, indem wir symbolische Eigenschaften verwenden.

2. Es gibt viele von JavaScript verwendete Systemsymbole, auf die als zugegriffen werden kann Symbol.*. Wir können sie verwenden, um einige integrierte Verhaltensweisen zu ändern. Zum Beispiel ...... Symbol.iteratorfür iterables, Symbol.toPrimitiveum die Konvertierung von Objekt zu Primitiv einzurichten und so weiter.

Quelle