深入浅出 Rust 迭代器:从基础用法到性能优化

Qdrant 深度拆解:35K Star 的 Rust 向量数据库,是如何把 HNSW、Payload 过滤和量化压缩揉成一台机器 Qdrant 是基于 Rust 构建的向量数据库,以高效协同稠密向量(HNSW)、Payload 过滤与量化索引著称。其核心优势在于三者在查询中同步生效,兼顾召回率与性能。适用于 RAG、语义搜索、推荐系统及多租户场景,但不擅长事务或精确检索。架构分层清晰,写入经 WAL 保障一致性,检索通过分片与段并行加速。关键技术包括过滤感知 HNSW、ACORN 跨跳搜索、八类 Payload 索引、四档量化(如 TurboQuant、Product)及灵活多租户策略。最新版本 v1.20.1 强化了嵌套索引与重打分 阅读详情

深入浅出 Rust 迭代器:从基础用法到性能优化

在 Rust 开发中,迭代器(Iterator)不仅是遍历集合的工具,更是 Rust 函数式编程风格的基石,也是零成本抽象理念的典型体现。本文将从基础用法入手,逐步深入迭代器的核心特性、高级用法,再到性能优化技巧,帮助你真正掌握 Rust 迭代器。

什么是迭代器

简单来说,迭代器是一种可以依次访问集合(如 Vec、Slice、HashSet 等)中元素的工具,它封装了“遍历逻辑”,让我们无需手动管理索引(避免越界风险),就能高效遍历数据。

下面我们可以通过集合的 iter() 方法创建迭代器,然后手动调用 next() 遍历,也可以使用 for 循环(Rust 的 for 循环本质就是对迭代器的封装):

fn main() {
    let v = vec![1, 2, 3, 4, 5];
    
    // 手动调用 next() 遍历
    let mut iter = v.iter();
    println!("{:?}", iter.next()); // Some(&1)
    println!("{:?}", iter.next()); // Some(&2)
    println!("{:?}", iter.next()); // Some(&3)
    println!("{:?}", iter.next()); // Some(&4)
    println!("{:?}", iter.next()); // Some(&5)
    println!("{:?}", iter.next()); // None
    
    // for 循环遍历(推荐用法)
    for item in v.iter() {
        println!("{}", item); // 依次打印 1-5
    }
}

Rust 为集合提供了三种常用的迭代器创建方法,对应不同的所有权语义,这是 Rust 迭代器的核心特点之一,也是避免内存安全问题的关键:

  • iter():创建不可变借用迭代器,返回元素的不可变引用(&T),不获取元素所有权,集合本身不受影响。
  • iter_mut():创建可变借用迭代器,返回元素的可变引用(&mut T),可以修改集合中的元素,同样不获取集合所有权。
  • into_iter():创建消费型迭代器,获取元素的所有权(T),迭代结束后,原集合会被消耗(无法再使用)。

代码示例对比:

fn main() {
    let mut v = vec![1, 2, 3];
    
    // iter():不可变借用,无法修改元素
    for &item in v.iter() {
        println!("不可变借用:{}", item);
    }
    println!("iter 后集合:{:?}", v); // 集合依然可用:[1,2,3]
    
    // iter_mut():可变借用,可修改元素
    for item in v.iter_mut() {
        *item *= 2; // 修改元素值
    }
    println!("iter_mut 后集合:{:?}", v); // 集合被修改:[2,4,6]
    
    // into_iter():消费型迭代,获取所有权
    for item in v.into_iter() {
        println!("消费型迭代:{}", item);
    }
    // println!("into_iter 后集合:{:?}", v); // 报错:v 已被消耗,无法访问
}

惰性求值与适配器

Rust 迭代器最强大的特性之一是惰性求值,创建迭代器、调用适配器方法时,并不会立即执行遍历和计算,只有当我们调用消费者方法(消耗迭代器的方法)时,才会真正执行逻辑。这种设计不仅节省内存,还能让我们链式调用多个适配器,构建简洁、高效的数据流处理逻辑。

下面的代码中,我们调用了 map() 适配器,但如果不调用消费者方法,map() 中的逻辑永远不会执行:

