24.1 复杂函数和函数复杂性

函数可以处理传递给它的参数，并且能返回它的退出状态码给脚本，以便后续处理。

function_name $arg1 $arg2

函数通过位置来引用传递过来的参数（就好像它们是位置参数），例如，$1, $2，等等。

例子 24-2. 带参数的函数

#!/bin/bash
# 函数和参数

DEFAULT=default                 # 默认参数值。D

func2 () {
    if [ -z "$1" ]              # 第一个参数长度是否为零？
    then
        echo "-Parameter #1 is zero length.-"  # 或者没有参数传递进来。
    else
        echo "-Parameter #1 is \"$1\".-"
    fi

    variable=${1-$DEFAULT}
    echo "variable = $variable"     #  这里的参数替换
                                    #+ 表示什么？
                                    #  ---------------------------
                                    #  为了区分没有参数的情况
                                    #+ 和只有一个null参数的情况。

    if [ "$2" ]
    then
        echo "-Parameter #2 is \"$2\".-"
    fi

    return 0
}

echo

echo "Nothing passed."
func2                          # 不带参数调用
echo


echo "Zero-length parameter passed."
func2 ""                        # 使用0长度的参数进行调用
echo

echo "Null parameter passed."
func2 "$uninitialized_param"    # 使用未初始化的参数进行调用
echo


echo "One parameter passed."
func2 first           # 带一个参数的调用
echo

echo "Two parameters passed."
func2 first second    # 带两个参数的调用
echo

echo "\"\" \"second\" passed."
func2 "" second       # 第一个调用参数为0长度参数，
echo                  # 第二个是ASCII码的字符串参数。

exit 0

也可以使用shift命令来处理传递给函数的参数（请参考例子 33-18. 但是，传递给脚本的命令行参数怎么办？在函数内部，可以看见这些命令行参数么？好，现在让我们弄清楚这个困惑。

例子 34-3. 函数以及传递给脚本的命令行参数。

#!/bin/bash
# func-cmdlinearg.sh
#  带一个命令行参数来执行这个脚本，
#+ 类似于 $0 arg1.


func ()
{
    echo "$1"   # 显示传递给这个函数的第一个参数。
}               # 命令行参数可以么？

echo "First call to function: no arg passed."
echo "See if command-line arg is seen."
func
# 不! 没有见到命令行参数.

echo "============================================================"
echo
echo "Second call to function: command-line arg passed explicitly."

func $1
# 现在，见到命令行参数了！

exit 0

和其它的编程语言相比，shell脚本一般只会传值给函数。如果把变量名（事实上就是指针）作为参数传递给函数的话，那将被解释为字面含义，也就是被看做字符串。 函数只会以字面含义来解释函数参数。

变量的间接引用（请参考例子 37-2）提供了一种笨拙的机制，来将变量指针传递给函数。

例子 24-4. 将一个间接引用传递给函数

#!/bin/bash
# ind-func.sh: 将一个间接引用传递给函数。

echo_var ()
{
    echo "$1"
}

message=Hello
Hello=Goodbye

echo_var "$message"         # Hello
# 现在，让我们传递一个间接引用给函数。
echo_var "${!message}"     # Goodbye
echo "-------------"

# 如果我们改变“hello”的值会发生什么？
Hello="Hello, again!"
echo_var "$message"        # Hello
echo_var "${!message}"     # Hello, again!

exit 0

接下来的一个逻辑问题就是，将参数传递给函数之后，参数能否被解除引用。

例子 24-5. 对一个传递给函数的参数进行解除引用的操作

#!/bin/bash
# dereference.sh
# 对一个传递给函数的参数进行解除引用的操作。
# 此脚本由Bruce W. Clare编写.

dereference ()
{
    y=\$"$1"   # 变量名（而不是值）.
    echo $y    # $Junk

    x=`eval "expr \"$y\" "`
    echo $1=$x
    eval "$1=\"Some Different Text \""  # 赋新值.
}

Junk="Some Text"
echo $Junk "before"         # Some Text before

dereference Junk
echo $Junk "after"          # Some Different Text after

exit 0

例子 24-6. 再来一次，对一个传递给函数的参数进行解除引用的操作

