Linux Shell 编程中的函数

• 在数学中，函数是由特定公式组成的数学表达式
• 在程序中，函数是对程序逻辑的封装
• 在程序中使用函数，可以实现代码的复用、一个位置修改，多个位置使用
• 脚本编程的 Shell 编程是一个完全面向过程的编程。它没有像 C++ 等面向对象语言中的对象的概念，也没有类。能进行代码封装的手段就非常的少。
• Shell 代码封装的重要概念就是函数、以及函数的更上一层概念：库

1. 基本的脚本函数；

• Shell 脚本函数（function）：函数是可以命名的，并在代码中任何位置重用的代码块
• 函数定义的语法

# 语法 1 （和 C 语言中的语法相似）：
function name {
	commands
}

# 语法 2：
name () {
	commands
}

# 使用演示：
cd /data/shellscript	# 演示文件所在文件夹
mkdir functest
cd functest

# 举例 1：
touch test1
chmod +x test1	# 赋予执行权限
vim test1
# 写入以下内容
#! /bin/bash

function func1 {
	echo 'This is the function'
}

func2(){
 	echo 'this is the other function'
}
# 调用函数
# 如果在函数定义前就调用函数，系统会抛出错误
func1
func2
# 保存退出并调用脚本
./test1		
# 输出
This is the function
This is the other function

• 函数的返回值：退出码、return 命令、函数输出

# 函数执行后会有一个默认的**退出状态码**
# 使用如下格式对状态码进行访问： 
echo "$?"
# 默认退出状态码是 0 ，脚本出错了，退出状态码就是 127
# 和之前提到的 Shell 的退出状态码是一致的
# 举例 1：
vim test1
# 写入以下内容
#! /bin/bash

func2(){
 	echo 'this is the other function'
}

func2
echo "$?"
# 保存退出并调用脚本
./test1		
# 输出
this is the other function
0

# 虽然可以通过函数的推出状态码来查看函数是否成功，
# 但是在大多数情况下希望函数的返回值是一个有意义的值
# 就要用到函数 return 命令
# 举例 2：
vim test1
# 写入以下内容
#! /bin/bash

func2(){
 	echo 'this is the other function'
 	return 20
}

func2
echo "$?"
# 保存退出并调用脚本
./test1		
# 输出
this is the other function
20
# 和使用默认的退出码相比，
# 使用 return 命令可以非常有效的控制函数返回的值
# 另外一点，使用"$?"来进行返回值的访问，必须在函数执行后立即进行
# “return”后退出码的定义必须在 0-255 之间，否则会抛出错误

# **函数输出**
# 可以使用变量保存函数的输出
vim test1
# 写入以下内容
#! /bin/bash

function func1 {
	echo 'This is the function'
}

value=`func1`
echo $value

# 保存退出并调用脚本
./test1		
# 输出 This is the function

2. 函数中的变量使用；

2.1函数参数变量 ；

• 在函数中处理参数

# 与“为 Shell 脚本传递参数类似”
# 也可以再 Shell 函数中以类似的方式来进行参数的调用和处理
touch test2
chmod +x test2
vim test2
# 写入如下内容
#！ /bin/bash

