ตรวจสอบว่าฟังก์ชั่นที่มีอยู่ในทุบตี

ขณะนี้ฉันกำลังทำการทดสอบหน่วยที่ดำเนินการจากการทุบตี การทดสอบหน่วยจะเริ่มต้นใช้งานและทำความสะอาดในสคริปต์ทุบตี สคริปต์นี้เป็นปกติมีฟังก์ชัน init (), execute () และ cleanup () แต่พวกเขาไม่ได้บังคับ ฉันต้องการทดสอบว่าพวกเขาเป็นหรือไม่ได้กำหนดไว้

ก่อนหน้านี้ฉันทำแบบนี้โดยการ greping และ seding แหล่งที่มา แต่ดูเหมือนว่าผิด มีวิธีที่สง่างามกว่านี้หรือไม่?

แก้ไข: sniplet ต่อไปนี้ทำงานเหมือนเครื่องราง:

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

หรือรวมทั้งสองอย่างเข้าด้วยกันเพื่อความบันเทิงที่ไม่มีจุดหมายของคุณเอง พวกเขาทั้งสองทำงาน

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

ประกาศเป็น helluvalot เร็วขึ้น!

มันลดลงโดยใช้ 'ประกาศ' เพื่อตรวจสอบผลลัพธ์หรือรหัสทางออก

สไตล์เอาท์พุท:

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

การใช้งาน:

isFunction some_name && echo yes || echo no

อย่างไรก็ตามหากหน่วยความจำทำหน้าที่การเปลี่ยนเส้นทางไปเป็นโมฆะเร็วกว่าการทดแทนเอาต์พุต (พูดถึงวิธีการ '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 (ไม่มีการตั้งค่า f)

ผู้ใช้จริง 0m0,038s 0m0,038s sys 0m0,000s รหัสทางออก 1

test_type (ยกเลิกการตั้งค่า f)

ผู้ใช้ 0m2,438s จริง 0m1,678s sys รหัสทางออก 0m1,045s 0

test_type2 (ไม่มีการตั้งค่า f)

จริง 0m0,805 ผู้ใช้ 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 0

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

ฉันชอบวิธีแก้ปัญหาจากGrégory Joseph

แต่ฉันได้ปรับเปลี่ยนนิดหน่อยเพื่อเอาชนะ

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

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

เป็นไปได้ที่จะใช้ 'type' โดยไม่มีคำสั่งภายนอก แต่คุณต้องเรียกมันสองครั้งดังนั้นมันจึงยังคงช้าลงประมาณสองเท่าของรุ่น 'ประกาศ':

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

นอกจากนี้ยังใช้ไม่ได้กับ POSIX sh ดังนั้นจึงไม่มีค่าทั้งหมดยกเว้นเรื่องเล็กน้อย!