shell编程4-shell嵌套循环及随机数

一.随机数

bash默认有一个$RANDOM的变量		默认是0~32767。使用set |grep RANDOM	查看上一次产生的随机数
echo $RANDOM

产生0~1之间的随机数
echo $[$RANDOM%2]

产生0~2之间的随机数
echo $[$RANDOM%3]

产生0~3之间的随机数
echo $[$RANDOM%4]

产生0~9内的随机数
echo $[$RANDOM%10]

产生0~100内的随机数
echo $[$RANDOM%101]

产生50-100之内的随机数
echo $[$RANDOM%51+50]

产生三位数的随机数
echo $[$RANDOM%900+100]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

实战案例:

• 1.写一个脚本,随机产生以134开头的手机号100个,每个一行写入到phonenum.txt文件中

分析:
1. 产生100个电话号码，脚本需要循环100次
2. 134+8位,后8位随机产生，可以让每一位数字都随机产生，$[RANDOM%10] 0-9
3. 将随机产生的数字分别保存到变量里，然后加上134保存到文件里
[root@shell ~]# vim phonenum.sh
#!/bin/bash
for i in {1..100}
do      
        n1=$[RANDOM%10]
        n2=$[RANDOM%10]
        n3=$[RANDOM%10]
        n4=$[RANDOM%10]
        n5=$[RANDOM%10]
        n6=$[RANDOM%10]
        n7=$[RANDOM%10]
        n8=$[RANDOM%10]
        echo "134$n1$n2$n3$n4$n5$n6$n7$n8" >> phonenum.txt
done
[root@shell ~]# source phonenum.sh 
[root@shell ~]# tail phonenum.txt 
13489797116
13400443887
13418483291
13461270741
13416077839
13470805899
13498525631
13451583328
13425220419
13405672110
[root@shell ~]# cat phonenum.txt |wc -l
100
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

• 2.在上面的100个手机号码中抽取5个幸运观众,并只显示头3个数字和尾号四个数字,中间的数字使用*代替

分析:
1.确定幸运观众所在的行		随机生成 RANDOM   $[RANDOM%1000+1]
2.将电话号码提取出来              head 和 tail
3.显示前3个和后4个数到屏幕     最后将电话号码输出到屏幕   echo ${电话号码部分}
[root@shell ~]# vim phonemem.sh    
#!/bin/bash
file=/root/phonenum.txt
for i in {1..5}
do
        file_num=`wc -l $file |cut -d' ' -f1`
        line=`echo $[$RANDOM%$file_num+1]`
        # 抽取幸运观众行号
        luck=`head -n $line $file|tail -1`
        # 取出幸运观众号码
        echo "134****${luck:7:4}" && echo $luck >> /root/luck_num.txt
        # 显示到屏幕
done
[root@shell ~]# source phonemem.sh 
134****7381
134****5575
134****9506
134****9430
134****4080
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

二.嵌套循环

一个循环体内又包含另一个完整的循环结构,称为循环的嵌套.在外部循环的每次执行过程中都会触发内部循环,直至内部完成一次循环,才接着执行下一次的外部循环.for循环,while循环和until循环都可以相互嵌套.
例:打印一个九九乘法表

[root@shell ~]# vim 1.sh    
#!/bin/bash
for i in {1..9}
do
        u=1
        while [ $u -le $i ]
        do
                echo -ne "$u*$i=$[ $u*$i ]\t"
                # -n 不要在最后自动换行
    　　　　　　 # -e 若字符串中出现以下字符，则特别加以处理，而不会将它当成一般
                let u++
        done
        echo
        echo
        # 换行
done
[root@shell ~]# source 1.sh 
1*1=1

1*2=2   2*2=4

1*3=3   2*3=6   3*3=9

1*4=4   2*4=8   3*4=12  4*4=16

1*5=5   2*5=10  3*5=15  4*5=20  5*5=25

1*6=6   2*6=12  3*6=18  4*6=24  5*6=30  6*6=36

1*7=7   2*7=14  3*7=21  4*7=28  5*7=35  6*7=42  7*7=49

1*8=8   2*8=16  3*8=24  4*8=32  5*8=40  6*8=48  7*8=56  8*8=64

1*9=9   2*9=18  3*9=27  4*9=36  5*9=45  6*9=54  7*9=63  8*9=72  9*9=81

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

三.总结

1.变量定义

普通变量定义：
变量名=值		shell变量默认可以赋予任何类型
$变量名		${变量名}		${变量名:从第几个字符开始:截取几个字符}
unset 变量名

交互式：
read 变量名
-p
-t
-s
-n

数组定义：
array=(var1 var2 var3 ...)
array[0]=var1
array[1]=var2
array[2]=var3
普通数组：数组的索引是整数

定义关联数组
关联数组：索引是字符串

获取数组里的元素：
${array[*]}
${array[2]}
${array[@]:1:2}
${!array[@]}		获取数组的索引号（下标）
${#array[@]}		获取数组索引号的个数

定义有类型的变量：
declare
-i
-x
-a
-A	
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

2.循环语句

for:
列表循环、非列表循环、类C风格			循环次数已知
while：
条件为真，进入循环，条件为假，退出循环	循环次数跟条件有关
until：
条件为假，进入循环，条件为真，退出循环	循环次数跟条件有关
1
2
3
4
5
6

3.影响shell程序的内置命令

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

4.补充扩展expect

expect 自动应答 tcl语言

Tcl(最早称为“工具命令语言”“Tool Command Language”, 但是已经不是这个含义，不过我们仍然称呼它为TCL)是一种脚本语言。 由John Ousterhout创建。 TCL很好学，功能很强大。TCL经常被用于 快速原型开发,脚本编程，GUI和测试等方面。