Inhaltsverzeichnis
Bitweise Operationen
View more Tutorials:
Folge uns auf unserer fanpage, um jedes Mal benachrichtigt zu werden, wenn es neue Artikel gibt.
Facebook
In der digitalen Computer Programmierung funktioniert die Operation bitwise auf eine oder viele Binärzahle (binary numerals), oder die binärzahlengleiche Strings. Das ist eine einfache und schnelle Operation, die durch der Verarbeiter (processor) direkt unterstützt wird. Normalerweise sind die Operationen bitwise mehr schneller als die Multiplikation, Division und manchmal auch als die Addition. Die Operationen bitwise benutzt weniger Energie denn sie benutzt selten die Ressourcen .
Es gibt 7 Operationen bitwise:
| Operator | Name | Description |
|---|---|---|
| & | AND | Wenn die beide bit 1 sind, ist die zurückgegebene Wert 1, umgekehrt 0. |
| | | OR | Wenn eine der zwei bits 1 ist, ist die zurückgegebene Wert 1, umgekehrt 0 |
| ^ | XOR | Wenn die zwei bit sich ändern, ist die zurückgegebene Wert 1, umgekehrt 0 . |
| ~ | NOT | alle bits umdrehen, 0 zu 1 und 1 zu 0. |
| << | Zero fill left shift | alle bit zu links schieben. |
| >> | Signed right shift | alle bit zu rechts außer das erste bit. |
| >>> | Zero fill right shift | alle bit zu rechts |
Bitwise AND
Wenn ein bitwise AND auf einem Paar bit durchgeführt wird, gibt es 1 zurück wenn die beide bit 1 sind und umgekehrt gibt es 0 zurück.
Zum Beispiel: Mit 1 bit:
| Operation | Result |
|---|---|
| 0 & 0 | 0 |
| 0 & 1 | 0 |
| 1 & 0 | 0 |
| 1 & 1 | 1 |
Zum Beispiel: mit 4 bit:
| Operation | Result |
|---|---|
| 1111 & 0000 | 0000 |
| 1111 & 0001 | 0001 |
| 1111 & 0010 | 0010 |
| 1111 & 0100 | 0100 |
Bitwise OR:
Wenn ein bitwise OR auf einem Paar bit durchgeführt wird, gibt es 1 zurück wenn ein der bits 1 ist und umgekehrt gibt es 0 zurück.
Zum Beispiel mit 1 bit:
| Operation | Result |
|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 1 |
Zum Beispiel mit 4 bit:
| Operation | Result |
|---|---|
| 1111 | 0000 | 1111 |
| 1111 | 0001 | 1111 |
| 1111 | 0010 | 1111 |
| 1111 | 0100 | 1111 |
Bitwise XOR
Wenn ein bitwise XOR auf ein Paar bit durchgeführt wird, gibt es 1 zurück wenn die bit sich ändern und umgekehrt gibt es 0 zurück.
Zum Beispiel mit 1 bit:
| Operation | Result |
|---|---|
| 0 ^ 0 | 0 |
| 0 ^ 1 | 1 |
| 1 ^ 0 | 1 |
| 1 ^ 1 | 0 |
Zum Beispiel mit 4 bit:
| Operation | Result |
|---|---|
| 1111 ^ 0000 | 1111 |
| 1111 ^ 0001 | 1110 |
| 1111 ^ 0010 | 1101 |
| 1111 ^ 0100 | 1011 |
Bitwise NOT
Wenn ein Bitwise NOT benutzt wird, dreht es alle bit um. 1 zu 0, und 0 zu 1.
Zum Beispiel mit 1 bit:
| Operation | Result |
|---|---|
| ~ 0 | 1 |
| ~ 1 | 0 |
Zum Beispiel mit 4 bit:
| Operation | Result |
|---|---|
| ~ 0000 | 1111 |
| ~ 0001 | 0001 |
| ~ 0010 | 1101 |
| ~ 1100 | 0011 |
Die unterschiedlichen Sprachen können vielen Datentypen um die Zahl zu bezeichnen.
- Java: byte, short, int, long, double.
- C#: byte, sbyte, short, ushort, int, uint, long, ulong, float, double
- Javascript: double
- .....
Javascript speichert die Zahlen wie 64 bits floating point numbers. Aber die Operations bitwise werden auf die 32 bit Integer durchgeführt. In die anderen Sprachen wie Java, C#,.. werden die Operations bitwise auf die 32 bit Integer durchgeführt.
So müssen Sie vor der Durchführung der Operation bitwise mit der Zahlen jede Zahl zu einer 32 Binärzahlen Reihe umwandeln.
| Base 10 | Base 2 | 32 bits |
| 5 | 101 | 00000000000000000000000000000101 |
| 218 | 11011010 | 00000000000000000000000011011010 |
In Javascript hilft das Method toString(base) Ihnen bei der Umwandlung einer Zahl vom Basis 10 zu anderem Basis.
toString-base-example.js (Javascript)
let a = 8;
// Base 2 string.
console.log( a.toString(2) );// 1000
// Base 8 string
console.log( a.toString(8) ); // 10
// Base 16 string
console.log( a.toString(16) ); // 8
let b = 218;
// Base 2 string.
console.log( b.toString(2) );// 11011010
// Base 8 string
console.log( b.toString(8) ); // 332
// Base 16 string
console.log( b.toString(16) ); // da
Zum Beispiel:
| Decimal | Binary |
|---|---|
| 5 | 00000000000000000000000000000101 |
| 1 | 00000000000000000000000000000001 |
| 5 & 1 = 1 | 00000000000000000000000000000001 |
| 5 | 1 = 5 | 00000000000000000000000000000101 |
| 5 ^ 1 = 4 | 00000000000000000000000000000100 |
| ~ 5 = -6 | 11111111111111111111111111111010 |
Achtung: Unter 32 bit wird das erste bit verwendet um die Zeichen (sign) der Zahl festzulegen. Wenn das bit 1 ist, entspricht es das Zeichen ( - ), wenn das bit 0 ist, entspricht es das Zeichen ( + )
Bitwise Left Shift (<<)
| Decimal | Binary |
|---|---|
| 5 | 00000000000000000000000000000101 |
| 5 << 1 = 10 | 00000000000000000000000000001010 |
| 5 << 2 = 20 | 00000000000000000000000000010100 |
Die Operation Bitwise Left Shift ( << ) kann das Zeichen der Zahl ändern.
(Javascript code)
console.log( 1073741824 << 1); // -2147483648
console.log( 2684354560 << 1); // 1073741824
Bitwise Right Shift (>>) [Unsigned Right Shift]
| Decimal | Binary |
|---|---|
| 29 | 00000000000000000000000000011101 |
| 29 >> 1 = 14 | 00000000000000000000000000001110 |
| 29 >> 2 = 7 | 00000000000000000000000000000111 |
Die Operation Bitwise Right Shift ( >> ) ändert das Zeichen der Zahl nicht denn das erste bit wird nicht bewegt.
Bitwise Right Shift (>>>) [Zero fill right Shift]
Die Operation Bitwise Right Shift ( >>> ) kann das Zeichen der Zahl ändern.
(Javascript Code)
console.log( -1073741824 >>> 1); // 1610612736
console.log( 1073741824 >>> 1); // 536870912
Die Operation bitwise wird durch den Verarbeiter (processor) des Computer direkt unterstützt so sie läuft sehr schnell. Unten liste ich einige Beispiele über die Verwendung dieser Operationen .
Die Operations bitweise auf die Strings (characters) in die Sprache Java, C#, C/C++ ... verwenden. Achtung: einige Sprachen wie Javascript unterstützt die Operation bitwise mit dem Typ String nicht.
Eine Großschrift (Uppercase) zu einer Kleinschrift (Lowercase) wechseln:
// Rule: x | ' '
('A' | ' ') ==> 'a'
('B' | ' ') ==> 'b'
('a' | ' ') => 'a'
Die Kleinschrift (Lowercase) zu der Großschrift (Uppercase) wechseln:
// Rule: x & '_'
('a' & '_') ==> 'A'
('b' & '_') ==> 'B'
('A' & '_') ==> 'A'
Die Großschrift zu der Kleinschrit, Die Kleinschrift zu der Großklein umkehren:
// Rule: x ^ ' '
('a' ^ ' ') ==> 'A'
('A' ^ ' ') ==> 'a'
Die Position der Buchstabe Latin (nur für die Großschrift anwenden) sehen
// Rule: x & '?'
'A' & '?' ==> 1
'B' & '?' ==> 2
...
'Z' & '?' ==> 26
// Rule: x ^ '@'
'A' ^ '@' ==> 1
'B' ^ '@' ==> 2
...
'Z' ^ '@' ==> 26
Die Position der Buchstabe Latin (nur für die Kleinschrift anwenden) sehen
// Rule: x ^ '`'
'a' ^ '`' ==> 1
'b' ^ '`' ==> 2
...
'z' ^ '`' ==> 26
// '`' : binary ( 1100000 ), hex('60'), chr(96)
Die Position der Buchstabe Latin sehen, für die Kleinschrift und die Großschrift anwenden:
// Rule: x & '\u001F'
'A' & '\u001F' ==> 1
'B' & '\u001F' ==> 2
...
'Z' & '\u001F' ==> 26
'A' & '\u001F' ==> 1
'B' & '\u001F' ==> 2
...
'Z' & '\u001F' ==> 26
*
