Verschidde Weeër fir Datei am Bash Skript ze liesen wärend Loop

Dësen Artikel ass alles iwwer wéi Dir Dateien a Bash Scripte liest mat enger While Loop. Eng Datei liesen ass eng allgemeng Operatioun am Programméiere. Dir sollt mat verschiddene Methoden vertraut sinn a wéi eng Method méi effizient ass ze benotzen. Am Bash kann eng eenzeg Aufgab op ville Weeër erreecht ginn awer et gëtt ëmmer en optimale Wee fir d'Aufgab gemaach ze kréien a mir sollten se verfollegen.

Ier Dir gesitt wéi d'Dateiinhalt liest andeems Dir While Loop benotzt, e schnelle Primer iwwer wéi iwwerdeems Loop funktionnéiert. Wärend Loop evaluéiert eng Bedingung an iteréiert iwwer e bestëmmte Set vu Coden wann d'Konditioun wouer ass.

while [ CONDITION ]
do
    code block
done

Loosst eis zerbriechen wärend der Loop Syntax.

  • während Loop soll mat engem Schlësselwuert ufänke gefollegt vun enger Konditioun.
  • Eng Bedingung soll bannent [ ] oder [[ ]] ageschloss sinn. D'Konditioun soll ëmmer richteg zréckkommen fir d'Loop auszeféieren.
  • Den eigentleche Codeblock gëtt tëscht maachen a gemaach.

NUMBER=0

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

Dëst ass e ganz einfacht Beispill, wou d'Loop ausféiert bis NUMBER net méi wéi 10 ass an d'Echo Ausso dréckt.

Zesumme mat iwwerdeems wäerte mir de Liesbefehl benotze fir den Inhalt vun enger Datei Zeil fir Zeil ze liesen. Drënner ass d'Syntax vu wéi während a liesen Kommandoen kombinéiert ginn. Elo ginn et verschidde Weeër fir d'Datei als Input ze passéieren a mir wäerte se all gesinn.

# SYNTAX
while read VARIABLE
do
    code
done

Piping an Linux

Normalerweis wäerte mir d'Zort benotzen, etc.

Ähnlech benotze mir de Cat Kommando hei fir den Inhalt vun der Datei ze liesen an et an eng Wäitschleife ze päifen. Fir Demonstratioun benotzen ech /etc/passwd Datei awer et ass net unzeroden mat dëser Datei ze messen, also huelt eng Backupkopie vun dëser Datei a spillt mat der wann Dir dat wëllt.

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

Loosst eis ofbriechen wat geschitt wann de uewe genannte Code presentéiert gëtt.

  • cat /etc/passwd liest den Inhalt vun der Datei an passt en als Input duerch d'Päif.
  • Lies Kommando liest all Zeil, déi als Input vum Cat Kommando passéiert ass a späichert se an der LREAD Variabel.
  • Lies Kommando liest den Inhalt vum Fichier bis EOL interpretéiert gëtt.

Dir kënnt och aner Befehle benotzen wéi Kapp, Schwanz, a Päif et während der Loop.

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

Input Viruleedung am Linux

Mir kënnen den Inhalt vun der Datei op d'Schleife redirectéieren andeems Dir den Input Redirection Operator (<) benotzt.

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

Dir kënnt och den Dateinumm op eng Variabel späicheren an et duerch e Viruleedungsoperateur passéieren.

FILENAME="/etc/passwd"

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

Dir kënnt och Dateinumm als Argument un Äert Skript weiderginn.

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

Intern Feld Separator

Dir kënnt mat verschiddenen Zorte vu Dateiformate schaffen (CSV, TXT, JSON) an Dir wëllt vläicht den Inhalt vun der Datei opdeelen op Basis vun engem personaliséierten Ofgrenzer. An dësem Fall kënnt Dir Intern Feldseparator (IFS) benotzen fir den Inhalt vun der Datei opzedeelen an a Variablen ze späicheren.

Loosst mech weisen wéi et funktionnéiert. Kuckt d' /etc/passwd Datei déi e Colon (:) als Ofgrenzer huet. Dir kënnt elo all Wuert vun enger Zeil opdeelen an et an enger separater Variabel späicheren.

Am Beispill hei ënnen trennen ech /etc/passwd Datei mat engem Doppelpunkt als meng Separator a späicheren all Split a verschidde Variabelen.

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

Ech hunn just eng Zeil gespléckt am uewe genannte Screenshot ugewisen wann Dir Screenshotgréisst berécksiichtegt.

Eidel Linnen am Linux

Eidel Zeilen ginn net ignoréiert wann Dir duerch den Dateiinhalt schleift. Fir dëst ze demonstréieren hunn ech eng Probedatei mat dem Inhalt hei ënnen erstallt. Et gi 4 Zeilen a e puer eidel Zeilen, führend Whitespace, hannendrun wäiss Plaz, Tab Charaktere an der Linn 2, an e puer Flucht Charaktere ( an).

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

Kuckt d'Resultat, eidel Linn gëtt net ignoréiert. Och eng interessant Saach ze notéieren ass wéi wäiss Plazen duerch de Liesbefehl ofgeschnidden ginn. En einfache Wee fir eidel Zeilen ze ignoréieren wann Dir de Fichierinhalt liest ass den Testoperateur mam -z Fändel ze benotzen, deen kontrolléiert ob d'Stringlängt null ass. Elo widderhuelen mir datselwecht Beispill awer dës Kéier mat engem Testoperateur.

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

Elo vum Ausgang kënnt Dir gesinn datt eidel Linnen ignoréiert ginn.

Flucht Charaktere

Escape Charaktere wéi , , 

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

Dir kënnt aus der Ausgab gesinn Flucht Zeechen hunn hir Bedeitung verluer an nëmmen n an t ginn gedréckt amplaz an . Dir kënnt -r benotzen fir Backslash Interpretatioun ze vermeiden.

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

Dat ass et fir dësen Artikel. Mir géife gären vun Iech zréck héieren wann et Feedback oder Tipps gëtt. Äre Feedback ass wat eis hëlleft besseren Inhalt ze kreéieren. Weiderliesen a weider ënnerstëtzen.