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

直接運行

$ go run hello.go
Hello, world!

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

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

簡短聲明

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

參見：基本類型

package main
import "fmt"
// 程序的入口點(dian)
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))
// 輸(shu)出：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

常量(liang)聲(sheng)明可以(yi)使用(yong) iota常量(liang)生成器 初(chu)始化，它用(yong)于(yu) 生成一(yi)組以(yi)相似規則初(chu)始化的常量(liang)，但是不(bu)用(yong)每行都(dou) 寫一(yi)遍初(chu)始化表(biao)達(da)式。 注意：

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

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

package main
import (
        "fmt"
        s "strings"
)
func main() {
    /* 需要將字符(fu)串(chuan)導(dao)入(ru)為(wei) s */
        fmt.Println(s.Contains("test", "e"))
    /* 內置 */
    fmt.Println(len("hello"))  // => 5
    // 輸出: 101
        fmt.Println("hello"[1])
    // 輸(shu)出: 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")
}

參見：

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
// 不定參在內存中是(shi)連續(xu)存儲(chu)的(de)
// 不(bu)定參內部再(zai)傳遞的(de)時候，參數也要是不(bu)定的(de)

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

---

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

func main() {
  // 將函數賦給名(ming)稱
  add := func(a, b int) int {
      return a + b
  }
  // 使用(yong)名稱調用(yong)函數
  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
// 一(yi)個內(nei)部(bu)包(bao)只能被另(ling)一(yi)個包(bao)導(dao)入
// 那是在以內部目(mu)錄的父級為(wei)根的樹內
package internal

另見：

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

另見：

ch <- 1
ch <- 2
ch <- 3
close(ch) // 關閉(bi)頻道

---

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

---

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

參見：

ch := make(chan int, 2)
ch <- 1
ch <- 2
ch <- 3
// 致(zhi)命錯誤：
// 所有 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...")
}

參見：

• 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代理
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 值，用于安全校驗