How to assign space-containing values to variables in bash using eval

Question

I want to dynamically assign values to variables using eval. The following dummy example works:

var_name="fruit"
var_value="orange"
eval $(echo $var_name=$var_value)
echo $fruit
orange

However, when the variable value contains spaces, eval returns an error, even if $var_value is put between double quotes:

var_name="fruit"
var_value="blue orange"
eval $(echo $var_name="$var_value")
bash: orange : command not found

Any way to circumvent this ?

Answer 1

Don't use eval, use declare

$ declare "$var_name=$var_value"
$ echo "fruit: >$fruit<"
fruit: >blue orange<

Answer 2

Don't use eval for this; use declare.

var_name="fruit"
var_value="blue orange"
declare "$var_name=$var_value"

Note that word-splitting is not an issue, because everything following the = is treated as the value by declare, not just the first word.

In bash 4.3, named references make this a little simpler.

$ declare -n var_name=fruit
$ var_name="blue orange"
$ echo $fruit
blue orange

You can make eval work, but you still shouldn't :) Using eval is a bad habit to get into.

$ eval "$(printf "%q=%q" "$var_name" "$var_value")"

Answer 3

A good way to work with eval is to replace it with echo for testing. echo and eval work the same (if we set aside the \x expansion done by some echo implementations like bash's under some conditions).

Both commands join their arguments with one space in between. The difference is that echo displays the result while eval evaluates/interprets as shell code the result.

So, to see what shell code

eval $(echo $var_name=$var_value)

would evaluate, you can run:

$ echo $(echo $var_name=$var_value)
fruit=blue orange

That's not what you want, what you want is:

fruit=$var_value

Also, using $(echo ...) here doesn't make sense.

To output the above, you'd run:

$ echo "$var_name=\$var_value"
fruit=$var_value

So, to interpret it, that's simply:

eval "$var_name=\$var_value"

Note that it can also be used to set individual array elements:

var_name='myarray[23]'
var_value='something'
eval "$var_name=\$var_value"

As others have said, if you don't care your code being bash specific, you can use declare as:

declare "$var_name=$var_value"

However note that it has some side effects.

It limits the scope of the variable to the function where it's run in. So you can't use it for instance in things like:

setvar() {
  var_name=$1 var_value=$2
  declare "$var_name=$var_value"
}
setvar foo bar

Because that would declare a foo variable local to setvar so would be useless.

bash-4.2 added a -g option for declare to declare a global variable, but that's not what we want either as our setvar would set a global var as opposed to that of the caller if the caller was a function, like in:

setvar() {
  var_name=$1 var_value=$2
  declare -g "$var_name=$var_value"
}
foo() {
  local myvar
  setvar myvar 'some value'
  echo "1: $myvar"
}
foo
echo "2: $myvar"

which would output:

1:
2: some value

Also, note that while declare is called declare (actually bash borrowed the concept from the Korn shell's typeset builtin), if the variable is already set, declare doesn't declare a new variable and the way the assignment is done depends on the type of the variable.

For instance:

varname=foo
varvalue='([PATH=1000]=something)'
declare "$varname=$varvalue"

will produce a different result (and potentially have nasty side effects) if varname was previously declared as a scalar, array or associative array.

Also note that declare is not any safer than eval, if the contents of $varname is not tightly controlled.

For instance, both eval "$varname=\$varvalue" and declare "$varname=$varvalue" would reboot the system if $varname contained a[$(reboot)1] for instance.

Answer 4

If you do:

eval "$name=\$val"

...and $name contains a ; - or any of several other tokens the shell might interpret as delimiting a simple command - preceded by proper shell syntax, that will be executed.

name='echo hi;varname' val='be careful with eval'
eval "$name=\$val" && echo "$varname"

OUTPUT

hi
be careful with eval

It can sometimes be possible to separate the evaluation and execution of such statements, though. For example, alias can be used to pre-evaluate a command. In the following example the variable definition is saved to an alias that can only be successfully declared if the $nm variable it is evaluating contains no bytes that do not match ASCII alphanumerics or _.

LC_OLD=$LC_ALL LC_ALL=C
alias "${nm##*[!_A-Z0-9a-z]*}=_$nm=\$val" &&
eval "${nm##[0-9]*}" && unalias "$nm"
LC_ALL=$LC_OLD

eval is used here to handle invoking the new alias from a varname. But it is only called at all if the previous alias definition is successful, and while I know a lot of different implementations will accept a lot of different kinds of values for alias names, I haven't yet run into one that will accept a completely empty one.

The definition within the alias is for _$nm, however, and this is to ensure that no significant environment values are written over. I don't know of any noteworthy environment values beginning with a _ and it is usually a safe bet for semi-private declaration.

Anyway, if the alias definition is successful it will declare an alias named for $nm's value. And eval will only call that alias if also does not start with a number - else eval gets only a null argument. So if both conditions are met eval calls the alias and the variable definition saved in the alias is made, after which the new alias is promptly removed from the hash table.

Answer 5

use dead quote ie. apstroph.
eval $(echo $var_name='$var_value')
it worked with me.

Answer 6

First, double quote to prevent globbing and word splitting. $var_name should be quoted, for best habit.

In normal shell script, variables turn into values, which is called expansion. When eval is in use, in addition to the normal phrase one expansion, variable are expanded inside eval also. This is what makes eval so powerful (not evil if used with care).

Solution one:

Suppress the expansion of $var_value outside eval by single quotes. eval takes one argument fruit=$var_value. Note that this is no different from eval 'fruit=$var_value' in plain text. Beware that the value in var_name should not contain any spaces. All three examples are the same, as long as they suppress the expansion. $var_value is treated as plain text.

var_name="fruit" ; var_value="blue orange" ; eval "$var_name"='$var_value' ; echo "$fruit"
var_name="fruit" ; var_value="blue orange" ; eval "$var_name"='$'var_value ; echo "$fruit"
var_name="fruit" ; var_value="blue orange" ; eval "$var_name"=$var_value ; echo "$fruit"

Solution two:

Give eval the quotes. In these cases, both $var_name and $var_value get expanded outside eval. eval gets fruit='blue orange' or fruit="blue orange".

var_name="fruit" ; var_value="blue orange" ; eval "$var_name"=\'"$var_value"\' ; echo "$fruit"
var_name="fruit" ; var_value="blue orange" ; eval "$var_name"=""$var_value"" ; echo "$fruit"
var_name="fruit" ; var_value="blue orange" ; eval "$var_name="$var_value"" ; echo "$fruit"

Single quotes and double quotes make no different in the above case. But when it comes to indirect variables, it makes a different.

basket='$var_value' ; var_name="fruit" ; var_value="blue orange" ; eval "$var_name"=\'"$basket"\' ; echo "$fruit"
$var_value
basket='$var_value' ; var_name="fruit" ; var_value="blue orange" ; eval "$var_name"=""$basket"" ; echo "$fruit"
blue orange

---

In your example, the use of echo is not necessary.

echo $var_name="$var_value" expands to fruit=blue orange. The problem is this string is not quoted. eval takes two arguments, fruit=blue and orange, separately. To fix it, either suppress the expansion of $var_value, or give it the proper quotes.

var_name="fruit" ; var_value="blue orange" ; eval $(echo "$var_name"='$var_value') ; echo "$fruit"
var_name="fruit" ; var_value="blue orange" ; eval $(echo "$var_name"='"$var_value"') ; echo "$fruit"

This use of echo is redundant. Try to avoid it as much as possible.