अंग्रेज़ीफ्रेंचस्पेनिश

सर्वर चलाएं | Ubuntu > | Fedora > |


ऑनवर्क्स फ़ेविकॉन

jq - क्लाउड में ऑनलाइन

उबंटू ऑनलाइन, फेडोरा ऑनलाइन, विंडोज ऑनलाइन एमुलेटर या मैक ओएस ऑनलाइन एमुलेटर पर ऑनवर्क्स मुफ्त होस्टिंग प्रदाता में जेक्यू चलाएं

यह कमांड jq है जिसे हमारे कई मुफ्त ऑनलाइन वर्कस्टेशन जैसे कि उबंटू ऑनलाइन, फेडोरा ऑनलाइन, विंडोज ऑनलाइन एमुलेटर या मैक ओएस ऑनलाइन एमुलेटर में से एक का उपयोग करके ऑनवर्क्स फ्री होस्टिंग प्रदाता में चलाया जा सकता है।

कार्यक्रम:

नाम


jq - कमांड लाइन JSON प्रोसेसर

SYNOPSIS


jq [विकल्पों...] फ़िल्टर [फ़ाइलों...]

jq JSON को विभिन्न तरीकों से बदल सकता है, चयन करके, पुनरावृति, कम करके और अन्यथा
JSON दस्तावेज़ों को मैनेज करना। उदाहरण के लिए, कमांड चलाना jq मैप (.कीमत) | जोड़ें मर्जी
इनपुट के रूप में JSON ऑब्जेक्ट्स की एक सरणी लें और उनके "कीमत" फ़ील्ड का योग वापस करें।

jq टेक्स्ट इनपुट को भी स्वीकार कर सकते हैं, लेकिन डिफ़ॉल्ट रूप से, jq JSON संस्थाओं की एक धारा पढ़ता है
(संख्याओं और अन्य शाब्दिकों सहित) से stdin. व्हॉट्सएप को केवल अलग करने की आवश्यकता है
1 और 2 जैसी इकाइयाँ, और सत्य और असत्य। एक या अधिक फ़ाइलों निर्दिष्ट किया जा सकता है, जिसमें
मामला jq इसके बजाय उनसे इनपुट पढ़ेगा।

RSI विकल्पों में वर्णित हैं प्रेरक JQ अनुभाग; वे ज्यादातर इनपुट और आउटपुट से संबंधित हैं
स्वरूपण। फ़िल्टर jq भाषा में लिखा गया है और निर्दिष्ट करता है कि कैसे बदलना है
इनपुट फ़ाइल या दस्तावेज़।

फिल्टर


एक jq प्रोग्राम एक "फ़िल्टर" है: यह एक इनपुट लेता है, और एक आउटपुट उत्पन्न करता है। वहां अत्यधिक हैं
किसी ऑब्जेक्ट के किसी विशेष फ़ील्ड को निकालने, या किसी संख्या को में कनवर्ट करने के लिए बिल्टिन फ़िल्टर
एक स्ट्रिंग, या विभिन्न अन्य मानक कार्य।

फिल्टर को विभिन्न तरीकों से जोड़ा जा सकता है - आप एक फिल्टर के आउटपुट को पाइप कर सकते हैं
एक अन्य फ़िल्टर, या किसी फ़िल्टर के आउटपुट को एक सरणी में एकत्रित करें।

कुछ फ़िल्टर अनेक परिणाम उत्पन्न करते हैं, उदाहरण के लिए, एक ऐसा है जो सभी परिणाम देता है
इसके इनपुट सरणी के तत्व। उस फ़िल्टर को एक सेकंड में डालने से दूसरा फ़िल्टर चलता है
सरणी के प्रत्येक तत्व। आम तौर पर, चीजें जो लूप और पुनरावृत्ति के साथ की जाएंगी
अन्य भाषाओं में jq में एक साथ फ़िल्टर ग्लूइंग करके किया जाता है।

यह याद रखना महत्वपूर्ण है कि प्रत्येक फ़िल्टर में एक इनपुट और एक आउटपुट होता है। यहां तक ​​कि शाब्दिक
जैसे "हैलो" या 42 फ़िल्टर हैं - वे एक इनपुट लेते हैं लेकिन हमेशा वही शाब्दिक उत्पादन करते हैं जैसे
आउटपुट संचालन जो दो फिल्टर को मिलाते हैं, जैसे जोड़, आम तौर पर एक ही इनपुट को फीड करते हैं
दोनों के लिए और परिणामों को मिलाएं। तो, आप एक औसत फ़िल्टर को इस प्रकार कार्यान्वित कर सकते हैं: जोड़ना / लंबाई
- दोनों को इनपुट ऐरे को फीड करना जोड़ना फिल्टर और लंबाई फ़िल्टर करें और फिर प्रदर्शन करें
विभाजन।

लेकिन वह खुद से आगे हो रहा है। :) आइए कुछ आसान से शुरू करते हैं:

प्रेरक JQ


jq फ़िल्टर JSON डेटा की स्ट्रीम पर चलते हैं। jq के इनपुट को के अनुक्रम के रूप में पार्स किया जाता है
व्हॉट्सएप से अलग किए गए JSON मान जो दिए गए फ़िल्टर के माध्यम से a . पर पारित किए जाते हैं
समय। फ़िल्टर के आउटपुट को मानक आउट पर फिर से के अनुक्रम के रूप में लिखा जाता है
व्हाइटस्पेस से अलग JSON डेटा।

नोट: शेल के उद्धरण नियमों को ध्यान में रखना महत्वपूर्ण है। एक सामान्य नियम के रूप में यह सबसे अच्छा है
हमेशा jq प्रोग्राम को (एकल-उद्धरण वर्णों के साथ) उद्धृत करें, साथ ही बहुत से वर्ण
jq के लिए विशेष अर्थ शेल मेटा-कैरेक्टर भी हैं। उदाहरण के लिए, jq "फू" विफल हो जाएगा
अधिकांश यूनिक्स गोले क्योंकि यह वही होगा jq foo, जो आम तौर पर विफल हो जाएगा
क्योंकि foo is नहीं परिभाषित. विंडोज कमांड शेल (cmd.exe) का उपयोग करते समय यह सबसे अच्छा है
कमांड-लाइन पर दिए जाने पर अपने jq प्रोग्राम के चारों ओर दोहरे उद्धरण चिह्नों का उपयोग करें (इसके बजाय) -f
कार्यक्रम फाइल विकल्प), लेकिन फिर jq प्रोग्राम में डबल-कोट्स को बैकस्लैश एस्केपिंग की आवश्यकता होती है।

आप कुछ कमांड-लाइन का उपयोग करके प्रभावित कर सकते हैं कि jq कैसे अपने इनपुट और आउटपुट को पढ़ता और लिखता है
विकल्प हैं:

· --संस्करण:

jq संस्करण को आउटपुट करें और शून्य से बाहर निकलें।

· --seq:

उपयोग आवेदन/json-seq jq´s इनपुट . में JSON टेक्स्ट को अलग करने के लिए MIME टाइप स्कीम
और आउटपुट। इसका मतलब है कि एक ASCII RS (रिकॉर्ड सेपरेटर) वर्ण पहले मुद्रित होता है
आउटपुट पर प्रत्येक मान और प्रत्येक आउटपुट के बाद एक ASCII LF (लाइन फीड) मुद्रित किया जाता है। इनपुट
JSON पाठ जो पार्स करने में विफल होते हैं, उन्हें अनदेखा किया जाता है (लेकिन इसके बारे में चेतावनी दी जाती है), सभी को छोड़कर
अगले आरएस तक बाद के इनपुट। यह और भी बिना jq के आउटपुट को पार्स करता है
--seq विकल्प.

· --धारा:

स्ट्रीमिंग फैशन में इनपुट को पार्स करें, पथ और पत्ती मूल्यों के आउटपुट सरणी
(स्केलर और खाली सरणियाँ या खाली वस्तुएँ)। उदाहरण के लिए, "ए" हो जाता है [[],"ए"], तथा
[[],"ए", ["बी"]] हो जाता है [[0], []], [[1],"ए"], तथा [[1,0],"बी"].

यह बहुत बड़े इनपुट को प्रोसेस करने के लिए उपयोगी है। इसके साथ संयोजन में प्रयोग करें
छानना और को कम करने और प्रत्येक के लिए बड़े इनपुट को क्रमिक रूप से कम करने के लिए सिंटैक्स।

· --slurp/-s:

इनपुट में प्रत्येक JSON ऑब्जेक्ट के लिए फ़िल्टर चलाने के बजाय, संपूर्ण इनपुट पढ़ें
एक बड़े सरणी में स्ट्रीम करें और फ़िल्टर को केवल एक बार चलाएँ।

· --कच्चे इनपुट/-R:

इनपुट को JSON के रूप में पार्स न करें। इसके बजाय, पाठ की प्रत्येक पंक्ति फ़िल्टर को a . के रूप में पास की जाती है
डोरी। अगर के साथ संयुक्त --slurp, फिर संपूर्ण इनपुट फ़िल्टर को a . के रूप में पास किया जाता है
एकल लंबी स्ट्रिंग।

· --नल-इनपुट/-n:

कोई भी इनपुट बिल्कुल न पढ़ें! इसके बजाय, फ़िल्टर एक बार उपयोग करके चलाया जाता है रिक्त इनपुट के रूप में।
एक साधारण कैलकुलेटर के रूप में jq का उपयोग करते समय या से JSON डेटा का निर्माण करते समय यह उपयोगी होता है
खरोंच।

· --कॉम्पैक्ट-आउटपुट / -c:

डिफ़ॉल्ट रूप से, jq जेएसओएन आउटपुट को सुंदर-प्रिंट करता है। इस विकल्प का उपयोग करने से परिणाम अधिक होगा
प्रत्येक JSON ऑब्जेक्ट को एक लाइन पर रखने के बजाय कॉम्पैक्ट आउटपुट।

· --टैब:

प्रत्येक इंडेंटेशन स्तर के लिए दो रिक्त स्थान के बजाय एक टैब का उपयोग करें।

· --इंडेंट n:

इंडेंटेशन के लिए दिए गए रिक्त स्थान (8 से अधिक नहीं) का उपयोग करें।

· --रंग-आउटपुट / -C और --मोनोक्रोम-आउटपुट / -M:

डिफ़ॉल्ट रूप से, jq टर्मिनल पर लिखते समय रंगीन JSON आउटपुट करता है। आप इसे मजबूर कर सकते हैं
एक पाइप या फ़ाइल का उपयोग करके लिखने पर भी रंग उत्पन्न करें -C, और रंग अक्षम करें -M.

· --ascii-आउटपुट / -a:

jq आमतौर पर गैर-ASCII यूनिकोड कोडपॉइंट को UTF-8 के रूप में आउटपुट करता है, भले ही इनपुट निर्दिष्ट हो
उन्हें एस्केप सीक्वेंस के रूप में (जैसे "\u03bc")। इस विकल्प का उपयोग करके, आप jq को के लिए बाध्य कर सकते हैं
समकक्ष के साथ प्रतिस्थापित प्रत्येक गैर-ASCII वर्ण के साथ शुद्ध ASCII आउटपुट उत्पन्न करें
निकास का क्रम।

· --अनबफर्ड

प्रत्येक JSON ऑब्जेक्ट के प्रिंट होने के बाद आउटपुट को फ्लश करें (उपयोगी यदि आप धीमी गति से पाइप कर रहे हैं
डेटा स्रोत jq में और पाइपिंग jq´s आउटपुट कहीं और)।

· --सॉर्ट-कुंजी / -S:

प्रत्येक ऑब्जेक्ट के फ़ील्ड को क्रमबद्ध क्रम में कुंजियों के साथ आउटपुट करें।

· --रॉ-आउटपुट / -r:

इस विकल्प के साथ, यदि फ़िल्टर का परिणाम एक स्ट्रिंग है तो इसे सीधे लिखा जाएगा
कोट्स के साथ JSON स्ट्रिंग के रूप में स्वरूपित होने के बजाय मानक आउटपुट के लिए। यह हो सकता है
jq फ़िल्टर को गैर-JSON-आधारित सिस्टम से बात करने के लिए उपयोगी बनाएं।

· --जॉइन-आउटपुट / -j:

पसंद -r लेकिन jq प्रत्येक आउटपुट के बाद एक नई लाइन प्रिंट नहीं करेगा।

· -f फ़ाइल का नाम / --लेख्यपत्र से फ़ाइल का नाम:

कमांड लाइन के बजाय फ़ाइल से फ़िल्टर पढ़ें, जैसे awk´s -f विकल्प। आप
टिप्पणी करने के लिए ´#´ का भी उपयोग कर सकते हैं।

· -एलनिर्देशिका / -L डायरेक्टरी:

प्रारंभ में लगा डायरेक्टरी मॉड्यूल के लिए खोज सूची में। यदि इस विकल्प का उपयोग किया जाता है तो नहीं
बिल्टिन खोज सूची का उपयोग किया जाता है। नीचे मॉड्यूल पर अनुभाग देखें।

· -e / --निकास-स्थिति:

यदि अंतिम आउटपुट मान न तो था, तो jq की निकास स्थिति को 0 पर सेट करता है असत्यरिक्त,
1 यदि अंतिम आउटपुट मान या तो था असत्य or रिक्त, या 4 यदि कोई वैध परिणाम कभी नहीं था
उत्पादित। यदि कोई उपयोग समस्या या सिस्टम त्रुटि थी, तो आम तौर पर jq 2 से बाहर निकलता है, 3
अगर कोई jq प्रोग्राम कंपाइल एरर था, या 0 अगर jq प्रोग्राम चलता था।

· --आर्ग नाम मूल्य:

यह विकल्प jq प्रोग्राम के लिए एक पूर्वनिर्धारित चर के रूप में एक मान पास करता है। यदि आप jq . चलाते हैं
साथ में --आर्ग foo बार, तो $फू कार्यक्रम में उपलब्ध है और इसका मूल्य है "बार".
ध्यान दें कि मूल्य एक स्ट्रिंग के रूप में माना जाएगा, इसलिए --आर्ग foo 123 बांध देंगे $फू सेवा मेरे "123".

· --argjson नाम JSON-पाठ:

यह विकल्प एक JSON-एन्कोडेड मान को jq प्रोग्राम में एक पूर्वनिर्धारित चर के रूप में पास करता है। अगर
आप के साथ jq चलाते हैं --argjson foo 123, तो $फू कार्यक्रम में उपलब्ध है और है
मूल्य 123.

· --slurpfile चर का नाम फ़ाइल का नाम:

यह विकल्प नामित फ़ाइल में सभी JSON ग्रंथों को पढ़ता है और एक सरणी को बांधता है
दिए गए वैश्विक चर के लिए JSON मानों को पार्स किया। यदि आप jq के साथ चलाते हैं --argfile foo बार,
फिर $फू कार्यक्रम में उपलब्ध है और इसमें एक सरणी है जिसके तत्व के अनुरूप हैं
नाम की फ़ाइल में ग्रंथ बार.

· --argfile चर का नाम फ़ाइल का नाम:

उपयोग नहीं करो। उपयोग --slurpfile बजाय.

(यह विकल्प इस प्रकार है --slurpfile, लेकिन जब फ़ाइल में केवल एक टेक्स्ट हो, तो वह है
उपयोग किया जाता है, अन्यथा ग्रंथों की एक सरणी का उपयोग in . के रूप में किया जाता है --slurpfile.)

· --रन-परीक्षण [फ़ाइल का नाम]:

दी गई फ़ाइल या मानक इनपुट में परीक्षण चलाता है। यह दिया गया अंतिम विकल्प होना चाहिए
और सभी पूर्ववर्ती विकल्पों का सम्मान नहीं करता है। इनपुट में टिप्पणी पंक्तियाँ होती हैं, खाली
लाइन, और प्रोग्राम लाइन के बाद एक इनपुट लाइन, जितनी आउटपुट की लाइनें हैं
अपेक्षित (एक प्रति आउटपुट), और एक समाप्ति खाली लाइन। संकलन विफलता परीक्षण
केवल "%%FAIL" वाली लाइन से शुरू करें, फिर प्रोग्राम वाली एक लाइन to
संकलित करें, फिर वास्तविक से तुलना करने के लिए एक त्रुटि संदेश वाली एक पंक्ति।

सावधान रहें कि यह विकल्प पीछे की ओर-असंगत रूप से बदल सकता है।

बुनियादी फिल्टर


.
सबसे सरल (और कम से कम दिलचस्प) फ़िल्टर है .. यह एक फिल्टर है जो इसे लेता है
इनपुट और इसे आउटपुट के रूप में अपरिवर्तित करता है।

चूंकि jq डिफ़ॉल्ट रूप से सभी आउटपुट को सुंदर-प्रिंट करता है, इसलिए यह छोटा प्रोग्राम एक उपयोगी तरीका हो सकता है
जेएसओएन आउटपुट स्वरूपण, कहें, कर्ल.

जेक्यू .´
"नमस्ते दुनिया!"
=> "नमस्ते, दुनिया!"

.फू, .फू.बार
सबसे आसान उपयोगी फिल्टर है .फू. जब एक JSON ऑब्जेक्ट (उर्फ डिक्शनरी या हैश) दिया जाता है
इनपुट, यह "फू" कुंजी पर मान उत्पन्न करता है, या यदि कोई मौजूद नहीं है तो शून्य।

