Rust 学习笔记:模式的语法

Rust实战系列-基本语法 i + j}add 函数接收两个整数类型参数,绑定到本地变量 i 和 j,返回一个整数Rust 的函数定义语法:Rust 在定义函数的时候需要指定参数的类型和函数返回值的类型。明确的生命周期注释 表示在 add_with_lifetimes() 函数范围内引入生命周期 ‘a’ 和 ‘b’,&'a i32 读作 “对生命周期为 a 的 i32 的引用”通常,这些额外信息为 Rust 编译器提供了函数外部数据的信息。使用引用(类型前面的 & 符号表示)的函数存在函数作用域之外的数据。 阅读详情

Rust 学习笔记:模式的语法

匹配字面值

可以直接将模式与字面量进行匹配。

    let x = 1;

    match x {
        1 => println!("one"),
        2 => println!("two"),
        3 => println!("three"),
        _ => println!("anything"),
    }

匹配命名变量

命名变量是匹配任何值的不可反驳的模式。但是,当在 match、if let 或 while let 表达式中使用命名变量时,会出现一个复杂问题。因为这类表达式中的每一种都开始一个新的作用域,所以在表达式内部作为模式的一部分声明的变量将在外部遮蔽同名的变量,所有变量都是如此。

    let x = Some(5);
    let y = 10;

    match x {
        Some(50) => println!("Got 50"),
        Some(y) => println!("Matched, y = {y}"),
        _ => println!("Default case, x = {x:?}"),
    }

    println!("at the end: x = {x:?}, y = {y}");

输出:

Matched, y = 5
at the end: x = Some(5), y = 10

第一个匹配分支中的模式与定义的 x 值不匹配,因此代码继续。

第二个匹配分支中的模式引入了一个名为 y 的新变量,该变量将匹配 Some 中的任何值。因为我们在匹配表达式的新范围内,这是一个新的 y 变量,而不是我们在开始时用值 10 声明的 y。这个新的 y 绑定将匹配 Some 中的任何值,也就是我们在 x 中的值,因此该值为 5。

匹配表达式完成后,它的作用域结束,内部 y 的作用域也结束。

要创建一个比较外部 x 和 y 值的匹配表达式,而不是引入一个掩盖现有 y 变量的新变量,我们需要使用匹配保护条件。我们将在后面讨论 match guard。

多个模式

您可以使用 | 语法匹配多个模式,这是模式或操作符。

    let x = 1;

    match x {
        1 | 2 => println!("one or two"),
        3 => println!("three"),
        _ => println!("anything"),
    }

在上面的代码中,我们将 x 的值与匹配分支进行匹配,其中第一个有一个 or 选项,这意味着如果 x 的值与该分支中的任何一个值匹配,则该分支的代码将运行。

用 ..= 匹配值的范围

..= 语法允许我们匹配一个包含范围的值。

在下面的代码中,当模式匹配给定范围内的任何值时,该分支将执行:

    let x = 5;

    match x {
        1..=5 => println!("one through five"),
        _ => println!("something else"),
    }

编译器在编译时检查范围是否为空,因为 Rust 可以判断范围是否为空的类型只有 char 和数值,所以范围只允许使用这两类。

下面是一个使用 char 值范围的例子:

    let x = 'c';

    match x {
        'a'..='j' => println!("early ASCII letter"),
        'k'..='z' => println!("late ASCII letter"),
        _ => println!("something else"),
    }

解构数据结构

我们还可以使用模式来解构结构体、枚举和元组,以使用这些值的不同部分。让我们遍历每个值。

解构结构体

假如我们有一个 Point 结构体,它有两个字段 x 和 y,我们可以使用带有 let 语句的模式将其分开。

struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p = Point { x: 0, y: 7 };

    let Point { x: a, y: b } = p;
    assert_eq!(0, a);
    assert_eq!(7, b);
}

