path: root/files/de/conflicting/web/javascript/reference/operators/index.html

---
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 &amp; 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 &lt;&lt; b</code></td>
   <td>Verschiebt <code>a</code> in binärer Repräsentation <code>b</code> (&lt; 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 &gt;&gt; b</code></td>
   <td>Verschiebt <code>a</code> in binärer Repräsentation <code>b</code> (&lt; 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 &gt;&gt;&gt; b</code></td>
   <td>Verschiebt <code>a</code> in binärer Repräsentation <code>b</code> (&lt; 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">&amp; (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 &amp; 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') &lt;= 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="&lt;&lt;_(Linksverschiebung)"><a name="Left_shift">&lt;&lt; (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 &lt;&lt; 2</code> <code>36</code>:</p>

<pre class="brush: js">.    9 (Basis 10): 00000000000000000000000000001001 (Basis 2)
                   --------------------------------
9 &lt;&lt; 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">&gt;&gt; (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 &gt;&gt; 2</code> <code>2</code>:</p>

<pre class="brush: js">.    9 (base 10): 00000000000000000000000000001001 (base 2)
                  --------------------------------
9 &gt;&gt; 2 (base 10): 00000000000000000000000000000010 (base 2) = 2 (base 10)
</pre>

<p>Likewise, <code>-9 &gt;&gt; 2</code> yields <code>-3</code>, because the sign is preserved:</p>

<pre class="brush: js">.    -9 (Basis 10): 11111111111111111111111111110111 (Basis 2)
                    --------------------------------
-9 &gt;&gt; 2 (Basis 10): 11111111111111111111111111111101 (Basis 2) = -3 (Basis 10)
</pre>

<h3 id=">>>_(Null_füllende_Rechtsverschiebung)"><a name="Unsigned_right_shift">&gt;&gt;&gt; (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 &gt;&gt;&gt; 2</code> <code>2</code>, das selbe wie <code>9 &gt;&gt; 2</code>:</p>

<pre class="brush: js">.     9 (Basis 10): 00000000000000000000000000001001 (Basis 2)
                    --------------------------------
9 &gt;&gt;&gt; 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 &gt;&gt;&gt; 2</code> <code>1073741821</code>, was sich unterschiedet von <code>-9 &gt;&gt; 2</code> (was <code>-3</code> ergibt):</p>

<pre class="brush: js">.     -9 (Basis 10): 11111111111111111111111111110111 (Basis 2)
                     --------------------------------
-9 &gt;&gt;&gt; 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 =&gt; 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 &amp; FLAG_C) { // 0101 &amp; 0100 =&gt; 0100 =&gt; 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 &amp; 0010) || (0101 &amp; 0100) =&gt; 0000 || 0100 =&gt; true
if ((flags &amp; FLAG_B) || (flags &amp; 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 =&gt; 0110
if (flags &amp; mask) { // 0101 &amp; 0110 =&gt; 0100 =&gt; 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 =&gt; 1100
flags |= mask;   // 0101 | 1100 =&gt; 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 =&gt; 1010
flags &amp;= mask;   // 1101 &amp; 1010 =&gt; 1000
</pre>

<p>The mask could also have been created with <code>~FLAG_A &amp; ~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 &amp; ~FLAG_C;
flags &amp;= mask;   // 1101 &amp; 1010 =&gt; 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 =&gt; 1010
</pre>

<p>Alle Flags können mit dem Negationsoperator umgedreht werden:</p>

<pre class="brush: js">// entering parallel universe...
flags = ~flags;    // ~1010 =&gt; 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 &gt; 32 ? 32 : arguments.length;
  for (nFlag; nFlag &lt; nLen; nMask |= arguments[nFlag] &lt;&lt; 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 &gt; 0x7fffffff || nMask &lt; -0x80000000) {
    throw new TypeError('arrayFromMask - out of range');
  }
  for (var nShifted = nMask, aFromMask = []; nShifted;
       aFromMask.push(Boolean(nShifted &amp; 1)), nShifted &gt;&gt;&gt;= 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 &lt; 32;
       nFlag++, sMask += String(nShifted &gt;&gt;&gt; 31), nShifted &lt;&lt;= 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>