JSON 转 YAML 在线工具指南：Kubernetes、Docker Compose 与 Python 脚本

TL;DR — 10 秒选择最适合的方法

• 立即转换、无需安装 → FormatArc JSON to YAML (浏览器端处理，无需上传，JSON 校验，保持键顺序)
• CLI / 单行命令 → yq -P '.' file.json (DevOps 标准，-P 指定块格式)
• Python 脚本 + 保持键顺序 → yaml.dump(data, sort_keys=False, default_flow_style=False, allow_unicode=True)
• Node.js 应用 → js-yaml 的 yaml.dump(data, { lineWidth: -1 })
• Go 服务 → gopkg.in/yaml.v3 的 yaml.Marshal
• Kubernetes 往返转换 → kubectl get ... -o json | jq '...' | yq -P '.'
• 将 JSON 数组拆分为多文档 YAML → yq -P '.[]' --split-exp 'true' array.json

JSON 转 YAML 在结构上是明确的（两种格式表达相同的数据模型）。实际中的难点在于：键顺序的保持、字符串引号的处理、多行字符串（换行）的处理、将 JSON 数组拆分为多文档 YAML，以及避免“挪威问题”等实现细节。

为什么要将 JSON 转换为 YAML

JSON 和 YAML 可以表示相同的数据结构（映射/对象、列表/数组、字符串、数字、布尔值、null）。功能上它们可以互换，但选择哪种格式通常取决于运行环境的生态系统和可读性。

Kubernetes 与容器编排

Kubernetes 接受 JSON 和 YAML 作为资源定义，但其生态系统压倒性地以 YAML 为中心。官方文档、教程、技术博客和社区回答几乎都使用 YAML。将程序或 API 生成的资源定义（通常是 JSON）转换为 YAML，可以保持集群配置的一致性，并使 Pull Request (PR) 审查变得更加轻松。

kubectl 提供了以下 YAML 输出标志：

kubectl get deployment web-app -o yaml > deployment.yaml

但是，当源数据（Source of Truth）是 JSON 时（例如准入控制器 Webhook 响应、Terraform Kubernetes 提供程序的输出、自定义 Operator 的协调结果等），就需要显式的转换步骤。

Docker Compose 与 Helm values

Docker Compose 文件以 YAML 格式为标准定义。如果服务配置以 JSON 形式从配置管理 API 或服务网格控制平面提供，那么在将其用作 Compose 文件之前需要进行 YAML 转换。

Helm 图表的 values.yaml 文件也是 YAML。从外部秘密源（如 HashiCorp Vault 或 AWS Systems Manager Parameter Store，它们通常返回 JSON）获取配置时，在传递给 helm install -f values.yaml 之前必须转换为 YAML。

Ansible 剧本

Ansible 剧本和清单文件是 YAML 格式。云 API、CMDB、资产管理数据库导出的数据通常是 JSON，因此在使用剧本之前的第一步就是转换为 YAML。

可读性与编辑便利性

YAML 是优化了人类阅读和编写体验的格式。没有大括号（{}）、方括号（[]）、逗号（,）等标点符号，视觉噪音更少。

JSON：

{
  "server": {
    "host": "0.0.0.0",
    "port": 8080,
    "workers": 4,
    "logging": {
      "level": "info",
      "format": "json"
    }
  }
}

YAML：

server:
  host: 0.0.0.0
  port: 8080
  workers: 4
  logging:
    level: info
    format: json

YAML 版本字符更少，层级结构通过缩进直观呈现。对于工程师经常直接查看和修改的配置文件，这种可读性差异能带来显著的效率提升。

添加注释

JSON 规范中没有注释语法。而 YAML 标准支持使用 # 进行注释。如果想在配置文件中保留特定配置值的意图或注意事项，可以先转换为 YAML 然后添加注释。

server:
  host: 0.0.0.0
  port: 8080
  # 在生产环境中增加 workers 数量。Staging 环境 4 个足够
  workers: 4

