तुलना
संख्याओं की तुलना
jq में संख्याओं की तुलना नीचे दिए गए रिलेशनल और समानता ऑपरेटरों से की जा सकती है।
| तुलना |
ऑपरेटर |
| से बड़ा |
a > b |
| से बड़ा या बराबर |
a >= b |
| से छोटा |
a < b |
| से छोटा या बराबर |
a <= b |
| बराबर |
a == b |
| बराबर नहीं |
a != b |
तुलना का परिणाम हमेशा एक बूलियन वैल्यू होता है, यानी या तो true या false.
1 < 3, # => true
2 != 2, # => false
1 == 1.0 # => true
# All numbers are floating-points, so this is different syntax
# for the exact same value.
स्ट्रिंग की तुलना
ऊपर दिए गए ऑपरेटरों से स्ट्रिंग की तुलना भी की जा सकती है।
ऐसे में शब्दकोश (लेक्सिकोग्राफिकल) क्रम लागू होता है।
यह क्रम यूनिकोड कोडपॉइंट वैल्यू के अनुसार होता है।
"Apple" > "Pear", # => false
"a" < "above", # => true
"a" == "A" # => false
जब आप ऐसे दो वेरिएबल की तुलना करें जिनमें देखने में संख्याएँ लगती हों, लेकिन जिनका टाइप स्ट्रिंग हो, तो आपको सावधान रहना चाहिए।
शब्दकोश क्रम के कारण परिणाम वही नहीं आएगा जो संख्या टाइप की वैल्यू की तुलना करने पर आता है।
10 < 2, # => false
"10" < "2" # => true (because "1" comes before "2")
"सख्त" समानता
jq का == ऑपरेटर JavaScript के === जैसा है: जो चीज़ें देखने में एक जैसी लगती हैं, लेकिन जिनके टाइप अलग हैं, वे बराबर नहीं होतीं।
"3" == 3 # => false
# the value on the left has type string,
# the value on the right has type number.
ऐरे की तुलना
दो ऐरे तब बराबर होते हैं जब उनके सभी संगत एलिमेंट बराबर हों।
[1, 2, 3] == [1, 2, 3] # => true
[1, 2, 3] == [1, 3, 2] # => false, different order
[1, 2, 3] == [1, 2, "3"] # => false, different types
ऑब्जेक्ट की तुलना
दो ऑब्जेक्ट तब बराबर होते हैं जब उनके की-वैल्यू जोड़े एक जैसे हों।
{name: "Joe", age: 42} == {age: 42, name: "Joe"} # => true
{name: "Joe", age: 42} == {age: 42, name: "Jane"} # => false
{name: "Joe", age: 42} == {age: "42", name: "Joe"} # => false
{name: "Joe", age: 42} == {age: 42, name: "Joe", height: 175} # => false
# comparisons will drill down as deeply as required
{a: {b: {c: [1, 2]}}} == {a: {b: {c: [1, 2]}}} # => true
{a: {b: {c: [1, 2]}}} == {a: {b: {c: [1, 2, 3]}}} # => false
शर्तें
if एक्सप्रेशन
jq का शर्त वाला एक्सप्रेशन if A then B else C end होता है।
if-then-else भी jq के बाकी सारे बिल्ट-इन की तरह एक फिल्टर है: यह एक इनपुट लेता है और एक आउटपुट देता है।
अगर एक्सप्रेशन A "सही" मानी जाने वाली वैल्यू देता है, तो if फिल्टर B का मूल्यांकन करता है।
वरना वह C का मूल्यांकन करता है।
if फिल्टर को मिला इनपुट B या C को भेजा जाता है।
42 | if . < 50 then "small" else "big" end # => "small"
5 | if . % 2 == 0 then . / 2 else . * 4 end # => 20
else क्लॉज़ वैकल्पिक है; नीचे दिए गए दोनों स्टेटमेंट एक जैसे हैं।
if A then B else . end
if A then B end
नेस्टेड if स्टेटमेंट
elif की मदद से और शर्तें जोड़ी जा सकती हैं।
42 | if . < 33 then "small"
elif . < 66 then "medium"
else "big"
end
# => "medium"
आप जितने चाहें उतने elif क्लॉज़ इस्तेमाल कर सकते हैं।
सत्यता
jq में "गलत" मानी जाने वाली बस दो वैल्यू हैं: false और null.
बाकी सब कुछ "सही" है, यहाँ तक कि शून्य संख्या, खाली स्ट्रिंग, खाली ऐरे और खाली ऑब्जेक्ट भी।
बूलियन ऑपरेटर
जटिल क्वेरी बनाने के लिए बूलियन ऑपरेटर and और or इस्तेमाल किए जा सकते हैं।
42 | if . < 33 or . > 66 then "big or small"
else "medium"
end
किसी वैल्यू को नकारने के लिए not इस्तेमाल कीजिए। यह ऑपरेटर नहीं, एक फिल्टर है।
42 | if (. < 33 or . > 66 | not) then "medium"
else "big or small"
end
वैकल्पिक ऑपरेटर
अगर कोई एक्सप्रेशन false या null हो, तो वैकल्पिक ऑपरेटर की मदद से आप उसके लिए एक "डिफॉल्ट" वैल्यू तय कर सकते हैं।
A // B
# This is identical to
if A then A else B end
उदाहरण देखिए:
[3, 5, 18] | add / 2 # => 13
[] | add / 2 # => error: null (null) and number (2) cannot be divided
[] | add // 0 / 2 # => 0
सीखने का अभ्यास
