లూప్ అయితే బాష్ స్క్రిప్ట్uలో ఫైల్ చదవడానికి వివిధ మార్గాలు

ఈ వ్యాసం కాసేపు లూప్ ఉపయోగించి బాష్ స్క్రిప్ట్స్uలో ఫైళ్ళను ఎలా చదవాలి అనే దాని గురించి. ఫైల్uను చదవడం ప్రోగ్రామింగ్uలో ఒక సాధారణ ఆపరేషన్. మీరు వేర్వేరు పద్ధతులతో పరిచయం కలిగి ఉండాలి మరియు ఏ పద్ధతిని ఉపయోగించడానికి మరింత సమర్థవంతంగా ఉంటుంది. బాష్uలో, ఒకే పనిని అనేక విధాలుగా సాధించవచ్చు, కాని ఆ పనిని పూర్తి చేయడానికి ఎల్లప్పుడూ సరైన మార్గం ఉంటుంది మరియు మేము దానిని అనుసరించాలి.

అయితే లూప్ ఉపయోగించి ఫైల్ విషయాలను ఎలా చదవాలో చూడటానికి ముందు, లూప్ ఎలా పనిచేస్తుందో శీఘ్ర ప్రైమర్. లూప్ ఒక షరతును అంచనా వేస్తుంది మరియు షరతు నిజం అయినప్పుడు ఇచ్చిన సంకేతాల సమితిపై మళ్ళిస్తుంది.

while [ CONDITION ]
do
    code block
done

లూప్ సింటాక్స్ అయితే విచ్ఛిన్నం చేద్దాం.

• అయితే లూప్ కాసేపు కీవర్డ్uతో షరతులతో ప్రారంభం కావాలి.
• [] లేదా [[]] లోపల ఒక షరతు ఉండాలి. లూప్ అమలు కావడానికి పరిస్థితి ఎల్లప్పుడూ నిజం అవుతుంది.
• కోడ్ యొక్క వాస్తవ బ్లాక్ చేయవలసిన మరియు చేసిన వాటి మధ్య ఉంచబడుతుంది.

NUMBER=0

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

ఇది చాలా సరళమైన ఉదాహరణ, ఇక్కడ NUMBER 10 కంటే ఎక్కువ కాదు మరియు ఎకో స్టేట్uమెంట్uను ప్రింట్ చేసే వరకు లూప్ అమలు చేస్తుంది.

ఫైల్ లైన్ యొక్క విషయాలను లైన్ ద్వారా చదవడానికి మేము రీడ్ కమాండ్ను ఉపయోగిస్తాము. ఎలా మరియు చదివే ఆదేశాలను కలుపుతారు అనే వాక్యనిర్మాణం క్రింద ఉంది. ఇప్పుడు ఫైల్uను ఇన్uపుట్uగా పాస్ చేయడానికి వివిధ మార్గాలు ఉన్నాయి మరియు అవన్నీ చూస్తాము.

# SYNTAX
while read VARIABLE
do
    code
done

Linux లో పైపింగ్

సాధారణంగా మేము విధమైన ఉపయోగిస్తాము.

అదేవిధంగా, ఫైల్ యొక్క కంటెంట్ను చదవడానికి మరియు కాసేపు లూప్కు పైప్ చేయడానికి మేము ఇక్కడ పిల్లి ఆదేశాన్ని ఉపయోగిస్తాము. ప్రదర్శన కోసం, నేను/etc/passwd ఫైల్uని ఉపయోగిస్తున్నాను కాని ఈ ఫైల్uతో గందరగోళానికి గురికావడం మంచిది కాదు కాబట్టి ఈ ఫైల్ యొక్క బ్యాకప్ కాపీని తీసుకొని మీరు కోరుకుంటే దానితో ప్లే చేయండి.

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

పై కోడ్ సమర్పించినప్పుడు ఏమి జరుగుతుందో విడదీయండి.

• cat/etc/passwd ఫైల్ యొక్క విషయాలను చదివి పైపు ద్వారా ఇన్పుట్ గా పాస్ చేస్తుంది.
<
• రీడ్ కమాండ్ పిల్లి కమాండ్ నుండి ఇన్పుట్ గా పంపిన ప్రతి పంక్తిని చదివి LREAD వేరియబుల్ లో నిల్వ చేస్తుంది.
<
• రీడ్ కమాండ్ EOL ను వివరించే వరకు ఫైల్ విషయాలను చదువుతుంది

