Swift Language
कार्य

मूल उपयोग

कार्यों को मापदंडों या रिटर्न वैल्यू के बिना घोषित किया जा सकता है। केवल आवश्यक जानकारी एक नाम है (इस मामले में hello )।

func hello()
{
    print("Hello World")
}

कोष्ठक की एक खाली जोड़ी के बाद अपना नाम लिखकर, बिना किसी पैरामीटर के एक फ़ंक्शन को कॉल करें।

hello()
//output: "Hello World"

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

फ़ंक्शंस पैरामीटर ले सकते हैं ताकि उनकी कार्यक्षमता को संशोधित किया जा सके। पैरामीटर को उनके प्रकारों और परिभाषित नामों के साथ अल्पविराम से अलग की गई सूची के रूप में दिया जाता है।

func magicNumber(number1: Int)
{
    print("\(number1) Is the magic number")
}

नोट: The \(number1) सिंटैक्स मूल स्ट्रिंग इंटरपोलेशन है और इसका उपयोग स्ट्रिंग में पूर्णांक सम्मिलित करने के लिए किया जाता है।

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

magicNumber(5)
//output: "5 Is the magic number
let example: Int = 10
magicNumber(example)
//output: "10 Is the magic number"

Int के किसी भी प्रकार के मूल्य का उपयोग किया जा सकता था।

func magicNumber(number1: Int, number2: Int)
{
    print("\(number1 + number2) Is the magic number")
}

जब कोई फ़ंक्शन कई मापदंडों का उपयोग करता है तो पहले पैरामीटर का नाम पहले के लिए आवश्यक नहीं है, लेकिन बाद के मापदंडों पर है।

let ten: Int = 10
let five: Int = 5
magicNumber(ten,number2: five)
//output: "15 Is the magic number"

फ़ंक्शन कॉल को अधिक पठनीय बनाने के लिए बाहरी पैरामीटर नामों का उपयोग करें।

func magicNumber(one number1: Int, two number2: Int)
{
    print("\(number1 + number2) Is the magic number")
}

let ten: Int = 10
let five: Int = 5
magicNumber(one: ten, two: five)

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

func magicNumber(one number1: Int = 5, two number2: Int = 10)
{
    print("\(number1 + number2) Is the magic number")
}

magicNumber()
//output: "15 Is the magic number"

लौटाने का मूल्य

पैरामीटर की सूची के बाद प्रकार निर्दिष्ट करके कार्य मान लौटा सकते हैं।

func findHypotenuse(a: Double, b: Double) -> Double
{
    return sqrt((a * a) + (b * b))
}

let c = findHypotenuse(3, b: 5)
//c = 5.830951894845301

कार्य टुपल्स का उपयोग करके कई मान भी लौटा सकते हैं।

func maths(number: Int) -> (times2: Int, times3: Int)
{
    let two = number * 2
    let three = number * 3
    return (two, three)
}
let resultTuple = maths(5)
//resultTuple = (10, 15)

फेंकने की त्रुटियाँ

यदि आप चाहते हैं कि कोई फ़ंक्शन त्रुटियों को फेंकने में सक्षम हो, तो आपको तर्क रखने वाले कोष्ठकों के बाद throws कीवर्ड को जोड़ना होगा:

func errorThrower()throws -> String {}

जब आप एक त्रुटि फेंकना चाहते हैं, तो throw कीवर्ड का उपयोग करें:

func errorThrower()throws -> String {
  if true {
    return "True"
  } else {
    // Throwing an error
    throw Error.error 
  }
}

यदि आप एक समारोह है कि एक त्रुटि फेंक कर सकते हैं कॉल करना चाहते हैं, तो आप उपयोग करने की आवश्यकता try एक में कीवर्ड do ब्लॉक:

do {
  try errorThrower()
}

स्विफ्ट त्रुटियों पर अधिक के लिए: त्रुटियां

तरीके

उदाहरण विधियाँ ऐसे कार्य हैं जो स्विफ्ट (एक वर्ग , संरचना , गणना या प्रोटोकॉल ) में एक प्रकार के उदाहरणों से संबंधित हैं। टाइप विधियों को एक प्रकार पर ही कहा जाता है।

उदाहरण के तरीके

इंस्टेंस विधियों को func घोषणा के साथ परिभाषित किया जाता है टाइप की परिभाषा के अंदर, या एक विस्तार में ।

class Counter {
    var count = 0
    func increment() {
        count += 1
    }
}

increment() इंस्टेंस विधि Counter क्लास के एक उदाहरण पर कहा जाता है:

let counter = Counter()  // create an instance of Counter class   
counter.increment()      // call the instance method on this instance

टाइप मेथड्स

