jshon - מקוון בענן

תָכְנִית:

שֵׁם

ג'שון - מנתח JSON עבור המעטפת

תַקצִיר

ג'שון -[P|S|Q|V|C|I|0] [-F path] -[t|l|k|u|p|a] -[s|n] ערך -[e|i|d] אינדקס

תיאור

ג'שון מנתח, קורא ויוצר JSON. זה נועד להיות שמיש ככל האפשר מ
בתוך המעטפת ומחליף מנתחי adhoc שבירים העשויים מ-grep/sed/awk וכן
מנתחים כבדים בשורה אחת העשויים מ-perl/python.

ג'שון טוען טקסט json מ-stdin, מבצע פעולות, ואז מציג את הפעולה האחרונה ב-stdout.
חלק מהאפשרויות פלט json, אחרות פלט סיכומי טקסט רגיל. כי לבש יש מאוד
מבני נתונים מקוננים גרועים, ג'שון אינו מחזיר את ה-JSON כאובייקט מקורי כאופייני
הספרייה הייתה. במקום זאת ג'שון שומר על היסטוריה של עריכות בערימה, ואתה מתפעל את
רכיב JSON העליון ביותר.

פעולות

כל פעולה לובשת צורה של אפשרות קצרה. חלקם דורשים טיעונים. בעוד מקרים רבים
of ג'שון ניתן להעביר זה דרך זה, יש לשרשר פעולות ברצף כדי לצמצם
שיחות. כל הדוגמאות משתמשות בדוגמה זו של json:

{"a":1,"b":[true,false,null,"str"],"c":{"d":4,"e":5}}
jshon [פעולות] < sample.json

השימושים הנפוצים ביותר לקריאה בלבד יצטרכו רק כמה -e פעולות ואחת -a באמצע ה
אותם.

-t (סוג) מחזיר מחרוזת, אובייקט, מערך, מספר, bool, null

jshon -t -> אובייקט

-l (אורך) מחזיר מספר שלם. עובד רק על מחרוזת, אובייקט, מערך.

jshon -l -> 3

-k (מפתחות) מחזיר רשימה מופרדת בשורה חדשה של מפתחות. עובד רק על אובייקט.

jshon -k -> abc

-e מדד
(חילוץ) מחזיר ערך json ב-"index". עובד רק על אובייקט, מערך. המדד של an
מערך הוא מספר שלם.

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

-a (across) ממפה את שאר הפעולות על פני האלמנט הנבחר. עובד רק על חפצים
ומערכים. מרובות -a ניתן לקנן שיחות, אם כי הצורך הוא נדיר בפועל.

jshon -eb -a -t -> bool bool null מחרוזת

-s ערך
(string) מחזיר מחרוזת מקודדת json. ניתן (-i) להכניס מאוחר יותר לקיים
מבנה.

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

-n ערך
(nonstring/number) מחזיר אלמנט json. ניתן (-i) להכניס מאוחר יותר לקיים
מִבְנֶה. ערכים חוקיים הם 'true', 'false', 'null', 'array', 'object',
צפים. גם הקיצורים t, f, n, [] ו-{} בהתאמה פועלים.

jshon -n אובייקט -> {}

-u (unstring) מחזיר מחרוזת מפוענחת. עובד רק על סוגים פשוטים: string, int, real,
בוליאני, ריק.

jshon -eb -e 3 -u -> str

-p (פופ) מקפיץ את המניפולציה האחרונה מהמחסנית, מגלגל את ההיסטוריה לאחור. שימושי ל
חילוץ ערכים מרובים מאובייקט אחד.

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", ...}

מערכים מטופלים בצורה מיוחדת. העברת מספרים שלמים תכניס ערך בלי
הדפסה. מספרים שלמים שליליים קבילים, וכך גם המחרוזת 'להוסיף'. כדי להחליף
ערך במערך: מחק את האינדקס, -n/s הערך החדש, ולאחר מכן הוסף באינדקס.

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

אי מניפולציה

ישנן מספר מטא-אפשרויות שאינן עורכות ישירות את json. התקשר לאלה לכל היותר פעם אחת בכל
קְרִיאָה.

