Watch 25 Star 65 Fork 17

hainuo / rust ebookRuby

Create your Gitee Account
Explore and code with more than 6 million developers,Free private repositories !:)
Sign up
This repository doesn't specify license. Without author's permission, this code is only for learning and cannot be used for other purposes.
Clone or download 10.03 KB
Copy Edit Web IDE Raw Blame History
hainuo authored 2015-07-08 22:38 . 语法变量引用

% Variable Bindings 变量绑定

Virtually every non-'Hello World’ Rust program uses variable bindings. They look like this:

几乎每一个非“hello world”的Rust程序都在使用了变量绑定。他们看起来是这样子的:

fn main() {
    let x = 5;

Putting fn main() { in each example is a bit tedious, so we’ll leave that out in the future. If you’re following along, make sure to edit your main() function, rather than leaving it off. Otherwise, you’ll get an error.

在每一个例子中写入一个fn main(){ 是枯燥无味的,所以我们将它留到以后。如果你跟随者教程,请务必编辑你的main()函数,而不是把它删掉,不然你会得到一个报错。

In many languages, this is called a variable, but Rust’s variable bindings have a few tricks up their sleeves. For example the left-hand side of a let expression is a ‘pattern’, not just a variable name. This means we can do things like:

在许多语言中,这被称之为变量,但是Rust的变量绑定有一些高招。例如,一个let表达式的左侧是一个 [pattern 模式][pattern],而不是只有一个变量名。这意味着我们可以这样做:

let (x, y) = (1, 2);

After this expression is evaluated, x will be one, and y will be two.Patterns are really powerful, and have their own section in the book. We don’t need those features for now, so we’ll just keep this in the back of our minds as we go forward.

这个表达式被求值后,x将会是1,y将会是2. 模式是非常强大的,并且在本书中有自己的章节。现在我们不需要那些特性,我们将这些置于脑后,因为我们还要继续学习。

Rust is a statically typed language, which means that we specify our types up front, and they’re checked at compile time. So why does our first example compile? Well, Rust has this thing called ‘type inference’. If it can figure out what the type of something is, Rust doesn’t require you to actually type it out.


We can add the type if we want to, though. Types come after a colon (:):


let x: i32 = 5;

If I asked you to read this out loud to the rest of the class, you’d say “x is a binding with the type i32 and the value five.”

如果我要求你向全班其余同学大声的读出来,你应该说:“x 是一个i32类型的变量,它的值是5。”

In this case we chose to represent x as a 32-bit signed integer. Rust has many different primitive integer types. They begin with i for signed integers and u for unsigned integers. The possible integer sizes are 8, 16, 32, and 64 bits.


In future examples, we may annotate the type in a comment. The examples will look like this:


fn main() {
    let x = 5; // x: i32

Note the similarities between this annotation and the syntax you use with let. Including these kinds of comments is not idiomatic Rust, but we'll occasionally include them to help you understand what the types that Rust infers are.


By default, bindings are immutable. This code will not compile:


let x = 5;
x = 10;

It will give you this error:


error: re-assignment of immutable variable `x`
     x = 10;

If you want a binding to be mutable, you can use mut:


let mut x = 5; // mut x: i32
x = 10;

There is no single reason that bindings are immutable by default, but we can think about it through one of Rust’s primary focuses: safety. If you forget to say mut, the compiler will catch it, and let you know that you have mutated something you may not have intended to mutate. If bindings were mutable by default, the compiler would not be able to tell you this. If you did intend mutation, then the solution is quite easy: add mut.


There are other good reasons to avoid mutable state when possible, but they’re out of the scope of this guide. In general, you can often avoid explicit mutation, and so it is preferable in Rust. That said, sometimes, mutation is what you need, so it’s not verboten.


Let’s get back to bindings. Rust variable bindings have one more aspect that differs from other languages: bindings are required to be initialized with a value before you're allowed to use them.


Let’s try it out. Change your src/ file to look like this:


fn main() {
    let x: i32;

    println!("Hello world!");

You can use cargo build on the command line to build it. You’ll get a warning, but it will still print "Hello, world!":

你可以在命令行中使用cargo build来构建它。你会得到一个警告,但是它仍然将打印出“hello world!”:

   Compiling hello_world v0.0.1 (file:///home/you/projects/hello_world)
src/ 2:10 warning: unused variable: `x`, #[warn(unused_variable)]
   on by default
src/     let x: i32;

Rust warns us that we never use the variable binding, but since we never use it, no harm, no foul. Things change if we try to actually use this x,however. Let’s do that. Change your program to look like this:


fn main() {
    let x: i32;

    println!("The value of x is: {}", x);

And try to build it. You’ll get an error:


$ cargo build
   Compiling hello_world v0.0.1 (file:///home/you/projects/hello_world)
src/ 4:40 error: use of possibly uninitialized variable: `x`
src/     println!("The value of x is: {}", x);
note: in expansion of format_args!
<std macros>:2:23: 2:77 note: expansion site
<std macros>:1:1: 3:2 note: in expansion of println!
src/ 4:42 note: expansion site
error: aborting due to previous error
Could not compile `hello_world`.

Rust will not let us use a value that has not been initialized. Next, let’s talk about this stuff we've added to println!.


If you include two curly braces ({}, some call them moustaches...) in your string to print, Rust will interpret this as a request to interpolate some sort of value. String interpolation is a computer science term that means "stick in the middle of a string." We add a comma, and then x, to indicate that we want x to be the value we’re interpolating. The comma is used to separate arguments we pass to functions and macros, if you’re passing more than one.


When you just use the curly braces, Rust will attempt to display the value in a meaningful way by checking out its type. If you want to specify the format in a more detailed manner, there are a wide number of options available.For now, we'll just stick to the default: integers aren't very complicated to print.


Comment ( 0 )

Sign in for post a comment