ஆசிரியர்: பால் கோபட்
வெளியிடப்பட்ட தேதி: அக்டோபர் 16, 2014
மொழிபெயர்ப்பு: ஏ. பானின்
மொழிபெயர்ப்பு தேதி: டிசம்பர் 21, 2014

அத்தியாயம் 22. ஸ்கிரிப்ட்களில் சுழல்கள்

சோதனை கட்டளை

ஒரு வெளிப்பாடு உண்மையா அல்லது பொய்யா என்பதைத் தீர்மானிக்க சோதனை கட்டளை உங்களை அனுமதிக்கிறது. முழு எண் மதிப்பு 55 ஐ விட முழு எண் மதிப்பு 10 அதிகமாக உள்ளதா என்பதை சோதிப்பதன் மூலம் தொடங்குவோம். $ test 10 -gt 55 ; எதிரொலி $? 1$

வெளிப்பாடு தவறாக இருந்தால் சோதனை கட்டளை 1 ஐ வழங்குகிறது. மேலும், பின்வரும் எடுத்துக்காட்டில் நீங்கள் பார்ப்பது போல், வெளிப்பாடு உண்மைக்கு மதிப்பிட்டால் சோதனை கட்டளை 0 ஐ வழங்கும். $ சோதனை 56 -ஜிடி 55 ; எதிரொலி $? $0

சரி மற்றும் தவறான சரங்களுடன் பணிபுரிவது உங்களுக்கு மிகவும் வசதியாக இருந்தால், கீழே காட்டப்பட்டுள்ளபடி சோதனைக் கட்டளையைப் பயன்படுத்தலாம். $ சோதனை 56 -ஜிடி 55 && எதிரொலி உண்மை || எதிரொலி தவறான உண்மை $ சோதனை 6 -ஜிடி 55 && எதிரொலி உண்மை || எதிரொலி தவறான பொய்

சோதனை கட்டளையை சதுர அடைப்புக்குறிகளால் மாற்றலாம், எனவே கீழே உள்ள எடுத்துக்காட்டில் உள்ள கட்டளைகள் மேலே உள்ள எடுத்துக்காட்டில் உள்ள கட்டளைகளைப் போலவே இருக்கும். $ [ 56 -gt 55 ] && எதிரொலி உண்மை || எதிரொலி தவறான உண்மை $ [ 6 -gt 55 ] && எதிரொலி உண்மை || எதிரொலி தவறான பொய்

சில காசோலைகளை செயல்படுத்துவதற்கான எடுத்துக்காட்டுகள் கீழே உள்ளன. மேலோட்டப் பார்வைக்கு மேன் டெஸ்ட் பக்கத்தைப் பார்க்கவும் கூடுதல் அம்சங்கள்பல்வேறு காசோலைகளை செயல்படுத்துதல். [ -d foo ] அடைவு foo உள்ளதா? [ -e bar ] பார் கோப்பு உள்ளதா? [ "/etc" = $PWD ] /etc $PWD இன் மதிப்புக்கு சமமானதா? [ $1 != "secret" ] முதல் ஸ்கிரிப்ட் அளவுருவின் மதிப்பு இரகசிய சரத்திலிருந்து வேறுபட்டதா? [55 -lt $bar] முழு எண் மதிப்பு $bar மதிப்பை விட 55 குறைவாக உள்ளதா? [ $foo -ge 1000 ] $foo இன் மதிப்பு முழு எண் மதிப்பு 1000 ஐ விட அதிகமாக உள்ளதா அல்லது சமமாக உள்ளதா? ["abc"< $bar ] Будет ли строка abc расположена выше значения переменной $bar в списке после сортировки? [ -f foo ] Является ли foo обычным файлом? [ -r bar ] Является ли bar படிக்கக்கூடிய கோப்பு? [foo-nt bar] பட்டியை விட foo புதியதா? [ -o nounset ] nounset ஷெல் விருப்பம் இயக்கப்பட்டதா?

காசோலை ஆபரேட்டர்கள் தொடர்புடைய ஆபரேட்டர்களுடன் இணைக்கப்படலாம் தருக்க செயல்பாடுகள்"AND" மற்றும் "OR". paul@RHEL4b:~$ [ 66 -gt 55 -a 66 -lt 500 ] && எதிரொலி உண்மை || echo false true paul@RHEL4b:~$ [ 66 -gt 55 -a 660 -lt 500 ] && எதிரொலி உண்மை || echo false false paul@RHEL4b:~$ [ 66 -gt 55 -o 660 -lt 500 ] && எக்கோ உண்மை || எதிரொலி தவறான உண்மை

வேறு என்றால் நிபந்தனை தாவல்

if then else construct என்பது குறியீடு விருப்பத்தைத் தேர்ந்தெடுக்கும் நோக்கம் கொண்டது. ஒரு குறிப்பிட்ட நிபந்தனை உண்மையாக இருந்தால், சில குறியீடுகள் செயல்படுத்தப்படும், இல்லையெனில் வேறு சில குறியீடுகள் செயல்படுத்தப்படும். கீழே உள்ள எடுத்துக்காட்டு ஒரு கோப்பின் இருப்பை சரிபார்க்கிறது, அதன் பிறகு, கோப்பின் இருப்பு பற்றிய அனுமானம் உறுதிப்படுத்தப்பட்டால், தொடர்புடைய செய்தி காட்டப்படும். #!/bin/bash [ -f isit.txt ] எனில், isit.txt கோப்பை எதிரொலிக்கவும்! வேறு எக்கோ கோப்பு isit.txt கிடைக்கவில்லை! fi

நாம் சேமிக்கும் நிகழ்வில் இந்த குறியீடு"தேர்வு" என்ற கோப்பில் உள்ள ஸ்கிரிப்ட், அதை அதே வழியில் செயல்படுத்தலாம். $ ./choice கோப்பு isit.txt கிடைக்கவில்லை! $ touch isit.txt $ ./choice கோப்பு isit.txt உள்ளது! $

கண்டிஷனல் ஜம்ப் என்றால் elif

நீங்கள் இடுகையிடலாம் புதிய ஆபரேட்டர்எலிஃப் ஆபரேட்டரைப் பயன்படுத்தி வேறு ஒரு தொகுதிக்குள் இருந்தால் நிபந்தனைக்குட்பட்ட ஜம்ப். அத்தகைய நுழைவுக்கான எளிய எடுத்துக்காட்டு கீழே உள்ளது. #!/bin/bash count=42 எனில் [ $count -eq 42 ] பிறகு எதிரொலி "42 என்பது சரியான மதிப்பு." elif [ $count -gt 42 ] பின்னர் "மிக அதிகம்" என்று எதிரொலிக்கவும். வேறு எதிரொலி "போதாது." fi

வளையத்திற்கு

கீழே உள்ள உதாரணம் பாஷ் ஷெல்லில் கிளாசிக் ஃபார் லூப்பின் தொடரியல் காட்டுகிறது. நான் 1 2 4 க்கு எதிரொலி $நான் செய்தேன்

இன்லைன் ஷெல் அழைப்புடன் இணைந்து ஃபார் லூப்பைப் பயன்படுத்துவதற்கான எடுத்துக்காட்டு. `seq 1 20` இல் கவுண்டருக்கு #!/bin/ksh 1 முதல் 20 வரை எதிரொலி எண்ணுதல், தற்போதைய மதிப்பு $counter sleep 1 முடிந்தது

மேலே வழங்கப்பட்டுள்ளதை ஒத்த ஸ்கிரிப்டை, உட்பொதிக்கப்பட்ட கட்டளை ஷெல்லைப் பயன்படுத்தாமல், மதிப்புகளின் வரம்பிற்கு (மதிப்பிலிருந்து.. மதிப்பு வரை) பாஷ் ஷெல் அறிவிப்பைப் பயன்படுத்தி உருவாக்க முடியும். #!/bin/bash for counter in (1..20) do echo counting to 1 to 20, current value $counter sleep 1 முடிந்தது

இது ஃபார் லூப் வடிவத்தின் மூலம் கோப்புகளைத் தேடுவதற்கான ஒரு பொறிமுறையைப் பயன்படுத்துகிறது (கட்டளை விரிவாக்க பொறிமுறையின் ஒரு பகுதியாக செயல்படுத்தப்படுகிறது). மேலே உள்ள வழிமுறைகள் நேரடியாக இடுகையிடப்பட்டிருந்தால் கட்டளை வரி, இது இதேபோல் செயல்படும். *.ksh இல் உள்ள கோப்புக்கு kahlan@solexp11$ ls count.ksh go.ksh kahlan@solexp11$ ; cp $file $file.backup செய்யுங்கள்; முடிந்தது kahlan@solexp11$ ls count.ksh count.ksh.backup go.ksh go.ksh.backup