यदि कुंजी में विशेष वर्ण हैं, तो आपको इसे दोहरे उद्धरण चिह्नों से घेरना होगा जैसे
इस: "फू$".

प्रपत्र का एक फ़िल्टर .फू.बार के बराबर है .foo|.bar.

jq .foo´
{"फू": 42, "बार": "कम दिलचस्प डेटा"}
=> २

jq .foo´
{"notfoo": सच, "alsonotfoo": झूठा}
=> शून्य

जेक्यू .["फू"]´
{"फू": 42}
=> २

.फू?
बिलकुल इसके जैसा .फू, लेकिन एक त्रुटि भी आउटपुट नहीं करता है जब . एक सरणी या वस्तु नहीं है।

jq .foo?´
{"फू": 42, "बार": "कम दिलचस्प डेटा"}
=> २

jq .foo?´
{"notfoo": सच, "alsonotfoo": झूठा}
=> शून्य

jq .["foo"]?´
{"फू": 42}
=> २

jq [.foo?]´
[1,2]
=> []

.[ ], [2], [10:15]
आप सिंटैक्स का उपयोग करके किसी ऑब्जेक्ट के फ़ील्ड भी देख सकते हैं जैसे ["फू"] (.foo ऊपर है a
इसका शॉर्टहैंड संस्करण)। यदि कुंजी एक पूर्णांक है, तो यह सरणी के लिए भी काम करता है।
Arrays शून्य-आधारित हैं (जैसे जावास्क्रिप्ट), इसलिए . [2] सरणी का तीसरा तत्व लौटाता है।

RSI [10:15] सिंटैक्स का उपयोग किसी सरणी के उप-सरणी या स्ट्रिंग के सबस्ट्रिंग को वापस करने के लिए किया जा सकता है।
सरणी द्वारा लौटाया गया [10:15] लंबाई 5 की होगी, जिसमें अनुक्रमणिका 10 . के तत्व शामिल होंगे
(समावेशी) से सूचकांक 15 (अनन्य) तक। कोई भी सूचकांक ऋणात्मक हो सकता है (जिस स्थिति में यह मायने रखता है
सरणी के अंत से पीछे की ओर), या छोड़ा गया (जिस स्थिति में यह प्रारंभ को संदर्भित करता है या
सरणी का अंत)।

RSI . [2] दिए गए इंडेक्स पर तत्व को वापस करने के लिए सिंटैक्स का उपयोग किया जा सकता है। नकारात्मक सूचकांक हैं
अनुमति है, -1 अंतिम तत्व का जिक्र करते हुए, -2 अगले से अंतिम तत्व का जिक्र करते हुए,
और इतना पर.

RSI .फू सिंटैक्स केवल कुंजियों के लिए काम करता है यानी सभी अल्फ़ान्यूमेरिक वर्ण वाली कुंजियाँ।
.[ ] उन कुंजियों के साथ काम करता है जिनमें विशेष वर्ण जैसे कोलन और डॉट्स होते हैं। के लिये
उदाहरण .["फू :: बार"] और .["फू.बार"] काम करते समय .foo::bar और .फू.बार नहीं होगा।

RSI ? "ऑपरेटर" का उपयोग स्लाइस ऑपरेटर के साथ भी किया जा सकता है, जैसा कि in [10:15]?, जो आउटपुट
वे मान जहां इनपुट स्लाइस-सक्षम हैं।

जेक्यू .[0]´
[{"नाम": "JSON", "अच्छा": सच}, {"नाम": "XML", "अच्छा": झूठा}]
=> {"नाम": "JSON", "अच्छा": सच}

जेक्यू .[2]´
[{"नाम": "JSON", "अच्छा": सच}, {"नाम": "XML", "अच्छा": झूठा}]
=> शून्य

जेक्यू . [2:4]´
["ए", "बी", "सी", "डी", "ई"]
=> ["सी", "डी"]

जेक्यू . [2:4]´
"abcdefghi"
=> "सीडी"

जेक्यू .[:3]´
["ए", "बी", "सी", "डी", "ई"]
=> ["ए", "बी", "सी"]

जेक्यू .[-2:]´
["ए", "बी", "सी", "डी", "ई"]
=> ["डी", "ई"]

जेक्यू .[-2]´
[1,2,3]
=> २

.[]
यदि आप उपयोग करते हैं ।[अनुक्रमणिका] सिंटैक्स, लेकिन इंडेक्स को पूरी तरह से छोड़ दें, यह वापस आ जाएगा सब का
एक सरणी के तत्व। दौड़ना .[] इनपुट के साथ [1,2,3] संख्याओं को तीन . के रूप में उत्पन्न करेगा
अलग परिणाम, बजाय एक सरणी के रूप में।

आप इसे किसी ऑब्जेक्ट पर भी इस्तेमाल कर सकते हैं, और यह ऑब्जेक्ट के सभी मान वापस कर देगा।

जेक्यू .[]´
[{"नाम": "JSON", "अच्छा": सच}, {"नाम": "XML", "अच्छा": झूठा}]
=> {"नाम": "JSON", "अच्छा": सच}, {"नाम": "XML", "अच्छा": झूठा}

जेक्यू .[]´
[]
=>

जेक्यू .[]´
{"ए": 1, "बी": 1}
=> 1, 1

.[]?
पसंद .[], लेकिन कोई त्रुटि आउटपुट नहीं होगी यदि . एक सरणी या वस्तु नहीं है।

,
यदि दो फ़िल्टर अल्पविराम द्वारा अलग किए जाते हैं, तो इनपुट को और वहां दोनों में फीड किया जाएगा
कई आउटपुट होंगे: सबसे पहले, बाएं अभिव्यक्ति द्वारा उत्पादित सभी आउटपुट, और
फिर दाईं ओर से उत्पादित सभी आउटपुट। उदाहरण के लिए, फ़िल्टर .फू, .Cafe, पैदा करता है
दोनों "फू" फ़ील्ड और "बार" फ़ील्ड अलग-अलग आउटपुट के रूप में।

jq .foo, .bar´
{"फू": 42, "बार": "कुछ और", "बाज": सच}
=> 42, "कुछ और"

jq .user, .projects[]´
{"उपयोगकर्ता":"स्टेडोलन", "प्रोजेक्ट": ["jq", "विकीफ्लो"]}
=> "स्टेडोलन", "जेक्यू", "विकीफ्लो"

जेक्यू .[4,2]´
["ए", "बी", "सी", "डी", "ई"]
=> "ई", "सी"

|
| ऑपरेटर बाईं ओर एक के आउटपुट को फीड करके दो फिल्टर को जोड़ता है
दाईं ओर एक का इनपुट। यह काफी हद तक यूनिक्स शेल के पाइप के समान है, अगर
आप इसके अभ्यस्त हैं।

यदि बाईं ओर वाला एकाधिक परिणाम देता है, तो दाईं ओर वाले के लिए चलाया जाएगा
उन परिणामों में से प्रत्येक। तो, अभिव्यक्ति .[] | .फू प्रत्येक का "foo" फ़ील्ड पुनर्प्राप्त करता है
इनपुट सरणी का तत्व।

जेक्यू .[] | ।नाम
[{"नाम": "JSON", "अच्छा": सच}, {"नाम": "XML", "अच्छा": झूठा}]
=> "JSON", "XML"

प्रकार और मान


jq JSON के समान डेटाटाइप के सेट का समर्थन करता है - संख्याएं, तार, बूलियन, सरणियाँ,
ऑब्जेक्ट्स (जो जेएसओएन-स्पीक में केवल स्ट्रिंग कुंजियों के साथ हैश हैं), और "शून्य"।

बूलियन, नल, तार और संख्याएं उसी तरह लिखी जाती हैं जैसे जावास्क्रिप्ट में। बिलकुल इसके जैसा
jq में बाकी सब कुछ, ये साधारण मान एक इनपुट लेते हैं और एक आउटपुट उत्पन्न करते हैं - 42 एक
मान्य jq व्यंजक जो एक इनपुट लेता है, उसे अनदेखा करता है, और इसके बजाय 42 देता है।

ऐरे निर्माण - []
जैसा कि JSON में है, [] सरणियों के निर्माण के लिए प्रयोग किया जाता है, जैसा कि in [1,2,3]. सरणियों के तत्व कर सकते हैं
कोई jq अभिव्यक्ति हो। सभी भावों द्वारा उत्पन्न सभी परिणाम एकत्रित किए जाते हैं
एक बड़े सरणी में। आप इसका उपयोग मानों की ज्ञात मात्रा से एक सरणी बनाने के लिए कर सकते हैं
(जैसे की [.फू, ।छड़, .बाज]) या फ़िल्टर के सभी परिणामों को एक सरणी में "एकत्रित" करने के लिए (as .)
in [.आइटम []। नाम])

एक बार जब आप "," ऑपरेटर को समझ लेते हैं, तो आप jq के सरणी सिंटैक्स को एक अलग में देख सकते हैं
प्रकाश: अभिव्यक्ति [1,2,3] अल्पविराम से अलग किए गए सरणियों के लिए अंतर्निहित सिंटैक्स का उपयोग नहीं कर रहा है,
लेकिन इसके बजाय लागू कर रहा है [] अभिव्यक्ति 1,2,3 (जो .) के लिए ऑपरेटर (परिणाम एकत्र करें)
तीन अलग-अलग परिणाम उत्पन्न करता है)।

यदि आपके पास फ़िल्टर है X जो चार परिणाम उत्पन्न करता है, फिर व्यंजक [X] एक उत्पादन होगा
एकल परिणाम, चार तत्वों की एक सरणी।

jq [.user, .projects[]]´
{"उपयोगकर्ता":"स्टेडोलन", "प्रोजेक्ट": ["jq", "विकीफ्लो"]}
=> ["स्टेडोलन", "जेक्यू", "विकीफ्लो"]

वस्तुएँ - {}
जेएसओएन की तरह, {} वस्तुओं (उर्फ शब्दकोश या हैश) के निर्माण के लिए है, जैसा कि: {"ए": 42,
"बी": 17}.

यदि कुंजियाँ "समझदार" (सभी वर्णमाला वर्ण) हैं, तो उद्धरणों को छोड़ा जा सकता है।
मान कोई भी व्यंजक हो सकता है (हालाँकि आपको इसे कोष्ठकों में लपेटने की आवश्यकता हो सकती है यदि यह sa . है)
जटिल एक), जो {} अभिव्यक्ति के इनपुट पर लागू हो जाता है (याद रखें, सभी फ़िल्टर
एक इनपुट और एक आउटपुट है)।

{फू: .बार}

JSON ऑब्जेक्ट का उत्पादन करेगा {"फू": 42} यदि JSON ऑब्जेक्ट दिया गया है {"बार":42, "बाज़":43}.
आप इसका उपयोग किसी वस्तु के विशेष क्षेत्रों का चयन करने के लिए कर सकते हैं: यदि इनपुट एक वस्तु है
"उपयोगकर्ता", "शीर्षक", "आईडी", और "सामग्री" फ़ील्ड और आप बस "उपयोगकर्ता" और "शीर्षक" चाहते हैं, आप कर सकते हैं
लिखना

{उपयोगकर्ता: .उपयोगकर्ता, शीर्षक: .शीर्षक}

क्योंकि यह बहुत आम है, एक शॉर्टकट सिंटैक्स है: {उपयोगकर्ता, शीर्षक}.

यदि कोई एक व्यंजक अनेक परिणाम उत्पन्न करता है, तो अनेक शब्दकोश होंगे
उत्पादित। यदि इनपुट s

{"उपयोगकर्ता":"स्टेडोलन",,"शीर्षक":["जेक्यू प्राइमर", "मोर जेक्यू"]}

फिर अभिव्यक्ति

{उपयोगकर्ता, शीर्षक: .शीर्षक []}

दो आउटपुट देगा:

{"उपयोगकर्ता":"स्टेडोलन", "शीर्षक": "जेक्यू प्राइमर"}
{"उपयोगकर्ता":"स्टेडोलन", "शीर्षक": "अधिक जेक्यू"}

कुंजी के चारों ओर कोष्ठक लगाने का अर्थ है कि इसका मूल्यांकन एक अभिव्यक्ति के रूप में किया जाएगा। उसके साथ
ऊपर जैसा ही इनपुट,

{(.उपयोगकर्ता): .शीर्षक}

पैदा करता है

{"स्टेडोलन": ["जेक्यू प्राइमर", "मोर जेक्यू"]}

jq {उपयोगकर्ता, शीर्षक: .titles[]}´
{"उपयोगकर्ता":"स्टेडोलन",,"शीर्षक":["जेक्यू प्राइमर", "मोर जेक्यू"]}
=> {"उपयोगकर्ता":"स्टेडोलन", "शीर्षक": "जेक्यू प्राइमर"}, {"उपयोगकर्ता":"स्टेडोलन", "शीर्षक": "अधिक जेक्यू"}

jq {(.user): .titles}´
{"उपयोगकर्ता":"स्टेडोलन",,"शीर्षक":["जेक्यू प्राइमर", "मोर जेक्यू"]}
=> {"स्टेडोलन": ["जेक्यू प्राइमर", "मोर जेक्यू"]}

अंतर्निहित ऑपरेटरों और कार्य


कुछ jq ऑपरेटर (उदाहरण के लिए, +) उनके प्रकार के आधार पर अलग-अलग काम करते हैं
तर्क (सरणी, संख्या, आदि)। हालांकि, jq कभी भी निहित प्रकार के रूपांतरण नहीं करता है। अगर
आप किसी ऑब्जेक्ट में एक स्ट्रिंग जोड़ने का प्रयास करते हैं, आपको एक त्रुटि संदेश मिलेगा और कोई परिणाम नहीं मिलेगा।

इसके अलावा - +
परिचालक + दो फ़िल्टर लेता है, उन दोनों को एक ही इनपुट पर लागू करता है, और जोड़ता है
एक साथ परिणाम। क्या "जोड़ना" का अर्थ शामिल प्रकारों पर निर्भर करता है:

· नंबर सामान्य अंकगणित द्वारा जोड़े जाते हैं।

· Arrays एक बड़े सरणी में संयोजित करके जोड़ा जाता है।

· स्ट्रिंग्स एक बड़े तार में जुड़कर जोड़े जाते हैं।

· वस्तुएँ विलय करके जोड़े जाते हैं, अर्थात, दोनों से सभी कुंजी-मूल्य जोड़े सम्मिलित करना
एक संयुक्त वस्तु में वस्तुओं। यदि दोनों वस्तुओं का मान समान है
कुंजी, दायीं ओर की वस्तु + जीतता है। (पुनरावर्ती विलय के लिए उपयोग करें * ऑपरेटर।)

रिक्त किसी भी मूल्य में जोड़ा जा सकता है, और अन्य मूल्य अपरिवर्तित लौटाता है।

जेक्यू .ए + 1´
{"ए": 7}
=> २

jq .a + .b´
{"ए": [1,2], "बी": [3,4]}
=> [1,2,3,4]

jq .a + null´
{"ए": 1}
=> २

जेक्यू .ए + 1´
{}
=> २

जेक्यू {ए: 1} + {बी: 2} + {सी: 3} + {ए: 42}´
रिक्त
=> {"ए": 42, "बी": 2, "सी": 3}

घटाव - -
साथ ही संख्याओं पर सामान्य अंकगणितीय घटाव, - ऑपरेटर का उपयोग सरणियों पर किया जा सकता है
पहली सरणी से दूसरी सरणी के तत्वों की सभी घटनाओं को हटाने के लिए।

जेक्यू 4 - .a´
{"ए":3}
=> २

जेक्यू . - ["xml", "yaml"]´
["एक्सएमएल", "यमल", "जेसन"]
=> ["जेसन"]

गुणा, विभाजन, प्रपत्र - *, /, और %
दो नंबर दिए जाने पर ये इंफिक्स ऑपरेटर उम्मीद के मुताबिक व्यवहार करते हैं। शून्य से विभाजन बढ़ जाता है
एक त्रुटि। x % y x मॉड्यूल y की गणना करता है।

एक स्ट्रिंग को किसी संख्या से गुणा करने पर उस स्ट्रिंग का संयोजन उत्पन्न होता है जो कई
बार. "एक्स" * 0 पैदा करता है रिक्त.

एक स्ट्रिंग को दूसरे से विभाजित करना दूसरे को विभाजक के रूप में उपयोग करके पहले को विभाजित करता है।

दो वस्तुओं को गुणा करने से उन्हें पुनरावर्ती रूप से मिला दिया जाएगा: यह जोड़ की तरह काम करता है लेकिन यदि दोनों
ऑब्जेक्ट में एक ही कुंजी के लिए एक मान होता है, और मान ऑब्जेक्ट होते हैं, दोनों मर्ज किए जाते हैं
इसी रणनीति के साथ।

जेक्यू 10 / . * 3´
5
=> २

जेक्यू . / ", "´
"ए, बी, सी, डी, ई"
=> ["ए", "बी, सी, डी", "ई"]

जेक्यू {"के": {"ए": 1, "बी": 2}} * {"के": {"ए": 0,"सी": 3}}´
रिक्त
=> {"के": {"ए": 0, "बी": 2, "सी": 3}}

जेक्यू .[] | (1 /।)?´
[1,0,-1]
=> 1, -1

लंबाई
बिल्टिन फ़ंक्शन लंबाई विभिन्न प्रकार के मूल्य की लंबाई प्राप्त करता है:

