ప్రోగ్రామింగ్ లాంగ్వేజ్లో, ప్రధానంగా మూడు రకాల లూప్లు ఉన్నాయి (ఫర్, అయితే మరియు వరకు). మూడు రకాల లూప్లు వివిధ మార్గాల్లో ముఖ్యమైనవి. లూప్ల వరకు మరియు లూప్ల మధ్య చాలా తేడా లేదు, కానీ లూప్ కోసం ఈ రెండింటికి భిన్నంగా పనిచేస్తుంది. అందుకే మీరు బాష్ యూజర్గా ఇంటరాక్టివ్ స్క్రిప్ట్లను సృష్టించడానికి ఈ లూప్లను ఉపయోగించవచ్చు.
కాబట్టి బాష్ ఉదాహరణలు నేర్చుకోవడం స్క్రిప్ట్లను రూపొందించడంలో మీ నైపుణ్యాలను మెరుగుపరచడంలో మీకు సహాయపడుతుంది. కాబట్టి ఈ ట్యుటోరియల్లో, మీ స్క్రిప్టింగ్ నైపుణ్యాలను మెరుగుపరచుకోవడానికి మీరు ప్రయత్నించగల 10 అద్భుతమైన మరియు అద్భుతమైన బాష్ లూప్ ఉదాహరణలను మేము చేర్చుతాము.
10 అద్భుతమైన మరియు అద్భుతమైన బాష్ లూప్ ఉదాహరణలు
ఈ విభాగంలో, మేము లూప్లలో ఉపయోగించిన వివిధ ఉదాహరణలు మరియు విధానాలను వివరిస్తాము.
బాష్లో లూప్తో సీక్ కమాండ్
మీరు సంఖ్యల క్రమాన్ని సృష్టించడానికి for loopలో seq ఆదేశాన్ని ఉపయోగించవచ్చు. ఉదాహరణకు, మీరు క్రింది కోడ్ను కలిగి ఉన్న “File.sh” బాష్ స్క్రిప్ట్ని కలిగి ఉన్నారు:
#!/బిన్/బాష్
కోసం ఎ లో $ ( సీక్ 5 రెండు 25 )
చేయండి
ప్రతిధ్వని 'సంఖ్యలు $A ఉన్నాయి'
పూర్తి
టెర్మినల్లో స్క్రిప్ట్ను అమలు చేసిన తర్వాత మీరు క్రింది ఫలితాన్ని పొందుతారు:
. / file.sh
లూప్ ఉపయోగించి ఫైల్స్ పేరు మార్చండి
బాష్ స్క్రిప్ట్ని ఉపయోగించి, మీరు బహుళ ఫైల్ల పేరు మార్చడానికి for loopsని ఉపయోగించవచ్చు. ఉదాహరణకు, మీరు బహుళ .txt ఫైల్లను కలిగి ఉన్నారు మరియు పేరుతో ప్రస్తుత తేదీని జోడించాలనుకుంటున్నారు. కాబట్టి మీరు ఉపయోగించగల ఉదాహరణ స్క్రిప్ట్ ఇక్కడ ఉంది:
#!/బిన్/బాష్కోసం ఎ లో $ ( ls * .పదము ) ; చేయండి
mv $A ( బేస్ పేరు $A .పదము ) _$ ( తేదీ % డి % m % ) .పదము
పూర్తి
ఇప్పుడు, మీరు స్క్రిప్ట్ను అమలు చేయవచ్చు మరియు ప్రస్తుత తేదీని జోడించడం ద్వారా ఇది అన్ని .txt ఫైల్ల పేరును మారుస్తుంది:
అదేవిధంగా, మీరు ఒకే స్క్రిప్ట్ ద్వారా ఫైల్ యొక్క పొడిగింపులను మార్చవచ్చు. కాబట్టి కింది స్క్రిప్ట్ ద్వారా .txt పొడిగింపును .sh లోకి మారుద్దాం:
కోసం ఫైల్ లో * .పదము; చేయండి
mv -- ' $ ఫైల్ ' '{file%.txt}.sh'
పూర్తి
టెర్మినల్లో స్క్రిప్ట్ని అమలు చేసిన తర్వాత, మీరు .txt ఫైల్ల కంటే .shని పొందుతారు:
. / MyFile.sh
బాష్లో లూప్ కోసం అనంతం
లూప్లో ఎటువంటి ముగింపు పరిస్థితిని నిర్వచించనప్పుడు, దానిని అనంతమైన లూప్ అంటారు. బాష్ లూప్ యొక్క ఈ ఉదాహరణలో, మేము బాష్లో లూప్ కోసం అనంతాన్ని పరిశీలిస్తాము. లూప్ కోసం క్రింది అనంతం డబుల్ సెమికోలన్ (; ; ) ద్వారా నిర్వచించబడింది మరియు ఏ ప్రారంభ, చర్య లేదా ముగింపు భాగాలను కలిగి ఉండదు.
మీరు Ctrl+C నొక్కినంత వరకు లేదా ఇన్పుట్గా “నిష్క్రమించు” అని టైప్ చేసే వరకు దిగువ స్క్రిప్ట్ కొనసాగుతుంది. ఈ స్క్రిప్ట్ ఇన్పుట్గా ఇవ్వబడిన 10 నుండి 50 వరకు ప్రతి సంఖ్యను ప్రింట్ చేస్తుంది. లేకపోతే, అది “సంఖ్య పరిధికి మించి ఉంది” అని ప్రింట్ చేస్తుంది.
#!/బిన్/బాష్#అనంతమైన చుట్టు
కోసం ( ( ; ; ) )
చేయండి
ప్రతిధ్వని '10 నుండి 50 మధ్య సంఖ్యను నమోదు చేయండి'
చదవండి n
ఉంటే [ $n == 'నిష్క్రమించు' ]
అప్పుడు
ప్రతిధ్వని 'ముగింపు'
బయటకి దారి 0
ఉంటుంది
ఉంటే ( ( $n < 10 || $n > యాభై ) )
అప్పుడు
ప్రతిధ్వని 'సంఖ్య పరిధి వెలుపల ఉంది'
లేకపోతే
ప్రతిధ్వని 'సంఖ్య ఉంది $n '
ఉంటుంది
పూర్తి
మేము పై స్క్రిప్ట్పై 45 మరియు 23 చెల్లుబాటు అయ్యే ఇన్పుట్లను అందించాము. ఆ తర్వాత, మేము 2ని ఇన్పుట్గా ప్రింట్ చేస్తాము, అది అవుట్పుట్లో “సంఖ్య పరిధికి మించి ఉంది” అని తెలియజేస్తుంది. ఆ తర్వాత, స్క్రిప్ట్ను మూసివేయడానికి, మేము ఇన్పుట్గా క్విట్ అని టైప్ చేస్తాము. ఇక్కడ మీరు అనంతమైన లూప్ నుండి నిష్క్రమించడానికి Ctrl+Cని కూడా నొక్కవచ్చు.
బాష్లో మూడు ఎక్స్ప్రెషన్ లూప్
మూడు-వ్యక్తీకరణ లూప్ పేరు నుండి ఇది మూడు వ్యక్తీకరణలను కలిగి ఉంటుంది, దీనిని నియంత్రణ వ్యక్తీకరణలు అని కూడా పిలుస్తారు. మొదటి వ్యక్తీకరణ (EXP1) అనేది ఇనిషియలైజర్, రెండవ వ్యక్తీకరణ (EXP2) అనేది లూప్ టెస్ట్ లేదా కండిషన్, మరియు మూడవ వ్యక్తీకరణ (EXP3) అనేది కౌంటింగ్ ఎక్స్ప్రెషన్/స్టెప్. బాష్లో మూడు-వ్యక్తీకరణ లూప్ని అమలు చేద్దాం:
#!/బిన్/బాష్కోసం ( ( n = 5 ; n > = 1 ; n-- ) )
చేయండి
ప్రతిధ్వని 'పుస్తకం $n '
పూర్తి
పై స్క్రిప్ట్ని రన్ చేసినప్పుడు, మీరు ఈ క్రింది అవుట్పుట్ పొందుతారు.
బహుళ షరతులతో లూప్ చేయండి
మేము క్రింది బాష్ లూప్ ఉదాహరణలో బహుళ షరతులతో వరకు లూప్ని ఉపయోగించాము. ఈ స్క్రిప్ట్లో, మేము వరుసగా 20 మరియు 10 విలువలను కలిగి ఉన్న “m” మరియు “n” అనే రెండు వేరియబుల్లను తీసుకున్నాము మరియు 15 పరిమితిని ఉంచాము. ఇక్కడ మనం లూప్లో “m” మరియు “n” షరతులను కలిపి ఉంచాము, దీనిలో 'm' విలువ పరిమితి కంటే తక్కువగా మరియు 'n' పరిమితి కంటే ఎక్కువగా ఉండే వరకు లూప్ నడుస్తుంది.
#!/బిన్/బాష్పరిమితి = పదిహేను
m = ఇరవై
n = 10
వరకు [ [ $m -lt $పరిమితి || $n -gt $పరిమితి ] ] ;
చేయండి
ప్రతిధ్వని 'ఒకవేళ M = $m అప్పుడు N = $n '
( ( m-- ) )
( ( n++ ) )
పూర్తి
'm' మరియు 'n' విలువలు ఒకే స్థాయికి వచ్చే వరకు పై స్క్రిప్ట్ని రన్ చేయడాన్ని మీరు చూడవచ్చు.
బాష్లో ఫైల్ని చదవండి
బాష్లో, మీరు ఫైల్ యొక్క కంటెంట్లను అనేక మార్గాల్లో చదవవచ్చు. బాష్ లూప్ యొక్క ఈ ఉదాహరణలో, మేము ఫైల్ పేరు ద్వారా ఫైల్ కంటెంట్లను చదువుతాము. ఫైల్ను బాష్లో చదవడానికి మనం క్రింది స్క్రిప్ట్ని ఉపయోగించవచ్చు:
#!/బిన్/బాష్ప్రతిధ్వని 'నమోదు చేయబడిన ఫైల్ యొక్క కంటెంట్:'
అయితే
చదవండి లైన్
చేయండి
ప్రతిధ్వని $లైన్
పూర్తి < ~ పత్రాలు / Linuxhint.txt
పై స్క్రిప్ట్ని అమలు చేసిన తర్వాత, మీరు నమోదు చేసిన ఫైల్ యొక్క పూర్తి కంటెంట్ను చదవవచ్చు.
ఫైల్కి వ్రాయడం
టెర్మినల్ నుండే ఫైల్ను సవరించడానికి మీరు స్క్రిప్ట్లోని లూప్లను ఉపయోగించవచ్చు. ఉదాహరణకు, మన దగ్గర txt ఫైల్ “Example.txt” ఉంటే మరియు మేము కొంత సమాచారాన్ని జోడించాలనుకుంటే, మేము ఈ క్రింది స్క్రిప్ట్ని ఉపయోగించవచ్చు:
మీరు పై స్క్రిప్ట్ని అమలు చేస్తే, అది మిమ్మల్ని వివరాలను నమోదు చేయమని అడుగుతుంది:
మీరు వివరాలను నమోదు చేసిన తర్వాత, దయచేసి ఫైల్ను సేవ్ చేయడానికి CTRL + D మరియు ప్రక్రియను విజయవంతంగా పూర్తి చేయడానికి CTRL + Z.
బాష్లో స్టేట్మెంట్ లూప్ను బ్రేక్ చేసి కొనసాగించండి
బాష్లో, మీరు విరామం తర్వాత మీ లూప్ స్టేట్మెంట్ను కొనసాగించవచ్చు. బ్రేక్ స్టేట్మెంట్ లూప్ నుండి నిష్క్రమిస్తుంది మరియు తదుపరి ఇచ్చిన స్టేట్మెంట్కు నియంత్రణను పంపుతుంది. అదే కొనసాగింపు ప్రకటనతో ప్రస్తుత పునరావృతం దాటవేయబడిన తర్వాత పునరావృత సంఖ్య రెండు ప్రారంభమవుతుంది.
#!/బిన్/బాష్ఒకదానిపై = 16
వరకు తప్పుడు
చేయండి
( ( ఒకదానిపై-- ) )
ఉంటే [ [ $సం -eq 13 ] ]
అప్పుడు
కొనసాగుతుంది
ఎలిఫ్ [ [ $సం - ది 4 ] ]
అప్పుడు
బ్రేక్
ఉంటుంది
ప్రతిధ్వని 'LinuxHint= $సం '
పూర్తి
కింది బాష్ స్క్రిప్ట్లో, “సంఖ్య” 13కి సమానమైనప్పుడు, అది మిగిలిన లూప్ బాడీని దాటవేసి తదుపరి పునరావృతానికి వెళ్లడాన్ని మీరు చూడవచ్చు. అదేవిధంగా, 'సం' 4 కంటే తక్కువగా లేదా సమానంగా ఉన్నప్పుడు లూప్ విచ్ఛిన్నమవుతుంది.
లూప్ 15కి మొదలై, 13కి బ్రేక్ అయి, 5 వరకు కొనసాగుతుందని పై స్క్రిప్ట్ చూపిస్తుంది.
బాష్లో సగటును గణించడం
మీరు స్క్రిప్ట్ను బాష్ లూప్లో అమలు చేయడం ద్వారా సగటును లెక్కించవచ్చు. దీనిలో, వినియోగదారు నిర్వచించిన పరిధిలో సంఖ్యల సగటును లెక్కించవచ్చు. కింది స్క్రిప్ట్ వినియోగదారు అందించిన ఇన్పుట్ సగటును గణిస్తుంది.
#!/బిన్/బాష్మార్కులు = '0'
సగటు = '0'
మొత్తం = '500'
ఒకదానిపై = '5'
అయితే నిజం ; చేయండి
ప్రతిధ్వని -ఎన్ 'మీ మార్కులను నమోదు చేయండి లేదా రద్దు చేయడానికి 'q' నొక్కండి' ; చదవండి మార్కులు;
ఉంటే ( ( ' $మార్కులు ' < '0' ) ) || ( ( ' $మార్కులు ' > '100' ) ) ; అప్పుడు
ప్రతిధ్వని 'దయచేసి మీ మార్కులను నమోదు చేయండి'
ఎలిఫ్ [ ' $మార్కులు ' == 'q' ] ; అప్పుడు
ప్రతిధ్వని 'సగటు మార్కులు: $AVERAGE %'
బ్రేక్
లేకపోతే
మొత్తం =$ [ $SUM + $మార్కులు ]
ఒకదానిపై =$ [ $NUM + 1 ]
సగటు =$ [ $SUM / $NUM ]
ఉంటుంది
పూర్తి
ఇన్పుట్ పరిధిలో లేకుంటే, 'దయచేసి మీ మార్కులను నమోదు చేయండి' అనే సందేశం ముద్రించబడుతుంది. అన్ని మార్కులను నమోదు చేసిన తర్వాత వినియోగదారు “q”ని నొక్కినప్పుడు, స్క్రిప్ట్ నమోదు చేసిన అన్ని సంఖ్యల సగటు సగటును గణిస్తుంది.
పై స్క్రిప్ట్ అమలు చేయబడినప్పుడు, మీ అవుట్పుట్ ఇలా ఉంటుంది.
బాష్లో కమాండ్-లైన్ ఆర్గ్యుమెంట్లను చదవండి
బాష్లో, మీరు లూప్లను ఉపయోగించి సింగిల్ కమాండ్-లైన్ ఆర్గ్యుమెంట్లను చదవవచ్చు. స్క్రిప్ట్ ఫార్మాట్ చేసిన ఆర్గ్యుమెంట్ విలువలను ప్రింట్ చేస్తుంది. మేము కింది స్క్రిప్ట్లో కామ్ లూప్ని ఉపయోగించి బాష్లో కమాండ్ లైన్ ఆర్గ్యుమెంట్లను అమలు చేస్తాము. దీని ద్వారా, మీరు ఒకే కమాండ్ సహాయంతో ఆర్గ్యుమెంట్ విలువ చెల్లుబాటు అయ్యే ఎంపికను పాస్ చేసే విలువను ప్రింట్ చేస్తారు.
#!/బిన్/బాష్అయితే గెటాప్ట్లు N:F:M: OPT
చేయండి
కేసు ' ${OPT} '
లో
ఎన్ ) పేరు = ${OPTARG} ;;
ఎఫ్ ) తండ్రి పేరు = ${OPTARG} ;;
ఎం ) తల్లిపేరు = ${OPTARG} ;;
* ) ప్రతిధ్వని 'చెల్లదు'
బయటకి దారి 1 ;;
esac
పూర్తి
printf 'పేరు: $పేరు \n తండ్రి పేరు: $తండ్రి పేరు \n తల్లి పేరు: $తల్లి పేరు \n '
అందువల్ల, మీరు పై స్క్రిప్ట్ను బాష్లో అమలు చేయడం ద్వారా అవుట్పుట్కి ఫార్మాట్ చేసిన ఆర్గ్యుమెంట్ విలువలను ప్రింట్ చేయవచ్చు.
చుట్టి వేయు
కాబట్టి ఇది మీరు నేర్చుకోగల 10 కూల్ మరియు అద్భుతమైన బాష్ లూప్ ఉదాహరణలపై సంక్షిప్త సమాచారం. ఇంటరాక్టివ్ స్క్రిప్ట్ను సులభంగా సృష్టించడానికి మేము వివిధ రకాల లూప్లను ఉపయోగించాము. అంతేకాకుండా, పై ఉదాహరణలలో ఉపయోగించిన ప్రాథమిక విధానాలను కూడా మేము వివరించాము. మీరు బాష్లోని లూప్ల గురించి లోతైన వివరాలను కలిగి ఉంటే, దయచేసి మరింత తెలుసుకోవడానికి మా అధికారిక వెబ్సైట్ను సందర్శించండి.