JSON to TypeScript

Генерация TypeScript-интерфейсов из JSON

Попробовать пример
Имя корневого интерфейса:

Ввод JSON

Вывод TypeScript

Работает локально · Безопасно вставлять секреты
TypeScript-интерфейсы появятся здесь…

Что такое конвертация JSON в TypeScript?

Вставьте JSON-данные — и получите готовые TypeScript-интерфейсы: типизированные контракты, точно описывающие свойства объекта и тип каждого из них. Без них данные из JSON.parse() приходят с типом any — никакой подсказки редактора и никаких проверок компилятора при обращении к свойствам и присваивании значений. Конвертация JSON в TypeScript даёт эту безопасность без ручного написания интерфейсов.

TypeScript покрывает все шесть типов значений JSON: string, number, boolean, null, object и array. Каждый вложенный JSON-объект преобразуется в отдельный именованный интерфейс. Массивы типизируются по первому элементу. Результат соответствует тому, что JSON.parse() возвращает во время выполнения, поэтому интерфейсы отражают реальные данные, а не предположения.

Ручное написание интерфейсов для больших или глубоко вложенных JSON — утомительная и ошибкоопасная работа. Генератор JSON-в-TypeScript читает структуру автоматически, рекурсивно обрабатывает вложенность и выдаёт чистый код интерфейсов за секунды. Это особенно полезно при подключении незнакомого API, прототипировании с тестовыми данными или переводе JavaScript-кодовой базы на TypeScript. Кроме того, вы избавляетесь от необходимости отслеживать имена вложенных свойств и их типы вручную — и можете сосредоточиться на логике приложения, а не на шаблонном коде типов.

Зачем использовать генератор JSON в TypeScript?

Ручное написание TypeScript-интерфейсов вполне оправдано для небольших объектов, но быстро становится неудобным при вложенных структурах или больших ответах API. Представьте ответ API с 50 полями и тремя уровнями вложенности — написание вручную означает десятки интерфейсов, каждый из которых может содержать опечатки или пропущенные nullable-поля. Автоматический генератор создаёт весь набор за миллисекунды и снижает вероятность несоответствия типов между кодом и потребляемыми данными. Помимо точности, он синхронизирует типы с реальным контрактом API. Когда сервис меняет форму ответа, достаточно вставить обновлённый JSON и сгенерировать заново — это намного быстрее, чем искать каждое изменённое свойство в написанном вручную файле интерфейсов.

Мгновенная генерация интерфейсов
Вставьте любые JSON-данные и получите корректно типизированные интерфейсы за миллисекунды. Никакой конфигурации, никаких шагов сборки.
🔒
Данные остаются у вас
Вся конвертация происходит в браузере. JSON не покидает вашу машину — это важно при работе с production-данными или внутренними ответами API.
📋
Автоматическая обработка вложенных структур
Вложенные объекты генерируют отдельные именованные интерфейсы. Массивы, nullable-поля и смешанные типы разрешаются без ручного вмешательства.
🌐
Без аккаунта и установки
Работает в любом современном браузере. Не нужно устанавливать npm-пакеты, настраивать CLI-инструменты или заполнять формы регистрации.

Сценарии использования JSON to TypeScript

