Wat is het Singleton-patroon?

Question

Accepted Answer

Het **Singleton**-patroon zorgt ervoor dat een klasse slechts **één instantie** heeft en biedt een globaal toegangspunt ervan. Het wordt gebruikt wanneer precies één object iets coördineert (een configuratie, een verbindingspool, een logger), hoewel het ook enigszins controversieel is.

## Wat Singleton doet

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

## Voorbeeld

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

## Veelvoorkomende toepassingen en de controverse

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

## Waarom het belangrijk is

Het begrijpen van het Singleton-patroon is waardevol omdat het één van de **meest bekende ontwerppatronen** is (veel aangetroffen en besproken), en het begrijpen ervan — inclusief de controverses ervan — weerspiegelt goed oordeel in ontwerp.

Singleton zorgt ervoor dat een klasse slechts één instantie heeft met globale toegang, gebruikt wanneer er werkelijk slechts één van iets zou moeten zijn (configuratie, logger, verbindingspool, cache) waartoe vanuit veel plaatsen wordt benaderd.

Het begrijpen wat het doet (een klasse die haar eigen instantiatie controleert om dezelfde instantie telkens terug te geven) is de basiskennis.

Het begrijpen van de **controverse** is echter even belangrijk en weerspiegelt volwassen oordeel: Singletons worden veel bekritiseerd omdat ze in wezen **globale staat in vermomming** zijn, wat **verborgen afhankelijkheden** creëert (code die een Singleton gebruikt, heeft een niet-aangegeven afhankelijkheid), code **moeilijk testbaar** maakt (je kunt de enkele instantie niet gemakkelijk mocken of vervangen), nauwe koppeling veroorzaakt, en gelijktijdigheidsprobleemen met zich meebrengt.

Het begrijpen dat **afhankelijkheidsinjectie vaak een beter alternatief is** (het doorgeven van de enkele instantie, dezelfde voordelen van "één instantie" bieden maar op een testbare, expliciete manier) weerspiegelt het ontwerpoordeel om in veel gevallen afhankelijkheidsinjectie boven Singletons te verkiezen.

Deze evenwichtige kennis — het patroon kennen maar ook de problemen ervan en betere alternatieven — is wat doordachtig gebruik onderscheidt van het blindelings kopiëren van patronen.

Omdat Singleton één van de meest bekende en veel besproken patronen is, en omdat het begrijpen ervan samen met de aanzienlijke controverses ervan (globale staat, testbaarheidsproblemen) en het afhankelijkheidsinjectie-alternatief goed ontwerpoordeel weerspiegelt, is het begrijpen van het Singleton-patroon waardevol, veelvoorkomend kennis — een beroemd patroon dat het waard is te begrijpen, waarbij waardering voor de nadelen ervan (globale staat, moeilijk testbaar) en de voorkeur voor afhankelijkheidsinjectie in veel gevallen het volwassen ontwerpoordeel weerspiegelt dat doordachte ontwikkelaars onderscheidt, en een veel aangetroffen en besproken onderwerp in softwareontwerp.