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 parses, ອ່ານ ແລະສ້າງ JSON. ມັນໄດ້ຖືກອອກແບບເພື່ອໃຫ້ເປັນການນໍາໃຊ້ທີ່ເປັນໄປໄດ້ຈາກ
ພາຍໃນແກະແລະແທນທີ່ຕົວແຍກ adhoc ທີ່ອ່ອນແອທີ່ເຮັດຈາກ grep/sed/awk ເຊັ່ນດຽວກັນກັບ
ຕົວວິເຄາະແຖວໜຶ່ງທີ່ມີນ້ຳໜັກໜັກທີ່ເຮັດມາຈາກ perl/python.

jshon ໂຫຼດຂໍ້ຄວາມ json ຈາກ stdin, ດໍາເນີນການ, ຫຼັງຈາກນັ້ນສະແດງການປະຕິບັດສຸດທ້າຍໃນ stdout.
ບາງທາງເລືອກອອກ json, ທາງເລືອກອື່ນສົ່ງຜົນສະຫຼຸບຂໍ້ຄວາມທໍາມະດາ. ເນື່ອງຈາກວ່າ Bash ມີຫຼາຍ
ໂຄງ​ສ້າງ​ຂໍ້​ມູນ​ທີ່​ບໍ່​ດີ​, jshon ບໍ່ໄດ້ສົ່ງຄືນ JSON ເປັນວັດຖຸພື້ນເມືອງຕາມປົກກະຕິ
ຫ້ອງສະຫມຸດຈະ. ແທນ jshon ຮັກສາປະຫວັດການແກ້ໄຂໃນ stack ເປັນ, ແລະທ່ານ manipulate ໄດ້
ອົງປະກອບ JSON ເທິງສຸດ.

ກິດຈະກໍາ

ແຕ່ລະການປະຕິບັດໃຊ້ເວລາຮູບແບບຂອງທາງເລືອກສັ້ນ. ບາງຄົນຮຽກຮ້ອງໃຫ້ມີການໂຕ້ຖຽງ. ໃນຂະນະທີ່ຫຼາຍຕົວຢ່າງ
of jshon ສາມາດທໍ່ຜ່ານກັນແລະກັນ, ການປະຕິບັດຄວນຈະຖືກຕ່ອງໂສ້ຕາມລໍາດັບເພື່ອຫຼຸດຜ່ອນ
ໂທ. ຕົວຢ່າງທັງໝົດໃຊ້ຕົວຢ່າງ json ນີ້:

{"a":1,"b":[true,false,null,"str"],"c":{"d":4,"e":5}}
jshon [ການປະຕິບັດ] < sample.json

ການນໍາໃຊ້ແບບອ່ານພຽງແຕ່ທົ່ວໄປສ່ວນໃຫຍ່ຈະຕ້ອງການພຽງແຕ່ຫຼາຍໆອັນ -e ການ​ກະ​ທໍາ​ແລະ​ຫນຶ່ງ​ -a ຢູ່ເຄິ່ງກາງຂອງ
ໃຫ້ເຂົາເຈົ້າ.

-t (type) ສົ່ງຄ່າ string, object, array, number, bool, null

jshon -t -> ວັດຖຸ

-l (ຄວາມຍາວ) ຕອບຄ່າຈຳນວນເຕັມ. ເຮັດວຽກພຽງແຕ່ກ່ຽວກັບ string, object, array.

jshon -l -> 3

-k (keys) ສົ່ງຄືນລາຍຊື່ກະແຈທີ່ແຍກອອກແຖວໃໝ່. ພຽງແຕ່ເຮັດວຽກຢູ່ໃນວັດຖຸ.

jshon -k -> abc

-e ດັດຊະນີ
(extract) ສົ່ງຄືນຄ່າ json ຢູ່ "index". ພຽງແຕ່ເຮັດວຽກກ່ຽວກັບວັດຖຸ, array. ດັດຊະນີຂອງ an
array ເປັນຈຳນວນເຕັມ.

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

