JSON-reparasjonsverktøy

Fiks og gjenopprett ødelagt eller feilformatert JSON automatisk—sikkert, raskt og gratis.

Dette verktøyet reparerer ødelagt eller ugyldig JSON ved hjelp av automatisk feilkorrigering. Det retter de vanligste syntaksfeilene som finnes i eksporterte data, logger eller håndredigerte filer—som manglende anførselstegn, overflødige kommaer eller feilparrede parenteser—og gir gyldig og lesbar JSON som resultat.

Reparer JSON-en din nedenfor

Hvordan JSON-reparasjon fungerer

Verktøyet sjekker inndataene dine for vanlige JSON-syntaksfeil og utfører målrettede rettelser, slik at det produseres gyldig JSON når det er mulig.

  1. Tolker inndataene og finner vanlige syntaksfeil, inkludert ulovlige tegn, feilplasserte klammer og feilaktige anførselstegn i tekststrenger.
  2. Fjerner vanlige feil – som å legge til manglende anførselstegn, fjerne overflødige kommaer eller rette opp i klammer.
  3. Leverer den reparerte JSON-en. I de fleste tilfeller er resultatet klart til å tolkes eller brukes umiddelbart.
  4. Hvis strukturen ikke kan repareres automatisk, vises en tydelig feilmelding slik at du kan justere inndataene dine.

Vanlige JSON-feil og hvordan du fikser dem

Her er vanlige JSON-feil som dette verktøyet kan reparere, med eksempler for hver:

Utsagnsfrie nøkler

Nøkler må være i doble anførselstegn.

Before:
{ navn: "Bob" }
After:
{ "name": "Bob" }

Løsning: Legger til doble anførselstegn rundt alle uendrede objektnøkler.

Enkle anførselstegn brukt

JSON godtar kun doble anførselstegn for strenger.

Before:
{ 'rolle': 'admin' }
After:
{ "rolle": "administrator" }

Fiks: Erstatter enkeltanførselstegn med doble anførselstegn for alle strenger.

Etterslepende kommaer

Ingen komma er tillatt etter det siste elementet.

Before:
{ "a": 1, "b": 2, }
After:
{ "a": 1, "b": 2 }

Fiks: Fjerner alle avsluttende komma.

Uoverensstemmende eller ufullstendige parenteser

Alle parenteser og krøllparanteser må lukkes riktig.

