லினக்ஸில் பேஷ் ஃபார் லூப்ஸ் பற்றி நீங்கள் தெரிந்து கொள்ள வேண்டிய அனைத்தும்

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

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

---

---

பேஷ் ஸ்கிரிப்டுகள் எவ்வாறு வேலை செய்கின்றன

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

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

முதலில், பின்வரும் கோப்பை வசதியான இடத்தில் உருவாக்கவும் (வெறுமனே, ஒரு முனையத்தைத் திறந்து முதலில் விரும்பிய கோப்பகத்திற்கு செல்லவும்):

#!/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') {
...
}
}

சுழல்களில்

பாஷ், foreach — அல்லது இல் -லூப் மிகவும் பொதுவானது. அடிப்படை தொடரியல், வெறுமனே:

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

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

வன் விண்டோஸ் 10 ஐ எப்படி விரைவுபடுத்துவது

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

தற்போதைய கோப்பகத்தில் இதுபோன்ற கோப்புகள் இருந்தால், இந்த ஸ்கிரிப்டிலிருந்து வெளியீடு இருக்கும்:

one.c
two.c
three.c

ஒரு நிலையான கோப்புகளுக்குப் பதிலாக, பட்டியலை ஒரு குளோப் முறை மூலம் பெறலாம் (வைல்ட் கார்டுகள் உட்பட - மற்ற எழுத்துக்களைக் குறிக்கும் சிறப்பு எழுத்துக்கள்). பின்வரும் எடுத்துக்காட்டில், ஃபார் லூப் அனைத்து கோப்புகளிலும் (தற்போதைய கோப்பகத்தில்) அதன் பெயர்கள் '.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

ஆனால் ஒரு குறிப்பிடத்தக்க வேறுபாடு உள்ளது: ஃபார் லூப் செயல்படுத்துகிறது 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'

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

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

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

முடிவுரை

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

பகிர் பகிர் ட்வீட் மின்னஞ்சல் விண்டோஸ் 11 க்கு மேம்படுத்துவது மதிப்புள்ளதா?

விண்டோஸ் மறுவடிவமைப்பு செய்யப்பட்டுள்ளது. ஆனால் விண்டோஸ் 10 இலிருந்து விண்டோஸ் 11 க்கு மாறுவதற்கு இது போதுமானதா?

அடுத்து படிக்கவும் தொடர்புடைய தலைப்புகள்

• நிரலாக்க
• லினக்ஸ்

எழுத்தாளர் பற்றி பாபி ஜாக்(58 கட்டுரைகள் வெளியிடப்பட்டன)

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

பாபி ஜாக் இருந்து மேலும்

எங்கள் செய்திமடலுக்கு குழுசேரவும்

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

குழுசேர இங்கே சொடுக்கவும்