· एक की लंबाई स्ट्रिंग इसमें शामिल यूनिकोड कोडपॉइंट्स की संख्या है (जो होगा
बाइट्स में इसकी JSON-एन्कोडेड लंबाई के समान यदि यह शुद्ध ASCII है)।

· an . की लंबाई सरणी तत्वों की संख्या है।

· an . की लंबाई वस्तु कुंजी-मूल्य जोड़े की संख्या है।

· इसकी लंबाई रिक्त शून्य है

जेक्यू .[] | लम्बाई´ [[1,2], "स्ट्रिंग", {"ए":2}, शून्य] => 2, 6, 1, 0

चांबियाँ, key_unsorted
बिल्टिन फ़ंक्शन Instagram पर , जब कोई वस्तु दी जाती है, तो उसकी कुंजियों को एक सरणी में लौटाता है।

यूनिकोड कोडपॉइंट ऑर्डर द्वारा कुंजियों को "वर्णानुक्रम में" क्रमबद्ध किया जाता है। यह आदेश नहीं है
यह किसी विशेष भाषा में विशेष अर्थ रखता है, लेकिन आप इस पर भरोसा कर सकते हैं
किन्हीं दो वस्तुओं के लिए समान कुंजियों के सेट के साथ, स्थानीय सेटिंग्स की परवाह किए बिना।

. Instagram पर एक सरणी दी गई है, यह उस सरणी के लिए मान्य सूचकांक देता है: पूर्णांक
0 से लंबाई -1 तक।

RSI key_unsorted समारोह बस की तरह है Instagram पर , लेकिन अगर इनपुट एक वस्तु है तो कुंजियाँ
क्रमबद्ध नहीं किया जाएगा, इसके बजाय कुंजियाँ मोटे तौर पर सम्मिलन क्रम में होंगी।

जेक्यू (कुंजी)
{"एबीसी": 1, "एबीसीडी": 2, "फू": 3}
=> ["फू", "एबीसी", "एबीसीडी"]

जेक्यू (कुंजी)
[42,3,35]
=> [0,1,2]

है (कुंजी)
बिल्टिन फ़ंक्शन है रिटर्न करता है कि इनपुट ऑब्जेक्ट में दी गई कुंजी है, या इनपुट
सरणी में दिए गए सूचकांक में एक तत्व है।

है($कुंजी) जाँच के समान प्रभाव पड़ता है कि क्या $ कुंजी लौटाए गए सरणी का सदस्य है
by Instagram पर , हालांकि है तेज होगा।

jq map(has("foo"))´
[{"फू": 42}, {}]
=> [सच, झूठा]

जेक्यू नक्शा(है(2))´
[[0,1], ["ए", "बी", "सी"]]
=> [झूठा, सच]

in
बिल्टिन फ़ंक्शन in रिटर्न इनपुट कुंजी दिए गए ऑब्जेक्ट में है, या इनपुट इंडेक्स
दिए गए सरणी में एक तत्व से मेल खाती है। यह, अनिवार्य रूप से, का उलटा संस्करण है
है.

जेक्यू .[] | इन ({"फू": 42})´
["फू", "बार"]
=> सत्य, असत्य

jq map(in([0,1]))´
[2, 0]
=> [झूठा, सच]

