diff options
Diffstat (limited to 'files/de/conflicting/web/javascript/reference/operators')
| -rw-r--r-- | files/de/conflicting/web/javascript/reference/operators/index.html | 576 | ||||
| -rw-r--r-- | files/de/conflicting/web/javascript/reference/operators/spread_syntax/index.html | 221 |
2 files changed, 0 insertions, 797 deletions
diff --git a/files/de/conflicting/web/javascript/reference/operators/index.html b/files/de/conflicting/web/javascript/reference/operators/index.html deleted file mode 100644 index 1d540b8f9e..0000000000 --- a/files/de/conflicting/web/javascript/reference/operators/index.html +++ /dev/null @@ -1,576 +0,0 @@ ---- -title: Bitweise Operatoren -slug: conflicting/Web/JavaScript/Reference/Operators -tags: - - JavaScript - - Operator - - Reference -translation_of: Web/JavaScript/Reference/Operators -translation_of_original: Web/JavaScript/Reference/Operators/Bitwise_Operators -original_slug: Web/JavaScript/Reference/Operators/Bitwise_Operatoren ---- -<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/conflicting/web/javascript/reference/operators/spread_syntax/index.html b/files/de/conflicting/web/javascript/reference/operators/spread_syntax/index.html deleted file mode 100644 index 41317b23e8..0000000000 --- a/files/de/conflicting/web/javascript/reference/operators/spread_syntax/index.html +++ /dev/null @@ -1,221 +0,0 @@ ---- -title: Spread-Operator -slug: conflicting/Web/JavaScript/Reference/Operators/Spread_syntax -tags: - - ECMAScript 2015 - - Iterator - - JavaScript - - Operator -translation_of: Web/JavaScript/Reference/Operators/Spread_syntax -translation_of_original: Web/JavaScript/Reference/Operators/Spread_operator -original_slug: 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> |