While 循环：条件驱动的重复执行

站在电梯门前，你会一直等待，直到电梯到达。你不知道需要等多久——可能 10 秒，也可能 2 分钟——但你知道等待的条件："只要电梯还没来，就继续等"。这种"只要条件满足就持续执行"的逻辑，在编程中就是 while 循环的精髓。

While 循环的基本原理

while 循环是最简单的循环结构之一。它只有一个条件：只要条件为真，就反复执行循环体：

while (condition) {
  // 循环体
}

每次循环开始前，程序都会检查条件。如果条件为真（truthy），执行循环体；如果为假（falsy），跳出循环继续执行后面的代码。

让我们从一个简单的倒计时开始：

let count = 5;

while (count > 0) {
  console.log(count);
  count--;
}

console.log("Blast off!");

// 输出：
// 5
// 4
// 3
// 2
// 1
// Blast off!

这个循环的执行流程：

1. 检查 count > 0（5 > 0 为真）→ 执行循环体
2. 输出 5，count 变为 4
3. 检查 count > 0（4 > 0 为真）→ 继续执行
4. 输出 4，count 变为 3
5. ...重复直到 count 为 0
6. 检查 count > 0（0 > 0 为假）→ 跳出循环

与 for 循环不同，while 循环没有内置的初始化和更新部分。这使它更灵活，但也意味着你需要自己管理循环变量。如果忘记更新 count，循环会永远执行下去。

While vs For：何时选择

for 循环和 while 循环能完成同样的任务，但适用场景不同：

// 用 for 循环
for (let i = 0; i < 5; i++) {
  console.log(i);
}

// 等价的 while 循环
let i = 0;
while (i < 5) {
  console.log(i);
  i++;
}

使用 for 循环的场景：

• 循环次数已知或明确
• 需要计数器变量
• 遍历数组、列表等有明确范围的数据

使用 while 循环的场景：

• 循环次数未知，依赖于运行时条件
• 条件比计数更自然地表达逻辑
• 需要在循环前和循环中都能修改条件

比如，读取文件直到遇到特定标记：

let line;
let fileReader = getFileReader(); // 假设的文件读取器

while ((line = fileReader.readLine())) {
  if (line === "END") {
    break;
  }
  console.log(line);
}

或者等待用户输入正确的密码：

let password;
let correctPassword = "secret123";

while (password !== correctPassword) {
  password = prompt("Enter password:");

  if (password !== correctPassword) {
    console.log("Incorrect password. Try again.");
  }
}

console.log("Access granted!");

这些场景中，循环的次数事先不确定，while 比 for 更自然。

无限循环：危险与用途

如果 while 的条件永远为真，循环会无限执行下去。这通常是 bug，但有时也是有意为之。

意外的无限循环

let i = 0;

// ❌ 忘记更新 i
while (i < 5) {
  console.log(i); // 会永远输出 0
}

// ❌ 更新方向错误
let j = 0;
while (j < 5) {
  console.log(j);
  j--; // j 会变成负数，但仍然小于 5
}

// ❌ 条件永远为真
while (true) {
  console.log("This will run forever!");
  // 没有 break 语句
}

这些错误会导致浏览器或程序冻结。一定要确保循环条件最终会变为假，或者有 break 语句作为退出点。

有意的无限循环

在某些场景中，无限循环是合理的，比如游戏主循环或服务器监听：

// 游戏主循环（伪代码）
while (true) {
  handleInput(); // 处理用户输入
  updateGame(); // 更新游戏状态
  renderFrame(); // 渲染画面

  if (gameOver) {
    break; // 游戏结束时退出
  }
}

// 服务器监听（伪代码）
while (true) {
  let request = waitForRequest(); // 阻塞等待请求
  handleRequest(request);
}

在这些情况下，循环会一直运行，直到程序主动退出或通过 break 跳出。

Do-While 循环：至少执行一次

do-while 循环是 while 的变体，区别在于条件检查的时机。while 在循环开始前检查条件，do-while 在循环结束后检查：

do {
  // 循环体
} while (condition);

这保证了循环体至少执行一次，即使条件一开始就为假：

let count = 0;

// while 循环：不会执行
while (count > 0) {
  console.log("This won't print");
  count--;
}

