Golang 备忘清单

package main
import "fmt"
func main() {
    fmt.Println("Hello, world!")
}

直接运行

$ go run hello.go
Hello, world!

或者在 Go repl 中尝试一，go 命令参考

var s1 string
s1 = "Learn Go!"
// 一次声明多个变量
var b, c int = 1, 2
var d = true
// 匿名赋值
_ , e = 10, 20 

简短声明

s1 := "Learn Go!"        // string
b, c := 1, 2             // int
d := true                // bool

参见：基本类型

package main
import "fmt"
// 程序的入口点
func main() {
  fmt.Println("Hello world!")
  say("Hello Go!")
}
func say(message string) {
  fmt.Println("You said: ", message)
}

参见：函数(Functions)

// 单行注释
/* 这是
多行注释 */

if true {
  fmt.Println("Yes!")
}

参见：条件控制

s1 := "Hello" + "World"
s2 := `A "raw" string literal
can include line breaks.`
// 输出：10
fmt.Println(len(s1))
// 输出：Hello
fmt.Println(string(s1[0:5]))

字符串的类型为 字符串

s := make([]string, 3)
s[0] = "a"
s[1] = "b"
s = append(s, "d")
s = append(s, "e", "f")
fmt.Println(s)
fmt.Println(s[1])
fmt.Println(len(s))
fmt.Println(s[1:3])
slice := []int{2, 3, 4}

另见：切片示例

const s string = "constant"
const Phi = 1.618
const n = 500000000
const d = 3e20 / n

常量声明可以使用 iota常量生成器 初始化，它用于 生成一组以相似规则初始化的常量，但是不用每行都 写一遍初始化表达式。 注意：

1. 在一个const声明语句中，在第一个声明的常量所在的行，iota被置为0，然后在每一个有常量声明的行加一。
2. 写在同一行的值是相同的

const (
    a = iota
    b
    c
)
// a = 0, b = 1, c = 2

package main
import (
        "fmt"
        s "strings"
)
func main() {
    /* 需要将字符串导入为 s */
        fmt.Println(s.Contains("test", "e"))
    /* 内置 */
    fmt.Println(len("hello"))  // => 5
    // 输出: 101
        fmt.Println("hello"[1])
    // 输出: e
        fmt.Println(string("hello"[1]))
}

实例	Result
Contains("test", "es")	true
Count("test", "t")	2
HasPrefix("test", "te")	true
HasSuffix("test", "st")	true
Index("test", "e")	1
Join([]string{"a", "b"}, "-")	a-b
Repeat("a", 5)	aaaaa
Replace("foo", "o", "0", -1)	f00
Replace("foo", "o", "0", 1)	f0o
Split("a-b-c-d-e", "-")	[a b c d e]
ToLower("TEST")	test
ToUpper("test")	TEST

a := 10
if a > 20 {
    fmt.Println(">")
} else if a < 20 {
    fmt.Println("<")
} else {
    fmt.Println("=")
}

x := "hello go!"
if count := len(x); count > 0 {
    fmt.Println("Yes")
}

---

if _, err := doThing(); err != nil {
    fmt.Println("Uh oh")
}

x := 42.0
switch x {
  case 0:
  case 1, 2:
      fmt.Println("Multiple matches")
  case 42:   // Don't "fall through".
      fmt.Println("reached")
  case 43:
      fmt.Println("Unreached")
  default:
      fmt.Println("Optional")
}

参见：Switch

for i := 0; i <= 10; i++ {
  fmt.Println("i: ", i)
}

nums := []int{2, 3, 4}
sum := 0
for _, num := range nums {
  sum += num
}
fmt.Println("sum:", sum)

i := 1
for i <= 3 {
  fmt.Println(i)
  i++
}

for i := 0; i <= 5; i++ {
  if i % 2 == 0 {
      continue
  }
  fmt.Println(i)
}

for {
  fmt.Println("loop")
  break
}

v := Vertex{X: 1, Y: 2}
// Field names can be omitted
v := Vertex{1, 2}
// Y is implicit
v := Vertex{X: 1}

您还可以输入字段名

v := &Vertex{1, 2}
v.X = 2

Doing v.X is the same as doing (*v).X, when v is a pointer.

func plus(a int, b int) int {
    return a + b
}
func plusPlus(a, b, c int) int {
    return a + b + c
}
fmt.Println(plus(1, 2))
fmt.Println(plusPlus(1, 2, 3))

