前段时间，和群友偶然聊到了GUI话题，期望可以使用GUI应用来替代前端工具，比如代码规范/校验等，但是查找了相关资料，关于代码管理类的GUI程序非常少（甚至说是一个空白），总结了以下大概有以下几点：

1. 安全性问题，用户不期望将代码上传到服务端
2. GUI设计不贴合程序员，提升不了工作效率
3. 极难扩展，大多数基于代码管理的SASS服务，程序员不可以开发插件去扩展已有功能

如果你是Mac用户，相信你一定知道RayCast，RayCast本质上是一个代替Mac启动器的应用程序，但是由于其强大的插件机制，可以让前端开发者方便地开发各种插件，比如翻译/词典/截图等等，如下图是我安装的一款颜色选择器插件：

RayCast的最佳设计不仅限于此，它还提供了‘快捷键’功能，使其通过预定义好的快捷键，轻松的唤起用户装的指定扩展，例如在Mac中有一款大名鼎鼎的剪贴板软件叫作Paste，而在RayCast中可以直接免费的使用类似的功能，装好指定的插件之后，只需要快捷键就可以唤出剪贴板软件：

另外，有曾接触过运维的同学们应该都知道一个国产的面板应用“宝塔”，虽然这款软件面向的是初级运维人员，但是其免费易用的特性让不少非专业的开发人员也能管理服务器。比如本博客就在使用宝塔软件，是我在上高中时使用宝塔搭建的，已经运行有5，6年了。抛开安全问题，作为一个在当时不懂运维的同学也能深深产生依赖，一直沿用至今，这或许就是GUI的魅力。

读者们对于GUI程序并不陌生，我们在使用的Mac，iphone等操作系统都在时时刻刻的服务用户；同样我们开发者领域也有一些出色的GUI程序，比如Clashx，SourceTree帮助着我们日常开发。

但是有没有一款工具可以改变开发习惯，真正的提高效率，并且兼顾安全。拿前端领域举例，诸如Eslint等工具层出不穷，包管理工具也是五花八门，而且作为一名优秀的开发者无时无刻都在使用工具去减少重复劳动，我们需要有大量的额外工具，例如JSON校验，Mock服务，Local Server，甚至是代码优化，日报/日志工具。

很遗憾，我们目前并没有这样的软件去集成这些五花八门的工具，但是读者们会心里想，我可以唤出浏览器打开一个工具网站就可以解决所有问题，为什么还需要一个GUI软件去做这样的事情呢？这也是本篇文章的重点。

依赖管理

NPM对于前端开发者来说并不陌生，我们想要安装一个库其实要做很多调研，大多需要查看其更新时间，下载量以及issue数量等等；但是当你有一天想要开发Rust程序时，你并不知道你要编写的功能需要安装什么库，你也不知道库和库是如何依赖的，这势必要浪费很多时间，所以如何统一各个语言的依赖管理呢？

这里实现技术也比较简单，无非就是将用户所期望的依赖底层通过命令行的形式进行安装；GUI的重点是如何查找到开发者心仪的依赖，下图是使用NPM搜索PDF关键字的结果：

在默认搜索模式下，在搜索如此具体的关键字时，仍然找不到pdf.js的核心库，如果我是一个对前端领域比较陌生的开发者，我大概率会安装第一个依赖。虽然举得这个例子有点极端并且有一点杠精，但是作为一款跨平台的代码项目管理工具，我们要做的是多个流行语言的包管理工具，对于经常跨语言开发的开发者，你不再需要打开多个标签页并且你也不需要熟悉你安装依赖的命令，只需要2步：

• 精确地搜索出依赖列表
• 右键单击鼠标，你的依赖会自动下载

如果在依赖列表中看到了你已安装的依赖，你完全可以双击右键去卸载它，这在我们频繁查找与安装依赖的场景非常有用，并且节约时间。

