Come leggere un file in una variabile nella shell?

Voglio leggere un file e salvarlo in una variabile, ma devo conservare la variabile e non solo stampare il file. Come posso fare questo? Ho scritto questo script ma non è proprio quello di cui avevo bisogno:

#!/bin/sh
while read LINE  
do  
  echo $LINE  
done <$1  
echo 11111-----------  
echo $LINE  

Nel mio script, posso dare il nome del file come parametro, quindi, se il file contiene "aaaa", per esempio, lo stampa:

aaaa
11111-----

Ma questo stampa semplicemente il file sullo schermo e voglio salvarlo in una variabile! C'è un modo semplice per farlo?

In multipiattaforma, il minimo comune denominatore shsi utilizza:

#!/bin/sh
value=`cat config.txt`
echo "$value"

In basho zsh, per leggere un intero file in una variabile senza richiamare cat:

#!/bin/bash
value=$(<config.txt)
echo "$value"

Invocare catin basho zshper trangugiare un file sarebbe considerato un inutile Uso di Cat .

Si noti che non è necessario citare la sostituzione del comando per preservare le nuove righe.

Vedi: Wiki di Bash Hacker - Sostituzione comandi - Specialità .

Se vuoi leggere l'intero file in una variabile:

#!/bin/bash
value=`cat sources.xml`
echo $value

Se vuoi leggerlo riga per riga:

while read line; do    
    echo $line    
done < file.txt

Due insidie ​​importanti

che finora sono state ignorate da altre risposte:

1. Trailing rimozione di newline dall'espansione dei comandi
2. Rimozione del carattere NUL

Trailing rimozione di newline dall'espansione dei comandi

Questo è un problema per:

value="$(cat config.txt)"

soluzioni di tipo, ma non per readsoluzioni basate.

L'espansione dei comandi rimuove le nuove righe finali:

S="$(printf "a\n")"
printf "$S" | od -tx1

Uscite:

0000000 61
0000001

Questo rompe il metodo ingenuo di lettura dai file:

FILE="$(mktemp)"
printf "a\n\n" > "$FILE"
S="$(<"$FILE")"
printf "$S" | od -tx1
rm "$FILE"

Soluzione alternativa POSIX: aggiungere un ulteriore carattere all'espansione del comando e rimuoverlo in seguito:

S="$(cat $FILE; printf a)"
S="${S%a}"
printf "$S" | od -tx1

Uscite:

0000000 61 0a 0a
0000003

Soluzione quasi POSIX: codifica ASCII. Vedi sotto.

Rimozione del carattere NUL

Non esiste un modo Bash sano per memorizzare i caratteri NUL in variabili .

Ciò influisce sia sull'espansione che sulle readsoluzioni e non conosco alcuna soluzione alternativa.

Esempio:

printf "a\0b" | od -tx1
S="$(printf "a\0b")"
printf "$S" | od -tx1

Uscite:

0000000 61 00 62
0000003

0000000 61 62
0000002

Ah, il nostro NUL è sparito!

soluzioni alternative:

• Codifica ASCII. Vedi sotto.

• usa $""letterali di estensione bash :

  S=$"a\0b"
  printf "$S" | od -tx1
  

  Funziona solo con valori letterali, quindi non è utile per leggere da file.

Soluzione alternativa per le insidie

Archivia una versione codificata uuencode base64 del file nella variabile e decodifica prima di ogni utilizzo:

FILE="$(mktemp)"
printf "a\0\n" > "$FILE"
S="$(uuencode -m "$FILE" /dev/stdout)"
uudecode -o /dev/stdout <(printf "$S") | od -tx1
rm "$FILE"

Produzione:

0000000 61 00 0a
0000003

uuencode e udecode sono POSIX 7 ma non in Ubuntu 12.04 per impostazione predefinita ( sharutilspacchetto) ... Non vedo un'alternativa POSIX 7 per l' <()estensione di sostituzione del processo bash tranne la scrittura in un altro file ...

Naturalmente, questo è lento e scomodo, quindi immagino che la vera risposta sia: non usare Bash se il file di input può contenere caratteri NUL.

questo funziona per me: v=$(cat <file_path>) echo $v

Come Ciro Santilli nota, usando le sostituzioni di comando si lasceranno cadere nuove righe finali. La loro soluzione alternativa all'aggiunta di caratteri finali è ottima, ma dopo averlo usato per un po 'di tempo ho deciso che avevo bisogno di una soluzione che non usasse affatto la sostituzione dei comandi.

Il mio approccio ora usa readinsieme al flagprintf incorporato per leggere il contenuto di stdin direttamente in una variabile.-v

# Reads stdin into a variable, accounting for trailing newlines. Avoids needing a subshell or
# command substitution.
read_input() {
  # Use unusual variable names to avoid colliding with a variable name
  # the user might pass in (notably "contents")
  : "${1:?Must provide a variable to read into}"
  if [[ "$1" == '_line' || "$1" == '_contents' ]]; then
    echo "Cannot store contents to $1, use a different name." >&2
    return 1
  fi

  local _line _contents
   while read -r _line; do
     _contents="${_contents}${_line}"$'\n'
   done
   _contents="${_contents}${_line}" # capture any content after the last newline
   printf -v "$1" '%s' "$_contents"
}

Questo supporta input con o senza newline finali.

Esempio di utilizzo:

$ read_input file_contents < /tmp/file
# $file_contents now contains the contents of /tmp/file

Puoi accedere a 1 linea alla volta per il ciclo

#!/bin/bash -eu

#This script prints contents of /etc/passwd line by line

FILENAME='/etc/passwd'
I=0
for LN in $(cat $FILENAME)
do
    echo "Line number $((I++)) -->  $LN"
done

Copia l'intero contenuto su File (ad esempio line.sh); Eseguire

chmod +x line.sh
./line.sh