Salta al contenuto principale

05 - satisfies: controllare un catalogo senza perdere le sue chiavi

Annotare un oggetto letterale con un'interfaccia costa l'elenco delle sue chiavi. La prova compilata, l'errore reale e la regola per scegliere.

Cosa ne pensi di questo articolo?

05 - satisfies: controllare un catalogo senza perdere le sue chiavi
TypeScript Avanzatofedericocalo.dev

In Breve

Annotare un oggetto letterale con un'interfaccia costa l'elenco delle sue chiavi. La prova compilata, l'errore reale e la regola per scegliere.

L'annotazione che controlla il tipo e butta via le chiavi

Hai un catalogo scritto a mano: un oggetto letterale con una voce per strumento, o per rotta, o per lingua. Vuoi due cose insieme. La prima è che il compilatore controlli che ogni voce abbia la forma giusta, perché sono decine e un campo dimenticato è questione di tempo. La seconda è che altrove nel programma si possa scrivere una funzione che accetta solo le chiavi che esistono davvero.

Il modo in cui tutti provano a ottenerle è annotare la costante con un'interfaccia. Funziona per la prima e distrugge la seconda, e il motivo per cui la distrugge non è ovvio: l'annotazione non descrive il valore, lo riqualifica. Da quel momento il compilatore guarda la costante attraverso il tipo che hai dichiarato, e tutto quello che il tipo non dice è perso, anche se era scritto due righe sopra. Questo è il quinto articolo della serie e poggia sui tipi unione e sull'esaustività dell'articolo 04: ti serve sapere che cosa significa un tipo letterale e come lo legge il compilatore.

Gli errori riportati sono quelli di TypeScript 7.0.2, la versione latest sul registro npm il 2026-11-13, provati con strict attivo. Con la 5.9.3 i codici e le posizioni sono gli stessi, ma cambiano due dettagli di forma che ti capiterà di vedere: la 7.0 ordina in modo alfabetico i membri di un'unione di stringhe nei messaggi (la 5.9 li dà nell'ordine di dichiarazione), e scrive fra apici singoli le stringhe dentro il tipo di un oggetto.

La prova che l'informazione è andata persa

Il tipo Record<string, VoceStrumento> dice «un oggetto con chiavi di testo qualunque». Non è falso, ed è molto meno di quello che sapevi. Il risultato non va dedotto: si può far verificare. Il trucco, che userò anche negli altri blocchi, è assegnare un valore al tipo never: l'assegnazione fallisce sempre, e il messaggio di errore stampa il tipo che il compilatore ha davvero calcolato.


interface VoceStrumento {
  titolo: string;
  categoria: 'rete' | 'testo' | 'immagini';
}

// Annotazione: il tipo è controllato, ma le chiavi diventano 'string'.
export const strumentiAnnotati: Record<string, VoceStrumento> = {
  'json-formatter': { titolo: 'Formattatore JSON', categoria: 'testo' },
  'subnet-calculator': { titolo: 'Calcolatore di sottoreti', categoria: 'rete' },
};

export type IdAnnotato = keyof typeof strumentiAnnotati;

// Compila: con l'annotazione la chiave è 'string', quindi il refuso passa.
export const refusoAccettato: IdAnnotato = 'json-formater';

// Compila anche questo: il tipo dichiarato è VoceStrumento, il valore è undefined.
export const vocePersa = strumentiAnnotati['chiave-inventata'];

console.log(refusoAccettato);
console.log(vocePersa);

// Per far stampare al compilatore il tipo di IdAnnotato basta un'assegnazione impossibile.
export const sonda: never = null as unknown as IdAnnotato;

// Uscita di tsc 7.0.2:
// 01-annotato.ts(24,14): error TS2322: Type 'string' is not assignable to type 'never'.

// Uscita di node 24.11.0:
// json-formater
// undefined
      

Nel blocco, IdAnnotato è keyof typeof strumentiAnnotati, e l'ultima riga mostra che il suo tipo è string, non l'elenco delle due chiavi: l'elenco non fa parte del tipo dichiarato. Per questo refusoAccettato compila, benché 'json-formater' non esista: è un identificativo con un refuso assegnato a una variabile che dovrebbe accettare solo chiavi valide. Anche vocePersa compila, e qui il compilatore attribuisce alla lettura il tipo VoceStrumento, non VoceStrumento | undefined. L'uscita di Node lo conferma: a tempo di esecuzione quella lettura vale undefined, e il primo accesso a un suo campo solleva. L'unico errore del compilatore è quello delle sonde finali, messe lì apposta.