另外依赖检索列表中，会借鉴NPM的搜索模式，并且在之上结合搜索引擎和ChatGPT，会给你一个智能的依赖推荐，尽管你搜索的关键字和实际的依赖完全不同，你也能快速安装它！并且智能推荐是联网的，你无需GPT4，软件内部会将搜索引擎的结果提供给GPT，让GPT提取可用的依赖信息。

代码体检？咋有点像360？

代码体检的功能是一个仍然在探讨的feature，所以本章和最后完成的功能差距可能会非常大。在一些代码管理的SASS产品中，可能会提供这种功能，并且相对耗时以及昂贵。那么我们如何做这个功能呢？当代码项目被添加到软件中时，会经过一次极快的预处理，会在短时间内得出项目的技术栈和依赖关系，基础的模块数量。

在真正体检时，会得出一份报告，这个报告生成的过程不会产生联网的请求，一切都在本地完成，不依赖GPT。因为大额的代码段落让GPT分析会造成很多Token消耗，这一般人不太用得起（笑哭）。所以这块可能会使用开源的一些检测工具去扫描代码库中可能重复的函数，并且行数特别多的函数，并且注释的数量多少也会影响报告分数；

报告中的检查项可以手动关闭，因为开发者的习惯并不一样，有些人并不习惯编写注释，也有一些项目避免不了行数过多的函数。如果关闭对应的检查项，软件也会跳过这些步骤，势必会更快地生成报告。

工作流

软件会提供一个基础的工作流，将软件项目和快捷键绑定，甚至和其他软件绑定。你可以理解为迷你版的快捷指令，可以用代码编写工作流中的代码，比方说你有一个很重很大的项目，当你有一天重启了电脑或者应用崩溃闪退，导致你不得不重新打开这些应用。那么你就可以自定义一个工作流，当你使用快捷键唤出项目时，你的数据库，Docker，Redis就全部按照你的指示有顺序的跑起来了！

另外当你编写代码时，软件会每隔一段时间去检测你正在编写的模块，找到你经常更改的代码块，并且自动的给出你优化的建议（会有一个提示消息，和Copilot不同）。

利用到GPT的地方会有很多，比如当您把代码提到暂存区时，软件就已经分析其代码并且对代码做总结，生成好commit message，你只需要看到消息之后，点击确定，就可以应用这个提交。

除了显性的工作流之外，在软件内部，不管是体检的预处理分析文件还是你在编写代码时候产生的输出，都有可能会给软件其他功能提供支持。比如日志/日报插件，它会总结你一天的Commit message和具体的工作任务，你可以为其定义一个日报模板，只需要稍加修改，就可以一键发布；发布到哪儿呢？Github/Gitlab/钉钉，只要存在第三方接口的应用，自己编写逻辑，就可以直达！

插件

还记得一个成功的软件核心是什么吗？就是插件，软件可以允许用户使用HTML/JS定义界面，使用Rust/WASM去定义其实现，关于支持Nodejs？这个得看后续啦。

插件分为2类：

• 核心官方插件（上述的几个功能都属于核心插件）
• 第三方插件

这是借鉴了Obsidian，对第三方插件必须要提供源代码并且接受监管，如果对于非常流行的第三方插件会合并到官方插件中，但是会继续由社区开源爱好者（和官方开发者）一起推动维护。

有了第三方插件，你脑海中的各种工具，比如JSON校验，Mock服务，Format等等，把那些工具网站都删除了吧~，只需要一个快捷键就可以抵达的插件，无论是性能还是便捷性，本地的软件都会更胜一筹。

总结

对了，软件的名字叫作YourPanel，现已开源：

https://github.com/yourpanel/core （Next.js + Tauri）

文章中的GPT相关功能，都可以关闭，关闭这些GPT调用之后，任何有网络连接的插件在运行时，都会让你知晓；并且在安装插件时，你也可以清楚地看到插件是否基于网络连接！

作为一个本地的代码管理面板软件，我期望你的代码只允许你一个人访问，并且期望用较少的网络连接去完成任务。在初期使用中，我们没有计划引入用户管理，这意味着软件没有登录，我们也看不到你的代码和你的任务。

我们的初心就是：在一个安全环境下，提供开发者便捷服务。

