JSON Javító Eszköz

Javítsa és állítsa helyre automatikusan a sérült vagy hibás JSON fájlokat — biztonságosan, gyorsan és ingyen.

Ez az eszköz automatikus hibajavítással javítja a sérült vagy érvénytelen JSON-t. A leggyakoribb szintaxisproblémákat célozza meg, amelyek exportált adatokban, naplókban vagy kézzel szerkesztett fájlokban fordulnak elő — például hiányzó idézőjelek, tévedésből bekerült vesszők vagy nem egyező zárójelek — és érvényes, feldolgozható JSON-t állít elő eredményként.

Javítsa ki az alábbi JSON-t

Hogyan működik a JSON javítása

Az eszköz átvizsgálja a bevitt adatokat a tipikus JSON szintaxis hibákra, és célzott javításokat alkalmaz, hogy lehetőség szerint érvényes JSON-t hozzon létre.

  1. Feldolgozza a bemenetet, és felismeri a gyakori szintaktikai hibákat, például az illegális karaktereket, rosszul elhelyezett zárójeleket és helytelen idézőjeleket. Kiemelten segít a hibák gyors javításában és a kód megbízhatóságának növelésében.
  2. Javításokat alkalmaz a gyakori hibákra — például hiányzó idézőjelek hozzáadása, felesleges vesszők eltávolítása vagy zárójelek korrigálása.
  3. A javított JSON-t adja vissza. A legtöbb esetben az eredmény azonnal feldolgozható vagy használható.
  4. Ha a szerkezetet nem lehet automatikusan javítani, egy egyértelmű hibaüzenet jelenik meg, hogy módosíthassa a bevitelét.

Gyakori JSON hibák és azok javítása

Íme néhány tipikus JSON-hiba, amelyeket ez az eszköz képes javítani, példákkal mindegyikre:

Idézőjelek nélküli kulcsok

A kulcsoknak dupla idézőjelek között kell lenniük.

Before:
{ név: "Bob" }
After:
{ "name": "Bob" }

Javítás: Kettős idézőjeleket ad a nem idézőjeles objektumkulcsok köré.

Egyszeres idézőjelek használata

A JSON csak dupla idézőjeleket fogad el karakterláncokhoz.

Before:
{ 'szerep': 'adminisztrátor' }
After:
{ "szerep": "adminisztrátor" }

Javítás: Egyszeres idézőjeleket cserél dupla idézőjelekre az összes szövegben.

Vessző a sor végén

Az utolsó elem után nem megengedett vessző.

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

Javítás: Eltávolítja a végrehagyott vesszőket.

Eltérő vagy Lezáratlan Zárójelek

Minden zárójelnek és kapcsos zárójelnek megfelelően be kell záródnia.

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

Javítás: Hiányzó záró zárójelek vagy kapcsos zárójelek hozzáadása.

Hiányzó vagy Túlzott Vesszők

A tömb- és objektumtételeket egyetlen vesszővel kell elválasztani.

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

Javítás: Hiányzó vesszők beszúrása vagy duplikált elemek eltávolítása.

Megjegyzéssorok találhatók

A szabványos JSON nem engedélyezi a megjegyzéseket (mint például // vagy /* ... */).

Before:
{ "id": 1, // felhasználó azonosító
 "active": true }
After:
{ "id": 1, "active": true }

Javítás: Eltávolítja a megjegyzés sorokat a bemenetből.

Érvénytelen számformátumok

Csak egyszerű tizedes számok érvényesek (nem NaN, Végtelen vagy hexadecimális).

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

Javítás: Érvénytelen számokat null értékre cserél.

Nem megengedett vezérlő karakterek

A karakterek, például az új sorok a sztringekben, escape-elni kell.

Before:
{ "msg": "1. sor
2. sor" }
After:
{ "msg": "Első sor\nMásodik sor" }

Javítás: A vezérlőkarakterek helyes elmentése.

Duplikált kulcsok az objektumban

Az azonos kulcsok ismétlése ugyanabban az objektumban kétértelműséget okoz.

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

Javítás: Csak az utolsó értéket tartja meg bármely ismétlődő kulcshoz.

Hibás tömbök

A tömböknek zárójelekkel és elemközi vesszőkkel kell rendelkezniük.

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

Javítás: Hiányzó vesszők hozzáadása a tömb elemei között.

Üres bevitel vagy csak szóközök

A JSON nem lehet üres.

Before:
After:
null
Javítás: Üres bemenet esetén null értéket ad vissza.
Példa: Hibás JSON-tól a Hibátlan Javításig
Hibás JSON bemenet
{ user: 'alice', id: 42, roles: [admin, 'szerkesztő',] // extra vessző
 active: true }
Javított JSON kimenet
{
  "user": "alice",
  "id": 42,
  "roles": [
    "adminisztrátor",
    "szerkesztő"
  ],
  "active": true
}
Hogyan Használd Ezt a JSON Javító Eszközt
  1. Illessze be vagy írja be a hibás JSON-ját az alábbi szerkesztőbe.
  2. Kattintson a „Javítás” gombra a gyakori szintaxis hibák automatikus felismeréséhez és javításához.
  3. Tekintse át a javított kimenetet, és másolja át a javított JSON-t.
Mindig ellenőrizze a javított JSON-t, mielőtt kritikus adatokhoz használná – bonyolultabb vagy erősen sérült adatok esetén manuális módosításokra lehet szükség.
JSON javítás kód példák
Nézze meg, hogyan javítható a JSON különböző programozási nyelveken.
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)