La seconda parte dipende da un'opzione che vale la pena conoscere, perché non è dentro strict. Si chiama noUncheckedIndexedAccess, e quando è attiva ogni lettura per indice restituisce il tipo del valore unito a undefined, costringendo a gestire l'assenza. In questo progetto non è impostata, quindi vale il suo valore predefinito, che è falso: l'ho verificato chiedendo la configurazione risolta al compilatore con npx tsc -p tsconfig.app.json --showConfig. È il genere di flag che conviene accendere su un progetto nuovo e che su uno grande produce centinaia di errori veri, cioè tutti i posti in cui si leggeva un indice dando per scontato che ci fosse qualcosa. Ecco che cosa cambia con l'opzione accesa, su un file di prova:


interface VoceStrumento {
  titolo: string;
  categoria: 'rete' | 'testo' | 'immagini';
}

const strumentiAnnotati: Record<string, VoceStrumento> = {
  'json-formatter': { titolo: 'Formattatore JSON', categoria: 'testo' },
};

// Con noUncheckedIndexedAccess la lettura per indice include undefined.
export const vocePersa = strumentiAnnotati['chiave-inventata'];
export const titolo = vocePersa.titolo;

// Uscita di tsc 7.0.2:
// 10-indice.ts(12,23): error TS18048: 'vocePersa' is possibly 'undefined'.
      

La riga 12 non compilava più: vocePersa è «possibly undefined», errore TS18048, e per leggere il titolo dovresti prima controllare che la voce esista. Senza l'opzione, lo stesso file compila (l'ho provato), ed è il motivo per cui l'annotazione larga è insidiosa: ti toglie le chiavi e, per default, non ti avvisa nemmeno che una lettura può restituire niente.

satisfies: verificare senza riqualificare

L'operatore satisfies, aggiunto in TypeScript 4.9, fa esattamente la cosa che serve: verifica che il valore sia compatibile con un tipo e lascia al valore il tipo che il compilatore aveva dedotto da sé.


interface VoceStrumento {
  titolo: string;
  categoria: 'rete' | 'testo' | 'immagini';
}

// satisfies: controlla il tipo e conserva le chiavi letterali.
export const strumenti = {
  'json-formatter': { titolo: 'Formattatore JSON', categoria: 'testo' },
  'subnet-calculator': { titolo: 'Calcolatore di sottoreti', categoria: 'rete' },
} satisfies Record<string, VoceStrumento>;

export type IdStrumento = keyof typeof strumenti;

export function titoloDi(id: IdStrumento): string {
  return strumenti[id].titolo;
}

console.log(titoloDi('subnet-calculator'));

// Sonde: un'assegnazione impossibile fa stampare al compilatore il tipo reale.
export const sondaId: never = null as unknown as IdStrumento;
export const sondaCategoria: never = strumenti['json-formatter'].categoria;

// Uscita di tsc 7.0.2:
// 02-satisfies.ts(21,14): error TS2322: Type '"json-formatter" | "subnet-calculator"' is not assignable to type 'never'.
//   Type '"json-formatter"' is not assignable to type 'never'.
// 02-satisfies.ts(22,14): error TS2322: Type '"testo"' is not assignable to type 'never'.

// Uscita di node 24.11.0:
// Calcolatore di sottoreti
      

La differenza con il blocco di prima è una parola e cambia tre cose. Le sonde in fondo le rendono misurabili: la prima mostra che IdStrumento è l'unione dei due identificativi, la seconda che categoria dentro la costante ha tipo 'testo', non l'unione delle tre categorie ammesse.

  • Il controllo di forma resta: se a una voce manca categoria, o se il suo valore non è fra i tre ammessi, il blocco non compila. È lo stesso servizio dell'annotazione.
  • Le chiavi restano letterali, quindi keyof typeof strumenti è l'unione dei due identificativi, e una funzione può accettare quel tipo invece di string.
  • I valori restano stretti: categoria dentro la costante ha tipo 'testo', non 'rete' | 'testo' | 'immagini', quindi può essere usata dove serve quel valore preciso.

