Я запутался в скрипте bash.

У меня есть следующий код:

function grep_search() {
    magic_way_to_define_magic_variable_$1=`ls | tail -1`
    echo $magic_variable_$1
}

Я хочу иметь возможность создать имя переменной, содержащей первый аргумент команды и содержащей значение, например, последней строки ls.

Итак, чтобы проиллюстрировать, что я хочу:

$ ls | tail -1
stack-overflow.txt

$ grep_search() open_box
stack-overflow.txt

Итак, как я должен определить / объявить $magic_way_to_define_magic_variable_$1и как я должен вызвать его в сценарии?

Я попытался eval, ${...}, \$${...}, но я до сих пор путаю.

Используйте ассоциативный массив с именами команд в качестве ключей.

# Requires bash 4, though
declare -A magic_variable=()

function grep_search() {
    magic_variable[$1]=$( ls | tail -1 )
    echo ${magic_variable[$1]}
}

Если вы не можете использовать ассоциативные массивы (например, вы должны поддерживать bash3), вы можете использовать declareдля создания динамических имен переменных:

declare "magic_variable_$1=$(ls | tail -1)"

и использовать косвенное расширение параметра для доступа к значению.

var="magic_variable_$1"
echo "${!var}"

См. BashFAQ: косвенное обращение - оценка косвенных / ссылочных переменных .

Я искал лучший способ сделать это в последнее время. Ассоциативный массив звучит как излишнее для меня. Смотри, что я нашел:

suffix=bzz
declare prefix_$suffix=mystr

...а потом...

varname=prefix_$suffix
echo ${!varname}

Помимо ассоциативных массивов, в Bash есть несколько способов достижения динамических переменных. Обратите внимание, что все эти методы представляют риски, которые обсуждаются в конце этого ответа.

В следующих примерах я буду предполагать, что i=37и что вы хотите присвоить псевдоним переменной, var_37чье начальное значение равно lolilol.

Способ 1. Использование переменной «указатель»

Вы можете просто сохранить имя переменной в косвенной переменной, в отличие от указателя Си. Bash затем имеет синтаксис для чтения псевдонима переменной: ${!name}расширяется до значения переменной, имя которой равно значению переменной name. Вы можете думать об этом как о двухэтапном расширении: ${!name}расширяется до $var_37, которое расширяется до lolilol.

name="var_$i"
echo "$name"         # outputs “var_37”
echo "${!name}"      # outputs “lolilol”
echo "${!name%lol}"  # outputs “loli”
# etc.

К сожалению, нет никакого аналога синтаксиса для изменения псевдонима переменной. Вместо этого вы можете выполнить задание с помощью одного из следующих приемов.

1a. Назначение сeval

evalэто зло, но это также самый простой и самый портативный способ достижения нашей цели. Вы должны тщательно избегать правой части задания, так как оно будет оцениваться дважды . Простой и систематический способ сделать это - предварительно оценить правую часть (или использовать printf %q).

