Go

Go 语言被设计成一门应用于搭载 Web 服务器、存储集群或类似用途的巨型中央服务器的系统编程语言。对于高性能分布式系统领域而言,Go 语言比大多数其它语言有着更高的开发效率,并提供海量并行的支持。

Go 的核心在于 用简洁的语法与内建的并发(goroutine / channel)机制,让高并发服务端程序的开发更高效、更可靠。

相比 C/C++ 开发复杂、Python 并发受限的传统方式,Go 以原生并发支持和单一静态二进制,显著降低了高性能分布式系统的开发与部署成本。
Go 1.x

1. 概述

本文系统梳理 Go 语言的核心知识,从开发环境搭建到并发编程与网络开发一应俱全。Go 被设计为一门面向 Web 服务器、存储集群等巨型中央服务器的系统编程语言,以简洁语法与内建的 goroutine / channel 并发机制,让高并发服务端程序的开发更高效、更可靠。相比 C/C++ 的开发复杂度与 Python 的并发限制,Go 凭借原生并发支持和单一静态二进制,显著降低了高性能分布式系统的开发与部署成本。

2. 开发环境搭建

官方下载与文档:https://golang.google.cn/

3. 基础

2.1 编译

命令 说明
go run 文件名 直接运行文件
go run build 文件名.exe 编译成 exe 可执行文件
go build -o 指定文件名.exe 指定编译的文件名

2.2 转义字符

转义字符 说明
\t 制表符
\n 换行
\\ 斜杠 \
\" 分号 "
\r 回车

2.3 注释

// 单行注释

/* 多行注释 */

2.4 变量的声明

指定变量类型,但是不赋值,此时变量采用默认值:

var i int
fmt.Println(i)

根据值自动推导类型:

var name = "tom"
var num = 10

:= 左侧的变量不应该是已经声明过的:

name := test

一次声明多个变量:

var a,b = 10,12

一次声明多个变量并使用类型推导:

a,b,c=10,"test",0

定义多个全局变量:

var (
  v1 = "money"
  v2 = 10
)

4. 数据类型

fmt.Printf("%T\n", c1) 可打印出 c1 的类型。

3.1 整型

类型 占用 / 说明
int8 1 字节
int16 2 字节
int32 4 字节
int64 8 字节
int / uint 平台相关
rune 与 int32 一样,等价 int32,表示一个 Unicode 编码
byte 与 int8 等价
import "unsafe"

fmt.Print(unsafe.Sizeof(j))   //---> 8

3.2 浮点数

  • 单精度 float32
  • 双精度 float64
  • 3.14e2 科学计数法,表示 3.14*10^2

3.3 字符类型 char

  • Go 没有专门的字符类型,可以用 byte 保存(ASCII 码值)。
  • Go 的字符串是由字节组成的。
  • Go 语言采用的编码是 utf-8,解决了编码乱码的问题。
var c2 int = '值'
fmt.Println(c2)
// ----->20540

3.4 布尔类型

只有 false、true。

3.5 字符串类型

  • 字符串一旦赋值就无法更改了,Go 中的字符串是不可变的。
  • 反引号输出:以字符串的原生形式输出,包括换行和特殊字符。
fmt.Print(`\n test`)

字符串的拼接:

fmt.Print("test" + "hahaha")

3.6 数据类型的默认值

var a int //0
var b float32 //0
var v float64 //0
var test bool //false
var name string //""

3.7 类型转换

Golang 中数据类型不能自动转换。

T(v)
//T为数据类型 int32 float64
//v为要转换的变量和数据

Go 的数据类型可以是范围小到范围大,也可以范围大到范围小。

3.8 基本类型转 string

通用格式化动词:

动词 类别 说明
%v 通用 值的默认格式表示
%+v 通用 类似 %v,但输出结构体时会添加字段名
%#v 通用 值的 Go 语法表示
%T 通用 值的类型的 Go 语法表示
%% 通用 百分号
%t 布尔值 单词 true 或 false
%b 整数 表示为二进制
%c 整数 该值对应的 unicode 码值
%d 整数 表示为十进制
%o 整数 表示为八进制
%q 整数 该值对应的单引号括起来的 go 语法字符字面值,必要时会采用安全的转义表示
%x 整数 表示为十六进制,使用 a-f
%X 整数 表示为十六进制,使用 A-F
%U 整数 表示为 Unicode 格式:U+1234,等价于 “U+%04X”
%b 浮点数 无小数部分、二进制指数的科学计数法,如 -123456p-78;参见 strconv.FormatFloat
%e 浮点数 科学计数法,如 -1234.456e+78
%E 浮点数 科学计数法,如 -1234.456E+78
%f 浮点数 有小数部分但无指数部分,如 123.456
%F 浮点数 等价于 %f
%g 浮点数 根据实际情况采用 %e 或 %f 格式(以获得更简洁、准确的输出)
%G 浮点数 根据实际情况采用 %E 或 %F 格式(以获得更简洁、准确的输出)
%s 字符串/[]byte 直接输出字符串或者 []byte
%q 字符串/[]byte 该值对应的双引号括起来的 go 语法字符串字面值,必要时会采用安全的转义表示
%x 字符串/[]byte 每个字节用两字符十六进制数表示(使用 a-f)
%X 字符串/[]byte 每个字节用两字符十六进制数表示(使用 A-F)
%p 指针 表示为十六进制,并加上前导的 0x

