బాష్ (బోర్న్ ఎగైన్ షెల్) అనేది GNU/Linux ఆపరేటింగ్ సిస్టమ్‌లలో షెల్ కమాండ్ ప్రాంప్ట్ మరియు స్క్రిప్టింగ్ భాష. ఇది చాలా Linux పంపిణీలకు డిఫాల్ట్ షెల్.
చాలా స్క్రిప్టింగ్ భాషల వలె, బాష్ సారూప్య పనులను అనేకసార్లు పునరావృతం చేయడానికి లూప్ సింటాక్స్‌లను అందిస్తుంది. ఈ ఆర్టికల్లో, మేము ఎలా ఉపయోగించాలో నేర్చుకుంటాము కోసం బాష్‌లో లూప్.
పరిచయం
ఒక సాధారణ బాష్ స్క్రిప్ట్ ఒకదాని తర్వాత మరొకటి అమలు చేయడానికి ఆదేశాల శ్రేణిని కలిగి ఉంటుంది. స్ట్రింగ్స్, పూర్ణాంక సూచిక విలువలు, కమాండ్ ఫలితాలు మొదలైనవాటిని నిల్వ చేయడానికి వేరియబుల్స్ ఉపయోగించవచ్చు. వినియోగదారు నిర్దిష్ట ఆదేశాన్ని అనేకసార్లు అమలు చేయాలనుకున్నప్పుడు లూప్‌లు అవసరం. ఒక కమాండ్ యొక్క అవుట్‌పుట్ జాబితా రూపంలో ఉన్నప్పుడు మరియు ప్రతి ఫలితంపై, జాబితాలో, రెండవ ఆదేశాన్ని అమలు చేయాల్సి వచ్చినప్పుడు ఇది ప్రత్యేకంగా ఉపయోగపడుతుంది.
సాధారణ వాక్యనిర్మాణం
కోసం సాధారణ వాక్యనిర్మాణం కోసం బాష్‌లోని లూప్:
ఇన్ డూ ...... పూర్తయిందిఇక్కడ, ది బాష్ వేరియబుల్, ఇది తప్పనిసరిగా చెల్లుబాటు అయ్యే Linux షెల్ వేరియబుల్ పేరు అయి ఉండాలి, అనగా, పేరు అక్షరాలు(az, AZ), సంఖ్యలు (0-9) మరియు అండర్ స్కోర్ (_ ) కలయికను కలిగి ఉంటుంది మరియు ఇది తప్పనిసరిగా ఒక అక్షరంతో ప్రారంభం కావాలి లేదా ఒక అండర్ స్కోర్.
ది లూప్ చేయబడే పూర్ణాంకాల సూచికల అనుకూల పరిధి లేదా పూర్ణాంకాల లేదా స్ట్రింగ్‌ల అనుకూల జాబితా. ఇది మరొక Linux కమాండ్‌ను కూడా కలిగి ఉండవచ్చు, అయితే, అటువంటి కమాండ్ యొక్క అవుట్‌పుట్ తప్పనిసరిగా ఖాళీలు లేదా కొత్త లైన్ అక్షరాలతో వేరు చేయబడాలి, అనగా, Bash ద్వారా జాబితాగా అన్వయించవచ్చు (బాష్‌లోని జాబితా ప్రాథమికంగా స్పేస్ లేదా కొత్త లైన్ ద్వారా వేరు చేయబడిన విలువల సమాహారం. )
ఏ కమాండ్(లు) అమలు చేయాలన్నా దాని లోపల తప్పనిసరిగా ఉంచాలి చేయండి..చేసింది నిరోధించు.
కొన్ని సాధారణ ఉదాహరణలను చూద్దాం.
పూర్ణాంకాల విలువల శ్రేణిపై లూప్ చేస్తోంది: క్రింది కోడ్ dir1, dir2, dir3 అనే డైరెక్టరీలను dir10 వరకు సృష్టిస్తుంది.
నేను {1..10}లో ఉన్నానుస్థిర విలువల జాబితాలో లూపింగ్: కింది కోడ్ ఇచ్చిన స్థిర జాబితాలోని ప్రతి స్ట్రింగ్ లేదా పూర్ణాంకాన్ని ముద్రిస్తుంది.
నేను హలో 1 2 3 లో బై! ప్రతిధ్వని చేయండి $నేను పూర్తి చేసానుకమాండ్ అవుట్‌పుట్‌పై లూపింగ్: యొక్క అవుట్‌పుట్‌పై క్రింది కోడ్ లూప్ అవుతుంది ls మరియు ఇచ్చిన ఫార్మాట్‌లో ప్రతి ఫైల్ పేరును ప్రింట్ చేస్తుంది.
నేను `ls`లో ఎకో "ఫైల్‌నేమ్ $i" చేయడం పూర్తయిందివ్యక్తీకరణ ఆధారిత సింటాక్స్
C ప్రోగ్రామింగ్ లాంగ్వేజ్ మాదిరిగానే వ్యక్తీకరణ-ఆధారిత సింటాక్స్ కూడా బాష్‌లో సాధ్యమవుతుంది:
((వ్యక్తీకరణ 1; వ్యక్తీకరణ 2; వ్యక్తీకరణ 3)) కోసం ... ... పూర్తయిందిఇక్కడ, వ్యక్తీకరణ 1 ఇండెక్స్ వేరియబుల్(లు) యొక్క ప్రారంభీకరణ. వ్యక్తీకరణ 2 లూప్ తప్పనిసరిగా నిష్క్రమించాల్సిన పరిస్థితి; ఈ పరిస్థితి ప్రతి పునరావృతంలో తనిఖీ చేయబడుతుంది. వ్యక్తీకరణ 3 ఇండెక్స్ వేరియబుల్(ల) విలువలో పెంపు/తరుగుదల/మార్పును నిర్దేశిస్తుంది
కింది ఉదాహరణ కేవలం 0 నుండి 4 వరకు విలువలను ముద్రిస్తుంది:
కోసం ((i=0;i<5;i++)) echo $i పూర్తయిందికింది ఉదాహరణ అనంతమైన లూప్‌ను సృష్టిస్తుంది, ఎందుకంటే వ్యక్తీకరణలు ఏవీ పేర్కొనబడలేదు:
(( ; )) ప్రతిధ్వని చేయడం కోసం "ఆపడానికి Ctrl-C నొక్కండి" పూర్తయిందిబ్రేక్ చేసి కొనసాగించండి
షరతులతో కూడిన నిష్క్రమణ కోసం బ్రేక్ స్టేట్‌మెంట్
మేము షరతులతో కూడిన ప్రకటనను కూడా ఉపయోగించవచ్చు ఉంటే లూప్ లోపల. ది ఉంటే ప్రకటనను a తో ఉపయోగించవచ్చు బ్రేక్ ప్రకటన, లూప్ నుండి షరతులతో కూడిన నిష్క్రమణ కోసం.
కోసం ((i=0;i<10;i++)) చేస్తే [[ $i -eq 5 ]] ఆపై బ్రేక్ else echo $i; పూర్తయిందిపై లూప్ 0 నుండి 4 వరకు సంఖ్యలను ముద్రిస్తుంది. తర్వాత i విలువ 5 అయినప్పుడు, అది లూప్ నుండి బయటపడుతుంది. కమాండ్ నిర్దిష్ట అవుట్‌పుట్ ఇచ్చినప్పుడు లూప్ నుండి నిష్క్రమించినప్పుడు ఇది ప్రత్యేకంగా ఉపయోగపడుతుంది. ఉదాహరణకు, కింది లూప్ ఖాళీ ఫైల్‌ను కనుగొంటే మరియు అది విచ్ఛిన్నమవుతుంది.
ఫైల్ కోసం `ls` do flen=`wc -c $file` అయితే [[ "$flen" = "0 $file" ]] ఆపై echo "$file ఖాళీగా ఉంది" బ్రేక్ లేకపోతే echo $flen fi పూర్తయింది ఆదేశం wc -c ఫైల్‌లోని పంక్తుల సంఖ్యను ప్రింట్ చేస్తుంది . ఇది ఫార్మాట్‌లో ముద్రిస్తుంది , ఉదాహరణకి, 10 test.txt. పంక్తుల సంఖ్య 0 అయినప్పుడు మేము లూప్ నుండి బయటపడతాము, అనగా ఖాళీ ఫైల్.
షరతులతో ఒక పునరావృతాన్ని దాటవేయడానికి ప్రకటనను కొనసాగించండి
సి మరియు అనేక ఇతర ప్రోగ్రామింగ్ లాంగ్వేజెస్ లాగానే, బాష్ కూడా aని కలిగి ఉంది కొనసాగుతుంది ప్రకటన, ఒక నిర్దిష్ట షరతు సంతృప్తి చెందినట్లయితే, లూప్‌లో పునరావృతం యొక్క మిగిలిన భాగాన్ని దాటవేయడం.
కోసం ((i=0;i<10;i++)) చేస్తే [[ $i -eq 5 ]] ఆపై fi echo $iని కొనసాగించండి; పూర్తిపై లూప్ 5 మినహా 0 నుండి 10 వరకు సంఖ్యలను ముద్రిస్తుంది, ఎందుకంటే పునరావృతం సమయంలో i=5 కొనసాగింపు స్టేట్‌మెంట్ ఉంది, ఇది లూప్‌లోని మిగిలిన కోడ్‌ను ప్రారంభంలో పునరావృతం చేయడంతో దాటవేస్తుంది i=6.
కింది ఉదాహరణలో, మేము ఫైల్‌లోని పంక్తుల సంఖ్యను ప్రింట్ చేస్తాము మరియు నిర్దిష్ట పునరావృతం అవుతుంది కొనసాగుతుంది అది డైరెక్టరీ అయితే ఫైల్ కాదు.
`ls`లో ఫైల్ కోసం [[ -d $file ]] ఉంటే, ఆపై fi wc -c "$file"ని కొనసాగించండి[[ -d $file ]] ఫైల్ డైరెక్టరీ కాదా అని తనిఖీ చేస్తుంది. అది ఉంటే, మేము తదుపరి ఫైల్‌కి, అంటే తదుపరి పునరావృతానికి దాటవేస్తాము. ఇది డైరెక్టరీ కాకపోతే, మేము ఉపయోగించి ఫైల్‌లోని పంక్తుల సంఖ్యను ప్రింట్ చేస్తాము wc కమాండ్, గతంలో చూపిన విధంగా.
లూప్‌లను ఉపయోగించడం: స్క్రిప్ట్‌లు మరియు కమాండ్ లైన్
లూప్ సింటాక్స్ నేరుగా బాష్ షెల్‌లో లేదా షెల్ స్క్రిప్ట్ ఫైల్ నుండి ఉపయోగించబడుతుంది. ఒకప్పుడు ఒక కోసం లూప్ సింటాక్స్ షెల్‌పై నమోదు చేయబడింది, లూప్ చేయవలసిన ఆదేశాలను వినియోగదారు కొనసాగించడానికి షెల్ ప్రాంప్ట్‌ను కొనసాగిస్తుంది.
లేదా వినియోగదారు దీన్ని స్క్రిప్ట్ ఫైల్‌లో సేవ్ చేయవచ్చు మరియు స్క్రిప్ట్ ఫైల్‌ను అమలు చేయవచ్చు.
ది #!/బిన్/బాష్ ప్రారంభంలో ఫైల్ అమలు చేయబడినప్పుడు ఉపయోగించాల్సిన ఇంటర్‌ప్రెటర్‌ను నిర్దేశిస్తుంది. ఈ రోజుల్లో బాష్ ఎక్కువగా ఉపయోగించే షెల్ అయినప్పటికీ, కొంతమంది వినియోగదారులు షెల్‌లను ఇష్టపడతారు zsh, ఈ ఫైల్ ప్రారంభంలో బాష్ స్థానంలో పేర్కొనబడాలి.
అమలు అనుమతులు ఇవ్వడానికి ఈ ఫైల్ కోసం, అమలు చేయండి:
chmod +x test.shచివరగా, ఫైల్‌ను అమలు చేయడానికి, అమలు:
./test.sh
ముగింపు
ది కోసం బాష్‌లోని లూప్ చాలా సరళమైన లక్షణం, అయితే దాదాపు ప్రతి రకమైన సంక్లిష్టమైన స్క్రిప్టింగ్ దృష్టాంతంలో దాని ఉపయోగం ఉంది. మీరు సాధారణ లేదా అధునాతన Linux వినియోగదారు అయినా లేదా సిస్టమ్ అడ్మినిస్ట్రేషన్ మరియు DevOps టాస్క్‌ల కోసం ఆటోమేషన్ నేర్చుకోవడం ప్రారంభించినా దీన్ని నేర్చుకోవడం చాలా దూరం ఉంటుంది.