这是我参与「第五届青训营 」伴学笔记创作活动的第 1 天

课堂笔记

本堂课重点内容

GO语言的基础知识，相应的数据类型和常用的函数与设计的思想

详细知识点介绍

实践练习例子

Hello world

使用package main表示属于main包的一部分（注意，如果不使用的话会导致报错）

import 导入包（和python类似）

 package main
 ​
 import (
     "fmt"
 )
 ​
 func main() {
     fmt.Println("hello world")
 }
 ​

变量

 package main
 ​
 import (
     "fmt"
     "math"
 )
 ​
 func main() {
 ​
     var a = "initial"
 ​
     var b, c int = 1, 2
 ​
     var d = true
 ​
     var e float64
 ​
     f := float32(e)
 ​
     g := a + "foo"
     fmt.Println(a, b, c, d, e, f) // initial 1 2 true 0 0
     fmt.Println(g)                // initialapple
 ​
     const s string = "constant"
     const h = 500000000
     const i = 3e20 / h
     fmt.Println(s, h, i, math.Sin(h), math.Sin(i))
 }
 ​

GO语言中有多个类型，并且可以根据上下文自动判断类型，当然，其中的常量与c/c++一样，采取const进行声明

if-else

 package main
 ​
 import "fmt"
 ​
 func main() {
 ​
     if 7%2 == 0 {
         fmt.Println("7 is even")
     } else {
         fmt.Println("7 is odd")
     }
 ​
     if 8%4 == 0 {
         fmt.Println("8 is divisible by 4")
     }
 ​
     if num := 9; num < 0 {
         fmt.Println(num, "is negative")
     } else if num < 10 {
         fmt.Println(num, "has 1 digit")
     } else {
         fmt.Println(num, "has multiple digits")
     }
 }
 ​

if-else不用打括号（和python类似）但是必须打大括号进行分割（和java的规范相同）

其中:=操作符可以用于判断相等，注意，GO中没有while

for循环

 package main
 ​
 import "fmt"
 ​
 func main() {
 ​
     i := 1
     for {
         fmt.Println("loop")
         break
     }
     for j := 7; j < 9; j++ {
         fmt.Println(j)
     }
 ​
     for n := 0; n < 5; n++ {
         if n%2 == 0 {
             continue
         }
         fmt.Println(n)
     }
     for i <= 3 {
         fmt.Println(i)
         i = i + 1
     }
 }
 ​

for循环不用打括号（和python类似）但是必须打大括号进行分割（和java的规范相同）

switch语句

 package main
 ​
 import (
     "fmt"
     "time"
 )
 ​
 func main() {
 ​
     a := 2
     switch a {
     case 1:
         fmt.Println("one")
     case 2:
         fmt.Println("two")
     case 3:
         fmt.Println("three")
     case 4, 5:
         fmt.Println("four or five")
     default:
         fmt.Println("other")
     }
 ​
     t := time.Now()
     switch {
     case t.Hour() < 12:
         fmt.Println("It's before noon")
     default:
         fmt.Println("It's after noon")
     }
 }
 ​

注意，此时的switch语句自带break，即匹配一个case后就不会往下面继续匹配了

数组

一个有编号，且长度不变的序列（开发时很少使用）

 package main
 ​
 import "fmt"
 ​
 func main() {
 ​
     var a [5]int
     a[4] = 100
     fmt.Println("get:", a[2])
     fmt.Println("len:", len(a))
 ​
     b := [5]int{1, 2, 3, 4, 5}
     fmt.Println(b)
 ​
     var twoD [2][3]int
     for i := 0; i < 2; i++ {
         for j := 0; j < 3; j++ {
             twoD[i][j] = i + j
         }
     }
     fmt.Println("2d: ", twoD)
 }
 ​

切片

