循环控制 #

for (let i = 0; i < 10; i++) {
  if (i === 5) {
    break;
  }
  console.log(i);
}
// 输出：0 1 2 3 4

let count = 0;

while (true) {
  console.log(count);
  count++;
  
  if (count >= 5) {
    break;
  }
}
// 输出：0 1 2 3 4

const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
let found: number | undefined;

for (const num of numbers) {
  if (num > 5) {
    found = num;
    break;
  }
}

console.log(found); // 6

function hasInvalidNumber(numbers: number[]): boolean {
  for (const num of numbers) {
    if (num < 0 || num > 100) {
      return true;
    }
  }
  return false;
}

console.log(hasInvalidNumber([1, 2, 3])); // false
console.log(hasInvalidNumber([1, -1, 3])); // true

for (let i = 0; i < 5; i++) {
  if (i === 2) {
    continue;
  }
  console.log(i);
}
// 输出：0 1 3 4

const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

console.log("奇数：");
for (const num of numbers) {
  if (num % 2 === 0) {
    continue;
  }
  console.log(num);
}
// 输出：1 3 5 7 9

const data = [
  { id: 1, name: "Alice" },
  { id: 2, name: "" },
  { id: 3, name: "Charlie" },
  null,
  { id: 4, name: "Diana" }
];

for (const item of data) {
  if (!item || !item.name) {
    continue;
  }
  console.log(`${item.id}: ${item.name}`);
}
// 输出：1: Alice 3: Charlie 4: Diana

const lines = [
  "# 注释行",
  "",
  "hello world",
  "  ",
  "foo bar",
  "# 另一个注释"
];

for (const line of lines) {
  const trimmed = line.trim();
  
  if (!trimmed || trimmed.startsWith("#")) {
    continue;
  }
  
  console.log(trimmed);
}
// 输出：hello world foo bar

labelName: {
  // 代码块
}

labelName: for (...) {
  // 循环
}

outer: for (let i = 0; i < 3; i++) {
  for (let j = 0; j < 3; j++) {
    if (i === 1 && j === 1) {
      break outer;
    }
    console.log(`i: ${i}, j: ${j}`);
  }
}
// 输出：i: 0, j: 0  i: 0, j: 1  i: 0, j: 2  i: 1, j: 0

outer: for (let i = 0; i < 3; i++) {
  for (let j = 0; j < 3; j++) {
    if (j === 1) {
      continue outer;
    }
    console.log(`i: ${i}, j: ${j}`);
  }
}
// 输出：i: 0, j: 0  i: 1, j: 0  i: 2, j: 0

const matrix = [
  [1, 2, 3],
  [4, 5, 6],
  [7, 8, 9]
];

function findInMatrix(matrix: number[][], target: number): [number, number] | null {
  let result: [number, number] | null = null;
  
  search: for (let i = 0; i < matrix.length; i++) {
    for (let j = 0; j < matrix[i].length; j++) {
      if (matrix[i][j] === target) {
        result = [i, j];
        break search;
      }
    }
  }
  
  return result;
}

console.log(findInMatrix(matrix, 5)); // [1, 1]

function processData(data: string): string | null {
  let result: string | null = null;
  
  process: {
    if (!data) {
      break process;
    }
    
    const trimmed = data.trim();
    if (!trimmed) {
      break process;
    }
    
    result = trimmed.toUpperCase();
  }
  
  return result;
}

console.log(processData("  hello  ")); // "HELLO"
console.log(processData("")); // null

function findFirst<T>(arr: T[], predicate: (item: T) => boolean): T | undefined {
  for (const item of arr) {
    if (predicate(item)) {
      return item;
    }
  }
  return undefined;
}

const numbers = [1, 2, 3, 4, 5];
const firstEven = findFirst(numbers, n => n % 2 === 0);
console.log(firstEven); // 2

function processArray(arr: number[]): number {
  if (arr.length === 0) {
    return 0;
  }
  
  let sum = 0;
  for (const num of arr) {
    if (num < 0) {
      return -1;
    }
    sum += num;
  }
  
  return sum;
}

interface FormData {
  username: string;
  email: string;
  password: string;
}

function validateForm(data: FormData): { valid: boolean; error?: string } {
  const fields: Array<{ key: keyof FormData; value: string; rules: Array<(v: string) => string | null> }> = [
    {
      key: "username",
      value: data.username,
      rules: [
        v => v.length < 3 ? "用户名至少3个字符" : null,
        v => !/^[a-zA-Z0-9_]+$/.test(v) ? "用户名只能包含字母、数字和下划线" : null
      ]
    },
    {
      key: "email",
      value: data.email,
      rules: [
        v => !v.includes("@") ? "邮箱格式不正确" : null
      ]
    },
    {
      key: "password",
      value: data.password,
      rules: [
        v => v.length < 8 ? "密码至少8个字符" : null
      ]
    }
  ];
  
  for (const field of fields) {
    for (const rule of field.rules) {
      const error = rule(field.value);
      if (error) {
        return { valid: false, error: `${field.key}: ${error}` };
      }
    }
  }
  
  return { valid: true };
}

async function processInBatches<T>(
  items: T[],
  batchSize: number,
  processor: (batch: T[]) => Promise<void>
): Promise<void> {
  for (let i = 0; i < items.length; i += batchSize) {
    const batch = items.slice(i, i + batchSize);
    await processor(batch);
  }
}

async function pollWithTimeout(
  checkFn: () => Promise<boolean>,
  options: { interval?: number; timeout?: number } = {}
): Promise<boolean> {
  const { interval = 1000, timeout = 30000 } = options;
  const startTime = Date.now();
  
  while (true) {
    if (await checkFn()) {
      return true;
    }
    
    if (Date.now() - startTime >= timeout) {
      return false;
    }
    
    await new Promise(resolve => setTimeout(resolve, interval));
  }
}

interface GameState {
  running: boolean;
  score: number;
}

async function gameLoop(state: GameState): Promise<void> {
  while (state.running) {
    // 更新游戏状态
    state.score++;
    
    // 渲染
    console.log(`Score: ${state.score}`);
    
    // 延迟
    await new Promise(resolve => setTimeout(resolve, 100));
    
    // 检查结束条件
    if (state.score >= 10) {
      state.running = false;
    }
  }
  
  console.log("Game Over!");
}

// 不推荐
for (const a of arrA) {
  for (const b of arrB) {
    for (const c of arrC) {
      if (condition) {
        // 处理
      }
    }
  }
}

// 推荐：使用提前退出或提取函数
function processItem(a: TypeA, b: TypeB, c: TypeC): boolean {
  if (!condition) {
    return false;
  }
  // 处理
  return true;
}

// 使用循环
const result: number[] = [];
for (const num of numbers) {
  if (num > 5) {
    result.push(num * 2);
  }
}

// 使用数组方法
const result2 = numbers
  .filter(num => num > 5)
  .map(num => num * 2);

// 危险：可能无限循环
while (true) {
  // 忘记break条件
}

// 安全：设置最大迭代次数
let iterations = 0;
const maxIterations = 1000;

while (condition && iterations < maxIterations) {
  // 处理
  iterations++;
}