ऑब्जेक्ट के बारे में
दूसरी भाषाओं की शब्दावली में कहें तो एक JSON ऑब्जेक्ट एक "हैश", "मैप", या "डिक्शनरी" होता है।
JSON एक ऑब्जेक्ट को इस तरह परिभाषित करता है:
एक ऑब्जेक्ट नाम/वैल्यू जोड़ों का एक क्रम-रहित समुच्चय होता है।
एक ऑब्जेक्ट { बायाँ ब्रेस से शुरू होता है और } दायाँ ब्रेस पर खत्म होता है।
हर नाम के बाद : कोलन आता है, और नाम/वैल्यू जोड़ों को , कॉमा से अलग किया जाता है।
नाम स्ट्रिंग ही होना चाहिए।
नाम को की भी कहा जाता है।
वैल्यू किसी भी JSON टाइप की हो सकती है।
एक ही ऑब्जेक्ट में अलग-अलग वैल्यू अलग-अलग टाइप की हो सकती हैं, जैसे इस उदाहरण में।
{
"name": "Jane",
"age": 42,
"pets": ["cat", "fish"],
"address": {"street": "123 Main St", "city": "Springfield"}
}
ध्यान दें कि अंतिम की-वैल्यू जोड़े के बाद कॉमा नहीं होना चाहिए।
ऑब्जेक्ट बनाना
नाम/वैल्यू जोड़ों को इकट्ठा करने के लिए ब्रेस का उपयोग कीजिए।
हालाँकि नाम स्ट्रिंग होने चाहिए, अगर नाम आइडेंटिफायर-जैसे हों (अल्फान्यूमेरिक अक्षरों और अंडरस्कोर से बने हों, और शुरू में कोई अंक न हो) तो उन्हें कोट्स में लिखने की ज़रूरत नहीं है।
{name: "Jane", age: 42}
ऐसे की इस्तेमाल करना भी मान्य है जो आइडेंटिफायर-जैसे नहीं हैं।
उन्हें बस कोट्स में लिख दीजिए।
{"first name": "Jane", "last name": "Lopez", age: 42}
अगर नाम किसी एक्सप्रेशन का परिणाम है, तो वह एक्सप्रेशन अवश्य कोष्ठकों में होना चाहिए।
$ echo "Jane" | jq -Rc '{.: 42}'
jq: error: syntax error, unexpected '.' (Unix shell quoting issues?) at <top-level>, line 1:
{.: 42}
jq: error: May need parentheses around object key expression at <top-level>, line 1:
{.: 42}
jq: 2 compile errors
$ echo "Jane" | jq -Rc '{(.): 42}'
{"Jane":42}
संक्षिप्त रूप
ऑब्जेक्ट बनाने के कुछ आम मामलों के लिए संक्षिप्त सिंटैक्स होता है।
-
किसी इनपुट ऑब्जेक्ट से की-वैल्यू जोड़ों का दोबारा उपयोग करना।
$ jq -n '$ENV | {USER: .USER, EDITOR: .EDITOR}'
{
"USER": "glennj",
"EDITOR": "vim"
}
$ENV एक ऑब्जेक्ट है जिसमें एनवायरनमेंट के नाम-वैल्यू जोड़े रहते हैं।
बार-बार दोहराए जाने वाले key: .key जोड़ों को सिर्फ key लिखा जा सकता है।
$ jq -n '$ENV | {USER, EDITOR}'
{
"USER": "glennj",
"EDITOR": "vim"
}
-
इसी तरह, वेरिएबल इस्तेमाल करते समय भी एक संक्षिप्त रूप होता है।
$ jq -cn '"foo" as $a | "bar" as $b | {a: $a, b: $b}'
{"a":"foo","b":"bar"}
$ jq -cn '"foo" as $a | "bar" as $b | {$a, $b}'
{"a":"foo","b":"bar"}
इंडेक्सिंग
ऑब्जेक्ट से वैल्यू डॉट नोटेशन से निकाली जाती हैं।
{name: "Jane", age: 42} | .age # => 42
अगर आप की को आइडेंटिफायर की तरह संदर्भित नहीं कर सकते, तो ब्रैकेट नोटेशन का उपयोग कीजिए।
"name" as $key | {name: "Jane", age: 42} | .$key # => error
"name" as $key | {name: "Jane", age: 42} | .[$key] # => "Jane"
अगर की ऑब्जेक्ट में नहीं है, तो परिणाम null होता है।
{name: "Jane", age: 42} | .sport # => null
नेस्टेड वैल्यू का इंडेक्सिंग
आप पाएँगे कि API क्वेरीज़ के परिणाम पार्स करते समय यह काम आपको बार-बार करना पड़ता है।
अगर किसी ऑब्जेक्ट में ऐरे या ऑब्जेक्ट वैल्यू हों, तो हम इंडेक्स एक्सप्रेशनों को एक के बाद एक जोड़ सकते हैं।
{
"name": "Jane",
"age": 42,
"pets": ["cat", "fish"],
"address": {"street": "123 Main St", "city": "Springfield"}
}
| (
.pets[1], # => "fish"
.address.city # => "Springfield"
)
की-वैल्यू जोड़े जोड़ना या बदलना
किसी ऐरे में नया की-वैल्यू जोड़ा जोड़ने के लिए, या किसी मौजूदा की की वैल्यू बदलने के लिए, = असाइनमेंट ऑपरेटर का उपयोग कीजिए, और बाईं ओर एक इंडेक्स एक्सप्रेशन रखिए।
{name: "Jane", age: 42} | .sport = "tennis" | .age = 21
# => {
# "name": "Jane",
# "age": 21,
# "sport": "tennis"
# }
+ ऑपरेटर ऑब्जेक्टों को मर्ज करता है।
{Richard: 54} + {Jane: 42}
# => {
# "Richard": 54,
# "Jane": 42
# }
की को हटाना
किसी की को हटाने के लिए del फंक्शन का उपयोग कीजिए।
यह अपडेट किया गया ऑब्जेक्ट लौटाता है।
{name: "Jane", age: 42} | del(.age) # => {"name": "Jane"}
del का पैरामीटर एक इंडेक्स एक्सप्रेशन होता है (डॉट या ब्रैकेट नोटेशन का उपयोग करके) जो ऑब्जेक्ट में किसी की पर पहुँचता है।
jq इसे पाथ एक्सप्रेशन कहता है।
सिर्फ एक स्ट्रिंग देना पर्याप्त नहीं है।
{name: "Jane", age: 42} | del(name) # error: name/0 is not defined
{name: "Jane", age: 42} | del("name") # error: Invalid path expression with result "name"
{name: "Jane", age: 42} | del(.name) # OK
{name: "Jane", age: 42} | del(.["name"]) # OK
मेंबरशिप
-
यह जाँचने के लिए कि ऑब्जेक्ट में कोई की है या नहीं, has फंक्शन का उपयोग कीजिए।
{name: "Jane", age: 42} as $example
|
($example | has("name")), # => true
($example | has("sport")) # => false
-
in के साथ जाँचिए कि कोई की ऑब्जेक्ट में है या नहीं।
{name: "Jane", age: 42} as $example
|
("name" | in($example)), # => true
("sport" | in($example)) # => false
की या वैल्यू की सूची बनाना
सभी की की सूची देने के लिए keys फंक्शन का उपयोग कीजिए।
{name: "Jane", age: 42} | keys # => ["age", "name"]
ध्यान दें कि keys की को सॉर्ट करता है।
की को मूल क्रम में पाने के लिए keys_unsorted का उपयोग कीजिए।
सभी वैल्यू की सूची देने वाला कोई समकक्ष फंक्शन नहीं है।
लेकिन .[] फिल्टर ऑब्जेक्ट की वैल्यू को एक स्ट्रीम के रूप में देता है, और उस स्ट्रीम को [...] ऐरे कंस्ट्रक्टर से पकड़ा जा सकता है।
[{first: "Jane", last: "Lopez", status: "awesome!"} | .[]]
# => ["Jane", "Lopez", "awesome!"]
इटरेशन करना
-
map_values(filter) फंक्शन ऑब्जेक्ट की हर वैल्यू पर फिल्टर लागू करता है।
{first: "Jane", last: "Lopez", status: "awesome!"}
| map_values(ascii_upcase)
# => {"first": "JANE", "last": "LOPEZ", "status": "AWESOME!"}
-
किसी ऑब्जेक्ट पर इटरेशन करने के लिए, पहले उसे की-वैल्यू ऑब्जेक्टों के ऐरे में बदलना होगा।
to_entries फंक्शन यही करता है।
{name: "Jane", age: 42} | to_entries
# => [
# {
# "key": "name",
# "value": "Jane"
# },
# {
# "key": "age",
# "value": 42
# }
# ]
अब हम ऐरे इटरेशन फंक्शनों का उपयोग कर सकते हैं, जैसे map.
-
from_entries फंक्शन उल्टा काम करता है: की-वैल्यू ऑब्जेक्टों के ऐरे को ऑब्जेक्ट में बदलता है।
[
{"key":"name", "value":"Jane"},
{"key":"age", "value":42}
] | from_entries # => {"name": "Jane", "age": 42}
-
किसी ऑब्जेक्ट में हर की-वैल्यू जोड़े पर फिल्टर लागू करने के लिए, with_entries(filter) फंक्शन का उपयोग कीजिए।
उदाहरण के लिए, मान लीजिए एक ऑब्जेक्ट है जो नाम को उम्र से मैप करता है; हम उसके की और वैल्यू नीचे दिए तरीके से आपस में बदल सकते हैं।
{"Jane": 42, "Richard": 54}
| with_entries({key: (.value | tostring), value: .key})
यह आउटपुट देता है:
{
"42": "Jane",
"54": "Richard"
}
with_entries(filter) इसके समान है:
to_entries | map(filter) | from_entries
4 अभ्यास
ऑब्जेक्ट सीखिए
