Eina de Reparació JSON

Repara i recupera automàticament JSON trencat o mal formatat—de manera segura, ràpida i gratuïta.

Aquesta eina repara JSON trencat o invàlid mitjançant correcció d'errors automatitzada. Està dissenyada per solucionar els problemes de sintaxi més comuns trobats en dades exportades, registres o fitxers editats a mà—com ara cometes que falten, comes sobreres o claudàtors desajustats—i genera un JSON vàlid i analitzable com a resultat.

Repara el teu JSON a continuació

Com funciona la reparació de JSON

L'eina escaneja l'entrada per detectar problemes típics de sintaxi JSON i aplica correccions específiques, generant JSON vàlid quan és possible.

  1. Analitza l'entrada i detecta errors comuns de sintaxi, incloent-hi caràcters il·legals, parèntesis mal col·locats i cometes incorrectes en cadenes de text.
  2. Aplica correccions per a errors freqüents—com afegir cometes que falten, eliminar comes finals o corregir claus.
  3. Genera el JSON reparat. En la majoria de casos, el resultat està llest per analitzar-se o utilitzar-se immediatament.
  4. Si l'estructura no es pot reparar automàticament, es mostra un error clar perquè puguis ajustar la teva entrada.

Errors comuns de JSON i com solucionar-los

Aquí teniu errors típics de JSON que aquesta eina pot reparar, amb exemples per a cadascun:

Claus no entrecomillades

Les claus han d'anar entre cometes dobles.

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

Solució: Afegeix cometes dobles al voltant de qualsevol clau d'objecte que no estigui entre cometes.

Cometes simples utilitzades

JSON només accepta cometes dobles per a les cadenes de text.

Before:
{ 'role': 'administrador' }
After:
{ "role": "administrador" }

Solució: Substitueix les cometes simples per cometes dobles en totes les cadenes de text.

Cometes finals

No es permet utilitzar comes després de l'últim element.

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

Solució: Elimina qualsevol coma final.

Claudàtors desajustats o sense tancar

Tots els claudàtors i claudàtors corbats han de tancar-se correctament.

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

Solució: Afegeix parèntesis o claus de tancament que faltaven.

Comes que falten o sobrants

Els elements d'un array i d'un objecte han d'estar separats per una sola coma.

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

Corregiu: Insereix comes que falten o elimina duplicats.

Línies de comentari presents

El JSON estàndard no permet comentaris (com // o /* ... */).

Before:
{ "id": 1, // identificador d'usuari
 "active": true }
After:
{ "id": 1, "actiu": true }

Solució: Elimina les línies de comentari de l'entrada.

Formats de Nombre Invàlids

Només es permeten nombres decimals senzills (sense NaN, infinit ni hexadecimals).

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

Solució: Substitueix números invàlids per null.

Caràcters de control no escapats

Els caràcters com els salts de línia en cadenes de text s'han d'escapar.

Before:
{ "msg": "Línia1
Línia2" }
After:
{ "msg": "Línia1\nLínia2" }

Solució: Escapa correctament els caràcters de control.

Claus duplicades en objecte

Les claus duplicades en el mateix objecte causen ambigüitat.

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

Solució: Conserva només l'últim valor per a qualsevol clau duplicada.

Arrays mal formats

Els arrays han de tenir claudàtors i comes entre els elements.

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

Solució: S'afegixen comes que faltaven entre elements de l'array.

Entrada buida o només espais en blanc

El JSON no pot estar buit.

Before:
After:
null
Solució: retorna nul·l per a entrada buida.
Exemple: De JSON trencat a una reparació vàlida
Entrada JSON malformada
{ usuari: 'alice', id: 42, rols: [administrador, 'editor',] // coma extra
 actiu: true }
Sortida JSON Reparada
{
  "user": "alice",
  "id": 42,
  "roles": [
    "administrador",
    "editor"
  ],
  "active": true
}
Com utilitzar aquesta eina de reparació JSON
  1. Enganxa o escriu el teu JSON trencat a l'editor que hi ha a sota.
  2. Feu clic a 'Reparar' per detectar i corregir automàticament errors comuns de sintaxi.
  3. Revisa la sortida reparada i copia el teu JSON corregit.
Sempre comproveu el JSON reparat abans d'utilitzar-lo per a dades crítiques; pot ser necessari fer ajustaments manuals en casos d'entrades complexes o molt danyades.
Exemples de Codi per a la Reparació de JSON
Descobreix com reparar JSON en diversos llenguatges de programació.
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)