FormatArc CSV to JSON 转换结果，左侧为 CSV 数据，右侧为转换后的 JSON 输出FormatArc CSV to JSON 转换结果，左侧为 CSV 数据，右侧为转换后的 JSON 输出
作者: FormatArc 编辑部发布日期: 2026-09-02更新日期: 2026-09-02

CSV 转 JSON 在线工具与 Python/Node/Go 转换指南

TL;DR — 按用途选方法 10 秒速查

  • 现在就要转、不想装任何东西 → FormatArc CSV to JSON（浏览器内完成，无需上传，支持 UTF-8 / 引号 / 单元格内换行）
  • Shell 脚本或命令行一行命令 → csvjson data.csv（csvkit）或 mlr --icsv --ojson cat data.csv（Miller）
  • Python 应用内 → csv.DictReader（标准库，零依赖）或大文件用 pandas.read_csv
  • Node.js 应用内 → PapaParse 的 { header: true, dynamicTyping: true }
  • Go 服务内 → encoding/csv + 表头转 map 循环
  • 内存装不下的大文件 → 用 csv.DictReader 逐行输出 NDJSON，切勿用 json.dump 一次性输出整个列表
方法安装与配置大文件支持类型推断NDJSON 输出
FormatArc 浏览器无有限（全量加载，受浏览器可用内存限制）无（全部保留为字符串）无（推荐 CLI 工具）
Python csv.DictReader标准库支持（流式循环）无（全部为字符串）支持
pandas read_csvpip install pandaschunksize= 分块流式支持（dtype 自动推断）支持（lines=True）
Miller (mlr)brew install miller支持（完整流式处理）支持（--inumeric）支持（--ojsonl）
csvkit (csvjson)pip install csvkit有限（全量加载）默认开启（--no-inference 关闭）支持（--stream）
PapaParse (Node.js)npm install papaparse支持（step 回调流式）支持（dynamicTyping）支持（手动流式）
Go encoding/csv标准库支持（Read() 循环流式）无（手动解析）支持（手动编写）

本文会逐一介绍每种方法的可用代码，然后重点讲解实际开发中常见的 4 类问题（输出格式、编码不一致、类型推断陷阱、大文件性能优化）。

CSV 格式基础（RFC 4180）

CSV（Comma-Separated Values）由 RFC 4180 非正式规定，是一种基于文本的表格格式。但实际使用中各种变体和方言层出不穷。典型的 CSV 如下：

name,email,department,start_date
Alice Johnson,alice@example.com,Engineering,2024-01-15
Bob Smith,bob@example.com,Marketing,2023-06-01
Carol Williams,carol@example.com,Engineering,2024-03-10

第 1 行是表头（列名），从第 2 行开始是数据记录。字段以逗号分隔，但看似简单的格式其实有不少注意事项：

  • 包含逗号的字段必须用双引号包裹："Smith, John"
  • 包含双引号的字段用两个连续双引号转义："She said ""hello"""
  • 引号内的换行是合法的（简单解析器最容易在此处出错）
  • 编码没有统一标准。UTF-8、UTF-8 BOM、GBK/GB18030、Shift-JIS、Latin-1 等，取决于生成环境（Windows 版 Excel 默认输出带 BOM 的 UTF-8 或 GBK）
  • 分隔符也不统一。TSV 用制表符（\t），欧洲地区 Excel 用分号（;），部分数据集用竖线（|）

关于 CSV 的历史与 RFC 4180 规范的细节，参见什么是 CSV。

为什么要把 CSV 转成 JSON