Before:
[1, 2, 3
After:
[1, 2, 3]

Fiks: Legger til manglende avsluttende parenteser eller klammer.

Manglende eller ekstra komma

Elementer i matriser og objekter må skilles med et enkelt komma.

Before:
{ "a": 1 "b": 2 }
After:
{ "a": 1, "b": 2 }

Fiks: Setter inn manglende kommaer eller fjerner duplikater.

Kommentarlinjer til stede

Standard JSON tillater ikke kommentarer (som // eller /* ... */).

Before:
{ "id": 1, // bruker-ID
 "active": true }
After:
{ "id": 1, "aktiv": true }

Fiks: Fjerner kommentarlinjer fra inndataene.

Ugyldige tallformater

Kun vanlige desimaltall er gyldige (ingen NaN, uendelig eller heksadesimale).

Before:
{ "val": NaN }
After:
{ "val": null }

Fiks: Erstatter ugyldige tall med null.

Ukodede kontrolltegn

Tegn som linjeskift i strenger må escapes.

Before:
{ "msg": "Linje1
Linje2" }
After:
{ "msg": "Linje1\nLinje2" }

Fiks: Escape-tegn for kontrolltegn håndteres korrekt.

Dupliserte nøkler i objekt

Dupliserte nøkler i samme objekt forårsaker uklarhet.

Before:
{ "name": "A", "name": "B" }
After:
{ "name": "B" }

Løsning: Beholder kun den siste verdien for eventuelle dupliserte nøkler.

Feilformatert matrise

Matriser må ha klammeparenteser og komma mellom elementene.

Before:
[ 1 2 3 ]
After:
[ 1, 2, 3 ]

Fiks: Legger til manglende kommaer mellom array-elementer.

Tomt inndata eller kun mellomrom

JSON kan ikke være tom.

Before:
After:
null
Fiks: Returnerer null for tomt input.
Eksempel: Fra Ødelagt JSON til Gyldig Reparasjon
Feilformatert JSON-inndata
{ bruker: 'alice', id: 42, roller: [admin, 'redaktør',] // ekstra komma
 aktiv: true }
Reparert JSON-utdata
{
  "user": "alice",
  "id": 42,
  "roller": [
    "administrator",
    "redaktør"
  ],
  "aktiv": true
}
Hvordan bruke dette JSON-reparasjonsverktøyet
  1. Lim inn eller skriv inn din ødelagte JSON i redigeringsfeltet nedenfor.
  2. Klikk på «Reparer» for å automatisk oppdage og fikse vanlige syntaksfeil.
  3. Gå gjennom den reparerte utdatafilen og kopier din korrigerte JSON.
Sjekk alltid reparert JSON før bruk i kritiske data – manuelle justeringer kan være nødvendig for komplekse eller sterkt skadde data.
Kodeeksempler for JSON-reparasjon
Se hvordan du kan reparere JSON i ulike programmeringsspråk.
JavaScript (Node.js) with jsonrepair
Install: npm install jsonrepair
const { jsonrepair } = require('jsonrepair');
const broken = '{ name: "Bob", age: 42, }';
const fixed = jsonrepair(broken);
console.log(fixed); // Now valid JSON!
JavaScript (Node.js) simple fix (not for production)
Install: Standard library
let broken = "{ name: 'Bob', age: 42 }";
broken = broken.replace(/(['"])?:([\s]*)([^\s,\{\}\[\]":']+)/g, '"$1$3":');
try {
  let obj = JSON.parse(broken);
  console.log(obj);
} catch (e) {
  console.error('Still broken:', e.message);
}
Python with dirtyjson
Install: pip install dirtyjson
import dirtyjson
broken = "{ name: 'Bob', age: 42 }"
obj = dirtyjson.loads(broken)
print(obj)
Python with demjson3
Install: pip install demjson3
import demjson3
broken = "{ name: 'Bob', age: 42 }"
obj = demjson3.decode(broken)
print(obj)
Go (using otto for JS-like object parsing)
Install: go get github.com/robertkrimen/otto
package main
import (
  "fmt"
  "github.com/robertkrimen/otto"
)
func main() {
  vm := otto.New()
  broken := "{ name: 'Bob', age: 42 }"
  value, err := vm.Run("(" + broken + ")")
  if err != nil {
    fmt.Println("Cannot repair:", err)
  } else {
    obj, _ := value.Export()
    fmt.Println(obj)
  }
}
Java with org.json (manual fix for single quotes)
Install: org.json:json
import org.json.JSONObject;
public class Main {
  public static void main(String[] args) {
    String broken = "{'name': 'Bob', 'age': 42}".replace(''', '"');
    JSONObject obj = new JSONObject(broken);
    System.out.println(obj);
  }
}
C# with Newtonsoft.Json (try-catch, manual fix)
Install: Newtonsoft.Json
using System;
using Newtonsoft.Json;
class Program {
  static void Main() {
    var broken = "{ name: 'Bob', age: 42 }".Replace("'", "\"");
    try {
      var obj = JsonConvert.DeserializeObject(broken);
      Console.WriteLine(obj);
    } catch (Exception ex) {
      Console.WriteLine("Broken JSON: " + ex.Message);
    }
  }
}
PHP (manual fix for single quotes/unquoted keys)
Install: Standard library
<?php
$broken = "{ name: 'Bob', age: 42 }";
$fixed = preg_replace("/'([^"]*)'/", '"$1"', $broken);
$fixed = preg_replace('/([a-zA-Z0-9_]+):/', '"$1":', $fixed);
$obj = json_decode($fixed);
var_dump($obj);
Ruby with json-repair (via gem or shell call)
Install: gem install json-repair or use npx jsonrepair
# Using system call to npx jsonrepair
require 'open3'
broken = "{ name: 'Bob', age: 42 }"
fixed, _ = Open3.capture2("echo #{broken.inspect} | npx jsonrepair")
puts fixed
Bash (npx jsonrepair CLI)
Install: npm install -g jsonrepair
echo "{ name: 'Bob', age: 42 }" | npx jsonrepair
Rust (suggest manual pre-processing)
Install: Standard libraries
// Rust does not have a json repair crate yet. Pre-process string with regex to fix simple cases, then use serde_json.
Kotlin (manual fix, like Java)
Install: org.json:json
import org.json.JSONObject
fun main() {
  var broken = "{ name: 'Bob', age: 42 }".replace("'", "\"")
  broken = Regex("([a-zA-Z0-9_]+):").replace(broken, ""$1":")
  val obj = JSONObject(broken)
  println(obj)
}
TypeScript (Node.js) with jsonrepair
Install: npm install jsonrepair
import { jsonrepair } from 'jsonrepair';
const broken = '{ name: "Bob", age: 42 }';
const fixed = jsonrepair(broken);
console.log(fixed);
Dart (manual string fixes)
Install: Standard library
var broken = "{ name: 'Bob', age: 42 }";
var fixed = broken.replaceAll("'", '"').replaceAllMapped(
  RegExp(r'([a-zA-Z0-9_]+):'),
  (m) => '"${m[ 1 ]}":',
);
print(fixed);
Elixir (manual fix with Regex)
Install: Standard library
broken = "{ name: 'Bob', age: 42 }"
fixed = Regex.replace(~r/'/, broken, """)
fixed = Regex.replace(~r/(\w+):/, fixed, ""\\1":")
IO.puts(fixed)