Swift में कार्यात्मक प्रोग्रामिंग: मूल बातें और उदाहरण

Swift में कार्यात्मक प्रोग्रामिंग: क्लोज़र से कंपोज़िशन तक

Swift को मूल रूप से एक मल्टी-पैराडाइम भाषा के रूप में डिज़ाइन किया गया था। यह ऑब्जेक्ट-ओरिएंटेड, प्रोटोकॉल-ओरिएंटेड और कार्यात्मक प्रोग्रामिंग का समर्थन करता है। कार्यात्मक दृष्टिकोण अधिक पूर्वानुमानित, परीक्षण योग्य और समानांतर-सुरक्षित कोड लिखने में मदद करता है। इस लेख में, हम व्यावहारिक उदाहरणों के साथ Swift में कार्यात्मक प्रोग्रामिंग की प्रमुख अवधारणाओं पर चर्चा करेंगे।

1. शुद्ध फंक्शन और इम्यूटेबिलिटी

कार्यात्मक शैली का आधार शुद्ध फंक्शन हैं। ऐसा फंक्शन समान तर्कों के लिए हमेशा एक ही परिणाम लौटाता है और इसका कोई दुष्प्रभाव नहीं होता (बाहरी स्थिति को नहीं बदलता)।

// अशुद्ध फंक्शन — बाहरी वेरिएबल को बदलता हैvar total = 0func addToTotal(_ value: Int) -> Int {    total += value    return total}

// शुद्ध फंक्शन — केवल गणनाfunc add(_ a: Int, _ b: Int) -> Int {    return a + b}

इम्यूटेबिलिटी (अपरिवर्तनीयता) let और वैल्यू सेमैंटिक्स वाली संरचनाओं के माध्यम से प्राप्त की जाती है। ऐरे को बदलने के बजाय, हम एक नया बनाते हैं:

let numbers = [1, 2, 3, 4, 5]// var और append के बजाय:let newNumbers = numbers + [6] // [1, 2, 3, 4, 5, 6]

2. क्लोज़र (Closures) बिल्डिंग ब्लॉक के रूप में

Swift में क्लोज़र अनाम फंक्शन हैं जो आसपास के संदर्भ से वेरिएबल को कैप्चर कर सकते हैं। वे "प्रथम श्रेणी के नागरिक" हैं: उन्हें पैरामीटर के रूप में पास किया जा सकता है और फंक्शन से लौटाया जा सकता है।

// सरल क्लोज़रlet multiply: (Int, Int) -> Int = { $0 * $1 }let result = multiply(3, 4) // 12

// संदर्भ कैप्चर करने वाला क्लोज़रvar counter = 0let increment = { counter += 1 }increment() // counter = 1increment() // counter = 2

क्लोज़र का उपयोग उच्च-क्रम विधियों जैसे sorted में सक्रिय रूप से किया जाता है:

let names = ["इवान", "अन्ना", "बोरिस", "ऐलेना"]let sorted = names.sorted { $0.localizedStandardCompare($1) == .orderedAscending }print(sorted) // ["अन्ना", "बोरिस", "ऐलेना", "इवान"]

3. उच्च-क्रम विधियाँ: map, filter, reduce

ये Swift में कार्यात्मक शैली का "वर्कहॉर्स" हैं। ये स्पष्ट लूप और म्यूटेशन के बिना कलेक्शन को प्रोसेस करने की अनुमति देते हैं।

map

कलेक्शन के प्रत्येक तत्व को रूपांतरित करता है:

let prices = [100, 200, 300]let withTax = prices.map { $0 * 1.2 }print(withTax) // [120.0, 240.0, 360.0]

// वास्तविक उदाहरण: मॉडल ऐरे से नाम निकालनाstruct User {    let name: String    let age: Int}let users = [User(name: "एलेक्सी", age: 30), User(name: "मारिया", age: 25)]let userNames = users.map { $0.name }print(userNames) // ["एलेक्सी", "मारिया"]

filter

शर्त के अनुसार तत्वों का चयन करता है:

let numbers = [1, 2, 3, 4, 5, 6]let evenNumbers = numbers.filter { $0 % 2 == 0 }print(evenNumbers) // [2, 4, 6]

// 18 वर्ष से अधिक आयु के उपयोगकर्ताओं को फ़िल्टर करनाlet adults = users.filter { $0.age >= 18 }

reduce

कलेक्शन को एक मान में समेटता है:

let sum = numbers.reduce(0, +) // 21// ऐरे से स्ट्रिंग बनानाlet words = ["कार्यात्मक", "प्रोग्रामिंग", "Swift"]let sentence = words.reduce("") { $0.isEmpty ? $1 : $0 + " " + $1 }print(sentence) // "कार्यात्मक प्रोग्रामिंग Swift"

विधियों का संयोजन

सबसे दिलचस्प बात है कॉल की चेन:

let transactions = [250, -50, 100, -200, 300, -100]let balance = transactions    .filter { $0 > 0 }          // केवल आय    .map { $0 * 0.87 }          // 13% कर घटाना    .reduce(0, +)               // योग करनाprint(balance) // 565.5

4. फंक्शन कंपोज़िशन और करीइंग

कंपोज़िशन कई फंक्शन को एक में संयोजित करने की अनुमति देता है। Swift में कोई बिल्ट-इन कंपो