ലിനക്സിലെ വേരിയബിളുകളുടെ താരതമ്യം. ബാഷിലെ കേസ്-ഇൻസെൻസിറ്റീവ് സ്ട്രിംഗ് താരതമ്യം. ശൂന്യമായ മൂല്യത്തിനായി ഒരു സ്ട്രിംഗ് പരിശോധിക്കുന്നു

ഈ വിഷയം "ബാഷ് ഷെൽ ലാംഗ്വേജ്" പരമ്പരയിലെ നാലാമത്തെ വിഷയമാണ്. സോപാധിക പ്രസ്താവനകളായി ഭാഷയുടെ അത്തരം നിയന്ത്രണ ഘടനകളെക്കുറിച്ച് അദ്ദേഹം സംസാരിക്കും. എന്നാൽ അവയുടെ വിവരണത്തിലേക്ക് പോകുന്നതിനുമുമ്പ്, ചുവടെയുള്ള മെറ്റീരിയലിൻ്റെ പരിഗണന കൂടുതൽ മനസ്സിലാക്കാവുന്നതാക്കുന്ന ചില സൂക്ഷ്മതകളിൽ വസിക്കേണ്ടത് ആവശ്യമാണ്.
ആദ്യം, ഒരു കമാൻഡ് ലിസ്റ്റ് എന്താണെന്ന് നോക്കാം. കമാൻഡ് ലിസ്റ്റ് എന്നത് ഒരൊറ്റ കമാൻഡ്, പൈപ്പ്‌ലൈൻ അല്ലെങ്കിൽ ഇനിപ്പറയുന്ന ഓപ്പറേറ്റർമാരിൽ ഒന്ന് വേർതിരിക്കുന്ന കമാൻഡുകളുടെ/പൈപ്പുകളുടെ സീക്വൻസാണ്: ";", "&&", "||", ഒരു അർദ്ധവിരാമം കൊണ്ട് അവസാനിപ്പിക്കുന്നു.
; - നിരവധി കമാൻഡുകളുടെ തുടർച്ചയായ എക്സിക്യൂഷൻ ഓപ്പറേറ്റർ. ഓരോ തുടർന്നുള്ള കമാൻഡും മുമ്പത്തേത് പൂർത്തിയാക്കിയതിനുശേഷം മാത്രമേ എക്സിക്യൂട്ട് ചെയ്യാൻ തുടങ്ങുകയുള്ളൂ (അത് വിജയിച്ചോ ഇല്ലയോ എന്നത് പ്രശ്നമല്ല);
&& - മുമ്പത്തെ കമാൻഡ് വിജയകരമായി പൂർത്തിയാക്കിയതിന് ശേഷം മാത്രം ഒരു കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യാൻ ഓപ്പറേറ്റർ;
|| - മുമ്പത്തേത് തെറ്റായി എക്സിക്യൂട്ട് ചെയ്തതിന് ശേഷം മാത്രം ഒരു കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യുന്ന ഓപ്പറേറ്റർ.
വിജയ കോഡ് 0 ആണ്, കൂടാതെ പിശക് കോഡ് പൂജ്യമല്ല (പിശകിൻ്റെ തരം അനുസരിച്ച്). ഇത് പരമ്പരാഗത പ്രോഗ്രാമിംഗ് ഭാഷകളുമായി ആശയക്കുഴപ്പത്തിലാക്കരുത്, ഇവിടെ 1 എന്നത് ട്രൂ എന്നതിന് സമാനമാണ്, കൂടാതെ 0 എന്നത് തെറ്റിന് സമാനവുമാണ്.
ഇപ്പോൾ നമുക്ക് സോപാധിക പ്രസ്താവനകൾ നേരിട്ട് പരിഗണിക്കാൻ തുടങ്ങാം.

കേസ് ഓപ്പറേറ്റർ

കേസ് പ്രസ്താവനയുടെ പൊതുവായ വാക്യഘടന ഇതാണ്:

കേസ് മൂല്യം
ടെംപ്ലേറ്റ്1) ലിസ്റ്റ്1;;
ടെംപ്ലേറ്റ്2 | ടെംപ്ലേറ്റ്3) ലിസ്റ്റ്2;;
esac

