स्विफ्ट - एक्सटेंशन

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

Swift Extension Functionalities -

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

एक्सटेंशन 'कीवर्ड' एक्सटेंशन के साथ घोषित किए जाते हैं

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

extension SomeType {
   // new functionality can be added here
}

मौजूदा प्रकार को एक्सटेंशन के साथ जोड़ा जा सकता है ताकि इसे एक प्रोटोकॉल मानक के रूप में बनाया जा सके और इसका सिंटैक्स कक्षाओं या संरचनाओं के समान हो।

extension SomeType: SomeProtocol, AnotherProtocol {
   // protocol requirements is described here
}

संगणित गुण

एक्सटेंडेड 'उदाहरण' और 'टाइप' प्रॉपर्टीज को एक्सटेंशन की मदद से भी बढ़ाया जा सकता है।

extension Int {
   var add: Int {return self + 100 }
   var sub: Int { return self - 10 }
   var mul: Int { return self * 10 }
   var div: Int { return self / 5 }
}

let addition = 3.add
print("Addition is \(addition)")

let subtraction = 120.sub
print("Subtraction is \(subtraction)")

let multiplication = 39.mul
print("Multiplication is \(multiplication)")

let division = 55.div
print("Division is \(division)")

let mix = 30.add + 34.sub
print("Mixed Type is \(mix)")

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

Addition is 103
Subtraction is 110
Multiplication is 390
Division is 11
Mixed Type is 154

initializers

स्विफ्ट 4 एक्सटेंशन द्वारा मौजूदा प्रकार के नए इनिशियलाइज़र को जोड़ने के लिए लचीलापन प्रदान करता है। उपयोगकर्ता पहले से परिभाषित प्रकारों का विस्तार करने के लिए अपने स्वयं के कस्टम प्रकार जोड़ सकते हैं और अतिरिक्त आरंभीकरण विकल्प भी संभव हैं। एक्सटेंशन केवल init () का समर्थन करता है। डिनिट () एक्सटेंशन द्वारा समर्थित नहीं है।

struct sum {
   var num1 = 100, num2 = 200
}

struct diff {
   var no1 = 200, no2 = 100
}

struct mult {
   var a = sum()
   var b = diff()
}

let calc = mult()
print ("Inside mult block \(calc.a.num1, calc.a.num2)")
print("Inside mult block \(calc.b.no1, calc.b.no2)")

let memcalc = mult(a: sum(num1: 300, num2: 500),b: diff(no1: 300, no2: 100))
print("Inside mult block \(memcalc.a.num1, memcalc.a.num2)")
print("Inside mult block \(memcalc.b.no1, memcalc.b.no2)")

extension mult {
   init(x: sum, y: diff) {
      let X = x.num1 + x.num2
      let Y = y.no1 + y.no2
   }
}

let a = sum(num1: 100, num2: 200)
print("Inside Sum Block:\( a.num1, a.num2)")

let b = diff(no1: 200, no2: 100)
print("Inside Diff Block: \(b.no1, b.no2)")

Inside mult block (100, 200)
Inside mult block (200, 100)
Inside mult block (300, 500)
Inside mult block (300, 100)
Inside Sum Block:(100, 200)
Inside Diff Block: (200, 100)

तरीकों

नए उदाहरण के तरीके और प्रकार के तरीकों को एक्सटेंशन की मदद से उपवर्ग में और जोड़ा जा सकता है।

extension Int {
   func topics(summation: () -> ()) {
      for _ in 0..<self {
         summation()
      }
   }
}

4.topics(summation: {
   print("Inside Extensions Block")
})

3.topics(summation: {
   print("Inside Type Casting Block")
})

Inside Extensions Block
Inside Extensions Block
Inside Extensions Block
Inside Extensions Block
Inside Type Casting Block
Inside Type Casting Block
Inside Type Casting Block

विषय () फ़ंक्शन प्रकार का तर्क लेता है '(सारांश: () → ()) फ़ंक्शन को इंगित करने के लिए कोई तर्क नहीं लेता है और यह किसी भी मान को वापस नहीं करेगा। उस फ़ंक्शन को कई बार कॉल करने के लिए, ब्लॉक के लिए आरंभीकृत किया जाता है और विषय () के साथ विधि पर कॉल किया जाता है।

उत्परिवर्तन के तरीके

एक्सटेंशन के रूप में घोषित किए जाने पर इंस्टेंस के तरीकों को भी म्यूट किया जा सकता है।

संरचना और एन्यूमरेशन विधियाँ जो स्वयं या उसके गुणों को संशोधित करती हैं, उन्हें मूल पद्धति से उत्परिवर्तन विधियों की तरह, उत्परिवर्तन के रूप में उदाहरण विधि को चिह्नित करना चाहिए।

extension Double {
   mutating func square() {
      let pi = 3.1415
      self = pi * self * self
   }
}

var Trial1 = 3.3
Trial1.square()
print("Area of circle is: \(Trial1)")

var Trial2 = 5.8
Trial2.square()
print("Area of circle is: \(Trial2)")

var Trial3 = 120.3
Trial3.square()
print("Area of circle is: \(Trial3)")

Area of circle is: 34.210935
Area of circle is: 105.68006
Area of circle is: 45464.070735

सबस्क्रिप्ट

एक्सटेंशन के साथ पहले से घोषित उदाहरणों के लिए नई सदस्यता जोड़ना भी संभव हो सकता है।

extension Int {
   subscript(var multtable: Int) -> Int {
      var no1 = 1
      while multtable > 0 {
         no1 *= 10
         --multtable
      }
      return (self / no1) % 10
   }
}

print(12[0])
print(7869[1])
print(786543[2])

2
6
5

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

क्लास, संरचना और गणना उदाहरणों के लिए नस्टेड प्रकारों को एक्सटेंशन की मदद से भी बढ़ाया जा सकता है।

extension Int {
   enum calc {
      case add
      case sub
      case mult
      case div
      case anything
   }
   var print: calc {
      switch self {
         case 0:
            return .add
         case 1:
            return .sub
         case 2:
            return .mult
         case 3:
            return .div
         default:
            return .anything
      }
   }
}

func result(numb: [Int]) {
   for i in numb {
      switch i.print {
         case .add:
            print(" 10 ")
         case .sub:
            print(" 20 ")
         case .mult:
            print(" 30 ")
         case .div:
            print(" 40 ")
         default:
            print(" 50 ")
      }
   }
}
result(numb: [0, 1, 2, 3, 4, 7])