Wie iteriere ich mit Bash durch jede Zeile einer Textdatei ?

Mit diesem Skript:

echo "Start!"
for p in (peptides.txt)
do
    echo "${p}"
done

Ich bekomme diese Ausgabe auf dem Bildschirm:

Start!
./runPep.sh: line 3: syntax error near unexpected token `('
./runPep.sh: line 3: `for p in (peptides.txt)'

(Später möchte ich etwas Komplizierteres tun, $pals nur auf dem Bildschirm auszugeben.)

Die Umgebungsvariable SHELL ist (von env):

SHELL=/bin/bash

/bin/bash --version Ausgabe:

GNU bash, version 3.1.17(1)-release (x86_64-suse-linux-gnu)
Copyright (C) 2005 Free Software Foundation, Inc.

cat /proc/version Ausgabe:

Linux version 2.6.18.2-34-default (geeko@buildhost) (gcc version 4.1.2 20061115 (prerelease) (SUSE Linux)) #1 SMP Mon Nov 27 11:46:27 UTC 2006

Die Datei peptides.txt enthält:

RKEKNVQ
IPKKLLQK
QYFHQLEKMNVK
IPKKLLQK
GDLSTALEVAIDCYEK
QYFHQLEKMNVKIPENIYR
RKEKNVQ
VLAKHGKLQDAIN
ILGFMK
LEDVALQILL

Ein Weg, dies zu tun, ist:

while read p; do
  echo "$p"
done <peptides.txt

Wie in den Kommentaren erwähnt, hat dies die Nebenwirkungen, dass führende Leerzeichen gekürzt, Backslash-Sequenzen interpretiert und die letzte Zeile übersprungen werden, wenn ein abschließender Zeilenvorschub fehlt. Wenn dies Bedenken sind, können Sie Folgendes tun:

while IFS="" read -r p || [ -n "$p" ]
do
  printf '%s\n' "$p"
done < peptides.txt

In Ausnahmefällen können Sie die Datei mit einem anderen Dateideskriptor öffnen , wenn der Schleifenkörper aus der Standardeingabe lesen kann:

while read -u 10 p; do
  ...
done 10<peptides.txt

Hier ist 10 nur eine beliebige Zahl (verschieden von 0, 1, 2).

cat peptides.txt | while read line 
do
   # do something with $line here
done

und die Einzeiler-Variante:

cat peptides.txt | while read line; do something_with_$line_here; done

Diese Optionen überspringen die letzte Zeile der Datei, wenn kein nachfolgender Zeilenvorschub vorhanden ist.

Sie können dies folgendermaßen vermeiden:

cat peptides.txt | while read line || [[ -n $line ]];
do
   # do something with $line here
done

Option 1a: While-Schleife: Jeweils einzelne Zeile: Eingangsumleitung

#!/bin/bash
filename='peptides.txt'
echo Start
while read p; do 
    echo $p
done < $filename

Option 1b: While-Schleife: Jeweils eine Zeile:
Öffnen Sie die Datei und lesen Sie sie aus einem Dateideskriptor (in diesem Fall Dateideskriptor Nr. 4).

#!/bin/bash
filename='peptides.txt'
exec 4<$filename
echo Start
while read -u4 p ; do
    echo $p
done

Dies ist nicht besser als andere Antworten, aber eine weitere Möglichkeit, die Arbeit in einer Datei ohne Leerzeichen zu erledigen (siehe Kommentare). Ich finde, dass ich oft Einzeiler brauche, um Listen in Textdateien zu durchsuchen, ohne den zusätzlichen Schritt, separate Skriptdateien zu verwenden.

for word in $(cat peptides.txt); do echo $word; done

Mit diesem Format kann ich alles in einer Befehlszeile zusammenfassen. Ändern Sie den Teil "echo $ word" nach Ihren Wünschen und Sie können mehrere durch Semikolons getrennte Befehle ausgeben. Im folgenden Beispiel wird der Inhalt der Datei als Argument für zwei andere Skripte verwendet, die Sie möglicherweise geschrieben haben.

