it-swarm.com.de

Wie kann ich JSON in einem Shell-Skript drucken?

Gibt es ein (Unix) Shell-Skript zum Formatieren von JSON in für Menschen lesbarer Form?

Grundsätzlich möchte ich, dass es Folgendes umwandelt:

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

... in so etwas:

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

Mit Python 2.6+ können Sie einfach Folgendes tun:

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

wenn sich der JSON in einer Datei befindet, können Sie Folgendes tun:

python -m json.tool my_json.json

wenn der JSON von einer Internetquelle wie einer API stammt, können Sie verwenden

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

In allen diesen Fällen können Sie einen Alias ​​verwenden:

alias prettyjson='python -m json.tool'

Für noch mehr Komfort mit etwas mehr Tippen, um es vorzubereiten:

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

prettyjson_f() {
    python -m json.tool "$1"
}

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

für alle oben genannten Fälle. Sie können dies in .bashrc eingeben und es wird jedes Mal in Shell verfügbar sein. Rufen Sie es wie prettyjson_s '{"foo": "lorem", "bar": "ipsum"}' auf.

3958
B Bycroft

Sie können verwenden: jq

Es ist sehr einfach zu bedienen und funktioniert super! Es kann sehr große JSON-Strukturen einschließlich Streams verarbeiten. Sie finden Ihre Tutorials hier .

Hier ist ein Beispiel:

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

Oder mit anderen Worten:

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

Ich benutze das "space" -Argument von JSON.stringify , um JSON in JavaScript zu drucken.

Beispiele:

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

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

Geben Sie in der Unix-Befehlszeile mit nodejs json in der Befehlszeile an:

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

Kehrt zurück:

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

Geben Sie in der Unix-Befehlszeile mit Node.js einen Dateinamen an, der JSON enthält, und verwenden Sie einen Einzug aus vier Leerzeichen:

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

Mit einer Pfeife:

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));\
 });\
"
366
Somu

Ich habe ein Tool geschrieben, das eines der besten verfügbaren "intelligenten Whitespace" -Formate hat. Es erzeugt eine lesbarere und weniger ausführliche Ausgabe als die meisten anderen Optionen hier.

unterstrichen-cli

So sieht "Smart Whitespace" aus:

 

Ich bin zwar ein bisschen voreingenommen, aber es ist ein großartiges Werkzeug zum Drucken und Bearbeiten von JSON-Daten über die Befehlszeile. Es ist sehr benutzerfreundlich und verfügt über ausführliche Befehlszeilenhilfe/Dokumentation. Es ist ein Schweizer Taschenmesser, das ich für 1001 verschiedene kleine Aufgaben benutze, die auf andere Weise überraschend ärgerlich wären.

Letzter Anwendungsfall: Chrome, Dev-Konsole, Registerkarte "Netzwerk", alle als HAR-Datei exportieren. Jetzt habe ich eine chronologisch geordnete Liste aller URL-Abrufe, die während des Ladens der Website meines Unternehmens gemacht wurden.

Hübsches Drucken ist einfach:

underscore -i data.json print

Gleiche Sache:

cat data.json | underscore print

Gleiches, expliziter:

cat data.json | underscore print --outfmt pretty

Dieses Tool ist mein aktuelles Passionsprojekt. Wenn Sie also Funktionswünsche haben, besteht eine gute Chance, dass ich sie ansprechen werde.

326
Dave Dopson

Ich mache normalerweise nur:

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

Und um ausgewählte Daten abzurufen (in diesem Fall den Wert "test"):

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

Wenn sich die JSON-Daten in einer Datei befinden:

python -mjson.tool filename.json

Wenn Sie alles auf einmal mit curl in der Befehlszeile mit einem Authentifizierungstoken tun möchten:

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

Dank der hilfreichen Hinweise von J. F. Sebastian, hier ein leicht verbessertes Skript, das ich mir ausgedacht habe:

#!/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 __== "__main__":
    sys.exit(not main(sys.argv))
85
AnC

Wenn Sie npm und Node.js verwenden, können Sie npm install -g json ausführen und dann den Befehl über json weiterleiten. Führen Sie json -h aus, um alle Optionen zu erhalten. Es kann auch bestimmte Felder herausziehen und die Ausgabe mit -i einfärben.

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

Verwenden Sie bei Perl das CPAN-Modul JSON::XS. Es installiert ein Befehlszeilenprogramm json_xs.

