Rust 1.94 新API概览 ​

核心概念 ​

Rust 1.94.0 于 2026 年 3 月 5 日发布,是截至目前的最新稳定版本。这个版本带来了 array_windows 切片迭代方法、Cargo 配置文件的 include 支持、TOML v1.1 解析支持,以及一系列新稳定化的 API。这些改进从不同层面提升了 Rust 的开发体验和表达能力。

array_windows 方法 ​

array_windows 是为切片类型新增的迭代方法,与已有的 windows 方法类似,但返回固定长度的数组引用 &[T; N] 而非动态大小的切片 &[T]。编译器通常能根据使用方式自动推断窗口长度。

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

    // array_windows 返回 &[T; N] 类型的窗口
    // 编译器可以根据解构模式推断 N = 2
    for [a, b] in data.array_windows() {
        println!("({}, {}), 差值: {}", a, b, b - a);
    }

    println!("---");

    // 窗口大小为 3
    for window in data.array_windows::<3>() {
        // window 的类型是 &[i32; 3]
        let sum: i32 = window.iter().sum();
        println!("{:?}, 窗口和: {}", window, sum);
    }

    println!("---");

    // 实际应用:检测回文子串
    let text = b"abba_xyyx";
    let has_palindrome_4 = text
        .array_windows::<4>()
        .any(|[a, b, c, d]| a == d && b == c);
    println!("包含 4 字符回文: {}", has_palindrome_4);
}
rust
// array_windows 与 windows 的对比

fn main() {
    let nums = [10, 20, 30, 40, 50];

    // 旧方法:windows 返回 &[T](动态大小)
    // 需要通过索引访问元素
    for w in nums.windows(2) {
        let diff = w[1] - w[0];
        println!("windows: {} - {} = {}", w[1], w[0], diff);
    }

    println!("---");

    // 新方法:array_windows 返回 &[T; N](固定大小)
    // 可以直接解构,编译期检查长度
    for &[a, b] in nums.array_windows() {
        let diff = b - a;
        println!("array_windows: {} - {} = {}", b, a, diff);
    }
}
方法返回类型长度检查模式解构
windows(n)&[T]运行时不支持
array_windows::<N>()&[T; N]编译时支持

element_offset 方法 ​

element_offset 方法用于计算切片中某个元素引用相对于切片起始位置的索引偏移量。

rust
fn main() {
    let data = [10, 20, 30, 40, 50];
    let slice = &data[..];

    // 获取某个元素的引用
    let elem = &slice[2];

    // 计算该引用在切片中的偏移量
    if let Some(offset) = slice.element_offset(elem) {
        println!("元素 {} 在切片中的索引: {}", elem, offset);
        // 输出: 元素 30 在切片中的索引: 2
    }

    // 如果引用不在切片范围内,返回 None
    let other = &42;
    println!("外部引用的偏移: {:?}", slice.element_offset(other));
    // 输出: None
}

LazyCell 和 LazyLock 新方法 ​

rust
use std::cell::LazyCell;
use std::sync::LazyLock;

fn main() {
    // LazyCell:单线程延迟初始化
    let lazy: LazyCell<String> = LazyCell::new(|| {
        println!("初始化 LazyCell");
        "hello".to_string()
    });

    // get:尝试获取值(不触发初始化)
    assert!(LazyCell::get(&lazy).is_none());

    // 首次解引用触发初始化
    println!("值: {}", *lazy);

    // 初始化后 get 返回 Some
    assert_eq!(LazyCell::get(&lazy), Some(&"hello".to_string()));

    // LazyLock:线程安全的延迟初始化
    static GLOBAL: LazyLock<Vec<i32>> = LazyLock::new(|| {
        println!("初始化 LazyLock");
        vec![1, 2, 3]
    });

    // get:不触发初始化
    // LazyLock::get(&GLOBAL) — 初始化前返回 None

    // 首次访问触发初始化
    println!("全局值: {:?}", *GLOBAL);

    // 初始化后 get 返回 Some
    assert_eq!(LazyLock::get(&GLOBAL), Some(&vec![1, 2, 3]));
}

Peekable::next_if_map ​

rust
fn main() {
    let mut iter = [1, 2, 3, 4, 5].into_iter().peekable();

    // next_if_map:如果下一个元素满足条件,消费并转换它
    // 类似 next_if 和 map 的组合
    let result = iter.next_if_map(|&x| {
        if x > 0 { Some(x * 10) } else { None }
    });
    println!("next_if_map 结果: {:?}", result);
    // 输出: Some(10)

    // 如果条件不满足,不消费元素
    let result = iter.next_if_map(|&x| {
        if x > 100 { Some(x) } else { None }
    });
    println!("条件不满足: {:?}", result);
    // 输出: None
    // 元素 2 没有被消费

    println!("剩余第一个: {:?}", iter.next());
    // 输出: Some(2)
}

数学常量 ​

