I just assigned a variable, but echo $variable shows something else

Question

Here are a series of cases where echo $var can show a different value than what was just assigned. This happens regardless of whether the assigned value was "double quoted", 'single quoted' or unquoted.

How do I get the shell to set my variable correctly?

Asterisks

The expected output is /* Foobar is free software */, but instead I get a list of filenames:

$ var="/* Foobar is free software */"
$ echo $var 
/bin /boot /dev /etc /home /initrd.img /lib /lib64 /media /mnt /opt /proc ...

Square brackets

The expected value is [a-z], but sometimes I get a single letter instead!

$ var=[a-z]
$ echo $var
c

Line feeds (newlines)

The expected value is a a list of separate lines, but instead all the values are on one line!

$ cat file
foo
bar
baz

$ var=$(cat file)
$ echo $var
foo bar baz

Multiple spaces

I expected a carefully aligned table header, but instead multiple spaces either disappear or are collapsed into one!

$ var="       title     |    count"
$ echo $var
title | count

Tabs

I expected two tab separated values, but instead I get two space separated values!

$ var=$'key\tvalue'
$ echo $var
key value

Burnsed

Thanks for doing this. I encounter the line feeds one often. So var=$(cat file) is fine, but echo "$var" is needed. – Zenia

BTW, this is also BashPitfalls #14: mywiki.wooledge.org/BashPitfalls#echo_.24foo – Mullock

See also #10067766 – Perambulate

Also, see also #2414650 – Perambulate

Answer 1

In all of the cases above, the variable is correctly set, but not correctly read! The right way is to use double quotes when referencing:

echo "$var"

This gives the expected value in all the examples given. Always quote variable references!

---

Why?

When a variable is unquoted, it will:

1. Undergo field splitting where the value is split into multiple words on whitespace (by default):

   Before: /* Foobar is free software */

   After: /*, Foobar, is, free, software, */

2. Each of these words will undergo pathname expansion, where patterns are expanded into matching files:

   Before: /*

   After: /bin, /boot, /dev, /etc, /home, ...

3. Finally, all the arguments are passed to echo, which writes them out separated by single spaces, giving

   /bin /boot /dev /etc /home Foobar is free software Desktop/ Downloads/
   

   instead of the variable's value.

When the variable is quoted it will:

1. Be substituted for its value.
2. There is no step 2.

This is why you should always quote all variable references, unless you specifically require word splitting and pathname expansion. Tools like shellcheck are there to help, and will warn about missing quotes in all the cases above.

Burnsed

it's not always working. I can give an example: paste.ubuntu.com/p/8RjR6CS668 – Ebbarta

Yup, $(..) strips trailing linefeeds. You can use var=$(cat file; printf x); var="${var%x}" to work around it. – Burnsed

Answer 2

You may want to know why this is happening. Together with the great explanation by that other guy, find a reference of Why does my shell script choke on whitespace or other special characters? written by Gilles in Unix & Linux:

Why do I need to write "$foo"? What happens without the quotes?

$foo does not mean “take the value of the variable foo”. It means something much more complex:

• First, take the value of the variable.
• Field splitting: treat that value as a whitespace-separated list of fields, and build the resulting list. For example, if the variable contains foo * bar ​ then the result of this step is the 3-element list foo, *, bar.
• Filename generation: treat each field as a glob, i.e. as a wildcard pattern, and replace it by the list of file names that match this pattern. If the pattern doesn't match any files, it is left unmodified. In our example, this results in the list containing foo, following by the list of files in the current directory, and finally bar. If the current directory is empty, the result is foo, *, bar.

Note that the result is a list of strings. There are two contexts in shell syntax: list context and string context. Field splitting and filename generation only happen in list context, but that's most of the time. Double quotes delimit a string context: the whole double-quoted string is a single string, not to be split. (Exception: "$@" to expand to the list of positional parameters, e.g. "$@" is equivalent to "$1" "$2" "$3" if there are three positional parameters. See What is the difference between $* and $@?)

The same happens to command substitution with $(foo) or with `foo`. On a side note, don't use `foo`: its quoting rules are weird and non-portable, and all modern shells support $(foo) which is absolutely equivalent except for having intuitive quoting rules.

The output of arithmetic substitution also undergoes the same expansions, but that isn't normally a concern as it only contains non-expandable characters (assuming IFS doesn't contain digits or -).

See When is double-quoting necessary? for more details about the cases when you can leave out the quotes.

Unless you mean for all this rigmarole to happen, just remember to always use double quotes around variable and command substitutions. Do take care: leaving out the quotes can lead not just to errors but to security holes.

Egg

Answer 3

In addition to other issues caused by failing to quote, -n and -e can be consumed by echo as arguments. (Only the former is legal per the POSIX spec for echo, but several common implementations violate the spec and consume -e as well).

To avoid this, use printf instead of echo when details matter.

Thus:

$ vars="-e -n -a"
$ echo $vars      # breaks because -e and -n can be treated as arguments to echo
-a
$ echo "$vars"
-e -n -a

However, correct quoting won't always save you when using echo:

$ vars="-n"
$ echo "$vars"
$ ## not even an empty line was printed

...whereas it will save you with printf:

$ vars="-n"
$ printf '%s\n' "$vars"
-n

Mullock

Yay, we need a good dedup for this! I agree this fits the question title, but I don't think it'll get the visibility it deserves here. How about a new question à la "Why is my -e/-n/backslash not showing up?" We can add links from here as appropriate. – Burnsed

Did you mean consume -n as well? – Jermaine

@PesaThe, no, I meant -e. The standard for echo does not specify output when its first argument is -n, making any/all possible output legal in that case; there is no such provision for -e. – Mullock

Answer 4

user double quote to get the exact value. like this:

echo "${var}"

and it will read your value correctly.

Leadin

root@ubuntu:/home/qgb# var_a=100 echo ${var_a} – Shaneka

Answer 5

echo $var output highly depends on the value of IFS variable. By default it contains space, tab, and newline characters:

[ks@localhost ~]$ echo -n "$IFS" | cat -vte
 ^I$

This means that when shell is doing field splitting (or word splitting) it uses all these characters as word separators. This is what happens when referencing a variable without double quotes to echo it ($var) and thus expected output is altered.

One way to prevent word splitting (besides using double quotes) is to set IFS to null. See http://pubs.opengroup.org/onlinepubs/009695399/utilities/xcu_chap02.html#tag_02_06_05 :

If the value of IFS is null, no field splitting shall be performed.

Setting to null means setting to empty value:

IFS=

---

Test:

[ks@localhost ~]$ echo -n "$IFS" | cat -vte
 ^I$
[ks@localhost ~]$ var=$'key\nvalue'
[ks@localhost ~]$ echo $var
key value
[ks@localhost ~]$ IFS=
[ks@localhost ~]$ echo $var
key
value
[ks@localhost ~]$ 

Transpicuous

You would also have to set -f to prevent globbing – Burnsed

@thatotherguy, is it really necessary for your 1-st example with path expansion? With IFS set to null, echo $var will be expanded to echo '/* Foobar is free software */' and path expansion is not performed inside single quoted strings. – Transpicuous

