С Python 2. 6+ вы можете просто сделать:

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

или, если JSON находится в файле, вы можете сделать:

python -m json.tool my_json.json

если JSON находится из интернет-источника, такого как 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 и он будет доступен каждый раз в оболочке. prettyjson_s '{"foo": "lorem", "bar": "ipsum"}' его как prettyjson_s '{"foo": "lorem", "bar": "ipsum"}'.

Вы можете использовать: jq

Он очень прост в использовании, и он отлично работает! Он может обрабатывать очень большие структуры JSON, включая потоки. Ты можешь найти их учебники здесь.

Вот пример:

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

Или другими словами:

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

Я использую аргумент "space" для JSON.stringify для JSON.stringify печати JSON в JavaScript.

Примеры:

// Indent with 4 spaces
JSON.stringify({"foo":"lorem","bar":"ipsum"}, null, 4);

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

Из командной строки Unix с nodejs, указав json в командной строке:

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

Возвращает:

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

Из командной строки Unix с Node.js, указав имя файла, содержащее 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));\
 });\
"

Я написал инструмент, который имеет один из лучших "умных белых" форматировщиков. Он дает более читаемый и менее подробный вывод, чем большинство других опций здесь.

подчеркивание-кли

Это то, что выглядит "умный белый":

Я могу быть немного предвзятым, но это отличный инструмент для печати и обработки данных JSON из командной строки. Он очень удобен в использовании и имеет обширную справочную/документацию по командной строке. Это нож швейцарской армии, который я использую для 1001 различных небольших задач, которые были бы удивительно раздражающими, чтобы сделать любой другой способ.

Последний вариант использования: консоль Chrome, Dev, вкладка "Сеть", экспортировать все как файл HAR, "cat site.har | underscore select".url --outfmt text | grep mydomain "; теперь у меня есть хронологически упорядоченный список всех URL-адресов, сделанных во время загрузки моего сайта компании.

Довольно печатать легко:

underscore -i data.json print

То же самое:

cat data.json | underscore print

То же самое, более явное:

cat data.json | underscore print --outfmt pretty

Этот инструмент - мой текущий проект страсти, поэтому, если у вас есть какие-либо запросы о функциях, есть хороший шанс, я обращусь к ним.

Обычно я просто делаю:

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

Благодаря Дж. Ф. Себастьяну очень полезные указатели, здесь немного расширенный script Я придумал:

#!/usr/bin/python

"""
Convert JSON data to human-readable form.

Usage:
  prettyJSON.py inputFile [outputFile]
"""

import sys
import simplejson as json


def main(args):
    try:
        if args[1] == '-':
            inputFile = sys.stdin
        else:
            inputFile = open(args[1])
        input = json.load(inputFile)
        inputFile.close()
    except IndexError:
        usage()
        return False
    if 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))

С Perl используйте модуль CPAN JSON::XS. Он устанавливает инструмент командной строки json_xs.

Validate:

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 "Extension System" ).

On * nix, чтение из stdin и запись в stdout работает лучше:

#!/usr/bin/env python
"""
Convert JSON data to human-readable form.

(Reads from stdin and writes to stdout)
"""

import sys
try:
    import simplejson as json
except:
    import json

print json.dumps(json.loads(sys.stdin.read()), indent=4)
sys.exit(0)

Поместите это в файл (я назвал свой "prettyJSON" после AnC ответа) в вашем PATH и chmod +x, и вы хорошо перейти.

Если вы используете npm и Node.js, вы можете сделать npm install -g json, а затем выполнить команду через json. Сделайте json -h, чтобы получить все варианты. Он также может вытащить определенные поля и раскрасить результат с помощью -i.

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

Это не слишком просто с родным способом с инструментами jq.

Например:

cat xxx | jq .

JSON Ruby Gem поставляется с оболочкой script для защиты JSON:

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

Script скачать: gist.github.com/3738968

ОБНОВЛЕНИЕ Я использую jq сейчас, как это предлагается в другом ответе. Это чрезвычайно мощно при фильтрации JSON, но, по своему самому основному, также является удивительным способом довольно печатать JSON для просмотра.

jsonpp - очень приятная строка командной строки JSON.

Из README:

Довольно печатайте ответы на веб-службу, например:

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

