Определите, существует ли функция в bash

Я думаю, вы ищете команду типа. Он скажет вам, является ли что-то функцией, встроенной функцией, внешней командой или просто не определено. Пример:

$ LC_ALL=C type foo
bash: type: foo: not found

$ LC_ALL=C type ls
ls is aliased to `ls --color=auto'

$ which type

$ LC_ALL=C type type
type is a shell builtin

$ LC_ALL=C type -t rvm
function

$ if [ -n "$(LC_ALL=C type -t rvm)" ] && [ "$(LC_ALL=C type -t rvm)" = function ]; then echo rvm is a function; else echo rvm is NOT a function; fi
rvm is a function

Встроенная команда bash declare имеет параметр -F, который отображает все определенные имена функций. Если заданы аргументы имени, он покажет, какие из этих функций существуют, и, если все они это сделают, установит статус соответственно:

$ fn_exists() { declare -F "" > /dev/null; }

$ unset f
$ fn_exists f && echo yes || echo no
no

$ f() { return; }
$ fn_exist f && echo yes || echo no
yes

Я бы улучшил его до:

fn_exists()
{
    type  2>/dev/null | grep -q 'is a function'
}

И используйте это так:

fn_exists test_function
if [ $? -eq 0 ]; then
    echo 'Function exists!'
else
    echo 'Function does not exist...'
fi

Это говорит вам, существует ли он, но не то, что это функция

fn_exists()
{
  type  >/dev/null 2>&1;
}

Копаем старый пост ... но недавно я использовал это и протестировал обе альтернативы, описанные с помощью:

test_declare () {
    a () { echo 'a' ;}

    declare -f a > /dev/null
}

test_type () {
    a () { echo 'a' ;}
    type a | grep -q 'is a function'
}

echo 'declare'
time for i in $(seq 1 1000); do test_declare; done
echo 'type'
time for i in $(seq 1 100); do test_type; done

это сгенерировало:

real    0m0.064s
user    0m0.040s
sys     0m0.020s
type

real    0m2.769s
user    0m1.620s
sys     0m1.130s

объявить шибко быстрее!

Можно использовать 'type' без каких-либо внешних команд, но вы должны вызвать его дважды, поэтому он все равно будет примерно в два раза медленнее, чем версия 'declare':

test_function () {
        ! type -f  >/dev/null 2>&1 && type -t  >/dev/null 2>&1
}

К тому же это не работает в POSIX sh, так что ничего не стоит, кроме как пустяков!

Пользуясь другими решениями и комментариями, я пришел к следующему:

fn_exists() {
  # appended double quote is an ugly trick to make sure we do get a string -- if  is not a known command, type does not output anything
  [ `type -t `"" == 'function' ]
}

Используется как ...

if ! fn_exists $FN; then
    echo "Hey, $FN does not exist ! Duh."
    exit 2
fi

Он проверяет, является ли данный аргумент функцией, и избегает перенаправлений и другого поиска.

Особенно понравилось решение от Грегори Жозеф

Но я немного изменил его, чтобы обойти "уродливый трюк с двойными кавычками":

function is_executable()
{
    typeset TYPE_RESULT = "`type -t `"

    if [ "$TYPE_RESULT" == 'function' ]; then
        return 0
    else
        return 1
    fi
}

Если declare в 10 раз быстрее, чем test, это кажется очевидным ответом.

Обновлено: ниже параметр -f является излишним для BASH, не стесняйтесь его опускать. Лично мне сложно вспомнить, какой вариант что делает, поэтому я просто использую оба. -f показывает функции, а -F показывает имена функций.

#!/bin/sh

function_exists() {
    declare -f -F  > /dev/null
    return $?
}

function_exists function_name && echo Exists || echo No such function

Параметр "-F" для объявления заставляет его возвращать только имя найденной функции, а не все содержимое.

Не должно быть заметного снижения производительности при использовании / dev / null, и если это вас так сильно беспокоит:

fname=`declare -f -F `
[ -n "$fname" ]    && echo Declare -f says $fname exists || echo Declare -f says  does not exist

Или скомбинируйте то и другое для собственного бессмысленного удовольствия. Они оба работают.

fname=`declare -f -F `
errorlevel=$?
(( ! errorlevel )) && echo Errorlevel says  exists     || echo Errorlevel says  does not exist
[ -n "$fname" ]    && echo Declare -f says $fname exists || echo Declare -f says  does not exist

Это сводится к использованию 'declare' для проверки вывода или кода выхода.

Стиль вывода:

isFunction() { [[ "$(declare -Ff "")" ]]; }

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

isFunction some_name && echo yes || echo no

Однако, если память не используется, перенаправление на null выполняется быстрее, чем подстановка вывода (кстати, ужасный и устаревший метод cmd должен быть изгнан и вместо него должен использоваться $ (cmd)). И поскольку declare возвращает true / false, если найдено / не найден, и функции возвращают код выхода последней команды в функции, поэтому явный возврат обычно не требуется, а поскольку проверка кода ошибки выполняется быстрее, чем проверка строкового значения (даже пустой строки):

Стиль статуса выхода:

isFunction() { declare -Ff "" >/dev/null; }

Это, вероятно, настолько лаконично и мягко, насколько это возможно.

fn_exists()
{
   [[ $(type -t ) == function ]] && return 0
}

Обновить

isFunc () 
{ 
    [[ $(type -t ) == function ]]
}

$ isFunc isFunc
$ echo $?
0
$ isFunc dfgjhgljhk
$ echo $?
1
$ isFunc psgrep && echo yay
yay
$

Тестируем разные решения:

#!/bin/bash

test_declare () {
    declare -f f > /dev/null
}

test_declare2 () {
    declare -F f > /dev/null
}

test_type () {
    type -t f | grep -q 'function'
}

test_type2 () {
     [[ $(type -t f) = function ]]
}

funcs=(test_declare test_declare2 test_type test_type2)

test () {
    for i in $(seq 1 1000); do ; done
}

f () {
echo 'This is a test function.'
echo 'This has more than one command.'
return 0
}
post='(f is function)'

for j in 1 2 3; do

    for func in ${funcs[@]}; do
        echo $func $post
        time test $func
        echo exit code $?; echo
    done

    case $j in
    1)  unset -f f
        post='(f unset)'
        ;;
    2)  f='string'
        post='(f is string)'
        ;;
    esac
done

выходы, например:

test_declare (f is function)

real 0m0,055s user 0m0,041s sys 0m0,004s exit code 0

test_declare2 (f is function)

real 0m0,042s user 0m0,022s sys 0m0,017s exit code 0

test_type (f is function)

real 0m2,200s user 0m1,619s sys 0m1,008s exit code 0

test_type2 (f is function)

real 0m0,746s user 0m0,534s sys 0m0,237s exit code 0

test_declare (f unset)

real 0m0,040s user 0m0,029s sys 0m0,010s exit code 1

test_declare2 (f unset)

real 0m0,038s user 0m0,038s sys 0m0,000s exit code 1

test_type (f unset)

real 0m2,438s user 0m1,678s sys 0m1,045s exit code 1

test_type2 (f unset)

real 0m0,805s user 0m0,541s sys 0m0,274s exit code 1

test_declare (f is string)

real 0m0,043s user 0m0,034s sys 0m0,007s exit code 1

test_declare2 (f is string)

real 0m0,039s user 0m0,035s sys 0m0,003s exit code 1

test_type (f is string)

real 0m2,394s user 0m1,679s sys 0m1,035s exit code 1

test_type2 (f is string)

real 0m0,851s user 0m0,554s sys 0m0,294s exit code 1

Так что declare -F f кажется лучшим решением.

Из моего комментария к другому ответу (который мне не хватает, когда я возвращаюсь на эту страницу)

$ fn_exists() { test x$(type -t ) = xfunction; }
$ fn_exists func1 && echo yes || echo no
no
$ func1() { echo hi from func1; }
$ func1
hi from func1
$ fn_exists func1 && echo yes || echo no
yes

Вызов функции, если она определена.

Известное имя функции. Скажем, имя my_function, затем используйте

[[ "$(type -t my_function)" == 'function' ]] && my_function;
# or
[[ "$(declare -fF my_function)" ]] && my_function;

Имя функции в переменной. Если мы объявим func=my_function, мы сможем использовать

[[ "$(type -t $func)" == 'function' ]] && $func;
# or
[[ "$(declare -fF $func)" ]] && $func;

Логическая инверсия с тем же результатом. Все сразу. Здесь мы используем || вместо &&.

[[ "$(type -t my_function)" != 'function' ]] || my_function;
[[ ! "$(declare -fF my_function)" ]] || my_function;
func=my_function
[[ "$(type -t $func)" != 'function' ]] || $func;
[[ ! "$(declare -fF $func)" ]] || $func;

Опасная ситуация при использовании || с return внутри функции
Следующая комбинация заставит вас завершить процесс оболочки.

# Some script execution strict mode. The essence is in the "-e"
set -euf +x -o pipefail

function run_if_exists(){
    my_function=

    [[ "$(type -t my_function)" != 'function' ]] || return;

    $my_function
}

run_if_exists  non_existing_function

Это потому, что приведенное выше эквивалентно

set -e
function run_if_exists(){
    return 1;
}
run_if_exists

который всегда будет терпеть неудачу. Чтобы предотвратить это, вы должны использовать || { true; return; } или что-то еще в таком предусловии вашей функции.

    [[ "$(type -t my_function)" != 'function' ]] || { true; return; }