Strumento di Riparazione JSON

Correggi e recupera automaticamente JSON danneggiati o malformati—velocemente, in modo sicuro e gratuito.

Questo strumento corregge automaticamente JSON danneggiati o non validi utilizzando la correzione automatica degli errori. È progettato per risolvere i problemi di sintassi più comuni presenti in dati esportati, log o file modificati manualmente—come virgolette mancanti, virgole erranti o parentesi non corrispondenti—e genera un JSON valido e analizzabile come output.

Ripara il tuo JSON qui sotto

Come Funziona il Ripristino JSON

Lo strumento analizza il tuo input alla ricerca di problemi tipici nella sintassi JSON e applica correzioni mirate, generando JSON valido quando possibile.

  1. Analizza l'input e individua gli errori sintattici comuni, inclusi caratteri non consentiti, parentesi fuori posto e virgolette errate nelle stringhe.
  2. Applica correzioni per errori frequenti—come aggiungere virgolette mancanti, rimuovere virgole finali o correggere parentesi.
  3. Restituisce il JSON riparato. Nella maggior parte dei casi, il risultato è pronto per essere analizzato o utilizzato immediatamente.
  4. Se la struttura non può essere riparata automaticamente, viene mostrato un errore chiaro affinché tu possa correggere il tuo input.

Errori Comuni di JSON e Come Risolverli

Ecco gli errori tipici nei file JSON che questo strumento può correggere, con esempi per ciascuno:

Chiavi senza virgolette

Le chiavi devono essere tra virgolette doppie.

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

Correzione: Aggiunge virgolette doppie attorno a qualsiasi chiave di oggetto non quotata.

Virgolette singole utilizzate

JSON accetta solo virgolette doppie per le stringhe.

Before:
{ 'ruolo': 'amministratore' }
After:
{ "role": "amministratore" }

Correzione: sostituisce gli apici singoli con virgolette doppie in tutte le stringhe.

Virgole finali

Non è consentita la virgola dopo l'ultimo elemento.

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

Correzione: Rimuove tutte le virgole finali.

Parentesi non corrispondenti o non chiuse

Tutte le parentesi tonde e graffe devono essere chiuse correttamente.

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

Correzione: Aggiunte parentesi o parentesi graffe mancanti.

Virgole Mancanti o Extra

Gli elementi di array e oggetto devono essere separati da una virgola singola.

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

Correzione: Inserisce le virgole mancanti o rimuove quelle duplicate.

Linee di commento presenti

Lo standard JSON non consente commenti (come // o /* ... */).

Before:
{ "id": 1, // ID utente
 "active": true }
After:
{ "id": 1, "active": true }

Correzione: Rimuove le righe di commento dall'input.

Formati Numerici Non Validi

Sono validi solo numeri decimali semplici (niente NaN, infinito o esadecimale).

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

Correzione: Sostituisce i numeri non validi con valore nullo.

Caratteri di Controllo Non Escape

I caratteri come le nuove righe nelle stringhe devono essere preceduti da un carattere di escape.

Before:
{ "msg": "Linea1
Linea2" }
After:
{ "msg": "Linea1\nLinea2" }

Correzione: gestisce correttamente i caratteri di controllo di escape.

Chiavi Duplicate nell'Oggetto

Chiavi duplicate nello stesso oggetto creano ambiguità.

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

Correzione: mantiene solo l'ultimo valore per ogni chiave duplicata.

Array Non Validi

Gli array devono avere parentesi quadre e virgole tra gli elementi.

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

Correzione: Aggiunte le virgole mancanti tra gli elementi dell'array.

Input vuoto o solo spazi bianchi

Il JSON non può essere vuoto.

Before:
After:
null
Correzione: Restituisce null per input vuoto.
Esempio: Da JSON Corrotto a Riparazione Valida
Input JSON non valido
{ user: 'alice', id: 42, roles: [admin, 'editore',] // virgola extra
 attivo: vero }
Output JSON Riparato
{
  "user": "alice",
  "id": 42,
  "roles": [
    "amministratore",
    "redattore"
  ],
  "active": true
}
Come utilizzare questo strumento di riparazione JSON
  1. Incolla o digita il tuo JSON danneggiato nell'editor qui sotto.
  2. Clicca su 'Ripara' per rilevare e correggere automaticamente gli errori di sintassi più comuni.
  3. Verifica il risultato riparato e copia il tuo JSON corretto.
Controlla sempre il JSON riparato prima di utilizzarlo per dati critici—potrebbero essere necessari aggiustamenti manuali per input complessi o fortemente danneggiati.
Esempi di Codice per Riparazione JSON
Scopri come riparare il JSON in vari linguaggi di programmazione.
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)