【美高梅手机版4858】语法之函数,Linux命令行与shell脚本编制程序大全

By admin in 美高梅手机版4858 on 2019年9月11日

《Linux命令行与shell脚本编制程序大全》创建函数
 

能够将shell脚本代码放进函数中封装起来,这样就可以在剧本中的任哪个地方方每每选用它了。

函数是被给予名称的台本代码块,能够在代码的妄动地点重用。每当供给在剧本中利用那样的代码块时,只需援引该代码块被予以的函数名称。

1. 在shell文件之中定义函数并引用:

主导的台本函数

17.1 基本的本子函数

函数:是叁个本子代码块,可感觉其命名并在代码中其他岗位重用。

 

复制代码 代码如下:

创办函数

17.1.1 成立函数

有二种格式:name 是函数名

1)

function name

{

         commands

}

2)这种就相比较左近c语言风格了

name()

{

         commands

}

 

创设函数

[~/shell/function]# cat factorial.sh
#!/bin/bash
function factorial
{
factorial=1
for (( i=1;i <= $1;i++ ))
        do
        factorial=$[ $factorial * $i ]
        done
echo $1的阶乘是:$factorial
}
echo ‘程序名’:$0,用于求阶乘
factorial $1
[~/shell/function]# ./factorial.sh 10

1.用function关键字,前边跟函数名

17.1.2 使用函数

跟别的shell命令同样,在行中指定函数名就好了。

在函数定义前应用函数,会抽出一条错误音信。

函数名是不二法门的,假设重定义了函数,新的会覆盖旧的,並且不会发出别的不当新闻。

例子:

*  1 #!/bin/bash*

*  2*

*  3 function fun*

*  4 {*

*  5         echo “hahahaha, i am a function”*

*  6 }*

*  7*

*  8 count=1*

*  9 while [ $count -lt 5 ]*

* 10 do*

* 11         fun*

* 12         count=$[ $count + 1 ]*

* 13 done*

* 14*

* 15 fun2  # Error fun2 not define*

* 16 fun2() # 声称函数的其余一种艺术*

* 17 {*

* 18         echo “I am Fun2, hahaha”*

* 19 }*

* 20 fun2*

 

格式

次第名:./factorial.sh,用于求阶乘
10的阶乘是:3628800

[plain] 

17.2 返回值

函数运营停止会回来叁个退出状态码,有3种艺术为函数生成退出状态码。

function name {

2.返回值

function name {  

17.2.1 默许退出状态码

在函数甘休时用 $? 来鲜明函数的退出状态码。

比如:

fun

echo “return code:$?”

 

一旦函数最终实践的讲话失利了,这里就能回到非0,最终成功了(不管前边有未有战败)再次回到都以0.

 

  commands

函数重回码是指函数最终一条命令的状态码,能够用来函数重返值
采纳return命令手动内定重返值:

    commands  

17.2.2 使用return命令

bashshell使用return命令来退出函数并回到特定的退出状态码。return允许钦赐四个整数值来定义函数的退出状态码。

注意:

函数一停止就要立即取重临值

退出状态码必需是0 – 255.(大于255会发生二个错误值)

 

}

复制代码 代码如下:

}  

17.2.3 使用函数输出

能够将函数输出(任何项目标函数输出)保存到shell变量中。

语法:result=$(fun) 
那些命令会将fun函数的输出赋给$result变量

例子:

*  1 #!/bin/bash*

*  2*

*  3 function fun*

*  4 {*

*  5         echo “hahahaha, i am a function”*

*  6         return 1*

*  7 }*

*  8*

*  9 fun*

* 10 echo “fun return $?”*

* 11*

 12 function fun2

 13 {

 14         echo “This is Function
fun2”

 15         read -p “Enter a value:”
num

 16         echo $[ $num \ 2
]*

 17 }

*【美高梅手机版4858】语法之函数,Linux命令行与shell脚本编制程序大全。 18*

* 19 #fun2 # 比方加上那句就能调一次了。*

* 20 result=$(fun2)*

* 21 echo “fun2
return:$result“*

 那样就足以回来浮点数和字符串了。

 

name 属性定义了该函数的独一名称。name 前边要有空格。

