将3条输出行读入bash中的3个变量

Question

I have a command that generates 3 lines of output such as

$ ./mycommand
1
asdf
qwer zxcv

I'd like to assign those 3 lines to 3 different variables ($a, $b, $c) such that

$ echo $a
1
$ echo $b
asdf
$ echo $c
qwer zxcv

I'm familiar with the while loop method that would normally be used for reading 3 lines at a time from output that contains sets of 3 lines. But that seems less than elegant considering my command will only ever output 3 lines.

I tried playing around with various combinations of values for IFS= and options for read -rabc , sending the command output as stdin, but I could only ever get it to set the first line to the first variable. Some examples:

IFS= read -r a b c < <(./mycommand)
IFS=$'\n' read -r a b c < <(./mycommand)
IFS= read -r -d $'\n' < <(./mycommand)

If I modify my command so that the 3 lines are separated by spaces instead of newlines, I can successfully just use this variation as long as each former line is properly quoted:

read -r a b c < <(./mycommand)

And while that is working for the purposes of my current project, it's still bugging me that I couldn't get it to work the other way. So I'm wondering if anyone can see and explain what I was missing in my original attempt with the 3 lines of output.

Answer 1

If you want to read data from three lines, use three reads:

{ read -r a; read -r b; read -r c; } < <(./mycommand)

read reads a chunk of data and then splits it up. You couldn't get it to work because your chunks were always single lines.

Answer 2

Newer BASH versions support mapfile command. Using that you can read all the lines into an array:

mapfile -t ary < <(./command)

Check the array content:

declare -p ary
declare -a ary='([0]="1" [1]="asdf" [2]="qwer zxcv")'

Answer 3

Perhaps this explanation will be useful to you.

... it's still bugging me that I couldn't get it to work the other way. So I'm wondering if anyone can see and explain what I was missing in my original attempt with the 3 lines of output.

Simple: read works only with one line (by default). This:

#!/bin/bash

mycommand(){ echo -e "1\nasdf\nqwer zxcv"; }

read a b c < <(mycommand)

printf 'first  : %s\nsecond : %s\nthird  : %s\n' "$a" "$b" "$c"

Will print:

first  : 1
second : 
third  : 

However, using a null character will capture the whole string in (replace this line above):

    read -d '' a b c < <(mycommand)

Will print:

first  : 1
second : asdf
third  : qwer zxcv

The read command absorbed the whole output of the command and was broken into parts with the default value of IFS: Space Tab Enter .

In this specific example, that worked correctly because the last value is the one with more than one "part".
But this kind of processing is very brittle. For example: this other possible output of the command, the assignment to variables will break:

mycommand(){ echo -e "1 and 2\nasdf and dfgh\nqwer zxcv"; }

Will output (incorrectly):

first  : 1
second : and
third  : 2
asdf and dfgh
qwer zxcv

The processing is brittle. To make it robust we need to use a loop. But you say that that is something you already know:

#!/bin/bash
mycommand(){ echo -e "1 and 2\nasdf and dfgh\nqwer zxcv"; }

i=0; while read arr[i]; do ((i++)); done < <(mycommand)

printf 'first  : %s\nsecond : %s\nthird  : %s\n' "${arr[0]}" "${arr[1]}" "${arr[2]}"

Which will (correctly) print:

first  : 1 and 2
second : asdf and dfgh
third  : qwer zxcv

However, the loop could be made simpler using bash command readarray:

#!/bin/bash

mycommand(){ echo -e "1 and 2\nasdf and dfgh\nqwer zxcv"; }

readarray -t arr < <(mycommand)

printf 'first  : %s\nsecond : %s\nthird  : %s\n' "${arr[0]}" "${arr[1]}" "${arr[2]}"

And using a printf "loop" will make the structure work for any count of input lines:

#!/bin/bash
mycommand(){ echo -e "1 and 2\nasdf and dfgh\n*\nqwer zxcv"; }

readarray -t arr < <(mycommand)
printf 'value : %s\n' "${arr[@]}"

Hope that this helped.

EDIT

About nulls (in simple read):

In bash, the use of nulls is almost never practical. In specific, nulls are erased silently in most condidions. This solution does suffer of that limitation.

Including a null in the input:

mycommand(){ echo -e "1 and 2\nasdf and dfgh\n\000\n*\nqwer zxcv"; }

will make a simple read -r -d '' get the input up to the first null (understanding such null as the character with octal 000).

echo "test one:"; echo
echo "input"; echo
mycommand | od -tcx1

echo "output"; echo
read -r -d '' arr < <(mycommand)
echo "$arr" | od -tcx1

Gives this as output:

test one:

input

0000000   1       a   n   d       2  \n   a   s   d   f       a   n   d
         31  20  61  6e  64  20  32  0a  61  73  64  66  20  61  6e  64
0000020       d   f   g   h  \n  \0  \n   *  \n   q   w   e   r       z
         20  64  66  67  68  0a  00  0a  2a  0a  71  77  65  72  20  7a
0000040   x   c   v  \n
         78  63  76  0a
0000044

output

0000000   1       a   n   d       2  \n   a   s   d   f       a   n   d
         31  20  61  6e  64  20  32  0a  61  73  64  66  20  61  6e  64
0000020       d   f   g   h  \n
         20  64  66  67  68  0a
0000026

It is clear that the value captured by read stops at the first octal 000.
Which, frankly, is to be expected.

---

About nulls (in readarray):

I have to report, however, that readarray does not stop at the octal 000 but just silently removes it (an usual shell trait).
Running this code:

#!/bin/bash
mycommand(){ echo -e "1 and 2\nasdf and dfgh\n\000\n*\nqwer zxcv"; }
echo "test two:"; echo
echo "input"; echo
mycommand | od -tcx1

echo "output"; echo
readarray -t arr < <(mycommand)
printf 'value : %s\n' "${arr[@]}"
echo
printf 'value : %s\n' "${arr[@]}"|od -tcx1

Renders this output:

test two:

input

0000000   1       a   n   d       2  \n   a   s   d   f       a   n   d
         31  20  61  6e  64  20  32  0a  61  73  64  66  20  61  6e  64
0000020       d   f   g   h  \n  \0  \n   *  \n   q   w   e   r       z
         20  64  66  67  68  0a  00  0a  2a  0a  71  77  65  72  20  7a
0000040   x   c   v  \n
         78  63  76  0a
0000044

output

value : 1 and 2
value : asdf and dfgh
value : 
value : *
value : qwer zxcv

0000000   v   a   l   u   e       :       1       a   n   d       2  \n
         76  61  6c  75  65  20  3a  20  31  20  61  6e  64  20  32  0a
0000020   v   a   l   u   e       :       a   s   d   f       a   n   d
         76  61  6c  75  65  20  3a  20  61  73  64  66  20  61  6e  64
0000040       d   f   g   h  \n   v   a   l   u   e       :      \n   v
         20  64  66  67  68  0a  76  61  6c  75  65  20  3a  20  0a  76
0000060   a   l   u   e       :       *  \n   v   a   l   u   e       :
         61  6c  75  65  20  3a  20  2a  0a  76  61  6c  75  65  20  3a
0000100       q   w   e   r       z   x   c   v  \n
         20  71  77  65  72  20  7a  78  63  76  0a
0000113

That is, the null 000 or just \\0 gets silently removed.