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

直接運(yùn)行

$ go run hello.go
Hello, world!

或者在 Go repl 中嘗試一，go 命令參考

var s1 string
s1 = "Learn Go!"
// 一次聲明多個(gè)變量
var b, c int = 1, 2
var d = true
// 匿名賦值
_ , e = 10, 20 

簡(jiǎn)短聲明

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

參見：基本類型

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

參見：函數(shù)(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常量生成器 初始化，它用于 生成一組以相似規(guī)則初始化的常量，但是不用每行都 寫一遍初始化表達(dá)式。 注意：

1. 在一個(gè)const聲明語(yǔ)句中，在第一個(gè)聲明的常量所在的行，iota被置為0，然后在每一個(gè)有常量聲明的行加一。
2. 寫在同一行的值是相同的

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

package main
import (
        "fmt"
        s "strings"
)
func main() {
    /* 需要將字符串導(dǎo)入為 s */
        fmt.Println(s.Contains("test", "e"))
    /* 內(nèi)置 */
    fmt.Println(len("hello"))  // => 5
    // 輸出: 101
        fmt.Println("hello"[1])
    // 輸出: e
        fmt.Println(string("hello"[1]))
}

實(shí)例	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
// 不定參在內(nèi)存中是連續(xù)存儲(chǔ)的
// 不定參內(nèi)部再傳遞的時(shí)候，參數(shù)也要是不定的

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

---

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

func main() {
  // 將函數(shù)賦給名稱
  add := func(a, b int) int {
      return a + b
  }
  // 使用名稱調(diào)用函數(shù)
  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
// 一個(gè)內(nèi)部包只能被另一個(gè)包導(dǎo)入
// 那是在以內(nèi)部目錄的父級(jí)為根的樹內(nèi)
package internal

另見：內(nèi)部包

// 以大寫字母開頭
func Hello () {
  ···
}

另見：導(dǎo)出的名稱

ch <- 1
ch <- 2
ch <- 3
close(ch) // 關(guān)閉頻道

---

// 迭代通道直到關(guān)閉
for i := range ch {
  ···
}

---

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

參見：范圍和關(guān)閉

ch := make(chan int, 2)
ch <- 1
ch <- 2
ch <- 3
// 致命錯(cuò)誤：
// 所有 goroutine 都處于休眠狀態(tài) - 死鎖

參見：緩沖通道

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 函數(shù)使用當(dāng)前值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 [參數(shù)]	go 命令 [參數(shù)]
go build	編譯包和依賴包
go clean	移除對(duì)象和緩存文件
go doc	顯示包的文檔
go env	打印go的環(huán)境變量信息
go bug	報(bào)告bug
go fix	更新包使用新的api
go fmt	格式規(guī)范化代碼
go generate	通過處理資源生成go文件
go get	下載并安裝包及其依賴
go install	編譯和安裝包及其依賴
go list	列出所有包
go run	編譯和運(yùn)行g(shù)o程序
go test	測(cè)試
go tool	運(yùn)行給定的go工具
go version	顯示go當(dāng)前版本
go vet	發(fā)現(xiàn)代碼中可能的錯(cuò)誤

:-	--
GOOS	編譯系統(tǒng)
GOARCH	編譯arch
GO111MODULE	gomod開關(guān)
GOPROXY	go代理 https://goproxy.io https://goproxy.cn https://mirrors.aliyun.com/goproxy/
GOSSAFUNC	生成 SSA.html 文件，展示代碼優(yōu)化的每一步 GOSSAFUNC=func_name go build

:-	--
go mod init	初始化當(dāng)前文件夾，創(chuàng)建go.mod文件
go mod download	下載依賴的module到本地
go mod tidy	增加缺少的module，刪除無用的module
go mod vendor	將依賴復(fù)制到vendor下
文件 go.mod	依賴列表和版本約束
文件 go.sum	記錄 module 文件 hash 值，用于安全校驗(yàn)