Ho questa stringa multilinea (virgolette incluse):

abc'asdf"
$(dont-execute-this)
foo"bar"''

Come lo assegnerei a una variabile usando un heredoc in Bash?

Devo preservare le nuove righe.

Non voglio sfuggire ai personaggi nella stringa, sarebbe fastidioso ...

Puoi evitare un uso inutile cate gestire meglio le virgolette non corrispondenti con questo:

$ read -r -d '' VAR <<'EOF'
abc'asdf"
$(dont-execute-this)
foo"bar"''
EOF

Se non si cita la variabile quando la si fa eco, le nuove righe vengono perse. Citando, li conserva:

$ echo "$VAR"
abc'asdf"
$(dont-execute-this)
foo"bar"''

Se si desidera utilizzare il rientro per la leggibilità nel codice sorgente, utilizzare un trattino dopo i meno di. Il rientro deve essere eseguito utilizzando solo le schede (senza spazi).

$ read -r -d '' VAR <<-'EOF'
    abc'asdf"
    $(dont-execute-this)
    foo"bar"''
    EOF
$ echo "$VAR"
abc'asdf"
$(dont-execute-this)
foo"bar"''

Se, invece, desideri conservare le schede nei contenuti della variabile risultante, devi rimuovere la scheda IFS. Il marker terminale per here doc ( EOF) non deve essere rientrato.

$ IFS='' read -r -d '' VAR <<'EOF'
    abc'asdf"
    $(dont-execute-this)
    foo"bar"''
EOF
$ echo "$VAR"
    abc'asdf"
    $(dont-execute-this)
    foo"bar"''

Le schede possono essere inserite dalla riga di comando premendo Ctrl- V Tab. Se si utilizza un editor, a seconda di quale, potrebbe funzionare o potrebbe essere necessario disattivare la funzione che converte automaticamente le schede in spazi.

Usa $ () per assegnare l'output della cattua variabile in questo modo:

VAR=$(cat <<'END_HEREDOC'
abc'asdf"
$(dont-execute-this)
foo"bar"''
END_HEREDOC
)

# this will echo variable with new lines intact
echo "$VAR"
# this will echo variable without new lines (changed to space character)
echo $VAR

Assicurati di delimitare l'avvio di END_HEREDOC con virgolette singole.

Nota che il delimitatore ereditario finale END_HEREDOCdeve essere solo sulla linea (quindi la parentesi finale è sulla riga successiva).

Grazie @ephemientper la risposta.

questa è la variazione del metodo Dennis, sembra più elegante negli script.

definizione della funzione:

define(){ IFS='\n' read -r -d '' ${1} || true; }

utilizzo:

define VAR <<'EOF'
abc'asdf"
$(dont-execute-this)
foo"bar"''
EOF

echo "$VAR"

godere

ps ha creato una versione 'read loop' per shell che non supportano read -d. dovrebbe funzionare con set -eue apici inversi spaiati , ma non testato molto bene:

define(){ o=; while IFS="\n" read -r a; do o="$o$a"'
'; done; eval "$1=\$o"; }

VAR=<<END
abc
END

non funziona perché stai reindirizzando lo stdin a qualcosa che non ti interessa, vale a dire il compito

export A=`cat <<END
sdfsdf
sdfsdf
sdfsfds
END
` ; echo $A

funziona, ma c'è un back-tic che potrebbe impedirti di usarlo. Inoltre, dovresti davvero evitare di usare i backtick, è meglio usare la notazione di sostituzione dei comandi $(..).

export A=$(cat <<END
sdfsdf
sdfsdf
sdfsfds
END
) ; echo $A

Non esiste ancora una soluzione che preservi le nuove linee.

Questo non è vero - probabilmente stai solo venendo fuorviato dal comportamento dell'eco:

echo $VAR # strips newlines

echo "$VAR" # preserves newlines

Diramando la risposta di Neil , spesso non hai bisogno di una var, puoi usare una funzione più o meno allo stesso modo di una variabile ed è molto più facile da leggere rispetto alle readsoluzioni in linea o basate.

$ complex_message() {
  cat <<'EOF'
abc'asdf"
$(dont-execute-this)
foo"bar"''
EOF
}

$ echo "This is a $(complex_message)"
This is a abc'asdf"
$(dont-execute-this)
foo"bar"''

Un array è una variabile, quindi in questo caso mapfile funzionerà

mapfile y <<z
abc'asdf"
$(dont-execute-this)
foo"bar"''
z

Quindi puoi stampare in questo modo

printf %s "${y[@]}"

assegnare un valore ereditario a una variabile

VAR="$(cat <<'VAREOF'
abc'asdf"
$(dont-execute-this)
foo"bar"''
VAREOF
)"

usato come argomento di un comando

echo "$(cat <<'SQLEOF'
xxx''xxx'xxx'xx  123123    123123
abc'asdf"
$(dont-execute-this)
foo"bar"''
SQLEOF
)"

Mi sono ritrovato a dover leggere una stringa con NULL, quindi ecco una soluzione che leggerà tutto ciò che ci lancerai. Anche se in realtà hai a che fare con NULL, dovrai affrontarlo a livello esadecimale.

$ cat> read.dd.sh

read.dd() {
     buf= 
     while read; do
        buf+=$REPLY
     done < <( dd bs=1 2>/dev/null | xxd -p )

     printf -v REPLY '%b' $( sed 's/../ \\\x&/g' <<< $buf )
}

Prova:

$ . read.dd.sh
$ read.dd < read.dd.sh
$ echo -n "$REPLY" > read.dd.sh.copy
$ diff read.dd.sh read.dd.sh.copy || echo "File are different"
$ 

Esempio HEREDOC (con ^ J, ^ M, ^ I):

$ read.dd <<'HEREDOC'
>       (TAB)
>       (SPACES)
(^J)^M(^M)
> DONE
>
> HEREDOC

$ declare -p REPLY
declare -- REPLY="  (TAB)
      (SPACES)
(^M)
DONE

"

$ declare -p REPLY | xxd
0000000: 6465 636c 6172 6520 2d2d 2052 4550 4c59  declare -- REPLY
0000010: 3d22 0928 5441 4229 0a20 2020 2020 2028  =".(TAB).      (
0000020: 5350 4143 4553 290a 285e 4a29 0d28 5e4d  SPACES).(^J).(^M
0000030: 290a 444f 4e45 0a0a 220a                 ).DONE

Grazie alla risposta di dimo414 , questo mostra come funziona la sua ottima soluzione e mostra che puoi avere facilmente citazioni e variabili nel testo:

esempio di output

$ ./test.sh

The text from the example function is:
  Welcome dev: Would you "like" to know how many 'files' there are in /tmp?

  There are "      38" files in /tmp, according to the "wc" command

test.sh

#!/bin/bash

function text1()
{
  COUNT=$(\ls /tmp | wc -l)
cat <<EOF

  $1 Would you "like" to know how many 'files' there are in /tmp?

  There are "$COUNT" files in /tmp, according to the "wc" command

EOF
}

function main()
{
  OUT=$(text1 "Welcome dev:")
  echo "The text from the example function is: $OUT"
}

main

$TEST="ok"
read MYTEXT <<EOT
this bash trick
should preserve
newlines $TEST
long live perl
EOT
echo -e $MYTEXT