有TidyJSON。

它是C#，所以也许你可以用Mono编译它，并在*nix上工作。但不能保证，对不起。

$ echo '{ "foo": "lorem", "bar": "ipsum" }' \> | python -c'import fileinput, json;> print(json.dumps(json.loads("".join(fileinput.input())),>                  sort_keys=True, indent=4))'{"bar": "ipsum","foo": "lorem"}

注意：这不是的的方法。

在Perl中也一样：

$ cat json.txt \> | perl -0007 -MJSON -nE'say to_json(from_json($_, {allow_nonref=>1}),>                                     {pretty=>1})'{"bar" : "ipsum","foo" : "lorem"}

注2：如果你运行

echo '{ "Düsseldorf": "lorem", "bar": "ipsum" }' \| python -c'import fileinput, json;print(json.dumps(json.loads("".join(fileinput.input())),sort_keys=True, indent=4))'

可读的单词变成\u编码

{"D\u00fcsseldorf": "lorem","bar": "ipsum"}

如果您的管道的其余部分将优雅地处理Unicode，并且您希望您的JSON也对人类友好，只需使用ensure_ascii=False

echo '{ "Düsseldorf": "lorem", "bar": "ipsum" }' \| python -c'import fileinput, json;print json.dumps(json.loads("".join(fileinput.input())),sort_keys=True, indent=4, ensure_ascii=False)'

你会得到：

{"Düsseldorf": "lorem","bar": "ipsum"}

感谢J. F. Sebastian非常有用的指针，这里有一个我想出的稍微增强的脚本：

#!/usr/bin/python
"""Convert JSON data to human-readable form.
Usage:prettyJSON.py inputFile [outputFile]"""
import sysimport simplejson as json

def main(args):try:if args[1] == '-':inputFile = sys.stdinelse:inputFile = open(args[1])input = json.load(inputFile)inputFile.close()except IndexError:usage()return Falseif len(args) < 3:print json.dumps(input, sort_keys = False, indent = 4)else:outputFile = open(args[2], "w")json.dump(input, outputFile, sort_keys = False, indent = 4)outputFile.close()return True

def usage():print __doc__

if __name__ == "__main__":sys.exit(not main(sys.argv))

J. F. Sebastian的解决方案在Ubuntu 8.04中对我不起作用。
这是一个修改后的Perl版本，适用于旧的1. X JSON库：

perl -0007 -MJSON -ne 'print objToJson(jsonToObj($_, {allow_nonref=>1}), {pretty=>1}), "\n";'

在*nix上，从stdin读取并写入stdout效果更好：

