ऐरे में

ऐरे के बारे में

JSON एक ऐरे को इस तरह परिभाषित करता है:

ऐरे वैल्यू का एक क्रमबद्ध संग्रह होता है। ऐरे [ बाएँ ब्रैकेट से शुरू होता है और ] दाएँ ब्रैकेट पर खत्म होता है। वैल्यू को , कॉमा से अलग किया जाता है।

ऐरे में शून्य या उससे अधिक, किसी भी तरह की JSON वैल्यू हो सकती हैं। ऐरे के सारे एलिमेंट का एक ही टाइप होना ज़रूरी नहीं है।

ऐरे बनाना

ब्रैकेट की मदद से एलिमेंट को एक ऐरे में इकट्ठा कीजिए।

[1, 2, 3]

स्ट्रीम के एलिमेंट को ब्रैकेट में बंद करके एक ऐरे में बदला जा सकता है।

range(5)     # => a stream of 5 numbers
[range(5)]   # => the array [0, 1, 2, 3, 4]

साइज़

length फंक्शन ऐरे में मौजूद एलिमेंट की संख्या लौटाता है।

इंडेक्सिंग और स्लाइसिंग

ऐरे के इंडेक्स 0 से शुरू होते हैं।

ब्रैकेट एक्सप्रेशन से ऐरे का कोई एलिमेंट निकालिए: .[2] तीसरा एलिमेंट देता है।

ऋणात्मक इंडेक्स ऐरे के अंत से उलटी गिनती करते हैं: .[-1] अंतिम एलिमेंट देता है; .[-2] अंत से दूसरा।

स्लाइस ऐरे का एक हिस्सा होता है। .[10:15] इंडेक्स 10 से शुरू करके 5 एलिमेंट लौटाता है; अंत वाला इंडेक्स इसमें शामिल नहीं होता।

कुछ ऐसे फंक्शन भी हैं जो काम आसान कर देते हैं:

• first पहला एलिमेंट देता है।
• last अंतिम एलिमेंट देता है।
• nth(n) इंडेक्स n वाला एलिमेंट देता है।

एलिमेंट की स्ट्रीम में बदलना

कई बार हमें ऐरे के एलिमेंट को अलग-अलग स्ट्रीम करना होता है। इसके लिए हम .[] इस्तेमाल करते हैं।

मान लीजिए हमें किसी ऐरे में मौजूद स्ट्रिंग की लंबाई की एक स्ट्रीम चाहिए।

["a", "be", "cat", "door"] | length        # => 4 -- the number of elements in the array
["a", "be", "cat", "door"] | .[] | length  # => 1, 2, 3, 4 -- the lengths of each element

पाइप छोड़कर खाली ब्रैकेट को पिछले एक्सप्रेशन के ठीक बाद लगाया जा सकता है।

["a", "be", "cat", "door"][] | length      # => 1, 2, 3, 4 -- the lengths of each element
# ........................^^

जोड़ना और घटाना

ऐरे जोड़ने के लिए + इस्तेमाल कीजिए।

[1, 2, 3] + [4, 5]          # => [1, 2, 3, 4, 5]

- ऑपरेटर बाएँ ऐरे में से दाएँ ऐरे के एलिमेंट हटा देता है।

[range(10)] - [2, 4, 6]     # => [0, 1, 3, 5, 7, 8, 9]

इटरेशन करना

jq में आम इटरेशन के कामों के लिए कई फंक्शन हैं:

• map(expr) एक नया ऐरे लौटाता है जिसमें expr हर एलिमेंट पर एक-एक करके लागू होता है।

  [1, 2, 3] | map(. * 10)    # => [10, 20, 30]
  
  

• select(expr) एक फंक्शन है जो expr को एक अकेली वैल्यू पर लागू करता है; अगर एक्सप्रेशन का परिणाम सही है, तो वह वैल्यू लौटा दी जाती है; अगर परिणाम गलत है, तो कुछ भी नहीं लौटता -- null नहीं, बिलकुल कुछ भी नहीं।

  इसे किसी ऐरे पर लागू करने के लिए इसके साथ map जोड़िए।

  [range(10)] | map(select(. % 2 == 0))    # => [0, 2, 4, 6, 8]
  

  दूसरा तरीका: select को स्ट्रीम पर लागू कीजिए और नतीजे इकट्ठा कर लीजिए।

  [range(10) | select(. % 2 == 0)]    # => [0, 2, 4, 6, 8]
  

• any(condition) और all(condition) एक बूलियन वैल्यू लौटाते हैं, जो बताती है कि ऐरे के कुछ या सारे एलिमेंट शर्त पूरी करते हैं या नहीं।

  [1, 2, 3, 4] | any(. > 4)    # false
  [1, 2, 3, 4] | any(. >= 4)   # true
  
  [1, 2, 3, 4] | all(. >= 4)   # false
  [1, 2, 3, 4] | all(. <= 4)   # true
  

सदस्यता

index की मदद से हम जाँच सकते हैं कि किसी ऐरे में कोई एलिमेंट है या नहीं। अगर दिया गया एलिमेंट ऐरे में है, तो यह फंक्शन उसका इंडेक्स लौटाता है; वरना यह null लौटाता है।

["carrots", "beef", "potatoes"] | index("beef")    # => 1
["carrots", "beef", "potatoes"] | index("bees")    # => null

इसका उल्टा काम करने वाला एक फंक्शन भी है, जिसका नाम IN है (हाँ, बड़े अक्षरों में)। IN की खास बात यह है कि इसे आर्गुमेंट के तौर पर ऐरे नहीं, बल्कि एक स्ट्रीम दी जाती है।

"beef" | IN(["carrots", "beef", "potatoes"][])    # => true
"bees" | IN(["carrots", "beef", "potatoes"][])    # => false

अन्य फंक्शन (जानकारी के लिए मैनुअल देखिए)

• Ruby में एक काम का each_with_index मेथड है, जो एलिमेंट की वैल्यू को उसके इंडेक्स के साथ जोड़ देता है। Python में enumerate है। jq में भी ऐसा ही कुछ है, जिसका नाम to_entries है। यह ऐरे को {key: index, value: value} ऑब्जेक्ट के ऐरे में बदल देता है।

  [11, 22, 33, 44] | to_entries
  # => [{key: 0, value: 11}, {key: 1, value: 22}, {key: 2, value: 33}, {key: 3, value: 44}]
  

• sort और sort_by

• group_by

• min, max, min_by, max_by

• unique, unique_by

• flatten