Recherche…
Opérateurs binaires
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-1 où n 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
Opérateurs de poste
Le décalage binaire peut être considéré comme «déplaçant» les bits à gauche ou à droite, ce qui modifie la valeur des données utilisées.
Décalage à gauche
L'opérateur de décalage de gauche (value) << (shift amount) décale les bits vers la gauche des bits (shift amount) ; les nouveaux bits venant de la droite seront les 0 :
5 << 2 => 20
// 5: 0..000101
// 20: 0..010100 <= adds two 0's to the right
Décalage à droite ( propagation de signe )
L'opérateur de décalage vers la droite (value) >> (shift amount) est également appelé «décalage vers la droite de propagation de signe», car il conserve le signe de l'opérande initiale. L'opérateur de décalage vers la droite décale la value du shift amount de bits de shift amount spécifié shift amount la droite. Les bits excédentaires décalés à droite sont supprimés. Les nouveaux bits provenant de la gauche seront basés sur le signe de l’opérande initiale. Si le bit le plus à gauche était 1 les nouveaux bits seront tous 1 et vice-versa pour les 0 .
20 >> 2 => 5
// 20: 0..010100
// 5: 0..000101 <= added two 0's from the left and chopped off 00 from the right
-5 >> 3 => -1
// -5: 1..111011
// -2: 1..111111 <= added three 1's from the left and chopped off 011 from the right
Right Shift ( remplissage à zéro )
L'opérateur de décalage à droite à remplissage zéro (value) >>> (shift amount) déplacera les bits vers la droite et les nouveaux bits seront à 0 . Les 0 sont décalés de la gauche et les bits excédentaires à droite sont décalés et supprimés. Cela signifie qu'il peut faire des nombres négatifs en positifs.
-30 >>> 2 => 1073741816
// -30: 111..1100010
//1073741816: 001..1111000
Un décalage vers la droite et un décalage vers la droite se propageant à zéro donnent le même résultat pour les nombres non négatifs.