JavaScript - ECMAScript 2021: Una Guida per Principianti

Ciao futuro superprogrammatore! Sono entusiasta di essere il tuo guida in questo viaggio emozionante nel mondo di ECMAScript 2021. Come insegnante di scienze informatiche con anni di esperienza, ho visto innumerevoli studenti passare da principianti assoluti a programmatori sicuri di sé. Oggi esploreremo le ultime funzionalità di JavaScript, e prometto di renderlo il più divertente e facile da capire possibile. Allora, prenditi la tua bevanda preferita, mettiti comodo, e tuffiamoci!

Cos'è ECMAScript 2021?

Prima di immergerci nelle nuove funzionalità, parliamo rapidamente di cosa sia ECMAScript. Immagina ECMAScript come il libro delle ricette per JavaScript. Ogni anno, gli chef (ovvero gli sviluppatori del linguaggio) aggiungono nuove ricette (funzionalità) per rendere le nostre vite di programmatori più facili e gustose. ECMAScript 2021, noto anche come ES12, è l'ultima edizione di questo libro delle ricette.

Nuove Funzionalità Aggiunte in ECMAScript 2021

ECMAScript 2021 ci porta alcuni strumenti nuovi e affascinanti da utilizzare. È come ottenere un nuovo set di mattoni LEGO da aggiungere alla nostra collezione. Esploriamo ciascuna di queste nuove funzionalità una per una.

separatori numerici (_)

Hai mai provato a leggere un numero davvero lungo, come 1000000000? È un po' un mal di testa, vero? Beh, il separatore numerico è qui per salvare la situazione!

// Senza separatore numerico
const billion = 1000000000;

// Con separatore numerico
const billionReadable = 1_000_000_000;

console.log(billion === billionReadable); // Output: true

L'underscore (_) in 1_000_000_000 non cambia il valore del numero. È solo lì per rendere più facile per noi umani leggerlo. Non è fantastico? È come aggiungere spazi in una frase lunga per renderla più leggibile.

Metodo Promise.any()

Le Promise in JavaScript sono come fare un sacco di telefonate contemporaneamente e aspettare che qualcuno risponda. Il metodo Promise.any() è un nuovo modo per gestire più promise.

const promise1 = new Promise((resolve, reject) => setTimeout(reject, 100, 'promise1'));
const promise2 = new Promise((resolve, reject) => setTimeout(resolve, 200, 'promise2'));
const promise3 = new Promise((resolve, reject) => setTimeout(resolve, 300, 'promise3'));

Promise.any([promise1, promise2, promise3])
.then((value) => console.log(value))
.catch((error) => console.log(error));

// Output: promise2

In questo esempio, Promise.any() si risolve non appena una delle promise nell'array è soddisfatta. È come una gara in cui ci interessa solo la prima persona a tagliare il traguardo, indipendentemente da chi arriva secondo o terzo.

Metodo String.replaceAll()

Hai mai giocato a un gioco di sostituzione delle parole? Il metodo replaceAll() è un po' come quello, ma per le stringhe in JavaScript.

const sentence = "Adoro i gatti. I gatti sono ottimi animali domestici.";
const newSentence = sentence.replaceAll("gatti", "cani");

console.log(newSentence); // Output: "Adoro i cani. I cani sono ottimi animali domestici."

Prima di replaceAll(), dovevamo utilizzare espressioni regolari o cicli per sostituire tutte le occorrenze di un sottotesto. Ora, è facilissimo!

Operatori di Assegnazione Logica

ECMAScript 2021 introduce tre nuovi operatori di assegnazione logica. Questi sono come modi abbreviati di scrivere schemi comuni in JavaScript. Esaminiamo ognuno:

Operatore di Assegnazione Logica AND (&&=)

let x = 1;
let y = 2;

x &&= y;

console.log(x); // Output: 2

// Questo è equivalente a:
// x && (x = y);

L'operatore &&= assegna il valore di destra solo se il valore di sinistra è truthy. È come dire, "Se x è vero, allora rendilo uguale a y."

Operatore di Assegnazione Logica OR (||=)

let a = null;
let b = 'valore predefinito';

a ||= b;

console.log(a); // Output: "valore predefinito"

// Questo è equivalente a:
// a || (a = b);

L'operatore ||= assegna il valore di destra solo se il valore di sinistra è falsy. È perfetto per impostare valori predefiniti!

Operatore di Assegnazione Nullish Coalescing (??=)

let foo = null;
let bar = 'baz';

foo ??= bar;

console.log(foo); // Output: "baz"

// Questo è equivalente a:
// foo ?? (foo = bar);

L'operatore ??= assegna il valore di destra solo se il valore di sinistra è null o undefined. È simile a ||=, ma più specifico su cosa considera "vuoto".

Riepilogo dei Metodi

Ecco una tabella comoda che riassume i nuovi metodi che abbiamo imparato:

Metodo	Descrizione	Esempio
Separatori Numerici	Rende i numeri grandi più leggibili	1_000_000_000
Promise.any()	Si risolve quando qualsiasi promise in un array si soddisfa	Promise.any([promise1, promise2, promise3])
String.replaceAll()	Sostituisce tutte le occorrenze di un sottotesto	"hello hello".replaceAll("hello", "hi")
&&=	Assegna se il lato sinistro è truthy	x &&= y
||=	Assegna se il lato sinistro è falsy	x \|\|= y
??=	Assegna se il lato sinistro è null o undefined	x ??= y

Ecco fatto, gente! Abbiamo intrapreso un viaggio attraverso le affascinanti nuove funzionalità di ECMAScript 2021. Ricorda, il miglior modo per imparare a programmare è mettersi in pratica. Quindi, ti incoraggio a giocare con queste nuove funzionalità, sperimentare e, soprattutto, divertirti!

Come diceva il mio vecchio professore di programmazione, "Codificare è come cucinare. Potresti bruciare un paio di piatti all'inizio, ma con la pratica, sarai in grado di creare capolavori in breve tempo!" Quindi, non aver paura di fare errori - sono tutti parte del processo di apprendimento.

Continua a programmare, rimani curioso, e buon apprendimento!

Credits: Image by storyset