TypeScript Academy · Lezione

Asserzioni const con as const

Renda oggetti e array profondamente readonly con i tipi literal.

Asserzioni const con as const è una lezione TypeScript Academy gratuita su CoddyKit. Questa è la lezione 3 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'asserzione as const

Un'asserzione const, scritta as const, indica a TypeScript di inferire il tipo più specifico possibile e profondamente readonly per un valore. Le proprietà degli oggetti diventano letterali e immutabili; gli array diventano tuple readonly.

const point = { x: 10, y: 20 } as const;
// type: { readonly x: 10; readonly y: 20 }
console.log(point.x, point.y);

Senza as const

Senza l'asserzione, le proprietà degli oggetti si ampliano. { x: 10 } inferisce x: number e il valore rimane mutabile. Confronti questo risultato con la scena precedente per vedere cosa cambia con as const.

const a = { x: 10 };       // x: number, mutable
const b = { x: 10 } as const; // x: 10, readonly
a.x = 99; // allowed
console.log(a.x, b.x);

Bloccare le proprietà sui tipi letterali

as const trasforma ogni proprietà stringa nel relativo tipo letterale. È prezioso per gli oggetti di configurazione, le cui chiavi e i cui valori devono rimanere esatti.

const config = {
  env: 'production',
  retries: 3
} as const;
// env: 'production', retries: 3
console.log(config.env, config.retries);

readonly impedisce la mutazione

Poiché as const rende le proprietà readonly, il compilatore impedisce di riassegnarle. Il valore è immutabile a livello di tipo, quindi viene protetto da modifiche accidentali.

const settings = { mode: 'dark' } as const;
console.log(settings.mode);
// settings.mode = 'light'; // Error: readonly property

Asserzioni const sugli array

Applicato a un array, as const produce una tupla readonly di tipi letterali. La lunghezza è fissa e ogni elemento conserva il proprio valore esatto.

const colors = ['red', 'green', 'blue'] as const;
// type: readonly ['red', 'green', 'blue']
console.log(colors[0], colors.length);

Nessuna mutazione negli array readonly

Una tupla readonly rifiuta i metodi che modificano i dati, come push, e l'assegnazione tramite indice. I dati sono bloccati, esattamente ciò che serve per le tabelle di ricerca fisse.

const days = ['Mon', 'Tue', 'Wed'] as const;
console.log(days.join(', '));
// days.push('Thu'); // Error: push does not exist on readonly tuple

Derivare un'unione con typeof arr[number]

Un modello molto utile consiste nel prendere un array readonly e derivare un'unione dei tipi dei suoi elementi usando typeof arr[number]. Scrive i valori una sola volta e ottiene automaticamente un'unione letterale.

const ROLES = ['admin', 'editor', 'viewer'] as const;
type Role = typeof ROLES[number];
// 'admin' | 'editor' | 'viewer'
const r: Role = 'editor';
console.log(r);

Un'unica fonte di verità

In questo modo l'array a runtime e il tipo rimangono sincronizzati. Aggiunga un valore all'array e l'unione si aggiornerà automaticamente: non dovrà mantenere elenchi duplicati.

const SIZES = ['S', 'M', 'L', 'XL'] as const;
type Size = typeof SIZES[number];

function pick(s: Size): void {
  console.log('Picked', s);
}
pick('M');

Asserzioni const sulle tuple

Per le tuple i cui elementi hanno tipi diversi, as const conserva sia i tipi esatti sia l'ordine, producendo una tupla readonly precisa.

const pair = [1, 'one'] as const;
// type: readonly [1, 'one']
console.log(pair[0], pair[1]);

Comportamento readonly profondo

as const si applica in modo profondo. Anche gli oggetti e gli array annidati diventano readonly con tipi letterali, fino all'ultimo livello.

const data = {
  name: 'app',
  tags: ['a', 'b']
} as const;
// tags is readonly ['a', 'b']
console.log(data.name, data.tags[1]);

Asserzioni const per gli enum

Un oggetto const insieme a un'unione derivata è un'alternativa leggera a enum. Ottiene valori letterali a runtime e un tipo esatto, senza generare codice aggiuntivo.

const Status = {
  Idle: 'idle',
  Active: 'active'
} as const;
type Status = typeof Status[keyof typeof Status];
const s: Status = Status.Active;
console.log(s);

Verifica rapida

Verifichi la Sua comprensione delle asserzioni const.

Riepilogo: as const

Ha imparato che as const:

Inferisce il tipo letterale più specifico possibile e profondamente readonly.
Trasforma le proprietà degli oggetti in campi readonly letterali.
Trasforma gli array in tuple readonly di valori letterali.
Permette di derivare unioni tramite typeof arr[number], mantenendo sincronizzati valori e tipi.

Ora combineremo i tipi letterali in unioni espressive.

const LEVELS = ['low', 'mid', 'high'] as const;
type Level = typeof LEVELS[number];
const chosen: Level = 'mid';
console.log(chosen);

Domande Frequenti

La lezione «Asserzioni const con as const» è gratuita?

Sì — il testo completo di «Asserzioni const con as const» è 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 «Asserzioni const con as const»?

Renda oggetti e array profondamente readonly con i tipi 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 3 di 4.

Quanto tempo richiede la lezione «Asserzioni const con as const»?

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