Come leggere da un file o STDIN in Bash?

Il seguente script Perl ( my.pl) può leggere dal file sulla riga di comando args o da STDIN:

while (<>) {
   print($_);
}

perl my.plleggerà da STDIN, mentre perl my.pl a.txtleggerà da a.txt. Questo è molto conveniente

Ti chiedi c'è un equivalente in Bash?

La seguente soluzione legge da un file se lo script viene chiamato con un nome file come primo parametro, $1altrimenti dall'input standard.

while read line
do
  echo "$line"
done < "${1:-/dev/stdin}"

La sostituzione ${1:-...}prende $1se definito, altrimenti viene utilizzato il nome file dell'input standard del proprio processo.

Forse la soluzione più semplice è reindirizzare stdin con un operatore di reindirizzamento unito:

#!/bin/bash
less <&0

Stdin è il descrittore di file zero. Quanto sopra invia l'input reindirizzato al tuo script bash nello stdin di less.

Ulteriori informazioni sul reindirizzamento del descrittore di file .

Ecco il modo più semplice:

#!/bin/sh
cat -

Uso:

$ echo test | sh my_script.sh
test

Per assegnare stdin alla variabile, puoi usare: STDIN=$(cat -)o semplicemente STDIN=$(cat)come operatore non è necessario (come da commento @ mklement0 ).

Per analizzare ciascuna riga dall'input standard , provare il seguente script:

#!/bin/bash
while IFS= read -r line; do
  printf '%s\n' "$line"
done

