面试题：Rust 中控制流语句嵌套优化的常见场景及方法

Question

在 Rust 中，列举至少两个控制流语句嵌套的常见场景，并说明如何对这些嵌套结构进行优化以提高代码性能和可读性。

Answer 1

常见场景

1. 多层循环嵌套
   • 例如在矩阵乘法的实现中，可能会有如下代码：

   let mut result = vec![vec![0; cols]; rows];
   for i in 0..rows {
       for j in 0..cols {
           for k in 0..cols {
               result[i][j] += matrix1[i][k] * matrix2[k][j];
           }
       }
   }
   

   • 这里外层循环遍历结果矩阵的行，中间层循环遍历结果矩阵的列，最内层循环用于计算乘积和。
2. 循环与条件语句嵌套
   • 比如在解析文本文件，筛选特定行中的特定字段时，可能这样写：

   let lines: Vec<String> = file.read_to_string()?.lines().map(|s| s.to_string()).collect();
   for line in lines {
       if line.starts_with("prefix") {
           let parts: Vec<&str> = line.split(' ').collect();
           if parts.len() > 2 {
               println!("{}", parts[2]);
           }
       }
   }
   

   • 外层循环逐行读取文件内容，内层条件语句先判断行前缀，再进一步判断字段数量。

优化方法

1. 减少不必要的嵌套
   • 提取函数：对于多层循环嵌套，可以将内层循环逻辑提取成函数。例如上述矩阵乘法，可将内层计算逻辑提取出来：

   fn multiply_element(matrix1: &[Vec<i32>], matrix2: &[Vec<i32>], i: usize, j: usize, cols: usize) -> i32 {
       let mut sum = 0;
       for k in 0..cols {
           sum += matrix1[i][k] * matrix2[k][j];
       }
       sum
   }
   let mut result = vec![vec![0; cols]; rows];
   for i in 0..rows {
       for j in 0..cols {
           result[i][j] = multiply_element(matrix1, matrix2, i, j, cols);
       }
   }
   

   • 这样使代码结构更清晰，且便于测试内层逻辑。
2. 使用迭代器方法
   • 对于循环与条件语句嵌套，可利用迭代器的过滤（filter）和映射（map）方法。例如上述文本文件解析：

   let lines: Vec<String> = file.read_to_string()?.lines().map(|s| s.to_string()).collect();
   let results: Vec<&str> = lines.iter()
      .filter(|line| line.starts_with("prefix"))
      .filter(|line| line.split(' ').count() > 2)
      .map(|line| line.split(' ').nth(2).unwrap())
      .collect();
   for result in results {
       println!("{}", result);
   }
   

   • 迭代器方法链式调用，使代码更简洁，同时 Rust 的迭代器通常有较好的性能优化。
3. 提前返回
   • 在循环与条件语句嵌套中，如果满足某些条件后无需继续执行内层逻辑，可以提前返回。例如：

   let lines: Vec<String> = file.read_to_string()?.lines().map(|s| s.to_string()).collect();
   for line in lines {
       if!line.starts_with("prefix") {
           continue;
       }
       let parts: Vec<&str> = line.split(' ').collect();
       if parts.len() <= 2 {
           continue;
       }
       println!("{}", parts[2]);
   }
   

   • 通过continue提前跳过不满足条件的行，减少不必要的计算。