प्रकार विधियाँ static func कीवर्ड के साथ परिभाषित की जाती हैं। (कक्षाओं के लिए, class func एक प्रकार की विधि को परिभाषित करता है जिसे उपवर्गों द्वारा ओवरराइड किया जा सकता है।)

class SomeClass {
    class func someTypeMethod() {
        // type method implementation goes here
    }
}

SomeClass.someTypeMethod()  // type method is called on the SomeClass type itself

Inout पैरामीटर

यदि inout कीवर्ड के साथ चिह्नित हैं, तो कार्य उनके पास दिए गए मापदंडों को संशोधित कर सकते हैं। किसी फ़ंक्शन के लिए inout पैरामीटर पास करते समय, कॉल करने वाले को पास किए जा रहे वैरिएबल में & a जोड़ना चाहिए।

func updateFruit(fruit: inout Int) {
    fruit -= 1
}

var apples = 30 // Prints "There's 30 apples"
print("There's \(apples) apples")

updateFruit(fruit: &apples)

print("There's now \(apples) apples") // Prints "There's 29 apples".

यह संदर्भ शब्दार्थों को उन प्रकारों पर लागू करने की अनुमति देता है जो सामान्य रूप से मूल्य शब्दार्थ होंगे।

अनुगामी क्लोज सिंटैक्स

जब किसी फ़ंक्शन का अंतिम पैरामीटर एक क्लोजर होता है

func loadData(id: String, completion:(result: String) -> ()) {
    // ...
    completion(result:"This is the result data")
}

फ़ंक्शन को ट्रेलिंग क्लोजर सिंटैक्स का उपयोग करके लागू किया जा सकता है

loadData("123") { result in
    print(result)
}

संचालक कार्य हैं

संचालक जैसे + , - , ?? अक्षरों के बजाय प्रतीकों का उपयोग करके नाम का एक प्रकार है। उन्हें कार्यों से अलग तरीके से आमंत्रित किया जाता है:

• उपसर्ग: - x
• Infix: x + y
• उपसर्ग: x ++

आप द स्विफ्ट प्रोग्रामिंग लैंग्वेज में बुनियादी ऑपरेटरों और उन्नत ऑपरेटरों के बारे में अधिक पढ़ सकते हैं।

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

कभी-कभी, किसी फ़ंक्शन की आवश्यकता के मापदंडों की संख्या को सूचीबद्ध करना संभव नहीं है। एक sum समारोह पर विचार करें:

func sum(_ a: Int, _ b: Int) -> Int {
    return a + b
}

यह दो संख्याओं का योग खोजने के लिए ठीक काम करता है, लेकिन तीन का योग खोजने के लिए हमें एक और फ़ंक्शन लिखना होगा:

func sum(_ a: Int, _ b: Int, _ c: Int) -> Int {
    return a + b + c
}

और चार मापदंडों के साथ एक और एक की आवश्यकता होगी, और इसी तरह। स्विफ्ट एक फ़ंक्शन को तीन अवधियों के अनुक्रम का उपयोग करके चर की संख्या के साथ परिभाषित करना संभव बनाता है: ... उदाहरण के लिए,

func sum(_ numbers: Int...) -> Int {
    return numbers.reduce(0, combine: +)
}

ध्यान दें कि कैसे numbers पैरामीटर, जो कि वैरिएडिक है, को टाइप [Int] एक एकल Array में ले जाया जाता है। यह सामान्य रूप से सही है, टाइप T... वैरिएड पैरामीटर T... [T] रूप में सुलभ हैं।

इस फ़ंक्शन को अब इस तरह कहा जा सकता है:

let a = sum(1, 2) // a == 3
let b = sum(3, 4, 5, 6, 7) // b == 25

स्विफ्ट में एक वैराडिक पैरामीटर को पैरामीटर सूची के अंत में नहीं आना है, लेकिन प्रत्येक फ़ंक्शन हस्ताक्षर में केवल एक ही हो सकता है।

कभी-कभी, मापदंडों की संख्या पर न्यूनतम आकार डालना सुविधाजनक होता है। उदाहरण के लिए, यह वास्तव में कोई मूल्य नहीं की sum लेने के लिए समझ में नहीं आता है। इसे लागू करने का एक आसान तरीका कुछ गैर-वैरेडिक आवश्यक पैरामीटर डालकर और उसके बाद वैरेडिक पैरामीटर जोड़ना है। यह सुनिश्चित करने के लिए कि sum को केवल कम से कम दो मापदंडों के साथ बुलाया जा सकता है, हम लिख सकते हैं

func sum(_ n1: Int, _ n2: Int, _ numbers: Int...) -> Int {
    return numbers.reduce(n1 + n2, combine: +)
}

