Narzędzie do Naprawy JSON

Automatycznie naprawiaj i odzyskuj uszkodzony lub błędnie sformatowany JSON — bezpiecznie, szybko i za darmo.

To narzędzie naprawia uszkodzony lub niepoprawny JSON za pomocą zautomatyzowanej korekty błędów. Skupia się na najczęstszych problemach składniowych występujących w eksportowanych danych, logach lub ręcznie edytowanych plikach — takich jak brakujące cudzysłowy, zbędne przecinki czy niezgodne nawiasy — i generuje poprawny, parsowalny JSON jako wynik.

Napraw swój JSON poniżej

Jak działa naprawa JSON

Narzędzie skanuje Twoje dane wejściowe pod kątem typowych problemów z składnią JSON i stosuje ukierunkowane poprawki, aby w miarę możliwości wygenerować ważny plik JSON.

  1. Analizuje dane wejściowe i wykrywa typowe błędy składniowe, w tym nielegalne znaki, źle umieszczone nawiasy oraz niepoprawne cudzysłowy w łańcuchach znaków.
  2. Zastosowuje poprawki typowych błędów — takich jak dodawanie brakujących cudzysłowów, usuwanie zbędnych przecinków na końcu czy poprawianie nawiasów.
  3. Generuje naprawiony plik JSON. W większości przypadków wynik jest gotowy do natychmiastowego przetworzenia lub użycia.
  4. Jeśli nie można automatycznie naprawić struktury, wyświetlony zostanie jasny komunikat o błędzie, abyś mógł dostosować swoje dane wejściowe.

Najczęstsze błędy JSON i jak je naprawić

Oto typowe błędy JSON, które to narzędzie potrafi naprawić, wraz z przykładami dla każdego z nich:

Klucze bez cudzysłowów

Klucze muszą być zapisane w cudzysłowie podwójnym.

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

Poprawka: Dodaje cudzysłowy do kluczy obiektów, które wcześniej ich nie miały.

Użyto pojedynczych cudzysłowów

JSON akceptuje tylko podwójne cudzysłowy dla łańcuchów znaków.

Before:
{ 'rola': 'administrator' }
After:
{ "role": "administrator" }

Poprawka: Zastępuje pojedyncze cudzysłowy podwójnymi dla wszystkich łańcuchów tekstowych.

Przecinki końcowe

Po ostatnim elemencie nie wolno stawiać przecinka.

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

Naprawiono: Usunięto przecinki końcowe.

Niedopasowane lub niezamknięte nawiasy

Wszystkie nawiasy i klamry muszą być poprawnie zamknięte.

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

Poprawka: Dodaje brakujące zamykające nawiasy lub klamry.

Brakujące lub Nadmiarowe Przecinki

Elementy tablicy i obiektu muszą być oddzielone pojedynczym przecinkiem.

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

Naprawa: Wstawia brakujące przecinki lub usuwa duplikaty.

Komentarze w kodzie

Standardowy JSON nie pozwala na komentowanie (takie jak // lub /* ... */).

Before:
{ "id": 1, // identyfikator użytkownika
 "active": true }
After:
{ "id": 1, "active": true }

Naprawa: Usuwa linie z komentarzami z wejścia.

Nieprawidłowe formaty numerów

Dozwolone są wyłącznie zwykłe liczby dziesiętne (bez NaN, nieskończoności ani liczb szesnastkowych).

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

Poprawka: Zastępuje nieprawidłowe numery wartością null.

Nieprzetworzone znaki kontrolne

Znaki, takie jak nowe linie w ciągach tekstowych, muszą być poprzedzone znakiem ucieczki.

Before:
{ "msg": "Linia1
Linia2" }
After:
{ "msg": "Linia1\nLinia2" }

Naprawiono: Prawidłowe uciekanie znaków kontrolnych.

Zduplikowane klucze w obiekcie

Powtarzające się klucze w tym samym obiekcie powodują niejednoznaczność.

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

Poprawka: Zachowuje tylko ostatnią wartość dla każdego zduplikowanego klucza.

Niepoprawne tablice

Tablice muszą mieć nawiasy i przecinki między elementami.

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

Poprawka: Dodano brakujące przecinki między elementami tablicy.

Puste dane lub same spacje

JSON nie może być pusty.

Before:
After:
null
Poprawka: Zwraca null dla pustego wejścia.
Przykład: Od uszkodzonego JSON do poprawnej naprawy
Nieprawidłowy format JSON
{ user: 'alice', id: 42, roles: [admin, 'redaktor',] // dodatkowy przecinek
 aktywny: prawda }
Naprawiony wynik JSON
{
  "user": "alice",
  "id": 42,
  "roles": [
    "administrator",
    "redaktor"
  ],
  "active": true
}
Jak korzystać z tego narzędzia do naprawy JSON
  1. Wklej lub wpisz swój uszkodzony JSON w edytor poniżej.
  2. Kliknij „Napraw”, aby automatycznie wykryć i naprawić typowe błędy składniowe.
  3. Przejrzyj naprawiony wynik i skopiuj poprawiony plik JSON.
Zawsze sprawdzaj naprawiony JSON przed użyciem go do krytycznych danych — w przypadku złożonych lub mocno uszkodzonych danych mogą być potrzebne ręczne poprawki.
Przykłady kodu do naprawy JSON
Zobacz, jak naprawić JSON w różnych językach programowania.
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)