കമാൻഡുകൾ, സിന്റാക്സ്, ഉദാഹരണങ്ങൾ
നിങ്ങള്ക്ക് ഒരു കമാന്ഡ്സ് എക്സ്റ്റന്ഷന് എക്സിക്യൂട്ട് ചെയ്യാം ഒരു സ്ക്രിപ്റ്റ് ഫയലിലേക്ക് എഴുതി അത് ഓടിച്ചാണ്.
ഒരു സ്ക്രിപ്റ്റ് ഫയൽ കേവലം ഒരു ടെക്സ്റ്റ് ഫയലാണു്. സാധാരണയായി SH ഫയൽ എക്സ്റ്റെൻഷൻ, കമാൻഡ് ലൈനിൽ ( ഷെൽ ) നിന്നും എക്സിക്യൂട്ട് ചെയ്യാവുന്ന നിർദ്ദേശങ്ങളുടെ ക്രമം ഉൾക്കൊള്ളുന്നു.
ലൂപ്പ് ഉദാഹരണങ്ങൾ
ഒരു കുറച്ചു ഭാഗത്തേക്കുള്ള ഉദാഹരണമാണ് താഴെ കൊടുത്തിരിക്കുന്നത്. എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ, ഈ സ്ക്രിപ്റ്റ് ഫയൽ സ്ക്രീനിൽ 1 മുതൽ 9 വരെ സംഖ്യകൾ അച്ചടിക്കും. ഇൻ-സ്റ്റേറ്റ്മെന്റ് നിങ്ങൾക്ക് ലൂപ് ചെയ്യാനുള്ള വ്യവസ്ഥയെ വ്യക്തമാക്കുന്നതിനുള്ള കൂടുതൽ വഴക്കം നൽകുന്നു.
#! / bin / bash count = 1 [$ count -le 9] echo "$ count" ഉറക്കം 1 ((count ++)) ചെയ്തുഉദാഹരണത്തിന്, നിങ്ങൾക്ക് മുമ്പത്തെ സ്ക്രിപ്റ്റ് ഇൻക്രിമെൻറ് പ്രസ്താവന ഒഴിവാക്കുന്നതിലൂടെ അനന്തമായ ലൂപ്പ് നിർമ്മിക്കാം "((count ++))":
#! / bin / bash count = 1 [$ count -le 9] echo "$ count" ഉറക്കം 1 ചെയ്തു"ഉറക്കം 1" എന്ന പ്രസ്താവന നടപ്പ് ഓരോ സെക്കൻഡിലും 1 സെക്കൻഡ് വേണ്ടി വധശിക്ഷ നിർത്തുന്നു. പ്രക്രിയ അവസാനിപ്പിക്കാൻ Ctrl + C കീബോർഡ് കുറുക്കുവഴി ഉപയോഗിക്കുക.
ഒരു കോളണിയെ ഈ അവസ്ഥയിൽ ഇട്ടുകൊണ്ട് നിങ്ങൾക്ക് അനന്തമായ ലൂപ്പ് സൃഷ്ടിക്കാൻ കഴിയും:
#! / bin / bash count = 1 while: echo "$ count" ഉറക്കം 1 ((count ++)) ചെയ്തുWhile-loop- ൽ ഒന്നിലധികം കൺഡിഷനുകൾ ഉപയോഗിക്കുന്നതിന്, നിങ്ങൾ ഇരട്ട ചതുര ബ്രാക്കറ്റ് നോട്ടേഷൻ ഉപയോഗിക്കേണ്ടതുണ്ട്:
count = 1 done = 0 ആകുമ്പോൾ [[$ count -le 9] && [$ പൂർത്തിയായി == 0]] [$ count == 5] ആണെങ്കിൽ echo "$ count" ഉറക്കം 1 ((count ++)) ചെയ്യുന്നു; പിന്നീട് $ ചെയ്തു = 1 fi ചെയ്തുഈ സ്ക്രിപ്റ്റിൽ, വേരിയബിൾ "പൂർത്തിയായി" ആരംഭിക്കുകയും 0-ൽ എത്തുകയും ചെയ്യുമ്പോൾ 1 ആയി സജ്ജമാക്കുകയും ചെയ്യുന്നു. ലൂപ്പ് അവസ്ഥ അനുസരിച്ച് "ലൂപ്പ്" ഒൻപത് കുറവും "പൂർത്തിയായിക്കഴിഞ്ഞു" പൂജ്യത്തിലേക്ക്. അതിനാൽ ഈ സംഖ്യ 5 ന് തുല്യമാകുമ്പോൾ ലൂപ്പുകൾ പുറത്തുകടക്കുന്നു.
"&&" എന്നാൽ "ലോജിക്കൽ", "", "||" "ലോജിക്കൽ" അല്ലെങ്കിൽ ".
സങ്കലനങ്ങൾക്ക് "ബൾഡനുകളുടെ", "" അല്ലെങ്കിൽ "" സാഹചര്യങ്ങളിൽ ബദൽ നൊട്ടേഷൻ "" ഒരു "" -ഒരു ചതുര ബ്രാക്കറ്റുകളുമുണ്ട്. മുകളിലെ അവസ്ഥ:
[[$ count -le 9] && [$ പൂർത്തിയായി == 0]]ഇങ്ങനെ എഴുതിയിരിക്കുന്നു:
[$ count -le 9] -a [$ പൂർത്തിയായി == 0]ഒരു വാചക ഫയൽ വായിക്കുന്നത് സാധാരണയായി കുറച്ചു സമയം കൊണ്ട് ചെയ്യുന്നു. താഴെ കാണിക്കുന്ന ഉദാഹരണത്തിൽ, "inventory.txt:" എന്ന പേരിൽ ഒരു വരിയിൽ നിന്നുമുള്ള ബാഷ് സ്ക്രിപ്റ്റ് ഉള്ളടക്കം വരികൾ വായിക്കുന്നു.
FILE = inventory.txt exec 6ആദ്യ വരി ഇൻപുട്ട് ഫയൽ നാമം "FILE" വേരിയബിളായി നൽകുന്നു. രണ്ടാമത്തെ വരി "ഡിസ്ട്രിക്ട്" ലെ "സ്റ്റാൻഡേർഡ് ഇൻപുട്ട്" (ഇത് 3 നും 9 നും ഇടയിലുള്ള ഏതൊരു മൂല്യവും ആയിരിക്കും) ചെയ്യുന്നു. ഇത് "സ്റ്റാൻഡേർഡ് ഇൻപുട്ട്" ഉപയോഗിച്ച് സ്ക്രിപ്റ്റിന്റെ അവസാനത്തിൽ ഫയൽ ഡിസ്ക്രിപ്റ്റർ "0" ലേക്ക് പുനഃസ്ഥാപിക്കാനാകും (പ്രസ്താവന "എക്സിക്യൂട്ട് കാണുക" കാണുക 3rd വരിയിൽ ഇൻപുട്ട് ഫയൽ ഫയൽ ഡിസ്ക്രിപ്റ്റർ "0" ആണ് ഉപയോഗിക്കുന്നത്. സ്റ്റാൻഡേർഡ് ഇൻപുട്ടിനായി "വായിക്കുന്ന" സ്റ്റേറ്റ്മെന്റ് ഓരോ ആവർത്തനത്തിലും ഫയലിൽ നിന്നുള്ള ഒരു വരി വായിക്കുകയും "ലൈൻ 1" വേരിയബിളിന് നൽകുകയും ചെയ്യുന്നു.
അപ്രതീക്ഷിതമായി ഒരു കുറച്ചു ലാപ്ടോപ്പിൽ നിന്ന് പുറത്തുകടക്കാൻ നിങ്ങൾക്കിത് ബ്രേക്ക് സ്റ്റേറ്റ്മെന്റ് ഉപയോഗിക്കാം:
count = 1 done = 0 while [$ count -le 9] echo "$ count" ഉറക്കം 1 ((count ++)) [$ count == 5] എങ്കിൽ echo പൂർത്തിയായിബ്രേക്ക് സ്റ്റേറ്റ്മെൻറ് അവസാനിക്കുന്നതിനിടയിൽ പ്രോഗ്രാം പ്രവർത്തിപ്പിയ്ക്കുകയും, താഴെ പറഞ്ഞിരിയ്ക്കുന്ന ഏതെങ്കിലും പ്രസ്താവനകൾ നടപ്പിലാക്കുകയും ചെയ്യുന്നു. ഈ സാഹചര്യത്തിൽ, പ്രസ്താവന "echo പൂർത്തിയായി."
തുടരുന്ന പ്രസ്താവന, നിലവിലെ ആവർത്തനത്തിന്റെ ശേഷിക്കുന്ന ലൂപ്പ് പ്രസ്താവന മാത്രം ഉപേക്ഷിക്കുകയും അടുത്ത ആവർത്തനത്തിലേക്ക് നേരിട്ട് ചാടുകയും ചെയ്യുന്നു:
count = 1 done = 0 while [$ count -le 9] ഉറങ്ങുക 1 ((count ++)) [$ count == 5] എങ്കിൽ "fi echo" $ count "പൂർത്തിയായി echo പൂർത്തിയായിഈ സന്ദർഭത്തിൽ, "തുടരുന്നു" വേരിയബിൾ "കണ്ട്" 5 മാറുമ്പോൾ "തുടരുന്നു" സ്റ്റേറ്റ്മെന്റ് എക്സിക്യൂട്ട് ചെയ്യുന്നു. ഇതിനർത്ഥം തുടർന്നുള്ള പ്രസ്താവന (echo "$ count") ഈ ആവർത്തനത്തിൽ നടപ്പിലാക്കുന്നില്ല എന്നാണ് ("എണ്ണ" 5 എന്നതിന്റെ മൂല്യം).