2021-07-13

元组

是不同类型值的集合。元组是使用括号构造()，且每个元组本身是具有式签名的值 (T1, T2, …)，其中T1，T2是所述类型的成员。函数可以使用元组返回多个值，因为元组可以保存任意数量的值。

数组

是T存储在连续内存中的相同类型对象的集合。数组是使用方括号创建的[]，它们的长度（在编译时已知）是它们类型签名的一部分[T; length]。

切片类似于数组，但它们的长度在编译时是未知的。相反，切片是一个双字对象，第一个字是指向数据的指针，第二个字是切片的长度。字长与 usize 相同，由处理器架构决定，例如 x86-64 上的 64 位。切片可用于借用数组的一部分，并具有类型签名 &[T]。

结构

枚举
常数

变量绑定

可变性

默认情况下，变量绑定是不可变的，但这可以使用mut修饰符覆盖。

范围和阴影

变量绑定有一个作用域，并且被限制在一个块中。块是用大括号括起来的一组语句{}。

先申报

可以先声明变量绑定，然后再初始化它们。但是，这种形式很少使用，因为它可能导致使用未初始化的变量。

冷冻

当数据以不变的名称绑定在一起时，它也会冻结。在不可变绑定超出范围之前，无法修改冻结的数据：

fn main() {
    let mut _mutable_integer = 7i32;

    {
        // Shadowing by immutable `_mutable_integer`
        let _mutable_integer = _mutable_integer;

        // Error! `_mutable_integer` is frozen in this scope
        _mutable_integer = 50;
        // FIXME ^ Comment out this line

        // `_mutable_integer` goes out of scope
    }

    // Ok! `_mutable_integer` is not frozen in this scope
    _mutable_integer = 3;
}

类型

铸件

Rust 不提供原始类型之间的隐式类型转换（强制）。但是，可以使用as关键字执行显式类型转换（强制转换）。

整数类型之间的转换规则通常遵循 C 约定，除非 C 具有未定义的行为。整型之间的所有类型转换的行为在 Rust 中都有很好的定义。

文字

数字文字可以通过添加类型作为后缀来进行类型注释。例如，要指定文字42应具有 type i32，请写入42i32。

无后缀数字文字的类型取决于它们的使用方式。如果不存在约束，编译器将i32用于整数和f64浮点数。

fn main() {
    // Suffixed literals, their types are known at initialization
    let x = 1u8;
    let y = 2u32;
    let z = 3f32;

    // Unsuffixed literals, their types depend on how they are used
    let i = 1;
    let f = 1.0;

    // `size_of_val` returns the size of a variable in bytes
    println!("size of `x` in bytes: {}", std::mem::size_of_val(&x));
    println!("size of `y` in bytes: {}", std::mem::size_of_val(&y));
    println!("size of `z` in bytes: {}", std::mem::size_of_val(&z));
    println!("size of `i` in bytes: {}", std::mem::size_of_val(&i));
    println!("size of `f` in bytes: {}", std::mem::size_of_val(&f));
}

前面代码中用到的一些概念还没有解释，这里给不耐烦的读者简单解释一下：

std::mem::size_of_val是一个函数，但以其完整路径调用。代码可以分成称为模块的逻辑单元。在这种情况下， size_of_val函数定义在mem模块中，mem模块定义在std crate 中。有关更多详细信息，请参阅 模块和板条箱。

推理

类型推理引擎非常聪明。它不仅仅是在初始化期间查看值表达式的类型。它还查看之后如何使用变量来推断其类型。这是类型推断的高级示例：

fn main() {
    // Because of the annotation, the compiler knows that `elem` has type u8.
    let elem = 5u8;

    // Create an empty vector (a growable array).
    let mut vec = Vec::new();
    // At this point the compiler doesn't know the exact type of `vec`, it
    // just knows that it's a vector of something (`Vec<_>`).

    // Insert `elem` in the vector.
    vec.push(elem);
    // Aha! Now the compiler knows that `vec` is a vector of `u8`s (`Vec<u8>`)
    // TODO ^ Try commenting out the `vec.push(elem)` line

    println!("{:?}", vec);
}

不需要变量的类型注释，编译器很高兴，程序员也很高兴！

别名

