ഒരു ബാഷ് സ്ക്രിപ്റ്റിനുള്ളിലെ ടെസ്റ്റ് അവസ്ഥകൾ എങ്ങനെയാണ് ഉപയോഗിക്കുക

മറ്റൊരു കമാന്ഡിനെ മറ്റൊന്നുമായി താരതമ്യം ചെയ്യാൻ ലിനക്സ് കമാൻറ് ലൈനിൽ ടെസ്റ്റ് കമാൻഡ് ഉപയോഗിക്കാം. എന്നാൽ ലോജിക്, പ്രോഗ്രാമിന്റെ ഒഴുക്ക് നിയന്ത്രിക്കുന്ന സോപാധികമായ പ്രസ്താവനകളുടെ ഭാഗമായി ബാഷ് ഷെൽ സ്ക്രിപ്റ്റുകളിൽ ഇത് സാധാരണയായി ഉപയോഗിക്കുന്നു.

ഒരു അടിസ്ഥാന ഉദാഹരണം

ടെർമിനൽ വിൻഡോ തുറക്കുന്നതിലൂടെ ഈ നിർദ്ദേശങ്ങൾ നിങ്ങൾക്ക് പരീക്ഷിക്കാം.

test 1 -eq 2 && echo "yes" || echo "no"

മുകളിൽ പറഞ്ഞിരിക്കുന്ന കമാൻഡ് താഴെപറയും:

• പരീക്ഷണം - ഇത് നിങ്ങൾ ഒരു താരതമ്യം ചെയ്യാൻ പോവുകയാണ് എന്നാണ്
• 1 - നിങ്ങൾ താരതമ്യം ചെയ്യാൻ തുടങ്ങിയ ആദ്യ ഘടകം
• -eq (ഒരു താരതമ്യപഠനം മറ്റൊന്നു തുല്യമാണോ എന്ന് നിങ്ങൾ പരീക്ഷിച്ചു നോക്കുന്നതെങ്ങനെ എന്ന കാര്യത്തിൽ നിങ്ങൾ എങ്ങനെ വിലയിരുത്തുന്നു)
• 2 - നിങ്ങൾ വീണ്ടും ആദ്യത്തെ ഘടകം താരതമ്യപ്പെടുത്തുന്നു
• && - ഫലം ശരിയാണെങ്കില് താഴെ പറയുന്ന പ്രസ്താവന നടത്തുക
• echo "അതെ" - താരതമ്യം ശരിയാണു് പ്രവർത്തിക്കുവാനുള്ള കമാൻഡ്
• || - ഫലം തെറ്റാണെങ്കിൽ താഴെ പറയുന്ന പ്രസ്താവന നടത്തുക
• echo "no" - താരതമ്യത്തിനുള്ള തെറ്റ് ശരിയാണെങ്കിൽ പ്രവർത്തിപ്പിയ്ക്കാനുള്ള കമാൻഡ്

സാരഥിയിൽ, കമാൻഡ് 1 മുതൽ 2 വരെ താരതമ്യപ്പെടുത്തുമ്പോൾ, അവർ "അതെ" പ്രദർശിപ്പിക്കുന്ന എക്കോ "yes" സ്റ്റേറ്റ്മെന്റിനെ പൊരുത്തപ്പെടുത്തുകയും അവർ പൊരുത്തപ്പെടുന്നില്ലെങ്കിൽ "no" സ്റ്റേറ്റ്മെന്റ് "ഇല്ല" എന്ന് പ്രദർശിപ്പിക്കുകയും ചെയ്യുന്നു.

സംഖ്യകൾ താരതമ്യം ചെയ്യുക

നിങ്ങൾ നമ്പറുകളായി പാഴ്സ് ചെയ്യുന്ന ഘടകങ്ങളെ താരതമ്യം ചെയ്താൽ നിങ്ങൾ താഴെ താരതമ്യം ചെയ്യാനുള്ള ഓപ്പറേറ്റർമാർ ഉപയോഗിക്കും:

