shell函数_shell函数传参 - CSDN
精华内容
参与话题
  • shell脚本之函数

    千次阅读 2019-02-12 14:56:54
    函数: 1.语法 方法1: 函数名() { 函数体 return n } 方法2:(更加规范) function 函数名() { 函数体 return n } [root@localhost mnt]# vim 01_function.sh ##################### #!...

    函数:

    通过使用函数,可以对程序进行更加好的组织。将一些相对独立的代码变成函数,
    可以提高程序的可读性和重用性。避免重复编写大量相同的代码。
    

    1.语法

    方法1:
    
    函数名() {
       函数体
       return n
    }
    
    方法2:(更加规范)
    
    function 函数名() {
         函数体
         return n    
    }
    
    [root@localhost mnt]# vim 01_function.sh 
    #####################
    #!/bin/bash
    
    function fun1(){
        echo "hello shell!"
    }
    
    fun1
    

    在这里插入图片描述

    [root@localhost mnt]# sh 01_function.sh 
    hello shell!
    

    在这里插入图片描述
    2.调用函数

    [root@localhost mnt]# vim 02_function.sh 
    #####################
    #!/bin/bash
    
    function fun1() {
        echo "I like you"
    }
    
    count=1
    while [ $count -le 5 ]
    do
        fun1
        ((count++))
    done
    
    echo "Eed of loop" 
    
    fun1
    
    echo "Eed of scritp" 
    

    在这里插入图片描述

    #  若是加-x表示调试
    [root@localhost mnt]# sh 02_function.sh 
    

    在这里插入图片描述
    3.引用函数

    每次引用函数时,bash会重新回到函数的定义
    
    函数不一定要要在最开始定义,但是如果函数在定义之前便使用会报错
    
    [root@localhost mnt]# vim 03_function.sh 
    #####################
    #!/bin/bash
    
    count=1
    echo "Before function definition"
    
    function fun1(){
        echo "hello fun1"
    }
    
    while [ $count -le 5 ]
    do
        fun1
        count=$[ $count + 1 ]
    done
    
    echo "End of loop"
    
    fun2
    
    function fun2() {
        echo "hello fun2"
    }
    

    在这里插入图片描述

    [root@localhost mnt]# sh 03_function.sh 
    

    在这里插入图片描述

    函数名必须是唯一的,如果重复定义了有相同名字的函数,则新定义的函数就会覆盖旧的函数
    
    [root@localhost mnt]# vim 04_function.sh 
    #####################
    #!/bin/bash
    
    function fun1(){
        echo "first fun1"
    }
    function fun1(){
        echo "second fun1"
    }
    function fun1(){
        echo "third fun1"
    }
    
    fun1
    

    在这里插入图片描述

    [root@localhost mnt]# sh 04_function.sh 
    third fun1
    

    在这里插入图片描述
    4.返回值

    (1)默认退出状态码

    默认退出状态码:默认情况下,函数退出状态码是函数中最后一条命令返回的退出状态码
    
    [root@localhost mnt]# ls -l westosfile
    ls: cannot access westosfile: No such file or directory
    [root@localhost mnt]# vim func_exit_01.sh 
    #####################
    #!/bin/bash
    
    function fun1(){
        echo "Trying to display a non-existent file"
        ls -l westosfile &> /dev/null
    }
    
    echo "test the function"
    fun1
    echo "The exit status is: $?"
    
    #  $? 在循环中表示获取循环体中最后一条语句执行状态的返回值
          0表示成功,非0表示失败
    

    在这里插入图片描述

    [root@localhost mnt]# sh func_exit_01.sh 
    

    在这里插入图片描述

    ##调换语句
    [root@localhost mnt]# vim func_exit_01.sh
    #####################
    #!/bin/bash
    
    function fun1(){
        ls -l westosfile &> /dev/null
        echo "Trying to display a non-existent file"  ##输出语句一定是正确的
    }
    
    echo "test the function"
    fun1
    echo "The exit status is: $?"
    

    在这里插入图片描述

    [root@localhost mnt]# sh func_exit_01.sh 
    

    在这里插入图片描述
    (2)return命令

    shell使用return命令来退出函数并返回特定的退出状态码
    自定义返回值范围:  0-255之间
    
    [root@localhost mnt]# vim func_exit_return_01.sh
    #####################
    #!/bin/bash
    
    function func(){
        read -p "Enter a value: " value
        echo "doubling the value..."
        return $[ $value * 2 ]      ##用return自定义返回值
    }
    
    func
    
    echo "The new value is $?"
    

    在这里插入图片描述

    [root@localhost mnt]# sh func_exit_return_01.sh 
    

    在这里插入图片描述
    (3)函数输出

    使用函数输出将函数的输出保存在shell变量中,可以获得任何类型的函数输出,并将其保存到变量中
    
    [root@localhost mnt]# vim function_variate.sh
    #####################
    #!/bin/bash
    
    function db1() {
        read -p "Enter a value:" value
        echo $[ $value * 2 ] 
    }
    
    result=`db1`
    
    echo "The new value is $result" 
    

    在这里插入图片描述

    [root@localhost mnt]# sh function_variate.sh 
    

    在这里插入图片描述
    (4)函数中的变量

    函数中的变量:可以向函数传递参数
    

    练习1:

    定义算法,当脚本后什么都不输入时,输出-1,当脚本后输入一个数字时,把这个数字扩大2倍,当输入两个数字时,把这两个数字相加
    
    [root@localhost mnt]# vim function_value_01.sh
    #####################
    #!/bin/bash
    
    a=$1     #接收脚本后的第一串字符
    b=$2     #接收脚本后的第二串字符
    c=$#     ##记录脚本后输入字符的个数
    
    function add() {
        if [ "$c" == 0 ];then
             echo "-1"        
         elif [ "$c" == 1 ];then
             echo  $[ a + a ]    
         elif [ "$c" == 2 ];then
             echo  $[ a + b ]   
         else
           echo "error" 
         fi
    }
    
    add
    

    在这里插入图片描述

    [root@localhost mnt]# sh function_value_01.sh 
    

    在这里插入图片描述
    练习2:

    定义算法,当用户的输入不符合输入要求时,告诉用户具体用法,当输入正确时,计算乘积
    
    [root@localhost mnt]# vim function_value_02.sh
    #####################
    #!/bin/bash
    
    function fun1() {
        echo $[ $1 * $2 ] 
    }
    if [ $# -eq 2 ];then
        value=`fun1 $1 $2`
        echo "The result is $value" 
    else
        echo "Usage:fun1 a b" 
    fi
    
    #   $# 表示脚本后输入字符的个数
    

    在这里插入图片描述

    [root@localhost mnt]# sh function_value_02.sh 
    

    在这里插入图片描述
    (5)函数不能从命令行获取脚本的参数值

    [root@localhost mnt]# vim function_value_03.sh
    #####################
    #!/bin/bash
    
    read -p "Enter a value:" value
    
    function fun1(){
         db1=$[ $value * 2 ]
     }
    
    fun1
    
    echo "The new value is:" $value
    

    5.变量的作用域

    (1)全局变量

    全局变量:定义在函数体之外,任何地方都生效的变量,默认情况下,脚本主体内定义全局变量,函数内可以用,函数外也可以
    
    [root@localhost mnt]# vim function_all_01.sh
    #####################
    #!/bin/bash
    
    function fun1(){
         temp=$[ $value + 5 ]
         result=$[ $temp *2 ]
     }
    
    # 定义全局变量
    temp=4
    value=6
    
    fun1
    
    echo "The result is $result" 
    if [ $temp -gt $value ];then
        echo "temp is lager" 
    else
        echo "temp is smaller" 
    fi
    

    在这里插入图片描述

    [root@localhost mnt]# sh function_all_01.sh 
    

    在这里插入图片描述
    (2)局部变量

    局部变量:定义在函数体内部,仅在函数内部可以使用
    
    [root@localhost mnt]# vim function_local_01.sh
    #####################
    #!/bin/bash
    
    function fun1(){
        local temp=$[ $value + 5 ]    # 声明temp为局部变量
        result=$[ $temp *2 ]
    }
    
    temp=4
    value=6
    
    fun1
    
    echo "The result is $result" 
    
    if [ $temp -gt $value ];then
        echo "temp is lager" 
    else
        echo "temp is smaller"      
    fi
    

    在这里插入图片描述

    [root@localhost mnt]# sh function_local_01.sh 
    

    在这里插入图片描述
    6.函数的递归

    计算阶乘:

    注意:  0!=1  1! =1
    
    [root@localhost mnt]# vim function_factorial.sh
    #####################
    #!/bin/bash
    
    function jc(){
        if [ $1 -eq 1 ];then
            echo 1 
        elif [ $1 -eq 0 ];then
            echo 1 
        else
            local temp=$[ $1 - 1 ]
            local result=`jc $temp`
            echo $[ result * $1 ] 
        fi
    }
    
    read -p "Enter a value: " value
    
    result=`jc $value`
    
    echo "The jc of $value is: $result"  
    

    在这里插入图片描述

    [root@localhost mnt]# sh function_factorial.sh
    

    在这里插入图片描述

    展开全文
  • linux shell 可以用户定义函数,然后在shell脚本中可以随便调用。Shell 函数定义的语法格式如下: [function] funname [()]{ 函数体 [return int;] } 格式1: 简化写法,不写 function 关键字: 函数名(){ ...

    分享知识 传递快乐

     

    1、函数定义

    linux shell 可以用户定义函数,然后在shell脚本中可以随便调用。Shell 函数定义的语法格式如下:

    [function] funname [()]{
        函数体
        [return int;]
    }

    格式1:

    简化写法,不写 function 关键字:

    函数名(){
        函数体
    }

    格式2:

    这是标准写法,也推荐大家使用的写法:

    function 函数名(){
    	命令序列
    }

    这样方便做到一看就懂。

    格式3:

    如果写了 function 关键字,也可以省略函数名后面的小括号:

    function 函数名{
    	命令序列
    }


    说明:

    • function 是 Shell 中的关键字,专门用来定义函数;可以带function funname () 定义,也可以直接funname () 定义,不带任何参数;
    • funname 是函数名;
    • 函数体 是函数要执行的代码,也就是一组语句;
    • return int 表示函数的返回值,其中 return 是 Shell 关键字,专门用在函数中返回一个值;这一部分可以写也可以不写,如果不加,将以最后一条命令运行结果,作为返回值。

     

    2、函数变量

    Shell 函数的变量不像其它语言中需要在变量前定义变量类型什么的,更没有结果符号等。语法:

    num=1

    变量作用域

    局部变量:作用域是函数的生命周期;在函数结束时被自动销毁。定义局部变量的方法:

    local VAR=VALUE

    本地变量:作用域是运行脚本的shell进程的生命周期;因此,其作用范围为当前shell

    示例一:

    #!/bin/bash
    
    #在函数外定义本地变量
    var="Hello,World"
    
    function show() {
        #在函数内改变变量内容
        var="Hi,var is changed"
    }
    echo "$var"
    show
    echo "$var"

    输出结果:

    [guest@localhost shell]$ ./tempsh.sh
    Hello,World
    Hi,var is changed

    结果显示在调用函数后,原有的本地变量var被替换了。还好这个变量并不是重要的部分,想想若是PATH被替换了,那么这个函数的罪过就大了。因此我们如何即调用函数中定义的变量同时又不对本地变量造成任何影响呢?局部变量的出现就是为了解决这个问题。

    下面看看在使用了局部变量后的效果。

    #!/bin/bash
    #在函数外定义本地变量
    var="Hello,World"
    
    function show() {
        #在函数内改变变量内容
        local var="Hi,var is changed"
        echo "$var"
    }
    echo "$var"
    show
    echo "$var"

    输出结果

    [guest@localhost shell]$ ./tempsh.sh
    Hello,World
    Hi,var is changed
    Hello,World

    该实验结果说明,使用局部变量后,函数体中出现的变量作用范围只存在于当前函数生命周期。

     

    3、函数调用

    定义函数的代码段不会自动执行,而是在调用时执行;在函数定义好后,用户可以在shell 中直接调用,调用时不用带上();调用 Shell 函数时可以给它传递参数,也可以不传递。如果不传递参数,直接给出函数名字即可。

    示例一:

    #!/bin/bash
    
    # 函数定义
    function show(){
        echo "Hello word"
    }
    
    # 函数调用
    show

    输出结果:

    Hello word

    函数调用成功。上边的例子是把函数把在脚本上边,那么如果放函数放在下边会怎样呢?

    无非就两种结果:1成功,2失败

    下面我们举例测试一下:

    示例二:

    #!/bin/bash
    
    # 函数调用
    show
    
    #函数定义
    function show(){
        echo "Hello word"
    }

    输出结果:

    ./tempsh.sh:行4: show: 未找到命令

    系统报错,为啥?为什么会报错呢?

    首先,脚本的执行顺序是从上到下顺序执行的,因此会先执行show,通过定义的环境变量$PATH定义的路径找不到show对应的命令因此报“show:未找到命令”。

    我们在终端命令行中输错命令报错也是这个原因。终端命令行默认会将最左面输入的内容当做命令,因此若是错误的命令,不是命令的命令等内容都会报错。

    通过上面的对比,我们至少知道函数的调用若是在同一个脚本中,调用操作需要在定义的函数后面。

     

    4、函数传参

    函数传参调用语法:

    函数名 参数1 参数2 ....

    如果传递参数,那么多个参数之间以空格分隔:

    funname param1 param2 param3

    不管是哪种形式,函数名字后面都不需要带括号。和其它编程语言不同的是,Shell 函数在定义时不能指明参数,但是在调用时却可以传递参数,并且给它传递什么参数它就接收什么参数。

    在Shell中,调用函数时可以向其传递参数。在函数体内部,函数中的变量均为全局变量,没有局部变量,若使用局部变量需要在变量前加上 local,通过 $n 的形式来获取参数的值,例如,$1表示第一个参数,$2表示第二个参数....

    示例:

    #!/bin/bash
    
    function show(){
        echo "第一个参数为 $1 !"
        echo "第二个参数为 $2 !"
        echo "第十个参数为 $10 !"
        echo "第十个参数为 ${10} !"
        echo "第十一个参数为 ${11} !"
        echo "参数总数有 $# 个!"
        echo "作为一个字符串输出所有参数 $* !"
    }
    
    show 0 1 2 3 4 5 6 7 8 9 10 11

    输出结果:

    第一个参数为 0 
    第二个参数为 1 
    第十个参数为 10 
    第十个参数为 9 
    第十一个参数为 10 
    参数总数有 12 个
    作为一个字符串输出所有参数 0 1 2 3 4 5 6 7 8 9 10 11 

    注意:$10 不能获取第十个参数,获取第十个参数需要${10}。当n>=10时,需要使用${n}来获取参数。

    另外,还有几个特殊字符用来处理参数:

    参数处理 说明
    $# 传递到脚本的参数个数
    $* 以一个单字符串显示所有向脚本传递的参数
    $$ 脚本运行的当前进程ID号
    $! 后台运行的最后一个进程的ID号
    $@ 与$*相同,但是使用时加引号,并在引号中返回每个参数。
    $- 显示Shell使用的当前选项,与set命令功能相同。
    $? 显示最后命令的退出状态。0表示没有错误,其他任何值表明有错误。

     

    5、函数返回值

    退出状态码

    在介绍函数返回值前先了解一下跟函数返回值有关的状态退出码。

    Shell 中运行的每个命令都使用退出状态码(exit status)来告诉shell它完成了处理。退出状态码是一个0-255之间的整数值,在命令结束运行时由命令传给shell。你可以捕获这个值并在脚本中使用。

    如何查看退出状态码呢?

    Linux提供了 $? 专属变量来保存上个执行的命令的退出状态码。你必须在你要查看的命令之后马上查看或使用 $? 变量。它的值会变成Shell中执行的最后一条命令的退出状态码。

    退出状态码大体分两种:

    • 一种是命令正确执行的状态码,该状态码为:0
    • 一种是命令错误执行的状态码,为1-255

     Linux退出状态码

    状态码 描述
    0 命令成功结束
    1 通用未知错误
    2 误用shell命令
    126 命令不可执行
    127 没找到命令
    128 无效退出参数
    128+x Linux信号x的严重错误
    130 命令通过Ctrl+C终止
    255 退出状态码越界

    在脚本中也可以指定退出状态码的值,通过命令exit实现。

    状态码取值范围为0-255,如果在指定的状态码大于255,那么shell会通过模(模就是256)运算得到相应的退出状态码。

    示例一:

    成功的

    #!/bin/bash
    
    # 函数定义
    function show(){
        echo $(date +%Y%m%d)
    }
    show
    echo $?

    输出结果:

    0

    示例二:

    失败的

    #!/bin/bash
    
    SYS_DATE=$(date +%Y%m%d)
    
    echo $SYS_DATE
    
    # 函数定义
    function show(){
        log=`lt`
    	echo log
    }
    show
    echo $?

    输出结果:

    [guest@localhost shell]$ ./tempsh.sh 
    20191123
    ./tempsh.sh:行10: lt: 未找到命令
    log
    0
    

    这次,由于函数最后一行命令正确执行,函数的退出状态码就是0,尽管函数中有一条命令没有成功运行。

    使用函数的默认退出状态码是很危险的,幸运的是return命令可以解决这个问题。

    示例:

    #!/bin/bash
    
    SYS_DATE=$(date +%Y%m%d)
    
    echo $SYS_DATE
    
    # 函数定义
    function show(){
        log=`lt`
    	echo log
    	return 2
    }
    show
    echo $?

    输出结果:

    [guest@localhost shell]$ ./tempsh.sh 
    20191123
    ./tempsh.sh:行10: lt: 未找到命令
    
    2
    

    还是使用相同的函数,在函数最后加上return指定的状态码2。

     

    函数返回值

    Shell函数返回值,常用的两种方式:return、echo。

     

    1)return 语句

    Shell函数的返回值,可以和其他语言的返回值一样,通过return语句返回,return只能用来返回整数值。

    示例一:

    #!/bin/bash
    
    function getResultFun(){
        echo "这是我的第一个 shell 函数!"
        return `expr 1 + 1`
    }
    
    getResultFun
    echo $?

    输出结果:

    这是我的第一个 shell 函数!
    2

    Shell 函数返回值只能是整形数值,一般是用来表示函数执行成功与否的,0表示成功,其他值表示失败。用函数返回值来返回函数执行结果是不合适的。如果return某个计算结果,比如一个字符串,往往会得到错误提示:“numeric argument required”。

    如果一定要让函数返回一个或多个值,可以定义全局变量,函数将计算结果赋给全局变量,然后脚本中其他地方通过访问全局变量,就可以获得那个函数“返回”的一个或多个执行结果了。

    示例:

    #!/bin/sh
    
    function getStr(){
    	return "string"
    }
    
    getStr
    echo $?

    输出如下:

    ./test.sh: line 5: return: string: numeric argument required
    255

    可以看到已经提示要求return 整数类型,真实返回值是255。当面对这种问题怎么解决呢?

    别急,断续看下去你就会找到你想要的答案了。

     

    2)echo 语句

    echo是通过输出到标准输出返回,可以返回任何类型的数据。

    示例:

    #!/bin/sh
    
    function test()  {
    	echo "arg1 = $1"
    	if [ $1 = "1" ] ;then
    		echo "1"
    	else
    		echo "0"
    	fi
    }
    
    echo
    echo "test 1"
    test 1
    
    echo
    echo "test 0"
    test 0
    
    echo
    echo "test 2"
    test 2

    输出结果:

    test 1
    arg1 = 1
    1
    
    test 0
    arg1 = 0
    0
    
    test 2
    arg1 = 2
    0

     

    3)函数返回值总结

    学习了上面的函数返回值的操作后我们下面做个知识总结,我们先看一用例:

    #!/bin/bash
    
    function getResultFun(){
        echo "这是我的第一个 shell 函数!"
        return `expr 1 + 1`
    }
    
    getResultFun
    echo $?
    
    function getResultFun2(){
     echo "这是我的第二个 shell 函数!"
     expr 1 + 1
    }
    
    getResultFun2
    echo $?
    
    getResultFun
    echo 在这里插入命令!
    echo $?

    输出结果:

    这是我的第一个 shell 函数!
    2
    这是我的第二个 shell 函数!
    2
    0
    这是我的第一个 shell 函数!
    在这里插入命令!
    0

    这是为什么?

    因为调用 getResultFun2 后,函数最后一条命令 expr 1 + 1 得到的返回值($?值)为 0,意思是这个命令没有出错。所有的命令的返回值仅表示其是否出错,而不会有其他有含义的结果。

    第二次调用 getResultFun 后,没有立即查看 $? 的值,而是先插入了一条别的 echo 命令,最后再查看 $? 的值得到的是 0,也就是上一条 echo 命令的结果,而 getResultFun 的返回值被覆盖了。下面这个测试,连续使用两次 echo $?,得到的结果不同,更为直观:

    #!/bin/bash
    
    function getResult(){
        echo "这是我的第一个 shell 函数!"
        return `expr 1 + 1`
    }
    
    getResult
    echo $?
    echo $?

    输出结果:

    这是我的第一个 shell 函数!
    2
    0

     

    6、获取函数返回值

    我们上面谈到了函数定义、传参、调用、返回结果,那我们如果得到返回结果呢?上面也谈到了一种获取返回结果的方法 $? ,难道只有这一种方式吗?答案肯定不止。

    示例一:

    用 $? 获取返回值,上面已有介绍,在这里就不做介绍了。

    示例二:

    #!/bin/sh
    
    function getStr(){
    	return "string"
    }
    
    #方法一
    echo `getStr` 
    
    #方法二
    echo $(getStr) 

    两种写法的原理一样的,将getStr当成命令执行,然后获取其标准输出。

    示例三:函数传参

    #!/bin/bash
    
    #创建目录
    function createDir(){
    	if [ ! -d $1 ]; then
    		mkdir -p $1
    	fi
    }
    
    DIR="temp/"
    # 两者二先一
    #$(createDir $DIR)
    $(createDir "temp/")

    函数返回值获取的方法总结:

    • 用变量接收函数返回值,函数用echo等标准输出将要返回的东西打印出来。
    • 用 $? 来接收函数的执行状态,但是 $? 要紧跟在函数调用处的后面。

     

     

     

     

     

     

     

     

     

     

    ———————————
    相互学习,共同进步
    如有不足请留言指正

    展开全文
  • 函数可以让我们将一个复杂功能划分成若干模块,让程序结构更加清晰,代码重复利用率更高。 Shell 函数必须先定义后使用。1、Shell 函数的定义格式function_name () { list of commands [ return value ] }如果你...

    函数可以让我们将一个复杂功能划分成若干模块,让程序结构更加清晰,代码重复利用率更高。
    Shell 函数必须先定义后使用。

    1、Shell 函数的定义格式

    function_name () {
        list of commands
        [ return value ]
    }
    
    如果你愿意,也可以在函数名前加上关键字 function
    function function_name () {
        list of commands
        [ return value ]
    }

    注意:

    1. 函数返回值,可以显式增加return语句;如果不加,会将最后一条命令运行结果作为返回值。
    2. Shell 函数返回值只能是整数,一般用来表示函数执行成功与否,0表示成功,其他值表示失败。
    3. 如果 return 其他数据,比如一个字符串,往往会得到错误提示:“numeric argument required”。

    2、函数返回字符串的技巧

    如果一定要让函数返回字符串,那么可以先定义一个变量,用来接收函数的计算结果,脚本在需要的时候访问这个变量来获得函数返回值。

    #!/bin/bash
    # Define your function here
    Hello () {
       echo "Url is http://see.xidian.edu.cn/cpp/shell/"
    }
    # Invoke your function
    Hello

    调用函数只需要给出函数名,不需要加括号。

    一个带有return语句的函数:

    #!/bin/bash
    funWithReturn(){
        echo "The function is to get the sum of two numbers..."
        echo -n "Input first number: "
        read aNum
        echo -n "Input another number: "
        read anotherNum
        echo "The two numbers are $aNum and $anotherNum !"
        return $(($aNum+$anotherNum))
    }
    funWithReturn
    # Capture value returnd by last command
    ret=$?
    echo "The sum of two numbers is $ret !"
    
    $? 可以获取上一个命令的退出状态,在这里也就是函数funWithReturn最后退出状态。

    3、函数嵌套

    #!/bin/bash
    # Calling one function from another
    number_one () {
       echo "Url_1 is http://see.xidian.edu.cn/cpp/shell/"
       number_two
    }
    number_two () {
       echo "Url_2 is http://see.xidian.edu.cn/cpp/u/xitong/"
    }
    number_one
    
    脚本直接调用number_one,在number_one中调用number_two
    
    运行结果:
    Url_1 is http://see.xidian.edu.cn/cpp/shell/
    Url_2 is http://see.xidian.edu.cn/cpp/u/xitong/

    4、删除函数

    像删除变量一样,删除函数也可以使用 unset 命令,不过要加上 .f 选项,如下所示:

    $unset .f function_name

    如果你希望直接从终端调用函数,可以将函数定义在主目录下的 .profile 文件,这样每次登录后,在命令提示符后面输入函数名字就可以立即调用。

    5、带参数函数

    在Shell中,调用函数时可以向其传递参数。
    在函数体内部,通过 n1表示第一个参数,$2表示第二个参数…

    带参数的函数示例:

    #!/bin/bash
    funWithParam(){
        echo "The value of the first parameter is $1 !"
        echo "The value of the second parameter is $2 !"
        echo "The value of the tenth parameter is $10 !"
        echo "The value of the tenth parameter is ${10} !"
        echo "The value of the eleventh parameter is ${11} !"
        echo "The amount of the parameters is $# !"  # 参数个数
        echo "The string of the parameters is $* !"  # 传递给函数的所有参数
    }
    funWithParam 1 2 3 4 5 6 7 8 9 34 73
    
    The value of the first parameter is 1 !
    The value of the second parameter is 2 !
    The value of the tenth parameter is 10 !
    The value of the tenth parameter is 34 !
    The value of the eleventh parameter is 73 !
    The amount of the parameters is 12 !
    The string of the parameters is 1 2 3 4 5 6 7 8 9 34 73 !"

    注意,10{10}。当n>=10时,需要使用${n}来获取参数。

    6、几个特殊变量用来处理参数

    特殊变量 说明

    1. $# 传递给函数的参数个数。
    2. $* 显示所有传递给函数的参数。
    3. $@ 与 (2)相同,但是略有区别,请查看Shell特殊变量。
    4. $? 函数的返回值。
    展开全文
  • Linux Shell函数返回值

    万次阅读 2012-09-11 11:25:40
    Shell函数返回值,一般有3种方式:return,argv,echo1) return 语句shell函数的返回值,可以和其他语言的返回值一样,通过return语句返回。示例:#!/bin/bash - function mytest() { echo "arg1 = $1" if [ $1 =...

    Shell函数返回值,一般有3种方式:returnargvecho


    1) return 语句
    shell函数的返回值,可以和其他语言的返回值一样,通过return语句返回。
    示例:

    #!/bin/bash -
    function mytest()
    {
        echo "arg1 = $1"
        if [ $1 = "1" ] ;then
            return 1
        else
            return 0
        fi
    }
    
    echo 
    echo "mytest 1"
    mytest 1
    echo $?         # print return result
    
    echo 
    echo "mytest 0"
    mytest 0
    echo $?         # print return result
    
    echo 
    echo "mytest 2"
    mytest 2
    echo $?         # print return result
    
    
    echo
    echo "mytest 1 = "`mytest 1`
    if  mytest 1 ; then
        echo "mytest 1"
    fi
    
    echo
    echo "mytest 0 = "`mytest 0`
    if  mytest 0 ; then
        echo "mytest 0"
    fi
    
    echo
    echo "if fasle" # if 0 is error
    if false; then
        echo "mytest 0"
    fi
    
    
    echo
    mytest 1
    res=`echo $?`   # get return result
    if [ $res = "1" ]; then
        echo "mytest 1"
    fi
    
    echo
    mytest 0
    res=`echo $?`   # get return result
    if [ $res = "0" ]; then
        echo "mytest 0"
    fi
    
    
    
    echo 
    echo "end"

    结果:

    mytest 1
    arg1 = 1
    1

    mytest 0
    arg1 = 0
    0

    mytest 2
    arg1 = 2
    0

    mytest 1 = arg1 = 1
    arg1 = 1

    mytest 0 = arg1 = 0
    arg1 = 0
    mytest 0

    if fasle

    arg1 = 1
    mytest 1

    arg1 = 0
    mytest 0

    end

    先定义了一个函数mytest,根据它输入的参数是否为1来return 1或者return 0.
    获取函数的返回值通过调用函数,或者最后执行的值获得。
    另外,可以直接用函数的返回值用作if的判断。
    注意:return只能用来返回整数值,且和c的区别是返回为正确,其他的值为错误。


    2) argv全局变量

    这种就类似于C语言中的全局变量(或环境变量)。

    示例:

    #!/bin/bash -
    
    g_var=
    function mytest2()
    {
        echo "mytest2"
        echo "args $1"
        g_var=$1
    
        return 0
    }
    
    mytest2 1
    echo "return $?"
    
    echo
    echo "g_var=$g_var"

    结果:

    mytest2
    args 1
    return 0

    g_var=1


    函数mytest2通过修改全局变量的值,来返回结果。


    注: 以上两个方法失效的时候

    以上介绍的这两种方法在一般情况下都是好使的,但也有例外。
    示例:
    #!/bin/bash -
    
    
    function mytest3()
    {
        grep "123" test.txt | awk -F: '{print $2}' | while read line ;do
            echo "$line"
            if [ $line = "yxb" ]; then
                return 0    # return to pipe only
            fi
        done
    
        echo "mytest3 here "
        return 1            # return to main process
    }
    
    g_var=
    function mytest4()
    {
        grep "123" test.txt | awk -F: '{print $2}' | while read line ;do
            echo "$line"
            if [ $line = "yxb" ]; then
                g_var=0
                echo "g_var=0"
                return 0    # return to pipe only
            fi
        done
    
        echo "mytest4 here "
        return 1
    }
    
    mytest3
    echo $?
    
    echo
    mytest4
    echo $?
    
    echo
    echo "g_var=$g_var"

    其中,test.txt 文件中的内容如下:

    456:kkk
    123:yxb
    123:test

    结果:

    yxb
    mytest3 here 
    1

    yxb
    g_var=0
    mytest4 here 
    1

    g_var=
    可以看到mytest3在return了以后其实没有直接返回,而是执行了循环体后的语句,同时看到mytest4中也是一样,同时,在mytest4中,对全局变量的修改也无济于事,全局变量的值根本就没有改变。这个是什么原因那?
    笔者认为,之所以return语句没有直接返回,是因为return语句是在管道中执行的,管道其实是另一个子进程,而return只是从子进程中返回而已,只是while语句结束了。而函数体之后的语句会继续执行。
    同理,全局变量在子进程中进行了修改,但是子进程的修改没有办法反应到父进程中,全局变量只是作为一个环境变量传入子进程,子进程修改自己的环境变量,不会影响到父进程。
    因此在写shell函数的时候,用到管道(cmd &后台进程也一样)的时候一定要清楚此刻是从什么地方返回。


    3) echo 返回值

    其实在shell中,函数的返回值有一个非常安全的返回方式,即通过输出到标准输出返回。因为子进程会继承父进程的标准输出,因此,子进程的输出也就直接反应到父进程。因此不存在上面提到的由于管道导致返回值失效的情况。
    在外边只需要获取函数的返回值即可。

    示例:

    #!/bin/bash 
    
    ##############################################
    # Author : IT-Homer
    # Date   : 2012-09-06 
    # Blog   : http://blog.csdn.net/sunboy_2050
    ##############################################
    
    function mytest5()
    {
        grep "123" test.txt | awk -F: '{print $2}' | while read line; do
            if [ $line = "yxb" ]; then
                echo "0"    # value returned first by this function
                return 0
            fi
        done
    
        return 1
    }
    
    echo '$? = '"$?"
    result=$(mytest5)
    
    echo "result = $result"
    
    echo
    if [ -z $result ]       # string is null
    then
        echo "no yxb. result is empyt"
    else
        echo "have yxb, result is $result"
    fi
    结果:
    $? = 0
    result = 0

    have yxb, result is 0

    这个方式虽然好使,但是有一点一定要注意,不能向标准输出一些不是结果的东西,比如调试信息,这些信息可以重定向到一个文件中解决,特别要注意的是,用到比如grep这样的命令的时候,一定要记得1>/dev/null 2>&1来避免这些命令的输出。



    参考推荐:

    Shell函数返回值

    Linux 之 shell 比较运算符(推荐)

    Linux Shell学习简单小结(推荐)

    SHELL学习笔记----IF条件判断,判断条件


    展开全文
  • Shell 函数

    千次阅读 2018-06-27 09:31:04
    系统函数basename 获取文件名,返回绝对路径最后/的部分basename [pathname] [suffix]basename [string] [suffix]basename /root/shell/myShell.sh myShell.sh basename /root/shell/myShell.sh .sh #去掉.sh后缀 ...
  • shell 函数

    千次阅读 2018-11-14 11:29:17
    function 函数名() { #<==推荐的书写函数的方法(带括号) 指令…… return n } #简化写法1: function 函数名{ #<==不推荐使用此方法(无括号) 指令…… return n } #...
  • shell函数的定义

    千次阅读 2018-03-26 17:35:59
    1.shell中定义函数的方式:示例1:funtion name {command1command2....}示例2:name () {command1command2...}取消函数:unset -f +函数名2.向函数中传递参数:示例:#!/bin/bashtest (){ a=$1 echo "test ()...
  • 函数可以确保命令循环执行,可以解决命令多重复的情况,函数用来简化脚本,使脚本可以循环执行 1.函数的语法 (1)方法1 函数名(){ 函数体 return n } (2)方法2(这样比较规范) function 函数名(){ ...
  • shell中的函数

    千次阅读 2020-02-12 19:45:44
    文章目录shell中的函数1.shell函数格式2.函数的调用3.函数的参数 1.shell函数格式 shell函数的本质是一段可以重复使用的脚本代码,这段代码被提前编写好,放在指定位置,使用时直接调用即可。 shell中的函数和C++、...
  • shell函数

    2020-07-27 08:39:00
    shell函数一、shell函数【1】shell函数的格式(1)定义一个函数(2)全局声明函数【2】递归函数(1)定义(2)特点(3)举例说明二、shell数组【1】数组的作用【2】定义数组(1)数值类数组的定义(2)字符串类型...
  • shell脚本函数及传参

    万次阅读 2018-09-17 19:29:39
    shell函数的定义 shell脚本的函数位置相对自由,既可以一个shell脚本单独成一个函数, 也可以在主代码中嵌入内置函数. 在Shell中可以通过下面的两种语法来定义函数,分别如下: function_name () { ...
  • shell函数返回值的接收

    万次阅读 2016-08-21 18:35:05
    shell函数返回值接收主要有两种方法。方法一: 函数子程序的标准输出赋值给主程序的变量。ret=`function_name arg1 arg2 ...`注意:不是引号。 例如:function test() { echo 23 }#调用test函数,并得到返回...
  • Shell函数的定义和使用

    万次阅读 2017-09-02 16:28:01
    和其他语言一样,在Shell语言中也有着函数。尽管在Shell函数并非是必须的编程元素,但是通过使用函数,可以对程序进行更加好的组织。将一些相对独立的代码变成函数,可以提高程序的可读性和重用性。避免重复编写...
  • shell 使用数组作为函数参数的方法

    万次阅读 2017-03-10 23:43:56
    因工作需要,需要使用shell开发一些小工具,当使用数组作为函数参数时,发现只能传递数组的第一个元素,数组后面的元素不能传递到函数内。本文将介绍在shell中使用数组作为函数参数的方法,并提供完整实例代码。
  • shell中局部变量及local命令

    万次阅读 2016-08-14 18:43:02
    (2)shell函数定义的变量默认是global的,其作用域从“函数被调用时执行变量定义的地方”开始,到shell结束或被显示删除处为止。函数定义的变量可以被显示定义成local的,其作用域局限于函数内。但请注意,函数的参
  • shell调用自定义函数及传参

    万次阅读 2019-12-05 09:27:15
    1 单个参数 #!/bin/bash function LoopPrint() { count=0; while [ $count -lt $1 ] ; do echo $count; let ++count; sleep 1; done return 0; } read...
  • shell脚本里实现带参数函数的方法

    万次阅读 2014-05-05 21:57:32
    $str="This is a test!" fun1(){ echo $str;  echo $1;  echo $2; } #调用fun1 fun1 "aa" "bb" fun1 "cc" "dd" 结果: This is a test! aa bb This a test!...$str="This is a t
  • shell脚本——如何获取函数的返回值

    万次阅读 多人点赞 2018-06-07 17:07:58
    shell脚本(以bash为例),既可以通过return关键字来返回函数的值,也可以通过echo关键字来返回函数的值。下面分开来讲一下如何捕获函数的返回值。 (1)函数中使用return返回函数值时,通过 echo $? 来捕获函数...
  • shell local命令

    万次阅读 2018-01-30 10:01:25
    作用:一般用于shell内局部变量的定义,多使用在函数内部 ... (2)shell函数定义的变量也是global的,其作用域从 函数被调用执行变量的地方 开始,到shell或结束或者显示删除为止。函数定义的变量可以是local的,其
  • shell 函数返回值接收问题

    万次阅读 2013-07-19 18:09:19
    check_user() { n=`cat /etc/passwd | cut -d ":" -f 1 | grep -n "^$1$"| cut -d ":" -f 1` if [ -z "$n" ] then return 0 else return 1 fi } ... userinfo=`head -$n /etc/passwd | tai
1 2 3 4 5 ... 20
收藏数 291,201
精华内容 116,480
关键字:

shell函数