Alat Pembaikan JSON

Betulkan dan pulihkan JSON yang rosak atau tidak teratur secara automatik—dengan selamat, pantas, dan percuma.

Alat ini membaiki JSON yang rosak atau tidak sah menggunakan pembetulan ralat automatik. Ia menyasarkan masalah sintaks yang paling biasa ditemui dalam data yang dieksport, log, atau fail yang disunting secara manual—seperti tanda petik yang hilang, koma yang tersasar, atau kurungan yang tidak sepadan—dan menghasilkan JSON yang sah serta boleh diurai sebagai output.

Baiki JSON anda di bawah

Bagaimana Pembaikan JSON Berfungsi

Alat ini mengimbas input anda untuk masalah sintaks JSON yang biasa dan menerapkan pembetulan khusus, menghasilkan JSON yang sah apabila boleh.

  1. Mengurai input dan mengesan kesilapan tatabahasa yang biasa, termasuk aksara haram, kurungan yang diletakkan salah, dan tanda petik string yang tidak tepat.
  2. Menerapkan pembetulan untuk kesilapan yang kerap berlaku—seperti menambah petikan yang hilang, membuang koma yang berlebihan, atau membetulkan kurungan.
  3. Mengeluarkan JSON yang telah diperbaiki. Dalam kebanyakan kes, hasilnya sedia untuk diparse atau guna serta-merta.
  4. Jika struktur tidak dapat dibaiki secara automatik, ralat yang jelas akan dipaparkan supaya anda boleh menyesuaikan input anda.

Ralat JSON Biasa dan Cara Memperbaikinya

Berikut adalah kesilapan JSON biasa yang alat ini boleh baiki, dengan contoh untuk setiap satu:

Kunci Tanpa Petikan

Kunci mesti dalam tanda petik berganda.

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

Betulkan: Menambah tanda petik berganda di sekeliling sebarang kunci objek yang tidak dinamakan dengan petikan.

Petikan Tunggal Digunakan

JSON hanya menerima tanda petik dua untuk rentetan.

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

Betulkan: Gantikan tanda petik tunggal dengan tanda petik berganda untuk semua rentetan.

Koma Susulan

Tiada koma dibenarkan selepas item terakhir.

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

Betulkan: Buang mana-mana koma yang terletak di hujung.

Tanda Kurung Tidak Padan atau Tidak Ditutup

Semua tanda kurungan dan kurungan kerinting mesti ditutup dengan betul.

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

Betulkan: Menambah tanda tutup kurungan atau tanda kurungan kurawal yang hilang.

Koma Hilang atau Berlebihan

Item dalam array dan objek mesti dipisahkan oleh satu koma sahaja.

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

Betulkan: Masukkan koma yang hilang, atau buang pendua.

Baris Komen Dikesan

JSON standard tidak membenarkan komen (seperti // atau /* ... */).

Before:
{ "id": 1, // ID pengguna
 "active": benar }
After:
{ "id": 1, "aktif": benar }

Betulkan: Buang baris komen daripada input.

Format Nombor Tidak Sah

Hanya nombor perpuluhan biasa yang sah (tiada NaN, Infiniti, atau heksadesimal).

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

Betulkan: Gantikan nombor tidak sah dengan null.

Aksara Kawalan Tidak Terpapar

Aksara seperti baris baru dalam rentetan mesti diisikan dengan escape.

Before:
{ "msg": "Baris1
Baris2" }
After:
{ "msg": "Baris1\nBaris2" }

Baiki: Melarikan watak kawalan dengan betul.

Kunci Berganda dalam Objek

Kunci pendua dalam objek yang sama menyebabkan kekeliruan.

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

Betulkan: Simpan hanya nilai terakhir untuk sebarang kekunci berganda.

Array Tidak Teratur

Tatasusunan mesti mempunyai tanda kurungan dan koma antara setiap item.

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

Betulkan: Menambah koma yang hilang antara elemen array.

Input Kosong atau Semua Ruang Putih

JSON tidak boleh kosong.

Before:
After:
null
Pembaikan: Mengembalikan nilai kosong untuk input kosong.
Contoh: Dari JSON Rosak ke Pembetulan Sah
Input JSON Tidak Sah
{ pengguna: 'alice', id: 42, peranan: [pentadbir, 'penyunting',] // koma tambahan
 aktif: benar }
Output JSON yang Dibaiki
{
  "user": "alice",
  "id": 42,
  "roles": [
    "pentadbir",
    "penyunting"
  ],
  "active": true
}
Cara Menggunakan Alat Pembaikan JSON Ini
  1. Tampal atau taip JSON yang rosak anda ke dalam penyunting di bawah.
  2. Klik 'Baiki' untuk mengesan dan membaiki kesalahan sintaks biasa secara automatik.
  3. Semak semula hasil yang diperbaiki dan salin JSON yang telah anda betulkan.
Sentiasa semak JSON yang telah dibaiki sebelum menggunakannya untuk data penting—penyesuaian manual mungkin diperlukan untuk input yang kompleks atau sangat rosak.
Contoh Kod untuk Pembetulan JSON
Lihat cara membaiki JSON dalam pelbagai bahasa pengaturcaraan.
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)