JSON යුනික්ස් මෙවලම් සමඟ විග්‍රහ කිරීම

මම උත්සාහ කරන්නේ JSON වක්‍ර ඉල්ලීමකින් ආපසු පැමිණීම විග්‍රහ කිරීමට ය:

curl 'http://twitter.com/users/username.json' |
    sed -e 's/[{}]/''/g' | 
    awk -v k="text" '{n=split($0,a,","); for (i=1; i<=n; i++) print a[i]}'

ඉහත දැක්වෙන්නේ JSON ක්ෂේත්‍රයට බෙදීමයි, උදාහරණයක් ලෙස:

% ...
"geo_enabled":false
"friends_count":245
"profile_text_color":"000000"
"status":"in_reply_to_screen_name":null
"source":"web"
"truncated":false
"text":"My status"
"favorited":false
% ...

විශේෂිත ක්ෂේත්‍රයක් මුද්‍රණය කරන්නේ කෙසේද -v k=text?

විධාන රේඛාවෙන් JSON හැසිරවීම සඳහා විෙශේෂෙයන් නිර්මාණය කර ඇති මෙවලම් ගණනාවක් ඇති අතර, ඒවා අව්ක් සමඟ කිරීමට වඩා පහසු සහ විශ්වාසදායක වනු ඇත, වැනි jq:

curl -s 'https://api.github.com/users/lambda' | jq -r '.name'

jsonමොඩියුලය භාවිතා කරන පයිතන් වැනි ඔබේ පද්ධතියේ දැනටමත් ස්ථාපනය කර ඇති මෙවලම් සමඟද ඔබට මෙය කළ හැකිය , එබැවින් නිසි JSON විග්‍රහකයකුගේ වාසිය තිබියදීත් අමතර පරායත්තතාවයන් වළක්වා ගන්න. පහත දැක්වෙන උපකල්පනය ඔබට මුල් JSON කේතනය කළ යුතු UTF-8 භාවිතා කිරීමට අවශ්‍ය යැයි උපකල්පනය කරන අතර බොහෝ නූතන පර්යන්තයන් ද භාවිතා කරන්නේ එයයි:

පයිතන් 3:

curl -s 'https://api.github.com/users/lambda' | \
    python3 -c "import sys, json; print(json.load(sys.stdin)['name'])"

පයිතන් 2:

export PYTHONIOENCODING=utf8
curl -s 'https://api.github.com/users/lambda' | \
    python2 -c "import sys, json; print json.load(sys.stdin)['name']"

Notes තිහාසික සටහන්

මෙම පිළිතුර මුලින් නිර්දේශ කර ඇත්තේ jsawk වන අතර එය තවමත් ක්‍රියාත්මක විය යුතු නමුත් එය භාවිතා කිරීමට වඩා ටිකක් කරදරකාරී jqවන අතර එය පයිතන් පරිවර්තකයෙකුට වඩා අඩු පොදු වන ජාවාස්ක්‍රිප්ට් පරිවර්තකයක් ස්ථාපනය කර ඇති අතර එය රඳා පවතී. එබැවින් ඉහත පිළිතුරු වඩාත් යෝග්‍ය වේ:

curl -s 'https://api.github.com/users/lambda' | jsawk -a 'return this.name'

මෙම පිළිතුර මුලින් ට්විටර් ඒපීඅයි ද භාවිතා කළ නමුත් එම ඒපීඅයි තවදුරටත් ක්‍රියාත්මක නොවන බැවින් අත්හදා බැලීමට උදාහරණ පිටපත් කිරීම දුෂ්කර වන අතර නව ට්විටර් ඒපීඅයි ඒපීඅයි යතුරු අවශ්‍ය වේ, එබැවින් මම ගිට්හබ් ඒපීඅයි භාවිතා කිරීමට මාරු වී සිටිමි. API යතුරු නොමැතිව පහසුවෙන් භාවිතා කළ හැකිය. මුල් ප්‍රශ්නයට පළමු පිළිතුර වනුයේ:

curl 'http://twitter.com/users/username.json' | jq -r '.text'

විශේෂිත යතුරක් සඳහා අගයන් ඉක්මණින් උකහා ගැනීම සඳහා, මම පෞද්ගලිකව කැමතියි “grep -o” භාවිතා කිරීමට, එය නැවත ලබා දෙන්නේ රීජෙක්ස්ගේ තරගය පමණි. උදාහරණයක් ලෙස, ට්වීට් වලින් "පෙළ" ක්ෂේත්‍රය ලබා ගැනීමට, වැනි දෙයක්:

grep -Po '"text":.*?[^\\]",' tweets.json

මෙම රීජෙක්ස් ඔබ සිතනවාට වඩා ශක්තිමත් ය; නිදසුනක් ලෙස, කොමා කාවැද්දූ නූල් සහ ඒවා තුළ ඇති උපුටා දැක්වීම් වලින් ගැලවී ඇත. මම හිතන්නේ තව ටිකක් වැඩ කිරීමෙන් ඔබට පරමාණුක නම් වටිනාකම උකහා ගැනීම සහතික කළ හැකි එකක් බවට පත් කළ හැකිය. (එයට කැදැල්ලක් තිබේ නම්, රීජෙක්ස් කෙනෙකුට එය කළ නොහැක.)

තව දුරටත් පිරිසිදු කිරීම සඳහා (නූල්වල මුල් පිටවීම වළක්වා ගත්තද) ඔබට මෙවැනි දෙයක් භාවිතා කළ හැකිය : | perl -pe 's/"text"://; s/^"//; s/",$//'. ( මෙම විශ්ලේෂණය සඳහා මම මෙය කළෙමි .)

ඔබ සැබෑ JSON විග්‍රහයක් භාවිතා කළ යුතු යැයි අවධාරනය කරන සියලු වෛරකරුවන්ට - ඔව්, එය නිවැරදි බව සඳහා අත්‍යවශ්‍ය වේ, නමුත්

