Rust- 变量绑定

In Rust, you bind values to a variable name using the let keyword. This is often referred to as "variable binding" because it's like binding a name to a value.

Here's a simple example:

rust 复制代码
let x = 5;

In this example, x is bound to the value 5. By default, bindings are immutable in Rust. If you try to reassign x to a different value, you'll get a compile-time error. If you want a binding to be mutable, you can use the mut keyword:

rust 复制代码
let mut x = 5;
x = 10; // This is okay because x is mutable

In Rust, you can also bind a variable to an expression. The expression will be evaluated, and the resulting value will be bound to the variable:

rust 复制代码
let x = 5 * 5; // x is bound to the value 25

Variable binding in Rust also allows for pattern matching, which enables more complex types of binding. For example, if you have a tuple, you can bind the individual elements of the tuple to different variables:

rust 复制代码
let (x, y) = (1, 2); // x is bound to 1, and y is bound to 2

Rust also requires that all variables be initialized before they are used, which prevents undefined behavior.

Lastly, Rust features a system of "shadowing" where a new variable can be declared with the name of a previous variable, effectively creating a new variable that "shadows" the old one.

rust 复制代码
let x = 5;
let x = x + 5; // x is now 10
let x = x * 2; // x is now 20

Each x is a new variable that shadows the previous x. This is not the same as mutation because these xs are new variables, they just happen to have the same name as the previous variable.

rust 复制代码
fn main() {
    /*
        变量是有作用域的,也就是在一个代码块中生存。
        代码块 {}, 也允许变量遮蔽。
     */

    // main 函数中
    let spend = 1;
    {
        // 只存在本代码块中
        let target = "面向对象";
        println!("内部 {}", target);    // 内部 面向对象

        // 遮蔽了外面的spend
        let spend = 2.0;
        println!("内部 {}", spend);     // 内部 2
    }

    // target在此作用域是不存在的
    // println!("外部 {}", target);
    println!("外部 {}", spend);         // 外部 1

    // 遮蔽了spend
    let spend = String::from("学习时间1小时");
    println!("外部 {}", spend);         // 外部 学习时间1小时

    let spend2;
    {
        let x = 2;
        spend2 = x * x;
    }
    println!("spend2: {}", spend2);     // spend2: 4

    let spend3;
    // println!("spend3: {}", spend3); // 报错,使用了未初始化的绑定
    spend3 = 1;
    println!("another binding spend3: {}", spend3); // another binding spend3: 1

    // 冻结 资源存在使用的引用时,在当前作用域中这一资源是不可被修改的。
    let mut spend4 = Box::new(1);
    let spend5 = &spend4;   // `spend4` is borrowed here
    spend4 = Box::new(100); // `spend4` is assigned to here but it was already borrowed
    println!("{}", spend4);
    println!("{}", spend5);
}
相关推荐
LucianaiB4 小时前
掌握 Rust:从内存安全到高性能服务的完整技术图谱
开发语言·安全·rust
Java水解7 小时前
Rust 性能优化实战:从 unsafe 使用到 SIMD 指令,让服务端响应快 2 倍
后端·rust
大鱼七成饱7 小时前
掌握 anyhow,让你的 Rust 错误处理优雅又安全
后端·rust
alwaysrun8 小时前
Rust中的Enum与Struct详解
rust·enum·named strcut·tuple struct·unit struct
盒马盒马9 小时前
Rust:Windows 系统 VsCode 环境搭建
windows·vscode·rust
摘星编程9 小时前
深入浅出 Tokio 源码:掌握 Rust 异步编程的底层逻辑
网络·算法·rust·系统编程·tokio
于顾而言9 小时前
【笔记】Comprehensive Rust语言学习
笔记·学习·rust
alwaysrun2 天前
Rust中的智能指针
rust·智能指针·pin·cow·box·arc
fqbqrr2 天前
2510rs,rust,1.88
rust
fqbqrr2 天前
2510rs,rust,1.90
rust