മികച്ച വായനാക്ഷമതയ്ക്കായി ഒരു ഷെൽ സ്‌ക്രിപ്റ്റിൽ JSON ഫോർമാറ്റ് ചെയ്യുന്നതെങ്ങനെ

യുണിക്സ് ഷെൽ സ്ക്രിപ്റ്റുകളിൽ JSON റീഡബിൾ ആക്കുന്നു

JSON ഡാറ്റ അതിൻ്റെ അസംസ്‌കൃത രൂപത്തിൽ കൈകാര്യം ചെയ്യുന്നത് വെല്ലുവിളി നിറഞ്ഞതാണ്, പ്രത്യേകിച്ചും വായനാക്ഷമതയുടെ കാര്യത്തിൽ. Unix-അധിഷ്‌ഠിത സിസ്റ്റങ്ങളിൽ, JSON-നെ പ്രെറ്റി-പ്രിൻ്റ് ചെയ്യാൻ കഴിയുന്ന ഒരു ഷെൽ സ്‌ക്രിപ്റ്റ് ഉള്ളത് വിശകലനം ചെയ്യാനും ഡീബഗ് ചെയ്യാനും എളുപ്പമാക്കുന്നു.

ഈ ഗൈഡിൽ, ലളിതമായ Unix ഷെൽ കമാൻഡുകൾ ഉപയോഗിച്ച് കോംപാക്റ്റ് JSON ഒബ്‌ജക്റ്റുകളെ കൂടുതൽ മനുഷ്യർക്ക് വായിക്കാനാകുന്ന ഫോർമാറ്റിലേക്ക് എങ്ങനെ പരിവർത്തനം ചെയ്യാമെന്ന് ഞങ്ങൾ പര്യവേക്ഷണം ചെയ്യും. ഈ സമീപനം JSON ഡാറ്റ സംഘടിതവും ഘടനാപരവുമായ രീതിയിൽ പ്രദർശിപ്പിക്കുന്നുവെന്ന് ഉറപ്പാക്കുന്നു.

ഷെൽ സ്ക്രിപ്റ്റുകളിൽ JSON പ്രെറ്റി-പ്രിൻറിംഗ് മനസ്സിലാക്കുന്നു

The first script leverages the power of the jq command-line tool to pretty-print JSON data. The #!/bin/bash shebang indicates that the script should be run in the Bash shell. It starts by checking if jq is installed using command -v jq >ആദ്യ സ്ക്രിപ്റ്റ് JSON ഡാറ്റ പ്രെറ്റി-പ്രിൻ്റ് ചെയ്യുന്നതിന് jq കമാൻഡ്-ലൈൻ ടൂളിൻ്റെ ശക്തി പ്രയോജനപ്പെടുത്തുന്നു. സ്ക്രിപ്റ്റ് ബാഷ് ഷെല്ലിൽ പ്രവർത്തിപ്പിക്കണമെന്ന് #!/bin/bash shebang സൂചിപ്പിക്കുന്നു. jq കമാൻഡ് -v jq > /dev/null ഉപയോഗിച്ച് ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ടോ എന്ന് പരിശോധിച്ച് ഇത് ആരംഭിക്കുന്നു. jq കണ്ടെത്തിയില്ലെങ്കിൽ, സ്ക്രിപ്റ്റ് ഒരു പിശക് സന്ദേശത്തോടെ പുറത്തുകടക്കുന്നു. jq ലഭ്യമാകുമ്പോൾ, സ്‌ക്രിപ്റ്റ് stdin-ൽ നിന്ന് JSON ഇൻപുട്ട് വായിക്കുകയും അത് jq '.' ഉപയോഗിച്ച് പ്രോസസ്സ് ചെയ്യുകയും ചെയ്യുന്നു, ഇത് JSON ഫോർമാറ്റ് ചെയ്‌ത് വായിക്കാൻ കഴിയുന്ന രീതിയിൽ ഔട്ട്പുട്ട് ചെയ്യുന്നു. jq എളുപ്പത്തിൽ ലഭ്യമാകുന്ന Unix-അധിഷ്ഠിത സിസ്റ്റങ്ങൾക്ക് ഈ സമീപനം കാര്യക്ഷമമാണ്.

