JSON reparationsværktøj

Ret og genskab automatisk ødelagt eller forkert formateret JSON—sikkert, hurtigt og gratis.

Dette værktøj reparerer ødelagt eller ugyldig JSON ved hjælp af automatisk fejlkorrigering. Det retter de mest almindelige syntaksproblemer, der findes i eksporterede data, logfiler eller manuelt redigerede filer—som manglende citationstegn, overflødige kommaer eller ubalancerede parenteser—og genererer gyldig, parsebar JSON som output.

Reparer din JSON nedenfor

Sådan fungerer JSON-reparation

Værktøjet scanner din indtastning for typiske JSON-syntaksfejl og anvender målrettede rettelser, så der produceres gyldig JSON, når det er muligt.

  1. Analyserer input og finder almindelige syntaksfejl, herunder ulovlige tegn, fejlplacerede parenteser og forkerte anførselstegn i tekststrenge.
  2. Anvender rettelser for hyppige fejl – som at tilføje manglende citationstegn, fjerne afsluttende kommaer eller rette parenteser.
  3. Genererer den reparerede JSON. I de fleste tilfælde er resultatet klar til at blive parset eller brugt med det samme.
  4. Hvis strukturen ikke kan repareres automatisk, vises en tydelig fejlmeddelelse, så du kan rette din indtastning.

Almindelige JSON-fejl og hvordan du retter dem

Her er typiske JSON-fejl, som dette værktøj kan rette, med eksempler for hver enkelt:

Nøgler uden anførselstegn

Nøgler skal være omsluttet af dobbelte anførselstegn.

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

Fix: Tilføjer dobbelte anførselstegn rundt om alle uanførte objektnøgler.

Enkeltanførselstegn Bruges

JSON accepterer kun dobbelte anførselstegn til strenge.

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

Rettelse: Erstatter enkelte anførselstegn med dobbelte anførselstegn i alle tekststrenge.

Efterfølgende kommaer

Der må ikke sættes komma efter det sidste element.

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

Fix: Fjerner eventuelle afsluttende kommaer.

Uoverensstemmende eller Ikke Lukkede Parentheser

Alle parenteser og klammer skal lukkes korrekt.

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

Fix: Tilføjer manglende lukkende parenteser eller krøllede parenteser.

Manglende eller Ekstra Kommaer

Elementer i arrays og objekter skal adskilles af et enkelt komma.

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

Ret: Indsætter manglende kommaer eller fjerner duplikater.

Kommentarlinjer til stede

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

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

Ret: Fjerner kommentarlinjer fra input.

Ugyldige nummerformater

Kun almindelige decimaltal er gyldige (ingen NaN, uendelig eller hexadecimale tal).

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

Ret: Erstatter ugyldige numre med null.

Ukodede Kontroltegn

Tegn som linjeskift i strenge skal undslippes.

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

Fikset: Undslipper kontroltegn korrekt.

Dublerede nøgler i objekt

Duplikerede nøgler i samme objekt forårsager uklarhed.

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

Løsning: Beholder kun den sidste værdi for enhver duplikeret nøgle.

Fejlformaterede arrays

Arrays skal have klammer og kommaer mellem elementerne.

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

Ret: Tilføjer manglende kommaer mellem elementer i arrayet.

Tom indtastning eller kun mellemrum

JSON kan ikke være tom.

Before:
After:
null
Ret: Returnerer null for tomt input.
Eksempel: Fra beskadiget JSON til en gyldig reparation
Fejlagtig JSON-indgang
{ bruger: 'alice', id: 42, roller: [administrator, 'redaktør',] // ekstra komma
 aktiv: sand }
Repareret JSON-output
{
  "user": "alice",
  "id": 42,
  "roles": [
    "administrator",
    "redaktør"
  ],
  "active": true
}
Sådan bruger du dette JSON-reparationsværktøj
  1. Indsæt eller skriv din ødelagte JSON i editoren nedenfor.
  2. Klik på 'Reparer' for automatisk at opdage og rette almindelige syntaksfejl.
  3. Gennemgå den reparerede output og kopier din rettede JSON.
Kontroller altid det reparerede JSON, før det bruges til kritiske data – manuelt tilpasninger kan være nødvendige for komplekse eller meget beskadigede input.
Kodeeksempler til JSON-reparation
Se, hvordan du reparerer JSON i forskellige programmeringssprog.
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)