sum(1, 2) // ok
sum(3, 4, 5, 6, 7) // ok
sum(1) // not ok
sum() // not ok

सबस्क्रिप्ट

कक्षाएं, संरचनाएं, और गणना सदस्यता को परिभाषित कर सकती हैं, जो एक संग्रह, सूची या अनुक्रम के सदस्य तत्वों तक पहुंचने के लिए शॉर्टकट हैं।

उदाहरण

struct DaysOfWeek {
  
  var days = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"]
  
  subscript(index: Int) -> String {
    get {
      return days[index]
    }
    set {
      days[index] = newValue
    }
  }
}

सदस्यता का उपयोग

var week = DaysOfWeek()
//you access an element of an array at index by array[index].
debugPrint(week[1])
debugPrint(week[0])
week[0] = "Sunday"
debugPrint(week[0])

सदस्यता विकल्प:

सदस्यता किसी भी इनपुट पैरामीटर को ले सकती है, और ये इनपुट पैरामीटर किसी भी प्रकार के हो सकते हैं। सदस्यता किसी भी प्रकार वापस कर सकते हैं। अंश चर मापदंडों और चर मापदंडों का उपयोग कर सकते हैं, लेकिन इन-आउट मापदंडों का उपयोग नहीं कर सकते हैं या डिफ़ॉल्ट पैरामीटर मान प्रदान नहीं कर सकते हैं।

उदाहरण:

struct Food {
  
  enum MealTime {
    case Breakfast, Lunch, Dinner
  }
  
  var meals: [MealTime: String] = [:]
  
  subscript (type: MealTime) -> String? {
    get {
      return meals[type]
    }
    set {
      meals[type] = newValue
    }
  }
}

प्रयोग

var diet = Food()
diet[.Breakfast] = "Scrambled Eggs"
diet[.Lunch] = "Rice"

debugPrint("I had \(diet[.Breakfast]) for breakfast")

क्लोजर के साथ कार्य

उन कार्यों का उपयोग करना जो क्लोज़र को अंदर ले जाने और निष्पादित करने के लिए कोड को ब्लॉक करने के लिए कहीं और निष्पादित करने के लिए बेहद उपयोगी हो सकते हैं। हम अपने फ़ंक्शन को एक वैकल्पिक क्लोजर में लेने की अनुमति देकर शुरू कर सकते हैं जो (इस मामले में) Void वापस करेगा।

func closedFunc(block: (()->Void)? = nil) {
    print("Just beginning")

    if let block = block {
        block()
    }
}

अब जब हमारे फ़ंक्शन को परिभाषित किया गया है, तो इसे कॉल करें और कुछ कोड में पास करें:

closedFunc() { Void in
    print("Over already")
}

हमारे फ़ंक्शन कॉल के साथ एक अनुगामी क्लोजर का उपयोग करके, हम कोड में पारित कर सकते हैं (इस मामले में, print ) को हमारे closedFunc() फ़ंक्शन के भीतर कुछ बिंदु पर निष्पादित किया जाना है।

लॉग को प्रिंट करना चाहिए:

शुरुआत

पहले से ही

इसके अधिक विशिष्ट उपयोग के मामले में दो वर्गों के बीच कोड का निष्पादन शामिल हो सकता है:

class ViewController: UIViewController {

    override func viewDidLoad() {
        let _  = A.init(){Void in self.action(2)}
    }

    func action(i: Int) {
        print(i)
    }
}


class A: NSObject {
    var closure : ()?

    init(closure: (()->Void)? = nil) {
        // Notice how this is executed before the  closure
        print("1")
        // Make sure closure isn't nil
        self.closure = closure?()
    }
}

लॉग को प्रिंट करना चाहिए:

1

2

पासिंग और फंक्शनिंग

निम्न फ़ंक्शन इसके परिणाम के रूप में एक और फ़ंक्शन लौटा रहा है जिसे बाद में एक चर को सौंपा जा सकता है और कहा जाता है:

func jediTrainer () -> ((String, Int) -> String) {
  func train(name: String, times: Int) -> (String) {
    return "\(name) has been trained in the Force \(times) times"
  }
  return train
}

let train = jediTrainer()
train("Obi Wan", 3)

प्रकार्य

प्रत्येक फ़ंक्शन का अपना फ़ंक्शन प्रकार होता है, जो पैरामीटर प्रकार और फ़ंक्शन के रिटर्न प्रकार से बना होता है। उदाहरण के लिए निम्न कार्य:

func sum(x: Int, y: Int) -> (result: Int) { return x + y }

एक समारोह प्रकार है:

(Int, Int) -> (Int)

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