for word in $(cat peptides.txt); do cmd_a.sh $word; cmd_b.py $word; done

Wenn Sie dies wie einen Stream-Editor verwenden möchten (learn sed), können Sie die Ausgabe wie folgt in eine andere Datei kopieren.

for word in $(cat peptides.txt); do cmd_a.sh $word; cmd_b.py $word; done > outfile.txt

Ich habe diese wie oben beschrieben verwendet, weil ich Textdateien verwendet habe, in denen ich sie mit einem Wort pro Zeile erstellt habe. (Siehe Kommentare) Wenn Sie Leerzeichen haben, in denen Sie Ihre Wörter / Zeilen nicht teilen möchten, wird es etwas hässlicher, aber der gleiche Befehl funktioniert immer noch wie folgt:

OLDIFS=$IFS; IFS=$'\n'; for line in $(cat peptides.txt); do cmd_a.sh $line; cmd_b.py $line; done > outfile.txt; IFS=$OLDIFS

Dadurch wird die Shell lediglich angewiesen, nur in Zeilenumbrüchen und nicht in Leerzeichen zu teilen. Anschließend wird die Umgebung auf den vorherigen Stand zurückgesetzt. An dieser Stelle möchten Sie möglicherweise in Betracht ziehen, alles in ein Shell-Skript einzufügen, anstatt alles in einer einzigen Zeile zusammenzufassen.

Viel Glück!

Noch ein paar Dinge, die von anderen Antworten nicht abgedeckt werden:

Lesen aus einer begrenzten Datei

# ':' is the delimiter here, and there are three fields on each line in the file
# IFS set below is restricted to the context of `read`, it doesn't affect any other code
while IFS=: read -r field1 field2 field3; do
  # process the fields
  # if the line has less than three fields, the missing fields will be set to an empty string
  # if the line has more than three fields, `field3` will get all the values, including the third field plus the delimiter(s)
done < input.txt

Lesen aus der Ausgabe eines anderen Befehls mithilfe der Prozessersetzung

while read -r line; do
  # process the line
done < <(command ...)

Dieser Ansatz ist besser, als command ... | while read -r line; do ...weil die while-Schleife hier in der aktuellen Shell ausgeführt wird und nicht wie im Fall der letzteren in einer Subshell. Siehe den entsprechenden Beitrag. Eine in einer while-Schleife geänderte Variable wird nicht gespeichert .

Zum Beispiel das Lesen von einer durch Null getrennten Eingabe find ... -print0

while read -r -d '' line; do
  # logic
  # use a second 'read ... <<< "$line"' if we need to tokenize the line
done < <(find /path/to/dir -print0)

Lesen Sie dazu: BashFAQ / 020 - Wie kann ich Dateinamen finden und sicher behandeln, die Zeilenumbrüche, Leerzeichen oder beides enthalten?

Lesen von mehr als einer Datei gleichzeitig

while read -u 3 -r line1 && read -u 4 -r line2; do
  # process the lines
  # note that the loop will end when we reach EOF on either of the files, because of the `&&`
done 3< input1.txt 4< input2.txt

Basierend auf der Antwort von @ chepner hier :

-uist eine Bash-Erweiterung. Aus Gründen der POSIX-Kompatibilität würde jeder Aufruf ungefähr so ​​aussehen read -r X <&3.

Einlesen einer ganzen Datei in ein Array (Bash-Versionen vor 4)

while read -r line; do
    my_array+=("$line")
done < my_file

Wenn die Datei mit einer unvollständigen Zeile endet (neue Zeile fehlt am Ende), dann:

while read -r line || [[ $line ]]; do
    my_array+=("$line")
done < my_file

Einlesen einer ganzen Datei in ein Array (Bash-Versionen 4x und höher)

readarray -t my_array < my_file

oder

mapfile -t my_array < my_file

Und dann

for line in "${my_array[@]}"; do
  # process the lines
done

• Mehr über die eingebauten Shell-Befehle readund readarray-Befehle - GNU

• Mehr über IFS- Wikipedia

