Swift Language
एक्सटेंशन

टिप्पणियों

चर और कार्य

एक्सटेंशन में फ़ंक्शंस हो सकते हैं और गणना / स्थिर चर प्राप्त कर सकते हैं। वे प्रारूप में हैं

extension ExtensionOf {
    //new functions and get-variables
}

विस्तारित वस्तु के उदाहरण को संदर्भित करने के लिए, self का उपयोग किया जा सकता है, जैसे कि इसका उपयोग किया जा सकता है

String का एक विस्तार बनाने के लिए जो एक .length() फ़ंक्शन को जोड़ता है जो स्ट्रिंग की लंबाई लौटाता है, उदाहरण के लिए

extension String {
    func length() -> Int {
        return self.characters.count
    }
}

"Hello, World!".length() // 13

एक्सटेंशन भी शामिल कर सकते हैं get चर। उदाहरण के लिए, स्ट्रिंग के लिए .length चर जोड़ना जो स्ट्रिंग की लंबाई लौटाता है

extension String {
    var length: Int {
        get {
            return self.characters.count
        }
    }
}

"Hello, World!".length // 13

एक्सटेंशन्स में शुरुआती

एक्सटेंशन में सुविधा इनिशियलाइज़र हो सकते हैं। उदाहरण के लिए, Int लिए एक फालतू इनिशियलाइज़र जो NSString स्वीकार करता है:

extension Int {
    init?(_ string: NSString) {
        self.init(string as String)  // delegate to the existing Int.init(String) initializer
    }
}

let str1: NSString = "42"
Int(str1) // 42

let str2: NSString = "abc"
Int(str2) // nil

एक्सटेंशन्स क्या हैं?

एक्सटेंशन का उपयोग स्विफ्ट में मौजूदा प्रकारों की कार्यक्षमता को बढ़ाने के लिए किया जाता है। एक्सटेंशन सब्सक्राइबर्स, फ़ंक्शंस, इनिशियलाइज़र और कंप्यूटेड प्रॉपर्टीज़ को जोड़ सकते हैं। वे प्रोटोकॉल के प्रकार भी बना सकते हैं।

मान लीजिए कि आप एक Int के भाज्य की गणना करने में सक्षम होना चाहते हैं। आप एक एक्सटेंशन में एक संगणित संपत्ति जोड़ सकते हैं:

extension Int {
    var factorial: Int {
        return (1..<self+1).reduce(1, combine: *)
    }
}

फिर आप संपत्ति को उसी तरह एक्सेस कर सकते हैं जैसे कि इसे मूल Int API में शामिल किया गया था।

let val1: Int = 10

val1.factorial  // returns 3628800

प्रोटोकॉल एक्सटेंशन

स्विफ्ट 2.2 की एक बहुत ही उपयोगी विशेषता प्रोटोकॉल को विस्तारित करने की क्षमता है।

यह काफी हद तक अमूर्त कक्षाओं की तरह काम करता है जब आप एक कार्यक्षमता के बारे में चाहते हैं जो सभी वर्गों में उपलब्ध है जो कुछ प्रोटोकॉल को लागू करता है (एक आधार सामान्य वर्ग से विरासत के बिना)।

protocol FooProtocol {
    func doSomething()
}

extension FooProtocol {
    func doSomething() {
        print("Hi")
    }
}

class Foo: FooProtocol {
    func myMethod() {
        doSomething() // By just implementing the protocol this method is available
    }
}

यह जेनरिक का उपयोग करके भी संभव है।

प्रतिबंध

एक सामान्य प्रकार पर एक विधि लिखना संभव है जो जहां वाक्य का उपयोग करके अधिक प्रतिबंधक है।

extension Array where Element: StringLiteralConvertible {
  func toUpperCase() -> [String] {
      var result = [String]()
      for value in self {
          result.append(String(value).uppercaseString)
      }
      return result
    }        
}

उपयोग का उदाहरण

let array = ["a","b","c"]
let resultado = array.toUpperCase()

एक्सटेंशन क्या हैं और उनका उपयोग कब करना है

एक्सटेंशन किसी मौजूदा वर्ग, संरचना, गणना या प्रोटोकॉल प्रकार में नई कार्यक्षमता जोड़ते हैं। इसमें उन प्रकारों को विस्तारित करने की क्षमता शामिल है जिनके लिए आपके पास मूल स्रोत कोड तक पहुंच नहीं है।

स्विफ्ट में एक्सटेंशन कर सकते हैं:

• संगणित गुण और संगणित प्रकार गुण जोड़ें
• उदाहरण विधियों और प्रकार विधियों को परिभाषित करें
• नए इनिशियलाइज़र प्रदान करें
• सदस्यता को परिभाषित करें
• नए नेस्टेड प्रकारों को परिभाषित और उपयोग करें
• किसी प्रोटोकॉल के अनुसार एक मौजूदा प्रकार बनाएं

स्विफ्ट एक्सटेंशन का उपयोग कब करें:

• स्विफ्ट के लिए अतिरिक्त कार्यक्षमता
• UIKit / फाउंडेशन के लिए अतिरिक्त कार्यक्षमता
• अन्य व्यक्तियों के कोड के साथ खिलवाड़ किए बिना अतिरिक्त कार्यक्षमता
• ब्रेकडाउन क्लासेस इन: डेटा / फ़ंक्शनलिटी / डेलिगेट

जब उपयोग न करें:

• अपनी खुद की कक्षाओं को दूसरी फ़ाइल से बढ़ाएँ

सरल उदाहरण:

extension Bool {
    public mutating func toggle() -> Bool {
        self = !self
        return self
    }
}

var myBool: Bool = true
print(myBool.toggle()) // false

स्रोत

सबस्क्रिप्ट

एक्सटेंशन मौजूदा प्रकार में नए सब्सक्रिप्शन जोड़ सकते हैं।

इस उदाहरण को दिए गए इंडेक्स का उपयोग करते हुए स्ट्रिंग के अंदर का चरित्र मिलता है:

extension String {
    subscript(index: Int) -> Character {
        let newIndex = startIndex.advancedBy(index)
        return self[newIndex]
    }
}

var myString = "StackOverFlow"
print(myString[2]) // a
print(myString[3]) // c

extension String {
    subscript(offset: Int) -> Character {
        let newIndex = self.index(self.startIndex, offsetBy: offset)
        return self[newIndex]
    }
}

var myString = "StackOverFlow"
print(myString[2]) // a
print(myString[3]) // c