ഷെൽ സ്uക്രിപ്uറ്റുകളിൽ ബ്രേക്ക്, കൺടിന്യൂ സ്റ്റേറ്റ്uമെന്റുകൾ എങ്ങനെ ഉപയോഗിക്കാം

ഈ ലേഖനത്തിൽ, എങ്ങനെ ഒരു ബ്രേക്ക് ഉപയോഗിക്കാമെന്നും ബാഷ് സ്ക്രിപ്റ്റുകളിൽ തുടരാമെന്നും നോക്കാം. ബാഷിൽ, ഞങ്ങൾക്ക് മൂന്ന് പ്രധാന ലൂപ്പ് കൺസ്ട്രക്uറ്റുകൾ ഉണ്ട് (ഇപ്പോൾ, വരെ). ബ്രേക്ക് ആന്റ് തുടരുക പ്രസ്താവനകൾ ബാഷ് ബിൽറ്റിൻ ആണ്, നിങ്ങളുടെ ലൂപ്പുകളുടെ ഒഴുക്ക് മാറ്റാൻ ഉപയോഗിക്കുന്നു. പൈത്തൺ പോലുള്ള ജനപ്രിയ പ്രോഗ്രാമിംഗ് ഭാഷകളിൽ ബ്രേക്ക് ആന്റ് കൺട്രോൾ എന്ന ഈ ആശയം ലഭ്യമാണ്.

$ type -a break continue

ഒരു ബ്രേക്ക് സ്റ്റേറ്റ്മെന്റ് ഉപയോഗിച്ച് ലൂപ്പിൽ നിന്ന് പുറത്തുകടക്കുക

ബ്രേക്ക് സ്റ്റേറ്റ്uമെന്റ് ലൂപ്പിൽ നിന്ന് പുറത്തുകടക്കുകയും നിയന്ത്രണം ലൂപ്പിലെ അടുത്ത സ്റ്റേറ്റ്uമെന്റിലേക്ക് കൈമാറുകയും ചെയ്യും. ബ്രേക്ക് സ്റ്റേറ്റ്uമെന്റിനെക്കുറിച്ചുള്ള ചില വിവരങ്ങൾ ലഭിക്കുന്നതിന് നിങ്ങൾക്ക് സഹായ കമാൻഡ് പ്രവർത്തിപ്പിക്കാം.

$ help break

ബ്രേക്കിന്റെ അടിസ്ഥാന വാക്യഘടന.

$ break [n]

n is optional

താഴെ കൊടുത്തിരിക്കുന്ന ഉദാഹരണം നോക്കുക. 2 ന്റെ ഇൻക്രിമെന്റൽ സ്റ്റെപ്പിൽ 1 മുതൽ 20 വരെയുള്ള മൂല്യങ്ങളുടെ ഒരു ശ്രേണിയിൽ ആവർത്തിക്കുന്ന ലൂപ്പിനുള്ള ലളിതമാണിത്. സോപാധിക പ്രസ്താവന പദപ്രയോഗത്തെ വിലയിരുത്തും, അത് ശരിയാകുമ്പോൾ ($val = 9) അത് ബ്രേക്ക് സ്റ്റേറ്റ്മെന്റ് പ്രവർത്തിപ്പിക്കുകയും ചെയ്യും. ശേഷിക്കുന്ന ആവർത്തനങ്ങൾ ഒഴിവാക്കിക്കൊണ്ട് ലൂപ്പ് അവസാനിപ്പിക്കും.

#!/usr/bin/bash

for val in {1..20..2}
do
  If [[ $val -eq 9 ]]
  then
     break
  else
  echo "printing ${val}"
fi
done

തുടരുന്ന പ്രസ്താവന ഉപയോഗിച്ച് ഒരു ആവർത്തനം ഒഴിവാക്കുക

