Go-CheatSheet

group

Go CheatSheet | Go语法速览与实践清单

Go (a.k.a. Golang) is a statically-typed programming language first developed at Google. It is derived from C with additional features such as garbage collection, type safety, dynamic-typing capabilities, additional built-in types, and a large standard library.

可以前往这里下载Go SDK安装包，或者使用brew等包管理器安装。现在我们也推荐使用 gvm 这样的专用版本管理工具，来方便地更新与切换版本。环境配置完毕后，可以使用go get获取依赖，go run运行程序，go build来编译项目生成与包名(文件夹名)一致的可执行文件。Golang 1.8之后支持dep依赖管理工具，对于空的项目使用dep init初始化依赖配置，其会生成 Gopkg.toml Gopkg.lock vendor/ 这三个文件(夹)。

在这里，我们首先对于Go的常用语法有所了解，Go语言设计的关键字，了解这些关键字有助于命名变量的冲突避免：

break    default      func    interface    select
case     defer        go      map          struct
chan     else         goto    package      switch
const    fallthrough  if      range        type
continue for          import  return       var

包管理与模块机制

Golang的包管理是一直是为人诟病之处，从Golang 1.5引入的vendor机制，到准官方工具dep,再到Go 1.11引入了Go Modules，其包管理与模块机制一直也在不断地完善。

Package

早期Go命令依赖于GOPATH环境变量进行代码组织，多项目情况下也可以使用ln进行目录映射以方便进行项目管；GOPATH允许设置多个目录，每个目录都会包含三个子目录：src用于存放源代码，pkg用于存放编译后生成的文件，bin用于存放编译后生成的可执行文件。

Go并没有相对路径引入，而是以文件夹为单位定义模块；并且规定每个源文件的首部需要进行包声明，可执行文件默认放在main包中。如上文所述，GOPATH环境变量为我们指明了本地工作空间的地址，而每个导入路径都会指明唯一的包。标准库中的包往往是fmt,net/http这样的短路径；而对于自定义的包，则必须指明根路径以避免潜在的冲突。如果我们使用了Github这样的源码仓库，则需要使用 github.com/user 作为根路径。

// goworkdir/src/project1/utils/auth.go
package utils

func Test1() string {
    return "Test1"
}

// goworkdir/src/project1/controllers/login.go
package controllers

import "project1/utils"

func Test2() string {
    return utils.Test1()
}

// goworkdir/src/project1/main.go
package main

import (
    "fmt"
    "project1/controllers"
)

func main() {
    fmt.Println(controllers.Test2())
}

Go中还允许针对不同的编译目标平台引入不同的文件:

mypkg_linux.go         // only builds on linux systems
mypkg_windows_amd64.go // only builds on windows 64bit platforms

我们可以使用 dep ensure -add github.com/pkg/errors 添加依赖，运行之后，其会在toml文件中添加如下锁：

[[constraint]]
  name = "github.com/pkg/errors"
  version = "0.8.0"

简单的Go中Hello World代码如下：

package main
import "fmt"
func main() {
    fmt.Println("hello world")
}

Go Modules

Go Modules将包名与路径分离，可以存放于文件系统上的任何为止，而不用管GOPATH路径到底是什么，我们可以创建任意的项目目录:

$ mkdir -p /tmp/scratchpad/hello
$ cd /tmp/scratchpad/hello

然后初始化所需要的模块:

$ go mod init github.com/you/hello

go: creating new go.mod: module github.com/you/hello

然后照常编写Go模块代码:

// hello.go
package main

import (
    "fmt"
    "rsc.io/quote"
)

func main() {
    fmt.Println(quote.Hello())
}

在执行 go build 命令之后，即可以在 go.mod 文件中查看模块定义与显式的声明:

$ cat go.mod

module github.com/you/hello

require rsc.io/quote v1.5.2

模块结构

模块是包含了Go源文件的目录树，并在根目录中添加了名为go.mod的文件，go.mod包含模块导入名称，声明了要求的依赖项，排除的依赖项和替换的依赖项。

module my/thing

require (
        one/thing v1.3.2
        other/thing v2.5.0 // indirect
        ...
)

exclude (
        bad/thing v0.7.3
)

replace (
        src/thing 1.0.2 => dst/thing v1.1.0
)

