protocols ਅਤੇ extensions ਨਾਲ protocol-oriented programming ਬਾਰੇ ਦੱਸੋ।

Question

IT Interview Practice · Accepted Answer

**Protocol-oriented programming (POP)** behavior share ਕਰਨ ਦਾ Swift ਦਾ ਤਰਜੀਹੀ ਤਰੀਕਾ ਹੈ: ਕਿਸੇ base class ਤੋਂ inherit ਕਰਨ ਦੀ ਬਜਾਏ, types **protocols ਦੀ ਪਾਲਣਾ ਕਰਦੇ ਹਨ**, ਅਤੇ **protocol extensions** ਦੁਬਾਰਾ-ਵਰਤੋਂਯੋਗ default implementations ਦਿੰਦੇ ਹਨ। ਇਹ ਤੁਹਾਨੂੰ single inheritance ਦੀ ਸਖ਼ਤੀ ਤੋਂ ਬਿਨਾਂ composition ਅਤੇ code reuse ਦਿੰਦਾ ਹੈ।

## ਇਹ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ

ਇੱਕ protocol requirements 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 extensions ਬਨਾਮ class inheritance

- **Structs ਅਤੇ enums ਪਾਲਣਾ ਕਰ ਸਕਦੇ ਹਨ** — POP value types 'ਤੇ ਕੰਮ ਕਰਦਾ ਹੈ, class inheritance ਨਹੀਂ ਕਰ ਸਕਦੀ।
- **Multiple conformance**: ਇੱਕ type ਬਹੁਤ ਸਾਰੇ protocols ਅਪਣਾ ਸਕਦੀ ਹੈ; ਇੱਕ class ਦਾ ਇੱਕ superclass ਹੁੰਦਾ ਹੈ।
- **Constrained extensions** behavior ਸਿਰਫ਼ ਉੱਥੇ ਜੋੜਦੇ ਹਨ ਜਿੱਥੇ ਇਹ ਢੁਕਵਾਂ ਹੋਵੇ:

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

## ਧਿਆਨ ਰੱਖਣ ਯੋਗ ਗੱਲਾਂ

- **Static ਬਨਾਮ dynamic dispatch:** ਇੱਕ method ਜੋ *ਸਿਰਫ਼* extension ਵਿੱਚ define ਕੀਤਾ ਗਿਆ ਹੈ (protocol ਵਿੱਚ ਨਹੀਂ) ਉਹ variable ਦੀ declared type ਦੁਆਰਾ statically dispatch ਹੁੰਦਾ ਹੈ — ਇਸ ਲਈ ਕਿਸੇ conformer ਵਿੱਚ ਇਸਨੂੰ override ਕਰਨ 'ਤੇ ਇਹ ਸ਼ਾਇਦ protocol-typed reference ਰਾਹੀਂ call ਨਾ ਹੋਵੇ। dynamic dispatch ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਇਸਨੂੰ protocol ਵਿੱਚ declare ਕਰੋ।

## ਇਹ ਮਹੱਤਵਪੂਰਨ ਕਿਉਂ ਹੈ

POP Swift ਦੀ standard library (`Equatable`, `Collection`, `Codable`) ਅਤੇ testable architecture ਦੀ ਰੀੜ੍ਹ ਦੀ ਹੱਡੀ ਹੈ — ਤੁਸੀਂ protocols 'ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹੋ ਅਤੇ conformers ਨੂੰ mocks ਨਾਲ ਬਦਲਦੇ ਹੋ। Interviewers ਇਹ ਜਾਂਚਣ ਲਈ ਇਸਦੀ ਪੜਤਾਲ ਕਰਦੇ ਹਨ ਕਿ ਤੁਸੀਂ ਡੂੰਘੀਆਂ, ਭੁਰਭੁਰੀਆਂ class hierarchies ਬਣਾਉਣ ਦੀ ਬਜਾਏ protocols ਨਾਲ behavior compose ਕਰਦੇ ਹੋ ਜਾਂ ਨਹੀਂ।

ਇਹ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ

Protocol extensions ਬਨਾਮ class inheritance

ਧਿਆਨ ਰੱਖਣ ਯੋਗ ਗੱਲਾਂ

ਇਹ ਮਹੱਤਵਪੂਰਨ ਕਿਉਂ ਹੈ

ਸੰਬੰਧਿਤ ਸਵਾਲ