Opérateurs binaire exemple concret

Une vidéo de Grafikart m’a inspiré pour un besoin que j’avais en javascript pour stocker en base les horaires cron des utilisateurs pour déclencher des alarmes.

// ex. Le nombre binaire 000000000000000001000000 est équivalent à l'entier 64.
// getChoices(64) donnera donc [ 7 ]
// Le nombre binaire 000000000000000001000001 est équivalent à l'entier 65.
// getChoices(65) donnera donc [ 1, 7 ]
function getChoices(number) {
    let choices = [];
    let position = 1;

    while (number > 0) {
        // Si le bit de poids faible est 1, ajoutez la position à la liste des choix
        if ((number & 1) === 1) {
            choices.push(position);
        }

        // Décalez les bits vers la droite et passez à la position suivante
        number >>= 1;
        position++;
    }

    return choices;
}
// fonction inverse, on donne le tableau en entrée pour donner l'entier correspondants des heures
// getNumber( [1, 7] ) donnera 65
function getNumber(choices) {
    let number = 0;
    for (let i = 0; i < choices.length; i++) {
        let position = choices[i];
        // Définir le bit à la position spécifiée à 1
        number |= 1 << (position - 1);
    }
    return number;
}

Les sources :

Lien MDN Javascript Grafikart opérateurs binaires

Opérateurs binaires

Un opérateur binaire traite les opérandes comme des suites de 32 bits (des zéros ou des uns) plutôt que comme des nombres décimaux, hexadécimaux et octaux. Ainsi, le nombre décimal 9 se représente en binaire comme 1001. Les opérateurs binaires effectuent leur opération sur des représentations binaires et renvoient des valeurs numériques.

Le tableau qui suit détaille les opérateurs binaires JavaScript.

Opérateur	Utilisation	Description
ET binaire	`a & b`	Renvoie un à chaque position pour laquelle les bits des deux opérandes valent un.
OU binaire	`a \| b`	Renvoie un zéro à chaque position pour laquelle les bits des deux opérandes valent zéro.
OU exclusif binaire	`a ^ b`	Renvoie un zéro à chaque position pour laquelle les bits sont les mêmes. [Renvoie un à chaque position où les bits sont différents.]
NON binaire	`~ a`	Inverse les bits de l'opérande.
Décalage à gauche	`a << b`	Décale la représentation binaire de `a` de `b` bits vers la gauche, en ajoutant des zéros à droite.
Décalage à droite avec propagation du signe	`a >> b`	Décale la représentation binaire de `a` de `b` bits vers la droite, enlevant les bits en trop.
Décalage à droite avec remplissage à zéro	`a >>> b`	Décale la représentation binaire de `a` de `b` bits vers la droite, enlevant les bits en trop et en ajoutant des zéros à gauche.

Opérateurs binaires logiques

Les opérateurs logiques binaires fonctionnent de la façon suivante :

Les opérandes sont convertis en entiers sur 32 bits. Pour les nombres dont la valeur binaire dépasse 32 bits, les bits les plus hauts sont abandonnés. Ainsi, l'entier suivant sur plus de 32 bits sera converti en entier sur 32 bits :
```
Avant : 1110 0110 1111 1010 0000 0000 0000 0110 0000 0000 0001
Après :                1010 0000 0000 0000 0110 0000 0000 0001
```
Chaque bit du premier opérande est associé au bit correspondant du second opérande : le premier bit avec le premier bit, le second avec le second et ainsi de suite.
L'opérateur est appliqué sur chaque paire ainsi constituée et le résultat est construit en binaire.

Par exemple, la représentation binaire du nombre décimal 9 est 1001, et celle du nombre décimal 15 est 1111. Aussi, quand on utilise les opérateurs binaires sur ces valeurs, on a les résultats suivants :

Expression	Résultat	Description binaire
`15 & 9`	`9`	`1111 & 1001 = 1001`
`15 \| 9`	`15`	`1111 \| 1001 = 1111`
`15 ^ 9`	`6`	`1111 ^ 1001 = 0110`
`~15`	`-16`	`~ 0000 0000 … 0000 1111 = 1111 1111 … 1111 0000`
`~9`	`-10`	`~ 0000 0000 … 0000 1001 = 1111 1111 … 1111 0110`

On notera que tous les 32 bits sont inversés lors de l'utilisation de l'opérateur NON binaire et que les valeurs avec le bit le plus à gauche à 1 représentent des valeurs négatives (représentation en complément à deux). Aussi, l'évaluation de ~x fournira la même valeur que -x - 1.

Opérateurs de décalage binaire

Les opérateurs de décalage binaire utilisent deux opérandes : celui de gauche est la quantité sur laquelle effectuer le décalage et celui de droite indique le nombre de bits à décaler. La direction de l'opération de décalage dépend de l'opérateur utilisé.

Les opérateurs de décalage convertissent leurs opérandes en entiers sur 32 bits et renvoient un résultat de type Number ou BigInt selon la règle suivante : si l'opérande gauche est de type BigInt, la valeur de retour sera de type BigInt et sinon, la valeur de retour sera de type Number.

Les opérateurs de décalage sont listés dans le tableau suivant.

Opérateurs de décalage binaire
Opérateur	Description	Exemple
Décalage à gauche (`<<`)	Cet opérateur décale la valeur du premier opérande du nombre de bits indiqué vers la gauche. Les bits en trop sont abandonnés et des bits à 0 sont ajoutés sur la droite.	`9<<2` donne `36`, car `1001`, décalé de 2 bits à gauche vaut `100100` en binaire, ce qui correspond à `36` en décimal.
Décalage à droite avec propagation du signe (`>>`)	Cet opérateur décale la valeur du premier opérande du nombre de bits indiqué vers la droite. Les bits en trop à droite sont abandonnés. Des copies du bit le plus à gauche sont ajoutés sur la gauche.	`9>>2` donne `2`, car `1001` décalé de 2 bits à droite vaut `10` en binaire, ce qui correspond à `2` en décimal. De même, `-9>>2` donne `-3`, car le signe est conservé.
Décalage à droite avec remplissage à zéro (`>>>`)	Cet opérateur décale la valeur du premier opérande du nombre de bits indiqué vers la droite. Les bits en trop à droite sont abandonnés. Des bits à zéro sont ajoutés sur la gauche.	`19>>>2` donne `4`, car `10011` décalé de deux bits à droite devient `100` en binaire, ce qui vaut `4` en décimal. Pour les valeurs positives, le décalage à droite avec remplissage à zéro et le décalage à droite avec propagation du signe fourniront le même résultat.