स्विफ्ट - कार्य

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

Function Declaration - एक फंक्शन के नाम, रिटर्न टाइप और पैरामीटर्स के बारे में कंपाइलर को बताता है।
Function Definition - यह फ़ंक्शन का वास्तविक निकाय प्रदान करता है।

स्विफ्ट 4 फ़ंक्शन में पैरामीटर प्रकार और इसके वापसी प्रकार शामिल हैं।

कार्य की परिभाषा

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

प्रत्येक फ़ंक्शन में एक फ़ंक्शन नाम होता है, जो उस कार्य का वर्णन करता है जो फ़ंक्शन करता है। किसी फ़ंक्शन का उपयोग करने के लिए, आप उस फ़ंक्शन को उसके नाम के साथ "कॉल" करते हैं और इनपुट मानों (तर्कों के रूप में जाना जाता है) जो फ़ंक्शन के मापदंडों के प्रकारों से मेल खाते हैं। फ़ंक्शन मापदंडों को 'टुपल्स' भी कहा जाता है।

फ़ंक्शन के तर्कों को हमेशा उसी क्रम में प्रदान किया जाना चाहिए जैसे कि फ़ंक्शन की पैरामीटर सूची और रिटर्न मान → के बाद होते हैं।

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

func funcname(Parameters) -> returntype {
   Statement1
   Statement2
   ---
   Statement N
   return parameters
}

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

func student(name: String) -> String {
   return name
}

print(student(name: "First Program"))
print(student(name: "About Functions"))

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

First Program
About Functions

एक समारोह बुला रहा है

मान लें कि हमने 'डिसप्ले' नामक फ़ंक्शन को 'डिसप्ले' के रूप में परिभाषित किया है, उदाहरण के लिए फंक्शन नंबर्स को 'फंक्शन नेम' डिसप्ले के साथ शुरू करने के लिए उदाहरण के लिए पहले 'नं 1' तर्क दिया गया है जो पूर्णांक डेटा प्रकार रखता है। फिर तर्क 'no1' को 'a' तर्क दिया जाता है जो इसके बाद उसी डेटा प्रकार पूर्णांक को इंगित करेगा। अब तर्क 'a' फ़ंक्शन पर वापस आ जाता है। यहां प्रदर्शन () फ़ंक्शन पूर्णांक मान को रखेगा और पूर्णांक मानों को लौटाएगा जब फ़ंक्शन को हर बार लागू किया जाता है।

func display(no1: Int) -> Int {
   let a = no1
   return a
}

print(display(no1: 100))
print(display(no1: 200))

100
200

पैरामीटर और रिटर्न मान

स्विफ्ट 4 लचीले फ़ंक्शन पैरामीटर और इसके रिटर्न मान को सरल से जटिल मान प्रदान करता है। सी और ऑब्जेक्टिव सी के समान, स्विफ्ट 4 में कार्य भी कई रूप ले सकते हैं।

पैरामीटर के साथ कार्य

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

func mult(no1: Int, no2: Int) -> Int {
   return no1*no2
}

print(mult(no1: 2, no2: 20))
print(mult(no1: 3, no2: 15))
print(mult(no1: 4, no2: 30))

40
45
120

पैरामीटर के बिना कार्य

हमारे पास बिना किसी पैरामीटर के भी कार्य हो सकते हैं।

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

func funcname() -> datatype {
   return datatype
}

एक पैरामीटर के बिना एक फ़ंक्शन होने के बाद एक उदाहरण है -

func votersname() -> String {
   return "Alice"
}
print(votersname())

Alice

रिटर्न मान के साथ कार्य

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

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

func ls(array: [Int]) -> (large: Int, small: Int) {
   var lar = array[0]
   var sma = array[0]

   for i in array[1..<array.count] {
      if i < sma {
         sma = i
      } else if i > lar {
         lar = i
      }
   }
   return (lar, sma)
}

let num = ls(array: [40,12,-5,78,98])
print("Largest number is: \(num.large) and smallest number is: \(num.small)")

Largest number is: 98 and smallest number is: -5

रिटर्न वैल्यू के बिना कार्य

कुछ कार्यों में बिना किसी रिटर्न मान के फ़ंक्शन के अंदर घोषित किए गए तर्क हो सकते हैं। निम्नलिखित कार्यक्रम घोषित करता हैa तथा bयोग () फ़ंक्शन के तर्क के रूप में। फ़ंक्शन के अंदर ही तर्कों के लिए मान हैंa तथा b फ़ंक्शन कॉल योग () को लागू करके पारित किया जाता है और इसके मूल्यों को मुद्रित किया जाता है जिससे रिटर्न मान समाप्त हो जाते हैं।

