लूप के दौरान बैश स्क्रिप्ट में फ़ाइल पढ़ने के विभिन्न तरीके


यह आलेख इस बारे में है कि बैश स्क्रिप्ट में थोड़ी देर के लूप का उपयोग करके फ़ाइलों को कैसे पढ़ा जाए। प्रोग्रामिंग में एक फाइल पढ़ना एक सामान्य ऑपरेशन है। आपको विभिन्न विधियों से परिचित होना चाहिए और कौन सी विधि उपयोग करने के लिए अधिक कुशल है। बैश में, एक कार्य को कई तरीकों से प्राप्त किया जा सकता है लेकिन कार्य को पूरा करने का हमेशा एक इष्टतम तरीका होता है और हमें इसका पालन करना चाहिए।

लूप के दौरान फ़ाइल सामग्री को पढ़ने का तरीका देखने से पहले, लूप कैसे काम करता है, इस पर एक त्वरित प्राइमर। जबकि लूप एक शर्त का मूल्यांकन करता है और स्थिति के सही होने पर कोड के दिए गए सेट पर पुनरावृति करता है।

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

आइए देखें कि उपरोक्त कोड सबमिट करने पर क्या होगा।

  • cat /etc/passwd फ़ाइल की सामग्री को पढ़ेगा और इसे पाइप के माध्यम से इनपुट के रूप में पास करेगा।
  • रीड कमांड कैट कमांड से इनपुट के रूप में पास की गई प्रत्येक लाइन को पढ़ता है और इसे LREAD वेरिएबल में स्टोर करता है।
  • रीड कमांड ईओएल की व्याख्या होने तक फ़ाइल सामग्री को पढ़ेगा।

आप हेड, टेल जैसे अन्य कमांड का भी उपयोग कर सकते हैं और इसे लूप के दौरान पाइप कर सकते हैं।

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) के साथ काम कर सकते हैं और आप कस्टम सीमांकक के आधार पर फ़ाइल की सामग्री को विभाजित करना चाह सकते हैं। इस मामले में, आप फ़ाइल की सामग्री को विभाजित करने और इसे चरों में संग्रहीत करने के लिए \आंतरिक क्षेत्र विभाजक (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

मैंने स्क्रीनशॉट के आकार को देखते हुए उपरोक्त स्क्रीनशॉट में सिर्फ एक लाइन स्प्लिट प्रदर्शित किया।

लिनक्स में खाली लाइनें

जब आप फ़ाइल सामग्री के माध्यम से लूप करते हैं तो खाली लाइनों को अनदेखा नहीं किया जाता है। इसे प्रदर्शित करने के लिए मैंने नीचे दी गई सामग्री के साथ एक नमूना फ़ाइल बनाई है। 4 पंक्तियाँ और कुछ खाली रेखाएँ हैं, प्रमुख रिक्त स्थान, अनुगामी श्वेत स्थान, पंक्ति 2 में टैब वर्ण, और कुछ बच निकलने वाले वर्ण (\n और \t)।

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

परिणाम देखें, रिक्त रेखा को अनदेखा नहीं किया जाता है। साथ ही, ध्यान देने वाली एक दिलचस्प बात यह है कि रीड कमांड द्वारा व्हाइट स्पेस को कैसे ट्रिम किया जाता है। फ़ाइल सामग्री को पढ़ते समय रिक्त पंक्तियों को अनदेखा करने का एक आसान तरीका है -z ध्वज के साथ परीक्षण ऑपरेटर का उपयोग करना जो यह जांचता है कि स्ट्रिंग की लंबाई शून्य है या नहीं। अब उसी उदाहरण को दोहराते हैं लेकिन इस बार एक परीक्षण ऑपरेटर के साथ।

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

अब आउटपुट से, आप देख सकते हैं कि खाली लाइनों को नजरअंदाज कर दिया गया है।

एस्केप कैरेक्टर

फ़ाइल पढ़ते समय \n, \t, \c जैसे एस्केप कैरेक्टर प्रिंट नहीं होंगे। इसे प्रदर्शित करने के लिए मैं उसी नमूना फ़ाइल का उपयोग कर रहा हूं जिसमें कुछ बच निकलने वाले वर्ण हैं।

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

आप आउटपुट से देख सकते हैं कि एस्केप वर्ण अपना अर्थ खो चुके हैं और \n और \t के बजाय केवल n और t मुद्रित होते हैं। बैकस्लैश व्याख्या को रोकने के लिए आप -r का उपयोग कर सकते हैं।

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

इस लेख के लिए बस इतना ही। अगर कोई प्रतिक्रिया या सुझाव है तो हम आपसे वापस सुनना पसंद करेंगे। आपकी प्रतिक्रिया ही हमें बेहतर सामग्री बनाने में मदद करती है। पढ़ते रहिये और सपोर्ट करते रहिये।