Bash'da bir işlevin var olup olmadığını belirleme

Şu anda bash yürütülen bazı birim testleri yapıyorum. Birim testleri bir bash betiğinde başlatılır, yürütülür ve temizlenir. Bu komut dosyası genellikle bir init (), execute () ve cleanup () işlevleri içerir. Ancak zorunlu değildir. Tanımlanmış olup olmadıklarını test etmek istiyorum.

Bunu daha önce kaynağı açıp kapatarak yaptım, ama yanlış görünüyordu. Bunu yapmanın daha zarif bir yolu var mı?

Düzenleme: Aşağıdaki sniplet bir cazibe gibi çalışır:

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

Bence 'tip' komutunu arıyorsunuz. Bir şeyin bir işlev, yerleşik işlev, harici komut olup olmadığını veya tanımlanmadığını size söyleyecektir. Misal:

$ 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

Beyan, testten 10 kat daha hızlıysa, bu açık bir cevap gibi görünecektir.

Düzenleme: Aşağıda, -fseçenek BASH ile gereksizdir, dışarıda bırakmaktan çekinmeyin. Şahsen, hangi seçeneğin hangisini yaptığını hatırlamakta zorlanıyorum, bu yüzden her ikisini de kullanıyorum. -f işlevleri ve -F işlev adlarını gösterir.

#!/bin/sh

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

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

Bildirmek için "-F" seçeneği, tüm içerik yerine yalnızca bulunan işlevin adını döndürmesine neden olur.

/ Dev / null kullanımı için ölçülebilir bir performans cezası olmamalı ve sizi bu kadar endişelendiriyorsa:

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

Ya da kendi anlamsız zevkiniz için ikisini birleştirin. İkisi de çalışıyor.

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

Diğer çözümlerden ve yorumlardan ödünç alarak, bunu buldum:

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

Olarak kullanılır ...

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

Verilen argümanın bir işlev olup olmadığını kontrol eder ve yeniden yönlendirmelerden ve diğer açılmadan kaçınır.

Eski bir gönderiyi taramak ... ama son zamanlarda bunu kullandım ve her iki alternatifi de test ettik:

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

bu oluşturulan:

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

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

beyan daha hızlı bir helluvalot olduğunu!

Çıktıyı kontrol etmek veya çıkış kodunu kontrol etmek için 'declare' kullanmak üzere kaynar.

Çıktı tarzı:

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

Kullanımı:

isFunction some_name && echo yes || echo no

Bununla birlikte, bellek hizmet veriyorsa, null değerine yönlendirme çıktı ikamesinden daha hızlıdır (bahsetmek gerekirse, korkunç ve eski tarihli cmd` yöntemi kaldırılmalı ve bunun yerine $ (cmd) kullanılmalıdır). bulunamadı ve işlevler, işlevdeki son komutun çıkış kodunu döndürür, böylece açık bir dönüş genellikle gerekli değildir ve hata kodunu kontrol etmek bir dize değerini (null dize bile) kontrol etmekten daha hızlı olduğundan:

Durum stilinden çık:

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

Bu muhtemelen elde edebileceğiniz kadar özlü ve iyi huyludur.

Farklı çözümleri test etme:

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

çıktılar örn:

test_declare (f işlevdir)

gerçek 0m0.055s kullanıcı 0m0.041s sys 0m0,004s çıkış kodu 0

test_declare2 (f işlevdir)

gerçek 0m0.042s kullanıcı 0m0.022s sys 0m0.017s çıkış kodu 0

test_type (f işlevdir)

gerçek 0m2.200s kullanıcı 0m1.619s sys 0m1.008s çıkış kodu 0

test_type2 (f işlevdir)

gerçek 0m0.746s kullanıcı 0m0.534s sys 0m0.237s çıkış kodu 0

test_declare (ayarlanmamış)

gerçek 0m0.040s kullanıcı 0m0.029s sys 0m0.010s çıkış kodu 1

test_declare2 (f unset)

gerçek 0m0.038s kullanıcı 0m0.038s sys 0m0.000s çıkış kodu 1

test_type (ayarlanmamış)

gerçek 0m2.438s kullanıcı 0m1.678s sys 0m1.045s çıkış kodu 1

test_türü2 (ayarlanmamış)

gerçek 0m0.805s kullanıcı 0m0.541s sys 0m0.274s çıkış kodu 1

test_declare (f dizedir)

gerçek 0m0.043s kullanıcı 0m0.034s sys 0m0,007s çıkış kodu 1

test_declare2 (f dizedir)

gerçek 0m0.039s kullanıcı 0m0.035s sys 0m0,003s çıkış kodu 1

test_type (f dizedir)

gerçek 0m2.394s kullanıcı 0m1.679s sys 0m1.035s çıkış kodu 1

test_type2 (f dizedir)

gerçek 0m0.851s kullanıcı 0m0.554s sys 0m0.294s çıkış kodu 1

Bu yüzden declare -F fen iyi çözüm gibi görünüyor.

Başka bir yanıt hakkındaki yorumumdan (bu sayfaya geri döndüğümde kaybolmaya devam ediyorum)

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

Güncelleme

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

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

Bunu geliştirmek için:

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

Ve şu şekilde kullanın:

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

Bu, var olup olmadığını söyler, ancak bunun bir işlev olmadığını

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

Özellikle Grégory Joseph'in çözümünü beğendim

Ama ben "çift teklif çirkin hile" üstesinden biraz değiştirdim:

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

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

Herhangi bir harici komut olmadan 'type' kullanmak mümkündür, ancak bunu iki kez çağırmanız gerekir, bu yüzden hala 'declare' versiyonunun yaklaşık iki katı kadar yavaş sonuç verir:

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

Ayrıca bu POSIX sh'de çalışmaz, bu yüzden trivia dışında tamamen değersizdir!