• -eq - മൂല്യം 1 തുല്യമൂല്യം 2 ചെയ്യുന്നു
• -ge - മൂല്യം 1 ഒന്നിൽ കൂടുതൽ അല്ലെങ്കിൽ തുല്യമാണ്
• -gt - value 2 നെക്കാൾ മൂല്യത്തേക്കാൾ വലുതാണ്
• -le - മൂല്യം 2-ൽ കുറവോ മൂല്യം കുറവോ ആണ്
• -lt - value 2 നെക്കാൾ മൂല്യം 1 ആണ്
• -ne - മൂല്യം 1 അല്ല തുല്യമൂല്യം 2 ചെയ്യുന്നു

ഉദാഹരണങ്ങൾ:

test 1 -eq 2 && echo "yes" || echo "no"

(സ്ക്രീനിൽ "അല്ല" എന്ന് പ്രദർശിപ്പിക്കുന്നു, കാരണം 1 തുല്യമല്ല 2)

test 1 -ge 2 && echo "yes" || echo "no"

(സ്ക്രീനിൽ "അല്ല" എന്നത് പ്രദർശിപ്പിക്കുന്നു, കാരണം 1 എണ്ണം ഒന്നുകിൽ 2 അല്ല അല്ലെങ്കിൽ തുല്യമാണ്)

test 1-gt 2 && echo "yes" || echo "no"

(സ്ക്രീനിൽ "അല്ല" എന്നത് പ്രദർശിപ്പിക്കുന്നു, കാരണം 1 എന്നത് 2-നേക്കാൾ വലുതല്ല)

test 1 -le 2 && echo "yes" || echo "no"

(സ്ക്രീനിൽ "അതെ" എന്ന് പ്രദർശിപ്പിക്കുന്നു, കാരണം 1 എണ്ണം 2 ൽ കുറവോ തുല്യമോ ആണ്)

test 1 -lt 2 && echo "അതെ" || echo "no"

(സ്ക്രീനിൽ "അതെ" എന്ന് പ്രദർശിപ്പിക്കുന്നു, കാരണം 1 എണ്ണം 2 ൽ കുറവോ തുല്യമോ ആണ്)

test 1 -ne 2 && echo "yes" || echo "no"

(സ്ക്രീനിൽ "അതെ" പ്രദർശിപ്പിക്കുന്നു, കാരണം 1 തുല്യമല്ല 2)

വാചകം താരതമ്യം ചെയ്യുന്നു

നിങ്ങൾക്ക് സ്ട്രിംഗുകളായി പാഴ്സ് ചെയ്യുന്ന ഘടകങ്ങളെ താരതമ്യം ചെയ്താൽ നിങ്ങൾ താഴെ താരതമ്യം ചെയ്യുന്ന ഓപ്പറേറ്റർമാർ ഉപയോഗിക്കാം:

• = - 1 മത്സര സ്ട്രിംഗ് 2 സ്ട്രിംഗ് ചെയ്യുന്നു
• സ്ട്രിംഗ് 2 ൽ സ്ട്രിംഗ് 1 വ്യത്യസ്തമാണ്! = -
• -n - 0 ആയതിനേക്കാൾ കൂടുതൽ സ്ട്രിംഗ് നീളം
• -z - സ്ട്രിംഗ് ദൈർഘ്യം 0 ആണ്

ഉദാഹരണങ്ങൾ:

test "string1" = "string2" && echo "yes" || echo "no"

