Rust基础

最新推荐文章于 2024-05-24 14:54:06 发布
最新推荐文章于 2024-05-24 14:54:06 发布
阅读量140 收藏
点赞数 1
文章标签： rust 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_47437411/article/details/129692757
版权

Rust语法基础

本文源自观看B站Rust编程语言入门教程记录下来的重点笔记
视频链接：Rust编程语言入门教程（Rust语言/Rust权威指南配套）

文章目录

第三章

变量与可变性

shadow：定义了一个变量后，用let再给同名变量赋值即为shadow，可改变原值（原值不一样的类型也可以）。
如果用let mut定义了一个变量类型后，这个变量不能赋值给不同类型。

数据类型

rust是静态编译语言，在编译时必须知道所有变量的类型。有时可能的类型比较多，编译器无法自动推断，就必须添加类型标注，否则编译会报错（如把String转为整数的parse方法）
标量类型：整数、浮点、布尔、字符

  • 整数字面值 ex：十进制：98_222，十六进制：0xff，八进制：0o77，二进制：0b1111_000，字节：b’A’。允许使用类型后缀如57u8；整数的默认类型是i32（速度较快）
  • 整数溢出：调试模式下会检查整数溢出，如果溢出程序在运行时会panic；在发布模式下（-- release）编译，rust会执行“环绕”操作比如u8是0-255，256会变成0···但程序不会panic
  • 浮点类型：f64为默认类型，因为在现代cpu上f64（双精度）和f32（单精度）速度差不多，而且精度更高。
  • 布尔类型：1字节，true与false
  • 字符类型：rust中的字符类型char是Unicode标量值的表示，使rust在处理字符串时能准确地表示Unicode字符，使用单引号，4字节，Unicode标量值能表示比ASCII多得多的字符：甚至emoji；Unicode没有“字符”概念，因为它是基于Unicode标量的（由一个或多个Unicode代码单元组成）

复合类型：
可以将多个值放在一个类型里，rust提供了两种基础的复合类型：tuple和数组。
Tuple：

  • tuple中每个位置对应一个类型，各元素类型不必相同；长度固定，声明后无法改变
  • 可以用模式匹配来解构一个tuple来获取元素的值
  • 用.索引号访问tuple里的元素
  • ex：let tup(i32, f64, u8) = (500, 6.4, 1); let (x, y, z) = tup; println!(tup.1);

数组：

  • 可以将多个值放在一个类型里，每个元素类型相同，数组长度是固定的
  • 放在栈上而不是堆上，保证有固定数量的元素。（vector更灵活）
  • 表示形式：let a:[i32; 5] = [1, 2, 3, 4, 5] 或 let a = [3(初始值); 5(元素个数)];
  • 访问：数组是栈上分配的单个块的内存，可以使用索引访问数组的元素
  • 如果访问越界，那么编译时会通过，但运行时会报错（panic），不允许继续访问相应地址的内存

函数

声明使用fn关键字，针对函数和变量名rust都适用snake case命名规范：所有字母都是小写，单词之间使用下划线分开。并且不像C++函数生命位置与调用顺序无关（没有前置声明）

  • 参数：行参（parameters）实参（arguments），在函数签名里，必须声明每个参数的类型
  • 函数体中的语句与表达式：函数体由一系列语句组成，可选的由一个表达式结束；rust是基于表达式的语言；语句不返回值所以不能将let将一个语句赋值给一个变量
  • 函数的返回值：在->符号后声明函数返回值的类型，但不可以为返回值命名；函数体中最后一个表达式的值为返回值

控制流

if，else
循环：

  • loop：用break 加表达式的值退出
  • while
  • for：for i in elements.iter()类似于迭代器，更安全且简洁
  • range：指定一个开始数字和一个结束数字，Range可以生成他们之间的数字（不包含结束，左开右闭），rev方法可以反转Range。for number in (1..4).rev() {} 输出321

第四章

所有权

