Stellen Sie fest, ob in bash eine Funktion vorhanden ist

Derzeit mache ich einige Unit-Tests, die von Bash ausgeführt werden. Unit-Tests werden in einem Bash-Skript initialisiert, ausgeführt und bereinigt. Dieses Skript enthält normalerweise die Funktionen init (), execute () und cleanup (). Sie sind jedoch nicht obligatorisch. Ich möchte testen, ob sie definiert sind oder nicht.

Ich habe dies zuvor getan, indem ich die Quelle ergriffen und ausgesät habe, aber es schien falsch zu sein. Gibt es eine elegantere Möglichkeit, dies zu tun?

Bearbeiten: Das folgende Sniplet wirkt wie ein Zauber:

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

Ich denke, Sie suchen nach dem Befehl 'type'. Hier erfahren Sie, ob etwas eine Funktion, eine integrierte Funktion, ein externer Befehl ist oder nicht. Beispiel:

$ 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

Wenn deklarieren 10x schneller als Test ist, scheint dies die offensichtliche Antwort zu sein.

Bearbeiten: Unten ist die -fOption mit BASH überflüssig. Sie können sie auch weglassen. Persönlich fällt es mir schwer, mich daran zu erinnern, welche Option welche macht, also benutze ich einfach beide. -f zeigt Funktionen und -F zeigt Funktionsnamen.

#!/bin/sh

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

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

Die zu deklarierende Option "-F" gibt nur den Namen der gefundenen Funktion und nicht den gesamten Inhalt zurück.

Es sollte keine messbare Leistungseinbuße für die Verwendung von / dev / null geben, und wenn es Sie so sehr beunruhigt:

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

Oder kombinieren Sie beides für Ihren eigenen sinnlosen Genuss. Sie arbeiten beide.

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

In Anlehnung an andere Lösungen und Kommentare habe ich Folgendes gefunden:

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

Benutzt als ...

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

Es prüft, ob das angegebene Argument eine Funktion ist, und vermeidet Umleitungen und andere Grepping.

Einen alten Beitrag ausgraben ... aber ich habe ihn kürzlich genutzt und beide Alternativen getestet, die beschrieben wurden mit:

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

dies erzeugte:

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

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

deklarieren ist ein helluvalot schneller!

Es läuft darauf hinaus, 'declare' zu verwenden, um entweder den Ausgabe- oder den Exit-Code zu überprüfen.

Ausgabestil:

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

Verwendung:

isFunction some_name && echo yes || echo no

Wenn jedoch Speicher bereitgestellt wird, ist die Umleitung auf Null schneller als die Ersetzung der Ausgabe (wenn man davon spricht, sollte die schreckliche und veraltete "cmd" -Methode verbannt und stattdessen $ (cmd) verwendet werden.) Und da declare true / false zurückgibt, wenn gefunden / nicht gefunden, und Funktionen geben den Exit-Code des letzten Befehls in der Funktion zurück, sodass eine explizite Rückgabe normalerweise nicht erforderlich ist. Da das Überprüfen des Fehlercodes schneller ist als das Überprüfen eines Zeichenfolgenwerts (sogar einer Nullzeichenfolge):

Statusstatus beenden:

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

Das ist wahrscheinlich so prägnant und harmlos wie möglich.

Testen verschiedener Lösungen:

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

Ausgänge zB:

test_declare (f ist Funktion)

real 0m0,055s Benutzer 0m0,041s sys 0m0,004s Exit-Code 0

test_declare2 (f ist Funktion)

real 0m0,042s Benutzer 0m0,022s sys 0m0,017s Exit-Code 0

test_type (f ist Funktion)

real 0m2,200s Benutzer 0m1,619s sys 0m1,008s Exit-Code 0

test_type2 (f ist Funktion)

real 0m0,746s Benutzer 0m0,534s sys 0m0,237s Exit-Code 0

test_declare (f nicht gesetzt)

real 0m0,040s Benutzer 0m0,029s sys 0m0,010s Exit-Code 1

test_declare2 (f nicht gesetzt)

real 0m0,038s Benutzer 0m0,038s sys 0m0,000s Exit-Code 1

test_type (f nicht gesetzt)

real 0m2,438s Benutzer 0m1,678s sys 0m1,045s Exit-Code 1

test_type2 (f nicht gesetzt)

real 0m0,805s Benutzer 0m0,541s sys 0m0,274s Exit-Code 1

test_declare (f ist string)

real 0m0,043s Benutzer 0m0,034s sys 0m0,007s Exit-Code 1

test_declare2 (f ist string)

real 0m0,039s Benutzer 0m0,035s sys 0m0,003s Exit-Code 1

test_type (f ist string)

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

test_type2 (f ist string)

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

Also declare -F fscheint die beste Lösung zu sein.

Aus meinem Kommentar zu einer anderen Antwort (die ich immer wieder vermisse, wenn ich auf diese Seite zurückkomme)

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

aktualisieren

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

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

Ich würde es verbessern, um:

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

Und benutze es so:

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

Dies sagt Ihnen, ob es existiert, aber nicht, dass es eine Funktion ist

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

Besonders gut hat mir die Lösung von Grégory Joseph gefallen

Aber ich habe es ein wenig modifiziert, um den "hässlichen Trick mit doppelten Anführungszeichen" zu überwinden:

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

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

Es ist möglich, 'type' ohne externe Befehle zu verwenden, aber Sie müssen es zweimal aufrufen, damit es immer noch etwa doppelt so langsam ist wie die 'declare'-Version:

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

Außerdem funktioniert dies in POSIX sh nicht, so dass es völlig wertlos ist, außer als Trivia!