पथ (पथ_अभिव्यक्ति)
आउटपुट सरणी में दिए गए पथ अभिव्यक्ति का प्रतिनिधित्व करता है .. आउटपुट के सरणियाँ हैं
तार (ऑब्जेक्ट 0 और/या संख्याओं में कुंजी (सरणी सूचकांक।

पथ भाव jq भाव हैं जैसे .a, लेकिन यह भी .[]. पथ दो प्रकार के होते हैं
भाव: वे जो बिल्कुल मेल खा सकते हैं, और जो नहीं कर सकते। उदाहरण के लिए, एबीसी है एक
सटीक मिलान पथ अभिव्यक्ति, जबकि .ए[].बी नहीं है।

पथ (सटीक_पथ_अभिव्यक्ति) पथ अभिव्यक्ति के सरणी प्रतिनिधित्व का उत्पादन करेगा
भले ही यह अस्तित्व में न हो ., अगर . is रिक्त या एक सरणी या एक वस्तु।

पथ (पैटर्न) मेल खाने वाले पथों के सरणी प्रतिनिधित्व का उत्पादन करेगा पैटर्न अगर
पथ मौजूद हैं ..

ध्यान दें कि पथ व्यंजक सामान्य व्यंजकों से भिन्न नहीं होते हैं। इजहार
पथ (.. | चयन करें (प्रकार == बूलियन")) बूलियन मानों के सभी पथों को आउटपुट करता है ., और केवल
उन रास्तों।

jq पथ(.a[0].b)´
रिक्त
=> ["ए", 0, "बी"]

jq [पथ(..)]´
{"ए":[{"बी":1}]}
=> [[], ["ए"], ["ए", 0], ["ए", 0, "बी"]]

डेल (पथ_अभिव्यक्ति)
बिल्टिन फ़ंक्शन डेल किसी ऑब्जेक्ट से एक कुंजी और उसके संबंधित मान को हटा देता है।

jq del(.foo)´
{"फू": 42, "बार": 9001, "बाज": 42}
=> {"बार": 9001, "बाज़": 42}

jq del(.[1, 2])´
["फू", "बार", "बाज"]
=> ["फू"]

to_entries, from_entries, with_entries
ये फ़ंक्शन किसी ऑब्जेक्ट और की-वैल्यू पेयर की एक सरणी के बीच कनवर्ट करते हैं। अगर to_entries
एक वस्तु पारित की जाती है, फिर प्रत्येक के लिए k: v इनपुट में प्रविष्टि, आउटपुट सरणी में शामिल हैं
{"चाभी": k, "मूल्य": v}.

from_entries विपरीत रूपांतरण करता है, और with_entries(foo) के लिए एक आशुलिपि है
to_entries | नक्शा (फू) | from_entries, सभी चाबियों के लिए कुछ ऑपरेशन करने के लिए उपयोगी और
किसी वस्तु के मूल्य। from_entries कुंजी, कुंजी, नाम, मान और मान को कुंजी के रूप में स्वीकार करता है।

jq to_entries´
{"ए": 1, "बी": 2}
=> [{"कुंजी":"ए", "मान":1}, {"कुंजी":"बी", "मान":2}]

jq from_entries´
[{"कुंजी":"ए", "मान":1}, {"कुंजी":"बी", "मान":2}]
=> {"ए": 1, "बी": 2}

jq with_entries(.key |= "KEY_" + ।)´
{"ए": 1, "बी": 2}
=> {"KEY_a": 1, "KEY_b": 2}

चुनें (बूलियन_एक्सप्रेशन)
समारोह चुनें (फू) अपने इनपुट को अपरिवर्तित करता है अगर foo उस इनपुट के लिए सत्य लौटाता है,
और अन्यथा कोई उत्पादन नहीं करता है।

यह सूचियों को छानने के लिए उपयोगी है: [1,2,3] | नक्शा (चुनें (. >= 2)) तुम्हे दूंगा [2,3].

jq नक्शा (चुनें(.>= 2))´
[1,5,3,0,7]
=> [5,3,7]

जेक्यू .[] | चयन करें (.id == "दूसरा")´
[{"आईडी": "पहला", "वैल": 1}, {"आईडी": "दूसरा", "वैल": 2}]
=> {"आईडी": "दूसरा", "वैल": 2}

सरणियाँ, वस्तुएं, पुनरावर्तनीय, बुलियन, नंबर, मानदंड, परिमित, तार, शून्य, मूल्यों,
स्केलर
ये बिल्ट-इन केवल उन इनपुट का चयन करते हैं जो सरणियाँ, वस्तुएँ, पुनरावृत्तियाँ (सरणी या .) हैं
ऑब्जेक्ट्स), बूलियन, संख्याएं, सामान्य संख्याएं, परिमित संख्याएं, तार, शून्य, गैर-शून्य
मान, और गैर-पुनरावृत्तीय, क्रमशः।

jq .[]|नंबर´
[[],{},1,,"foo",null,true,false]
=> २

खाली
खाली कोई परिणाम नहीं देता है। बिल्कुल भी नहीं। भी नहीं रिक्त.

यह अवसर पर उपयोगी है। आपको पता चल जाएगा कि आपको इसकी आवश्यकता है :)

जेक्यू 1, खाली, 2´
रिक्त
=> 1, 2

जेक्यू [1,2,खाली,3]´
रिक्त
=> [1,2,3]

त्रुटि(संदेश)
एक त्रुटि उत्पन्न करता है, जैसे .a शून्य और वस्तुओं के अलावा अन्य मूल्यों पर लागू होगा, लेकिन
दिए गए संदेश के साथ त्रुटि के मान के रूप में।

$__लोक__
फ़ाइल नाम और लाइन नंबर के साथ "फ़ाइल" कुंजी और "लाइन" कुंजी के साथ ऑब्जेक्ट उत्पन्न करता है
जहां $__लोक__ मूल्यों के रूप में होता है।

jq try error("\($__loc__)") catch .´
रिक्त
=> "{\"फ़ाइल\":\" \",\"लाइन 1}"

नक्शा (एक्स), map_values(x)
किसी भी फिल्टर के लिए x, नक्शा (एक्स) इनपुट सरणी के प्रत्येक तत्व के लिए उस फ़िल्टर को चलाएगा, और
आउटपुट को एक नई सरणी उत्पन्न करें। नक्शा(.+1) की एक सरणी के प्रत्येक तत्व में वृद्धि करेगा
संख्या.

इसी तरह, map_values(x) प्रत्येक तत्व के लिए उस फ़िल्टर को चलाएगा, लेकिन यह वापस आ जाएगा
ऑब्जेक्ट पास होने पर ऑब्जेक्ट।

नक्शा (एक्स) के बराबर है [.[] | x]. वास्तव में, इसे इस तरह परिभाषित किया गया है। इसी तरह,
map_values(x) के रूप में परिभाषित किया गया है .[] |= x.

jq नक्शा(.+1)´
[1,2,3]
=> [2,3,4]

jq map_values(.+1)´
{"ए": 1, "बी": 2, "सी": 3}
=> {"ए": 2, "बी": 3, "सी": 4}

रास्ते, पथ (नोड_फिल्टर), पत्ती_पथ
पथ इसके इनपुट में सभी तत्वों के पथ को आउटपुट करता है (सिवाय इसके कि यह आउटपुट नहीं करता है
खाली सूची, प्रतिनिधित्व . अपने आप)।

पथ (एफ) किसी भी मान के पथ को आउटपुट करता है जिसके लिए f सच हैं। अर्थात्, पथ (संख्या)
सभी संख्यात्मक मानों के पथ को आउटपुट करता है।

पत्ती_पथ का एक उपनाम है पथ (स्केलर); पत्ती_पथ is पदावनत और में हटा दिया जाएगा
अगली बड़ी रिलीज।

jq [पथ] ´
[1,[[],{"ए":2}]]
=> [[0],[1],[1,0],[1,1],[1,1,"a"]]

jq [पथ (स्केलर)]´
[1,[[],{"ए":2}]]
=> [[0], [1,1,"ए"]]

जोड़ना
फ़िल्टर जोड़ना इनपुट के रूप में एक सरणी लेता है, और आउटपुट के रूप में सरणी के तत्वों का उत्पादन करता है
एक साथ जोड़ा। इसका मतलब संक्षेप, संयोजित या विलय के प्रकारों के आधार पर हो सकता है
इनपुट ऐरे के तत्व - नियम वही हैं जो के लिए हैं + ऑपरेटर
(ऊपर वर्णित)।

यदि इनपुट एक खाली सरणी है, जोड़ना रिटर्न रिक्त.

जेक्यू जोड़
["ए", "बी", "सी"]
=> "एबीसी"

जेक्यू जोड़
[1, 2, 3]
=> २

जेक्यू जोड़
[]
=> शून्य

कोई भी, कोई भी (शर्त), कोई (जनरेटर; स्थिति)
फ़िल्टर कोई इनपुट के रूप में बूलियन मानों की एक सरणी लेता है, और उत्पन्न करता है <strong>उद्देश्य</strong> आउटपुट के रूप में अगर
सरणी का कोई भी तत्व है <strong>उद्देश्य</strong>.

यदि इनपुट एक खाली सरणी है, कोई रिटर्न असत्य.

RSI कोई भी (शर्त) फॉर्म दी गई शर्त को इनपुट ऐरे के तत्वों पर लागू करता है।

RSI कोई (जनरेटर; स्थिति) फॉर्म दी गई शर्त को सभी आउटपुट पर लागू करता है
जनरेटर दिया।

जेक्यू कोई´
[सही गलत]
=> सच

जेक्यू कोई´
[झूठा, झूठा]
=> असत्य

जेक्यू कोई´
[]
=> असत्य

सब, सभी (हालत), सभी (जनरेटर; स्थिति)
फ़िल्टर सब इनपुट के रूप में बूलियन मानों की एक सरणी लेता है, और उत्पन्न करता है <strong>उद्देश्य</strong> आउटपुट के रूप में अगर
सरणी के सभी तत्व हैं <strong>उद्देश्य</strong>.

RSI सभी (हालत) फॉर्म दी गई शर्त को इनपुट ऐरे के तत्वों पर लागू करता है।

RSI सभी (जनरेटर; स्थिति) फॉर्म दी गई शर्त को सभी आउटपुट पर लागू करता है
जनरेटर दिया।

यदि इनपुट एक खाली सरणी है, सब रिटर्न <strong>उद्देश्य</strong>.

jq all´
[सही गलत]
=> असत्य

jq all´
[सच सच]
=> सच

jq all´
[]
=> सच

[आवश्यक 1.5] चपटा, समतल (गहराई)
फ़िल्टर समतल करना इनपुट के रूप में नेस्टेड सरणियों की एक सरणी लेता है, और एक फ्लैट सरणी उत्पन्न करता है
जो मूल सरणी के अंदर सभी सरणियों को उनके मूल्यों द्वारा पुनरावर्ती रूप से बदल दिया गया है।
आप यह निर्दिष्ट करने के लिए एक तर्क पारित कर सकते हैं कि नेस्टिंग के कितने स्तर समतल करने हैं।

समतल करना(2) के समान ही समतल करना, लेकिन केवल दो स्तरों तक गहरे जा रहे हैं।

jq समतल
[1, [2], [[3]]]
=> [२१४९१२८०६०, २१४९१२८०६०, २१४९१२८०६०]

जेक्यूसमतल करना(1)´
[1, [2], [[3]]]
=> [1, 2, [3]]

jq समतल
[[]]
=> []

jq समतल
[{"foo": "bar"}, [{"foo": "baz"}]]
=> [{"foo": "bar"}, {"foo": "baz"}]

रेंज (तक), रेंज (से; तक) रेंज (से; तक; द्वारा)
RSI रेंज फ़ंक्शन संख्याओं की एक श्रृंखला उत्पन्न करता है। रेंज(4;10) 6 . से 4 संख्याएँ उत्पन्न करता है
(समावेशी) से 10 (अनन्य)। संख्याओं को अलग-अलग आउटपुट के रूप में उत्पादित किया जाता है। उपयोग
[रेंज(4;10)] एक सरणी के रूप में एक सीमा प्राप्त करने के लिए।

एक तर्क प्रपत्र की वृद्धि के साथ, 0 से दी गई संख्या तक संख्याएँ उत्पन्न करता है
1.

दो तर्क प्रपत्र से संख्याएँ उत्पन्न करता है से सेवा मेरे तक 1 की वृद्धि के साथ।

तीन तर्क प्रपत्र संख्या उत्पन्न करता है से सेवा मेरे तक की वृद्धि के साथ by.

जेक्यू रेंज(2;4)´
रिक्त
=> 2, 3

जेक्यू [रेंज(2;4)]´
रिक्त
=> [2,3]

जेक्यू [रेंज(4)]´
रिक्त
=> [0,1,2,3]

जेक्यू [रेंज(0;10;3)]´
रिक्त
=> [0,3,6,9]

jq [रेंज(0;10;-1)]´
रिक्त
=> []

jq [रेंज(0;-5;-1)]´
रिक्त
=> [0,-1,-2,-3,-4]

मंजिल
RSI मंजिल फ़ंक्शन अपने संख्यात्मक इनपुट का तल लौटाता है।

जेक्यू फर्श´
3.14159
=> २

sqrt
RSI sqrt फ़ंक्शन अपने संख्यात्मक इनपुट का वर्गमूल लौटाता है।

जेक्यू वर्ग´
9
=> २

टोनंबर
RSI टोनंबर फ़ंक्शन अपने इनपुट को एक संख्या के रूप में पार्स करता है। यह सही ढंग से स्वरूपित परिवर्तित हो जाएगा
उनके संख्यात्मक समकक्ष के लिए तार, संख्याओं को अकेला छोड़ दें, और अन्य सभी पर एक त्रुटि दें
इनपुट।

जेक्यू .[] | टनंबर
[1 1"]
=> 1, 1

तार
RSI तार फ़ंक्शन अपने इनपुट को एक स्ट्रिंग के रूप में प्रिंट करता है। स्ट्रिंग्स को अपरिवर्तित छोड़ दिया जाता है, और सभी
अन्य मान JSON-एन्कोडेड हैं।

जेक्यू .[] | तार
[1, "1", [1]]
=> "1", "1", "[1]"

टाइप
RSI टाइप फ़ंक्शन अपने तर्क के प्रकार को एक स्ट्रिंग के रूप में देता है, जो शून्य में से एक है,
बूलियन, संख्या, स्ट्रिंग, सरणी या वस्तु।

जेक्यू नक्शा (प्रकार)´
[0, झूठा, [], {}, शून्य, "हैलो"]
=> ["संख्या", "बूलियन", "सरणी", "वस्तु", "शून्य", "स्ट्रिंग"]

अनंत, नेन अनंत है, इसान, अनंत, यह सामान्य है
कुछ अंकगणितीय संचालन अनंत और "संख्या नहीं" (NaN) मान उत्पन्न कर सकते हैं। NS
अनंत है बिल्टिन रिटर्न <strong>उद्देश्य</strong> यदि इसका इनपुट अनंत है। इस्नान बिल्टिन रिटर्न <strong>उद्देश्य</strong>
यदि इसका इनपुट NaN है। अनंत बिल्टिन एक सकारात्मक अनंत मूल्य देता है। नान
बिल्टिन एक NaN देता है। NS यह सामान्य है यदि इनपुट सामान्य संख्या है तो बिल्टिन सत्य लौटाता है।

ध्यान दें कि शून्य से भाग देने पर त्रुटि उत्पन्न होती है।

वर्तमान में अधिकांश अंकगणितीय संचालन अनंत, NaN और उप-मानकों पर चल रहे हैं
त्रुटियाँ उठाना।

जेक्यू .[] | (अनंत *।) <0´
[-1 1]
=> सत्य, असत्य

jq अनंत, नैन | प्रकार
रिक्त
=> "संख्या", "संख्या"

छाँटना, सॉर्ट_बी (पथ_अभिव्यक्ति)
RSI तरह फ़ंक्शन इसके इनपुट को सॉर्ट करता है, जो एक सरणी होना चाहिए। मानों को क्रमबद्ध किया जाता है
निम्नलिखित आदेश:

· रिक्त

· असत्य

· <strong>उद्देश्य</strong>

· संख्याएं

स्ट्रिंग्स, वर्णानुक्रम में (यूनिकोड कोडपॉइंट मान द्वारा)

· सरणियाँ, शाब्दिक क्रम में

· वस्तु

वस्तुओं का क्रम थोड़ा जटिल है: पहले उनकी तुलना उनकी तुलना करके की जाती है
चाबियों के सेट (क्रमबद्ध क्रम में सरणियों के रूप में), और यदि उनकी कुंजियाँ समान हैं तो मान हैं
कुंजी द्वारा तुलना कुंजी।

तरह किसी वस्तु के किसी विशेष क्षेत्र द्वारा क्रमबद्ध करने के लिए या किसी jq फ़िल्टर को लागू करने के लिए उपयोग किया जा सकता है।

सॉर्ट_बी (फू) के परिणाम की तुलना करके दो तत्वों की तुलना करता है foo प्रत्येक तत्व पर।

जेक्यू सॉर्ट´
[8,3,शून्य,6]
=> [शून्य,3,6,8]

jq sort_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) इनपुट के रूप में एक सरणी लेता है, समान वाले तत्वों को समूहित करता है .फू खेत
अलग-अलग सरणियों में, और इन सभी सरणियों को एक बड़े सरणी के तत्वों के रूप में उत्पन्न करता है,
के मान द्वारा क्रमबद्ध .फू खेत।

कोई भी jq व्यंजक, न कि केवल एक क्षेत्र अभिगम, का उपयोग के स्थान पर किया जा सकता है .फू. छँटाई
आदेश वही है जैसा वर्णित है तरह ऊपर समारोह।

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)
इनपुट सरणी का न्यूनतम या अधिकतम तत्व खोजें।

RSI min_by(path_exp) और max_by(path_exp) फ़ंक्शन आपको एक विशेष निर्दिष्ट करने की अनुमति देते हैं
जांच करने के लिए क्षेत्र या संपत्ति, उदाहरण के लिए min_by(.foo) वस्तु को सबसे छोटी के साथ पाता है foo
खेत।

जेक्यू मिनट´
[5,4,2,7]
=> २

jq max_by(.foo)´
[{"foo":1, "bar":14}, {"foo":2, "bar":3}]
=> {"फू":2, "बार":3}

अद्वितीय, Unique_by(path_exp)
RSI अद्वितीय फ़ंक्शन इनपुट के रूप में एक सरणी लेता है और समान तत्वों की एक सरणी उत्पन्न करता है, in
क्रमबद्ध क्रम, डुप्लिकेट हटाए जाने के साथ।

RSI Unique_by(path_exp) फ़ंक्शन द्वारा प्राप्त प्रत्येक मान के लिए केवल एक तत्व रखेगा
तर्क को लागू करना। इसे प्रत्येक में से एक तत्व को निकालकर एक सरणी बनाने के रूप में सोचें
द्वारा निर्मित समूह समूह.

जेक्यू अद्वितीय´
[1,2,5,3,5,3,1,3]
=> [1,2,3,5]

jq unique_by(.foo)´
[{"फू": 1, "बार": 2}, {"फू": 1, "बार": 3}, {"फू": 4, "बार": 5}]
=> [{"फू": 1, "बार": 2}, {"फू": 4, "बार": 5}]

jq unique_by(लंबाई)´
["चंकी", "बेकन", "बिल्ली का बच्चा", "सिकाडा", "शतावरी"]
=> ["बेकन", "चंकी", "शतावरी"]

उल्टा
यह फ़ंक्शन एक सरणी को उलट देता है।

जेक्यू रिवर्स´
[1,2,3,4]
=> [4,3,2,1]

शामिल (तत्व)
फ़िल्टर शामिल है (बी) यदि बी पूरी तरह से इनपुट के भीतर समाहित है तो सत्य उत्पन्न होगा। ए
स्ट्रिंग बी एक स्ट्रिंग ए में समाहित है यदि बी ए का सबस्ट्रिंग है। एक सरणी बी में निहित है
एक सरणी ए यदि बी में सभी तत्व ए में किसी भी तत्व में निहित हैं। एक वस्तु बी है
वस्तु A में निहित है यदि B के सभी मान A के मान में समाहित हैं
एक ही कुंजी। अन्य सभी प्रकारों को एक दूसरे में समाहित माना जाता है यदि वे समान हैं।

jq (शामिल है ("बार")´
"फूबार"
=> सच

jq में शामिल है (["बाज", "बार"])´
["फोबार", "फूबाज़", "ब्लार्प"]
=> सच

jq में शामिल है (["bzzzz", "bar"])´
["फोबार", "फूबाज़", "ब्लार्प"]
=> असत्य

jq में शामिल है ({foo: 12, बार: [{barp: 12}]})´
{"फू": 12, "बार":[1,2,{"बार्प":12, "ब्लिप":13}]}
=> सच

jq में शामिल है ({foo: 12, बार: [{barp: 15}]})´
{"फू": 12, "बार":[1,2,{"बार्प":12, "ब्लिप":13}]}
=> असत्य

सूचकांक
एक सरणी को आउटपुट करता है जिसमें सूचकांक होते हैं . जहां s होता है। इनपुट एक सरणी हो सकता है, in
कौन सा मामला अगर s एक सरणी है तो सूचकांक आउटपुट वे होंगे जहां सभी तत्व .
उनमें से मिलान करें s.

jq सूचकांक(", ")´
"ए, बी, सीडी, ईएफजी, हिज्क"
=> [3,7,12]

जेक्यूइंडेक्स(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]

सूचकांक (ओं), रिनडेक्स
पहले के सूचकांक को आउटपुट करता है (अनुक्रमणिका) या अंतिम (रिनडेक्स) की घटना s इनपुट में।

jq सूचकांक(", ")´
"ए, बी, सीडी, ईएफजी, हिज्क"
=> २

jq रिंडेक्स(", ")´
"ए, बी, सीडी, ईएफजी, हिज्क"
=> २

अंदर
फ़िल्टर अंदर (बी) यदि इनपुट पूरी तरह से b के भीतर समाहित है तो सत्य उत्पन्न होगा। यह
अनिवार्य रूप से, का उलटा संस्करण है शामिल हैं.

jq अंदर("foobar")´
"बार"
=> सच

jq inside(["foobar", "foobaz", "blarp"])´
["बाज़", "बार"]
=> सच

jq inside(["foobar", "foobaz", "blarp"])´
["बैज़्ज़्ज़", "बार"]
=> असत्य

jq inside({"foo": 12, "bar":[1,2,{"barp":12, "blip":13}]})´
{"फू": 12, "बार": [{"बार्प": 12}]}
=> सच

jq inside({"foo": 12, "bar":[1,2,{"barp":12, "blip":13}]})´
{"फू": 12, "बार": [{"बार्प": 15}]}
=> असत्य

startwith(str)
आउटपुट <strong>उद्देश्य</strong> अगर । दिए गए स्ट्रिंग तर्क से शुरू होता है।

jq [.[]|startwith("foo")]´
["fo", "foo", "barfoo", "foobar", "barfoob"]
=> [झूठा, सच, झूठा, सच, झूठा]

एंडविथ (str)
आउटपुट <strong>उद्देश्य</strong> अगर । दिए गए स्ट्रिंग तर्क के साथ समाप्त होता है।

jq [.[]|समाप्त होता है("foo")]´
["फूबर", "बारफू"]
=> [झूठा, सच]

संयोजन, संयोजन (एन)
इनपुट सरणी में सरणियों के तत्वों के सभी संयोजनों को आउटपुट करता है। अगर दिया गया
तर्क n, यह के सभी संयोजनों को आउटपुट करता है n इनपुट सरणी की पुनरावृत्ति।

जेक्यू संयोजन´
[[1,2], [3, 4]]
=> [1, 3], [1, 4], [2, 3], [2, 4]

जेक्यूसंयोजन(2)´
[0, 1]
=> [0, 0], [0, 1], [1, 0], [1, 1]

ltrimstr(str)
दिए गए उपसर्ग स्ट्रिंग के साथ अपने इनपुट को आउटपुट करता है, अगर यह इसके साथ शुरू होता है।

jq [.[]|ltrimstr("foo")]´
["fo", "foo", "barfoo", "foobar", "afoo"]
=> ["फो", "", "बारफू", "बार", "एफू"]

rtrimstr(str)
दिए गए प्रत्यय स्ट्रिंग के साथ अपना इनपुट आउटपुट करता है, अगर यह इसके साथ समाप्त होता है।

jq [.[]|rtrimstr("foo")]´
["fo", "foo", "barfoo", "foobar", "foob"]
=> ["फो", "", "बार", "फूबार", "फूब"]

विस्फोट
एक इनपुट स्ट्रिंग को स्ट्रिंग के कोडपॉइंट नंबरों की एक सरणी में परिवर्तित करता है।

जेक्यू विस्फोट´
"फूबार"
=> [102,111,111,98,97,114]

फटना
विस्फोट का उलटा।

jq implode´
[65, 66, 67]
=> "एबीसी"

विभाजित
विभाजक तर्क पर एक इनपुट स्ट्रिंग को विभाजित करता है।

jq split(", ")´
"ए, बी, सी, डी, ई,"
=> ["ए", "बी, सी, डी", "ई", ""]

शामिल हों (str)
विभाजक के रूप में तर्क का उपयोग करके इनपुट के रूप में दिए गए तत्वों की सरणी में शामिल हो जाता है। यह है
का उलटा विभाजित: वह है, चल रहा है विभाजन ("फू") | शामिल हों ("फू") किसी भी इनपुट स्ट्रिंग पर
रिटर्न ने कहा इनपुट स्ट्रिंग।

जेक्यू जॉइन(", ")´
["ए", "बी, सी, डी", "ई"]
=> "ए, बी, सी, डी, ई"

ascii_downcase, ascii_upcase
इनपुट स्ट्रिंग की एक कॉपी को उसके अल्फ़ाबेटिक कैरेक्टर (az और AZ) के साथ में कनवर्ट करें
निर्दिष्ट मामला।

जबकि (शर्त; अपडेट करें)
RSI जबकि (शर्त; अपडेट करें) फ़ंक्शन आपको बार-बार अपडेट को लागू करने की अनुमति देता है . जब तक cond
गलत है।

ध्यान दें कि जबकि (शर्त; अपडेट करें) आंतरिक रूप से एक पुनरावर्ती jq फ़ंक्शन के रूप में परिभाषित किया गया है। पुनरावर्ती
भीतर कॉल करता है जब अतिरिक्त मेमोरी का उपभोग नहीं करेगा यदि अद्यतन अधिकतम एक . का उत्पादन करता है
प्रत्येक इनपुट के लिए आउटपुट। नीचे उन्नत विषय देखें।

jq [जबकि(.<100; .*2)]´
1
=> [1,2,4,8,16,32,64]

जब तक (शर्त; अगला)
RSI जब तक (शर्त; अगला) फ़ंक्शन आपको बार-बार अभिव्यक्ति लागू करने की अनुमति देता है अगला,
शुरू में करने के लिए . तब तक अपने स्वयं के आउटपुट तक cond सच हैं। उदाहरण के लिए, इसका उपयोग किया जा सकता है
एक फैक्टोरियल फ़ंक्शन को लागू करने के लिए (नीचे देखें)।

ध्यान दें कि जब तक (शर्त; अगला) आंतरिक रूप से एक पुनरावर्ती jq फ़ंक्शन के रूप में परिभाषित किया गया है। पुनरावर्ती
भीतर कॉल करता है जब तक() अतिरिक्त मेमोरी का उपभोग नहीं करेगा यदि अगला अधिकतम एक . का उत्पादन करता है
प्रत्येक इनपुट के लिए आउटपुट। नीचे उन्नत विषय देखें।

jq [.,1]|जब तक(.[0] <1; [.[0] - 1, .[1] * .[0]])|.[1]´
4
=> २

रिकर्स (एफ), रिकर्स, रिकर्स (एफ; शर्त), रिकर्स_डाउन
RSI रिकर्स (एफ) फ़ंक्शन आपको एक पुनरावर्ती संरचना के माध्यम से खोज करने और निकालने की अनुमति देता है
सभी स्तरों से दिलचस्प डेटा। मान लीजिए कि आपका इनपुट एक फाइल सिस्टम का प्रतिनिधित्व करता है:

{"नाम": "/", "बच्चे": [
{"नाम": "/ bin", "बच्चे": [
{"नाम": "/बिन/एलएस", "बच्चे": []},
{"नाम": "/ बिन / श", "बच्चे": []}]},
{"नाम": "/ होम", "बच्चे": [
{"नाम": "/ घर/स्टीफन", "बच्चे": [
{"नाम": "/ घर/स्टीफन/jq", "बच्चे": []}]}]}]}

अब मान लीजिए कि आप मौजूद सभी फाइलनामों को निकालना चाहते हैं। आपको पुनः प्राप्त करने की आवश्यकता है . नाम,
.बच्चों []। नाम, .बच्चे []। बच्चे []। नाम, और इसी तरह। आप इसके साथ ऐसा कर सकते हैं:

रिकर्स (.बच्चों []) | ।नाम

बिना किसी तर्क के पुकारे जाने पर, फिर से इकट्ठा करना के बराबर है रिकर्स (.[]?).

रिकर्स (एफ) के समान है रिकर्स (एफ; . != शून्य) और बिना किसी चिंता के इस्तेमाल किया जा सकता है
रिकर्सन गहराई।

रिकर्स (एफ; स्थिति) एक जनरेटर है जो उत्सर्जन से शुरू होता है। और फिर बारी-बारी से उत्सर्जित करता है
.|f, .|f|f, .|f|f|f, ... जब तक परिकलित मान शर्त को पूरा करता है। के लिये
उदाहरण के लिए, सभी पूर्णांकों को उत्पन्न करने के लिए, कम से कम सिद्धांत रूप में, कोई लिख सकता है रिकर्स(.+1;
सच).

विरासत कारणों से, रिकर्स_डाउन कॉलिंग के लिए एक उपनाम के रूप में मौजूद है फिर से इकट्ठा करना बिना तर्क के।
यह उपनाम माना जाता है पदावनत और अगले प्रमुख रिलीज में हटा दिया जाएगा।

पुनरावर्ती कॉल in फिर से इकट्ठा करना जब भी अतिरिक्त मेमोरी का उपभोग नहीं करेंगे f पर पैदा करता है
प्रत्येक इनपुट के लिए अधिकतम एकल आउटपुट।

jq recurse(.foo[])´
{"foo":[{"foo": []}, {"foo":[{"foo":[]}]}]}
=> {"foo":[{"foo":[]},{"foo":[{"foo":[]}]}]}, {"foo":[]}, {"foo": [{"फू":[]}]}, {"फू":[]}

जेक्यू (पुनरावृत्ति)
{"ए":0,"बी":[1]}
=> {"ए":0,"बी":[1]}, 0, [1], 1

jq recurse(. * .; . <20)´
2
=> 2, 4, 16

..
शॉर्ट-हैंड फॉर फिर से इकट्ठा करना बिना तर्क के। यह XPath से मिलता जुलता है //
ऑपरेटर। ध्यान दें कि ..ए काम नहीं करता; उपयोग ..|ए बजाय। नीचे दिए गए उदाहरण में हम उपयोग करते हैं
..|.ए? "नीचे" पाए गए किसी भी ऑब्जेक्ट में ऑब्जेक्ट कुंजी "ए" के सभी मानों को खोजने के लिए ..

जेक्यू ..|.ए?´
[[{"ए":1}]]
=> २

env
jq के पर्यावरण का प्रतिनिधित्व करने वाली वस्तु को आउटपुट करता है।

jq env.PAGER´
रिक्त
=> "कम"

खिसकाना
संभावित रूप से जंजीर मैट्रिक्स (सरणी की एक सरणी) को स्थानांतरित करें। पंक्तियों को नल के साथ गद्देदार किया जाता है ताकि
परिणाम हमेशा आयताकार होता है।

जेक्यू स्थानांतरण´
[[1], [2,3]]
=> [[1,2], [शून्य, 3]]

बी खोज (एक्स)
bsearch(x) इनपुट सरणी में x के लिए एक बाइनरी खोज करता है। यदि इनपुट सॉर्ट किया गया है और
इसमें x है, फिर bsearch(x) सरणी में अपना सूचकांक लौटाएगा; अन्यथा, यदि सरणी है
क्रमबद्ध, यह वापस आ जाएगा (-1 - ix) जहां ix एक सम्मिलन बिंदु है जैसे कि सरणी होगी
ix पर x डालने के बाद भी सॉर्ट किया जा सकता है। यदि सरणी क्रमबद्ध नहीं है, तो bsearch(x)
एक पूर्णांक लौटाएगा जो शायद कोई दिलचस्पी नहीं है।

जेक्यूbsearch(0)´
[0,1]
=> २

जेक्यूbsearch(0)´
[1,2,3]
=> -1

जेक्यूbsearch(4) $ix | . के रूप में अगर $ix <0 तो .[-(1+$ix)] = 4 और। समाप्त
[1,2,3]
=> [1,2,3,4]

तार प्रक्षेप - \(फू)
एक स्ट्रिंग के अंदर, आप बैकस्लैश के बाद माता-पिता के अंदर एक अभिव्यक्ति डाल सकते हैं। जो भी
अभिव्यक्ति रिटर्न स्ट्रिंग में प्रक्षेपित किया जाएगा।

jq ´"इनपुट \(.) था, जो \(.+1)"´ . से एक कम है
42
=> "इनपुट 42 था, जो 43 से एक कम है"

में कनवर्ट करना से करने के लिए JSON
RSI तोजसन और फ्रॉमजॉन बिल्टिन मान को JSON टेक्स्ट के रूप में डंप करते हैं या JSON टेक्स्ट को पार्स करते हैं
मान, क्रमशः। tojson बिल्टिन उस tostring रिटर्न में tostring से भिन्न होता है
स्ट्रिंग्स अनमॉडिफाइड हैं, जबकि tojson स्ट्रिंग्स को JSON स्ट्रिंग्स के रूप में एन्कोड करता है।

जेक्यू [.[]|टोस्ट्रिंग]´
[1, "फू", ["फू"]]
=> ["1", "फू", "[\"foo\"]"]

jq [.[]|tojson]´
[1, "फू", ["फू"]]
=> ["1", "\"foo\"",,"[\"foo\"]"]

jq [.[]|tojson|fromjson]´
[1, "फू", ["फू"]]
=> [1,"फू", ["फू"]]

का गठन तार और भागने
RSI @फू सिंटैक्स का उपयोग स्ट्रिंग्स को प्रारूपित करने और बचने के लिए किया जाता है, जो URL बनाने के लिए उपयोगी है,
HTML या XML जैसी भाषा में दस्तावेज़, इत्यादि। @फू एक फिल्टर के रूप में इस्तेमाल किया जा सकता है
अपने स्वयं के, संभावित पलायन हैं:

@मूलपाठ:

कॉल तार, विवरण के लिए उस फ़ंक्शन को देखें।

@json:

इनपुट को JSON के रूप में क्रमबद्ध करता है।

@html:

वर्णों की मैपिंग करके, HTML/XML एस्केपिंग लागू करता है <>&´" उनकी इकाई के लिए
समकक्ष <, >, और, ', ".

@uri:

सभी आरक्षित URI वर्णों को a . में मैप करके प्रतिशत-एन्कोडिंग लागू करता है % XX अनुक्रम।

@सीएसवी:

इनपुट एक सरणी होना चाहिए, और इसे दोहरे उद्धरण चिह्नों के साथ CSV के रूप में प्रस्तुत किया जाता है
तार, और उद्धरण दोहराव से बच गए।

@tsv:

इनपुट एक सरणी होना चाहिए, और इसे TSV (टैब से अलग किए गए मान) के रूप में प्रस्तुत किया जाता है। प्रत्येक
इनपुट ऐरे को सिंगल लाइन के रूप में प्रिंट किया जाएगा। फ़ील्ड्स को एक टैब द्वारा अलग किया जाता है
(एएससीआईई) 0x09) इनपुट वर्ण लाइन-फ़ीड (ascii 0x0ए), कैरिज-रिटर्न (ascii .)
0x0d), टैब (ascii 0x09) और बैकस्लैश (ascii .) 0x5c) एस्केप के रूप में आउटपुट होगा
दृश्यों \n, \r, \t, \\ क्रमशः.

