כלי לתיקון JSON

תקן ושחזר אוטומטית קבצי JSON שבורים או שפגומים — בצורה בטוחה, מהירה וללא עלות.

כלי זה מתקן JSON שבור או לא תקין באמצעות תיקון שגיאות אוטומטי. הוא מתמקד בבעיות התחביר הנפוצות ביותר שנמצאות בנתונים מיוצאים, יומני רישום או קבצים שנערכו ידנית—כגון גרשיים חסרים, פסיקים מיותרים או סוגריים לא תואמים—ומפיק JSON תקין שניתן לפרש כקלט.

תקן את קובץ ה-JSON שלך למטה

איך תיקון JSON עובד

הכלי סורק את הקלט שלך לאיתור בעיות סינטקס טיפוסיות של JSON ומבצע תיקונים ממוקדים, כדי ליצור JSON תקין במידת האפשר.

  1. מפרש את הקלט ומאתר שגיאות תחביר נפוצות, כולל תווים לא חוקיים, סוגריים מונחים לא נכון וציטוטים שגויים במחרוזות.
  2. מיישם תיקונים לשגיאות נפוצות—כמו הוספת גרשיים חסרים, הסרת פסיקים מיותרים בסוף, או תיקון סוגריים.
  3. מייצא את קובץ ה-JSON המתוקן. ברוב המקרים, התוצאה מוכנה לעיבוד או לשימוש מיידי.
  4. אם המבנה אינו ניתן לתיקון באופן אוטומטי, תוצג שגיאה ברורה כדי שתוכל להתאים את הקלט שלך.

שגיאות JSON נפוצות ואיך לתקן אותן

להלן שגיאות JSON טיפוסיות שכלי זה יכול לתקן, עם דוגמאות לכל אחת:

מפתחות ללא גרשיים

המפתחות חייבים להיות במרכאות כפולות.

Before:
{ name: "בוב" }
After:
{ "name": "בוב" }

תיקון: מוסיף גרשיים כפולים סביב מפתחות אובייקט שלא היו במרכאות.

נעשה שימוש במרכאות בודדות

JSON מקבל רק גרשיים כפולים למחרוזות.

Before:
{ 'role': 'מנהל' }
After:
{ "role": "מנהל" }

תיקון: מחליף גרישים בודדים בגרשיים כפולים בכל המחרוזות.

פסיקים בסוף רשימה

לא מותר פסיק אחרי הפריט האחרון.

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

תיקון: מסיר פסיקים מיותרים בסוף.

סוגריים לא תואמים או לא סגורים

כל הסוגריים והמסולסלות חייבים להיסגר כראוי.

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

תיקון: מוסיף סוגריים או מסגרות חסרות.

פסיקים חסרים או מיותרים

פריטי מערך ואובייקט חייבים להיות מופרדים על ידי פסיק יחיד.

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

תיקון: מכניס פסיקים חסרים או מסיר כפילויות.

שורות הערה קיימות

JSON הסטנדרטי לא מאפשר הערות (כמו // או /* ... */).

Before:
{ "id": 1, // מזהה משתמש
 "active": true }
After:
{ "id": 1, "active": true }

תיקון: מסיר שורות הערה מהקלט.

פורמטים של מספרים לא תקינים

רק מספרים עשרוניים רגילים תקפים (ללא NaN, אינסוף או הקסדצימלי).

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

תיקון: מחליף מספרים לא חוקיים בערך null.

תווי בקרה בלתי מפוענחים

תוים כגון שורות חדשות במחרוזות חייבים להיות ממוינים.

Before:
{ "msg": "שורה1
שורה2" }
After:
{ "msg": "שורה1\nשורה2" }

תיקון: הברחת תווי בקרה בצורה נכונה.

מפתחות כפולים באובייקט

מפתחות כפולים באותו האובייקט גורמים לאי-בהירות.

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

תיקון: שומר רק על הערך האחרון לכל מפתח כפול.

מערכים מפורענים

מערכים חייבים לכלול סוגריים מרובעים ופסיקים בין הפריטים.

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

תקן: הוספת פסיקים חסרים בין אלמנטים במערך.

קלט ריק או רווחים בלבד

ה-JSON לא יכול להיות ריק.

Before:
After:
אפס
תיקון: מחזיר null עבור קלט ריק.
דוגמה: מ-JSON שבור לתיקון תקין
קלט JSON שבור או שגוי
{ user: 'אליס', id: 42, roles: [מנהל, 'עורך'] // פסיק נוסף
 active: true }
פלט JSON מתוקן
{
  "user": "אליס",
  "id": 42,
  "roles": [
    "מנהל",
    "עורך"
  ],
  "active": true
}
כיצד להשתמש בכלי תיקון JSON זה
  1. הדבק או הקלד את קובץ ה-JSON השבור שלך בעורך למטה.
  2. לחץ על 'תיקון' לזיהוי ותיקון אוטומטי של שגיאות תחביר נפוצות.
  3. סקור את הפלט המתוקן והעתק את קובץ ה-JSON המתוקן שלך.
תמיד בדקו את קובץ ה-JSON המתוקן לפני השימוש בו לנתונים קריטיים — ייתכן שיהיה צורך בהתאמות ידניות עבור קלטים מורכבים או פגומים מאוד.
דוגמאות קוד לתיקון JSON
ראה כיצד לתקן JSON בשפות תכנות שונות.
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)