JSON in TypeScript, Python e SQL

Trasforma un oggetto JSON, o un array di oggetti, in un'interfaccia TypeScript, in una classe Python, in un modello Pydantic o in SQL. La formattazione resta nel formattatore JSON

Che cosa costruisce questa pagina

Un campione di API è spesso un oggetto JSON, o un array di oggetti. Questa pagina scrive un'interfaccia TypeScript, una classe Python, un modello Pydantic, oppure un CREATE TABLE e un INSERT per oggetto. Formattazione e riparazione restano nel formattatore JSON.

Come si usa

  1. Incolla il JSON nella casella. Aggiorna mentre scrivi è attivo.
  2. Direzione è Interfaccia TypeScript, SQL CREATE TABLE + INSERT, Classe Python o Modello Pydantic. Nome parte da Item. Proprietà facoltative parte selezionato. L'ultima casella è export in TypeScript e import in Python o Pydantic.
  3. Converti esegue una volta. Mostra esempio riempie {"id":1,"name":"Ada","ok":true,"tags":["a","b"],"meta":{"n":2}}, mette Direzione su Interfaccia TypeScript, Nome su Item e lascia entrambe le caselle attive. Il risultato ha export interface Item con id?: number, name?: string, ok?: boolean, tags?: string[] e meta?: ItemMeta, più export interface ItemMeta con n?: number.
  4. Passa Direzione a SQL CREATE TABLE + INSERT. La tabella è item. Le colonne sono id BIGINT NOT NULL, name TEXT NOT NULL, ok BOOLEAN NOT NULL, tags TEXT NOT NULL e meta TEXT NOT NULL. L'INSERT è 1, 'Ada', 1, '["a","b"]', '{"n":2}'.
  5. Passa Direzione a Classe Python e lascia selezionati Proprietà facoltative e import. Il risultato inizia con from dataclasses import dataclass e from typing import Optional, List, poi la classe @dataclass ItemMeta con n: Optional[int] = None, poi la classe @dataclass Item con id, name, ok, tags: Optional[List[str]] = None e meta: Optional[ItemMeta] = None. Passa Direzione a Modello Pydantic: gli import aggiungono from pydantic import BaseModel ed entrambe le classi estendono BaseModel, senza @dataclass. Mostra esempio resta su Interfaccia TypeScript.
  6. Cancella tutto svuota le due caselle. Copia risultato copia l'uscita.

Come vengono scelti i tipi

La radice deve essere un oggetto, o un array di oggetti. Un numero, una stringa o un array di numeri si ferma con un errore. Un oggetto senza chiavi si ferma con un errore.

TypeScript usa boolean, number e string. Un array di uno di quei tipi diventa T[]. Un array vuoto diventa unknown[]. Un oggetto annidato diventa un'altra interfaccia: il nome del padre più la chiave, così meta sotto Item è ItemMeta. I tipi misti diventano unknown. Proprietà facoltative aggiunge ? su ogni campo. Se la radice è un array e a qualche oggetto manca una chiave, quel campo è facoltativo anche con Proprietà facoltative spento. export scrive export interface. Una radice che è un array aggiunge il commento // JSON root is Nome[].

SQL mette Nome in minuscolo e converte gli altri caratteri in trattini bassi, così Order Line diventa order_line. Gli interi sono BIGINT, gli altri numeri sono DOUBLE, i booleani sono BOOLEAN e si scrivono come 1 o 0, e le stringhe sono TEXT. Un oggetto o un array annidato è TEXT con il testo JSON. Un apostrofo dentro una stringa viene raddoppiato. Una chiave che è null, o che manca in qualche riga, accetta NULL. Ogni oggetto è un INSERT.

Dove si usa

  • Abbozzare un'interfaccia TypeScript da un campione di API.
  • Caricare un array JSON quando i campi annidati possono restare testo JSON.
  • Controllare che un apostrofo dentro un nome sia salvato come due apostrofi.

Domande

Perché meta è una seconda interfaccia?

È un oggetto, quindi TypeScript lo chiama ItemMeta. In SQL quello stesso campo è TEXT con {"n":2}.

Perché un array di numeri è fallito?

Ogni oggetto diventa una riga. Un array di numeri non ha colonne.