#!/bin/bash
# ref-params.sh: 解除传递给函数的参数引用。
#                (复杂的例子C)

ITERATIONS=3  # 取得输入的次数。
icount=1

my_read () {
    #  用my_read varname这种形式来调用,
    #+ 将之前用括号括起的值作为默认值输出,
    #+ 然后要求输入一个新值.

    local local_var

    echo -n "Enter a value "
    eval 'echo -n "[$'$1'] "'  #  之前的值.
# eval echo -n "[\$$1] "     #  更容易理解,
                             #+ 但会丢失用户在尾部输入的空格。
    read local_var
    [ -n "$local_var" ] && eval $1=\$local_var

    # "与列表": 如果 "local_var" 的测试结果为true，则把变量"$1"的值赋给它。
}

echo

while [ "$icount" -le "$ITERATIONS" ]
do
    my_read var
    echo "Entry #$icount = $var"
    let "icount += 1"
    echo
done

# 感谢Stephane Chazelas 提供这个例子。

exit 0

退出与返回码

退出状态码

函数返回一个值，被称为退出状态码。这和一条命令返回的退出状态码类似。退出状态码可以由return 命令明确指定，也可以由函数中最后一条命令的退出状态码来指定（如果成功，则返回0，否则返回非0值）。可以在脚本中使用$?来引用退出状态码。 因为有了这种机制，所以脚本函数也可以像C函数一样有“返回值”。

return

终止一个函数。一个return命令1 可选的允许带一个整形参数，这个整形参数将作为函数的“退出状态码”返回给调用这个函数的脚本，并且这个证书也被赋值给变量$?.

例子 24-7. 取两个数中的最大值

#!/bin/bash
# max.sh: 取两个Maximum of two integers.
E_PARAM_ERR=250    # 如果传给函数的参数少于两个时，就返回这个值。
EQUAL=251          # 如果两个参数相等时，就返回这个值。
#  任意超出范围的
#+ 参数值都可能传递到函数中。

max2 ()             # 返回两个数中的最大值。
{                   # 注意：参与比较的数必须小于250.
    if [ -z "$2" ]
    then
        return $E_PARAM_ERR
    fi

    if [ "$1" -eq "$2" ]
    then
        return $EQUAL
    else
        if [ "$1" -gt "$2" ]
        then
            return $1
        else
            return $2
        fi
    fi
}

max2 33 34
return_val=$?

if [ "$return_val" -eq $E_PARAM_ERR ]
then
    echo "Need to pass two parameters to the function."
elif [ "$return_val" -eq $EQUAL ]
then
    echo "The two numbers are equal."
else
    echo "The larger of the two numbers is $return_val."
fi

exit 0
#  练习 (easy):
#  ---------------
#  把这个脚本转化为交互脚本，
#+ 也就是，修改这个脚本，让其要求调用者输入2个数。

为了让函数可以返回字符串或者是数组，可以使用一个在函数外可见的专用全局变量。

count_lines_in_etc_passwd()
{
    [[ -r /etc/passwd ]] && REPLY=$(echo $(wc -l < /etc/passwd))
    #  如果 /etc/passwd 可读，让 REPLY 等于 文件的行数.
    #  这样就可以同时返回参数值与状态信息。
    #  'echo' 看上去没什么用，可是...
    #+ 它的作用是删除输出中的多余空白符。
}

if count_lines_in_etc_passwd
then
    echo "There are $REPLY lines in /etc/passwd."
else
    echo "Cannot count lines in /etc/passwd."
fi

# 感谢, S.C.

例子 24-8. 将阿拉伯数字转化为罗马数字

#!/bin/bash
# 将阿拉伯数字转化为罗马数字。
# 范围：0 - 200
# 比较粗糙，但可以正常工作。
# 扩展范围, 并且完善这个脚本, 作为练习.
# 用法: roman number-to-convert

LIMIT=200
E_ARG_ERR=65
E_OUT_OF_RANGE=66

if [ -z "$1" ]
then
    echo "Usage: `basename $0` number-to-convert"
exit $E_ARG_ERR
fi