1. දත්ත පිරිසිදු කිරීමේ දෝෂ පරීක්ෂා කිරීම සඳහා අගයන් ගණන් කිරීම හෝ දත්ත පිළිබඳ සාමාන්‍ය හැඟීමක් ලබා ගැනීම වැනි ඉතා ඉක්මන් විශ්ලේෂණයක් කිරීමට, විධාන රේඛාවේ යමක් ගැටීම වේගවත් වේ. පිටපතක් ලිවීම සඳහා සංස්කාරකයක් විවෘත කිරීම අවධානය වෙනතකට යොමු කරයි.
2. grep -oයනු පයිතන් සම්මත jsonපුස්තකාලයට වඩා වේගයෙන් ඇණවුම් කිරීමයි , අවම වශයෙන් මෙය ට්වීට් සඳහා කරන විට (ඒවා K 2 KB බැගින්). jsonමෙය මන්දගාමී නිසාදැයි මට විශ්වාස නැත (මම යම් වේලාවක යජ්ල් සමඟ සැසඳිය යුතුය); නමුත් ප්‍රතිපත්තිමය වශයෙන්, රීජෙක්ස් වේගවත් විය යුතු අතර එය සීමිත තත්වයක් වන අතර එය වඩාත් ප්‍රශස්ත කළ හැකි ය, පුනරාවර්තනයට සහාය විය යුතු පාර්සර් වෙනුවට, මේ අවස්ථාවේ දී, ඔබ නොසලකන ව්‍යුහයන් සඳහා සීපීයූ ගොඩනැගිලි ගස් විශාල ප්‍රමාණයක් වැය කරයි. (යමෙකු සීමිත (ගැඹුරු-සීමිත) JSON විග්‍රහයක් කරන සීමිත රාජ්‍ය සම්ප්‍රේෂකය ලියා ඇත්නම්, එය අපූරු වනු ඇත! මේ අතර අපට “grep -o” ඇත.)

නඩත්තු කළ හැකි කේතයක් ලිවීමට, මම සෑම විටම සැබෑ විග්‍රහ කිරීමේ පුස්තකාලයක් භාවිතා කරමි. මම jsawk උත්සාහ කර නැත , නමුත් එය හොඳින් ක්‍රියාත්මක වන්නේ නම්, එය අංක 1 ස්ථානයට යොමු වේ.

අන්තිම, වෝකියර්, විසඳුම: මම පයිතන් භාවිතා කරන පිටපතක් ලියා jsonඔබට අවශ්‍ය යතුරු ටැබ් වෙන් කළ තීරුවලට උකහා ගනිමි ; පසුව මම awkතීරු වෙත නම් තැබීමට ඉඩ සලසන එතුමකින් එතීමි . මෙහි: json2tsv සහ tsvawk ස්ක්‍රිප්ට් . එබැවින් මෙම උදාහරණය සඳහා එය වනුයේ:

json2tsv id text < tweets.json | tsvawk '{print "tweet " $id " is: " $text}'

මෙම ප්‍රවේශය # 2 අමතන්නේ නැත, එය තනි පයිතන් පිටපතකට වඩා අකාර්යක්ෂම වන අතර එය ටිකක් අස්ථාවර ය: එය නව රේඛා සහ ටැබ් නූල් අගයන් සාමාන්‍යකරණය කිරීමට බල කරයි, අව්ගේ ක්ෂේත්‍රය / වාර්තාගත ලෙස වෙන් කර ඇති ලෝකය දෙස හොඳින් බැලීමට. නමුත් එය ඔබට වඩා විධාන රේඛාවේ රැඳී සිටීමට ඉඩ දෙයි grep -o.

මෙහි ඇති සමහර නිර්දේශයන් (අදහස් දැක්වීමේදී) පයිතන් භාවිතය යෝජනා කළ පදනම මත, උදාහරණයක් සොයා ගැනීමට නොහැකි වීම ගැන මම කලකිරීමට පත්වීමි.

ඉතින්, සමහර JSON දත්ත වලින් තනි අගයක් ලබා ගැනීම සඳහා එක් ලයිනර් එකක් මෙන්න. එය උපකල්පනය කරන්නේ ඔබ දත්ත කොහේ හෝ තැනක සිට ගෙන යන බවයි. එබැවින් එය ස්ක්‍රිප්ටින් සන්දර්භය තුළ ප්‍රයෝජනවත් විය යුතුය.

echo '{"hostname":"test","domainname":"example.com"}' | python -c 'import json,sys;obj=json.load(sys.stdin);print obj["hostname"]'

මාටින් ආර් සහ බොයිකෝගේ නායකත්වය අනුගමනය කරමින්:

$ curl -s 'http://twitter.com/users/username.json' | python -mjson.tool

එමඟින් ඔබට අතිශයින්ම මිත්‍රශීලී ප්‍රතිදානයක් ලැබෙනු ඇත. ඉතා පහසුයි:

$ curl -s 'http://twitter.com/users/username.json' | python -mjson.tool | grep my_key

ඔබ විය හැකි බාගත jqඔබේ වේදිකාව සඳහා ද්විමය (සහ ලකුණු chmod +x jq):

$ curl 'https://twitter.com/users/username.json' | ./jq -r '.name'

එය "name"json වස්තුවෙන් ගුණාංග උපුටා ගනී.

jqමුල් පිටුව පවසන්නේ එය sedJSON දත්ත සඳහා සමාන බවයි.

Node.js භාවිතා කිරීම

පද්ධතිය තිබේ නම් nodeස්ථාපනය කර ඇති අතර, අවශ්‍ය ඕනෑම අගයක් ඉවතට ගැනීම සඳහා -pමුද්‍රණ -eධජ භාවිතා කර ස්ක්‍රිප්ට් ධජ භාවිතා කළ හැකිය JSON.parse.

