Kagamitan sa Pag-ayos ng JSON

Awtomatikong ayusin at ibalik ang sira o maling format na JSON—ligtas, mabilis, at libre.

Ang tool na ito ay nag-aayos ng sirang o hindi wasto na JSON gamit ang awtomatikong pagwawasto ng mga error. Nilalayon nito ang mga karaniwang problema sa sintaks na makikita sa na-export na data, mga log, o mga file na manu-manong in-edit—tulad ng nawawalang panipi, hindi tamang mga kuwit, o hindi magkatugmang panaklong—at nagbibigay ng wastong, madaling i-parse na JSON bilang output.

Ayusin ang iyong JSON sa ibaba

Paano Gumagana ang Pag-ayos ng JSON

Sinusuri ng tool ang iyong input para sa mga karaniwang problema sa sintaks ng JSON at naglalapat ng mga tiyak na ayos, na lumilikha ng wastong JSON kapag posible.

  1. Sinusuri ang input at hinahanap ang mga karaniwang pagkakamali sa sintaks, kabilang ang mga ilegal na karakter, maling ayos ng mga bracket, at maling mga panipi sa string.
  2. Naglalapat ng mga ayos para sa mga madalas na pagkakamali—tulad ng pagdaragdag ng nawawalang panipi, pagtanggal ng mga sobra na kuwit, o pagtutuwid ng mga bracket.
  3. Nagbibigay ng naayos na JSON. Kadalasan, ang resulta ay handa nang i-parse o gamitin kaagad.
  4. Kung hindi kayang ayusin nang awtomatiko ang istruktura, ipapakita ang malinaw na error upang maayos mo ang iyong input.

Karaniwang Mga Error sa JSON at Paano Ito Ayusin

Narito ang mga karaniwang pagkakamali sa JSON na kayang ayusin ng tool na ito, kasama ang mga halimbawa para sa bawat isa:

Mga Key na Walang Panipi

Dapat ang mga susi ay nasa dobleng panipi.

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

Ayusin: Nagdadagdag ng dobleng panipi sa paligid ng mga object keys na walang panipi.

Gumamit ng Single Quotes

Tinatanggap lamang ng JSON ang doble na panipi para sa mga string.

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

Ayusin: Pinapalitan ang mga panaklong na solong kuwit ng dobleng kuwit para sa lahat ng mga string.

Mga Huling Kuwit

Hindi pinapayagan ang kuwit pagkatapos ng huling item.

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

Ayusin: Tinatanggal ang anumang huling kuwit.

Mga Hindi Tumutugmang o Hindi Nakasaradong Panaklong

Lahat ng panaklong at curly braces ay dapat maayos na magsara.

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

Ayusin: Magdagdag ng nawawalang panaklong o braces.

Nawawala o Sobrang Kuwit

Dapat paghiwalayin ng isang kuwit lamang ang mga item sa array at object.

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

Ayusin: Magdagdag ng nawawalang kuwit, o alisin ang mga dobleng kuwit.

Mayroong Mga Linyang Komento

Hindi pinapayagan ng karaniwang JSON ang mga komento (tulad ng // o /* ... */).

Before:
{ "id": 1, // ID ng gumagamit
 "active": true }
After:
{ "id": 1, "aktibo": totoo }

Ayusin: Tinatanggal ang mga linyang puna mula sa input.

Hindi Wastong Mga Format ng Numero

Mga payak na decimal na numero lamang ang wasto (walang NaN, Infinity, o hexadecimal).

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

Ayusin: Pinapalitan ang mga maling numero ng null.

Hindi Naka-escape na Mga Karakter ng Kontrol

Ang mga karakter tulad ng bagong linya sa mga string ay kailangang i-escape.

Before:
{ "msg": "Linya1
Linya2" }
After:
{ "msg": "Linya1\nLinya2" }

Ayusin: Tama ang pag-escape ng mga control character.

Doble na Mga Susi sa Obhekto

Nagdudulot ng kalituhan ang pagkakaroon ng magkaparehong susi sa iisang bagay.

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

Ayusin: Pinananatili lamang ang huling halaga para sa anumang duplikadong susi.

Maling Ayos ng Mga Array

Ang mga array ay dapat may mga panaklong at kuwit sa pagitan ng mga item.

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

Ayusin: Nagdagdag ng nawawalang kuwit sa pagitan ng mga elemento ng array.

Walang Laman ang Input o Puro Espasyo

Hindi maaaring walang laman ang JSON.

Before:
After:
wala
Ayusin: Nagbabalik ng null para sa walang laman na input.
Halimbawa: Mula sa Sirang JSON Patungo sa Tamang Ayos
Hindi wastong anyo ng JSON
{ gumagamit: 'alice', id: 42, mga_papel: [admin, 'editor',] // dagdag na kuwit
 aktibo: totoo }
Naayos na JSON Output
{
  "user": "alice",
  "id": 42,
  "roles": [
    "admin",
    "editor"
  ],
  "active": true
}
Paano Gamitin ang Tool na Ito para Ayusin ang JSON
  1. I-paste o i-type ang iyong sirang JSON sa editor sa ibaba.
  2. I-click ang 'Ayusin' upang awtomatikong matukoy at maayos ang mga karaniwang error sa syntax.
  3. Suriin ang naayos na output at kopyahin ang iyong naitamang JSON.
Laging suriin ang naayos na JSON bago gamitin ito para sa mahahalagang datos—maaaring kailanganin ang manu-manong pag-aayos para sa mga kumplikado o lubhang nasirang input.
Mga Halimbawa ng Code para sa Pag-ayos ng JSON
Tingnan kung paano ayusin ang JSON sa iba't ibang wika ng programming.
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)