Forklar protocol-oriented programming med protocols og extensions.

Question

IT Interview Practice · Accepted Answer

**Protocol-oriented programming (POP)** er Swifts foretrukne måde at dele adfærd på: i stedet for at nedarve fra en baseklasse **overholder** typer **protocols**, og **protocol extensions** leverer genanvendelige standard-implementeringer. Dette giver dig komposition og kodegenbrug uden stivheden ved enkelt-nedarvning.

## Sådan fungerer det

En protocol erklærer krav; en extension på den protocol leverer standardadfærd, som enhver conformer arver gratis.

```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 kontra class inheritance

- **Structs og enums kan conforme** — POP virker på value types, hvilket class inheritance ikke kan.
- **Multipel conformance**: en type kan adoptere mange protocols; en class har én superclass.
- **Constrained extensions** tilføjer kun adfærd, hvor det giver mening:

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

## Faldgruber

- **Static kontra dynamic dispatch:** en metode defineret *kun* i extensionen (ikke i protocolen) dispatches statisk efter variablens erklærede type — så at overskrive den i en conformer bliver måske ikke kaldt gennem en protocol-typed reference. Erklær den i protocolen for at få dynamic dispatch.

## Hvorfor det betyder noget

POP er rygraden i Swifts standardbibliotek (`Equatable`, `Collection`, `Codable`) og i testbar arkitektur — du afhænger af protocols og udskifter conformers med mocks. Interviewere undersøger dette for at se, om du komponerer adfærd med protocols i stedet for at bygge dybe, skrøbelige class-hierarkier.

Sådan fungerer det

Protocol extensions kontra class inheritance

Faldgruber

Hvorfor det betyder noget

Relaterede spørgsmål