-F
(קובץ) קורא מקובץ במקום stdin. האפשרות היחידה ללא מניפולציה לקחת an
ויכוח.

-P (jsonp) מסיר התקשרות חוזרת של jsonp לפני שהוא ממשיך כרגיל.

-S (מיין) מחזיר את json ממוין לפי מפתח, במקום ההזמנה המקורית.

-Q (שקט) משבית את דיווח השגיאות ב-stderr, כך שלא תצטרך לפזר "2> /dev/null"
לאורך התסריט שלך.

-V (לפי ערך) מאפשר מעבר לפי ערך בערימת היסטוריית העריכה. במקרים קיצוניים עם
אלפי ערכים מקוננים עמוקים שהדבר עלול להוביל אליהם ג'שון פועל לאט פי כמה
תוך שימוש פי כמה בזיכרון. עם זאת, ערך לוואי בטוח יותר מהפניה נלווית ו
בדרך כלל גורם פחות הפתעה. הפנייה לדרך מופעלת כברירת מחדל מכיוון שאין
סיכון במהלך פעולות לקריאה בלבד ובדרך כלל הופך את עריכת 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 (המשך) על שגיאות הניתנות לשחזור. למשל, חילוץ ערכים שלא
exist יוסיף 'null' לערימת העריכה במקום לבטל. ההתנהגות עשויה להשתנות ב
עתיד.

-I עריכת קבצים (במקום). דורש קובץ לשינוי ולכן עובד רק עם -F. זה
מיועד לביצוע שינויים קלים בקובץ json. בעת שימוש, פלט רגיל מדוכא
והחלק התחתון של ערימת העריכה נכתב החוצה.

-0 (מפרידים null) משנה את המפריד של -u משורה חדשה ל-null. אפשרות זו
משפיע רק על -u מכיוון שזו הפעם היחידה שבה שורה חדשה עשויה להופיע באופן לגיטימי ב-
פלט.

--גִרְסָה
מחזיר חותמת זמן YYYYMMDD ויוצא.

אחר כלי עבודה

ג'שון תמיד מוציא שדה אחד בכל שורה. כלי יוניקס רבים מצפים להפרדת כרטיסיות מרובות
שדות לכל שורה. העבר את הפלט דרך 'הדבק' כדי לתקן זאת. עם זאת, הדבק לא יכול
טפל בקווים ריקים כדי לרפד אותם עם מציין מיקום. הנה דוגמה:

jshon ... | sed 's/^$/-/' | הדבק -s -d '\t\t\n'

זה מחליף את החסר ב-'-' וממזג כל שלוש שורות לאחת.

יש יותר ויותר כלים שמייצרים פלט של json. לעתים קרובות אלה משתמשים בקו מכוון
json/plaintext היברידי כאשר כל שורה היא מבנה json עצמאי. לצערי זה אומר
הפלט בכללותו אינו json לגיטימי. כל לולאה דרך הנתונים שורה אחר שורה
(יִעוּד ג'שון פעם אחת עבור כל שורה) או המרה אותו למערך json לגיטימי. לדוגמה:

בזמן קריאת שורה; do jshon <<< "$line"; בוצע < <(journalctl -o json)

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

גולף

אם אכפת לך מ-one liners קצרים במיוחד, טיעונים יכולים להתמצות כשלא
לגרום לאי בהירות. הדוגמה מ -פּוֹפּ) ניתן לשחק גולף באופן הבא:

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

אני לא ממליץ לעשות את זה (זה עושה דברים הרבה יותר קשה להבין) אבל כמה אנשים
גולף למרות ההשלכות.

יצירה JSON

ג'שון יכול ליצור json על ידי העברת אובייקט ריק כקלט:

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

מחברים

ג'שון נכתב על ידי קייל קין[מוגן בדוא"ל]> עם טלאים של דייב רייזנר
<[מוגן בדוא"ל]>, AndrewF (BSD, OSX, jsonp, מיון), וז'אן-מארק A (solaris).

השתמש ב-jshon באינטרנט באמצעות שירותי onworks.net