Comment éviter bash de la substitution de commande pour supprimer le caractère de saut de ligne?

Pour accélérer un script bash exécution, je tiens à garder le résultat d'une commande dans une variable à l'aide de la substitution de commande, mais la substitution de commande remplace le 0x0A caractère de saut de ligne par un espace. Par exemple:

a=`df -H`

ou

a=$( df -H )

Quand je veux processus de $a, les caractères de saut de ligne sont remplacés par un espace et toutes les lignes sont maintenant sur une seule ligne, ce qui est beaucoup plus difficile de grep:

echo $a

Quels seraient les conseils pour éviter le caractère de saut de ligne supprimée par la substitution de commande?

InformationsquelleAutor Laurent | 2013-03-03
  1. 105

    Non de fuite des retours à la ligne ne sont pas supprimés

    Les retours à la ligne que vous cherchez sont là, vous ne les voyez pas, parce que vous utilisez echo sans citer de la variable.

    Validation:

    $ a=$( df -H )
$ echo $a
Filesystem Size Used Avail Use% Mounted on /dev/sda3 276G 50G 213G 19% / udev 2.1G 4.1k 2.1G 1% /dev tmpfs 832M 820k 832M 1% /run none 5.3M 0 5.3M 0% /run/lock none 2.1G 320k 2.1G 1% /run/shm
$ echo "$a"
Filesystem      Size  Used Avail Use% Mounted on
/dev/sda3       276G   50G  213G  19% /
udev            2.1G  4.1k  2.1G   1% /dev
tmpfs           832M  820k  832M   1% /run
none            5.3M     0  5.3M   0% /run/lock
none            2.1G  320k  2.1G   1% /run/shm
$

    De fuite retours à la ligne sont supprimés

    Comme @user4815162342 souligné à juste titre, bien que les retours à la ligne dans la sortie ne sont pas supprimés, de fuite des retours à la ligne sont enlevés avec une substitution de commande. Voir l'expérience ci-dessous:

    $ a=$'test\n\n'
$ echo "$a"
test


$ b=$(echo "$a")
$ echo "$b"
test
$

    Dans la plupart des cas, cela n'a pas d'importance, parce que echo va ajouter de la disparition de retour à la ligne (sauf si elle est invoquée avec la -n option), mais il y a certains cas où il y a plus qu'une fuite des retours à la ligne dans la sortie d'un programme, et ils sont importants pour une raison quelconque.

    Solutions de contournement

    1. Ajouter mannequin de caractère

    Dans ces cas, comme @Scrutinizer mentionné, vous pouvez utiliser la solution de contournement suivante:

    $ a=$(printf 'test\n\n'; printf x); a=${a%x}
$ echo "$a"
test


