Go语言学习之旅 1 - 简介

Go 是编译型语言

要创建并运行 Go 程序，程序员必须执行如下步骤。

1. 使用文本编辑器创建 Go 程序；
2. 保存文件；
3. 编译程序；
4. 运行编译得到的可执行文件。

为什么要学习Go语言

最佳的平衡：快速编译，高效执行，易于开发。

Go语言的特性

语法简单
并发模型
Goroutine 是 Go 最显著的特征。它用类协程的方式来处理并发单元
并发编程变得极为容易，无须处理回调，无须关注线程切换，仅一个关键字，简单而自然。
搭配 channel，将并发单元间的数据耦合拆解开来，这对所有纠结于内存共享、锁粒度的开发人员都是一个可期盼的解脱
内存分配
垃圾回收
静态链接
将运行时、依赖库直接打包到可执行文件内部
标准库
其中值得称道的是 net/http，仅须简单几条语句就能实现一个高性能 Web Server，
工具链

Go语言为并发而生

大部分编程语言都没有有效的工具让程序可以轻易利用这些资源，Go语言从底层原生支持并发，无须第三方库，开发人员可以很轻松地在编写程序时决定怎么使用 CPU 资源。并发是基于 goroutine 的，goroutine 类似于线程，但并非线程。可以将 goroutine 理解为一种虚拟线程。Go语言运行时会参与调度 goroutine，并将 goroutine 合理地分配到每个 CPU 中，最大限度地使用 CPU 性能

多个 goroutine 中，Go语言使用通道（channel）进行通信，通道是一种内置的数据结构，可以让用户在不同的 goroutine 之间同步发送具有类型的消息。这让编程模型更倾向于在 goroutine 之间发送消息，而不是让多个 goroutine 争夺同一个数据的使用权。

程序可以将需要并发的环节设计为生产者模式和消费者的模式，将数据放入通道。通道另外一端的代码将这些数据进行并发计算并返回结果，如下图所示。

更多学习资料

http://docscn.studygolang.com/doc/
https://go-zh.org/#
https://tour.go-zh.org/list

 

Go语言学习之旅 2 - 基本语法及数据结构

概述

连续三节的内容如下：

• 第一节覆盖了基本语法及数据结构
• 第二节讨论了方法与接口
• 第三节则简单介绍了 Go 的并发原语。

导入包 import

大写开头，导出
如果一个名字以大写字母开头，那么它就是已导出的。例如，Pizza 就是个已导出名，Pi 也同样，它导出自 math 包。

1. import 分组 
   import "fmt" 
   import "math"
   

   　　

不过使用分组导入语句是更好的形式。

import (
 
"fmt"
 
"math"
 
)

　　

函数参数缩写 

1. func add(x int, y int) int {
    
   return x + y
    
   }
    
   可缩写为
    
   func add(x, y int) int {
    
   return x + y
    
   }
   

   有意义的返回值

Go 的返回值可被命名，它们会被视作定义在函数顶部的变量。

var 语句用于声明一个变量
var c, python, java bool

短变量声明
在函数中，简洁赋值语句 := 可在类型明确的地方代替 var 声明。:= 结构不能在函数外使用。

Go 的基本类型有

bool
 
string
 
int int8 int16 int32 int64
 
uint uint8 uint16 uint32 uint64 uintptr
 
byte // uint8 的别名
 
rune // int32 的别名
 
// 表示一个 Unicode 码点
 
float32 float64
 
complex64 complex128

　　

类型转换

表达式 T(v) 将值 v 转换为类型 T。

1.  
   i := 42
2.  
   f := float64(i)
3.  
   u := uint(f)
4.  
    
5.  
   var i int = 42
6.  
   var f float64 = float64(i)

类型推导
在声明一个变量而不指定其类型时（即使用不带类型的 := 语法或 var = 表达式语法），变量的类型由右值推导得出。

常量

常量的声明与变量类似，只不过是使用 const 关键字。
for 是 Go 中的 “while”

1.  
   func main() {
2.  
   sum := 1
3.  
   for sum < 1000 {
4.  
   sum += sum
5.  
   }
6.  
   fmt.Println(sum)
7.  
   }

defer

defer 语句会将函数推迟到外层函数返回之后执行。

推迟调用的函数其参数会立即求值，但直到外层函数返回前该函数都不会被调用。
推迟的函数调用会被压入一个栈中。当外层函数返回时，被推迟的函数会按照后进先出的顺序调用。

Go 拥有指针。指针保存了值的内存地址。

类型 *T 是指向 T 类型值的指针。其零值为 nil。

var p *int
& 操作符会生成一个指向其操作数的指针。

i := 42
p = &i

结构体

一个结构体（struct）就是一组字段（field）

数组

数组的长度是其类型的一部分，因此数组不能改变大小
var a [10]int

