Alat Perbaikan JSON

Perbaiki dan pulihkan JSON yang rusak atau salah format secara otomatis—aman, cepat, dan gratis.

Alat ini memperbaiki JSON yang rusak atau tidak valid dengan koreksi otomatis kesalahan. Alat ini menargetkan masalah sintaksis paling umum yang ditemukan dalam data ekspor, log, atau file yang diedit secara manual—seperti kutipan yang hilang, koma berlebih, atau tanda kurung yang tidak cocok—dan menghasilkan JSON yang valid serta dapat diparsing sebagai output.

Perbaiki JSON Anda di bawah ini

Cara Kerja Perbaikan JSON

Alat ini memindai masukan Anda untuk masalah sintaks JSON yang umum dan menerapkan perbaikan yang tepat, sehingga menghasilkan JSON yang valid bila memungkinkan.

  1. Mengurai input dan menemukan kesalahan sintaks umum, termasuk karakter ilegal, tanda kurung yang salah tempat, dan kutipan string yang tidak benar.
  2. Menerapkan perbaikan untuk kesalahan umum—seperti menambahkan tanda kutip yang hilang, menghapus koma yang tidak perlu, atau memperbaiki tanda kurung.
  3. Menghasilkan JSON yang telah diperbaiki. Dalam sebagian besar kasus, hasilnya siap untuk diurai atau digunakan secara langsung.
  4. Jika struktur tidak dapat diperbaiki secara otomatis, akan ditampilkan kesalahan yang jelas agar Anda dapat menyesuaikan masukan Anda.

Kesalahan JSON Umum dan Cara Memperbaikinya

Berikut adalah kesalahan JSON umum yang dapat diperbaiki oleh alat ini, beserta contoh untuk masing-masing:

Kunci Tanpa Tanda Petik

Kunci harus dalam tanda kutip ganda.

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

Perbaikan: Menambahkan tanda kutip ganda di sekitar kunci objek yang tidak diberi tanda kutip.

Tanda Petik Tunggal Digunakan

JSON hanya menerima tanda kutip ganda untuk string.

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

Perbaikan: Mengganti tanda kutip tunggal dengan tanda kutip ganda untuk semua string.

Koma Akhir

Tidak diperbolehkan tanda koma setelah item terakhir.

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

Perbaikan: Menghapus semua koma di akhir.

Kurat Kurang Cocok atau Kurang Tertutup

Semua tanda kurung dan kurung kurawal harus ditutup dengan benar.

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

Perbaikan: Menambahkan tanda kurung tutup atau kurung kurawal yang hilang.

Koma Hilang atau Berlebih

Item array dan objek harus dipisahkan oleh satu koma saja.

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

Perbaiki: Menyisipkan koma yang hilang, atau menghapus duplikat.

Baris Komentar Terdeteksi

JSON standar tidak mengizinkan komentar (seperti // atau /* ... */).

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

Perbaiki: Menghapus baris komentar dari input.

Format Nomor Tidak Valid

Hanya angka desimal biasa yang valid (tidak termasuk NaN, Infinity, atau heksadesimal).

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

Perbaikan: Mengganti angka tidak valid dengan nilai null.

Karakter Kontrol Tidak Terescape

Karakter seperti baris baru dalam string harus di-escape.

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

Perbaiki: Melarikan karakter kontrol dengan benar.

Duplikat Kunci dalam Objek

Kunci duplikat dalam objek yang sama menyebabkan ketidakjelasan.

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

Perbaiki: Hanya menyimpan nilai terakhir untuk setiap kunci yang duplikat.

Array Tidak Terbentuk Dengan Benar

Array harus memiliki tanda kurung siku dan koma di antara setiap item.

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

Perbaikan: Menambahkan koma yang hilang di antara elemen array.

Input Kosong atau Hanya Spasi

JSON tidak boleh kosong.

Before:
After:
nol
Perbaikan: Mengembalikan null untuk input kosong.
Contoh: Dari JSON Rusak ke Perbaikan yang Valid
Input JSON Tidak Terformat dengan Benar
{ user: 'alice', id: 42, roles: [admin, 'editor',] // koma ekstra
 aktif: true }
Output JSON yang Diperbaiki
{
  "user": "alice",
  "id": 42,
  "roles": [
    "admin",
    "editor"
  ],
  "active": true
}
Cara Menggunakan Alat Perbaikan JSON Ini
  1. Tempel atau ketik JSON rusak Anda ke editor di bawah ini.
  2. Klik 'Perbaiki' untuk mendeteksi dan memperbaiki kesalahan sintaks umum secara otomatis.
  3. Tinjau hasil perbaikan dan salin JSON yang telah Anda perbaiki.
Selalu periksa JSON yang telah diperbaiki sebelum digunakan untuk data penting—penyesuaian manual mungkin diperlukan untuk input yang kompleks atau sangat rusak.
Contoh Kode untuk Perbaikan JSON
Lihat cara memperbaiki JSON dalam berbagai bahasa pemrograman.
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)