Ein Zuweisungsoperator weist seinem linken Operanden einen Wert basierend auf dem Wert seines rechten Operanden zu.Der einfache Zuweisungsoperator ist gleich (=), der den Wert seines rechten Operanden seinem linken Operanden zuweist.Das heißt,x = f() ist ein Zuweisungsausdruck, der den Wert vonf() zux zuweist.

Es gibt auch zusammengesetzte Zuweisungsoperatoren, die eine Kurzschrift für die in der folgenden Tabelle aufgelisteten Operationen sind:

Wenn ein Ausdruck zu einemObjekt ausgewertet wird, dann kann die linke Seite eines Zuweisungsausdrucks Zuweisungen zu den Eigenschaften dieses Ausdrucks machen.Zum Beispiel:

const obj = {};obj.x = 3;console.log(obj.x); // Prints 3.console.log(obj); // Prints { x: 3 }.const key = "y";obj[key] = 5;console.log(obj[key]); // Prints 5.console.log(obj); // Prints { x: 3, y: 5 }.

Weitere Informationen zu Objekten finden Sie unterArbeiten mit Objekten.

Wenn ein Ausdruck nicht zu einem Objekt ausgewertet wird, dann weisen Zuweisungen zu den Eigenschaften dieses Ausdrucks nichts zu:

const val = 0;val.x = 3;console.log(val.x); // Prints undefined.console.log(val); // Prints 0.

Imstrengen Modus wirft der obige Code einen Fehler, weil man keine Eigenschaften zu Primitiven zuweisen kann.

Es ist ein Fehler, Werte zu unveränderlichen Eigenschaften zuzuwiesen oder zu Eigenschaften eines Ausdrucks ohne Eigenschaften (null oderundefined).

Für komplexere Zuweisungen ist dieDestrukturierung eine JavaScript-Ausdruckssyntax, die es ermöglicht, Daten aus Arrays oder Objekten mithilfe einer Syntax zu extrahieren, die der Konstruktion von Array- undObjektliteralien ähnelt.

Ohne Destrukturierung erfordert es mehrere Anweisungen, um Werte aus Arrays und Objekten zu extrahieren:

const foo = ["one", "two", "three"];const one = foo[0];const two = foo[1];const three = foo[2];

Mit Destrukturierung können Sie mehrere Werte in verschiedene Variablen mit einer einzigen Anweisung extrahieren:

const [one, two, three] = foo;

Im Allgemeinen werden Zuweisungen innerhalb einer Variablendeklaration verwendet (d.h. mitconst,let odervar) oder als eigenständige Anweisungen.

// Declares a variable x and initializes it to the result of f().// The result of the x = f() assignment expression is discarded.let x = f();x = g(); // Reassigns the variable x to the result of g().

Da jedoch, wie andere Ausdrücke, auch Zuweisungsausdrücke wiex = f() in einen Ergebniswert ausgewertet werden.Obwohl dieser Ergebniswert normalerweise nicht verwendet wird, kann er dann von einem anderen Ausdruck verwendet werden.

Durch das Verketten von Zuweisungen oder das Verschachteln von Zuweisungen in anderen Ausdrücken können überraschende Verhaltensweisen entstehen.Aus diesem Grundraten einige JavaScript-Stilrichtlinien das Verketten oder Verschachteln von Zuweisungen ab.Trotzdem können manchmal Verkettung und Verschachtelung von Zuweisungen auftreten, daher ist es wichtig, zu verstehen, wie sie funktionieren.

Durch das Verketten oder Verschachteln eines Zuweisungsausdrucks kann das Ergebnis selbst einer anderen Variablen zugewiesen werden.Es kann protokolliert, in ein Array-Literal oder einen Funktionsaufruf eingefügt und so weiter getan werden.

let x;const y = (x = f()); // Or equivalently: const y = x = f();console.log(y); // Logs the return value of the assignment x = f().console.log(x = f()); // Logs the return value directly.// An assignment expression can be nested in any place// where expressions are generally allowed,// such as array literals' elements or as function calls' arguments.console.log([0, x = f(), 0]);console.log(f(0, x = f(), 0));