Sono tre garanzie di natura diversa. La prima è una verifica a tempo di scrittura e la ottieni anche con l'annotazione; le altre due sono informazione che il compilatore conserva dopo la verifica, e sono quelle che rendono possibile il resto dell'articolo. Il dubbio su cui si perde tempo quando si legge keyof typeof per la prima volta è l'ordine: typeof strumenti prende il tipo del valore, cioè passa dal mondo dei valori a quello dei tipi, e keyof ne estrae l'unione delle chiavi. Senza typeof il compilatore cercherebbe un tipo chiamato strumenti, che non esiste.

L'errore, quando l'identificativo è sbagliato

È il momento in cui tutto il lavoro ripaga. Il messaggio dipende da dove sta il refuso: lo stesso identificativo sbagliato produce due errori diversi se è l'argomento di una funzione o il valore assegnato a una variabile.


interface VoceStrumento {
  titolo: string;
  categoria: 'rete' | 'testo' | 'immagini';
}

const strumenti = {
  'json-formatter': { titolo: 'Formattatore JSON', categoria: 'testo' },
  'subnet-calculator': { titolo: 'Calcolatore di sottoreti', categoria: 'rete' },
} satisfies Record<string, VoceStrumento>;

type IdStrumento = keyof typeof strumenti;

export function titoloDi(id: IdStrumento): string {
  return strumenti[id].titolo;
}

// Argomento di una funzione: errore con i valori ammessi, senza suggerimento.
export const titolo = titoloDi('json-formater');

// Assegnazione a una variabile: lo stesso errore, con il suggerimento.
export const id: IdStrumento = 'json-formater';

// Uscita di tsc 7.0.2:
// 03-id-inesistente.ts(18,32): error TS2345: Argument of type '"json-formater"' is not assignable to parameter of type '"json-formatter" | "subnet-calculator"'.
// 03-id-inesistente.ts(21,14): error TS2820: Type '"json-formater"' is not assignable to type '"json-formatter" | "subnet-calculator"'. Did you mean '"json-formatter"'?
      

Entrambe le righe sono rifiutate, e in entrambe il compilatore elenca i valori ammessi. Solo l'assegnazione, errore TS2820, aggiunge il suggerimento «Did you mean», e nel mio esperimento il suggerimento non compare sull'argomento di funzione, che dà l'errore TS2345. Con l'annotazione quella riga non avrebbe prodotto nessun errore, e il refuso si sarebbe manifestato come una pagina vuota o un valore indefinito, in un punto del programma che non ha niente a che fare con il catalogo.

Il guadagno vero: i tipi che si derivano da sé

Conservare le chiavi letterali non serve solo a evitare un refuso. Serve perché da quella costante si possono ricavare altri tipi, e quei tipi restano allineati al catalogo senza che nessuno li aggiorni. È la parte che cambia il modo di organizzare un progetto, e si vede meglio con la forma completa.


interface VoceStrumento {
  titolo: string;
  categoria: 'rete' | 'testo' | 'immagini';
}

export const catalogo = {
  'json-formatter': { titolo: 'Formattatore JSON', categoria: 'testo' },
  'subnet-calculator': { titolo: 'Calcolatore di sottoreti', categoria: 'rete' },
} as const satisfies Record<string, VoceStrumento>;

export type IdCatalogo = keyof typeof catalogo;

// Le categorie effettivamente usate, derivate dal catalogo e non riscritte a mano.
export type CategoriaUsata = (typeof catalogo)[IdCatalogo]['categoria'];

// Un contenitore che deve avere una voce per ogni strumento: niente dimenticanze.
export type ConteggioPerStrumento = Record<IdCatalogo, number>;

export const conteggi: ConteggioPerStrumento = {
  'json-formatter': 0,
  'subnet-calculator': 0,
};

// Sonda: il compilatore dice quali sono le categorie presenti.
export const sonda: never = null as unknown as CategoriaUsata;

// Uscita di tsc 7.0.2:
// 04-catalogo.ts(25,14): error TS2322: Type '"rete" | "testo"' is not assignable to type 'never'.
//   Type '"rete"' is not assignable to type 'never'.
      

Tre righe di questo blocco meritano una spiegazione, perché sono tre tecniche distinte che si riusano in contesti diversi.

