Whiz Tools

ஜேஎஸ்ஒஎன் வடிவமைப்பாளர்

இந்த எளிய கருவியுடன் உங்கள் ஜேஎஸ்ஒஎன் ஐ வடிவமைத்து அழகுபடுத்துங்கள்

வடிவமைக்கப்பட்ட ஜேஎஸ்ஒஎன் இங்கே தோன்றும்...

## JSON வடிவமைப்பாளர்

### அறிமுகம்

JSON (JavaScript Object Notation) என்பது எளிமையான தரவுகள் பரிமாற்ற வடிவமாகும், இது இணைய பயன்பாடுகளில் தரவுகள் பரிமாற்றத்திற்கான தரநிலையாக மாறியுள்ளது. அதன் எளிமையைப் புறக்கணித்தாலும், JSON தரவுகள் குறுக்கீடு செய்யப்பட்ட அல்லது சரியான வடிவமைப்பின்மை காரணமாக வாசிக்க கடினமாக மாறலாம். இந்த கருவி உங்கள் கச்சா, வடிவமைக்கப்படாத JSON சரங்களை நன்கு அமைக்கப்பட்ட, இடைவெளியுடன் உள்ள வடிவத்திற்கு மாற்ற உதவுகிறது, இது வாசிக்க மற்றும் பகுப்பாய்வு செய்ய மிகவும் எளிது.

JSON வடிவமைப்பு (அல்லது "அழகுபடுத்துதல்") ஒழுங்கான இடைவெளி, வரி உடைப்புகள் மற்றும் இடைவெளிகளைச் சேர்க்கிறது, இது JSON தரவுகளின் அடிப்படைக் கட்டமைப்பைக் கண்ணோட்டமாக காட்டுகிறது. இது குறிப்பாக சிக்கலான அடுக்கீட்டுள்ள பொருட்கள் அல்லது பெரிய தரவுத்தொகுப்புகளுடன் பணியாற்றும் போது பயனுள்ளதாக இருக்கும், அங்கு உருப்படிகளுக்கிடையிலான உறவுகளைப் புரிந்துகொள்ளுவது கடினமாக இருக்கும்.

எங்கள் JSON வடிவமைப்பாளர் கருவி உங்கள் JSON தரவுகளை அழகுபடுத்துவதற்கான எளிய இடைமுகத்தை வழங்குகிறது, இது சரியான இடைவெளி மற்றும் கட்டமைப்புடன், மனிதர்களுக்கு வாசிக்கவும் இயந்திரங்களுக்கு செல்லுபடியாகவும் இருக்கும்.

### JSON ஒழுங்கமைப்பு மற்றும் கட்டமைப்பு

JSON இரண்டு முதன்மை கட்டமைப்புகளை அடிப்படையாகக் கொண்டுள்ளது:

1. **பொருட்கள்**: { } குறியீடுகளில் மூடிய பெயர்/மதிப்பு ஜோடிகளின் தொகுப்புகள். ஒவ்வொரு பெயருக்கும் ஒரு கொள்கை (:) பிறகு வருகிறது மற்றும் ஜோடிகள் காமாக்கள் (,) மூலம் பிரிக்கப்படுகின்றன.

json {"name": "John", "age": 30, "city": "New York"}


2. **அணிகள்**: [ ] குறியீடுகளில் மூடிய மதிப்புகளின் வரிசைகள். மதிப்புகள் காமாக்கள் (,) மூலம் பிரிக்கப்படுகின்றன.

json ["apple", "banana", "cherry"]


JSON மதிப்புகள்:
- Strings (இரு மேற்கோள்களில்): `"Hello World"`
- எண்கள்: `42` அல்லது `3.14159`
- Boolean: `true` அல்லது `false`
- Null: `null`
- பொருட்கள்: `{"key": "value"}`
- அணிகள்: `[1, 2, 3]`

சரியான JSON இல் இந்த ஒழுங்கமைப்பு விதிகளை பின்பற்ற வேண்டும்:
- பெயர்கள் இரு மேற்கோள்களில் உள்ள சரங்களை ஆக இருக்க வேண்டும்
- மதிப்புகள் செல்லுபடியாகும் JSON தரவுப் வகைகளில் ஒன்றாக இருக்க வேண்டும்
- எந்த பின்வட்டார காமா (,) இல்லாமல் இருக்க வேண்டும்
- கருத்துகள் அனுமதிக்கப்படவில்லை
- செயல்பாடுகள் அல்லது முறைமைகள் அனுமதிக்கப்படவில்லை