fmt.Sprintf() 将任意类型格式化为字符串:

var a1 int = 10
var str string= fmt.Sprintf("%d", a1)
print(str)

strconv.FormatInt():

  • 第一个参数是你要转换的整数。
  • 第二个参数是基数,表示你希望整数以哪种进制格式来表示。例如,基数 10 表示十进制,基数 16 表示十六进制。
var str1 = strconv.FormatInt(10,10)

//'f'为格式 1表示保留一位小数   64表示为float64
var str2 = strconv.FormatFloat(89.99, 'f', 1, 64)

3.9 string 转基本类型

ParseBool:

func ParseBool(str string) (value bool, err error)

返回字符串表示的 bool 值。它接受 1、0、t、f、T、F、true、false、True、False、TRUE、FALSE;否则返回错误。

ParseInt:

func ParseInt(s string, base int, bitSize int) (i int64, err error)

返回字符串表示的整数值,接受正负号。

base 指定进制(2 到 36),如果 base 为 0,则会从字符串前置判断,”0x” 是 16 进制,”0” 是 8 进制,否则是 10 进制;

bitSize 指定结果必须能无溢出赋值的整数类型,0、8、16、32、64 分别代表 int、int8、int16、int32、int64;返回的 err 是 *NumErr 类型的,如果语法有误,err.Error = ErrSyntax;如果结果超出类型范围 err.Error = ErrRange。

ParseUint:

func ParseUint(s string, base int, bitSize int) (n uint64, err error)

ParseUint 类似 ParseInt 但不接受正负号,用于无符号整型。

ParseFloat:

func ParseFloat(s string, bitSize int) (f float64, err error)

解析一个表示浮点数的字符串并返回其值。

如果 s 合乎语法规则,函数会返回最为接近 s 表示值的一个浮点数(使用 IEEE754 规范舍入)。bitSize 指定了期望的接收类型,32 是 float32(返回值可以不改变精确值的赋值给 float32),64 是 float64;返回值 err 是 *NumErr 类型的,语法有误的,err.Error=ErrSyntax;结果超出表示范围的,返回值 f 为 ±Inf,err.Error= ErrRange。

var str3 string = "true"
var bl bool
bl, _ = strconv.ParseBool(str3)
print(bl)
函数会返回两个值,一个是转换后的值,另一个是错误,可以使用 _ 忽略 error。如果 string 为 "hello" 并且转为 int,这时会采用 int 的默认值 0。

3.10 指针

& 取地址:

fmt.Printf("i的地址为", &a)

* 解引用:

var a int = 10
var ptr *int = &a
fmt.Printf("i的地址为\n", &a)
fmt.Printf("%d\n", *ptr)

3.11 运算符

与 C 语言类似。

3.12 获取用户终端输入

  • fmt.Scanf()
  • fmt.Scanfln()

5. 流程控制语句

if / else / else if:

if 10 > 20 {
    fmt.Println("data1")
} else {
    fmt.Println("data2")
}

switch:switch 的后面可以不用加 break。

switch(a){
    case "a":
    fmt.Print("test1")
    case "b":
    fmt.Print("test2")
    case "c":
    fmt.Print("test3")
    default:
    fmt.Print("test4")
}

for 循环:

for i := 0; i < 100; i++ {
    fmt.Println("test")
}

练习 - 空心金字塔:

for i := 0; i <= 9; i++ {
    for j := 1; j <= 9-i; j++ {
        fmt.Print(" ")
    }
    if i != 9 && i != 0 {
        fmt.Print("*")
        for j := 1; j <= i*2+1-2; j++ {
            fmt.Print(" ")
        }
        fmt.Print("*")
    } else {
        for j := 1; j <= i*2+1; j++ {
            fmt.Print("*")
        }
    }
    fmt.Println()
}

练习 - 99 乘法表:

for i := 1; i <= 9; i++ {
    for j := 1; j <= i; j++ {
        fmt.Printf("%d * %d = %d\t", i, j, i*j)
    }
    fmt.Println()
}

