Rust实战系列-Rust介绍

abin

发布于 2023-03-21 20:24:00

1.3K0

发布于 2023-03-21 20:24:00

文章被收录于专栏：abin在路上

“学习资料：rust in action[1]

1. Rust 安装

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source "$HOME/.cargo/env"

2. hello world

创建 hello 项目

mkdir rust_tmp && cd rust_tmp
cargo new hello
cd hello
cargo run

看到这样的输出，就表示已经成功运行了 Rust 项目，尽管还没写任何代码。接下来看看发生了什么。

Cargo

Cargo 是一个同时提供项目构建和软件包管理功能的工具。也就是说，Cargo 执行 rustc（Rust 编译器）将 Rust 代码转换为可执行的二进制文件或共享库。cargo new会创建一个遵循标准模板的项目，目录结构如下：

Cargo.toml：描述项目的元数据信息（项目名，版本，依赖）

[package]
name = "hello"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]

src：源码目录，Rust 的源码文件扩展名为 .rs

创建好项目后，运行 cargon run 命令启动项目，这个过程完成了很多工作。

当敲下 cargon run 命令准备 run 项目时，实际上并没有可以 run 的内容，因此，cargon 会以 debug 模式编译项目，编译生成的可执行文件位于：target/debug/hello，然后执行这个文件，输出我们看到的内容：“Hello, world!”。

编译之后，项目的目录结构发生了变化，在根目录多了 Cargo.lock 文件和 target 目录，它们都是通过 cargon 进行管理的，不需要人工修改。

“Cargo.lock 指定了所有依赖项的确切版本号，这样，在 Cargo.toml 被修改之前，项目编译过程都会以相同的方式进行。

3. 第一个 Rust 项目

目标：输出不同语言的 hello world，理解 Rust 的两个特性：易于迭代和原生支持 Unicode。

直接修改 hello 项目中 src/main.rs 的内容：

fn main() {
    println!("Hello, world!");

    let southern_germany = "Grüß Gott!";
    let japan = "ハロー・ワールド";
    let china = "你好，世界！";

    let regions = [southern_germany, japan, china];

    for region in regions.iter() {
        println!("{}", &region);
    }

}

感叹号表示引用了一个宏
Rust 中的变量赋值，更恰当的称呼是变量绑定，使用 let 关键字
原生支持 Unicode，不需要考虑乱码问题
使用方括号表示数组
很多数据类型可以通过 iter()返回迭代器
&表示取出地址的值

修改后，项目的执行结果：

4. 文本处理

接下来，通过实例了解 Rust 的文本处理能力。主要包括以下特性：

常见的控制流机制：包括 for 循环和 continue 关键字
函数语法：虽然 Rust 不是面向对象的，因为它不支持继承，但它继承了面向对象语言的这个特点
高级编程：函数可以同时接受和返回函数。例如，实例第 19 行包括一个闭包，也被称为匿名函数或 λ（lambda）函数
类型注解：虽然用得不多，但偶尔也需要这些注解提示编译器（第 28 行）
有条件地编译：编译项目时，不会编译第 22-24 行的内容
隐式返回：Rust 提供了一个 return 关键字，但它通常被省略了

fn main() {                 // <1>
    let penguin_data = "\
    common name,length (cm)
    Little penguin,33
    Yellow-eyed penguin,65
    Fiordland penguin,60
    Invalid,data
    ";

    let records = penguin_data.lines();    // <2>

    for (i, record) in records.enumerate() {   // <3>
      if i == 0 || record.trim().len() == 0 {  // <4>
        continue;
      }

      let fields: Vec<_> = record     // <5>
        .split(',')                   // <6>
        .map(|field| field.trim())    // <7>
        .collect();                   // <8>

      if cfg!(debug_assertions) {              // <9>
        eprintln!("debug: {:?} -> {:?}",
                   record, fields);            // <10>
      }

      let name = fields[0];                    // <11>
      if let Ok(length) = fields[1].parse::<f32>() { // <12>
          println!("{}, {}cm", name, length);        // <13>
      }
    }
  }

