Go 极速上手

> brew install go
> go env GOROOT
> export GOPATH=$HOME/workspace/go
> mkdir -p $GOPATH/{src,bin}

# .zshrc or .bashrc
# Go
export GOPATH=$HOME/workspace/go
export GOROOT=/usr/local/opt/go/libexec

~/workspace/go via 🐹 v1.15.5
[I] ➜ mkdir hello
~/workspace/go via 🐹 v1.15.5
[I] ➜ go mod init fastzhong.com/hello
go: creating new go.mod: module fastzhong.com/hello
~/workspace/go via 🐹 v1.15.5
[I] ➜ ls
go.mod  pkg

~/workspace/go via 🐹 v1.15.5
[I] ➜ cat go.mod
───────┬─────────────────────────────────────────────────────────────────────────────────────────────────────────────────
       │ File: go.mod
───────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────────
   1   │ module fastzhong.com/hello
   2   │
   3   │ go 1.15
───────┴─────────────────────────────────────────────────────────────────────────────────────────────────────────────────

import (
    "github.com/gohugoio/hugo/commands"
)

package main

import (
    "fmt"
)

func main() {
    fmt.Println("Hello World!")
}

//运行main
workspace/go/hello via 🐹 v1.15.5 took 6s
[I] ➜ go run main.go
Hello World!

// 打包安装
workspace/go/hello via 🐹 v1.15.5
[I] ➜ go install fastzhong.com/hello

// 直接运行可执行二进制
workspace/go/hello via 🐹 v1.15.5
[I] ➜ hello
Hello World!

func add(num int) {
	num += 1
}

func realAdd(num *int) {
	*num += 1
}

func main() {
	num := 100
	add(num)
	fmt.Println(num)  // 100，num 没有变化

	realAdd(&num)
	fmt.Println(num)  // 101，指针传递，num 被修改
}

a := [...]int{1, 2, 3, 4, 5}
s1 := a[2:4]   // 3，4
s2 := a[1:5]   // 2，3，4，5
s3 := a[:]     // a
s4 := a[:4]    // 1，2，3，4
s5 := s2[:]    // 1，2，3，4，5
s6 := a[2:4:5] // 3

if x > 0 {
    return "positive"
} else {
    return "negative"
}

switch t := i.(type) {
case bool:
    return "I'm a bool"
case int:
    return "I'm an int"
default:
    return "Don't know type %T", t
}

-   for init; condition; post { } // 类似 C
-   for condition { } // 相当于 while
-   for { } // 无限循环

for i := 0; i < 10; i++ {
    sum += i
}

if skipped {
  goto doLast
}
// 跳过上面的代码块
doLast:
// 立即执行的代码块

list := []string{"a", "b", "c", "d", "e", "f"}
for i, v := range list {
    // i is the element index
    // v is the element value
}

-   init 函数先于 main 函数自动执行，不能被其他函数调用；
-   init 函数没有输入参数、返回值；
-   每个包可以有多个 init 函数，每个源文件也可以有多个 init 函数；
-   同一个包的 init 执行顺序，golang 没有明确定义，编程时要注意程序不要依赖这个执行顺序；
-   不同包的 init 函数按照包导入的依赖关系决定执行顺序；

func main() {
	for i := 0; i < 5; i++ {
		defer fmt.Println(i)
	}
}

$ go run main.go
4
3
2
1

func action() {
    defer fmt.Println("action completed")
    defer func() {
        if err := recover(); err != nil {
            fmt.Println(err)
            // do something to recover
        }
    }()

    panic("something goes wrong !!!")
}
// something goes wrong !!!
// action completed

// 单个变量
var i int = 0
var i = 0
i := 0

// 多个变量
var i, j, k int

// 常量:
const (
    a = iota    // a=0
    b           // 和 a 一样，不用重复 b = iota，iota会自增，b=1
    c           // c=2
    d = 1
    f           // 和 d 一样，f=1
)

func function_name( [parameter list] ) [return_types] {
// 函数体
}

func test(num ...int){
    fmt.Println(num) // [1 2 3 4]
}

test(1,2,3,4)

func test() (string,int,bool){
    return "Hello World", 100, true
}

v1, v2, v3 := test()

fmt.Println(v1, v2, v3) // Hello World 100 true

func test() (a string, b bool, c int) {
    a = "Golang"
    b = false
    c = 200
    return
}

v1, v2, v3 := test()

fmt.Println(v1, v2, v3) // Golang false 200

func test(){
    // 函数体
}

funcTest := test
fmt.Println(funcTest())

test := func(){
    // 函数体
}

package main

import "fmt"

type iAdder func(int, int) int

func main(){
    var adder iAdder = func(a int, b int) int {
        return a + b
    }

    fmt.Println(adder(1,2)) // 3
}

package main

import "fmt"

// 使用 闭包实现 斐波那契数列
func fibonacci() func() int {
    a, b := 0, 1

    return func() int {
        a, b = b, a +b
        return a
    }
}

func main() {
    f := fibonacci()

    fmt.Println(f()) // 1
    fmt.Println(f()) // 1
    fmt.Println(f()) // 2
    fmt.Println(f()) // 3
    fmt.Println(f()) // 5
}

type Student struct {
	name string
	age  int
}

func (stu *Student) hello(person string) string {
	return fmt.Sprintf("hello %s, I am %s", person, stu.name)
}

func main() {
	stu := &Student{
		name: "Tom",
	}
	msg := stu.hello("Jack")
	fmt.Println(msg) // hello Jack, I am Tom
}

type Person interface {
    getName() string
    getAge() int
}

type Student struct {
	name string
	age  int
}

func (stu *Student) getName() string {
	return stu.name
}

func (stu *Student) getAge() int {
	return stu.age
}

func main() {
	var p Person = &Student{
		name: "Tom",
		age:  18,
	}

	fmt.Println(p.getName()) // Tom
}