関数がbashに存在するかどうかを判別する

現在、bashから実行される単体テストをいくつか行っています。ユニットテストは、bashスクリプトで初期化、実行、クリーンアップされます。このスクリプトには、通常、init（）、execute（）、およびcleanup（）関数が含まれています。ただし、必須ではありません。定義されているかどうかをテストしたいと思います。

私は以前ソースを手探りで落ち着かせることでこれを行いましたが、それは間違っているようでした。これを行うためのよりエレガントな方法はありますか？

編集：次のスニペットは魅力のように機能します：

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

「type」コマンドを探していると思います。それは、何かが関数、組み込み関数、外部コマンド、または単に定義されていないかどうかを教えてくれます。例：

$ 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

宣言がテストよりも10倍速い場合、これは明白な答えのように思われます。

編集：以下では、-fオプションはBASHでは不要です。自由に省略してください。個人的には、どちらのオプションがどちらを実行するのか思い出せないので、両方を使用しています。 -fは関数を示し、-Fは関数名を示します。

#!/bin/sh

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

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

宣言する "-F"オプションは、内容全体ではなく、見つかった関数の名前のみを返します。

/ dev / nullを使用することで測定可能なパフォーマンスのペナルティはないはずです。

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

または、あなた自身の無意味な楽しみのために、2つを組み合わせてください。どちらも機能します。

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

他の解決策とコメントを借りて、私はこれを思いつきました：

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

使用されます ...

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

指定された引数が関数かどうかをチェックし、リダイレクトやその他のgreppingを回避します。

古い投稿をしみ込ませて...しかし、私は最近これを使用し、で説明されている両方の代替案をテストしました：

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

これは生成されました：

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

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

declareはより速くhelluvalotです！

つまり、「declare」を使用して、出力または終了コードをチェックします。

出力スタイル：

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

使用法：

isFunction some_name && echo yes || echo no

ただし、メモリが機能する場合、nullへのリダイレクトは出力置換よりも高速です（いわば、恐ろしく時代遅れの `cmd`メソッドを削除して、代わりに$（cmd）を使用する必要があります）。見つからず、関数は関数の最後のコマンドの終了コードを返すため、通常、明示的な戻りは必要ありません。エラーコードをチェックする方が、文字列値（null文字列でも）をチェックするよりも速いためです。

終了ステータススタイル：

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

それはおそらくあなたが得ることができるのと同じくらい簡潔で良性です。

さまざまなソリューションのテスト：

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

出力例：

test_declare（fは関数）

実際0m0,055sユーザー0m0,041s sys 0m0,004s終了コード0

test_declare2（fは関数）

実際の0m0,042sユーザー0m0,022s sys 0m0,017s終了コード0

test_type（fは関数）

実際0m2,200sユーザー0m1,619s sys 0m1,008s終了コード0

test_type2（fは関数）

実数0m0,746sユーザー0m0,534s sys 0m0,237s終了コード0

test_declare（f unset）

実際0m0,040sユーザー0m0,029s sys 0m0,010s終了コード1

test_declare2（設定解除）

実際の0m0,038sユーザー0m0,038s sys 0m0,000s終了コード1

test_type（設定解除）

実際0m2,438sユーザー0m1,678s sys 0m1,045s終了コード1

test_type2（f unset）

実際の0m0,805sユーザー0m0,541s sys 0m0,274s終了コード1

test_declare（fは文字列）

実際の0m0,043sユーザー0m0,034s sys 0m0,007s終了コード1

test_declare2（fは文字列）

実際の0m0,039sユーザー0m0,035s sys 0m0,003s終了コード1

test_type（fは文字列）

実際の0m2,394sユーザー0m1,679s sys 0m1,035s終了コード1

test_type2（fは文字列）

実際の0m0,851sユーザー0m0,554s sys 0m0,294s終了コード1

だからdeclare -F f最良の解決策のようです。

別の回答についての私のコメントから（このページに戻ったとき、私は見逃してしまいます）

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

更新

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

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

私はそれを次のように改善します：

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

次のように使用します。

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

これは存在するかどうかを通知しますが、関数であることは通知しません

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

私は特にグレゴリー・ジョセフのソリューションが好きでした

しかし、「二重引用符の醜いトリック」を克服するために少し修正しました。

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

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

外部コマンドなしで「type」を使用することは可能ですが、2回呼び出す必要があるため、「declare」バージョンの約2倍遅くなります。

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

加えて、これはPOSIX shでは機能しないので、雑学を除いてまったく役に立ちません！