TypeScript Academy · Lezione

Literal booleani e inferenza dei literal

Comprenda come TypeScript ampli o restringa l’inferenza dei literal.

Literal booleani e inferenza dei literal è 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.

Tipi letterali booleani

Il tipo boolean è in realtà l'unione true | false. Ognuno dei due è un tipo letterale booleano: un tipo che consente un solo valore booleano specifico.

let yes: true = true;
let no: false = false;
console.log(yes, no);
// yes = false; // Error: false not assignable to true

Letterali booleani nelle unioni

I letterali booleani sono particolarmente utili quando vengono combinati con altri letterali per modellare risultati discriminati, ad esempio un flag di successo insieme alla struttura del payload.

type Result =
  | { ok: true; value: number }
  | { ok: false; error: string };

const r: Result = { ok: true, value: 42 };
console.log(r);

Ampliamento del tipo

Quando inizializza una variabile, TypeScript decide quale tipo inferire. A volte conserva il letterale preciso; altre volte lo amplia trasformandolo nel tipo generale. Comprendere questo comportamento è fondamentale per ottenere tipi prevedibili.

const exact = 'hello'; // type: 'hello' (literal)
let broad = 'hello';   // type: string (widened)
console.log(exact, broad);

let si amplia al tipo generale

Poiché una variabile let può essere riassegnata, TypeScript inferisce il tipo generale per consentire le assegnazioni future. Una stringa let inizia con il tipo string, non con il letterale.

let mood = 'happy'; // inferred as string
mood = 'sad';       // allowed
mood = 'tired';     // allowed
console.log(mood);

const conserva il letterale

Un const non può mai essere riassegnato, quindi TypeScript inferisce il tipo più specifico: il letterale. Per questo const greeting = 'hi' ha tipo 'hi', non string.

const greeting = 'hi'; // type: 'hi'

type Greeting = typeof greeting; // 'hi'
const other: Greeting = 'hi';
console.log(other);

Ampliamento con numeri e booleani

La stessa regola vale per numeri e booleani. const conserva 42 o true come letterale; let li amplia rispettivamente a number o boolean.

const n = 42;   // type: 42
const b = true; // type: true
let m = 42;     // type: number
let c = true;   // type: boolean
console.log(n, b, m, c);

Perché esiste l'ampliamento

L'ampliamento rende il codice quotidiano più pratico. Se ogni let count = 0 avesse il tipo letterale 0, non potrebbe incrementarlo. L'ampliamento consente alle variabili riassegnabili di comportarsi in modo naturale.

let count = 0; // widened to number
count = count + 1;
count = 10;
console.log('Count:', count);

Forzare un letterale con un'annotazione

A volte si desidera che un let rimanga un letterale. Aggiunga un'annotazione esplicita del tipo letterale: TypeScript lo manterrà ristretto, consentendo comunque di riassegnarlo all'interno di quell'unione.

let status: 'on' | 'off' = 'on';
status = 'off'; // allowed
console.log(status);
// status = 'paused'; // Error

Ampliamento nelle proprietà degli oggetti

Anche le proprietà dei literal di oggetto vengono ampliate per impostazione predefinita. Persino in un oggetto const, le proprietà mutabili ricevono il tipo generale, perché la proprietà stessa può essere riassegnata.

const config = { mode: 'dark' };
// config.mode has type string, not 'dark'
config.mode = 'light';
console.log(config.mode);

Inferenza dei letterali con le funzioni

Vengono inferiti anche i valori restituiti dalle funzioni. Una funzione che restituisce un valore letterale const amplia comunque il tipo restituito al tipo generale, a meno che non lo annoti o non usi tipi letterali nella firma.

function getMode(): 'dark' | 'light' {
  return 'dark';
}

const m = getMode(); // type: 'dark' | 'light'
console.log(m);

Scegliere tra tipo letterale e tipo generale

Regola pratica: usi const o annotazioni letterali esplicite quando servono valori esatti, ad esempio per le chiavi di configurazione o i discriminanti. Per le normali variabili mutabili, lasci che avvenga l'allargamento del tipo. Sapere quale comportamento si verifica evita errori di assegnabilità imprevisti.

const KEY = 'apiUrl';     // literal 'apiUrl'
let retries = 3;          // number
let level: 'low' | 'high' = 'low'; // pinned literal
console.log(KEY, retries, level);

Verifica rapida

Verifichi la Sua comprensione dell'allargamento del tipo e dell'inferenza dei tipi letterali.

Riepilogo: inferenza dei tipi letterali

Punti chiave:

true e false sono tipi letterali; boolean equivale a true | false.
let si amplia al tipo generale (string, number, boolean).
const conserva il tipo letterale esatto.
Annoti con un tipo letterale per vincolare un let a un'unione ristretta.

Ora renderemo esplicita l'immutabilità con as const.

const literal = 'fixed'; // 'fixed'
let widened = 'fixed';   // string
let pinned: 'a' | 'b' = 'a';
console.log(literal, widened, pinned);

Domande Frequenti

La lezione «Literal booleani e inferenza dei literal» è gratuita?

Sì — il testo completo di «Literal booleani e inferenza dei literal» è 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 «Literal booleani e inferenza dei literal»?

Comprenda come TypeScript ampli o restringa l’inferenza dei literal. 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 «Literal booleani e inferenza dei literal»?

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

Tipi literal stringa e numerici
Literal booleani e inferenza dei literal
Asserzioni const con as const
Combinare i literal in union

← Torna a TypeScript Academy