रिमोट कंट्रोल कार

फंक्शन

jq में आप अपने कस्टम फंक्शन बना सकते हैं, ताकि जो भी लॉजिक आपको चाहिए उसे एक जगह समेट सकें। फंक्शन बिल्टइन की तरह ही काम करते हैं: वे एक इनपुट लेते हैं और शून्य, एक या अधिक आउटपुट देते हैं।

फंक्शन बनाना

आप नीचे दिए गए सिंटैक्स से jq में एक फंक्शन बना सकते हैं:

# no arguments
def funcname: expression;

# or with arguments
def funcname(args): expression;

• शुरू def कीवर्ड से होता है,
• फंक्शन की बॉडी से पहले एक कोलन आता है,
• बॉडी में एक ही एक्सप्रेशन होता है,
• अंत में सेमीकोलन लगता है,
• jq के बाकी सिंटैक्स की तरह, पढ़ने में आसानी के लिए आप मनमानी खाली जगह छोड़ सकते हैं।

फंक्शन कहाँ रखें

फंक्शन को इस्तेमाल करने से पहले बनाना ज़रूरी है: यह एक एरर है:

def A: B(10);
def B(n): n + 1;
A
# => error: B/1 is not defined

इसका मतलब है कि आपको फंक्शन अपने jq कोड में सबसे ऊपर रखने होंगे, "मुख्य" एक्सप्रेशन से पहले।

नेस्टेड फंक्शन

फंक्शन नेस्टेड हो सकते हैं:

def A:
    def B(n): n + 1;
    B(10)
    ;
A
# => 11

यहाँ B फंक्शन सिर्फ A की बॉडी में ही दिखता है।

स्कोप

एक फंक्शन वेरिएबलो और नेस्टेड फंक्शन के लिए एक नया स्कोप बनाता है।

आर्गुमेंट

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

def add_mul(adder; multiplier): (. + adder) * multiplier;

10 | add_mul(5; 4)    # => 60

10 | add_mul(5, 4)
# error: add_mul/1 is not defined

आर्गुमेंट एक्सप्रेशन होते हैं

फंक्शन के आर्गुमेंट फ़िल्टर होते हैं, वैल्यू नहीं। इस मायने में वे वैसा ही काम करते हैं जिसे दूसरी भाषाएँ कॉलबैक कहती हैं:

add_mul फंक्शन को उदाहरण के तौर पर लेते हैं:

10 | add_mul(. + 5; . - 2)    # => 200

यहाँ हो क्या रहा है?

• adder आर्गुमेंट को एक्सप्रेशन . + 5 मिलता है
  • जब फंक्शन . + adder चलाता है, तो यह . + . + 5 बन जाता है
  • चूँकि . == 10 है, इसका मान 25 निकलता है
• इसी तरह, multiplier आर्गुमेंट एक्सप्रेशन . - 2 है
  • जिसका मान 8 निकलता है
  • फिर परिणाम 25 * 8 == 200 होता है

आर्गुमेंट को वैल्यू की तरह इस्तेमाल करना

कभी-कभी आप किसी आर्गुमेंट को वेरिएबल में डालना चाहेंगे:

def my_func(arg):
    arg as $arg
    | other stuff ...
;

इसका एक शॉर्टहैंड भी है:

def my_func($arg):
    other stuff ...
;

ध्यान दीजिए कि यह सिर्फ "सिंटैक्टिक शुगर" है: बिना $ वाला नाम arg भी फंक्शन के स्कोप में बना रहता है।

आरिटी

फंक्शन की एक आरिटी होती है, यानी वे जितने आर्गुमेंट लेते हैं उनकी संख्या।

फंक्शन एक ही नाम को अलग-अलग आरिटी के साथ इस्तेमाल कर सकते हैं। बिल्टइन range फंक्शन इसका उदाहरण है: range/1, range/2 और range/3 तीनों एक साथ रह सकते हैं।

यह उन रिकर्सिव फंक्शन को बनाने में काम आ सकता है जो आर्गुमेंट के ज़रिए स्थिति साथ ले चलते हैं। उदाहरण के लिए map को इस तरह बनाया जा सकता है:

def my_map($accumulator; func):
    if length == 0
        then $accumulator
        else first as $elem | .[1:] | my_map($accumulator + [$elem | func]; func)
    end
    ;

def my_map(func):
    my_map([]; func)
    ;

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

रिकर्शन

jq टेलकॉल ऑप्टिमाइज़ेशन करता है, लेकिन सिर्फ 0-आरिटी फंक्शन के लिए।

मॉड्यूल

jq मॉड्यूल एक ऐसी फाइल होती है जिसमें सिर्फ फंक्शन होते हैं। मॉड्यूल को include या import कमांड से किसी jq प्रोग्राम में शामिल किया जाता है।