jshon - ക്ലൗഡിൽ ഓൺലൈനിൽ

പട്ടിക:

NAME

jshon - ഷെല്ലിനുള്ള JSON പാഴ്സർ

സിനോപ്സിസ്

jshon -[P|S|Q|V|C|I|0] [-F പാത്ത്] -[t|l|k|u|p|a] -[s|n] മൂല്യം -[e|i|d] സൂചിക

വിവരണം

jshon JSON പാഴ്‌സ് ചെയ്യുകയും വായിക്കുകയും സൃഷ്‌ടിക്കുകയും ചെയ്യുന്നു. പരമാവധി ഉപയോഗിക്കാവുന്ന തരത്തിലാണ് ഇത് രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്
ഷെല്ലിനുള്ളിൽ, grep/sed/awk എന്നിവയിൽ നിന്നും നിർമ്മിച്ച ദുർബലമായ adhoc പാർസറുകൾ മാറ്റിസ്ഥാപിക്കുന്നു.
പെർൽ/പൈത്തണിൽ നിന്ന് നിർമ്മിച്ച ഹെവിവെയ്റ്റ് വൺ-ലൈൻ പാർസറുകൾ.

jshon stdin-ൽ നിന്ന് json ടെക്സ്റ്റ് ലോഡ് ചെയ്യുന്നു, പ്രവർത്തനങ്ങൾ ചെയ്യുന്നു, തുടർന്ന് stdout-ൽ അവസാന പ്രവർത്തനം പ്രദർശിപ്പിക്കുന്നു.
ചില ഓപ്ഷനുകൾ json ഔട്ട്പുട്ട് ചെയ്യുന്നു, മറ്റുള്ളവ പ്ലെയിൻ ടെക്സ്റ്റ് സംഗ്രഹങ്ങൾ ഔട്ട്പുട്ട് ചെയ്യുന്നു. കാരണം ബാഷിന് വളരെ ഉണ്ട്
മോശം നെസ്റ്റഡ് ഡാറ്റാസ്ട്രക്ചറുകൾ, jshon ഒരു നേറ്റീവ് ഒബ്‌ജക്റ്റായി JSON-നെ സാധാരണ പോലെ തിരികെ നൽകുന്നില്ല
ലൈബ്രറി ചെയ്യും. പകരം jshon എഡിറ്റുകളുടെ ചരിത്രം ഒരു സ്റ്റാക്കിൽ സൂക്ഷിക്കുന്നു, നിങ്ങൾ കൈകാര്യം ചെയ്യുന്നു
ഏറ്റവും ഉയർന്ന JSON ഘടകം.

പ്രവർത്തനങ്ങൾ

ഓരോ പ്രവർത്തനവും ഒരു ഹ്രസ്വ ഓപ്ഷന്റെ രൂപമെടുക്കുന്നു. ചിലർക്ക് വാദങ്ങൾ ആവശ്യമാണ്. പല സന്ദർഭങ്ങളിലും
of jshon പരസ്പരം പൈപ്പ് ചെയ്യാൻ കഴിയും, പ്രവർത്തനങ്ങൾ കുറയ്ക്കുന്നതിന് തുടർച്ചയായി ചങ്ങലയിലായിരിക്കണം
വിളിക്കുന്നു. എല്ലാ ഉദാഹരണങ്ങളും ഈ json സാമ്പിൾ ഉപയോഗിക്കുന്നു:

{"a":1,"b":[true,false,null,"str"],"c":{"d":4,"e":5}}
jshon [പ്രവർത്തനങ്ങൾ] < sample.json

ഏറ്റവും സാധാരണമായ വായന-മാത്രം ഉപയോഗത്തിന് കുറച്ച് മാത്രമേ ആവശ്യമുള്ളൂ -e പ്രവർത്തനങ്ങളും ഒന്ന് -a നടുവിൽ
അവരെ.

-t (തരം) സ്ട്രിംഗ്, ഒബ്‌ജക്റ്റ്, അറേ, നമ്പർ, ബൂൾ, നൾ എന്നിവ നൽകുന്നു

jshon -t -> ഒബ്ജക്റ്റ്

