关于前端:前端眼中的Rust

5次阅读

共计 9783 个字符，预计需要花费 25 分钟才能阅读完成。

引言：本文推选自腾讯云开发者社区「技思广益 · 腾讯技术人原创集」专栏。该专栏是腾讯云开发者社区为腾讯技术人与宽泛开发者打造的分享交换窗口。栏目邀约腾讯技术人分享原创的技术积淀，与宽泛开发者互启迪共成长。作者是 [腾讯云开发者社区] 的作者——Altria Pendragon

rust 是一门强类型的、编译型的、内存平安的编程语言。最早版本的 Rust 本来是 Mozilla 基金会的一名叫 Graydon Hoare 的员工的私人我的项目，2009 年开始，Mozilla 开始赞助者们我的项目的倒退，并于 2010 年，Rust 实现了自举——应用 Rust 构建了 Rust 的编译器。
Mozilla 将 Rust 利用到构建新一代浏览器排版引擎 Servo 当中——Servo 的 CSS 引擎在 2017 年开始，集成到了 FireFox 当中去。
Rust 本来作为一种内存平安的语言，其初衷是代替 C ++ 或者 C，来构建大型的底层我的项目，如操作系统、浏览器等，然而因为 Mozilla 的这一层关系，前端业界也留神到了这门语言，并将它利用在了其余畛域，其生态也缓缓凋敝起来。

家喻户晓，当下支流的编程语言当中个别分为两类，一类是主动 GC 的，如 Golang、Java、JavaScript 等，另一类则是 C ++ 和 C，用户须要手动治理内存。
大部分语言的内存模型都是大同小异的。
当代码被执行时，一个个变量所对应的值，就被顺次入栈，当代码执行完某一个作用域时，变量对应的值也就跟着出栈，栈作为一个先进后出的构造十分合乎编程语言的作用域——最外层的作用域先申明、后完结。然而栈无奈在两头插入值，因而栈当中只能存储一旦申明、占用空间就不会扭转的值，比方 int、char，或者是固定长度的数组，而其余值，比方可变长度的数组 vector，可变长度的字符串 String，是无奈被塞进栈当中的。
当编程语言须要一个事后不晓得多大的空间时，就会向操作系统申请，操作系统开拓一块空间，并将这一块空间的内存地址——指针返回给程序，于是编程语言就胜利将这些数据存到了堆中，并将指针存到栈当中去——因为指针的大小是固定的，32 位程序的指针肯定是 32bit，64 位程序的指针也必定是 64bit。
栈中的数据是不须要做内存治理的，随着代码执行，一个变量很容易被判断还有没有用——只有这个变量的作用域完结，那么再也无奈读取到这个变量的值，那么这个变量必定没用了。只须要随着作用域的申明与完结，一直的入栈和出栈就足以治理栈的内存了，不须要程序员操心。
然而堆当中的数据就不行了，因为程序拿到的只是一个内存指针，理论的内存块不在栈当中，无奈随着栈主动销毁。程序也不能在栈当中的内存指针变量销毁时，就将指针对应的空间主动清理——因为可能有多个变量保留的指针都指向了同一个内存块，此时清理这个内存块，会导致意料之外的状况。

基于此，有的程序自带一套非常复杂的 GC 算法，比方通过援用计数，统计一个内存区块的指针到底保留在多少个变量当中，当援用计数归 0 时，就代表所有的指向此处的指针都被销毁了，此处内存块就能够被清理。而有的程序则须要手动治理内存空间，任何堆当中开拓的空间，都必须手动清理。
这两种方法各有优劣，前者导致程序必须带一个 runtime，runtime 当中寄存 GC 算法，导致程序体积变大，而后者，则变得内存不平安，或者说，因为内存治理的责任到了程序员头上，程序员的程度极大水平上影响了代码安全性，遗记回收会导致程序占用的内存越来越大，回收谬误会导致删掉不应该删的数据，除此以外还有通过指针批改数据的时候溢出到其余区块导致批改了不应批改的数据等等。

