Kotlin में फंक्शन को पैरामीटर के रूप में पास करना: शुरुआती के लिए पूरी गाइड

Kotlin: फंक्शन को पैरामीटर के रूप में कैसे पास करें? उदाहरणों के साथ समझें

नमस्ते दोस्त! अगर आपने कभी Kotlin में कोड लिखा है और सोचा है: "किसी फंक्शन को दूसरे फंक्शन में पैरामीटर के रूप में कैसे पास करें?" — तो आप सही जगह पर हैं। Stack Overflow पर इस सवाल के हज़ारों व्यूज़ हैं, और यह कोई हैरानी की बात नहीं है। Kotlin में फंक्शनल प्रोग्रामिंग सिर्फ एक ट्रेंड नहीं, बल्कि एक शक्तिशाली टूल है जो कोड को साफ, छोटा और अभिव्यंजक बनाता है।

इस आर्टिकल में हम सिर्फ सूखा जवाब नहीं देंगे। हम सरल लैम्ब्डा एक्सप्रेशन से लेकर एडवांस तकनीकों तक सब कुछ समझेंगे। आप जानेंगे कि Function टाइप, फंक्शन रेफरेंस ऑपरेटर :: का उपयोग कैसे करें, और शुरुआती लोगों की सामान्य गलतियों से कैसे बचें। चलिए शुरू करते हैं!

यह क्यों ज़रूरी है? फंक्शन को पैरामीटर के रूप में उपयोग करने के तीन कारण

\n
• लचीलापन: आप एक ऐसा फंक्शन लिख सकते हैं जो अलग-अलग फंक्शन पास करने पर अलग-अलग काम करे।
\n
• पढ़ने में आसानी: कोड डिक्लेरेटिव हो जाता है — आप बताते हैं क्या करना है, न कि कैसे करना है।
\n
• रीयूज़ेबिलिटी: सामान्य पैटर्न को higher-order functions में डालकर कोड डुप्लिकेशन से बचें।
\n

बुनियादी बातें: फंक्शन टाइप्स (Function Types)

Kotlin में फंक्शन first-class objects हैं। इसका मतलब है कि उनका अपना एक टाइप होता है। फंक्शन टाइप इस तरह लिखा जाता है: (पैरामीटर) -> रिटर्न टाइप। उदाहरण के लिए:

// एक फंक्शन जो Int लेता है और String रिटर्न करता है\nval intToString: (Int) -> String = { number -> "संख्या: $number" }\n\n// एक फंक्शन जो कुछ नहीं लेता और कुछ नहीं रिटर्न करता\nval doNothing: () -> Unit = { println("नमस्ते!") }\n\n// दो पैरामीटर वाला फंक्शन\nval sum: (Int, Int) -> Int = { a, b -> a + b }\n

Unit पर ध्यान दें — यह Java/JavaScript के void के समान है। अगर फंक्शन कुछ रिटर्न नहीं करता, तो उसका टाइप () -> Unit होता है।

फंक्शन को पैरामीटर के रूप में कैसे पास करें: पहला उदाहरण

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

fun applyTwice(x: Int, operation: (Int) -> Int): Int {\n    val firstResult = operation(x)\n    return operation(firstResult)\n}\n\n// उपयोग:\nval result = applyTwice(5) { it * 2 } // लैम्ब्डा\nprintln(result) // आउटपुट: 20 (5*2 = 10, 10*2 = 20)\n\n// या नाम वाले फंक्शन के साथ:\nfun double(x: Int) = x * 2\nval result2 = applyTwice(5, ::double)\nprintln(result2) // यह भी 20\n

देखिए कितना सुंदर है? पहले मामले में हमने लैम्ब्डा एक्सप्रेशन (अनाम फंक्शन) का उपयोग किया, और दूसरे में मौजूदा फंक्शन का रेफरेंस :: ऑपरेटर के ज़रिए। दोनों तरीके सही हैं, और हम इन्हें विस्तार से समझेंगे।

फंक्शन पास करने के तरीके (विस्तृत विवरण)

1. लैम्ब्डा एक्सप्रेशन (सबसे लोकप्रिय तरीका)

लैम्ब्डा एक अनाम फंक्शन है जिसे सीधे पास किया जा सकता है। Kotlin में लैम्ब्डा का सिंटैक्स बहुत संक्षिप्त है:

val list = listOf(1, 2, 3, 4, 5)\n\n// filter फंक्शन में लैम्ब्डा पास करना\nval evenNumbers = list.filter { it % 2 == 0 }\nprintln(evenNumbers) // [2, 4]\n\n// अगर कई पैरामीटर हों:\nval numbersWithIndex = list.mapIndexed { index, value -> "$index: $value" }\nprintln(numbersWithIndex) // ["0: 1", "1: 2", ...]\n

महत्वपूर्ण: अगर लैम्ब्डा फंक्शन का आखिरी पैरामीटर है, तो इसे कोष्ठक के बाहर रखा जा सकता है। इससे कोड भाषा के बिल्ट-इन कंस्ट्रक्ट जैसा दिखता है। filter, map, forEach आदि इसी तरह काम करते हैं।

एक से अधिक पैरामीटर होने पर स्पष्ट पैरामीटर नाम देने का उदाहरण:

fun performAction(a: Int, b: Int, action: (Int, Int) -> String) {\n    println(action(a, b))\n}\n\n// लैम्ब्डा के साथ कॉल\nperformAction(3, 4) { x, y -> "योग: ${x + y}" }\n