स्विफ्ट - जेनेरिक

स्विफ्ट 4 भाषा लचीली और पुन: उपयोग योग्य कार्यों और प्रकारों को लिखने के लिए 'जेनेरिक' सुविधाएँ प्रदान करती है। नकल से बचने और अमूर्तता प्रदान करने के लिए जेनरिक का उपयोग किया जाता है। स्विफ्ट 4 मानक पुस्तकालय जेनरिक कोड के साथ बनाए गए हैं। Swift 4s 'Arrays' और 'Dictionary' प्रकार सामान्य संग्रह से संबंधित हैं। सरणियों और शब्दकोशों की सहायता से सरणियों को 'इंट' मान और 'स्ट्रिंग' मान या किसी अन्य प्रकार के धारण करने के लिए परिभाषित किया जाता है।

func exchange(a: inout Int, b: inout Int) {
   let temp = a
   a = b
   b = temp
}

var numb1 = 100
var numb2 = 200

print("Before Swapping values are: \(numb1) and \(numb2)")
exchange(a: &numb1, b: &numb2)
print("After Swapping values are: \(numb1) and \(numb2)")

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

Before Swapping values are: 100 and 200
After Swapping values are: 200 and 100

सामान्य कार्य: प्रकार पैरामीटर

जेनेरिक फ़ंक्शंस का उपयोग किसी भी डेटा प्रकार जैसे 'इंट' या 'स्ट्रिंग' तक पहुंचने के लिए किया जा सकता है।

func exchange<T>(a: inout T, b: inout T) {
   let temp = a
   a = b
   b = temp
}
var numb1 = 100
var numb2 = 200

print("Before Swapping Int values are: \(numb1) and \(numb2)")
exchange(a: &numb1, b: &numb2)
print("After Swapping Int values are: \(numb1) and \(numb2)")

var str1 = "Generics"
var str2 = "Functions"

print("Before Swapping String values are: \(str1) and \(str2)")
exchange(a: &str1, b: &str2)
print("After Swapping String values are: \(str1) and \(str2)")

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

Before Swapping Int values are: 100 and 200
After Swapping Int values are: 200 and 100
Before Swapping String values are: Generics and Functions
After Swapping String values are: Functions and Generics

फ़ंक्शन एक्सचेंज () का उपयोग उन मूल्यों को स्वैप करने के लिए किया जाता है जो उपरोक्त कार्यक्रम में वर्णित हैं और <T> का उपयोग एक प्रकार के पैरामीटर के रूप में किया जाता है। पहली बार, फ़ंक्शन एक्सचेंज () को 'इंट' वैल्यू वापस करने के लिए कहा जाता है और फ़ंक्शन एक्सचेंज को दूसरा कॉल () स्ट्रींग 'वैल्यू' लौटाएगा। अल्पविराम द्वारा अलग किए गए कोण कोष्ठक के अंदर कई पैरामीटर प्रकार शामिल किए जा सकते हैं।

प्रकार पैरामीटर को उस प्रकार के पैरामीटर के उद्देश्य को जानने के लिए परिभाषित उपयोगकर्ता के रूप में नामित किया जाता है। स्विफ्ट 4 सामान्य प्रकार के पैरामीटर नाम के रूप में <T> प्रदान करता है। हालाँकि, Arrays और D शब्दकोशों जैसे प्रकार के मापदंडों को भी कुंजी के रूप में नामित किया जा सकता है, यह पहचानने के लिए कि वे 'Dictionary' टाइप के हैं।

struct TOS<T> {
   var items = [T]()
   mutating func push(item: T) {
      items.append(item)
   }
   mutating func pop() -> T {
      return items.removeLast()
   }
}

var tos = TOS<String>()
tos.push(item: "Swift 4")
print(tos.items)

tos.push(item: "Generics")
print(tos.items)

tos.push(item: "Type Parameters")
print(tos.items)

tos.push(item: "Naming Type Parameters")
print(tos.items)

let deletetos = tos.pop()

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

[Swift 4]
[Swift 4, Generics]
[Swift 4, Generics, Type Parameters]
[Swift 4, Generics, Type Parameters, Naming Type Parameters]

एक सामान्य प्रकार का विस्तार

आइटम के शीर्ष को जानने के लिए स्टैक गुण का विस्तार करना 'एक्सटेंशन' कीवर्ड के साथ शामिल है।

