JavaScript Optional Chaining (?.): come funziona e quando utilizzarlo

Scopri come funziona l'Optional Chaining in JavaScript (?.): esempi pratici, accesso a proprietà e metodi, array, Nullish Coalescing e compatibilità browser. 
Cos'è l'Optional Chaining in JavaScript
L'Optional Chaining è un operatore JavaScript che consente
di accedere alle proprietà di un oggetto senza generare un errore
quando uno dei riferimenti intermedi è null oppure
undefined.
Prima della sua introduzione, per accedere a proprietà annidate era spesso necessario utilizzare una serie di verifiche condizionali, soprattutto quando non si aveva la certezza che tutti i livelli dell'oggetto fossero disponibili.
Consideriamo il seguente oggetto:
const user = {
name: 'Mario',
address: {
city: 'Roma',
country: 'Italia'
}
};
Per accedere alla città dell'utente possiamo utilizzare la normale notazione con il punto:
console.log(user.address.city); // Roma
Il problema si presenta quando la proprietà address
non esiste oppure ha valore undefined o
null. In questi casi, il tentativo di accedere
a city genera un TypeError.
L'Optional Chaining permette di gestire questa eventualità in modo diretto:
console.log(user.address?.city);
Se address è presente, viene restituito il valore
di city. Se invece è null oppure
undefined, l'espressione restituisce
undefined senza interrompere l'esecuzione
del programma.
La sintassi utilizza il simbolo ?., che introduce
un accesso condizionale alla proprietà successiva.
È importante ricordare che l'operatore non verifica genericamente
che un valore sia valido: verifica esclusivamente che il riferimento
sul quale viene applicato non sia null o
undefined.
Come funziona l'operatore Optional Chaining
L'operatore ?. interrompe la valutazione della
catena di accesso quando il valore immediatamente precedente
è null o undefined.
In questo caso, il risultato dell'espressione è
undefined.
In caso contrario, l'accesso prosegue normalmente. Questo comportamento permette di evitare controlli espliciti su ogni singola proprietà.
Vediamo un esempio con una struttura più articolata:
const response = {
data: {
user: {
profile: {
name: 'Mario',
surname: 'Rossi'
}
}
}
};
const name = response.data?.user?.profile?.name;
console.log(name); // Mario
Se uno qualsiasi dei riferimenti sui quali viene applicato
l'Optional Chaining è null o
undefined, l'intera catena restituisce
undefined.
Ad esempio:
const response = {
data: null
};
const name = response.data?.user?.profile?.name;
console.log(name); // undefined
In questo caso non viene generato alcun errore perché
l'operatore interrompe la valutazione quando incontra
response.data con valore null.
Attenzione: l'Optional Chaining non rende automaticamente sicura qualsiasi espressione. Se il riferimento iniziale non è definito, occorre applicare l'operatore anche a quel riferimento:
const name = response?.data?.user?.profile?.name;
Senza il primo ?., un valore iniziale
response non dichiarato o non inizializzato
continuerebbe a generare un errore.
Optional Chaining con le proprietà degli oggetti
Il caso d'uso più comune riguarda l'accesso alle proprietà di oggetti che possono contenere dati opzionali. L'operatore può essere utilizzato sia con proprietà semplici sia con strutture annidate.
const user = {
name: 'Mario',
contact: null
};
const email = user.contact?.email;
console.log(email); // undefined
In assenza dell'operatore, l'accesso a
user.contact.email avrebbe generato un errore.
Un altro scenario frequente riguarda le risposte delle API:
const response = {
status: 200,
data: {
user: {
id: 10,
name: 'Mario'
}
}
};
const userId = response?.data?.user?.id;
In questo modo possiamo gestire strutture di risposta che non garantiscono la presenza di tutti i livelli dell'oggetto, senza ricorrere a controlli ripetitivi.
Optional Chaining con gli array
L'operatore può essere utilizzato anche per accedere agli elementi di un array attraverso la notazione con parentesi quadre.
const users = [
{ name: 'Mario' },
{ name: 'Luigi' }
];
console.log(users?.[0]?.name); // Mario
console.log(users?.[2]?.name); // undefined
La sintassi ?.[index] permette di verificare
che l'array non sia null o
undefined prima di accedere all'elemento.
L'ulteriore ?. verifica invece che l'elemento
selezionato sia disponibile prima di leggerne la proprietà.
Questo approccio è utile quando si lavora con array opzionali o con strutture dati provenienti da fonti esterne:
const data = {
products: null
};
const firstProduct = data.products?.[0];
console.log(firstProduct); // undefined
È importante precisare che l'Optional Chaining non verifica
che il valore sia effettivamente un array: se
products contiene un valore di tipo diverso,
il comportamento dipenderà dal tipo di valore e dall'operazione
richiesta.
Optional Chaining con le funzioni e i metodi
L'Optional Chaining può essere utilizzato anche per invocare
funzioni e metodi che potrebbero non essere definiti.
In questo caso la sintassi è ?.().
Consideriamo un oggetto che contiene una funzione opzionale:
const user = {
name: 'Mario',
onLogin() {
console.log('Utente autenticato');
}
};
user.onLogin?.(); // Utente autenticato
Se onLogin non esiste oppure contiene
null o undefined, la chiamata
viene ignorata e il risultato dell'espressione è
undefined.
const user = {
name: 'Mario'
};
user.onLogin?.(); // undefined
Questa funzionalità è particolarmente utile quando si sviluppano componenti, librerie o API che prevedono callback opzionali.
function saveData(data, callback) {
// Salvataggio dei dati...
callback?.(data);
}
saveData({ id: 10 });
In questo esempio, il callback viene eseguito soltanto
se è stato fornito un valore diverso da
null o undefined.
È importante distinguere questo comportamento dalla verifica
del tipo: se callback contiene un valore
non nullo che non è una funzione, la chiamata genera comunque
un TypeError.
Analogamente, se un oggetto esiste ma la proprietà che dovrebbe contenere il metodo non è invocabile, l'Optional Chaining non impedisce l'errore.
Optional Chaining e Nullish Coalescing
L'Optional Chaining viene spesso utilizzato insieme
all'operatore Nullish Coalescing (??),
introdotto anch'esso con ECMAScript 2020.
Mentre l'Optional Chaining permette di accedere in sicurezza
alle proprietà di un oggetto, il Nullish Coalescing consente
di definire un valore predefinito quando un'espressione
restituisce null oppure undefined.
const user = {
name: 'Mario',
address: null
};
const city = user.address?.city ?? 'Città non disponibile';
console.log(city); // Città non disponibile
In questo esempio, l'Optional Chaining restituisce
undefined perché address è
null. Il Nullish Coalescing intercetta
questo risultato e assegna il valore alternativo.
La differenza rispetto all'operatore OR logico
(||) è importante:
const quantity = 0;
console.log(quantity || 10); // 10
console.log(quantity ?? 10); // 0
L'operatore || utilizza il valore alternativo
quando l'espressione è falsy, quindi anche in presenza
di 0, false o stringhe vuote.
Il ??, invece, interviene soltanto quando
il valore è null o undefined.
La combinazione di Optional Chaining e Nullish Coalescing
è quindi particolarmente efficace per leggere dati opzionali
e assegnare valori di fallback senza alterare valori validi
come 0 o false.
Short-circuit evaluation: quando JavaScript interrompe la valutazione
L'Optional Chaining utilizza il meccanismo di
short-circuit evaluation: quando il valore sul quale
viene applicato l'operatore è null o
undefined, JavaScript interrompe la valutazione
della parte restante della catena.
Questo comportamento è importante anche quando l'accesso a una proprietà prevede l'esecuzione di un'espressione.
let index = 0;
const users = null;
const user = users?.[index++];
console.log(user); // undefined
console.log(index); // 0
Poiché users è null,
JavaScript interrompe la valutazione prima di eseguire
index++. Di conseguenza, il valore di
index rimane invariato.
Questo dettaglio è utile da conoscere quando si utilizzano espressioni con effetti collaterali all'interno di una catena Optional Chaining.
Limiti e casi in cui non utilizzare Optional Chaining
Nonostante sia una funzionalità molto utile, l'Optional Chaining non dovrebbe essere utilizzato indiscriminatamente. Il suo scopo è gestire riferimenti opzionali, non nascondere errori strutturali o rendere tollerante qualsiasi accesso a proprietà.
Non protegge da riferimenti iniziali non definiti
Se una variabile non è stata dichiarata, l'Optional Chaining
non può evitare un ReferenceError.
// ReferenceError
console.log(user?.name);
L'operatore protegge l'accesso a partire da un riferimento esistente, ma non può risolvere un identificatore che JavaScript non riesce a trovare.
Non protegge da qualsiasi valore falsy
L'operatore controlla soltanto null e
undefined. Valori come 0,
false e '' non interrompono
la catena.
const user = {
active: false
};
console.log(user?.active); // false
Questo comportamento è intenzionale: questi valori possono rappresentare informazioni perfettamente valide e non devono essere confusi con l'assenza di un dato.
Non può essere utilizzato per assegnare valori
L'Optional Chaining non è valido come destinazione di un'assegnazione.
// Sintassi non valida
user?.name = 'Luigi';
Per modificare una proprietà opzionale è necessario verificare esplicitamente che l'oggetto esista:
if (user) {
user.name = 'Luigi';
}
Non può essere utilizzato con new e tagged template
La sintassi Optional Chaining non può essere utilizzata
direttamente per costruire oggetti tramite new
o per invocare tagged template.
// Sintassi non valida
new User?.();
// Sintassi non valida
String.raw?.`test`;
In questi casi è necessario verificare esplicitamente la disponibilità del costruttore o della funzione prima di utilizzarli.
Non sostituisce la validazione dei dati
Un utilizzo eccessivo dell'Optional Chaining può nascondere problemi nella struttura dei dati o errori di programmazione. Se una proprietà è obbligatoria secondo il contratto di un'API o il modello applicativo, la sua assenza potrebbe indicare un errore che dovrebbe essere gestito esplicitamente.
Utilizza quindi l'operatore quando l'assenza di un valore è prevista dal modello dei dati, non per ignorare indiscriminatamente qualsiasi proprietà mancante.
Optional Chaining e prestazioni
L'Optional Chaining è principalmente una funzionalità sintattica che semplifica l'accesso a proprietà potenzialmente assenti. Il suo utilizzo non dovrebbe essere motivato da presunti vantaggi prestazionali rispetto ai controlli condizionali tradizionali.
Nella maggior parte delle applicazioni, la differenza di prestazioni tra le due modalità è trascurabile. La scelta dovrebbe essere guidata soprattutto dalla leggibilità del codice, dalla chiarezza del modello dei dati e dalla corretta gestione dei casi in cui una proprietà potrebbe non essere disponibile.
È comunque opportuno evitare catene eccessivamente lunghe quando rendono difficile comprendere la struttura dell'oggetto o nascondono condizioni che meriterebbero una gestione esplicita.
Compatibilità con i browser
L'Optional Chaining è stato introdotto con ECMAScript 2020 (ES11) ed è supportato dai principali browser moderni, tra cui Chrome, Firefox, Safari ed Edge.
Non è invece disponibile nativamente nei browser meno recenti che non implementano questa versione dello standard JavaScript. Se il progetto deve supportare ambienti legacy, è necessario utilizzare un processo di transpilation, ad esempio tramite Babel, oppure configurare il compilatore TypeScript per trasformare la sintassi in codice compatibile.
Per verificare la compatibilità con i browser e le versioni effettivamente utilizzate dal progetto, puoi consultare la documentazione di MDN e Can I Use.
Link utili
Se vuoi approfondire il funzionamento dell'Optional Chaining e le specifiche che ne definiscono il comportamento, puoi consultare queste risorse:
- MDN Web Docs - Optional chaining (?.) : documentazione tecnica con esempi, sintassi e casi particolari.
- ECMAScript Language Specification - Optional Chains : specifica ufficiale del linguaggio JavaScript.
- Can I Use - Optional Chaining : informazioni sulla compatibilità della funzionalità nei principali browser.
- Babel - Transform Optional Chaining : documentazione relativa alla trasformazione della sintassi per gli ambienti che non supportano nativamente l'operatore.
Conclusioni
L'Optional Chaining è una funzionalità JavaScript che permette di semplificare notevolmente l'accesso a proprietà e metodi potenzialmente assenti, riducendo la necessità di controlli condizionali ripetitivi e migliorando la leggibilità del codice.
La sintassi ?. può essere utilizzata con proprietà
degli oggetti, array e chiamate a funzioni opzionali.
Combinata con il Nullish Coalescing (??),
permette inoltre di gestire i valori mancanti assegnando
fallback appropriati, senza confondere null
e undefined con valori validi come
0 o false.
Come ogni funzionalità del linguaggio, deve essere utilizzata con criterio. L'Optional Chaining non sostituisce la validazione dei dati e non dovrebbe essere impiegato per nascondere errori che richiedono una gestione esplicita.
Conoscere il suo funzionamento, i limiti e i casi d'uso consente di scrivere applicazioni JavaScript più pulite, robuste e manutenibili, soprattutto quando si lavora con strutture dati complesse e informazioni provenienti da servizi esterni.