കേസ് പ്രസ്താവന നടപ്പിലാക്കുന്നതിൻ്റെ യുക്തിസഹമായ ക്രമം:
a) മൂല്യവുമായി പൊരുത്തപ്പെടുന്ന ആദ്യ പാറ്റേൺ തിരയുന്നു;
b) അത് കണ്ടെത്തിയാൽ, ";;" എന്നതിൽ അവസാനിക്കുന്ന കമാൻഡുകളുടെ അനുബന്ധ ലിസ്റ്റ് എക്സിക്യൂട്ട് ചെയ്യപ്പെടും;
സി) കേസ് നിർമ്മാണത്തെ തുടർന്നുള്ള പ്രസ്താവനകളിലേക്ക് നിയന്ത്രണം കൈമാറുന്നു.
ടെംപ്ലേറ്റും ലിസ്റ്റും ")" എന്ന അക്ഷരത്താൽ വേർതിരിച്ചിരിക്കുന്നു. കമാൻഡുകളുടെ ഒരു ലിസ്റ്റ് നിരവധി വ്യവസ്ഥകളുമായി പൊരുത്തപ്പെടാം, തുടർന്ന് അവ "|" ചിഹ്നത്താൽ വേർതിരിക്കേണ്ടതാണ്.
ടെംപ്ലേറ്റുകളിൽ നിങ്ങൾക്ക് "*", "?", "" എന്നീ ചിഹ്നങ്ങൾ ഉപയോഗിക്കാം, അവ പരമ്പരയിലെ രണ്ടാമത്തെ വിഷയത്തിൽ ചർച്ചചെയ്തു. അവരുടെ സഹായത്തോടെ, സ്ഥിരസ്ഥിതിയായി പ്രവർത്തിക്കുന്ന ഒരു നിർദ്ദേശം നിങ്ങൾക്ക് നടപ്പിലാക്കാൻ കഴിയും സ്വിച്ച് സ്റ്റേറ്റ്മെൻ്റ്സി, പിഎച്ച്പി പോലുള്ള ഭാഷകൾ.
കേസ് ഉപയോഗിക്കുന്നതിനുള്ള ഒരു ഉദാഹരണം ഇതാ:
echo -n "[യൂണിവേഴ്സൽ വ്യൂവർ] ഫയലിൻ്റെ പേര് വ്യക്തമാക്കുക: "; *.jpg|*.gif|*.png-ൽ ഫയൽ കേസ് "$ഫയൽ" വായിക്കുക) eog $File ;; *.pdf) evince $File ;; *.txt) കുറവ് $ഫയൽ ;; *.html) firefox $File ;; /dev/*) echo "ശരി, ഇവ ഭയപ്പെടുത്തുന്ന ഫയലുകളാണ്." ;; *) പ്രതിധ്വനി "ശരി, ശരി - അത്ര സാർവത്രികമല്ല." echo "എനിക്ക് ഇത്തരത്തിലുള്ള ഫയലുകൾ പരിചിതമല്ല. അത് എങ്ങനെ കാണണമെന്ന് എനിക്കറിയില്ല." ;; esac
കേസ് നിർമ്മാണം ഉപയോഗിക്കുന്നതിനുള്ള മറ്റൊരു ഉദാഹരണം:
echo "പിശക്. ഞാൻ ആർക്കാണ് സന്ദേശം അയയ്‌ക്കേണ്ടത്?" പ്രതിധ്വനി "ബോസിനോട്: ബി" പ്രതിധ്വനി "സഹപ്രവർത്തകർക്ക്: സി" പ്രതിധ്വനി "ആരുമില്ല: ഏതെങ്കിലും കീ" ഉത്തരം കേസ് വായിക്കുക $answer in b|B) mail –s "error log" boss< error.log;; c|C) mail –s "Help! error log" –c denis nick < error.log;; *) echo "error"; exit;; esac

സോപാധിക ഓപ്പറേറ്റർഎങ്കിൽ

if പ്രസ്താവനയുടെ പൊതുവായ വാക്യഘടന ഇതാണ്:

ലിസ്റ്റ്1 എങ്കിൽ
പട്ടിക2

fi

ഇവിടെ സ്ക്വയർ ബ്രാക്കറ്റുകൾ ഓപ്ഷണൽ നിർമ്മാണങ്ങളെ സൂചിപ്പിക്കുന്നു. കേസ് പ്രസ്താവന നടപ്പിലാക്കുന്നതിൻ്റെ യുക്തിസഹമായ ക്രമം:
a) list1 എക്സിക്യൂട്ട് ചെയ്തു;
b) ഇത് പിശകുകളില്ലാതെ നടപ്പിലാക്കുകയാണെങ്കിൽ, list2 എക്സിക്യൂട്ട് ചെയ്യപ്പെടും. അല്ലെങ്കിൽ, list3 എക്സിക്യൂട്ട് ചെയ്യപ്പെടും, കൂടാതെ അത് പിശകുകളില്ലാതെ പൂർത്തിയാകുകയാണെങ്കിൽ, list4 എക്സിക്യൂട്ട് ചെയ്യപ്പെടും. list3 ഒരു പിശക് കോഡും നൽകുന്നുവെങ്കിൽ, list5 എക്സിക്യൂട്ട് ചെയ്യപ്പെടും;
c) ഇഫ് കൺസ്ട്രക്‌റ്റിനെ തുടർന്ന് നിയന്ത്രണം ഓപ്പറേറ്റർമാർക്ക് കൈമാറുന്നു.
ഇനിപ്പറയുന്നവ ഉപയോഗിക്കുന്നതിനുള്ള ഒരു ഉദാഹരണം ഇതാ:
grep -q Bash ഫയൽ ആണെങ്കിൽ, "ഫയലിൽ കുറഞ്ഞത് ഒരു ബാഷ് പദമെങ്കിലും അടങ്ങിയിരിക്കുന്നു." fi
if, തുടർന്ന് ഒരേ വരിയിൽ ദൃശ്യമാകുമ്പോൾ, if, തുടർന്ന് കൺസ്ട്രക്‌റ്റുകൾ ഒരു അർദ്ധവിരാമത്തിൽ അവസാനിക്കണം. ഉദാഹരണത്തിന്:
$ എങ്കിൽ [$? -ne 0 ]; തുടർന്ന് "പിശക്" പ്രതിധ്വനിക്കുക; fi
ഇപ്പോൾ, ഒരേ വരിയിൽ എങ്കിൽ സ്ഥാപിക്കാൻ കഴിയുമെന്ന് അറിഞ്ഞുകൊണ്ട്, മുകളിലുള്ള ഉദാഹരണം വീണ്ടും എഴുതാം:
grep -q ബാഷ് ഫയൽ ആണെങ്കിൽ; തുടർന്ന് പ്രതിധ്വനിക്കുക "ഫയലിൽ ബാഷ് എന്ന വാക്ക് അടങ്ങിയിരിക്കുന്നു." fi

ടെസ്റ്റ് പ്രസ്താവനയും സോപാധിക പദപ്രയോഗങ്ങളും

മുകളിലെ ഉദാഹരണത്തിൽ, എക്സിറ്റ് കോഡ് പാഴ്‌സ് ചെയ്യുന്നതിന് പകരം ഒരു കണ്ടീഷൻ ചെക്ക് ഉപയോഗിക്കുന്നു. അത്തരം പരിശോധനയുടെ രണ്ട് രൂപങ്ങൾ തുല്യമാണ്: ബിൽറ്റ്-ഇൻ ടെസ്റ്റ് കമാൻഡും [കണ്ടീഷനും]. ഉദാഹരണത്തിന്, ഒരു ഫയലിൻ്റെ അസ്തിത്വം പരിശോധിക്കാൻ നിങ്ങൾ എഴുതേണ്ടതുണ്ട്:
ടെസ്റ്റ് -ഇ<файл>
അല്ലെങ്കിൽ
[-ഇ<файл> ]
സ്ക്വയർ ബ്രാക്കറ്റുകൾ ഉപയോഗിക്കുകയാണെങ്കിൽ, അവ പരസ്പരം ഒരു സ്പേസ് ഉപയോഗിച്ച് വേർതിരിക്കേണ്ടതാണ്, കാരണം "[" എന്നത് കമാൻഡിൻ്റെ പേരാണ്, കൂടാതെ "]" എന്നത് അതിൻ്റെ പൂർത്തീകരണത്തിന് ആവശ്യമായ അവസാന ആർഗ്യുമെൻ്റാണ്.
വ്യവസ്ഥ വിജയകരമായി പരിശോധിച്ചാൽ, 0 തിരികെ നൽകും, തെറ്റാണെങ്കിൽ, പിശക് കോഡ് 1 തിരികെ നൽകും.
ഒരു സ്ട്രിംഗ് ശൂന്യമാണോ എന്ന് ടെസ്റ്റ് കമാൻഡിന് പരിശോധിക്കാൻ കഴിയും. ശൂന്യമല്ലാത്ത ഒരു സ്ട്രിംഗ് എക്സിറ്റ് കോഡ് 0. യഥാക്രമം ശൂന്യമായി - 1. ഉദാഹരണത്തിന്:
$ ടെസ്റ്റ് $USER; പ്രതിധ്വനി $? 0
"" എന്നതുമായി താരതമ്യം ചെയ്യുമ്പോൾ "" ഡിസൈൻ കൂടുതൽ സാർവത്രികമാണ്. ഇത് ടെസ്റ്റ് കമാൻഡിൻ്റെ വിപുലീകൃത പതിപ്പാണ്. ഈ നിർമ്മിതിയിൽ, ഫയൽ നാമങ്ങളുടെ അധിക വ്യാഖ്യാനമൊന്നും നടത്തപ്പെടുന്നില്ല, ആർഗ്യുമെൻ്റുകൾ പ്രത്യേക പദങ്ങളായി വിഭജിക്കപ്പെടുന്നില്ല, എന്നാൽ പാരാമീറ്ററുകളുടെയും കമാൻഡുകളുടെയും പകരം വയ്ക്കൽ അനുവദനീയമാണ്. ഉദാഹരണത്തിന്:
file=/etc/passwd [[ -e $file ]] എങ്കിൽ "പാസ്‌വേഡ് ഫയൽ കണ്ടെത്തി" എന്ന് പ്രതിധ്വനിപ്പിക്കുക. fi
"" നിർമ്മാണം "" എന്നതിനേക്കാൾ അഭികാമ്യമാണ്, കാരണം ഇത് ചില ലോജിക്കൽ പിശകുകൾ ഒഴിവാക്കാൻ സഹായിക്കും. ഉദാഹരണത്തിന്, ഓപ്പറേറ്റർമാർ "&&", "||", "<" и ">" " ഉള്ളിൽ " " തികച്ചും സ്വീകാര്യമാണ്, അതേസമയം " " ഉള്ളിൽ പിശക് സന്ദേശങ്ങൾ സൃഷ്ടിക്കുന്നു.
"(())" നിർമ്മാണം അതിനുള്ളിലെ ഗണിത പദപ്രയോഗങ്ങൾ വിലയിരുത്താൻ നിങ്ങളെ അനുവദിക്കുന്നു. കണക്കുകൂട്ടലിൻ്റെ ഫലം പൂജ്യമാണെങ്കിൽ, ഒരു പിശക് കോഡ് തിരികെ നൽകും. ഒരു കണക്കുകൂട്ടലിൻ്റെ പൂജ്യമല്ലാത്ത ഫലം 0 ൻ്റെ റിട്ടേൺ കോഡ് ഉണ്ടാക്കുന്നു. അതായത്, മുകളിൽ ചർച്ച ചെയ്തിരിക്കുന്ന ടെസ്റ്റിൻ്റെയും "" നിർദ്ദേശങ്ങളുടെയും നേർ വിപരീതം.
if സ്റ്റേറ്റ്മെൻ്റ് നെസ്റ്റഡ് ചെക്കുകൾ അനുവദിക്കുന്നു:
പ്രതിധ്വനി ആണെങ്കിൽ "അടുത്ത *if* ആദ്യത്തെ *if* ഉള്ളിലാണെങ്കിൽ."< b)) else [[ $a < $b ]] fi then echo "$a меньше $b" fi

[[ $comparison = "integer" ]] എങ്കിൽ ((a
! <выражение>സാധാരണ ലോജിക്കൽ പ്രവർത്തനങ്ങൾ ഉപയോഗിച്ച് സോപാധിക പദപ്രയോഗങ്ങൾ സംയോജിപ്പിക്കാൻ കഴിയും:
<выражение1>- നിഷേധം;<выражение2>–എ
<выражение1>- ലോജിക്കൽ AND;<выражение2>–ഒ

- ലോജിക്കൽ അല്ലെങ്കിൽ.
ഫയലുകൾക്കുള്ള എലിമെൻ്ററി സോപാധിക എക്സ്പ്രഷനുകൾ:
-e - ഫയൽ നിലവിലുണ്ട്;
-f - ഒരു സാധാരണ ഫയൽ (ഒരു ഡയറക്‌ടറിയോ ഉപകരണ ഫയലോ അല്ല);
-s - പൂജ്യമല്ലാത്ത ഫയൽ വലുപ്പം;
-d - ഫയൽ ഒരു ഡയറക്ടറിയാണ്;
-b - ഫയൽ ഒരു ബ്ലോക്ക് ഉപകരണമാണ് (ഫ്ലോപ്പി, cdrom, മുതലായവ); -c - ഫയൽ ഒരു പ്രതീക ഉപകരണമാണ് (കീബോർഡ്, മോഡം,ശബ്ദ കാർഡ്
മുതലായവ);
-p - ഫയൽ ഒരു ചാനലാണ്;
-h - ഫയൽ ഒരു പ്രതീകാത്മക ലിങ്കാണ്;
-L - ഫയൽ ഒരു പ്രതീകാത്മക ലിങ്കാണ്;
-S - ഫയൽ ഒരു സോക്കറ്റ് ആണ്;
-t - ഫയൽ ടെർമിനൽ ഉപകരണവുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു;
-r - ഫയൽ വായിക്കാവുന്നതാണ് (സ്ക്രിപ്റ്റ് സമാരംഭിച്ച ഉപയോക്താവിന്);
-w - ഫയൽ എഴുതാവുന്നതാണ് (സ്ക്രിപ്റ്റ് സമാരംഭിച്ച ഉപയോക്താവിന്);
-x - ഫയൽ എക്സിക്യൂഷൻ ലഭ്യമാണ് (സ്ക്രിപ്റ്റ് സമാരംഭിച്ച ഉപയോക്താവിന്);
-g - (sgid) ഫയലിനോ ഡയറക്ടറിക്കോ വേണ്ടി ഫ്ലാഗ് സജ്ജീകരിച്ചിരിക്കുന്നു;
ഫയലിനുള്ള -u - (suid) ഫ്ലാഗ് സജ്ജീകരിച്ചിരിക്കുന്നു;
-k - സ്റ്റിക്കി ബിറ്റ് ഫ്ലാഗ് സജ്ജീകരിച്ചിരിക്കുന്നു;
-O - ​​നിങ്ങൾ ഫയലിൻ്റെ ഉടമയാണ്;
-ജി - നിങ്ങൾ ഫയലിൻ്റെ അതേ ഗ്രൂപ്പിൽ പെട്ടവരാണ്;
-N - അവസാനമായി വായിച്ചതിനുശേഷം ഫയൽ പരിഷ്ക്കരിച്ചു;
file1 -nt file2 – file1 file2 നേക്കാൾ പുതിയതാണ്;
file1 -ot file2 – file1 file2 നേക്കാൾ പഴയതാണ്;

file1 -ef file2 – file1, file2 എന്നിവ ഒരേ ഫയലിലേക്കുള്ള "ഹാർഡ്" ലിങ്കുകളാണ്.
സ്ട്രിംഗുകൾ താരതമ്യം ചെയ്യുന്നതിനുള്ള എലിമെൻ്ററി സോപാധിക പദപ്രയോഗങ്ങൾ:
-z സ്ട്രിംഗ് - സ്ട്രിംഗ് നീളം 0 ആണ്;
-n സ്ട്രിംഗ് - സ്ട്രിംഗ് നീളം 0 ന് തുല്യമല്ല;
line1 == line2 - വരികൾ പൊരുത്തപ്പെടുന്നു ("=" പോലെ);
line1 !== line2 - വരികൾ പൊരുത്തപ്പെടുന്നില്ല ("!=" എന്നതിന് സമാനമാണ്);< строка2 – строка1 предшествует строке2 в лексикографическом порядке;
വരി1
ലൈൻ1 > ലൈൻ2 - ലൈൻ1 ലെക്സിക്കോഗ്രാഫിക്കൽ ക്രമത്തിൽ ലൈൻ2 പിന്തുടരുന്നു.
ഒരു ഗണിത സോപാധിക പദപ്രയോഗത്തിന് ഫോർമാറ്റ് ഉണ്ട്:
ആർഗ്യുമെൻ്റ്1 ഓപ്പറേഷൻ ആർഗ്യുമെൻ്റ്2, ആർഗ്യുമെൻ്റുകൾ പൂർണ്ണസംഖ്യകളാണ്, ഇനിപ്പറയുന്ന പ്രവർത്തനങ്ങൾ അനുവദനീയമാണ്:
-eq - തുല്യം;
-നെ - തുല്യമല്ല;
-lt - കുറവ്;
-le - അതിൽ കുറവോ തുല്യമോ;
-gt - കൂടുതൽ;
< - меньше (внутри двойных круглых скобок);
<= - меньше или равно (внутри двойных круглых скобок);
-ge - അതിലും വലുതോ തുല്യമോ;
> - അതിലും വലുത് (ഇരട്ട പരന്തീസിസിനുള്ളിൽ);

>= - അതിലും വലുതോ തുല്യമോ (ഇരട്ട പരന്തീസിസിനുള്ളിൽ).
echo "പിശക്. ഞാൻ ആർക്കാണ് സന്ദേശം അയയ്‌ക്കേണ്ടത്?" echo "Boss: b" echo "Colleagues: c" echo "ആരുമില്ല: ഏതെങ്കിലും കീ" [ "$answer" == "b" –o "$answer" == "B" ] എങ്കിൽ ഉത്തരം വായിക്കുക; തുടർന്ന് മെയിൽ-s "പിശക് ലോഗ്" ബോസ്< error.log; elif [ "$answer" == "c" –o "$answer" == "C" ]; then mail –s "Help! error log" –c denis nick < error.log; else echo "error"; exit; fi

അടുത്ത വിഷയത്തിൽ ഞാൻ ബാഷ് കമാൻഡ് ഇൻ്റർപ്രെറ്ററിൻ്റെ നിയന്ത്രണ ഘടനകൾ നോക്കുന്നത് തുടരും. അതായത്, ലൂപ്പ് ഓപ്പറേറ്റർമാരെ പരിഗണിക്കും. ഇപ്പോൾ ഞാൻ അഭിപ്രായങ്ങൾക്കും വിമർശനങ്ങൾക്കും വേണ്ടി കാത്തിരിക്കുകയാണ് :).

UPD: ഉപയോക്താവിന് നന്ദി

ബാഷ് ഷെൽ സ്ക്രിപ്റ്റുകളിൽ, നമുക്ക് നമ്പർ താരതമ്യങ്ങൾ നടത്താം. ബാഷിൽ ഒരു നമ്പർ താരതമ്യ പ്രവർത്തനം നടത്താൻ, നിങ്ങൾ ഒരു if അല്ലെങ്കിൽ ലൂപ്പിനുള്ളിൽ "ടെസ്റ്റ്" അവസ്ഥ ഉപയോഗിക്കണം. ഈ പോസ്റ്റിൽ, ബാഷിലെ നമ്പറുകൾ എങ്ങനെ താരതമ്യം ചെയ്യാമെന്ന് ഞങ്ങൾ നിങ്ങളോട് പറയും.

നമ്പറുകളുടെ ബാഷ് താരതമ്യത്തിനുള്ള ഓപ്പറേറ്റർമാർ

ഓപ്പറേറ്റർ	അത് എന്ത് ചെയ്യുന്നു	ഉദാഹരണം
-eq	തുല്യതയ്ക്കായി ബാഷിലെ സംഖ്യകൾ താരതമ്യം ചെയ്യുക, തുല്യമാണെങ്കിൽ 0 നൽകുന്നു	[ $a -eq $b ] എങ്കിൽ
-ജി	വലുതോ തുല്യമോ ആണെങ്കിൽ ബാഷിലെ സംഖ്യകൾ താരതമ്യം ചെയ്യുന്നു. ഇതിലും വലുതോ തുല്യമോ ആണെങ്കിൽ ഫലം 0 നൽകുന്നു	[ $a -ge $b ] എങ്കിൽ
-ജിടി	വലുതാണെങ്കിൽ ബാഷിലെ സംഖ്യകളെ താരതമ്യം ചെയ്യുന്നു.	[ $a -gt $b ] എങ്കിൽ
-ലെ	ബാഷിൽ കുറവോ തുല്യമോ ആണെങ്കിൽ സംഖ്യകളെ താരതമ്യം ചെയ്യുന്നു.	[ $a -le $b ] എങ്കിൽ
-lt	കുറവാണെങ്കിൽ ബാഷിലെ സംഖ്യകൾ താരതമ്യം ചെയ്യുന്നു.	[ $a -lt $b ] എങ്കിൽ
-നെ	തുല്യമല്ലെങ്കിലും ബാഷിലെ സംഖ്യകളെ താരതമ്യം ചെയ്യുന്നു.	[ $a -ne $b ] എങ്കിൽ

ബാഷിലെ നമ്പർ താരതമ്യ ഓപ്പറേറ്റർമാരുടെ വിശദമായ ഉദാഹരണങ്ങൾ:

1. ഓപ്പറേറ്റർ-eq

ഈ ഓപ്പറേറ്റർ നമ്പറുകൾ താരതമ്യം ചെയ്യുന്നു, മൂല്യം തുല്യമാണോ അല്ലയോ എന്ന് പരിശോധിക്കും. ഇത് തുല്യമാണെങ്കിൽ, 0 തിരികെ നൽകും.

# cat test.sh #!/bin/bash echo "വേരിയബിളിൻ്റെ മൂല്യം നൽകുക" ഒരു പ്രതിധ്വനി വായിക്കുക "വേരിയബിളിൻ്റെ മൂല്യം നൽകുക" b എന്ന് വായിക്കുക, [ $a -eq $b ] തുടർന്ന് echo "റിട്ടേൺ മൂല്യം:: $ ?" എക്കോ "എയും ബിയും തുല്യമാണ്" അല്ലെങ്കിൽ "റിട്ടേൺ മൂല്യം:: $?" എക്കോ "എയും ബിയും തുല്യമല്ല" fi #

നിർവ്വഹണം:

# sh test.sh വേരിയബിളിൻ്റെ മൂല്യം 2 നൽകുക എയും ബിയും തുല്യമാണ് #

മുകളിലുള്ള ഉദാഹരണത്തിൽ, ഞങ്ങൾ ആദ്യമായി 2, 3 അക്കങ്ങൾ എടുക്കുകയും സിസ്റ്റം മൂല്യം 1 നൽകുകയും ചെയ്തു, എന്നിരുന്നാലും, a, b എന്നിവയ്‌ക്കായി ഒരേ മൂല്യങ്ങൾ എടുക്കുമ്പോൾ, വേരിയബിൾ പൂജ്യത്തിൻ്റെ മൂല്യം നൽകുന്നു.

2. ഓപ്പറേറ്റർ-ജി

ഈ ഓപ്പറേറ്റർ അക്കങ്ങൾ താരതമ്യം ചെയ്യുകയും മൂല്യങ്ങൾ അതിലും വലുതാണോ തുല്യമാണോ എന്ന് പരിശോധിക്കുകയും ചെയ്യുന്നു. മൂല്യം കൂടുതലോ തുല്യമോ ആണെങ്കിൽ, റിട്ടേൺ മൂല്യം 0 ആണ്.

# cat test1.sh #!/bin/bash #comparison program for -ge echo "വേരിയബിളിൻ്റെ മൂല്യം നൽകുക" ഒരു പ്രതിധ്വനി വായിക്കുക "വേരിയബിളിൻ്റെ മൂല്യം നൽകുക" b എന്ന് വായിക്കുകയാണെങ്കിൽ b വായിക്കുക [ $a -ge $b ] echo "റിട്ടേൺ മൂല്യം: : $?" പ്രതിധ്വനി "a b-യെക്കാൾ വലുതോ തുല്യമോ ആണ്" അല്ലെങ്കിൽ "റിട്ടേൺ മൂല്യം:: $?" പ്രതിധ്വനി "a എന്നത് b എന്നതിനേക്കാൾ വലുതോ തുല്യമോ അല്ല" fi #

3. operator -gt

ഈ നമ്പർ താരതമ്യ ഓപ്പറേറ്റർ നമ്പർ വലുതാണോ എന്ന് പരിശോധിക്കും. മൂല്യം കൂടുതലാണെങ്കിൽ, 0 നൽകുന്നു.

# cat test2.sh #!/bin/bash #comparison program for -gt b=100 echo "100-ൽ കൂടുതൽ മൂല്യം നൽകുക" a if [ $a -gt $b ] വായിക്കുക, തുടർന്ന് "വളരെ നല്ലത്" എന്ന് പ്രതിധ്വനിക്കുക "അല്ല" വളരെ നല്ലത് "ഫി

4. ഓപ്പറേറ്റർ-ലെ

ഈ നമ്പർ താരതമ്യ ഓപ്പറേറ്റർ മൂല്യങ്ങൾ അതിലും കുറവോ തുല്യമോ പരിശോധിക്കും. ഇത് അതിൽ കുറവോ തുല്യമോ ആണെങ്കിൽ, റിട്ടേൺ മൂല്യം 0 ആണ്.

#compare program for -le b=5 echo "5-നേക്കാൾ കുറവോ തുല്യമോ ആയ ഒരു മൂല്യം നൽകുക" a if [ $a -le $b ] വായിക്കുക, തുടർന്ന് "എല്ലാം ശരി" ​​എന്ന് പ്രതിധ്വനിക്കുക അല്ലെങ്കിൽ "തെറ്റായ" fi #

5. ഓപ്പറേറ്റർ-lt

ഈ നമ്പർ താരതമ്യ ഓപ്പറേറ്റർ കുറഞ്ഞ മൂല്യങ്ങൾ പരിശോധിക്കും. സംഖ്യ കുറവാണെങ്കിൽ, റിട്ടേൺ മൂല്യം 0 ആണ്.

if-else വ്യവസ്ഥ ബാധകമാണ് ബാഷ് സ്ക്രിപ്റ്റുകൾ വളരെ പലപ്പോഴും. ഈ അവസ്ഥയ്ക്ക് തന്നെ അൽപ്പം വിചിത്രമായ രൂപമുണ്ട് [[ അവസ്ഥ ]]. ഇൻഡൻ്റേഷനുകൾ ശ്രദ്ധിക്കുക. അവരില്ലാതെ, അവസ്ഥ പ്രവർത്തിക്കില്ല. വ്യവസ്ഥയ്‌ക്കായുള്ള ലോജിക്കൽ ഓപ്പറേറ്റർമാരുടെ ഒരു ലിസ്റ്റ് ഇതാ [[ ? ]]:

ലോജിക്കൽ ഓപ്പറേറ്റർമാരുടെ ലിസ്റ്റ്
if-then-else-fi നിർമ്മാണത്തിനായി ഉപയോഗിക്കുന്നു

#!/bin/bash [[ $1 > 2 ]] ആണെങ്കിൽ # എങ്കിൽ [[ ? ]] എക്കോ $1" 2 നേക്കാൾ വലുതാണ്" വേറെ # എക്കോ $1 പൊരുത്തപ്പെടുന്നില്ലെങ്കിൽ" 2 അല്ലെങ്കിൽ 2" fi-ൽ കുറവാണ്

നിങ്ങളിൽ ചിലർക്ക് സമത്വ ഓപ്പറേറ്റർ -eq വിചിത്രമായി തോന്നിയേക്കാം. പരിചിതമായ ഓപ്പറേറ്റർമാരെ ഉപയോഗിച്ച് ശ്രമിക്കുക >

നിങ്ങൾക്ക് ഒരു സ്ക്രിപ്റ്റ് ഉണ്ടെന്നും ഉപയോക്താവിനെ പരിശോധിക്കേണ്ടതുണ്ടെന്നും പറയാം. ഉപയോക്താവ് റൂട്ട് അല്ലെങ്കിൽ, സ്ക്രിപ്റ്റ് നിർത്തും.

#!/bin/bash എങ്കിൽ [ "$(whoami)" != "root" ]; തുടർന്ന് പ്രതിധ്വനിക്കുക "$0 പ്രവർത്തിപ്പിക്കാൻ നിങ്ങൾക്ക് അനുമതിയില്ല."

പുറത്തുകടക്കുക 1; fi

പലപ്പോഴും ഒരു വേരിയബിളിന് മൂല്യമുണ്ടോ എന്ന് പരിശോധിക്കേണ്ടതുണ്ട്. വേരിയബിളിൽ ഒന്നുമില്ലെങ്കിൽ, നിങ്ങൾക്ക് സ്ക്രിപ്റ്റ് നിർത്താം.

#!/bin/bash എങ്കിൽ [ -n "$num" ]; തുടർന്ന് "വേരിയബിളിന് എന്തെങ്കിലും ഉണ്ട്, നിങ്ങൾക്ക് മറ്റൊരു പ്രക്രിയ ആരംഭിക്കാം" അല്ലെങ്കിൽ "ഒരു ശൂന്യ വേരിയബിൾ, സ്ക്രിപ്റ്റ് നിർത്തുക" 0-ൽ നിന്ന് പുറത്തുകടക്കുക; fi

വേരിയബിൾ ശൂന്യമാണെങ്കിൽ, അത് പൂരിപ്പിക്കാം.

#!/bin/bash എങ്കിൽ [ -z "$num" ]; തുടർന്ന് എക്കോ "വേരിയബിൾ ശൂന്യമാണ്" num=1 വേറെ എക്കോ "num="$num fi

ഒരു ശൂന്യമായ വേരിയബിളിന് ഒരു സ്ഥിര മൂല്യം നൽകാം. ഈ എൻട്രി മുമ്പത്തെ ഉദാഹരണത്തേക്കാൾ ചെറുതാണ്. #!/bin/bash # ആർഗ്യുമെൻ്റുകൾ ആണെങ്കിൽ DEFAULT എന്ന് എഴുതുകകമാൻഡ് ലൈൻ

കാണുന്നില്ല [ -z "$arg1" ] && arg1=DEFAULT echo $arg1

ആരംഭിക്കുന്നതിന്, താരതമ്യം ചെയ്യാനുള്ള സ്ട്രിംഗുകൾ അടങ്ങിയ str1, str2 എന്നീ രണ്ട് വേരിയബിളുകൾ ഞാൻ സൃഷ്ടിക്കും. ഇനിപ്പറയുന്ന കോഡ് ഉദാഹരണങ്ങളിൽ ഇവ ഉപയോഗിക്കും.

#!/bin/bash str1 = "താരതമ്യപ്പെടുത്താനുള്ള സ്ട്രിംഗ്" str2 = "താരതമ്യപ്പെടുത്താനുള്ള സ്ട്രിംഗ്"

ഞാൻ നിർദ്ദേശിക്കാൻ ആഗ്രഹിക്കുന്ന കേസ്-ഇൻസെൻസിറ്റീവ് സ്ട്രിംഗ് താരതമ്യത്തിൻ്റെ ആദ്യ പതിപ്പ് shopt buildin കമാൻഡ് ഉപയോഗിച്ച് ഷെൽ ഓപ്ഷൻ മാനേജ്മെൻ്റ് ഉപയോഗിക്കുന്നു.

shopt -s nocasematch [[ $str1 == $str2 ]] && എക്കോ "മാച്ച്" ||

echo "പൊരുത്തം" shopt -u nocasematch കേസ്-ഇൻസെൻസിറ്റീവ് സ്ട്രിംഗ് താരതമ്യത്തിൻ്റെ അടുത്ത പതിപ്പ് സ്ട്രിംഗുകളെ ഒരു സാധാരണ കേസിലേക്ക് സ്വതന്ത്രമായി പരിവർത്തനം ചെയ്യുന്ന തത്വത്തെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്. ഈ കോഡ് വേരിയൻ്റ് Bash 4-ലും അതിനുശേഷമുള്ളവയിലും പ്രവർത്തിക്കുന്നു. കൂടുതൽ കാര്യങ്ങൾക്കായി ഇത് ഉപയോഗിക്കുകആദ്യകാല പതിപ്പ്

ബാഷ് ഒരു പിശക് എറിയും.

അതിനാൽ, ചെറിയക്ഷരത്തിലേക്ക് പരിവർത്തനം ചെയ്ത സ്ട്രിംഗുകൾ താരതമ്യം ചെയ്യാൻ, നിങ്ങൾക്ക് ഇനിപ്പറയുന്ന കോഡ് ഓപ്ഷൻ ഉപയോഗിക്കാം.

[[ " $( str1 , ) " == " $( str2 , ) " ]] && പ്രതിധ്വനി "പൊരുത്തം" ||

പ്രതിധ്വനി "പൊരുത്തമല്ല"

വലിയക്ഷരവുമായി താരതമ്യപ്പെടുത്തുന്ന സ്ട്രിംഗുകൾ പരിവർത്തനം ചെയ്യണമെങ്കിൽ, നിങ്ങൾക്ക് ഇനിപ്പറയുന്ന കോഡ് ഉപയോഗിക്കാം.

[[ " $( str1 ^^ ) " == " $( str2 ^^ ) " ]] && എക്കോ "മാച്ച്" ||

പ്രതിധ്വനി "പൊരുത്തമല്ല"

ഒരു ബദലായി, വേരിയബിളുകൾ പ്രഖ്യാപിക്കുന്ന സമയത്ത് സ്ട്രിംഗുകൾ ഒരൊറ്റ രജിസ്റ്ററിലേക്ക് പരിവർത്തനം ചെയ്യാവുന്നതാണ്. ഇത് ചെയ്യുന്നതിന്, shell buildin കമാൻഡ് declare ഉപയോഗിക്കുക. ചെറിയ അക്ഷരങ്ങൾ അടങ്ങിയ ഒരു വേരിയബിൾ പ്രഖ്യാപിക്കാൻ, ഇനിപ്പറയുന്ന കോഡ് ഉപയോഗിക്കുക.#!/bin/bash declare -l str = "ഒട്ടക ചരട്"

ഈ കോഡ് എക്സിക്യൂട്ട് ചെയ്യുന്നതിൻ്റെ ഫലമായി, അസൈൻ ചെയ്ത സ്ട്രിംഗ് ഒട്ടക കേസിൽ എഴുതിയിട്ടുണ്ടെങ്കിലും, വേരിയബിളിൽ ഒരു ചെറിയക്ഷര സ്ട്രിംഗ് അടങ്ങിയിരിക്കും. ഇതിനകം വ്യക്തമാക്കിയ ഒരു കേസ് മാറ്റുക

സ്ട്രിംഗ് വേരിയബിൾ

ഇനിപ്പറയുന്ന രീതിയിൽ ചെയ്യാം.

#!/bin/bash str = "ഒട്ടക ചരട്" പ്രഖ്യാപിക്കുക -l str str = $str echo $str

ബാഷ് സ്‌ക്രിപ്റ്റുകൾ എഴുതുമ്പോൾ ചർച്ച ചെയ്യപ്പെടുന്ന ഏതെങ്കിലും കേസ്-ഇൻസെൻസിറ്റീവ് സ്ട്രിംഗ് താരതമ്യ ഓപ്‌ഷനുകൾ ഉപയോഗിക്കാം. അതിനാൽ, നിങ്ങൾ ബാഷ് പതിപ്പ് 4 അല്ലെങ്കിൽ അതിലും ഉയർന്നതാണ് ഉപയോഗിക്കുന്നതെങ്കിൽ, നിങ്ങൾക്ക് ഏറ്റവും ഇഷ്ടപ്പെട്ട ഒന്ന് തിരഞ്ഞെടുക്കാം. Bash പതിപ്പ് 4-ൽ താഴെയാണെങ്കിൽ, shopt shell ബിൽറ്റ്-ഇൻ കമാൻഡ് ഉപയോഗിച്ച് nocasematch ഓപ്ഷൻ വ്യക്തമാക്കി നിങ്ങൾ ആദ്യ ഓപ്ഷൻ ഉപയോഗിക്കണം.

ബാഷിൽ സ്ക്രിപ്റ്റുകൾ എഴുതുമ്പോൾ, പരിചയസമ്പന്നരായ പ്രോഗ്രാമർമാർ മാത്രമല്ല, ബാഷ് ഷെല്ലിലെ പുതിയവരും സ്ട്രിംഗുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നു. എക്സിക്യൂട്ടബിൾ സ്ക്രിപ്റ്റിലേക്കുള്ള ആർഗ്യുമെൻ്റുകളായി ഉപയോക്താവ് നൽകിയ കമാൻഡുകൾ വായിക്കുമ്പോഴും പ്രോസസ്സ് ചെയ്യുമ്പോഴും ഇത് മിക്കപ്പോഴും ആവശ്യമാണ്. ടെക്സ്റ്റ് ഫയലുകൾ. ഈ കേസിൽ ആവശ്യമായ സാങ്കേതികതകളിലൊന്ന് സ്ട്രിംഗ് താരതമ്യം ആണ്.

ഈ ലേഖനം താരതമ്യം നോക്കും ബാഷ് ലൈനുകൾ, അതുപോലെ താരതമ്യ പ്രവർത്തനങ്ങൾ ഉപയോഗിക്കുന്നതിനും പൊതുവായ പിശകുകൾ പരിഹരിക്കുന്നതിനുമുള്ള ചില സൂക്ഷ്മതകൾ.

താരതമ്യം ചെയ്യുന്ന സ്ട്രിംഗുകൾ ഒന്നുതന്നെയാണോ എന്ന് നിർണ്ണയിക്കാൻ ഈ പ്രവർത്തനങ്ങൾ നിങ്ങളെ അനുവദിക്കുന്നു:

• = - തുല്യം, ഉദാഹരണത്തിന് എങ്കിൽ [ "$x" = "$y" ]
• == - ഉദാഹരണത്തിന് "=" ഓപ്പറേറ്റർ എന്നതിൻ്റെ പര്യായപദം എങ്കിൽ [ "$x" == "$y" ]
• != - തുല്യമല്ല, ഉദാഹരണത്തിന് എങ്കിൽ [ "$x" != "$y" ]

#!/bin/bash
ടെസ്റ്റുസർ=ആൻ്റൺ
[$USER = $ടെസ്റ്റുസർ] ആണെങ്കിൽ
പിന്നെ
പ്രതിധ്വനി "സ്വാഗതം $ testuser"
fi

സ്ക്രിപ്റ്റിൻ്റെ ഫലം:

കമാൻഡ് ഉപയോഗിച്ച് സമത്വത്തിനായി പരിശോധിക്കുമ്പോൾ പരീക്ഷ(ചതുരാകൃതിയിലുള്ള ബ്രാക്കറ്റുകളുടെ പര്യായമായി) എല്ലാ വിരാമചിഹ്നങ്ങളും താരതമ്യപ്പെടുത്തിയ സ്ട്രിംഗുകളുടെ അക്ഷരങ്ങളുടെ കാര്യത്തിലെ വ്യത്യാസങ്ങളും കണക്കിലെടുക്കുന്നു.

പാറ്റേണുകളുമായുള്ള സ്ട്രിംഗ് താരതമ്യത്തിൻ്റെ ചില സവിശേഷതകൾ:

$x-ൽ അടങ്ങിയിരിക്കുന്ന സ്ട്രിംഗ് "y" എന്ന അക്ഷരത്തിൽ ആരംഭിക്കുകയാണെങ്കിൽ # ശരിയാണെന്ന് നൽകുന്നു
[[ $x == y* ]]
$x-ൽ നിന്നുള്ള സ്ട്രിംഗ് "y*" എന്ന രണ്ട് പ്രതീകങ്ങൾക്ക് തുല്യമാണെങ്കിൽ # ശരിയാണെന്ന് നൽകുന്നു
[[ $x == "y*" ]]
നിലവിലെ ഡയറക്‌ടറിയിൽ "y" എന്ന് തുടങ്ങുന്ന ഫയലിൻ്റെ പേര് $x-ൽ അടങ്ങിയിട്ടുണ്ടെങ്കിൽ # ശരിയാണെന്ന് നൽകുന്നു
[$x == y*]
$x എന്ന സ്ട്രിംഗ് രണ്ട് "y*" പ്രതീകങ്ങൾക്ക് തുല്യമാണെങ്കിൽ # ശരിയാണെന്ന് നൽകുന്നു
[ "$x" == "y*" ]

ഉദാഹരണത്തിന്, ഒരു ബാഷ് സ്ട്രിംഗ് y എന്ന അക്ഷരത്തിൽ തുടങ്ങുന്നുണ്ടോ എന്ന് പരിശോധിക്കുന്നത്:

#!/bin/bash
x=yandex
[[ $x == y* ]]
പ്രതിധ്വനി $?

കോഡ് നടപ്പിലാക്കുന്നതിൻ്റെ ഫലം:

അവസാനം എക്സിക്യൂട്ട് ചെയ്ത നിർദ്ദേശത്തിൻ്റെ പിശക് കോഡ് പ്രദർശിപ്പിക്കാൻ ഞങ്ങൾ അഭ്യർത്ഥിച്ചതിനാൽ സ്ക്രിപ്റ്റ് ഔട്ട്പുട്ട് 0 (പൂജ്യം) ആണ്. കൂടാതെ കോഡ് 0 എന്നാൽ സ്ക്രിപ്റ്റ് പിശകുകളില്ലാതെ എക്സിക്യൂട്ട് ചെയ്തു എന്നാണ്. തീർച്ചയായും - ഒരു വേരിയബിൾ $xസ്ട്രിംഗ് അടങ്ങിയിരിക്കുന്നു yandex, "y" എന്ന അക്ഷരത്തിൽ തുടങ്ങുന്നു. അല്ലെങ്കിൽ, "1" എന്ന് എഴുതിയേക്കാം. സ്ക്രിപ്റ്റുകൾ ഡീബഗ് ചെയ്യുന്നതിനുള്ള വളരെ സൗകര്യപ്രദമായ മാർഗമാണിത്.

ബാഷിൽ അക്ഷരമാലാക്രമത്തിൽ സ്ട്രിംഗുകൾ താരതമ്യം ചെയ്യുന്നു

ആരോഹണ ക്രമത്തിൽ ഒരു വരി മറ്റൊരു വരിയുടെ മുൻഗാമിയാണോ എന്ന് നിർണ്ണയിക്കാൻ ശ്രമിക്കുമ്പോൾ ടാസ്ക് കൂടുതൽ ബുദ്ധിമുട്ടാകുന്നു. ബാഷ് സ്ക്രിപ്റ്റുകൾ എഴുതുന്ന ആളുകൾ പലപ്പോഴും താരതമ്യവുമായി ബന്ധപ്പെട്ട പ്രവർത്തനങ്ങളേക്കാൾ വലുതും കുറവുള്ളതുമായ രണ്ട് പ്രശ്നങ്ങളിൽ അകപ്പെടുന്നു. Linux സ്ട്രിംഗുകൾ, അവയ്ക്ക് വളരെ ലളിതമായ പരിഹാരങ്ങളുണ്ട്:

ആദ്യം, വലുതും കുറവുള്ളതുമായ പ്രതീകങ്ങൾ ഒരു ബാക്ക്‌സ്ലാഷ് (\) ഉപയോഗിച്ച് ഒഴിവാക്കേണ്ടതുണ്ട്, അല്ലാത്തപക്ഷം ഷെൽ അവയെ റീഡയറക്ഷൻ പ്രതീകങ്ങളായും സ്ട്രിംഗുകളെ ഫയൽ നാമങ്ങളായും പരിഗണിക്കും. പിശക് കണ്ടെത്തുന്നത് വളരെ ബുദ്ധിമുട്ടുള്ള കേസുകളിൽ ഒന്നാണിത്.

#!/bin/bash
# സ്ട്രിംഗ് താരതമ്യ ഓപ്പറേറ്റർമാരുടെ തെറ്റായ ഉപയോഗം
val1=ബേസ്ബോൾ
val2=ഹോക്കി
എങ്കിൽ [ $val1 > $val2 ]
പിന്നെ

വേറെ

fi

നിങ്ങൾ ബാഷ് സ്ട്രിംഗുകൾ താരതമ്യം ചെയ്താൽ നിങ്ങൾക്ക് എന്ത് ലഭിക്കും:

നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, "അതിനേക്കാൾ വലുത്" എന്ന ചിഹ്നം അതിൻ്റെ ഉടനടി രൂപത്തിൽ മാത്രം തെറ്റായ ഫലങ്ങളിലേക്ക് നയിച്ചു, എന്നിരുന്നാലും പിശകുകളൊന്നും സൃഷ്ടിച്ചില്ല. ഈ സാഹചര്യത്തിൽ, ഈ പ്രതീകം ഔട്ട്പുട്ട് സ്ട്രീം റീഡയറക്‌ടുചെയ്യുന്നതിന് കാരണമായി, അതിനാൽ ഇല്ല വാക്യഘടന പിശകുകൾകണ്ടെത്തിയില്ല, അതിൻ്റെ ഫലമായി ഒരു ഫയൽ വിളിച്ചു ഹോക്കി:

ഈ പിശക് പരിഹരിക്കുന്നതിന്, നിങ്ങൾ ">" പ്രതീകത്തിൽ നിന്ന് രക്ഷപ്പെടേണ്ടതുണ്ട്, അതിനാൽ അവസ്ഥ ഇതുപോലെ കാണപ്പെടുന്നു:

...
എങ്കിൽ [ $val1 \> $val2 ]
...

അപ്പോൾ പ്രോഗ്രാമിൻ്റെ ഫലം ശരിയായിരിക്കും:

രണ്ടാമതായി, ഓപ്പറേറ്റർമാരേക്കാൾ വലുതും കുറവും ഉപയോഗിച്ച് ഓർഡർ ചെയ്ത സ്ട്രിംഗുകൾ കമാൻഡിൽ നിന്ന് വ്യത്യസ്തമായി ക്രമീകരിച്ചിരിക്കുന്നു അടുക്കുക. ഇവിടെ, പ്രശ്നങ്ങൾ തിരിച്ചറിയാൻ കൂടുതൽ ബുദ്ധിമുട്ടാണ്, താരതമ്യത്തിൽ അക്ഷരങ്ങളുടെ കാര്യം കണക്കിലെടുക്കുന്നില്ലെങ്കിൽ നിങ്ങൾക്ക് അവ നേരിടേണ്ടി വരില്ല. ടീമിൽ അടുക്കുകഒപ്പം പരീക്ഷതാരതമ്യം വ്യത്യസ്ത രീതികളിൽ സംഭവിക്കുന്നു:

#!/bin/bash
val1=ടെസ്റ്റിംഗ്
val2=ടെസ്റ്റിംഗ്
എങ്കിൽ [ $val1 \> $val2 ]
പിന്നെ
പ്രതിധ്വനി "$val1 $val2 നേക്കാൾ വലുതാണ്"
വേറെ
പ്രതിധ്വനി "$val1 $val2 ൽ കുറവാണ്"
fi

കോഡിൻ്റെ ഫലം:

ടീമിൽ പരീക്ഷകൂടെ വരികൾ വലിയ അക്ഷരങ്ങളിൽആദ്യം ചെറിയ അക്ഷരങ്ങളുള്ള വരികൾ ആയിരിക്കും. എന്നാൽ നിങ്ങൾ അതേ ഡാറ്റ ഒരു ഫയലിലേക്ക് എഴുതുകയാണെങ്കിൽ, ആ കമാൻഡ് പ്രയോഗിക്കുക അടുക്കുക, അപ്പോൾ ചെറിയ അക്ഷരങ്ങളുള്ള വരികൾ ആദ്യം വരും:

അവരുടെ ജോലി തമ്മിലുള്ള വ്യത്യാസം ഇതാണ് പരീക്ഷഅടുക്കൽ ക്രമം നിർണ്ണയിക്കാൻ, ASCII പട്ടികയിലെ പ്രതീകങ്ങളുടെ ക്രമീകരണം ഒരു അടിസ്ഥാനമായി എടുക്കുന്നു. IN അടുക്കുകപ്രാദേശിക ക്രമീകരണങ്ങൾക്കായി വ്യക്തമാക്കിയ അടുക്കൽ ക്രമം ഉപയോഗിക്കുന്നു.

ശൂന്യമായ മൂല്യത്തിനായി ഒരു സ്ട്രിംഗ് പരിശോധിക്കുന്നു

ഓപ്പറേറ്റർമാരെ ഉപയോഗിച്ചുള്ള താരതമ്യം -zഒപ്പം -എൻഒരു വേരിയബിളിൽ ഉള്ളടക്കങ്ങൾ ഉണ്ടോ എന്ന് നിർണ്ണയിക്കാൻ ഉപയോഗിക്കുന്നു. ഇതുവഴി നിങ്ങൾക്ക് ബാഷ് ശൂന്യമായ വരികൾ കണ്ടെത്താനാകും. ഉദാഹരണം:

#!/bin/bash
val1=ടെസ്റ്റിംഗ്
val2=""
# സ്ട്രിംഗ് ശൂന്യമാണോ എന്ന് പരിശോധിക്കുന്നു
എങ്കിൽ [-n $val1 ]
പിന്നെ
പ്രതിധ്വനി "$val1" എന്ന സ്ട്രിംഗ് ശൂന്യമല്ല"
വേറെ
പ്രതിധ്വനി "$val1" എന്ന സ്ട്രിംഗ് ശൂന്യമാണ്"
fi
# സ്ട്രിംഗ് ശൂന്യമാണോ എന്ന് പരിശോധിക്കുന്നു
എങ്കിൽ [-z $val2 ]
പിന്നെ
പ്രതിധ്വനി "$val2" എന്ന സ്ട്രിംഗ് ശൂന്യമാണ്"
വേറെ
പ്രതിധ്വനി "$val2" എന്ന സ്ട്രിംഗ് ശൂന്യമല്ല"
fi
എങ്കിൽ [ -z $val3 ]
പിന്നെ
പ്രതിധ്വനി "$val3" എന്ന സ്ട്രിംഗ് ശൂന്യമാണ്"
വേറെ
പ്രതിധ്വനി "$val3" എന്ന സ്ട്രിംഗ് ശൂന്യമല്ല"
fi

കോഡിൻ്റെ ഫലം:

ഈ ഉദാഹരണം രണ്ട് സ്ട്രിംഗ് വേരിയബിളുകൾ സൃഷ്ടിക്കുന്നു - val1ഒപ്പം val2. ഓപ്പറേഷൻ -എൻഒരു വേരിയബിളിന് ഉണ്ടോ എന്ന് നിർണ്ണയിക്കുന്നു val1പൂജ്യമല്ലാത്ത നീളം, ഒപ്പം -zപരിശോധിക്കുന്നു val2ഒപ്പം val3പൂജ്യത്തിലേക്ക്. താരതമ്യ നിമിഷം വരെ രണ്ടാമത്തേത് നിർവചിക്കപ്പെട്ടിട്ടില്ല എന്നത് ശ്രദ്ധേയമാണ്, എന്നാൽ അതിൻ്റെ ദൈർഘ്യം ഇപ്പോഴും പൂജ്യത്തിന് തുല്യമാണെന്ന് വ്യാഖ്യാതാവ് വിശ്വസിക്കുന്നു. വിവിധ സ്ക്രിപ്റ്റ് പരിശോധനകളിൽ ഈ സൂക്ഷ്മത കണക്കിലെടുക്കണം. കൂടാതെ, വേരിയബിളിൽ എന്ത് മൂല്യമാണ് അടങ്ങിയിരിക്കുന്നതെന്നും അത് സജ്ജീകരിച്ചിട്ടുണ്ടോ എന്നും നിങ്ങൾക്ക് ഉറപ്പില്ലെങ്കിൽ, ഓപ്പറേറ്റർ ഉപയോഗിച്ച് അത് പരിശോധിക്കേണ്ടതാണ്. -എൻഅല്ലെങ്കിൽ -zഎന്നിട്ട് മാത്രമേ അത് ഉദ്ദേശിച്ച ആവശ്യത്തിനായി ഉപയോഗിക്കൂ.

പ്രവർത്തനത്തിൽ ശ്രദ്ധിക്കുന്നത് മൂല്യവത്താണ് -എൻ. ഒരു അപ്രഖ്യാപിതമോ ശൂന്യമോ ആയ വേരിയബിൾ പരിശോധനയ്‌ക്കായി അതിലേക്ക് കൈമാറുകയാണെങ്കിൽ, അത് തെറ്റല്ല എന്നതിലുപരി ശരിയാകും. അത്തരം സന്ദർഭങ്ങളിൽ, നിങ്ങൾ ചെക്ക് ഇൻ ചെയ്യുന്ന സ്ട്രിംഗ് (വേരിയബിൾ) ഉൾപ്പെടുത്തണം ഇരട്ട ഉദ്ധരണികൾഅതിനാൽ ഇത് ഇതുപോലെ കാണപ്പെടുന്നു:

...
എങ്കിൽ [-n "$val1" ]
...

നിഗമനങ്ങൾ

അവതരിപ്പിച്ച ബാഷ് സ്ട്രിംഗ് താരതമ്യ പ്രവർത്തനങ്ങൾക്ക് സ്ക്രിപ്റ്റ് പിശകുകൾ തടയുന്നതിന് മനസ്സിലാക്കേണ്ട ചില സൂക്ഷ്മതകളുണ്ട്. എന്നാൽ പ്രായോഗികമായി അത്തരം നിരവധി സാഹചര്യങ്ങളുണ്ട്, അതിനാൽ എല്ലാം ഓർമ്മിക്കുന്നത് അസാധ്യമാണ് (അത് വിവരിക്കട്ടെ).