Yes. If you mkdir "/this thing called Foobar is free software etc/" you'll see that it still expands. It's obviously more practical for the [a-z] example. – Burnsed

I see, this makes sense for [a-z] example. – Transpicuous

root@ubuntu:/home/qgb# var=32321 echo $var root@ubuntu:/home/qgb# var=3231; echo $var 3231 – Shaneka

Answer 6

The answer from ks1322 helped me to identify the issue while using docker-compose exec:

If you omit the -T flag, docker-compose exec add a special character that break output, we see b instead of 1b:

$ test=$(/usr/local/bin/docker-compose exec db bash -c "echo 1")
$ echo "${test}b"
b

echo "${test}" | cat -vte
1^M$

With -T flag, docker-compose exec works as expected:

$ test=$(/usr/local/bin/docker-compose exec -T db bash -c "echo 1")
$ echo "${test}b"
1b

Artwork

Answer 7

Additional to putting the variable in quotation, one could also translate the output of the variable using tr and converting spaces to newlines.

$ echo $var | tr " " "\n"
foo
bar
baz

Although this is a little more convoluted, it does add more diversity with the output as you can substitute any character as the separator between array variables.

Rosaniline

But this substitutes all spaces to newlines. Quoting preserves the existing newlines and spaces. – Nye

True, yes. I suppose it depends on what is within the variable. I actually use tr the other way around to create arrays from text files. – Rosaniline

Creating a problem by not quoting the variable properly and then working around it with a hamfisted extra process is not good programming. – Perambulate

@Alek, ...err, what? There's no tr needed to properly/correctly create an array from a text file -- you can specify whatever separator you want by setting IFS. For instance: IFS=$'\n' read -r -d '' -a arrayname < <(cat file.txt && printf '\0') works all the way back through bash 3.2 (the oldest version in wide circulation), and correctly sets exit status to false if your cat failed. And if you wanted, say, tabs instead newlines, you'd just replace the $'\n' with $'\t'. – Mullock

@Alek, ...if you're doing something like arrayname=( $( cat file | tr '\n' ' ' ) ), then that's broken on multiple layers: It's globbing your results (so a * turns into a list of files in the current directory), and it would work just as well without the tr (or the cat, for that matter; one could just use arrayname=$( $(<file) ) and it would be broken in the same ways, but less inefficiently so). – Mullock