走进Go语言基础语法

Go语言简介

高性能高并发静态链接快速编译垃圾回收

入门

开发环境配置

GOROOT与GOPATH配置

基础语法

变量类型

go语言中字符串是内置类型：可以直接使用+拼接；也可以直接使用==去比较两个字符串；

变量声明（两种声明方式）

var a = "initial"该方式声明一般会自动推导变量的类型，若有需要也可显示的写出变量类型如： var b, c int = 1, 2
f := a + "foo"

常量

const s string = "constant"或const h = 500000golang中常量没有确定的类型，可以根据使用的上下文来自动确定类型

if-else（与C的不同点）

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

if后无括号
if后需为{结尾，不可将if中的语句写到同一行

循环（只有for循环，无while与do-while）

//死循环
for {  
fmt.Println("loop")  
break  
}  

//7 8
for j := 7; j < 9; j++ {  
fmt.Println(j)  
}  
  
for n := 0; n < 5; n++ {  
if n%2 == 0 {  
continue  //continue break
}  
fmt.Println(n)  
}  

for i <= 3 {  
fmt.Println(i)  
i = i + 1  
}

switch分支（与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")  
}

无需括号
无需在每个分支后加break，执行完一个分支后不会继续往后执行
功能更加强大，可以使用任何的字符串、结构体，甚至取代任何的if-else语句

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

数组

var a [5]int var twoD [2][3]int
b := [5]int{1, 2, 3, 4, 5}

长度固定，真实场景很少用，常用切片

切片

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) // [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]

可变长度的数组，可以任意时刻更改长度

创建切片s := make([]string, 3) c := make([]string, len(s))

像数组一样取值s[0] = "a"

使用s = append(s, "d") s = append(s, "e", "f")追加元素，注意需将append结果附质回原数组，因为golang中切片的原理是存储了一个长度加一个容量加指向数组的指针，若append时容量不够，会发生扩容并返回一个新的slice，故需要赋值回去。

使用cpoy(c, s)在两个slice中拷贝数据

有类似Python的切片操作，但不同的是不支持负数索引，需要用len进行简单的运算

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

使用m := make(map[string]int) 创建一个空map，map([key的类型]value的类型)

通过[]读取和写入key-value对，通过delete(m, "key")删除。读取时可以通过r, ok := m["key"]，通过Ok来读取这个map中有没有key存在

golang中的map完全无序

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  
  
m := map[string]string{"a": "A", "b": "B"}  
for k, v := range m {  
fmt.Println(k, v) // b 8; a A  
}  
for k := range m {  
fmt.Println("key", k) // key a; key b  
}

遍历时对于数组返回两个值索引与对应位置的值，若不需要索引可以使用下划线来忽略，若遍历map则第一个值是Key, 第二个是value

函数

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  
}

golang中的变量类型是后置的

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  
}

golang初步支持指针、主要用途为对传入的参数进行修改。传入的参数会经过拷贝、若要修改则要通过指针。

结构体

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  
}

类成员函数func (u user) xxx(password string) bool

错误处理

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

符合语言错误处理的习惯为使用单独的返回值来传递错误信息，能很清晰的知道是哪个函数返回了错误。

import "errors" ，出现错误return nil, errors.New("Message"), 无错误return res, nil

调用返回错误的函数时u, err := xxxx()，先判断有无err，若有则进行处理如打印err，只有当确定没用err时才可以取原来的返回值，否则可能出现空指针错误。

字符串操作

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  对与中文，一个中文可能对应多个字符
}

import "strings" 该包中有非常多的工具函数

字符串格式化

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  
}

import "fmt"

可以用%v来打印任何类型的变量而不需要区分类型，使用%+v %#v来打印更详细的信息，使用%.2f来进行小数位数打印

JSON操作

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

对于一个结构体，保证每个字段的第一个字母大写，即可使用json.Marshal(x)来序列化，序列化后会变成一个buf数组，使用json.Unmarshal(x, &b)去反序列化到一个空的变量（b）中去。

序列化出来的字符串是大写开头的，若要小写风格的，可以在声明结构体时，在变量后面加`json:"age"`的tag

时间处理

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  
}

格式化时间为字符串时使用的不是YYYY-MM-DD HH:MM:SS而是一个指定的时间"2006-01-02 15:04:05"

使用time.unix来获取一个时间戳

数字解析

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  
}

import "strconv"引入字符串与数字的转换包

n, _ := strconv.ParseInt("string", 进制, 位数)也可以使用strconv.Atoi来快速将一个十进制字符串转化为数字

若输入不合法则这些函数都会返回错误

进程信息获取

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  
}

import ("os" "os/exec")

使用os.Args来获取进程在执行时的命令行参数

使用os.Getenv或os.Setenv来获取或写入环境变量

使用````exec.Command```来快速启动子进程并获取其输入输出

Go语言的实战案例

猜谜游戏

在线词典

请求代码生成：curlconverter.com

结构体代码生成：

socks5代理

socks协议的工作原理

浏览器和代理服务器建立TCP连接，代理服务器再和真正的服务器去建立TCP连接

协商阶段浏览器向代理服务器发送报文包括认证请求、支持的协议版本号、支持的认证的种类的种类等。代理服务器会选一个它支持的认证方式返回给浏览器。返回0代表不需要认证，返回其他代表需要认证，进行认证流程（此处跳过）。
认证通过后浏览器会向代理服务器发送下一个报文，包括协议版本号、请求类型。一般为connection请求，代表命令代理服务器和某个域名 ip 端口建立TCP连接。代理服务器返回连接建立结果。
连接建立成功后代理服务器转发浏览器请求给服务器，转发服务器响应结果给浏览器。

nc命令：可以直接和某个端口建立TCP连接发现没用netcat于是装了一个：

协议第一步：认证阶段实现

课后作业

1、使用fmt.scanf改写猜谜游戏

fmt.scanf用法：

func Scanf(format string, a ...any) (n int, err error)

Newlines in the input must match newlines in the format. The one exception: the verb %c always scans the next rune in the input, even if it is a space (or tab etc.) or newline.

将原本使用bufio.NewReader读入的输入改为

var guess int  
for {  
_, err := fmt.Scanf("%d\n", &guess)  
if err != nil {  
fmt.Println("Invalid input. Please enter an integer value")  
continue  
}

Go语言基础语法 | 青训营