需要注意的是，该文件中声明的依赖，并不会在模块的源代码中使用import自动导入，还是需要我们人工添加import语句来导入的。模块可以包含其他模块，在这种情况下，它们的内容将从父模块中排除。除了go.mod文件外，跟目录下还可以存在一个名为go.sum的文件，用于保存所有的依赖项的哈希摘要校验之，用于验证缓存的依赖项是否满足模块要求。

外部依赖

模块依赖项会被下载并存储到 GOPATH/src/mod 目录中，直接后果就是废除了模块的组织名称。假设我们正在开发的项目依赖于github.com/me/lib且版本号1.0.0的模块，对于这种情况，我们会发现在GOPATH/src/mod中文件结构如下

Go的模块版本号必须以v开头，在发布版本时可以通过Tag方式来指定不同的版本。我们可以使用 go mod tidy 来移除未被使用的依赖，使用 go mod vendor 可以生成独立的vendor目录。

初始化函数

各个包中默认首字母大写的函数作为其他包可见的导出函数，而小写函数则默认外部不可见的私有函数。Go允许在文件中包含初始化函数，默认使用 _ 引入的包仅调用初始化函数：

import (
        mongo "mywebapp/libs/mongodb/db" // 对引入的模块重命名
        _ "mywebapp/libs/mysql/db" // 使用空白下划线表示仅调用其初始化函数

)

初始化函数会于属性初始化之后被调用：

// sandbox.go
package main

import "fmt"

var _ int64 = s()
func init() {
    fmt.Println("init in sandbox.go")
}
func s() int64 {
    fmt.Println("calling s() in sandbox.go")
    return 1
}
func main() {
    fmt.Println("main")
}

// a.go
package main
import "fmt"

var _ int64 = a()
func init() {
    fmt.Println("init in a.go")
}
func a() int64 {
    fmt.Println("calling a() in a.go")
    return 2
}

/* 输出结果
calling a() in a.go
calling s() in sandbox.go
init in a.go
init in sandbox.go
main
*/

而单个文件中也可以定义多个初始化函数：

package main

import "fmt"

func init() {
    fmt.Println("init 1")
}
func init() {
    fmt.Println("init 2")
}
func main() {
    fmt.Println("main")
}

表达式与控制流

变量声明与赋值

作为强类型静态语言，Go允许我们在变量之后标识数据类型，也为我们提供了自动类型推导的功能。不过需要注意的是，在函数体外Go仅允许使用声明式语句。

// 声明三个变量，皆为 bool 类型
var c, python, java bool

// 声明不同类型的变量，并且赋值
var i bool, j int = true, 2

// 复杂变量声明
var (
	ToBe   bool       = false
	MaxInt uint64     = 1<<64 - 1
	z      complex128 = cmplx.Sqrt(-5 + 12i)
)

// 短声明变量
c, python, java := true, false, "no!"

// 声明常量
const constant = "This is a constant"

在Go中，如果我们需要比较两个复杂对象的相似性，可以使用reflect.DeepEqual方法：

m1 := map[string]int{
    "a":1,
    "b":2,
}
m2 := map[string]int{
    "a":1,
    "b":2,
}

fmt.Println(reflect.DeepEqual(m1, m2))

条件判断

Go提供了增强型的if语句进行条件判断：

// 基础形式
if x > 0 {
	return x
} else {
	return -x
}

// 条件判断之前添加自定义语句
if a := b + c; a < 42 {
	return a
} else {
	return a - 42
}

// 常用的类型判断
var val interface{}
val = "foo"
if str, ok := val.(string); ok {
	fmt.Println(str)
}

Switch

Go也支持使用Switch语句：

// 基础格式
switch operatingSystem {
    case "darwin":
        fmt.Println("Mac OS Hipster")
        // 默认 break，不需要显式声明
    case "linux":
        fmt.Println("Linux Geek")
    default:
        // Windows, BSD, ...
        fmt.Println("Other")
}

// 类似于 if，可以在条件之前添加自定义语句
switch os := runtime.GOOS; os {
case "darwin": ...
}

// 使用 switch 语句进行类型判断：
switch v := anything.(type) {
  case string:
    fmt.Println(v)
  case int32, int64:
    ...
  default:
    fmt.Println("unknown")
}

