[toc]

课程目标

  • 掌握for循环语句的基本语法结构
  • 掌握while和until循环语句的基本语法结构
  • 能会使用RANDOM产生随机数
  • 理解嵌套循环

一、随机数

关键词：一切都是未知数，永远不知道明天会抽什么风嵌套循环+随机数及综合案例 - 图1嵌套循环+随机数及综合案例 - 图2

1. 如何生成随机数？

系统变量：RANDOM，默认会产生0~32767的随机整数

前言：要想调用变量，不管你是什么变量都要给钱，而且是美元嵌套循环+随机数及综合案例 - 图3

  1. 打印一个随机数
  2. echo $RANDOM
  3. 查看系统上一次生成的随机数
  4. # set|grep RANDOM
  5. RANDOM=28325
  7. 产生0~1之间的随机数
  8. echo $[$RANDOM%2]
  10. 产生0~2之间的随机数
  11. echo $[$RANDOM%3]
  13. 产生0~3之间的随机数
  14. echo $[$RANDOM%4]
  16. 产生0~9内的随机数
  17. echo $[$RANDOM%10]
  19. 产生0~100内的随机数
  20. echo $[$RANDOM%101]
  23. 产生50-100之内的随机数
  24. echo $[$RANDOM%51+50]
  26. 产生三位数的随机数
  27. echo $[$RANDOM%900+100]

2. 实战案例

㈠ 随机产生以139开头的电话号码

具体需求1：

写一个脚本，产生一个phonenum.txt文件，随机产生以139开头的手机号1000个，每个一行。

① 思路

  1. 产生1000个电话号码，脚本需要循环1000次 FOR WHILE UNTIL
  2. 139+8位,后8位随机产生，可以让每一位数字都随机产生 echo $[$RANDOM%10]
  3. 将随机产生的数字分别保存到变量里，然后加上139保存到文件里

② 落地实现

  2. #!/bin/env bash
  3. #产生1000个以139开头的电话号码并保存文件phonenum.txt
  4. file=/shell03/phonenum.txt
  5. for ((i=1;i<=1000;i++))
  6. do
  7.     n1=$[$RANDOM%10]
  8.     n2=$[$RANDOM%10]
  9.     n3=$[$RANDOM%10]
  10.     n4=$[$RANDOM%10]
  11.     n5=$[$RANDOM%10]
  12.     n6=$[$RANDOM%10]
  13.     n7=$[$RANDOM%10]
  14.     n8=$[$RANDOM%10]
  15.     echo "139$n1$n2$n3$n4$n5$n6$n7$n8" >> $file
  16. done
  19. #!/bin/bash
  20. # random phonenum
  21. # 循环1000次产生电话号码并保存到文件
  22. for i in {1..1000}
  23. do
  24.     n1=$[RANDOM%10]
  25.     n2=$[RANDOM%10]
  26.     n3=$[RANDOM%10]
  27.     n4=$[RANDOM%10]
  28.     n5=$[RANDOM%10]
  29.     n6=$[RANDOM%10]
  30.     n7=$[RANDOM%10]
  31.     n8=$[RANDOM%10]
  32.     echo "139$n1$n2$n3$n4$n5$n6$n7$n8" >> phonenum.txt
  33. done
  35. #!/bin/bash
  36. i=1
  37. while [ $i -le 1000 ]
  38. do
  39.     n1=$[$RANDOM%10]
  40.     n2=$[$RANDOM%10]
  41.     n3=$[$RANDOM%10]
  42.     n4=$[$RANDOM%10]
  43.     n5=$[$RANDOM%10]
  44.     n6=$[$RANDOM%10]
  45.     n7=$[$RANDOM%10]
  46.     n8=$[$RANDOM%10]
  47.     echo "139$n1$n2$n3$n4$n5$n6$n7$n8" >> phonenum.txt
  48.     let i++
  49. done
  51. continue:继续，跳过本次循环，执行下一次循环
  52. break:打断，执行循环体外的代码do..done外
  53. exit:退出程序
  56. #!/bin/bash
  57. for i in {1..1000}
  58. do
  59.     n1=$[$RANDOM%10]
  60.     n2=$[$RANDOM%10]
  61.     n3=$[$RANDOM%10]
  62.     n4=$[$RANDOM%10]
  63.     n5=$[$RANDOM%10]
  64.     n6=$[$RANDOM%10]
  65.     n7=$[$RANDOM%10]
  66.     n8=$[$RANDOM%10]
  67.     echo "139$n1$n2$n3$n4$n5$n6$n7$n8" >> phonenum.txt
  68. done
  70. #!/bin/bash
  71. #create phone num file
  72. for ((i=1;i<=1000;i++))
  73. do
  74.     n1=$[$RANDOM%10]
  75.     n2=$[$RANDOM%10]
  76.     n3=$[$RANDOM%10]
  77.     n4=$[$RANDOM%10]
  78.     n5=$[$RANDOM%10]
  79.     n6=$[$RANDOM%10]
  80.     n7=$[$RANDOM%10]
  81.     n8=$[$RANDOM%10]
  82.     echo "139$n1$n2$n3$n4$n5$n6$n7$n8" |tee -a phonenum.txt
  83. done
  85. #!/bin/bash
  86. count=0
  87. while true
  88. do
  89.     n1=$[$RANDOM%10]
  90.     n2=$[$RANDOM%10]
  91.     n3=$[$RANDOM%10]
  92.     n4=$[$RANDOM%10]
  93.     n5=$[$RANDOM%10]
  94.     n6=$[$RANDOM%10]
  95.     n7=$[$RANDOM%10]
  96.     n8=$[$RANDOM%10]
  97.     echo "139$n1$n2$n3$n4$n5$n6$n7$n8" |tee -a phonenum.txt && let count++
  98.     if [ $count -eq 1000 ];then
  99.         break
  100.     fi
  101. done

