Como atribuir valores que contêm espaço a variáveis ​​no bash usando eval

Eu quero atribuir valores dinamicamente a variáveis ​​usando eval. O seguinte exemplo fictício funciona:

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

No entanto, quando o valor da variável contém espaços, evalretorna um erro, mesmo que $var_valueseja colocado entre aspas duplas:

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

Alguma maneira de contornar isso?

Não use eval, use declare

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

Não use evalpara isso; use declare.

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

Observe que a divisão de palavras não é um problema, porque tudo o que se segue a =é tratado como valor declare, não apenas a primeira palavra.

Na bash4.3, as referências nomeadas tornam isso um pouco mais simples.

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

Você pode fazer o evaltrabalho, mas ainda não deveria :) Usar evalé um mau hábito para entrar.

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

Uma boa maneira de trabalhar evalé substituí-lo echopelos testes. echoe evalfunciona da mesma forma (se deixarmos de lado a \xexpansão feita por algumas echoimplementações como bashas de algumas condições).

Ambos os comandos juntam seus argumentos com um espaço no meio. A diferença é que echo exibe o resultado enquanto eval avalia / interpreta como código shell o resultado.

Então, para ver qual código shell

eval $(echo $var_name=$var_value)

avaliar, você pode executar:

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

Não é isso que você quer, o que você quer é:

fruit=$var_value

Além disso, usar $(echo ...)aqui não faz sentido.

Para gerar o resultado acima, você executaria:

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

Então, para interpretar, é simplesmente:

eval "$var_name=\$var_value"

Observe que também pode ser usado para definir elementos individuais da matriz:

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

Como outros já disseram, se você não se importa que seu código seja bashespecífico, você pode usar declarecomo:

declare "$var_name=$var_value"

No entanto, note que ele tem alguns efeitos colaterais.

Limita o escopo da variável à função em que ela é executada. Portanto, você não pode usá-la, por exemplo, em coisas como:

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

Porque isso declararia uma foovariável local para setvarisso seria inútil.

bash-4.2adicionou uma -gopção para declaredeclarar uma variável global , mas isso não é o que queremos, pois o nosso setvardefiniria uma var global em oposição à do chamador se o chamador fosse uma função, como em:

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 produziria:

1:
2: some value

Além disso, observe que while declareé chamado declare(na verdade, basho conceito emprestado do shell Korn typeset), se a variável já estiver definida, declarenão declara uma nova variável e a maneira como a atribuição é feita depende do tipo da variável.

Por exemplo:

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

produzirá um resultado diferente (e potencialmente terá efeitos colaterais desagradáveis) se tiver varnamesido declarado anteriormente como escalar , matriz ou matriz associativa .

Se você fizer:

eval "$name=\$val"

... e $namecontém um ;- ou vários outros tokens que o shell pode interpretar como delimitando um comando simples - precedido pela sintaxe apropriada do shell, que será executada.

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

SAÍDA

hi
be careful with eval

Às vezes, pode ser possível separar a avaliação e a execução de tais declarações. Por exemplo, aliaspode ser usado para pré-avaliar um comando. No exemplo a seguir, a definição da variável é salva em uma aliasque só pode ser declarada com êxito se a $nmvariável que está avaliando não contiver bytes que não correspondam a alfanuméricos ASCII ou _.

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é usado aqui para manipular a chamada do novo aliasde um nome de var. Mas isso só é chamado se a aliasdefinição anterior for bem-sucedida e, embora eu saiba que muitas implementações diferentes aceitem muitos tipos diferentes de valores para aliasnomes, ainda não encontrei uma que aceite uma completamente vazia .

A definição dentro de aliasé para _$nm, no entanto, e isso é para garantir que nenhum valor significativo do ambiente seja substituído. Não conheço nenhum valor de ambiente notável que comece com a _e geralmente é uma aposta segura para declarações semi-privadas.

De qualquer forma, se a aliasdefinição for bem-sucedida, ela declarará um valor aliasnomeado para $nm. E evalsó chamará isso aliasse também não começar com um número - senão evalrecebe apenas um argumento nulo. Portanto, se as duas condições forem atendidas eval, o alias e a definição da variável salva no alias serão feitos, após o que o novo aliasserá imediatamente removido da tabela de hash.