Das Auswertungsergebnis stimmt mit dem im Ausdruck rechts vom Gleichheitszeichen in der Spalte "Bedeutung" der obigen Tabelle überein. Das bedeutet, dassx = f() zum Ergebnis vonf() ausgewertet wird,x += f() sich in die sich ergebende Summex + f() auswertet,x **= f() in die sich ergebende Potenzx ** f() und so weiter.

Im Fall von logischen Zuweisungen werdenx &&= f(),x \|\|= f() undx ??= f() der Rückgabewert der logischen Operation ohne die Zuweisung, alsox && f(),x \|\| f(), undx ?? f(), je nachdem.

Beim Verkettung dieser Ausdrücke ohne Klammern oder andere Gruppierungsoperatoren, wie Array-Literale, werden die Zuweisungsausdrückevon rechts nach links gruppiert (sie sindrechtsassoziativ), abervon links nach rechts ausgewertet.

Beachten Sie, dass bei allen anderen Zuweisungsoperatoren als= selbst die Ergebnisse immer auf den Werten der Operanden basieren,bevor die Operation durchgeführt wird.

Zum Beispiel, nehmen wir an, dass die folgenden Funktionenf undg und die Variablenx undy deklariert wurden:

function f() {  console.log("F!");  return 2;}function g() {  console.log("G!");  return 3;}let x, y;

Betrachten Sie diese drei Beispiele:

y = x = f();y = [f(), x = g()];x[f()] = g();

Auswertungsbeispiel 1

y = x = f() ist gleichwertig mity = (x = f()), weil der Zuweisungsoperator=rechtsassoziativ ist. Es wird jedoch von links nach rechts ausgewertet:

1. Der Zuweisungsausdrucky = x = f() beginnt ausgewertet zu werden.
   1. Dasy auf der linken Seite dieser Zuweisung wird in einen Verweis auf die Variableny ausgewertet.
   2. Der Zuweisungsausdruckx = f() beginnt ausgewertet zu werden.
      1. Dasx auf der linken Seite dieser Zuweisung wird in einen Verweis auf die Variablenx ausgewertet.
      2. Der Funktionsaufruff() druckt "F!" auf die Konsole und wird dann in die Zahl2 ausgewertet.
      3. Dieses2-Ergebnis vonf() wirdx zugewiesen.
   3. Der Zuweisungsausdruckx = f() hat nun die Auswertung abgeschlossen; sein Ergebnis ist der neue Wert vonx, der2 ist.
   4. Dieses2-Ergebnis wird wiederum auchy zugewiesen.
2. Der Zuweisungsausdrucky = x = f() hat nun die Auswertung abgeschlossen; sein Ergebnis ist der neue Wert vony – der zufällig2 ist.x undy werden auf2 gesetzt, und die Konsole hat "F!" gedruckt.

Auswertungsbeispiel 2

y = [f(), x = g()] wird ebenfalls von links nach rechts ausgewertet:

1. Der Zuweisungsausdrucky = [f(), x = g()] beginnt ausgewertet zu werden.
   1. Dasy auf der linken Seite dieser Zuweisung wird in einen Verweis auf die Variableny ausgewertet.
   2. Das innere Array-Literal[f(), x = g()] beginnt ausgewertet zu werden.
      1. Der Funktionsaufruff() druckt "F!" auf die Konsole und wird dann in die Zahl2 ausgewertet.
      2. Der Zuweisungsausdruckx = g() beginnt ausgewertet zu werden.
         1. Dasx auf der linken Seite dieser Zuweisung wird in einen Verweis auf die Variablenx ausgewertet.
         2. Der Funktionsaufrufg() druckt "G!" auf die Konsole und wird dann in die Zahl3 ausgewertet.
         3. Dieses3-Ergebnis vong() wirdx zugewiesen.
      3. Der Zuweisungsausdruckx = g() hat nun die Auswertung abgeschlossen; sein Ergebnis ist der neue Wert vonx, der3 ist. Dieses3-Ergebnis wird das nächste Element im inneren Array-Literal (nach dem2 vonf()).
   3. Das innere Array-Literal[f(), x = g()] hat nun die Auswertung abgeschlossen; sein Ergebnis ist ein Array mit zwei Werten:[2, 3].
   4. Dieses[2, 3]-Array wird nuny zugewiesen.