$

    Explication: Caractère x est ajouté à la sortie (à l'aide de printf x), après les retours à la ligne. Depuis les retours à la ligne ne sont pas de fuite plus, ils ne sont pas supprimés par la substitution de commande. La prochaine étape consiste à supprimer le x nous avons ajouté, à l'aide de la % opérateur dans ${a%x}. Maintenant, nous avons la sortie d'origine, avec tous les retours à la ligne actuelle!!!

    2. Lecture à l'aide de processus de substitution

    Au lieu d'utiliser la substitution de commande affecter la sortie d'un programme de variable, on peut, au lieu d'utiliser processus de substitution pour nourrir la sortie du programme de la read de commande intégrée (crédit à @ormaaj). Processus de substitution conserve tous les retours à la ligne. La lecture de la sortie d'une variable est un peu difficile, mais vous pouvez le faire comme ceci:

    $ IFS= read -rd '' var < <( printf 'test\n\n' ) 
$ echo "$var"
test


$

    Explication:

    • Nous avons mis l' internal field separator pour la commande de lecture à null, avec IFS=. Sinon read ne serait pas affecter l'ensemble de la sortie de var, mais seulement le premier jeton.
    • Nous invoquons lire avec des options -rd ''. Le r est pour la prévention de la barre oblique inverse à agir comme un caractère spécial, et avec d '' définir le séparateur à rien, de sorte que lire lit l'intégralité de sortie, au lieu de simplement la première ligne.

    3. Lire à partir d'un tuyau

    Au lieu de l'aide de la commande ou le processus de substitution d'affecter la sortie d'un programme de variable, on peut, au lieu de rediriger la sortie du programme pour le read de commande (crédit à @ormaaj). Tuyauterie conserve également tous les retours à la ligne. À noter toutefois, que cette fois nous avons mis l' lastpipe shell comportement en option, à l'aide de le shopt builtin. Cela est nécessaire, de sorte que le read commande est exécutée dans le courant de l'environnement de shell. Sinon, la variable sera affecté dans un shell interne est exécuté, et il ne sera pas accessible depuis le reste du script.

    $ cat test.sh 
#!/bin/bash
shopt -s lastpipe
printf "test\n\n" | IFS= read -rd '' var
echo "$var"
$ ./test.sh 
test


$
    • Le de fuite retours à la ligne sont encore retirée, bien que, et je crains que ça ne peut pas être évitée. (L'OP n'a probablement pas de soins sur les personnes, mais c'est bon à savoir en général.)
    • Merci beaucoup, très éclairante - un autre exemple de se concentrer sur le mauvais endroit, puisqu'il n'était pas la substitution de commande de retirer le retour à la ligne.
    • Merci pour le commentaire. J'ai mis à jour la réponse pour les futurs lecteurs.
    • Intéressant, un minable contourner pourrait être d'utiliser a=$(printf 'test\n\n'; printf x); echo "${a%x}"
    • Belle astuce! Je l'ai ajouté à la réponse.
    • Ce n'est pas une très bonne solution de contournement. Il n'y a pas une bonne façon d'éviter le décapage de fuite des retours à la ligne avec une substitution de commande. La meilleure solution est d'utiliser read non standard des options pour effectuer la cession. shopt -s lastpipe; printf %s "$myData" | IFS= read -rd '' var. Bash est printf -v est également utile dans certaines situations semblables.
    • Pourquoi, à votre avis est-ce pas une bonne solution? Je suis d'accord c'est moche, mais qu'avez-vous trouvé qui ne fonctionne pas correctement?
    • Il implique deux missions, et de tout ce que la manipulation de la chaîne juste pour contourner le problème n'est pas très évidente. Il n'a pas à être rompu pour être de la merde. Une substitution de commande dans la plupart des shells est juste un peu de sucre pour la lecture à partir d'un tuyau pour commencer, afin de résoudre le problème de cette façon est beaucoup plus directe. Dans la pratique, le décapage de fuite des retours à la ligne est généralement un trait de caractère désirable et je ne peux pas dire que j'ai eu à l'utiliser dans un script réel, plus que quelques fois. (Je pense à un cas où ce quelque chose peut être préférable de read, mais il ne s'applique pas à Bash.)
    • J'ai ajouté votre solution de contournement pour la réponse ainsi. N'hésitez pas à modifier si mon explication est mal en aucune façon. J'ai remarqué cependant que, bien que dans un script, il fonctionne très bien, dans le terminal, il ne renvoie à un blanc. J'ai dû l'enfermer dans ( ) de travailler dans le terminal comme ceci: ( shopt -s lastpipe; printf 'test\n\n' | IFS= read -rd '' var; echo "$var"; )
    • Il est beaucoup plus commun et vers l'arrière-compatible en Bash d'utiliser un processus de substitution dans une redirection plutôt que de compter sur lastpipe (bien que j'ai l'habitude d'utiliser lastpipe de toute façon). La raison pour laquelle vous avis, c'est en raison de l'emploi de contrôle. Shell interactif ont set -m laquelle les forces de pipelines pour s'exécuter en séparer les groupes de processus, ce qui nécessite un sous-shell pour le dernier élément. Depuis le contrôle du travail ne s'applique pas aux enfants de un shell interne est exécuté, l'emballage tout en (...) est une solution de contournement (que j'ai presque toujours lors de l'essai de manière interactive, de toute façon).
    • Remarque: read sorties avec non nul, quand il frappe les expressions du FOLKLORE. Cela provoque les méthodes 2 et 3 de sortie non nul, par conséquent, de masquage de commande principale de l'état de sortie. Dans la Méthode 1 en utilisant main_cmd ; printf x remplace également le principal commandes code de sortie et interfère avec la gestion des erreurs. Essayez main_cmd && printf x à la place (si les lignes de fuite sont importantes uniquement sur la réussite de sortie) ou main_cmd ; ec=$?; printf x; exit $ec pour garder des espaces à la fois les succès et les cas d'erreur.
    • Fait intéressant, un an et demi plus tard, AndrDevEK trouvé un inconvénient de la read méthode. Elle masque le statut de sortie. Lire le commentaire ci-dessus.
    • Qui est attendu et pas vraiment un inconvénient. Si vous devez accéder à l'état, vous pouvez l'obtenir par le biais de la PIPESTATUS tableau. Cela ne fonctionne que si vous utilisez un pipeline, que bash ne pas exposer l'état de sortie des processus de substitution. shopt -s lastpipe; { printf %s $'foo\nbar'; exit 3; } | IFS= read -rd '' x; printf '%q, %s\n' "$x" "${PIPESTATUS[0]}"
    • "Citez toujours vos variables, les enfants"

    InformationsquelleAutor user000001
  2. 0

    J'ai été d'essayer d'envelopper ma tête autour de cela parce que j'ai été en utilisant bash de flux dans le résultat de l'exécution de l'interprète sur un F# script. Après quelques essais et erreurs, ce qui s'est avéré pour résoudre le problème:

    $ cat fsi.ch
#!/bin/bash
echo "$(fsharpi --quiet --exec --nologo $1)"

$ fsi.ch messages.fsx
Welcome to my program. Choose from the menu:
new | show | remove

    En supposant, bien sûr, que vous devez exécuter un programme de terminal.
    Espérons que cette aide.

    InformationsquelleAutor Alexander