Quelle est la valeur la plus élevée du Javascript qui peut être utilisée en toute sécurité dans un masque de bits ?

Question

Imaginons que je veuille créer un masque de bits en Javascript. Je ferais basculer un bit comme ceci :

mask |= (1 << bit);

est un peu clair comme ceci :

mask &= ~(1 << bit);

et vérifier si un bit est défini comme suit :

(bit & mask) != 0

Ma question est la suivante : quel est le nombre de bits le plus sûr sur lequel cela fonctionne en Javascript ? J'ai trois hypothèses principales :

1. 32 bits, car les opérations sur les bits peuvent être indéfinies au-delà de 32 bits
2. 53 bits, comme Number.MAX_SAFE_INTEGER es 2^53 - 1
3. 64 bits, car Javascript utilise 64 bits pour chaque nombre

Laquelle est la bonne ? Ou est-ce autre chose ?

Answer 1

32 bits :

Les opérateurs bitwise traitent leurs opérandes comme un ensemble de 32 bits (zéros et uns) et renvoient des valeurs numériques JavaScript standard.

Spécifications :

6.1.6.1.9 Number::leftShift ( x, y )

1. Soit lnum ! ToInt32(x).
2. Soit rnum ! ToUint32(y).
3. Soit shiftCount le résultat du masquage des 5 bits les moins significatifs de rnum, c'est-à-dire le calcul de rnum & 0x1F.
4. Renvoie le résultat du décalage à gauche de lnum par les bits de shiftCount. Le résultat est un entier signé de 32 bits.

Answer 2

Il convient de noter que si l'on utilise la fonction BigInt Le masque de bits n'est alors limité que par les contraintes de mémoire, de sorte que l'on peut gérer des masques bien au-delà de 32 bits. En suivant généralement les lignes de la question, par exemple, on peut définir un masque de 127 bits à tous les 1 comme suit...

x = ( 1n << 128n ) - 1n

• x : 340282366920938463463374607431768211455n
• x.toString(2) : 11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111

...et ensuite, disons, effacer le bit 16...

x &= ~( 1n << 16n )

• x : 340282366920938463463374607431768145919n
• x.toString(2) : 11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111101111111111111111

...et vérifier si un bit, disons 17, est activé...

( ( 1n << 17n ) & x )== 0n

• vrai

...ou vérifier si le bit 16 est activé...

( ( 1n << 16n ) & x )== 0n

• faux

JavaScript dispose également de la fonction BigUint64Array qui est un tableau typé d'entiers BigInt non signés de 64 bits dans l'ordre des octets de la plate-forme. Il s'agit également d'une option pour les masques de bits de 33 à 64 bits...

Notez que pour les masques BigInt extrêmes, il sera probablement plus performant de gérer un tableau de Uint32 comme masque de bits collectif plutôt que d'utiliser les fonctions natives de manipulation de bits BigInt. Ainsi, si les performances sont en jeu, il faudra expérimenter pour déterminer si les masques de bits BigInt sont acceptables pour le cas d'utilisation en question...