web-dev-qa-db-fra.com

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 les fonctions init (), execute () et cleanup (). Mais ils ne sont pas obligatoires. Je voudrais tester si elles sont ou ne sont pas définies.

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

Edit: Le sniplet suivant fonctionne à merveille:

fn_exists()
{
    LC_ALL=C type $1 | grep -q 'Shell function'
}
bashfunctiontestingscripting
163
terminus

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 pas 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
175
JBB
$ g() { return; }
$ declare -f g > /dev/null; echo $?
0
$ declare -f j > /dev/null; echo $?
1
69
Allan Wind

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

Edit: ci-dessous, le -f L'option est superflue avec BASH, n'hésitez pas à la laisser. Personnellement, j'ai du mal à me rappeler quelle option fait laquelle, alors je n'utilise que les deux. - f affiche les fonctions et - F indique 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 entraîne uniquement le retour du nom de la fonction trouvée, plutôt que le contenu entier.

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

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 plus grand plaisir. Ils travaillent 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
36
Orwellophile

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 greps.

18
Grégory Joseph

Draguer un ancien poste ... mais j’ai récemment eu recours à cela et 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 vite!

9
jonathanserafini

Cela revient à utiliser 'declare' pour vérifier le code de 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 utile, la redirection vers null est plus rapide que la substitution de la sortie (en parlant de, la méthode `cmd` horrible et obsolète devrait être bannie et utilisée à la place $ (cmd).) Et puisque declare renvoie true/false si trouvé/non trouvé et les fonctions renvoient le code de sortie de la dernière commande de la fonction. Un retour explicite n'est donc généralement pas nécessaire. Depuis 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 vous pouvez obtenir.

6
Scott

Tester la vitesse de différentes solutions

#!/bin/bash

f () {
echo 'This is a test function.'
echo 'This has more than one command.'
return 0
}

test_declare () {
    declare -f f > /dev/null
}

test_declare2 () {
    declare -F f > /dev/null
}

test_type () {
    type -t f | grep -q 'function'
}

test_type2 () {
    local var=$(type -t f)
    [[ "${var-}" = function ]]
}

post=
for j in 1 2; do
echo
echo 'declare -f' $post
time for i in $(seq 1 1000); do test_declare; done
echo
echo 'declare -F' $post
time for i in $(seq 1 1000); do test_declare2; done
echo
echo 'type with grep' $post
time for i in $(seq 1 1000); do test_type; done
echo
echo 'type with var' $post
time for i in $(seq 1 1000); do test_type2; done
unset -f f
post='(f unset)'
done

sorties par exemple:

déclarer -f

real 0m0.037s 0m0.024s sys 0m0.012s

déclarer -F

real 0m0.030s 0m0.020s sys 0m0.008s

taper avec grep

real 0m1.772s 0m0.084s sys 0m0.340s

tapez avec var

real 0m0.770s 0m0.096s sys 0m0.160s

déclarer -f (f non défini)

real 0m0.031s utilisateur 0m0.028s sys 0m0.000s

déclarer -F (f non défini)

real 0m0.031s 0m0.020s sys 0m0.008s

taper avec grep (f non défini)

real 0m1.859s 0m0.100s sys 0m0.348s

taper avec var (f non défini)

réel 0m0.683s utilisateur 0m0.092s sys 0m0.160s

Alors declare -F f && echo function f exists. || echo function f does not exist. semble être la meilleure solution.

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

mise à jour

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

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

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

Mais je l'ai un peu modifié pour surmonter "le truc laide entre guillemets":

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

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

Cela vous dit si cela existe, mais pas que c'est une fonction

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

De mon commentaire sur une autre réponse (qui me manque quand je reviens à 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
2
qneill

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
1
user186791

Il est possible d'utiliser 'type' sans aucune commande externe, mais vous devez l'appeler deux fois pour qu'il finisse 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 c'est totalement inutile, sauf comme une anecdote!

0
Noah Spurrier