try-catch in Javascript… ist das nicht eine gute Praxis?

In Javascript ist ein Try-Catch- Block vorgesehen . Obwohl es in Java oder einer anderen Sprache obligatorisch ist, Fehler zu behandeln, sehe ich niemanden, der sie in größerem Umfang in Javascript verwendet. Ist es nicht eine gute Übung oder brauchen wir sie nur nicht in Javascript?

Man sollte throwFehler vermeiden , um Fehlerbedingungen in Anwendungen weiterzugeben.

Die throwAussage sollte nur verwendet werden "Denn dies sollte niemals passieren, abstürzen und brennen. Nicht elegant in irgendeiner Weise erholen."

try catch Wird jedoch in Situationen verwendet, in denen Hostobjekte oder ECMAScript Fehler auslösen können.

Beispiel:

var json
try {
    json = JSON.parse(input)
} catch (e) {
    // invalid json input, set to null
    json = null
}

In der node.js- Community wird empfohlen , Fehler in Rückrufen (da Fehler nur bei asynchronen Operationen auftreten) als erstes Argument weiterzugeben

fs.readFile(uri, function (err, fileData) {
    if (err) {
        // handle
        // A. give the error to someone else
        return callback(err)
        // B. recover logic
        return recoverElegantly(err)
        // C. Crash and burn
        throw err
    }
    // success case, handle nicely
})

Es gibt auch andere Probleme, wie Try / Catch ist sehr teuer und es ist hässlich und es funktioniert einfach nicht mit asynchronen Operationen.

Da synchrone Vorgänge keinen Fehler auslösen sollten und bei asynchronen Vorgängen nicht funktionieren, verwendet niemand try catch, außer für Fehler, die von Hostobjekten oder ECMAScript ausgelöst werden

Try / catch in Javascript ist aufgrund der asynchronen Natur von Javascript nicht so kugelsicher wie in anderen Sprachen. Betrachten Sie dieses Snippet:

try {
    setTimeout(function() {
        do_something_that_throws();
    }, 1000);
}
catch (e) {
    alert("You won't see this!");
}

Das Problem ist, dass der Kontrollfluss den tryBlock verlässt , bevor er do_something_that_throws()ausgeführt wird, sodass der Fehler, der im Callback ausgelöst wird, niemals abgefangen wird.

Try / catch ist daher in vielen Fällen grundsätzlich unangemessen und es ist nicht immer offensichtlich, ob Code asynchron ausgeführt wird oder nicht. Glücklicherweise bietet Javascript mit seiner eigentümlichen Singlethread-Asynchronous-Callback-Sprache und seiner Unterstützung für tatsächliche Abschlüsse eine elegante Alternative: Fehlerbehandlung im Continuation-Passing-Stil. Übergeben Sie einfach die richtige Antwort auf einen Fehler als Funktion, z.

