ലൂപ്പ് ഉപയോഗിച്ച് ബാഷ് സ്ക്രിപ്റ്റിൽ ഫയൽ വായിക്കുന്നതിനുള്ള വ്യത്യസ്ത വഴികൾ


ഒരു സമയത്ത് ലൂപ്പ് ഉപയോഗിച്ച് ബാഷ് സ്ക്രിപ്റ്റുകളിൽ ഫയലുകൾ എങ്ങനെ വായിക്കാം എന്നതിനെക്കുറിച്ചാണ് ഈ ലേഖനം. ഒരു ഫയൽ വായിക്കുന്നത് പ്രോഗ്രാമിംഗിലെ ഒരു സാധാരണ പ്രവർത്തനമാണ്. നിങ്ങൾക്ക് വ്യത്യസ്ത രീതികൾ പരിചയമുണ്ടായിരിക്കണം, ഏത് രീതിയാണ് കൂടുതൽ ഫലപ്രദമാകുന്നത്. ബാഷിൽ, ഒരൊറ്റ ടാസ്uക്ക് പല തരത്തിൽ നേടിയെടുക്കാൻ കഴിയും, എന്നാൽ ടാസ്uക് പൂർത്തിയാക്കുന്നതിന് എല്ലായ്പ്പോഴും ഒരു സമുചിതമായ മാർഗമുണ്ട്, ഞങ്ങൾ അത് പാലിക്കണം.

ലൂപ്പ് ഉപയോഗിച്ച് ഫയൽ ഉള്ളടക്കങ്ങൾ എങ്ങനെ വായിക്കാമെന്ന് കാണുന്നതിന് മുമ്പ്, ലൂപ്പ് എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതിനെക്കുറിച്ചുള്ള ഒരു ദ്രുത പ്രൈമർ. ലൂപ്പ് ഒരു അവസ്ഥയെ വിലയിരുത്തുകയും വ്യവസ്ഥ ശരിയാണെങ്കിൽ നൽകിയിരിക്കുന്ന ഒരു കൂട്ടം കോഡുകളിൽ ആവർത്തിക്കുകയും ചെയ്യുന്നു.

while [ CONDITION ]
do
    code block
done

ലൂപ്പ് വാക്യഘടന സമയത്ത് നമുക്ക് തകർക്കാം.

  • വെയിൽ ലൂപ്പ് ആരംഭിക്കുന്നത് അൽപ്പസമയം കീവേഡിനൊപ്പം ഒരു നിബന്ധനയും വേണം.
  • ഒരു വ്യവസ്ഥ [ ] അല്ലെങ്കിൽ [[ ]] എന്നതിനുള്ളിൽ ഉൾപ്പെടുത്തണം. ലൂപ്പ് എക്uസിക്യൂട്ട് ചെയ്യുന്നതിനായി വ്യവസ്ഥ എല്ലായ്പ്പോഴും ശരിയായി നൽകണം.
  • ചെയ്യുന്നതിനും ചെയ്യുന്നതിനും ഇടയിൽ കോഡിന്റെ യഥാർത്ഥ ബ്ലോക്ക് സ്ഥാപിക്കും.

NUMBER=0

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

ഇത് വളരെ ലളിതമായ ഒരു ഉദാഹരണമാണ്, NUMBER 10-ൽ കൂടാത്തത് വരെ ലൂപ്പ് എക്സിക്യൂട്ട് ചെയ്യുകയും എക്കോ സ്റ്റേറ്റ്മെന്റ് പ്രിന്റ് ചെയ്യുകയും ചെയ്യുന്നു.

അതേസമയം, ഒരു ഫയലിന്റെ ഉള്ളടക്കങ്ങൾ വരി വരിയായി വായിക്കാൻ ഞങ്ങൾ റീഡ് കമാൻഡ് ഉപയോഗിക്കും. അതേസമയം, റീഡ് കമാൻഡുകൾ എങ്ങനെ സംയോജിപ്പിക്കുന്നു എന്നതിന്റെ വാക്യഘടന ചുവടെയുണ്ട്. ഇപ്പോൾ ഫയൽ ഇൻപുട്ടായി കൈമാറാൻ വ്യത്യസ്ത വഴികളുണ്ട്, അവയെല്ലാം നമുക്ക് കാണാം.

# SYNTAX
while read VARIABLE
do
    code
done

ലിനക്സിൽ പൈപ്പിംഗ്

സാധാരണയായി നമ്മൾ സോർട്ട് മുതലായവ ഉപയോഗിക്കും.

അതുപോലെ, ഫയലിന്റെ ഉള്ളടക്കം വായിക്കാനും അത് കുറച്ച് ലൂപ്പിലേക്ക് പൈപ്പ് ചെയ്യാനും ഞങ്ങൾ ഇവിടെ cat കമാൻഡ് ഉപയോഗിക്കും. പ്രകടനത്തിനായി, ഞാൻ /etc/passwd ഫയൽ ഉപയോഗിക്കുന്നു, എന്നാൽ ഈ ഫയലിൽ കുഴപ്പമുണ്ടാക്കുന്നത് ഉചിതമല്ല, അതിനാൽ ഈ ഫയലിന്റെ ഒരു ബാക്കപ്പ് കോപ്പി എടുത്ത് നിങ്ങൾക്ക് വേണമെങ്കിൽ അത് ഉപയോഗിച്ച് പ്ലേ ചെയ്യുക.

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

