边看春晚边学Go｜青训营笔记

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

Go言语简介

Go言语是Google主导开发的通用性计算机编程言语，Go是具有高性能、高并发特性的编程言语，具有和C++、Java能够比美的性能并且天然支撑高并发。

Go的语法相对简略，学习起来比较简略。别的Go还具有丰厚的规范库、完善的东西链(编译、代码格局化、过错查看、包办理、代码提示、代码测试等)，支撑快速编译、跨渠道、自动垃圾回收等特性。

开发环境

装置Go的开发环境，能够直接参考Go官网进行下载装置，进程比较简略。

运用Go模块代理能够加快Go的依赖下载速度。

Go开发编辑器主要有VSCode和GoLand，这两款编辑器都支撑跨渠道。GoLand相对于初学者来说比较友好，由于我的电脑现已装置VSCode了，所以就没再装置GoLand（收费的而且电脑扛不住）。

根底语法

快速入门

学习一门言语，其时是先“Hello World”一下啦。

package main
import "fmt"
func main() {
    fmt.Println("Hello World")
}

package界说一个包，只有main这个包才能运用go run 或go build直接运转。

import是导入本文件中所需求的包。

main是进口函数，main函数是每一个可履行程序所必须包括的，一般是在发动后第一个履行的函数（假如有init函数，先履行init）。

go运转代码的办法有两种，一种是直接运转，另一种是编译生成可履行文件再运转。

直接运转：go run main.go

编译运转：go build main.go

编译后会生成一个main文件，window上是main.exe，然后直接运转该文件即可。

变量

Go言语变量名由字母、数字、下划线组成，其中首个字符不能为数字。

变量类型包括：字符串、整形、浮点型、布尔型、其他类型(指针、结构体、channel、函数、切片、接口、Map等)。

变量声明

变量在运用前必需求提早声明，能够运用类型揣度或许显现声明类型，声明变量的一般形式是运用 var 关键字。

运用类型揣度时，需求为变量指定值，go会依据值来揣度该变量是什么具体类型。

var str = "我是字符串。"
var num = 1

var 关键字其实也是能够省掉的，不过要把=换成:=。

str := "我是字符串。"
num := 1

运用显现声明变量时，需求在变量后边履行该变量的具体类型，假如声明时不指定具体的值，则会被赋值为默许值。

var str string // str的值为""(空字符串)
var num int    // num的值为0

能够在声明变量的同时给变量进行赋值。

var str string = "我是字符串"
var num int = 1

多个变量在同一行同时声明。

var str1, str2 string = "字符串1", "字符串2"
var num1, num2 int = 1, 2
a, b := 1, 2

常量声明

Go在声明常量时，运用const关键字。常量的值一旦初始化好后就不可更改。

const str string = "我是字符串"
const num int = 1
const a, b = 3, 4
num = 2 // 若更改会报错

流程控制

if句子

Go的if句子和C、C++相似，只不过if后边没有括号，可是加上括号也能正确运转，在IDE中假如在if后边加上括号保存时可能会被直接去掉，别的if后边的开始大括号必须跟if在同一行，不能换行(会报错)。

num1 := 1
num2 := 2
if num1 < num2 {
        fmt.Println("num1 < num2")
} else {
        fmt.Println("num1 >= num2")
}

if句子后边也能够界说变量，但只能用一个分号。也支撑if-else-if句子。

if num1, num2 := 1, 2; num1 < num2 {
    fmt.Println("num1 < num2")
} else if num1 > num2 {
    fmt.Println("num1 < num2")
} else {
    fmt.Println("num1 = num2")
}

for循环

在Go里没有while和do-while循环，只有for循环。Go的for循环包括了for和while的功用。

用for界说死循环，相当于while(true)。

for {
        fmt.Println("loop")
}
for true {
        fmt.Println("loop")
}

用for界说一般的循环，三段式，任何一段都能够省掉，在for循环里也能够运用continue和break来跳出循环。

// 一般for循环
for i := 0; i < 5; i++ {
    fmt.Println(i)
}
// 运用continue
for i := 0; i < 5; i++ {
    if i == 3 {
        continue
    }
    fmt.Println(i)
}
// 运用break
for i := 0; i < 5; i++ {
    if i == 3 {
        break
    }
    fmt.Println(i)
}

用for界说while的功用。

num := 1
for num < 5 {
    fmt.Println(num)
    num++
}

switch

switch句子也和C、C++的switch句子相似，只不过switch后边不需求加括号，case里也不需求加break，Go的switch 默许情况下 case 最后自带 break 句子，匹配成功后就不会履行其他 case，假如咱们需求履行后边的 case，能够运用 fallthrough 。