2. Der Zuweisungsausdrucky = [f(), x = g()] hat nun die Auswertung abgeschlossen; sein Ergebnis ist der neue Wert vony – der zufällig[2, 3] ist.x ist nun auf3 gesetzt,y ist nun auf[2, 3] gesetzt, und die Konsole hat zuerst "F!" und dann "G!" gedruckt.

Auswertungsbeispiel 3

x[f()] = g() wird ebenfalls von links nach rechts ausgewertet.(Dieses Beispiel setzt voraus, dassx bereits einem Objekt zugeordnet ist. Weitere Informationen zu Objekten finden Sie unterArbeiten mit Objekten.)

1. Der Zuweisungsausdruckx[f()] = g() beginnt ausgewertet zu werden.
   1. Derx[f()]-Eigenschaftszugriff auf der linken Seite dieser Zuweisung beginnt ausgewertet zu werden.
      1. Dasx in diesem Eigenschaftszugriff wird in einen Verweis auf die Variablenx ausgewertet.
      2. Dann druckt der Funktionsaufruff() "F!" auf die Konsole und wird in die Zahl2 ausgewertet.
   2. Derx[f()]-Eigenschaftszugriff auf dieser Zuweisung hat nun die Auswertung abgeschlossen; sein Ergebnis ist ein Variableneigenschaftsverweis:x[2].
   3. Dann druckt der Funktionsaufrufg() "G!" auf die Konsole und wird in die Zahl3 ausgewertet.
   4. Dieses3 wird jetztx[2] zugewiesen. (Dieser Schritt wird nur erfolgreich sein, wennx einemObjekt zugewiesen ist.)
2. Der Zuweisungsausdruckx[f()] = g() hat nun die Auswertung abgeschlossen; sein Ergebnis ist der neue Wert vonx[2] – der zufällig3 ist.x[2] ist jetzt auf3 festgelegt, und die Konsole hat zuerst "F!" und dann "G!" gedruckt.

Das Verketten von Zuweisungen oder das Verschachteln von Zuweisungen in anderen Ausdrücken kann zu überraschendem Verhalten führen. Aus diesem Grund wirddas Verketten von Zuweisungen in derselben Anweisung abgeraten.

Insbesondere das Einfügen eines Variablenketten in eineconst,let, odervar Anweisung funktioniert oftnicht. Nur die äußerste/linksste Variabel wird deklariert; andere Variablen innerhalb der Zuweisungskette werden von derconst/let/var-Anweisungnicht deklariert.

Zum Beispiel:

const z = y = x = f();

Diese Anweisung deklariert scheinbar die Variablenx,y, undz.Es deklariert jedoch tatsächlich nur die Variablez.y undx sind entweder ungültige Verweise auf nicht vorhandene Variablen (imstrengen Modus) oder, noch schlimmer, würden implizitglobale Variablen fürx undy imschluderhaften Modus erstellen.

Ein Vergleichsoperator vergleicht seine Operanden und gibt einen logischen Wert basierend darauf zurück, ob der Vergleich wahr ist.Die Operanden können numerische, Zeichenfolgen, logische oderobjektartige Werte sein.Zeichenfolgen werden basierend auf der Standardlexikographie geordnet, wobei Unicode-Werte verwendet werden.In den meisten Fällen, wenn die beiden Operanden nicht vom gleichen Typ sind, versucht JavaScript, sie in einen passenden Typ für den Vergleich zu konvertieren.Dieses Verhalten führt im Allgemeinen dazu, dass die Operanden numerisch verglichen werden.Die einzigen Ausnahmen bei der Typkonvertierung innerhalb der Vergleiche betreffen die=== und!== Operatoren, die eine strenge Gleichheits- und Ungleichheitsprüfung durchführen.Diese Operatoren versuchen nicht, die Operanden vor dem Gleichheitsprüfung in kompatible Typen zu konvertieren.Die folgende Tabelle beschreibt die Vergleichsoperatoren im Kontext dieses Beispielcodes:

const var1 = 3;const var2 = 4;

Ein arithmetischer Operator nimmt numerische Werte (entweder Literale oder Variablen) als seine Operanden und gibt einen einzelnen numerischen Wert zurück.Die Standard-Arithmetik-Operatoren sind Addition (+), Subtraktion (-), Multiplikation (*) und Division (/).Diese Operatoren funktionieren, wie sie es in den meisten anderen Programmiersprachen tun, wenn sie mit Gleitkommazahlen verwendet werden (insbesondere beachten Sie, dass die Division durch NullInfinity erzeugt). Zum Beispiel:

1 / 2; // 0.51 / 2 === 1.0 / 2.0; // this is true

Zusätzlich zu den Standard-Arithmetik-Operationen (+,-,*,/) bietet JavaScript die in der folgenden Tabelle aufgelisteten Arithmetik-Operatoren:

Ein bitweiser Operator behandelt seine Operanden als eine Menge von 32 Bits (Nullen und Einsen) und nicht als Dezimal-, Hexadezimal- oder Oktalzahlen. Zum Beispiel hat die Dezimalzahl neun eine binäre Darstellung von 1001. Bitweise Operatoren führen ihre Operationen auf solchen binären Darstellungen durch, geben aber standardmäßige JavaScript-numerische Werte zurück.

Die folgende Tabelle fasst die bitweisen Operatoren von JavaScript zusammen.

Konzepte, die die bitweisen logischen Operatoren umfassen, funktionieren wie folgt:

• Die Operanden werden in zweiunddreißig-Bit-Ganzzahlen umgewandelt und werden durch eine Reihe von Bits (Nullen und Einsen) ausgedrückt. Zahlen mit mehr als 32 Bits verlieren ihre am meisten signifikanten Bits. Zum Beispiel wird die folgende Ganzzahl mit mehr als 32 Bit in eine 32-Bit-Ganzzahl umgewandelt:

  Before: 1110 0110 1111 1010 0000 0000 0000 0110 0000 0000 0001After:                 1010 0000 0000 0000 0110 0000 0000 0001

• Jedes Bit im ersten Operanden wird mit dem entsprechenden Bit im zweiten Operanden gepaart: erstes Bit zu erstem Bit, zweites Bit zu zweitem Bit und so weiter.

• Der Operator wird auf jedes Bitpaar angewendet, und das Ergebnis wird bitweise konstruiert.

Zum Beispiel ist die binäre Darstellung von neun 1001 und die binäre Darstellung von fünfzehn ist 1111. Wenn die bitweisen Operatoren auf diese Werte angewendet werden, sind die Ergebnisse wie folgt:

Beachten Sie, dass alle 32 Bits mit dem Bitweisen NICHT Operator invertiert werden, und dass Werte mit dem am meisten signifikanten (links darstellenden) Bit, das auf 1 gesetzt ist, negative Zahlen darstellen (Zweierkomplementdarstellung).~x wird in denselben Wert ausgewertet, den-x - 1 ergibt.

Die bitweisen Verschiebeoperatoren nehmen zwei Operanden: Der erste ist eine zu verschiebende Menge, und die zweite gibt die Anzahl der Bits an, um die der erste Operand verschoben werden soll. Die Richtung des Verschiebevorgangs wird durch den verwendeten Operator gesteuert.

Verschiebeoperatoren konvertieren ihre Operanden in zweiunddreißig-Bit-Ganzzahlen und liefern ein Ergebnis entweder des TypsNumber oderBigInt: insbesondere, wenn der Typ des linken OperandenBigInt ist, geben sieBigInt zurück; andernfalls geben sieNumber zurück.

Die Verschiebeoperatoren sind in der folgenden Tabelle aufgeführt.