该type语句可用于为现有类型赋予新名称。类型必须有UpperCamelCase名称，否则编译器会发出警告。唯一例外的规则是基本类型：usize，f32，等。

转换

from 和 into

tryfrom 和 tryinto

往返字符串

控制流程

if_else

用if-分支else类似于其他语言。与它们中的许多不同，布尔条件不需要用括号括起来，每个条件后跟一个块。if-else条件是表达式，并且所有分支必须返回相同的类型。

loop

Rust 提供了一个loop关键字来表示无限循环。

该break语句可用于随时退出循环，而该 continue语句可用于跳过剩余的迭代并开始新的迭代。

while

for loops

该for in构造可用于遍历Iterator. 创建迭代器的最简单方法之一是使用范围表示法a…b。这会 以 1 的步长产生从a（包含）到b（不包含）的值。或者，a…=b可用于包含两端的范围.

fn main() {
    // `n` will take the values: 1, 2, ..., 100 in each iteration
    for n in 1..101 {
        if n % 15 == 0 {
            println!("fizzbuzz");
        } else if n % 3 == 0 {
            println!("fizz");
        } else if n % 5 == 0 {
            println!("buzz");
        } else {
            println!("{}", n);
        }
    }
}

 fn main() {
    // `n` will take the values: 1, 2, ..., 100 in each iteration
    for n in 1..=100 {
        if n % 15 == 0 {
            println!("fizzbuzz");
        } else if n % 3 == 0 {
            println!("fizz");
        } else if n % 5 == 0 {
            println!("buzz");
        } else {
            println!("{}", n);
        }
    }
}

for和迭代器

该for in构造能够以Iterator多种方式与 交互。正如Iterator trait部分所讨论的，默认情况下，for 循环会将into_iter函数应用于集合。但是，这并不是将集合转换为迭代器的唯一方法。

into_iter，iter并且iter_mut都通过提供对其中数据的不同视图，以不同的方式处理集合到迭代器的转换。

iter- 这通过每次迭代借用集合的每个元素。从而使集合保持不变并可在循环后重复使用。

fn main() {
    let names = vec!["Bob", "Frank", "Ferris"];

    for name in names.iter() {
        match name {
            &"Ferris" => println!("There is a rustacean among us!"),
            // TODO ^ Try deleting the & and matching just "Ferris"
            _ => println!("Hello {}", name),
        }
    }
    
    println!("names: {:?}", names);
}

into_iter- 这会消耗集合，以便在每次迭代时提供准确的数据。一旦集合被消耗，它就不再可用于重用，因为它已在循环中“移动”。

fn main() {
    let names = vec!["Bob", "Frank", "Ferris"];

    for name in names.into_iter() {
        match name {
            "Ferris" => println!("There is a rustacean among us!"),
            _ => println!("Hello {}", name),
        }
    }
    
    println!("names: {:?}", names);
    // FIXME ^ Comment out this line
}

iter_mut - 这会可变地借用集合的每个元素，允许就地修改集合。

fn main() {
    let mut names = vec!["Bob", "Frank", "Ferris"];

    for name in names.iter_mut() {
        *name = match name {
                   &mut "Ferris" => "There is a rustacean among us!",
            _ => "Hello",
        }
    }

    println!("names: {:?}", names);
}

match

Rust 通过match关键字提供模式匹配，它可以像 C 一样使用switch。评估第一个匹配臂，并且必须涵盖所有可能的值。
结构元组，结构体
对于指针，需要区分解构和解引用，因为它们是不同的概念，与C.

取消引用用途 *
解构使用&, ref, 和ref mut

结构

卫兵：编译器不会检查任意表达式是否已检查所有可能的条件。因此，您必须_在最后使用模式。
捆绑：
if let
while let

function

方法

方法是附加到对象的函数。这些方法可以通过self关键字访问对象及其其他方法的数据。方法在impl块下定义。

关闭

闭包是可以捕获封闭环境的函数。例如，一个捕获 x 变量的闭包：

|val| val + x
闭包的语法和功能使其非常便于即时使用。调用闭包就像调用函数一样。但是，可以推断输入和返回类型，并且必须指定输入变量名称。

闭包的其他特征包括：

使用||而不是()围绕输入变量。
{}单个表达式的可选正文分隔 ( )（否则为强制性）。
捕获外部环境变量的能力。

