Rust 闭包与所有权:move 关键字到底移走了什么

《Rust 实战指南》第 9 章:无畏并发——编译期的多线程革命 针对 Java 开发者的“锁恐惧症”和 Python 开发者的“GIL 无奈”,展示 Rust 如何通过类型系统将并发错误的发现时间从“线上崩溃时”提前到“代码编译时”。 阅读详情

Rust 闭包与所有权:move 关键字到底移走了什么

一、那个让我困惑了很久的编译报错

学 Rust 闭包的时候,我第一次见到 move 关键字,直觉上觉得它就是"把变量移进闭包里"。但很快我就遇到了这样的编译错误:

error[E0382]: borrow of moved value: `name`

我心想:我不是已经用了 move 了吗?怎么还报借用错误?

翻来覆去折腾了之后才慢慢理解——move 的行为和我想的不完全一样。它不是"把用到的所有变量都移进去",而是"强制闭包获取其捕获变量的所有权"。但具体是哪些变量、以什么形式捕获,取决于你在闭包里怎么用它们。

这个问题困扰了我不短的时间,所以这篇文章我试着把我的理解整理出来,希望能帮到遇到同样困惑的朋友。

二、闭包的三种"捕获姿势"

Rust 的闭包在捕获外部变量时,有三种方式。这三种方式是从"借用量最少"到"借用量最多"递增的。用一张图来直观对比:

flowchart TD
    subgraph 借用捕获["闭包只读访问"]
        V1["外部变量: msg = String"]
        C1["闭包: || println!({}, msg)"]
        V1 -.->|不可变借用| C1
    end

    subgraph 可变借用["闭包修改外部变量"]
        V2["外部变量: count = 0"]
        C2["闭包: || count += 1"]
        V2 -.->|可变借用| C2
    end

    subgraph 移动捕获["闭包获取所有权"]
        V3["外部变量: data = Vec<i32>"]
        C3["闭包: move || process(data)"]
        V3 -->|所有权转移| C3
    end

编译器会根据闭包体的使用方式自动选择最"弱"的捕获方式:

  • 如果只读变量,就用不可变借用(&T)
  • 如果修改了变量,就用可变借用(&mut T)
  • move 关键字则是强制所有捕获都走所有权转移

三、从代码看三种闭包 trait:Fn、FnMut、FnOnce

三种捕获方式对应着三个 trait,这是理解闭包的关键:

// ==========================================
// 示例 1: Fn —— 不可变借用,可多次调用
// ==========================================
fn demo_fn() {
    let greeting = String::from("你好");

    // 这里只读 greeting,闭包实现 Fn trait
    let say_hello = || {
        println!("{}", greeting);  // 仅仅是读取,&String
    };

    say_hello();  // 可以多次调用
    say_hello();  // greeting 还活着
    println!("闭包外面也能读: {}", greeting);
}

// ==========================================
// 示例 2: FnMut —— 可变借用,可多次调用但每次会改变状态
// ==========================================
fn demo_fn_mut() {
    let mut counter = 0;

    // 修改了 counter,闭包实现 FnMut trait
    let mut increment = || {
        counter += 1;  // 需要 &mut counter
        println!("计数器: {}", counter);
    };

    increment();
    increment();
    // println!("{}", counter);  // 这里不能读,因为 increment 持有可变借用
}

// ==========================================
// 示例 3: FnOnce —— 获取所有权,只能调用一次
// ==========================================
fn demo_fn_once() {
    let data = vec![1, 2, 3, 4, 5];

    // 将 data 的所有权转移到闭包内部
    let consumer = || {
        // data 被移入闭包,外面的 data 不再可用
        let sum: i32 = data.iter().sum();
        println!("消费掉了 data,和 = {}", sum);
        // data 在这里被 drop
    };

    consumer();  // 只能调用一次
    // consumer();  // 编译错误:consumer 已经被消耗
}

这三个 trait 有继承关系:Fn 继承自 FnMut,FnMut 继承自 FnOnce。换句话说,一个实现了 Fn 的闭包,必然也实现了 FnMut 和 FnOnce。

三(续)、move 到底做了什么

现在回来看 move 关键字。假设你有这样的代码:

use std::thread;

fn demo_move() {
    let name = String::from("张三");
    let age = 30;

    // 不加 move:编译器报错,因为线程可能比当前函数活得更久
    // 加上 move:name 的所有权被移入闭包(age 是 Copy 类型,直接拷贝)
    let handle = thread::spawn(move || {
        println!("名字: {}, 年龄: {}", name, age);
        // name 在这里被 drop,因为所有权在闭包里
    });

    // println!("{}", name);  // 编译错误:name 已被移走
    println!("年龄还能用: {}", age);  // 没问题,age 是 i32(Copy),被拷贝了一份

    handle.join().unwrap();
}

关键点:

  • name 是 String(非 Copy 类型),move 把它的所有权移入了闭包
  • age 是 i32(Copy 类型),move 只是拷贝了一份,外面的 age 还能用
  • 如果某个变量根本在闭包里没用到,move 也不会动它

再来看一个更微妙的例子:

fn demo_move_with_ref() {
    let text = String::from("原始数据");
    let text_ref = &text;  // 引用

    // move 移走的是引用本身,不是引用的目标
    let closure = move || {
        println!("{}", text_ref);  // text_ref 是 &&String,被移入闭包
    };

    closure();
    // text 还活着,因为移走的是引用而不是原值
    println!("text 还在: {}", text);
}

所以 move 移走的是被捕获变量本身。如果被捕获的是一个引用,那移走的就是这个引用,不影响引用指向的原值。

四、什么时候必须用 move,什么时候可以不用

必须用 move 的场景:

  1. 跨线程传递闭包:thread::spawn 要求闭包是 'static 的,move 能确保闭包不持有外部引用
  2. 返回闭包:如果函数要返回一个闭包,闭包捕获的变量生命周期必须足够长,move 把所有权给闭包
  3. 异步任务:tokio::spawn 同样要求 'static,如果闭包里引用了外部变量,需要 move

可以不用 move 的场景:

  • 闭包生命周期短于或等于外部变量(比如 Iterator 的 map、filter 等方法)
  • 只读访问,编译器自动处理不可变借用
fn when_move_is_needed() {
    let items = vec![1, 2, 3];

    // 场景1: 不需要 move —— 闭包在同步上下文中立即消费
    let doubled: Vec<_> = items.iter().map(|x| x * 2).collect();

    // 场景2: 必须 move —— 跨线程传递
    let items_for_thread = vec![4, 5, 6];
    std::thread::spawn(move || {
        println!("在线程中: {:?}", items_for_thread);
    });

    // 场景3: 必须 move —— tokio spawn
    let data_for_async = String::from("异步数据");
    tokio::spawn(async move {
        println!("异步任务: {}", data_for_async);
    });
}

还有一个常见的误用是把 move 和闭包性能混在一起看。不是加了 move 闭包就跑得更快——它只是改变了捕获方式,不涉及任何优化。在 Iterator 的适配器里,.map(|x| x + 1) 和 .map(move |x| x + 1) 编译后的机器码几乎一样,但后者会让代码更难读。不需要的时候就别加。

如果觉得某个闭包的 move 分析很绕,可以让 AI 画出变量的所有权流转图——从创建、捕获到最后一个使用位置,一目了然。我试过几次,比自己盯着编译器错误猜快得多。

五、总结

move 关键字看起来简单,但背后涉及 Rust 所有权系统的一整套规则。我的学习经验是:不要试图一次性把所有情况都记住,而是先理解编译器选捕获方式的三条路径(只读→Fn、修改→FnMut、消费→FnOnce),然后再把 move 理解为"强制把所有捕获升级为所有权转移"。

实际编码中,编译器的错误提示已经非常友好了——当你忘记加 move 时,它会直接告诉你需要加;当你加错了,它也会指出哪个变量的生命周期出了问题。多看几次编译错误,慢慢就形成肌肉记忆了。

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

相关推荐

FOFA奇技淫巧:从搜索语法到实战场景的深度挖掘