struct TOS<T> {
   var items = [T]()
   mutating func push(item: T) {
      items.append(item)
   }
   mutating func pop() -> T {
      return items.removeLast()
   }
}
var tos = TOS<String>()
tos.push(item: "Swift 4")
print(tos.items)

tos.push(item: "Generics")
print(tos.items)

tos.push(item: "Type Parameters")
print(tos.items)

tos.push(item: "Naming Type Parameters")
print(tos.items)

extension TOS {
   var first: T? {
      return items.isEmpty ? nil : items[items.count - 1]
   }
}
if let first = tos.first {
   print("The top item on the stack is \(first).")
}

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

["Swift 4"]
["Swift 4", "Generics"]
["Swift 4", "Generics", "Type Parameters"]
["Swift 4", "Generics", "Type Parameters", "Naming Type Parameters"]
The top item on the stack is Naming Type Parameters.

अड़चनें टाइप करें

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

func exchange<T>(a: inout T, b: inout T) {
   let temp = a
   a = b
   b = temp
}
var numb1 = 100
var numb2 = 200

print("Before Swapping Int values are: \(numb1) and \(numb2)")
exchange(a: &numb1, b: &numb2)
print("After Swapping Int values are: \(numb1) and \(numb2)")

var str1 = "Generics"
var str2 = "Functions"

print("Before Swapping String values are: \(str1) and \(str2)")
exchange(a: &str1, b: &str2)
print("After Swapping String values are: \(str1) and \(str2)")

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

Before Swapping Int values are: 100 and 200
After Swapping Int values are: 200 and 100
Before Swapping String values are: Generics and Functions
After Swapping String values are: Functions and Generics

संबद्ध प्रकार

स्विफ्ट 4 संबंधित प्रकारों को 'संबद्धता' कीवर्ड द्वारा प्रोटोकॉल परिभाषा के अंदर घोषित करने की अनुमति देता है।

protocol Container {
   associatedtype ItemType
   mutating func append(item: ItemType)
   var count: Int { get }
   subscript(i: Int) -> ItemType { get }
}
struct TOS<T>: Container {
   // original Stack<T> implementation
   var items = [T]()
   mutating func push(item: T) {
      items.append(item)
   }
   mutating func pop() -> T {
      return items.removeLast()
   }
   
   // conformance to the Container protocol
   mutating func append(item: T) {
      self.push(item: item)
   }
   var count: Int {
      return items.count
   }
   subscript(i: Int) -> T {
      return items[i]
   }
}
var tos = TOS<String>()
tos.push(item: "Swift 4")
print(tos.items)

tos.push(item: "Generics")
print(tos.items)

tos.push(item: "Type Parameters")
print(tos.items)

tos.push(item: "Naming Type Parameters")
print(tos.items)

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

[Swift 4]
[Swift 4, Generics]
[Swift 4, Generics, Type Parameters]
[Swift 4, Generics, Type Parameters, Naming Type Parameters]

जहां क्लाज हैं

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

protocol Container {
   associatedtype ItemType
   mutating func append(item: ItemType)
   var count: Int { get }
   subscript(i: Int) -> ItemType { get }
}
struct Stack<T>: Container {
   // original Stack<T> implementation
   var items = [T]()
   mutating func push(item: T) {
      items.append(item)
   }
   mutating func pop() -> T {
      return items.removeLast()
   }

   // conformance to the Container protocol
   mutating func append(item: T) {
      self.push(item: item)
   }
   var count: Int {
      return items.count
   }
   subscript(i: Int) -> T {
      return items[i]
   }
}
func allItemsMatch<
C1: Container, C2: Container
where C1.ItemType == C2.ItemType, C1.ItemType: Equatable>
(someContainer: C1, anotherContainer: C2) -> Bool {
   // check that both containers contain the same number of items
   if someContainer.count != anotherContainer.count {
      return false
   }
   
   // check each pair of items to see if they are equivalent
   for i in 0..<someContainer.count {
      if someContainer[i] != anotherContainer[i] {
         return false
      }
   }
   // all items match, so return true
   return true
}  
var tos = Stack<String>()

tos.push(item: "Swift 4")
print(tos.items)

tos.push(item: "Generics")
print(tos.items)

tos.push(item: "Where Clause")
print(tos.items)

var eos = ["Swift 4", "Generics", "Where Clause"]
print(eos)

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

[Swift 4]
[Swift 4, Generics]
[Swift 4, Generics, Where Clause]
[Swift 4, Generics, Where Clause]