@श्री:

POSIX शेल के लिए कमांड-लाइन में उपयोग के लिए उपयुक्त इनपुट बच निकला है। अगर
इनपुट एक सरणी है, आउटपुट अंतरिक्ष से अलग तारों की एक श्रृंखला होगी।

@ बेस 64:

आरएफसी 64 द्वारा निर्दिष्ट इनपुट को बेस 4648 में परिवर्तित किया गया है।

इस सिंटैक्स को उपयोगी तरीके से स्ट्रिंग इंटरपोलेशन के साथ जोड़ा जा सकता है। आप अनुसरण कर सकते हैं a
@फू एक स्ट्रिंग अक्षर के साथ टोकन। स्ट्रिंग शाब्दिक इच्छा की सामग्री नहीं बच जाना।
हालांकि, उस स्ट्रिंग अक्षर के अंदर किए गए सभी इंटरपोलेशन बच जाएंगे। उदाहरण के लिए,

@uri "https://www.google.com/search?q=\(.search)"

इनपुट के लिए निम्नलिखित आउटपुट का उत्पादन करेगा {"खोज":"क्या is जेक्यू?"}:

"https://www.google.com/search?q=what%20is%20jq%3F"

ध्यान दें कि URL में स्लैश, प्रश्नवाचक चिह्न आदि बच नहीं गए हैं, क्योंकि वे भाग थे
स्ट्रिंग अक्षर का।

जेक्यू @html´
"यह काम करता है अगर x <y"
=> "यह काम करता है अगर x <y"

jq @sh "इको \(.)"´
"ओहारास अली"
=> "इको O´\\´´हारा´\\´´s Ale´"

तिथियाँ
jq कुछ हाई-लेवल और लो-लेवल के साथ कुछ बेसिक डेट हैंडलिंग फंक्शनलिटी प्रदान करता है
बिल्टिन्स सभी मामलों में ये बिल्टिन यूटीसी में विशेष रूप से समय के साथ सौदा करते हैं।

RSI fromdateiso8601 आईएसओ 8601 प्रारूप में कई सेकंड के लिए बिल्टिन पार्स डेटाटाइम
यूनिक्स युग (1970-01-01T00:00:00Z) के बाद से। NS टोडेटिसो8601 बिल्टिन उलटा करता है।

RSI की तिथि से बिल्टिन पार्स डेटाटाइम स्ट्रिंग्स। वर्तमान में की तिथि से केवल आईएसओ 8601 का समर्थन करता है
डेटाटाइम स्ट्रिंग्स, लेकिन भविष्य में यह डेटाटाइम स्ट्रिंग्स को और अधिक पार्स करने का प्रयास करेगा
प्रारूपों.

RSI तारीख तक बिल्टिन एक उपनाम है टोडेटिसो8601.

RSI अभी यूनिक्स युग के बाद से सेकंड में बिल्टिन वर्तमान समय को आउटपुट करता है।

सी-लाइब्रेरी टाइम फ़ंक्शंस के लिए निम्न-स्तरीय जेक्यू इंटरफेस भी प्रदान किए जाते हैं: स्ट्रिपटाइम,
स्ट्रैफ़टाइम, एमकेटाइम, तथा जीएमटाइम. इसके लिए अपने होस्ट ऑपरेटिंग सिस्टम के दस्तावेज़ देखें
प्रारूप स्ट्रिंग्स द्वारा उपयोग किया जाता है स्ट्रिपटाइम और स्ट्रैफ़टाइम. नोट: ये जरूरी नहीं कि स्थिर हों
jq में इंटरफेस, विशेष रूप से उनके स्थानीयकरण कार्यक्षमता के रूप में।

RSI जीएमटाइम यूनिक्स युग के बाद से बिल्टिन कई सेकंड का उपभोग करता है और "टूटा हुआ" आउटपुट करता है
डाउन टाइम" का प्रतिनिधित्व करने वाली संख्याओं की एक सरणी के रूप में समय का प्रतिनिधित्व (इस क्रम में): the
वर्ष, महीना (शून्य-आधारित), महीने का दिन, दिन का समय, का मिनट
घंटा, मिनट का दूसरा, सप्ताह का दिन, और वर्ष का दिन -- सभी
एक-आधारित जब तक अन्यथा न कहा गया हो।

RSI एमकेटाइम बिल्टिन समय के आउटपुट के "टूटे हुए समय" का उपभोग करता है जीएमटाइम
और स्ट्रिपटाइम.

RSI स्ट्रिपटाइम (एफएमटी) बिलिन पार्स इनपुट स्ट्रिंग्स से मेल खाता है fmt तर्क। आउटपुट में है
द्वारा भस्म "टूटा हुआ समय" प्रतिनिधित्व जीएमटाइम और आउटपुट द्वारा एमकेटाइम.

RSI स्ट्रैटटाइम (एफएमटी) बिल्टिन दिए गए प्रारूप के साथ एक समय प्रारूपित करता है।

प्रारूप स्ट्रिंग्स के लिए स्ट्रिपटाइम और स्ट्रैफ़टाइम विशिष्ट सी पुस्तकालय में वर्णित हैं
दस्तावेज़ीकरण। आईएसओ 8601 डेटाटाइम के लिए प्रारूप स्ट्रिंग है "%Y-%m-%dT%H:%M:%SZ".

हो सकता है कि jq कुछ सिस्टम पर इस तारीख की कुछ या सभी कार्यक्षमता का समर्थन न करे।

जेक्यू तारीख´
"2015-03-05T23:51:47Z"
=> २

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"
=> २

सशर्त, और तुलना


==, !=
व्यंजक a == b´ true´ उत्पन्न करेगा यदि a और b का परिणाम बराबर है (अर्थात,
अगर वे समकक्ष JSON दस्तावेज़ों का प्रतिनिधित्व करते हैं) और "गलत" अन्यथा। विशेष रूप से, तार
संख्याओं के बराबर कभी नहीं माना जाता है। यदि आप जावास्क्रिप्ट से आ रहे हैं, तो jq´s == जैसा है
Javascript´s === - मानों को समान मानने पर ही उनका प्रकार और साथ ही समान होता है
एक ही मूल्य।

!= "बराबर नहीं" है, और ´a != b´ ´a == b´ का विपरीत मान देता है

जेक्यू .[] == 1´
[1, 1.0, "1", "केला"]
=> सत्य, सत्य, असत्य, असत्य

अगर-तो-और कुछ
if A फिर B अन्य C समाप्त के समान कार्य करेगा B if A असत्य के अलावा कोई मान उत्पन्न करता है या
शून्य, लेकिन उसी के समान कार्य करें C अन्यथा।

जावास्क्रिप्ट में पाए जाने की तुलना में झूठी या शून्य की जांच करना "सत्यता" की एक सरल धारणा है
या पायथन, लेकिन इसका मतलब है कि आपको कभी-कभी स्थिति के बारे में अधिक स्पष्ट होना होगा
आप चाहते हैं: आप परीक्षण नहीं कर सकते हैं, उदाहरण के लिए एक स्ट्रिंग खाली है या नहीं if . नाम फिर A अन्य B समाप्त,
आपको कुछ और चाहिए if (।नाम | लंबाई) > 0 फिर A अन्य B समाप्त बजाय.

यदि स्थिति A कई परिणाम उत्पन्न करती है, तो इसे "सत्य" माना जाता है, यदि उनमें से कोई भी हो
परिणाम गलत या शून्य नहीं है। यदि यह शून्य परिणाम देता है, तो इसे गलत माना जाता है।

यदि उपयोग कर रहे हैं तो अधिक मामलों को जोड़ा जा सकता है elif A फिर B वाक्य - विन्यास।

जेक्यू, अगर। == 0 तब

"शून्य" एलिफ। == 1 फिर "एक" और "अनेक" अंत´ 2 => "अनेक"

>, >=, <=, <
तुलना ऑपरेटर >, >=, <=, < वापसी करें कि क्या उनका बायां तर्क इससे बड़ा है,
उनके सही तर्क से बड़ा या उसके बराबर, उससे कम या उसके बराबर या उससे कम
(क्रमश)।

क्रम वही है जो इसके लिए वर्णित है तरह, ऊपर।

जेक्यू . <5´
2
=> सच

और/या/नहीं
jq सामान्य बूलियन ऑपरेटरों का समर्थन करता है और/या/नहीं। उनके पास सच्चाई का एक ही मानक है
जैसे कि भाव - झूठे और अशक्त को "गलत मान" माना जाता है, और कुछ और है a
"वास्तविक मूल्य"।

यदि इनमें से किसी एक ऑपरेटर का ऑपरेंड कई परिणाम देता है, तो ऑपरेटर स्वयं
प्रत्येक इनपुट के लिए एक परिणाम उत्पन्न करेगा।

नहीं वास्तव में एक ऑपरेटर के बजाय एक बिल्टिन फ़ंक्शन है, इसलिए इसे फ़िल्टर के रूप में कहा जाता है
विशेष वाक्य रचना के बजाय किन चीजों को पाइप किया जा सकता है, जैसा कि in .फू और .Cafe | नहीं.

ये तीनों केवल "सत्य" और "झूठे" मान उत्पन्न करते हैं, और इसलिए केवल वास्तविक के लिए उपयोगी होते हैं
सामान्य पर्ल/पायथन/रूबी मुहावरे के बजाय बूलियन ऑपरेशंस
"value_that_may_be_null या डिफ़ॉल्ट"। यदि आप "या" के इस रूप का उपयोग करना चाहते हैं, तो बीच में चयन करें
किसी शर्त का मूल्यांकन करने के बजाय दो मान, नीचे "//" ऑपरेटर देखें।

jq 42 और "एक स्ट्रिंग"´
रिक्त
=> सच

jq (सत्य, असत्य) या असत्य´
रिक्त
=> सत्य, असत्य

jq (सत्य, सत्य) और (सत्य, असत्य)´
रिक्त
=> सत्य, असत्य, सत्य, असत्य