(typeof catalogo)[IdCatalogo]['categoria'] è un accesso indicizzato a un tipo, e si legge da sinistra a destra come un accesso a un valore. Prende il tipo del catalogo, lo indicizza con l'unione di tutte le chiavi, e del risultato prende il campo categoria. Dato che l'indice è un'unione, il risultato è l'unione dei valori corrispondenti: la sonda mostra "rete" | "testo", cioè le categorie effettivamente usate nel catalogo. La differenza con l'unione scritta a mano in VoceStrumento è sostanziale: quella elenca le categorie ammesse, questa le categorie presenti. Se togli l'ultimo strumento di rete, questo tipo si restringe da sé.

Record<IdCatalogo, number> costruisce un oggetto che deve avere una chiave per ogni strumento, e nessuna in più. È la tecnica che risolve la classe di difetti più noiosa in un progetto con un catalogo: la tabella parallela a cui manca una voce. Dimenticandone una, e confrontandola con la stessa dimenticanza su un oggetto annotato con Record<string, number>, si vede la differenza:


interface VoceStrumento {
  titolo: string;
  categoria: 'rete' | 'testo' | 'immagini';
}

const catalogo = {
  'json-formatter': { titolo: 'Formattatore JSON', categoria: 'testo' },
  'subnet-calculator': { titolo: 'Calcolatore di sottoreti', categoria: 'rete' },
} as const satisfies Record<string, VoceStrumento>;

type IdCatalogo = keyof typeof catalogo;

// Manca 'subnet-calculator'.
export const conteggi: Record<IdCatalogo, number> = {
  'json-formatter': 0,
};

// Con l'annotazione larga la stessa dimenticanza passa in silenzio.
export const conteggiLarghi: Record<string, number> = {
  'json-formatter': 0,
};

// Uscita di tsc 7.0.2:
// 05-voce-dimenticata.ts(14,14): error TS2741: Property '"subnet-calculator"' is missing in type '{ 'json-formatter': number; }' but required in type 'Record<"json-formatter" | "subnet-calculator", number>'.
      

Il primo errore nomina la chiave mancante, "subnet-calculator". Il secondo oggetto, conteggiLarghi, non produce nessun errore: la voce assente diventerebbe un valore indefinito dentro un conteggio. È il motivo per cui conviene fare il giro dalle chiavi derivate invece di scrivere la tabella contro string.

Che lavoro fa as const, e che lavoro non fa

Nel catalogo ho scritto as const satisfies, e la prima impressione è che as const serva a mantenere strette le categorie. Misurato, non è così. Il primo file confronta tre varianti dello stesso catalogo, e la sonda stampa le categorie che ne derivano.


interface VoceStrumento {
  titolo: string;
  categoria: 'rete' | 'testo' | 'immagini';
}

// Solo satisfies, senza as const.
const solo = {
  'json-formatter': { titolo: 'Formattatore JSON', categoria: 'testo' },
  'subnet-calculator': { titolo: 'Calcolatore di sottoreti', categoria: 'rete' },
} satisfies Record<string, VoceStrumento>;

type CategoriaSolo = (typeof solo)[keyof typeof solo]['categoria'];
export const sondaSolo: never = null as unknown as CategoriaSolo;

// Nessuno dei due: un campo sbagliato entra nel tipo.
const nessuno = {
  'json-formatter': { titolo: 'Formattatore JSON', categoria: 'testi' },
};
type CategoriaNessuno = (typeof nessuno)[keyof typeof nessuno]['categoria'];
export const sondaNessuno: never = null as unknown as CategoriaNessuno;

// Solo as const: il campo sbagliato entra nel tipo e resta letterale.
const soloConst = {
  'json-formatter': { titolo: 'Formattatore JSON', categoria: 'testi' },
} as const;
type CategoriaConst = (typeof soloConst)[keyof typeof soloConst]['categoria'];
export const sondaConst: never = null as unknown as CategoriaConst;

// Uscita di tsc 7.0.2:
// 06-senza-as-const.ts(13,14): error TS2322: Type '"rete" | "testo"' is not assignable to type 'never'.
//   Type '"rete"' is not assignable to type 'never'.
// 06-senza-as-const.ts(20,14): error TS2322: Type 'string' is not assignable to type 'never'.
// 06-senza-as-const.ts(27,14): error TS2322: Type '"testi"' is not assignable to type 'never'.
      

Con il solo satisfies, senza as const, la categoria è comunque "rete" | "testo": il tipo a cui l'oggetto deve adeguarsi contiene stringhe letterali, e il compilatore le conserva. Senza nessuno dei due, la categoria diventa string, e un errore di battitura come 'testi' entra senza un avviso. Con il solo as const l'errore di battitura entra nel tipo e resta letterale, "testi": il tipo è stretto e sbagliato. Ecco perché è satisfies, non as const, a fare il controllo.

