Bash: передать функцию в качестве параметра

Если вам не нужно ничего особенного, например, задержки вычисления имени функции или ее аргументов, вам не нужно eval:

function x()      { echo "Hello world";          }
function around() { echo before; $1; echo after; }

around x

делает то, что вы хотите. Вы даже можете передать функцию и ее аргументы следующим образом:

function x()      { echo "x(): Passed $1 and $2";  }
function around() { echo before; "$@"; echo after; }

around x 1st 2nd

отпечатки

before
x(): Passed 1st and 2nd
after

Я думаю, что никто толком не ответил на вопрос. Он не спрашивал, может ли он повторять строки по порядку. Скорее автор вопроса хочет знать, может ли он имитировать поведение указателя функции.

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

От автора:

function x() {
  echo "Hello world"
}

function around() {
  echo "before"
  ($1)                   <------ Only change
  echo "after"
}

around x

Чтобы расширить это, у нас будет функция x echo "Hello world:$1", чтобы показать, когда действительно происходит выполнение функции. Мы передадим строку, которая является именем функции «x»:

function x() {
  echo "Hello world:$1"
}

function around() {
  echo "before"
  ($1 HERE)                   <------ Only change
  echo "after"
}

around x

Чтобы описать это, строка «x» передается в функцию around(), которая выводит «before», вызывает функцию x (через переменную $1, первый параметр, переданный в round), передавая аргумент «HERE», наконец выводит после .

Кроме того, это методология использования переменных в качестве имен функций. Переменные фактически содержат строку, которая является именем функции, и ($variable arg1 arg2 ...) вызывает функцию, передавая аргументы. Смотри ниже:

function x(){
    echo $3 $1 $2      <== just rearrange the order of passed params
}

Z="x"        # or just Z=x

($Z  10 20 30)

дает: 30 10 20, где мы выполнили функцию с именем «x», хранящуюся в переменной Z, и передали параметры 10 20 и 30.

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

В bash это не указатели на функции, а переменные, ссылающиеся на имена функций, которые вы позже будете использовать.

нет необходимости использовать eval

function x() {
  echo "Hello world"
}

function around() {
  echo "before"
  var=$($1)
  echo "after $var"
}

around x

Вы не можете передать в функцию ничего, кроме строк. Подстановки процессов могут их имитировать. Bash имеет тенденцию удерживать FIFO открытым до тех пор, пока команда не завершится.

Вот быстрый глупый

foldl() {
    echo $(($(</dev/stdin)$2))
} < <(tr '\n' "$1" <$3)

# Sum 20 random ints from 0-999
foldl + 0 <(while ((n=RANDOM%999,x++<20)); do echo $n; done)

Функции можно экспортировать, но это не так интересно, как кажется на первый взгляд. Я считаю, что это в основном полезно для того, чтобы сделать функции отладки доступными для скриптов или других программ, которые запускают скрипты.

(
    id() {
        "$@"
    }

    export -f id
    exec bash -c 'echowrap() { echo "$1"; }; id echowrap hi'
)

id по-прежнему получает только строку, которая является именем функции (автоматически импортированной из сериализации в среде) и ее аргументами.

Комментарий Pumbaa80 к другому ответу также хорош (eval $(declare -F "$1")), но в основном он полезен для массивов, а не для функций, поскольку они всегда глобальны. Если вы запустите это внутри функции, все, что она сделает, это переопределит ее, так что никакого эффекта. Его нельзя использовать для создания замыканий, частичных функций или «экземпляров функций», зависящих от того, что происходит в текущей области видимости. В лучшем случае это можно использовать для хранения определения функции в строке, которая переопределяется в другом месте, но эти функции также могут быть жестко запрограммированы, если, конечно, не используется eval

В принципе, Bash нельзя использовать таким образом.

Лучшим подходом является использование локальных переменных в ваших функциях. Затем возникает проблема, как передать результат вызывающей стороне. Один из механизмов заключается в использовании подстановки команд:

function myfunc()
{
    local  myresult='some value'
    echo "$myresult"
}

result=$(myfunc)   # or result=`myfunc`
echo $result

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

У вас должно получиться что-то вроде:

function around()
{
  echo 'before';
  echo `$1`;
  echo 'after';
}

Затем вы можете позвонить around x

eval, вероятно, единственный способ сделать это. Единственным реальным недостатком является его аспект безопасности, так как вам нужно убедиться, что ничего вредоносного не передается, и будут вызываться только те функции, которые вы хотите вызвать (наряду с проверкой того, что в нем нет неприятных символов, таких как ';' в нем же).

Так что, если вы тот, кто вызывает код, то eval, вероятно, единственный способ сделать это. Обратите внимание, что есть и другие формы eval, которые, вероятно, тоже будут работать с подкомандами ($() и ``), но они не безопаснее и дороже.