jq [सच, झूठा | नहीं
रिक्त
=> [झूठा, सच]

विकल्प ऑपरेटर - //
प्रपत्र का एक फ़िल्टर a // b के समान परिणाम उत्पन्न करता है a, अगर a अन्य परिणाम उत्पन्न करता है
से असत्य और रिक्त। अन्यथा, a // b के समान परिणाम उत्पन्न करता है b.

यह डिफ़ॉल्ट प्रदान करने के लिए उपयोगी है: .फू // 1 का मूल्यांकन करेंगे evaluate 1 अगर वहाँ नहीं है .फू
इनपुट में तत्व। यह कैसे के समान है or कभी-कभी पायथन में प्रयोग किया जाता है (jq´s or ऑपरेटर
सख्ती से बूलियन संचालन के लिए आरक्षित है)।

jq .foo // 42´
{"फू": 19}
=> २

jq .foo // 42´
{}
=> २

पकड़ने की कोशिश
का उपयोग करके त्रुटियों को पकड़ा जा सकता है कोशिश ऍक्स्प पकड़ ऍक्स्प. पहली अभिव्यक्ति निष्पादित की जाती है, और if
यह विफल रहता है तो दूसरा त्रुटि संदेश के साथ निष्पादित किया जाता है। हैंडलर का आउटपुट, if
कोई भी, आउटपुट है जैसे कि यह कोशिश करने के लिए अभिव्यक्ति का आउटपुट था।

RSI कोशिश ऍक्स्प प्रपत्र उपयोग खाली अपवाद हैंडलर के रूप में।

jq try .a catch ". कोई वस्तु नहीं है"´
<strong>उद्देश्य</strong>
=> ". कोई वस्तु नहीं है"

jq [.[]|कोशिश .a]´
[{}, सच, {"ए":1}]
=> [शून्य, 1]

jq try error("someException") catch .´
<strong>उद्देश्य</strong>
=> "कुछ अपवाद"

तोड़कर आउट of नियंत्रण संरचनाओं
कोशिश/पकड़ का एक सुविधाजनक उपयोग नियंत्रण संरचनाओं से बाहर निकलना है जैसे को कम करने, प्रत्येक के लिए,
जब, और इतने पर.

उदाहरण के लिए:

# किसी व्यंजक को तब तक दोहराएं जब तक कि वह "ब्रेक" को an . के रूप में न बढ़ा दे
# त्रुटि, फिर त्रुटि को फिर से उठाए बिना दोहराना बंद करें।
# लेकिन अगर पकड़ी गई त्रुटि "ब्रेक" नहीं है, तो इसे फिर से उठाएं।
दोहराने का प्रयास करें (एक्सपी) पकड़ें। == "ब्रेक" फिर खाली और त्रुटि;

jq में "ब्रेक" या "गो (बैक) टू" नामित लेक्सिकल लेबल्स के लिए एक सिंटैक्स है:

लेबल $आउट | ... $ बाहर तोड़ो ...

RSI तोड़ना $लेबल_नाम अभिव्यक्ति कार्यक्रम को निकटतम के रूप में कार्य करने का कारण बनेगी
(बांई ओर) लेबल $लेबल_नाम उत्पादित खाली.

के बीच संबंध तोड़ना और इसी लेबल शाब्दिक है: लेबल होना चाहिए
ब्रेक से "दृश्यमान"।

ए से बाहर निकलने के लिए को कम करने, उदाहरण के लिए:

लेबल $आउट | कम करें। [] $ आइटम के रूप में (शून्य; अगर .== झूठा तो $ बाहर तोड़ दें ... अंत)

निम्नलिखित jq प्रोग्राम एक सिंटैक्स त्रुटि उत्पन्न करता है:

$बाहर तोड़ो

क्योंकि कोई लेबल नहीं $आउट दिख रहा है।

? ऑपरेटर
RSI ? ऑपरेटर, के रूप में इस्तेमाल किया क्स्प?, के लिए आशुलिपि है कोशिश ऍक्स्प.

jq [.[]|(.a)?]´
[{}, सच, {"ए":1}]
=> [शून्य, 1]

नियमित अभिव्यक्ति (पीसीआरई)


jq ओनिगुरुमा रेगुलर एक्सप्रेशन लाइब्रेरी का उपयोग करता है, जैसे php, रूबी, टेक्स्टमैट, सब्लिमे टेक्स्ट,
आदि, इसलिए यहां विवरण jq विशिष्टताओं पर केंद्रित होगा।

jq रेगेक्स फ़िल्टर को परिभाषित किया गया है ताकि इन पैटर्नों में से किसी एक का उपयोग करके उनका उपयोग किया जा सके:

स्ट्रिंग | फ़िल्टर (रेगेक्स)
स्ट्रिंग | फ़िल्टर (रेगेक्स; झंडे)
स्ट्रिंग | फ़िल्टर ( [रेगेक्स] )
स्ट्रिंग | फ़िल्टर ([रेगेक्स, फ़्लैग्स])

जहां: * STRING, REGEX और FLAGS jq स्ट्रिंग्स हैं और jq स्ट्रिंग इंटरपोलेशन के अधीन हैं; *
रेगेक्स, स्ट्रिंग इंटरपोलेशन के बाद, एक वैध पीसीआरई रेगेक्स होना चाहिए; *फ़िल्टर इनमें से एक है परीक्षण,
मैचया, कब्जा, निम्नलिखित अनुसार।

FLAGS एक स्ट्रिंग है जिसमें समर्थित फ़्लैग में से एक में से एक है:

· g - वैश्विक खोज (सभी मिलान खोजें, न कि केवल पहले)

· i - केस असंवेदनशील खोज

· m - मल्टी लाइन मोड (´.´ न्यूलाइन से मेल खाएगा)

· n - खाली मैचों पर ध्यान न दें

· p - s और m दोनों मोड सक्षम हैं

· s - सिंगल लाइन मोड (´^´ -> ´\A´, ´$´ -> ´\Z´)

· l - सबसे लंबे समय तक संभव मैच खोजें

· x - विस्तारित रेगेक्स प्रारूप (व्हाट्सएप और टिप्पणियों पर ध्यान न दें)

x पैटर्न में व्हॉट्सएप का मिलान करने के लिए \s जैसे एस्केप का उपयोग करें, उदा

परीक्षण ("ए \ एसबी", "एक्स")।

ध्यान दें कि कुछ फ़्लैग्स को REGEX में भी निर्दिष्ट किया जा सकता है, उदाहरण के लिए

· jq -n ("टेस्ट", "टेस्ट", "टेस्ट", "टेस्ट") | परीक्षण ("(?i) ते (?-i) सेंट")´

का मूल्यांकन करता है: सत्य, सत्य, झूठा, झूठा।

[आवश्यक 1.5] परीक्षण (वैल), परीक्षण (रेगेक्स; झंडे)
पसंद मैच, लेकिन मैच की वस्तुओं को वापस नहीं करता है, केवल <strong>उद्देश्य</strong> or असत्य चाहे या नहीं के लिए
रेगेक्स इनपुट से मेल खाता है।

जेक्यू टेस्ट ("फू")´
"फू"
=> सच

जेक्यू .[] | परीक्षण ("एबीसी # रिक्त स्थान को अनदेखा किया जाता है"; "ix")´
["एक्सएबीसीडी", "एबीसी"]
=> सत्य, सत्य

[आवश्यक 1.5] मैच (वैल), मैच (रेगेक्स; झंडे)
मैच प्रत्येक मैच के लिए एक वस्तु को आउटपुट करता है। मैचों में निम्नलिखित फ़ील्ड हैं:

· ओफ़्सेट - इनपुट की शुरुआत से UTF-8 कोडपॉइंट में ऑफसेट

· लंबाई - मैच के UTF-8 कोडपॉइंट में लंबाई

· स्ट्रिंग - वह स्ट्रिंग जो इससे मेल खाती है

· कब्जा - कैप्चरिंग समूहों का प्रतिनिधित्व करने वाली वस्तुओं की एक सरणी।

समूह वस्तुओं को कैप्चर करने में निम्नलिखित फ़ील्ड होते हैं:

· ओफ़्सेट - इनपुट की शुरुआत से UTF-8 कोडपॉइंट में ऑफसेट

· लंबाई - इस कैप्चरिंग ग्रुप के UTF-8 कोडपॉइंट में लंबाई

· स्ट्रिंग - वह तार जिसे पकड़ा गया था

· नाम - कैप्चरिंग ग्रुप का नाम (या रिक्त अगर यह अनाम था)

किसी भी चीज़ से मेल नहीं खाने वाले समूहों को कैप्चर करना -1 . का ऑफ़सेट लौटाता है

जेक्यू मैच ("(एबीसी) +"; "जी")´
"एबीसी एबीसी"
=> {"ऑफ़सेट": 0, "लंबाई": 3, "स्ट्रिंग": "एबीसी", "कैप्चर": [{"ऑफ़सेट": 0, "लंबाई": 3, "स्ट्रिंग": "एबीसी", " नाम": नल}]}, {"ऑफ़सेट": 4, "लंबाई": 3, "स्ट्रिंग": "एबीसी", "कैप्चर": [{"ऑफ़सेट": 4, "लंबाई": 3, "स्ट्रिंग" : "एबीसी", "नाम": शून्य}]}

जेक्यू मैच ("फू")´
"फू बार फू"
=> {"ऑफसेट": 0, "लंबाई": 3, "स्ट्रिंग": "फू", "कैप्चर": []}

जेक्यू मैच (["फू", "आईजी"])´
"फू बार फू"
=> {"ऑफ़सेट": 0, "लंबाई": 3, "स्ट्रिंग": "फू", "कैप्चर": []}, {"ऑफ़सेट": 8, "लंबाई": 3, "स्ट्रिंग": "फू "," कैप्चर ": []}

जेक मैच ("फू (? छड़)? फू"; "आईजी")´
"फू बार फू फू फू"
=> {"ऑफसेट": 0, "लंबाई": 11, "स्ट्रिंग": "फू बार फू", "कैप्चर": [{"ऑफसेट": 4, "लंबाई": 3, "स्ट्रिंग": "बार" , "नाम": "बार123"}]}, {"ऑफ़सेट": 12, "लंबाई": 8, "स्ट्रिंग": "फू फू", "कैप्चर": [{"ऑफ़सेट": -1, "लंबाई" : 0, "स्ट्रिंग": शून्य, "नाम": "बार123"}]}

jq [ मैच ("।"; "जी")] | लंबाई
"एबीसी"
=> २

[आवश्यक 1.5] कब्जा (वैल), कैप्चर (रेगेक्स; झंडे)
एक JSON ऑब्जेक्ट में नामित कैप्चर को कुंजी के रूप में प्रत्येक कैप्चर के नाम के साथ एकत्रित करता है,
और मिलान किए गए स्ट्रिंग को संबंधित मान के रूप में।

jq capture("(? [az]+)-(? [0-9]+)")´
"xyzzy-14"
=> {"a": "xyzzy", "n": "14"}

[आवश्यक 1.5] स्कैन (रेगेक्स), स्कैन (रेगेक्स; झंडे)
रेगेक्स से मेल खाने वाले इनपुट के गैर-अतिव्यापी सबस्ट्रिंग की एक धारा उत्सर्जित करें
झंडे के अनुसार, यदि कोई निर्दिष्ट किया गया है। यदि कोई मेल नहीं है, तो धारा है
खाली। प्रत्येक इनपुट स्ट्रिंग के सभी मैचों को कैप्चर करने के लिए, मुहावरे का उपयोग करें [ expr ], उदा [
स्कैन (रेगेक्स) ].

विभाजन (रेगेक्स; झंडे)
पश्च संगतता के लिए, विभाजित एक स्ट्रिंग पर विभाजित होता है, रेगेक्स नहीं।

[आवश्यक 1.5] विभाजन (रेगेक्स), विभाजन (रेगेक्स; झंडे)
ये वही परिणाम प्रदान करते हैं जो उनके विभाजित समकक्षों, लेकिन एक के बजाय एक धारा के रूप में
सरणी।

[आवश्यक 1.5] उप (रेगेक्स; स्ट्रिंग) उप (रेगेक्स; डोरी; झंडे)
इनपुट स्ट्रिंग में रेगेक्स के पहले मैच को बदलकर प्राप्त स्ट्रिंग को उत्सर्जित करें
तार, इंटरपोलेशन के बाद। तार एक jq स्ट्रिंग होना चाहिए, और इसमें संदर्भ हो सकते हैं
नामित कब्जा करने के लिए। नामांकित कैप्चर, वास्तव में, JSON ऑब्जेक्ट के रूप में प्रस्तुत किए जाते हैं (as .)
द्वारा निर्मित कब्जा) करने के लिए तार, इसलिए "x" नामक एक कैप्चर किए गए चर का संदर्भ होगा
फॉर्म लें: "(.x)"।

[आवश्यक 1.5] जीएसयूबी (रेगेक्स; डोरी), जीएसयूबी (रेगेक्स; डोरी; झंडे)
gsub के समान ही नीचे लेकिन रेगेक्स की सभी गैर-अतिव्यापी घटनाओं को द्वारा प्रतिस्थापित किया जाता है
स्ट्रिंग, प्रक्षेप के बाद।

उन्नत विशेषताएं


अधिकांश प्रोग्रामिंग भाषाओं में चर एक परम आवश्यकता हैं, लेकिन उन्हें हटा दिया गया है
jq में "उन्नत सुविधा" के लिए।

अधिकांश भाषाओं में, चर डेटा को प्रसारित करने का एकमात्र साधन हैं। यदि आप ए की गणना करते हैं
मान, और आप इसे एक से अधिक बार उपयोग करना चाहते हैं, तो आपको इसे एक चर में संग्रहीत करने की आवश्यकता होगी। प्रति
कार्यक्रम के दूसरे भाग के लिए एक मान पास करें, आपको कार्यक्रम के उस भाग की आवश्यकता होगी
एक चर परिभाषित करें (फ़ंक्शन पैरामीटर के रूप में, ऑब्जेक्ट सदस्य, या जो कुछ भी) जिसमें जगह है
आँकड़े।

jq में फ़ंक्शन को परिभाषित करना भी संभव है, हालांकि यह एक ऐसी विशेषता है जिसका सबसे बड़ा
उपयोग jq´s मानक पुस्तकालय को परिभाषित कर रहा है (कई jq फ़ंक्शन जैसे नक्शा और खोज वास्तव में हैं
jq) में लिखा है।

jq में कमी करने वाले ऑपरेटर हैं, जो बहुत शक्तिशाली हैं लेकिन थोड़े मुश्किल हैं। फिर से, ये हैं
jq के मानक पुस्तकालय के कुछ उपयोगी बिट्स को परिभाषित करने के लिए ज्यादातर आंतरिक रूप से उपयोग किया जाता है।

यह पहली बार में स्पष्ट नहीं हो सकता है, लेकिन jq जनरेटर के बारे में है (हाँ, जैसा कि अक्सर पाया जाता है
अन्य भाषाएँ)। जनरेटर से निपटने में मदद के लिए कुछ उपयोगिताएँ प्रदान की जाती हैं।

कुछ न्यूनतम I/O समर्थन (मानक इनपुट से JSON पढ़ने और JSON को लिखने के अलावा
मानक आउटपुट) उपलब्ध है।

अंत में, एक मॉड्यूल/लाइब्रेरी सिस्टम है।

चर
jq में, सभी फ़िल्टर में एक इनपुट और एक आउटपुट होता है, इसलिए मैन्युअल प्लंबिंग की आवश्यकता नहीं होती है
प्रोग्राम के एक भाग से दूसरे भाग में मान पास करें। कई भाव, उदाहरण के लिए a + b,
उनके इनपुट को दो अलग-अलग उप-अभिव्यक्तियों में पास करें (यहां a और b दोनों एक ही पारित कर रहे हैं
इनपुट), इसलिए दो बार मान का उपयोग करने के लिए चर आमतौर पर आवश्यक नहीं होते हैं।

उदाहरण के लिए, संख्याओं की एक सरणी के औसत मान की गणना करने के लिए कुछ की आवश्यकता होती है
अधिकांश भाषाओं में चर - कम से कम एक सरणी धारण करने के लिए, शायद प्रत्येक तत्व के लिए एक
या लूप काउंटर के लिए। jq में, यह बस है जोड़ना / लंबाई - जोड़ना अभिव्यक्ति दी गई है
सरणी और इसके योग का उत्पादन करता है, और लंबाई अभिव्यक्ति को सरणी दी जाती है और इसका उत्पादन करती है
लंबाई।

इसलिए, चर को परिभाषित करने की तुलना में jq में अधिकांश समस्याओं को हल करने के लिए आम तौर पर एक क्लीनर तरीका है।
फिर भी, कभी-कभी वे चीजों को आसान बनाते हैं, इसलिए jq आपको चर का उपयोग करके परिभाषित करने देता है
अभिव्यक्ति as $परिवर्तनीय. सभी चर नाम से शुरू होते हैं $. यहाँ´सा थोड़ा बदसूरत संस्करण
सरणी-औसत उदाहरण के:

लंबाई $array_length के रूप में | जोड़ें / $array_length

वास्तव में चर का उपयोग करने वाली स्थिति को खोजने के लिए हमें एक और अधिक जटिल समस्या की आवश्यकता होगी
हमारे जीवन को आसान बनाता है।

मान लीजिए कि हमारे पास "लेखक" और "शीर्षक" फ़ील्ड के साथ ब्लॉग पोस्ट की एक सरणी है, और अन्य
ऑब्जेक्ट जिसका उपयोग लेखक उपयोगकर्ता नाम को वास्तविक नामों से मैप करने के लिए किया जाता है। हमारा इनपुट इस तरह दिखता है:

{"पोस्ट": [{"शीर्षक": "फ्रिस्ट psot", "लेखक": "anon"},
{"शीर्षक": "एक अच्छी तरह से लिखा गया लेख", "लेखक": "व्यक्ति 1"}],
"असली नाम": {"अनोन": "बेनामी कायर",
"person1": "पर्सन मैकफर्सन"}}

हम वास्तविक नाम वाले लेखक फ़ील्ड के साथ पोस्ट तैयार करना चाहते हैं, जैसे कि:

{"शीर्षक": "फ्रिस्ट प्सोट", "लेखक": "बेनामी कायर"}
{"शीर्षक": "एक अच्छी तरह से लिखा गया लेख", "लेखक": "व्यक्ति मैकफर्सन"}

हम वास्तविक नाम वस्तु को संग्रहीत करने के लिए एक चर, $names का उपयोग करते हैं, ताकि हम इसे बाद में संदर्भित कर सकें
लेखक उपयोगकर्ता नाम खोजते समय:

.realnames as $names | पोस्ट [] | {शीर्षक, लेखक: $names[.author]}

मुहावरा exp as $x | ... अर्थ: अभिव्यक्ति के प्रत्येक मूल्य के लिए exp, बाकी चलाओ
संपूर्ण मूल इनपुट के साथ पाइपलाइन, और साथ $x उस मान पर सेट करें। इस प्रकार as
फ़ोरैच लूप के रूप में कार्य करता है।

बस के रूप में {फू} लिखने का एक आसान तरीका है {फू: .फू}, इतना {$फू} लिखने का एक आसान तरीका है
{फू:$फू}.

एकल का उपयोग करके एकाधिक चर घोषित किए जा सकते हैं as एक पैटर्न प्रदान करके अभिव्यक्ति
जो इनपुट की संरचना से मेल खाता है (इसे "विनाशकारी" के रूप में जाना जाता है):

. जैसे {वास्तविक नाम: $नाम, पद: [$प्रथम, $सेकंड]} | ...

सरणी पैटर्न में परिवर्तनीय घोषणाएं (उदाहरण के लिए, . as [$पहले, $सेकंड]) के लिए बाध्य
अनुक्रमित शून्य पर तत्व से सरणी के तत्व क्रम में। जब कोई नहीं है
एक सरणी पैटर्न तत्व के लिए सूचकांक पर मान, रिक्त उस चर के लिए बाध्य है।

वेरिएबल को बाकी एक्सप्रेशन पर स्कोप किया जाता है जो उन्हें परिभाषित करता है, इसलिए

.realnames as $names | (.posts[] | {शीर्षक, लेखक: $names[.author]})

