Déterminer si une fonction existe dans bash

Question

Actuellement, je fais quelques tests unitaires qui sont exécutés à partir de bash. Les tests unitaires sont initialisés, exécutés et nettoyés dans un script bash. Ce script contient habituellement une fonction init(), execute() et cleanup(). Mais elles ne sont pas obligatoires. J'aimerais tester si elles sont ou non définies.

Je l'ai fait précédemment en recherchant et en semant la source, mais cela ne semblait pas correct. Existe-t-il une manière plus élégante de procéder ?

Edit : Le sniplet suivant fonctionne comme un charme :

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

Answer 1

Je pense que vous cherchez la commande 'type'. Elle vous dira si quelque chose est une fonction, une fonction intégrée, une commande externe, ou simplement non définie. Exemple :

batzel@batzel-laptop:~$ type foo
bash: type: foo: not found
batzel@batzel-laptop:~$ type ls
ls is aliased to `ls --color=auto'
batzel@batzel-laptop:~$ which type
batzel@batzel-laptop:~$ type type
type is a shell builtin

Answer 2

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

Answer 3

Si declare est 10x plus rapide que test, cela semble être la réponse évidente.

#!/bin/sh

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

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

L'option "-F" de declare permet de retourner uniquement le nom de la fonction trouvée, plutôt que le contenu entier.

Il ne devrait pas y avoir de pénalité de performance mesurable pour l'utilisation de /dev/null, et si cela vous inquiète tant que ça :

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

Ou combinez les deux, pour votre propre plaisir inutile. Les deux fonctionnent.

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

Answer 4

En empruntant à d'autres solutions et commentaires, j'ai trouvé ceci :

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

Utilisé comme ...

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

Il vérifie si l'argument donné est une fonction, et évite les redirections et autres grepping.

Answer 5

Il s'agit d'un vieux post ... mais j'ai récemment eu recours à cette solution et j'ai testé les deux alternatives décrites avec :

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

cela a généré :

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

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

déclarer est sacrément plus rapide !