㈡ 随机抽出5位幸运观众

具体需求：

  1. 在上面的1000个手机号里抽奖5个幸运观众，显示出这5个幸运观众。
  2. 但只显示头3个数和尾号的4个数，中间的都用*代替

① 思路

  1. 确定幸运观众所在的行 0-1000 随机找出一个数字 $[$RANDOM%1000+1]
  2. 将电话号码提取出来 head -随机产生行号 phonenum.txt |tail -1
  3. 显示前3个和后4个数到屏幕 echo 139****

② 落地实现

  1. #!/bin/bash
  2. #定义变量
  3. phone=/shell03/phonenum.txt
  4. #循环抽出5位幸运观众
  5. for ((i=1;i<=5;i++))
  6. do
  7.     #定位幸运观众所在行号
  8.     line=`wc -l $phone |cut -d' ' -f1`
  9.     luck_line=$[RANDOM%$line+1]
  10.     #取出幸运观众所在行的电话号码
  11.     luck_num=`head -$luck_line $phone|tail -1`
  12.     #显示到屏幕
  13.     echo "139****${luck_num:7:4}"
  14.     echo $luck_num >> luck.txt
  15.     #删除已经被抽取的幸运观众号码
  16.     #sed -i "/$luck_num/d" $phone
  17. done
  20. #!/bin/bash
  21. file=/shell04/phonenum.txt
  22. for i in {1..5}
  23. do
  24.     file_num=`wc -l $file |cut -d' ' -f1`
  25.     line=`echo $[$RANDOM%$file_num+1]`
  26.     luck=`head -n $line  $file|tail -1`
  27.     echo "139****${luck:7:4}" && echo $luck >> /shell04/luck_num.txt
  28. done
  31. #!/bin/bash
  32. for ((i=1;i<=5;i++))
  33. do
  34. file=phonenum.txt
  35. line=`cat phonenum.txt |wc -l`    1000
  36. luckline=$[$RANDOM%$line+1]
  37. phone=`cat $file|head -$luckline|tail -1`
  38. echo "幸运观众为:139****${phone:7:4}"
  39. done
  42. 或者
  43. #!/bin/bash
  44. # choujiang
  45. phone=phonenum.txt
  46. for ((i=1;i<=5;i++))
  47. do
  48.     num=`wc -l phonenum.txt |cut -d' ' -f1`
  49.     line=`echo $[$RANDOM%$num+1]`
  50.     luck=`head -$line $phone |tail -1`
  51.     sed -i "/$luck/d" $phone
  52.     echo "幸运观众是:139****${luck:7:4}"
  53. done

㈢ 批量创建用户(密码随机产生)

