切片范围语法 ​

什么是范围语法 ​

Rust 用 .. 和 ..= 操作符来表示范围(Range),在创建切片时用来指定"从哪里到哪里"。范围语法可以和数组、Vec、字符串等任何支持索引的类型配合使用。

六种范围写法 ​

rust
fn main() {
    let data = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];

    // 1. start..end(左闭右开):从 start 到 end-1
    let s1 = &data[2..5];
    println!("2..5   = {:?}", s1);    // [2, 3, 4]

    // 2. start..=end(左闭右闭):从 start 到 end(包含 end)
    let s2 = &data[2..=5];
    println!("2..=5  = {:?}", s2);    // [2, 3, 4, 5]

    // 3. start..(从 start 到末尾)
    let s3 = &data[7..];
    println!("7..    = {:?}", s3);    // [7, 8, 9]

    // 4. ..end(从开头到 end-1)
    let s4 = &data[..3];
    println!("..3    = {:?}", s4);    // [0, 1, 2]

    // 5. ..=end(从开头到 end,包含 end)
    let s5 = &data[..=3];
    println!("..=3   = {:?}", s5);    // [0, 1, 2, 3]

    // 6. ..(整个切片)
    let s6 = &data[..];
    println!("..     = {:?}", s6);    // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
}

范围类型总结 ​

语法类型名含义示例结果(对 [0..9])
2..5Range<usize>从 2 到 4(不含 5)[2, 3, 4]
2..=5RangeInclusive<usize>从 2 到 5(含 5)[2, 3, 4, 5]
2..RangeFrom<usize>从 2 到末尾[2, 3, ..., 9]
..5RangeTo<usize>从开头到 4[0, 1, 2, 3, 4]
..=5RangeToInclusive<usize>从开头到 5[0, 1, 2, 3, 4, 5]
..RangeFull整个范围[0, 1, ..., 9]

范围在 for 循环中的使用 ​

范围不仅用于切片,还常用在 for 循环中生成数字序列。

rust
fn main() {
    // 左闭右开范围
    print!("0..5: ");
    for i in 0..5 {
        print!("{} ", i);  // 0 1 2 3 4
    }
    println!();

    // 左闭右闭范围
    print!("1..=5: ");
    for i in 1..=5 {
        print!("{} ", i);  // 1 2 3 4 5
    }
    println!();

    // 反向迭代
    print!("反向 (0..5).rev(): ");
    for i in (0..5).rev() {
        print!("{} ", i);  // 4 3 2 1 0
    }
    println!();

    // 步进迭代(每隔 2 个)
    print!("步进 (0..10).step_by(2): ");
    for i in (0..10).step_by(2) {
        print!("{} ", i);  // 0 2 4 6 8
    }
    println!();
}

字符串切片中的范围 ​

字符串切片的范围索引是按字节位置计算的,不是按字符位置。对于包含多字节字符(中文等)的字符串,需要特别注意。

rust
fn main() {
    // ASCII 字符串:每个字符 1 字节,索引和字符位置一一对应
    let ascii = "Hello, World!";
    println!("{}", &ascii[0..5]);    // "Hello"
    println!("{}", &ascii[7..]);     // "World!"

    // 中文字符串:每个中文字符占 3 个字节(UTF-8)
    let chinese = "你好世界";
    println!("{}", &chinese[0..3]);    // "你"(3 个字节)
    println!("{}", &chinese[0..6]);    // "你好"(6 个字节)
    // println!("{}", &chinese[0..2]);  // panic! 切到了字符中间

    // 安全地按字符切片
    let chars: Vec<char> = chinese.chars().collect();
    let first_two: String = chars[0..2].iter().collect();
    println!("前两个字符:{}", first_two);  // "你好"
}

基本示例 ​

用范围语法实现一些常见的数据操作:

rust
fn main() {
    let data = vec![15, 42, 8, 23, 16, 4, 38, 27, 11, 35];

    // 取前 3 个元素
    let first_three = &data[..3];
    println!("前三个:{:?}", first_three);  // [15, 42, 8]

    // 取最后 3 个元素
    let last_three = &data[data.len() - 3..];
    println!("后三个:{:?}", last_three);   // [27, 11, 35]

    // 取中间部分
    let middle = &data[3..7];
    println!("中间部分:{:?}", middle);     // [23, 16, 4, 38]

    // 用范围做分页
    let page_size = 3;
    let total_pages = (data.len() + page_size - 1) / page_size;

    for page in 0..total_pages {
        let start = page * page_size;
        let end = (start + page_size).min(data.len());
        println!("第 {} 页:{:?}", page + 1, &data[start..end]);
    }

    // 用范围检查值是否在某个区间内
    let score = 85;
    let grade = match score {
        90..=100 => "优秀",
        80..=89 => "良好",
        60..=79 => "及格",
        0..=59 => "不及格",
        _ => "无效分数",
    };
    println!("{} 分 -> {}", score, grade);
}

常见问题 ​

问题一:.. 和 ..= 该用哪个?

.. 是左闭右开(不包含右端),..= 是左闭右闭(包含右端)。切片时用 .. 更常见,因为可以直接用 .len() 作为右端。match 中匹配数字范围时用 ..= 更自然(比如 0..=100)。

问题二:范围索引越界会怎样?

运行时 panic。比如数组只有 5 个元素,你写 &arr[3..10] 就会 panic。编译器不会在编译期检查范围是否越界(除非是明显的字面量常量)。

问题三:可以用负数索引从末尾开始切片吗?

Rust 不支持 Python 式的负数索引。想从末尾开始要自己算:&data[data.len() - 3..] 取最后 3 个元素。

问题四:空范围(如 3..3)合法吗?

合法。&data[3..3] 会得到一个空切片,长度为 0。但 3..2(起始大于结束)会 panic。

适用场景 ​

  • 子序列提取:取数组或字符串的一部分
  • 分页显示:按固定大小把数据分成多页
  • for 循环:生成连续的数字序列
  • match 分支:匹配数字是否在某个范围内
  • 滑动窗口:配合 windows() 方法做滑动窗口分析
  • 字符串截取:截取字符串的子串(注意 UTF-8 边界)

注意事项 ​

  • .. 是左闭右开,..= 是左闭右闭
  • 范围的索引是 usize 类型,不能用负数
  • 字符串的范围索引是按字节位置,不是字符位置,切到多字节字符中间会 panic
  • 空范围(如 5..5)合法,会得到空切片
  • 范围起始大于结束(如 5..3)会 panic
  • .. 单独使用时表示完整范围(RangeFull),在切片中等同于引用全部元素
  • 在 match 中只能用 ..=(闭区间),不能用 ..(因为语法歧义)

总结 ​

Rust 的范围语法用 .. 和 ..= 表示,有六种变体覆盖了从"指定起止"到"省略起止"的所有组合。.. 是左闭右开(不含右端),..= 是左闭右闭(含右端)。范围用在切片操作中指定子序列的边界,用在 for 循环中生成数字序列,用在 match 中匹配数值区间。使用范围切片时需要注意边界不能越界、字符串必须在 UTF-8 字符边界切割。