Linux Shell编程及自动化运维实现 第4章 数组和函数

数组

数组简介

变量：用一个固定的字符串，代替一个不固定字符串。
数组：用一个固定的字符串，代替多个不固定字符串。

类型

	普通数组：只能使用整数作为数组索引
	关联数组：可以使用字符串作为数组索引
	总结
		变量切片有个索引的概念。一个索引（整数）对应一个字符。
		普通数组：中的索引对应一个字符串。
		关联数组：数组中的索引可以使用字符串。

一、普通数组

定义数组：

方法一： 一次赋一个值

数组名[下标]=变量值
# array1[0]=pear
# array1[1]=apple
# array1[2]=orange
# array1[3]=peach
查看数组
[root@localhost ~]# declare -a | grep array1
declare -a array1='([0]="pear" [1]="apache" [2]="orange")'
查看数组
[root@localhost ~]# echo ${array1[@]}
pear apache orange

方法二：一次赋予多个值

# array2=(tom jack alice)
# array3=(`cat /etc/passwd`) 
希望是将该文件中的每一个行作为一个元数赋值给数组array3
# array5=(tom jack alice "bash shell")
# array6=(1 2 3 4 5 6 7 "linux shell" [20]=saltstack)

二、关联数组

定义关联数组：

先声明关联数组
方法一： 一次赋一个值

注：

数组名[索引]=变量值
# declare -A  ass_array1
# ass_array1[index1]=pear
# ass_array1[index2]=apple
# ass_array1[index3]=orange
# ass_array1[index4]=peach
查看
[root@localhost ~]# echo ${ass_array1[@]}
peach pear apple orange

方法二： 一次赋多个值

# declare  -A  ass_array2
# ass_array2=([index1]=tom [index2]=jack
 [index3]=alice [index4]='bash shell')

访问数组元素：
# echo ${ass_array2[index2]} 访问数组中的第二个元数
# echo ${ass_array2[@]} 访问数组中所有元数 等同于 echo ${array1[*]}
# echo ${#ass_array2[@]} 获得数组元数的个数
# echo ${!ass_array2[@]} 获得数组元数的索引

数组和循环

1：通过循环定义和显示数组
2：通过数组统计数据

---

案例1：while脚本快速定义数组

定义数组
	#!/bin/bash
#循环读取文件，定义数组
while read line
do
#hosts:数组名
#[++i]:索引递增,++i是1开始，i++是0开始。
#$line:值，即文件中的内容
    hosts[++i]=$line
done < /etc/hosts

#输出索引每一行
for i in ${!hosts[@]}
do
echo "$i  :   ${hosts[$i]}"
done

---

案例2：for脚本快速定义数组

否则效果为

---

案例3：使用数组统计，用户shell的类型和数量

#！/bin/bash
declare -A shells
while read ll
do
type=`echo $ll | awk -F:  '{print $NF}'`
let shells[$type]++
done  < /etc/passwd

for i in ${!shells[*]}
do
echo "$i: ${shells[$i]}"
done

---

函数

概述

概念
	函数是一段完成特定功能的代码片段（块）
在shell中定义了函数，就可以使代码模块化，便于复用代码
注意函数必须先定义才可以使用。
重点
	传参 $1,$2
局部变量 local
返回值 return   即$?

一、定义函数

方法一
	函数名() {
函数要实现的功能代码
}
方法二
	方法二：
function 函数名 {
函数要实现的功能代码
}

二、调用函数

语法
	函数名
函数名 参数1 参数2

示例1：初识函数

需求
通过shell脚本，编写系统工具箱
编写循环脚本，功能菜单
provide these tools:
show disk info(d)
show mem info(m)
show cpu info©
quit(q)

#!/bin/bash
show_menu () {
cat << EOF
provide these tools:
show disk info (d)
show mem info (m)
show cpu info (c)
quit (q)
EOF
}

show_menu
while :
do
read -p "input demand:" input
    case $input in
d)
    echo "*****disk*****"
    df -hT
;;
m)
    echo "*****meme*****"
    free-m
;;
c)
    echo "*****cpu*****"
    uptime
;;
q)
    echo "*****exit*****"
     break
;;
h)
    echo "*****help*****"
    show_menu
;;
esac
done

---

示例2：阶乘函数（传参）

需求
制作函数用于阶乘

#!/bin/bash
#定义函数
fun(){
factor=1
for((i=1;i<=5;i++))
do
        factor=$[$factor*$i]
done
    echo "5的阶乘是：$factor"
}
fun

优化1：传参，让函数能够自定义

#!/bin/bash
#定义函数
fun(){
factor=1
for((i=1;i<=$1;i++))
do
    factor=$[$factor*$i]
done
    echo "$1 的阶乘是：$factor"
}
fun 6
fun 7