num=$1
if [ "$num" -gt $LIMIT ]
then
    echo "Out of range!"
    exit $E_OUT_OF_RANGE
fi

to_roman ()             # 在第一次调用函数前必须先定义它。
{
    number=$1
    factor=$2
    rchar=$3
    let "remainder = number - factor"
    while [ "$remainder" -ge 0 ]
    do
        echo -n $rchar
        let "number -= factor"
        let "remainder = number - factor"
    done

    return $number
        # 练习:
        # ---------
        # 1) 解释这个函数如何工作
        #    提示: 依靠不断的除，来分割数字。
        # 2) 扩展函数的范围：
        #    提示: 使用echo和substitution命令.
}

to_roman $num 100 C
num=$?
to_roman $num 90 LXXXX
num=$?
to_roman $num 50 L
num=$?
to_roman $num 40 XL
num=$?
to_roman $num 10 X
num=$?
to_roman $num 9 IX
num=$?
to_roman $num 5 V
num=$?
to_roman $num 4 IV
num=$?
to_roman $num 1 I
# 成功调用了转换函数。
# 这真的是必须的么？ 这个可以简化么？

echo

exit

也可以参见例子 11-29

函数所能返回最大的正整数是255. return命令和退出状态码的概念紧密联系在一起，并且退出状态码的值受此限制。 幸运的是，如果想让函数返回大整数的话，有好多种不同的变通方法 能够应对这个情况。

例子24-9. 测试函数最大的返回值

#!/bin/bash
# return-test.sh
# 函数所能返回的最大正整数为255.

return_test ()         # 传给函数什么值，就返回什么值。
{
    return $1
}

return_test 27          # o.k.
echo $?                 # 返回27.

return_test 255         # Still o.k.
echo $?                 # 返回 255.

return_test 257         # 错误!
echo $?                 # 返回 1 (对应各种错误的返回码).

# =========================================================
return_test -151896    # 能返回一个大负数么?
echo $?                # 能否返回 -151896?
                        # 不行! 返回的是 168.

#  Bash 2.05b 之前的版本
#+ 允许返回大负数。
#  这可能是个有用的特性。
#  Bash之后的新版本修正了这个漏洞。
#  这可能会影响以前所编写的脚本。
#  一定要小心!
# =========================================================

exit 0

如果你想获得大整数“返回值”的话，简单的方法就是将“要返回的值”保存到一个全局变量中。

Return_Val=   # 用于保存函数特大返回值的全局变量。

alt_return_test ()
{
    fvar=$1
    Return_Val=$fvar
    return   # 返回 0 (成功).
}

alt_return_test 1
echo $?             #0
echo "return value = $Return_Val"            #1

alt_return_test 256
echo "return value = $Return_Val"           # 256

alt_return_test 257
echo "return value = $Return_Val"           # 257

alt_return_test 25701
echo "return value = $Return_Val"           #25701

一种更优雅的做法是在函数中使用echo命令将"返回值输出到stdout“，然后用命令替换来捕捉此值。请参考36.7小节 中关于这种用法的讨论。

例子 24-10. 比较两个大整数

#!/bin/bash
# max2.sh: 取两个大整数中的最大值。

#  这是前一个例子 "max.sh" 的修改版,
#+ 这个版本可以比较两个大整数。

EQUAL=0             # 如果两个值相等，那就返回这个值。
E_PARAM_ERR=-99999  # 没有足够多的参数，那就返回这个值。
#           ^^^^^^    任意超出范围的参数都可以传递进来。

max2 ()             # "返回" 两个整数中最大的那个。
{
    if [ -z "$2" ]
    then
        echo $E_PARAM_ERR
        return
    fi

    if [ "$1" -eq "$2" ]
    then
        echo $EQUAL
        return
    else
        if [ "$1" -gt "$2" ]
        then
            retval=$1
        else
            retval=$2
        fi
    fi

    echo $retval            # 输出 (到 stdout), 而没有用返回值。
                            # 为什么?
}


return_val=$(max2 33001 33997)
#            ^^^^             函数名
#                 ^^^^^ ^^^^^ 传递进来的参数
#  这其实是命令替换的一种形式：
#+ 可以把函数看作一个命令，
#+ 然后把函数的stdout赋值给变量“return_val".


