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

一、本堂课重点内容：

今天的课程主要是介绍Go语言的一些特性以及基础语法（代码示例），并讲解了下面三个实例帮助我们熟悉语法，三个实例难度依次递增，涉及的技术知识也越多。

二、详细知识点介绍：

Go开发环境配置

开发环境有两个选择，使用 VS Code 或者 Goland ，由于之前写C++以及Python都是使用VS Code，所以就不考虑后者了。

1、下载Go安装包 go.dev/ 或者 studygolang.com/dl ，点击安装即可。

2、安装VS Code（已安装），然后安装 Go 插件

然后新建一个 man.go 文件，插件会提示你安装一些插件丢失的工具

点击安装后，终端会输出安装失败信息，此时需要配置 go mod proxy加速访问GitHub，goproxy.cn/ ，自称中国最可靠的 Go 模块代理，打开终端输入以下命令即可(Windows)

go env -w GO111MODULE=on
go env -w GOPROXY=goproxy.cn,direct

3、安装git，安装比较简单，以前装过了，然后直接按提示克隆本节课仓库即可。

4、Hello World，运行如下命令成功，目前基础环境配置结束，更详细的环境管理可见下篇GO语言的工程进阶｜青训营笔记。

语言特性

Go 语言最主要的特性：

自动垃圾回收
更丰富的内置类型
函数多返回值
错误处理
匿名函数和闭包
类型和接口
并发编程
反射
语言交互性

初学着光看这些特性恐怕不会有太多的理解，所以等有一定的技术和知识积累后可以再重新回顾。

第一个go程序

Go语言以“包”作为管理单位，每个 Go 源文件必须先声明它所属的包，所以每个 Go 源文件的开头都是一个 package 声明。 Go语言的包与文件夹是一一对应的，它具有以下几点特性：

一个目录下的同级文件属于同一个包。
包名可以与其目录名不同。
main 包是Go语言程序的入口包，一个Go语言程序必须有且仅有一个 main 包。如果一个程序没有 main 包，那么编译时将会出错，无法生成可执行文件。

package main    // 声明 main 包

import (
    "fmt"       // 导入 fmt 包（标准库），用于打印字符串
)

func main() {   // 声明 main 主函数
    fmt.Println("Hello World!") // 打印 Hello World!
}

基础语法

具体的基础语法，课程分为20个小部分介绍，有大概的印象即，后续使用时需要继续巩固，更详细的语法介绍和实例参考Go圣经。

变量

变量的声明有两种方式：

//方式一
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))

if

go 中的if 还有一种特殊的写法，可以在 if 表达式之前添加一个执行语句，这种写法可以将返回值与判断放在一行进行处理，而且返回值的作用范围被限制在 if、else 语句组合中（局部变量），降低变量冲突风险。

if 7%2 == 0 {  //必须加大括号，且在不同行
    fmt.Println("7 is even")
} else {
    fmt.Println("7 is odd")
}

if num := 9; num < 0 {  //num只在此 if 语句中有效
    fmt.Println(num, "is negative")
} else if num < 10 {
    fmt.Println(num, "has 1 digit")
} else {
    fmt.Println(num, "has multiple digits")
}

for

在go中只有唯一的循环语句for

i := 1
for {
    fmt.Println("loop")
    break  //不加break即死循环
}
for n := 0; n < 5; n++ {
    if n%2 == 0 {
        continue
    }
    fmt.Println(n)
}
for i <= 3 {
    fmt.Println(i)
    i = i + 1
}

switch

switch后的变量可以是任何类型，并且进入某个case分支后，其后的分支默认是不会顺序执行下去（与C语言的不同）。

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 {    //可以代替if else语句
case t.Hour() < 12:
    fmt.Println("It's before noon")
default:
    fmt.Println("It's after noon")
}

数组

数组使用较少，用切片代替

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)

切片（slice）

切片是一个可变长度的数组，可以任意时刻修改长度

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")  //append后赋值回去（因为需要扩容）
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]  ，第2到第5个位置 不包括第5个位置
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

m := make(map[string]int)   //map[keytype]valuetype
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来获取key是否存在
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)

range

nums := []int{2, 3, 4}
sum := 0
for i, num := range nums {  //对于数组，range的返回值有两个：索引+元素值
    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 {  //对于map range返回值：key+value
    fmt.Println(k, v) // b 8; a A
}
for k := range m {
    fmt.Println("key", k) // key a; key b
}

函数

func 函数名(形式参数列表) (返回值列表){    
   函数体  
}

其中返回值列表可省略

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
}

指针

相比C，go中的指针操作有限，主要用于修改传入的参数

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
}

结构体

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
}

结构体方法

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
}

错误处理