func vals() (int, int) {
  return 3, 7
}
a, b := vals()
fmt.Println(a)    // => 3
fmt.Println(b)    // => 7

r1, r2 := func() (string, string) {
    x := []string{"hello", "world"}
    return x[0], x[1]
}()
// => hello world
fmt.Println(r1, r2)

func split(sum int) (x, y int) {
  x = sum * 4 / 9
  y = sum - x
  return
}
x, y := split(17)
fmt.Println(x)   // => 7
fmt.Println(y)   // => 10

func sum(nums ...int) {
  fmt.Print(nums, " ")
  total := 0
  for _, num := range nums {
      total += num
  }
  fmt.Println(total)
}
sum(1, 2)     // => [1 2] 3
sum(1, 2, 3)  // => [1 2 3] 6
nums := []int{1, 2, 3, 4}
sum(nums...)  // => [1 2 3 4] 10
// 不定参在内存中是连续存储的
// 不定参内部再传递的时候，参数也要是不定的

import --> const --> var --> init()

---

var num = setNumber()
func setNumber() int {
  return 42
}
func init() {
  num = 0
}
func main() {
  fmt.Println(num) // => 0
}

func main() {
  // 将函数赋给名称
  add := func(a, b int) int {
      return a + b
  }
  // 使用名称调用函数
  fmt.Println(add(3, 4)) // => 7
}

func scope() func() int{
  outer_var := 2
  foo := func() int {return outer_var}
  return foo
}
// Outpus: 2
fmt.Println(scope()())

package main
// 一个内部包只能被另一个包导入
// 那是在以内部目录的父级为根的树内
package internal

另见：内部包

// 以大写字母开头
func Hello () {
  ···
}

另见：导出的名称

ch <- 1
ch <- 2
ch <- 3
close(ch) // 关闭频道

---

// 迭代通道直到关闭
for i := range ch {
  ···
}

---

// Closed if `ok == false`
v, ok := <- ch

参见：范围和关闭

ch := make(chan int, 2)
ch <- 1
ch <- 2
ch <- 3
// 致命错误：
// 所有 goroutine 都处于休眠状态 - 死锁

参见：缓冲通道

func main() {
  defer func() {
    fmt.Println("Done")
  }()
  fmt.Println("Working...")
}

func main() {
  var d = int64(0)
  defer func(d *int64) {
    fmt.Printf("& %v Unix Sec\n", *d)
  }(&d)
  fmt.Print("Done ")
  d = time.Now().Unix()
}

defer 函数使用当前值d，除非我们使用指针在 main 末尾获取最终值

func main() {
  defer fmt.Println("Done")
  fmt.Println("Working...")
}

参见：Defer, panic and recover

• 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

+	&	+=	&=	&&	==	!=	(	)
-	|	-=	|=	||	<	<=	[	]
*	^	*=	^=	<-	>	>=	{	}
/	<<	/=	<<=	++	=	:=	,	;
%	>>	%=	>>=	--	!	...	.	:
	&^	&^=

:-	--
go command [参数]	go 命令 [参数]
go build	编译包和依赖包
go clean	移除对象和缓存文件
go doc	显示包的文档
go env	打印go的环境变量信息
go bug	报告bug
go fix	更新包使用新的api
go fmt	格式规范化代码
go generate	通过处理资源生成go文件
go get	下载并安装包及其依赖
go install	编译和安装包及其依赖
go list	列出所有包
go run	编译和运行go程序
go test	测试
go tool	运行给定的go工具
go version	显示go当前版本
go vet	发现代码中可能的错误

:-	--
GOOS	编译系统
GOARCH	编译arch
GO111MODULE	gomod开关
GOPROXY	go代理 https://goproxy.io https://goproxy.cn https://mirrors.aliyun.com/goproxy/
GOSSAFUNC	生成 SSA.html 文件，展示代码优化的每一步 GOSSAFUNC=func_name go build

:-	--
go mod init	初始化当前文件夹，创建go.mod文件
go mod download	下载依赖的module到本地
go mod tidy	增加缺少的module，删除无用的module
go mod vendor	将依赖复制到vendor下
文件 go.mod	依赖列表和版本约束
文件 go.sum	记录 module 文件 hash 值，用于安全校验