स्विफ्ट - क्लोजर

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

वैश्विक कार्य	नेस्टेड कार्य	क्लोजर एक्सप्रेशन
एक नाम है। किसी भी मूल्य पर कब्जा न करें	एक नाम है। फ़ंक्शन को एन्क्लोज़ करने से मान कैप्चर करें	बेनाम: आसन्न ब्लॉक से मूल्यों पर कब्जा कब्जा

स्विफ्ट 4 भाषा में बंद अभिव्यक्ति कुरकुरा, अनुकूलन और हल्के वाक्यविन्यास शैलियों का पालन करती है जिसमें शामिल हैं।

संदर्भ से संदर्भ पैरामीटर और वापसी मान प्रकार।
एकल-अभिव्यक्ति क्लोजर से निहित रिटर्न।
आशुलिपि तर्क नाम और
ट्रेलिंग क्लोजर सिंटैक्स

वाक्य - विन्यास

क्लोजर को परिभाषित करने के लिए एक सामान्य वाक्यविन्यास निम्नलिखित है जो मापदंडों को स्वीकार करता है और एक डेटा प्रकार देता है -

{
   (parameters) −> return type in
   statements
}

निम्नलिखित एक सरल उदाहरण है -

let studname = { print("Welcome to Swift Closures") }
studname()

जब हम खेल के मैदान का उपयोग करके उपरोक्त कार्यक्रम चलाते हैं, तो हमें निम्नलिखित परिणाम मिलते हैं -

Welcome to Swift Closures

निम्नलिखित क्लोजर दो मापदंडों को स्वीकार करता है और एक बूल मान लौटाता है -

{     
   (Int, Int) −> Bool in
   Statement1
   Statement 2
   ---
   Statement n
}

निम्नलिखित एक सरल उदाहरण है -

let divide = {
   (val1: Int, val2: Int) -> Int in 
   return val1 / val2 
}

let result = divide(200, 20)
print (result)

क्लोजर में अभिव्यक्तियाँ

नेस्टेड फ़ंक्शन कोड के नामकरण और परिभाषित ब्लॉकों का एक सुविधाजनक तरीका प्रदान करते हैं। पूरे फ़ंक्शन की घोषणा करने के बजाय और छोटे कार्यों को दर्शाने के लिए नाम निर्माण का उपयोग किया जाता है। फ़ोकस सिंटैक्स के साथ एक स्पष्ट संक्षिप्त विवरण में फ़ंक्शन का प्रतिनिधित्व करना बंद भावों के माध्यम से प्राप्त किया जाता है।

आरोही क्रम कार्यक्रम

एक स्ट्रिंग को सॉर्ट करना स्विफ्ट 4 जी कुंजी आरक्षित फ़ंक्शन "सॉर्ट" द्वारा प्राप्त किया गया है जो पहले से ही मानक पुस्तकालय में उपलब्ध है। फ़ंक्शन दिए गए स्ट्रिंग्स को आरोही क्रम में सॉर्ट करेगा और तत्वों को नए सरणी में समान आकार और पुराने प्रकार में उल्लिखित डेटा प्रकार के साथ लौटाएगा। पुरानी सरणी वही रहती है।

दो तर्कों को हल किए गए फ़ंक्शन के अंदर दर्शाया गया है -

ज्ञात प्रकार के मान सरणियों के रूप में दर्शाए जाते हैं।
सरणी सामग्री (इंट, इंट) और एक बूलियन मान (बूल) लौटाता है यदि सरणी को ठीक से सॉर्ट किया जाता है तो यह सही मान लौटाएगा अन्यथा यह गलत वापस आ जाएगा।

इनपुट स्ट्रिंग के साथ एक सामान्य फ़ंक्शन को लिखा गया है और नए सरणी में सॉर्ट किए गए तार प्राप्त करने के लिए सॉर्ट किए गए फ़ंक्शन को पास किया गया है जो नीचे दिखाया गया है -

func ascend(s1: String, s2: String) -> Bool {
   return s1 > s2
}

let stringcmp = ascend(s1: "Swift 4", s2: "great")
print (stringcmp)

true

Icecream के लिए छांटे जाने वाले प्रारंभिक सरणी को "स्विफ्ट 4" और "महान" के रूप में दिया गया है। सरणी को सॉर्ट करने के लिए फ़ंक्शन को स्ट्रिंग डेटाटाइप के रूप में घोषित किया गया है और इसके वापसी प्रकार को बूलियन के रूप में उल्लेख किया गया है। दोनों तारों की तुलना की जाती है और आरोही क्रम में क्रमबद्ध किया जाता है और एक नए सरणी में संग्रहीत किया जाता है। यदि छँटाई सफल हुई है तो फ़ंक्शन सही मान लौटाएगा अन्यथा यह गलत वापस आ जाएगा।