复合类型

顾名思义, 复合类型就是其他类型组合而成的, 最典型的就是结构体struct和枚举enum.

字符串

rust中的字符串和我们平时说了解到的编程语言不一样, 比如下面这一段代码是会编译错误的:

fn main() {
  let my_name = "Pascal";
  greet(my_name);
}

fn greet(name: String) {
  println!("Hello, {}!", name);
}

切片

切片在go中就已经很流行了, 它允许你引用集合部分内容, 而不是全部, 在字符串中, 我们可以这么写:

let s = String::from("hello world");

let hello = &s[0..5];
let world = &s[6..11];

如果是从0开始, 就可以省略0:

let hello = &s[..5];

同理, 如果你要截取到尾部, 你可以这样省略:

let hello = &s[1..];

但是如果我们操作中文, 就需要格外注意utf-8啦, 一个中文是3个字节, 所以我们在做切片的时候, 如果切到第二个, 就会编译器报错:

实际上, 如果返回切片, 其实是一个字符串引用, 所以我们可以写出这样一段代码:

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

    let word = first_word(&s);

    s.clear(); // error!

    println!("the first word is: {}", word);
}
fn first_word(s: &String) -> &str {
    &s[..1]
}

不仅仅字符串可以进行切片, 数组也是可以的:

let a = [1, 2, 3, 4, 5];
let slice = &a[1..3];
assert_eq!(slice, &[2, 3]);

如果我们通过字符串字面量创建字符串的话, 是这样的:

let a = "hello";

此时a就是&str类型, 我们完全可以这样编写代码, 因为此时a指向了可执行文件中的某个点, 也因此字面量创建的字符串是不可变的, 因为&str就是不可变的.

let a: &str = "hello";

字符串是什么

rust中的字符是由unicode编码实现的, 每一个字符占据了4bytes, 但是字符串是用utf-8实现的, 占用的字节数是1-4变化的, 所以更节省内存.

&str和String的区别

在语言层面上来说, 只有str一种类型, 是硬编码到可执行文件中的, 无法被修改; 但是在标准库中我们却可以使用String来创建一个不定长度的字符串类型; String同样也是utf-8编码也具有所有权特性;

如何互相转换

str → string

let a = String::from("hello world");
let b = "hello world".to_string();

string → str

fn main() {
    let s = String::from("hello,world!");
    say_hello(&s);
    say_hello(&s[..]);
    say_hello(s.as_str());
}

fn say_hello(s: &str) {
    println!("{}",s);
}

字符串索引

在js中, 我们可以使用索引轻松的访问字符串, 但是在rust中这是不被允许的:

let s1 = String::from("hello");
let h = s1[0];

因为字符串的底层是使用[u8]字符数组实现的, 如果我们在字符串中使用中文, 一般一个中文是3个byte, 那么此时我们操作中文字符串时, 可能会得到预想不到的值; 所以在rust中, 字符串索引是一个容易造成误解的功能, 因此不支持;

如何正确操作utf-8字符串

如果你想要通过unicode方式操作字符串, 就可以使用.chars()函数

for c in "中国人".chars() {
    println!("{}", c);
}

如果你想要查看字符串在底层的字节数组, 就可以使用bytes()函数

for b in "中国人".bytes() {
    println!("{}", b);
}

228
184
173
229
155
189
228
186
186

ps: 如果要在rust中截取正确的子串, 就要使用一些库, 比如utf8_slice

深入理解字符串

为什么string可变而str不可变呢? 这很容易理解因为str是在我们编译期间就可以知道的内容, 即不可变, 直接编译到可执行文件中; 但是我们在开发中, 不可能都使用不可变的str, 通常我们的值都会在运行时经过逻辑处理得到的, 所以我们需要一个可变的string类型; 可变的string类型是要在堆上划分一块区域存储的, 等到需要被释放时才会归还给操作系统, 整个周期都是在运行时;

元组

元组是由多种类型组合一起形成的, 它的长度是固定的, 顺序也是固定的; 我们可以通过这个函数创建一个元组:

fn main() {
    let tup: (i32, f64, u8) = (500, 6.4, 1);
}

可以用模式匹配来解构元组

let (x, y, z) = tup;

也可以通过.索引的方式来获取元组元素

tup.1

在函数中, 如果要返回多个值, 除了使用下面即将介绍的结构体之外, 还可以使用元组

fn calculate_length(s: String) -> (String, usize) {
    let length = s.len();
    (s, length)
}

结构体

在元组的介绍中, 返回的calculate_length函数是一个元组类型, 这对于程序来说是不好维护的, 因为不清楚返回参数的任何意义; 那么rust中有一个复合类型叫做结构体可以解决; 那么在其他语言中结构体可以当作object, record(typescript); 结构体是由多个类型组合而成; 它可以给每个类型设置一个名称(key), 所以结构体对比元组更加灵活

我们定义一个结构体, 非常简单:

struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

我们需要使用这个结构体构造一个实例, 就更简单啦:

let user1 = User {
      email: String::from("someone@example.com"),
      username: String::from("someusername123"),
      active: true,
      sign_in_count: 1,
  };

和ts一样, 我们定义的结构体需要完全初始化, 即数据模型要和结构体完全匹配.

如果我们需要修改user1的某个字段, 必须把整个user1变为mut可变类型, 结构体不支持仅把某个元素变为可变:

user1.email = String::from("anotheremail@example.com");

我们在结构体中, 对于同名的key和value是可以做到省略简写的, 比如这样:

fn build_user(email: String, username: String) -> User {
    User {
        email,
        username,
        active: true,
        sign_in_count: 1,
    }
}

同样的, 我们在ts中经常使用es的扩张运算符来更新对象, 在rust中, 你完全可以使用类似的语法更新结构体 (必须写在尾部)

let user2 = User {
    email: String::from("another@example.com"),
    ..user1
};

关于更新语句, 所有权也需要关注, 在rust所有权中, 部分类型如果支持copy, 那么数据在这里就会被拷贝, 比如bool和u64都实现了copy, 那么在此时的更新结构体的语句中, 仅仅只是把值copy了一份而已; 但是username是string类型, 在此处是转移了所有权到user2中, 那么在user1中就不能操作username了.

结构体不仅仅有key, value这种形式, 还可以有其他形式

struct Color(i32, i32, i32);
struct Point(i32, i32, i32);

let black = Color(0, 0, 0);
let origin = Point(0, 0, 0);

枚举

枚举是一个类型, 有多个枚举成员, 枚举值是其中某个枚举成员的实例

enum PokerSuit {
  Clubs,
  Spades,
  Diamonds,
  Hearts,
}

在一些特殊场景下, 你不仅仅可以指定成员类型, 还可以代替结构体简化代码: 在ts中枚举是运行时类型(经过编译器编译之后为对象), 但是在rust中就是实打实的类型, 不能在声时指定值;

如果使用传统的结构体, 是这样写的

enum PokerSuit {
    Clubs,
    Spades,
    Diamonds,
    Hearts,
}

struct PokerCard {
    suit: PokerSuit,
    value: u8
}

fn main() {
   let c1 = PokerCard {
       suit: PokerSuit::Clubs,
       value: 1,
   };
   let c2 = PokerCard {
       suit: PokerSuit::Diamonds,
       value: 12,
   };
}

我们通过枚举进行改造, 可以大大简化代码:

enum PokerCard {
    Clubs(u8),
    Spades(u8),
    Diamonds(u8),
    Hearts(u8),
}

fn main() {
   let c1 = PokerCard::Spades(5);
   let c2 = PokerCard::Diamonds(13);
}

指定成员类型

enum PokerCard {
    Clubs(u8),
    Spades(u8),
    Diamonds(char),
    Hearts(char),
}

更复杂的枚举成员类型 (结构体)

struct Ipv4Addr {
    // --snip--
}

struct Ipv6Addr {
    // --snip--
}

enum IpAddr {
    V4(Ipv4Addr),
    V6(Ipv6Addr),
}