这段代码创建了变量 a 和 b,它们匹配 p 结构体的 x 和 y 字段的值。这个例子表明,模式中变量的名称不必与结构体的字段名称匹配。但是,通常将变量名与字段名相匹配,以便更容易记住哪个变量来自哪个字段。

因为这种常用用法,也因为写 let Point { x: x, y: y } = p; 包含大量重复,Rust 对匹配结构域的模式有一个简写:你只需要列出结构域的名称,从模式创建的变量将具有相同的名称。如下所示:

struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p = Point { x: 0, y: 7 };

    let Point { x, y } = p;
    assert_eq!(0, x);
    assert_eq!(7, y);
}

这段代码创建了与 p 变量的 x 和 y 字段匹配的变量 x 和 y。结果是变量 x 和 y 包含来自 p 结构体的值。

我们还可以将字面量作为结构体模式的一部分进行解构,而不是为所有字段创建变量。这样做允许我们测试某些字段的特定值,同时创建变量来解构其他字段。

以下是一个匹配表达式,它将 Point 值分为三种情况:直接位于 x 轴上的点(当 y = 0 时为真)、位于 y 轴上的点(x = 0),或者两个轴上都没有点。

fn main() {
    let p = Point { x: 0, y: 7 };

    match p {
        Point { x, y: 0 } => println!("On the x axis at {x}"),
        Point { x: 0, y } => println!("On the y axis at {y}"),
        Point { x, y } => {
            println!("On neither axis: ({x}, {y})");
        }
    }
}

第一个分支将匹配 x 轴上的任何点,通过指定如果 y 字段的值与 0 匹配,则 y 字段匹配。该模式仍然创建一个 x 变量,我们可以在该分支的代码中使用该变量。

类似地,第二个分支匹配 y 轴上的任何点,通过指定 x 字段匹配 0,并为 y 字段的值创建一个变量 y。

第三个分支没有指定任何字面量,因此它匹配任何其他 Point,并为 x 和 y 字段创建变量。

在本例中,由于 x 包含 0,所以值 p 与第二分支匹配,因此此代码打印 On the y axis at 7。

记住,匹配表达式一旦找到第一个匹配模式就会停止检查分支,所以即使 Point {x: 0, y: 0} 位于 x 轴和 y 轴上,这段代码也只会打印 On the x axis at 0。

解构枚举

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

fn main() {
    let msg = Message::ChangeColor(0, 160, 255);

    match msg {
        Message::Quit => {
            println!("The Quit variant has no data to destructure.");
        }
        Message::Move { x, y } => {
            println!("Move in the x direction {x} and in the y direction {y}");
        }
        Message::Write(text) => {
            println!("Text message: {text}");
        }
        Message::ChangeColor(r, g, b) => {
            println!("Change color to red {r}, green {g}, and blue {b}");
        }
    }
}

对于没有任何数据的 enum 变量,比如 Message::Quit,我们不能再解构值了。我们只能匹配 Message::Quit 值,并且该模式中没有变量。

对于类结构的枚举变体,如 Message::Move,可以使用与指定的匹配结构的模式类似的模式。在变量名之后,我们放置花括号,然后列出包含变量的字段,这样我们就可以将各个部分分开,在代码中用于该分支。

对于类似元组的枚举变体,比如 Message::Write(包含一个元素的元组)和 Message::ChangeColor(包含三个元素的元组),其模式类似于我们指定的匹配元组的模式。模式中的变量数量必须与我们要匹配的变量中的元素数量相匹配。

解构嵌套结构体和枚举

匹配可以在嵌套项上工作。

例如,我们可以重构上一小节的代码,以便在 ChangeColor 中支持 RGB 和 HSV 颜色。

enum Color {
    Rgb(i32, i32, i32),
    Hsv(i32, i32, i32),
}

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(Color),
}