काम करेगा, लेकिन

(.realnames as $names | .posts[]) | {शीर्षक, लेखक: $names[.author]}

नहीं होगा।

प्रोग्रामिंग भाषा सिद्धांतकारों के लिए, यह कहना अधिक सटीक है कि jq चर हैं
लेक्सिकली-स्कोप्ड बाइंडिंग। विशेष रूप से बाध्यकारी के मूल्य को बदलने का कोई तरीका नहीं है;
कोई केवल उसी नाम से एक नया बंधन स्थापित कर सकता है, लेकिन जो दिखाई नहीं देगा
पुराना था।

jq .bar के रूप में $x | .फू | . + $x´
{"फू":10, "बार":200}
=> २

जेक्यू . $i|[(.*2|. as $i| $i), $i]´ . के रूप में
5
=> [10,5]

जेक्यू . के रूप में [$a, $b, {c: $c}] | $a + $b + $c´
[2, 3, {"सी": 4, "डी": 5}]
=> २

jq .[] के रूप में [$a, $b] | {ए: $ए, बी: $बी}´
[[0], [0, 1], [2, 1, 0]]
=> {"a":0,"b":null}, {"a":0,"b":1}, {"a":2,"b":1}

परिभाषित कार्य
आप "डीफ़" सिंटैक्स का उपयोग करके फ़िल्टर को एक नाम दे सकते हैं:

डीईएफ़ वृद्धि:। + 1;

तब से, वेतन वृद्धि एक बिल्टिन फ़ंक्शन की तरह एक फिल्टर के रूप में प्रयोग करने योग्य है (वास्तव में, यह
यह है कि कुछ बिल्टिन कैसे परिभाषित किए जाते हैं)। एक फ़ंक्शन तर्क ले सकता है:

डीईएफ़ नक्शा (एफ): [.[] | एफ];

तर्कों को फ़िल्टर के रूप में पारित किया जाता है, मानों के रूप में नहीं। उसी तर्क का उल्लेख किया जा सकता है
अलग-अलग इनपुट के साथ कई बार (यहां f इनपुट सरणी के प्रत्येक तत्व के लिए चलाया जाता है)।
फ़ंक्शन के तर्क मूल्य तर्कों की तुलना में कॉलबैक की तरह अधिक काम करते हैं। यह है
समझना महत्वपूर्ण है। विचार करना:

डीईएफ़ फू (एफ): एफ | एफ;
5|फू(.*2)

परिणाम 20 होगा क्योंकि f is .*2, और के पहले आह्वान के दौरान f . 5 होगा,
और दूसरी बार यह 10 (5 * 2) होगा, इसलिए परिणाम 20 होगा। फ़ंक्शन तर्क
फ़िल्टर हैं, और फ़िल्टर लागू होने पर इनपुट की अपेक्षा करते हैं।

यदि आप सरल कार्यों को परिभाषित करने के लिए मूल्य-तर्क व्यवहार चाहते हैं, तो आप बस a . का उपयोग कर सकते हैं
चर:

def addvalue(f): f as $f | नक्शा (। + $ एफ);

या शॉर्ट-हैंड का उपयोग करें:

डीईएफ़ एडवैल्यू ($ एफ): ...;

किसी भी परिभाषा के साथ, अतिरिक्त मूल्य (.foo) वर्तमान इनपुट जोड़ देगा´s .फू प्रत्येक के लिए क्षेत्र
सरणी का तत्व।

समान फ़ंक्शन नाम का उपयोग करने वाली एकाधिक परिभाषाओं की अनुमति है। प्रत्येक पुन: परिभाषा को प्रतिस्थापित करता है
फ़ंक्शन तर्कों की समान संख्या के लिए पिछला वाला, लेकिन केवल संदर्भों के लिए
कार्य (या मुख्य कार्यक्रम) पुन: परिभाषा के बाद।

jq def addvalue(f): . + [एफ]; नक्शा (अतिरिक्त मूल्य (.[0]))´
[[1,2], [10,20]]
=> [[1,2,1], [10,20,10]]

jq def addvalue(f): f as $x | नक्शा (। + $ एक्स); अतिरिक्त मूल्य (.[0])´
[[1,2], [10,20]]
=> [[1,2,1,2], [10,20,1,2]]

कम करना
RSI को कम करने jq में सिंटैक्स आपको अभिव्यक्ति के सभी परिणामों को संयोजित करने की अनुमति देता है
उन्हें एक ही उत्तर में जमा करना। एक उदाहरण के रूप में, हम पास करेंगे [3,2,1] इस के लिए
अभिव्यक्ति:

कम करें। [] $ आइटम के रूप में (0;। + $ आइटम)

प्रत्येक परिणाम के लिए कि .[] पैदा करता है, . + $आइटम चल रहे कुल को जमा करने के लिए चलाया जाता है,
0 से शुरू। इस उदाहरण में, .[] परिणाम 3, 2, और 1 उत्पन्न करता है, इसलिए प्रभाव है
कुछ इस तरह चलाने के समान:

0 | (3 के रूप में $आइटम | . + $आइटम) |
(2 के रूप में $आइटम | । + $आइटम) |
(1 के रूप में $आइटम | . + $आइटम)

jq reduce .[] $item के रूप में (0; . + $item)´
[10,2,5,3]
=> २

सीमा (एन; क्स्प)
RSI सीमा समारोह निष्कर्ष n से आउटपुट exp.

jq [सीमा(3;.[])]´
[0,1,2,3,4,5,6,7,8,9]
=> [0,1,2]

पहला (एक्सपीआर), अंतिम (एक्सपीआर), एनएच (एन; एक्सपीआर)
RSI पहला (एक्सपीआर) और अंतिम (एक्सपीआर) फ़ंक्शन पहले और अंतिम मान को से निकालता है expr,
क्रमशः.

RSI एनएच (एन; एक्सपीआर) फ़ंक्शन nth मान आउटपुट को निकालता है expr. इसे इस प्रकार परिभाषित किया जा सकता है
डीईएफ़ एनएच (एन; एक्सपीआर): अंतिम(सीमा(एन + 1; एक्सपीआर));। ध्यान दें कि एनएच (एन; एक्सपीआर) समर्थन नहीं करता
के ऋणात्मक मान n.

jq [प्रथम (रेंज (।)), अंतिम (रेंज (।)), nth (./2; रेंज (।))]´
10
=> [0,9,5]

प्रथम, अंतिम, एनएच (एन)
RSI प्रथम और पिछली बार फ़ंक्शन किसी भी सरणी से पहले और अंतिम मान निकालते हैं ..

RSI एनएच (एन) फ़ंक्शन किसी भी सरणी के nth मान को निकालता है ..

jq [रेंज (।)] | [पहला, आखिरी, n वें(5)]´
10
=> [0,9,5]

प्रत्येक के लिए
RSI प्रत्येक के लिए वाक्य रचना के समान है को कम करने, लेकिन के निर्माण की अनुमति देने का इरादा सीमा
और रेड्यूसर जो मध्यवर्ती परिणाम उत्पन्न करते हैं (उदाहरण देखें)।

रूप है प्रत्येक के लिए ऍक्स्प as $var (इस में; अपडेट करें; निचोड़)। जैसा को कम करने, INIT मूल्यांकन किया जाता है
एक बार राज्य मूल्य का उत्पादन करने के लिए, फिर प्रत्येक आउटपुट ऍक्स्प स्वाभाविक है $var, अद्यतन is
के प्रत्येक आउटपुट के लिए मूल्यांकन किया गया ऍक्स्प वर्तमान स्थिति के साथ और साथ $var दृश्यमान। प्रत्येक मान
द्वारा आउटपुट अद्यतन पिछली स्थिति को प्रतिस्थापित करता है। आखिरकार, EXTRACT प्रत्येक नए के लिए मूल्यांकन किया जाता है
का आउटपुट निकालने के लिए राज्य प्रत्येक के लिए.

यह ज्यादातर केवल निर्माण के लिए उपयोगी है को कम करने- और सीमा- जैसे कार्य। लकिन यह है
बहुत अधिक सामान्य, क्योंकि यह आंशिक कटौती की अनुमति देता है (नीचे उदाहरण देखें)।

jq ´[foreach .[] $item के रूप में ([[],[]]; अगर $item == null तो [[],.[0]] और [(.[0] + [$item]),[ ]] अंत; अगर $आइटम == शून्य तो [1] और खाली अंत)]´
[1,2,3,4,अशक्त,"ए", "बी", अशक्त]
=> [[1,2,3,4], ["ए", "बी"]]

Recursion
जैसा ऊपर बताया गया है, फिर से इकट्ठा करना रिकर्सन का उपयोग करता है, और कोई भी jq फ़ंक्शन पुनरावर्ती हो सकता है।
जब बिल्टिन को रिकर्सन के संदर्भ में भी लागू किया गया है।

जब भी रिकर्सिव कॉल आउटपुट के बाईं ओर अभिव्यक्ति होती है तो टेल कॉल को अनुकूलित किया जाता है
इसका अंतिम मूल्य। व्यवहार में इसका अर्थ है कि पुनरावर्ती के बाईं ओर का व्यंजक
कॉल को प्रत्येक इनपुट के लिए एक से अधिक आउटपुट नहीं देना चाहिए।

उदाहरण के लिए:

डीईएफ़ रिकर्स (एफ): डीईएफ़ आर:।, (एफ | चयन करें (।! = शून्य) | आर); आर;

def जबकि (cond; अद्यतन):
डीईएफ़ _जबकि:
अगर cond तो।, (अपडेट | _जबकि) और खाली अंत;
_जबकि;

डीईएफ़ दोहराना (expक्स्प):
def _repeat:
क्स्प, _दोहराना;
_दोहराना;

जेनरेटर और पुनरावर्तक
कुछ jq ऑपरेटर और फ़ंक्शन वास्तव में जेनरेटर होते हैं जिसमें वे शून्य उत्पन्न कर सकते हैं,
प्रत्येक इनपुट के लिए एक, या अधिक मान, जैसा कि कोई अन्य प्रोग्रामिंग में उम्मीद कर सकता है
जिन भाषाओं में जनरेटर हैं। उदाहरण के लिए, .[] इसके इनपुट में सभी मान उत्पन्न करता है
(जो एक सरणी या वस्तु होनी चाहिए), रेंज(0; 10) 0 और . के बीच पूर्णांक उत्पन्न करता है
10, और इसी तरह।

यहां तक ​​​​कि अल्पविराम ऑपरेटर एक जनरेटर है, जो पहले उत्पन्न मूल्यों को उत्पन्न करता है
अल्पविराम के बाईं ओर अभिव्यक्ति, फिर उनमें से प्रत्येक के लिए, द्वारा उत्पन्न मान
अल्पविराम के दाईं ओर अभिव्यक्ति।

RSI खाली बिल्टिन जनरेटर है जो शून्य आउटपुट उत्पन्न करता है। खाली builtin
पूर्ववर्ती जनरेटर अभिव्यक्ति के लिए बैकट्रैक।

सभी jq फ़ंक्शन केवल बिलिन जनरेटर का उपयोग करके जनरेटर हो सकते हैं। यह भी संभव है
केवल रिकर्सन और अल्पविराम ऑपरेटर का उपयोग करके नए जेनरेटर को परिभाषित करने के लिए। यदि पुनरावर्ती
कॉल (हैं) "पूंछ की स्थिति में" है तो जनरेटर कुशल होगा। उदाहरण में
द्वारा रिकर्सिव कॉल के नीचे _श्रेणी अपने आप में पूंछ की स्थिति में है। उदाहरण दिखाता है
तीन उन्नत विषय: टेल रिकर्सन, जनरेटर निर्माण और उप-कार्य।

jq def रेंज (init; upto; by): def _range: if (by> 0 and . <upto) or (by <0 and . > upto) तब ., ((.+by)|_range) और । समाप्त; अगर द्वारा == 0 तो init और init|_range end | चयन करें ((द्वारा> 0 और। < तक) या (<0 और।> तक)); रेंज (0; 10; 3)´
रिक्त
=> 0, 3, 6, 9

jq def जबकि (cond; अद्यतन): def _ जबकि: यदि cond तो।, (अपडेट | _जबकि) अन्य खाली अंत; _जबकि; [जबकि (.<100; .*2)]´
1
=> [1,2,4,8,16,32,64]

गणित


jq में वर्तमान में केवल IEEE754 डबल-प्रेसिजन (64-बिट) फ्लोटिंग पॉइंट नंबर सपोर्ट है।

सरल अंकगणितीय ऑपरेटरों के अलावा जैसे +, jq में अधिकांश मानक गणित कार्य भी हैं
सी गणित पुस्तकालय से। सी गणित कार्य जो एक इनपुट तर्क लेते हैं (उदाहरण के लिए, पाप ())
शून्य-तर्क jq फ़ंक्शन के रूप में उपलब्ध हैं। सी गणित के कार्य जो दो इनपुट लेते हैं
तर्क (जैसे, पाउ ()) दो-तर्क jq फ़ंक्शंस के रूप में उपलब्ध हैं जो अनदेखा करते हैं ..

मानक गणित कार्यों की उपलब्धता संबंधित की उपलब्धता पर निर्भर करती है
आपके ऑपरेटिंग सिस्टम और सी गणित पुस्तकालय में गणित कार्य करता है। अनुपलब्ध गणित कार्य
परिभाषित किया जाएगा लेकिन एक त्रुटि उठाएगा।

मैं / हे


इस समय jq के पास I/O के लिए न्यूनतम समर्थन है, ज्यादातर कब . पर नियंत्रण के रूप में
इनपुट पढ़े जाते हैं। इसके लिए दो बिल्टिन फंक्शन दिए गए हैं, निवेश और निविष्टियां, जो पढ़ा
एक ही स्रोत से (जैसे, stdin, कमांड-लाइन पर नामित फाइलें) jq के रूप में ही। इन
दो बिलिन, और jq की अपनी पठन क्रियाएं, एक दूसरे के साथ इंटरलीव की जा सकती हैं।

एक बिलिन न्यूनतम आउटपुट क्षमता प्रदान करता है, डिबग. (याद रखें कि एक jq प्रोग्राम´s
आउटपुट मान हमेशा JSON टेक्स्ट के रूप में आउटपुट होते हैं stdout।) डिबग बिल्टिन हो सकता है
एप्लिकेशन-विशिष्ट व्यवहार, जैसे निष्पादन योग्य के लिए जो libjq C API का उपयोग करते हैं लेकिन नहीं हैं
jq निष्पादन योग्य ही।

निवेश
एक नया इनपुट आउटपुट करता है।

निविष्टियां
एक-एक करके सभी शेष इनपुट को आउटपुट करता है।

यह मुख्य रूप से प्रोग्राम के इनपुट पर कटौती के लिए उपयोगी है।

डिबग
उत्पन्न होने वाले इनपुट मान के आधार पर डिबग संदेश का कारण बनता है। jq निष्पादन योग्य रैप्स
के साथ इनपुट मान ["डीबग:", ] और प्रिंट करता है और stderr पर एक नई लाइन,
संक्षेप में। यह भविष्य में बदल सकता है।

इनपुट_फ़ाइलनाम
उस फ़ाइल का नाम देता है जिसका इनपुट वर्तमान में फ़िल्टर किया जा रहा है। ध्यान दें कि यह
जब तक jq UTF-8 लोकेल में नहीं चल रहा है तब तक ठीक से काम नहीं करता है।

इनपुट_लाइन_नंबर
वर्तमान में फ़िल्टर किए जा रहे इनपुट की लाइन नंबर देता है।

स्ट्रीमिंग


उसके साथ --धारा विकल्प jq इनपुट टेक्स्ट को स्ट्रीमिंग तरीके से पार्स कर सकता है, जिससे jq
पार्स के बजाय बड़े JSON टेक्स्ट को तुरंत प्रोसेस करना शुरू करने के लिए प्रोग्राम
पूरा करता है। यदि आपके पास एक एकल JSON टेक्स्ट है जो आकार में 1GB है, तो इसकी स्ट्रीमिंग आपको अनुमति देगी
इसे और अधिक तेज़ी से संसाधित करने के लिए।

हालाँकि, स्ट्रीमिंग से निपटना आसान नहीं है क्योंकि jq प्रोग्राम में होगा [ ,
] (और कुछ अन्य रूप) इनपुट के रूप में।

धाराओं को संभालना आसान बनाने के लिए कई बिल्टिन प्रदान किए जाते हैं।

नीचे दिए गए उदाहरण के स्ट्रीम किए गए रूप का उपयोग करते हैं [0,[1]]है, जो है
[[0],0],[[1,0],1],[[1,0]],[[1]].