രണ്ടാമത്തെ സ്ക്രിപ്റ്റ് അതേ ചുമതല നിർവഹിക്കാൻ പൈത്തൺ ഉപയോഗിക്കുന്നു. #!/bin/bash shebang ബാഷ് ഷെല്ലിൻ്റെ ഉപയോഗത്തെ സൂചിപ്പിക്കുന്നു, അതേസമയം python3 -c 'import sys, json; പ്രിൻ്റ്(json.dumps(json.load(sys.stdin), ഇൻഡൻ്റ്=4))' എന്നത് ആവശ്യമായ മൊഡ്യൂളുകൾ ഇറക്കുമതി ചെയ്യുകയും JSON ഡാറ്റ പ്രെറ്റി-പ്രിൻ്റ് ചെയ്യുകയും ചെയ്യുന്ന ഒരു വൺ-ലൈനറാണ്. സ്‌ക്രിപ്റ്റ് sys.stdin ഉപയോഗിച്ച് stdin-ൽ നിന്ന് JSON വായിക്കുന്നു, അത് json.load ഉപയോഗിച്ച് പാഴ്‌സ് ചെയ്യുന്നു, തുടർന്ന് 4 സ്‌പെയ്‌സുകളുടെ ഇൻഡൻ്റ് ഉപയോഗിച്ച് json.dumps ഉപയോഗിച്ച് ഒരു മനുഷ്യനെ നിർമ്മിക്കുന്നു. - വായിക്കാവുന്ന ഫോർമാറ്റ്. jq ഇൻസ്റ്റാൾ ചെയ്തിട്ടില്ലെങ്കിലും പൈത്തൺ ലഭ്യമാണെങ്കിൽ ഈ രീതി പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്.

JSON ഫോർമാറ്റിംഗിനായി പേൾ പര്യവേക്ഷണം ചെയ്യുന്നു

മൂന്നാമത്തെ സ്ക്രിപ്റ്റ് JSON ഡാറ്റ ഫോർമാറ്റ് ചെയ്യാൻ Perl ഉപയോഗിക്കുന്നു. #!/usr/bin/perl shebang, പേൾ ഇൻ്റർപ്രെറ്ററിൽ സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കണമെന്ന് വ്യക്തമാക്കുന്നു. JSON ഡാറ്റ കൈകാര്യം ചെയ്യുന്നതിന് ആവശ്യമായ പ്രവർത്തനങ്ങൾ നൽകുന്ന JSON; ഉപയോഗിച്ച് JSON മൊഡ്യൂൾ ലോഡുചെയ്യുന്നതിലൂടെ ഇത് ആരംഭിക്കുന്നു. ലോക്കൽ $/, എന്നിവ ഉപയോഗിച്ച് സ്ക്രിപ്റ്റ് മുഴുവൻ JSON ഇൻപുട്ടും ഒരേസമയം വായിക്കുന്നു, decode_json ഉപയോഗിച്ച് ഇത് ഡീകോഡ് ചെയ്യുന്നു, ഒടുവിൽ 1 ആയി സജ്ജീകരിച്ച പ്രെറ്റി ഓപ്‌ഷൻ ഉപയോഗിച്ച് to_json ഉപയോഗിച്ച് പ്രെറ്റി പ്രിൻ്റ് ചെയ്യുന്നു. പേൾ ഇഷ്ടപ്പെട്ട സ്ക്രിപ്റ്റിംഗ് ഭാഷയായ പരിതസ്ഥിതികളിൽ പ്രവർത്തിക്കുമ്പോൾ ഈ സ്ക്രിപ്റ്റ് പ്രയോജനകരമാണ്.

കോംപാക്റ്റ് JSON ഡാറ്റ റീഡബിൾ ഫോർമാറ്റിലേക്ക് പരിവർത്തനം ചെയ്യുന്നതിനുള്ള ശക്തമായ പരിഹാരം ഈ സ്‌ക്രിപ്റ്റുകളിൽ ഓരോന്നും നൽകുന്നു. jq, പൈത്തൺ അല്ലെങ്കിൽ പേൾ ഉപയോഗിക്കുന്നതിലൂടെ, ഉപയോക്താക്കൾക്ക് അവരുടെ പരിസ്ഥിതിക്കും മുൻഗണനകൾക്കും ഏറ്റവും അനുയോജ്യമായ ഉപകരണം തിരഞ്ഞെടുക്കാനാകും. ഈ സ്ക്രിപ്റ്റുകൾ വായനാക്ഷമത വർദ്ധിപ്പിക്കുക മാത്രമല്ല, JSON ഡാറ്റാ ഘടനകളെ ഡീബഗ് ചെയ്യാനും മനസ്സിലാക്കാനും എളുപ്പമാക്കുന്നു.