num := 2
switch num {
case 1:
    fmt.Println("one")
case 2, 3:
    fmt.Println("two or three")
default:
    fmt.Println("other")
}

Go的switch能够匹配恣意类型，也能够实现if-else的功用，在switch后边不加匹配条件，能够在case里进行匹配。

t := time.Now()
switch {
case t.Hour() < 12:
    fmt.Println("It's before noon")
default:
    fmt.Println("It's after noon")
}

数组Array

数组（array）是具有相同唯一类型的一组已编号且长度固定的数据项序列，这种类型能够是恣意的原始类型例如整型、字符串或许自界说类型。

一维数组

数组声明以及拜访如下：

// 声明一个长度为5的数组
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)

上述代码，a为长度为5的数组，为数组的某个元素赋值，能够经过数组下标进行赋值，如a[4] = 100。

也能够经过:=声明并初始化一个数组。

多维数组

多维数组的声明办法和一维数组相似，几维数组就加几个中括号，例如二维数据的声明以及赋值代码如下：

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

切片（slice）与数组的区别是切片的长度不是固定的而是可变的，比数组的用处愈加广泛。

切片声明需求经过make来进行，需求指定切片的类型以及长度，例如下面为创立一个长度为3的string类型的切片。

// 声明一个空切片
s1 := make([]string, 3)
// 声明并初始化
s2 :=[] int {1,2,3,4,5,6}

切片除了长度还有一个容量（capacity）的概念，能够在声明切片的时分同时指定长度和容量。

s := make([]string, 3, 10)

对切片元素的操作，能够像数组一样操作：

s := make([]string, 3)
s[0] = "a"
s[1] = "b"
s[2] = "c"

能够经过append办法向切片中增加元素，因为切片会涉及到扩容，所以需求一个变量来接纳回来值。

s = append(s, "d")
s = append(s, "e", "f")

能够经过copy办法对切片进行复制，复制后是两个独立的切片，更改元素值彼此不影响。

c := make([]string, len(s))
copy(c, s)
fmt.Println(c) // [a b c d e f]

既然是切片，很简略联想到python的切片操作，下面来看下Go的切片功用，与python的切片比较，Go的切片不支撑-1下标。

// 回来下标2到4的值
fmt.Println(s[2:5]) // [c d e]
// 回来下标0到4的值
fmt.Println(s[:5])  // [a b c d e]
// 回来下标2到最后一个元素
fmt.Println(s[2:])  // [c d e f]

调集Map

Map 是一种无序的键(key)值(value)对的调集，也被称为映射、字典。

Map是无序的，支撑相似数组和切片的操作。

Map的声明如下：

m := make(map[string]int)

这行代码是声明了一个键为string类型，值为int类型的空Map。

也能够在声明的同时对其进行初始化操作：

m2 := map[string]int{"one": 1, "two": 2}

对Map的赋值和数组相似经过”下标“进行操作，只不过这个”下标“对应的是key。

m["one"] = 1
m["two"] = 2

对Map元素的拜访，也是经过”下标“来拜访的，假如拜访的key不存在的话会回来0。

fmt.Println(m["one"])    // 1
fmt.Println(m["unknow"]) // 0

对于不存在的key回来0，假如一个key的值也为0，就很简略产生不必要的误解，Go在查询key时回来了两个值，一个是成果，另一个是bool类型的值代表是否存在。

r, ok := m["unknow"]
fmt.Println(r, ok) // 0 false

能够运用delete函数来删去Map中的键值对。

delete(m, "one")

range遍历

数组、切片、Map都能够运用range来遍历，经过range能够得到索引和对应的值。

nums := []int{2, 3, 4}
sum := 0
// 遍历切片
for i, num := range nums {
    fmt.Println("index:", i, "num:", num)
}
// 遍历Map
m := map[string]string{"a": "A", "b": "B"}
for k, v := range m {
    fmt.Println(k, v) // b 8; a A
}
// 只获取key
for k := range m {
    fmt.Println("key", k) // key a; key b
}
// 只获取value
for _, v := range m {
    fmt.Println("value", v) // value A; value B
}

函数

函数界说格局如下：

func function_name( [parameter list] ) [return_types] {
   函数体
}

例如，界说一个两个数相加的函数：

func add(a int, b int) int {
    return a + b
}

Go函数能够回来多个值，一般来说，第一个是函数的回来值，第二个是过错信息。

func exists(m map[string]string, k string) (v string, ok bool) {
    v, ok = m[k]
    return v, ok
}

指针

Go支撑指针，相对于C言语，Go的指针功用十分简略，当然功用也很有限，主要用处便是对函数传入的参数进行修正。