而 Rust 则采取了一种全新的内存治理形式。这个形式能够简略概括为：程序员和编译器达成某一种约定，程序员必须依照这个约定来写代码，而当程序员依照这个约定来写代码时，那么一个内存区块是否还在被应用，就变得十分清晰，清晰到不须要程序跑起来，就能够在编译阶段晓得，那么编译器就能够将内存回收的代码，插入到代码的特定地位，来实现内存回收。换句话说，Rust 实质上是通过限度援用的应用，将那些【不好判断某块地址是否还在应用】的状况给躲避了，残余的状况，都是很好判断的状况，简略到不须要业余的程序员，只须要一个编译器，就能很好的判断了。

这样的一大益处是：
不须要 GC 算法和 runtime，实质上还是手动回收，只不过编译器把手动回收的代码插入进去了，程序员不须要本人写而已。只有编译能够通过，那么就肯定是内存平安的。

rust 的内存平安机制能够说是独创的，它有一套非常简单、便于了解的机制，叫做所有权零碎，这外面会波及到两个外围概念，所有权和借用。

任何值，包含指针，都要绑定到一个变量，那么，咱们就称这个变量领有这个值的所有权，比方以下代码，变量 str 就领有“hello”的所有权。
let str = "hello"
当 str 所在的作用域完结时，str 的值就会被清理，str 也不再无效。这个和简直所有支流语言都是统一的，没有什么问题。也很好了解。然而留神一下，Rust 自身辨别了可变长度的字符串和不可变长度的字符串，上文是一个不可变长度的字符串，因为其长度不可变，能够保留在栈当中，于是上面这一段代码能够正确执行，就像其余简直所有支流语言一样：

let str = "hello world";
let str2 = str;
println!("{}", str);
println!("{}", str2);

但如果咱们引入一个保留在堆里、长度可变的字符串，咱们再来看看同样的代码：

fn main() {let str = String::from("hello world");
  let str2 = str;

  println!("{}", str);
  println!("{}", str2);
}

此时，咱们会诧异地发现，代码报错了。为什么呢？
起因在于，第一段代码当中，str 这个变量的值，保留在栈里，str 这个变量所领有的，是 hello world 这一串字符串自身。所以如果令 str2=str，那么相当于又创立了一个 str2 变量，它也领有这么一串截然不同的字符串，这里产生的是“内存拷贝”。两个变量各自领有 hello world 这一个值的所有权，只不过两者的 hello world 不是同一个 hello world。
而第二段代码当中，咱们拿到的 str，实质上只是一个指向到某一个内存区块的地址，而这个地址，当咱们另 str2=str 的时候，实际上是将这一个地址的值赋值给 str2，如果是在其余语言当中，这么写极大概率是没问题的，然而 str 和 str2 会指向同一个内存地址，批改 str 的时候，str2 也变了。
然而 rust 当中，同一个值只能被绑定到一个同一个变量，或者说，某一个变量对这一个值有所有权，就像一个货色同一时间只能属于同一个人一样！当令 str2=str 的时候 str 保留的地址值，就不再属于 str 了，它属于 str2，这叫做【所有权转移】。所以 str 生效了，咱们应用一个生效的值，那么天然报错了。
以下这些状况都能导致所有权转移：
上文提到的赋值操作：

let str = String::from("hello world"); let str2=str; //str 失去所有权！

将一个值传进另一个作用域，比方函数：

let str=String::from("hello world"); some_func(str); // 此时 str 生效。

