Determinar si existe una función en bash

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 generalmente contiene funciones init (), execute () y cleanup (). Pero no son obligatorios. Me gustaría probar si están o no definidos.

Hice esto previamente codificando y enviando la fuente, pero parecía estar mal. ¿Hay alguna forma más elegante de hacer esto?

Editar: el siguiente fragmento funciona como un encanto:

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

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

$ 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 declarar es 10 veces más rápido que la prueba, esta parece ser la respuesta obvia.

Editar: a continuación, la -fopción es superflua con BASH, no dude en dejarla fuera. Personalmente, tengo problemas para recordar qué opción hace cuál, así que solo uso ambas. -f muestra funciones y -F muestra nombres de 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 hace que solo devuelva el nombre de la función encontrada, en lugar de todo el contenido.

No debería haber ninguna penalización de rendimiento medible por usar / dev / null, y si te preocupa tanto:

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

O combine 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

Tomando prestado de 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' ]
}

Usado como ...

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

Comprueba si el argumento dado es una función y evita redireccionamientos y otros grepping.

Desenterrando una publicación anterior ... pero recientemente tuve uso de esto y probé 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

esto generó:

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

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

declarar es un helluvalot más rápido!

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

Estilo de salida:

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

Uso:

isFunction some_name && echo yes || echo no

Sin embargo, si la memoria sirve, la redirección a nulo es más rápida que la sustitución de salida (hablando de, el método `cmd` horrible y anticuado debe ser desterrado y $ (cmd) utilizado en su lugar). Y dado que declare devuelve verdadero / falso si se encuentra / no encontrado, 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 dado que verificar el código de error es más rápido que verificar un valor de cadena (incluso una cadena nula):

Estilo de estado de salida:

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

Probablemente sea lo más sucinto y benigno posible.

Probar diferentes soluciones:

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

salidas, por ejemplo:

test_declare (f es función)

usuario real 0m0,055s 0m0,041s sys 0m0,004s código de salida 0

test_declare2 (f es función)

0m0,042s real usuario 0m0,022s sys 0m0,017s código de salida 0

test_type (f es función)

usuario real 0m2.200s 0m1,619s sys 0m1,008s código de salida 0

test_type2 (f es función)

real 0m0,746s usuario 0m0,534s sys 0m0,237s código de salida 0

test_declare (f sin establecer)

0m0,040s usuario real 0m0,029s sys 0m0,010s código de salida 1

test_declare2 (f sin establecer)

usuario real 0m0,038s 0m0,038s sys 0m0,000s código de salida 1

test_type (f sin establecer)

usuario real 0m2,438s 0m1,678s sys 0m1,045s código de salida 1

test_type2 (f sin establecer)

0m0,805s real usuario 0m0,541s sys 0m0,274s código de salida 1

test_declare (f es una cadena)

0m0,043s real usuario 0m0,034s sys 0m0,007s código de salida 1

test_declare2 (f es una cadena)

0m0,039s real usuario 0m0,035s sys 0m0,003s código de salida 1

test_type (f es una cadena)

usuario real 0m2,394s 0m1,679s sys 0m1,035s código de salida 1

test_type2 (f es una cadena)

real 0m0,851s usuario 0m0,554s sys 0m0,294s código de salida 1

Entonces declare -F fparece ser la mejor solución.

De mi comentario sobre otra respuesta (que sigo perdiendo cuando vuelvo 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

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

actualizar

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

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

Lo mejoraría para:

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

Y úsalo así:

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

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

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

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

Pero lo he modificado un poco para superar el "truco feo entre comillas dobles":

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

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

Es posible usar 'type' sin ningún comando externo, pero debe llamarlo dos veces, por lo que aún termina aproximadamente el doble de lento que la versión 'declare':

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

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