Per leggere dal file o stdin (se l'argomento non è presente), è possibile estenderlo a:

#!/bin/bash
file=${1--} # POSIX-compliant; ${1:--} can be used either.
while IFS= read -r line; do
  printf '%s\n' "$line" # Or: env POSIXLY_CORRECT=1 echo "$line"
done < <(cat -- "$file")

Appunti:

^{- read -r- Non trattare un carattere barra rovesciata in alcun modo speciale. Considerare ogni barra rovesciata come parte della riga di input.}

^{- Senza impostazione IFS, per impostazione predefinita le sequenze di Spacee Taball'inizio e alla fine delle righe vengono ignorate (tagliate).}

^{- Uso printfinvece di echoevitare di stampare righe vuote quando la linea è costituita da un singolo -e, -no -E. Tuttavia, esiste una soluzione alternativa env POSIXLY_CORRECT=1 echo "$line"che utilizza l' esecuzione della GNU esternaecho che la supporta. Vedi: Come echo "-e"?}

Vedi: Come leggere stdin quando non vengono passati argomenti? su stackoverflow SE

Penso che questo sia il modo semplice:

$ cat reader.sh
#!/bin/bash
while read line; do
  echo "reading: ${line}"
done < /dev/stdin

-

$ cat writer.sh
#!/bin/bash
for i in {0..5}; do
  echo "line ${i}"
done

-

$ ./writer.sh | ./reader.sh
reading: line 0
reading: line 1
reading: line 2
reading: line 3
reading: line 4
reading: line 5

La echosoluzione aggiunge nuove righe ogni volta che IFSinterrompe il flusso di input. La risposta di @ fgm può essere modificata un po ':

cat "${1:-/dev/stdin}" > "${2:-/dev/stdout}"

Il ciclo Perl nella domanda legge da tutti gli argomenti del nome file sulla riga di comando o dall'input standard se non viene specificato alcun file. Le risposte che vedo sembrano elaborare un singolo file o input standard se non è stato specificato alcun file.

Anche se spesso deriso accuratamente come UUOC (Uso inutile di cat), ci sono momenti in cui catè lo strumento migliore per il lavoro ed è discutibile che questo sia uno di questi:

cat "$@" |
while read -r line
do
    echo "$line"
done

L'unico aspetto negativo di questo è che crea una pipeline in esecuzione in una sotto-shell, quindi cose come le assegnazioni di variabili nel whileciclo non sono accessibili al di fuori della pipeline. Il bashmodo per aggirare questo è Sostituzione processo :

while read -r line
do
    echo "$line"
done < <(cat "$@")

Questo lascia il whileloop in esecuzione nella shell principale, quindi le variabili impostate nel loop sono accessibili al di fuori del loop.

Il comportamento di Perl, con il codice indicato nell'OP, può accettare nessuno o più argomenti e se un argomento è un singolo trattino, -questo viene inteso come stdin. Inoltre, è sempre possibile avere il nome file con $ARGV. Nessuna delle risposte fornite finora imita davvero il comportamento di Perl sotto questi aspetti. Ecco una pura possibilità di Bash. Il trucco è usare in modo execappropriato.

#!/bin/bash

(($#)) || set -- -
while (($#)); do
   { [[ $1 = - ]] || exec < "$1"; } &&
   while read -r; do
      printf '%s\n' "$REPLY"
   done
   shift
done

Il nome file è disponibile in $1.

Se non viene fornito alcun argomento, impostiamo artificialmente -il primo parametro posizionale. Quindi eseguiamo il ciclo sui parametri. Se un parametro non lo è -, reindirizziamo l'input standard dal nome file con exec. Se questo reindirizzamento ha esito positivo, eseguiamo il loop con un whileloop. Sto usando la REPLYvariabile standard e in questo caso non è necessario reimpostare IFS. Se vuoi un altro nome, devi reimpostarlo in questo IFSmodo (a meno che, ovviamente, non lo desideri e sappia cosa stai facendo):

while IFS= read -r line; do
    printf '%s\n' "$line"
done

Più accuratamente...

while IFS= read -r line ; do
    printf "%s\n" "$line"
done < file

Si prega di provare il seguente codice:

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

Il codice ${1:-/dev/stdin}capirà solo il primo argomento, quindi, che ne dici di questo.

ARGS='$*'
if [ -z "$*" ]; then
  ARGS='-'
fi
eval "cat -- $ARGS" | while read line
do
   echo "$line"
done

Non trovo accettabile nessuna di queste risposte. In particolare, la risposta accettata gestisce solo il primo parametro della riga di comando e ignora il resto. Il programma Perl che sta tentando di emulare gestisce tutti i parametri della riga di comando. Quindi la risposta accettata non risponde nemmeno alla domanda. Altre risposte usano estensioni bash, aggiungono comandi "cat" non necessari, funzionano solo per il semplice caso di eco dell'input all'output o sono semplicemente inutilmente complicate.

Tuttavia, devo dare loro un po 'di credito perché mi hanno dato alcune idee. Ecco la risposta completa:

#!/bin/sh

if [ $# = 0 ]
then
        DEFAULT_INPUT_FILE=/dev/stdin
else
        DEFAULT_INPUT_FILE=
fi

# Iterates over all parameters or /dev/stdin
for FILE in "$@" $DEFAULT_INPUT_FILE
do
        while IFS= read -r LINE
        do
                # Do whatever you want with LINE here.
                echo $LINE
        done < "$FILE"
done

Ho combinato tutte le risposte sopra e ho creato una funzione shell adatta alle mie esigenze. Questo proviene da un terminale Cygwin delle mie 2 macchine Windows 10 in cui avevo una cartella condivisa tra di loro. Devo essere in grado di gestire quanto segue:

• cat file.cpp | tx
• tx < file.cpp
• tx file.cpp

Laddove viene specificato un nome file specifico, è necessario utilizzare lo stesso nome file durante la copia. Laddove il flusso di dati di input è stato reindirizzato, è necessario generare un nome file temporaneo con l'ora, i minuti e i secondi. La cartella principale condivisa ha sottocartelle dei giorni della settimana. Questo è per scopi organizzativi.

Ecco, la sceneggiatura definitiva per le mie esigenze:

tx ()
{
  if [ $# -eq 0 ]; then
    local TMP=/tmp/tx.$(date +'%H%M%S')
    while IFS= read -r line; do
        echo "$line"
    done < /dev/stdin > $TMP
    cp $TMP //$OTHER/stargate/$(date +'%a')/
    rm -f $TMP
  else
    [ -r $1 ] && cp $1 //$OTHER/stargate/$(date +'%a')/ || echo "cannot read file"
  fi
}

Se c'è un modo che puoi vedere per ottimizzare ulteriormente questo, vorrei sapere.

Il seguente funziona con lo standard sh(testato con dashsu Debian) ed è abbastanza leggibile, ma è una questione di gusti:

if [ -n "$1" ]; then
    cat "$1"
else
    cat
fi | commands_and_transformations

Dettagli: se il primo parametro non è vuoto, allora catquel file, altrimenti catinput standard. Quindi l'output dell'intera ifistruzione viene elaborato dal commands_and_transformations.

Questo è facile da usare sul terminale:

$ echo '1\n2\n3\n' | while read -r; do echo $REPLY; done
1
2
3

Che ne dite di

for line in `cat`; do
    something($line);
done