JSON 转 YAML 经常作为向配置文件添加说明的第一步。JSON 本身没有注释语法，因此无法从 JSON 继承注释内容（如果必须在 JSON 环境中保留注释，需参考替代模式）。

需要 JSON 转 YAML 的 4 种实际场景

场景 1: Kubernetes API 响应 → 保存为 Git 清单

Kubernetes API 返回 JSON。如果需要将 Deployment 状态以 YAML 文件形式提交到 GitOps 仓库：

kubectl get deployment web-app -o json | yq -P '.' > deployment.yaml
git add deployment.yaml && git commit -m "Capture web-app current state"

场景 2: Vault 秘密 → Helm values

Vault 以 JSON 返回秘密，而 Helm 需要 values.yaml。

vault read -format=json secret/prod/app | jq '.data.data' | yq -P '.' > values.yaml
helm upgrade --install app ./chart -f values.yaml

场景 3: 控制平面 API → Docker Compose

当服务网格控制平面以 JSON 返回服务定义，而 Docker Compose 需要 YAML 格式时：

curl -s https://control-plane/services | jq '.' | yq -P '.' > docker-compose.yml
docker compose up -d

场景 4: CMDB → Ansible 清单

许多 CMDB（Device42, ServiceNow, NetBox 等）通过 REST API 返回 JSON。Ansible 清单是 YAML。

curl -s https://cmdb/hosts | jq '.hosts' | yq -P '.' > inventory.yaml
ansible-playbook -i inventory.yaml site.yaml

这四种场景都可以通过单步流水线轻松处理，便于编写自动化脚本。

浏览器端处理 vs 云端转换：上传配置文件的安全风险

市面上许多在线 JSON 转 YAML 转换器声称“客户端处理”，但实际上不少是将输入数据 POST 到后端服务器。对于配置文件，这非常危险，因为它们通常包含以下敏感信息：

• secret: 块中的 API 令牌和认证凭据
• 包含数据库密码的连接字符串 (Connection String)
• 云访问密钥（AWS IAM、GCP 服务账号密钥 JSON）
• 内部主机名及基础设施网络结构
• 加密密钥及 TLS 证书

即使声称“不记录日志”，服务器端的一个小配置错误也可能导致秘密泄露。使用完全在浏览器内部运行、不将数据传输到服务器的工具是安全的做法。

这不是杞人忧天。2025 年 11 月，安全公司 watchTowr 报告称，大型在线格式化/转换网站 JSONFormatter 和 CodeBeautify 中，用户保存的数据通过“Recent Links”功能处于任何人可查看的状态。收集到的提交物超过 8 万件（5GB 以上），包括 Active Directory 凭据、数据库和云访问密钥、私钥、CI/CD 秘密、JWT 和 API 令牌、支付网关认证信息，甚至 AWS Secrets Manager 的完整导出数据，影响了政府、金融、医疗、航空航天等众多组织（watchTowr 调查报告在新标签页中打开）。粘贴到保存输入或发送到服务器的转换器中的数据，同样面临暴露风险。

验证方法：打开转换器网页，在开发者工具（F12）的 Network 标签页中勾选“Offline”（禁用网络），然后粘贴 JSON。如果工具正常工作，则是浏览器端处理工具。如果停止工作或出现网络错误，则是云端传输方式。更完整的安全检查清单见在线工具安全检测。

FormatArc JSON to YAML 转换器 在离线状态下也能完美运行。本地 CLI 工具 yq 或本地 Python/Node.js/Go 脚本同样安全。

对于包含 Kubernetes Secret、API 令牌等凭据的配置文件（如 Helm values），请务必使用浏览器端工具或本地环境进行转换。

方法 1: FormatArc 浏览器工具（无需安装、无需上传）

JSON to YAML 转换器 将 JSON 转换为格式整齐的 YAML。所有处理都在浏览器内完成。

1. 打开 JSON to YAML 转换器。
2. 在左侧编辑器窗口粘贴 JSON。
3. 点击“转换”按钮。

