```dart
// 定义个方法。
printNumber(num aNumber) {
  print('The number is $aNumber.'); // 在控制台打印内容。
}

// 这是程序执行的入口。
// 每个应用都需要有个顶级的 main() 入口方法才能执行。
// main() 方法的返回值为 void 并且有个可选的 List<String> 参数。
main() {
  var number = 42; // 定义并初始化一个变量。
  printNumber(number); // 调用一个方法。
}
```

- 所有能够使用变量引用的都是对象， 每个对象都是一个类的实例。
  在 Dart 中 甚至连 数字、方法和 null 都是对象。
  所有的对象都继承于 Object 类。
- 没有指定类型的变量的类型为 dynamic
- Dart 支持顶级方法 (例如 main())
- Dart 还支持顶级变量，以及 在类中定义变量（静态变量和实例变量）。
  实例变量有时候被称之为域（Fields）或者属性（Properties）
- Dart 没有 public、 protected、 和 private 关键字。
  如果一个标识符以 (\_) 开头，则该标识符 在库内是私有的。


dart.md

- 每个 Go 程序都是由包构成的。
- 程序从 `main` 包开始运行。
- 按照约定，包名与导入路径的最后一个元素一致。
  例如，"math/rand" 包中的源码均以 `package rand` 语句开始。
- 传指针比较轻量级 (8bytes),只是传内存地址，我们可以用指针传递体积大的结构体。
  如果用参数值传递的话, 在每次 copy 上面就会花费相对较多的系统开销（内存和时间）。
  所以当你要传递大的结构体的时候，用指针是一个明智的选择。
- Go 语言中 channel，slice，map 这三种类型的实现机制类似指针，
  所以可以直接传递，而不用取地址后传递指针。
  （注：若函数需改变 slice 的长度，则仍需要取地址传递指针）

```go
// helloword.2.go
package main
import (
  "fmt"
  "time"
)
func main() {
  fmt.Println("Welcome to the playground!")
  fmt.Println("The time is", time.Now())
}
```

一个变量就是一个可寻址的内存空间，里面存储了一个值，
并且存储的值可以通过内存地址来更新。

可以通过调用 reflect.ValueOf(&x).Elem()，
来获取任意变量 x 对应的可取地址的 Value。

```go
x := 2                   // value   type    variable?
a := reflect.ValueOf(2)  // 2       int     no
b := reflect.ValueOf(x)  // 2       int     no
c := reflect.ValueOf(&x) // &x      *int    no
d := c.Elem()            // 2       int     yes (x)

// 调用reflect.Value的CanAddr方法来判断其是否可以被取地址
fmt.Println(a.CanAddr()) // "false"
fmt.Println(b.CanAddr()) // "false"
fmt.Println(c.CanAddr()) // "false"
fmt.Println(d.CanAddr()) // "true"

// 另一个相关的方法CanSet是用于检查对应的reflect.Value是否是可取地址并可被修改的：
fmt.Println(fd.CanAddr(), fd.CanSet()) // "true false"
```

- 如果需要把数字转字符串，使用 `strconv.Itoa()` 会比 `fmt.Sprintf()` 要快一倍左右
- 尽可能地避免把 `String` 转成`[]Byte` 。这个转换会导致性能下降。
- 如果在 for-loop 里对某个 slice 使用 `append()`请先把 slice 的容量很扩充到位，这样可以避免内存重新分享以及系统- 自动按 2 的 N 次方幂进行扩展但又用不到，从而浪费内存。
- 使用 `StringBuffer` 或是 `StringBuild` 来拼接字符串，会比使用 `+` 或 `+=` 性能高三到四个数量级。
- 尽可能的使用并发的 go routine，然后使用 sync.WaitGroup 来同步分片操作
- 避免在热代码中进行内存分配，这样会导致 gc 很忙。尽可能的使用 sync.Pool 来重用对象。
- 使用 l`ock-free` 的操作，避免使用 `mutex`，尽可能使用 `sync/Atomic` 包。 （关于无锁编程的相关话题，可参看《无锁- 队列实现》或《无锁 Hashmap 实现》）
- 使用 `I/O` 缓冲，I/O 是个非常非常慢的操作，使用 `bufio.NewWrite()` 和 `bufio.NewReader()` 可以带来更高的性- 能。
- 对于在 for-loop 里的固定的正则表达式，一定要使用 `regexp.Compile()` 编译正则表达式。性能会得升两个数量级。
- 如果你需要更高性能的协议，你要考虑使用 protobuf 或 msgp 而不是 JSON，因为 JSON 的序列化和反序列化里使用了反- 射。
- 你在使用 map 的时候，使用整型的 key 会比字符串的要快，因为整型比较比字符串比较要快。