fn main() {
    let msg = Message::ChangeColor(Color::Hsv(0, 160, 255));

    match msg {
        Message::ChangeColor(Color::Rgb(r, g, b)) => {
            println!("Change color to red {r}, green {g}, and blue {b}");
        }
        Message::ChangeColor(Color::Hsv(h, s, v)) => {
            println!("Change color to hue {h}, saturation {s}, value {v}");
        }
        _ => (),
    }
}

第一个分支的模式匹配一个包含 Color::Rgb 变体的 Message::ChangeColor 枚举变体。然后,模式绑定到三个内部 i32 值。

第二分支的模式也匹配 Message::ChangeColor 枚举变体,但是内部枚举匹配的是 Color::Hsv。

我们可以在一个匹配表达式中指定这些复杂的条件,即使涉及到两个枚举。

解构结构和元组

我们可以以更复杂的方式混合、匹配和嵌套解构模式。

下面的例子展示了一个复杂的解构,我们将结构体和元组嵌套在元组中,并将所有的原始值解构出来:

let ((feet, inches), Point { x, y }) = ((3, 10), Point { x: 3, y: -10 });

这段代码允许我们将复杂类型分解成它们的组成部分,这样我们就可以单独使用我们感兴趣的值。

使用模式进行解构是一种方便的方法,可以分别使用值的每个部分,例如结构体中每个字段的值。

忽略模式中的值

有时忽略模式中的值是有用的,例如在匹配的最后一部分,以获得一个实际上不做任何事情但考虑所有剩余可能值的集合。

通配符:_

我们使用下划线作为通配符模式,它将匹配任何值,但不绑定到值。这在匹配表达式的最后一部分特别有用,但是我们也可以在任何模式中使用它,包括函数参数。

fn foo(_: i32, y: i32) {
    println!("This code only uses the y parameter: {y}");
}

fn main() {
    foo(3, 4);
}

这段代码将完全忽略作为第一个参数传递的值 3。

在大多数情况下,当你不再需要某个特定的函数参数时,你可以更改签名,使其不包括未使用的参数。在某些情况下,忽略函数参数可能特别有用,例如,当你实现一个 trait 时,你需要一个特定的类型签名,但你实现的函数体不需要其中一个参数。这样就可以避免收到关于未使用函数参数的编译器警告,而如果使用名称则会这样做。

通过嵌套 _ 忽略值的一部分

我们也可以在另一个模式中使用 _ 来忽略值的一部分,例如,当我们只想测试值的一部分,而不想使用相应代码中要运行的其他部分时。

    let mut setting_value = Some(5);
    let new_setting_value = Some(10);

    match (setting_value, new_setting_value) {
        (Some(_), Some(_)) => {
            println!("Can't overwrite an existing customized value");
        }
        _ => {
            setting_value = new_setting_value;
        }
    }

    println!("setting is {setting_value:?}");

在第一个匹配分支中,我们不需要匹配或使用某些变体中的值,但我们确实需要测试 setting_value 和 new_setting_value 是某些变体的情况。在这种情况下,我们输出不更改 setting_value 的原因,它不会被更改。

在第二部分中的 _ 模式表示的所有其他情况下(如果 setting_value 或 new_setting_value 中的一个为 None),我们将 new_setting_value 赋值为 new_setting_value,即 Some(10)。

我们还可以在一个模式中的多个位置使用下划线来忽略特定的值。

    let numbers = (2, 4, 8, 16, 32);

    match numbers {
        (first, _, third, _, fifth) => {
            println!("Some numbers: {first}, {third}, {fifth}");
        }
    }

该示例忽略包含五个元素的元组中的第二个和第四个值。

以_开头的未使用变量

如果你创建了一个变量,但没有在任何地方使用它,Rust 会发出警告,因为未使用的变量可能是一个 bug。

然而,有时能够创建一个还不会使用的变量是很有用的,例如当你创建原型或刚开始一个项目时。在这种情况下,你可以告诉 Rust 不要警告未使用的变量,方法是在变量名的开头加上下划线。