स्ट्रीमिंग रूपों में शामिल हैं [ , ] (किसी भी अदिश मान को इंगित करने के लिए, खाली सरणी,
या खाली वस्तु), और [ ] (किसी सरणी या वस्तु के अंत को इंगित करने के लिए)। भविष्य
jq के संस्करण के साथ चलते हैं --धारा और -सेक अतिरिक्त रूपों को आउटपुट कर सकता है जैसे कि ["त्रुटि
संदेश"] जब कोई इनपुट टेक्स्ट पार्स करने में विफल रहता है।

truncate_stream (stream_expression)
इनपुट के रूप में एक संख्या का उपभोग करता है और पथ तत्वों की संबंधित संख्या को से काटता है
दिए गए स्ट्रीमिंग एक्सप्रेशन के आउटपुट के बाईं ओर।

jq ´[1|truncate_stream([[0],1],[[1,0],2],[[1,0]],[[1]])]´
1
=> [[[0],2],[[0]]]

फ्रॉमस्ट्रीम (स्ट्रीम_एक्सप्रेशन)
स्ट्रीम एक्सप्रेशन के आउटपुट के अनुरूप आउटपुट मान।

jq ´fromstream(1|truncate_stream([[0],1],[[1,0],2],[[1,0]],[[1]]))´
रिक्त
=> [2]

धारा में
RSI धारा में बिल्टिन अपने इनपुट के स्ट्रीम किए गए फॉर्म को आउटपुट करता है।

जेक्यू . $डॉट के रूप में|फ्रॉमस्ट्रीम($डॉट|टूस्ट्रीम)|.==$डॉट´
[0,[1,{"a":1},{"b":2}]]
=> सच

ASSIGNMENT


अधिकांश प्रोग्रामिंग भाषाओं की तुलना में jq में असाइनमेंट थोड़ा अलग तरीके से काम करता है। जेक्यू नहीं करता है
किसी चीज़ के संदर्भ और प्रतियों के बीच अंतर करना - दो वस्तुएँ या सरणियाँ हैं
"एक ही वस्तु" या "नहीं" होने की किसी और धारणा के बिना या तो बराबर या बराबर नहीं
एक ही वस्तु"।

यदि किसी वस्तु में दो क्षेत्र हैं जो सरणियाँ हैं, .फू और .Cafe, और आप कुछ जोड़ते हैं
.फू, तो .Cafe बड़ा नहीं होगा। भले ही आपने अभी-अभी सेट किया हो .Cafe = .फू. यदि आप उपयोग कर रहे हैं
पायथन, जावा, रूबी, जावास्क्रिप्ट आदि भाषाओं में प्रोग्रामिंग करने के लिए तो आप सोच सकते हैं
इसके बारे में जैसे कि jq असाइनमेंट करने से पहले हर ऑब्जेक्ट की पूरी डीप कॉपी करता है
(प्रदर्शन के लिए, यह वास्तव में ऐसा नहीं करता है, लेकिन यह सामान्य विचार है)।

jq में सभी असाइनमेंट ऑपरेटरों के बाईं ओर पथ अभिव्यक्ति है।

=
फ़िल्टर .फू = 1 इनपुट के रूप में एक वस्तु लेगा और आउटपुट के रूप में एक वस्तु के साथ उत्पादन करेगा
"फू" फ़ील्ड 1 पर सेट है। jq में कुछ "संशोधित" या "बदलने" की कोई धारणा नहीं है -
सभी jq मान अपरिवर्तनीय हैं। उदाहरण के लिए,

.फू = .बार | .फू.बाज़ = 1

.bar.baz को 1 पर सेट करने का साइड-इफ़ेक्ट नहीं होगा, जैसा कि समान-दिखने वाला
जावास्क्रिप्ट, पायथन, रूबी या अन्य भाषाओं में कार्यक्रम होगा। इन भाषाओं के विपरीत (but
हास्केल और कुछ अन्य कार्यात्मक भाषाओं की तरह), दो सरणियों की कोई धारणा नहीं है या
वस्तुएं "एक ही सरणी" या "एक ही वस्तु" हैं। वे बराबर हो सकते हैं, या बराबर नहीं, लेकिन
यदि हम उनमें से एक को किसी भी परिस्थिति में नहीं बदलते हैं तो दूसरा हमारी पीठ पीछे नहीं बदलेगा।

इसका मतलब है कि jq में वृत्ताकार मान बनाना असंभव है (जैसे कि एक सरणी जिसका
पहला तत्व स्वयं है)। यह काफी इरादतन है, और यह सुनिश्चित करता है कि कुछ भी jq
प्रोग्राम का उत्पादन JSON में किया जा सकता है।

ध्यान दें कि =´ के बाईं ओर एक मान को संदर्भित करता है .। इस प्रकार $var.foo = 1 काम नहीं करेगा
आशा के अनुसार ($var.foo में मान्य या उपयोगी पथ व्यंजक नहीं है .); प्रयोग करें $var | .फू = 1
बजाय.

यदि =´ का दाहिना हाथ कई मान उत्पन्न करता है, तो ऐसे प्रत्येक मान के लिए jq होगा
बाईं ओर पथ को मान पर सेट करें और फिर यह संशोधित आउटपुट करेगा ..
उदाहरण के लिए, (ए, बी) =रेंज(2) outputs के {"ए":0,"बी":0}, तो {"ए":1,"बी":1}. अद्यतन"
असाइनमेंट फॉर्म (नीचे देखें) ऐसा नहीं करते हैं।

उस पर भी ध्यान दें .ए, बी = 0 सेट नहीं करता .a और .b, परंतु (.ए, बी) = 0 दोनों सेट करता है।

|=
साथ ही असाइनमेंट ऑपरेटर ´=´, jq "अपडेट" ऑपरेटर ´|=´ प्रदान करता है, जो
दाईं ओर एक फ़िल्टर लेता है और की संपत्ति के लिए नया मान निकालता है .
इस अभिव्यक्ति के माध्यम से पुराने मान को चलाकर असाइन किया जा रहा है। उदाहरण के लिए, .foo |=
.+1 इनपुट के "foo" प्लस 1 पर सेट "foo" फ़ील्ड के साथ एक ऑब्जेक्ट बनाएगा।

इस उदाहरण को ´=´ और ´|=´ के बीच अंतर दिखाना चाहिए:

कार्यक्रमों के लिए इनपुट {"a": {"b": 10}, "b": 20}´ प्रदान करें:

.a = .b .a |= .b

पूर्व इनपुट के "ए" फ़ील्ड को इनपुट के "बी" फ़ील्ड में सेट करेगा, और उत्पादन
आउटपुट {"ए": 20}। उत्तरार्द्ध इनपुट के "ए" फ़ील्ड को "ए" फ़ील्ड में सेट करेगा
"बी" फ़ील्ड, {"ए": 10} का उत्पादन करती है।

बाईं ओर कोई भी सामान्य पथ अभिव्यक्ति हो सकती है; देखो पथ().

ध्यान दें कि ´|=´ के बाईं ओर एक मान को संदर्भित करता है .। इस प्रकार $var.foo |= . + 1 नहीं होगा
उम्मीद के मुताबिक काम करें ($var.foo में मान्य या उपयोगी पथ व्यंजक नहीं है .); प्रयोग करें $var | .फू
|= . + 1 बजाय.

यदि दाहिनी ओर एकाधिक मान आउटपुट करता है, तो केवल अंतिम का उपयोग किया जाएगा।

jq (..|select(type=="boolean")) |= if . फिर 1 और 0 अंत´
[सच, झूठा, [5, सच, [सच, [झूठा]], झूठा]]
=> [1,0,[5,1,[1,[0]],0]]

+=, -=, *=, /=, %=, // =
jq में फॉर्म के कुछ ऑपरेटर हैं a सेशन = b, जो सभी के बराबर हैं a |= . op b। इसलिए,
+= 1 मूल्यों को बढ़ाने के लिए इस्तेमाल किया जा सकता है।

jq .foo += 1´
{"फू": 42}
=> {"फू": 43}

जटिल कार्य
jq असाइनमेंट के बाईं ओर अधिकांश की तुलना में बहुत अधिक चीजों की अनुमति है
भाषाएं। हमने पहले ही बाईं ओर सरल फ़ील्ड एक्सेस देखे हैं, और यह नहीं है
आश्चर्य है कि ऐरे एक्सेस भी काम करता है:

.posts[0].title = "JQ मैनुअल"

आश्चर्य की बात यह हो सकती है कि बाईं ओर की अभिव्यक्ति कई उत्पन्न कर सकती है
परिणाम, इनपुट दस्तावेज़ में विभिन्न बिंदुओं का जिक्र करते हुए:

.posts[].comments |= . + ["यह बहुत अच्छा है"]

वह उदाहरण प्रत्येक पोस्ट की "टिप्पणियों" सरणी में "यह बहुत अच्छा है" स्ट्रिंग जोड़ता है
इनपुट (जहां इनपुट "पोस्ट" फ़ील्ड वाला एक ऑब्जेक्ट है जो पोस्ट की एक सरणी है)।

जब jq को a = b´ जैसे असाइनमेंट का सामना करना पड़ता है, तो यह a . का चयन करने के लिए लिया गया "पथ" रिकॉर्ड करता है
निष्पादित करते समय इनपुट दस्तावेज़ का हिस्सा a. इस पथ का उपयोग तब पता लगाने के लिए किया जाता है कि . का कौन सा भाग है
असाइनमेंट निष्पादित करते समय बदलने के लिए इनपुट। किसी भी फिल्टर का इस्तेमाल किया जा सकता है
एक बराबर के बाएँ हाथ की ओर - इनपुट से वह जो भी पथ चुनता है वह वहीं होगा जहाँ
असाइनमेंट किया जाता है।

यह बहुत शक्तिशाली ऑपरेशन है। मान लीजिए कि हम ब्लॉग पोस्ट में एक टिप्पणी जोड़ना चाहते हैं, का उपयोग कर
ऊपर वही "ब्लॉग" इनपुट. इस बार, हम केवल द्वारा लिखी गई पोस्ट पर टिप्पणी करना चाहते हैं
"स्टेडोलन"। हम उन पदों को पहले वर्णित "चयन" फ़ंक्शन का उपयोग करके ढूंढ सकते हैं:

पोस्ट [] | चयन करें (. लेखक == "स्टेडोलन")

इस ऑपरेशन द्वारा प्रदान किए गए पथ "स्टेडोलन" द्वारा लिखे गए प्रत्येक पोस्ट को इंगित करते हैं, और
हम उनमें से प्रत्येक पर उसी तरह टिप्पणी कर सकते हैं जैसे हमने पहले किया था:

(.posts[] | select(.author == "stedolan") | .comments) |=
. + ["भयानक।"]

मॉड्यूल


jq में लाइब्रेरी/मॉड्यूल सिस्टम है। मॉड्यूल वे फाइलें हैं जिनके नाम समाप्त होते हैं .जेक्यू.

किसी प्रोग्राम द्वारा आयात किए गए मॉड्यूल को डिफ़ॉल्ट खोज पथ में खोजा जाता है (नीचे देखें)।
आयात और शामिल निर्देश आयातक को इस पथ को बदलने की अनुमति देते हैं।

खोज पथ में पथ विभिन्न प्रतिस्थापन के अधीन हैं।

"~/" से शुरू होने वाले पथ के लिए, उपयोगकर्ता की होम निर्देशिका को "~" के लिए प्रतिस्थापित किया जाता है।

"$ORIGIN/" से शुरू होने वाले पथों के लिए jq निष्पादन योग्य पथ को प्रतिस्थापित किया जाता है
"$ मूल"।

"./" से शुरू होने वाले पथ या "।" वाले पथ के लिए, फ़ाइल सहित पथ है
इसके लिए प्रतिस्थापित "।"। कमांड-लाइन पर दिए गए शीर्ष-स्तरीय कार्यक्रमों के लिए, वर्तमान
निर्देशिका का उपयोग किया जाता है।

आयात निर्देश वैकल्पिक रूप से एक खोज पथ निर्दिष्ट कर सकते हैं जिसमें डिफ़ॉल्ट जोड़ा गया है।

डिफ़ॉल्ट खोज पथ को दिया गया खोज पथ है -L कमांड-लाइन विकल्प, अन्य
["~/.jq", "$ मूल/../lib/jq", "$मूल/../ दायित्व"].

शून्य और खाली स्ट्रिंग पथ तत्व खोज पथ प्रसंस्करण को समाप्त करते हैं।

सापेक्ष पथ "foo/bar" के साथ एक निर्भरता "foo/bar.jq" और . में खोजी जाएगी
दिए गए खोज पथ में "foo/bar/bar.jq"। इसका उद्देश्य मॉड्यूल को रखने की अनुमति देना है
एक निर्देशिका में, उदाहरण के लिए, संस्करण नियंत्रण फ़ाइलें, README फ़ाइलें, और इसी तरह,
लेकिन सिंगल-फाइल मॉड्यूल की अनुमति देने के लिए भी।

समान नाम वाले लगातार घटकों को अस्पष्टता से बचने की अनुमति नहीं है (उदाहरण के लिए,
"फू/फू")।

उदाहरण के लिए, साथ -एल$होम/.jq एक मॉड्यूल foo में पाए जा सकते हैं $HOME/.jq/foo.jq और
$HOME/.jq/foo/foo.jq.

अगर "$HOME/.jq" एक फाइल है, तो इसे मुख्य प्रोग्राम में सोर्स किया जाता है।

आयात रिलेटिवपाथस्ट्रिंग as नाम [ ];
खोज पथ में निर्देशिका के सापेक्ष दिए गए पथ पर मिले मॉड्यूल को आयात करता है। एक ".jq"
प्रत्यय सापेक्ष पथ स्ट्रिंग में जोड़ा जाएगा। मॉड्यूल के प्रतीकों के साथ उपसर्ग हैं
"नाम::"।

वैकल्पिक मेटाडेटा एक स्थिर jq व्यंजक होना चाहिए। यह चाबियों के साथ एक वस्तु होनी चाहिए
जैसे "होमपेज" इत्यादि। इस समय jq केवल "खोज" कुंजी/मान का उपयोग करता है
मेटाडेटा। मेटाडेटा भी उपयोगकर्ताओं के लिए उपलब्ध कराया जाता है मॉड्यूलमेटा बिल्टिन।

मेटाडेटा में "खोज" कुंजी, यदि मौजूद है, तो एक स्ट्रिंग या सरणी मान होना चाहिए (सरणी
तार की); यह शीर्ष-स्तरीय खोज पथ के उपसर्ग के लिए खोज पथ है।

शामिल रिलेटिवपाथस्ट्रिंग [ ];
किसी निर्देशिका के सापेक्ष दिए गए पथ पर पाए गए मॉड्यूल को खोज पथ में आयात करता है जैसे कि यह
स्थान पर शामिल थे। सापेक्ष पथ स्ट्रिंग में एक ".jq" प्रत्यय जोड़ा जाएगा।
मॉड्यूल के प्रतीकों को कॉलर के नाम स्थान में आयात किया जाता है जैसे कि मॉड्यूल की सामग्री थी
सीधे शामिल किया गया है।

वैकल्पिक मेटाडेटा एक स्थिर jq व्यंजक होना चाहिए। यह चाबियों के साथ एक वस्तु होनी चाहिए
जैसे "होमपेज" इत्यादि। इस समय jq केवल "खोज" कुंजी/मान का उपयोग करता है
मेटाडेटा। मेटाडेटा भी उपयोगकर्ताओं के लिए उपलब्ध कराया जाता है मॉड्यूलमेटा बिल्टिन।

आयात रिलेटिवपाथस्ट्रिंग as $NAME [ ];
खोज पथ में किसी निर्देशिका के सापेक्ष दिए गए पथ पर मिली JSON फ़ाइल को आयात करता है। ए
".json" प्रत्यय सापेक्ष पथ स्ट्रिंग में जोड़ा जाएगा। फ़ाइल का डेटा होगा
के रूप में उपलब्ध है $NAME::NAME.

वैकल्पिक मेटाडेटा एक स्थिर jq व्यंजक होना चाहिए। यह चाबियों के साथ एक वस्तु होनी चाहिए
जैसे "होमपेज" इत्यादि। इस समय jq केवल "खोज" कुंजी/मान का उपयोग करता है
मेटाडेटा। मेटाडेटा भी उपयोगकर्ताओं के लिए उपलब्ध कराया जाता है मॉड्यूलमेटा बिल्टिन।

मेटाडेटा में "खोज" कुंजी, यदि मौजूद है, तो एक स्ट्रिंग या सरणी मान होना चाहिए (सरणी
तार की); यह शीर्ष-स्तरीय खोज पथ के उपसर्ग के लिए खोज पथ है।

मॉड्यूल ;
यह निर्देश पूरी तरह से वैकल्पिक है। यह उचित संचालन के लिए आवश्यक नहीं है। यह काम करता है
केवल मेटाडेटा प्रदान करने का उद्देश्य जिसे इसके साथ पढ़ा जा सकता है मॉड्यूलमेटा बिल्टिन।

मेटाडेटा एक स्थिर jq व्यंजक होना चाहिए। यह कुंजियों वाली एक वस्तु होनी चाहिए जैसे
"होमपेज"। इस समय jq इस मेटाडेटा का उपयोग नहीं करता है, लेकिन इसे उपयोगकर्ताओं के लिए उपलब्ध कराया जाता है
के माध्यम से मॉड्यूलमेटा बिल्टिन।

मॉड्यूलमेटा
इनपुट के रूप में मॉड्यूल का नाम लेता है और मॉड्यूल के मेटाडेटा को ऑब्जेक्ट के रूप में आउटपुट करता है
मॉड्यूल का आयात (मेटाडेटा सहित) "डिप्स" कुंजी के लिए एक सरणी मान के रूप में।

प्रोग्राम इसका उपयोग मॉड्यूल के मेटाडेटा को क्वेरी करने के लिए कर सकते हैं, जिसका वे तब उपयोग कर सकते हैं, इसके लिए
उदाहरण के लिए, अनुपलब्ध निर्भरताएँ खोजें, डाउनलोड करें और स्थापित करें।

onworks.net सेवाओं का उपयोग करके jq ऑनलाइन का उपयोग करें


Ad


Ad