实际开发中需要把 CSV 数据转成 JSON 的典型场景：

  • REST API 通信：大多数现代 Web API 要求请求体（Request Body）为 JSON。要把电子表格中管理的数据通过 POST 发送到 API，必须先转换为 JSON 结构。
  • 前端框架对接：React、Vue、Svelte、Next.js 等框架天然处理 JSON 对象和数组。在浏览器中直接解析 CSV 虽然可行，但会增加不必要的包体积和解析开销。
  • 数据类型保留：CSV 中所有字段都是字符串（文本）。而 JSON 可以明确区分数字（number）、布尔值（boolean）、字符串（string）和 null。
  • NoSQL 数据库导入：MongoDB（mongoimport）、CouchDB、DynamoDB 的批量加载器直接接受 JSON Lines（NDJSON）格式。
  • 数据管道与工作流：Apache Airflow、Prefect、Mage、dbt 等数据处理工具经常要求在阶段间以 JSON/NDJSON 作为交换格式。
  • LLM 上下文传递：向大语言模型（LLM）传递表格数据时，相比原始 CSV，结构清晰的 JSON 对象有助于提高模型的字段识别准确率，减少幻觉。关于 LLM 输入格式的对比，参见LLM 输入用 Markdown 还是 HTML。

关于 JSON 格式本身与数据类型的入门，参见什么是 JSON。

5 种 JSON 输出格式

大多数 CSV 转 JSON 工具只提供"以表头为键的对象数组"这一种输出。但根据数据消费方的不同，你需要的结构可能完全不同。下面用同一份 CSV 展示 5 种不同的 JSON 输出：

输入 CSV：

id,name,score
1,Alice,95
2,Bob,87
3,Carol,92

选择哪种格式，取决于接收方系统的需求，而不是转换工具的默认值：

格式JSON 结构选择场景生成方式
对象数组[{...}, {...}]REST API 或前端组件以列表形式接收行数据大多数转换工具的默认值
Keyed 对象{"id": {...}}需要通过特定 ID 直接查找而非逐行遍历Python 字典推导式
JSON Lines (NDJSON)每行一个对象，无外层数组文件大到内存装不下，或数据仓库批量加载器读取大文件用 mlr --ojsonl，内存中已有数组时用 jq -c '.[]'
列导向{"col": [v1, v2]}接收方的 Python/数据分析代码期望按列组织的列表pandas df.to_dict(orient="list")
嵌套结构[{"a": {"b": v}}]API 请求体要求层级化对象结构斜杠（/）分隔表头 + 后处理

格式 1：对象数组（大多数工具的默认值）

[
  { "id": 1, "name": "Alice", "score": 95 },
  { "id": 2, "name": "Bob", "score": 87 },
  { "id": 3, "name": "Carol", "score": 92 }
]

适用场景：REST API 请求、前端数据渲染、通用数据交换。

格式 2：Keyed 对象（以特定列为主键）

{
  "1": { "name": "Alice", "score": 95 },
  "2": { "name": "Bob", "score": 87 },
  "3": { "name": "Carol", "score": 92 }
}

适用场景：查找表、按 ID 进行 O(1) 字典访问。Python 生成方式：

import csv, json, sys
rows = list(csv.DictReader(sys.stdin))
result = {row["id"]: {k: v for k, v in row.items() if k != "id"} for row in rows}
json.dump(result, sys.stdout, indent=2, ensure_ascii=False)

格式 3：JSON Lines / NDJSON（换行分隔 JSON）

{"id":1,"name":"Alice","score":95}
{"id":2,"name":"Bob","score":87}
{"id":3,"name":"Carol","score":92}

适用场景：大文件流式导入（BigQuery、Snowflake COPY INTO、MongoDB mongoimport --type=json、日志收集管道、Kafka 生产者）。每行是独立的完整 JSON 对象，因此即使 10GB 以上的文件也可以逐行处理，无需全部加载到内存。

生成方式：Miller 的 mlr --icsv --ojsonl cat data.csv，或 jq -c '.[]' array.json > lines.ndjson。

格式 4：列导向（并行数组）

{
  "id": [1, 2, 3],
  "name": ["Alice", "Bob", "Carol"],
  "score": [95, 87, 92]
}

适用场景：数据科学与机器学习（与 Apache Arrow / pandas 内部内存布局一致）、GPU 加速管道、列式数据库。pandas 生成：df.to_dict(orient="list")。

格式 5：斜杠分隔表头生成嵌套结构

输入 CSV（表头使用斜杠分隔符）：

