זוהי הפקודה jq שניתן להפעיל בספק האירוח החינמי של OnWorks באמצעות אחת מתחנות העבודה המקוונות המרובות שלנו, כגון Ubuntu Online, Fedora Online, אמולטור מקוון של Windows או אמולטור מקוון של MAC OS
תָכְנִית:
שֵׁם
jq - מעבד JSON בשורת הפקודה
תַקצִיר
jq [אפשרויות...] לסנן [קבצים...]
jq יכול לשנות את JSON בדרכים שונות, על ידי בחירה, איטרציה, הפחתה ואחרות
משבש מסמכי JSON. למשל, הפעלת הפקודה jq 'map(.price) | לְהוֹסִיף יצטרך
קח מערך של אובייקטי JSON כקלט והחזר את סכום שדות ה"מחיר" שלהם.
jq יכול לקבל גם קלט טקסט, אבל כברירת מחדל, jq קורא זרם של ישויות JSON
(כולל מספרים ושאר מילים) מ סטדין. רווח לבן נדרש רק כדי להפריד
ישויות כגון 1 ו-2, וכן אמת ושקר. אחד או יותר קבצים ניתן לציין, שבו
מקרה jq יקרא קלט מאלה במקום זאת.
אל האני אפשרויות מתוארים ב מזמין JQ סָעִיף; הם נוגעים בעיקר לקלט ופלט
עיצוב. ה לסנן כתוב בשפת jq ומציין כיצד להפוך את
קובץ קלט או מסמך.
מסננים
תוכנית jq היא "מסנן": היא לוקחת קלט, ומפיקה פלט. יש הרבה
מסננים מובנים לחילוץ שדה מסוים של אובייקט, או המרת מספר ל
מחרוזת, או משימות סטנדרטיות שונות אחרות.
ניתן לשלב מסננים בדרכים שונות - אתה יכול להזרים את הפלט של מסנן אחד לתוך
מסנן אחר, או לאסוף את הפלט של מסנן למערך.
מסננים מסוימים מייצרים תוצאות מרובות, למשל יש אחד שמפיק את כל
אלמנטים של מערך הקלט שלו. צנרת המסנן לשנייה מפעילה את המסנן השני עבור
כל רכיב של המערך. באופן כללי, דברים שיעשו עם לולאות ואיטרציה
בשפות אחרות פשוט נעשה על ידי הדבקת מסננים יחד ב-jq.
חשוב לזכור שלכל מסנן יש קלט ופלט. אפילו מילוליים
כמו "שלום" או 42 הם מסננים - הם לוקחים קלט אבל תמיד מייצרים את אותו מילולי כמו
תְפוּקָה. פעולות המשלבות שני מסננים, כמו הוספה, מזינות בדרך כלל את אותו קלט
לשניהם ולשלב את התוצאות. אז אתה יכול ליישם מסנן ממוצע כמו להוסיף / אורך
- הזנת מערך הקלט הן ל- להוסיף מסנן ואת אורך לסנן ולאחר מכן לבצע
המחלקה.
אבל זה מקדים את עצמנו. :) בואו נתחיל במשהו פשוט יותר:
מזמין JQ
מסנני jq פועלים על זרם של נתוני JSON. הקלט ל-jq מנותח כרצף של
ערכי JSON מופרדים ברווחים לבנים אשר מועברים דרך המסנן שסופק אחד ב-a
זְמַן. הפלט(ים) של המסנן נכתבים ל-standard out, שוב כרצף של
נתוני JSON מופרדים ברווחים לבנים.
הערה: חשוב לשים לב לכללי הציטוט של הקליפה. ככלל עדיף
תמיד לצטט (עם תווים עם מרכאות בודדות) את תוכנית jq, כמו יותר מדי תווים עם
משמעות מיוחדת ל-jq הן גם מטא-תווים של מעטפת. לדוגמה, jq "פו" ייכשל
רוב קונכיות יוניקס כי זה יהיה זהה לזה jq Foo, שבדרך כלל ייכשל
כי Foo is לֹא מוגדר. בעת שימוש במעטפת הפקודה של Windows (cmd.exe) עדיף
השתמש במירכאות כפולות סביב תוכנית ה-jq שלך כאשר היא ניתנת בשורת הפקודה (במקום -f
מסמך תוכנית אפשרות), אבל אז במירכאות כפולות בתוכנית jq יש צורך ביציאה לאחור.
אתה יכול להשפיע על האופן שבו jq קורא וכותב את הקלט והפלט שלו באמצעות שורת פקודה כלשהי
אפשרויות:
· --גִרְסָה:
פלט את גרסת jq וצא עם אפס.
· --Seq:
השתמש application/json-seq סכימת סוג MIME להפרדת טקסטים של JSON בקלט של jq
ופלט. המשמעות היא שתו ASCII RS (מפריד רשומות) מודפס לפני
כל ערך בפלט ו-ASCII LF (הזנת שורה) מודפס לאחר כל פלט. קֶלֶט
מתעלמים מטקסטים של JSON שלא מצליחים לנתח (אך מוזהרים עליהם), ומבטלים את כולם
קלט עוקב עד ה-RS הבא. זה גם מנתח את הפלט של jq ללא ה-
--Seq אוֹפְּצִיָה.
· --זרם:
נתח את הקלט בצורה זורמת, הפקת מערכים של ערכי נתיב ועלים
(סקלרים ומערכים ריקים או אובייקטים ריקים). לדוגמה, "א" הופך להיות [[],"א"], ו
[[],"a",["b"]] הופך להיות [[0],[]], [[1],"א"], ו [[1,0],"ב"].
זה שימושי לעיבוד תשומות גדולות מאוד. השתמש בזה בשילוב עם
סינון ואת להפחית ו foreach תחביר כדי לצמצם כניסות גדולות בהדרגה.
· --לשלוף/-s:
במקום להפעיל את המסנן עבור כל אובייקט JSON בקלט, קרא את כל הקלט
הזרם לתוך מערך גדול והפעל את המסנן פעם אחת בלבד.
· --קלט גולמי/-R:
אל תנתח את הקלט בתור JSON. במקום זאת, כל שורת טקסט מועברת למסנן בתור א
חוּט. אם משלבים עם --לשלוף, ואז כל הקלט מועבר למסנן בתור a
מחרוזת אחת ארוכה.
· ---null-input/-n:
אל תקראו שום מידע בכלל! במקום זאת, המסנן מופעל פעם אחת בשימוש ריק כקלט.
זה שימושי בעת שימוש ב-jq כמחשבון פשוט או לבניית נתוני JSON
שריטה.
· --פלט קומפקטי / -c:
כברירת מחדל, jq pretty מדפיס פלט JSON. שימוש באפשרות זו יביא ליותר
פלט קומפקטי על ידי הצבת כל אובייקט JSON על שורה אחת.
· --טאב:
השתמש בטאב עבור כל רמת הזחה במקום שני רווחים.
· --לְשַׁנֵן n:
השתמש במספר הרווחים הנתון (לא יותר מ-8) להזחה.
· --פלט צבע / -C ו --פלט מונוכרום / -M:
כברירת מחדל, jq מוציא JSON צבעוני אם כותבים למסוף. אתה יכול להכריח את זה
לייצר צבע גם אם כותבים לצינור או לקובץ באמצעות -C, והשבת צבע עם -M.
· - פלט ascii / -a:
jq מוציא בדרך כלל נקודות קוד שאינן ASCII Unicode כ-UTF-8, גם אם הקלט צוין
אותם כרצפי בריחה (כמו "\u03bc"). באמצעות אפשרות זו, אתה יכול לאלץ את jq
הפקת פלט ASCII טהור כאשר כל תו שאינו ASCII מוחלף בדמות המקבילה
רצף בריחה.
· --לא מאומצת
שטף את הפלט לאחר הדפסת כל אובייקט JSON (שימושי אם אתה מבצע צנרת איטי
מקור נתונים ל-jq והעברת הפלט של jq במקום אחר).
· --מפתחות מיון / -S:
פלט את השדות של כל אובייקט עם המקשים בסדר ממוין.
· --תפוקה גולמית / -r:
עם אפשרות זו, אם התוצאה של המסנן היא מחרוזת, היא תיכתב ישירות
לפלט סטנדרטי במקום להיות מעוצב כמחרוזת JSON עם מרכאות. זה יכול
להיות שימושי כדי לגרום למסנני jq לדבר עם מערכות שאינן מבוססות JSON.
· ---join-output / -j:
כמו -r אבל jq לא ידפיס שורה חדשה אחרי כל פלט.
· -f שם הקובץ / --from-file שם הקובץ:
קרא מסנן מהקובץ ולא משורת פקודה, כמו אפשרות -f של awk. אתה
יכול גם להשתמש ב'#' כדי להעיר הערות.
· -Ldirectory / -L בספרייה:
תתכונן בספרייה לרשימת החיפוש של מודולים. אם נעשה שימוש באפשרות זו אז לא
נעשה שימוש ברשימת חיפוש מובנית. עיין בסעיף על מודולים להלן.
· -e / --סטטוס יציאה:
מגדיר את מצב היציאה של jq ל-0 אם ערכי הפלט האחרונים לא היו אף אחד מהם שקר ולא ריק,
1 אם ערך הפלט האחרון היה אחד מהם שקר or ריק, או 4 אם לא הייתה תוצאה חוקית אי פעם
מיוצר. בדרך כלל jq יוצא עם 2 אם הייתה בעיית שימוש או שגיאת מערכת כלשהי, 3
אם הייתה שגיאת קומפילציה של תוכנית jq, או 0 אם תוכנית jq רצה.
· --ארג שם ערך:
אפשרות זו מעבירה ערך לתוכנית jq כמשתנה מוגדר מראש. אם אתה מריץ את jq
עם --ארג Foo בָּר, לאחר מכן $foo זמין בתוכנית ויש לו את הערך "בָּר".
שים לב כי ערך יטופל כמחרוזת, אז --ארג Foo 123 יתחייב $foo ל "123".
· --ארג'סון שם JSON-text:
אפשרות זו מעבירה ערך מקודד JSON לתוכנית jq כמשתנה מוגדר מראש. אם
אתה מפעיל את jq עם --ארג'סון Foo 123, לאחר מכן $foo זמין בתוכנית ויש לו את
ערך 123.
· --slurpfile שם משתנה שם הקובץ:
אפשרות זו קוראת את כל טקסט ה-JSON בקובץ בעל השם ומקשרת מערך של ה-
ניתוח ערכי JSON למשתנה הגלובלי הנתון. אם אתה מריץ jq עם --argfile Foo בָּר,
אז $foo זמין בתוכנית ויש לו מערך שהרכיבים שלו תואמים
הטקסטים בקובץ בשם בָּר.
· --argfile שם משתנה שם הקובץ:
אל תשתמש. להשתמש --slurpfile במקום.
(אפשרות זו היא כמו --slurpfile, אבל כאשר לקובץ יש רק טקסט אחד, אז זהו
בשימוש, אחרת נעשה שימוש במערך של טקסטים כמו ב --slurpfile.)
· --ריצת בדיקות [שם קובץ]:
מפעיל את הבדיקות בקובץ הנתון או בקלט הסטנדרטי. זו חייבת להיות האפשרות האחרונה שניתנה
ואינו מכבד את כל האפשרויות הקודמות. הקלט מורכב משורות הערה, ריקות
שורות, ושורות תוכנית ואחריהן שורת קלט אחת, כמה שורות פלט שיש
צפוי (אחד לכל פלט), ושורה ריקה מסתיימת. מבחני כשל קומפילציה
התחל עם שורה המכילה רק "%%FAIL", ולאחר מכן שורה המכילה את התוכנית to
קומפיל, ולאחר מכן שורה המכילה הודעת שגיאה להשוואה למציאות.
הוזהר כי אפשרות זו יכולה להשתנות לאחור באופן לא תואם.
בסיסי מסננים
.
המסנן הפשוט ביותר (והפחות מעניין) הוא .. זה פילטר שלוקח את שלו
קלט ומפיק אותו ללא שינוי כפלט.
מאז jq כברירת מחדל די-מדפיס את כל הפלט, תוכנית טריוויאלית זו יכולה להיות דרך שימושית
עיצוב פלט JSON מ, למשל, תלתל.
jq '.'
"שלום עולם!"
=> "שלום, עולם!"
.foo, .פו בר
הכי פשוט מועיל מסנן הוא .foo. כאשר ניתן אובייקט JSON (המכונה מילון או hash) כ
קלט, הוא מייצר את הערך במפתח "foo", או null אם אין כזה.
אם המפתח מכיל תווים מיוחדים, עליך להקיף אותו במירכאות כפולות כמו
זֶה: ."foo$".
מסנן של הטופס .פו בר שווה .foo|.bar.
jq '.foo'
{"foo": 42, "bar": "נתונים פחות מעניינים"}
=> 42
jq '.foo'
{"notfoo": true, "alsonotfoo": false}
=> ריק
jq ´.["foo"]´
{"foo": 42}
=> 42
.foo?
בדיוק כמו .foo, אך אינו מוציא אפילו שגיאה כאשר . אינו מערך או אובייקט.
jq ´.foo?´
{"foo": 42, "bar": "נתונים פחות מעניינים"}
=> 42
jq ´.foo?´
{"notfoo": true, "alsonotfoo": false}
=> ריק
jq ´.["פו"]?´
{"foo": 42}
=> 42
jq '[.foo?]'
[1,2]
=> []
.[ ], .[2], .[10:15]
אתה יכול גם לחפש שדות של אובייקט באמצעות תחביר כמו .["פו"] (.foo למעלה הוא א
גרסת קיצור של זה). זה עובד גם עבור מערכים, אם המפתח הוא מספר שלם.
מערכים מבוססים על אפס (כמו javascript), אז . [2] מחזירה את האלמנט השלישי של המערך.
אל האני .[10:15] ניתן להשתמש בתחביר כדי להחזיר תת-מערך של מערך או מחרוזת משנה של מחרוזת.
המערך חזר על ידי .[10:15] יהיה באורך 5, המכיל את האלמנטים מאינדקס 10
(כולל) עד מדד 15 (בלעדי). כל מדד עשוי להיות שלילי (במקרה זה הוא נחשב
אחורה מסוף המערך), או הושמט (במקרה זה מתייחס להתחלה או
סוף המערך).
אל האני . [2] ניתן להשתמש בתחביר כדי להחזיר את האלמנט באינדקס הנתון. מדדים שליליים הם
מותר, כאשר -1 מתייחס לאלמנט האחרון, -2 מתייחס לאלמנט הבא לאחרון,
וכן הלאה.
אל האני .foo תחביר עובד רק עבור מקשים פשוטים כלומר מקשים שכולם תווים אלפאנומריים.
.[ ] עובד עם מקשים המכילים תווים מיוחדים כגון נקודתיים ונקודות. ל
דוגמה .["פו בר"] ו .["פו בר"] לעבוד בזמן .פו בר ו .פו בר לא הייתי.
אל האני ? "מפעיל" יכול לשמש גם עם אופרטור הפרוסות, כמו ב .[10:15]?, אשר מוציא
ערכים שבהם התשומות ניתנות לפרוסות.
jq ´.[0]´
[{"name":"JSON", "good":true}, {"name":"XML", "good":false}]
=> {"name":"JSON", "good":true}
jq ´.[2]´
[{"name":"JSON", "good":true}, {"name":"XML", "good":false}]
=> ריק
jq ´.[2:4]´
["אבגדה"]
=> ["ג", "ד"]
jq ´.[2:4]´
"abcdefghi"
=> "תקליטורים"
jq ´.[:3]´
["אבגדה"]
=> ["א", "ב", "ג"]
jq ´.[-2:]´
["אבגדה"]
=> ["ד", "ה"]
jq ´.[-2]´
[1,2,3]
=> 2
.[]
אם אתה משתמש .[אינדקס] תחביר, אבל להשמיט את האינדקס לחלוטין, הוא יחזור את כל של
אלמנטים של מערך. רץ .[] עם הקלט [1,2,3] יפיק את המספרים כשלוש
תוצאות נפרדות, במקום כמערך בודד.
אתה יכול להשתמש בזה גם על אובייקט, וזה יחזיר את כל הערכים של האובייקט.
jq '.[]'
[{"name":"JSON", "good":true}, {"name":"XML", "good":false}]
=> {"name":"JSON", "good":true}, {"name":"XML", "good":false}
jq '.[]'
[]
=>
jq '.[]'
{"a": 1, "b": 1}
=> 1, 1
.[]?
כמו .[], אך לא יופקו שגיאות אם . אינו מערך או אובייקט.
,
אם שני מסננים מופרדים בפסיק, הקלט יוזן גם וגם לשם
יהיו פלטים מרובים: ראשית, כל הפלטים המופקים על ידי הביטוי השמאלי, ו
ואז כל התפוקות שהופקו על ידי הימין. למשל, סינון .foo, .בַּר, מייצרת
גם שדות "foo" וגם שדות "בר" כפלטים נפרדים.
jq ´.foo, .bar´
{"foo": 42, "bar": "משהו אחר", "baz": true}
=> 42, "משהו אחר"
jq ´.user, .projects[]´
{"user":"stedolan", "projects": ["jq", "wikiflow"]}
=> "stedolan", "jq", "wikiflow"
jq ´.[4,2]´
["אבגדה"]
=> "ה", "ג"
|
ה | המפעיל משלב שני מסננים על ידי הזנת הפלט/ים של זה משמאל לתוכו
הקלט של זה מימין. זה פחות או יותר זהה לצינור של מעטפת יוניקס, אם
אתה רגיל לזה.
אם זה משמאל מייצר תוצאות מרובות, זה מימין יפעל
כל אחת מהתוצאות הללו. אז, הביטוי .[] | .foo מאחזר את שדה "foo" של כל אחד
אלמנט של מערך הקלט.
jq ´.[] | .שֵׁם
[{"name":"JSON", "good":true}, {"name":"XML", "good":false}]
=> "JSON", "XML"
סוגי ו ערכים
jq תומך באותה קבוצה של סוגי נתונים כמו JSON - מספרים, מחרוזות, בוליאנים, מערכים,
אובייקטים (שב-JSON-speak הם hashes עם מקשי מחרוזת בלבד), ו-"null".
בוליאניות, null, מחרוזות ומספרים נכתבים באותו אופן כמו ב-javascript. בדיוק כמו
כל השאר ב-jq, הערכים הפשוטים האלה לוקחים קלט ומייצרים פלט - 42 הוא
ביטוי jq חוקי שלוקח קלט, מתעלם ממנו ומחזיר במקום 42.
מערך בניה - []
כמו ב-JSON, [] משמש לבניית מערכים, כמו ב [1,2,3]. האלמנטים של המערכים יכולים
להיות כל ביטוי jq. כל התוצאות המיוצרות על ידי כל הביטויים נאספות
למערך אחד גדול. אתה יכול להשתמש בו כדי לבנות מערך מתוך כמות ידועה של ערכים
(כמו ב [.foo, .בָּר, .baz]) או "לאסוף" את כל התוצאות של מסנן למערך (כמו
in [.items[].name])
ברגע שתבינו את האופרטור "," תוכלו להסתכל על תחביר המערך של jq בצורה שונה
אור: הביטוי [1,2,3] אינו משתמש בתחביר מובנה עבור מערכים מופרדים בפסיקים,
אבל במקום זאת מיישם את [] אופרטור (איסוף תוצאות) לביטוי 1,2,3 (אשר
מניב שלוש תוצאות שונות).
אם יש לך פילטר X שמפיק ארבע תוצאות, ואז הביטוי [X] יפיק א
תוצאה בודדת, מערך של ארבעה אלמנטים.
jq '[.user, .projects[]]'
{"user":"stedolan", "projects": ["jq", "wikiflow"]}
=> ["stedolan", "jq", "wikiflow"]
אובייקטים - {}
כמו JSON, {} מיועד לבניית אובייקטים (המכונה מילונים או גיבוב), כמו ב: {"א": 42,
"ב": 17}.
אם המקשים הם "הגיוניים" (כל התווים האלפביתיים), אז ניתן להשאיר את המירכאות.
הערך יכול להיות כל ביטוי (אם כי ייתכן שיהיה עליך לעטוף אותו בסוגריים אם זה סה
מסובך), המוחל על הקלט של הביטוי {} (זכור, כל המסננים
יש קלט ופלט).
{פו בר}
יפיק את אובייקט JSON {"foo": 42} אם ניתן אובייקט JSON {"בר":42, "באז":43}.
אתה יכול להשתמש בזה כדי לבחור שדות מסוימים של אובייקט: אם הקלט הוא אובייקט עם
שדות "משתמש", "כותרת", "מזהה" ו-"תוכן" ואתה רק רוצה "משתמש" ו"כותרת", אתה יכול
לכתוב
{user: .user, title: .title}
מכיוון שזה כל כך נפוץ, יש תחביר קיצורי דרך: {מִשׁתַמֵשׁ, כותרת}.
אם אחד הביטויים מייצר תוצאות מרובות, מספר מילונים יהיו
מיוצר. אם הקלט הוא
{"user":"stedolan","titles":["JQ Primer", "More JQ"]}
ואז הביטוי
{משתמש, כותרת: .titles[]}
יפיק שני פלטים:
{"user":"stedolan", "title": "JQ Primer"}
{"user":"stedolan", "title": "עוד JQ"}
הצבת סוגריים סביב המפתח פירושה שהוא יוערך כביטוי. עם ה
אותו קלט כמו לעיל,
{(.user): .titles}
ייצור
{"stedolan": ["JQ Primer", "More JQ"]}
jq ´{משתמש, כותרת: .titles[]}´
{"user":"stedolan","titles":["JQ Primer", "More JQ"]}
=> {"user":"stedolan", "title": "JQ Primer"}, {"user":"stedolan", "title": "עוד JQ"}
jq ´{(.user): .titles}´
{"user":"stedolan","titles":["JQ Primer", "More JQ"]}
=> {"stedolan": ["JQ Primer", "More JQ"]}
BUILTIN מפעילים ו פונקציות
אופרטור jq כלשהו (לדוגמה, +) לעשות דברים שונים בהתאם לסוג שלהם
ארגומנטים (מערכים, מספרים וכו'). עם זאת, jq אף פעם לא מבצע המרות מסוג מרומז. אם
תנסה להוסיף מחרוזת לאובייקט תקבל הודעת שגיאה וללא תוצאה.
תוספת - +
המפעיל + לוקח שני מסננים, מחיל את שניהם על אותו קלט ומוסיף את
תוצאות ביחד. המשמעות של "הוספה" תלויה בסוגים המעורבים:
· מספרים מתווספים באמצעות חשבון רגיל.
· מערכים מתווספים על ידי שרשור למערך גדול יותר.
· מחרוזות מתווספים על ידי צירוף למחרוזת גדולה יותר.
· אובייקטים מתווספים על ידי מיזוג, כלומר, הוספת כל צמדי המפתח-ערך משניהם
אובייקטים לאובייקט משולב יחיד. אם שני האובייקטים מכילים ערך עבור אותו הדבר
מפתח, האובייקט מימין ל- + מנצח. (למיזוג רקורסיבי השתמש ב- * מַפעִיל.)
ריק ניתן להוסיף לכל ערך, ומחזיר את הערך השני ללא שינוי.
jq '.a + 1'
{"a": 7}
=> 8
jq ´.a + .b´
{"a": [1,2], "ב": [3,4]}
=> [1,2,3,4]
jq ´.a + null´
{"a": 1}
=> 1
jq '.a + 1'
{}
=> 1
jq '{a: 1} + {b: 2} + {c: 3} + {a: 42}'
ריק
=> {"a": 42, "b": 2, "c": 3}
חִסוּר - -
כמו גם חיסור אריתמטי רגיל על מספרים, ה - ניתן להשתמש באופרטור על מערכים
כדי להסיר את כל המופעים של רכיבי המערך השני מהמערך הראשון.
jq ´4 - .a´
{"a":3}
=> 1
jq'. - ["xml", "yaml"]´
["xml", "yaml", "json"]
=> ["json"]
כֶּפֶל, חטיבה, מודולו - *, /, ו %
אופרטורים אלו מתנהגים כצפוי כאשר מקבלים שני מספרים. חלוקה באפס העלאות
שגיאה. x % y מחשב את x modulo y.
הכפלה של מחרוזת במספר מייצרת את השרשור של המחרוזת הזו
פעמים. "איקס" * 0 ייצור ריק.
חלוקת מחרוזת באחר מפצלת את הראשון באמצעות השני כמפרידים.
הכפלת שני אובייקטים תמזג אותם רקורסיבית: זה עובד כמו חיבור אבל אם שניהם
אובייקטים מכילים ערך עבור אותו מפתח, והערכים הם אובייקטים, שניהם מתמזגים
עם אותה אסטרטגיה.
jq '10 / . * 3'
5
=> 6
jq'. / ", "´
"אבגדה"
=> ["a","b,c,d","e"]
jq ´{"k": {"a": 1, "b": 2}} * {"k": {"a": 0,"c": 3}}´
ריק
=> {"k": {"a": 0, "b": 2, "c": 3}}
jq ´.[] | (1 / .)?´
[1,0,-1]
=> 1, -1
אורך
הפונקציה המובנית אורך מקבל את האורך של סוגים שונים של ערך:
· אורכו של א מחרוזת הוא מספר נקודות הקוד של Unicode שהוא מכיל (שיהיה
זהה לאורכו המקודד ב-JSON בבתים אם הוא ASCII טהור).
· אורכו של an מערך הוא מספר האלמנטים.
· אורכו של an אובייקט הוא מספר צמדי מפתח-ערך.
· האורך של ריק הוא אפס.
jq ´.[] | length´ [[1,2], "string", {"a":2}, null] => 2, 6, 1, 0
מפתחות, keys_unsorted
הפונקציה המובנית מפתחות, כאשר ניתן אובייקט, מחזיר את המפתחות שלו במערך.
המפתחות ממוינים "בסדר אלפביתי", לפי סדר נקודות קוד של Unicode. זו לא פקודה
זה הגיוני במיוחד בכל שפה מסוימת, אבל אתה יכול לסמוך על כך שזה
זהה לכל שני אובייקטים עם אותה קבוצת מפתחות, ללא קשר להגדרות המקום.
מתי מפתחות ניתן מערך, הוא מחזיר את המדדים התקפים עבור אותו מערך: המספרים השלמים
מ-0 עד אורך-1.
אל האני keys_unsorted הפונקציה היא בדיוק כמו מפתחות, אבל אם הקלט הוא אובייקט אז המקשים
לא ימוינו, במקום זאת המפתחות יהיו בערך בסדר ההכנסה.
jq 'מפתחות'
{"abc": 1, "abcd": 2, "Foo": 3}
=> ["פו", "abc", "abcd"]
jq 'מפתחות'
[42,3,35]
=> [0,1,2]
יש (מפתח)
הפונקציה המובנית יש ל מחזירה אם לאובייקט הקלט יש את המפתח הנתון, או את הקלט
למערך יש אלמנט באינדקס הנתון.
יש ($מפתח) יש אותה השפעה כמו לבדוק אם מקש $ הוא חבר במערך שהוחזר
by מפתחות, למרות ש יש ל יהיה מהיר יותר.
jq 'map(has("foo"))'
[{"foo": 42}, {}]
=> [נכון, שקר]
jq 'מפה(יש ל(2))'
[[0,1], ["a","b","c"]]
=> [לא נכון, נכון]
in
הפונקציה המובנית in מחזירה מפתח הקלט נמצא באובייקט הנתון, או באינדקס הקלט
מתאים לאלמנט במערך הנתון. זוהי, בעצם, גרסה הפוכה של
יש ל.
jq ´.[] | in({"foo": 42})'
["פו בר"]
=> נכון, לא נכון
jq 'map(in([0,1]))'
[2, 0]
=> [לא נכון, נכון]
path(path_expression)
פלט ייצוגי מערך של ביטוי הנתיב הנתון ב .. הפלטים הם מערכים של
מחרוזות (מפתחות באובייקטים0 ו/או במספרים (מדדי מערך.
ביטויי נתיב הם ביטויי jq כמו .a, אלא גם .[]. ישנם שני סוגים של נתיבים
ביטויים: כאלה שיכולים להתאים בדיוק, וכאלה שלא. לדוגמה, .א ב ג הוא
ביטוי נתיב התאמה מדויקת, while .א[].ב לא.
path(exact_path_expression) יפיק את ייצוג המערך של ביטוי הנתיב
גם אם זה לא קיים ב ., אם . is ריק או מערך או אובייקט.
נתיב (תבנית) יפיק ייצוגי מערך של התאמת הנתיבים דפוס אם
נתיבים קיימים ב ..
שימו לב שביטויי הנתיב אינם שונים מביטויים רגילים. הביטוי
path(..|select(type=="boolean")) מוציא את כל הנתיבים לערכים בוליאניים ., ורק
השבילים האלה.
jq 'path(.a[0].b)'
ריק
=> ["a",0,"b"]
jq '[נתיב(..)]'
{"a":[{"b":1}]}
=> [[],["a"],["a",0],["a",0,"b"]]
del(path_expression)
הפונקציה המובנית דל מסיר מפתח ואת הערך המתאים שלו מאובייקט.
jq 'del(.foo)'
{"foo": 42, "bar": 9001, "baz": 42}
=> {"bar": 9001, "baz": 42}
jq 'del(.[1, 2])'
["פו", "בר", "באז"]
=> ["פו"]
לערכים, מתוך_ערכים, עם_ערכים
פונקציות אלו ממירות בין אובייקט למערך של זוגות מפתח-ערך. אם לערכים
מועבר אובייקט, ואז עבור כל אחד k: v כניסה בקלט, מערך הפלט כולל
{"מַפְתֵחַ": k, "ערך": v}.
מ_ערכים עושה את ההמרה ההפוכה, ו with_entries(foo) הוא קיצור של
לערכים | מפה (פו) | מ_ערכים, שימושי לביצוע פעולה כלשהי לכל המקשים ו
ערכים של חפץ. מ_ערכים מקבל מפתח, מפתח, שם, ערך וערך כמפתחות.
jq 'to_entries'
{"a": 1, "b": 2}
=> [{"key":"a", "value":1}, {"key":"b", "value":2}]
jq 'from_entries'
[{"key":"a", "value":1}, {"key":"b", "value":2}]
=> {"a": 1, "b": 2}
jq 'with_entries(.key |= "KEY_" + .)'
{"a": 1, "b": 2}
=> {"KEY_a": 1, "KEY_b": 2}
select(בוליאנית_ביטוי)
הפונקציה בחר (פו) מייצר את הקלט שלו ללא שינוי אם Foo מחזיר נכון עבור הקלט הזה,
ולא מייצר תפוקה אחרת.
זה שימושי לסינון רשימות: [1,2,3] | map(בחר(. >= 2)) אתן לך [2,3].
jq 'map(select(. >= 2))'
[1,5,3,0,7]
=> [5,3,7]
jq ´.[] | select(.id == "second")´
[{"id": "first", "val": 1}, {"id": "second", "val": 2}]
=> {"id": "second", "val": 2}
מערכים, חפצים, איטרבלים, בוליאנים, מספרים, רגילים, סופיים, מחרוזות, אפס, ערכים,
סקלרים
המובנים האלה בוחרים רק קלט שהם מערכים, אובייקטים, איטרנסים (מערכים או
אובייקטים), בוליאנים, מספרים, מספרים רגילים, מספרים סופיים, מחרוזות, null, non-null
ערכים, ואי-איטרבלים, בהתאמה.
jq ´.[]|מספרים´
[[],{},1,"foo",null,true,false]
=> 1
ריק
ריק לא מחזיר תוצאות. בכלל לא. אפילו לא ריק.
זה שימושי מדי פעם. אתה תדע אם אתה צריך את זה :)
jq '1, ריק, 2'
ריק
=> 1, 2
jq '[1,2,ריק,3]'
ריק
=> [1,2,3]
שגיאה(הודעה)
מייצר שגיאה, בדיוק כמו .a מיושם על ערכים אחרים מאשר null ואובייקטים היו, אבל
עם ההודעה הנתונה כערך השגיאה.
$__loc__
מייצר אובייקט עם מקש "קובץ" ומקש "קו", עם שם הקובץ ומספר השורה
איפה $__loc__ מתרחש, כערכים.
jq ´try error("\($__loc__)") catch .´
ריק
=> "{\"קובץ\":\" \",\"שורה 1}"
map(x), map_values(x)
לכל פילטר x, מפה(x) יריץ את המסנן הזה עבור כל רכיב של מערך הקלט, ו
לייצר את הפלטים מערך חדש. מפה(.+1) יגדיל כל רכיב של מערך של
מספרים.
באופן דומה, map_values(x) יפעיל את המסנן עבור כל אלמנט, אבל הוא יחזיר an
אובייקט כאשר חפץ עובר.
מפה(x) שווה [.[] | x]. למעשה, כך זה מוגדר. באופן דומה,
map_values(x) מוגדר .[] |= x.
jq 'map(.+1)'
[1,2,3]
=> [2,3,4]
jq 'map_values(.+1)'
{"a": 1, "b": 2, "c": 3}
=> {"a": 2, "b": 3, "c": 4}
שבילים, paths(node_filter), עלים_נתיבי
שבילים מפלט את הנתיבים לכל האלמנטים בקלט שלו (חוץ מזה שהוא לא מוציא את
רשימה ריקה, המייצגת . עצמו).
נתיבים (ו) מפלט את הנתיבים לכל ערכים שעבורם f נכון. זה, נתיבים (מספרים)
מפלט את הנתיבים לכל הערכים המספריים.
עלים_נתיבי הוא כינוי של שבילים (סקלרים); עלים_נתיבי is הוצא משימוש ויוסר ב
המהדורה הגדולה הבאה.
jq '[נתיבים]'
[1,[[],{"a":2}]]
=> [[0],[1],[1,0],[1,1],[1,1,"a"]]
jq '[נתיבים(סקלרים)]'
[1,[[],{"a":2}]]
=> [[0],[1,1,"a"]]
להוסיף
הפילטר להוסיף לוקח כקלט מערך, ומייצר כפלט את רכיבי המערך
מתווספים יחד. פירוש הדבר עשוי להיות סיכום, שרשור או מיזוג בהתאם לסוגים של
האלמנטים של מערך הקלט - הכללים זהים לאלה של ה- + מפעיל
(מתואר לעיל).
אם הקלט הוא מערך ריק, להוסיף החזרות ריק.
jq 'הוסף'
["א ב ג"]
=> "abc"
jq 'הוסף'
[1, 2, 3]
=> 6
jq 'הוסף'
[]
=> ריק
כל, כל (תנאי), any(גנרטור; מַצָב)
הפילטר כל לוקח כקלט מערך של ערכים בוליאניים, ומייצר נָכוֹן כפלט אם
כל אחד מהרכיבים של המערך הוא נָכוֹן.
אם הקלט הוא מערך ריק, כל החזרות שקר.
אל האני כל (תנאי) form מחיל את התנאי הנתון על האלמנטים של מערך הקלט.
אל האני any(גנרטור; מַצָב) טופס מחיל את התנאי הנתון על כל הפלטים של
מחולל נתון.
jq 'כל'
[אמת שקר]
=> נכון
jq 'כל'
[שקר, שקר]
=> שקר
jq 'כל'
[]
=> שקר
את כל, הכל (תנאי), הכל(מחולל; מַצָב)
הפילטר את כל לוקח כקלט מערך של ערכים בוליאניים, ומייצר נָכוֹן כפלט אם
כל הרכיבים של המערך הם נָכוֹן.
אל האני הכל (מצב) form מחיל את התנאי הנתון על האלמנטים של מערך הקלט.
אל האני הכל(מחולל; מַצָב) טופס מחיל את התנאי הנתון על כל הפלטים של
מחולל נתון.
אם הקלט הוא מערך ריק, את כל החזרות נָכוֹן.
jq 'הכל'
[אמת שקר]
=> שקר
jq 'הכל'
[אמת אמת]
=> נכון
jq 'הכל'
[]
=> נכון
[מחייב 1.5] לְשַׁטֵחַ, לשטח (עומק)
הפילטר לְשַׁטֵחַ לוקח כקלט מערך של מערכים מקוננים, ומייצר מערך שטוח ב
שכל המערכים בתוך המערך המקורי הוחלפו באופן רקורסיבי בערכים שלהם.
אתה יכול להעביר אליו טיעון כדי לציין כמה רמות קינון לשטח.
לְשַׁטֵחַ(2) הוא כמו לְשַׁטֵחַ, אבל עולה רק לעומק של שתי רמות.
jq 'לשטח'
[1, [2], [[3]]]
=> [1, 2, 3]
jq'לְשַׁטֵחַ(1)'
[1, [2], [[3]]]
=> [1, 2, [3]]
jq 'לשטח'
[[]]
=> []
jq 'לשטח'
[{"foo": "בר"}, [{"foo": "baz"}]]
=> [{"foo": "בר"}, {"foo": "baz"}]
טווח (עד), טווח (מ; עד) טווח (מ; עד; לפי)
אל האני רכס הפונקציה מייצרת טווח של מספרים. range(4;10) מייצר 6 מספרים, מ-4
(כולל) עד 10 (בלעדי). המספרים מופקים כפלטים נפרדים. להשתמש
[range(4;10)] כדי לקבל טווח כמערך.
צורת הארגומנט האחד מייצרת מספרים מ-0 למספר הנתון, עם תוספת של
1.
צורת שני הארגומנטים מייצרת מספרים מ החל מ- ל עד ל עם תוספת של 1.
צורת שלושת הארגומנטים יוצרת מספרים החל מ- ל עד ל עם תוספת של by.
jq 'range(2;4)'
ריק
=> 2, 3
jq '[range(2;4)]'
ריק
=> [2,3]
jq '[רכס(4)]'
ריק
=> [0,1,2,3]
jq '[range(0;10;3)]'
ריק
=> [0,3,6,9]
jq '[range(0;10;-1)]'
ריק
=> []
jq '[range(0;-5;-1)]'
ריק
=> [0,-1,-2,-3,-4]
קומה
אל האני קומה הפונקציה מחזירה את הקומה של הקלט המספרי שלה.
jq 'קומה'
3.14159
=> 3
מ"ר
אל האני מ"ר הפונקציה מחזירה את השורש הריבועי של הקלט המספרי שלה.
jq 'sqrt'
9
=> 3
למספר
אל האני למספר הפונקציה מנתחת את הקלט שלה כמספר. זה ימיר בפורמט נכון
מחרוזות למקבילה המספרית שלהן, השאר את המספרים לבד, ותן שגיאה בכל השאר
קֶלֶט.
jq ´.[] | למספר
[1, "1"]
=> 1, 1
tostring
אל האני tostring הפונקציה מדפיסה את הקלט שלה כמחרוזת. המיתרים נשארים ללא שינוי, והכל
ערכים אחרים מקודדים ב-JSON.
jq ´.[] | tostring´
[1, "1", [1]]
=> "1", "1", "[1]"
סוג
אל האני סוג הפונקציה מחזירה את סוג הארגומנט שלה כמחרוזת, שהיא אחת של null,
בוליאני, מספר, מחרוזת, מערך או אובייקט.
jq 'map(type)'
[0, false, [], {}, null, "שלום"]
=> ["מספר", "בוליאני", "מערך", "אובייקט", "null", "מחרוזת"]
אינסופי, לא, הוא אינסופי, איסנן, הוא סופי, זה נורמלי
פעולות אריתמטיות מסוימות יכולות להניב אינסוף וערכי "לא מספר" (NaN). ה
הוא אינסופי תשואות מובנות נָכוֹן אם הקלט שלו הוא אינסופי. ה isnan תשואות מובנות נָכוֹן
אם הקלט שלו הוא NaN. ה אין סופי מובנה מחזיר ערך אינסופי חיובי. ה נאן
מובנה מחזירה NaN. ה זה נורמלי ingebouwd מחזירה true אם הקלט שלו הוא מספר נורמלי.
שימו לב שחילוק באפס מעלה שגיאה.
נכון לעכשיו, רוב הפעולות האריתמטיות הפועלות על אינסוף, NaNs ותת-נורמליות אינן
להעלות שגיאות.
jq ´.[] | (אינסופי * .) < 0´
[-1, 1]
=> נכון, לא נכון
jq ´אינסופי, נאן | סוּג
ריק
=> "מספר", "מספר"
סוג, sort_by(path_expression)
אל האני sort functions ממיין את הקלט שלו, שחייב להיות מערך. הערכים ממוינים ב-
הסדר הבא:
· ריק
· שקר
· נָכוֹן
· מספרים
· מחרוזות, בסדר אלפביתי (לפי ערך נקודת קוד Unicode)
· מערכים, לפי סדר מילוני
· חפצים
הסדר עבור אובייקטים הוא מעט מורכב: ראשית הם מושווים על ידי השוואה שלהם
קבוצות מפתחות (כמערכים בסדר ממוין), ואם המפתחות שלהם שווים אז הערכים הם
השוו מפתח אחר מפתח.
sort ניתן להשתמש כדי למיין לפי שדה מסוים של אובייקט, או על ידי החלת כל מסנן jq.
sort_by(foo) משווה שני אלמנטים על ידי השוואת התוצאה של Foo על כל אלמנט.
jq 'מיין'
[8,3,null,6]
=> [null,3,6,8]
jq 'סort_by(.foo)'
[{"foo":4, "bar":10}, {"foo":3, "bar":100}, {"foo":2, "bar":1}]
=> [{"foo":2, "bar":1}, {"foo":3, "bar":100}, {"foo":4, "bar":10}]
group_by(path_expression)
group_by(.foo) לוקח כקלט מערך, מקבץ את האלמנטים בעלי אותו הדבר .foo שדה
למערכים נפרדים, ומייצר את כל המערכים הללו כאלמנטים של מערך גדול יותר,
ממוין לפי הערך של .foo שדה.
ניתן להשתמש בכל ביטוי jq, לא רק גישה לשדה, במקום .foo. המיון
הסדר זהה כמתואר ב- sort פונקציה למעלה.
jq 'group_by(.foo)'
[{"foo":1, "bar":10}, {"foo":3, "bar":100}, {"foo":1, "bar":1}]
=> [[{"foo":1, "bar":10}, {"foo":1, "bar":1}], [{"foo":3, "bar":100}]]
דקות מקסימום, min_by(path_exp), max_by(path_exp)
מצא את האלמנט המינימלי או המקסימלי של מערך הקלט.
אל האני min_by(path_exp) ו max_by(path_exp) פונקציות מאפשרות לך לציין פרט מסוים
שדה או נכס לבחון, למשל min_by(.foo) מוצא את האובייקט עם הקטן ביותר Foo
שדה.
jq 'דקה'
[5,4,2,7]
=> 2
jq 'max_by(.foo)'
[{"foo":1, "bar":14}, {"foo":2, "bar":3}]
=> {"foo":2, "bar":3}
ייחודי, unique_by(path_exp)
אל האני ייחודי הפונקציה לוקחת כקלט מערך ומייצרת מערך של אותם אלמנטים, ב
סדר ממוין, כשהכפילויות הוסרו.
אל האני unique_by(path_exp) הפונקציה תשמור רק רכיב אחד עבור כל ערך שיתקבל על ידי
יישום הטיעון. תחשוב על זה כיצירת מערך על ידי הוצאת אלמנט אחד מכל אחד
קבוצה שהופקה על ידי קבוצה.
jq 'ייחודי'
[1,2,5,3,5,3,1,3]
=> [1,2,3,5]
jq 'unique_by(.foo)'
[{"foo": 1, "bar": 2}, {"foo": 1, "bar": 3}, {"foo": 4, "bar": 5}]
=> [{"foo": 1, "bar": 2}, {"foo": 4, "bar": 5}]
jq 'unique_by(length)'
["שמנמן", "בייקון", "חתלתול", "ציקדה", "אספרגוס"]
=> ["בייקון", "שמנמן", "אספרגוס"]
להפוך
פונקציה זו הופכת מערך.
jq 'הפוך'
[1,2,3,4]
=> [4,3,2,1]
מכיל (אלמנט)
הפילטר מכיל (ב) יפיק true אם b מוכל לחלוטין בתוך הקלט. א
מחרוזת B כלולה במחרוזת A אם B היא מחרוזת משנה של A. מערך B כלול ב
מערך A אם כל האלמנטים ב-B כלולים באלמנט כלשהו ב-A. אובייקט B הוא
הכלול באובייקט A אם כל הערכים ב-B כלולים בערך ב-A עם ה-
אותו מפתח. ההנחה היא שכל שאר הסוגים מוכלים זה בזה אם הם שווים.
jq 'contains("bar")'
"פו בר"
=> נכון
jq ´contains(["baz", "bar"])´
["foobar", "foobaz", "ברפ"]
=> נכון
jq ´contains(["bazzzzz", "bar"])´
["foobar", "foobaz", "ברפ"]
=> שקר
jq 'contains({foo: 12, bar: [{barp: 12}]})'
{"foo": 12, "bar":[1,2,{"barp":12, "blip":13}]}
=> נכון
jq 'contains({foo: 12, bar: [{barp: 15}]})'
{"foo": 12, "bar":[1,2,{"barp":12, "blip":13}]}
=> שקר
מדדים
פלט מערך המכיל את המדדים ב . איפה s מתרחשת. הקלט עשוי להיות מערך, ב
איזה מקרה אם s הוא מערך אז פלט המדדים יהיה אלה שבהם כל האלמנטים נמצאים .
להתאים לאלה של s.
jq 'מדדים(", ")'
"a,b, cd, efg, hijk"
=> [3,7,12]
jq'מדדים(1)'
[0,1,2,1,3,1,4]
=> [1,3,5]
jq 'מדדים([1,2])'
[0,1,2,3,1,4,2,5,1,2,6,7]
=> [1,8]
אינדקס(ים), rindex(ים)
מוציא את האינדקס של הראשון (מדד) או אחרון (rindex) התרחשות של s בקלט.
jq 'index(", ")'
"a,b, cd, efg, hijk"
=> 3
jq 'rindex(", ")'
"a,b, cd, efg, hijk"
=> 12
בתוך
הפילטר בתוך (ב) יפיק true אם הקלט כלול לחלוטין בתוך b. זה
הוא, בעצם, גרסה הפוכה של מכיל.
jq 'inside("foobar")'
"בָּר"
=> נכון
jq ´inside(["foobar", "foobaz", "ברפ"])´
["באז", "בר"]
=> נכון
jq ´inside(["foobar", "foobaz", "ברפ"])´
["bazzzz", "בר"]
=> שקר
jq ´inside({"foo": 12, "bar":[1,2,{"barp":12, "blip":13}]})´
{"foo": 12, "bar": [{"barp": 12}]}
=> נכון
jq ´inside({"foo": 12, "bar":[1,2,{"barp":12, "blip":13}]})´
{"foo": 12, "bar": [{"barp": 15}]}
=> שקר
מתחיל עם(str)
יציאות נָכוֹן אם . מתחיל עם ארגומנט המחרוזת הנתון.
jq ´[.[]|startswith("foo")]´
["פו", "פו", "ברפו", "פובר", "ברפוב"]
=> [שקר, נכון, שקר, נכון, שקר]
endswith(str)
יציאות נָכוֹן אם . מסתיים בארגומנט המחרוזת הנתון.
jq ´[.[]|endswith("foo")]´
["foobar", "barfoo"]
=> [לא נכון, נכון]
שילובים, שילובים (n)
מוציא את כל השילובים של רכיבי המערכים במערך הקלט. אם ניתן an
טענה n, הוא מוציא את כל השילובים של n חזרות של מערך הקלט.
jq 'שילובים'
[[1,2], [3, 4]]
=> [1, 3], [1, 4], [2, 3], [2, 4]
jq'שילובים(2)'
[0, 1]
=> [0, 0], [0, 1], [1, 0], [1, 1]
ltrimstr(str)
מוציא את הקלט שלו עם מחרוזת הקידומת הנתונה שהוסרה, אם הוא מתחיל איתה.
jq ´[.[]|ltrimstr("foo")]´
["פו", "פו", "ברפו", "פובר", "אפו"]
=> ["fo","","barfoo","bar","afoo"]
rtrimstr(str)
מוציא את הקלט שלו עם הסרת מחרוזת הסיומת הנתונה, אם היא מסתיימת בה.
jq ´[.[]|rtrimstr("foo")]´
["פו", "פו", "ברפו", "פובר", "פוב"]
=> ["fo","","bar","foobar","foob"]
להתפוצץ
ממירה מחרוזת קלט למערך של מספרי נקודות הקוד של המחרוזת.
jq 'להתפוצץ'
"פו בר"
=> [102,111,111,98,97,114]
להתפוצץ
היפוך של התפוצצות.
jq 'תפוצץ'
[65, 66, 67]
=> "ABC"
לפצל
מפצל מחרוזת קלט בארגומנט המפריד.
jq ´split(", ")´
"אבגדה, "
=> ["a","b,c,d","e",""]
join(str)
מצטרף למערך האלמנטים שניתנו כקלט, תוך שימוש בארגומנט כמפריד. זה
הפוך מ לפצל: כלומר ריצה split("פו") | join("פו") מעל כל מחרוזת קלט
מחזיר את מחרוזת הקלט האמורה.
jq 'join(", ")'
["אבגדה"]
=> "א, ב, ג, ד, ה"
ascii_downcase, ascii_upcase
שלח עותק של מחרוזת הקלט עם התווים האלפביתיים שלה (az ו-AZ) המומרים ל
המקרה שצוין.
while(cond; עדכון)
אל האני while(cond; עדכון) הפונקציה מאפשרת לך להחיל עדכון שוב ושוב על . עד תנאי
הוא שקר.
שים לב כי while(cond; עדכון) מוגדרת באופן פנימי כפונקציית jq רקורסיבית. רקורסיבי
שיחות בפנים בזמן לא יצרוך זיכרון נוסף אם עדכון מייצר לכל היותר אחד
פלט עבור כל קלט. ראה נושאים מתקדמים למטה.
jq '[while(.<100; .*2)]'
1
=> [1,2,4,8,16,32,64]
עד(cond; הַבָּא)
אל האני עד(cond; הַבָּא) הפונקציה מאפשרת לך להחיל שוב ושוב את הביטוי הבא,
בתחילה ל . ואז לפלט משלו, עד תנאי נכון. לדוגמה, ניתן להשתמש בזה
ליישם פונקציה פקטוריאלית (ראה להלן).
שים לב כי עד(cond; הַבָּא) מוגדרת באופן פנימי כפונקציית jq רקורסיבית. רקורסיבי
שיחות בפנים עד() לא יצרוך זיכרון נוסף אם הבא מייצר לכל היותר אחד
פלט עבור כל קלט. ראה נושאים מתקדמים למטה.
jq ´[.,1]|עד(.[0] < 1; [.[0] - 1, .[1] * .[0]])|.[1]´
4
=> 24
recurse(f), מהפך, recurse(f; מַצָב), recurse_down
אל האני חזרה (ו) הפונקציה מאפשרת לך לחפש דרך מבנה רקורסיבי ולחלץ
נתונים מעניינים מכל הרמות. נניח שהקלט שלך מייצג מערכת קבצים:
{"name": "/", "ילדים": [
{"שם": "/ סל", "ילדים": [
{"שם": "/bin/ls", "ילדים": []},
{"שם": "/ Bin / sh", "ילדים": []}]},
{"שם": "/ בית", "ילדים": [
{"name": "/home/stephen", "children": [
{"name": "/home/stephen/jq", "children": []}]}]}]}
כעת נניח שאתה רוצה לחלץ את כל שמות הקבצים הקיימים. אתה צריך לאחזר . שם,
.children[].שם, .children[].children[].שם, וכן הלאה. אתה יכול לעשות זאת עם:
recurse(.children[]) | .שֵׁם
כשקוראים לו בלי ויכוח, להחזיר שווה recurse(.[]?).
חזרה (ו) זהה ל recurse(f; . != ריק) וניתן להשתמש בו ללא דאגות לגבי
עומק רקורסיה.
recurse(f; מַצָב) הוא מחולל שמתחיל בפליטת . ואז פולט בתורו
.|f, .|f|f, .|f|f|f, ... כל עוד הערך המחושב עומד בתנאי. ל
לדוגמה, כדי ליצור את כל המספרים השלמים, לפחות באופן עקרוני, אפשר לכתוב recurse(.+1;
נכון).
מסיבות עתיקות יומין, recurse_down קיים ככינוי להתקשרות להחזיר בלי ויכוחים.
כינוי זה נחשב הוצא משימוש ויוסר במהדורה הגדולה הבאה.
הרקורסיב מתקשר להחזיר לא יצרוך זיכרון נוסף בכל פעם f מייצרת ב
כמעט פלט בודד עבור כל קלט.
jq 'recurse(.foo[])'
{"foo":[{"foo": []}, {"foo":[{"foo":[]}]}]}
=> {"foo":[{"foo":[]},{"foo":[{"foo":[]}]}]}, {"foo":[]}, {"foo": [{"foo":[]}]}, {"foo":[]}
jq 'recurse'
{"a":0,"b":[1]}
=> {"a":0,"b":[1]}, 0, [1], 1
jq 'recurse(. * .; . < 20)'
2
=> 2, 4, 16
..
יד קצרה עבור להחזיר ללא ויכוחים. זה נועד להידמות ל-XPath //
מַפעִיל. ציין זאת ..א לא עובד; להשתמש ..|א במקום זאת. בדוגמה למטה אנו משתמשים
..|.א? כדי למצוא את כל הערכים של מפתחות האובייקט "a" בכל אובייקט שנמצא "למטה" ..
jq ´..|.a?´
[[{"a":1}]]
=> 1
env
פלט אובייקט המייצג את הסביבה של jq.
jq 'env.PAGER'
ריק
=> "פחות"
לְשַׁרבֵּב
העברה של מטריצה אולי משוננת (מערך של מערכים). שורות מרופדות באפס כך שה
התוצאה היא תמיד מלבנית.
jq 'העברה'
[[1], [2,3]]
=> [[1,2],[null,3]]
bsearch(x)
bsearch(x) מבצע חיפוש בינארי של x במערך הקלט. אם הקלט ממוין ו
מכיל x, אז bsearch(x) יחזיר את האינדקס שלו במערך; אחרת, אם המערך הוא
ממוין, הוא יחזיר (-1 - ix) כאשר ix היא נקודת הכנסה כך שהמערך
עדיין להיות ממוין לאחר הוספה של x ב-ix. אם המערך אינו ממוין, bsearch(x)
יחזיר מספר שלם שכנראה לא מעניין אותו.
jq'bsearch(0)'
[0,1]
=> 0
jq'bsearch(0)'
[1,2,3]
=> -1
jq'bsearch(4) בתור $ix | אם $ix < 0 אז .[-(1+$ix)] = 4 אחר . סוֹף
[1,2,3]
=> [1,2,3,4]
מחרוזת אינטרפולציה - \(פו)
בתוך מחרוזת, אתה יכול לשים ביטוי בתוך Parens לאחר נטוי אחורי. מה שלא יהיה
החזרות ביטוי יעברו אינטרפולציה לתוך המחרוזת.
jq ´"הקלט היה \(.), שהוא אחד פחות מ-\(.+1)"´
42
=> "הקלט היה 42, שזה אחד פחות מ-43"
המרת אל/מ JSON
אל האני טויסון ו fromjson ערכי dump מובנה כטקסטים של JSON או ניתוח טקסטים של JSON
ערכים, בהתאמה. ה-tojson המובנה שונה מ-tostring בכך שה-tostring מחזיר
מחרוזות ללא שינוי, בעוד ש-tojson מקודד מחרוזות כמחרוזות JSON.
jq '[.[]|tostring]'
[1, "פו", ["פו"]]
=> ["1","foo","[\"foo\"]"]
jq '[.[]|tojson]'
[1, "פו", ["פו"]]
=> ["1","\"foo\"","[\"foo\"]"]
jq '[.[]|tojson|fromjson]'
[1, "פו", ["פו"]]
=> [1,"foo",["foo"]]
פוּרמָט מחרוזות ו בריחה
אל האני @foo התחביר משמש לעיצוב והחלפת מחרוזות, וזה שימושי לבניית כתובות URL,
מסמכים בשפה כמו HTML או XML וכן הלאה. @foo יכול לשמש כמסנן על
משלו, ההימלטות האפשריות הן:
@טֶקסט:
שיחות tostring, עיין בפונקציה הזו לפרטים.
@json:
מסדר את הקלט בתור JSON.
@html:
מחיל HTML/XML בריחה, על ידי מיפוי התווים <>&´" לישות שלהם
שווי ערך <, >, &, ', ".
@ורי:
מחיל קידוד אחוז, על ידי מיפוי כל תווי ה-URI השמורים ל-a % XX סדר פעולות.
@csv:
הקלט חייב להיות מערך, והוא מוצג כ-CSV עם מרכאות כפולות עבור
מחרוזות, ומרכאות שנמלטו על ידי חזרה.
@tsv:
הקלט חייב להיות מערך, והוא מוצג כ-TSV (ערכים מופרדים בטאבים). כל אחד
מערך הקלט יודפס כשורה אחת. השדות מופרדים בכרטיסייה אחת
(ascii 0x09). הזנת תווים בשורה (ascii 0x0a), החזרת כרכרה (ascii
0x0d), tab (ascii 0x09) ונטוי לאחור (ascii 0x5c) ייצא כ-escape
רצפים \n, \r, \t, \\ בהתאמה.
@ש:
הקלט הוא Escape מתאים לשימוש בשורת פקודה עבור מעטפת POSIX. אם ה
הקלט הוא מערך, הפלט יהיה סדרה של מחרוזות מופרדות בחלל.
@base64:
הקלט מומר ל-base64 כפי שצוין ב-RFC 4648.
ניתן לשלב את התחביר הזה עם אינטרפולציה של מחרוזות בצורה שימושית. אתה יכול לעקוב אחר א
@foo אסימון עם מחרוזת מילולית. תוכן המחרוזת רצון מילולי לֹא להימלט.
עם זאת, כל האינטרפולציות שנעשות בתוך המילולית של המחרוזת הזו תימלט. לדוגמה,
@uri "https://www.google.com/search?q=\(.search)"
יפיק את הפלט הבא עבור הקלט {"search":"what is jq?"}:
"https://www.google.com/search?q=what%20is%20jq%3F"
שים לב שהלוכסנים, סימן השאלה וכו' בכתובת ה-URL אינם בורחים, מכיוון שהם היו חלק
של המיתר מילולי.
jq '@html'
"זה עובד אם x < y"
=> "זה עובד אם x < y"
jq ´@sh "echo \(.)"´
"האייל של אוהרה"
=> "הד ´O´\\´´Hara´\\´´s Ale´"
תאריכים
jq מספק פונקציונליות בסיסית של טיפול בתאריכים, עם חלק ברמה גבוהה וברמה נמוכה
מובנה. בכל המקרים המובנים הללו עוסקים אך ורק בזמן ב-UTC.
אל האני fromdateiso8601 מובנה מנתח תאריכים בפורמט ISO 8601 למספר שניות
מאז תקופת יוניקס (1970-01-01T00:00:00Z). ה todateiso8601 מובנה עושה את ההיפך.
אל האני מתאריך מובנה מנתח מחרוזות תאריך ושעה. כַּיוֹם מתאריך תומך רק ב-ISO 8601
מחרוזות תאריך תאריך, אך בעתיד היא תנסה לנתח מחרוזות תאריך תאריך יותר
פורמטים.
אל האני עד היום בנוי הוא כינוי עבור todateiso8601.
אל האני עַכשָׁיו מובנה מוציא את הזמן הנוכחי, בשניות מאז עידן יוניקס.
ממשקי jq ברמה נמוכה לפונקציות הזמן של ספריית C מסופקים גם: זמן זמן,
זמן אחסון, זמן מקומי, ו gmtime. עיין בתיעוד של מערכת ההפעלה המארחת שלך עבור
מחרוזות פורמט בשימוש על ידי זמן זמן ו זמן אחסון. הערה: אלה לא בהכרח יציבים
ממשקים ב-jq, במיוחד באשר לפונקציונליות הלוקליזציה שלהם.
אל האני gmtime מובנה צורך מספר שניות מאז עידן יוניקס ומוציא "שבור
זמן השבתה" ייצוג הזמן כמערך של מספרים המייצגים (בסדר זה): את
שנה, החודש (מבוסס אפס), היום בחודש, השעה ביום, הדקה של ה
שעה, השני של הדקה, היום בשבוע והיום בשנה - כולם
מבוסס אחד אלא אם צוין אחרת.
אל האני זמן מקומי מובנה צורכת ייצוגים של "זמן שבור" של פלט זמן על ידי gmtime
ו זמן זמן.
אל האני strptime(fmt) מובנה מנתח מחרוזות קלט התואמות את fmt טַעֲנָה. הפלט בפנים
ייצוג "הזמן השבור" הנצרך על ידי gmtime ופלט על ידי זמן מקומי.
אל האני strftime(fmt) פורמטים מובנים של זמן עם הפורמט הנתון.
מחרוזות הפורמט עבור זמן זמן ו זמן אחסון מתוארים בספריית C טיפוסית
תיעוד. מחרוזת הפורמט עבור ISO 8601 תאריך ושעה היא "%Y-%m-%dT%H:%M:%SZ".
ייתכן ש-jq לא יתמוך בחלק מפונקציונליות התאריך הזו או את כולה במערכות מסוימות.
jq 'fromdate'
"2015-03-05T23:51:47Z"
=> 1425599507
jq 'strptime("%Y-%m-%dT%H:%M:%SZ")'
"2015-03-05T23:51:47Z"
=> [2015,2,5,23,51,47,4,63]
jq 'strptime("%Y-%m-%dT%H:%M:%SZ")|mktime'
"2015-03-05T23:51:47Z"
=> 1425599507
תנאים ו השוואות
==, !=
הביטוי ´a == b´ ייצור ´true´ אם התוצאה של a ו-b שוות (כלומר,
אם הם מייצגים מסמכי JSON שווים) ו'false' אחרת. בפרט, מיתרים
לעולם לא נחשבים שווים למספרים. אם אתה מגיע מ-Javascript, jq's == הוא כמו
Javascript's === - בהתחשב בערכים שווים רק כאשר יש להם אותו סוג כמו גם
אותו ערך.
!= הוא "לא שווה", ו-'a != b' מחזירה את הערך ההפוך של ´a == b´
jq ´.[] == 1´
[1, 1.0, "1", "בננה"]
=> נכון, נכון, שקר, שקר
אם-אז-אחר
if A אז B אחר C סוף יפעל כמו B if A מייצר ערך אחר מאשר false or
null, אבל לפעול כמו C אחרת.
בדיקה של false או null היא מושג פשוט יותר של "אמת" ממה שנמצא ב-Javascript
או Python, אבל זה אומר שלפעמים תצטרך להיות מפורש יותר לגבי המצב
אתה רוצה: אתה לא יכול לבדוק אם, למשל, מחרוזת ריקה באמצעות if . שם אז A אחר B סוף,
תצטרך עוד משהו כמו if (.שֵׁם | אורך) > 0 אז A אחר B סוף במקום.
אם התנאי A מייצר תוצאות מרובות, הוא נחשב "נכון" אם אחד מאלה
התוצאות אינן שקר או אפס. אם זה מייצר אפס תוצאות, זה נחשב לא נכון.
ניתן להוסיף מקרים נוספים ל-if using אליף A אז B תחביר.
jq 'אם . == 0 אז
"אפס" אליף. == 1 ואז "אחד" אחר "רבים" סוף´ 2 => "רבים"
>, >=, <=, <
מפעילי ההשוואה >, >=, <=, < להחזיר אם הטיעון השמאלי שלהם גדול מ,
גדול או שווה ל, קטן או שווה או קטן מהטיעון הנכון שלהם
(בהתאמה).
ההזמנה זהה לזו שתוארה עבור sortמעל.
jq'. < 5'
2
=> נכון
ו/או/לא
jq תומך באופרטורים בוליאניים רגילים ו/או/לא. יש להם אותו סטנדרט של אמת
כאילו ביטויים - false ו-null נחשבים "ערכים כוזבים", וכל דבר אחר הוא א
"ערך אמיתי".
אם אופרנד של אחד מהאופרטורים הללו מייצר תוצאות מרובות, האופרטור עצמו
יפיק תוצאה עבור כל קלט.
לֹא הוא למעשה פונקציה מובנית ולא אופרטור, אז זה נקרא כמסנן ל
אילו דברים ניתן להעביר במקום עם תחביר מיוחד, כמו ב .foo ו .בַּר | לֹא.
שלושת אלה מייצרים רק את הערכים "true" ו-"false", ולכן הם שימושיים רק עבור אמיתי
פעולות בוליאניות, ולא הביטוי הנפוץ של Perl/Python/Ruby של
"ערך_שעשוי_להיות_ריק או ברירת מחדל". אם אתה רוצה להשתמש בצורה זו של "או", בחר בין
שני ערכים במקום הערכת תנאי, ראה את האופרטור "//" למטה.
jq '42 ו"מחרוזת"'
ריק
=> נכון
jq '(true, false) או false'
ריק
=> נכון, לא נכון
jq '(true, true) and (true, false)'
ריק
=> נכון, שקר, נכון, שקר
jq ´[true, false | לֹא
ריק
=> [לא נכון, נכון]
חלופה מפעיל - //
מסנן של הטופס a // b מייצר את אותן תוצאות כמו a, אם a מייצר תוצאות אחרות
מֵאֲשֶׁר שקר ו ריק. אחרת, a // b מייצר את אותן תוצאות כמו b.
זה שימושי למתן ברירות מחדל: .foo // 1 יעריך עד 1 אם אין .foo
אלמנט בקלט. זה דומה לאיך or משמש לפעמים ב-Python (jq's or מפעיל
שמור לפעולות בוליאניות בלבד).
jq ´.foo // 42´
{"foo": 19}
=> 19
jq ´.foo // 42´
{}
=> 42
נסה לתפוס
ניתן לתפוס שגיאות על ידי שימוש לנסות EXP לתפוס EXP. הביטוי הראשון מבוצע, ואם
זה נכשל ואז השני מבוצע עם הודעת השגיאה. הפלט של המטפל, אם
any, הוא פלט כאילו זה היה הפלט של הביטוי לנסות.
אל האני לנסות EXP שימושי צורה ריק כמטפל חריג.
jq ´try .a catch ". is not a object"´
נָכוֹן
=> ". אינו אובייקט"
jq '[.[]|try .a]'
[{}, נכון, {"a":1}]
=> [null, 1]
jq ´try error("כמה חריג") catch .´
נָכוֹן
=> "יוצא מן הכלל"
שבירה הַחוּצָה of לִשְׁלוֹט מבנים
שימוש נוח ב- try/catch הוא לפרוץ מבנים משליטה כמו להפחית, foreach,
בזמן, וכן הלאה.
לדוגמה:
# חזור על ביטוי עד שהוא מעלה "שבירה" כ-an
# שגיאה, ולאחר מכן הפסק לחזור מבלי להעלות מחדש את השגיאה.
# אבל אם השגיאה שנתפסה אינה "שבירה" אז הרם אותה מחדש.
נסה repeat(exp) catch .=="break" ואז ריק שגיאה אחרת;
ל-jq יש תחביר עבור תוויות מילוניות בשם "לשבור" או "לחזור (בחזרה) אל":
תווית $out | ... לפרוץ $ החוצה ...
אל האני לשבור $label_name ביטוי יגרום לתוכנית להתנהג כאילו היא הקרובה ביותר
(לשמאל) תווית $label_name מיוצר ריק.
הקשר בין לשבור ומתאים תווית הוא מילוני: התווית חייבת להיות
"גלוי" מההפסקה.
לפרוץ מתוך א להפחית, לדוגמה:
תווית $out | צמצם את .[] כ-$item (null; אם .==false אז צא ל-$out else ... end)
תוכנית jq הבאה מייצרת שגיאת תחביר:
לפרוץ $ החוצה
כי אין תווית $ החוצה גלוי.
? מפעיל
אל האני ? מפעיל, משמש כ EXP?, הוא קיצור עבור לנסות EXP.
jq '[.[]|(.a)?]'
[{}, נכון, {"a":1}]
=> [null, 1]
רגיל ביטויים (PCRE)
jq משתמש בספריית הביטויים הרגולריים Oniguruma, כמו גם php, ruby, TextMate, Sublime Text,
וכו', אז התיאור כאן יתמקד בפרטי jq.
מסנני ה-jq regex מוגדרים כך שניתן להשתמש בהם באמצעות אחת מהדפוסים הבאים:
STRING | FILTER ( REGEX )
STRING | FILTER( REGEX; FLAGS)
STRING | FILTER( [REGEX] )
STRING | FILTER( [REGEX, FLAGS] )
כאשר: * STRING, REGEX ו-FLAGS הם מחרוזות jq וכפופות לאינטרפולציה של מחרוזת jq; *
REGEX, לאחר אינטרפולציה של מחרוזת, צריך להיות ביטוי רגולרי PCRE חוקי; * FILTER הוא אחד מהם מבחן,
להתאים, או ללכוד, כמפורט להלן.
FLAGS היא מחרוזת המורכבת מאחד או יותר מהדגלים הנתמכים:
· g - חיפוש גלובלי (מצא את כל ההתאמות, לא רק את הראשונה)
· i - חיפוש לא רגיש לאותיות רישיות
· m - מצב ריבוי קווים ('.' יתאים לשורות חדשות)
· n - התעלם מגפרורים ריקים
· p - שני מצבי s ו-m מופעלים
· s - מצב קו בודד ('^' -> ´\A´, ´$´ -> ´\Z´)
· l - מצא התאמות הארוכות ביותר האפשריות
· x - פורמט ביטוי מורחב (התעלם מרווח לבן והערות)
כדי להתאים רווח לבן בתבנית x השתמש ב-escape כגון \s, למשל
· test( "a\sb", "x" ).
שים לב שדגלים מסוימים עשויים להיות מצוינים גם בתוך REGEX, למשל
· jq -n ´("בדיקה", "TEst", "teST", "TEST") | test( "(?i)te(?-i)st" )´
מעריך ל: נכון, נכון, שקר, שקר.
[מחייב 1.5] test(val), test(regex; דגלים)
כמו להתאים, אך אינו מחזיר אובייקטים תואמים, בלבד נָכוֹן or שקר עבור אם או לא את
ביטוי רגולרי מתאים לקלט.
jq 'test("foo")'
"פו"
=> נכון
jq ´.[] | test("מתעלמים מ-abc # רווחים"; "ix")´
["xabcd", "ABC"]
=> נכון, נכון
[מחייב 1.5] match(val), match(regex; דגלים)
להתאים מוציא אובייקט עבור כל התאמה שהוא מוצא. להתאמות יש את השדות הבאים:
· לקזז - היסט בנקודות קוד של UTF-8 מתחילת הקלט
· אורך - אורך בנקודות UTF-8 של המשחק
· מחרוזת - המחרוזת שהיא תאמה
· לוכדת - מערך של אובייקטים המייצגים קבוצות לכידה.
לכידת אובייקטים קבוצתיים יש את השדות הבאים:
· לקזז - היסט בנקודות קוד של UTF-8 מתחילת הקלט
· אורך - אורך בנקודות קוד UTF-8 של קבוצת הלכידה הזו
· מחרוזת - המיתר שנלכד
· שם - שם קבוצת הלכידה (או ריק אם זה היה ללא שם)
לכידת קבוצות שלא התאימו לשום דבר מחזירה היסט של -1
jq 'match("(abc)+"; "g")'
"abc abc"
=> {"offset": 0, "length": 3, "string": "abc", "captures": [{"offset": 0, "length": 3, "string": "abc", " name": null}]}, {"offset": 4, "length": 3, "string": "abc", "captures": [{"offset": 4, "length": 3, "string" : "abc", "name": null}]}
jq 'match("foo")'
"פו בר פו"
=> {"offset": 0, "length": 3, "string": "foo", "captures": []}
jq ´match(["foo", "ig"])´
"פו בר FOO"
=> {"offset": 0, "length": 3, "string": "foo", "captures": []}, {"offset": 8, "length": 3, "string": "FOO ", "לוכדת": []}
jq ´match("foo (? בָּר)? foo"; "ig")´
"פו בר פו פו פו פו"
=> {"offset": 0, "length": 11, "string": "foo bar foo", "captures": [{"offset": 4, "length": 3, "string": "bar" , "name": "bar123"}]}, {"offset": 12, "length": 8, "string": "foo foo", "captures": [{"offset": -1, "length" : 0, "string": null, "name": "bar123"}]}
jq ´[ match("."; "g")] | אורך
"א ב ג"
=> 3
[מחייב 1.5] לכידת (val), capture(regex; דגלים)
אוסף את הצילומים בעלי השם באובייקט JSON, עם השם של כל לכידה כמפתח,
והמחרוזת התואמת כערך המתאים.
jq ´capture("(? [az]+)-(? [0-9]+)")'
"xyzzy-14"
=> { "a": "xyzzy", "n": "14" }
[מחייב 1.5] סריקה (רגקס), scan(regex; דגלים)
פלט זרם של מחרוזות המשנה שאינן חופפות של הקלט התואמות את הביטוי הרגולרי ב
בהתאם לדגלים, אם צוינו. אם אין התאמה, הזרם כן
ריק. כדי ללכוד את כל ההתאמות עבור כל מחרוזת קלט, השתמש בביטוי [ ביטוי ]למשל [
סריקה (רגקס) ].
split(regex; דגלים)
עבור תאימות לאחור, לפצל מתפצל על מיתר, לא על ביטוי רגולרי.
[מחייב 1.5] פיצול(רגקס), splits(regex; דגלים)
אלה מספקים את אותן תוצאות כמו שלהם לפצל עמיתים, אבל כזרם במקום an
מערך.
[מחייב 1.5] sub(regex; tostring) sub(regex; מחרוזת; דגלים)
פלט את המחרוזת שהושגה על ידי החלפת ההתאמה הראשונה של הביטוי הרגולרי במחרוזת הקלט ב
tostring, לאחר אינטרפולציה. tostring צריכה להיות מחרוזת jq, ועשויה להכיל הפניות
ללכודות בשם. הלכידות הנקובות מוצגות, למעשה, כאובייקט JSON (כמו
נבנה על ידי ללכוד) כדי tostring, כך שהפניה למשתנה שנלכד בשם "x" תהיה
קח את הצורה: "(.x)".
[מחייב 1.5] gsub(regex; חוּט), gsub(regex; מחרוזת; דגלים)
gsub הוא כמו להלן אבל כל המופעים שאינם חופפים של הביטוי הרגולרי מוחלפים ב-
מחרוזת, לאחר אינטרפולציה.
מתקדם מאפיינים
משתנים הם הכרח מוחלט ברוב שפות התכנות, אבל הם נדחים
ל"תכונה מתקדמת" ב-jq.
ברוב השפות, משתנים הם האמצעי היחיד להעברת נתונים. אם מחשבים את א
ערך, ואתה רוצה להשתמש בו יותר מפעם אחת, תצטרך לאחסן אותו במשתנה. ל
להעביר ערך לחלק אחר של התוכנית, תצטרך את החלק הזה של התוכנית
להגדיר משתנה (כפרמטר פונקציה, איבר אובייקט או כל דבר אחר) שבו למקם
הנתונים.
אפשר גם להגדיר פונקציות ב-jq, אם כי מדובר בתכונה שהכי גדולה שלה
use מגדיר את הספרייה הסטנדרטית של jq (פונקציות jq רבות כגון מַפָּה ו למצוא הם למעשה
כתוב ב-jq).
ל-jq יש אופרטורים להפחתה, שהם מאוד חזקים אבל קצת מסובכים. שוב, אלה הם
משמש בעיקר פנימי, כדי להגדיר כמה סיביות שימושיות של הספרייה הסטנדרטית של jq.
זה אולי לא מובן מאליו בהתחלה, אבל jq הוא הכל על גנרטורים (כן, כפי שנמצא לעתים קרובות ב
שפות אחרות). כמה כלי עזר מסופקים כדי לעזור להתמודד עם גנרטורים.
תמיכה מינימלית ב-I/O (מלבד קריאת JSON מקלט סטנדרטי, וכתיבת JSON ל
פלט סטנדרטי) זמין.
לבסוף, יש מערכת מודול/ספרייה.
משתנים
ב-jq, לכל המסננים יש קלט ופלט, כך שאין צורך בצנרת ידנית
להעביר ערך מחלק אחד של תוכנית למשנהו. ביטויים רבים, למשל a + b,
להעביר את הקלט שלהם לשני ביטויי משנה ברורים (כאן a ו b שניהם עברו אותו הדבר
קלט), כך שבדרך כלל אין צורך במשתנים על מנת להשתמש בערך פעמיים.
לדוגמה, חישוב הערך הממוצע של מערך מספרים דורש כמה
משתנים ברוב השפות - לפחות אחד שיחזיק את המערך, אולי אחד עבור כל אלמנט
או עבור מונה לולאות. ב-jq, זה פשוט להוסיף / אורך - ה להוסיף ניתן ביטוי ל
מערך ומייצר את הסכום שלו, ואת אורך הביטוי מקבל את המערך ומייצר את שלו
אורך.
אז, בדרך כלל יש דרך נקייה יותר לפתור את רוב הבעיות ב-jq מאשר הגדרת משתנים.
ובכל זאת, לפעמים הם עושים את זה יותר קל, אז jq מאפשר לך להגדיר משתנים באמצעות
ביטוי as $משתנה. כל שמות המשתנים מתחילים ב $. הנה גרסה קצת יותר מכוערת
של הדוגמה של ממוצע המערך:
אורך כ-$array_length | add / $array_length
נזדקק לבעיה מסובכת יותר כדי למצוא מצב שבו משתמשים במשתנים בפועל
עושה את החיים שלנו קלים יותר.
נניח שיש לנו מערך של פוסטים בבלוג, עם שדות "מחבר" ו"כותרת", ועוד אחד
אובייקט המשמש למיפוי שמות משתמש של מחבר לשמות אמיתיים. הקלט שלנו נראה כך:
{"posts": [{"title": "Frist psot", "author": "anon"},
{"title": "מאמר כתוב היטב", "author": "person1"}],
"realnames": {"anon": "פחדן אנונימי",
"person1": "Person McPherson"}}
אנחנו רוצים להפיק את הפוסטים עם שדה המחבר המכיל שם אמיתי, כמו ב:
{"title": "Frist psot", "author": "פחדן אנונימי"}
{"title": "מאמר כתוב היטב", "author": "Person McPherson"}
אנו משתמשים במשתנה, $names, כדי לאחסן את אובייקט ה-realnames, כדי שנוכל להתייחס אליו מאוחר יותר
בעת חיפוש שמות משתמש של מחבר:
.realnames בתור $names | .פוסטים[] | {כותרת, מחבר: $names[.author]}
הביטוי exp as $x | ... פירושו: לכל ערך ביטוי exp, הפעל את שאר
הצינור עם כל הקלט המקורי, ועם $x מוגדר לערך זה. לכן as
מתפקד כמו לולאה קדמית.
בדיוק כפי {פו} היא דרך שימושית לכתיבה {פו: .foo}, כך {$foo} היא דרך שימושית לכתיבה
{foo:$foo}.
ניתן להצהיר על מספר משתנים באמצעות יחיד as ביטוי על ידי מתן דפוס
התואם את מבנה הקלט (זה ידוע בשם "הרס"):
. בתור {שמות אמיתיים: $names, פוסטים: [$first, $second]} | ...
הצהרות המשתנים בתבניות מערך (למשל, . as [$ראשון, $שניה]) לאגד את
אלמנטים של המערך נכנסים מהאלמנט באינדקס אפס ומעלה, לפי הסדר. כשאין
ערך באינדקס עבור רכיב דפוס מערך, ריק קשור למשתנה הזה.
משתנים נמצאים בהיקף על פני שאר הביטוי המגדיר אותם, אז
.realnames בתור $names | (.פוסטים[] | {כותרת, מחבר: $names[.author]})
יעבוד, אבל
(.realnames כמו $names | .פוסטים[]) | {כותרת, מחבר: $names[.author]}
רָגִיל.
עבור תאורטיקנים של שפת תכנות, יותר נכון לומר שמשתני jq הם כאלה
כריכות בהיקף מילוני. במיוחד אין דרך לשנות את הערך של כריכה;
אפשר רק להגדיר כריכה חדשה עם אותו שם, אך לא תהיה גלויה היכן
הישן היה.
jq ´.bar כ-$x | .foo | . + $x´
{"foo":10, "bar":200}
=> 210
jq'. כמו $i|[(.*2|. as $i| $i), $i]´
5
=> [10,5]
jq'. כמו [$a, $b, {c: $c}] | $a + $b + $c´
[2, 3, {"c": 4, "d": 5}]
=> 9
jq ´.[] בתור [$a, $b] | {a: $a, b: $b}´
[[0], [0, 1], [2, 1, 0]]
=> {"a":0,"b":null}, {"a":0,"b":1}, {"a":2,"b":1}
מגדיר פונקציות
אתה יכול לתת למסנן שם באמצעות תחביר "def":
תוספת קבע: . + 1;
מכאן ואילך, תוֹסֶפֶת הוא שמיש כמסנן בדיוק כמו פונקציה מובנית (למעשה, זו
כך מוגדרים חלק מהמבנים). פונקציה עשויה לקחת ארגומנטים:
def map(f): [.[] | f];
ארגומנטים מועברים כמסננים, לא כערכים. ניתן להתייחס לאותו טיעון
מספר פעמים עם כניסות שונות (כאן f מופעל עבור כל רכיב של מערך הקלט).
ארגומנטים לפונקציה עובדים יותר כמו התקשרות חוזרת מאשר ארגומנטים כמו ערך. זה
חשוב להבין. לשקול:
def foo(f): f|f;
5|foo(.*2)
התוצאה תהיה 20 כי f is .*2, ובמהלך הקריאה הראשונה של f . יהיה 5,
ובפעם השנייה זה יהיה 10 (5 * 2), אז התוצאה תהיה 20. ארגומנטים של פונקציה
הם מסננים, ומסננים מצפים לקלט כאשר הם מופעלים.
אם אתה רוצה את התנהגות הערך-טיעון להגדרת פונקציות פשוטות, אתה יכול פשוט להשתמש ב-a
מִשְׁתַנֶה:
def addvalue(f): f כ-$f | map(. + $f);
או השתמש ביד הקצרה:
def addvalue($f): ...;
עם כל אחת מההגדרות, addvalue(.foo) יוסיף את הקלט הנוכחי .foo שדה לכל אחד
אלמנט של המערך.
מותרות הגדרות מרובות המשתמשות באותו שם פונקציה. כל הגדרה מחדש מחליפה
הקודם עבור אותו מספר של ארגומנטים של פונקציה, אבל רק עבור הפניות מ
פונקציות (או תוכנית ראשית) לאחר ההגדרה מחדש.
jq ´def addvalue(f): . + [f]; map(addvalue(.[0]))'
[[1,2], [10,20]]
=> [[1,2,1], [10,20,10]]
jq ´def addvalue(f): f כ-$x | map(. + $x); addvalue(.[0])'
[[1,2], [10,20]]
=> [[1,2,1,2], [10,20,1,2]]
להפחית
אל האני להפחית תחביר ב-jq מאפשר לך לשלב את כל התוצאות של ביטוי על ידי
לצבור אותם לתשובה אחת. כדוגמה, נעבור [3,2,1] לזה
ביטוי:
הפחת את .[] בתור $item (0; . + $item)
לכל תוצאה ש .[] מייצר, . + $item מופעלת כדי לצבור סכום שוטף,
החל מ-0. בדוגמה זו, .[] מייצר את התוצאות 3, 2 ו-1, אז ההשפעה היא
דומה להפעלת משהו כזה:
0 | (3 בתור $item | . + $item) |
(2 בתור $item | . + $item) |
(1 בתור $item | . + $item)
jq 'הפחת .[] בתור $item (0; . + $item)'
[10,2,5,3]
=> 20
limit(n; exp)
אל האני להגביל פונקציות מחלצות עד n תפוקות מ exp.
jq '[limit(3;.[])]'
[0,1,2,3,4,5,6,7,8,9]
=> [0,1,2]
first(expr), last(expr), nth(n; expr)
אל האני first(expr) ו last(expr) פונקציות מחלצות את הערך הראשון והאחרון ביטוי,
בהתאמה.
אל האני nth(n; expr) הפונקציה מחלצת את הפלט של הערך ה-n על ידי ביטוי. ניתן להגדיר זאת כ
def nth(n; expr): last(limit(n + 1; expr));. שים לב ש nth(n; expr) לא תומך
ערכים שליליים של n.
jq '[first(range(.)), last(range(.)), nth(./2; range(.))]'
10
=> [0,9,5]
ראשון, אחרון, nth(n)
אל האני ראשון ו אחרון פונקציות מחלצות את הערך הראשון והאחרון מכל מערך ב ..
אל האני nth(n) הפונקציה מחלצת את הערך ה-n של כל מערך ב ..
jq ´[range(.)]|[ראשון, אחרון, נ '(5)]'
10
=> [0,9,5]
foreach
אל האני foreach תחביר דומה ל להפחית, אך נועד לאפשר בניית להגביל
ומפחיתים המייצרים תוצאות ביניים (ראה דוגמה).
הצורה היא foreach EXP as $ var (INIT; עדכון; לחלץ). כמו להפחית, INIT מוערך
פעם אחת כדי לייצר ערך מצב, ואז כל פלט של EXP מאוגד $ var, עדכון is
מוערך עבור כל פלט של EXP עם המצב הנוכחי ועם $ var גלוי. כל ערך
פלט על ידי עדכון מחליף את המצב הקודם. סוף כל סוף, EXTRACT מוערך עבור כל חדש
מצב לחלץ פלט של foreach.
זה שימושי בעיקר רק לבנייה להפחית- ו להגבילפונקציות כמו. אבל זה
הרבה יותר כללי, שכן הוא מאפשר הפחתה חלקית (ראה את הדוגמה למטה).
jq ´[foreach .[] בתור $item ([[],[]]; אם $item == null אז [[],.[0]] אחרת [(.[0] + [$item]),[ ]] סוף; אם $item == null אז .[1] אחרת סוף ריק)]´
[1,2,3,4,null,"a","b",null]
=> [[1,2,3,4],["a","b"]]
רקורסיה
כמתואר לעיל, להחזיר משתמש ברקורסיה, וכל פונקציית jq יכולה להיות רקורסיבית. ה
בזמן ה-buildin מיושם גם במונחים של רקורסיה.
שיחות זנב עוברות אופטימיזציה בכל פעם שהביטוי משמאל ליציאות השיחה הרקורסיבית
ערכו האחרון. בפועל זה אומר שהביטוי משמאל לרקורסיב
קריאה לא אמורה לייצר יותר מפלט אחד עבור כל קלט.
לדוגמה:
def recurse(f): def r: ., (f | select(. != null) | r); ר;
def while(cond; update):
def _while:
if cond then ., (עדכון | _while) אחרת סוף ריק;
_בזמן;
def repeat (exp):
def _repeat:
exp, _repeat;
_חזור;
גנרטורים ו איטרטורים
כמה אופרטורים ופונקציות jq הם למעשה מחוללים בכך שהם יכולים לייצר אפס,
ערך אחד או יותר עבור כל קלט, בדיוק כפי שניתן לצפות בתכנות אחר
שפות שיש בהן גנרטורים. לדוגמה, .[] יוצר את כל הערכים בקלט שלו
(שחייב להיות מערך או אובייקט), range(0; 10) יוצר את המספרים השלמים בין 0 ל
10, וכן הלאה.
אפילו אופרטור הפסיק הוא מחולל, שמייצר תחילה את הערכים שנוצרו על ידי
ביטוי משמאל לפסיק, ולאחר מכן עבור כל אחד מהם, הערכים שנוצרים על ידי ה-
ביטוי מימין לפסיק.
אל האני ריק ה-buildin הוא הגנרטור שמייצר אפס יציאות. ה ריק בנוי
חוזר לביטוי המחולל הקודם.
כל פונקציות jq יכולות להיות גנרטורים רק על ידי שימוש במחוללים מובנים. זה גם אפשרי
כדי להגדיר מחוללים חדשים באמצעות רקורסיה ואופרטור הפסיק. אם הרקורסיב
קריאה(ים) היא(נמצאת) "במצב זנב" ואז המחולל יהיה יעיל. בדוגמה
מתחת לקריאה רקורסיבית על ידי _טווח לעצמו הוא במצב זנב. הדוגמה מתבלטת
שלושה נושאים מתקדמים: רקורסיית זנב, בניית גנרטור ותת-פונקציות.
jq ´def range(init; upto; by): def _range: if (על ידי > 0 ו. < upto) או (על ידי < 0 ו. > upto) אז ., ((.+by)|_range) else . סוֹף; אם לפי == 0 אז init else init|_range end | select((על ידי > 0 ו. < עד) או (על ידי < 0 ו. > עד)); range(0; 10; 3)'
ריק
=> 0, 3, 6, 9
jq ´def while(cond; update): def _while: if cond then ., (עדכון | _while) else ריק אחר; _בזמן; [while(.<100; .*2)]'
1
=> [1,2,4,8,16,32,64]
MATH
ל-jq יש כרגע רק IEEE754 דיוק כפול (64 סיביות) מספרי נקודה צפה.
מלבד אופרטורים אריתמטיים פשוטים כגון +, ל-jq יש גם את רוב הפונקציות המתמטיות הסטנדרטיות
מספריית C מתמטיקה. C פונקציות מתמטיות שלוקחות ארגומנט קלט יחיד (למשל, חטא ())
זמינות כפונקציות jq אפס ארגומנט. C פונקציות מתמטיות שלוקחות שני קלט
טיעונים (למשל, פאו ()) זמינות כפונקציות jq דו-טיעונים שמתעלמות ..
זמינותן של פונקציות מתמטיות סטנדרטיות תלויה בזמינותן של התואמות
פונקציות מתמטיקה במערכת ההפעלה שלך ובספריית C מתמטיקה. פונקציות מתמטיקה לא זמינות
יוגדר אך יעלה שגיאה.
I / O
בשלב זה ל-jq יש תמיכה מינימלית ב-I/O, בעיקר בצורה של שליטה על מתי
כניסות נקראות. שתי פונקציות מובנות מסופקות לכך, קלט ו תשומות, שקרא
מאותם מקורות (למשל, סטדין, קבצים המכונים בשורת הפקודה) בתור jq עצמו. אלה
שני מובנים, ופעולות הקריאה של jq עצמו, יכולים להיות משולבים זה בזה.
אחד מובנה מספק יכולות פלט מינימליות, באגים. (זכור שתוכנית jq
ערכי פלט מופקים תמיד כטקסטים של JSON stdout.) ה באגים מובנה יכול להיות
התנהגות ספציפית ליישום, כגון עבור קובצי הפעלה המשתמשים ב-libjq C API אך אינם
קובץ ההפעלה jq עצמו.
קלט
מוציא קלט אחד חדש.
תשומות
מוציא את כל הכניסות הנותרות, אחת אחת.
זה שימושי בעיקר להפחתות ביחס לתשומות של תוכנית.
באגים
גורם להודעת ניפוי באגים המבוססת על ערך הקלט שיופק. קובץ ההפעלה jq עוטף
ערך הקלט עם ["לנפות:", ] ומדפיס את זה ושורה חדשה ב-stderr,
בצורה קומפקטית. זה עשוי להשתנות בעתיד.
input_filename
מחזירה את שם הקובץ שהקלט שלו מסונן כעת. שימו לב שזה יהיה
לא עובד טוב אלא אם כן jq פועל במקום UTF-8.
input_line_number
מחזירה את מספר השורה של הקלט המסונן כעת.
נהירה
עם --זרם option jq יכול לנתח טקסטים קלט בצורה סטרימינג, מה שמאפשר jq
תוכניות להתחיל לעבד טקסטים גדולים של JSON מיד ולא לאחר הניתוח
משלים. אם יש לך טקסט JSON יחיד בגודל 1GB, הזרמתו תאפשר לך
לעבד אותו הרבה יותר מהר.
עם זאת, זרימה לא קלה להתמודדות כפי שתהיה לתוכנית jq [ ,
] (ועוד כמה צורות) בתור תשומות.
מספר מבנים מסופקים כדי להקל על הטיפול בזרמים.
הדוגמאות שלהלן משתמשות בצורת הסטרימינג של [0,[1]], שהוא
[[0],0],[[1,0],1],[[1,0]],[[1]].
טפסי סטרימינג כוללים [ , ] (כדי לציין ערך סקלרי כלשהו, מערך ריק,
או חפץ ריק), ו [ ] (כדי לציין את הסוף של מערך או אובייקט). עתיד
גרסאות של jq פועלות עם --זרם ו -Seq עשוי להפיק טפסים נוספים כגון ["שְׁגִיאָה
הוֹדָעָה"] כאשר טקסט קלט לא מצליח לנתח.
truncate_stream(stream_expression)
צורכת מספר כקלט ומקצצת את המספר המתאים של רכיבי נתיב
בצד שמאל של הפלטים של ביטוי הסטרימינג הנתון.
jq ´[1|truncate_stream([[0],1],[[1,0],2],[[1,0]],[[1]])]´
1
=> [[[0],2],[[0]]]
fromstream(stream_expression)
פלט ערכים התואמים את הפלטים של ביטוי הזרם.
jq ´fromstream(1|truncate_stream([[0],1],[[1,0],2],[[1,0]],[[1]]))´
ריק
=> [2]
להזרים
אל האני להזרים מובנה מפלט את צורת הזרימה של הקלט שלו.
jq'. בתור $dot|fromstream($dot|tostream)|.==$dot´
[0,[1,{"a":1},{"b":2}]]
=> נכון
מְשִׁימָה
המשימה עובדת קצת אחרת ב-jq מאשר ברוב שפות התכנות. jq לא
להבחין בין הפניות למשהו והעתקים של משהו - שני אובייקטים או מערכים הם
שווה או לא שווה, בלי שום מושג נוסף של היותו "אותו אובייקט" או "לא".
אותו חפץ".
אם לאובייקט יש שני שדות שהם מערכים, .foo ו .בַּר, ואתה מצרף משהו ל
.foo, לאחר מכן .בַּר לא יגדל. גם אם רק הגדרת .בַּר = .foo. אם אתה רגיל
לתכנות בשפות כמו Python, Java, Ruby, Javascript וכו' אז אתה יכול לחשוב
שלו כאילו jq עושה עותק עמוק מלא של כל אובייקט לפני שהוא מבצע את ההקצאה
(לביצועים, זה לא באמת עושה את זה, אבל זה הרעיון הכללי).
לכל אופרטורי ההקצאה ב-jq יש ביטויי נתיב בצד שמאל.
=
הפילטר .foo = 1 ייקח כקלט אובייקט ויפיק כפלט אובייקט עם ה
שדה "foo" מוגדר ל-1. אין מושג של "שינוי" או "שינוי" משהו ב-jq -
כל ערכי jq אינם ניתנים לשינוי. לדוגמה,
.foo = .bar | .foo.baz = 1
לא תהיה תופעת הלוואי של הגדרת .bar.baz ל-1, כמו המראה הדומה
תוכנית ב-Javascript, Python, Ruby או שפות אחרות. בניגוד לשפות אלו (אבל
כמו Haskell ושפות פונקציונליות אחרות), אין מושג של שני מערכים או
אובייקטים שהם "אותו מערך" או "אותו אובייקט". הם יכולים להיות שווים, או לא שווים, אבל
אם נשנה אחד מהם בשום פנים ואופן לא ישתנה השני מאחורי הגב שלנו.
משמעות הדבר היא שאי אפשר לבנות ערכים מעגליים ב-jq (כגון מערך שלו
האלמנט הראשון הוא עצמו). זה די מכוון, ומבטיח שכל דבר הוא jq
תוכנית יכולה לייצר יכולה להיות מיוצגת ב-JSON.
שים לב שהצד השמאלי של '=' מתייחס לערך ב .. כך $var.foo = 1 לא יעבוד
כצפוי ($var.foo אינו ביטוי נתיב חוקי או שימושי ב .); להשתמש $ var | .foo = 1
במקום.
אם הצד הימני של '=' מייצר מספר ערכים, אז עבור כל ערך כזה יעשה jq
הגדר את הנתיבים בצד שמאל לערך ואז זה יוציא את השינוי ..
לדוגמה, (.a,.b)=רכס(2) פלטים {"a":0,"b":0}, לאחר מכן {"a":1,"b":1}. העדכון"
טפסי הקצאה (ראה להלן) אינם עושים זאת.
שימו לב גם לזה .a,.b=0 אינו קובע .a ו .b, אבל (.a,.b)=0 קובע את שניהם.
|=
בנוסף לאופרטור ההקצאה ´=´, jq מספק את האופרטור "עדכון" ´|=´, אשר
לוקח מסנן בצד ימין ומחשב את הערך החדש עבור הנכס של .
מוקצה על ידי הפעלת הערך הישן דרך ביטוי זה. לדוגמה, .foo |=
.+1 יבנה אובייקט כאשר השדה "foo" מוגדר ל-"foo" של הקלט פלוס 1.
דוגמה זו אמורה להראות את ההבדל בין ´=´ ל-´|=´:
ספק קלט '{"a": {"b": 10}, "b": 20}' לתוכניות:
.a = .b .a |= .ב
הראשון יקבע את שדה "a" של הקלט לשדה "b" של הקלט, וייצור
הפלט {"a": 20}. האחרון יגדיר את שדה "a" של הקלט לשדה "a".
שדה "b", המפיק {"a": 10}.
הצד השמאלי יכול להיות כל ביטוי נתיב כללי; לִרְאוֹת נָתִיב().
שים לב שהצד השמאלי של '|=' מתייחס לערך ב .. כך $var.foo |= . + 1 רָגִיל
לעבוד כמצופה ($var.foo אינו ביטוי נתיב חוקי או שימושי ב .); להשתמש $ var | .foo
|= . + 1 במקום.
אם הצד הימני מוציא מספר ערכים, רק האחרון ישמש.
jq ´(..|select(type=="boolean")) |= if . ואז 1 אחר 0 סוף´
[true,false,[5,true,[true,[false]],false]]
=> [1,0,[5,1,[1,[0]],0]]
+=, -=, *=, /=, %=, // =
ל-jq יש כמה אופרטורים של הטופס a אופ = b, שכולם שוות ערך ל a |= . op b. לכן,
+= 1 ניתן להשתמש כדי להגדיל ערכים.
jq ´.foo += 1´
{"foo": 42}
=> {"foo": 43}
מורכב הקצאות
הרבה יותר דברים מותרים בצד שמאל של הקצאת jq מאשר ברובם
שפות. כבר ראינו גישה פשוטה לשדה בצד שמאל, וזה לא
מפתיע שגישות למערך עובדות באותה מידה:
.posts[0].title = "JQ Manual"
מה שעלול להפתיע הוא שהביטוי משמאל עשוי לייצר מרובים
תוצאות, בהתייחס לנקודות שונות במסמך הקלט:
.posts[].comments |= . + ["זה נהדר"]
הדוגמה הזו מצרפת את המחרוזת "זה נהדר" למערך ה"תגובות" של כל פוסט ב
הקלט (כאשר הקלט הוא אובייקט עם שדה "פוסטים" שהוא מערך של פוסטים).
כאשר jq נתקל בהקצאה כמו ´a = b´, הוא מתעד את ה"נתיב" שנלקח לבחירת
חלק ממסמך הקלט בזמן ביצוע א. נתיב זה משמש לאחר מכן כדי למצוא באיזה חלק
הקלט לשינוי בזמן ביצוע ההקצאה. ניתן להשתמש בכל מסנן על
צד שמאל של שווה - הנתיבים שהוא בוחר מהקלט יהיה היכן שה-
המשימה מתבצעת.
זו פעולה חזקה מאוד. נניח שרצינו להוסיף הערה לפוסטים בבלוג, באמצעות
אותו קלט "בלוג" למעלה. הפעם, אנחנו רוצים להגיב רק על הפוסטים שנכתבו על ידי
"סטדולן". אנו יכולים למצוא את הפוסטים הללו באמצעות הפונקציה "בחר" שתוארה קודם לכן:
.פוסטים[] | select(.author == "stedolan")
הנתיבים שמספקת פעולה זו מצביעים על כל אחד מהפוסטים ש"שטולאן" כתב, ו
אנחנו יכולים להגיב על כל אחד מהם באותה דרך שהגענו בעבר:
(.posts[] | select(.author == "stedolan") | .comments) |=
. + ["נורא."]
מודולים
ל-jq יש מערכת ספרייה/מודולים. מודולים הם קבצים ששמותיהם מסתיימים ב .jq.
מודולים המיובאים על ידי תוכנית מחפשים בנתיב חיפוש ברירת מחדל (ראה להלן). ה
לייבא ו לכלול ההנחיות מאפשרות ליבואן לשנות נתיב זה.
נתיבים בנתיב החיפוש כפופים להחלפות שונות.
עבור נתיבים המתחילים ב-"~/", ספריית הבית של המשתמש מוחלף ב-"~".
עבור נתיבים המתחילים ב-"$ORIGIN/", הנתיב של קובץ ההפעלה jq מוחלף
"$ORIGIN".
עבור נתיבים המתחילים ב-"./" או נתיבים שהם ".", הנתיב של הקובץ הכולל הוא
החליף ".". עבור תוכניות ברמה העליונה הניתנות בשורת הפקודה, הנוכחי
נעשה שימוש בספרייה.
הנחיות ייבוא יכולות לציין נתיב חיפוש שאליו מצורפת ברירת המחדל.
נתיב החיפוש המוגדר כברירת מחדל הוא נתיב החיפוש שניתן ל- -L אפשרות שורת פקודה, אחר
["~/.jq", "$ORIGIN/../lib/jq", "$ORIGIN/../ lib"].
רכיבי נתיב מחרוזת ריק וריקים מפסיקים את עיבוד נתיב החיפוש.
תלות עם נתיב יחסי "foo/bar" יחפש ב-"foo/bar.jq" ו-
"foo/bar/bar.jq" בנתיב החיפוש הנתון. זה נועד לאפשר הצבת מודולים
בספרייה יחד עם, למשל, קבצי בקרת גרסאות, קבצי README וכן הלאה,
אלא גם כדי לאפשר מודולים של קובץ בודד.
רכיבים עוקבים בעלי אותו שם אינם רשאים למנוע אי בהירות (למשל,
"פו/פו").
לדוגמה, עם -L$HOME/.jq מודול Foo ניתן למצוא $HOME/.jq/foo.jq ו
$HOME/.jq/foo/foo.jq.
אם "$HOME/.jq" הוא קובץ, מקורו בתוכנית הראשית.
לייבא RelativePathString as שֵׁם [ ];
מייבא מודול שנמצא בנתיב הנתון ביחס לספרייה בנתיב חיפוש. ".jq"
סיומת תתווסף למחרוזת הנתיב היחסית. הסמלים של המודול הם קידומת של
"שֵׁם::".
המטא-נתונים האופציונליים חייבים להיות ביטוי jq קבוע. זה צריך להיות חפץ עם מפתחות
כמו "דף הבית" וכן הלאה. בשלב זה jq משתמש רק במפתח/ערך "חיפוש" של ה-
מטא נתונים. המטא-נתונים זמינים גם למשתמשים דרך ה modulemeta מובנה.
למפתח "חיפוש" במטא נתונים, אם קיים, צריך להיות מחרוזת או ערך מערך (מערך
של מיתרים); זהו נתיב החיפוש שיתחיל בנתיב החיפוש ברמה העליונה.
לכלול RelativePathString [ ];
מייבא מודול שנמצא בנתיב הנתון ביחס לספרייה בנתיב חיפוש כאילו הוא
נכללו במקום. סיומת ".jq" תתווסף למחרוזת הנתיב היחסית. ה
הסמלים של המודול מיובאים למרחב השמות של המתקשר כאילו יש לתוכן המודול
נכלל ישירות.
המטא-נתונים האופציונליים חייבים להיות ביטוי jq קבוע. זה צריך להיות חפץ עם מפתחות
כמו "דף הבית" וכן הלאה. בשלב זה jq משתמש רק במפתח/ערך "חיפוש" של ה-
מטא נתונים. המטא-נתונים זמינים גם למשתמשים דרך ה modulemeta מובנה.
לייבא RelativePathString as $NAME [ ];
מייבא קובץ JSON שנמצא בנתיב הנתון ביחס לספרייה בנתיב חיפוש. א
סיומת ".json" תתווסף למחרוזת הנתיב היחסית. הנתונים של הקובץ יהיו
זמין כ $NAME::NAME.
המטא-נתונים האופציונליים חייבים להיות ביטוי jq קבוע. זה צריך להיות חפץ עם מפתחות
כמו "דף הבית" וכן הלאה. בשלב זה jq משתמש רק במפתח/ערך "חיפוש" של ה-
מטא נתונים. המטא-נתונים זמינים גם למשתמשים דרך ה modulemeta מובנה.
למפתח "חיפוש" במטא נתונים, אם קיים, צריך להיות מחרוזת או ערך מערך (מערך
של מיתרים); זהו נתיב החיפוש שיתחיל בנתיב החיפוש ברמה העליונה.
מודול ;
הנחיה זו היא אופציונלית לחלוטין. זה לא הכרחי לפעולה תקינה. זה משמש
רק המטרה של אספקת מטא נתונים שניתן לקרוא עם modulemeta מובנה.
המטא-נתונים חייבים להיות ביטוי jq קבוע. זה צריך להיות חפץ עם מפתחות כמו
"דף הבית". בשלב זה jq אינו משתמש במטא נתונים אלה, אך הם זמינים למשתמשים
באמצעות modulemeta מובנה.
modulemeta
לוקח שם מודול כקלט ומוציא את המטא נתונים של המודול כאובייקט, עם ה-
הייבוא של המודול (כולל מטא נתונים) כערך מערך עבור מפתח "deps".
תוכניות יכולות להשתמש בזה כדי לבצע שאילתות למטא-נתונים של מודול, אשר לאחר מכן הם יוכלו להשתמש בהם
לדוגמה, חפש, הורד והתקן תלות חסרות.
השתמש ב-jq באינטרנט באמצעות שירותי onworks.net