相比较元组结构体, 从语法角度上来说枚举的方式更为简洁且高内聚

Option

在rust中避免了使用大多数语言经常用到的null概念, 改为option, 其类型本身就是一个枚举

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

some指的是有值(任意值), 类型为t, t是一个泛型参数; none则为空

值得注意的是, option并不需要显式的引入, 因为它本身就被包含在标准库中, 也不需要::调用some和none;

let some_number = Some(5);
let some_string = Some("a string");

let absent_number: Option<i32> = None;

在rust语言设计中, 你如果想使用类似null的概念, 就必须告诉编译器这个null如果有值的话是什么类型, 即第三段代码; 反之如果使用了some, 就代表了值存在于some之中; 那rust为何这么做, 多此一举新增一个option枚举呢?

其实主要核心问题还是安全性, rust编译器要在编译器确保数据的安全, 不能因为null的滥用导致程序错误, 如果不使用option来标记可能为空的值, 那么在之后的代码中你可能就会忘记这个值的类型和其他类型做逻辑运算, 那么此时null就会被爆雷; 所以如果使用option标记值, 在编译期就可以让rust判断, 提醒开发者.

数组

数组很简单, 同样rust可以设置数组的类型

fn main() {
    let a = [1, 2, 3, 4, 5];
        // 这里的类型声明, ;之前是类型, ;之后是重复几次
        let b: [i32; 5] = [1, 2, 3, 4, 5];
        // 同样的也可以通过上述的语法, 让我们初始化数组更快速, 初始化值为3, 重复5次
        let c = [3; 5];
}

访问数组

a[0]

可以进行切片

let slice: &[i32] = &a[1..3];

最近学习rust的时候,了解到rust的浮点数实现是和js是一样的, 也就导致了我们在js上遇到的精度问题, 在rust同样也能遇到.

首先我们来理清, rust的默认浮点类型是f64, 而js由于和其他语言不同, 无论是整数和浮点数都是number类型, 也是64位固定长度, 也就是标准的双精度浮点数,

双精度浮点数(double)是计算机使用的一种数据类型，使用 64 位（8字节） 来存储一个浮点数。 它可以表示十进制的15或16位有效数字，其可以表示的数字的绝对值范围大约是：-1.79E+308 ~ +1.79E+308 [1] 。

既然2种语言底层的标准都是一样的, 都是使用了IEEE 754标准中的double精度, 那我们就直接使用大家熟悉的js来做demo.

为什么使用double精度标准

对比单精度标准来说, 虽然double精度占用比单精度高(8byte > 4byte), 这也就间接意味着cpu在处理上, 单精度会有优势, 但是单精度的致命缺陷就是有效数少而且范围也会更小, 总的来说适用性略低, 而且在现代cpu来说, 处理速度上基本是可以忽略不计的.所以在rust中默认的浮点数类型就是f64, 如果有需要就选择f32(单精度)

double精度如何存储

直接从wiki上抄一张图下来

• 符号位：1 位 (+, -)
• 指数：11 位 (次方)
• 有效位数精度：52 位

运算过程

我们通常会用十进制来表达浮点数, 但是我们rust/js底层都是用二进制实现浮点数类型的, 比如说我们写一句这样的代码:

var a = 0.1;

在我们程序员眼中它可能就是绝对等于0.1的, 但是在内部实现中, 它需要转换为二进制, 但是在二进制中就是无限精度类型, 也就变成了下面这样:

0.1 -> 0.0001 1001 1001 1001...(1100循环)

但是由于我们底层的标准, 有效位数的精度是52位, 我们在做浮点运算的时候, 多余的数字都会被截断, 所以在js从二进制转换为十进制之后, 就不是我们预想的答案了(在一定精度结果是对的)
, 同理在rust/js中我们也不要使用浮点数做比较, 因为是一个危险不受信赖的计算结果, 也希望精度问题能够引起大家重视, 因为有很多危险的事件是由转换精度触发的:

对于Ariane 4火箭的工作代码在Ariane 5中被重新使用，但是Ariane 5更高速的运算引擎在火箭航天计算机中的算法程序中触发了一个bug。该错误存在于将64位浮点数转换为16位带符号整数的程序中。更快的运算引擎导致了Ariane 5中的64位数据要比Ariane 4中更长，直接诱发了溢出条件，最终导致了航天计算机的崩溃。首先501航天飞机的备份计算机崩溃，然后0.05秒之后，主计算机也崩溃了。这些计算机崩溃直接导致了火箭的主要处理器使火箭的运算引擎过载，同时导致火箭在发射40秒后解体破碎。

顺带提一句, rust中对于整型有溢出处理, 在release环境下, 会按照补码循环溢出的规则去解决, 但是这仍然会造成结果不一致的错误.

如何解决

rust: 我不知道咋解决, 我才学rust
js: 大把的精度库, 最流行的方案就是底层使用string了, bignumber.js, 就可以避免浮点数陷阱;

基础类型

rust是一门静态编程语言, 所以我们有必要知道它的类型, rust的类型可以分为基本类型和复合类型(也可以称之为复杂类型), 基本类型指的就是原子化最小的类型, 它不能转换为其他类型;

rust不像ts, ts是js的超集, ts可以更好的推断类型, 但是rust拥有一个很聪明的编译器, 你可以无需指定类型, 让编译器去自动推断, 但是某些情况下编译器无法推断类型, 比如这样

let guess = "42".parse().expect("Not a number!");

鬼知道guess是什么类型, 所以编译器会报错, 你只需要显式的指定类型即可;

数值类型

rust创建数值非常简单

let a = 1;

整数

我们继续来探讨整数类型, 我们之前了解过的i32类型, 表示有符号的32位整数

i表示integer, 与之相反的是u, 代表无符号

类型统一定义为 “有无符号” + “位数(bit)”, 无符号表示就是正数, 有符号就是正负; 简单的使用准则需要我们记住, rust整形默认使用i32, 可以首选i32, 而且性能也是最好的;

我们在处理整型的时候, 如果设置的值超过了范围, 那么rust会区分模式, 做不同的决策, 比如在debug模式中, 程序会报错退出; 如果是release环境, 会被补码为范围内的最小值, 因此这样的结果是不符合预期的, 会被认为是错误的.

浮点数

浮点数默认类型是f64, 但是rust有一个浮点数的陷阱, 我们通常会使用十进制表达浮点数, 但是rust底层是使用二进制实现浮点数类型的, 比如说0.5在十进制上存在精确表达, 但是在二进制中不存在, 所以就会造成歧义, 所以想要表达完整的真实浮点数字, 就必须使用无限精度的浮点数才行.

还有一个注意的点就是, 我们不要对浮点进行比较, 这和js一样, 由于rust的浮点类型底层是二进制, 而js同样在浮点数运算时也是二进制, 都会存在不准确的问题; 在rust中对浮点数进行比较的时候, float声明了PartialEq, 注意它不是Eq; 在map数据结构中的k类型, rust是需要你传入声明过Eq 的类型, 很显然float不满足要求; 而且当我们使用浮点做比较的时候, 会造成编译器错误.

NaN

和js一样, 我们可以在rust中做一个防御性编程:

fn main() {
    let x = (-42.0_f32).sqrt();
    if x.is_nan() {
        println!("未定义的数学行为")
    }
}

序列

rust提供了一种简洁的方式生成连续的数值

// 生成1-5 (包括5)
1..=5
// 生成1-5 (不包括5)
1..5

字符, 布尔, 单元类型

这一部分比较简单,

char

fn main() {
    let c = 'z';
    let z = 'ℤ';
    let g = '国';
    let heart_eyed_cat = 'hhh';
}

不管是ascii, 还是unicloud都算作rust字符char; 另外字符是用’’包裹的, “”是表达为字符串

bool

rust中的布尔类型和其他语言一样, 存在true/false

单元类型

