Nouveaux types de données immuables de JavaScript: enregistrements et tuples

Online Coding Courses for Kids


Nouveaux types de données immuables de JavaScript: enregistrements et tuples

Les enregistrements et les tuples sont de nouveaux types de données immuables JavaScript actuellement à étape 2 du processus d’approbation des normes TC39. Ils sont susceptibles de changer et ne sont actuellement disponibles dans aucun navigateur ou environnement d’exécution, mais les implémentations fonctionnelles devraient arriver dans l’année prochaine. Ils aident à résoudre quelques énigmes déroutantes auxquelles sont confrontés les codeurs…

Changements constants

Les JavaScript professionnels vous diront que l’attribution de variables avec const est la meilleure pratique dans la mesure du possible. Il fait des variables immuable. Les valeurs ne peuvent pas être modifiées, vous avez donc moins de problèmes à résoudre.

Malheureusement, const rend uniquement les valeurs primitives immuables (String, Number, BigInt, Boolean, Symbol et undefined). Vous ne pouvez pas réaffecter un tableau ou un objet, mais les valeurs et propriétés qu’ils contiennent pouvez être modifié. Par exemple:

// array constant
const myArray = [1, 2, 3];

// change array values
myArray[0] = 99;
myArray.push(42);

console.log(myArray); // [ 99, 2, 3, 42 ]

myArray = 'change'; // ERROR!

De même pour les objets:

// object constant
const myObj = { a: 1, b: 2, c: 3 }

// change object properties
myObj.a = 99;
myObj.d = 42;

console.log(myObj); // { a:99 ,b:2, ,c:3, ,d:42 }

myObj = 'change'; // ERROR!

le Object.freeze() peut aider, mais seul un gel superficiel est appliqué aux propriétés enfants immédiates d’un objet:

const myObj = { a: 1, b: 2, c: { v: 3 } }
Object.freeze(myObj);

myObj.a = 99; // silently ignored
myObj.c.v = 99; // works fine

console.log(myObj); // { a: 1, b: 2, c: { v: 99 } }

Il est donc difficile de garantir qu’une fonction ne modifiera pas intentionnellement ou accidentellement les valeurs contenues dans un tableau ou un objet. Les développeurs doivent soit espérer le meilleur, soit passer une version clonée d’une variable – (qui a ses propres défis).

Inégalité équivalente

Un chaos supplémentaire peut survenir lorsque les développeurs tentent des comparaisons d’objets ou de tableaux apparemment raisonnables:

const str = 'my string';
console.log( str === 'mystring' );  // true

const num = 123;
console.log( num === 123 );         // true

const arr = [1, 2, 3];
console.log( arr === [1, 2, 3] );   // false

const obj = { a: 1 };
console.log( obj === { a: 1 } );    // false

Seuls les types primitifs peuvent être comparés par valeur. Les objets et les tableaux sont passés et comparés par référence. Deux variables ne seront équivalentes que lorsqu’elles pointent vers le même élément en mémoire:

const a = [1, 2];

const b = a;
b.push(3);

console.log( a === b ); // true

// original array has changed
console.log( a ); // [1, 2, 3]

La comparaison approfondie de deux objets ou tableaux nécessite une fonction de comparaison récursive pour évaluer chaque valeur à son tour. Même dans ce cas, vous pouvez rencontrer des problèmes avec des types tels que des dates ou des fonctions qui pourraient être stockés de différentes manières.

continuer la lecture
Nouveaux types de données immuables de JavaScript: enregistrements et tuples
sur SitePoint.

Close Menu