कार्यहरू

१. कार्य घोषणा

कार्य कार्य कीवर्डले सुरु हुन्छ, नाम त्यसपछि, प्यारामिटर (...) मा, र शरीर अन्त्य सम्म:

कार्य नमस्ते()
    लेख "नमस्ते!"
अन्त्य

नमस्ते()        # कल गर्ने
नमस्ते()        # जति पटक पनि
# आउटपुट:
# नमस्ते!
# नमस्ते!

घोषणा गर्दा कोड चल्दैन — कल (नमस्ते()) गर्दा मात्र चल्छ। कार्य पहिला परिभाषित भएर पछि कल गर्नुपर्छ।

२. प्यारामिटर सहित

प्यारामिटरले कार्यलाई इनपुट दिन्छ। हरेक प्यारामिटरको नामभन्दा अगाडि प्रकार लेख्नु राम्रो अभ्यास हो:

कार्य स्वागत(पाठ नाम)
    लेख "नमस्ते, " + नाम + "!"
अन्त्य

स्वागत("राम")    # आउटपुट: नमस्ते, राम!
स्वागत("सीता")   # आउटपुट: नमस्ते, सीता!

३. फर्क मान (Return Value)

कार्यले फर्काऊ ले मान फर्काउँछ, जुन चरमा राख्न वा सीधै प्रयोग गर्न सकिन्छ। -> ले फर्क प्रकार बताउँछ:

कार्य जोड(पूर्णाङ्क ए, पूर्णाङ्क बी) -> पूर्णाङ्क
    फर्काऊ ए + बी
अन्त्य

राख परिणाम = जोड(५, ३)    # ८
लेख परिणाम + १०            # १८

फर्क प्रकार दिनुभन्दा अघि — उदाहरण, क्षेत्रफल:

कार्य क्षेत्रफल(दशमलव अर्धव्यास) -> दशमलव
    फर्काऊ ३.१४१५९ * अर्धव्यास * अर्धव्यास
अन्त्य

लेख क्षेत्रफल(५.०)   # ७८.५३९७५

४. धेरै प्यारामिटर

कार्य औसत(पूर्णाङ्क ए, पूर्णाङ्क बी, पूर्णाङ्क सी) -> दशमलव
    फर्काऊ (ए + बी + सी) / ३
अन्त्य

लेख औसत(५, १०, १५)   # १०.०

५. कार्य भित्र कार्य (क्लोजर)

कार्यले आफ्नो वरिपरिको दायराका चरहरू कैद गर्छ र कलहरूबीच ती चरको अवस्था राख्न सक्छ। यसरी एउटा कार्यबाट अर्को कार्य फर्काउन पनि सकिन्छ:

कार्य काउन्टर_बनाउ()
    राख ग = ०

    कार्य भित्री()
        ग = ग + १
        फर्काऊ ग
    अन्त्य

    फर्काऊ भित्री
अन्त्य

राख गणक = काउन्टर_बनाउ()
लेख गणक()   # १
लेख गणक()   # २
लेख गणक()   # ३

हरेक पटक काउन्टर_बनाउ() कल गर्दा नयाँ स्वतन्त्र गणक बन्छ — ग हरेकको आफ्नै हुन्छ।

६. रिकर्सन (Recursion)

कार्यले आफैंलाई कल गर्न सक्छ। हरेक रिकर्सिभ कार्यमा रोकिने सर्त (base case) हुनुपर्छ, होइन भने अनन्त कल हुन्छ:

कार्य फ्याक्टोरियल(पूर्णाङ्क न) -> पूर्णाङ्क
    यदि न <= १        # रोकिने सर्त
        फर्काऊ १
    अन्त्य
    फर्काऊ न * फ्याक्टोरियल(न - १)
अन्त्य

लेख फ्याक्टोरियल(५)   # १२०

७. पूरा उदाहरण

रिकर्सन र लुप मिसाइएको — फिबोनाची श्रेणी:

कार्य फिबोनाची(पूर्णाङ्क न) -> पूर्णाङ्क
    यदि न <= १
        फर्काऊ न
    अन्त्य
    फर्काऊ फिबोनाची(न - १) + फिबोनाची(न - २)
अन्त्य

राख सङ्ख्याहरू = [१, २, ३, ४, ५, ६, ७, ८, ९, १०]
प्रत्येक सङ्ख्या भित्र सङ्ख्याहरू
    लेख फिबोनाची(सङ्ख्या)
अन्त्य
# आउटपुट: १ १ २ ३ ५ ८ १३ २१ ३४ ५५

कार्य बुझिसकेपछि अर्को ठूलो अवधारणा बाँकी छ — क्लास (OOP), जहाँ डाटा र यससँग सम्बन्धित कार्यहरू वस्तुमा जोडिन्छन्।