该工具在转换前验证 JSON 的有效性。缺失逗号、多余的右括号（}）、未加引号的键等语法错误会立即显示行号。即使目的不是 YAML 转换，也可用作快速的 JSON 验证器。常见 JSON 解析错误的排查方法见JSON parse 报错排查。

由于仅在浏览器内运行，处理认证信息或内部基础设施配置等敏感数据时也可放心使用。

输出结果应用 Kubernetes 标准的 2 空格缩进，保留输入 JSON 的键顺序，并默认以块样式（无大括号的标准 YAML 外观）整齐对齐。

方法 2: yq (DevOps 标准 CLI 工具)

yq 是在终端环境中处理 JSON 转 YAML 最顺畅的工具。

# 基本转换
yq -P '.' input.json > output.yaml

# 从标准输入 (stdin) 通过管道接收
cat config.json | yq -P '.' > output.yaml

# 块格式（高可读性的标准 YAML）；没有 -P 选项可能会输出流格式
yq -P '.' input.json

# 指定缩进宽度（默认值 2）
yq -P -I=4 '.' input.json

# 提取特定子树并进行转换
yq -P '.spec.template' deployment.json

# 将 JSON 数组拆分为多文档 YAML 输出
yq -P '.[]' --split-exp 'true' kubernetes-list.json

-P 选项是 --prettyPrint 的缩写，强制以块格式输出 YAML。如果没有 -P，嵌套结构可能会以流格式（类似 JSON 的形式）输出。

安装方法：

# macOS (Homebrew)
brew install yq

# Linux (直接安装二进制文件)
sudo wget -qO /usr/local/bin/yq https://github.com/mikefarah/yq/releases/latest/download/yq_linux_amd64
sudo chmod +x /usr/local/bin/yq

# Docker
docker run --rm -i mikefarah/yq -P '.' < input.json > output.yaml

使用 yq + jq 组合进行过滤转换

# 从 Deployment 中仅提取 spec.template 并转换为 YAML
jq '.spec.template' deployment.json | yq -P '.'

# 仅使用 yq 也可以处理
yq -P '.spec.template' deployment.json

方法 3: Python (PyYAML 和 ruamel.yaml)

PyYAML 基本用法

import json
import yaml

with open("config.json") as f:
    data = json.load(f)

with open("config.yaml", "w") as f:
    yaml.dump(
        data,
        f,
        default_flow_style=False,   # 块格式 (标准 YAML 样式)
        allow_unicode=True,          # 不将 Unicode 字符 (如中文) 转义为 \uXXXX
        sort_keys=False,             # 保持输入 JSON 的键顺序
    )

必须指定的三个核心选项：

• default_flow_style=False — 输出普通块状 YAML，而不是 {a: 1, b: 2} 这样的一行流格式。
• allow_unicode=True — 中文、特殊字符、表情符号等保持为人类可读的文本，而不会被转换为 \uXXXX。
• sort_keys=False — 保持 JSON 的原始键顺序（在 Kubernetes 中，为了遵守 apiVersion 必须位于 kind 之前的惯例，这是必须的）。

终端单行命令

python3 -c 'import sys, json, yaml; yaml.dump(json.load(sys.stdin), sys.stdout, default_flow_style=False, allow_unicode=True, sort_keys=False)' < input.json > output.yaml

使用 ruamel.yaml 保持注释及格式

如果需要以编程方式向生成的 YAML 添加注释，或需要精细的格式保持，请使用 ruamel.yaml。

from ruamel.yaml import YAML
import json

yaml_writer = YAML()
yaml_writer.default_flow_style = False
yaml_writer.preserve_quotes = True
yaml_writer.indent(mapping=2, sequence=4, offset=2)

with open("config.json") as fin:
    data = json.load(fin)

# 以编程方式添加注释
data.yaml_set_comment_before_after_key("server", before="Web 服务器配置")

with open("config.yaml", "w") as fout:
    yaml_writer.dump(data, fout)