fn main() {
    let v = vec![1, 2, 3];
    // 仅创建迭代器,不执行任何逻辑(无打印输出)
    let mapped_iter = v.iter().map(|x| {
        println!("执行 map:{}", x);
        x * 2
    });
    
    // 调用 collect() 消费者方法,才会执行 map 逻辑
    let result: Vec<_> = mapped_iter.collect();
    println!("结果:{:?}", result); // 结果:[2,4,6]
}

Rust 常用的适配器有以下几种:

map:元素转换

map() 接收一个闭包,将迭代器的每个元素转换为另一种类型,返回一个新的迭代器。这里实现一个将数字转换为字符串和进行算术运算的示例:

fn main() {
    let numbers = vec![1, 2, 3, 4];
    // 数字转字符串
    let strs: Vec<_> = numbers.iter().map(|x| x.to_string()).collect();
    println!("{:?}", strs); // ["1", "2", "3", "4"]
    
    // 每个数字加 10
    let added: Vec<_> = numbers.iter().map(|&x| x + 10).collect();
    println!("{:?}", added); // [11, 12, 13, 14]
}

filter:元素过滤

filter() 接收一个闭包,闭包返回一个 bool,仅保留闭包返回 true 的元素。这里实现一个过滤出偶数的示例:

fn main() {
    let numbers = vec![1, 2, 3, 4, 5, 6];
    let evens: Vec<_> = numbers.iter().filter(|&x| x % 2 == 0).collect();
    println!("偶数:{:?}", evens); // [2, 4, 6]
}

filter_map:过滤+转换

filter_map() 是 map 和 filter 的结合体,闭包返回 Option<B>,当返回 Some(b) 时保留元素 b,返回 None 时丢弃元素,比单独使用 map+filter 更简洁高效。

use std::str::FromStr;

fn main() {
    let text = "1\nfrond .25 289\n3.1415 estuary\n";
    // 解析以空格分割的字符串,过滤无法转为浮点数的内容
    for number in text.split_whitespace().filter_map(|x| f64::from_str(x).ok()) {
        println!("{:4.2}", number); // 输出:1.00、0.25、289.00、3.14
    }
}

flat_map:展平嵌套迭代器

flat_map() 接收一个闭包,闭包返回一个可迭代对象(如 Vec、Slice),最终将所有嵌套的迭代器展平为一个单层迭代器。适用于处理嵌套结构,比如“将二维数组转为一维数组”。

fn main() {
    let nested_vec = vec![vec![1, 2], vec![3, 4], vec![5, 6]];
    // 展平二维向量为一维向量
    let flat_vec: Vec<_> = nested_vec.into_iter().flat_map(|v| v).collect();
    println!("展平后:{:?}", flat_vec); // [1, 2, 3, 4, 5, 6]
}

消费者方法:触发迭代执行

适配器返回新的迭代器,而消费者方法则会消耗迭代器,触发实际的遍历和计算,返回一个非迭代器的结果。常用的消费者方法有:

  • collect():将迭代器的结果收集到集合中(如 Vec、HashSet),需要显式指定集合类型(或通过类型推断)。
  • sum():对迭代器中的数值元素求和,返回一个数值类型。
  • fold():折叠迭代器,接收一个初始值和一个闭包,依次将元素与初始值进行运算,返回最终结果(类似累加、累乘)。
  • for_each():对每个元素执行闭包操作,无返回值(类似 for 循环)。
fn main() {
    let numbers = vec![1, 2, 3, 4, 5];
    
    // collect:收集到 Vec
    let vec: Vec<_> = numbers.iter().collect();
    
    // sum:求和
    let total: i32 = numbers.iter().sum();
    println!("总和:{}", total); // 15
    
    // fold:累乘(初始值为 1,闭包逻辑:acc * x)
    let product: i32 = numbers.iter().fold(1, |acc, &x| acc * x);
    println!("乘积:{}", product); // 120
    
    // for_each:遍历执行操作
    numbers.iter().for_each(|&x| println!("元素:{}", x));
}

自定义迭代器

在 Rust 中迭代器都实现了 Iterator 特征(Trait),下面的示例是一个生成斐波那契数列的迭代器,代码如下所示:

// 定义斐波那契迭代器结构体,存储迭代状态(前两个数)
struct Fibonacci {
    a: u32,
    b: u32,
}

// 为 Fibonacci 实现 Iterator 特征
impl Iterator for Fibonacci {
    // 定义迭代器返回的元素类型
    type Item = u32;