JSON නූල භාවිතා කර { "foo": "bar" }"foo" හි අගය ඉවත් කිරීම සඳහා සරල උදාහරණයක් :

$ node -pe 'JSON.parse(process.argv[1]).foo' '{ "foo": "bar" }'
bar

අපට ප්‍රවේශය catසහ වෙනත් උපයෝගිතා ඇති බැවින්, අපට මෙය ගොනු සඳහා භාවිතා කළ හැකිය:

$ node -pe 'JSON.parse(process.argv[1]).foo' "$(cat foobar.json)"
bar

හෝ JSON අඩංගු URL වැනි වෙනත් ආකෘතියක්:

$ node -pe 'JSON.parse(process.argv[1]).name' "$(curl -s https://api.github.com/users/trevorsenior)"
Trevor Senior

භාවිතය Python හි JSON සහාය awk භාවිතා වෙනුවට!

මේ වගේ දෙයක්:

curl -s http://twitter.com/users/username.json | \
    python -c "import json,sys;obj=json.load(sys.stdin);print obj['name'];"

ඔබ පාමුලට වෙඩි තබන්නේ කෙසේදැයි ඔබ විමසා ඇති අතර උණ්ඩ සැපයීමට මම මෙහි සිටිමි:

curl -s 'http://twitter.com/users/username.json' | sed -e 's/[{}]/''/g' | awk -v RS=',"' -F: '/^text/ {print $2}'

tr -d '{}'ඒ වෙනුවට ඔබට භාවිතා කළ හැකිය sed. නමුත් ඒවා සම්පූර්ණයෙන්ම අත්හැර දැමීමෙන් අපේක්ෂිත ප්‍රති have ල ඇති බව පෙනේ.

ඔබට පිටත උපුටා දැක්වීම් ඉවත් කිරීමට අවශ්‍ය නම්, ඉහත ප්‍රති the ලය නල මාර්ගයෙන් නල කරන්න sed 's/\(^"\|"$\)//g'

මම හිතන්නේ අනෙක් අය ප්‍රමාණවත් අනතුරු ඇඟවීමක් කර තිබෙනවා. මම ගිලන් රථයක් ඇමතීමට ජංගම දුරකථනයක් සමඟ සිටිමි. සූදානම් වන විට ගින්න.

පයිතන් සමඟ බෑෂ් භාවිතා කිරීම

ඔබගේ .bash_rc ගොනුවේ bash ශ්‍රිතයක් සාදන්න

function getJsonVal () { 
    python -c "import json,sys;sys.stdout.write(json.dumps(json.load(sys.stdin)$1))"; 
}

ඉන්පසු

$ curl 'http://twitter.com/users/username.json' | getJsonVal "['text']"
My status
$ 

මෙන්න එකම කාර්යය, නමුත් දෝෂ පරීක්ෂා කිරීම සමඟ.

