JavaScript -Syntax

Das Syntax von JavaScript ist der Satz von Regeln, die ein korrekt strukturiertes JavaScript -Programm definieren.

Die folgenden Beispiele verwenden die Protokollfunktion des Konsolenobjekts in den meisten Browsern für Standardtextausgabe.

Das JavaScript Standardbibliothek fehlt eine offizielle Standard -Textausgabefunktion (mit Ausnahme von document.write). Da JavaScript hauptsächlich für verwendet wird Client-Seite Scripting innerhalb der modernen Internetbrowserund dass fast alle Webbrowser die Warnfunktion bieten, Alarm kann auch verwendet werden, wird aber nicht häufig verwendet.

Ursprünge

Brendan Eich Zusammenfassend die Abstammung der Syntax im ersten Absatz der Spezifikation von JavaScript 1.1 zusammengefasst^[1][2] folgendermaßen:

JavaScript leiht sich den größten Teil seiner Syntax aus Java, aber auch erbt Awk und Perl, mit einem indirekten Einfluss von Selbst in seinem Objektprototypsystem.

Grundlagen

Fallempfindlichkeit

JavaScript ist Fallempfindlichkeit. Es ist üblich, den Namen von a zu beginnen Konstrukteur mit einer aktiviert Buchstabe und der Name einer Funktion oder Variable mit einem niedrigeren Buchstaben.

Beispiel:

var a = 5; Konsole.Protokoll(a); // 5 Konsole.Protokoll(A); // wirft ein ReferenzError aus: a ist nicht definiert 

Whitespace und Semikolons

Anders als in CDie Whitespace in JavaScript -Quelle kann sich direkt auswirken Semantik. Semikolons Endaussagen in JavaScript. Durch Automatische Semikoloninsertion (ASI), werden einige Aussagen, die bei einer Neuanalyse gut geformt werden, als vollständig angesehen, als ob ein Semikolon kurz vor der Newline eingefügt wurde. Einige Behörden empfehlen, Semikolonen ausdrücklich zu terminieren, da dies die unbeabsichtigten Auswirkungen des automatischen Semikoloninsertions verringern kann.^[3]

Es gibt zwei Probleme: Fünf Token können entweder eine Erklärung beginnen oder die Erweiterung einer vollständigen Aussage sein; und fünf eingeschränkte Produktionen, bei denen Linienbrüche in bestimmten Positionen nicht zulässig sind, was möglicherweise eine falsche Parsen ergibt.^[4]

Die fünf problematischen Token sind die offene Klammern. "(", offene Klammer"[", Schrägstrich"/", Plus "+", und Minus"-". Von diesen ist die offene Klammer in der häufig Sofortiger Funktionsausdruck Muster und offene Klammer treten manchmal auf, während andere ziemlich selten sind. Das in der Spezifikation angegebene Beispiel ist:^[4]

a = b + c (d + e).Foo() // Behandelt wie: // a = b + c (d + e) ​​.foo (); 

mit dem Vorschlag, die vorhergehende Aussage mit einem Semikolon zu beenden.

Einige schlagen stattdessen die Verwendung von vor führend Semikolons in Linien beginnen mit '(' oder '[', also wird die Linie nicht versehentlich mit dem vorherigen verbunden. Dies ist als a bekannt Defensives Semikolonund ist besonders empfohlen, da der Code ansonsten bei der Umstellung eindeutig werden kann.^[4][5] Zum Beispiel:

a = b + c ; (d + e).Foo() // Behandelt wie: // a = b + c; // (d + e) ​​.foo (); 

Erste Semikolons werden manchmal auch zu Beginn von JavaScript -Bibliotheken verwendet, falls sie an eine andere Bibliothek beigefügt sind, die ein nachverfolgunges Semikolon auslässt, da dies zu einer Unklarheit der ersten Aussage führen kann.

Die fünf eingeschränkten Produktionen sind Rückkehr, Wurf, Unterbrechung, fortsetzenund nach der Inkrementierung/Abnahme. In allen Fällen behebt das Einsetzen von Semikolonen das Problem nicht, sondern macht die Parsen -Syntax klar, was den Fehler erleichtert. Rückkehr und Wurf Nehmen Sie während eines optionalen Wertes Unterbrechung und fortsetzen Nehmen Sie ein optionales Etikett. In allen Fällen lautet der Rat, den Wert oder das Etikett auf derselben Zeile wie die Anweisung zu halten. Dies zeigt sich am häufigsten in der Rückkehrerklärung, wo man ein großes Objektliteral zurückgeben könnte, das versehentlich auf einer neuen Linie platziert werden kann. Für die Nachnahme/Dekrementierung besteht potenzielle Unklarheiten bei Vorinkrement/Dekrement, und es wird erneut empfohlen, diese einfach auf derselben Linie zu halten.

Rückkehr a + b; // Gibt undefiniert zurück. Behandelt wie: //   Rückkehr; // a + b; // sollte geschrieben werden als: // A + B zurückgeben; 

Kommentare

Kommentar Syntax ist die gleiche wie in C ++, Schnell und viele andere Sprachen.

// ein kurzer Einzeilen-Kommentar /* Dies ist ein langer, mehrzeiliger Kommentar   über mein Drehbuch. Möge es eines Tages   sei großartig. */ /* Kommentare /* darf nicht verschachtelt sein* / Syntax Error */ 

Variablen

Variablen In Standard -JavaScript haben keine Typ beigefügt, also jeder Wert (jeder Wert hat einen Typ) kann in jeder Variablen gespeichert werden. Beginnen mit Es6, die 6. Version der Sprache, Variablen konnten mit deklariert werden var Für Funktionsabschottungsvariablen und Lassen oder Const die für Blockebene Variablen. Vor ES6 konnten Variablen nur mit a deklariert werden var Aussage. Werte zugewiesene Variablen zugewiesen mit deklariert mit Const kann nicht geändert werden, aber seine Eigenschaften können. Eine Variable Kennung Muss mit einem Brief beginnen, Unterstrich (_) oder Dollar Zeichen ($), während nachfolgende Zeichen auch Ziffern sein können (0-9). JavaScript ist Fall empfindlich, daher unterscheiden sich die Großbuchstaben "A" durch "Z" von den Kleinbuchstaben "A" durch "Z".

