From 4b1a9203c547c019fc5398082ae19a3f3d4c3efe Mon Sep 17 00:00:00 2001 From: Peter Bengtsson Date: Tue, 8 Dec 2020 14:41:15 -0500 Subject: initial commit --- .../reference/statements/async_function/index.html | 223 ++++++++++ .../reference/statements/block/index.html | 115 ++++++ .../reference/statements/break/index.html | 164 ++++++++ .../reference/statements/class/index.html | 192 +++++++++ .../reference/statements/const/index.html | 170 ++++++++ .../reference/statements/continue/index.html | 165 ++++++++ .../reference/statements/debugger/index.html | 52 +++ .../reference/statements/default/index.html | 120 ++++++ .../reference/statements/do...while/index.html | 132 ++++++ .../reference/statements/empty/index.html | 147 +++++++ .../reference/statements/export/index.html | 126 ++++++ .../reference/statements/for...in/index.html | 227 +++++++++++ .../reference/statements/for...of/index.html | 183 +++++++++ .../javascript/reference/statements/for/index.html | 201 +++++++++ .../reference/statements/for_each...in/index.html | 122 ++++++ .../reference/statements/function_star_/index.html | 200 +++++++++ .../reference/statements/funktion/index.html | 190 +++++++++ .../reference/statements/if...else/index.html | 168 ++++++++ .../reference/statements/import/index.html | 151 +++++++ .../web/javascript/reference/statements/index.html | 148 +++++++ .../reference/statements/label/index.html | 205 ++++++++++ .../javascript/reference/statements/let/index.html | 454 +++++++++++++++++++++ .../reference/statements/return/index.html | 192 +++++++++ .../reference/statements/switch/index.html | 289 +++++++++++++ .../reference/statements/throw/index.html | 256 ++++++++++++ .../reference/statements/try...catch/index.html | 382 +++++++++++++++++ .../javascript/reference/statements/var/index.html | 243 +++++++++++ .../reference/statements/while/index.html | 102 +++++ 28 files changed, 5319 insertions(+) create mode 100644 files/de/web/javascript/reference/statements/async_function/index.html create mode 100644 files/de/web/javascript/reference/statements/block/index.html create mode 100644 files/de/web/javascript/reference/statements/break/index.html create mode 100644 files/de/web/javascript/reference/statements/class/index.html create mode 100644 files/de/web/javascript/reference/statements/const/index.html create mode 100644 files/de/web/javascript/reference/statements/continue/index.html create mode 100644 files/de/web/javascript/reference/statements/debugger/index.html create mode 100644 files/de/web/javascript/reference/statements/default/index.html create mode 100644 files/de/web/javascript/reference/statements/do...while/index.html create mode 100644 files/de/web/javascript/reference/statements/empty/index.html create mode 100644 files/de/web/javascript/reference/statements/export/index.html create mode 100644 files/de/web/javascript/reference/statements/for...in/index.html create mode 100644 files/de/web/javascript/reference/statements/for...of/index.html create mode 100644 files/de/web/javascript/reference/statements/for/index.html create mode 100644 files/de/web/javascript/reference/statements/for_each...in/index.html create mode 100644 files/de/web/javascript/reference/statements/function_star_/index.html create mode 100644 files/de/web/javascript/reference/statements/funktion/index.html create mode 100644 files/de/web/javascript/reference/statements/if...else/index.html create mode 100644 files/de/web/javascript/reference/statements/import/index.html create mode 100644 files/de/web/javascript/reference/statements/index.html create mode 100644 files/de/web/javascript/reference/statements/label/index.html create mode 100644 files/de/web/javascript/reference/statements/let/index.html create mode 100644 files/de/web/javascript/reference/statements/return/index.html create mode 100644 files/de/web/javascript/reference/statements/switch/index.html create mode 100644 files/de/web/javascript/reference/statements/throw/index.html create mode 100644 files/de/web/javascript/reference/statements/try...catch/index.html create mode 100644 files/de/web/javascript/reference/statements/var/index.html create mode 100644 files/de/web/javascript/reference/statements/while/index.html (limited to 'files/de/web/javascript/reference/statements') diff --git a/files/de/web/javascript/reference/statements/async_function/index.html b/files/de/web/javascript/reference/statements/async_function/index.html new file mode 100644 index 0000000000..1179b3f924 --- /dev/null +++ b/files/de/web/javascript/reference/statements/async_function/index.html @@ -0,0 +1,223 @@ +--- +title: async function +slug: Web/JavaScript/Reference/Statements/async_function +tags: + - Example + - JavaScript +translation_of: Web/JavaScript/Reference/Statements/async_function +--- +
+
{{jsSidebar("Statements")}}
+ +

 Die async function Deklaration definiert eine asynchrone Funktion, die ein {{jsxref("Global_Objects/AsyncFunction","AsyncFunction")}} Objekt zurück gibt. Asynchrone Funktionen laufen über den Event Loop außerhalb des üblichen Kontrollflusses, und geben als Ergebnis ein implizites {{jsxref("Promise")}} Objekt zurück. Die Syntax und der Aufbau des Codes bei einer asynchronen Funktion ähnelt allerdings der den standardmässigen synchronen Funktionen.

+ +
+

Eine async function kann auch durch den {{jsxref("Operators/async_function", "async function expression", "", 1)}} Ausdruck definiert werden.

+
+
+ +
{{EmbedInteractiveExample("pages/js/statement-async.html", "taller")}}
+ + + +

Syntax

+ +
async function name([param[, param[, ... param]]]) {
+   statements
+}
+
+ +

Die Parameter

+ +
+
name
+
Der Name der Funktion.
+
+ +
+
param
+
Der Name eines Arguments, welches der Funktion übergeben wird.
+
+ +
+
statements
+
Die Ausdrücke, aus denen der Funktionskörper besteht.
+
+ +

Der zurückgegebene Wert

+ +

Ein Promise Objekt. Das Promise wird entweder mit dem zurück gelieferten Wert der asnychronen Funktion eingehalten (Engl: "resolved"), oder mit einem unbehandelten Fehler innerhalb der asynchronen Funktion verworfen (Engl: "rejected").

+ +

Beschreibung

+ +

Eine async Funktion darf einen {{jsxref("Operators/await", "await")}} Ausdruck enthalten, der die Ausführung der asynchronen Funktion anhält. Die Funktion wartet auf die Entscheidung des übergebenen Promise, setzt dann die Ausführung der asynchronen Funktionen fort und wird als eingehaltener (Engl: "resolved") Wert ausgewertet.

+ +

Das Schlüsselwort await gilt nur innerhalb der async Funktionen. Die Verwendung außerhalb solcher Funktion wirft einen SyntaxError auf.

+ +
+

Das Ziel der async/await Funktionen ist zweifach. Erstens vereinfachen sie die Anwendung von Promises im Rahmen eines synchronen Verfahrens. Zweitens ermöglichen sie die kollektive Verarbeitung einer Gruppe von Promises. Genau wie die Promises dem Verhalten von callbacks ("Rückruffunktionen") ähneln, so ähnelt die async/await Methode der Zusammensetzung von Generatoren und Promises.

+
+ +

Beispiele

+ +

Einfaches Beispiel

+ +
var resolveAfter2Seconds = function() {
+  //nach 2 Sek. einlösen
+  console.log("langsames Promise beginnt");
+  return new Promise(resolve => {
+    setTimeout(function() {
+      resolve(20); //"20" taucht als der zurückgegebene Wert der Fkn. auf
+      console.log("langsames Promise fertig");
+    }, 2000);
+  });
+};
+
+var resolveAfter1Second = function() {
+  //nach 1 Sek. einlösen
+  console.log("schnelles Promise beginnt");
+  return new Promise(resolve => {
+    setTimeout(function() {
+      resolve(10); //"10" taucht als der zurückgegebene Wert der Fkn. auf
+      console.log("schnelles Promise fertig");
+    }, 1000);
+  });
+};
+
+var sequentialStart = async function() {
+  console.log('==NACHEINANDER STARTEN==');
+  // Falls der dem await Operator folgende Ausdruck kein Promise ist,
+  // wird jener Ausdruck in ein eingehaltenes ("resolved") Promise umgewandelt
+
+  // 1. die Ausführung erfolgt fast sofort
+  const slow = await resolveAfter2Seconds();
+  console.log(slow); // 2. das hier startet 2 Sekunden nach 1.
+
+  const fast = await resolveAfter1Second();
+  console.log(fast); // 3. das hier startet 3 Sekunden nach 1.
+}
+
+var concurrentStart = async function() {
+  console.log('==ZEITGLEICH ANFANGEN mit await==');
+  const slow = resolveAfter2Seconds(); // startet den Timer sofort
+  const fast = resolveAfter1Second(); // startet den Timer sofort
+
+  // 1. die Ausführung erfolgt fast sofort
+  console.log(await slow); // 2. das hier startet 2 Sekunden nach 1.
+  console.log(await fast); // 3. das hier startet 2 Sekunden nach 1., also sofort nach 2., da "fast" bereits aufgelöst ist
+}
+
+var stillConcurrent = function() {
+  console.log('==ZEITGLEICH ANFANGEN mit Promise.all==');
+  Promise.all([resolveAfter2Seconds(), resolveAfter1Second()]).then((messages) => {
+    console.log(messages[0]); // "slow"
+    console.log(messages[1]); // "fast"
+  });
+}
+
+var parallel = function() {
+  console.log('==PARALLEL mit Promise.then==');
+  resolveAfter2Seconds().then((message)=>console.log(message));
+  resolveAfter1Second().then((message)=>console.log(message));
+}
+
+sequentialStart(); // loggt "slow" nach 2 Sek., dann "fast" nach einer weiteren Sek.
+
+// wartet, bis das obige Verfahren abschließt
+setTimeout(concurrentStart, 4000); // loggt nach 2 Sek. erst "slow", dann "fast"
+
+// wieder warten
+setTimeout(stillConcurrent, 7000); // genau wie concurrentStart
+
+// wieder warten
+setTimeout(parallel, 10000); // echt parallel: loggt "fast" nach 1 Sek., dann "slow" nach einer weiteren Sek.
+
+ +

await und Parallelität

+ +

In der Funktion sequentialStart wird die Ausführung wegen dem ersten await für 2 Sekunden angehalten, und dann nochmal eine weitere Sekunde wegen dem zweiten await. Der zweite Timer wird erst erzeugt, sobald der erste durch ist, daher wird der Code nach 3 Sekunden durchgelaufen sein.

+ +

In der Funktion concurrentStart werden beide Timer erzeugt und dann darauf gewartet (await). Die beiden Timer laufen zur selben Zeit, was bedeutet, dass der Code in 2 Sekunden statt 3 durchläuft, also wie der langsamste Timer. Trotzdem laufen die await Aufrufe immer noch nacheinander, was bedeutet, dass das zweite await auf das Ende des ersten Timers warten wird. In diesem Fall wird das Ergebnis des schnellsten Timers erst nach dem des langsamsten Timers verarbeitet.

+ +

Wenn du wirklich zwei oder mehr Jobs gleichzeitig, also parallel, ausführen willst, musst du await Promise.all([job1(), job2()]) wie in der parallel Funktion gezeigt verwenden.

+ +
+

Merke: await mit Promise#then nicht verwechseln

+ +

Bei sequentialStart wird die Programmausführung auf 2 Sek. aufgehalten wegen des ersten await, dann wieder auf 1 Sek. wegen des zweiten await. Die zweite Stoppuhr wird erst nach Ablauf der ersten Stoppuhr erstellt.

+ +

Bei concurrentStart werden beide Stoppuhren gleichzeitig erstellt, dann in await versetzt. Obwohl beide Uhren nebeneinander laufen, laufen die await Abrufe serienweise. Das bedeutet, dass die zweite await Anweisung auf Ablauf der ersten wartet. Die Laufzeit dieses Abschnitts lautet daher 2--nicht 3--Sekunden, weil das langsamere Verfahren 2 Sek. braucht. Das Gleiche ereignet sich bei stillConcurrent, welcher Abschnitt die Promise.all Methode verwendet.

+ +

Wenn man auf mehrfache Promises parallel warten (await) will, muss man Promise#then verwenden, gerade wie die parallel Funktion am Ende dieses Beispiels.

+
+ +

Umschreiben einer Promise-Kette mittels einer async Funktion

+ +

Eine API die ein {{jsxref("Promise")}} zurückgibt resultiert in einer vielteiligen Promise-Kette. Man beachte den folgenden Code:

+ +
function getProcessedData(url) {
+  return downloadData(url) // returns a promise
+    .catch(e => {
+      return downloadFallbackData(url)  // returns a promise
+    })
+    .then(v => {
+      return processDataInWorker(v); // returns a promise
+    });
+}
+
+ +

das kann mit einer async Funktion folgendermaßen umgeschrieben werden:

+ +
async function getProcessedData(url) {
+  let v;
+  try {
+    v = await downloadData(url);
+  } catch(e) {
+    v = await downloadFallbackData(url);
+  }
+  return processDataInWorker(v);
+}
+
+ +

Im obigen Beispiel ist zu beachten, dass es keinen await Ausdruck auf dem return Ausdruck gibt, weil der Rückgabewert einer async function implizit im {{jsxref("Promise.resolve")}} eingeschlossen ist.

+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ESDraft', '#sec-async-function-definitions', 'async function')}}{{Spec2('ESDraft')}}Initial definition in ES2017.
{{SpecName('ES8', '#sec-async-function-definitions', 'async function')}}{{Spec2('ES8')}}
+ +

Browserkompatibilität

+ +
+ + +

{{Compat("javascript.statements.async_function")}}

+
+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/statements/block/index.html b/files/de/web/javascript/reference/statements/block/index.html new file mode 100644 index 0000000000..788082aeae --- /dev/null +++ b/files/de/web/javascript/reference/statements/block/index.html @@ -0,0 +1,115 @@ +--- +title: block +slug: Web/JavaScript/Reference/Statements/block +tags: + - Anweisung + - JavaScript + - Statement +translation_of: Web/JavaScript/Reference/Statements/block +--- +

{{jsSidebar("Statements")}}

+ +

Eine Blockanweisung (oder in anderen Sprachen Verbundanweisung) wird genutzt, um Anweisungen zu gruppieren. Ein Block wird durch ein Paar geschweifte Klammern abgegrenzt. Optional kann ihm ein {{jsxref("Statements/label", "Label")}} zugewiesen werden.

+ +

{{EmbedInteractiveExample("pages/js/statement-block.html", "taller")}}

+ +

Syntax

+ +
[label:] {
+  anweisung_1;
+  anweisung_2;
+  ...
+  anweisung_n;
+}
+
+ +
+
anweisung1, anweisung2, anweisungN
+
Anweisungen, die zu einer Blockanweisung gruppiert werden.
+
label
+
Ein optionales {{jsxref("Statements/label", "Label")}}, entweder nur als Kennzeichnung oder als Referenz für die Verwendung in einer {{jsxref("Statements/break", "break")}}-Anweisung.
+
+ +

Beschreibung

+ +

Eine Blockanweisung wird meistens in Verbindung mit Komtrollfluss-Anweisungen (z. B. {{jsxref("Statements/if...else", "if…else")}}, {{jsxref("Statements/for", "for")}}, {{jsxref("Statements/while", "while")}}) genutzt. Zum Beispiel:

+ +
while (x < 10) {
+  x++;
+}
+
+ +

Zu beachten ist, dass eine Blockanweisung nicht mit einem Semikolon endet.

+ +

In anderen Sprachen wird eine Blockanweisung auch oftmals Verbundanweisung genannt. Dieser erlaubt den Einsatz mehrerer Anweisungen an Stellen, an denen JavaScript nur eine Anweisung erwartet. Das Kombinieren von Anweisungen in Blöcken ist in Javascript gängige Praxis. Mit einer {{jsxref("Statements/empty", "empty")}}-Anweisung ist auch der gegenteilige Fall umsetzbar (keine Anweisung an Stellen, an denen Anweisungen erwartet werden).

+ +

Variablen in Blockgültigkeitsbereichen

+ +

Wichtig: Variablen, die mit {{jsxref("Statements/var", "var")}} deklariert werden, haben keinen Blockgültigkeitsbereich. Sie sind an den Gültigkeitsbereich der umschließenden Funktion oder des Skripts gebunden. Variablen sind folglich auch außerhalb des Blocks verfügbar, in dem sie deklariert wurden. Beispiel:

+ +
var x = 1;
+{
+  var x = 2;
+}
+console.log(x); // Ausgabe: 2
+
+ +

Die Ausgabe zeigt 2, weil die Anweisungen var x außerhalb des Blocks und innerhalb des Blocks den gleichen Gültigkeitsbereich haben. In anderen Sprachen würde dieser Code 1 ausgeben.

+ +

Um die Gültigkeit auf den Block zu begrenzen, muss {{jsxref("Statements/let", "let")}} eingesetzt werden:

+ +
let x = 1;
+{
+  let x = 2; // dieses x ist nur in diesem Block sichtbar
+}
+console.log(x); // Ausgabe: 1
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ESDraft', '#sec-block', 'Block statement')}}{{Spec2('ESDraft')}}
{{SpecName('ES6', '#sec-block', 'Block statement')}}{{Spec2('ES6')}}
{{SpecName('ES5.1', '#sec-12.1', 'Block statement')}}{{Spec2('ES5.1')}}
{{SpecName('ES3', '#sec-12.1', 'Block statement')}}{{Spec2('ES3')}}
{{SpecName('ES1', '#sec-12.1', 'Block statement')}}{{Spec2('ES1')}}Erste Definition. Implementiert in JavaScript 1.0.
+ +

Browserkompatibilität

+ +

{{Compat("javascript.statements.block")}}

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/statements/break/index.html b/files/de/web/javascript/reference/statements/break/index.html new file mode 100644 index 0000000000..350ba91400 --- /dev/null +++ b/files/de/web/javascript/reference/statements/break/index.html @@ -0,0 +1,164 @@ +--- +title: break +slug: Web/JavaScript/Reference/Statements/break +tags: + - JavaScript + - Statement +translation_of: Web/JavaScript/Reference/Statements/break +--- +
+
{{jsSidebar("Statements")}}
+
+ +

Die break Anweisung beendet die aktuelle Schleife, {{jsxref("Statements/switch", "switch")}}-Anweisung oder Anweisungen die mit einem {{jsxref("Statements/label", "label")}} versehen sind und sorgt dafür, dass das Programm mit der Anweisung weiterläuft, die auf die beendete Anweisung folgt.

+ +

Syntax

+ +
break [Label];
+ +
+
Label
+
Optional. Ein Bezeichner, der mit einem {{jsxref("Statements/label", "Label")}} einer Anweisung in Verbindung gebracht werden kann. Es wird vorausgesetzt, dass die Anweisung, die beendet wird, eine Schleife oder ein {{jsxref("Statements/switch", "switch")}}-Statement ist.
+
+ +

