ग्रेड आँकड़े

Reduce

मान लीजिए हमें संख्याओं के एक ऐरे का जोड़ निकालना है। यह काम करने के कई तरीके हैं।

• कई भाषाओं में यह समस्या एक लूप और एक एक्युमुलेटर वेरिएबल के रूप में लिखी जाती है।

• यह समस्या एक रिकर्सिव फंक्शन के रूप में भी लिखी जा सकती है। स्यूडो कोड में यह कुछ ऐसा दिखेगा।

  function Add(X, Sum=0):
    if X is empty then
      return Sum
    else
      return Add(rest(X), Sum + first(X))
    end
  end
  

  समस्या को छोटे-छोटे टुकड़ों में बाँटने के इस तरीके को "बेस केस की ओर रिड्यूस करना" भी कहा जाता है।

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

jq में यह प्रक्रिया reduce फिल्टर में लागू की गई है। दूसरी भाषाओं में इसे "fold", "fold-left", "inject" या "aggregate" कहा जाता है।

jq का reduce एक्सप्रेशन ऐसा दिखता है।

reduce STREAM_EXPRESSION as $var (INITIAL_VALUE; UPDATE_EXPRESSION)

• STREAM_EXPRESSION आइटम की एक स्ट्रीम है, जिसमें हर आइटम बारी-बारी से $var वेरिएबल में रखा जाता है।
  • याद रखिए, किसी ऐरे को स्ट्रीम करने के लिए इटरेटर फिल्टर .[] इस्तेमाल कीजिए: $myArray | .[]।
• INITIAL_VALUE जमा होने वाले परिणाम की शुरुआती वैल्यू है (जिसे एक्युमुलेटर कहा जाता है)।
• UPDATE_EXPRESSION मौजूदा वैल्यू ($var) को एक्युमुलेटर में जोड़ता है ("फोल्ड" करता है)।
  • इस एक्सप्रेशन के संदर्भ में . एक्युमुलेटर की वैल्यू है।
  • इस एक्सप्रेशन का आउटपुट अगले इटरेशन में काम आने के लिए एक्युमुलेटर में संग्रहीत कर दिया जाता है।
  • अंतिम इटरेशन के बाद जमा हुआ परिणाम ही reduce का आउटपुट होता है।

चलिए एक उदाहरण देखते हैं: किसी ऐरे की संख्याओं का जोड़ निकालना। add फिल्टर यही काम करता है, लेकिन हम देखेंगे कि इसे खुद कैसे लागू किया जाए।

अगर हम [10, 20, 30, 40] को इनपुट बनाएँ और शून्य को शुरुआती स्थिति मानें, तो हर चरण ऐसा दिखता है।

jq सिंटैक्स में यह इस कोड जैसा दिखता है।

0 + 10 | . + 20 | . + 30 | . + 40

हम इसे reduce फिल्टर से लिख सकते हैं।

[10, 20, 30, 40] | reduce .[] as $n (0; . + $n)     # => 100

def add: reduce .[] as $x (null; . + $x);

ध्यान में रखने वाली कुछ बातें

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

  {"apple": 10, "banana": 16, "carrot": 4}
  | . as $obj
  | reduce (keys | .[]) as $key (0; . + $obj[$key])     # => 30
  

• एक्युमुलेटर किसी भी डेटा टाइप का हो सकता है। उदाहरण के लिए, आपको किसी ऐरे को उलटना हो सकता है।

  ["A", "B", "C", "D"]
  | reduce .[] as $elem ([]; [$elem] + .)       # => ["D", "C", "B", "A"]