[~/shell/function]# cat return.sh
#!/bin/bash
function fun1 {
  read -p “enter a: ” a
  echo -n “print 2a: “
  return $[ $a * 2 ]
}
fun1
echo “return value $?”
[~/shell/function]# ./return.sh
enter a: 100
print 2a: return value 200

2.函数名背后跟空圆括号,标注正在定义一个函数

17.3 在函数中选取变量

介绍一些甩卖shell脚本函数内外变量的法子

 

commands 是结合函数的一条或多条 bash shell 命令。

是因为shell状态码最大是255,所以当重返值大于255时会出错。

[plain] 

17.3.1 向函数字传送递参数

就跟向脚本传递参数同样,能够用$# $0 $1 $2

只顾脚本中央的$1 $2 和传颂函数里面包车型客车并区别。

例子:

*  1 #!/bin/bash*

  2 function add

  3 {

  4         if [ $# -eq 0 ] || [ $#
-gt 2 ]

  5         then

  6                 echo -1

  7         elif [ $# -eq 1 ]

  8         then

  9                 echo $[ $1 + $1
]

 10         else

 11                 echo $[ $1 + $2
]

 12         fi

 13 }

* 14*

 15 #ret=$(add)

 16 #ret=$(add 34) #
那边表达的怎么传播参数

 17 ret=$(add 23 18)

* 18 if [ $ret -eq -1 ]*

* 19 then*

* 20         echo “Function add Error”*

* 21 else*

* 22         echo “The value = $ret”*

* 23 fi*

* 24*

* 25 if [ $# -eq 2 ] # 这一个的剧本主体接收的参数个数*

* 26 then*

* 27         echo “The value is $(add
$1 $2)” # ***
style=”color: #ff0000″>将脚本主体的参数字传送给里面包车型大巴函数**

* 28 else*

* 29         echo “Input Error”*

* 30 fi*

 

另一种格式 

复制代码 代码如下:

name() {  

17.3.2 在函数中拍卖变量

变量的作用域相比费心。成效域是变量可知的区域。

函数中定义的变量和常常变量的成效域区别,也正是说对台本的其余一些来讲它们是藏匿的

函数使用两连串型的变量:全局变量和部分变量

 

1.全局变量

是指在shell脚本中另各地方都有效的变量。

在本子主体部分概念了全局变量,那么在函数内足以读取它的值。

在函数钦命义了全局变量,在本子的着爱惜部分也能够读取它的值。

暗中同意情况下,在本子中定义的别样变量都以全局变量。函数外定义的变量可在函数内访问

这么要非常注意变量的运用。很轻易就改成了变量。

 

2.局部变量

可以在函数内部使用的其余变量都宣称成局地变量。

在变量证明前增进local关键字就好了

local temp

例子:

*  1 #!/bin/bash*

*  2 function fun*

*  3 {*

*  4         #temp=$[ $value + 5 ] #*
万一那些是全局变量上面包车型大巴结果就能分外

  5         local temp=$[ $value + 5 ]

*  6         ret=$[ $temp * 2 ]*

*  7 }*

*  8*

*  9 temp=4*

* 10 value=6*

* 11 fun*

* 12 echo “fun: ret = $ret”*

* 13 if [ $temp -gt $value ]*

* 14 then*

* 15         echo “temp is big”*

* 16 else*

* 17         echo “value is big”*

* 18 fi*

 

 

name() {

[~/shell/function]# ./return.sh
enter a: 200
print 2a: return value 144

   commands  

17.4 数组变量和函数

第6章研讨了数组来在单个变量中保存五个值的高等用法

 

  commands

3.函数出口

}  

17.4.1 向函数字传送数组参数

复习一下数组的用法:

定义方法1:初步化数组 array=(a b c)

定义方法2:新建数组并累加原色  array[数组]=元素

定义方法3:将下令输出作为数组成分 array=($(command))

数组操作:

1)获取具有因素:echo ${array[*]}

2)获取第n个元素: echo ${array[n]}    n为数组下标

3)添韩成分:array[3]=d

4)删除元素:unset array[n] n为数组下标

 

 

  1. 数组作为参数字传送递时不可能用 $arrayName。

