go语言最主要特性主要是：
自动垃圾回收
更丰富的内置类型函数多返回值
错误处理
匿名函数和闭包
类型和接口
并发编程
反射
语言交互性
1、自动垃圾回收
能够像java、C#等语言自带GC，不用再为内存管理苦恼
2、更丰富的内置类型
关键在于内置，像map、slice这些常用的数据类型，内置于builtin，默认包含，无需自己添加。
3、函数返回多值
多值返回仅动态语言Python有此特性
func getName()(firstName, middleName, lastName, nickName string){
return "May", "M", "Chen", "Babe"
}
func getName()(firstName, middleName, lastName, nickName string){
firstName = "May"
middleName = "M"
lastName = "Chen"
nickName = "Babe"
return
}
_, _, lastName, _ := getName()
4、错误处理
3个重要关键字defer、panic、recover
defer是函数结束后执行，呈先进后出；
panic是程序出现无法修复的错误时使用，但会让defer执行完；
recover会修复错误，不至于程序终止。当不确定函数不会出错时使用defer+recover
package main
import (
"log"
)
func fixError() {
if r := recover(); r != nil {
log.Printf("err caught: %v", r)
} else {
log.Println("no err")
}
}
func myDivide(x, y int) int {
return x / y
}
func testFunc() {
defer fixError()
myDivide(6, 0)
}
func main() {
testFunc()
log.Println("main end")
}
/Users/zhaojunyan/go/src/src [/Users/zhaojunyan/go/src]
2018/01/29 12:52:44 err caught: runtime error: integer divide by zero
2018/01/29 12:52:44 main end
成功: 进程退出代码 0.
5、匿名函数和闭包
匿名函数就是一个没有名字的函数，本身也是一个闭包
func main() {
f := func(x, y int) int {
return x + y
}
fmt.Println(f(4, 5))
z := func(x, y int) int {
fmt.Println("匿名函数，直接执行", "x:", x, "y:", y)
return x + y
}(6, 7)
fmt.Println(z)
}
闭包是可以包含自由变量的代码块，这些变量不在这个代码块内或者任何全局上下文中定义，而是在定义代码块的环境中定义。
闭包的价值在于可以作为函数对象或者匿名函数，存储到变量中作为参数传递给其他函数，能够被函数动态创建和返回。package main
import (
"fmt"
)
func main() {
var j int = 5
a := func() func() {
var i int = 10
return func() {
fmt.Printf("i, j: %d, %d\n", i, j)
}
}()
a()
j *= 2
a()
}
/Users/zhaojunyan/go/src/src [/Users/zhaojunyan/go/src]
i, j: 10, 5
i, j: 10, 10
成功: 进程退出代码 0.
再看个复杂的：
package main
import "fmt"
func adder() func(int) int {
sum := 0
return func(x int) int {
sum += x
return sum
}
}
func main() {
pos := adder()
n := 10
fmt.Println(pos(n))
}
此时，n是多少，打印出来的就是多少，但是当pos(n)多执行几次，就会发现不同。
func main() {
pos := adder()
n := 10
fmt.Println(pos(n))
fmt.Println(pos(n))
fmt.Println(pos(n))
}
/Users/zhaojunyan/go/src/src [/Users/zhaojunyan/go/src]
10
20
30
成功: 进程退出代码 0.
发现结果，成n的倍数增长。其实pos的函数体虽然是sum := 0
return func(x int) int {
sum += x
return sum
}但是sum是一个闭包变量，或者理解为仅初始化一次，且是一个静态变量。备注：return之前的代码仅执行一次。
如下面示例代码，sum:=0和sum=9都仅执行一次：
package main
import "fmt"
func adder() func(int) int {
sum := 0
sum = 9
return func(x int) int {
sum += x
return sum
}
}
func main() {
pos := adder()
n := 10
fmt.Println(pos(n))
fmt.Println(pos(n))
fmt.Println(pos(n))
}
/Users/zhaojunyan/go/src/src [/Users/zhaojunyan/go/src]
19
29
39
成功: 进程退出代码 0.
6、类型和接口
类型非常接近于C语言中的结构体，也使用了struct。go语言类型不支持继承和重载，仅有封装和组合。
go语言引入了强大的“非侵入式”接口，无需指明类型实现了哪个接口。
7、并发编程
go语言倡导使用消息传递来共享内存，引入了goroutine概念，这是一个协程，更轻量级的线程。与channel搭配使用。
package main
import "fmt"
func sum(values []int, resultChan chan int) {
sum := 0
for _, value := range values {
sum += value
}
resultChan <- sum // 将计算结果发送到channel中
}
func main() {
values := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
resultChan := make(chan int, 2)
go sum(values[:len(values)/2], resultChan)
go sum(values[len(values)/2:], resultChan)
sum1, sum2 := <-resultChan, <-resultChan // 接收结果
fmt.Println("Result:", sum1, sum2, sum1+sum2)
}
8、反射
通过反射，你可以获取对象类型的详细信息，并可动态操作对象。反射是把双刃剑，功能强大但代码可读性并不理想。若非必要，不推荐使用反射。
package main
import (
"fmt"
"reflect"
)
type Bird struct {
Name string
LifeExpectance int
}
func (b *Bird) Fly() {
fmt.Println("I am flying...")
}
func main() {
sparrow := &Bird{"Sparrow", 3}
s := reflect.ValueOf(sparrow).Elem()
typeOfT := s.Type()
for i := 0; i < s.NumField(); i++ {
f := s.Field(i)
fmt.Printf("%d: %s %s = %v\n", i, typeOfT.Field(i).Name, f.Type(),
f.Interface())
}
}
/Users/zhaojunyan/go/src/src [/Users/zhaojunyan/go/src]
0: Name string = Sparrow
1: LifeExpectance int = 3
成功: 进程退出代码 0.
9、语言交互性
由于Go语言与C语言之间的天生联系，Go语言的设计者们自然不会忽略如何重用现有C模块 的这个问题，这个功能直接被命名为Cgo。Cgo既是语言特性,同时也是一个工具的名称。
package main
//#include <stdio.h>
import "C"
func main() {
cstr := C.CString("ab, Hello, world")
C.puts(cstr)
println(*cstr)
}
有疑问加站长微信联系（非本文作者）
