一、基础语法

1、变量和常量

rust为强类型语言，但具有自动判断类型的能力，所以可以不用指定类型

关键词let用于声明变量，如let a =123;或let mut a = 123;

由于rust是强类型语言，所以下面代码是不合法的

let a=123;
a=123 //不能把字符串赋值给整型变量

关键字coast用于声明常量，其用法和let相同，区别在于coast声明的常量值既不能被改变也不能重影（见下），但是可变变量可以进行重影操作。

也可以人工给变量或常量指定类型，如let a: u64 = 123;或const a: i32 = 123;。这两行代码的含义分别为将a声明为一个64位无符号整型变量和将a声明为一个32位有符号整型常量。如果不指定类型，a将会被识别位32位整型。

2、可变变量与不可变变量

上面提到let a =123;或let mut a = 123;均可以用于声明变量，其区别在于，mut关键字（mutable）声明的变量为可变变量。

不可变变量在定义后是不可以被重新赋值的（考虑到高并发安全）。例如如下代码是不合法的

let a=123;
a=456 //不可变变量的值不能被改变

但是可以通过添加mut关键字来声明一个可变变量，可变变量的值是可以被修改的。

可变变量可以执行重影操作（Shadowing）。重影是指用同一个名字重新代表另一个变量实体，其类型、可变属性和值都可以变化，。和可变变量的赋值不是一个概念，可变变量赋值仅能发生值的变化。

二、数据类型

1、整型

isize 和 usize 两种整数类型是用来衡量数据大小的，它们的位长度取决于所运行的目标平台，如果是 32 位架构的处理器将使用 32 位位长度整型。整型的表达方式如下

整数中间的下划线起分割作用，提高数字的可读性，并不影响数字的值

2、浮点

因64位浮点具有更好的精确性，所以默认使用64位浮点

3、布尔

4、字符

关键字为char，长度为4字节，表示一个unicode符号量

5、复合类型

元组

类似于python中的元组，可以混合数据类型，其使用方式如下

// 定义名为t1的元组
let t1: (i32, f64, u8) = (500, 6.4, 1);
// 也可以不指定数据类型
let t1 = (500, 6.4, 1);
// 访问全部元素
println!({:?},t1);
// 访问某个元素
println!({:?},t1.0);

数组

类似于c中的数组，其元素为同一种类型。使用方式如下

let a = [1, 2, 3, 4, 5];
// a 是一个长度为 5 的整型数组
let b = [January, February, March];
// b 是一个长度为 3 的字符串数组
let c: [i32; 5] = [1, 2, 3, 4, 5];
// c 是一个长度为 5 的 i32 数组
let d = [3; 5];
// 等同于 let d = [3, 3, 3, 3, 3];
let first = a[0];
let second = a[1];
// 数组访问

a[0] = 123; // 错误：数组 a 不可变
let mut a = [1, 2, 3];
a[0] = 4; // 正确

三、注释

//单行注释
/*单行注释*/

///说明文档注释
///可以用于编写函数或变量的说明文本

四、函数

1、函数的基本结构

fn为定义函数的关键字，return为函数返回值关键字，于绝大多数语言的函数结构类似，为fn <函数名> ( <参数> ) <函数体>。示例代码如下：

fn add(a: i32, b: i32) -> i32 {
    return a + b;
}

上述代码的含义为定义了一个名为add的函数，有两个参数a和b，类型都是有符32位整型，返回值类型也为有符号32位整型，返回了a+b的值。

2、表达式和语句

语句是执行某些操作且没有返回值的步骤，例如let a = 6;

表达式有计算步骤且有返回值，例如x + 1

可以在一个用 {} 包括的块里编写一个较为复杂的表达式，表达式块是一个合法的函数体。如下

fn main() {
    let x = 5;

    let y = {
        let x = 3;
        x + 1
    };

    println!(x 的值为 : {}, x);
    println!(y 的值为 : {}, y);
}

//x 的值为 : 5
//y 的值为 : 4

注意：x + 1 之后没有分号，否则它将变成一条语句

五、选择和循环

1、选择

关键字为if和else，使用方式类似于python，后仅可以接bool，不可以接1或0

示例代码如下

fn main() {
    let a = 12;
    let b;
    if a > 0 {
        b = 1;
    }  
    else if a < 0 {
        b = -1;
    }  
    else {
        b = 0;
    }
    println!(b is {}, b);
}

//b is 1

1、和python类似，if后的条件表达式可以不被放在()中，也可以放在()中
2、 if 不存在单语句不用加 {} 的规则，不允许使用一个语句代替一个块
3、执行的块可以是任意合法的函数体，如let a = if true {1};就是合法的

2、循环

循环可以使用的关键词有while和for，其使用方式和python类似，例如

// while
let mut i = 0;
while i < 10 {
    // 循环体
    i += 1;
}
// for
let a = [10, 20, 30, 40, 50];
    for i in a.iter() {
        println!(值为 : {}, i);
    }

除此之外，rust还支持原生的无限循环关键字loop，其等同于while(true)。

使用break则可以退出循环，其后还可以接一个值作为循环退出时的返回值，类似于函数的return。代码如下

fn main() {
    let s = ['0', '1', '2', '3', '4', '5'];
    let mut i = 0;
    let location = loop {
        let ch = s[i];
        if ch == '2' {
            break i;
        }
        i += 1;
    };
    println!( \'2\' 的索引为 {}, location);
}

// '2' 的索引为 2