补充 2：Golang 一些特性
Go语言的这些地方都做的还不错：
- 拥有自动垃圾回收： 不用手动释放内存
- 一个包系统：
Go 语言的源码复用建立在包（package）基础之上。包通过 package, import, GOPATH 操作完成。
Go 语言的入口 main() 函数所在的包（package）叫 main，main 包想要引用别的代码，需要import导入.
包需要满足：
- 一个目录下的同级文件归属一个包。
- 包名可以与其目录不同名。
- 包名为 main 的包为应用程序的入口包，其他包不能使用
- 包中，通过标识符首字母是否大写，来确定是否可以被导出。首字母大写才可以被导出，视为 public 公共的资源。
-
要引用其他包，可以使用 import 关键字，可以单个导入或者批量导入，语法演示：
// 单个导入 import "package" // 批量导入 import ( "package1" "package2" )
- 导入时，可以为包定义别名：
import ( p1 "package1" p2 "package2" ) // 使用时 p1.Method()
7. import导入时，会从GO的安装目录（也就是GOROOT环境变量设置的目录）和GOPATH环境变量设置的目录中，检索 src/package 来导入包。如果不存在，则导入失败。
GOROOT，就是GO内置的包所在的位置。
GOPATH，就是我们自己定义的包的位置。
8. 可以在源码中，定义 init() 函数。此函数会在包被导入时执行，例如如果是在 main 中导入包，包中存在 init()，那么 init() 中的代码会在 main() 函数执行前执行，用于初始化包所需要的特定资料。
golang的包管理有很大的问题，这个后续有章节单独介绍。
- 函数作为一等公民
支持头等函数（First Class Function）的编程语言，可以把函数赋值给变量，也可以把函数作为其它函数的参数或者返回值。Go 语言支持头等函数的机制
package main import ( "fmt" ) func main() { a := func() { fmt.Println("hello world first class function") } a() fmt.Printf("%T", a) }
在上面的程序中，我们将一个函数赋值给了变量 a这是把函数赋值给变量的语法。你如果观察得仔细的话，会发现赋值给 a 的函数没有名称。由于没有名称，这类函数称为匿名函数（Anonymous Function）。
输出：
hello world first class function func()
调用一个匿名函数，也可以不赋值。如下是上面使用的简化版本：
package main import ( "fmt" ) func main() { func() { fmt.Println("hello world first class function") }() }
而且还可以给匿名函数传参数呢：
// mainfile package main import ( "fmt" ) func main() { func(n string) { fmt.Println("Welcome", n) }("Gophers") }
输出：
Welcome Gophers
正如我们定义自己的结构体类型一样，我们可以定义自己的函数类型
// mainfile package main import ( "fmt" ) type add func(a int, b int) int func main() { var a add = func(a int, b int) int { return a + b } s := a(5, 6) fmt.Println("Sum", s) }
高阶函数：
满足下列条件之一的函数：
- 接收一个或多个函数作为参数
package main import ( "fmt" ) func simple(a func(a, b int) int) { fmt.Println(a(60, 7)) } func main() { f := func(a, b int) int { return a + b } simple(f) }
2. 函数返回函数
func simple() func(a, b int) int { f := func(a, b int) int { return a + b } return f } func main() { s := simple() fmt.Println(s(60, 7)) }
下面通过一个例子来看看头灯函数的实际用途：
首先定义一个 student 类型：
type student struct { firstName string lastName string grade string country string }
下一步是编写一个 filter 函数。该函数接收一个 students 切片和一个函数作为参数，这个函数会计算一个学生是否满足筛选条件：
func filter(s []student, f func(student) bool) []student { var r []student for _, v := range s { if f(v) == true { r = append(r, v) } } return r }
filter 的第二个参数是一个函数。这个函数接收 student 参数，返回一个 bool 值。这个函数计算了某一学生是否满足筛选条件。我们在第 3 行遍历了 student 切片，将每个学生作为参数传递给了函数 f。如果该函数返回 true，就表示该学生通过了筛选条件，接着将该学生添加到了结果切片 r 中。
package main import ( "fmt" ) type student struct { firstName string lastName string grade string country string } func filter(s []student, f func(student) bool) []student { var r []student for _, v := range s { if f(v) == true { r = append(r, v) } } return r } func main() { s1 := student{ firstName: "Naveen", lastName: "Ramanathan", grade: "A", country: "India", } s2 := student{ firstName: "Samuel", lastName: "Johnson", grade: "B", country: "USA", } s := []student{s1, s2} f := filter(s, func(s student) bool { if s.grade == "B" { return true } return false }) fmt.Println(f) }
在 main 函数中，我们首先创建了两个学生 s1 和 s2，并将他们添加到了切片 s。现在假设我们想要查询所有成绩为 B 的学生。为了实现这样的功能，我们传递了一个检查学生成绩是否为 B 的函数，如果是，该函数会返回 true。我们把这个函数作为参数传递给了 filter 函数（第 38 行）。上述程序会输出
假设我们想要查找所有来自印度的学生。通过修改传递给 filter 的函数参数，就很容易地实现了。
c := filter(s, func(s student) bool { if s.country == "India" { return true } return false }) fmt.Println(c)
- 词法作用域
- 系统调用接口: 系统调用是程序向操作系统内核请求服务的过程，通常包含硬件相关的服务(例如访问硬盘),创建新进程等。系统调用提供了一个进程和操作系统之间的接口。
- 只读的UTF8字符串: golang的字符串是只读的unicode字节序列，Go语言使用UTF-8格式编码Unicode字符，每个字符对应一个rune类型。一旦字符串变量赋值之后，内部的字符就不能修改。
但是Go语言本身只有很少的特性，也不太可能添加太多的特性：
- 它没有隐式的数值转换，
- 没有构造函数和析构函数，
- 没有运算符重载，
- 没有默认参数，
- 也没有继承：
golang语言中没有继承，但是可以依靠组合来模拟继承和多态。
但是，这样模拟出来的继承是有局限的，也就是说：在需要多态的时候，需要小心。
package main type ST struct{ } func (s *ST)Show(){ println("ST") } func (s *ST)Show2(){ println("ST:Show2()") } type ST2 struct{ ST // 注意，这里是ST 而不是 st ST ！！！！！！！！ I int } func (s *ST2)Show(){ println("ST2") } func main() { s := ST2{I:5} s.Show() // ST2自己有show（ ）方法； s.Show2() // ST2自己没有show2方法 println(s.I) }
输出：
ST2 ST:Show2() 5
- 没有泛型： 但是Golang也有解决方案：
看一下冒泡排序：
package main import ( "fmt" ) func bubbleSort(array []int) { for i := 0; i < len(array); i++ { for j := 0; j < len(array)-i-1; j++ { if array[j] > array[j+1] { array[j], array[j+1] = array[j+1], array[j] } } } } func main() { a1 := []int{3, 2, 6, 10, 7, 4, 6, 5} bubbleSort(a1) fmt.Println(a1) }
针对上面的排序问题，我们可以分析一下排序的步骤：
- 查看切片长度，以用来遍历元素(Len)；
- 比较切片中的两个元素(Less)；
- 根据比较的结果决定是否交换元素位置(Swap)。
到这里，或许你已经明白了，我们可以把上面的函数分解为一个支持任意类型的接口，任何其他类型的数据只要实现了这个接口，就可以用这个接口中的函数来排序了。
定义接口：
type Sortable interface{ Len() int Less(int, int) bool Swap(int, int) }
下面看一下实现：
package main import ( "fmt" )
// 定义接口 type Sortable interface { Len() int Less(int, int) bool Swap(int, int) }
// 对接口编程，实现冒泡排序 func bubbleSort(array Sortable) { for i := 0; i < array.Len(); i++ { for j := 0; j < array.Len()-i-1; j++ { if array.Less(j+1, j) { array.Swap(j, j+1) } } } } //实现接口的整型切片 type IntArr []int
// 实现接口 func (array IntArr) Len() int { return len(array) } // 实现接口 func (array IntArr) Less(i int, j int) bool { return array[i] < array[j] } // 实现接口 func (array IntArr) Swap(i int, j int) { array[i], array[j] = array[j], array[i] } //实现接口的字符串，按照长度排序 type StringArr []string
// 实现接口 func (array StringArr) Len() int { return len(array) } // 实现接口 func (array StringArr) Less(i int, j int) bool { return len(array[i]) < len(array[j]) } // 实现接口 func (array StringArr) Swap(i int, j int) { array[i], array[j] = array[j], array[i] } //测试 func main() { intArray1 := IntArr{3, 4, 2, 6, 10, 1} bubbleSort(intArray1) fmt.Println(intArray1) stringArray1 := StringArr{"hello", "i", "am", "go", "lang"} bubbleSort(stringArray1) fmt.Println(stringArray1) }
- 没有异常，
在Golang错误处理中，变量名称err遍布各处。不论Golang项目有多大和多重要，普遍的格式化错误结构如下：
f, err := os.Open(filename)
if err != nil {
// Handle the error here
}
根据Golang的约定，每个可能导致错误的函数都将error其作为最后一个返回值，码农有责任在每一步都正确处理它，所以golang代码中随处都是"if err != nil"语句。用条件处理每一个错误令人反感，而且非常不好看。
golang 中的错误处理的哲学和 C 语言一样，函数通过返回错误类型(error)或者 bool 类型(不需要区分多种错误状态时)表明函数的执行结果，调用检查返回的错误类型值是否是 nil 来判断调用结果。
"这设计有问题，为啥处处要检查错误"，估计每一个刚入Golang的人都会有这样的共识。
在Go以外的语言中（c++, java,python），你需要将所有内容包装在相同的内容中try...catch.
Golang中，将他严格规定下来：可能失败的每个函数都应该返回一个error类型作为最后一个值，并且随后对其处理。
golang 中内置的错误类型 error 是一个接口类型，自定义的错误类型也必须实现为 error 接口，这样调用总是可以通过 Error() 获取到具体的错误信息而不用关心错误的具体类型。标准库的 fmt.Errorf 和 errors.New 可以方便的创建 error 类型的变量。
type error interface { Error() string }
golang 的多返回值语法糖(可以返回多个值)，错误值一般作为返回值列表的最后一个，其他返回值是成功执行时需要返回的信息。为了避免错误处理时过深的代码缩进。
if err != nil { // error handling } else { // normal code }
预定义错误：
func doStuff() error { if someCondition { return errors.New("no space left on the device") // errors.NEW - 非常方便的生成新的error } else { return errors.New("permission denied") } }
但是上面的方法不好，因为对返回error进行检查时，需要根据字符串比较才能知道错误的类型，下面是一种优雅的方式：
var ErrNoSpaceLeft = errors.New("no space left on the device") var ErrPermissionDenied = errors.New("permission denied") func doStuff() error { if someCondition { return ErrNoSpaceLeft } else { return ErrPermissionDenied } }
根据下面的方式进行判断：优雅很多
if err == ErrNoSpaceLeft { // handle this particular error }
自定义错误：
HTTP 表示客户端的错误状态码有几十个。如果为每种状态码都预定义相应的错误值，代码会变得很繁琐：
var ErrBadRequest = errors.New("status code 400: bad request") var ErrUnauthorized = errors.New("status code 401: unauthorized") // ...
这种场景下最佳的最法是自定义一种错误类型，并且至少实现 Error() 方法(满足 error 定义)：
type HTTPError struct { Code int Description string } func (h *HTTPError) Error() string { return fmt.Sprintf("status code %d: %s", h.Code, h.Description) }
判断的的代码如下：
func request() error { return &HTTPError{404, "not found"} } func main() { err := request() if err != nil { // an error occured if err.(*HTTPError).Code == 404 { // handle a "not found" error } else { // handle a different error } } }
panic 、recover、 defer ： 会有专门的章节讲解这个专题
- 没有宏， 没有define(define有副作用： 没有类型检查， 还有富作用)
- 没有函数修饰， 大写表示public, 小写表示private
- 更没有线程局部存储