சாதாரண ஒழுங்கமைப்பு பிழைகள்:
- குறியீடுகள்/குறியீடுகள் இல்லாமல்
- குறியீடுகள் அல்லது கூடைகள் இல்லாமல்
- சொற்றொடர்களுக்குப் பதிலாக ஒரு மேற்கோள் பயன்படுத்துதல்
- பின்வட்டார காமா உள்ளடக்கம்
- மதிப்பாக வரையறுக்கப்படாதது

### JSON வடிவமைப்பு எப்படி வேலை செய்கிறது

JSON வடிவமைப்பு, குறுக்கீடு செய்யப்பட்ட, அழுத்தப்பட்ட JSON ஐ வாசிக்கக்கூடிய வடிவத்திற்கு மாற்றுகிறது:

1. **பார்சிங்**: JSON சரம் முதலில் செல்லுபடியாகுமா என்பதை உறுதி செய்யவும், தரவுப் கட்டமைப்பின் நினைவகத்தில் உள்ள பிரதிநிதியை உருவாக்கவும் பார்ச் செய்யப்படுகிறது.

2. **இடைவெளி**: ஒவ்வொரு அடுக்கு அளவிலும் உள்ள பொருட்கள் மற்றும் அணிகள் இடைவெளியுடன் (பொதுவாக 2 அல்லது 4 இடைவெளிகள்) அடுக்குகளை கண்ணோட்டமாகக் காட்டுகிறது.

3. **வரி உடைப்புகள்**: ஒவ்வொரு சொத்து அல்லது அணியின் உருப்படியின் பிறகு புதிய வரிகள் சேர்க்கப்படுகின்றன.

4. **இடைவெளிகள்**: கொள்கைகள் மற்றும் காமாக்கள் சுற்றிலும் ஒழுங்கான இடைவெளிகள் சேர்க்கப்படுகின்றன.

உதாரணமாக, இந்த அழுத்தப்பட்ட JSON:

json {"name":"John Doe","age":30,"address":{"street":"123 Main St","city":"Anytown","state":"CA"},"hobbies":["reading","hiking","photography"]}


இந்த வடிவமைக்கப்பட்ட JSON ஆக மாறுகிறது:

json { "name": "John Doe", "age": 30, "address": { "street": "123 Main St", "city": "Anytown", "state": "CA" }, "hobbies": [ "reading", "hiking", "photography" ] }


எங்கள் வடிவமைப்பாளர் ஒவ்வொரு அடுக்கிற்கும் 2 இடைவெளிகள் என்ற தரநிலையைப் பயன்படுத்துகிறது, இது மேம்பாட்டு சமுதாயத்தில் ஒரு பொதுவான 관행மாகும் மற்றும் வாசிக்கவும் புரிந்துகொள்ளவும் நல்ல சமநிலையை வழங்குகிறது.

### JSON சரிபார்த்தல்

JSON வடிவமைப்பின் ஒரு முக்கிய அம்சம் சரிபார்த்தல். JSON வடிவமைக்கப்படுவதற்கு முன், அது JSON விவரக்குறிப்பின் படி ஒழுங்கமைப்பில் செல்லுபடியாக வேண்டும். பொதுவான சரிபார்ப்பு பிழைகள் உள்ளன:

1. **ஒழுங்கமைப்பு பிழைகள்**:
   - சொத்து பெயர்களுக்கான மேற்கோள்கள் இல்லாமல்
   - காமாக்கள் இல்லாமல் அல்லது அதிகமாக
   - தவறான அடுக்கீட்டுகள்
   - மூடிய சொற்றொடர்கள், பொருட்கள் அல்லது அணிகள் இல்லாமல்

2. **தரவுப் வகை பிழைகள்**:
   - JavaScript-க்கு குறிப்பிட்ட மதிப்புகளைப் பயன்படுத்துதல், உதாரணமாக `undefined` அல்லது `NaN`
   - செயல்பாடுகள் அல்லது முறைமைகளை உள்ளடக்கம்
   - சரங்களைப் பயன்படுத்தும் போது ஒருங்கிணைக்கப்பட்ட குறியீடுகள்