# ========================= OUTPUT ========================
if [ "$return_val" -eq "$E_PARAM_ERR" ]
then
    echo "Error in parameters passed to comparison function!"
elif [ "$return_val" -eq "$EQUAL" ]
then
    echo "The two numbers are equal."
else
    echo "The larger of the two numbers is $return_val."
fi
# =========================================================

exit 0

#  练习:
#  ---------
#  1) 找到一种更优雅的方法，
#+    去测试传递给函数的参数。
#  2) 简化”输出“段的if/then结构。
#  3) 重写这个脚本，使其能够从命令行参数中获得输入。

这是另一个能够捕捉函数”返回值“的例子。要想搞明白这个例子，需要一些awk的知识。

month_length ()  # 把月份作为参数。
{                # 返回该月包含的天数。
    monthD="31 28 31 30 31 30 31 31 30 31 30 31"  # 作为局部变量声明？
    echo "$monthD" | awk '{ print $'"${1}"' }'    # 小技巧.
#                             ^^^^^^^^^
# 传递给函数的参数  ($1 -- 月份), 然后传给 awk.
# Awk 把参数解释为"print $1 . . . print $12" (这依赖于月份号)
# 这是一个模板，用于将参数传递给内嵌awk的脚本：
#                                 $'"${script_parameter}"'
#    这里是一个简单的awk结构：
#    echo $monthD | awk -v month=$1 '{print $(month)}'
#    使用awk的-v选项，可以把一个变量值赋给
#+   awk程序块的执行体。
#    感谢 Rich.
#  需要做一些错误检查，来保证月份好正确，在范围（1-12）之间， 
#+ 别忘了检查闰年的二月。
}
# ----------------------------------------------
# 用例：
month=4        # 以四月为例。
days_in=$(month_length $month)
echo $days_in  # 30
# ----------------------------------------------

也请参考例子 A-7 和例子A-37.

练习:使用目前我们已经学到的知识，来扩展之前的例子 将阿拉伯数字转化为罗马数字，让它能够接受任意大的输入。

重定向 重定向函数的stdin 函数本质上其实就是一个代码块,这就意味着它的stdin可以被重定向（比如例子3-1)。

例子 24-11. 从username中取得用户的真名

#!/bin/bash
# realname.sh
#
# 依靠username，从/etc/passwd 中获得“真名”.


ARGCOUNT=1       # 需要一个参数.
E_WRONGARGS=85

file=/etc/passwd
pattern=$1

if [ $# -ne "$ARGCOUNT" ]
then
    echo "Usage: `basename $0` USERNAME"
    exit $E_WRONGARGS
fi

file_excerpt ()    # 按照要求的模式来扫描文件,
{                  #+ 然后打印文件的相关部分。
    while read line  # "while" 并不一定非得有 [ 条件 ] 不可。
    do
        echo "$line" | grep $1 | awk -F":" '{ print $5 }'
        # awk用":" 作为界定符。
    done
    } <$file  # 重定向到函数的stdin。

file_excerpt $pattern
# 是的，整个脚本其实可以被缩减为
#       grep PATTERN /etc/passwd | awk -F":" '{ print $5 }'
# or
#       awk -F: '/PATTERN/ {print $5}'
# or
#       awk -F: '($1 == "username") { print $5 }' # 从username中获取真名
# 但是，这些起不到示例的作用。

exit 0

还有一个办法，或许能够更好的理解重定向函数的stdin。 它在函数内添加了一对大括号，并且将重定向stdin的行为放在这对添加的大括号上。

# 用下面的方法来代替它:
Function ()
{
    ...
} < file

# 试试这个:
Function ()
{
    { 
        ...
    } < file 
}

# 同样的,

Function ()  # 没问题.
{
    {
        echo $*
    } | tr a b 
}

Function ()  # 不行.
{
    echo $*
} | tr a b   # 这儿的内嵌代码块是被强制的。
# 感谢, S.C.

Emmanuel Rouat的 sample bash 文件包含了一些很有指导性意义的函数例子。

echo

shell中函数返回值，个人觉得可以用echo