Switch中也支持进行比较：

number := 42
switch {
	case number < 42:
		fmt.Println("Smaller")
	case number == 42:
		fmt.Println("Equal")
	case number > 42:
		fmt.Println("Greater")
}

或者进行多条件匹配：

var char byte = '?'
switch char {
	case ' ', '?', '&', '=', '#', '+', '%':
		fmt.Println("Should escape")
}

Switch中还支持对于类型的条件判断：

type T struct {
	name string
}

t := T{}

switch (interface{})(t).(type) {
case T:
	fmt.Print("1")
}

循环

Go支持使用for语句进行循环，不存在while或者until:

for i := 1; i < 10; i++ {
}

// while - loop
for ; i < 10;  {
}

// 单条件情况下可以忽略分号
for i < 10  {
}

// ~ while (true)
for {
}

我们也可以使用range函数，对于Arrays与Slices进行遍历:

// loop over an array/a slice
for i, e := range a {
    // i 表示下标，e 表示元素
}

// 仅需要元素
for _, e := range a {
    // e is the element
}

// 或者仅需要下标
for i := range a {
}

// 定时执行
for range time.Tick(time.Second) {
    // do it once a sec
}

因为Go没有逗号运算符，并且++与 – 是语句而非表达式，因此当我们想要去同时处理多个变量时，需要使用并行赋值:

// Reverse a
for i, j := 0, len(a)-1; i < j; i, j = i+1, j-1 {
    a[i], a[j] = a[j], a[i]
}

Function |函数

定义，参数与返回值

// 简单函数定义
func functionName() {}

// 含参函数定义
func functionName(param1 string, param2 int) {}

// 多个相同类型参数的函数定义
func functionName(param1, param2 int) {}

// 函数表达式定义
add := func(a, b int) int {
	return a + b
}

Go支持函数的最后一个参数使用 … 设置为不定参数，即可以传入一个或多个参数值：

func adder(args ...int) int {
	total := 0
	for _, v := range args { // Iterates over the arguments whatever the number.
		total += v
	}
	return total
}

adder(1, 2, 3) // 6
adder(9, 9) // 18

nums := []int{10, 20, 30}
adder(nums...) // 60

// 传入任意类型的不定参数

我们也可以使用Function Stub作为函数参数传入，以实现回调函数的功能：

func Filter(s []int, fn func(int) bool) []int {
    var p []int // == nil
    for _, v := range s {
        if fn(v) {
            p = append(p, v)
        }
    }
    return p
}

Go支持多个返回值：

// 返回单个值
func functionName() int {
    return 42
}

// 返回多个值
func returnMulti() (int, string) {
    return 42, "foobar"
}
var x, str = returnMulti()

// 命名返回多个值
func returnMulti2() (n int, s string) {
    n = 42
    s = "foobar"
    // n and s will be returned
    return
}
var x, str = returnMulti2()

虽然Go不是函数式语言，但是也可以用其实现柯里函数(Currying Function):

func add(x, y int) int {
    return x+ y
}

func adder(x int) (func(int) int) {
    return func(y int) int {
        return add(x, y)
    }
}

func main() {
	add3 := adder(3)
	fmt.Println(add3(4))    // 7
}

闭包| Closure

Go同样支持词法作用域与变量保留，因此我们可以使用来访问函数定义处外层的变量：

func scope() func() int{
    outer_var := 2
    foo := func() int { return outer_var}
    return foo
}

闭包中并不能够直接修改外层变量，而是会自动重定义新的变量值：

func outer() (func() int, int) {
    outer_var := 2
    inner := func() int {
        outer_var += 99
        return outer_var // => 101 (but outer_var is a newly redefined
    }
    return inner, outer_var // => 101, 2 (outer_var is still 2, not mutated by inner!)
}

函数执行

Go中提供了defer关键字，允许将某个语句的执行推迟到函数返回语句之前：