本文深入探讨了FOFA搜索语法在网络空间测绘中的高效应用,从基础语法到实战场景的深度挖掘。通过渗透测试、威胁狩猎、资产发现等实际案例,展示了如何利用FOFA精准定位目标系统、识别蜜罐、追踪威胁,并提供了合规使用指南和性能优化技巧,助力安全工作者提升效率。

weixin_32428571的博客 240

不只是匿名函数:深入 Rust 闭包的“捕获”本质与 Fn Trait

就通过。

2503_94037438的博客 562

高效搭建微信公众号爬虫全流程

微信公众号爬虫系统成功完成功能测试验证。该系统具备完整的数据采集与管理能力,支持多公众号内容爬取、数据存储与统计分析。通过命令行界面可执行爬取操作(如量子位、新智元等公众号),查看最新文章列表和系统统计信息。测试显示SQLite数据库正常存储数据,所有核心功能(多源支持、文章检索、数据统计)均运行良好。系统采用模块化设计,扩展性强,为后续接入真实API或网页爬取奠定了坚实基础,是AI内容聚合的优质开发平台。🎉

weixin_44975687的博客 1556

Rust语法核心机制解析:从所有权到并发编程的实战指南

在系统编程领域,内存安全和并发控制是开发者面临的核心挑战。传统语言如C++依赖开发者手动管理内存和同步,容易导致悬垂指针、内存泄漏和数据竞争等问题。Rust通过独特的所有权系统和借用检查器,在编译期强制执行内存安全规则,从根本上杜绝了这类错误。其核心机制包括所有权、借用与生命周期,这些概念共同构成了零成本抽象的基础,使得开发者无需运行时开销即可编写高效安全的代码。在并发编程方面,Rust的类型系统通过Send和Sync trait保障线程安全,配合通道和互斥锁等原语,让编写无数据竞争的并发代码成为可能。这些

weixin_30606461的博客 806

stm32f407VET6 系统学习 day01 GPIO 配置

stm32f407VET6 系统学习 day01 GPIO 配置 LED 蜂鸣器 按键的不讲了,之前讲过了

she666666的博客 8908

不止是打字机效果:手把手教你用SpannableStringBuilder打造Android富文本AI对话界面

本文详细介绍了如何使用SpannableStringBuilder在Android平台上构建专业级AI对话界面,涵盖流式文本处理、富文本解析、交互优化等核心技术。通过实战代码示例,帮助开发者实现类似DeepSeek的AI产品交互效果,提升用户体验和应用专业度。

weixin_28358083的博客 199

Rust 初学者最容易踩的 10 个坑:从编译器报错中总结的防坑手册

把编译错误当成对话,而不是障碍。每一次、每一次、每一次,编译器不是在对你说"你写错了"。它是在对你说:"按照 Rust 的内存模型,你现在的写法会导致一个运行时 bug,但我不允许这个问题发生。对于来说,这反而是加速学习的方式:你不需要先理解理论再写代码,而是通过编译器反馈倒推理解内存模型。不要试图第一次就写对:先写能编译的,再写正确的,最后写优雅的。学会读编译器错误是新手最好的老师。clone()不是罪:学习阶段为了绕过生命周期问题而 clone 是完全合理的,理解之后再回来优化。

no1coder的博客 4812

【人工智能之深度学习】21. 自动驾驶感知实战:YOLOv4复杂天气优化方案(BDD100K全代码+效果对比)

摘要:自动驾驶摄像头在雨雾天气下易受图像模糊、目标遮挡影响,导致YOLOv4检测精度骤降。本文基于BDD100K公开数据集(含多天气场景),设计三阶段优化方案:1)物理建模生成雨雾效果(雨滴线条+大气散射模型),将恶劣天气样本占比从20%提升至40%;2)在YOLOv4颈部嵌入CBAM注意力机制,强化模糊区域特征提取;3)L1剪枝(30%)+TensorRT量化实现轻量化。需特别说明:本文为教学虚拟案例,不可直接用于车载部署,实际落地需结合多传感器融合与ISO 26262认证。

专注于人工智能、软件开发、工控自动化、工厂数字化及智能化等领域,希望和大家共同进步! 1689

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

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

qq_36765170的博客 572

信创服务器(麒麟 V10 SP3)安装 NVIDIA GeForce RTX 5070 驱动