    // 核心方法:实现 next(),控制迭代逻辑
    fn next(&mut self) -> Option<Self::Item> {
        // 保存当前要返回的斐波那契数(初始为 a=0, b=1,首次返回0)
        let current = self.a;
        // 更新状态:下一个数 = 前两个数之和,同时移动指针
        self.a = self.b;
        self.b = current + self.b;
        // 斐波那契数列无限递增,此处返回 Some(current),永不返回 None
        // 若需限制迭代次数,可添加条件判断返回 None
        Some(current)
    }
}

// 提供一个构造函数,初始化斐波那契迭代器(初始值 0, 1)
fn fibonacci() -> Fibonacci {
    Fibonacci { a: 0, b: 1 }
}

fn main() {
    // 使用自定义迭代器,取前 10 个斐波那契数
    let fib_iter = fibonacci().take(10);
    // 收集并打印结果
    let fibs: Vec<u32> = fib_iter.collect();
    println!("前10个斐波那契数:{:?}", fibs);
    // 输出:[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
}

迭代器实战

掌握了迭代器的基础和核心特性后,我们可以用它来简化各种日常开发场景,替代繁琐的手动循环,让代码更简洁、更安全。

场景一:处理文本数据

需求:读取一段文本,去除每行的空格,过滤掉空行,然后将每行转为大写并收集到向量中。

fn main() {
    let text = " ponies \n giraffes\niguanas \n squid \n\n rust ";
    
    let result: Vec<_> = text
        .lines() // 按行分割,返回迭代器
        .map(str::trim) // 去除每行前后空格
        .filter(|s| !s.is_empty()) // 过滤空行
        .map(str::to_uppercase) // 转为大写
        .collect();
    
    println!("{:?}", result); 
    // ["PONIES", "GIRAFFES", "IGUANAS", "SQUID", "RUST"]
}

场景二:处理集合数据

需求:给定一个用户列表,筛选出年龄大于 18 岁的用户,提取他们的用户名,然后按字母顺序排序。

use itertools::Itertools;

#[derive(Debug)]
struct User {
    username: String,
    age: u8,
}

fn main() {
    let users = vec![
        User {
            username: "alice".to_string(),
            age: 20,
        },
        User {
            username: "bob".to_string(),
            age: 17,
        },
        User {
            username: "charlie".to_string(),
            age: 25,
        },
        User {
            username: "dave".to_string(),
            age: 19,
        },
    ];

    let adult_usernames: Vec<_> = users
        .into_iter() // 消费型迭代,获取 User 所有权
        .filter(|user| user.age > 18) // 筛选成年用户
        .map(|user| user.username) // 提取用户名
        .sorted() // 按字母排序(需导入 itertools 库)
        .collect();

    println!("成年用户:{:?}", adult_usernames); // ["alice", "charlie", "dave"]
}

场景三:并行迭代(Rayon 库)

对于大规模数据处理,Rust 可以通过 Rayon 库实现并行迭代,充分利用多核 CPU,提升处理效率。只需将普通迭代器替换为并行迭代器,无需修改核心逻辑。

use rayon::iter::{IntoParallelRefIterator, ParallelIterator};

fn main() {
    let numbers: Vec<u64> = (1..=1_000_000).collect();

    // 并行求和,比普通迭代器更快(数据量越大,优势越明显)
    let total: u64 = numbers.par_iter().sum();
    println!("并行求和结果:{}", total); // 500000500000
}

迭代器性能优化

Rust 迭代器是零成本抽象的,编译后的代码与手写循环几乎完全一致(可通过 cargo asm --release 查看汇编代码验证),但如果使用不当,依然会出现性能问题。以下是常见的性能陷阱和优化技巧:

避免不必要的 collect()

多次调用 collect() 会导致中间集合的堆分配,增加内存开销。尽量将多个适配器链式调用,只调用一次 collect()。

// ❌ 不好:多次 collect(),产生中间 Vec
fn bad_filter(data: &[i32]) -> Vec<i32> {
    data.iter()
        .filter(|&amp;&amp;x| x &gt; 0)
        .collect::<Vec<_>>() // 中间堆分配
        .iter()
        .map(|&x| x * 2)
        .collect()
}

