0Pricing
TypeScript Academy · Lezione

DeepPartial e DeepReadonly

Costruisca versioni ricorsive di Partial e Readonly.

DeepPartial e DeepReadonly è una lezione TypeScript Academy gratuita su CoddyKit. Questa è la lezione 1 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.

Perché utilizzare utility type profondi?

I tipi integrati Partial e Readonly si applicano a un solo livello di profondità. Per gli oggetti annidati sono necessarie versioni ricorsive.

interface Config {
  db: { host: string; port: number };
  app: { name: string };
}
type Shallow = Partial<Config>;
// Shallow.db is still required — only top level is optional

Implementazione di DeepPartial

Esegua il mapping ricorsivo sulle proprietà dell'oggetto, rendendole tutte facoltative e applicando ricorsivamente DeepPartial se il valore della proprietà è un oggetto.

type DeepPartial<T> = T extends object
  ? { [K in keyof T]?: DeepPartial<T[K]> }
  : T;

DeepPartial in azione

Applichi DeepPartial a un tipo di configurazione annidato e osservi come tutti i livelli diventano facoltativi.

type PartialConfig = DeepPartial<Config>;
// PartialConfig.db?: { host?: string; port?: number }

const c: PartialConfig = { db: { host: "localhost" } };
// No error — all other fields are optional

Implementazione di DeepReadonly

Renda ogni proprietà, a qualsiasi livello di profondità, readonly ricorrendo nei tipi oggetto annidati.

type DeepReadonly<T> = T extends object
  ? { readonly [K in keyof T]: DeepReadonly<T[K]> }
  : T;

DeepReadonly in azione

Una configurazione congelata in profondità non può essere modificata a nessun livello.

type ReadonlyConfig = DeepReadonly<Config>;
const cfg: ReadonlyConfig = { db: { host: "localhost", port: 5432 }, app: { name: "my-app" } };
// cfg.db.port = 3000; // Error: readonly

Gestione degli array nei tipi profondi

Gli array richiedono una gestione speciale: esegua il mapping ricorsivo sui tipi degli elementi invece di trattare gli array come semplici oggetti.

type DeepPartial<T> =
  T extends (infer U)[]
    ? DeepPartial<U>[]
    : T extends object
      ? { [K in keyof T]?: DeepPartial<T[K]> }
      : T;

Gestione dei tipi primitivi

Il caso base della ricorsione deve restituire i tipi primitivi così come sono, senza racchiuderli in un mapped type di oggetto.

type DeepReadonly<T> =
  T extends string | number | boolean | null | undefined ? T
  : T extends (infer U)[] ? ReadonlyArray<DeepReadonly<U>>
  : { readonly [K in keyof T]: DeepReadonly<T[K]> };

Combinazione di DeepPartial e DeepReadonly

È possibile combinarli per creare un tipo profondamente parziale e readonly, utile per applicare patch sicure alla configurazione.

type SafePatch<T> = DeepReadonly<DeepPartial<T>>;

Considerazioni sulle prestazioni

I tipi ricorsivi applicati a oggetti molto grandi possono rallentare il controllo dei tipi di TypeScript. Per il codice in cui le prestazioni sono critiche, consideri limiti di profondità o una valutazione lazy.

// For very deep schemas, consider using Zod or io-ts
// which provide runtime + compile-time deep typing

Uso nel mondo reale: patch dello stato React

DeepPartial è perfetto per le funzioni di patch dello stato che accettano solo il sottoinsieme modificato di un oggetto di stato di grandi dimensioni.

function patch<T>(state: T, changes: DeepPartial<T>): T {
  return { ...state, ...changes } as T;
}

Riepilogo: utility type profondi

DeepPartial e DeepReadonly sono mapped type ricorsivi che applicano il proprio modificatore a ogni livello di un oggetto annidato. Gestisca gli array separatamente e utilizzi casi base per i tipi primitivi.

Verifica rapida

Qual è il caso base ricorsivo corretto per DeepPartial?

Cosa ha imparato

Ha implementato DeepPartial e DeepReadonly utilizzando mapped type ricorsivi. Gestisca gli array come caso speciale e restituisca sempre i tipi primitivi invariati nel caso base.

Domande Frequenti

La lezione «DeepPartial e DeepReadonly» è gratuita?

Sì — il testo completo di «DeepPartial e DeepReadonly» è 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 «DeepPartial e DeepReadonly»?

Costruisca versioni ricorsive di Partial e Readonly. 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 1 di 4.

Quanto tempo richiede la lezione «DeepPartial e DeepReadonly»?

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

  1. DeepPartial e DeepReadonly
  2. Utility Flatten e UnwrapPromise
  3. TupleToUnion e UnionToIntersection
  4. Pubblicazione di una libreria di utility per i tipi
← Torna a TypeScript Academy