模块

能见度

默认情况下，模块中的项目具有私有可见性，但这可以用pub修饰符覆盖。只有模块的公共项可以从模块范围之外访问。

结构可见性

结构对其字段具有额外的可见性。可见性默认为私有，并且可以用pub修饰符覆盖。这种可见性仅在从定义它的模块外部访问结构时才重要，并且具有隐藏信息（封装）的目标。

该use声明

该use声明可用于将完整路径绑定到新名称，以便于访问。

super 和 self

的super和self关键字可以在路径中使用访问的项目时，以除去模糊并防止不必要的路径硬编码。

文件层次结构

模块可以映射到文件/目录层次结构。让我们分解文件中的 可见性示例：

Crates板条箱

cargo

依赖关系
公约
测试
构建脚本

属性

死码

crates

该crate_type属性可用于告诉编译器一个 crate 是二进制文件还是库（甚至是哪种类型的库），该crate_name 属性可用于设置 crate 的名称。

配置文件

某些条件，例如target_os隐式提供rustc，但自定义条件必须传递给rustc使用–cfg标志。

泛型

范围规则

作用域在所有权、借用和生命周期中扮演着重要的角色。也就是说，它们向编译器指示何时借用有效、何时可以释放资源以及何时创建或销毁变量。

RAII

Rust 中的变量不仅仅在堆栈中保存数据：它们还拥有 资源，例如Box拥有堆中的内存。Rust 强制执行RAII （资源获取即初始化），因此只要对象超出范围，就会调用其析构函数并释放其拥有的资源。

此行为可防止资源泄漏错误，因此您永远不必手动释放内存或再次担心内存泄漏！

所有权和搬家

因为变量负责释放自己的资源， 资源只能有一个 owner。这也可以防止资源被多次释放。请注意，并非所有变量都拥有资源（例如引用）。

在进行赋值 ( let x = y) 或按值 ( foo(x))传递函数参数时，资源的所有权将被转移。在 Rust 中，这被称为移动。

移动资源后，不能再使用以前的所有者。这避免了创建悬空指针。

可变性

当所有权转移时，数据的可变性可以改变。

部分动作

在单个变量的解构中，可以同时使用by-move和 by-reference模式绑定。这样做将导致变量的部分移动，这意味着变量的一部分将被移动，而其他部分将保持不变。在这种情况下，父变量不能作为一个整体使用，但是仍然可以使用仅引用（而不是移动）的部分。

借贷

大多数情况下，我们希望在不拥有所有权的情况下访问数据。为了实现这一点，Rust 使用了借用机制。T可以通过引用 ( &T)传递对象，而不是按值 ( )传递对象。

编译器静态地保证（通过其借用检查器）引用 始终指向有效对象。也就是说，虽然存在对对象的引用，但该对象不能被销毁。

• 可变性
• • 可以使用 可变地借用可变数据&mut T。这称为可变引用，并为借用者提供读/写访问权限。相反，&T通过不可变引用借用数据，借用者可以读取数据但不能修改它
• 别名
• • 数据可以不可变地借用任意次，但在不可变地借用的同时，不能可变地借用原始数据。另一方面，一次只 允许一个可变借用。只有在最后一次使用可变引用后才能再次借用原始数据。
• 参考模式
• • 当通过let绑定进行模式匹配或解构时，ref 关键字可用于获取对结构/元组字段的引用。下面的示例显示了一些可能有用的实例

lifetime

寿命是一个构建体中的编译器（或更具体地，其借检查器）使用，以确保所有借位是有效的。具体来说，变量的生命周期从创建时开始，到销毁时结束。虽然生命周期和作用域经常一起被引用，但它们并不相同。

以我们通过 借用变量的情况为例&。借用的生命周期由它的声明位置决定。因此，只要在贷方被销毁之前结束，借入就是有效的。但是，借用的范围取决于引用的使用位置。

trait

宏规则！

代号

宏的参数以美元符号为前缀$，类型用指示符注释：

错误处理

panic

我们将看到的最简单的错误处理机制是panic. 它会打印一条错误消息，开始展开堆栈，然后通常会退出程序。在这里，我们明确调用panic我们的错误条件：

？

标准库类型