本文介绍了在麒麟V10 SP3系统上安装NVIDIA RTX 5070显卡驱动的详细步骤。首先需要关闭nouveau驱动,安装必要的编译环境和工具,确保内核版本与kernel-devel完全一致。最后运行NVIDIA驱动安装程序,关键选择包括启用DKMS支持、编译模块、禁用32位兼容和nouveau驱动。整个流程适用于海光CPU和Blackwell架构GPU的国产操作系统环境。

猿小白的博客 688

手把手教你学基于 Linux 的 NPU 固件开发-第 10 讲:可靠性设计(RAS)——让系统坚如磐石错误检测、纠正与上报机制(ECC、Parity)

组件推荐保护机制备注HBM/DDRScrubbing必须开启,定期巡检片上 SRAMECC(权重/激活值),Parity(指令)权衡面积与可靠性计算单元ABFT或DMR(关键路径)防止计算逻辑错误片上网络CRC重传保证数据传输完整性系统软件AER 上报CE 监控自动恢复闭环管理,杜绝 SDC运维策略预测性维护Checkpoint变被动为主动核心心法(信任硬件,但必须验证。在纳米尺度下,错误是必然发生的物理现象。

MHD0815的博客 93

rust: Fan-out/Fan-in Pattern

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

Geovin Du Dream Park 166

【软考高项】【计算专题】- 3 - 进度类 - 双代号网络图

共需压缩 20 天。在双代号网络图中,工作一般使用箭线表示,任意一条箭线都需要占用时间、消耗资源,工作名称写在箭线的上方,而消耗的时间则写在箭线的下方或者工作后面。反映的是前后工作的交接点,节点中的编号可以任意编写,但应保证后续工作的节点比前面节点的编号大,即上图图中的1⃣️4⃣️ 即表示 B 活动和 D 活动间有依赖关系,D 活动的开始,依赖 B 活动的结束。B活动完成了一半, 各计划的实际支出为A活动6500元, B活动1000元, C活动280元, D。

欢迎来到我的博客,一起探索代码里的世界! 4566

Rust组织管理(AI回答)

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

yaoct的博客 153

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0, 兼容Win7/Win10/WinXP,解压就可用。

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

如果有云服务的话,可以基于 RustDesk 的 hbbs / hbbr 自己部署一套,不过会碰到一个问题:每台电脑装完客户端,都得手动去设置里填三样东西——ID 服务器、中继服务器、Key。填错一个就连不上,还得远程指导同事操作。这篇记录两种解决办法,以及云端编译的完整流程。内容基于 RustDesk 1.5.3 的源码。

风声的专栏 635

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

Rust LeetCode443 算法题解

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

weixin_43379230的博客 185

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

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的博客 449

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

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

wfly blog 444

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

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

olegja3d的博客 213

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

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

ZenovaEdgeOS的博客 561

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的博客 169

【Rust算法硬核拆解】LeetCode 334 递增的三元子序列(贪心+O(1))

【LeetCode 334 递增的三元子序列】用一次扫描贪心实现:时间 O(n)、空间 O(1)。附 13 个单测与正确性说明。

weixin_43379230的博客 354

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

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

2601_96785163的博客 304

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

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

aifannihao的博客 222

rust: Push & Pull Pattern

本项目基于Rust实现珠宝行业全流程的推-拉(Push&Pull)消息模式,采用领域驱动设计(DDD)六层架构。通过JewelryPushPullHub通道实现生产者推送与消费者拉取解耦,12个业务部门(如采购、设计、质检等)作为独立消费者,按供应链顺序串行或并发处理消息。系统集成重试熔断、线程安全日志(按日期/等级分文件)、内存仓储及依赖注入容器,确保高并发下流程可追溯、弹性可靠。演示涵盖串行调度、批量并发、端口契约调用等场景,完整呈现企业级消息型模式的核心能力。

Geovin Du Dream Park 119
上一篇: Tokio 同步原语:Mutex、RwLock 和 Semaphore 在异步世界里怎么用
下一篇: WebAssembly AI 插件缓存策略:把模型权重缓存在 IndexedDB 里
第一程序员
博客等级 码龄1年 1万+粉丝 1827原创
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值