-a (ຂ້າມ) ແຜນທີ່ການດໍາເນີນການທີ່ຍັງເຫຼືອໃນທົ່ວອົງປະກອບທີ່ເລືອກ. ພຽງແຕ່ເຮັດວຽກກ່ຽວກັບວັດຖຸ
ແລະ arrays. ຫຼາຍ -a ການໂທສາມາດຖືກວາງໄວ້, ເຖິງແມ່ນວ່າຄວາມຕ້ອງການແມ່ນຫາຍາກໃນການປະຕິບັດ.

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

-s ມູນຄ່າ
(string) ສົ່ງຄືນສະຕຣິງທີ່ເຂົ້າລະຫັດ json. ຕໍ່ມາສາມາດຖືກ (-i)ໃສ່ກັບທີ່ມີຢູ່ແລ້ວ
ໂຄງສ້າງ.

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

-n ມູນຄ່າ
(nonstring/number) ສົ່ງຄືນອົງປະກອບ json. ຕໍ່ມາສາມາດຖືກ (-i)ໃສ່ກັບທີ່ມີຢູ່ແລ້ວ
ໂຄງສ້າງ. ຄ່າທີ່ຖືກຕ້ອງແມ່ນ 'true', 'false', 'null', 'array', 'object', integers ແລະ
ລອຍ. ຕົວຫຍໍ້ t, f, n, [] ແລະ {} ຕາມລໍາດັບຍັງເຮັດວຽກ.

jshon -n object -> {}

-u (unstring) ຕອບສະຕຣິງທີ່ຖອດລະຫັດແລ້ວ. ເຮັດວຽກພຽງແຕ່ປະເພດງ່າຍດາຍ: string, int, real,
ບູລີນ, null.

jshon -eb -e 3 -u -> str

-p (ປັອບ) ປະກົດການຫມູນໃຊ້ຄັ້ງສຸດທ້າຍຈາກ stack, rewinding ປະຫວັດສາດ. ທີ່ເປັນປະໂຫຍດສໍາລັບ
ສະກັດຄ່າຫຼາຍຈາກວັດຖຸອັນດຽວ.

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

-d ດັດຊະນີ
(ລຶບ) ເອົາລາຍການໃນອາເຣ ຫຼືວັດຖຸ. ດັດຊະນີ array ລົບຈະຫໍ່
ປະມານ.

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

-i ດັດຊະນີ
(ໃສ່) ແມ່ນສັບສົນ. ມັນເປັນການປີ້ນກັບກັນຂອງສານສະກັດຈາກ. Extract ໃສ່ອົງປະກອບຍ່ອຍ json
ສຸດ stack ໄດ້. Insert ເອົາອົງປະກອບຍ່ອຍອອກຈາກ stack, ແລະໃສ່ bit ຂອງ json
ເຂົ້າໄປໃນ array / object ທີ່ໃຫຍ່ກວ່າຢູ່ຂ້າງລຸ່ມ. ໃຊ້ສານສະກັດເພື່ອເຂົ້າໄປໃນຕົ້ນໄມ້ json,
ລຶບ/string/nonstring ເພື່ອປ່ຽນສິ່ງຕ່າງໆ, ແລະໃສ່ເພື່ອຍູ້ການປ່ຽນແປງກັບໄປໃສ່ໃນ
ຕົ້ນໄມ້.

jshon -ea -ia -> json ຕົ້ນສະບັບ
jshon -s one -ia -> {"a":"one", ...}

Arrays ຖືກຈັດການດ້ວຍລັກສະນະພິເສດ. ຈຳນວນເຕັມທີ່ຜ່ານຈະໃສ່ຄ່າທີ່ບໍ່ມີ
ການຂຽນທັບ. ຈຳນວນເຕັມລົບແມ່ນຍອມຮັບໄດ້, ຄືກັບສະຕຣິງ 'ຕໍ່ທ້າຍ'. ເພື່ອຂຽນທັບ
ຄ່າໃນ array: ລຶບດັດຊະນີ, -n/s ຄ່າໃຫມ່, ແລະຫຼັງຈາກນັ້ນໃສ່ໃນດັດຊະນີ.

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

ບໍ່ແມ່ນການຈັດການ

