Le titre peut donner l'impression qu'il n'y a qu'une blague qui vous attend ici (un désastre SEO, je sais). Désolé de décevoir. Cet article concerne en fait les opérateurs d'affectation logique de JavaScript introduits dans ES2021. Lisez la suite pour découvrir ce que George et Robert ont à voir avec cela...

Contexte historique

Les opérateurs d'affectation logique sont essentiellement un mélange de logique booléenne et d'opération d'affectation. Mais ces composants contiennent bien plus que ce que l’on pourrait penser au départ.

D'une part, de nombreux développeurs, sinon la plupart, ne réalisent peut-être pas à quel point la logique booléenne est profondément ancrée dans le tissu informatique moderne. Cela s'étend des circuits informatiques aux instructions conditionnelles dans votre code.

Nous utilisons également le signe égal tous les jours, souvent sans y réfléchir sérieusement. Ce symbole, désormais crucial en mathématiques et en codage, a été inventé à des fins mathématiques au XVIe siècle. Environ 400 ans plus tard, dans les années 1950, il a trouvé sa place dans la programmation informatique.

Si ce contexte historique ne vous semble pas du tout intéressant, n'hésitez pas à passer directement à la section Comprendre les opérateurs d'affectation logique. Sinon, rejoignez-moi pour un bref voyage dans le temps.

Georges Boole

Les premières études sur la logique sont attribuées aux Grecs anciens, en particulier à Aristote, qui est souvent appelé le « Père de la logique ». Il a développé un système formel de logique qui a jeté les bases de l'utilisation d'opérateurs logiques.

Le véritable fondement mathématique des opérateurs logiques tels que nous les connaissons aujourd'hui a commencé à prendre forme avec l'avènement de la logique symbolique au XIXe siècle. Il utilise des symboles pour représenter des formes et des structures logiques, ce qui permet un raisonnement plus complexe et abstrait.

George Boole, mathématicien et logicien anglais du XIXe siècle, dans son ouvrage fondateur « Les lois de la pensée » (1854), a introduit une approche algébrique de la logique. Ici, les valeurs peuvent être vraies ou fausses, et des opérations peuvent être effectuées sur ces valeurs, analogues aux opérations algébriques. Ce système comprenait les opérateurs logiques de base :

• ET (conjonction)
• OU (disjonction)
• PAS (négation)

S'appuyant sur les travaux de Boole, d'autres mathématiciens et logiciens ont élargi la portée et la profondeur de la logique symbolique. Et au milieu du XXe siècle, elle a trouvé un terrain nouveau et fertile dans le domaine émergent de l’informatique. La nature binaire de la logique booléenne s'est avérée parfaitement adaptée aux circuits numériques au cœur des ordinateurs, où les données pouvaient être représentées par une série de 0 et de 1, et où les opérateurs logiques pouvaient contrôler le flux de ces données.

Les opérateurs logiques sont devenus un élément fondamental des langages de programmation, permettant la construction d'une logique informatique complexe et de processus de prise de décision dans les logiciels. Aujourd'hui, ils font partie intégrante de la syntaxe de presque tous les langages de programmation.

Robert Recordé

Le signe égal a été introduit en 1557 par le mathématicien gallois Robert Recorde dans son livre "La pierre à aiguiser de Witte". Recorde en a eu assez d'écrire « est égal à » à plusieurs reprises dans son travail, il a donc choisi deux lignes parallèles de même longueur comme symbole d'égalité. Comme il l'a dit, c'était parce que « deux choses ne peuvent pas être plus égales ». Il s'agissait d'un développement important dans la notation mathématique, offrant un moyen concis et clair d'exprimer l'égalité.

Au début de la programmation, en particulier avec le code machine et les langages d'assemblage, le concept d'« affectation » concernait davantage le stockage et le déplacement de données entre les registres et les emplacements mémoire. Les instructions ont été données à l'aide d'opcodes spécifiques qui ordonnaient à la machine d'effectuer ces opérations.

À mesure que les langages de programmation de haut niveau étaient développés, il devenait nécessaire de trouver une manière plus abstraite et plus lisible par l'homme de représenter l'opération d'attribution de valeurs aux variables. Cela a conduit à l'adoption du signe égal comme opérateur d'affectation dans de nombreuses langues, à commencer par le FORTRAN dans les années 1950.

L'utilisation de = pour l'affectation a créé une certaine ambiguïté avec sa signification mathématique d'égalité. Cela a abouti à l'introduction de différents symboles pour clarifier l'intention dans la programmation :

