Comment attribuer une heredoc valeur à une variable en Bash?

J'ai cette multi-ligne de chaîne (guillemets compris):

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

Comment aurais-je l'attribuer à une variable à l'aide d'un heredoc en Bash?

J'ai besoin de conserver les retours à la ligne.

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

J'ai juste essayé une heredoc cession avec une seule cité 'EOF', avec échappé retours à la ligne (avec ` in the content: if the second line has cd commande, j'obtiens en retour: ".sh: ligne X: cd: command not found"; mais si je double-quote "EOF"; puis des variables bash ${A} ne pas être préservé comme des chaînes de caractères (ils se élargie); mais ensuite, des sauts de lignes sont préservées et, je n'ai pas de problème d'exécution d'une commande avec cd en deuxième ligne (et à la fois des "expressions du FOLKLORE" et "expressions du FOLKLORE" semblent bien jouer aussi avec eval, pour l'exécution d'un ensemble de commandes stockées dans une variable de type string). Cheers!
... et pour ajouter à mon commentaire précédent: bash commentaires "#" en double-qouted "EOF" variable, si elle est appelée par eval $VAR, seront la cause de tout le reste du script à être commentée, comme ici, $VAR sera considéré comme une seule ligne; pour être en mesure d'utiliser bash # commentaires multilignes script, double-quote également variable dans le eval call: eval "$VAR"`.
J'ai eu des problèmes avec eval ith cette méthode, mais qui n'a pas suivi vers le bas comme elle faisait partie d'un paquet qui evals certaines variables définies dans le fichier config. Message d'erreur était: /usr/lib/network/network: eval: line 153: syntax error: unexpected end of file. J'ai tout juste de passer à une autre solution.

InformationsquelleAutor Neil | 2009-07-22

bash heredoc

442

