Slik fikser du feilutformet JSON raskt: En utviklers felthåndbok

API-kallet ditt feilet akkurat med JSONDecodeError: Expecting property name enclosed in double quotes. Klokkene tikker. Dataene kom fra en LLM, og et sted i det 2000-tokens lange svaret har et eneste etterfølgende komma ødelagt hele pipelinen din.

Per mai 2026 er den raskeste måten å fikse feilutformete JSON-filer på å bruke automatiserte biblioteker som json_repair (Python) eller jsonrepair (npm). Disse verktøyene er spesialbygget for å fikse LLM-genererte syntaksfeil umiddelbart. For manuelle reparasjoner er de vanlige mistenkte etterfølgende komma, enkle anførselstegn eller usiterte nøkler — de tre vanligste bruddene på RFC 8259-standarden.

Den raskeste fiksingen: json_repair for LLM-utdata

Standard parsere som Pythons json.loads() er strenge etter design. Ett feilplassert tegn utløser en JSONDecodeError, og alt stopper opp. Dette er et daglig problem i 2026, fordi LLM-er rutinemessig pakker JSON inn i samtaletekst, avkorter svar midt i en setning, eller strør inn kommentarer som bryter spesifikasjonen.

json_repair-biblioteket er den foretrukne løsningen. Ifølge GitHub har dette prosjektet over 4700 stjerner per 2026. Det fungerer ved å “gjette” strengens intensjon — lukke manglende klammer, legge til anførselstegn og fjerne overflødig tekst rundt JSON-blokken.

Python: Før og etter

Installer: pip install json-repair

Den ødelagte inndataen:

import json_repair

bad_json = '{"user": "Alice", "status": tru'
decoded_object = json_repair.loads(bad_json)

Hva som skjedde bak kulissene: json_repair så at tru sannsynligvis var true, la til den manglende lukkende klammen, og returnerte en gyldig Python-ordbok. Null manuell inngripen.

Salvage-modus: Når dataene er virkelig stygge

For tøffere tilfeller inkluderer json_repair (v0.59.5+) en Salvage-modus. Som det står i prosjektdokumentasjonen, er denne modusen bygget spesifikt for avkuttede AI-svar eller korrupte logger. Den kan tvinge arrays inn i objekter eller forkaste elementer som er for ødelagte til å reddes, slik at utdataen passer skjemaet ditt.

import json_repair

# Salvage mode for severely truncated data
result = json_repair.loads(
    '{"items": [{"id": 1, "name": "Widget"}, {"id": 2, "na',
    salvage_mode=True
)
# Result: {'items': [{'id': 1, 'name': 'Widget'}, {'id': 2}]}
# Dropped the incomplete 'na' but saved everything else

npm-alternativ

For Node.js-prosjekter håndterer jsonrepair-CLI-en den samme jobben:

# Fix a file in place
npx jsonrepair broken.json > fixed.json

# Fix a string in a script
const { jsonrepair } = require('jsonrepair');
const fixed = jsonrepair('{"name": "test",}');

Manuell feilsøking: Finn hva som brøt spesifikasjonen

Når automatisering ikke strekker til, må du finne nøyaktig hvor filen bryter RFC 8259. JSON er langt mindre ettergivende enn YAML eller JavaScript. Som JSONParser Diagnostics Team forklarer: “Parseren feiler ved det første tegnet den ikke forstår, noe som ofte er et nedstrøms symptom på et problem flere linjer tidligere.”

De tre JSON-morderne

Morder 1: Etterfølgende komma

Ifølge DEV Community er etterfølgende komma årsak nummer én til parsefeil. De er greie i JavaScript, men ulovlige etter det siste elementet i en JSON-array eller et JSON-objekt.

// BROKEN - trailing comma after "active"
{
  "name": "Alice",
  "status": "active",
}

// FIXED - no comma before closing brace
{
  "name": "Alice",
  "status": "active"
}

Morder 2: Enkle anførselstegn