可变长度的数组

 package main
 ​
 import "fmt"
 ​
 func main() {
 ​
     s := make([]string, 3)
     s[0] = "a"
     s[1] = "b"
     s[2] = "c"
     fmt.Println("get:", s[2])   // c
     fmt.Println("len:", len(s)) // 3
 ​
     s = append(s, "d")
     s = append(s, "e", "f")
     fmt.Println(s) // [a b c d e f]
 ​
     c := make([]string, len(s))
     copy(c, s)
     fmt.Println(c) // [a b c d e f]
 ​
     fmt.Println(s[2:5]) // [c d e]
     fmt.Println(s[:5])  // [a b c d e]
     fmt.Println(s[2:])  // [c d e f]
 ​
     good := []string{"g", "o", "o", "d"}
     fmt.Println(good) // [g o o d]
 }
 ​

copy可以将后一个切片的数据完全复制到前一个切片

切片的一个好处是可以进行访问子切片，即s[2:5]，表达s切片中编号为2-5的全部数据

map

键值对，一个key对应一个value

 package main
 ​
 import "fmt"
 ​
 func main() {
     m := make(map[string]int)
     m["one"] = 1
     m["two"] = 2
     fmt.Println(m)           // map[one:1 two:2]
     fmt.Println(len(m))      // 2
     fmt.Println(m["one"])    // 1
     fmt.Println(m["unknow"]) // 0
 ​
     r, ok := m["unknow"]
     fmt.Println(r, ok) // 0 false
 ​
     delete(m, "one")
 ​
     m2 := map[string]int{"one": 1, "two": 2}
     var m3 = map[string]int{"one": 1, "two": 2}
     fmt.Println(m2, m3)
 }
 ​

创建的语法为m:=make(map[key的类型]value的类型)

range

类似python中的range，如果后面跟的是一个数组，那么就是循环遍历这个数组；

如果后面跟的是一个数字，在默认情况下是从0开始，步长为1进行增加

 package main
 ​
 import "fmt"
 ​
 func main() {
     nums := []int{2, 3, 4}
     sum := 0
     for i, num := range nums {
         sum += num
         if num == 2 {
             fmt.Println("index:", i, "num:", num) // index: 0 num: 2
         }
     }
     fmt.Println(sum) // 9
 ​
     m := map[string]string{"a": "A", "b": "B"}
     for k, v := range m {
         fmt.Println(k, v) // b 8; a A
     }
     for k := range m {
         fmt.Println("key", k) // key a; key b
     }
 }
 ​

函数

函数与其他语言相比最大的特点是支持多个返回值

但是如果具有多个返回值，则需要在函数的最后写上返回值的类型

func 函数名(函数参数1 参数类型1，函数参数2 参数类型2)(返回值类型1，返回值类型2){

return 返回值1,返回值2

}

 package main
 ​
 import "fmt"
 ​
 func add(a int, b int) int {
     return a + b
 }
 ​
 func add2(a, b int) int {
     return a + b
 }
 ​
 func exists(m map[string]string, k string) (v string, ok bool) {
     v, ok = m[k]
     return v, ok
 }
 ​
 func main() {
     res := add(1, 2)
     fmt.Println(res) // 3
 ​
     v, ok := exists(map[string]string{"a": "A"}, "a")
     fmt.Println(v, ok) // A True
 }
 ​

指针

与其他语言的指针类似，用于指向某个数据的地址，常用于直接对数据进行操作(因为直接传参的时候，参数不能返回主函数)

 package main
 ​
 import "fmt"
 ​
 func add2(n int) {
     n += 2
 }
 ​
 func add2ptr(n *int) {
     *n += 2
 }
 ​
 func main() {
     n := 5
     add2(n)
     fmt.Println(n) // 5
     add2ptr(&n)
     fmt.Println(n) // 7
 }
 ​

结构体

