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:
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:
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:
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:
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.文章来源:https://www.toymoban.com/news/detail-621212.html
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 x
s are new variables, they just happen to have the same name as the previous variable.文章来源地址https://www.toymoban.com/news/detail-621212.html
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);
}
到了这里,关于Rust- 变量绑定的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!