JSON krever doble anførselstegn (") for både nøkler og strengverdier. Mange Python- og JavaScript-utviklere bruker ved et uhell enkle anførselstegn ('). Som TidyCode påpeker, er dette en obligatorisk fiks.

// BROKEN - single quotes
{'name': 'Alice'}

// FIXED - double quotes
{"name": "Alice"}

Morder 3: Usiterte nøkler

I JavaScript kan du skrive { name: "Alice" }. I JSON trenger hver nøkkel doble anførselstegn.

// BROKEN - unquoted key
{name: "Alice"}

// FIXED - quoted key
{"name": "Alice"}

“Unexpected Token”-feilen

Når en validerer flagger “Unexpected Token”, betyr det at parseren støtte på NaN, Infinity eller undefined — JavaScript-konstanter som JSON ikke støtter. JSON tillater kun null, true, false og tall.

// BROKEN - NaN is not valid JSON
{"score": NaN, "result": Infinity}

// FIXED - replace with null or valid values
{"score": null, "result": null}

Streng parsing vs. reparasjonsparsing: Når skal du bruke hva

Riktig tilnærming avhenger av hvor dataene dine kommer fra. Menneske-redigerte konfigurasjonsfiler fortjener streng parsing for å tvinge forfatteren til å rette feil. Maskingenererte data fra LLM-er eller API-logger trenger reparasjonsbasert parsing.

Skjema-styrte reparasjoner med Pydantic

Du kan styre reparasjonsprosessen med Pydantic v2 eller JSON Schema. Ved å gi json_repair et skjema gjør verktøyet mer enn å fikse syntaks — det kan korrigere typer (gjøre strengen "1" om til tallet 1) og fylle ut manglende obligatoriske felt med standardverdier.

from pydantic import BaseModel
import json_repair

class User(BaseModel):
    id: int
    name: str
    active: bool = True

# Broken JSON with wrong types
raw = '{"id": "42", "name": "Alice"}'
repaired = json_repair.loads(raw)

# Validate against schema
user = User(**repaired)
# user.id is now int(42), user.active defaults to True

Som Stefano Baccianella bemerket i sin prosjekt-sitering fra 2025, er denne tilnærmingen optimalisert for den “stort sett korrekte, men teknisk ugyldige” JSON-en som språkmodeller pleier å produsere.

Håndtering av flergigabyte-filer uten å krasje

Å reparere et 10KB-utdrag er enkelt. Å fikse en 2GB-fil krever en strategi som ikke spiser opp hele RAM-en din. Å laste hele filen inn i minnet forårsaker Out-of-Memory (OOM)-feil.

Strategi 1: Strømming med ijson

For massive datasett bruker du ijson til å behandle data bit for bit. Som Scrapfly nevner, behandler ijson data inkrementelt. Kombiner det med et oppryddingsskript som fikser problemer linje for linje før parsing.

import ijson

# Stream through a large JSON file
with open('huge_broken.json', 'r') as f:
    for item in ijson.items(f, 'records.item'):
        # Process each item individually
        process(item)

Strategi 2: CLI-rør for maksimal effektivitet

Den mest minneeffektive tilnærmingen for store filer er å bruke jsonrepair-CLI-en og røre utdata direkte til en ny fil:

# Streams repair, never loads full file into memory
jsonrepair large_broken.json > fixed.json

Dette er betydelig mer minneeffektivt enn å laste filen inn i Python eller en nettleser.

Konklusjon

Å fikse feilutformet JSON er ikke lenger manuelt arbeid takket være AI-bevisste biblioteker som json_repair. Du må fortsatt forstå RFC 8259-grunnleggende — ingen etterfølgende komma, ingen enkle anførselstegn, ingen usiterte nøkler — men automatisering er den eneste praktiske tilnærmingen for data i stor skala i 2026.

Arbeidsflyten er enkel: prøv et reparasjonsbibliotek først. Hvis det feiler, bruk en validator for å peke ut den eksakte syntaksfeilen. Dette holder applikasjonene dine i gang selv når innkommende data er alt annet enn perfekte.

Vanlige spørsmål

Støtter JSON offisielt kommentarer eller enkle anførselstegn?

Nei. RFC 8259-standarden forbyr kommentarer strengt. Enkle anførselstegn er også ugyldige — kun doble anførselstegn er tillatt for nøkler og strenger. Imidlertid kan verktøy som json_repair fjerne kommentarer og konvertere anførselstegn automatisk for å gjøre filer parsérbare av standardbiblioteker.

Hvordan håndterer jeg svært store feilutformede JSON-filer uten å krasje?

Bruk en strømmende parser som ijson for å behandle data i biter. Unngå å laste hele den feilutformede strengen inn i en enkelt variabel. For raskeste resultat, bruk CLI-reparasjonsverktøy som rører utdata direkte til en ny fil på disk uten å holde alt i minnet.

Hva er forskjellen på feilutformet JSON og ugyldig JSON?

Feilutformet (malformed) JSON bryter syntaksregler — manglende klammer, usiterte nøkler, etterfølgende komma — noe som gjør den umulig å parse. Ugyldig (invalid) JSON følger alle syntaksregler, men svarer ikke til et spesifikt JSON-skjema (for eksempel er et felt en streng når skjemaet forventer et heltall). Å fikse feilutformet JSON er strukturell reparasjon; å fikse ugyldig JSON handler om dataintegritet.

Kan jeg bruke json_repair med Pydantic-validering?

Ja. Kjør json_repair.loads() først for å fikse syntaksfeil, og send deretter den reparerte ordboken til Pydantic-modellen din for typevalidering og skjema-håndhevelse. Denne to-trinns tilnærmingen håndterer både strukturelle og semantiske problemer.

Hvorvidt JSON med JavaScript-stil kommentarer?

Standard JSON støtter ikke kommentarer, men json_repair kan fjerne //– og /* */-kommentarer automatisk. Hvis du trenger kommentarer i konfigurasjonsfilene dine, kan du vurdere å bruke JSONC (JSON med kommentarer)-formatet og en kompatibel parser som json5 for Python.