("സ്ട്രിംഗ് 1" തുല്യമല്ല "string2" ആയതിനാൽ (സ്ക്രീനിൽ "അല്ല" കാണിക്കുന്നു)

test "string1"! = "string2" && echo "അതെ" || echo "no"

("അതെ" സ്ക്രീനിൽ പ്രദർശിപ്പിക്കുന്നു കാരണം "സ്ട്രിംഗ് 1" തുല്യമല്ല "സ്ട്രിംഗ് 2")

test -n "string1" && echo "അതെ" || echo "no"

(സ്ക്രീനിൽ "അതെ" പ്രദർശിപ്പിക്കുന്നു കാരണം "സ്ട്രിംഗ് 1" എന്നതിന് ഒരു സ്ട്രിംഗ് ദൈർഘ്യം പൂജ്യത്തേക്കാൾ വലുതായതിനാൽ)

test -z "string1" && echo "അതെ" || echo "no"

(സ്ക്രീനിൽ "അല്ല" കാണിക്കുന്നു കാരണം "string1" എന്നതിന് ഒരു സ്ട്രിംഗ് നീളം പൂജ്യത്തേക്കാൾ വലുതാണ്)

ഫയലുകൾ താരതമ്യം ചെയ്യുന്നു

നിങ്ങൾ ഫയലുകൾ താരതമ്യപ്പെടുത്തുകയാണെങ്കിൽ താഴെക്കൊടുത്തിരിക്കുന്ന താരതമ്യ ഓപ്പറേറ്ററുകൾ ഉപയോഗിക്കാം:

• -ef - ഫയലുകൾ ഒരേ ഉപകരണവും ഐനോഡ് നമ്പറുകളുമുണ്ടോ (അവ ഒരേ ഫയലാണ്)
• -nt - രണ്ടാമത്തെ ഫയലേക്കാൾ ആദ്യത്തെ ഫയൽ ഇതാണെങ്കിൽ
• -ot - രണ്ടാമത്തെ ഫയലിനെക്കാൾ ആദ്യ ഫയൽ ആണ്
• -b - ഫയൽ നിലവിലുണ്ട്, അത് പ്രത്യേക ബ്ലോക്ക് ആണ്
• -c - ഫയൽ നിലവിലുണ്ട് കൂടാതെ പ്രതീക പ്രത്യേകതയുമാണ്
• -d - ഫയൽ നിലവിലുണ്ട് ഒരു ഡയറക്ടറിയാണ്
• -e - ഫയൽ നിലവിലുണ്ട്
• -f - ഫയൽ നിലവിലുണ്ട് ഒരു സാധാരണ ഫയൽ ആണ്
• -g - ഫയൽ നിലവിലുണ്ട്, നിർദ്ദിഷ്ട ഗ്രൂപ്പ് നമ്പർ ഉണ്ട്
• -G - ഫയൽ നിലവിലുണ്ട്, ഉപയോക്താവിന്റെ ഗ്രൂപ്പിനാൽ ഉടമസ്ഥൻ
• -h - ഫയൽ നിലവിലുണ്ട് ഒരു പ്രതീകാത്മക ലിങ്കാണ്
• -k - ഫയൽ നിലവിലുണ്ട് അതിന്റെ സ്റ്റിക്കി ബിറ്റ് സെറ്റ് ഉണ്ട്
• -L - അതേ പോലെ -h
• -ഒ - നിങ്ങൾ തന്നെ ആണ് ഉടമസ്ഥൻ
• -p - ഫയൽ നിലവിലുണ്ട്, പേരുള്ള പൈപ്പ് ആണ്
• -r - ഫയൽ നിലവിലുണ്ട് വായിക്കാൻ സാധിക്കും
• -s - ഫയൽ നിലവിലുണ്ട് കൂടാതെ പൂജ്യത്തേക്കാൾ വലിയ വലിപ്പം ഉണ്ട്
• -S - ഫയൽ നിലവിലുണ്ട് ഒരു സോക്കറ്റ് ആണ്
• -t - ഫയൽ ഡിസ്ക്രിപറ്റർ ഒരു ടെർമിനലിൽ തുറക്കുന്നു
• -u - ഫയൽ നിലവിലുണ്ട്, സെറ്റ്-യൂസർ-ഐഡി ബിറ്റ് സെറ്റ് ചെയ്തിരിക്കുന്നു
• -w - ഫയൽ നിലവിലുണ്ട് ഒപ്പം റൈറ്റ് ചെയ്യാവുന്നതുമാണ്
• -x - ഫയൽ നിലവിലുണ്ട് എക്സിക്യൂട്ടബിൾ ആണ്

ഉദാഹരണങ്ങൾ:

test / path / to / file1 -n / path / to / file2 && echo "yes"

(ഫയൽ 1 ഫയൽ 2 ൽ പുതിയതാണ് എങ്കിൽ "അതെ" എന്ന വാക്ക് പ്രദർശിപ്പിക്കപ്പെടും)

test -e / path / to / file1 && echo "yes"

(ഫയൽ 1 ആണെങ്കിൽ "അതെ" എന്ന വാക്ക് പ്രദർശിപ്പിക്കപ്പെടും)

test -O / path / to / file1 && echo "yes"

(നിങ്ങൾക്ക് ഫയൽ 1 ഉണ്ടെങ്കിൽ, "അതെ" എന്ന വാക്കിന് കാണാം)

ടെർമിനോളജി

• തടയുക പ്രത്യേകമായി - ഫയൽ ഒരു ബ്ലോക്ക് ഡിവൈസ് ആണ്, അതായത് ബൈറ്റുകളുടെ ബ്ലോക്കുകളിൽ ഡാറ്റ വായിച്ചാൽ എന്നാണ്. ഇവ സാധാരണയായി ഹാർഡ് ഡ്രൈവുകൾ പോലുള്ള ഡിവൈസ് ഫയലുകളാണ്.
• അക്ഷര സ്പെഷ്യൽ - നിങ്ങൾ അതിലേക്ക് റൈറ്റ് ചെയ്യുമ്പോൾ ഫയൽ ഉടൻ പ്രവർത്തിക്കുന്നു, സാധാരണയായി സീരിയൽ പോർട്ട് പോലുള്ള ഒരു ഉപകരണമാണ് ഇത്

ഒന്നിലധികം വ്യവസ്ഥകൾ താരതമ്യം ചെയ്യുന്നു

ഇതുവരെ എല്ലാം ഒരു കാര്യം മറ്റൊന്നുമായി താരതമ്യം ചെയ്യുന്നുണ്ട്, എന്നാൽ രണ്ട് സാഹചര്യങ്ങൾ താരതമ്യം ചെയ്യാനാണ് നിങ്ങൾ ആഗ്രഹിക്കുന്നത്.

ഉദാഹരണത്തിന്, ഒരു മൃഗത്തിന് 4 കാലുകളുണ്ടെങ്കിൽ "മൂ" എന്നത് ഒരു പശുവാണ്. ലളിതമായി 4 കാലുകൾ പരിശോധിക്കുന്നത് നിങ്ങൾക്ക് ഒരു പശുവിനല്ല, ഉറപ്പുണ്ടാക്കുന്ന ശബ്ദമുണ്ടോ എന്ന് ഉറപ്പ് നൽകുന്നില്ല.

രണ്ട് ഉപാധികളും ഒരേ സമയം പരിശോധിക്കുന്നതിന് ഇനിപ്പറയുന്ന പ്രസ്താവന ഉപയോഗിക്കുക:

test 4 -eq 4 a ഒരു "moo" = "moo" && echo "ഒരു പശു" || എക്കോ "ഒരു പശു"

ഇവിടെ പ്രധാന ഭാഗം -a ആണ്.

ഒരേ ടെസ്റ്റ് നടപ്പിലാക്കുന്നതിനേക്കാൾ നല്ലതും സാധാരണയായി ഉപയോഗിക്കപ്പെടുന്നതുമായ ഒരു മാർഗമുണ്ട്, അത് താഴെക്കൊടുത്തിരിക്കുന്നു:

test 4 -eq 4 && test "moo" = "moo" && echo "ഒരു പശു" || എക്കോ "ഒരു പശു"

നിങ്ങൾ ചെയ്യേണ്ട മറ്റൊരു ടെസ്റ്റ് രണ്ട് പ്രസ്താവനകളെ താരതമ്യം ചെയ്യുന്നു, അല്ലെങ്കിൽ ഒന്നുകിൽ യഥാർത്ഥ ഔട്ട്പുട്ട് ഒരു സ്ട്രിംഗ് ആണെങ്കിൽ. ഉദാഹരണത്തിന്, "file1.txt" എന്ന് പേരുള്ള ഒരു ഫയല് നിലവിലുണ്ടോ അല്ലെങ്കില് "file1.doc" എന്ന് പേരുള്ള ഒരു ഫയല് ഉണ്ടോ എന്ന് പരിശോധിക്കണമെങ്കില് നിങ്ങള്ക്ക് താഴെ പറയുന്ന കമാന്ഡ് ഉപയോഗിക്കാം

test -e file1.txt -o -e file1.doc && echo "file1 exist" || echo "file1 നിലവിലില്ല"

ഇവിടെ പ്രധാന ഭാഗമായ -o ആണ് അല്ലെങ്കിൽ അത് സൂചിപ്പിക്കുന്നു.

ഒരേ ടെസ്റ്റ് നടപ്പിലാക്കുന്നതിനേക്കാൾ നല്ലതും സാധാരണയായി ഉപയോഗിക്കപ്പെടുന്നതുമായ ഒരു മാർഗമുണ്ട്, അത് താഴെക്കൊടുത്തിരിക്കുന്നു:

test -e file1.txt || test -e file1.doc && echo "file1 exist" || echo "file1 നിലവിലില്ല"

ടെസ്റ്റ് കീവേഡ് ഒഴിവാക്കുന്നു

താരതമ്യപഠനം നടപ്പിലാക്കാൻ നിങ്ങൾ യഥാർത്ഥത്തിൽ വാക്ക് ടെസ്റ്റ് ഉപയോഗിക്കേണ്ടതില്ല. ചതുര ബ്രാക്കറ്റിലുള്ള പ്രസ്താവന താഴെ പറഞ്ഞിരിക്കുന്നു.

[-e file1.txt] && echo "file1 നിലവിലുള്ളത്" || echo "file1 നിലവിലില്ല"

ഇത് അടിസ്ഥാനപരമായി ടെസ്റ്റ് പോലെ തന്നെ.

അനവധി അവസ്ഥകൾ താരതമ്യം ചെയ്യുമ്പോൾ താഴെ പറയുന്ന രീതിയിൽ മെച്ചപ്പെടുത്താം എന്ന് നിങ്ങൾക്ക് ഇപ്പോൾ മനസ്സിലാകും:

[4 -eq 4] && ["moo" = "moo"] && echo "ഒരു പശു" || എക്കോ "ഒരു പശു"

[-e file1.txt] || [-e file1.doc] && echo "file1 exist" || echo "file1 നിലവിലില്ല"

സംഗ്രഹം

സ്ക്രിപ്റ്റുകളില് ടെസ്റ്റ് കമാന്ഡ് കൂടുതല് ഉപയോഗപ്രദമാണ്, കാരണം ഒരു വേരിയബിളിന്റെ മറ്റൊരു വേരിയബിള് പരിശോധിച്ച് പ്രോഗ്രാം പ്രവാഹത്തെ നിയന്ത്രിക്കാന് കഴിയും. സ്റ്റാൻഡേർഡ് കമാൻഡ് ലൈനിൽ, ഒരു ഫയൽ നിലവിലുണ്ടോ എന്ന് പരിശോധിക്കാൻ അത് ഉപയോഗിക്കാം