shell脚本——函数与数组

目录

一、函数

1、什么是函数？

2、函数的定义与调用

2.1 函数的格式

2.2 函数的调用方法

3 、查看与删除函数

3.1 查看函数

3.2 删除函数

4、函数的返回值

5、函数的传参数

6、函数的作用范围

7、函数的递归

二、数组

1、什么是数组？

2、数组的语法格式

3、数组的数据类型

4、数组的属性

4.1 获取数组的长度

4.2 获取数组的数据列表

4.3获取数组下标的值

5、数组的常用操作

5.1 数组的遍历

5.2 数组切片

5.3 数组替换

5.4 数组删除和指定下标的值删除

5.5 数组追加元素

5.6 declare -a：查看所有数组

三、冒泡排序

1、冒泡排序的定义

2、冒泡排序的原理

---

一、函数

1、什么是函数？

函数定义：封装的可重复利用的具有特定功能的代码
函数就是可以在shell脚本当中做出一个类似自定义执行的命令的东西，最大的功能就是简化我们很多的代码。

• 将命令序列按照格式书写在一起
• 可方便重复使用命令序列

2、函数的定义与调用

2.1 函数的格式

方法一：
[function] 函数名 (){
	命令序列
	[return x]         #使用return或者exit可以显式的结束函数
}
 
 
方法二：
函数名(){
	命令序列
}

注意事项 

1. 直接写 函数中调用函数 直接写函数名

2. 同名函数 后一个生效

3. 调用函数一定要先定义

4. 每个函数是独立

2.2 函数的调用方法

示例1：查看当前操作系统

#定义函数
#!/bin/bash
 
os (){
if  grep -i -q "CentOS Linux 7 " /etc/os-release
then 
 echo "此操作系统是centos 7"
 
 
elif  grep -i -q "CentOS Linux 6 " /etc/os-release
then 
 echo "此操作系统是centos 6"
 
elif  grep -i -q "CentOS Linux 8 " /etc/os-release
then 
 echo "此操作系统是centos 8"
fi
}
 
#调用函数
os

示例2：函数备份yum线上源，创建yum本地源和清理缓存安装httpd

#!/bin/bash
backups(){
cd /etc/yum.repos.d
mkdir repo.bak
mv *.repo repo.bak
mount /dev/sr0 /mnt >/dev/null
}
 
configuration(){
echo -e '[local]\nname=local\nbaseurl=file:///mnt\nenable=1\ngpgcheck=0' >/etc/yum.repos.d/local.repo
}
 
clean(){
yum clean all
yum makecache
yum install -y httpd > /dev/null
}
 
 
backups
configuration
clean

3 、查看与删除函数

3.1 查看函数

[root@localhost ~]# declare -F
#函数列表
declare -f __HOSTNAME
declare -f __SIZE
declare -f __SLAVEURL
[root@localhost ~]# declare -f
#函数具体的定义

3.2 删除函数

[root@localhost ~]unset 函数名

4、函数的返回值

return表示退出函数并返回一个退出值，脚本中可以用$?变量表示该值

使用原则：

1. 函数一结束就去返回值，应为$?变量只返回执行的最后一条命令的退出返回码

2. 退出码必须是0-255，超出的值将为除以256取余

解决大于255的方法：

5、函数的传参数

在Shell中，调用函数时可以向其传递参数。在函数体内部，通过 $n 的形式来获取参数的值，例如，$1表示第一个参数，$2表示第二个参数…即使用位置参数来实现参数传递。

示例脚本：

#!/bin/bash
sum () {
echo "第一个位置参数：" $1
echo "第二个位置参数：" $2
let n=$1+$2
echo $n
}
sum $2 $1

6、函数的作用范围

• 函数在Shell脚本中仅在当前Shell环境中有效
• Shell脚本中变量默认全局有效
• 将变最限定在函数内部使用local命令

示例脚本1：Shell脚本中变量默认全局有效

7、函数的递归

函数调用自己本身的函数

示例1：阶乘函数

fact() {
  if [ $1 -eq 1 ]
  then
    echo 1
  else
   local temp=$[$1 - 1]
   local result=$(fact $temp)
   echo $[$1 * $result]
		#  5 * $result(4*$result(3*$result(2*$result(1))))
  fi
}
read -p "请输入：" n
result=$(fact $n)
echo $result

二、数组

1、什么是数组？

• 数组中可以存放多个值。Bash Shell 只支持一维数组（不支持多维数组），初始化时不需要定义数组大小（与 PHP 类似）。
• 与大部分编程语言类似，数组元素的下标由 0 开始。
• Shell 数组用括号来表示，元素用"空格"符号分割开
• 在shell语句中，使用、遍历数组的时候，数组格式要写成 ${arr[@]} 或 ${arr[*]}

2、数组的语法格式

格式一：
数组名=(value1 value2 ... valuen)
arr_number=(1 2 3 4 5 6 7 8 9)

格式二：
数组名=([0]=value0 [1]=value0 [2]=value0 ...)
arr_number=([0]=1 [1]=2 [2]=3 [3]=4)