goto 与 C 语言类似。

6. 函数

5.1 函数基本用法

func test5(a string, b string) float64 {
  var res1, res2 float64
  res1, _ = strconv.ParseFloat(a, 64)
  res2, _ = strconv.ParseFloat(b, 64)
  return res1 + res2
}

打包的基本语法:package util

引入包的基本语法:import "包的路径",一般路径是 GOPATH 的 src 目录下开始。

  • 首字母大写类似 public,小写为 private。
  • Go 语言不支持重载。
//如果要导出包,则将首字母大写
func ha() {
  fmt.Print("ha")
}

5.2 支持使用变量接收函数

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

func main(){
  a := fun
  var res int = a(10,20)
  fmt.Print(res)
}

并且可以当做参数传递:

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

func fun1(funcvar func(int, int) int, c int) int {
  return funcvar(10, 40) + c
}

func main() {
  a := fun
  var res int = a(10, 20)
  fmt.Println(res)
  var res1 = fun1(a, 30)
  fmt.Println(res1)
}

Go 支持自定义数据类型:

type myInt int
var v myInt = myInt(90)
print(v)

Go 支持给返回值命名:

func rs(a int,b int)(sum int,sub int){
  sum = a + b
  sub = a - b
  return 
}

可以使用 args... 类型接收多个参数,args 的类型为 Slice 可以用 [index] 访问:

func add(args ...int) int {
  var res int
  for i := 0; i < len(args); i++ {
    res += args[i]
  }
  return res
}

5.3 init 函数

  • 在 main 函数之前执行,用于基本构建。
  • 被引入的包的 init 会先执行。
func init() {
  fmt.Print("init\n")
}

5.4 匿名函数

在定义的同时就完成了调用:

func (a int,b int) int{
    return a+b
}(10,30)

将匿名函数赋值给变量:

fu := func (a float64,b float64) float64 {
    return a * b
}

将匿名函数赋值给全局变量时,该匿名函数为全局匿名函数。

5.5 defer

即延迟(defer)语句,你可以在函数中添加多个 defer 语句。当函数执行到最后时,这些 defer 语句会按照逆序执行,最后该函数返回。特别是当你在进行一些打开资源的操作时,遇到错误需要提前返回,在返回前你需要关闭相应的资源,不然很容易造成资源泄露等问题。

将 defer 语句放入到栈时,其相关的值也会拷贝一份,遵守先进后出的规则。defer 在函数执行完毕后,可以及时释放函数创建的资源;当函数完毕后,系统会依次从 defer 栈中取出语句,关闭资源。
func ReadWrite() bool {
    file.Open("file") //打开file文件
    defer file.Close()
    if failureX {
        return false
    }
    if failureY {
        return false
    }
    return true
}

7. 字符串常用的函数

函数 / 用法 说明
len(str) 统计长度,按字节返回
strconv.Atoi 字符串转整数
strconv.Itoa 整数转字符串
[]byte(str) 字符串转 byte 切片
string([]byte) byte 切片转字符串
strconv.FormatInt 整数转 2/8/16 进制字符串
strings.Contains / Count / EqualFold / Index / LastIndex 子串查找
strings.Replace 替换字符
strings.Split 分割字符
strings.ToLower / ToUpper 大小写转换
strings.TrimSpace / Trim / TrimLeft / TrimRight 去掉空格
strings.HasPrefix / HasSuffix 判断前缀 / 后缀

6.1 len

len(str) 统计长度,按字节返回。

fmt.Print(len("test"))   //==>4

遍历中文:

//遍历中文
str := "你好"
var res = []rune(str)
for i := 0; i < len(res); i++ {
    fmt.Printf("%c\n", res[i])
}

6.2 Atoi

将字符串转为整数:

n, err := strconv.Atoi("123")
if err != nil {
    fmt.Println("转换错误", err)
} else {
    fmt.Println("转换成功", n)
}

6.3 ItoA

将整数转为字符串。

6.4 字符串转整数

ns := strconv.Itoa(123)
fmt.Printf("%s\n", ns)

6.5 字符串转为 byte

var bytes = []byte("gogogo")
fmt.Printf("bytes=%v\n", bytes)

6.6 byte 转为字符串

var strs = string([]byte{97, 98, 99})
fmt.Printf("strs=%v\n", strs)

6.7 10 转 2、8、16 进制

返回值为字符串。

str = strconv.FormatInt(123,2); //--->转为2进制

6.8 查找子串是否在字符串内

判断 str 是否有 substr:

fmt.Println(strings.Contains("hahaha", "ha"))  //==>true
fmt.Println(strings.Count("hahaha","ha"))  //文本内有几个substr  ===>3
fmt.Println(strings.EqualFold("abc","ABC"))  //比较字符串,不区分大小写  ==>true
fmt.Println(strings.Index("abc","b")) //查找substr第一次在str出现的位置,没有为-1   ===>1
strings.LastIndex()  //===>与index相同,取得是最后一次出现的位置

6.9 替换字符

子字符串 / 需要替换的字符串 / 替换成的字符串 / 替换的执行次数。

strings.Replace("go go go hello","go","golang",1)  

6.10 分割字符

strings.Split("10,20,30,40",",") //===>拆分字符串","为拆分的字符

6.11 大小写转换

Strings.ToLower("GO")
strings.ToUpper("go")

6.12 去掉空格

strings.TrimSpace(" space ") //====>去掉左右两边的字符串
strings.Trim("hahah!","!") //=====>去掉左右两边的!字符
strings.TrimLeft()  //=====>去掉左两边的!字符
strings.TrimRight()  //=====>去掉右两边的!字符

6.13 判断字符

strings.hasPrefix("haha","ha")  //判断是否以ha开头
strings.HasStuffix("haha","ha") //判断是否以ha结尾

8. 日期与时间函数

7.1 基本使用

now := time.Now()
fmt.Printf("%T,%v", now, now)

//===>time.Time,2024-08-29 17:12:07.0249172 +0800 CST m=+0.002417901

获取年月日时分秒:

fmt.Print(now.Year(), now.Month(), now.Day(), now.Hour(), now.Minute(), now.Second())

时间格式化:

  • time.Format("2006/01/02 15:04:05")
  • 字符数字不能改动。
  • time.Format("2006-01-02 15:04:05")

7.2 时间的常量

  • Sleep(d Duration) 休眠的时间。
  • Hour 小时
  • Minute 分钟
  • Second 秒
  • Millisecond 毫秒
  • Microsecond 微秒
  • Nanosecond 纳秒
now.Unix()   //时间戳
now.UnixNano()  //时间戳微秒

7.3 错误执行机制

当 Go 程序出现异常时,会抛出 panic 的异常,然后在 defer 中用 recover 捕获这个异常,然后正常处理。

func test() {
  defer func() {
    err := recover() //可以捕获到异常
    if err != nil {
      fmt.Println("err=", err)
    }
  }()
  num1 := 10
  num2 := 0
  res := num1 / num2
  fmt.Println(res)
}

func main() {
  test() //==>err= runtime error: integer divide by zer
}

7.4 自定义错误

errors.New("错误说明") 返回一个 error 类型的值,表示一个错误。

func readfile(name string) (error error) {
  if name == "123" {
    return nil
  } else {
    return errors.New("读取文件错误")
  }

}

func testfile() {
  err := readfile("12")
  if err != nil {
    panic(err)
  }
  fmt.Println("成功执行")
}

func main() {
  testfile()   //==>读取文件错误
}

9. 数组与切片

8.1 定义

var test[10] float64
for i := 0; i < len(test); i++ {
    fmt.Println(i)
}
var num = [...]int{8, 9, 10}
fmt.Println("num=", num)

//1为索引  索引:值
var num1 = [...]int{1: 800, 0: 1000, 2: 888}
fmt.Println("num1=", num1)

8.2 遍历

  • index 索引
  • value 值
var num1 = [...]int{1: 800, 0: 1000, 2: 888}
fmt.Println("num1=", num1)

for index, value := range num1 {
fmt.Printf("index=%d,value=%d\n", index, value)
}

8.3 切片

切片是数组的引用,切片的长度可变。

var 变量名 []类型
var intarr [5]int = [...]int{1, 2, 3, 4, 5}

//引用intarr的下标1-3的位置(不包含3)
slice := intarr[1:3]
fmt.Println("slice的元素", slice)
fmt.Println("slice的长度", len(slice))
fmt.Println("slice的容量", cap(slice))
slice 的元素为 [2 3],长度为 2,容量为 4。slice 底层是一个结构体:ptr*[2]int 指针引用的位置、len int 切片长度、cap int 容量。

定义切片:

var 切片[]type = make([],len,[cap])
var test []float64 = make([]float64, 5, 10)
fmt.Println(test)

8.4 切片注意事项

  • arr[0:len(arr)] 简写为 arr[:]。
  • 切片定义完后不能直接使用,需要引用一个数组,或者 make 一个空间来使用。
  • 切片可以再次切片,同时切片与使用它切片而成的切片共用同一个内存地址,因此一个改变,两个都会变。