நீங்கள் செல்லுபடியாகாத JSON-ஐ சந்திக்கும்போது, பிழைச் செய்தி சிக்கல்களை அடையாளம் காண உதவுகிறது. பெரும்பாலான JSON பார்சர்கள், பார்சிங் தோல்வியுற்ற இடத்தை குறிக்கின்றன, இது சிக்கல்களை கண்டறிய உதவுகிறது. எங்கள் கருவி உங்கள் JSON தரவுகளில் சிக்கல்களை அடையாளம் காண மற்றும் சரிசெய்ய உதவுவதற்கான தெளிவான பிழைச் செய்திகளை வழங்குகிறது.

### பயன்பாட்டு வழிகள்

JSON வடிவமைப்பு பல்வேறு சூழ்நிலைகளில் பயனுள்ளதாக இருக்கும்:

#### API மேம்பாடு மற்றும் சோதனை

RESTful API-களுடன் பணியாற்றும் போது, வடிவமைக்கப்பட்ட JSON:
- பதிலளிக்கும் payloads ஐ ஆய்வு செய்ய
- கேள்வி உட்பட சோதனை செய்ய
- API எடுத்துக்காட்டுகளை ஆவணமாக்க
- தரவுப் கட்டமைப்புகள் எதிர்பார்ப்புகளைப் பொருந்துகிறதா என்பதை சரிபார்க்க

#### கட்டமைப்பு மேலாண்மை

பல மாடர்ன் பயன்பாடுகள் JSON-ஐ கட்டமைப்பிற்காகப் பயன்படுத்துகின்றன:
- பயன்பாட்டு அமைப்புகள் கோப்புகள்
- சூழல் கட்டமைப்புகள்
- கட்டமைப்பு மற்றும் வெளியீட்டு விவரக்குறிப்புகள்
- கோடாக் கட்டமைப்புகள் (எடுத்துக்காட்டாக, AWS CloudFormation, Terraform)

#### தரவுப் பகுப்பாய்வு மற்றும் காட்சியமைப்பு

வடிவமைக்கப்பட்ட JSON உதவுகிறது:
- தரவுத்தொகுப்புகளை ஆராய
- காட்சியமைப்பிற்கான தரவுகளைத் தயாரிக்க
- தரவுப் திட்டங்களைப் புரிந்துகொள்ள
- கட்டமைக்கப்பட்ட தரவுகளில் மாதிரிகளை அடையாளம் காண

#### பிழைதிருத்தம் மற்றும் சிக்கல்களை தீர்க்க

சரியாக வடிவமைக்கப்பட்ட JSON முக்கியமாக இருக்கும்:
- இணைய பயன்பாடுகளை பிழைதிருத்த
- localStorage அல்லது sessionStorage ஐ ஆய்வு
- நெட்வொர்க் பதில்களை ஆய்வு
- தரவுப் ஒருங்கிணைப்பு சிக்கல்களை தீர்க்க

#### கல்வி நோக்கங்கள்

தெளிவான JSON வடிவமைப்பு பயனுள்ளதாக இருக்கும்:
- தரவுப் கட்டமைப்புகளை கற்பிக்க
- அடுக்கீட்டின் உறவுகளை விளக்க
- API கருத்துக்களை விளக்க
- தரவுப் மாதிரிகள் கொள்கைகளை விளக்க

### மாற்று வழிகள்

எங்கள் வலை அடிப்படையிலான JSON வடிவமைப்பாளர் விரைவான வடிவமைப்புப் பணிகளுக்கான வசதியாக இருந்தாலும், பல்வேறு சூழ்நிலைகளுக்கான பல மாற்று வழிகள் உள்ளன:

#### உலாவி மேம்பாட்டு கருவிகள்

மாடர்ன் உலாவிகள் JSON வடிவமைப்பு திறன்களை உள்ளடக்குகின்றன:
- Chrome மற்றும் Edge DevTools நெட்வொர்க் அட்டவணையில் JSON பதில்களை தானாக வடிவமைக்கின்றன
- Firefox இன் JSON காட்சியாளர் தொடர்பான மரபுகளை வழங்குகிறது
- JSONView போன்ற உலாவி நீட்சிகள் உலாவியில் நேரடியாக JSON ஐ வடிவமைக்கலாம்

#### குறியீட்டு எடிட்டர்கள் மற்றும் IDEகள்

மிகவும் மேம்பாட்டு சூழல்களில் JSON வடிவமைப்பு வழங்கப்படுகிறது:
- Visual Studio Code இல் உள்ள JSON வடிவமைப்பு (Alt+Shift+F)
- JetBrains IDEகள் (WebStorm, IntelliJ) சக்திவாய்ந்த JSON கருவிகளை உள்ளடக்குகின்றன
- Sublime Text மற்றும் Atom இல் நீட்சிகள் மூலம் JSON வடிவமைப்பை ஆதரிக்கின்றன