നിങ്ങൾക്ക് ലൂപ്പിൽ നിന്ന് പൂർണ്ണമായും പുറത്തുകടക്കാൻ താൽപ്പര്യമില്ലെങ്കിലും ഒരു നിശ്ചിത വ്യവസ്ഥ പാലിക്കുമ്പോൾ കോഡിന്റെ ബ്ലോക്ക് ഒഴിവാക്കിയാലോ? ഒരു തുടർ പ്രസ്താവനയിലൂടെ ഇത് ചെയ്യാൻ കഴിയും. ഒരു നിശ്ചിത വ്യവസ്ഥ പാലിക്കുകയും അടുത്ത ആവർത്തനത്തിനായി നിയന്ത്രണം ലൂപ്പ് സ്റ്റേറ്റ്uമെന്റിലേക്ക് തിരികെ നൽകുകയും ചെയ്യുമ്പോൾ Continue Statement കോഡ് ബ്ലോക്കിന്റെ നിർവ്വഹണം ഒഴിവാക്കും.

സഹായം ആക്സസ് ചെയ്യാൻ.

$ help continue

താഴെ കൊടുത്തിരിക്കുന്ന ഉദാഹരണം നോക്കുക. ബ്രേക്ക് സ്റ്റേറ്റ്uമെന്റ് തെളിയിക്കാൻ ഞങ്ങൾ ഉപയോഗിച്ച അതേ ഉദാഹരണമാണിത്. ഇപ്പോൾ Val നെ ഒമ്പതായി വിലയിരുത്തുമ്പോൾ, തുടരുന്ന പ്രസ്താവന, കോഡിന്റെ ശേഷിക്കുന്ന എല്ലാ ബ്ലോക്കുകളും ഒഴിവാക്കുകയും അടുത്ത ആവർത്തനത്തിനായി ലൂപ്പിനായി നിയന്ത്രണം കൈമാറുകയും ചെയ്യും.

#!/usr/bin/bash

for val in {1..20..2}
do
  If [[ $val -eq 9 ]]
  then
      continue
  fi
  echo "printing ${val}"
done

നിങ്ങൾക്ക് പൈത്തണിനെ അറിയാമായിരുന്നെങ്കിൽ ബ്രേക്ക് ചെയ്ത് തുടരുന്ന സ്വഭാവം പൈത്തണിലും സമാനമാണ്. എന്നാൽ പൈത്തൺ ഒരു പാസ് എന്ന ലൂപ്പ് കൺട്രോൾ സ്റ്റേറ്റ്uമെന്റ് കൂടി നൽകുന്നു.

പാസ് ഒരു ശൂന്യമായ പ്രസ്താവന പോലെയാണ്, വ്യാഖ്യാതാവ് അത് വായിക്കും, പക്ഷേ ഒരു പ്രവർത്തനവും നടത്തില്ല. ഇത് കേവലം ഒരു പ്രവർത്തനത്തിനും കാരണമാകില്ല. ബാഷ് സമാനമായ ഒരു പ്രസ്താവന നൽകുന്നില്ല, എന്നാൽ യഥാർത്ഥ കീവേഡ് അല്ലെങ്കിൽ കോളൻ (:) ഉപയോഗിച്ച് ഞങ്ങൾക്ക് ഈ സ്വഭാവം അനുകരിക്കാം. ശരിയും കോളണും ഷെൽ ബിൽഡിൻ ആണ്, ഒരു പ്രവർത്തനവും നടത്തില്ല.

$ type -a : true

താഴെ കൊടുത്തിരിക്കുന്ന ഉദാഹരണം നോക്കുക. ഒരു സോപാധിക പ്രസ്താവന ശരിയാണെന്ന് വിലയിരുത്തുമ്പോൾ ($val = 9) അപ്പോൾ യഥാർത്ഥ പ്രസ്താവന ഒന്നും ചെയ്യില്ല, ലൂപ്പ് തുടരും.

#!/usr/bin/bash

for val in {1..20..2}
do
  If [[ $val -eq 9 ]]
  then
      true
  fi
  echo "printing ${val}"
done

ഈ ലേഖനത്തിന് അത്രയേയുള്ളൂ. നിങ്ങളുടെ വിലയേറിയ ഫീഡ്uബാക്കും നിങ്ങൾക്ക് ഉള്ള നുറുങ്ങുകളും കേൾക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു.