Generi un'interfaccia TypeScript da JSON
Incolli un oggetto di esempio e ottenga un’interfaccia TypeScript pronta: nell’esempio id diventa number, tags diventa string[] e la chiave display-name resta tra virgolette, il tutto con il nome UserRecord. Gratis nel suo browser.
- Gratis
- Funziona nel suo browser
- Senza registrazione
- I suoi dati restano sul dispositivo
Esegui gratis nel browser
Lo strumento analizza l'esempio, verifica che la radice sia un oggetto e produce un'interfaccia deterministica per stringhe, numeri, booleani, valori null, array e oggetti annidati.
Come viene dedotto ogni tipo
Il generatore guarda ogni valore del suo esempio, non il nome delle chiavi. Un testo diventa string, qualsiasi numero diventa number, vero o falso riceve il proprio tipo sì-no e un valore vuoto diventa null. Gli oggetti dentro altri oggetti diventano tipi annidati, e gli elenchi vengono valutati su tutti gli elementi, non solo sul primo: un elenco di soli testi dà string[], uno misto un’unione come (string | number | null)[]. Le chiavi che non si possono scrivere così come sono, come display-name, restano tra virgolette, e le proprietà mantengono l’ordine dell’esempio originale.
Errori tipici e come evitarli
Un solo esempio non può dimostrare che un dato sia facoltativo, quindi tutte le proprietà risultano obbligatorie; le corregga a mano dove i dati reali possono omettere qualcosa. Un elenco vuoto non offre indizi e diventa unknown[], un oggetto vuoto diventa Record<string, never>, perciò conviene scegliere un esempio con elenchi e oggetti pieni. Il testo deve seguire un formato di dati rigoroso, non JavaScript: nomi tra virgolette doppie, niente commenti né virgole finali e un oggetto al livello superiore. Date, valori fissi ed enumerazioni non vengono mai inventati.
Parta da un esempio simile ai dati reali
Gli oggetti annidati sono rappresentati come tipi oggetto dentro l'interfaccia radice. Ogni proprietà rilevata nell'esempio viene emessa come obbligatoria, perché un unico campione non può dimostrare che un campo sia facoltativo. Per un risultato utile, scelga un campione contenente campi e varianti realmente ricevuti dall'applicazione.
Può anche fornire un nome radice come <code>UserResponse</code>; deve essere un identificatore TypeScript valido e non riservato. Se lo omette, viene usato <code>RootObject</code>. Radici scalari, nulle o array vengono rifiutate.
Comprenda array, valori null e strutture annidate
L'inferenza degli array considera ogni elemento del campione, non soltanto il primo. Un elenco composto solo da stringhe diventa <code>string[]</code>, mentre un elenco misto produce un'unione stabile come <code>(string | number | null)[]</code>. Un array vuoto non offre indicazioni sul tipo degli elementi e diventa quindi <code>unknown[]</code>, senza introdurre ipotesi fuorvianti.
Gli oggetti negli array sono espressi come tipi oggetto inline e gli array annidati vengono elaborati ricorsivamente. Gli oggetti vuoti diventano <code>Record<string, never></code>, indicando che il campione non ha mostrato campi noti. Le chiavi non utilizzabili come normali identificatori TypeScript, comprese quelle con spazi, punteggiatura o parole riservate, vengono emesse come proprietà stringa tra virgolette.
Il generatore non inventa indicatori facoltativi, date, tipi letterali, enum o nomi di classe specifici del dominio.
Domande frequenti
Quali input sono accettati?
Array, scalari e null alla radice vengono rifiutati.
Come vengono tipizzati gli array vuoti?
Diventano unknown[] perché un campione vuoto non offre indicazioni sul tipo dei suoi elementi.
Che tipo di testo posso incollare?
Un testo di dati rigoroso il cui livello superiore sia un oggetto. I nomi richiedono virgolette doppie, e commenti o virgole finali non sono ammessi. Un valore singolo, un null o un elenco al livello superiore vengono rifiutati, perché il risultato descrive un oggetto.
Posso scegliere il nome dell’interfaccia?
Sì. Indichi un nome come UserRecord; deve essere un nome TypeScript valido e non una parola riservata. Se lo lascia vuoto, l’interfaccia si chiama RootObject, così ogni ripetizione produce sempre lo stesso testo.
Che tipo riceve un elenco con valori misti?
Vengono controllati tutti gli elementi, non solo il primo. Un elenco di soli testi diventa string[], mentre un misto produce un’unione stabile come (string | number | null)[], quindi il risultato riflette esattamente ciò che mostra l’esempio.
Le proprietà vengono segnate come facoltative?
No. Un solo esempio non può dimostrare che un dato sia facoltativo, quindi ogni proprietà trovata viene indicata come obbligatoria. Dove i suoi dati reali possono omettere qualcosa, la modifichi a mano dopo la generazione.
Strumenti correlati
Per sviluppatori — accesso via API
Tutto quello che vedi in questa pagina è disponibile anche via API. Questa sezione è per i team che vogliono integrarlo nei propri sistemi; chi non ne ha bisogno può semplicemente usare lo strumento qui sopra.
Endpoint
Autenticazione con Bearer token: un POST mette in coda l'attività e il risultato arriva via webhook o link firmato.
Chiamala dal tuo stack
curl -X POST https://api.kit.forhosting.com/dev2/json-to-typescript-interface \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"json":"{\"id\":42,\"name\":\"Ada\",\"active\":true,\"tags\":[\"admin\",\"editor\"],\"profile\":{\"email\":\"ada@example.com\",\"score\":9.5}}"}'const res = await fetch("https://api.kit.forhosting.com/dev2/json-to-typescript-interface", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"json": "{\"id\":42,\"name\":\"Ada\",\"active\":true,\"tags\":[\"admin\",\"editor\"],\"profile\":{\"email\":\"ada@example.com\",\"score\":9.5}}"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/dev2/json-to-typescript-interface",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"json": "{\"id\":42,\"name\":\"Ada\",\"active\":true,\"tags\":[\"admin\",\"editor\"],\"profile\":{\"email\":\"ada@example.com\",\"score\":9.5}}"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev2/json-to-typescript-interface", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"json":"{\\"id\\":42,\\"name\\":\\"Ada\\",\\"active\\":true,\\"tags\\":[\\"admin\\",\\"editor\\"],\\"profile\\":{\\"email\\":\\"ada@example.com\\",\\"score\\":9.5}}"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"json":"{\"id\":42,\"name\":\"Ada\",\"active\":true,\"tags\":[\"admin\",\"editor\"],\"profile\":{\"email\":\"ada@example.com\",\"score\":9.5}}"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev2/json-to-typescript-interface", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Esempio di richiesta
{
"json": "{\"id\":42,\"name\":\"Ada\",\"active\":true,\"tags\":[\"admin\",\"editor\"],\"profile\":{\"email\":\"ada@example.com\",\"score\":9.5}}"
}Esempio di risposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev2.json_to_typescript_interface",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}L'API è asincrona: ricevi subito un task_id e puoi fare polling fino a 1 richiesta al secondo.
Prezzi
Prezzo pubblicato, senza token né crediti. Se l'attività fallisce, non paghi.
Limiti
max_chars | 1000000 |
max_depth | 64 |
Errori
| HTTP | Codice | Significato |
|---|---|---|
401 | unauthorized | Chiave API mancante o non valida: controlla l'header Authorization. |
402 | insufficient_balance | Credito esaurito: ricarica per continuare a eseguire attività. |
404 | unknown_type | Tipo di attività sconosciuto: controlla il campo type della richiesta. |
429 | rate_limited | Troppe richieste in poco tempo: rallenta e riprova tra qualche secondo. |
Note tecniche
Trasformi un oggetto JSON rappresentativo in un'interfaccia TypeScript senza installare un generatore né seguire manualmente ogni valore annidato. Protegge inoltre con virgolette le chiavi JSON insolite e consente di scegliere il nome dell'interfaccia radice.
Parta da un oggetto JSON rappresentativo
Incolli un JSON valido il cui valore radice sia un oggetto, per esempio una risposta API, un record di configurazione, un payload webhook o un documento archiviato. Il generatore esamina i valori anziché i nomi dei campi: una stringa diventa <code>string</code>, qualsiasi numero JSON diventa <code>number</code>, un booleano diventa <code>boolean</code> e un valore nullo diventa <code>null</code>. L'input deve essere testo JSON, non sintassi di oggetti JavaScript: i nomi richiedono virgolette doppie, i commenti non sono ammessi e le virgole finali non sono valide.
Comprenda array, valori null e strutture annidate
L'output descrive così fedelmente le evidenze contenute nel JSON fornito. L'ordine delle proprietà segue il JSON originale, mentre i membri delle unioni usano un ordine deterministico.
Verifichi l'interfaccia generata prima della produzione
Se un campione contiene null e un altro una stringa, incorpori tale conoscenza nel tipo mantenuto. L'output deterministico facilita la revisione: gli stessi input e nome producono sempre lo stesso testo, senza rete, modelli, casualità o data corrente. Consideri la definizione generata una descrizione accurata dell'esempio e un ottimo primo abbozzo per il codice reale, non la prova del contratto completo di un'API esterna. La confronti con più payload o con la documentazione del fornitore prima di stabilire se le proprietà debbano essere facoltative, annullabili, più ristrette o condivise tramite interfacce con nome. Un timestamp rimane una stringa perché JSON non possiede un tipo data, mentre un intero rimane <code>number</code> perché TypeScript non distingue gli interi JSON durante l'esecuzione. JSON non valido, testo mancante, nomi errati, annidamento eccessivo e radici non oggetto restituiscono <code>invalid_input</code>. L'API parte da $0.002 per richiesta e il browser applica localmente la stessa logica pura.
Casi di integrazione
Tipizzare una risposta API sconosciuta
Crei una prima interfaccia pratica da una risposta acquisita, quindi perfezioni i campi facoltativi usando la documentazione.
Documentare i payload webhook
Converta un evento rappresentativo in TypeScript leggibile e condivisibile dal servizio ricevente e dai test.
Avviare fixture e integrazioni
Generi tipi annidati stabili per configurazioni, record importati o dati di test senza seguire ogni proprietà a mano.
Domande tecniche
Le proprietà vengono segnate come facoltative?
No. Le proprietà presenti sono obbligatorie. Verifichi più payload o uno schema autorevole per individuare i campi facoltativi.
Riconosce date o enum?
No. Le stringhe JSON restano string e da un solo campione non vengono dedotte semantica di dominio o restrizioni enum.
Quanto costa una richiesta API?
Una richiesta API parte da $0.002. L'esecutore nel browser usa la stessa logica deterministica.