前言
这是我参与「第三届青训营 -后端场」笔记创作活动的的第1篇笔记，做笔记记录一下自己的学习过程。
此笔记主要内容如下：
- Go语言背景
- Go语言基础语法
- Go语言小项目实战
1 Go语言背景
1.1 什么是Go语言
- 高性能、高并发
- 语法简单、学习曲线平缓
- 丰富的标准库
- 完善的工具链
- 静态链接
- 快速编译
- 跨平台
- 垃圾回收
1.2 为什么选择Go语言
- Go性能比较好
- C++不太适合在线Web业务
- 部署简单、学习成本低
- 内部RPC和HTTP框架的推广
2 Go语言入门
2.1 开发环境
安装Golang
- 访问go官网进行下载安装
- 打不开可以尝试golang中国镜像
- 如果访问Github较慢，配置goproxy，参考goproxy.cn加快下载第三方依赖包
配置集成开发环境
到Goland官网下载安装Goland，可以免费使用30天，学生可以申请认证免费试用。
2.2 基础语法
Hello World
fmt.Println("hello world")
fmt包主要用来输入输出字符串，格式化字符串。
变量
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) // initialfoo
const s string = "constant" //const声明常量，const无明确类型，通过使用上下文来确定类型
if-else
Go的if-else没有括号，后面必须是大括号。
if 7%2 == 0 {
fmt.Println("7 is even")
} else {
fmt.Println("7 is odd")
}
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")
}
循环
Go只有for循环
i := 1
for {
fmt.Println("loop")
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
Go不需要加break，switch可以使用任意变量类型，如字符串、结构体、空等。
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")
}
//甚至可以取代if-else
t := time.Now()
switch {
case t.Hour() < 12:
fmt.Println("It's before noon")
default:
fmt.Println("It's after noon")
}
数组array&切片slice
数组长度是固定的，因此实际业务中使用切片较多。
切片是可变长度的数组，并且支持更丰富的操作。
切片可以用append追加元素，再将append返回的切片重新赋值回去。
//数组
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)
//切片，可以用make创建
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
// 切片用append追加元素
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
在其他编程语言中，map可能也叫哈希或者字典，map是实际使用过程中使用最频繁的数据结构。
Go中的map是无序的，遍历是也不是按插入顺序，是随机的。
//可以用make声明一个空的map
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"] //在获取值时可以加一个ok获取key是否存在
fmt.Println(r, ok) // 0 false
delete(m, "one") //通过delete删除kv对
range
对于slice或者map，可以用range来快速遍历。
//对于数组，range返回两个值，不需要索引可用下划线忽略
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
//对于map，第一个值是key，第二个值是value
m := map[string]string{"a": "A", "b": "B"}
for k, v := range m {
fmt.Println(k, v) // b B; a A
}
for k := range m {
fmt.Println("key", k) // key a; key b
}
函数
Golang变量类型是后置的，并且支持返回多个值。 在实际业务逻辑代码中，几乎所有函数都返回多个值，第一个值是真正的返回结果，第二个值是错误信息。
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 := add2(1, 2)
fmt.Println(res) // 3
v, ok := exists(map[string]string{"a": "A"}, "a")
fmt.Println(v, ok) // A True
}
指针
Golang也支持指针，但是相比C/C++的指针操作十分有限。
Golang的指针常用于对传入参数的值进行修改。
//值传递
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
}
结构体struct
在Go中，可以用结构体名称来初始化变量。
- 对于没有初始化的字段，都会初始化为空值，对于字符串是空字符串，对于数值是0。
- 结构体也可以作为函数参数。
- 用指针作为参数可以实现对结构体的修改，还能避免大结构体拷贝的开销
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
}
错误处理
在Golang中，使用单独的返回值来传递错误信息，可以知道是哪个函数发生错误，并且可以用if-else处理错误，比如在函数返回值中加一个error。
type user struct {
name string
password string
}
//添加err作为错误处理返回值
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") //错误可以用new实现
}
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)
}
}
字符串操作
在Go的strings包中，存在很多对字符串操作的函数。
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 对于中文一个中文可能对应多个字符
}
字符串格式化
在Go字符串格式化中，可用%v打印任意类型的变量，%+v得到更详细的结构，%#v进一步详细。 还可以用%.2f打印保留两位小数的浮点数
type point struct {
x, y int
}
func main() {
s := "hello"
n := 123
p := point{1, 2}
fmt.Println(s, n) // hello 123
fmt.Println(p) // {1 2}
//%v %+v %#v
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}
//%.2f
f := 3.141592653
fmt.Println(f) // 3.141592653
fmt.Printf("%.2f\n", f) // 3.14
}
JSON处理
在Go中，只需要保证结构体每个字段第一个字母是大写，那么该结构体就可以用json.Marshal进行序列化。对于序列化后的字符串，也可以用json.Unmarshal进行反序列化到一个空的变量里面。还可以添加一个json的tag来改变输出的json key值。
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)
if err != nil {
panic(err)
}
//在打印时需要转换为string类型，否则会打印出16进制编码
fmt.Println(buf) // [123 34 78 97...]
fmt.Println(string(buf)) // {"Name":"wang","age":18,"Hobby":["Golang","TypeScript"]}
//MarshalIndent先序列化后格式化
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"}}
}
时间处理
格式化用特定时间2006-01-02 15:04:05，这个时间也可以拿来解析时间。 需要注意的是Go语言中格式化时间模板不是常见的Y-m-d H:M:S， 而是使用Go语言的诞生时间 2006-01-02 15:04:05 -0700 MST。为了记忆方便，按照美式时间格式 月日时分秒年 外加时区 排列起来依次是 01/02 03:04:05PM ‘06 -0700（1234567），刚开始使用时需要注意。
package main
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(), t.Weekday()) // 2022 March 27 1 25 Sunday
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 获取时间戳
}
数字解析
在Golang中，关于数字和字符串之间的转换都在strconv包下。可以用Atoi/Itoa快速将十进制数字和字符串间转换。
package main
import (
"fmt"
"strconv"
)
func main() {
f, _ := strconv.ParseFloat("1.234", 64)
fmt.Println(f) // 1.234
//s base bitSize
n, _ := strconv.ParseInt("111", 10, 64)
fmt.Println(n) // 111
// base 传0表示自动推测进制
n, _ = strconv.ParseInt("0x1000", 0, 64)
fmt.Println(n) // 4096
// Atoi/Itoa
n2, _ := strconv.Atoi("123")
fmt.Println(n2) // 123
s2 := strconv.Itoa(443)
fmt.Println(s2) // "443"
//输入非法会返回错误
n2, err := strconv.Atoi("AAA")
fmt.Println(n2, err) // 0 strconv.Atoi: parsing "AAA": invalid syntax
}
进程信息
在Go中，我们可以用os.Args获取进程在执行时一些命令和参数，第一个参数是可执行文件本身信息，是一个临时目录，后面才是例子中的a b c d参数。
package main
import (
"fmt"
"os"
"os/exec"
)
func main() {
// go run example/20-env/main.go a b c d
//os.Args获取进程在执行时一些命令和参数
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
}
3 实战
3.1 猜数字游戏
3.1.1 猜数字游戏 - 生成随机数
我们这里采用go生成随机数的包"math/rand"，来生成一个的随机数。
Seed uses the provided seed value to initialize the default Source to a deterministic state. If Seed is not called, the generator behaves as if seeded by Seed(1). Seed values that have the same remainder when divided by 2³¹-1 generate the same pseudo-random sequence. Seed, unlike the Rand.Seed method, is safe for concurrent use.
如果不设置随机数种子，默认采用seed=1来初始化，这就是为什么不初始化随机数种子每次生成的随机数会一样。因此，我们采用时间戳来初始化随机数种子，这样就可以保证每次初始化的随机数种子都不一样，就可以确保我们每次生成的随机数都不一样。
3.1.2 猜数字游戏 - 获取用户输入
我们使用fmt.Scanf()来获取用户输入
3.1.3 猜数字游戏 - 实现判断逻辑&游戏循环
注意fmt.Scanf()读取后会在末尾留下一个回车，要加上\n把回车吞掉。
3.1.4 猜数字游戏 - 完整实现
package main
import (
"fmt"
"math/rand"
"time"
)
func main() {
// 生成随机数
maxNum := 100
rand.Seed(time.Now().UnixNano())
secretNumber := rand.Intn(maxNum)
// fmt.Println("The secret number is ", secretNumber)
fmt.Println("Please input your guess")
for {
// 获取用户输入
var guess int
fmt.Scanf("%v\n", &guess)
fmt.Println("You guess is", guess)
// 实现判断逻辑&游戏循环
if guess > secretNumber {
fmt.Println("Your guess is bigger than the secret number. Please try again")
} else if guess < secretNumber {
fmt.Println("Your guess is smaller than the secret number. Please try again")
} else {
fmt.Println("Correct, you Legend!")
break
}
}
}
3.2 在线词典
3.2.1 在线词典 - 抓包 & 发起请求
在翻译网站上打开开发者工具，找到用来查询单词的请求。以火山翻译和彩云翻译为例，这是一个http的POST请求，里面的header比较复杂，但一般都包括你要查询的单词。然后在API返回的字段中有我们需要的翻译信息。由于我们要在Golang中发起这个请求，我们可以右键开发者工具中这个请求，copy as curl(win10中以bash复制)，然后到curlconverter.com/#go 中生成Golang代码。
3.2.2 在线词典 - 生成request body
在Go中，我们可以构造一个与翻译请求所需要的JSON结构一一对应的结构体，然后定义一个结构体变量，再用json.marshal来序列化字符串，来发起HTTP请求。结构体变量初始化就可以获取用户输入到Go中的单词。
3.2.3 在线词典 - 解析response body
在HTTP请求返回的JSON序列字符串中，我们用json.Unmarshal把它反序列化到我们创建的response结构体里面，再将结构体中我们需要的翻译信息输出出来，就实现了我们在线字典的所有功能。当然，我们在浏览器中看到API返回的结构非常复杂，如果要一一定义结构体字段容易出错，我们可以打开oktools.net/json2go ，把json字符串复制进去，得到我们想要的结构体。
3.2.4 在线词典 - 完整实现（火山翻译&彩云翻译）
完整代码过长，仅展示关键代码。
func query(word string) {
start := time.Now()
fmt.Printf("彩云翻译开始时间：%s\n", start)
client := &http.Client{}
/生成request body
request := DictRequest{TransType: "en2zh", Source: word}
buf, err := json.Marshal(request)
if err != nil {
log.Fatal(err)
}
var data = bytes.NewReader(buf)
req, err := http.NewRequest("POST", "https://api.interpreter.caiyunai.com/v1/dict", data)
if err != nil {
log.Fatal(err)
}
resp, err := client.Do(req)
if err != nil {
log.Fatal(err)
}
defer resp.Body.Close()
bodyText, err := ioutil.ReadAll(resp.Body)
if err != nil {
log.Fatal(err)
}
if resp.StatusCode != 200 {
log.Fatal("bad StatusCode:", resp.StatusCode, "body", string(bodyText))
}
// 解析response body
var dictResponse DictResponse
err = json.Unmarshal(bodyText, &dictResponse)
if err != nil {
log.Fatal(err)
}
fmt.Println(word, "UK:", dictResponse.Dictionary.Prons.En, "US:", dictResponse.Dictionary.Prons.EnUs)
for _, item := range dictResponse.Dictionary.Explanations {
fmt.Println(item)
}
cost := time.Since(start)
fmt.Printf("彩云翻译耗时：%s\n", cost)
}
func main() {
if len(os.Args) != 2 {
fmt.Fprintf(os.Stderr, `usage: simpleDict WORD
example: simpleDict hello
`)
os.Exit(1)
}
word := os.Args[1]
query(word)
}
3.2.5 在线词典 - 运行截图
具体耗时视实际情况。
总结
到这里Go语言快速上手-基础语言的学习笔记基本差不多整理完成了（除了socks5代理），由于作者水平有限，如果文中存在错误，还请指正，感谢。
