JSON മുറുക്കൽ ഉപകരണം

തെറ്റായോ തകരാറിലായോ ഉള്ള JSON സ്വയം ശരിയാക്കി പുനരധിഷ്ഠാനം ചെയ്യുക—സുരക്ഷിതമായി, വേഗതയിൽ, എതുട്ടി കൊടുക്കാതെ.

ഈ ഉപകരണം തകര്‍ന്നോ അസാധുവായോ എത്തിയ JSON സ്വയം തിരുത്തി ശരിയാക്കുന്നു. ഇത് മദ്യാനായ്മ ലഭിച്ച ഡാറ്റ, ലോഗ്‌സുകള്‍, കൈകളാൽ തിരുത്തിയ ഫയലുകളിൽ കാണപ്പെടുന്ന സാധാരണമായ സിന്റാക്സ് പ്രശ്നങ്ങൾ—ഉദാഹരണത്തിന്, മിസ്സിംഗ് ക്വോട്ടുകൾ, തെറ്റായ കോമകൾ, പൊരുത്തക്കേടായ ബ്രാക്കറ്റുകൾ എന്നിവ ലക്ഷ്യംവെച്ച് ചിട്ടയുള്ള, പാഴ്സുചെയ്യാൻ കഴിയുന്ന JSON ഇറക്കുമതി നൽകുന്നു.

താഴെ നിങ്ങളുടെ JSON പരിച്ഛേദമാക്കുക

JSON റിപ്പെയർ എങ്ങനെ പ്രവർത്തിക്കുന്നു

ഈ ഉപകരണം നിങ്ങളുടെ ഇൻപുട്ടിൽ സാധാരണ JSON സിന്റാക്‌സ് പ്രശ്നങ്ങൾ കണ്ടെത്തുകയും ലക്ഷ്യമിട്ടു പരിഹാരങ്ങൾ നടപ്പിലാക്കുകയും ചെയ്യുന്നു, അതുവഴി സാധ്യമെങ്കിൽ സാക്ഷ്യവത്തായ JSON ഉൽപാദിപ്പിക്കുന്നു.

  1. ഇൻപുട്ട് വിവർത്തനം ചെയ്ത് സാധാരണ_Syntax_പിഴവുകൾ കണ്ടെത്തുന്നു, അവയിൽ ഉൾപ്പെടുന്നത് നിയമവിരുദ്ധ അക്ഷരങ്ങൾ, തെറ്റായ സ്ഥലത്തുള്ള ബ്രാക്കറ്റുകൾ, തെറ്റായ സ്റ്റ്രിംഗ് ക്വോട്ടുകൾ എന്നിവയാണ്.
  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 ഹോം أفريقيا comentar ഇല്ല (ഉദാ: // അല്ലെങ്കിൽ /* ... */).

Before:
{ "id": 1, // ഉപയോക്തൃ ഐഡി
 "active": true }
After:
{ "id": 1, "സജീവം": വാസ്തവം }

പരിഹാരം: ഇൻപുട്ടിലുണ്ടായ കമന്റ് വരികൾ നീക്കം ചെയ്യുന്നു.

അസാധുവായ നമ്പർ ഫോർമാറ്റുകൾ

സാധുവായത് വെറും ദശാംശ സംഖ്യകൾ മാത്രം ആണ് (NaN, അനന്തം, അല്ലെങ്കിൽ ഹെക്സാഡെസിമൽ അനുവദനീയമല്ല).

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

പരിഹാരം: അസാധുവായ നമ്പറുകൾ നുള്ളായി മാറ്റുന്നു.

ടെക്സ്റ്റ് നിയന്ത്രണ കഥാപാത്രങ്ങള്‍ (Unescaped Control Characters)

സ്ലിംഗ് കം പന്തികളില് ലെ ന്യൂലൈന് സ് പോലുള്ള അക്ഷരങ്ങള് kaçെ എസ്കേപ്പുചെയ്യണം.

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:
നല്ല
പതിപ്പിക്കുക: ശൂന്യമായ ഇന്‍പുട്ട് നല്‍കുമ്പോള്‍ നൾ മടക്കി നല്‍കുന്നത് പരിഹരിച്ചു.
ഉദാഹരണം: തകരാറുള്ള 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)