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

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

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

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

लिनक्स में पाइपिंग

आम तौर पर हम टर्मिनल से फ़ाइल की सामग्री को देखने के लिए कैट कमांड का उपयोग करेंगे। साथ ही, हम cat कमांड . के आउटपुट को पाइप करेंगे अन्य कमांड जैसे grep, सॉर्ट, आदि के लिए।

इसी तरह, हम कैट कमांड . का उपयोग करेंगे यहाँ फ़ाइल की सामग्री को पढ़ने के लिए और इसे जबकि . तक पाइप करें फंदा। प्रदर्शन के लिए, मैं उपयोग कर रहा हूँ /etc/passwd फ़ाइल लेकिन इस फ़ाइल के साथ खिलवाड़ करना उचित नहीं है इसलिए इस फ़ाइल की एक बैकअप प्रति लें और यदि आप चाहें तो इसके साथ खेलें।

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

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

• बिल्ली /आदि/पासवार्ड फ़ाइल की सामग्री को पढ़ेगा और इसे पाइप के माध्यम से इनपुट के रूप में पास करेगा।
• पढ़ें कमांड प्रत्येक पंक्ति को कैट कमांड से इनपुट के रूप में पढ़ता है और इसे 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 ) और आप कस्टम सीमांकक के आधार पर फ़ाइल की सामग्री को विभाजित करना चाह सकते हैं। इस मामले में, आप “आंतरिक क्षेत्र विभाजक (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 और टी \n . के बजाय मुद्रित होते हैं और \t . आप -r . का उपयोग कर सकते हैं बैकस्लैश व्याख्या को रोकने के लिए।

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

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