बंद अभिव्यक्ति सिंटैक्स का उपयोग करता है -

निरंतर पैरामीटर,
चर मापदंडों, और
inout पैरामीटर।

क्लोजर एक्सप्रेशन ने डिफ़ॉल्ट मानों का समर्थन नहीं किया। वैरिएडिक पैरामीटर और ट्यूपल्स को पैरामीटर प्रकार और रिटर्न प्रकार के रूप में भी इस्तेमाल किया जा सकता है।

let sum = {
   (no1: Int, no2: Int) -> Int in 
   return no1 + no2 
}

let digits = sum(10, 20)
print(digits)

फ़ंक्शन स्टेटमेंट में उल्लिखित पैरामीटर और रिटर्न प्रकार की घोषणाएं इनलाइन क्लोजर एक्सप्रेशन फ़ंक्शन के साथ 'कीवर्ड' में भी दर्शाई जा सकती हैं। एक बार 'कीवर्ड' में 'पैरामीटर और रिटर्न टाइप्स' घोषित करने के लिए क्लोजर के बॉडी को दर्शाने के लिए उपयोग किया जाता है।

एकल अभिव्यक्ति निहित रिटर्न

यहां, सॉर्ट किए गए फ़ंक्शन के दूसरे तर्क का फ़ंक्शन प्रकार यह स्पष्ट करता है कि एक बूल मान को बंद करके वापस किया जाना चाहिए। क्योंकि क्लोजर के शरीर में एक एकल अभिव्यक्ति (s1> s2) होता है जो बूल मान लौटाता है, कोई अस्पष्टता नहीं है, और वापसी कीवर्ड छोड़ा जा सकता है।

अभिव्यक्ति में एकल अभिव्यक्ति विवरण वापस करने के लिए 'वापसी' कीवर्ड इसके घोषणा भाग में छोड़ा गया है।

var count:[Int] = [5, 10, -6, 75, 20]
let descending = count.sorted(by: { n1, n2 in n1 > n2 })
let ascending = count.sorted(by: { n1, n2 in n1 < n2 })

print(descending)
print(ascending)

[75, 20, 10, 5, -6]
[-6, 5, 10, 20, 75]

यह कथन स्वयं स्पष्ट रूप से परिभाषित करता है कि जब string1 string 2 से अधिक है तो सही है अन्यथा असत्य है इसलिए रिटर्न स्टेटमेंट को यहाँ छोड़ दिया गया है।

ज्ञात प्रकार क्लोजर

दो संख्याओं के जोड़ पर विचार करें। हम जानते हैं कि इसके अलावा पूर्णांक डेटाटाइप वापस आ जाएगा। इसलिए ज्ञात प्रकार के बंदों को घोषित किया जाता है -

let sub = {
   (no1: Int, no2: Int) -> Int in 
   return no1 - no2 
}

let digits = sub(10, 20)
print(digits)

-10

क्लोजर के रूप में आशुलिपि तर्क नाम की घोषणा

स्विफ्ट 4 स्वचालित रूप से इनलाइन क्लोजर को शॉर्टहैंड तर्क नाम प्रदान करता है, जिसका उपयोग $ 0, $ 1, $ 2, और इसी तरह के नामों द्वारा क्लोजर के तर्कों के मूल्यों को संदर्भित करने के लिए किया जा सकता है।

var shorthand: (String, String) -> String
shorthand = { $1 }
print(shorthand("100", "200"))

यहाँ, $ 0 और $ 1 क्लोजर के पहले और दूसरे स्ट्रिंग तर्क का उल्लेख करते हैं।

स्विफ्ट 4 उपयोगकर्ता को $ 0, $ 1, $ 2 --- $ n का प्रतिनिधित्व करके इनहैंड क्लोजर नाम के रूप में इनलाइन क्लोजर का प्रतिनिधित्व करने की सुविधा देता है।

क्लोजर तर्क सूची को परिभाषा खंड में छोड़ दिया जाता है जब हम क्लोजर अभिव्यक्तियों के अंदर शॉर्टहैंड तर्क नामों का प्रतिनिधित्व करते हैं। फ़ंक्शन प्रकार के आधार पर शॉर्टहैंड तर्क नाम व्युत्पन्न किए जाएंगे। चूंकि शॉर्टहैंड तर्क को अभिव्यक्ति बॉडी में परिभाषित किया गया है, इसलिए 'कीवर्ड' को छोड़ दिया गया है।

संचालक कार्य के रूप में क्लोजर

