path: root/files/de/web/javascript/reference/statements/try...catch/index.html

---
title: try...catch
slug: Web/JavaScript/Reference/Statements/try...catch
translation_of: Web/JavaScript/Reference/Statements/try...catch
---
<div>{{jsSidebar("Statements")}}</div>

<p>Die <strong>try...catch</strong>-Anweisung (sinngemäß: testen und verarbeiten) rahmt einen Block von Anweisungen (<em>try statements)</em> ein und legt Reaktionen (<em>catch statementes</em>) fest, die im Fehlerfall ausgeführt werden.</p>

<h2 id="Syntax">Syntax</h2>

<pre class="syntaxbox">try {
   <em>try_Anweisungen</em>
}
[catch (<em>Fehler_var_1</em> if <em>Bedingung_1</em>) { // nicht Standard
   <em>catch_Anweisungen</em>
}]
...
[catch (<em>Fehler_var_2</em>) {
   <em>catch_Anweisungen_2</em>
}]
[finally {
   <em>finally_Anweisungen</em>
}]
</pre>

<dl>
 <dt><code>try_Anweisungen</code></dt>
 <dd>Die auszuführenden Anweisungen.</dd>
</dl>

<dl>
 <dt><code>catch_Anweisungen_1</code>, <code>catch_Anweisungen_2</code></dt>
 <dd>Anweisungen, die ausgeführt werden, wenn bei den <code>try</code>-Anweisungen ein Fehler auftritt.</dd>
</dl>

<dl>
 <dt><code>Fehler_var_1</code>, <code>Fehler_var_2</code></dt>
 <dd>Ein Bezeichner der das Fehlerobjekt des zugehörigen <code>catch</code>-Abschnitts enthält.</dd>
</dl>

<dl>
 <dt><code>Bedingung_1</code></dt>
 <dd>Ein Bedingungsausdruck.</dd>
</dl>

<dl>
 <dt><code>finally_Anweisungen</code></dt>
 <dd>Die Schlussanweisungen werden nach den <code>try</code>-Anweisungen ausgeführt. Die Anweisungen werden immer ausgeführt, auch wenn ein Fehler ausgegeben wurde. </dd>
</dl>

<h2 id="Beschreibung">Beschreibung</h2>

<p>Der <em>try</em>-Block besteht aus einer oder mehreren Anweisungen (der Absschnitt steht – auch bei nur einer Zeile – immer in geschweiften Klammern {}), mindestens einem <em>catch</em>- oder einem <em>finally</em>-Abschnitt oder beiden. Es gibt also drei Arten von <em>try</em>-Anweisungen:</p>

<ol>
 <li><code>try...catch</code></li>
 <li><code>try...finally</code></li>
 <li><code>try...catch...finally</code></li>
</ol>

<p>Der <code>catch</code>-Abschnitt enthält Anweisungen, die ausgeführt werden, wenn im <code>try</code>-Abschnitt ein Fehler auftritt. Bei einer fehlerhaften Anweisung im Block im <code>try</code>-Abschnitt – oder in Funktionen, die von dort aufgerufen werden – geht die Kontrolle sofort an den <code>catch</code>-Abschnitt über. Wird kein Fehler gemeldet wird der <code>catch</code>-Abschnitt nicht ausgeführt.</p>

<p>Der <code>finally</code>-Abschnitt wird nach dem <code>try</code>- und <code>catch</code>-Abschnitt ausgeführt. Der Abschnitt wird immer ausgeführt, egal ob ein Fehler aufgetreten ist oder nicht.</p>

<p>Mehrere <code>try</code>-Anweisungen können verschachtelt werden. Wenn ein innerer <code>try</code>-Block keinen <code>catch</code>-Abschnitt hat, wird der <code>catch</code>-Abschnitt des nächsthöheren <code>try</code>-Blocks ausgeführt.</p>

<p>Mit der try-Anweisungen können auch JavaScript-Fehler bearbeitet werden. Mehr zur Fehlerbearbeitung in JavaScript steht im <a href="/en-US/docs/Web/JavaScript/Guide" title="en/JavaScript/Guide">JavaScript Guide</a>.</p>

<h3 id="Unbhängiger_catch-Abschnitt">Unbhängiger <code>catch-Abschnitt</code></h3>

<p>Wenn mit einem einzelnen, ungebundenen <code>catch</code>-Abschnitt gearbeitet wird, dann wird der catch-Block bei jedem Fehler durchlaufen. Wenn der Fehler im folgenden Beispiel-Code auftritt geht die Kontrolle an den <code>catch</code>-Abschnitt über.</p>

