Tengo esta cadena de varias líneas (citas incluidas):

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

¿Cómo lo asignaría a una variable usando un heredoc en Bash?

Necesito preservar nuevas líneas.

No quiero escapar de los caracteres en la cadena, eso sería molesto ...

Puede evitar un uso inútil de cat y manejar mejor las citas no coincidentes con esto:

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

Si no cita la variable cuando la repite, se pierden las nuevas líneas. Citarlo los preserva:

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

Si desea utilizar la sangría para facilitar la lectura en el código fuente, use un guión después de la menor thans. La sangría debe hacerse usando solo pestañas (sin espacios).

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

Si, en cambio, desea conservar las pestañas en el contenido de la variable resultante, debe eliminar la pestaña de IFS. El marcador de terminal para el documento aquí (EOF ) no debe tener sangría.

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

Las pestañas se pueden insertar en la línea de comando presionando Ctrl- V Tab. Si está utilizando un editor, dependiendo de cuál, eso también puede funcionar o puede que tenga que desactivar la función que convierte automáticamente las pestañas en espacios.

Use $ () para asignar la salida de cata su variable de esta manera:

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

Asegurarse de delimitar el inicio de END_HEREDOC con comillas simples.

Tenga en cuenta que terminando aquí delimitador END_HEREDOC debe estar solo en la línea (por lo tanto, el paréntesis final está en la línea siguiente).

Gracias a @ephemientpor la respuesta.

Esta es una variación del método Dennis, se ve más elegante en los guiones.

definición de función:

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

uso:

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

echo "$VAR"

disfrutar

ps hizo un versión de 'lectura de bucle' para shells que no son compatibles read -d. debe trabajar con set -euy acentos abiertos no apareados , pero no han sido evaluados muy bien:

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

VAR=<<END
abc
END

no funciona porque está redirigiendo stdin a algo que no le importa, es decir, la asignación

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

funciona, pero hay un tic de respaldo que puede evitar que lo uses. Además, realmente debe evitar el uso de backticks, es mejor usar la notación de sustitución de comandos $(..).

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

Todavía no hay una solución que conserve nuevas líneas.

Esto no es cierto: probablemente te esté engañando el comportamiento del eco:

echo $VAR # strips newlines

echo "$VAR" # preserves newlines

Ramificando la respuesta de Neil , a menudo no necesita una var en absoluto, puede usar una función de la misma manera que una variable y es mucho más fácil de leer que las readsoluciones en línea o basadas.

$ 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"''

Una matriz es una variable, por lo que en ese caso funcionará mapfile

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

Entonces puedes imprimir así

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

asignar un valor heredoc a una variable

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

usado como argumento de un comando

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

Me encontré teniendo que leer una cadena con NULL, así que aquí hay una solución que leerá todo lo que le arrojes. Aunque si en realidad estás lidiando con NULL, tendrás que lidiar con eso en el nivel hexadecimal.

$ 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 )
}

Prueba:

$ . 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"
$ 

Ejemplo de 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

Gracias a la respuesta de dimo414 , esto muestra cómo funciona su gran solución, y muestra que también puede tener comillas y variables en el texto fácilmente:

salida de ejemplo

$ ./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