7月12-15日上课内容第三章 shell编程之循环语句与函数_语句填空:下列 for循环语句将输出: 0 1 2 0 1 2 0 1 2-CSDN博客

本文链接：https://blog.csdn.net/m0_70766460/article/details/131709087

循环遍历

循环：重复执行一段代码的结构，通过循环，可以满足一定的条件之下，多次执行相同的代码

循环语句：循环体，代码的总结构，循环条件，当循环条件满足时，循环体内的代码才会执行，条件不满足，循环结束。

遍历：是指对数据结构中的每个元素都进行一次访问的过程。操作，输出。

循环和遍历是结合在一起使用的

循环实际上是一种控制流程的结构，用于重复执行代码

遍历：对数据进行访问和操作的过程

循环语句

循环的特点：

1、重复执行代码

2、简化程序的逻辑，提高程序的可读性和可理解性，降低了代码出错的可能

3、提高了代码的重复利用率

4、提高了效率，循环可以自动化的让程序执行，减少了人工的干预，提高了效率。

循环的作用就是为了批量执行代码的一种方式。减少人工干预，提高效率。

for循环语句

for循环语句：

1、for循环一般用于已知次数的循环

2、语法结构：

for 变量名 in 取值范围（变量名）

命令序列，对取值范围内的变量进行特定的操作。

done 循环结束的标志。

3、无限循环：for ((;;)) 死循环

for 变量名 in取值范围

命令序列，对取值范围内的变量进行特定的操作。

done 循环结束的标志

应用示例：

示例1：

set -x 开启调试

set +x 关闭调试

执行结果详细展示：

示例2：

结果：

第二种格式：指定循环次数

for i in{1..5}

例：

第三种格式：类c语言格式：

for （（表达式1;表达式2;表达式3））

命令序列

done

for ((i=1;i<=10;i++))

i=1：循环变量的初始值

i<=10：表示i变量的最大值是10

i++：i每次会自加1

从1开始，循环到10

例：

for ((i=1;i<10;i++))

echo $i

done

就是输出1-9

数字累加脚本：

set -x
sum=0
for i in {1..100}
do

sum=$(($i+$sum))

done
set +x

第一次循环：

sum=1=1+0

第二次循环

sum=3=2+1

第三次

sum=6=3+3

第四次

sum=6 i=4

sum=10

第五次：

15=5+10

第六次：

21=6+15

第七次:

28=7+21

第八次：

36=8+28

第九次：

45=9+36

第十次；

55=10+45

1-100

奇数和

偶数和

累加求和：

每一次都是前一次的和，加上当前循环的值，依次往后加，一直加到循环结束。

双重循环：

for

echo -n：表示不换行输出

echo -e：可以使用转义符

常用的转义符

\b：按了一个退格键，理解为删除键

\n：换行，换一行输出

\t：相当于tab键的空格。

\c：不换行输出，字符过长，会导致后面的字符不输出

主要用\t

双重循环演示：

99乘法表过程

循环控制语句：

break：一旦触发了break，整个循环会立刻跳出，即使后面还有循环条件，也不在执行了，整个循环结束。

continue：一旦触发coutinue，只会跳出这一次循环，如果后面的循环条件依然有，继续执行。

continue2：

for i in {1..3}
do
for j in {1..5}
do
if [ $j -eq 3 ]
then
continue 2
fi
echo $j
done
done

break2：

exit：直接退出，后续代码不再执行

作业：

1、计算从1到100所有整数的和

实现：

2、提示用户输入一个小于100的整数，并计算从1到该数之间所有整数的和

实现结果：

3.某山顶上有一颗香蕉树，一只猴子第一天从树上摘了若干根香蕉，当即就吃了一半，还不过瘾，

又多吃了一根。第二天猴子又将剩下的香蕉吃了一半，禁不住诱惑，又多吃了一根香蕉。

依此类推，每天都将剩余的香蕉吃一半后再多吃一根。到了第十天，猴子发现只剩一根香蕉了，请问这只猴子在第一天总共摘了多少根香蕉？

结果：

---------------------------------------------------------------------------------------------------------------------------------

小结：

条件判断：

1、test

2、[ ]

-e -f -d -r -w -x

-a &&

-o ||

3、if [ ]

then

命令序列

单分支结构

if [ ]

then

命令序列

else

命令序列

双分支结构

if [ ]

then

命令序列

elif []

then

命令序列

else

命令序列