可执行项目必须有一个 main 函数
将字符串按行拆分成切片
遍历每行字符串，i 是下标，record 是 item
跳过表头和空行
Vec 类型是向量的简称,向量是一种数组，在需要时可以动态扩展。下划线要求编译器推断出向量的元素类型。即变量名 fields，类型为 Vec，Vec 中元素类型 Rust 推导。
将 record 拆分成子字符串数组（以逗号为分隔符）
对于循环，可以使用高级函数，这里去掉空白字符。map()对 split 出来的每个子字符串应用函数 term()，field 临时变量表示每个子字符串（个人理解，不一定对）
Collects 迭代的结果并保存到向量 fields 中
这个代码块是为了调试，感叹号 ! 表示宏调用，宏类似于函数，返回代码而不是值，通常用于简化常见的模式
打印到标准错误输出， {:?} 语法请求这两种数据类型的默认调试格式作为输出
Rust 支持用整数下标对集合进行索引
将字符串解析为 f32（单精度浮点数）类型，parse 可以将字符串解析为任何实现了 FromStr trait 的类型（在 Rust 中，为了安全起见，不允许隐式的数据类型转换），使用 Ok()函数是为了在 if 的条件中创建 length 变量并进行赋值操作
打印到 stdout，{} 语法表示 Rust 应该使用用户自定义的方法来输出字符串的值，而不是用 {:?} 来显示调试结果

运行项目的输出结果：

可以看到有输出以 debug 开头的行，通过 --release 参数去掉这部分调试内容。

可以通过 -q（quiet）来进一步减少输出信息：

“严格来说，rustc 才是 Rust 编译器，但我们并没有使用它来编译项目，cargon 代替我们调用 rustc ，简化编译过程。如果希望查看 rustc 编译过程的详细信息，使用 --verbose 或 -v 参数。（需要保证目标文件未被编译，如果已经编译则没有对应输出） rustc：管理 Rust 源代码的编译 rustup：管理 Rust 的安装

5. Rust 的目标：安全

“we need a safer systems programming language[2]

Rust 不受以下情况的影响：

空悬指针（dangling pointers）：对程序运行过程中变得无效的数据进行实时引用（指针被释放后，仍然引用原来的内存）
数据竞争（data race）：由于外部环境的变化，无法确定程序在运行过程中的行为（非线程安全的情况下，多线程对同一个地址空间进行写操作）
缓存溢出（Buffer overflow）：试图访问一个只有 6 个元素数组的第 12 个元素
迭代器失效（Iterator invalidation）：已经迭代的内容被中途修改后导致的问题（python 中遇到过这种问题）

当程序在调试模式下被编译时，Rust 也会对整数溢出进行保护。

“什么是整数溢出：整数只能代表有限的一组数字；这些数字在内存中占用固定的长度。整数溢出是指当整数达到其极限时发生的情况。

空悬指针的示例代码

#[derive(Debug)]    // <1>
enum Cereal {       // <2>
    Barley, Millet, Rice,
    Rye, Spelt, Wheat,
}

fn main() {
    let mut grains: Vec<Cereal> = vec![];   // <3>
    grains.push(Cereal::Rye);               // <4>
    drop(grains);                           // <5>

    println!("{:?}", grains);               // <6>
}

允许 println! 打印 Cereal 枚举
枚举是一种有固定数量有效值的类型
初始化空的向量（数组）grains
向 grains 添加元素
删除向量 grains 和其中的内容
尝试访问被删除的值

代码中，Vec是用一个指向底层数组的内部指针实现的，尝试编译项目会出错：

数据竞争的示例代码

use std::thread;                          // <1>

fn main() {
    let mut data = 100;

    thread::spawn(|| { data = 500; });    // <2>
    thread::spawn(|| { data = 1000; });   // <2>

    println!("{}", data);
}