#### கட்டளை வரி கருவிகள்

தரையினரைப் பயன்படுத்துபவர்களுக்கு அல்லது தானியங்கி:
- `jq` ஒரு சக்திவாய்ந்த கட்டளை வரி JSON செயலி
- `json_pp` பல Unix அமைப்புகளில் முன்பே நிறுவப்பட்டுள்ளது
- `python -m json.tool` Python-ஐப் பயன்படுத்தி விரைவான வடிவமைப்பை வழங்குகிறது

#### நிரலாக்க அணுகுமுறைகள்

அனுப்புகளில் JSON ஐ வடிவமைக்கும் போது:

javascript // JavaScript const formatted = JSON.stringify(jsonObject, null, 2);

python

Python

import json formatted = json.dumps(json_object, indent=2)

java // Java with Gson Gson gson = new GsonBuilder().setPrettyPrinting().create(); String formatted = gson.toJson(jsonObject);

ruby

Ruby

require 'json' formatted = JSON.pretty_generate(json_object)

php // PHP formatted=jsonencode(formatted = json_encode(jsonObject, JSON_PRETTY_PRINT);


### வரலாறு

JSON-ஐ Douglas Crockford 2000-களின் ஆரம்பத்தில் XML-க்கு எளிதான மாற்றமாக உருவாக்கினார். இந்த வடிவம் JavaScript பொருள் இலக்கணம் சின்கரமாக இருந்தது, ஆனால் மொழி சுதந்திரமாக வடிவமைக்கப்பட்டது. 2006-ல், JSON அதிகாரப்பூர்வமாக RFC 4627 இல் விவரிக்கப்பட்டது, மேலும் அதன் எளிமை மற்றும் JavaScript உடன் ஒத்திசைவு காரணமாக இது விரைவாக பிரபலமாக மாறியது.

JSON-க்கு முன்பு, XML தரவுகள் பரிமாற்றத்திற்கான பிரதான வடிவமாக இருந்தது, ஆனால் அதன் பரந்த மற்றும் சிக்கலான தன்மை பல பயன்பாடுகளுக்கு சிரமமாக இருந்தது. JSON ஒரு குறுகிய குறியீட்டை வழங்கியது, இது மனிதர்களுக்கும் இயந்திரங்களுக்கும் வாசிக்கவும் எழுதவும் எளிதாக உள்ளது. இது JavaScript-இன் பொருள் மாதிரிக்கு முற்றிலும் ஒத்ததாக இருந்ததால், இணைய பயன்பாடுகளுக்கான இயற்கையான தேர்வாக மாறியது.

JSON-ன் ஏற்றத்தை 2000-களின் நடுப்பகுதியில் AJAX மற்றும் RESTful API-களின் எழுச்சியுடன் கூடியது. 2010-களில், இது இணைய API-க்கள், கட்டமைப்பு கோப்புகள் மற்றும் MongoDB மற்றும் CouchDB போன்ற NoSQL தரவுத்தொகுப்புகளில் பரவலாகக் கொண்டு வந்தது.

இன்று, JSON மொத்தமாக அனைத்து நிரலாக்க மொழிகளால் ஆதரிக்கப்படுகிறது மற்றும் இணையத்தில் எண்ணற்ற பயன்பாடுகளில் பயன்படுத்தப்படுகிறது. அதன் எளிமை, நெகிழ்வுத்தன்மை மற்றும் உலகளாவிய ஆதரவு, இது நவீன கணினியில் மிகவும் முக்கியமான தரவுப் வடிவமாக மாறியுள்ளது.

### குறியீட்டு எடுத்துக்காட்டுகள்

பல்வேறு நிரலாக்க மொழிகளில் JSON-ஐ வடிவமைப்பதற்கான எடுத்துக்காட்டுகள் இங்கே உள்ளன:

javascript // JavaScript JSON வடிவமைப்பு function formatJSON(jsonString) { try { const parsedData = JSON.parse(jsonString); return JSON.stringify(parsedData, null, 2); } catch (error) { return பிழை: ${error.message}; } }

// எடுத்துக்காட்டு பயன்பாடு const rawJSON = '{"name":"John","age":30,"city":"New York"}'; console.log(formatJSON(rawJSON));

python

Python JSON வடிவமைப்பு

import json