ມີຫລາຍທາງເລືອກ meta ທີ່ບໍ່ໄດ້ແກ້ໄຂ json ໂດຍກົງ. ໂທຫາເຫຼົ່ານີ້ຫຼາຍທີ່ສຸດຫນຶ່ງຄັ້ງຕໍ່
ຄຳຮຽກຮ້ອງ.

-F
(file) ອ່ານຈາກໄຟລ໌ແທນ stdin. ທາງ​ເລືອກ​ທີ່​ບໍ່​ແມ່ນ​ການ​ຫມູນ​ໃຊ້​ພຽງ​ແຕ່​ທີ່​ຈະ​ເປັນ​
ການໂຕ້ຖຽງ.

-P (jsonp) ລອກເອົາ jsonp callback ກ່ອນທີ່ຈະສືບຕໍ່ຕາມປົກກະຕິ.

-S (sort) ສົ່ງຄືນ json ຈັດຮຽງຕາມລະຫັດ, ແທນທີ່ຈະເປັນຄໍາສັ່ງຕົ້ນສະບັບ.

-Q (ງຽບ) ປິດການລາຍງານຄວາມຜິດພາດໃນ stderr, ດັ່ງນັ້ນທ່ານບໍ່ຈໍາເປັນຕ້ອງ sprinkle "2> /dev/null"
ຕະຫຼອດ script ຂອງທ່ານ.

-V (by-value) ເປີດໃຊ້ pass-by-value ໃນ stack ປະຫວັດການແກ້ໄຂ. ໃນກໍລະນີທີ່ຮ້າຍແຮງກັບ
ຫລາຍພັນຄ່າທີ່ຝັງເລິກອັນນີ້ອາດຈະສົ່ງຜົນໃຫ້ 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 , ການປ່ຽນແປງຕ້ອງໄດ້ຮັບການໃສ່ດ້ວຍຕົນເອງກັບຄືນໄປບ່ອນໂດຍຜ່ານ stack ແທນທີ່ຈະງ່າຍດາຍ
popping off ຄ່າລະດັບປານກາງ.

-C (ສືບຕໍ່) ກ່ຽວກັບຄວາມຜິດພາດທີ່ອາດຈະສາມາດຟື້ນຕົວໄດ້. ຕົວຢ່າງ, ການສະກັດເອົາຄ່າທີ່ບໍ່ມີ
ທີ່ມີຢູ່ແລ້ວຈະເພີ່ມ 'null' ໃສ່ stack ການແກ້ໄຂແທນທີ່ຈະຍົກເລີກ. ພຶດ​ຕິ​ກໍາ​ອາດ​ຈະ​ມີ​ການ​ປ່ຽນ​ແປງ​ໃນ​
ໃນອະນາຄົດ.

-I (ຢູ່ໃນສະຖານທີ່) ການແກ້ໄຂໄຟລ໌. ຮຽກ​ຮ້ອງ​ໃຫ້​ມີ​ໄຟລ​໌​ເພື່ອ​ປັບ​ປຸງ​ແກ້​ໄຂ​ແລະ​ດັ່ງ​ນັ້ນ​ພຽງ​ແຕ່​ເຮັດ​ວຽກ​ຮ່ວມ​ກັບ -F​. ນີ້​ແມ່ນ
ຫມາຍຄວາມວ່າສໍາລັບການປ່ຽນແປງເລັກນ້ອຍຕໍ່ໄຟລ໌ json. ເມື່ອນໍາໃຊ້, ຜົນຜະລິດປົກກະຕິແມ່ນຖືກສະກັດກັ້ນ
ແລະລຸ່ມສຸດຂອງ stack ການແກ້ໄຂແມ່ນຂຽນອອກ.

-0 (ຕົວຂັ້ນ null) ປ່ຽນຕົວຂັ້ນຂອງ -u ຈາກແຖວໃໝ່ເປັນ null. ທາງເລືອກນີ້
ພຽງແຕ່ມີຜົນກະທົບ -u ເພາະວ່ານັ້ນແມ່ນເວລາດຽວທີ່ສາຍໃຫມ່ອາດຈະປາກົດຢູ່ໃນກົດຫມາຍ
ຜົນຜະລິດ.