fn main() {
    let _x = 5;
    let y = 10;
}

在这里,我们得到一个关于不使用变量 y 的警告,但是我们没有得到一个关于不使用 _x 的警告。

请注意,仅使用 _ 和使用以下划线开头的名称之间存在细微的区别。语法 _x 仍然将值绑定到变量,而 _ 根本不绑定。为了说明这种区别的重要性,请看下面两个示例。

    let s = Some(String::from("Hello!"));

    if let Some(_s) = s {
        println!("found a string");
    }

    println!("{s:?}");

我们将收到一个错误,因为 s 的值仍然会被移到 _s 中,这阻止了我们再次使用 s。

但是,使用下划线本身不会绑定到值。

    let s = Some(String::from("Hello!"));

    if let Some(_) = s {
        println!("found a string");
    }

    println!("{s:?}");

这段代码编译后不会出现任何错误,因为 s 没有被移到 _ 中。

使用 .. 忽略部分值

对于包含许多部分的值,我们可以使用 .. 语法,以使用特定部分并忽略其余部分,从而避免为每个被忽略的值列出下划线。.. 忽略了我们在模式的其余部分中没有显式匹配的值的任何部分。

例如,我们有一个 Point 结构体,它保存三维空间中的坐标。在匹配表达式中,我们希望只对 x 坐标进行操作,而忽略 y 和 z 字段中的值。

    struct Point {
        x: i32,
        y: i32,
        z: i32,
    }

    let origin = Point { x: 0, y: 0, z: 0 };

    match origin {
        Point { x, .. } => println!("x is {x}"),
    }

这比列出 y: _ 和 z: _ 要快得多,特别是当我们处理有很多字段的结构体时,而只有一两个字段是相关的。

.. 语法可以扩展到需要的任意多的值。

fn main() {
    let numbers = (2, 4, 8, 16, 32);

    match numbers {
        (first, .., last) => {
            println!("Some numbers: {first}, {last}");
        }
    }
}

在这段代码中,第一个和最后一个值与 first 和 last 匹配。.. 将匹配并忽略中间的所有内容。

然而,使用 .. 必须是明确的。如果不清楚哪些值需要匹配,哪些值应该忽略,Rust 会给我们一个错误。

fn main() {
    let numbers = (2, 4, 8, 16, 32);

    match numbers {
        (.., second, ..) => {
            println!("Some numbers: {second}")
        },
    }
}

Rust 不可能确定在与第二个值匹配之前要忽略元组中的多少值,以及之后要忽略多少值。变量名 second 对 Rust 没有任何特殊意义,所以我们得到一个编译器错误,因为像这样在首尾两个地方使用 .. 是模棱两可的。

使用匹配守卫指定额外条件

匹配守卫(match guard)是一个附加的 if 条件,在匹配分支中的模式之后指定,它也必须与要选择的匹配分支相匹配。

匹配守卫对于表达比模式本身更复杂的想法很有用。但是请注意,它们只能在 match 表达式中使用,而不能在 if let 或 while let 表达式中使用。

条件可以使用在模式中创建的变量。下列代码显示了一个匹配,其中第一个分支具有模式 Some(x),并且还有一个匹配守卫 if x % 2 == 0(如果数字是偶数,则为真)。

    let num = Some(4);

    match num {
        Some(x) if x % 2 == 0 => println!("The number {x} is even"),
        Some(x) => println!("The number {x} is odd"),
        None => (),
    }

这个例子将输出 The number 4 is even。当 num 与第一个分支中的模式比较时,它匹配,然后匹配保护检查 x 除以 2 的余数是否等于 0,因为是,所以选择第一个分支。

如果 num 改为 Some(5),则第一个分支中的匹配守卫将为假,然后 Rust 会转到第二个分支,因为第二个分支没有匹配守卫,因此会匹配任何一些变体。