在需要精确控制注释或引号格式的情况下，ruamel.yaml 是最佳选择。

方法 4: Node.js (js-yaml)

const fs = require("fs");
const yaml = require("js-yaml");

const data = JSON.parse(fs.readFileSync("config.json", "utf8"));
const ymlText = yaml.dump(data, {
  lineWidth: -1,    // 防止长行自动换行
  noRefs: true,     // 禁用生成 YAML 锚点和别名 (alias)
  sortKeys: false,  // 保持输入顺序
  quotingType: '"', // 需要引号时优先使用双引号
});

fs.writeFileSync("config.yaml", ymlText);

lineWidth: -1 可以防止 js-yaml 的自动换行行为，避免长 URL 或配置字符串在中间被截断。noRefs: true 禁用锚点生成，提高了与不支持锚点的下游工具（如 kubectl）的兼容性。

方法 5: Go (gopkg.in/yaml.v3)

package main

import (
    "encoding/json"
    "fmt"
    "os"

    "gopkg.in/yaml.v3"
)

func main() {
    data, _ := os.ReadFile("config.json")
    var obj interface{}
    json.Unmarshal(data, &obj)
    out, _ := yaml.Marshal(obj)
    fmt.Print(string(out))
}

在 Go 中确定保持键顺序需要直接使用 yaml.Node，而不是 interface{}。通过 json.Unmarshal 解析为 map[string]interface{} 时，由于 Go 映射的内部特性，顺序会随机打乱。这在键顺序重要的 Kubernetes 清单等环境中会成为一个问题。

// 如果要显式保持顺序，请使用 yaml.Node
var node yaml.Node
yaml.Unmarshal(data, &node)
out, _ := yaml.Marshal(&node)

或者可以使用第三方库（如 github.com/iancoleman/orderedmap）来保持插入顺序。

Kubernetes Deployment 实战示例：JSON ↔ YAML 往返转换

这是一个实际的工作场景。从 JSON 格式编写的 Deployment 资源定义开始。

{
  "apiVersion": "apps/v1",
  "kind": "Deployment",
  "metadata": {
    "name": "web-app",
    "labels": { "app": "web", "tier": "frontend" }
  },
  "spec": {
    "replicas": 3,
    "selector": { "matchLabels": { "app": "web" } },
    "template": {
      "metadata": { "labels": { "app": "web" } },
      "spec": {
        "containers": [{
          "name": "nginx",
          "image": "nginx:1.25",
          "ports": [{ "containerPort": 80 }],
          "env": [
            { "name": "LOG_LEVEL", "value": "info" }
          ]
        }]
      }
    }
  }
}

使用 yq 进行转换：

yq -P '.' deployment.json

输出结果：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-app
  labels:
    app: web
    tier: frontend
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web
  template:
    metadata:
      labels:
        app: web
    spec:
      containers:
        - name: nginx
          image: nginx:1.25
          ports:
            - containerPort: 80
          env:
            - name: LOG_LEVEL
              value: info

apiVersion → kind → metadata → spec 的顺序被整齐地保持住了。如果使用默认设置 (sort_keys=True) 的 PyYAML 运行，键会按字母顺序排序，虽然 kubectl apply 本身可以通过，但会与上游 Kubernetes 示例的 Git diff 产生偏差，使代码审查变得困难。

集群应用：kubectl apply -f deployment.yaml

YAML 字符串引号处理：数字形式的字符串变为数字的问题

YAML 判断字符串是否需要引号的规则非常复杂。在转换器处理这些规则的过程中，可能会发生意外的类型转换。

数字形式的字符串被去除引号

在 JSON 中，如果端口号以字符串 "8080" 形式存储，但转换器在 YAML 中随意去除了引号，将其变成数字，就会出现问题。

JSON：

{ "port": "8080" }

正确的转换结果：

port: "8080"   # 保持字符串类型

错误的转换结果：

port: 8080     # 变成了数字