Logische Operatoren werden normalerweise mit Booleschen Werten verwendet; wenn sie es tun, geben sie einen Booleschen Wert zurück. Die Operatoren&&,|| und?? geben tatsächlich den Wert eines ihrer angegebenen Operanden zurück. Wenn diese Operatoren mit nicht-booleschen Werten verwendet werden, können sie einen nicht-booleschen Wert zurückgeben. Als solche sind sie treffender als "Wertauswahloperatoren" bezeichnet. Die logischen Operatoren sind in der folgenden Tabelle beschrieben.

Beispiele für Ausdrücke, die infalse konvertiert werden können, sind solche, die zunull,0,0n,NaN, der leeren Zeichenfolge ("") oderundefined ausgewertet werden.

Der folgende Code zeigt Beispiele des&&-Operators (logisches UND).

const a1 = true && true; // t && t returns trueconst a2 = true && false; // t && f returns falseconst a3 = false && true; // f && t returns falseconst a4 = false && 3 === 4; // f && f returns falseconst a5 = "Cat" && "Dog"; // t && t returns Dogconst a6 = false && "Cat"; // f && t returns falseconst a7 = "Cat" && false; // t && f returns false

Der folgende Code zeigt Beispiele des||-Operators (logisches ODER).

const o1 = true || true; // t || t returns trueconst o2 = false || true; // f || t returns trueconst o3 = true || false; // t || f returns trueconst o4 = false || 3 === 4; // f || f returns falseconst o5 = "Cat" || "Dog"; // t || t returns Catconst o6 = false || "Cat"; // f || t returns Catconst o7 = "Cat" || false; // t || f returns Cat

Der folgende Code zeigt Beispiele des??-Operators (nullish coalescing).

const n1 = null ?? 1; // 1const n2 = undefined ?? 2; // 2const n3 = false ?? 3; // falseconst n4 = 0 ?? 4; // 0

Beachten Sie, wie?? wie|| funktioniert, aber es gibt den zweiten Ausdruck nur dann zurück, wenn der erste "nullish" ist, d.h.null oderundefined.?? ist eine bessere Alternative als|| für das Setzen von Standardwerten für Werte, die möglicherweisenull oderundefined sind, insbesondere wenn Werte wie'' oder0 gültige Werte sind und der Standardwert nicht anwendbar ist.

Der folgende Code zeigt Beispiele des!-Operators (logisches NICHT).

const n1 = !true; // !t returns falseconst n2 = !false; // !f returns trueconst n3 = !"Cat"; // !t returns false

Da logische Ausdrücke von links nach rechts ausgewertet werden, werden sie auf mögliche "Kurzschluss"-Auswertung unter den folgenden Regeln getestet:

• falsy && anything wird auf den falsy Wert evaluiert.
• truthy || anything wird auf den truthy Wert evaluiert.
• nonNullish ?? anything wird auf den nicht-nullish Wert evaluiert.

Die Logikregeln garantieren, dass diese Auswertungen immer korrekt sind. Beachten Sie, dass deranything Teil der obigen Ausdrücke nicht ausgewertet wird, so dass die Nebenwirkungen des Ausführens nicht zum Tragen kommen.

Die meisten Operatoren, die zwischen Zahlen verwendet werden können, können auch zwischenBigInt Werten verwendet werden.

// BigInt additionconst a = 1n + 2n; // 3n// Division with BigInts round towards zeroconst b = 1n / 2n; // 0n// Bitwise operations with BigInts do not truncate either sideconst c = 40000000000000000n >> 2n; // 10000000000000000n

Eine Ausnahme istunsigned right shift (>>>), die für BigInt-Werte nicht definiert ist. Dies liegt daran, dass ein BigInt keine feste Breite hat und technisch gesehen keine "höchste Bit" hat.

const d = 8n >>> 2n; // TypeError: BigInts have no unsigned right shift, use >> instead

BigInts und Zahlen sind nicht austauschbar — Sie können sie nicht in Berechnungen mischen.

const a = 1n + 2; // TypeError: Cannot mix BigInt and other types