所有权是rust最独特的特性，让rust无需垃圾回收器（GC）就可以保证内存安全。

  • 所有程序在运行时都需要必须管理它们使用计算机内存的方式
    • 有些内存有垃圾收集机制，在程序运行时，它们会不断地寻找不再使用的内存（如C#和java）
    • 在其他语言中，程序必须显示的分配内存和释放内存
  • 但rust采用了第三种方式：
    • 内存是通过一个所有权系统管理的，其中包含一组编译器在编译时进行检查的规则
    • 当程序运行时，所有权不会减慢程序运行的速度（因为内存管理相关的工作都发生在编译时）

Statck vs Heap：
在像rust这样的系统级编程语言下，一个值在stack还是在heap上有重大影响；在代码运行时这两者都是你可用的内存，但它们的结构很不相同。

  • Stack按值的接受顺序来存储数据（压入栈），按相反的顺序将它们移除（弹出栈）（后进先出）

  • 所有存储在栈上的数据都必须拥有已知的固定的大小

    • 编译时大小未知的数据或者运行时大小发生改变的数据都需要存放在堆上

  • 把值压到栈上不叫分配

  • 因为指针是固定大小的所以可以存放在栈上

    • 但如果想要实际数据，必须使用指针来定位（使用栈中的指针指向堆中的数据）

  • Heap内存组织差一些，当把数据放入heap时会请求一定数量的空间

  • 操作系统在堆中找到一块足够大的空间，把它标记为在用，并返回一个指针，也就是这个空间的地址；这个过程叫做在heap上进行分配

  • 把数据压到栈上要比在heap上分配快得多：因为操作系统不需要寻找用来存储新数据的空间，那个位置永远都在栈的顶端

  • 然而在heap上分配空间需要做更多的工作：操作系统首先找到一块儿足够大的空间存放数据，然后要做好记录方便下次分配

访问数据：

  • 访问堆上的数据要比在栈上更慢，因为需要通过指针才能找到堆中的数据
    • 对于现代的处理器来说，由于缓存的缘故，当指令在内存中跳转的次数越少，访问速度越快
  • 如果数据存放的比较近，访问速度就快一些（栈）
  • 如果数据之间的距离比较远，访问速度就慢一些（堆）
    • 在堆上分配大量的空间也需要时间

函数调用：
当代码调用函数时，值被传入到函数（包括指向堆区的指针）；函数本地的变量被压入到栈上，当函数结束后，这些值会从stack上弹出

所有权存在的原因：
解决存放在堆中数据的内存浪费问题；加入一个结构体中存放了一个字符串类型（动态数据类型，在堆上分配）和一个整形（固定类型大小，在栈上分配），如果多次复制该结构体，会造成结构体中的字符串在堆上分配多次造成内存空间浪费，这时rust凭借所有权可以将字符串字段的所有权转移给结构体的所有者，当所有者离开作用域时，字符串字段的内存将被自动释放，从而避免重复占用堆上的内存。 ex：let s = String::from("hello"); let p = Person { name: s, age: 30 };在这个例子中，一个字符串值"hello"被动态分配在堆上，并将其所有权赋值给变量s。然后，将s的值赋值给Person结构体的name字段，这意味着字符串的所有权被转移给了Person结构体变量p。当p变量离开作用域时，字符串的内存将被自动释放。

所有权规则、内存与分配

所有权规则：

  • 每个值都有一个变量，这个变量是该值的所有者
  • 每个值同时只能拥有一个所有者
  • 当所有者超出作用域时，该值将被删除

String类型：

  • 一个String由三部分组成：
    • 一个指向存放字符串内容的内存的指针
    • 一个长度len（存放字符串内容所需要的字节数）
    • 一个容量（从操作系统总共获得内存的总字节数）
  • 上面这些东西都存放在栈上，存放字符串内容的部分在堆上
  • 创建：let s = String::from("Hello");
  • String类型的值可以修改，而字符串字面值不可以修改，因为它们处理内存的方式不同
  • 为了支持可变性，需要在堆上分配内存（通过调用String::from）来保存编译时未知的文本内容；而字符串字面值在编译时就知道其内容了，其文本内容直接被硬编码到最终的可执行文件里了（速度快，高效，因为其不可变性）

内存与分配：
rust中对某个值来说，当拥有它的变量走出作用范围时，内存会立即自动的交还给系统（内存释放）；即自动调用drop函数

