TypeScript Academy · Lezione

Operatore di asserzione non-null

Utilizzi l’operatore ! per affermare che un valore non è null né undefined.

Operatore di asserzione non-null è una lezione TypeScript Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento TypeScript Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso TypeScript Academy include 4 lezioni in totale.

L'operatore di asserzione non-null

L'operatore ! postfisso dice a TypeScript «questo valore qui non è null né undefined». Rimuove questi valori dal tipo senza eseguire alcun controllo a runtime.

function firstChar(s: string | null): string {
  return s!.charAt(0); // assert s is not null
}
console.log(firstChar('hello'));

Dove posizionare !

! va posizionato immediatamente dopo l'espressione che sta asserendo, prima di qualsiasi accesso successivo. Rimuove null | undefined dal tipo di quell'espressione.

type Box = { value?: number };
const box: Box = { value: 7 };
const n: number = box.value!; // value is number | undefined -> number
console.log(n);

Asserire un valore non nullo dopo un controllo

A volte ha verificato logicamente che un valore sia presente, ma il compilatore non riesce a seguire il ragionamento. ! le consente di procedere. Tuttavia, un controllo effettivo a runtime è generalmente più chiaro.

const list: Array<string | null> = ['a', null, 'c'];
const present = list.filter((x) => x !== null);
// TS may still see string | null; assert if certain:
console.log(present[0]!.toUpperCase());

Solo in fase di compilazione, ancora una volta

Come as, l'operatore ! viene eliminato a runtime. Non esegue alcun controllo. Se il valore è realmente null, si verificherà un errore a runtime nonostante il compilatore lo consideri valido.

function risky(s: string | null): number {
  return s!.length; // no runtime guard
}
console.log(risky('hi'));
// risky(null) would throw at runtime

Il pericolo di !

Se asserisce che un valore non è nullo quando in realtà può esserlo, crea un bug nascosto. Il compilatore smette di segnalarlo, quindi l'errore emerge solo quando quel valore nullo compare in produzione.

type User = { name?: string };
const u: User = {};
// const len = u.name!.length; // compiles, crashes at runtime
console.log('name is undefined here -> ! would crash');

Preferire un controllo reale

Quando è pratico farlo, sostituisca ! con un controllo effettivo di null oppure con l'optional chaining. La versione sicura richiede una sola riga ed elimina un'intera categoria di arresti anomali a runtime.

type User = { name?: string };
function nameLen(u: User): number {
  if (u.name) return u.name.length; // checked
  return 0;
}
console.log(nameLen({ name: 'Ada' }), nameLen({}));

Asserzione di assegnazione definita

Una funzionalità correlata è l'asserzione di assegnazione definita: let x!: T. Essa comunica al compilatore che x verrà assegnata prima dell'uso, anche se non viene inizializzata nella dichiarazione.

let token!: string; // promise: assigned before use
function init() { token = 'abc123'; }
init();
console.log(token.length);

Assegnazione definita nelle classi

È comune nelle classi in cui una proprietà viene impostata da un framework o da un metodo di inizializzazione anziché dal costruttore. ! dopo il nome della proprietà elimina l'errore «non assegnata in modo definitivo».

class Service {
  config!: { url: string }; // set later by setup()
  setup() { this.config = { url: '/api' }; }
}
const s = new Service();
s.setup();
console.log(s.config.url);

Usare con cautela l'assegnazione definita

L'asserzione di assegnazione definita è un'altra promessa che il compilatore non può verificare. Se accede alla proprietà prima di assegnarle un valore, a runtime leggerà undefined senza ricevere alcun avviso.

class Late {
  data!: number[];
  read() { return this.data.length; } // crashes if called before init
}
const l = new Late();
l.data = [1, 2];
console.log(l.read());

! e optional chaining

Non ricorra a ! quando sarebbe sufficiente ?.. L'optional chaining gestisce in sicurezza i valori null a runtime, mentre ! si limita a silenziare il compilatore. Risolvono problemi diversi.

type Cfg = { db?: { host?: string } };
const c: Cfg = {};
console.log(c.db?.host ?? 'localhost'); // safe
// c.db!.host! would crash here

Quando ! è giustificato

L'operatore ! è ragionevole quando dispone di una garanzia effettiva che il compilatore non può esprimere, per esempio per un valore appena inserito e letto immediatamente. Anche in questo caso, documenti il motivo per cui è sicuro.

const cache = new Map<string, number>();
cache.set('hits', 0);
// We just set it, so get is non-null:
const hits = cache.get('hits')!;
console.log(hits);

Verifica rapida

Verifichi la sua comprensione dell'operatore di asserzione non-null.

Riepilogo: asserzione non-null

Ha imparato che:

Il postfisso ! rimuove null | undefined da un tipo solo in fase di compilazione.
Non esegue alcun controllo a runtime, quindi un'asserzione errata causa comunque un arresto anomalo.
let x!: T è l'asserzione di assegnazione certa per i valori inizializzati in un secondo momento.
Preferisca i controlli effettivi o l'optional chaining; riservi ! ai casi in cui esista una garanzia reale.

Ora analizzeremo le doppie asserzioni e i loro rischi.

const map = new Map<string, number>();
map.set('a', 1);
const v = map.get('a')!;
console.log(v);

Domande Frequenti

La lezione «Operatore di asserzione non-null» è gratuita?

Sì — il testo completo di «Operatore di asserzione non-null» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso TypeScript Academy, passa a CoddyKit PRO. Il corso TypeScript Academy include 4 lezioni in totale.

Cosa imparerò in «Operatore di asserzione non-null»?

Utilizzi l’operatore ! per affermare che un valore non è null né undefined. Eserciti TypeScript Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare TypeScript Academy?

Non è richiesta alcuna esperienza precedente. TypeScript Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Operatore di asserzione non-null»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione TypeScript Academy?

Sì. Ogni lezione TypeScript Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a TypeScript Academy