和c里面的结构体非常类似，用于封装一个抽象的概念，便于进行数据生成以及计算操作，是编程的灵魂

 package main
 ​
 import "fmt"
 ​
 type user struct {
     name     string
     password string
 }
 ​
 func main() {
     a := user{name: "wang", password: "1024"}
     b := user{"wang", "1024"}
     c := user{name: "wang"}
     c.password = "1024"
     var d user
     d.name = "wang"
     d.password = "1024"
 ​
     fmt.Println(a, b, c, d)                 // {wang 1024} {wang 1024} {wang 1024} {wang 1024}
     fmt.Println(checkPassword(a, "haha"))   // false
     fmt.Println(checkPassword2(&a, "haha")) // false
 }
 ​
 func checkPassword(u user, password string) bool {
     return u.password == password
 }
 ​
 func checkPassword2(u *user, password string) bool {
     return u.password == password
 }
 ​

结构体方法

c中的成员函数，用于直接调用结构体中封装的私有的数据，提高了程序的封装性，让结构体有更大的操作空间

 package main
 ​
 import "fmt"
 ​
 type user struct {
     name     string
     password string
 }
 ​
 func (u user) checkPassword(password string) bool {
     return u.password == password
 }
 ​
 func (u *user) resetPassword(password string) {
     u.password = password
 }
 ​
 func main() {
     a := user{name: "wang", password: "1024"}
     a.resetPassword("2048")
     fmt.Println(a.checkPassword("2048")) // true
 }
 ​

错误处理

在函数中添加error，表明这个函数可能会出现错误，通过error的返回值可以在主函数中用简单的if-else语句进行错误的判断以及提示

 package main
 ​
 import (
     "errors"
     "fmt"
 )
 ​
 type user struct {
     name     string
     password string
 }
 ​
 func findUser(users []user, name string) (v *user, err error) {
     for _, u := range users {
         if u.name == name {
             return &u, nil
         }
     }
     return nil, errors.New("not found")
 }
 ​
 func main() {
     u, err := findUser([]user{{"wang", "1024"}}, "wang")
     if err != nil {
         fmt.Println(err)
         return
     }
     fmt.Println(u.name) // wang
 ​
     if u, err := findUser([]user{{"wang", "1024"}}, "li"); err != nil {
         fmt.Println(err) // not found
         return
     } else {
         fmt.Println(u.name)
     }
 }
 ​

字符串操作

以下为字符串操作的函数说明

操作符	操作
Contains（a,b）	判断a中是否包含b（返回值为bool）
Count(a, b)	判断a中包含多少个b的字符（返回值为int）
HasPrefix(a, b)	判断a中是否包含b（返回值为bool）
HasSuffix(a, b)	判断a中是否包含b（返回值为bool）
Index(a,b)	查找b在a中的位置（返回值为int）
Join([]string{a, b}, flag)	用flag连接a和b
Repeat(a, 2)	将a重复两次变为aa
Replace(a, "e", "E", -1)	将a中的字符e变为E，从-1号位置开始进行搜索
ToLower(a)	将a中的字符全小写
ToUpper(a)	将a中的字符全大写

 package main
 ​
 import (
     "fmt"
     "strings"
 )
 ​
 func main() {
     a := "hello"
     fmt.Println(strings.Contains(a, "ll"))                // true
     fmt.Println(strings.Count(a, "l"))                    // 2
     fmt.Println(strings.HasPrefix(a, "he"))               // true
     fmt.Println(strings.HasSuffix(a, "llo"))              // true
     fmt.Println(strings.Index(a, "ll"))                   // 2
     fmt.Println(strings.Join([]string{"he", "llo"}, "-")) // he-llo
     fmt.Println(strings.Repeat(a, 2))                     // hellohello
     fmt.Println(strings.Replace(a, "e", "E", -1))         // hEllo
     fmt.Println(strings.Split("a-b-c", "-"))              // [a b c]
     fmt.Println(strings.ToLower(a))                       // hello
     fmt.Println(strings.ToUpper(a))                       // HELLO
     fmt.Println(len(a))                                   // 5
     b := "你好"
     fmt.Println(len(b)) // 6
 }
 ​

课后个人总结

不容易掌握的知识点

• 函数多个返回值有时候会漏掉
• switch中自带break会导致一些功能无法实现

容易混淆的知识点

• 与其他语言不同的多个返回值容易忘记写返回值的类型导致返回值错误