Où devrais-je utiliser un opérateur de bitwise en JavaScript?

Question

J'ai lu ce (http://stackoverflow.com/quest...), donc je sais ce que les opérateurs sur les bits mais je ne suis toujours pas clair sur la façon dont on peut les utiliser... quelqu'un Peut-il offrir à tous des exemples du monde réel de l'endroit où un opérateur au niveau du bit serait utile en JavaScript?

Merci.

Edit:

Juste de creuser dans le jQuery source , j'ai trouvé quelques endroits où les opérateurs sur les bits sont utilisés, par exemple: (uniquement l'opérateur&)

// Line 2756:
event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));

// Line 2101
var ret = a.compareDocumentPosition(b) & 4 ? -1 : a === b ? 0 : 1;

Answer 1

Exemple:

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

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

var red   = (rgb >> 16) & 0xFF;
var green = (rgb >> 8) & 0xFF;  
var blue  = rgb & 0xFF;
 

Answer 2

J'ai fortement l'utilisation opérateurs au niveau du bit pour les conversions dans la production de scripts, parce que parfois ils sont beaucoup plus rapides que leurs Math ou parseInt équivalents.

Le prix que j'ai payer est la lisibilité du code. Donc, j'utilise généralement des Math dans le développement et bit à bit dans la production.

Vous pouvez trouver quelques astuces sur la performance jsperf.com.

Comme vous pouvez le voir, les navigateurs ne pas optimiser Math.ceil et parseInt pendant des années, j'ai donc prévoir au niveau du bit sera plus rapide et plus courte façon de faire les choses dans furure ainsi.

Quelques lectures complémentaires sur le sujet DONC...

---

Bonus: feuille de triche pour | 0 : un moyen facile et rapide de convertir tout entier:

(désolé pour la russie commentaires, google translate peut vous aider)

( 3|0 ) === 3;             // целые числа не изменяет
( 3.3|0 ) === 3;           // у дробных чисел отбрасывает дробную часть
( 3.8|0 ) === 3;           // не округляет, а именно отбрасывает дробную часть
( -3.3|0 ) === -3;         // в том числе и у отрицательных дробных чисел
( -3.8|0 ) === -3;         // у которых Math.floor(-3.3) == Math.floor(-3.8) == -4
( "3"|0 ) === 3;           // строки с числами преобразуются к целым числам
( "3.8"|0 ) === 3;         // при этом опять же отбрасывается дробная часть
( "-3.8"|0 ) === -3;       // в том числе и у отрицательных дробных чисел
( NaN|0 ) === 0;           // NaN приводится к нулю
( Infinity|0 ) === 0;      // приведение к нулю происходит и с бесконечностью,
( -Infinity|0 ) === 0;     // и с минус бесконечностью,
( null|0 ) === 0;          // и с null,
( (void 0)|0 ) === 0;      // и с undefined,
( []|0 ) === 0;            // и с пустым массивом,
( [3]|0 ) === 3;           // но массив с одним числом приводится к числу,
( [-3.8]|0 ) === -3;       // в том числе с отбрасыванием дробной части,
( [" -3.8 "]|0 ) === -3;   // и в том числе с извлечением чисел из строк,
( [-3.8, 22]|0 ) === 0     // но массив с несколькими числами вновь зануляется
( {}|0 ) === 0;                // к нулю также приводится пустой объект
( {'2':'3'}|0 ) === 0;         // или не пустой
( (function(){})|0 ) === 0;    // к нулю также приводится пустая функция
( (function(){ return 3;})|0 ) === 0;

et un peu de magie pour moi:

3 | '0px' === 3;

Answer 3

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 donnent toujours les mêmes résultats qu' ~~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 semble être le plus rapide.

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

(Posté sur les plus Étranges pour le langage)

Answer 4

Étant 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:

• L'adresse IP de l'exploitation:

  //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 des algorithmes utilise beaucoup

Découvrez l' article de wikipédia sur ce

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

Answer 5

Vous pouvez les utiliser pour renverser une valeur booléenne:

 var foo = 1;
var bar = 0;
alert(foo ^= 1);
alert(bar ^= 1);
 

C'est un peu idiot et pour la plupart des opérateurs au niveau des bits n'ont pas beaucoup d'applications en Javascript.