DevToolBox免费
博客

JSON 格式化与验证：在线美化、修复 JSON 完全指南

12 分钟阅读作者 DevToolBox

JSON 格式化工具和 JSON 验证器是每个处理 API、配置文件和数据交换的开发者的必备工具。无论你需要格式化 JSON 以提高可读性、在线验证 JSON 以捕获语法错误，还是美化打印 JSON 进行调试，本综合指南涵盖了你需要了解的一切。JSON（JavaScript 对象表示法）已成为 Web 数据的通用语言，掌握如何格式化、验证和调试 JSON 是一项基本技能。我们的免费在线 JSON 格式化工具可在浏览器中即时处理格式化、验证、压缩和语法错误检测。

立即试用我们的免费 JSON 格式化和验证工具。

什么是 JSON？

JSON（JavaScript Object Notation）是一种轻量级、基于文本的数据交换格式，人类易于读写，机器易于解析和生成。JSON 最初源自 JavaScript，但现在是语言无关的，几乎每种编程语言都支持它。它已成为 Web API、配置文件和 NoSQL 数据库中数据交换的事实标准。

JSON 文档由两种主要结构组成：对象（用花括号 {} 包裹的无序键值对集合）和数组（用方括号 [] 包裹的有序值列表）。值可以是字符串（双引号）、数字、布尔值（true/false）、null、对象或数组。这种简洁性使 JSON 如此通用和广泛采用。

JSON 由两个标准定义：RFC 8259（IETF 规范）和 ECMA-404（ECMA International 规范）。官方媒体类型是 application/json，文件扩展名是 .json。与 XML 不同，JSON 不支持注释、命名空间或属性，这使格式保持最小化且解析快速。

为什么需要 JSON 格式化工具

可读性：来自 API 和数据库的原始 JSON 通常是没有空格的一长行。JSON 格式化工具（也称为 JSON 美化器）添加适当的缩进和换行，让你可以直观地解析嵌套结构。

调试：当 API 响应或配置文件出现问题时，第一步通常是格式化 JSON 并检查结构。JSON 验证器可以识别语法错误的确切位置，帮助你在几秒钟内定位问题。

验证：在部署配置文件、发送 API 负载或存储数据之前，应始终验证 JSON 以确保符合规范。无效的 JSON 可能导致应用程序静默失败和难以调试的生产问题。

压缩：通过网络传输 JSON 时，你需要压缩 JSON，移除所有不必要的空格。这可以减小负载大小、加快 API 响应速度并降低带宽成本。

常见 JSON 语法错误

JSON 语法错误可能破坏整个应用程序。以下是开发者最常犯的错误：

尾部逗号：JSON 不允许在对象或数组的最后一项后面有逗号。{"a": 1, "b": 2,} 是无效的。

// INVALID: trailing comma
{
  "name": "John",
  "age": 30,
}

// VALID: no trailing comma
{
  "name": "John",
  "age": 30
}

使用单引号：JSON 要求所有字符串和键使用双引号。{'name': 'John'} 是无效的。

// INVALID: single quotes
{'name': 'John', 'age': 30}

// VALID: double quotes
{"name": "John", "age": 30}

未加引号的键：JSON 对象中的每个键必须是双引号字符串。{name: "John"} 是无效的。

JSON 中的注释：标准 JSON 不支持注释。如果需要注释，考虑使用 JSONC、YAML 或 TOML。

// INVALID: comments not allowed in JSON
{
  "name": "John", // this is a comment
  "age": 30       /* block comment */
}

// VALID: no comments
{
  "name": "John",
  "age": 30
}

使用 undefined 或 NaN：JSON 只支持 null，不支持 undefined、NaN 或 Infinity。

// INVALID in JSON (JavaScript-specific values)
{
  "value1": undefined,
  "value2": NaN,
  "value3": Infinity
}

// VALID: use null instead
{
  "value1": null,
  "value2": null,
  "value3": null
}

括号不匹配：每个 { 或 [ 都必须有对应的 } 或 ]。JSON 验证器可以精确指出不匹配的括号。

无效转义序列：JSON 字符串支持特定转义序列：\"、\\、\/、\b、\f、\n、\r、\t 和 \uXXXX。

如何格式化 JSON

根据你的工作流程，有多种方法可以格式化 JSON：

在线 JSON 格式化：最快的方法是将数据粘贴到我们的免费 JSON 格式化工具中。它会即时验证、格式化并高亮显示语法错误。

命令行 jq：jq 是最强大的命令行 JSON 处理器。使用 echo '{"a":1}' | jq . 在终端中美化打印 JSON。

Python 内置模块：Python 自带 JSON 格式化工具：python -m json.tool file.json。

IDE 扩展：VS Code 内置 JSON 格式化（Shift+Alt+F）。JetBrains IDE 提供代码重格式化（Ctrl+Alt+L）。

