Существует ли (Unix) сценарий оболочки для форматирования JSON в удобочитаемой форме?

По сути, я хочу преобразовать следующее:

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

... в нечто вроде этого:

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

С 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"}'.

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

Он очень прост в использовании и отлично работает! Он может обрабатывать очень большие структуры 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"
}

. это идентификационный фильтр.

Я использую аргумент "пробел", 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 с Node.js, указав 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, вкладка Network, экспорт всего в виде файла 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

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

#!/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))

Если вы используете 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 .

С 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 «Extension System»).

На * nix чтение из стандартного ввода и запись в стандартный вывод работает лучше:

#!/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, и все готово .

JSON Ruby Gem поставляется со сценарием оболочки для предварительной настройки JSON:

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

Скрипт загрузки: gist.github.com/3738968

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

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

Из README:

Довольно распечатать ответы веб-сервисов так:

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

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

jsonpp data/long_malformed.json

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

Вот как я это делаю:

curl yourUri | json_pp

Это сокращает код и выполняет работу.

простой 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

Попробуй pjson. У него есть цвета!

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

⚡ pip install pjson

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

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

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

echo $COMPACTED_JSON_TEXT | jshon

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

Или с Руби:

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

Проверьте Jazor . Это простой JSON-анализатор командной строки, написанный на Ruby.

gem install jazor
jazor --help

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

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

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

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

Пример:

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

С 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

Pygmentize

Я комбинирую Python's json.tool с pygmentize:

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

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

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

Я рекомендую использовать утилиту командной строки json_xs, которая включена в модуль perl JSON :: XS. 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

Вы можете просто использовать стандартные инструменты, такие как jq или json_pp.

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

или

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

оба преобразуют вывод, как показано ниже (jq еще более красочный):

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

Огромным преимуществом jq является то, что он может сделать намного больше, если вы хотите проанализировать и обработать json.

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

jj -p # for reading from STDIN

или

jj -p -i input.json

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

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

batэто catклон с подсветкой синтаксиса:

Пример:

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

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

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

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

sudo apt-get install yajl-tools

тогда,

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