diff options
Diffstat (limited to 'files/de/web/javascript/reference/operators')
11 files changed, 12 insertions, 1705 deletions
diff --git a/files/de/web/javascript/reference/operators/bitwise_operatoren/index.html b/files/de/web/javascript/reference/operators/bitwise_operatoren/index.html deleted file mode 100644 index 598d43df68..0000000000 --- a/files/de/web/javascript/reference/operators/bitwise_operatoren/index.html +++ /dev/null @@ -1,575 +0,0 @@ ---- -title: Bitweise Operatoren -slug: Web/JavaScript/Reference/Operators/Bitwise_Operatoren -tags: - - JavaScript - - Operator - - Reference -translation_of: Web/JavaScript/Reference/Operators -translation_of_original: Web/JavaScript/Reference/Operators/Bitwise_Operators ---- -<div>{{jsSidebar("Operators")}}</div> - -<p><strong>Bitweise Operatoren </strong>werden auf Sequenzen aus 32 bit (Nullen und Einsen) angewandt im Gegensatz zu Operatoren, die mit Dezimal-, Hexadezimal- oder Oktalzahlen (<code><a href="/de/docs/Web/JavaScript/Reference/Global_Objects/Number">numbers</a></code>) arbeiten. Beispielsweise hat die Dezimalzahl neun die binäre Darstellung 1001. Auch wenn Bitweise Operatoren mit Binärdarstellungen arbeiten, sind deren Ausgabewerte Javascript Standardzahlenwerte.</p> - -<div>{{EmbedInteractiveExample("pages/js/expressions-bitwiseoperators.html")}}</div> - - - -<p>Die folgende Tabelle fasst Javascripts Bitweise Operatoren zusammen:</p> - -<table class="standard-table"> - <tbody> - <tr> - <th>Operator</th> - <th>Einsatz</th> - <th>Beschreibung</th> - </tr> - <tr> - <td><a href="#Bitwise_AND">Bitweises UND</a></td> - <td><code>a & b</code></td> - <td>Gibt <code>1</code> in jeder Bit Position zurück, an welcher beide Operanden <code>1</code> sind.</td> - </tr> - <tr> - <td><a href="#Bitwise_OR">Bitweises ODER</a></td> - <td><code>a | b</code></td> - <td>Gibt <code>1</code> in jeder Bit Position zurück, an welcher einer oder beide Operanden <code>1</code> sind.</td> - </tr> - <tr> - <td><a href="#Bitwise_XOR">Bitweises XOR</a></td> - <td><code>a ^ b</code></td> - <td>Gibt <code>1</code> in jeder Bit Position zurück, an welcher einer aber nicht beide Operanden <code>1</code> sind.</td> - </tr> - <tr> - <td><a href="#Bitwise_NOT">Bitweise Negation</a></td> - <td><code>~ a</code></td> - <td>Invertiert die Bits des Operanden</td> - </tr> - <tr> - <td><a href="#Left_shift">Linksverschiebung</a></td> - <td><code>a << b</code></td> - <td>Verschiebt <code>a</code> in binärer Repräsentation <code>b</code> (< 32) Bits nach links, von Rechts werden Nullen hereingeschoben.</td> - </tr> - <tr> - <td><a href="#Right_shift">Vorzeichen propagierende Rechtsverschiebung</a></td> - <td><code>a >> b</code></td> - <td>Verschiebt <code>a</code> in binärer Repräsentation <code>b</code> (< 32) Bits nach rechts, herausgeschobene Bits werden verworfen.</td> - </tr> - <tr> - <td><a href="#Unsigned_right_shift">Null füllende Rechtsverschiebung</a></td> - <td><code>a >>> b</code></td> - <td>Verschiebt <code>a</code> in binärer Repräsentation <code>b</code> (< 32) Bits nach rechts, herausgeschobene Bits werden verworfen und Nullen werden von links hereingeschoben.</td> - </tr> - </tbody> -</table> - -<h2 id="Vorzeichenbehaftete_32-Bit_Integer">Vorzeichenbehaftete 32-Bit Integer</h2> - -<p>Die Operanden aller Bitweisen Operationen werden in vorzeichenbehaftete 32-Bit Integer im Zweierkomplementformat konvertiert. Zweierkomplementformat bedeutet, dass das Gegenstück einer negative Zahl alle Bits invertiert (Bitweise Negation einer Zahl oder auch Einerkomplement einer Zahl) plus eins ist. Zum Beispiel die codierte Integer 314:</p> - -<pre class="brush: js">00000000000000000000000100111010 -</pre> - -<p>Im Folgenden ist <code>~314</code> codiert, d. h. das Einerkomplement von <code>314</code>:</p> - -<pre class="brush: js">11111111111111111111111011000101 -</pre> - -<p>Anschließend wird <code>-314</code> codiert, d. h. das Zweierkomplement <code>314</code>:</p> - -<pre class="brush: js">11111111111111111111111011000110 -</pre> - -<p>Das Zweierkomplement garantiert, dass das Bit ganz links 0 ist, wenn die Zahl Positiv ist und 1 ist, wenn die Zahl negativ ist. Dieses wird das Vorzeichenbit genannt.</p> - -<p>Die Zahl <code>0</code> ist ein Integer, der komplett aus 0 Bits besteht.</p> - -<pre class="brush: js">0 (base 10) = 00000000000000000000000000000000 (base 2) -</pre> - -<p>Die Zahl <code>-1</code> ist ein Integer der komplett aus 1 Bits besteht.</p> - -<pre class="brush: js">-1 (base 10) = 11111111111111111111111111111111 (base 2) -</pre> - -<p>Die Zahl <code>-2147483648</code> (hexadezimale Repräsentation: <code>-0x80000000</code>) ist der Integer, welcher komplett aus 0 Bits besteht, außer dem ersten Bit (linkes Bit).</p> - -<pre class="brush: js">-2147483648 (base 10) = 10000000000000000000000000000000 (base 2) -</pre> - -<p>Die Zahl <code>2147483647</code> (hexadezimale Repräsentation: <code>-0x7fffffff</code>) ist der Integer, welcher komplett aus 1 Bits besteht, außer dem ersten Bit (linkes Bit).</p> - -<pre class="brush: js">2147483647 (base 10) = 01111111111111111111111111111111 (base 2) -</pre> - -<p>Die Zahlen <code>-2147483648</code> und <code>2147483647</code> sind die minimalen und Maximalen Integers, die mit 32-Bit vorzeichenbehafteten Zahlen repräsentiert werden können.</p> - -<h2 id="Bitweise_logische_Operatoren">Bitweise logische Operatoren</h2> - -<p>Konzeptionell arbeiten die bitweisen logischen Operatoren wie folgt:</p> - -<ul> - <li>Die Operanden werden in 32-Bit Integer konvertiert und als Serie von Bits (null und eins) ausgedrückt. Bei Zahlen mit mehr als 32 Bits, werden die höchstwertigen Bits verworfen. Zum Beispiel wird der folgende Integer mit mehr als 32 Bits zu einem 32 Bit Integer konvertiert:: - <pre class="brush: js">Vorher: 11100110111110100000000000000110000000000001 -Nachher: 10100000000000000110000000000001</pre> - </li> - <li>Jedes Bit im ersten Operanden wird mit dem korrespondierenden Bit im zweiten Operanden gepaart: erstes Bit zu erstem, zweites Bit zu zweitem Bit, und so weiter.</li> - <li>Der Operator wird auf jedem Bitpaar angewendet und das Ergebnis wird Bitweise konstruiert.</li> -</ul> - -<h3 id="(Bitweises_UND)"><a name="Bitwise_AND">& (Bitweises UND)</a></h3> - -<p>Führt die UND Operation auf jedem Bitpaar durch. <code>a</code> UND <code>b</code> ergibt <code>1</code>, wenn beide <code>a</code> und <code>b</code> <code>1</code> sind. Die Wahrheitstabelle für den UND Operator ist:</p> - -<table class="standard-table"> - <tbody> - <tr> - <td class="header">a</td> - <td class="header">b</td> - <td class="header">a UND b</td> - </tr> - <tr> - <td>0</td> - <td>0</td> - <td>0</td> - </tr> - <tr> - <td>0</td> - <td>1</td> - <td>0</td> - </tr> - <tr> - <td>1</td> - <td>0</td> - <td>0</td> - </tr> - <tr> - <td>1</td> - <td>1</td> - <td>1</td> - </tr> - </tbody> -</table> - -<pre class="brush: js">. 9 (Basis 10) = 00000000000000000000000000001001 (Basis 2) - 14 (Basis 10) = 00000000000000000000000000001110 (Basis 2) - -------------------------------- -14 & 9 (Basis 10) = 00000000000000000000000000001000 (Basis 2) = 8 (Basis 10) -</pre> - -<p>Bitweises verUNDen jeder Zahl <code>x</code> mit <code>0</code> ergibt <code>0</code>. Bitweises verUNDen jeder Zahl <code>x</code> mit <code>-1</code> ergibt <code>x</code>.</p> - -<h3 id="(Bitweises_ODER)"><a name="Bitwise_OR">| (Bitweises ODER)</a></h3> - -<p>Führt die ODER Operation auf jedem Bitpaar durch. <code>a</code> ODER <code>b</code> ergibt <code>1</code>, wenn einer, <code>a</code> oder <code>b</code>, <code>1</code> sind. Die Wahrheitstabelle für den ODER Operator ist:</p> - -<table class="standard-table"> - <tbody> - <tr> - <td class="header">a</td> - <td class="header">b</td> - <td class="header">a ODER b</td> - </tr> - <tr> - <td>0</td> - <td>0</td> - <td>0</td> - </tr> - <tr> - <td>0</td> - <td>1</td> - <td>1</td> - </tr> - <tr> - <td>1</td> - <td>0</td> - <td>1</td> - </tr> - <tr> - <td>1</td> - <td>1</td> - <td>1</td> - </tr> - </tbody> -</table> - -<pre class="brush: js">. 9 (Basis 10) = 00000000000000000000000000001001 (Basis 2) - 14 (Basis 10) = 00000000000000000000000000001110 (Basis 2) - -------------------------------- -14 | 9 (Basis 10) = 00000000000000000000000000001111 (Basis 2) = 15 (Basis 10) -</pre> - -<p>Bitweises verODERn jeder Zahl <code>x</code> mit <code>0</code> ergibt <code>x</code>. Bitweises verODERn jeder Zahl <code>x</code> mit <code>-1</code> ergibt <code>-1</code>.</p> - -<h3 id="(Bitweises_XOR)"><a name="Bitwise_XOR">^ (Bitweises XOR)</a></h3> - -<p>Führt die XOR Operation auf jedem Bitpaar durch. <code>a</code> XOR <code>b</code> ergibt <code>1</code>, wenn sich <code>a</code> und <code>b</code>, unterscheiden. Die Wahrheitstabelle für den XOR Operator ist:</p> - -<table class="standard-table"> - <tbody> - <tr> - <td class="header">a</td> - <td class="header">b</td> - <td class="header">a XOR b</td> - </tr> - <tr> - <td>0</td> - <td>0</td> - <td>0</td> - </tr> - <tr> - <td>0</td> - <td>1</td> - <td>1</td> - </tr> - <tr> - <td>1</td> - <td>0</td> - <td>1</td> - </tr> - <tr> - <td>1</td> - <td>1</td> - <td>0</td> - </tr> - </tbody> -</table> - -<pre class="brush: js">. 9 (Basis 10) = 00000000000000000000000000001001 (Basis 2) - 14 (Basis 10) = 00000000000000000000000000001110 (Basis 2) - -------------------------------- -14 ^ 9 (Basis 10) = 00000000000000000000000000000111 (Basis 2) = 7 (Basis 10) -</pre> - -<p>Bitweises verXORn jeder Zahl <code>x</code> mit <code>0</code> ergibt <code>x</code>. Bitweises verXORn jeder Zahl <code>x</code> mit <code>-1</code> ergibt <code>~x</code>.</p> - -<h3 id="(Bitweise_Negation)"><a name="Bitwise_NOT">~ (Bitweise Negation)</a></h3> - -<p>Führt die Negationsoperation auf jedem Bit durch. NICHT <code>a</code> ergibt ergibt den invertierten Wert (d. h. das Einerkomplement) von <code>a</code>. Die Wahrheitstabelle für den Negationsoperator ist:</p> - -<table class="standard-table"> - <tbody> - <tr> - <td class="header">a</td> - <td class="header">NICHT a</td> - </tr> - <tr> - <td>0</td> - <td>1</td> - </tr> - <tr> - <td>1</td> - <td>0</td> - </tr> - </tbody> -</table> - -<pre class="brush: js"> 9 (Basis 10) = 00000000000000000000000000001001 (Basis 2) - -------------------------------- -~9 (Basis 10) = 11111111111111111111111111110110 (Basis 2) = -10 (Basis 10) -</pre> - -<p>Bitweises Negieren jeder Zahl <code>x</code> ergibt <code>-(x + 1)</code>. Zum Beispiel ergibt <code>~-5</code> <code>4</code>.</p> - -<p>Beispiel mit <code>indexOf</code>:</p> - -<pre class="brush: js">var str = 'rawr'; -var searchFor = 'a'; - -// Das ist eine alternativer Weg um if (-1*str.indexOf('a') <= 0) zu tippen -if (~str.indexOf(searchFor)) { - // searchFor is in the string -} else { - // searchFor is not in the string -} - -// Hier die Werte, die von (~str.indexOf(searchFor)) zurück gegeben werden -// r == -1 -// a == -2 -// w == -3 -</pre> - -<h2 id="Bitweise_Verschiebeoperatoren">Bitweise Verschiebeoperatoren</h2> - -<p>Die bitweisen Verschiebeoperatoren (shift Operatoren) haben zwei Operanden: Der erste ist der Anteil, der verschoben werden soll und der zweite ist die Anzahl der Positionen, um die der erste Operand verschoben werden soll. Die Richtung der Verschiebung wird durch den eingesetzten Operator festgelegt.</p> - -<p>Verschiebeoperatoren konvertieren ihre Operanden in 32-Bit Integers in Bit-Endian Reihenfolge und geben als Resultat den gleichen Typ des linken Operanden zurück. Der rechte Operand sollte kleiner als 32 sein, aber wenn das nicht so ist, werden nur die kleinsten fünf Bits verwendet.</p> - -<h3 id="<<_(Linksverschiebung)"><a name="Left_shift"><< (Linksverschiebung)</a></h3> - -<p>Dieser Operator verschiebt den ersten Operand um die spezifizierte Anzahl von Bits nach links. Überflüssige Bits, die nach links verschoben wurden, werden verworfen. Von rechts wird mit 0-Bits aufgefüllt.</p> - -<p>Zum Beispiel ergibt <code>9 << 2</code> <code>36</code>:</p> - -<pre class="brush: js">. 9 (Basis 10): 00000000000000000000000000001001 (Basis 2) - -------------------------------- -9 << 2 (Basis 10): 00000000000000000000000000100100 (Basis 2) = 36 (Basis 10) -</pre> - -<p>Bitweises Verschieben jeder Zahl <code>x</code> nach links mit <code>y</code> Bits ergibt <code>x * 2 ** y</code>.</p> - -<h3 id=">>_(Vorzeichen_propagierende_Rechtsverschiebung)"><a name="Right_shift">>> (Vorzeichen propagierende Rechtsverschiebung)</a></h3> - -<p>Dieser Operator verschiebt den ersten Operand um die spezifizierte Anzahl von Bits nach rechts. Überflüssige Bits, die nach rechts verschoben wurden, werden verworfen. Kopien des linken Bits (Vorzeichenbits) werden von links hereingeschoben. Weil das neue Vorzeichenbit immer das selbe wie das alte Vorzeichenbit ist, ändert sich das linke Bit nicht. Daher kommt der Name "Vorzeichen propagierend" her.</p> - -<p>Zum Beispiel ergibt <code>9 >> 2</code> <code>2</code>:</p> - -<pre class="brush: js">. 9 (base 10): 00000000000000000000000000001001 (base 2) - -------------------------------- -9 >> 2 (base 10): 00000000000000000000000000000010 (base 2) = 2 (base 10) -</pre> - -<p>Likewise, <code>-9 >> 2</code> yields <code>-3</code>, because the sign is preserved:</p> - -<pre class="brush: js">. -9 (Basis 10): 11111111111111111111111111110111 (Basis 2) - -------------------------------- --9 >> 2 (Basis 10): 11111111111111111111111111111101 (Basis 2) = -3 (Basis 10) -</pre> - -<h3 id=">>>_(Null_füllende_Rechtsverschiebung)"><a name="Unsigned_right_shift">>>> (Null füllende Rechtsverschiebung)</a></h3> - -<p>Dieser Operator verschiebt den ersten Operand um die spezifizierte Anzahl von Bits nach rechts. Überflüssige Bits, die nach rechts verschoben wurden, werden verworfen. Von link wird mit 0-Bits aufgefüllt. Das Vorzeichenbit wird 0, so dass das Ergebnis nie negativ ist.</p> - -<p>Für nicht negative Zahlen ist das Ergebnis bei der Null füllenden Rechtsverschiebung und bei der Vorzeichen propagierenden Rechtsverschiebung das selbe. Zum Beispiel ergibt <code>9 >>> 2</code> <code>2</code>, das selbe wie <code>9 >> 2</code>:</p> - -<pre class="brush: js">. 9 (Basis 10): 00000000000000000000000000001001 (Basis 2) - -------------------------------- -9 >>> 2 (Basis 10): 00000000000000000000000000000010 (Basis 2) = 2 (Basis 10) -</pre> - -<p>Jedoch ist das nicht der Fall für negative Zahlen. Zum Beispiel ergibt <code>-9 >>> 2</code> <code>1073741821</code>, was sich unterschiedet von <code>-9 >> 2</code> (was <code>-3</code> ergibt):</p> - -<pre class="brush: js">. -9 (Basis 10): 11111111111111111111111111110111 (Basis 2) - -------------------------------- --9 >>> 2 (Basis 10): 00111111111111111111111111111101 (Basis 2) = 1073741821 (Basis 10) -</pre> - -<h2 id="Beispiele">Beispiele</h2> - -<h3 id="Flags_und_Bitmasken">Flags und Bitmasken</h3> - -<p>Die bitweisen logischen Operatoren werden häufig eingesetzt, um Sequenzen von Flags zu erstellen, zu manipulieren und zu lesen, welche wie binäre Variablen sind. Variablen können statt dieser Sequenzen genutzt werden, aber binäre Flags verbrauchen weniger Speicher (um den Faktor 32).</p> - -<p>Angenommen es gibt 4 Flags:</p> - -<ul> - <li>Flag A: Man hat ein Ameisenproblem</li> - <li>Flag B: Man besitzt eine Fledermaus</li> - <li>Flag C: Man besitzt eine Katze</li> - <li>Flag D: Man besitzt eine Ente</li> -</ul> - -<p>Diese Flags sind durch eine Sequenz von Bits repräsentiert: DCBA. Wenn ein Flag gesetzt wird, hat es den Wert 1. Wenn ein Flag geleert wird, hat es den Wert 0. Angenommen eine Variable <code>flags</code> hat den binären Wert 0101:</p> - -<pre class="brush: js">var flags = 5; // binär 0101 -</pre> - -<p>Dieser Wert zeigt an:</p> - -<ul> - <li>Flag A ist true (man hat ein Ameisenproblem);</li> - <li>Flag B ist false (man hat keine Fledermaus);</li> - <li>Flag C ist true (man hat eine Katze);</li> - <li>Flag D ist false (man hat keine Ente);</li> -</ul> - -<p>Weil Bitweise Operatoren mit 32-Bit arbeiten, ist 0101 eigentlich 00000000000000000000000000000101, aber die führenden nullen können vernachlässigt werden, weil sie keine Informationen enthalten.</p> - -<p>Eine Bitmaske ist eine Sequenz von Bits, die Flags manipulieren und/oder lesen kann. Typisch ist es, dass eine "primitive" Bitmaske für jedes Flag definiert ist:</p> - -<pre class="brush: js">var FLAG_A = 1; // 0001 -var FLAG_B = 2; // 0010 -var FLAG_C = 4; // 0100 -var FLAG_D = 8; // 1000 -</pre> - -<p>Neue Bitmasken können erstellt werden, indem bitweise logische Operatoren auf den primitiven Bitmasken angewendet werden. Zum Beispiel kann die Bitmaske 1011 mit VerODERn von FLAG_A, FLAG_B und FLAG_D erstellt werden:</p> - -<pre class="brush: js">var mask = FLAG_A | FLAG_B | FLAG_D; // 0001 | 0010 | 1000 => 1011 -</pre> - -<p>Individuelle Flagwerte können durch das VerUNDen mit einer Bitmaske extrahiert werden, wobei jedes Bit mit dem Wert eins das korrespondierende Flag extrahiert. Die Bitmaske wirft nicht relevante Flags heraus, indem Nullen verUNDet werden (daher der Begriff "Bitmaske"). Zum Beispiel kann die Bitmaske 0100 genutzt werden, um zu sehen, ob Flag C gesetzt ist:</p> - -<pre class="brush: js">// Wenn man eine Katze besitzt -if (flags & FLAG_C) { // 0101 & 0100 => 0100 => true - // tu irgendetwas -} -</pre> - -<p>Eine Bitmaske mit mehreren gesetzten Flags funktioniert wie ein "entweder/oder". Zum Beispiel sind die beiden folgenden Ansätze äquivalent:</p> - -<pre class="brush: js">// wenn man eine Fledermaus besitzt oder eine Katze besitzt -// (0101 & 0010) || (0101 & 0100) => 0000 || 0100 => true -if ((flags & FLAG_B) || (flags & FLAG_C)) { - // do stuff -} -</pre> - -<pre class="brush: js">// wenn man eine Fledermaus oder eine Katze besitzt -var mask = FLAG_B | FLAG_C; // 0010 | 0100 => 0110 -if (flags & mask) { // 0101 & 0110 => 0100 => true - // do stuff -} -</pre> - -<p>Flags können mit VerODERung mit einer Bitmaske gesetzt werden, wobei jedes Bit in der Bitmaske mit dem Wert 1 wird das korrespondierende Flag setzen, wenn es noch nicht gesetzt ist. Zum Beispiel kann die Bitmaske 1100 benutzt werden, um die Flags C und D zu setze:</p> - -<pre class="brush: js">// ja, man besitzt eine Katze und eine Ente -var mask = FLAG_C | FLAG_D; // 0100 | 1000 => 1100 -flags |= mask; // 0101 | 1100 => 1101 -</pre> - -<p>Flags können mit VerUNDung mit einer Bitmaske geleert werden, wobei jedes Bit in der Bitmaske mit dem Wert 0 wird das korrespondierende Flag geleert, wenn es noch nicht geleert ist. Die Bitmaske dafür kann mit Negation primitiver Bitmasken erstellt werden Zum Beispiel kann die Bitmaske 1010 benutzt werden, um die Flags A und C zu leeren:</p> - -<pre class="brush: js">// no, we don't have an ant problem or own a cat -var mask = ~(FLAG_A | FLAG_C); // ~0101 => 1010 -flags &= mask; // 1101 & 1010 => 1000 -</pre> - -<p>The mask could also have been created with <code>~FLAG_A & ~FLAG_C</code> (De Morgan's law):</p> - -<pre class="brush: js">// nein, mat hat kein Problem mit Ameisen und man besitzt keine Katze -var mask = ~FLAG_A & ~FLAG_C; -flags &= mask; // 1101 & 1010 => 1000 -</pre> - -<p>Flags können mit VerXORung mit einer Bitmaske umgeschaltet werden, wobei jedes Bit in der Bitmaske mit dem Wert 1 wird das korrespondierende Flag umschaltet. Zum Beispiel kann die Bitmaske 0110 benutzt werden, um die Flags B und C umzuschalten:</p> - -<pre class="brush: js">// wenn man keine Fledermaus besitzt und und jetzt eine bekommt -// and wenn man eine hat und die Fledermaus verabschiedet -// das gleiche für eine Katze -var mask = FLAG_B | FLAG_C; -flags = flags ^ mask; // 1100 ^ 0110 => 1010 -</pre> - -<p>Alle Flags können mit dem Negationsoperator umgedreht werden:</p> - -<pre class="brush: js">// entering parallel universe... -flags = ~flags; // ~1010 => 0101 -</pre> - -<h3 id="Konvertierungsbeispiele">Konvertierungsbeispiele</h3> - -<p>Konvertierung eines binär <code><a href="/de/docs/Web/JavaScript/Reference/Global_Objects/String" title="/de/docs/JavaScript/Reference/Global_Objects/String">String</a></code> zu einer dezimal <code><a href="/de/docs/Web/JavaScript/Reference/Global_Objects/Number" title="/de/docs/JavaScript/Reference/Global_Objects/Number">Number</a></code>:</p> - -<pre class="brush: js">var sBinString = '1011'; -var nMyNumber = parseInt(sBinString, 2); -alert(nMyNumber); // prints 11, i.e. 1011 -</pre> - -<p>Konvertierung einer dezimal <code><a href="/de/docs/Web/JavaScript/Reference/Global_Objects/Number" title="/de/docs/JavaScript/Reference/Global_Objects/Number">Number</a></code> zu einem binär <code><a href="/de/docs/Web/JavaScript/Reference/Global_Objects/String" title="/de/docs/JavaScript/Reference/Global_Objects/String">String</a></code>:</p> - -<pre class="brush: js">var nMyNumber = 11; -var sBinString = nMyNumber.toString(2); -alert(sBinString); // prints 1011, i.e. 11 -</pre> - -<h3 id="Bitmaskenerstellung_automatisieren">Bitmaskenerstellung automatisieren</h3> - -<p>Man kann, wie folgt, mehrere Masken von einer Menge von <code><a href="/de/docs/Web/JavaScript/Reference/Global_Objects/Boolean" title="/de/docs/JavaScript/Reference/Global_Objects/Boolean">Boolean</a></code> Werten erstellen:</p> - -<pre class="brush: js">function createMask() { - var nMask = 0, nFlag = 0, nLen = arguments.length > 32 ? 32 : arguments.length; - for (nFlag; nFlag < nLen; nMask |= arguments[nFlag] << nFlag++); - return nMask; -} -var mask1 = createMask(true, true, false, true); // 11, i.e.: 1011 -var mask2 = createMask(false, false, true); // 4, i.e.: 0100 -var mask3 = createMask(true); // 1, i.e.: 0001 -// etc. - -alert(mask1); // prints 11, i.e.: 1011 -</pre> - -<h3 id="Umgedrehter_Algorithmus_Ein_Array_von_Booleanen_von_einer_Bitmaske">Umgedrehter Algorithmus: Ein Array von Booleanen von einer Bitmaske</h3> - -<p>Wenn man ein <code><a href="/de/docs/Web/JavaScript/Reference/Global_Objects/Array" title="/de/docs/JavaScript/Reference/Global_Objects/Array">Array</a></code> mit <code><a href="/de/docs/Web/JavaScript/Reference/Global_Objects/Boolean" title="/de/docs/JavaScript/Reference/Global_Objects/Boolean">Boolean</a></code> Werten von einer Bitmaske haben möchte, kann man folgenden Code benutzen:</p> - -<pre class="brush: js">function arrayFromMask(nMask) { - // nMask must be between -2147483648 and 2147483647 - if (nMask > 0x7fffffff || nMask < -0x80000000) { - throw new TypeError('arrayFromMask - out of range'); - } - for (var nShifted = nMask, aFromMask = []; nShifted; - aFromMask.push(Boolean(nShifted & 1)), nShifted >>>= 1); - return aFromMask; -} - -var array1 = arrayFromMask(11); -var array2 = arrayFromMask(4); -var array3 = arrayFromMask(1); - -alert('[' + array1.join(', ') + ']'); -// prints "[true, true, false, true]", i.e.: 11, i.e.: 1011 -</pre> - -<p>Man kann beide Algorithmen gleichzeitig testen:</p> - -<pre class="brush: js">var nTest = 19; // our custom mask -var nResult = createMask.apply(this, arrayFromMask(nTest)); - -alert(nResult); // 19 -</pre> - -<p>Nur aus didaktischen Gründen (weil dort die <code><a href="/de/docs/Web/JavaScript/Reference/Global_Objects/Number/toString" title="/de/docs/JavaScript/Reference/Global_Objects/Number/toString">Number.toString(2)</a></code> Methode ist), zeigen wir, wie es möglich ist den <code>arrayFromMask</code> Algorithmus zu verändern, um einen <code><a href="/de/docs/Web/JavaScript/Reference/Global_Objects/String" title="/de/docs/JavaScript/Reference/Global_Objects/String">String</a></code> mit der Binärrepräsentation der <code><a href="/de/docs/Web/JavaScript/Reference/Global_Objects/Number" title="/de/docs/JavaScript/Reference/Global_Objects/Number">Number</a></code> statt eines <code><a href="/de/docs/Web/JavaScript/Reference/Global_Objects/Array" title="/de/docs/JavaScript/Reference/Global_Objects/Array">Array</a></code>s von <code><a href="/de/docs/Web/JavaScript/Reference/Global_Objects/Boolean" title="/de/docs/JavaScript/Reference/Global_Objects/Boolean">Boolean</a></code>en:</p> - -<pre class="brush: js">function createBinaryString(nMask) { - // nMask must be between -2147483648 and 2147483647 - for (var nFlag = 0, nShifted = nMask, sMask = ''; nFlag < 32; - nFlag++, sMask += String(nShifted >>> 31), nShifted <<= 1); - return sMask; -} - -var string1 = createBinaryString(11); -var string2 = createBinaryString(4); -var string3 = createBinaryString(1); - -alert(string1); -// prints 00000000000000000000000000001011, i.e. 11 -</pre> - -<h2 id="Spezifikationen">Spezifikationen</h2> - -<table class="standard-table"> - <tbody> - <tr> - <th scope="col">Spezifikation</th> - <th scope="col">Status</th> - <th scope="col">Kommentar</th> - </tr> - <tr> - <td>{{SpecName('ES1')}}</td> - <td>{{Spec2('ES1')}}</td> - <td>Initiale Definition.</td> - </tr> - <tr> - <td>{{SpecName('ES5.1', '#sec-11.7')}}</td> - <td>{{Spec2('ES5.1')}}</td> - <td>Definiert in verschiedenen Abschnitten der Spezifikation: <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.4.8">Bitwise NOT operator</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.7">Bitwise shift operators</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.10">Binary bitwise operators</a></td> - </tr> - <tr> - <td>{{SpecName('ES6', '#sec-bitwise-shift-operators')}}</td> - <td>{{Spec2('ES6')}}</td> - <td>Definiert in verschiedenen Abschnitten der Spezifikation: <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-bitwise-not-operator">Bitwise NOT operator</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-bitwise-shift-operators">Bitwise shift operators</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-binary-bitwise-operators">Binary bitwise operators</a></td> - </tr> - <tr> - <td>{{SpecName('ESDraft', '#sec-bitwise-shift-operators')}}</td> - <td>{{Spec2('ESDraft')}}</td> - <td>Definiert in verschiedenen Abschnitten der Spezifikation: <a href="http://tc39.github.io/ecma262/#sec-bitwise-not-operator">Bitwise NOT operator</a>, <a href="http://tc39.github.io/ecma262/#sec-bitwise-shift-operators">Bitwise shift operators</a>, <a href="http://tc39.github.io/ecma262/#sec-binary-bitwise-operators">Binary bitwise operators</a></td> - </tr> - </tbody> -</table> - -<h2 id="Browserkompatibilität">Browserkompatibilität</h2> - -<div class="hidden"> -<p>The compatibility table on this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> -</div> - -<p>{{Compat("javascript.operators.bitwise")}}</p> - -<h2 id="Siehe_auch">Siehe auch</h2> - -<ul> - <li><a href="/de/docs/Web/JavaScript/Reference/Operators/Logical_Operators">Logische Operatoren</a></li> -</ul> diff --git a/files/de/web/javascript/reference/operators/dekrement/index.html b/files/de/web/javascript/reference/operators/decrement/index.html index 16b185b35c..c425107a8d 100644 --- a/files/de/web/javascript/reference/operators/dekrement/index.html +++ b/files/de/web/javascript/reference/operators/decrement/index.html @@ -1,11 +1,12 @@ --- title: Dekrement (--) -slug: Web/JavaScript/Reference/Operators/Dekrement +slug: Web/JavaScript/Reference/Operators/Decrement tags: - Dekrement - Dekrement-Operator - Dekrementieren translation_of: Web/JavaScript/Reference/Operators/Decrement +original_slug: Web/JavaScript/Reference/Operators/Dekrement --- <div>{{jsSidebar("Operators")}}</div> diff --git a/files/de/web/javascript/reference/operators/destrukturierende_zuweisung/index.html b/files/de/web/javascript/reference/operators/destructuring_assignment/index.html index 1ece290e90..82a5d0ab5a 100644 --- a/files/de/web/javascript/reference/operators/destrukturierende_zuweisung/index.html +++ b/files/de/web/javascript/reference/operators/destructuring_assignment/index.html @@ -1,12 +1,13 @@ --- title: Destrukturierende Zuweisung -slug: Web/JavaScript/Reference/Operators/Destrukturierende_Zuweisung +slug: Web/JavaScript/Reference/Operators/Destructuring_assignment tags: - Destructuring - ECMAScript 2015 - JavaScript - Operator translation_of: Web/JavaScript/Reference/Operators/Destructuring_assignment +original_slug: Web/JavaScript/Reference/Operators/Destrukturierende_Zuweisung --- <div>{{jsSidebar("Operators")}}</div> diff --git a/files/de/web/javascript/reference/operators/inkrement/index.html b/files/de/web/javascript/reference/operators/increment/index.html index 74289b92e1..f47037708f 100644 --- a/files/de/web/javascript/reference/operators/inkrement/index.html +++ b/files/de/web/javascript/reference/operators/increment/index.html @@ -1,11 +1,12 @@ --- title: Inkrement (++) -slug: Web/JavaScript/Reference/Operators/Inkrement +slug: Web/JavaScript/Reference/Operators/Increment tags: - Inkrement - Inkrement-Operator - Inkrementieren translation_of: Web/JavaScript/Reference/Operators/Increment +original_slug: Web/JavaScript/Reference/Operators/Inkrement --- <div>{{jsSidebar("Operators")}}</div> diff --git a/files/de/web/javascript/reference/operators/logische_operatoren/index.html b/files/de/web/javascript/reference/operators/logische_operatoren/index.html deleted file mode 100644 index 6a20e85b79..0000000000 --- a/files/de/web/javascript/reference/operators/logische_operatoren/index.html +++ /dev/null @@ -1,247 +0,0 @@ ---- -title: Logische Operatoren -slug: Web/JavaScript/Reference/Operators/Logische_Operatoren -tags: - - JavaScript - - Logic - - Logical Operators - - Not - - Operator - - Reference - - and - - or -translation_of: Web/JavaScript/Reference/Operators -translation_of_original: Web/JavaScript/Reference/Operators/Logical_Operators ---- -<div>{{jsSidebar("Operators")}}</div> - -<p>Logische Operatoren werden typischerweise im Zusammenhang mit {{jsxref("Boolean")}} (logischen) Werten verwendet. Die Operatoren <code>&&</code> (Logisches UND) und <code>||</code> (Logisches ODER) geben dabei den Wert von einem der Operanden zurück. Sind die Operanden mit nicht-booleschen Werten belegt, geben diese Operatoren entsprechend nicht-boolesche Werte zurück.</p> - -<div>{{EmbedInteractiveExample("pages/js/expressions-logicaloperator.html")}}</div> - - - -<h2 id="Beschreibung">Beschreibung</h2> - -<p>In der folgenden Tabelle werden die logischen Operatoren erläutert.</p> - -<table class="fullwidth-table"> - <tbody> - <tr> - <th>Operator</th> - <th>Verwendung</th> - <th>Beschreibung</th> - </tr> - <tr> - <td>Logisches UND (<code>&&</code>)</td> - <td><code><em>ausdruck1</em> && <em>ausdruck2</em></code></td> - <td>Gibt <code>ausdruck1</code> zurück, wenn er zu <code>false</code> konvertiert werden kann; anderfalls wird <code>ausdruck2</code> zurückgegeben. Sind beide Operanden <code>true</code>, gibt <code>&&</code> <code>true</code> zurück, Andernfalls <code>false</code>.</td> - </tr> - <tr> - <td>Logisches ODER (<code>||</code>)</td> - <td><code><em>ausdruck1</em> || <em>ausdruck2</em></code></td> - <td>Gibt <code>ausdruck1</code> zurück, wenn er zu <code>true</code> konvertiert werden kann; andernfalls wird <code>ausdruck2</code> zurückgegeben. Ist einer der Operanden <code>true</code>, gibt <code>||</code> <code>true</code> zurück.</td> - </tr> - <tr> - <td>Logisches NICHT (<code>!</code>)</td> - <td><code>!<em>ausdruck</em></code></td> - <td>Gibt <code>false</code> zurück, wenn der Operand zu <code>true</code> konvertiert werden kann. Andernfalls wird <code>true</code> zurückgegeben.</td> - </tr> - </tbody> -</table> - -<p>Wenn ein Wert zu <code>true</code> konvertiert werden kann, wird er {{Glossary("truthy")}} genannt. Wenn ein Wert zu <code>false</code> konvertiert werden kann, wird er {{Glossary("falsy")}} genannt.</p> - -<p>Beispiele für Ausdrücke, die zu <code>false</code> konvertiert werden können:</p> - -<ul> - <li><code>null</code></li> - <li>NaN</li> - <li><code>0</code></li> - <li>leerer String (<code>""</code> oder <code>''</code>)</li> - <li><code>undefined</code></li> -</ul> - -<p>Auch wenn die Operatoren <code>&&</code> und <code>||</code> mit nichtbooleschen Operanden verwendet werden können, gehören sie trotzdem zur Gruppe der logischen Operatoren, da ihre Rückgabewerte immer zu booleschen Werten konvertiert werden können.</p> - -<h3 id="Kurschlussauswertung_(Short-Circuit_Evaluation)">Kurschlussauswertung (Short-Circuit Evaluation)</h3> - -<p>Logische Ausdrücke werden von links nach rechts ausgewertet und hierbei wird anhand der folgenden Regeln getestet, ob Kurzschlussauswertungen möglich sind:</p> - -<ul> - <li><code>false && (<em>irgendwas)</em></code> wird kurzerhand zu false.</li> - <li><code>true || (<em>irgendwas)</em></code> wird kurzerhand zu true.</li> -</ul> - -<p>Die Regeln der Logik garantieren, dass diese Auswertungen immer korrekt sind. Zu beachten ist, dass der <em><code>irgendwas</code></em> Teil nicht ausgewertet wird, so dass keine Seiteneffekte die von diesem Teil ausgehen ausgeführt werden. Zu beachten ist zudem, dass der <em><code>irgendwas</code></em> Teil ein einzelner Ausdruck ist (wie die Klammern anzeigen).</p> - -<p>Beispielhaft betrachten wir die folgenden äquivalenten Funktionen:</p> - -<pre class="brush: js">function shortCircuitEvaluation() { - // Logisches ODER (||) - doSomething() || doSomethingElse(); - - // Logisches UND (&&) - doSomething() && doSomethingElse(); -} - -function equivalentEvaluation() { - - // Logisches ODER (||) - var orFlag = doSomething(); - if (!orFlag) { - doSomethingElse(); - } - - // Logisches UND (&&) - var andFlag = doSomething(); - if (andFlag) { - doSomethingElse(); - } -} -</pre> - -<p>Die folgenden Ausdrücke sind aufgrund der <a href="/de/docs/Web/JavaScript/Reference/Operators/Operator_Precedence">Operatorrangfolgen</a> nicht äquivalent und betont, wie wichtig es ist, dass der rechte Operand ein einzelner Ausdruck ist (gruppiert, falls in Klammern erforderlich).</p> - -<pre class="brush: js">false && true || true // wird zu true -false && (true || true) // wird zu false</pre> - -<h3 id="Logisches_UND_()"><a id="Logical_AND" name="Logical_AND">Logisches UND (<code>&&</code>)</a></h3> - -<p>Im Folgenden sind Beispiele des <code>&&</code> (logisches UND) Operators zu sehen.</p> - -<pre class="brush: js">a1 = true && true // t && t wird zu true -a2 = true && false // t && f wird zu false -a3 = false && true // f && t wird zu false -a4 = false && (3 == 4) // f && f wird zu false -a5 = 'Cat' && 'Dog' // t && t wird zu "Dog" -a6 = false && 'Cat' // f && t wird zu false -a7 = 'Cat' && false // t && f wird zu false -a8 = '' && false // f && f wird zu "" -a9 = false && '' // f && f wird zu false -</pre> - -<h3 id="Logisches_ODER_()"><a name="Logical_OR">Logisches ODER (<code>||</code>)</a></h3> - -<p>Im Folgenden sind Beispiele des <code>||</code> (logisches ODER) Operators zu sehen.</p> - -<pre class="brush: js">o1 = true || true // t || t wird zu true -o2 = false || true // f || t wird zu true -o3 = true || false // t || f wird zu true -o4 = false || (3 == 4) // f || f wird zu false -o5 = 'Cat' || 'Dog' // t || t wird zu "Cat" -o6 = false || 'Cat' // f || t wird zu "Cat" -o7 = 'Cat' || false // t || f wird zu "Cat" -o8 = '' || false // f || f wird zu false -o9 = false || '' // f || f wird zu "" -</pre> - -<h3 id="Logisches_NICHT_(!)"><a name="Logical_NOT">Logisches NICHT (<code>!</code>)</a></h3> - -<p>Im Folgenden sind Beispiele des <code>!</code> (logisches NICHT) Operators zu sehen.</p> - -<pre class="brush: js">n1 = !true // !t wird zu false -n2 = !false // !f wird zu true -n3 = !"Cat" // !t wird zu false -</pre> - -<h3 id="Konvertierungsregeln">Konvertierungsregeln</h3> - -<h4 id="Konvertierung_von_UND_zu_ODER">Konvertierung von UND zu ODER</h4> - -<p>Die folgende Operation nutzt Booleane:</p> - -<pre class="brush: js">bCondition1 && bCondition2</pre> - -<p>ist äquivalent zum folgenden Ausdruck:</p> - -<pre class="brush: js">!(!bCondition1 || !bCondition2)</pre> - -<h4 id="Konvertierung_von_ODER_zu_UND">Konvertierung von ODER zu UND</h4> - -<p>Die folgende Operation nutzt Booleane:</p> - -<pre class="brush: js">bCondition1 || bCondition2</pre> - -<p>ist äquivalent zu folgendem Ausdruck:</p> - -<pre class="brush: js">!(!bCondition1 && !bCondition2)</pre> - -<h4 id="Negierung_des_logischen_NICHT">Negierung des logischen NICHT</h4> - -<p>Die folgende Operation nutzt Booleane:</p> - -<pre class="brush: js">!!bCondition</pre> - -<p>ist äquivalent mit:</p> - -<pre class="brush: js">bCondition</pre> - -<h3 id="Klammern_in_logischen_Ausdrücken_auflösen">Klammern in logischen Ausdrücken auflösen</h3> - -<p>Ein logischer Ausdruck wird von links nach rechts ausgewertet. Es ist immer möglich runde Klammern von einem komplexen Ausdruck zu entfernen, wenn einige Regeln beachtet werden.</p> - -<h4 id="Geschachteltes_AND_entfernen">Geschachteltes AND entfernen</h4> - -<p>Die folgende Operation nutzt Booleane:</p> - -<pre class="brush: js">bCondition1 || (bCondition2 && bCondition3)</pre> - -<p>ist äquivalent mit:</p> - -<pre class="brush: js">bCondition1 || bCondition2 && bCondition3</pre> - -<h4 id="Geschachteltes_OR_entfernen">Geschachteltes OR entfernen</h4> - -<p>Die folgende Operation nutzt Booleane:</p> - -<pre class="brush: js">bCondition1 && (bCondition2 || bCondition3)</pre> - -<p>ist äquivalent mit:</p> - -<pre class="brush: js">!(!bCondition1 || !bCondition2 && !bCondition3)</pre> - -<h2 id="Spezifikationen">Spezifikationen</h2> - -<table class="standard-table"> - <tbody> - <tr> - <th scope="col">Spezifikation</th> - <th scope="col">Status</th> - <th scope="col">Kommentar</th> - </tr> - <tr> - <td>{{SpecName('ES1')}}</td> - <td>{{Spec2('ES1')}}</td> - <td>Initiale Definition.</td> - </tr> - <tr> - <td>{{SpecName('ES5.1', '#sec-11.11')}}</td> - <td>{{Spec2('ES5.1')}}</td> - <td>Definiert in mehreren Kapiteln der Spezifikation: <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.4.9">Logical NOT Operator</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.11">Binary Logical Operators</a></td> - </tr> - <tr> - <td>{{SpecName('ES6', '#sec-binary-logical-operators')}}</td> - <td>{{Spec2('ES6')}}</td> - <td>Definiert in mehreren Kapiteln der Spezifikation: <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-logical-not-operator">Logical NOT Operator</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-binary-logical-operators">Binary Logical Operators</a></td> - </tr> - <tr> - <td>{{SpecName('ESDraft', '#sec-binary-logical-operators')}}</td> - <td>{{Spec2('ESDraft')}}</td> - <td>Definiert in mehreren Kapiteln der Spezifikation: <a href="http://tc39.github.io/ecma262/#sec-logical-not-operator">Logical NOT Operator</a>, <a href="http://tc39.github.io/ecma262/#sec-binary-logical-operators">Binary Logical Operators</a></td> - </tr> - </tbody> -</table> - -<h2 id="Browserkompatibilität">Browserkompatibilität</h2> - - - -<p>{{Compat("javascript.operators.logical")}}</p> - -<h2 id="Siehe_auch">Siehe auch</h2> - -<ul> - <li>{{jsxref("Operators/Bitwise_Operators", "Bitweise Operatoren")}}</li> - <li>{{jsxref("Boolean")}}</li> -</ul> diff --git a/files/de/web/javascript/reference/operators/objekt_initialisierer/index.html b/files/de/web/javascript/reference/operators/object_initializer/index.html index 32c30b7f16..b4ac1fb413 100644 --- a/files/de/web/javascript/reference/operators/objekt_initialisierer/index.html +++ b/files/de/web/javascript/reference/operators/object_initializer/index.html @@ -1,6 +1,6 @@ --- title: Objekt Initialisierer -slug: Web/JavaScript/Reference/Operators/Objekt_Initialisierer +slug: Web/JavaScript/Reference/Operators/Object_initializer tags: - ECMAScript 2015 - JSON @@ -13,6 +13,7 @@ tags: - mutation - properties translation_of: Web/JavaScript/Reference/Operators/Object_initializer +original_slug: Web/JavaScript/Reference/Operators/Objekt_Initialisierer --- <div>{{JsSidebar("Operators")}}</div> diff --git a/files/de/web/javascript/reference/operators/optionale_verkettung/index.html b/files/de/web/javascript/reference/operators/optional_chaining/index.html index 8ef763b3cd..84344c90ab 100644 --- a/files/de/web/javascript/reference/operators/optionale_verkettung/index.html +++ b/files/de/web/javascript/reference/operators/optional_chaining/index.html @@ -1,6 +1,6 @@ --- title: Optionale Verkettung -slug: Web/JavaScript/Reference/Operators/Optionale_Verkettung +slug: Web/JavaScript/Reference/Operators/Optional_chaining tags: - Experimentell - JavaScript @@ -9,6 +9,7 @@ tags: - Referenz - Verkettung translation_of: Web/JavaScript/Reference/Operators/Optional_chaining +original_slug: Web/JavaScript/Reference/Operators/Optionale_Verkettung --- <div>{{JSSidebar("Operators")}}</div> diff --git a/files/de/web/javascript/reference/operators/modulo/index.html b/files/de/web/javascript/reference/operators/remainder/index.html index 19403ab883..36aacbfa93 100644 --- a/files/de/web/javascript/reference/operators/modulo/index.html +++ b/files/de/web/javascript/reference/operators/remainder/index.html @@ -1,12 +1,13 @@ --- title: Modulo (%) -slug: Web/JavaScript/Reference/Operators/Modulo +slug: Web/JavaScript/Reference/Operators/Remainder tags: - Division mit Rest - Divisionsalgorithmus - Restwert - Restwertberechnung translation_of: Web/JavaScript/Reference/Operators/Remainder +original_slug: Web/JavaScript/Reference/Operators/Modulo --- <div>{{jsSidebar("Operators")}}</div> diff --git a/files/de/web/javascript/reference/operators/spread_operator/index.html b/files/de/web/javascript/reference/operators/spread_operator/index.html deleted file mode 100644 index ee125663f4..0000000000 --- a/files/de/web/javascript/reference/operators/spread_operator/index.html +++ /dev/null @@ -1,220 +0,0 @@ ---- -title: Spread-Operator -slug: Web/JavaScript/Reference/Operators/Spread_operator -tags: - - ECMAScript 2015 - - Iterator - - JavaScript - - Operator -translation_of: Web/JavaScript/Reference/Operators/Spread_syntax -translation_of_original: Web/JavaScript/Reference/Operators/Spread_operator ---- -<div>{{jsSidebar("Operators")}}</div> - -<p>Mit der <strong>Spread-Syntax</strong> kann ein einzelner Ausdruck dort expandiert werden, wo mehrere Argumente (bei Funktionsaufrufen), mehrere Elemente (für Array-Literale) oder mehrere Variablen (für destrukturierende Anweisungen) erwartet werden.</p> - -<h2 id="Syntax">Syntax</h2> - -<p>Für Funktionsaufrufe:</p> - -<pre class="brush: js">myFunction(...iterableObj); -</pre> - -<p>Für Array-Literale:</p> - -<pre class="brush: js">[...iterableObj, 4, 5, 6]</pre> - -<h2 id="Beispiele">Beispiele</h2> - -<h3 id="Ein_besseres_apply">Ein besseres "apply"</h3> - -<p><strong>Beispiel:</strong> Für gewöhnlich wird {{jsxref( "Function.prototype.apply")}} verwendet, wenn man die Elemente eines Arrays als Argumente eines Funktionsaufrufs nutzen möchte:</p> - -<pre class="brush: js">function myFunction(x, y, z) { } -var args = [0, 1, 2]; -myFunction.apply(null, args);</pre> - -<p>Mit dem ES2015 Spread-Operator kann das nun wie folgt geschrieben werden:</p> - -<pre class="brush: js">function myFunction(x, y, z) { } -var args = [0, 1, 2]; -myFunction(...args);</pre> - -<p>Die Spread-Syntax kann für jedes beliebige Argument der Argumentliste verwendet werden, und sie kann auch mehrmals verwendet werden:</p> - -<pre class="brush: js">function myFunction(v, w, x, y, z) { } -var args = [0, 1]; -myFunction(-1, ...args, 2, ...[3]);</pre> - -<h3 id="Ein_mächtigeres_Array-Literal">Ein mächtigeres Array-Literal</h3> - -<p><strong>Beispiel:</strong> Wenn man ohne den Spread-Operator ein neues Array erstellen will, bei dem ein Teil davon ein bereits bestehendes Array sein soll, dann ist die Array-Literal-Syntax nicht mehr ausreichend und man muss auf imperative Programmierung mit einer Kombination aus <code>push</code>, <code>splice</code>, <code>concat</code>, etc. zurückgreifen. Mit der Spread-Syntax jedoch kann das viel prägnanter ausgedrückt werden:</p> - -<pre class="brush: js">var parts = ['shoulders', 'knees']; -var lyrics = ['head', ...parts, 'and', 'toes']; // <span class="objectBox objectBox-array"><a class="objectLink "><span class="arrayLeftBracket">[</span></a><span class="objectBox objectBox-string">"head"</span><span class="arrayComma">, </span><span class="objectBox objectBox-string">"shoulders"</span><span class="arrayComma">, </span><span class="objectBox objectBox-string">"knees"</span><span class="arrayComma">, </span><span class="objectBox objectBox-string">"and"</span><span class="arrayComma">, </span><span class="objectBox objectBox-string">"toes"</span></span>] -</pre> - -<p>Genau wie der Spread-Operator für Argumentlisten kann <code>...</code> überall im Array-Literal verwendet werden, auch mehrmals.</p> - -<h3 id="Apply_für_new">"Apply" für "new"</h3> - -<p><strong>Beispiel:</strong> In ES5 kann <code>new</code> nicht mit <code>apply</code> kombiniert werden (nach den ES5-Regeln führt <code>apply</code> einen <code>[[Call]]</code> aus, keinen <code>[[Construct]]</code>). Die Spread-Syntax von ES2015 unterstützt dies auf ganz natürliche Weise:</p> - -<pre class="brush: js">var dateFields = readDateFields(database); -var d = new Date(...dateFields);</pre> - -<h3 id="Ein_Array_kopieren">Ein Array kopieren</h3> - -<pre>var arr = [1,2,3]; -var arr2 = [...arr]; // wie arr.slice() -arr2.push(4); // arr2 wird [1,2,3,4], arr bleibt unverändert.</pre> - -<h3 id="Ein_besseres_push">Ein besseres "push"</h3> - -<p><strong>Beispiel:</strong> {{jsxref("Global_Objects/Array/push", "push")}} wird oft verwendet um alle Elemente eines Arrays an das Ende eines bestehenden Arrays anzuhängen. Das wird in ES5 oft wie folgt umgesetzt:</p> - -<pre class="brush: js">var arr1 = [0, 1, 2]; -var arr2 = [3, 4, 5]; -// Append all items from arr2 onto arr1 -Array.prototype.push.apply(arr1, arr2);</pre> - -<p>Mit dem Spread-Operator von ES2015 wird daraus:</p> - -<pre class="brush: js">var arr1 = [0, 1, 2]; -var arr2 = [3, 4, 5]; -arr1.push(...arr2);</pre> - -<h3 id="Nur_apply_für_iterables">Nur "apply" für iterables</h3> - -<pre>var obj = {"key1":"value1"}; -function myFunction(x) { - console.log(x) // undefined -} -myFunction(...obj); -var args = [...obj]; -console.log(args, args.length); // [] 0</pre> - -<h2 id="Rest-Syntax_(Parameter)">Rest-Syntax (Parameter)</h2> - -<p>Rest-Syntax sieht genauso aus wie die Spread-Syntax und wird für das Destrukturieren von Arrays und Objekten eingesetzt. Rest-Syntax ist sozusagen das Gegenteil von Spread-Syntax: Spread klappt die einzelnen Bestandteile eines Arrays aus, während Rest verschiedene einzelne Elemente zu einem Array zusammenfasst.</p> - -<h2 id="Spezifikationen">Spezifikationen</h2> - -<table class="standard-table"> - <thead> - <tr> - <th scope="col">Spezifikation</th> - <th scope="col">Status</th> - <th scope="col">Kommentar</th> - </tr> - </thead> - <tbody> - <tr> - <td>{{SpecName('ES2015', '#sec-array-initializer')}}</td> - <td>{{Spec2('ES2015')}}</td> - <td>Definiert in verschiedenen Abschnitten der Spezifikation: <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-array-initializer">Array Initializer</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-argument-lists">Argument Lists</a></td> - </tr> - <tr> - <td>{{SpecName('ESDraft', '#sec-array-initializer')}}</td> - <td>{{Spec2('ESDraft')}}</td> - <td> </td> - </tr> - </tbody> -</table> - -<h2 id="Browser-Kompatibilität">Browser-Kompatibilität</h2> - -<p>{{CompatibilityTable}}</p> - -<div id="compat-desktop"> -<table class="compat-table"> - <tbody> - <tr> - <th>Feature</th> - <th>Chrome</th> - <th>Firefox (Gecko)</th> - <th>Internet Explorer</th> - <th>Opera</th> - <th>Safari (WebKit)</th> - </tr> - <tr> - <td>Spread-Operation innerhalb von Array-Literalen</td> - <td>{{CompatChrome("46")}}</td> - <td>{{CompatGeckoDesktop("16")}}</td> - <td>{{CompatIE("Edge")}}</td> - <td>{{CompatNo}}</td> - <td>7.1</td> - </tr> - <tr> - <td>Spread-Operation innerhalb von Funktionsaufrufen</td> - <td>{{CompatChrome("46")}}</td> - <td>{{CompatGeckoDesktop("27")}}</td> - <td>{{CompatIE("Edge")}}</td> - <td>{{CompatNo}}</td> - <td>7.1</td> - </tr> - <tr> - <td>Spread-Operation beim Destrukturieren ("destructuring")</td> - <td>{{CompatChrome("49")}}</td> - <td>{{CompatGeckoDesktop("34")}}</td> - <td>{{CompatNo}}</td> - <td>{{CompatUnknown}}</td> - <td>{{CompatUnknown}}</td> - </tr> - </tbody> -</table> -</div> - -<div id="compat-mobile"> -<table class="compat-table"> - <tbody> - <tr> - <th>Feature</th> - <th>Android</th> - <th>Android Webview</th> - <th>Firefox Mobile (Gecko)</th> - <th>IE Mobile</th> - <th>Opera Mobile</th> - <th>Safari Mobile</th> - <th>Chrome for Android</th> - </tr> - <tr> - <td>Spread-Operation innerhalb von Array-Literalen</td> - <td>{{CompatNo}}</td> - <td>{{CompatChrome("46")}}</td> - <td>{{CompatGeckoMobile("16")}}</td> - <td>{{CompatNo}}</td> - <td>{{CompatNo}}</td> - <td>8</td> - <td>{{CompatChrome("46")}}</td> - </tr> - <tr> - <td>Spread-Operation innerhalb von Funktionsaufrufen</td> - <td>{{CompatNo}}</td> - <td>{{CompatChrome("46")}}</td> - <td>{{CompatGeckoMobile("27")}}</td> - <td>{{CompatNo}}</td> - <td>{{CompatNo}}</td> - <td>8</td> - <td>{{CompatChrome("46")}}</td> - </tr> - <tr> - <td>Spread-Operation beim Destrukturieren ("destructuring")</td> - <td>{{CompatNo}}</td> - <td>{{CompatNo}}</td> - <td>{{CompatGeckoDesktop("34")}}</td> - <td>{{CompatUnknown}}</td> - <td>{{CompatUnknown}}</td> - <td>{{CompatUnknown}}</td> - <td>{{CompatNo}}</td> - </tr> - </tbody> -</table> -</div> - -<h2 id="Siehe_auch">Siehe auch</h2> - -<ul> - <li><a href="/de/docs/Web/JavaScript/Reference/Functions_and_function_scope/rest_parameters">Rest Parameter</a></li> - <li><a href="http://exploringjs.com/es6/ch_destructuring.html#sec_rest-operator">Rest Operator</a></li> -</ul> diff --git a/files/de/web/javascript/reference/operators/vergleichsoperatoren/index.html b/files/de/web/javascript/reference/operators/vergleichsoperatoren/index.html deleted file mode 100644 index ceedd1eb07..0000000000 --- a/files/de/web/javascript/reference/operators/vergleichsoperatoren/index.html +++ /dev/null @@ -1,244 +0,0 @@ ---- -title: Vergleichsoperatoren -slug: Web/JavaScript/Reference/Operators/Vergleichsoperatoren -tags: - - JavaScript - - Operator - - Reference -translation_of: Web/JavaScript/Reference/Operators -translation_of_original: Web/JavaScript/Reference/Operators/Comparison_Operators ---- -<div>{{jsSidebar("Operators")}}</div> - -<p>JavaScript kennt sowohl den strikten als auch den Typ konvertierenden Vergleich. Ein strikter Vergleich (z. B. <code>===</code>) gibt nur true zurück, wenn der gleiche Typ und der gleiche Wert vorhanden sind. Der häufiger verwendete abstrakte Vergleich (z. B. <code>==</code>) wandelt die Operanden in den gleichen Typen um, bevor sie verglichen werden. Bei relationalen Vergleichsoperatoren (z. B. <code><=</code>) werden die Operanden vor dem Vergleich zuerst in elementare Datentypen konvertiert und dann in gleiche Typen umgewandelt.</p> - -<p>Strings werden entsprechend der lexikographischen Ordnung, basierend auf den Unicode, verglichen.</p> - -<div>{{EmbedInteractiveExample("pages/js/expressions-comparisonoperators.html")}}</div> - - - -<p>Merkmale von Vergleichen:</p> - -<ul> - <li>Zwei Strings sind strikt gleich, wenn sie die gleiche Abfolge von Zeichen, die gleiche Länge und die gleichen Zeichen in übereinstimmenden Positionen haben.</li> - <li>Zwei Zahlen sind strikt gleich, wenn sie numerisch gleich sind (den gleichen Zahlwert haben). <a href="/de/docs/Web/JavaScript/Reference/Global_Objects/NaN" title="NaN">NaN</a> ist mit nichts gleich, auch nicht mit sich selbst. +0 und -0 sind strikt gleich zueinander.</li> - <li>Zwei Boolesche Operanden sind exakt gleich wenn beide <code>true</code> oder beide <code>false</code> sind.</li> - <li>Zwei unterschiedliche Objekte sind niemals gleich, weder in strikten noch nicht-strikten Vergleichen.</li> - <li>Ein Ausdruck, der Objekte vergleicht, gilt nur als <code>true</code>, wenn die Operanden auf das gleiche Objekt zeigen.</li> - <li>Die Typen <code>Null</code> und <code>undefined</code> sind immer strikt gleich zu sich selbst und abstrakt gleich zueinander.</li> -</ul> - -<h2 id="Gleichheitsoperatoren">Gleichheitsoperatoren</h2> - -<h3 id="Gleichheit_()">Gleichheit (==)</h3> - -<p>Der Gleichheitsoperator konvertiert die Operanden, wenn sie <strong>nicht vom gleichen Typs</strong> sind und prüft dann auf strikte Gleichheit. Sind <strong>beide Operanden Objekte</strong>, vergleicht JavaScript die Referenzen; Referenzen gelten als gleich, wenn sie auf das gleiche Objekt im Speicher zeigen.</p> - -<h4 id="Syntax">Syntax</h4> - -<pre class="syntaxbox">x == y -</pre> - -<h4 id="Beispiele">Beispiele</h4> - -<pre class="brush: js">1 == 1 // true -'1' == 1 // true -1 == '1' // true -0 == false // true -0 == null // false -var object1 = {'key': 'value'}, object2 = {'key': 'value'} -object1 == object2 // false -0 == undefined // false -null == undefined // true -</pre> - -<h3 id="Ungleichheit_(!)">Ungleichheit (!=)</h3> - -<p>Der Ungleichheitsoperator gibt true zurück, wenn die Operanden nicht gleich sind. Wenn die beiden Operanden <strong>nicht vom gleichen Typ </strong>sind, versucht JavaScript die Operanden in einen, für den Vergleich passenden Typ, umzuwandeln. Wenn <strong>beide Operanden Objekte sind</strong>, vergleicht JavaScript die Referenzen; Referenzen sind ungleich, wenn sie auf verschiedene Objekte im Speicher verweisen.</p> - -<p>Syntax</p> - -<pre class="syntaxbox">x != y</pre> - -<h4 id="Beispiele_2">Beispiele</h4> - -<pre class="brush: js">1 != 2 // true -1 != "1" // false -1 != '1' // false -1 != true // false -0 != false // false -</pre> - -<h3 id="Identität_strikte_Gleichheit_()">Identität / strikte Gleichheit (===)</h3> - -<p>Der Identitätsoperator gibt true zurück, wenn die Operanden strikt gleich sind (siehe oben) <strong>ohne eine Typkonvertierung</strong></p> - -<h4 id="Syntax_2">Syntax</h4> - -<pre class="syntaxbox">x === y</pre> - -<h4 id="Beispiele_3">Beispiele</h4> - -<pre class="brush: js ">3 === 3 // true -3 === '3' // false -var object1 = {'key': 'value'}, object2 = {'key': 'value'} -object1 === object2 // false -</pre> - -<h3 id="Nicht_identisch_Strikte_Ungleichheit_(!)">Nicht identisch / Strikte Ungleichheit (!==)</h3> - -<p>Der strikte Ungleichheitsoperator gibt true zurück, wenn die Operanden<strong> nicht vom gleichen Typ sind bzw. ungleich sind</strong>.</p> - -<h4 id="Syntax_3">Syntax</h4> - -<pre class="syntaxbox">x !== y</pre> - -<h4 id="Beispiele_4">Beispiele</h4> - -<pre class="brush: js">3 !== '3' // true -4 !== 3 // true -</pre> - -<h2 id="Relationale_Operatoren">Relationale Operatoren</h2> - -<p>Jeder dieser Operatoren wird die <code>valueOf()</code> Funktion aufrufen, bevor ein Vergleich durchgeführt wird.</p> - -<h3 id="Größer-als-Operator_(>)">Größer-als-Operator (>)</h3> - -<p>Der Größer-als-Operator gibt true zurück, wenn der linke Operand größer als der rechte Operand ist.</p> - -<h4 id="Syntax_4">Syntax</h4> - -<pre class="syntaxbox">x > y</pre> - -<h4 id="Beispiele_5">Beispiele</h4> - -<pre class="brush: js">4 > 3 // true -</pre> - -<h3 id="Größer-oder-gleich-Operator_(>)">Größer-oder-gleich-Operator (>=)</h3> - -<p>Der Größer-oder-gleich-Operator gibt true zurück, wenn der linke Operand größer als oder gleich dem rechten Operanden ist.</p> - -<h4 id="Syntax_5">Syntax</h4> - -<pre class="syntaxbox"> x >= y</pre> - -<h4 id="Beispiele_6">Beispiele</h4> - -<pre class="brush: js">4 >= 3 // true -3 >= 3 // true -</pre> - -<h3 id="Kleiner-als-Operator_(<)">Kleiner-als-Operator (<)</h3> - -<p>Der Kleiner-als-Operator gibt true zurück, wenn der linke Operand kleiner als der rechte Operand ist.</p> - -<h4 id="Syntax_6">Syntax</h4> - -<pre class="syntaxbox"> x < y</pre> - -<h4 id="Beispiele_7">Beispiele</h4> - -<pre class="brush: js">3 < 4 // true -</pre> - -<h3 id="Kleiner-oder-gleich-Operator_(<)">Kleiner-oder-gleich-Operator (<=)</h3> - -<p>Der Kleiner-oder-gleich-Operator gibt true zurück, wenn der linke Operand kleiner oder gleich dem rechten Operanden ist.</p> - -<h4 id="Syntax_7">Syntax</h4> - -<pre class="syntaxbox"> x <= y</pre> - -<h4 id="Beispiele_8">Beispiele</h4> - -<pre class="brush: js">3 <= 4 // true -</pre> - -<h2 id="Die_Gleichheitsoperatoren_anwenden">Die Gleichheitsoperatoren anwenden</h2> - -<p>Die Standard-Gleichheitsoperatoren (<code>==</code> und <code>!=</code>) benutzen den <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.3">Abstract Equality Comparison Algorithmus</a>, um zwei Operanden zu vergleichen. Sind die Operanden unterschiedlichen Typs, wird vor dem Vergleich zuerst versucht sie in gleiche Typen umzuwandeln; z.B. wird beim Ausdruck <code>5 == '5'</code> das Zeichen auf der rechten Seite in eine Zahl konvertiert.</p> - -<p>Die strikten Gleichheitsoperatoren (<code>===</code> und <code>!==</code>) benutzen den <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.6">Strict Equality Comparison Algorithmus</a> und sind dafür gedacht, Operanden des gleichen Typs zu vergleichen. Wenn die Operanden von unterschiedlichen Typen sind, ist das Ergebnis immer <code>false</code>, wie <code>5 !== '5'</code>.</p> - -<p>Strikte Gleichheitsoperatoren sollten verwendet werden, wenn die Operanden sowohl einen bestimmten Typen als auch Wert haben sollen. Ansonsten benutzt man die abstrakten Gleichheitsoperatoren, die es einem erlauben Operanden unterschiedlicher Typen zu vergleichen.</p> - -<p>Wenn beim Vergleich eine Typkonvertierung vorgenommen wird (z.B. beim nicht-strikten Vergleich), konvertiert JavaScript in die Typen {{jsxref("String")}}, {{jsxref("Number")}}, {{jsxref("Boolean")}} und {{jsxref("Object")}} und führt den Vergleich dann aus:</p> - -<ul> - <li>Wenn eine Zahl und eine Zeichenkette verglichen werden, wird die Zeichenkette zu einem Zahlenwert umgewandelt. JavaScript versucht das numerische Zeichenliteral in einen Wert des Typs <code>Number</code> zu wandeln. Zuerst wird der mathematische Wert des numerischen Zeichenliterals ermittelt. Danach wird der Wert auf den nächsten Wert des Typs <code>Number</code> gerundet.</li> - <li>Wenn einer der Operanden ein Boolescher Typ ist, wird der Operand zur 1 konveriert wenn er <code>true</code> ist und zur +0 wenn <code>false</code>.</li> - <li>Wenn ein Objekt mit einer Zahl oder einer Zeichenkette verglichen wird, versucht JavaScript den Defaultwert für das Objekt zurückzugeben. Operatoren versuchen das Objekt in einen elementaren Wert (<code>String</code> oder <code>Number)</code> umzuwandeln, indem sie die <code>valueOf</code> und <code>toString</code> Methoden der Objekte benutzen. Kann ein Objekt nicht umgewandelt werden, wird ein Laufzeitfehler erzeugt.</li> - <li>Ein Objekt wird nur dann in einen elementaren Datentypen umgewandelt, wenn sein Vergleichsoperand ein elementarer Datentyp ist. Sind beide Operanden Objekte, werden sie als Objekte verglichen und der Gleichheitstest liefert nur dann true, wenn beide auf das gleiche Objekt zeigen.</li> -</ul> - -<div class="note"><strong>Hinweis:</strong> String Objekte sind vom Typ Objekte, nicht String! String Objekte werden selten eingesetzt, so dass das folgende Ergebnis überraschend sein kann:</div> - -<pre class="brush:js">// true, da beide Operanden vom Typ String sind (string primitives) -'foo' === 'foo' - -var a = new String('foo'); -var b = new String('foo'); - -// false, da a und b auf verschiedene Objekte zeigen -a == b - -// false, da a und b auf verschiedene Objekte zeigen -a === b - -// true, da a und 'foo' verschiedene Typen sind und das Objekt (a) -// vor dem Vergleich zum String 'foo' umgewandelt wird -a == 'foo' </pre> - -<h2 id="Spezifikationen">Spezifikationen</h2> - -<table class="standard-table"> - <tbody> - <tr> - <th scope="col">Spezifikation</th> - <th scope="col">Status</th> - <th scope="col">Kommentar</th> - </tr> - <tr> - <td>{{SpecName('ES1')}}</td> - <td>{{Spec2('ES1')}}</td> - <td>Initial Definition. Implementiert in JavaScript 1.0</td> - </tr> - <tr> - <td>{{SpecName('ES3')}}</td> - <td>{{Spec2('ES3')}}</td> - <td>Fügt <code>===</code> und <code>!==</code> Operatoren hinzu. Implementiert in JavaScript 1.3</td> - </tr> - <tr> - <td>{{SpecName('ES5.1', '#sec-11.8')}}</td> - <td>{{Spec2('ES5.1')}}</td> - <td>In verschiedenen Kapiteln der Spezifikation definiert: <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.8">Relational Operators</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.9">Equality Operators</a></td> - </tr> - <tr> - <td>{{SpecName('ES6', '#sec-relational-operators')}}</td> - <td>{{Spec2('ES6')}}</td> - <td>In verschiedenen Kapiteln der Spezifikation definiert: <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-relational-operators">Relational Operators</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-equality-operators">Equality Operators</a></td> - </tr> - <tr> - <td>{{SpecName('ESDraft', '#sec-relational-operators')}}</td> - <td>{{Spec2('ESDraft')}}</td> - <td>In verschiedenen Kapiteln der Spezifikation definiert: <a href="http://tc39.github.io/ecma262/#sec-relational-operators">Relational Operators</a>, <a href="http://tc39.github.io/ecma262/#sec-equality-operators">Equality Operators</a></td> - </tr> - </tbody> -</table> - -<h2 id="Browserkompatibilität">Browserkompatibilität</h2> - - - -<p>{{Compat("javascript.operators.comparison")}}</p> - -<h2 id="Siehe_auch">Siehe auch</h2> - -<ul> - <li>{{jsxref("Object.is()")}}</li> - <li>{{jsxref("Math.sign()")}}</li> - <li><a href="/de/docs/Web/JavaScript/Equality_comparisons_and_sameness">Equality comparisons and sameness</a></li> -</ul> diff --git a/files/de/web/javascript/reference/operators/zuweisungsoperator/index.html b/files/de/web/javascript/reference/operators/zuweisungsoperator/index.html deleted file mode 100644 index 5df33bfe62..0000000000 --- a/files/de/web/javascript/reference/operators/zuweisungsoperator/index.html +++ /dev/null @@ -1,413 +0,0 @@ ---- -title: Zuweisungsoperator -slug: Web/JavaScript/Reference/Operators/Zuweisungsoperator -tags: - - JavaScript - - Operator -translation_of: Web/JavaScript/Reference/Operators#Assignment_operators -translation_of_original: Web/JavaScript/Reference/Operators/Assignment_Operators ---- -<div>{{jsSidebar("Operators")}}</div> - -<p>Ein <strong>Zuweisungsoperator</strong> weist dem linken Operanten einen Wert auf Basis des rechten Operanten zu.</p> - -<div>{{EmbedInteractiveExample("pages/js/expressions-assignment.html")}}</div> - - - -<h2 id="Überblick">Überblick</h2> - -<p>Der Basiszuweisungsoperator ist das Gleich (<code>=</code>), welches den Wert des rechten Operanten dem linken Operanten zuweist. So wird bei <code>x = y</code> der Wert von <code>y</code> <code>x</code> zugewiesen. Die anderen Zuweisungsoperatoren sind Kurzformen für Standardoperationen, wie es in den folgenden Definition und Beispielen gezeigt wird.</p> - -<table class="standard-table"> - <tbody> - <tr> - <th>Name</th> - <th>Kurzformoperator</th> - <th>Bedeutung</th> - </tr> - <tr> - <td><a href="#Assignment">Zuweisung</a></td> - <td><code>x = y</code></td> - <td><code>x = y</code></td> - </tr> - <tr> - <td><a href="#Addition_assignment">Additionszuweisung</a></td> - <td><code>x += y</code></td> - <td><code>x = x + y</code></td> - </tr> - <tr> - <td><a href="#Subtraction_assignment">Subtraktionszuweisung</a></td> - <td><code>x -= y</code></td> - <td><code>x = x - y</code></td> - </tr> - <tr> - <td><a href="#Multiplication_assignment">Multiplikationszuweisung</a></td> - <td><code>x *= y</code></td> - <td><code>x = x * y</code></td> - </tr> - <tr> - <td><a href="#Division_assignment">Divisionszuweisung</a></td> - <td><code>x /= y</code></td> - <td><code>x = x / y</code></td> - </tr> - <tr> - <td><a href="#Remainder_assignment">Restzuweisung</a></td> - <td><code>x %= y</code></td> - <td><code>x = x % y</code></td> - </tr> - <tr> - <td><a href="#Exponentiation_assignment">Potenzierungszuweisung</a></td> - <td><code>x **= y</code></td> - <td><code>x = x ** y</code></td> - </tr> - <tr> - <td><a href="#Left_shift_assignment">Links verschiebende Zuweisung</a></td> - <td><code>x <<= y</code></td> - <td><code>x = x << y</code></td> - </tr> - <tr> - <td><a href="#Right_shift_assignment">Rechts verschiebende Zuweisung</a></td> - <td><code>x >>= y</code></td> - <td><code>x = x >> y</code></td> - </tr> - <tr> - <td><a href="#Unsigned_right_shift_assignment">Vorzeichenlose rechts verschiebende Zuweisung</a></td> - <td><code>x >>>= y</code></td> - <td><code>x = x >>> y</code></td> - </tr> - <tr> - <td><a href="#Bitwise_AND_assignment">Bitweise AND Zuweisung</a></td> - <td><code>x &= y</code></td> - <td><code>x = x & y</code></td> - </tr> - <tr> - <td><a href="#Bitwise_XOR_assignment">Bitweise XOR Zuweisung</a></td> - <td><code>x ^= y</code></td> - <td><code>x = x ^ y</code></td> - </tr> - <tr> - <td><a href="#Bitwise_OR_assignment">Bitweise OR Zuweisung</a></td> - <td><code>x |= y</code></td> - <td><code>x = x | y</code></td> - </tr> - </tbody> -</table> - -<h2 id="Zuweisung"><a name="Assignment">Zuweisung</a></h2> - -<p>Einfacher Zuweisungsoperator, welcher den Wert zu einer Variablen zuweist. Der Zuweisungsoperator gibt den zugewiesenen Wert zurück. Eine Verkettung der Zuweisungsoperatoren ist möglich, um einen Wert mehreren Variablen zuzuweisen. Sie in den Beispielen.</p> - -<h4 id="Syntax">Syntax</h4> - -<pre class="syntaxbox"><strong>Operator:</strong> x = y -</pre> - -<h4 id="Beispiele">Beispiele</h4> - -<pre class="brush: js">// Folgende Variablen sind vorausgesetzt -// x = 5 -// y = 10 -// z = 25 - -x = y // x ist 10 -x = y = z // x, y und z sind alle 25 -</pre> - -<h3 id="Additionszuweisung"><a name="Addition_assignment">Additionszuweisung</a></h3> - -<p>Der Additionszuweisungsoperator <strong>addiert</strong> den Wert des rechten Operanten zu einer Variablen und weist das Ergebnis der Variablen zu. Die Typen der Operanten entscheiden über das Verhalten des Additionszuweisungsoperator. Addition oder Konkatination sind möglich. Siehe beim {{jsxref("Operators/Arithmetic_Operators", "Additionsoperator", "#Addition", 1)}} für mehr Details nach.</p> - -<h4 id="Syntax_2">Syntax</h4> - -<pre class="syntaxbox"><strong>Operator:</strong> x += y -<strong>Bedeutung:</strong> x = x + y -</pre> - -<h4 id="Beispiele_2">Beispiele</h4> - -<pre class="brush: js">// Die folgenden Variablen werden vorausgesetzt -// foo = 'foo' -// bar = 5 -// baz = true - - -// Number + Number -> Addition -bar += 2 // 7 - -// Boolean + Number -> Addition -baz += 1 // 2 - -// Boolean + Boolean -> Addition -baz += false // 1 - -// Number + String -> Konkationation -bar += 'foo' // "5foo" - -// String + Boolean -> Konkatination -foo += false // "foofalse" - -// String + String -> Konkationation -foo += 'bar' // "foobar" -</pre> - -<h3 id="Subtraktionszuweisung"><a name="Subtraction_assignment">Subtraktionszuweisung</a></h3> - -<p>Der Subtraktionszuweisungsoperator <strong>subtahiert</strong> den Wert des rechten Operanten von einer Variablen und weist das Ergebnis der Variablen zu. Siehe beim {{jsxref("Operators/Arithmetic_Operators", "Subraktionsoperator", "#Subtraction", 1)}} für mehr Details nach.</p> - -<h4 id="Syntax_3">Syntax</h4> - -<pre class="syntaxbox"><strong>Operator:</strong> x -= y -<strong>Bedeutung:</strong> x = x - y -</pre> - -<h4 id="Beispiele_3">Beispiele</h4> - -<pre class="brush: js">// Die folgenden Variablen werden vorausgesetzt -// bar = 5 - -bar -= 2 // 3 -bar -= 'foo' // NaN -</pre> - -<h3 id="Multiplikationszuweisung"><a name="Multiplication_assignment">Multiplikationszuweisung</a></h3> - -<p>Der Multiplikationszuweisungsoperator <strong>multipliziert</strong> den Wert des rechten Operanten zu einer Variablen und weist das Ergebnis der Variablen zu. Siehe beim {{jsxref("Operators/Arithmetic_Operators", "Multiplikationsoperator", "#Multiplication", 1)}} für mehr Details nach.</p> - -<h4 id="Syntax_4">Syntax</h4> - -<pre class="syntaxbox"><strong>Operator:</strong> x *= y -<strong>Bedeutung:</strong> x = x * y -</pre> - -<h4 id="Beispiele_4">Beispiele</h4> - -<pre class="brush: js">// Die folgenden Variablen werden vorausgesetzt -// bar = 5 - -bar *= 2 // 10 -bar *= 'foo' // NaN -</pre> - -<h3 id="Divisionszuweisung"><a name="Division_assignment">Divisionszuweisung</a></h3> - -<p>Der Divisionszuweisungsoperator <strong>dividiert</strong> eine Variable durch den rechten Operanten zu und weist das Ergebnis der Variablen zu. Siehe beim {{jsxref("Operators/Arithmetic_Operators", "Divisionsoperator", "#Division", 1)}} für mehr Details nach.</p> - -<h4 id="Syntax_5">Syntax</h4> - -<pre class="syntaxbox"><strong>Operator:</strong> x /= y -<strong>Bedeutung:</strong> x = x / y -</pre> - -<h4 id="Beispiele_5">Beispiele</h4> - -<pre class="brush: js">// Die folgenden Variablen werden vorausgesetzt -// bar = 5 - -bar /= 2 // 2.5 -bar /= 'foo' // NaN -bar /= 0 // Infinity -</pre> - -<h3 id="Restzuweisung"><a name="Remainder_assignment">Restzuweisung</a></h3> - -<p>Der Restzuweisungsoperator <strong>dividiert</strong> einer Variable durch den rechten Operanten und weist den <strong>Rest</strong> des Ergebnis der Variablen zu. Siehe beim {{jsxref("Operators/Arithmetic_Operators", "Restoperator", "#Remainder", 1)}} für mehr Details nach.</p> - -<h4 id="Syntax_6">Syntax</h4> - -<pre class="syntaxbox"><strong>Operator:</strong> x %= y -<strong>Bedeutung:</strong> x = x % y -</pre> - -<h4 id="Beispiele_6">Beispiele</h4> - -<pre class="brush: js">// Die folgenden Variablen werden vorausgesetzt -// bar = 5 - -bar %= 2 // 1 -bar %= 'foo' // NaN -bar %= 0 // NaN -</pre> - -<h3 id="Potenzierungszuweisung"><a id="Exponentiation_assignment" name="Exponentiation_assignment">Potenzierungszuweisung</a></h3> - -<p>Der Potenzierungszuweisungsoperator <strong>potenziert</strong> einer Variable mit den rechten Operanten und weist das Ergebnis der Variablen zu. Siehe beim {{jsxref("Operators/Arithmetic_Operators", "Exponentialoperator", "#Exponentiation", 1)}} für mehr Details nach.</p> - -<h4 id="Syntax_7">Syntax</h4> - -<pre class="syntaxbox"><strong>Operator:</strong> x **= y -<strong>Bedeutung:</strong> x = x ** y -</pre> - -<h4 id="Beispiele_7">Beispiele</h4> - -<pre class="brush: js">// Die folgenden Variablen werden vorausgesetzt -// bar = 5 - -bar **= 2 // 25 -bar **= 'foo' // NaN</pre> - -<h3 id="Links_verschiebende_Zuweisung"><a name="Left_shift_assignment">Links verschiebende Zuweisung</a></h3> - -<p>Der links verschiebende Zuweisungsoperator verschiebt um die Anzahl Bits im rechten Operanten in der Variablen und weist das Ergebnis der Variablen zu. Siehe beim {{jsxref("Operators/Bitwise_Operators", "links verschiebenden Operator", "#Left_shift", 1)}} für mehr Details nach.</p> - -<h4 id="Syntax_8">Syntax</h4> - -<pre class="syntaxbox"><strong>Operator:</strong> x <<= y -<strong>Bedeutung:</strong> x = x << y -</pre> - -<h4 id="Beispiele_8">Beispiele</h4> - -<pre class="brush: js">var bar = 5; // (00000000000000000000000000000101) -bar <<= 2; // 20 (00000000000000000000000000010100) -</pre> - -<h3 id="Rechts_verschiebende_Zuweisung"><a name="Right_shift_assignment">Rechts verschiebende Zuweisung</a></h3> - -<p>Der rechts verschiebende Zuweisungsoperator verschiebt um die Anzahl Bits im rechten Operanten in der Variablen und weist das Ergebnis der Variablen zu. Siehe beim {{jsxref("Operators/Bitwise_Operators", "rechts verschiebenden Operator", "#Right_shift", 1)}} für mehr Details nach.</p> - -<h4 id="Syntax_9">Syntax</h4> - -<pre class="syntaxbox"><strong>Operator:</strong> x >>= y -<strong>Bedeutung:</strong> x = x >> y -</pre> - -<h4 id="Beispiele_9">Beispiele</h4> - -<pre class="brush: js">var bar = 5; // (00000000000000000000000000000101) -bar >>= 2; // 1 (00000000000000000000000000000001) - -var bar -5; // (-00000000000000000000000000000101) -bar >>= 2; // -2 (-00000000000000000000000000000010) -</pre> - -<h3 id="Vorzeichenlose_rechts_verschiebende_Zuweisung"><a name="Unsigned_right_shift_assignment">Vorzeichenlose rechts verschiebende Zuweisung</a></h3> - -<p>Der vorzeichenlose rechts verschiebende Zuweisungsoperator verschiebt um die Anzahl Bits im rechten Operanten in der Variablen und weist das Ergebnis der Variablen zu. Siehe beim {{jsxref("Operators/Bitwise_Operators", "vorzeichenlose rechts verschiebenden Operator", "#Unsigned_right_shift", 1)}} für mehr Details nach.</p> - -<h4 id="Syntax_10">Syntax</h4> - -<pre class="syntaxbox"><strong>Operator:</strong> x >>>= y -<strong>Bedeutung:</strong> x = x >>> y -</pre> - -<h4 id="Beispiele_10">Beispiele</h4> - -<pre class="brush: js">var bar = 5; // (00000000000000000000000000000101) -bar >>>= 2; // 1 (00000000000000000000000000000001) - -var bar = -5; // (-00000000000000000000000000000101) -bar >>>= 2; // 1073741822 (00111111111111111111111111111110)</pre> - -<h3 id="Bitweise_UND_Zuweisung"><a name="Bitwise_AND_assignment">Bitweise UND Zuweisung</a></h3> - -<p>Der bitweise UND Zuweisungsoperator nutzt die Bitrepräsentation beider Operanten, führt eine bitweises UND Operation aus und weist das Ergebnis der Variablen zu.<strong> </strong>Siehe beim {{jsxref("Operators/Bitwise_Operators", "bitweisen UND Operator", "#Bitwise_AND", 1)}} für mehr Details nach.</p> - -<h4 id="Syntax_11">Syntax</h4> - -<pre class="syntaxbox"><strong>Operator:</strong> x &= y -<strong>Bedeutung:</strong> x = x & y -</pre> - -<h4 id="Beispiele_11">Beispiele</h4> - -<pre class="brush: js">var bar = 5; -// 5: 00000000000000000000000000000101 -// 2: 00000000000000000000000000000010 -bar &= 2; // 0 -</pre> - -<h3 id="Bitweise_XOR_Zuweisung"><a name="Bitwise_XOR_assignment">Bitweise XOR Zuweisung</a></h3> - -<p>Der bitweise XOR Zuweisungsoperator nutzt die Bitrepräsentation beider Operanten, führt eine bitweises XOR Operation aus und weist das Ergebnis der Variablen zu.<strong> </strong>Siehe beim {{jsxref("Operators/Bitwise_Operators", "bitweisen XOR Operator", "#Bitwise_XOR", 1)}} für mehr Details nach.</p> - -<h4 id="Syntax_12">Syntax</h4> - -<pre class="syntaxbox"><strong>Operator:</strong> x ^= y -<strong>Bedeutung:</strong> x = x ^ y -</pre> - -<h4 id="Beispiele_12">Beispiele</h4> - -<pre class="brush: js">var bar = 5; -bar ^= 2; // 7 -// 5: 00000000000000000000000000000101 -// 2: 00000000000000000000000000000010 -// ----------------------------------- -// 7: 00000000000000000000000000000111 -</pre> - -<h3 id="Bitweise_ODER_Zuweisung"><a name="Bitwise_OR_assignment">Bitweise ODER Zuweisung</a></h3> - -<p>Der bitweise ODER Zuweisungsoperator nutzt die Bitrepräsentation beider Operanten, führt eine bitweises ODER Operation aus und weist das Ergebnis der Variablen zu.<strong> </strong>Siehe beim {{jsxref("Operators/Bitwise_Operators", "bitweisen ODER Operator", "#Bitwise_OR", 1)}} für mehr Details nach.</p> - -<h4 id="Syntax_13">Syntax</h4> - -<pre class="syntaxbox"><strong>Operator:</strong> x |= y -<strong>Bedeutung:</strong> x = x | y -</pre> - -<h4 id="Beispiele_13">Beispiele</h4> - -<pre class="brush: js">var bar = 5; -bar |= 2; // 7 -// 5: 00000000000000000000000000000101 -// 2: 00000000000000000000000000000010 -// ----------------------------------- -// 7: 00000000000000000000000000000111 -</pre> - -<h2 id="Beispiele_14">Beispiele</h2> - -<h3 id="Linker_Operant_mit_anderem_Zuweisungsoperator">Linker Operant mit anderem Zuweisungsoperator</h3> - -<p>In ungewöhnlichen Situationen kann ein Zuweisungsoperator (z. B. <code>x += y</code>) nicht identisch mit der äquivalenten Zuweisung (hier <code>x = x + y</code>). Wenn der linke Operant einer Zuweisung selbst eine Zuweisung enthält, wird der linke Operant nur einem ausgewertet. Zum Beispiel:</p> - -<pre class="brush: js">a[i++] += 5 // i wird einmal ausgewertet -a[i++] = a[i++] + 5 // i wird zweimal ausgewertet -</pre> - -<h2 id="Spezifikationen">Spezifikationen</h2> - -<table class="standard-table"> - <tbody> - <tr> - <th scope="col">Spezifikation</th> - <th scope="col">Status</th> - <th scope="col">Kommentar</th> - </tr> - <tr> - <td>{{SpecName('ESDraft', '#sec-assignment-operators', 'Assignment operators')}}</td> - <td>{{Spec2('ESDraft')}}</td> - <td> </td> - </tr> - <tr> - <td>{{SpecName('ES2015', '#sec-assignment-operators', 'Assignment operators')}}</td> - <td>{{Spec2('ES2015')}}</td> - <td> </td> - </tr> - <tr> - <td>{{SpecName('ES5.1', '#sec-11.13', 'Assignment operators')}}</td> - <td>{{Spec2('ES5.1')}}</td> - <td> </td> - </tr> - <tr> - <td>{{SpecName('ES1', '#sec-11.13', 'Assignment operators')}}</td> - <td>{{Spec2('ES1')}}</td> - <td>Initiale Definition.</td> - </tr> - </tbody> -</table> - -<h2 id="Browserkompatibilität">Browserkompatibilität</h2> - - - -<p>{{Compat("javascript.operators.assignment")}}</p> - -<h2 id="Siehe_auch">Siehe auch</h2> - -<ul> - <li><a href="/de/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators">Arithmetische Operatoren</a></li> -</ul> |