லூப் போது

ஒரு போது வளையத்தைப் பயன்படுத்துவதற்கான எளிய எடுத்துக்காட்டு கீழே உள்ளது. நான்=100; அதே நேரத்தில் [ $i -ge 0 ] ; 100 முதல் 0 வரை எதிரொலி கவுண்ட்டவுன் செய்யுங்கள், தற்போதைய மதிப்பு $i; நான் -- விடு; முடிந்தது

Infinite loops when true or while: declarations, இதில் சின்னம்: என்பது கோர்ன் ஷெல் மற்றும் பாஷில் விடுபட்ட செயல்பாட்டிற்குச் சமமானதாகும். #!/bin/ksh # முடிவில்லாத லூப் போது: எக்கோ ஹலோ ஸ்லீப் 1 முடிந்தது

லூப் வரை

வரை லூப்பைப் பயன்படுத்துவதற்கான எளிய எடுத்துக்காட்டு கீழே உள்ளது. i=100ஐ விடுங்கள்; வரை [ $i -le 0 ] ; 100 முதல் 1 வரை எதிரொலி கவுண்ட்டவுன் செய்யுங்கள், தற்போதைய மதிப்பு $i; நான் -- விடு; முடிந்தது

பயிற்சி: ஸ்கிரிப்ட்களில் சோதனைகள் மற்றும் சுழல்கள்

3. ஒரு ஸ்கிரிப்டை உருவாக்கவும், அது 3 முதல் 7 வரை எண்ணுவதற்கு சிறிது நேர சுழற்சியைப் பயன்படுத்துகிறது.

4. 8 முதல் 4 வரை எண்ணுவதற்கு வரை சுழற்சியைப் பயன்படுத்தும் ஸ்கிரிப்டை உருவாக்கவும்.

5. தற்போதைய கோப்பகத்தில் .txt நீட்டிப்புடன் கோப்புகளை எண்ணும் ஸ்கிரிப்டை உருவாக்கவும்.

6. தற்போதைய கோப்பகத்தில் .txt நீட்டிப்புடன் கோப்புகள் இல்லை என்றால், உருவாக்கப்பட்ட ஸ்கிரிப்ட்டில் if அறிக்கையைப் பயன்படுத்தவும்.

ஒரு நடைமுறை பணியை முடிப்பதற்கான சரியான செயல்முறை: ஸ்கிரிப்ட்களில் காசோலைகள் மற்றும் சுழல்கள்

1. 3 முதல் 7 வரை எண்ணுவதற்கு ஒரு லூப்பைப் பயன்படுத்தும் ஸ்கிரிப்டை உருவாக்கவும்.

#!/bin/bash for i in 3 4 5 6 7 do echo Counting to 3 இலிருந்து 7, தற்போதைய மதிப்பு $நான் முடிந்தது

2. 1 முதல் 17000 வரை எண்ணுவதற்கு ஒரு லூப்பைப் பயன்படுத்தும் ஸ்கிரிப்டை உருவாக்கவும்.

பாஷ் ஷெல் சுழல்களை ஆதரிக்கிறது, இது மதிப்புகளின் வரிசைகளை மீண்டும் செய்ய உங்களை அனுமதிக்கிறது. அதுதான் அது அடிப்படை கட்டமைப்புஅத்தகைய சுழற்சிகள்:

பட்டியலில் உள்ள var க்கு செய்ய கட்டளை முடிந்தது
லூப்பின் ஒவ்வொரு மறு செய்கையிலும், மாறி var என்பது அடுத்த மதிப்புக்கு எழுதப்படும் பட்டியல். எனவே லூப்பின் முதல் பாஸ் பட்டியலிலிருந்து முதல் மதிப்பைப் பயன்படுத்தும். இரண்டாவது - இரண்டாவது, மற்றும் பல - லூப் கடைசி உறுப்பு அடையும் வரை.

எளிய மதிப்புகள் மீது மீண்டும் மீண்டும்

பாஷ் ஸ்கிரிப்ட்களில் ஃபார் லூப்பின் எளிய உதாரணம், எளிய மதிப்புகளின் பட்டியலை மீண்டும் செயல்படுத்துவதாக இருக்கலாம்:

#!/bin/bash for var in first second third fourth fifth do echo The $var உருப்படி முடிந்தது
இந்த ஸ்கிரிப்ட்டின் முடிவுகள் கீழே காட்டப்பட்டுள்ளன. $var மாறி வரிசையாக பட்டியலிலிருந்து கூறுகளைக் கொண்டிருப்பதை நீங்கள் தெளிவாகக் காணலாம். சுழற்சி கடைசியாக அடையும் வரை இது நடக்கும்.

வளையத்திற்கு எளிமையானது

லூப்பில் இருந்து வெளியேறும் போது $var மாறி அதன் மதிப்பைத் தக்க வைத்துக் கொள்கிறது, அதன் உள்ளடக்கங்களை மாற்றலாம் மற்றும் பொதுவாக, நீங்கள் மற்ற மாறிகளைப் போலவே அதனுடன் வேலை செய்யலாம்.

சிக்கலான மதிப்புகள் மீது மீண்டும் மீண்டும்

for loop ஐத் துவக்கப் பயன்படுத்தப்படும் பட்டியலில் ஒரு சொல்லைக் கொண்ட எளிய சரங்கள் மட்டுமின்றி, பல சொற்கள் மற்றும் நிறுத்தற்குறிகள் அடங்கிய முழு சொற்றொடர்களும் இருக்கலாம். உதாரணமாக, இது இப்படி இருக்கலாம்:

#!/bin/bash for var முதல் "இரண்டாவது" "மூன்றாவது" "நான் அதை செய்வேன்" எதிரொலி "இது: $var" முடிந்தது
இந்த லூப் பட்டியலில் சென்ற பிறகு இதுதான் நடக்கும். நீங்கள் பார்க்க முடியும் என, முடிவு மிகவும் எதிர்பார்க்கப்படுகிறது.

சிக்கலான மதிப்புகள் மீது மீண்டும் மீண்டும்
TNW-CUS-FMP - எங்கள் சேவைகளில் 10% தள்ளுபடிக்கான விளம்பரக் குறியீடு, 7 நாட்களுக்குள் செயல்படுத்தப்படும்"

கட்டளையின் முடிவுகளிலிருந்து பெறப்பட்ட பட்டியலுடன் ஒரு சுழற்சியைத் தொடங்குதல்

for loop ஐ துவக்க மற்றொரு வழி, ஒரு கட்டளையின் விளைவாக ஒரு பட்டியலை அனுப்புவது. இங்கே கட்டளை மாற்றீடு அவற்றை இயக்கவும் அவர்களின் வேலையின் முடிவுகளைப் பெறவும் பயன்படுத்தப்படுகிறது.

#!/bin/bash file="myfile" for var in $(cat $file) do echo " $var" முடிந்தது
இந்த எடுத்துக்காட்டு பூனை கட்டளையைப் பயன்படுத்துகிறது, இது ஒரு கோப்பின் உள்ளடக்கங்களைப் படிக்கிறது. இதன் விளைவாக மதிப்புகளின் பட்டியல் வளையத்திற்குள் அனுப்பப்பட்டு திரையில் காட்டப்படும். நாங்கள் அணுகும் கோப்பில் புதிய வரிகளால் பிரிக்கப்பட்ட சொற்களின் பட்டியல் உள்ளது; இடைவெளிகள் பயன்படுத்தப்படவில்லை.

ஒரு கோப்பின் உள்ளடக்கங்கள் வழியாகச் செல்லும் வளையம்

வரிக்கு வரி தரவு செயலாக்கம் எதிர்பார்க்கப்பட்டால், அத்தகைய அணுகுமுறை மிகவும் சிக்கலான கட்டமைப்பின் கோப்பிற்கு வேலை செய்யாது என்பதை இங்கே நாம் கணக்கில் எடுத்துக்கொள்ள வேண்டும், அதன் வரிகளில் இடைவெளிகளால் பிரிக்கப்பட்ட பல சொற்கள் இருக்கலாம். லூப் தனிப்பட்ட வார்த்தைகளை செயலாக்கும், வரிகளை அல்ல.

