GO语言基础 | 青训营笔记

398 阅读7分钟

这是我参与「第五届青训营 」笔记创作活动的第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
}

如何实例化一个结构体实例?
有两种方法:

  1. 结构体类型{...}
  2. 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

常用函数:

  1. func Marshal(v any) ([][byte],error)
    将v序列化为json对象
  2. func MarshalIndent(v any, prefix string, indent string) ([][byte]byte,error)
    将产生带缩进的json对象,prefix表示每行输出的前缀,indent代表一个缩进
  3. 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
  1. func Now() Time
    返回当前时间
  2. func(t Time) Unix() int64
    返回时间戳(秒)
  3. 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
  1. func ParseFloat(value,位数)(float64,error)
    位数可以是32或64
  2. func ParseInt(value,进制,位数) (i int64, err error)
    进制传0表示自动推测
    位数可以是0、8、16、32、64,分别表示int、int8、int16、int32、int64
  3. 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

常用知识点:

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