// ✅ 好:链式调用,只 collect() 一次
fn good_filter(data: &[i32]) -> Vec<i32> {
    data.iter()
        .filter(|&&x| x > 0)
        .map(|&x| x * 2)
        .collect() // 仅一次堆分配
}

利用 SIMD 自动向量化

对于连续内存的集合(如 Slice),迭代器的简单运算(如加法、乘法)会被编译器自动优化为 SIMD(单指令多数据)指令,大幅提升性能。触发 SIMD 优化的条件:

  • 集合是连续内存(如 &[T],而非 &Vec<T>);
  • 运算为可向量化操作(如 +、*、& 等);
  • 无分支逻辑(避免 if 条件判断)。
// 向量加法的 SIMD 优化
fn simd_add(a: &[f32], b: &[f32]) -> Vec<f32> {
    a.iter()
        .zip(b.iter()) // 配对两个迭代器的元素
        .map(|(&x, &y)| x + y)
        .collect()
}

避免过度使用闭包捕获

闭包捕获外部变量会导致间接调用,影响编译器优化。如果闭包逻辑简单,可尝试使用直接函数或 fold 替代,提升性能。

// ❌ 不好:闭包捕获 multiplier,间接调用
fn bad_map(data: &[i32], multiplier: i32) -> i32 {
    data.iter().map(|&x| x * multiplier).sum()
}

// ✅ 好:使用 fold,更易被编译器优化
fn good_map(data: &[i32], multiplier: i32) -> i32 {
    data.iter().fold(0, |acc, &x| acc + x * multiplier)
}

总结

最后,迭代器的核心是用更简洁的代码,做更高效、更安全的事。在日常开发中,尽量用迭代器替代手动循环,既能提升开发效率,也能让代码更具可读性和可维护性。

C++高级数据结构算法 | 二叉树的四种遍历算法详解(递归与非递归实现) 二叉树遍历方法 、前序遍历算法 、中序遍历算法 、后序遍历算法 、层序遍历算法 阅读详情

相关推荐

从专利库到Zemax:一个6mm定焦镜头从零到交付的完整设计流程(含CodeV转换技巧)

本文详细介绍了6mm定焦镜头从专利库检索到最终交付的全流程设计,重点解析了CodeV与Zemax工具链的无缝衔接技巧。通过实际案例展示规格定义、专利筛选、结构适配、非球面优化等关键步骤,帮助光学设计工程师提升设计效率和制造良率。特别包含CodeV转换Zemax的实用技巧,适用于机器视觉和安防镜头开发。

weixin_42561040的博客 165

深入浅出Rust编程:Vec 源码解析

Rust标准库中的Vec实现精妙地平衡了性能与安全性。其核心结构仅包含指针、容量和长度三个元素,采用智能扩容策略(当前容量2倍与所需容量的较大值)来优化性能。实现中大量使用unsafe代码块进行精细控制,配合Unique指针和PhantomData确保内存安全。特殊优化包括零大小类型的特殊处理、批量操作的效率提升以及关键方法的内联标记。迭代器实现采用双指针设计,支持高效的双端遍历。这些设计细节展现了Rust在底层控制与高级抽象间的完美平衡,使Vec成为既高效又安全的动态数组实现。

踏雨歌青春,诗酒趁年华 6041

从实习生到独立上手:我是如何用海思PQTool搞定IPC图像调试的

本文分享了从实习生到独立使用海思PQTool进行IPC图像调试的成长历程。通过工具搭建、核心参数调整和实战案例,详细介绍了如何高效解决图像质量问题,特别强调了ISP调试中的关键参数和实用技巧,适合刚入门的图像调试工程师参考。

weixin_33756596的博客 313

Rust探索之旅·开发者技术创作征文活动获奖名单正式公布

当高性能与内存安全成为技术研发的核心追求,Rust 语言正以其独特优势席卷多领域开发场景。由旋武社区主理人发起,优快云 与 GitCode 联合举办的 “Rust 探索之旅・开发者技术创作征文活动” 已圆满落幕。活动期间,全国各地的 Rust 技术爱好者踊跃参与,围绕语言特性、开源库应用、实战项目复盘等核心方向创作了大量优质内容,既展现了 Rust 生态的蓬勃活力,也为开发者群体搭建了高效的技术交流平台。

devxuanwu的博客 1622