Beschreibung

+ +

Die break Anweisung enthält ein optionales {{jsxref("Statements/label", "Label")}}, mit dem es möglich ist, eine mit einem {{jsxref("Statements/label", "Label")}} versehene Anweisung zu beenden. Dabei muss sich die break Anweisung innerhalb der Anweisung, die mit einem {{jsxref("Statements/label", "Label")}} versehen ist, befinden. Die Anweisung, die mit einem Label versehen ist, kann jede {{jsxref("Statements/block", "Block")}}-Anweisung sein und muss nicht zwingend eine Schleife sein.

+ +

Beispiele

+ +

Die folgende Funktion nutzt eine break Anweisung die die {{jsxref("Statements/while", "while")}} Schleife beendet, wenn i gleich 3 ist. Danach gibt die Funktion 3 * x zurück.

+ +
function testBreak(x) {
+   var i = 0;
+
+   while (i < 6) {
+      if (i == 3) {
+         break;
+      }
+      i += 1;
+   }
+   return i * x;
+}
+ +

Der folgende Quelltext benutzt die break Anweisungen mit einem {{jsxref("Statements/label", "Label")}} auf einem {{jsxref("Statements/block", "Block")}}. Weil inner_block innerhalb vom {{jsxref("Statements/block", "Block")}} mit dem outer_block {{jsxref("Statements/label", "Label")}} ist, funktioniert break fehlerfrei.

+ +
outer_block:{
+  inner_block:{
+    console.log ('1');
+    break outer_block;      // breaks out of both inner_block and outer_block
+    console.log (':-(');    // skipped
+  }
+
+  console.log ('2');        // skipped
+}
+
+ +

Der folgende Quelltext benutzt eine break Anweisung, die nicht auf ein {{jsxref("Statements/label", "Label")}} verweist, in dem sich das break befindet. Dieses ist nicht möglich, weshalb ein {{jsxref("Global_Objects/SyntaxError", "SyntaxError")}} erzeugt wird.

+ +
block_1:{
+  console.log ('1');
+  break block_2;            // SyntaxError: Label nicht gefunden
+}
+
+block_2:{
+  console.log ('2');
+}
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES1')}}{{Spec2('ES1')}}Initiale Definition. nur die Version ohne Labels hinzugefügt.
{{SpecName('ES3')}}{{Spec2('ES3')}}Version mit Labels hinzugefügt.
{{SpecName('ES5.1', '#sec-12.8', 'Break statement')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-break-statement', 'Break statement')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-break-statement', 'Break statement')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ +

{{ CompatibilityTable() }}

+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}
+
+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/statements/class/index.html b/files/de/web/javascript/reference/statements/class/index.html new file mode 100644 index 0000000000..48fda4c9bb --- /dev/null +++ b/files/de/web/javascript/reference/statements/class/index.html @@ -0,0 +1,192 @@ +--- +title: Klasse +slug: Web/JavaScript/Reference/Statements/class +tags: + - Deklaration + - ECMAScript 2015 + - JavaScript + - Klasse + - Klassen + - Ref + - Statement +translation_of: Web/JavaScript/Reference/Statements/class +--- +
{{jsSidebar("Statements")}}
+ +
Die Klassendeklaration erstellt eine neue Klasse mit einem Namen unter Verwendung von prototypen Vererbung.
+ +
 
+ +
+

Sie können eine Klasse auch mit Hilfe einer {{jsxref("Operators/class", "class expression", "", 1)}} definieren. Unglücklicherweise ist es mit diesen class-Ausdrücken nicht möglich eine existierende Klasse erneut zu deklarieren. Dieses führt zu einem TypeError.

+
+ +

Syntax

+ +
class name [extends] {
+  // class body
+}
+
+ +

Beschreibung

+ +

Genau wie mit class expressions, wird der body der Klassendeklaration im strict mode ausgeführt. Die constructor Eigenschaft ist optional.

+ +

Klassendeklarationen sind nicht {{Glossary("Hoisting", "hoisted")}} (im Gegensatz zu function declarations).

+ +

Beispiele

+ +

Eine einfache Klassendeklaration

+ +

Im folgenden Beispiel definieren wir zuerst eine Klasse mit dem Namen Polygon. Diese wird danach erweitert, um eine Klasse mit dem Namen Square zu erstellen. Beachten Sie, dass die Anweisung super() nur im Konstruktor verwendet werden kann und vor dem this Schlüsselwort verwendet werden kann.

+ +
class Polygon {
+  constructor(height, width) {
+    this.name = 'Polygon';
+    this.height = height;
+    this.width = width;
+  }
+}
+
+class Square extends Polygon {
+  constructor(length) {
+    super(length, length);
+    this.name = 'Square';
+  }
+}
+ +
+

Versuch eine Klasse zweimal zu deklarieren

+ +

Neudeklarieren einer Klasse unter Einsatz von Klassendeklarationen führt zu einem TypeError.

+ +
class Foo {};
+class Foo {}; // Uncaught TypeError: Identifier 'Foo' has already been declared
+
+ +

Der gleiche Fehler tritt auch auf, wenn eine Klasse zuvor mit einem class-Ausdruck definiert wurde.

