So starten Sie schnell mit VUE3.0: Erfahren Sie,
Symbol (Symbol) ist ein neuer Datentyp in ES6. Symbole sind primitive Werte (der zugrunde liegende Datentyp) und Symbolinstanzen sind einzigartig und unveränderlich. Es wird generiert, weil es zur eindeutigen Kennzeichnung und anschließenden Verwendung als Objektattribute in Nicht-String-Form dient. Es soll sicherstellen, dass Objektattribute eindeutige Bezeichner verwenden und keine Gefahr von Attributkonflikten besteht.
Verwendungssymbole müssen mit der Funktion Symbol() initialisiert werden. Da Symbole selbst primitive Typen sind, gibt der Operator „typeof“ ein Symbol für Symbole zurück.
sei sym = Symbol(); console.log(typeof sym); // symbol
Die Symbol()-Funktion kann einen zu beschreibenden String-Parameter empfangen, und dann können Sie diesen String zum Debuggen des Codes verwenden. Es ist jedoch zu beachten, dass ihre Werte nicht gleich sind, selbst wenn mehrere Symbol()-Funktionen dieselben Parameter akzeptieren.
let genericSymbol = Symbol();
let otherGenericSymbol = Symbol();
let fooSymbol = Symbol("foo");
let otherFooSymbol = Symbol("foo");
console.log(genericSymbol == otherGenericSymbol); // false
console.log(fooSymbol == otherFooSymbol); // false Wenn Sie dieselbe Symbolinstanz an mehreren Stellen im Code verwenden müssen, können Sie eine Zeichenfolge übergeben und dann Symbol.for( verwenden. )-Methode zum Erstellen eines wiederverwendbaren Symbols, ähnlich dem Singleton-Modus. Bei der ersten Verwendung von Symbol.for() wird anhand der übergebenen Parameter global gesucht, ob Symbol.for() zum Erstellen verwendet werden soll Instanz wurde übergeben, falls vorhanden, verwenden Sie sie erneut. Wenn nicht, erstellen Sie
eine neue. let fooGlobalSymbol = Symbol.for("foo"); // Ein neues Symbol erstellen let otherFooGlobalSymbol = Symbol.for("foo"); / Wiederverwenden Signiert console.log(fooGlobalSymbol === otherFooGlobalSymbol); // true Der Unterschied zwischen der von Symbol.for() erstellten Instanz und der von Symbol() erstellten Instanz: Die von Symbol() erstellte Instanz ist immer eindeutig und ändert sich nicht, da die Eingabeparameter gleich und denen anderer Instanzen gleich sind, aber die von Symbol.for() erstellten Instanzen sind gleich, wenn die Parameter gleich sind, da sie dieselbe Symbolinstanz teilen
let fooSymbol = Symbol("foo");
let otherFooSymbol = Symbol("foo");
console.log(fooSymbol == otherFooSymbol); // false
let fooGlobalSymbol = Symbol.for("foo"); // Ein neues Symbol erstellen let otherFooGlobalSymbol = Symbol.for("foo"); // Ein vorhandenes Symbol wiederverwenden console.log(fooGlobalSymbol === otherFooGlobalSymbol); Die Attribute in Objekten liegen im Allgemeinen in Form von Zeichenfolgen vor, Sie können jedoch auch Symbolinstanzen als Attribute verwenden. Der Vorteil besteht darin, dass Ihre neuen Attribute keine vorherigen Attribute überschreiben.
let s1 = Symbol ( „foo“),
s2 = Symbol("bar"),
s3 = Symbol("baz"),
s4 = Symbol("qux");
sei o = {
[s1]: „foo val“,
};
// Das funktioniert auch: o[s1] = 'foo val';
console.log(o);
// {Symbol(foo): foo val}
Object.defineProperty(o, s2, { value: "bar val" });
console.log(o);
// {Symbol(foo): foo val, Symbol(bar): bar val}
Object.defineProperties(o, {
[s3]: { Wert: "baz val" },
[s4]: { Wert: "qux val" },
});
console.log(o);
// {Symbol(foo): foo val, Symbol(bar): bar val,
// Symbol(baz): baz val, Symbol(qux): qux val} Hinweis: Wenn Sie beim Erstellen einer Symbolinstanz als Objektattribut das Symbol ändern, ohne zu Beginn eine Variable zu deklarieren, um es zu empfangen, müssen Sie es anschließend durchlaufen alle Symbole der Eigenschaft, um den entsprechenden Eigenschaftsschlüssel zu finden:
let o = {
[Symbol("foo")]: "foo val",
[Symbol("bar")]: "bar val",
};
console.log(o);
// {Symbol(foo): "foo val", Symbol(bar): "bar val"}
let barSymbol = Object.getOwnPropertySymbols(o).find(symbol => symbol.toString().match(/bar/));
console.log(barSymbol);
// Symbol(bar) ES6 führt außerdem eine Reihe häufig verwendeter integrierter Symbole (bekannte Symbole) ein, um das interne Verhalten der Sprache offenzulegen und diese neu zu schreiben oder zu simulieren Verhaltensweisen. Wenn diese Standardattribute geändert werden, können sich die endgültigen Ausführungsergebnisse einiger Vorgänge ändern. Beispielsweise verwendet eine for-of-Schleife die Eigenschaft Symbol.iterator für das relevante Objekt, sodass Sie das Verhalten von for-of beim Iterieren des Objekts ändern können, indem Sie den Wert von Symbol.iterator für das benutzerdefinierte Objekt neu definieren.
ist eigentlich ein Generator, der ein Promise zurückgibt, das im Allgemeinen mit einem for-await von
Gemäß der ECMAScript-Spezifikation stellt dieses Symbol als Attribut „eine Methode dar, die den Standard-AsyncIterator des Objekts zurückgibt.“ wait -of-Anweisung mit „. Mit anderen Worten: Dieses Symbol stellt eine Funktion dar, die die asynchrone Iterator-API implementiert.
Diese Eigenschaft ist im Funktionsprototyp definiert. Wir alle wissen, dass der Operator „Instanceof“ verwendet werden kann, um zu bestimmen, ob eine Objektinstanz zu einem bestimmten Konstruktor gehört. Das Prinzip besteht darin, dass der Instanzoperator die Funktion Symbol.hasInstance verwendet, um die Beziehungsfunktion
Foo() {} zu bestimmen
sei f = new Foo();
console.log(f Instanz von Foo); // true
Klasse Bar {}
sei b = new Bar();
console.log(b instanceof Bar); // trueWenn Sie die Eigenschaft Symbol.hasInstance einer Funktion neu definieren, können Sie veranlassen, dass die Methode „instanceof“ etwas Unerwartetes zurückgibt.
class Bar {}
Klasse Baz erweitert Bar {
static [Symbol.hasInstance]() {
return false;
}
}
sei b = new Baz();
console.log(Bar[Symbol.hasInstance](b)); // true
console.log(b Instanz von Bar); // true
console.log(Baz[Symbol.hasInstance](b)); // false
console.log(b instanceof Baz); // false Diese Eigenschaft ist im Prototyp von Array definiert
. Gemäß der ECMAScript-Spezifikation stellt dieses Symbol als Eigenschaft „einen booleschen Wert“ dar. Wenn es wahr ist, bedeutet es das Das Objekt sollte Array verwenden. „prototyp.concat() reduziert seine Array-Elemente“. Die Array.prototype.concat()-Methode in ES6 wählt basierend auf dem empfangenen Objekttyp aus, wie ein Array-ähnliches (Pseudo-Array-)Objekt in eine Array-Instanz gespleißt wird. Durch Ändern des Werts von Symbol.isConcatSpreadable kann dieses Verhalten geändert werden.
ist false: füge ein ganzes Objekt zum Array hinzu true: füge ein ganzes Paar zum Array hinzu
let initial = ["foo"];
let array = ["bar"];
console.log(array[Symbol.isConcatSpreadable]); // undefiniert
console.log(initial.concat(array)); // ['foo', 'bar']
array[Symbol.isConcatSpreadable] = false;
console.log(initial.concat(array)); // ['foo', Array(1)]
let arrayLikeObject = { length: 1, 0: "baz" };
console.log(arrayLikeObject[Symbol.isConcatSpreadable]); // undefiniert
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]); // undefiniert
console.log(initial.concat(otherObject)); // ['foo', Set(1)]
otherObject[Symbol.isConcatSpreadable] = true;
console.log(initial.concat(otherObject)); // ['foo'] Gemäß der ECMAScript-Spezifikation stellt dieses Symbol als Attribut „eine Methode dar, die den Standarditerator des Objekts zurückgibt. Wird von for- Die of-Anweisung verwendet „
Dieses Attribut gibt eine Generatorfunktion zurück und for of ruft wiederum die next()-Methode auf. Aus diesem Grund kann for of für bestimmte Objekte verwendet werden.“
Klasse Emitter {
Konstruktor(max) {
this.max = max;
this.idx = 0;
}
*[Symbol.iterator]() {
while (this.idx < this.max) {
yield this.idx++;
}
}
}
Funktion count() {
let emitter = new Emitter(5);
for (const x of emitter) {
console.log(x);
}
}
zählen();
// 0
// 1
// 2
// 3
// 4 Gemäß der ECMAScript-Spezifikation stellt dieses Symbol als Attribut „eine reguläre Ausdrucksmethode dar, die einen regulären Ausdruck verwendet, um eine Zeichenfolge abzugleichen. Wird von der String.prototype.match()-Methode verwendet.“
Die Methode String.prototype.match() wertet einen regulären Ausdruck mithilfe einer durch Symbol.match verschlüsselten Funktion aus. Wenn Sie also das Symbol.match-Attribut eines regulären Ausdrucks ändern, kann String.prototype.match() den gewünschten Wert erhalten.
console.log(RegExp.prototype[Symbol.match]);
// ƒ [Symbol.match]() { [nativer Code] }
console.log("foobar".match(/bar/));
// ["bar", Index: 3, Eingabe: "foobar", Gruppen: undefiniert]
Klasse FooMatcher {
static [Symbol.match](target) {
return target.includes("foo");
}
}
console.log("foobar".match(FooMatcher)); // true
console.log("barbaz".match(FooMatcher)); // false
Klasse StringMatcher {
Konstruktor(str) {
this.str = str;
}
[Symbol.match](Ziel) {
return target.includes(this.str);
}
}
console.log("foobar".match(new StringMatcher("foo"))); // true
console.log("barbaz".match(new StringMatcher("qux"))); // false Dieses Symbol stellt als Attribut „eine reguläre Ausdrucksmethode dar, die den passenden regulären Ausdruck im String-Index zurückgibt.“ die Formel. Wird von der Methode String.prototype.search() verwendet“
Dieses Symbol stellt als Attribut „einen Funktionswert dar, der als Konstruktor zum Erstellen abgeleiteter Objekte dient.“
Dieses Symbol stellt als Attribut „eine reguläre Ausdrucksmethode dar, die eine Zeichenfolge an der Indexposition teilt, die dem regulären Ausdruck entspricht. Wird von der String.prototype.split()-Methode verwendet.“
Dieses Symbol stellt als Attribut „eine Methode dar, die ein Objekt in den entsprechenden primitiven Wert umwandelt. Wird von der abstrakten ToPrimitive-Operation verwendet“
Dieses Symbol stellt als Attribut „eine Zeichenfolge dar, an die String gewöhnt ist.“ Erstellt die Standard-String-Beschreibung des Objekts. Wird von der integrierten Methode Object.prototype.toString() verwendet.
Dieses Symbol stellt ein Objekt als Eigenschaft dar und alle geerbten Eigenschaften des Objekts werden abgeleitet aus den zugehörigen „Ausgeschlossen von“-Objekten mit Umgebungsbindung