Hexo | Go语言入门

什么是go语言

高性能、高并发
语法简单、学习曲线平缓
丰富的标准库
完善的工具链
静态链接
快速编译
跨平台
垃圾回收

基础语法

package main
 
import (
    //用于向屏幕输出的包
    "fmt"
)

func main() {
    fmt.Println("hello world")
}

变量

var a = "hello world"
var b,c int = 1, 2
var d = true
var e float64
f := float32(e)
g := a + "foo"

//常量
const s string = "constant"
const h = 500000

if-else

if 7%2 == 0 {
    fmt.Println("xxx")
} else {
    ...
}

循环

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

for j = 7;j<9; j++ {
	fmt.Println(j)
}

switch

//默认不需要break
a := 2
switch a {
case 1: 
	fmt.Println("xxx")
case 2:
	...
case 3, 4:
	...
}

t := time.Now()
switch {
case t.Hour() < 12 :
    xxx
default:
    fmt.Println("xxx")
}

数组

var a [5]int
a[4] = 100
//长度固定，使用很少

切片

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]

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)
//无序输出

range

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
	}
	for k := range m {
		fmt.Println("key", k) // key a; key b
	}
}

函数

package main

import "fmt"

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

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

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
}

指针

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
}

结构体

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

错误处理

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

字符串操作

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
}

字符串格式化

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
}

JSON处理

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

语言进阶

Go语言可以充分发挥多核优势，高效运行

Goroutine

协程：用户态，轻量级线程，栈MB级别

线程：内核态，线程跑多个携程，栈KB级别

快速打印0~4

CSP

go提倡通过通信共享内存，而不是通过共享内存来实现通信

Channel

make(chan 元素类型,[缓冲大小])

无缓冲通道 make(chan int)
有缓冲通道 make(chan int,2)

并发安全 Lock

Go语言也有锁来支持通过共享内存来实现通信的操作

WaitGroup

Go的依赖管理

演进

GOPATH

GOPATH环境变量

bin 项目编译的二进制文件
pkg 项目编译的中间产物，加速编译
src 项目源码

项目代码直接依赖src下的代码

go get 下载最新版本的包到src目录下

弊端

无法实现package的多版本控制

GO Vendor

项目目录下增加vendor文件，所有依赖副本形式存放
依赖寻址方式：vendor => GOPATH

通过每个项目引入一个依赖的副本，解决了多个项目需要同一个package依赖的冲突问题

弊端

无法控制依赖的版本
更新项目又可能出现依赖冲突，导致编译错

GO Module

通过go.mod文件管理依赖包
通过go get/go mod指令工具管理依赖包

依赖管理三要素

配置文件，描述依赖 go.mod
中心仓库管理依赖库 Proxy
本地工具 go get/mod

依赖配置-go.mod

依赖配置-version

为了方便版本管理定义了两种版本

语义化版本
- &{MAJOR}.${MINOR}.&{PATCH}
  
  例如V1.3.0
基于commit的伪版本

依赖配置- indirect

go.mod中的非直接依赖

依赖配置- incompatible

标志出可能存在的冲突

测试

回归测试
集成测试
单元测试

Go框架三件套

Gorm的基础使用

Gorm的约定（默认）

Gorm使用名为ID的字段作为主键
使用结构体的蛇形负数作为表名
字段名的蛇形作为列名
使用CreatedAt、UpdatedAt字段作为创建、更新时间

使用Gorm创建数据

First使用踩坑

使用First时，需要注意查询不到数据会返回ErrRecordNotFound
使用Find查询多条数据，查询不到不会返回错误

使用结构体作为查询条件

当使用结构体作为查询条件时，Gorm指挥查询非零值字段。这意味着如果字段值为0、false或其他零值，该字段不会被用于构建查询条件，使用map来构建查询条件。

更新数据

使用Struct更新时，只会更新非零值。如果需要更新零值，可以使用map更新或者使用select选择字段

删除数据

物理删除

软删除

Gorm提供了DeletedAt用于帮助用户实现软删除
拥有软删除能力的 Model 调用 Delete 时，记录不会被从数据库中真正删除。但 GORM 会将 DeletedAt 置为兰前时间，并且你不能再通过正常的查询方法找到该记录
使用 Unscoped 可以查询到被软删的数据

Gorm事务

Gorm提供了Begin、Commit、Rollback方法用于使用事务

Gorm提供了Tansaction方法用于自动提交事务，避免用户漏写Commit、rollback

GormHook