应该那样: fun ${arrName[*]}

还能加多双引号。

 

例子:

*  1 #!/bin/bash*

*  2 function testit*

*  3 {*

*  4         echo “The param are:$@, Param count:$#”*

*  5         thisarray=$1*

*  6         echo “The received array is:${thisarray[*]}”*

*  7*

*  8         for param in “$@”*

*  9         do*

* 10                 echo “Param = $param”*

* 11         done*

* 12 }*

* 13*

* 14 myarray=(13 25 35 45 55 65)*

* 15 echo “The original array is: ${myarray[*]}”*

* 16 testit “${myarray[*]}”*

* 17 testit ${myarray[*]}*

 有双引号时,函数接受的参数个数为1.

 

}

为了重返大于255的数、浮点数和字符串值,最佳用函数输出到变量:

若是八个函数的名称一致,那么前边的将会覆盖前面包车型地铁,何况不会有提示。

17.4.2 从函数重回参数

函数用echo语句来按精确顺序输出单个数组值,然后脚本再将它们重新放进叁个新的数组变量中。

 

例子:

*  1 #!/bin/bash*

*  2 function fun*

*  3 {*

*  4         local origarray*

*  5         local newarray*

*  6         local count*

*  7         local i*

*  8         origarray=($(echo “$@”))*

*  9         newarray=($(echo “$@”))*

* 10         count=$[ $# – 1 ]*

* 11         for (( i = 0; i <= count; i++ ))*

* 12         {*

* 13                 newarray[$i]=$[ ${origarray[$i]} * 2 ]*

* 14         }*

* 15         echo ${newarray[*]}*

* 16 }*

* 17*

* 18 myarr=(1 2 3 4 5 6 7 8 9 10 11 12 13 14)*

* 19 echo “original arr is: ${myarr[*]}”*

* 20 arg1=$(echo ${myarr[*]}) # 这里的用命令输出定义数组*

* 21 ret=($(fun $arg1))*

* 22 echo “new arr is: ${ret[*]}”*

 

用arg1变量将数组值传给函数fun。函数将该数组重组到新的数组变量中。

剧本用fun函数的输出来重新生成二个新的数组变量

 

示例

复制代码 代码如下:

选择函数

17.5 函数递归

函数的重回值直接用echo传递了。

事例:求阶乘(注意书上的例证p369 中间部分的 result ** 写错了)

*  1 #!/bin/bash*

*  2 function fun1*

*  3 {*

*  4         if [ $1 -eq 1 ]*

*  5         then*

*  6                 echo 1*

*  7         else*

*  8                 local temp=$[ $1 – 1 ]*

*  9                 local ret=$( style=”color: #ff0000″>fun1 $temp)*

* 10                 echo $[ $ret * $1 ]*

* 11         fi*

* 12 }*

* 13*

* 14 read -p “Enter value:” value*

* 15 ret=$(fun1 $value)*

* 16 echo “ret = $ret”*

 

#!/bin/bash
# using a function in a script

[~/shell/function]# cat ./fun_out.sh
#!/bin/bash
function fun2 {
  read -p “enter a: ” a
  echo -n “print 2a: “
  echo $[ $a * 2 ]
}
result=`fun2`
echo “return value $result”
[~/shell/function]# ./fun_out.sh    
enter a: 400
return value print 2a: 800

使用函数名称就能够。必须先定义,再使用。

17.6 创建库

同意创造函数库文件,然后在三个脚本中引用该库文件。

一经有个本子,myfuncs。里面定义了一部分函数:

* 1 function addem*

*  2 {*

*  3         echo $[ $1 + $2 ]*

*  4 }*

*  5*

*  6 function multem*

*  7 {*

*  8         echo $[ $1 * $2 ]*

*  9 }*

* 10*

* 11*

* 12 function divem*

* 13 {*

* 14         if [ $2 -ne 0 ]*

* 15         then*

* 16                 echo $[ $1 / $2 ]*

* 17         else*

* 18                 echo -1*

* 19         fi*

* 20 }*

shell函数仅在概念它的shell会话中立竿见影。

设若您在shell命令行分界面包车型客车提示符下运营myfuncs
shell脚本,shell会创制贰个新的shell并在里面运转那个本子。

它会为那二个新的shell定义这里面包车型客车函数,但当你运营其余贰个要用到那个函数的台本时,它们是力所不及利用的。

怎么使用:使用函数库的关键在于source命令,source命令会在当前的shell上下文中实施命令。实际不是成立一个新的shell。

source命令有个高速的外号,称作点操作符。

怎么样行使: .
./myfuncs

这里假定在同样目录,假如不在,则供给钦定相应的路线名。

实例:

1 #!/bin/bash

*  2 . ./myfuncs*

*  3*

*  4 value1=10*

*  5 value2=5*

*  6 echo “Add Test ret = $(addem
$value1 $value2)”*

*  7 echo “Mult Test ret = $( style=”color: #ff0000″>multem $value1 $value2)”*

*  8 echo “Div Test ret = $(divem
$value1 $value2)”*

 

function func1 {
  echo “This is an example of a
function”
}

4.向函数字传送递参数(使用地方参数):

[plain] 

17.7 在命令行上运用函数

count=1
while [ $count -le 5 ]
do
func1
count=$[ $count + 1 ]
done

复制代码 代码如下:

#!/bin/bash  

17.7.1 在指令行上创造函数

能够在命令行分界面包车型客车晋升符下直接选取函数。

用起来就跟命令同样。并且假诺定义的函数,就足以在全部体系中央银行使它了,无需管PATH情形变量了。

例子:

 美高梅手机版4858 1

注意:

1)必得在每一个命令前面加上分号,那样技巧了解哪儿是命令的起止

2)无法创建跟内建命令或其余命令同样的函数,不然会覆盖原本的授命

 

echo “This is the end of the
loop”
func1
echo “Now this is the end of the
script”

[~/shell/function]# cat ./parameter.sh
#!/bin/bash
if [ $# -ne 3 ]
then
    echo “usage: $0 a b c”
    exit
美高梅手机版4858,fi
fun3() {
    echo $[ $1 * $2 * $3 ]
}
result=`fun3 $1 $2 $3`
echo the result is $result
[~/shell/function]# ./parameter.sh  1 2 3
the result is 6
[~/shell/function]# ./parameter.sh  1 2
usage: ./parameter.sh a b c

f1() {  

17.7.2 在.bashrc文件中定义函数

在命令行数定义shell函数鲜明的先天不足是退出shell时,函数就消失了。

焚林而猎办法:将函数定义在三个特定的岗位,那个任务在历次运行一个新的shell的时候都由shell重新载入。

至上地方正是.bashrc。bash
shell在每一趟运转时都会在主目录查找那一个文件

  1. 一向定义函数

直白在.bashrc前边加上

function addem

{

*         echo $[ $1 + $2 ]*

}

那般在系统上随机地点使用那个函数了。

2.读取函数文件

能够用source命令将库文件中的函数增加到.bashrc中

直接在.bashrc前边加上

.  /home/xcy/myfuncs

如此那般就足以用myfuncs里面包车型地铁函数了。

 

[root@tang sh14]# ./test1
This is an example of a function
This is an example of a function
This is an example of a function
This is an example of a function
This is an example of a function
This is the end of the loop
This is an example of a function
Now this is the end of the script

5.全局变量与一些变量

    echo “this is f1.”  

17.8 实例

本节介绍GNU shtool shell
脚本函数库。shtool库提供了一部分简易的shell脚本库。这里一时不写了。

 

暗许条件下,在函数和shell主体中国建工业总会公司立的变量都是全局变量,能够相互引用,当shell主体部分与函数部分持知名字同样的变量时,大概会相互影响,举个例子:

}  

在意:若是在函数定义在此之前运用函数,会博得错误音信。

复制代码 代码如下:

f1  

         假诺重复定义函数,那么新定义将顶替函数原先的概念。

[~/shell/function]# cat ./variable.sh   
#!/bin/bash
if [ $# -ne 3 ]
then
    echo “usage: $0 a b c”
    exit
fi
temp=5
value=6
echo temp is: $temp
echo value is: $value
fun3() {
    temp=`echo “scale=3;$1*$2*$3” | bc -ql`  
    result=$temp
}
fun3 $1 $2 $3
echo “the result is $result”
if [ `echo “$temp > $value” | bc -ql` -ne 0 ]
then
    echo “temp is larger”
else
    echo “temp is still smaller”
fi
[~/shell/function]# ./variable.sh  12 3 2
temp is: 5
value is: 6
the result is 72
temp is larger

  

 

在这种情景下,在函数内部最佳使用一些变量,化解影响。

function f1 {  

函数重返值

复制代码 代码如下:

    echo “this is f1111.”  

私下认可退出状态

[~/shell/function]# cat ./variable.sh
#!/bin/bash
if [ $# -ne 3 ]
then
    echo “usage: $0 a b c”
    exit
fi
temp=5
value=6
echo temp is: $temp
echo value is: $value
fun3() {
    local temp=`echo “scale=3;$1*$2*$3” | bc -ql`  
    result=$temp
}
fun3 $1 $2 $3
echo “the result is $result”
if [ `echo “$temp > $value” | bc -ql` -ne 0 ]
then
    echo “temp is larger”
else
    echo “temp is still smaller”
fi
[~/shell/function]# ./variable.sh  12 3 2
temp is: 5
value is: 6
the result is 72
temp is still smaller

}  

暗许处境下,函数的脱离状态是函数的最后一条命令归来的退出状态。

6.向函数字传送递数组变量:

f1  

示例

复制代码 代码如下:

  

#!/bin/bash
# testing the exit status of a
function

[~/shell/function]# cat array.sh
#!/bin/bash
a=(11 12 13 14 15)
echo ${a[*]}
function array(){
  echo parameters : “$@”
  local factorial=1
  for value in “$@”
  do
    factorial=$[ $factorial * $value ]
  done
  echo $factorial
}
array ${a[*]}
[~/shell/function]# ./array.sh
11 12 13 14 15
parameters : 11 12 13 14 15
360360

f2  

func1() {
  echo “trying to display a non-existent
file”
  ls -l badfile
}

7.函数重回数组变量

f2() {  

echo “testing the function:”
func1
echo “The exit status is: $?”

复制代码 代码如下:

    echo “this is f2.”  

[root@tang sh14]# ./test4
testing the function:
trying to display a non-existent file
ls: badfile: No such file or directory
The exit status is: 2

[~/shell/function]# cat array1.sh
#!/bin/bash
a=(11 12 13 14 15)
function array(){
  echo parameters : “$@”
  local newarray=(`echo “$@”`)
  local element=”$#”
  local i
  for (( i = 0; i < $element; i++ ))
  {
    newarray[$i]=$[ ${newarray[$i]} * 2 ]   
  }
  echo  new value:${newarray[*]}
}
result=`array ${a[*]}`
echo ${result[*]}
[~/shell/function]# ./array1.sh
parameters : 11 12 13 14 15 new value:22 24 26 28 30

}  

 

您或者感兴趣的稿子:

  • Shell脚本中让过程休眠的方法(sleep用法)
  • linux
    shell命令行选项与参数用法详解
  • Shell脚本数组用法小结
  • Shell中eval的用法示例
  • shell中case的用农学习笔记
  • Bash Shell中Shift用法分享
  • ShellExecute函数用法的实例代码
  • shell中冒号的标新立异用法分享
  • linux
    shell命令行参数用法详解
  • Shell常见用法小记

此间首先定义了f1,然后实行,然后又定义了三个f1,再施行。开掘第三次举办的是新的f1函数。

使用 return 命令

跟着调用f2,由于此时f2还尚无定义,所以会调用失利。

return
 命令能够利用单个整数值来定义函数退出状态,提供了一种通过编制程序设置函数退出状态的轻松方法。

[plain] 

示例

$ function_test   

#!/bin/bash
# using the return command in a
function

this is f1.  

function db1 {
  read -p “Enter a value: ”
value
  echo “doubling the value”
  return $[ $value * 2]
}

this is f1111.  

db1
echo “The new value is $?”

./function_test: line 12: f2: command not found  

[root@tang sh14]# ./test5
Enter a value: 10
doubling the value
The new value is 20

返回值

潜心:请牢记在函数完毕后不久提取重返值

bash shell会把函数当做Mini脚本,运行停止时会再次来到叁个退出状态码。

         请记住退出状态的取值范围是0~255

有三种办法生成函数退出状态码

 

暗中认可退出状态码

行使函数输出

暗中认可情形下,函数的退出状态码是函数中最终一条命令归来的退出状态码

正如命令输出能够捕获并贮存到 shell
变量中如出一辙,函数的出口也能够捕获并存放到 shell 变量中。

函数实践实现后,能够应用$?变量来调控函数的退出状态码

示例

[plain] 

#!/bin/bash
# using the echo to return a value

#!/bin/bash  

function db1 {
  read -p “Enter a value: ”
value
  echo $[ ($value) * 2 ]
}

fun(){  

result=`db1`
echo “The new value is $result”

    ls nothing  

[root@tang sh14]# ./test5b
Enter a value: 1
The new value is 2 

    echo $?  

 

    echo “done”  

向函数字传送递参数

}  

函数能够动用正规参数情形变量来表示命令行传递给函数的参数。

  

函数名在变量 $0 中定义, 函数命令行的任何参数使用变量
$1、$2…,专有变量$#能够用来规定传递给函数的参数数目。

fun  

示例

echo “fun:$?”  

#!/bin/bash
# passing parameters to a function

鉴于ls找不到nothing文件也许目录,所以回来的状态码=2

function addem {
  if [ $# -eq 0 ] || [ $# -gt 2
]
  then
    echo -1
  elif [ $# -eq 1 ]
  then
    echo $[ $1 + $1 ]
  else
    echo $[ $1 + $2 ]
  fi
}

只是fun函数最终的echo推行成功了,所以fun再次来到的场馆码=0

echo -n “Adding 10 and 15: “
value=`addem 10 15`
echo $value
echo -n “Let’s try adding just one number:

value=`addem 10`
echo $value
echo -n “Now trying adding no numbers:

value=`addem`
echo $value
echo -n “Finally, try adding three
numbers: “
value=`addem 10 15 20`
echo $value

[plain] 

[root@tang sh14]# ./test6
Adding 10 and 15: 25
Let’s try adding just one number: 20
Now trying adding no numbers: -1
Finally, try adding three numbers: -1 

$ function_test   

 

ls: cannot access nothing: No such file or directory  

鉴于函数为和睦的参数值使用专用的参数蒙受变量,所以函数不能够从脚本命令行直接采访脚本参数值。假设想在函数中采取那几个值,那么必需在调用该函数时手动传递这个数据。

2  

示例

done  

#!/bin/bash
# trying to access script parameters
inside a function

fun:0  

function func7 {
  echo $[ $1 * $2 ]
}

选取函数默许退出状态码是很危险的……

if [ $# -eq 2 ]
then
  value=`func7 $1 $2`
  echo “The result is $value”
else
  echo “Usage: badtest1 a b”
fi

 

[root@tang sh14]# ./test7
Usage: badtest1 a b

使用return命令

[root@tang sh14]# ./test7 2 6
The result is 12

bash shell使用return命令退出函数并回到特定的退出状态码。

 

return命令允许钦赐四个整数值来定义函数的退出状态码

在函数中使用变量

在意:函数一甘休就取重回值,退出状态码必须在0-255里边。

全局变量是在 shell 脚本内部处理处有效的变量。

使用函数输出

示例

可以将函数的输出保存到变量中,比方:

#!/bin/bash
# using a global variable to pass a
value

result=`f1`

function db1 {
  value=$[ $value * 2 ]
}

bash shell不会将read读取输入的一对作为 STDOUT

read -p “Enter a value: ” value
db1
echo “The new value is: $value”

 

[root@tang sh14]# ./test8
Enter a value: 10
The new value is: 20

在函数中使用变量

 

向函数字传送递参数

一些变量是在函数内部选拔的变量,在变量申明前面冠以 local 关键字。

在剧本中钦命函数时,必得将参数和函数放在同一行

举例脚本在函数外界有同名变量,那么 shell 将能分别开那三个变量。

下一场函数能够用参数情形变量来博取参数值

示例

在函数中管理变量

#!/bin/bash
# demonstrating the local keyword

函数会用到全局变量和部分变量。

function func1 {
  local temp=$[ $value + 5 ]
  result=$[ $temp * 2 ]
}

全局变量

temp=4
value=6

在剧本中定义的有着变量均为全局变量。

func1
echo “The result is $result”

[plain] 

if [ $temp -gt $value ]
then
  echo “temp is larger”
else
  echo “temp is smaller”
fi

#!/bin/bash  

[root@tang sh14]# ./test9
The result is 22
temp is smaller

var=1  

 

fun(){  

向函数字传送递数组

    echo “var:”$var  

比如准备将数组变量作为函数参数使用,那么函数只领到数组变量的首先个取值。

    var2=2  

示例

}  

#!/bin/sh
# array variable to function test

  

function testit {
  local newarray
  newarray=(“$@”)
  echo “The new array value is:
${newarray[*]}”
}

fun  

myarray=(1 2 3 4 5)
echo “The original array is
${myarray[*]}”
testit ${myarray[*]}

echo “var2:”$var2  

[root@tang sh14]# ./test10
The original array is 1 2 3 4 5
The new array value is: 1 2 3 4 5

输出:

非得将数组变量拆分为单个成分,然后使用那几个因素的值作为函数参数。

[plain] 

 

$ function_test   

函数内部选取数组

var:1  

示例

var2:2  

#!/bin/bash
# adding values in an array

一对变量

function addarray {
  local sum=0
  local newarray
  newarray=(`echo “$@”`)
  for value in
${newarray[*]}
  do
    sum=$[ $sum + $value ]
  done
  echo $sum
}

函数内部任何变量都得以注脚为一些变量,只需在变量前加local关键字就能够。

myarray=(1 2 3 4 5)
echo “The original array is:
${myarray[*]}”
arg1=`echo ${myarray[*]}`
result=`addarray $arg1`
echo “The result is $result”

在本子中定义的一部分变量,函数中是不可能访问的。

[root@tang sh14]# ./test11
The original array is: 1 2 3 4 5
The result is 15

 

 

数组变量和函数

从函数再次回到数组

向函数字传送递数组参数

示例

亟待将数组变量的值分解成单个值,然后作为函数参数使用。

#!/bin/sh
# returning an array value

在函数内部,能够将她们再结合多个数组。

function arraydblr {
  local origarray
  local newarray
  local elements
  local i
  origarray=(`echo “$@”`)
  newarray=(`echo “$@”`)
  elements=$[ $# – 1 ]
  for(( i=0; i<=elements; i++
))
  {
    newarray[$i]=$[
${origarray[$i]} * 2 ]
  }
  echo ${newarray[*]}
}

[plain] 

myarray=(1 2 3 4 5)
echo “The original array is:
${myarray[*]}”
arg1=`echo ${myarray[*]}`
result=(`arraydblr $arg1`)
echo “The new array is:
${result[*]}”

#!/bin/bash  

[root@tang sh14]# ./test12
The original array is: 1 2 3 4 5
The new array is: 2 4 6 8 10

array=(a b c d)  

 

  

函数递归

fun(){  

示例

   
newarray=([email protected])
#重新组合为数组  

#!/bin/sh
# using recursion

    echo “newarray is:”${newarray[*]} #打字与印刷数组  

function factorial {
  if [ $1 -eq 1 ]
  then
    echo 1
  else
    local temp=$[ $1 – 1 ]
    local result=`factorial
$temp`
    echo $[ $1 * $result
]  
  fi
}

    echo “The 3rd element is:”${newarray[3]}  

read -p “Enter value: ” value
result=`factorial $value`
echo “The factorial of $value is:
$result”

}  

[root@tang sh14]# ./test13
Enter value: 5
The factorial of 5 is: 120

  

 

fun ${array[*]} #拆分成多个值传入  

创建库

输出:

始建函数的库文件,能够在不相同脚本中援用该库文件。

[plain] 

其难点在于 shell 函数的成效域。与意况变量同样,shell
函数仅在其定义所处的 shell 会话中立竿见影。假如从 shell
命令行分界面运维库文件,那么 shell 将开拓贰个新的 shell ,并在新 shell
中运作此脚本,但是当试图运营调用那些库函数的另一个剧本时,库函数并不能够采纳。

$ function_test   

采取函数库的严重性是 source 命令。source 命令在脚下 shell
景况中实行命令,而非制造新 shell 来实施命令。使用 source 命令在 shell
脚本内部运营库文件脚本。

newarray is:a b c d  

source 有三个短小的外号,称为点操作符(.)

The 3rd element is:d  

示例

如若准备将数组当做一个参数字传送递给函数,那么函数只会读取数组变量的第一个值。

#!/bin/bash
# using functions defiend in a library
file

[plain] 

. ./myfuncs

#!/bin/bash  

value1=10
value2=5
result1=`addem $value1 $value2`
result2=`multem $value1
$value2`
result3=`divem $value1 $value2`

array=(a b c d)  

echo “The result of adding them is:
$result1”
echo “The result of multiplying them is:
$result2”
echo “The result of dividing them is:
$result3”

  

[root@tang sh14]# ./test14
The result of adding them is: 15
The result of multiplying them is: 50
The result of dividing them is: 2

fun(){  

 

    echo “We have “$#” parameter(s).”  

在指令行中使用参数

    echo “They are:
“[email protected]
 

$ function divem { echo $[ $1 + $2 ]; }

    echo “They are: “$*  

$ divem 100 5

}  

 

  

在.bashrc 文件中定义函数

fun $array  

将函数定义放在 shell 每回运行都能重新载入的地点,.bashrc。

fun函数只认得数组中的第一个要素

可以直接定义函数,恐怕提供函数文件。

[plain] 

$ function_test   

We have 1 parameter(s).  

They are: a  

They are: a  

从函数重返数组

[plain] 

#!/bin/bash  

fun(){  

    local array=(a b c d)  

    echo ${array[*]}  

}  

  

array=(`fun`)  

echo ${array[2]}  

同再次来到普通字符串类似,按顺序echo输出,然后放在圆括号内部就能够。

 

函数递归

要么以最简易的求N的阶乘为例:

[plain] 

#!/bin/bash  

fun(){  

    local result=1;  

    if [ $1 -eq 1 ]  

    then  

        echo 1  

    else  

        result=$[$1 * `fun $[$1 – 1]`]  

        echo $result  

    fi  

}  

  

fun $1  

从未有过新的知识点,只是不太熟习罢了

纵然利用了“,那么函数内的echo就不会输出到STDOUT了,和方面其余的事例同样。

 

创建库

source命令能够在方今的shell上下文中实行命令,并不是创办贰个新的shell来奉行命令。可以用source命令来在shell脚本中运行库文件脚本。

source命令等同于点操作符(dot operator)

在三个名称叫lib_test的文件中定义三个plus函数

[plain] 

#!/bin/bash  

plus(){  

    if [ $# -ne 2 ]  

    then  

        echo “I need 2 numbers!”  

        return  

    fi  

    echo $[$1 + $2]  

}  

下一场大家在另贰个本子中运用它

[plain] 

#!/bin/bash  

. lib_test #本子路径  

plus $1 $2  

采纳办法异常的粗略,那样就相当于把lib_test导入到当前文件中了

[plain] 

$ function_test 4 5  

9  

在命令行上采用函数

在命令行上创立函数

鉴于在键入命令时shell就能分解命令,所以能够在命令上直接定义函数。

[plain] 

$ plus(){ echo $[$1 + $2]; }  

$ plus 3 1  

4  

瞩目:要在花括号两侧加空格,每条命令用分号隔断。

上面包车型大巴主意看起来更实用一些,效果也更加好

[plain] 

$ plus(){  

> echo $[$1 + $2]  

> }  

$ plus 4234 23  

4257  

无须分号和空格。

在.bashrc文件中定义函数

能够直接在此地定义函数,也能够应用source命令,导入库

小心,修改了.bashrc之后要重启才具见效

倘诺不是每一次开机都要施行,那大家还足以在shell中一贯动用source,非常多时候,这种措施大概越来越好有的。

 

基本的脚本函数 创立函数 1.用function关键字,前面跟函数名 [plain]
function name { commands } 2.函数名…

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有