创建项目
[root@itoracle test]# cargo new guessing_game Created binary (application) `guessing_game` package [root@itoracle test]# cd guessing_game [root@itoracle guessing_game]# ls Cargo.toml src [root@itoracle guessing_game]# cat Cargo.toml [package] name = "guessing_game" version = "0.1.0" authors = ["tanpf <itoracle@163.com>"] edition = "2018" [dependencies]
the main function is the entry point into the program
# vim src/main.rs use std::io; fn main() { println!("Guess the number!"); println!("Please input your guess."); let mut guess = String::new(); io::stdin().read_line(&mut guess) .expect("Failed to read line"); println!("You guessed: {}", guess); }
println! is a macro that prints a string to the screen, then create a place to store the user input
let statement, which is used to create a variable. In Rust, variables are immutable by default. The following example shows how to use mut before the variable name to make a variable mutable:let foo = 5; // immutable let mut bar = 5; // mutable
You now know that let mut guess will introduce a mutable variable named guess. On the other side of the equal sign (=) is the value that guess is bound to, which is the result of calling String::new, a function that returns a new instance of a String. String is a string type provided by the standard library that is a growable, UTF-8 encoded bit of text. The :: syntax in the ::new line indicates that new is an associated function of the String type. An associated function is implemented on a type, in this case String, rather than on a particular instance of a String. Some languages call this a static method. This new function creates a new, empty string. You’ll find a new function on many types, because it’s a common name for a function that makes a new value of some kind. To summarize, the let mut guess = String::new(); line has created a mutable variable that is currently bound to a new, empty instance of a String
io::stdin().read_line(&mut guess) .expect("Failed to read line");
If we hadn’t listed the use std::io line at the beginning of the program, we could have written this function call as std::io::stdin. The stdin function returns an instance of std::io::Stdin, which is a type that represents a handle to the standard input for your terminal. The next part of the code, .read_line(&mut guess), calls the read_line method on the standard input handle to get input from the user. We’re also passing one argument to read_line: &mut guess. The & indicates that this argument is a reference, which gives you a way to let multiple parts of your code access one piece of data without needing to copy that data into memory multiple times. References are a complex feature, and one of Rust’s major advantages is how safe and easy it is to use references. You don’t need to know a lot of those details to finish this program. For now, all you need to know is that like variables, references are immutable by default. Hence, you need to write &mut guess rather than &guessto make it mutable.
.expect("Failed to read line");
As mentioned earlier, read_line puts what the user types into the string we’re passing it, but it also returns a value—in this case, an io::Result. Rust has a number of types named Result in its standard library: a generic Result as well as specific versions for submodules, such as io::Result. The Result types are enumerations, often referred to as enums. An enumeration is a type that can have a fixed set of values, and those values are called the enum’s variants. An instance of io::Result has an expectmethod that you can call. If this instance of io::Result is an Err value, expect will cause the program to crash and display the message that you passed as an argument to expect. If the read_line method returns an Err, it would likely be the result of an error coming from the underlying operating system. If this instance of io::Result is an Ok value, expect will take the return value that Ok is holding and return just that value to you so you can use it. In this case, that value is the number of bytes in what the user entered into standard input. If you don’t call expect, the program will compile, but you’ll get a warning.
println!("You guessed: {}", guess);
let x = 5; let y = 10; println!("x = {} and y = {}", x, y);
This code would print x = 5 and y = 10.
代码运行如下，
[root@itoracle src]# cargo run Finished dev [unoptimized + debuginfo] target(s) in 0.01s Running `/usr/local/automng/src/rust/test/guessing_game/target/debug/guessing_game` Guess the number! Please input your guess. happly new year You guessed: happly new year
至此，完成了界面输入、程序输出的用户交互的过程。
获取随机数使用了rand ，这须先配置外部依赖
[root@itoracle guessing_game]# vim Cargo.toml [package] name = "guessing_game" version = "0.1.0" authors = ["tanpf <itoracle@163.com>"] edition = "2018" [dependencies] rand = "0.3.14"
The [dependencies] section is where you tell Cargo which external crates your project depends on and which versions of those crates you require. In this case, we’ll specify the rand crate with the semantic version specifier 0.3.14.
The number 0.3.14 is actually shorthand for ^0.3.14, which means “any version that has a public API compatible with version 0.3.14.”
[root@itoracle guessing_game]# cargo build Updating crates.io index Downloaded rand v0.3.22 Downloaded rand v0.4.5 Downloaded libc v0.2.47 Compiling libc v0.2.47 Compiling rand v0.4.5 Compiling rand v0.3.22 Compiling guessing_game v0.1.0 (/usr/local/automng/src/rust/test/guessing_game) Finished dev [unoptimized + debuginfo] target(s) in 42.07s
Crates.io is where people in the Rust ecosystem post their open source Rust projects for others to use.
After updating the registry, Cargo checks the [dependencies] section and downloads any crates you don’t have yet. In this case, although we only listed rand as a dependency, Cargo also grabbed a copy of libc, because rand depends on libc to work. After downloading the crates, Rust compiles them and then compiles the project with the dependencies available.
When you build a project for the first time, Cargo figures out all the versions of the dependencies that fit the criteria and then writes them to the Cargo.lock file. When you build your project in the future, Cargo will see that the Cargo.lock file exists and use the versions specified there rather than doing all the work of figuring out versions again. This lets you have a reproducible build automatically. In other words, your project will remain at 0.3.14 until you explicitly upgrade, thanks to the Cargo.lock file.
Updating a Crate to Get a New Version
When you do want to update a crate, Cargo provides another command, update, which will ignore the Cargo.lock file and figure out all the latest versions that fit your specifications in Cargo.toml. If that works, Cargo will write those versions to the Cargo.lock file.
But by default, Cargo will only look for versions larger than 0.3.0 and smaller than 0.4.0. If the rand crate has released two new versions, 0.3.15 and 0.4.0, you would see the following if you ran cargo update:
# cargo update
Updating crates.io index
If you wanted to use rand version 0.4.0 or any version in the 0.4.x series, you’d have to update the Cargo.toml file to look like this instead:
[dependencies] rand = "0.4.0"
获取随机数
use std::io; use rand::Rng; fn main() { println!("Guess the number!"); let secret_number = rand::thread_rng().gen_range(1, 101); println!("The secret number is: {}", secret_number); println!("Please input your guess."); let mut guess = String::new(); io::stdin().read_line(&mut guess) .expect("Failed to read line"); println!("You guessed: {}", guess); }
The Rng trait defines methods that random number generators implement, and this trait must be in scope for us to use those methods.
The rand::thread_rng function will give us the particular random number generator that we’re going to use: one that is local to the current thread of execution and seeded by the operating system. Next, we call the gen_range method on the random number generator. This method is defined by the Rng trait that we brought into scope with the use rand::Rng statement. The gen_range method takes two numbers as arguments and generates a random number between them.
API文档查看
# cargo doc --open
Checking libc v0.2.47
Documenting libc v0.2.47
Checking rand v0.4.5
Documenting rand v0.4.5
Checking rand v0.3.22
Documenting rand v0.3.22
Documenting guessing_game v0.1.0 (/usr/local/automng/src/rust/test/guessing_game)
Finished dev [unoptimized + debuginfo] target(s) in 12.30s
Opening /usr/local/automng/src/rust/test/guessing_game/target/doc/guessing_game/index.html
该命令生成项目引用API文档，下载/usr/local/automng/src/rust/test/guessing_game/target/doc到windows电脑，打开页面即可查看API
[root@itoracle guessing_game]# cargo run Compiling guessing_game v0.1.0 (/usr/local/automng/src/rust/test/guessing_game) Finished dev [unoptimized + debuginfo] target(s) in 3.55s Running `target/debug/guessing_game` Guess the number! The secret number is: 38 Please input your guess. 8 You guessed: 8 [root@itoracle guessing_game]# cargo run Finished dev [unoptimized + debuginfo] target(s) in 0.06s Running `target/debug/guessing_game` Guess the number! The secret number is: 51 Please input your guess. 51 You guessed: 51
[root@itoracle src]# cat main.rs use std::io; use std::cmp::Ordering; use rand::Rng; fn main() { println!("Guess the number!"); let secret_number = rand::thread_rng().gen_range(1, 101); println!("The secret number is: {}", secret_number); println!("Please input your guess."); let mut guess = String::new(); io::stdin().read_line(&mut guess) .expect("Failed to read line"); let guess: u32 = guess.trim().parse() .ok() .expect("Please type a number!"); println!("You guessed: {}", guess); match guess.cmp(&secret_number) { Ordering::Less => println!("Too small!"), Ordering::Greater => println!("Too big!"), Ordering::Equal => println!("You win!"), }; }
cpm方法要求对比的数据类型一致，所以对比前先将字符串类型的guess转换成u32(无符号32位整形)，trim可以去掉字符串前后的空字符。ok与expect则是进行异常处理。
运行
[root@itoracle src]# cargo run Finished dev [unoptimized + debuginfo] target(s) in 0.02s Running `/usr/local/automng/src/rust/test/guessing_game/target/debug/guessing_game` Guess the number! The secret number is: 69 Please input your guess. 69 You guessed: 69 You win!