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

本文的部分示例代码来源于官方文档以及该课程提供的GitHub仓库
The Go Programming Language Specification - The Go Programming Language
GitHub - wangkechun/go-by-example

接下来就记录一下课程中学到的知识吧！

因为之前学过一点GO基础，所以这里只记录一些没那么熟悉的知识点。

switch

每个case表达式自带break，不需要手动添加

switch(expr){
	case val1:
		...
	case val2:
		...
	default:
		...
}

其中expr可以是任意类型，但不能为无类型常量nil，而在C++中expr只能为整数表达式。
每个case用例不一定是常量，也可以是表达式，而C++中必须是整数常量表达式。
可以用switch对变量进行类型判断，下面是官方的例子：

switch i := x.(type) {
case nil:
	printString("x is nil")                // type of i is type of x (interface{})
case int:
	printInt(i)                            // type of i is int
case float64:
	printFloat64(i)                        // type of i is float64
case func(int) float64:
	printFunction(i)                       // type of i is func(int) float64
case bool, string:
	printString("type is bool or string")  // type of i is type of x (interface{})
default:
	printString("don't know the type")     // type of i is type of x (interface{})
}

课程中的例子：

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:  // case可以是表达式
	fmt.Println("It's before noon")
default:
	fmt.Println("It's after noon")
}

数组与切片

切片实际上指向一个数组。
make 创建切片
append 添加元素返回新元素
append时，当容量足够时，返回的切片指向的数组不变，当容量不足时，返回的切片指向的数组是一个新分配的数组。

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]

map

Go中的map是无序的,不像C++中的map每次遍历都按key元素排序输出，虽然C++的unordered_map也是无序的，但每次遍历unordered_map的顺序是固定的，而遍历GO中的map每次的顺序都可能不一样，原因是因为go每次遍历map的起始索引都是随机的。

m := make(map[string]int)  // 创建一个空的map
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"]  // ok用于判断元素是否存在
fmt.Println(r, ok) // 0 false
delete(m, "one")  // 删除指定key
m2 := map[string]int{"one": 1, "two": 2}
var m3 = map[string]int{"one": 1, "two": 2}
fmt.Println(m2, m3)

range 遍历元素

遍历切片或数组返回索引和索引对应的值遍历map返回key,value

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
}

指针

GO的指针继承自C语言，但是相比较C语言，GO对指针做了大量的限制：

没有指针运算(+、-、++、--)；
数组变量名不是数组首地址；
不能通过指针运算来访问数组元素；

下面通过两段代码来看看GO语言的指针和C/C++指针的区别：

var arr [5]int = [5]int{1, 2, 3, 4, 5}
p := &arr
fmt.Println(*p)

代码执行结果：
[1 2 3 4 5]

int arr[5]{1,2,3,4,5};
int* p=&arr;
std::cout<<*p<<std::endl;

代码执行结果：
1
可以看到go语言对数组取地址得到的指针指向的是整个数组，所以对指针p进行取值操作后进行打印，结果是整个数组。而由于C/C++中的数组名称表示数组首元素的地址，所以可以用数组名称赋给int*指针p，如果想要将指针指向整个数组，则应该将&arr赋给int (*p)[5]

结构体

type user struct{
   name string
}

如何实例化一个结构体实例？
有两种方法：

结构体类型{...}
new(结构体类型)

根据以上1、2两种方式、下面两段代码是等价的：

p:=&user{name:"张三"}

p:=new(user)
*p=user{name:"张三"}

内建函数new
func new(Type) *Type 该函数为指定的类型分配一块内存，并返回指向该内存的指针，分配的内存被初始化为该类型的零值。

结构体方法

结构体方法接收者是指针时，可以修改被调用变量，否则是值传递，不能修改。 结构体方法的模板为：

func 接收者 方法名(参数) 返回值{
	...
}

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
}

错误处理

用到的包

errors

go语言的函数通常会返回多个返回值，而最后一个返回值的类型通常为error，表示函数执行的错误信息。

可以通过errors.New(str)自定义一个error

例子：

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)
    }
}

json处理

用到的包：

encoding/json

常用函数：