GORM 在提供了 CURD 的 Hook 能力
Hook 是在创建、查询、更新、删除等操作之前、之后自动调用的函数
如果任何 Hook 返回错误，GORM 将停止后续的操作并回滚事务

Gorm性能提高

对于写操作(创建、更新、删除) ，为了确保数据的完整性，GORM 会将它们封装在事务内运行但这会降低性能，你可以使用 SkipDefaultTransaction 关闭默认事务
使用 PrepareStmt 缓存预编译语句可以提高后续调用的速度，本机测试提高大约 35 %左右

KiteX

定义IDL

使用 IDL 定义服务与接口

如果我们要进行 RPC，就需要知道对方的接口是什么，需要传什么参数，同时也需要知道返回值是什么样的。这时候，就需要通过 IDL 来约定双方的协议，就像在写代码的时候需要调用某个函数，我们需要知道函数签名一样。

Kitex生成代码

使用 kitex -module example -service example echo.thrift 命令生成代码

build.sh :构建脚本
kitex gen :IDL 内容相关的生成代码主要是基础的 Server/Client 代码。
maingo 程序入口
handler.go 用户在该文件里实现 IDL service 定义的方法

Kitex基本使用

默认监听8888端口

Kitex Client发送请求

创建Client

发送请求

Kitex服务注册与发现

目前kitex的服务注册与发现已经对接了主流的服务注册与发现中心

Hertz

基本使用

使用Hertz实现，服务监听8080端口并注册了一个GET方法的路由函数

Hertz路由

Hertz提供了GET、POST、PUT、DELETE、ANY等方法用于注册路由

Hertz提供了路由组（Group）的能力，用于支持路由分组的功能
Hertz 提供了参数路由和通配路由，路由的优先级为: 静态路由 > 命名路由 > 通配路由

Hertz参数绑定

Hertz 提供了 Bind、Validate、BindAndValidate 函数用于进行参数绑定和校验

Hertz中间件

Hertz 的中间件主要分为客户端中间件与服务端中间件，如下展示一个服务端中间件

Hertz Client

Hertz 提供了 HTTP Client 用于帮助用户发送 HTTP 请求

高质量编程以及编码规范

简介

什么是高质量

各种边界条件是否考虑完备
异常情况处理，稳定性保证
易读易维护

编程原则

简单性
- 消除多余的复杂性
- 不理解的代码无法修复改进
可读性
- 代码给人看而不是机器
- 编写可维护代码第一步是确保代码可读
生产力
- 团队整体工作效率非常重要

编码规范

代码格式
注释
- 解释代码作用
- 解释代码如何做
- 解释代码实现原因
- 什么情况会出错
命名规范
- 简洁
- 缩略词全大写
- 变量距离其被使用的地方越远，需要携带更多的上下文
控制流程
- 避免嵌套
- 保持正常代码路径最小缩进
错误和异常处理
- 简单错误优先使用errors.New来创建匿名变量来直接表示简单错误
- 尽量提供简明的上下文信息
- panic用于真正异常情况

性能优化

性能优化的前提是满足正确可靠
Go语言提供了支持基准性能测试
Go语言提供了支持基准性能测试的benchmark工具
slice预分配内存
map预分配内存
字符串处理使用strings.builder
使用空结构体节省内存
使用atomic包

性能调优实战

原则

要依赖数据而不是猜测
要定位最大瓶颈而不是细枝末节
不要过早优化
不要过度优化

站点信息

Go语言入门

什么是go语言

基础语法

变量

if-else

循环

switch

数组

切片

map

range

函数

指针

结构体

错误处理

字符串操作

字符串格式化

JSON处理

语言进阶

Goroutine

快速打印0~4

CSP

Channel

并发安全 Lock

WaitGroup

Go的依赖管理

演进

GOPATH

弊端

GO Vendor

弊端

GO Module

依赖管理三要素

依赖配置-go.mod

依赖配置-version

依赖配置- indirect

依赖配置- incompatible

测试

Go框架三件套

Gorm的基础使用

Gorm的约定（默认）

使用Gorm创建数据

使用Gorm创建数据

更新数据

删除数据

物理删除

软删除

Gorm事务

GormHook

KiteX

定义IDL

使用 IDL 定义服务与接口

Kitex生成代码

Kitex基本使用

Kitex Client发送请求

创建Client

发送请求

Kitex服务注册与发现

Hertz

基本使用

Hertz路由

Hertz参数绑定

Hertz中间件

Hertz Client

高质量编程以及编码规范

简介

什么是高质量

编程原则

编码规范

性能优化

性能调优实战

原则

评论区

目录

公告栏