默许情况下，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 和 struct 句子。

type struct_variable_type struct {
   member definition
   ...
   member definition
}

例如，界说一个包括name和password的user结构体：

type user struct {
    name     string
    password string
}

结构体的初始化，能够指定字段初始化，也能够悉数初始化。

a := user{name: "wang", password: "1024"}
b := user{"wang", "1024"}
c := user{name: "wang"}

对于结构体内部成员的拜访能够经过.操作符来进行拜访或赋值。

var d user
d.name = "wang"
d.password = "1024"
fmt.Println(d.password)

结构体办法

结构体办法能够理解为其他言语类的成员函数。

把一个一般办法的func关键字后边加上结构体信息，就代表这个办法是归于结构体的。

为user结构体增加一个查看暗码的函数：

func (u user) checkPassword(password string) bool {
    return u.password == password
}

为user结构体增加一个重置暗码的函数，因为要修正结构体内部的值，所以要运用指针类型：

func (u *user) resetPassword(password string) {
    u.password = password
}

结构体办法的调用：

a := user{name: "wang", password: "1024"}
a.resetPassword("2048")
fmt.Println(a.checkPassword("2048")) // true

过错处理

Go内置的过错接口提供了非常简略的过错处理机制，error类型是一个接口类型，其界说如下：

type error interface {
    Error() string
}

Go函数能够回来多个值，一般函数的最后一个值用来代表过错信息，在函数内部能够运用errors.New 可回来一个过错信息：

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

假如函数不出现过错的话，能够直接回来nil。

在调用函数的时分，需求用多个变量来接纳函数的回来值，咱们能够经过函数的回来值来判别是否发生了异常。

u, err := findUser([]user{{"wang", "1024"}}, "wang")
if err != nil {
    fmt.Println(err)
    return
}

规范库

Go内置了非常丰厚的规范库东西，包括字符串操作、字符串格局化、json处理、时刻处理等。

字符串操作

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

字符串格局化

Println最为常用作用为打印并换行，Printf能够按指定格局打印字符串。

+v能够打印字段和值详细信息。

#v能够打印出整个结构体的构造以及详细信息。

s := "hello"
n := 123
p := point{1, 2}
fmt.Println(s, n) // hello 123
fmt.Println(p)    // {1 2}
fmt.Printf("s=%v\n", s)  // s=hello
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

json处理

Go在处理json时十分简略，只需求将结构体中的字段第一个字母变成大写就能用内置的JSON东西进行处理。

Go中一些特殊的类型，比如Channel、complex、function是不能被解析成JSON的。

Go中JSON目标只支撑string作为key，对于map，那么必须是map[string]T这种类型，T能够是Go言语中恣意的类型。

Go的json处理是经过Marshal、Unmarshal办法来进行处理的。

Marshal 用于自界说编码json的办法，也便是将变量、目标转成json，转换之后需求用string办法强转一下，不然会打印出的是16进制字符串。

Unmarshal用于自界说解码json办法，也便是将json转为目标。

type userInfo struct {
    Name  string
    Age   int `json:"age"` // 自界说json输出的字段
    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"}}

时刻处理

Go提供了许多常用的时刻处理函数，例如Now、解析字符串、转字符串、获取时刻戳等。在操作时刻相关的办法时，需求导入time包。

// 获取当前时刻
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

引用

字节内部课——Go 言语原理与实践

菜鸟教程——Go言语教程

声明：本站所有文章，如无特殊说明或标注，均为本站原创发布。任何个人或组织，在未征得本站同意时，禁止复制、盗用、采集、发布本站内容到任何网站、书籍等各类媒体平台。如若本站内容侵犯了原著者的合法权益，可联系我们进行处理。

边看春晚边学Go｜青训营笔记

Go言语简介

开发环境

根底语法

快速入门

变量

变量声明

常量声明

流程控制

if句子

for循环

switch

数组Array

一维数组

多维数组

切片Slice

调集Map

range遍历

函数

指针

结构体

结构体界说

结构体办法

过错处理

规范库

字符串操作

字符串格局化

json处理

时刻处理

引用

近期文章

近期评论

边看春晚边学Go｜ 青训营笔记

Go言语简介

开发环境

根底语法

快速入门

变量

变量声明

常量声明

流程控制

if句子

for循环

switch

数组Array

一维数组

多维数组

切片Slice

调集Map

range遍历

函数

指针

结构体

结构体界说

结构体办法

过错处理

规范库

字符串操作

字符串格局化

json处理

时刻处理

引用

近期文章

近期评论

边看春晚边学Go｜青训营笔记