JSON labošanas rīks

Automātiski labojiet un atjaunojiet bojātu vai nepareizi izveidotu JSON — droši, ātri un bez maksas.

Šis rīks automātiski labo bojātu vai nederīgu JSON, izmantojot kļūdu automātisko koriģēšanu. Tas mērķē uz visbiežāk sastopamajām sintakses problēmām eksportētos datos, žurnālfailos vai manuāli rediģētos failos — piemēram, trūkstošajām pēdiņām, liekajiem komatiem vai neatbilstošajiem iekavām — un ģenerē pareizu, analizēšanai derīgu JSON izlaidi.

Salabo savu JSON zemāk

Kā darbojas JSON labošana

Rīks pārbauda jūsu ievadi, lai atrastu tipiskas JSON sintakses kļūdas, un veic mērķtiecīgus labojumus, nodrošinot derīgu JSON, kad tas iespējams.

  1. Analizē ievadi un nosaka biežākās sintakses kļūdas, tostarp neatļautus simbolus, nepareizi novietotas iekavas un nepareizu virkņu pēdiņas.
  2. Novērš bieži sastopamās kļūdas — piemēram, pievienojot trūkstošās pēdiņas, noņemot liekās komatus vai labošanai iekavas.
  3. Izvada laboto JSON. Lielākajā daļā gadījumu rezultāts ir tūlītēji gatavs parsēšanai vai izmantošanai.
  4. Ja struktūru nav iespējams automātiski labot, tiek parādīta skaidra kļūda, lai jūs varētu pielāgot savu ievadi.

Biežākās JSON kļūdas un to novēršanas veidi

Šeit ir tipiskas JSON kļūdas, ko šis rīks var labot, ar piemēriem katrai:

Atslēgas bez pēdiņām

Atslēgas jābūt divkāršajās pēdiņās.

Before:
{ name: "Bobs" }
After:
{ "name": "Bobs" }

Labojums: Pievieno dubultpēdiņas ap visiem neatbilstoši nemarķētiem objekta atslēgas nosaukumiem.

Izmantotas vienkāršās pēdiņas

JSON pieņem tikai dubultās pēdiņas virkņu apzīmēšanai.

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

Labojums: Aizstāj vienkāršās pēdiņas ar dubultajām pēdiņām visiem tekstiem.

Beigu komati

Pēc pēdējā elementa nav atļauts lietot komatu.

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

Labojums: Noņem visus liekos komatus teikuma beigās.

Nepareizi saliktas vai neaizvērtas iekavas

Visām iekavām un lauztās iekavām jābūt pareizi aizvērtām.

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

Labojums: Pievieno trūkstošos aizvadošos iekavas vai figūras iekavas.

Trūkstošie vai papildu komati

Masīva un objekta elementi jāatdala ar vienu komatu.

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

Labot: ievieto trūkstošās komatus vai noņem dublikātus.

Komentāru rindas klāt

Standarta JSON neļauj pievienot komentārus (piemēram, // vai /* ... */).

Before:
{ "id": 1, // lietotāja ID
 "active": true }
After:
{ "id": 1, "aktīvs": true }

Izlabošana: Noņem komentāru rindas no ievades.

Nederīgi numura formāti

Derīgas ir tikai vienkāršas decimāldaļskaitļu vērtības (nav pieļaujami NaN, bezgalība vai heksadecimālie skaitļi).

Before:
{ "val": Nav skaitlis}
After:
{ "val": null }

Labojums: Aizstāj nederīgus skaitļus ar nulli.

Neizlaisti vadības simboli

Rakstzīmes, piemēram, jaunas līnijas tekstos, jānorāda ar atbilstošu aizbēgšanas simbolu.

Before:
{ "msg": "Rinda1
Rinda2" }
After:
{ "msg": "Rinda1\nRinda2" }

Labojums: Kontrolrakstzīmes tiek pareizi aizstātas ar izvairīšanās secību.

Dublikātu atslēgas objektā

Dublikāta atslēgas tajā pašā objektā rada neskaidrības.

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

Labojums: Saglabā tikai pēdējo vērtību jebkuram dublikāta atslēgai.

Nepareizi veidotas masīvas

Masīvos jāizmanto iekavas, un starp vienumiem jāliek komati.

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

Labojums: Pievieno trūkstošās komatus starp masīva elementiem.

Tukšs ievades lauks vai tikai atstarpes

JSON nedrīkst būt tukšs.

Before:
After:
null
Labojums: Tukša ievade atgrieza null vērtību.
Piemērs: No bojāta JSON uz derīgu labošanas risinājumu
Nepareizi veidots JSON ievads
{ user: 'alice', id: 42, roles: [admin, 'redaktors',] // liekā komata
 active: true }
Salabots JSON izvades
{
  "user": "alice",
  "id": 42,
  "roles": [
    "administrators",
    "redaktore"
  ],
  "active": true
}
Kā izmantot šo JSON labošanas rīku
  1. Ielīmējiet vai ierakstiet savu bojāto JSON zemāk esošajā redaktorā.
  2. Noklikšķiniet uz 'Labot', lai automātiski atklātu un izlabotu biežākās sintakses kļūdas.
  3. Pārskatiet labošanas rezultātu un nokopējiet laboto JSON.
Vienmēr pārbaudiet laboto JSON pirms tā izmantošanas svarīgiem datiem — sarežģītām vai ļoti bojātām ievadēm var būt nepieciešama manuāla korekcija.
Koda piemēri JSON labošanai
Skatiet, kā labot JSON dažādās programmēšanas valodās.
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)