在模式中没有办法表达 if x % 2 == 0 条件,因此匹配保护使我们能够表达这种逻辑。这种额外的表达性的缺点是,当涉及匹配保护表达式时,编译器不会尝试检查穷尽性。

我们之前提到可以使用匹配保护来解决模式隐藏问题。回想一下,我们在匹配表达式的模式内部创建了一个新变量,而不是在匹配之外使用该变量。这个新变量意味着我们不能针对外部变量的值进行测试。使用匹配守卫就可以解决这个问题。

fn main() {
    let x = Some(5);
    let y = 10;

    match x {
        Some(50) => println!("Got 50"),
        Some(n) if n == y => println!("Matched, n = {n}"),
        _ => println!("Default case, x = {x:?}"),
    }

    println!("at the end: x = {x:?}, y = {y}");
}

这段代码打印 Default case, x = Some(5)。第二个匹配分支中的模式并没有引入一个新的变量 y 来遮蔽外部的 y,这意味着我们可以在匹配保护中使用外部的 y。我们没有将模式指定为 Some(y),因为这会遮蔽外部的 y,而是指定 Some(n)。这就创建了一个新的变量 n,它不会遮蔽任何东西,因为在匹配之外没有变量 n。

匹配守卫 if n == y 不是模式,因此不会引入新的变量。这个 y 是外部的 y,而不是一个新的 y,我们可以通过比较 n 和 y 来寻找一个与外部 y 相同的值。

还可以在匹配保护中使用或操作符 | 来指定多个模式,匹配守卫条件将适用于所有模式。

下面代码显示了将使用 | 的模式与匹配守卫组合在一起时的优先级。这个示例的重要部分是,if y 匹配保护适用于 4、5 和 6,尽管看起来像是 if y 只适用于 6。

    let x = 4;
    let y = false;

    match x {
        4 | 5 | 6 if y => println!("yes"),
        _ => println!("no"),
    }

匹配条件表明,只有当 x 的值等于 4、5 或 6并且 y 为真时,第一个分支才匹配。原因是 if 条件适用于整个模式 4 | 5 | 6,而不仅仅适用于最后一个值 6。

换句话说,与模式相关的匹配保护的优先级是这样的:

(4 | 5 | 6) if y => ...

而不是:

4 | 5 | (6 if y) => ...

@ 绑定

@ 操作符允许我们创建一个变量,该变量在我们测试该值以进行模式匹配的同时保存该值。

例如,我们想测试 Message::Hello id 字段是否在 3…=7 的范围内。我们还希望将该值绑定到变量 id_variable,以便在与分支相关的代码中使用它。

我们可以将这个变量命名为 id,与字段名称相同,但在本例中,我们将使用不同的名称。

    enum Message {
        Hello { id: i32 },
    }

    let msg = Message::Hello { id: 5 };

    match msg {
        Message::Hello {
            id: id_variable @ 3..=7,
        } => println!("Found an id in range: {id_variable}"),
        Message::Hello { id: 10..=12 } => {
            println!("Found an id in another range")
        }
        Message::Hello { id } => println!("Found some other id: {id}"),
    }

这个例子将打印 Found an id in range: 5。

在第一个分支中,通过在范围 3…=7 之前指定 id_variable @,我们捕获匹配范围的任何值,同时也测试该值是否匹配范围模式。

在第二个分支中,我们只有模式中指定的范围,与该分支关联的代码没有包含 id 字段实际值的变量。id 字段的值可以是 10、11 或 12,但是使用该模式的代码不知道它是哪个。模式代码不能使用 id 字段中的值,因为我们没有将 id 值保存在变量中。

在最后一个分支中,我们指定了一个没有范围的变量,我们确实在分支代码中有一个名为 id 的变量中可用的值。原因是我们使用了 struct 字段速记语法。但是我们没有像对前两个分支那样对这个分支中的 id 字段中的值应用任何测试:任何值都将匹配这个模式。