Bestätigen:

json_xs -t null < myfile.json

Bestätigen Sie die JSON-Datei src.json mit pretty.json:

< src.json json_xs > pretty.json

Wenn Sie json_xs nicht haben, versuchen Sie json_pp. "pp" steht für "pure Perl" - das Tool ist nur in Perl implementiert, ohne dass eine Bindung an eine externe C-Bibliothek besteht (dafür steht XS, "Extension System" von Perl).

68
knb

Auf * nix funktioniert das Lesen von stdin und schreiben in stdout besser:

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

Fügen Sie dies in eine Datei ein (ich habe mein "prettyJSON" nach der Antwort von AnC benannt) in PATH und chmod +x, und Sie können loslegen.

67
Daryl Spitzer

Der JSON Ruby Gem wird mit einem Shell-Skript geliefert, um JSON zu verbessern:

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

Skript-Download: Gist.github.com/3738968

64
Paul Horsfall

Es ist nicht zu einfach, auf native Weise mit den jq-Tools .

Zum Beispiel: 

cat xxx | jq .
63
Olexandr Minzak

UPDATE Ich verwende jq jetzt wie in einer anderen Antwort vorgeschlagen. Es ist extrem leistungsfähig beim Filtern von JSON, aber in seiner einfachsten Form ist es auch eine großartige Möglichkeit, JSON für die Anzeige zu drucken.

jsonpp ist ein sehr hübscher JSON-Drucker.

Aus der README:

Ziemlich gedruckte Webservice-Antworten wie folgt:

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

und machen Sie die Dateien auf Ihrer Festplatte schön:

jsonpp data/long_malformed.json

Wenn Sie mit Mac OS X arbeiten, können Sie brew install jsonpp. Wenn nicht, können Sie die Binärdatei einfach an eine beliebige Stelle in Ihrem $PATH kopieren.

53
jordelver

Versuchen Sie pjson . Es hat Farben!

echo '{"json":"obj"} | pjson

Installieren Sie es mit pip:

⚡ pip install pjson

Und dann den JSON-Inhalt an pjson weiterleiten.

So mach ich es:

curl yourUri | json_pp

Es verkürzt den Code und erledigt die Arbeit.

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

HINWEIS: Es ist nicht die - Methode, dies zu tun.

Dasselbe in Perl:

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

Hinweis 2: Wenn Sie ausführen

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

das schön lesbare Wort wird\u00fcodiert

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

Wenn der Rest Ihrer Pipeline Unicode einwandfrei handhabt und Sie möchten, dass Ihr JSON auch benutzerfreundlich ist, einfach useensure_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)'

und du bekommst:

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

Ich benutze jshon , um genau das zu tun, was Sie beschreiben. Renn einfach:

echo $COMPACTED_JSON_TEXT | jshon

Sie können auch Argumente übergeben, um die JSON-Daten umzuwandeln.

39
yardena

Check out Jazor . Es ist ein einfacher, in Ruby geschriebener JSON-Parser.

gem install jazor
jazor --help
37
Mike

Oder mit Ruby:

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

Leiten Sie die Ausgabe einfach an jq . weiter.

Beispiel:

twurl -H ads-api.Twitter.com '.......' | jq .
29
Ackshaey Singh

JSONLint hat eine Open-Source-Implementierung auf github kann in der Befehlszeile oder in einem Projekt "node.js" verwendet werden.

npm install jsonlint -g

und dann

jsonlint -p myfile.json

oder

curl -s "http://api.Twitter.com/1/users/show/user.json" | jsonlint | less
28
Salman A

Vanilla Bash

Ein einfaches Bash-Skript (grep/awk) für den hübschen JSON-Druck ohne Installation durch Dritte:

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}'

Beispiele:

1) Lesen Sie die Datei und drucken Sie sie in der Konsole aus

cat file.json | json_pretty.sh

2) Verwenden Sie mit Windows GIT Bash von Datei zu Datei (UTF8-basiert):

cat fileIn.json |sh.exe json_pretty.sh > fileOut.json
23
Evgeny Karpov

Pygementize

Ich kombiniere Pythons json.tool mit pygementize:

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

Es gibt einige Alternativen zu pygementize, die in meiner Antwort aufgelistet sind.

Hier ist eine Live-Demo:

 Demo

23

Wenn Sie mit Perl JSON :: PP von CPAN installieren, erhalten Sie den Befehl json_pp . Das Beispiel from B Bycroft stehlen erhalten Sie:

