బాష్ 'వైల్' లూప్: ట్యుటోరియల్ మరియు ఉదాహరణలు

బాష్ స్క్రిప్టింగ్‌లో 'while' లూప్‌ని ఉపయోగించి కమాండ్(ల)పై మళ్ళించండి.

బాష్ (బోర్న్ ఎగైన్ షెల్) అనేది GNU/Linux ఆపరేటింగ్ సిస్టమ్‌లలో షెల్ కమాండ్ ప్రాంప్ట్ మరియు స్క్రిప్టింగ్ భాష. ఇది చాలా Linux పంపిణీలకు డిఫాల్ట్ షెల్.

చాలా స్క్రిప్టింగ్ భాషల వలె, బాష్ సారూప్య పనిని అనేకసార్లు పునరావృతం చేయడానికి లూప్ సింటాక్స్‌లను అందిస్తుంది. ఈ వ్యాసంలో మనం ఎలా ఉపయోగించాలో నేర్చుకుంటాము అయితే బాష్‌లో లూప్.

పరిచయం

ది అయితే బాష్‌లోని లూప్ అనేది మరొక కమాండ్(లు) (కండిషన్ కమాండ్‌లు) అవుట్‌పుట్ ఆధారంగా పలుసార్లు కమాండ్(లు) (ఎగ్జిక్యూటెడ్ కమాండ్‌లు) అమలు చేయడానికి ఉపయోగించబడుతుంది. కండిషన్ కమాండ్ విజయవంతంగా రన్ అయ్యే వరకు ఎగ్జిక్యూట్ చేయబడిన కమాండ్‌లు రన్ అవుతూనే ఉంటాయి (అనగా, 0 స్థితిని అందిస్తుంది. Linuxలో ఏదైనా కమాండ్ సక్సెస్ కోసం 0ని మరియు వైఫల్యం కోసం సున్నా కాని పూర్ణాంకాన్ని అందిస్తుంది).

బహుళ కండిషన్ కమాండ్‌లు ఉంటే, స్టేట్‌మెంట్ జాబితాలోని చివరి కమాండ్ యొక్క స్థితిని మాత్రమే పరిగణిస్తుంది, అనగా, జాబితాలోని చివరి కమాండ్ విజయవంతంగా అమలు అయ్యే వరకు లూప్ అమలు చేస్తుంది.

సాధారణ వాక్యనిర్మాణం

కోసం సాధారణ వాక్యనిర్మాణం అయితే బాష్‌లోని లూప్:

పూర్తి అయితే

కండిషన్ కమాండ్ లిస్ట్‌లోని చివరి కమాండ్ విజయవంతంగా రన్ అయ్యే వరకు ఎగ్జిక్యూట్ కమాండ్ లిస్ట్ రన్ అవుతూనే ఉంటుంది మరియు స్టేటస్ 0తో నిష్క్రమిస్తుంది. పునరావృతంలో, చివరి కండిషన్ కమాండ్ విఫలమైనప్పుడు, లూప్ నిష్క్రమిస్తుంది.

వినియోగదారు కమాండ్ జాబితాలలో ఏదైనా ఎక్జిక్యూటబుల్ ఫైల్‌ను పేర్కొనవచ్చు. ఇది ప్రామాణిక Linux ప్రోగ్రామ్‌లు లేదా అనుకూల వినియోగదారు ప్రోగ్రామ్‌లు లేదా స్క్రిప్ట్‌లు కావచ్చు. ప్రతి ఆదేశం కొత్త లైన్‌లో ఉండాలి లేదా అదే లైన్‌లో సెమికోలన్‌తో వేరు చేయబడాలి.

కొన్ని ఉదాహరణలు చూద్దాం.

వేరియబుల్ వరకు లూప్ చేయడం నిర్దిష్ట విలువను కలిగి ఉంటుంది: కింది లూప్ వేరియబుల్ విలువ వరకు అమలు చేస్తుంది x 10కి సమానం కాదు.

x=0 అయితే [[ $x -ne 10 ]] echo $x ((x++)) పూర్తయింది

