I-convert ang JSON sa mga TypeScript type!

Maglagay ng JSON para gawing TypeScript interface! Sinusuportahan ang TypeScript interface. Nasa mga tab sa itaas ang TypeORM · Sequelize · Mongoose.
JSON
Resulta
 

I-convert ang JSON sa mga TypeScript type!

Binabasa ng tool na ito ang isang JSON value at isinusulat ang mga TypeScript interface declaration para dito. Eksaktong napapanatili ang mga key; pinagsasama sa iisang interface ang mga array ng object, nakakakuha ng ? ang mga key na nasa ilang item lang, at nagiging union type ang mga halo-halong value.

Gamitin ito para lagyan ng type ang mga fetch o axios response sa frontend, para mag-declare ng mga return type para sa mga Next.js API route o Express handler, o tuwing mga halimbawang response lang ang idinodokumento ng isang backend at walang type definition.

Paano gamitin

  1. I-paste ang isang response JSON, halimbawa ang kinopya mula sa Network tab ng DevTools.
  2. Ilagay sa Pangalan ng type ang pangalan ng root interface (hal. ChannelHistory); nananatili ito sa URL bilang ?name=.
  3. I-save ang output sa isang file gaya ng types.ts at gamitin ito sa pamamagitan ng import type { ChannelHistory } from "./types".

Halimbawa

Input (JSON)
{
  "channel": "general",
  "messages": [
    { "id": "m1", "user": "kim", "text": "deploy done", "reactions": ["+1"] },
    { "id": "m2", "user": "lee", "text": null, "edited": true, "attachment": { "type": "image", "url": "https://cdn.example.com/a.png" } }
  ],
  "cursor": 42
}
Output (TypeScript)
export interface ChannelHistory {
  channel: string;
  messages: Message[];
  cursor: number;
}

export interface Message {
  id: string;
  user: string;
  text: string | null;
  reactions?: string[];
  edited?: boolean;
  attachment?: Attachment;
}

export interface Attachment {
  type: string;
  url: string;
}

Pinagsasama sa iisang Message interface ang dalawang message; nasa isa lang sa kanila ang reactions, edited at attachment, kaya nakakakuha sila ng ?. Halo ang string at null sa text, kaya string | null ito. Kinukuha ng mga element interface ang singular na anyo ng key (messages → Message).

Mga sinusuportahang feature

  • export interface ang bawat declaration, handang i-import sa ibang lugar.
  • Hindi pinapalitan ang pangalan ng mga JSON key, kaya one-to-one na tugma ang mga type sa response object; naka-quote ang mga key na hindi valid na identifier ("a-b", "2fa").
  • Pinagsasama ng mga array ng object ang mga key mula sa bawat element; nagiging optional (?:) ang mga key na wala sa ilang element.
  • Gumagawa ng union (string | number) ang mga halo-halong type; idinudugtong sa huli ang null bilang | null. Nagiging (string | number)[] ang mga halo-halong array.
  • Walang element type na mai-infer ang mga empty array kaya nagiging unknown[] sila.
  • Kapag array ang top level, gumagawa rin ito ng alias gaya ng export type Root = RootItem[];.

Mga gamit

Paglalagay ng type sa mga fetch at axios response

Ipasa ang type bilang generic, hal. const res = await axios.get<ChannelHistory>(url), at babalaan ka ng editor na puwedeng null ang res.data.messages[0].text.

Mga third-party API na walang typing

Para sa mga internal o external na API na walang SDK o @types package, sapat na ang isang sample response para gumawa ng type definition file na maibabahagi sa team.

Mock data at mga component prop

Gumawa ng mga interface mula sa Storybook o test mock JSON at gamitin sila bilang props type ng mga component; kapag lumayo ang mga mock sa mga component, sasabihan ka ng compiler.

Mga paalala at limitasyon

  • Binubura ang mga interface sa compile time at hindi nila sinusuri sa runtime kung talagang ganoon ang hugis ng isang response. Ipares sila sa isang schema library gaya ng zod kung kailangan mo ng runtime validation.
  • number ang lahat ng numero (walang hiwalay na integer/float), at string ang mga date string.
  • Lumalabas na string ang mga field na may fixed na set ng value, gaya ng "status": "active"; ikaw na ang magpaliit sa kanila bilang literal union ("active" | "banned").
  • May kanya-kanyang interface ang magkaparehong hugis sa ilalim ng magkaibang key, at nakakakuha ng numeric suffix gaya ng Profile2 ang mga nagbabanggaang pangalan.

Mga madalas itanong

Puwede ba akong makakuha ng type alias sa halip na interface?

Para lang sa top-level na array o primitive ginagamit ang type alias; laging interface ang mga object. Pareho ang behavior para sa layuning ito kapag isinulat ulit ang export interface X { ... } bilang export type X = { ... };.

Bakit magkahiwalay ang optional (?) at | null?

Magkaiba ang ibig sabihin nila: sinasabi ng ? na puwedeng wala ang key (undefined), habang sinasabi ng | null na nandoon ang key pero null ang value. Kapag naka-on ang strictNullChecks, magkaiba ang paghawak mo sa dalawang kaso.

Bakit hindi kino-convert sa camelCase ang mga key?

Inilalarawan ng isang TypeScript type ang totoong object, kaya hindi na tutugma sa response ang mga key na pinalitan ng pangalan. Kung gusto mo ng camelCase sa code mo, mag-define ng hiwalay na type para sa resulta ng mapping function mo.

Kailangan ko ng mga ORM entity (TypeORM, Sequelize, Mongoose).

Mga simpleng type declaration lang ang inilalabas ng page na ito. Gumagawa ng entity at model code mula sa parehong JSON ang mga tab na TypeORM, Sequelize at Mongoose sa itaas.