JSON:n korjaustyökalu

Korjaa ja palauta automaattisesti rikkinäinen tai väärinmuodostunut JSON – turvallisesti, nopeasti ja ilmaiseksi.

Tämä työkalu korjaa rikki tai virheelliset JSON-tiedostot automaattisen virheenkorjauksen avulla. Se kohdistuu yleisimpiin syntaksivirheisiin, joita esiintyy esimerkiksi viedyissä tiedoissa, lokitiedostoissa tai käsin muokatuissa tiedostoissa – kuten puuttuvat lainausmerkit, ylimääräiset pilkut tai epäsopivat sulkeet – ja tuottaa kelvollista, jäsennettävää JSON-muotoa ulostulona.

Korjaa JSONisi alla

Kuinka JSON-korjaus toimii

Työkalu tarkistaa syötteesi tyypilliset JSON-syntaksivirheet ja korjaa ne tarkasti, tuottaen mahdollisuuksien mukaan kelvollista JSON-dataa.

  1. Jäsentää syötteen ja paikantaa yleisimmät syntaksivirheet, kuten virheelliset merkit, väärin sijoitetut sulkeet ja virheelliset merkkijonon lainausmerkit.
  2. Korjaa yleisimpiä virheitä, kuten puuttuvien lainausmerkkien lisääminen, ylimääräisten pilkkujen poistaminen ja sulkujen korjaaminen.
  3. Tuottaa korjatun JSON-tiedoston. Useimmissa tapauksissa tulos on heti valmis jäsentää tai käyttää.
  4. Jos rakennetta ei voi korjata automaattisesti, näytetään selkeä virheilmoitus, jotta voit muokata syötettäsi.

Yleiset JSON-virheet ja kuinka korjata ne

Tässä on tyypillisiä JSON-virheitä, joita tämä työkalu voi korjata, esimerkkien kera:

Lainausmerkeittä avaimet

Avainsanojen tulee olla lainausmerkeissä.

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

Korjaa: Lisää lainausmerkit ympärille kaikille lainausmerkeiltä puuttuville objektiavaimille.

Yksittäiset lainausmerkit käytössä

JSON hyväksyy merkkijonoissa vain kaksinkertaiset lainausmerkit.

Before:
{ 'rooli': 'ylläpitäjä' }
After:
{ "rooli": "ylläpitäjä" }

Korjaa: Korvaa yksittäiset lainausmerkit kaksoislainausmerkeillä kaikissa merkkijonoissa.

Peräkkäiset pilkut

Viimeisen kohteen jälkeen ei saa käyttää pilkkua.

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

Korjaa: Poistaa kaikki loppuun jääneet pilkut.

Erimittaiset tai sulkemattomat hakasulkeet

Kaikkien sulkujen ja aaltosulkujen on sulkeuduttava oikein.

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

Korjaa: Lisää puuttuvat sulkevat hakasulkeet tai aaltosulkeet.

Puuttuvat tai ylimääräiset pilkut

Taulukon ja objektin kohteet on erotettava toisistaan yhdellä pilkulla.

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

Korjaa: Lisää puuttuvat pilkut tai poistaa kaksoiskappaleet.

Kommenttirivejä läsnä

Standardi JSON ei salli kommentteja (kuten // tai /* ... */).

Before:
{ "id": 1, // käyttäjän tunnus
 "active": true }
After:
{ "id": 1, "aktiivinen": true }

Korjaa: Poistaa kommenttirivit syötteestä.

Virheelliset numeromuodot

Kelvollisia ovat vain tavalliset desimaaliluvut (ei NaN, ääretöntä tai heksadesimaalilukuja).

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

Korjaa: Korvaa virheelliset numerot arvolla null.

Ei-escapoidut kontrollimerkit

Merkkijonoissa olevat merkit, kuten rivinvaihdot, on pakko merkitä pako-merkeillä.

Before:
{ "msg": "Rivi1
Rivi2" }
After:
{ "msg": "Rivi1\nRivi2" }

Korjattu: Hallintamerkit käsitellään oikein pelkistämällä.

Kaksoisavaimet objektissa

Saman objektin kaksoisavaimet aiheuttavat epäselvyyttä.

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

Korjaa: Säilyttää vain viimeisen arvon, jos avain esiintyy useasti.

Virheellisesti muotoillut taulukot

Taulukoissa tulee olla hakasulut ja pilkut kohteiden välillä.

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

Korjaa: Lisää puuttuvat pilkut taulukon alkioiden väliin.

Tyhjä syöte tai pelkkää välilyöntiä

JSON ei voi olla tyhjä.

Before:
After:
null
Korjaa: Palauttaa null-arvon tyhjälle syötteelle.
Esimerkki: Rikkinäisestä JSON-tiedostosta toimivaan korjaukseen
Väärin muotoiltu JSON-syöte
{ käyttäjä: 'alice', id: 42, roolit: [ylläpitäjä, 'toimittaja',] // ylimääräinen pilkku
 aktiivinen: tosi }
Korjattu JSON-lähtö
{
  "user": "alice",
  "id": 42,
  "roles": [
    "järjestelmänvalvoja",
    "muokkaaja"
  ],
  "active": true
}
Kuinka käyttää tätä JSON-korjaustyökalua
  1. Liitä tai kirjoita rikkinäinen JSON-tiedostosi alla olevaan editoriin.
  2. Napsauta 'Korjaa', niin tunnistamme ja korjaamme automaattisesti yleiset syntaksivirheet.
  3. Tarkista korjattu sisältö ja kopioi korjattu JSON-tiedostosi.
Tarkista aina korjattu JSON ennen sen käyttämistä kriittisiin tietoihin – monimutkaisiin tai voimakkaasti vaurioituneisiin tietoihin saattaa olla tarpeen tehdä manuaalisia säätöjä.
JSON-korjausesimerkit
Katso, miten JSON-tiedosto korjataan eri ohjelmointikielillä.
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)