Есть TidyJSON.

Это C#, так что, возможно, вы сможете скомпилировать его с помощью Мононуклеоз и поработать над * 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"
}

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

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

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

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

Или с 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 из интернет-источника, такого как 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"}'.

Обратите внимание, что, как указывает @pnd в комментариях ниже, в Python 3.5+ объект JSON больше не сортируется по умолчанию. Для сортировки добавьте в конец флаг --sort-keys. Т.е. ... | python -m json.tool --sort-keys.

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

sudo gem install json
echo '{ "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 «Система расширений»).

Я использую аргумент «пробел» в 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.info(JSON.stringify(JSON.parse(process.argv[1]), null, '\t'));" \
  '{"foo":"lorem","bar":"ipsum"}'

Возврат:

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

Из командной строки Unix с помощью Node.js, указав имя файла, содержащее JSON, и используя отступ в четыре пробела:

$ node -e "console.info(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.info(JSON.stringify(JSON.parse(d.join('')),null,2));\
 });\
"

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

gem install jazor
jazor --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, которая включена в модуль 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

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

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

autocmd FileType json setlocal equalprg=json_reformat

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

echo $COMPACTED_JSON_TEXT | jshon

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

В Perl, если вы устанавливаете JSON :: PP из CPAN, вы получите команду json_pp. Украдя пример у Б. Байкрофт, вы получите:

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

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

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

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-лайнер. Это инструмент командной строки для преобразования 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 не анализировались ни одним из этих методов.

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

Ответ на этот пост помог мне найти решение.

Считается недействительным 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

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

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

Вот как выглядит "умный пробел":

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

Последний вариант использования: Chrome, консоль разработчика, вкладка «Сеть», экспорт всего в виде файла 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

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

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

Кстати, я не мог заставить работать какие-либо инструменты командной строки.

Если кому-то нужен простой код 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-tools с помощью следующей команды:

sudo apt-get install yajl-tools

потом,

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

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

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

⚡ pip install pjson

А затем передайте все содержимое JSON в pjson.

Вы можете использовать: 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"
}

Или используйте 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-принтер для командной строки.

Из README:

Pretty print web service responses like so:

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

and make beautiful the files running around on your disk:

jsonpp data/long_malformed.json

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

Вот решение Ruby, которое лучше команды prettify Json. Самоцвет colorful_json неплох.

gem install colorful_json
echo '{"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/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
 }

Пигментизировать

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

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

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

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

Для Node.js вы также можете использовать модуль «util». Он использует подсветку синтаксиса, интеллектуальные отступы, удаляет кавычки из ключей и просто делает вывод максимально красивым.

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

gem install jsonpretty
echo '{"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.

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

В 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 pretty

#!/usr/bin/env node

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

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

> chmod +x pretty

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

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

#!/usr/bin/env node

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

> ./pretty file.json

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

curl yourUri | json_pp

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

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

С родным способом с инструменты 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

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

Пример:

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

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

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

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

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

Например:

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

Вы можете использовать Сидель.

Xidel is a command line tool to download and extract data from HTML/XML pages or JSON-APIs, using CSS, XPath 3.0, XQuery 3.0, JSONiq or pattern templates. It can also create new or transformed XML/HTML/JSON documents.

По умолчанию Xidel красиво печатает:

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

или же:

$ echo '{"foo":"lorem","bar":"ipsum"}' | xidel -s - -e .
{
  "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.

TL; DR: для выступлений используйте jj -p < my.json.

Контрольный показатель

Я взял здесь несколько решений и протестировал их с помощью следующего фиктивного скрипта:

function bench {
    time (
      for i in {1..100}; do
        echo '{ "foo": "lorem", "bar": "ipsum" }'  | $@ > /dev/null
      done
    )
}

Вот результат на моем Mac (8 ГБ 2133 МГц LPDDR3, 2,3 ГГц Intel Core i5):

bench python -m json.tool
# 3.60s user 1.24s system 88% cpu 5.448 total
bench jq
# 2.79s user 0.29s system 89% cpu 3.453 total
bench bat -p -l json
# 5.77s user 0.99s system 95% cpu 7.080 total
bench jj -p
# 0.19s user 0.26s system 85% cpu 0.529 total

Спасибо @peak и вашему отвечать за это открытие jj!

Я придумал это решение: https://calbertts.medium.com/unix-pipelines-with-curl-requests-and-serverless-functions-e21117ae4c65

# this in your bash profile
jsonprettify() {
  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
#     ]
# }

Нет необходимости ничего устанавливать, если у вас есть подключение к Интернету и установлен cURL, вы можете использовать эту функцию.

Вы находитесь на другом хосте, где ничего не можете установить, это было бы идеальным решением этой проблемы.

Когда у вас установлен узел в вашей системе, работает следующее.

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

{
  "test": 1,
  "test2": 2
}