需求：批量创建5个用户，每个用户的密码为一个随机数

① 思路

  1. 循环5次创建用户
  2. 产生一个密码文件来保存用户的随机密码
  3. 从密码文件中取出随机密码赋值给用户

② 落地实现

  1. #!/bin/bash
  2. #crate user and set passwd
  3. #产生一个保存用户名和密码的文件
  4. echo user0{1..5}:itcast$[$RANDOM%9000+1000]#@~|tr ' ' '\n'>> user_pass.file
  6. #循环创建5个用户
  7. for ((i=1;i<=5;i++))
  8. do
  9.     user=`head -$i user_pass.file|tail -1|cut -d: -f1`
  10.     pass=`head -$i user_pass.file|tail -1|cut -d: -f2`
  11.     useradd $user
  12.     echo $pass|passwd --stdin $user
  13. done
  15. 或者
  16. for i in `cat user_pass.file`
  17. do
  18.     user=`echo $i|cut -d: -f1`
  19.     pass=`echo $i|cut -d: -f2`
  20.     useradd $user
  21.     echo $pass|passwd --stdin $user
  22. done
  24. #!/bin/bash
  25. #crate user and set passwd
  26. #产生一个保存用户名和密码的文件
  27. echo user0{1..3}:itcast$[$RANDOM%9000+1000]#@~|tr ' ' '\n'|tr ':' ' ' >> user_pass.file
  28. #循环创建5个用户
  29. while read user pass
  30. do
  31. useradd $user
  32. echo $pass|passwd --stdin $user
  33. done < user_pass.file
  36. pwgen工具产生随机密码：
  37. [root@server shell04]# pwgen -cn1 12
  38. Meep5ob1aesa
  39. [root@server shell04]# echo user0{1..3}:$(pwgen -cn1 12)
  40. user01:Bahqu9haipho user02:Feiphoh7moo4 user03:eilahj5eth2R
  41. [root@server shell04]# echo user0{1..3}:$(pwgen -cn1 12)|tr ' ' '\n'
  42. user01:eiwaShuZo5hi
  43. user02:eiDeih7aim9k
  44. user03:aeBahwien8co

二、嵌套循环

关键字：大圈套小圈

嵌套循环+随机数及综合案例 - 图4时钟：分针与秒针，秒针转⼀圈（60格），分针转1格。循环嵌套就是外层循环⼀次，内层循环⼀轮。

  1. 一个循环体内又包含另一个完整的循环结构，称为循环的嵌套。
  2. 每次外部循环都会触发内部循环，直至内部循环完成，才接着执行下一次的外部循环。
  3. for循环、while循环和until循环可以相互嵌套。

1. 应用案例

㈠ 打印指定图案

  1. 1
  2. 12
  3. 123
  4. 1234
  5. 12345
  7. 5
  8. 54
  9. 543
  10. 5432
  11. 54321

㈡ 落地实现1

  1. X轴：
  2. for ((i=1;i<=5;i++));do echo -n $i;done
  3. Y轴：
  4. 负责打印换行
  6. #!/bin/bash
  7. for ((y=1;y<=5;y++))
  8. do
  9.     for ((x=1;x<=$y;x++))
  10.     do
  11.         echo -n $x
  12.     done
  13. echo
  14. done
  16. #!/bin/bash
  17. for ((y=1;y<=5;y++))
  18. do
  19.     x=1
  20.     while [ $x -le $y ]
  21.         do
  22.         echo -n $x
  23.         let x++
  24.         done
  25. echo
  26. done

㈢ 落地实现2

  1. Y轴：打印换行
  2. X轴：打印数字 5-1
  4. #!/bin/bash
  5. y=5
  6. while (( $y >= 1 ))
  7. do
  8.     for ((x=5;x>=$y;x--))
  9.     do
  10.         echo -n $x
  11.     done
  12. echo
  13. let y--
  14. done
  17. #!/bin/bash
  18. for (( y=5;y>=1;y--))
  19. do
  20.     for (( x=5;x>=$y;x--))
  21.     do
  22.     echo -n $x
  23.     done
  24. echo
  25. done
  27. #!/bin/bash
  28. y=5
  29. while [ $y -ge 1 ]
  30. do
  31.     for ((x=5;x>=$y;x--))
  32.     do
  33.     echo -n $x
  34.     done
  35. echo
  36. let y--
  37. done
  40. #!/bin/bash
  41. y=1
  42. until (( $y >5 ))
  43. do
  44.     x=1
  45.     while (( $x <= $y ))
  46.     do
  47.     echo -n $[6-$x]
  48.     let x++
  49.     done    
  50. echo
  51. let y++
  52. done
  55. 课后打印：
  56. 54321
  57. 5432
  58. 543
  59. 54
  60. 5