#i<=$1 参数1是阶乘的上限

优化2：传参2，由脚本外部传递参数。

#!/bin/bash
#定义函数
fun(){
factor=1
for((i=1;i<=$1;i++))
do
    factor=$[$factor*$i]
done
    echo "$1 的阶乘是：$factor"
}
fun $1
fun $2
fun $3
fun $4

优化3：shell 的写法和其他运算表达式。

#!/bin/bash
#定义函数
fun(){
factor=1
#for((i=1;i<=$1;i++))
for i in `seq $1`
do
#       factor=$[$factor*$i]
    let factor*=$i
done
    echo "$1 的阶乘是：$factor"
}
fun $1
#fun $2
#fun $3
#fun $4

---

示例3：函数传参 数组传参

1 制作一个简单的阶乘脚本。通过数组给函数传参

#!/bin/bash
num=(1 2 3 4 5)
array(){
acm=1
for i in $*
do
    acm=$[acm*$i]
done
    echo $acm
}
array ${num[*]}

2.数组的好处在于，多个数组时传参的效率就增高了。

#!/bin/bash
num1=(1 2 3 4 5)
num2=(6 7 8)
array(){
acm=1
for i in $*
do
    acm=$[acm*$i]
done
    echo $acm
}
array ${num1[*]}

array ${num2[*]}

示例4：函数结果 赋予数组

#!/bin/bash
num=(1 2 3)
array(){
    #local定义变量仅在函数中有效。
    local j
    #设置循环的次数，等于索引总数。
            for i in  $*
            do
            #定义不同的值乘以5.注意调取值的时候使用的是索引。
                    outarray[j++]=$[$i+5]

            done
    #输出新的数组。
    echo "${outarray[*]}"
}
array ${num[*]}

关于i++递增的问题
[root@localhost ~]# aaa[i++]=111
[root@localhost ~]# aaa[i++]=222
[root@localhost ~]# aaa[i++]=333
[root@localhost ~]# echo ${!aaa[@]}
0 1 2
[root@localhost ~]# echo ${aaa[@]}
111 222 333

[root@localhost ~]# ccc[++k]=111
[root@localhost ~]# ccc[++k]=222
[root@localhost ~]# ccc[++k]=333
[root@localhost ~]# echo ${!ccc[@]}
1 2 3
[root@localhost ~]# echo ${ccc[@]}
111 222 333
[root@localhost ~]# aaa[1]=3
[root@localhost ~]# echo ${aaa[@]}
3
[root@localhost ~]# aaa[1]=$[3*5]
[root@localhost ~]# echo ${aaa[@]}
15
[root@localhost ~]# aaa[i++]=20
[root@localhost ~]# aaa[i++]=25
[root@localhost ~]# aaa[i++]=30
[root@localhost ~]# echo ${aaa[@]}
15 20 25 30

影响Shell程序的内置命令

概览

:
true
false
exit
break
continue
shift
————————————————————————

shift 使位置参数向左移动，默认移动1位，可以使用shift 2
exit 退出整个程序
break 结束当前循环，或跳出本层循环
continue 忽略本次循环剩余的代码，直接进行下一次循环

需求
1 通过循环脚本，输出如下效果。
	  A123456789
  B123456789
...
  D123456789

---

2 编写循环脚本。
#!/bin/bash
for i in {A..D}
do
    echo   $i
    for j in {1..9}
    do
    echo   $j
    done
    echo
done

因为默认echo输出换行符，使用-n不输出

修改过后·
#!/bin/bash
for i in {A..D}
do
    echo -n  $i
    for j in {1..9}
    do
    echo   -n  $j
    done
    echo
done

总结：循环嵌套的规则是：外部循环一次，内部循环一轮。

---

---

---

循环嵌套，打印乘法口诀表。

#!/bin/bash -
for i in `seq 9`
do
for j in `seq 9`
    do
    [ $j -le $i ] && echo -n "$i x $j = `echo $(($i*$j))`  " 
done
echo ""
done

---

2 使用while循环，发现停不下来
#!/bin/bash
while [ $# -ne 0 ]
do
    let sum+=$1
    echo $sum
done
echo "sum : $sum"
测试
	[root@localhost ~]# bash sum.sh 1 2
根本停不下来。因为循环为真。




3 使用shift 移动参数的命令。结果得以实现。
#!/bin/bash
while [ $# -ne 0 ]
do
    let sum+=$1
    shift
done
echo "sum : $sum"
测试：
	[root@localhost ~]# bash sum.sh 1 2
sum : 3
[root@localhost ~]# bash sum.sh 1 2 3
sum : 6
总结：
	shift 1使参数 左移1位，shift 2 左移2位