变量和数据交互的方式：

  • 移动（Move）：s2复制s1，s1失效（相当于将s1移动到s2）；rust隐含的一个设计原则：不会自动创建数据的深拷贝；就运行时的性能而言，任何自动赋值的操作都是廉价的
  • 克隆（Clone）：如果真想对堆上的String数据进行深度拷贝，而不仅仅是栈上的数据，可以使用克隆方法

Stack上的数据：复制（Copy）

  • Copy trait，一般存放在栈上的数据类型自动默认有该接口
  • 如果一个类型实现了这个trait，那么旧的变量在赋值后仍然可用
  • 如果一个类型或者该类型的一部分实现了Drop trait，那么rust就不允许它再去实现Copy trait了
  • ex：
    let x = 5; 
    let y = x; 
    println!("adda {:?}", x); // Output：5
    // 这段代码中的变量 x 拥有整数值 5 的所有权，然后将其赋值给变量 y。由于 i32 类型是 Copy trait 的实现类型，因此这个赋值操作不会移交整数值的所有权，而是复制一份新的值给 y，因此 x 和 y 都拥有整数值 5 的所有权。

所有权与函数

在语义上将值传递给函数跟把值赋给变量是类似的：将发生移动或复制（取决于不同的变量类型）

引用与借用

把引用&作为函数参数的行为叫做借用
可变引用（&mut）：

  • 有一个重要的限制：在特定作用域内，对某一块数据只能有一个可变的引用，但可以有多个不可变的引用
    • 这样的好处是可在编译时防止数据竞争
  • 以下三种行为下会发生数据竞争：
    • 两个或多个指针访问同一个数据
    • 至少有一个指针用于写入数据
    • 没有使用任何机制来同步对数据的访问
  • 可以通过创建新的作用域，来允许非同时的创建多个可变引用
  • 不能同时存在可变引用和不可变引用，因为这时如果再对引用的变量操作会报错

悬空引用：

  • 悬空指针：一个指针引用了内存中的某个地址，而这块内存可能已经释放了
  • rust可以保证引用永远不是悬空引用，编译器会保证引用在离开作用域之前数据不会离开作用域

字符串切片：

  • 指向字符串中一部分内容的引用&s[..]
  • 字符串切片在 Rust 中是不可变引用类型。字符串切片是&str类型的变量，它是对原始字符串的一个不可变引用。因为它是一个引用类型，所以它本身不拥有所引用的数据的所有权，而是借用了原始字符串的所有权。同时，由于它是不可变引用类型，所以它不能修改原始字符串中的数据

第五章

struct定义和实例化

  • 使用struct关键字，并为整个struct命名
  • 要想使用struct需要创建struct的实例：
    • 为每个字段指定具体的值，不能遗漏某一字段
    • 无需按照声明的顺序指定
  • 使用点标记法访问
  • 一旦struct实例是可变的，那么实例中所有的字段都是可变的
  • 字段初始化可以简写；当字段名与字段值对应变量名相同时，就可以使用字段初始化简写的方式
  • stuct更新语法
  • tuple struct
  • struct里可以存引用，但需要生命周期

输出格式化

因为简单的类型变量自带Display这个trait所以用{}可以直接输出，但是像struct这种类型则需要加上#[derive(Debug)]来显示打印调试的功能，这样就可以使用{:#?}来格式化输出

struct方法

  • 方法和函数类似：fn 关键字、名称、函数、返回值
  • 方法与函数不同之处：
    • 方法是在sturct（或enum、trait对象）的上下文中定义
    • 第一个参数是self，表示方法被调用的struct实例
      ex：
struct Rectangle {
    width: u32,
    length: u32,
}

impl Rectangle {
    fn area(&self) -> u32{
        self.width * self.length
    }
}

方法调用的运算符

  • Rust没有指针用的->运算符
  • Rust会自动引用或解引用；在调用方法时就会发生这种行为
  • 在调用方法时自动添加&、&mut或*，以便object可以匹配方法的签名

关联函数

  • 可以在impl块里定义不把self作为第一个参数的函数，他们叫关联函数（不是方法） 例如：String::from()
  • 关联函数通常用于构造器
  • :: 符号

impl块

每个struct允许拥有多个impl块

第六章

