JSON Reparationsverktyg

Åtgärda och återställ automatiskt trasig eller felaktig JSON – säkert, snabbt och gratis.

Det här verktyget reparerar trasig eller ogiltig JSON med automatisk felkorrigering. Det åtgärdar de vanligaste syntaxproblemen som förekommer i exporterad data, loggar eller handredigerade filer—såsom saknade citattecken, överflödiga kommatecken eller ojämna klamrar—och producerar giltig, parsbar JSON som resultat.

Reparera din JSON nedan

Hur JSON-reparation fungerar

Verktyget analyserar din inmatning för vanliga JSON-syntaxfel och tillämpar riktade korrigeringar, vilket ger giltig JSON när det är möjligt.

  1. Analyserar inmatningen och identifierar vanliga syntaxfel, inklusive otillåtna tecken, felplacerade parenteser och felaktiga strängcitattecken.
  2. Tillämpa åtgärder för vanliga misstag—som att lägga till saknade citationstecken, ta bort avslutande kommatecken eller rätta till parenteser.
  3. Returnerar den reparerade JSON. I de flesta fall är resultatet klart att tolkas eller användas direkt.
  4. Om strukturen inte kan repareras automatiskt visas ett tydligt felmeddelande så att du kan justera din inmatning.

Vanliga JSON-fel och hur du åtgärdar dem

Här är vanliga JSON-fel som detta verktyg kan åtgärda, med exempel för varje:

Ocitera nycklar

Nycklar måste vara inom dubbla citationstecken.

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

Åtgärd: Lägger till dubbla citattecken runt alla objekt-nycklar utan citationstecken.

Enkel citationstecken använda

JSON accepterar endast dubbla citattecken för strängar.

Before:
{ 'roll': 'admin' }
After:
{ "role": "admin" }

Åtgärd: Byter ut enkla citattecken mot dubbla citattecken för alla strängar.

Avslutande kommatecken

Ingen komma tillåts efter sista objektet.

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

Åtgärd: Tar bort alla avslutande kommatecken.

Ojämna eller Ej Stängda Parenteser

Alla hakparenteser och klamrar måste stängas korrekt.

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

Fixa: Lägger till saknade avslutande hakparenteser eller måsvingar.

Saknade eller extra kommatecken

Element i arrayer och objekt måste separeras med ett enda komma.

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

Åtgärda: Infogar saknade kommatecken eller tar bort dubbletter.

Kommentarrader Förekommer

Standard JSON tillåter inte kommentarer (som // eller /* ... */).

Before:
{ "id": 1, // användar-ID
 "active": true }
After:
{ "id": 1, "aktiv": sant }

Åtgärd: Tar bort kommentarsrader från indata.

Ogiltiga nummerformat

Endast vanliga decimala tal är giltiga (ingen NaN, oändlighet eller hexadecimala tal).

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

Åtgärd: Ersätter ogiltiga nummer med null.

Okodade kontrolltecken

Tecken som radbrytningar i strängar måste undantas.

Before:
{ "msg": "Rad1
Rad2" }
After:
{ "msg": "Rad1\nRad2" }

Åtgärd: Escape-kontrolltecken hanteras korrekt.

Dubblettnycklar i objekt

Dubbletter av nycklar i samma objekt orsakar oklarheter.

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

Åtgärd: Behåller endast det sista värdet för varje duplicerad nyckel.

Felaktigt formaterade arrayer

Arrayer måste ha hakparenteser och kommatecken mellan objekten.

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

Åtgärd: Lägger till saknade kommatecken mellan arrayelement.

Tomt inmatningsfält eller endast blanksteg

JSON kan inte vara tomt.

Before:
After:
null
Åtgärd: Returnerar null för tomt indata.
Exempel: Från Trasig JSON till Korrekt Reparation
Felaktigt formaterad JSON-indata
{ user: 'alice', id: 42, roller: [admin, 'redaktör',] // extra komma
 aktiv: true }
Reparerad JSON-utdata
{
  "user": "alice",
  "id": 42,
  "roles": [
    "administratör",
    "redaktör"
  ],
  "active": true
}
Hur du använder detta JSON-reparationsverktyg
  1. Klistra in eller skriv din felaktiga JSON i redigeraren nedan.
  2. Klicka på 'Reparera' för att automatiskt upptäcka och åtgärda vanliga syntaxfel.
  3. Granska den reparerade utdata och kopiera din korrigerade JSON.
Kontrollera alltid reparerad JSON innan den används för kritiska data—manuella justeringar kan behövas för komplexa eller kraftigt skadade indata.
Kodexempel för JSON-reparation
Se hur du reparerar JSON i olika 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)