rust
fn main() {
    // 新增的数学常量

    // 欧拉-马斯切罗尼常量 (Euler-Mascheroni constant)
    // γ ≈ 0.5772156649...
    println!("f64 欧拉常数: {}", f64::consts::EULER_GAMMA);
    println!("f32 欧拉常数: {}", f32::consts::EULER_GAMMA);

    // 黄金比例 (Golden Ratio)
    // φ = (1 + √5) / 2 ≈ 1.6180339887...
    println!("f64 黄金比例: {}", f64::consts::GOLDEN_RATIO);
    println!("f32 黄金比例: {}", f32::consts::GOLDEN_RATIO);

    // 验证黄金比例的性质:φ² = φ + 1
    let phi = f64::consts::GOLDEN_RATIO;
    let diff = (phi * phi - phi - 1.0).abs();
    println!("φ² - φ - 1 = {} (应接近 0)", diff);

    // mul_add 现在在 const 上下文中稳定
    // a * b + c 的融合乘加运算
    const RESULT: f64 = 2.0_f64.mul_add(3.0, 4.0); // 2*3+4 = 10
    println!("const mul_add: {}", RESULT);
}

Cargo 新特性 ​

toml
# === Cargo 配置文件 include 支持 ===
# .cargo/config.toml

# 引入其他配置文件
include = [
    "shared-config.toml",                    # 相对路径
    { path = "ci-config.toml", optional = true },  # 可选文件
]

[build]
jobs = 8
toml
# === TOML v1.1 支持 ===
# Cargo.toml 现在支持 TOML v1.1 语法

[package]
name = "my-app"
version = "0.1.0"
edition = "2024"

# TOML v1.1 允许内联表跨多行并使用尾随逗号
[dependencies]
serde = { version = "1",
    features = [
        "derive",
    ],
}

# 注意:使用 TOML v1.1 语法会提高 MSRV 要求
# 但 cargo publish 会自动重写为兼容格式

基本示例 ​

rust
use std::sync::LazyLock;

// 全局配置使用 LazyLock
static CONFIG: LazyLock<AppConfig> = LazyLock::new(|| {
    AppConfig {
        name: "my-app".to_string(),
        version: "1.94".to_string(),
    }
});

struct AppConfig {
    name: String,
    version: String,
}

fn moving_average(data: &[f64], window: usize) -> Vec<f64> {
    // 使用 windows 计算移动平均(array_windows 需要编译期常量)
    data.windows(window)
        .map(|w| w.iter().sum::<f64>() / w.len() as f64)
        .collect()
}

fn detect_trend(data: &[f64]) -> &'static str {
    // 使用 array_windows 检测趋势
    let increasing = data.array_windows::<2>().all(|[a, b]| b >= a);
    let decreasing = data.array_windows::<2>().all(|[a, b]| b <= a);

    if increasing {
        "上升"
    } else if decreasing {
        "下降"
    } else {
        "波动"
    }
}

fn main() {
    // LazyLock 延迟初始化
    println!("应用: {} v{}", CONFIG.name, CONFIG.version);

    // array_windows 使用
    let prices = [100.0, 102.0, 105.0, 103.0, 108.0, 110.0];
    println!("趋势: {}", detect_trend(&prices));

    let avg = moving_average(&prices, 3);
    println!("3日均值: {:?}", avg);

    // 数学常量
    let phi = f64::consts::GOLDEN_RATIO;
    println!("黄金比例: {:.10}", phi);
}

常见问题 ​

问题一:array_windows 的窗口大小必须是编译时常量吗?

是的。array_windows::<N>() 的 N 是泛型常量参数,必须在编译时确定。如果需要运行时指定窗口大小,使用传统的 windows(n) 方法。

问题二:TOML v1.1 支持会影响现有项目吗?

不会影响。现有的 TOML v1.0 语法完全兼容。只有使用新语法特性(如内联表尾随逗号)时才会提高 MSRV。cargo publish 会自动将 TOML v1.1 重写为兼容格式。

问题三:LazyCell 和 LazyLock 的区别?

LazyCell 是单线程的(不实现 Sync),性能更好。LazyLock 是线程安全的(实现了 Sync),可以用在 static 中。选择取决于是否需要跨线程共享。

问题四:从旧版本升级到 1.94 需要改代码吗?

不需要。Rust 保持向后兼容,旧代码在新版本上直接编译。新 API 是新增的,不影响现有代码。

适用场景 ​

  • 数据分析:array_windows 用于滑动窗口计算
  • 配置管理:Cargo include 管理复杂项目配置
  • 延迟初始化:LazyCell/LazyLock 的 get 方法检查初始化状态
  • 数学计算:新的数学常量用于科学计算

注意事项 ​

  • array_windows 的 N 必须是编译期常量
  • TOML v1.1 语法会提高 MSRV
  • LazyCell 不是线程安全的,LazyLock 是
  • Cargo include 路径可以标记为 optional
  • mul_add 现在可以在 const 上下文中使用
  • element_offset 引用不在切片范围内时返回 None

总结 ​

Rust 1.94.0 的主要更新包括:array_windows 提供编译时固定长度的切片窗口迭代,支持模式解构;element_offset 计算引用在切片中的位置;LazyCell/LazyLock 新增 get、get_mut、force_mut 方法;新增 EULER_GAMMA 和 GOLDEN_RATIO 数学常量;Peekable::next_if_map 提供条件消费和转换。Cargo 层面支持配置文件 include 和 TOML v1.1 解析。mul_add 在 const 上下文中稳定。这些改进在数据处理、延迟初始化和项目配置管理等方面提供了更好的工具。