function getJsonVal() {
   if [ \( $# -ne 1 \) -o \( -t 0 \) ]; then
       cat <<EOF
Usage: getJsonVal 'key' < /tmp/
 -- or -- 
 cat /tmp/input | getJsonVal 'key'
EOF
       return;
   fi;
   python -c "import json,sys;sys.stdout.write(json.dumps(json.load(sys.stdin)$1))";
}

එහිදී $ # -ne 1 අවම වශයෙන් ආදානය 1 ක් වත්, -t 0 ඔබ පයිප්පයකින් හරවා යවන බවට වග බලා ගන්න.

මෙම ක්‍රියාවට නැංවීමේ ඇති හොඳ දෙය නම් ඔබට කැදැලි json අගයන් වෙත ප්‍රවේශ විය හැකි අතර ඒ වෙනුවට json ලබා ගත හැකිය! =)

උදාහරණයක්:

$ echo '{"foo": {"bar": "baz", "a": [1,2,3]}}' |  getJsonVal "['foo']['a'][1]"
2

ඔබට සැබවින්ම විසිතුරු වීමට අවශ්‍ය නම්, ඔබට දත්ත මුද්‍රණය කළ හැකිය:

function getJsonVal () { 
    python -c "import json,sys;sys.stdout.write(json.dumps(json.load(sys.stdin)$1, sort_keys=True, indent=4))"; 
}

$ echo '{"foo": {"bar": "baz", "a": [1,2,3]}}' |  getJsonVal "['foo']"
{
    "a": [
        1, 
        2, 
        3
    ], 
    "bar": "baz"
}

ටික්ටික් යනු JSON විග්‍රහකයකි (<කේත පේළි 250)

කතුවරයාගේ ලිපියේ කුඩා කොටස මෙන්න , බාෂ් JSON ට සහය දක්වන ලෝකයක් ගැන සිතන්න :

#!/bin/bash
. ticktick.sh

``  
  people = { 
    "Writers": [
      "Rod Serling",
      "Charles Beaumont",
      "Richard Matheson"
    ],  
    "Cast": {
      "Rod Serling": { "Episodes": 156 },
      "Martin Landau": { "Episodes": 2 },
      "William Shatner": { "Episodes": 2 } 
    }   
  }   
``  

function printDirectors() {
  echo "  The ``people.Directors.length()`` Directors are:"

  for director in ``people.Directors.items()``; do
    printf "    - %s\n" ${!director}
  done
}   

`` people.Directors = [ "John Brahm", "Douglas Heyes" ] ``
printDirectors

newDirector="Lamont Johnson"
`` people.Directors.push($newDirector) ``
printDirectors

echo "Shifted: "``people.Directors.shift()``
printDirectors

echo "Popped: "``people.Directors.pop()``
printDirectors

ස්වදේශීය බෑෂ් අනුවාදය: බැක්ස්ලෑෂ් (\) සහ මිල ගණන් (") සමඟද හොඳින් ක්‍රියා කරයි

function parse_json()
{
    echo $1 | \
    sed -e 's/[{}]/''/g' | \
    sed -e 's/", "/'\",\"'/g' | \
    sed -e 's/" ,"/'\",\"'/g' | \
    sed -e 's/" , "/'\",\"'/g' | \
    sed -e 's/","/'\"---SEPERATOR---\"'/g' | \
    awk -F=':' -v RS='---SEPERATOR---' "\$1~/\"$2\"/ {print}" | \
    sed -e "s/\"$2\"://" | \
    tr -d "\n\t" | \
    sed -e 's/\\"/"/g' | \
    sed -e 's/\\\\/\\/g' | \
    sed -e 's/^[ \t]*//g' | \
    sed -e 's/^"//'  -e 's/"$//'
}


parse_json '{"username":"john, doe","email":"john@doe.com"}' username
parse_json '{"username":"john doe","email":"john@doe.com"}' email

--- outputs ---

john, doe
johh@doe.com

PHP CLI සමඟ JSON විග්‍රහ කිරීම

මාතෘකාවෙන් බැහැරව ඇති නමුත් ප්‍රමුඛත්වය රජකම් කරන බැවින් අපගේ විශ්වාසවන්ත සහ විශ්වාසවන්ත PHP ගැන සඳහන් නොකර මෙම ප්‍රශ්නය අසම්පූර්ණව පවතී, මම හරිද?

JSON එකම උදාහරණය භාවිතා කරමින් අපැහැදිලි බව අඩු කිරීම සඳහා එය විචල්‍යයකට පැවරීමට ඉඩ දෙයි.

$ export JSON='{"hostname":"test","domainname":"example.com"}'

දැන් PHP යහපත්කම සඳහා, file_get_contents සහ php: // stdin stream wrapper භාවිතා කරන්න.

$ echo $JSON|php -r 'echo json_decode(file_get_contents("php://stdin"))->hostname;'

හෝ භාවිතයෙන් උල් පිටතට ලෙස fgets හා පාබල නියත වන විටත් විවෘත අංශයෙන් STDIN .

$ echo $JSON|php -r 'echo json_decode(fgets(STDIN))->hostname;'

n ජෝයි!

රූබි සහ http://flori.github.com/json/ භාවිතා කරන අනුවාදය

$ < file.json ruby -e "require 'rubygems'; require 'json'; puts JSON.pretty_generate(JSON[STDIN.read]);"

හෝ වඩාත් සංක්ෂිප්තව:

$ < file.json ruby -r rubygems -r json -e "puts JSON.pretty_generate(JSON[STDIN.read]);"

අවාසනාවකට මෙන් ඉහළ භාවිතා, එම පිළිතුර ඡන්දය grepප්රතිලාභ පූර්ණ මගේ තත්වය තුළ වැඩ කටයුතු කළේ නැත එම තරගයේදී, එහෙත් ඔබ දන්නවා නම්, JSON ආකෘතිය ඔබට භාවිතා කළ හැකි නියතව පවතිනු ඇත lookbehind හා lookahead පමණක් අපේක්ෂිත අගයන් ලබා ගැනීම සඳහා.

# echo '{"TotalPages":33,"FooBar":"he\"llo","anotherValue":100}' | grep -Po '(?<="FooBar":")(.*?)(?=",)'
he\"llo
# echo '{"TotalPages":33,"FooBar":"he\"llo","anotherValue":100}' | grep -Po '(?<="TotalPages":)(.*?)(?=,)'
33
#  echo '{"TotalPages":33,"FooBar":"he\"llo","anotherValue":100}' | grep -Po '(?<="anotherValue":)(.*?)(?=})'
100

යමෙකුට කැදැලි ව්‍යුහයන් අවශ්‍ය නොවී සරල JSON වස්තූන්ගෙන් අගයන් උකහා ගැනීමට අවශ්‍ය නම්, කඩාවැටීමකින් තොරව නිත්‍ය ප්‍රකාශන භාවිතා කළ හැකිය.

JSON ප්‍රමිතිය මත පදනම් වූ නිත්‍ය ප්‍රකාශන භාවිතා කරමින් මා විසින් අර්ථ දක්වන ලද ශ්‍රිතයක් මෙන්න :

function json_extract() {
  local key=$1
  local json=$2

  local string_regex='"([^"\]|\\.)*"'
  local number_regex='-?(0|[1-9][0-9]*)(\.[0-9]+)?([eE][+-]?[0-9]+)?'
  local value_regex="${string_regex}|${number_regex}|true|false|null"
  local pair_regex="\"${key}\"[[:space:]]*:[[:space:]]*(${value_regex})"

  if [[ ${json} =~ ${pair_regex} ]]; then
    echo $(sed 's/^"\|"$//g' <<< "${BASH_REMATCH[1]}")
  else
    return 1
  fi
}

Caveats: වස්තු සහ අරා අගය ලෙස සහය නොදක්වයි, නමුත් ප්‍රමිතියේ අර්ථ දක්වා ඇති අනෙකුත් සියලුම අගය වර්ග සඳහා සහය දක්වයි. එසේම, JSON ලේඛනයේ කොතරම් ගැඹුරු වුවත් යුගලයක් ගැලපෙන්නේ හරියටම එකම යතුරු නාමයක් ඇති තාක් කල් ය.

OP ගේ උදාහරණය භාවිතා කිරීම:

$ json_extract text "$(curl 'http://twitter.com/users/username.json')"
My status

$ json_extract friends_count "$(curl 'http://twitter.com/users/username.json')"
245

දැන් පවර්ෂෙල් හරස් වේදිකාවක් බැවින්, මම සිතුවේ එය තරමක් දුරට බුද්ධිමත් හා අතිශය සරල බව මට පෙනී යන හෙයිනි.

curl -s 'https://api.github.com/users/lambda' | ConvertFrom-Json 

ConvertFrom-Json විසින් JSON පවර්ෂෙල් අභිරුචි වස්තුවක් බවට පරිවර්තනය කරයි, එම නිසා ඔබට එම ස්ථානයේ සිට ඉදිරියට ඇති ගුණාංග සමඟ පහසුවෙන් වැඩ කළ හැකිය. ඔබට අවශ්‍ය වූයේ 'හැඳුනුම්පත' දේපල පමණි, ඔබ මෙය කරන්නේ:

curl -s 'https://api.github.com/users/lambda' | ConvertFrom-Json | select -ExpandProperty id

ඔබට බාෂ් තුළ සිට සියල්ලම ආයාචනා කිරීමට අවශ්‍ය නම්, ඔබට එය මේ ආකාරයට හැඳින්විය යුතුය:

powershell 'curl -s "https://api.github.com/users/lambda" | ConvertFrom-Json'

ඇත්ත වශයෙන්ම කරකැවිල්ලකින් තොරව එය කිරීමට පිරිසිදු පවර්ෂෙල් ක්‍රමයක් ඇත, එය වනුයේ:

Invoke-WebRequest 'https://api.github.com/users/lambda' | select -ExpandProperty Content | ConvertFrom-Json

අවසාන වශයෙන්, අභිරුචි වස්තුවක් JSON වෙත පහසුවෙන් පරිවර්තනය කරන 'ConvertTo-Json' ද ඇත. මෙන්න උදාහරණයක්:

(New-Object PsObject -Property @{ Name = "Tester"; SomeList = @('one','two','three')}) | ConvertTo-Json

මේ වගේ ලස්සන JSON නිපදවන:

{
"Name":  "Tester",
"SomeList":  [
                 "one",
                 "two",
                 "three"
             ]

}

යුනික්ස් හි වින්ඩෝස් කවචයක් භාවිතා කිරීම තරමක් පරිශුද්ධ දෙයක් බව පිළිගත යුතුය, නමුත් පවර්ෂෙල් සමහර දේවල ඇත්තෙන්ම හොඳයි, සහ JSON සහ XML විග්‍රහ කිරීම ඒවායින් කිහිපයක්. හරස් වේදිකා අනුවාදය සඳහා මෙය GitHub පිටුව https://github.com/PowerShell/PowerShell

Json නූලකින් දේපලක් ලබා ගැනීමට පහසු ක්‍රමයක් තිබේ. package.jsonඋදාහරණයක් ලෙස ගොනුවක් භාවිතා කරමින් මෙය උත්සාහ කරන්න:

#!/usr/bin/env bash
my_val="$(json=$(<package.json) node -pe "JSON.parse(process.env.json)['version']")"

අප භාවිතා process.envකරන්නේ අනිෂ්ට අන්තර්ගතයන් ඒවායේ උපුටා දැක්වීමෙන් ගැලවී කේතයක් ලෙස විග්‍රහ කිරීමෙන් අනතුරකින් තොරව ගොනුවේ අන්තර්ගතය node.js වෙතට නූලක් ලෙස ලබා ගන්නා බැවිනි.

Xml ලිපිගොනු ඇති අයෙකුට මගේ Xidel දෙස බැලීමට අවශ්‍ය විය හැකිය . එය ක්ලයි , පරායත්තතාවයෙන් තොර JSONiq ය ප්‍රොසෙසරයකි. (එනම් එය xml හෝ json සැකසුම් සඳහා XQuery සඳහා සහය දක්වයි)

ප්‍රශ්නයේ උදාහරණය වනුයේ:

 xidel -e 'json("http://twitter.com/users/username.json")("name")'

හෝ මගේම, සම්මත නොවන දිගු කිරීමේ සින්ටැක්ස් සමඟ:

 xidel -e 'json("http://twitter.com/users/username.json").name'

මට මෙහි කිසිදු පිළිතුරක් භාවිතා කළ නොහැක. ලබා ගත හැකි jq, ෂෙල් අරා නැත, ප්‍රකාශයක් නැත, grep -P, බැලූ බැල්මට සහ බැලූ බැල්මට නැත, පයිතන්, පර්ල් නැත, රූබි නැත, නැත - බාෂ් පවා නැත ... ඉතිරි පිළිතුරු සරලව ක්‍රියා නොකරයි. ජාවාස්ක්‍රිප්ට් හුරුපුරුදු බව පෙනේ, නමුත් ටින් එක පවසන්නේ නෙස්කැෆේ - එබැවින් එය ද යන්නක් නැත :) මගේ සරල අවශ්‍යතාවය සඳහා වුවද - ඒවා අධික ලෙස හා මන්දගාමී වනු ඇත.

එහෙත්, මගේ මොඩමයේ json ආකෘතිගත පිළිතුරෙන් බොහෝ විචල්‍යයන් ලබා ගැනීම මට අතිශයින් වැදගත් ය. මම එය කරන්නේ මගේ රවුටර වලදී ඉතා කාර්යබහුල වූ කාර්යබහුල බොක්ස් ය. අවදිවීම පමණක් භාවිතා කිරීමේ ගැටළු නොමැත: පරිසීමක සකසා දත්ත කියවන්න. තනි විචල්යයක් සඳහා, එපමණයි!

awk 'BEGIN { FS="\""; RS="," }; { if ($2 == "login") {print $4} }' test.json

මට අරා නොමැති බව මතකද? මට ෂෙල් ස්ක්‍රිප්ටයක අවශ්‍ය විචල්‍යයන් 11 ට අවලංගු විග්‍රහ කළ දත්ත ලබා දීමට සිදු විය. මා කොතැනක බැලූවත් එය කළ නොහැකි මෙහෙයුමක් යැයි කියනු ලැබේ. ඒ ගැනත් ප්‍රශ්නයක් නැහැ.

මගේ විසඳුම සරලයි. මෙම කේතය: 1) ප්‍රශ්නයෙන් .json ගොනුව විග්‍රහ කරන්න (ඇත්ත වශයෙන්ම, මම වැඩිපුරම උච්චාරණය කළ පිළිතුරෙන් වැඩ කරන දත්ත නියැදියක් ණයට ගෙන ඇත) සහ උපුටා ගත් දත්ත තෝරාගන්න, ප්ලස් 2) නොමිලේ නම් කරන ලද කවචය ලබා දෙමින් ෂෙල් විචල්‍යයන් නිර්මාණය කරන්න. විචල්ය නම්.