#!/bin/bash
# This script uses jq to pretty-print JSON data

# Check if jq is installed
if ! command -v jq > /dev/null; then
  echo "jq is not installed. Please install jq to use this script."
  exit 1
fi

# Read JSON input from stdin and pretty-print it
jq '.'

#!/bin/bash
# This script uses Python to pretty-print JSON data

# Read JSON input from stdin and pretty-print it using Python
python3 -c 'import sys, json; print(json.dumps(json.load(sys.stdin), indent=4))'

#!/usr/bin/perl
# This script uses Perl to pretty-print JSON data
use JSON;
use strict;
use warnings;

my $json_text = do { local $/; <STDIN> };
my $json = decode_json($json_text);
print to_json($json, { pretty => 1 });

യുണിക്സ് ഷെല്ലിലെ JSON ഫോർമാറ്റിംഗിനുള്ള നൂതന സാങ്കേതിക വിദ്യകൾ

jq, പൈത്തൺ, പേൾ തുടങ്ങിയ അടിസ്ഥാന ഉപകരണങ്ങൾ ഉപയോഗിക്കുന്നതിനുമപ്പുറം, യുണിക്സ് ഷെൽ സ്ക്രിപ്റ്റുകളിൽ JSON കൈകാര്യം ചെയ്യുന്നതിനും മനോഹരമായി അച്ചടിക്കുന്നതിനും കൂടുതൽ വിപുലമായ രീതികളുണ്ട്. അത്തരത്തിലുള്ള ഒരു രീതിയിൽ Node.js അതിൻ്റെ ബിൽറ്റ്-ഇൻ JSON കഴിവുകൾ ഉപയോഗിക്കുന്നത് ഉൾപ്പെടുന്നു. JSON കൈകാര്യം ചെയ്യുന്നതിനായി Node.js ശക്തവും വഴക്കമുള്ളതുമായ അന്തരീക്ഷം പ്രദാനം ചെയ്യുന്നു, പ്രത്യേകിച്ചും കൂടുതൽ സങ്കീർണ്ണമായ ഡാറ്റാ ഘടനകൾ കൈകാര്യം ചെയ്യുമ്പോൾ. stdin, ഔട്ട്‌പുട്ട് ഫോർമാറ്റ് ചെയ്ത JSON എന്നിവയിൽ നിന്ന് വായിക്കാൻ ഒരു ലളിതമായ Node.js സ്‌ക്രിപ്റ്റ് സൃഷ്‌ടിക്കാം. JavaScript-ഹവി എൻവയോൺമെൻ്റുകളിൽ പ്രവർത്തിക്കുമ്പോഴോ JSON ഡാറ്റയുടെ അധിക പ്രോസസ്സിംഗ് ആവശ്യമായി വരുമ്പോഴോ ഈ രീതി പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്.

മറ്റൊരു നൂതന സാങ്കേതികതയിൽ JSON ഫോർമാറ്റിംഗിനായി sed, awk എന്നിവ ഉൾപ്പെടുന്നു. ഈ ടൂളുകൾ പരമ്പരാഗതമായി ടെക്സ്റ്റ് പ്രോസസ്സിംഗിനായി ഉപയോഗിക്കുമ്പോൾ, JSON ഫോർമാറ്റ് ചെയ്യുന്നതിനായി അവ ക്രിയാത്മകമായ രീതിയിൽ സംയോജിപ്പിക്കാം. ഉദാഹരണത്തിന്, JSON ഡാറ്റയുടെ ഘടനയെ അടിസ്ഥാനമാക്കി പുതിയ ലൈനുകളും ഇൻഡൻ്റേഷനും ചേർക്കാൻ awk ഉപയോഗിക്കാം, അതേസമയം ഔട്ട്‌പുട്ട് കൂടുതൽ പരിഷ്കരിക്കാൻ sed ഉപയോഗിക്കാം. ഈ രീതി സമർപ്പിത JSON ടൂളുകൾ ഉപയോഗിക്കുന്നതിനേക്കാൾ കൂടുതൽ സങ്കീർണ്ണവും അവബോധജന്യവുമാകുമെങ്കിലും, അടിസ്ഥാന Unix യൂട്ടിലിറ്റികൾ മാത്രം ലഭ്യമാകുന്ന പരിതസ്ഥിതികളിൽ ഇത് ഉപയോഗപ്രദമാകും.