1 这样，咱们就能够很简略的发现，对于同一个内存区块地址，它同时只能保留在一个变量里，这个变量如果出了作用域，导致这个变量读取不到了，那么这个内存地址就注定永远无法访问了，那么，这个内存区块，就能够被开释了。这个判断过程非常简单，齐全能够放在动态查看阶段让编译器来实现。所以 rust 能够很简略的实现内存平安。但，上述的写法是很反人类的，这的确解决了内存平安的问题，然而不好用。比方我须要将 str 传入一个办法做一些逻辑操作，做完操作之后我还心愿我能读取到这个 str，比方相似于上面这段代码：fn main() {
let mut str1 = String::from(“hello world”); // 这里的 mut 只是标注这个变量是可变的变量，而十分量。

add_str(mut str1, "!!!");

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

fn add_str(str_1: String, str_2: &str) {str_1.push_str(str_2);
}

咱们心愿对 str 进行操作，前面增加三个感叹号而后打印进去，这段代码必定是谬误的，因为当 str 传入 add_str 办法时，就将所有权转移到了 add_str 办法内的变量 str_1 上，它不再具备所有权，所以就不能应用了，这种状况其实很常见，单纯的所有权机制让这个问题复杂化了，所以 rust 还有一个机制来解决上面的问题：【援用和借用】。

尽管一个值只能有一个变量领有其所有权，然而，就像人能够把本人的货色借给其他人用，借给不同的人用一样，变量也能够把本人领有的值给借出去，上述代码稍作批改：

fn main() {let mut str1 = String::from("hello world");

  add_str(&mut str1, "!!!");

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

fn add_str(str_1: &mut String, str_2: &str) {str_1.push_str(str_2);
}

add_str 传入的不再是 mut str，而是 &mut str1，这就相当于从 mut str1 上借了这份数据来应用，但实际上的所有权仍在 str1 上，内存区块的回收条件，依然是【str1 所在的作用域执行结束，str1 保留的内存地址北出栈而销毁】。
这两种机制，所造成的实质是：对于一块内存的援用计数，变得异样简略，只有这个内存地址对应的变量在堆里，援用计数就是 1，否则就是 0，只有这两种状况。相对不存在，多个变量都指向同一个内存地址的状况，这一下子就把援用计数 GC 算法的复杂度给大幅度降低了。升高到不须要一个简单的运行时，动态查看阶段就能够失去所有须要 GC 的机会并进行 GC 了。

rust 作为一个十分年老的编程语言，它领有许多新语言常见的个性，在个性方面有点相似于 Golang、ts 和高版本 C ++ 的混合。比如说：
没有继承，只有组合，相似于 Golang。继承带来的子类型会带来数学上的不可判定性，即存在一种可能，能够结构出一段蕴含子类型的代码，无奈对它进行类型推倒和类型查看，因为类型不可判定，体现在工程上，那就是编译器在类型推倒时陷入死递归，无奈进行。同时，多层的继承也让代码变得难以保护，越来越多的新语言摈弃了继承。
有一个好用的包管理器 cargo，能够不便的治理各项依赖。依赖存在我的项目间的隔离，而非对立放在一块，这一点相似于 nodejs，golang 也在推动依赖的我的项目间隔离。我的项目内装置的依赖被写在 cargo.toml 当中，并且存在 cargo.lock，将依赖锁定在特定版本（简直和 npm 统一）。
大量高级的语言个性：模式匹配、没有 null 然而有 Option（任何可能报错、返回空指针的中央，都能够返回一个 Option 枚举，基于模式匹配来匹配胜利和失败两种状况，null 不再对开发者裸露）、原生的异步编程反对等等。

Rust 加上上述的一些个性，使得它成为了一个 C ++ 的完满代替。目前，前端畛域应用 Rust 有以下两个方向，一个，是应用 Rust 来打造更高性能的前端工具，另一个是作为 WASM 的编程语言，编译成能够在浏览器当中跑的 WASM 模块。

在之前，前端畛域如果心愿做一个高性能的工具，那么惟一抉择就是 gyp，应用 C ++ 编写代码，通过 gyp 编译成 nodejs 能够调用的 API，saas-loader 等大家耳熟能详的库都是这样实现的。但更多的状况下，前端的大部分工具都是齐全不在乎性能，间接用 js 写的，比方 Babel、ESLint、webpack 等等，有很大一部分起因在于 C ++ 切实不太好入门，光是几十个版本的 C ++ 个性，就足够让人花掉大量的工夫来学习，学习完之后还要大量的开发教训才能够学会如何更好的做内存治理、防止内存泄露等问题。而 Rust 不一样，它足够年老，没有几十个版本的规范、有和 npm 一样古代的包管理器，还有更要害的，不会内存泄露，这使得即使 rust 的历史不长，即使 C ++ 也能写 Nodejs 扩大，但前端畛域依然呈现了大量的 Rust 写的高性能工具。比方：
swc 一个 Rust 写的，封装出 Nodejs API 的，性能相似 Babel 的 JS polyfill 库，但在 Rust 加持之下，它的性能能够达到 Babel 的 40 倍。
Rome 也是基于 Rust 实现，其作者也是是 Babel 的作者 Sebastian。
Rome 涵盖了编译、代码检测、格式化、打包、测试框架等工具。它旨在成为解决 JavaScript 源代码的综合性工具。
RSLint，一个 Rust 写的 JS 代码 lint 工具，旨在代替 ESLint。随着前端愈发简单，咱们必定会逐步谋求性能更好的工具链，兴许过几年咱们就会看到应用 swc 和 Rome 正式版的我的项目跑在生产环境当中了。

另外，在有了 WASM 之后，前端也在寻找一个最完满反对 WASM 的语言，目前来看，也很有可能是 Rust。对于 WASM 来说，带运行时的语言是不可承受的，因为带有运行时的语言，打包成 WASM 之后，不仅蕴含了咱们本人写的业务代码，同时还有运行时的代码，这外面蕴含了 GC 等逻辑，这大大提高了包体积，并不利于用户体验，将带运行时的语言剔除之后，前端能抉择的范畴便不大了，C++、Rust 外面，Rust 的劣势使得前端界更违心抉择 Rust。同时，Rust 在这方面，也提供了不错的反对，Rust 的官网编译器反对将 Rust 代码编译成 WASM 代码，再加上 wasm-pack 这种开箱即用的工具，使得前端是能够很快的构建 wasm 模块的。这里做一个简略的演示，上面这一串代码是我从上文提到的 swc 外面挖出来的：

#![deny(warnings)]
#![allow(clippy::unused_unit)]

// 援用其余的包或者规范库、内部库
use std::sync::Arc;

use anyhow::{Context, Error};
use once_cell::sync::Lazy;
use swc::{config::{ErrorFormat, JsMinifyOptions, Options, ParseOptions, SourceMapsConfig},
    try_with_handler, Compiler,
};
use swc_common::{comments::Comments, FileName, FilePathMapping, SourceMap};
use swc_ecmascript::ast::{EsVersion, Program};

// 引入 wasm 相干的库
use wasm_bindgen::prelude::*;

// 应用 wasm_bindgen 宏，这里的意思是，上面这个办法编译成 wasm 之后，办法名是 transformSync，// TS 的类型是 transformSync
#[wasm_bindgen(
    js_name = "transformSync",
    typescript_type = "transformSync",
    skip_typescript
)]
#[allow(unused_variables)]
// 定义一个能够办法，总共办法因为是 pub 的，因而能够被内部调用。这个办法的目标是：将高版本 JS 本义成低版本 JS
// 具体的外部逻辑咱们齐全不去管。pub fn transform_sync(
    s: &str,
    opts: JsValue,
    experimental_plugin_bytes_resolver: JsValue,
) -> Result<JsValue, JsValue> {console_error_panic_hook::set_once();

    let c = compiler();

    #[cfg(feature = "plugin")]
    {if experimental_plugin_bytes_resolver.is_object() {use js_sys::{Array, Object, Uint8Array};
            use wasm_bindgen::JsCast;

            // TODO: This is probably very inefficient, including each transform
            // deserializes plugin bytes.
            let plugin_bytes_resolver_object: Object = experimental_plugin_bytes_resolver
                .try_into()
                .expect("Resolver should be a js object");

            swc_plugin_runner::cache::init_plugin_module_cache_once();

            let entries = Object::entries(&plugin_bytes_resolver_object);
            for entry in entries.iter() {
                let entry: Array = entry
                    .try_into()
                    .expect("Resolver object missing either key or value");
                let name: String = entry
                    .get(0)
                    .as_string()
                    .expect("Resolver key should be a string");
                let buffer = entry.get(1);

                //https://github.com/rustwasm/wasm-bindgen/issues/2017#issue-573013044
                //We may use https://github.com/cloudflare/serde-wasm-bindgen instead later
                let data = if JsCast::is_instance_of::<Uint8Array>(&buffer) {JsValue::from(Array::from(&buffer))
                } else {buffer};

                let bytes: Vec<u8> = data
                    .into_serde()
                    .expect("Could not read byte from plugin resolver");

                // In here we 'inject' externally loaded bytes into the cache, so
                // remaining plugin_runner execution path works as much as
                // similar between embedded runtime.
                swc_plugin_runner::cache::PLUGIN_MODULE_CACHE.store_once(&name, bytes);
            }
        }
    }

    let opts: Options = opts
        .into_serde()
        .context("failed to parse options")
        .map_err(|e| convert_err(e, ErrorFormat::Normal))?;

    let error_format = opts.experimental.error_format.unwrap_or_default();

    try_with_handler(c.cm.clone(),
        swc::HandlerOpts {..Default::default()
        },
        |handler| {
            c.run(|| {
                let fm = c.cm.new_source_file(if opts.filename.is_empty() {FileName::Anon} else {FileName::Real(opts.filename.clone().into())
                    },
                    s.into(),);
                let out = c
                    .process_js_file(fm, handler, &opts)
                    .context("failed to process input file")?;

                JsValue::from_serde(&out).context("failed to serialize json")
            })
        },
    )
    .map_err(|e| convert_err(e, error_format))
}

