JavaScript Opérateurs binaires


Exemple

Les opérateurs binaires effectuent des opérations sur les valeurs de bit des données. Ces opérateurs convertissent les opérandes en entiers signés de 32 bits en complément à deux .

Conversion en entiers 32 bits

Les nombres de plus de 32 bits rejettent leurs bits les plus significatifs. Par exemple, le nombre entier suivant de plus de 32 bits est converti en un entier de 32 bits:

Before: 10100110111110100000000010000011110001000001
After:              10100000000010000011110001000001

Complément à deux

En binaire normale , nous trouvons la valeur binaire en ajoutant les 1 « s en fonction de leur position de puissances de 2 - Le bit étant plus à droite 2^0 au bit de gauche étant 2^n-1n est le nombre de bits. Par exemple, utiliser 4 bits:

// Normal Binary
// 8 4 2 1
   0 1 1 0  => 0 + 4 + 2 + 0 => 6

Le format de deux compléments signifie que la contrepartie négative du nombre (6 vs -6) correspond à tous les bits d'un nombre inversé, plus un. Les bits inversés de 6 seraient:

// Normal binary
   0 1 1 0
// One's complement (all bits inverted)
   1 0 0 1  => -8 + 0 + 0 + 1 => -7
// Two's complement (add 1 to one's complement)
   1 0 1 0  => -8 + 0 + 2 + 0 => -6

Remarque: L’ajout de 1 à la gauche d’un nombre binaire ne change pas sa valeur en complément de deux. La valeur 1010 et 1111111111010 sont les deux -6 .

Bitwise AND

L'opération AND binaire a a & b renvoie la valeur binaire avec un 1 où les deux opérandes binaires ont 1 dans une position spécifique et 0 dans toutes les autres positions. Par exemple:

13 & 7 => 5
// 13:     0..01101
//  7:     0..00111
//-----------------
//  5:     0..00101 (0 + 0 + 4 + 0 + 1)

Exemple de monde réel: contrôle de parité du numéro

Au lieu de ce "chef-d'œuvre" (malheureusement trop souvent vu dans de nombreuses parties de code réel):

function isEven(n) {
    return n % 2 == 0;
}

function isOdd(n) {
    if (isEven(n)) {
        return false;
    } else {
        return true;
    }
}

Vous pouvez vérifier la parité du nombre (entier) de manière beaucoup plus efficace et simple:

if(n & 1) {
    console.log("ODD!");
} else {
    console.log("EVEN!");
}

Bit à bit OU

L'opération OU bit à bit a | b renvoie la valeur binaire avec un 1 où les opérandes ou les deux opérandes ont 1 dans une position spécifique et 0 lorsque les deux valeurs ont une position 0 . Par exemple:

13 | 7 => 15
// 13:     0..01101
//  7:     0..00111
//-----------------
// 15:     0..01111 (0 + 8 + 4 + 2 + 1)  

Pas au bit

L'opération binaire PAS ~a retourne les bits de la valeur donnée a . Cela signifie que tous les 1 deviendront des 0 et que tous les 0 deviendront des 1 .

~13 => -14
// 13:     0..01101
//-----------------
//-14:     1..10010 (-16 + 0 + 0 + 2 + 0)

Bit par bit XOR

L'opération binaire XOR ( exclusive ou ) a ^ b place un 1 uniquement si les deux bits sont différents. Exclusif ou signifie l'un ou l'autre, mais pas les deux .

13 ^ 7 => 10
// 13:     0..01101
//  7:     0..00111
//-----------------
// 10:     0..01010  (0 + 8 + 0 + 2 + 0)

Exemple de monde réel: permuter deux valeurs entières sans allocation de mémoire supplémentaire

var a = 11, b = 22;
a = a ^ b;
b = a ^ b;
a = a ^ b;
console.log("a = " + a + "; b = " + b);// a is now 22 and b is now 11