id,name,address/city,address/zip
1,Alice,上海,200000
2,Bob,北京,100000

输出（嵌套 JSON）：

[
  { "id": 1, "name": "Alice", "address": { "city": "上海", "zip": "200000" } },
  { "id": 2, "name": "Bob",   "address": { "city": "北京", "zip": "100000" } }
]

适用场景：生成要求层级结构的 API 请求体。大多数转换工具需要额外后处理。

方法 1：FormatArc 浏览器工具（无需上传）

如果你想现在就把 CSV 转成 JSON 且不想安装任何东西，FormatArc CSV to JSON 是最快的选择。所有运算都在浏览器内完成，数据不会发送到任何外部服务器。

  1. 打开 CSV to JSON 转换器
  2. 在左侧编辑器中粘贴 CSV 文本
  3. 点击"转换"按钮，右侧即显示格式化的 JSON 结果

FormatArc CSV to JSON 转换结果FormatArc CSV to JSON 转换结果

常见的解析器容易出错的边界情况，在浏览器中也能安全处理：引号包裹的字段内含逗号、包含换行的单元格、空字段（转换为空字符串）等。

浏览器内处理在处理敏感数据时尤为重要。客户信息、工资数据、从密钥库导出的 API 密钥、公司内部财务指标等，都可以在当前浏览器标签页内安全转换，无需上传到任何服务器。

方法 2：Python — csv.DictReader 与 pandas

Python 标准库内置了 csv 和 json 模块，基本转换无需安装任何第三方包。

import csv
import json
import sys

reader = csv.DictReader(sys.stdin)
rows = list(reader)
json.dump(rows, sys.stdout, indent=2, ensure_ascii=False)

保存为 csv2json.py 后运行：

python3 csv2json.py < data.csv > data.json

csv.DictReader 会自动将第一行识别为表头。每行变成一个 dict，字典列表直接序列化为 JSON 对象数组。如果 CSV 中包含中文、日文、特殊字符或 emoji，必须指定 ensure_ascii=False，否则输出会变成 \u4e2d\u6587 这样的 Unicode 转义序列。

使用 pandas（大文件 + 类型推断）

数据科学环境或大文件处理时，pandas 更合适：

import pandas as pd

df = pd.read_csv("data.csv", encoding="utf-8")
df.to_json("data.json", orient="records", indent=2, force_ascii=False)

orient="records" 生成对象数组格式。其他有用选项："index"（Keyed 对象）、"columns"（列导向）、"values"（数组的数组）。

内存装不下的大文件用 chunksize 分块流式处理：

import pandas as pd

with open("output.ndjson", "w", encoding="utf-8") as out:
    for chunk in pd.read_csv("huge.csv", chunksize=10000):
        chunk.to_json(out, orient="records", lines=True, force_ascii=False)
        out.write("\n")

该代码以 NDJSON 格式输出，内存中始终保持 10,000 行，因此可以用固定内存处理任意大小的文件。

方法 3：Node.js — PapaParse

JavaScript 和 Node.js 生态中 CSV 解析的事实标准库是 papaparse。FormatArc 的浏览器工具内部也使用 PapaParse。

const Papa = require("papaparse");
const fs = require("fs");

const csv = fs.readFileSync("data.csv", "utf8");
const result = Papa.parse(csv, {
  header: true,
  dynamicTyping: true,   // "42" → 42, "true" → true 自动转换
  skipEmptyLines: true,
});

fs.writeFileSync("data.json", JSON.stringify(result.data, null, 2));

千兆字节级的大文件用 Node.js 流和 step 回调组合，将内存占用降到最小：

const fs = require("fs");
const Papa = require("papaparse");

const stream = fs.createReadStream("huge.csv");
const out = fs.createWriteStream("huge.ndjson");

Papa.parse(stream, {
  header: true,
  dynamicTyping: true,
  step: (row) => out.write(JSON.stringify(row.data) + "\n"),
  complete: () => out.end(),
});

每行立即写入磁盘，无论文件多大，内存使用量始终恒定。