RV1126开发板性能实测:网络、温度与功耗全解析

本文对RV1126开发板进行了全面的性能实测,重点分析了网络性能、温度表现与功耗特性。测试发现UDP带宽可达500Mbps,但TCP性能受限于协议栈;散热设计对持续性能至关重要,大板子在AI推理和视频推流中表现更稳定。为嵌入式开发者提供了真实的选型参考和优化建议。

d3e4f的博客 272

MIPI CSI-2 协议解析

CSI-2标准协议前言一、Overview of CSI-2二、CSI-2 layer Definitions三、 Camera Control Interface(CCI)3.1 数据传输协议(Data Transfer Protocol)3.1.1 消息类型(Message Type)3.1.2 读写操作(Read/Write Operations)3.1.2.1 随机位置单次读3.1.2.2 当前位置单次读3.1.2.3 随机位置连续读3.1.2.4 当前位置连续读3.1.2.5 随机位置单次写3.1

Lucky 3万+

深入浅出 LLVM Project:从核心架构到自定义优化 Pass 实战

编译器是软件开发的底层基石,而 LLVM Project 正是现代编译器基础设施的代表。它通过前端、优化器与后端的解耦设计,以统一的中间表示(IR)为枢纽,让一种语言能够轻松移植到多种硬件平台。其模块化架构不仅支撑了 Clang、LLD、LLDB 等工具链,也被 Rust、Swift 等语言广泛采用。本文从编译器基本原理出发,剖析 LLVM 的 IR、Pass 机制与代码生成流程,并结合实操展示如何编写自定义优化 Pass,帮助读者快速构建对 LLVM 生态的系统认知。

weixin_34023982的博客 496

百度慧眼人口位置数据:从原理到实战的GIS处理全流程

本文详细解析百度慧眼人口位置数据的处理全流程,从基本原理到实战应用。通过空间网格划分、终端数量统计等技术手段,百度慧眼数据能准确反映人群分布特征。文章涵盖坐标系转换、核密度分析、热力图制作等GIS处理技巧,并分享商业选址、城市规划等典型业务场景的解决方案,帮助读者高效利用这一数据资源。

weixin_30872157的博客 534

C++之父的设计哲学:从RAII到工程实践的底层逻辑

编程语言的设计往往决定了开发者的思维方式与工程效率。C++作为一门兼具高性能与复杂性的语言,其底层设计理念直接影响了资源管理、抽象机制与零开销原则的实现。理解这些原理,不仅能帮助我们写出更健壮的代码,还能在面试与工程实战中脱颖而出。例如,RAII(资源获取即初始化)通过对象生命周期自动管理内存与资源,避免了传统手动释放带来的内存泄漏风险;而C++八股文中常考的虚函数表、移动语义等知识点,背后都源于对硬件直接映射与性能零损失的追求。在实际应用中,无论是vscode配置C/C++环境的繁琐,还是OpenCV棋盘

weixin_34297704的博客 314

PyTorch实战:卷积神经网络详解+Python实现卷积神经网络Cifar10彩色图片分类

PyTorch可以说是三大主流框架中最适合初学者学习的了,相较于其他主流框架,PyTorch的简单易用性使其成为初学者们的首选。这样我想要强调的一点是,框架可以类比为编程语言,仅为我们实现项目效果的工具,也就是我们造车使用的轮子,我们重点需要的是理解如何使用Torch去实现功能而不要过度在意轮子是要怎么做出来的,那样会牵扯我们太多学习时间。以后就出一系列专门细解深度学习框架的文章,但是那是较后期我们对深度学习的理论知识和实践操作都比较熟悉才好开始学习,现阶段我们最需要的是学会如何使用这些工具。

master_hunter的博客 8936

连接参数详解:Connection Interval, Slave Latency, Supervision Timeout 的协同与调优实战

在低功耗蓝牙(BLE)开发与调试中,Connection Interval(连接间隔)、Slave Latency(从机延迟) 和 Supervision Timeout(监督超时) 是三个核心参数。它们不仅直接影响设备的通信性能、功耗表现和连接稳定性,更是各类技术面试与认证考试的高频考点。本文将从基础概念出发,深入剖析三者的协同机制,结合历年真题解析考点与解题思路,并通过实战案例演示调优方法,快速掌握这一核心知识点。

