protocol மற்றும் extension-களுடன் protocol-oriented programming-ஐ விளக்குங்கள்.

Question

IT Interview Practice · Accepted Answer

**Protocol-oriented programming (POP)** என்பது behavior-ஐ பகிர்ந்துகொள்ள Swift விரும்பும் வழி: ஒரு base class-லிருந்து inherit செய்வதற்குப் பதிலாக, type-கள் **protocol-களை conform செய்கின்றன**, மேலும் **protocol extension-கள்** மறுபயன்பாட்டு 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-இன் declare செய்யப்பட்ட type-ஆல் static-ஆக dispatch செய்யப்படுகிறது — எனவே ஒரு conformer-இல் அதை override செய்வது ஒரு protocol-typed reference மூலம் அழைக்கப்படாமல் போகலாம். dynamic dispatch-ஐப் பெற அதை protocol-இல் declare செய்யுங்கள்.

## இது ஏன் முக்கியம்

POP என்பது Swift standard library-இன் (`Equatable`, `Collection`, `Codable`) மற்றும் testable architecture-இன் முதுகெலும்பு — நீங்கள் protocol-களை சார்ந்து mock-களுக்காக conformer-களை swap செய்கிறீர்கள். ஆழமான, உடையக்கூடிய class hierarchy-களை உருவாக்குவதற்குப் பதிலாக நீங்கள் protocol-களுடன் behavior-ஐ compose செய்கிறீர்களா என்பதைப் பார்க்க interviewer-கள் இதை ஆராய்கிறார்கள்.

இது எப்படி வேலை செய்கிறது

Protocol extension vs class inheritance

சிக்கல்கள்

இது ஏன் முக்கியம்

தொடர்புடைய கேள்விகள்