Kotlin में let में एकाधिक चर: 3 सुरुचिपूर्ण तरीके

शुरुआती लोगों के लिए ऑनलाइन Python प्रशिक्षक

Python आसानी से सीखें बिना सिद्धांत के बोझ के। स्वचालित जांच के साथ व्यावहारिक कार्य हल करें और ब्राउज़र में सीधे कोड लिखें।

पाठ्यक्रम शुरू करें

let में एकाधिक चर: एक समस्या जिसे आपने नोटिस नहीं किया

\n\n

क्या आपने कभी Kotlin में लिखा है और अचानक महसूस किया: "मुझे एक साथ दो nullable चर को संसाधित करने की आवश्यकता है"? आप अपने पसंदीदा let तक पहुँचते हैं, लेकिन... रुकिए। let केवल एक चर के साथ काम करता है। लेकिन अगर आपके पास दो, तीन या अधिक हों तो क्या करें?

\n\n

यह प्रश्न Kotlin विषय पर Stack Overflow पर सबसे लोकप्रिय प्रश्नों में से एक है। हजारों डेवलपर इस प्रतीत होने वाले सरल कार्य पर अटक जाते हैं। और आज हम एक बार और हमेशा के लिए समझेंगे कि इसे खूबसूरती और सही तरीके से कैसे हल किया जाए।

\n\n

इस लेख में, हम केवल सूखे उदाहरण नहीं देंगे। हम 3 दृष्टिकोणों की तुलना करेंगे, उनके फायदे, नुकसान और best practices पर चर्चा करेंगे। आप जानेंगे कि स्थिति के आधार पर कौन सी विधि चुननी है, और बदसूरत नेस्टेड let लिखना बंद कर देंगे।

\n\n

"Multiple variable let" समस्या इतनी लोकप्रिय क्यों है?

\n\n

Kotlin एक ऐसी भाषा है जो null safety से प्यार करती है। दायरा फ़ंक्शन (scope functions) — let, run, with, apply, also — nullable प्रकारों के साथ सुरक्षित रूप से काम करने के लिए हमारा गुप्त हथियार हैं। लेकिन उनकी एक सीमा है: प्रत्येक फ़ंक्शन एक रिसीवर ऑब्जेक्ट के लिए डिज़ाइन किया गया है।

\n\n

एक स्थिति की कल्पना करें: आप API से दो nullable फ़ील्ड प्राप्त करते हैं — उपयोगकर्ता का नाम और उसका ईमेल। आपको यह जाँचने की आवश्यकता है कि दोनों null नहीं हैं, और उसके बाद ही कार्रवाई करें (उदाहरण के लिए, एक स्वागत ईमेल भेजें)।

\n\n

शुरुआती अक्सर ऐसा लिखते हैं:

\n\n

val name: String? = getUserName()\nval email: String? = getUserEmail()\n\nif (name != null && email != null) {\n    sendWelcomeEmail(name, email)\n}

\n\n

यह काम करता है, लेकिन यह Kotlin-way नहीं है। हम कोड को अधिक संक्षिप्त और सुरक्षित बना सकते हैं। आइए देखें कैसे।

\n\n

दृष्टिकोण 1: नेस्टेड let — सरल, लेकिन बदसूरत

\n\n

सबसे स्पष्ट तरीका एक let को दूसरे के अंदर नेस्ट करना है। यह पहली बात है जो दिमाग में आती है:

\n\n

val name: String? = getUserName()\nval email: String? = getUserEmail()\n\nname?.let { safeName ->\n    email?.let { safeEmail ->\n        sendWelcomeEmail(safeName, safeEmail)\n    }\n}

\n\n

फायदे:

"बॉक्स से बाहर" काम करता है, किसी अतिरिक्त फ़ंक्शन की आवश्यकता नहीं
कोड क्रमिक रूप से पढ़ा जाता है

\n\n

नुकसान:

चरों की संख्या बढ़ने पर (3, 4 और अधिक) कोड "डरावने पिरामिड" में बदल जाता है
पढ़ना और बनाए रखना मुश्किल
प्रत्येक नेस्टेड स्तर एक अतिरिक्त इंडेंटेशन जोड़ता है

\n\n

यह दृष्टिकोण केवल दो चरों के लिए उपयुक्त है। तीन या अधिक के लिए — विकल्प खोजें।

\n\n

दृष्टिकोण 2: Pair, Triple और data class का उपयोग

\n\n

Kotlin अंतर्निहित क्लास Pair और Triple प्रदान करता है। विचार nullable चरों को एक ऑब्जेक्ट में संयोजित करना और फिर let के माध्यम से इसकी जाँच करना है।

\n\n

val name: String? = getUserName()\nval email: String? = getUserEmail()\n\nval pair = name?.let { n ->\n    email?.let { e -> n to e }\n}\n\npair?.let { (safeName, safeEmail) ->\n    sendWelcomeEmail(safeName, safeEmail)\n}

\n\n

तीन चरों के लिए हम Triple का उपयोग करते हैं:

\n\n

val name: String? = getUserName()\nval email: String? = getUserEmail()\nval age: Int? = getUserAge()\n\nval triple = name?.let { n ->\n    email?.let { e ->\n        age?.let { a -> Triple(n, e, a) }\n    }\n}\n\ntriple?.let { (safeName, safeEmail, safeAge) ->\n    sendWelcomeEmail(safeName, safeEmail, safeAge)\n}

\n\n

फायदे: