షట్టర్‌స్టాక్ / జీప్ 5 డి

చాలా ప్రోగ్రామింగ్ భాషలు వివిధ రకాల కోడ్ లైన్ లూప్‌లకు మద్దతు ఇస్తాయి. బాష్ స్థానికంగా “ఉండగానే”, “ఉచ్చులు వరకు” మరియు “ఉచ్చుల కోసం మరింత ప్రాచుర్యం” వరకు మద్దతు ఇస్తుంది. ఈ వ్యాసం ఈ మూడింటిని పరిచయం చేస్తుంది మరియు చర్చిస్తుంది.

ఏవి బాష్ ఉచ్చులు?

దీన్ని కొంచెం మెరుగ్గా నిర్వచించడానికి, మనం ప్రశ్నతో ప్రారంభించాలి ఉచ్చులు ఏమిటి. లూప్స్ అనేది ప్రోగ్రామింగ్ లాంగ్వేజ్ నిర్మాణం, ఇది డెవలపర్‌ను ఆ లూప్ నిర్వచనంలోని కొన్ని లేదా అన్ని కోడ్‌లను పునరావృతం చేయడానికి అనుమతిస్తుంది (అనగా లూప్). ఇప్పుడు నిర్వచించడం సులభం బాష్ ఉచ్చులు బాష్‌లో ఉపయోగించిన లూప్ ప్రోగ్రామింగ్ భాష యొక్క ఏదైనా నిర్మాణం వంటిది!

బాష్ స్థానికంగా “కోసం”, “వరకు” మరియు “అయితే” ఆధారిత ఉచ్చులకు మద్దతు ఇస్తుంది. వీటిలో ప్రతి దాని ప్రయోజనాలు ఉన్నాయి, కానీ ఇడియమ్ అనే ప్రధాన పదాన్ని చూడటం ద్వారా మీరు ఇప్పటికే వాటి అర్ధాన్ని తెలుసుకోవచ్చు. ఉదాహరణకు, “వరకు” సహజంగా “ఏదైనా చేయటం” గురించి ఆలోచించటానికి దారితీస్తుంది మరియు ఇది వాస్తవానికి “వరకు” బాష్ లూప్ చేస్తుంది; ఒక నిర్దిష్ట షరతు నెరవేరే వరకు ఇది కొంత మొత్తంలో కోడ్ (లేదా ప్రతిదీ) ద్వారా ఉచ్చులు వేస్తుంది.

అదేవిధంగా, షరతులు ఇకపై నిజం కానంత వరకు “అయితే” ఉచ్చులు పని చేస్తూనే ఉంటాయి. చివరగా, “కోసం” ఉచ్చులు, ఉదాహరణకు, “70 సార్లు, ఎలా చేద్దాం …” అని మనం ఎలా వ్రాస్తామో దానికి సమానమైన నిర్వచించిన సంఖ్యలు. ప్రతి లూప్ మాకు అందించే ప్రత్యేక లక్షణాలను తార్కికంగా అర్థం చేసుకోవడానికి మరియు మరింత చదవగలిగే కోడ్‌ను అమలు చేయడానికి ఇది మాకు సహాయపడుతుంది.

కోసం ఆధారిత బాష్ లూప్స్

ఈ వ్యాసం యొక్క ప్రయోజనాల కోసం, మేము క్రొత్త నిర్వచనం యొక్క రూపాన్ని పరిశీలిస్తాము ఉచ్చుల కోసం బాష్. యొక్క కొంత పాత, తక్కువ ఆధునిక నిర్వచనం కోసం బాష్‌లోని ఉచ్చులు, ఉదాహరణకు, ఇలా ఉండవచ్చు: for i in $(seq 1 5); do echo $i; done. దీన్ని క్లీనర్, మెరుగైన ఆకృతి మరియు ఆధునిక రూపంతో పోల్చండి కోసం లూప్:

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

లూప్ కోసం బాష్ ఆధారిత

ఈ సింపుల్ కోసం బాష్-ఆధారిత పంక్తి (ఒకే పంక్తిలో వ్రాసిన మినీ-స్క్రిప్ట్‌ను సంభావితం చేయడానికి లైనక్స్ / బాష్ సర్కిల్‌లలో తరచుగా ఉపయోగించే పదం) 1 నుండి 5 సంఖ్యలను వరుస క్రమంలో ముద్రిస్తుంది. మేము దీని కోసం ప్రారంభ విలువను సెట్ చేసాము i వేరియబుల్ ($i) విలువను కేటాయించడం ద్వారా 1 అదే, మా మొదటి భాగం కోసం లూప్ నిర్వచనం, a చేత ముగించబడింది ; డీలిమిటర్.

తరువాత, మనకు ఎక్కడానికి ఒకటి మాత్రమే ఉందని మేము పేర్కొంటాము “ఐదు కంటే తక్కువ లేదా సమానం” ఉపయోగించి i<=5. ప్రతి రౌండ్ చివరిలో ఏమి జరగాలి అని మేము సూచిస్తాము మరియు అది వేరియబుల్ పెంచడం i ఒకటి ద్వారా, లేదా, సాధారణంగా ఉపయోగించే కోడింగ్ సత్వరమార్గంలో (ఉదాహరణకు C ++ భాషలో చేర్చబడింది), ఇది ఇలా ప్రదర్శించబడుతుంది i++.

చివరగా మేము ఉపయోగించి మా లూప్ కోడ్ ప్రారంభాన్ని తెలుపుతాము do, అంటే, మాది పూర్తి చేసిన తర్వాత for లూప్ నిర్వచనం, ఇతర స్టేట్మెంట్ ముగింపు వంటిది ; ముందు do. మేము మా లూప్ కోడ్ ముగింపును కూడా పేర్కొంటాము done మరియు యు.ఎస్ echo (ప్రింట్) మా వేరియబుల్ విలువ నేను మధ్య do ఉంది done.

ప్రత్యేకంగా గమనించండి do నిబంధన కూడా అంతం కాదు ;మరియు అలా చేస్తే లోపం ఏర్పడుతుంది. పరిగణించండి do ఏమి చేయాలో ఉపసర్గ మరియు ఇది మరింత అర్ధమే. మల్టీ-లైన్ స్క్రిప్ట్‌లో వస్తువులను ఉంచడం కొన్నిసార్లు శుభ్రంగా ఉండటానికి ఇది ఒక కారణం do ఇది ఒక పంక్తి యొక్క చివరి పదం కావచ్చు.

ఇతర రకాల ఉచ్చులను నిర్వచించేటప్పుడు కూడా, మేము ఫైల్‌ను అలాగే ఉంచుతాము do ఉంది done నిబంధనలు, మరియు మేము ఎల్లప్పుడూ మా లూప్ నిర్వచనాన్ని పూర్తి చేస్తామని నిర్ధారించుకుంటాము (అనగా ముందు do) తో ;, అలాగే మనలోని ప్రతి ప్రకటన ముగింపును ముగించడం do...done తో లూప్ నిర్వచనం ;.

ఈ విధంగా విషయాలు ఎలా పని చేస్తాయో మరింత స్పష్టంగా చూడటానికి చిన్న స్క్రిప్ట్‌లో ఉంచండి:

#!/bin/bash

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

లూప్ ఆధారిత బాష్ స్క్రిప్ట్

స్క్రిప్ట్‌ను ఎక్జిక్యూటబుల్ చేసిన తర్వాత chmod +x test.sh, మేము అదే చేస్తాము. స్క్రిప్ట్‌లో కొన్ని చిన్న మార్పులు చేయబడ్డాయి. ఈసారి మనం వేరియబుల్‌ను ఎలా పెంచుతున్నామో గమనించండి i ప్రతిసారీ రెండు. ఇది మరొక కోడింగ్ సత్వరమార్గాన్ని ఉపయోగించి జరుగుతుంది i+=2 ఇది చదవవచ్చు నేను రెండు పెంచండి. మీరు కూడా వ్రాయవచ్చు i=i+2 అదే స్థలంలో మరియు ఇది సరిగ్గా అదే విధంగా పనిచేస్తుంది.

మనం ప్రారంభిద్దాం చూద్దాం 1మరియు ద్వారా పెంచండి 2 మేము లూప్ చేసిన ప్రతిసారీ ముగుస్తుంది 9. అది ముగియడానికి కారణం 9 అంటే గరిష్ట విలువ 10. కాబట్టి, తరువాత 9 తదుపరి విలువ ఉంటుంది 11, అప్పుడు ఎక్కువ 10 అందువల్ల ప్రదర్శించబడదు / పునరావృతం కాదు.

అని కూడా పిలుస్తారు ; ఎకో లైన్ తర్వాత తొలగించబడింది. ఎందుకంటే పరిస్థితి / న్యూలైన్ అక్షరం ఉంటే స్టేట్‌మెంట్ ముగింపును ముగించాల్సిన అవసరం లేదు. ఇక్కడ ఇదే పరిస్థితి; తరువాత మాకు వేరే ఆదేశం లేదు echo $i మరియు పంక్తి వెంటనే ముగుస్తుంది (పంక్తి చివర ఖాళీలు కూడా బాగానే ఉంటాయి, సూత్రం ఆ క్రొత్త ఆదేశం ముందు (మరియు మునుపటిది ముగించబడినది) ద్వారా తప్ప మరొక ఆదేశాన్ని కలిగి ఉండకూడదు. ;).

అయితే ఆధారిత బాష్ లూప్స్

ఇప్పుడు బాష్ లూప్‌ను చూద్దాం do...done లూప్ నిర్వచనం, మేము ఒక ఫైల్ను నిర్వచించగలము బాష్ లూప్ ఆధారపడి ఉంటుంది ఇచ్చిన షరతు నిజం అయినంత వరకు ఇది అమలు అవుతుంది.

i=1; while [ $i -le 5 ]; do echo $i; i=$[ i + 1 ]; done

బాష్ ఆధారిత చక్రం

ఈ ఉదాహరణలో, మేము మా మొదటి మాదిరిగానే చేస్తాము కోసం లూప్ ఆధారిత ఉదాహరణ. నిర్వచనం మరింత క్లిష్టంగా కనిపించినప్పటికీ (అందువలన a కోసం ఈ ప్రత్యేక వినియోగ సందర్భానికి మరింత అనుకూలంగా ఉండవచ్చు), మేము ఫైల్‌ను ఎలా నిర్వచించవచ్చో చూడటం ఆసక్తికరంగా ఉంటుంది అయితే అదే విధంగా లూప్ చేయండి.

ఇక్కడ మేము మొదట మాది సెట్ చేసాము i వేరియబుల్, మానవీయంగా, ఒక ప్రత్యేక ఆదేశంలో ముగించబడింది ;, కోసం 1. తరువాత మేము ఒక ఫైల్ను ప్రారంభిస్తాము అయితే లూప్‌లో మనం ఒక షరతును సెట్ చేసాము, ఒక విధంగా నిర్వచించటానికి చాలా పోలి ఉంటుంది if స్టేట్మెంట్ (ఈ వ్యాసం చివర ఒక వ్యాసానికి లింక్ ఉంది if మీరు మరింత తెలుసుకోవాలనుకుంటే), మేము ఎక్కడ తనిఖీ చేస్తున్నాము i వేరియబుల్ కంటే తక్కువ లేదా సమానం (-le) అప్పుడు 5.

దీని తరువాత మనకు మామూలు ఉంది do...done మేము ఎక్కడ బ్లాక్ echo మా వేరియబుల్, ఆపై, క్రొత్త సూచనలో, మానవీయంగా, మన విలువను పెంచుతుంది i నిర్వచించిన విధంగా గణిత గణనలో ఒకటి వేరియబుల్ $[...] ఇడియమ్స్ లెక్కించే బాష్. తదుపరి చెక్అవుట్ చేద్దాం a బాష్ ఆధారిత చక్రం వరకు