ప్రతి పునరావృతంలో, మేము x విలువ 10 కాదా అని తనిఖీ చేస్తున్నాము. విలువను ఉపయోగించి తనిఖీ చేయబడుతోంది పరీక్ష ఆదేశం. [[ వ్యక్తీకరణ ]] పరీక్ష కమాండ్ కోసం వాక్యనిర్మాణం (చూడండి మనిషి పరీక్ష) మేము ఉపయోగిస్తున్నందున ఇక్కడ -నే ఆపరేటర్ (ఇది 'ఈక్వల్ టు' అని సూచిస్తుంది), టెస్ట్ కమాండ్ 0ని అందిస్తుంది, అనగా విజయం, x విలువ 10 కాకపోతే, మరియు అది సున్నా కాని విలువను అందిస్తుంది, అనగా, x విలువ 10 అయితే వైఫల్యం.

అప్పుడు లోపల చెయ్యి... పూర్తయింది బ్లాక్, మేము x విలువను ప్రింట్ చేస్తాము మరియు దానిని పెంచుతాము. x విలువ 10 అయిన తర్వాత, పరీక్ష కమాండ్ సున్నా కాని స్థితిని అందిస్తుంది మరియు లూప్ నిష్క్రమిస్తుంది.

గమనిక: అయితే లూప్‌లో ఉపయోగించాల్సిన ఇండెక్స్ వేరియబుల్ అయితే లూప్‌కు ముందు లేదా కండిషన్ కమాండ్‌లలో ప్రారంభించబడాలి, లూప్‌కు విరుద్ధంగా, ఇది వేరియబుల్‌ను అవ్యక్తంగా ప్రారంభించడాన్ని అనుమతిస్తుంది.

బహుళ షరతుల ఆదేశాలతో: కింది లూప్ పేరుతో 5 డైరెక్టరీలను సృష్టిస్తుంది dir0, dir1, ... dir4.

z=0 అయితే "ఫైల్‌ల జాబితా:" ls -l [[ $z -ne 5 ]] ప్రతిధ్వని "dir$z సృష్టిస్తోంది..." mkdir dir$z ((z++)) పూర్తయింది

మొదటి ఆదేశాలు ప్రతిధ్వని "ఫైళ్ల జాబితా:" మరియు ls -l పూర్తిగా ఒకసారి అమలు చేస్తుంది; వారి విజయం లేదా వైఫల్యం లూప్ ఎంతకాలం నడుస్తుందనే దానిపై ఎటువంటి ప్రభావం ఉండదు.

అప్పుడు వేరియబుల్ z విలువను తనిఖీ చేయడానికి పరీక్ష కమాండ్ అమలు అవుతుంది. z విలువ 5 కానంత వరకు, టెస్ట్ కమాండ్ విజయ స్థితిని అందిస్తుంది మరియు అందువల్ల లూప్ రన్ అవుతూనే ఉంటుంది. కండిషన్ కమాండ్‌లు మరియు ఎగ్జిక్యూటెడ్ కమాండ్‌లు క్రమంలో రన్ అవుతూ ఉంటాయి. ఇక్కడ, ప్రతి పునరావృతం కోసం, ఇది మొదట echo కమాండ్ మరియు ls కమాండ్‌ను కండిషన్‌లో అమలు చేస్తుంది మరియు తర్వాత 3వ కండిషన్ కమాండ్ z విలువ కోసం తనిఖీ చేస్తుంది. అది 5 కాకపోతే, అది లూప్‌లోకి ప్రవేశించి, ఇచ్చిన ఆదేశాలను అమలు చేస్తుంది.

బ్రేక్ చేసి కొనసాగించండి

షరతులతో కూడిన నిష్క్రమణ కోసం బ్రేక్ స్టేట్‌మెంట్

మేము షరతులతో కూడిన ప్రకటనను కూడా ఉపయోగించవచ్చు ఉంటే లూప్ లోపల. ది ఉంటే ప్రకటనను a తో ఉపయోగించవచ్చు బ్రేక్ ప్రకటన, లూప్ నుండి షరతులతో కూడిన నిష్క్రమణ కోసం.

x=0 అయితే [[ $x -ne 10 ]] [[ $x -eq 5 ]] బ్రేక్ ఫి ఎకో $x ((x++)) పూర్తయితే