<pre class="brush: js">try {
   throw "myException"; // Fehler wird ausgelöst
}
catch (e) {
   // Anweisungen für jeden Fehler
   logMyErrors(e); // Fehler-Objekt an die Error-Funktion geben
}
</pre>

<p>Im <code>catch</code>-Block wird ein Bezeichner festgelegt (e im Beispiel), die den Wert enthält, der durch die <code>throw</code>-Anweisung entstanden ist. Der catch-Block ist besonders, weil er zu Beginn der Ausführung einen Bezeichner anlegt, der für den gesamten Block gilt. Wenn der catch-Block abgearbeitet ist steht der Bezeichner nicht mehr zur Verfügung.</p>

<h3 id="Abhängige_catch-Abschnitte">Abhängige <code>catch</code>-Abschnitte</h3>

<p>{{non-standard_header}}</p>

<p>Mehrere abhängige catch-Abschnitte können spezifische Fehler bearbeiten. In diesem Fall wird der passende catch-Abschnitt aufgerufen, wenn der zugehörige Fehler aufgetreten ist. Im folgenden Beispiel kann der Code im <code>try</code>-Block drei mögliche Fehler ausgeben: {{jsxref("TypeError")}}, {{jsxref("RangeError")}}, and {{jsxref("EvalError")}} (Typ-Fehler, Bereich-Fehler und Rechenfehler). Wenn ein Fehler auftritt geht die Kontrolle an den zugehörigen <code>catch</code>-Abschnitt. Wenn dem Fehler kein catch-Abschnitt entspricht und ein unabhäniger <code>catch</code>-Abschnitt vorhanden ist, geht die Kontrolle an ihn.</p>

<p>Wenn mehrere abhängige catch-Abschnitt mit einem unabhängigen kombiniert werden, muss der unabhängige Abschnitt am Ende stehen: er fängt sonst alle Fehlertypen ab bevor sie die eigenen, abhängigen Abschnitte erreichen.</p>

<p>Zu Erinnerung: diese Funktionalität ist kein Teil der ECMAScript-Spezifikation.</p>

<pre class="brush: js">try {
    myroutine(); // erzeugt drei mögliche Fehlertypen
} catch (e if e instanceof TypeError) {
    // Anweisungen für die verschiedenen Fehlertypen
} catch (e if e instanceof RangeError) {
    // Anweisungen für Bereichsfehler
} catch (e if e instanceof EvalError) {
    // Anweisungen für Berechnungsfehler
} catch (e) {
    // Anweisungen für nicht festgelegte Fehlertypen
    logMyErrors(e); // Objekt an die Fehler-Funktion geben
}
</pre>

<p>Das nächste Beispiel zeigt, wie die gleichen "abhängigen <code>catch</code>-Abschnitte" aussehen, wenn einfaches JavaScript benutzt wird, das den ECMAScript-Spezifikationen entspricht (etwas umfangreicher, funktioniert aber genauso).</p>

<pre class="brush: js">try {
    myroutine(); // erzeugt drei mögliche Fehlertypen
} catch (e) {
    if (e instanceof TypeError) {
        // Anweisungen für die verschiedenen Fehlertypen
    } else if (e instanceof RangeError) {
        // Anweisungen für Bereichsfehler
    } else if (e instanceof EvalError) {
        // Anweisungen für Berechnungsfehler
    } else {
       // Anweisungen für nicht festgelegte Fehlertypen
       logMyErrors(e); // Objekt an die Fehler-Funktion geben
    }
}
</pre>

<h3 id="Der_Fehler-Bezeichner">Der Fehler-Bezeichner</h3>

<p>Wenn im try-Block ein Fehler auftritt, enthält die <em>exception_var</em> (z.B. das e in catch(e)) den Wert, der durch die <em>throw</em>-Anweisung erzeugt wird. Mit diesem Bezeichner können also Informationen über den Fehler gewonnen werden.</p>

<p>Der Bezeichner gilt nur innerhalb des <code>catch</code>-Abschnitts. Er wird zu Beginn des Abschnitts angelegt und steht nach der Abarbeitung nicht mehr zur Verfügung.</p>

<h3 id="Der_finally-Abschnitt">Der finally-Abschnitt</h3>

<p>Zum Abschluss-Abschnitt (<code>finally</code>) gehören die Anweisungen, die nach dem <code>try</code>- und dem <code>catch</code>-Block ausgeführt werden, noch bevor irgenwelche Anweisugnen nach den <code>try-/catch-/finally</code>-Abschnitten ausgeführt werden. Der finally-Abschnitt wird immer ausgeführt, auch wenn bei der Verarbeitung ein Fehler aufgetreten ist. Er wird auch ausgeführt, wenn kein catch-Abschnitt den Fehler bearbeitet. Der finally-Abschnitt kann dabei helfen, das eigene Script im Fehlerfall anständig zu beenden. Dort können zum Beispiel für ein übergreifendes Aufräumen Ressourcen wieder freigegeben werden, die durch das Script gebunden wurden.</p>

