प्रोटोकॉल ओरिएंटेड प्रोग्रामिंग स्विफ्ट 5.1 में

• ऑब्जेक्ट-ओरिएंटेड और प्रोटोकॉल-ओरिएंटेड प्रोग्रामिंग के बीच अंतर को समझना;
• मानक प्रोटोकॉल कार्यान्वयन को समझें;
• मानक स्विफ्ट लाइब्रेरी की कार्यक्षमता का विस्तार करना सीखें;
• जेनरिक के साथ प्रोटोकॉल का विस्तार करना सीखें।

शुरू करना

प्रोटोकॉल उन्मुख प्रोग्रामिंग क्या है?

कोड करते हैं

protocol Bird {
  var name: String { get }
  var canFly: Bool { get }
}

protocol Flyable {
  var airspeedVelocity: Double { get }
}

प्रोटोकॉल के अनुरूप प्रकार निर्धारित करें

struct FlappyBird: Bird, Flyable {
  let name: String
  let flappyAmplitude: Double
  let flappyFrequency: Double
  let canFly = true

  var airspeedVelocity: Double {
    3 * flappyFrequency * flappyAmplitude
  }
}

struct Penguin: Bird {
  let name: String
  let canFly = false
}

struct SwiftBird: Bird, Flyable {
  var name: String { "Swift \(version)" }
  let canFly = true
  let version: Double
  private var speedFactor = 1000.0
  
  init(version: Double) {
    self.version = version
  }

  // Swift is FASTER with each version!
  var airspeedVelocity: Double {
    version * speedFactor
  }
}

डिफ़ॉल्ट व्यवहार के साथ प्रोटोकॉल का विस्तार

extension Bird {
  // Flyable birds can fly!
  var canFly: Bool { self is Flyable }
}

तबादलों को करते हैं

enum UnladenSwallow: Bird, Flyable {
  case african
  case european
  case unknown
  
  var name: String {
    switch self {
    case .african:
      return "African"
    case .european:
      return "European"
    case .unknown:
      return "What do you mean? African or European?"
    }
  }
  
  var airspeedVelocity: Double {
    switch self {
    case .african:
      return 10.0
    case .european:
      return 9.9
    case .unknown:
      fatalError("You are thrown from the bridge of death!")
    }
  }
}

डिफ़ॉल्ट व्यवहार को ओवरराइड करना

extension UnladenSwallow {
  var canFly: Bool {
    self != .unknown
  }
}

UnladenSwallow.unknown.canFly         // false
UnladenSwallow.african.canFly         // true
Penguin(name: "King Penguin").canFly  // false

प्रोटोकॉल का विस्तार

protocol Bird: CustomStringConvertible {
  var name: String { get }
  var canFly: Bool { get }
}

extension CustomStringConvertible where Self: Bird {
  var description: String {
    canFly ? "I can fly" : "Guess I'll just sit here :["
  }
}

स्विफ्ट मानक पुस्तकालयों में प्रोटोकॉल

let numbers = [10, 20, 30, 40, 50, 60]
let slice = numbers[1...3]
let reversedSlice = slice.reversed()

let answer = reversedSlice.map { $0 * 10 }
print(answer)

तुम्हारे प्राप्तांक पर

class Motorcycle {
  init(name: String) {
    self.name = name
    speed = 200.0
  }

  var name: String
  var speed: Double
}

यह सब एक साथ डालें

// 1
protocol Racer {
  var speed: Double { get }  // speed is the only thing racers care about
}

// 2
extension FlappyBird: Racer {
  var speed: Double {
    airspeedVelocity
  }
}

extension SwiftBird: Racer {
  var speed: Double {
    airspeedVelocity
  }
}

extension Penguin: Racer {
  var speed: Double {
    42  // full waddle speed
  }
}

extension UnladenSwallow: Racer {
  var speed: Double {
    canFly ? airspeedVelocity : 0.0
  }
}

extension Motorcycle: Racer {}

// 3
let racers: [Racer] =
  [UnladenSwallow.african,
   UnladenSwallow.european,
   UnladenSwallow.unknown,
   Penguin(name: "King Penguin"),
   SwiftBird(version: 5.1),
   FlappyBird(name: "Felipe", flappyAmplitude: 3.0, flappyFrequency: 20.0),
   Motorcycle(name: "Giacomo")]

उच्चतम गति

func topSpeed(of racers: [Racer]) -> Double {
  racers.max(by: { $0.speed < $1.speed })?.speed ?? 0.0
}

topSpeed(of: racers) // 5100

फ़ंक्शन को अधिक सामान्य बनाना

// 1
func topSpeed<RacersType: Sequence>(of racers: RacersType) -> Double
    /*2*/ where RacersType.Iterator.Element == Racer {
  // 3
  racers.max(by: { $0.speed < $1.speed })?.speed ?? 0.0
}

1. RacersType हमारे फ़ंक्शन का सामान्य तर्क प्रकार है। यह कुछ भी हो सकता है जो अनुक्रम प्रोटोकॉल के अनुरूप है।
2. जहां निर्धारित करता है कि अनुक्रम सामग्री को रेसर प्रोटोकॉल का पालन करना चाहिए।
3. फ़ंक्शन का शरीर स्वयं अपरिवर्तित रहता है।

topSpeed(of: racers[1...3]) // 42

समारोह को और अधिक "तेज" बनाना

extension Sequence where Iterator.Element == Racer {
  func topSpeed() -> Double {
    self.max(by: { $0.speed < $1.speed })?.speed ?? 0.0
  }
}

racers.topSpeed()        // 5100
racers[1...3].topSpeed() // 42

प्रोटोकॉल तुलनाकर्ता

protocol Score {
  var value: Int { get }
}

struct RacingScore: Score {
  let value: Int
}

protocol Score: Comparable {
  var value: Int { get }
}

struct RacingScore: Score {
  let value: Int
  
  static func <(lhs: RacingScore, rhs: RacingScore) -> Bool {
    lhs.value < rhs.value
  }
}

RacingScore(value: 150) >= RacingScore(value: 130) // true

वस्तु में परिवर्तन करना

protocol Cheat {
  mutating func boost(_ power: Double)
}

extension SwiftBird: Cheat {
  mutating func boost(_ power: Double) {
    speedFactor += power
  }
}

var swiftBird = SwiftBird(version: 5.0)
swiftBird.boost(3.0)
swiftBird.airspeedVelocity // 5015
swiftBird.boost(3.0)
swiftBird.airspeedVelocity // 5030

निष्कर्ष