JSON taisymo įrankis

Automatiškai taisykite ir atkurkite sugadintą arba klaidingai suformatuotą JSON – saugiai, greitai ir nemokamai.

Šis įrankis pataiso sugadintą ar neteisingą JSON, naudodamas automatizuotą klaidų taisymą. Jis pašalina dažniausias sintaksės problemas, dažnai pasitaikančias eksportuotuose duomenyse, žurnaluose ar rankiniu būdu redaguotuose failuose – tokias kaip trūkstamos kabutės, klaidingi kableliai ar neatitinkantys skliaustai – ir pateikia galiojantį, analizuojamą JSON failą.

Sutvarkykite jūsų JSON žemiau

Kaip veikia JSON taisymas

Įrankis patikrina jūsų įvestį dėl dažniausių JSON sintaksės klaidų ir taiko tikslingus taisymus, kiek įmanoma sugeneruodamas galiojančią JSON struktūrą.

  1. Analizuoja įvestį ir aptinka dažnas sintaksės klaidas, įskaitant neleistinas raides, neteisingai išdėstytas skliaustelius bei klaidingai užrašytas eilutės kabutes.
  2. Taiko pataisas dažnoms klaidoms – pavyzdžiui, prideda trūkstamas kabutes, pašalina nereikalingas kablelius arba taiso skliaustus.
  3. Išveda pataisytą JSON. Daugeliu atvejų rezultatas yra paruoštas iškart analizuoti arba naudoti.
  4. Jei struktūros automatiškai ištaisyti nepavyksta, rodoma aiški klaida, kad galėtumėte pakoreguoti savo įvestį.

Dažnos JSON Klaidos ir Kaip Jas Ištaisyti

Čia pateikti dažniausiai pasitaikantys JSON klaidų pavyzdžiai, kuriuos ši priemonė gali ištaisyti:

Nekituotos raktinės eilutės

Raktiniai žodžiai turi būti dvigubose kabutėse.

Before:
{ name: "Bobas" }
After:
{ "name": "Bobas" }

Pataisyti: Prideda kabutes aplink bet kuriuos nenurodytus objekto raktus.

Naudojamos viengubos kabutės

JSON priima tik dvigubas kabutes eilutėms.

Before:
{ 'pareigos': 'administratorius' }
After:
{ "role": "administratorius" }

Ištaisymas: Pakeičia viengubas kabutes dvigubomis visiems tekstiniams kintamiesiems.

Pabaigos kableliai

Po paskutinio elemento kablelis nėra leidžiamas.

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

Pataisyta: Pašalina bet kokias pabaigoje esančias kableles.

Nesuderintos arba neatidarytos skliaustelės

Visos skliaustelės ir kabliataškiai turi būti tinkamai uždaryti.

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

Pataisymai: Pridėti trūkstami uždarantys skliaustai arba kabliai.

Trūkstamos arba perteklinės kableliai

Masyvų ir objektų elementai turi būti atskirti vienu kableliu.

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

Taisyti: įterpia trūkstamas kablelius arba pašalina pasikartojimus.

Komentarų eilutės yra

Standartinis JSON formatas neleidžia komentarų (pvz., // arba /* ... */).

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

Taisyti: Pašalina komentarų eilutes iš įvesties.

Neteisingi skaičiaus formatai

Galioja tik paprasti dešimtainiai skaičiai (be NaN, begalybės ar šešioliktainių skaičių).

Before:
{ "val": Ne skaičius }
After:
{ "val": null }

Pataisymas: neteisingus skaičius pakeičia į null.

Nepageidaujami valdymo simboliai

Eilutėse, pavyzdžiui, naujos eilutės simboliai, turi būti pažymėti pabėgimo simboliu.

Before:
{ "msg": "Eilutė1
Eilutė2" }
After:
{ "msg": "Eilutė1\nEilutė2" }

Pataisyta: Valdymo simboliai teisingai pereinami.

Pasikartojantys raktai objekte

Dublikatai raktų tame pačiame objekte sukelia neaiškumų.

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

Pataisyta: palieka tik paskutinę pasikartojančio rakto reikšmę.

Netinkamai suformuotos masyvų struktūros

Masyvai turi turėti skliaustus ir kablelius tarp elementų.

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

Pataisyta: pridėti trūkstami kableliai tarp masyvo elementų.

Tuščia įvestis arba tik tarpai

JSON negali būti tuščias.

Before:
After:
null
Taisymas: Grazina null, kai ivestis tuscia.
Pavyzdys: Nuo sugadinto JSON iki teisingo taisymo
Klaidingai suformuotas JSON įvestis
{ user: 'alice', id: 42, roles: [admin, 'redaktorius',] // papildoma kablelis
 aktyvus: true }
Sutvarkytas JSON išvestis
{
  "user": "alicija",
  "id": 42,
  "roles": [
    "administratorius",
    "redaktorius"
  ],
  "active": true
}
Kaip naudotis šiuo JSON taisymo įrankiu
  1. Įklijuokite arba įveskite savo neteisingą JSON kodą į žemiau esantį redaktorių.
  2. Spustelėkite „Taisyti“, kad automatiškai aptiktumėte ir ištaisytumėte dažnas sintaksės klaidas.
  3. Peržiūrėkite pataisytą rezultatą ir nukopijuokite savo ištaisytą JSON.
Visada patikrinkite taisytą JSON prieš naudodami jį kritiniams duomenims – sudėtingiems ar stipriai pažeistiems įrašams gali prireikti rankinių pataisymų.
Kodo Pavyzdžiai JSON Taisyti
Sužinokite, kaip taisyti JSON įvairiomis programavimo kalbomis.
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)