Визначте, чи існує функція в bash

В даний час я роблю одиничні тести, які виконуються з bash. Блокові тести ініціалізуються, виконуються та очищаються за допомогою bash-сценарію. Цей сценарій зазвичай містить функції init (), Execute () та очищення (). Але вони не є обов'язковими. Я хотів би перевірити, чи вони не визначені.

Я робив це раніше, зігріваючи та відкладаючи джерело, але це здавалося неправильним. Чи є більш елегантний спосіб це зробити?

Редагувати: Наступний фрагмент працює як шарм:

fn_exists()
{
    LC_ALL=C type $1 | grep -q 'shell function'
}

Я думаю, ти шукаєш команду 'type'. Він розповість, чи є щось функцією, вбудованою функцією, зовнішньою командою чи просто не визначено. Приклад:

$ 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

$ g() { return; }
$ declare -f g > /dev/null; echo $?
0
$ declare -f j > /dev/null; echo $?
1

Якщо заявити в 10 разів швидше, ніж тест, це здасться очевидною відповіддю.

Редагувати: Внизу -fваріант із BASH є зайвим, сміливо залишайте його. Особисто мені не вдається запам'ятати, який варіант робить який, тому я просто використовую обидва. -f показує функції, а -F показує назви функцій.

#!/bin/sh

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

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

Опція "-F" для оголошення викликає повернення лише імені знайденої функції, а не всього вмісту.

Не повинно бути жодного вимірюваного покарання за використання / dev / null, і якщо це вас дуже турбує:

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

Або комбінуйте два, для власного безглуздого задоволення. Вони обидва працюють.

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

Позичивши інші рішення та коментарі, я придумав таке:

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

Використовується як ...

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

Він перевіряє, чи є даний аргумент функцією, і уникає перенаправлень та інших помилок.

Викопування старого допису ... але нещодавно я користувався цим і перевіряв обидва варіанти, описані:

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

заявити, що це пекло швидше!

Це зводиться до використання "оголосити" для перевірки вихідного або вихідного коду.

Стиль виводу:

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

Використання:

isFunction some_name && echo yes || echo no

Однак якщо пам'ять служить, перенаправлення на null відбувається швидше, ніж підміна виводу (якщо говорити про, жахливий і застарілий метод `cmd 'слід відмовити, а замість цього використовувати $ (cmd). не знайдено, і функції повертають код виходу останньої команди у функції, тому явного повернення зазвичай не потрібно, а оскільки перевірка коду помилки швидше, ніж перевірка значення рядка (навіть нульового рядка):

Вихід із стилю статусу:

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

Мабуть, це настільки ж лаконічно і доброзичливо, як ви можете отримати.

Тестування різних рішень:

#!/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 $1; 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 - функція)

реальний користувач 0m0,055s 0m0,041s sys 0m0,004s код виходу 0

test_declare2 (функція f)

реальний користувач 0m0,042s 0m0,022s sys 0m0,017s код виходу 0

test_type (f - функція)

реальний користувач 0m2,200s 0m1,619s sys 0m1,008s код виходу 0

test_type2 (f - функція)

реальний користувач 0m0,746s 0m0,534s sys 0m0,237s код виходу 0

test_declare (f не встановлено)

реальний користувач 0m0,040s 0m0,029s sys 0m0,010s код виходу 1

test_declare2 (f unset)

реальний користувач 0m0,038s 0m0,038s sys 0m0,000s код виходу 1

test_type (f unset)

реальний користувач 0m2,438s 0m1,678s sys 0m1,045s код виходу 1

test_type2 (f знято)

реальний користувач 0m0,805s 0m0,541s sys 0m0,274s код виходу 1

test_declare (f - рядок)

реальний користувач 0m0,043s 0m0,034s sys 0m0,007s код виходу 1

test_declare2 (f - рядок)

реальний користувач 0m0,039s 0m0,035s sys 0m0,003s код виходу 1

test_type (f - рядок)

реальний користувач 0m2,394s 0m1,679s sys 0m1,035s код виходу 1

test_type2 (f - рядок)

реальний користувач 0m0,851s 0m0,554s sys 0m0,294s код виходу 1

Так declare -F fздається, найкраще рішення.

З мого коментаря до іншої відповіді (яку я постійно пропускаю, коли повертаюся на цю сторінку)

$ fn_exists() { test x$(type -t $1) = 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

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

оновлення

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

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

Я б вдосконалив її до:

fn_exists()
{
    type $1 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 $1 >/dev/null 2>&1;
}

Особливо мені сподобалось рішення Грегорі Йосифа

Але я трохи змінив це, щоб подолати "потворну хитрість подвійної цитати":

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

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

Можна використовувати "type" без жодних зовнішніх команд, але ви повинні викликати його двічі, щоб він все-таки закінчувався приблизно вдвічі повільніше, ніж версія "оголосити":

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

Плюс це не працює в POSIX sh, тому це абсолютно нічого, крім дрібниць!