0长度的元组, 单元类型使用()来表达, 我们可以用单元类型占位, 它不占用任何内存, rust函数中的main还有print函数都会返回一个单元类型. 我们不能说main函数没有返回值, 因为没有返回值在rust中是有单独的定义的(发散函数: diverge function) , 顾名思义, 无法收敛的函数.

语句和表达式

在rust的函数体中是一系列语句组成, 最后是由表达式返回, 比如这样

fn add(x: i32, y: i32) -> i32 {
    let x = x + 2; // 语句
    let y = y + 3; // 语句
    x + y // 表达式
}

语句

 let x = x + 2; // 语句
 let y = y + 3; // 语句

由于let是语句, 我们不能将let赋值给其他值:

let b = (let a = 8);

这样编译器会报错…

表达式

表达式会进行运算/求值, 比如1+2, 会返回3, 我们在语句上面写了这段代码:

 let x = x + 2; 

这里的x + 2确实是一个表达式, 只要记住只要能返回值, 它就是表达式 而且表达式不能包含分号, 比如下面一段代码

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

如果x + 1包含了分号, 那么此时这个语句块不会返回任何值了, 也就不算作表达式了, 所以我们在rust中编写函数的时候, 如果要返回值, 就要注意这里不需要加分号;

函数

rust的函数很简单, 下面是一个例子, 有关键字, 函数名称, 形参名称和类型, 函数返回值类型, 以及一个代码块, 就构成了一个最简单的函数:

fn add(i: i32, j: i32) -> i32 {
   i + j
 }

1. 首先rust是强类型的语言, 我们在编写函数的时候, 参数的类型是必须的, 如果不提供参数的类型是会报错的.
2. 函数的返回值就是代码块的最后一行的表达式返回值, 当然我们也可以使用return关键字提前返回也可以
3. 在单元类型中, 我们提到了无返回值, 我们可以使用单元类型作为返回, 而一些表达式你不幸加了分号变成了语句, 那么此时也会返回一个单元类型.
4. 在上文提到了diverge function, 我们可以使用!作为函数返回类型, 这一般会作为程序崩溃的函数, 代表永不返回:

fn end() -> ! {
  panic!("it is over...");
}

作为一个没有学过C/C++的开发者（比如说我），在初步学习Rust中需要了解一些JavaScript中不存在的东西，那么所有权就是Rust中的核心功能之一。我需要一篇文章记录这一次的学习，在真正内容开始之前我需要描述一些基础知识，在最后也会简单看看”引用和借用“，”slice类型“这些与之相关的Rust概念。因为是Rust初学者，请大家阅读本篇文章带着自己的思考，因为每个人的思考方式和理解都不一样，所以可能会导致某些错误...。

参考资料:

• Rust程序设计语言-所有权

预热

程序员编写的所有程序都必须管理其使用计算机内存的方式，比如说JavaScript这一类的语言具有垃圾回收机制（GC）它可以不断寻找不再使用的内存，因此不需要开发者手动干预；在另外一些语言中，我们需要亲自分配和释放内存；但是在Rust中就利用了所有权的概念管理内存，编译器在编译阶段会根据规则进行检查，同样的也不需要程序员手动干预内存，这些有关内存的工作都交给了所有权和编译器。所以我们学习Rust中的所有权的时候，准确说应该是学习编译器是通过什么“规则”来进行检查的，这个规则对我们更重要。

堆栈

我们在写JavaScript的时候，通常业务开发我们不需要考虑堆栈，但是在Rust中我们需要考虑一个值是在堆上还是在栈上，这和所有权息息相关，所以我们先简单回顾一下堆和栈的基础知识。堆和栈都是代码运行时可使用的的内存，它们是不相同的。大家都知道栈是先进后出,像服务生手中一个一个托盘一样，最先放入的托盘一般都会最晚从上方取出；栈中所有数据都占用固定的大小，程序在编译时都会看值大小是否可能会变化，如果是则需要存储到堆中，因为堆中所有的数据都是凌乱的，需要分配器去在堆中区域开辟一块空间，标记为已使用并且返回指针，这个过程也叫做在堆上分配内存