func read(...) (...) {
  f, err := os.Open(file)
  ...
  defer f.Close()
  ...
  return .. // f will be closed

多个defer出现的时候，多个defer之间按照LIFO（后进先出）的顺序执行:

package main
import "fmt"
func main(){
    defer func(){
        fmt.Println("1")
    }()
    defer func(){
        fmt.Println("2")
    }()
    defer func(){
        fmt.Println("3")
    }()
}

异常处理

Go语言中并不存在try-catch等异常处理的关键字，对于那些可能返回异常的函数，只需要在函数返回值中添加额外的Error类型的返回值：

type error interface {
    Error() string
}

某个可能返回异常的函数调用方式如下：

import (
    "fmt"
    "errors"
)

func main() {
    result, err:= Divide(2,0)

    if err != nil {
            fmt.Println(err)
    }else {
            fmt.Println(result)
    }
}

func Divide(value1 int,value2 int)(int, error) {
    if(value2 == 0){
        return 0, errors.New("value2 mustn't be zero")
    }
    return value1/value2 , nil
}

Panic与Recover

Go还为我们提供了panic函数，所谓panic，即是未获得预期结果，常用于抛出异常结果。譬如当我们获得了某个函数返回的异常，却不知道如何处理或者不需要处理时，可以直接通过panic函数中断当前运行，打印出错误信息、Goroutine追踪信息，并且返回非零的状态码：

_, err := os.Create("/tmp/file")
if err != nil {
	panic(err)
}

当函数F调用panic时，其执行流程会被终止，而所有的deferred函数会被正常的依次执行，然后F会返回到调用者。F此时的行为逻辑与直接调用panic函数并无差异，进程会在函数所在Goroutine的所有函数执行完毕之后，恢复异常的调用栈。Recover函数则可以手动地恢复Panic Goroutine的执行，正常的执行中recover函数会返回nil；而如果当前Goroutine被panic，recover函数会捕获传递给panic的值，并且恢复正常的执行流。

package main

import "fmt"

func main(){
    defer func(){
        if r := recover();r != nil{
            fmt.Println(r)
        }
    }()
    panic([]int{12312})
}

数据类型与结构

Go中可以使用 interface{} 来表示任意类型。

类型绑定与初始化

Go中的type关键字能够对某个类型进行重命名：

// IntSlice 并不等价于 []int，但是可以利用类型转换进行转换
type IntSlice []int
a := IntSlice{1, 2}

可以使用T(v)或者obj.(T)进行类型转换，obj.(T)仅针对interface{}类型起作用：

t := obj.(T) // if obj is not T, error
t, ok := obj.(T) // if obj is not T, ok = false

// 类型转换与判断
str, ok := val.(string);

基本数据类型

interface {} // ~ java Object
bool // true/false
string
int8  int16  int32  int64
int // =int32 on 32-bit, =int64 if 64-bit OS
uint8 uint16 uint32 uint64 uintptr
uint
byte // alias for uint8
rune // alias for int32, represents a Unicode code point
float32 float64

字符串

Go中支持以反引号定义多行字符串：

// 多行字符串声明
hellomsg := `
 "Hello" in Chinese is 你好 ('Ni Hao')
 "Hello" in Hindi is नमस्ते ('Namaste')
`

fmt的输出模块为我们提供了方便的格式化字符串输出功能：

fmt.Println("Hello, 你好, नमस्ते, Привет, ᎣᏏᏲ") // basic print, plus newline
p := struct { X, Y int }{ 17, 2 }
fmt.Println( "My point:", p, "x coord=", p.X ) // print structs, ints, etc
s := fmt.Sprintln( "My point:", p, "x coord=", p.X ) // print to string variable

fmt.Printf("%d hex:%x bin:%b fp:%f sci:%e",17,17,17,17.0,17.0) // c-ish format

// Sprintf 能够仅进行字符串格式化，返回格式化后的字符串，而非输出到控制台
s2 := fmt.Sprintf( "%d %f", 17, 17.0 )

// 将其输出到错误流中
fmt.Fprintf(os.Stderr, "an %s\n", "error")

序列类型

Array与Slice都可以用来表示序列数据，二者也有着一定的关联。

Array

其中Array用于表示固定长度的，相同类型的序列对象，可以使用如下形式创建：

[N]Type
[N]Type{value1, value2, ..., valueN}

// 由编译器自动计算数目
[...]Type{value1, value2, ..., valueN}

其具体使用方式为：

// 数组声明
var a [10]int

// 赋值
a[3] = 42

// 读取
i := a[3]

// 声明与初始化
var a = [2]int{1, 2}
a := [2]int{1, 2}

// 加 ... 会限制数组长度
a := [...]int{1, 2}

// 声明二维数组
array := [2][3]int{{1, 2, 3}, {4, 5, 6}}

Go内置了len与cap函数，用于获取数组的尺寸与容量：

var arr = [3]int{1, 2, 3}
arr := [...]int{1, 2, 3}

len(arr) // 3
cap(arr) // 3

不同于C/C++中的指针(Pointer)或者Java中的对象引用(Object Reference)，Go中的Array只是值(Value)。这也就意味着，当进行数组拷贝，或者函数调用中的参数传值时，会复制所有的元素副本，而非仅仅传递指针或者引用。显而易见，这种复制的代价会较为昂贵。

Slice

Slice为我们提供了更为灵活且轻量级地序列类型操作，可以使用如下方式创建Slice:

// 使用内置函数创建
make([]Type, length, capacity)
make([]Type, length)

// 声明为不定长度数组
[]Type{}
[]Type{value1, value2, ..., valueN}

// 对现有数组进行切片转换
array[:]
array[:2]
array[2:]
array[2:3]

// 不定类型切片声明
a := []interface{}{2, 1, []interface{}{3, []interface{}{4, 5}, 6}, 7, []interface{}{8}}

// 二维不定类型切片
b := [][]interface{}{
		[]interface{}{1, 2},
		[]interface{}{3, 4},
	}

不同于Array, Slice可以看做更为灵活的引用类型(Reference Type)，它并不真实地存放数组值，而是包含数组指针(ptr)，len，cap三个属性的结构体。换言之，Slice可以看做对于数组中某个段的描述，包含了指向数组的指针，段长度，以及段的最大潜在长度，其结构如下图所示：

group 2

// 创建 len 为 5，cap 为 5 的 Slice
s := make([]byte, 5)

// 对 Slice 进行二次切片，此时 len 为 2，cap 为 3
s = s[2:4]

// 恢复 Slice 的长度
s = s[:cap(s)]

需要注意的是，切片操作并不会真实地复制Slice中值，只是会创建新的指向原数组的指针，这就保证了切片操作和操作数组下标有着相同的高效率。不过如果我们修改Slice中的值，那么其会真实修改底层数组中的值，也就会体现到原有的数组中：

d := []byte{'r', 'o', 'a', 'd'}
e := d[2:]
// e == []byte{'a', 'd'}
e[1] = 'm'
// e == []byte{'a', 'm'}
// d == []byte{'r', 'o', 'a', 'm'}

Go提供了内置的append函数，来动态为Slice添加数据，该函数会返回新的切片对象，包含了原始的Slice中值以及新增的值。如果原有的Slice的容量不足以存放新增的序列，那么会自动分配新的内存：

// len=0 cap=0 []
var s []int

// len=1 cap=2 [0]
s = append(s, 0)

// len=2 cap=2 [0 1]
s = append(s, 1)

// len=5 cap=8 [0 1 2 3 4]
s = append(s, 2, 3, 4)

// 使用 ... 来自动展开数组并进行合并
a := []string{"John", "Paul"}
b := []string{"George", "Ringo", "Pete"}
a = append(a, b...) // equivalent to "append(a, b[0], b[1], b[2])"
// a == []string{"John", "Paul", "George", "Ringo", "Pete"}

我们也可以使用内置的copy函数，进行Slice的复制，该函数支持对于不同长度的Slice进行复制，其会自动使用最小的元素数目。同时，copy函数还能够自动处理使用了相同的底层数组之间的Slice复制，以避免额外的空间浪费。

func copy(dst, src []T) int

// 申请较大的空间容量
t := make([]byte, len(s), (cap(s)+1)*2)
copy(t, s)
s = t

Map |映射类型

var m map[string]int
m = make(map[string]int)
m["key"] = 42

// 删除某个键
delete(m, "key")

// 测试该键对应的值是否存在
elem, has_value := m["key"]

// map literal
var m = map[string]Vertex{
    "Bell Labs": {40.68433, -74.39967},
    "Google":    {37.42202, -122.08408},
}

Struct & Interface |结构体与接口

Struct |结构体

Go语言中并不存在类的概念，只有结构体，结构体可以看做属性的集合，同时可以为其定义方法。

// 声明结构体
type Vertex struct {
    // 结构体的属性，同样遵循大写导出，小写私有的原则
    X, Y int
    z bool
}

// 也可以声明匿名/隐式结构体
point := struct {
	X, Y int
}{1, 2}

// 声明空指针
var v *Vertex = new(Vertex)

// 显式声明键
var v = Vertex{X: 1, Y: 2}

// 声明数组
var v = []Vertex{{1,2},{5,2},{5,5}}

// 创建结构体实例
var v = Vertex{1, 2}

// 读取或者设置属性
v.X = 4;

方法的声明也非常简洁，只需要在func关键字与函数名之间声明结构体指针即可，该结构体会在不同的方法间进行复制：

func (v Vertex) Abs() float64 {
    return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

// Call method
v.Abs()

对于那些需要修改当前结构体对象的方法，则需要传入指针：

func (v *Vertex) add(n float64) {
    v.X += n
    v.Y += n
}

new与make

Pointer |指针

// p 是 Vertex 类型
p := Vertex{1, 2}

// q 是指向 Vertex 的指针
q := &p

// r 同样是指向 Vertex 对象的指针
r := &Vertex{1, 2}

// 指向 Vertex 结构体对象的指针类型为 *Vertex
var s *Vertex = new(Vertex)

当我们在定义结构体时，可以使用指针或者值作为接受者来定义方法用指针作为接收者，那么变量（或者可以称作对象）本身是按引用传递的，在方法内可以修改对象的数据。使用值接收者，以为这是按值传递的，那么对象在方法内是处于只读状态的。并且指针类型时调用方法会复制receiver,每调用一次TestValue，item就会被复制一次.实际相当于TestValue(v)，TestPointer(&v)。

type VideoItem struct {
	GroupId  int64
	ItemId   int64
	AggrType int32
}

func (item *VideoItem) TestPointer(GroupId int64) {
	fmt.Printf("TestPointer %p %v\n", item, item)
	item.GroupId = GroupId
}

func (item VideoItem) TestValue(GroupId int64) {
	fmt.Printf("TestPointer %p %v\n", &item, &item)
	item.GroupId = GroupId
}

func main() {
	v := VideoItem{}
	fmt.Printf("TestPointer %p %v\n", &v, &v)

    // 值不变
    v.TestValue(1)

    // v 的 GroupId 被修改为 2
	v.TestPointer(2)

    // 值不变
    (&v).TestValue(3)

    // v 的  GroupId 被修改为 4
	(&v).TestPointer(4)

	fmt.Println(v)
}

/*
TestPointer 0xc420018300 &{0 0 0}
TestPointer 0xc420018360 &{0 0 0}
TestPointer 0xc420018300 &{0 0 0}
TestPointer 0xc4200183c0 &{0 0 0}
TestPointer 0xc420018300 &{0 0 0}
*/

传递普通变量传递值拷贝，不能修改原始值，如果是大对象则内存效率不高。 传递变量的指针，指针为固定大小，效率更高，可以就地修改对象的原始值。 在方法集的使用上，无论接收者是变量还是指针，都能直接正确调用，无需特殊处理，能正确调用所有绑定在该值或指针上的方法，Go会自动帮我们处理引用与解引用。

Interface |接口

Go允许我们通过定义接口的方式来实现多态性：

// 接口声明
type Awesomizer interface {
    Awesomize() string
}

// 结构体并不需要显式实现接口
type Foo struct {}

// 而是通过实现所有接口规定的方法的方式，来实现接口
func (foo Foo) Awesomize() string {
    return "Awesome!"
}

type Shape interface {
   area() float64
}

func getArea(shape Shape) float64 {
   return shape.area()
}

type Circle struct {
   x,y,radius float64
}

type Rectangle struct {
   width, height float64
}

func(circle Circle) area() float64 {
   return math.Pi * circle.radius * circle.radius
}

func(rect Rectangle) area() float64 {
   return rect.width * rect.height
}

func main() {
   circle := Circle{x:0,y:0,radius:5}
   rectangle := Rectangle {width:10, height:5}

   fmt.Printf("Circle area: %f\n",getArea(circle))
   fmt.Printf("Rectangle area: %f\n",getArea(rectangle))
}
//Circle area: 78.539816
//Rectangle area: 50.000000

惯用的思路是先定义接口，再定义实现，最后定义使用的方法：

package animals

type Animal interface {
	Speaks() string
}

// implementation of Animal
type Dog struct{}
func (a Dog) Speaks() string { return "woof" }

/** 在需要的地方直接引用 **/
package circus

import "animals"

func Perform(a animal.Animal) { return a.Speaks() }

Go也为我们提供了另一种接口的实现方案，我们可以不在具体的实现处定义接口，而是在需要用到该接口的地方，该模式为：

func funcName(a INTERFACETYPE) CONCRETETYPE

定义接口：

package animals

type Dog struct{}
func (a Dog) Speaks() string { return "woof" }

/** 在需要使用实现的地方定义接口 **/
package circus

type Speaker interface {
	Speaks() string
}

func Perform(a Speaker) { return a.Speaks() }

Embedding |嵌入

Go语言中并没有子类继承这样的概念，而是通过嵌入(Embedding)的方式来实现类或者接口的组合。

// ReadWriter 的实现需要同时满足 Reader 与 Writer
type ReadWriter interface {
    Reader
    Writer
}

// Server 暴露了所有 Logger 结构体的方法
type Server struct {
    Host string
    Port int
    *log.Logger
}

// 初始化方式并未受影响
server := &Server{"localhost", 80, log.New(...)}

// 却可以直接调用内嵌结构体的方法，等价于 server.Logger.Log(...)
server.Log(...)

// 内嵌结构体的名词即是类型名
var logger *log.Logger = server.Logger

Reflection & Generics |反射与泛型

Go中并没有泛型。

Web编程

HTTP Server

package main

import (
    "fmt"
    "net/http"
)

// define a type for the response
type Hello struct{}

// let that type implement the ServeHTTP method (defined in interface http.Handler)
func (h Hello) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    fmt.Fprint(w, "Hello!")
}

func main() {
    var h Hello
    http.ListenAndServe("localhost:4000", h)
}

// Here's the method signature of http.ServeHTTP:
// type Handler interface {
//     ServeHTTP(w http.ResponseWriter, r *http.Request)
// }

Beego

利用Beego官方推荐的 bee 命令行工具，我们可以快速创建Beego项目，其目录组织方式如下：

quickstart
├── conf
│   └── app.conf
├── controllers
│   └── default.go
├── main.go
├── models
├── routers
│   └── router.go
├── static
│   ├── css
│   ├── img
│   └── js
├── tests
│   └── default_test.go
└── views
    └── index.tpl

在main.go文件中，我们可以启动Beego实例，并且调用路由的初始化配置文件：

package main

import (
        _ "quickstart/routers"
        "github.com/astaxie/beego"
)

func main() {
        beego.Run()
}

而在路由的初始化函数中，我们会声明各个路由与控制器之间的映射关系：

package routers

import (
        "quickstart/controllers"
        "github.com/astaxie/beego"
)

func init() {
        beego.Router("/", &controllers.MainController{})
}

也可以手动指定Beego项目中的静态资源映射：

beego.SetStaticPath("/down1", "download1")
beego.SetStaticPath("/down2", "download2")

在具体的控制器中，可以设置返回数据，或者关联的模板名：

package controllers

import (
        "github.com/astaxie/beego"
)

type MainController struct {
        beego.Controller
}

func (this *MainController) Get() {
        this.Data["Website"] = "beego.me"
        this.Data["Email"] = "astaxie@gmail.com"
        this.TplNames = "index.tpl" // version 1.6 use this.TplName = "index.tpl"
}

DevPractics |开发实践

文件读写

import (
    "io/ioutil"
)
...
datFile1, errFile1 := ioutil.ReadFile("file1")
if errFile1 != nil {
	panic(errFile1)
}
...

测试

VSCode可以为函数自动生成基础测试用例，并且提供了方便的用例执行与调试的功能。

/** 交换函数 */
func swap(x *int, y *int) {
	x, y = y, x
}

/** 自动生成的测试函数 */
func Test_swap(t *testing.T) {
	type args struct {
		x *int
		y *int
	}
	tests := []struct {
		name string
		args args
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			swap(tt.args.x, tt.args.y)
		})
	}
}

Links

下一页

最近更新于0001-01-01