protocol અને extension સાથે protocol-oriented programming સમજાવો.

Question

IT Interview Practice · Accepted Answer

**Protocol-oriented programming (POP)** એ behavior share કરવાની Swift ની પસંદગીની રીત છે: base class થી inherit કરવાને બદલે, type **protocol ને conform** કરે છે, અને **protocol extension** ફરીથી વાપરી શકાય તેવા default implementation પૂરા પાડે છે. આ તમને single inheritance ની કઠોરતા વગર composition અને code reuse આપે છે.

## તે કેવી રીતે કામ કરે છે

Protocol requirement declare કરે છે; તે protocol પરનું extension default behavior પૂરું પાડે છે જે કોઈપણ conformer મફતમાં inherit કરે છે.

```swift
protocol Identifiable {
    var id: String { get }          // requirement
}

protocol Describable {
    var name: String { get }
}

// Default implementation shared by ALL conformers
extension Describable {
    func describe() -> String { "Item: \(name)" }
}

struct Product: Identifiable, Describable {   // composes multiple protocols
    let id: String
    let name: String
}

Product(id: "1", name: "Book").describe()     // => "Item: Book" (free)
```

## Protocol extension vs class inheritance

- **Struct અને enum conform કરી શકે** — POP value type પર કામ કરે છે, class inheritance નહીં.
- **Multiple conformance**: એક type ઘણા protocol અપનાવી શકે; class ને એક જ superclass હોય.
- **Constrained extension** behavior માત્ર ત્યાં ઉમેરે છે જ્યાં તે અર્થપૂર્ણ હોય:

```swift
extension Collection where Element: Numeric {
    func total() -> Element { reduce(0, +) }   // only for numeric collections
}
[1, 2, 3].total()   // => 6
```

## મુશ્કેલીઓ

- **Static vs dynamic dispatch:** માત્ર extension માં (protocol માં નહીં) વ્યાખ્યાયિત method variable ના declared type દ્વારા statically dispatch થાય છે — તેથી conformer માં તેને override કરવાથી protocol-typed reference દ્વારા તે કદાચ call ન થાય. Dynamic dispatch મેળવવા તેને protocol માં declare કરો.

## આ શા માટે મહત્વનું છે

POP એ Swift standard library (`Equatable`, `Collection`, `Codable`) અને testable architecture નો કરોડરજ્જુ છે — તમે protocol પર આધાર રાખો છો અને conformer ને mock થી બદલો છો. Interviewer આ ચકાસે છે કે તમે ઊંડા, બરડ class hierarchy બનાવવાને બદલે protocol સાથે behavior compose કરો છો કે નહીં.

તે કેવી રીતે કામ કરે છે

Protocol extension vs class inheritance

મુશ્કેલીઓ

આ શા માટે મહત્વનું છે

સંબંધિત પ્રશ્નો