数据直接入栈当然也比在堆上分配内存更快，入栈直接放到栈顶即可，入堆的话分配器不仅要查看内存，分配内存还要记录以便为下一次分配做准备；访问堆上的数据也比访问栈中的数据要慢（因为指针），而因为处理器缓存的原因，跳转越少就越快，当访问的数据彼此都是栈中那自然快，但是彼此数据一个在栈中一个在堆中那自然会稍慢一点。那么所有权将会帮助我们处理堆中的重复数据，无用的数据以及跟踪哪些代码在使用堆中数据，总的来说所有权的存在就是为了管理堆数据。

所有权规则

• 每一个值都有一个被称为其所有者的变量
• 值在任一时刻只有一个所有者
• 当所有者（变量）离开作用域的时候就会被丢弃

感觉目前理解这几个规则还比较晦涩，但是我们可以随着笔记深入慢慢地理解

作用域

所有权规则中既然提到了作用域，那我们简单看看作用域，其实和JavaScript相差不大，我们非常容易理解

fn main(){ // a在这里无效
    let a = "hello seho" // a有效
} // 作用域结束了，a无效

看起来很简单不是么？和JS一样?

我们此时会发现hello seho这个值是通过字面量硬编码创建了一个字符串并且绑定到a中，这种情况下a将会在栈中，因为它有着固定的大小，那么当作用域结束之后，a将会直接出栈。

内存和分配

对于以上的hello seho这种值，在我们的实际业务中并不常见，我们大多数会存在一个大小不定的内容，而且会在程序的运行时增大或者减小，那么为了支持这种需求只能在堆中开辟出一块内存，意味着程序需要在运行时去创建这块的区域，而且当我们处理完内容，需要把内存还给内存分配器。

第一步很好说，我们调用String::from这种方法就可以在堆中创建一块区域，那么第二步怎么还呢？

在C中是需要手动的释放内存的，但是程序终究是人写的，有时候忘记还了，有时候过早还了，有时候重复还了，都会造成系统bug。在有GC的语言中，GC会记录并且清除不使用的内容从而释放内存，所以这也就是我为啥喜欢JS的原因了，真的太爽了....

我们把上面的代码改造一下

fn main(){ // a在这里无效
    let a = String::from(""hello seho"") // a有效
} // 作用域结束了，a无效

在作用域结束之后，rust会调用一个特殊函数drop从而释放内存，在stirng内部会实现这个drop函数...

移动

我们在JS中写过很多这样的代码

let a = 1;
let b = a;

很显然，它在栈中创建了2个变量, a和b，他们的值都是1

在rust中也一样，但是如果我使用String::from创建变量呢，在堆中和栈中会有不同么？

let a = String::from("hello seho");
let b = a;

很显然，a的值是hello seho，b“复制”了a的指针，它们都存在栈中，指针指向了堆中的hello seho。

诶，难道说，rust的表现和js一样？在我们前面提到了所有权的规则之一，当变量离开了作用域将会自动释放，但是此时a和b都指向同一堆中内容，此时不是造成了多次释放的问题？答案是肯定的，在我们之前就说到过，没有释放，过早释放，多次释放都会对程序造成影响，所以rust在针对我们上面这种代码的时候，作出了一个处理即当a被“复制”到了b身上，此时a不再生效，程序会在编译期间报错。

如此看来，就避免了多次释放的问题，而“复制”也不是真正的复制，而是移动；

那么如果真的想克隆一个一摸一样的值，可以调用clone方法，而我们在上面写了一个整型的例子，为什么没有调用clone也可以被克隆，是因为它们本身就是栈中的数据，在栈中的拷贝是快速的，不需要通过移动这种机制来实现拷贝

到此为止，我们应该能理解所有权到底是什么了，我们在本篇笔记中学习了所有权的概念和规则，以及复习了堆栈基本知识，还有rust的内存分配。我们在本篇笔记中大量的使用了js这门语言作为参照对象，如果你不熟悉js的话，下次笔记我会将语言的比较去掉，这样应该会更加容易理解，有问题发评论区，吴彦祖和迪丽热巴发的评论我肯定都会回复