格式三：
列表名：“value1 value2 valueN ..."
数组名=($列表名)
list_number="1 2 3 4 5 6"
arr_number=($list_number)

格式四：
数组名[0]="value"
数组名[1]="value"
数组名[2]="value"
arr_number[0]=1
arr_number[1]=2
arr_number[2]=3

3、数组的数据类型

• 数值类型
• 字符类型
• 使用 “ ”（双引号） 或者 ‘ ’ （单引号）定义

4、数组的属性

4.1 获取数组的长度

echo ${#数组名[*]} 
echo ${#数组名[@]} 

4.2 获取数组的数据列表

echo ${数组名[*]}
echo ${数组名[@]}

4.3获取数组下标的值

数组名=（元素0  元素1  元素2  ……）					
#定义数组
echo ${数组名[索引值]}							
#输出数组索引值对应的元素，索引值为从0开始

5、数组的常用操作

5.1 数组的遍历

#!/bin/bash
a=(1 2 3 4 5 6)
for i in ${a[@]}
do
   echo $i
done

5.2 数组切片

a=(0 1 2 3 4 5 6 7 8)
echo "输出整个数组: " ${a[@]}
echo "取出数组1到3: " ${a[@]:1:3}
echo "取出数组5到后面所有的元素: " ${a[@]:5:5}

5.3 数组替换

#临时替换
echo ${a[@]/原替换位置/替换内容} 
 
#重新赋值，可以永久修改
a=(${a[@]/原替换位置/替换内容})

5.4 数组删除和指定下标的值删除

#删除整个数组
unset 数组名
 
#删除指定下标的值
unset 数组名[数组下标]

5.5 数组追加元素

方法一：直接使用下标进行元素的追加

数组名[下标]=变量

方法二：将数组的长度作为下标进行追加元素

数组名[${数组名[@]}]=变量名

方法三：使用+=进行追加

数组名+=(变量1 变量2 ...)

5.6 declare -a：查看所有数组

三、冒泡排序

1、冒泡排序的定义

冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端，但是在广泛适用后，冒泡排序可以用来排任意顺序。

2、冒泡排序的原理

假设要将已知无需数列按从小到大排列，将第一个元素与后面的元素依次比较，如果必后面的元素小，就与后面某个元素交换位置，然后用这个元素再依次往后比较，遇到比这个元素小的就与这个元素交换，直到最后一个元素，就完成了一趟冒泡排序，则最后一个元素一定是这个序列里最大的一个元素；然后开始第二趟冒泡排序，继续从第一个元素开始往后一次比较，遇到较小的就交换位置，直到倒数第二个数，那么最后倒数第二个数就变成了第二大的数.......依次排完序列中所有的数，那么这个数的顺序就会变成从小到大，下面我用图来演示

假设有下面一组无序数组，我们要对他们进行升序排序，具体实现过程如下：

首先让 6 和 9 比较，发现 6 比 9 要小，因此元素位置不变。

接下来让 9 和 7 比较，发现 9 比 7 要大，所以 9 和 7 交换位置。

继续让 9 和 4 比较，发现 9 比 4 要大，所以 9 和 4 交换位置。

继续让 9 和 10 比较，发现 9 比 10 要小，所以元素位置不变。

最后让 10 和 2 比较，发现 10 比 2要大，所以 10 和 2 交换位置。

这样一来，元素 10 作为数列的最大元素，就像是汽水里的小气泡一样漂啊漂，漂到了最右侧。

这时候，我们的冒泡排序的第一轮结束了。数列最右侧的元素 10 可以认为是一个有序区域，有序区域目前只有一个元素。

第二趟冒泡排序的过程

下面，让我们来进行第二轮排序：

首先让 6 和 7 比较，发现 6 比 7 要小，因此元素位置不变。

接下来让 7 和 4 比较，发现 7 比 4 要大，所以 7 和 4 交换位置。

继续让 7 和 9 比较，发现 7 比 9 要小，因此元素位置不变。

接下来让 9 和 2 比较，发现 9 比 2 要大，所以 9 和 2 交换位置。

 第二轮排序结束后，我们数列右侧的有序区有了两个元素，顺序如下：

第三趟冒泡排序的过程

按照以上步骤，第三轮过后的状态如下：

第四趟冒泡排序的过程

第四轮过后状态如下：

第五趟冒泡排序的过程

第五轮过后状态如下：

 到此为止，所有元素都是有序的了，这就是冒泡排序的整体思路。

代码实现：

#!/bin/bash
#排序之前的数组顺序
a=(6 9 7 4 10 2) 
#确定循环比较的次数
for ((j=1;j<${#a[@]};j++))
do
#对比获取每次的最大元素的索引位置
for ((i=0;i<${#a[@]}-j;i++))
do
#如果对比出最大元素，就把该元素赋值给后面的变量tmp
if  [ ${a[$i]} -gt ${a[$i+1]} ]
then
#定义一个变量tmp，将每次比较的最大数值放进tmp，实现变量对换
tmp=${a[$i+1]}
a[$i+1]=${a[$i]}
a[$i]=$tmp
fi
done
done
echo ${a[*]}