Beginnend mit JavaScript 1.5, ISO 8859-1 oder Unicode Briefe (oder \ uxxxx Unicode Escape -Sequenzen können in Kennungen verwendet werden.^[6] In bestimmten JavaScript -Implementierungen kann das AT -Zeichen (@) in einem Kennung verwendet werden. Dies widerspricht jedoch den Spezifikationen und wird in neueren Implementierungen nicht unterstützt.

Scoping und Heben

Variablen deklariert mit var sind lexikalisch abgebildet an einer Funktionsstufewährend derjenigen mit Lassen oder Const haben eine Blockebene Umfang. Da Deklarationen verarbeitet werden, bevor ein Code ausgeführt wird, kann eine Variable zugewiesen und verwendet werden, bevor sie im Code deklariert werden.^[7] Dies wird als bezeichnet als Hebenund es entspricht Variablen, die sein vorwärts erklärt oben in der Funktion oder Block.^[8]

Mit var, Lassen, und Const Aussagen, nur die Erklärung wird gehoben; Aufträge werden nicht gehoben. So a var x = 1 Die Anweisung in der Mitte der Funktion entspricht a var x Erklärungserklärung an der Spitze der Funktion und ein x = 1 Zuweisungsanweisung an diesem Punkt in der Mitte der Funktion. Dies bedeutet, dass Werte nicht zugegriffen werden können, bevor sie deklariert werden. Vorwärtsreferenz Ist nicht möglich. Mit var Der Wert einer Variablen ist nicht definiert bis es initialisiert wird. Variablen deklariert mit Lassen oder Const Es kann nicht zugegriffen werden, bis sie initialisiert wurden. Wenn Sie also zuvor solche Variablen beziehen, wird ein Fehler verursacht.

Funktionserklärungen, die eine Variable deklarieren und eine Funktion zuweisen Vorwärtsreferenz ist ebenfalls möglich: Der Ort einer Funktionserklärung in einer umschließenden Funktion ist irrelevant. Dies unterscheidet sich von einem Funktionsausdruck, der einer Variablen in a zugewiesen wird var, Lassen, oder Const Aussage.

Also zum Beispiel,

var Func = Funktion() { .. } // Deklaration wird nur gehoben Funktion Func() { .. } // Deklaration und Aufgabe werden gehoben 

Blockscoping kann erzeugt werden, indem der gesamte Block in eine Funktion eingewickelt und dann ausgeführt wird - dies wird als die bezeichnet Sofortiger Funktionsausdruck Muster - oder durch Deklarieren der Variablen mit der Lassen Stichwort.

Erklärung und Aufgabe

Variablen, die außerhalb eines Umfangs deklariert sind global. Wenn eine Variable in einem höheren Zielfernrohr deklariert wird, kann sie durch Kinderbereiche zugreifen.

Wenn JavaScript versucht beschließen Ein Kennung, es sieht im lokalen Bereich aus. Wenn diese Kennung nicht gefunden wird, schaut sie im nächsten äußeren Bereich und so weiter entlang der Bereichskette bis es die erreicht globaler Umfang wo sich globale Variablen befinden. Wenn es noch nicht gefunden wird, wird JavaScript a erheben ReferenzError Ausnahme.

Wann Zuweisung JavaScript, ein Bezeichner, durchläuft genau den gleichen Prozess, um diesen Kennung abzurufen, außer dass, wenn es nicht in der gefunden wird globaler UmfangEs wird die "Variable" im Bereich, in dem es erstellt wurde, erstellt.^[9] Infolgedessen ist eine nie deklarierte Variable global, wenn sie zugewiesen wird. Deklarieren Sie eine Variable (mit dem Schlüsselwort var) in dem globaler Umfang (d. H. Außerhalb eines Funktionskörper globales Objekt (normalerweise Fenster) wird auch eine neue globale Variable schaffen.

Beachten Sie, dass JavaScripts strikter Modus verbietet die Zuordnung einer nicht deklarierten Variablen, die die globale Namespace -Verschmutzung vermeidet.

Beispiele

Hier sind einige Beispiele für variable Deklarationen und Umfang:

var x1 = 0; // eine globale Variable, da sie in keiner Funktion befindet Lassen x2 = 0; // auch global, diesmal, weil es sich in keinem Block befindet Funktion f() {  var z = "Füchse", r = "Vögel"; // 2 Lokale Variablen  m = 'Fische'; // global, weil es vorher nirgendwo deklariert wurde  Funktion Kind() {  var r = "Affen"; // Diese Variable ist lokal und wirkt sich nicht auf die "Vögel" der übergeordneten Funktion aus.  z = "Penguine"; // Verschluss: Die untergeordnete Funktion kann auf die Variablen der übergeordneten Funktion zugreifen.  }  zwanzig = 20; // Diese Variable wird in der nächsten Zeile deklariert, aber überall in der Funktion verwendbar, noch zuvor, wie hier  var zwanzig;  Kind();  Rückkehr x1 + x2; // Wir können hier x1 und x2 verwenden, weil sie global sind } f(); Konsole.Protokoll(z); // Diese Zeile erhöht eine ReferenzError -Ausnahme, da der Wert von Z nicht mehr verfügbar ist 

zum (Lassen i = 0; i < 10; i++) Konsole.Protokoll(i); Konsole.Protokoll(i); // wirft einen ReferenzError aus: Ich bin nicht definiert 

zum (Const i = 0; i < 10; i++) Konsole.Protokoll(i); // wirft eine TypeError: Zuordnung in die konstante Variable aus zum (Const i von [1,2,3])) Konsole.Protokoll(i); // wird keine Ausnahme hervorrufen. Ich bin nicht neu zugeordnet, sondern in jeder Iteration nachgebildet Const Pi; // wirft einen SyntaxError aus: fehlender Initialisierer in der Const -Deklaration 

Primitive Datentypen

Die JavaScript -Sprache bietet sechs Primitive Datentypen:

• Nicht definiert
• Nummer
• Bigint
• Saite
• Boolesche
• Symbol

Einige der primitiven Datentypen liefern auch eine Reihe benannter Werte, die die Ausdehnung der Typgrenzen darstellen. Diese benannten Werte werden in den entsprechenden Abschnitten unten beschrieben.

Nicht definiert

Das Wert von "undefiniert" wird allen zugeordnet nicht initialisierte Variablenund wird auch zurückgegeben, wenn sie nach Objekteigenschaften prüfen, die nicht existieren. In einem booleschen Kontext wird der undefinierte Wert als falscher Wert angesehen.

HINWEIS: undefiniert gilt als echter primitiver Typ. Sofern nicht explizit konvertiert, kann sich der undefinierte Wert im Vergleich zu anderen Typen, die in einem logischen Kontext zu False bewerten, unerwartet verhalten.

var Prüfung;  // Variable deklariert, aber nicht definiert, ...  // ... auf Wert von undefiniert eingestellt var testobj = {}; Konsole.Protokoll(Prüfung);  // Testvariable existiert, aber nicht ...  // ... definiert, zeigt undefiniert an Konsole.Protokoll(testobj.MyProp);  // testobj existiert, Eigentum nicht, ...  // ... Zeigt undefiniert an Konsole.Protokoll(nicht definiert == Null);  // Unversorgter Typ während der Prüfung zeigt True an Konsole.Protokoll(nicht definiert === Null);  // Type während der Prüfung durchsetzen, zeigt false an 

Hinweis: Es gibt keine eingebaute Sprache für undefinierte Sprache. Daher (x === undefined) ist keine narrensichere Möglichkeit zu überprüfen, ob eine Variable undefiniert ist, da in Versionen vor ECMascript 5 jemand legal ist, um zu schreiben var undefined = "I'm defined now";. Ein robusterer Ansatz ist der Vergleichen der Verwendung (typeof x === 'undefined').

Funktionen wie diese werden nicht wie erwartet funktionieren:

Funktion ist nicht definiert(x) { var u; Rückkehr x === u; }  // so was... Funktion ist nicht definiert(x) { Rückkehr x === Leere 0; }  // ... oder das zweite Funktion ist nicht definiert(x) { Rückkehr (Art der x) === "nicht definiert"; } // ... oder dieser dritte 

Hier rufen isundefiniert (my_var) Erhöht a ReferenzError wenn my_var ist eine unbekannte Kennung, während typeof my_var === 'undefined' nicht.

Nummer

Zahlen sind in binärem als dargestellt IEEE-754 schwimmender Punkt Doppel. Obwohl dieses Format eine Genauigkeit von fast 16 darstellt wichtige ZifferEs kann nicht immer genau reelle Zahlen darstellen, einschließlich Brüchen.

Dies wird beim Vergleich oder Formatieren von Zahlen zu einem Problem. Zum Beispiel:

Konsole.Protokoll(0,2 + 0,1 === 0,3); // Zeigt false an Konsole.Protokoll(0,94 - 0,01);  // Zeigt 0,9299999999999999 an 

Infolgedessen eine Routine wie die tofixed () Methode sollte verwendet werden, um Zahlen zu runden, wann immer sie sind für die Ausgabe formatiert.

Zahlen können in einer dieser Notationen angegeben werden:

345;  // eine "Ganzzahl", obwohl JavaScript nur einen numerischen Typ gibt 34.5;  // eine schwimmende Punktzahl 3.45e2; // ein weiterer Schwimmpunkt, der 345 entspricht 0B1011; // eine binäre Ganzzahl gleich 11 0o377;  // eine Oktalgülle in Höhe von 255 0xff;  // eine hexadezimale Ganzzahl von 255, Ziffern, die durch das ...  // ... Buchstaben A-F können obere oder Kleinbuchstaben sein 

Es gibt auch ein numerisches Trennzeichen, _ (der Unterstrich), eingeführt in ES2021:

// Hinweis: Wikipedia -Syntax unterstützt numerische Separatoren noch nicht 1_000_000_000;  // mit großen Zahlen verwendet 1_000_000.5;  // Unterstützung mit Dezimalstellen 1_000e1_000;  // Unterstützung mit Exponenten // Unterstützung mit Binär, Oktalen und Hex 0B0000_0000_0101_1011; 0o0001_3520_0237_1327; 0xffff_Ffff_ffff_fffe; // aber Sie können sie nicht neben einem nicht-stelligen Zahlenteil oder am Anfang oder am Ende verwenden _12; // Variable ist nicht definiert (der Unterstrich macht es zu einer variablen Kennung) 12_; // Syntaxfehler (kann nicht am Ende der Zahlen liegen) 12_.0; // Syntaxfehler (ist nicht sinnvoll, ein Separator neben dem Dezimalpunkt zu setzen) 12._0; // Syntax-Fehler 12E_6; // Syntaxfehler (neben "e", ein Nicht-Digit. Ist nicht sinnvoll, um am Start einen Trennzeichen zu setzen). 1000____0000; // Syntaxfehler (neben "_", ein nicht-digit. Es ist nur 1 Separator gleichzeitig zulässig 

Die Ausdehnung +∞, −∞ und Nan (Nicht eine Zahl) des Zahlentyps kann durch zwei Programmausdrücke erhalten werden:

Unendlichkeit; // positive Unendlichkeit (negativ erhalten mit -Infinity) Nan;  // Der nicht-a-number-Wert, auch als Fehler in ...  // ... Conversions von String-to-Number 

Unendlichkeit und Nan sind Zahlen:

Art der Unendlichkeit;  // Rücksende "Nummer" zurück Art der Nan;  // Rücksende "Nummer" zurück 

Diese drei besonderen Werte entsprechen und verhalten sich als die IEEE-754 beschreibt sie.

Der Zahlenkonstruktor (als Funktion verwendet) oder ein Unary + oder -kann verwendet werden, um eine explizite numerische Konvertierung durchzuführen:

var Mystring = "123.456"; var mynumber1 = Nummer(Mystring); var mynumber2 = +Mystring; 

Wenn als Konstruktor verwendet wird, als numerisch Verpackung Objekt wird erstellt (obwohl es von geringem Nutzen ist):

Mynumericwrapper = Neu Nummer(123.456); 

Nan ist jedoch nicht gleich selbst:

Const Nan = Nan; Konsole.Protokoll(Nan == Nan);  // FALSCH Konsole.Protokoll(Nan === Nan);  // FALSCH Konsole.Protokoll(Nan ! == Nan);  // Stimmt Konsole.Protokoll(Nan ! == Nan);  // Stimmt // Sie können die ISNAN -Methoden verwenden, um nach NAN zu suchen Konsole.Protokoll(isnan("auf Nan konvertiert"));  // Stimmt Konsole.Protokoll(isnan(Nan));  // Stimmt Konsole.Protokoll(Nummer.isnan("Nicht konvertiert")); // FALSCH Konsole.Protokoll(Nummer.isnan(Nan));  // Stimmt 

Bigint

Bigints können für willkürlich große verwendet werden Ganzzahlen. Besonders ganze Zahlen größer als 2⁵³ .

Bei der Aufteilung von Bigints sind die Ergebnisse gekürzt.

Saite

A Saite In JavaScript ist eine Abfolge von Zeichen. In JavaScript können Zeichenfolgen direkt (als Literale) erstellt werden, indem die Zeichenreihe zwischen Double (") oder einzelner (') Zitate platziert werden. Solche Zeichenfolgen müssen auf eine einzelne Zeile geschrieben werden, können jedoch entkommene Neuline -Zeichen (wie \ n). Der JavaScript -Standard erlaubt dem Rückquote Charakter (`, a.k.a. Grabakzent oder Backtick) zur Zitat von Multiline Literal -Saiten, aber dies wird ab 2016 nur bei bestimmten Browsern unterstützt: Firefox und Chrome, aber nicht im Internet Explorer 11.^[10]

var Gruß = "Hallo Welt!"; var Ein anderer Greeting = "Grüße, Menschen der Erde."; 

Auf einzelne Zeichen in einer Zeichenfolge kann mit dem zugegriffen werden Charat Methode (bereitgestellt von String.Prototyp). Dies ist der bevorzugte Weg beim Zugriff auf einzelne Zeichen in einer Zeichenfolge, da es auch in nicht modernen Browsern funktioniert:

var h = Gruß.Charat(0); 

In modernen Browsern können einzelne Zeichen innerhalb einer Zeichenfolge (als Zeichenfolgen mit nur einem einzigen Zeichen) durch dieselbe Notation wie Arrays zugegriffen werden:

var h = Gruß[0]; 

JavaScript -Zeichenfolgen sind jedoch unveränderlich:

Gruß[0] = "H"; // scheitert. 

Anwenden des Gleichstellungsoperators ("==") auf zwei Zeichenfolgen gibt True zurück, wenn die Zeichenfolgen den gleichen Inhalt haben, was bedeutet, dass dieselbe Länge und die gleiche Abfolge von Zeichen enthalten (Fall ist für Alphabete signifikant). Daher:

var x = "Welt"; var vergleichen1 = ("Hallo, " +x == "Hallo Welt"); // Hier enthält vergleichen1 true. var vergleichen2 = ("Hallo, " +x == "Hallo Welt"); // Hier Compare2 enthält ...  // ... falsch seit der ...  // ... erste Charaktere ...  // ... von beiden Operanden ...  // ... sind nicht vom gleichen Fall. 

Zitate desselben Typs können nur verschachtelt werden, wenn sie nicht sind entkam.

var x = '"Hallo Welt!" er sagte.'; // Alles gut. var x = "" "Hallo, Welt!" er sagte."; //  Nicht gut. var x = "Hallo, Welt! \" Sagte er. "; // arbeitet durch Flucht "mit \" 

Das Saite Der Konstruktor erstellt ein String -Objekt (ein Objekt, das eine Zeichenfolge einpackt):

var Gruß = Neu Saite("Hallo Welt!"); 

Diese Objekte haben a Wert von Methode, die die in sie eingewickelte primitive Zeichenfolge zurückgibt:

var s = Neu Saite("Hallo !"); Art der s; // ist 'Objekt'. Art der s.Wert von(); // ist 'String'. 

Gleichheit zwischen zwei Saite Objekte verhalten sich nicht wie bei String -Primitiven:

var S1 = Neu Saite("Hallo !"); var S2 = Neu Saite("Hallo !"); S1 == S2; // ist falsch, weil sie zwei unterschiedliche Objekte sind. S1.Wert von() == S2.Wert von(); // Ist wahr. 

Boolesche

JavaScript bietet a Boolean Datentyp mit Stimmt und FALSCH Literale. Das Art der Der Bediener gibt die Zeichenfolge zurück "boolean" für diese primitive Typen. Wenn in einem logischen Kontext verwendet, 0, -0, Null, Nan, nicht definiertund die leere Zeichenfolge ("" ") bewerten as FALSCH wegen automatisch Tippen Sie Zwang. Alle anderen Werte (die ergänzen der vorherigen Liste) bewerten als Stimmt, einschließlich der Saiten "0", "FALSCH" und jedes Objekt.

Typumwandlung Typ

Automatischer Typ -Zwang durch die Gleichstellungsvergleichsbetreiber (== und ! =) kann durch Verwendung des vom Typ überprüften Vergleichsbetreiber vermieden werden (Operatoren (=== und ! ==).

Wenn die Typumwandlung erforderlich ist, konvertiert JavaScript Boolesche, Nummer, Saite, oder Objekt Operanden wie folgt:^[11]

Nummer und Zeichenfolge

Die Zeichenfolge wird in einen Zahlenwert konvertiert. JavaScript versucht, das Zeichen der Zeichenfolge numerisch in einen Zahlen -Typ -Wert zu konvertieren. Zunächst wird ein mathematischer Wert aus dem Zahlenstring -Literal abgeleitet. Als nächstes wird dieser Wert auf den Wert des nächsten Zahlen -Typs abgerundet.

Boolesche

Wenn einer der Operanden ein Boolescher ist, wird der Boolesche Operand auf 1 umgewandelt, wenn es sich Stimmt, oder zu 0, wenn es ist FALSCH.

Objekt

Wenn ein Objekt mit einer Zahl oder einer String verglichen wird, versucht JavaScript, den Standardwert für das Objekt zurückzugeben. Ein Objekt wird in einen primitiven Zeichenfolge oder einen Zahlenwert konvertiert, wobei die .Wert von() oder .ToString () Methoden des Objekts. Wenn dies fehlschlägt, wird ein Laufzeitfehler generiert.

Douglas Crockford befürwortet die Begriffe "Wahrheit" und "falsy"Um zu beschreiben, wie sich die Werte verschiedener Typen in einem logischen Kontext verhalten, insbesondere in Bezug auf Kantenfälle.^[12] Die binären logischen Operatoren haben in frühen Versionen von JavaScript einen Booleschen Wert zurückgegeben, aber jetzt geben sie stattdessen einen der Operanden zurück. Der linke Operand wird zurückgegeben, wenn er bewertet werden kann wie: FALSCH, Im Falle des Verbindung: (a && b), oder Stimmt, Im Falle des disjunktion: (A || b); Ansonsten wird der richtige Operand zurückgegeben. Der automatische Typ-Zwang durch die Vergleichsbetreiber kann sich für Fälle von gemischten booleschen und zahlem kompatiblen Operanden unterscheiden (einschließlich Zeichenfolgen, die als Zahl oder Objekte bewertet werden können, die als solchen Zeichenfolge bewertet werden können), da der Boolesche Operand als verglichen wird ein numerischer Wert. Dies kann unerwartet sein. Ein Ausdruck kann explizit auf einen boolenischen Primitiv gegossen werden, indem die logische Verdoppelung verdoppelt wird Negationsoperator: (!!), Verwendung der Boolean () Funktion oder verwenden die Bedingender Bediener: (c ? T: f).

// Automatischer Typ Zwang Konsole.Protokoll(Stimmt  ==  2 ); // false ... true → 1! == 2 ← 2 Konsole.Protokoll(FALSCH ==  2 ); // false ... false → 0! == 2 ← 2 Konsole.Protokoll(Stimmt  ==  1 ); // true .... true → 1 === 1 ← 1 Konsole.Protokoll(FALSCH ==  0 ); // true .... false → 0 === 0 ← 0 Konsole.Protokoll(Stimmt  ==  "2"); // false ... true → 1! == 2 ← "2" Konsole.Protokoll(FALSCH ==  "2"); // false ... false → 0! == 2 ← "2" Konsole.Protokoll(Stimmt  ==  "1"); // true .... true → 1 === 1 ← "1" Konsole.Protokoll(FALSCH ==  "0"); // true .... false → 0 === 0 ← "0" Konsole.Protokoll(FALSCH ==  "" " ); // true .... false → 0 === 0 ← "" Konsole.Protokoll(FALSCH ==  Nan); // falsch ... falsch → 0! == nan Konsole.Protokoll(Nan == Nan); // falsch ...... Nan entspricht nichts, einschließlich Nan. // Überprüfter Vergleich Typ (keine Konvertierung von Typen und Werten) Konsole.Protokoll(Stimmt === 1); // false ...... Datentypen stimmen nicht überein // explizite Typ -Zwang Konsole.Protokoll(Stimmt === !!2);  // true .... Datentypen und Werte stimmen überein Konsole.Protokoll(Stimmt === !!0);  // false ... Datentypen stimmen überein, aber die Werte unterscheiden sich Konsole.Protokoll( 1  ? Stimmt : FALSCH); // true .... nur ± 0 und nan sind "falsy" -Zahlen Konsole.Protokoll("0" ? Stimmt : FALSCH); // wahr ... nur die leere Zeichenfolge ist "falsy" Konsole.Protokoll(Boolesche({}));  // wahr .... alle Objekte sind "wahrheit" 

Der neue Bediener kann verwendet werden, um eine Objektwrapper für einen booleschen Primitiv zu erstellen. Allerdings die Art der Der Betreiber kehrt nicht zurück Boolesche Für die Objektverpackung kehrt es zurück Objekt. Weil alle Objekte als bewertet werden Stimmt, eine Methode wie z. .Wert von(), oder .ToString (), muss verwendet werden, um den verpackten Wert abzurufen. Für einen expliziten Zwang zum Booleschen Typ empfiehlt Mozilla, dass die Boolean () Funktion (ohne Neu) Vorliebe für das Boolesche Objekt.

var b = Neu Boolesche(FALSCH);  // Objekt falsch {} var t = Boolesche(b);  // boolean wahr var f = Boolesche(b.Wert von()); // boolean falsch var n = Neu Boolesche(b);  // Nicht empfohlen n = Neu Boolesche(b.Wert von()); // bevorzugt wenn (0 || -0 || "" " || Null || nicht definiert || b.Wert von() || !Neu Boolesche() || !t) {  Konsole.Protokoll("Niemals das"); } anders wenn ([] && {} && b && Art der b === "Objekt" && b.tostring() === "FALSCH") {  Konsole.Protokoll("Immer das"); } 

Symbol

Neu in ECMascript6. EIN Symbol ist eine einzigartige und unveränderliche Kennung.

Beispiel:

var x = Symbol(1); var y = Symbol(1); x === y; // => falsch var Symbolobjekt = {}; var NormalObject = {}; // Da x und y einzigartig sind, // Sie können als einzigartige Schlüssel in einem Objekt verwendet werden Symbolobjekt[x] = 1; Symbolobjekt[y] = 2; Symbolobjekt[x]; // => 1 Symbolobjekt[y]; // => 2 // im Vergleich zu normalen numerischen Schlüssel NormalObject[1] = 1; NormalObject[1] = 2; // überschreibt den Wert von 1 NormalObject[1]; // => 2 // Ändern des Wertes von X ändert nicht den im Objekt gespeicherten Schlüssel x = Symbol(3); Symbolobjekt[x]; // => undefiniert // Das Ändern von x zurück erstellt einfach ein anderes einzigartiges Symbol x = Symbol(1); Symbolobjekt[x]; // => undefiniert 

Es gibt auch bekannte Symbole.

Eines davon ist Symbol.iterator; Wenn etwas impliziert Symbol.iterator, es ist iterbar:

Lassen x = [1, 2, 3, 4]; // x ist ein Array x[Symbol.Iterator] === Array.Prototyp[Symbol.Iterator]; // und Arrays sind iterbar Const Xiterator = x[Symbol.Iterator] (); // Die Funktion [symbol.iterator] sollte einen Iterator für x liefern Xiterator.nächste(); // {Wert: 1, fertig: false} Xiterator.nächste(); // {Wert: 2, fertig: false} Xiterator.nächste(); // {Wert: 3, fertig: false} Xiterator.nächste(); // {Wert: 4, fertig: false} Xiterator.nächste(); // {value: undefiniert, fertig: true} Xiterator.nächste(); // {value: undefiniert, fertig: true} // für..of Loops iterieren automatisch Werte zum (Const Wert von x) {  Konsole.Protokoll(Wert); // 1 2 3 4 } // Sets sind auch iterbar: [Symbol.Iterator] in Satz.Prototyp; // Stimmt zum (Const Wert von Neu Satz['Apfel', 'Orange']))) {  Konsole.Protokoll(Wert); // "Apfel Orange" } 

Einheimische Objekte

Die JavaScript -Sprache bietet eine Handvoll Eingeborener Objekte. Native Objekte von JavaScript werden als Teil der JavaScript -Spezifikation betrachtet. Ungeachtet der JavaScript -Umgebung sollte immer dieser Satz von Objekten verfügbar sein.

Array

Ein Array ist ein aus dem prototypisiertes JavaScript -Objekt Array Der Konstruktor wurde speziell für die Speicherung von Datenwerten entwickelt, die von Ganzzahlschlüssel indiziert sind. Arrays werden im Gegensatz zum grundlegenden Objekttyp mit Methoden und Eigenschaften prototypisiert, um dem Programmierer bei Routineaufgaben zu helfen (zum Beispiel, beitreten, Scheibe, und drücken).

Wie in der C-Familie verwenden Arrays ein nullbasiertes Indexierungsschema: einen Wert, der mithilfe der in ein leeres Array eingefügt wird drücken Die Methode nimmt den 0. Index des Arrays ein.

var myarray = [];  // Zeigen Sie die Variable myarray auf ein neu ...  // ... erstellt, leeres Array myarray.drücken("Hallo Welt"); // Füllen Sie den nächsten leeren Index in diesem Fall 0 aus Konsole.Protokoll(myarray[0]);  // entspricht Console.log ("Hallo Welt"); 

Arrays haben a Länge Eigenschaft, die garantiert immer größer ist als der größte Ganzzahl -Index, der im Array verwendet wird. Es wird automatisch aktualisiert, wenn man eine Eigenschaft mit einem noch größeren Index erstellt. Schreiben einer kleineren Zahl an die Länge Eigenschaft wird größere Indizes entfernen.

Elemente von ArrayS kann mit der Note für die Normalbeschaffung der Objekteigenschaften zugegriffen werden:

myarray[1];  // der 2. Artikel in MyArray myarray["1"]; 

Die oben genannten zwei sind gleichwertig. Es ist nicht möglich, die "Punkt" -Notation oder Zeichenfolgen mit alternativen Darstellungen der Zahl zu verwenden:

myarray.1;  // Syntax-Fehler myarray["01"]; // Nicht das gleiche wie Myarray [1] 

Erklärung eines Arrays kann entweder eine verwenden Array wörtlich oder der Array Konstrukteur:

Lassen myarray; // Array -Literale myarray = [1, 2]; // Länge von 2 myarray = [1, 2,]; // gleiches Array - Sie können am Ende auch ein zusätzliches Komma haben // Es ist auch möglich, keine Teile des Arrays auszufüllen myarray = [0, 1, /* Loch */, /* Loch */, 4, 5]; // Länge von 6 myarray = [0, 1, /* Loch */, /* Loch */, 4, 5,]; // gleiches Array myarray = [0, 1, /* Loch */, /* Loch */, 4, 5, /* Loch */,]; // Länge von 7 // mit dem Konstruktor myarray = Neu Array(0, 1, 2, 3, 4, 5); // Länge von 6 myarray = Neu Array(365);  // ein leeres Array mit Länge 365 

Arrays werden so implementiert, dass nur die definierten Elemente Speicher verwenden. sie sind "Spärliche Arrays". Einstellung myArray[10] = 'someThing' und myArray[57] = 'somethingOther' Nutzt nur Platz für diese beiden Elemente, genau wie jedes andere Objekt. Das Länge des Arrays wird weiterhin als 58 gemeldet.₂.

Man kann die Objekterklärung wörtlich verwenden, um Objekte zu erstellen, die sich ähnlich assoziativen Arrays in anderen Sprachen verhalten:

Hund = {Farbe: "braun", Größe: "groß"}; Hund["Farbe"]; // führt zu "Brown" Hund.Farbe;  // führt auch zu "Brown". 

Man kann die Literale von Objekt- und Array -Erklärung verwenden, um schnell assoziative, mehrdimensionale oder beides zu erstellen. (Technisch gesehen unterstützt JavaScript keine mehrdimensionalen Arrays, aber man kann sie mit Arrays-of-Arrays nachahmen.)

Katzen = [{{{Farbe: "braun", Größe: "groß"},  {Farbe: "Schwarz", Größe: "klein"}]; Katzen[0]["Größe"];  // führt zu "groß" Hunde = {Rover: {Farbe: "braun", Größe: "groß"},  Stelle: {Farbe: "Schwarz", Größe: "klein"}}; Hunde["Stelle"]["Größe"]; // führt zu "klein" Hunde.Rover.Farbe;  // führt zu "Brown" 

Datum

A Datum Objekt speichert eine signierte Millisekundenzahl mit Null, die 1970-01-01 00:00:00 UT und einen Bereich von ± 10 darstellt⁸ Tage. Es gibt verschiedene Möglichkeiten, Argumente vorzulegen Datum Konstrukteur. Beachten Sie, dass Monate auf Null basieren.

Neu Datum();  // Erstellen Sie eine neue Datumsinstanz, die die aktuelle Zeit/Datum darstellt. Neu Datum(2010, 2, 1);  // Erstellen Sie eine neue Datumsinstanz für 2010-mar-01 00:00:00 Neu Datum(2010, 2, 1, 14, 25, 30); // Erstellen Sie eine neue Datumsinstanz, die 2010-mar-01 14:25:30 darstellt Neu Datum("2010-3-1 14:25:30");  // Erstellen Sie eine neue Datumsinstanz aus einer Zeichenfolge. 

Methoden zum Extrahieren von Feldern sowie nützlich tostring:

var d = Neu Datum(2010, 2, 1, 14, 25, 30); // 2010-mar-01 14:25:30; // zeigt '2010-3-1 14:25:30' an: Konsole.Protokoll(d.Getreide() + '-' ' + (d.GetMonth() + 1) + '-' ' + d.Verabredung bekommen() + '' '  + d.Gethours() + ':' + d.Getminutes() + ':' + d.Getseconds()); // Eingebautes TOString gibt so etwas wie 'Mo 01.010 2010 14:25:30 GMT-0500 (EST)' zurück: Konsole.Protokoll(d); 

Fehler

Benutzerdefinierte Fehlermeldungen können mit dem erstellt werden Fehler Klasse:

Wurf Neu Fehler("Etwas ist schief gelaufen."); 

Diese können durch den Versuch gefangen werden ... fangen ... schließlich blockiert schließlich wie im Abschnitt über beschrieben Ausnahmebehandlung.

Mathematik

Das Mathematik Das Objekt enthält verschiedene Mathematikkonstanten (zum Beispiel, zum Beispiel, π) und Funktionen (zum Beispiel Cosinus). (Notiere dass der Mathematik Objekt hat im Gegensatz zu keinen Konstruktor Array oder Datum. Alle seine Methoden sind "statisch", dh "Klasse" -Methoden.) Alle trigonometrischen Funktionen verwenden Winkel, die in ausgedrückt werden Radians, nicht Grad oder Absolventen.

Methoden des Mathematikobjekts

Beispiel	Rückgabewert auf 5 Ziffern gerundet	Beschreibung
Math.abs (-2.3)	2.3	Absoluter Wert
Math.acos (math.sqrt1_2)	0,78540rad = 45 °	Arccosine
Math.asin (math.sqrt1_2)	0,78540 rad = 45 °	Bogensieg
Math.atan (1)	0,78540 rad = 45 °	Halbkreis Arctangent (${\ displayStyle -\ pi /2}$ zu ${\ displayStyle +\ pi /2}$))
Math.atan2 (-3.7, -3.7)	–2,3562 rad = –135 °	Ganzkreis Arctangent (${\ displayStyle -\ pi}$ zu ${\ displayStyle +\ pi}$))
Math.ceil (1.1)	2	Decke: runden bis zur kleinsten Ganzzahl ≥ Argument
Math.cos (math.pi/4)	0,70711	Kosinus
Math.exp(1)	2.7183	Exponentialfunktion: e auf diese Macht auferlegt
Math.floor (1.9)	1	Boden: rund bis zur größten Ganzzahl ≤ Argument
Math.log (math.e)	1	Natürlicher Logarithmus, Basis e
Math.max (1, -2)	1	Maximal: (x> y)? x: y
Math.min (1, -2)	–2	Minimum: (x <y)? x: y
Math.pow (-3, 2)	9	Exponentiation (zur Kraft von):): Math.pow (x, y) gibt xy
Math.random ()	z.B. 0,17068	Pseudorandom Nummer zwischen 0 (inklusiv) und 1 (exklusiv)
Math.round (1,5)	2	Runde zur nächsten Ganzzahl; Halbfraktionen sind zusammengefasst (z. B. 1,5 Runden bis 2)
Math.sin (math.pi/4)	0,70711	Sinus
Math.sqrt (49)	7	Quadratwurzel
Math.tan (math.pi/4)	1	Tangente

Regulären Ausdruck

/Ausdruck/.Prüfung(Saite);  // gibt boolean zurück "String".Suche(/Ausdruck/); // Die Positionsnummer zurückgibt "String".ersetzen(/Ausdruck/, Ersatz); // Hier sind einige Beispiele wenn (/Tom/.Prüfung("Mein Name ist Tom")) Konsole.Protokoll("Hallo Tom!"); Konsole.Protokoll("Mein Name ist Tom".Suche(/Tom/));  // == 11 (Buchstaben vor Tom) Konsole.Protokoll("Mein Name ist Tom".ersetzen(/Tom/, "John")); // == "Mein Name ist John" 

Charakterklassen

// \ d - Ziffern // \ d - Nichtstellig // \ s - Raum // \ s - Nichtraum // \ w - Wort char // \ w - Nicht Wort // [ ] - einer von // [^] - Ein nicht von //  -  - Angebot wenn (/\d/.Prüfung('0'))  Konsole.Protokoll('Ziffer'); wenn (/[0-9]/.Prüfung('6'))  Konsole.Protokoll('Ziffer'); wenn (/[13579]/.Prüfung('1'))  Konsole.Protokoll('Ungerade Zahl'); wenn (/\ S \ s \ s \ s \ s \ s \ s//.Prüfung('Mein Name')) Konsole.Protokoll("Format ok"); wenn (/\ w \ w \ w/.Prüfung("Tom"))  Konsole.Protokoll('Hallo Tom'); wenn (/[a-za-z]//.Prüfung('B'))  Konsole.Protokoll('Brief'); 

Charakteranpassung

// a ... z a ... z 0 ... 9 - alphanumerisch // \ u0000 ... \ Uffff - Unicode Hexadezimal // \ x00 ... \ xff - ASCII -Hexadezimal // \ t - Registerkarte // \ n - neue Zeile // \ r - cr //. - Jeder Charakter // | - ODER wenn (/T.m/.Prüfung("Tom")) Konsole.Protokoll ("Hallo Tom, Tam oder Tim"); wenn (/A | b/.Prüfung("EIN"))  Konsole.Protokoll ('A oder B'); 

Repeater

//? - 0 oder 1 Übereinstimmung // * - 0 oder mehr // + - 1 oder mehr // {n} - genau n // {n,} - n oder mehr // {0, n} - n oder weniger // {n, m} - Bereich n bis m wenn (/ABC/.Prüfung("AC"))  Konsole.Protokoll("OK"); // Match: "AC", "ABC" wenn (/ABC/.Prüfung("AC"))  Konsole.Protokoll("OK"); // Match: "AC", "ABC", "ABBC", "ABBBC" usw. wenn (/ab+c/.Prüfung("ABC"))  Konsole.Protokoll("OK"); // Match: "ABC", "ABBC", "ABBBC" usw. wenn (/ab {3} c/.Prüfung("ABBBC"))  Konsole.Protokoll("OK"); // Match: "ABBBC" wenn (/ab {3,} c/.Prüfung("ABBBC")) Konsole.Protokoll("OK"); // Übereinstimmung: "ABBBC", "ABBBBC", "ABBBBBBC" usw. wenn (/ab {1,3} c/.Prüfung("ABC"))  Konsole.Protokoll("OK"); // Match: "ABC", "ABBC", "ABBBC" 

Anker

// ^ - String beginnt mit // $ - String endet mit wenn (/^My//.Prüfung("Mein Name ist Tom"))  Konsole.Protokoll ("Hi!"); wenn (/Tom $/.Prüfung("Mein Name ist Tom"))  Konsole.Protokoll ("Hallo Tom!"); 

Unterexpression

// () - Gruppieren Zeichen wenn (/Wasser (Mark)?/.Prüfung("Wasserzeichen")) Konsole.Protokoll("Hier ist Wasser!"); // Match: "Wasser", "Wasserzeichen", wenn (/(Tom) | (John)///.Prüfung("John"))  Konsole.Protokoll("Hallo Tom oder John!"); 

Flaggen

// /g - global ///i - Ignorieren Sie das obere/untere Gehäuse // /m - Übereinstimmungen in mehreren Zeilen überspannen lassen Konsole.Protokoll("Hallo Tom!".ersetzen(/Tom/i, "John"));  // == "Hallo John!" Konsole.Protokoll("Ratatam".ersetzen(/ta//, "Tu"));  // == "Ratutam" Konsole.Protokoll("Ratatam".ersetzen(/Schild, "Tu"));  // == "Ratutum" 

Erweiterte Methoden

my_array = my_string.Teilt(my_delimiter); // Beispiel my_array = "Hund, Katze, Kuh".Teilt(",");  // my_array == ["Hund", "Katze", "Kuh"]; my_array = my_string.passen(my_expression); // Beispiel my_array = "Wir beginnen um 11:30, 12:15 und 16:45".passen(/\ d \ d: \ d \ d/g); // my_array == ["11:30", "12:15", "16:45"]; 

Gruppen erfassen

var Myre = /(\ d {4}-\ d {2}-\ d {2}) (\ d {2}: \ d {2}: \ d {2})//; var Ergebnisse = Myre.Geschäftsführer("Datum und Uhrzeit sind 2009-09-08 09:37:08."); wenn (Ergebnisse) {  Konsole.Protokoll("Matched:" + Ergebnisse[0]); // Ganzes Match  var meine Verabredung = Ergebnisse[1]; // First Group == "2009-09-08"  var meine Zeit = Ergebnisse[2]; // zweite Gruppe == "09:37:08"  Konsole.Protokoll("Es ist " + meine Zeit + " an " + meine Verabredung); } anders Konsole.Protokoll("Ich habe kein gültiges Datum gefunden!"); 

Funktion

Jede Funktion in JavaScript ist eine Instanz der Funktion Konstrukteur:

// x, y ist das Argument. 'return x + y' ist der Funktionskörper, der die letzte in der Argumentliste ist. var hinzufügen = Neu Funktion('x', "y", 'Return X + Y'); hinzufügen(1, 2); // => 3 

Die obige Funktion hinzufügen kann auch unter Verwendung eines Funktionsausdrucks definiert werden:

var hinzufügen = Funktion(x, y) {  Rückkehr x + y; }; hinzufügen(1, 2); // => 3 

In ES6 wurde die Pfeilfunktionssyntax hinzugefügt, die Funktionen ermöglicht, die einen Wert zurückgeben. Sie behalten auch die Dies des globalen Objekts anstatt es zu erben, wo es genannt wurde / was es aufgerufen wurde, anders als die function () {} Ausdruck.

var hinzufügen = (x, y) => {Rückkehr x + y;}; // Werte können auch implizit zurückgegeben werden (d. H. Es ist keine Rückgabeanweisung erforderlich) var Addimplicit = (x, y) => x + y; hinzufügen(1, 2); // => 3 Addimplicit(1, 2) // => 3 

Für Funktionen, die gehoben werden müssen, gibt es einen separaten Ausdruck:

Funktion hinzufügen(x, y) {  Rückkehr x + y; } hinzufügen(1, 2); // => 3 

Mit Heben können Sie die Funktion verwenden, bevor sie "deklariert" wird:

hinzufügen(1, 2); // => 3, kein ReferenzError Funktion hinzufügen(x, y) {  Rückkehr x + y; } 

Eine Funktionsinstanz hat Eigenschaften und Methoden.

Funktion subtrahieren(x, y) {  Rückkehr x - y; } Konsole.Protokoll(subtrahieren.Länge); // => 2, Arity der Funktion (Anzahl der Argumente) Konsole.Protokoll(subtrahieren.tostring()); /* "Funktion subtrahieren (x, y) {   Rückgabe x - y; } " */ 

Betreiber

Der '+' -Preiber ist überladen: Es wird zur String -Verkettung und zur arithmetischen Addition verwendet. Dies kann Probleme verursachen, wenn Sie versehentlich Strings und Zahlen mischen. Als unärer Operator kann es eine numerische Zeichenfolge in eine Zahl konvertieren.

// 2 Saiten verkettet Konsole.Protokoll('Er' + 'llo' '); // Zeigt Hallo an // zwei Zahlen hinzufügen Konsole.Protokoll(2 + 6);  // Zeigt 8 an // Hinzufügen einer Zahl und einer Zeichenfolge führt zu einer Verkettung (von links nach rechts) Konsole.Protokoll(2 + '2');  // Zeigt 22 an Konsole.Protokoll("$" + 3 + 4);  // Zeigt 34 ​​US -Dollar an, aber 7 US -Dollar wurden möglicherweise erwartet Konsole.Protokoll("$" + (3 + 4)); // Zeigt $ 7 an Konsole.Protokoll(3 + 4 + '7'); // Zeigt 77 an, Nummern bleiben Nummern, bis eine Zeichenfolge hinzugefügt wird // Konvertieren Sie eine Zeichenfolge mit dem Unary Plus in eine Zahl Konsole.Protokoll(+'2' === 2); // Zeigt true an Konsole.Protokoll(+'Hallo'); // Zeigt Nan an 

In ähnlicher Weise wird der '*' -Operator überlastet: Er kann eine Zeichenfolge in eine Zahl umwandeln.

Konsole.Protokoll(2 + '6'*1);  // Zeigt 8 an Konsole.Protokoll(3*'7'); // 21 Konsole.Protokoll('3'*'7'); // 21 Konsole.Protokoll('hallo'*'Welt'); // Zeigt Nan an 

Arithmetik

JavaScript unterstützt Folgendes Binäre arithmetische Operatoren:

JavaScript unterstützt Folgendes unäre arithmetische Operatoren:

var x = 1; Konsole.Protokoll(++x); // x wird 2; Zeigt 2 an Konsole.Protokoll(x++); // Zeigt 2 an; x wird 3 Konsole.Protokoll(x);  // x ist 3; Zeigt 3 an Konsole.Protokoll(x--); // Zeigt 3 an; x wird 2 Konsole.Protokoll(x);  // Zeigt 2 an; x ist 2 Konsole.Protokoll(--x); // x wird 1; Zeigt 1 an 

Der Modulo -Bediener zeigt den Rest nach der Aufteilung durch den Modul an. Wenn negative Zahlen beteiligt sind, hängt der zurückgegebene Wert vom Operanden ab.

var x = 17; Konsole.Protokoll(x%5); // Zeigt 2 an Konsole.Protokoll(x%6); // Zeigt 5 an Konsole.Protokoll(-x%5); // Zeigt -2 an Konsole.Protokoll(-x%-5); // Zeigt -2 an Konsole.Protokoll(x%-5); // Zeigt 2 an 

Um immer eine nicht negative Zahl zurückzugeben, nutzen Sie den Modul neu und wenden Sie den Modulo-Operator erneut an:

var x = 17; Konsole.Protokoll((-x%5+5)%5); // Zeigt 3 an 

Sie könnten es auch tun:

var x = 17; Konsole.Protokoll(Mathematik.Abs(-x%5)); // auch 3 

Abtretung

Abtretung von primitive Typen

var x = 9; x += 1;  Konsole.Protokoll(x); // Anzeigen: 10 x *= 30; Konsole.Protokoll(x); // Anzeigen: 300 x /= 6; Konsole.Protokoll(x); // Anzeigen: 50 x -= 3; Konsole.Protokoll(x); // Anzeigen: 47 x %= 7; Konsole.Protokoll(x); // Anzeigen: 5 

Zuordnung von Objekttypen

/**  * JavaScript -Objekte lernen ...  */ var Objekt_1 = {a: 1};		// Referenz des neu erstellten Objekts zu Object_1 zuweisen var Objekt_2 = {a: 0}; var Objekt_3 = Objekt_2;	// Object_3 verweist auf dasselbe Objekt wie Object_2 	  Objekt_3.a = 2; Botschaft();	        	// Zeigt 1 2 2 an 	  Objekt_2 = Objekt_1;		// Object_2 verweist nun dasselbe Objekt wie Object_1 	        	 // Object_3 bezieht sich weiter Botschaft();		 // Zeigt 1 1 2 an 	  Objekt_2.a = 7;  	 // modifiziert Object_1 Botschaft();		 // Zeigt 7 7 2 an Objekt_3.a = 5;  // Object_3 ändert Object_2 nicht Botschaft();	 // zeigt 7 7 5 an Objekt_3 = Objekt_2;	 Objekt_3.a=4;  // Object_3 ändert Object_1 und Object_2 Botschaft();  // zeigt 4 4 4 an /**  * Druckt die Meldung console.log  */ Funktion Botschaft() { 	Konsole.Protokoll(Objekt_1.a + "" " + Objekt_2.a + "" " + Objekt_3.a); } 

Zerstörungsaufgabe

In Mozillas JavaScript ermöglicht die Destructuring -Zuordnung seit Version 1.7 die Zuordnung von Teilen von Datenstrukturen zu mehreren Variablen gleichzeitig. Die linke Seite einer Zuordnung ist ein Muster, das einem willkürlich verschachtelten Objekt/Array-Literal ähnelt, das L-Lvalues ​​an seinen Blättern enthält, die die Unterstrukturen des zugewiesenen Wertes empfangen sollen.

var a, b, c, d, e; [a, b, c] = [3, 4, 5]; Konsole.Protokoll(a + ',' + b + ',' + c); // Anzeigen: 3,4,5 e = {Foo: 5, Bar: 6, Baz: ["Baz", 'Inhalt']}; var arr = []; ({{Baz: [arr[0], arr[3]], Foo: a, Bar: b}) = e; Konsole.Protokoll(a + ',' + b + ',' + arr);	// Anzeigen: 5,6, Baz ,,, Inhalt [a, b] = [b, a];		// Inhalt von A und B tauschen Konsole.Protokoll(a + ',' + b);		// Anzeigen: 6,5 [a, b, c] = [3, 4, 5]; // Permutationen [a, b, c] = [b, c, a]; Konsole.Protokoll(a + ',' + b + ',' + c); // Anzeigen: 4,5,3 

Ausbreitung/Rastoperator

Der ECMAScript 2015 -Standard führt das "vor"..."Operator, für die verwandten Konzepte von" Spread Syntax "^[13] und "Ruheparameter"^[14]

Syntax verbreiten Bietet eine andere Möglichkeit, Arrays zu zerstören. Es zeigt an, dass die Elemente in einem angegebenen Array als Parameter in einem Funktionsaufruf oder die Elemente in einem Array -Literal verwendet werden sollten.

Mit anderen Worten, "..."transformiert"[... foo]" hinein "[Foo [0], Foo [1], Foo [2]]", und "this.bar (... foo);" hinein "this.bar (foo [0], foo [1], foo [2]);".

var a = [1, 2, 3, 4];  // Es kann im selben Ausdruck mehrfach verwendet werden var b = [...a, ...a]; // B = [1, 2, 3, 4, 1, 2, 3, 4];  // Es kann mit nicht verbreiteten Gegenständen kombiniert werden. var c = [5, 6, ...a, 7, 9]; // c = [5, 6, 1, 2, 3, 4, 7, 9];  // zum Vergleich ohne den Spread Operator  // Erstellt ein verschachteltes Array. var d = [a, a]; // d = [[1, 2, 3, 4], [1, 2, 3, 4]]  // Es funktioniert gleich mit Funktionsaufrufen Funktion Foo(arg1, arg2, arg3) {   Konsole.Protokoll(arg1 + ':' + arg2 + ':' + arg3); }  // Sie können es auch dann verwenden, wenn es mehr Parameter übergeht als die Funktion verwendet Foo(...a); // "1: 2: 3" → Foo (a [0], a [1], a [2], a [3]);  // Sie können es mit nicht verbreiteten Parametern mischen Foo(5, ...a, 6); // "5: 1: 2" → Foo (5, a [0], a [1], a [2], a [3], 6);  // zum Vergleich ohne den Spread Operator // weist Array das Array und nichts den anderen Parametern zu. Foo(a); // "1,2,3,4: undefiniert: undefiniert" 

Wann ... wird in einer Funktion verwendet Erklärung, es zeigt a an Ruheparameter. Der Restparameter muss der endgültige benannte Parameter in der Parameterliste der Funktion sein. Es wird eine zugewiesen Array Enthaltende Argumente, die an die Funktion über die anderen benannten Parameter übergeben wurden. Mit anderen Worten, es wird "den Rest" der Argumente erhalten, die an die Funktion übergeben wurden (daher der Name).

Funktion Foo(a, b, ...c) {  Konsole.Protokoll(c.Länge); } Foo(1, 2, 3, 4, 5); // "3" → C = [3, 4, 5] Foo('a', 'b'); // "0" → C = [] 

Ruheparameter ähneln den JavaScripts Argumente Objekt, ein Array-ähnliches Objekt, das alle Parameter (benannt und unbenannt) im aktuellen Funktionsaufruf enthält. nicht wie ArgumenteRuheparameter sind jedoch wahr Array Objekte, also Methoden wie z. .Scheibe() und .Sortieren() kann direkt auf ihnen verwendet werden.

Das ... Der Bediener kann nur mit verwendet werden Array Objekte. (Es gibt jedoch einen Vorschlag, es auf zu erweitern Objekts in einem zukünftigen ECMAScript -Standard.^[15]))

Vergleich

Variablen, die Objekte referenzieren, sind nur dann gleich oder identisch, wenn sie auf das gleiche Objekt verweisen:

var OBJ1 = {a: 1}; var OBJ2 = {a: 1}; var OBJ3 = OBJ1; Konsole.Protokoll(OBJ1 == OBJ2);  //FALSCH Konsole.Protokoll(OBJ3 == OBJ1);  //Stimmt Konsole.Protokoll(OBJ3 === OBJ1); //Stimmt 

Siehe auch Saite.

Logisch

JavaScript bietet vier logische Operatoren:

• einstellig Negation (Nicht =! A)
• binär disjunktion (Oder = a || b) und Verbindung (Und = a && b)
• ternär bedingt (c ? T: f)

Im Kontext einer logischen Operation bewertet jeder Ausdruck auf True, außer dem folgenden:

• Saiten: "" ", '' ',
• Zahlen: 0, -0, Nan,
• Speziell: Null, nicht definiert,
• Booleschen: FALSCH.

Die Boolesche Funktion kann verwendet werden, um explizit in einen primitiven Typ umzuwandeln Boolesche:

// Nur leere Saiten geben falsch zurück Konsole.Protokoll(Boolesche("" ")  === FALSCH); Konsole.Protokoll(Boolesche("FALSCH") === Stimmt); Konsole.Protokoll(Boolesche("0")  === Stimmt); // nur null und nan return falsch Konsole.Protokoll(Boolesche(Nan) === FALSCH); Konsole.Protokoll(Boolesche(0)  === FALSCH); Konsole.Protokoll(Boolesche(-0)  === FALSCH); // äquivalent zu -1*0 Konsole.Protokoll(Boolesche(-2)  === Stimmt); // Alle Objekte geben wahr zurück Konsole.Protokoll(Boolesche(Dies) === Stimmt); Konsole.Protokoll(Boolesche({})  === Stimmt); Konsole.Protokoll(Boolesche([])  === Stimmt); // Diese Typen geben falsch zurück Konsole.Protokoll(Boolesche(Null)  === FALSCH); Konsole.Protokoll(Boolesche(nicht definiert) === FALSCH); // äquivalent zu boolean () 

Der Nichtbetreiber bewertet seinen Operanden als Booleschen und gibt die Negation zurück. Mit dem Bediener zweimal hintereinander als a Doppel negativUmdreht explizit einen Ausdruck in einen primitiven Booleschen Typ:

Konsole.Protokoll( !0 === Boolesche(!0)); Konsole.Protokoll(Boolesche(!0) === !!1); Konsole.Protokoll(!!1 === Boolesche(1)); Konsole.Protokoll(!!0 === Boolesche(0)); Konsole.Protokoll(Boolesche(0) === !1); Konsole.Protokoll(!1 === Boolesche(!1)); Konsole.Protokoll(!"" " === Boolesche(!"" ")); Konsole.Protokoll(Boolesche(!"" ") === !!"s"); Konsole.Protokoll(!!"s" === Boolesche("s")); Konsole.Protokoll(!!"" " === Boolesche("" ")); Konsole.Protokoll(Boolesche("" ") === !"s");	 Konsole.Protokoll(!"s" === Boolesche(!"s")); 

Der ternäre Operator kann auch zur expliziten Konvertierung verwendet werden:

Konsole.Protokoll([] == FALSCH); Konsole.Protokoll([] ? Stimmt : FALSCH); // "Truthy", aber der Vergleich verwendet [] .ToString () Konsole.Protokoll[0] == FALSCH); Konsole.Protokoll[0]? Stimmt : FALSCH); // [0] .ToString () == "0" Konsole.Protokoll("0" == FALSCH); Konsole.Protokoll("0"? Stimmt : FALSCH); // "0" → 0 ... (0 == 0) ... 0 ← Falsch Konsole.Protokoll[1] == Stimmt); Konsole.Protokoll[1]? Stimmt : FALSCH); // [1] .ToString () == "1" Konsole.Protokoll("1" == Stimmt); Konsole.Protokoll("1"? Stimmt : FALSCH); // "1" → 1 ... (1 == 1) ... 1 ← True Konsole.Protokoll[2] ! = Stimmt); Konsole.Protokoll[2]? Stimmt : FALSCH); // [2] .ToString () == "2" Konsole.Protokoll("2" ! = Stimmt); Konsole.Protokoll("2"? Stimmt : FALSCH); // "2" → 2 ... (2! = 1) ... 1 ← True 

Ausdrücke, die Funktionen wie Post -Inkrementierung verwenden (i ++) haben eine erwartete Nebeneffekt. JavaScript bietet Kurzschlussbewertung von Ausdrücken; Der rechte Operand wird nur ausgeführt, wenn der linke Operand nicht ausreicht, um den Wert des Ausdrucks zu bestimmen.

Konsole.Protokoll(a || b);  // Wenn a wahr ist, gibt es keinen Grund, b zu bewerten. Konsole.Protokoll(a && b);  // Wenn a falsch ist, gibt es keinen Grund, b zu bewerten. Konsole.Protokoll(c ? t : f); // Wenn C wahr ist, gibt es keinen Grund, F zu bewerten. 

In frühen Versionen von JavaScript und JscriptDie binären logischen Operatoren kehrten einen booleschen Wert zurück (wie die meisten C-abgeleiteten Programmiersprachen). Alle zeitgenössischen Implementierungen geben stattdessen jedoch einen ihrer Operanden zurück:

Konsole.Protokoll(a || b); // Wenn a wahr ist, return a, ansonsten zurück b Konsole.Protokoll(a && b); // Wenn a falsch ist, geben Sie A zurück, ansonsten zurück B 

Programmierer, die mit dem Verhalten in C besser vertraut sind Null -Koalescing:

var s = t || "(Ursprünglich)"; // weist T oder den Standardwert zu, wenn t null, leer ist, usw. 

Logische Zuordnung

Bitweise

JavaScript unterstützt Folgendes binär Bitgewise -Operatoren:

Beispiele:

x=11 & 6; Konsole.Protokoll(x); // 2 

JavaScript unterstützt Folgendes Unarm Bitwise Operator:

Bitgewise -Zuordnung

JavaScript unterstützt Folgendes Binärzuordnungsbetreiber:

Beispiele:

x=7; Konsole.Protokoll(x); // 7 x<<=3; Konsole.Protokoll(x); // 7-> 14-> 28-> 56 

Saite

Beispiele:

str = "AB" + "CD";  // "A B C D" str += "E";  // "Abcde" STR2 = "2" + 2;  // "22", nicht "4" oder 4. 

?

Const a = b ? 3; 

Const a = b || 3; 

Kontrollstrukturen

Zusammengesetzte Aussagen

Ein Paar lockige Klammern {} und eine geschlossene Abfolge von Aussagen bildet eine zusammengesetzte Aussage, die überall dort verwendet werden kann, wo eine Aussage verwendet werden kann.

Ansonsten

wenn (Expr) {  // Aussagen; } anders wenn (expr2) {  // Aussagen; } anders {  // Aussagen; } 

Bedingter (ternärer) Operator

Der bedingte Operator erstellt einen Ausdruck, der je nach Zustand als einen von zwei Ausdrücken bewertet. Dies ähnelt dem wenn Anweisung, die je nach Bedingung eine von zwei Aussagen auswählt, um auszuführen. D.h. der bedingte Operator ist ausdrücken was wenn ist zu Aussagen.

 Ergebnis = Bedingung ? Ausdruck : Alternative; 

ist das gleiche wie:

 wenn (Bedingung) {  Ergebnis = Ausdruck;  } anders {  Ergebnis = Alternative;  } 

im Gegensatz zu den wenn Aussage, der bedingte Bediener kann seine "else-branch" nicht weglassen.

Schaltanweisung

Die Syntax des JavaScripts Schaltanweisung ist wie folgt:

 Schalter (Expr) {  Fall Ein bisschen Wert:  // Aussagen;  Unterbrechung;  Fall Ein anderer Wert:  // Aussagen für When OtherValue || Ornaotherone  // Keine Break -Erklärung, die in den folgenden Fall fällt  Fall Oranotherone:  // Aussagen spezifisch für Oranotherone (d. H.! Ein anderer Wert && oranother);  Unterbrechung; // Das Geld hält hier auf.  Fall NOCH EIN ANDERER:  // Aussagen;  Unterbrechung;  Ursprünglich:  // Aussagen;  Unterbrechung;  } 

• Unterbrechung; es ist optional; Es wird jedoch normalerweise benötigt, da die Codeausführung ansonsten bis zum Körper des nächsten Fallblocks fortgesetzt wird. Dies durchfallen Verhalten kann verwendet werden, wenn dieselben Aussagen in mehreren Fällen gelten und effektiv a erstellen disjunktion zwischen diesen Fällen.
• Fügen Sie als Vorsichtsmaßnahme eine Pausenanweisung zum Ende des letzten Falls hinzu, falls zusätzliche Fälle später hinzugefügt werden.
• String -Literalwerte können auch für die Fallwerte verwendet werden.
• Ausdrücke können anstelle von Werten verwendet werden.
• Der Standardfall (optional) wird ausgeführt, wenn der Ausdruck nicht mit anderen angegebenen Fällen übereinstimmt.
• Zahnspangen sind erforderlich.

Für Schleife

Die Syntax des JavaScripts Für Schleife ist wie folgt:

 zum (Initial; Bedingung; Schleife Aussage) {  /*    Aussagen werden jedes Mal ausgeführt    die für {} Schleifenzyklen, während die    Der Zustand ist erfüllt   */  } 

oder

 zum (Initial; Bedingung; Schleife Aussage(Wiederholung)) // eine Aussage 

Für ... in Schleife

Die Syntax des JavaScripts für ... in Schleife ist wie folgt:

zum (var Name des Anwesens in SONDER_OBJECT) {  // Anweisungen unter Verwendung von slow_object [Property_name]; } 

• Iteriert alle aufzählbaren Eigenschaften eines Objekts.
• Iteriert alle verwendeten Array-Indizes, einschließlich aller benutzerdefinierten Eigenschaften des Array-Objekts, falls vorhanden. Daher kann es besser sein, eine traditionelle für die Schleife mit einem numerischen Index bei der Iterierung über Arrays zu verwenden.
• Es gibt Unterschiede zwischen den verschiedenen Webbrowsern in Bezug auf welche Eigenschaften mit der für ... in der Schleifenanweisung widerspiegelt werden. Theoretisch wird dies durch eine interne Zustandseigenschaft kontrolliert, die durch den ECMAScript -Standard als "Dontenum" definiert wird, aber in der Praxis gibt jeder Browser während der Selbstbeobachtung einen leicht unterschiedlichen Satz von Eigenschaften zurück. Es ist nützlich, auf eine bestimmte Eigenschaft zu testen if (some_object.hasOwnProperty(property_name)) { ...}. So fügen Sie dem Array -Prototyp mit einer Methode mit hinzu Array.prototype.newMethod = function() {...} kann verursachen für in Schleifen zum Schleifen über den Namen der Methode.

While-Schleife

Die Syntax des JavaScripts while-Schleife ist wie folgt:

während (Bedingung) {  Erklärung1;  Erklärung2;  Erklärung3;  ... } 

Tun ... während Schleife

Die Syntax des JavaScripts tun ... während Schleife ist wie folgt:

tun {  Erklärung1;  Erklärung2;  Erklärung3;  ... } während (Bedingung); 

Mit

Die With -Anweisung fügt alle Eigenschaften und Methoden des angegebenen Objekts in den Bereich des folgenden Blocks hinzu, sodass sie als lokale Variablen bezeichnet werden können.

mit (dokumentieren) {  var a = GetElementById('a');  var b = GetElementById('b');  var c = GetElementById('c'); }; 

• Beachten Sie das Fehlen von dokumentieren. vor jedem GetElementById () Aufruf.

Die Semantik ähnelt der mit der Erklärung von Pascal.

Da die Verfügbarkeit von Aussagen die Programmleistung behindert und angenommen wird, dass sie die Code -Klarheit verringert (da eine bestimmte Variable tatsächlich eine Eigenschaft aus einer Einschließung sein kann mit) Diese Aussage ist nicht erlaubt in strikter Modus.

Etiketten

JavaScript unterstützt verschachtelte Labels in den meisten Implementierungen. Schleifen oder Blöcke können für die Break -Anweisung und Schleifen für gekennzeichnet werden fortsetzen. Obwohl gehe zu ist ein reserviertes Wort,^[17] gehe zu wird nicht in JavaScript implementiert.

Loop1: zum (var a = 0; a < 10; ++a) {  wenn (a === 4) Unterbrechung Loop1; // stoppt nach dem 4. Versuch  Konsole.Protokoll('a =' + a);  Loop2: zum (var b = 0; b < 10; ++b) {  wenn (b === 3) fortsetzen Loop2; // Nummer 3 wird übersprungen  wenn (b === 6) fortsetzen Loop1; // Fortsetzung der ersten Schleife, "fertig" wird nicht gezeigt  Konsole.Protokoll('B =' + b);  } // Ende von Loop2  Konsole.Protokoll('fertig'); } // Ende von Loop1 Block 1: {  Konsole.Protokoll('Hallo'); // Zeigt 'Hallo' an  Unterbrechung Block 1;  Konsole.Protokoll('Welt'); // wird niemals hierher kommen } gehe zu Block 1; // Fehler analysieren. 

Funktionen

A Funktion ist ein Block mit einer (möglicherweise leeren) Parameterliste, die normalerweise einen Namen erhält. Eine Funktion kann lokale Variablen verwenden. Wenn Sie die Funktion ohne Rückgabeanweisung beenden, ist der Wert der Wert nicht definiert ist zurück gekommen.

Funktion GCD(Nummer 1, Nummer 2) {  wenn isnan(Nummer 1*Nummer 2) Wurf Typeerror("Nicht numerische Argumente nicht erlaubt.");  Nummer 1 = Mathematik.runden(Nummer 1);  Nummer 2 = Mathematik.runden(Nummer 2);  Lassen Unterschied = Nummer 1 - Nummer 2;  wenn (Unterschied === 0) Rückkehr Nummer 1;  Rückkehr Unterschied > 0 ? GCD(Nummer 2, Unterschied) : GCD(Nummer 1, -Unterschied); } Konsole.Protokoll(GCD(60, 40)); // 20 // ohne Klammern nach der Kennung 'GCD' auf den RHS der folgenden Zuordnung, // 'GCD' gibt einen Verweis auf die Funktion selbst zurück, ohne sie aufzurufen. Lassen mygcd = GCD; // MyGCD und GCD verweisen auf die gleiche Funktion. Konsole.Protokoll(mygcd(60, 40)); // 20 

Funktionen sind erstklassige Objekte und kann anderen Variablen zugeordnet werden.

Die Anzahl der Argumente, die beim Aufrufen einer Funktion angegeben sind, entsprechen möglicherweise nicht unbedingt der Anzahl der Argumente in der Funktionsdefinition. Ein benanntes Argument in der Definition, das kein übereinstimmendes Argument im Anruf hat nicht definiert (Das kann implizit auf falsch geworfen werden). Innerhalb der Funktion können auch auf die Argumente über die zugegriffen werden Argumente Objekt; Dies bietet Zugriff auf alle Argumente unter Verwendung von Indizes (z. arguments[0], arguments[1], ... arguments[n]), einschließlich derjenigen, die über die Anzahl der benannten Argumente hinausgehen. (Während die Argumenteliste eine hat .Länge Eigentum ist es nicht eine Instanz von Array; Es gibt keine Methoden wie .Scheibe(), .Sortieren(), etc.)

Funktion Add7(x, y) {  wenn (!y) {  y = 7;  }  Konsole.Protokoll(x + y + Argumente.Länge); }; Add7(3); // 11 Add7(3, 4); // 9 

Primitive Werte (Zahl, Boolesche, String) werden nach Wert übergeben. Für Objekte ist es der Verweis auf das übergebene Objekt.

var OBJ1 = {a : 1}; var OBJ2 = {b : 2}; Funktion Foo(p) {  p = OBJ2; // Ignoriert den tatsächlichen Parameter  p.b = Argumente[1]; } Foo(OBJ1, 3); // betrifft OBJ1 überhaupt nicht. 3 ist ein zusätzlicher Parameter Konsole.Protokoll(OBJ1.a + "" " + OBJ2.b); // schreibt 1 3 

Funktionen können in anderen Funktionen deklariert und auf die lokalen Variablen der äußeren Funktion zugreifen. Darüber hinaus implementieren sie voll Schließungen Durch das Erinnern an die lokalen Variablen der äußeren Funktion auch nach dem Ausgang der äußeren Funktion.

Lassen t = "Oben"; Lassen Bar, Baz; Funktion Foo() {  Lassen f = "Foo var";  Bar = Funktion() { Konsole.Protokoll(f) };  Baz = Funktion(x) { f = x; }; } Foo(); Baz("baz arg"); Bar(); // "baz arg" (nicht "foo var"), obwohl Foo () beendet ist. Konsole.Protokoll(t); // Oben 

Asynchron/wartet

Async Funktion CreateNewdoc() {  Lassen Antwort = erwarten db.Post({}); // einen neuen Dokument veröffentlichen  Rückkehr db.erhalten(Antwort.Ich würde); // durch ID finden } Async Funktion hauptsächlich() {  Versuchen {  Lassen Dokument = erwarten CreateNewdoc();  Konsole.Protokoll(Dokument);  } Fang (irren) {  Konsole.Protokoll(irren);  } } hauptsächlich(); 

Objekte

Zur Bequemlichkeit werden normalerweise Typen unterteilt in Primitive und Objekte. Objekte sind Entitäten, die eine Identität haben (sie sind nur gleich) und die Eigenschaftennamen zu Werten ("Slots" in Prototypbasierte Programmierung Terminologie). Objekte können als als angesehen werden assoziative Arrays oder Hashes und werden häufig mit diesen Datenstrukturen implementiert. Objekte haben jedoch zusätzliche Merkmale wie eine Prototypkette^{[Klarstellung erforderlich]}, welche gewöhnlichen assoziativen Arrays nicht haben.

JavaScript hat verschiedene Arten von integrierten Objekten, nämlich Array, Boolesche, Datum, Funktion, Mathematik, Nummer, Objekt, Regexp und Saite. Andere Objekte sind "Host -Objekte", die nicht von der Sprache, sondern von der Laufzeitumgebung definiert sind. In einem Browser gehören beispielsweise typische Hostobjekte zum DOM (Fenster, Form, Links usw.).

Objekte erstellen

Objekte können mit einem Konstruktor oder einem Objektliteral erstellt werden. Der Konstruktor kann entweder eine integrierte Objektfunktion oder eine benutzerdefinierte Funktion verwenden. Es ist eine Konvention, dass Konstruktorfunktionen einen Namen erhalten, der mit einem Großbuchstaben beginnt:

// Konstrukteur var ein Objekt = Neu Objekt(); // Objekt wörtlich var Objekta = {}; var Objecta2 = {};  // a! = A2, {} s erstellen neue Objekte als Kopien. var Objektb = {Index1: 'Wert 1', Index2: 'Wert 2'}; // benutzerdefinierter Konstruktor (siehe unten) 

Objektliterale und Array -Literale ermöglichen es, problemlos flexible Datenstrukturen zu erstellen:

var Mystruktur = {  Name: {  Erste: "Mel",  letzte: "Schmied"  },  das Alter: 33,  Hobbys: ["Schach", "Joggen"] }; 

Dies ist die Grundlage für JSON, was eine einfache Notation ist, die JavaScript-ähnliche Syntax für den Datenaustausch verwendet.

Methoden

A Methode ist einfach eine Funktion, die einem Eigenschaftsnamen eines Objekts zugewiesen wurde. Im Gegensatz zu vielen objektorientierten Sprachen gibt es keine Unterscheidung zwischen einer Funktionsdefinition und einer Methodendefinition im objektbezogenen JavaScript. Vielmehr erfolgt die Unterscheidung während der Funktionsaufruf; Eine Funktion kann als Methode aufgerufen werden.

Bei als Methode aufgerufene Standard -Lokalvariable Dies wird einfach automatisch auf die Objektinstanz links vom "festgelegt".". (Es gibt auch Anruf und anwenden Methoden, die festlegen können Dies explizit - einige Pakete wie JQuery mach ungewöhnliche Dinge mit Dies.))

Im folgenden Beispiel wird Foo als Konstruktor verwendet. Ein Konstruktor hat nichts Besonderes - es ist nur eine einfache Funktion, die ein Objekt initialisiert. Wenn mit dem verwendet Neu Schlüsselwort, ebenso wie die Norm, Dies wird auf ein neu erstelltes leeres Objekt eingestellt.

Beachten Sie, dass Foo im folgenden Beispiel einfach Werte zu Slots zuweist, von denen einige Funktionen sind. Somit kann es unterschiedlichen Instanzen unterschiedliche Funktionen zuweisen. In diesem Beispiel gibt es kein Prototyping.

Funktion px() { Rückkehr Dies.Präfix + "X"; } Funktion Foo(yz) {  Dies.Präfix = "a-";  wenn (yz > 0) {  Dies.Pyz = Funktion() { Rückkehr Dies.Präfix + "Y"; };  } anders {  Dies.Pyz = Funktion() { Rückkehr Dies.Präfix + "Z"; };  }  Dies.M1 = px;  Rückkehr Dies; } var foo1 = Neu Foo(1); var foo2 = Neu Foo(0); foo2.Präfix = "b-"; Konsole.Protokoll("Foo1/2" + foo1.Pyz() + foo2.Pyz()); // foo1/2 a-y b-z foo1.M3 = px; // weist die Funktion selbst zu, nicht ihr ausgewertetes Ergebnis, d. H. Nicht PX () var Baz = {"Präfix": "c-"}; Baz.M4 = px; // kein Konstruktor benötigt, um ein Objekt zu erstellen. Konsole.Protokoll("M1/M3/M4" + foo1.M1() + foo1.M3() + Baz.M4()); // M1/M3/M4 A-X A-X C-X foo1.M2(); // macht eine Ausnahme, weil foo1.m2 nicht existiert. 

Konstrukteure

Konstruktorfunktionen Weisen Sie Slots eines neu erstellten Objekts einfach Werte zu. Die Werte können Daten oder andere Funktionen sein.

Beispiel: Manipulieren eines Objekts:

Funktion MyObject(Attributea, Attributeb) {  Dies.Attributea = Attributea;  Dies.Attributeb = Attributeb; } MyObject.staticc = "blau"; // Auf MyObject -Funktion, nicht Objekt Konsole.Protokoll(MyObject.staticc); // blau Objekt = Neu MyObject('rot', 1000); Konsole.Protokoll(Objekt.Attributea); // rot Konsole.Protokoll(Objekt["Attributeb"]); // 1000 Konsole.Protokoll(Objekt.staticc); // nicht definiert Objekt.Attributec = Neu Datum(); // eine neue Immobilie hinzufügen löschen Objekt.Attributeb; // Entfernen Sie eine Eigenschaft des Objekts Konsole.Protokoll(Objekt.Attributeb); // nicht definiert 

Der Konstruktor selbst wird im Prototyp des Objekts verwiesen Konstrukteur Slot. So,

Funktion Foo() {} // Verwendung von 'neuen' Sets Prototyp -Slots (zum Beispiel, zum Beispiel,  // x = new foo () würde den Prototyp von X auf foo.prototype festlegen, // und foo.prototype hat einen Konstruktor -Slot, der auf Foo zurückzeigt). x = Neu Foo(); // Das oben oben ist fast gleichbedeutend mit y = {}; y.Konstrukteur = Foo; y.Konstrukteur(); // Außer x.Konstrukteur == y.Konstrukteur // Stimmt x Instanz Foo // Stimmt y Instanz Foo // FALSCH // Ys Prototyp ist Object.Prototyp, nicht // foo.prototype, da es mit initialisiert wurde // {} anstelle von neuem Foo. // Obwohl Foo auf Ys Konstruktor -Slot eingestellt ist, // Dies wird durch Instanz ignoriert - nur Ys Prototypen // Konstruktorschlitz wird berücksichtigt. 

Funktionen sind Objekte selbst, die verwendet werden können, um einen Effekt zu erzeugen, der "statische Eigenschaften" (unter Verwendung von C ++/Java -Terminologie) ähnelt, wie unten gezeigt. (Das Funktionsobjekt hat auch ein spezielles Prototyp Eigenschaft, wie im Abschnitt "Vererbung" unten beschrieben.)

Die Löschung der Objekte wird selten verwendet, da der Skriptmotor wird Müll sammeln Objekte, auf die nicht mehr verwiesen wird.

Nachlass

JavaScript unterstützt Vererbungshierarchien durch Prototyping in der Art von Selbst.

Im folgenden Beispiel die Abgeleitet Klasse erbt aus dem Base Klasse. Wann d wird erstellt als Abgeleitet, der Verweis auf die Basisinstanz von Base wird kopiert zu D.Base.

Ableitung enthält keinen Wert für Abasefunktion, so wird es abgerufen von Abasefunktion Wenn Abasefunktion ist zugegriffen. Dies wird deutlich, indem der Wert von geändert wird Base.AbaseFunction, was sich im Wert von widerspiegelt D.Abasefunktion.

Einige Implementierungen ermöglichen es dem Prototyp, zugegriffen zu werden oder explizit mit dem festzulegen __Proto__ Slot wie unten gezeigt.

Funktion Base() {  Dies.Anoverride = Funktion() { Konsole.Protokoll("Basis :: Anoverride ()"); };  Dies.Abasefunktion = Funktion() { Konsole.Protokoll("Basis :: AbaseFunction ()"); }; } Funktion Abgeleitet() {  Dies.Anoverride = Funktion() { Konsole.Protokoll("Abgeleitet :: Anoverride ()"); }; } Base = Neu Base(); Abgeleitet.Prototyp = Base; // muss vor neuem abgeleitet sein () Abgeleitet.Prototyp.Konstrukteur = Abgeleitet; // erforderlich, um `Instanceof` funktionieren zu lassen d = Neu Abgeleitet();  // Kopien abgeleitet. d Instanz Abgeleitet; // Stimmt d Instanz Base;  // Stimmt Base.Abasefunktion = Funktion() { Konsole.Protokoll("Basis :: NeubaseFunction ()"); } d.Anoverride();  // Abgeleitet :: Anoverride () d.Abasefunktion(); // Basis :: NeueBaseFunction () Konsole.Protokoll(d.Abasefunktion == Abgeleitet.Prototyp.Abasefunktion); // Stimmt Konsole.Protokoll(d.__Proto__ == Base); // wahr in Mozilla-basierten Implementierungen und in vielen anderen falsch. 

Das Folgende zeigt deutlich, wie Hinweise auf Prototypen sind kopiert Bei der Instanzerstellung, aber diese Änderungen an einem Prototyp können alle Instanzen beeinflussen, die sich darauf beziehen.

Funktion M1() { Rückkehr "Einer"; } Funktion M2() { Rückkehr "Zwei"; } Funktion M3() { Rückkehr "Drei"; } Funktion Base() {} Base.Prototyp.m = M2; Bar = Neu Base(); Konsole.Protokoll("bar.m" + Bar.m()); // bar.m zwei Funktion oben() { Dies.m = M3; } t = Neu oben(); Foo = Neu Base(); Base.Prototyp = t; // Keine Wirkung auf Foo, die * Referenz * auf T wird kopiert. Konsole.Protokoll("foo.m" + Foo.m()); // foo.m zwei Baz = Neu Base(); Konsole.Protokoll("baz.m" + Baz.m()); // baz.m drei t.m = M1; // wirkt sich auf Baz und alle anderen abgeleiteten Klassen aus. Konsole.Protokoll("Baz.m1" + Baz.m()); // baz.m1 eins 

In der Praxis werden viele Variationen dieser Themen verwendet, und es kann sowohl mächtig als auch verwirrend sein.

Ausnahmebehandlung

JavaScript enthält a versuche ... fangen ... endlich Ausnahmebehandlung Anweisung zur Behandlung von Laufzeitfehlern.

Das versuche ... fangen ... endlich Aussagefänge Ausnahmen resultiert aus einem Fehler oder einer Wurfanweisung. Seine Syntax ist wie folgt:

Versuchen {  // Aussagen, in denen Ausnahmen geworfen werden könnten } Fang(Fehlerwert) {  // Aussagen, die im Falle einer Ausnahme ausgeführt werden } endlich {  // Aussagen, die danach in beiden Fällen ausgeführt werden } 

Zunächst führen die Aussagen im Try -Block aus. Wenn eine Ausnahme ausgelöst wird, überträgt der Steuerfluss des Skripts sofort auf die Aussagen im Catch -Block, mit der Ausnahme als Fehlerargument. Andernfalls wird der Fangblock übersprungen. Der Fangblock kann throw (FehlerValue), wenn es keinen bestimmten Fehler behandeln möchte.

In jedem Fall werden die Aussagen im endgültigen Block immer ausgeführt. Dies kann zur freien Ressourcen verwendet werden, obwohl der Speicher automatisch Müll gesammelt wird.

Entweder kann der Fang oder die schließlich die Klausel weggelassen werden. Das Fangargument ist erforderlich.

Die Mozilla -Implementierung ermöglicht mehrere Catch -Anweisungen als Erweiterung des ECMascript -Standards. Sie folgen einer Syntax ähnlich der in verwendeten in Java:

Versuchen { Aussage; } Fang (e wenn e == "InvalyNameException")  { Aussage; } Fang (e wenn e == "Invalyidexception")  { Aussage; } Fang (e wenn e == "InvalyEmailException") { Aussage; } Fang (e)  { Aussage; } 

In einem Browser die onError Das Ereignis wird häufiger verwendet, um Ausnahmen zu fangen.

onError = Funktion (Fehlerwert, URL, Leinenr) {...; Rückkehr Stimmt;}; 

Native Funktionen und Methoden

(Nicht im Zusammenhang mit Webbrowsern.)

Eval (Ausdruck)

Bewertet den ersten Parameter als Ausdruck, der Zuweisungsanweisungen enthalten kann. Variablen lokal zu Funktionen können durch den Ausdruck verwiesen werden. Jedoch, eval stellt ein großes Sicherheitsrisiko dar, da ein schlechter Akteur willkürlicher Code ausführt, sodass seine Verwendung entmutigt wird.^[22]

> (Funktion Foo() { ...  var x = 7; ...  Konsole.Protokoll("Val" + bewerten("x + 2")); ... }) (); val 9 nicht definiert 

Siehe auch

• Vergleich von JavaScript-basierten Quellcode-Editoren
• JavaScript

Verweise

Weitere Lektüre

• Danny Goodman: JavaScript -Bibel, Wiley, John & Sons, ISBN0-7645-3342-8.
• David Flanagan, Paula Ferguson: JavaScript: Der endgültige Handbuch, O'Reilly & Associates, ISBN0-596-10199-6.
• Thomas A. Powell, Fritz Schneider: JavaScript: Die vollständige Referenz, McGraw-Hill-Unternehmen, ISBN0-07-219127-9.
• Axel Rauschmayer: JavaScript sprechend: Eine eingehende Anleitung für Programmierer, 460 Seiten, O'Reilly Media, 25. Februar 2014, ISBN978-1449365035. (Kostenlose Online -Ausgabe)
• Emily Vander Veer: JavaScript für Dummies, 4. Ausgabe, Wiley, ISBN0-7645-7659-3.

Externe Links

• Eine Wiedereinführung in JavaScript - Mozilla Developer Center
• JavaScript Loops
• ECMAScript -Standardreferenzen: ECMA-262
• Interaktive JavaScript -Lektionen - Beispielbasierte Basis
• JavaScript auf About.com: Lektionen und Erklärung
• JavaScript -Training
• Mozilla Developer Center Core Referenzen für JavaScript -Versionen 1.5, 1.4, 1.3 und 1.2
• Mozilla Javascript Sprachdokumentation