-l (നീളം) ഒരു പൂർണ്ണസംഖ്യ നൽകുന്നു. സ്ട്രിംഗ്, ഒബ്‌ജക്റ്റ്, അറേ എന്നിവയിൽ മാത്രം പ്രവർത്തിക്കുന്നു.

jshon -l -> 3

-k (കീകൾ) ഒരു പുതിയ വരിയിൽ വേർതിരിച്ച കീകളുടെ ലിസ്റ്റ് നൽകുന്നു. വസ്തുവിൽ മാത്രം പ്രവർത്തിക്കുന്നു.

jshon -k -> abc

-e സൂചിക
(എക്‌സ്‌ട്രാക്റ്റ്) "ഇൻഡക്‌സിൽ" json മൂല്യം നൽകുന്നു. ഒബ്‌ജക്റ്റ്, അറേ എന്നിവയിൽ മാത്രമേ പ്രവർത്തിക്കൂ. ഒരു സൂചിക
അറേ ഒരു പൂർണ്ണസംഖ്യയാണ്.

jshon -ec -> {"d":4,"e":5}

-a (മുഴുവൻ) തിരഞ്ഞെടുത്ത ഘടകത്തിലുടനീളം ശേഷിക്കുന്ന പ്രവർത്തനങ്ങൾ മാപ്പ് ചെയ്യുന്നു. വസ്തുക്കളിൽ മാത്രം പ്രവർത്തിക്കുന്നു
അറേകളും. ഒന്നിലധികം -a പ്രയോഗത്തിൽ ആവശ്യം വിരളമാണെങ്കിലും കോളുകൾ നെസ്റ്റഡ് ചെയ്യാം.

jshon -eb -a -t -> bool bool null string

-s മൂല്യം
(സ്ട്രിംഗ്) ഒരു json എൻകോഡ് ചെയ്ത സ്ട്രിംഗ് നൽകുന്നു. പിന്നീട് നിലവിലുള്ളതിലേക്ക് (-i) ചേർക്കാം
ഘടന

jshon -s "back\slash" -> "back\\slash"

-n മൂല്യം
(നോൺസ്ട്രിംഗ്/നമ്പർ) ഒരു json ഘടകം നൽകുന്നു. പിന്നീട് നിലവിലുള്ളതിലേക്ക് (-i) ചേർക്കാം
ഘടന. 'ശരി', 'തെറ്റ്', 'ശൂന്യം', 'അറേ', 'വസ്തു', പൂർണ്ണസംഖ്യകൾ എന്നിവയാണ് സാധുവായ മൂല്യങ്ങൾ
ഫ്ലോട്ടുകൾ. യഥാക്രമം t, f, n, [], {} എന്നീ ചുരുക്കെഴുത്തുകളും പ്രവർത്തിക്കുന്നു.

jshon -n ഒബ്‌ജക്റ്റ് -> {}

-u (അൺസ്ട്രിംഗ്) ഒരു ഡീകോഡ് ചെയ്ത സ്ട്രിംഗ് നൽകുന്നു. ലളിതമായ തരങ്ങളിൽ മാത്രം പ്രവർത്തിക്കുന്നു: സ്ട്രിംഗ്, ഇൻറ്റ്, റിയൽ,
ബൂളിയൻ, ശൂന്യം.

jshon -eb -e 3 -u -> str

-p (pop) ചരിത്രത്തെ റിവൈൻഡ് ചെയ്തുകൊണ്ട് സ്റ്റാക്കിൽ നിന്നുള്ള അവസാന കൃത്രിമത്വം പോപ്പ് ചെയ്യുന്നു. വേണ്ടി ഉപയോഗപ്രദമാണ്
ഒരു വസ്തുവിൽ നിന്ന് ഒന്നിലധികം മൂല്യങ്ങൾ വേർതിരിച്ചെടുക്കുന്നു.

jshon -ec -ed -u -p -ee -u -> 4 5

-d സൂചിക
(ഇല്ലാതാക്കുക) ഒരു അറേയിലോ ഒബ്‌ജക്റ്റിലോ ഉള്ള ഒരു ഇനം നീക്കംചെയ്യുന്നു. നെഗറ്റീവ് അറേ സൂചികകൾ പൊതിയുന്നു
ചുറ്റും.

jshon -db -> {"a":1,"c":{"d":4,"e":5}}

