头歌--第6关：循环语句嵌套(shell脚本入门——流程控制)

目录

任务描述

代码

---

任务描述

本关任务：掌握 shell 语句中的循环嵌套的方法和使用场景，输出系统中的可执行文件。

相关知识

循环语句可以在循环内使用任意类型的命令，包括其他循环命令。这种循环叫作嵌套循环（nested loop）。注意，在使用嵌套循环时，你是在迭代中使用迭代，与命令运行的次数是乘积关系。不注意这点的话，有可能会在脚本中造成问题。

for-for循环嵌套

这里有个在 for 循环中嵌套 for 循环的简单例子。

【实例1】

1. #!/bin/bash
2. # nesting for loops
3. for (( a = 1; a <= 3; a++ ))
4. do
5. echo "Starting loop $a:"
6. for (( b = 1; b <= 3; b++ ))
7. do
8. echo " Inside loop: $b"
9. done
10. done

执行脚本输出结果为：

1. Starting loop 1:
2. Inside loop: 1
3. Inside loop: 2
4. Inside loop: 3
5. Starting loop 2:
6. Inside loop: 1
7. Inside loop: 2
8. Inside loop: 3
9. Starting loop 3:
10. Inside loop: 1
11. Inside loop: 2
12. Inside loop: 3

这个被嵌套的循环（也称为内部循环，inner loop）会在外部循环的每次迭代中遍历一次它所有的值。注意，两个循环的 do 和 done 命令没有任何差别。bash shell 知道当第一个 done 命令执行时，是指内部循环而非外部循环。

for-while循环嵌套

在混用循环命令时也一样，比如在 while 循环内部放置一个 for 循环。

【实例2】

1. #!/bin/bash
2. # placing a for loop inside a while loop
3. var1=5
4. while [ $var1 -ge 0 ]
5. do
6. echo "Outer loop: $var1"
7. for (( var2 = 1; $var2 < 3; var2++ ))
8. do
9. var3=$[ $var1 * $var2 ]
10. echo " Inner loop: $var1 * $var2 = $var3"
11. done
12. var1=$[ $var1 - 1 ]
13. done

执行脚本输出结果为：

1. Outer loop: 5
2. Inner loop: 5 * 1 = 5
3. Inner loop: 5 * 2 = 10
4. Outer loop: 4
5. Inner loop: 4 * 1 = 4
6. Inner loop: 4 * 2 = 8
7. Outer loop: 3
8. Inner loop: 3 * 1 = 3
9. Inner loop: 3 * 2 = 6
10. Outer loop: 2
11. Inner loop: 2 * 1 = 2
12. Inner loop: 2 * 2 = 4
13. Outer loop: 1
14. Inner loop: 1 * 1 = 1
15. Inner loop: 1 * 2 = 2
16. Outer loop: 0
17. Inner loop: 0 * 1 = 0
18. Inner loop: 0 * 2 = 0

until-while循环嵌套

如果真的想挑战脑力，可以混用 until 和 while 循环。 【实列3】

1. #!/bin/bash
2. # using until and while loops
3. var1=3
4. until [ $var1 -eq 0 ]
5. do
6. echo "Outer loop: $var1"
7. var2=1
8. while [ $var2 -lt 5 ]
9. do
10. var3=$(echo "scale=4; $var1 / $var2" | bc)
11. echo " Inner loop: $var1 / $var2 = $var3"
12. var2=$[ $var2 + 1 ]
13. done
14. var1=$[ $var1 - 1 ]
15. done

执行脚本输出结果为：

1. Outer loop: 3
2. Inner loop: 3 / 1 = 3.0000
3. Inner loop: 3 / 2 = 1.5000
4. Inner loop: 3 / 3 = 1.0000
5. Inner loop: 3 / 4 = .7500
6. Outer loop: 2
7. Inner loop: 2 / 1 = 2.0000
8. Inner loop: 2 / 2 = 1.0000
9. Inner loop: 2 / 3 = .6666
10. Inner loop: 2 / 4 = .5000
11. Outer loop: 1
12. Inner loop: 1 / 1 = 1.0000
13. Inner loop: 1 / 2 = .5000
14. Inner loop: 1 / 3 = .3333
15. Inner loop: 1 / 4 = .2500

