initial commit

10 files changed, 929 insertions, 0 deletions

diff --git a/files/de/web/javascript/reference/global_objects/error/columnnumber/index.html b/files/de/web/javascript/reference/global_objects/error/columnnumber/index.html
new file mode 100644
index 0000000000..8335fd02d6
--- /dev/null
+++ b/files/de/web/javascript/reference/global_objects/error/columnnumber/index.html
@@ -0,0 +1,43 @@
+---
+title: Error.prototype.columnNumber
+slug: Web/JavaScript/Reference/Global_Objects/Error/columnNumber
+tags:
+  - Error
+  - JavaScript
+  - Non-standard
+  - Property
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Error/columnNumber
+---
+<div>{{JSRef}} {{non-standard_header}}</div>
+
+<p>Die <code><strong>columnNumber</strong></code> Eigenschaft enthält die Spaltennummer in der Zeile in der Datei, in der der Fehler erzeugt wurde.</p>
+
+<h2 id="Beispiele">Beispiele</h2>
+
+<h3 id="Einsatz_von_columnNumber">Einsatz von <code>columnNumber</code></h3>
+
+<pre class="brush: js">var e = new Error('Could not parse input');
+throw e;
+console.log(e.columnNumber) // 0
+</pre>
+
+<h2 id="Spezifikationen">Spezifikationen</h2>
+
+<p>In keiner Spezifikation enthalten. Kein Standard.</p>
+
+<h2 id="Browserkompatibilität">Browserkompatibilität</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.Error.columnNumber")}}</p>
+</div>
+
+<h2 id="Siehe_auch">Siehe auch</h2>
+
+<ul>
+ <li>{{jsxref("Error.prototype.stack")}} {{non-standard_inline}}</li>
+ <li>{{jsxref("Error.prototype.lineNumber")}} {{non-standard_inline}}</li>
+ <li>{{jsxref("Error.prototype.fileName")}} {{non-standard_inline}}</li>
+</ul>
diff --git a/files/de/web/javascript/reference/global_objects/error/filename/index.html b/files/de/web/javascript/reference/global_objects/error/filename/index.html
new file mode 100644
index 0000000000..df7383803e
--- /dev/null
+++ b/files/de/web/javascript/reference/global_objects/error/filename/index.html
@@ -0,0 +1,47 @@
+---
+title: Error.prototype.fileName
+slug: Web/JavaScript/Reference/Global_Objects/Error/fileName
+tags:
+  - Error
+  - JavaScript
+  - Non-standard
+  - Property
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Error/fileName
+---
+<div>{{JSRef}} {{non-standard_header}}</div>
+
+<p>Die <code><strong>fileName</strong></code> Eigenschaft enthält den Pfad der Datei, in der der Fehler erzeugt wurde.</p>
+
+<h2 id="Beschreibung">Beschreibung</h2>
+
+<p>Diese nicht standardisierte Eigenschaft enthält den Pfad der Datei, in der der Fehler erzeugt wurde. Wenn diese Eigenschaft von aus einem Debugger heraus aufgerufen wird (z. B. Firefox Developer Tools), wird "debugger eval code" zurückgegeben.</p>
+
+<h2 id="Beispiele">Beispiele</h2>
+
+<h3 id="Einsatz_von_fileName">Einsatz von <code>fileName</code></h3>
+
+<pre class="brush: js">var e = new Error('Could not parse input');
+throw e;
+// e.fileName könnte aussehen wie: "file:///C:/example.html"
+</pre>
+
+<h2 id="Spezifikationen">Spezifikationen</h2>
+
+<p>In keiner Spezifikation enthalten. Kein Standard.</p>
+
+<h2 id="Browserkompatibilität">Browserkompatibilität</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.Error.fileName")}}</p>
+</div>
+
+<h2 id="Siehe_auch">Siehe auch</h2>
+
+<ul>
+ <li>{{jsxref("Error.prototype.stack")}} {{non-standard_inline}}</li>
+ <li>{{jsxref("Error.prototype.columnNumber")}} {{non-standard_inline}}</li>
+ <li>{{jsxref("Error.prototype.lineNumber")}} {{non-standard_inline}}</li>
+</ul>
diff --git a/files/de/web/javascript/reference/global_objects/error/index.html b/files/de/web/javascript/reference/global_objects/error/index.html
new file mode 100644
index 0000000000..293f0927fc
--- /dev/null
+++ b/files/de/web/javascript/reference/global_objects/error/index.html
@@ -0,0 +1,241 @@
+---
+title: Error
+slug: Web/JavaScript/Reference/Global_Objects/Error
+tags:
+  - Error
+  - JavaScript
+  - Reference
+translation_of: Web/JavaScript/Reference/Global_Objects/Error
+---
+<div>{{JSRef}}</div>
+
+<p>Der <strong><code>Error</code></strong> Konstruktor erstellt ein Fehler (Error) Objekt. Instanzen von <code>Error</code> Objekten werden geworfen (thrown), wenn zur Laufzeit ein Fehler auftritt. Das <code>Error</code> Objekt kann zudem als Basis für benutzerdefinierte Fehler benutzt werden. Weiter unten werden schon eingebaute Fehlertypen beschrieben.</p>
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox">new Error([<var>message</var>[, <var>fileName</var>[, <var>lineNumber</var>]]])</pre>
+
+<h3 id="Parameter">Parameter</h3>
+
+<dl>
+ <dt><code>message</code></dt>
+ <dd>Optional. Für Menschen lesbare Beschreibung des Errors.</dd>
+ <dt><code>fileName</code> {{non-standard_inline}}</dt>
+ <dd>Optional. Der Wert für die <code>fileName</code> Eigenschaft eines erstellten <code>Error</code> Objekts. Der Standardwert ist der Name der Datei, in dem der Quelltext <code>Error()</code> aufgerufen wird.</dd>
+ <dt><code>lineNumber</code> {{non-standard_inline}}</dt>
+ <dd>Optional. Der Wert für die <code>lineNumber</code> Eigenschaft eines erstellten <code>Error</code> Objekts. Der Standardwert ist die Zeilennummer, in dem der Quelltext <code>Error()</code> aufgerufen wird.</dd>
+</dl>
+
+<h2 id="Beschreibung">Beschreibung</h2>
+
+<p>Laufzeitfehler resultieren in einem neu erstellten und geworfenen <code>Error</code> Objekt.</p>
+
+<p>Diese Seite Dokumentiert den Einsatz des <code>Error</code> Objektes und den Einsatz als Konstruktorfunktion. Für eine Liste der Eigenschaften und Methoden, die eine <code>Error</code> Instanz erbt, siehe auf der Seite {{jsxref("Error.prototype")}}.</p>
+
+<h3 id="Einsatz_als_Funktion">Einsatz als Funktion</h3>
+
+<p>Wenn <code>Error</code> als Funktion genutzt wird -- ohne <code>new</code>, wird diese ein <code>Error</code> Objekt zurückgeben. Daher wird der Aufruf der Funktion das gleiche zurückgeben wie der Aufruf des <code>Error</code> Konstruktors (mit <code>new</code> Schlüsselwort).</p>
+
+<pre class="brush: js">// dieser Aufruf:
+const x = Error('Ich wurde mit einem Funktionsaufruf erstellt!');
+​​​​// hat die gleiche Funktion wie folgender:
+const y = new Error('Ich wurde mit dem "new" Schlüsselwort erstellt!');</pre>
+
+<h3 id="Fehlertypen">Fehlertypen</h3>
+
+<p>Neben dem generischen <code>Error</code> Konstruktor sind in JavaScript noch sieben weitere Error-Konstruktoren eingebaut. Für benutzerdefinierte Fehler siehe <a href="/de/docs/Web/JavaScript/Guide/Statements#Statements_zur_Fehler-_bzw._Ausnahmebehandlung">Statements zur Fehler- und Ausnahmebehandlung</a>.</p>
+
+<dl>
+ <dt>{{jsxref("EvalError")}}</dt>
+ <dd>Erstellt eine Instanz, die einen Fehler repräsentiert, der bei der globalen {{jsxref("Global_Objects/eval", "eval()")}} Funktion auftritt.</dd>
+ <dt>{{jsxref("InternalError")}} {{non-standard_inline}}</dt>
+ <dd>Erstellt eine Instanz, die einen Fehler repräsentiert, der auftritt, wenn ein interner Fehler in JavaScript auftaucht (z. B. zu viel Rekursion).</dd>
+ <dt>{{jsxref("RangeError")}}</dt>
+ <dd>Erstellt eine Instanz, die einen Fehler repräsentiert, der auftritt, wenn eine nummerische Variable oder ein nummerischer Parameter außerhalb seiner validen Grenzen ist.</dd>
+ <dt>{{jsxref("ReferenceError")}}</dt>
+ <dd>Erstellt eine Instanz, die einen Fehler repräsentiert, der auftritt, wenn eine nicht valide Referenz referenziert werden soll.</dd>
+ <dt>{{jsxref("SyntaxError")}}</dt>
+ <dd>Erstellt eine Instanz, die einen Fehler repräsentiert, der auftritt, wenn die Syntax von  Quellcode, der in der {{jsxref("Global_Objects/eval", "eval()")}} Funktion übergeben wird, nicht richtig ist.</dd>
+ <dt>{{jsxref("TypeError")}}</dt>
+ <dd>Erstellt eine Instanz, die einen Fehler repräsentiert, der auftritt, wenn eine Variable oder ein Parameter einen nicht validen Typen enthält.</dd>
+ <dt>{{jsxref("URIError")}}</dt>
+ <dd>Erstellt ein Instanz, die einen Fehler repräsentiert, der auftritt, wenn die Methode {{jsxref("Global_Objects/encodeURI", "encodeURI()")}} oder {{jsxref("Global_Objects/decodeURI", "decodeURI()")}} nicht valide Parameter übergeben bekommt.</dd>
+</dl>
+
+<h2 id="Eigenschaften">Eigenschaften</h2>
+
+<dl>
+ <dt>{{jsxref("Error.prototype")}}</dt>
+ <dd>Erlaubt es die Eigenschaften aller <code>Error</code> Instanzen zu verändern.</dd>
+</dl>
+
+<h2 id="Methoden">Methoden</h2>
+
+<p>Das globale <code>Error</code> Objekt besitzt keine eigenen Methoden. Stattdessen erbt es einige Methoden durch die Prototypenkette.</p>
+
+<h2 id="Error_Instanzen">Error Instanzen</h2>
+
+<div>{{page('/de/docs/Web/JavaScript/Reference/Global_Objects/Error/prototype', 'Beschreibung')}}</div>
+
+<h3 id="Eigenschaften_2">Eigenschaften</h3>
+
+<div>{{page('/de/docs/Web/JavaScript/Reference/Global_Objects/Error/prototype', 'Eigenschaften')}}</div>
+
+<h3 id="Methoden_2">Methoden</h3>
+
+<div>{{page('/de/docs/Web/JavaScript/Reference/Global_Objects/Error/prototype', 'Methoden')}}</div>
+
+<h2 id="Beispiele">Beispiele</h2>
+
+<h3 id="Werfen_eines_generischen_Errors">Werfen eines generischen Errors</h3>
+
+<p>Typischerweise erstellt man ein <code>Error</code> Objekt mit der Intention es mit dem {{jsxref("Statements/throw", "throw")}} Schlüsselwort zu werfen. Man kann den Fehler auffangen, indem man ein {{jsxref("Statements/try...catch", "try...catch")}} Konstrukt benutzt.</p>
+
+<pre class="brush: js">try {
+  throw new Error('Whoops!');
+} catch (e) {
+  console.log(e.name + ': ' + e.message);
+}
+</pre>
+
+<h3 id="Einen_Spezifischen_Error_behandeln">Einen Spezifischen Error behandeln</h3>
+
+<p>Man kann sich aussuchen, welche spezifischen Fehlertypen behandelt werden sollen, indem man die {{jsxref("Object.prototype.constructor", "constructor")}} Eigenschaft des Errors abfragt. In modernen JavaScript-Umgebungen kann stattdessen das {{jsxref("Operators/instanceof", "instanceof")}} Schlüsselwort verwendet werden:</p>
+
+<pre class="brush: js">try {
+  foo.bar();
+} catch (e) {
+  if (e instanceof EvalError) {
+    console.log(e.name + ': ' + e.message);
+  } else if (e instanceof RangeError) {
+    console.log(e.name + ': ' + e.message);
+  }
+  // ... etc
+}
+</pre>
+
+<h3 id="Benutzerdefinierte_Fehlertypen">Benutzerdefinierte Fehlertypen</h3>
+
+<p>Manchmal möchte man aber einen eigenen Error erstellen, der von <code>Error</code> abgeleitet ist, durch den Aufruf <code>throw new CustomError()</code>  geworfen werden kann und durch <code>instanceof CustomError</code> abgefragt werden kann. Eigene Fehlertypen führen zu einer besseren und konsistenten Fehlerbehandlung. Für eine tiefer gehende Diskussion schaue bitte auf <a href="https://stackoverflow.com/questions/1382107/whats-a-good-way-to-extend-error-in-javascript">Stack Overflow</a> nach.</p>
+
+<h4 id="ES6_benutzerdefinierte_Error_Klasse">ES6 benutzerdefinierte Error Klasse</h4>
+
+<div class="warning">
+<p>Babel und andere Transpiler werden den folgenden Quelltext nicht ohne <a href="https://github.com/loganfsmyth/babel-plugin-transform-builtin-extend">zusätzliche Konfigurationen</a> verarbeiten können.</p>
+</div>
+
+<div class="note">
+<p>Einige Browser enthalten den CustomError Konstruktor im Stack Trace, wenn ES2015 Klassen eingesetzt werden</p>
+</div>
+
+<pre class="brush: js">class CustomError extends Error {
+  constructor(foo = 'bar', ...params) {
+    // Übergibt die verbleibenden Parameter (einschließlich Vendor spezifischer Parameter) dem Error Konstruktor
+    super(...params);
+
+    // Behält den richtigen Stack-Trace für die Stelle bei, an der unser Fehler ausgelöst wurde (nur bei V8 verfügbar)
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, CustomError);
+    }
+
+    // Benutzerdefinierte Debugging Informationen
+    this.foo = foo;
+    this.date = new Date();
+  }
+}
+
+try {
+  throw new CustomError('buz', 'buzMessage');
+} catch(e){
+  console.log(e.foo);     // baz
+  console.log(e.message); // bazMessage
+  console.log(e.stack);   // stacktrace
+}</pre>
+
+<h4 id="ES5_benutzerdefiniertes_Error_Objekt">ES5 benutzerdefiniertes Error Objekt</h4>
+
+<div class="warning">
+<p><strong>Alle</strong> Browser enthalten den CustomError Konstruktor im Stack Trace, wenn eine Prototypische Deklaration verwendet wird.</p>
+</div>
+
+<pre class="brush: js">function CustomError(foo, message, fileName, lineNumber) {
+  var instance = new Error(message, fileName, lineNumber);
+  instance.foo = foo;
+  Object.setPropertyOf(instance, Object.getPrototypeOf(this));
+  if(Error.captureStackTrace) {
+    Error.captureStackTrace(instance, CustomError);
+  }
+  return instance;
+}
+
+CustomError.prototype = Object.create(Error.prototype, {
+  constructor: {
+    value: Error,
+    enumerable: false,
+    writable: true,
+    configurable: true
+  }
+});
+
+if(typeof Object.setPropertyOf != 'undefined') {
+  Object.setPrototypeOf(CustomError, Error);
+} else {
+  CustomError.__proto__ = Error;
+}
+
+
+try {
+  throw new CustomError('baz', 'bazMessage');
+} catch (e) {
+  console.log(e.foo);      // 'baz'
+  console.log(e.message);  // 'bazMessage'
+}
+</pre>
+
+<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('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Initiale Definition. Implementiert in JavaScript 1.1.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.11', 'Error')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-error-objects', 'Error')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-error-objects', 'Error')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browserkompatibilität">Browserkompatibilität</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.Error")}}</p>
+</div>
+
+<h2 id="Siehe_auch">Siehe auch</h2>
+
+<ul>
+ <li>{{jsxref("Error.prototype")}}</li>
+ <li>{{jsxref("Statements/throw", "throw")}}</li>
+ <li>{{jsxref("Statements/try...catch", "try...catch")}}</li>
+</ul>
diff --git a/files/de/web/javascript/reference/global_objects/error/linenumber/index.html b/files/de/web/javascript/reference/global_objects/error/linenumber/index.html
new file mode 100644
index 0000000000..63bb6a59c2
--- /dev/null
+++ b/files/de/web/javascript/reference/global_objects/error/linenumber/index.html
@@ -0,0 +1,55 @@
+---
+title: Error.prototype.lineNumber
+slug: Web/JavaScript/Reference/Global_Objects/Error/lineNumber
+tags:
+  - Error
+  - JavaScript
+  - Non-standard
+  - Property
+  - Prototype
+  - Reference
+translation_of: Web/JavaScript/Reference/Global_Objects/Error/lineNumber
+---
+<div>{{JSRef}} {{non-standard_header}}</div>
+
+<p>Die <code><strong>lineNumber</strong></code> Eigenschaft enthält die Zeilennummer in der Datei, in der der Fehler erzeugt wurde.</p>
+
+<h2 id="Beispiele">Beispiele</h2>
+
+<h3 id="Einsatz_von_lineNumber">Einsatz von <code>lineNumber</code></h3>
+
+<pre class="brush: js">var e = new Error('Could not parse input');
+throw e;
+console.log(e.lineNumber) // 2
+</pre>
+
+<h3 id="Alternatives_Beispiel_mit_error_Events">Alternatives Beispiel mit <code>error</code> Events</h3>
+
+<pre class="brush: js">window.addEventListener('error', function(e) {
+  console.log(e.lineNumber); // 5
+});
+var e = new Error('Could not parse input');
+throw e;
+</pre>
+
+<p>Das ist keine Standardfunktion und es gibt auch keine breite Unterstützung (siehe Browserkompatibilitätstabelle unten).</p>
+
+<h2 id="Spezifikationen">Spezifikationen</h2>
+
+<p>Ist in keiner Spezifikation enthalten. Kein Standard.</p>
+
+<h2 id="Browserkompatibilität">Browserkompatibilität</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.Error.lineNumber")}}</p>
+</div>
+
+<h2 id="Siehe_auch">Siehe auch</h2>
+
+<ul>
+ <li>{{jsxref("Error.prototype.stack")}} {{non-standard_inline}}</li>
+ <li>{{jsxref("Error.prototype.columnNumber")}} {{non-standard_inline}}</li>
+ <li>{{jsxref("Error.prototype.fileName")}} {{non-standard_inline}}</li>
+</ul>
diff --git a/files/de/web/javascript/reference/global_objects/error/message/index.html b/files/de/web/javascript/reference/global_objects/error/message/index.html
new file mode 100644
index 0000000000..559f457cb2
--- /dev/null
+++ b/files/de/web/javascript/reference/global_objects/error/message/index.html
@@ -0,0 +1,75 @@
+---
+title: Error.prototype.message
+slug: Web/JavaScript/Reference/Global_Objects/Error/message
+tags:
+  - Error
+  - JavaScript
+  - Property
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Error/message
+---
+<div>{{JSRef}}</div>
+
+<p>Die <code><strong>message</strong></code> Eigenschaft ist eine für Menschen lesbare Beschreibung von Errors.</p>
+
+<h2 id="Beschreibung">Beschreibung</h2>
+
+<p>Diese Eigenschaft enthält eine knappe Beschreibung des Errors, wenn eine verfügbar ist oder gesetzt wird. Zum Beispiel setzt <a href="/de/docs/Mozilla/Projects/SpiderMonkey">SpiderMonkey</a> diese Eigenschaft sehr oft ein. Die <code>message</code> Eigenschaft kombiniert mit der {{jsxref("Error.prototype.name", "name")}} Eigenschaft werden in der {{jsxref("Error.prototype.toString()")}} Methode eingesetzt, um eine String-Repräsentation des Errors zu erstellen.</p>
+
+<p>Der Standardwert für die <code>message</code> Eigenschaft ist ein leerer String, jedoch kann diese von einer Instanz überschrieben werden, indem der erste Parameter des  {{jsxref("Error", "Error Konstruktors")}} gesetzt wird.</p>
+
+<h2 id="Beispiele">Beispiele</h2>
+
+<h3 id="Einen_benutzerdefinierten_Fehler_erzeugen">Einen benutzerdefinierten Fehler erzeugen</h3>
+
+<pre class="brush: js">var e = new Error('Falsches Eingabeformat');
+// e.message ist 'Falsches Eingabeformat'
+throw e;
+</pre>
+
+<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('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Initiale Definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.11.4.3', 'Error.prototype.message')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-error.prototype.message', 'Error.prototype.message')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-error.prototype.message', 'Error.prototype.message')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browserkompatibilität">Browserkompatibilität</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.Error.message")}}</p>
+</div>
+
+<h2 id="Siehe_auch">Siehe auch</h2>
+
+<ul>
+ <li>{{jsxref("Error.prototype.name")}}</li>
+ <li>{{jsxref("Error.prototype.toString()")}}</li>
+</ul>
diff --git a/files/de/web/javascript/reference/global_objects/error/name/index.html b/files/de/web/javascript/reference/global_objects/error/name/index.html
new file mode 100644
index 0000000000..abf77777fc
--- /dev/null
+++ b/files/de/web/javascript/reference/global_objects/error/name/index.html
@@ -0,0 +1,58 @@
+---
+title: Error.prototype.name
+slug: Web/JavaScript/Reference/Global_Objects/Error/name
+tags:
+  - Error
+  - JavaScript
+  - Property
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Error/name
+---
+<div>{{JSRef}}</div>
+
+<p>Die <code><strong>name</strong></code> Eigenschaft repräsentiert einen Namen für die Art des Errors. Der Initialwert ist "Error".</p>
+
+<h2 id="Beschreibung">Beschreibung</h2>
+
+<p>Als Standard wird für einer {{jsxref("Error")}} Instanz der Name "Error" gegeben. Die <code>name</code> Eigenschaft und die {{jsxref("Error.prototype.message", "message")}} Eigenschaft werden eingesetzt, um in der {{jsxref("Error.prototype.toString()")}} Methode eine Repräsentation des Fehlers als String zu erstellen.</p>
+
+<h2 id="Beispiele">Beispiele</h2>
+
+<h3 id="Einen_benutzerdefinierten_Fehler_erzeugen">Einen benutzerdefinierten Fehler erzeugen</h3>
+
+<pre class="brush: js">var e = new Error('Malformed input'); // e.name ist 'Error'
+
+e.name = 'ParseError';
+throw e;
+// e.toString() wird 'ParseError: Malformed input' zurückgeben.
+</pre>
+
+<h2 id="Spezifikationen">Spezifikationen</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spezifikation</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-error.prototype.name', 'Error.prototype.name')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browserkompatibilität">Browserkompatibilität</h2>
+
+<div>
+<div>
+
+
+<p>{{Compat("javascript.builtins.Error.name")}}</p>
+</div>
+</div>
+
+<h2 id="Siehe_auch">Siehe auch</h2>
+
+<ul>
+ <li>{{jsxref("Error.prototype.message")}}</li>
+ <li>{{jsxref("Error.prototype.toString()")}}</li>
+</ul>
diff --git a/files/de/web/javascript/reference/global_objects/error/prototype/index.html b/files/de/web/javascript/reference/global_objects/error/prototype/index.html
new file mode 100644
index 0000000000..f383b474ea
--- /dev/null
+++ b/files/de/web/javascript/reference/global_objects/error/prototype/index.html
@@ -0,0 +1,113 @@
+---
+title: Error.prototype
+slug: Web/JavaScript/Reference/Global_Objects/Error/prototype
+tags:
+  - Error
+  - JavaScript
+  - Property
+translation_of: Web/JavaScript/Reference/Global_Objects/Error
+---
+<div>{{JSRef}}</div>
+
+<p>Die <code><strong>Error.prototype</strong></code> Eigenschaft repräsentiert den Prototypen für den {{jsxref("Error")}} Konstruktor.</p>
+
+<div>{{js_property_attributes(0, 0, 0)}}</div>
+
+<h2 id="Beschreibung">Beschreibung</h2>
+
+<p>Alle {{jsxref("Error")}} Instanzen und Instanzen von {{jsxref("Global_Objects/Error", "nicht generischen Errors", "#Error_types", 1)}} erben von <code>Error.prototype</code>. Wie bei jeder Konstruktorfunktion, kann man den Prototypen des Konstruktors einsetzen, um Eigenschaften oder Methoden bei allen erstellten Instanzen hinzuzufügen.</p>
+
+<h2 id="Eigenschaften">Eigenschaften</h2>
+
+<h3 id="Standard-Eigenschaften">Standard-Eigenschaften</h3>
+
+<dl>
+ <dt><code>Error.prototype.constructor</code></dt>
+ <dd>Spezifiziert die Funktion, die einen Prototypen einer Instanz erstellt.</dd>
+ <dt>{{jsxref("Error.prototype.message")}}</dt>
+ <dd>Errornachricht.</dd>
+ <dt>{{jsxref("Error.prototype.name")}}</dt>
+ <dd>Errorname.</dd>
+</dl>
+
+<h3 id="Vendor-spezifische_Erweiterungen">Vendor-spezifische Erweiterungen</h3>
+
+<div>{{non-standard_header}}</div>
+
+<h4 id="Microsoft">Microsoft</h4>
+
+<dl>
+ <dt>{{jsxref("Error.prototype.description")}} {{non-standard_inline}}</dt>
+ <dd>Errorbeschreibung. Ist das gleiche wie {{jsxref("Error.prototype.message")}}</dd>
+ <dt>{{jsxref("Error.prototype.number")}} {{non-standard_inline}}</dt>
+ <dd>Errornummer.</dd>
+</dl>
+
+<h4 id="Mozilla">Mozilla</h4>
+
+<dl>
+ <dt>{{jsxref("Error.prototype.fileName")}} {{non-standard_inline}}</dt>
+ <dd>Pfad zu der Datei, die der der Error ausgelöst wurde.</dd>
+ <dt>{{jsxref("Error.prototype.lineNumber")}} {{non-standard_inline}}</dt>
+ <dd>Zeilennummer in der Datei, in der der Error ausgelöst wurde.</dd>
+ <dt>{{jsxref("Error.prototype.columnNumber")}} {{non-standard_inline}}</dt>
+ <dd>Spaltennummer in der Zeile, in der der Error ausgelöst wurde.</dd>
+ <dt>{{jsxref("Error.prototype.stack")}} {{non-standard_inline}}</dt>
+ <dd>Stacktrace.</dd>
+</dl>
+
+<h2 id="Methoden">Methoden</h2>
+
+<dl>
+ <dt>{{jsxref("Error.prototype.toSource()")}} {{non-standard_inline}}</dt>
+ <dd>Gibt einen String zurück, der den Quelltext eines spezifischen {{jsxref("Error")}} Objektes beinhaltet. Man kann diesen einsetzen, um ein neues Objekt zu erstellen. Überschreibt die {{jsxref("Object.prototype.toSource()")}} Methode.</dd>
+ <dt>{{jsxref("Error.prototype.toString()")}}</dt>
+ <dd>Gibt einen String zurück, der das Objekt repräsentiert. Überschreibt die {{jsxref("Object.prototype.toString()")}} Methode.</dd>
+</dl>
+
+<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('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Initiale Definition. Implementiert in JavaScript 1.1.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.11.3.1', 'Error')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-error.prototype', 'Error')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-error.prototype', 'Error')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browserkompatibilität">Browserkompatibilität</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.Error.prototype")}}</p>
+</div>
+
+<h2 id="Siehe_auch">Siehe auch</h2>
+
+<ul>
+ <li>{{jsxref("Error")}}</li>
+ <li>{{jsxref("Object.prototype")}}</li>
+</ul>
diff --git a/files/de/web/javascript/reference/global_objects/error/stack/index.html b/files/de/web/javascript/reference/global_objects/error/stack/index.html
new file mode 100644
index 0000000000..ed930983bc
--- /dev/null
+++ b/files/de/web/javascript/reference/global_objects/error/stack/index.html
@@ -0,0 +1,124 @@
+---
+title: Error.prototype.stack
+slug: Web/JavaScript/Reference/Global_Objects/Error/Stack
+tags:
+  - Error
+  - JavaScript
+  - Non-standard
+  - Property
+  - Prototype
+  - Reference
+translation_of: Web/JavaScript/Reference/Global_Objects/Error/Stack
+---
+<div>{{JSRef}} {{non-standard_header}}</div>
+
+<p>Die nicht standardisierte <strong><code>stack</code></strong> Eigenschaft des {{jsxref("Error")}} Objektes zeigt den Verlauf der aufgerufenen Funktionen. Dabei wird die Reihenfolge der Aufrufe, der Zeile und die Datei der Aufrufes und die übergebenen Argumenten angegeben. Der stack String verläuft von den jüngsten Aufrufen zu den vorherigen Aufrufen, bis zum globalen Scope zurück.</p>
+
+<h2 id="Beschreibung">Beschreibung</h2>
+
+<p>Jeder Schritt wird durch einen neue Zeile getrennt. Der erste Teil einer Zeile besteht aus dem Funktionsnamen (wenn es kein Aufruf vom globalen Scope ist), gefolgt von einem @-Zeichen, dem Dateiort (ausgenommen, wenn die Funktion der Error-Konstruktor des geworfenen Errors ist), einem Doppelpunkt und einer Zeilennummer, wenn ein Dateiort existiert. Zu beachten ist, dass das {{jsxref("Error")}} Objekt auch die Eigenschaften <code>fileName</code>, <code>lineNumber</code> und <code>columnNumber</code> besitzt, um dieses von geworfenen Error wiederherzustellen (aber nur dem Fehler und nicht seinem trace).</p>
+
+<p>Zu beachten ist, dass dieses das Format von Firefox ist. Es gibt keine Standardformat, auch wenn Safari 6+ und Opera 12- ein ähnliches Format verwenden. Browser die die V8 JavaScript Umgebung benutzen (z. B. Chrome, Opera 15+, Android Browser) und IE10+ nutzen ein anderes Format (zusehen in den MSDN <a class="external" href="http://msdn.microsoft.com/en-us/library/windows/apps/hh699850.aspx">error.stack</a> docs).</p>
+
+<p><strong>Parameter Werte im Stack:</strong> Bis Firefox 14 ({{bug("744842")}}) folgten auf den Funktionsnamen die zu Strings konvertierten Werte der Parameter in runden Klammern vor dem @-Zeichen. Während ein Objekt (oder Array, etc.) zu<code> "[object Object]"</code> konvertiert werden und diese Werte nicht zurück zu einem existierenden Objekt ausgewertet werden können, können skalare Werte zurückverfolgt werden (manchmal kann es einfacher sein — nur in Firefox 14 möglich — <code>arguments.callee.caller.arguments</code> zu benutzen, der Funktionsname kann mit <code>arguments.callee.caller.name</code> erfragt werden). <code>"undefined"</code> wird mit <code>"(void 0)"</code> dargestellt. Zu beachten ist, dass String Argumente (oder auch Dateinamen), die Zeichen wie "@", "(", ")" beinhalten dazu führen, dass es nicht einfach ist, die Zeile in seine Komponenten aufzuteilen. In Firefox 14+ ist dieses kein Problem mehr.</p>
+
+<p>Verschiedene Browser setzen den this Wert zu verschiedenen Zeitpunkten. Zum Beispiel setzt Firefox diesen beim erstellen eines {{jsxref("Error")}} Objektes, während PhantomJS dieses nur setzt, wenn das {{jsxref("Error")}} Objekt geworfen wird und <a href="http://msdn.microsoft.com/en-us/library/windows/apps/hh699850.aspx">MSDN docs</a> scheinen diesem verhalten auch zu folgen.</p>
+
+<h2 id="Beispiele">Beispiele</h2>
+
+<p>Der folgende HTML-Quelltext demonstriert den Einsatz der <code>stack</code> Eigenschaft.</p>
+
+<pre class="brush: html">&lt;!DOCTYPE HTML&gt;
+&lt;meta charset="UTF-8"&gt;
+&lt;title&gt;Stack Trace Example&lt;/title&gt;
+&lt;body&gt;
+&lt;script&gt;
+function trace() {
+  try {
+    throw new Error('myError');
+  }
+  catch(e) {
+    alert(e.stack);
+  }
+}
+function b() {
+  trace();
+}
+function a() {
+  b(3, 4, '\n\n', undefined, {});
+}
+a('first call, firstarg');
+&lt;/script&gt;
+</pre>
+
+<p>Angenommen der oben stehende Quelltext ist auf einen Windows Datei System unter <code>C:\example.html</code> gespeichert, wird der folgende Text ausgegeben:</p>
+
+<p>Mit Firefox 30+ wird die Spaltennummer mit angegeben ({{bug("762556")}}):</p>
+
+<pre><samp>trace@file:///C:/example.html:9:17
+b@file:///C:/example.html:16:13
+a@file:///C:/example.html:19:13
+@file:///C:/example.html:21:9</samp></pre>
+
+<p>Von Firefox 14 bis Firefox 29:</p>
+
+<pre><samp>trace@file:///C:/example.html:9
+b@file:///C:/example.html:16
+a@file:///C:/example.html:19
+@file:///C:/example.html:21</samp></pre>
+
+<p>Bis Firefox 13 wird folgender Text ausgegeben:</p>
+
+<pre><samp>Error("myError")@:0
+trace()@file:///C:/example.html:9
+b(3,4,"\n\n",(void 0),[object Object])@file:///C:/example.html:16
+a("first call, firstarg")@file:///C:/example.html:19
+@file:///C:/example.html:21</samp></pre>
+
+<h3 id="Stacks_von_eval_Quelltext">Stacks von eval Quelltext</h3>
+
+<p>Angefangen mit Firefox 30 {{geckoRelease("30")}} enthällt der Stack von Errors auch Informationen von <code>Function()</code> und <code>eval()</code> Aufrufen mit detailierten Spalten- und Zeilennummern innerhalb dieser Aufrufe. Funktionsaufrufe werden mit <code>"&gt; Function"</code> angezeigt, Aufrufe mit eval werden mit <code>"&gt; eval"</code> angezeigt. Siehe {{bug("332176")}}.</p>
+
+<pre class="brush: js">try {
+  new Function('throw new Error()')();
+} catch (e) {
+  console.log(e.stack);
+}
+
+// anonymous@file:///C:/example.html line 7 &gt; Function:1:1
+// @file:///C:/example.html:7:6
+
+
+try {
+  eval("eval('FAIL')");
+} catch (x) {
+  console.log(x.stack);
+}
+
+// @file:///C:/example.html line 7 &gt; eval line 1 &gt; eval:1:1
+// @file:///C:/example.html line 7 &gt; eval:1:1
+// @file:///C:/example.html:7:6
+</pre>
+
+<p>Man kann auch die <code>//# sourceURL</code> Direktive benutzen, um den eval-Code zu benennen. Siehe auch <a href="/de/docs/Tools/Debugger/How_to/Debug_eval_sources">Debug eval sources</a> in den <a href="/de/docs/Tools/Debugger">Debugger</a> docs und diesen <a href="http://fitzgeraldnick.com/weblog/59/">Blogeintrag</a>.</p>
+
+<h2 id="Spezifikationen">Spezifikationen</h2>
+
+<p>Ist kein Teil einer Spezifikation, nicht standardisiert.</p>
+
+<h2 id="Browserkompatibilität">Browserkompatibilität</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.Error.stack")}}</p>
+</div>
+
+<h2 id="Siehe_auch">Siehe auch</h2>
+
+<ul>
+ <li><a href="/de/docs/Components.stack">Components.stack</a></li>
+ <li>Externe Projekte: <a class="link-https" href="https://github.com/csnover/TraceKit/">TraceKit</a> und <a class="link-https" href="https://github.com/eriwen/javascript-stacktrace">javascript-stacktrace</a></li>
+ <li>MSDN: <a class="external" href="http://msdn.microsoft.com/en-us/library/windows/apps/hh699850.aspx" title="http://msdn.microsoft.com/en-us/library/windows/apps/hh699850.aspx">error.stack</a> docs</li>
+ <li><a href="https://github.com/v8/v8/wiki/Stack%20Trace%20API">Überblick über die V8 JavaScript Stack Trace API</a></li>
+</ul>
diff --git a/files/de/web/javascript/reference/global_objects/error/tosource/index.html b/files/de/web/javascript/reference/global_objects/error/tosource/index.html
new file mode 100644
index 0000000000..59025435f5
--- /dev/null
+++ b/files/de/web/javascript/reference/global_objects/error/tosource/index.html
@@ -0,0 +1,57 @@
+---
+title: Error.prototype.toSource()
+slug: Web/JavaScript/Reference/Global_Objects/Error/toSource
+tags:
+  - Error
+  - JavaScript
+  - Method
+  - Non-standard
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Error/toSource
+---
+<div>{{JSRef}} {{non-standard_header}}</div>
+
+<p>Die <code><strong>toSource()</strong></code> Methode gibt den Quelltext zurück, der zu dem selben Error ausgewertet werden kann.</p>
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox"><var>e</var>.toSource()</pre>
+
+<h3 id="Rückgabewert">Rückgabewert</h3>
+
+<p>Ein String, der den Quelltext des Fehlers enthält.</p>
+
+<h2 id="Beschreibung">Beschreibung</h2>
+
+<p>Das Aufrufen der <code>toSource</code> Methode auf einer {{jsxref("Error")}} Instanz (auch bei<em> <a href="/de/docs/Web/JavaScript/Reference/Global_Objects/Error#Error_Typen">NativeErrors</a></em>) gibt einen String zurück, der den Quelltext der Instanz enthält. Dieser String kann ausgeführt werden, um (annähernd) gleiches Objekt zu erzeugen. Normalerweise enthält der String den Quelltext des {{jsxref("Error")}} Konstruktors. Zum Beispiel:</p>
+
+<pre class="brush: js">(new<em>name</em>(<em>message</em> ,<em>fileName</em>,<em>lineNumber</em>))
+</pre>
+
+<p>wo die Attribute den Eigenschaften der Error-Instanz entsprechen.</p>
+
+<div class="note">
+<p><strong>Bemerkung:</strong> <span id="result_box" lang="de"><span>Seien Sie sich bewusst</span><span>, dass die Eigenschaften</span>, <span>die</span> <span>durch die toSource</span> <span>Methode</span> <span>bei der Erstellung</span> des Strings <span>verwendet</span>, veränderbar <span>sind</span> <span>und</span> <span>nicht genau die</span> <span>Funktion</span> <span>widerspiegeln</span><span>, die eine Fehler</span> <span>Instanz erstellt habt. Das betrifft</span><span> den Dateinamen </span><span>und</span> <span>die Zeilennummer.</span></span></p>
+</div>
+
+<h2 id="Spezifikationen">Spezifikationen</h2>
+
+<p>In keine Spezifikation enthalten. Implementiert in JavaScript 1.3.</p>
+
+<h2 id="Browserkompatibilität">Browserkompatibilität</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.Error.toSource")}}</p>
+</div>
+
+<h2 id="See_auch">See auch</h2>
+
+<ul>
+ <li>{{jsxref("Error.prototype.fileName")}}</li>
+ <li>{{jsxref("Error.prototype.lineNumber")}}</li>
+ <li>{{jsxref("Error.prototype.message")}}</li>
+ <li>{{jsxref("Error.prototype.name")}}</li>
+ <li>{{jsxref("Object.prototype.toSource()")}}</li>
+</ul>
diff --git a/files/de/web/javascript/reference/global_objects/error/tostring/index.html b/files/de/web/javascript/reference/global_objects/error/tostring/index.html
new file mode 100644
index 0000000000..15565bd296
--- /dev/null
+++ b/files/de/web/javascript/reference/global_objects/error/tostring/index.html
@@ -0,0 +1,116 @@
+---
+title: Error.prototype.toString()
+slug: Web/JavaScript/Reference/Global_Objects/Error/toString
+tags:
+  - Error
+  - JavaScript
+  - Method
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Error/toString
+---
+<div>{{JSRef}}</div>
+
+<div>Die <code><strong>toString()</strong></code> Methode gibt einen String zurück, der das {{jsxref("Error")}} Objekt repräsentiert.</div>
+
+<div> </div>
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox"><code><var>e</var>.toString()</code></pre>
+
+<h3 id="Rückgabewert">Rückgabewert</h3>
+
+<p>Einen String, der das gegebenen {{jsxref("Error")}} Objekt repräsentiert.</p>
+
+<h2 id="Beschreibung">Beschreibung</h2>
+
+<p>Das {{jsxref("Error")}} Objekt überschreibt die {{jsxref("Object.prototype.toString()")}} Methode, die an allen Objekte vererbt werden. Die Semanik ist die folgende (angenommen {{jsxref("Object")}} und {{jsxref("String")}} wurden nicht verändert):</p>
+
+<pre class="brush: js">Error.prototype.toString = function() {
+  'use strict';
+
+  var obj = Object(this);
+  if (obj !== this) {
+    throw new TypeError();
+  }
+
+  var name = this.name;
+  name = (name === undefined) ? 'Error' : String(name);
+
+  var msg = this.message;
+  msg = (msg === undefined) ? '' : String(msg);
+
+  if (name === '') {
+    return msg;
+  }
+  if (msg === '') {
+    return name;
+  }
+
+  return name + ': ' + msg;
+};
+</pre>
+
+<h2 id="Beispiele">Beispiele</h2>
+
+<pre class="brush: js">var e = new Error('fatal error');
+console.log(e.toString()); // 'Error: fatal error'
+
+e.name = undefined;
+console.log(e.toString()); // 'Error: fatal error'
+
+e.name = '';
+console.log(e.toString()); // 'fatal error'
+
+e.message = undefined;
+console.log(e.toString()); // 'Error'
+
+e.name = 'hello';
+console.log(e.toString()); // 'hello'
+</pre>
+
+<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('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Initiale Definition. Implementiert in JavaScript 1.1.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.11.4.4', 'Error.prototype.toString')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-error.prototype.tostring', 'Error.prototype.toString')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-error.prototype.tostring', 'Error.prototype.toString')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browserkompatibilität">Browserkompatibilität</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.Error.toString")}}</p>
+</div>
+
+<h2 id="Siehe_auch">Siehe auch</h2>
+
+<ul>
+ <li>{{jsxref("Error.prototype.toSource()")}}</li>
+</ul>