• BashFAQ / 001 - Wie kann ich eine Datei (Datenstrom, Variable) Zeile für Zeile (und / oder Feld für Feld) lesen?

Zusammenhängende Posts:

• Erstellen eines Arrays aus einer Textdatei in Bash
• Was ist der Unterschied zwischen deinen Ansätzen zum Lesen einer Datei mit nur einer Zeile?
• Bash während der Leseschleife im Vergleich zu Katze extrem langsam, warum?

Verwenden Sie eine while-Schleife wie folgt:

while IFS= read -r line; do
   echo "$line"
done <file

Anmerkungen:

1. Wenn Sie das nicht IFSrichtig einstellen, verlieren Sie die Einrückung.

2. Sie sollten fast immer die Option -r beim Lesen verwenden.

3. Lies keine Zeilen mit for

Angenommen, Sie haben diese Datei:

$ cat /tmp/test.txt
Line 1
    Line 2 has leading space
Line 3 followed by blank line

Line 5 (follows a blank line) and has trailing space    
Line 6 has no ending CR

Es gibt vier Elemente, die die Bedeutung der von vielen Bash-Lösungen gelesenen Dateiausgabe ändern:

1. Die leere Zeile 4;
2. Führende oder nachfolgende Leerzeichen in zwei Zeilen;
3. Beibehaltung der Bedeutung einzelner Zeilen (dh jede Zeile ist ein Datensatz);
4. Die Leitung 6 endete nicht mit einem CR.

Wenn Sie die Textdatei zeilenweise einschließlich Leerzeilen und Abschlusszeilen ohne CR verwenden möchten, müssen Sie eine while-Schleife verwenden und einen alternativen Test für die letzte Zeile durchführen.

Hier sind die Methoden, mit denen die Datei geändert werden kann (im Vergleich zu den catzurückgegebenen):

1) Verlieren Sie die letzte Zeile und die führenden und nachfolgenden Leerzeichen:

$ while read -r p; do printf "%s\n" "'$p'"; done </tmp/test.txt
'Line 1'
'Line 2 has leading space'
'Line 3 followed by blank line'
''
'Line 5 (follows a blank line) and has trailing space'

(Wenn Sie dies while IFS= read -r p; do printf "%s\n" "'$p'"; done </tmp/test.txtstattdessen tun, behalten Sie die führenden und nachfolgenden Leerzeichen bei, verlieren jedoch die letzte Zeile, wenn sie nicht mit CR abgeschlossen wird.)

2) Wenn Sie die Prozesssubstitution mit catWillen verwenden, wird die gesamte Datei in einem Zug gelesen und die Bedeutung einzelner Zeilen verloren:

$ for p in "$(cat /tmp/test.txt)"; do printf "%s\n" "'$p'"; done
'Line 1
    Line 2 has leading space
Line 3 followed by blank line

Line 5 (follows a blank line) and has trailing space    
Line 6 has no ending CR'

