Heim > Artikel > Web-Frontend > Javascript-Kernlesesätze_Javascript-Kenntnisse
Javascript-Kernlesesätze_Javascript-Kenntnisse
- WBOYOriginal
- 2016-05-16 16:14:371091Durchsuche
In JavaScript sind Ausdrücke Phrasen und Anweisungen ganze Sätze oder Befehle. So wie englische Anweisungen mit einem Punkt enden, endet JavaScript mit einem Semikolon.
Ein Ausdruck ergibt einen Wert, aber eine Anweisung bewirkt, dass etwas geschieht.
Eine Möglichkeit, „etwas geschehen zu lassen“, besteht darin, einen Ausdruck mit Nebenwirkungen zu bewerten. Ausdrücke mit Nebeneffekten, wie Zuweisungen und Funktionsaufrufe, können als separate Anweisungen behandelt werden. Diese Verwendung von Ausdrücken als Anweisungen wird auch als Ausdrucksanweisungen bezeichnet. Ähnliche Anweisungen umfassen Deklarationsanweisungen, die zum Deklarieren neuer Variablen oder zum Definieren neuer Funktionen verwendet werden.
Ein JavaScript-Programm ist eine Sammlung ausführbarer Anweisungen. Standardmäßig führt der JavaScript-Interpreter diese der Reihe nach aus. Eine andere Möglichkeit, „etwas geschehen zu lassen“, besteht darin, die Standardausführungsreihenfolge von Anweisungen zu ändern:
1. Bedingte Anweisung: Der JavaScript-Interpreter kann anhand des Werts eines Ausdrucks beurteilen, ob diese Anweisungen ausgeführt oder übersprungen werden sollen.
2. Schleifenanweisung: Anweisung, die wiederholt ausgeführt werden kann, z. B. while- und for-Anweisungen
3. Jump-Anweisung: Ermöglicht dem Interpreter, zu anderen Teilen des Programms zu springen, um die Ausführung fortzusetzen, z. B. Break-, Return- und Throw-Anweisungen
Der folgende Artikel stellt verschiedene Anweisungen und ihre Syntax in JavaScript vor. Das Kapitel schließt mit einer Zusammenfassung dieser Aussagen. Ein Javascript-Programm ist nichts anderes als eine Sammlung von durch Trennzeichen getrennten Anweisungen. Sobald Sie also Javascript-Anweisungen beherrschen, können Sie Javascript-Programme schreiben.
1. Ausdrucksanweisung
Die Zuweisungsanweisung ist eine relativ wichtige Ausdrucksanweisung. Ihre Funktion besteht darin, den Wert einer Variablen zu ändern, genau wie die Ausführung einer Zuweisungsanweisung: zum Beispiel
greet = „Hallo“ name;
i *= 3;
Der Inkrementoperator ( ) und der Dekrementoperator (--) beziehen sich auf Zuweisungsanweisungen. Ihr Zweck besteht darin, den Wert einer Variablen zu ändern, genau wie das Ausführen einer Zuweisungsanweisung.
Zähler ;
delete-Operators besteht darin, die Attribute eines Objekts (oder der Elemente eines Arrays) zu löschen. Daher wird er im Allgemeinen als Anweisung und nicht als Teil eines komplexen Ausdrucks verwendet.
o.x löschen;
Funktionsaufrufe sind eine weitere wichtige Kategorie von Ausdrucksanweisungen, wie z. B.
alarm(begrüßen);
window.close();
Obwohl diese clientseitigen Funktionen Ausdrücke sind, haben sie gewisse Auswirkungen auf Webbrowser. Daher sind wir der Meinung, dass es auch bei Anweisungen keinen Sinn macht, eine Funktion aufzurufen, die keine Nebenwirkungen hat, es sei denn, sie ist beispielsweise Teil eines komplexen Ausdrucks oder einer Zuweisungsanweisung. Es ist unmöglich, einen Kosinuswert einfach wegzuwerfen
Math.cos(x);
Um den Kosinuswert zu erhalten, müssen Sie ihn hingegen einer Variablen zuweisen, damit der Wert in Zukunft verwendet werden kann:
var cx = Math.cos(x);
Erinnern Sie alle noch einmal daran, dass jede Codezeile mit einem Semikolon endet.
2. Zusammengesetzte Aussagen und leere Aussagen
Mit dem Komma-Operator können Sie mehrere Ausdrücke zu einem Ausdruck zusammenfügen. Ebenso kann JavaScript auch mehrere Anweisungen zu einer zusammengesetzten Anweisung kombinieren. Schließen Sie mehrere Anweisungen einfach in geschweifte Klammern ein. Daher können die folgenden Codezeilen als eine einzelne Anweisung behandelt und überall in JavaScript verwendet werden, wo eine Anweisung gewünscht wird.
{
x = Math.PI;
cx = Math.cos(x);
console.log("cos(π)=" cx);
}
Bei Anweisungsblöcken gibt es einige Dinge zu beachten: Erstens erfordern Anweisungsblöcke keine Semikolons. Elementanweisungen innerhalb eines Blocks müssen mit einem Semikolon enden, Anweisungsblöcke jedoch nicht.
Zweitens sind die Zeilen im Anweisungsblock eingerückt. Dies ist nicht notwendig, aber eine saubere Einrückung kann den Code besser lesbar und verständlicher machen.
Drittens hat JavaScript keinen Geltungsbereich auf Blockebene und in einem Anweisungsblock deklarierte Variablen sind für den Anweisungsblock nicht privat. (Siehe den ersten Abschnitt von Kapitel 3, Abschnitt 10)
Das Zusammenführen vieler Anweisungen zu einem großen Anweisungsblock ist in der JavaScript-Programmierung weit verbreitet. Ähnliche Ausdrücke enthalten oft Unterausdrücke, und viele JavaScripts enthalten andere Unteranweisungen. Formal gesehen erlaubt JavaScript normalerweise, dass ein Anweisungsblock eine Unteranweisung enthält. Beispiel: Der Schleifenkörper einer While-Schleife kann nur eine Anweisung enthalten. Mithilfe von Anweisungsblöcken können Sie beliebig viele Anweisungen in diesen Block einfügen und dieser Anweisungsblock kann als eine Anweisung verwendet werden.
Wenn Sie in JavaScript mehrere Anweisungen als eine Anweisung verwenden möchten, verwenden Sie stattdessen eine passende Anweisung. Eine leere Anweisung ist genau das Gegenteil und erlaubt 0-Anweisungen. Eine leere Anweisung sieht so aus:
;//Semikolon
Der JavaScript-Interpreter führt offensichtlich keine Aktion aus, wenn er eine leere Anweisung ausführt, aber die Praxis hat gezeigt, dass leere Anweisungen manchmal nützlich sind, wenn eine Schleife mit einem leeren Schleifenkörper erstellt wird, wie zum Beispiel die folgende for-Schleife
//Initialisiere ein Array a
for (i = 0; i < a.length; a[i ] = 0);
In dieser Schleife werden alle Operationen im Ausdruck a[i]=0 abgeschlossen, und hier ist kein Schleifenkörper erforderlich. Allerdings erfordert JavaScript, dass der Schleifenkörper mindestens eine Anweisung enthält, daher wird hier ein einzelnes Semikolon verwendet, um eine leere Anweisung darzustellen.
Beachten Sie, dass das Semikolon in der rechten Klammer einer for-Schleife, einer while-Schleife oder einer if-Anweisung sehr unauffällig ist, was wahrscheinlich zu schwerwiegenden Fehlern führt und diese Fehler schwer zu finden sind. Das Ausführungsergebnis des folgenden Codes ist beispielsweise wahrscheinlich der vom Autor nicht beabsichtigte Effekt:
If((a==0)||(b==0)); //Diese Codezeile bewirkt nichts....
o = null; //Diese Codezeile wird immer ausgeführt
Wenn Sie eine leere Anweisung für einen bestimmten Zweck verwenden, fügen Sie am besten Kommentare in den Code ein, um deutlicher zu machen, dass diese leere Anweisung nützlich ist
for (i = 0; i < a.length; a[i ] = 0) /*empty*/;
3. Erklärung zur Erklärung
Var und Funktion sind Deklarationsanweisungen, die Variablen oder Funktionen deklarieren oder definieren. Diese Anweisungen definieren Bezeichner (Variablen- und Funktionsnamen) und weisen ihnen Werte zu, die überall im Programm verwendet werden können. Die Deklarationsanweisung selbst bewirkt nichts, hat aber eine wichtige Bedeutung: Durch die Erstellung von Variablen und Funktionen kann die Semantik des Codes besser organisiert werden.
In den nächsten Abschnitten werden die var-Anweisung und die Funktionsanweisung beschrieben, sie decken jedoch nicht den gesamten Inhalt von Variablen und Funktionen ab.
i.var
Dievar-Anweisung wird verwendet, um eine oder mehrere Variablen zu deklarieren. Ihre Syntax lautet wie folgt:
var name_1[ = value_1][, ..., name_n[ = value_n]]
Dem Schlüsselwort var folgt eine Liste der zu deklarierenden Variablen. Jede Variable in der Liste kann einen Initialisierungsausdruck haben, der zur Angabe ihres Anfangswerts verwendet werden kann. Zum Beispiel:
var i; //Eine einfache Variable
var j = 0; //Eine Variable mit einem Anfangswert
var p, q; //Zwei Variablen
var meet = "hello" name; // Komplexerer Initialisierungsausdruck
var x = 2.34,y = Math.cos(0.75),r, theta; //Viele Variablen
var x = 2,y = x * x; //Die zweite Variable verwendet die erste Variable
var x = 2,
f = function(x) {return x * x}, //Jede Variable hat ihre eigene Zeile
y = f(x)
Wenn die var-Anweisung im Funktionskörper erscheint, ist eine lokale Variable definiert, deren Gültigkeitsbereich diese Funktion ist. Wenn Sie die var-Anweisung im Code der obersten Ebene verwenden, deklariert sie eine globale Variable, die in ganz JavaScript sichtbar ist. Es wird in Kapitel 3, Abschnitt 10 erwähnt: Globale Variablen sind Attribute des globalen Objekts. Im Gegensatz zu anderen globalen Objektattributen können mit var deklarierte Variablen nicht durch Löschen gelöscht werden.
Wenn die Variable in der var-Anweisung keinen Initialisierungsausdruck angibt, ist der Wert dieser Variablen zunächst undefiniert. Daher ist der Variablenwert vor der Deklarationsanweisung undefiniert.
Es ist zu beachten, dass die var-Anweisung auch als Bestandteil einer for-Schleife oder einer for/in-Schleife verwendet werden kann. (Wie die vor der Schleife deklarierte Variablendeklaration ist auch die hier deklarierte Variable „erweitert“), zum Beispiel:
for (var i = 0; i < 10; i ) console.log(i);
for (var i = 0, j = 10; i < 10; i , j--) console.log(i * j);
für (var i in o)console.log(i);
Beachten Sie, dass es keine Rolle spielt, wenn Sie dieselbe Variable mehrmals deklarieren.
ii.function
Das Schlüsselwort function wird verwendet, um Funktionen zu deklarieren (4.3). Funktionsdefinitionen können in Form von Anweisungen geschrieben werden. Zum Beispiel: die beiden Definitionsschreibmethoden im folgenden Beispielcode:
var f = function f(x) {return x 1;} //Weisen Sie den Ausdruck einer Variablen zu
function f(x){return x 1;} //Anweisung mit Variablennamen
Die Syntax der Funktionsdeklaration lautet wie folgt:
Funktion funcname([arg1[, arg2[..., argn]]]) {
Aussagen
}
funcname ist die Namenskennung der zu deklarierenden Funktion. Nach dem Funktionsnamen folgt die durch Kommas getrennte Parameterliste. Wenn eine Funktion aufgerufen wird, verweisen diese Bezeichner auf die tatsächlichen Parameter, die an die Funktion übergeben werden.
Der Funktionskörper besteht aus JavaScript-Anweisungen. Die Anzahl der Anweisungen ist unbegrenzt und sie sind in geschweifte Klammern eingeschlossen. Wenn eine Funktion definiert ist, werden die Anweisungen im Funktionskörper nicht ausgeführt, sondern mit dem neuen Funktionsobjekt verknüpft, das beim Aufruf der Funktion ausgeführt werden soll. Beachten Sie, dass die geschweiften Klammern in der Funktionsanweisung erforderlich sind, was sich von den Anweisungsblöcken unterscheidet, die von while-Schleifen und anderen Anweisungssperren verwendet werden. Auch wenn der Funktionskörper nur eine Anweisung enthält, sind dennoch geschweifte Klammern erforderlich, um diese einzuschließen.
Funktion hyteus(x, y) {
return Math.sqrt(x * x y * y);
}
hyteus(1, 2) //=>2.23606797749979
function facial(n) { //Eine rekursive Funktion
Wenn (n <= 1) 1 zurückgibt;
Geben Sie n * facial(n - 1);
zurück }
Gesichtsbehandlung(11) //=>39916800
Die Deklaration einer Funktion erscheint normalerweise oben im JavaScript-Code und kann auch im Hauptteil anderer Funktionen verschachtelt werden. Bei einer Verschachtelung können Funktionsdeklarationen jedoch nur am Anfang der verschachtelten Funktion erscheinen. Das heißt: Funktionsdefinitionen können nicht in if-, while- oder anderen Anweisungen vorkommen.
Wie bei der var-Anweisung können die durch die Funktionsdeklarationsanweisung erstellten Variablen nicht gelöscht werden. Diese Variablen sind jedoch nicht schreibgeschützt und die Variablenwerte können überschrieben werden.
4. Bedingte Anweisung
Bedingte Anweisungen werden verwendet, um bestimmte Anweisungen auszuführen oder zu überspringen, indem beurteilt wird, ob der Wert des angegebenen Ausdrucks vorhanden ist. Diese Anweisungen sind „Entscheidungspunkte“ des Codes, manchmal auch „Zweige“ genannt. Wenn der Javascript-Interpreter entsprechend dem „Pfad“ des Codes ausgeführt wird. Bedingte Anweisungen sind die Weggabelung. Das Programm erreicht diesen Punkt und muss einen Pfad auswählen, um die Ausführung fortzusetzen.
i.if-Anweisung
Dieif-Anweisung ist eine grundlegende Steueranweisung. Genauer gesagt ermöglicht sie die bedingte Ausführung dieser Anweisung: Die erste ist
Wenn (Ausdruck)
Aussage
In dieser Form wird der Wert des Ausdrucks beurteilt. Wenn er wahr ist, wird die Anweisung ausgeführt. Wenn er beispielsweise falsch ist, wird die Anweisung nicht ausgeführt
username = "jack wong" // Definiere es
Die Javascript-Syntax schreibt vor, dass auf das Schlüsselwort if und den Ausdruck mit Klammern eine Anweisung folgen muss. Sie können jedoch Anweisungsblöcke verwenden, um mehrere Anweisungen zu einer zusammenzufassen. Daher sieht die if-Anweisung so aus:
Adresse = "";
message = „Bitte Postanschrift“
}
Aussage1
sonst
Aussage2
if (n == 1)
console.log("1 neue Nachricht");
sonst
console.log("Sie haben" n "Neue Nachricht");
Beim Verschachteln von if-Anweisungen in if/else-Anweisungen muss darauf geachtet werden, dass die else-Anweisung mit der richtigen if-Anweisung übereinstimmt. Betrachten Sie den folgenden Code:
i = j = 1;
k = 2;
if (i == j)
Wenn (j == k)
console.log("i equs k");
sonst
console.log("i dosent equal j"); //Fehler! !
In diesem Beispiel bildet die innere if-Anweisung die Klauseln, die für die äußere if-Anweisung erforderlich sind. Allerdings ist die Übereinstimmungsbeziehung zwischen if und else nicht klar (nur die Einrückung gibt einen Hinweis) und in diesem Fall gibt die Einrückung den falschen Hinweis, weil der JavaScript-Interpreter dies so versteht.
Wenn (i == j) {
Wenn (j == k)
console.log("i equs k");
Sonst console.log("i dosent equal j");
}
sollte verwendet werden
Wenn (j == k) {
console.log("i equs k");
. console.log("i dosent equal j");
}
}
Die if/else-Anweisung wählt einen von zwei Zweigen aus, indem sie das Auswertungsergebnis eines Ausdrucks beurteilt. Was sollen wir tun, wenn der Code viele Zweige enthält? Eine Lösung besteht darin, eine else if-Anweisung zu verwenden. else if ist keine echte Javascript-Anweisung, sondern lediglich eine Möglichkeit, mehrere miteinander verbundene if/else-Anweisungen zu schreiben.
if (n == 1) {
//Codeblock 1 ausführen
} else if (n == 2) {
//Codeblock 2 ausführen
} else if (n == 3) {
//Codeblock 3 ausführen
} sonst {
// Die vorherigen Bedingungen sind alle falsch, dann führen Sie Codeblock 4 aus
}
An diesem Code gibt es nichts Besonderes. Er besteht aus mehreren if-Anweisungen, und die else-Klausel jeder if-Anweisung enthält eine weitere if-Anweisung. Syntaktisch äquivalenter Code kann mit einer verschachtelten Form von if-Anweisungen vervollständigt werden, aber im Vergleich dazu ist die Schreibweise „else if“ offensichtlich klarer und vorzuziehen.
iii.switch
Die if-Anweisung erstellt während der Programmausführung eine Verzweigung, und else if kann zum Verarbeiten mehrerer Verzweigungen verwendet werden. Wenn jedoch alle Zweige vom Wert desselben Ausdrucks abhängen, ist „sonst if“ nicht die beste Lösung. In diesem Fall wäre es verschwenderisch, Ausdrücke in mehreren if-Anweisungen wiederholt auszuwerten.
Die switch-Anweisung eignet sich zur Bewältigung dieser Situation. Dem Schlüsselwort switch folgt ein in Klammern eingeschlossener Ausdruck. Darauf folgt ein in geschweifte Klammern eingeschlossener Codeblock.
switch (Ausdruck) {
Aussagen
}
Allerdings ist die vollständige Syntax der switch-Anweisung komplizierter. Nach der Groß-/Kleinschreibung folgt ein Ausdruck und ein Doppelpunkt. Groß-/Kleinschreibung ist einem Tag sehr ähnlich, außer dass das Tag keinen Namen hat.
Es ist nur mit dem darauf folgenden Ausdruck verknüpft. Wenn diese Switch-Anweisung ausgeführt wird, berechnet sie zunächst den Wert von expression und prüft dann, ob der Ausdruck in der Case-Klausel mit dem Wert von expression übereinstimmt. (Die Ähnlichkeit wird hier anhand des Operators "===" verglichen.) Wenn der Fall übereinstimmt, wird der entsprechende Code ausgeführt. Wenn kein passender Fall gefunden wird, wird der Codeblock im Tag „default:“ ausgeführt. Ohne das Tag „default:“ überspringt der Switch alle Codeblöcke.
Die switch-Anweisung ist sehr leicht zu verwechseln. Anhand eines Beispiels wird die switch-Anweisung unten äquivalent zur if/else-Anweisung.
Schalter (n) {
Fall 1: //Wenn n ===1, beginnen Sie hier
//Codeblock 1 ausführen
Pause;
Fall 2:
//Codeblock 2 ausführen
Pause;
Fall 3:
//Codeblock 3 ausführen
Pause;
Standard:
//Codeblock 4 ausführen
Pause;
}
Es ist zu beachten, dass das Schlüsselwort break am Ende jeder case-Anweisung verwendet wird. Wir werden die Break-Anweisung später einführen. Die Break-Anweisung kann dazu führen, dass der Interpreter aus der Switch-Anweisung oder der Loop-Anweisung herausspringt. Bei switch gibt case nur den Startpunkt des auszuführenden Codes an, nicht jedoch den Endpunkt. Wenn keine Break-Anweisung vorhanden ist, beginnt die Ausführung der Switch-Anweisung mit dem Code an der entsprechenden Groß-/Kleinschreibung des Ausdruckswerts und führt die nachfolgenden Anweisungen der Reihe nach bis zum Ende des gesamten Switch-Codeblocks aus. Wenn Sie eine Switch-Anweisung in einer Funktion verwenden, können Sie natürlich auch „return“ verwenden, um „break“ zu ersetzen. „Return“ und „break“ werden zum Beenden der „switch“-Anweisung verwendet und verhindern außerdem, dass der nächste Case-Anweisungsblock nach einer Case-Anweisung weiter ausgeführt wird hingerichtet.
Die folgende Anweisung ist praxisnah, sie wandelt den Wert entsprechend seinem Typ in einen String um.
Funktion konvertieren(x) {
switch (typeof x) {
case 'number': //Konvertiert die Zahl in Hexadezimalzahl
Geben Sie x.toString(16);
zurück case 'string':
return '"' x '"' //Zwei Zeichenfolgen mit doppelten Anführungszeichen zurückgeben.
Standard: //Gewöhnliche Methoden verwenden, um andere Typen zu konvertieren
return String(x); }
}
console.log(convert(100255114)) //=>5f9c58a
Die Switch-Anweisung berechnet zuerst den Ausdruck nach dem Schlüsselwort switch und dann den Ausdruck nach jedem Fall in der Reihenfolge von oben nach unten, bis der Wert des Case-Ausdrucks gleich dem Wert des Switch-Ausdrucks ist. Da es sich bei der Abgleichsoperation für jeden Fall tatsächlich um einen „==="-Identitätsoperatorvergleich anstelle von „==" handelt, wird für den Abgleich von Ausdrücken und Fällen keine Typkonvertierung durchgeführt.
Wie bereits erwähnt, wird der mit „default:“ gekennzeichnete Anweisungsblock ausgeführt, wenn der switch-Ausdruck mit keinem case-Ausdruck übereinstimmt. Wenn kein „default:“-Label vorhanden ist, wird die gesamte switch-Anweisung übersprungen. Im vorherigen Beispiel erscheint das Tag „default:“ am Ende des Schalters, nach allen case-Tags. Dies ist natürlich die sinnvollste und am häufigsten verwendete Schreibweise. Tatsächlich kann das Tag „default:“ an einer beliebigen Stelle innerhalb der Switch-Anweisung platziert werden.
5. Schleife.
Um bedingte Anweisungen zu verstehen, können Sie sich den Code in JavaScript als Verzweigungspfade vorstellen. Eine Schleifenanweisung ist eine Schleife im Programmpfad, die die wiederholte Ausführung eines Teils des Codes ermöglicht. In JavaScript gibt es vier Arten von Schleifenanweisungen: while, do/while, for, for/in. In den folgenden Abschnitten werden sie alle auf einmal erklärt. Die am häufigsten verwendete Schleife ist das Durchlaufen von Array-Elementen (7.6 wird diese Schleife und die spezielle Schleifenmethode, die mithilfe der Array-Klasse definiert wird, ausführlich besprechen.)
i.while
Die if-Anweisung ist eine grundlegende Steueranweisung, mit der die Verzweigungsanweisung des Ausführungsprogramms ausgewählt wird. Wie if ist auch die while-Anweisung eine einfache Schleifenanweisung. Ihre Syntax lautet wie folgt:
Aussage
Bevor die while-Anweisung ausgeführt wird, berechnet der JavaScript-Interpreter zunächst den Wert von expression. Wenn sein Wert falsch ist, überspringt das Programm die logische Anweisung im Schleifenkörper und führt die nächste Anweisung im Programm aus. Wenn der Wert wahr ist, wird die Logik in der Anweisung im Schleifenkörper ausgeführt und dann der Wert von Ausdruck berechnet. Die Schleife wird fortgesetzt, bis der Wert von Ausdruck falsch ist. Mit anderen Worten: Wenn der Ausdruck wahr ist, wird die Anweisung in einer Schleife ausgeführt. Beachten Sie, dass durch die Verwendung von while(true) eine Endlosschleife erstellt wird.
Im Allgemeinen möchten wir nicht, dass Javascript immer wieder denselben Vorgang ausführt. In fast jeder Schleife werden eine oder mehrere Variablen durch die Schleife iteriert. Gerade weil diese Variablen geändert werden, sind auch die Operationen der Anweisung, die jedes Mal in der Schleife ausgeführt werden, unterschiedlich. Wenn die geänderten Variablen im Ausdruck verwendet werden, ist außerdem der Wert des Ausdrucks in jeder Schleife unterschiedlich. Dies ist sehr wichtig. Der Ausdruck, der dafür verantwortlich ist, dass der Anfangswert wahr ist, wird immer wahr sein und die Schleife wird niemals enden. Das folgende Beispiel zeigt die Ausgabe der Werte 0-9.
var count = 0;
while (count < 10) {
console.log(count);
Zählen ;
}
In diesem Beispiel ist der Anfangswert der Variablen count 0. Während der Schleife erhöht sich ihr Wert jedes Mal um 1, wenn die Schleife zehnmal ausgeführt wird. Der Wert des Ausdrucks ist auf „false“ programmiert, dann endet „while“ und der JavaScript-Interpreter führt die nächste Anweisung des Programms aus. Die meisten Schleifen haben eine Zählervariable wie count. Obwohl für Zähler häufig Variablennamen wie i j k verwendet werden, sollten Sie spezifischere Syntaxnamen verwenden, wenn Sie den Code besser lesbar machen möchten.
ii.do/while
Die do/while-Schleife ist der while-Schleife sehr ähnlich, außer dass sie den Schleifenausdruck am Ende der Schleife statt am Anfang testet, was bedeutet, dass der Schleifenkörper mindestens einmal ausgeführt wird. Die Syntax der do/while-Schleife lautet wie folgt:
tun
Aussage
while(expression);
Die do/while-Schleife wird nicht so häufig verwendet wie die while-Schleife. Dies liegt daran, dass es in der Praxis unüblich ist, dass eine Schleife mindestens einmal ausgeführt werden soll. Unten finden Sie ein Beispiel für eine do/while-Schleife
Funktion printArray(a) {
var len = a.length,
i = 0;
Wenn (len == 0)
console.log("empty array");
Sonst <<> tun {
console.log(a[i]);
} while ( i < len);
}
printArray([1,5,2,6])
Es gibt zwei Syntaxunterschiede zwischen do/while-Schleifen und gewöhnlichen while-Schleifen. Erstens erfordert die do-Schleife das Schlüsselwort do, um den Anfang der Schleife zu markieren, und die Variable while, um das Ende der Schleife zu markieren und die Beurteilung der Schleifenbedingung einzugeben. Zweitens endet die do-Schleife im Gegensatz zur while-Schleife mit a Semikolon. Wenn der Körper der while-Schleife in geschweifte Klammern eingeschlossen ist, endet die while-Schleife nicht mit einem Semikolon.
iii.für
Die for-Anweisung bietet eine praktischere Struktur zur Steuerung der Schleifenanweisung als while. Die for-Anweisung vereinfacht einige häufig verwendete Schleifenmuster. Die meisten Schleifen verfügen über spezifische Zählervariablen. Initialisieren Sie diese Variable, bevor die Schleife beginnt, und überprüfen Sie dann ihren Wert vor jeder Schleife. Abschließend wird die Zählervariable inkrementiert, andernfalls wird sie nach Ende der Schleife und vor der nächsten Beurteilung geändert. In dieser Art von Schleife sind die drei Schlüsseloperationen des Zählers Initialisierung, Erkennung und Aktualisierung. Die for-Anweisung deklariert diese drei Operationen explizit als Teil der Schleifensyntax und verwendet jeweils einen Ausdruck, um sie darzustellen. Die Syntax der for-Anweisung lautet wie folgt:
für (initialisieren; testen; erhöhen)
Aussage
Die drei Ausdrücke „Initialisieren“, „Testen“ und „Inkrementieren“ sind durch Semikolons getrennt. Sie sind für Initialisierungsvorgänge, die Beurteilung von Schleifenbedingungen und die Aktualisierung von Zählervariablen verantwortlich. Wenn Sie sie in die erste Zeile der Schleife einfügen, ist es einfacher zu verstehen, was die for-Schleife tut, und verhindert außerdem, dass Sie vergessen, eine Zählervariable zu initialisieren oder zu erhöhen.
Der einfachste Weg, die Funktionsweise einer for-Schleife zu erklären, besteht darin, eine äquivalente while-Schleife aufzulisten
initialisieren
while (test) {
Aussage
inkrementieren;
}
Mit anderen Worten: Der Initialisierungsausdruck wird nur einmal ausgeführt, bevor die Schleife beginnt. Der Initialisierungsausdruck sollte einen Nebeneffekt haben (normalerweise eine Zuweisungsanweisung). JavaScript ermöglicht auch Initialisierungsausdrücke mit var-Variablendeklarationsanweisungen, sodass eine Variable deklariert und initialisiert werden kann. Der Testausdruck wird vor jeder Schleife ausgeführt und das Ergebnis des Ausdrucks wird beurteilt, um zu bestimmen, ob der Schleifenkörper ausgeführt werden soll. Vor jeder Schleife wird der Testausdruck ausgeführt und sein Ergebnis wird als Ausführung des Schleifenkörpers beurteilt. Wenn das Testergebnis wahr ist, wird die Anweisung im Schleifenkörper ausgeführt. Abschließend wird der Inkrementausdruck ausgeführt. Um nützlich zu sein, muss der Inkrementausdruck hier auch Nebenwirkungen haben. Im Allgemeinen handelt es sich entweder um einen Zuweisungsausdruck oder um einen Ausdruck, der aus den Operatoren „ “ und „--“ besteht.
Die obige while-Schleife kann mit einer for-Schleife geschrieben werden
for (var count = 0; count < 10; count )
console.log(count)
Natürlich sind einige Schleifen komplexer und umfassen mehrere Variablen, die gleichzeitig durchlaufen werden. In JavaScript muss in dieser Situation der Kommaoperator verwendet werden, der den Initialisierungsausdruck und den Inkrementierungsausdruck in einem Ausdruck zur Verwendung in einer for-Schleife kombiniert.
var i, j;
für (i = 0, j = 10; i < 10; i , j--)
console.log(i * j);
Bisher waren die Schleifenvariablen im Beispielcode alle Zahlen. Zahlen werden natürlich am häufigsten verwendet, sind aber nicht erforderlich. Der folgende Code verwendet eine for-Schleife, um die Tabellendatenergebnisse zu durchlaufen und das letzte Objekt in der verknüpften Liste zurückzugeben (d. h. das erste Objekt, das das nächste Attribut nicht enthält)
function tail(o) { //Das letzte Knotenobjekt der verknüpften Liste zurückgeben
for (; o.next; o = o.next) /*empty*/ //Traversal basierend auf der Beurteilung ausführen, ob o.next ein wahrer Wert ist
return o;
}
Es ist zu beachten, dass dieser Code nicht den Initialisierungsausdruck enthält. Einer und einer der drei Ausdrücke in der for-Schleife können ignoriert werden, die beiden Semikolons sind jedoch unerlässlich. Wenn der Testausdruck weggelassen wird, handelt es sich um eine Endlosschleife. Ähnlich wie beim Typ while(ture) ist for(;;) eine Möglichkeit, eine Endlosschleife zu schreiben.
iiii.for/in
Die for/in-Anweisung verwendet das for-Schlüsselwort, es handelt sich jedoch um einen anderen Schleifentyp als die reguläre for-Schleife. Die Syntax der for/in-Schleife lautet wie folgt
für (Variable im Objekt)
Aussage
Variable ist normalerweise ein Variablenname oder kann ein Ausdruck sein, der einen L-Wert oder eine über die var-Anweisung deklarierte Variable erzeugen kann. Kurz gesagt handelt es sich um einen Wert, der für die linke Seite des Zuweisungsausdrucks gilt. Objekt ist ein Ausdruck, und das Ergebnis dieses Ausdrucks ist ein Objekt. Ebenso ist eine Anweisung eine Anweisung oder ein Anweisungsblock, der den Hauptteil einer Schleife bildet.
Es ist sehr einfach, mithilfe einer for-Schleife über Array-Elemente zu iterieren
var a = [1, 3, 5, "44"];
for (var i = 0; i < a.length; i ) //i stellt den Index des Array-Elements
dar console.log(a[i]) //Die Elemente jedes Arrays ausgeben
Die for/in-Schleife wird verwendet, um Objektmitgliedsattribute bequem zu durchlaufen
for (var p in o) // Weisen Sie der Variablen p den Namen des Attributs zu
console.log(o[p]); //den Wert jedes Attributs ausgeben
Während der Ausführung der for/in-Anweisung wertet der JavaScript-Interpreter zunächst den Objektausdruck aus. Wenn der Ausdruck null oder undefiniert ist, überspringt der JavaScript-Interpreter die Schleife und führt den nachfolgenden Code aus. Wenn der Ausdruck einem Grundwert entspricht, wird der Grundwert in das entsprechende Waxer-Objekt konvertiert (Abschnitt 3.6). Andernfalls ist der Ausdruck selbst bereits ein Objekt. JavaScript listet die Eigenschaften des Objekts der Reihe nach auf, um die Schleife auszuführen. Vor jeder Schleife wertet JavaScript jedoch den Variablenausdruck aus und weist ihm den Eigenschaftsnamen (eine Zeichenfolge) zu.
Es ist zu beachten, dass der Wert der Variablen in einer for/in-Schleife als L-Wert des Zuweisungsausdrucks verwendet werden kann und es sich dabei um einen beliebigen Ausdruck handeln kann. Dieser Ausdruck wird bei jedem Schleifendurchlauf ausgewertet, was bedeutet, dass er bei jedem Schleifendurchlauf einen anderen Wert ergeben kann. Sie können beispielsweise den folgenden Code verwenden, um alle Objekteigenschaften in ein Array zu kopieren:
var o = {x: 1,y: 2,z: 3};
var a = [],i = 0;
für (a[i ] in o) /*empty*/;
document.write(a)//=> x,y,z
Javascript-Arrays sind nur eine besondere Art von Objekten, daher können for/in-Schleifen Datenindizes genau wie Objekteigenschaften aufzählen. Wenn Sie diesen Code beispielsweise nach dem obigen Code hinzufügen, können Sie den Datenindex 0,1,2:
aufzählenvar o = {x: 1,y: 2,z: 3};
var a = [],i = 0;
für (a[i ] in o) /*empty*/;
document.write(a)//=> for(i in a)
document.write(i) //=>Enumeration data index 0 1 2
Tatsächlich durchläuft die for/in-Schleife nicht alle Eigenschaften des Objekts, sondern nur die „aufzählbaren“ Eigenschaften (siehe 6.7). Weil die durch den Kern der JavaScript-Sprache definierten integrierten Methoden nicht „aufzählbar“ sind. Beispielsweise verfügen alle Objekte über toString(), aber die for/in-Schleife zählt die toString()-Eigenschaft nicht auf. Zusätzlich zu den integrierten Methoden gibt es viele integrierte Objekteigenschaften, die nicht aufzählbar (nicht nummerierbar) sind. Alle im Code definierten Eigenschaften und Methoden sind aufzählbar (wir werden in Abschnitt 6.7 darüber sprechen, aber ECMAScript5 verfügt über spezielle Mittel, um Eigenschaften nicht aufzählbar zu machen).
Objekte können die Eigenschaften anderer Objekte erben, und die Zeile der geerbten benutzerdefinierten Eigenschaften (6.2.ii) kann auch mit for/in aufgezählt werden.
Wenn der for/in-Schleifenkörper ein Attribut löscht, das noch nicht aufgezählt wurde, wird dieses Attribut nicht mehr aufgezählt. Wenn der Schleifenkörper neue Eigenschaften des Objekts definiert, werden diese Eigenschaften normalerweise nicht aufgezählt (einige Implementierungen von JavaScript können jedoch im Schleifenkörper hinzugefügte Eigenschaften aufzählen).
Reihenfolge der Attributaufzählung
Die ECMAScript-Spezifikation gibt nicht die Reihenfolge an, in der for/in-Schleifen die Eigenschaften eines Objekts aufzählen. Tatsächlich zählt die JavaScript-Implementierung gängiger Browserhersteller jedoch die Eigenschaften einfacher Objekte in der Reihenfolge auf, in der sie definiert sind, wobei zuerst definierte Eigenschaften zuerst aufgezählt werden. Wenn Sie ein Objekt in Form eines Objektliterals erstellen, werden die Eigenschaften im Literal in der Reihenfolge aufgelistet, in der sie erscheinen. (Einige Websites und JavaScript-Bibliotheken basieren auf dieser Aufzählungsreihenfolge, und die meisten Browserhersteller ändern diese Reihenfolge nicht. In den folgenden Fällen hängt die Aufzählungsreihenfolge von der spezifischen Implementierung ab (nicht interaktiv)
1. Das Objekt erbt aufzählbare Eigenschaften
2. Das Objekt hat Eigenschaften
mit einem ganzzahligen Array-Index
3. Verwenden Sie „Löschen“, um vorhandene Attribute des Objekts zu löschen
4. Verwenden Sie Object.defineProperty() oder ähnliche Methoden, um die Objekteigenschaften
6. Springen
Der erste Anweisungstyp in JavaScript ist eine Sprunganweisung. Aus dem Verständnis der Anweisung kann es dazu führen, dass die Javascript-Ausführung von einer Position zur anderen springt.
Die break-Anweisung springt zum Ende einer Schleife oder einer anderen Anweisung. Die continue-Anweisung beendet die Ausführung dieser Schleife und startet die Ausführung der nächsten Schleife. Anweisungen in JavaScript können benannt oder beschriftet werden, und break und continue können Zielschleifen oder andere Anweisungsbezeichnungen identifizieren.
Die Return-Anweisung ermöglicht es dem Interpreter, aus der Ausführung des Funktionskörpers herauszuspringen. Und geben Sie den Rückgabewert dieses Aufrufs an. Die throw-Anweisung löst eine Ausnahme aus oder löst sie aus. Sie wird zusammen mit try/catch/finally-Anweisungen verwendet, die die Codelogik für die Behandlung von Ausnahmen angeben. Dies ist eine komplexe Sprunganweisung. Wenn eine Ausnahme ausgelöst wird, springt das Programm zum nächstgelegenen geschlossenen Ausnahme-Stern. Dieses Ausnahmeprogramm kann sich in derselben Funktion oder in einem übergeordneten Aufrufstapel befinden.
Beschreiben Sie als Nächstes jede Art von Sprunganweisung
i. Tag-Anweisung
Anweisungen können mit einem Label versehen werden. Das Label besteht aus einem Bezeichner und einem Doppelpunkt vor der Anweisung:
bezeichner:Anweisung
Durch die Definition einer Bezeichnung für eine Anweisung können Sie die Anweisung über den Bezeichnungsnamen an einer beliebigen Stelle im Programm referenzieren. Beschriftungen können für mehrere Anweisungen definiert werden. Sie sind jedoch nützlicher, wenn Beschriftungen für Anweisungsblöcke definiert werden, z. B. Schleifen oder Bedingungen. Indem Sie einen Label-Namen für die Schleife definieren, können Sie innerhalb des Schleifenkörpers „break“ und „continue“ verwenden, um die Schleife zu verlassen oder direkt den Start der nächsten Schleife anzufordern. break und continue sind die einzigen Anweisungen in JavaScript, die Anweisungsbezeichnungen verwenden können (wird als nächstes in diesem Kapitel besprochen). Im folgenden Beispiel definiert die while-Schleife eine Bezeichnung und die continue-Anweisung verwendet diese Bezeichnung:
mainloop: while (token != null) {
//Diesen Code ignorieren...
Mapoop fortsetzen; // zur nächsten Schleife springen
//Ignoriere den Code hier...
}
Der hier als Tag verwendete Bezeichner muss ein zulässiger JavaScript-Bezeichner sein, kein reserviertes Wort. Der Namensraum einer Bezeichnung unterscheidet sich vom Namensraum einer Variablen oder Funktion, sodass Sie denselben Bezeichner als Anweisungsbezeichnung und als Variablen- oder Funktionsnamen verwenden können. Eine Anweisungsbezeichnung wird nur innerhalb der Anweisung definiert, auf die sie einwirkt (oder natürlich innerhalb ihrer Klauseln). Eine Anweisungsbeschriftung darf nicht denselben Namen wie ihre interne Anweisungsbeschriftung haben, es können jedoch Anweisungsbeschriftungen mit demselben Namen erscheinen, wenn die beiden Codes nicht ineinander verschachtelt sind. Beschriftete Anweisungen können auch beschriftet werden, d. h. jede Anweisung kann viele Beschriftungen haben.
ii.break
Die alleinige Verwendung der Break-Anweisung besteht darin, die Schleife oder Switch-Anweisung mit dem meisten Speicher sofort zu verlassen. Die Syntax lautet wie folgt:
Pause;
Da es dazu führen kann, dass Schleifen und Switch-Anweisungen beendet werden, ist diese Form von break nur in solchen Anweisungen zulässig.
Wir haben die break-Anweisung bereits im Beispiel der switch-Anweisung gesehen. Wenn Sie in einer Schleife aus irgendeinem Grund nicht mit der Ausführung der gesamten Schleife fortfahren möchten, können Sie mit break vorzeitig beenden. Wenn die Schleifenbeendigungsbedingung sehr komplex ist, ist es viel einfacher, die Break-Anweisung im Funktionskörper zu verwenden, um solche bedingten Beurteilungen zu implementieren, als die komplexe Beendigungsbedingung direkt in den Schleifenausdruck zu schreiben.
Im folgenden Beispiel durchläuft die Schleife die gesamten Array-Elemente, um einen bestimmten Wert zu finden. Wenn der gesamte Array-Durchlauf abgeschlossen ist, wird die Schleife normal beendet. Wenn das zu findende Array-Element gefunden wird, verwenden Sie zum Beenden die break-Anweisung die Schleife:
für (var i = 0; i < a.length; i ) {
If (a[i] == target) break;
}
JavaScript ermöglicht auch, dass dem Schlüsselwort „break“ eine Anweisungsbezeichnung folgt (nur Bezeichner, kein Doppelpunkt)
break labelname;
Wenn break zusammen mit einem Label verwendet wird, springt das Programm zum Ende des durch das Label identifizierten Anweisungsblocks oder beendet direkt die Ausführung des geschlossenen Anweisungsblocks. Ein Syntaxfehler tritt auf, wenn kein umschließender Anweisungsblock vorhanden ist, der eine Bezeichnung für break angibt. Wenn Sie diese Form einer Break-Anweisung verwenden, sollte die gekennzeichnete Anweisung keine Schleife oder Switch-Anweisung sein, da die Break-Anweisung aus jedem umschließenden Anweisungsblock „herausspringen“ kann. Die Anweisung hier kann eine Gruppe von Anweisungen sein, die durch geschweifte Klammern gruppiert sind und dieselbe Bezeichnung verwenden, um eine Gruppe von Anweisungen zu identifizieren.
Zwischen dem Schlüsselwort „break“ und dem Labelnamen darf kein Zeilenumbruch stehen. Da JavaScript ausgelassene Semikolons für Anweisungen automatisch vervollständigen kann, geht der JavaScript-Interpreter davon aus, dass Sie die einfachste Form von break ohne Labels verwenden, wenn zwischen dem Schlüsselwort break und der Beschriftung ein Zeilenumbruch steht, und fügt nach break ein Semikolon ein.
Wenn Sie aus einer nicht in der Nähe befindlichen Schleife oder einer Switch-Anweisung ausbrechen möchten, verwenden Sie eine beschriftete Break-Anweisung. Hier ist der Beispielcode:
var matrix = getData(); // Holen Sie sich ein zweidimensionales Array von irgendwoher
//Summiere alle Elemente in der Matrix
var sum = 0,
success = false;
//Beginnen Sie mit der Signatur, um das Programm zu starten, wenn ein Fehler gemeldet wird.
Compure_sum: if (Matrix) {
für (var x = 0; x < Matrix.Länge; x ) {
var row = matrix[x];
Wenn (!Zeile) brichtcomputer_sum;
for (var y = 0; y < row.length; y ) {
var cell = row[y];
Wenn (isNaN(Zelle)) break compress_sum;
Summe = Zelle;
}
}
success = true;
}
//break-Anweisung springt hierher
//Wenn die Bedingung success =false hier ankommt, bedeutet das, dass in der von uns angegebenen Matrix ein Fehler vorliegt
//Andernfalls summiere alle Elemente in der Matrix
Abschließend ist zu beachten, dass die Steuerung der Break-Anweisung unabhängig davon, ob sie beschriftet ist oder nicht, die Grenzen der Funktion nicht überschreiten kann. Beispiel: Bei einer Funktionsdefinitionsanweisung mit einer Bezeichnung können Sie diese Bezeichnung nicht verwenden, um durch das Innere der Funktion zur Außenseite der Funktion zu springen.
iii.Fortsetzungserklärung
Die continue-Anweisung ist der break-Anweisung sehr ähnlich, verlässt jedoch nicht die Schleife, sondern führt stattdessen die nächste Schleife aus. Die Syntax der continue-Anweisung ist genauso einfach wie die Syntax der break-Anweisung
weiter;
Die continue-Anweisung enthält auch Tags
weiter lebname;
Unabhängig davon, ob die continue-Anweisung eine Bezeichnung hat oder nicht, kann sie nur im Schleifenkörper verwendet werden. Bei Verwendung an anderer Stelle wird ein Syntaxfehler gemeldet.
Wenn die Continue-Anweisung ausgeführt wird, wird die aktuelle Schleifenlogik beendet und die nächste Schleife sofort ausgeführt. Bei verschiedenen Schleifentypen ist das Verhalten von Continue ebenfalls unterschiedlich
1. In der while-Schleife wird der angegebene Ausdruck am Anfang der Schleife wiederholt getestet. Wenn das Testergebnis wahr ist, wird der Schleifenkörper von Anfang an ausgeführt.
2. In der do/while-Schleife springt die Ausführung des Programms zum Ende der Schleife. Zu diesem Zeitpunkt wird die Schleifenbedingung erneut beurteilt, bevor mit der nächsten Schleife fortgefahren wird.
3. In der for-Schleife wird zunächst der Autoinkrement-Ausdruck berechnet und dann der Testausdruck erkannt, um zu bestimmen, ob der Schleifenkörper ausgeführt werden soll.
4. In der for/in-Schleife beginnt die Schleife, den nächsten Attributnamen zu durchlaufen, der der angegebenen Variablen zugewiesen ist.
Sie müssen auf den Unterschied zwischen der continue-Anweisung in while- und for-Schleifen achten. Die while-Schleife geht direkt in die nächste Runde der Schleifenbedingungsbeurteilung über, aber die for-Schleife berechnet zuerst den Inkrementierungsausdruck und beurteilt dann die Schleifenbedingung . Im vorherigen Kapitel wurde das „äquivalente“ Verhalten einer for-Schleife zu einer while-Schleife besprochen. Da sich continue in diesen beiden Schleifen jedoch unterschiedlich verhält, ist es unmöglich, die entsprechende for-Schleife mithilfe einer while-Schleife perfekt zu simulieren.
Der folgende Code zeigt die continue-Anweisung ohne Beschriftung, die bei Auftreten eines Fehlers die nachfolgende Logik der aktuellen Schleife überspringt
für (i = 0; i < data.length; i ) {
If (!data[i]) continue; //Undefinierte Daten können nicht verarbeitet werden
total = data[i];
}
Ähnlich wie die break-Anweisung kann die beschriftete continue-Anweisung in verschachtelten Schleifen verwendet werden, um aus der hierarchisch verschachtelten Schleifenkörperlogik herauszuspringen. Ähnlich wie bei der break-Anweisung darf zwischen der continue-Anweisung und labname kein Zeilenumbruch stehen.
iiii.return
Denken Sie daran, dass ein Funktionsaufruf ein Ausdruck ist und alle Ausdrücke Werte haben. Die Return-Anweisung in einer Funktion bezieht sich auf den Rückgabewert nach dem Funktionsaufruf. Hier ist die Syntax der Return-Anweisung:
Rückgabeausdruck;
Die Return-Anweisung kann nur im Funktionskörper erscheinen. Andernfalls wird ein Syntaxfehler gemeldet. Wenn die Return-Anweisung ausgeführt wird, beendet die Funktion die Ausführung und gibt den Wert von expression an das aufrufende Programm zurück. Zum Beispiel:
function quadrat(x) {return x * x} //Eine Anweisungsfunktion, die return
enthält quadrat(4) //Die Ausführung ist 16
Wenn keine Return-Anweisung vorhanden ist, führt der Funktionsaufruf nur jede Anweisung im Funktionskörper der Reihe nach bis zum Ende der Funktion aus und kehrt schließlich zum aufrufenden Programm zurück. In diesem Fall ist das Ergebnis des Aufrufs des Ausdrucks undefiniert. Die Return-Anweisung erscheint oft als letzte Anweisung in einer Funktion, aber das bedeutet nicht unbedingt, dass sie am Ende der Funktion platziert werden muss, selbst wenn bei der Ausführung der Return-Anweisung viel Code vorhanden ist , kehrt die Funktion weiterhin zum aufrufenden Programm zurück.
Die return-Anweisung kann auch alleine ohne Ausdruck verwendet werden. In diesem Fall möchte die Funktion auch das Programm aufrufen und undefiniert zurückgeben
If (!o) return;
// Andere Logik
Die sogenannte Ausnahme (Excepion) ist ein Signal, das generiert wird, wenn eine ungewöhnliche Situation oder ein Fehler auftritt. Das Auslösen einer Ausnahme bedeutet, dass signalisiert wird, dass ein Fehler oder eine abnormale Bedingung aufgetreten ist. Das Abfangen einer Ausnahme bedeutet, das Signal zu verarbeiten und eine Ausnahme auszulösen, d. h. ein Signal zu verwenden, um zu benachrichtigen, dass ein Fehler oder eine abnormale Situation aufgetreten ist. Das Abfangen einer Ausnahme bezieht sich auf die Verarbeitung dieses Signals, d. h. auf das Ergreifen der erforderlichen Maßnahmen zur Wiederherstellung nach der Ausnahme. In JavaScript wird eine Ausnahme explizit ausgelöst, wenn ein Laufzeitfehler auftritt oder wenn das Programm die throw-Anweisung verwendet. Ausnahmen können mit try/catch/finally-Anweisungen abgefangen werden, die im nächsten Abschnitt ausführlich vorgestellt werden.
Die Syntax der throw-Anweisung lautet wie folgt:
Ausdruck werfen
Der Wert des Ausdrucks kann beliebiger Art sein. Kann ein Array mit Fehlercodes oder eine Zeichenfolge mit einer Fehlermeldung auslösen. Wenn der JavaScript-Interpreter eine Ausnahme auslöst, verwendet er normalerweise den Typ Eeeor oder seine Untertypen, sie können jedoch auch verwendet werden. Ein Fehlerobjekt verfügt über eine bekannte Darstellung des Fehlertyps und ein Nachrichtenattribut, das zur Übergabe der Zeichenfolge an den Konstruktor verwendet wird (siehe die Error-Klasse in Teil 3). Im folgenden Beispiel wird ein Fehler ausgelöst, wenn die Funktion mit illegal aufgerufen wird Parameter. Objekt:
In Verbindung stehende Artikel
Mehr sehen- Eine eingehende Analyse der Bootstrap-Listengruppenkomponente
- Detaillierte Erläuterung des JavaScript-Funktions-Curryings
- Vollständiges Beispiel für die Generierung von JS-Passwörtern und die Erkennung der Stärke (mit Download des Demo-Quellcodes)
- Angularjs integriert WeChat UI (weui)
- Wie man mit JavaScript schnell zwischen traditionellem Chinesisch und vereinfachtem Chinesisch wechselt und wie Websites den Wechsel zwischen vereinfachtem und traditionellem Chinesisch unterstützen – Javascript-Kenntnisse