导入 thread 标准库
thread::spawn() 产生一个新的线程，thread::spawn()的闭合由竖条和大括号表示（例如，|| {...}）

使用 cargo 编译不会通过。

缓存溢出的示例代码

fn main() {
  let fruit = vec!['🥝', '🍌', '🍇'];

  let buffer_overflow = fruit[4];    // <1>

  assert_eq!(buffer_overflow, '🍉')  // <2>
}

这行代码会出现 panic
assert_eq!() 的两边必须相等，否则程序 panic

使用 cargo 编译不会通过。

迭代器失效的示例代码

fn main() {
  let mut letters = vec![            // <1>
      "a", "b", "c"
  ];

  for letter in letters {
      println!("{}", letter);
      letters.push(letter.clone());  // <2>
  }
}

初始化一个向量并允许修改（mut）
创建 letter 的副本并追加到 letters 的末尾

使用 cargo 编译不会通过。

6. Rust 的目标：生产力

在有选择的情况下，Rust 更倾向于选择对开发者来说最容易的选项。例如，在一个应该使用等于判断（==）的表达式中使用赋值（=）符号。

fn main() {
    let a = 10;

    if a = 10 {
        println!("a equals ten");
    }
}

这段代码是不能编译通过（C 语言没有这种能力）的，Rust 编译器会生成错误：

if 接收的不是一个整数，它接收的是一个赋值的结果。在 Rust 中，这是一个空白类型：()

Rust 提供了许多人性化的特点，包括泛型、复杂数据类型、模式匹配和闭包。

cargo 为 Rust 程序员提供了这些命令：

cargo init：创建一个 Rust 项目框架
cargo build：下载依赖项并编译代码
cargo run：功能与 cargo build 相同，编译好之后会运行生成的可执行文件
cargo doc：为当前项目中的每个依赖关系建立 HTML 文档

7. Rust 的目标：资源控制

从代码层面提升性能时，对内存访问、内存布局和特定 CPU 指令的控制都非常重要。

有时，必须要管理某些操作的方式
有时，数据存储在栈中而不是堆上可能很重要
有时，为一个共享值添加引用计数可能很有意义
通常，将引用传递给函数是有意义的
偶尔，为一个特定的访问模式创建一个自己的指针类型可能很有用

对于大多数情况，Rust 使用了合理的默认值，与它的 “零成本抽象”理念一致。

以下代码描述了多种创建整数值的方式，每种形式都提供了不同的语义和运行时特性：

use std::rc::Rc;
use std::sync::{Arc, Mutex};

fn main() {
    let a = 10;                       // <1>
    let b = Box::new(20);             // <2>
    let c = Rc::new(Box::new(30));    // <3>
    let d = Arc::new(Mutex::new(40)); // <4>

    println!("a: {:?}, b: {:?}, c: {:?}, d: {:?}", a, b, c, d);
}

存储在栈中
存储在堆中，也叫 boxed integer
boxed integer 被包裹在引用计数器中
整数被包裹在原子引用计数器中，并受到互斥锁的保护

8. Rust 的特征：性能

Rust 充分发挥计算机的可用性能，Rust 不依赖 GC（垃圾收集器）来保证内存安全。

硬件 CPU 的性能是固定的，因此，为了使软件的运行速度更快，需要减少 CPU 完成的工作，在 Rust 中，这个过程由编译器完成，尽可能减小程序的大小和运行速度。

默认提供有利于缓存的数据结构：通常，在 Rust 程序中使用数组保存数据，而不是由指针创建的深度嵌套树结构。这被称为面向数据编程。
先进的软件包管理器：cargo 的出现使我们很容易构建有许多依赖关系的大型项目。
函数静态调度：除非明确要求动态调度，函数默认静态调度，这使得编译器可以大量优化代码，有时甚至可以完全消除函数调用带来的开销。

9. Rust 的特征：并发