2. 课堂练习

打印九九乘法表（三种方法）

  1. 1*1=1
  3. 1*2=2   2*2=4
  5. 1*3=3   2*3=6   3*3=9
  7. 1*4=4   2*4=8   3*4=12  4*4=16
  9. 1*5=5   2*5=10  3*5=15  4*5=20  5*5=25
  11. 1*6=6   2*6=12  3*6=18  4*6=24  5*6=30  6*6=36
  13. 1*7=7   2*7=14  3*7=21  4*7=28  5*7=35  6*7=42  7*7=49
  15. 1*8=8   2*8=16  3*8=24  4*8=32  5*8=40  6*8=48  7*8=56  8*8=64
  17. 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
  20. Y轴：循环9次，打印9行空行
  21. X轴：循环次数和Y轴相关；打印的是X和Y轴乘积 $[] $(())
  23. #!/bin/bash
  24. for ((y=1;y<=9;y++))
  25. do
  26.     for ((x=1;x<=$y;x++))
  27.     do
  28.         echo -ne "$x*$y=$[$x*$y]\t"
  29.     done
  30. echo
  31. echo
  32. done
  35. #!/bin/bash
  36. y=1
  37. while [ $y -le 9 ]
  38. do
  39.         x=1
  40.         while [ $x -le $y ]
  41.         do
  42.                 echo -ne "$x*$y=$[$x*$y]\t"
  43.                 let x++
  44.         done
  45. echo
  46. echo
  47. let y++
  48. done
  50. 或者
  51. #!/bin/bash
  52. for i in `seq 9`
  53. do
  54.     for j in `seq $i`
  55.     do
  56.         echo -ne  "$j*$i=$[$i*$j]\t"
  57.     done
  58. echo
  59. echo
  60. done
  61. 或者
  62. #!/bin/bash
  63. y=1
  64. until [ $y -gt 9 ]
  65. do
  66.         x=1
  67.         until [ $x -gt $y ]
  68.         do
  69.                 echo -ne "$x*$y=$[ $x*$y ]\t"
  70.                 let x++
  71.         done
  72. echo
  73. echo
  74. let y++
  75. done

三、阶段性补充总结

1、变量定义

2. 流程控制语句

3. 循环语句

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

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