- ການປ່ຽນແປງ
ຕອບສະແຕມເວລາ YYYYMMDD ແລະອອກ.

ອື່ນໆ ເຄື່ອງມື

jshon ສະເຫມີໃຫ້ຜົນໄດ້ຮັບຫນຶ່ງພາກສະຫນາມຕໍ່ແຖວ. ເຄື່ອງມື unix ຫຼາຍຄາດວ່າຈະມີແຖບຫຼາຍແຍກ
ຊ່ອງຂໍ້ມູນຕໍ່ແຖວ. ທໍ່ຜົນຜະລິດຜ່ານ 'ວາງ' ເພື່ອແກ້ໄຂນີ້. ຢ່າງໃດກໍຕາມ, paste ບໍ່ສາມາດ
ຈັດການເສັ້ນຫວ່າງເປົ່າເພື່ອໃຫ້ແຜ່ນທີ່ມີຕົວຍຶດ. ນີ້ແມ່ນຕົວຢ່າງ:

jshon ... | sed 's/^$/-/' | ວາງ -s -d '\t\t\n'

ອັນນີ້ແທນທີ່ຊ່ອງຫວ່າງດ້ວຍ '-' ແລະຮວມທຸກໆສາມແຖວເປັນໜຶ່ງ.

ມີເຄື່ອງມືຫຼາຍກວ່າແລະຫຼາຍທີ່ຜະລິດ json output. ສ່ວນຫຼາຍແລ້ວສິ່ງເຫຼົ່ານີ້ໃຊ້ເສັ້ນຮັດກຸມ
json/plaintext hybrid ທີ່ແຕ່ລະແຖວເປັນໂຄງສ້າງ json ທີ່ເປັນເອກະລາດ. ແຕ່ຫນ້າເສຍດາຍ, ນີ້ຫມາຍຄວາມວ່າ
ຜົນຜະລິດໂດຍລວມບໍ່ແມ່ນ json ທີ່ຖືກຕ້ອງ. ທັງສອງ loop ເຖິງແມ່ນວ່າຂໍ້ມູນໂດຍສາຍ
(ໂທ jshon ຫນຶ່ງຄັ້ງສໍາລັບແຕ່ລະແຖວ) ຫຼືປ່ຽນເປັນ json array ທີ່ຖືກຕ້ອງ. ຍົກ​ຕົວ​ຢ່າງ:

ໃນຂະນະທີ່ອ່ານເສັ້ນ; do jshon <<< "$line"; ສຳເລັດ <(journalctl -o json)

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

GOLF

ຖ້າທ່ານສົນໃຈກັບ liners ສັ້ນທີ່ສຸດ, ການໂຕ້ຖຽງສາມາດ condensed ໃນເວລາທີ່ມັນບໍ່ໄດ້
ເຮັດໃຫ້ເກີດຄວາມບໍ່ແນ່ນອນ. ຕົວຢ່າງຈາກ -p(op) ສາມາດຕີກ໊ອຟໄດ້ດັ່ງນີ້:

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

ຂ້າພະເຈົ້າບໍ່ແນະນໍາໃຫ້ເຮັດສິ່ງນີ້ (ມັນເຮັດໃຫ້ສິ່ງທີ່ເຂົ້າໃຈຍາກກວ່າ) ແຕ່ບາງຄົນ
Golf ເຖິງວ່າຈະມີຜົນສະທ້ອນ.

ການສ້າງ JSON

jshon ສາມາດສ້າງ json ໂດຍການຖ່າຍທອດວັດຖຸຫວ່າງເປົ່າເປັນການປ້ອນຂໍ້ມູນ:

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

AUTHORS

jshon ຂຽນໂດຍ Kyle Keen[email protected]> ມີ patches ຈາກ Dave Reisner
<[email protected]>, AndrewF (BSD, OSX, jsonp, sorting), ແລະ Jean-Marc A (solaris).

ໃຊ້ jshon ອອນໄລນ໌ໂດຍໃຊ້ບໍລິການ onworks.net