方法 4：Go — encoding/csv

Go 标准库的 encoding/csv 和 encoding/json 实现高性能转换：

package main

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

func main() {
    f, err := os.Open("data.csv")
    if err != nil {
        panic(err)
    }
    defer f.Close()

    reader := csv.NewReader(f)
    records, err := reader.ReadAll()
    if err != nil {
        panic(err)
    }

    headers := records[0]
    result := make([]map[string]string, 0, len(records)-1)
    for _, row := range records[1:] {
        obj := make(map[string]string, len(headers))
        for i, val := range row {
            obj[headers[i]] = val
        }
        result = append(result, obj)
    }

    out, _ := json.MarshalIndent(result, "", "  ")
    fmt.Println(string(out))
}

Go 的 encoding/csv 默认将所有字段作为字符串处理。如果需要数字或布尔类型输出，必须手动调用 strconv.Atoi、strconv.ParseFloat、strconv.ParseBool。

处理大文件时，将 ReadAll() 替换为 for 循环中逐行调用 Read()，并用 json.Marshal 写入 NDJSON 文件，即可保持内存占用恒定。

方法 5：Miller 与 csvkit（一行命令 CLI）

在终端或 Shell 脚本中用一行命令完成转换时，两个强大的 CLI 工具非常实用。

Miller（mlr）

Miller 是面向结构化数据的高性能流式处理器，在 CSV/JSON/TSV 处理中占据类似 awk 的定位。

# 转换为 JSON 对象数组
mlr --icsv --ojson cat data.csv > data.json

# NDJSON（流式管道最优）
mlr --icsv --ojsonl cat data.csv > data.ndjson

# 过滤与转换同时进行
mlr --icsv --ojson filter '$score > 90' data.csv

# 转换过程中添加计算列
mlr --icsv --ojson put '$grade = $score >= 90 ? "A" : "B"' data.csv

安装：macOS 用 brew install miller，Linux（Debian/Ubuntu）用 apt install miller。

csvkit（csvjson）

csvkit 是基于 Python 的 CSV 专用工具集。

pip install csvkit
csvjson data.csv > data.json

常用选项：

  • --indent 2 — 带缩进的格式化 JSON 输出
  • --no-inference — 关闭自动数字转换，所有值保留为字符串
  • --stream — 以 NDJSON 流式输出而非数组
  • --locale zh_CN.UTF-8 — 按区域设置解析数字

不需要写代码、快速从终端输出 NDJSON 时，csvjson --stream 是最简单的选择。

嵌套 JSON 生成（斜杠分隔表头）

大多数转换工具只生成一维扁平对象。当下游 REST API、MongoDB 模式或 GraphQL 解析器要求嵌套对象结构时，需要后处理逻辑。

实际开发中广泛使用在表头中用斜杠（/）或点号（.）表示层级的约定：

id,name,address/city,address/zip,address/country
1,Alice,上海,200000,CN
2,Bob,北京,100000,CN

Python 嵌套对象生成脚本：

import csv, json, sys

def nest(row, sep="/"):
    result = {}
    for key, val in row.items():
        parts = key.split(sep)
        cursor = result
        for part in parts[:-1]:
            cursor = cursor.setdefault(part, {})
        cursor[parts[-1]] = val
    return result

reader = csv.DictReader(sys.stdin)
rows = [nest(r) for r in reader]
json.dump(rows, sys.stdout, indent=2, ensure_ascii=False)

输出结果：

[
  { "id": "1", "name": "Alice", "address": { "city": "上海", "zip": "200000", "country": "CN" } },
  { "id": "2", "name": "Bob",   "address": { "city": "北京", "zip": "100000", "country": "CN" } }
]

如果使用点号表示法（address.city），将 sep 改为 "." 即可。

编码问题排查（GBK / GB18030 / UTF-8 BOM / 引号 / 换行）

编码不匹配是 CSV 转 JSON 时出现乱码的最常见原因。

GBK / GB18030（中文 Windows Excel 默认编码）