వరకు ఆధారిత బాష్ లూప్స్

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

i=1; until [ $i -gt 5 ]; do echo $i; i=$[ i + 1 ]; done

చక్రం ఆధారిత బాష్

ఇక్కడ మేము పరిస్థితి కోసం చూస్తాము నేను ఎక్కువ అప్పుడు 5 నిజం కావడానికి. ఆ సమయం వరకు (అనగా a వరకు లూప్ ఆధారంగా), మేము ప్రింట్ చేస్తాము (ఉపయోగించి echo) మా వేరియబుల్ నేను మరియు మా మునుపటి మాదిరిగానే ఒకదానితో పెంచండి అయితే ఆధారిత ఉదాహరణ.

యొక్క వాక్యనిర్మాణం ఎలా ఉంటుందో మనం చూడవచ్చు వరకు ఆదేశం చాలా పోలి ఉంటుంది అయితే ఆదేశం. ఇది కాకుండా, గమనించండి for కమాండ్ బేస్డ్, ఈ ఆదేశాలు ఫైల్ కోసం చూస్తాయి నిజం కొనసాగడానికి పరిస్థితి (తో అయితే) లేదా ఒకదానికి ఒకటి నిజం ప్రారంభించాల్సిన పరిస్థితి (తో వరకు). అవుట్పుట్ వంటి నిజమైన / తప్పుడు తిరిగి ఇవ్వగల ఇతర ఆదేశాలను ఉపయోగించడానికి ఇది మిమ్మల్ని అనుమతిస్తుంది grep -q:

echo 1 > a
while grep -q '1' ./a; do echo 'yes'; sleep 5; done

కాసేపు ఆధారిత బాష్ లూప్‌లో grep -q ఉపయోగించి నిజమైన స్థితి కోసం తనిఖీ చేయండి

ఇక్కడ మేము సంఖ్యను జోడిస్తాము 1 అనే ఫైల్‌లో aమరియు సంఖ్య యొక్క ఉనికిని తనిఖీ చేయండి 1 a ఉపయోగించి ఆ ఫైల్ లోపల grep -q (నిశ్శబ్ద గ్రెప్). మేము దీన్ని కొనసాగిస్తున్నాము (ఉదా అయితే) ఇది నిజం కానంత వరకు. అది నిజం అయినప్పటికీ, మేము వచనాన్ని ముద్రించాము అయ్యో మరియు ఐదు సెకన్ల పాటు చక్రం పాజ్ చేయండి sleep 5. ప్రతి ఆదేశం ఎలా ముగుస్తుందో గమనించండి ; ఇంకా.

సుమారు 17 సెకన్ల తరువాత మేము CTRL + c ని ఉపయోగించి మా స్క్రిప్ట్‌ను ఆపివేస్తాము, ఇది బాష్‌లో నడుస్తున్న ప్రక్రియను ఆపడానికి సార్వత్రిక పద్ధతి (ప్లస్ బలమైన మరియు మరింత ప్రభావవంతమైన CTRL + z ఇది ఒక ప్రక్రియను వెంటనే చంపుతుంది, కానీ అది మరొక వ్యాసం కోసం!)

చుట్టి వేయు

ఈ వ్యాసంలో, బాష్‌లో స్థానికంగా లభించే “కోసం”, “ఉండగా” మరియు “వరకు” ఉచ్చులను పరిశీలించాము. మీకు ఎక్కువ బాష్ పట్ల ఆసక్తి ఉంటే, బాష్‌లోని షరతులతో కూడిన పరీక్షలను చూడండి: ఉంటే, లేకపోతే, ఎలిఫ్, మరియు బాష్ ఫంక్షన్లు మరియు లోకల్ వేరియబుల్స్.

సుఖపడటానికి!

Source link