ലൂപ്പിനുള്ള ഒരു ബാഷ് എഴുതാൻ എങ്ങനെ

ഷെൽ സ്ക്രിപ്റ്റുകളിലെ ബോഷിനെ "എങ്ങനെ" എന്നതിനായി ഉപയോഗിക്കാമെന്നത്

മിക്ക ലിനക്സ് , യുണിക്സ് അടിസ്ഥാന ഓപ്പറേറ്റിങ് സിസ്റ്റങ്ങളും ഉപയോഗിയ്ക്കുന്ന ഒരു സ്ക്രിപ്റ്റിങ് ഭാഷയാണ് ബാഷ് (ബോൺ എഗൻ ഷെല്ല്).

മറ്റേതിന് ശേഷം ഒരു ടെർമിനൽ വിൻഡോയിൽ നിങ്ങൾക്ക് BASH കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കാം അല്ലെങ്കിൽ ഷെൽ സ്ക്രിപ്റ്റ് നിർമ്മിക്കുന്നതിന് ഒരു ടെക്സ്റ്റ് ഫയലിലേക്ക് കമാൻഡുകൾ ചേർക്കാൻ കഴിയും.

ഷെൽ സ്ക്രിപ്റ്റുകൾ എഴുതുവാനുള്ള മഹത്തായ കാര്യം നിങ്ങൾക്ക് വീണ്ടും വീണ്ടും ഓടിക്കാൻ കഴിയും എന്നതാണ്. ഉദാഹരണമായി നിങ്ങൾ ഒരു ഉപയോക്താവിനെ ഒരു സിസ്റ്റത്തിലേക്ക് ചേർക്കുകയും അവരുടെ അനുമതികൾ സജ്ജമാക്കുകയും അവരുടെ തുടക്ക പരിസ്ഥിതി കൈകാര്യം ചെയ്യേണ്ടതുണ്ടാവുകയും ചെയ്യുക. ഒരു കഷണം പേപ്പറിൽ കമാൻഡുകൾ എഴുതുകയും നിങ്ങൾ പുതിയ ഉപയോക്താക്കളെ ചേർക്കുമ്പോൾ അവയെ ഓടിക്കുകയും ചെയ്യാം, അല്ലെങ്കിൽ നിങ്ങൾക്ക് ഒരു സ്ക്രിപ്റ്റ് എഴുതാനും ആ സ്ക്രിപ്റ്റിലേക്ക് പാരാമീറ്ററുകൾ മാത്രം കടന്നുപോകാനും കഴിയും.

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

ഏതെങ്കിലും പ്രോഗ്രാമിങ്ങും സ്ക്രിപ്റ്റിങ് ഭാഷയും ഒരു പ്രധാന ഭാഗമാണ്, അതേ കോഡ് കോപ്പി വീണ്ടും വീണ്ടും പ്രവർത്തിപ്പിക്കാനുള്ള കഴിവാണ്.

കോഡ് ആവർത്തിക്കാനുള്ള പല മാർഗ്ഗങ്ങളുണ്ട് (ലൂപുകൾ എന്നും അറിയപ്പെടുന്നു). ഈ ഗൈഡിൽ, നിങ്ങൾക്ക് ഒരു "for" loop എങ്ങനെ എഴുതാം എന്ന് കാണിക്കും.

ലൂപ്പിന് വേണ്ടി ഒരു കോഡിന്റെ ഒരു ഭാഗം വീണ്ടും വീണ്ടും ആവർത്തിക്കുന്നു. അവ ഒരു പ്രയോഗം ആകുന്നു, അതിലൂടെ അവർ നിർത്തും.

ഈ ഗൈഡിൽ, നിങ്ങൾ ഒരു ബാഷ് ലിപിയിലുള്ള ലൂപ്പ് ഉപയോഗിക്കാൻ അഞ്ച് വഴികൾ കാണിക്കും.

ആരംഭിക്കുന്നതിന് മുമ്പായി

നിങ്ങൾ ലൂപ്പ് ഉദാഹരണങ്ങൾക്കായി ആരംഭിക്കുന്നതിനുമുമ്പ്, ഒരു ടെർമിനൽ വിൻഡോ തുറന്ന് ഈ ഘട്ടങ്ങൾ പാലിക്കണം:

1. Mkdir സ്ക്രിപ്റ്റുകൾ നൽകുക ( ഇവിടെ mkdir നെക്കുറിച്ച് കൂടുതലറിയുക )
2. സിഡി സ്ക്രിപ്റ്റുകൾ നൽകുക (ഇത് ഡയറക്ടറിയെ സ്ക്രിപ്റ്റാക്കി മാറ്റുന്നു )
3. നാനോ examplen.sh നൽകുക ( n എവിടെയാണ് നിങ്ങൾ പ്രവർത്തിക്കുന്നത്)
4. സ്ക്രിപ്റ്റ് നൽകുക
5. പുറത്തുകടക്കാൻ CTRL + O അമർത്തുക, CTRL + X അമർത്തുക
6. പ്രവർത്തിപ്പിക്കുക bash examplen.sh (വീണ്ടും, നിങ്ങൾ പ്രവർത്തിച്ചതിന്റെ ഉദാഹരണം)

ഒരു പട്ടികയിൽ നിന്ന് എങ്ങനെ ലൂപ്പ് ചെയ്യണം

#! / bin / bash
1 2 3 4 5
ചെയ്യുക
echo $ number
ചെയ്തു
പുറത്തുകടക്കുക 0

പല പ്രോഗ്രാമുകളും സ്ക്രിപ്റ്റിംഗ് ഭാഷകളും കണ്ണികൾക്കായി "വേണ്ടി" കൈകാര്യം ചെയ്യുന്ന രീതികൾക്കായി "വേണ്ടി" ലൂപ്പുകൾ ഉപയോഗിക്കുന്ന ബാഷ് രീതി വ്യത്യസ്തമാണ്. സ്ക്രിപ്റ്റ് താഴേക്കിറക്കാം ...

ഒരു ബാഷിൽ "ഫോർ" എന്നതിനൊപ്പം, ചെയ്യേണ്ടതും പൂർത്തിയാക്കുന്നതുമായ ഓരോ പ്രസ്താവനയും ലിസ്റ്റിലെ ഓരോ ഇനത്തിനും ഒരിക്കൽ നടപ്പിലാക്കും.

മുകളില് പറഞ്ഞിരിക്കുന്ന ഉദാഹരണത്തില്, പട്ടികയില് വരുന്ന വാക്കുകള് (അതായത് 1 2 3 4 5) ആണ്.

ഓരോ തവണയും ലൂപ്പ് അത്റ്റെടുക്കുന്നു, പട്ടികയിലെ അടുത്ത മൂല്യം "for" എന്ന വാക്കിൽ പറഞ്ഞിരിക്കുന്ന വേരിയബിളിലേക്ക് തിരുകുന്നു. മുകളിലുള്ള ലൂപ്പില്, വേരിയബിള് നമ്പര് എന്നു പറയുന്നു .

സ്ക്രീനിലേക്കു് വിവരങ്ങൾ ലഭ്യമാക്കുന്നതിനു് echo സ്റ്റേറ്റ്മെന്റ് ഉപയോഗിയ്ക്കുന്നു.

അതിനാൽ, ഈ ഉദാഹരണം സംഖ്യകൾ 1 മുതൽ 5 വരെ എടുക്കുകയും അവയെ ഓരോന്നായി സ്ക്രീനിൽ ഒറ്റയടിക്കുകയും ചെയ്യുന്നു:

• 1
• 2
• 3
• 4
• 5

ഒരു ആരംഭ, അവസാന പോയിന്റ് തമ്മിലുള്ള ലൂപ്പ് എങ്ങനെ

ഒരു വലിയ പട്ടിക (500 മുതൽ 1 വരെ) നിങ്ങൾക്ക് പ്രക്രിയപ്പെടുത്തണമെങ്കിൽ, എല്ലാ നമ്പറുകളും ആദ്യം ടൈപ്പുചെയ്യാൻ ഇത് എടുക്കും.

ഇത് ഒരു ആരംഭ, അവസാന പോയിന്റ് എങ്ങനെ വ്യക്തമാക്കാമെന്ന് കാണിക്കുന്ന രണ്ടാമത്തെ ഒരു ഉദാഹരണം നൽകുന്നു.

