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 లు** reusable default implementation లను సరఫరా చేస్తాయి. ఇది single inheritance యొక్క దృఢత్వం లేకుండా మీకు composition మరియు code reuse ను ఇస్తుంది.

## ఇది ఎలా పనిచేస్తుంది

ఒక protocol requirement లను declare చేస్తుంది; ఆ protocol పై ఒక extension ఏ conformer అయినా ఉచితంగా inherit చేసే default behavior ను అందిస్తుంది.

```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 లను adopt చేయగలదు; ఒక 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 ద్వారా static గా dispatch అవుతుంది — కాబట్టి conformer లో దాన్ని override చేయడం protocol-typed reference ద్వారా call కాకపోవచ్చు. Dynamic dispatch పొందడానికి దాన్ని protocol లో declare చేయండి.

## ఇది ఎందుకు ముఖ్యం

POP అనేది Swift standard library (`Equatable`, `Collection`, `Codable`) కు మరియు testable architecture కు వెన్నెముక — మీరు protocol లపై ఆధారపడతారు మరియు mock ల కోసం conformer లను swap చేస్తారు. మీరు లోతైన, పెళుసైన class hierarchy లను నిర్మించడానికి బదులుగా protocol లతో behavior ను compose చేస్తారా అని చూడటానికి interviewer లు దీన్ని probe చేస్తారు.

ఇది ఎలా పనిచేస్తుంది

Protocol extension లు vs class inheritance

లోపాలు

ఇది ఎందుకు ముఖ్యం

సంబంధిత ప్రశ్నలు