(Wenn Sie das Entfernen "von $(cat /tmp/test.txt)Ihnen lesen Sie die Datei Wort für Wort , anstatt einem Zug. Auch wahrscheinlich nicht , was beabsichtigt ist ...)

Der robusteste und einfachste Weg, eine Datei Zeile für Zeile zu lesen und alle Abstände beizubehalten, ist:

$ while IFS= read -r line || [[ -n $line ]]; do printf "'%s'\n" "$line"; done </tmp/test.txt
'Line 1'
'    Line 2 has leading space'
'Line 3 followed by blank line'
''
'Line 5 (follows a blank line) and has trailing space    '
'Line 6 has no ending CR'

Wenn Sie führende und handelnde Leerzeichen entfernen möchten, entfernen Sie das IFS=Teil:

$ while read -r line || [[ -n $line ]]; do printf "'%s'\n" "$line"; done </tmp/test.txt
'Line 1'
'Line 2 has leading space'
'Line 3 followed by blank line'
''
'Line 5 (follows a blank line) and has trailing space'
'Line 6 has no ending CR'

(Eine Textdatei ohne Terminierung \nwird unter POSIX als fehlerhaft angesehen , obwohl sie ziemlich häufig vorkommt. Wenn Sie sich auf das Trailing verlassen können, das \nSie || [[ -n $line ]]in der whileSchleife nicht benötigen .)

Mehr in den BASH FAQ

Wenn Sie nicht möchten, dass Ihr Lesevorgang durch Zeilenumbrüche unterbrochen wird, verwenden Sie -

#!/bin/bash
while IFS='' read -r line || [[ -n "$line" ]]; do
    echo "$line"
done < "$1"

Führen Sie dann das Skript mit dem Dateinamen als Parameter aus.

#!/bin/bash
#
# Change the file name from "test" to desired input file 
# (The comments in bash are prefixed with #'s)
for x in $(cat test.txt)
do
    echo $x
done

Hier ist mein Beispiel aus dem wirklichen Leben, wie man Zeilen einer anderen Programmausgabe schleift, nach Teilzeichenfolgen sucht, doppelte Anführungszeichen aus der Variablen löscht und diese Variable außerhalb der Schleife verwendet. Ich denke, ziemlich viele stellen diese Fragen früher oder später.

##Parse FPS from first video stream, drop quotes from fps variable
## streams.stream.0.codec_type="video"
## streams.stream.0.r_frame_rate="24000/1001"
## streams.stream.0.avg_frame_rate="24000/1001"
FPS=unknown
while read -r line; do
  if [[ $FPS == "unknown" ]] && [[ $line == *".codec_type=\"video\""* ]]; then
    echo ParseFPS $line
    FPS=parse
  fi
  if [[ $FPS == "parse" ]] && [[ $line == *".r_frame_rate="* ]]; then
    echo ParseFPS $line
    FPS=${line##*=}
    FPS="${FPS%\"}"
    FPS="${FPS#\"}"
  fi
done <<< "$(ffprobe -v quiet -print_format flat -show_format -show_streams -i "$input")"
if [ "$FPS" == "unknown" ] || [ "$FPS" == "parse" ]; then 
  echo ParseFPS Unknown frame rate
fi
echo Found $FPS

Deklarieren Sie eine Variable außerhalb der Schleife, setzen Sie den Wert und verwenden Sie sie außerhalb der Schleife. Dies erfordert die Syntax <<< "$ (...)" . Die Anwendung muss im Kontext der aktuellen Konsole ausgeführt werden. Anführungszeichen um den Befehl halten neue Zeilen des Ausgabestreams.

Die Schleifenübereinstimmung für Teilzeichenfolgen lautet dann Name = Wertepaar, teilt den rechten Teil von last = Zeichen, löscht das erste Anführungszeichen, löscht das letzte Anführungszeichen, wir haben einen sauberen Wert, der an anderer Stelle verwendet werden kann.

Das kommt ziemlich spät, aber mit dem Gedanken, dass es jemandem helfen könnte, füge ich die Antwort hinzu. Auch dies ist möglicherweise nicht der beste Weg. headBefehl kann mit -nArgument verwendet werden, um n Zeilen vom Anfang der Datei tailzu lesen, und Befehl kann ebenfalls verwendet werden, um von unten zu lesen. Um nun die n-te Zeile aus der Datei abzurufen, leiten wir n Zeilen und leiten die Daten weiter, um nur eine Zeile aus den weitergeleiteten Daten zu beenden.

   TOTAL_LINES=`wc -l $USER_FILE | cut -d " " -f1 `
   echo $TOTAL_LINES       # To validate total lines in the file

   for (( i=1 ; i <= $TOTAL_LINES; i++ ))
   do
      LINE=`head -n$i $USER_FILE | tail -n1`
      echo $LINE
   done

@Peter: Das könnte für dich klappen-

echo "Start!";for p in $(cat ./pep); do
echo $p
done

Dies würde die Ausgabe zurückgeben.

Start!
RKEKNVQ
IPKKLLQK
QYFHQLEKMNVK
IPKKLLQK
GDLSTALEVAIDCYEK
QYFHQLEKMNVKIPENIYR
RKEKNVQ
VLAKHGKLQDAIN
ILGFMK
LEDVALQILL