Resta da capire che cosa aggiunge as const. Il file seguente lo mostra su due campi diversi.


interface VoceStrumento {
  titolo: string;
  categoria: 'rete' | 'testo' | 'immagini';
}

const solo = {
  'json-formatter': { titolo: 'Formattatore JSON', categoria: 'testo' },
} satisfies Record<string, VoceStrumento>;

const conConst = {
  'json-formatter': { titolo: 'Formattatore JSON', categoria: 'testo' },
} as const satisfies Record<string, VoceStrumento>;

// Il titolo: senza as const è string, con as const è il testo letterale.
export const s1: never = solo['json-formatter'].titolo;
export const s2: never = conConst['json-formatter'].titolo;

// Modificare una voce: senza as const si può, con as const no.
solo['json-formatter'].categoria = 'immagini';
conConst['json-formatter'].categoria = 'immagini';

// Uscita di tsc 7.0.2:
// 09-as-const.ts(15,14): error TS2322: Type 'string' is not assignable to type 'never'.
// 09-as-const.ts(16,14): error TS2322: Type '"Formattatore JSON"' is not assignable to type 'never'.
// 09-as-const.ts(19,1): error TS2322: Type '"immagini"' is not assignable to type '"testo"'.
// 09-as-const.ts(20,28): error TS2540: Cannot assign to 'categoria' because it is a read-only property.
      

Fa due cose. Rende letterali i valori che non hanno un tipo letterale a cui adeguarsi: il titolo è string con il solo satisfies e "Formattatore JSON" con as const. E rende l'oggetto di sola lettura: le righe 19 e 20 sono entrambe rifiutate, ma per ragioni diverse. La 19 perché 'immagini' non è 'testo', il tipo che la categoria ha mantenuto (TS2322); la 20 a prescindere dal valore, perché la proprietà è di sola lettura (TS2540). Per un catalogo che non deve cambiare a tempo di esecuzione, di sola lettura è la scelta giusta.

Quando l'annotazione resta la scelta giusta

satisfies non sostituisce l'annotazione in tutti i casi, e trattarlo come un rimpiazzo porta a usarlo dove non serve. La differenza sta nella direzione in cui vuoi che il tipo viaggi.

L'annotazione serve quando il tipo è il contratto e il valore deve adeguarsi: una configurazione che passi a una libreria, un oggetto che implementa un'interfaccia pubblica, un valore di scorta che deve avere esattamente la forma attesa altrove. Là la riqualificazione è il comportamento desiderato, perché vuoi che chi legge veda il contratto e non i dettagli di questa istanza. Un dubbio che si sente ripetere è che l'errore cada su un punto diverso: ho provato un catalogo con una categoria sbagliata in una voce, annotato e con satisfies.


interface VoceStrumento {
  titolo: string;
  categoria: 'rete' | 'testo' | 'immagini';
}

// Annotazione: l'errore cade sulla voce sbagliata.
export const annotato: Record<string, VoceStrumento> = {
  'json-formatter': { titolo: 'Formattatore JSON', categoria: 'testo' },
  'subnet-calculator': { titolo: 'Calcolatore di sottoreti', categoria: 'reti' },
};

// satisfies: dove cade l'errore?
export const controllato = {
  'json-formatter': { titolo: 'Formattatore JSON', categoria: 'testo' },
  'subnet-calculator': { titolo: 'Calcolatore di sottoreti', categoria: 'reti' },
} satisfies Record<string, VoceStrumento>;

// Uscita di tsc 7.0.2:
// 08-posizione-errore.ts(9,62): error TS2322: Type '"reti"' is not assignable to type '"immagini" | "rete" | "testo"'.
// 08-posizione-errore.ts(15,62): error TS2322: Type '"reti"' is not assignable to type '"immagini" | "rete" | "testo"'.
      

In questo esperimento i due errori cadono sulla stessa riga e sulla stessa colonna, la 62, cioè sul valore sbagliato dentro la voce. Quindi la posizione del messaggio non è una ragione per preferire l'annotazione: la ragione è il contratto. L'unica differenza fra le due righe di output è una questione di forma, e riguarda l'ordine con cui la 7.0 elenca i membri dell'unione, di cui ti ho avvertito all'inizio.

