Wat is JSON? Uitleg in gewone taal (en hoe je veelvoorkomende fouten oplost)

JSON is overal in moderne software — configuratiebestanden, API-antwoorden, databases en instellingen leunen erop. Toch kan één verdwaalde komma een heel bestand breken en je achterlaten met een cryptische „Unexpected token”-fout. Deze gids legt in gewone taal uit wat JSON is, hoe de syntaxis echt werkt en hoe je de fouten diagnosticeert en oplost die je het vaakst tegenkomt.

Wat JSON is

JSON staat voor JavaScript Object Notation. Het is een lichtgewicht, tekstgebaseerd formaat om gestructureerde data op te slaan en uit te wisselen. Ondanks de naam is het niet gebonden aan JavaScript — vrijwel elke programmeertaal kan het lezen en schrijven, en dat is precies waarom het de standaardtaal van web-API's werd.

Het hele punt van JSON is dat het zowel voor mensen als machines leesbaar is. Het stelt data voor als combinatie van een paar eenvoudige bouwstenen:

• Objecten — verzamelingen sleutel/waarde-paren tussen accolades { }.
• Arrays — geordende lijsten tussen vierkante haken [ ].
• Waarden — een string, een getal, true, false, null, een object of een array.

Hier een klein maar volledig voorbeeld:

{
  "name": "Ada Lovelace",
  "active": true,
  "age": 36,
  "skills": ["math", "logic"],
  "address": {
    "city": "London",
    "postcode": null
  }
}

De regels waar mensen over struikelen

JSON lijkt sterk op een JavaScript-object, en die gelijkenis is de bron van de meeste fouten — JSON is strenger. Houd deze regels in gedachten en je vermijdt de overgrote meerderheid van de fouten:

1. Sleutels en strings hebben dubbele aanhalingstekens nodig

Elke sleutel moet een string tussen dubbele aanhalingstekens zijn, en elke tekstwaarde moet ook dubbele aanhalingstekens gebruiken. Enkele aanhalingstekens zijn geen geldige JSON, ook al kunnen ze in JavaScript prima.

// Ongeldig
{ 'name': 'Ada' }

// Geldig
{ "name": "Ada" }

2. Geen komma's aan het eind

Je mag geen komma laten staan na het laatste item in een object of array. Dit is verreweg de meest voorkomende JSON-fout, omdat veel editors en talen het elders gewillig toestaan.

// Ongeldig — komma na de laatste waarde
{ "a": 1, "b": 2, }

// Geldig
{ "a": 1, "b": 2 }

3. Geen commentaar

Standaard-JSON heeft geen commentaarsyntaxis. Regels die met // beginnen of blokken tussen /* */ veroorzaken een parseerfout. Heb je commentaar nodig, dan staan formaten als JSON5 of YAML het toe — bekijk onze YAML-formatter als dat beter past bij je situatie.

4. Getallen zijn simpel

Getallen worden zonder aanhalingstekens geschreven en zonder voorloopnullen of afsluitende decimaalpunten. 01, 1. en .5 zijn allemaal ongeldig; schrijf 1, 1.0 en 0.5.

Veelvoorkomende fouten en hoe je ze oplost

Wanneer een parser je JSON afwijst, meldt hij meestal een regel en kolom. Die plek wijst naar waar de parser het opgaf, wat vaak net na de echte fout ligt. Dit zijn de meldingen die je het vaakst ziet en wat ze werkelijk betekenen:

• "Unexpected token } in JSON" — bijna altijd een komma aan het eind vóór de sluitende accolade of haak. Verwijder de overtollige komma.
• "Unexpected string" / "Expected comma" — je mist een komma tussen twee waarden, of je gebruikte een regeleinde waar een komma hoorde.
• "Unexpected token ' in JSON" — enkele aanhalingstekens. Vervang ze door dubbele.
• "Unexpected end of JSON input" — een haak of accolade werd nooit gesloten. Tel je { en }; elke opener heeft een bijpassende sluiter nodig.
• "Unexpected token o in JSON" — een klassiek teken dat je iets probeerde te parsen dat al een object was, geen JSON-string. Roep een parser alleen op tekst aan.

De snelste manier om de exacte plek te vinden, is de tekst door een formatter te halen die valideert terwijl je typt. Onze JSON-formatter en -validator markeert de precieze regel en kolom van de eerste fout en, zodra de JSON geldig is, drukt hij hem netjes af zodat structurele problemen (een verkeerd geplaatste haak, een waarde één niveau te diep genest) in één oogopslag zichtbaar worden. Alles draait in je browser, dus je kunt privé- of gevoelige data veilig controleren.

Formatteren vs. minificeren

Twee bewerkingen komen voortdurend voor bij het werken met JSON. Formatteren (ook wel verfraaien of pretty-printen) voegt inspringing en regeleinden toe om een dichte klomp leesbaar te maken — ideaal tijdens het debuggen. Minificeren strookt elke onnodige spatie en regeleinde weg om de kleinst mogelijke uitvoer te maken — ideaal om over het netwerk te versturen of in code in te sluiten, waar grootte telt. De data is in beide gevallen identiek; alleen de witruimte verandert.

Snelle checklist

Voordat je JSON aan een programma geeft, controleer:

• Alle sleutels en stringwaarden gebruiken dubbele aanhalingstekens.
• Er zijn geen komma's aan het eind.
• Er is geen commentaar.
• Elke haak en accolade is in evenwicht.
• Het komt zonder fouten door een validator.

Krijg die vijf goed en JSON wordt waarvoor het ontworpen is: een saai, voorspelbaar formaat dat gewoon werkt. Glipt er toch iets doorheen, plak het dan in de JSON-formatter en laat die je recht naar het probleem leiden.