లైనక్స్‌లో లూప్‌ల కోసం బాష్ గురించి మీరు తెలుసుకోవలసిన ప్రతిదీ

బాష్ స్క్రిప్ట్‌లు ఆటోమేటిక్ టాస్క్‌ల యొక్క అత్యంత సమర్థవంతమైన సాధనం, ప్రత్యేకించి ప్రస్తుతం ఉన్న ఇతర ప్రోగ్రామ్‌ల ప్రయోజనాన్ని పొందేవి. ఈ ఆటోమేషన్‌కు తరచుగా ఇదే విధమైన ఆపరేషన్‌ను అనేకసార్లు పునరావృతం చేయాల్సి ఉంటుంది, ఇది ఖచ్చితంగా ఎక్కడ ఉంది లూప్ కోసం దానిలోకి వస్తుంది.

లైనక్స్ మరియు మాక్ సిస్టమ్ అడ్మినిస్ట్రేటర్లకు సాధారణంగా టెర్మినల్ ద్వారా స్క్రిప్టింగ్ గురించి బాగా తెలుసు, కానీ విండోస్ యూజర్లు కూడా చేయగలరు లైనక్స్ కోసం విండోస్ సబ్‌సిస్టమ్‌తో చర్య తీసుకోండి .

---

---

బాష్ స్క్రిప్ట్‌లు ఎలా పని చేస్తాయి

బాష్ స్క్రిప్ట్ అనేది సాదా టెక్స్ట్ ఫైల్, ఇది బాష్ షెల్ చదవగల మరియు అమలు చేయగల ఆదేశాల శ్రేణిని కలిగి ఉంటుంది. ప్రీ-కాటాలినా మాకోస్‌లో బాష్ డిఫాల్ట్ షెల్ మరియు చాలా లైనక్స్ పంపిణీలు.

మీరు ఇంతకు ముందు షెల్ స్క్రిప్ట్‌తో పని చేయకపోతే, మీరు సంపూర్ణ సరళమైన కేసుతో ప్రారంభించాలి. స్క్రిప్ట్ సృష్టి మరియు దాని అమలుతో సహా కీలక భావనలను సాధన చేయడానికి ఇది మిమ్మల్ని అనుమతిస్తుంది.

ముందుగా, కింది ఫైల్‌ను అనుకూలమైన ప్రదేశంలో సృష్టించండి (ఆదర్శంగా, టెర్మినల్‌ని తెరిచి, ముందుగా కావలసిన డైరెక్టరీకి నావిగేట్ చేయండి):

#!/bin/bash
echo 'Hello, World'

మొదటి ప్రోగ్రామ్ ఈ ప్రోగ్రామ్‌ని ఏది రన్ చేయాలో చెబుతుంది (అంటే బాష్ ఇంటర్‌ప్రెటర్‌ను ఉపయోగించడం). రెండవది మీరు కమాండ్ లైన్‌లో నమోదు చేయగల ఇతర ఆదేశాల లాగానే ఉంటుంది. ఆ ఫైల్‌ని ఇలా సేవ్ చేయండి హలో_ప్రపంచం , అప్పుడు:

$ chmod +x hello_world.sh
$ ./hello_world.sh

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

---

---

హలో, వరల్డ్ అనే పదాలను మీ టెర్మినల్‌లోని ఒక లైన్‌లో ముద్రించినట్లు మీరు చూసినట్లయితే, అప్పుడు ప్రతిదీ అవసరమైన విధంగా పని చేస్తుంది.

ఉచ్చులు ఎలా పని చేస్తాయి

సాధారణ ప్రోగ్రామింగ్‌లో, లూప్ కోసం రెండు ప్రధాన రకాలు ఉన్నాయి: సంఖ్యా మరియు ప్రతి . సంఖ్యా రకం సాంప్రదాయకంగా సర్వసాధారణం, కానీ బాష్ ఉపయోగంలో, ఇది సాధారణంగా మరొక విధంగా ఉంటుంది.

---

---