这是中文开发者最常遇到的问题。中文 Windows 版 Excel 默认以 GBK 编码保存 CSV 文件（选择"CSV(逗号分隔)"而非"CSV UTF-8"时）。GBK 使用双字节编码，而 UTF-8 使用三字节编码，两者完全不兼容。如果你把 GBK 编码的文件按 UTF-8 读取，中文字符会变成 å­¦ç"¿、测试 这样的乱码。

GBK 与 GB18030 的区别：GB18030 是 GBK 的超集，增加了 Unicode 中所有字符的映射。部分包含生僻字或少数民族文字的 CSV 可能使用 GB18030。大多数情况下 gbk 编码即可处理，遇到无法解码的字符时尝试 gb18030。

Python 中指定编码：

with open("data.csv", encoding="gbk") as f:  # 中文 Windows Excel 导出的 CSV
    reader = csv.DictReader(f)

如果文件是 GB18030：

with open("data.csv", encoding="gb18030") as f:
    reader = csv.DictReader(f)

终端中批量转换为 UTF-8：

iconv -f GBK -t UTF-8 data.csv > data.utf8.csv

FormatArc 浏览器工具 以 UTF-8 为输入标准。GBK/GB18030 编码的文件需要先通过 iconv 转换或在文本编辑器中"另存为"UTF-8 编码后再粘贴。

UTF-8 BOM（字节顺序标记）

Windows 版 Excel 选择"CSV UTF-8"格式保存时，文件开头会附加 3 字节的 BOM（EF BB BF）。许多 JSON 解析器不会自动去除 BOM，导致第一个字段的键从 name 变成带不可见字符的 name。

Python 解决：

with open("data.csv", encoding="utf-8-sig") as f:  # -sig 自动去除 BOM
    reader = csv.DictReader(f)

Miller 解决：mlr --icsv --ojson cat <(sed '1s/^\xEF\xBB\xBF//' data.csv)。

Latin-1（欧洲 Excel 默认值）

西欧地区 Excel 经常以 Latin-1（Windows-1252）保存。处理方式与 GBK 相同：iconv -f LATIN1 -t UTF-8 或 Python 中指定 encoding="latin-1"。

Shift-JIS（日文版 Excel 默认值）

日文版 Excel 默认以 Shift-JIS 编码输出。iconv -f SHIFT-JIS -t UTF-8 转换或 Python 中 encoding="shift-jis"。

引号内逗号与单元格内换行

包含分隔符（逗号）或换行的字段必须用双引号包裹：

id,description
1,"Hello, world"
2,"Multi-line
description here"

简单的 string.split(",") 解析器会在第一行的逗号处错误地拆分字段，在第二行的换行处误判记录结束。务必使用符合规范的正式 CSV 解析器（csv.DictReader、PapaParse、Miller、csvkit）。

逗号以外的分隔符（分号 / 制表符 / 竖线）

欧洲地区 Excel 使用分号（;）作为字段分隔符（因为逗号是小数点）。此时需要显式指定分隔符：

reader = csv.DictReader(f, delimiter=";")

mlr --csv --ifs ";" --ojson cat data.csv

Papa.parse(csv, { header: true, delimiter: ";" });

TSV（制表符分隔文件）使用 delimiter="\t" 或 Miller 的 --itsv 选项。

类型推断（数字 / 布尔值 / null 解析）

CSV 本质上所有值都是文本。转为 JSON 时是否自动转换类型（类型推断）取决于工具：

工具默认行为启用类型推断的方式
Python csv.DictReader全部为字符串手动类型转换（Casting）
pandas read_csv按列自动推断默认开启（dtype=str 关闭）
PapaParse (Node.js)全部为字符串{ dynamicTyping: true }
Miller (mlr)全部为字符串--inumeric 标志
csvkit (csvjson)自动推断开启--no-inference 关闭
FormatArc 浏览器全部保留为字符串（防止数据失真）-

