Eine variable verändert sich innerhalb einer while-Schleife wird nicht gespeichert

In dem folgenden Programm, wenn ich die variable $foo auf den Wert 1 innerhalb der ersten if Aussage, es funktioniert in dem Sinne, dass Ihr Wert wird gespeichert nach der if-Anweisung. Allerdings, wenn ich die gleiche variable auf den Wert 2 innerhalb einer if die in einem while Aussage, es ist vergessen, nach der while Schleife. Es verhält sich so wie ich über irgendeine Art von Kopie der variable $foo innerhalb der while loop und ich bin nur das veränderte, insbesondere kopieren. Hier ist eine komplette test-Programm:

#!/bin/bash

set -e
set -u 
foo=0
bar="hello"  
if [[ "$bar" == "hello" ]]
then
    foo=1
    echo "Setting \$foo to 1: $foo"
fi

echo "Variable \$foo after if statement: $foo"   
lines="first line\nsecond line\nthird line" 
echo -e $lines | while read line
do
    if [[ "$line" == "second line" ]]
    then
    foo=2
    echo "Variable \$foo updated to $foo inside if inside while loop"
    fi
    echo "Value of \$foo in while loop body: $foo"
done

echo "Variable \$foo after while loop: $foo"

# Output:
# $ ./testbash.sh
# Setting $foo to 1: 1
# Variable $foo after if statement: 1
# Value of $foo in while loop body: 1
# Variable $foo updated to 2 inside if inside while loop
# Value of $foo in while loop body: 2
# Value of $foo in while loop body: 2
# Variable $foo after while loop: 1

# bash --version
# GNU bash, version 4.1.10(4)-release (i686-pc-cygwin)

Schlüssel Lesen Sie hier: ich Variablen in einer Schleife, die in einer pipeline. Warum verschwinden Sie, nachdem die Schleife beendet wird? Oder, warum kann ich nicht weiterleiten von Daten zu Lesen?.
Die shellcheck utility fängt diese (siehe github.com/koalaman/shellcheck/wiki/SC2030); Ausschneiden und einfügen der oben genannten code in shellcheck.net Probleme in diesem feedback für Zeile 19: SC2030: Modification of foo is local (to subshell caused by pipeline).

InformationsquelleAutor Eric Lilja | 2013-05-31

bash scope sh while-loop

193
```
echo -e $lines | while read line 
    ...
done
```
Den while Schleife ausgeführt wird, in einer subshell. So werden änderungen, die Sie tun, um die variable wird nicht verfügbar sein, wenn die subshell beendet.

Stattdessen können Sie eine die - Zeichenkette zu re-schreiben die while-Schleife in der main-shell-Prozess; nur echo -e $lines läuft in einer subshell:
```
while read line
do
    if [[ "$line" == "second line" ]]
    then
        foo=2
        echo "Variable \$foo updated to $foo inside if inside while loop"
    fi
    echo "Value of \$foo in while loop body: $foo"
done <<< "$(echo -e "$lines")"
```
Können Sie loszuwerden, die eher hässlich echo in der here-Zeichenfolge oben, durch den ausbau der backslash-Sequenzen sofort bei der Zuweisung lines. Die $'...' form zu zitieren, die verwendet werden können gibt es:
```
lines=$'first line\nsecond line\nthird line'
while read line; do
    ...
done <<< "$lines"
```
besser ändern <<< "$(echo -e "$lines")" einfache <<< "$lines"
was ist, wenn die Quelle war, aus tail -f anstatt fester text?
Sie können while read -r line; do echo "LINE: $line"; done < <(tail -f file) (natürlich die Schleife nicht beenden, wie es weiter warten für die Eingabe von tail).

InformationsquelleAutor P.P.
45

AKTUALISIERT#2

Erklärung ist im Blue Moons Antwort.

Alternative Lösungen:

Beseitigen echo
```
while read line; do
...
done <<EOT
first line
second line
third line
EOT
```
Fügen Sie das echo innerhalb der hier-ist-das-Dokument
```
while read line; do
...
done <<EOT
$(echo -e $lines)
EOT
```
Laufen echo im hintergrund:
```
coproc echo -e $lines
while read -u ${COPROC[0]} line; do 
...
done
```
Umleiten in eine Datei explizit verarbeiten (denken Sie an das Leerzeichen in < <!):
```
exec 3< <(echo -e  $lines)
while read -u 3 line; do
...
done
```
Oder leite es einfach an die stdin:
```
while read line; do
...
done < <(echo -e  $lines)
```
Und eine für chepner (Beseitigung echo):
```
arr=("first line" "second line" "third line");
for((i=0;i<${#arr[*]};++i)) { line=${arr[i]}; 
...
}
```
Variable $lines umgewandelt werden können, um ein array ohne starten eine neue sub-shell. Die Charaktere \ und n umgewandelt werden einige Zeichen (z.B. eine echte neue-Zeile-Zeichen) und die IFS (Internal Field Separator) variable split die Zeichenfolge in ein array von Elementen. Diese kann getan werden, wie:
```
lines="first line\nsecond line\nthird line"
echo "$lines"
OIFS="$IFS"
IFS=$'\n' arr=(${lines//\\n/$'\n'}) # Conversion
IFS="$OIFS"
echo "${arr[@]}", Length: ${#arr[*]}
set|grep ^arr
```
Ergebnis ist
```
first line\nsecond line\nthird line
first line second line third line, Length: 3
arr=([0]="first line" [1]="second line" [2]="third line")
```
+1 für die here-doc, da die lines variable einzige Zweck scheint zu sein, zu füttern while Schleife.
Thx!!! Ich fügte hinzu, ein anderes, für Sie!
Es gibt noch eine andere Lösung gegeben hier: for line in $(echo -e $lines); do ... done
Vielen Dank für Ihren Kommentar! Würde diese Lösung im Ergebnis 6 Zeilen mit einem einzigen Wort. OP ' s Anfrage war anders...
von Ihnen positiv bewertet werden. läuft echo in einer subshell hier drinnen-ist, war eine der wenigen Lösungen, die arbeitete in Esche

InformationsquelleAutor TrueY
9

Sind Sie der 742342nd Benutzer zu Fragen, dies bash-FAQ. Die Antwort beschreibt auch den Allgemeinen Fall der Variablen in subshells erstellt von pipes:
E4) , Wenn ich pipe die Ausgabe eines Befehls in read variable, warum
nicht der Ausgang zeigen, bis in $variable wenn der read-Befehl beendet wird?

Dies hat zu tun mit der Eltern-Kind-Beziehung zwischen Unix
Prozesse. Es betrifft alle Befehle ausführen, die in Rohrleitungen, nicht nur
einfache Aufrufe read. Zum Beispiel, Rohrleitungen ein Befehl
in einem while - Schleife, die wiederholt read führen
das gleiche Verhalten.

Jedes element einer pipeline, sogar eine vordefinierte oder eine shell-Funktion,
in einem separaten Prozess ausgeführt, ein Kind der shell ausführen
pipeline. Ein Teilprozess kann sich nicht auf seine Eltern Umgebung.
Wenn die read Befehl setzt die variable auf den Eingang, dass
variable ist nur in der subshell, nicht die Eltern-shell. Wenn
die subshell beendet, wird der Wert der Variablen verloren.

Vielen Rohrleitungen, die am Ende mit read variable umgewandelt werden können
in den Befehls-Substitution, die zu erfassen die Ausgabe von
einen angegebenen Befehl. Die Ausgabe kann dann zugeordnet werden
variable:
```
grep ^gnu /usr/lib/news/active | wc -l | read ngroup
```
umgewandelt werden kann
```
ngroup=$(grep ^gnu /usr/lib/news/active | wc -l)
```
Diese leider nicht die Arbeit aufteilen, den text unter
mehrere Variablen, wie Lesen funktioniert wenn da mehrere variable
Argumente. Wenn Sie brauchen, um dies zu tun, verwenden Sie entweder die
Kommando-substitution oben zu Lesen, die Ausgabe in eine variable
und hacken Sie die variable mit Hilfe des bash-Muster entfernen
expansion Betreiber oder einige der folgenden Variante
Ansatz.

Sagen /usr/local/bin/ipaddr, ist das folgende shell-Skript:
```
#! /bin/sh
host `hostname` | awk '/address/{print $NF}'
```
Anstatt
```
/usr/local/bin/ipaddr | read A B C D
```
brechen dem lokalen Computer die IP-Adresse in getrennten Oktetten, verwenden Sie
```
OIFS="$IFS"
IFS=.
set -- $(/usr/local/bin/ipaddr)
IFS="$OIFS"
A="$1" B="$2" C="$3" D="$4"
```
Bedenken Sie jedoch, dass dies ändern wird, die shell-positions
Parameter. Wenn Sie Sie benötigen, sollten Sie diese speichern, bevor Sie
dies.

Dies ist die Allgemeine Vorgehensweise-die in den meisten Fällen werden Sie nicht brauchen, um
$IFS auf einen anderen Wert.

Einige andere Benutzer angegebenen alternativen sind:
```
read A B C D << HERE
    $(IFS=.; echo $(/usr/local/bin/ipaddr))
HERE
```
und, wo Prozess-substitution verfügbar ist,
```
read A B C D < <(IFS=.; echo $(/usr/local/bin/ipaddr))
```
Haben Sie vergessen, die Familien-Fehde problem. Manchmal ist es sehr schwer zu finden, die die gleiche Kombination von Worten wie wer schrieb die Antwort, so dass Sie weder überflutet im falschen Ergebnissen, noch herausfiltern sagte Antwort.