枚举

枚举允许我们列举所有可能的值来定义一个类型

// 定义枚举
enum IpAddr{
    V4,
    V6,
}

// 枚举值
let four = IpAddr::V4;
// 枚举的变体都位于标识符的命名空间下，使用两个冒号::进行分隔

允许数据附加到枚举的变体中：
优点：

  • 不需要额外使用struct
  • 每个变体可以拥有不同的类型以及关联的数据量

ex：

enum IpAddr{
    V4(u8, u8, u8, u8), // 无论是数字、字符串、结构体还是枚举类型都能嵌入
    V6(String),
}

为枚举定义方法：也使用impl关键字

Option枚举

定义与标准库中，在预导入模块中，描述了某个值可能存在（某种类型）或不存在的情况
Rust没有Null但是它提供了一个类似Null概念的枚举 - Option<T>
标准库中的定义：

enum Option<T> {
    Some(T),
    None,
}
// 这三者都包含在预导入模块中，均可直接使用

这样Option<T>比Null好在哪儿呢？

  • Option<T>与T是不同的类型，不能把Option<T>直接当成T来用（比如相加减）

Match

强大的控制流运算符，允许一个值与一系列模式进行匹配，并执行匹配的模式对应的代码；模式可以是字面值、变量名、通配符…
ex:

enum Car{
    laosilaisi,
    benchi,
    aodi,
    hamadi,
}

fn trans(car: Car) -> String {
    // 必须要穷举所有的模式
    match car {
        Car::laosilaisi => String::from("劳斯莱斯"),
        Car::benchi => String::from("奔驰"),
        Car::aodi => String::from("奥迪"),
        // Car::hamadi => String::from("哈马迪"),
        _ => (),// 但使用_通配符可以替代其余没列出来的值
    }
}

fn main() {
    let c:Car = Car::aodi;
    let x = trans(c);
    
    println!("{}", x);

}

if let

  • 处理只关心一种匹配而忽略其他匹配的情况
  • 更少的代码，更少的缩进
  • 放弃了穷举的可能
  • 相当于match的语法糖
  • 搭配else

ex：

if let Car::aodi = car {
    String::from("奥迪")
} else {
    String::from("其他车")
}

第七章

路径

私有边界：

  • 模块不仅可以组织代码，还可以定义私有边界
  • 如果想把函数或struct等设为私有，可以把它放到某个模块当中
  • Rust中所有条目（函数、模块、方法、enum、struct、常量）默认是私有的

ex：

mod front_of_house {
    // 注意以下模块和方法如果不加pub在下方调用时都会报错
    pub mod hosting {
        pub fn add_to_house() {}
    }
}

pub fn eat_at_res() {
    crate::front_of_house::hosting::add_to_house(); // 绝对路径

    front_of_house::hosting::add_to_house(); // 相对路径
}

super关键字：

  • 用来访问父级模块路径中的内容，类似文件系统中的…

比如上面的例子：

        pub fn add_to_house() {
            // 因为上级有两个mod所以要使用两次super
            super::super::eat_at_res(); // 相对路径
            crate::eat_at_res(); // 绝对路径
        }

pub struct：

  • pub放在struct前：
    • struct是公共的
    • struct字段默认是私有的
  • struct字段要单独设置pub来变成公有

pub enum：

  • pub放在enum前：
    • enum是公共的
    • enum的变体也都是公共的

use的习惯用法：

  • 函数：将函数的父级模块引入到作用域（指定到父级）
  • struct，enum等指定到完整路径（指定到本身）
  • 同名条目：指定到父级；或使用as创建别名

将模块内容移动到其他文件：

  • 模块定义时，如果模块后边是“；”，而不是代码块：
    • Rust会从与模块同名的文件中加载内容
    • 模块树的结构不会变化
  • 随着模块逐渐变大，该技术可以让你把模块的内容移动到其他文件中

第八章

Vector

创建Vector：

let v: V<i32> = Vec::new();
let v = vec![1, 2, 3]; // 初始值创建方式用vec!宏

// 即使初始化时没有指明存储类型，rust可以上下文推断出类型
let mut v = Vec::new();
// 更新vector
v.push(3);
v.push(4);