ఎగువ అయితే లూప్ 0 నుండి 4 వరకు సంఖ్యలను ముద్రిస్తుంది. తర్వాత i విలువ 5 అయినప్పుడు, అది లూప్ నుండి బయటపడుతుంది. కమాండ్ నిర్దిష్ట అవుట్‌పుట్ ఇచ్చినప్పుడు లూప్ నుండి నిష్క్రమించినప్పుడు ఇది ప్రత్యేకంగా ఉపయోగపడుతుంది.

షరతులతో ఒక పునరావృతాన్ని దాటవేయడానికి ప్రకటనను కొనసాగించండి

బాష్ కూడా ఒక కొనసాగుతుంది ప్రకటన, ఒక నిర్దిష్ట షరతు సంతృప్తి చెందినట్లయితే, లూప్‌లో పునరావృతం యొక్క మిగిలిన భాగాన్ని దాటవేయడం.

x=0 అయితే [[ $x -ne 10 ]] [[ $x -eq 5 ]] కొనసాగితే fi echo $x ((x++)) పూర్తయింది

పై లూప్ 5 మినహా 0 నుండి 10 వరకు సంఖ్యలను ముద్రిస్తుంది, ఎందుకంటే పునరావృతం సమయంలో x=5 కొనసాగింపు స్టేట్‌మెంట్ ఉంది, ఇది లూప్‌లోని మిగిలిన కోడ్‌ను ప్రారంభంలో పునరావృతం చేయడంతో దాటవేస్తుంది x=6.

లూప్‌లను ఉపయోగించడం: స్క్రిప్ట్‌లు మరియు కమాండ్ లైన్

లూప్ సింటాక్స్‌లను నేరుగా బాష్ షెల్‌లో లేదా ఎక్జిక్యూటబుల్ షెల్ స్క్రిప్ట్ ఫైల్ నుండి ఉపయోగించవచ్చు. ఒకేలా కోసం మరియు అయితే ఉచ్చులు, ఒకసారి ఒక అయితే లూప్ సింటాక్స్ షెల్‌పై నమోదు చేయబడింది, లూప్ చేయవలసిన ఆదేశాలను వినియోగదారు కొనసాగించడానికి షెల్ ప్రాంప్ట్‌ను కొనసాగిస్తుంది.

లేదా వినియోగదారు దీన్ని స్క్రిప్ట్ ఫైల్‌లో సేవ్ చేయవచ్చు మరియు స్క్రిప్ట్ ఫైల్‌ను అమలు చేయవచ్చు.

ది #!/బిన్/బాష్ ప్రారంభంలో ఫైల్ అమలు చేయబడినప్పుడు ఉపయోగించాల్సిన ఇంటర్‌ప్రెటర్‌ను నిర్దేశిస్తుంది. ఈ రోజుల్లో బాష్ ఎక్కువగా ఉపయోగించే షెల్ అయినప్పటికీ, కొంతమంది వినియోగదారులు షెల్‌లను ఇష్టపడతారు zsh, ఈ ఫైల్ ప్రారంభంలో బాష్ స్థానంలో పేర్కొనబడాలి.

అమలు అనుమతులు ఇవ్వడానికి ఈ ఫైల్ కోసం, అమలు చేయండి:

chmod +x test.sh

చివరగా, ఫైల్‌ను అమలు చేయడానికి, అమలు:

./test.sh

ముగింపు

ది అయితే లూప్, పోలి కోసం మరియు వరకు బాష్ స్క్రిప్టింగ్‌లో లూప్‌లు ఒక ముఖ్యమైన లక్షణం. లూప్ వరకు లూప్ వలె ఉపయోగించినప్పటికీ, నిర్దిష్ట ప్రోగ్రామ్ విజయవంతమైతే ప్రత్యామ్నాయ ఆదేశాలు/ప్రోగ్రామ్‌లను అమలు చేయడానికి ఇది ఉపయోగించబడుతుంది. ఇది తరచుగా అధునాతన నెట్‌వర్కింగ్ స్క్రిప్ట్‌లు, సిస్టమ్ మెయింటెనెన్స్ స్క్రిప్ట్‌లు మొదలైన వాటిలో దాని ఉపయోగాన్ని కనుగొంటుంది.