举例说明：

  1. 以下脚本都能够实现用户自定义输入数字，然后脚本计算和：
  2. [root@MissHou shell04]# cat shift.sh 
  3. #!/bin/bash
  4. sum=0
  5. while [ $# -ne 0 ]
  6. do
  7. let sum=$sum+$1
  8. shift
  9. done
  10. echo sum=$sum
  13. [root@MissHou shell04]# cat for3.sh 
  14. #!/bin/bash
  15. sum=0
  16. for i
  17. do
  18. let sum=$sum+$i
  19. done
  20. echo sum=$sum

4. 补充扩展expect

expect 自动应答 tcl语言

需求1：A远程登录到server上什么都不做

  1. #!/usr/bin/expect
  2. # 开启一个程序
  3. spawn ssh root@10.1.1.1
  4. # 捕获相关内容
  5. expect {
  6.         "(yes/no)?" { send "yes\r";exp_continue }
  7.         "password:" { send "123456\r" }
  8. }
  9. interact   //交互
  11. 脚本执行方式：
  12. # ./expect1.sh
  13. # /shell04/expect1.sh
  14. # expect -f expect1.sh
  16. 1）定义变量
  17. #!/usr/bin/expect
  18. set ip 10.1.1.2
  19. set pass 123456
  20. set timeout 5
  21. spawn ssh root@$ip
  22. expect {
  23.     "yes/no" { send "yes\r";exp_continue }
  24.     "password:" { send "$pass\r" }
  25. }
  26. interact
  29. 2）使用位置参数
  30. #!/usr/bin/expect
  31. set ip [ lindex $argv 0 ]
  32. set pass [ lindex $argv 1 ]
  33. set timeout 5
  34. spawn ssh root@$ip
  35. expect {
  36.     "yes/no" { send "yes\r";exp_continue }
  37.     "password:" { send "$pass\r" }
  38. }
  39. interact

需求2：A远程登录到server上操作

  1. #!/usr/bin/expect
  2. set ip 10.1.1.1
  3. set pass 123456
  4. set timeout 5
  5. spawn ssh root@$ip
  6. expect {
  7.     "yes/no" { send "yes\r";exp_continue }
  8.     "password:" { send "$pass\r" }
  9. }
  11. expect "#"
  12. send "rm -rf /tmp/*\r"
  13. send "touch /tmp/file{1..3}\r"
  14. send "date\r"
  15. send "exit\r"
  16. expect eof

需求3：shell脚本和expect结合使用，在多台服务器上创建1个用户

  1. [root@server shell04]# cat ip.txt 
  2. 10.1.1.1 123456
  3. 10.1.1.2 123456
  6. 1. 循环
  7. 2. 登录远程主机——>ssh——>从ip.txt文件里获取IP和密码分别赋值给两个变量
  8. 3. 使用expect程序来解决交互问题
  10. #!/bin/bash
  11. # 循环在指定的服务器上创建用户和文件
  12. while read ip pass
  13. do
  14.     /usr/bin/expect <<-END &>/dev/null
  15.     spawn ssh root@$ip
  16.     expect {
  17.     "yes/no" { send "yes\r";exp_continue }
  18.     "password:" { send "$pass\r" }
  19.     }
  20.     expect "#" { send "useradd yy1;rm -rf /tmp/*;exit\r" }
  21.     expect eof
  22.     END
  23. done < ip.txt
  27. #!/bin/bash
  28. cat ip.txt|while read ip pass
  29. do
  30.         {
  32.         /usr/bin/expect <<-HOU
  33.         spawn ssh root@$ip
  34.         expect {
  35.                 "yes/no" { send "yes\r";exp_continue }
  36.                 "password:" { send "$pass\r" }
  37.         }
  38.         expect "#"
  39.         send "hostname\r"
  40.         send "exit\r"
  41.         expect eof
  42.         HOU
  44.         }&
  45. done
  46. wait
  47. echo "user is ok...."
  50. 或者
  51. #!/bin/bash
  52. while read ip pass
  53. do
  54.         {
  56.         /usr/bin/expect <<-HOU
  57.         spawn ssh root@$ip
  58.         expect {
  59.                 "yes/no" { send "yes\r";exp_continue }
  60.                 "password:" { send "$pass\r" }
  61.         }
  62.         expect "#"
  63.         send "hostname\r"
  64.         send "exit\r"
  65.         expect eof
  66.         HOU
  68.         }&
  69. done<ip.txt
  70. wait
  71. echo "user is ok...."

四、综合案例

1. 实战案例1

㈠ 具体需求

写一个脚本，将跳板机上yunwei用户的公钥推送到局域网内可以ping通的所有机器上

说明：主机和密码文件已经提供

10.1.1.1:123456

10.1.1.2:123456

㈡ 案例分析

  • 关闭防火墙和selinux
  • 判断ssh服务是否开启（默认ok）
  • 循环判断给定密码文件里的哪些IP是可以ping通
  • 判断IP是否可以ping通——>$?—>流程控制语句
  • 密码文件里获取主机的IP和密码保存变量
  • 判断公钥是否存在—>不存在创建它
  • ssh-copy-id 将跳板机上的yunwei用户的公钥推送到远程主机—>expect解决交互
  • 将ping通的主机IP单独保存到一个文件
  • 测试验证

㈢ 落地实现

① 代码拆分

  1. 1.判断yunwei用户的公钥是否存在
  2. [ ! -f /hoem/yunwei/.ssh/id_rsa ] && ssh-keygen -P '' -f ./id_rsa
  4. 2.获取IP并且判断是否可以ping通
  5. 1)主机密码文件ip.txt
  6.     10.1.1.1:123456
  7.    10.1.1.2:123456
  8. 2) 循环判断主机是否ping通
  9.     tr ':' ' ' < ip.txt|while read ip pass
  10.     do
  11.         ping -c1 $ip &>/dev/null
  12.       if [ $? -eq 0 ];then
  13.           推送公钥
  14.       fi
  15.     done
  19. 3.非交互式推送公钥
  20. /usr/bin/expect <<-END &>/dev/null
  21.         spawn ssh-copy-id root@$ip
  22.         expect {
  23.                 "yes/no" { send "yes\r";exp_continue }
  24.                 "password:" { send "$pass\r" }
  25.         }
  26.         expect eof
  27.     END

