Carbon循环语句 #

一、循环概述 #

循环用于重复执行代码块。Carbon提供了 while 循环、for 循环和迭代器等多种循环方式。

二、while循环 #

2.1 基本while循环 #

carbon 
var count: i32 = 0;

while (count < 5) {
  Print("计数: {0}", count);
  count += 1;
}

2.2 while循环条件 #

carbon 
var sum: i32 = 0;
var i: i32 = 1;

while (i <= 100) {
  sum += i;
  i += 1;
}
Print("1到100的和: {0}", sum);

2.3 无限循环 #

carbon 
while (true) {
  var input: String = ReadInput();
  if (input == "exit") {
    break;
  }
  Process(input);
}

2.4 while表达式 #

carbon 
var x: i32 = 10;
while (x > 0) {
  Print("{0}", x);
  x -= 1;
}
Print("发射！");

三、for循环 #

3.1 范围for循环 #

carbon 
// 遍历范围
for (i in 0..5) {
  Print("i = {0}", i);  // 0, 1, 2, 3, 4
}

// 包含结束值
for (i in 0..=5) {
  Print("i = {0}", i);  // 0, 1, 2, 3, 4, 5
}

3.2 数组遍历 #

carbon 
var fruits: [String; 3] = ("苹果", "香蕉", "橙子");

for (fruit in fruits) {
  Print("水果: {0}", fruit);
}

3.3 带索引遍历 #

carbon 
var items: [i32; 5] = (10, 20, 30, 40, 50);

for (i, item in items.Enumerate()) {
  Print("索引 {0}: 值 {1}", i, item);
}

3.4 反向遍历 #

carbon 
var items: [i32; 5] = (1, 2, 3, 4, 5);

for (item in items.Reverse()) {
  Print("{0}", item);  // 5, 4, 3, 2, 1
}

3.5 步长遍历 #

carbon 
// 步长为2
for (i in (0..10).Step(2)) {
  Print("{0}", i);  // 0, 2, 4, 6, 8
}

四、循环控制 #

4.1 break语句 #

break 用于立即退出循环：

carbon 
var i: i32 = 0;
while (true) {
  Print("{0}", i);
  i += 1;
  if (i >= 5) {
    break;  // 退出循环
  }
}
Print("循环结束");

4.2 continue语句 #

continue 用于跳过当前迭代，继续下一次：

carbon 
for (i in 0..10) {
  if (i % 2 == 0) {
    continue;  // 跳过偶数
  }
  Print("{0}", i);  // 只打印奇数
}

4.3 标签与break #

carbon 
outer: for (i in 0..5) {
  for (j in 0..5) {
    if (i + j == 5) {
      break outer;  // 跳出外层循环
    }
    Print("({0}, {1})", i, j);
  }
}

4.4 标签与continue #

carbon 
outer: for (i in 0..3) {
  for (j in 0..3) {
    if (j == 1) {
      continue outer;  // 跳到外层循环的下一次迭代
    }
    Print("({0}, {1})", i, j);
  }
}

五、迭代器 #

5.1 迭代器概念 #

迭代器是遍历集合的标准方式，提供 Next() 方法：

carbon 
interface Iterator(ElementType) {
  fn Next(me) -> Optional(ElementType);
}

5.2 创建迭代器 #

carbon 
var arr: [i32; 5] = (1, 2, 3, 4, 5);
var iter: auto = arr.Iter();

while (true) {
  match (iter.Next()) {
    case Some(value) => Print("{0}", value);
    case None => break;
  }
}

5.3 迭代器方法 #

carbon 
var numbers: [i32; 5] = (1, 2, 3, 4, 5);

// Map: 转换每个元素
var doubled: [i32] = numbers.Iter().Map(fn (x: i32) -> i32 { return x * 2; });

// Filter: 过滤元素
var evens: [i32] = numbers.Iter().Filter(fn (x: i32) -> bool { return x % 2 == 0; });

// Reduce: 归约
var sum: i32 = numbers.Iter().Reduce(0, fn (a: i32, b: i32) -> i32 { return a + b; });

// Take: 取前N个
var first_three: [i32] = numbers.Iter().Take(3);

// Skip: 跳过前N个
var last_two: [i32] = numbers.Iter().Skip(3);

5.4 链式调用 #

carbon 
var numbers: [i32; 10] = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

var result: i32 = numbers.Iter()
  .Filter(fn (x: i32) -> bool { return x % 2 == 0; })  // 过滤偶数
  .Map(fn (x: i32) -> i32 { return x * x; })           // 平方
  .Take(3)                                              // 取前3个
  .Reduce(0, fn (a: i32, b: i32) -> i32 { return a + b; });  // 求和

Print("结果: {0}", result);  // 4 + 16 + 36 = 56

六、循环表达式 #

6.1 for表达式 #

carbon 
// 使用for生成数组
var squares: [i32] = for (i in 1..6) yield i * i;
// [1, 4, 9, 16, 25]

6.2 while表达式 #

carbon 
// 使用while生成值
var result: i32 = while (condition) {
  // ...
  yield value;
};

七、实际应用 #

7.1 查找元素 #