add(){
	# 通过“$#”判断函数参数的数量
	if [ $# -eq 2 ];then
		# 使用“$1”和“$2”这两个位置参数来指代两个参数变量 
		result=$[ $1+$2 ]
		echo $result
	else
		echo "please input 2 params"
		# 返回一个“1”的退出码
		return 1
	fi
}

# 在函数调用时，使用“`”函数调用方式
# 这里的两个位置参数指代的是脚本参数，而不是函数内参数
# 也就是说，这个测试脚本会收取两个参数
# 将两个参数传给调用的 add 函数中
value=`add $1 $2`
# 函数退出码的判断
# "$?" 就是刚才执行的函数的退出码
# 当退出码等于 0 时，也就是函数判断中的 if 判断成功
# 那就返回两个参数的和
if [ $? -eq 0 ];then
	echo $value
else
	# add 函数执行了 else 语句
	# 会将实际的输出作为错误信息进行标准输出
	echo "err: $value"
fi

# 保存退出调用
./test2		# 输出：err: please input 2 params
./test2	1 2 # 输出：3
# 通过 add() 函数 将复杂的逻辑判断封装起来
# 在脚本中就可以简单的调用来进行逻辑的实现
# 这也是函数最主要的作用

# 函数的参数使用和脚本的参数使用非常相似
# 它也包含一系列特殊参数
# 也通过位置参数来进行函数参数的调用 

• 在函数中处理数组参数

touch test3
chmod +x test3
vim test3
# 写入如下内容
#！ /bin/bash

testarray(){
	# 输出所有数组参数
	echo "$@"
	echo "$1"
	echo "$2"
	echo "$#"
}

array=(1 2 3 4 5 6 7)
testarray ${array[*]}
# 保存退出调用
./test3
# 返回
1 2 3 4 5 6 7
1
2
7
# 将数组传递给了函数，
# 但是从函数参数的角度看，实际上传入的是 7 个参数，
# 也就是说，函数将数组中的每一项作为一个参数来处理
# 因此，使用位置参数进行调用时，“$1”就是 1 ，“$2”就是 2
# 而且总的参数数量就是数组的长度

vim test3
# 修改内容
#！ /bin/bash

testarray(){
	echo "$@"
	echo "$1"
	echo "$2"
	echo "$#"
}

sum(){
	result=0
	for var in $@
	do
		result=$[ $result + $var ]
	done
	echo $result
}

array=(1 2 3 4 5 6 7)
sum ${array[*]}
# 保存退出调用
./test3
# 返回 28

# 数组作为函数的输出
vim test3
# 修改内容
#！ /bin/bash

sum(){
	result=0
	for var in $@
	do
		result=$[ $result + $var ]
	done
	echo $result
	# “$@”所显示的是所有的参数
	# 如果想返回一个数组，这里就要新建一个数组
	# 并且使用输入的参数对新的数组进行初始化
	newarray=(`echo "$@"`)
	echo ${newarray[*]}
}

array=(1 2 3 4 5 6 7)
sum ${array[*]}
# 保存退出调用
./test3
# 输出
28
1 2 3 4 5 6 7

2.2 变量的作用域；

• 全局变量 & 局部变量

# 全局变量：整个脚本都有效，函数外部内部都能访问
# 局部变量：函数内部有效
# 使用的参数变量实际上都是局部变量，只在函数内部有效
vim test3
# 修改内容
#！ /bin/bash

sum(){
	local result=0
	for var in $@
	do
		result=$[ $result + $var ]
	done
	echo $result
	local newarray=(`echo "$@"`)
	echo ${newarray[*]}
}

array=(1 2 3 4 5 6 7)
sum ${array[*]}
# 脚本已经有变量 result、newarray
# 刚才没有强调它们的作用域
# 现在在外部调用一下 result 变量
echo "This is outside function: $result"
# 返回 This is outside function: 28
# 虽然是函数内定义的，但是在函数外依然可以访问到这个变量
# 实际上这是一个全局变量，
# 这并不符合预期
# 局部变量的定义：local
local result=0
# 再运行脚本
# 返回 This is outside function: 
# 通过 local 关键字将 result 变量的作用域限制在了定义它的函数中
# 这也是在函数中定于局部变量的方式 
# 如果不使用 local 定义，所有的变量默认都是全局变量
# 就非常容易在函数外部修改修改了函数内部的变量值
# 在程序执行时，带给我们意想不到的结果

# 保存退出调用

3. 使用函数库。

• 如果说函数是对某种特定逻辑的封装，那函数库就是包含了一系列的函数的一个封装，它是函数的更上一层的封装的概念。
• 在 Shell 脚本中，函数库指的是包含可重用函数的脚本文件
• 也就是说，在 Shell 中，函数库是以脚本文件的形式存在的，在这个脚本文件中，它包含了一系列的定义好的函数。而这些函数可以通过对脚本文件的引用来进行重用。
• 创建包含函数的脚本文件，也就是创建一个函数库

touch calc.sh
chmod +x calc.sh
vim calc.sh
# 写入以下内容

#！ /bin/bash

add(){
	local result=0
	if [ $# -eq 2 ];then
		result=$[ $1+$2 ]
		echo $result
	else
		echo "please input 2 params"
		# 返回一个“1”的退出码
	fi
}

sum(){
	local result=0
	for var in $@
	do
		result=$[ $result + $var ]
	done
	echo $result
}

# 保存退出

# calc.sh 就是一个单纯的函数库文件
# 问什么用到“.sh”
# 实际上，Linux 中的文件并不需要扩展名来进行标识，它和 windows 有很大的不同
# windows 是根据扩展名来进行打开文件的匹配，系统通过扩展名知道使用哪些应用软件来打开这个文件
# 而 Linux 实际上是不需要的，这个“.sh”仅仅是帮助我们能更好的在系统中查找到所编写的脚本
# 实际上也可以完全不使用“.sh”作为后缀进行文件名的命名
# 但是会在一些开源的系统中看到很多的脚本文件都以“.sh”命名，实际上是为了方便文件的管理查找

# 在其它脚本里应用函数库文件
source filepath
# source 命令可以将一个已知的文件引入到当前的环境中
# 另一个写法：用“.”代替 source，实际作用一致
. filepath
# 在 bash 中，可以使用 source 命令来进行函数库文件的引入
source calc.sh
add 12 23		# 返回35

# 在脚本中可以以同样的形式进行函数库的引用
touch test4
chmod +x test4
vim test4
# 写入以下内容

#！ /bin/bash

source ./calc.sh

echo `add 12 23`

# 保存退出调用
./test4		# 返回 35

# 如果希望在 bash 启动时自动加载相应的函数库，
# 修改默认的用户目录下的 .bashrc 文件
vim ~/.bashrc
# 在最后添加
. /data/shellscript/functest/calc.sh
# 保存退出