事实证明，要求计算机同时完成多件事情对软件工程师来说是很困难的。从操作系统层面考虑，如果程序员在并发访问的时候出现错误，会导致两个独立执行的线程可以任意破坏对方线程。Rust 对安全的强调跨越了独立线程的界限，允许程序员可以随意使用并发编程特性。

10. Rust 的特征：内存效率

Rust 使你能够创建需要最小内存的程序。如果需要，程序员可以使用固定大小的结构，并清楚地知道每个 byte 是如何被管理的。使用高级数据结构，如迭代和泛型，只会产生最小的运行开销。

11. Rust 的不足

循环数据结构

在 Rust 中很难对任意图结构这样的循环数据进行建模，实现一个双向链表是本科计算机科学水平的问题，但 Rust 的安全检查使得其很难实现。

编译时间

Rust 在编译代码时比它的同类语言要慢。它有一个复杂的编译器工具链，它接收多个中间表示，并向 LLVM 编译器发送大量代码。Rust 程序的“编译单元”不是一个单独的文件，而是一个完整的包。由于包可以包含多个模块，这些模块可以是非常大的编译单元。

严格性

在使用 Rust 编程时，除非一切都是正确的，否则程序不会编译。编译器是严格的，但很有帮助。

语言的尺寸

Rust 有一个复杂的类型系统，可以通过多种方式访问值，还有一个与强制转换对象生命期相匹配的权限系统。对于这些访问方式，程序员有选择负担。

炒作

用 Rust 编写的软件也不能完全避免安全问题。2015 年，随着 Rust 知名度的提高，SSL/TLS 的实现（即 OpenSSL 和苹果自己的 fork）被发现有严重的安全漏洞。这两个漏洞被非正式地称为 "Heartbleed "和 "goto fail"，为测试 Rust 声称的内存安全提供了机会。在这两个案例中，Rust 很可能起到了帮助作用，但仍然有可能写出存在类似问题的 Rust 代码。"

Heartbleed 是由于不正确地重复使用缓冲区造成的。缓冲区是内存中预留的用于接收输入数据的空间。如果缓冲区的内容在两次写入之间没有被清擦除，那么数据就会从前一次读取泄漏到下一次。如果缓冲区存储的是密钥等信息，将会对安全性造成严重破坏。

为什么会出现这种情况呢？为了追求性能，程序通常会重复使用缓冲区，从而减少向操作系统申请内存的频率。以下是示例代码：

let buffer = &mut[0u8; 1024];  // <1>

read_secrets(&user1, buffer);  // <2>
store_secrets(buffer);

read_secrets(&user2, buffer);  // <3>
store_secrets(buffer);

将一个引用（&）与一个包含 1024 个初始化为 0 的无符号 8 位整数（u8）的可变（mut）数组（[...]）绑定到变量缓冲区
用 user1 对象的字节来填充缓冲区
此时，buffer 仍然包含来自 user1 的数据，这些数据可能被 user2 覆盖，也可能不被覆盖

goto fail 是由程序员错误使用 C 语言设计造成的问题（C 编译器没有检查出这个缺陷）造成的。被设计用来验证加密密钥对的函数最终跳过了所有检查。以下是该函数的部分内容：

static OSStatus
// line break OK below? original exceeded 76 char limit
SSLVerifySignedServerKeyExchange(SSLContext *ctx, bool isRsa,
                                 SSLBuffer signedParams,
                                 uint8_t *signature, UInt16 signatureLen)
{
    OSStatus        err;

    ...

    // need line break below at 55 char max (because line contains annotation)
    if ((err = SSLHashSHA1.update(&hashCtx, &serverRandom)) != 0)
        goto fail;
    if ((err = SSLHashSHA1.update(&hashCtx, &signedParams)) != 0)    // <1>
        goto fail;
        goto fail;    // <2>
    if ((err = SSLHashSHA1.final(&hashCtx, &hashOut)) != 0)
        goto fail;

    err = sslRawVerify(ctx,
                       ctx->peerPubKey,
                       dataToSign,              /* plaintext \*/
                       dataToSignLen,           /* plaintext length \*/
                       signature,
                       signatureLen);
        if(err) {
        sslErrorLog("SSLDecodeSignedServerKeyExchange: sslRawVerify "
                    "returned %d\n", (int)err);
        goto fail;
    }

fail:
    SSLFreeBuffer(&signedHashes);
    SSLFreeBuffer(&hashCtx);
    return err;    // <4>

}

