嵌套循环与作用域

循环的作用域

理解变量作用域对掌握循环非常重要，它决定了变量在哪里可以被访问和使用。

for 循环中的变量作用域

for 循环有两个关键的作用域范围：

作用域1：初始值声明的作用域

关键理解：

• 在 for 循环的初始值部分用 let 声明的变量，其作用域仅限于循环内部
• 循环结束后，这个变量会被自动清理
• 这是为了避免变量污染，让代码更干净

作用域2：循环体的作用域

对比：使用外部定义的变量

while 循环的作用域对比

while 循环的作用域相对简单，因为它没有初始值声明部分：

关键理解：

• while 循环没有初始值声明部分，所以变量通常在外部定义
• 外部变量：循环内外都能访问和使用
• 内部变量：只在循环内部有效，循环结束后被清理

最佳实践

1. 需要保存循环结果时：在循环外部定义变量

   加载代码编辑器...

2. 无需外部访问时使用内部变量： 如果计算结果只在循环内部使用，就应该在循环内部定义变量：

   加载代码编辑器...

嵌套循环 - 循环中的循环

嵌套循环就像是在循环里面再放一个循环，就像俄罗斯套娃一样，一层套一层。

🔍 嵌套循环的工作原理

第一步：理解单层循环

第二步：嵌套循环的结构

嵌套循环 = 外层循环 + 内层循环

第三步：执行过程详解

1. 外层第1次 (i=1)：
   • 内层第1次 (j=1)：输出 i=1, j=1
   • 内层第2次 (j=2)：输出 i=1, j=2
2. 外层第2次 (i=2)：
   • 内层第1次 (j=1)：输出 i=2, j=1
   • 内层第2次 (j=2)：输出 i=2, j=2
3. 外层第3次 (i=3)：
   • 内层第1次 (j=1)：输出 i=3, j=1
   • 内层第2次 (j=2)：输出 i=3, j=2

第四步：关键规律总结

🎯 核心规律：

1. 外层循环1次 → 内层循环完整执行n次
2. 外层循环m次 → 总共执行 m × n 次
3. 内层循环每次都从头开始

强化理解的例子

例子：九九乘法表

📋 九九乘法表执行过程详解

这个九九乘法表完美地展示了嵌套循环中内层循环受外层循环控制的机制：

第1轮：i = 1（第1行）

• 内层循环条件：j <= 1
• 内层循环：j 从 1 到 1（只执行1次）
• 内层循环执行过程：
  • j=1: line = "" + "1×1=1 " → 输出 "1×1=1 "

第2轮：i = 2（第2行）

• 内层循环条件：j <= 2
• 内层循环：j 从 1 到 2（执行2次）
• 内层循环执行过程：
  • j=1: line = "" + "1×2=2 " → "1×2=2 "
  • j=2: line = "1×2=2 " + "2×2=4 " → "1×2=2 2×2=4 "

第3轮：i = 3（第3行）

• 内层循环条件：j <= 3
• 内层循环：j 从 1 到 3（执行3次）
• 内层循环执行过程：
  • j=1: line = "" + "1×3=3 " → "1×3=3 "
  • j=2: line = "1×3=3 " + "2×3=6 " → "1×3=3 2×3=6 "
  • j=3: line = "1×3=3 2×3=6 " + "3×3=9 " → "1×3=3 2×3=6 3×3=9 "

第4轮：i = 4（第4行）

• 内层循环条件：j <= 4
• 内层循环：j 从 1 到 4（执行4次）
• 输出：1×4=4 2×4=8 3×4=12 4×4=16

第5轮：i = 5（第5行）

• 内层循环条件：j <= 5
• 内层循环：j 从 1 到 5（执行5次）
• 输出：1×5=5 2×5=10 3×5=15 4×5=20 5×5=25

第6轮：i = 6（第6行）

• 内层循环条件：j <= 6
• 内层循环：j 从 1 到 6（执行6次）
• 输出：1×6=6 2×6=12 3×6=18 4×6=24 5×6=30 6×6=36

第7轮：i = 7（第7行）

• 内层循环条件：j <= 7
• 内层循环：j 从 1 到 7（执行7次）
• 输出：1×7=7 2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49

第8轮：i = 8（第8行）

• 内层循环条件：j <= 8
• 内层循环：j 从 1 到 8（执行8次）
• 输出：1×8=8 2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64

第9轮：i = 9（第9行）

• 内层循环条件：j <= 9
• 内层循环：j 从 1 到 9（执行9次）
• 输出：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

🎯 核心理解：内层循环完全受外层循环控制

关键机制： j <= i 这个条件是整个九九乘法表的核心

1. 外层的 i 值决定了内层循环要执行多少次

   • 当 i = 3 时，内层循环条件变成 j <= 3，执行 3 次
   • 当 i = 7 时，内层循环条件变成 j <= 7，执行 7 次

2. 每轮内层循环都会重新开始

   • 外层循环 i = 2 结束后，下一轮 i = 3 时
   • 内层循环的 j 重新从 1 开始，一直到 3

嵌套循环变量的作用域规则

🔥 关键理解：外层变量向内可见，内层变量向外不可见

作用域规则详解：

• 外层变量（i, line）：在内层循环中可以访问和使用
• 内层变量（j）：只能在内层循环中使用，外层循环无法访问
• 变量生命周期：每次循环开始时创建，结束时自动清理

作用域规则总结： 经过这么多反复的介绍，你应该已经理解变量作用域的规则了：

• 外层向内可见：内层代码块可以访问外层定义的变量
• 内层向外不可见：外层代码块无法访问内层定义的变量
• 通过 {} 创建作用域：我们已经学过的 for/while 循环语句、if 语句都会创建作用域，实际上，单独的 {} 也能创建独立的作用域

📝 单独 {} 创建作用域的例子：

💡 提示：一般情况下我们不会单独使用 {} 来创建作用域，通常我们会使用 if 语句、for/while 循环等语句来创建代码块，这个例子主要是为了帮助你理解作用域的本质原理。

总结

今天我们学习了循环的高级技巧：

📚 核心知识

1. 变量作用域：通过 {} 创建作用域，外层变量向内可见，内层变量向外不可见
2. 嵌套循环：循环中的循环，外层循环控制内层循环的执行次数

🎯 实用技巧

• 理解作用域规则，合理定义变量位置
• 掌握嵌套循环的设计模式

🚀 编程思维

• 结构思维：理解复杂的嵌套结构
• 层级思维：理解外层循环如何控制内层循环的执行

掌握了这些高级技巧，你就能够：

• 处理复杂的嵌套逻辑
• 理解变量作用域的规则
• 写出更可靠的程序