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

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

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

while [ CONDITION ]
do
    code block
done

லூப் தொடரியல் போது உடைந்து விடுவோம்.

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

NUMBER=0

while [[ $NUMBER -le 10 ]]
do
    echo " Welcome ${NUMBER} times "
    (( NUMBER++ ))
done

இது மிகவும் எளிமையான எடுத்துக்காட்டு, அங்கு NUMBER 10 ஐ விட அதிகமாக இல்லாத வரை சுழற்சி இயங்குகிறது மற்றும் எதிரொலி அறிக்கையை அச்சிடுகிறது.

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

# SYNTAX
while read VARIABLE
do
    code
done

லினக்ஸில் குழாய் பதித்தல்

பொதுவாக நாம் வகை போன்றவற்றைப் பயன்படுத்துவோம்.

இதேபோல், இங்கே பூனை கட்டளையைப் பயன்படுத்தி கோப்பின் உள்ளடக்கத்தைப் படித்து சிறிது நேரத்திற்கு குழாய் பதிப்போம். ஆர்ப்பாட்டத்திற்கு, நான்/etc/passwd கோப்பைப் பயன்படுத்துகிறேன், ஆனால் இந்தக் கோப்பைக் குழப்பிக் கொள்வது நல்லதல்ல, எனவே இந்த கோப்பின் காப்பு பிரதியை எடுத்து நீங்கள் விரும்பினால் அதனுடன் விளையாடுங்கள்.

cat /etc/passwd | while read LREAD
do
    echo ${LREAD}
done

மேலே உள்ள குறியீடு சமர்ப்பிக்கப்படும்போது என்ன நடக்கும் என்பதை உடைப்போம்.

• பூனை/etc/passwd கோப்பின் உள்ளடக்கங்களைப் படித்து குழாய் வழியாக உள்ளீடாக அனுப்பும்.
• வாசிப்பு கட்டளை பூனை கட்டளையிலிருந்து உள்ளீடாக அனுப்பப்பட்ட ஒவ்வொரு வரியையும் படித்து LREAD மாறியில் சேமிக்கிறது.
• வாசிப்பு கட்டளை EOL விளக்கும் வரை கோப்பு உள்ளடக்கங்களைப் படிக்கும்.

தலை, வால் போன்ற பிற கட்டளைகளையும் நீங்கள் பயன்படுத்தலாம் மற்றும் லூப் போது அதை குழாய் செய்யலாம்.

head -n 5 /etc/passwd | while read LREAD
do
    echo ${LREAD}
done

லினக்ஸில் உள்ளீட்டு திசைதிருப்பல்

உள்ளீட்டு திசைதிருப்பல் ஆபரேட்டர் (<) ஐப் பயன்படுத்தி கோப்பின் உள்ளடக்கத்தை லூப்பிற்கு திருப்பி விடலாம்.

while read LREAD
do
    echo ${LREAD}
done < /etc/passwd | head -n 5

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

FILENAME="/etc/passwd"

while read LREAD
do
    echo ${LREAD}
done < ${FILENAME}

உங்கள் ஸ்கிரிப்டுக்கு ஒரு வாதமாக கோப்பு பெயர்களையும் அனுப்பலாம்.

while read LREAD
do
    echo ${LREAD}
done < $1 | head -n 5

உள் புலம் பிரிப்பான்

நீங்கள் பல்வேறு வகையான கோப்பு வடிவங்களுடன் (CSV, TXT, JSON) வேலை செய்யலாம் மற்றும் தனிப்பயன் டிலிமிட்டரின் அடிப்படையில் கோப்பின் உள்ளடக்கங்களை பிரிக்க விரும்பலாம். இந்த வழக்கில், கோப்பின் உள்ளடக்கத்தைப் பிரித்து அதை மாறிகளில் சேமிக்க “இன்டர்னல் ஃபீல்ட் பிரிப்பான் (ஐஎஃப்எஸ்)” ஐப் பயன்படுத்தலாம்.

இது எவ்வாறு செயல்படுகிறது என்பதை நிரூபிக்கிறேன். பெருங்குடல் (:) ஐ டிலிமிட்டராகக் கொண்ட/etc/passwd கோப்பைப் பாருங்கள். நீங்கள் இப்போது ஒவ்வொரு வார்த்தையையும் ஒரு வரியிலிருந்து பிரித்து தனி மாறியில் சேமிக்கலாம்.

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

while IFS=":" read A B C D E F G
do
    echo ${A}
    echo ${B}
    echo ${C}
    echo ${D}
    echo ${E}
    echo ${F}
    echo ${G}
done < /etc/passwd

ஸ்கிரீன்ஷாட் அளவைக் கருத்தில் கொண்டு மேலே உள்ள ஸ்கிரீன்ஷாட்டில் ஒரே ஒரு வரியைப் பிரித்தேன்.

லினக்ஸில் வெற்று கோடுகள்

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

while read LREAD
do
    echo ${LREAD}
done < testfile

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

while read LREAD
do
    if [[ ! -z $LREAD ]]
    then
        echo ${LREAD} 
    fi
done < testfile

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

தப்பிக்கும் எழுத்துக்கள்

போன்ற எழுத்துக்களைத் தப்பிக்கவும் , , <குறியீடு

while read LREAD
do
    echo ${LREAD}
done < testfile

வெளியீட்டு தப்பிக்கும் எழுத்துக்கள் அவற்றின் பொருளை இழந்துவிட்டன என்பதை நீங்கள் காணலாம் மற்றும் க்கு பதிலாக n மற்றும் t மட்டுமே அச்சிடப்படுகின்றன மற்றும் . பின்சாய்வு விளக்கத்தைத் தடுக்க நீங்கள் -r ஐப் பயன்படுத்தலாம்.

while read -r LREAD
do
    echo ${LREAD}
done < testfile

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