स्विफ्ट 4 बस के रूप में ऑपरेटर कार्यों को प्रदान करके सदस्यों तक पहुंचने का एक आसान तरीका प्रदान करता है। पिछले उदाहरणों में 'बूल' शब्द का प्रयोग या तो 'सही' लौटने के लिए किया जाता है जब तार बराबर होते हैं अन्यथा यह 'असत्य' देता है।

अभिव्यक्ति को क्लोजर में ऑपरेटर फ़ंक्शन द्वारा और भी सरल बनाया गया है -

let numb = [98, -20, -30, 42, 18, 35]
var sortedNumbers = numb.sorted ({
   (left: Int, right: Int) -> Bool in
   return left < right
})

let asc = numb.sorted(<)
print(asc)

[-30, -20, 18, 35, 42, 98]

ट्रेलरों के रूप में क्लोजर

फ़ंक्शन के अंतिम तर्क को एक बंद अभिव्यक्ति में पास करना 'ट्रेलिंग क्लोज़र' की मदद से घोषित किया जाता है। यह फ़ंक्शन के बाहर लिखा है () {} के साथ। इसके उपयोग की आवश्यकता तब होती है जब फ़ंक्शन को एक पंक्ति में इनलाइन लिखना संभव नहीं होता है।

reversed = sorted(names) { $0 > $1}

जहां {$ 0> $ 1} को बाहर (नाम) घोषित किए गए अनुगामी क्लोजर के रूप में दर्शाया जाता है।

import Foundation
var letters = ["North", "East", "West", "South"]

let twoletters = letters.map({ 
   (state: String) -> String in
   return state.substringToIndex(advance(state.startIndex, 2)).uppercaseString
})

let stletters = letters.map() { 
   $0.substringToIndex(advance($0.startIndex, 2)).uppercaseString 
}
print(stletters)

[NO, EA, WE, SO]

मान और संदर्भ प्रकार कैप्चर करना

स्विफ्ट 4 में, स्थिरांक और चर मान को बंद करने की मदद से किया जाता है। यह उन स्थिरांकों और चर के लिए मानों को आगे संदर्भित करता है और बंद करता है, भले ही चर अब मौजूद नहीं हैं।

अन्य फ़ंक्शन के शरीर में फ़ंक्शन लिखकर नेस्टेड फ़ंक्शन का उपयोग करके निरंतर और चर मान कैप्चर करना प्राप्त किया जाता है।

एक नेस्टेड फ़ंक्शन कैप्चर करता है -

बाहरी कार्य तर्क।
बाहरी फ़ंक्शन के भीतर परिभाषित स्थिरांक और चर कैप्चर करें।

स्विफ्ट 4 में, जब किसी फंक्शन के अंदर एक स्थिरांक या चर को घोषित किया जाता है, तो उस चर का संदर्भ भी स्वतः ही बंद हो जाता है। यह दो से अधिक चर को एक ही क्लोजर के रूप में संदर्भित करने की सुविधा प्रदान करता है -

let decrem = calcDecrement(forDecrement: 18)
decrem()

यहाँ oneDecrement और घटते चर दोनों क्लोजर संदर्भ के रूप में एक ही मेमोरी ब्लॉक को इंगित करेंगे।

func calcDecrement(forDecrement total: Int) -> () -> Int {
   var overallDecrement = 100
   func decrementer() -> Int {
      overallDecrement -= total
      print(overallDecrement)
      return overallDecrement
   }
   return decrementer
}

let decrem = calcDecrement(forDecrement: 18)
decrem()
decrem()
decrem()

82
64
46

जब प्रत्येक और हर बार बाहरी फ़ंक्शन कैल्सेड्रेमेंट कहलाता है, तो यह डिक्रिशनर () फ़ंक्शन को आमंत्रित करता है और 18 से मूल्य को घटाता है और बाहरी फ़ंक्शन कैल्सेड्रेमेंट की मदद से परिणाम देता है। यहाँ कैल्केड्रेमेंट एक क्लोजर के रूप में कार्य करता है।

भले ही फ़ंक्शन डिक्रिमिनेटर () में डिफ़ॉल्ट रूप से बंद होने वाले कोई तर्क नहीं हैं, यह मौजूदा मूल्यों को कैप्चर करके चर 'समग्र विकास' और 'कुल' को संदर्भित करता है। निर्दिष्ट चर के लिए मानों की प्रतिलिपि नए डिक्रीमेंटर () फ़ंक्शन के साथ संग्रहीत की जाती है। जब स्विचेस उपयोग में नहीं हैं, तो स्विफ्ट 4 मेमोरी मैनेजमेंट को आवंटित और डील करके मेमोरी प्रबंधन कार्यों को संभालता है।