Golang

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

var a int
var b bool
var str string

// 因式分解关键字的写法，一般用于声明全局变量
var (
	a int
	b bool
	str string
)

// 声明与赋值（初始化）语句也可以组合起来
var identifier [type] = value
var a int = 15
var i = 5 // 自动推断
var b bool = false
var str string = "Go says hello to the world!"

// 短变量声明，用于函数体内声明局部变量
a := 1
a, b, c := 5, 7, "abc"
a, b = b, a  // 相当于C++中的 swap(a,b)

const Pi float64 = 3.14159265358979323846 // 单行常量声明，显示
const Pi = 3.14159 // 隐式

// 以const代码块形式声明常量
const (
    size int64 = 4096
    i, j, s = 13, 14, "bar" // 单行声明多个常量
)

var arr [5]int // 一维
var mArr [2][3][4]int // 多维
var arr2 = [6]int { 11, 12, 13, 14, 15, 16,} // [11 12 13 14 15 16]
var arr3 = [...]int { 21, 22, 23,} // [21 22 23] ... 自动计算元素个数

var nums = []int{1, 2, 3, 4, 5, 6}

type slice struct {
    array unsafe.Pointer // 是指向底层数组的指针
    len   int // 切片的长度，即切片中当前元素的个数
    cap   int // 底层数组的长度，也是切片的最大容量，cap 值永远大于等于 len 值
} 

// 1、make 函数
sl := make([]byte, 6, 10) // 其中10为cap值，即底层数组长度，6为切片的初始长度
sl := make([]byte, 6) // cap = len = 6
// 2、数组切片化 array[low : high : max]
arr := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
sl := arr[3:7:9] // len = high - low ; cap = max - low ; 即数组下标 [3,7)
// 3、切片创建切片 与 方法2 书写方法相同

var s []int
s = append(s, 11) 
fmt.Println(len(s), cap(s)) //1 1	创建底层数组 u1（长度1）
s = append(s, 12) 
fmt.Println(len(s), cap(s)) //2 2	创建底层数组 u2（长度2 = u1的两倍），拷贝 u1 元素， array 指向 u2   
s = append(s, 13) 
fmt.Println(len(s), cap(s)) //3 4	创建底层数组 u3（长度4 = u2的两倍），拷贝 u2 元素， array 指向 u3
s = append(s, 14) 
fmt.Println(len(s), cap(s)) //4 4	cap 足够
s = append(s, 15) 
fmt.Println(len(s), cap(s)) //5 8   创建底层数组 u4（长度8 = u3的两倍），拷贝 u3 元素， array 指向 u4

// 创建map类型变量实例
m := make(map[keyType]valType, capacityhint) → m := runtime.makemap(maptype, capacityhint, m)

// 插入新键值对或给键重新赋值
m["key"] = "value" → v := runtime.mapassign(maptype, m, "key") v是用于后续存储value的空间的地址

// 获取某键的值 
v := m["key"]      → v := runtime.mapaccess1(maptype, m, "key")
v, ok := m["key"]  → v, ok := runtime.mapaccess2(maptype, m, "key")

// 删除某键
delete(m, "key")   → runtime.mapdelete(maptype, m, “key”)

var m map[string]int // m = nil
m["key"] = 1         // 发生运行时异常：panic: assignment to entry in nil map

// 1、使用复合字面值初始化 map 类型变量，
m := map[int]string{}

type Position struct {     
    x float64     
    y float64
}
// Go 允许省略字面值中的元素类型
m2 := map[Position]string{
    Position{29.935523, 52.568915}: "school", // Postion 可省略，如下
    {25.352594, 113.304361}: "shopping-mall",
    {73.224455, 111.804306}: "hospital",
}

// 2、make 函数
m1 := make(map[int]string) // 未指定初始容量
m2 := make(map[int]string, 8) // 指定初始容量为8

// 插入，更新相同
m := make(map[int]string)
m[1] = "value1"
// 查找
v := m["key1"]
v, ok := m["key1"]
if !ok { 
    // "key1"不在map中
}
// 删除
delete(m, "key2") // 删除"key2"
// 遍历，对同一 map 做多次遍历的时候，每次遍历元素的次序都不相同
for k, v := range m { 
    fmt.Printf("[%d, %d] ", k, v) 
}

if condition1 {
	// do something	
} else if condition2 {
	// do something else	
} else {
	// catch-all or default
}

// 多返回值简化
if value, ok := readData(); ok {
    // do something
}

