Segui su:
Programmazione Web Italia

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

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. marco dice...

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:

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.