#!/usr/bin/env python"""Convert JSON data to human-readable form.
(Reads from stdin and writes to stdout)"""
import systry:import simplejson as jsonexcept:import json
print json.dumps(json.loads(sys.stdin.read()), indent=4)sys.exit(0)

把它放在一个文件中（我在AnC的答案后将我的命名为“漂亮的JSON”）在你的PATH中并chmod +x它，你就可以走了。

或者，使用Ruby：

echo '{ "foo": "lorem", "bar": "ipsum" }' | ruby -r json -e 'jj JSON.parse gets'

使用Python 2.6+，您可以：

echo '{"foo": "lorem", "bar": "ipsum"}' | python -m json.tool

或者，如果JSON在文件中，您可以执行：

python -m json.tool my_json.json

如果JSON来自Internet源，例如API，则可以使用

curl http://my_url/ | python -m json.tool

为方便起见，在所有这些情况下，您可以创建别名：

alias prettyjson='python -m json.tool'

为了更方便，多输入一点以准备好：

prettyjson_s() {echo "$1" | python -m json.tool}
prettyjson_f() {python -m json.tool "$1"}
prettyjson_w() {curl "$1" | python -m json.tool}

对于上述所有情况。您可以将其放在.bashrc中，并且每次都可以在shell中使用。像prettyjson_s '{"foo": "lorem", "bar": "ipsum"}'一样调用它。

请注意，正如@pnd在下面的评论中指出的那样，在Python 3.5+中，默认情况下JSON对象不再排序。要排序，请在末尾添加--sort-keys标志。即... | python -m json.tool --sort-keys。

JSON Ruby Gem捆绑了一个外壳脚本来美化JSON：

sudo gem install jsonecho '{ "foo": "bar" }' | prettify_json.rb

脚本下载：gist.github.com/3738968

使用Perl，使用CPAN模块JSON::XS。它安装了一个命令行工具json_xs。

验证：

json_xs -t null < myfile.json

对齐JSON文件src.json到pretty.json：

< src.json json_xs > pretty.json

如果您没有json_xs，请尝试json_pp。“pp”用于“纯perl”-该工具仅在Perl中实现，没有绑定到外部C库（这就是XS所代表的Perl的“扩展系统”）。

我使用#0的“space”参数在JavaScript中漂亮地打印JSON。

示例：

// Indent with 4 spacesJSON.stringify({"foo":"lorem","bar":"ipsum"}, null, 4);
// Indent with tabsJSON.stringify({"foo":"lorem","bar":"ipsum"}, null, '\t');

从带有Node.js的Unix命令行，在命令行上指定JSON：

$ node -e "console.log(JSON.stringify(JSON.parse(process.argv[1]), null, '\t'));" \'{"foo":"lorem","bar":"ipsum"}'

退货：

{"foo": "lorem","bar": "ipsum"}

从带有Node.js的Unix命令行，指定包含JSON的文件名，并使用四个空格的缩进：

$ node -e "console.log(JSON.stringify(JSON.parse(require('fs') \.readFileSync(process.argv[1])), null, 4));"  filename.json

使用管道：

echo '{"foo": "lorem", "bar": "ipsum"}' | node -e \"\s=process.openStdin();\d=[];\s.on('data',function(c){\d.push(c);\});\s.on('end',function(){\console.log(JSON.stringify(JSON.parse(d.join('')),null,2));\});\"

查看Jazor。这是一个用Ruby编写的简单命令行JSON解析器。

gem install jazorjazor --help

如果您使用npm和Node.js，您可以执行npm install -g json，然后将命令通过json传输。执行json -h以获取所有选项。它还可以拉出特定字段并使用-i为输出着色。

curl -s http://search.twitter.com/search.json?q=node.js | json

我建议使用json_xs命令行实用程序，它包含在JSON::XS perl模块中。JSON::XS是一个用于序列化/反序列化JSON的Perl模块，在Debian或Ubuntu机器上，您可以像这样安装它：

sudo apt-get install libjson-xs-perl

它显然也适用于CPAN。

要使用它来格式化从URL获得的JSON，您可以使用curl或wget，如下所示：

$ curl -s http://page.that.serves.json.com/json/ | json_xs

或者这个：

$ wget -q -O - http://page.that.serves.json.com/json/ | json_xs

要格式化文件中包含的JSON，您可以这样做：

$ json_xs < file-full-of.json

要重新格式化为YAML，有些人认为它比JSON更人性化：

$ json_xs -t yaml < file-full-of.json

$ sudo apt-get install edit-json$ prettify_json myfile.json

根据我的经验，#0非常好。我使用它的json_reformat命令在vim中漂亮地打印.json文件，方法是在我的.vimrc中添加以下行：

autocmd FileType json setlocal equalprg=json_reformat

我使用jshon来做你所描述的事情。只需运行：

echo $COMPACTED_JSON_TEXT | jshon

您还可以传递参数来转换JSON数据。

使用Perl，如果您从CPAN安装JSON::PP，您将获得json_pp命令。从B Bycroft中窃取示例，您将获得：

[pdurbin@beamish ~]$ echo '{"foo": "lorem", "bar": "ipsum"}' | json_pp{"bar" : "ipsum","foo" : "lorem"}

值得一提的是，json_pp预装了Ubuntu 12.04（至少）和/usr/bin/json_pp中的Debian

我通常只做：

echo '{"test":1,"test2":2}' | python -mjson.tool

并检索选择数据（在本例中为“test”的值）：

echo '{"test":1,"test2":2}' | python -c 'import sys,json;data=json.loads(sys.stdin.read()); print data["test"]'

如果JSON数据在文件中：

python -mjson.tool filename.json

如果您想使用身份验证令牌在命令行上使用curl一次性完成所有操作：

curl -X GET -H "Authorization: Token wef4fwef54te4t5teerdfgghrtgdg53" http://testsite/api/ | python -mjson.tool

以下是如何使用Groovy脚本。

创建一个Groovy脚本，比如“漂亮的打印”

#!/usr/bin/env groovy
import groovy.json.JsonOutput
System.in.withReader { println JsonOutput.prettyPrint(it.readLine()) }

使脚本可执行：

chmod +x pretty-print

现在从命令行，

echo '{"foo": "lorem", "bar": "ipsum"}' | ./pretty-print

我是json-liner的作者。这是一个将JSON转换为grep友好格式的命令行工具。试一试。

$ echo '{"a": 1, "b": 2}' | json-liner/%a 1/%b 2$ echo '["foo", "bar", "baz"]' | json-liner/@0 foo/@1 bar/@2 baz

使用JavaScript/Node.js：看看vkBeautify.js插件，它为JSON和XML文本提供了漂亮的打印。

它是用纯JavaScript编写的，不到1.5 KB（缩小）并且非常快。

我的JSON文件没有被任何这些方法解析。

我的问题类似于帖子Google数据源JSON无效吗？。

这篇文章的答案帮助我找到了解决方案。

它被认为是没有字符串键的无效JSON。

{id:'name',label:'Name',type:'string'}

必须是：

{"id": "name", "label": "Name", "type": "string"}

此链接对一些不同的JSON解析器进行了很好的全面比较：http://deron.meranda.us/python/comparing_json_modules/basic

这让我想到了http://deron.meranda.us/python/demjson/。我认为这个解析器比其他许多解析器更容错。

JSONLint有一个GitHub上的开源实现，可以在命令行上使用，也可以包含在Node.js项目中。

npm install jsonlint -g

然后

jsonlint -p myfile.json

或

curl -s "http://api.twitter.com/1/users/show/user.json" | jsonlint | less

我写了一个工具，它有最好的“智能空白”格式化程序之一。它比这里的大多数其他选项产生更多的可读性和更少的冗长输出。

下划线

这就是“智能空白”的样子：

我可能有点偏颇，但它是一个很棒的工具，可以从命令行打印和操作JSON数据。它使用起来非常友好，并且有广泛的命令行帮助/留档。这是一把瑞士军刀，我用它来完成1001个不同的小任务，用其他方式做这些任务会非常烦人。

最新用例：Chrome，Dev控制台，网络选项卡，将所有内容导出为HAR文件，“catsite.har|下划线选择'. url'--outfmt text|grep mydom”；现在我有了一个按时间顺序排列的列表，其中包含了在加载我公司网站期间进行的所有URL获取。

漂亮的打印很容易：

underscore -i data.json print

同样的事情：

cat data.json | underscore print

同样的事情，更明确：

cat data.json | underscore print --outfmt pretty

这个工具是我目前的激情项目，所以如果你有任何功能要求，我很有可能会解决它们。

我知道最初的帖子要求外壳脚本，但有这么多有用和不相关的答案，可能对原作者没有帮助。添加到无关：）

顺便说一句，我无法获得任何命令行工具来工作。

如果有人想要简单的JSON JavaScript代码，他们可以这样做：

JSON.stringfy(JSON.parse(str), null, 4)

http://www.geospaces.org/geoweb/Wiki.jsp?page=JSON%20Utilities%20Demos

这是JavaScript代码，它不仅美化了JSON，还按属性或属性和级别对它们进行排序。

如果输入是

{ "c": 1, "a": {"b1": 2, "a1":1 }, "b": 1},

它要么打印（将所有对象组合在一起）：

{"b": 1,"c": 1,"a": {"a1": 1,"b1": 2}}

或（仅按键命令）：

{"a": {"a1": 1,"b1": 2},"b": 1,"c": 1}

使用下面的命令安装yajl工具：

sudo apt-get install yajl-tools

然后，

echo '{"foo": "lorem", "bar": "ipsum"}' | json_reformat

试试#0。它有颜色！

用pip安装它：

⚡pip install pjson

然后将任何JSON内容通过管道传输到pjson。

您可以使用：#0

它使用起来非常简单，效果很好！它可以处理非常大的JSON结构，包括流。你可以找到他们的教程这里。

使用示例：

$ jq --color-output . file1.json file1.json | less -R
$ command_with_json_output | jq .
$ jq # stdin/"interactive" mode, just enter some JSON
$ jq <<< '{ "foo": "lorem", "bar": "ipsum" }'{"bar": "ipsum","foo": "lorem"}

或者使用jq和身份过滤器：

$ jq '.foo' <<< '{ "foo": "lorem", "bar": "ipsum" }'"lorem"

PHP版本，如果您的PHP>=5.4。

alias prettify_json=php -E '$o = json_decode($argn); print json_encode($o, JSON_PRETTY_PRINT);'echo '{"a":1,"b":2}' | prettify_json

更新我现在正在使用jq，正如另一个答案所建议的那样。它在过滤JSON方面非常强大，但是，在最基本的情况下，也是一种漂亮打印JSON以供查看的很棒的方式。

jsonpp是一个非常漂亮的命令行JSON漂亮打印机。

从自述：

漂亮的打印Web服务响应，如下所示：

curl -s -L http://<!---->t.co/tYTq5Pu | jsonpp

并使磁盘上运行的文件变得美观：

jsonpp data/long_malformed.json

如果您使用的是Mac OS X，您可以brew install jsonpp。如果不是，您可以简单地将二进制文件复制到您的$PATH中的某个地方。

这是一个比Json的漂亮命令更好的Ruby解决方案。gemcolorful_json相当不错。

gem install colorful_jsonecho '{"foo": "lorem", "bar": "ipsum"}' | cjson{"foo": "lorem","bar": "ipsum"}

这是一个Groovy单行代码：

echo '{"foo": "lorem", "bar": "ipsum"}' | groovy -e 'import groovy.json.*; println JsonOutput.prettyPrint(System.in.text)'

您也可以使用在线工具，如果这是您的选择。

我发现http://jsonprettyprint.net是最简单和最容易的。

我正在使用HTTPIE

$ pip install httpie

你可以像这样使用它

 $ http PUT localhost:8001/api/v1/ports/myHTTP/1.1 200 OKConnection: keep-aliveContent-Length: 93Content-Type: application/jsonDate: Fri, 06 Mar 2015 02:46:41 GMTServer: nginx/1.4.6 (Ubuntu)X-Powered-By: HHVM/3.5.1
{"data": [],"message": "Failed to manage ports in 'my'. Request body is empty","success": false}

皮格门茨

我将Python的json.tool与pygmentze结合起来：

echo '{"foo": "bar"}' | python -m json.tool | pygmentize -g

在我的这个答案中列出了pyg的一些替代品。

以下是一个现场演示：

Node.js你也可以使用“util”模块，它使用语法高亮，智能缩进，从键中删除引号，并使输出尽可能漂亮。

cat file.json | node -e "process.stdin.pipe(new require('stream').Writable({write: chunk =>  {console.log(require('util').inspect(JSON.parse(chunk), {depth: null, colors: true}))}}))"

gem install jsonprettyecho '{"foo": "lorem", "bar": "ipsum"}' | jsonpretty

此方法还"检测HTTP响应/标头，原封不动地打印它们，并跳过到主体（用于'curl-i'）"

一个简单的bash脚本，用于漂亮的json打印

json_pretty.sh

#/bin/bash
grep -Eo '"[^"]*" *(: *([0-9]*|"[^"]*")[^{}\["]*|,)?|[^"\]\[\}\{]*|\{|\},?|\[|\],?|[0-9 ]*,?' | awk '{if ($0 ~ /^[}\]]/ ) offset-=4; printf "%*c%s\n", offset, " ", $0; if ($0 ~ /^[{\[]/) offset+=4}'

示例：

cat file.json | json_pretty.sh

工具ydump是一个JSON漂亮的打印机：

$ ydump my_data.json{"foo": "lorem","bar": "ipsum"}

或者您可以通过管道输入JSON：

$ echo '{"foo": "lorem", "bar": "ipsum"}' | ydump{"foo": "lorem","bar": "ipsum"}

这可能是除了使用jq工具之外最短的解决方案。

此工具是OCaml的yojson库的一部分，并记录在这里中。

在Debian及其衍生产品上，包libyojson-ocaml-dev包含此工具。或者，yojson可以通过OPAM安装。

只需将输出通过管道传输到jq .。

示例：

twurl -H ads-api.twitter.com '.......' | jq .

如果您不介意使用第三方工具，您可以简单地卷曲到jsonprettyprint.org。这是针对您无法在机器上安装软件包的情况。

curl -XPOST https://jsonprettyprint.org/api -d '{"user" : 1}'

请务必检查JSONFUI：支持折叠的命令行JSON查看器

如果你已经安装Node.js，你可以用一行代码自己创建一个。

>vim漂亮

#!/usr/bin/env node
console.log(JSON.stringify(JSON.parse(process.argv[2]), null, 2));

添加执行权限：

>chmod+x漂亮

或者如果您的JSON在文件中：

#!/usr/bin/env node
console.log(JSON.stringify(require("./" + process.argv[2]), null, 2));

>./漂亮的file.json

我就是这样做的：

curl yourUri | json_pp

它缩短了代码并完成了工作。

https://github.com/aidanmelen/json_pretty_print

from __future__ import unicode_literalsfrom __future__ import absolute_importfrom __future__ import print_functionfrom __future__ import division
import jsonimport jsonschema
def _validate(data):schema = {"$schema": "http://json-schema.org/draft-04/schema#"}try:jsonschema.validate(data, schema,format_checker=jsonschema.FormatChecker())except jsonschema.exceptions.ValidationError as ve:sys.stderr.write("Whoops, the data you provided does not seem to be " \"valid JSON.\n{}".format(ve))
def pprint(data, python_obj=False, **kwargs):_validate(data)kwargs["indent"] = kwargs.get("indent", 4)pretty_data = json.dumps(data, **kwargs)if python_obj:print(pretty_data)else:repls = (("u'",'"'),("'",'"'),("None",'null'),("True",'true'),("False",'false'))print(reduce(lambda a, kv: a.replace(*kv), repls, pretty_data))

用的jq工具的原生方式并不太简单。

例如：

cat xxx | jq .

1. brew install jq
2. command + | jq
3. （示例：curl localhost:5000/blocks | jq）
4. 好好享受！

在一行中使用Ruby：

echo '{"test":1,"test2":2}' | ruby -e "require 'json'; puts JSON.pretty_generate(JSON.parse(STDIN.read))"

您可以为此设置别名：

alias to_j="ruby -e \"require 'json';puts JSON.pretty_generate(JSON.parse(STDIN.read))\""

然后你可以更方便地使用它

echo '{"test":1,"test2":2}' | to_j
{"test": 1,"test2": 2}

如果你想用颜色显示JSON，你可以安装awesome_print，

gem install awesome_print

然后

alias to_j="ruby -e \"require 'json';require 'awesome_print';ap JSON.parse(STDIN.read)\""

试试看！

echo '{"test":1,"test2":2, "arr":["aa","bb","cc"] }' | to_j

jj非常快，可以经济地处理巨大的JSON文档，不会弄乱有效的JSON数字，并且易于使用，例如。

jj -p # for reading from STDIN

或

jj -p -i input.json

它（2018年）仍然很新，所以它可能不会像您期望的那样处理无效的JSON，但它很容易在主要平台上安装。

您可以使用这个简单的命令来实现结果：

echo "{ \"foo\": \"lorem\", \"bar\": \"ipsum\" }"|python -m json.tool

#0是带有语法高亮的cat克隆：

示例：

echo '{"bignum":1e1000}' | bat -p -l json

-p将输出没有标头，-l将显式指定语言。

它有JSON的着色和格式化，没有是否有此评论中指出的问题：如何在外壳脚本中漂亮地打印JSON？

使用Node.js的单行解决方案如下所示：

$ node -e "console.log( JSON.stringify( JSON.parse(require('fs').readFileSync(0) ), 0, 1 ))"

例如：

$ cat test.json | node -e "console.log( JSON.stringify( JSON.parse(require('fs').readFileSync(0) ), 0, 1 ))"

您可以使用xidel。

Xidel是一个命令行工具，用于使用CSS、XPath 3.0、XQuery 3.0、JSONiq或模式模板从超文本标记语言/XML页面或JSON-API下载和提取数据。它还可以创建新的或转换的XML/超文本标记语言/JSON文档。

默认情况下，Xidel漂亮打印：

$ xidel -se '$json' <<< '{"foo":"lorem","bar":"ipsum"}'{"foo": "lorem","bar": "ipsum"}

或：

$ echo '{"foo":"lorem","bar":"ipsum"}' | xidel -se '$json'{"foo": "lorem","bar": "ipsum"}

您可以简单地使用jq或json_pp等标准工具。

echo '{ "foo": "lorem", "bar": "ipsum" }' | json_pp

或

echo '{ "foo": "lorem", "bar": "ipsum" }' | jq

都会像下面这样美化输出（jq更丰富多彩）：

{"foo": "lorem","bar": "ipsum"}

jq的巨大优势在于，如果您想解析和处理json，它可以做更多的事情。

太长别读：对于表演，使用jj -p < my.json。

基准

我在这里采取了一些解决方案，并用下一个虚拟脚本对它们进行了基准测试：

function bench {time (for i in {1..1000}; doecho '{ "foo" : { "bar": { "dolorem" : "ipsum", "quia" : { "dolor" : "sit"} } } }' \| $@ > /dev/nulldone)}

这是我的mac上的结果（32 GB，Apple M1 Max，YMMV）：

bench python -m json.tool# 8.39s user 12.31s system 42% cpu 48.536 totalbench jq# 13.12s user 1.28s system 87% cpu 16.535 totalbench bat -p -l json # NOTE: only syntax colorisation.# 1.87s user 1.47s system 66% cpu 5.024 totalbench jj -p# 1.94s user 2.44s system 57% cpu 7.591 totalbench xidel -s - -e '$json' --printed-json-format=pretty# 4.32s user 1.89s system 76% cpu 8.101 total

感谢@峰值和你的回答为这个发现jj！

我想到了这个解决方案：https://calbertts.medium.com/unix-pipelines-with-curl-requests-and-serverless-functions-e21117ae4c65

# this in your bash profilejsonprettify() {curl -Ss -X POST -H "Content-Type: text/plain" --data-binary @- https://jsonprettify.vercel.app/api/server?indent=$@}

echo '{"prop": true, "key": [1,2]}' | jsonprettify 4# {#     "prop": true,#     "key": [#         1,#         2#     ]# }

不需要安装任何东西，如果您安装了Internet连接和cURL，您可以使用此功能。

你在另一个主机，你不能安装任何东西，这将是一个完美的解决方案，这个问题。

当您在系统上安装节点时，以下操作有效。

echo '{"test":1,"test2":2}' | npx json
{"test": 1,"test2": 2}

你只需要使用jq如果没有安装jq，则需要先安装jq。

sudo apt-get updatesudo apt-get install jq

安装jq后只需要使用jq

echo '{ "foo": "lorem", "bar": "ipsum" }' | jq

输出看起来像

{"foo": "lorem","bar": "ipsum"}

如果希望在控制台上可视化 json 日志，可以使用 Munia 漂亮 Json

npm install -g munia-pretty-json

您的 json 数据(app-log. json)

{"time":"2021-06-09T02:50:22Z","level":"info","message":"Log for pretty JSON","module":"init","hostip":"192.168.0.138","pid":123}
{"time":"2021-06-09T03:27:43Z","level":"warn","message":"Here is warning message","module":"send-message","hostip":"192.168.0.138","pid":123}

运行命令:

munia-pretty-json app-log.json

下面是控制台上的可读输出:

您可以使用模板格式化输出。默认模板是 '{time} {level -c} {message}'

使用模板:

munia-pretty-json -t '{module -c} - {level} - {message}' app-log.json

产出:

同意 jq。你可以在你的 $HOME/.bashrc中添加以下函数:

jqless () {
args=$1
shift
jq --color-output . $args "$@" | less --raw-control-chars
}

这允许任意数量的输入 JSON 文件。

您可以使用 更漂亮来完成此操作。

npx prettier <JSON file>应该在给定的文件中打印一个修饰过的 JSON 版本，而 npx prettier --write <JSON file>将用修饰过的 JSON 覆盖给定的 JSON 文件。

Yq 可以用来漂亮地打印 JSON

echo '{"foo": "lorem", "bar": "ipsum"}' | yq -o json

它有一个定义缩进的选项

echo '{"foo": "lorem", "bar": "ipsum"}' | yq -o json --indent 3

您可以选择彩色和单色输出

echo '{"foo": "lorem", "bar": "ipsum"}' | yq -o json --colors

echo '{"foo": "lorem", "bar": "ipsum"}' | yq -o json --no-colors