Vous pouvez éviter une inutile l'utilisation de cat et poignée incompatibles citations mieux avec cette:
```
$ read -r -d '' VAR <<'EOF'
abc'asdf"
$(dont-execute-this)
foo"bar"''
EOF
```
Si vous ne citez pas la variable lorsque vous faites l'écho, les retours à la ligne sont perdues. Citant les conserve:
```
$ echo "$VAR"
abc'asdf"
$(dont-execute-this)
foo"bar"''
```
Si vous souhaitez utiliser l'indentation pour des raisons de lisibilité dans le code source, utilisez un tiret après le moins thans. Le retrait doit être fait en utilisant uniquement les onglets (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, au lieu de cela, vous voulez préserver les onglets dans le contenu de la variable qui en découle, vous devez supprimer l'onglet de IFS. Le terminal de marqueur pour la doc ici (EOF) ne doit pas être 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"''
```
Onglets peuvent être insérés à la ligne de commande en appuyant sur Ctrl-V Tab. Si vous utilisez un éditeur, en fonction de celui qui, qui peut également fonctionner ou vous devrez peut-être désactiver la fonction qui convertit automatiquement les tabulations en espaces.
- Ceci est utile pour intégrer multi-ligne programmes perl dans des variables bash lorsqu'il est combiné avec le -r option pour conserver les barres obliques inverses ainsi.
- Vrai, read doivent presque toujours -r. J'ai oublié de l'inclure (fixe).
- Merci pour le compliment!
- Je pense qu'il vaut la peine de mentionner que si vous avez set -o errexit (un.k.un set -e) dans votre script et que vous utilisez ce, alors il sera de mettre fin à votre script car read renvoie une valeur non nulle code de retour quand elle atteint les expressions du FOLKLORE.
- C'est l'une des raisons pour lesquelles je n'utilisez jamais de set -e et recommande toujours à l'encontre de son utilisation. Il est préférable d'utiliser la bonne gestion d'erreur à la place. trap est votre ami. D'autres amis: else et || parmi d'autres.
- Comment dois-je faire cela tout en incluant le caractère de tabulation pour le retrait? Je sais que je peux juste utiliser de l'espace, mais est-ce possible?
- est-il une alternative à l'utilisation de la -d paramètre sur read? Je suis coincé à l'aide d'un environnement qui n'ont pas la -d option, mais je ne peux pas trouver une autre façon d'obtenir des read pour charger plusieurs lignes sans elle.
- Est l'évitement de cat vraiment la peine dans ce cas? L'affectation d'un heredoc à une variable de cat est bien connu de l'idiome. En quelque sorte, à l'aide de read dissimule des choses pour peu d'avantages à mon humble avis.
- Meh. Un avertissement de la part de quelqu'un qui a été d'essayer d'être trop intelligent (moi): read -rd'' VAR << EOF ne fonctionne pas, car VAR sera analysé dans le séparateur (et le heredoc finira dans $REPLY).
- C'est parce que vous ne disposez pas d'un espace entre d et la chaîne vide; bash s'effondre -rd'' simplement -rd avant read voit jamais de ses arguments, de sorte VAR est traitée comme argument de -d.
- correct. C'est ce que j'ai écrit, trop.
- Dans ce format, read sera de retour avec un code de sortie non nulle. Ce qui rend cette méthode de moins que l'idéal dans un script avec la vérification des erreurs est activé (par exemple set -e).
- href="http://mywiki.wooledge.org/BashFAQ/105" >set -e ne doit jamais être utilisé - faire une vérification d'erreur à la place
- c'était juste un exemple. Mon point est que la commande de lecture des rapports de l'échec lors de cette exécution.
- Est-il possible de l'utiliser et obtenir la substitution de variable? Je voudrais utiliser $variables dans mon multiligne chaîne.
- Supprimez les guillemets autour du nom de la heredoc. Cela permettra également de commande des substitutions pour être évaluées et affectera l'espace blanc de la manière que je l'ai indiqué dans ma réponse.
- Il est trop lent, car le shell appels read(2) pour chaque 1 octet dans le document.
- Pourquoi n'est $? == 1 après l'exécution de IFS='' read -r -d '' VAR <<'EOF' même s'il consomme un "expressions du FOLKLORE" au début de la ligne? Aucun moyen de contourner cela?
- Pour répondre à ma propre question, voir cette réponse (merci @ffledgling).
- Alors que je l'aime traping trop d'erreurs, lorsque vous travaillez sur un code partagé de la base, il n'est pas poli de modification à une norme (comme #!/bin/bash -eu). Donc, j'ai ajouté une note à la fin de cette excellente réponse.
- href="https://mywiki.wooledge.org/BashFAQ/105" >ne doit jamais être utilisé.
- que faire de ces arguments dire -r -d ? Je ne pouvais pas trouver dans man read. Exemple 3 a bien fonctionné dans mon cas.
- lire est sur le système d'exploitation de l'appel de fonction, donc il ne s'appliquent pas directement. Dans ce contexte, read est un Bash builtin et vous pouvez obtenir des informations à ce sujet à l'aide de help read ou man bash. L'option -r est d'accepter les barres obliques inverses, littéralement, au lieu de les utiliser pour échapper tous les caractères. Le -d option définit le premier caractère de l'argument comme délimiteur entre les enregistrements (lignes) au lieu de la valeur par défaut qui est de retour à la ligne. Dans l'exemple, je suis le délimiteur à une chaîne nulle.
- super merci beaucoup!!!
- Une petite note pour cette magnifique réponse: avant/après les lignes vides sont chomped par read sauf IFS=.
InformationsquelleAutor Dennis Williamson
189

Utiliser $() 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
```
Veillant à délimiter départ END_HEREDOC avec des guillemets simples.

Note que la fin de l'heredoc délimiteur END_HEREDOC doit être seul sur la ligne (d'où parenthèse de fin est sur la ligne suivante).