и сделайте красивые файлы, которые работают на вашем диске:

jsonpp data/long_malformed.json

Если вы находитесь в Mac OS X, вы можете brew install jsonpp. Если нет, вы можете просто скопировать двоичный файл где-нибудь в $PATH.

Попробуйте pjson. Он имеет цвета!

Установите его с помощью pip:

pip install pjson

А затем pjson любой контент JSON в pjson.

Что я делаю:

curl yourUri | json_pp

Он сокращает код и выполняет задание.

$ 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"
}

Если оставшаяся часть вашего конвейера будет изящно обрабатывать юникод, и вы хотите, чтобы ваш JSON был также удобным для людей, просто use 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"
}

Я использую jshon, чтобы сделать то, что вы описываете. Просто запустите:

echo $COMPACTED_JSON_TEXT | jshon

Вы также можете передавать аргументы для преобразования данных JSON.

Или, с Ruby:

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

Отъезд Jazor. Это простой синтаксический анализатор JSON, написанный на Ruby.

gem install jazor
jazor --help

Просто подайте вывод на jq ..

Пример:

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

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

Pygmentize

Я совмещаю Python json.tool с pygmentize:

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

Есть несколько альтернатив pygmentize, которые перечислены в моем ответе.

Вот живая демонстрация:

Vanilla Bash

Простой сценарий Bash (grep/awk) для довольно 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}'

Примеры:

1) Чтение файла и печать в консоли

cat file.json | json_pretty.sh

2) Используйте с окнами GIT Bash из файла в файл (на основе UTF8):

cat fileIn.json |sh.exe json_pretty.sh > fileOut.json

С Perl, если вы установите JSON:: PP из CPAN, вы получите json_pp. Воровав пример из B Bycroft, вы получите:

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

Стоит отметить, что json_pp поставляется с предустановленной версией Ubuntu 12.04 (по крайней мере) и Debian в /usr/bin/json_pp

Я рекомендую использовать утилиту командной строки json_xs, которая включена в модуль JSON:: XS perl. JSON:: XS - это модуль Perl для сериализации/десериализации JSON, на машине Debian или Ubuntu вы можете установить его следующим образом:

sudo apt-get install libjson-xs-perl

Он также доступен на CPAN.

Чтобы использовать его для форматирования JSON, полученного из URL-адреса, вы можете использовать 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

• brew install jq
• command + | jq
• (пример: curl localhost:5000/blocks | jq)
• Наслаждайтесь!

jj работает очень быстро, может экономно обрабатывать огромные JSON-документы, не работает с действительными числами JSON и прост в использовании, например:

jj -p # for reading from STDIN

или же

jj -p -i input.json

Он (2018) все еще довольно новый, так что, возможно, он не будет обрабатывать некорректный JSON так, как вы ожидаете, но его легко установить на основные платформы.

Установите yajl-инструменты с помощью команды ниже:

sudo apt-get install yajl-tools

то

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

yajl очень хорошо, по моему опыту. Я использую команду json_reformat для печати .json файлов в vim, помещая следующую строку в мой .vimrc:

autocmd FileType json setlocal equalprg=json_reformat

Версия 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

Используйте 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

Я использую httpie

$ pip install httpie

И вы можете использовать его так:

 $ http PUT localhost:8001/api/v1/ports/my 
 HTTP/1.1 200 OK
 Connection: keep-alive
 Content-Length: 93
 Content-Type: application/json
 Date: Fri, 06 Mar 2015 02:46:41 GMT
 Server: 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
 }

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

вы можете использовать эту простую команду для достижения результата.

Я знаю, что на этот вопрос ответили ad nauseam, но я хотел документировать решение Ruby, которое лучше, чем команда Json prettify, gem colorful_json довольно хорош.

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

J.F. Решения Sebastian не работали для меня в Ubuntu 8.04.
Вот модифицированная версия Perl, которая работает со старой библиотекой JXON 1.X:

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

bat - клон cat с подсветкой синтаксиса: https://github.com/sharkdp/bat

Пример:

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

-p будет выводиться без заголовков, а -l явно укажет язык.

Он имеет раскраску и форматирование для json и не имеет проблем, отмеченных в этом комментарии: как я могу -p rint JSON в сценарии оболочки?

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

Существует TidyJSON.