func sum(a: Int, b: Int) {
   let a = a + b
   let b = a - b
   print(a, b)
}

sum(a: 20, b: 10)
sum(a: 40, b: 10)
sum(a: 24, b: 6)

30 20
50 40
30 24

वैकल्पिक रिटर्न प्रकार के साथ कार्य

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

वैकल्पिक कार्य दो रूपों 'मूल्य' और एक 'शून्य' लेंगे। हम प्रमुख आरक्षित चरित्र के साथ 'वैकल्पिक' का उल्लेख करेंगे? ' यह जाँचने के लिए कि क्या टूपल एक मान या शून्य मान लौटा रहा है।

func minMax(array: [Int]) -> (min: Int, max: Int)? {
   if array.isEmpty { return nil }
   var currentMin = array[0]
   var currentMax = array[0]
   
   for value in array[1..<array.count] {
      if value < currentMin {
         currentMin = value
      } else if value > currentMax {
         currentMax = value
      }
   }
   return (currentMin, currentMax)
}

if let bounds = minMax(array: [8, -6, 2, 109, 3, 71]) {
   print("min is \(bounds.min) and max is \(bounds.max)")
}

min is -6 and max is 109

'' वैकल्पिक 'का उपयोग' शून्य 'या कचरा मानों की जांच के लिए किया जाता है, जिससे डिबगिंग में बहुत समय लगता है और उपयोगकर्ता के लिए कोड को कुशल और पठनीय बनाया जा सकता है।

कार्य स्थानीय बनाम बाहरी पैरामीटर नाम

स्थानीय पैरामीटर नाम

स्थानीय पैरामीटर नाम अकेले फ़ंक्शन के अंदर पहुंचते हैं।

func sample(number: Int) {
   print(number)
}

यहां ही funcनमूना तर्क संख्या को आंतरिक चर के रूप में घोषित किया जाता है क्योंकि यह फ़ंक्शन नमूना () द्वारा आंतरिक रूप से एक्सेस किया जाता है। यहां 'संख्या' को स्थानीय चर के रूप में घोषित किया गया है, लेकिन चर का संदर्भ निम्न कथन के साथ फ़ंक्शन के बाहर किया गया है -

func sample(number: Int) {
   print(number)
}

sample(number: 1)
sample(number: 2)
sample(number: 3)

1
2
3

बाहरी पैरामीटर नाम

बाहरी पैरामीटर नाम हमें अपने उद्देश्य को और अधिक स्पष्ट करने के लिए एक फ़ंक्शन पैरामीटर का नाम देने की अनुमति देते हैं। नीचे दिए गए उदाहरण के लिए आप दो फ़ंक्शन मापदंडों को नाम दे सकते हैं और फिर उस फ़ंक्शन को निम्नानुसार कॉल कर सकते हैं -

func pow(firstArg a: Int, secondArg b: Int) -> Int {
   var res = a
   for _ in 1..<b {
      res = res * a
   }
   print(res)
   return res
}

pow(firstArg:5, secondArg:3)

वैराडिक पैरामीटर्स

जब हम फ़ंक्शन को कई तर्कों के साथ परिभाषित करना चाहते हैं, तो हम सदस्यों को 'वैरेडिक' मापदंडों के रूप में घोषित कर सकते हैं। पैरामीटर नाम के बाद पैरामीटर्स को वैरिएड के रूप में निर्दिष्ट किया जा सकता है।

func vari<N>(members: N...){
   for i in members {
      print(i)
   }
}

vari(members: 4,3,5)
vari(members: 4.5, 3.1, 5.6)
vari(members: "Swift 4", "Enumerations", "Closures")

4
3
5
4.5
3.1
5.6
Swift 4
Enumerations
Closures

लगातार, परिवर्तनीय और I / O पैरामीटर

डिफ़ॉल्ट रूप से कार्य मापदंडों को 'स्थिर' मानते हैं, जबकि उपयोगकर्ता कार्यों के तर्कों को भी चर के रूप में घोषित कर सकता है। हमने पहले ही चर्चा की थी कि 'let' कीवर्ड का उपयोग निरंतर मापदंडों को घोषित करने के लिए किया जाता है और चर मापदंडों को 'var' कीवर्ड के साथ परिभाषित किया जाता है।