浏览器开发工具：Chrome、Firefox 和 Edge 的开发工具自动格式化网络选项卡中的 JSON 响应。也可以在控制台中使用 JSON.stringify(obj, null, 2)。

JSON 验证规则

要正确验证 JSON，需要理解 RFC 8259 定义的确切规范：

数据类型：JSON 支持六种数据类型：string（双引号 Unicode 文本）、number（整数或浮点数）、boolean（true 或 false）、null、object 和 array。

// All six JSON data types demonstrated:
{
  "string": "Hello World",
  "number": 42.5,
  "boolean": true,
  "nullValue": null,
  "object": {
    "nested": "value"
  },
  "array": [1, "two", false, null, {"key": "val"}, [1,2,3]]
}

字符串：必须用双引号括起来。可以包含除未转义控制字符外的任何 Unicode 字符。

数字：可以是整数或浮点数。允许科学记数法。不允许前导零、NaN、Infinity、十六进制和八进制。

// Valid JSON numbers:
42          // integer
-17         // negative integer
3.14        // floating point
2.5e10      // scientific notation
-1.23e-4    // negative scientific notation

// INVALID JSON numbers:
01          // leading zero not allowed
.5          // must have digit before decimal
+1          // leading plus not allowed
0xFF        // hex not allowed
0o77        // octal not allowed
NaN         // not a valid JSON value
Infinity    // not a valid JSON value

对象：键必须是唯一字符串。键值对的顺序不保证。空对象 {} 有效。

数组：元素可以是混合类型。空数组 [] 有效。数组可以嵌套到任意深度。

编码：JSON 文本必须使用 UTF-8、UTF-16 或 UTF-32 编码，UTF-8 是默认且最广泛使用的。

顶层值：RFC 8259 允许任何 JSON 值作为顶层元素。旧版 RFC 4627 只允许对象或数组。

代码示例：格式化和验证 JSON

JavaScript：格式化和验证 JSON

JavaScript 提供内置的 JSON.parse() 和 JSON.stringify() 方法。使用 JSON.stringify(data, null, 2) 进行 2 空格缩进的美化打印：

// ===== JSON.parse(): Validate JSON =====

// Valid JSON string
const jsonString = '{"name": "Alice", "age": 30, "active": true}';
const data = JSON.parse(jsonString);
console.log(data.name); // "Alice"

// Validate JSON safely with try/catch
function isValidJSON(str) {
  try {
    JSON.parse(str);
    return true;
  } catch (e) {
    console.error('JSON syntax error:', e.message);
    return false;
  }
}

isValidJSON('{"valid": true}');     // true
isValidJSON('{invalid: true}');     // false — "Unexpected token i"
isValidJSON('{"trailing": 1,}');    // false — "Unexpected token }"

// ===== JSON.stringify(): Format / Pretty Print JSON =====

const obj = {
  name: "Alice",
  age: 30,
  address: {
    city: "New York",
    zip: "10001"
  },
  hobbies: ["reading", "coding", "hiking"]
};

// Pretty print with 2-space indentation
const formatted = JSON.stringify(obj, null, 2);
console.log(formatted);
/*
{
  "name": "Alice",
  "age": 30,
  "address": {
    "city": "New York",
    "zip": "10001"
  },
  "hobbies": [
    "reading",
    "coding",
    "hiking"
  ]
}
*/

// Pretty print with 4-space indentation
console.log(JSON.stringify(obj, null, 4));

// Pretty print with tab indentation
console.log(JSON.stringify(obj, null, "\t"));

// Minify JSON (no whitespace)
const minified = JSON.stringify(obj);
// {"name":"Alice","age":30,"address":{"city":"New York","zip":"10001"},...}

// Custom replacer: filter specific keys
const filtered = JSON.stringify(obj, ["name", "age"], 2);
/*
{
  "name": "Alice",
  "age": 30
}
*/

// Reviver function: transform values during parsing
const parsed = JSON.parse('{"date": "2025-01-15T00:00:00Z"}', (key, value) => {
  if (key === 'date') return new Date(value);
  return value;
});
console.log(parsed.date instanceof Date); // true

Python：格式化和验证 JSON

Python 内置 json 模块提供 json.dumps()（带 indent 参数）和 json.loads() 进行格式化和验证：

import json

# ===== json.loads(): Validate JSON =====

json_string = '{"name": "Alice", "age": 30, "active": true}'
data = json.loads(json_string)
print(data["name"])  # "Alice"

# Validate JSON safely
def is_valid_json(s):
    try:
        json.loads(s)
        return True
    except json.JSONDecodeError as e:
        print(f"JSON syntax error at line {e.lineno}, col {e.colno}: {e.msg}")
        return False