И вы должны вручную проверить, является ли левая часть допустимым именем переменной или именем с индексом (что, если это было evil_code #?). В отличие от всех других методов, приведенных ниже, применять его автоматически.

# check that name is a valid variable name:
# note: this code does not support variable_name[index]
shopt -s globasciiranges
[[ "$name" == [a-zA-Z_]*([a-zA-Z_0-9]) ]] || exit

value='babibab'
eval "$name"='$value'  # carefully escape the right-hand side!
echo "$var_37"  # outputs “babibab”

Недостатки:

• не проверяет правильность имени переменной.
• eval это зло
• eval это зло
• eval это зло

1б. Назначение сread

readВстроенное позволяет присвоить значение переменной из которых вы даете имя, факт , который может быть использован в сочетании с здесь-строками:

IFS= read -r -d '' "$name" <<< 'babibab'
echo "$var_37"  # outputs “babibab\n”

IFSЧасть и опции -rубедитесь , что значение присваивается как есть, в то время как опция -d ''позволяет задавать значения нескольких строк. Из-за этой последней опции команда возвращается с ненулевым кодом выхода.

Обратите внимание, что, поскольку мы используем здесь-строку, к значению добавляется символ новой строки.

Недостатки:

• немного неясен;
• возвращается с ненулевым кодом выхода;
• добавляет новую строку к значению.

1c. Назначение сprintf

Начиная с Bash 3.1 (выпущен в 2005 году), printfвстроенный модуль также может присваивать свой результат переменной, имя которой дано. В отличие от предыдущих решений, это просто работает, никаких дополнительных усилий не требуется, чтобы избежать чего-то, предотвратить расщепление и так далее.

printf -v "$name" '%s' 'babibab'
echo "$var_37"  # outputs “babibab”

Недостатки:

• Менее портативный (но, хорошо).

Способ 2. Использование «ссылочной» переменной

Начиная с Bash 4.3 (выпущен в 2014 году), declareвстроенная функция имеет опцию -nдля создания переменной, которая является «ссылкой на имя» на другую переменную, во многом как ссылки на C ++. Как и в методе 1, ссылка хранит имя переменной с псевдонимом, но при каждом обращении к ссылке (либо для чтения, либо для назначения) Bash автоматически разрешает косвенное обращение.

Кроме того, Bash имеет специальное и очень запутанный синтаксис для получения значения самой ссылки, судьи сами: ${!ref}.

declare -n ref="var_$i"
echo "${!ref}"  # outputs “var_37”
echo "$ref"     # outputs “lolilol”
ref='babibab'
echo "$var_37"  # outputs “babibab”

Это не помогает избежать ошибок, описанных ниже, но, по крайней мере, упрощает синтаксис.

Недостатки:

• Не портативный

риски

Все эти методы сглаживания представляют несколько рисков. Первый - выполнение произвольного кода каждый раз, когда вы разрешаете косвенное обращение (либо для чтения, либо для назначения) . Действительно, вместо имени скалярной переменной, например var_37, вы можете использовать псевдоним массива, например arr[42]. Но Bash оценивает содержимое квадратных скобок каждый раз, когда это необходимо, поэтому псевдонимы arr[$(do_evil)]будут иметь неожиданные последствия ... Как следствие, используйте эти методы только тогда, когда вы контролируете происхождение псевдонима .

function guillemots() {
  declare -n var="$1"
  var="«${var}»"
}

arr=( aaa bbb ccc )
guillemots 'arr[1]'  # modifies the second cell of the array, as expected
guillemots 'arr[$(date>>date.out)1]'  # writes twice into date.out
            # (once when expanding var, once when assigning to it)

Второй риск - создание циклического псевдонима. Поскольку переменные Bash идентифицируются по имени, а не по области действия, вы можете непреднамеренно создать псевдоним для себя (полагая, что это будет псевдоним переменной из входящей области). Это может произойти, в частности, при использовании общих имен переменных (например var). Как следствие, используйте эти методы только тогда, когда вы управляете именем переменной с псевдонимом .

function guillemots() {
  # var is intended to be local to the function,
  # aliasing a variable which comes from outside
  declare -n var="$1"
  var="«${var}»"
}

var='lolilol'
guillemots var  # Bash warnings: “var: circular name reference”
echo "$var"     # outputs anything!

Источник:

• BashFaq / 006: Как я могу использовать переменные (косвенные переменные, указатели, ссылки) или ассоциативные массивы?
• BashFAQ / 048: проблемы с командой eval и безопасностью

Пример ниже возвращает значение $ name_of_var

var=name_of_var
echo $(eval echo "\$$var")

Это должно работать:

function grep_search() {
    declare magic_variable_$1="$(ls | tail -1)"
    echo "$(tmpvar=magic_variable_$1 && echo ${!tmpvar})"
}
grep_search var  # calling grep_search with argument "var"

Это тоже будет работать

my_country_code="green"
x="country"

eval z='$'my_"$x"_code
echo $z                 ## o/p: green

В твоем случае

eval final_val='$'magic_way_to_define_magic_variable_"$1"
echo $final_val

Согласно BashFAQ / 006 , вы можете использовать readс здесь строки синтаксис для назначения косвенных переменных:

function grep_search() {
  read "$1" <<<$(ls | tail -1);
}

Использование:

$ grep_search open_box
$ echo $open_box
stack-overflow.txt

использование declare

Нет необходимости использовать префиксы, как в других ответах, ни массивы. Используйте только declare, двойные кавычки , а также расширение параметра .

Я часто использую следующую уловку для разбора списков one to nаргументов, содержащих аргументы, отформатированные как key=value otherkey=othervalue etc=etc, например:

# brace expansion just to exemplify
for variable in {one=foo,two=bar,ninja=tip}
do
  declare "${variable%=*}=${variable#*=}"
done
echo $one $two $ninja 
# foo bar tip

Но расширение списка argv вроде

for v in "$@"; do declare "${v%=*}=${v#*=}"; done

Дополнительные советы

# parse argv's leading key=value parameters
for v in "$@"; do
  case "$v" in ?*=?*) declare "${v%=*}=${v#*=}";; *) break;; esac