第一个 goto 在 if 判断为 true 时执行
当第一个 goto 判断为 false 时，err 的值为 0，此时会执行第二个 goto 语句，从而跳过 SSLHashSHA1.final() 和对 sslRawVerify() 的调用（重要）
返回值为 0，通过验证（实际上没有执行 SSLHashSHA1.final() 和 sslRawVerify()）

12. 应用场景

命令行程序

Rust 为创建命令行程序提供了三个主要优势：最小的启动时间、低内存消耗和容易部署。由于 Rust 不需要初始化解释器（Python, Ruby, ...）或虚拟机（Java, C#, ...），程序可以快速开始运行。

在 Rust 中，许多类型只作为编译器的提示而存在，在运行的程序中根本不占用内存。

用 Rust 编写的程序默认是作为静态二进制文件编译，避免了对共享库的依赖。

数据处理

由于对内存使用的控制和极短的启动时间，Rust 擅长处理文本和其他形式的数据内容。Rust 也是多个搜索引擎、数据处理引擎和日志解析系统的实现基础，提供了创建高吞吐量的数据管道的能力，而且内存占用率低且稳定。

扩展应用

Rust 非常适合扩展用动态语言编写的程序。这使得 JNI（Java Native Interface）扩展、C 扩展或 Rust 中的 Erlang/Elixir NIFs（本地实现的函数）成为可能。

资源受限的环境

物联网（IoT）时代的到来意味着数十亿不安全的设备暴露在网络中。通常情况下，物联网设备的固件更新频率很低，因此，从一开始就尽可能地保证这些设备的安全是至关重要的，Rust 可以发挥重要作用。

服务器端的应用

大多数用 Rust 编写的应用程序运行在服务器上，通常位于操作系统和应用程序之间。例如：npm 包注册表，sled（嵌入式数据库）

面向用户的软件

Rust 的设计中没有任何阻止其被部署到面向用户软件开发中内容。Servo，作为 Rust 早期开发的网络浏览器引擎，就是一个面向用户的应用程序。

桌面应用程序

桌面应用程序通常很复杂，难以设计，也难以支持。由于 Rust 的部署方式符合人机工程学原理，而且很严谨，很可能成为许多应用程序的选择。

移动端软件

Android 和 IOS 都提供了让 "本地应用程序"在系统上运行的能力，这是为了让用 C++编写的应用程序，如游戏，能够被部署到手机上。Rust 能够通过相同的接口与手机交互，没有额外的时间开销。

web 网站

浏览器供应商正在开发一种叫做 WebAssembly（Wasm）的标准，有望成为许多语言的编译器目标，Rust 就是其中一个。将一个 Rust 项目移植到浏览器上只需要两个额外的命令行命令。

系统编程

许多大型程序都是用 Rust 实现的，包括编译器（Rust 本身）、视频游戏引擎和操作系统。Rust 社区包括解析器生成器、数据库和文件格式的开发者。

参考资料

[1]

rust in action: https://livebook.manning.com/book/rust-in-action

[2]

we need a safer systems programming language: https://msrc-blog.microsoft.com/2019/07/18/we-need-a-safer-systems-programming-language/

本文参与腾讯云自媒体同步曝光计划，分享自微信公众号。

原始发表：2022-08-19，如有侵权请联系 cloudcommunity@tencent.com 删除

rust

本文分享自 abin在路上微信公众号，前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

登录后参与评论

0 条评论

热度