eval $( curl -s 'https://api.github.com/users/lambda' | 
awk ' BEGIN { FS="\""; RS="," };
{
    if ($2 == "login") { print "Login=\""$4"\"" }
    if ($2 == "name") { print "Name=\""$4"\"" }
    if ($2 == "updated_at") { print "Updated=\""$4"\"" }
}' )
echo "$Login, $Name, $Updated"

ඇතුළත හිස් තැන් සමඟ ගැටළු නොමැත. මගේ භාවිතයේදී, එකම විධානය මඟින් දිගු තනි පේළි ප්‍රතිදානයක් විග්‍රහ කරයි. Eval භාවිතා කරන බැවින්, මෙම විසඳුම සුදුසු වන්නේ විශ්වාසදායක දත්ත සඳහා පමණි. පිකප් නොකියවූ දත්ත වලට අනුවර්තනය වීම සරල ය. විශාල විචල්‍යයන් සංඛ්‍යාවක් සඳහා, වෙනත් නම් භාවිතා කර ආන්තික වේග ලාභයක් ලබා ගත හැකිය. අරාව නොමැතිකම පැහැදිලිවම අදහස් කරන්නේ: අමතර විකාරයකින් තොරව බහුවිධ වාර්තා නොමැත. නමුත් අරා ලබා ගත හැකි ස්ථානවල මෙම විසඳුම අනුවර්තනය වීම සරල කාර්යයකි.

ai මයිකල් සෙඩ් පිළිතුර බොහෝ දුරට ක්‍රියාත්මක වේ (නමුත් මට ඒ ගැන අදහස් දැක්විය නොහැක). මගේ මනාව ආකෘතිගත කරන ලද දත්ත සඳහා - එය ක්‍රියාත්මක වේ. මෙහි භාවිතා කර ඇති උදාහරණය සමඟ එතරම් නොවේ (නැතිවූ උපුටා දැක්වීම් එය ඉවත දමයි). එය සංකීර්ණ හා වෙනස් කිරීමට අපහසුය. ප්ලස්, විචල්යයන් 11 ක් උපුටා ගැනීම සඳහා ඇමතුම් 11 ක් කිරීමට මා කැමති නැත. මන්ද? මම විචල්යයන් 9 ක් උපුටා ගන්නා ලූප 100 ක් ගත කළෙමි: sed ශ්‍රිතය තත්පර 48.99 ක් ගත් අතර මගේ විසඳුම තත්පර 0.91 ක් ගතවිය! සාධාරණ නැද්ද? විචල්යයන් 9 ක තනි නිස්සාරණයක් කිරීම: 0.51 එදිරිව තත්පර 0.02.

ඔබට මේ වගේ දෙයක් උත්සාහ කළ හැකිය -

curl -s 'http://twitter.com/users/jaypalsingh.json' | 
awk -F=":" -v RS="," '$1~/"text"/ {print}'

ඔබට භාවිතා කළ හැකිය jshon:

curl 'http://twitter.com/users/username.json' | jshon -e text

ඉතා සරල නමුත් බලවත් JSON CLI සැකසුම් මෙවලමක් ද ඇත fx - https://github.com/antonmedv/fx

උදාහරණ

නිර්නාමික ශ්‍රිතය භාවිතා කරන්න:

$ echo '{"key": "value"}' | fx "x => x.key"
value

ඔබ නිර්නාමික ශ්‍රිතය සමත් නොවන්නේ නම් param => ... කේතය ස්වයංක්‍රීයව නිර්නාමික ශ්‍රිතයක් බවට පරිවර්තනය වේ. මෙම මූල පදය මඟින් ඔබට JSON වෙත ප්‍රවේශය ලබා ගත හැකිය:

$ echo '[1,2,3]' | fx "this.map(x => x * 2)"
[2, 4, 6]

නැතහොත් තිත් සින්ටැක්ස් ද භාවිතා කරන්න:

$ echo '{"items": {"one": 1}}' | fx .items.one
1

JSON අඩු කිරීම සඳහා ඔබට ඕනෑම නිර්නාමික කාර්යයන් සමත් විය හැකිය:

$ echo '{"items": ["one", "two"]}' | fx "this.items" "this[1]"
two

පැතිරීමේ ක්‍රියාකරු භාවිතයෙන් ඔබට දැනට පවතින JSON යාවත්කාලීන කළ හැකිය:

$ echo '{"count": 0}' | fx "{...this, count: 1}"
{"count": 1}

සරල ජාවාස්ක්‍රිප්ට් . නව වාක්‍ය ඛණ්ඩ ඉගෙන ගැනීමට අවශ්‍ය නැත.

යාවත්කාලීන කිරීම 2018-11-06

fxදැන් අන්තර්ක්‍රියාකාරී මාදිලියක් ඇත ( ! )

https://github.com/antonmedv/fx

මෙන්න ඔබට එය අවදි කළ හැකි එක් ක්‍රමයක්

curl -sL 'http://twitter.com/users/username.json' | awk -F"," -v k="text" '{
    gsub(/{|}/,"")
    for(i=1;i<=NF;i++){
        if ( $i ~ k ){
            print $i
        }
    }
}'