Интеграция с API на фронтенде
Вставьте JSON-ответ REST или GraphQL — и получите интерфейсы для ваших компонентов React, Angular или Vue. Типобезопасные props и состояние предотвращают неожиданные ошибки во время выполнения. Сгенерированные интерфейсы можно совместно использовать на фронтенде и бэкенде в монорепозитории, чтобы обе стороны договорились об одной форме данных.
Типизация ответов на бэкенде
Сервисы на Node.js и Deno, потребляющие сторонние API, выигрывают от сгенерированных интерфейсов. Опишите контракт один раз — и несоответствия формы данных будут обнаружены на этапе компиляции. Сгенерированные интерфейсы также служат лёгкой документацией для потребителей сервиса, снижая потребность в отдельных файлах схем или страницах вики.
Конфигурационные файлы DevOps
Инфраструктурные инструменты, такие как AWS CDK или Pulumi, используют JSON-конфигурации. Сгенерируйте TypeScript-типы для этих конфигураций и проверяйте их перед деплоем. Это позволяет выявить неверно настроенные деплои, вызванные опечатками или неправильными типами значений, до того как код попадёт в production.
Тестовые фикстуры в QA
Генерируйте интерфейсы из JSON-фикстур, чтобы проверки соответствовали ожидаемой форме данных. Обнаруживайте отсутствующие или переименованные поля до запуска тестов.
Контракты в пайплайнах обработки данных
Когда пайплайн генерирует JSON-вывод, сгенерированные интерфейсы работают как схема для нижестоящих потребителей. Изменения формы вывода вызывают ошибки компиляции.
Изучение TypeScript
Студенты и разработчики, только начинающие работать с TypeScript, могут вставить знакомые JSON-структуры и увидеть, как интерфейсы соотносятся с данными. Это помогает освоить переход от динамической к статической типизации.

Таблица соответствия типов JSON и TypeScript

Каждое значение JSON соответствует определённому типу TypeScript. В таблице ниже показано, как каждый примитив и структурный тип JSON транслируется. Это соответствие следует стандарту ECMA-404 и встроенным типам TypeScript.

Тип JSONПример значенияТип TypeScript
string"hello"string
number42, 3.14number
booleantrue, falseboolean
nullnullnull
object{"key": "value"} nested interface
array[1, 2, 3]number[] (inferred from first element)

interface vs type в TypeScript

TypeScript предлагает два способа описания формы объектов: объявления interface и псевдонимы type. Оба подходят для представления JSON-структур, но различаются по возможностям расширения и слияния. Большинство генераторов JSON-в-TypeScript выводят именно interface — это идиоматический выбор для форм объектов в TypeScript.

interface
Поддерживает слияние объявлений и синтаксис extends. Предпочтителен для форм объектов, особенно в публичных API и библиотеках. Может расширяться другими интерфейсами или пересекаться с типами.
type
Поддерживает union-типы, типы пересечений и mapped-типы. Лучше подходит для вычисляемых типов, дискриминированных объединений или когда нужно создать псевдоним примитива. Не может быть переоткрыт для слияния объявлений.

Примеры кода

Ниже приведены примеры генерации TypeScript-интерфейсов из JSON на разных языках и инструментах. Каждый фрагмент производит готовый к запуску вывод.

TypeScript
// Manual interface definition from a JSON shape
const json = '{"id": 1, "name": "Alice", "active": true}';
const parsed = JSON.parse(json);

interface User {
  id: number;
  name: string;
  active: boolean;
}

const user: User = parsed;
console.log(user.name); // "Alice" — fully typed
JavaScript (json-to-ts library)
import JsonToTS from 'json-to-ts';

const json = {
  id: 1,
  name: "Alice",
  address: { street: "123 Main St", city: "Springfield" },
  tags: ["admin", "user"]
};

const interfaces = JsonToTS(json, { rootName: "User" });
console.log(interfaces.join("\n\n"));
// interface Address {
//   street: string;
//   city: string;
// }
//
// interface User {
//   id: number;
//   name: string;
//   address: Address;
//   tags: string[];
// }
Python (datamodel-code-generator)
# Install: pip install datamodel-code-generator
# Generate TypeScript-style types from JSON using Pydantic models

# Command line:
# datamodel-codegen --input data.json --output model.py

# Or generate TypeScript directly with quicktype:
# pip install quicktype
# quicktype --lang ts --src data.json --out types.ts

import json

data = {"id": 1, "name": "Alice", "scores": [98, 85, 92]}

# Python equivalent using TypedDict (Python 3.8+)
from typing import TypedDict, List

class User(TypedDict):
    id: int
    name: str
    scores: List[int]

user: User = data  # type-checked by mypy
CLI (quicktype)
# Install quicktype globally
npm install -g quicktype

# Generate TypeScript interfaces from a JSON file
quicktype --lang ts --src data.json --out types.ts

