类型

基元类型

rust中内置的基元类型有以下几种：

bool
char
integer
isize
usize
f32
f46
[T;N] 固定大小的数组
[T] 动态大小的连续序列的视图
str 字符串切片
(T, U, ..) 有限序列
不可变变量、可变变量和常量
在Rust中，存在着 不可变变量 , 可变变量 和 常量 的区别。

在 Rust 中定义的变量，默认是不可变的。声明如下：

let space = "  ";

在 Rust 中，变量一旦声明就不允许改变了。但是，在Rust中，还存在着一种叫做覆盖（Shadow）的行为。如下所示：

let x = 5;
let x = x + 1;
let x = x * 2;

最后的结果,i=12。Rust中的覆盖和 可变变量 都可以让之前声明的变量的值发生改变。但还是有所不同的：

可变变量 只能修改变量的值，不能修改其类型。而覆盖不仅可以修改变量的值，而且可以修改变量的类型。
可变变量 在声明后的所有地方都可以修改其值。而覆盖的值的修改，只能再以覆盖的形式去修改。

常量 是在永远不能修改的值。用 const 声明。

const PI = 3.1415926;

数据类型

Rust语言是一个 静态类型 的语言。所有在使用的过程中，Rust 需要知道当前变量的类型。在一般情况下，Rust 可以自动推断出变量的类型。当Rust无法推断时，我们就要指出变量类型。比如：

let n: u32 = 16;

在 Rust 中，有标量和复合变量两类类型。

标量

Struct

在Rust中，有一种叫 Struct 的数据结构，它类似于其他语言中的类，有自己的自定义结构和方法。但又比具体语言中的类要灵活许多。

基本结构

下面是基本的结构：

struct Rect{
    width: u32,
    height: u32
}
struct Color(i32, i32, i32);
struct Point(i32, i32, i32);
let black = Color(0,0,0);
let origin = Point(0,0,0);

实例方法

在 Rust 的 struct 中实现方法要用 impl 关键字。

struct Rect {
    width: u32,
    height: u32
}
impl Rect {
    fn area(&self) -> u32 {
        self.width * self.height
    }
    fn can_hold(&self, other: &Rect) -> bool {
        self.width > other.width && self.height > other.height
    }
}

在 Rust 中，实现的实例语法的第一个参数总是 &self ，代表着实例本身。而其他实体变量则以 类的引用 类型传入。

静态方法

在 Rust 的 struct 中实现静态方法使用没有 &self 的函数完成。

impl Rect {
    fn square(&size: u32) -> Rect {
        Rect {
            width: size,
            height: size
        }
    }
}

注意: 在 Rust 中，并不要求把 struct 所有的实现都写在同一个 impl 中。可以把实现分开放在不同的 impl 语句中。

枚举

在 Rust 中同样有枚举类型，而且枚举类型比其他语言中的要更加丰富。如：

enum IPAddr {
    V4(u8, u8, u8, u8),
    V6(String)
}
enum Message {
    Quit,
    ChangeColor(i32, i32 ,i32)
}
impl Message {
    fn call(&self) {
        // method body would defined here
    }
}

自定义判别值

在Rust中，枚举类型还支持无字段的自定义判别值。如下：

enum Foo {
  Bar,            // 0
  Baz = 123,    // 123
  Quux,            // 123
}

在上面的例子中，枚举Foo的Bar字段没有指定值，所以判别值为0。而字段Baz显式指定了123，所以判别值为123,紧挨着Baz的Quux字段是Baz的判别值+1的值，即124。
需要注意的是，Rust中的枚举类型的判别值的类型默认为isize（当然，我们可以使用as关键字把个别值转换为其他类型）。
当我们需要指定枚举判别值的类型的时候，我们可以使用repr这个tract。如下：

#[repr(u8)]
enum Foo {
  Bar,
  Baz = 123,
  Quux,
}

在指定枚举判别值的时候，无论是我们手动指定的还是Rust通过推导出来的都不能和已有的判别值有冲突。比如以下的两个枚举类型都是错误的：

// 手动指定的判别值存在冲突的错误
enum SharedDiscriminantError {
    SharedA = 1,
    SharedB = 1,
}
// Rust推导出来的判别值存在冲突的错误
enum SharedDiscriminantError2 {
    Zero,    // 0
    One,    // 1
    OneToo,    // 1 (collision with previous!)
}

在枚举的判别值超出范围后，同样会发生错误。如下：

#[repr(u8)]
enum OverflowingDiscriminantError {
    Max = 255,
    MaxPlusOne // would be 256, but that overflows the enum.
}

Option枚举

在 Rust 中不存在 null 类型，但是存在一个叫 Option 的枚举。如下：

enum Option<T> {
    Some(T),
    None
}

match操作符

match操作符：

fn plus_one(x: Option<i32>) -> Option<i32> {
    match x {
        Some(x) => Some(x+1),
        Node => None,
    }
}

`_` 占位符

在 Rust 的 match中有一个特殊的占位符。它能占用所有的情况。它就是 _ 。如下：

let some_u8_value = 0u8;
match some_u8_value {
    1 => println!("one"),
    3 => println!("three"),
    5 => println!("five"),
    7 => println!("seven"),
    _ => (),
}

基础知识

类型