Sprawdź, czy funkcja istnieje w bash

Obecnie przeprowadzam kilka testów jednostkowych wykonywanych z poziomu bash. Testy jednostkowe są inicjowane, wykonywane i czyszczone w skrypcie bash. Ten skrypt zwykle zawiera funkcje init (), execute () i cleanup (). Ale nie są obowiązkowe. Chciałbym sprawdzić, czy są, czy nie są zdefiniowane.

Zrobiłem to wcześniej, szukając źródła i szukając źródła, ale wydawało się to złe. Czy jest na to bardziej elegancki sposób?

Edycja: Poniższy fragment kodu działa jak urok:

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

Myślę, że szukasz polecenia „typ”. Powie ci, czy coś jest funkcją, funkcją wbudowaną, poleceniem zewnętrznym, czy po prostu nie jest zdefiniowane. Przykład:

$ 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

Jeśli deklaracja jest 10 razy szybsza niż test, wydaje się to oczywistą odpowiedzią.

Edycja: poniżej -fopcja jest zbędna w przypadku BASH, możesz ją pominąć. Osobiście mam problem z zapamiętaniem, która opcja to robi, więc używam obu. -f pokazuje funkcje, a -F pokazuje nazwy funkcji.

#!/bin/sh

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

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

Opcja „-F” do zadeklarowania powoduje, że zwraca tylko nazwę znalezionej funkcji, a nie całą zawartość.

Nie powinno być żadnych wymiernych ograniczeń wydajności za używanie / dev / null, a jeśli tak bardzo cię to martwi:

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

Lub połącz te dwa elementy, aby uzyskać własną bezcelową przyjemność. Oboje działają.

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

Pożyczając od innych rozwiązań i komentarzy, wymyśliłem to:

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' ]
}

Użyty jako ...

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

Sprawdza, czy dany argument jest funkcją i unika przekierowań i innych greppingów.

Pogłębiam stary post ... ale ostatnio z niego skorzystałem i przetestowałem obie alternatywy opisane za pomocą:

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

to wygenerowało:

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

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

deklaruj, że jest helluvalot szybciej!

Sprowadza się do użycia polecenia „deklaruj” do sprawdzenia kodu wyjściowego lub kodu zakończenia.

Styl wyjściowy:

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

Stosowanie:

isFunction some_name && echo yes || echo no

Jeśli jednak pamięć służy, przekierowanie na wartość NULL jest szybsze niż podstawianie danych wyjściowych (mówiąc o tym, że okropna i przestarzała metoda `cmd` powinna zostać usunięta, a zamiast niej należy użyć $ (cmd).) A ponieważ deklaracja zwraca true / false, jeśli znaleziono / nie znaleziono, a funkcje zwracają kod wyjścia ostatniego polecenia w funkcji, więc jawny zwrot zwykle nie jest konieczny, a ponieważ sprawdzenie kodu błędu jest szybsze niż sprawdzenie wartości ciągu (nawet ciągu zerowego):

Styl statusu wyjścia:

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

To prawdopodobnie tak zwięzłe i łagodne, jak to tylko możliwe.

Testowanie różnych rozwiązań:

#!/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

dane wyjściowe np .:

test_declare (f jest funkcją)

rzeczywisty 0m0,055s użytkownik 0m0,041s sys 0m0,004s kod wyjścia 0

test_declare2 (f jest funkcją)

rzeczywisty 0m0,042s użytkownik 0m0,022s sys 0m0,017s kod wyjścia 0

test_type (f jest funkcją)

rzeczywisty 0m2200s użytkownik 0m1,619s sys 0m1,008s kod wyjścia 0

test_type2 (f jest funkcją)

rzeczywisty 0m0,746s użytkownik 0m0,534s sys 0m0,237s kod wyjścia 0

test_declare (f rozbrojony)

rzeczywisty 0m0,040s użytkownik 0m0,029s sys 0m0,010s kod wyjścia 1

test_declare2 (f rozbrojony)

rzeczywisty 0m0,038s użytkownik 0m0,038s sys 0m0,000s kod wyjścia 1

test_type (f rozbrojony)

rzeczywisty 0m2,438s użytkownik 0m1,678s sys 0m1,045s kod wyjścia 1

test_type2 (f nieustawione)

rzeczywisty 0m0,805s użytkownik 0m0,541s sys 0m0,274s kod wyjścia 1

test_declare (f to string)

rzeczywisty 0m0,043s użytkownik 0m0,034s sys 0m0,007s kod wyjścia 1

test_declare2 (f to string)

rzeczywisty 0m0,039s użytkownik 0m0,035s sys 0m0,003s kod wyjścia 1

test_type (f to string)

rzeczywisty 0m2 394s użytkownik 0m1,679s sys 0m1,035s kod wyjścia 1

test_type2 (f to string)

rzeczywisty 0m0,851s użytkownik 0m0,554s sys 0m0,294s kod wyjścia 1

Więc declare -F fwydaje się być najlepszym rozwiązaniem.

Z mojego komentarza do innej odpowiedzi (której brakuje mi, gdy wracam na tę stronę)

$ 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
}

aktualizacja

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

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

Poprawiłbym to, aby:

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

I użyj tego w ten sposób:

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

To mówi ci, jeśli istnieje, ale nie, że jest to funkcja

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

Szczególnie podobało mi się rozwiązanie Grégory Joseph

Ale zmodyfikowałem to trochę, aby pokonać „podwójny cytat brzydkiej sztuczki”:

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

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

Możliwe jest użycie „type” bez żadnych zewnętrznych poleceń, ale musisz wywołać go dwa razy, więc nadal kończy się to około dwa razy wolniej niż wersja „deklaruj”:

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

Plus to nie działa w POSIX sh, więc jest całkowicie bezwartościowe, z wyjątkiem ciekawostek!