Kotlin में Fold vs Reduce: कब क्या उपयोग करें? पूरी गाइड

Kotlin में Fold या Reduce: शुरुआती लोगों का शाश्वत प्रश्न

यदि आप Kotlin में कम से कम एक सप्ताह से कोड लिख रहे हैं, तो आपने निश्चित रूप से fold और reduce फंक्शन्स का सामना किया होगा। पहली नज़र में ये दोनों एक ही काम करते हैं: कलेक्शन पर लूप चलाकर एक परिणाम जमा करना। लेकिन असल में, दोनों में बारीक अंतर है। गलत चुनाव से बग्स, एक्सेप्शन या बस बेकार कोड हो सकता है।

इस लेख में हम Kotlin में fold और reduce के बीच अंतर को वास्तविक प्रोजेक्ट्स के उदाहरणों के साथ समझेंगे और हमेशा के लिए याद रखेंगे कि कब किस फंक्शन का उपयोग करना है। चलिए शुरू करते हैं!

Fold और Reduce क्या हैं? बुनियादी समझ

ये दोनों फंक्शन कलेक्शन के लिए टर्मिनल ऑपरेशन हैं। ये सभी एलिमेंट्स लेते हैं और उन्हें एक ही वैल्यू में बदल देते हैं। कल्पना करें कि आपके पास ढेर सारे पैनकेक हैं और आप एक बड़ा बर्गर बनाना चाहते हैं। fold और reduce इसे करने की दो अलग-अलग तकनीकें हैं।

Reduce: न्यूनतम दृष्टिकोण

reduce फंक्शन कलेक्शन के पहले एलिमेंट को एक्युमुलेटर की शुरुआती वैल्यू के रूप में उपयोग करता है। इसका मतलब है कि यह खाली कलेक्शन पर काम नहीं कर सकता - इसमें UnsupportedOperationException आएगा।

val numbers = listOf(1, 2, 3, 4, 5)\nval sum = numbers.reduce { acc, i -> acc + i }\nprintln(sum) // 15

यहाँ acc शुरू में 1 (पहला एलिमेंट) है, फिर इसमें 2 जोड़ा जाता है, फिर 3, और इसी तरह। यह सरल और सुंदर है, लेकिन इसमें एक खामी है।

Fold: शुरुआत पर नियंत्रण

fold, reduce के विपरीत, शुरुआती वैल्यू स्पष्ट रूप से देने की आवश्यकता होती है। यह आपको पूरा नियंत्रण देता है और, अधिक महत्वपूर्ण बात, खाली कलेक्शन पर भी काम करता है।

val numbers = listOf(1, 2, 3, 4, 5)\nval sum = numbers.fold(0) { acc, i -> acc + i }\nprintln(sum) // 15\n\nval emptyList = listOf<Int>()\nval emptySum = emptyList.fold(0) { acc, i -> acc + i }\nprintln(emptySum) // 0, कोई एरर नहीं!

अंतर देखा? fold खाली कलेक्शन होने पर शुरुआती वैल्यू लौटाता है। reduce ऐसी स्थिति में क्रैश हो जाएगा।

Kotlin में Fold और Reduce के बीच मुख्य अंतर

आइए ज्ञान को व्यवस्थित करें। यहाँ एक तालिका है जो आपको जल्दी से समझने में मदद करेगी:

\n
• शुरुआती वैल्यू: fold में आप इसे स्वयं सेट करते हैं। reduce में यह कलेक्शन का पहला एलिमेंट होता है।
\n
• परिणाम का प्रकार: fold में परिणाम का प्रकार एलिमेंट्स के प्रकार से भिन्न हो सकता है (जैसे, Int जोड़कर String प्राप्त करना)। reduce में परिणाम का प्रकार हमेशा एलिमेंट्स के प्रकार के समान होता है।
\n
• खाली कलेक्शन: fold इसे सामान्य रूप से संभालता है (शुरुआती वैल्यू लौटाता है)। reduce एक एक्सेप्शन फेंकता है।
\n
• प्रदर्शन: दोनों फंक्शन O(n) समय में काम करते हैं। प्रदर्शन में अंतर नगण्य है।
\n

अब इसे कोड में देखते हैं।

उदाहरण 1: अलग-अलग प्रकार के एक्युमुलेटर और एलिमेंट

मान लीजिए, हमारे पास संख्याओं की एक सूची है, और हम एक स्ट्रिंग प्राप्त करना चाहते हैं - उनका योग पढ़ने योग्य रूप में। fold इसे आसानी से करता है, क्योंकि एक्युमुलेटर का प्रकार (String) एलिमेंट्स के प्रकार (Int) से भिन्न है।

val numbers = listOf(1, 2, 3)\nval result = numbers.fold("योग: ") { acc, i -> "$acc$i " }\nprintln(result) // "योग: 1 2 3 "

इसे reduce के साथ करने की कोशिश करें - कंपाइलर एरर देगा, क्योंकि reduce के लिए आवश्यक है कि एक्युमुलेटर का प्रकार एलिमेंट्स के प्रकार के समान हो।

उदाहरण 2: शुरुआती वैल्यू के साथ योग की गणना

एक सामान्य कार्य: ऑर्डर का कुल योग निकालना, लेकिन हमारे खाते में पहले से कुछ शुरुआती बैलेंस है।

val orders = listOf(100, 250, 75)\nval initialBalance = 500\nval totalBalance = orders.fold(initialBa