Determine si existe una función en bash

Question

Actualmente estoy haciendo algunas pruebas unitarias que se ejecutan desde bash. Las pruebas unitarias se inicializan, ejecutan y limpian en un script bash. Este script normalmente contiene una función init(), execute() y cleanup(). Pero no son obligatorios. Me gustaría probar si están o no definidos.

Hice esto previamente greping y seleccionando la fuente, pero me pareció incorrecto. ¿Hay una manera más elegante de hacer esto?

Editar: La siguiente sniplet funciona como un encanto:

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

Answer 1

Creo que usted está buscando el comando 'tipo'. Te dirá si algo es una función, una función incorporada, un comando externo o simplemente no está definido. Ejemplo:

$ type foo 
bash: type: foo: not found 

$ type ls 
ls is aliased to `ls --color=auto' 

$ which type 

$ type type 
type is a shell builtin 

$ type -t rvm 
function 

$ if [ -n "$(type -t rvm)" ] && [ "$(type -t rvm)" = function ]; then echo rvm is a function; else echo rvm is NOT a function; fi 
rvm is a function 

Answer 2

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

Answer 3

que podrían mejorar a:

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

Y utilizar de esta manera:

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

Answer 4

Esto le indica si existe, pero no que es una función

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

Answer 5

dragado hasta una entrada antigua ... pero recientemente tuve uso de este y probado ambas alternativas descritas con:

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 

esta creación:

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

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

declare es un helluvalot más rápido!

Answer 6

Es posible utilizar 'tipo' sin ningún tipo de comandos externos, pero hay que llamar dos veces, por lo que todavía termina aproximadamente dos veces más lento que el 'declare' versión:

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

Además este no funciona en POSIX sh, por lo que es totalmente inútil excepto como trivia!

Answer 7

prestado a otras soluciones y comentarios, se me ocurrió esto:

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

Se utiliza como ...

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

Se comprueba si el argumento dado es una función, y evita cambios de dirección y otro descremado

Answer 8

Me gustó especialmente solución de Grégory Joseph

Pero he modificado un poco para superar "cita doble feo truco":

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

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

Answer 9

Si declare es 10 veces más rápido que la prueba, esto parecería la respuesta obvia

Editar: A continuación, la opción -f es superflua con BASH, no dude en dejarlo. Personalmente, tengo problemas para recordar qué opción hace cuáles, así que solo uso ambas. -f muestra funciones, y -F muestra los nombres de las funciones.

#!/bin/sh 

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

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

La opción "-F" para declarar las causas sólo para devolver el nombre de la función encontrado, en lugar de todo el contenido.

No debería haber ninguna penalización en el rendimiento medible para el uso de/dev/null, y si le preocupa mucho:

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

o combinar los dos, para su propio disfrute sin sentido. Ambos trabajan.

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 10

Se reduce a usar 'declarar' para verificar el código de salida o de salida.

estilo de salida:

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

Uso:

isFunction some_name && echo yes || echo no 

Sin embargo, si la memoria no sirve, redirigiendo a nula es más rápido que la sustitución de salida (hablando de eso, el horrible y fuera de moda `cmd` el método debe ser desterrado y $ (cmd) usado en su lugar.) Y desde declarar devuelve verdadero/falso si se encuentra/no encuentra, y las funciones devuelven el código de salida del último comando en la función por lo que generalmente no es necesario un retorno explícito, y desde verificar el código de error es más rápido que consultar un valor de cadena e (incluso una cadena nula): estatus estilo

Salir:

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

Eso es probablemente tan breve y benigna que se puede obtener.

Answer 11

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

actualización

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

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

Answer 12

velocidad de ensayo de diferentes soluciones

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

salidas ej .:

declarar -f

0m0.037s reales usuario 0m0.024s sys 0m0.012s

declare -F

0m0.030s reales usuario 0m0.020s sys 0m0.008s tipo

con grep

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

tipo con var

0m0.770s reales usuario 0m0.096s sys 0m0.160s

-f declare (f unset)

0m0.031s reales 0m0.028s de usuario sys 0m0.000s

declare -F (f unset)

0m0.031s reales usuario 0m0.020s sys 0m0.008s tipo

con grep (f unset)

0m1.859s reales usuario 0m0.100s sys 0m0.348s

tipo con var (f establecido) La

0m0.683s reales usuario 0m0.092s sys 0m0.160s

Así declare -F f && echo function f exists. || echo function f does not exist. parece ser la mejor solución.

Answer 13

Desde mi comentario sobre otra respuesta (que guardo falta cuando vuelva a esta página)

$ 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