+ +
var Foo = class {};
+class Foo {}; // Uncaught TypeError: Identifier 'Foo' has already been declared
+
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES2015', '#sec-class-definitions', 'Class definitions')}}{{Spec2('ES2015')}}Erste Definition
{{SpecName('ESDraft', '#sec-class-definitions', 'Class definitions')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ +

{{CompatibilityTable}}

+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatChrome(42.0)}}{{CompatGeckoDesktop(45)}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
Array subclassing{{CompatChrome(43.0)}}{{CompatNo}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
Allowed in sloppy mode{{CompatChrome(49.0)}}    
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidAndroid WebviewFirefox Mobile (Gecko)IE MobileOpera MobileSafari MobileChrome for Android
Basic support{{CompatNo}}{{CompatChrome(42.0)}}{{CompatGeckoMobile(45)}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}{{CompatChrome(42.0)}}
Array subclassing{{CompatNo}}{{CompatChrome(43.0)}}{{CompatNo}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}{{CompatChrome(43.0)}}
Allowed in sloppy mode{{CompatNo}}{{CompatChrome(49.0)}}    {{CompatChrome(49.0)}}
+
+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/statements/const/index.html b/files/de/web/javascript/reference/statements/const/index.html new file mode 100644 index 0000000000..2bd5b39928 --- /dev/null +++ b/files/de/web/javascript/reference/statements/const/index.html @@ -0,0 +1,170 @@ +--- +title: const +slug: Web/JavaScript/Reference/Statements/const +tags: + - ECMAScript 2015 + - JavaScript + - Statement +translation_of: Web/JavaScript/Reference/Statements/const +--- +
+
{{jsSidebar("Statements")}}
+
+ +

Zusammenfassung

+ +

Die const-Deklaration erstellt eine Konstante. Wie bei der Deklaration einer Variablen mit {{jsxref("Statements/let", "let")}} ist der Gültigkeitsbereich auf den lokalen Block begrenzt. Der Wert einer Konstanten kann nicht verändert werden durch Zuweisung oder Neudeklaration.

+ +

{{EmbedInteractiveExample("pages/js/statement-const.html")}}

+ +

Syntax

+ +
const name1 = wert1 [, name2 = wert2 [, ... [, nameN = wertN]]];
+ +
+
nameN
+
Name der Konstanten. Dieser kann jeder gültige {{Glossary("Identifier", "Bezeichner")}} sein.
+
wertN
+
Wert der Konstanten. Dieser kann jeder gültige {{Glossary("Expression", "Ausdruck")}} sein, einschließlich einer Funktion.
+
+ +

Beschreibung

+ +

Die const-Deklaration erstellt eine Konstante, die entweder global sichtbar oder nur lokal in dem {{jsxref("Statements/Block", "Anweisungsblock")}}, in der sie deklariert wird, sichtbar ist.

+ +

Die Konstante muss bei ihrer Definition mit einem Wert belegt werden. Eine spätere Zuweisung ist logischerweise nicht möglich, denn Sinn einer Konstanten ist, dass nach ihrer Definition keine Änderungen mehr vorgenommen werden können.

+ +

Die const-Deklaration erzeugt eine nicht veränderbare Referenz auf einen Wert. Dies bedeutet aber nicht, dass dieser Wert an sich unveränderlich ist, sondern nur, dass der Konstanten kein anderer Wert zugewiesen werden kann. Ist der Wert einer Konstanten zum Beispiel ein Objekt vom Typ {{jsxref("Global_Objects/Array", "Array")}}, können dessen Einträge durchaus verändert werden. Die Beispiele unten verdeutlichen dies.

+ +

Eine Konstante kann nicht den gleichen Namen einer Funktion oder einer Variablen im gleichen Gültigkeitsbereich führen. Der Versuch, den Namen einer Konstanten nochmals zu verwenden, führt ebenso zu einem Fehler wie der Versuch, den Namen eines bestehenden Objektes für eine Konstante zu verwenden.

+ +

Für const gelten die gleichen Regel hinsichtlich der toten Zone wie für {{jsxref("Statements/let", "let")}}. Auch Konstanten sind erst nach ihrer Deklaration verfügbar, nicht jedoch zwischen dem Beginn des Blocks und der Deklaration.
+ Dies ist ein Unterschied zur Variablendeklaration mit {{jsxref("Statements/var", "var")}}. Mit var deklarierte Variablen sind in der gesamten Funktion verfügbar, in der sie deklariert wurden, selbst falls die Variablendeklaration die letzte Anweisung der Funktion war.

+ +

Beispiele

+ +

Die nachfolgenden Beispiele bauen aufeinander auf und sollten funktionell als ein Skript betrachtet werden. Sie sind lediglich in mehrere Absätze aufgeteilt, um die Teilaspekte der Konstantenbenutzung abzugrenzen.

+ +

Grundlagen

+ +

Konstanten müssen bei Deklaration mit einem Wert belegt werden und sind danach nicht mehr änderbar.

+ +
// Definiert my_fav als eine Konstante und weist ihr den Wert 7 zu.
+const MY_FAV = 7;
+
+// Ein Versuch, der Konstanten einen anderen Wert zuzuweisen, ergibt
+// einen Fehler.
+MY_FAV = 20;
+
+// Schreibt 7 auf die Konsole.
+console.log("my favorite number is: " + MY_FAV);
+
+// Der Versuch, eine existierende Konstante neu zu definieren,
+// erzeugt einen Fehler
+const MY_FAV = 20;
+
+// Der Name my_fav ist für die obige Konstante reserviert, weshalb
+// dieses ebenfalls einen Fehler erzeugt.
+var MY_FAV = 20;
+// Auch dies ergibt einen Fehler.
+let MY_FAV = 20;
+
+// Konstanten benötigten einen Initialwert, weshalb hier ein SyntaxError
+// erzeugt wird.
+const FOO;
+
+// Konstanten sind erst nach ihrer Deklaration verfügbar,
+// anders als var-Variablen.
+console.log("konstante = " + KONST); // Fehler, KONST existiert noch nicht
+console.log("variable = " + VAR); // VAR hingegen schon
+const KONST = "23";
+var VAR = "32";
+console.log("konstante = " + KONST); // KONST existiert erst jetzt
+
+
+ +

Der Block als Gültigkeitsbereich

+ +

Konstanten sind nur innerhalb des Blocks aus geschweiften Klammern sichtbar, in dem sie deklariert wurden.

+ +
// MY_FAV, in vorigem Beispiel erstellt, ist immer noch 7
+if (MY_FAV === 7) {
+    // Innerhalb dieses if-Blocks kann eine neue Konstante MY_FAV
+    // erzeugt werden, die nur für diesen Block gültig ist.
+    const MY_FAV = 20;
+
+    // MY_FAV ist nun 20
+    console.log("my favorite number is " + MY_FAV);
+
+    // var-Variablen werden hingegen immer in den übergeordneten
+    // Funktions- oder den globalen Kontext eingebettet, weshalb
+    // dies zu einer Kollision mit der globalen Konstante MY_FAV
+    // aus vorigem Beispiel führen wird:
+    var MY_FAV = 20;
+}
+// MY_FAV ist immer noch 7, denn wir haben den if-Block verlassen.
+console.log("my favorite number is " + MY_FAV);
+
+
+ +

Die Konstante und der Wert einer Konstante

+ +

Obwohl Konstanten selbst nicht geändert werden können, kann sich der Wert des Objektes, auf das die Konstante verweist, ändern.

+ +
// Konstanten können auch komplexe Objekte sein.
+const MY_OBJECT = {"key": "value"};
+
+// Ein Versuch, der Konstanten ein anderes Objekt zuzuweisen, ergibt
+// einen Fehler.
+MY_OBJECT = {"OTHER_KEY": "value"};
+
+// Das Objekt selber hingegen ist nicht vor Veränderungen geschützt.
+// Die folgende Anweisung wird ohne Probleme ausgeführt.
+MY_OBJECT.key = "otherValue";
+
+// Das Gleiche gilt für Felder:
+const MY_ARRAY = [];
+// Es ist möglich, neue Einträge an das Feld anzufügen.
+MY_ARRAY.push("A"); // ["A"]
+// Jedoch führt der Versuch, der Konstanten ein anderes Feld
+// zuzuweisen, zu einem Fehler.
+MY_ARRAY = ["B"]
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES2015', '#sec-let-and-const-declarations', 'Let and Const Declarations')}}{{Spec2('ES2015')}} +

Erste Definition.

+
{{SpecName('ESDraft', '#sec-let-and-const-declarations', 'Let and Const Declarations')}}{{Spec2('ESDraft')}}
+ +

Browserkompatibilität

+ +

{{Compat("javascript.statements.const")}}

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/statements/continue/index.html b/files/de/web/javascript/reference/statements/continue/index.html new file mode 100644 index 0000000000..b6b00242de --- /dev/null +++ b/files/de/web/javascript/reference/statements/continue/index.html @@ -0,0 +1,165 @@ +--- +title: continue +slug: Web/JavaScript/Reference/Statements/continue +tags: + - JavaScript + - Statement +translation_of: Web/JavaScript/Reference/Statements/continue +--- +
{{jsSidebar("Statements")}}
+ +

Die continue Anweisung beendet die Ausführung von Anweisungen im aktuellen Durchlauf der aktuellen oder benannten Schleife und setzt die Schleife mit der nächsten Iteration fort.

+ +
{{EmbedInteractiveExample("pages/js/statement-continue.html")}}
+ + + +

Syntax

+ +
continue [label];
+ +
+
label
+
Bezeichner mit dem Namen der verbundenen Anweisung.
+
+ +

Beschreibung

+ +

Im Gegensatz zur {{jsxref("Statements/break", "break")}} Anweisung, beendet continue die Ausführung der Schleife nicht komplett sondern:

+ + + + + +

Die continue Anweisung kann optional den Namen beinhalten und erlaubt dem Programm zum nächsten Durchlauf einer benannten Schleife zu springen anstatt der aktuellen. In diesem Fall muss die continue Anweisung innerhalb der benannten Anweisung liegen.

+ +

Beispiele

+ +

Verwendung von continue mit while

+ +

Das folgende Beispiel zeigt eine {{jsxref("Statements/while", "while")}} Schleife mit einer continue Anweisung, die ausgeführt wird, wenn i den Wert 3 hat. Daher nimmt n die Werte 1, 3, 7, und 12 an.

+ +
var i = 0;
+var n = 0;
+
+while (i < 5) {
+  i++;
+
+  if (i === 3) {
+    continue;
+  }
+
+  n += i;
+}
+
+ +

Verwendung von continue mit einem Bezeichner

+ +

Im folgenden Beispiel enthält die checkiandj benannte Anweisung eine benannte Anweisung namens checkj. Wenn continue erreicht wird, wird das Programm am Beginn der checkj Anweisung fortgesetzt. Jedes mal wenn continue erreicht wird, beginnt checkj einen neuen Durchlauf, bis die Bedingung false zurückgibt. Wenn false zurückgegeben wird, wird der Rest der checkiandj Anweisung ausgeführt.

+ +

Falls continue einen Bezeichner checkiandj hätte, dann würde das Programm am Beginn der checkiandj Anweisung fortgesetzt.

+ +

Siehe auch {{jsxref("Statements/label", "label")}}.

+ +
var i = 0;
+var j = 8;
+
+checkiandj: while (i < 4) {
+  console.log('i: ' + i);
+  i += 1;
+
+  checkj: while (j > 4) {
+    console.log('j: '+ j);
+    j -= 1;
+
+    if ((j % 2) == 0)
+      continue checkj;
+    console.log(j + ' is odd.');
+  }
+  console.log('i = ' + i);
+  console.log('j = ' + j);
+}
+
+ +

Ausgabe:

+ +
i: 0
+
+// start checkj
+j: 8
+7 is odd.
+j: 7
+j: 6
+5 is odd.
+j: 5
+// end checkj
+
+i = 1
+j = 4
+
+i: 1
+i = 2
+j = 4
+
+i: 2
+i = 3
+j = 4
+
+i: 3
+i = 4
+j = 4
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatuskommentar
{{SpecName('ES1')}}{{Spec2('ES1')}}Initiale Definition. Unbenannte Version.
{{SpecName('ES3')}}{{Spec2('ES3')}}Benannte Version hinzugefügt.
{{SpecName('ES5.1', '#sec-12.7', 'Continue statement')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-continue-statement', 'Continue statement')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-continue-statement', 'Continue statement')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.statements.continue")}}

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/statements/debugger/index.html b/files/de/web/javascript/reference/statements/debugger/index.html new file mode 100644 index 0000000000..0beef2ded9 --- /dev/null +++ b/files/de/web/javascript/reference/statements/debugger/index.html @@ -0,0 +1,52 @@ +--- +title: debugger +slug: Web/JavaScript/Reference/Statements/debugger +translation_of: Web/JavaScript/Reference/Statements/debugger +--- +
{{jsSidebar("Statements")}}
+ +

Die Anweisung debugger ruft eine nicht näher bestimmte Debugging-Funktionalität des Interpreters auf. Naheliegend, jedoch nicht vorgeschrieben, ist das Pausieren des Programmablaufs und Öffnen des Debuggers an dieser Stelle.
+ Stellt der Interpreter keine Debugging-Möglichkeiten zur Verfügung, hat die Anweisung keine Auswirkungen.

+ +

Syntax

+ +
debugger;
+ +

Beispiel

+ +

Dieses Beispiel zeigt eine Funktion, die mit der debugger-Anweisung beginnt.

+ +
function potentiallyBuggyCode() {
+    debugger;
+    // do potentially buggy stuff to examine, step through, etc.
+}
+ +

Bei Aufruf der Funktion wird das Skript pausiert und der Debugger öffnet sich, um den weiteren Ablauf gezielt kontrollieren zu können.

+ +

Paused at a debugger statement.

+ +

Spezifikation

+ + + + + + + + + + +
Spezifikation
{{SpecName('ESDraft', '#sec-debugger-statement', 'debugger')}}
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.statements.debugger")}}

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/statements/default/index.html b/files/de/web/javascript/reference/statements/default/index.html new file mode 100644 index 0000000000..3d078df932 --- /dev/null +++ b/files/de/web/javascript/reference/statements/default/index.html @@ -0,0 +1,120 @@ +--- +title: default +slug: Web/JavaScript/Reference/Statements/default +tags: + - JavaScript + - Keyword +translation_of: Web/JavaScript/Reference/Statements/switch +--- +
{{jsSidebar("Statements")}}
+ +

Das default Schlüsselwort kann in JavaScript in zwei Situationen verwendet werden: Innerhalb eines {{jsxref("Statements/switch", "switch")}} Statements, oder mit einem {{jsxref("Statements/export", "export")}} Statement.

+ +
{{EmbedInteractiveExample("pages/js/statement-default.html")}}
+ + + +

Syntax

+ +

Innerhalb eines {{jsxref("Statements/switch", "switch")}} Statements:

+ +
switch (expression) {
+  case value1:
+    // Das Statement wird ausgeführt, wenn das Ergebnis der expression mit value1 übereinstimmt
+    [break;]
+  default:
+    // Das Statement wird ausgeführt, wenn keiner Werte mit dem Wert der expression übereinstimmt
+    [break;]
+}
+ +

Mit dem {{jsxref("Statements/export", "export")}} Statement:

+ +
export default nameN
+ +

Beschreibung

+ +

Für mehr Informationen, siehe die

+ + + +

Beispiele

+ +

Verwenden von default in switch Statements

+ +

Wenn im folgenden Beispiel expr den Wert "Oranges" oder "Apples" hat, wird das Programm die jeweiligen Werte abgleichen und das dazugehörige Statement ausführen. Das default Schlüsselwort hilft, alle übrigen (nicht speziell behandelten) Fälle zu behandeln.

+ +
switch (expr) {
+  case 'Oranges':
+    console.log('Oranges are $0.59 a pound.');
+    break;
+  case 'Apples':
+    console.log('Apples are $0.32 a pound.');
+    break;
+  default:
+    console.log('Sorry, we are out of ' + expr + '.');
+}
+ +

Verwenden von default mit export

+ +

Wenn Sie einen einzelnen Wert oder einen "fallback" Wert für ein Modul brauchen, können Sie einen default export verwenden:

+ +
// module "my-module.js"
+let cube = function cube(x) {
+  return x * x * x;
+}
+export default cube;
+ +

Dann kann der default export in einem anderen Skript direkt importiert werden:

+ +
// module "my-module.js"
+import myFunction from 'my-module';
+console.log(cube(3)); // 27
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES6', '#sec-switch-statement', 'switch statement')}}{{Spec2('ES6')}} 
{{SpecName('ES6', '#sec-exports', 'Exports')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-switch-statement', 'switch statement')}}{{Spec2('ESDraft')}} 
{{SpecName('ESDraft', '#sec-exports', 'Exports')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.statements.default")}}

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/statements/do...while/index.html b/files/de/web/javascript/reference/statements/do...while/index.html new file mode 100644 index 0000000000..80dbf27192 --- /dev/null +++ b/files/de/web/javascript/reference/statements/do...while/index.html @@ -0,0 +1,132 @@ +--- +title: do...while +slug: Web/JavaScript/Reference/Statements/do...while +tags: + - JavaScript + - Statement +translation_of: Web/JavaScript/Reference/Statements/do...while +--- +
{{jsSidebar("Statements")}}
+ +

Das do...while statement erstellt eine Schleife, die einen bestimmten Ausdruck ausführt, bis die zu überprüfende Aussage falsch wird. Die Aussage wird überprüft, nachdem der Ausdruck ausgeführt wurde, sodass der Ausdruck mindenstens einmal ausgeführt wird.

+ +

Syntax

+ +
do
+   statement
+while (condition);
+
+ +
+
statement
+
Ein Ausdruck, welcher mindestens einmal ausgeführt wird und jedes Mal, wenn die Aussage wahr ist, wieder ausgeführt wird. Um mehrere Ausdrücke in der Schleife auszuführen,  nutzen Sie eine {{jsxref("Statements/block", "block")}} - Aussage ({ ... }) um diese Aussagen zu gruppieren.
+
+ +
+
condition
+
Eine Aussage, die nach jedem Durchgang durch die Schleife überprüft wird. Falls condition wahr ist, wird das statement wieder ausgeführt. Wenn condition falsch wird, geht das Programm zu dem Ausdruck nach dem do...while über.
+
+ +

Beispiele

+ +

do...while benutzen

+ +

 In dem folgendem Beispiel wird die do...while - Schleife mindestens einmal ausgeführt und wird wieder ausgeführt, bis i nicht länger weniger als 5 ist.

+ +
var i = 0;
+do {
+   i += 1;
+   console.log(i);
+} while (i < 5);
+
+ +

Spezialisierungen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezialisierungStatusKommentar
{{SpecName('ES3')}}{{Spec2('ES3')}}Initiale Definition. Implementiert in JavaScript 1.2
{{SpecName('ES5.1', '#sec-12.6.1', 'do-while statement')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-do-while-statement', 'do-while statement')}}{{Spec2('ES6')}}Trailing ; ist jetzt optional.
{{SpecName('ESDraft', '#sec-do-while-statement', 'do-while statement')}}{{Spec2('ESDraft')}} 
+ +

Browser compatibility

+ +

{{CompatibilityTable}}

+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basisunterstützung{{CompatVersionUnknown}}{{CompatVersionUnknown}}6{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basisunterstützung{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/statements/empty/index.html b/files/de/web/javascript/reference/statements/empty/index.html new file mode 100644 index 0000000000..d31a88d0bb --- /dev/null +++ b/files/de/web/javascript/reference/statements/empty/index.html @@ -0,0 +1,147 @@ +--- +title: empty +slug: Web/JavaScript/Reference/Statements/Empty +tags: + - Anweisung + - JavaScript +translation_of: Web/JavaScript/Reference/Statements/Empty +--- +
{{jsSidebar("Statements")}}
+ +

Eine leere Anweisung dient der Angabe keiner Anweisung, obwohl die JavaScript Syntax eine erwarten würde.

+ +

Syntax

+ +
;
+
+ +

Beschreibung

+ +

Die leere Anweisung ist ein Semikolon (;) und zeigt an, dass keine Anweisung ausgeführt wird, selbst wenn die JavaScript Syntax eine erfordert. Das gegenteilige Verhalten, bei dem man mehrere Anweisungen haben will, aber JavaScript nur eine einzelne erlaubt, ist die Verwendung einer Blockanweisung; sie kombiniert mehrere Anweisungen in einer einzelnen.

+ +

Beispiele

+ +

Die leere Anweisung wird manchmal in Schleifenanweisungen verwendet. Siehe dazu das folgende Beispiel mit einem leeren Schleifenkörper:

+ +
var arr = [1, 2, 3];
+
+// Alle Arraywerte auf 0 setzen
+for (i = 0; i < arr.length; arr[i++] = 0) /* leere Anweisung */ ;
+
+console.log(arr)
+// [0, 0, 0]
+
+ +

Hinweis: Es ist gute Praxis, die beabsichtigte Verwendung der leeren Anweisung durch einen Kommentar zu erklären, da der Unterschied zu einem normalen Semikolon nicht offensichtlich ist. In dem folgenden Beispiel ist die Verwendung möglicherweise nicht beabsichtigt:

+ +
if (condition);       // Achtung, der "if" Zweig tut nichts!
+   killTheUniverse()  // Daher wird dies hier immer ausgeführt!!!
+
+ +

Ein anderes Beispiel: Eine if...else Anweisung ohne geschweifte Klammern ({}). Falls three wahr ist, geschieht nichts, four trifft nicht zu und auch die launchRocket() Funktion im else Zweig wird nicht ausgeführt.

+ +
if (one)
+  doOne();
+else if (two)
+  doTwo();
+else if (three)
+  ; // nothing here
+else if (four)
+  doFour();
+else
+  launchRocket();
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ESDraft', '#sec-empty-statement', 'Empty statement')}}{{Spec2('ESDraft')}} 
{{SpecName('ES6', '#sec-empty-statement', 'Empty statement')}}{{Spec2('ES6')}} 
{{SpecName('ES5.1', '#sec-12.3', 'Empty statement')}}{{Spec2('ES5.1')}} 
{{SpecName('ES3', '#sec-12.3', 'Empty statement')}}{{Spec2('ES3')}} 
{{SpecName('ES1', '#sec-12.3', 'Empty statement')}}{{Spec2('ES1')}}Initiale Definition.
+ +

Browserkompatibilität

+ +

{{CompatibilityTable}}

+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/statements/export/index.html b/files/de/web/javascript/reference/statements/export/index.html new file mode 100644 index 0000000000..ffeec6b683 --- /dev/null +++ b/files/de/web/javascript/reference/statements/export/index.html @@ -0,0 +1,126 @@ +--- +title: export +slug: Web/JavaScript/Reference/Statements/export +tags: + - ECMAScript 2015 + - JavaScript + - Modules + - Statement + - export +translation_of: Web/JavaScript/Reference/Statements/export +--- +
{{jsSidebar("Statements")}}
+ +

Das export-Statement wird verwendet, um Funktionen und Objekte aus einer gegebenen Datei (oder Modul) zu exportieren.

+ +

Syntax

+ +
export { name1, name2, …, nameN };
+export { variable1 as name1, variable2 as name2, …, nameN };
+export let name1, name2, …, nameN; // oder: var
+export let name1 = …, name2 = …, …, nameN; // oder: var, const
+
+export default expression;
+export default function (…) { … } // oder: class, function*
+export default function name1(…) { … } // oder: class, function*
+export { name1 as default, … };
+
+export * from …;
+export { name1, name2, …, nameN } from …;
+export { import1 as name1, import2 as name2, …, nameN } from …;
+ +
+
nameN
+
Bezeichner der exportiert werden soll (damit er in einem anderen Script via import importiert werden kann).
+
+ +

Beschreibung

+ +

Es gibt zwei verschiedene Arten von Exports, die jeweils der oben angegebene Syntax entsprechen:

+ + + +

Benannte Exports sind nützlich um mehrere Werte zu exportieren. Beim Import kann man den selben Namen verwenden um auf den entsprechenden Wert zu verweisen.

+ +

Bezüglich Default-Export: es kann nur einen einzigen Default-Export pro Modul geben. Ein Default-Export kann eine Funktion sein, eine Klasse, ein Objekt oder irgendetwas anderes. Da dieser Wert am einfachsten importiert werden kann wird er als der "Haupt-Export" des Moduls angesehen.

+ +

Beispiele

+ +

Benannte Exports

+ +

Im Modul können wir den folgenden Code verwenden:

+ +
// Modul "my-module.js"
+function cube(x) {
+  return x * x * x;
+}
+const foo = Math.PI + Math.SQRT2;
+export { cube, foo };
+
+ +

Daraufhin könnten wir nun in einem anderen Script (cf. import) wie folgt vorgehen:

+ +
import { cube, foo } from 'my-module';
+console.log(cube(3)); // 27
+console.log(foo);    // 4.555806215962888
+ +

Standard-Export

+ +

Wenn wir nur einen einzelnen Wert exportieren wollen, oder einen Fallback-Wert für unser Modul zur Verfügung haben möchten, können wir einen Default-Export verwenden:

+ +
// Modul "my-module.js"
+export default function cube(x) {
+  return x * x * x;
+}
+
+ +

In einem anderen Script kann dieser Default-Export dann unkompliziert importiert werden:

+ +
import myFunction from 'my-module';
+console.log(myFunction(3)); // 27
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES2015', '#sec-exports', 'Exports')}}{{Spec2('ES2015')}}Initiale Definition.
{{SpecName('ESDraft', '#sec-exports', 'Exports')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.statements.export")}}

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/statements/for...in/index.html b/files/de/web/javascript/reference/statements/for...in/index.html new file mode 100644 index 0000000000..228f21927c --- /dev/null +++ b/files/de/web/javascript/reference/statements/for...in/index.html @@ -0,0 +1,227 @@ +--- +title: for...in +slug: Web/JavaScript/Reference/Statements/for...in +tags: + - JavaScript + - Statement +translation_of: Web/JavaScript/Reference/Statements/for...in +--- +
+
{{jsSidebar("Statements")}}
+
+ +

Die Schleife for…in durchläuft alle aufzählbaren Eigenschaften eines Objekts (mit Ausnahme jener, deren Name ein Symbol ist) in willkürlicher Reihenfolge und führt für jede ihren Anweisungsblock aus.

+ +

Syntax

+ +
for (variable in object) {... }
+ +
+
variable
+
Bei jedem Schleifendurchlauf wird der Name der aktuellen Eigenschaft variable zugewiesen.
+
object
+
Das Objekt, dessen Eigenschaften durchlaufen werden sollen.
+
+ +

Beschreibung

+ +

Die Schleife for…in durchläuft alle eigenen und geerbten Eigenschaften, die als aufzählbar gekennzeichnet sind und deren Name kein Symbol ist, in einer nicht festgelegten Reihenfolge.

+ +

Aufzählbare Eigenschaften

+ +

Die Eigenschaften eines Javascript-Objekts können anhand ihres internen Statusfeldes enumerable als aufzählbar oder nicht aufzählbar gekennzeichnet werden.

+ +

Insbesondere erben manche eingebaute Objekte wie Array und Object nicht-aufzählbare Eigenschaften von Object.prototype and String.prototype, unter anderem die Methoden {{jsxref("String.indexOf")}} und {{jsxref("Object.toString")}}.

+ +

Nicht-aufzählbare Eigenschaften werden von for…in ignoriert.

+ +

Reihenfolge

+ +

Obwohl die Reihenfolge bei Ausführung innerhalb desselben Interpreters als festgelegt erscheinen kann, darf von diesem Umstand nicht ausgegangen werden. Andere Versionen und insbesondere andere Javascript-Interpreter werden die Eigenschaften in einer anderen Reihenfolge durchlaufen.
+ Die Gründe sind in der Beschreibung des Operators {{jsxref("Operators/delete", "delete")}} näher erklärt.

+ +

Gelöschte, hinzugefügte oder modifizierte Eigenschaften

+ +

Änderungen der Eigenschaften eines Objekts, während dieses Objekt von for…in durchlaufen wird, haben nachfolgende Auswirkungen:

+ + + +

Im Allgemeinen ist es ratsam, innerhalb einer Schleife keine Änderungen an den Eigenschaften des durchlaufenden Objekts vorzunehmen. Eine Ausnahme bildet lediglich die derzeit bearbeitete Eigenschaft.
+ Es gibt keine Garantie, dass eine hinzugefügte Eigenschaft von der Schleife noch aufgerufen wird, ob eine geänderte (außer der aktuellen) Eigenschaft vor oder nach der Änderung aufgerufen wird oder ob eine gelöschte Eigenschaft aufgerufen wird, bevor sie gelöscht wird.

+ +

Array und for…in

+ +
+

Hinweis: for…in sollte nicht für den Durchlauf eines {{jsxref("Array", "Arrays")}} verwendet werden, bei dem die Indexreihenfolge wichtig ist.

+
+ +

Anders als vielleicht von vielen anderen Programmiersprachen gewohnt sind bei Javascript die Indizes eines Feldes normale Objekt-Eigenschaften mit Ganzzahlen als Namen.

+ +

Wie oben bereits erwähnt, ist nicht sichergestellt, dass for…in Eigenschaften eines Objektes in einer bestimmten Reihenfolge durchläuft. Dies gilt, da sie normale Eigenschaften sind, auch für die Feldindizes. Zudem durchläuft for…in auch alle anderen (aufzählbaren) Eigenschaften, einschließlich derer mit nicht ganzzahligen Namen sowie geerbte.

+ +

for…in ist daher nicht geeignet, um die Felder eines Objekts vom Typ Array von 0 bis Array.length der Reihenfolge nach zu durchlaufen.
+ Zu diesem Zweck kann entweder auf eine {{jsxref("Statements/for", "for-Schleife")}} mit numerischem Zähler, die Array-eigene Methode {{jsxref("Array.prototype.forEach()", "forEach()")}} oder eine {{jsxref("Statements/for...of", "for...of-Schleife")}} verwendet werden.

+ +

Durchlauf nur über eigene Eigenschaften

+ +

Sollen nur Eigenschaften berücksichtigen möchten, die direkt mit dem Objekt verknüpft und nicht von dessen Prototypen geerbt sind, bietet sich {{jsxref("Object.getOwnPropertyNames", "getOwnPropertyNames()")}} an. Die Zugehörigkeit auf einer bestimmten Eigenschaft kann mit {{jsxref("Object.prototype.hasOwnProperty", "hasOwnProperty()")}} geprüft werden.
+ Alternativ können eingebaute Prototypen mit einer Prüfmethode erweitert werden, sofern sichergestellt ist, dass es nicht zu einer Beeinflussung von externem Code kommt.

+ +

Beispiele

+ +

Die folgende Funktion erwartet ein Objekt als Argument. Es werden dann alle aufzählbaren Eigenschaften des Objekts durchlaufen und der Name der Eigenschaft mit dem entsprechenden Wert ausgegeben.

+ +
var obj = {a:1, b:2, c:3};
+
+for (var prop in obj) {
+  console.log("o." + prop + " = " + obj[prop]);
+}
+
+// Ausgabe:
+// "o.a = 1"
+// "o.b = 2"
+// "o.c = 3"
+ +

Die folgende Funktion verdeutlicht die Verwendung von {{jsxref("Object.hasOwnProperty", "hasOwnProperty()")}}: die geerbten Eigenschaften werden nicht angezeigt.

+ +
var triangle = {a:1, b:2, c:3};
+
+function ColoredTriangle() {
+  this.color = "red";
+}
+
+ColoredTriangle.prototype = triangle;
+
+var obj = new ColoredTriangle();
+
+for (var prop in obj) {
+  if( obj.hasOwnProperty( prop ) ) {
+    console.log("o." + prop + " = " + obj[prop]);
+  }
+}
+
+// Ausgabe:
+// "o.color = red"
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ESDraft', '#sec-for-in-and-for-of-statements', 'for...in statement')}}{{Spec2('ESDraft')}}
{{SpecName('ES6', '#sec-for-in-and-for-of-statements', 'for...in statement')}}{{Spec2('ES6')}}
{{SpecName('ES5.1', '#sec-12.6.4', 'for...in statement')}}{{Spec2('ES5.1')}}
{{SpecName('ES3', '#sec-12.6.4', 'for...in statement')}}{{Spec2('ES3')}}
{{SpecName('ES1', '#sec-12.6.3', 'for...in statement')}}{{Spec2('ES1')}}Initiale Definition.
+ +

Browserkompatibilität

+ +

{{ CompatibilityTable() }}

+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}6{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Kompatibilität: Initialisierender Ausdruck

+ +

Vor SpiderMonkey 40 {{geckoRelease(40)}}, war es möglich einen initialisierenden Ausdruck (i=0) in einer for…in-Schleife zu benutzen:

+ +
var obj = {a:1, b:2, c:3};
+for(var i=0 in obj) {
+  console.log(obj[i]);
+}
+// 1
+// 2
+// 3
+
+ +

Dieses nicht standardisierte Verhalten wird ab der Version 40 ignoriert und führt im strict-Modus zu einem {{jsxref("SyntaxError")}}, "for-in loop head declarations may not have initializers" (siehe {{bug(748550)}} und {{bug(1164741)}}).

+ +

Andere Umgebungen wie v8 (Chrome), Chakra (IE/Edge), und JSC (WebKit/Safari) prüfen ebenfalls die Möglichkeit, dieses Verhalten zu entfernen.

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/statements/for...of/index.html b/files/de/web/javascript/reference/statements/for...of/index.html new file mode 100644 index 0000000000..4010e660e3 --- /dev/null +++ b/files/de/web/javascript/reference/statements/for...of/index.html @@ -0,0 +1,183 @@ +--- +title: for...of +slug: Web/JavaScript/Reference/Statements/for...of +tags: + - ECMAScript 2015 + - Experimental + - JavaScript + - Statement +translation_of: Web/JavaScript/Reference/Statements/for...of +--- +
{{jsSidebar("Statements")}}
+ +

Mit dem for...of statement können sogenannte iterable objects durchlaufen werden ({{jsxref("Array")}}, {{jsxref("Map")}}, {{jsxref("Set")}}, das arguments Objekt und weitere eingeschlossen), wobei auf jeden gefundenen Wert eigene Statements ausgeführt werden können.

+ +

Syntax

+ +
for (variable of iterable) {
+  statement
+}
+
+ +
+
variable
+
Bei jedem Durchlauf wird variable der jeweils gefundene Wert zugewiesen.
+
iterable
+
Objekt, dessen aufzählbare Eigenschaften durchlaufen werden.
+
+ +

Beispiele

+ +

Unterschied zwischen for...of und for...in

+ +

Das folgende Beispiel zeigt den Unterschied zwischen einer for...of und einer for...in Schleife. Während for...in über die Namen der Eigenschaften läuft, geht for...of über deren Werte:

+ +
let arr = [3, 5, 7];
+arr.foo = "hallo";
+
+for (let i in arr) {
+   console.log(i); // logs "0", "1", "2", "foo"
+}
+
+for (let i of arr) {
+   console.log(i); // logs "3", "5", "7"
+}
+
+ +

Nutzen von Array.prototype.forEach()

+ +

Um dieselben Werte zu bekommen, die eine for...of Schleife zurückgeben würde, kann man auch die {{jsxref("Array.prototype.forEach()")}} Methode nutzen:

+ +
let arr = [3, 5, 7];
+arr.foo = "hallo";
+
+arr.forEach(function (element, index) {
+    console.log(element); // logs "3", "5", "7"
+    console.log(index);   // logs "0", "1", "2"
+});
+
+// or with Object.keys()
+
+Object.keys(arr).forEach(function (element, index) {
+    console.log(arr[element]); // logs "3", "5", "7", "hallo"
+    console.log(arr[index]);   // logs "3", "5", "7"
+});
+ +

Durchlaufen von DOM collections 

+ +

DOM collections wie {{domxref("NodeList")}} durchlaufen: Das folgende Beispiel fügt eine read class zu allen Paragraphen hinzu, die direkte Nachfolger eines Artikels sind:

+ +
// Notiz: Das wird nur auf Plattformen funktionieren, die
+// NodeList.prototype[Symbol.iterator] implementiert haben
+let articleParagraphs = document.querySelectorAll("article > p");
+
+for (let paragraph of articleParagraphs) {
+  paragraph.classList.add("read");
+}
+
+ +

Durchlaufen von Generatoren

+ +

Man kann auch Generatoren durchlaufen:

+ +
function* fibonacci() { // ein Generator
+    let [prev, curr] = [0, 1];
+    for (;;) {
+        [prev, curr] = [curr, prev + curr];
+        yield curr;
+    }
+}
+
+for (let n of fibonacci()) {
+    // die Sequence bei 1000 abbrechen
+    if (n > 1000)
+        break;
+    console.log(n);
+}
+
+ +

Spezifikation

+ + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES2015', '#sec-for-in-and-for-of-statements', 'for...of statement')}}{{Spec2('ES2015')}}Initial definition.
+ +

Browserkompatibilität

+ +

{{CompatibilityTable}}

+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatChrome(29)}}[1]
+ {{CompatChrome(38)}}		{{CompatGeckoDesktop("13")}}
+ {{CompatGeckoDesktop("17")}} (.iterator)
+ {{CompatGeckoDesktop("27")}} ("@@iterator")
+ {{CompatGeckoDesktop("36")}} (Symbol.iterator)		{{CompatNo}}257.1
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatUnknown}}{{CompatChrome(29)}}[1]
+ {{CompatChrome(38)}}		{{CompatGeckoMobile("13")}}
+ {{CompatGeckoMobile("17")}} (.iterator)
+ {{CompatGeckoMobile("27")}} ("@@iterator")
+ {{CompatGeckoMobile("36")}} (Symbol.iterator)		{{CompatUnknown}}{{CompatUnknown}}iOS 8
+
+ +

[1] Dieses Feature ist als Option enthalten. In chrome://flags/#enable-javascript-harmony muss der Eintrag “Enable Experimental JavaScript” aktiviert werden.

+ +

See also

+ + diff --git a/files/de/web/javascript/reference/statements/for/index.html b/files/de/web/javascript/reference/statements/for/index.html new file mode 100644 index 0000000000..d77a89b846 --- /dev/null +++ b/files/de/web/javascript/reference/statements/for/index.html @@ -0,0 +1,201 @@ +--- +title: for +slug: Web/JavaScript/Reference/Statements/for +tags: + - Anweisung + - JavaScript + - Loop + - for +translation_of: Web/JavaScript/Reference/Statements/for +--- +
{{jsSidebar("Anweisungen")}}
+ +

Die for Anweisung beschreibt eine Schleife mit drei optionalen Ausdrücken und einer oder mehreren Anweisungen.

+ +

Syntax

+ +
for ([initialization]; [condition]; [final-expression])
+   statement
+
+ +
+
initialization
+
Ein Ausdruck (inklusive Zuweisungen) oder eine Variablendeklaration. Normalerweise wird ein Schleifenzähler initialisiert. Neu deklarierte Variablen haben denselben Geltungsbereich wie die for Schleife (d.h. sie sind nicht lokal auf die Schleife begrenzt). Die Initialisierung ist optional.
+
condition
+
Die Bedingung wird vor jedem Schleifendurchlauf ausgewertet. Ergibt die Auswertung true, dann wird die Answeisung (statement) ausgeführt. Die Bedingung ist optional. Bei fehlender Bedingung gilt immer true. Bei false wird die Schleife verlassen (und bei der nächsten Anweisung, die dem Schleifenende folgt, weitergemacht).
+
final-expression
+
Dieser Ausdruck wird nach jedem Schleifendurchlauf ausgewertet. Dies findet vor der nächsten Auswertung der Schleifenbedinung statt. Üblicherweise wird der Schleifenzähler inkrementiert oder dekrementiert.
+
statement
+
Der Ausdruck wird ausgeführt solange die Bedingung erfüllt ist (true). Man kann mehrere Anweisungen ausführen, indem man sie in einer block Anweisung  ({ ... }) zusammenfasst. Eine leere Anweisung (empty statement), markiert durch semikolon, kann auch ausgeführt werden.
+
+ +

Beispiele

+ +

Verwendung der for Schleife

+ +

Die folgende for Anweisung initialisiert die Variable i mit null. Die Bedingung prüft ob i kleiner neun ist, führt den Code in der block Anweisung aus und erhöht i um eins nach jedem Schleifendurchlauf.

+ +
for (var i = 0; i < 9; i++) {
+   console.log(i);
+   // more statements
+}
+
+ +

Optionale for Ausdrücke

+ +

Alle drei for Ausdrücke sind optional.

+ +

Z.B. kann der Initialisierungsblock leer sein:

+ +
var i = 0;
+for (; i < 9; i++) {
+    console.log(i);
+    // more statements
+}
+
+ +

Die Schleifenbedinung ist auch optional. Man muss jedoch darauf achten, dass in der Schleife eine Austrittsbedingung (break Anweisung) vorkommt, um nicht in eine Endlosschleife zu geraten.

+ +
for (var i = 0;; i++) {
+   console.log(i);
+   if (i > 3) break;
+   // more statements
+}
+ +

Das gleiche gilt selbstverständlich wenn man alle drei Blöcke leer lässt. Hier wird i in der Schleife inkrementiert, um sicherzustellen, dass nach endlich vielen Durchläufen die Schleife abgebrochen wird.

+ +
var i = 0;
+
+for (;;) {
+  if (i > 3) break;
+  console.log(i);
+  i++;
+}
+
+ +

Verwendung von for Schleife mit leerer Anweisung

+ +

Das folgende Beispiel zeigt eine leere Anweisung im Schleifenkörper. Die Berechnungen finden im Ausdruck [final-expression] statt. Die Schleife wird solange durchlaufen bis die Bedingung nicht mehr erfüllt ist.

+ +
function showOffsetPos (sId) {
+  var nLeft = 0, nTop = 0;
+
+  for (var oItNode = document.getElementById(sId); // initialization
+       oItNode; // condition
+       nLeft += oItNode.offsetLeft, nTop += oItNode.offsetTop, oItNode = oItNode.offsetParent) // final-expression
+       /* empty statement */ ;
+
+  console.log("Offset position of \"" + sId + "\" element:\n left: " + nLeft + "px;\n top: " + nTop + "px;");
+}
+
+// Example call:
+
+showOffsetPos("content");
+
+// Output:
+// "Offset position of "content" element:
+// left: 0px;
+// top: 153px;"
+ +
Beachte: Die leere Anweisung folgt der Schleife und besteht lediglich aus einem Semikolon.
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusBemerkung
{{SpecName('ES1', '#sec-12.6.2', 'for statement')}}{{Spec2('ES1')}}Ursprüngliche Definition.
{{SpecName('ES3', '#sec-12.6.3', 'for statement')}}{{Spec2('ES3')}} 
{{SpecName('ES5.1', '#sec-12.6.3', 'for statement')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-for-statement', 'for statement')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-for-statement', 'for statement')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ +

{{CompatibilityTable}}

+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Unterstützung{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Unterstützung{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/statements/for_each...in/index.html b/files/de/web/javascript/reference/statements/for_each...in/index.html new file mode 100644 index 0000000000..34a52f5397 --- /dev/null +++ b/files/de/web/javascript/reference/statements/for_each...in/index.html @@ -0,0 +1,122 @@ +--- +title: for each...in +slug: Web/JavaScript/Reference/Statements/for_each...in +tags: + - Deprecated + - JavaScript + - Statement +translation_of: Archive/Web/JavaScript/for_each...in +--- +
{{jsSidebar("Statements")}}
+ +
+

The for each...in statement is deprecated as the part of ECMA-357 (E4X) standard. E4X support has been removed, but for each...in will not be disabled and removed because of backward compatibility considerations. Consider using {{jsxref("Statements/for...of", "for...of")}} instead. (Please refer to {{bug("791343")}}.)

+
+ +

Die for each...in Schleife wiederholt die definierteVariable in jeder Instanz eines Objekts. Für jedes einzelne Vorkommen wird der bestimmte Befehl ausgeführt.

+ +

Syntax

+ +
for each (variable in object) {
+  statement
+}
+ +
+
variable
+
die Variable, die innerhalb des durchsuchten Projekts gesucht wird. Diese kann durch das Schlüsselwort var bestimmt werden. Die Variable wird Lokal innerhalb der Funktion definiert, nicht für die ganze Schleife.
+
+ +
+
object
+
das Objekt, innerhalb dessen die Werte gesucht werden.
+
+ +
+
statement
+
am Befehl, der bei jedem auftreten der gesuchten Eigenschaft ausgeführt wird. Um mehrere Befehle innerhalb der Schleife auszuführen, nutzen Sie für deren Gruppierung das {{jsxref("Statements/block", "Block")}} statement ({ ... }) .
+
+ +

Beschreibung

+ +

einige Eigenschaften werden nicht in der Schleife durchsucht. Diese umfassen alle standardmäßigen Methoden von Objekten, beispielsweise die String-Methode indexOf. Es werden jedoch alle vom Nutzer definierten Werte durchsucht.

+ +

Beispiele

+ +

Nutzung von for each...in

+ +

Warnung: Nutzen Sie eine derartige Schleife niemals in Arrays. Nutzen Sie diese nur für Objekte. Weitere Einzelheiten bei {{jsxref("Statements/for...in", "for...in")}}.

+ +

der folgende Code Ausschnitt durchsucht die Eigenschaften eines Objektes und errechnet ihre Summe:

+ +
var sum = 0;
+var obj = {prop1: 5, prop2: 13, prop3: 8};
+
+for each (var item in obj) {
+  sum += item;
+}
+
+console.log(sum); // logs "26", which is 5+13+8
+ +

Spezifikationen

+ +

Kein teil der ECMA-262 Spezifikation. Implementiert in JavaScript 1.6 und deprecated.

+ +

Browserkompatibilität

+ +

{{CompatibilityTable}}

+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatNo}}{{CompatGeckoDesktop("1.8")}}{{CompatNo}}{{CompatNo}}{{CompatNo}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatNo}}{{CompatNo}}{{CompatGeckoMobile("1.0")}}{{CompatNo}}{{CompatNo}}{{CompatNo}}
+
+ +

See also

+ + diff --git a/files/de/web/javascript/reference/statements/function_star_/index.html b/files/de/web/javascript/reference/statements/function_star_/index.html new file mode 100644 index 0000000000..a8b2982dce --- /dev/null +++ b/files/de/web/javascript/reference/statements/function_star_/index.html @@ -0,0 +1,200 @@ +--- +title: function* +slug: Web/JavaScript/Reference/Statements/function* +tags: + - ECMAScript 2015 + - Function + - Iterator + - JavaScript + - Statement +translation_of: Web/JavaScript/Reference/Statements/function* +--- +
{{jsSidebar("Statements")}}
+ +

Die function*-Deklaration ( Schlüsselwort function gefolgt von einem Stern) definiert eine Generatorfunktion, welche ein  {{jsxref("Global_Objects/Generator","Generator")}}-Objekt zurückgibt.

+ +
{{EmbedInteractiveExample("pages/js/statement-functionasterisk.html")}}
+ + + +
+

Eine Generatorfunktion kann auch mittels des {{jsxref("GeneratorFunction")}}-Konstruktors definiert werden.

+
+ +

Syntax

+ +
function* name([param[, param[, ... param]]]) {
+   statements
+}
+
+ +
+
name
+
Der Name der Funktion.
+
+ +
+
param
+
Der Name eines an die Funktion zu übergebenden Arguments. Eine Funktion kann bis zu 255 Argumente haben.
+
+ +
+
statements
+
Die den Körper der Funktion ergebenden Anweisungen.
+
+ +

Beschreibung

+ +

Generatoren sind Funktionen, die verlassen und später wieder betreten werden können. Ihr Kontext (Variablenbindung) bleibt über die Wiedereintritte hinweg erhalten.

+ +

Der Aufruf einer Generatorfunktion führt ihren Körper nicht sofort aus; stattdessen wird ein Iterator-Objekt einer Funktion zurückgegeben. Wenn die next()-Methode des Iterators aufgerufen wird, wird der Körper der Generatorfunktion bis zum ersten {{jsxref("Operators/yield", "yield")}}-Ausdruck ausgeführt, der den vom Iterator zurückzugebenden Wert spezifiziert oder mittels {{jsxref("Operators/yield*", "yield*")}} an eine andere Generatorfunktion weitergibt. Die Methode next() gibt ein Objekt mit einer value-Eigenschaft zurück, die den zurückgegebenen Wert enthält, und eine Eigenschaft done, die anzeigt, ob der Generator seinen letzten Wert zurückgegeben hat (boolescher Wert). Beim Aufrufen der next()-Methode mit einem Argument wird die Generatorfunktion weiter ausgeführt.

+ +

Ein return-Statement in einer Generatorfunktion sorgt dafür, dass der Generator fertig ist (Status done). Falls ein Wert zurückgegeben wird, dann wird dieser als value zurückgegeben. Anschließend wird kein weiterer Wert mehr zurückgegeben.

+ +

Beispiele

+ +

Einfaches Beispiel

+ +
function* idMaker(){
+  var index = 0;
+  while(index < index+1)
+    yield index++;
+}
+
+var gen = idMaker();
+
+console.log(gen.next().value); // 0
+console.log(gen.next().value); // 1
+console.log(gen.next().value); // 2
+console.log(gen.next().value); // 3
+// ...
+ +

Beispiel mit yield*

+ +
function* anotherGenerator(i) {
+  yield i + 1;
+  yield i + 2;
+  yield i + 3;
+}
+
+function* generator(i) {
+  yield i;
+  yield* anotherGenerator(i);
+  yield i + 10;
+}
+
+var gen = generator(10);
+
+console.log(gen.next().value); // 10
+console.log(gen.next().value); // 11
+console.log(gen.next().value); // 12
+console.log(gen.next().value); // 13
+console.log(gen.next().value); // 20
+
+ +

Übergeben von Argumenten in Generatoren

+ +
function* logGenerator() {
+  console.log(0);
+  console.log(1, yield);
+  console.log(2, yield);
+  console.log(3, yield);
+}
+
+var gen = logGenerator();
+
+// the first call of next executes from the start of the function
+// until the first yield statement
+gen.next();             // 0
+gen.next('pretzel');    // 1 pretzel
+gen.next('california'); // 2 california
+gen.next('mayonnaise'); // 3 mayonnaise
+
+ +

Return Statement in einem Generator

+ +
function* yieldAndReturn() {
+  yield "Y";
+  return "R";
+  yield "unreachable";
+}
+
+var gen = yieldAndReturn()
+console.log(gen.next()); // { value: "Y", done: false }
+console.log(gen.next()); // { value: "R", done: true }
+console.log(gen.next()); // { value: undefined, done: true }
+
+ +

Generatoren haben keinen Konstruktor

+ +
function* f() {}
+var obj = new f; // throws "TypeError: f ist kein Konstruktor"
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES2015', '#', 'function*')}}{{Spec2('ES2015')}}Initiale Definition.
{{SpecName('ES2016', '#', 'function*')}}{{Spec2('ES2016')}}Änderung, dass Generatoren nicht über [[Construct]] trap verfügen und eine Ausnahme bei der Verwendung von new erzeugen.
{{SpecName('ESDraft', '#', 'function*')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ +
+ + +

{{Compat("javascript.statements.generator_function")}}

+
+ +

Firefox-spezifische Hinweise

+ +

Generatoren und Iteratoren in Firefox-Versionen vor 26

+ +

Ältere Firefox-Versionen implementierten eine ältere Version des Generatorenentwurfs. In den älteren Versionen wurden Generatoren, neben anderen Abweichungen, mit dem normalen Schlüsselwort function (ohne den Stern) definiert. Siehe veraltete Generatorfunktion für weitere Informationen.

+ +

IteratorResult-Objekt zurückgegeben anstatt Ausnahme erzeugt

+ +

Beginnend mit Gecko 29 {{geckoRelease(29)}} erzeugt die ausgeführte Generatorfunktion keine {{jsxref("TypeError")}} "generator has already finished"-Ausnahme mehr. Stattdessen gibt sie ein IteratorResult-Objekt mit { value: undefined, done: true } ({{bug(958951)}}) zurück.

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/statements/funktion/index.html b/files/de/web/javascript/reference/statements/funktion/index.html new file mode 100644 index 0000000000..64a54347bc --- /dev/null +++ b/files/de/web/javascript/reference/statements/funktion/index.html @@ -0,0 +1,190 @@ +--- +title: Funktion +slug: Web/JavaScript/Reference/Statements/funktion +translation_of: Web/JavaScript/Reference/Statements/function +--- +
{{jsSidebar("Statements")}}
+ +

Die Funktionsdeklaration definiert eine Funktion mit den angegebenen Parametern.

+ +

Es kann auch eine Funktion mit dem {{jsxref("Function")}}-Konstruktor und einem {{jsxref("Operators/function", "Funktionsausdruck")}} deklariert werden.

+ +

Syntax

+ +
function name([param,[, param,[..., param]]]) {
+   [statements]
+}
+
+ +
+
name
+
Der Funktionsname.
+
+ +
+
param
+
Der Name des Arguments, der an die Funktion übergeben werden soll. Eine Funktion kann bis zu 255 Argumente haben.
+
+ +
+
statements
+
Die Ausdrücke, aus denen der Funktionskörper besteht.
+
+ +

Beschreibung

+ +

Eine Funktion, die mit der Funktionsdeklaration erstellt wurde, ist ein Function -Objekt und hat alle Eigenschaften, Methoden und Verhalten des Function-Objekts. Siehe {{jsxref("Function")}} für detaillierte Information über Funktionen.

+ +

Eine Funktion kann auch mit einem Ausdruck erzeugt werden (siehe {{jsxref("Operators/function", "function expression")}}).

+ +

Standardmäßig geben Funktionen undefined zurück. Um einen beliebigen anderen Wert zurückzugeben muss die Funktion einen {{jsxref("Statements/return", "return")}}-Ausdruck haben, der den Wert der Rückgabe angibt.

+ +

Bedingungskreierte Funktionen

+ +

Funktionen können bedingungskreiert werden. Das heißt: Eine Funktionsanweisung kann innerhalb einer if-Anweisung verschachtelt werden. Die meisten modernen Browser, abseits von Mozilla, werden solche konditionsbasierten Deklarationen als unkonditionelle Deklarationen behandeln und die Funktion erstellen, ob wahr oder nicht, siehe dieser Artikel für eine Übersicht. Deshalb sollten sie so nicht verwendet werden. Stattdessen sollten Funktionsausdrücke für eine konditionelle Erstellung verwendet werden.

+ +

Hochziehen der Funktionsdeklaration

+ +

Funktionsdeklarationen in Javascript ziehen die Funktionsdefinition hoch. D. h. Funktionen können benutzt werden noch bevor sie deklariert wurden:

+ +
hochgezogen(); // loggt "foo"
+
+function hochgezogen() {
+  console.log("foo");
+}
+
+ +

Zu beachten ist aber, dass {{jsxref("Operators/function", "Funktionsausdrücke")}} nicht hochgezogen werden:

+ +
nichtHochgezogen(); // TypeError: nichtHochgezogen is not a function
+
+var nichtHochgezogen = function() {
+   console.log("bar");
+};
+
+ +

Beispiele

+ +

Mit function

+ +

Der folgende Code deklariert eine Funktion, die die Summe aller Verkäufe zurückgibt, wenn sie die Anzahl der verkauften Einheiten a, b, und c übergeben bekommt.

+ +
function berechne_verkäufe(einheit_a, einheit_b, einheit_c) {
+   return einheit_a*79 + einheit_b * 129 + einheit_c * 699;
+}
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES6', '#sec-function-definitions', 'Function definitions')}}{{Spec2('ES6')}} 
{{SpecName('ES5.1', '#sec-13', 'Function definition')}}{{Spec2('ES5.1')}} 
{{SpecName('ES3', '#sec-13', 'Function definition')}}{{Spec2('ES3')}} 
{{SpecName('ES1', '#sec-13', 'Function definition')}}{{Spec2('ES1')}}Initial definition. Implemented in JavaScript 1.0.
+ +

Browserkompatibilität

+ +

{{CompatibilityTable}}

+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
Allowed in sloppy mode{{CompatChrome(49.0)}}    
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidAndroid WebviewFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
Allowed in sloppy mode{{CompatNo}} +

{{CompatChrome(49.0)}}

+ 		    
+
+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/statements/if...else/index.html b/files/de/web/javascript/reference/statements/if...else/index.html new file mode 100644 index 0000000000..f0d95829cf --- /dev/null +++ b/files/de/web/javascript/reference/statements/if...else/index.html @@ -0,0 +1,168 @@ +--- +title: if...else +slug: Web/JavaScript/Reference/Statements/if...else +tags: + - JavaScript + - Statement +translation_of: Web/JavaScript/Reference/Statements/if...else +--- +
{{jsSidebar("Statements")}}
+ +

Die if-Anweisung führt Anweisungen aus, wenn eine bestimmte Bedingung zu true ausgewertet wird. Wird die Bedingung zu false ausgewertet, können andere Anweisungen ausgeführt werden.

+ +
{{EmbedInteractiveExample("pages/js/statement-ifelse.html")}}
+ + + +

Syntax

+ +
if (bedingung) anweisung1 [else anweisung2]
+
+ +
+
bedingung
+
Ein Ausdruck, der zu true oder false ausgewertet wird.
+
+ +
+
anweisung1
+
Eine Anweisung, die ausgeführt wird, wenn bedingung zu true ausgewertet wird. Diese Anweisung kann jede gültige Anweisung sein, auch eine if-Anweisung. Um mehrere Anweisungen auszuführen, muss eine {{jsxref("Statements/block", "block")}}-Anweisung ({...}) genutzt werden, um die Anweisungen zu gruppieren. Wenn keine Anweisung ausgeführt werden soll, muss die {{jsxref("Statements/empty", "empty")}}-Anweisung genutzt werden.
+
+ +
+
anweisung2
+
Eine Anweisung, die ausgeführt wird, wenn bedingung zu false ausgewertet wird und die else Klausel existiert. Auch hier können alle Anweisungen, egal ob {{jsxref("Statements/block", "block")}}-Anweisung ({...}) oder weitere if-Anweisungen genutzt werden.
+
+ +

Beschreibung

+ +

Mehrere if...else-Anweisungen können verschachtelt werden, wenn eine else if-Klausel erstellt wird. Zu beachten ist, dass es in JavaScript kein Schlüsselwort elseif (in einem Wort) gibt.

+ +
if (bedingung1)
+   anweisung1
+else if (bedingung2)
+   anweisung2
+else if (bedingung3)
+   anweisung3
+...
+else
+   anweisungN
+
+ +

Um zu sehen wie das funktioniert, ist es hilfreich, die verschachtelten Anweisungen einzurücken:

+ +
if (bedingung1)
+   anweisung1
+else
+   if (bedingung2)
+      anweisung2
+   else
+      if (bedingung3)
+...
+
+ +

Um mehrere Anweisungen in einer Klausel auszuführen, muss eine {{jsxref("Statements/block", "block")}}-Anweisung genutzt werden. Allgemein ist es immer gute Praxis (best practice) eine {{jsxref("Statements/block", "block")}}-Anweisung zu nutzen, besonders bei verschachtelten if-Anweisungen.

+ +
if (bedingung) {
+  anweisung1
+} else {
+  anweisung2
+}
+
+ +

Man sollte den primitiven boolean-Datentyp nicht mit dem {{jsxref("Global_Objects/Boolean", "Boolean")}}-Objekt verwechseln. Jeder Wert, der nicht undefined, null, 0, NaN, oder der leere string ("") ist, wird zu true ausgewertet. Dabei ist auch ein {{jsxref("Global_Objects/Boolean", "Boolean")}}-Objekt mit dem Wert false inbegriffen.

+ +
var b = new Boolean(false);
+if (b) // wird zu true ausgewertet
+
+ +

Beispiele

+ +

Einsatz von if...else

+ +
if (cipher_char === from_char) {
+  result = result + to_char;
+  x++;
+} else {
+  result = result + clear_char;
+}
+
+ +

Einsatz von else if

+ +

Zu beachten ist, dass in JavaScript kein elseif-Schlüsselwort existiert. Man kann jedoch immer ein Leerzeichen zwischen else und if benutzen.

+ +
if (x > 5) {
+
+} else if (x > 50) {
+
+} else {
+
+}
+ +

Zuweisungen in der Bedingung

+ +

Es ist nicht ratsam einfache Zuweisungen in die Bedingung zu schreiben, weil sie zu Verwechselungen mit dem Gleichheit-Operator führen kann. Zum Beispiel führt folgender Quelltext, der eine Zuweisung enthält immer zu 'true' und sollte daher so nicht benutzt werden:

+ +
if (x = y) {
+   /* tu das richtige */
+}
+
+ +

Wenn es nötig ist, eine Zuweisung in einer Bedingungs-Anweisunge zu benutzen, dann sollten Klammern um die Zuweisung gesetzt werden. Der Effekt ist jedoch derselbe, wie im vorangegangenen Code. Zum Beispiel:

+ +
if ((x = y)) {
+   /* tu das richtige */
+}
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ESDraft', '#sec-if-statement', 'if statement')}}{{Spec2('ESDraft')}} 
{{SpecName('ES6', '#sec-if-statement', 'if statement')}}{{Spec2('ES6')}} 
{{SpecName('ES5.1', '#sec-12.5', 'if statement')}}{{Spec2('ES5.1')}} 
{{SpecName('ES3', '#sec-12.5', 'if statement')}}{{Spec2('ES3')}} 
{{SpecName('ES1', '#sec-12.5', 'if statement')}}{{Spec2('ES1')}}Initiale Definition
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.statements.if_else")}}

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/statements/import/index.html b/files/de/web/javascript/reference/statements/import/index.html new file mode 100644 index 0000000000..07e1b12a7d --- /dev/null +++ b/files/de/web/javascript/reference/statements/import/index.html @@ -0,0 +1,151 @@ +--- +title: import +slug: Web/JavaScript/Reference/Statements/import +tags: + - ECMAScript 2015 + - JavaScript + - Module + - Statement +translation_of: Web/JavaScript/Reference/Statements/import +--- +
{{jsSidebar("Statements")}}
+ +

Das import Statement wird verwendet um Funktionen, Objekte und Primitives zu importieren die von einem externen Modul, einem anderen Script, etc. exportiert wurden.

+ +

{{noteStart}}Zur Zeit wird dieses Feature nicht von jedem Browser nativ unterstützt. Viele Transpiler implementieren es, wie beispielsweise der Traceur Compiler, Babel, Rollup oder Webpack.{{noteEnd}}

+ +

Syntax

+ +
import name from "module-name";
+import * as name from "module-name";
+import { member } from "module-name";
+import { member as alias } from "module-name";
+import { member1 , member2 } from "module-name";
+import { member1 , member2 as alias2 , [...] } from "module-name";
+import defaultMember, { member [ , [...] ] } from "module-name";
+import defaultMember, * as alias from "module-name";
+import defaultMember from "module-name";
+import "module-name";
+ +
+
name
+
Name des Objekts, das die importierten Daten empfängt
+
+ +
+
member, memberN
+
Namen der exportierten Member, die importiert werden
+
defaultMember
+
Name des exportierten Defaults, das importiert wird
+
alias, aliasN
+
Name des Objekts, das die importierte Property empfängt
+
module-name
+
Der Name des Moduls, das importiert wird. Also der Dateiname.
+
+ +

Beschreibung

+ +

Der Parameter name ist der Name des Objekts, das die exportierten Member empfängt. Die member-Parameter legen einzelne Einheiten fest, während der name Parameter alles importiert. name kann auch eine Funktion sein, wenn das Modul nur eine Einheit hat. Es folgen ein paar Beispiele für die Syntax:

+ +

Importieren der gesamten Inhalte des Moduls. Folgendes fügt myModule in den aktuellen Namensraum ein, mit allen exportierten Verbindungen von "my-module" bzw. "my-module.js".

+ +
import * as myModule from "my-module";
+
+ +

Einfügen einer einzelnen Einheit eines Moduls. Folgendes fügt myMember in den aktuellen Namensraum ein.

+ +
import {myMember} from "my-module";
+ +

Einfügen von mehreren Einheiten eines Moduls. Folgendes fügt foo und bar in den aktuellen Namensraum ein.

+ +
import {foo, bar} from "my-module";
+ +

Einfügen und Vergeben eines Alias. Folgendes fügt shortName in den aktuellen Namensraum ein.

+ +
import {reallyReallyLongModuleMemberName as shortName} from "my-module";
+ +

Einfügen und Vergeben von mehreren Aliasen

+ +
import {reallyReallyLongModuleMemberName as shortName, anotherLongModuleName as short} from "my-module";
+ +

Einfügen eines ganzen Moduls, ohne dessen Namensbindungen zu importieren.

+ +
import 'my-module';
+ +

Defaults importieren

+ +

Ein Standardexport ist möglich (egal, ob es sich um ein Objekt, eine Funktion, eine Klasse oder anderes handelt). Dementsprechend ist es auch möglich einen Standard-import zu benutzen, um diese Standards zu importieren.

+ +

Die einfachste Version importiert die Standards direkt:

+ +
import myModule from "my-module";
+ +

Man kann diese Syntax auch benutzen, um die oben genannten imports durchzufüren. In diesem Fall müssen die Standards aber wie folgt definiert werden:

+ +
import myDefault, * as myModule from "my-module";
+// myModule wird als namespace benutzt
+ +

oder

+ +
import myDefault, {foo, bar} from "my-module";
+// spezifische Imports nach Namen
+
+ +

Beispiele

+ +

Importieren einer weiteren Datei um AJAX JSON-Anfragen zu bearbeiten:

+ +
// --file.js--
+function getJSON(url, callback) {
+  let xhr = new XMLHttpRequest();
+  xhr.onload = function () {
+    callback(this.responseText)
+  };
+  xhr.open("GET", url, true);
+  xhr.send();
+}
+
+export function getUsefulContents(url, callback) {
+  getJSON(url, data => callback(JSON.parse(data)));
+}
+
+// --main.js--
+import { getUsefulContents } from "file";
+getUsefulContents("http://www.example.com", data => {
+  doSomethingUseful(data);
+});
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES2015', '#sec-imports', 'Imports')}}{{Spec2('ES2015')}}Initiale Definition
{{SpecName('ESDraft', '#sec-imports', 'Imports')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ +

{{Compat("javascript.statements.import")}}

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/statements/index.html b/files/de/web/javascript/reference/statements/index.html new file mode 100644 index 0000000000..a460b954d2 --- /dev/null +++ b/files/de/web/javascript/reference/statements/index.html @@ -0,0 +1,148 @@ +--- +title: Anweisungen und Deklarationen +slug: Web/JavaScript/Reference/Statements +tags: + - JavaScript + - Reference + - statements +translation_of: Web/JavaScript/Reference/Statements +--- +
{{jsSidebar("Statements")}}
+ +

JavaScript Anwendungen bestehen aus Anweisungen mit bestimmter Syntax. Eine Anweisung kann mehrere Zeilen umfassen und mehrere Anweisungen können in einer einzigen Zeile stehen, wenn sie mittels Semikolon voneinander getrennt sind.

+ +

Anweisungen und Deklarationen nach Kategorie

+ +

Für eine alphabetische Auflistung, siehe Sidebar auf der linken Seite.

+ +

Kontrollfluss

+ +
+
{{jsxref("Statements/block", "Block")}}
+
Anweisungsblöcke werden genutzt um ein oder mehrere Anweisungen zu gruppieren. Der Block wird von geschweiften Klammern umfasst.
+
{{jsxref("Statements/break", "break")}}
+
Beendet die aktuelle Schleifen-, Switch-, oder mit Label versehene Anweisung und das Programm wird hinter dieser fortgesetzt.
+
{{jsxref("Statements/continue", "continue")}}
+
Beendet den Durchlauf der aktuellen, bzw. der mittels Label angesprochenen Schleife und fährt mit dem nächsten Schleifendurchlauf fort.
+
{{jsxref("Statements/Empty", "Empty")}}
+
Man verwendet empty anstatt einer echten Anweisung, um keine Anweisung zu geben, an stellen an denen nach JavaScript-Syntax eine erwartet wird.
+
{{jsxref("Statements/if...else", "if...else")}}
+
Führt eine Anweisung aus wenn eine zuvor festgelegte Bedingung erfüllt (als true gewertet) wird. Ist die Bedingung false, kann eine andere Anweisung ausgeführt werden.
+
{{jsxref("Statements/switch", "switch")}}
+
Nach Auswertung eines Ausdrucks, wird anhand des Ergebnisses eine Fallunterscheidung durchgeführt und die entsprechende durch ein case-Label markierte Anweisung ausgeführt.
+
{{jsxref("Statements/throw", "throw")}}
+
Leitet das Auswerfen eines Fehlerausdrucks ein.
+
{{jsxref("Statements/try...catch", "try...catch")}}
+
Ein Anweisungsblock wird "ausprobiert" (try) und ein eventuell auftretender Fehler abgefangen (catch) und gegebenenfalls behandelt.
+
+ +

Deklarationen

+ +
+
{{jsxref("Statements/var", "var")}}
+
Deklariert eine Variable und initialisiert sie optional mit einem Wert.
+
{{experimental_inline()}} {{jsxref("Statements/let", "let")}}
+
Deklariert eine Blocklokale variable und initialisiert sie optional mit einem Wert.
+
{{experimental_inline()}} {{jsxref("Statements/const", "const")}}
+
Deklariert eine Konstante auf welche nur lesend zugegriffen werden kann.
+
+ +

Funktionen und Klassen

+ +
+
{{jsxref("Statements/function", "function")}}
+
Deklariert eine Funktion mit festgelegten Parametern.
+
{{experimental_inline()}} {{jsxref("Statements/function*", "function*")}}
+
Erzeugt Funktionen mit denen  Schleifen leichter zu schreiben sind.
+
{{jsxref("Statements/async_function", "async function")}}
+
Deklariert eine asynchrone Funktion mit festgelegten Parametern.
+
{{jsxref("Statements/return", "return")}}
+
Legt den Rückgabewert einer Funktion fest.
+
{{jsxref("Statements/class", "class")}}
+
Deklariert eine Klasse.
+
+ +

Schleifen

+ +
+
{{jsxref("Statements/do...while", "do...while")}}
+
Eine Schleife die solange ausgeführt wird bis die Bedingung false ist. Die Bedingung wird erst am Ende eines Durchgangs überprüft.
+
{{jsxref("Statements/for", "for")}}
+
Erstellt eine von drei unerforderlichen, zwischen Parenthesen geklammerten, durch Semikola getrennten Ausdrücken geregelte Schleife, gefolgt von einem Anweisungsblock innerhalb der Schleife.
+
{{deprecated_inline()}} {{non-standard_inline()}} {{jsxref("Statements/for_each...in", "for_each...in")}}
+
Iterates a specified variable over all values of object's properties. For each distinct property, a specified statement is executed.
+
{{jsxref("Statements/for...in", "for...in")}}
+
Stellt die aufzählbaren Eigenschaften eines Objektes in einer unbestimmten Reihenfolge zur Verfügung. Jede Eigenschaft kann durch Anweisungen in der Schleife ausgewertet werden.
+
{{experimental_inline()}} {{jsxref("Statements/for...of", "for...of")}}
+
Durchläuft die Werte eines iterationsfähigen Objektes, wie zum Beispiel eines arrays, eines Array-ähnlichen Objektes, oder eines Iterators oder Generators. Für jeden Wert des Objektes können Anweisungen ausgewertet werden.
+
 
+
{{jsxref("Statements/while", "while")}}
+
Erstellt eine Schleife, die solange durchlaufen wird, wie die Schleifenbedingung wahr ist. Die Schleifenbedingung wird am Anfang der Schleife (vor dem ersten Durchlauf des inneren Befehlsblocks) ausgewertet.
+
+ +

Weiteres

+ +
+
{{jsxref("Statements/debugger", "debugger")}}
+
Ruft irgendwelches verfügbare Fehlerentdeckungsvermögen auf. Steht keines zur Verfügung, hat dieser Befehl keine Wirkung.
+
{{experimental_inline()}} {{jsxref("Statements/export", "export")}}
+
Stellt eine Funktion zur Anwendung in anderen Modulen bereit. Dieser Ausdruck wird in dem Quellenmodul verwendet. Steht in Zusammenhang mit import auf der anderen Seite des Wechsels.
+
{{experimental_inline()}} {{jsxref("Statements/import", "import")}}
+
Importiert eine aus einem anderen Modul stammende Funktion, oder den gesamten Modul. Dieser Ausdruck wird in dem Entleihermodul verwendet, und arbeitet in Zusammenhang mit export.
+
{{jsxref("Statements/label", "label")}}
+
Hängt ein Etikett an eine Anweisung an. Auf dieses Etikett können  break (aussteigen) oder continue (fortsetzen) hinweisen, um den Kontrollfluss mit einer größeren Genauigkeit zu steuern.
+
+ +
+
{{deprecated_inline()}} {{jsxref("Statements/with", "with")}}
+
Extends the scope chain for a statement.
+
+ +

Specifications

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ES1', '#sec-12', 'Statements')}}{{Spec2('ES1')}}Initial Definition
{{SpecName('ES3', '#sec-12', 'Statements')}}{{Spec2('ES3')}} 
{{SpecName('ES5.1', '#sec-12', 'Statements')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-ecmascript-language-statements-and-declarations', 'ECMAScript Language: Statements and Declarations')}}{{Spec2('ES6')}}Neu: function*, let, for...of, yield, class
{{SpecName('ESDraft', '#sec-ecmascript-language-statements-and-declarations', 'ECMAScript Language: Statements and Declarations')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.statements")}}

+ +

See also

+ + diff --git a/files/de/web/javascript/reference/statements/label/index.html b/files/de/web/javascript/reference/statements/label/index.html new file mode 100644 index 0000000000..e9fcae4b50 --- /dev/null +++ b/files/de/web/javascript/reference/statements/label/index.html @@ -0,0 +1,205 @@ +--- +title: label +slug: Web/JavaScript/Reference/Statements/label +tags: + - JavaScript + - Statement +translation_of: Web/JavaScript/Reference/Statements/label +--- +
{{jsSidebar("Statements")}}
+ +

Ein Statement kann ein Label erhalten und zusammen mit dem {{jsxref("Statements/break", "break")}} oder {{jsxref("Statements/continue", "continue")}} Statements verwendet werden. Das Label ist das Präfix von einem Statement mit einer Bezeichner zum referenzieren.

+ +

Syntax

+ +
label : statement
+
+ +
+
label
+
Jeder JavaScript Bezeichner, welches kein reserviertes Wort ist.
+
statement
+
Statements. break kann mit jedem gelabelten Statement und continue kann mit Schleifen-Statements verwendet werden.
+
+ +

Beschreibung

+ +

Sie können ein Label verwenden, um eine Schleife zu identifizieren und danach einen break oder continue Statement verwenden, um anzugeben ob ein Programm die Schleife abbrechen oder weiter abarbeiten soll.

+ +
+

Hinweis: JavaScript hat KEINE goto Statements. Sie können die Labels nur mit break oder continue verwenden.

+
+ +

Beispiele

+ +

Verwenden eines continue mit Labels in for-Schleifen

+ +
var i, j;
+
+loop1:
+for (i = 0; i < 3; i++) {      // Das erste for Statement hat den Label "loop1"
+   loop2:
+   for (j = 0; j < 3; j++) {   // Das zweite for Statement hat den Label "loop2"
+      if (i === 1 && j === 1) {
+         continue loop1;
+      }
+      console.log("i = " + i + ", j = " + j);
+   }
+}
+
+// Ausgabe ist:
+//   "i = 0, j = 0"
+//   "i = 0, j = 1"
+//   "i = 0, j = 2"
+//   "i = 1, j = 0"
+//   "i = 2, j = 0"
+//   "i = 2, j = 1"
+//   "i = 2, j = 2"
+// Schau, wie "i = 1, j = 1" und"i = 1, j = 2" übersprungen werden
+
+ +

Verwenden eines continue Statements mit Label

+ +

Gegeben sei ein Array von Elementen und ein Array von Tests. Dieses Beispiel zählt die Anzahl von Elemente, die alle Tests bestehen.

+ +
var itemsPassed = 0;
+var i, j;
+
+top:
+for (i = 0; i < items.length; i++){
+  for (j = 0; j < tests.length; j++) {
+    if (!tests[j].pass(items[i])) {
+      continue top;
+    }
+  }
+
+  itemsPassed++;
+}
+ +

Verwenden eines breaks mit Labels für for-Schleifen

+ +
var i, j;
+
+loop1:
+for (i = 0; i < 3; i++) {      // Das erste for Statement hat den Label "loop1"
+   loop2:
+   for (j = 0; j < 3; j++) {   // Das zweite for Statement hat den Label "loop2"
+      if (i === 1 && j === 1) {
+         break loop1;
+      }
+      console.log("i = " + i + ", j = " + j);
+   }
+}
+
+// Ausgabe ist:
+//   "i = 0, j = 0"
+//   "i = 0, j = 1"
+//   "i = 0, j = 2"
+//   "i = 1, j = 0"
+// Schau den Unterschied zu dem vorigen continue Beispiel an
+ +

Verwenden eines Labels im break Statement

+ +

Gegeben ist ein Array von Items und ein Array von Tests. Dieses Beispiel bestimmt, ob alle Items alle Tests bestehen.

+ +
var allPass = true;
+var i, j;
+
+top:
+for (i = 0; items.length; i++)
+  for (j = 0; j < tests.length; i++)
+    if (!tests[j].pass(items[i])){
+      allPass = false;
+      break top;
+    }
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES3')}}{{Spec2('ES3')}}Initiale Definition. Implementiert in JavaScript 1.2
{{SpecName('ES5.1', '#sec-12.12', 'Labelled statement')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-labelled-statements', 'Labelled statement')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-labelled-statements', 'Labelled statement')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ +

{{CompatibilityTable}}

+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/statements/let/index.html b/files/de/web/javascript/reference/statements/let/index.html new file mode 100644 index 0000000000..5c68f5eb96 --- /dev/null +++ b/files/de/web/javascript/reference/statements/let/index.html @@ -0,0 +1,454 @@ +--- +title: let +slug: Web/JavaScript/Reference/Statements/let +tags: + - ECMAScript 2015 + - JavaScript + - Statement + - Variable declaration + - Variables + - let +translation_of: Web/JavaScript/Reference/Statements/let +--- +
+
+
{{jsSidebar("Statements")}}
+
+
+ +

Das Schlüsselwort let deklariert eine Variable im Gültigkeitsbereich des lokalen Blocks. Optional wird die Variable mit einem Wert initialisiert. let leitet sich vom englischen Verb "to let" ab, so daß man die Zeile "let x = 3" lesen kann als: "lassen wir x 3 sein" (let x be three), bekannt aus der Programmiersprache BASIC.

+ +

Syntax

+ +
let var1 [= wert1] [, var2 [= wert2]] [, ..., varN [= wertN]];
+ +

Parameter

+ +
+
var1, var2, …, varN
+
Variablenname. Jeder legale Bezeichner ist erlaubt.
+
wert1, wert2, …, wertN
+
Initialwerte der Variablen. Jeder legale Ausdruck ist erlaubt.
+
+ +

Beschreibung

+ +

let ermöglicht es Variablen zu deklarieren, deren Gültigkeitsbereich auf den Block, den Befehl oder den Ausdruck beschränkt ist, in dem sie deklariert sind. Der Unterschied zum var Schlüsselwort ist, dass der Gültigkeitsbereich auf Blöcke und nicht auf Funktionen bzw. Global beschränkt ist.

+ +

Regeln für Gültigkeitsbereiche

+ +

Variablen, die mit let deklariert werden, haben als Gültigkeitsbereich den Block in dem sie definiert wurden und alle weiteren Unterblöcke in denen sie nicht neu definiert werden. In dieser Hinsicht funktioniert let ähnlich wie var. Der Unterschied besteht darin, dass der Gültigkeitbereich bei var Deklarierten Variablen die umschließende Funktion ist:

+ +
function varTest() {
+  var x = 31;
+  if (true) {
+    var x = 71;  // gleiche Variable!
+    console.log(x);  // 71
+  }
+  console.log(x);  // 71
+}
+
+function letTest() {
+  let x = 31;
+  if (true) {
+    let x = 71;  // andere variable
+    console.log(x);  // 71
+  }
+  console.log(x);  // 31
+}
+ +

Auf der ersten Ebene von Programmen und Funktionen erzeugt let im globalen Objekt keine Property, var hingegen schon. Deshalb ist this.y im folgenden Beispiel undefined.

+ +
var x = 'global';
+let y = 'global';
+console.log(this.x); // "global"
+console.log(this.y); // undefined
+ +

Private Eigenschaften emulieren

+ +

Beim Einsatz von Konstruktoren können let-Deklarationen (alternativ zu Closures) genutzt werden, um private Eigenschaften in mehreren Methoden zu verwenden.

+ +
var Thing;
+
+{
+  let privateScope = new WeakMap();
+  let counter = 0;
+
+  Thing = function() {
+    this.someProperty = 'foo';
+
+    privateScope.set(this, {
+      hidden: ++counter,
+    });
+  };
+
+  Thing.prototype.showPublic = function() {
+    return this.someProperty;
+  };
+
+  Thing.prototype.showPrivate = function() {
+    return privateScope.get(this).hidden;
+  };
+}
+
+console.log(typeof privateScope);
+// "undefined"
+
+var thing = new Thing();
+
+console.log(thing);
+// Thing {someProperty: "foo"}
+
+thing.showPublic();
+// "foo"
+
+thing.showPrivate();
+// 1
+ +

Das selbe Kapselungsmuster mit Funktionsabschlüssen über lokale Variablen kann mit var erstellt werden, aber dieses benötigt dann funktionsweite Sichtbarkeit (üblicherweise eine IIFE im Modulmuster) anstatt nur blockweite Sichtbarkeit wie das obenstehende Beispiel.

+ +

Redeklarationen

+ +

Erneute Deklaration derselben Variable innerhalb desselben Gültigkeitsbereiches erzeugt einen Syntaxfehler ({{jsxref("SyntaxError")}}).

+ +
if (x) {
+  let foo;
+  let foo; // SyntaxError thrown.
+}
+ +

Der Körper einer switch-Anweisung ist nur ein einzelner Block, weshalb das folgende Beispiel einen Fehler verursacht.

+ +
let x = 1;
+switch(x) {
+  case 0:
+    let foo;
+    break;
+
+  case 1:
+    let foo; // SyntaxError for redeclaration.
+    break;
+}
+ +

Ist innerhalb einer case-Klausel jedoch ein innerer Block eingebettet, erzeugt dieser seinen eigenen lexikalischen Gültigkeitsbereich. Das folgende Beispiel erzeugt deshalb keine solchen Redeklarations-Fehler, wie sie im vorangegangenen Beispiel auftraten.

+ +
let x = 1;
+
+switch(x) {
+  case 0: {
+    let foo;
+    break;
+  }
+  case 1: {
+    let foo;
+    break;
+  }
+}
+ +

Sauberer Quelltext in inneren Funktionen

+ +

let macht den Programmcode manchmal leserlicher, wenn innere Funktionen eingesetzt werden.

+ +
var list = document.getElementById("list");
+
+for (var i = 1; i <= 5; i++) {
+  var item = document.createElement("li");
+  item.appendChild(document.createTextNode("Item " + i));
+
+  let j = i;
+  item.onclick = function (ev) {
+    console.log("Item " + j + " is clicked.");
+  };
+  list.appendChild(item);
+}
+
+ +

Dieses Beispiel funktioniert wie erwartet, weil alle fünf Instanzen der anonymen inneren Funktionen auf verschiedene Instanzen der Variable j zugreifen. Wenn stattdessen var verwendet wird oder in der inneren Funktion statt j zu deklarieren i benutzt wird, funktioniert dies nicht.

+ +

Zeitweilig tote Zonen und Fehler mit let

+ +

In ECMAScript 2015, werden Deklarationen mit let nicht an den Anfang des Blocks verschoben (hoist). Wird eine Variable vor der Deklaration in einem Block referenziert, führt dies zu einem ReferenceError, weil sich die Variable bei Eintritt in den Block bis zur Verarbeitung der Deklaration in einer "zeitweilig toten Zone" (temporal dead zone) befindet.

+ +
function do_something() {
+  console.log(foo); // ReferenceError
+  let foo = 2;
+}
+ +

Ein switch Block besteht nur aus einem Block, so dass Fehler wie im folgenden Beispiel auftreten können.

+ +
switch (x) {
+  case 0:
+    let foo;
+    break;
+
+  case 1:
+    let foo; // SyntaxError für erneute Deklaration
+    break;
+}
+ +

Ein weiteres Beispiel zeitweilig toter Zonen mit lexikalischen Gültigkeitsbereichen

+ +

Aufgrund seines lexikalischen Gültigkeitsbereiches wird der Bezeichner "foo" im untenstehenden Ausdruck (foo + 55) als das foo des if-Blocks interpretiert, nicht aber als die verdeckte Variable foo mit dem Wert 33.
+ Bei Auswertung des Ausdrucks existiert das foo des if-Blocks bereits im lexikalischen Gültigkeitsbereich, hat seine Initialisierung (welche Teil derselben Anweisung ist) aber noch nicht erreicht (und auch nicht abgeschlossen). Folglich ist es noch immer in seiner zeitweilig toten Zone.

+ +
function test(){
+   var foo = 33;
+   if (true) {
+      let foo = (foo + 55); // ReferenceError
+   }
+}
+test();
+ +

Dieses Phänomen kann in einer Situation wie der folgenden verwirren. Die Anweisung let n of n.a gehört bereits zum eigenen Gültigkeitsbereich des Blocks der for-Schleife. Der Bezeichner "n.a" wird als Eigenschaft 'a' des Objektes 'n' interpretiert, welches im ersten Teil derselben Anweisung deklariert wird ("let n"). Dieses befindet sich noch immer in seiner zeitweilig toten Zone, da bei Auswertung des Ausdrucks die Deklarationsanweisung als noch nicht erreicht und abgeschlossen gilt.

+ +
function go(n) {
+  // n here is defined!
+  console.log(n); // Object {a: [1,2,3]}
+
+  for (let n of n.a) { // ReferenceError
+    console.log(n);
+  }
+}
+
+go({a: [1, 2, 3]});
+ +

Nicht-standardisierte let Ausdrücke

+ +

let Blöcke

+ +
+

Die Unterstützung für let Blöcke wurde in Gecko 44 entfernt ({{bug(1167029)}}).

+
+ +

let Blöcke ermöglichen es Werte von Variablen in einem Block zu bearbeiten, ohne gleichnamige Variablen außerhalb des Blocks zu beeinflussen.

+ +

Syntax

+ +
let (var1 [= value1] [, var2 [= value2]] [, ..., varN [= valueN]]) block;
+ +

Beschreibung

+ +

Der let Block unterstützt lokales Scoping für Variablen. Es funktioniert mit dem Binden von keiner oder mehreren Variablen im lexikalischen Scope eines einzigen Blocks. Ansonsten ist es genau das selbe wie ein Block Statement. Zu beachten ist, dass Variablen, die innerhalb des let Blocks mit var definiert werden auch außerhalb des Blocks verfügbar sind, weil diese an die Funktion gebunden werden. Wenn ein let Block-Syntax benutzt wird, ist das let gefolgt von runden Klammern zwingend notwendig. Fehler beim benutzen führen zu einem Syntaxerror.

+ +

Beispiel

+ +
var x = 5;
+var y = 0;
+
+let (x = x+10, y = 12) {
+  console.log(x+y); // 27
+}
+
+console.log(x + y); // 5
+
+ +

Die Regeln für den Codeblock sind die gleichen wie für alle anderen Blöcke in JavaScript. Er hat seine Eigenen lokalen Variablen, die mit let deklariert sind.

+ +

Regeln für Gültigkeitsbereiche

+ +

Die Sichtbarkeit von mit let definierten Variablen ist der let Block selbst und auch jeder weitere innere Block in diesem Block, wenn die inneren Blöcke keine Variablen mit dem gleichen Namen definieren.

+ +

let Ausdrücke

+ +
+

Die Unterstützung für let Blöcke wurde in Gecko 41 entfernt ({{bug(1023609)}}).

+
+ +

Der let Ausdruck setzt die Sichtbarkeit einer Variablen auf nur einen Ausdruck.

+ +

Syntax

+ +
let (var1 [= value1] [, var2 [= value2]] [, ..., varN [= valueN]]) expression;
+ +

Beispiel

+ +

Man kann let benutzen, um Variablen nur für einen Ausdruck zu benutzen:

+ +
var a = 5;
+let(a = 6) console.log(a); // 6
+console.log(a); // 5
+ +

Regeln für Gültigkeitsbereiche

+ +

Gegeben ist folgender let Ausdruck:

+ +
let (decls) expr
+
+ +

Es wird ein impliziter Block um expr erstellt.

+ +

Name

+ +

Die Erklärung, daß let von englisch "to let sth. be sth." abgeleitet ist und so "let" als Name (reserviertes Wort) ausgewählt wurde, ist hier (englisch) zu finden.

+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES2015', '#sec-let-and-const-declarations', 'Let and Const Declarations')}}{{Spec2('ES2015')}}Initiale Definition. Definiert keine let Ausdrücke und let Blöcke.
{{SpecName('ESDraft', '#sec-let-and-const-declarations', 'Let and Const Declarations')}}{{Spec2('ESDraft')}}
+ +

Browserkompatibilität

+ +

{{CompatibilityTable}}

+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FeatureChromeEdgeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatChrome(41.0)}}12{{ CompatGeckoDesktop(44) }}1117{{CompatUnknown}}
Temporal dead zone{{CompatUnknown}}12{{ CompatGeckoDesktop(35) }}11{{CompatUnknown}}{{CompatUnknown}}
let expression {{non-standard_inline}}{{CompatNo}}{{CompatNo}}{{CompatNo}}{{CompatNo}}{{CompatNo}}{{CompatNo}}
let block {{non-standard_inline}}{{CompatNo}}{{CompatNo}}{{CompatNo}}{{CompatNo}}{{CompatNo}}{{CompatNo}}
Allowed in {{Glossary("sloppy mode")}}{{CompatChrome(49.0)}}{{CompatUnknown}}{{CompatGeckoDesktop(44)}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidAndroid WebviewFirefox Mobile (Gecko)IE MobileOpera MobileSafari MobileChrome for Android
Basic support{{CompatUnknown}}{{CompatChrome(41.0)}}{{ CompatGeckoMobile(44) }}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}{{CompatChrome(41.0)}}
Temporal dead zone{{CompatUnknown}}{{CompatUnknown}}{{ CompatGeckoMobile(35) }}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
let expression {{non-standard_inline}}{{CompatNo}}{{CompatUnknown}}{{CompatNo}}{{CompatNo}}{{CompatNo}}{{CompatNo}}{{CompatNo}}
let block {{non-standard_inline}}{{CompatNo}}{{CompatUnknown}}{{CompatNo}}{{CompatNo}}{{CompatNo}}{{CompatNo}}{{CompatNo}}
Allowed in {{Glossary("sloppy mode")}}{{CompatNo}}{{CompatChrome(49.0)}}{{CompatGeckoDesktop(44)}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}{{CompatChrome(49.0)}}
+
+ +

Firefox-spezifische Hinweise

+ + + +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/statements/return/index.html b/files/de/web/javascript/reference/statements/return/index.html new file mode 100644 index 0000000000..aff9552712 --- /dev/null +++ b/files/de/web/javascript/reference/statements/return/index.html @@ -0,0 +1,192 @@ +--- +title: return +slug: Web/JavaScript/Reference/Statements/return +tags: + - JavaScript + - Statement +translation_of: Web/JavaScript/Reference/Statements/return +--- +
{{jsSidebar("Statements")}}
+ +

Die return Anweisung beendet einen Funktionsaufruf und spezifiziert einen Wert, der von der Funktion zum Aufrufer zurückgegeben wird.

+ +

Syntax

+ +
return [[expression]];
+ +
+
expression
+
Ausdruck, der zurückgegeben wird. Wenn er weggelassen wird, wird undefined zurückgegeben.
+
+ +

Beschreibung

+ +

Wenn in einer Funktion eine return Anweisung aufgerufen wird, wird der Aufruf der Funktion gestoppt. Wenn ein Rückgabewert spezifiziert ist, wird dieser zu der aufrufenden Funktion zurückgegeben. Wenn kein Rückgabewert angegeben wird, wird stattdessen undefined zurückgegeben. Die folgenden return Anweisungen unterbrechen alle den Funktionsaufruf:

+ +
return;
+return true;
+return false;
+return x;
+return x + y / 3;
+
+ +

Automatische Semikolon-Einfügung

+ +

Die return Anweisung wird von der automatischen Semikolon-Einfügung (Automatic semicolon insertion, kurz ASI) beeinflusst. Es ist kein Zeilenumbruch zwischen dem return Schlüsselwort und dem nachfolgenden Ausdruck erlaubt.

+ +
return
+a + b;
+
+ +

wird durch ASI umgewandelt in:

+ +
return;
+a + b;
+
+ +

Die Konsole wird folgende Warnung ausgeben: "unreachable code after return statement".

+ +
Mit Gecko 40 {{geckoRelease(40)}}, wird eine Warnung in der Konsole ausgegeben, wenn Quelltext gefunden wird, der nach einer return Anweisung steht.
+ +

Beispiele

+ +

return

+ +

Die folgende Funktion gibt das Quadrat von x zurück. Dabei ist x eine Zahl.

+ +
function square(x) {
+   return x * x;
+}
+
+ +

Unterbrechen einer Funktion

+ +

Eine Funktion stoppt die Ausführung, wenn return aufgerufen wird.

+ +
function counter() {
+  for (var count = 1; ; count++) {  // infinite loop
+    console.log(count + "A"); // until 5
+      if (count === 5) {
+        return;
+      }
+      console.log(count + "B");  // until 4
+    }
+  console.log(count + "C");  // never appears
+}
+
+counter();
+
+// Output:
+// 1A
+// 1B
+// 2A
+// 2B
+// 3A
+// 3B
+// 4A
+// 4B
+// 5A
+
+ +

Funktion als Rückgabewert

+ +

Sie dazu auch im Artikel Closures.

+ +
function magic(x) {
+  return function calc(x) { return x * 42 };
+}
+
+var answer = magic();
+answer(1337); // 56154
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES1')}}{{Spec2('ES1')}}Initiale Definition.
{{SpecName('ES5.1', '#sec-12.9', 'Return statement')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-return-statement', 'Return statement')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-return-statement', 'Return statement')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ +

{{CompatibilityTable}}

+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/statements/switch/index.html b/files/de/web/javascript/reference/statements/switch/index.html new file mode 100644 index 0000000000..e53dc84fbe --- /dev/null +++ b/files/de/web/javascript/reference/statements/switch/index.html @@ -0,0 +1,289 @@ +--- +title: switch +slug: Web/JavaScript/Reference/Statements/switch +tags: + - JavaScript + - Reference + - Statement +translation_of: Web/JavaScript/Reference/Statements/switch +--- +
{{jsSidebar("Statements")}}
+ +

Die switch Anweisung wertet einen Ausdruck aus. Diese Auswertung wird mit einer case Klausel verglichen und (bei Übereinstimmung) die entsprechenden Anweisungen ausgeführt.

+ +

Syntax

+ +
switch (expression) {
+  case value1:
+    // Anweisungen werden ausgeführt,
+    // falls expression mit value1 übereinstimmt
+    [break;]
+  case value2:
+    // Anweisungen werden ausgeführt,
+    // falls expression mit value2 übereinstimmt
+    [break;]
+  ...
+  case valueN:
+    // Anweisungen werden ausgeführt,
+    // falls expression mit valueN übereinstimmt
+    [break;]
+  default:
+    // Anweisungen werden ausgeführt,
+    // falls keine der case-Klauseln mit expression übereinstimmt
+    [break;]
+}
+ +
+
expression
+
Ausdruck, der mit jeder case Klausel verglichen wird.
+
case valueN
+
Der Wert einer case Klausel wird mit expression verglichen.
+
+ +

Beschreibung

+ +

Ein switch Statement wertet als erstes den Ausdruck aus. Danach wird nach der ersten case Klausel gesucht, die zu dem gleichen Wert ausgewertet wird wie der erste Ausdruck im switch (mit striktem Vergleich, === ) und springt im Kontrollfluss zu der Klausel und führt die dort geschriebenen Statements aus. (Bei mehrfachen Übereinstimmungen springt das Programm zu der ersten gefundenen Klausel, auch wenn die gefunden Klausen nicht gleich sind.) Falls keine übereinstimmende case Klausel gefunden wird, sucht das Programm die optionale default Klausel und führt, wenn diese Klausel existiert, die Anweisungen in der Klausel aus. Wenn keine default Klausel vorhanden ist, wird das Programm nach dem switch Statement fortgesetzt. Konventionell ist die default Klausel die letzte Klausel, das muss aber nicht so sein.

+ +

Die optionale break Anweisung in jedem case Block weist das Programm an die switch Anweisung zu beenden. Das Programm macht dann mit der Anweisung weiter, die dem Ende der switch Anweisung folgt. Wird die break Anweisung weggelassen, dann macht das Programm linear weiter; es wird die nächste Anweisung ausgeführt.

+ +

Beispiele

+ +

Verwendung von switch

+ +

Betrachten wir das folgende Beispiel. Falls expr zu "Bananas" ausgewertet wird, dann springt das Programm zu der case Klausel "Bananas" und führt die entsprechenden Anweisungen aus. Die break Anweisung füht dazu, dass das Programm die switch Anweisung verlässt und mit der ersten Anweisung weitermacht, die dem Ende der switch Anweisung folgt.
+ Hätte man break weggelassen, dann hätte das Programm die Anweisungen der case Klausel "Cherries" ausgeführt.

+ +
switch (expr) {
+  case "Oranges":
+    console.log("Oranges are $0.59 a pound.");
+    break;
+  case "Apples":
+    console.log("Apples are $0.32 a pound.");
+    break;
+  case "Bananas":
+    console.log("Bananas are $0.48 a pound.");
+    break;
+  case "Cherries":
+    console.log("Cherries are $3.00 a pound.");
+    break;
+  case "Mangoes":
+  case "Papayas":
+    console.log("Mangoes and papayas are $2.79 a pound.");
+    break;
+  default:
+    console.log("Sorry, we are out of " + expr + ".");
+}
+
+console.log("Is there anything else you'd like?");
+
+ +

Was passiert, falls man eine break Anweisung weglässt?

+ +

Falls man eine break Anweisung vergisst, dann führt das Programm sowohl die übereinstimmende case Klausel als auch die darauf folgende case Klausel aus, unabhängig des Wertes der case Klausel.

+ +

Im Allgemeinen fährt das Programm linear fort bis es auf eine break Anweisung stößt. Falls keine break Anweisung vorhanden ist, dann werden alle Anweisungen bis zum Ende der switch Anweisung ausgeführt.

+ +
var foo = 0;
+switch (foo) {
+  case -1:
+    console.log('negative 1');
+    break;
+  case 0: // foo ist 0 - diese case-Klausel wird ausgeführt
+    console.log(0)
+    // HINWEIS: break Anweisung wurde hier weggelassen
+  case 1: // Da keine break Anweisung in 'case 0:'
+          // wird diese Klausel ebenfalls ausgeführt,
+          // obwohl der Wert nicht mit dem Ausdruck von
+          // switch übereinstimmt
+    console.log(1);
+    break; // das Programm verlässt die switch Anweisung.
+           // 'case 2:' wird nicht ausgeführt
+  case 2:
+    console.log(2);
+    break;
+  default:
+    console.log('default');
+}
+ +

Techniken für case Klauseln mit mehr als einem Kriterium

+ +

Die Quelle der erwähnten Methode kann hier aufgerufen werden (auf Englisch):
+ Switch statement multiple cases in JavaScript (Stack Overflow)

+ +

Mehrere case Klauseln mit einer einfachen Anweisung

+ +

Diese Technik macht es sich zum Vorteil, dass das Programm einfach bei der nächsten case Klausel weitermacht, wenn man die break Anweisung weglässt. Siehe Abschnitt "Was passiert, falls ich eine break Anweisung weglasse?"

+ +

Dieses Beispiel zeigt eine einfache Operation, die für alle entsprechenden case Klauseln ausgeführt wird ('Cow', 'Giraffe', 'Dog', 'Pig').

+ +
var Animal = 'Giraffe';
+switch (Animal) {
+  case 'Cow':
+  case 'Giraffe':
+  case 'Dog':
+  case 'Pig':
+    console.log('This animal will go on Noah\'s Ark.');
+    break;
+  case 'Dinosaur':
+  default:
+    console.log('This animal will not.');
+}
+ +

Mehrere case Klauseln mit mehreren Anweisungen

+ +

Dieses Beispiel zeigt wie mehrere Anweisungen verschiedener case Klauseln ausgeführt werden.
+ Die case Klauseln werden in geschriebener Reihenfolge ausgeführt, also unabhängig jeglicher Ordnung der Ausdrücke der case Klauseln.

+ +
var foo = 1;
+var output = 'Output: ';
+switch (foo) {
+  case 10:
+    output += 'So ';
+  case 1:
+    output += 'What ';
+    output += 'Is ';
+  case 2:
+    output += 'Your ';
+  case 3:
+    output += 'Name';
+  case 4:
+    output += '?';
+    console.log(output);
+    break;
+  case 5:
+    output += '!';
+    console.log(output);
+    break;
+  default:
+    console.log('Please pick a number from 0 to 6!');
+}
+ +

Mögliche Ergebnisse:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
WertAusgabe
10Output: So What Is Your Name?
1Output: What Is Your Name?
2Output: Your Name?
3Output: Name?
4Output: ?
5Output: !
Alle anderen WertePlease pick a number from 0 to 6!
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES3')}}{{Spec2('ES3')}}Initiale Definition.
+ Implementiert in JavaScript 1.2
{{SpecName('ES5.1', '#sec-12.11', 'switch statement')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-switch-statement', 'switch statement')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-switch-statement', 'switch statement')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ +

{{CompatibilityTable}}

+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Unterstützt{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Unterstützt{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/statements/throw/index.html b/files/de/web/javascript/reference/statements/throw/index.html new file mode 100644 index 0000000000..e022b01b54 --- /dev/null +++ b/files/de/web/javascript/reference/statements/throw/index.html @@ -0,0 +1,256 @@ +--- +title: throw +slug: Web/JavaScript/Reference/Statements/throw +tags: + - Ausnahmen + - JavaScript + - exceptions + - throw +translation_of: Web/JavaScript/Reference/Statements/throw +--- +
+
{{jsSidebar("Statements")}}
+
+ +

Zusammenfassung

+ +

Die throw Anweisung "wirft" eine benutzerdefinierte Exception (Ausnahme). Die Programmausführung der aktuellen Funktion bzw. des globalen Codes wird angehalten (Anweisungen nach throw werden dann nicht mehr ausgeführt), und die Programmausführung wird an den nächsthöheren catch Block in der Ausführungshierarchie übergeben. Falls in der gesamten Ausführungschierarchie kein catch Block definiert wurde, wird das Programm komplett angehalten.

+ +

Syntax

+ +
throw ausdruck;
+ +
+
ausdruck
+
Die zu werfende Ausnahme.
+
+ +

Beschreibung

+ +

Verwenden Sie die throw Anweisung, um eine Ausnahme zu werfen. Wenn Sie eine Ausnahme werfen,  bestimmt ausdruck den Typ der Ausnahme. Als Typ können Objekte (siehe Beispiel unten), als auch skalare Werte, wie Zeichenketten, Zahlen und boolesche Werte verwendet werden. Folgende Beispiele werfen jeweils eine Ausnahme:

+ +
throw "Fehler"; // erzeugt Ausnahme mit dem Wert "Fehler" (als String)
+throw 42;       // erzeugt Ausnahme mit dem Wert 42 (als Integer)
+throw true;     // erzeugt Ausnahme mit dem Wert TRUE (als boolescher Wert)
+ +

Beachten Sie auch, dass die throw-Anweisung von der automatic semicolon insertion (ASI) betroffen ist und daher kein Zeilenumbruch zwischen dem throw Schlüsselwort und dem Ausdruck zulässig ist.

+ +

Beispiele

+ +

Objekt als Ausnahme werfen

+ +

Als Ausnahme kann auch ein Objekt geworfen werden. Auf Eigenschaften des geworfenen Objektes kann dann im catch Block zugegriffen werden. Im folgenden Beispiel wird in der Funktion divide versucht Zahl n durch m zu dividieren. Falls m die Zahl 0 ist, wird ein Objekt (als Funktion) vom Typ DivisionException erzeugt und als Ausnahme geworfen, da Teilen durch 0 nicht möglich ist.

+ +
function DivisionException(message) {
+  this.message = message;
+  this.name = "DivisionException";
+}
+
+function divide(n, m) {
+  if (m == 0) {
+    throw new DivisionException("Teilen durch Null nicht möglich");
+  }
+
+  return n / m;
+}
+
+try {
+  // versuche 5 / 2 zu teilen
+  alert(divide(5, 2));  // 2.5
+
+  // versuche 5 / 0 zu teilen
+  var ausgabe = divide(5, 0);
+
+  // diese Zeile wird nie erreicht
+  alert(ausgabe);
+}
+catch (e) {
+  // "DivisionException: Teilen durch Null nicht möglich"
+  alert(e.name + ": " + e.message);
+}
+
+ +

Ausnahmen werden in der Regel als Funktionen definiert und mit dem new Schlüsselwort als Objekte instantiiert, da es in JavaScript kein direktes Konzept von Konstruktoren gibt, wie in anderen Programmiersprachen. Die Funktion dient dann selbst als Konstruktor. Falls in der catch Anweisung keine Unterscheidung der Ausnahme benötigt wird (z. B. mit Hilfe des instanceof Operators - siehe Beispiel unten), kann das Objekt direkt übergeben werden. Aus praktischen Gründen kann im geworfenen Objekt die Methode toString definiert werden, um es später einfacher ausgeben zu können:

+ +
try {
+  throw {
+    name: "MyException",
+    message: "Something is wrong",
+    toString: function() {
+      return this.name + ": " + this.message;
+    }
+  };
+}
+catch (e) {
+  alert(e); // "MyException: Something is wrong"
+}
+ +

Unterschiedliche Ausnahmen werfen und unterscheiden

+ +

Es ist möglich unterschiedliche Ausnahmen in einem try Block zu werfen und im dazugehörigen catch Block abzufangen. Dies erlaubt ein gezielteres Abfangen von Ausnahmen.

+ +
function myException(message) {
+  this.message = message;
+};
+
+function myOtherException(text) {
+  this.text = text;
+};
+
+var exceptions = [
+  "Don't panic! Where is my towel?",
+  42,
+  new myException("So long, and thanks for all the fish!"),
+  new myOtherException("Deep Thought is still watching..."),
+];
+
+for (var i=0; i < exceptions.length; i++) {
+  try {
+    throw exceptions[i];
+  }
+  catch (e) {
+    if (typeof e === "string") {
+      alert('String exception: ' + e);
+    }
+    else if (typeof e === "number") {
+      alert('Number exception: ' + e);
+    }
+    else if (typeof e === "object")
+    {
+      if (e instanceof myException) {
+        alert("myException: " + e.message);
+      }
+      else if (e instanceof myOtherException) {
+        alert("myOtherException: " + e.text);
+      }
+    }
+  }
+}
+
+ +

Abgefangene Ausnahmen neu werfen

+ +

Die throw Anweisung kann auch innerhalb eines catch Blocks verwendet werden, um eine neue oder die bereits abgefangene Ausnahme erneut zu werfen. Alle Anweisungen folgenden Anweisungen im catch Block werden wieder nicht ausgeführt und die neu geworfene Ausnahme wird an die nächsthöheren catch Block übergeben. Somit können "Ebenen" entworfen werden, die jeweils nur bestimmte Ausnahmen behandeln.

+ +

Folgender Quelltext zeigt "myException: This is an exception!" an, da der innere catch Block nicht für Ausnahmen vom Typ myOtherException zuständig ist und daher diese eine Ebene nach oben weiterleitet.

+ +
function myException(message) {
+  this.message = message;
+};
+
+function myOtherException(text) {
+  this.text = text;
+};
+
+try {
+  try {
+    throw new myOtherException("This is an exception!");
+  }
+  catch (e) {
+    if (e instanceof myException) {
+      alert("myException: " + e.message);  // wird nicht ausgeführt
+    } else {
+      throw e;  // eine Ebene nach oben weiterleiten
+    }
+  }
+}
+catch (e) {
+  alert("myException: " + e.text);
+}
+
+ +
+

Falls eine Exception durch keinen catch Block abgefangen wird, wird die Ausnahme in der JavaScript Konsole ausgegeben und die Programmausführung komplett unterbrochen.

+
+ +

 

+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES3')}}{{Spec2('ES3')}}Initiale Definition. Implementiert in JavaScript 1.4
{{SpecName('ES5.1', '#sec-12.13', 'throw statement')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-throw-statement', 'throw statement')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-throw-statement', 'throw statement')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ +

{{CompatibilityTable}}

+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/statements/try...catch/index.html b/files/de/web/javascript/reference/statements/try...catch/index.html new file mode 100644 index 0000000000..d86c0c8120 --- /dev/null +++ b/files/de/web/javascript/reference/statements/try...catch/index.html @@ -0,0 +1,382 @@ +--- +title: try...catch +slug: Web/JavaScript/Reference/Statements/try...catch +translation_of: Web/JavaScript/Reference/Statements/try...catch +--- +
{{jsSidebar("Statements")}}
+ +

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

+ +

Syntax

+ +
try {
+   try_Anweisungen
+}
+[catch (Fehler_var_1 if Bedingung_1) { // nicht Standard
+   catch_Anweisungen
+}]
+...
+[catch (Fehler_var_2) {
+   catch_Anweisungen_2
+}]
+[finally {
+   finally_Anweisungen
+}]
+
+ +
+
try_Anweisungen
+
Die auszuführenden Anweisungen.
+
+ +
+
catch_Anweisungen_1, catch_Anweisungen_2
+
Anweisungen, die ausgeführt werden, wenn bei den try-Anweisungen ein Fehler auftritt.
+
+ +
+
Fehler_var_1, Fehler_var_2
+
Ein Bezeichner der das Fehlerobjekt des zugehörigen catch-Abschnitts enthält.
+
+ +
+
Bedingung_1
+
Ein Bedingungsausdruck.
+
+ +
+
finally_Anweisungen
+
Die Schlussanweisungen werden nach den try-Anweisungen ausgeführt. Die Anweisungen werden immer ausgeführt, auch wenn ein Fehler ausgegeben wurde. 
+
+ +

Beschreibung

+ +

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

+ +
    +
  1. try...catch
    2. +
  2. try...finally
    3. +
  3. try...catch...finally
    4. +
+ +

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

+ +

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

+ +

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

+ +

Mit der try-Anweisungen können auch JavaScript-Fehler bearbeitet werden. Mehr zur Fehlerbearbeitung in JavaScript steht im JavaScript Guide.

+ +

Unbhängiger catch-Abschnitt

+ +

Wenn mit einem einzelnen, ungebundenen catch-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 catch-Abschnitt über.

+ +
try {
+   throw "myException"; // Fehler wird ausgelöst
+}
+catch (e) {
+   // Anweisungen für jeden Fehler
+   logMyErrors(e); // Fehler-Objekt an die Error-Funktion geben
+}
+
+ +

Im catch-Block wird ein Bezeichner festgelegt (e im Beispiel), die den Wert enthält, der durch die throw-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.

+ +

Abhängige catch-Abschnitte

+ +

{{non-standard_header}}

+ +

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 try-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 catch-Abschnitt. Wenn dem Fehler kein catch-Abschnitt entspricht und ein unabhäniger catch-Abschnitt vorhanden ist, geht die Kontrolle an ihn.

+ +

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.

+ +

Zu Erinnerung: diese Funktionalität ist kein Teil der ECMAScript-Spezifikation.

+ +
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
+}
+
+ +

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

+ +
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
+    }
+}
+
+ +

Der Fehler-Bezeichner

+ +

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

+ +

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

+ +

Der finally-Abschnitt

+ +

Zum Abschluss-Abschnitt (finally) gehören die Anweisungen, die nach dem try- und dem catch-Block ausgeführt werden, noch bevor irgenwelche Anweisugnen nach den try-/catch-/finally-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.

+ +

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 finally-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. 

+ +

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

+ +

Wenn unabhängig vom Erfolg des try...catch-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.

+ +

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 finally-Abschnitt diese Datei bevor das Script stoppt. Der Code im Abschnitt wird auch bei Returns aus try- oder catch-Blöcken ausgeführt.

+ +
openMyFile()
+try {
+   // bindet eine Ressource
+   writeMyFile(theData);
+}
+finally {
+   closeMyFile(); // Ressource immer wieder frei geben
+}
+
+ +

Examples

+ +

Verschachtelte try-Blöcke

+ +

Zuerst einmal untersuchen wir diese Beispiele:

+ +
try {
+  try {
+    throw new Error("oops");
+  }
+  finally {
+    console.log("finally");
+  }
+}
+catch (ex) {
+  console.error("outer", ex.message);
+}
+
+// Output:
+// "finally"
+// "outer" "oops"
+
+ +

Wenn wir den Fehler im inneren try-Block mit einem catch-Abschnitt bearbeiten

+ +
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"
+
+ +

Und jetzt wird der Fehler im catch-Abschnitt noch einmal produziert:

+ +
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"
+
+ +

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

+ +

Rückgaben aus einem finally-Block

+ +

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

+ +
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"
+
+ +

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

+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES3')}}{{Spec2('ES3')}}Erste Definition. Implementiert in JavaScript 1.4
{{SpecName('ES5.1', '#sec-12.14', 'try statement')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-try-statement', 'try statement')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-try-statement', 'try statement')}}{{Spec2('ESDraft')}} +

Fällt nicht unter den aktuellen ECMA-262-Standard: Mehrfache catch-Abschnitte und abhängige Abschnitte (SpiderMonkey extension, JavaScript 1.5).

+
+ +

Browser-Verträglichkeit

+ +

{{CompatibilityTable}}

+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + +
FunktionChromeFirefox (Gecko)Internet ExplorerOperaSafari
Grundunter-stützung{{CompatVersionUnknown}}{{CompatGeckoDesktop("6")}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
Abhängige Abschnitte
+ (Non-Standard)		{{CompatNo}}{{CompatVersionUnknown}}{{CompatNo}}{{CompatNo}}{{CompatNo}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FunktionAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
+ + + + + + + +
Grundunter-stützung 
+ 		{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+ + + + + + + +
Abhängige Abschnitte
+ (Non-Standard)		 
+ 		{{CompatNo}}{{CompatNo}}{{CompatVersionUnknown}}{{CompatNo}}{{CompatNo}}{{CompatNo}}
+
+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/statements/var/index.html b/files/de/web/javascript/reference/statements/var/index.html new file mode 100644 index 0000000000..bd11e7efd0 --- /dev/null +++ b/files/de/web/javascript/reference/statements/var/index.html @@ -0,0 +1,243 @@ +--- +title: var +slug: Web/JavaScript/Reference/Statements/var +tags: + - JavaScript + - Statement +translation_of: Web/JavaScript/Reference/Statements/var +--- +
+
{{jsSidebar("Statements")}}
+
+ +

Mit dem Schlüsselwort var deklariert man Variablen und initialisiert diese optional.

+ +

Syntax

+ +
var varname1 [= wert1] [, varname2 [= wert2] ... [, varnameN [=wertN]]];
+ +
+
varnameN
+
Variablenname. Jeder legale Bezeichner ist erlaubt.
+
+ +
+
wertN
+
Initialwert der Variablen. Jeder legale Ausdruck ist erlaubt.
+
+ +

Beschreibung

+ +

Variablendeklarationen werden immer ausgeführt bevor Programmcode ausgeführt wird, egal wo sie im Programmcode vorkommen. Der Gültigkeitsbereich einer Variablendeklaration mit var ist der aktuelle Kontext. Dieser ist der Kontext der umschließenden Funktion oder für Deklarationen außerhalb von Funktionen der globale Kontext.

+ +

Das Zuweisen eines Wertes zu einer nicht deklarierten Variablen führt immer dazu, dass eine globale Variable erstellt wird (die Variable wird auf dem globalen Objekt erstellt). Die Unterschiede zwischen deklarierten und nicht deklarierten Variablen sind:

+ +

1. Deklarierte Variablen sind immer in dem Kontext gültig, in dem sie deklariert wurden. Undeklarierte Variablen sind immer globale Variablen.

+ +
function x() {
+  y = 1;   // erzeugt einen ReferenceError im strict mode
+  var z = 2;
+}
+
+x();
+
+console.log(y); // gibt "1" aus
+console.log(z); // erzeugt einen ReferenceError: z ist nur in x verfügbar.
+
+ +

2. Deklarierte Variablen werden erstellt bevor Programmcode ausgeführt wird. Undeklarierte Variablen existieren nicht bevor die Zuweisung ausgeführt wurde.

+ +
console.log(a);                // erzeugt einen ReferenceError.
+console.log('still going...'); // wird nie ausgeführt
+ +
var a;
+console.log(a);                // gibt "undefined" oder "" aus, abhängig vom Browser.
+console.log('still going...'); // gibt "still going..." aus.
+ +

3. Deklarierte Variablen sind nicht konfigurierbare Attribute des ausführenden Kontexts (Funktion oder globaler Kontext). Undeklarierte Variablen sind konfigurierbar (z. B. sie können gelöscht werden).

+ +
var a = 1;
+b = 2;
+
+delete this.a; // erzeugt einen TypeError im strict mode. Andernfalls wird es ignoriert
+delete this.b;
+
+console.log(a, b); // erzeugt einen ReferenceError.
+// Das 'b' Attribut wurde gelöscht und existiert nicht länger.
+ +

Wegen dieser drei Unterschiede führt das Fehlen der Variablendeklaration zu unerwarteten Ergebnissen. Deswegen ist es empfohlen immer Variablen zu deklarieren, unabhängig davon, ob sie sich in einer Funktion oder im globalen Kontext befinden. Zudem wird im ECMAScript 5 {{jsxref("Functions_and_function_scope/Strict_mode", "strict mode")}} ein Fehler erzeugt, wenn einer nicht deklarierten Variablen ein Wert zugewiesen wird.

+ +

var hoisting

+ +

Weil Variablendeklarationen (und Deklarationen im Allgemeinen) vor dem Ausführen von Programmcode geschieht, ist das Deklarieren einer Variable irgendwo im Programmcode das gleiche, als würde sie am Anfang deklariert werden. Das bedeutet, dass eine Variable benutzt werden kann bevor sie im Programmcode deklariert wurde. Dieser Umstand wird "hoisting" genannt und wird möglich, weil die Deklaration der Variablen an den Anfang der Funktion oder den Anfang des globalen Programmcodes verschoben wird.

+ +
bla = 2
+var bla;
+// ...
+
+// Implizit wird Folgendes gemacht:
+
+var bla;
+bla = 2;
+
+ +

Aus diesem Grund ist es empfohlen Variablen immer am Anfang ihres Gültigkeitsbereiches zu definieren. Dadurch wird klarer, welche Variable vom lokalen Gültigkeitsbereich stammt und welche über die Gültigkeitsbereichekette gefunden werden muss.

+ +

Beispiele

+ +

Deklarieren und initialisieren zweier Variablen

+ +
var a = 0, b = 0;
+ +

Zuweisung zweier Variablen mit einer Zeichenkette

+ +
var a = "A";
+var b = a;
+
+// Das gleiche wie:
+
+var a, b = a = "A";
+
+ +

Sei aufmerksam mit der Reihenfolge:

+ +
var x = y, y = 'A';
+console.log(x + y); // undefinedA
+
+ +

x und y werden deklariert bevor Programmcode ausgeführt wird. Die Zuweisungen geschehen später. Wenn "x = y" ausgeführt wird, existiert y schon mit dem Wert undefined, weshalb kein Fehler erzeugt wird. x wird der Wert undefined zugewiesen. Dann wird y der Wert 'A' zugewiesen. Nach dieser einen Zeile ist demnach das Resultat x === undefined && y === 'A'.

+ +

Initialisierung mehrerer Variablen

+ +
var x = 0;
+
+function f(){
+  var x = y = 1; // x ist lokal Deklariert. y nicht!
+}
+f();
+
+console.log(x, y); // 0, 1
+// Nicht im strict-mode:
+// x ist die erwartetete globale Variable und nicht die lokale.
+// y wird global angelegt und der Wert 1 zugewiesen! 
+ +

Implizierte globale Variablen und Gültigkeitsbereiche äußerer Funktionen

+ +

Variablen die scheinbar global verfügbar sind, stammen manchmal aus dem Gültigkeitsbereich einer äußeren Funktion:

+ +
var x = 0;  // x ist global deklariert und mit dem Wert 0 initialisiert.
+
+console.log(typeof z); // undefined, solange z noch nicht existiert
+
+function a() { // Wenn a aufgerufen wird,
+  var y = 2;   // wird y in der Funktion a deklariert und der Wert 2 wird zugewiesen
+
+  console.log(x, y);   // 0 2
+
+  function b() {       // Wenn b aufgerufen wird,
+    x = 3;  // wird 3 der globalen Variablen x zugewiesen
+            // (es wird keine neue globale Variable erstellt)
+    y = 4;  // wird 4 der Variablen y (äußere Funktion) zugewiesen
+            // (es wird keine neue globale Variable erstellt)
+    z = 5;  // wird eine globale Variable z erstellt und der Wert 5 wird zugewiesen.
+  }         // (erzeugt einen ReferenceError im strict mode.)
+
+  b();     // Aufruf von b (erstellt z als globale Variable)
+  console.log(x, y, z);  // 3 4 5
+}
+
+a();                   // Aufruf von a und somit auch von b
+console.log(x, z);     // 3 5
+console.log(typeof y); // undefined weil y local in der Funktion a deklariert wurde.
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES1')}}{{Spec2('ES1')}}Initiale Definition.
+ Implementiert in JavaScript 1.0
{{SpecName('ES5.1', '#sec-12.2', 'var statement')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-variable-statement', 'variable statement')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-variable-statement', 'variable statement')}}{{Spec2('ESDraft')}}
+ +

Browserkompatibilität

+ +

{{CompatibilityTable}}

+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/statements/while/index.html b/files/de/web/javascript/reference/statements/while/index.html new file mode 100644 index 0000000000..d391fdbab1 --- /dev/null +++ b/files/de/web/javascript/reference/statements/while/index.html @@ -0,0 +1,102 @@ +--- +title: while +slug: Web/JavaScript/Reference/Statements/while +tags: + - JavaScript + - Statement +translation_of: Web/JavaScript/Reference/Statements/while +--- +
{{jsSidebar("Anweisungen")}}
+ +

Die while-Anweisung (Engl. statement) beschreibt eine Schleife, die solange durchlaufen wird wie die Schleifenbedingung wahr (Engl. true) ergibt. Die Schleifenbedingung (Engl. condition) wird am Anfang der Schleife ausgewertet.

+ +
{{EmbedInteractiveExample("pages/js/statement-while.html")}}
+ + + +

Syntax

+ +
while (condition) {
+  statement
+}
+ +
+
condition
+
Die Schleifenbedinung wird zu Anfang eines Schleifendurchlaufs ausgewertet. Ergibt die Auswertung wahr (true), dann wird der Schleifenkörper durchlaufen (statement wird ausgeführt). Ist die Bedingung falsch (false), dann fährt das Program mit der ersten Anweisung nach der while Schleife fort.
+
statement
+
Eine optionale Anweisung wird ausgeführt solange die Bedingung wahr (true) ist. Mehrere Anweisungen müssen in einer block Anweisung ({ ... }) gruppiert werden.
+
+ Bemerkung: Ein break-Statement kann eingesetzt werden, um die Schleife vorzeitig zu beenden, bevor die Bedingung auf false wechselt.
+
+ +

Beispiele

+ +

Die folgende while Schleife wird so oft durchlaufen wie n kleiner drei ist.

+ +
var n = 0;
+var x = 0;
+
+while (n < 3) {
+  n++;
+  x += n;
+}
+ +

In jedem Durchlauf wird n inkrementiert und zu x addiert. Die Schleifendurchläufe können wie folgt beschrieben werden:

+ + + +

Nach dem dritten Durchlauf ist die Schleifenbedingung nicht mehr wahr, und die Schleife wird beendet.

+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusBemerkung
{{SpecName('ESDraft', '#sec-while-statement', 'while statement')}}{{Spec2('ESDraft')}} 
{{SpecName('ES6', '#sec-while-statement', 'while statement')}}{{Spec2('ES6')}} 
{{SpecName('ES5.1', '#sec-12.6.2', 'while statement')}}{{Spec2('ES5.1')}} 
{{SpecName('ES3', '#sec-12.6.2', 'while statement')}}{{Spec2('ES3')}} 
{{SpecName('ES1', '#sec-12.6.1', 'while statement')}}{{Spec2('ES1')}}Initiale Definition
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.statements.while")}}

+ +

Siehe auch

+ + -- cgit v1.2.3-54-g00ecf