<p>Vielleicht sieht ein Abschnitt, der sich auf Fehler bezieht, aber UNABHÄNGIG vom tatsächlichen Auftreten eines Fehlers immer ausgeführt wird, merkwürdig aus. Aber dieses Konstrukt dient tatsächlich einem Zweck. Wichtig dabei ist nicht, dass der <code>finally</code>-Abschnitt immer aussgeführt wird, sonder das der normale Code nach einem try...catch NICHT ausgeführt wird. Wenn zum Beispiel in einem catch-Abschnitt, der zu einem try-Block gehört, ein Fehler auftritt, dann wird nichts von dem umgebenden Code ausgeführt, gleichgültig ob es ein umgebende try-catch-Blöcke oder normale Anweisungen sind. Die Kontrolle wird stattdessen an den catch-Abschnitt übergeben, der zum umgebenden try-Abschnitt gehört oder – wenn es den nicht gibt – an die interne Fehlerroutine. </p>

<p>Auf diese Weise wird jeder nachfolgende Aufräum-Code im eingeschlossenen Abschnitt oder im normalen Programmablauf übersprungen. Wenn aber zum <code>try</code>-Abschnitt ein finally-Abschnitt gehört, dann kann in diesem Abschnitt aufgeräumt werden, bevor es in einen umgebenden <code>catch</code>-Abschnitt (oder den Fehlergenerator) geht, der dann den zweiten Fehler bearbeitet. </p>

<p>Wenn unabhängig vom Erfolg des <code>try...catch-</code>Blocks aufgeräumt werden muss und der finally-Abschnitt nur nach einem Fehler ausgeführt würde, dann müsste der Aufräum-Code doppelt verwendet werden, innerhalb und außerhalb des finally-Abschnitts. Deshalb wird der finally-Block unabhängig von auftretenden Fehlern ausgeführt.</p>

<p>Das folgende Beispiel öffnet eine Datei und führt dann Anweisungen aus, die mit der Datei arbeiten (server-seitiges JavaScript lässt den Zugriff auf Dateien zu).  Wenn ein Fehler ausgegeben wird solange die Datei geöffnet ist, dann schließt der <code>finally</code>-Abschnitt diese Datei bevor das Script stoppt. Der Code im Abschnitt wird auch bei <code>Returns</code> aus <code>try</code>- oder <code>catch</code>-Blöcken ausgeführt.</p>

<pre class="brush: js">openMyFile()
try {
   // bindet eine Ressource
   writeMyFile(theData);
}
finally {
   closeMyFile(); // Ressource immer wieder frei geben
}
</pre>

<h2 id="Examples">Examples</h2>

<h3 id="Verschachtelte_try-Blöcke">Verschachtelte try-Blöcke</h3>

<p>Zuerst einmal untersuchen wir diese Beispiele:</p>

<pre class="brush: js">try {
  try {
    throw new Error("oops");
  }
  finally {
    console.log("finally");
  }
}
catch (ex) {
  console.error("outer", ex.message);
}

// Output:
// "finally"
// "outer" "oops"
</pre>

<p>Wenn wir den Fehler im inneren <code>try</code>-Block mit einem <code>catch</code>-Abschnitt bearbeiten</p>

<pre class="brush: js">try {
  try {
    throw new Error("oops");
  }
  catch (ex) {
    console.error("inner", ex.message);
  }
  finally {
    console.log("finally");
  }
}
catch (ex) {
  console.error("outer", ex.message);
}

// Output:
// "inner" "oops"
// "finally"
</pre>

<p>Und jetzt wird der Fehler im catch-Abschnitt noch einmal produziert:</p>

<pre class="brush: js">try {
  try {
    throw new Error("oops");
  }
  catch (ex) {
    console.error("inner", ex.message);
    throw ex;
  }
  finally {
    console.log("finally");
  }
}
catch (ex) {
  console.error("outer", ex.message);
}

// Output:
// "inner" "oops"
// "finally"
// "outer" "oops"
</pre>

<p>Jeder auftretende Fehler wird nur einmal bearbeitet, durch den nächsten umgebenden <code>catch</code>-Block (es sei denn, er wird erneut ausgegeben). Natürlich werden alle im inneren Abschnitt neu auftretenden Fehler durch den umschließenden Block bearbeitet.</p>

