Die vorherigen Wörter
Die Fehlerbehandlung ist für die Entwicklung von Webanwendungen von entscheidender Bedeutung. Es kann mögliche Fehler im Voraus nicht vorhersagen, und Wiederherstellungsstrategien können nicht im Voraus angenommen werden, was zu einer schlechten Benutzererfahrung führen kann. Da ein JavaScript -Fehler dazu führen kann, dass die Webseite als Entwickler unbrauchbar ist, müssen Sie wissen, wann, warum und was passieren wird. In diesem Artikel wird der Fehlerbehandlungsmechanismus in JavaScript im Detail vorgestellt
Fehlerobjekt
Das Fehlerobjekt ist ein Objekt, das Fehlerinformationen enthält und ein nationales Objekt von JavaScript. Wenn während des Code -Parsens oder -ausgangs ein Fehler auftritt, generiert und wirft die JavaScript -Engine automatisch eine Instanz des Fehlerobjekts, und dann wird das gesamte Programm unterbrochen, wenn der Fehler auftritt.
console.log (t); // Uncornd ReferenceError: T ist nicht definiert
ECMA-262 Gibt an, dass ein Fehlerobjekt zwei Eigenschaften enthält: Nachricht und Name. Das Nachrichtenattribut speichert die Fehlermeldung, während das Namensattribut den Fehlertyp speichert
Die Codekopie lautet wie folgt:
// Verwenden Sie im Allgemeinen die Anweisung Try-Catch, um Fehler zu fangen
versuchen{
T;
} catch (ex) {
console.log (ex.Message); // t ist nicht definiert
console.log (ex.name); // referenceError
}
Der Browser hat auch die Eigenschaften des Fehlerobjekts erweitert und andere relevante Informationen hinzugefügt. Unter ihnen ist das von Browserherstellern am meisten implementierte Stapelattribut, das auf Stack Trace -Informationen hinweist (Safari unterstützt es nicht).
Die Codekopie lautet wie folgt:
versuchen{
T;
} catch (ex) {
console.log (ex.stack); //@file: /// d: /wamp/www/form.html: 12: 2
}
Natürlich können Sie den Fehler () -Ronstruktor verwenden, um ein Fehlerobjekt zu erstellen. Wenn der Meldungsparameter angegeben ist, verwendet das Fehlerobjekt ihn als Nachrichteneigenschaft. Wenn nicht angegeben, wird eine vordefinierte Standardzeichenfolge als Wert der Eigenschaft verwendet
Die Codekopie lautet wie folgt:
neuer Fehler ();
neuer Fehler (Nachricht);
// Verwenden Sie im Allgemeinen Wurfanweisung, um Fehler zu werfen
Neuen Fehler werfen ('Test'); // Unbekundeter Fehler: Test
Werfen Sie einen neuen Fehler (); // Unkundungsverzerrten Fehler
Die Codekopie lautet wie folgt:
Funktion UserError (Nachricht) {
this.message = message;
this.name = "userError";
}
UserError.Prototype = new error ();
UserError.Prototype.Constructor = userError;
Neue UserError werfen ("ErrorMessage";
Wenn der Erressungskonstruktor als direkt wie eine Funktion genannt wird, ohne den neuen Bediener zu verwenden
Die Codekopie lautet wie folgt:
Fehler();
Fehler (Nachricht);
Wurffehler ('Test'); // Unbekundeter Fehler: Test
Wurf errät (); // Uncorned Fehler
Das Fehlerobjekt hat eine toString () -Methode, die das Nachrichtenattribut des Fehlerobjekts zurückgibt.
Die Codekopie lautet wie folgt:
var test = neuer Fehler ('testError');
console.log (test.toString ()); // 'fehler: testError' '
Fehlertyp
Es gibt viele Arten von Fehlern, die während der Codeausführung auftreten können. Jeder Fehler hat einen entsprechenden Fehlertyp, und wenn ein Fehler auftritt, wird ein Fehlerobjekt des entsprechenden Typs geworfen. ECMA-262 definiert die folgenden 7 Fehlertypen:
Die Codekopie lautet wie folgt:
Fehler
EvalError (Eval -Fehler)
RangeError (RHREEREGROR)
ReferenzError (Referenzfehler)
SyntaxError (Syntaxfehler)
TypeError (Typ Fehler)
Urierror (URI -Fehler)
Wo, Fehler ist der Basistyp und andere Fehlertypen werden von diesem Typ geerbt. Daher teilen alle Fehlertypen einen Satz derselben Eigenschaften. Fehlertypfehler sind selten, und wenn es vorhanden ist, werden sie auch vom Browser geworfen. Der Hauptzweck dieses Basistyps besteht darin, dass Entwickler benutzerdefinierte Fehler werfen
【EvalError (Eval -Fehler)】
Wenn die Eval -Funktion nicht korrekt ausgeführt wird, wird ein EvalErrorfehler geworfen. Dieser Fehlertyp erscheint nicht mehr in ES5, wird jedoch weiterhin erhalten, um die Kompatibilität mit früheren Codes sicherzustellen.
【RangeError (RangeError)】
Ein Fehler des RF -Typs wird ausgelöst, wenn ein Wert den entsprechenden Bereich überschreitet.
Die Codekopie lautet wie folgt:
Neuarray (-1); // Uncortn RangeError: Ungültige Arraylänge
Neuarray (number.max_value); // Uncortn RangeRror: Ungültige Arraylänge
.
.
【ReferenzError (Referenzfehler)】
ReferenzError wird ausgelöst, wenn sie sich auf einen extremen Variablen- oder LVALUE -Fehler beziehen.
a; // Uncornt ReferenceError: a ist nicht definiert
1 ++; // Uncornt ReferenceError: Ungültiger Ausdruck der linken Seite in der Postfix-Operation
【SyntaxError (syntaxError)】
Wenn die Syntaxregeln nicht erfüllt sind, wird ein SyntaxError geworfen (Syntaxfehler)
Die Codekopie lautet wie folgt:
// Der variable Name ist falsch
var 1a; // UnkundungssyntaxEerror: Unerwartete Zahl
// fehlende Klammern
console.log 'hello'); // Uncornt SyntaxError: Unerwartete Zeichenfolge
【TypeError (Typ Fehler)】
Der Fehlertyp-Fehler wird verursacht, wenn unerwartete Typen in Variablen gespeichert sind oder bei nicht existierenden Methoden. Obwohl die Ursachen von Fehlern vielfältig sind, entspricht dies letztendlich, weil die Art der Variablen bei der Durchführung einer bestimmten Operationsart nicht den Anforderungen entspricht.
Die Codekopie lautet wie folgt:
var o = new 10; // Uncortn TypeError: 10 ist kein Konstruktor
alert ('name' in true); // Unkaugert TypeError: Kann in 'Operator nicht verwendet werden, um nach' Name 'in True zu suchen
Function.prototype.toString.call ('Name'); // Uncortn TypeError: function.Prototype.toString ist nicht generisch
【Urierror (URI -Fehler)】
Urierror ist ein Fehler, wenn die Parameter von URI-bezogenen Funktionen falsch sind. Es handelt sich hauptsächlich um sechs Funktionen: codeuri (), decodeuri (), encodeuricomponent (), decodeuricomponent (), Escape () und uneisem ().
decodeuri ('%2'); // Urierror: URI missgebildet
Fehlerereignis
Alle Fehler, die nicht über Try-Catch verarbeitet werden
Das Fehlerereignis kann drei Parameter empfangen: Fehlermeldung, URL, bei dem sich der Fehler befindet, und Zeilennummer. In den meisten Fällen sind nur Fehlermeldungen nützlich, da die URL nur den Speicherort des Dokuments angibt und die Zeilennummer auf eine Codezeile bezieht, die aus dem eingebetteten JavaScript -Code oder aus einer externen Datei stammen kann.
Um einen Fehlerereignishandler anzugeben, können Sie die DOM0 -Technologie verwenden oder das Standardformat von Ereignissen auf DOM2 -Ebene verwenden
Die Codekopie lautet wie folgt:
// DOM0 -Ebene
window.onError = Funktion (Nachricht, URL, Zeile) {
alarm (Nachricht);
}
// DOM2 -Ebene
window.addeventListener ("Fehler", Funktion (Nachricht, URL, Zeile) {
alarm (Nachricht);
});
Ob der Browser eine Standardfehlermeldung anzeigt, hängt vom Rückgabewert von OnError ab. Wenn der Rückgabewert falsch ist, wird in der Konsole eine Fehlermeldung angezeigt. Wenn der Rückgabewert zutrifft, wird er nicht angezeigt
Die Codekopie lautet wie folgt:
// Konsole zeigt die Fehlermeldung an
window.onError = Funktion (Nachricht, URL, Zeile) {
alarm (Nachricht);
false zurückgeben;
}
A;
// Die Konsole zeigt keine Fehlermeldung an
window.onError = Funktion (Nachricht, URL, Zeile) {
alarm (Nachricht);
zurückkehren;
}
A;
Dieser Ereignis -Handler ist die letzte Verteidigungslinie, um die Meldung von Browsermeldungen zu vermeiden. Idealerweise sollten Sie es nicht nach Möglichkeit verwenden. Solange Sie die Try-Catch-Anweisung angemessen verwenden können, gibt es keine Fehler, die dem Browser übergeben werden, und das Fehlerereignis wird nicht ausgelöst.
Das Bild unterstützt auch Fehlerereignisse. Solange die URL in der SRC -Eigenschaft des Bildes das erkannte Bildformat nicht zurückgeben kann, wird ein Fehlerereignis ausgelöst. Zu diesem Zeitpunkt folgt das Fehlerereignis dem DOM -Format und gibt ein Ereignisobjekt zurück, das auf das Bild als Ziel abzielt
Ein Warnbox wird angezeigt, wenn das Bild geladen wird. Wenn ein Fehlerereignis auftritt, ist der Bild -Download -Prozess beendet, was bedeutet, dass er nicht erneut heruntergeladen werden kann.
Die Codekopie lautet wie folgt:
var image = new Image ();
Image.src = 'Smilex.gif';
Image.onError = Funktion (e) {
console.log (e);
}
Anweisung werfen und Fehler werfen
Die Wurfanweisung wird verwendet, um einen Fehler zu werfen. Wenn ein Fehler geworfen wird, müssen Sie einen Wert für die Wurfanweisung angeben. Welchen Typ ist dieser Wert? Es gibt keine Anforderung.
[Hinweis] Der Prozess des Fehlers eines Fehlers ist blockiert und der nachfolgende Code wird nicht ausgeführt
Die Codekopie lautet wie folgt:
werfen 12345;
Wirf 'Hallo Welt';
werfen wahr;
throw {name: 'javaScript'};
Sie können die Wurfanweisung verwenden, um ein Fehlerobjekt manuell zu werfen
Die Codekopie lautet wie folgt:
Neuen Fehler werfen ('etwas Schlimmes passiert');
Wirf eine neue SyntaxEerror ('Ich mag deine Syntax nicht.');
Werfen Sie neue TypenError ("Welche Art von Variable nehmen Sie mich auf?");
Wirf neuer Rangeerror ('Entschuldigung, du hast nur nicht die Reichweite.');
neue EvalError werfen ('das wird nicht bewertet.');
Wirf New Urierror ('uri, bist du das?');
Werfen Sie New ReferenceError ("Sie haben Ihre Referenzen nicht richtig angegeben");
Durch die Verwendung von Prototyp -Ketten kann auch benutzerdefinierte Fehlertypen erstellt werden, indem Fehler erben (Prototyp -Ketten werden in Kapitel 6 eingeführt). Zu diesem Zeitpunkt müssen Sie die Namen und Nachrichtenattribute für den neu erstellten Fehlertyp angeben
Der Browser behandelt benutzerdefinierte Fehlertypen, die von Fehler genauso geerbt wurden, genau wie andere Fehlertypen. Das Erstellen eines benutzerdefinierten Fehlers ist nützlich, wenn Sie den Fehler, den Sie werfen, aufnehmen und ihn als den Browserfehler anders behandeln möchten.
Die Codekopie lautet wie folgt:
Funktion CustomError (Nachricht) {
this.name = 'CustomError';
this.message = message;
}
CustomError.Prototype = new error ();
neue CustomError werfen ('meine Nachricht');
Wenn eine Wurfanweisung auftritt, hört der Code sofort auf, sofort auszuführen. Der Code wird weiterhin nur ausgeführt, wenn eine Versuchs-Catch-Anweisung den geworfenen Wert erfasst.
Eine detailliertere Erklärung lautet: Wenn eine Ausnahme ausgelöst wird, wird der JavaScript -Interpreter die derzeit ausgeführte Logik sofort eingestellt und zum nahe gelegenen Ausnahmebehandler springen. Der Ausnahmebehandler ist in der Fangklausel der Versuchserklärung geschrieben. Wenn der Codeblock, der die Ausnahme ausführt, keine zugehörige Fangklausel aufweist, überprüft der Interpreter den geschlossenen Codeblock auf höherer Ebene, um festzustellen, ob er über einen zugehörigen Ausnahmebehandler verfügt. Und so weiter, bis ein Ausnahmebehandler gefunden wird. Wenn die Funktion, die die Ausnahme ausgelegt hat, ihre Anweisung Try-Catch nicht behandelt, wird die Ausnahme nach oben in den Code ausgegeben, der die Funktion aufruft. Auf diese Weise wird die Ausnahme entlang der lexikalischen Struktur der JavaScript -Methode und des Anrufstacks nach oben ausgedehnt. Wenn kein Ausnahmehandler gefunden wird, wird JavaScript die Ausnahme als Programmfehler behandeln und dem Benutzer melden
Versuchen Sie, eine Anweisung zu fangen und Fehler zu fangen
ECMA-262 Edition 3 führt die Anweisung Try-Catch als Standard-Möglichkeit ein, Ausnahmen in JavaScript zu bewältigen, die zum Fangen und Umgang mit Fehlern verwendet werden
Unter ihnen definiert die Try -Klausel den Codeblock, in dem sich die Ausnahmen befinden, die verarbeitet werden müssen. Die Fangklausel folgt der Try -Klausel. Wenn irgendwo im Try -Block eine Ausnahme auftritt, wird die Codelogik im Fang aufgerufen. Auf die Fangklausel folgt der endgültige Block, in dem der Reinigungscode platziert wird. Unabhängig davon, ob eine Ausnahme im Try -Block auftritt, wird die Logik im endgültigen Block immer ausgeführt. Obwohl erfasst und schließlich optional sind, erfordert die Try -Klausel mindestens eine der beiden, um eine vollständige Aussage zu bilden.
Alle Versuche/Catch/End -Anweisungsblöcke müssen mit lockigen Klammern umschlossen sein. Hier sind Zahnspangen erforderlich. Auch wenn nur eine Aussage in der Klausel vorhanden ist, können lockige Klammern nicht weggelassen werden.
versuchen{
// Im Allgemeinen beginnt der Code hier von Anfang bis Ende ohne Probleme
// aber manchmal wird eine Ausnahme ausgelöst, entweder direkt durch die Wurfanweisung oder indirekt durch Aufrufen einer Methode
} catch (e) {
// Wenn und nur wenn eine Ausnahme durch den Block Anweisungsblock ausgelöst wird, wird der Code hier ausgeführt
// Hier können Sie einen Verweis auf das Fehlerobjekt oder andere Werte erhalten, die von der lokalen Variablen e geworfen werden
// Der Codeblock hier kann diese Ausnahme aus irgendeinem Grund verarbeiten oder diese Ausnahme ignorieren und die Ausnahme auch durch die Wurfanweisung wiederwischen
} Endlich{
// Unabhängig davon, ob die Anweisung eine Ausnahme ausgelöst wird, wird die Logik schließlich immer ausgeführt. Die Möglichkeiten zur Beendigung des Try -Anweisung -Blocks sind:
// 1. Normalerweise beenden Sie die letzte Anweisung des Anweisungsblocks
// 2. Kündigen Sie durch Pause, fordern Sie die Anweisung durch
// 3. Wirf eine Ausnahme, die Ausnahme wird von der Fangklausel erfasst
// 4. Wirf eine Ausnahme, die Ausnahme wird nicht erwischt, weiter nach oben propagiert
}
Geben Sie im Allgemeinen den gesamten Code ein, der Fehler in den Block für Try -Anweisungen werfen kann, und legen Sie den Code für Fehlerbehandlung in den Catch -Block ein
Wenn ein Code im Try -Block -Fehler auftritt, wird der Codeausführungsprozess sofort beendet und der Fangblock wird ausgeführt. Zu diesem Zeitpunkt empfängt der Catch -Block ein Objekt mit Fehlermeldung. Die tatsächlichen Informationen, die in diesem Objekt enthalten sind
[Hinweis] Nennen Sie das Fehlerobjekt unbedingt. Wenn Sie es entleeren, wird ein Syntaxfehler gemeldet.
Die Codekopie lautet wie folgt:
versuchen{
Q;
} catch (error) {
alarm (error.message); // q ist nicht definiert
}
// Uncortn SyntaxError: Unerwartetes Token)
versuchen{
Q;
}fangen(){
alert (error.message);
}
Catch akzeptiert einen Parameter, der den von dem Try -Code -Block geworfenen Wert angibt
Die Codekopie lautet wie folgt:
Funktion throwit (Ausnahme) {
versuchen {
Ausnahme werfen;
} catch (e) {
console.log ('gefangen:'+ e);
}
}
throwit (3); // gefangen: 3
Throwit ('Hallo'); // gefangen: Hallo
throwit (neuer Fehler ('ein Fehler passiert'); // gefangen: Fehler: Ein Fehler ist passiert
Nachdem der Catch -Code -Block den Fehler erfasst hat, wird das Programm nicht unterbrochen und wird weiterhin gemäß dem normalen Prozess ausgeführt.
Die Codekopie lautet wie folgt:
versuchen{
"Fehler" werfen;
} catch (e) {
console.log (111);
}
console.log (222);
// 111
// 222
Um verschiedene Arten von Fehlern zu fangen
Die Codekopie lautet wie folgt:
versuchen {
foo.bar ();
} catch (e) {
if (e instanceof evalError) {
console.log (e.name + ":" + e.message);
} else if (e instanceof ravenError) {
console.log (e.name + ":" + e.message);
}
// ...
}
Obwohl die endgültige Klausel in der Anweisung Try-Catch optional ist, wird der Code, sobald die Klausel verwendet wird, unabhängig von welcher Zeit ausgeführt. Mit anderen Worten, der gesamte Code im Try -Anweisung -Block wird normal ausgeführt, und schließlich werden Klauseln ausgeführt. Wenn der Block für Catch -Anweisungen aufgrund eines Fehlers ausgeführt wird, wird die endgültige Klausel weiterhin ausgeführt. Solange der Code endgültig Klauseln enthält, unabhängig davon, welcher Code im Block für Versuch oder Catch -Anweisungen enthalten ist - oder sogar in der Return -Anweisung, wird die Ausführung der endgültigen Klausel nicht verhindert.
Die Codekopie lautet wie folgt:
// Der Fehler wird nicht erfasst, da es keinen Catch -Anweisungsblock gibt. Nach dem Ausführen des endgültigen Codeblocks wird das Programm unterbrochen, wo der Fehler geworfen wird.
Funktion CleanSUp () {
versuchen {
Neuen Fehler werfen ('Fehler ...');
console.log ('Diese Zeile wird nicht ausgeführt');
} Endlich {
console.log ('vollständige Reinigungsarbeiten');
}
}
räumt auf();
// Die Reinigungsarbeiten ausfüllen
// Fehler: Etwas ist schief gelaufen ...
Die Codekopie lautet wie folgt:
Funktion testfinnally () {
versuchen{
Rückkehr 2;
} catch (error) {
Rückkehr 1;
} Endlich{
Rückkehr 0;
}
}
testFinnally (); // 0
[Hinweis] Der Wert der Anzahl der Rückgabeerklärung wird erhalten, bevor der endgültige Codeblock ausgeführt wird.
Die Codekopie lautet wie folgt:
var count = 0;
Funktion countUp () {
versuchen {
Rückgabezahl;
} Endlich {
zählen ++;
}
}
countUp (); // 0
console.log (count); // 1
Die Codekopie lautet wie folgt:
Funktion f () {
versuchen {
console.log (0);
"Bug" werfen;
} catch (e) {
Konsole.log (1);
zurückkehren; // Dieser Satz wäre bis zum Ende des endgültigen Codeblocks vor der Ausführung verzögert worden
console.log (2); // wird nicht laufen
} Endlich {
console.log (3);
false zurückgeben; // Dieser Satz behandelt die vorherige Rückgabe
console.log (4); // wird nicht laufen
}
console.log (5); // wird nicht laufen
}
var result = f ();
// 0
// 1
// 3
console.log (Ergebnis); // false
【Tipps】 Umfang auf Blockebene
Eine gemeinsame Verwendung von Try-Catch-Anweisungen besteht darin, Bereiche auf Blockebene zu erstellen, in denen deklarierte Variablen nur innerhalb des Fangs gültig sind
ES6 führt das LET-Schlüsselwort ein, um einen Bereich auf Blockebene für die von ihm deklarierenden Variablen zu erstellen. In der aktuellen Situation von ES3 und ES5 werden jedoch häufig Try-Catch-Aussagen verwendet, um ähnliche Effekte zu erzielen
Aus dem folgenden Code existiert E nur in der Fangklausel, und ein Fehler wird geworfen, wenn versucht wird, sie von anderen Orten zu verweisen.
Die Codekopie lautet wie folgt:
versuchen{
Werfen Sie einen neuen Fehler (); // über einen Fehler übertreffen
} catch (e) {
console.log (e); // error (…)
}
console.log (e); // Uncornt ReferenceError: E ist nicht definiert
Häufige Fehler
Der Kern der Fehlerbehandlung besteht darin, zuerst zu wissen, welche Fehler im Code auftreten werden. Da JavaScript locker getippt wird und die Parameter der Funktion nicht überprüft, tritt der Fehler nur während des Codes auf. Im Allgemeinen müssen drei Arten von Fehlern beachtet werden: Typ Conversion -Fehler, Datentypfehler und Kommunikationsfehler
【Konvertierungsfehler eingeben】
Der Typ -Konvertierungsfehler tritt bei der Verwendung eines Bedieners oder der Verwendung einer anderen Sprachstruktur von Datentypen auf, die die Werte automatisch umwandeln können.
Die Flow Control -Anweisung neigt dazu, Konvertierungsfehler einzugeben. Aussagen wie If, wodurch der Wert automatisch in einen Booleschen Umbau umgewandelt wird, bevor der nächste Vorgang festgelegt wird. Insbesondere wenn Aussagen, wenn sie nicht ordnungsgemäß verwendet werden, sind sie am wahrscheinlichsten Fehler.
Unbenutzten benannten Variablen werden automatisch undefinierte Werte zugewiesen. Der undefinierte Wert kann in einen booleschen Wert Falsch konvertiert werden. Die IF -Anweisung in der folgenden Funktion gilt also nur für Fälle, in denen der dritte Parameter bereitgestellt wird. Das Problem ist, dass es nicht nur undefiniert ist, in Falsch konvertiert zu werden, und es sind auch nur Stringwerte, die in true konvertiert werden können. Wenn der dritte Parameter beispielsweise der Wert 0 ist, fehl
Die Codekopie lautet wie folgt:
Funktion concat (str1, str2, str3) {
var result = str1 + str2;
if (str3) {// absolut nicht so
Ergebnis += str3;
}
Rückgabeergebnis;
}
Die Verwendung von Nicht-Boolen-Werten in Durchflusssteuerungsanweisungen ist eine äußerst häufige Fehlerquelle. Um solche Fehler zu vermeiden, muss bei verglichenen Bedingungen in Booleschen Werten bestehen. In der Tat kann die Durchführung einer Vergleichsform dies erreichen
Die Codekopie lautet wie folgt:
Funktion concat (str1, str2, str3) {
var result = str1 + str2;
if (typeof str3 == 'String') {// besser geeigneter
Ergebnis += str3;
}
Rückgabeergebnis;
}
【Datentypfehler】
JavaScript wird locker getippt und wird nicht verglichen, um sicherzustellen, dass ihr Datentyp korrekt ist, bis Variablen und Funktionsparameter verwendet werden. Um sicherzustellen, dass keine Datentypfehler auftreten, können nur geeigneter Datentyp -Erkennungscode geschrieben werden. Datentypfehler treten am wahrscheinlichsten auf, wenn unerwartete Werte an Funktionen übergeben werden
Die Codekopie lautet wie folgt:
// Unsichere Funktionen, jeder Nicht-Array-Wert verursacht Fehler
Funktion Reverseort (Werte) {
if (Werte) {
values.sort ();
Werte.Reverse ();
}
}
Ein weiterer häufiger Fehler besteht darin, Parameter mit Nullwerten zu vergleichen. Der Vergleich mit Null stellt nur sicher, dass die entsprechenden Werte nicht null und undefiniert sind. Um sicherzustellen, dass der übergebene Wert gültig ist, reicht er nicht aus, um nur Nullwerte zu erkennen
Die Codekopie lautet wie folgt:
// Unsichere Funktionen, jeder Nicht-Array-Wert verursacht Fehler
Funktion Reverseort (Werte) {
if (values! = null) {
values.sort ();
Werte.Reverse ();
}
}
Wenn ein Objekt, das die Sort () -Methode (anstatt ein Array) enthält
Die Codekopie lautet wie folgt:
// Unsichere Funktionen, jeder Nicht-Array-Wert verursacht Fehler
Funktion Reverseort (Werte) {
if (typeof values.sort == 'Funktion') {
values.sort ();
Werte.Reverse ();
}
}
Wenn Sie genau wissen, in welchem Typ Sie übergeben sollten, verwenden Sie am besten Instanz, um den Datentyp zu erkennen
Die Codekopie lautet wie folgt:
// sichere, Nicht-Array-Werte werden ignoriert
Funktion Reverseort (Werte) {
if (Werte Instanz von Array) {
values.sort ();
Werte.Reverse ();
}
}
【Kommunikationsfehler】
Mit dem Aufstieg der AJAX -Programmierung ist es für Webanwendungen alltäglich geworden, um Informationen oder Funktionen während ihres Lebenszyklus dynamisch zu laden. Jede Kommunikation zwischen JavaScript und dem Server kann jedoch einen Fehler verursachen
Das häufigste Problem ist, dass Daten nicht mit Encodeuricomponent () codiert werden, bevor sie an den Server gesendet werden
Die Codekopie lautet wie folgt:
//Fehler
http://www.yourdomain.com/?redir=http://www.sometherdomain.com?a=B&c=d
// Aufrufen von Encodeuricomponent () für alle Zeichenfolgen nach 'redir =' kann dieses Problem lösen
http://www.yourdomain.com/?redir=http:%3a%2f%2fww.Sometherdomain.com%3FA%3DB%26c%3DD