Déterminer si une fonction existe dans bash

Actuellement, je fais des 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 généralement des fonctions init (), execute () et cleanup (). Mais ils ne sont pas obligatoires. Je voudrais tester s'ils sont définis ou non.

Je l'ai fait précédemment en greffe et en semant la source, mais cela semblait faux. Y a-t-il une manière plus élégante de faire cela?

Edit: Le sniplet suivant fonctionne comme un charme:

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

Je pense que vous recherchez la commande «type». Il vous dira si quelque chose est une fonction, une fonction intégrée, une commande externe ou tout simplement non définie. Exemple:

$ 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

Si déclarer est 10 fois plus rapide que le test, cela semblerait la réponse évidente.

Edit: Ci-dessous, l' -foption est superflue avec BASH, n'hésitez pas à la laisser de côté. Personnellement, j'ai du mal à me souvenir quelle option fait quoi, alors j'utilise simplement les deux. -f montre les fonctions et -F montre les noms des fonctions.

#!/bin/sh

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

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

L'option "-F" à déclarer l'amène à ne renvoyer que le nom de la fonction trouvée, plutôt que le contenu entier.

Il ne devrait y avoir aucune pénalité mesurable en termes de performances pour l'utilisation de / dev / null, et si cela vous inquiète autant:

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. Ils fonctionnent tous les deux.

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

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.

Récupérer un ancien article ... mais j'ai récemment eu recours à cela 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 un helluvalot plus rapide!

Cela revient à utiliser 'declare' pour vérifier la sortie ou le code de sortie.

Style de sortie:

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

Usage:

isFunction some_name && echo yes || echo no

Cependant, si la mémoire est bonne, la redirection vers null est plus rapide que la substitution de sortie (en parlant de, la méthode horrible et obsolète `cmd` devrait être bannie et $ (cmd) utilisée à la place.) Et puisque declare retourne vrai / faux si trouvé / introuvable, et les fonctions renvoient le code de sortie de la dernière commande de la fonction, donc un retour explicite n'est généralement pas nécessaire, et comme la vérification du code d'erreur est plus rapide que la vérification d'une valeur de chaîne (même une chaîne nulle):

Style de statut de sortie:

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

C'est probablement aussi succinct et bénin que possible.

Tester différentes solutions:

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

sorties par exemple:

test_declare (f est une fonction)

réel 0m0,055s utilisateur 0m0,041s sys 0m0,004s code de sortie 0

test_declare2 (f est une fonction)

réel 0m0,042s utilisateur 0m0,022s sys 0m0,017s code de sortie 0

test_type (f est une fonction)

réel 0m2,200s utilisateur 0m1,619s sys 0m1,008s code de sortie 0

test_type2 (f est une fonction)

réel 0m0,746s utilisateur 0m0,534s sys 0m0,237s code de sortie 0

test_declare (f non défini)

réel 0m0,040s utilisateur 0m0,029s sys 0m0,010s code de sortie 1

test_declare2 (f non défini)

réel 0m0,038s utilisateur 0m0,038s sys 0m0,000s code de sortie 1

test_type (f non défini)

réel 0m2,438s utilisateur 0m1,678s sys 0m1,045s code de sortie 1

test_type2 (f non défini)

réel 0m0,805s utilisateur 0m0,541s sys 0m0,274s code de sortie 1

test_declare (f est une chaîne)

réel 0m0,043s utilisateur 0m0,034s sys 0m0,007s code de sortie 1

test_declare2 (f est une chaîne)

réel 0m0,039s utilisateur 0m0,035s sys 0m0,003s code de sortie 1

test_type (f est une chaîne)

réel 0m2,394s utilisateur 0m1,679s sys 0m1,035s code de sortie 1

test_type2 (f est une chaîne)

réel 0m0,851s utilisateur 0m0,554s sys 0m0294s code de sortie 1

Cela declare -F fsemble donc être la meilleure solution.

De mon commentaire sur une autre réponse (qui me manque toujours en revenant sur cette page)

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

mettre à jour

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

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

Je l'améliorerais pour:

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

Et utilisez-le comme ceci:

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

Cela vous indique s'il existe, mais pas que c'est une fonction

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

J'ai particulièrement aimé la solution de Grégory Joseph

Mais je l'ai un peu modifié pour surmonter le "truc laid des guillemets doubles":

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

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

Il est possible d'utiliser 'type' sans aucune commande externe, mais vous devez l'appeler deux fois, donc cela finit toujours par être environ deux fois plus lent que la version 'declare':

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

De plus, cela ne fonctionne pas dans POSIX sh, donc cela ne vaut absolument rien sauf pour des anecdotes!