# From a JSON string via stdin
echo '{"id": 1, "name": "Alice"}' | quicktype --lang ts

# Output:
# export interface Root {
#   id:   number;
#   name: string;
# }

Часто задаваемые вопросы

Как генератор обрабатывает опциональные поля?
Если значение JSON равно null, генератор помечает свойство как опциональное с суффиксом ? и присваивает тип null. Если вам нужно различать отсутствующие ключи и значения null, вы можете вручную скорректировать вывод — заменить null на undefined для отсутствующих свойств.
Можно ли конвертировать JSON-массивы в TypeScript?
Да. Если корневой JSON является массивом, генератор проверяет первый элемент для вывода типа элемента и создаёт интерфейс для этого элемента. Корневой тип становится этим интерфейсом с суффиксом []. Пустые массивы дают unknown[], поскольку нет элемента для анализа.
Что происходит с глубоко вложенными JSON-объектами?
Каждый вложенный объект генерирует отдельный именованный интерфейс. Имя выводится из ключа свойства, преобразованного в PascalCase. Например, свойство "shipping_address" даёт интерфейс ShippingAddress. Это сохраняет читаемость вывода даже для JSON с четырьмя-пятью уровнями вложенности. Если несколько вложенных объектов имеют одинаковую структуру, вы можете вручную объединить их в один общий интерфейс, чтобы избежать дублирования в кодовой базе.
Чем отличаются json2ts и quicktype?
json2ts — простой конвертер, который напрямую сопоставляет значения JSON с TypeScript-интерфейсами. quicktype идёт дальше: анализирует несколько JSON-примеров, дедуплицирует похожие структуры и поддерживает вывод на более чем 20 языках. Для разовых конвертаций браузерный инструмент быстрее. Для CI-пайплайнов или кодогенерации на нескольких языках лучше подойдёт quicktype.
Почему использовать interface вместо псевдонима type для JSON?
Интерфейсы поддерживают слияние объявлений — это значит, что вы можете расширить сгенерированный интерфейс в отдельном файле, не изменяя оригинал. Они также дают более чёткие сообщения об ошибках в большинстве редакторов. Псевдонимы type лучше подходят для union-типов или mapped-типов, но для простых форм JSON-объектов интерфейсы — стандартный выбор. При разработке библиотеки или SDK interface почти всегда правильный вариант: потребители могут дополнить его с помощью слияния объявлений, не затрагивая ваши исходники.
Справляется ли инструмент с JSON, где в массивах есть несогласованные типы?
Генератор выводит тип элемента массива по первому ненулевому элементу. Если массив содержит смешанные типы — например, объекты вперемешку со строками — вывод отражает только форму первого элемента. Для разнородных массивов нужно вручную определить union-тип после генерации — например, тип, принимающий как элементы Item, так и string — чтобы точно представить все возможные типы элементов.
Как использовать сгенерированные интерфейсы в реальном проекте?
Скопируйте сгенерированные интерфейсы в .ts-файл вашего проекта — обычно в директорию types/ или models/. Импортируйте их там, где вы получаете или обрабатываете JSON-данные. Если нужно гарантировать соответствие ответов API интерфейсу во время выполнения, а не только при компиляции, используйте runtime-валидатор: Zod или io-ts. С Zod можно вывести TypeScript-тип прямо из схемы с помощью утилиты infer, исключив дублирование между определением интерфейса и логикой валидации.
Обеспечивают ли сгенерированные TypeScript-интерфейсы безопасность типов во время выполнения?
Нет — система типов TypeScript стирается при компиляции. Интерфейсы существуют только в редакторе и в процессе сборки, но не во время выполнения. JSON.parse() всегда возвращает any, какой бы тип вы ни присвоили впоследствии. Для принудительной проверки типов во время выполнения используйте сгенерированные интерфейсы совместно с библиотекой Zod или io-ts. Эти библиотеки проверяют, что входящий объект действительно соответствует ожидаемой форме, — и защищают от некорректных ответов API, отсутствующих полей и неожиданных null-значений.