-i സൂചിക
(ഇൻസേർട്ട്) സങ്കീർണ്ണമാണ്. ഇത് എക്സ്ട്രാക്റ്റിന്റെ വിപരീതമാണ്. എക്സ്ട്രാക്റ്റ് ഒരു json ഉപ-ഘടകം ഇടുന്നു
സ്റ്റാക്കിൽ. Insert സ്റ്റാക്കിൽ നിന്ന് ഒരു ഉപഘടകം നീക്കം ചെയ്യുകയും json ന്റെ ആ ബിറ്റ് ചേർക്കുകയും ചെയ്യുന്നു
താഴെയുള്ള വലിയ അറേ/ഒബ്ജക്റ്റിലേക്ക്. json മരത്തിൽ മുങ്ങാൻ എക്സ്ട്രാക്റ്റ് ഉപയോഗിക്കുക,
കാര്യങ്ങൾ മാറ്റാൻ ഡിലീറ്റ്/സ്ട്രിംഗ്/നോൺസ്‌ട്രിംഗ്, മാറ്റങ്ങളെ അതിലേക്ക് തിരികെ കൊണ്ടുവരാൻ തിരുകുക
വൃക്ഷം.

jshon -ea -ia -> യഥാർത്ഥ json
jshon -s one -ia -> {"a":"one", ...}

അറേകൾ ഒരു പ്രത്യേക രീതിയിലാണ് കൈകാര്യം ചെയ്യുന്നത്. പൂർണ്ണസംഖ്യകൾ കടന്നുപോകുന്നത് ഇല്ലാതെ ഒരു മൂല്യം ചേർക്കും
തിരുത്തിയെഴുതുന്നു. 'അനുബന്ധം' എന്ന സ്ട്രിംഗ് പോലെ നെഗറ്റീവ് പൂർണ്ണസംഖ്യകൾ സ്വീകാര്യമാണ്. തിരുത്തിയെഴുതാൻ
ഒരു ശ്രേണിയിലെ ഒരു മൂല്യം: സൂചിക ഇല്ലാതാക്കുക, -എൻ. എസ് പുതിയ മൂല്യം, തുടർന്ന് സൂചികയിൽ ചേർക്കുക.

jshon -eb -d 0 -sq -i 0 -> {"b":"q",false,null,"str"}

നോൺ-മാനിപുലേഷൻ

json നേരിട്ട് എഡിറ്റ് ചെയ്യാത്ത നിരവധി മെറ്റാ ഓപ്‌ഷനുകൾ ഉണ്ട്. ഓരോ തവണയെങ്കിലും ഇവയെ വിളിക്കൂ
അഭ്യർത്ഥന.

-F
(ഫയൽ) stdin-ന് പകരം ഒരു ഫയലിൽ നിന്ന് വായിക്കുന്നു. എടുക്കാനുള്ള ഒരേയൊരു നോൺ-മാനിപുലേഷൻ ഓപ്ഷൻ
വാദം.

-P (jsonp) സാധാരണ തുടരുന്നതിന് മുമ്പ് ഒരു jsonp കോൾബാക്ക് സ്ട്രിപ്പ് ചെയ്യുന്നു.

-S (അടുക്കുക) യഥാർത്ഥ ഓർഡറിംഗിന് പകരം കീ ഉപയോഗിച്ച് അടുക്കിയ json നൽകുന്നു.

-Q (ശാന്തം) stderr-ൽ പിശക് റിപ്പോർട്ടുചെയ്യൽ പ്രവർത്തനരഹിതമാക്കുന്നു, അതിനാൽ നിങ്ങൾ "2> /dev/null" തളിക്കേണ്ടതില്ല
നിങ്ങളുടെ സ്ക്രിപ്റ്റിലുടനീളം.