स्विफ्ट 4 में I / O पैरामीटर पैरामीटर मानों को बनाए रखने के लिए कार्यक्षमता प्रदान करता है, भले ही इसके मान फ़ंक्शन कॉल के बाद संशोधित हो। फ़ंक्शन पैरामीटर परिभाषा की शुरुआत में, सदस्य मूल्यों को बनाए रखने के लिए 'इनऑउट' कीवर्ड घोषित किया जाता है।

यह कीवर्ड 'इनऑउट' को व्युत्पन्न करता है क्योंकि इसके मान 'फंक्शन' में 'पास' हो जाते हैं और इसके मान बॉडी द्वारा एक्सेस और संशोधित हो जाते हैं और मूल तर्क को संशोधित करने के लिए इसे फंक्शन से वापस 'आउट' कर दिया जाता है।

वेरिएबल्स को केवल इन-आउट पैरामीटर के लिए एक तर्क के रूप में पारित किया जाता है क्योंकि इसके मान अकेले फ़ंक्शन के अंदर और बाहर संशोधित किए जाते हैं। इसलिए तार और शाब्दिक को बाहर के मापदंडों के रूप में घोषित करने की आवश्यकता नहीं है। वेरिएबल नाम से पहले 'और' बताता है कि हम तर्क को इन-आउट पैरामीटर से गुजार रहे हैं।

func temp(a1: inout Int, b1: inout Int) {
   let t = a1
   a1 = b1
   b1 = t
}

var no = 2
var co = 10
temp(a1: &no, b1: &co)
print("Swapped values are \(no), \(co)")

Swapped values are 10, 2

प्रकार और इसके उपयोग

प्रत्येक और प्रत्येक फ़ंक्शन इनपुट मापदंडों पर विचार करके विशिष्ट फ़ंक्शन का अनुसरण करता है और वांछित परिणाम को आउटपुट करता है।

func inputs(no1: Int, no2: Int) -> Int {
   return no1/no2
}

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

func inputs(no1: Int, no2: Int) -> Int {
   return no1/no2
}

print(inputs(no1: 20, no2: 10))
print(inputs(no1: 36, no2: 6))

2
6

यहां फ़ंक्शन को दो तर्कों के साथ आरंभ किया गया है no1 तथा no2 पूर्णांक डेटा प्रकारों और उसके रिटर्न प्रकार को भी 'int' घोषित किया जाता है

Func inputstr(name: String) -> String {
   return name
}

यहाँ फ़ंक्शन के रूप में घोषित किया गया है string डाटा प्रकार।

कार्य भी हो सकते हैं void डेटा प्रकार और इस तरह के कार्य कुछ भी वापस नहीं करेंगे।

func inputstr() {
   print("Swift 4 Functions")
   print("Types and its Usage")
}
inputstr()

Swift 4 Functions
Types and its Usage

उपरोक्त फ़ंक्शन को बिना किसी तर्क और कोई वापसी मान के साथ एक शून्य फ़ंक्शन के रूप में घोषित किया गया है।

फ़ंक्शन प्रकारों का उपयोग करना

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

var addition: (Int, Int) -> Int = sum

यहाँ योग एक फ़ंक्शन नाम है जिसमें 'a' और 'b' पूर्णांक चर होते हैं, जिसे अब फ़ंक्शन नाम परिवर्धन के रूप में घोषित किया जाता है। इसके बाद दोनों जोड़ और योग फ़ंक्शन दोनों में समान संख्या में तर्क होते हैं जो पूर्णांक डेटाटाइप के रूप में घोषित किए जाते हैं और पूर्णांक मान को संदर्भ के रूप में भी लौटाते हैं।

func sum(a: Int, b: Int) -> Int {
   return a + b
}
var addition: (Int, Int) -> Int = sum
print("Result: \(addition(40, 89))")

Result: 129

पैरामीटर प्रकार और वापसी प्रकार के रूप में फ़ंक्शन

हम फ़ंक्शन को दूसरे फ़ंक्शन के पैरामीटर प्रकार के रूप में भी पास कर सकते हैं।

func sum(a: Int, b: Int) -> Int {
   return a + b
}
var addition: (Int, Int) -> Int = sum
print("Result: \(addition(40, 89))")

func another(addition: (Int, Int) -> Int, a: Int, b: Int) {
   print("Result: \(addition(a, b))")
}
another(sum, 10, 20)

Result: 129
Result: 30

नेस्टेड कार्य

एक नेस्टेड फ़ंक्शन बाहरी फ़ंक्शन को कॉल करने की सुविधा प्रदान करता है।

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

let decrem = calcDecrement(forDecrement: 30)
print(decrem())

-30