多分支结构

if []

嵌套结构

case 语句 in

1）

;;

2）

;;

3）

;;

*）

循环：

for 已知循环次数的场景

for 变量名 in {1..2}

命令序列

done

for（(i=1;i<=10;i++)）

命令序列

done

continue:跳出当前循环，但是后续还有循环条件，会继续执行

break：跳出当前循环，后面的条件不再执行

exit：直接退出，作用与整个脚本，整个脚本立即终止。

exit 0

while 循环

while满足条件执行循环，不满足结束循环

用于不知道循环次数，需要主动结束循环或者达到条件循环的场景。

while [ 条件判断 ]

命令序列

done

1..100

累加求和

while true

while [ 1 -eq 1]

死循环

随机数变量：

$RANDOM,表示一个随机整数

$RANDOM的值范围：0-32767

$((RANDOM%100+1))：1-100

$((RANDOM%1000+1))：1-1000

猜数字：

num=$((RANDOM%100+1))

实现：

测试网段：

192.168.233.0 ping 能把ping通的ip地址保留，保留到/opt/hosts.txt

192.168.233.1-254

read -p

并行执行，效率更快

利用循环把/opt目录下的.txt文件的内容合并到一个文件！

shell计算器

整数的加减乘除余数

购物（较难）详细见后面作业

淘宝只有一家店，

衣服 500

裤子 400

鞋子 300

帽子 200

袜子 100

每次选购完成之后都要提示用户是否继续购买，如果用户不买了，要提示结算金额，你消费了多少

如果继续买，就继续添加商品，最后也要给一个总金额

until语句

当判断条件不成立时，进行循环，条件成立，终止循环

until [ 条件测试语句 ]

命令序列

done

例：1-10求和

cat /etc/passwd | awk -F: '{print $1}'

切片passwd第一行

---------------------------------------------------------------------------------------------------------------------------------

shell函数

命令序列按照格式写在一起

*重复使用的命令序列

使用函数可以避免代码重复

函数可以将大的工程分割成若干小的功能模块，可以提高代码的可读性。

不会用函数，就是小白

return：表示退出函数并返回一个退出值，用$?可以显示这个值

退出值的有范围的0-255 超过255，除以256取余。

在shell脚本中，return的返回值默认就是0或者非0的返回码

return作用在函数内部，在shell中return一般就是判断函数的执行情况

exit：作用于整个脚本，立即终止，没有返回码，脚本会立刻停止运行。

exit 0 程序正常结束 1 程序的异常退出

$? 在shell脚本中exit 0

函数传参

在shell中，调用函数可以传递参数，位置变量来传参，我们在函数内部可以定义位置变量。

函数变量的作用范围

函数在shell中仅在当前的shell环境中有效

在函数中定义的变量值默认为全局变量

递归函数：

函数调用自己本身的函数。

阶乘：

运算符号

4的阶乘

1*2*3*4

尝试用函数递归的方式，写一个阶乘。

要求乘数可以定义

函数调用自己，打印出自定义目录下所有的目录和文件。 /opt

函数库：函数库中只包含函数的定义，脚本中包含调用函数的方法也可以有执行代码

例：计算器

调用函数

作业：

---------------------------------------------------------------------------------------------------------------------------------

shell数组

数组：数字组成的组，组里可以int类型，string字符串

数组当中的数据类型可以由用户自定义。

同一种，也可以是不同的数据类型组成的元素集合。

数组的最大作用：可以一次性定义多个变量。

怎么来定义数组，在shell中创建数组的方法

ky30=(cyb bu qhx dk qj 123 456)

echo ${ky30[*]}

ky30：定义数据的名称

（）定义数组的元素，多个元素之间隔开

[0] [1] [2]

表示数组的下标索引

数组当中的，元素位置的起始下标索引都是0

创建数组：

ky30=(cyb br qhx dk qj 123 456)

怎么查看数组的长度，也就是指数组当中有多少个元素

获取数组小组的元素值：

echo ${ky30[1]} 索引下标从0开始

数组的遍历：

批量添加用户：

数组的切片：只能切一次

索引下标后面的步长，是从当前的索引下标的位置，包含自己的位置，往后走几位，这里指的都是索引位置，不是对应的元素值

数组的替换：

替换数组当中的元素。

echo ${boge[*]/4/66}临时替换，源数组的值是不变的。

永久替换：

