Vai al contenuto

Da JSON a TypeScript

JSON to TypeScript

Deduce interfacce o tipi TypeScript da un esempio JSON, unendo i campi facoltativi e le unioni.

Si incolla una risposta JSON e si ottengono le interfacce TypeScript corrispondenti. L’inferenza fonde ogni record del campione invece di leggere il primo, così un campo che compare solo in alcuni esce facoltativo anziché obbligatorio — che è la differenza fra un tipo che compila e un tipo che è vero.

🔒 Funziona interamente nel tuo browsertypescriptjsoncodegentypes
Produci

JSON di esempio

Trascina un file .json

Letto in questa scheda. Non viene caricato niente.

Dagli tutti gli elementi che hai. Ogni record in più restringe la deduzione: un campo che manca in uno di loro è proprio quello che lo rende facoltativo.

TypeScript

Come si usa

  1. Incollare tutti i record che si hanno

    Viene letto e fuso ogni elemento di ogni array, non solo il primo. Tre record dicono molto più di uno, perché un campo che manca in uno di essi è esattamente ciò che rende quel campo facoltativo.

  2. Dare un nome al tipo radice

    Gli oggetti annidati prendono il nome dalla chiave che li contiene, al singolare per gli array, così `users` produce un `User`. Solo la radice ha bisogno di un nome dato a mano.

  3. Leggere i conteggi sotto l’uscita

    Tipi, campi facoltativi, unioni e quanti record sono stati fusi. Un conteggio di unioni sopra lo zero vuol dire che nel campione un campo ha contenuto due generi di valore diversi — vale la pena guardarlo prima di incollare il risultato in una base di codice.

  4. Copiare fuori le interfacce

    L’uscita è un insieme di interfacce esportate in ordine di dichiarazione, pronte da incollare in un `.d.ts` o accanto alla fetch che le restituisce.

Domande frequenti

È un validatore?

No. I tipi di TypeScript vengono cancellati in fase di build, quindi qui niente controlla la risposta a runtime: un server che cambia forma consegnerà un valore che mente sul proprio tipo. Se serve che il controllo avvenga davvero, dalla stessa schermata si può emettere Zod e analizzare con quello.

Perché un campo è di tipo `string` quando è una data?

Perché in JSON è una stringa. L’inferenza è strutturale: riporta quello che i valori sono, e non tira a indovinare che una stringa dall’aria ISO-8601 debba diventare una `Date`. Restringerlo è una decisione sulla propria base di codice, non sul campione.

E se un campo a volte è una stringa e a volte un numero?

Diventa un’unione, `string | number`, e il conteggio delle unioni in fondo sale. Di solito è un segnale sull’API più che sul tipo: un campo che cambia genere è un bug che aspetta da qualche parte a valle.

Vengono prodotti tipi letterali dal campione?

No: uno `status` che in tre record è sempre `"active"` esce comunque come `string`. Tre record non sono la prova di un enum, e un tipo letterale dedotto da troppo pochi dati è il genere di cosa che rompe una build una settimana dopo.

Può ricevere da

Dopo

Questi accettano ciò che produce questo strumento, così il risultato può passare direttamente.