代码的非凡之处在于一些办法上加了这样的派生，所谓的派生，指的是咱们只有加上这一段代码，编译器就会帮咱们实现约定好的逻辑：

#[wasm_bindgen(
    js_name = "transformSync",
    typescript_type = "transformSync",
    skip_typescript
)]

当加上这一段派生之后，编译器就会将上面的函数编译为二进制的 WASM 函数供 JS 调用。
咱们应用 wasm-pack 对代码进行编译打包：

wasm-pack build --scope swc -t nodejs --features plugin

拿到以下这些文件：

├── binding_core_wasm.d.ts
├── binding_core_wasm.js
├── binding_core_wasm_bg.js
├── binding_core_wasm_bg.wasm
├── binding_core_wasm_bg.wasm.d.ts
└── package.json

而后就能够在 JS 当中调用了：

// index.js
let settings = {
    jsc: {
        target: "es2016",
        parser: {
            syntax: "ecmascript",
            jsx: true,
            dynamicImport: false,
            numericSeparator: false,
            privateMethod: false,
            functionBind: false,
            exportDefaultFrom: false,
            exportNamespaceFrom: false,
            decorators: false,
            decoratorsBeforeExport: false,
            topLevelAwait: false,
            importMeta: false,
        },
    },
};

let code = `
let a = 1;
let b = {
    c: {d: 1}

};
console.log(b?.c?.d);

let MyComponent = () => {return (<div a={10}>
        <p>Hello World!</p>
    </div>);
}
`;


