Instrument de Reparare JSON

Repară și recuperează automat JSON-ul deteriorat sau incorect formatat — sigur, rapid și gratuit.

Acest instrument repară JSON-ul rupt sau invalid prin corectarea automată a erorilor. Se concentrează pe cele mai frecvente probleme de sintaxă întâlnite în datele exportate, jurnale sau fișiere editate manual — precum ghilimele lipsă, virgule în plus sau paranteze nepotrivite — și generează un JSON valid și parsabil ca rezultat.

Reparați JSON-ul de mai jos

Cum funcționează repararea JSON

Instrumentul analizează textul introdus pentru probleme uzuale de sintaxă JSON și aplică corecturi precise, generând JSON valid atunci când este posibil.

  1. Analizează intrarea și identifică erori comune de sintaxă, inclusiv caractere ilegale, paranteze plasate greșit și ghilimele incorecte în șiruri de caractere.
  2. Aplică remedieri pentru greșeli frecvente — cum ar fi adăugarea ghilimelelor lipsă, eliminarea virgulelor la sfârșit sau corectarea parantezelor.
  3. Generează JSON-ul reparat. În majoritatea cazurilor, rezultatul este gata pentru a fi analizat sau utilizat imediat.
  4. Dacă structura nu poate fi reparată automat, este afișată o eroare clară pentru a putea ajusta inputul.

Erori frecvente JSON și cum să le remediezi

Iată greșelile obișnuite în JSON pe care acest instrument le poate repara, împreună cu exemple pentru fiecare:

Chei fără ghilimele

Cheile trebuie să fie în ghilimele duble.

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

Remediere: Adaugă ghilimele duble în jurul tuturor cheilor obiectelor neîntrebuințate cu ghilimele.

Ghilimele simple utilizate

JSON acceptă doar ghilimelele duble pentru șiruri de caractere.

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

Remediere: Înlocuiește ghilimelele simple cu ghilimele duble pentru toate șirurile de caractere.

Virgule finale

Nu se permite virgulă după ultimul element.

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

Remediază: Elimină orice virgulă suplimentară de la final.

Paranteze nepotrivite sau neînchise

Toate parantezele și acoladele trebuie să se închidă corect.

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

Remediere: Adaugă parantezele sau acoladele lipsă.

Virgule Lipsă sau În Plus

Elementele din array și din obiect trebuie separate printr-o singură virgulă.

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

Remediere: Inserează virgulele lipsă sau elimină duplicatele.

Linii de comentariu prezente

JSON standard nu permite comentarii (precum // sau /* ... */).

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

Remediază: Elimină liniile de comentariu din intrare.

Formate de Numere Invalide

Sunt valide doar numere decimale simple (fără NaN, infinit sau hexazecimal).

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

Corectare: Înlocuiește numerele invalide cu null.

Caractere de Control Nescapate

Caractere precum sfârșiturile de linie în șiruri trebuie scăpate.

Before:
{ "msg": "Linia1
Linia2" }
After:
{ "msg": "Linia1\nLinia2" }

Remediere: Caracterele de control sunt evitate corect.

Chei Duplicat în Obiect

Cheile duplicate în același obiect provoacă ambiguitate.

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

Remediere: Păstrează doar ultima valoare pentru orice cheie duplicată.

Array-uri necorespunzătoare

Tablourile trebuie să aibă paranteze drepte și virgule între elemente.

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

Remediu: Adaugă virgule lipsă între elementele unui șir.

Intrare goală sau doar spații albe

JSON nu poate fi gol.

Before:
After:
nul
Remediere: Returnează null pentru input gol.
Exemplu: De la JSON Corupt la o Reparație Validă
Intrare JSON incorectă
{ user: 'alice', id: 42, roluri: [admin, 'editor',] // virgulă suplimentară
 activ: true }
JSON reparat
{
  "user": "alice",
  "id": 42,
  "roles": [
    "administrator",
    "editor"
  ],
  "active": true
}
Cum să folosești acest Instrument de Reparare JSON
  1. Lipiți sau introduceți JSON-ul dvs. deteriorat în editorul de mai jos.
  2. Apasă „Repară” pentru a detecta și corecta automat erorile comune de sintaxă.
  3. Revizuiește rezultatul reparat și copiază-ți JSON-ul corectat.
Verifică întotdeauna JSON-ul reparat înainte de al folosi pentru date critice — pot fi necesare ajustări manuale pentru intrări complexe sau foarte deteriorate.
Exemple de Cod pentru Repararea JSON
Descoperă cum să repari JSON în diverse limbaje de programare.
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)