Grâce à @ephemient pour la réponse.
- En fait, celui-ci permet par le biais de citations dans certaines circonstances. J'ai réussi à le faire en Perl facilement...
- +1. C'est le plus lisible solution, au moins pour mes yeux. Il laisse le nom de la variable à l'extrême gauche de la page, au lieu de l'intégrer dans la commande de lecture.
- Lors de l'utilisation de cette construction, je vois les retours à la ligne sont convertis en $ (en dollars de caractère) ??
- Il y a un nitch: vous il ne faut pas laisser en blanc à côté du " = " signe.
- PSA: rappelez-vous que la variable doit être cité pour conserver les retours à la ligne. echo "$VAR" au lieu de echo $VAR.
- C'est sympa avec ash et OpenWRT où read ne prend pas en charge -d.
- Cela fonctionne avec set -e.
- Pour des raisons que je n'arrivons pas à comprendre, il échoue avec un "inattendu EOF" erreur si vous avez un non appariés backtick dans le heredoc.
- Déposer les heredoc, et il suffit d'utiliser $(cat) et appuyez sur Ctrl-D pour envoyer un EOF. Cela a l'avantage de permettre la "END_HEREDOC" pour éventuellement se produire dans le texte.
- Quel est l'avantage de citer 'END_HEREDOC'?
- il empêche l'expansion des variables.
- Aah, merci! @miken32
- C'est le shell-agnostique solution (si vous vous souciez de la portabilité) comme read est intégrée à Bash et pas forcément compatible avec Zsh.
- $(cat <<-'}' -- fin avec indenté }, suivie par ) sur la ligne suivante.
InformationsquelleAutor Neil
73

c'est la variation de Dennis méthode, semble plus élégant dans les scripts.

définition de la fonction:
```
define(){ IFS='\n' read -r -d '' ${1} || true; }
```
utilisation:
```
define VAR <<'EOF'
abc'asdf"
$(dont-execute-this)
foo"bar"''
EOF

echo "$VAR"
```
profiter de

