Explică programarea orientată pe protocoale (protocol-oriented programming) cu protocoale și extensii.

Question

IT Interview Practice · Accepted Answer

**Programarea orientată pe protocoale (POP)** este modul preferat al Swift de a partaja comportament: în loc să moștenești dintr-o clasă de bază, tipurile **se conformează protocoalelor**, iar **extensiile de protocol** furnizează implementări implicite reutilizabile. Asta îți oferă compoziție și reutilizare de cod fără rigiditatea moștenirii unice.

## Cum funcționează

Un protocol declară cerințe; o extensie pe acel protocol oferă un comportament implicit pe care orice tip conform îl moștenește gratuit.

```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)
```

## Extensii de protocol vs. moștenire de clasă

- **Structurile și enum-urile se pot conforma** — POP funcționează pe value types, moștenirea de clasă nu poate.
- **Conformare multiplă**: un tip poate adopta multe protocoale; o clasă are o singură superclasă.
- **Extensii cu constrângeri** adaugă comportament doar acolo unde are sens:

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

## Capcane

- **Dispatch static vs. dinamic:** o metodă definită *doar* în extensie (nu și în protocol) este dispatch-uită static, după tipul declarat al variabilei — așa că suprascrierea ei într-un tip conform s-ar putea să nu fie apelată printr-o referință de tip protocol. Declar-o în protocol ca să obții dispatch dinamic.

## De ce contează

POP este coloana vertebrală a bibliotecii standard Swift (`Equatable`, `Collection`, `Codable`) și a arhitecturii testabile — depinzi de protocoale și înlocuiești tipurile conforme cu mock-uri. Intervievatorii sondează asta ca să vadă dacă compui comportament cu protocoale în loc să construiești ierarhii de clase adânci și fragile.

Cum funcționează

Extensii de protocol vs. moștenire de clasă

Capcane

De ce contează

Întrebări conexe