[[email protected] ~]$ echo '{"foo": "lorem", "bar": "ipsum"}' | json_pp
{
   "bar" : "ipsum",
   "foo" : "lorem"
}

Es ist erwähnenswert, dass json_pp mit Ubuntu 12.04 (mindestens) und Debian in /usr/bin/json_pp vorinstalliert ist.

19
Philip Durbin

Ich empfehle die Verwendung des Befehlszeilen-Dienstprogramms json_xs, das im Perl-Modul JSON :: XS enthalten ist. JSON :: XS ist ein Perl-Modul zum Serialisieren/Deserialisieren von JSON. Auf einem Debian- oder Ubuntu-Computer können Sie es folgendermaßen installieren:

Sudo apt-get install libjson-xs-Perl

Es ist natürlich auch auf CPAN verfügbar.

Um es zu verwenden, um JSON zu formatieren, das von einer URL abgerufen wird, können Sie curl oder wget folgendermaßen verwenden:

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

oder dieses:

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

um JSON in einer Datei zu formatieren, können Sie Folgendes tun:

$ json_xs < file-full-of.json

Umformatiert als YAML , was manche Leute für menschlicher lesbar halten als JSON:

$ json_xs -t yaml < file-full-of.json
18
htaccess
  1. brew install jq
  2. command + | jq 
  3. (Beispiel: curl localhost:5000/blocks | jq)
  4. Genießen!

 enter image description here

15

jj ist superschnell, kann ginormöse JSON-Dokumente wirtschaftlich verarbeiten, verwendet keine gültigen JSON-Nummern und ist einfach zu verwenden, z. 

jj -p # for reading from STDIN

oder

jj -p -i input.json

Es ist (2018) immer noch recht neu, daher wird es möglicherweise nicht mit ungültigen JSONs wie erwartet umgehen, aber es ist einfach auf großen Plattformen zu installieren.

14
peak

Installieren Sie yajl-tools mit dem folgenden Befehl:

Sudo apt-get install yajl-tools

dann,

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

11

yajl ist aus meiner Erfahrung sehr nett. Ich benutze seinen json_reformat-Befehl, um .json-Dateien in vim zu drucken, indem ich folgende Zeile in meinen .vimrc setze:

autocmd FileType json setlocal equalprg=json_reformat
10
Hank Gay

Die PHP -Version, wenn Sie PHP> = 5.4 haben.

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

Verwenden Sie Ruby in einer Zeile:

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

Und Sie können dafür einen Alias ​​setzen:

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

Dann können Sie es bequemer verwenden

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

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

Und wenn Sie JSON mit Farbe anzeigen möchten, können Sie awesome_print installieren,

gem install awesome_print

dann

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

Versuch es!

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

 Enter image description here

8
fangxing

bat ist ein cat-Klon mit Syntaxhervorhebung: https://github.com/sharkdp/bat

Beispiel:

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

-p wird ohne Header ausgegeben und -l wird die Sprache explizit angeben.

Es hat Farbgebung und Formatierung für Json und hat nicht die in diesem Kommentar genannten Probleme: Wie kann ich JSON in einem Shell-Skript hübsch drucken?

8
Grav

Ich benutze httpie

$ pip install httpie

Und du kannst es so benutzen

 $ 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
 }
8
slashmili

Ich weiß, dass diese Frage ad nauseam beantwortet wurde, aber ich wollte eine Ruby-Lösung dokumentieren, die besser ist als Jsons prettify-Befehl. Der Edelstein colorful_json ist ziemlich gut.

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

Die Lösungen von J. F. Sebastian haben in Ubuntu 8.04 nicht funktioniert.
Hier ist eine modifizierte Perl-Version, die mit der älteren 1.X-JSON-Bibliothek funktioniert:

Perl -0007 -MJSON -ne 'print objToJson(jsonToObj($_, {allow_nonref=>1}), {pretty=>1}), "\n";'
7
pimlottc
echo "{ \"foo\": \"lorem\", \"bar\": \"ipsum\" }"|python -m json.tool

sie können diesen einfachen Befehl verwenden, um das Ergebnis zu erzielen.

7
Arpit Rathod
$ Sudo apt-get install edit-json
$ prettify_json myfile.json
6
Bryan Larsen

So machen Sie es mit Groovy script.

Erstellen Sie ein Groovy-Skript, sagen wir "Pretty-Print".