setTimeout(function () {
    do_something_that_calls_err(function(err) {
        alert("Something went wrong, namely this: " + err);
    }),
    1000);

Viele dieser Antworten sind etwas alt und berücksichtigen nicht die neuen ES7-Funktionen asyncund await.

Mit async/ können awaitSie jetzt einen asynchronen Kontrollfluss erhalten, wie Sie möchten:

async function email(address) {
  try {
    // Do something asynchronous that may throw...
    await sendEmail({ to: address, from: 'noreply@domain.com`, subject: 'Hello' })
  } catch(err) {
    if (err instanceof SomeCustomError) {
      elegantlyHandleError(err)
    } else {
      throw err
    } 
  }
})

Erfahren Sie mehr über async/ awaithier . Du kannst async/ awaitjetzt mit babel .

try-catch in Javascript ist genauso gültig und nützlich wie in jeder anderen Sprache, die es implementiert. Es gibt einen Hauptgrund, warum es in Javascript nicht so oft verwendet wird wie in anderen Sprachen. Aus demselben Grund wird Javascript als eine hässliche Skriptsprache angesehen. Aus demselben Grund denken die Leute, Javascript-Programmierer seien keine echten Programmierer:

• Javascript ist eine unglaublich zugängliche und allgegenwärtige Sprache

Die bloße Tatsache, dass so viele Menschen Javascript ausgesetzt sind (aufgrund der einzigen von Browsern unterstützten Sprache), bedeutet, dass Sie viele unprofessionelle Codes haben. Natürlich gibt es auch viele kleinere Gründe:

• Einige Dinge in Javascript sind asynchron und daher nicht in der catchLage (asynchrones Zeug)
• Es wurde viel überstrapaziert darüber, wie Try-Catch einen enormen Performance-Erfolg hat. Es hat ein wenig Leistungseinbußen , aber für die meisten Codes lohnt es sich.
• Javascript wurde (leider) so implementiert, dass Fehler oft unbemerkt ignoriert werden (zB automatisch Zeichenketten in Zahlen ändern)

Unabhängig davon sollte try-catch verwendet werden, aber Sie sollten natürlich lernen, wie man sie richtig verwendet - wie alles andere in der Programmierung.

Ich glaube, dass ein Großteil des Grundes, der try..catchin JavaScript selten vorkommt, darin besteht, dass die Sprache eine ziemlich hohe Fehlertoleranz aufweist. Die überwiegende Mehrheit der Situationen kann mithilfe von Codeüberprüfungen, guten Standardeinstellungen und asynchronen Ereignissen bewältigt werden. In einigen Fällen können Sie Probleme vermeiden, indem Sie einfach ein Muster verwenden:

function Foo() {
    //this may or may not be called as a constructor!!
    //could accidentally overwrite properties on window
}

function Bar() {
    if (!(this instanceof Bar)) {
        return new Bar();
    }
    //this will only work on Bar objects, and wont impact window
}

Einige der Hauptprobleme in anderen Sprachen, die zum Auftreten von Ausnahmen führen, sind in JS einfach nicht vorhanden. Typguss wird in den meisten Fällen nicht benötigt. Die bevorzugte Methode ist in der Regel die Funktionsprüfung (Erzwingen einer bestimmten Schnittstelle):

function doFoo(arg) {
    if (arg.foo) {
        arg.foo();
    } else {
        Bar.prototype.foo.call(arg);
    }
}

Mit der Hinzufügung von async/ awaitzur Sprache try..catchwird immer mehr verbreitet. Da Versprechungen die asynchrone Form von sind try..catch, ist es sinnvoll, Folgendes zu erwarten:

doSomething().then(
  doSomethingWithResult,
  doSomethingWithError
)

stattdessen geschrieben werden als:

try {
  const result = await doSomething()
  doSomethingWithResult(result)
} catch (e) {
  doSomethingWithError(e)
}

Möglicherweise wird try / catch auch nicht sehr häufig in Javascript verwendet, da das Konstrukt in den allerersten Versionen von Javascript nicht verfügbar war ... es wurde später hinzugefügt.

Einige ältere Browser unterstützen dies daher nicht. (Tatsächlich kann es in einigen älteren Browsern zu einem Parser- / Syntaxfehler kommen, der schwieriger als die meisten anderen Fehlertypen zu "defensiven Programmen" führt.)

Da es ursprünglich nicht verfügbar war, wird es von den ursprünglich veröffentlichten integrierten Javascript-Funktionen (was man in vielen Sprachen als "Bibliotheks" -Funktionen bezeichnen würde) nicht verwendet. (Es funktioniert nicht sehr gut, einen Fehler von someobject.somefunction () zu "fangen", wenn er nicht "wirft", sondern nur "null" zurückgibt, wenn er auf ein Problem stößt.)

Ein weiterer möglicher Grund ist, dass der Try / Catch-Mechanismus anfangs nicht notwendig zu sein schien (und immer noch nicht so nützlich zu sein scheint). Dies ist nur dann wirklich erforderlich, wenn Anrufe routinemäßig mehrere Ebenen tief verschachtelt sind. Wenn Sie nur eine Art von ERRNO zurückgeben, funktioniert dies problemlos für Direktanrufe (obwohl es in den meisten Sprachen empfehlenswert ist, ERRNO überall und nicht nur für tief verschachtelte Anrufe zu verwenden, wenn es verfügbar ist ). Da ursprünglich angenommen wurde, dass die JavaScript-Logik klein und einfach ist (schließlich handelt es sich nur um eine Ergänzung zu einer Webseite :-), wurde nicht erwartet, dass Funktionsaufrufe tief verschachtelt sind, und daher schien ein Try / Catch-Mechanismus nicht erforderlich zu sein.

Ich glaube, dass sie nicht so häufig verwendet werden, weil das Auslösen von Ausnahmen im clientseitigen Javascript-Code das Debuggen einer Seite erschwert.

Anstatt Ausnahmen auszulösen, ziehe ich es im Allgemeinen vor, ein Warnungsfeld (dh alert("Error, invalid...");) anzuzeigen.

Es mag seltsam klingen, aber auf Client-Seite treten Javascript-Fehler auf, wenn ein Kunde eine von Ihnen erstellte Seite verwendet und die Seite eine Ausnahme auslöst, es sei denn, der Kunde ist ein technisch versierter Programmierer , kann er dies niemals feststellen Sie, was das Problem ist.

Er wird Sie nur anrufen, indem er sagt: "Hey, Seite X funktioniert nicht!", Und dann müssen Sie herausfinden, was falsch gelaufen ist und wo im Code.

Wenn Sie stattdessen die Benachrichtigungsbox verwenden, ist es wahrscheinlicher, dass er anruft und etwas sagt wie: "Hey, wenn ich auf die Schaltfläche A von Seite X klicke, wird eine Box angezeigt, die sagt ..." , vertrauen Sie mir, es ist viel einfacher zu finden der Fehler.