#! / bin / bash
{1.10} മാസത്തിനുള്ളിൽ
ചെയ്യുക
echo "$ number"
ചെയ്തു
പുറത്തുകടക്കുക 0

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

പ്രധാന വ്യത്യാസം പട്ടിക രൂപപ്പെടുന്നത് പോലെയാണ്. ചുരുളൻ ബ്രാക്കറ്റുകൾ {} ഒരു ശ്രേണിയെ സൂചിപ്പിക്കുന്നു, ഈ ശ്രേണിയിൽ 1 മുതൽ 10 വരെയാണ് (രണ്ട് ഡോട്ടുകളും ഒരു പരിധിയുടെ തുടക്കവും അവസാനവും).

ഈ ഉദാഹരണം, ഓരോ നംബറിലും 1- നും 10 നും ഇടയിലാണ്, താഴെ പറഞ്ഞിരിക്കുന്നത് പോലെ സ്ക്രീനിൽ താഴെ കാണിക്കുന്നു:

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10

ആദ്യത്തെ ഉദാഹരണം പോലെ തന്നെ സമാനമായ വാക്യഘടനയും ഇതേ എഴുതിയിരിക്കാം:

1 2 3 4 5 6 7 8 9 10

ഒരു ശ്രേണിയിൽ അക്കങ്ങളെ ഒഴിവാക്കുന്നത് എങ്ങനെ

ഒരു എൻഡ് എൻഡ് പോയിന്റ് തമ്മിലുള്ള ലൂപിലൂടെ എങ്ങനെയുണ്ടെന്ന് മുൻ ഉദാഹരണം കാണിച്ചു. അതിനാൽ നമ്മൾ പരിധിയിലെ സംഖ്യകളെ എങ്ങനെ ഒഴിവാക്കണം എന്ന് നോക്കാം.

നിങ്ങൾ 0-നും 100-നും ഇടയിൽ വളക്കുവാൻ ആഗ്രഹിക്കുന്നെങ്കിലും ഓരോ പത്താമത്തെ എണ്ണവും കാണിക്കുക. താഴെ കൊടുത്തിരിക്കുന്ന സ്ക്രിപ്റ്റ് എങ്ങനെ ചെയ്യാമെന്ന് കാണിച്ചുതരുന്നു:

#! / bin / bash
{0.10000..10} ലെ എണ്ണത്തിൽ
ചെയ്യുക
echo "$ number"
ചെയ്തു
പുറത്തുകടക്കുക 0

നിയമങ്ങൾ അടിസ്ഥാനപരമായി സമാനമാണ്. ചെയ്യാനും ചെയ്യാനും കഴിയുന്ന ഒരു ലിസ്റ്റ്, ഒരു വേരിയബിൾ, ഒരു കൂട്ടം സ്റ്റേറ്റ്മെന്റുകൾ ഉണ്ട്. ഈ സമയം ഈ ലിസ്റ്റ് കാണപ്പെടുന്നു: {0.100..10}.

ആദ്യത്തെ സംഖ്യ 0 ആണ്, അവസാന സംഖ്യ 100 ആണ്. മൂന്നാമത്തെ സംഖ്യ (10) എന്നത് ഒഴിവാക്കുന്ന പട്ടികയിലെ ഇനങ്ങളുടെ എണ്ണമാണ്.

മുകളിൽ പറഞ്ഞിരിക്കുന്ന ഉദാഹരണത്തിൽ, താഴെ പറയുന്ന ഔട്ട്പുട്ട് കാണിക്കുന്നു:

• 0
• 10
• 20
• 30
• 40
• 50
• 60
• 70
• 80
• 90
• 100

ലൂപ്പിനായുള്ള കൂടുതൽ പരമ്പരാഗതമായി തിരയുന്നു

മറ്റ് പ്രോഗ്രാമിംഗ് ഭാഷകളുമായി താരതമ്യപ്പെടുത്തുമ്പോൾ ലൂപ്പുകളുടെ എഴുതാനുള്ള ബിഷ് വഴി അല്പം വിചിത്രമാണ്.

എന്നിരുന്നാലും സി പ്രോഗ്രാമിങ് ഭാഷയ്ക്ക് സമാനമായ രീതിയിൽ നിങ്ങൾക്ക് ലൂപ്പിനുള്ള ഒരു റൈറ്റ് എഴുതാം, ഇതുപോലെ:

#! / bin / bash
((നമ്പർ = 1; നമ്പർ <100; നമ്പർ ++))
{
(($ 5% == 0))
പിന്നെ
echo "$ 5 വേർതിരിച്ചറിയാം"
fi
}
പുറത്തുകടക്കുക 0

വേരിയബിൾ സംഖ്യ 1 (നമ്പർ = 1 ) ആയി ക്രമീകരിച്ചുകൊണ്ട് ലൂപ്പ് ആരംഭിക്കുന്നു. ഒരു സംഖ്യയുടെ മൂല്യം 100 ൽ കുറവാണെങ്കിൽ ( ലൂട്ട് <100 ). ഓരോ നവീകരണത്തിനു ശേഷവും അതിലേക്ക് 1 എണ്ണം ചേർത്തുകൊണ്ട് നമ്പർ മാറ്റങ്ങളുടെ മൂല്യം ( നമ്പർ ++ ).

ലൂപ്പിയിലെ ഓരോ ആവർത്തനത്തിലൂടെയും വളഞ്ഞ ബ്രെയ്സുകൾക്കിടയിലുള്ള എല്ലാം ചെയ്യുന്നു.

ബ്രെയ്സ് തമ്മിലുള്ള ഒരു ബിറ്റ്, ഒരു സംഖ്യയുടെ മൂല്യം പരിശോധിക്കുന്നു, അതിനെ 5 ആക്കി, ബാക്കിയുള്ളതിൽ ഒരെണ്ണം താരതമ്യം ചെയ്യുന്നു. ബാക്കി 0 ആണെങ്കിൽ, സംഖ്യ 5 ആയി വേർതിരിക്കുകയും തുടർന്ന് സ്ക്രീനിൽ പ്രദർശിപ്പിക്കുകയും ചെയ്യുന്നു.

ഉദാഹരണത്തിന്:

• 5 കൊണ്ട് 5 ആക്കിത്തീർക്കാം
• 10 എന്നത് 5 കൊണ്ട് ഹരിച്ചാണ്
• 15 ആണ് 5 കൊണ്ട് വിഭജിക്കപ്പെടുന്നത്

നിങ്ങൾ iteration ന്റെ ഘടനയുടെ വലുപ്പം മാറ്റണമെങ്കിൽ നിങ്ങൾ നമ്പർ = സംഖ്യ + 2 , നമ്പർ = സംഖ്യ + 5 , അല്ലെങ്കിൽ നമ്പർ = സംഖ്യ + 10 എന്ന നമ്പർ ആയി ++ വിഭാഗം പരിഷ്കരിക്കാം.

ഇത് വീണ്ടും + = 2 അല്ലെങ്കിൽ നമ്പർ + = 5 ആയി കുറയ്ക്കുവാൻ കഴിയും.

ഒരു പ്രായോഗിക ഉദാഹരണം

സംഖ്യകൾക്ക് ആവർത്തന ലിസ്റ്റുകളേക്കാൾ കൂടുതൽ ചെയ്യാൻ കഴിയും. പട്ടികയിൽ നിന്ന് നിങ്ങൾക്ക് മറ്റ് ആജ്ഞകളുടെ ഔട്ട്പുട്ട് ഉപയോഗിക്കാവുന്നതാണ്.

MP3 ൽ നിന്നും WAV ലേക്ക് ഓഡിയോ ഫയലുകൾ എങ്ങനെ പരിവർത്തനം ചെയ്യുന്നു എന്ന് താഴെക്കാണിച്ചിരിക്കുന്ന ഉദാഹരണം കാണിക്കുന്നു:

#! / bin / bash

ഈ ഉദാഹരണത്തിലെ പട്ടിക ഓരോ ഫയലും നിലവിലെ ഫോൾഡറിൽ മെസഞ്ചർ 3 വിപുലീകരണവും വേരിയബിളും ആണ്.

Mpg കമാൻഡ് MP3 ഫയൽ WAV ആയി മാറ്റുന്നു. എന്നിരുന്നാലും, ആദ്യം നിങ്ങളുടെ പാക്കേജ് മാനേജർ ഉപയോഗിക്കേണ്ടതുണ്ട്.