Go Cheatsheet

This article is also posted on my blog, feel free to check the latest revision: Go Cheatsheet
  syntax

• The uppercase of the first letter of const, var, func, type is exported. And the lowercase is private.
  
• The { cannot be as a separate line.
  
• Not need to use ; to end the statement.(Not recommend)
  
• // or /* */ can be used to comment.
  
• the string can be connected by +
  
• fmt.Printf is used to print the string format.
  

dependency

go get

1. go env
2. # GOROOT='/usr/local/go' // the standard library
3. # GOPATH='/Users/username/go' // the project lib or three-party lib

复制代码

go get will download the three-party lib to the GOPATH/src directory. The go search GOROOT first, then search GOPATH. But the denpendency only can keep one version, which will cause some conflict.
go vendor

Save all the denpendency in the vendor directory of the project, which make the project more redundant. The go will search the vendor first. This still cannot solve the problem of version.
go module

It was introduced in go1.11, which can manage the denpendency more flexibly.

• go mod init first initialize the project denpendency.
  
• go mod tidy write the using denpendency to the go.mod file and remove the unused denpendency in the file.
  
• go mod download or go build or go test, the three-party lib will be downloaded to the GOPATH/pkg/mod directory.
  

indirect means the sub-denpendency.
+incompatible means compatible with the old version without the go.mod file.
If the project different package needs the same denpendency’s different version, it will choose the minimum compatible version.
denpendency distribution

Normally use the GOPROXY='https://proxy.golang.org,direct' search the proxy first, if not found, then search the original source.
data type

• Int float..: default is 0
  
• String: default is ""
  
• Bool: default is false
  

Below are all nil.

1. var a *int
2. var a []int
3. var a map[string] int
4. var a chan int
5. var a func(string) int
6. var a error

复制代码

var

1. // case1
2. var identifier1, identifier2 type
4. // usually used in global variable
5. var (
6.     vname1 v_type1
7.     vname2 v_type2
8. )
10. // case2 only can be used in function
11. intVal := 1 // you cannot declare the variable twice
12. // which is equivalent to var intVal int = 1
13. var intVal int
14. intVal =1
16. // case3 auto
17. var v1name, v2name = value1, value2

复制代码

The int, float, bool and string are basic value type, using these types of variables directly save the value in memory, if use such as i = j, then actually copy the value of j to i in memory. &i is used to get the address of i in memory. When the i is local variable, the address is in the stack, when the i is global variable, the address is in the heap.
The complex type is a pointer, slice, map, channel, function, interface, struct, they are usually used as reference type. The reference type usually save the address of the value in memory, if use such as i = j, then actually copy the address of j to i in memory. So if j changes reference value, i will also change.
You cannot declare a var but not use it in function. Except the global variable.
You can use a, b = b, a to swap the value of a and b.(Must be the same type)
Use _ to drop value, such as _, b = a, b
const

1. // type only boolen, string, number
2. const identifier [type] = value

复制代码

You can use the build-in function to operate the const.

1. import "unsafe"
2. const (
3.     a = "abc"
4.     b = len(a)
5.     c = unsafe.Sizeof(a)
6. )

复制代码

iota

special const, default is 0, every time add one const, the iota will add one.
And in the const block, if you don’t assign the value obviously, it will inherit the last value.

1. func main() {
2.     const (
3.             a = iota   //0
4.             b          //1
5.             c          //2
6.             d = "ha"   //"ha" iota += 1
7.             e          //"ha" iota += 1
8.             f = 100    //100 iota +=1
9.             g          //100 iota +=1
10.             h = iota   //7
11.             i          //8
12.     )
13. }

复制代码

operator

&: get the address of the variable.

• pointer variable: get the value of the address.
  

1. package main
3. import "fmt"
5. func main() {
6.    var a int = 4
7.    var b int32
8.    var c float32
9.    var ptr *int
11.    ptr = &a
12.    fmt.Printf("a is %d\n", a); // a is 4
13.    fmt.Printf("*ptr is %d\n", *ptr); // *ptr is 4
14. }

复制代码

if

1.         if num := 9; num < 0 {
2.                 fmt.Println(num, "is negative")
3.         } else if num < 10 {
4.                 fmt.Println(num, "has 1 digit")
5.         } else {
6.                 fmt.Println(num, "has multiple digits")
7.         }

复制代码

switch

1. switch var1 {
2. case val1:
3.   // do something
4. case val2:
5.   // do something
6. default:
7.   // do something
8. }
10. switch x.(type){
11.     case type:
12.        statement(s);      
13.     case type:
14.        statement(s);
15.     default: // optional
16.        statement(s);
17. }
19. // the fallthrough will execute the next case forcefully.
21. func main() {
23.     switch {
24.     case false:
25.             fmt.Println("1")
26.             fallthrough
27.     case true:
28.             fmt.Println("2")
29.             fallthrough
30.     case false:
31.             fmt.Println("3")
32.             fallthrough
33.     case true:
34.             fmt.Println("4")
35.     case false:
36.             fmt.Println("5")
37.             fallthrough
38.     default:
39.             fmt.Println("6")
40.     }
41. }
42. // 2 3 4

复制代码

select

select only can be used in channel, each case must be a channel operation, either send or receive.

1. select {
2. case <-ch1:
3.   // do something
4. case value := <- channel2:
5.   // do something
6. case channel3 <- value:
7.   // do something
8. default:
9.   // do something
10. }

复制代码

select statement will listen to all the channel operations, once one channel is ready, then execute the corresponding code block. If multiple channels are ready, then the select statement will randomly select one channel to execute. If all channels are not ready, then execute the code in the default block. if there is no default, select will block until one channel is ready. Go will not re-evaluate the channel or value.
for

1.         for n := 0; n < 5; n++ {
2.                 if n%2 == 0 {
3.                         continue
4.                 }
5.                 fmt.Println(n)
6.         }
7.   // infinite loop
8.   for {
9.                 fmt.Println("loop")
10.                 break
11.         }

复制代码

array

It is fixed length, which is not common used.

1.         var twoD [2][3]int
2.         for i := 0; i < 2; i++ {
3.                 for j := 0; j < 3; j++ {
4.                         twoD[i][j] = i + j
5.                 }
6.         }

复制代码

slice

1. func main() {
3.         s := make([]string, 3)
4.         s[0] = "a"
5.         s[1] = "b"
6.         s[2] = "c"
7.         fmt.Println("get:", s[2])   // c
8.         fmt.Println("len:", len(s)) // 3
10.         s = append(s, "d") // must be received back
11.         s = append(s, "e", "f")
12.         fmt.Println(s) // [a b c d e f]
14.         c := make([]string, len(s))
15.         copy(c, s)
16.         fmt.Println(c) // [a b c d e f]
18.         fmt.Println(s[2:5]) // [c d e]
19.         fmt.Println(s[:5])  // [a b c d e]
20.         fmt.Println(s[2:])  // [c d e f]
22.         good := []string{"g", "o", "o", "d"}
23.         fmt.Println(good) // [g o o d]
24. }

复制代码

map

1. func main() {
2.         m := make(map[string]int)
3.         m["one"] = 1
4.         m["two"] = 2
5.         fmt.Println(m)           // map[one:1 two:2]
6.         fmt.Println(len(m))      // 2
7.         fmt.Println(m["one"])    // 1
8.         fmt.Println(m["unknow"]) // 0
10.         r, ok := m["unknow"]
11.         fmt.Println(r, ok) // 0 false
13.         delete(m, "one")
15.         m2 := map[string]int{"one": 1, "two": 2}
16.         var m3 = map[string]int{"one": 1, "two": 2}
17.         fmt.Println(m2, m3)
18. }

复制代码

range

1. func main() {
2.         nums := []int{2, 3, 4}
3.         sum := 0
4.         for i, num := range nums {
5.                 sum += num
6.                 if num == 2 {
7.                         fmt.Println("index:", i, "num:", num) // index: 0 num: 2
8.                 }
9.         }
10.         fmt.Println(sum) // 9
12.         m := map[string]string{"a": "A", "b": "B"}
13.         for k, v := range m {
14.                 fmt.Println(k, v) // b 8; a A
15.         }
16.         for k := range m {
17.                 fmt.Println("key", k) // key a; key b
18.         }
19. }

复制代码

func

• not support nested
  
• not support overload
  
• not support default parameter
  
• return can only be received by multiple values x, _  cannot use a container to receive
  

1. // func name(parameter-list) (return-list)
2. func add(a int, b int) int {
3.         return a + b
4. }
6. func add2(a, b int) int {
7.         return a + b
8. }
10. func exists(m map[string]string, k string) (v string, ok bool) {
11.         v, ok = m[k]
12.         return v, ok
13. }
15. func main() {
16.         res := add(1, 2)
17.         fmt.Println(res) // 3
19.         v, ok := exists(map[string]string{"a": "A"}, "a")
20.         fmt.Println(v, ok) // A True
21. }

复制代码

1.   func myfunc(args ...interface{}) { // pass any type of parameter
2.   }
4.   func add(a int, b int, args…int) int {    //2 parameters or more
5.     // the args is a slice you can use it via args[index]
6.   }
8.   //eg.
9.   func test(s string, n ...int) string {
10.     var x int
11.     for _, i := range n {
12.         x += i
13.       }
15.       return fmt.Sprintf(s, x)
16.   }
18.   func main() {
19.       s := []int{1, 2, 3}
20.       res := test("sum: %d", s...)    // slice... (expand slice)
21.       println(res)
22.   }

复制代码

lambda function

In go, the lambda function is a closure.

1.   getSqrt := func(a float64) float64 {
2.       return math.Sqrt(a)
3.   }
4.   fmt.Println(getSqrt(4))

复制代码

The function is a first-class citizen in the language. Generally, a function returns another function, which can reference the local variables of the outer function, forming a closure.
Usually, a closure is implemented through a structure, which stores a function and an associated context environment. But in Go, the anonymous function is a closure, which can directly reference the local variables of the outer function.
closure

1. package main
3. import "fmt"
5. func add(base int) func(int) int {
6.     return func(i int) int {
7.         base += i
8.         return base
9.     }
10. }
12. func main() {
13.     tmp1 := add(10) // base is 10;
14.     // tmp1 is returned func(i)
15.     // in fact the tmp1 is a `FuncVal` object, FuncVal { func_address, closure_var_pointer ... } which contains:
16.     // 1. the anonymous function address
17.     // 2. the closure object pointer, which points to the closure object that contains the required external variables.
18.     // the function call usually involves passing parameters to the function and jumping to the function's entry address for execution.
19.     // **then FuncVal object is obtained, and the anonymous function address and the closure object pointer are obtained**, completing the function call and correctly accessing the required external variables.
20.     // the closure is indirectly expanded the life cycle of function.
21.     fmt.Println(tmp1(1), tmp1(2)) // 11 13
22.     // this tmp2 is a new entity
23.     tmp2 := add(100)
24.     fmt.Println(tmp2(1), tmp2(2)) // 101 103
25. }

复制代码

defer

• The keyword defer is used to register a deferred call.
  
• These calls are executed just before the return. Therefore, it can be used for resource cleanup.
  
• Multiple defer statements are executed in a FILO manner. Even if is a panic.
  
• The variables in the defer statement are determined when the defer statement is declared.
  

Often used in:

• Close file handle
  
• Release lock resource
  
• Release database connection
  

1. // defer in closure
2. package main
4. import "fmt"
6. func main() {
7.     var whatever [5]struct{}
8.     for i := range whatever {
9.         defer func() { fmt.Println(i) }()
10.     }
11. }

复制代码

  Each time a “defer” statement executes, the function value and parameters to the call are evaluated as usualand saved anew but the actual function is not invoked.

1. package main
3. func test() {
4.     x, y := 10, 20
6.     defer func(i int) {
7.         println("defer:", i, y) // y is a closure reference, will be executed until the test function return
8.     }(x) // (x) means calling the function right now, x is copied to i, but the function is deferred, so it will be executed after the test function return
10.     x += 10
11.     y += 100
12.     println("x =", x, "y =", y)
13. }
15. func main() {
16.     test()
17. }
19. // x = 20 y = 120
20. // defer: 10 120

复制代码

pointer

1. func add2(n int) {
2.         n += 2
3. }
5. func add2ptr(n *int) {
6.         *n += 2
7. }
9. func main() {
10.         n := 5
11.         add2(n)
12.         fmt.Println(n) // 5
13.         add2ptr(&n)
14.         fmt.Println(n) // 7
15. }

复制代码

struct

1. type user struct {
2.         name     string
3.         password string
4. }
6. func main() {
7.   // 1
8.         a := user{name: "wang", password: "1024"}
9.   // 2
10.         b := user{"wang", "1024"}
11.   // 3
12.         c := user{name: "wang"}
13.         c.password = "1024"
14.   // 4
15.         var d user
16.         d.name = "wang"
17.         d.password = "1024"
19.         fmt.Println(a, b, c, d)                 // {wang 1024} {wang 1024} {wang 1024} {wang 1024}
20.         fmt.Println(checkPassword(a, "haha"))   // false
21.         fmt.Println(checkPassword2(&a, "haha")) // false
22. }
24. func checkPassword(u user, password string) bool {
25.         return u.password == password
26. }
27. // if use pointer, you can make some changes and avoid some big structure cost
28. func checkPassword2(u *user, password string) bool {
29.         return u.password == password
30. }
32. // the structure method
33. func (u user) checkPassword(password string) bool {
34.         return u.password == password
35. }
36. // You can change the value via pointer
37. func (u *user) resetPassword(password string) {
38.         u.password = password
39. }
41. func main() {
42.         a := user{name: "wang", password: "1024"}
43.         a.resetPassword("2048")
44.         fmt.Println(a.checkPassword("2048")) // true
45. }

复制代码

exception

panic throw the error, recover catch the error.

1. func main() {
2.     defer func() {
3.         if err := recover(); err != nil {
4.             fmt.Println(err)
5.         }
6.     }()
8.     var ch chan int = make(chan int, 10)
9.     close(ch)
10.     ch <- 1
11. }
12. // send on closed channel

复制代码

error

Besides, panic causes a fatal system error, and can also return an error object to represent the status of the function call.

1. import (
2.         "errors"
3.         "fmt"
4. )
6. type user struct {
7.         name     string
8.         password string
9. }
11. func findUser(users []user, name string) (v *user, err error) {
12.         for _, u := range users {
13.                 if u.name == name {
14.                         return &u, nil
15.                 }
16.         }
17.         return nil, errors.New("not found")
18. }
20. func main() {
21.         if u, err := findUser([]user{{"wang", "1024"}}, "li"); err != nil {
22.                 fmt.Println(err) // not found
23.                 return
24.         } else {
25.                 fmt.Println(u.name)
26.         }
27. }

复制代码

string

1. import (
2.         "fmt"
3.         "strings"
4. )
6. func main() {
7.         a := "hello"
8.         fmt.Println(strings.Contains(a, "ll"))                // true
9.         fmt.Println(strings.Count(a, "l"))                    // 2
10.         fmt.Println(strings.HasPrefix(a, "he"))               // true
11.         fmt.Println(strings.HasSuffix(a, "llo"))              // true
12.         fmt.Println(strings.Index(a, "ll"))                   // 2
13.         fmt.Println(strings.Join([]string{"he", "llo"}, "-")) // he-llo
14.         fmt.Println(strings.Repeat(a, 2))                     // hellohello
15.         fmt.Println(strings.Replace(a, "e", "E", -1))         // hEllo
16.         fmt.Println(strings.Split("a-b-c", "-"))              // [a b c]
17.         fmt.Println(strings.ToLower(a))                       // hello
18.         fmt.Println(strings.ToUpper(a))                       // HELLO
19.         fmt.Println(len(a))                                   // 5
20.         b := "你好"
21.         fmt.Println(len(b)) // 6
22. }

复制代码

fmt

1. type point struct {
2.         x, y int
3. }
5. func main() {
6.         s := "hello"
7.         n := 123
8.         p := point{1, 2}
9.   // %v: value
10.         fmt.Printf("s=%v\n", s)  // s=hello
11.         fmt.Printf("n=%v\n", n)  // n=123
12.         fmt.Printf("p=%v\n", p)  // p={1 2}
13.   // %+v: value with field name
14.         fmt.Printf("p=%+v\n", p) // p={x:1 y:2}
15.   // more detail
16.         fmt.Printf("p=%#v\n", p) // p=main.point{x:1, y:2}
18.         f := 3.141592653
19.         fmt.Println(f)          // 3.141592653
20.         fmt.Printf("%.2f\n", f) // 3.14
21. }

复制代码

json

1. import (
2.         "encoding/json"
3.         "fmt"
4. )
6. type userInfo struct {
7.   // you should make sure the uppercase of field name
8.         Name  string
9.         Age   int `json:"age"`
10.         Hobby []string
11. }
13. func main() {
14.         a := userInfo{Name: "wang", Age: 18, Hobby: []string{"Golang", "TypeScript"}}
15.   // Marshal: convert struct to json
16.         buf, err := json.Marshal(a)
17.         if err != nil {
18.                 panic(err)
19.         }
20.   // hex code
21.         fmt.Println(buf)         // [123 34 78 97...]
22.   // convert to string
23.         fmt.Println(string(buf)) // {"Name":"wang","age":18,"Hobby":["Golang","TypeScript"]}
25.         buf, err = json.MarshalIndent(a, "", "\t")
26.         if err != nil {
27.                 panic(err)
28.         }
29.         fmt.Println(string(buf))
31.         var b userInfo
32.         err = json.Unmarshal(buf, &b)
33.         if err != nil {
34.                 panic(err)
35.         }
36.         fmt.Printf("%#v\n", b) // main.userInfo{Name:"wang", Age:18, Hobby:[]string{"Golang", "TypeScript"}}
37. }

复制代码

time

1. import (
2.         "fmt"
3.         "time"
4. )
6. func main() {
7.         now := time.Now()
8.         fmt.Println(now) // 2022-03-27 18:04:59.433297 +0800 CST m=+0.000087933
9.         t := time.Date(2022, 3, 27, 1, 25, 36, 0, time.UTC)
10.         t2 := time.Date(2022, 3, 27, 2, 30, 36, 0, time.UTC)
11.         fmt.Println(t)                                                  // 2022-03-27 01:25:36 +0000 UTC
12.         fmt.Println(t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute()) // 2022 March 27 1 25
13.         fmt.Println(t.Format("2006-01-02 15:04:05"))                    // 2022-03-27 01:25:36
14.         diff := t2.Sub(t)
15.         fmt.Println(diff)                           // 1h5m0s
16.         fmt.Println(diff.Minutes(), diff.Seconds()) // 65 3900
17.         t3, err := time.Parse("2006-01-02 15:04:05", "2022-03-27 01:25:36")
18.         if err != nil {
19.                 panic(err)
20.         }
21.         fmt.Println(t3 == t)    // true
22.         fmt.Println(now.Unix()) // 1648738080
23. }

复制代码

strconv

1. import (
2.         "fmt"
3.         "strconv"
4. )
6. func main() {
7.         f, _ := strconv.ParseFloat("1.234", 64)
8.         fmt.Println(f) // 1.234
9.   // str base precision
10.         n, _ := strconv.ParseInt("111", 10, 64)
11.         fmt.Println(n) // 111
13.         n, _ = strconv.ParseInt("0x1000", 0, 64)
14.         fmt.Println(n) // 4096
15.   // convert quickly
16.         n2, _ := strconv.Atoi("123")
17.         fmt.Println(n2) // 123
19.         n2, err := strconv.Atoi("AAA") // invalid
20.         fmt.Println(n2, err) // 0 strconv.Atoi: parsing "AAA": invalid syntax
21. }

复制代码

os

1. import (
2.         "fmt"
3.         "os"
4.         "os/exec"
5. )
7. func main() {
8.         // go run example/20-env/main.go a b c d
9.         fmt.Println(os.Args)           // [/var/folders/8p/n34xxfnx38dg8bv_x8l62t_m0000gn/T/go-build3406981276/b001/exe/main a b c d]
10.         fmt.Println(os.Getenv("PATH")) // /usr/local/go/bin...
11.         fmt.Println(os.Setenv("AA", "BB"))
13.         buf, err := exec.Command("grep", "127.0.0.1", "/etc/hosts").CombinedOutput()
14.         if err != nil {
15.                 panic(err)
16.         }
17.         fmt.Println(string(buf)) // 127.0.0.1       localhost
18. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。