InformationsquelleAutor Jens
1

Hmmm... ich würde fast schwören, dass das funktioniert hat, die für die ursprüngliche Bourne-shell, aber don ' T haben Zugriff auf eine ausgeführte Kopie gerade jetzt zu überprüfen.

Es ist jedoch eine sehr triviale Lösung für das problem.

Ändern Sie die erste Zeile des Skripts aus:
```
#!/bin/bash
```
zu
```
#!/bin/ksh
```
Et voila! Ein Lesen am Ende einer pipeline funktioniert gut, vorausgesetzt, Sie haben die Korn-shell installiert.

InformationsquelleAutor Jonathan Quist

Dies ist eine interessante Frage, und berühren Sie ein sehr grundlegendes Konzept in der Bourne-shell und subshell. Hier habe ich eine Lösung bereitzustellen, die sich von den vorherigen Lösungen, indem Sie eine Art der Filterung. Ich werde ein Beispiel geben, dass kann nützlich sein im wirklichen Leben. Dies ist ein fragment zum überprüfen der heruntergeladenen Dateien entsprechen zu wissen Prüfsummen. Die Datei-Prüfsumme wie folgt Aussehen (Mit nur 3 Zeilen):

49174 36326 dna_align_feature.txt.gz
54757     1 dna.txt.gz
55409  9971 exon_transcript.txt.gz

Dem shell-script:

#!/bin/sh

.....

failcnt=0 # this variable is only valid in the parent shell
#variable xx captures all the outputs from the while loop
xx=$(cat ${checkfile} | while read -r line; do
    num1=$(echo $line | awk '{print $1}')
    num2=$(echo $line | awk '{print $2}')
    fname=$(echo $line | awk '{print $3}')
    if [ -f "$fname" ]; then
        res=$(sum $fname)
        filegood=$(sum $fname | awk -v na=$num1 -v nb=$num2 -v fn=$fname '{ if (na == $1 && nb == $2) { print "TRUE"; } else { print "FALSE"; }}')
        if [ "$filegood" = "FALSE" ]; then
            failcnt=$(expr $failcnt + 1) # only in subshell
            echo "$fname BAD $failcnt"
        fi
    fi
done | tail -1) # I am only interested in the final result
# you can capture a whole bunch of texts and do further filtering
failcnt=${xx#* BAD } # I am only interested in the number
# this variable is in the parent shell
echo failcnt $failcnt
if [ $failcnt -gt 0 ]; then
    echo $failcnt files failed
else
    echo download successful
fi

Den Eltern und subshell kommunizieren, durch den echo-Befehl. Sie können wählen Sie eine einfach zu parsende text für die Eltern-shell. Diese Methode wird nicht brechen Ihre normale Art zu denken, nur, dass Sie zu tun haben, einige post-processing. Sie können mit grep, sed, awk, und mehr zu tun.

InformationsquelleAutor Kemin Zhou

-1

Wie wäre es mit einer sehr einfachen Methode

    +call your while loop in a function 
     - set your value inside (nonsense, but shows the example)
     - return your value inside 
    +capture your value outside
    +set outside
    +display outside


    #!/bin/bash
    # set -e
    # set -u
    # No idea why you need this, not using here

    foo=0
    bar="hello"

    if [[ "$bar" == "hello" ]]
    then
        foo=1
        echo "Setting  \$foo to $foo"
    fi

    echo "Variable \$foo after if statement: $foo"

    lines="first line\nsecond line\nthird line"

    function my_while_loop
    {

    echo -e $lines | while read line
    do
        if [[ "$line" == "second line" ]]
        then
        foo=2; return 2;
        echo "Variable \$foo updated to $foo inside if inside while loop"
        fi

        echo -e $lines | while read line
do
    if [[ "$line" == "second line" ]]
    then
    foo=2;          
    echo "Variable \$foo updated to $foo inside if inside while loop"
    return 2;
    fi

    # Code below won't be executed since we returned from function in 'if' statement
    # We aready reported the $foo var beint set to 2 anyway
    echo "Value of \$foo in while loop body: $foo"

done
}

    my_while_loop; foo="$?"

    echo "Variable \$foo after while loop: $foo"


    Output:
    Setting  $foo 1
    Variable $foo after if statement: 1
    Value of $foo in while loop body: 1
    Variable $foo after while loop: 2

    bash --version

    GNU bash, version 3.2.51(1)-release (x86_64-apple-darwin13)
    Copyright (C) 2007 Free Software Foundation, Inc.

Vielleicht gibt es eine anständige Antwort, die unter der Oberfläche hier, aber Sie haben geschlachtet, die Formatierung auf den Punkt, dass es unangenehm, zu versuchen und zu Lesen.
Meinst du den original-code ist angenehm zu Lesen? (Habe ich einfach gefolgt :p)

InformationsquelleAutor Marcin

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.