Forzare bash ad espandere le variabili in una stringa caricata da un file

Sto cercando di capire come fare in modo che bash (force?) Espandi le variabili in una stringa (che è stata caricata da un file).

Ho un file chiamato "something.txt" con il contenuto:

hello $FOO world

Allora corro

export FOO=42
echo $(cat something.txt)

questo restituisce:

   hello $FOO world

Non ha espanso $ FOO anche se la variabile è stata impostata. Non riesco a valutare o generare il file - poiché proverà ad eseguirlo (non è eseguibile così com'è - voglio solo la stringa con le variabili interpolate).

Qualche idea?

Mi sono imbattuto in quella che penso sia LA risposta a questa domanda: il envsubstcomando.

envsubst < something.txt

Nel caso in cui non sia già disponibile nella tua distribuzione, è nel file

Pacchetto GNU gettext.

@Rockallite - Ho scritto un piccolo script wrapper per occuparmi del problema "\ $".

(A proposito, c'è una "funzionalità" di envsubst, spiegata su https://unix.stackexchange.com/a/294400/7088 per espandere solo alcune delle variabili nell'input, ma sono d'accordo sul fatto che sfuggire alle eccezioni sia molto di più conveniente.)

Ecco il mio script:

#! /bin/bash
      ## -*-Shell-Script-*-
CmdName=${0##*/}
Usage="usage: $CmdName runs envsubst, but allows '\$' to  keep variables from
    being expanded.
  With option   -sl   '\$' keeps the back-slash.
  Default is to replace  '\$' with '$'
"

if [[ $1 = -h ]]  ;then echo -e >&2  "$Usage" ; exit 1 ;fi
if [[ $1 = -sl ]] ;then  sl='\'  ; shift ;fi

sed 's/\\\$/\${EnVsUbDolR}/g' |  EnVsUbDolR=$sl\$  envsubst  "$@"

Molte delle risposte utilizzando evaleecho tipo di lavoro, ma si interrompono su varie cose, come più righe, tentativi di sfuggire ai meta-caratteri della shell, fughe all'interno del modello non destinato ad essere espanso da bash, ecc.

Ho avuto lo stesso problema e ho scritto questa funzione di shell, che per quanto posso dire, gestisce tutto correttamente. Questo rimuoverà ancora solo le nuove righe finali dal modello, a causa delle regole di sostituzione dei comandi di bash, ma non ho mai scoperto che sia un problema finché tutto il resto rimane intatto.

apply_shell_expansion() {
    declare file="$1"
    declare data=$(< "$file")
    declare delimiter="__apply_shell_expansion_delimiter__"
    declare command="cat <<$delimiter"$'\n'"$data"$'\n'"$delimiter"
    eval "$command"
}

Ad esempio, puoi usarlo in questo modo con uno parameters.cfgscript di shell che imposta solo le variabili e template.txtun modello che utilizza tali variabili:

. parameters.cfg
printf "%s\n" "$(apply_shell_expansion template.txt)" > result.txt

In pratica, lo uso come una sorta di sistema di template leggero.

Puoi provare

echo $(eval echo $(cat something.txt))

Non vuoi stampare ogni riga, vuoi valutarla in modo che Bash possa eseguire sostituzioni di variabili.

FOO=42
while read; do
    eval echo "$REPLY"
done < something.txt

Vedere help evalo il manuale di Bash per ulteriori informazioni.

Un altro approccio (che sembra icky, ma lo metto comunque qui):

Scrivi il contenuto di something.txt in un file temporaneo, con un'istruzione echo racchiusa attorno ad esso:

something=$(cat something.txt)

echo "echo \"" > temp.out
echo "$something" >> temp.out
echo "\"" >> temp.out

quindi restituiscilo a una variabile:

RESULT=$(source temp.out)

e $ RESULT avrà tutto espanso. Ma sembra così sbagliato!

Se vuoi solo espandere i riferimenti alle variabili (un obiettivo che avevo per me stesso) puoi fare quanto segue.

contents="$(cat something.txt)"
echo $(eval echo \"$contents\")

(Le virgolette con escape intorno a $ contenuti sono fondamentali qui)

1. Se qualcosa.txt ha solo una riga, un bashmetodo, (una versione più breve della risposta "icky" di Michael Neale ), usando la sostituzione di processo e comando :

   FOO=42 . <(echo -e echo $(<something.txt))
   

   Produzione:

   hello 42 world
   

   Nota che exportnon è necessario.

2. Se qualcosa.txt ha una o più righe, un metodo di valutazione GNU :sed e

   FOO=42 sed 's/"/\\\"/g;s/.*/echo "&"/e' something.txt
   

Soluzione seguente:

• consente la sostituzione di variabili definite

• lascia inalterati i segnaposto delle variabili non definiti. Ciò è particolarmente utile durante le distribuzioni automatiche.

• supporta la sostituzione delle variabili nei seguenti formati:

  ${var_NAME}

  $var_NAME

• segnala quali variabili non sono definite nell'ambiente e restituisce il codice di errore per tali casi

    TARGET_FILE=someFile.txt;
    ERR_CNT=0;

    for VARNAME in $(grep -P -o -e '\$[\{]?(\w+)*[\}]?' ${TARGET_FILE} | sort -u); do     
      VAR_VALUE=${!VARNAME};
      VARNAME2=$(echo $VARNAME| sed -e 's|^\${||g' -e 's|}$||g' -e 's|^\$||g' );
      VAR_VALUE2=${!VARNAME2};

      if [ "xxx" = "xxx$VAR_VALUE2" ]; then
         echo "$VARNAME is undefined ";
         ERR_CNT=$((ERR_CNT+1));
      else
         echo "replacing $VARNAME with $VAR_VALUE2" ;
         sed -i "s|$VARNAME|$VAR_VALUE2|g" ${TARGET_FILE}; 
      fi      
    done

    if [ ${ERR_CNT} -gt 0 ]; then
        echo "Found $ERR_CNT undefined environment variables";
        exit 1 
    fi

$ eval echo $(cat something.txt)
hello 42 world
$ bash --version
GNU bash, version 3.2.57(1)-release (x86_64-apple-darwin17)
Copyright (C) 2007 Free Software Foundation, Inc.

foo=45
file=something.txt       # in a file is written: Hello $foo world!
eval echo $(cat $file)

envsubst è un'ottima soluzione (vedi la risposta di LenW) se il contenuto che stai sostituendo è di lunghezza "ragionevole".

Nel mio caso, dovevo sostituire il contenuto di un file per sostituire il nome della variabile. envsubstrichiede che il contenuto venga esportato come variabili di ambiente e bash ha un problema durante l'esportazione di variabili di ambiente che sono più di un megabyte o giù di lì.

soluzione awk

Usando la soluzione di cuonglm da una domanda diversa:

needle="doc1_base64" # The "variable name" in the file. (A $ is not needed.)
needle_file="doc1_base64.txt" # Will be substituted for the needle 
haystack=$requestfile1 # File containing the needle
out=$requestfile2
awk "BEGIN{getline l < \"${needle_file}\"}/${needle}/{gsub(\"${needle}\",l)}1" $haystack > $out

Questa soluzione funziona anche per file di grandi dimensioni.

I seguenti lavori: bash -c "echo \"$(cat something.txt)"\"