satisfies serve quando il valore è la fonte di verità e il tipo è solo un controllo: un catalogo, un elenco di rotte, una tabella di traduzioni, qualunque cosa da cui vuoi derivare altri tipi. La regola che uso è questa, ed è breve: se da quella costante devi ricavare un tipo con keyof o con un accesso indicizzato, serve satisfies; se la costante è una foglia che nessuno interroga, l'annotazione va benissimo ed è più leggibile.

C'è un terzo caso che vale la pena nominare perché è il più frequente nei progetti veri: una costante dichiarata con as const e nessuna delle due cose. as const congela i tipi letterali e non verifica niente, come mostra il campo 'testi' del file precedente, che entra nel tipo. La combinazione che dà tutto è as const satisfies Tipo, dove as const stringe e satisfies controlla, e per un catalogo di sola lettura è la forma che useresti sempre se non fosse un po' prolissa da leggere.

Da una costante con le chiavi conservate si ricavano cinque tipi diversi, ognuno utile in un punto diverso del programma. Sono indipendenti fra loro: ne userai quelli che ti servono.

  • keyof typeof c: l'unione degli identificativi, da usare come parametro di una funzione invece di string.
  • (typeof c)[keyof typeof c]: l'unione delle voci, utile quando una funzione accetta una voce qualunque del catalogo.
  • (typeof c)[K]['campo']: il tipo di un singolo campo, per derivare le categorie presenti invece di quelle ammesse.
  • Record<keyof typeof c, V>: una tabella parallela a cui non può mancare una voce.
  • Partial<Record<keyof typeof c, V>>: la stessa tabella quando le voci sono legittimamente facoltative, che è il caso delle sovrascritture.

I primi due descrivono l'insieme, il terzo scende a un campo, gli ultimi due costruiscono una struttura parallela al catalogo. Il quarto e il quinto sono in tensione apposta: scegliere fra Record e Partial è decidere se dimenticare una voce è un errore o è consentito, e quella decisione è meglio che la prenda il tipo che non il revisore.


interface VoceStrumento {
  titolo: string;
  categoria: 'rete' | 'testo' | 'immagini';
}

const catalogo = {
  'json-formatter': { titolo: 'Formattatore JSON', categoria: 'testo' },
  'subnet-calculator': { titolo: 'Calcolatore di sottoreti', categoria: 'rete' },
} as const satisfies Record<string, VoceStrumento>;

type Catalogo = typeof catalogo;

// 1. Gli identificativi.
export type Id = keyof Catalogo;
// 2. Una voce qualunque del catalogo.
export type Voce = Catalogo[Id];
// 3. Il campo di una voce precisa, che dipende dall'identificativo passato.
export function categoriaDi<K extends Id>(id: K): Catalogo[K]['categoria'] {
  return catalogo[id].categoria;
}
// 4. Una tabella a cui non può mancare nessuno strumento.
export type Tutte = Record<Id, number>;
// 5. La stessa tabella quando le voci possono mancare.
export type Alcune = Partial<Record<Id, number>>;

export const ridotte: Alcune = { 'subnet-calculator': 3 };

console.log(categoriaDi('subnet-calculator'), ridotte['json-formatter']);

// Sonde: ciò che il compilatore ha derivato.
export const s3: never = categoriaDi('subnet-calculator');
export const s2: never = null as unknown as Voce;
export const s5: never = null as unknown as Alcune;

// Uscita di tsc 7.0.2:
// 11-derivati.ts(31,14): error TS2322: Type '"rete"' is not assignable to type 'never'.
// 11-derivati.ts(32,14): error TS2322: Type 'Voce' is not assignable to type 'never'.
//   Type '{ readonly titolo: 'Formattatore JSON'; readonly categoria: 'testo'; }' is not assignable to type 'never'.
// 11-derivati.ts(33,14): error TS2322: Type 'Partial<Record<"json-formatter" | "subnet-calculator", number>>' is not assignable to type 'never'.

// Uscita di node 24.11.0:
// rete undefined
      

Il blocco mette i cinque tipi in un file. La funzione categoriaDi usa il terzo: il parametro di tipo K fa sì che il risultato dipenda dall'identificativo passato, e la prima sonda mostra che per 'subnet-calculator' il tipo è "rete", non l'unione delle categorie. Le altre due sonde mostrano la voce come oggetto di sola lettura e la tabella facoltativa. Node stampa rete e, per la voce che ridotte non contiene, undefined: è il costo di Partial, che riporta in scena l'assenza.