switch var1 {
	case val1:
		...
	case val2:
		...
	default:
		...
}

func checkWorkday(a int) {
    switch a {
    case 1, 2, 3, 4, 5:
        println("it is a work day")
    case 6, 7:
        println("it is a weekend day")
    default:
        println("are you live on earth")
    }
}

//如果需要执行下一个 case 的代码逻辑，可以显式使用 Go 提供的关键字 fallthrough 来实现
switch switchexpr() { 
    case case1(): 
    	println("exec case1") 
    	fallthrough 
    case case2(): 
    	println("exec case2") 
    	fallthrough 
    default: 
    	println("exec default") }

for i := 0; i < 5; i++ {
	fmt.Printf("This is the %d iteration\n", i)
}

for i >= 0 {
	i = i - 1
	fmt.Printf("The variable i is now: %d\n", i)
}

for i, v := range sl {
    fmt.Printf("sl[%d] = %d\n", i, v)
}

func funcName(参数列表) 返回值列表

func foo() // 无返回值
func foo() error // 仅有一个返回值
func foo() (int, string, error) // 有2或2个以上返回值

var dfs func(index int) // 函数类型
dfs = func(index int) {	// 匿名函数，闭包
    // ...
}

func dfs(task string) func() { 
    return func() {  
        // ...
    }
}

time.AfterFunc(time.Second*2, func() { println("timer fired") })

func Greeting(prefix string, who ...string)
Greeting("hello:", "Joe", "Anna", "Eileen")

func getX2AndX3(input int) (int, int) { // 非命名
    return 2 * input, 3 * input
}

func getX2AndX3_2(input int) (x2 int, x3 int) { // 命名
    x2 = 2 * input
    x3 = 3 * input
    // return x2, x3
    return
}

// 关闭文件流
// open a file  
defer file.Close()
// 解锁加锁的资源
mu.Lock()  
defer mu.Unlock()
// 打印最终报告
printHeader()  
defer printFooter()
// 关闭数据库连接
// open a database connection  
defer disconnectFromDB()

func Trace(name string) func() { 
	println("enter:", name) 
	return func() { 
		println("exit:", name) 
	}
}

func foo() { 
    defer Trace("foo")() 
    bar()
}

func bar() { 
    defer Trace("bar")()
}

func main() { 
    defer Trace("main")() 
    foo()
}

type identifier struct {
    field1 type1
    field2 type2
    ...
}

type Person struct { 
    Name string 
    Phone string
    Addr string
}
// 可以无需提供字段的名字，只需要使用其类型就可以了
type Book struct { 
    Title string 
    Person  // 嵌入字段（匿名字段）
}

// 1-struct as a value type:
var pers1 Person
pers1.firstName = "Chris"
pers1.lastName = "Woodward"
upPerson(&pers1)

// 2—struct as a pointer:
pers2 := new(Person)
pers2.firstName = "Chris"
pers2.lastName = "Woodward"
(*pers2).lastName = "Woodward"  // 这是合法的
upPerson(pers2)

// 3—struct as a literal:
pers3 := &Person{"Chris","Woodward"}
upPerson(pers3)

// 更常用：field:value 形式的复合字面值
t := &Timer{ 
    C: c, 
    r: runtimeTimer{ 
        when: when(d), 
    	f: sendTime, 
        arg: c, 
	}, 
}

func (recv receiver_type) methodName(parameter_list) (return_value_list) { ... }

type TwoInts struct {
	a int
	b int
}

func (tn *TwoInts) AddThem() int {
	return tn.a + tn.b
}

func (tn *TwoInts) AddToParam(param int) int {
	return tn.a + tn.b + param
}

type Namer interface {
    Method1(param_list) return_type
    Method2(param_list) return_type
    ...
}

var i interface{} = 15 // ok
i = "hello, golang" // ok
type T struct{}
var t T
i = t  // ok
i = &t // ok

v := varI.(T)       // unchecked type assertion，varI 必须是一个接口变量
if v, ok := varI.(T); ok {  // checked type assertion，一般用这种方法
    Process(v)
    return
}
// varI is not of type 

switch t := areaIntf.(type) {
case *Square:
	fmt.Printf("Type Square %T with value %v\n", t, t)
case *Circle:
	fmt.Printf("Type Circle %T with value %v\n", t, t)
case nil:
	fmt.Printf("nil value: nothing to check?\n")
default:
	fmt.Printf("Unexpected type %T\n", t)
}

