Estruturas de dados imutáveis: um novo recurso no ECMAScript 2024

ECMAScript 2024 apresenta várias atualizações interessantes, mas um recurso que se destaca para mim é a introdução de estruturas de dados imutáveis. Essas novas estruturas – Registros e Tuplas – são revolucionárias no gerenciamento de dados em JavaScript. Eles oferecem uma maneira satisfatória de manter nossos dados sólidos, seguros e consistentes, o que é de extrema importância quando queremos aplicativos confiáveis ​​que possamos manter facilmente. Veja por que as estruturas de dados imutáveis ​​são tão interessantes e como você pode usá-las de maneira mais eficaz.

O que são registros e tuplas?

Registros e tuplas são novas estruturas de dados imutáveis ​​por design. Isso significa que depois de criar um Registro ou Tupla, seu conteúdo não poderá ser alterado. Qualquer tentativa de modificá-los resulta na criação de uma nova instância, enquanto a original permanece inalterada. Essa imutabilidade ajuda a evitar efeitos colaterais indesejados e torna seu código mais previsível.

Por que usar estruturas de dados imutáveis?

• Previsibilidade: Estruturas de dados imutáveis ​​facilitam o raciocínio sobre seu código porque você sabe que, uma vez definidos, os dados não serão alterados acidentalmente em outro lugar do seu aplicativo.
• Depuração: Com a imutabilidade, você evita problemas relacionados à modificação inesperada de dados, simplificando a depuração.
• Programação Funcional: Os dados imutáveis ​​se adaptam bem aos paradigmas de programação funcional, onde as funções evitam efeitos colaterais e os dados são tratados como imutáveis.

Criando e usando registros

Os registros são como objetos imutáveis. Eles são definidos com uma estrutura definida e não podem ser alterados após a criação. Aqui está uma rápida olhada em como usar 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)

Neste exemplo, kittyFacts é um registro imutável. Quaisquer modificações nele, como a atualização da idade, resultam em um novo registro KittyFacts atualizado, deixando os kittyFacts originais intactos.

Trabalhando com tuplas

Tuplas são arrays imutáveis ​​que podem conter um número fixo de elementos. Eles são particularmente úteis para representar coleções ordenadas de valores que não devem ser alterados.

// 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)

; //Acessando valores console.log(concertSetlist[0]); //Saídas: Tupelo console.log(concertSetlist[2]); // Resultados: Mulher Morango //A tentativa de modificação criará uma nova instância const atualizadoSetlist = #[...concertSetlist, "Caos e Roupas"]; console.log(concertSetlist.length); // Saídas: 4 (inalterado) console.log(updatedSetlist.length); // Saídas: 5 (nova instância)

Aqui, concertSetlist é uma tupla imutável. Adicionar uma nova música ao setlist cria uma nova Tupla Setlist atualizada, preservando o original.

Operações Avançadas com Registros e Tuplas

Registros e tuplas vêm com métodos úteis para lidar com dados de forma imutável. Por exemplo, o método with para Tuplas permite atualizações fáceis em í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" ];

// Criando uma tupla const originalMixtape = #

; //Atualizando um índice específico const atualizadoMixtape = originalMixtape.with(1, "Vire você do avesso"); console.log(originalMixtape); // Saídas: #

; console.log (Mixtape atualizado); // Saídas: #

;

Neste exemplo, o método with atualiza a faixa no índice 1 sem alterar o originalMixtape.

Conclusão

Estruturas de dados imutáveis ​​– registros e tuplas – foram introduzidas no ECMAScript 2024 e representam uma grande melhoria para JavaScript. Eles ajudam a promover a consistência dos dados, simplificam a depuração e se alinham bem com as práticas de programação funcional. Ao experimentar essas estruturas imutáveis, você pode criar aplicativos mais confiáveis ​​e fáceis de manter, evitando as surpresas comuns e os efeitos colaterais dos dados mutáveis.

fontes:

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/proposal-record-tuple/tutorial/