Che cosa sai fare adesso

Adesso sai perché annotare un oggetto letterale con un'interfaccia ti costa l'elenco delle sue chiavi, e sai verificarlo invece di crederci: l'identificativo con il refuso che compila è la prova. Sai che satisfies controlla la forma senza riqualificare il valore, e che questo è ciò che rende keyof typeof capace di restituire un'unione di stringhe letterali invece di string. Sai anche che a mantenere strette le categorie è satisfies e non as const, che a sua volta rende letterali gli altri valori e il catalogo di sola lettura.

Sai la regola per scegliere, che non dipende dal gusto: se dalla costante devi derivare un tipo, serve satisfies; se la costante deve rispettare un contratto altrui, serve l'annotazione. E conosci l'esistenza di noUncheckedIndexedAccess, il flag fuori da strict che decide se una lettura per indice può restituire undefined: in questo progetto è spento, verificato con la configurazione risolta.

Nel prossimo articolo, 06 sui tipi template literal, le chiavi smettono di essere un elenco scritto a mano e diventano una regola che il compilatore sa comporre, usando la convenzione con cui questo progetto nomina i valori che scrive nell'archivio del browser. Il lavoro sui dati che arrivano da fuori, che precede tutto questo, è nell'articolo 02 e nell'articolo 03.

Domande frequenti

Che differenza c'è fra annotare un oggetto e usare satisfies?

L'annotazione riqualifica il valore: da quel momento il compilatore lo guarda attraverso il tipo dichiarato, e l'informazione in più che aveva dedotto dal letterale è persa. satisfies verifica la compatibilità e lascia al valore il tipo dedotto, quindi le chiavi e i valori restano letterali.

Perché keyof sul mio oggetto restituisce string invece delle chiavi?

Perché l'oggetto è annotato con un tipo a indice, per esempio Record<string, T>. In quel tipo l'elenco delle chiavi non esiste, quindi keyof non può restituirlo. Serve satisfies al posto dell'annotazione.

A che serve typeof dentro keyof typeof?

A passare dal mondo dei valori a quello dei tipi. strumenti è una costante, non un tipo: typeof strumenti ne prende il tipo, e keyof ne estrae l'unione delle chiavi. Senza typeof il compilatore cercherebbe un tipo con quel nome e non lo troverebbe.

Una lettura per indice può restituire undefined?

Dipende da noUncheckedIndexedAccess, che non fa parte di strict. Quando è attiva ogni lettura per indice restituisce il tipo unito a undefined, e il compilatore segnala l'accesso senza controllo con l'errore TS18048. Senza l'opzione, una chiave inesistente ha un tipo che mente.

Conviene combinare as const e satisfies?

Per un catalogo di sola lettura sì: satisfies verifica la forma e conserva le categorie letterali, as const rende letterali gli altri valori e l'oggetto di sola lettura. Da solo, as const non controlla niente e un campo sbagliato entrerebbe nel tipo.

Nella stessa serie trovi anche Strict mode non basta.

Fonti

  • TypeScript 4.9 - l'operatore satisfies: la versione in cui satisfies è stato aggiunto, la definizione e l'esempio del refuso intercettato, pagina scaricata; consultata il 2026-11-13.
  • TypeScript Handbook - keyof: il comportamento di keyof sui tipi con firma di indice, pagina scaricata; consultata il 2026-11-13.
  • TypeScript - noUncheckedIndexedAccess: la definizione dell'opzione e l'esempio in cui undefined si aggiunge ai campi non dichiarati, pagina scaricata; consultata il 2026-11-13.
  • Tutti gli errori e le uscite sono prodotti da tsc --noEmit --strict --noImplicitReturns --target ES2022 --module ESNext --moduleResolution bundler file.ts (typescript 7.0.2, npm view typescript version il 2026-11-13) e da node file.ts (Node 24.11); per il file con noUncheckedIndexedAccess l'opzione è aggiunta alla riga di comando.

Prova Questi Strumenti

Strumenti gratuiti correlati a questo argomento.

Commenti

Caricamento commenti...

Accedi per commentare

Articoli e strumenti nuovi anche su Telegram

Il canale Telegram segnala gli articoli e gli strumenti nuovi del sito.

Ti è piaciuto questo articolo?

Esplora altri contenuti sul blog o scopri i miei progetti