Hva er Singleton-mønsteret?

Question

Accepted Answer

**Singleton**-mønsteret sikrer at en klasse har bare **en instans** og gir et globalt tilgangspunkt til den. Det brukes når nøyaktig ett objekt skal koordinere noe (en konfiguration, en tilkoblingsbuffer, en logger), selv om det også er noe kontroversielt.

## Hva Singleton gjør

```text
SINGLETON → guarantee a class has only ONE instance, with global access to it:
  → the class controls its own instantiation (private constructor)
  → returns the SAME instance every time it's requested
→ for: things there should only be ONE of, accessed from many places
```

## Eksempel

```js
class Config {
  static #instance;
  static getInstance() {
    if (!Config.#instance) {
      Config.#instance = new Config();   // create once
    }
    return Config.#instance;             // always return the same instance
  }
}
// Config.getInstance() always returns the same object
```

## Vanlig bruk og kontroversen

```text
USES → configuration objects, loggers, connection pools, caches (one shared instance)
⚠️ CONTROVERSIAL → Singletons are often criticized:
  → GLOBAL STATE in disguise → hidden dependencies, hard to TEST (can't easily mock/replace),
    tight coupling, issues with concurrency
  → often better: DEPENDENCY INJECTION (pass the single instance in) → same "one instance"
    benefit but testable and explicit
→ use sparingly; consider DI as an alternative; valid for genuinely-single resources
```

## Hvorfor det er viktig

Å forstå Singleton-mønsteret er verdifullt fordi det er ett av de **mest kjente designmønstrene** (hyppig møtt og diskutert), og forståelsen av det — inkludert dens kontroversen — gjenspeiler god designdom.

Singleton sikrer at en klasse har bare en instans med globalt tilgang, brukt når det virkelig bør finnes bare ett av noe (konfiguration, logger, tilkoblingsbuffer, cache) som blir tilgang fra mange steder.

Å forstå hva det gjør (en klasse som kontrollerer sin egen instantiering for å returnere samme instans hver gang) er grunnleggende kunnskap.

Men å forstå **kontroversen** er like viktig og gjenspeiler modendom: Singletons blir bredt kritisert fordi de i hovedsak er **global tilstand i forkledning**, som skaper **skjulte avhengigheter** (kode som bruker en Singleton har en udokumentert avhengighet), gjør kode **vanskelig å teste** (du kan ikke enkelt mocke eller erstatte den enkelte instansen), forårsaker stram kobbling, og medfører concurrency-problemer.

Å forstå at **avhengighetsinjeksjon ofte er et bedre alternativ** (å sende den enkelte instansen inn, og gi samme "en instans"-fordel, men på en testbar, eksplisitt måte) gjenspeiler designdommen å foretrekke DI fremfor Singletons i mange tilfeller.

Denne balanserte forståelsen — å kjenne mønsteret, men også dets problemer og bedre alternativer — er det som skiller gjennomtenkt bruk fra cargo-culting.

Fordi Singleton er ett av de mest kjente og hyppig diskuterte mønstrene, og fordi forståelsen av det sammen med dets betydelige kontroversen (global tilstand, testbarhets-problemer) og alternativet avhengighetsinjeksjon gjenspeiler god designdom, er forståelsen av Singleton-mønsteret verdifull, relevant kunnskap — et berømt mønster som er verdt å forstå, hvor forståelsen av dets mangler (global tilstand, vanskelig å teste) og preferansen for avhengighetsinjeksjon i mange tilfeller gjenspeiler den modne designdommen som skiller gjennomtenkte utviklere, og et hyppig møtt og diskutert tema innen programvaredesign.