మీరు తల, తోక వంటి ఇతర ఆదేశాలను కూడా ఉపయోగించవచ్చు మరియు లూప్ చేసేటప్పుడు దాన్ని పైప్ చేయవచ్చు.

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

Linux లో ఇన్పుట్ దారి మళ్లింపు

ఇన్పుట్ దారి మళ్లింపు ఆపరేటర్ (<) ను ఉపయోగించి ఫైల్ యొక్క కంటెంట్uను లూప్uలోకి మళ్ళించగలము.

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

మీరు ఫైల్ పేరును వేరియబుల్uకు నిల్వ చేసి, దారి మళ్లింపు ఆపరేటర్ ద్వారా పంపవచ్చు.

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ను విభజించడానికి మరియు వేరియబుల్స్uలో నిల్వ చేయడానికి Internal "ఇంటర్నల్ ఫీల్డ్ సెపరేటర్ (IFS)" ను ఉపయోగించవచ్చు.

ఇది ఎలా పనిచేస్తుందో నేను ప్రదర్శిస్తాను. డీలిమిటర్uగా పెద్దప్రేగు (:) ఉన్న/etc/passwd ఫైల్uను చూడండి. మీరు ఇప్పుడు ప్రతి పదాన్ని ఒక పంక్తి నుండి విభజించి ప్రత్యేక వేరియబుల్uలో నిల్వ చేయవచ్చు.

దిగువ ఉదాహరణలో, నేను/etc/passwd ఫైల్uను పెద్దప్రేగుతో నా సెపరేటర్uగా విభజిస్తున్నాను మరియు ప్రతి స్ప్లిట్uను వేర్వేరు వేరియబుల్స్uగా నిల్వ చేస్తున్నాను.

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

స్క్రీన్ షాట్ పరిమాణాన్ని పరిగణనలోకి తీసుకుని పై స్క్రీన్ షాట్ లో నేను ఒక లైన్ స్ప్లిట్ ను ప్రదర్శించాను.

Linux లో ఖాళీ పంక్తులు

మీరు ఫైల్ కంటెంట్ ద్వారా లూప్ చేసినప్పుడు ఖాళీ పంక్తులు విస్మరించబడవు. దీన్ని ప్రదర్శించడానికి నేను ఈ క్రింది కంటెంట్uతో నమూనా ఫైల్uను సృష్టించాను. 4 పంక్తులు మరియు కొన్ని ఖాళీ పంక్తులు ఉన్నాయి, ప్రముఖ వైట్uస్పేస్, వెనువెంటనే తెల్లని స్థలం, 2 వ పంక్తిలో టాబ్ అక్షరాలు మరియు కొన్ని తప్పించుకునే అక్షరాలు ( మరియు).

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

ఫలితాన్ని చూడండి, ఖాళీ పంక్తి విస్మరించబడదు. అలాగే, గమనించదగ్గ విషయం ఏమిటంటే, రీడ్ కమాండ్ ద్వారా తెల్లని ఖాళీలు ఎలా కత్తిరించబడతాయి. ఫైల్ కంటెంట్uను చదివేటప్పుడు ఖాళీ పంక్తులను విస్మరించడానికి ఒక సరళమైన మార్గం ఏమిటంటే, -z ఫ్లాగ్uతో టెస్ట్ ఆపరేటర్uను ఉపయోగించడం, ఇది స్ట్రింగ్ పొడవు సున్నా కాదా అని తనిఖీ చేస్తుంది. ఇప్పుడు అదే ఉదాహరణను పునరావృతం చేద్దాం కాని ఈసారి టెస్ట్ ఆపరేటర్uతో.

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

ఈ వ్యాసం కోసం అది. ఏదైనా ఫీడ్uబ్యాక్uలు లేదా చిట్కాలు ఉంటే మీ నుండి తిరిగి వినడానికి మేము ఇష్టపడతాము. మీ అభిప్రాయం మంచి కంటెంట్uను సృష్టించడానికి మాకు సహాయపడుతుంది. చదువుతూ ఉండండి మరియు మద్దతు ఇవ్వండి.