[root@localhost opt]# boge=(${boge[*]/4/66})
[root@localhost opt]# echo ${boge[*]}
1 2 3 66 5

要通过重新赋值来实现。

删除数组，以及删除数组当中的指定元素。

[root@localhost opt]# unset boge
[root@localhost opt]# echo ${boge[*]}
删除整个数组

[root@localhost opt]# unset boge
[root@localhost opt]# echo ${boge[*]}

[root@localhost opt]# boge=(handsome tall rich fashion beautlful pool)
[root@localhost opt]# unset boge[5]
[root@localhost opt]# echo ${boge[*]}
handsome tall rich fashion beautlful

通过索引下标的位置，删除数组当中指定的元素。

追加数组元素

[root@localhost opt]# boge[5]=sexy
索引位置为空，可以是追加，如果索引位置有值，就是替换。

如果要追加元素，一般都是安装索引下标的顺序来进行添加。

[root@localhost opt]# boge[${#boge[*]}]=7
[root@localhost opt]# echo ${boge[*]}
sexy tall rich fashion beautlful sexy 7

这是用的最多的一种方式

[root@localhost opt]# boge+=(8 9)
[root@localhost opt]# echo ${boge[*]}
sexy tall rich fashion beautlful sexy 7 8 9
最简单的方式

数组的应用：

1、数组与函数之间的应用：

数组作为参数，传给函数。

seq 自动生成数字排序

seq 1 10 1-10

seq 1 2 10 2：步长，跨度 1 3 5

也可以倒序

seq 10 1 10-1

seq 10-2 1 倒序步长加个减号

函数调用数组传参：

例1：

例2：

1 2 3 4 5 6

对应的索引下标

0 1 2 3 4 5

abc[0]=1

abc[1]=2

0 1就是对应的索引下标

为什么长度要减一？

6个数，索引只到5，要从0开始算，0-5,6-1就是5

循环从0

到5

abc=(1 2 3 4 5 6)

1 2 3 4 5 6

0 1 2 3 4 5

长度是6，索引下标是5，长度减1就是5

循环从0开始 <=5

也就是0-5 也循环了6次 0 1 2 3 4 5

abc[0]=1

abc[1]=2

${abc[0]}1 * 2=2

就是取索引下标为0的数也就是1 乘 2，把这个值重新赋给索引下标为0的数，1就变成了2

1 2

0 1 2

1 2 4

2 3 6

3 4 8

4 5 10

5 6 12

变形：

冒泡排序：面试会问

类型气泡上涌在数组当中从小到大，或者从大到小进行排序

就是把一个大小顺序混乱的一个数组，安装从小到大或者从大到小进行排序。

冒泡排序的思路：

abc=(20 10 60 40 50 30)

从小到大：

两个相邻的数来比

大的往右走，小的往左走

20 10

10 20

abc[0]=10

abc[1]=20

依次比，小的都往前走，大的都往后移

1、冒泡排序需要双循环

外循环要确定次数

内循环比大小，换位置

实现循环次数和轮次减少

比完了，排序就完成了

示例：

实现：

核心就是两个数相比较，前面的数比后面的数小，位置不变；第一个数比第二个数大，小的就往前走，大的数就要往后移动。

核心就在于用位置互换来实现排序

abc=(20 10 60 40 50 30)

first=${abc[k]}

0 first=20

j=$(($k+1))

second=${$abc[$j]}

second=10

if [ $first -gt $second ]

20 10

then

temp=$first

abc[$k]=$second

0=10

abc[$j]=$temp

1=20

abc[0]=10

abc[1]=20

这样就实现了位置的互换

作业讲解：

超市购物：

进制转换：

思路：

代码：

效果：

用户名存放在users.txt文件中，每行一个，判断文件里的用户是否存在，若该用户存在，
输出提示该用户已存在；用户存在但没设密码，则提示用户并让用户设置密码；
若该用户不存在，提示用户输入密码，建立用户并设立其密码

用户输入密码，脚本判断密码是否正确，正确密码为123456，输入正确提示正确信息，连续输错3次则报警

文件删除：

安装nginx服务

cangku () {
wget -O /etc/yum.repos.d/CentOS-Base.repo https://mirrors.aliyun.com/repo/Centos-7.repo

yum clean all && yum makecache

yum -y install epel-release.noarch

}

anzhuang () {

yum -y install $1

}

. /opt/hanshuku.sh

cangku

read -p "请输入你想安装的软件名：" a
anzhuang $a