func Marshal(v any) ([][byte],error)
将v序列化为json对象
func MarshalIndent(v any, prefix string, indent string) ([][byte]byte，error)
将产生带缩进的json对象，prefix表示每行输出的前缀，indent代表一个缩进
func Unmarshal(data []byte, v any) error
将json对象反序列化为指定的数据类型

type userInfo struct {
    Name  string
    Age   int `json:"age"`
    Hobby []string
}

func main() {
    a := userInfo{Name: "wang", Age: 18, Hobby: []string{"Golang", "TypeScript"}}
    buf, err := json.Marshal(a)
    if err != nil {
        panic(err)
    }
    fmt.Println(buf)         // [123 34 78 97...]
    fmt.Println(string(buf)) // {"Name":"wang","age":18,"Hobby":["Golang","TypeScript"]}
    buf, err = json.MarshalIndent(a, "", "\t")
    if err != nil {
        panic(err)
    }
    fmt.Println(string(buf))
    var b userInfo
    err = json.Unmarshal(buf, &b)
    if err != nil {
        panic(err)
    }
    fmt.Printf("%#v\n", b) // main.userInfo{Name:"wang", Age:18, Hobby:[]string{"Golang", "TypeScript"}}
}

时间处理

用到的包：

time

func Now() Time
返回当前时间
func(t Time) Unix() int64
返回时间戳（秒）
func(t Time) Sub(u Time) Duration
返回时间差
4、func Parse(layout,value string) (Time, error)
格式化时间字符串value
layout表示作为输入的格式的示例，同样的格式规则会被用于输入字符串value。
其中layout的时间是固定的，但格式可以改变，例如:
01-02-2006 15:04:05
2006-01-02 15:04:05

func main() {
    now := time.Now()
    fmt.Println(now) // 2022-03-27 18:04:59.433297 +0800 CST m=+0.000087933
    t := time.Date(2022, 3, 27, 1, 25, 36, 0, time.UTC)
    t2 := time.Date(2022, 3, 27, 2, 30, 36, 0, time.UTC)
    fmt.Println(t)                                                  // 2022-03-27 01:25:36 +0000 UTC
    fmt.Println(t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute()) // 2022 March 27 1 25
    fmt.Println(t.Format("2006-01-02 15:04:05"))                    // 2022-03-27 01:25:36
    diff := t2.Sub(t)
    fmt.Println(diff)                           // 1h5m0s
    fmt.Println(diff.Minutes(), diff.Seconds()) // 65 3900
    t3, err := time.Parse("2006-01-02 15:04:05", "2022-03-27 01:25:36")
    if err != nil {
        panic(err)
    }
    fmt.Println(t3 == t)    // true
    fmt.Println(now.Unix()) // 1648738080
}

数字解析

用到的包：

strconv

func ParseFloat(value,位数）(float64,error)
位数可以是32或64
func ParseInt(value,进制,位数) (i int64, err error)
进制传0表示自动推测
位数可以是0、8、16、32、64，分别表示int、int8、int16、int32、int64
func Atoi(s string) (int,error)
相当于ParseInt(s,10,)

f, _ := strconv.ParseFloat("1.234", 64)
fmt.Println(f) // 1.234
n, _ := strconv.ParseInt("111", 10, 64)
fmt.Println(n) // 111
n, _ = strconv.ParseInt("0x1000", 0, 64)
fmt.Println(n) // 4096
n2, _ := strconv.Atoi("123")
fmt.Println(n2) // 123
n2, err := strconv.Atoi("AAA")
fmt.Println(n2, err) // 0 strconv.Atoi: parsing "AAA": invalid syntax

进程信息

用到的包：

os
os/exec

常用知识点：

获取程序运行的参数
os.Args
该变量是一个字符串数组，第一个元素是程序名称
func Getenv(key string) string
获取指定环境变量
Setenv 设置环境变量，程序退出后失效
func exec.Command(name string, arg... string) *Cmd
执行命令

GO语言基础 | 青训营笔记

switch

数组与切片

map

range 遍历元素

指针

结构体

结构体方法

错误处理

json处理

时间处理

数字解析

进程信息