切片

类型 []T 表示一个元素类型为 T 的切片。
切片通过两个下标来界定，即一个上界和一个下界，二者以冒号分隔：
a[low : high]
a[1:4] 它包含 a 中下标从 1 到 3 的元素：

切片就像数组的引用
切片并不存储任何数据，它只是描述了底层数组中的一段。
更改切片的元素会修改其底层数组中对应的元素。
切片文法类似于没有长度的数组文法。
这是一个数组文法：
[3]bool{true, true, false}
切片下界的默认值为 0，上界则是该切片的长度。
以下切片是等价的：

1.  
   a[0:10]
2.  
   a[:10]
3.  
   a[0:]
4.  
   a[:]

切片的长度与容量
切片拥有 长度 和 容量。
切片的长度就是它所包含的元素个数。
切片的容量是从它的第一个元素开始数，到其底层数组元素末尾的个数。
切片 s 的长度和容量可通过表达式 len(s) 和 cap(s) 来获取。
nil 切片的零值是 nil
用 make 创建切片,创建动态数组的方式。
make 函数会分配一个元素为零值的数组并返回一个引用了它的切片：

a := make([]int, 5)  // len(a)=5

切片的切片,即是二维数组

1.  
   board := [][]string{
2.  
   []string{"_", "_", "_"},
3.  
   []string{"_", "_", "_"},
4.  
   []string{"_", "_", "_"},
5.  
   }

Range

for 循环的 range 形式可遍历切片或映射。
当使用 for 循环遍历切片时，每次迭代都会返回两个值。第一个值为当前元素的下标，第二个值为该下标所对应元素的一份副本。

1.  
   for i, v := range pow {
2.  
   fmt.Printf("2**%d = %d\n", i, v)
3.  
   }

可以将下标或值赋予 _ 来忽略它。

1.  
   for i, _ := range pow
2.  
   for _, value := range pow

若你只需要索引，忽略第二个变量即可。

 for i := range pow

映射 ( map )

1.  
   其实就是 map 键值对的数据结构实现
2.  
   映射将键映射到值。
3.  
   映射的零值为 nil 。nil 映射既没有键，也不能添加键。
4.  
   make 函数会返回给定类型的映射，并将其初始化备用
5.  
    
6.  
   var m map[string]Vertex
7.  
   m = make(map[string]Vertex)
8.  
   m["Bell Labs"] = xxxxxxx

映射的文法
映射的文法与结构体相似，不过必须有键名。

1.  
   var m = map[string]Vertex{
2.  
   "Bell Labs": Vertex{
3.  
   40.68433, -74.39967,
4.  
   },
5.  
   "Google": Vertex{
6.  
   37.42202, -122.08408,
7.  
   },
8.  
   }
9.  
   若顶级类型只是一个类型名，你可以在文法的元素中省略它。
10.  
    var m = map[string]Vertex{
11.  
    "Bell Labs": {40.68433, -74.39967},
12.  
    "Google": {37.42202, -122.08408},
13.  
    }

修改映射
在映射 m 中插入或修改元素：

m[key] = elem

获取元素：

  elem = m[key]

删除元素：

  delete(m, key)

通过双赋值检测某个键是否存在：

  elem, ok = m[key]

若 key 在 m 中，ok 为 true ；否则，ok 为 false。
若 key 不在映射中，那么 elem 是该映射元素类型的零值。

函数值

函数也是值。它们可以像其它值一样传递。
函数值可以用作函数的参数或返回值。
PS: 其实就是函数可以当参数传递

函数的闭包
Go 函数可以是一个闭包。闭包是一个函数值，它引用了其函数体之外的变量。该函数可以访问并赋予其引用的变量的值，换句话说，该函数被这些变量“绑定”在一起。

1.  
   func adder() func(int) int {
2.  
   sum := 0
3.  
   return func(x int) int {
4.  
   sum += x
5.  
   return sum
6.  
   }
7.  
   }

函数的命名返回值
命名返回参数
可以像python那样返回多个结果，只是非tuple
对于不想要的返回值，可以扔垃圾桶_
如果用命名返回参数，return语句可以为空。return 不为空，返回值顺序是return的顺序而非在函数头声明的顺序

1.  
   package main
2.  
    
3.  
   func change(a, b int) (x, y int) {
4.  
   x = a + 100
5.  
   y = b + 100
6.  
    
7.  
   return //101, 102
8.  
   //return x, y //同上
9.  
   //return y, x //102, 101
10.  
    }
11.  
     
12.  
    # 更多学习资料
13.  
    [http://docscn.studygolang.com/doc/](http://docscn.studygolang.com/doc/)
14.  
    https://go-zh.org/#
15.  
    https://tour.go-zh.org/list
16.  
     
17.