var slice1 []int = []int{100, 200, 300}
//通过append给slice追加元素
slice1 = append(slice1, 2)
fmt.Println(slice1)
//将自身追加给自身
slice1 = append(slice1, slice1...)
fmt.Println(slice1)

使用 copy 完成拷贝:

var a []int = []int{10, 20, 30, 40, 50}
var slice2 = make([]int, 10, 20)
copy(slice2, a)
fmt.Println(slice2)

slice 具有引用传递:

func test(slice []int){
  slice[0] =100
}
//当传递一个切片时,该切片会改变

8.5 修改字符串

将 string 转为 []byte 或者 []rune -> 修改 -> 重写成 string。

var str string = "this is life"
arr := []byte(str)
arr[1] = 'a'
str = string(arr)
fmt.Println(str)

修改为中文:

var str string = "this is life"
arr := []rune(str)
arr[1] = '好'
str = string(arr)
fmt.Println(str)

10. Map

9.1 map

  • 给一个空 map 赋值报错,在使用前需要先 make,给 map 分配数据空间。
  • map 的 key-value 是无序的。
var a map[string]string
a["1"] = "一"
fmt.Println(a) //报错
var a map[string]string = make(map[string]string, 10)
a["1"] = "一"
fmt.Println(a)
定义一个 map,map 里面还是 map。
var students map[string]map[string]string = make(map[string]map[string]string, 3)
students["1001"] = map[string]string{"name": "tom", "age": "18"}
students["1002"] = map[string]string{"name": "jack", "age": "19"}
students["1003"] = map[string]string{"name": "jerry", "age": "20"}
fmt.Println(students)

9.2 更新修改

  • map[key] = "value" 如果有就是覆盖,没有就是增加。
  • delete(map名, key)。

查找键值对:

cal, ok := a["1"]
if ok {
    fmt.Println(cal)
} else {
    fmt.Println("不存在")
}

9.3 map 的遍历

var a map[string]string = make(map[string]string, 10)
a["1"] = "一"
a["2"] = "二"
a["3"] = "三"
fmt.Println(a)

for i, v := range a {
    fmt.Printf("i=%v\t v=%v\n", i, v)
}

计算长度:

//计算长度
length := len(a)
fmt.Println(length)

9.4 map 切片

[]map[string]string

var cityies = []map[string]string{}
cityies = make([]map[string]string, 3)

cityies[0] = make(map[string]string, 2)
cityies[1] = make(map[string]string, 2)

cityies[0]["guangdong"] = "guangzhou"
cityies[1]["hunan"] = "changsha"
fmt.Println(cityies)

通过 append 动态添加属性:

//动态增加
new_city := map[string]string{
    "beijing": "beijing",
}
cityies = append(cityies, new_city)
fmt.Println(cityies)

9.5 map 的排序

map 原本是无序的。

map1 := make(map[int]int)
map1[10] = 100
map1[3] = 90
map1[7] = 5
map1[20] = 30

将 map 的 key 放入切片中,对切片进行排序,再遍历切片按照 key 来输出 map 的值:

var keys []int
for k, _ := range map1 {
    keys = append(keys, k)
}
sort.Ints(keys)
fmt.Println(keys)
for _, k := range keys {
    fmt.Printf("map1[%v]=%v\n", k, map1[k])
}

11. 面向对象

10.1 struct

字段为大写开头 -> public,小写 -> private。

type 结构体名 struct{
  field1 type
  field2 type
}

声明结构体:

var person Person
var person Person = Person{}

var person *Person = new(Person)
(*person).属性="值"
//也可以简化访问

var person *Person = &Person()

序列化:通过 tag 给 struct 指定 tag,用于序列化,保证兼容性。

type Person struct{
  name string  `json:"name"`
  age int  `json:age`
}
//序列化
jsonStr, _ := json.Marshal(map1)
fmt.Println(jsonStr)

10.2 方法

type Person struct {
  name string
  age  int
}

// 给person绑定一个方法
func (p Person) test() {
  fmt.Println("test")
}

10.3 继承

嵌套匿名结构体实现继承:

type Animal struct{
  name string
  move string
}

type Dog struct{
  Animal   //嵌套匿名结构体实现继承
  age int
}

匿名结构体字段访问可以简化:直接 变量名.继承的父类的属性。

10.4 多重继承

可以嵌入一个基本数据类型:

type A struct{
  Name string
}

type B struct{
  int
  A
}
//访问 
var b B
b.int = 30

嵌套多个匿名结构体,实现多重继承。

10.5 接口

interface 不能包含任何变量。

//定义接口
type C interface {
  Start()
  End()
}

type D struct {
}

//实现接口方法
func (d D) Start(){

}