മുകളിലെ കോഡ് സമർപ്പിക്കുമ്പോൾ എന്ത് സംഭവിക്കുമെന്ന് നമുക്ക് വിശദീകരിക്കാം.

  • cat /etc/passwd ഫയലിന്റെ ഉള്ളടക്കങ്ങൾ വായിച്ച് പൈപ്പിലൂടെ ഇൻപുട്ടായി കൈമാറും.
  • read കമാൻഡ് cat കമാൻഡിൽ നിന്ന് ഇൻപുട്ടായി കടന്നുപോകുന്ന ഓരോ വരിയും വായിക്കുകയും LREAD വേരിയബിളിൽ സംഭരിക്കുകയും ചെയ്യുന്നു.
  • read കമാൻഡ് EOL വ്യാഖ്യാനിക്കുന്നതുവരെ ഫയൽ ഉള്ളടക്കങ്ങൾ വായിക്കും.

ഹെഡ്, ടെയിൽ, പൈപ്പ് ഇറ്റ് ലൂപ്പിലേക്ക് തുടങ്ങിയ മറ്റ് കമാൻഡുകളും നിങ്ങൾക്ക് ഉപയോഗിക്കാം.

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

ലിനക്സിൽ ഇൻപുട്ട് റീഡയറക്ഷൻ

ഇൻപുട്ട് റീഡയറക്ഷൻ ഓപ്പറേറ്റർ (<) ഉപയോഗിച്ച് നമുക്ക് ഫയലിന്റെ ഉള്ളടക്കം while loop-ലേക്ക് റീഡയറക്uട് ചെയ്യാം.

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

നിങ്ങൾക്ക് ഫയലിന്റെ പേര് ഒരു വേരിയബിളിലേക്ക് സംഭരിക്കാനും റീഡയറക്ഷൻ ഓപ്പറേറ്ററിലൂടെ കൈമാറാനും കഴിയും.

FILENAME="/etc/passwd"

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

നിങ്ങളുടെ സ്uക്രിപ്റ്റിലേക്ക് ഒരു ആർഗ്യുമെന്റായി ഫയൽ നാമങ്ങൾ കൈമാറാനും നിങ്ങൾക്ക് കഴിയും.

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

ആന്തരിക ഫീൽഡ് സെപ്പറേറ്റർ

നിങ്ങൾക്ക് വ്യത്യസ്ത തരം ഫയൽ ഫോർമാറ്റുകൾ (CSV, TXT, JSON) ഉപയോഗിച്ച് പ്രവർത്തിക്കാം കൂടാതെ ഒരു ഇഷ്uടാനുസൃത ഡിലിമിറ്ററിനെ അടിസ്ഥാനമാക്കി ഫയലിന്റെ ഉള്ളടക്കങ്ങൾ വിഭജിക്കാൻ നിങ്ങൾ ആഗ്രഹിച്ചേക്കാം. ഈ സാഹചര്യത്തിൽ, ഫയലിന്റെ ഉള്ളടക്കം വിഭജിച്ച് വേരിയബിളുകളിൽ സംഭരിക്കാൻ നിങ്ങൾക്ക് \ഇന്റേണൽ ഫീൽഡ് സെപ്പറേറ്റർ (IFS) ഉപയോഗിക്കാം.

ഇത് എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് ഞാൻ കാണിച്ചുതരാം. ഡിലിമിറ്ററായി ഒരു കോളൻ (:) ഉള്ള /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

സ്uക്രീൻഷോട്ടിന്റെ വലുപ്പം കണക്കിലെടുത്ത് മുകളിലെ സ്uക്രീൻഷോട്ടിൽ ഞാൻ ഒരു ലൈൻ സ്പ്ലിറ്റ് മാത്രമാണ് കാണിച്ചത്.

ലിനക്സിൽ ശൂന്യമായ വരികൾ

നിങ്ങൾ ഫയൽ ഉള്ളടക്കത്തിലൂടെ ലൂപ്പ് ചെയ്യുമ്പോൾ ശൂന്യമായ വരികൾ അവഗണിക്കില്ല. ഇത് പ്രകടമാക്കുന്നതിന് താഴെയുള്ള ഉള്ളടക്കം ഉപയോഗിച്ച് ഞാൻ ഒരു സാമ്പിൾ ഫയൽ സൃഷ്ടിച്ചു. 4 ലൈനുകളും കുറച്ച് ശൂന്യമായ വരികളും ഉണ്ട്, ലീഡിംഗ് വൈറ്റ്uസ്uപെയ്uസ്, പിന്നിലുള്ള വൈറ്റ് സ്uപെയ്uസ്, ലൈൻ 2 ലെ ടാബ് പ്രതീകങ്ങൾ, കൂടാതെ ചില എസ്uകേപ്പ് പ്രതീകങ്ങൾ ( ഒപ്പം ).

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

ഔട്ട്uപുട്ട് എസ്uകേപ്പ് പ്രതീകങ്ങൾക്ക് അവയുടെ അർത്ഥം നഷ്uടപ്പെട്ടതായും എന്നതിന് പകരം n, t എന്നിവ മാത്രം പ്രിന്റ് ചെയ്uതിരിക്കുന്നതായും നിങ്ങൾക്ക് കാണാൻ കഴിയും. ഒപ്പം . ബാക്ക്സ്ലാഷ് വ്യാഖ്യാനം തടയാൻ നിങ്ങൾക്ക് -r ഉപയോഗിക്കാം.

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

ഈ ലേഖനത്തിന് അത്രയേയുള്ളൂ. എന്തെങ്കിലും ഫീഡ്uബാക്കുകളോ നുറുങ്ങുകളോ ഉണ്ടെങ്കിൽ നിങ്ങളിൽ നിന്ന് കേൾക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു. മികച്ച ഉള്ളടക്കം സൃഷ്ടിക്കാൻ ഞങ്ങളെ സഹായിക്കുന്നത് നിങ്ങളുടെ ഫീഡ്uബാക്കാണ്. തുടർന്നും വായിക്കുകയും പിന്തുണയ്ക്കുകയും ചെയ്യുക.