自动类型推断无意间开启时的风险：

  • "007" 被转换为数字 7，前导零丢失（电话号码、邮政编码、身份证号、ISBN 等场景致命）
  • "NaN"、"Infinity" 字符串可能被转换为浮点数值
  • "true"、"false"、"yes"、"no" 可能被自动转为布尔值
  • 空字符串 "" 根据工具不同可能变为 null、"" 或字段被省略
  • 超过 15 位的数字型 ID 受 JavaScript 双精度浮点数限制（Number.MAX_SAFE_INTEGER = 2^53 - 1，约 9,007 亿）影响，末尾精度丢失

安全原则：生产数据管道中保持所有字段为字符串，在明确知道模式的 application 层显式转换类型最为安全。

性能与大文件处理

几兆字节以内的小文件，任何方法速度差异都难以感知。但当数据量超出内存容量时，工具选择就决定了处理速度与稳定性。

文件规模推荐方法选择理由
内存轻松装下FormatArc 浏览器工具 / csvkit / pandas无需流式实现，快速即时处理
一次性加载有压力pandas chunksize / Miller / PapaParse stream / Go逐行或分块处理，防止内存溢出（OOM）
超大文件（数 GB 以上）Miller / Go encoding/csv / Python csv.DictReader + NDJSON必须使用固定内存占用的纯流式处理

吞吐量实测数据（Apple M5 Pro / 64GB RAM / macOS 26.5，5 列 1,000,000 行 CSV，单线程，复现脚本见仓库 scripts/benchmarks/csv-to-json-throughput/）：

  • Python csv.DictReader + json.dump（Python 3.14.6）：约 232,000 行/秒
  • pandas read_csv + to_json（pandas 3.0.3）：约 1,113,000 行/秒
  • Miller mlr --c2j（Miller 6.19.0）：约 1,960,000 行/秒（5 次测量热态中位数。冷态首次因文件系统缓存未命中约 990,000 行/秒）
  • Go encoding/csv + encoding/json（Go 1.26.4）：约 2,058,000 行/秒
  • PapaParse streaming（papaparse 5.5.2 / Node 26.3.1）：约 1,626,000 行/秒
  • FormatArc 浏览器工具：内部使用 PapaParse 5.5 引擎，但受浏览器主线程响应性和标签页内存限制，无法达到 CLI 级别的吞吐量。实际使用中数十 MB、数十万行规模可流畅运行。

实测数值取决于硬件、操作系统和运行时版本。在旧款 CPU 或旧版本库（pandas 2.x、Miller 5.x 等）上，吞吐量会明显更低。关键系统建议在自身环境中重新实测。

TB 级别的大数据应使用 Apache Spark、DuckDB（COPY data FROM 'data.csv' (FORMAT CSV) → COPY (SELECT * FROM data) TO 'out.ndjson' (FORMAT JSON, ARRAY false)）或 Apache Arrow。

任意大小文件的流式处理模式（Python）

import csv
import json
import sys

writer = sys.stdout
reader = csv.DictReader(open("huge.csv", encoding="utf-8"))
for row in reader:
    writer.write(json.dumps(row, ensure_ascii=False) + "\n")

该代码以 NDJSON 格式逐行立即输出。无论输入文件多大，内存消耗仅为 1 行，因此内存使用量恒定。可以通过管道 gzip -c > out.ndjson.gz 实时压缩，或直接流式传输到 BigQuery、AWS S3。

CI/CD 工作流（curl POST 与 GitHub Actions）

Git 仓库中管理的 CSV 文件每次 push 时自动转成 JSON 并发送到 REST API 的自动化管道示例：

# 执行转换
python3 csv2json.py < users.csv > users.json

# 发送到 API
curl -X POST https://api.example.com/users/bulk \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $API_TOKEN" \
  -d @users.json

GitHub Actions 工作流配置：

name: Sync user CSV to API
on:
  push:
    paths: ["data/users.csv"]

jobs:
  sync:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Install Miller
        run: sudo apt-get install -y miller
      - name: Convert and upload
        env:
          API_TOKEN: ${{ secrets.API_TOKEN }}
        run: |
          mlr --icsv --ojson cat data/users.csv > users.json
          curl -fsS -X POST https://api.example.com/users/bulk \
            -H "Content-Type: application/json" \
            -H "Authorization: Bearer $API_TOKEN" \
            -d @users.json