-V (ബൈ-വാല്യൂ) എഡിറ്റ് ഹിസ്റ്ററി സ്റ്റാക്കിൽ പാസ്-ബൈ-വാല്യൂ പ്രാപ്തമാക്കുന്നു. അങ്ങേയറ്റത്തെ കേസുകളിൽ
ആയിരക്കണക്കിന് ആഴത്തിലുള്ള മൂല്യങ്ങൾ ഇത് കാരണമായേക്കാം jshon പല തവണ പതുക്കെ ഓടുന്നു
പല മടങ്ങ് കൂടുതൽ മെമ്മറി ഉപയോഗിക്കുമ്പോൾ. എന്നിരുന്നാലും, ബൈ-റഫറൻസ് എന്നതിനേക്കാൾ ബൈ-വാല്യൂ സുരക്ഷിതമാണ്
പൊതുവെ ആശ്ചര്യം കുറയ്ക്കുന്നു. ബൈ-റഫറൻസ് ഇല്ലാത്തതിനാൽ ഡിഫോൾട്ടായി പ്രവർത്തനക്ഷമമാക്കിയിരിക്കുന്നു
റീഡ്-ഒൺലി ഓപ്പറേഷനുകൾക്കിടയിലുള്ള അപകടസാധ്യത, സാധാരണയായി json എഡിറ്റിംഗ് കൂടുതൽ സൗകര്യപ്രദമാക്കുന്നു.

jshon -ec -n 7 -id -p -> c["d"] == 7
jshon -V -ec -n 7 -id -p -> c["d"] == 5
jshon -V -ec -n 7 -id -ic -> c["d"] == 7

കൂടെ -V , മാറ്റങ്ങൾ ലളിതമായി പകരം സ്റ്റാക്കിലൂടെ തിരികെ സ്വമേധയാ ചേർക്കണം
ഇന്റർമീഡിയറ്റ് മൂല്യങ്ങൾ പോപ്പിംഗ് ഓഫ്.

-C വീണ്ടെടുക്കാൻ സാധ്യതയുള്ള പിശകുകളിൽ (തുടരുക). ഉദാഹരണത്തിന്, ഇല്ലാത്ത മൂല്യങ്ങൾ വേർതിരിച്ചെടുക്കൽ
നിലവിലുള്ളത് നിർത്തലാക്കുന്നതിന് പകരം എഡിറ്റ് സ്റ്റാക്കിലേക്ക് 'null' ചേർക്കും. പെരുമാറ്റത്തിൽ മാറ്റം വരാം
ഭാവി.

-I (സ്ഥലത്ത്) ഫയൽ എഡിറ്റിംഗ്. പരിഷ്‌ക്കരിക്കുന്നതിന് ഒരു ഫയൽ ആവശ്യമാണ്, അതിനാൽ -F-ൽ മാത്രം പ്രവർത്തിക്കുന്നു. ഇതാണ്
ഒരു json ഫയലിൽ ചെറിയ മാറ്റങ്ങൾ വരുത്താൻ ഉദ്ദേശിച്ചുള്ളതാണ്. ഉപയോഗിക്കുമ്പോൾ, സാധാരണ ഔട്ട്പുട്ട് അടിച്ചമർത്തപ്പെടും
കൂടാതെ എഡിറ്റ് സ്റ്റാക്കിന്റെ അടിഭാഗം എഴുതിയിരിക്കുന്നു.

-0 (null delimiters) -u യുടെ ഡിലിമിറ്റർ ഒരു ന്യൂലൈനിൽ നിന്ന് null ആയി മാറ്റുന്നു. ഈ ഓപ്ഷൻ
-u-യെ മാത്രമേ ബാധിക്കുകയുള്ളൂ, കാരണം ഒരു പുതിയ ലൈൻ നിയമാനുസൃതമായി ദൃശ്യമാകുന്ന ഒരേയൊരു സമയമാണിത്
.ട്ട്‌പുട്ട്.

--പതിപ്പ്
ഒരു YYYYMMDD ടൈംസ്റ്റാമ്പ് നൽകി പുറത്തുകടക്കുന്നു.

മറ്റുള്ളവ ടൂളുകൾ

jshon എല്ലായ്‌പ്പോഴും ഒരു വരിയിൽ ഒരു ഫീൽഡ് ഔട്ട്‌പുട്ട് ചെയ്യുന്നു. പല യുണിക്സ് ടൂളുകളും ഒന്നിലധികം ടാബുകൾ വേർതിരിക്കുമെന്ന് പ്രതീക്ഷിക്കുന്നു
ഓരോ വരിയിലും ഫീൽഡുകൾ. ഇത് പരിഹരിക്കാൻ 'പേസ്റ്റ്' വഴി ഔട്ട്പുട്ട് പൈപ്പ് ചെയ്യുക. എന്നിരുന്നാലും, ഒട്ടിക്കാൻ കഴിയില്ല
ശൂന്യമായ വരികൾ കൈകാര്യം ചെയ്യുക, അങ്ങനെ ഒരു പ്ലെയ്‌സ്‌ഹോൾഡർ ഉള്ളവ പാഡ് ചെയ്യുക. ഒരു ഉദാഹരണം ഇതാ:

jshon ... | സെഡ് 's/^$/-/' | പേസ്റ്റ് -s -d '\t\t\n'

ഇത് ശൂന്യതയെ '-' ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുകയും ഓരോ മൂന്ന് വരികളും ഒന്നായി ലയിപ്പിക്കുകയും ചെയ്യുന്നു.

json ഔട്ട്‌പുട്ട് ഉൽപ്പാദിപ്പിക്കുന്ന കൂടുതൽ കൂടുതൽ ടൂളുകൾ ഉണ്ട്. പലപ്പോഴും ഇവ ഒരു ലൈൻ-ഓറിയന്റഡ് ഉപയോഗിക്കുന്നു
json/plaintext ഹൈബ്രിഡ്, ഓരോ വരിയും ഒരു സ്വതന്ത്ര json ഘടനയാണ്. ഖേദകരമെന്നു പറയട്ടെ
ഔട്ട്പുട്ട് മൊത്തത്തിൽ നിയമാനുസൃതമായ json അല്ല. ഒന്നുകിൽ ഡാറ്റ വരി വരിയായി ലൂപ്പ് ചെയ്യുക
(വിളിക്കുന്നു jshon ഓരോ ലൈനിനും ഒരിക്കൽ) അല്ലെങ്കിൽ ഒരു നിയമാനുസൃത json അറേയിലേക്ക് പരിവർത്തനം ചെയ്യുക. ഉദാഹരണത്തിന്:

വരി വായിക്കുമ്പോൾ; do jshon <<< "$line"; ചെയ്തു < <(journalctl -o json)

journalctl -o json | sed -e '1i[' -e '$!s/$/,/' -e '$a]' | jshon

ഗോൾഫ്

നിങ്ങൾ വളരെ ഹ്രസ്വമായ വൺ ലൈനറുകളിൽ ശ്രദ്ധാലുവാണെങ്കിൽ, വാദങ്ങൾ അങ്ങനെയല്ലെങ്കിൽ ഘനീഭവിപ്പിക്കാം
അവ്യക്തത ഉണ്ടാക്കുന്നു. നിന്നുള്ള ഉദാഹരണം -p(op) ഇനിപ്പറയുന്ന രീതിയിൽ ഗോൾഫ് ചെയ്യാൻ കഴിയും:

jshon -ec -ed -u -p -ee -u == jshon -ec -ed -upee -u

ഇത് ചെയ്യാൻ ഞാൻ ശുപാർശ ചെയ്യുന്നില്ല (ഇത് കാര്യങ്ങൾ മനസ്സിലാക്കാൻ വളരെ ബുദ്ധിമുട്ടാണ്) എന്നാൽ ചില ആളുകൾ
അനന്തരഫലങ്ങൾക്കിടയിലും ഗോൾഫ്.

ഉണ്ടാക്കുന്നു JSON

jshon ഒരു ശൂന്യമായ ഒബ്‌ജക്‌റ്റ് ഇൻപുട്ടായി നൽകിക്കൊണ്ട് json സൃഷ്‌ടിക്കാൻ കഴിയും:

jshon -s one -ia <<< "{}"

AUTHORS

jshon കെയ്ൽ കീൻ എഴുതിയത്[ഇമെയിൽ പരിരക്ഷിച്ചിരിക്കുന്നു]> ഡേവ് റെയ്സ്നറിൽ നിന്നുള്ള പാച്ചുകൾക്കൊപ്പം
<[ഇമെയിൽ പരിരക്ഷിച്ചിരിക്കുന്നു]>, ആൻഡ്രൂഎഫ് (BSD, OSX, jsonp, സോർട്ടിംഗ്), ജീൻ മാർക്ക് എ (സോളാരിസ്).

onworks.net സേവനങ്ങൾ ഉപയോഗിച്ച് jshon ഓൺലൈനായി ഉപയോഗിക്കുക