Das liegt daran, dass BigInt weder eine Teilmenge noch eine Obermenge von Zahlen ist. BigInts haben eine höhere Genauigkeit als Zahlen, wenn es um große ganze Zahlen geht, aber sie können keine Dezimalzahlen darstellen, sodass durch eine automatische Konvertierung auf beiden Seiten Genauigkeit verloren gehen könnte. Verwenden Sie eine explizite Konvertierung, um anzuzeigen, ob die Operation eine Zahl-Operation oder eine BigInt-Operation sein soll.

const a = Number(1n) + 2; // 3const b = 1n + BigInt(2); // 3n

Sie können BigInts mit Zahlen vergleichen.

const a = 1n > 2; // falseconst b = 3 > 2n; // true

Zusätzlich zu den Vergleichsoperatoren, die auf Zeichenfolgenwerte angewendet werden können, fügt der Konkatenationsoperator (+) zwei Zeichenfolgenwerte zusammen und gibt eine weitere Zeichenfolge zurück, die die Vereinigung der beiden Operanden-Zeichenfolgen ist.

Zum Beispiel,

console.log("my " + "string"); // console logs the string "my string".

Der Kurzzuweisungsoperator+= kann auch verwendet werden, um Zeichenfolgen zu concatenieren.

Zum Beispiel,

let myString = "alpha";myString += "bet"; // evaluates to "alphabet" and assigns this value to myString.

DerBedingungsoperator ist der einzige JavaScript-Operator, der drei Operanden benötigt. Der Operator kann, basierend auf einer Bedingung, einen von zwei Werten annehmen. Die Syntax lautet:

condition ? val1 : val2

Wenncondition wahr ist, hat der Operator den Wert vonval1. Andernfalls hat er den Wert vonval2. Sie können den Bedingungsoperator überall verwenden, wo Sie auch einen Standardoperator verwenden würden.

Zum Beispiel,

const status = age >= 18 ? "adult" : "minor";

Dieser Ausdruck weist der Variablenstatus den Wert "adult" zu, wennage achtzehn oder mehr ist. Andernfalls weist es den Wert "minor"status zu.

DerKomma-Operator (,) wertet beide seiner Operanden aus und gibt den Wert des letzten Operanden zurück. Dieser Operator wird in erster Linie in einerfor-Schleife verwendet, um mehrere Variablen bei jedem Durchlauf der Schleife zu aktualisieren. Es wird als schlechter Stil angesehen, ihn anderswo zu verwenden, wenn es nicht notwendig ist. Oft können und sollten zwei separate Anweisungen anstelle dessen verwendet werden.

Zum Beispiel, wenna ein zweidimensionales Array mit 10 Elementen an einer Seite ist, verwendet der folgende Code den Komma-Operator, um zwei Variablen gleichzeitig zu aktualisieren. Der Code druckt die Werte der diagonalen Elemente im Array:

const x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];const a = [x, x, x, x, x];for (let i = 0, j = 9; i <= j; i++, j--) {  //                              ^  console.log(`a[${i}][${j}]= ${a[i][j]}`);}

Ein unäres Operator ist eine Operation mit nur einem Operanden.

Derdelete Operator löscht die Eigenschaft eines Objekts. Die Syntax lautet:

delete object.property;delete object[propertyKey];delete objectName[index];

wobeiobject der Name eines Objekts ist,property eine vorhandene Eigenschaft ist undpropertyKey eine Zeichenfolge oder ein Symbol ist, das eine vorhandene Eigenschaft bezeichnet.

Wenn derdelete-Operator erfolgreich ist, entfernt er die Eigenschaft aus dem Objekt. Ein nachfolgender Zugriff darauf gibtundefined zurück. Derdelete-Operator gibttrue zurück, wenn die Operation möglich ist; er gibtfalse zurück, wenn die Operation nicht möglich ist.

delete Math.PI; // returns false (cannot delete non-configurable properties)const myObj = { h: 4 };delete myObj.h; // returns true (can delete user-defined properties)

Löschen von Array-Elementen

Da Arrays nur Objekte sind, ist es technisch möglich, Elemente aus ihnen zulöschen. Dies wird jedoch als schlechte Praxis angesehen - versuchen Sie, es zu vermeiden. Wenn Sie eine Array-Eigenschaft löschen, wird die Array-Länge nicht beeinflusst und andere Elemente werden nicht neu indiziert. Um dieses Verhalten zu erreichen, ist es viel besser, das Element durch den Wertundefined zu überschreiben. Um tatsächlich das Array zu manipulieren, verwenden Sie die verschiedenen Array-Methoden wiesplice.

Dertypeof operator gibt eine Zeichenkette zurück, die den Typ des nicht ausgewerteten Operanden angibt.operand ist die Zeichenfolge, Variable, das Schlüsselwort oder Objekt, für das der Typ zurückgegeben werden soll. Die Klammern sind optional.

Angenommen, Sie definieren die folgenden Variablen:

const myFun = () => 5 + 2;const shape = "round";const size = 1;const foo = ["Apple", "Mango", "Orange"];const today = new Date();

Dertypeof-Operator gibt die folgenden Ergebnisse für diese Variablen zurück:

typeof myFun; // returns "function"typeof shape; // returns "string"typeof size; // returns "number"typeof foo; // returns "object"typeof today; // returns "object"typeof doesntExist; // returns "undefined"

Für die Schlüsselwörtertrue undnull gibt dertypeof Operator die folgenden Ergebnisse zurück:

typeof true; // returns "boolean"typeof null; // returns "object"

Für eine Zahl oder Zeichenfolge gibt dertypeof Operator die folgenden Ergebnisse zurück:

typeof 62; // returns "number"typeof "Hello world"; // returns "string"

Für Eigenschaftswerte gibt dertypeof Operator den Typ des Wertes zurück, den die Eigenschaft enthält:

typeof document.lastModified; // returns "string"typeof window.length; // returns "number"typeof Math.LN2; // returns "number"

Für Methoden und Funktionen gibt dertypeof Operator folgende Ergebnisse zurück:

typeof blur; // returns "function"typeof parseInt; // returns "function"typeof shape.split; // returns "function"

Für vordefinierte Objekte gibt dertypeof Operator folgende Ergebnisse zurück:

typeof Date; // returns "function"typeof Function; // returns "function"typeof Math; // returns "object"typeof Option; // returns "function"typeof String; // returns "function"

Dervoid operator gibt einen Ausdruck an, der ausgewertet wird, ohne einen Wert zurückzugeben.expression ist ein JavaScript-Ausdruck, der ausgewertet werden soll. Die Klammern, die den Ausdruck umgeben, sind optional, aber es ist ein guter Stil, sie zu verwenden, um Präzedenzprobleme zu vermeiden.

Ein relationaler Operator vergleicht seine Operanden und gibt einen Booleschen Wert basierend darauf zurück, ob der Vergleich wahr ist.

Derin operator gibttrue zurück, wenn die angegebene Eigenschaft im angegebenen Objekt vorhanden ist. Die Syntax lautet:

propNameOrNumber in objectName

wobeipropNameOrNumber ein Zeichenfolgen-, numerischer oder Symbole-Ausdruck ist, der einen Eigenschaftsnamen oder Array-Index darstellt, undobjectName der Name eines Objekts ist.

Die folgenden Beispiele zeigen einige Verwendungen desin-Operators.

// Arraysconst trees = ["redwood", "bay", "cedar", "oak", "maple"];0 in trees; // returns true3 in trees; // returns true6 in trees; // returns false"bay" in trees; // returns false// (you must specify the index number, not the value at that index)"length" in trees; // returns true (length is an Array property)// built-in objects"PI" in Math; // returns trueconst myString = new String("coral");"length" in myString; // returns true// Custom objectsconst myCar = { make: "Honda", model: "Accord", year: 1998 };"make" in myCar; // returns true"model" in myCar; // returns true

Derinstanceof operator gibttrue zurück, wenn das angegebene Objekt vom angegebenen Objekttyp ist. Die Syntax lautet:

object instanceof objectType

wobeiobject das Objekt ist, das gegen denobjectType getestet werden soll, undobjectType ein Konstruktor ist, der einen Typ darstellt, wieMap oderArray.

Verwenden Sieinstanceof, wenn Sie den Typ eines Objekts zur Laufzeit bestätigen müssen. Zum Beispiel, wenn Sie Ausnahmen abfangen, können Sie je nach Art der ausgelösten Ausnahme in unterschiedliche Ausnahmebehandlungscodes wechseln.

Zum Beispiel verwendet der folgende Codeinstanceof, um zu bestimmen, obobj einMap-Objekt ist. Daobj einMap-Objekt ist, werden die Anweisungen innerhalb desif-Blocks ausgeführt.

const obj = new Map();if (obj instanceof Map) {  // statements to execute}

Alle Operatoren arbeiten schließlich an einem oder mehreren grundlegenden Ausdrücken. Diese grundlegenden Ausdrücke schließenBezeichner undLiterale ein, aber es gibt noch einige andere Arten. Sie werden unten kurz eingeführt, und ihre Semantik wird ausführlich in den jeweiligen Referenzabschnitten beschrieben.

Das Schlüsselwortthis wird normalerweise innerhalb einer Funktion verwendet. Im Allgemeinen, wenn die Funktion an ein Objekt als Methode angehängt ist, bezieht sichthis auf das Objekt, auf dem die Methode aufgerufen wird. Es handelt sich um einen Ausdruck, der zum Objekt ausgewertet wird, sodass Sie alle zuvor eingeführten Objektoperationen verwenden können.

this["propertyName"];this.propertyName;doSomething(this);

Zum Beispiel, nehmen wir an, eine Funktion wird wie folgt definiert:

function getFullName() {  return `${this.firstName} ${this.lastName}`;}

Wir können diese Funktion nun an ein Objekt anhängen, und es wird die Eigenschaften dieses Objekts verwenden, wenn es aufgerufen wird:

const person1 = {  firstName: "Chris",  lastName: "Martin",};const person2 = {  firstName: "Chester",  lastName: "Bennington",};// Attach the same functionperson1.getFullName = getFullName;person2.getFullName = getFullName;console.log(person1.getFullName()); // "Chris Martin"console.log(person2.getFullName()); // "Chester Bennington"

Der Gruppierungsoperator( ) steuert die Reihenfolge der Auswertung in Ausdrücken. Zum Beispiel können Sie Multiplikation und Division überschreiben, um zuerst Addition auszuführen.

const a = 1;const b = 2;const c = 3;// default precedencea + b * c; // 7// evaluated by default like thisa + (b * c); // 7// now overriding precedence// addition before multiplication(a + b) * c; // 9// which is equivalent toa * c + b * c; // 9

Die Syntax desEigenschaftszugriffs ruft Eigenschaftswerte von Objekten ab, entweder mit Punktnotation oder Klammernotation.

object.property;object["property"];

Der Leitfaden fürArbeiten mit Objekten geht ausführlicher auf Objekteigenschaften ein.

Dieoptionale Chaining-Syntax (?.) führt die verkettete Operation auf einem Objekt aus, wenn es definiert und nichtnull ist, ansonsten wird die Operation abgebrochen undundefined zurückgegeben. Dies ermöglicht es Ihnen, auf einen Wert zuzugreifen, der möglicherweisenull oderundefined ist, ohne einenTypeError auszulösen.

maybeObject?.property;maybeObject?.[property];maybeFunction?.();

Sie können dennew operator verwenden, um eine Instanz eines benutzerdefinierten Objekttyps oder eines der eingebauten Objekttypen zu erstellen. Verwenden Sienew wie folgt:

const objectName = new ObjectType(param1, param2, /* …, */ paramN);

Das Schlüsselwortsuper wird verwendet, um Funktionen auf dem übergeordneten Objekt aufzurufen. Es ist nützlich mitKlassen, um den übergeordneten Konstruktor aufzurufen, zum Beispiel.

super(args); // calls the parent constructor.super.functionOnParent(args);

• Zurück
• Weiter