स्विफ्ट - प्रोटोकॉल

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

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

प्रोटोकॉल भी वर्गों, संरचनाओं और गणना के समान सिंटैक्स का पालन करते हैं -

protocol SomeProtocol {
   // protocol definition 
}

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

struct SomeStructure: Protocol1, Protocol2 {
   // structure definition 
}

जब किसी प्रोटोकॉल को सुपर क्लास के लिए परिभाषित किया जाना है, तो प्रोटोकॉल नाम सुपर क्लास के नाम को अल्पविराम के साथ पालन करना चाहिए।

class SomeClass: SomeSuperclass, Protocol1, Protocol2 {
   // class definition 
}

संपत्ति और विधि आवश्यकताएँ

प्रोटोकॉल का उपयोग विशेष वर्ग प्रकार की संपत्ति या उदाहरण संपत्ति को निर्दिष्ट करने के लिए किया जाता है। यह निर्दिष्ट या संकलित संपत्ति के बजाय अकेले प्रकार या उदाहरण संपत्ति निर्दिष्ट करता है। इसके अलावा, यह निर्दिष्ट करने के लिए उपयोग किया जाता है कि संपत्ति 'गेटेबल' है या 'सेटलेबल' है।

संपत्ति आवश्यकताओं को 'चर' कीवर्ड द्वारा संपत्ति चर के रूप में घोषित किया जाता है। {get set} का उपयोग उनके प्रकार की घोषणा के बाद गेटेबल और सेटल होने योग्य गुणों की घोषणा करने के लिए किया जाता है। गेटटेबल का उल्लेख उनके प्रकार की घोषणा के बाद {get} संपत्ति द्वारा किया जाता है।

protocol classa {
   var marks: Int { get set }
   var result: Bool { get }
   
   func attendance() -> String
   func markssecured() -> String
}

protocol classb: classa {
   var present: Bool { get set }
   var subject: String { get set }
   var stname: String { get set }
}

class classc: classb {
   var marks = 96
   let result = true
   var present = false
   var subject = "Swift 4 Protocols"
   var stname = "Protocols"

   func attendance() -> String {
      return "The \(stname) has secured 99% attendance"
   }
   func markssecured() -> String {
      return "\(stname) has scored \(marks)"
   }
}

let studdet = classc()
studdet.stname = "Swift 4"
studdet.marks = 98
studdet.markssecured()

print(studdet.marks)
print(studdet.result)
print(studdet.present)
print(studdet.subject)
print(studdet.stname)

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

98
true
false
Swift 4 Protocols
Swift 4

म्यूटिंग मेथड रिक्वायरमेंट्स

protocol daysofaweek {
   mutating func print()
}

enum days: daysofaweek {
   case sun, mon, tue, wed, thurs, fri, sat 
   mutating func print() {
      switch self {
         case sun:
            self = sun
            print("Sunday")
         case mon:
            self = mon
            print("Monday")
         case tue:
            self = tue
            print("Tuesday")
         case wed:
            self = wed
            print("Wednesday")
         case mon:
            self = thurs
            print("Thursday")
         case tue:
            self = fri
            print("Friday")
         case sat:
            self = sat
            print("Saturday")
         default:
            print("NO Such Day")
      }
   }
}

var res = days.wed
res.print()

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

Wednesday

प्रारंभिक आवश्यकताएँ

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

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

protocol SomeProtocol {
   init(someParameter: Int)
}

उदाहरण के लिए

protocol tcpprotocol {
   init(aprot: Int)
}

प्रोटोकॉल प्रारंभिक आवश्यकताओं के वर्ग कार्यान्वयन

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

class SomeClass: SomeProtocol {
   required init(someParameter: Int) {
      // initializer implementation statements
   }
}

protocol tcpprotocol {
   init(aprot: Int)
}

class tcpClass: tcpprotocol {
   required init(aprot: Int) {
   }
}

प्रोटोकॉल की पुष्टि 'आवश्यक' संशोधक द्वारा स्पष्ट या विरासत में दिए गए कार्यान्वयन के लिए सभी उपवर्गों पर सुनिश्चित की जाती है।

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

protocol tcpprotocol {
   init(no1: Int)
}

class mainClass {
   var no1: Int        // local storage
   init(no1: Int) {
      self.no1 = no1  // initialization
   }
}

class subClass: mainClass, tcpprotocol {
   var no2: Int
   init(no1: Int, no2 : Int) {
      self.no2 = no2
      super.init(no1:no1)
   }
   // Requires only one parameter for convenient method
   required override convenience init(no1: Int) {
      self.init(no1:no1, no2:0)
   }
}

let res = mainClass(no1: 20)
let print = subClass(no1: 30, no2: 50)

print("res is: \(res.no1)")
print("res is: \(print.no1)")
print("res is: \(print.no2)")

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

res is: 20
res is: 30
res is: 50

प्रकार के रूप में प्रोटोकॉल

एक प्रोटोकॉल में कार्यक्षमताओं को लागू करने के बजाय उनका उपयोग कार्यों, वर्गों, विधियों आदि के लिए किया जाता है।

प्रोटोकॉल को निम्न प्रकार से एक्सेस किया जा सकता है -

• फ़ंक्शन, विधि या पैरामीटर या रिटर्न प्रकार के रूप में आरंभ करें

• लगातार, चर या संपत्ति

• आइटम के रूप में ऐरे, शब्दकोश या अन्य कंटेनर

protocol Generator {
   typealias members
   func next() -> members?
}

var items = [10,20,30].generate()
while let x = items.next() {
   print(x)
}

for lists in map([1,2,3], {i in i*5}) {
   print(lists)
}

print([100,200,300])
print(map([1,2,3], {i in i*10}))

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