使用 @ 可以让我们测试一个值,并将其保存在一个模式中的变量中。

Rust语言基础语法 与其他语言一样,Rust也有整型、浮点型、字符串、布尔型等数据类型。 阅读详情

相关推荐

rust教程 第二章 —— rust基础语法详解

本文主要详解Rust中基本语法的使用

余识- 1万+

Rust基础语法

默认是不可变的,当定义相同名称的变量的时候,会隐藏原来的变量。执行x=x+1 是相当于隐藏的值+1进行新的变量x的赋值操作。上面的代码1是i32位的,现在用i64来接受,那么会显示编译错误。1 变量默认是不变的,但是常量总是不变的,并且不能对常量使用let关键字。因为上面的正是一个语句,所以不产生返回值,那么下面的语句是错误的。对于Rust变量来说,默认是不可变的,那么是否可以说是常量呢?使用场景是不需要使用迭代元素的值,那么变量可以使用_替代。在rust中,返回值是表达式,因此不能使用分号结束。

大佛拈花的博客 4356

修复zookeeper未授权访问漏洞

【代码】修复zookeeper未授权访问漏洞。

qq_28392947的博客 4069

Rust 语法

引用是一个复杂的特性, Rust 的一个主要优势就是安全而简单的操纵引用。现在, 我们只需知道它像变量一样, 默认是不可变的。的工作是, 无论用户在标准输入中键入什么内容, 都将其追加(不会覆盖其原有内容)到一个字符串中, 因此它需要字符串作为参数。函数是一个特殊的函数: 在可执行的 Rust 程序中, 它总是最先运行的代码。在 Rust 中, 变量默认是不可变的, 这意味着一旦我们给变量赋值, 这个值就不再可以修改了。是一个标准库提供的字符串类型, 它是 UTF-8 编码的可增长文本块。

云满笔记 2055

2024年最新双摄像头的实时视频拼接及目标跟踪(一)_监控视频拼接实时(1),网络相关+C C++三方库的源码分析+数据结构与算法

opencv中采用了SURF,ORB进行特征点提取,如果装的是opencv2.0版本,则可以直接用SURF,如果是3.0版本,则需要下载相应的contrib库进行安装。原理不赘述,给出其实验结果对比和分析,原始图像1SURF特征点提取网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。需要这份系统化的资料的朋友,可以添加戳这里获取一个人可以走的很快,但一群人才能走的更远!

m0_51437227的博客 938

Microchip Studio 7.0 从下载到项目调试:AVR开发者的完整入门指南(附常见问题解决)

本文为AVR开发者提供了Microchip Studio 7.0从下载安装到项目调试的完整入门指南。详细介绍了如何获取安装包、创建第一个AVR工程项目,并配置编译与调试环境。同时,文章重点解决了开发过程中常见的编译错误和仿真问题,帮助开发者快速上手并高效使用这一官方集成开发环境。

joy55的博客 336

Rust 学习笔记:关于模式的语法的练习题

Rust 学习笔记:关于模式的语法的练习题

ProgramNovice的博客 267

Allegro16.6详细教程(二)

3-D Viewer,可以直接在allegro中看到board file的3-D顯示效果。3-D Viewer對於PCB Editor Products,只有環境變數中的OpenGL顯示功能開啟後才有效,而對於APD/SiP是無效的。2.3-D viewer是在一個獨立的視窗中打開的。3-D environment環境支援多種顯示內容的過濾,取景視角和顯示效果的選項,透過遊標可以直接控制放大,移動,翻轉等操作。

axingxiansen的博客 1926

Rust 学习笔记:模式匹配

Rust 学习笔记:模式匹配

ProgramNovice的博客 1281

C语言设计模式全面解析:从理论到28个实战示例