is_valid_json('{"valid": true}')      # True
is_valid_json('{invalid: true}')      # False
is_valid_json('{"trailing": 1,}')     # False

# ===== json.dumps(): Format / Pretty Print JSON =====

data = {
    "name": "Alice",
    "age": 30,
    "address": {
        "city": "New York",
        "zip": "10001"
    },
    "hobbies": ["reading", "coding", "hiking"]
}

# Pretty print with 2-space indentation
formatted = json.dumps(data, indent=2)
print(formatted)

# Pretty print with sorted keys
formatted_sorted = json.dumps(data, indent=2, sort_keys=True)
print(formatted_sorted)

# Minify JSON (compact output)
minified = json.dumps(data, separators=(",", ":"))
print(minified)
# {"name":"Alice","age":30,"address":{"city":"New York","zip":"10001"},...}

# Handle non-ASCII characters (useful for i18n)
data_intl = {"city": "Tokyo", "greeting": "Hello"}
print(json.dumps(data_intl, ensure_ascii=False, indent=2))

# Read and format a JSON file
with open("data.json", "r") as f:
    data = json.load(f)

with open("data_formatted.json", "w") as f:
    json.dump(data, f, indent=2)

# Command line: python -m json.tool
# $ echo '{"a":1,"b":2}' | python -m json.tool
# {
#     "a": 1,
#     "b": 2
# }

命令行：jq、python 和 node

命令行提供多种格式化和验证 JSON 的方式：

# ===== jq: The Swiss Army knife for JSON =====

# Pretty print JSON
echo '{"name":"Alice","age":30}' | jq .
# {
#   "name": "Alice",
#   "age": 30
# }

# Minify JSON (compact output)
echo '{
  "name": "Alice",
  "age": 30
}' | jq -c .
# {"name":"Alice","age":30}

# Extract specific fields
echo '{"name":"Alice","age":30,"city":"NYC"}' | jq '{name, city}'
# {"name": "Alice", "city": "NYC"}

# Format a JSON file
jq . input.json > formatted.json

# Validate JSON (exit code 0 = valid, non-zero = invalid)
echo '{"valid": true}' | jq . > /dev/null 2>&1 && echo "Valid" || echo "Invalid"
echo '{invalid}' | jq . > /dev/null 2>&1 && echo "Valid" || echo "Invalid"

# Sort keys
echo '{"b":2,"a":1,"c":3}' | jq -S .
# {"a": 1, "b": 2, "c": 3}

# ===== python -m json.tool =====

# Format JSON from stdin
echo '{"a":1,"b":2}' | python3 -m json.tool

# Format a JSON file
python3 -m json.tool input.json output.json

# Sort keys
echo '{"b":2,"a":1}' | python3 -m json.tool --sort-keys

# ===== Node.js one-liner =====

# Pretty print JSON
echo '{"a":1,"b":2}' | node -e "process.stdin.resume();let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>console.log(JSON.stringify(JSON.parse(d),null,2)))"

# Simpler: use node -p
node -p "JSON.stringify({a:1,b:[2,3]}, null, 2)"

curl + jq 管道

常见工作流是从 API 获取 JSON 并使用 curl 管道到 jq 进行即时格式化：

# Fetch and format JSON from a REST API
curl -s https://api.github.com/users/octocat | jq .

# Fetch, extract specific fields, and format
curl -s https://api.github.com/users/octocat | jq '{login, name, bio, public_repos}'

# Fetch and validate (check exit code)
curl -s https://api.example.com/data | jq . > /dev/null 2>&1
if [ $? -eq 0 ]; then
  echo "Response is valid JSON"
else
  echo "Response is NOT valid JSON"
fi

# POST JSON and format the response
curl -s -X POST https://api.example.com/data \
  -H "Content-Type: application/json" \
  -d '{"name":"Alice","age":30}' | jq .

# Save formatted JSON to file
curl -s https://api.github.com/users/octocat | jq . > user.json

# Minify before sending (reduce payload size)
DATA=$(jq -c . large-payload.json)
curl -s -X POST https://api.example.com/data \
  -H "Content-Type: application/json" \
  -d "$DATA" | jq .

JSON 最佳实践

遵循这些最佳实践编写干净、可维护和高性能的 JSON：

键名使用 camelCase：大多数 JSON API 和 JavaScript 约定使用 camelCase。在整个 API 中保持一致。

// camelCase (recommended for most APIs)
{
  "firstName": "Alice",
  "lastName": "Smith",
  "phoneNumber": "+1-555-0123",
  "isActive": true
}

// snake_case (common in Python/Ruby ecosystems)
{
  "first_name": "Alice",
  "last_name": "Smith",
  "phone_number": "+1-555-0123",
  "is_active": true
}

保持嵌套浅层：深度嵌套的 JSON（超过 3-4 层）难以阅读和解析。考虑扁平化或拆分为多个端点。