def format_json(json_string): try: parsed_data = json.loads(json_string) return json.dumps(parsed_data, indent=2) except json.JSONDecodeError as e: return f"பிழை: {str(e)}"

எடுத்துக்காட்டு பயன்பாடு

raw_json = '{"name":"John","age":30,"city":"New York"}' print(format_json(raw_json))

java // Java JSON வடிவமைப்பு Gson உடன் import com.google.gson.Gson; import com.google.gson.GsonBuilder; import com.google.gson.JsonSyntaxException;

public class JSONFormatter { public static String formatJSON(String jsonString) { try { Gson gson = new GsonBuilder().setPrettyPrinting().create(); Object parsedJson = gson.fromJson(jsonString, Object.class); return gson.toJson(parsedJson); } catch (JsonSyntaxException e) { return "பிழை: " + e.getMessage(); } }

public static void main(String[] args) {
    String rawJSON = "{\"name\":\"John\",\"age\":30,\"city\":\"New York\"}";
    System.out.println(formatJSON(rawJSON));
}

}

php // PHP JSON வடிவமைப்பு function formatJSON(jsonString) { result = json_decode(jsonString);if(jsonlasterror()!==JSONERRORNONE)return"பிழை:".jsonlasterrormsg();returnjsonencode(jsonString); if (json_last_error() !== JSON_ERROR_NONE) { return "பிழை: " . json_last_error_msg(); } return json_encode(result, JSON_PRETTY_PRINT); }

// எடுத்துக்காட்டு பயன்பாடு rawJSON=′"name":"John","age":30,"city":"NewYork"′;echoformatJSON(rawJSON = '{"name":"John","age":30,"city":"New York"}'; echo formatJSON(rawJSON);

ruby

Ruby JSON வடிவமைப்பு

require 'json'

def format_json(json_string) begin parsed_data = JSON.parse(json_string) return JSON.pretty_generate(parsed_data) rescue JSON::ParserError => e return "பிழை: #{e.message}" end end

எடுத்துக்காட்டு பயன்பாடு

raw_json = '{"name":"John","age":30,"city":"New York"}' puts format_json(raw_json)

csharp // C# JSON வடிவமைப்பு Newtonsoft.Json உடன் using Newtonsoft.Json; using System;

class JSONFormatter { public static string FormatJSON(string jsonString) { try { object parsedJson = JsonConvert.DeserializeObject(jsonString); return JsonConvert.SerializeObject(parsedJson, Formatting.Indented); } catch (JsonException e) { return $"பிழை: {e.Message}"; } }

static void Main()
{
    string rawJSON = "{\"name\":\"John\",\"age\":30,\"city\":\"New York\"}";
    Console.WriteLine(FormatJSON(rawJSON));
}

}

go // Go JSON வடிவமைப்பு package main

import ( "encoding/json" "fmt" )

func formatJSON(jsonString string) string { var parsedData interface{} err := json.Unmarshal([]byte(jsonString), &parsedData) if err != nil { return fmt.Sprintf("பிழை: %s", err.Error()) }

formattedBytes, err := json.MarshalIndent(parsedData, "", "  ")
if err != nil {
    return fmt.Sprintf("பிழை: %s", err.Error())
}

return string(formattedBytes)

}

func main() { rawJSON := {"name":"John","age":30,"city":"New York"} fmt.Println(formatJSON(rawJSON)) }


### எல்லைச் சந்தேகங்கள் மற்றும் கருத்துகள்

JSON வடிவமைப்புடன் பணியாற்றும்போது, இந்த சாத்தியமான சவால்களைப் பற்றி கவனமாக இருக்கவும்:

#### பெரிய JSON கோப்புகள்

மிகவும் பெரிய JSON கோப்புகள் (பல மெகாபைட்டுகள் அல்லது அதற்கு மேலே) உலாவி அடிப்படையிலான வடிவமைப்புகளில் செயல்திறனை ஏற்படுத்தலாம். அத்தகைய சந்தர்ப்பங்களில்:
- `jq` போன்ற கட்டளை வரி கருவிகளைப் பயன்படுத்தவும்
- JSON ஐ சிறிய துண்டுகளாகப் பிரிக்கவும்
- முழு கோப்பை நினைவகத்தில் ஏற்றாமல் செயலாக்குவதற்கான ஸ்ட்ரீமிங் பார்சர்களைப் பயன்படுத்தவும்

#### ஆழமான அடுக்கீட்டுகள்