本文系统介绍了23种经典设计模式在C语言中的实现方法。通过结构体、函数指针等技巧,C语言可以优雅地模拟面向对象特性,实现代码复用与解耦。文章分类详解了创建型、结构型、行为型三大类模式,并提供了28个完整代码示例,包括单例、策略、观察者等核心模式的精简实现。这些模式在嵌入式系统、操作系统内核等场景中广泛应用,如状态机、事件驱动等。学习C语言设计模式的关键在于理解模式意图,掌握函数指针和结构体组合等技巧,并在实际项目中灵活运用。本文为C语言开发者提供了全面的设计模式参考指南。

数字人生 364

MIKE21 MIKE软件 教程 0.1 软件介绍与教学目录

MIKE 21是一个专业的工程软件包,用于模拟河流、湖泊、河口、海湾、海岸及海洋的水流、波浪、泥沙及环境问题。在MIKE Zero集成平台中,主要有MIKE11,MIKE21,MIKE3三类软件,分别对应一维,二维,三维的水动力模型模拟。同时还包括MIKE HYDRO,MIKE FLOOD等其他功能,各软件的具体介绍请参考DHI公司的官方文档,在此不作赘述。学习过程中,对于任何操作界面的疑问,建议大家仔细阅读帮助文档(在有疑问的界面按F1调出),同时官方也提供了对应的线上和线下教学服务(免费+收费)。

Hello Word 2万+

Rust学习笔记_10——守卫

在Rust中,守卫(guard)是match表达式中的一个特性,它允许你在模式匹配的过程中附加一个条件。这个条件是一个表达式,它必须返回一个布尔值(bool),用于进一步细化或约束某个模式何时应该被匹配。守卫通过if关键字引入,并紧跟在模式之后。

LuckyLay的博客 1112

建行报专版报道建设银行金融科技发展历程

经过十多年的建设,总行前中后台部门都有了自己的业务系统,但系统“部门”特征显著,渠道、客户、产品的横向整合不足,产品系统层次化、结构化、参数化程度不高,渠道支持产品快速部署以及跨渠道服务能力不足,管理分析类系统建设相对滞后,系统较弱的可扩展能力在应对高速增长的交易量时已疲态尽显,同时安全稳定运行的压力和风险日益积聚。站在新的历史起点上,科技条线将聚焦主责主业,完善信息科技管理体系,紧紧围绕安全生产中心任务,持续推动技术能力复用共享和自主可控,为全行做好金融五篇大文章,推动业务高质量发展提供技术支撑。

银行信息系统应用架构详解 389

Rust 学习笔记:枚举与模式匹配

Rust 学习笔记:枚举与模式匹配

ProgramNovice的博客 1008

铁路场景雷达点云目标识别与追踪系统

本文介绍了一种基于毫米波雷达的铁路货运车站安全监控系统。该系统采用分布式架构,通过多个毫米波雷达节点采集点云数据,经过坐标转换、多雷达融合等处理后,利用机器学习算法实现列车、行人等目标的实时识别与追踪。系统包含数据采集层、处理层、目标识别层、追踪层、预警决策层和可视化层,能够克服传统视频监控受环境影响大的缺点,实现全天候可靠监测。文中详细展示了雷达数据解析和点云预处理的代码实现,包括坐标转换、数据格式解析和体素网格滤波等关键技术。该系统可有效预警铁路场景下的碰撞风险,提升货运车站的安全管理水平。

huanghm88的专栏 126

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

Rust 学习笔记:高级 trait

Rust 学习笔记:高级 trait

ProgramNovice的博客 952

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

Rust 学习笔记:宏

Rust 学习笔记:宏

ProgramNovice的博客 1254

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

ssm框架搭建

这个是一个在idea上成功跑起来的ssm框架项目,保存在这里方便以后使用直接下载

Rust学习笔记_12——闭包