const wasm = require('./pkg/binding_core_wasm');
console.log(wasm.transformSync(code, settings))

能够看出，只有当下已存在一个 Rust 库，那么将其转变为 WASM 是非常简单的，读者也能够去折腾一下 Golong、C++ 的 WASM，会发现 Rust 的整个折腾过程比 Golang、C++ 要简略不少。

尽管我上文说了许多 Rust 的好，但我在学习 Rust 的时候却有些备受打击，很大的一个起因在于，Rust 过于特立独行了。
举一个很简略的例子，在个别的编程语言当中，申明变量和常量，要么有不同的申明形式，如 javascript 辨别 let 和 const，go 辨别 const 和 var，要么就是申明进去默认是变量，常量须要额定申明，比方 Java 申明的变量后面加 final 就会是常量，而 Rust 就很非凡，申明进去的默认是常量，变量反而须要额定申明，let a= 1 失去的是常量，let mut a= 1 才是变量。
上述提到的，Rust 比拟特地的点十分多，尽管大部分都只是设计理念不同，没有高下优劣之分，但如此设计的确会给其余语言的开发者带来一部分心智累赘。
从我的学习教训来看，Rust 自身的学习难度并不低，学习起来实际上未必就比 C ++ 简略，社区内也有想学好 Rust 得先学习 C ++，不然齐全体会不到 Rust 优雅的说法。想学习 Rust 的同学，可能须要做好一些心理准备。

正文完