如果只是一次性 API 测试，直接把 CSV 粘贴到 CSV to JSON 转换器 中转换，复制生成的 JSON 传给 Postman、Insomnia 或 curl 即可。如果想让输出的 JSON 更整洁易读，参见JSON 排版技巧。

常见问题

Excel 导出的 CSV 带 BOM，FormatArc 能处理吗？

可以。FormatArc 浏览器工具 会自动检测并去除 UTF-8 BOM。Python 中使用 encoding="utf-8-sig"，Node.js 的 PapaParse 也能透明处理 BOM。

能否输出 NDJSON（JSON Lines）格式？

FormatArc 浏览器工具当前输出标准 JSON 对象数组。如需 NDJSON 输出，请使用 Miller（mlr --icsv --ojsonl）或 csvkit（csvjson --stream）。日志管道和数据库批量导入中，NDJSON 是标准格式。

没有表头的 CSV 怎么转换？

Python csv.DictReader 通过 fieldnames 参数直接传入列名：

reader = csv.DictReader(f, fieldnames=["id", "name", "score"])

PapaParse 使用 Papa.parse(csv, { header: false }) 以二维数组（数组的数组）读取，再手动映射为对象。

数字 ID 列输出为字符串怎么办？

大多数工具为安全起见默认输出字符串。需要数字输出时启用类型推断：PapaParse 的 dynamicTyping: true、Miller 的 --inumeric、pandas 的 dtype。注意：超过 15 位的 ID 受 JavaScript 浮点数精度限制，末尾可能丢失。

JSON 键的开头出现  字符？

这是 UTF-8 BOM 字节（EF BB BF）被按 Latin-1 编码显示的结果。Python 读取文件时指定 encoding="utf-8-sig"，或用 sed '1s/^\xEF\xBB\xBF//' data.csv 预先去除 BOM。

浏览器中能转换的最大 CSV 文件有多大？

没有固定上限，取决于使用设备的浏览器标签页可用内存。浏览器需要同时保留原始文本和解析后的 JSON 对象，因此实际内存消耗大于文件本身。千兆字节级的大文件建议使用 Miller、pandas chunksize 或 Go 流式程序处理。

CSV 单元格内包含 JSON 字符串怎么转换？

如果 CSV 单元格内有 "{""key"":""value""}" 这样的 JSON 字符串，先按普通文本解析，再对该字段应用 json.loads()：

import pandas as pd, json
df = pd.read_csv("data.csv")
df["metadata"] = df["metadata"].apply(json.loads)
df.to_json("data.json", orient="records", force_ascii=False)

JSON 输出中能保持列顺序吗？

主流工具都能保持列顺序。Python 3.7 以上的 dict 保持插入顺序，csv.DictReader 按表头顺序读取，pandas 的 to_json(orient="records") 同样保持列顺序。json.dump 在不显式传入 sort_keys=True 的情况下不会重排键。

相关工具

总结

CSV 转 JSON 时，根据工作环境与数据规模选择合适的方法即可高效完成。

  • 无安装即时转换与敏感数据：FormatArc CSV to JSON — 浏览器内完成，无服务器上传，支持 GBK/UTF-8 BOM 等编码问题
  • Shell 脚本与 CLI 自动化：Miller（mlr --icsv --ojson）或 csvkit（csvjson）
  • Python 应用：标准库 csv.DictReader，大文件与分析场景用 pandas
  • Node.js 应用：PapaParse（dynamicTyping 及大文件 step 流式回调）
  • Go 微服务：encoding/csv 与逐行流式循环

转换成功的 4 个关键点：选择匹配用途的输出格式（数组 / NDJSON / Keyed / 列导向 / 嵌套）、确认源文件编码（UTF-8 BOM、GBK/GB18030、Shift-JIS）、决定是否启用类型推断、对超出内存的大文件应用流式处理。