func (d D) End(){
  
}
  • 一个自定义类只有实现了某个接口,才能将自定义类型的实例赋值给接口类型。
  • 只要是自定义类型都可以实现接口,不仅仅是结构体。
func (i integer)Start(){
  
}

10.6 类型断言

b = a.(类型) 类型断言。

func main(){
  var a interface{}
  var b float32 = 10
  a = b
  b = a.(float32)
}

在进行断言时,带上检测机制:

if b, ok := a.(float64); ok {
    fmt.Printf("%T %v", b, b)
} else {
    fmt.Printf("error")
}
func TypeJudge(items ...interface{}) {
  for index, x := range items {
    switch x.(type) {
    case bool:
      fmt.Printf("%d %v", index, x)
    case int:
      fmt.Printf("%d %v", index, x)
    default:
      fmt.Printf("%d %v", index, x)
    }
  }
}

12. 文件操作

11.1 读取文件

os.Open 打开文件,file.Close() 关闭文件。

import (
  "bufio"
  "fmt"
  "io"
  "os"
)

func main() {
  file, err := os.Open("D:\\MYcode\\code_go\\src\\ts.txt")

  if err != nil {
    fmt.Println(err)
  }

  defer file.Close()

  reader := bufio.NewReader(file)
  for {
    //读到\n就结束
    str, err := reader.ReadString('\n')
    if err == io.EOF {
      break
    } else {
      fmt.Print(str)
    }
  }
}

11.2 写入文件

bufio.NewWriter

func main() {
  filePath := "D:/MYcode/code_go/src/abc.txt"
  file, err := os.OpenFile(filePath, os.O_WRONLY|os.O_CREATE, 0666)
  if err != nil {
    fmt.Println(err)
  }
  defer file.Close()
  writer := bufio.NewWriter(file)
  for i := 0; i < 5; i++ {
    writer.WriteString("Hello\n")
  }
  //将缓存的数据写入磁盘
  writer.Flush()
}

11.3 判断目录或文件是否存在

os.Stat():err 为 nil 表示存在,不为 nil 表示不存在。

11.4 将文件移动到另一个目录

filePath := "D:/MYcode/code_go/src/abc.txt"
NewfilePath := "D:/MYcode/code_go/src/abcd.txt"
content, err := ioutil.ReadFile(filePath)
if err != nil {
    fmt.Println(err)
}
err = ioutil.WriteFile(NewfilePath, content, 0666)

拷贝文件:io.Copy(writer, reader),使用 bufio.NewWriter / bufio.NewReader 获取 writer、reader。

11.5 接收参数的传递

func main() {
  fmt.Println(len(os.Args))
  for i, v := range os.Args {
    fmt.Println("args[%v]=%v", i, v)
  }
}

.\main.exe 1 go 2 go

11.6 获取解析命令行参数

var user string
var pwd string
var host string
var port int
flag.StringVar(&user, "u", "", "默认为空")
flag.StringVar(&pwd, "P", "", "默认为空")
flag.StringVar(&host, "h", "", "默认为空")
flag.IntVar(&port, "p", 3306, "默认为3306")

flag.Parse()
fmt.Printf("%v %v %v %v", user, pwd, host, port)

.\main.exe -u root -P 123456 -h 127.0.0.1 -p 3306 ===> root 123456 127.0.0.1 3306

11.7 序列化 JSON

  1. 序列化对象:
student := Student{
    Name: "tom",
    Age:  18,
}

data, err := json.Marshal(&student)
if err != nil {
    fmt.Println(err)
}
fmt.Println(string(data))
  1. 序列化 map:
a := make(map[string]interface{})
a["name"] = "jerry"
a["age"] = 33

data, err = json.Marshal(a)
if err != nil {
    fmt.Println(err)
}
fmt.Println(string(data))
  1. 序列化切片:
var slice []map[string]interface{}

var m1 map[string]interface{}
m1 = make(map[string]interface{})
m1["name"] = "alice"
m1["age"] = "14"

var m2 map[string]interface{}
m2 = make(map[string]interface{})
m2["name"] = "jack"
m2["age"] = "15"

slice = append(slice, m1)
slice = append(slice, m2)

data, err = json.Marshal(slice)
if err != nil {
    fmt.Println(err)
}
fmt.Println(string(data))

===> [{"age":"14","name":"alice"},{"age":"15","name":"jack"}]

11.8 序列化 JSON 时的 tag 使用

type Student struct {
  Name string `json:"name"`
  Age  int    `json:"age"`
}

11.9 反序列化

json.Unmarshal()

var mystudent Student

err = json.Unmarshal([]byte(string(data)), &mystudent)

