Cómo asignar valores que contienen espacio a variables en bash usando eval

Quiero asignar valores dinámicamente a variables usando eval. El siguiente ejemplo ficticio funciona:

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

Sin embargo, cuando el valor de la variable contiene espacios, evaldevuelve un error, incluso si $var_valuese coloca entre comillas dobles:

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

¿Alguna forma de evitar esto?

No uses eval, usa declare

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

No lo uses evalpara esto; uso declare.

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

Tenga en cuenta que la división de palabras no es un problema, ya que todo lo que sigue =es tratado como el valor por declare, no solo la primera palabra.

En bash4.3, las referencias con nombre hacen esto un poco más simple.

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

Usted puede hacer evalel trabajo, pero aún así no debería :) Usando evales un mal hábito para entrar.

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

Una buena forma de trabajar evales reemplazarlo por echopara probar. echoy evalfunciona igual (si dejamos de lado la \xexpansión realizada por algunas echoimplementaciones como bashen algunas condiciones).

Ambos comandos unen sus argumentos con un espacio en el medio. La diferencia es que echo muestra el resultado mientras eval evalúa / interpreta como código shell el resultado.

Entonces, para ver qué código de shell

eval $(echo $var_name=$var_value)

evaluaría, puede ejecutar:

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

Eso no es lo que quieres, lo que quieres es:

fruit=$var_value

Además, usar $(echo ...)aquí no tiene sentido.

Para generar lo anterior, ejecutarías:

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

Entonces, para interpretarlo, eso es simplemente:

eval "$var_name=\$var_value"

Tenga en cuenta que también se puede usar para establecer elementos de matriz individuales:

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

Como otros han dicho, si no te importa que tu código sea bashespecífico, puedes usarlo declarecomo:

declare "$var_name=$var_value"

Sin embargo, tenga en cuenta que tiene algunos efectos secundarios.

Limita el alcance de la variable a la función donde se ejecuta. Por lo tanto, no puede usarla, por ejemplo, en cosas como:

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

Porque eso declararía que una foovariable local setvarsería inútil.

bash-4.2agregó una -gopción para declaredeclarar una variable global , pero eso tampoco es lo que queremos, ya setvarque estableceríamos una var global en lugar de la de la persona que llama si la persona que llama fue una función, como en:

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"

que daría salida:

1:
2: some value

Además, tenga en cuenta que mientras declarese llama declare(en realidad bashtomó prestado el concepto de la construcción del shell Korn typeset), si la variable ya está establecida, declareno declara una nueva variable y la forma en que se realiza la asignación depende del tipo de la variable.

Por ejemplo:

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

producirá un resultado diferente (y potencialmente tendrá efectos secundarios desagradables) si varnamese declaró previamente como un escalar , matriz o matriz asociativa .

Si lo haces:

eval "$name=\$val"

... y $namecontiene una ;, o cualquiera de varias otras señales que el shell podría interpretar como delimitación de un comando simple, precedido por la sintaxis adecuada del shell, que se ejecutará.

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

SALIDA

hi
be careful with eval

Sin embargo, a veces puede ser posible separar la evaluación y la ejecución de tales declaraciones. Por ejemplo, aliasse puede usar para evaluar previamente un comando. En el siguiente ejemplo, la definición de la variable se guarda en una aliasque solo puede declararse con éxito si la $nmvariable que está evaluando no contiene bytes que no coincidan con los caracteres alfanuméricos o ASCII _.

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

evalse usa aquí para manejar la invocación de lo nuevo aliasdesde un nombre var. Pero solo se llama si la aliasdefinición anterior es exitosa, y aunque sé que muchas implementaciones diferentes aceptarán muchos tipos diferentes de valores para los aliasnombres, todavía no me he encontrado con uno que acepte uno completamente vacío. .

Sin embargo, la definición dentro de aliases para _$nm, y esto es para garantizar que no se sobrescriban valores de entorno significativos. No conozco ningún valor de entorno notable que comience con a _y, por lo general, es una apuesta segura para la declaración semiprivada.

De todos modos, si la aliasdefinición es exitosa, declarará un aliasnombre para $nmel valor de. Y evalsolo llamará a eso aliassi tampoco comienza con un número; de lo contrario, evalsolo obtiene un argumento nulo. Entonces, si se cumplen ambas condiciones, se evalllama alias y se realiza la definición de la variable guardada en el alias, después de lo cual la nueva aliasse elimina rápidamente de la tabla hash.