<h3 id="Rückgaben_aus_einem_finally-Block">Rückgaben aus einem finally-Block</h3>

<p>Wenn der <code>finally</code>-Abschnitt ein Wert  zurückgibt, wird dieser Wert zum Rückgabewert der gesamten <code>try-catch-finally</code>-Veranstaltung, unabhänig von allen return-Anweisungen in den <code>try</code>- oder <code>catch</code>-Blöcken. Das gilt auch für Fehler im <code>catch</code>-Block:</p>

<pre class="brush: js">try {
  try {
    throw new Error("oops");
  }
  catch (ex) {
    console.error("inner", ex.message);
    throw ex;
  }
  finally {
    console.log("finally");
    return;
  }
}
catch (ex) {
  console.error("outer", ex.message);
}

// Output:
// "inner" "oops"
// "finally"
</pre>

<p>Der äußere "oops"-Fehler wird nicht ausgelöst wegen des <code>return</code> im finally-Block. Das gleiche gilt für alle Werte, die aus dem <code>catch</code>-Abschnitt zurück gegeben werden.</p>

<h2 id="Spezifikationen">Spezifikationen</h2>

<table class="standard-table">
 <tbody>
  <tr>
   <th scope="col">Spezifikation</th>
   <th scope="col">Status</th>
   <th scope="col">Kommentar</th>
  </tr>
  <tr>
   <td>{{SpecName('ES3')}}</td>
   <td>{{Spec2('ES3')}}</td>
   <td>Erste Definition. Implementiert in JavaScript 1.4</td>
  </tr>
  <tr>
   <td>{{SpecName('ES5.1', '#sec-12.14', 'try statement')}}</td>
   <td>{{Spec2('ES5.1')}}</td>
   <td> </td>
  </tr>
  <tr>
   <td>{{SpecName('ES6', '#sec-try-statement', 'try statement')}}</td>
   <td>{{Spec2('ES6')}}</td>
   <td> </td>
  </tr>
  <tr>
   <td>{{SpecName('ESDraft', '#sec-try-statement', 'try statement')}}</td>
   <td>{{Spec2('ESDraft')}}</td>
   <td>
    <p>Fällt nicht unter den aktuellen ECMA-262-Standard: Mehrfache catch-Abschnitte und abhängige Abschnitte (SpiderMonkey extension, JavaScript 1.5).</p>
   </td>
  </tr>
 </tbody>
</table>

<h2 id="Browser-Verträglichkeit">Browser-Verträglichkeit</h2>

<p>{{CompatibilityTable}}</p>

<div id="compat-desktop">
<table class="compat-table">
 <tbody>
  <tr>
   <th>Funktion</th>
   <th>Chrome</th>
   <th>Firefox (Gecko)</th>
   <th>Internet Explorer</th>
   <th>Opera</th>
   <th>Safari</th>
  </tr>
  <tr>
   <td>Grundunter-stützung</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatGeckoDesktop("6")}}</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
  </tr>
  <tr>
   <td>Abhängige Abschnitte<br>
    (Non-Standard)</td>
   <td>{{CompatNo}}</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatNo}}</td>
   <td>{{CompatNo}}</td>
   <td>{{CompatNo}}</td>
  </tr>
 </tbody>
</table>
</div>

<div id="compat-mobile">
<table class="compat-table">
 <tbody>
  <tr>
   <th>Funktion</th>
   <th>Android</th>
   <th>Chrome for Android</th>
   <th>Firefox Mobile (Gecko)</th>
   <th>IE Mobile</th>
   <th>Opera Mobile</th>
   <th>Safari Mobile</th>
  </tr>
  <tr>
   <td>
    <table class="compat-table">
     <tbody>
      <tr>
       <td>Grundunter-stützung</td>
       <td> </td>
      </tr>
     </tbody>
    </table>
   </td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
  </tr>
  <tr>
   <td>
    <table class="compat-table">
     <tbody>
      <tr>
       <td>Abhängige Abschnitte<br>
        (Non-Standard)</td>
       <td> </td>
      </tr>
     </tbody>
    </table>
   </td>
   <td>{{CompatNo}}</td>
   <td>{{CompatNo}}</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatNo}}</td>
   <td>{{CompatNo}}</td>
   <td>{{CompatNo}}</td>
  </tr>
 </tbody>
</table>
</div>

<h2 id="Siehe_auch">Siehe auch</h2>

<ul>
 <li>{{jsxref("Error")}}</li>
 <li>{{jsxref("Statements/throw", "throw")}}</li>
</ul>