10
20
30
5
10
15
[100, 200, 300]
[10, 20, 30]

एक एक्सटेंशन के साथ प्रोटोकॉल अनुरूपता जोड़ना

एक्सटेंशन का उपयोग करके मौजूदा प्रकार को अपनाया जा सकता है और नए प्रोटोकॉल के अनुरूप बनाया जा सकता है। नई संपत्तियों, विधियों और सदस्यता को एक्सटेंशन की मदद से मौजूदा प्रकारों में जोड़ा जा सकता है।

protocol AgeClasificationProtocol {
   var age: Int { get }
   func agetype() -> String
}
class Person {
   let firstname: String
   let lastname: String
   var age: Int
   
   init(firstname: String, lastname: String) {
      self.firstname = firstname
      self.lastname = lastname
      self.age = 10
   }
}

extension Person : AgeClasificationProtocol {
   func fullname() -> String {
      var c: String
      c = firstname + " " + lastname
      return c
   }
   func agetype() -> String {
      switch age {
         case 0...2:
            return "Baby"
         case 2...12:
            return "Child"
         case 13...19:
            return "Teenager"
         case let x where x > 65:
            return "Elderly"
         default:
            return "Normal"
      }
   }
}

प्रोटोकॉल वंशानुक्रम

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

protocol classa {
   var no1: Int { get set }
   func calc(sum: Int)
}
protocol result {
   func print(target: classa)
}
class student2: result {
   func print(target: classa) {
      target.calc(sum: 1)
   }
}
class classb: result {
   func print(target: classa) {
      target.calc(sum: 5)
   }
}

class student: classa {
   var no1: Int = 10
   
   func calc(sum: Int) {
      no1 -= sum
      print("Student attempted \(sum) times to pass")
         
      if no1 <= 0 {
         print("Student is absent for exam")
      }
   }
}

class Player {
   var stmark: result!

   init(stmark: result) {
      self.stmark = stmark
   }
   func print(target: classa) {
      stmark.print(target: target)
   }
}

var marks = Player(stmark: student2())
var marksec = student()

marks.print(target: marksec)
marks.print(target: marksec)
marks.print(target: marksec)
marks.stmark = classb()
marks.print(target: marksec)
marks.print(target: marksec)
marks.print(target: marksec)

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

Student attempted 1 times to pass
Student attempted 1 times to pass
Student attempted 1 times to pass
Student attempted 5 times to pass
Student attempted 5 times to pass
Student is absent for exam
Student attempted 5 times to pass
Student is absent for exam

केवल कक्षा प्रोटोकॉल

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

protocol tcpprotocol {
   init(no1: Int)
}
class mainClass {
   var no1: Int        // local storage
   init(no1: Int) {
      self.no1 = no1  // initialization
   }
}
class subClass: mainClass, tcpprotocol {
   var no2: Int
   init(no1: Int, no2 : Int) {
      self.no2 = no2
      super.init(no1:no1)
   }
   
   // Requires only one parameter for convenient method
   required override convenience init(no1: Int) {
      self.init(no1:no1, no2:0)
   }
}

let res = mainClass(no1: 20)
let print = subClass(no1: 30, no2: 50)

print("res is: \(res.no1)")
print("res is: \(print.no1)")
print("res is: \(print.no2)")

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

res is: 20
res is: 30
res is: 50

प्रोटोकॉल संरचना

स्विफ्ट 4 कई प्रोटोकॉल प्रोटोकॉल संरचना की मदद से एक बार में कॉल करने की अनुमति देता है।

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

protocol<SomeProtocol, AnotherProtocol>

उदाहरण

protocol stname {
   var name: String { get }
}
protocol stage {
   var age: Int { get }
}
struct Person: stname, stage {
   var name: String
   var age: Int
}
func print(celebrator: stname & stage) {
   print("\(celebrator.name) is \(celebrator.age) years old")
}
let studname = Person(name: "Priya", age: 21)
print(studname)

let stud = Person(name: "Rehan", age: 29)
print(stud)

let student = Person(name: "Roshan", age: 19)
print(student)

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

Person(name: "Priya", age: 21)
Person(name: "Rehan", age: 29)
Person(name: "Roshan", age: 19)

प्रोटोकॉल अनुरूपता के लिए जाँच

प्रोटोकॉल अनुरूपता का परीक्षण 'है ’और ance ऑपरेटर’ के रूप में टाइप कास्टिंग के समान होता है।

• यदि ऑपरेटर प्रोटोकॉल मानक के अनुरूप है और विफल होने पर वापस लौटता है तो ऑपरेटर सही है।

• as? डाउनकास्ट ऑपरेटर का संस्करण प्रोटोकॉल के प्रकार का एक वैकल्पिक मान लौटाता है, और यह मान शून्य है यदि उदाहरण उस प्रोटोकॉल के अनुरूप नहीं है।

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

import Foundation

@objc protocol rectangle {
   var area: Double { get }
}
@objc class Circle: rectangle {
   let pi = 3.1415927
   var radius: Double
   var area: Double { return pi * radius * radius }
   init(radius: Double) { self.radius = radius }
}
@objc class result: rectangle {
   var area: Double
   init(area: Double) { self.area = area }
}
class sides {
   var rectsides: Int
   init(rectsides: Int) { self.rectsides = rectsides }
}
let objects: [AnyObject] = [Circle(radius: 2.0),result(area:198),sides(rectsides: 4)]

for object in objects {
   if let objectWithArea = object as? rectangle {
      print("Area is \(objectWithArea.area)")
   } else {
      print("Rectangle area is not defined")
   }
}

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

Area is 12.5663708
Area is 198.0
Rectangle area is not defined