లూప్‌ల కోసం సంఖ్యాశాస్త్రం సాధారణంగా ఒకే పూర్ణాంకంపై దృష్టి పెడుతుంది, ఇది ఎన్ని పునరావృత్తులు నిర్వహించబడుతుందో నిర్ణయిస్తుంది, ఉదాహరణకు:

for (i = 0; i <100; i++) {
/* statements to execute repeatedly */
}

లూప్‌లో నేను మార్పు చేయకపోతే, లేదా మరొక స్టేట్మెంట్ లూప్ అమలును నిలిపివేస్తే తప్ప సరిగ్గా 100 సార్లు తిరిగే లూప్ కోసం ఇది సుపరిచితమైనది.

ఫోరెచ్ లూప్‌లు, దీనికి విరుద్ధంగా, జాబితాలు లేదా శ్రేణుల వంటి నిర్మాణాలపై పనిచేస్తాయి మరియు ఆ సేకరణలోని ప్రతి అంశానికి పునరుక్తి చేయండి:

people = [ 'Peter', 'Paul', 'Mary' ]
foreach (people as person) {
if (person == 'Paul') {
...
}
}

కొన్ని భాషలు సేకరణ మరియు అంశాల క్రమాన్ని మార్చుకునే కొద్దిగా భిన్నమైన వాక్యనిర్మాణాన్ని ఉపయోగిస్తాయి:

people = [ 'Peter', 'Paul', 'Mary' ]
for (person in people) {
if (person == 'Paul') {
...
}
}

లూప్‌ల కోసం

బాష్‌లో, ఫోర్‌యాచ్ — లేదా లో - లూప్ మరింత సాధారణం. ప్రాథమిక వాక్యనిర్మాణం, కేవలం:

for arg in [list]
do
/* statements to execute repeatedly */
/* the value of arg can be obtained using $arg */
done

ఉదాహరణకు, స్పష్టంగా పేరున్న మూడు ఫైళ్ల ద్వారా మళ్లీ చెప్పడానికి:

ఎవరో నా psn అకౌంట్‌ని హ్యాక్ చేశారు, నేను దాన్ని ఎలా తిరిగి పొందగలను

for file in one.c two.c three.c
do
ls '$file'
done

ప్రస్తుత డైరెక్టరీలో అలాంటి ఫైల్‌లు ఉంటే, ఈ స్క్రిప్ట్ నుండి అవుట్‌పుట్ ఉంటుంది:

one.c
two.c
three.c

స్థిర సెట్ ఫైల్‌లకు బదులుగా, జాబితాను గ్లోబ్ నమూనా ద్వారా పొందవచ్చు (వైల్డ్‌కార్డ్‌లతో సహా - ఇతర అక్షరాలను సూచించే ప్రత్యేక అక్షరాలు). కింది ఉదాహరణలో, for. లూప్ అన్ని ఫైల్‌లలో (ప్రస్తుత డైరెక్టరీలో) దాని పేర్లు '.xml' లో ముగుస్తాయి:

for file in *.xml
do
ls -l '$file'
done

ఇక్కడ కొన్ని ఉదాహరణ అవుట్‌పుట్ ఉంది:

$ -rw-r--r-- 1 bobby staff 2436 3 Nov 2019 feed.xml
$ -rw-r--r-- 1 bobby staff 6447 27 Oct 16:24 sitemap.xml

ఇది సుదీర్ఘమైన మార్గం వలె కనిపిస్తుంది:

$ ls -l *.xml

కానీ ఒక ముఖ్యమైన వ్యత్యాసం ఉంది: for loop అమలు చేస్తుంది ls ప్రోగ్రామ్ 2 వేర్వేరు సార్లు, ఒక్కో ఫైల్ పేరు ప్రతిసారీ దానికి పంపబడుతుంది. ప్రత్యేక ls ఉదాహరణలో, గ్లోబ్ నమూనా (*.xml) మొదట ఫైల్ పేర్లతో సరిపోలుతుంది మరియు తర్వాత అన్నింటినీ వ్యక్తిగత కమాండ్-లైన్ పారామితులుగా, ఒక ఉదాహరణకి పంపుతుంది ls .

