Bitweise Operationen

1- Bitwise

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 | 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 ^ 0 1
1 ^ 1
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

2- Die Operation Bitwise auf die Zähle

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

3- Wofür ist Bitwise ?

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