இது உங்களுக்குத் தேவையில்லை என்றால் என்ன செய்வது?

புலப் பிரிப்பான்கள்

மேற்கூறிய அம்சத்திற்குக் காரணம் சிறப்பு சுற்றுச்சூழல் மாறி, இது IFS (உள் புல பிரிப்பான்) என்று அழைக்கப்படுகிறது மற்றும் புலம் பிரிப்பான்களைக் குறிப்பிட உங்களை அனுமதிக்கிறது. இயல்பாக, பாஷ் ஷெல் பின்வரும் எழுத்துக்களை புலம் பிரிப்பான்களாகக் கருதுகிறது:

• விண்வெளி
• தாவல் எழுத்து
• வரி ஊட்ட எழுத்து

தரவுகளில் இந்த எழுத்துக்களில் ஏதேனும் ஒன்றை பாஷ் சந்தித்தால், அது பட்டியலில் உள்ள அடுத்த சுயாதீன மதிப்புக்கு முன்னால் இருக்கும் என்று கருதுகிறது.

சிக்கலைத் தீர்க்க, நீங்கள் IFS சூழல் மாறியை தற்காலிகமாக மாற்றலாம். பாஷ் ஸ்கிரிப்ட்டில் அதை எப்படி செய்வது என்பது இங்கே உள்ளது, உங்களுக்கு ஒரு புதிய வரி மட்டுமே புலம் பிரிப்பானாக தேவை என்று கருதி:

IFS=$"\n"
உங்கள் பாஷ் ஸ்கிரிப்ட்டில் இந்தக் கட்டளையைச் சேர்த்தவுடன், அது எதிர்பார்த்தபடி செயல்படும், இடைவெளிகள் மற்றும் தாவல்களைப் புறக்கணித்து, புதிய வரி எழுத்துக்களை மட்டுமே புலப் பிரிப்பான்களாகக் கருதுகிறது.

#!/bin/bash file="/etc/passwd" IFS=$"\n" var in $(cat $file) do echo " $var" முடிந்தது
இந்த ஸ்கிரிப்ட் இயக்கப்பட்டால், லூப்பின் ஒவ்வொரு மறு செய்கையிலும், கோப்பில் எழுதப்பட்ட அடுத்த வரிக்கான அணுகலைக் கொடுக்கும்.

ஒரு ஃபார் லூப்பில் உள்ள கோப்பின் வரிக்கு வரி குறுக்குவழி

பிரிப்பான்கள் மற்ற எழுத்துக்களாகவும் இருக்கலாம். எடுத்துக்காட்டாக, மேலே /etc/passwd கோப்பின் உள்ளடக்கங்களைக் காண்பித்தோம். வரிகளில் உள்ள பயனர் தரவு பெருங்குடல்களால் பிரிக்கப்படுகிறது. அத்தகைய சரங்களை நீங்கள் ஒரு வளையத்தில் செயலாக்க வேண்டும் என்றால், IFS ஐ இவ்வாறு கட்டமைக்க முடியும்:

ஒரு கோப்பகத்தில் உள்ள கோப்புகளை நகர்த்துதல்

பாஷ் ஸ்கிரிப்ட்களில் உள்ள லூப்களின் பொதுவான பயன்பாடுகளில் ஒன்று, ஒரு கோப்பகத்தில் உள்ள கோப்புகளை கடந்து அந்த கோப்புகளை செயலாக்குவது ஆகும்.

எடுத்துக்காட்டாக, கோப்புகள் மற்றும் கோப்புறைகளை எவ்வாறு பட்டியலிடுவது என்பது இங்கே:

/home/likegeeks/* இல் உள்ள கோப்பிற்கான #!/bin/bash என்றால் [ -d "$file" ] பின்னர் "$file is a directory" elif [ -f "$file" ] echo "$file is a கோப்பு" முடிந்தது
இந்தக் கட்டுரைத் தொடரில் முந்தைய உள்ளடக்கத்தை நீங்கள் புரிந்துகொண்டிருந்தால், if-then construct இன் கட்டமைப்பையும், கோப்புறையிலிருந்து ஒரு கோப்பை எவ்வாறு வேறுபடுத்துவது என்பதையும் நீங்கள் புரிந்து கொள்ள வேண்டும். மேலே உள்ள குறியீட்டைப் புரிந்துகொள்வது கடினமாக இருந்தால், இந்த உள்ளடக்கத்தை மீண்டும் படிக்கவும்.

இதைத்தான் ஸ்கிரிப்ட் வெளியிடும்.

ஒரு கோப்புறையின் உள்ளடக்கங்களைக் காட்டுகிறது

லூப்பை எவ்வாறு துவக்குகிறோம் என்பதில் கவனம் செலுத்துங்கள், அதாவது காட்டு அட்டைகோப்புறை முகவரியின் முடிவில் "*". இந்த சின்னத்தை ஒரு வைல்டு கார்டு என்று கருதலாம்: "எந்த பெயர்களுடனும் அனைத்து கோப்புகளும்." இது உங்களை ஒழுங்கமைக்க அனுமதிக்கிறது தானியங்கி மாற்றுவடிவத்துடன் பொருந்தக்கூடிய கோப்பு பெயர்கள்.

if கூற்றில் ஒரு நிபந்தனையை சோதிக்கும் போது, ​​நாம் மாறி பெயரை மேற்கோள்களில் இணைக்கிறோம். கோப்பு அல்லது கோப்புறை பெயரில் இடைவெளிகள் இருக்கலாம் என்பதால் இது செய்யப்படுகிறது.

சுழல்களுக்கான சி-பாணி

நீங்கள் C நிரலாக்க மொழியை நன்கு அறிந்திருந்தால், லூப்களுக்கான பாஷை விவரிப்பதற்கான தொடரியல் உங்களுக்கு விசித்திரமாகத் தோன்றலாம், ஏனெனில் நீங்கள் வெளிப்படையாக இவ்வாறு லூப்களை விவரிக்கப் பழகிவிட்டீர்கள்:

(i = 0; i< 10; i++) { printf("number is %d\n", i); }
பாஷ் ஸ்கிரிப்ட்களில் நீங்கள் சுழல்களுக்குப் பயன்படுத்தலாம், சில வேறுபாடுகள் இருந்தாலும், சி-ஸ்டைல் ​​லூப்களின் விளக்கம் மிகவும் ஒத்திருக்கிறது. இந்த அணுகுமுறையுடன் சுழற்சி வரைபடம் இதுபோல் தெரிகிறது:

((மாறியின் ஆரம்ப மதிப்பு; லூப்பை முடிப்பதற்கான நிபந்தனை; மாறியின் மாற்றம்))
பாஷில் இதை இப்படி எழுதலாம்:

((a = 1; a< 10; a++))
இங்கே ஒரு வேலை உதாரணம்:

#!/பின்/பாஷ் ((i=1; i<= 10; i++)) do echo "number is $i" done
இந்த குறியீடு 1 முதல் 10 வரையிலான எண்களின் பட்டியலை வெளியிடும்.

சி ஸ்டைலில் லூப்பிங்

லூப் போது

பாஷ் ஸ்கிரிப்ட்களில் லூப்களை ஒழுங்கமைப்பதற்கான ஒரே வழி ஃபார் கன்ஸ்ட்ரக்ட் அல்ல. இங்கே லூப்களை நீங்கள் பயன்படுத்தலாம். அத்தகைய சுழற்சியில், ஒரு குறிப்பிட்ட நிலையைச் சரிபார்ப்பதற்கும், சோதனை செய்யப்பட்ட நிபந்தனை பூஜ்ஜியத்தைத் தரும் வரை அல்லது ஒரு குறிப்பிட்ட செயல்பாட்டை வெற்றிகரமாக முடிப்பதற்கான சமிக்ஞையை வழங்கும் வரை லூப்பின் உடலை இயக்குவதற்கும் ஒரு கட்டளையை நீங்கள் குறிப்பிடலாம். லூப் நிலை பூஜ்ஜியம் அல்லாத மதிப்பை வழங்கும் போது, ​​அதாவது பிழை என்று அர்த்தம், லூப் நிறுத்தப்படும்.

இதோ while லூப்களின் அமைப்பின் வரைபடம்
போது நிபந்தனை சரிபார்க்க கட்டளை
செய்
மற்ற அணிகள்
முடிந்தது

இது போன்ற லூப் கொண்ட உதாரண ஸ்கிரிப்டைப் பார்ப்போம்:

#!/bin/bash var1=5 போது [ $var1 -gt 0 ] எக்கோ $var1 var1=$[ $var1 - 1 ] முடிந்தது
லூப்பின் நுழைவாயிலில், $var1 மாறி பூஜ்ஜியத்தை விட அதிகமாக உள்ளதா என சரிபார்க்கப்படுகிறது. அப்படியானால், லூப்பின் உடல் செயல்படுத்தப்படுகிறது, இதில் ஒன்று மாறியின் மதிப்பிலிருந்து கழிக்கப்படுகிறது. இது ஒவ்வொரு மறு செய்கையிலும் நிகழ்கிறது, மேலும் அதன் மதிப்பை மாற்றியமைக்கும் முன் கன்சோலில் அச்சிடுவோம். $var1 மதிப்பு 0 ஐ அடைந்தவுடன், லூப் நின்றுவிடும்.

நேர சுழற்சியின் முடிவு

நீங்கள் $var1 மாறியை மாற்றவில்லை என்றால், இது ஸ்கிரிப்ட் ஒரு முடிவிலா சுழற்சியில் முடிவடையும்.

உள்ளமைக்கப்பட்ட சுழல்கள்

பிற சுழல்களைத் தொடங்குவது உட்பட, லூப்பின் உடலில் உள்ள எந்த கட்டளைகளையும் நீங்கள் பயன்படுத்தலாம். இத்தகைய கட்டுமானங்கள் உள்ளமை சுழல்கள் என்று அழைக்கப்படுகின்றன:

#!/பின்/பாஷ் ((a = 1; a<= 3; a++)) do echo "Start $a:" for ((b = 1; b <= 3; b++)) do echo " Inner loop: $b" done done
இந்த ஸ்கிரிப்ட் என்ன அவுட்புட் செய்யும் என்பதை கீழே காணலாம். நீங்கள் பார்க்க முடியும் என, முதலில் வெளிப்புற சுழற்சியின் முதல் மறு செய்கை செயல்படுத்தப்படுகிறது, பின்னர் உள் ஒன்றின் மூன்று மறு செய்கைகள், அது முடிந்த பிறகு வெளிப்புற வளையம் மீண்டும் செயல்பாட்டுக்கு வருகிறது, பின்னர் உள் ஒன்று.

உள்ளமைக்கப்பட்ட சுழல்கள்

கோப்பு உள்ளடக்கங்களை செயலாக்குகிறது

பெரும்பாலும், உள்ளமைக்கப்பட்ட சுழல்கள் கோப்புகளைச் செயலாக்கப் பயன்படுத்தப்படுகின்றன. எனவே, வெளிப்புற வளையம் கோப்பின் வரிகளுக்கு மேல் திரும்புகிறது, மேலும் உள் ஒன்று ஏற்கனவே ஒவ்வொரு வரியிலும் வேலை செய்கிறது. இங்கே, எடுத்துக்காட்டாக, /etc/passwd கோப்பை செயலாக்குவது எப்படி இருக்கும்:

$(cat /etc/passwd) இல் நுழைவதற்கு #!/bin/bash IFS=$"\n", "$entry இல் உள்ள மதிப்புகள் –" IFS=: $entry இல் உள்ள மதிப்புக்கு எதிரொலி "$value" செய்ய வேண்டும் முடிந்தது
இந்த ஸ்கிரிப்ட்டில் இரண்டு சுழல்கள் உள்ளன. முதலாவது புதிய வரி எழுத்தை ஒரு பிரிப்பானாகப் பயன்படுத்தி கோடுகளைக் கடக்கிறது. அகமானது, புலங்கள் பெருங்குடல்களால் பிரிக்கப்பட்ட சரங்களை அலசுவதில் மும்முரமாக உள்ளது.

கோப்பு தரவு செயலாக்கம்

தேவைக்கேற்ப IFS சூழல் மாறியில் டிலிமிட்டர் எழுத்தை எழுதுவதன் மூலம், CSV கோப்புகள் அல்லது ஏதேனும் ஒத்த கோப்புகளைச் செயலாக்கும்போது இந்த அணுகுமுறையைப் பயன்படுத்தலாம்.

சுழற்சி மேலாண்மை

ஒருவேளை, லூப்பில் நுழைந்த பிறகு, லூப் மாறி ஒரு குறிப்பிட்ட மதிப்பை அடையும் போது நீங்கள் அதை நிறுத்த வேண்டும், இது லூப்பை முடிப்பதற்கான ஆரம்பத்தில் குறிப்பிடப்பட்ட நிபந்தனைக்கு பொருந்தாது. அத்தகைய சூழ்நிலையில், சுழற்சியின் இயல்பான நிறைவுக்காக காத்திருக்க வேண்டியது அவசியமா? நிச்சயமாக இல்லை, அத்தகைய சந்தர்ப்பங்களில் பின்வரும் இரண்டு கட்டளைகள் கைக்குள் வரும்:

• உடைக்க
• தொடரவும்

உடைக்க கட்டளை

இந்த கட்டளை ஒரு லூப்பின் செயல்பாட்டை குறுக்கிட உங்களை அனுமதிக்கிறது. இது சுழல்கள் மற்றும் போது ஆகிய இரண்டிற்கும் பயன்படுத்தப்படலாம்:

1 2 3 4 5 6 7 8 9 10 இல் var1 க்கு #!/bin/bash [$var1 -eq 5 ] எனில் ஃபை எக்கோ "எண்: $var1" ஐ உடைத்து
அத்தகைய வளையம், சாதாரண நிலைமைகளின் கீழ், பட்டியலிலிருந்து மதிப்புகளின் முழு பட்டியலையும் கடந்து செல்லும். எவ்வாறாயினும், எங்கள் விஷயத்தில், $var1 மாறி 5 க்கு சமமாக இருக்கும்போது அதன் செயலாக்கம் குறுக்கிடப்படும்.

ஒரு ஃபார் லூப் சீக்கிரம் வெளியேறுகிறது

இங்கே அதே விஷயம், ஆனால் அதே நேரத்தில் வளையத்திற்கு:

#!/bin/bash var1=1 போது [ $var1 -lt 10 ] செய்தால் [$var1 -eq 5 ] பின் fi எதிரொலியை உடைத்து "Iteration: $var1" var1=$(($var1 + 1)) முடிந்தது
$var1 5ஐ அடையும் போது செயல்படுத்தப்படும் பிரேக் கட்டளை, லூப்பை உடைக்கிறது. கன்சோல் முந்தைய எடுத்துக்காட்டில் உள்ளதைப் போலவே காண்பிக்கும்.

கட்டளையைத் தொடரவும்

இந்த கட்டளையை லூப்பின் உடலில் சந்திக்கும் போது, ​​தற்போதைய மறு செய்கை முன்கூட்டியே முடிவடைகிறது மற்றும் அடுத்தது லூப்பில் இருந்து வெளியேறாமல் தொடங்குகிறது. லூப்பில் தொடரும் கட்டளையைப் பார்ப்போம்:

#!/பின்/பாஷ் ((var1 = 1; var1< 15; var1++)) do if [ $var1 -gt 5 ] && [ $var1 -lt 10 ] then continue fi echo "Iteration number: $var1" done
லூப்பில் உள்ள நிபந்தனை திருப்தி அடையும் போது, ​​அதாவது $var1 5ஐ விட அதிகமாகவும் 10ஐ விட குறைவாகவும் இருக்கும் போது, ​​ஷெல் தொடரும் கட்டளையை செயல்படுத்துகிறது. இது லூப்பின் உடலில் மீதமுள்ள கட்டளைகளைத் தவிர்த்துவிட்டு அடுத்த மறு செய்கைக்குச் செல்லும்.

லூப்பில் தொடரும் கட்டளை

ஒரு சுழற்சியில் இயங்கும் வெளியீட்டை செயலாக்குகிறது

ஒரு சுழற்சியில் இருந்து தரவு வெளியீடு வெளியீட்டை திசைதிருப்புவதன் மூலம் அல்லது அதை ஒரு குழாய்க்கு அனுப்புவதன் மூலம் செயலாக்கப்படும். முடிந்த அறிக்கைக்குப் பிறகு வெளியீட்டு செயலாக்க கட்டளைகளைச் சேர்ப்பதன் மூலம் இது செய்யப்படுகிறது.

எடுத்துக்காட்டாக, ஒரு லூப்பில் என்ன வெளியீடு இருக்கிறது என்பதைத் திரையில் காட்டுவதற்குப் பதிலாக, நீங்கள் அனைத்தையும் ஒரு கோப்பில் எழுதலாம் அல்லது வேறு எங்காவது அனுப்பலாம்:

#!/பின்/பாஷ் ((a = 1; a< 10; a++)) do echo "Number is $a" done >myfile.txt எதிரொலி "முடிந்தது."
ஷெல் myfile.txt கோப்பை உருவாக்கி, அறிக்கைக்கான வெளியீட்டை அந்தக் கோப்பிற்கு திருப்பிவிடும். கோப்பைத் திறந்து, அதில் நாம் எதிர்பார்ப்பது சரியாக உள்ளதா என்பதை உறுதி செய்வோம்.

லூப் வெளியீட்டை கோப்பிற்கு திருப்பி விடவும்

எடுத்துக்காட்டு: இயங்கக்கூடிய கோப்புகளைத் தேடுங்கள்

நாம் ஏற்கனவே உள்ளடக்கியதைப் பயன்படுத்தி பயனுள்ள ஒன்றை எழுதுவோம். எடுத்துக்காட்டாக, கணினியில் எந்த இயங்கக்கூடிய கோப்புகள் உள்ளன என்பதை நீங்கள் கண்டுபிடிக்க வேண்டும் என்றால், PATH சூழல் மாறியில் பதிவுசெய்யப்பட்ட அனைத்து கோப்புறைகளையும் ஸ்கேன் செய்யலாம். இதற்குத் தேவையான கருவிகளின் முழு ஆயுதக் களஞ்சியமும் எங்களிடம் ஏற்கனவே உள்ளது, எல்லாவற்றையும் ஒன்றாக இணைக்க வேண்டும்:

#!/bin/bash IFS=: $PATH இல் உள்ள கோப்புறைக்கு "$folder:" என்பதை $folder/* இல் உள்ள கோப்புக்கு எதிரொலிக்கவும்.
இந்த ஸ்கிரிப்ட், சிறிய மற்றும் எளிமையானது, PATH இலிருந்து கோப்புறைகளில் சேமிக்கப்பட்ட இயங்கக்கூடிய கோப்புகளின் பட்டியலைப் பெற எங்களுக்கு அனுமதித்தது.

PATH மாறியிலிருந்து கோப்புறைகளில் இயங்கக்கூடிய கோப்புகளைத் தேடுகிறது

முடிவுகள்

இன்று நாம் பாஷ் ஸ்கிரிப்ட்களில் உள்ள லூப்கள், அவற்றை எவ்வாறு இயக்குவது மற்றும் அவற்றை எவ்வாறு நிர்வகிப்பது என்பதைப் பற்றி பேசினோம். சுழல்களில் வெவ்வேறு டிலிமிட்டர்களுடன் சரங்களை எவ்வாறு செயலாக்குவது என்பது இப்போது உங்களுக்குத் தெரியும், சுழல்களில் தரவு வெளியீட்டை கோப்புகளுக்கு எவ்வாறு திருப்பிவிடுவது, கோப்பகங்களின் உள்ளடக்கங்களை எவ்வாறு பார்ப்பது மற்றும் பகுப்பாய்வு செய்வது என்பது உங்களுக்குத் தெரியும்.

நீங்கள் பாஷ் ஸ்கிரிப்ட்களை உருவாக்குபவர் என்று நாங்கள் கருதினால், இந்த கட்டுரைத் தொடரின் முதல் பகுதியிலும், இந்த இரண்டாவது பகுதியிலும், நீங்கள் ஏற்கனவே பயனுள்ள ஒன்றை எழுதலாம். முன்னோக்கி மூன்றாவது பகுதி, இதைப் புரிந்துகொண்ட பிறகு, பாஷ் ஸ்கிரிப்ட்களுக்கு அளவுருக்கள் மற்றும் கட்டளை வரி சுவிட்சுகளை எவ்வாறு அனுப்புவது மற்றும் அனைத்தையும் என்ன செய்வது என்பதை நீங்கள் கற்றுக் கொள்வீர்கள்.

லூப் வகைகளில் உள்ள வேறுபாட்டின் சுருக்கமான விளக்கம்:

க்கு - செயல்படுத்த பொருள்கள் இருக்கும் வரை ஒரு செயலைச் செய்யும் (உதாரணமாக, stdin, ஒரு கோப்பு அல்லது செயல்பாடு ஆகியவற்றிலிருந்து ஸ்ட்ரீமைப் படித்தல்);
அதே நேரத்தில் - வரை செயலைச் செய்கிறது நிலைஉண்மைதான்;
வரை - வரை செயல்படுத்தப்படும் நிலைஉண்மை ஆகாது, அதாவது. இப்போதைக்கு அது பொய் .

லூப்பிற்கு

ஸ்கிரிப்ட்டின் இந்த பதிப்பை ஒரு வளையத்துடன் பரிசீலிப்போம்:

`ls -1` இல் மாறிக்கான $ cat loop.sh #!/bin/bash செய்ய எக்கோ "$variable" முடிந்தது

தொடரியல் மிகவும் எளிமையானது மற்றும் எடுத்துக்காட்டில் தெளிவாகக் காட்டப்பட்டுள்ளது:

(லூப்பைத் தொடங்கு) மாறி (நாம் செயல்களைச் செய்யும் ஒரு மாறியை அறிவிக்கவும்) இல் (லூப்பிற்கு ஒரு ஓட்டத்தை அனுப்பவும்) `ls -1` (இயக்க வேண்டிய கட்டளை மற்றும் $ மாறி மாறிக்கு அனுப்பப்படும்). டூ அண்ட் டூன் என்பது லூப்பின் "உடல்" ஆகும், இதில் முக்கிய செயல்கள் பெறப்பட்ட தரவுகளில் செய்யப்படும், மேலும் எதிரொலி "$ மாறி" என்பது வளையத்தால் செய்யப்படும் உண்மையான செயலாகும்.

இப்போது உதாரணத்தை சிறிது மாற்றுவோம், கட்டளையை வெளிப்படையாகக் குறிப்பிடுவதற்குப் பதிலாக, இரண்டாவது மாறியைப் பயன்படுத்துவோம்:

$ls இல் மாறிக்கான $ cat loop.sh #!/bin/bash ls=`ls -1` எக்கோ "$variable" முடிந்தது

இப்போது ls -1 கட்டளை ஒரு தனி மாறியில் அனுப்பப்படுகிறது, இது வளையத்துடன் மிகவும் நெகிழ்வாக வேலை செய்ய உங்களை அனுமதிக்கிறது. ஒரு சுழற்சியில் மாறிக்கு பதிலாக, நீங்கள் ஒரு செயல்பாட்டையும் பயன்படுத்தலாம்:

$ cat loop.sh #!/bin/bash lsl () ( ls -1 ) இல் `lsl` இல் உள்ள மாறிக்கு எதிரொலி "$variable" முடிந்தது

ஃபார் லூப்பின் முக்கிய நிபந்தனை என்னவென்றால், அதற்கு அனுப்பப்பட்ட கட்டளை செயலுக்கான பொருட்களைக் கொண்டிருக்கும் வரை அது செயல்படுத்தப்படும். மேலே உள்ள எடுத்துக்காட்டின் அடிப்படையில் - ls -1 கோப்புகளைக் காண்பிக்கும் வரை - லூப் அவற்றை ஒரு மாறிக்கு அனுப்பி "லூப் பாடி" ஐ இயக்கும். கோப்பகத்தில் உள்ள கோப்புகளின் பட்டியல் முடிந்தவுடன், லூப் அதன் செயல்பாட்டை நிறைவு செய்யும்.

உதாரணத்தை இன்னும் கொஞ்சம் சிக்கலாக்குவோம்.

கோப்பகத்தில் கோப்புகளின் பட்டியல் உள்ளது:

$ ls -1 file1 file2 file3 file4 file5 loop.sh nofile1 nofile2 nofile3 nofile4 nofile5

அவற்றிலிருந்து " என்ற வார்த்தை இல்லாதவற்றை மட்டும் தேர்ந்தெடுக்க வேண்டும். இல்லை«:

$lsl இல் மாறிக்கான $ cat loop.sh #!/bin/bash lsl=`ls -1` எக்கோ "$variable" | grep -v "இல்லை" $./loop.sh கோப்பு1 கோப்பு2 கோப்பு3 கோப்பு4 கோப்பு5 loop.sh முடிந்தது

நீங்கள் ஒரு வளையத்தில் நிபந்தனை வெளிப்பாடுகளையும் பயன்படுத்தலாம் ( நிபந்தனை வெளிப்பாடுகள்) […] நிபந்தனைகளை சரிபார்க்க மற்றும் நிபந்தனை தூண்டப்பட்டால் லூப்பை குறுக்கிட பிரேக் ஸ்டேட்மெண்ட்.

இந்த உதாரணத்தைக் கவனியுங்கள்:

$lsl இல் மாறிக்கு $ cat loop.sh #!/bin/bash lsl=`ls -1` என்றால் [ $variable != "loop.sh" ] பிறகு "$variable" ஐ எதிரொலிக்கவும் | grep -v "இல்லை" வேறு பிரேக் ஃபை முடிந்தது

loop.sh கோப்பு வரும் வரை லூப் தொடரும். லூப்பின் செயல்படுத்தல் இந்த கோப்பை அடைந்தவுடன், இடைவெளி கட்டளையால் லூப் குறுக்கிடப்படும்:

$ ./loop.sh கோப்பு1 கோப்பு2 கோப்பு3 கோப்பு4 கோப்பு5

மற்றொரு உதாரணம், லூப்பின் உடலை இயக்குவதற்கு முன் உடனடியாக எண்கணித செயல்பாடுகளைப் பயன்படுத்துவது:

$ cat loop.sh #!/bin/bash க்கான ((எண்ணிக்கை=1; எண்ணிக்கை<11; count++)) do echo "$count" done

இங்கே நாம் மூன்று கட்டுப்பாட்டு கட்டளைகளை அமைக்கிறோம் - எண்ணிக்கை = 1, ஒரு கட்டுப்படுத்தும் நிலை - எண்ணிக்கை 11 க்கும் குறைவாக இருக்கும் போது, ​​மற்றும் செயல்படுத்த ஒரு கட்டளை - எண்ணு +1:

WHILE மற்றும் untIL சுழல்கள்

லூப் எவ்வாறு செயல்படுகிறது என்பதை தெளிவாக விளக்கும் எளிய எடுத்துக்காட்டு:

$ cat loop.sh #!/bin/bash count=0 [ $count -lt 10 ] செய்ய ((count++)) எதிரொலி $count முடிந்தது

$count மாறியை பூஜ்ஜியமாக அமைத்து, பின்னர் “$count பத்துக்கும் குறைவாக இருக்கும் போது, ​​loopஐ இயக்கவும்” என்ற நிபந்தனையுடன் whi le loopஐ இயக்குவோம். சுழற்சியின் உடலில் நாம் செயல்படுத்துகிறோம் postfix அதிகரிப்பு$count மாறிக்கு +1 மற்றும் முடிவு stdout க்கு அச்சிடப்படும்.

செயல்படுத்தல் முடிவு:

$ ./loop.sh 1 2 3 4 5 6 7 8 9 10

$count மாறியின் மதிப்பு 10 ஆனதும், லூப் நின்றுவிட்டது.

"எல்லையற்ற" வளையத்தின் ஒரு சிறந்த உதாரணம், அது எப்படி வேலை செய்யும் என்பதை விளக்குகிறது:

$ cat loop.sh #!/bin/bash count=10 while [ 1 = 1 ] do ((count++)) echo $count done $ ./loop.sh ... 5378 5379 5380 5381 5382 5383 ^C

வரை வளையம் இதேபோல் செயல்படுகிறது, ஆனால் எதிர் திசையில்:

$ cat loop.sh #!/bin/bash count=0 வரை [ $count -gt 10 ] செய்ய ((count++)) எதிரொலி $count முடிந்தது

இங்கே நாம் இதேபோன்ற நிபந்தனையை அமைக்கிறோம், ஆனால் "மாறி 10 க்கும் குறைவாக இருக்கும்போது" என்பதற்கு பதிலாக "மாறி 10 ஐ விட அதிகமாகும் வரை" குறிப்பிடுகிறோம். செயல்படுத்தல் முடிவு:

$ ./loop.sh 1 2 3 4 5 6 7 8 9 10 11

"முடிவற்ற வளையத்தின்" மேலே உள்ள உதாரணம் வரை பயன்படுத்தி செயல்படுத்தப்பட்டால், அது எதையும் வெளியிடாது, போது போலல்லாமல்:

$ cat loop.sh #!/bin/bash count=10 வரை [1 = 1 ] செய்ய ((count++)) எதிரொலி $count ஆனது $ ./loop.sh $

ஏனெனில் " நிலை"முதலில்" உண்மை"-லூப்பின் உடல் செயல்படுத்தப்படாது.

ஃபார் லூப்பில் உள்ளதைப் போலவே, நீங்கள் எப்போது மற்றும் வரை செயல்பாடுகளைப் பயன்படுத்தலாம். எடுத்துக்காட்டாக, சேவையக நிலையைச் சரிபார்க்கும் நிஜ வாழ்க்கை ஸ்கிரிப்ட்டின் லூப் டாம்கேட்(PID அமைப்பிலிருந்து எடுக்கப்பட்டது SLES, பிற அமைப்புகளில் வேறுபடலாம்), சற்று எளிமைப்படுத்தப்பட்ட பதிப்பு:

$ cat loop.sh #!/bin/bash check_tomcat_status () ( RUN=`ps aux | grep tomcat | grep -v grep | grep java | awk "(அச்சிடு $2)"` ) போது_tomcat_status சரிபார்க்கும் போது [ -n "$ ரன்" ] பின்னர் அச்சிடுதல் "எச்சரிக்கை: டாம்கேட் இன்னும் PID $RUN உடன் இயங்குகிறது." வேறு printf "Tomcat நிறுத்தப்பட்டது, தொடர்கிறது...nn" இடைவேளை fi செய்யப்பட்டது

செயல்படுத்தல் முடிவு:

டாலர் இன்னும் PID 14435 26548 உடன் இயங்குகிறது. எச்சரிக்கை: Tomcat இன்னும் PID 14435 26548 உடன் இயங்குகிறது. எச்சரிக்கை: Tomcat இன்னும் PID 14435 26548 உடன் இயங்குகிறது. எச்சரிக்கை: Tomcat இன்னும் PID 14435 உடன் இயங்குகிறது.

முழு பதிப்பு:

Check_tomcat_status () ( RUN=`ps aux | grep tomcat | grep -v grep | grep java | awk "(அச்சிடு $2)"` ) போது check_tomcat_status; செய் என்றால் [ -n "$RUN" ] பின்னர் printf "எச்சரிக்கை: டாம்கேட் இன்னும் PID $RUN உடன் இயங்குகிறது. அதை நிறுத்து? " பதில் "Tomcat ஐ நிறுத்துகிறது..." "நிறுவலை தொடர்கிறது..." && $CATALINA_HOME/bin/shutdown . sh 2&>1 /dev/null || ப்ரேக் ஸ்லீப் 2 என்றால் [ -n "$RUN" ] பிறகு printf "டாம்கேட் இன்னும் இயங்குகிறது. அதைக் கொல்லவா? " பதில் "டாம்கேட்டைக் கொல்கிறது..." "நிறுவலைத் தொடர்கிறது...n" && $RUN ஐக் கொல்லுங்கள் || இடைவேளை தூக்கம் 2 fi else printf "Tomcat நிறுத்தப்பட்டது, தொடர்கிறது...nn" இடைவேளை fi முடிந்தது

பதில் செயல்பாடு கட்டுரையில் விவரிக்கப்பட்டுள்ளது, ஆனால் இங்கே சற்று மேம்படுத்தப்பட்ட பதிப்பு பயன்படுத்தப்படுகிறது:

பதில் () (பதிலைப் படிக்கும்போது; எக்கோ கேஸ் $response in |) printf "$1n" ரிட்டர்ன் 0 பிரேக் ;; |) printf "$2n" திரும்ப 1 இடைவெளி ;; *) printf "தயவுசெய்து, Y(yes) அல்லது N(no) ஐ உள்ளிடவும்! " esac done )

இங்கே போது மற்றும் வரை இரண்டையும் பயன்படுத்த முடியும் - ஆனால் ஒரு லூப் அல்ல, ஏனெனில் for ஒரு முறை வேலை செய்திருக்கும் (PID ஐப் பெற்று முடிந்தது).

எந்த புரோகிராம்கள் அல்லது ஸ்கிரிப்ட்களை எழுதும்போது சுழல்கள் மிகவும் வசதியான விஷயம், மாறாக அவசியமானவை. ஒரு குறிப்பிட்ட பிரிவின் குறியீட்டை குறிப்பிட்ட எண்ணிக்கையிலான முறை இயக்க அவை நம்மை அனுமதிக்கின்றன. இயற்கையாகவே, பாஷ் பல வகையான சுழல்களைக் கொண்டுள்ளது. சுழற்சிகளை விவரிப்போம் இன், க்கான, போது, ​​வரை. இன் மற்றும் ஃபார் என்பது ஒரே அறிக்கையின் வெவ்வேறு தொடரியல்களாகக் கருதப்பட்டாலும், என் கருத்துப்படி அவை ஒன்றுக்கொன்று வேறுபடுகின்றன.

உள்ளுக்கான கவுண்டருடன் லூப்:

மிதிவண்டி உள்ளேஇது கவுண்டருடன் கூடிய வளையமாகும். லூப்பின் உடலில் அமைந்துள்ள குறியீட்டின் தொகுதியானது, for இன் ஆபரேட்டரின் பட்டியலில் உள்ள மதிப்புகள் பல முறை மீண்டும் மீண்டும் செய்யப்படுகிறது, மேலும் ஒவ்வொரு மறுமுறையிலும், எதிர் மாறி (இங்கே இது var என்று அழைக்கப்படுகிறது, ஆனால் நிச்சயமாக நீங்கள் என்ன வேண்டுமானாலும் அழைக்கலாம்) பட்டியலின் அடுத்த உறுப்பின் மதிப்பைக் கொண்டுள்ளது.
do என்ற சொல் அதே வரியில் இருந்தால், வாதங்களின் பட்டியலுக்குப் பிறகு (செய்யும் முன்) நீங்கள் ஒரு அரைப்புள்ளியை வைக்க வேண்டும்.
உறுப்புகள் ஒவ்வொன்றும்<список>பல வாதங்களைக் கொண்டிருக்கலாம். அளவுருக்களின் குழுக்களை செயலாக்கும்போது இது பயனுள்ளதாக இருக்கும். இந்த வழக்கில், ஒவ்வொரு வாதத்தையும் பாகுபடுத்த கட்டாயப்படுத்த<списке>, நீங்கள் செட் வழிமுறையைப் பயன்படுத்த வேண்டும்
லூப்பில் ஒரு மாறியை பட்டியலாகப் பயன்படுத்தலாம்.
IN<списке>ஃபார் லூப் கோப்பு பெயர்களைப் பயன்படுத்தலாம், அதையொட்டி வைல்டு கார்டு எழுத்துகள் இருக்கலாம். அதிக எண்ணிக்கையிலான கோப்புகளுடன் பணிபுரியும் போது இது மிகவும் பயனுள்ளதாக இருக்கும்.
என்றால்<список>for loop இல் குறிப்பிடப்படவில்லை, பின்னர் $@ என்ற மாறி பயன்படுத்தப்படுகிறது - கட்டளை வரி வாதங்களின் பட்டியல்.
வாதங்களின் பட்டியலை உருவாக்கும் போது, ​​லூப்பில் கட்டளை மாற்றீட்டைப் பயன்படுத்தலாம்.
லூப்பின் வெளியீடு stdout இலிருந்து ஒரு கோப்பிற்கு அல்லது வேறு எங்காவது திசைதிருப்பப்படலாம் (I/O திசைதிருப்பலைப் பார்த்து இதைப் பற்றி மேலும் அறியலாம்).

தொடரியல்:
var in க்கான<список>
செய்
<выполняемые команды>
முடிந்தது

உதாரணமாக:
பெயர்1 பெயர்2 பெயர்3 பெயர்4 இல் உள்ள பெயர்களுக்கு
செய்
எதிரொலி $பெயர்கள்
முடிந்தது

லூப் ஆபரேட்டர் க்கானஎழுதும் மற்றொரு வழி உள்ளது - சி மொழியில் ஆபரேட்டருக்கான தொடரியல் போன்றது. இந்த வழக்கில், கவுண்டர்களை துவக்கும் போது, ​​மாறிகள் அல்லது ஒரு மாறியின் ஆரம்ப மதிப்புகள் அமைக்கப்பட்டு, லூப்பின் ஒவ்வொரு பாஸ் பிறகும் நிபந்தனை சரிபார்க்கப்பட்டது, காசோலை உண்மையாக இருந்தால், லூப்பின் அடுத்த பாஸ் தொடங்குகிறது. தொகுதியில்<приращение счётчиков>எங்கள் மாறி கவுண்டர்களின் மதிப்பு அவசியம் மாற வேண்டும் (அவசியம் மேல்நோக்கி இல்லை) அதனால் நிலையை சரிபார்க்கும் போது, ​​விரைவில் அல்லது பின்னர் தவறான மதிப்பைப் பெறுவோம், இல்லையெனில் லூப் முடிவடையாது. எந்தவொரு செயலையும் குறிப்பிட்ட எண்ணிக்கையில் மீண்டும் செய்ய வேண்டியிருந்தால் மிகவும் வசதியான மற்றும் மிக முக்கியமாக நன்கு தெரிந்த விருப்பம்.

இதே போன்ற தொடரியல் மூலம்:
((<инициализация счётчиков>; <проверка условия>; <приращение счётчиков>))
செய்
<выполняемые команды>
முடிந்தது

உதாரணமாக:
((var=1; var<= LIMIT ; var++))
செய்
எதிரொலி $var
முடிந்தது

போது வளையம்:

இது மிகவும் எளிமையான கட்டுமானமாகும், இது ஆபரேட்டரின் பின்னால் உள்ள நிலையை சரிபார்க்கிறது போதுஇந்த நிபந்தனை உண்மையாக இருந்தால், do and done என்ற வார்த்தைகளுக்கு இடையே உள்ள கட்டளைகளின் தொகுதியை இயக்கி, மீண்டும் நிபந்தனையை சரிபார்க்கும். காசோலை தவறானதாக இருந்தால், சுழற்சி முடிவடைகிறது மற்றும் பின்வரும் கட்டளைகள் செயல்படுத்தப்படும்: முடிந்தது. என்பதை உறுதி செய்ய வேண்டியது அவசியம்<проверка условия>லூப்பில் இயங்கும் குறியீட்டைச் சார்ந்தது; இல்லையெனில், காசோலையின் முடிவு மாறவில்லை என்றால், நீங்கள் ஒரு எல்லையற்ற வளையத்தைப் பெறுவீர்கள்.
சிறிது நேர சுழற்சிக்கான நிலையான உள்ளீட்டு சாதனத்தை திசைதிருப்பல் கட்டளையைப் பயன்படுத்தி ஒரு கோப்பிற்கு திருப்பி விடலாம்< в конце цикла.

தொடரியல்:
போது<Проверка условия>
செய்
<Блок команд, обязательно меняющий переменные влияющие на проверку условия>
முடிந்தது

உதாரணமாக:
அதே நேரத்தில் [ $var0 -eq 100 ]
செய்
எதிரொலி $var
var++
முடிந்தது

ஆபரேட்டர் போதுபல நிபந்தனைகள் இருக்கலாம். ஆனால் அவர்களில் கடைசி மட்டுமே சுழற்சியைத் தொடரும் சாத்தியத்தை தீர்மானிக்கிறது. இந்த வழக்கில், லூப் ஆபரேட்டரின் தொடரியல் வழக்கமான ஒன்றிலிருந்து வேறுபட்டதாக இருக்கும்.
தொடரியல்(கடைசி நிபந்தனை மட்டுமே லூப்பின் செயல்பாட்டை பாதிக்கிறது என்பதை மீண்டும் மீண்டும் சொல்கிறேன்) :
போது
<условие1>
<условие2>

<условиеN>
செய்
<выполняемые команды - тело цикла>
முடிந்தது

லூப் வரை:

ஆபரேட்டர் வரைஅதே சமயம், இது நிலைமையை மதிப்பிடுகிறது, ஆனால் கணக்கீட்டின் முடிவு தவறானதாக இருந்தால், லூப்பின் உடலை இயக்குகிறது. இது வழக்கத்திற்கு மாறானதாகத் தோன்றலாம், ஆனால் லூப்பின் முதல் பாஸுக்கு முன் நிலையை மதிப்பிடும் வரை, அதே சமயம், அதற்குப் பிறகு அல்ல. லூப்களுக்கு/இன் லூப்களைப் போலவே, லூப் அறிவிப்பின் அதே வரியில் do முக்கிய சொல்லை வைக்கும்போது, ​​நீங்கள் ";" எழுத்தை செருக வேண்டும். செய்வதற்கு முன்.
முந்தைய வழக்கைப் போலவே, லூப் உடலில் உள்ள செயல்பாடுகளைப் பொறுத்து நிபந்தனை இருக்க வேண்டும் என்பதை நினைவில் கொள்வது அவசியம், இல்லையெனில் எங்கள் ஸ்கிரிப்ட் ஒருபோதும் முடிவடையாது.

தொடரியல்:
வரை<Проверка условия>
செய்
<Блок команд, обязательно меняющий переменные влияющие на проверку условия>
முடிந்தது

உதாரணமாக:
[ $var0 -gt 100] வரை # மறு செய்கையின் தொடக்கத்தில் நிபந்தனை சரிபார்க்கப்பட்டது.
செய்
எதிரொலி $var
var--
முடிந்தது

இப்போதைக்கு அதுவே போதுமானது. :)

• மீண்டும்
• முன்னோக்கி

புதிய கட்டுரைகள்:

• விண்டோஸ் 7/8/2008/2012 இல் நெட்வொர்க் கண்டுபிடிப்பு இயக்கப்படவில்லை
• பிழை: Qt இயங்குதளம் செருகுநிரலான "windows"ஐக் கண்டறியவோ ஏற்றவோ முடியாததால் இந்தப் பயன்பாடு தொடங்குவதில் தோல்வியடைந்தது.
• 1C 8.3 சேவையகத்தில் rphost.exe பணியாளர் செயல்முறைகளின் தானியங்கி மறுதொடக்கத்தை உள்ளமைத்தல்
• MS SQL 2008/20012 இல் பரிவர்த்தனை பதிவின் (.ldf) அளவை எவ்வாறு குறைப்பது

  MS SQL, எந்தவொரு ஒழுக்கமான தொழில்துறை DBMS ஐப் போலவே, தரவுத்தளத்துடன், பரிவர்த்தனை பதிவுகளை வைத்திருக்கிறது.

0 மீரான் பாலா-குமரன்

இந்த லூப் ஏன் முடிவடையாது என்பதை நான் உண்மையில் புரிந்து கொள்ள முயற்சிக்கிறேன், லூப் தொடங்கும் போது எனது LOC மாறி சோதனைக்கு அமைக்கப்பட்டுள்ளது/ இந்த நிரலை சோதிக்க நான் உருவாக்கிய அடைவு பின்வரும் தளவமைப்பைக் கொண்டுள்ளது:

எல்லா கோப்பகங்களிலும் "கவுண்ட்" செயல்பாடு பயன்படுத்தப்பட்டவுடன் லூப் முடிவடையும் என்று நான் விரும்புகிறேன்.
இதோ நான் முயற்சித்தேன்;

நான் எண்ணிக்கை செயல்பாட்டைச் சரிபார்த்தேன், அது எல்லையற்ற வளையத்தை உருவாக்கவில்லை

அல்காரிதத்தை கைமுறையாக இயக்க முயற்சித்தேன்

PARSE=1 LOC=$LOC/ எண்ணிக்கை AVAILABLEDIR=$(ls $LOC -AFl | sed "1 d" | grep "/$" | awk "( $9 அச்சிட )") போது [ $PARSE = "1" ] செய்தால் [[ $(கிடைக்கக்கூடிய[@]) == "" ]]; பிறகு PARSE=0 fi DIRBASE=$LOC க்கு $(AVAILABLEDIR[@]); LOC="$(DIRBASE)$(a)" LOCLIST="$LOCLIST $LOC" எண்ணிக்கையை $(LOCLIST[@]) இல் செய்ய வேண்டும்; செய்ய TMPAVAILABLEDIR=$(ls $a -AFl | sed "1 d" | grep "/$" | awk "(அச்சு $9 )") PREPEND=$a என்றால் [[ $(TMPAVAILABLEDIR[@]) == "" ] ]; $(TMPAVAILABLEDIR[@]) இல் fi ஐத் தொடரவும்; TMPAVAILABLEDIR2="$TMPAVAILABLEDIR2 $(PREPEND[@])$(a)" செய்தேன் NEWAVAILABLEDIR="$NEWAVAILABLEDIR $TMPAVAILABLEDIR2" செய்தேன்

நான் மிகவும் சிரமப்படுகிறேன், எந்தவொரு உள்ளீடும் பெரிதும் பாராட்டப்படும், கடந்த இரண்டு மணிநேரமாக இதைக் கண்டுபிடிக்க முயற்சிக்கிறேன்.

பாஷ் எல்லையற்ற-லூப்

4 பதில்கள்

-x வாதத்துடன் ஸ்கிரிப்டை இயக்க முயற்சிக்கவும் அல்லது முதல் வரியில் எழுதவும்:

#!/பின்/பாஷ் -x

பின்னர் அவர் செய்யும் அனைத்தையும் உங்களுக்குச் சொல்கிறார்.

இந்த வழக்கில், நீங்கள் இரண்டு பிழைகளை கவனிக்கலாம்:

நீங்கள் ஒருபோதும் TMPAVAILABLEDIR2 ஐ மீண்டும் ஏற்ற மாட்டீர்கள்

நீங்கள் வழக்கமான கோப்புகளிலும் ls செய்கிறீர்கள்.

நீங்கள் உண்மையில் மறுநிகழ்வைத் தவிர்க்க வேண்டும் என்றால், மறுநிகழ்வு இல்லாமல் இதை முயற்சிக்கவும்:

#!/bin/bash count() ( echo counting "$1" ) todo=(சோதனை) சோதனை $(#todo[@]) != 0 do doit=("$(todo[@])") todo= () "$(doit[@])" இல் உள்ள dir க்கு, "$dir"/* # இல் உள்ளிடுவதற்கு, dir காலியாக இருந்தால், இது "*" do test -e "$entry" என்ற ஒரு உள்ளீட்டைக் காட்டுகிறது || தொடரவும் # ஒரு வெற்று இலக்கத்தின் "*" உள்ளீட்டைத் தவிர்க்கவும் "$entry" சோதனை -d "$entry" || தொடருங்கள் todo+=("$entry") முடிந்தது முடிந்தது

இருப்பினும், நீங்கள் மறுநிகழ்வை ஏன் பயன்படுத்த முடியாது என்று சொல்லுங்கள்? இது ஒருவித அலர்ஜியா? சபதம்? நீங்கள் வசிக்கும் இடத்தில் சுழல்நிலை மென்பொருளுக்கு எதிராக ஏதேனும் உள்ளூர் சட்டங்கள் உள்ளதா?

அனைத்து வெட்டுக்களிலும் "கவுண்ட்" செய்ய வேண்டும் என்று எழுதியுள்ளீர்கள். தேடல் விருப்பங்களைப் பார்க்கவும்:

$LOC -வகை d | படிக்கும் போது dir; cd $LOC cd $(dir) எண்ணிக்கை முடிந்தது

அல்லது குறுகியது (உங்கள் செயல்பாட்டு கவுண்டர் கோப்பகத்தை அளவுரு 1 ஆக எடுக்கும்போது)

$LOC -வகை d | xargs எண்ணிக்கை

நீங்கள் கண்டுபிடி அல்லது ls -R (சுழற்சி செயல்பாடு) பயன்படுத்த விரும்பவில்லை என்பதை இப்போது நான் காண்கிறேன். பின்னர் நீங்கள் உங்கள் சொந்த சுழல் செயல்பாடு போன்ற செய்ய வேண்டும்

செயல்பாடு parseDir ( ls -d */ $1 | படிக்கும் போது dir; parseDir $1/$dir ஐ எண்ணுங்கள் )

இது வேலை செய்யுமா என்று எனக்குத் தெரியவில்லை, ஆனால் இது ஒரு சுவாரஸ்யமான கேள்வி, என்னால் யோசிப்பதை நிறுத்த முடியவில்லை. நல்ல அதிர்ஷ்டம்

உண்மையாக இருக்கும்போது; "$(எக்கோ *)" இல் வார்த்தைக்காக செய்; [[ -d "$word" ]] என்றால் செய்யுங்கள்; பின்னர் d[$((i++))]="$PWD"/"$word" elif [[ -f "$word" ]] ;பின் f[$((j++))]="$PWD"/"$ வார்த்தை" ஃபை முடிந்தது [[ $k -gt $i ]] && cd .. cd "$d[$((k++))]" || இடைவேளை முடிந்தது