Rust-lang Book Ch1-3 Gettiing started, An example of Guessing Game, Common Concepts: Variable & Mutability, Data Types, Functions, Comments, Control Flow

Rust的意义

1. 编译器会拒绝具有潜在bug风险的代码，减少了单元测试时间，便于大规模合作

2. Rust自身携带的工具: Cargo帮助管理依赖包+编译+测试，Rustfmt能够统一代码风格，Rust Language Server内含IDE

3. 面向系统开发者，速度与稳定性兼备

资源列表

书源码： https://github.com/rust-lang/book/tree/master/src

discord: https://discord.com/invite/rust-lang

安装、文档相关命令

rustup update

rustup self uninstall

rustup doc

　　

Hello World!

1. 用rustc

fn main() { //main.rs
    println!("Hello, world!");
}

rustc main.rs

　

2. 用cargo

cargo new hello_cargo
cargo build
cargo build --release
cargo run
cargo check #确保代码能通过编译，但是不编译

　　

简单示例：Guessing Game

use rand::Rng;
use std::cmp::Ordering;//std::cmp下面的enum
use std::io;

fn main() {
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1, 101);

    loop {//infinite loop
        println!("Please input your guess.");//println! is a macro

        let mut guess = String::new();//let 定义变量，mut 决定变量是否可变，String是变长UTF8编码字符串

        io::stdin()
            .read_line(&mut guess)//mut 表示函数能够改变这个变量， &表示传递的是guess的引用，由于引用默认是immutatble，不可改变的，所以这里用&mut
            .expect("Failed to read line");//read_line返回的是io::Result，可能是Err或者Ok，res.expect在返回OK时获取OK内部包含的值，在返回Err的时候输出提示并crash，如果不expect，会编译时有Warning

        let guess: u32 = match guess.trim().parse() {//更改了guess的类型看，通过声明guess为u32，parse明确要转化为什么类型
            Ok(num) => num,
            Err(_) => continue,//注意这里match错误处理
        };

        println!("You guessed: {}", guess);

        match guess.cmp(&secret_number) {//match由多个arm组成
            Ordering::Less => println!("Too small!"),//Ordering::less是这个arm的pattern，如果被匹配上了，就运行后面的代码
            Ordering::Greater => println!("Too big!"),
            Ordering::Equal => {
                println!("You win!");
                break;
            }
        }
    }
}

　Cargo.toml中要加入依赖的crate：

[dependencies]
rand = "0.5.5"//实际上是^0.5.5，即任意和0.5.5版本的public API匹配的版本

　此时cargo是从registry（即crates.io的数据的拷贝中）获取的依赖包。生成的Cargo.lock文件确保了依赖包的版本不会因为重新build发生变化，除非手动upgrade（cargo update，获取新依赖包）。

变量

变量默认是immutable的，不能变更具体值，这样限制给程序带来了安全保障，有时不更改数据结构，而是直接新建或者拷贝一个类似的能够带来额外的安全保障。不过在变量声明时加上mut就能变成可写的变量。

rust同样支持const，那么immutable variable和const variable的差别是什么呢？

const MAX_POINTS: u32 = 100_000;

　　

1.  显然，不需要在const上面使用mut，同时，普通变量的类型可以被某种程序上推测到，但是const是一定要声明类型的。

2. const变量可以在任何作用域声明，包括global scope。

3. const变量只能是一个不变的静态表达式计算的产物，而不能是一个函数调用或者必须要运行时才能确定的其他任何值。

使用const变量的好处-便于传达某个值的意义

Shadowing

变量Shadowing指用let声明一个新的、类型可能不同的变量替代一个旧的同样名字的变量。旧的is shadowed by新的。实际上，这两个变量除了名字相同，可以没有其他联系。这样做的好处是能够减少无意义的变量命名，比如a, a_str。

    let spaces = 123;
    let mut spaces = "   ";//That is ok!
    println!("Hello, world!");

　

数据类型

Rust是静态类型语言，需要能够在编译阶段确定所有变量的类型。Rust会尽量推断变量类型，如果无法推断，就会编译时报错。

let guess = "42".parse().expect("Not a number!");
  |         ^^^^^ consider giving `guess` a type

　　

Scalar types

Integers, Floating-point, Booleans, Chararcters。

Integers: i8, i16, i32, i64, i128, u8, u16, u32, u64, u128, isize, usize  isize和usize与机器环境有关，如果是32位环境，长度32，64位环境长度64

输入方式: 0xff, 0o77, 0b11111_0000, b'A'

注意: Integer Overflow具有如下设置：当debug选项编译后，如果运行时出现Overflow会panic，但是在release下则会自动wrap（具体Wrap方法在Wrapping中实现）

Floating point: f32, f64

Char Type: 注意区分与u8的差别。此外，U+0000到U+D7FF到U+E000到U+10FFFF都能用char直接表示。Accented letters; Chinese, Japanese, and Korean characters; emoji; and zero-width spaces are all valid char values in Rust

组合类型-tuples and arrays

Tuple

fn main() {
    let tup: (i32, f64, u8) = (500, 6.4, 1);

    let (x, y, z) = tup;//destructuring
	
    let five_hundred = x.0;//访问tuple内元素

    let six_point_four = x.1;

    let one = x.2;
}

Array　　

let a: [i32; 5] = [1, 2, 3, 4, 5];
let a = [3; 5];//[初始值;个数]
let first = a[0];

　　

 函数

默认使用snake case方式（即使用小写和_）来写函数名和变量名。

fn main() {
    another_function(5, 6);
}

fn another_function(x: i32, y: i32) {
    let y = {let x = 3;x + 1};//括号内是一个expression
    println!("The value of x is: {}", x);
    println!("The value of y is: {}", y);
    5 //如果加一个分号，就变成了statement,就不能直接作为返回值，会报错
}

　　

注释

基本的注释//

还有专用于文档生成的注释

控制流

If

fn main() {
    let condition = true;
    let number = if condition { 5 } else { 6 };

     if number % 4 == 0 {
        println!("number is divisible by 4");
    } else if number % 3 == 0 {
        println!("number is divisible by 3");
    } else {
        println!("number is not divisible by 4, 3, or 2");
    }
    println!("The value of number is: {}", number);
}

　　

Loop

fn main() {
    let mut counter = 0;

    let result = loop {
        counter += 1;

        if counter == 10 {
            break counter * 2;//result = counter * 2， break语句返回了值
        }
    };

    loop {
        println!("again!");
    }
    println!("The result is {}", result);
}

　　

While

fn main() {
    let a = [10, 20, 30, 40, 50];
    let mut index = 0;

    while index < 5 {
        println!("the value is: {}", a[index]);

        index += 1;
    }
	
	for element in a.iter() {//iteration
        println!("the value is: {}", element);
    }
    for number in (1..4).rev() {//rev: reverse the range
        println!("{}!", number);
    }
}