p.s. faites un "lecture en boucle" en version pour les coques qui ne prennent pas en charge read -d. devrait fonctionner avec set -eu et non appariés backticks, mais pas testé très bien:
```
define(){ o=; while IFS="\n" read -r a; do o="$o$a"'
'; done; eval "$1=$o"; }
```
- Cela semble fonctionner que de façon superficielle. L'définir la fonction renverra une valeur de 1, et je ne suis pas tout à fait sûr de ce qui doit être corrigé.
- C'est également supérieure à la accepté de répondre, car il peut être modifié à l'appui de POSIX sh en plus de bash (un read boucle dans la fonction, afin d'éviter la -d '' bashism nécessaire pour conserver les retours à la ligne).
- À la différence du chat-dans-un-shell interne est exécuté option, cela fonctionne avec non appariés backticks dans le heredoc. Merci!!!!
- Cette solution fonctionne avec set -e ensemble, alors que la réponse choisie n'est pas. Il semble être à cause de http://unix.stackexchange.com/a/265151/20650
- comment le read boucle ressemblent effectivement à éviter la -d ''? Depuis la belle réponse de l'OP n'est certainement pas de travailler sur AIX.
- ajoutée "lecture en boucle" en version, mais n'ont pas accès à AIX pour le test, donc ymmv.
- p.s. de retour d'état a longtemps été corrigé
InformationsquelleAutor ttt
27

L'ajout de commentaire ici comme une réponse étant donné que je n'ai pas assez de points de rep pour commenter votre texte de la question.

Il n'y a toujours pas de solution qui préserve les retours à la ligne.

Ce n'est pas vrai, vous êtes probablement juste d'être induit en erreur par le comportement de l'écho:

echo $VAR # strips newlines

echo "$VAR" # preserves newlines
- L'obtention de rep sur stackoverflow est plus difficile que de la programmation bash. +1 de sympathie.
- C'est vraiment le comportement de la façon dont citant une variable œuvres. Sans les guillemets, il va insérer sous la forme de différents paramètres, de l'espace deliminated, tandis que les citations de l'ensemble du contenu de variable sera considérée comme un argument
InformationsquelleAutor patspam
27
```
VAR=<<END
abc
END
```
ne fonctionne pas parce que vous êtes rediriger stdin pour quelque chose qui ne se soucie pas d'elle, à savoir la cession
```
export A=`cat <<END
sdfsdf
sdfsdf
sdfsfds
END
` ; echo $A
```
fonctionne, mais il y a un arrière-tic qui peut vous arrêter de l'utilisation de ce. Aussi, vous devriez vraiment éviter d'utiliser des backticks, il est préférable d'utiliser la substitution de commande notation $(..).
```
export A=$(cat <<END
sdfsdf
sdfsdf
sdfsfds
END
) ; echo $A
```
- J'ai mis à jour ma question d'inclure $(exécutable). Aussi, comment faites-vous pour préserver les retours à la ligne?
- Si près... Utiliser $(cat <<'END' à la place. @Neil: Le dernier saut de ligne ne fera pas partie de la variable, mais le repos sera préservé.
- Il ne semble pas comme tout les retours à la ligne sont conservés. L'exécution de l'exemple ci-dessus, je vois: "sdfsdf sdfsdf sdfsfds"... ah! Mais l'écriture echo "$A" (c'est à dire de mettre $A dans les guillemets) et vous faire voir les retours à la ligne!
- aha! J'avais remarqué que la question des retours à la ligne, et en utilisant les guillemets autour de la variable de sortie n'a résoudre le problème. thx!
- Je voudrais juste laisser mention de backticks.
- Vous n'avez pas besoin d'utiliser le chat à l'intérieur de l' $(...) depuis << envoie le document à stdout. Donc export A=$(<<END ... END) fonctionne tout aussi bien, avec moins de processus en cours d'exécution.
- Il est intéressant de noter, à cause de la bizarrerie de la le premier exemple, dans un pincement, vous pouvez l'utiliser pour la fortune des blocs de commentaires comme ceci: REM=<< 'REM' ... comment block goes here ... REM. Ou de manière plus compacte, : << 'REM' .... Où "REM" pourrait être quelque chose comme "NOTES" ou "BLOC-notes", etc.
InformationsquelleAutor l0st3d
10

Bifurquant Neil réponse, souvent, vous n'avez pas besoin d'une var à tous, vous pouvez utiliser une fonction de la même façon qu'une variable, et il est beaucoup plus facile à lire que la ligne ou readde solutions à base d'.
```
$ 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"''
```
InformationsquelleAutor dimo414
8

Un tableau est une variable, donc dans ce cas mapfile travaillera
```
mapfile y <<z
abc'asdf"
$(dont-execute-this)
foo"bar"''
z
```
Vous pouvez ensuite les imprimer comme ce
```
printf %s "${y[@]}"
```
- ne travailler que pour bash 4+ pour que je puisse en juger
InformationsquelleAutor Steven Penny
3

attribuer un heredoc valeur à une variable
```
VAR="$(cat <<'VAREOF'
abc'asdf"
$(dont-execute-this)
foo"bar"''
VAREOF
)"
```
utilisé comme un argument d'une commande
```
echo "$(cat <<'SQLEOF'
xxx''xxx'xxx'xx  123123    123123
abc'asdf"
$(dont-execute-this)
foo"bar"''
SQLEOF
)"
```
- Quand j'ai essayé la première méthode, il semble y avoir aucune ligne de terminateurs entre les lignes. Doit être une sorte de configuration sur ma machine linux?
- C'est probablement ce qui signifie que lorsque vous étiez en écho à votre variable, vous n'avez pas mis des guillemets autour d'elle... l'Essayer comme ceci: echo "$VAR"
InformationsquelleAutor bronze man

Je me suis trouvé avoir à lire une chaîne de caractères avec la valeur NULL, alors voici une solution qui va lire rien vous jeter à elle. Bien que si vous avez fait affaire avec des valeurs NULL, vous aurez besoin pour faire face à l'hex de niveau.

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

HEREDOC exemple (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

Celui-ci fonctionne comme prévu, mais cela dépend de gvim.

InformationsquelleAutor Orwellophile

Grâce à dimo414 réponse, cela montre comment sa grande solution fonctionne, et montre que vous pouvez avoir des devis et des variables dans le texte facilement ainsi:

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

Il serait intéressant de voir un inégalée de la citation dans le texte pour voir comment il gère ça. Peut-être " pas de panique, il y a "$COUNT" fichiers " donc, l'apostrophe/apostrophe peut rendre les choses intéressantes.

InformationsquelleAutor Brad Parks

-9

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

Cela ne fonctionne pas à tous.

InformationsquelleAutor Guy Kastenbaum

Vous devez vous connecter pour publier un commentaire.

attribuer un heredoc valeur à une variable

utilisé comme un argument d'une commande

exemple de sortie

test.sh