这是我参与「第五届青训营 」伴学笔记创作活动的第一天
前言
本人之前只接触过Java，所以我希望通过接触不同的编程语言来拓宽自己的思维。
一、Go语言简介
1.1 什么是Go语言
1.高性能、高并发
2.语法简单，学习曲线平缓
3.丰富的标准库
4.完善的工具链
5.静态链接
6.快速编译
7.跨平台
8.垃圾回收
二、Go入门
2.1开发环境-安装Golang
1.输入https://studygolang.com/dl网站下载Go，找到稳定版本，操作系统为64位Windows的压缩包进行下载。
2.下载完后，我们需测试GO环境是否搭建成功。则我们要在下载有Go的文件中找到bin文件夹，通过终端，输入go和go version命令
但每次都需要找到bin文件，是不是觉得有点麻烦，所以如果我们想要在任意的路径下执行某个命令，就需要将这个命令所在的目录配置到环境变量path中去，将命令“注册”到当前的计算机中。找到此电脑，右键点击属性，找到高级系统设置，点击环境变量，找到系统变量中的path，点击新建，然后把bin的路径粘贴进去
3.点击Win+R输入cmd，打开终端，再输入go和go version命令，显示如下，则安装Go成功
2.2开发环境-配置集成开发环境
1.打开(https://code.visualstudio.com/)点击Download for Windows下载安装包，自定义安装路径。
2.设置vscode，vscode的默认语言是英语，如果不熟悉英语的同学，或者是希望更加熟练掌握vscode的小白同学可以选则下载Chinese简体中文插件，下载玩后重启程序即可
3.然后，使用vscode作为go的集成开发环境，我们还需要下载go插件
4.最后，下载go插件后，可能会出现如下图错误
我们只需在cmd终端中输入以下命令，重启vscode，直接install all就可以了
go env -w GO111MODULE=on
go env -w GOPROXY=https://goproxy.cn.direct
2.3Go基础语法-Hello World
1.在窗口下创建go的基本目录结构，创建完后，在vscode点击打开文件夹，这样你创建的go的基本目录就会出现在vocode，接着就可以在文件夹下创建main.go文件。
在vscode新建终端，输入go run go文件的上一个文件夹/main.go,比如我这里的就是 go run 1-hello/main.go,运行如下
其实还有一种更为简单直接的方法，在vscode下载插件code runner
在vscode的右上方会出现一个运行按钮，直接点击它，下面就会直接输出结果
2.4 变量
1.跟我之前所接触的Java不一样的是，Go语言的变量是类型后置的，即int的变量为：
var a int =1
2.同一行申明多个变量：
var b,c int =1, 2
3.Go支持变量类型自动推断
var d = true
4.如果变量没有初始化，则必须显式声明变量类型:
var e float64// 0
5.Go还可以以隐式声明:=声明变量,省略var关键字:
f := 2 //相当于 var f = 2
6.可以使用const关键字来创建一个常量（不可变常量）:
const h string = "constant"
2.5 流程控制
1.Go支持if-else，switch语法进行控制
注意，一般if是if()这种格式,但在Go中if是不加括号的，if表达式后面是接大括号的{}
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 mutiple digits")
}
2.Go中的switch结构跟其他语言是比较相像的,且Go里的swich case是不需要夹break的，Go中swich语句还可以使用任意的变量类型
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("other")
}
t := time.Now()
switch {
case t.Hour() < 12:
fmt.Println("It's before noon")
default:
fmt.Println("It's after noon")
}
}
2.6 数组
1.数组长度一般都是固定，更多的情况下是用切片，这里不过多表述
package main
import "fmt"
func main() {
var a [5]int
a[4] = 100
fmt.Println(a[4], len(a)) //100 5
b := [5]int{1, 2, 3, 4, 5}
fmt.Println(b) //[1 2 3 4 5]
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) //2d: [[0 1 2] [1 2 3]]
}
2.8 切片
1.因数组是定长的，Go在大多数情况下中用切片slice切片代替数组，是一个可变数组，类似于Java的ArrayList,切片是通过make创建
s := make([]string, 3)
它可以像数组一样去取值，使用append来追加元素。使用append的前提是要把append的结果赋值为原数组。slice的原理实际是存储了一个长度和容量，加一个指向一个数组的指针，在执行append操作的时候，如果容量不够，会扩容并返回新的slice
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 获取索引为0的元素
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)//copy方法把切片元素拷贝到另一个切片中
fmt.Println(c) // [a b c d e f]
fmt.Println(s[2:5]) // [c d e]从第2个元素到第四个元素，不包括第五个元素
fmt.Println(s[:5]) // [a b c d e]取0-4的元素
fmt.Println(s[2:]) // [c d e f]
good := []string{"g", "o", "o", "d"}
fmt.Println(good) // [g o o d]
}
2.9 映射
1.map映射用于存储键值对,相对于Java的map集合中的实现类可以排序，Go的map是随机无序的，用make函数来创建map
package main
import "fmt"
func main() {
m := make(map[string]int)//声明一个空map，其中键是字符串，值是整数
m["one"] = 1 //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"] //使用索引运算符检索特定键的值
fmt.Println(r, ok) //0 false
delete(m, "one") //使用delete函数从map中删除键值对
m2 := map[string]int{"one": 1, "two": 2}
var m3 = map[string]int{"one": 1, "two": 2}
println(m2, m3) //0xc000143da0 0xc000143d70
}
2.在Go中，for-rang用于遍历数组、切片、map和通道channel
遍历数组、切片、字符串时，返回每个元素的索引index和值value
for index, value := range array{
}
遍历map则返回每个键key和值值
for key,value := range m{
}
遍历通道，可从通道接收数据，如channel关闭，则会解除阻塞并退出循环
for value := range channel{
}
如果我们忽略索引或值，在遍历时可以用_下划线符号来忽略该变量
for _,value := range m{
}
package main
import "fmt"
func main() {
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
}
//返回key
for k := range m {
fmt.Println("key", k) // key a; key b
}
}
2.10 函数
1.Go中的函数几乎都返回两个值，第一个是真正的返回结果，第二个则是错误信息，定义一个函数，需要使用关键字func，函数名称，参数和返回值
package main
import "fmt"
//声明一个函数
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
}
2.11 指针
1.在Go中，指针是指一个变量的地址的变量，主要作用就是对传入参数进行修改,意思就是如果你想改变变量的值就需要使用指针。使用*来声明一个指针变量，&符号来调用指针
package main
import "fmt"
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
}
2.12 结构体
1.结构体就是带类型的字段的集合。定义结构体需要使用关键字为type和struct,声明一个结构体:
package main
import "fmt"
//声明结构体
type user struct {
name string
password string
}
func main() {
//初始化结构体
a := user{name: "wang", password: "1024"}
//可以把name和passowrd省略，即不写键，直接写value值
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
//使用点号(.)访问结构体
fmt.Println(a.name)//wang
fmt.Println(a.password)//1024
}
//密码比较不加指针
func checkPassword(u user, password string) bool {
return u.password == password
}
//加指针
func checkPassword2(u *user, password string) bool {
return u.password == password
}
2.13 结构体方法
1.结构体方法相当于Java中的非静态方法，把一个普通函数修改成结构体方法，就是把第一个参数加上括号，写到函数名称前面。实现结构体有两种方法，一种是带指针，另一种是不带指针。这个区别就是，带指针可以对结构体进行修改，不带的话，实际操作就是一个拷贝，无法对结构体进行修改
package main
import "fmt"
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
}
2.14 错误处理
1.在Go中，错误处理就是使用一个单独的返回值来传递错误信息。通过导入标准库的errors包来实现.不同于Java自身使用的异常，Go的错误处理能够很清晰地知道哪个函数返回了错误，并且能用简单if-else来处理错误。即通过if判断error是否为nil，nil等价于其他编程语言的null
package main
import (
"errors"
"fmt"
)
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)
}
}
2.15 字符串操作
1.标准库中的strings包中有很多常用的字符串工具函数，比如contains判断一个字符串是否包含另一个字符串，count字符串计数，index查询某个字符串的位置。join连接多个字符串，repeat重复多个字符串，replace替换字符串，剩下的如下图所示
package main
import (
"fmt"
"strings"
)
func main() {
a := "hello"
//判断该字符串中是否包含另一个字符串
fmt.Println(strings.Contains(a, "ll")) //true
//字符串计数
fmt.Println(strings.Count(a, "l")) //2
//接受一个字符串和一个前缀作为参数，并判断该字符串是否以该前缀开头。如果是，函数返回 true，否则返回 false
fmt.Println(strings.HasPrefix(a, "he")) //true
//接受一个字符串和一个后缀作为参数，并判断该字符串是否以该后缀结尾。如果是，函数返回 true，否则返回 false
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
b := "你好"
//获取字符串的长度，一个中文会对应多个字符
fmt.Println(len(b)) //6
}
2.16 字符串格式化
1.Go标准库中的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
}
2.17 JSON处理
1.Go语言中可以通过标准库的encoding/json包进行JSON处理，可以使用json.Marshal函数去序列化Go值，得到一个JSON的字符串，也可使用json.Unmarshal函数反序列化JSON数据为Go值
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)
}
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"}}
}
2.18 时间处理
1. 在Go中最常用的就是用time.Now来获取当前时间，也可用time.date去构造一个带时区的时间，也可用Sub去对两个时间进行减法，得到一个时间段。还可用now.Unix来获取当前时间戳
package main
import (
"fmt"
"time"
)
func main() {
now := time.Now()
fmt.Println(now) // 2023-01-16 00:55:14.6609875 +0800 CST m=+0.002640001
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()) // 1673801714
}
2.19 数字解析
1. 关于字符串和数字类型之间的转换都在strconv包下
- ParseFloat 将字符串转换为浮点数
- ParseInt 将字符串转换为整型
- Atoi 将字符串转换为整数
- Itoa 将整数转换为字符串
- FormatFloat 将浮点数转换为字符串
- ParseBool 将字符串转换为布尔值
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
}
2.20 进程信息
1. 在Go中，我们可以用os.argv来得到程序执行的时候的指定命令行参数，os.gentenv来获取环境变量
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
}
通过上述步骤，go开发环境的基本入门完成。
三、Go语言实战
1.猜数字游戏
用time.now.unix来初始化随机种子
2.在线词典
通过HTTP的POST请求来爬取其他在线词典网站的结果并返回
3.Socks5 代理
通过socks5的工作原理，即socks5代理建立TCP连接，代理再和真正的服务器建立TCP连接。这里可以分成四个阶段，握手阶段、认证阶段、请求阶段、relay阶段
总结
第一天的学习让我获益匪浅，Go是一种静态强类型、编译型语言，语法和C相近，不同于Java，Go内嵌了关联数组（哈希表（Hashes）或字典D（Dictionaries）），就像字符串类型一样，且编写简单。
引用
本文章部分内容来自于以下课程：
- 掘金字节内部课：
