J'ai cette chaîne multi-lignes (guillemets inclus):

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

Comment pourrais-je l'affecter à une variable en utilisant un hérédoc dans Bash?

Je dois préserver les nouvelles lignes.

Je ne veux pas échapper aux caractères de la chaîne, ce serait ennuyeux ...

Vous pouvez éviter une utilisation inutile catet mieux gérer les citations incompatibles avec ceci:

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

Si vous ne citez pas la variable lorsque vous l'échoz, les sauts de ligne sont perdus. Le citer les conserve:

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

Si vous souhaitez utiliser l'indentation pour la lisibilité dans le code source, utilisez un tiret après les moins. L'indentation doit être effectuée en utilisant uniquement des tabulations (pas d'espaces).

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

Si, à la place, vous souhaitez conserver les onglets dans le contenu de la variable résultante, vous devez supprimer l'onglet de IFS. Le marqueur terminal pour ici doc ( EOF) ne doit pas être mis en retrait.

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

Des onglets peuvent être insérés sur la ligne de commande en appuyant sur Ctrl- V Tab. Si vous utilisez un éditeur, selon celui-ci, cela peut également fonctionner ou vous devrez peut-être désactiver la fonctionnalité qui convertit automatiquement les tabulations en espaces.

Utilisez $ () pour affecter la sortie de catà votre variable comme ceci:

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

Assurez-vous de délimiter le début END_HEREDOC avec des guillemets simples.

Notez que la fin du délimiteur hérédoc END_HEREDOC doit être seul sur la ligne (par conséquent, la parenthèse de fin se trouve sur la ligne suivante).

Grâce à @ephemient pour la réponse.

il s'agit d'une variante de la méthode Dennis, plus élégante dans les scripts.

définition de la fonction:

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

usage:

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

echo "$VAR"

prendre plaisir

ps a fait une version en «boucle de lecture» pour les shells qui ne sont pas compatibles read -d. devrait travailler avec set -euet contre - apostrophes non appariés , mais pas testé très bien:

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

VAR=<<END
abc
END

ne fonctionne pas parce que vous redirigez stdin vers quelque chose qui ne vous intéresse pas, à savoir l'affectation

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

fonctionne, mais il y a un back-tic là-dedans qui peut vous empêcher d'utiliser cela. De plus, vous devriez vraiment éviter d'utiliser des backticks, il est préférable d'utiliser la notation de substitution de commande $(..).

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

Il n'y a toujours pas de solution qui préserve les nouvelles lignes.

Ce n'est pas vrai - vous êtes probablement juste trompé par le comportement de l'écho:

echo $VAR # strips newlines

echo "$VAR" # preserves newlines

En dérivant la réponse de Neil , vous n'avez souvent pas besoin de var du tout, vous pouvez utiliser une fonction de la même manière qu'une variable et c'est beaucoup plus facile à lire que les readsolutions en ligne ou basées.

$ 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 tableau est une variable, donc dans ce cas, le mapfile fonctionnera

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

Ensuite, vous pouvez imprimer comme ceci

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

affecter une valeur hérédoc à une variable

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

utilisé comme argument d'une commande

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

Je me suis retrouvé à devoir lire une chaîne contenant NULL, alors voici une solution qui lira tout ce vous lui lancerez. Bien que si vous avez réellement affaire à NULL, vous devrez vous en occuper au niveau hexadécimal.

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

Preuve:

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

Exemple HEREDOC (avec ^ 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

Merci à la réponse de dimo414 , cela montre comment fonctionne sa grande solution et montre que vous pouvez également avoir facilement des guillemets et des variables dans le texte:

exemple de sortie

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