外部的 until 循环以值 3 开始，并继续执行到值等于 0。内部 while 循环以值 1 开始并一直执行，只要值小于 5。每个循环都必须改变在测试条件中用到的值，否则循环就会无止尽进行下去。

控制循环

你可能会想，一旦启动了循环，就必须苦等到循环完成所有的迭代，并不是这样的。有两个命令能帮我们控制循环内部的情况： break 命令和 continue 命令，每个命令在如何控制循环的执行方面有不同的用法。下面将介绍如何使用这些命令来控制循环。

• break 命令：跳出单个循环在 shell 执行 break 命令时，它会尝试跳出当前正在执行的循环，请见【实例4】。

【实列4】

1. #!/bin/bash
2. # breaking out of a for loop
3. for var1 in 1 2 3 4 5 6 7 8 9 10
4. do
5. if [ $var1 -eq 5 ]；then
6. break
7. fi
8. echo "Iteration number: $var1"
9. done
10. echo "The for loop is completed"

执行脚本输出结果为：

1. Iteration number: 1
2. Iteration number: 2
3. Iteration number: 3
4. Iteration number: 4
5. The for loop is completed

for 循环通常都会遍历列表中指定的所有值。但当满足 if-then 的条件时，shell 会执行 break 命令，停止 for 循环。

• continue 命令：continue 命令可以提前中止某次循环中的命令，但并不会完全终止整个循环。可以在循环内部设置 shell 不执行命令的条件。这里有个在 for 循环中使用 continue 命令的简单例子。

【实例5】

1. #!/bin/bash
2. # using the continue command
3. for (( var1 = 1; var1 < 15; var1++ ))
4. do
5. if [ $var1 -gt 5 ] && [ $var1 -lt 10 ]
6. then
7. continue
8. fi
9. echo "Iteration number: $var1"
10. done

执行脚本输出结果为：

1. Iteration number: 1
2. Iteration number: 2
3. Iteration number: 3
4. Iteration number: 4
5. Iteration number: 5
6. Iteration number: 10
7. Iteration number: 11
8. Iteration number: 12
9. Iteration number: 13
10. Iteration number: 14

执行说明：

• 当 if-then 语句的条件被满足时（值大于 5 且小于 10），shell 会执行 continue 命令，跳过此次循环中剩余的命令，但整个循环还会继续。当 if-then 的条件不再被满足时，一切又回到正轨；
• 也可以在 while 和 until 循环中使用 continue 命令，但要特别小心。记住，当 shell 执行 continue 命令时，它会跳过剩余的命令。如果你在其中某个条件里对测试条件变量进行增值，问题就会出现。

编程要求

背景：当你从命令行中运行一个程序的时候，Linux 系统会搜索一系列目录来查找对应的文件。

在右侧编辑器 Begin-End 区间补充代码，输出变量 dir 的可执行文件有哪些。

编程思路：

• 首先是创建一个 for 循环，对环境变量 dir 中的目录进行迭代。处理的时候别忘了设置 IFS 分隔符。（IFS=：，即指定 shell 的分割符为 ：）
  1. IFS=:
  2. for folder in $dir
  3. do
• 现在你已经将各个目录存放在了变量 $folder 中，可以使用另一个 for 循环来迭代特定目录中的所有文件。
  1. for file in $folder/*
  2. do
• 最后一步是检查各个文件是否具有可执行权限，你可以使用 if-then 测试功能来实现。
  1. if [ -x $file ]
  2. then
  3. echo " $file"
  4. fi

测试说明

补全脚本之后，点击评测按钮，平台会对你编写的代码进行测试，当你的结果与预期输出一致时，即为通过。

代码

#!/bin/bash 
# finding files in the dir 
dir=/usr/games
##1.修改当前shell的分割符为 :
IFS=:

##########  Begin  ##########

##2.第一个for循环,遍历$dir ,根据IFS=:指定的":"分割符隔开遍历。
for folder in $dir
do

##3.第二个for循环,遍历取值的变量$folder下的文件。
    for w in $folder/*
    do

##4.if语句判断时候具有执行权限。
        if [ -x $w ]
        then
            echo "$w"
        fi
    done
done
######### End   #########