carbon 
fn Find(arr: [i32], target: i32) -> Optional(i32) {
  for (i, value in arr.Enumerate()) {
    if (value == target) {
      return Some(i);
    }
  }
  return None;
}

var items: [i32; 5] = (10, 20, 30, 40, 50);
match (Find(items, 30)) {
  case Some(index) => Print("找到，索引: {0}", index);
  case None => Print("未找到");
}

7.2 计算统计 #

carbon 
fn CalculateStats(numbers: [f64]) -> (f64, f64, f64) {
  var sum: f64 = 0.0;
  var min: f64 = f64.Max;
  var max: f64 = f64.Min;
  
  for (n in numbers) {
    sum += n;
    if (n < min) { min = n; }
    if (n > max) { max = n; }
  }
  
  var avg: f64 = sum / f64(numbers.Length());
  return (avg, min, max);
}

var data: [f64; 5] = (1.5, 2.5, 3.5, 4.5, 5.5);
var (avg, min_val, max_val) = CalculateStats(data);
Print("平均: {0}, 最小: {1}, 最大: {2}", avg, min_val, max_val);

7.3 矩阵遍历 #

carbon 
var matrix: [[i32; 3]; 3] = (
  (1, 2, 3),
  (4, 5, 6),
  (7, 8, 9)
);

for (row in matrix) {
  for (value in row) {
    Print("{0} ", value);
  }
  Print("");
}

7.4 文件处理 #

carbon 
fn ProcessFile(filename: String) -> i32 {
  var file: File = File.Open(filename);
  var line_count: i32 = 0;
  
  for (line in file.Lines()) {
    ProcessLine(line);
    line_count += 1;
  }
  
  file.Close();
  return line_count;
}

八、性能优化 #

8.1 避免不必要的迭代 #

carbon 
// 好的做法：提前退出
fn Contains(arr: [i32], target: i32) -> bool {
  for (value in arr) {
    if (value == target) {
      return true;  // 找到就退出
    }
  }
  return false;
}

// 避免：总是遍历全部
fn ContainsSlow(arr: [i32], target: i32) -> bool {
  var found: bool = false;
  for (value in arr) {
    if (value == target) {
      found = true;
    }
  }
  return found;
}

8.2 使用迭代器方法 #

carbon 
// 好的做法：使用内置方法
var sum: i32 = numbers.Iter().Sum();

// 避免：手动循环
var sum: i32 = 0;
for (n in numbers) {
  sum += n;
}

8.3 减少循环内计算 #

carbon 
// 好的做法：循环外计算
var limit: i32 = CalculateLimit();
for (i in 0..limit) {
  // ...
}

// 避免：每次迭代都计算
for (i in 0..CalculateLimit()) {
  // ...
}

九、最佳实践 #

9.1 选择合适的循环 #

carbon 
// 已知次数：使用for
for (i in 0..10) {
  Print("{0}", i);
}

// 条件循环：使用while
var input: String;
while (input != "quit") {
  input = ReadInput();
}

9.2 避免深层嵌套 #

carbon 
// 好的做法：提前返回
fn Process(data: [i32]) -> i32 {
  if (data.Length() == 0) {
    return 0;
  }
  
  for (item in data) {
    if (item < 0) {
      return -1;
    }
  }
  
  return ProcessValid(data);
}

// 避免：深层嵌套
fn Process(data: [i32]) -> i32 {
  if (data.Length() > 0) {
    var valid: bool = true;
    for (item in data) {
      if (item < 0) {
        valid = false;
      }
    }
    if (valid) {
      return ProcessValid(data);
    }
  }
  return 0;
}

9.3 使用有意义的循环变量名 #

carbon 
// 好的命名
for (row in matrix) {
  for (column in row) {
    // ...
  }
}

// 避免的命名
for (i in matrix) {
  for (j in i) {
    // ...
  }
}

十、常见错误 #

10.1 无限循环 #

carbon 
// 错误：忘记更新条件
var i: i32 = 0;
while (i < 10) {
  Print("{0}", i);
  // 忘记 i += 1;
}

// 正确
var i: i32 = 0;
while (i < 10) {
  Print("{0}", i);
  i += 1;
}

10.2 边界错误 #

carbon 
var arr: [i32; 5] = (1, 2, 3, 4, 5);

// 错误：越界
// for (i in 0..=5) {
//   Print("{0}", arr[i]);  // i=5时越界
// }

// 正确
for (i in 0..5) {
  Print("{0}", arr[i]);
}

10.3 修改迭代集合 #

carbon 
var items: [i32; 5] = (1, 2, 3, 4, 5);

// 错误：在迭代中修改集合
// for (item in items) {
//   items.Push(item * 2);  // 危险
// }

// 正确：创建新集合
var new_items: [i32] = for (item in items) yield item * 2;

十一、总结 #

本章我们学习了：

  1. while循环：条件循环、无限循环
  2. for循环：范围遍历、数组遍历、带索引遍历
  3. 循环控制：break、continue、标签
  4. 迭代器：创建、方法、链式调用
  5. 循环表达式：yield生成值
  6. 性能优化：提前退出、减少计算
  7. 最佳实践：选择合适循环、避免嵌套

接下来让我们学习Carbon的函数！

最后更新：2026-03-27