• Algol, développé dans les années 1960, a introduit le symbole := pour l'affectation, le distinguant de la comparaison d'égalité.
• C a ensuite popularisé l'utilisation de = pour l'affectation et de == pour les tests d'égalité, une convention que de nombreux langages ultérieurs ont suivie.

Au fil du temps, les langages de programmation ont introduit diverses formes d'opérateurs d'affectation pour gérer efficacement différentes opérations, tels que les opérateurs d'affectation composés ( =, -=, etc.) et, plus récemment, les opérateurs d'affectation logique en JavaScript.

Comprendre les opérateurs d'affectation logique

Les opérateurs d'affectation logique sont du sucre syntaxique en JavaScript qui combinent l'affectation (=) avec un opérateur de fusion logique (&&, ||) ou nul (??). Il existe trois types :

• Affectation ET logique (&&=) : attribue la valeur de droite à la variable de gauche uniquement si la variable de gauche est véridique.
• Affectation OU logique (||=) : attribue la valeur de droite à la variable de gauche uniquement si la variable de gauche est fausse.
• Affectation de fusion nulle (??=) : attribue la valeur de droite à la variable de gauche uniquement si la variable de gauche est nulle ou non définie.

Affectation ET logique (&&=)

L'opérateur &&= est un raccourci permettant de définir la valeur d'une variable uniquement si elle contient actuellement une valeur véridique. C'est particulièrement utile dans les scénarios où une action ne doit se poursuivre que si une certaine condition reste vraie.

Exemple de cas d'utilisation : basculement de fonctionnalités

Imaginez un scénario dans lequel certaines fonctionnalités ne devraient être activées que pour les administrateurs :

const isAdmin = user.isAdmin();
let canAccessDashboard = isAdmin;

canAccessDashboard &&= user.isAuthenticated();
console.log(canAccessDashboard); // true if user is authenticated, otherwise false

Cet extrait de code garantit que canAccessDashboard n'est vrai que si isAdmin et user.isAuthenticated() sont tous deux vrais, protégeant ainsi la fonctionnalité derrière deux conditions.

Affectation OU logique (||=)

L'opérateur ||= vous permet d'attribuer une valeur à une variable si la variable contient actuellement une valeur fausse (par exemple, null, non défini, 0, false, ""). Ceci est incroyablement utile pour définir les valeurs par défaut.

Exemple de cas d'utilisation : définition des valeurs par défaut

const userSettings = {
  theme: null,
};

// Set default theme if none is specified
userSettings.theme ||= "dark";
console.log(userSettings.theme); // Outputs 'dark'

Cet opérateur est idéal pour initialiser des variables qui n'ont pas été définies, garantissant que votre application utilise une valeur par défaut raisonnable sans écraser des valeurs fausses potentiellement significatives comme 0 ou false.

Affectation de fusion nulle (??=)

Le ?? L’opérateur de coalescence nul, connu sous le nom d’opérateur de coalescence nulle, est un ajout relativement récent aux langages de programmation. Ce n'est pas un opérateur d'affectation logique au sens strict, même si la spécification ES2021 le classe comme tel, puisqu'il n'est pas basé sur un opérateur logique. Au lieu de cela, son développement est plus étroitement lié aux besoins pratiques de la programmation, en particulier dans la gestion des valeurs nulles et indéfinies de manière propre et prévisible.

L'opérateur ??= est utilisé pour attribuer une valeur à une variable si et seulement si la variable est actuellement nulle ou indéfinie. C'est plus précis que l'opérateur ||=, qui prend également en compte d'autres valeurs fausses.

Exemple de cas d'utilisation : paramètres de configuration par défaut

const config = {
  timeout: 0,
};

config.timeout ??= 5000; // Set default timeout if not specified, i.e. undefined, or null
console.log(config.timeout); // Outputs 0, preserving the explicitly set falsy value

Cet opérateur est particulièrement utile dans les configurations et les paramètres où les valeurs par défaut ne doivent remplir que les valeurs manquantes sans remplacer d'autres paramètres faux mais valides comme 0.

Avantages et considérations pratiques

L'utilisation d'opérateurs d'affectation logique, au lieu d'instructions if ou ternaires, réduit la quantité de code que vous devez écrire et peut rendre vos intentions plus claires pour les autres développeurs. Comme pour de nombreuses fonctionnalités, la clé est d'utiliser ces opérateurs judicieusement, en particulier lorsqu'il s'agit de valeurs fausses valides dans le contexte de votre code.

Note supplémentaire

Il existe d'autres opérateurs d'affectation en JavaScript, comme l'opérateur d'affectation de décalage vers la gauche (

(Image de couverture en haut par starline sur Freepik)