done
# consume argv's leading key=value parameters
while (( $# )); do
  case "$v" in ?*=?*) declare "${v%=*}=${v#*=}";; *) break;; esac
  shift
done

Вау, большая часть синтаксиса ужасна! Вот одно решение с более простым синтаксисом, если вам нужно косвенно ссылаться на массивы:

#!/bin/bash

foo_1=("fff" "ddd") ;
foo_2=("ggg" "ccc") ;

for i in 1 2 ;
do
    eval mine=( \${foo_$i[@]} ) ;
    echo ${mine[@]} ;
done ;

Для более простых случаев использования я рекомендую синтаксис, описанный в Advanced Bash-Scripting Guide .

Для индексированных массивов вы можете ссылаться на них так:

foo=(a b c)
bar=(d e f)

for arr_var in 'foo' 'bar'; do
    declare -a 'arr=("${'"$arr_var"'[@]}")'
    # do something with $arr
    echo "\$$arr_var contains:"
    for char in "${arr[@]}"; do
        echo "$char"
    done
done

На ассоциативные массивы можно ссылаться аналогичным образом, но вместо -Aвключения нужно включить .declare-a

Дополнительный метод, который не зависит от того, какая у вас версия оболочки / bash, - это использование envsubst. Например:

newvar=$(echo '$magic_variable_'"${dynamic_part}" | envsubst)

Я хочу иметь возможность создать имя переменной, содержащей первый аргумент команды

script.sh файл:

#!/usr/bin/env bash
function grep_search() {
  eval $1=$(ls | tail -1)
}

Тест:

$ source script.sh
$ grep_search open_box
$ echo $open_box
script.sh

Согласно help eval:

Выполните аргументы как команду оболочки.

Вы также можете использовать ${!var}косвенное расширение Bash , как уже упоминалось, однако оно не поддерживает получение индексов массивов.

Для дальнейшего чтения или примеров, проверьте BashFAQ / 006 о косвенности .

Нам неизвестны какие-либо хитрости, которые могут дублировать эту функциональность в оболочках POSIX или Bourne eval, что может быть сложно сделать безопасно. Итак, рассмотрите это использование на свой страх и риск .

Тем не менее, вы должны пересмотреть использование косвенного обращения согласно следующим примечаниям.

Обычно в сценариях bash вам вообще не нужны косвенные ссылки. Обычно люди ищут это решение, когда они не понимают или не знают о массивах Bash или еще не полностью рассмотрели другие функции Bash, такие как функции.

Помещение имен переменных или любого другого синтаксиса bash в параметры часто выполняется неправильно и в неподходящих ситуациях для решения проблем, которые имеют лучшие решения. Это нарушает разделение между кодом и данными и, как таковое, ставит вас на скользкий путь к ошибкам и проблемам безопасности. Непрямость может сделать ваш код менее прозрачным и трудным для понимания.

для varname=$prefix_suffixформата просто используйте:

varname=${prefix}_suffix