Leg protocol-oriented programming uit met protocols en extensions.

Question

IT Interview Practice · Accepted Answer

**Protocol-oriented programming (POP)** is Swifts voorkeursmanier om gedrag te delen: in plaats van over te erven van een base class, **voldoen types aan protocols**, en **protocol extensions** leveren herbruikbare standaardimplementaties. Dit geeft je compositie en hergebruik van code zonder de starheid van enkelvoudige overerving.

## Hoe het werkt

Een protocol declareert requirements; een extension op dat protocol levert standaardgedrag dat elke conformer gratis overneemt.

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

protocol Describable {
    var name: String { get }
}

// Standaardimplementatie gedeeld door ALLE conformers
extension Describable {
    func describe() -> String { "Item: \(name)" }
}

struct Product: Identifiable, Describable {   // combineert meerdere protocols
    let id: String
    let name: String
}

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

## Protocol extensions versus class inheritance

- **Structs en enums kunnen conformeren** — POP werkt op value types, class inheritance niet.
- **Meervoudige conformance**: een type kan veel protocols adopteren; een class heeft één superclass.
- **Constrained extensions** voegen gedrag alleen toe waar het zin heeft:

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

## Valkuilen

- **Static versus dynamic dispatch:** een method die *alleen* in de extension is gedefinieerd (niet in het protocol) wordt statisch gedispatcht op basis van het gedeclareerde type van de variabele — dus het overschrijven ervan in een conformer wordt mogelijk niet aangeroepen via een referentie met een protocol-type. Declareer het in het protocol om dynamic dispatch te krijgen.

## Waarom het belangrijk is

POP is de ruggengraat van de Swift-standaardbibliotheek (`Equatable`, `Collection`, `Codable`) en van testbare architectuur — je hangt af van protocols en wisselt conformers in voor mocks. Interviewers peilen dit om te zien of je gedrag samenstelt met protocols in plaats van diepe, brosse class-hiërarchieën te bouwen.

Hoe het werkt

Protocol extensions versus class inheritance

Valkuilen

Waarom het belangrijk is

Gerelateerde vragen