Rust basics
使用rust语言编写hello world再容易不过了：
fn main() {
println!("Hello world!");
}
然后利用rustc编译器编译即可:
rustc hell.rs -o hello.out && ./hello.out
可变(mutable)与不可变(immutable)
rust程序默认的变量是不可变的，类似Scala这种函数式编程的语言，鼓励用户使用immutable的变量。当然如果你非想要使用可变的对象也是支持的：
let i = 32; // immutable
let mut i = 32;
编译器会检查是否对不可变对象重新赋值:
| 4 | let i = 10; | - | | | first assignment to `i` | help: make this binding mutable: `mut i` ... 7 | i = 99; | ^^^^^^ cannot assign twice to immutable variable
那么，对于简单类型直接赋值会有问题，如果是复杂类型，如何呢？比如我们用一个不可变的字符串，然后去调用它的函数改变值，会发生生么情况呢？
--> test.rs:5:5
|
4 | let s = String::from("hello");
| - help: consider changing this to be mutable: `mut s`
5 | s.push_str(" world!!!");
| ^ cannot borrow as mutable
结果表明，rust依然保持对象是不可变的。看了一下这个方法的定义，有些蹊跷：
pub fn push_str(&mut self, string: &str) {
self.vec.extend_from_slice(string.as_bytes())
}
具体怎么做到的，我们后面再来研究。
基本类型
rust跟大多数编译型语言一样是静态类型(statically typed)的语言，即所有的变量的类型在程序编译的时候就是已知的。在rust语言中，有着如下的基本类型：
标量类型(Scalar types)
类型 长度
-------- ----------------------------------------
bool 1 true/ false char 4 并不等同于Unicode i8/u8 8 i16/u16 16 i32/u32 32 i32是默认类型，通常拥有最快的速度 i64/u64 64 i128/u128 128 isize/usize arch 取决于机器架构，在32位机器上位32位，64位上位64位 f32 32 浮点数使用IEEE-754标准 f64 64
let f = true;
let sum:i32 = 100;
let heart_eyed_cat = '😻';
复合类型(Compound types)
复合类型分为元组（Tuple）和数组。元组可以用来将不同类型的解构组合到一起：
let t: (i32, bool) = (100, false);
let (x, y) = t; // 解构元组
let x = t.0; // 或者通过序号访问
数组的与元组的区别在于数组中包含的都是同一种数据类型的值。
let a = [1, 2, 3];
let a: [i32; 5] = [1, 2, 3, 4, 5]; // 显示声明一个数组
let b = [10; 5]; // 声明初始值为10、长度为5的数组
值得注意的是，在rust中元组和数组都是固定长度的，一旦声明以后就不可以更改。如果非要可变长度的集合，那么可以考虑使用标准库中的`vector`。并且数组中的元素也是不可以更改的，如果尝试去更改一个不可变的对象编译时会出错：
6 | let b = [100; 5]; | - help: consider changing this to be mutable: `mut b` 7 | b[1] = 1024; | ^^^^^^^^^^^ cannot assign
这和一些其他的语言(例如Java中的final)是有区别的。
数组中如果如果声明的长度和和实际值的长度不一样会怎样呢？rust在编译时就会出错：
--> hell.rs:11:23 | 11 | let a: [i32; 3] = [1]; | ^^^ expected an array with a fixed size of 3 elements, found one with 1 element
另外，rust程序会在运行时对数组的边界进行检查，如果越界访问数组将抛出错误而结束程序，而不是返回一个错误的内存。
方法
在rust中定义一个方法使用`fn`关键字定义：
fn foo(i: i32, j: i32) {
let sum = i + j
}
// 带有返回值的方法
fn sum(i: i32, j: i32) -> i32 {
i + j
}
在rust中方法是第一类值，意味着你可以这样操作：
let fn_s = sum;
let s = fn_s(i, j);
另外，方法中包含在大括号中的语句块，被称作是表达式(expression)，可以这样用：
let a = {
e + 10
};
println!("{}", a);
流程控制
if语句
rust的if语句和其他语言基本类似，稍微有一点区别：
if e % 2 == 0 { // if条件后面不用写小括号
println!("{}", e);
} else if e % 3 == 0 { // 但是后面的语句块必须包含在大括号之中，哪怕只有一行
println!("{} % 3 ==0", e);
} else {
println!(":p");
}
条件赋值
因为if语句本身是一个表达式，所以可以把if和let联合在一起来使用，也就是条件赋值：
let a = if condition {
5
} else {
6
};
当然前提是不同的分支下的语句要是一样的类型，否则编译器会检测出错误。
循环
rust的`loop`关键字支持创建一个循环:
let mut i = 0;
loop {
i += 1;
println!("->{}", i);
}
基本上这就是一个死循环了。不知道为啥要定义这样一个奇葩的关键字。索性我们可以像其他编程语言一样`break`。值得注意的是，跟条件赋值一样，loop语句也是可以和let一起来赋值的，像下面这样：
let s = loop {
i += 1;
println!("->{}", i);
if(i > 100) {
break i;
}
};
println!("s = {}", s); // s = 101
除了这个`loop`外，也可以“正常的”像其他语言一样，使用`while`和`for`进行条件循环：
while i < 1000 { // 不用写小括号
i += 1;
}
for e in a.iter() { // 使用for循环遍历数组
println!("{}", e);
}
// for i in (1..10).rev()
// 使用rev()反转顺序
for i in (1..10) {
println!("{}", i);
}
rust语言的一些惯例
命名方式
rust中推荐使用蛇形命名(snake case)来作为方法和变量的命名方式，所有的标识符都是小写且使用下划线分隔，例如：
let foo_bar = 1;
fn print_info() {
}