වඩාත් සංකීර්ණ JSON විග්‍රහ කිරීම සඳහා මම යෝජනා කරන්නේ පයිතන් jsonpath මොඩියුලය (ස්ටෙෆාන් ගොස්නර් විසිනි) -

1. එය ස්ථාපනය කරන්න -

sudo easy_install -U jsonpath

1. එය භාවිතා කරන්න -

උදාහරණ file.json ( http://goessner.net/articles/JsonPath වෙතින් ) -

{ "store": {
    "book": [ 
      { "category": "reference",
        "author": "Nigel Rees",
        "title": "Sayings of the Century",
        "price": 8.95
      },
      { "category": "fiction",
        "author": "Evelyn Waugh",
        "title": "Sword of Honour",
        "price": 12.99
      },
      { "category": "fiction",
        "author": "Herman Melville",
        "title": "Moby Dick",
        "isbn": "0-553-21311-3",
        "price": 8.99
      },
      { "category": "fiction",
        "author": "J. R. R. Tolkien",
        "title": "The Lord of the Rings",
        "isbn": "0-395-19395-8",
        "price": 22.99
      }
    ],
    "bicycle": {
      "color": "red",
      "price": 19.95
    }
  }
}

එය විග්‍රහ කරන්න (සියලුම පොත් මාතෘකා මිල සමඟ උපුටා ගන්න <10) -

$ cat file.json | python -c "import sys, json, jsonpath; print '\n'.join(jsonpath.jsonpath(json.load(sys.stdin), 'store.book[?(@.price < 10)].title'))"

ප්‍රතිදානය කරයි -

Sayings of the Century
Moby Dick

සටහන: ඉහත විධාන රේඛාවේ දෝෂ පරීක්ෂා කිරීම ඇතුළත් නොවේ. දෝෂ පරීක්ෂාව සමඟ සම්පූර්ණ විසඳුම සඳහා ඔබ කුඩා පයිතන් ස්ක්‍රිප්ට් එකක් සෑදිය යුතු අතර උත්සාහය හැර කේතය ඔතා තිබිය යුතුය.

ඔබට php තිබේ නම් :

php -r 'var_export(json_decode(`curl http://twitter.com/users/username.json`, 1));'

උදාහරණයක් ලෙස:
අපට අයිසෝ කේත සමඟ json සපයන සම්පත් ඇත: http://country.io/iso3.json සහ අපට එය පහසුවෙන් කරකැවිල්ලකින් දැක ගත හැකිය:

curl http://country.io/iso3.json

නමුත් එය එතරම් පහසු නොවන අතර කියවිය නොහැකි, වඩා හොඳ විග්‍රහයක් සහ කියවිය හැකි ව්‍යුහය බලන්න:

php -r 'var_export(json_decode(`curl http://country.io/iso3.json`, 1));'

මෙම කේතය මෙවැනි දෙයක් මුද්‍රණය කරයි:

array (
  'BD' => 'BGD',
  'BE' => 'BEL',
  'BF' => 'BFA',
  'BG' => 'BGR',
  'BA' => 'BIH',
  'BB' => 'BRB',
  'WF' => 'WLF',
  'BL' => 'BLM',
  ...

ඔබ කැදැලි අරා තිබේ නම් මෙම ප්‍රතිදානය වඩා හොඳ වනු ඇත ...

මෙය ප්‍රයෝජනවත් වේ යැයි සිතමු ...

මෙය තවත් bash& pythonදෙමුහුන් පිළිතුරකි. මම මෙම පිළිතුර පළ කළේ මට වඩාත් සංකීර්ණ JSON ප්‍රතිදානය සැකසීමට අවශ්‍ය වූ නිසා, නමුත් මගේ බාෂ් යෙදුමේ සංකීර්ණතාව අඩු කිරීමෙනි. මම සිට පහත සඳහන් JSON වස්තුව විවෘත ඉරිතලා කිරීමට අවශ්ය http://www.arcgis.com/sharing/rest/info?f=json දී bash:

{
  "owningSystemUrl": "http://www.arcgis.com",
  "authInfo": {
    "tokenServicesUrl": "https://www.arcgis.com/sharing/rest/generateToken",
    "isTokenBasedSecurity": true
  }
}

පහත දැක්වෙන උදාහරණයේ දී, මම මගේම ක්‍රියාත්මක කිරීම jqසහ unquoteඋත්තේජනය කිරීම නිර්මාණය කළෙමි python. අපි පයිතන් වස්තුව සිට jsonපයිතන් ශබ්දකෝෂයකට ආනයනය කළ පසු අපට ශබ්ද කෝෂය සැරිසැරීමට පයිතන් සින්ටැක්ස් භාවිතා කළ හැකි බව ඔබ සටහන් කරනු ඇත. ඉහත සැරිසැරීමට, වාක්‍ය ඛණ්ඩය:

• data
• data[ "authInfo" ]
• data[ "authInfo" ][ "tokenServicesUrl" ]

බාෂ් තුළ මැජික් භාවිතා කිරීමෙන්, අපි dataඅතහැර දමා දත්තවල දකුණට පයිතන් පෙළ පමණක් සපයන්නෙමු , එනම්

• jq
• jq '[ "authInfo" ]'
• jq '[ "authInfo" ][ "tokenServicesUrl" ]'

සටහන, කිසිදු පරාමිතියක් නොමැතිව, jqJSON pretifier ලෙස ක්‍රියා කරයි. පරාමිතීන් සමඟ අපට ශබ්දකෝෂයෙන් අවශ්‍ය ඕනෑම දෙයක් උපුටා ගැනීම සඳහා පයිතන් සින්ටැක්ස් භාවිතා කළ හැකිය.

ඉහත දැක්වෙන ක්‍රියාකාරී උදාහරණය මෙන්න:

jq_py() {
cat <<EOF
import json, sys
data = json.load( sys.stdin )
print( json.dumps( data$1, indent = 4 ) )
EOF
}

jq() {
  python -c "$( jq_py "$1" )"
}

unquote_py() {
cat <<EOF
import json,sys
print( json.load( sys.stdin ) )
EOF
}

unquote() {
  python -c "$( unquote_py )"
}

curl http://www.arcgis.com/sharing/rest/info?f=json | tee arcgis.json
# {"owningSystemUrl":"https://www.arcgis.com","authInfo":{"tokenServicesUrl":"https://www.arcgis.com/sharing/rest/generateToken","isTokenBasedSecurity":true}}

cat arcgis.json | jq
# {
#     "owningSystemUrl": "https://www.arcgis.com",
#     "authInfo": {
#         "tokenServicesUrl": "https://www.arcgis.com/sharing/rest/generateToken",
#         "isTokenBasedSecurity": true
#     }
# }

cat arcgis.json | jq '[ "authInfo" ]'
# {
#     "tokenServicesUrl": "https://www.arcgis.com/sharing/rest/generateToken",
#     "isTokenBasedSecurity": true
# }

cat arcgis.json | jq '[ "authInfo" ][ "tokenServicesUrl" ]'
# "https://www.arcgis.com/sharing/rest/generateToken"

cat arcgis.json | jq '[ "authInfo" ][ "tokenServicesUrl" ]' | unquote
# https://www.arcgis.com/sharing/rest/generateToken

මම මෙය කර ඇති අතර, යම් අගයක් සඳහා json ප්‍රතිචාරයක් "විග්‍රහ කිරීම" පහත පරිදි වේ:

curl $url | grep $var | awk '{print $2}' | sed s/\"//g 

පැහැදිලිවම, මෙහි $ url ට්විටර් යූආර්එල් වන අතර, එම var සඳහා ප්‍රතිචාරය ලබා ගැනීම සඳහා text var "පෙළ" වනු ඇත.

ඇත්ත වශයෙන්ම, මම හිතන්නේ මම OP විසින් අතහැර දමා ඇති එකම දෙය නම් ඔහු සොයන නිශ්චිත විචල්‍යය සමඟ රේඛාව සඳහා grep කිරීමයි. අව්ක් පේළියේ දෙවන අයිතමය අල්ලා ගන්නා අතර, සෙඩ් සමඟ මම උපුටා දැක්වීම් ඉවත් කරමි.

මට වඩා බුද්ධිමත් කෙනෙකුට මුළු සිතීමම අවුල් සහගතව කළ හැකිය.

දැන්, ඔබට එය සියල්ලම කළ හැකිය:

curl $url | sed '/text/!d' | sed s/\"text\"://g | sed s/\"//g | sed s/\ //g

මේ නිසා, අවුලක් නැත, ග්‍රහණයක් නැත ... මම මීට පෙර ඒ ගැන නොසිතුවේ මන්දැයි මම නොදනිමි. හ්ම් ...

JSON විග්‍රහ කිරීම ෂෙල් පිටපතක වේදනාකාරී වේ. වඩාත් සුදුසු භාෂාවක් සමඟ, ෂෙල් ස්ක්‍රිප්ටින් සම්මුතීන්ට අනුකූල වන පරිදි JSON ගුණාංග උපුටා ගන්නා මෙවලමක් සාදන්න. ක්ෂණික ෂෙල් ස්ක්‍රිප්ටින් ගැටළුව විසඳීමට ඔබට ඔබගේ නව මෙවලම භාවිතා කළ හැකි අතර අනාගත තත්වයන් සඳහා එය ඔබගේ කට්ටලයට එක් කරන්න.

නිදසුනක් ලෙස, jsonlookup මෙවලමක් සලකා බලන්න, jsonlookup access token idඑය මා කියන්නේ නම්, එය stdin වෙතින් ආරෝපණ ප්‍රවේශය තුළ අර්ථ දක්වා ඇති ගුණාංග ටෝකනය තුළ අර්ථ දක්වා ඇති ගුණාංග හැඳුනුම්පත නැවත ලබා දෙනු ඇත , එය අනුමාන වශයෙන් JSON දත්ත වේ. ගුණාංගය නොපවතී නම්, මෙවලම කිසිවක් ලබා නොදේ (තත්වය 1 පිටවීම). විග්‍රහ කිරීම අසමත් වුවහොත්, තත්වය 2 පිටවීම සහ stderr වෙත පණිවිඩයක්. බැලීම සාර්ථක වුවහොත්, මෙවලම ගුණාංගයේ අගය මුද්‍රණය කරයි.

JSON අගයන් උකහා ගැනීමේ නිශ්චිත අරමුණ සඳහා යුනික්ස් මෙවලමක් නිර්මාණය කිරීමෙන් ඔබට එය පහසුවෙන් ෂෙල් ස්ක්‍රිප්ට් වලින් භාවිතා කළ හැකිය:

access_token=$(curl <some horrible crap> | jsonlookup access token id)

ඕනෑම භාෂාවක් jsonlookup ක්‍රියාත්මක කිරීම සඳහා කරනු ඇත. මෙන්න තරමක් සංක්ෂිප්ත පයිතන් අනුවාදයක්:

#!/usr/bin/python                                                               

import sys
import json

try: rep = json.loads(sys.stdin.read())
except:
    sys.stderr.write(sys.argv[0] + ": unable to parse JSON from stdin\n")
    sys.exit(2)
for key in sys.argv[1:]:
    if key not in rep:
        sys.exit(1)
    rep = rep[key]
print rep

පයිතන් භාවිතා කරන ලයිනර් දෙකකි. ඔබ තනි .sh ගොනුවක් ලියන්නේ නම් සහ වෙනත් .py ගොනුවක් මත යැපීමට ඔබට අවශ්‍ය නැතිනම් එය විශේෂයෙන් හොඳින් ක්‍රියාත්මක වේ. එමඟින් නල භාවිතය ද උත්තේජනය කරයි |. echo "{\"field\": \"value\"}"stsout වෙත json මුද්‍රණය කරන ඕනෑම දෙයක් මගින් ප්‍රතිස්ථාපනය කළ හැකිය.

echo "{\"field\": \"value\"}" | python -c 'import sys, json
print(json.load(sys.stdin)["field"])'

පයිතන්පි සඳහා මෙය හොඳ භාවිත කට්ටලයක් :

curl 'http://twitter.com/users/username.json' | py 'json.load(sys.stdin)["name"]'