// BAD: deeply nested (hard to read and parse)
{
  "company": {
    "departments": {
      "engineering": {
        "teams": {
          "frontend": {
            "members": [{"name": "Alice"}]
          }
        }
      }
    }
  }
}

// BETTER: flattened structure
{
  "companyId": "acme",
  "departmentId": "engineering",
  "teamId": "frontend",
  "members": [{"name": "Alice"}]
}

谨慎处理大文件：对于大于几 MB 的 JSON 文件，使用流式解析器如 ijson（Python）、JSONStream（Node.js）。

使用 JSON Schema 验证：在生产环境中，使用 JSON Schema 定义验证 JSON 负载。ajv（JavaScript）和 jsonschema（Python）提供强大的验证。

// JSON Schema example for validating user objects
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "type": "object",
  "properties": {
    "name": { "type": "string", "minLength": 1 },
    "age": { "type": "integer", "minimum": 0 },
    "email": { "type": "string", "format": "email" },
    "roles": {
      "type": "array",
      "items": { "type": "string" },
      "minItems": 1
    }
  },
  "required": ["name", "email"]
}

避免存储二进制数据：JSON 是文本格式。如需包含二进制数据，使用 Base64 编码或单独存储并用 URL 引用。

统一 null 处理：决定是省略 null 值的键还是显式包含它们，并一致应用。

JSON 与替代方案：YAML、TOML、XML

JSON 不是唯一的数据序列化格式。以下是与最流行替代方案的快速对比：

FeatureJSONYAMLTOMLXML
ReadabilityGoodExcellentExcellentModerate
CommentsNoYesYesYes
Data types6 typesRich (dates, etc.)Rich (dates, etc.)Text only
NestingUnlimitedUnlimitedLimitedUnlimited
Multi-line stringsNoYesYesYes (CDATA)
Parser supportUniversalWideGrowingUniversal
File sizeSmallSmallerSmallestLarge (verbose)
Best forAPIs, dataConfig filesSimple configDocuments, SOAP

API 和数据交换选择 JSON；需要注释和可读性的配置文件选择 YAML；简单配置选择 TOML；现有标准（SOAP、RSS、SVG）要求时选择 XML。

常见问题

如何在线格式化 JSON？

将原始 JSON 粘贴到我们的 JSON 格式化工具中，工具会自动验证语法、添加缩进和换行、高亮显示错误。可选择 2 空格或 4 空格缩进，在格式化和压缩输出间切换。工具完全在浏览器中运行，数据不会离开你的电脑。

常见的 JSON 语法错误有哪些？

最常见的 JSON 语法错误包括：尾部逗号、使用单引号代替双引号、未加引号的对象键、添加注释、使用 undefined 或 NaN 值、括号不匹配、无效转义序列。JSON 验证工具会识别每个错误的精确行号和位置。

JSON 和 YAML 有什么区别？

JSON 使用花括号、方括号和双引号来构建结构，而 YAML 使用缩进和最少的标点符号。YAML 支持注释、多行字符串和锚点/别名；JSON 不支持。JSON 更适合机器间的数据交换（API、数据库），YAML 更适合人工编辑的配置文件。JSON 是 YAML 的严格子集。

掌握 JSON 格式化和验证是现代开发者的必备技能。无论是调试 API 响应、编写配置文件还是构建数据管道，理解如何格式化、验证 JSON 并避免常见语法错误将为你节省大量时间。收藏本指南以备参考，使用我们的免费工具进行即时格式化和验证。

使用我们的免费在线工具即时格式化、验证和压缩 JSON。

𝕏 Twitterin LinkedIn
这篇文章有帮助吗？

保持更新

获取每周开发技巧和新工具通知。

无垃圾邮件，随时退订。

试试这些相关工具

{ }JSON FormatterTSJSON to TypeScriptGoJSON to Go Struct✓JSON Validator

相关文章

JSON vs YAML vs TOML：你应该用哪种配置格式？

比较 JSON、YAML 和 TOML 配置格式，了解语法、特性和优缺点，选择适合你项目的格式。

JSON Schema 验证：类型、工具与最佳实践

关于 JSON Schema 验证的一切：从基本类型到高级模式、验证库以及与 TypeScript 和 API 的集成。

JSON 解析错误：Unexpected Token — 如何查找并修复

逐步排查 JSON 解析错误。了解 unexpected token 错误的原因、如何定位问题，以及验证和修复 JSON 的工具。

JSON 格式化工具完全指南：在线美化、VS Code、命令行与代码中格式化 JSON（2026）

学习如何在线格式化 JSON、在 VS Code 中美化 JSON、用命令行工具 jq 处理 JSON，以及在 JavaScript 和 Python 中进行 JSON 格式化。涵盖验证、压缩、查看器和常见错误。