Antwoord.

Achtergrond van de vraag:

In Go zijn er geen standaard generieke containertypes zoals een generieke map — pas vanaf Go 1.18 zijn generics geïntroduceerd, maar voor dynamische structuren gebruiken ontwikkelaars vaak map[string]interface{}, wat het mogelijk maakt om waarden van elk type op te slaan onder een string sleutel.

Probleem:

Dit patroon — dat vergelijkbaar is met een woordenboek/JSON-object — komt vaak voor bij serialisatie, het werken met middleware, en data zonder bepaalde structuur (bijvoorbeeld JSON-parser met encoding/json). Echter, toegang tot waarden vereist handmatige typecasting en voorzichtigheid met impliciete waarden en ontbrekende sleutels.

Oplossing:

Gebruik map[string]interface{} waar de structuur van de inkomende gegevens niet bekend is. Controleer zorgvuldig op sleutel-bestaans en voer type-casting (type assertion) alleen uit na de exists-idiom. Het is beter om deze maps niet "diep" in de bedrijfslogica te houden, maar als adapter aan de grenzen van het systeem.

Voorbeeldcode:

obj := map[string]interface{}{
    "int": 42,
    "str": "hallo",
    "flag": true,
}

if v, ok := obj["int"]; ok {
    n, success := v.(int)
    if success {
        fmt.Println(n)
    }
}

Belangrijkste kenmerken:

Maakt het mogelijk om waarden van verschillende types in één map op te slaan.
Vereist strikte controle bij typecasting en het lezen van waarden.
Vaak gebruikt voor JSON/HTTP API's, maar niet aanbevolen voor de kernbedrijfslogica.

Misleidende vragen.

Kan je zonder fouten toegang krijgen tot een waarde op sleutel in map[string]interface{}, als de sleutel ontbreekt?

Nee, dit geeft de "zero value" (nil) voor interface{}, en type-casting naar een specifiek type zal een paniek veroorzaken.

Wat gebeurt er bij serialisatie van map[string]interface{} met geneste slices of andere maps?

JSON-serialisatie zal de structuur correct verwerken, maar als er types zijn die standaard niet ondersteund worden (maps, channels, functies), zal er een marshaling-error optreden.

Kun je twee waarden in map[string]interface{} vergelijken met ==?

Nee, interface{} kan alleen worden vergeleken als de onderliggende waarde vergelijkbaar is. Als er een map of slice in zit, leidt dat tot paniek bij de vergelijking.

Typische fouten en anti-patronen

Voer geen type assertion uit, denkend dat het altijd het juiste type is.
Houd "ruwe" dergelijke maps in de logica van de applicatie, in plaats van aan de grenzen/beneden bij het parseren.
Controleer niet op het bestaan van een sleutel voordat je leest.

Voorbeeld uit het echte leven

Negatief geval

In de applicatie is de hele logica gebaseerd op objecten van map[string]interface{}, elke controller/service geeft ze diep door in aanroepen.

Voordelen:

Flexibel, snel prototype opstarten.

Nadelen:

Geen typecontroles — bugs manifesteren zich tijdens runtime.
Moeilijk te lezen en te onderhouden code.

Positief geval

Gebruik map[string]interface{} alleen voor interactie met externe interfaces, inkomende/uitgaande gegevens, en vertaal ze vervolgens naar normale structuren.