if err != nil {
    fmt.Println(err)
}
fmt.Printf("{name:%v,age:%v\n}", mystudent.Name, mystudent.Age)

13. 单元测试

testing 框架:

import "testing"

func TestAdd(t *testing.T) {
  res := Add(5)
  if res != 55 {
    t.Fatalf("执行错误,期望值%v,实际值%v", 55, res)
    return
  }
  t.Logf("成功执行")
}

func Add(a int) int {
  return a + 50
}
  • 文件名以 _test.go 结尾。
  • 测试函数以 Test 开头。
  • go test -v。
  • Pass 表示成功,Fail 表示失败。

14. Go 并发(进程 / 协程)

13.1 go 协程

go test() 函数调用开启协程。

13.2 MPG 模式

  • M:操作系统的主线程。
  • P:协程需要的上下文。
  • G:协程。

13.3 设置 CPU 核数

import (
  "fmt"
  "runtime"
)

func main() {
  //获取当前设备的CPU数
  num := runtime.NumCPU()
  fmt.Println(num)
  //设置最大使用的CPU数
  runtime.GOMAXPROCS(4)
}

13.4 全局互斥锁

  • lock sync.Mutex
  • 加锁:lock.Lock()
  • 解锁:lock.Unlock()

13.5 channel

  • channel 是一个队列。
  • channel 是引用类型,需要 make 才能使用,管道是有类型的,intChan 只能写入整数 int。
  • var intChan chan<- int 只写。
  • var intChan <-chan int 只读。
var intChan chan int
intChan = make(chan int)
fmt.Printf("%v", intChan)

写入:

intChan <- 10

取出:

num2 := <-intChan
fmt.Println(num2)

关闭:

close(intChan)

遍历应该使用 for range 遍历,如果在遍历前没有关闭则会报错。

13.6 管道和协程的共同使用

func putNumber(intChan chan int) {
  for i := 1; i <= 8000; i++ {
    intChan <- i
  }
  close(intChan)
}

func checkNumber(intChan chan int, resChan chan int, exitChan chan bool) {
  var flag bool
  for {
    num, ok := <-intChan
    if !ok {
      break
    }
    flag = true
    for i := 2; i < num; i++ {
      if num%i == 0 {
        flag = false
        break
      }
    }
    if flag {
      resChan <- num
    }
  }
  exitChan <- true
}

func main() {

  intChan := make(chan int, 1000)
  resChan := make(chan int, 2000)
  exitChan := make(chan bool, 4)
  go putNumber(intChan)
  go checkNumber(intChan, resChan, exitChan)
  go checkNumber(intChan, resChan, exitChan)
  go checkNumber(intChan, resChan, exitChan)
  go checkNumber(intChan, resChan, exitChan)

  go func() {
    for i := 0; i < 4; i++ {
      <-exitChan
    }
    close(resChan)
  }()
  for v := range resChan {
    fmt.Printf("取到的值%d\n", v)
  }
}

通过 select 解决管道阻塞问题,当阻塞时会自动过渡到下一个 case:

select {
  case v: <- intChan:
    fmt.Println("读取")
}

使用 recover 解决管道阻塞问题:

defer func() {
    err := recover() //可以捕获到异常
    if err != nil {
        fmt.Println("err=", err)
    }
}()
简化写法。
defer func() {
  if err := recover(); err != nil {
    log.Println(err)
  }
}()

15. 反射

反射(Reflection)在编程中通常被定义为在运行时检查程序的能力。这种能力使得一个程序能够操纵像变量、数据结构、方法和类型这样的对象的各种属性和行为。这一机制在 Go 中主要通过 reflect 标准库实现。

在 Go 中,接口(interface)和反射是紧密相关的。事实上,你可以认为接口是实现反射的“入口”。当你将一个具体类型的变量赋给一个接口变量时,这个接口变量内部存储了这个具体变量的类型信息和数据。

type Any interface{}

func inspect(a Any) {
    t := reflect.TypeOf(a)
    v := reflect.ValueOf(a)
    fmt.Println("Type:", t, "Value:", v)
}

func main() {
    var x int = 10
    var y float64 = 20.0
    inspect(x) // Type: int Value: 10
    inspect(y) // Type: float64 Value: 20
}

14.1 使用注意事项

  • reflect.Value.Kind() 获取变量的类别,返回的是一个常量。
  • .Elem() 相当于取到了地址,并且使用 SetInt() 方法。
func reflect1(b interface{}) {
  rVal := reflect.ValueOf(b)
  //tTyp := reflect.TypeOf(b)
  rVal.Elem().SetInt(10)
}

func main() {
  var num int = 10
  reflect1(&num)
  fmt.Println(num)
}

14.2 基本实践