Это С#, поэтому, возможно, вы можете получить его для компиляции с Mono и работать с * nix. Никаких гарантий, хотя, извините.

Инструмент ydump - довольно красивый принтер JSON:

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

Или вы можете подключиться к JSON:

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

Это, вероятно, самое короткое решение, кроме использования инструмента jq.

Этот инструмент является частью библиотеки yojson для OCaml и документирован здесь.

В Debian и производных пакет libyojson-ocaml-dev содержит этот инструмент. В качестве альтернативы yojson можно установить через OPAM.

Вот как это сделать с помощью Groovy script.

Создайте Groovy script, скажем, "pretty-print"

#!/usr/bin/env groovy

import groovy.json.JsonOutput

System.in.withReader { println JsonOutput.prettyPrint(it.readLine()) }

Сделайте исполняемый файл script:

chmod +x pretty-print

Теперь из командной строки

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

Для 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}))}}))"

Если у вас установлен Node.js, вы можете создать его самостоятельно с помощью одной строки кода. Создайте файл довольно:

> vim pretty

#!/usr/bin/env node

console.log(JSON.stringify(JSON.parse(process.argv[2]), null, 2));

Добавить разрешение выполнения:

> chmod + x pretty

> ./pretty '{ "foo": "lorem", "bar": "ipsum" }'

Или, если ваш JSON находится в файле:

#!/usr/bin/env node

console.log(JSON.stringify(require("./" + process.argv[2]), null, 2));

> ./pretty file.json

С JavaScript/NodeJS: посмотрите vkBeautify.js плагин, который обеспечивает довольно печать для текста JSON и XML.

Он написан на обычном JavaScript, менее 1,5 КБ (минимализирован) и очень быстро.

Я автор 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

https://github.com/aidanmelen/json_pretty_print

from __future__ import unicode_literals
from __future__ import absolute_import
from __future__ import print_function
from __future__ import division

import json
import 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))

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

Этот метод также " Обнаруживает HTTP-ответ/заголовки, печатает их нетронутыми и пропускает тело (для использования с `curl -i ')" .

Вот Groovy однострочный:

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

Однострочное решение с использованием nodejs будет выглядеть так:

$ 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 - это инструмент командной строки для загрузки и извлечения данных со страниц HTML/XML или JSON-API с использованием CSS, XPath 3.0, XQuery 3.0, JSONiq или шаблонов шаблонов. Он также может создавать новые или преобразованные документы XML/HTML/JSON.

Xidel pretty-prints по умолчанию:

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

или же:

$ echo '{"foo":"lorem","bar":"ipsum"}' | xidel -s - -e .
{
  "foo": "lorem",
  "bar": "ipsum"
}

просто добавив еще один вариант для полноты jtc - jtc:

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

jtc пусть печать в сыром (компактном) формате. Для красивого формата также существует опция tab/indent:

bash $ echo '{"foo": "lorem", "bar": "ipsum"}' | jtc -r
{ "bar": "ipsum", "foo": "lorem" }
bash $ echo '{"foo": "lorem", "bar": "ipsum"}' | jtc -t1
{
 "bar": "ipsum",
 "foo": "lorem"
}
bash $ 

Также не забудьте проверить JSONFUI: программа командной строки JSON, которая поддерживает фальцовку

Если вы не возражаете против использования стороннего инструмента, вы можете просто зависнуть до jsonprettyprint.org. Это относится к случаю, когда вы не можете устанавливать пакеты на машине.

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

Мои файлы JSON не обрабатывались ни одним из этих методов.

Моя проблема была похожа на этот пост Источник данных Google JSON недействителен?.

Ответ на этот пост помог мне найти решение. https://stackoverflow.com/questions/628505/is-google-data-source-json-not-valid

Он считается недопустимым 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/. Я думаю, что этот парсер гораздо более терпим к ошибкам, чем многие другие.

Я знаю, что исходный пост запрашивал оболочку script, но есть так много полезных и нерелевантных ответов, которые, вероятно, не помогли оригинальному автору. Добавление к неуместности:)

BTW Я не мог заставить инструменты командной строки работать.

Если кто-то хочет простой 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
}

Вместо этого вы можете использовать онлайн-инструменты, если это вариант для вас.

Я считаю http://jsonprettyprint.net самым простым и легким.