மிகவும் ஆழமான JSON (10-20 அடுக்குகளுக்கு மேல்) வடிவமைக்கப்பட்டாலும், கண்ணோட்டமாகவே சிக்கலாக மாறலாம். இத்தகைய சந்தர்ப்பங்களில்:
- சtructureஐ சாத்தியமானால் சமமாக்கவும்
- சுருக்கமான JSON காட்சியாளர்களைப் பயன்படுத்தவும்
- JSON இன் குறிப்பிட்ட பகுதிகளைப் பயன்படுத்தி வேலை செய்யவும்

#### சிறப்பு எழுத்துகள் மற்றும் Unicode

JSON Unicode-ஐ ஆதரிக்கிறது, ஆனால் சில வடிவமைப்பாளர்கள் குறிப்பிட்ட எழுத்துக்களுடன் சிக்கல்களை சந்திக்கலாம்:
- உங்கள் வடிவமைப்பாளர் எமோஜி மற்றும் பிற Unicode எழுத்துக்களை சரியாக கையாளுமா என்பதை உறுதி செய்யவும்
- கட்டுப்பாட்டு எழுத்துக்களும்逃序序列்களும் கவனமாக இருக்கவும்
- வடிவமைக்கப்பட்ட வெளியீடு அனைத்து முதன்மை எழுத்துக்களைப் பாதுகாக்குமா என்பதைச் சரிபார்க்கவும்

#### எண்களின் துல்லியம்

JSON எண்களுக்கு துல்லியத்தை குறிப்பிடவில்லை, இது மிகவும் பெரிய முழு எண்கள் அல்லது மிதவெண் மதிப்புகளுடன் சிக்கல்களை ஏற்படுத்தலாம்:
- JavaScript-இல் 53 பிட்டுகளை மீறிய முழு எண்களுக்கு சில செயல்பாடுகள் துல்லியத்தை இழக்கலாம் என்பதைக் கவனிக்கவும்
- துல்லியமான எண்களைப் பெற string பிரதிநிதிகளைப் பயன்படுத்தவும்
- உங்கள் பயன்பாடு உயர் துல்லியத்தைப் பெற வேண்டும் என்றால் கடுமையான மதிப்புகளைப் சோதிக்கவும்

#### காலியான பொருட்கள் மற்றும் அணிகள்

செல்லுபடியாகும் JSON-ல் காலியான பொருட்கள் `{}` மற்றும் அணிகள் `[]` உள்ளன, இது சரியாக வடிவமைக்கப்பட வேண்டும்:
- காலியான பொருட்கள் `{}` என்ற வடிவில் காணப்பட வேண்டும்
- காலியான அணிகள் `[]` என்ற வடிவில் காணப்பட வேண்டும்
- அடுக்கீட்டுள்ள காலியான கட்டமைப்புகள் சரியான இடைவெளியுடன் இருக்க வேண்டும்

### மேற்கோள்கள்

1. [JSON.org](https://www.json.org/) - அதிகாரப்பூர்வ JSON விவரக்குறிப்பு இணையதளம்
2. [RFC 8259](https://tools.ietf.org/html/rfc8259) - JSON தரவுப் பரிமாற்ற வடிவம்
3. [MDN வலை ஆவணங்கள்: JSON](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON) - JavaScript இல் JSON பற்றிய விரிவான ஆவணங்கள்
4. [JSON Lint](https://jsonlint.com/) - ஒரு பிரபலமான ஆன்லைன் JSON சரிபார்த்தல் கருவி
5. [jq](https://stedolan.github.io/jq/) - ஒரு எளிதான மற்றும் நெகிழ்வான கட்டளை வரி JSON செயலி

தொடர்புடைய கருவிகள்

கால அலகு மாற்றி: ஆண்டுகள், நாட்கள், மணித்தியாலங்கள், நொடிகள்
பேஸ்64 குறியாக்கி மற்றும் குறியாக்கி: உரையை பேஸ்64 க்கு/இல் மாற்றவும்
உரை மாற்றி கருவி: எந்த உரையில் எழுத்துக்களின் வரிசையை மாற்றவும்
யூனிக்ஸ் டைம் ஸ்டாம்பை தேதியாக மாற்றி: 12/24 மணி நேர வடிவம் ஆதரவு
கோணமிட்ட சமன்பாட்டை தீர்க்கும் கருவி: ax² + bx + c = 0 இல் அடிப்படைகளை கண்டறியவும்
சீரற்ற API விசை உருவாக்கி: பாதுகாப்பான 32-அகர வரிசைகளை உருவாக்கவும்
Feedback