这是我参与「第三届青训营 -后端场」笔记创作活动的第1篇笔记
一、简介
1.1 什么是Go语言
- 高性能、高并发
- 语法简单、学习曲线平缓
- 丰富的标准库
- 完善的工具链
- 静态链接
- 快速编译
- 跨平台
- 垃圾回收
1.2 哪些公司在使用Go语言
腾讯、百度、美团、滴滴、深信服、平安、OPPO、知乎、去哪儿、360、金山、微博、哔哩哔哩、七牛、PingCAP
1.3 字节为什么全面拥抱Go语言
最初使用的Python,由于性能问题换成了Go,C++不太适合在线Web业务.早期团队非Java背景,性能比较好,部署简单、学习成本低,内部RPC和HTTP框架的推广
二、开发环境
2.1 下载安装包
Go安装包下载地址 Mac M1版直接下载安装即可
安装完成后,输入go version 查看是否安装完成.
2.2 配置
配置网址https://goproxy.cn/
# 启动包管理
go env -w GO111MODULE=on
# 配置依赖包国内源
go env -w GOPROXY=https://goproxy.cn,direct
# 配置go的工程根目录 最好在这个位置的src下构建工程
go env -w GOPATH=/Users/zhuzz/go
# 检查
go env
配置的GOPATH是工程目录,其中src用来存放源代码,pkg用来存放编译后生成的文件,bin用来存放生成的可执行文件
2.3 HelloWorld
使用vscode打开/Users/zhuzz/go/src/,在这个下面创建一个项目,编写一个helloworld.go,这个时候vscode会安装提醒,直接全部安装(安装的内容会保存到/Users/zhuzz/go/bin)
在当前目录下,执行go mod init生成一个.mod文件,执行go run helloworld.go运行,执行go build进行编译
/*
* @Description:
* @Author: zhuzhongzheng
* @Date: 2022-05-18 00:11:02
* @LastEditors: zhuzhongzheng
* @LastEditTime: 2022-05-18 16:53:32
*/
// 说明这个文件属于main包的一部分,main包是程序的入口包
package main
// 导入fmt包
// fmt包是用来往屏幕输入输出字符串、格式化字符串的
import "fmt"
func main() {
fmt.Println("Hello World!")
}
// 通过go run helloworld.go 来运行
// 通过go build进行编译
// 可以通过https://pkg.go.dev/ + 包名 来看文档
2.4 vscode调试
设置debug的launch.json文件
{
"version": "0.2.0",
"configurations": [
{
"name": "Launch Go",
"type": "go",
"request": "launch",
"mode": "auto",
"program": "${fileDirname}",
"env": {
"GOPATH": "/Users/zhuzz/go",
"GOROOT": "/opt/homebrew/Cellar/go/1.18/libexec"
}
}
]
}
三、基本语法
3.1 变量
go是一门强类型语言,每一个变量都有它自己的变量类型.在go语言里变量的声明有两种方式:一种是通过var name string = "",一种是通过变量 := 值.如果没有声明变量的类型,会自动推导变量的类型.
go语言中的常量通过const修饰,它没有明确的类型,会根据使用的上下文来自动确定类型.
/*
* @Description:变量
* @Author: zhuzhongzheng
* @Date: 2022-05-18 19:48:46
* @LastEditors: zhuzhongzheng
* @LastEditTime: 2022-05-18 19:53:04
*/
package main
import (
"fmt"
"math"
)
func main() {
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)
fmt.Println(g)
const s string = "constant"
const h = 50000
const i = 3e20 / h
fmt.Println(s, h, i, math.Sin(h), math.Sin(i))
}
3.2 if-else
go语言的if后面没有括号,后面必须有{}.
/*
* @Description:
* @Author: zhuzhongzheng
* @Date: 2022-05-18 20:00:54
* @LastEditors: zhuzhongzheng
* @LastEditTime: 2022-05-18 20:04:07
*/
package main
import "fmt"
func main() {
if 7%2 == 0 {
fmt.Println("7 is even")
} else {
fmt.Println("7 is odd")
}
if 8%4 == 0 {
fmt.Println("8 is divisible by 4")
}
if num := 9; num < 0 {
fmt.Println(num, "negative")
} else if num < 10 {
fmt.Println(num, "has 1 digit")
} else {
fmt.Println(num, "has multiple digits")
}
}
3.3 for
在go语言里面,没有while和do while循环,只有唯一的一种for循环.最简单的for循环后面什么都不写,代表一个死循环.
/*
* @Description:
* @Author: zhuzhongzheng
* @Date: 2022-05-18 20:07:30
* @LastEditors: zhuzhongzheng
* @LastEditTime: 2022-05-18 20:09:38
*/
package main
import "fmt"
func main() {
i := 1
for {
fmt.Println("loop")
break
}
for j := 7; j < 9; j++ {
fmt.Println(j)
}
for n := 0; n < 5; n++ {
if n%2 == 0 {
continue
}
fmt.Println(n)
}
for i <= 3 {
fmt.Println(i)
i = i + 1
}
}
3.4 switch
go语言中的switch不需要加break,并且swicth的功能更加强大,可以使用任意的变量类型,甚至可以用来取代任意的if else语句,也可以在swicth后面不加任何的变量,然后在case里面写条件分支.
/*
* @Description:
* @Author: zhuzhongzheng
* @Date: 2022-05-18 21:58:48
* @LastEditors: zhuzhongzheng
* @LastEditTime: 2022-05-18 22:12:10
*/
package main
import (
"fmt"
"time"
)
func main() {
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("It's after noon")
}
t := time.Now()
switch {
case t.Hour() < 12:
fmt.Printf("It's before noon")
default:
fmt.Println("It's after noon")
}
}
3.5 数组
在真实业务代码里,很少直接使用数组,因为长度是固定的,更多的是使用切片.
/*
* @Description:
* @Author: zhuzhongzheng
* @Date: 2022-05-18 22:15:37
* @LastEditors: zhuzhongzheng
* @LastEditTime: 2022-05-18 22:19:52
*/
package main
import "fmt"
func main() {
var a [5]int
a[4] = 100
fmt.Println(a[4], 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)
}
3.6 切片
切片不同于数组可以任意更改长度,然后也有更多丰富的操作,可以使用make来创建一个切片,使append来追加元素.
/*
* @Description:
* @Author: zhuzhongzheng
* @Date: 2022-05-18 22:25:38
* @LastEditors: zhuzhongzheng
* @LastEditTime: 2022-05-18 22:33:48
*/
package main
import "fmt"
func main() {
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)
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:])
good := []string{"g", "o", "o", "d"}
fmt.Println(good)
}
3.7 Map
go语言中使用make来创建一个空map,这里需要两个类型,第一个是key的类型,第二个是value的类型,通过delete删除键值对,map是无序的.
/*
* @Description:
* @Author: zhuzhongzheng
* @Date: 2022-05-18 22:36:38
* @LastEditors: zhuzhongzheng
* @LastEditTime: 2022-05-18 22:40:35
*/
package main
import "fmt"
func main() {
m := make(map[string]int) // string是key的类型,int是value的类型
m["one"] = 1
m["two"] = 2
fmt.Println(m)
fmt.Println(m["one"])
fmt.Println(m["unknow"])
r, ok := m["unknow"]
fmt.Println(r, ok)
delete(m, "one")
m2 := map[string]int{"one": 1, "two": 2}
var m3 = map[string]int{"one": 1, "two": 2}
fmt.Println(m2, m3)
}
3.8 range
可以使用range来快速遍历
/*
* @Description:
* @Author: zhuzhongzheng
* @Date: 2022-05-18 22:42:41
* @LastEditors: zhuzhongzheng
* @LastEditTime: 2022-05-18 22:48:45
*/
package main
import "fmt"
func main() {
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", "c": "C"}
for k, v := range m { // 对于map,range会返回两个值,第一个是key,第二个是value map随机返回
fmt.Println(k, v)
}
for k := range m {
fmt.Println("key:", k)
}
}
3.9 函数
go语言中的变量类型是后置的,函数支持返回多个值,一般实际业务中,函数都会返回两个值,第一个是真正的结果,第二个值是错误信息.
/*
* @Description:
* @Author: zhuzhongzheng
* @Date: 2022-05-18 22:52:04
* @LastEditors: zhuzhongzheng
* @LastEditTime: 2022-05-18 22:58:59
*/
package main
import "fmt"
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
}
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
}
3.10 指针
go支持指针,主要用途是对于传入参数进行修改.
/*
* @Description:
* @Author: zhuzhongzheng
* @Date: 2022-05-18 23:02:41
* @LastEditors: zhuzhongzheng
* @LastEditTime: 2022-05-18 23:04:06
*/
package main
import "fmt"
func main() {
n := 5
add(&n)
fmt.Println(n)
}
func add(n *int) {
*n += 2
}
3.11 结构体
结构体的话是带类型的字段的集合.结构体也可以定义一些方法.
/*
* @Description:
* @Author: zhuzhongzheng
* @Date: 2022-05-18 23:07:22
* @LastEditors: zhuzhongzheng
* @LastEditTime: 2022-05-18 23:22:44
*/
package main
import "fmt"
type user struct {
name string
password string
}
func main() {
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(a, b, c, d)
fmt.Println(checkPassword(a, "haha")) // false
fmt.Println(checkPassword2(&a, "haha")) // false
a.resetPassword("2048")
fmt.Println(a.checkPassword3("2048")) // true
}
func checkPassword(u user, password string) bool {
return u.password == password
}
func checkPassword2(u *user, password string) bool {
return u.password == password
}
// 这里给 user 结构体添加一个方法, 如果不是指针,相当于copy
func (u user) checkPassword3(password string) bool {
return u.password == password
}
// 如果接口体传递的是指针,可以直接修改
func (u *user) resetPassword(password string) {
u.password = password
}
3.12 错误处理
go语言的习惯使用一个单独的返回值来传递错误信息.在函数里,在函数的返回值类型后面加一个error,如果错误返回 nil error,如果没有错误返回接口 nil
/*
* @Description:
* @Author: zhuzhongzheng
* @Date: 2022-05-18 23:26:11
* @LastEditors: zhuzhongzheng
* @LastEditTime: 2022-05-18 23:30:20
*/
package main
import (
"errors"
"fmt"
)
type user struct {
name string
password string
}
func main() {
u, err := findUser([]user{{"wang", "1024"}}, "wang")
if err != nil {
fmt.Println(err)
return
}
fmt.Println(u.name) // wang
}
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")
}
3.13 字符串操作
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
}
3.14 fmt
%v打印任何类型的值,%+v打印详细结果,%#v打印更加详细的
package main
import "fmt"
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}
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
}
3.15 json处理
go语言里的json操作很简单,对于一个已有的结构体,只需要保证每个字段的第一个字母是大写,也就是公开字段,就能使用json.Marshal去序列化,变成一个JSON的字符串.序列化后的字符串,可以通过json.Unmarshal反序列化到一个空的变量中.
/*
* @Description:
* @Author: zhuzhongzheng
* @Date: 2022-05-17 23:17:30
* @LastEditors: zhuzhongzheng
* @LastEditTime: 2022-05-18 23:47:05
*/
package main
import (
"encoding/json"
"fmt"
)
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) // 这里的panic是宕机
}
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"}}
}
3.16 时间处理
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()) // 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
}
3.17 数字解析
package main
import (
"fmt"
"strconv"
)
func main() {
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
}
3.18 进程信息
package main
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
}