import (
    "errors"
    "fmt"
)
type user struct {
    name     string
    password string
}
func findUser(users []user, name string) (v *user, err error) { //返回error类型
    for _, u := range users {
        if u.name == name {
            return &u, nil  //没有错误
        }
    }
    return nil, errors.New("not found")  //返回"not found"错误
}
func main() {
    u, err := findUser([]user{{"wang", "1024"}}, "wang")
    if err != nil {  //检查错误，防止出现u为空指针错误
        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)
    }
}

字符串操作

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

字符串格式化

import "fmt"
type point struct {
    x, y int
}
func main() {
    s := "hello"
    n := 123
    p := point{1, 2}
    fmt.Println(s, n) // hello 123   //打印并换行 ln即line
    fmt.Println(p)    // {1 2}

    fmt.Printf("s=%v\n", s)  // s=hello    //%v可以打印任意类型的变量
    fmt.Printf("n=%v\n", n)  // n=123
    fmt.Printf("p=%v\n", p)  // p={1 2}
    fmt.Printf("p=%+v\n", p) // p={x:1 y:2}  //打印详细结构
    fmt.Printf("p=%#v\n", p) // p=main.point{x:1, y:2}  //打印更详细结构

    f := 3.141592653
    fmt.Println(f)          // 3.141592653
    fmt.Printf("%.2f\n", f) // 3.14   //指定浮点数位数
}

go语言的JSON操作

首先补充什么是JSON，JSON（JavaScript Object Notation）是一种轻量级的数据交换格式。易于人阅读和编写，可以在多种语言之间进行数据交换。比如，JSON 可以将 JavaScript 对象中表示的一组数据转换为字符串，然后就可以在网络或者程序之间轻松地传递这个字符串，并在需要的时候将它还原为各编程语言所支持的数据格式，例如在 PHP 中，可以将 JSON 还原为数组或者一个基本对象。类似的数据交换格式还有XML。

import (
    "encoding/json"
    "fmt"
)
type userInfo struct {
    Name  string
    Age   int `json:"age"`  //添加json的tag 改变字段输出
    Hobby []string
}
func main() {
    a := userInfo{Name: "wang", Age: 18, Hobby: []string{"Golang", "TypeScript"}}
    buf, err := json.Marshal(a)  //序列化结构体变量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)   //反序列化结构体变量buf
    if err != nil {
        panic(err)
    }
    fmt.Printf("%#v\n", b) // main.userInfo{Name:"wang", Age:18, Hobby:[]string{"Golang", "TypeScript"}}
}

go语言里面的JISON操作非常简单，对于一个已有的结构体，我们可以什么都不做，只要保证每个字段的第一个字母是大写，也就是是公开字段。那这个结构体就能使用JSON.marshaler去序列化，变成一个JSON的字符串。
序列化之后的字符串也能够用JSON.unmarshaler去反序列化到一个空的变量里面。这样默认序列化出来的字符串的话，它的风格是大写字母开头，而不是下划线。我们可以在后面用json tag等语法来去修改输出JSON结果里面的字段名。

时间处理

import (
    "fmt"
    "time"
)
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") //作用同t.format 将字符串按格式解析成时间
    if err != nil {
            panic(err)
    }
    fmt.Println(t3 == t)    // true
    fmt.Println(now.Unix()) // 1648738080  时间戳
}

数字解析

import (
    "fmt"
    "strconv"  //string convert
)
func main() {
    f, _ := strconv.ParseFloat("1.234", 64)
    fmt.Println(f) // 1.234

    n, _ := strconv.ParseInt("111", 10, 64)  //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.Args获取命令行参数，其返回值为参数数组，第一个元素为二进制文件的目录+文件名，之后元素依次是各参数，下例中参数数组长度为5.

import (
    "fmt"
    "os"
    "os/exec"
)
func main() {
    // go run example/20-env/main.go a b c d
    fmt.Println(os.Args)           // [/var/folders/8p/n34xxfnx38dg8bv_x8l62t_m0000gn/T/go-build3406981276/b001/exe/main a b c d]
    fmt.Println(os.Getenv("PATH")) // /usr/local/go/bin...  //获取环境变量
    fmt.Println(os.Setenv("AA", "BB"))

    buf, err := exec.Command("grep", "127.0.0.1", "/etc/hosts").CombinedOutput()  //快速启动子进程并且获取输入输出
    if err != nil {
        panic(err)
    }
    fmt.Println(string(buf)) // 127.0.0.1       localhost
}

三、实践练习例子：

见 Go实战案例一

四、课后个人总结：

由于Go语言是在C语言的基础上开发的，所以语法方面倒没有太大的问题，只是需要时间去熟悉罢了，但对一个技术小白来说，实际项目开发中涉及的技术知识盲区是一件头疼的事，也只能一个个去补充学习了。所以对于实例二与实例三需要配合视频讲解慢慢去理解。更详细的Go语法以及特性可参考: Go语言圣经（中文版）和菜鸟Go编程

五、引用参考：

Go语言圣经（中文版）
菜鸟Go编程

技术小白初识GO｜青训营笔记