initial commit

6 files changed, 881 insertions, 0 deletions

diff --git a/files/de/web/javascript/reference/global_objects/promise/all/index.html b/files/de/web/javascript/reference/global_objects/promise/all/index.html
new file mode 100644
index 0000000000..9753db7994
--- /dev/null
+++ b/files/de/web/javascript/reference/global_objects/promise/all/index.html
@@ -0,0 +1,137 @@
+---
+title: Promise.all()
+slug: Web/JavaScript/Reference/Global_Objects/Promise/all
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Méthode
+  - Promise
+translation_of: Web/JavaScript/Reference/Global_Objects/Promise/all
+---
+<div>{{JSRef}}</div>
+
+<p>Die <code><strong>Promise.all(iterable)</strong></code> Methode gibt einen {{jsxref("Promise")}} zurück, welcher erfüllt(<em>resolved)</em> wird, wenn alle Promises in dem <em>iterable </em>- Argument erfüllt wurden oder wenn das <em>iterable</em> - Argument keine Promises enthält. Eine Ablehnung (<em>reject</em>) erfolgt mit dem Grund des ersten Promises, das abgelehnt wurde, oder mit dem Error der von dem ersten Argument, wenn das innerhalb eines try/catch/throw blocks gefangen wurde.</p>
+
+<p>Es wird typischerweise für mehrere asynchrone Aufgaben die parallel laufen und die Promises als Ergebnisse haben, so das eines warten kann, bis alle anderen Aufgaben abgeschlossen sind.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/promise-all.html")}}</div>
+
+<p class="hidden">Die Quellen für diese interaktive Demo sind in einem GitHub Repository gespeichert. Wenn Du etwas zum interaktiven Demo Projekt beitragen willst, klone das Repository  <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> und schicke uns einen pull request.</p>
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox">Promise.all(<var>iterable</var>);</pre>
+
+<h3 id="Parameter">Parameter</h3>
+
+<dl>
+ <dt>iterable</dt>
+ <dd>Ein <a href="/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterable_protocol">iterierbares</a> Objekt, z.B. ein {{jsxref("Array")}} oder ein {{jsxref("String")}}.</dd>
+</dl>
+
+<h3 id="Rückgabe-Wert">Rückgabe-Wert</h3>
+
+<ul>
+ <li>Ein <strong>bereits eingelöstes</strong> {{jsxref("Promise")}}, wenn das eingegebene <em>iterable</em> - Argument leer ist.</li>
+ <li>Ein <strong>asynchron eingelöstes</strong> {{jsxref("Promise")}}, wenn das eingegebene <em>iterable</em> - Argument keine Promises enthält. Achtung, Google Chrome 58 gibt in diesem Fall ein <strong>bereits eingelöstes</strong> Promise zurück.</li>
+ <li>Ein <strong>ausstehendes</strong> (<em>pending</em>) {{jsxref("Promise")}} in allen anderen Fällen. Dieses zurückgegebene Promise wird dann <strong>asynchron</strong> erfüllt/abgelehnt (sobald der <em>stack</em> leer ist), wenn alle Promises des gegebenen <em>iterable</em> erfüllt wurden, oder wenn irgendeiner der Promises abgelehnt wird. Die Rückgabewerte entsprechen dann der Reihenfolge der Promises, unabhängig von der Reihenfolge der Erfüllung.</li>
+</ul>
+
+<h2 id="Beschreibung">Beschreibung</h2>
+
+<p>Diese Methode dient dem Bündeln von mehreren Promises.</p>
+
+<p>Erfüllt: <br>
+ Wenn alle Promises erfolgreich erfüllt werden, oder keine Promises sind, wird <code>Promise.all</code> mit einem Array, welches die Rückgabewerte der einzelnen Promises (aber auch die nicht-Promise Werte) enthält, erfüllt. Wenn ein leeres Array übergeben wird, wird  <code>Promise.all</code> (synchron) sofort erfüllt. </p>
+
+<p>Abgelehnt:<br>
+ Wenn eines der übergebenen Promises abgelehnt wird, wird <code>Promise.all</code> asynchron mit dem Wert des fehlgeschlagenen Promise abgelehnt, ganz egal, ob die anderen Promises erfolgreich waren oder nicht.</p>
+
+<h2 id="Beispiele">Beispiele</h2>
+
+<h3 id="Erfolgreich">Erfolgreich:</h3>
+
+<pre class="brush: js">var p1 = Promise.resolve(3);
+var p2 = 1337;
+var p3 = new Promise((resolve, reject) =&gt; {
+   setTimeout(resolve, 100, 'foo');
+});
+
+Promise.all([p1, p2, p3])
+.then(values =&gt; {
+  console.log(values); // [3, 1337, "foo"]
+});
+</pre>
+
+<h3 id="Sofortige_Ablehnung">Sofortige Ablehnung:</h3>
+
+<pre class="brush: js">var p1 = new Promise((resolve, reject) =&gt; {
+  setTimeout(resolve, 1000, 'one');
+});
+var p2 = new Promise((resolve, reject) =&gt; {
+  setTimeout(resolve, 2000, 'two');
+});
+var p3 = new Promise((resolve, reject) =&gt; {
+  setTimeout(resolve, 3000, 'three');
+});
+var p4 = new Promise((resolve, reject) =&gt; {
+  setTimeout(resolve, 4000, 'four');
+});
+var p5 = new Promise((resolve, reject) =&gt; {
+  reject('reject');
+});
+
+Promise.all([p1, p2, p3, p4, p5]).then(values =&gt; {
+  console.log(values);
+}, reason =&gt; {
+  console.log(reason)
+});
+
+//From console:
+//"reject"
+
+//You can also use .catch
+Promise.all([p1, p2, p3, p4, p5]).then(values =&gt; {
+  console.log(values);
+}).catch(reason =&gt; {
+  console.log(reason)
+});
+
+//From console:
+//"reject"
+</pre>
+
+<h2 id="Spezifikationen">Spezifikationen</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td><a href="https://github.com/domenic/promises-unwrapping">domenic/promises-unwrapping</a></td>
+   <td>Draft</td>
+   <td>Standardization work is taking place here.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-promise.all', 'Promise.all')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Initial definition in an ECMA standard.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browserkompatiblität">Browserkompatiblität</h2>
+
+<p class="hidden">To contribute to this compatibility data, please write a pull request against this repository: <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p>
+
+<p>{{Compat("javascript.builtins.Promise.all")}}</p>
+
+<h2 id="Siehe_auch">Siehe auch</h2>
+
+<ul>
+ <li>{{jsxref("Promise")}}</li>
+ <li>{{jsxref("Promise.race()")}}</li>
+</ul>
diff --git a/files/de/web/javascript/reference/global_objects/promise/finally/index.html b/files/de/web/javascript/reference/global_objects/promise/finally/index.html
new file mode 100644
index 0000000000..588d00d43f
--- /dev/null
+++ b/files/de/web/javascript/reference/global_objects/promise/finally/index.html
@@ -0,0 +1,93 @@
+---
+title: Promise.prototype.finally()
+slug: Web/JavaScript/Reference/Global_Objects/Promise/finally
+translation_of: Web/JavaScript/Reference/Global_Objects/Promise/finally
+---
+<div>{{JSRef}}</div>
+
+<p>finally () gibt ein {{jsxref ("Promise")}} zurück. Wenn das Promise erfüllt oder abgelehnt wird, wird die angegebene callback-Funktion ausgeführt. Dies stellt eine Möglichkeit für Code bereit, der ausgeführt werden muss, unabhängig davon, ob das Promise erfolgreich erfüllt wurde oder nicht. Auf diese Weise können Sie vermeiden, dass derselbe Code für die beiden Handlern des Promise {{jsxref ("Promise.then", "then ()")}} und {{jsxref ("Promise.catch", "catch ()")}} geschrieben werden muss.</p>
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox"><var>p.finally(onFinally)</var>;
+
+p.finally(function() {
+   // settled (fulfilled or rejected)
+});
+</pre>
+
+<h3 id="Parameters">Parameters</h3>
+
+<dl>
+ <dt><code>onFinally</code></dt>
+ <dd>A {{jsxref("Function")}} called when the <code>Promise</code> is settled.</dd>
+</dl>
+
+<h3 id="Return_value">Return value</h3>
+
+<p>Returns a {{jsxref("Promise")}} whose <code>finally</code> handler is set to the specified function, <code>onFinally</code>.</p>
+
+<h2 id="Description">Description</h2>
+
+<p>The <code>finally()</code> method can be useful if you want to do some processing or cleanup once the promise is settled, regardless of its outcome.</p>
+
+<p>The <code>finally()</code> method is very similar to calling <code>.then(onFinally, onFinally)</code> however there are couple of differences:</p>
+
+<ul>
+ <li>When creating a function inline, you can pass it once, instead of being forced to either declare it twice, or create a variable for it</li>
+ <li>A <code>finally</code> callback will not receive any argument, since there's no reliable means of determining if the promise was fulfilled or rejected. This use case is for precisely when you <em>do not care</em> about the rejection reason, or the fulfillment value, and so there's no need to provide it.</li>
+ <li>Unlike <code>Promise.resolve(2).then(() =&gt; {}, () =&gt; {})</code> (which will be resolved with <code>undefined</code>), <code>Promise.resolve(2).finally(() =&gt; {})</code> will be resolved with <code>2</code>.</li>
+ <li>Similarly, unlike <code>Promise.reject(3).then(() =&gt; {}, () =&gt; {})</code> (which will be fulfilled with <code>undefined</code>), <code>Promise.reject(3).finally(() =&gt; {})</code> will be rejected with <code>3</code>.</li>
+</ul>
+
+<div class="note">
+<p><strong>Note:</strong> A <code>throw</code> (or returning a rejected promise) in the <code>finally</code> callback will reject the new promise with the rejection reason specified when calling <code>throw()</code>.</p>
+</div>
+
+<h2 id="Examples">Examples</h2>
+
+<pre class="brush: js">let isLoading = true;
+
+fetch(myRequest).then(function(response) {
+    var contentType = response.headers.get("content-type");
+    if(contentType &amp;&amp; contentType.includes("application/json")) {
+      return response.json();
+    }
+    throw new TypeError("Oops, we haven't got JSON!");
+  })
+  .then(function(json) { /* process your JSON further */ })
+  .catch(function(error) { console.log(error); })
+  .finally(function() { isLoading = false; });
+
+</pre>
+
+<h2 id="Specifications">Specifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td><a href="https://github.com/tc39/proposal-promise-finally">TC39 proposal</a></td>
+   <td>Stage 4</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility">Browser compatibility</h2>
+
+<p class="hidden">To contribute to this compatibility data, please write a pull request against this repository: <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p>
+
+<p>{{Compat("javascript.builtins.Promise.finally")}}</p>
+
+<h2 id="See_also">See also</h2>
+
+<ul>
+ <li>{{jsxref("Promise")}}</li>
+ <li>{{jsxref("Promise.prototype.then()")}}</li>
+ <li>{{jsxref("Promise.prototype.catch()")}}</li>
+</ul>
diff --git a/files/de/web/javascript/reference/global_objects/promise/index.html b/files/de/web/javascript/reference/global_objects/promise/index.html
new file mode 100644
index 0000000000..9e9756ac65
--- /dev/null
+++ b/files/de/web/javascript/reference/global_objects/promise/index.html
@@ -0,0 +1,244 @@
+---
+title: Promise
+slug: Web/JavaScript/Reference/Global_Objects/Promise
+translation_of: Web/JavaScript/Reference/Global_Objects/Promise
+---
+<div>{{JSRef}}</div>
+
+<p>Das <strong><code>Promise</code></strong> Objekt stellt eine Repräsentation einer eventuellen Ausführung (oder eines Fehlschlags) einer asynchronen Operation und den daraus resultierenden Ergebnissen dar.</p>
+
+<p>Um mehr darüber zu erfahren wie promises funktionieren und wie diese verwendet werden sollte zuerst <a href="/de-DE/docs/Web/JavaScript/Guide/Using_promises">Promises benutzen</a> gelesen werden.</p>
+
+<dl>
+</dl>
+
+<h2 id="Beschreibung">Beschreibung</h2>
+
+<p>Das <strong><code>Promise-Objekt (dt./deutsch Ein Versprechens-Objekt, das später eingelöst wird)</code></strong>wird für asynchrone Berechnungen verwendet.</p>
+
+<p>Ein <code>Promise</code> kann sich in einem von drei Zuständen befinden:</p>
+
+<ul>
+ <li><em>pending</em> (schwebend): initialer Status, weder fulfilled noch rejected.</li>
+ <li><em>fulfilled</em> (erfüllt): heisst das die Operation erfolgreich abgeschlossen wurde.</li>
+ <li><em>rejected</em> (zurück gewiesen): heisst das die Operation gescheitert ist.</li>
+</ul>
+
+<p>Ein weiterer Begriff beschreibt den Zustand <em>settled (erledigt aber nicht zwingend erfolgreich)</em>: Der Promise ist entweder <em>fulfilled</em> oder <em>rejected</em>, aber nicht <em>pending</em>.</p>
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox notranslate">new Promise(<em>executor</em>);
+new Promise(function(resolve, reject) { ... });</pre>
+
+<h3 id="Parameter">Parameter</h3>
+
+<dl>
+ <dt>executor (Ausführer)</dt>
+ <dd>Funktion mit den zwei Argumenten <code>resolve</code> und <code>reject</code>. Das erste Argument führt den Promise aus, das zweite verwirft ihn. Die Funktionen können ausgeführt werden, sobald die Operation durchgeführt wurde.</dd>
+</dl>
+
+<h2 id="Beschreibung_2">Beschreibung</h2>
+
+<p>Das <code><strong>Promise</strong></code>-Interface repräsentiert einen Proxy für einen Wert, der nicht zwingend bekannt ist, wenn der Promise erstellt wird. Das erlaubt die Assoziation zwischen <em>Handler</em> und dem Gelingen oder Fehlschlagen einer asynchronen Aktion. Mit diesem Mechanismus können asynchrone Methoden in gleicher Weise Werte zurück geben wie synchrone Methoden: Anstelle des endgültigen Wertes wird ein <em>Promise</em> zurückgegeben, dass es zu einem Zeitpunkt in der Zukunft einen Wert geben wird.</p>
+
+<p>Ein Promise mit dem Status <em>pending</em> kann entweder zu <em>fulfilled</em> mit Wert oder zu einem <em>rejected</em> mit Grund werden. Wenn einer dieser Fälle eintritt, werden die assoziierten <em>Handler</em>, die über die <em>then</em>-Methode gequeued wurde, aufgerufen. Ist ein Promise bereits in fullfilled oder rejected und wird erst dann ein entsprechender <em>Handler</em> hinzugefügt, dann wird dieser Handler aufgerufen. Es gibt somit keine <em>Race Conditions</em> zwischen der Ausführung der asynchronen Aktion und dem Hinzufügen des <em>Handlers</em>.</p>
+
+<p>Da die Methoden<code> Promise.prototype.then</code> und <code>Promise.prototype.catch</code> Promises zurückgeben, können sie aneinander gereiht werden (Komposition).</p>
+
+<p><img alt="" src="https://mdn.mozillademos.org/files/8633/promises.png" style="height: 297px; width: 801px;"></p>
+
+<h2 id="Properties">Properties</h2>
+
+<dl>
+ <dt><code>Promise.length</code></dt>
+ <dd><em>Length</em>-Attribut mit dem Wert 1 (Anzahl der Konstruktorargumente).</dd>
+ <dt>{{jsxref("Promise.prototype")}}</dt>
+ <dd>Repräsentiert den Prototyp für den <code>Promise</code>-Konstruktor.</dd>
+</dl>
+
+<h2 id="Methoden">Methoden</h2>
+
+<dl>
+ <dt>{{jsxref("Promise.all", "Promise.all(iterable)")}}</dt>
+ <dd>Gibt einen <code>Promise</code> zurück, der aufgelöst wird, sobald alle Promises in dem <code>iterable</code>-Argument aufgelöst wurden.</dd>
+ <dt>{{jsxref("Promise.race", "Promise.race(iterable)")}}</dt>
+ <dd>Gibt einen <code>Promise</code> zurück, der aufgelöst oder verworfen wird, sobald einer der Promises in dem <code>iterable</code>-Argument aufgelöst oder verworfen wurde, und den Wert oder den Grund dieses Promise enthält.</dd>
+</dl>
+
+<dl>
+ <dt>{{jsxref("Promise.reject", "Promise.reject(reason)")}}</dt>
+ <dd>Gibt einen <code>Promise</code> zurück, der mit dem angegeben Grund (<code>reason</code>) verworfen wird.</dd>
+</dl>
+
+<dl>
+ <dt>{{jsxref("Promise.resolve", "Promise.resolve(value)")}}</dt>
+ <dd>Gibt einen <code>Promise</code> zurück, der mit <code>value</code> aufgelöst wird. Falls der Wert ein <em>thenable</em> ist (Objekt besitzt eine <code>then</code>-Methode), folgt der zurückgegebene <code>Promise</code> dem <em>thenable</em> und übernimmt den Status. Andernfalls wird der zurückgegebene <code>Promise</code> auf <em>fulfilled</em> gesetzt.</dd>
+</dl>
+
+<h2 id="Promise-Prototyp"><code>Promise</code>-Prototyp</h2>
+
+<h3 id="Eigenschaften">Eigenschaften</h3>
+
+<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/Promise/prototype','Eigenschaften')}}</p>
+
+<h3 id="Methoden_2">Methoden</h3>
+
+<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/Promise/prototype','Methoden')}}</p>
+
+<h2 id="Beispiele">Beispiele</h2>
+
+<h3 id="Einen_Promise_erstellen">Einen Promise erstellen</h3>
+
+<pre class="brush: html notranslate" style="display: none;">&lt;button id="btn"&gt;Make a promise!&lt;/button&gt;
+&lt;div id="log"&gt;&lt;/div&gt;
+</pre>
+
+<p>Dieses kleine Beispiel zeigt den Mechanismus eines <code>Promise</code>. Die Methode <code>testPromise() </code>wird jedes Mal aufgerufen, wenn der {{HTMLElement("button")}} geklickt wurde. Es wird ein Promise erstellt, der mithilfe von <code>window.setTimeout</code> nach einer zufällig gewählten Zeit (1-3 s) zu <code>'result'</code> aufgelöst wird.</p>
+
+<p>Die Ausführung der Promises wird mit einem <em>fulfill</em>-Callback unter Verwendung von <code>p1.then</code> gelogt. Durch ein paar Logeinträge wird gezeigt, wie der synchrone Teil der Methode von der asynchronen Vollendung des Promises abgekoppelt ist.</p>
+
+<pre class="brush: js notranslate">var promiseCount = 0;
+function testPromise() {
+  var thisPromiseCount = ++promiseCount;
+
+  var log = document.getElementById('log');
+  log.insertAdjacentHTML('beforeend', thisPromiseCount +
+      ') Started (&lt;small&gt;Sync code started&lt;/small&gt;)&lt;br/&gt;');
+
+  // Wir erstellen einen neuen Promise: wir versprechen den String 'result' (Wartezeit max. 3s)
+  var p1 = new Promise(
+    // Resolver-Funktion kann den Promise sowohl auflösen als auch verwerfen
+    // reject the promise
+    function(resolve, reject) {
+      log.insertAdjacentHTML('beforeend', thisPromiseCount +
+          ') Promise started (&lt;small&gt;Async code started&lt;/small&gt;)&lt;br/&gt;');
+      // nur ein Beispiel, wie Asynchronität erstellt werden kann
+      window.setTimeout(
+        function() {
+          // We fulfill the promise !
+          resolve(thisPromiseCount)
+        }, Math.random() * 2000 + 1000);
+    });
+
+  // wir bestimmen, was zu tun ist, wenn der Promise fulfilled
+  p1.then(
+    // Loggen der Nachricht und des Wertes
+    function(val) {
+      log.insertAdjacentHTML('beforeend', val +
+          ') Promise fulfilled (&lt;small&gt;Async code terminated&lt;/small&gt;)&lt;br/&gt;');
+    });
+
+  log.insertAdjacentHTML('beforeend', thisPromiseCount +
+      ') Promise made (&lt;small&gt;Sync code terminated&lt;/small&gt;)&lt;br/&gt;');
+}
+</pre>
+
+<pre class="brush:js notranslate" style="display: none;">if ("Promise" in window) {
+  btn = document.getElementById("btn");
+   btn.addEventListener("click",testPromise);
+}
+else {
+  log = document.getElementById('log');
+  log.innerHTML = "Live example not available as your browser doesn't support the Promise interface.";
+}
+</pre>
+
+<p>Dieses Beispiel wird ausgeführt, wenn der Button geklickt wird. Man benötigt einen Browser, der <em>Promise</em> unterstützt. Durch mehrmaliges Klicken in kurzer Zeit kann beobachtet werden, wie die einzelnen Promises nacheinander <em>fulfilled</em> werden.</p>
+
+<p>{{EmbedLiveSample("Creating_a_Promise", "500", "200")}}</p>
+
+<h3 id="Laden_eines_Bildes_mit_XHR">Laden eines Bildes mit XHR</h3>
+
+<p>Ein weiteres, einfaches Beispiel für die Verwendung von Promises und <code><a href="/en-US/docs/Web/API/XMLHttpRequest">XMLHTTPRequest</a>,</code> um ein Bild zu laden, ist in dem MDN GitHub <a href="https://github.com/mdn/js-examples/blob/master/promises-test/index.html">promise-test</a> Repository. <a href="https://mdn.github.io/js-examples/promises-test/">Hier </a>kannst du es in Aktion sehen. Jeder Schritt ist kommentiert und erlaubt die den Promises und der XHR-Architektur nachzuvollziehen.</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><a href="https://github.com/domenic/promises-unwrapping">domenic/promises-unwrapping</a></td>
+   <td>Draft</td>
+   <td>Standardisierung findet hier statt.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-promise-objects', 'Promise')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Initiale Definition als ein ECMA-Standard.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browserkompatiblität">Browserkompatiblität</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic Support</td>
+   <td>32</td>
+   <td>{{CompatGeckoDesktop(24.0)}} als <code>Future</code><br>
+    {{CompatGeckoDesktop(25.0)}} als <code>Promise</code> hinter einem Flag[1]<br>
+    {{CompatGeckoDesktop(29.0)}} per Default</td>
+   <td>{{CompatNo}}</td>
+   <td>19</td>
+   <td>7.1</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+   <th>Chrome for Android</th>
+  </tr>
+  <tr>
+   <td>Basic Support</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatGeckoMobile(24.0)}} als <code>Future</code><br>
+    {{CompatGeckoMobile(25.0)}} als <code>Promise</code> hinter einem Flag[1]<br>
+    {{CompatGeckoMobile(29.0)}} per Default</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>iOS 8</td>
+   <td>32</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<p>[1] Gecko 24 hat eine experimentelle Implementierung von <em>Promises</em> unter dem vorherigen Namen <em>Future</em>. In Gecko 25 wurde sie in ihren endgültigen Namen umbenannt, wird aber per Default durch das Flag <code>dom.promise.enable</code> unterdrückt. <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=918806">Bug 918806</a> aktiviert Promises per Default in Gecko 29.</p>
+
+<h2 id="Siehe_auch">Siehe auch</h2>
+
+<ul>
+ <li><a href="http://promisesaplus.com/">Promises/A+ specification</a></li>
+ <li><a href="http://www.html5rocks.com/en/tutorials/es6/promises/">Jake Archibald: JavaScript Promises: There and Back Again</a></li>
+ <li><a href="http://de.slideshare.net/domenicdenicola/callbacks-promises-and-coroutines-oh-my-the-evolution-of-asynchronicity-in-javascript">Domenic Denicola: Callbacks, Promises, and Coroutines – Asynchronous Programming Patter in JavaScript</a></li>
+ <li><a href="http://www.mattgreer.org/articles/promises-in-wicked-detail/">Matt Greer: JavaScript Promises ... In Wicked Detail</a></li>
+ <li><a href="https://www.promisejs.org/">Forbes Lindesay: promisejs.org</a></li>
+ <li>Fussnote1: bitte die englischen Begriffe in dieser Übersetzung stehen lassen, da sonst der Zusammenhang zu englischen Dokumentation völlig verloren geht. Worte wie 'Promise' sollte man sich merken, um sie auch in englisch zu verstehen.</li>
+</ul>
diff --git a/files/de/web/javascript/reference/global_objects/promise/race/index.html b/files/de/web/javascript/reference/global_objects/promise/race/index.html
new file mode 100644
index 0000000000..78c4d9edf2
--- /dev/null
+++ b/files/de/web/javascript/reference/global_objects/promise/race/index.html
@@ -0,0 +1,184 @@
+---
+title: Promise.race()
+slug: Web/JavaScript/Reference/Global_Objects/Promise/race
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Method
+  - Promise
+translation_of: Web/JavaScript/Reference/Global_Objects/Promise/race
+---
+<div>{{JSRef}}</div>
+
+<p><code><strong>Promise.race(iterable)</strong></code> gibt ein erfolgreiches oder fehlgeschlagenes Promise zurück, sobald eines der Promises in dem <code>iterable</code> erfolgreich war oder fehlgeschlagen ist, entsprechend mit dem <code>value</code> oder dem <code>reason</code> dieses Promises.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/promise-race.html")}}</div>
+
+<p class="hidden">Der Code für das interaktive Demo ist in einem GitHub Repository zu finden. Sollten Sie bei diesem interaktiven Demo Projekt mitmachen wollen, dann klonen Sie <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> und senden uns einen Pull Request.</p>
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox"><var>Promise.race(iterable)</var>;</pre>
+
+<h3 id="Parameter">Parameter</h3>
+
+<dl>
+ <dt>iterable</dt>
+ <dd>Ein iterierbares Objekt, wie zum Beispiel {{jsxref("Array")}}. Siehe auch <a href="/en-US/docs/Web/JavaScript/Guide/iterable">iterable</a>.</dd>
+</dl>
+
+<h3 id="Rückgabewert">Rückgabewert</h3>
+
+<p>Eine {{jsxref("Promise")}} im Status <strong>pending</strong>, die <strong>asynchron</strong> (sobald der Stack leer ist) einen erfolgreichen oder fehlerhaften Status annimmt, sobald die erste Promise erfolgreich, bzw. fehlerhaft ist und entsprechend diesen Wert zurückliefert.</p>
+
+<h2 id="Beschreibung">Beschreibung</h2>
+
+<p>Die <code>race</code> Funktion gibt eine <code>Promise</code> zurück, die sich genauso verhält, wie die Promise aus <code>iterable</code>, die als erstes einen erfolgreichen oder fehlerhaften Status annimmt und entsprechend diesen Wert zurückliefert.</p>
+
+<p>Wenn das übergebene <code>iterable</code> leer ist, wird die Promise für immer im Status <strong>pending</strong> verharren.</p>
+
+<p>Wenn <code>iterable</code> einen oder mehrere Werte enthält, die keine Promise sind bzw. Promises die bereits einen erfolgreichen oder fehlerhaften Status angenommen haben, dann wird die zurückgegebene Promise von <code>Promise.race</code> entsprechend den ersten dieser Werte aus <code>iterable</code> annehmen.</p>
+
+<h2 id="Beispiele"> Beispiele</h2>
+
+<h3 id="Asynchronität_von_Promise.race"><font face="consolas, Liberation Mono, courier, monospace">Asynchronität von <code>Promise.race</code></font></h3>
+
+<p>Das folgende Beispiel demonstriert the Asynchronität von <code>Promise.race:</code></p>
+
+<pre class="brush: js">// wir übergeben als Argument ein Array von Promises, die bereits einen
+// erfolgreichen Status angenommen haben, um Promise.race sofort auszulösen
+var resolvedPromisesArray = [Promise.resolve(33), Promise.resolve(44)];
+
+var p = Promise.race(resolvedPromisesArray);
+// sofortiges Loggen des Wertes aus p
+console.log(p);
+
+// mit setTimeout wird der Code erst nachdem der Stack leer ist ausgeführt
+setTimeout(function(){
+    console.log('der Stack ist jetzt leer');
+    console.log(p);
+});
+
+// Logs, in der Reihenfolge:
+// Promise { &lt;state&gt;: "pending" }
+// der Stack ist jetzt leer
+// Promise { &lt;state&gt;: "fulfilled", &lt;value&gt;: 33 }</pre>
+
+<p>Ein leeres <code>iterable</code> führt zu einer Promise, die für immer im Status <strong>pending</strong> bleibt:</p>
+
+<pre class="brush: js">var foreverPendingPromise = Promise.race([]);
+console.log(foreverPendingPromise);
+setTimeout(function(){
+    console.log('der Stack ist jetzt leer');
+    console.log(foreverPendingPromise);
+});
+
+// Logs, in der Reihenfolge:
+// Promise { &lt;state&gt;: "pending" }
+// der Stack ist jetzt leer
+// Promise { &lt;state&gt;: "pending" }
+</pre>
+
+<p>Wenn <code>iterable</code> einen oder mehrere Werte enthält, die keine Promise sind bzw. Promises die bereits einen erfolgreichen oder fehlerhaften Status angenommen haben, dann wird <code>Promise.race</code> entsprechend den ersten dieser Werte aus <code>iterable</code> annehmen:</p>
+
+<pre class="brush: js">var foreverPendingPromise = Promise.race([]);
+var alreadyResolvedProm = Promise.resolve(666);
+
+var arr = [foreverPendingPromise, alreadyResolvedProm, "keine Promise"];
+var arr2 = [foreverPendingPromise, "keine Promise", Promise.resolve(666)];
+var p = Promise.race(arr);
+var p2 = Promise.race(arr2);
+
+console.log(p);
+console.log(p2);
+setTimeout(function(){
+    console.log('der Stack ist jetzt leer');
+    console.log(p);
+    console.log(p2);
+});
+
+// Logs, in der Reihenfolge:
+// Promise { &lt;state&gt;: "pending" }
+// Promise { &lt;state&gt;: "pending" }
+// der Stack ist jetzt leer
+// Promise { &lt;state&gt;: "fulfilled", &lt;value&gt;: 666 }
+// Promise { &lt;state&gt;: "fulfilled", &lt;value&gt;: "keine Promise" }
+</pre>
+
+<h3 id="Benutzung_von_Promise.race_–_Beispiele_mit_setTimeout">Benutzung von <code>Promise.race</code> – Beispiele mit <a href="/en-US/docs/Web/API/WindowOrWorkerGlobalScope/setTimeout"><code>setTimeout</code></a></h3>
+
+<pre class="brush: js">var p1 = new Promise(function(resolve, reject) {
+    setTimeout(resolve, 500, 'eins');
+});
+var p2 = new Promise(function(resolve, reject) {
+    setTimeout(resolve, 100, 'zwei');
+});
+
+Promise.race([p1, p2]).then(function(value) {
+  console.log(value); // "zwei"
+  // beide erfolgreich, aber p2 ist schneller
+});
+
+var p3 = new Promise(function(resolve, reject) {
+    setTimeout(resolve, 100, 'drei');
+});
+var p4 = new Promise(function(resolve, reject) {
+    setTimeout(reject, 500, 'vier');
+});
+
+Promise.race([p3, p4]).then(function(value) {
+  console.log(value); // "drei"
+  // p3 ist schneller, also insgesamt erfolgreich
+}, function(reason) {
+  // nicht aufgerufen
+});
+
+var p5 = new Promise(function(resolve, reject) {
+    setTimeout(resolve, 500, 'fünf');
+});
+var p6 = new Promise(function(resolve, reject) {
+    setTimeout(reject, 100, 'sechs');
+});
+
+Promise.race([p5, p6]).then(function(value) {
+  // nicht aufgerufen
+}, function(reason) {
+  console.log(reason); // "sechs"
+  // p6 ist schneller, also insgesamt fehlerhaft
+});
+</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('ES2015', '#sec-promise.race', 'Promise.race')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Initiale Definition eines ECMA Standards.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-promise.race', 'Promise.race')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browserkompatibilität">Browserkompatibilität</h2>
+
+<p class="hidden">The Kompatibilitätstabelle auf dieser Seite wurde aus strukturierten Daten generiert. Wenn Sie Daten beisteuert möchten, schauen Sie sich gerne <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> an und senden uns einen Pull Request.</p>
+
+<p>{{Compat("javascript.builtins.Promise.race")}}</p>
+
+<h2 id="Siehe_auch">Siehe auch</h2>
+
+<ul>
+ <li>{{jsxref("Promise")}}</li>
+ <li>{{jsxref("Promise.all()")}}</li>
+</ul>
diff --git a/files/de/web/javascript/reference/global_objects/promise/reject/index.html b/files/de/web/javascript/reference/global_objects/promise/reject/index.html
new file mode 100644
index 0000000000..1b90305142
--- /dev/null
+++ b/files/de/web/javascript/reference/global_objects/promise/reject/index.html
@@ -0,0 +1,74 @@
+---
+title: Promise.reject()
+slug: Web/JavaScript/Reference/Global_Objects/Promise/reject
+translation_of: Web/JavaScript/Reference/Global_Objects/Promise/reject
+---
+<div>{{JSRef}}</div>
+
+<div>Die <code><strong>Promise.reject(reason)</strong></code> Methode gibt ein <code>Promise</code> Objekt zurück, das mit dem angegebenen Grund <code><strong>reason</strong></code> abgelehnt wurde.</div>
+
+<p> </p>
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox"><var>Promise.reject(reason)</var>;</pre>
+
+<h3 id="Parameter">Parameter</h3>
+
+<dl>
+ <dt>reason</dt>
+ <dd>Der Grund warum diese <code>Promise</code> abgelehnt wurde.</dd>
+</dl>
+
+<h3 id="Rückgabewerte">Rückgabewerte</h3>
+
+<p>Ein {{jsxref("Promise")}}, das mit dem angegeben Grund abgelehnt wurde</p>
+
+<h2 id="Beschreibung">Beschreibung</h2>
+
+<p>Die statische <code>Promise.reject</code> Funktion gibt ein <code>Promise</code> zurück, das abgelehnt wurde. Für Debugging zwecke, sowie gezielte Fehlerverarbeitung ist es empfehlenswert, als <code>reason</code> eine <code>instanceof </code>{{jsxref("Error")}}. zu verwenden.</p>
+
+<h2 id="Beispiele">Beispiele</h2>
+
+<h3 id="Verwendung_der_Promise.reject()_Methode">Verwendung der Promise.reject() Methode</h3>
+
+<pre class="brush: js">Promise.reject(new Error('fail')).then(function(error) {
+  // nicht aufgerufen
+}, function(error) {
+  console.log(error); // Stacktrace
+});</pre>
+
+<h2 id="Spezifikationen">Spezifikationen</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-promise.reject', 'Promise.reject')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Initial definition in an ECMA standard.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-promise.reject', 'Promise.reject')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browserkompatibilität">Browserkompatibilität</h2>
+
+<p class="hidden">To contribute to this compatibility data, please write a pull request against this file: <a href="https://github.com/mdn/browser-compat-data/blob/master/javascript/promise.json">https://github.com/mdn/browser-compat-data/blob/master/javascript/promise.json</a>.</p>
+
+<p>{{Compat("javascript/promise","Promise.reject")}}</p>
+
+<h2 id="Siehe_auch">Siehe auch</h2>
+
+<ul>
+ <li>{{jsxref("Promise")}}</li>
+ <li><a href="https://github.com/petkaantonov/bluebird#error-handling">Selective error catching using the BlueBird Promise library</a></li>
+</ul>
diff --git a/files/de/web/javascript/reference/global_objects/promise/then/index.html b/files/de/web/javascript/reference/global_objects/promise/then/index.html
new file mode 100644
index 0000000000..3578cfcb62
--- /dev/null
+++ b/files/de/web/javascript/reference/global_objects/promise/then/index.html
@@ -0,0 +1,149 @@
+---
+title: Promise.prototype.then()
+slug: Web/JavaScript/Reference/Global_Objects/Promise/then
+translation_of: Web/JavaScript/Reference/Global_Objects/Promise/then
+---
+<div>{{JSRef}}</div>
+
+<div>Die <strong>then()</strong>-Methode gibt ein <code>Promise</code>-Objekt zurück. Sie benötigt zwei Argumente, jeweils eine Callback-Funktion für den Erfolg und den Fehlschlag des <code>Promise</code>.</div>
+
+<div> </div>
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox"><var>p.then(onFulfilled, onRejected)</var>;
+
+p.then(function(value) {
+   // fulfillment
+  }, function(reason) {
+  // rejection
+});
+</pre>
+
+<h3 id="Parameter">Parameter</h3>
+
+<dl>
+ <dt>onFulfilled</dt>
+ <dd>Eine {{jsxref("Function")}}, welche aufgerufen wird, wenn der <code>Promise</code> erfüllt wurde. Die Funktion hat ein Argument, den Rückgabewert <code>value</code>.</dd>
+ <dt>onRejected {{optional_inline}}</dt>
+ <dd>Eine {{jsxref("Function")}}, welche aufgerufen wird, wenn der <code>Promise</code> fehlschlägt. Die Funktion hat ein Argument, den Grund für den Fehlschlag: <code>reason</code>. Ist keine Funktion definiert, so wird sie intern durch die "Thrower" Funktion ersetzt (Dieser gibt einen Fehler als Argument zurück)</dd>
+</dl>
+
+<h2 id="Beschreibung">Beschreibung</h2>
+
+<p>Die <code>then</code>- und {{jsxref("Promise.prototype.catch()")}}-Methoden, können, da sie Promises zurückgeben<font face="Consolas, Liberation Mono, Courier, monospace">, verkettetet werden </font>— ein Vorgehen, das <em>composition</em> genannt wird.</p>
+
+<h2 id="Beispiele">Beispiele</h2>
+
+<h3 id="Benutzen_der_then-Methode">Benutzen der <code>then</code>-Methode</h3>
+
+<pre class="brush: js">var p1 = new Promise(function(resolve, reject) {
+  resolve("Success!");
+  // or
+  // reject ("Error!");
+});
+
+p1.then(function(value) {
+  console.log(value); // Success!
+}, function(reason) {
+  console.log(reason); // Error!
+});
+</pre>
+
+<h3 id="Verketten">Verketten</h3>
+
+<p>Da die <code>then</code>-Methode einen <code>Promise</code> zurückliefert, können <code>then</code>-Aufrufe leicht verkettet werden.</p>
+
+<pre class="brush: js">var p2 = new Promise(function(resolve, reject) {
+  resolve(1);
+});
+
+p2.then(function(value) {
+  console.log(value); // 1
+  return value + 1;
+}).then(function(value) {
+  console.log(value); // 2
+});
+
+p2.then(function(value) {
+  console.log(value); // 1
+});
+</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('ES2015', '#sec-promise.prototype.then', 'Promise.prototype.then')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Initiale Definition in einem ECMAScript-Standard.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browserkompatibilität">Browserkompatibilität</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>32</td>
+   <td>{{CompatGeckoDesktop(29.0)}} [1]</td>
+   <td>{{CompatNo}}</td>
+   <td>19</td>
+   <td>7.1</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+   <th>Chrome for Android</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatGeckoMobile(29.0)}} [1]</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>8</td>
+   <td>32</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<p>[1] Gecko 24 besitzt, unter dem Namen Future, eine experimentielle Implementation von Promise. In Gecko 25 wurde der Name final festgelegt aber standardmäßig durch die Einstellung <code>dom.promise.enabled </code>deaktiviert. Durch <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=918806">Bug 918806</a> wurden Promises in Gecko 29 standardmäßig aktiviert.</p>
+
+<h2 id="Siehe_auch">Siehe auch</h2>
+
+<ul>
+ <li>{{jsxref("Promise")}}</li>
+ <li>{{jsxref("Promise.prototype.catch()")}}</li>
+</ul>