func TypeOf(i interface{}) Type
func ValueOf(i interface{}) Value

go fmt.Println("I am a goroutine")
var c = make(chan int)
go func(a, b int) { // 匿名函数/闭包
    c <- a + b
}(3,4) 

// $GOROOT/src/net/http/server.go
c := srv.newConn(rw)
go c.serve(connCtx) // 命名函数/方法

var ch chan int // 声明 int 类型的 channel 类型变量，默认值为 nil

ch1 := make(chan int)  		//无缓冲
ch2 := make(chan int, 5) 	//带缓冲，5是缓冲长度

ch1 := make(chan<- int, 1) // 只发送channel类型
ch2 := make(<-chan int, 1) // 只接收channel类型

ch1 <- 13    // 将整型字面值13发送到无缓冲channel类型变量ch1中
n := <- ch1  // 从无缓冲channel类型变量ch1中接收一个整型值存储到整型变量n中
ch2 <- 17    // 将整型字面值17发送到带缓冲channel类型变量ch2中
m := <- ch2  // 从带缓冲channel类型变量ch2中接收一个整型值存储到整型变量m中

ch2 := make(chan int, 1)
n := <-ch2 // 由于此时ch2的缓冲区中无数据，因此对其进行接收操作将导致goroutine挂起

ch3 := make(chan int, 1)
ch3 <- 17  // 向ch3发送一个整型数17
ch3 <- 27  // 由于此时ch3中缓冲区已满，再向ch3发送数据也将导致goroutine挂起

close(ch)


// 判断是否关闭可以用 c,ok
n := <- ch      // 当ch被关闭后，n将被赋值为ch元素类型的零值
m, ok := <-ch   // 当ch被关闭后，m将被赋值为ch元素类型的零值, ok值为false
for v := range ch { // 当ch被关闭后，for range循环结束
    ... ...
}

select {
case x := <-ch1:     // 从channel ch1接收数据
  ... ...

case y, ok := <-ch2: // 从channel ch2接收数据，并根据ok值判断ch2是否已经关闭
  ... ...

case ch3 <- z:       // 将z值发送到channel ch3中:
  ... ...

default:             // 当上面case中的channel通信均无法实施时，执行该默认分支
}

// 判断前缀
strings.HasPrefix(s, prefix string) bool 
// 判断后缀
strings.HasSuffix(s, suffix string) bool
// 字符串包含
strings.Contains(s, substr string) bool
// 字符串替换
strings.Replace(str, old, new string, n int) string // 替换old的前 n 个字符， n=-1 替换整个 old
// 判断索引（出现位置）
strings.Index(s, str string) int // -1 表示不包含
strings.LastIndex(s, str string) int // 最后出现的位置
strings.IndexRune(s string, r rune) int // 非 ASCII 编码的字符，strings.IndexRune("chicken", 99)
// 出现次数
strings.Count(s, str string) int
// 重复字符串
strings.Repeat(s, count int) string //重复 count 次字符串 s 并返回一个新的字符串
// 大小写转换
strings.ToLower(s) string
strings.ToUpper(s) string
// 修剪
strings.TrimSpace(s) // 剔除开头和结尾的空白符号
strings.Trim(s, "cut") // 剔除开头和结尾指定字符，TrimLeft，TrimRight 只剔除一边
// 分割，返回 slice
strings.Fields(s) // 用一个或多个空白分割，全是空白则返回长度 0 的切片
strings.Split(s, sep) // 用指定字符串 seq 分割
// 拼接
strings.Join(sl []string, sep string) string // seq 为分隔符， sl 为字符串切片
// 例如：strings.Join([]string{"删除：文件夹", path}, " ")

strconv.IntSize // 当前操作系统 int 所占位置
// 整数转字符串
strconv.Itoa(i int) string
// 浮点数转字符串
strconv.FormatFloat(f float64, fmt byte, prec int, bitSize int) string
	// 其中 fmt 表示格式（其值可以是 'b'、'e'、'f' 或 'g'）
	// prec 表示精度，bitSize 则使用 32 表示 float32，用 64 表示 float64
// 字符串转整数
strconv.Atoi(s string) (i int, err error)
// 浮点数转字符串
strconv.ParseFloat(s string, bitSize int) (f float64, err error)

t := time.Now() // 当前时间
t.Day()
t.Minute()
// 标准格式化
t.Format("02 Jan 2006 15:04") // 输出 21 Jul 2011 10:31