Où voudrais-je utiliser un opérateur au niveau du bit en JavaScript?

Exemple:

Analyse valeur hexadécimale pour obtenir les valeurs de couleurs RVB.

var hex = 'ffaadd';
var rgb = parseInt(hex, 16); //rgb is 16755421


var red   = (rgb >> 16) & 0xFF; //returns 255
var green = (rgb >> 8) & 0xFF;  //170
var blue  = rgb & 0xFF;     //221  

En JavaScript, vous pouvez utiliser une double négation binaire (~~n) comme un remplacement pour Math.floor(n) (si n est un nombre positif) ou parseInt(n, 10) (même si n est négatif). n|n et n&n toujours obtenir les mêmes résultats que ~~n.

var n = Math.PI;
n; //3.141592653589793
Math.floor(n); //3
parseInt(n, 10); //3
~~n; //3
n|n; //3
n&n; //3
//~~n works as a replacement for parseInt() with negative numbers…
~~(-n); //-3
(-n)|(-n); //-3
(-n)&(-n); //-3
parseInt(-n, 10); //-3
//…although it doesn’t replace Math.floor() for negative numbers
Math.floor(-n); //-4

Une seule négation binaire (~) calcule -(parseInt(n, 10) + 1), de sorte que deux au niveau du bit négations sera de retour -(-(parseInt(n, 10) + 1) + 1).

Il convient de noter que de ces trois solutions, n|n qui semble être le plus rapide.

Mise à jour: Plus précise des repères ici: http://jsperf.com/rounding-numbers-down

(Posté sur Plus étrange langage)

Donné les avancées de Javascript est de faire (surtout avec nodejs qui permet la programmation côté serveur avec js), il est de plus en plus complexes et code en JS. Voici quelques cas où j'ai utilisé les opérateurs au niveau du bit:

• Adresse IP opérations:

  //computes the broadcast address based on the mask and a host address
  broadcast = (ip & mask) | (mask ^ 0xFFFFFFFF)
  //converts a number to an ip adress 
  sprintf(ip, "%i.%i.%i.%i", ((ip_int >> 24) & 0x000000FF),
  ((ip_int >> 16) & 0x000000FF),
  ((ip_int >>  8) & 0x000000FF),
  ( ip_int        & 0x000000FF));

Note: ceci est un code en C, mais le JS est presque identique

• CRC algorithmes utilise beaucoup

Découvrez la l'entrée de wikipedia sur ce

• La résolution de l'écran opérations

Quelques autres exemples de la façon d'utiliser not au niveau du bit et double not au niveau du bit:

Sol

~~2.5    //2
~~2.1    //2
~~(-2.5) //-2

Vérifier si indexOf retourné à -1 ou non

var foo = 'abc';
!~foo.indexOf('bar'); //true

var arr = ['abc', 'xyz']

Ennuyé pour écrire

if (arr.indexOf('abc') > -1) {
//'abc' is in arr
}
if (arr.indexOf('def') === -1) {
//'def' is not in arr
}

pour vérifier si quelque chose est à l'intérieur d'un tableau?

Vous pouvez utiliser l'opérateur au niveau du bit ~ comme suit:

if (~arr.indexOf('abc')) {
//'abc' is in arr
}
if (! ~arr.indexOf('def')) {
//'def' is not in arr
}

Je l'ai utilisé une fois pour un les autorisations de widget. Des autorisations de fichier unix sont un masque de bits, donc, pour l'analyser, vous devez utiliser les opérations sur les bits.

Cette réponse contient des explications de Marc réponse.

Par la lecture de ces explications et l'exécution du fragment de code suivant, une idée peut être acquise.

JS:

var hex = 'ffaadd';
var rgb = parseInt(hex, 16); //rgb value is 16755421 in decimal = 111111111010101011011101 in binary = total 24 bits
var red   = (rgb >> 16) & 0xFF; //returns 255
var green = (rgb >> 8) & 0xFF;  //returns 170
var blue  = rgb & 0xFF;         //returns 221  
//HOW IS IT
//There are two bitwise operation as named SHIFTING and AND operations.
//SHIFTING is an operation the bits are shifted toward given direction by adding 0 (zero) bit for vacated bit fields.
//AND is an operation which is the same with multiplying in Math. For instance, if 9th bit of the given first bit-set is 0
//and 9th bit of the given second bit-set is 1, the new value will be 0 because of 0 x 1 = 0 in math.
//0xFF (000000000000000011111111 in binary) - used for to evaluate only last 8 bits of a given another bit-set by performing bitwise AND (&) operation. 
//The count of bits is 24 and the first 16 bits of 0xFF value consist of zero (0) value. Rest of bit-set consists of one (1) value.
console.log("0xFF \t\t\t\t: ", 0xFF) 
//111111111010101011011101 -> bits of rgb variable
//000000000000000011111111 -> 255 after (rgb >> 16) shifting operation
//000000000000000011111111 -> 255 complement (changes the first 16 bits and does nothing for the last 8 bits)
//000000000000000011111111 -> result bits after performing bitwise & operation
console.log("Red - (rgb >> 16) & 0xFF \t: ", (rgb >> 16) & 0xFF) //used for to evaluate the first 8 bits
//111111111010101011011101 -> bits of rgb variable
//000000001111111110101010 -> 65450 -> 'ffaa'
//000000000000000011111111 -> 255 complement (changes the first 16 bits and does nothing for the last 8 bits)
//000000000000000010101010 -> result bits after performing bitwise & operation
//calculation -> 000000001111111110101010 & 000000000000000011111111 = 000000000000000010101010 = 170 in decimal = 'aa' in hex-decimal
console.log("Green - (rgb >> 8) & 0xFF \t: ", (rgb >> 8) & 0xFF) //used for to evaluate the middle 8 bits 
//111111111010101011011101 -> 'ffaadd'
//000000000000000011111111 -> 255 complement (changes the first 16 bits and does nothing for the last 8 bits)
//000000000000000011011101 -> result bits after performing bitwise & operation 
//calculation -> 111111111010101011011101 & 000000000000000011111111 = 221 in decimal = 'dd' in hex-decimal
console.log("Blue - rgb & 0xFF \t\t: ", rgb & 0xFF) ////used for to evaluate the last 8 bits.
console.log("It means that `FFAADD` hex-decimal value specifies the same color with rgb(255, 170, 221)")
/* console.log(red)
console.log(green)
console.log(blue) */

Exemple à l'aide de Node.js

En supposant que vous avez eu un fichier (appelé multiply.js) avec ces contenus, vous pouvez exécuter

`node multiply <number> <number>`

et obtenir un résultat cohérent avec l'aide de l'opérateur de multiplication sur les deux mêmes numéros. Le décalage de bits se passe dans le Mulitply fonction est un exemple de la façon de prendre le masque de bits représentant le nombre et l'utiliser pour inverser les bits dans un autre numéro pour les opérations rapides.

var a, b, input = process.argv.slice(2);
var printUsage = function() {
console.log('USAGE:');
console.log('  node multiply <number> <number>');
}
if(input[0] === '--help') {+
printUsage();
process.exit(0);
}
if(input.length !== 2) {
printUsage();
process.exit(9);
}
if(isNaN(+input[0]) || isNaN(+input[1])) {
printUsage();
process.exit(9);
}
//Okay, safe to proceed
a = parseInt(input[0]),
b = parseInt(input[1]);
var Multiply = function(a,b) {
var x = a, y = b, z = 0;
while( x > 0 ) {
if(x % 2 === 1) {
z = z + y;
}
y = y << 1;
x = x >> 1;
}
return z;
}
var result = Multiply(a,b);
console.log(result);