读取Vector中的元素：

  • 索引（类似字符串切片）&v[0]
    • 数组越界时发生panic
  • get方法（返回的事Option值）
    • 数组越界时返回None

所有权和借用规则

  • 不能在同一作用域内同时拥有可变和不可变引用
    ex：
let v = vec![1, 2, 3];
let first = &v[0];
v.push(6); // 报错
// 试想一下vector工作原理，vector是动态分配的连续容器，如果push之后容器找了一块扩充的新的内存地址，而first还指向原内存地址，那么就会发生内存泄漏（所以借用规则防止该情况发生）

vector遍历
ex：

let v = vec![1, 2, 3];
// 注意是引用，如果要修改v里的值就用&mut，然后用解引用符号*
for i in &v{
    println!("{}", i);
}
println!("{:?}", v);

vector还可以与枚举enum配合使用

String

更新String：

  • push_str()方法：把一个字符串切片附加到String
  • push方法：把单个字符附加到String
  • +：连接字符串；相当于add(self, s: &str)
  • format!：连接多个字符串
    • 和println!类似，但返回字符串
    • 不会获得参数的所有权

Rust不允许对String进行索引
切割String：

  • 可以使用[]和一个范围来创建字符串的切片
    • 必须谨慎使用
    • 如果切割时跨越了字符边界，程序就会panic

遍历String

  • 对于标量值：chars()方法
  • 对于字节：bytes()方法

HashMap

  • HashMap用的比较少，不在预导入模块（Prelude）中
  • 标准库对其支持较少，没有内置的宏定来创建HashMap
  • 数据存储在heap上
  • 同构的，在一个HashMap中：
    • 所有的K必须是同一种类型
    • 所有的V必须是同一种类型

HashMap和所有权：

  • 对于实现了Copy trait的类型类如i32，值会被复制到HashMap中
  • 对于拥有所有权的值例如String，值会被移动，所有权转移给HashMap
  • 如果将值的引用插入到HashMap，值本身不会移动

更新HashMap：

  • entry方法：检查指定的HashMap中Key是否对应一个V；如果不存在V则使用or_insert()方法插入

第九章

Result枚举

enum Result<T, E>{
    Ok(T), // T：操作成功时Ok变体里返回的数据类型
    Err(E), // E：操作失败时Err变体里返回的数据类型
}

处理Result的一种方式：match表达式
和Option一样，Result及其变体也是由prelude带入作用域的
ex：

use std::{fs::File};
fn main() {
    let file = File::open("hello.txt");
    let _f = match file {
        Ok(file) => file,
        Err(e) => {
            panic!("Error opening file {:?}", e)
        }
    };
}

unwrap：match表达式一个快捷方法

  • 如果Result结果是Ok，返回Ok里面的值
  • 如果Result结果是Err，调用panic！宏
    expect：和unwrap类似，但可指定错误信息

传播

？运算符：
传播错误的一种快捷方式

  • 如果Result是Ok，Ok中的值就是表达式的结果，然后继续运行程序
  • 如果Result是Err，Err就是整个函数的返回值，就像使用了return
  • 可以链式调用

？与from函数：
用于针对不同的错误原因返回同一种错误类型，只要每个错误类型实现了转换为所返回的错误类型的from函数

？与main函数：

  • main函数的返回类型是：（）
  • main函数的返回类型也可以是：Result<T, E>
  • Box是trait对象

第十章