// do-while 循环：会执行一次
do {
  console.log("This will print once"); // 输出一次
  count--;
} while (count > 0);

Do-While 的典型应用

最常见的用途是输入验证，确保至少提示用户一次：

let age;

do {
  age = prompt("Please enter your age:");
} while (age === null || age === "" || isNaN(age) || age < 0);

console.log(`Your age is ${age}`);

这个循环会持续提示用户输入，直到得到有效的年龄。用户必须至少看到一次提示，所以 do-while 比 while 更合适。

另一个例子是菜单驱动的程序：

let choice;

do {
  console.log("\n=== Menu ===");
  console.log("1. View profile");
  console.log("2. Edit settings");
  console.log("3. Log out");

  choice = prompt("Enter your choice (1-3):");

  switch (choice) {
    case "1":
      console.log("Viewing profile...");
      break;
    case "2":
      console.log("Editing settings...");
      break;
    case "3":
      console.log("Logging out...");
      break;
    default:
      console.log("Invalid choice. Please try again.");
  }
} while (choice !== "3");

console.log("Goodbye!");

用户会看到菜单，做出选择，然后菜单再次显示，直到选择退出。

实际应用场景

1. 处理用户输入

function getUserConfirmation() {
  let answer;

  while (answer !== "yes" && answer !== "no") {
    answer = prompt("Do you want to continue? (yes/no)").toLowerCase();

    if (answer !== "yes" && answer !== "no") {
      console.log("Please answer 'yes' or 'no'");
    }
  }

  return answer === "yes";
}

if (getUserConfirmation()) {
  console.log("Proceeding...");
} else {
  console.log("Cancelled.");
}

2. 数据处理直到满足条件

let numbers = [5, 12, 8, 130, 44, 3, 9];
let sum = 0;
let index = 0;

// 累加直到总和超过 100
while (sum < 100 && index < numbers.length) {
  sum += numbers[index];
  console.log(`Added ${numbers[index]}, total: ${sum}`);
  index++;
}

console.log(`Stopped at index ${index}, sum: ${sum}`);
// 输出：
// Added 5, total: 5
// Added 12, total: 17
// Added 8, total: 25
// Added 130, total: 155
// Stopped at index 4, sum: 155

3. 队列处理

let taskQueue = ["task1", "task2", "task3", "task4"];

while (taskQueue.length > 0) {
  let currentTask = taskQueue.shift(); // 取出第一个任务
  console.log(`Processing: ${currentTask}`);

  // 模拟任务处理
  if (currentTask === "task2") {
    console.log("Task2 generated a new task!");
    taskQueue.push("task5"); // 动态添加新任务
  }
}

console.log("All tasks completed!");
// 输出：
// Processing: task1
// Processing: task2
// Task2 generated a new task!
// Processing: task3
// Processing: task4
// Processing: task5
// All tasks completed!

4. 随机事件模拟

function simulateCoinFlips() {
  let flips = 0;
  let heads = 0;

  // 抛硬币直到连续出现 3 次正面
  while (heads < 3) {
    flips++;
    let isHeads = Math.random() < 0.5;

    if (isHeads) {
      heads++;
      console.log(`Flip ${flips}: Heads (streak: ${heads})`);
    } else {
      heads = 0;
      console.log(`Flip ${flips}: Tails (streak reset)`);
    }
  }

  console.log(`It took ${flips} flips to get 3 heads in a row!`);
}

simulateCoinFlips();

5. 倒计时和定时器

function countdown(seconds) {
  let remaining = seconds;

  let timer = setInterval(() => {
    console.log(remaining);
    remaining--;

    if (remaining < 0) {
      clearInterval(timer);
      console.log("Time's up!");
    }
  }, 1000);
}

countdown(5);

虽然这个例子使用了 setInterval，但逻辑上它是一个基于条件的重复执行，类似 while 循环的思想。

循环控制技巧

1. 多条件组合

let attempts = 0;
let maxAttempts = 3;
let success = false;

while (attempts < maxAttempts && !success) {
  console.log(`Attempt ${attempts + 1}...`);

  // 模拟操作
  success = Math.random() > 0.5;
  attempts++;

  if (success) {
    console.log("Success!");
  } else if (attempts < maxAttempts) {
    console.log("Failed, retrying...");
  }
}

if (!success) {
  console.log("All attempts failed.");
}