② 最终实现

  1. 环境准备
  1. jumper-server    有yunwei用户
  3. yunwei用户sudo授权：
  4. visudo
  5. ## Allow root to run any commands anywhere
  6. root    ALL=(ALL)       ALL
  7. yunwei  ALL=(root)      NOPASSWD:ALL,!/sbin/shutdown,!/sbin/init,!/bin/rm -rf /
  9. 解释说明：
  10. 1）第一个字段yunwei指定的是用户：可以是用户名，也可以是别名。每个用户设置一行，多个用户设置多行，也可以将多个用户设置成一个别名后再进行设置。
  11. 2）第二个字段ALL指定的是用户所在的主机：可以是ip,也可以是主机名，表示该sudo设置只在该主机上生效，ALL表示在所有主机上都生效！限制的一般都是本机，也就是限制使用这个文件的主机;一般都指定为"ALL"表示所有的主机，不管文件拷到那里都可以用。比如：10.1.1.1=...则表示只在当前主机生效。
  12. 3）第三个字段（root）括号里指定的也是用户：指定以什么用户身份执行sudo，即使用sudo后可以享有所有root账号下的权限。如果要排除个别用户，可以在括号内设置，比如ALL=(ALL,!oracle,!pos)。
  13. 4）第四个字段ALL指定的是执行的命令：即使用sudo后可以执行所有的命令。除了关机和删除根内容以外；也可以设置别名。NOPASSWD: ALL表示使用sudo的不需要输入密码。
  14. 5）也可以授权给一个用户组
  15.     %admin ALL=(ALL) ALL    表示admin组里的所有成员可以在任何主机上以任何用户身份执行任何命令
  1. 脚本实现
  1. #!/bin/bash
  2. #判断公钥是否存在
  3. [ ! -f /home/yunwei/.ssh/id_rsa ] && ssh-keygen -P '' -f ~/.ssh/id_rsa
  5. #循环判断主机是否ping通，如果ping通推送公钥
  6. tr ':' ' ' < /shell04/ip.txt|while read ip pass
  7. do
  8. {
  9.         ping -c1 $ip &>/dev/null
  10.         if [ $? -eq 0 ];then
  11.         echo $ip >> ~/ip_up.txt
  12.         /usr/bin/expect <<-END &>/dev/null
  13.          spawn ssh-copy-id root@$ip
  14.          expect {
  15.                 "yes/no" { send "yes\r";exp_continue }
  16.                 "password:" { send "$pass\r" }
  17.                 }
  18.         expect eof
  19.         END
  20.         fi
  21. }&
  22. done
  23. wait
  24. echo "公钥已经推送完毕，正在测试...."
  25. #测试验证
  26. remote_ip=`tail -1 ~/ip_up.txt`
  27. ssh root@$remote_ip hostname &>/dev/null
  28. test $? -eq 0 && echo "公钥成功推送完毕"

2. 实战案例2

写一个脚本，统计web服务的不同连接状态个数

  1. #!/bin/bash
  2. #count_http_80_state
  3. #统计每个状态的个数
  4. declare -A array1
  5. states=`ss -ant|grep 80|cut -d' ' -f1`
  6. for i in $states
  7. do
  8.         let array1[$i]++
  9. done
  10. #通过遍历数组里的索引和元素打印出来
  11. for j in ${!array1[@]}
  12. do
  13.         echo $j:${array1[$j]}
  14. done

五、课后实战

1、将/etc/passwd里的用户名分类，分为管理员用户，系统用户，普通用户。
2、写一个倒计时脚本，要求显示离2019年1月1日（元旦）的凌晨0点，还有多少天，多少时，多少分，多少秒。
3、写一个脚本把一个目录内的所有空文件都删除，最后输出删除的文件的个数。