byte轻骑兵的技术小窝 2764

组网第63课:安全域划分——Trust/Untrust/DMZ、区域模型、与 VLAN 的关系

一组接口 + 一组策略 + 一条默认拒绝。一组接口:这个域包含哪些物理口、VLAN、子接口;一组策略:这个域到别的域放行什么、拒绝什么;一条默认拒绝:没写进策略的,一律不通。第三条最关键。没有默认拒绝,前面划的域全是装饰。

qq_36765170的博客 571

微信小程序 - 解决请求报错 request:fail errcode:-201 cronet_error_code:-201 error_msg:net::ERR_CERT_DATE_INVALID

微信小程序报错“request:fail errcode:-201 cronet_error_code:-201 error_msg:net::ERR_CERT_DATE_INVALID“,微信小程序请求报错,微信小程序errcode:-201,服务器报错,无法调用接口,微信小程序真机https请求失败,微信小程序wx.request接口报错,小程序真机调试运行接口都报错了,真机测试下网络请求都不行了且报错,证书没问题依旧报错,检查HTTPS证书,ssl证书,使用浏览器测试访问证书是正常的,不是证书问题,请

🏆 前端领域优质创作者 1万+

rust: Fan-out/Fan-in Pattern

本项目基于Rust实现珠宝行业全流程的扇出/扇入模式,采用DDD六层架构。通过ProcessRequestDto与ProcessResponseDto传输数据,将采购、设计、生产等12个业务阶段抽象为可并行执行的FanoutTask子任务。核心由JewelryFanoutFanin实现并行调度:先扇出至12个线程并发执行,再统一扇入汇总结果。系统集成日志(文件+控制台)、重试熔断、内存仓储及依赖注入容器,支持顺序与并发两种调度方式,确保高并发下任务可靠执行与可观测性。

Geovin Du Dream Park 162

IDEA的使用指南

IDEA基于java的使用手册,可以最快速的上手,在使用中不断的丰富自己的使用技巧.

迈瑞BS系列全自动生化分析仪LIS协议接口手册(内含HL7和ASTM)

迈瑞BS系列全自动生化分析仪LIS协议接口手册,内含HL7和ASTM)

Rust组织管理(AI回答)

你想做的事JS / Python 做法Rust 做法把一个文件纳入工程新建文件即可新建 xxx.rs 后,必须在入口写mod xxx;挂载对外暴露函数/结构体export(Python 默认全公开)默认全私有,必须显式加pub引入别处的函数use crate::模块名::函数名;找路径的基准词./ 或 ../(从 src 根出发)、(上一级 ../)、(当前级 ./)日常写项目:不要用 #[path],直接遵守默认规则——

yaoct的博客 153

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!

自建 RustDesk 服务端后,做一个“装完就能连“的客户端

目前市面上的远程工具(如向日葵、toDesk等)免费版基本上都卡的不行,而且收费版好像也会卡。如果有云服务的话,可以基于 RustDesk 的 hbbs / hbbr 自己部署一套,不过会碰到一个问题:每台电脑装完客户端,都得手动去设置里填三样东西——ID 服务器、中继服务器、Key。填错一个就连不上,还得远程指导同事操作。这篇记录两种解决办法,以及云端编译的完整流程。内容基于 RustDesk 1.5.3 的源码。

风声的专栏 626

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

Rust LeetCode443 算法题解

LeetCode 443 字符串压缩:原地行程编码,用 start 标记组起点、next 扫描组边界、i 原地写出;长度 1 不写计数使编码不膨胀,写指针不越过读指针。时间 O(n),额外空间 O(1)。

weixin_43379230的博客 121

GitHub 热榜项目:日榜(2026-11-10)

本期共 11 个热门开源项目,合计新增 13,136 stars。榜单前三分别是 Anthropic 的 Agent Skills 仓库、Meta 开源的 React 设计系统 Astryx(+3,278)和用户名检索工具 sherlock(+4,267,本期涨星最多)。其余项目覆盖 DeepMind 的物理引擎 MuJoCo、Claude 官方示例集、自托管智能体记忆系统 GBrain、用 Rust 写的浏览器自动化 CLI、基于 WiFi 信号的人体感知平台 RuView、多市场股票分析工具,以及 Ho

u130130的博客 443