go.md

- ECMAScript 和 JavaScript 的关系是，前者是后者的规格，后者是前者的一种实现
- ES6 这个词的原意，就是指 JavaScript 语言的下一个版本
- ES6 既是一个历史名词，也是一个泛指，含义是 5.1 版以后的 JavaScript 的下一代标准，
  涵盖了 ES2015、ES2016、ES2017 等等

JavaScript 学习内容包括

- ES5
- ES6
- DOM
- 浏览器
- Node.js
- TypeScript


js.md

## 所有权

Rust 的核心功能（之一）是 所有权（ownership）。

- Rust 中的每一个值都有一个被称为其 所有者（owner）的变量。
- 值在任一时刻有且只有一个所有者。
- 当所有者（变量）离开作用域，这个值将被丢弃。

## 内存与分配

```rust
    {
        let s = String::from("hello"); // 从此处起，s 开始有效
        // 使用 s
    }                                  // 此作用域已结束，
                                       // s 不再有效
```

变量离开作用域，Rust 为我们调用一个特殊的函数。
这个函数叫做 `drop`。Rust 在结尾的 `}` 处自动调用 `drop`。

```rust
// 整数是有已知固定大小的简单值，所以这两个 5 被放入了栈中。
// 这里没有深浅拷贝的区别
let x = 5;
let y = x;
println!("x = {}, y = {}", x, y);

// 将 s1 赋值给 s2，String 的数据被复制了，
// 这意味着我们从栈上拷贝了它的指针、长度和容量。
// 我们并没有复制指针指向的堆上数据。
let s1 = String::from("hello");
let s2 = s1;

// 使用 clone 方法
let s1 = String::from("hello");
let s2 = s1.clone();
println!("s1 = {}, s2 = {}", s1, s2);
```

## 克隆

- 如果一个类型实现了 `Copy trait`，那么一个旧的变量在将其赋值给其他变量后仍然可用。
- Rust 不允许自身或其任何部分实现了 `Drop trait` 的类型使用 `Copy trait`。

如下是一些 Copy 的类型：

- 所有整数类型，比如 u32。
- 布尔类型，bool，它的值是 true 和 false。
- 所有浮点数类型，比如 f64。
- 字符类型，char。
- 元组，当且仅当其包含的类型也都实现 Copy 的时候。比如，(i32, i32) 实现了 Copy，但 (i32, String) 就没有。

## 引用与借用

- 在任意给定时间，要么 只能有一个可变引用，要么 只能有多个不可变引用。
- 引用必须总是有效的。

与使用 `&` 引用相反的操作是 解引用（dereferencing），它使用解引用运算符，`*`。

```rust
fn main() {
    let s1 = String::from("hello");
    let len = calculate_length(&s1);
    println!("The length of '{}' is {}.", s1, len);
}

fn calculate_length(s: &String) -> usize { // s 是对 String 的引用
    s.len()
}
```

```rust
fn main() {
    let mut s = String::from("hello"); // 可变引用
    change(&mut s);
}

fn change(some_string: &mut String) {
    some_string.push_str(", world");
}
```

不能在同一时间多次将 s 作为可变变量借用。

```rust
let mut s = String::from("hello");
let r1 = &mut s;
let r2 = &mut s; // 错误
println!("{}, {}", r1, r2);
```

可以使用大括号来创建一个新的作用域，以允许拥有多个可变引用，只是不能 同时 拥有

```rust
let mut s = String::from("hello");
{
    let r1 = &mut s;
} // r1 在这里离开了作用域，所以我们完全可以创建一个新的引用
let r2 = &mut s;
```

我们 也 不能在拥有不可变引用的同时拥有可变引用。

```rust
let mut s = String::from("hello");
let r1 = &s; // 没问题
let r2 = &s; // 没问题
let r3 = &mut s; // 大问题
println!("{}, {}, and {}", r1, r2, r3);
```

```rust
let mut s = String::from("hello");

let r1 = &s; // 没问题
let r2 = &s; // 没问题
println!("{} and {}", r1, r2);
// 此位置之后 r1 和 r2 不再使用

let r3 = &mut s; // 没问题
println!("{}", r3);
```

## 悬垂引用（Dangling References）

```rust
fn main() {
    let reference_to_nothing = dangle();
}

fn dangle() -> &String { // dangle 返回一个字符串的引用
    let s = String::from("hello"); // s 是一个新字符串
    &s // 返回字符串 s 的引用
} // 这里 s 离开作用域并被丢弃。其内存被释放。
  // 危险！
```


基础概念

了解更多