泛型

  • 提高代码复用能力，处理重复代码的问题
  • 泛型是具体类型或其他属性的抽象代替：
    • 你编写的代码相当于一个模版，里面有一些占位符
    • 编译器在编译时将“占位符”替换为具体类型
  • 例如：`fn largest(list: &[T]) -> T {…}
  • 类型参数：
    • 很短，通常就一个字母
    • 驼峰命名
    • T：type的缩写

函数定义中的泛型

  • 参数类型
  • 返回类型

Struct定义中的泛型

  • 可以使用多个泛型的类型参数
#[derive(Debug)]
struct Car<T, U> {
    door: T,
    people: U,
}

fn main() {
    let x = Car {door:3, people: "sdad"};
    println!("{:#?}", x);
}

Enum定义中的类型

  • 可以让枚举的变体持有泛型数据类型
    • 例如Option<T>, Result<T, E>

方法定义中的泛型

  • 为struct或enum实现方法的时候，可以在定义使用泛型
  • 注意：
    • 把T放在impl关键词后，表示在类型T上实现方法
      • ex：impl<T> Point<T>
    • 只针对具体类型实现方法（其余类型没实现方法）：
      • ex：impl Point<f32>
  • struct里的泛型类型参数可以和方法的泛型类型参数不同

泛型代码的性能：

  • 使用泛型的代码和使用具体类型的代码运行速度是一样的
  • 单态化：
    • 在编译时将泛型替换成具体类型的过程

trait

格式

pub trait Summary{
    fn summarize(&self) -> String;
}

pub struct NewsArticle {
    pub headline: String,
    pub baseline: String,
}

impl Summary for NewsArticle{
    fn summarize(&self) -> String {
        format!("{}, {}", self.headline, self.baseline)
    }
}

Trait作为参数

  • impl Trait语法：适用于简单情况
  • Trait bound语法：可用于复杂情况
  • 使用+指定多个Trait bound
  • Trait bound使用where子句
    • 在方法签名后指定where子句
vo很懒
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
rust基础
fengxiandada的博客
08-06 1584
rust基础学习笔记
Rust基础语法
大佛拈花的博客
09-13 3149
默认是不可变的，当定义相同名称的变量的时候，会隐藏原来的变量。执行x=x+1 是相当于隐藏的值+1进行新的变量x的赋值操作。上面的代码1是i32位的，现在用i64来接受，那么会显示编译错误。1 变量默认是不变的，但是常量总是不变的，并且不能对常量使用let关键字。因为上面的正是一个语句，所以不产生返回值，那么下面的语句是错误的。对于Rust变量来说，默认是不可变的，那么是否可以说是常量呢？使用场景是不需要使用迭代元素的值，那么变量可以使用_替代。在rust中，返回值是表达式，因此不能使用分号结束。
Rust基础教程
weixin_51551879的博客
03-19 540
Rust基础教程 Rust简介 安装Rust Rust rustup 第一个Rust应用 Rust项目管理工具Cargo 使用RustRover开发Rust应用 使用VSCode开发Rust应用 Cargo项目结构分析 Rust关键字和标识符 Rust命名规范 Rust注释 Rust变量 Rust不可变变量 Rust可变变量 Rust常量 Rust常量和不可变变量的区别 Rust隐藏变量（Shadowing） Rust数据类型 Rust整数类型 Rust浮点型 Ru
Rust语言基础教程学习【一】（Rust基础语法、数据类型）
cyf1294311560的博客
05-06 2101
Rust语言基础教程学习【一】（Rust基础语法、数据类型），包括变量、常量以及各种数据类型（标量类型、复合类型）
【Rust 基础篇】Rust 生命周期
繁依Fanyi的博客
07-09 721
生命周期描述了引用的有效期，即引用可以安全地访问其引用的数据的时间范围。在 Rust 中，生命周期是一种编译时的静态检查机制，用于确保引用的安全性。生命周期注解是一种方式，通过标记引用之间的关系，让编译器能够推断出引用的有效范围。本篇博客详细介绍了 Rust 生命周期的定义、使用和相关概念。通过生命周期注解和生命周期省略规则，我们可以指定引用的有效范围，并确保代码的安全性和正确性。希望本篇博客对你理解和应用 Rust 生命周期有所帮助。
Rust 基础
只为龙舞的博客
10-15 786
Rust 支持变量的覆盖，也就是可以定义一个与之前变量同名的新变量，此时一般称之为第一个变量被第二个隐藏（Shadowing） 了，这意味着当使用这个变量的名称时，编译器将使用第二个变量。例如数组类型[i32;不过有时根据值及其使用方式，编译器可以推断出我们想要用的类型，比如前面截图上变量声明后面灰色的 i32 usize， 这两个就是变量类型， 灰色表示是编译器自动推导出来的而非开发者主动指定的。标量（scalar）类型代表一个单独的值，比如前面的代码中的变量都是标量类型的，变量都是只有一种类型。
rust基础学习
iceforg123的博客
08-08 1025
rust基础学习
Rust 基础语法学习
NameisBoy的博客
08-27 1539
hello rust！
Rust 基础: Module 模块系统
超悠閒的博客
11-10 715
Rust 基础: Module 模块系统 文章目录Rust 基础: Module 模块系统正文1. 简介2. 文件内模块3. 单文件模块4. 目录为模块5. 目录下其他模块其他资源参考连接完整代码示例 正文 1. 简介 在 Rust 中的模块系统感觉与 ESM(ECMAScript Module)非常类似，只是更加严谨，同时也限制了作用域与可见性 模块系统实际上用关键字 mod 就能进行区分，同时也跟 ESM 一样，一个文件将被视为一个单独的模块；而目录则与 ESM 类似，由特殊名称的文件 mod.rs 为
rust基础学习记录
m0_37626922的博客
03-23 92
rust基础学习笔记，欢迎讨论
rust基础教程-0基础
07-24
rust基础 环境搭建 cargo 所有权 包 生命周期 闭包 面向对象 指针 trait
rust基础知识分享.doc
03-25
rust基础知识分享.doc
原创rust基础学习源码
01-16
刚学习rust时写的，包含最基本的语法等等。初学rust的好例子，直接新建工程后，用里面的main.rs替换你本地文件即可。
Rust 基础系列1 创建并运行你的首个 Rust 程序.docx
02-21
安装完成后，打开你的命令行工具，输入以下命令来创建一个新的 Rust 项目： cargo new my_first_rust_program 这将在当前目录下创建一个名为 my_first_rust_program 的新目录，里面包含了一个简单的 Rust 项目结构...
rust-infra:关于Rust基础架构的信息
05-20
我们使用Travis测试生活在rust-lang / rust之外的rust-lang板条箱。 。 越来越多的事情要做。 。 旧信息，有时仍然值得一看。 此仓库是私人的，因为它包含机密。 。 AWS的登录页面。 。 我们的在线Rust评估程序...
Rust 程序设计：三层架构的“全局数据”的“依赖注入”设计方法
程序猿视角
05-18 516
其实，这样做并不违反三层架构原则，因为 main 函数并非三层架构中的 api 层，而是承担起了三层架构的组织者的角色 —— 这就是所谓的“依赖注入” 方法。Rust 程序分三层：api、logic、data，其中数据 Server 在 data 中定义，如果在 data 内定义成全局静态变量，api 层可以看不到 Server，但是 data层的代码访问全局变量 Server 必须是 unsafe 的。然而，在程序运行期间，其他模块应该通过接口或抽象层与data层进行交互，以保持代码的封装性和模块化。
Gb 2024-05-22开源项目日报Top10
老孙正经胡说
05-22 1066
根据Github Trendings的统计，今日(2024-05-22统计)共有10个项目上榜。
Rust面试宝典第14题：旋转数组
hope_wisdom的技术博客
05-22 355
一个问题的解决方案可能远不止一种，正所谓“条条大路通罗马”，如何在众多解决方案中找出最优解，实际上非常考验软件开发工程师的综合能力。从多个角度、多个维度分析和思考问题，是一种非常有效的思维方式，可以帮助我们更全面地理解问题，并找到更好更优的解决方案。
rust语言一些规则学习
最新发布
weixin_42152531的博客
05-24 254
主要用于将数据集中的每个元素转换为另一个形式，创建出一个新的数据集（不改变原数据），适用于无副作用的数据转换场景。比如，将一个整数集合转换为对应的字符串集合，或对每个元素应用某种计算规则得到新的值并创建新的集合。for循环则更加灵活，既可以用作简单的遍历查看元素，也可以用来直接修改原数据集中的元素。当你需要对集合中的每个元素执行可能包含副作用的操作（如修改元素、打印输出、基于当前元素影响外部状态等）时，for循环是更合适的选择。
rust权威指南 pdf
06-21
作为Rust语言的权威指南，该书不仅涵盖了Rust语言的基础知识，还深入讲解了Rust语言的高级特性，如内存管理、安全性、并发等方面。此外，书中还包括了大量的实例和案例，可以帮助读者更深入地理解Rust语言。 对于...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值