Skip to content

JSON 转 TOML 转换器

在浏览器中粘贴 JSON,即刻得到 TOML。安全处理 null、检查顶层表,输出适配 Cargo.toml 与 pyproject.toml,100% 本地运行,无需上传,隐私安全。

无追踪 浏览器中运行 免费
0 字符
TOML 输出
0
已针对 TOML 1.0.0 规范合规性、顶层表强制与透明的 null 处理进行审核 — Go Tools 工程团队 · 2026年7月2日

什么是 TOML,为什么要从 JSON 转换?

TOML(Tom's Obvious, Minimal Language,汤姆的显而易见的极简语言)是一种配置文件格式,构建目标是无歧义、便于人类阅读与编辑。它是 Rust 生态(Cargo.toml)、现代 Python 打包(pyproject.toml)以及 Hugo、Netlify、Poetry、Foundry 等工具的标准配置格式。JSON 则是工具和 API 产出的通用机器格式。当你手上有作为 JSON 的结构化数据、但需要一份人可编辑的 TOML 配置作为目标时 — 生成 Cargo.toml 或 pyproject.toml,或把应用的 JSON 设置变成可读的配置文件 — 把 JSON 转换为 TOML 就很常见。

TOML 比 JSON 更有结构,而本工具把这种严格性变成指引,而非晦涩的失败:

**1. 顶层表强制。** 每个 TOML 文档的根都是一个表 — 裸数组或标量都不是有效的 TOML。本工具不会为 { 顶层数组 } 的输入产出损坏的输出,而是检测到它并准确告诉你如何把数据包在一个键下,因此你总能得到有效的 TOML 或清晰的解释。

**2. 安全、透明的 null 处理。** JSON 有 null,TOML 没有。大多数转换器要么崩溃,要么悄悄丢弃数据。本工具很明确:值为 null 的对象键会被丢弃,被移除的键会列在一条警告里;而数组内部的 null — 没有有效的 TOML 表示 — 会产生一个精确的、指向路径的错误。你绝不会因缺失数据而措手不及。

**3. 惯用的 TOML 输出。** 嵌套对象变成 [表],深度嵌套对象变成点分表([tool.ruff]),对象数组变成表数组([[section]])— 正是真实的 Cargo.toml 和 pyproject.toml 文件所用的形态。转换由零依赖、符合 TOML 1.0.0 的 smol-toml 库驱动。

**4. 100% 基于浏览器的隐私。** 你的 JSON — 可能包含凭据、令牌或内部服务细节 — 绝不会离开你的浏览器。无上传、无服务器、无日志。在浏览器的「网络」标签中即可确认。

需要反向转换?请使用 TOML 转 JSON 转换器。在处理其他配置格式?试试 JSON 转 YAML 转换器YAML 转 JSON 转换器,或先用 JSON 格式化工具 清理你的 JSON 输入。每种格式都有其定位:JSON 用于机器交换,TOML 用于人工编辑的应用与工具配置,YAML 用于深度嵌套的基础设施清单。本转换器让你无需编写任何代码即可从 JSON 转到 TOML。

// Convert JSON to TOML in Node.js using the smol-toml library
import { stringify } from 'smol-toml';

const data = JSON.parse(`{
  "package": { "name": "my-app", "version": "1.0.0" },
  "dependencies": { "serde": { "version": "1.0" } }
}`);

// The top-level value must be an object; null values on objects are dropped.
const toml = stringify(data);

console.log(toml);
// [package]
// name = "my-app"
// version = "1.0.0"
//
// [dependencies.serde]
// version = "1.0"

核心功能

实时转换

当你输入或粘贴 JSON 时,TOML 输出会即刻更新 — 无需「转换」按钮。大型输入(>200KB)会自动切换到手动模式,以保持浏览器响应流畅。

顶层表指引

TOML 文档的根必须是一个表。如果你的 JSON 顶层是数组或标量,工具会准确告诉你如何把它包在一个键下 — 没有损坏的输出,无需猜测。

安全的 null 处理

TOML 没有 null。值为 null 的对象键会被丢弃并列在一条警告里;数组内部的 null 会引发一个精确的、指向路径的错误。你始终清楚你的数据发生了什么。

惯用的 TOML 输出

嵌套对象变成 [表],深度嵌套对象变成点分表([tool.ruff]),对象数组变成表数组([[section]])— 正是真实的 Cargo.toml 和 pyproject.toml 所用的形态。

浮点数与整数感知

TOML 区分整数与浮点数,因此像 1.0 这样的浮点数会被写作整数 1。当这种强制转换改变数值类型时,工具会提醒你,让往返转换的意外可见。

100% 基于浏览器的隐私

所有解析都在你的浏览器本地运行。你的 JSON — 包括凭据、令牌和内部服务细节 — 绝不会被上传、存储或记录。

示例

Cargo.toml 源

{
  "package": {
    "name": "my-app",
    "version": "1.0.0",
    "edition": "2021"
  },
  "dependencies": {
    "serde": { "version": "1.0", "features": ["derive"] },
    "tokio": { "version": "1", "features": ["full"] }
  }
}

从 JSON 生成 Rust 的 Cargo.toml — 嵌套对象变成 [表],内联对象变成内联表,与 Cargo 的期望完全一致。

pyproject.toml 源

{
  "build-system": {
    "requires": ["hatchling"],
    "build-backend": "hatchling.build"
  },
  "project": {
    "name": "my-package",
    "version": "0.3.1",
    "requires-python": ">=3.10",
    "dependencies": ["requests>=2.31", "pydantic>=2.0"]
  }
}

从 JSON 项目元数据生成 PEP 621 的 pyproject.toml — 当某个工具或 API 产出 JSON 而你需要 TOML 形式时很有用。

应用设置

{
  "title": "My Service",
  "debug": false,
  "port": 8080,
  "database": {
    "host": "localhost",
    "port": 5432,
    "pool_size": 10
  },
  "features": ["auth", "metrics", "tracing"]
}

把扁平的应用设置对象转换为 TOML — 顶层标量留在顶部,嵌套的 database 对象变成一个 [database] 表。

服务器(表数组)

{
  "servers": [
    { "name": "alpha", "ip": "10.0.0.1", "ports": [8001, 8002] },
    { "name": "beta", "ip": "10.0.0.2", "ports": [9001] }
  ]
}

对象数组在 TOML 中会变成表数组([[servers]])— 这是表达重复段落的惯用方式。

Netlify 配置源

{
  "build": {
    "command": "npm run build",
    "publish": "dist",
    "environment": { "NODE_VERSION": "20" }
  },
  "redirects": [
    { "from": "/old", "to": "/new", "status": 301, "force": true }
  ]
}

把 JSON 部署配置转成 netlify.toml,带有嵌套的 [build] 和 [build.environment] 表以及一个 [[redirects]] 表数组。

含点分结构的配置

{
  "tool": {
    "ruff": { "line-length": 100, "target-version": "py310" },
    "black": { "line-length": 100 }
  }
}

深度嵌套的 JSON 对象会变成像 [tool.ruff] 和 [tool.black] 这样的点分 TOML 表 — 正是 pyproject.toml 工具链所期望的形态。

如何使用

  1. 1

    粘贴你的 JSON

    在上方输入框中输入或粘贴你的 JSON。你也可以点击「加载示例」来试用 Cargo.toml 源、pyproject.toml 源或应用设置对象。

  2. 2

    查看实时 TOML 输出

    TOML 会即刻出现在输出面板。如果你的 JSON 有顶层数组或 null 值,工具会准确解释该怎么做,而不是产出损坏的输出。

  3. 3

    复制或下载

    点击「复制」把 TOML 抓到剪贴板,或点击「下载」保存为 .toml 文件,供 Cargo、Poetry、Hugo、Netlify 或任何读取 TOML 的工具直接使用。

常见 JSON 转 TOML 陷阱

顶层数组或标量

TOML 文档的根必须是一个表(对象)。JSON 数组或孤立值不能作为 TOML 文档。把它包在一个键下即可转换。

✗ 错误
[1, 2, 3]
✓ 正确
{ "items": [1, 2, 3] }

对象中的 null 值

TOML 没有 null 类型,因此值为 null 的对象键会在转换时被丢弃。工具会提醒你哪些键被移除了。如果你需要保留该键,请给它一个真实的值或一个空字符串。

✗ 错误
{ "name": "a", "nickname": null }
✓ 正确
{ "name": "a", "nickname": "" }

数组内部的 null

TOML 数组不能包含 null 或空缺,因此像 [1, null, 3] 这样的 JSON 没有有效的 TOML 输出。请在转换前移除该 null 或用一个真实的值替换它。

✗ 错误
{ "ports": [8001, null, 8003] }
✓ 正确
{ "ports": [8001, 8003] }

无效的 JSON 语法

输入必须首先是有效的 JSON。尾随逗号、单引号和未加引号的键是从 JavaScript 抄来的常见错误,它们不是有效的 JSON,必须在转换前修正。

✗ 错误
{ 'name': 'a', 'active': true, }
✓ 正确
{ "name": "a", "active": true }

小数部分为零的浮点数会变成整数

TOML 会把小数部分为零的浮点数(1.0)写作整数 1,从而在往返转换中改变其类型。工具会提醒你。如果该值在概念上就是整数,这没问题;如果它必须保持为浮点数,对于整数值 TOML 无法保留这一点。

✗ 错误
{ "ratio": 1.0 }  →  ratio = 1
✓ 正确
{ "ratio": 1.5 }  →  ratio = 1.5

在同一个键上混用对象与数组

一个 JSON 键必须一致地是对象或数组,才能映射为表或表数组。数据集中形态不一致会产出令人困惑的 TOML — 请先把结构规范化。

✗ 错误
{ "server": { "a": 1 }, "server": [1] }
✓ 正确
{ "server": { "a": 1 }, "servers": [1] }

常见使用场景

生成 Cargo.toml
把结构化的 JSON — 来自脚手架工具、API 或脚本 — 转成有效的 Rust Cargo.toml,自动产出嵌套的 [dependencies] 表和内联表。
生成 pyproject.toml
把 JSON 项目元数据转换为 PEP 621 的 pyproject.toml,包括点分的 [tool.*] 表,让产出 JSON 的工具链能够生成 Python 打包配置。
从 JSON 生成人可编辑的配置
把应用的 JSON 设置转变为可读的 TOML 配置文件,让人可以舒适地编辑,之后再手动加上注释。
部署配置生成
从 JSON 产出 netlify.toml、foundry.toml 或类似的平台配置,把嵌套对象和对象数组变成那些工具期望的表和表数组。
配置格式迁移
把配置从基于 JSON 的系统迁移到基于 TOML 的系统,用本转换器作为桥梁,并借助 null 与顶层警告来捕捉任何无法映射的内容。
原型化 TOML 结构
用 JSON 勾勒一份配置 — 一种大多数开发者都能流畅书写的格式 — 然后转换为 TOML,在把它提交到仓库前查看惯用的表与表数组布局。

技术细节

RFC 8259 JSON 解析
JSON 输入使用浏览器原生的 JSON.parse() 解析,它完全符合 RFC 8259。在序列化之前,工具会检查顶层值是否为对象,并扫描 null 值,以便对被丢弃的对象键发出警告,或以精确路径拒绝数组内部的 null。
通过 smol-toml 输出 TOML 1.0.0
TOML 使用 smol-toml 库生成,这是一个零依赖、完全符合 TOML 1.0.0 的序列化器。嵌套对象变成表,深度嵌套对象变成点分表,对象数组变成表数组。小数部分为零的浮点数会按 TOML 规则写作整数,并附带一条警告。
100% 基于浏览器 — 无上传、无服务器
所有处理都在你浏览器的 JavaScript 引擎中进行。任何时刻都不会传输数据。大于 200KB 的输入会从实时切换到手动模式(需显式点击「转换」),以保持界面响应流畅。

最佳实践

把顶层数组包在一个键下
如果你的数据天生就是 JSON 数组,请在转换前把它包在一个带描述性键的对象里({ "items": [...] })。TOML 文档的根必须是一个表,而这个键会在输出中给你的数组一个清晰的名字。
决定 null 应该表示什么
在转换前,决定 null 字段应该消失(丢弃该键)还是携带一个值。TOML 会丢弃对象中的 null 并拒绝数组中的 null,因此先在你的 JSON 中解决它们,能得到可预测、完整的输出。
用嵌套对象进行分组
把相关的设置分组到你 JSON 中的嵌套对象里 — 它们会在 TOML 中变成干净的 [表] 和点分表,比一大堆扁平的键可读得多,也与 Cargo 和 pyproject 配置的组织方式一致。
先验证你的 JSON
如果你的 JSON 是手写的或来自不可靠的来源,请用我们的 JSON 格式化工具 验证它,在转换为 TOML 前捕捉尾随逗号和引号错误。
转换后再添加注释
JSON 没有注释,因此不会有任何注释被带过来。由于 TOML 支持 # 注释,请手动给生成的 TOML 加上文档说明 — 这本就是把人工编辑的配置迁移到 TOML 的主要原因之一。

常见问题

如何在线将 JSON 转换为 TOML?
把你的 JSON 粘贴到上方输入框。工具会解析它并在浏览器中即刻生成 TOML — 无需点击任何按钮。TOML 出现在输出区后,点击「复制」把它抓到剪贴板,或点击「下载」保存为 .toml 文件。一切都在本地运行,因此你的 JSON 绝不会离开你的设备。开始前有两点需要知道:你的 JSON 顶层必须是对象(而非数组),且 null 值没有 TOML 等价物 — 若遇到这两种情况,工具都会清晰地为你解释。
什么是 TOML,为什么要把 JSON 转换为它?
TOML(Tom's Obvious, Minimal Language,汤姆的显而易见的极简语言)是一种配置格式,设计上便于人类读写,语义无歧义。它是 Rust 的 Cargo、Python 的 pyproject.toml、Hugo、Netlify、Poetry 等的配置格式。当某个工具或 API 给你 JSON 但目标端期望 TOML 时,你就会把 JSON 转换为 TOML — 例如从结构化数据生成 Cargo.toml 或 pyproject.toml,或把应用的 JSON 设置变成人可编辑的 TOML 配置文件。
为什么我的 JSON 顶层必须是对象?
TOML 文档的根始终是一个表(一组键值对)— 规范不允许在顶层出现裸数组、字符串或数字。因此像 [1, 2, 3] 这样的 JSON 数组或像 42 这样的孤立值无法直接转换。解决办法是把它包在一个键下:{ "items": [1, 2, 3] } 可以干净地转换为 items = [1, 2, 3]。本工具会检测非对象的顶层,并准确告诉你如何包装它,而不是产出损坏的输出。
把 JSON 转换为 TOML 时,null 值会怎样?
TOML 没有 null 类型,因此无法表示 null。本工具以两种方式安全、透明地处理它。当 null 作为对象值出现时,TOML 会直接省略该键 — 工具会显示一条警告,列出被丢弃的确切键,让你绝不会因悄悄的数据丢失而措手不及。当 null 出现在数组内部时,根本没有有效的 TOML 输出(数组无法容纳空缺),因此工具会报告一个错误,指向那个惹麻烦的 null 的确切路径。无论哪种情况,你都能精确知道发生了什么、发生在哪里。
嵌套对象和数组是如何转换为 TOML 的?
嵌套的 JSON 对象会变成 TOML 表:{ "owner": { "name": "Tom" } } 会变成带有 name = "Tom" 的 [owner]。深度嵌套的对象会变成像 [tool.ruff] 这样的点分表。对象数组会变成用双方括号书写的表数组([[servers]]),这是表达重复段落的惯用 TOML 方式。标量数组保持为内联数组(ports = [8001, 8002])。输出遵循 TOML 1.0.0 规范。
像 1.0 这样的浮点数会怎样?
TOML 区分整数与浮点数,而小数部分为零的浮点数(如 1.0)会被写作整数 1。因此 { "version": 1.0 } 会变成 version = 1。当这种强制转换发生时,工具会显示一条小警告,因为它在往返转换中改变了数值的类型。如果你需要该值保持为浮点数,对于整数值来说这个区别无法通过 TOML 保留 — 请考虑你是否真的想要一个整数。
我的 JSON 数据会被发送到任何服务器吗?
不会。所有解析与转换都完全在你的浏览器中用 JavaScript 完成。你的 JSON 绝不会被上传、存储或记录。这让本工具可以安全地用于含 API 密钥、数据库凭据或内部服务细节的配置。你可以打开浏览器的「网络」标签来验证 — 粘贴 JSON 触发的网络请求为零。
我可以把 TOML 转换回 JSON 吗?
可以。使用配套的 TOML 转 JSON 转换器 进行反向转换,或点击本工具顶部的「交换方向」按钮就地翻转输入与输出。TOML 转 JSON 的约束更少 — 它接受任何有效的 TOML — 因此只要你的 JSON 一开始就没有 null 或顶层数组,JSON → TOML → JSON 的往返就很可靠。
如何在命令行把 JSON 转换为 TOML?
一个流行的选择是 Go 工具 'yj'(yj -jt 读取 JSON 并写出 TOML)。在 Python 中你可以使用第三方的 'tomli-w' 包:import json, tomli_w; tomli_w.dump(json.load(open('config.json')), open('config.toml','wb'))。在 Node.js 中:import { stringify } from 'smol-toml'; const toml = stringify(JSON.parse(text)) — 与本工具使用的库相同。若想不安装任何东西就快速做一次性转换,这个浏览器工具是最快的途径。
如何在 Python、Rust 或 Node.js 中把 JSON 转换为 TOML?
在 Python 中:import json, tomli_w; tomli_w.dump(json.load(open('config.json')), open('config.toml','wb'))。在 Rust 中:使用 serde_json 和 toml — let value: serde_json::Value = serde_json::from_str(&text)?; let toml = toml::to_string_pretty(&value)?。在 Node.js 中:import { stringify } from 'smol-toml'; const toml = stringify(JSON.parse(text)) — 这正是本工具所用的方法。记住在所有这些方式中,顶层值都必须是对象。
转换器会保留键的顺序吗?
表内的键会保持其原始顺序,但 TOML 结构要求一个表的所有普通键值对都必须排在任何子表头之前。因此顶层标量会先被输出,然后才是表和表数组 — 转换器仅在 TOML 语法要求之处进行重排。数据是完全相同的;只有表段落的文本排序会移动,以产出有效的 TOML。
JSON 输入有文件大小限制吗?
没有硬性限制,但超过 200KB 的输入会从实时转换切换到手动模式:会出现一个「转换」按钮,只有点击时才运行转换,以保持浏览器响应流畅。典型的配置负载转换也远低于 50 毫秒。