Estructuras de datos inmutables: una nueva característica en ECMAScript 2024

ECMAScript 2024 presenta varias actualizaciones interesantes, pero una característica que me destaca es la introducción de estructuras de datos inmutables. Estas nuevas estructuras (registros y tuplas) cambian las reglas del juego para administrar datos en JavaScript. Ofrecen una forma satisfactoria de mantener nuestros datos sólidos, seguros y consistentes, lo cual es de suma importancia cuando queremos aplicaciones confiables que podamos mantener fácilmente. He aquí por qué las estructuras de datos inmutables son tan interesantes y cómo utilizarlas de forma más eficaz.

¿Qué son los registros y las tuplas?

Los registros y tuplas son nuevas estructuras de datos que son inmutables por diseño. Esto significa que una vez que crea un Registro o Tupla, su contenido no se puede cambiar. Cualquier intento de modificarlos da como resultado la creación de una nueva instancia, mientras que la original permanece sin cambios. Esta inmutabilidad ayuda a prevenir efectos secundarios no deseados y hace que su código sea más predecible.

¿Por qué utilizar estructuras de datos inmutables?

• Previsibilidad: Las estructuras de datos inmutables hacen que sea más fácil razonar sobre tu código porque sabes que una vez que se configuran los datos, no se cambiarán accidentalmente en ninguna otra parte de tu aplicación.
• Depuración: Con la inmutabilidad, evita problemas relacionados con la modificación inesperada de datos, lo que simplifica la depuración.
• Programación funcional: Los datos inmutables encajan bien con los paradigmas de programación funcional, donde las funciones evitan efectos secundarios y los datos se tratan como inmutables.

Crear y usar registros

Los registros son como objetos inmutables. Se definen con una estructura establecida y no se pueden modificar después de su creación. A continuación se ofrece un vistazo rápido a cómo utilizar Registros:

// Creating an immutable Record const kittyFacts = 
#{ name: "Turbodog", age: 17, favoriteToy: "Laser Pointer" }; 
// Accessing values 
console.log(kittyFacts.name); 
// Outputs: Turbodog 
console.log(kittyFacts.favoriteToy); 
// Outputs: Laser Pointer 
// Attempting to modify will create a new instance 
const updatedKittyFacts = #{ ...kittyFacts, age: 18 };
console.log(kittyFacts.age); 
// Outputs: 17 (unchanged) 
console.log(updatedKittyFacts.age); 
// Outputs: 18 (new instance)

En este ejemplo, kittyFacts es un registro inmutable. Cualquier modificación, como actualizar la edad, da como resultado un nuevo Registro KittyFacts actualizado, dejando intactos los kittyFacts originales.

Trabajar con tuplas

Las tuplas son matrices inmutables que pueden contener una cantidad fija de elementos. Son particularmente útiles para representar colecciones ordenadas de valores que no deben modificarse.

// Creating an immutable Tuple 
const concertSetlist = #[ "Tupelo", "Live Oak", "Strawberry Woman", "Elephant" ]; 
// Accessing values 
console.log(concertSetlist[0]);
 // Outputs: Tupelo 
console.log(concertSetlist[2]);
 // Outputs: Strawberry Woman 
// Attempting to modify will create a new instance
 const updatedSetlist = #[...concertSetlist, "Chaos and Clothes"]; 
console.log(concertSetlist.length); 
 // Outputs: 4 (unchanged) 
console.log(updatedSetlist.length);
// Outputs: 5 (new instance)

; // Accediendo a valores console.log(concertSetlist[0]); // Salidas: Tupelo console.log(concertSetlist[2]); // Salidas: Mujer Fresa // Intentar modificar creará una nueva instancia const actualizadoSetlist = #[...concertSetlist, "Caos y ropa"]; console.log(conciertoSetlist.length); // Salidas: 4 (sin cambios) console.log(actualizadoSetlist.length); // Salidas: 5 (nueva instancia)

Aquí, concertSetlist es una tupla inmutable. Agregar una nueva canción a la lista de canciones crea una nueva tupla de listas de canciones actualizada, conservando la original.

Operaciones avanzadas con registros y tuplas

Los registros y tuplas vienen con métodos útiles para manejar datos de forma inmutable. Por ejemplo, el método with para Tuplas permite actualizaciones sencillas en índices específicos:

// Creating a Tuple 
const originalMixtape = #[ "If We Were Vampires", "World Leader Pretend", "Right Back to It" ];
 // Updating a specific index 
const updatedMixtape = originalMixtape.with(1, "Turn You Inside-Out"); 
console.log(originalMixtape); 
// Outputs: #[ "If We Were Vampires", "World Leader Pretend", "Right Back to It" ]; 
console.log(updatedMixtape); 
// Outputs: #[ "If We Were Vampires", "Turn You Inside-Out", "Right Back to It" ];

// Creando una tupla const originalMixtape = #

; // Actualizando un índice específico const actualizadoMixtape = originalMixtape.with(1, "Vuélvete del revés"); console.log(originalMixtape); // Salidas: #

; console.log(actualizadoMixtape); // Salidas: #

;

En este ejemplo, el método with actualiza la pista en el índice 1 sin alterar el Mixtape original.

Conclusión

Las estructuras de datos inmutables (registros y tuplas) se introdujeron en ECMAScript 2024 y representan una mejora importante para JavaScript. Ayudan a promover la coherencia de los datos, simplificar la depuración y alinearse bien con las prácticas de programación funcional. Al experimentar con estas estructuras inmutables, puede crear aplicaciones más confiables y fáciles de mantener y, al mismo tiempo, evitar las sorpresas y los efectos secundarios comunes de los datos mutables.

fuentes:

https://www.interactivated.me/blog/whats-new-in-javascript-top-10-exciting-features-for-2024

https://thenewstack.io/whats-new-for-javascript-developers-in-ecmascript-2024/

https://www.w3schools.com/js/js_2024.asp

https://github.com/tc39/proposal-record-tuple

https://tc39.es/propuesta-record-tuple/tutorial/