在Rust编程语言中,闭包(closures)是一种匿名函数,它能够捕获并存储其所在作用域内的变量,以便在稍后的某个时间点调用。在大多数情况下,你不需要显式地指定闭包的类型,因为Rust的编译器能够推断它。当闭包以移动方式捕获变量时,原始变量将不再可用,因为闭包已经接管了该变量的所有权。不可变捕获是闭包捕获变量的默认方式。当闭包以不可变方式捕获变量时,它只能读取该变量的值,而不能修改它。这种方式保证了闭包内部对变量的访问是安全的,因为闭包不会改变变量的状态。可变捕获允许闭包修改其捕获的变量的值。

LuckyLay的博客 1397

Rust学习笔记(一)

使用wsl2 ubuntu 20.04,照着教程直接然后无脑回车安装完成。

_Divinity_'s Blog 1020

Rust 学习笔记:关于枚举与模式匹配的练习题

Rust 学习笔记:关于枚举与模式匹配的练习题

ProgramNovice的博客 837

Rust学习笔记心得

近段时间在学习研究Rust。都说Rust学习曲线陡峭,感觉果然如此。之前学习Go,基本上没有专门去看语法,只是在需要的时候上网查一查,再花点时间看看大型的开源软件项目,差不多就可以写生产级别的代码了。而Rust则不然,至少本人花了差不多两三周的时间专门学习语法,然而去看开源的项目依然觉得很吃力,又花了一些时间才搞明白了Rust的几种编码模式,特别是异步模式,又分为poll循环的方式、combinator方式和.await协程的方式,各种坑比较多,填坑的过程还是比较费劲的。 整个大约两个多月学习过程中,曾经

跨链技术践行者 718

Rust学习笔记

Rust学习笔记

weixin_43225644的博客 737

Rust学习笔记——模式和匹配

https://doc.rust-lang.org/book/ch18-00-patterns.html 模式有以下几种类型: Literals Destructured arrays, enums, structs, or tuples Variables Wildcards Placeholders 模式是什么 && 在哪里使用模式 模式在 Rust 中很常见,比如我们常用的赋值语句也使用了模式:let x = 5;,x 就是一个模式,Rust 会将表达式的值和模式进行比较,如果.

黄先生的博客 937

Rust笔记

同一时刻,你只能拥有要么一个可变引用, 要么任意多个不可变引用引用必须总是有效的在 Rust 中,Option<T>是一个枚举类型,用于表示一个可能存在或可能不存在的值。Some(T)和None。因此,你需要使用Option<T>的完整写法,并通过<i32>显式指定的类型为。这样编译器就知道是一个可能存在或可能不存在的i32类型的值。

WuwuPrograming的博客 497

rust学习笔记8-枚举与模式匹配

switch 语法很经典,但在 Rust 中并不支持,很多语言摒弃 switch 的原因都是因为 switch 容易存在因忘记添加 break 而产生的串接运行问题,Java 和 C# 这类语言通过安全检查杜绝这种情况出现。总结一下,Rust的枚举类型非常灵活,能够表示多种不同的情况,每个变体可以携带不同类型和数量的数据。许多语言支持 null 的存在(C/C++、Java),这样很方便,但也制造了极大的问题,null 的发明者也承认这一点,"一个方便的想法造成累计 10 亿美元的损失"。

weixin_50253985的博客 660

【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数

Rust 不是传统的面向对象编程语言,它的所有特性,使其独一无二。因此,学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此,本系列文章的结构也与此书的结构相同(后续可能会调成结构),基本上分为三个部分习惯语法设计模式反模式(anti_patterns)习惯语法是社区广泛认同的Rust编程常用风格、指导方针和模式。编写惯用的代码可以让其他开发人员更好地理解你所写的代码。...

专注Rust编程与技术分享,涵盖C++、Python等开发实战,新手友好,专注实战,助力编程成长。 7万+
上一篇: Rust 学习笔记:关于模式匹配的练习题
下一篇: Rust 学习笔记:关于模式的语法的练习题
UestcXiye
博客等级 码龄8年 9033粉丝 1306原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

UestcXiye

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值