import (
  "fmt"
  "reflect"
)

type Cal struct {
  Num1 int
  Num2 int
}

func (c Cal) GetSub(name string) {
  fmt.Printf("%s完成了%d-%d=%d", name, c.Num2, c.Num1, c.Num2-c.Num1)
}

func main() {
  var c *Cal
  var rval reflect.Value
  c = &Cal{}
  rval = reflect.ValueOf(c)
  rval = rval.Elem()
  rval.FieldByName("Num1").SetInt(3)
  rval.FieldByName("Num2").SetInt(8)

  //Call传递的参数为reflect.Value切片类型
  var params []reflect.Value
  params = append(params, reflect.ValueOf("tom"))
  rval.Method(0).Call(params)
}

16. 网络编程

15.1 服务监听

func main() {
  listen, err := net.Listen("tcp", "0.0.0.0:8888")
  if err != nil {
    fmt.Println(err)
  }

  defer listen.Close() //延时关闭

  fmt.Printf("begin to listen%v", listen)
}

15.2 循环等待处理连接

func process(conn net.Conn) {
  defer conn.Close()

  for {
    buf := make([]byte, 1024)

    n, err := conn.Read(buf)
    //n为接收的字节数
    if err != nil {
      fmt.Println(err)
      return
    }

    fmt.Printf("recive message:%v", string(buf[:n]))
  }
}

func main() {
  listen, err := net.Listen("tcp", "0.0.0.0:8888")
  if err != nil {
    fmt.Println(err)
  }

  defer listen.Close() //延时关闭

  //循环等待
  fmt.Printf("begin to listen%v address\n", listen)
  for {
    conn, err := listen.Accept()
    if err != nil {
      fmt.Println(err)
    } else {
      fmt.Printf("connect %v", conn)

    }
    go process(conn)
  }
}

15.3 客户端连接并发送消息

func main() {
  //建立连接
  conn, err := net.Dial("tcp", "10.34.111.137:8888")
  if err != nil {
    fmt.Println(err)
  }
  //从控制台输入内容
  reader := bufio.NewReader(os.Stdin)
  strs, err := reader.ReadString('\n')
  if err != nil {
    fmt.Println(err)
  }
  //发送请求
  n, err := conn.Write([]byte(strs))
  if err != nil {
    fmt.Println(err)
  }
  fmt.Print(n)
}

15.4 循环发送客户端消息

func main() {
  //建立连接
  conn, err := net.Dial("tcp", "10.34.111.137:8888")
  if err != nil {
    fmt.Println(err)
  }

  //发送请求
  for {
    //从控制台输入内容
    reader := bufio.NewReader(os.Stdin)
    strs, err := reader.ReadString('\n')
    if err != nil {
      fmt.Println(err)
    }
    strs = strings.Trim(strs, " \r\n")
    if strs == "exit" {
      return
    } else {
      n, err := conn.Write([]byte(strs))
      if err != nil {
        fmt.Println(err)
      }
      fmt.Print(n)
    }

  }
}

17. Redis + Go

16.1 redigo

package main

import (
  "fmt"
  "redigo-master/redis"
)

func main() {
  conn, err := redis.Dial("tcp", "127.0.0.1:6379")
  if err != nil {
    fmt.Println(err)
  }

  fmt.Println(conn)
}

16.2 操作 Redis(string 类型)

func main() {
  conn, err := redis.Dial("tcp", "127.0.0.1:6379")
  if err != nil {
    fmt.Println(err)
  }
  defer conn.Close()
  fmt.Println(conn)

  _, err = conn.Do("set", "name", 6)
  if err != nil {
    fmt.Println(err)
  }
    value, err := redis.Int(conn.Do("get", "name"))
  if err != nil {
    fmt.Println(err)
  }
  fmt.Printf("%c", value)
}

16.3 操作 Redis(hash 类型)

func main() {
  conn, err := redis.Dial("tcp", "127.0.0.1:6379")
  if err != nil {
    fmt.Println(err)
  }
  defer conn.Close()

  _, err = conn.Do("HSet", "value", "name", "name")
  if err != nil {
    fmt.Println(err)
  }
  value, err := redis.String(conn.Do("HGetall", "value", "name"))
  if err != nil {
    fmt.Println(err)
  }
  fmt.Printf("%s", value)
}

获取所有的字段和值:

value, err := redis.Strings(conn.Do("HGetall", "value"))

设置过期时间:

conn.Do("expire", "value", "name", 10) //10秒过期

16.4 Redis 连接池


一句话总结:Go 以静态编译、内建的 goroutine 与 channel 并发模型及简洁语法,让高性能分布式系统与高并发服务端程序的开发更高效、可靠。