దీనిని ఉపయోగించే ఉదాహరణ ఇక్కడ ఉంది wc (వర్డ్ కౌంట్) ప్రోగ్రామ్ వ్యత్యాసాన్ని మరింత స్పష్టంగా చేయడానికి:

$ wc -l *.xml
44 feed.xml
231 sitemap.xml
275 total

ది wc ప్రోగ్రామ్ ప్రతి ఫైల్‌లోని పంక్తుల సంఖ్యను విడిగా లెక్కిస్తుంది, ఆపై మొత్తం కౌంట్ మొత్తాన్ని ప్రింట్ చేస్తుంది. దీనికి విరుద్ధంగా, ఉంటే wc లూప్ కోసం పనిచేస్తుంది:

for file in *.xml
do
wc -l $file
done

మీరు ఇప్పటికీ ప్రతి ఫైల్ కోసం గణనను చూస్తారు:

44 feed.xml
231 sitemap.xml

కానీ మొత్తం సారాంశం మొత్తం లేదు ఎందుకంటే wc ఒంటరిగా అమలు చేయబడుతుంది, ప్రతిసారి లూప్ మళ్లీ మారుతుంది.

జాబితా జాబితా కానప్పుడు

ఉల్లేఖనాల కోసం వ్యవహరించేటప్పుడు చాలా సులభమైన మరియు సాధారణ తప్పు ఉంది, బాష్ ఉల్లేఖించిన వాదనలు/తీగలను నిర్వహించే విధానం కారణంగా. ఫైళ్ల జాబితా ద్వారా లూప్ చేయడం ఇలా చేయాలి:

for file in one.c two.c

ఇలా కాదు:

for file in 'one.c two.c'

రెండవ ఉదాహరణ ఫైల్ పేర్లను డబుల్-కోట్స్‌లో జతచేస్తుంది, దీని వలన కేవలం ఒకే పరామితితో జాబితా వస్తుంది; for loop ఒక్కసారి మాత్రమే అమలు చేస్తుంది. అటువంటి సందర్భాలలో వేరియబుల్ ఉపయోగించడం ద్వారా ఈ సమస్యను నివారించవచ్చు:

FILES='one.c two.c'
for file in $FILES
do
...
done

వేరియబుల్ డిక్లరేషన్ దాని విలువను డబుల్ కోట్స్‌లో జతచేయాల్సిన అవసరం ఉందని గమనించండి!

ఒక కంప్యూటర్ నుండి మరొక కంప్యూటర్‌కు ఫైల్‌లను ఎలా తరలించాలి

జాబితా లేకుండా

పునరుద్ఘాటించడానికి ఏమీ లేనప్పుడు, స్క్రిప్ట్‌కి ఇన్‌వక్ట్ చేసినప్పుడు కమాండ్-లైన్ ఆర్గ్యుమెంట్‌లు అందించబడిన వాటిపై ఫర్ లూప్ పనిచేస్తుంది. ఉదాహరణకు, మీకు పేరున్న స్క్రిప్ట్ ఉంటే args.sh కింది వాటిని కలిగి ఉంది:

#!/bin/sh
for a
do
echo $a
done

అప్పుడు args.sh ని అమలు చేయడం వలన మీకు ఈ క్రిందివి ఇవ్వబడతాయి:

$ ./args.sh one two three
one
two
three

బాష్ ఈ కేసును గుర్తించి చికిత్స చేస్తాడు ఒక పని కోసం సమానంగా $@ చేయండి లో ఇక్కడ $@ అనేది కమాండ్-లైన్ ఆర్గ్యుమెంట్‌లను సూచించే ప్రత్యేక వేరియబుల్.

లూప్ కోసం సాంప్రదాయ సంఖ్యాకాన్ని అనుకరించడం

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

for (( i=1; i<=5; i++ ))
do
echo $i
done

ఇది మూడు భాగాలతో కూడిన క్లాసిక్ రూపం:

1. లూప్ మొదట ఎదురైనప్పుడు వేరియబుల్ ప్రారంభించబడింది (i = 1)
2. పరిస్థితి ఉన్నంత వరకు లూప్ కొనసాగుతుంది (i<=5) is true
3. లూప్ చుట్టూ ప్రతిసారీ, వేరియబుల్ పెరుగుతుంది (i ++)

రెండు విలువల మధ్య పునరుద్ఘాటించడం అనేది ఒక చిన్న, కొంచెం తక్కువ గందరగోళ ప్రత్యామ్నాయం ఉన్న ఒక సాధారణ అవసరం:

for i in {1..5}
do
echo $i
done

లూప్ కోసం పైన పేర్కొన్న వాటిని సమర్థవంతంగా అనువదించే బ్రేస్ విస్తరణ:

for i in 1 2 3 4

బ్రేక్ మరియు కంటిన్యూతో ఫైనర్ లూప్ కంట్రోల్

లూప్‌ల కోసం మరింత సంక్లిష్టంగా తరచుగా ముందుగానే నిష్క్రమించడం లేదా తదుపరి లూప్‌తో ప్రధాన లూప్‌ను వెంటనే రీస్టార్ట్ చేయడం అవసరం. అలా చేయడానికి, ఇతర ప్రోగ్రామింగ్ భాషలలో సాధారణం అయిన బాష్ బ్రేక్ మరియు స్టేట్‌మెంట్‌లను కొనసాగించండి. 100 అక్షరాల కంటే ఎక్కువ పొడవు ఉన్న మొదటి ఫైల్‌ను కనుగొనడానికి రెండింటినీ ఉపయోగించే ఉదాహరణ ఇక్కడ ఉంది:

#!/bin/bash
for file in *
do
if [ ! -f '$file' ]
then
echo '$file is not a file'
continue
fi
num_chars=$(wc -c <'$file')
echo $file is '$num_chars characters long'
if [ $num_chars -gt 100 ]
then
echo 'Found $file'
break
fi
done

ఇక్కడ ఉన్న లూప్ ప్రస్తుత డైరెక్టరీలోని అన్ని ఫైళ్లలో పనిచేస్తుంది. ఫైల్ సాధారణ ఫైల్ కానట్లయితే (ఉదా. అది డైరెక్టరీ అయితే), తదుపరి ఫైల్‌తో లూప్‌ను పునartప్రారంభించడానికి కొనసాగింపు స్టేట్‌మెంట్ ఉపయోగించబడుతుంది. ఇది సాధారణ ఫైల్ అయితే, రెండవ షరతులతో కూడిన బ్లాక్‌లో 100 కంటే ఎక్కువ అక్షరాలు ఉన్నాయో లేదో నిర్ధారిస్తుంది. అలా అయితే, బ్రేక్ స్టేట్‌మెంట్ వెంటనే లూప్‌ను వదిలివేయడానికి ఉపయోగించబడుతుంది (మరియు స్క్రిప్ట్ చివరకి చేరుకోండి).

ముగింపు

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

షేర్ చేయండి షేర్ చేయండి ట్వీట్ ఇమెయిల్ ఇది విండోస్ 11 కి అప్‌గ్రేడ్ చేయడం విలువైనదేనా?

Windows పునesరూపకల్పన చేయబడింది. విండోస్ 10 నుండి విండోస్ 11 కి మారడానికి మిమ్మల్ని ఒప్పించడానికి ఇది సరిపోతుందా?

తదుపరి చదవండి సంబంధిత అంశాలు

• ప్రోగ్రామింగ్
• లైనక్స్

రచయిత గురుంచి బాబీ జాక్(58 కథనాలు ప్రచురించబడ్డాయి)

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

బాబీ జాక్ నుండి మరిన్ని

మా వార్తాలేఖకు సభ్యత్వాన్ని పొందండి

టెక్ చిట్కాలు, సమీక్షలు, ఉచిత ఈబుక్‌లు మరియు ప్రత్యేకమైన డీల్స్ కోసం మా వార్తాలేఖలో చేరండి!

సభ్యత్వం పొందడానికి ఇక్కడ క్లిక్ చేయండి