2. 使用标志变量

let numbers = [10, 20, 30, 40, 50];
let found = false;
let index = 0;
let target = 30;

while (index < numbers.length && !found) {
  if (numbers[index] === target) {
    found = true;
    console.log(`Found ${target} at index ${index}`);
  }
  index++;
}

if (!found) {
  console.log(`${target} not found in array`);
}

3. 提前退出

let data = [5, 10, 15, -1, 20, 25];
let i = 0;

while (i < data.length) {
  let value = data[i];

  if (value < 0) {
    console.log("Encountered negative value, stopping.");
    break; // 提前退出
  }

  console.log(`Processing: ${value}`);
  i++;
}

常见陷阱与最佳实践

1. 确保条件最终会变为假

// ❌ 条件永远不会变
let count = 10;
while (count > 0) {
  console.log("This will freeze the browser!");
  // 忘记 count--
}

// ✅ 确保有更新
let count = 10;
while (count > 0) {
  console.log(count);
  count--; // 条件最终会变为假
}

2. 避免复杂的条件

// ❌ 难以理解的复杂条件
while (
  (status === "pending" || status === "processing") &&
  retries < maxRetries &&
  !errorOccurred &&
  connectionActive
) {
  // ...
}

// ✅ 使用有意义的标志变量
let shouldContinue =
  (status === "pending" || status === "processing") &&
  retries < maxRetries &&
  !errorOccurred &&
  connectionActive;

while (shouldContinue) {
  // ... 处理逻辑

  // 更新条件
  shouldContinue =
    (status === "pending" || status === "processing") &&
    retries < maxRetries &&
    !errorOccurred &&
    connectionActive;
}

3. While 循环中的作用域

// ❌ 在循环外无法访问
while (count > 0) {
  let message = `Count: ${count}`; // 块级作用域
  console.log(message);
  count--;
}
// console.log(message); // 错误：message 未定义

// ✅ 在循环外声明
let message;
while (count > 0) {
  message = `Count: ${count}`;
  console.log(message);
  count--;
}
console.log(`Last message: ${message}`); // 可以访问

4. 异步操作中的 While

在异步环境中使用 while 要特别小心：

// ❌ 同步的 while 循环会阻塞
let data = null;

fetchData(); // 异步函数

while (data === null) {
  // 这会阻塞，data 永远不会被赋值（因为异步操作没机会完成）
}

// ✅ 使用 async/await
async function waitForData() {
  let data = null;
  let attempts = 0;
  let maxAttempts = 10;

  while (data === null && attempts < maxAttempts) {
    data = await fetchData();
    if (data === null) {
      await sleep(1000); // 等待 1 秒后重试
      attempts++;
    }
  }

  return data;
}

5. 性能考虑

虽然 while 循环很灵活，但在处理大数据集时要注意性能：

// ❌ 每次都访问属性
let list = getLargeList();
let i = 0;
while (i < list.length) {
  // 每次都访问 length
  process(list[i]);
  i++;
}

// ✅ 缓存长度
let list = getLargeList();
let i = 0;
let len = list.length;
while (i < len) {
  process(list[i]);
  i++;
}

不过，对于大多数情况，这种优化的影响微乎其微。优先考虑代码的可读性和正确性。

While vs Do-While 选择指南

场景	推荐
循环可能一次都不执行	while
至少需要执行一次	do-while
输入验证（必须至少提示一次）	do-while
菜单驱动程序	do-while
条件在执行前需要检查	while
读取数据直到结束	while

总结

while 和 do-while 循环是条件驱动的循环结构，特别适合循环次数不确定的场景。它们比 for 循环更灵活，但也需要更小心地管理循环条件和变量更新。

关键要点：

• while 在循环开始前检查条件，可能一次都不执行
• do-while 在循环结束后检查条件，至少执行一次
• 确保循环条件最终会变为假，避免无限循环
• 当循环次数未知，依赖运行时条件时，优先使用 while
• 当需要至少执行一次时，使用 do-while
• 在异步环境中使用 while 要特别小心
• 清晰的循环条件比复杂的条件更易维护

选择合适的循环类型能让代码更清晰地表达意图。for 循环适合"做 N 次"，while 循环适合"直到条件满足"。掌握它们的区别和使用场景，是编写高质量代码的重要一步。

---