Merge branch 'master' of github.com:rustcc/RustPrimer

Author: wayslog

03-editors/03-05-atom.md

@@ -4,6 +4,11 @@
 虽然本文独占一小节，但是其实能写的东西也就了了。
 可是，正是由于软件工程师的智慧，才让我们拥有了如此易用顺手的编辑器，同时也给了我们如此完美的语言——Rust。
 
+- [自行配置](#自行配置)
+- [使用tokamak](#tokamak)
+
+## 自行配置
+
 ## 1.1 准备工作
 
 首先，你需要一个可执行的rustc编译器，一个cargo程序，一个已经编译好的racer程序和一份已经解压好的rust源码。
@@ -30,3 +35,7 @@ ps:无论是windows用户还是*nix用户都需要将以上三个程序加入你
 ## 2.1 完成安装
 
 好了，就是这么简单。你现在可以打开任意一个rust文件就会发现源码高亮已经默认打开了，编辑一下，racer也能自动补全，*如果不能*，尝试一下用`F3`键来显式的呼出racer的补全。
+
+## tokamak
+
+[tokamak](https://github.com/vertexclique/tokamak) 是一个使 atom 摇身一变为 rust IDE 的 atom 插件. 安装后 atom 即具有语法高亮, 代码补全与 Lint 等功能, 而且还有个不错的界面, 看起来确实像个 IDE. 你可以在 atom 中搜索 tokamak 并安装它.

04-quickstart-rewrite-WIP/04-00-rust-travel.md

@@ -0,0 +1,112 @@
+# Rust旅程
+
+## HelloWorld
+按照编程语言的传统，学习第一门编程语言的第一个程序都是打印 Hello World！
+下面根据我们的步骤创建 Rust 的 Hello World！程序：
+
+**下面的命令操作，如果没有特别说明，都是在shell下运行。本文为了简单统一，所有例子都在 win10 的 powershell 下运行，所有命令都运行在`ps:`标识符之后**
+
+- 创建一个 Doing 目录和 helloworld.rs 文件
+
+> ps: mkdir ~/Doing
+
+> ps: cd ~/Doing
+
+> ps: notepad helloworld.rs # 作者偏向于使用 sublime 作为编辑器
+
+> ps: subl helloworld.rs # 本章以后使用 subl 代替 notepad
+
+注意这里用的后缀名是.rs，一般编程语言的代码文件都有惯用的后缀名，比如：
+    C语言是.c，java是.java，python是.py等等，**请务必记住Rust语言的惯用后缀名是.rs**（虽然用别的后缀名也能通过rustc的编译）。 
+
+- 在 helloworld.rs 文件中输入 Rust 代码
+
+```rust
+fn main() {
+    println!("Hello World!");
+}
+```
+
+- 编译 helloworld.rs 文件
+
+> ps: rustc helloworld.rs
+
+> ps: rustc helloworld.rs -O # 也可以选择优化编译
+
+- 运行程序
+
+> ps: ./helloworld.exe # windows 平台下需要加 .exe 后缀
+
+> Hello World!
+
+没有`ps:`前缀的表示为控制台打印输出。
+
+我们已经用rust编写第一个可执行程序，打印出了'hello world!'，很酷，对吧！  
+但是这段代码到底是什么意思呢，作为新手的你一定云里雾里吧，让我们先看一下这个程序：
+
+1. 第一行中 fn 表示定义一个**函数**，main是这个函数的名字，花括号{}里的语句则表示这个函数的内容。
+2. 名字叫做**main**的函数有特殊的用途，那就是作为程序的入口，也就是说程序每次都从这个函数开始运行。
+3. 函数中只有一句 ```println!("Hello World!");```，这里```println!```是一个Rust语言自带的**宏**，
+这个宏的功能就是打印文本(结尾会换行)，而"Hello World!"这个用引号包起来的东西是一个**字符串**，就是我们要打印的文本。
+4. 你一定注意到了```;```吧， 在Rust语言中，分号```;```用来把语句分隔开，也就是说语句的末尾一般用分号做为结束标志。
+
+## HelloRust
+
+- 创建项目 hellorust
+
+> ps: cargo new hellorust --bin
+
+- 查看目录结构
+
+> ps: tree # win10 powershell 自带有 tree 查看文件目录结构的功能
+
+> └─hellorust
+
+> ----└─src
+
+这里显示的目录结构，在hellorust目录下有 src 文件夹和 Cargo.toml 文件，同时这个目录会初始化为 git 项目
+
+- 查看Cargo.toml文件
+
+> ps: cat Cargo.toml
+
+> [package]
+name = "hellorust"
+version = "0.1."
+authors = ["YourName <YourEmail>"]
+
+> [dependencies]
+
+- 编辑src目录下的main.rs文件
+
+> ps: subl ./src/main.rs
+
+cargo 创建的项目，在src目录下会有一个初始化的main.rs文件，内容为：
+```rust
+fn main() {
+    println!("Hello, world!");
+}
+```
+现在我们编辑这个文件，改为：
+```rust
+fn main() {
+    let rust = "Rust";
+    println!("Hello, {}!", rust);
+}
+```
+这里的 `let rust = "Rust"` 是把 rust 变量绑定为 "Rust" ，
+`println!("Hello, {}!", rust);`里把 rust 变量的值代入到`"Hello, {}!"`中的`{}`。
+
+- 编译和运行
+
+> ps: cargo build
+
+> ps: cargo build --release # 这个属于优化编译
+
+> ps: ./target/debug/hellorust.exe
+
+> ps: ./target/release/hellorust.exe # 如果前面是优化编译，则这样运行
+
+> ps: cargo run # 编译和运行合在一起
+
+> ps: cargo run --release # 同上，区别是是优化编译的

10-trait/10-01-trait.md

@@ -33,7 +33,7 @@ fn main() {
     println!("circle c has an area of {}", c.area());
 }
 ```
-**注**: **&self**表示的是**area**这个函数会将调用者的借贷引用作为参数
+**注**: **&self**表示的是**area**这个函数会将调用者的借代引用作为参数
 
 这个程序会输出：
 

12-ownership-system/12-01-ownership.md

@@ -28,7 +28,7 @@ int* foo() {
 上面定义了一个i32类型的标识符a，如果你直接println，你会收到一个error报错：
 > error: use of possibly uninitialized variable: `a`
 
-这是**因为Rust并不会像其他语言一样可以为变量默认初始化值，Rust明确规定变量的初始值必须有程序员自己决定**。
+这是**因为Rust并不会像其他语言一样可以为变量默认初始化值，Rust明确规定变量的初始值必须由程序员自己决定**。
 
 正确的做法：
 ```rust
@@ -141,13 +141,13 @@ a = 200;
 > error: re-assignment of immutable variable `a` [E0384]  
 <anon>:3     a = 200;  
 
-不能对**不可变绑定**赋值。如果要修改值，必须用关键字mut申明绑定为可变的：
+不能对**不可变绑定**赋值。如果要修改值，必须用关键字mut声明绑定为可变的：
 ```rust
-let mut a: i32 = 100;  // 通过关键字mut申明a是可变的
+let mut a: i32 = 100;  // 通过关键字mut声明a是可变的
 a = 200;
 ```
 
-**想到“不可变”我们第一时间想到了const常量，但不可变绑定与const常量是完全不同的两种概念；首先，“不可变”确切地应该称为“不可变绑定”，是用来约束绑定行为的，“不可变绑定”后不能通过这个“所有者”变更所绑定“value内存区域”的内容，所以，依然可以把目标value内存区域变为“可变绑定”，目标“value内存区域”由数据类型本身决定。**  
+**想到“不可变”我们第一时间想到了const常量，但不可变绑定与const常量是完全不同的两种概念；首先，“不可变”确切地应该称为“不可变绑定”，是用来约束绑定行为的，“不可变绑定”后不能通过这个“所有者”变更所绑定“value内存区域”的内容，但是，依然可以把目标value内存区域变为“可变绑定”，目标“value内存区域”由数据类型本身决定。**  
 **例如：**
 ```rust
 let a = vec![1, 2, 3];  //不可变绑定, a <=> 内存区域A(1,2,3)
@@ -261,7 +261,9 @@ fn main() {
 }
 ```
 >结果： x=100, y=102  
-  
+
+注意: 例子1是比较特别的，使不使用 move 对结果都没什么影响，因为环境变量 x 是 i32 类型，属于 primitive type，实现了 Copy trait，在闭包使用 move 的时候，是先 clone 了一份 x ，在 move 的时候是 move 了这份 clone 的 x，所以后面的 println！引用 x 的时候没有报错。
+
 **例子2：**
 ```rust
 fn main() {

12-ownership-system/12-02-borrowing_references.md

@@ -28,7 +28,7 @@ fn main() {
 
 ###借用与引用的区别
 借用与引用是一种相辅相成的关系，若B是对A的引用，也可称之为B借用了A。
-很相近对吧，但是借用一词本意以为要归还。所以在Rust用引用时，一定要注意应该在何处何时正确的“归回”借用/引用。
+很相近对吧，但是借用一词本意为要归还。所以在Rust用引用时，一定要注意应该在何处何时正确的“归回”借用/引用。
 最后面的“高级”小节会详细举例。
 
 ###规则
@@ -94,19 +94,19 @@ fn main() {
         let z = &mut y;
         z.push(1000);
 
-	    println!("{:?}", z);
+	    println!("{:?}", z); //打印: [1, 2, 3, 10, 100, 1000]
     } //y和z在此处被销毁，并释放借用。
 
 
 	//访问x正常
-	println!("{:?}", x);
+	println!("{:?}", x); //打印: [1, 2, 3, 10, 100, 1000]
 }
 ```
 ####总结
 1. 借用不改变内存的所有者（Owner），借用只是对源内存的临时引用。
 2. 在借用周期内，借用方可以读写这块内存，所有者被禁止读写内存；且所有者保证在有“借用”存在的情况下，不会释放或转移内存。
 3. 失去所有权的变量不可以被借用（访问）。
-4. 在租借期内，内存所有者保证不会释放/转移/租借这块内存
+4. 在租借期内，内存所有者保证不会释放/转移/可变租借这块内存，但如果是在**非可变租借**的情况下，所有者是允许继续**非可变租借**出去的。
 5. 借用周期满后，所有者收回读写权限
 6. 借用周期小于被借用者（所有者）的生命周期。