yq v4、PyYAML（默认设置）、js-yaml 都能正常保持原有的字符串类型。使用简单的正则表达式或启发式方法直接编写的转换脚本容易出现这个问题。

在 PyYAML 中强制为特定字符串添加引号，可以定义如下包装器：

class QuotedString(str): pass

def represent_quoted(dumper, data):
    return dumper.represent_scalar("tag:yaml.org,2002:str", str(data), style='"')

yaml.add_representer(QuotedString, represent_quoted)

看起来像布尔值 (Boolean) 的字符串 (挪威问题)

{ "active": "yes" }

转换为 YAML 1.1 模式时：

active: yes    # 下一次解析时会被解释为布尔值 true

经过质量验证的转换器会安全地为其加上引号。

active: "yes"

如果可以控制原始 JSON，那么使用 JSON 标准类型 true / false / null 代替 "yes" / "no" 这样的字符串，是从根本上防止挪威问题（如国家代码 NO 被转换为 false 的 bug 等）的方法。

以特殊字符开头的字符串

以 YAML 特殊字符（*、&、!、{、[、>、|、#、@、反引号、开头的 -）开头的值必须用引号包裹。

{ "tag": "*production*" }

tag: "*production*"   # 因为开头的 * 而应用引号

主要转换工具会自动安全地处理这种情况。

块标量：多行字符串的 | 与 > 表示法

JSON 使用 \n 转义字符表示多行字符串。在 YAML 转换时，通常使用可读性强的块标量 (Block Scalar) 表示法。

JSON：

{
  "description": "Line one\nLine two\nLine three"
}

在 YAML 中有三种表达方式。

字面量块 (|) — 保持换行不变

description: |
  Line one
  Line two
  Line three

原始换行直接反映在输出字符串中。最适合日志消息、证书 PEM 块、包含在配置文件中的 shell 脚本。

折叠块 (>) — 将换行转换为空格

description: >
  Line one
  Line two
  Line three

这种方式被解释为 Line one Line two Line three 这样一个句子（换行被替换为空格，仅空行处理为实际换行）。适合段落形式的长描述。

引号单行字符串

description: "Line one\nLine two\nLine three"

这是直接在大引号内表示 \n 的方式。虽然能运行，但超过 2-3 行时可读性会大幅下降。

yq -P 默认对包含换行的字符串应用 |（字面量）方式。PyYAML 和 js-yaml 也默认使用 |。

在 PyYAML 中强制特定样式：

yaml.dump(data, default_style='|')   # 将所有字符串设为字面量块
yaml.dump(data, default_style='"')   # 将所有字符串设为双引号

在包含多行脚本或 PEM 证书的 Kubernetes ConfigMap 中，必须使用 | 方式。kubectl create configmap --from-file 也会以 | 形式生成清单。

保持键顺序：维持 apiVersion → kind → metadata 顺序

JSON 对象和 YAML 映射在规范上都是无序 (unordered) 结构。然而在实际运行环境中，往往要求保持有意义的顺序。特别是 Kubernetes 资源中，已经确立了 apiVersion → kind → metadata → spec 的惯例顺序。

主要工具的顺序保持现状：

• yq (基于 Go yaml.v3): 通过内部 yaml.Node 保持顺序
• PyYAML + sort_keys=False: 保持顺序 (默认值 sort_keys=True 是按字母顺序排序，因此必须设置)
• js-yaml + sortKeys: false: 保持顺序
• ruamel.yaml: 默认保持顺序

注意事项：

• PyYAML 的默认值 sort_keys=True — 将所有键按字母顺序排序，导致 apiVersion 移到 kind 之后
• Go 的 interface{} 反序列化 — 映射顺序随机化 (必须使用 yaml.Node)
• 在直接编写的脚本中通过 Go 映射 (map[string]string) 输出 — 顺序任意打乱

在将 YAML 提交到 Git 的 GitOps 工作流中，如果键顺序随机变化，即使数据相同也会产生不必要的大规模 Git diff。在将工具引入部署流水线之前，务必确认是否保持键顺序。

将 JSON 数组拆分为多文档 YAML 输出

将包含 Kubernetes 资源的 JSON 数组转换为以 --- 分隔的一个多文档 YAML 文件，这是一种常见的模式。

使用 yq 时

yq -P '.[]' --split-exp 'true' kubernetes-list.json

输出结果：

---
apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
---
apiVersion: v1
kind: Service
metadata:
  name: app-service

保存文件：通过 yq -P '.[]' --split-exp 'true' kubernetes-list.json > resources.yaml 命令，可以立即生成可供 kubectl apply -f resources.yaml 使用的文件。

使用 Python 时

import json
import yaml

with open("list.json") as f:
    items = json.load(f)["items"]   # 根据实际数组路径调整

with open("resources.yaml", "w") as f:
    yaml.dump_all(
        items,
        f,
        default_flow_style=False,
        allow_unicode=True,
        sort_keys=False,
    )

yaml.dump_all 函数以 --- 分隔输出多个文档。

使用 Node.js 时

const yaml = require("js-yaml");
const fs = require("fs");

const items = JSON.parse(fs.readFileSync("list.json", "utf8")).items;
const ymlText = items.map(item => yaml.dump(item, { lineWidth: -1 })).join("---\n");

fs.writeFileSync("resources.yaml", ymlText);

由于 js-yaml 没有内置的 dumpAll，所以使用 ---\n 手动连接。

CI/CD 流水线集成

GitHub Actions

name: Convert JSON config to YAML for deployment
on:
  push:
    paths: ["config/*.json"]

jobs:
  convert:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Install yq
        run: |
          sudo wget -qO /usr/local/bin/yq https://github.com/mikefarah/yq/releases/latest/download/yq_linux_amd64
          sudo chmod +x /usr/local/bin/yq
      - name: Convert all configs
        run: |
          for f in config/*.json; do
            yq -P '.' "$f" > "${f%.json}.yaml"
          done
      - name: Validate against Kubernetes
        run: |
          for f in config/*.yaml; do
            kubectl apply --dry-run=client -f "$f"
          done
      - uses: stefanzweifel/git-auto-commit-action@v5
        with:
          commit_message: "Auto-convert configs to YAML"

如果流水线已经配置了 Node.js 环境，也可以使用 npx formatarc json-to-yaml 等命令进行转换，无需安装额外的二进制文件。详见formatarc npm。

GitLab CI

generate-yaml:
  image: mikefarah/yq:latest
  stage: build
  script:
    - for f in config/*.json; do yq -P "." "$f" > "${f%.json}.yaml"; done
  artifacts:
    paths:
      - config/*.yaml

Jenkins (Declarative)

pipeline {
  agent any
  stages {
    stage('Convert configs') {
      steps {
        sh 'for f in config/*.json; do yq -P "." "$f" > "${f%.json}.yaml"; done'
      }
    }
    stage('Validate') {
      steps {
        sh 'for f in config/*.yaml; do kubectl apply --dry-run=client -f "$f"; done'
      }
    }
  }
}

转换和验证阶段通常只在 CI 执行时间中增加几秒钟，不会对流水线性能产生影响。

Kubernetes 实用工作流

在实际工作中最常遇到的场景。使用 kubectl 将现有资源获取为 JSON 并修改，然后转换为 YAML 提交到 Git 仓库的过程。

# 将当前 Deployment 配置获取为 JSON
kubectl get deployment web-app -o json > deployment.json

# 值修改 (使用 jq 进行自动修改的示例)
jq '.spec.replicas = 5' deployment.json > updated.json

# 转换为 YAML 以进行 Git 仓库管理
yq -P '.' updated.json > deployment.yaml

# 检查变更，提交，推送
git diff deployment.yaml
git add deployment.yaml && git commit -m "Scale web-app to 5 replicas"

组合成一条流水线：

kubectl get deployment web-app -o json | jq '.spec.replicas = 5' | yq -P '.' > deployment.yaml

如果是不需要编写脚本的一次性修改，将 JSON 粘贴到 JSON to YAML 转换器，复制输出的 YAML 并保存为文件是最快的方法。

常见问题

YAML 输出中的端口号 8080 会变成字符串吗？

不会。YAML 将无引号的数字视为数字。实际出现问题的是相反的情况：JSON 中的字符串 "8080" 在 YAML 中输出为无引号的 8080，在下一次转换时变成数字。要保持原来的字符串类型，需要使用会对模糊值加引号的转换器。yq v4 和最新的 PyYAML 能正确处理这一点。

从 JSON 转换为 YAML 时能保留注释吗？

不能。JSON 本身没有注释语法，因此在 JSON 转 YAML 过程中无法保留注释。如果注释对配置文件很重要，应使用 YAML 作为源数据，或在 JSON 环境中应用注释替代模式。

为什么 PyYAML 将键顺序按字母顺序排序？

因为 PyYAML 的 yaml.dump 默认设置为 sort_keys=True。指定 sort_keys=False 可以保持原始 JSON 的键顺序。如果在 Kubernetes 资源中希望将 apiVersion 放在最上面，这是必需选项。

可以将 Helm values.json 转换为 values.yaml 吗？

可以。values 数据结构完全相同，只是文件格式不同。使用 yq -P '.' values.json > values.yaml 命令转换后，可以通过 helm template ./chart -f values.yaml > rendered.yaml 验证渲染结果。

YAML 的 null 显示为 ~ 符号

YAML 中有多种表示 null 的方法：null、Null、NULL、~、空值等。转换工具采用的默认表示不同。yq 使用 null，PyYAML 默认使用空值，js-yaml 使用 null。它们含义相同，只是外观不同。如果要强制特定表示，可以这样设置：

yaml.add_representer(type(None), lambda d, _: d.represent_scalar("tag:yaml.org,2002:null", "null"))

JSON 的锚点 (Anchor) 会保留在 YAML 输出中吗？

JSON 规范中没有锚点的概念。要在 YAML 输出中利用锚点（&anchor / *alias），需要在转换后手动添加或使用 YAML 专用编辑器。ruamel.yaml 支持以编程方式生成锚点。

如何在没有网络连接的情况下将 JSON 转换为 YAML？

本地环境有三种方法。第一，安装无依赖的 Go 单二进制文件 yq。第二，运行使用 pyyaml 的 Python 脚本。第三，编写使用 js-yaml 的 Node.js 脚本。FormatArc JSON to YAML 转换器 一旦加载网页，即可在浏览器内部运行，因此无需额外网络连接即可在离线状态下使用。

反向转换 (YAML → JSON)

如果需要将 YAML 文件再次转换为 JSON（例如用于 API 传输、调试、JSON 专用工具的输入），可以使用 FormatArc 的 YAML to JSON 转换器。其使用方法与此相同，操作简便。详细转换步骤见YAML 转 JSON 指南。

总结

JSON 转 YAML 转换是在 DevOps、IaC (Infrastructure as Code)、配置管理工作流中必然遇到的任务。可以根据情况选择以下 5 种方式：

• 无需安装、注重安全的配置数据: FormatArc JSON to YAML — 浏览器内完结，保持键顺序，包含行号的 JSON 语法验证
• CLI / 流水线自动化: yq -P '.' — DevOps 标准工具，完美支持过滤及多文档输出
• Python 应用: yaml.dump(data, sort_keys=False, default_flow_style=False, allow_unicode=True)
• Node.js 应用: js-yaml 的 yaml.dump + lineWidth: -1, sortKeys: false 选项
• Go 服务: gopkg.in/yaml.v3 的 Marshal 函数及用于保持顺序的 yaml.Node 利用

在生产环境中必须记住的 4 点注意事项：Kubernetes 中必需的键顺序保持、用于多行字符串的块标量 (|) 表示法、处理多个资源时 JSON 数组的多文档拆分、以及防止挪威问题和去引号导致的意外类型变更。