GitHub 今日推荐|HGhubX:Tauri 2 跨平台短剧客户端实战

Tauri 2 + Rust + React 构建的跨平台短剧观看客户端,实现 HLS 代理、AES 封面解密、多线路探测与会话隔离,覆盖桌面与移动全平台。

wfly blog 395

Rust 日志追踪实战:工业边缘场景下的 tracing

Rust 生态下:相比println!log,它提供结构化字段、span 上下文、异步友好和 OpenTelemetry 集成。本文从工程实战角度梳理 tracing 的用法与常见的坑。

ZenovaEdgeOS的博客 559

ARTCRAFT系列软件简单试用手记1

AI辅助开发推动开源重构热潮,ARTCRAFT系列以Rust重写经典软件,性能媲美C/C++。其Launcher支持多平台、多架构,可快速部署开源版Excel(GridCraft)与Word(WordCraft),启动速度远超Office 2016。界面类Office 2016,但暂不完善汉字字号与红头嵌套编辑。项目持续更新,主打“CraftAnything”理念——理解软件原理,自创版本,未来可期。

olegja3d的博客 211

Rust如何实现微服务网关的高并发与限流熔断机制

在现代互联网系统中,微服务架构已成为主流,而微服务网关则是整个系统的重要组成部分。当面对高并发、高可用性需求时,很多开发者对如何用 Rust 实现一个稳定可靠的网关存在疑惑,尤其是处理请求的幂等性、限流和熔断机制。本文将以 Rust 的实际案例为基础,结合生产环境中的具体经验,讲解如何设计和实现一个具备限流与熔断能力的微服务网关。

wuchangjian的专栏 115

第 1 讲:内存布局与所有权解剖——栈帧、胖指针与“移动/拷贝”在汇编层面的真实面目

看图最下面的(或者数组切片&[T]它在栈上占16 个字节,由(ptr, len)两个机器字组成。这就是系统编程里常说的胖指针(普通指针只有 8 字节地址,它胖了一倍,多带了一个 8 字节的长度或虚表指针)。痛点追问:C 语言里表示字符串切片只要一个 8 字节的char*,为什么 Rust 非要浪费双倍的栈空间搞成 16 字节?如果少掉len这一环会出什么乱子?回想一下 C 语言是怎么知道一个字符串在哪结束的:靠在内存末尾塞一个字节的\0求长度是 $O(N)$ 的苦力活:在 C 里调strlen(p)

yaoct的博客 168

Rust LeetCode334 算法题解

本文分析了 LeetCode 334 题“递增的三元子序列”的两种解法。暴力法(三重循环)时间复杂度为 O(n³),仅适用于小数据;最优解采用一次扫描贪心策略,维护 first(最小值)和 second(递增对第二元素的最小值),通过三个分支判断:若当前数大于 second,则存在三元递增子序列;否则更新 first 或 second。算法正确性基于不变式:first 始终为已遍历最小值,second 为可形成递增对的最小尾部。时间复杂度 O(n),空间复杂度 O(1),适用于大规模数据。

weixin_43379230的博客 342

主流开源 LLM 网关横向评测:OneAPI、LiteLLM、NewAPI 能力对比

在大模型应用规模化落地的当下,多模型混用、API 密钥分散、成本不可控、接口不统一已成为开发者的普遍痛点。LLM 网关作为 AI 应用层与模型层之间的核心中间件,承担着协议转换、流量路由、成本管控、安全审计的关键作用。本文从协议许可、功能完备度、性能表现、生态适配四个核心维度,对业内主流的三款开源 LLM 网关 ——OneAPI、LiteLLM、NewAPI 进行深度横向评测,为不同规模的团队提供选型参考。

2601_96785163的博客 287

Rust 1.100 的 DropGuard:用 Python 实测失败回滚与吞异常

解析一批数据往列表里塞,塞到第三条抛异常,列表已经脏了一半——这类「能跑但结果不对」的 bug 不报错也不崩溃。Rust 1.100.0 把 core::mem::DropGuard 稳定了:包裹一个

aifannihao的博客 222
上一篇: 深入理解 Rust 闭包:从基础语法到实战应用
下一篇: Rust 是如何判断对象是否相等的?一起来聊一聊 PartialEq 与 Eq
Rust研习社
博客等级 码龄11年 52粉丝 84原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值