#!/usr/bin/env groovy

import groovy.json.JsonOutput

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

Skript ausführbar machen:

chmod +x pretty-print

Jetzt von der Befehlszeile aus

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

Es gibt TidyJSON .

Es ist C #, vielleicht können Sie es mit Mono kompilieren und an * nix arbeiten. Keine Garantien, sorry.

5
Robert Gould

Das Tool ydump ist ein hübscher JSON-Drucker:

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

Oder Sie können die JSON-Pipeline eingeben:

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

Dies ist wahrscheinlich die kürzeste Lösung, abgesehen von der Verwendung des Tools jq.

Dieses Werkzeug ist Teil der Bibliothek yojson für OCaml und ist hier dokumentiert.

Bei Debian und Derivaten enthält das Paket libyojson-ocaml-dev dieses Tool. Alternativ kann yojson über OPAM installiert werden.

5
josch

Für Node.js können Sie auch das Modul "util" verwenden. Es verwendet Syntaxhervorhebung, intelligente Einrückung, entfernt Anführungszeichen von Schlüsseln und macht die Ausgabe einfach so hübsch, wie es nur geht.

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}))}}))"
4
adius

Ich bin der Autor von Json-Liner . Es ist ein Befehlszeilentool, um JSON in ein grep-freundliches Format umzuwandeln. Versuche es.

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

Wenn Sie Node.js installiert haben, können Sie selbst eine mit einer Codezeile erstellen. Erstellen Sie eine Datei hübsch:

> vim hübsch

#!/usr/bin/env node

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

Ausführungsberechtigung hinzufügen:

> chmod + x hübsch

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

Oder wenn sich Ihr JSON in einer Datei befindet:

#!/usr/bin/env node

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

> ./pretty file.json

3
Nikhil Ranjan

Mit JavaScript/NodeJS: Schauen Sie sich das vkBeautify.js-Plugin an, das sowohl für JSON- als auch für XML-Text hübsches Drucken ermöglicht.

Es ist in einfachem JavaScript geschrieben, weniger als 1,5 KB (minimiert) und sehr schnell.

3
vadimk

Hier ist Groovy One-Liner:

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

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))
2
Aidan Melen
gem install jsonpretty
echo '{"foo": "lorem", "bar": "ipsum"}' | jsonpretty

Diese Methode auch "Erkennt HTTP-Antwort/Header, druckt sie unberührt und springt zu Dem Hauptteil (zur Verwendung mit` curl -i ') " .

2
lev

Eine einzeilige Lösung, die nodejs verwendet, sieht folgendermaßen aus

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

für zB:

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

Sie können smk verwenden:

echo '{"foo": "lorem", "bar": "ipsum"}' | smk -e"JSON.stringify(JSON.parse(data), null, 4)"

In einer Zeile

echo '{"foo": "lorem", "bar": "ipsum"}' | npx smk -e"JSON.stringify(JSON.parse(data), null, 4)"
0

Wenn es Ihnen nichts ausmacht, ein Drittanbieter-Tool zu verwenden, können Sie sich einfach zu jsonprettyprint.org bewegen. Dies ist für den Fall, dass Sie keine Pakete auf dem Computer installieren können.

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

Meine JSON-Dateien wurden mit keiner dieser Methoden analysiert. 

Mein Problem ähnelte diesem Beitrag Google Data Source JSON nicht gültig? .

Die Antwort auf diesen Beitrag half mir, eine Lösung zu finden. https://stackoverflow.com/a/628634/619760

Es wird als ungültiger JSON ohne die Zeichenfolgeschlüssel betrachtet.

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

muss sein:

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

Dieser Link bietet einen umfassenden Überblick über einige der verschiedenen JSON-Parser. http://deron.meranda.us/python/comparing_json_modules/basic

Was mich zu http://deron.meranda.us/python/demjson/ führte. Ich denke, dieser Parser ist weitaus fehlertoleranter als viele andere. 

0
nelaaro

Sie können Xidel verwenden. 

Xidel ist ein Befehlszeilenprogramm zum Herunterladen und Extrahieren von Daten aus HTML/XML-Seiten oder JSON-APIs mit CSS, XPath 3.0, XQuery 3.0, JSONiq oder Mustervorlagen. Es können auch neue oder transformierte XML/HTML/JSON-Dokumente erstellt werden.

Xidel-Hübschdrucke standardmäßig:

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

oder:

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