From 2d9a1a3b53ec39de3f641f215471222c3dc19577 Mon Sep 17 00:00:00 2001 From: Estom Date: Fri, 3 Sep 2021 05:41:27 +0800 Subject: [PATCH] =?UTF-8?q?go=E6=95=99=E7=A8=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../Snipaste_2020-03-18_11-08-29.png | Bin 0 -> 12840 bytes .../常量、变量、数据类型.md | 590 +++++++ .../流程控制、运算符、复杂数据类型.md | 979 ++++++++++++ .../04函数、defer、闭包/04函数、defer、闭包.md | 469 ++++++ .../Snipaste_2020-03-21_11-50-46.png | Bin 0 -> 16933 bytes .../05自定义类型与结构体/自定义类型与结构体.md | 694 ++++++++ Go/其他教程/06package/package.md | 101 ++ Go/其他教程/07接口/接口.md | 297 ++++ .../08文件操作/Snipaste_2020-04-02_06-56-32.png | Bin 0 -> 32595 bytes Go/其他教程/08文件操作/文件.md | 328 ++++ Go/其他教程/09time标准库/time标准库.md | 210 +++ Go/其他教程/10反射/反射.md | 337 ++++ .../11conf.ini解析器/conf.ini解析器.md | 156 ++ Go/其他教程/12strconvc标准库/strconv标准库.md | 110 ++ Go/其他教程/13并发编程/1.png | Bin 0 -> 951 bytes Go/其他教程/13并发编程/并发编程.md | 1401 +++++++++++++++++ Go/其他教程/14网络编程/网络编程.md | 631 ++++++++ .../15测试模块/Snipaste_2020-04-07_06-26-10.png | Bin 0 -> 2472 bytes .../15测试模块/Snipaste_2020-04-07_06-29-13.png | Bin 0 -> 3605 bytes .../15测试模块/Snipaste_2020-04-07_06-31-59.png | Bin 0 -> 4840 bytes .../15测试模块/Snipaste_2020-04-07_06-36-32.png | Bin 0 -> 5050 bytes .../15测试模块/Snipaste_2020-04-07_06-37-22.png | Bin 0 -> 3365 bytes .../15测试模块/Snipaste_2020-04-07_06-52-02.png | Bin 0 -> 3620 bytes .../15测试模块/Snipaste_2020-04-07_07-00-55.png | Bin 0 -> 7235 bytes .../15测试模块/Snipaste_2020-04-07_07-03-11.png | Bin 0 -> 8248 bytes .../15测试模块/Snipaste_2020-04-07_07-06-09.png | Bin 0 -> 14456 bytes .../15测试模块/Snipaste_2020-04-07_07-15-26.png | Bin 0 -> 8113 bytes .../15测试模块/Snipaste_2020-04-07_07-17-30.png | Bin 0 -> 5375 bytes .../15测试模块/Snipaste_2020-04-07_07-20-07.png | Bin 0 -> 5990 bytes .../15测试模块/Snipaste_2020-04-07_07-30-40.png | Bin 0 -> 5808 bytes .../15测试模块/Snipaste_2020-04-07_07-47-12.png | Bin 0 -> 20982 bytes .../15测试模块/Snipaste_2020-04-07_08-18-20.png | Bin 0 -> 5870 bytes .../15测试模块/Snipaste_2020-04-07_08-58-15.png | Bin 0 -> 6835 bytes .../15测试模块/Snipaste_2020-04-07_09-21-01.png | Bin 0 -> 45260 bytes Go/其他教程/15测试模块/测试模块.md | 639 ++++++++ Go/其他教程/16context/context.md | 531 +++++++ Go/其他教程/17flag标准库/flag标准库.md | 147 ++ .../18gomodule/Snipaste_2020-04-10_08-08-25.png | Bin 0 -> 6199 bytes .../18gomodule/Snipaste_2020-04-10_08-09-56.png | Bin 0 -> 5780 bytes .../18gomodule/Snipaste_2020-04-10_08-11-08.png | Bin 0 -> 9607 bytes .../18gomodule/Snipaste_2020-04-10_08-18-47.png | Bin 0 -> 4571 bytes .../18gomodule/Snipaste_2020-04-10_08-20-16.png | Bin 0 -> 4866 bytes .../18gomodule/Snipaste_2020-04-10_08-21-14.png | Bin 0 -> 9402 bytes .../18gomodule/Snipaste_2020-04-10_08-22-03.png | Bin 0 -> 11905 bytes .../18gomodule/Snipaste_2020-04-10_08-27-34.png | Bin 0 -> 12153 bytes Go/其他教程/18gomodule/go-module.md | 187 +++ Go/其他教程/19mysqlx/mysqlx.md | 455 ++++++ 47 files changed, 8262 insertions(+) create mode 100644 Go/其他教程/02常量、变量、基本数据类型/Snipaste_2020-03-18_11-08-29.png create mode 100644 Go/其他教程/02常量、变量、基本数据类型/常量、变量、数据类型.md create mode 100644 Go/其他教程/03流程控制、运算符、复杂数据类型/流程控制、运算符、复杂数据类型.md create mode 100644 Go/其他教程/04函数、defer、闭包/04函数、defer、闭包.md create mode 100644 Go/其他教程/04函数、defer、闭包/Snipaste_2020-03-21_11-50-46.png create mode 100644 Go/其他教程/05自定义类型与结构体/自定义类型与结构体.md create mode 100644 Go/其他教程/06package/package.md create mode 100644 Go/其他教程/07接口/接口.md create mode 100644 Go/其他教程/08文件操作/Snipaste_2020-04-02_06-56-32.png create mode 100644 Go/其他教程/08文件操作/文件.md create mode 100644 Go/其他教程/09time标准库/time标准库.md create mode 100644 Go/其他教程/10反射/反射.md create mode 100644 Go/其他教程/11conf.ini解析器/conf.ini解析器.md create mode 100644 Go/其他教程/12strconvc标准库/strconv标准库.md create mode 100644 Go/其他教程/13并发编程/1.png create mode 100644 Go/其他教程/13并发编程/并发编程.md create mode 100644 Go/其他教程/14网络编程/网络编程.md create mode 100644 Go/其他教程/15测试模块/Snipaste_2020-04-07_06-26-10.png create mode 100644 Go/其他教程/15测试模块/Snipaste_2020-04-07_06-29-13.png create mode 100644 Go/其他教程/15测试模块/Snipaste_2020-04-07_06-31-59.png create mode 100644 Go/其他教程/15测试模块/Snipaste_2020-04-07_06-36-32.png create mode 100644 Go/其他教程/15测试模块/Snipaste_2020-04-07_06-37-22.png create mode 100644 Go/其他教程/15测试模块/Snipaste_2020-04-07_06-52-02.png create mode 100644 Go/其他教程/15测试模块/Snipaste_2020-04-07_07-00-55.png create mode 100644 Go/其他教程/15测试模块/Snipaste_2020-04-07_07-03-11.png create mode 100644 Go/其他教程/15测试模块/Snipaste_2020-04-07_07-06-09.png create mode 100644 Go/其他教程/15测试模块/Snipaste_2020-04-07_07-15-26.png create mode 100644 Go/其他教程/15测试模块/Snipaste_2020-04-07_07-17-30.png create mode 100644 Go/其他教程/15测试模块/Snipaste_2020-04-07_07-20-07.png create mode 100644 Go/其他教程/15测试模块/Snipaste_2020-04-07_07-30-40.png create mode 100644 Go/其他教程/15测试模块/Snipaste_2020-04-07_07-47-12.png create mode 100644 Go/其他教程/15测试模块/Snipaste_2020-04-07_08-18-20.png create mode 100644 Go/其他教程/15测试模块/Snipaste_2020-04-07_08-58-15.png create mode 100644 Go/其他教程/15测试模块/Snipaste_2020-04-07_09-21-01.png create mode 100644 Go/其他教程/15测试模块/测试模块.md create mode 100644 Go/其他教程/16context/context.md create mode 100644 Go/其他教程/17flag标准库/flag标准库.md create mode 100644 Go/其他教程/18gomodule/Snipaste_2020-04-10_08-08-25.png create mode 100644 Go/其他教程/18gomodule/Snipaste_2020-04-10_08-09-56.png create mode 100644 Go/其他教程/18gomodule/Snipaste_2020-04-10_08-11-08.png create mode 100644 Go/其他教程/18gomodule/Snipaste_2020-04-10_08-18-47.png create mode 100644 Go/其他教程/18gomodule/Snipaste_2020-04-10_08-20-16.png create mode 100644 Go/其他教程/18gomodule/Snipaste_2020-04-10_08-21-14.png create mode 100644 Go/其他教程/18gomodule/Snipaste_2020-04-10_08-22-03.png create mode 100644 Go/其他教程/18gomodule/Snipaste_2020-04-10_08-27-34.png create mode 100644 Go/其他教程/18gomodule/go-module.md create mode 100644 Go/其他教程/19mysqlx/mysqlx.md diff --git a/Go/其他教程/02常量、变量、基本数据类型/Snipaste_2020-03-18_11-08-29.png b/Go/其他教程/02常量、变量、基本数据类型/Snipaste_2020-03-18_11-08-29.png new file mode 100644 index 0000000000000000000000000000000000000000..62f48476602309ceb28434acac4b93fab3285781 GIT binary patch literal 12840 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 LD2SJd8hrjg9SIX$ literal 0 HcmV?d00001 diff --git a/Go/其他教程/02常量、变量、基本数据类型/常量、变量、数据类型.md b/Go/其他教程/02常量、变量、基本数据类型/常量、变量、数据类型.md new file mode 100644 index 00000000..33041fbc --- /dev/null +++ b/Go/其他教程/02常量、变量、基本数据类型/常量、变量、数据类型.md @@ -0,0 +1,590 @@ +[TOC] + +### 一、Hello Go + +```go +// 包名为main , 表示当前go将会被编译成二进制可执行文件 +// 当前文件想被编译成二进制的可执行文件,除了main包, 还得出现main()函数 +// 如果是我们写一个工具包, 那么不用取名叫main +package main + +import "fmt" + +// 函数外只能放置变量的声明,不能防止逻辑语句( 如打印一句话 ) + +// main() 很干净,没参数,没返回值 +func main(){ + fmt.Println("hello world") +} +``` + + + +### 二、变量和常量 + +#### 2.1 标识符 + +GO中的标识符，实际上就是程序员提供的变量名，方法名，常量名等等，在Go中这些标识符由字母、数字、下划线组成， 并且只用以字符和下划线开头。 + +```go +abc +_123 +a312 +``` + + + +#### 2.2 关键字 + +* Go中一共有25个关键字。 + +```go +for break continue func interface var +if else switch case import return +range type package const default map +select defer struct goto chan go +fallthrough +``` + + + +* 37个保留字 + +就像java中Goto的是保留字一样，虽然现在好没有开发，但是未来可能会拓展。 + +```go +常量4个 true false iota nil + +类型19个 int int8 int16 int32 int64 + uint uint8 uint16 uint32 uint64 + float32 float64 complex64 complex128 + bool byte rune string error + +函数13个 make len cap new append copy close delete + complex real imag + panic recover +``` + +#### 2.3 变量 + +* 变量的声明 + +```go +var 变量名 变量类型 +``` + +Go的变量名推荐驼峰命令法 如： `studentName`。 + +同一个作用域下不能申明重复的变量。 + +* 标准声明 + +```go +var name string +var age int +var isDone bool + +// 声明变量的同时并赋值 +var name string = "zhangsan" + +// Go同样支持类型推导，所以我们可以直接这样写 +var name = "Jerry" +``` + +> **和Java中顺序有不同，且每行语句后都没有分号结尾。** + + + +* 批量声明全局变量 + +```go +var ( + name string // "" + age int // 0 + isDone bool // false +) + +// 声明时赋值 +var ( + name string // "" + age int // 0 + isDone bool // false +) +``` + + + +* 短变量声明： + +```go +name := "Jerry" // 相当于 var name = "Jerry" 的简写 +``` + +短变量声明，要求只能在函数中使用。 + + + +* 变量一旦声明，必须使用 + +demo如下： + +![](Snipaste_2020-03-18_11-08-29.png) + +**变量先声明，再使用**，变量一旦声明了，就要求我们使用它 + +* 对于全局变量： 爆出黄色的警告说，变量不曾使用到。 +* 对于方法内部的局部变量： 声明了，但是不使用，就会爆红。 + + + +#### 2.4 匿名变量 + +```go +func foo()(int,string){ + return 1,"tom" +} + +func main(){ + x,_ := foo() + _,y := foo() + fmt.Print(x) + fmt.Print(y) +} +``` + +Go中的匿名变量使用 _ 表示， 表示占位与忽略值。 + +如果我们确定不会使用函数的返回值，就将其表示成匿名变量。 + +匿名变量不占用命名空间，不会分配内存，所以匿名变量不存在重复声明。 + + + +#### 2.5 常量 + +相当于js中的const， 数值恒定不变的量， 同样的关键字使用const + +```go +// 声明常量 +const pi = 3.1415926 +const e = 2.71 + +// 批量声明常量 +const ( + name = "tom" + age = 23 +) + +// 声明多个常量同时使用相同值， var变量则不行 +const( + n1= 100 + n2 + n3 +) +``` + +尝试修改常量时，编译器会爆红 + + + +#### 2.6 iota + +iota是Go语言中的**常量计数器** + +在const中出现时重置为0 ，每多一行const变量的声明，计数+1 + +```go +const ( + n1 = iota //0 + n2 //1 + n3 //2 +) + +func main() { + fmt.Print(n1) // 0 + fmt.Print(n2) // 1 + fmt.Print(n3) // 2 +} +``` + +更多示例： + +```go +const ( + n1 = iota //0 + n2 //1 + _ // 什么都没写表示和上面一行 + n3 //3 +) + +const ( + n1 = iota //0 + n2 //1 + n3=100 // 100 + n4 //100和上一行一样 +) + +const ( + n1 = iota //0 + n2 =100 //100 + n3= iota // 1 + n4 //2 +) + +// 多个常量声明在一行, 想知道结果话，得记住下面这句话 +// 当const出现时 iota初始化为1，以后const中每多一行（不算空行），iota+1 +const ( + d1, d2 = iota+1, iota+2 + d3, d4 = iota+1, iota+2 +) + +func main() { + fmt.Println("n1: ", d1) //1 + fmt.Println("n2: ", d2) //2 + fmt.Println("n3: ", d3) //2 + fmt.Println("n4: ", d4) //3 +} + +// 定义数量级常量 +const( + _ = iota + kB = 1 << (10*iota) //1左移10位， 相当于2的10次方 + MB = 1 << (10*iota) + GB = 1 << (10*iota) + TB = 1 << (10*iota) + PB = 1 << (10*iota) +) + kB: 1024 + MB: 1048576 + GB: 1073741824 + TB: 1099511627776 + PB: 1125899906842624 +``` + + + +### 三、Go基本数据类型 + + + +整形、浮点型、布尔型、字符串 + +数组、切片、结构体、函数、map、通道（channel) + +#### 3.01 整形 + +| 类型 | 描述 | +| :-------------------------------------: | :-----------------------------------------------: | +| uint8(能表示的范围实际上就是byte的范围) | 无符号 0-255 | +| uint16 | 无符号0-65535 | +| uint32 | 无符号 0-4294967295 | +| uint64 | 无符号0-18446744073709551615 | +| int8 | 有符号-128 到127 | +| int16 | 有符号 -32768 到 32767 | +| int32 | 有符号 -2147483648 到 2147484647 | +| int64 | 有符号 -9223372037854776808到 9223372037854776807 | + +特殊整型： + +| 类型 | 描述 | +| ------- | --------------------------------------------------- | +| uint | 32位的操作系统就是uint32, 64位的操作系统就是uint64 | +| int | 32位的操作系统就是int32, 64位的操作系统就是int64 | +| uintptr | 无符号整形，用于存放一个指针 | + +#### 3.02 八进制和十六进制 + +Go无法直接定义二进制数，如下是8进制和16进制数的示例 + +```go +func main() { + var a int = 10 + fmt.Printf("%d \n", a) // %d 十进制表示10 + fmt.Printf("%b \n", a) // %b 二进制表示1010 + + // 八进制数，以0开头 + var b int = 077 + fmt.Printf("%o \n", b)// 77 + + // 16进制数，以0x 开头 + var c int = 0xff + // c := 0xff + fmt.Printf("%x \n", c) //ff + fmt.Printf("%X \n", c) //FF +} +``` + + + +#### 3.03 浮点数 + +见如下实例： + +```go + fmt.Printf("%f \n",math.Pi) // 3.141593 + fmt.Printf("%.2f \n",math.Pi)// 3.14 + fmt.Printf("%f \n",math.MaxFloat32) // 340282346638528859811704183484516925440.000000 + fmt.Printf("%f \n",math.MaxFloat64) //179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.000000 + + f1:=1.23456 + fmt.Printf("%T \n",f1) // float64 + + f2:=float32(1.23456) // 显示声明 + fmt.Printf("%T \n",f2) // float32 + + // 和java一样，Go是静态类型的语言，所以f1与f2之间不能随便相互赋值, + // 需要进行强转，但是强转后会发生精度损失 + f1= float64(f2) +``` + + + +#### 3.04 复数 + +```go + var c1 complex64 + c1 = 1+2i + + var c2 complex128 + c2 = 2+3i + + fmt.Println(c1) // (1+2i) + fmt.Println(c2) // (2+3i) +} +``` + +#### 3.05 布尔值 + +```go + var b1 bool = true + b2:=false + var b3 bool + fmt.Print(b1) // true + fmt.Print(b2) // false + fmt.Print(b3) // false +``` + +Go中， bool 不能参与类型强制转换其他类型 + + + +#### 3.06 字符串 + +Go语言中的字符串不同于java， Go中的字符串以原生的类型出现，string + +Go中的字符串的内部编码实现使用utf-8 + +只能用 “ ” 包裹 + +```go + var s string = "string" + s2:= "string" + fmt.Printf("s= %#v \n", s) // s= "string" + fmt.Printf("s= %#v \n", s2) // s= "string" +``` + +#### 3.07 字符串的常见操作 + +```go + var name string = "tom" + var address string = "beijing" + + //全局函数，求长度 + fmt.Println(len(name)) //3 + + // 合并两个字符串 + result:=fmt.Sprintf("%s %s",name,address) + fmt.Println(result) // tom beijing + + // 和java一样，重载了+号，实现运算符的拼接 + result2:=name+address + fmt.Println(result2) //tombeijing +``` + +其他方法的使用strings工具 + +```go +func main() { + + var address string = "bei jing" + + // 分隔 + result1:=strings.Split(address," ") + fmt.Println(result1) // [bei jing] + + // 收否包含 + result2:=strings.Contains(address,"jing") + fmt.Println(result2) // true + + // 前后缀判断 + result3:=strings.HasPrefix(address,"b") + fmt.Println(result3) // true + + // 后缀判断 + result4:=strings.HasSuffix(address,"g") + fmt.Println(result4) // true + + // 返回字符首次出现的下标 + result5:=strings.Index(address,"i") + fmt.Println(result5) // 2 + + // 返回字符首次出现的下标 + result6:=strings.LastIndex(address,"i") + fmt.Println(result6) // 5 + + // 连接字符串 + fmt.Println(strings.Join(result1,"+")) //bei+jing + +} +``` + + + + + +#### 3.08 转义符号 + +| 转义 | 含义 | +| :--: | :-------------------: | +| \r | 回车 | +| \n | 换行 | +| \t | 制表符，相当于4个空格 | +| `\'` | 单引号 | +| `\"` | 双引号 | +| `\\` | 反斜杠 | + +```go + path1:=`D:\EEText` // 反引号里面的东西会原样输出 + path2:= "D:\\EEText" //通过 \ 转意路径 + fmt.Print(path1) + fmt.Print(path2) +``` + +#### 3.09 byte ， rune 和 int32 + +在Go中，字符串中的元素叫做**字符**， 使用 ’ ‘ 表示 + +1. **uint8 或者叫byte类型，代表了ASCII的字符** + + int8 可以表示 0-2^8 即 0-128, uint8可以表示 0-256 , 整好在ascii范围内 + +2. **rune , 代表一个UTF8类型的字符** + +当我们需要处理中文或者其他国家的语言时，我们选择使用`rune`类型， `rune`类型实际上是一个`int32` + +```go +func main() { + + var address string = "嗨！ bei jing" + + // 处理英文数字 + for i:=0; i=90{ + fmt.Print("A") + }else{ + fmt.Print("B") + } +``` + +score>=90 , 是判断的条件，看上面的例子，我们能发现**它可以在判断条件前多执行一个语句** + +#### 1.3 for循环 + +Go中所有可循环的类型都可以使用 `for`完成 + +```go +for 初始语句；条件表达式；每次循环修改条件{ + 循环体 +} + +// 变种1 +var i = 5 +for ;i<10;i++{ + ... +} + +// 变种2 +var i = 5 +for i<10{ + ... + i++ +} + +// 死循环 +for{ + ... +} + +// for range(键值循环) +// 可以用来遍历：数组，切片，字符串，map,channel +// 通过for range遍历的返回值有如下的规律 +1. 数组，切片，字符串 返回索引和值 +2. map返回key和value +3. channel只返回通道内的值, 常用这种方式去不断从channel中取值, 当channel被关闭时, for range自动退出, 而不用成员手动判断channel是否关闭了 +如下： + s:="嗨，Go" + for i,v := range s{ + fmt.Printf("i:%d v:%c \n",i,v) + } +结果： + i:0 v:嗨 // 嗨是中文，占有012三个字节 + i:3 v:， + i:6 v:G + i:7 v:o +``` + +和java的for几乎一样，只不过省去了小括号 + +在Go中，可以通过break，goto，return，panic 控制退出 + +continue实现退出本次循环，继续下次循环 + + + +#### 1.4 switch case + +default代码块仅仅有一个 + +写法1： + +```go +func main() { + finger := 2 + switch finger { + case 1: + fmt.Print("111") + case 2: + fmt.Println("222") + default: + fmt.Println("default ... ") + } +} +``` + +写法2： + +```go + // 和上面的if相似, 都将变量的声明和使用写在一行了 + switch finger := 2 ; finger { + case 1: + fmt.Print("111") + case 2: + fmt.Println("222") + default: + fmt.Println("default ... ") + } +``` + +写法3： + +```go + switch finger := 2 ; finger { + case 1,2,3,4,5: + fmt.Print("111") + case 6: + fmt.Println("222") + default: + fmt.Println("default ... ") + } +``` + +`fallthrough`语法可以执行满足的case的下一个case，目的是为了兼容C语言中的case而设计 + +```go + switch n:=1 ; n { + case 1: + fmt.Print("111") + fallthrough + case 2: + fmt.Println("222") + } +// 结果就是 +111 +222 +``` + + + +#### 1.5 goto + +for循环的存在的不足： + +```go +func tryGoto(){ + for i := 0;i<10;i++{ + for j:=0 ; j<10;j++{ + if j==2{ + break + } + fmt.Printf("i:%d j:%d \n",i,j) + } + } +} + +// 输出结果如下，break仅仅跳出了内层的for循环 +i:0 j:0 +i:0 j:1 +i:1 j:0 +i:1 j:1 +i:2 j:0 +i:2 j:1 +i:3 j:0 +i:3 j:1 +i:4 j:0 +i:4 j:1 +i:5 j:0 +i:5 j:1 +i:6 j:0 +i:6 j:1 +i:7 j:0 +i:7 j:1 +i:8 j:0 +i:8 j:1 +i:9 j:0 +i:9 j:1 + +// 如下实现了当内层遇到break时，两层循环全部退出 +// 通过添加一个标记为实现 +func tryGoto(){ + var breakTag bool + for i := 0;i<10;i++{ + for j:=0 ; j<10;j++{ + if j==2{ + breakTag = true + break + } + fmt.Printf("i:%d j:%d \n",i,j) + } + + if breakTag{ + break + } + fmt.Printf("i:%d",i) + } +} +``` + +goto + label 解决 for 循环带来的不足 + +```go +func tryGoto(){ + for i := 0;i<10;i++{ + for j:=0 ; j<10;j++{ + if j==2{ + // 跳转到先的标签所在的位置继续执行，而标签而双重循环的外面 + // 实现了退出循环的动作 + goto BreakTag + } + fmt.Printf("i:%d j:%d \n",i,j) + } + } + BreakTag: + fmt.Println("循环结束") +} +``` + + + +### 二、运算符 + +Go中内置了5种运算符 + +1. 算数运算符 `+ - * / %` +2. 关系运算符 `== != > < >= <=` +3. 逻辑运算符 `&& || !` +4. 位运算符`& | ^ << >>` +5. 赋值运算符 `= += *= /= %= <<= >>= &= |= ^=` + +> **Go中， ++和--同java中一样，是单独的语句，不是运算符** + +上面的运算符和java中的运算符如出一辙 + + + +### 三、复合数据类型 + +#### 3.01 数组的定义： + +```go +var 数组名 [初始容量] T +如： +var arr1 [3]int +var arr2 [3]bool +``` + + + +#### 3.02 Go的数组和其他语言数组的区别 + +Go中，**数组的容量和数组的类型都是数组的一部分，换句话说，即使两个数组都存放bool类型的数据，但是很可能因为他们的容量不同导致他们无法比较。** + +```go + var arr1 [3]bool // 类型： 长度为3的bool + var arr2 [4]bool // 类型： 长度为4的bool + + fmt.Printf("arr1: %T ， arr2:%T",arr1,arr2) // arr1: [3]bool ， arr2:[4]bool +``` + +#### 3.03 数组的初始化 + +默认值： + +```go + var arr1 [3]bool + var arr2 [4]bool + fmt.Print(arr1,arr2) //[false false false] [false false false false] + // 如果不显示的初始化，bool默认为false， int，float默认为0 string默认"" +``` + + + +初始化： + +```go + // 定义长度为3的bool数组 + var arr1 [3]bool + + // 定义长度为3的bool数组并初始化 + arr1 = [3]bool{true,false,true} //[true false true] + + // 根据初始化值，推断数组的长度 + arr2:=[...]int {1,2,3,4,5,6} //[true false true] + + // 初始化方式3 + arr3:=[5]int{1,2} //[1 2 0 0 0] + + // 根据索引初始化 + arr4:=[5]int{0:1,3:2} //[1 0 0 2 0] +``` + + + +遍历： + +```go +for i:=0;i doublecap { + newcap = cap + } else { + if old.len < 1024 { + newcap = doublecap + } else { + // Check 0 < newcap to detect overflow + // and prevent an infinite loop. + for 0 < newcap && newcap < cap { + newcap += newcap / 4 + } + // Set newcap to the requested cap when + // the newcap calculation overflowed. + if newcap <= 0 { + newcap = cap + } + } + } +``` + +1. 如果新申请的容量大于两倍的旧容量, 最终的容量及就是新申请的cap +2. 如果不满足1, 且切片的旧容量长度小于1024 , 那么切片的容量为两倍的旧容量 +3. 如果不满足1和2, 如果旧容量已经大于等于1024, 那么就从旧容量开始循环, 每次给旧容量增加自己的1/4大小, 直到旧容量它大于新申请的容量 , 然后用累加出来的结果当作新容量 +4. 如果计算newcap时发生了overflow溢出的情况, 那么最终容量就是新申请的容量 + +> **需要注意的是, 切片扩容会根据不同的数据类型做不同的处理, 如int , string类型的处理方式不同,结果不同** + + + +#### 3.13 使用`copy()` 函数进行赋值切片 + +参见如下例子: 注意点写在下面的注释里面 + +```go + s0:= []int{1,2,3} + // var s1 []int 这样声明一个变量,内存为nil, 不能进行拷贝 + // 使用make()创建切片, 注意算好len, 不然他不能接收全拷贝给它的值 + // 新切片的cap也要算好, 不够的话会报错, out of range + s1:=make([]int,len(s0)) // + + // 这仅仅是简单的引用的传递, 实际上他们会共用一个底层的数组 + s2:=s0 + // 使用copy()函数, 会拷贝一份底层的数组给当前的切片使用 + copy(s0,s1) + fmt.Println(s0)// [0,0,0] + fmt.Println(s1)// [0,0,0] + fmt.Println(s2)// [0,0,0] + + s2[0]=666 + s1[0]=888 + fmt.Println(s0)// [666,0,0] + fmt.Println(s1)// [888,0,0] + fmt.Println(s2)// [666,0,0] +``` + + + +#### 3.15 从切片中删除元素 + + Go中没有专门用来删除切片中元素的方法, 只能使用切片的特性去删除元素 + +```go + s0:= []int{1,2,3,4,5,6,7,8,9} + // 删除index = 2的元素 + // 参数1: 在谁身上追加 + // 参数2: 追加的内容 + s0 = append(s0[0:2],s0[3:]...) + fmt.Print(s0) // [1 2 4 5 6 7 8 9] +``` + + + +#### 3.16 练习 + +```go +var a = make([]int,5,10) +for i:=0;i<10;i++{ + // 在a的基础上继续追加, cap不够了会自动扩容 + a = append(a,i) +} +fmt.Print(a) // [0,0,0,0,0,1,2,3,4,5,6,7,8,9] +``` + + + + + +#### 3.17 指针 + +Go语言中的指针相对较为简单 , 因为它没有指针的运算 + +用法和C语言中的指针相当 + +* 通过&取变量的内存地址(16进制) +* 通过*取值 + +```go + s:= 18 + p:=&s // 取地址 + fmt.Printf("type:%T ,value:%v" , p,p) //type:*int ,value:0xc00000a0c8 + fmt.Printf("type:%T ,value:%v",*p,*p) // type:int ,value:18 +``` + + + +#### 3.18 new 和 make + +```go +// 返回指针, 用来给基本的数据类型分配内存 +func new(Type) *Type + +// 返回Type, 一般用来给 channel , map , slice 分配内存 +func make(t Type, size ...IntegerType) Type +``` + + + +如下例: 会发生panic + +**原因是: Go中我们对于引用类型的变量在使用时不仅要声明它, 而且还要为他分配内存空间, 否则我们的值就没办法存储** + +> 像 int、float、bool 和 string 这些基本类型都属于值类型，使用这些类型的变量直接指向存在内存中的值 +> +> 更复杂的数据通常会需要使用多个字节，这些数据一般使用引用类型保存。一个引用类型的变量 r1 存储的是 r1 的值所在的内存地址（数字），或内存地址中第一个字所在的位置。 + + + +而**对于值类型的声明,我们不需要再为他分配内存空间**, 因为我们在声明的时候已经默认为他分配好了内存空间 + +而我们想分配内存空间, 需要使用 `new`和`make` + +```go +func main(){ + var a *int + *a = 100 + fmt.Println(*a) + + var b map[string]int + b["白日梦"] = 100 + fmt.Println(b) +} + +// 报错如下: +panic: runtime error: invalid memory address or nil pointer dereference +[signal 0xc0000005 code=0x1 addr=0x0 pc=0x49dd4a] + +``` + +--- + +**`new()`很少用, 一般用来给string,int等基本类型的指针分配内存, 返回值是*int , *string 这种类型的指针** + +> **使用new , 一般是用来给基本类型的指针分配内存** + +通过`new()` 分配内存地址如下: + +```go +func main(){ + var a *int + fmt.Println(a) // + + var a2 = new(int) + fmt.Println(a2) // 0xc00000a0f0 + fmt.Println(*a2) // 0 + + *a2 = 100 + fmt.Println(*a2) // 100 +} +``` + +--- + +`make()`的详解 + +```go +func make(t Type,size ...IntegerType) Type +``` + +`make()`也可以实现内存地址的分配, 区别于new, 他们**只适用于slice, map, 以及chan**的**内存分配和创建**, 而且我们在使用slice,map,chan时, 也必须使用`make()` 为他们分配内存 + +`make()`的返回值是Type, 而不是他们的指针, 因为这三种类型本身就是引用类型, 所以没有必要返回他们的指针 + +```go +func main(){ + // 声明map变量 + var b map[string]int + + // 为map申请内存 + b = make(map[string]int , 10) + + // 赋值 + b["age"] = 12 + fmt.Print(b) // map[age:12] +} +``` + + + +#### 3.19 map + +Go语言提供的双列容器, map, 存储的是键值对, 底层使用散列表实现 + +map无序, 基于k-v的数据结构, map是引用类型, 必须通过初始化后(分配内存)才能使用 + + + +map定义 + +```go +map[keyType]ValueType + +// 如: +var m map[string]int +定义m是map, key=为字符串类型, 值为数值类型 +``` + + + +例: 不初始化而直接使用 报出panic + +```go + // 声明map变量 + var b map[string]int + b["age"] = 12 + fmt.Print(b) + // 报错如下: panic: assignment to entry in nil map +``` + +需要我们为其申请空间, 再使用 + +```go + var b map[string]int // 未在内存中申请空间 + b = make(map[string]int,5) // 申请内存 + b["age"] = 12 + fmt.Print(b) // map[age:12] + + //取值 + fmt.Println(b["age"]) //12 + + // 取不存在的值, 返回对应类型的默认值 + fmt.Println(b["age2"]) // 0 + + // 一般我们可以这样写 + value,ok :=b["age3"] + if !ok{ + fmt.Println("找不到key") + }else { + fmt.Printf("value: %d",value) + } +``` + + + +#### 3.20 map的遍历 + +```go + +func main() { + var m map[string]int + m = make(map[string]int , 5) + m["age"] = 12 + m["length"] = 13 + for k, v := range m { + fmt.Print(k," ",v," \n") + } + + for k:= range m { + fmt.Print(k,"\n") + } + + for k,_:= range m { + fmt.Print(k, "\n") + } + + for _,v:= range m { + fmt.Print(v," \n") + } +} + +``` + + + +#### 3.21 根据key, 删除元素 + +使用全局函数 `delete()` + +```go +func main() { + var m map[string]int + m = make(map[string]int , 5) + m["age"] = 12 + m["length"] = 13 + // 删除存在的key + delete(m,"age") + // 删除不存在的key, no-op 不报错, 也不做任何操作 + delete(m,"age2") +} +``` + + + +#### 3.22 按照指定的顺序遍历map + +思路, 使用切片将map的值切出来, 然后对切片进行排序等操作, 最后在遍历切片的同时取出map中的值 + + + +#### 3.23 元素为map的切片 + +```go +var s1 = make([]map[string]int,3,5) + +// s1[0]["age"] = 12 报错, 没有初始化内部的map + +// 先为map分配内存,再使用 +s1[0] = make(map[string]int,1) +s1[0]["age"] = 12 +fmt.Println(s1) // [map[age:12] map[] map[]] + +``` + + + +#### 3.24 值为切片类型的map + +```go +var s1 = make(map[string][]int,3) +s1["age"] = []int{1,3,5} +// s1["age"] = make([]int,3) // map[age:[0 0 0]] +fmt.Println(s1) +``` + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Go/其他教程/04函数、defer、闭包/04函数、defer、闭包.md b/Go/其他教程/04函数、defer、闭包/04函数、defer、闭包.md new file mode 100644 index 00000000..498b9cb7 --- /dev/null +++ b/Go/其他教程/04函数、defer、闭包/04函数、defer、闭包.md @@ -0,0 +1,469 @@ +[TOC] + +### 补充: + +语言中有函数和方法, 我们写的做的最多的 func xxx (){} 这被称为Go语言中的函数 + +而指定接受者的函数被称为方法 , 如下面就是专属于user的方法 + +``` + func (u user) SaveUser(name string, age int) (err error){ + + } +``` + +### 一、函数 + +#### 1.1 函数的定义： + +```go +// 无参数，无返回值 +func fun(){ + +} + +// 无参数，有返回值， 并且给返回值取了名字叫 ret +func fun()(ret Type){ + +} + +// 有参数，有返回值， 并且没有给返回值取名字 +func sum(a int,b int) int { + return a+b +} + +// 连续参数类型相同时，可像下面这样简写 +func sun (a,b int) { + +} + +// 有参数，有返回值， 且给返回值取了名字 +func sum(a int,b int) （ret int） { + ret = a+b + return +} + +// 多个返回值 +func fun()(int,int){ + return 1,2 +} +// 使用 +_,v := fun() + +// 可变长度的参数 , b可以接受多个int, 也能接受int类型的切片 +func fun(a int,b...int){ + +} +``` + +#### 1.2 函数的作用域 + +Go中函数的作用域和Java中的作用域相当， 会被{ }限制住作用域， 局部找不到就找全局的 + +```go +package main +import "fmt" + +var x = 100 + +func f1() { + // 删除中变量查找的顺序： + // 1. 现在函数内部找， 找不到找函数的外部，全局的变量x + fmt.Print(x) +} + +func main() { + f1() +} +``` + + + +#### 1.3 函数类型与作用域 + +通过如下例查看函数的返回值类型 + +```go +func f1() { + fmt.Print("hello f1 \n") +} + +func f2() int{ + return 1 +} + +func f3(f func() int)(ret int){ + ret = f() + return +} + + + +func main() { + a := f1 + b := f2 + + // 查看函数的返回值类型 + fmt.Printf("%T \n",a) // 类型：func() + fmt.Printf("%T \n",b) // 类型：func() int + + //调用 + f1() //hello f1 + // 函数也做当作参数传递 + fmt.Printf("f3：%v ",f3(f2)) //f3：1 +} + +``` + + + +####1.4 匿名函数 + +参加如下示例学习匿名函数 + +```go +// 声明匿名函数 +// 但是一般我们都是在函数的内部申明匿名函数 +var f = func () { + +} + +func main() { + // 通常在函数的内部声明一个匿名函数 + var f1 = func() { + + } + f1() + f1() + f1() + + // 如果函数仅执行一次，完全可以这样写 + func(x int){ + fmt.Print("仅会被执行一次的函数, 入参传递进来的值为：",x) + }(1) + +} +``` + + + +#### 1.5 内置函数 + +| 内置函数 | 介绍 | +| -------------- | ------------------------------------------- | +| close | 主要用于关闭channel | +| len | 求长度， string，array, slice, map, channel | +| new | 分配内存， int, struct | +| make | 用来分配内存， chan， map , slice | +| append | 向数组， slice中追加元素 | +| panic和recover | 错误尝试恢复 | + +当出现panic时，程序会崩溃， 通过recover尝试恢复错误 + +**在Go中是没有try， catch这种异常处理机制来处理** + +**在Go的设计哲学中， 对待每一种错误都当做是一种具体的值，应该去具体判断，具体处理， 会比较多的if-else** + + + +参照如下的使用`recover()`的实例： + +* `recover()`必须搭配defer使用 +* defer+recover必须出现在 panic前面执行才有意义 + +```go +package main + +import "fmt" + +func a () { + fmt.Println("a") +} + +func b () { + defer func() { + // recover也不被推荐使用 + err:=recover() + if err!=nil{ + fmt.Printf("尝试恢复错误") + } + }() + panic("error panic \n") +} + +func main() { + a () // a + b () // 尝试恢复错误 +} +``` + + + +关于`fmt.Scan` 获取用户的输入 + +```go +func main() { + var s string + // 通过& 取值 + fmt.Scan(&s) + fmt.Println(s) + + // 输入指定的格式数据 + var ( + name string + age int + ) + fmt.Scanf("%s %d \n",&name,&age) + fmt.Println(name,age) + + // 可以扫描到换行 + fmt.Scanln(&name,&age) + fmt.Println(name,age) +} +``` + + + +### 二、defer语句 + +#### 2.1 初识defer语句 + +Go 语言中的defer语句会将其后面跟随的语句进行延迟处理， + +先被defer修饰的函数最后被执行， 最后被defer修饰的函数先执行 + +一个函数中可以存在多个defer + +defer多用于释放资源，文件句柄，数据库连接，socket连接 + +```go +func main(){ + fmt.Println("1") + defer fmt.Println("2") + defer fmt.Println("3") + defer fmt.Println("4") + fmt.Println("5") +} +运行结果： +1 +5 +4 +3 +2 +``` + + + +#### 2.2 defer的执行时机 + +![](Snipaste_2020-03-21_11-50-46.png) + +Go的底层， return语句并不是原子操作， 分成赋值和执行RET命令两步操作 + +如上图为defer的执行时机 + + + +#### 2.3 defer修饰匿名函数 + +```go + +func f1() int { + x := 5 + defer func() { + x++ + }() + return x +} + +func f2() (x int) { + defer func() { + x++ + }() + return 5 +} + +func f3() (y int) { + x := 5 + defer func() { + x++ // 匿名函数自己没有x， 所以使用的是外部的x + }() + return x +} + +func f4() (x int) { + defer func(x int) { + x++ // 这里面的x使用的就是传递给匿名函数的x + }(x) // 将x当作参数传进去 + return 5 +} + +func main() { + // 结果5， 因为他们的执行顺序为： 1.为返回值赋值 2. 执行defer 3.RET指令 + // 所以在defer之前，返回值就确定了 + + fmt.Println(f1()) // 5 + + /* + 第一步： 对返回值进行赋值 x=5 + 第二步: defer 对x++, x=6 + 第三步： 执行RET 返回6 + */ + fmt.Println(f2()) // 6 + + /* + 第一步对返回值进行赋值， 返回值是y，赋值成5 + 第二步 defer对x++, 但是没有y的事 + 第三步执行RET指令，返回y = 5 + */ + fmt.Println(f3()) //5 + + /* + 第一步对返回值进行赋值， 返回值是x，赋值成5 + 第二步 defer 中将返回值x当成参数传递给defer匿名函数, 是值传递，传递的副本 + 第三步执行RET指令，返回x = 5 + */ + fmt.Println(f4()) //5 +} +``` + + + +### 三、闭包 + +闭包大概率是一个函数（多数为匿名函数），这个函数可以起到适配的作用。 + +根据Go的作用域规定，内层函数能访问到外层函数中的变量。 + +所以： 闭包 = 函数+外部变量的引用 + +参照如下的实例： + +下例中，函数f3里面的匿名函数实际上就是一个闭包， 通过他实现了`main()`中的调用关系 + +```go +package main + +import "fmt" + +func f1(f2 func()) { + fmt.Println("this is f1 will call f2") + f2() + fmt.Println("this is f1 finished call f2") +} + +func f2(x int, y int) { + fmt.Println("this is f2 start") + fmt.Printf("x: %d y: %d \n", x, y) + fmt.Println("this is f2 end") +} + +// 接受一个两个参数的杉树， 返回一个包装函数 +func f3(f func(int,int) ,x,y int) func() { + fun := func() { + f(x,y) + } + return fun +} + +func main() { + // 目标是实现如下的传递与调用 + f1(f3(f2,6,6)) +} + +// 结果 +this is f1 will call f2 +this is f2 start +x: 6 y: 6 +this is f2 end +this is f1 finished call f2 +``` + +实际上底层的原理就是： + +1. 函数可以作为返回值 +2. 函数中变量的查找顺序：现在自己的{}作用域中查找，再从全局范围内查找 + + + +案例： + +```go +package main + +import "fmt" + +func calc(base int) (func(int) int, func(int)int){ + + add:= func(i int) int{ + base+=i + return base + } + + sub:= func(i int)int { + base-=i + return base + } + return add,sub +} + +func main() { + add,sub :=calc(10) + + fmt.Println(add(1)) // 11 + fmt.Println(sub(2)) // 9 , 之所以是9, 是因为他先执行的add 将base修改成了11 +} +``` + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Go/其他教程/04函数、defer、闭包/Snipaste_2020-03-21_11-50-46.png b/Go/其他教程/04函数、defer、闭包/Snipaste_2020-03-21_11-50-46.png new file mode 100644 index 0000000000000000000000000000000000000000..34fe37b31e41b0688a73e8af2737e5ec6e00cb74 GIT binary patch literal 16933 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 literal 0 HcmV?d00001 diff --git a/Go/其他教程/05自定义类型与结构体/自定义类型与结构体.md b/Go/其他教程/05自定义类型与结构体/自定义类型与结构体.md new file mode 100644 index 00000000..8246b05c --- /dev/null +++ b/Go/其他教程/05自定义类型与结构体/自定义类型与结构体.md @@ -0,0 +1,694 @@ +[TOC] + + + +### 一、自定义类型和类型别名 + +* 自定义类型： + +自定义类型指的是我们可以通过Go原生数据类型如 string，整形，浮点型，布尔等 去定义我们自己的数据类型如下： + +```go +type myString string +``` + +如上的myString，就是我们自定义的类型，它具有string的特性 + + + +* 类型别名： + +类型别名其实在学这之前我们就遇到过：如下： + +```go +//表示中文符号的rune +type rune = int32 +type byte = uint8 +``` + + + +* 自定义类型和类型别名的区别 + +```go +func main() { + type myString string + type myInt = int + + var a myString + var b myInt + + fmt.Printf("type of a %T",a)//type of a main.myString + fmt.Printf("type of b %T",b)//type of b int +} +``` + +区别如下: + +1. 自定义类型的类型数据**`main.自定义类型`** +2. 而我们为某一个类型所取的**类型别名一旦经过编译就退化成原生类型** + + + +### 二、结构体 + +#### 2.01 什么是结构体 + +因为之前学过C C++, 所以对Go语言中的struct并不陌生 + +Go语言中使用结构体实现面向对象 + +定义格式如下: + +```go +type 自定义类型名 struct{ + 字段名1 字段类型 + 字段名2 字段类型 + ... +} +``` + +注意点: + +* **同一个包中 自定义类型名 不能重复** +* **同一个结构体中, 字段名不能重复** + +例: + +```go +type person struct{ + name string + age int +} + +// 也可以像下面这样简化书写 +type person struct{ + name,sex string + age int +} +``` + + + +#### 2.02 结构体的实例化 + +```go +// 假设我们有如下的结构体 +type person struct{ + name string + age int +} +``` + +* 方式1: + +```go +// 实例化方式1:如下 +func main() { + var p person + fmt.Print(p) // { 0} + fmt.Printf("p4=%#v\n", p) //p=main.person{name:"", age:0} + + p.name = "tom" + p.age = 23 + fmt.Print(p) // {tom 23} + fmt.Printf("p4=%#v\n", p) //p=main.person{name:"tom", age:23} + +} +``` + +1. 我们打印结构体的值, 可以看到结构体长的样子是 被一对大括号直接包裹 +2. 如果我们不指定值, 结构体中的字段会使用默认值, 比如字符串是`""` +3. **如果想更友好的显示结构体,我们可以使用上面的打印格式化模式 #** + + + +* 方式2: + + 通过**new创建指针类型的结构体, 得到是指向结构体的指针** + +```go +// 实例化方式2:如下, 通过new创建指针类型的结构体, 得到是指向结构体的指针 +func main() { + var p = new(person) + fmt.Printf("a %T \n",p) // a *main.person + + fmt.Printf("a %#v \n",p) // a &{ 0} // 字符串的默认值是"", int的默认值是0 + p.name = "jerry" + fmt.Printf("a %#v \n",p) // a &{jerry 0} // 取值时可以看到为 + (*p).age = 23 + fmt.Printf("a %#v \n",p) // a &{jerry 23} + + fmt.Printf("a %#v \n",*p) // a main.person{name:"jerry", age:23} +} +``` + +注意上面的语法糖 + +1. 我们可以直接通过 指针.属性名使用结构体 +2. 也可以正常使用 (*指针).属性名 使用结构体 +3. 可以通过 (*指针)取出指针的值 +4. 直接格式化打印结构体指针的值可以看到编译器我们添加上了 &符号 + + + +* 实例化方式3: + +使用键值对的方式对指针进行初始化 + +```go +func main() { + p := person{ + name: "tom", + age: 23, + } + + fmt.Printf("%#T \n", p) //main.person + fmt.Printf("%#v \n", p) // main.person{name:"tom", age:23} +} +``` + + + +* 实例化方式4: + +我们**对一个结构体变量进行取地址& , 就会得到这个结构体变量的指针** + +同样我们可以通过键值对的方式去实例化一个结构体 + +```go +func main() { + + p := &person{ + name: "tom", + age: 23, + } + + fmt.Printf("%#T \n", p) //*main.person + fmt.Printf("%#v \n", p) //&main.person{name:"tom", age:23} +} +``` + +* 方式5 + +实际上是方式4的简写 + +```go +func main() { + p := &person{ + "tom", + 23, + } + + fmt.Printf("%#T \n", p) //*main.person + fmt.Printf("%#v \n", p) //&main.person{name:"tom", age:23} +} +``` + +但是这就意味着我们必须按照结构体中字段定义的顺序, 实例化结构体中所有的字段 + + + + + +#### 2.03 匿名结构体 + +匿名结构体和java中的匿名内部类有异曲同工之妙, 如果我们真的是仅仅使用一次这个结构体, 完全可以将其定义成匿名结构体如下: + +```go +var user = struct{ + name string + age int +} +``` + +#### 2.04 结构体的匿名字段 + +```go +type student struct{ + string + age +} +func main(){ + stu:=&student{ + "tom" + 23 + } + fmt.Printf("%#v",stu) +} +``` + +我们可以图省事为结构体添加匿名字段, 但是同样是存在限制的, 就是我们的不能出现重复的类型, 比如, 不能出现两个相同的字段string + +#### 2.05 嵌套结构体 + +如下示例: + +```go +type class struct { + non int + students []student +} + +type student struct { + name string + age int +} + +func main() { + cla:=class{ + non:1, + students:[]student{ + student{name:"jerry",age:23}, + student{name:"tom",age:23}, + }, + } + + // main.class{non:1, students:[]main.student{main.student{name:"jerry", age:23}, main.student{name:"tom", age:23}}} + fmt.Printf("%#v",cla) +} +``` + + + +#### 2.06 嵌套匿名结构体 + +```go +type class struct { + non int + []student // 嵌套匿名结构体 +} + +type student struct { + name string + age int +} +``` + + + +#### 2.07 嵌套结构体的字段冲突 + +```go +type class struct { + non int + []student // 嵌套匿名结构体 +} + +type student struct { + non int +} +``` + +如上, class结构体和student结构体中都存在一个int 类型的non字段, 这就是所谓的字段冲突, 解决方式如下: + +```go +type class struct { + non int + students []student +} + +type student struct { + non int +} + +func main() { + cla:=class{ + non:1, + students:[]student{ + student{non:2}, + student{non:3}, + }, + } + fmt.Printf("%#v",cla.non) + fmt.Printf("%#v",cla.students[0].non) +} +``` + + + + + + + +#### 2.08 结构体的内存布局 + +为结构体分配内存时, 默认会分配给它一整块连续的内存 + +```go +type test struct { + a int8 + b int8 + c int8 + d int8 +} +n := test{ + 1, 2, 3, 4, +} +fmt.Printf("n.a %p\n", &n.a) +fmt.Printf("n.b %p\n", &n.b) +fmt.Printf("n.c %p\n", &n.c) +fmt.Printf("n.d %p\n", &n.d) +``` + +结果: + +```go +n.a 0xc0000a0060 +n.b 0xc0000a0061 +n.c 0xc0000a0062 +n.d 0xc0000a0063 +``` + + + +> **空结构体不占用内存** + + + +#### 2.09 练习题 + +```go +type student struct { + name string + age int +} + +func main() { + m := make(map[string]*student) + stus := []student{ + {name: "小王子", age: 18}, + {name: "娜扎", age: 23}, + {name: "大王八", age: 9000}, + } + + for i:=0;i<3;i++{ + m[stus[i].name] = &stus[i] + } + + for k, v := range m { + fmt.Println(k, "=>", v.name) + } +} +// 输出结果如下 +小王子 => 小王子 +娜扎 => 娜扎 +大王八 => 大王八 + + + +type student struct { + name string + age int +} + +func main() { + m := make(map[string]*student) + stus := []student{ + {name: "小王子", age: 18}, + {name: "娜扎", age: 23}, + {name: "大王八", age: 9000}, + } + + for _, stu := range stus { + // m中存放是结构体.name = 结构体指针本身 + m[stu.name] = &stu + fmt.Printf("value = %#v \n",*m[stu.name]) + } + + for k, v := range m { + fmt.Println(k, "=>", v.name) + } +} +// 输出结果如下: +小王子 => 大王八 +娜扎 => 大王八 +大王八 => 大王八 +``` + +原因是因为: 我们m中的key虽然一直在变, 但是所有的key对应的value都指向了一块内存地址stu, 而stu里面的值一直在变, 所以得到了最终的结果 + + + + + +#### 2.10 构造函数 + +我们可以为结构体创建构造函数, **一般结构体的构造函数会返回结构体指针**, 防止结构体过大而带来的内存开销问题 + +一般结构体指针的命名规范 `new结构体名` + +```go +func newPerson(name string,age int){ + return &person{ + name:name + age:age + } +} + +func main(){ + p:=newPerson("tom",23) +} +``` + + + +#### 2.11 方法的接受者 + +在Go中存在方式接受者机制 + +如果说结构体好比java中的类, 那么这种**方法的接受者就像是类内部的成员函数** + +```go +func (自定义接受者名 接受者类型) 方法名(参数列表)(返回值列表){ + +} +``` + +**自定义接受者名就好比是 java中的this, python中的self** + + + +#### 2.12 值类型接受者 + +示例如下: **值类型的接受者传递的实际上是接受者值的一份拷贝, 所作出的任何修改也不会影响到main中的原始状态** + +```go +type student struct { + name string + age int +} + +func newStudent(name string,age int)(*student){ + return &student{ + name: name, + age: age, + } +} + +//值类型接受者 +func (stu student) saySomething(word string){ + fmt.Print(word) +} + +func main() { + stu:=newStudent("tom",23) + stu.saySomething("hi go") +} +``` + +#### 2.13 指针类型接受者 + +```go +//值类型接受者 +func (stu *student) saySomething(word string){ + fmt.Print(word) +} +``` + +这种写法传递是指针, 就真的**类似this和self的感觉了** + + + +#### 2.14 为任意类型添加接受者 + +```go +//MyInt 将int定义为自定义MyInt类型 +type MyInt int + +//SayHello 为MyInt添加一个SayHello的方法 +func (m MyInt) SayHello() { + fmt.Println("Hello, 我是一个int。") +} + +func main() { + var m1 MyInt + m1.SayHello() //Hello, 我是一个int。 + m1 = 100 + fmt.Printf("%#v %T\n", m1, m1) //100 main.MyInt +} +``` + +接收者的类型可以是任何类型，不仅仅是结构体，任何类型都可以拥有方法 + + + +#### 2.15 结构体的继承 + +Go使用结构体实现了面向对象编程的思想 + +同时也提供了结构体的继承 : **在Go中, 通过使用嵌套匿名结构体来实现继承** + +```go +type person struct { + name string +} + +type student struct { + age int + *person +} + +func main() { + stu:=student{age:23,person:&person{name:"jerry"}} + fmt.Printf("%#v",stu.name)// "jerry" +} +``` + +虽然咱看着有点牵强, 但是人家确实算是实现了继承 + + + +#### 2.16 结构体与JSON的序列化 + +这个模块主要是学习一下 下面的函数. 将结构体序列化成json串 + +```go +json.Marshal(结构体) +json.Marshal(结构体指针) +``` + + + +第一个注意点: **如果我们想使用json的序列话和反序列化函数,我们需要将结构体指针的属性首字母开头大写: 表示对外开放** + + + +第二个注意点: **json.Marshal()**`函数如下: 入参位置可以是任意类型 , 就意味着**我们可以将结构体的值赋值给他, 也可以将结构体指针赋值给他, 至于效率嘛. 一眼就看出来了** + +```go +func Marshal(v interface{}) ([]byte, error) {...} +``` + + + +参照下面的例子: + +```go +type Person struct { + Name string +} + +type Student struct { + Age int + *Person +} + +func main() { + + stu:=&Student{Age:23,Person:&Person{Name:"jerry"}} + + // 序列化 + data,err:=json.Marshal(stu) + if err != nil { + fmt.Printf("error: %v\n", err) + return + } + fmt.Printf("json: %s \n",data)//json: {"Age":23,"Name":"jerry"} + + + // 反序列化 + str:="{\"Age\":23,\"Name\":\"jerry\"}" + var Stu Student + err2:= json.Unmarshal([]byte(str),&Stu) + if err2 != nil { + fmt.Printf("error: %v\n", err) + return + } + //obj: main.Student{Age:23, Person:(*main.Person)(0xc000088360)} + fmt.Printf("obj: %#v \n",Stu) +} +``` + + + +#### 2.17 结构体标签 + +结构体标签长下面这样 + +```go +`key1:"value1" key2:"value2"` + +// 示例: +type Person struct { + Name string `tag:"name"` + age int `myTag:"age"` +} +``` + + + +结构体标签主要是用在反射的领域 + +参照如下的例子: 因为json的Marshal方法底层使用的就是反射的技术 + +```go +type Person struct { + Name string `tag:"name"` + Age int `json:"json-age"` + address string `json:"add"` // 能被序列化或者反序列话 +} + +func main() { + p:= &Person{ + Name: "tom", + Age: 23, + address: "shandong", + } + + data,err:=json.Marshal(p) + if err != nil { + fmt.Printf("error: %v\n", err) + return + } + + fmt.Printf("%s",data) // {"Name":"tom","json-age":23} +} +``` + +通过上面的例子我们其实就能看出来, **序列化反射时, 得到的结果的key, 其实是可以通过Tag指定的, 默认使用字段名称当作key** + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Go/其他教程/06package/package.md b/Go/其他教程/06package/package.md new file mode 100644 index 00000000..4534eeb0 --- /dev/null +++ b/Go/其他教程/06package/package.md @@ -0,0 +1,101 @@ +### 一. package + +Go语言中,为我们提供了多个内置包, 如fmt , os , io等等 + +我们也可以定义自己的包, 一个package . 可以简单的理解成它是用来存放 `*.go`文件的文件夹 + +所有的`*.go`文件的第一行都要添加如下的代码 + +```go +package 包名 +``` + + + +### 二. 包名的命名规范 + +* **同一个文件夹下直接包含的文件只能属于一个package, 同一个package不能在多个文件夹下** +* 包名可以不和文件夹的名字一样 +* 包名中不能含有`-` 符号 +* 只有 `package main` 才会被编译成可执行的文件 + + + +### 三. 可见性 + +如果包内的内容想对外暴露可见, 要求将变量名 / 函数名 / 结构体名**首字母大写** + + + +### 四. 包的导入 + +```go +// 单行导入 +//import "code.github.com/changwu/2020-03-17/helloworld" + +// 单行导入+自定义包名 + import hw "code.github.com/changwu/2020-03-17/helloworld" + +// 单行导入+匿名导入 + import _ "code.github.com/changwu/2020-03-17/helloworld" + +import ( + // 多行导入 + //"code.github.com/changwu/2020-03-17/helloworld" + + // 多行导入+自定义包名 + //"code.github.com/changwu/2020-03-17/helloworld" + + // 多行导入+匿名导入 + //_ "code.github.com/changwu/2020-03-17/helloworld" +) + +func main(){ + hw.SayHello() +} + +// 补充: +点（.）标识的包导入后，调用该包中函数时可以省略前缀包名。点（.）操作的语法为： +import ( +. "package1" +. "package2" +. "package3" ... ) +``` + +### 五. `init()` + +包内部都会有一个`init()` , 每次导入时都会先触发被导入包的`init()`的调用, 再触发自己的`init()`的调用 + +```go +import ( + hw "code.github.com/changwu/2020-03-17/helloworld" + "fmt" +) + +func init(){ + fmt.Println("this is structToJson init()") +} + + +func main(){ + /** + this is hello world init() + this is structToJson init() + */ + hw.SayHello() +} +``` + + + +#### 5.1 init()函数的执行时机 + +```go +全局变量 --> init() --> main() +``` + + + +#### 5.2 是否可以主动调用`init()`方法 + +不可以 \ No newline at end of file diff --git a/Go/其他教程/07接口/接口.md b/Go/其他教程/07接口/接口.md new file mode 100644 index 00000000..ab4f4391 --- /dev/null +++ b/Go/其他教程/07接口/接口.md @@ -0,0 +1,297 @@ +### 一. 接口 + +Go中的接口的概念和Java中的接口, 或者python中的鸭子类型是相仿的, 都是体现了面象对象的过程, 只不过具体的实现语法, 细节不同 + +如果说goroutine和channel是Go并发的两大基石，那么接口是Go语言编程中数据类型的关键。 + +在Go中, **接口也是一种类型, 一种抽象的类型** + +**接口中一般会定义一组方法**, 用来拓展某个对象的能力 + +Go语言中的接口是一些方法的集合（method set），它指定了对象的行为： + +```go +type 接口类型名 interface{ + 方法名1( 参数列表1 )返回值列表1 + 方法名2( 参数列表2 )返回值列表2 +} +// 一般接口名的命名规范: 在末尾+er , 如 reader Stringer +// 当接口名+方法名的首字母都大写时, 这个方法可以被接口所在包之外的包访问 +// 参数列表, 返回值列表中的变量名同样可以省略不写 +``` + +#### 1.1 如何算作实现了接口 + +在Go中, 只要结构体**实现了接口中的所有方法**, 就算作是实现了接口 + +> **注意, 是实现所有方法** + +### 二. 优雅的接口 + +先看如**下不使用接口**的编程方式 + +如下的say()方法,作用大同小异,首先说代码肯定会出现两份, 这不是代码的冗余，而是具体的struct对say()方法有不同的实现，但是这不够灵活，比如这不能实现父类引用指向子类对象。 + +```go +type Cat struct{} +type Dog struct{} + +func (c Cat)say{ + fmt.Println("喵~~~") +} +func (d Dog)say{ + fmt.Println("汪~~~") +} + +func main(){ + c:=Cat{} + d:=Dog{} + c.say() + d.say() +} +``` + +让Cat和Dog分别实现接口, 我们就可以使用父类引用指向子类对象 , 代码变的更加优雅 + +```go +// 定义接口 +type Animal interface{ + say() +} +type Cat struct{} +type Dog struct{} + +func (c Cat)say(){ + fmt.Println("喵~~~") +} +func (d Dog)say(){ + fmt.Println("汪~~~") +} + +func main() { + var a Animal + a = Cat{} + a.say() + + a = Dog{} + a.say() +} +``` + +### 三. 值接收者&指针接收者 + +在Go中存在对指针变量求值的语法糖, 将像下面这样, Go会将指针p 处理成 *p , 再去求值 + +示例如下: + +```go +type Animal interface { + say() +} +type Cat struct{} +type Dog struct{} + +func (c Cat) say() { + fmt.Println("喵~~~") +} +func (d Dog) say() { + fmt.Println("汪~~~") +} + +func main() { + var a Animal + a = Cat{} + a.say() + fmt.Printf("%T \n",a) // main.Cat + + a = &Dog{} + a.say() // go会自动的将指针处理成 *p , 然后再调用函数 + fmt.Printf("%T \n",a)// *main.Dog +} +``` + +### 测试题: + +下面的代码是否能编译通过? + +```go +type People interface { + Speak(string) string +} + +type Student struct{} + +func (stu *Student) Speak(think string) (talk string) { + // do something ... + return +} + +func main() { + // 能调用Speak函数, 前提是得有一个Student类型的指针, 所以下面的这行不对 + // var peo People = Student{} + + var peo People = &Student{} + think := "~" + fmt.Println(peo.Speak(think)) +} +``` + + + +### 四. 类型和接口的关系 + +* **一个类型可以实现多个接口, 且多个接口之间不会相互影响** +* **多个类型可以实现同一个接口, 而具有这个接口的能力** +* **实现接口, 并不一定需要自己将接口中方法完全实现, 我们可以通过在类型中嵌入其他类型或者是结构体来实现** + + + + + +### 五. 接口的嵌套: + +接口和接口之间通过嵌套可以创建出新的接口 + +```go +type mover interface { + move() +} + +type sayer interface { + say() +} + +type aminal interface { + mover + sayer +} +``` + + + +### 六. 空接口 + +在Go语言中，所有其它数据类型都实现了空接口。 + +在Go中,如果我们想让入参可以接受任意类型的变量, 那么我们可以使用空接口来实现 + +常见的实现的`fmt`之所以能打印输出各种类型, 就是因为他使用了空接口 + +诸如下面的方法 + +```go +// Println formats using the default formats for its operands and writes to standard output. +// Spaces are always added between operands and a newline is appended. +// It returns the number of bytes written and any write error encountered. +func Println(a ...interface{}) (n int, err error) { + return Fprintln(os.Stdout, a...) +} + +// Sprintln formats using the default formats for its operands and returns the resulting string. +// Spaces are always added between operands and a newline is appended. +func Sprintln(a ...interface{}) string { + p := newPrinter() + p.doPrintln(a) + s := string(p.buf) + p.free() + return s +} +``` + + + +此外, 空接口还一可以作为map的值, 从而让map不再局限存放一种特定的类型 + +```go + // 空接口作为map值 + var studentInfo = make(map[string]interface{}) + studentInfo["name"] = "沙河娜扎" + studentInfo["age"] = 18 + studentInfo["married"] = false + fmt.Println(studentInfo) +``` + +###七. 类型断言 + +既然接口可以实现接收任意类型的变量, 那么我们如何去确定接口的类型呢? -- 断言 + +语法 + +```go +// 断言x接口是T类型的值 +// v 表示第一个参数转换成T类型的后的值 +// ok bool值, 若为true, 表示断言成功 +v,ok:=x.(T) +``` + +示例: + +```go +func main() { + var x interface{} + x = 123 + v, ok := x.(string) + if ok { + fmt.Println(v) + } else { + fmt.Println("类型断言失败") + } +} + +// 使用switch 判断多个断言 +func justifyType(x interface{}) { + switch v:=x.(type){ + case string: + fmt.Printf("x is a string，value is %v\n", v) + case int: + fmt.Printf("x is a int is %v\n", v) + case bool: + fmt.Printf("x is a bool is %v\n", v) + default: + fmt.Println("unsupport type！") + } +} +``` + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Go/其他教程/08文件操作/Snipaste_2020-04-02_06-56-32.png b/Go/其他教程/08文件操作/Snipaste_2020-04-02_06-56-32.png new file mode 100644 index 0000000000000000000000000000000000000000..280062dacdafe86dda5733f1e1565e6eccd6c164 GIT binary patch literal 32595 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 **无论是 Atoi 还是 Itoa, 其中的 i 表示 int , a代表string, 之所以用a代表string , 是因为在C语言中, 没有string, 所有C语言不得不使用array表示字符串** + + + +* 将字符串转换成指定的值 + +```go +ParseBool() +ParseFloat() +ParseInt() +ParseUint() +``` + + + +* 将其他类型的值, 格式化为string + +```go +func FormatBool(b bool) string +func FormatInt(i int64, base int) string +func FormatUint(i uint64, base int) string +func FormatFloat(f float64, fmt byte, prec, bitSize int) string +``` + + + +* 其他 + +```go +// 返回一个字符是否是可打印的，和unicode.IsPrint一样，r必须是：字母（广义）、数字、标点、符号、ASCII空格。 +func IsPrint(r rune) bool + +// 返回字符串s是否可以不被修改的表示为一个单行的、没有空格和tab之外控制字符的反引号字符串。 +func CanBackquote(s string) bool +``` + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Go/其他教程/13并发编程/1.png b/Go/其他教程/13并发编程/1.png new file mode 100644 index 0000000000000000000000000000000000000000..e23ba8574eb5533fc913ebe6dc0dabdc26920ef3 GIT binary patch literal 951 zcmV;o14#UdP)Px#1ZP1_K>z@;j|==^1poj532;bRa{vGi!vFvd!vV){sAK>D158OoK~#8N?b_jS zt1t|}@iz|{Bx5iJTd)LMkl}chL5b_<6iaq5_}>4+?|MmtV@pOdz5cn~ZW{mqS4YDF z0Ca(d1pw#*4GRF!1sWCrpbIoC06-Ut8`dz++vD+gTBdvUb0zN662@5PG5h-x7Cxv0~40jcb!)9Iva{ILAJ;7G>fCb=t5r8ELWGi;isr zNrEI9S_nNwBBxcNbzYuv;y8tk=vZ5e0!Y5fTqR#3G~Nc|q&yA%UGcT9^<9p`IL25L zAE@(&6$1M`sTyqW>GrAxu%-ZoYmbKT(S}97id-dMLcZVn^n2!AVJ#trJp7sKxK>|V z@|D|%;r-Ag><1^}199H4LI7WZ4L7&E9{ok9bphOqkFOZZwX)g526T>*p7d)9pw2~E z<4eBIT`FHk;he{PPC8C)(MtD$mBz?Bms~@59h}O?BR+_gH>{)JX@F}^$t??@%uhB= zixZfx$vReA@Vo^u5}s73So8daHSQ5NTXxF0w9rGftY!*LucqSg|xL z;)9pMKMBf)`F$hr;B~Vq^Cw}p@_98fcvJa8zaYBaOCrPLdvn8{$rk# zAo=>)_42h}lYZ~sSbaq`#H2FU`T5ipWF6b`Btm=;J8f7Z6uW41Xz}p|wzdHNR`IL3 z31ZeF`c4}6Qsm3#)A>r*;c0xTKG(;0N5%K~p0mh{nms^#po$unkee|+iFy*Aj-f1x z*3FR}$9Td?PusO8B;_rD|IDZ21|VPMu9z>+lU|F$DRMdU#3x=;?ZJZhKomDD002IT zh6MoV0u2iQ&;=S60H6yrEC4_kXjlM%F3_+509~MA0RXx{!vX+wfrbSD=mHH30MLQk Z_7|pfZlW5Z_=W%g002ovPDHLkV1hy3xS;?5 literal 0 HcmV?d00001 diff --git a/Go/其他教程/13并发编程/并发编程.md b/Go/其他教程/13并发编程/并发编程.md new file mode 100644 index 00000000..524cb88a --- /dev/null +++ b/Go/其他教程/13并发编程/并发编程.md @@ -0,0 +1,1401 @@ +### 一. 并发编程 + +#### 1.1 简介: + +Java对多线程的封装类是Thread, 每一个Thread的实例都会通过JVM调用C++的方法, 和系统内核的线程做唯一的绑定, 因此, java中的多线程, 是真实的多线程, 可以利用多核系统的特性 + +但是Java从1997年诞生, 那时候还没有发展成多核机器, 因此Java在设计之初是没有考虑为多核多线程而设计的, 即使他后续推出了多线程编程, 但是相对来说依然还是挺复杂的 + +此外, Java的多线程中的线程栈空间初始大小为2兆, 那么2兆*1000 = 2G的内容, 所以, Java的多线程很吃内存, 这可不太好, 因为内存资源是很珍贵的 + + + +对于Go来说, 它诞生于09年, 那时多核机器已经问世, 它对适配多核, 在语言设计指出就有所考虑, 通过`goroutine`实现了多个函数之间的并发执行, 我们不再自己去写什么进程, 线程, 协程, 一个goroutine就够了 + +`goroutine`绑在着用户空间的线程, 通常只需要2k的内存就可以, 所以Go可以实现的高并发很容易就到达十万级别 + +#### 1.2 goroutine的使用 + +使用很简单, 只需要在func之前, 添加上go关键字就行 + +```go + +func hello() { + fmt.Println("Hello Goroutine!") +} +func main() { + go hello() + fmt.Println("main goroutine done!") +} +// 只会输出 main goroutine done! , 因为main goroutine执行结束之后, 就会结束, 子任务也被退出 +``` + +* 解决方式1: + +```go +// 可以简单粗暴的让main goroutine 睡一秒, 等待子任务的执行 +func hello() { + fmt.Println("Hello Goroutine!") +} +func main() { + go hello() + fmt.Println("main goroutine done!") + time.Sleep(time.Second) +} +``` + + + +* 解决方式2: 使用 `sync.waitGroup`来实现同步 + +```go +var wait sync.WaitGroup + +func hello() { + // 减少一次计数 + defer wait.Done() + fmt.Println("Hello Goroutine!") +} +func main() { + + for i:=0;i<=5;i++{ + // 每次启动一次, 就增加一次计数 + wait.Add(1) + go hello() + } + // 当计数为0时, 不再wait + wait.Wait() + fmt.Println("main goroutine done!") +} +``` + + + +#### 1.3 goroutine的调度 + +goroutine的调度简称: GPM + +一句话总结就是: P 管理着一组 G, 挂载到M上执行 + +* G: 就是goroutine本身, 还存放着goroutine和GPM之间绑定的信息 +* P: P里面管理着一组goroutine, 存储当前goroutine的运行时环境, 函数指针, 堆栈, 地址边界, 同时 P会去对自己管理的goroutine队列进行调度,( 比如把占用CPU时间较长的goroutine暂停、运行后续的goroutine等等 , 当自己的队列中**消费完了goroutine就去全局的队列中取, 全局的goroutine队列也被消费完了, 就是其他队列里面抢** +* M:（machine) 是Go运行时（runtime）对操作系统内核线程的虚拟， M与内核线程一般是一一映射的关系， 一个groutine最终是要放到M上执行的； + + + +P与M一般也是一一对应的。他们关系是： P管理着一组G挂载在M上运行。当一个G长久阻塞在一个M上时，runtime会新建一个M，阻塞G所在的P会把其他的G 挂载在新建的M上。当旧的G阻塞完成或者认为其已经死掉时 回收旧的M。 + +P的个数是通过`runtime.GOMAXPROCS`设定（最大256），Go1.5版本之后默认为物理线程数。 在并发量大的时候会增加一些P和M，但不会太多，切换太频繁的话得不偿失。 + + + +* 单从线程调度讲，Go语言相比起其他语言的优势在于OS线程是由OS内核来调度的，`goroutine`则是由Go运行时（runtime）自己的调度器调度的， + +* 调度器使用一个称为m:n调度的技术（复用/调度m个goroutine到n个OS线程）。 其一大特点是goroutine的调度是在用户态下完成的， 不涉及内核态与用户态之间的频繁切换，包括内存的分配与释放，都是在用户态维护着一块大的内存池， 不直接调用系统的malloc函数（除非内存池需要改变），成本比调度OS线程低很多。  +* 充分利用了多核的硬件资源，近似的把若干goroutine均分在物理线程上， 再加上本身goroutine的超轻量，以上种种保证了go调度方面的性能。 + + + +#### 1.4 GOMAXPROCS + +Go运行时的调度器使用`GOMAXPROCS`参数来确定需要使用多少个OS线程来同时执行Go代码。默认值是机器上的CPU核心数。例如在一个8核心的机器上，调度器会把Go代码同时调度到8个OS线程上（GOMAXPROCS是m:n调度中的n） + +**Go语言中可以通过`runtime.GOMAXPROCS()`函数设置当前程序并发时占用的CPU逻辑核心数。** + +**Go1.5版本之前，默认使用的是单核心执行。Go1.5版本之后，默认使用全部的CPU逻辑核心数。** + +我们可以通过将任务分配到不同的CPU逻辑核心上实现并行的效果，这里举个例子 + +```go +func main() { + runtime.GOMAXPROCS(1) + go a() + go a() + go a() +} +``` + + + +### 二 . channel + +#### 2.01 channel 简介: + +在Java中, JMM规范要求, 如果两条线程之间想通信的话, 需要借助于主存中的变量区完成通信 + +**在Go中, 两个并发执行的函数可以通过channel进行数据的交互** + +Go的并发模型是`CSP (communicating sequential processor)` 即, 通过通信来共享内存, 而不是通过内存来实现通信 + +在Go中, 通过channel去实现各个goroutine之间的通信, chanel是一个特殊类型, 遵循先进先出 (FIFO)的规则, 保证收发信息的顺序, 每一个channel都有他具体的类型, 声明通道时, 需要指定这个类型 + + + +#### 2.02 channel的类型 + +```go +var ch1 chan int +var ch2 chan string +var ch3 chan bool +var ch4 chan []int +... +``` + + + +#### 2.03 创建通道 + +通道声明后, **还得为他分配空间才能使用** + +可以通过make函数设置通道缓冲区的大小 + +```go +func main() { + var ch chan int + ch4 := make(chan int) + ch5 := make(chan bool) + ch6 := make(chan []int) + ch7 := make(chan []int,15) + + fmt.Println(ch) // + fmt.Println(ch4) // <0xc00001a120> + fmt.Println(ch5) // <0xc00001a180> + fmt.Println(ch6) // <0xc00001a1e0> + fmt.Println(ch7) // <0xc00003e060> +} +``` + +#### 2.04 channel的操作 + +```go +// 创建 +ch := make(chan int ,15) +// 将值写入通道: +ch <- 10 + +// 取出存储value中 +value := <- ch + +// 取出并忽略 +<- ch + +// 关闭通道, 只有在通知接收方所有的数据都发送完毕的时候, 才需要关闭通道 +// 通道是可以被强制回收的, 所以不一定非得关闭通道 +close(ch) +``` + + + +#### 2.05 有缓冲的channel + +当缓冲信道达到满的状态的时候，就会表现出阻塞了，因为这时再也不能承载更多的数据了，「你们必须把 数据拿走，才可以流入数据」。 + +在声明一个信道的时候，我们给make以第二个参数来指明它的容量(默认为0，即无缓冲): + +```go + // 写入2个元素都不会阻塞当前goroutine, 存储个数达到2的时候会阻塞 + // 如果被阻塞后, 还有没其他的goroutine去消费这个channel, 就会爆出死锁 +var ch chan int = make(chan int, 2) +``` + +如下的例子，缓冲信道ch可以无缓冲的流入3个元素: + +```go +func main() { + ch := make(chan int, 3) + ch <- 1 + ch <- 2 + ch <- 3 +} +``` + +如果你再试图流入一个数据的话，信道ch会阻塞main线, 报死锁。 + +也就是说，缓冲信道会在满容量的时候加锁。 + +其实，缓冲信道是先进先出的，我们可以把缓冲信道看作为一个线程安全的队列： + +```go +func main() { + ch := make(chan int, 3) + ch <- 1 + ch <- 2 + ch <- 3 + + fmt.Println(<-ch) // 1 + fmt.Println(<-ch) // 2 + fmt.Println(<-ch) // 3 +} +``` + + + + + +```go +// 缓冲区大小是15的通道 +ch7 := make(chan []int,15) + +func main() { + ch := make(chan int,3) + for i:=3;i<8 ;i++ { + ch <-i + } +} + +// 向有缓冲区的通道中, 只存入, 当超出缓冲区大小的容量时, 就会报错 死锁 +fatal error: all goroutines are asleep - deadlock! +goroutine 1 [chan send]: +main.main() +``` + + + +#### 2.06 无缓冲区的channel + +如下: + +```go + // 没有缓冲区的通道 + ch6 := make(chan []int) +``` + + + +例: 当向没有缓冲区的channel写入数据, 同时也没有其他的goroutine去尝试获取锁, 就会报错死锁 + +> **因为我们使用`ch := make(chan int)`创建的是无缓冲的通道，无缓冲的通道只有在有人接收值的时候才能发送值。** + +```go +func main() { + ch := make(chan int) + ch <- 10 +} + +fatal error: all goroutines are asleep - deadlock! +goroutine 1 [chan send]: +main.main() + + +// 可以向下面这样, 找个goroutine去消费它 +func hello(ch <-chan int) { + var value = <- ch + fmt.Println("value: ",value) +} + +func main() { + ch := make(chan int) + go hello(ch) + ch <- 10 +} +``` + +无缓冲的信道永远不会存储数据，只负责数据的流通 + +* 从无缓冲信道取数据，必须要有数据流进来才可以，否则当前线阻塞 +* 数据流入无缓冲信道, 如果没有其他goroutine来拿走这个数据，那么当前线阻塞 + + + +#### 2.07 无缓冲信道的数据进出顺序 + +我们已经知道，无缓冲信道从不存储数据，流入的数据必须要流出才可以 + +```go +var ch chan int = make(chan int) + +func foo(id int) { //id: 这个routine的标号 + ch <- id +} + +func main() { + // 开启5个routine + for i := 0; i < 5; i++ { + go foo(i) + } + + // 取出信道中的数据 + for i := 0; i < 5; i++ { + fmt.Print(<- ch) + } +} +``` + +我们开了5个goroutine，然后又依次取数据。其实整个的执行过程细分的话，5个线的数据 依次流过信道ch, main打印之, 而宏观上我们看到的即 无缓冲信道的数据是先到先出，但是 无缓冲信道并不存储数据，只负责数据的流通 + + + + + + + +#### 2.08 体会从空channel中获取值会被阻塞 + +示例1: + +```go +// 可以向下面这样, 找个goroutine去消费它 +func hello(ch <-chan int) { + fmt.Println("准备获取值 value: ") + var value = <- ch // 被阻塞住,等到main往channel中存入值 + fmt.Println("value: ",value) +} + +func main() { + ch := make(chan int) + go hello(ch) + + time.Sleep(time.Second*5) + ch <- 10 + time.Sleep(time.Second*5) +} +``` + +示例2: + +```go +var complete chan int = make(chan int) + +func loop() { + for i := 0; i < 10; i++ { + fmt.Printf("%d ", i) + } + + complete <- 0 // 执行完毕了，发个消息 +} + + +func main() { + go loop() + <- complete // 直到线程跑完, 取到消息. main在此阻塞住 +} +``` + + + +> 默认的，信道的存消息和取消息都是阻塞的 (叫做无缓冲的信道，不过缓冲这个概念稍后了解，先说阻塞的问题)。 +> +> 也就是说, 无缓冲的信道在取消息和存消息的时候都会挂起当前的goroutine，除非另一端已经准备好。 + +#### 2.09 for range从通道循环取值 + +* 如果通道已经关闭了, 还往里面写入值, 就会爆出 panic +* for range 可以自动判断channel是否关闭了, 当 channel 关闭后, for range也会自动退出, 这是普遍的做法 + + + +```go +func main() { + ch1 := make(chan int) + ch2 := make(chan int) + + go func() { + for i := 0; i < 100; i++ { + ch1 <- i + } + // todo 发送完毕后, 关闭channel + close(ch1) + }() + + go func() { + for { + // todo channel 关闭后, 得到的ok = false + v, ok := <-ch1 + if !ok { + break + } + ch2 <- v * v + } + // 关闭channel + close(ch2) + }() + + // todo 通常使用 for range 去遍历channel, channel关闭后, 会自动退出 + for value := range ch2 { + fmt.Println(value) + } +} +``` + + + +#### 2.10 单向通道 + +首先得知道, 一个通道, 它既可以被写, 也可以被读 + +但是, 我们可以限制什么情况下它只能被写, 什么情况下只能被读 + +就比如下面的例子, 通道 ch , 默认的可以对ch进行读写, 也可以像下面那样, 限制` inChannel`函数, 只能往通道里面写, 限制 outerChannel函数, 只能从通道里面读 + +```go +// 只能往里面写的通道如下: +func inChannel(ch chan<- int){ + ch <- 10 + close(ch) +} + +// 只能往外读 +func outerChannel( ch <-chan int){ + v:= <- ch + close(ch) +} + +``` + +#### 2.11 worker pool + +worker pool 实际上就是 goroutine 池 , + +```go +// 开启指定数量的 goroutine +func worker(number int, jobs <-chan int, results chan<- int) { + for i:=1;i<=number;i++{ + go func(i int) { + for j := range jobs { + fmt.Printf("worker:%d start job:%d\n", i, j) + time.Sleep(time.Second) + fmt.Printf("worker:%d end job:%d\n", i, j) + results <- j * 2 + } + }(i) + } +} + +func main() { + jobs := make(chan int, 100) + results := make(chan int, 100) + // 开启3个goroutine + worker(3, jobs, results) + // 添加5个任务 + for j := 1; j <= 5; j++ { + jobs <- j + } + close(jobs) + time.Sleep(time.Second*6) +} + +``` + + + +#### 2.12 select + +Go内置了select 关键字, 可以同时监听多个channel, 在接收和发送的过程中同样会发生阻塞等待 + + + +```go +select{ + case <-ch1: + ... + case data := <-ch2: + ... + case ch3<-data: + ... + default: + 默认操作 +} + +示例: +func main() { + ch1 := make(chan int) + ch2 := make(chan int) + select{ + case value1:=<-ch1: + fmt.Println("ch1",value1) + case value2 := <-ch2: + fmt.Println("ch2",value2) + default: + fmt.Println("default") + } +} +//结果: +default + + +// 示例2 +func main() { + ch1 := make(chan int,1) + ch2 := make(chan int,1) + ch1 <- 10 + ch2 <- 10 + + select{ + case value1:=<-ch1: + fmt.Println("ch1",value1) + case value2 := <-ch2: + fmt.Println("ch2",value2) + default: + fmt.Println("default") + } +} +结果: +ch1 10 + + + +// 示例3: +func main() { + ch1 := make(chan int,1) + ch2 := make(chan int,1) + ch3 := make(chan int,1) + ch4 := make(chan int,1) + ch5 := make(chan int,1) + ch6 := make(chan int,1) + ch7 := make(chan int,1) + ch1 <- 10 + ch2 <- 10 + ch3 <- 10 + ch4 <- 10 + ch5 <- 10 + ch6 <- 10 + ch7 <- 10 + + for i:=1;i<=8 ;i++ { + select{ + case value1:=<-ch1: + fmt.Println("ch1",value1) + case value2 := <-ch2: + fmt.Println("ch2",value2) + case value2 := <-ch3: + fmt.Println("ch3",value2) + case value2 := <-ch4: + fmt.Println("ch4",value2) + case value2 := <-ch5: + fmt.Println("ch5",value2) + case value2 := <-ch6: + fmt.Println("ch6",value2) + case value2 := <-ch7: + fmt.Println("ch7",value2) + default: + fmt.Println("default") + } + } +} + +// 结果: 表名 select会随机选中case进行处理 +ch2 10 +ch6 10 +ch5 10 +ch7 10 +ch3 10 +ch4 10 +ch1 10 +default + + +// 示例4: +func main() { + ch1 := make(chan int,1) + ch2 := make(chan int,1) + ch1 <- 10 + ch2 <- 10 + + for i:=1;i<=3 ;i++ { + select{ + case value1:=<-ch1: + fmt.Println("ch1",value1) + time.Sleep(time.Second*5) + case value2 := <-ch2: + fmt.Println("ch2",value2) + default: + fmt.Println("default") + } + } +} +// 证明, 任意一个case出现阻塞的情况, 整个select 都被阻塞 +``` + +select的好处: + +* 可处理一个或多个channel的发送/接收操作。 +* 如果多个`case`同时满足，`select`会随机选择一个。 +* 对于没有`case`的`select{}`会一直等待，可用于阻塞main函数 + + + + + +### 三. 并发和并行 + +什么是并发, 什么是并行? + +简单举例来说: + +* 两个队列，一个Coffee机器，那是并发 +* 两个队列，两个Coffee机器，那是并行 + +说白了其实就是如果我们的电脑只有一个CPU, 那最多只能做到并发 , 而 如果我们的电脑本身就是多核的, 多个CPU之间可以做大并行执行 , 那我们的go程序就可以变成并行 + +看这个示例: + +```go +var quit chan int = make(chan int) + +func loop() { + for i := 0; i < 10; i++ { + fmt.Printf("%d ", i) + } + quit <- 0 +} + +func main() { + // 在go1.5之前, 默认是1 + runtime.GOMAXPROCS(1) // 最多使用2个核 + // 开两个goroutine跑函数loop, loop函数负责打印10个数 + go loop() + go loop() + + for i := 0; i < 2; i++ { + <-quit + } +} + +``` + + + +如果将GOMAXPROCES设置值>1 , 则会出现争抢执行的效果 (go 1.5之后, 默认的GOMAXPROCES值才是 机器的最大的核心数) , 且, 只有当GOMAXPROCS设置的值大于1时, 才可能是真正的并行运行 + + + +还可以像这样, 显示的让CPU让出执行的时间 + +```go +func loop() { + for i := 0; i < 10; i++ { + runtime.Gosched() // 显式地让出CPU时间给其他goroutine + fmt.Printf("%d ", i) + } + quit <- 0 +} + + +func main() { + + go loop() + go loop() + + for i := 0; i < 2; i++ { + <- quit + } +} +结果: +0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 +``` + + + +### 四. runtime 调度器 + +* Gosched: 让当前goroutine让出cpu +* NumCPU: 返回当前系统的CPU核心数 +* GOMAXPROCS: 设置当前可同时使用的CPU数 +* Goexit: 退出当前goroutine , 但是 defer 依然会正常执行 + + + + + +### 五. 并发安全和锁 + +多个goroutine 操作同一个数据, 如果不加锁, 很容易出现并发异常, 导致数据不准确, 和Java一样, Go也提供了一些列的锁用来同步各个goroutine的计算过程 + + + +#### 5.1 互斥锁 + +出现线程安全的demo + +```go +var wait sync.WaitGroup + +var x int + +func add() { + for i := 1; i <= 5000; i++ { + x++ + } + wait.Done() +} + +func main() { + + wait.Add(2) + go add() + go add() + wait.Wait() + fmt.Println(x) // 7656 +} +``` + +解决: 互斥锁`sync.Mutex` 它的用法和java中的ReentranLock相仿, 示例如下 + +```go +var wait sync.WaitGroup +var lock sync.Mutex + +var x int + +func add() { + for i := 1; i <= 5000; i++ { + lock.lock() + x++ + lock.unlock() + } + wait.Done() +} + +func main() { + + wait.Add(2) + go add() + go add() + wait.Wait() + fmt.Println(x) // 7656 +} +``` + +> **使用 sync.Mutex 加锁, 被唤醒的几率是随机的** + + + +#### 5.2 读写锁 + +Go提供的读写锁是 `sync.RWMutex` + +遵循: + +* 读读不互斥 +* 读写互斥 +* 写写互斥 + +> 需要注意的是读写锁非常适合读多写少的场景，如果读和写的操作差别不大，读写锁的优势就发挥不出来。 + + + +#### 5.3 几个死锁的例子 + +1. 只在单一的goroutine里操作无缓冲信道，一定死锁。比如你只在main函数里操作信道: + +```go +func main() { + ch := make(chan int) + ch <- 1 // 1流入信道，堵塞当前线, 没人取走数据信道不会打开 + fmt.Println("This line code wont run") //在此行执行之前Go就会报死锁 +} +``` + +1. 如下也是一个死锁的例子: + +其中主线等ch1中的数据流出，ch1等ch2的数据流出，但是ch2等待数据流入，两个goroutine都在等，也就是死锁。 + +```go +var ch1 chan int = make(chan int) +var ch2 chan int = make(chan int) + +func say(s string) { + fmt.Println(s) + ch1 <- <- ch2 // ch1 等待 ch2流出的数据 +} + +func main() { + go say("hello") + <- ch1 // 堵塞主线 +} +``` + +1. 总结来看，为什么会死锁？非缓冲信道上如果发生了流入无流出，或者流出无流入，也就导致了死锁。或者这样理解 Go启动的所有goroutine里的非缓冲信道一定要一个线里存数据，一个线里取数据，要成对才行 。所以下面的示例一定死锁: + +```go +c, quit := make(chan int), make(chan int) + +go func() { + c <- 1 // c通道的数据没有被其他goroutine读取走，堵塞当前goroutine + quit <- 0 // quit始终没有办法写入数据 +}() + +<- quit // quit 等待数据的写 +``` + + + + + +#### 5.4 sync.WaitGroup + +我们一般都是使用它去防止main goroutine提前终止, 而中断子 goroutine + +他的作用和Java中的CountDownLatch相仿 + +| 方法名 | 功能 | +| ------------------------------- | ------------------- | +| (wg * WaitGroup) Add(delta int) | 计数器+delta | +| (wg *WaitGroup) Done() | 计数器-1 | +| (wg *WaitGroup) Wait() | 阻塞直到计数器变为0 | + +#### 5.5 sync.Once + +编程的很多场景下我们需要确保某些操作在高并发的场景下只执行一次，例如只加载一次配置文件、只关闭一次通道等。 + +`sync.Once`只有一个`Do`方法，其签名如下： + +```go +func (o *Once) Do(f func()) {} +``` + +实例如下: 只会打印一次 hi + +```go +var once sync.Once + +func add() { + for i := 1; i <= 5000; i++ { + once.Do(func() { + fmt.Println("hi") + }) + } + wait.Done() +} + +func main() { + wait.Add(2) + go add() + go add() + go add() + go add() + go add() + wait.Wait() +} +``` + + + +#### 5.6 单例模式 + +借助`sync.Once`的特性去做这件事 + +```go +type singleton struct { + name string +} +var once sync.Once +var instance *singleton + +func getInstance()(*singleton){ + once.Do(func() { + instance = &singleton{name:"tom"} + }) + return instance +} +``` + + + +#### 5.7 sync.Map + +Go语言中提供的原生map是不能保证并发安全的, 在sync包中的Map可以保证并发安全的特性 + +sync.Map 内置了诸如: `Store , Load , LoadOrStore , Delete , Range` 方法, 都可以保证线程安全 + + + +#### 5.8 原子操作 + +Demo + +```go +// 导入原子类相关的包 +import ( + "fmt" + "sync/atomic" +) + +func main() { + // 注意这里不能写 index := 1 , 因为下loadInt32, 编译都过不去 + index := int32(1) + // 传递地址 + loadInt32 := atomic.LoadInt32(&index) + // 添加的动作也是传递地址 + atomic.AddInt32(&loadInt32,1) + fmt.Println(loadInt32) +} + +``` + +* atomic常用的API如下: + +```go +// 加载一个原子类型的数 loadXXX +func LoadInt32(addr *int32) (val int32) +func LoadInt64(addr *int64) (val int64) +func LoadUint32(addr *uint32) (val uint32) +func LoadUint64(addr *uint64) (val uint64) +func LoadUintptr(addr *uintptr) (val uintptr) +func LoadPointer(addr *unsafe.Pointer) (val unsafe.Pointer) + +// 写入操作, 它会对原有的值进行一次覆盖 +func StoreInt32(addr *int32, val int32) +func StoreInt64(addr *int64, val int64) +func StoreUint32(addr *uint32, val uint32) +func StoreUint64(addr *uint64, val uint64) +func StoreUintptr(addr *uintptr, val uintptr) +func StorePointer(addr *unsafe.Pointer, val unsafe.Pointer) + +// 累加 +func AddInt32(addr *int32, delta int32) (new int32) +func AddInt64(addr *int64, delta int64) (new int64) +func AddUint32(addr *uint32, delta uint32) (new uint32) +func AddUint64(addr *uint64, delta uint64) (new uint64) +func AddUintptr(addr *uintptr, delta uintptr) (new uintptr) + +// 交换值 +func SwapInt32(addr *int32, new int32) (old int32) +func SwapInt64(addr *int64, new int64) (old int64) +func SwapUint32(addr *uint32, new uint32) (old uint32) +func SwapUint64(addr *uint64, new uint64) (old uint64) +func SwapUintptr(addr *uintptr, new uintptr) (old uintptr) +func SwapPointer(addr *unsafe.Pointer, new unsafe.Pointer) (old unsafe.Pointer) + +// CAS 比较+交换 +func CompareAndSwapInt32(addr *int32, old, new int32) (swapped bool) +func CompareAndSwapInt64(addr *int64, old, new int64) (swapped bool) +func CompareAndSwapUint32(addr *uint32, old, new uint32) (swapped bool) +func CompareAndSwapUint64(addr *uint64, old, new uint64) (swapped bool) +func CompareAndSwapUintptr(addr *uintptr, old, new uintptr) (swapped bool) +func CompareAndSwapPointer(addr *unsafe.Pointer, old, new unsafe.Pointer) (swapped bool) +``` + + + +#### 5.9 Cond + +条件等待Conｄ + +示例： + +```go +func main() { + condition:=false + + var lock sync.Mutex + cond:=sync.NewCond(&lock) + + go func() { + lock.Lock() + condition=true + // 模拟其他耗时操作 + time.Sleep(time.Second*3) + // 通过signal使得 + cond.Signal() + lock.Unlock() + }() + + + /* + 官方要求的写法 + c.L.Lock() + for !condition() { + c.Wait() + } + // 执行条件满足之后的动作... + c.L.Unlock() + */ + + lock.Lock() + // 为了防止虚假唤醒, wait放置到条件循环中 + for !condition{ + cond.Wait() + } + fmt.Println("条件满足, 开始后续的动作") + lock.Unlock() + +} +``` + +文档： + +```go +type Cond struct { + L Locker // 在“检查条件”或“更改条件”时 L 应该锁定。 +} + +// 创建一个条件等待 +func NewCond(l Locker) *Cond + +// Broadcast 唤醒所有等待的 Wait，建议在“更改条件”时锁定 c.L，更改完毕再解锁。 +func (c *Cond) Broadcast() + +// Signal 唤醒一个等待的 Wait，建议在“更改条件”时锁定 c.L，更改完毕再解锁。 +func (c *Cond) Signal() + +// Wait 会解锁 c.L 并进入等待状态，在被唤醒时，会重新锁定 c.L +func (c *Cond) Wait() +``` + + + +### 六. Pool 临时对象池 + +```go + +type Pool struct { + noCopy noCopy + + local unsafe.Pointer // local fixed-size per-P pool, actual type is [P]poolLocal + localSize uintptr // size of the local array + + // New optionally specifies a function to generate + // a value when Get would otherwise return nil. + // It may not be changed concurrently with calls to Get. + New func() interface{} +} + + +// Local per-P Pool appendix. +type poolLocalInternal struct { + private interface{} // Can be used only by the respective P. + shared []interface{} // Can be used by any P. + Mutex // Protects shared. +} + +type poolLocal struct { + poolLocalInternal + + // Prevents false sharing on widespread platforms with + // 128 mod (cache line size) = 0 . + pad [128 - unsafe.Sizeof(poolLocalInternal{})%128]byte +} +``` + +Pool 用于存储临时对象，它将使用完毕的对象存入对象池中，在需要的时候取出来重复使用，目的是为了避免重复创建相同的对象造成 GC 负担过重。其中存放的临时对象随时可能被 GC 回收掉（如果该对象不再被其它变量引用） + + + +从 Pool 中取出对象时，如果 Pool 中没有对象，将返回nil，但是如果给 Pool.New 字段指定了一个函数的话，Pool 将使用该函数创建一个新对象返回。 + + + + Pool 可以安全的在多个例程中并行使用，但 Pool 并不适用于所有空闲对象，Pool 应该用来管理并发的例程共享的临时对象，而不应该管理短寿命对象中的临时对象，因为这种情况下内存不能很好的分配，这些短寿命对象应该自己实现空闲列表。Pool 在开始使用之后，不能再被复制。 + + + +Pool是提供给外部使用的对象。其中的local成员的真实类型是一个poolLocal数组，localSize是数组长度。poolLocal是真正保存数据的地方。priveate保存了一个临时对象，shared是保存临时对象的数组。　　 + + + +为什么Pool中需要这么多poolLocal对象呢？实际上，Pool是给每个线程分配了一个poolLocal对象。也就是说local数组的长度，就是工作线程的数量(size := runtime.GOMAXPROCS(0))。当多线程在并发读写的时候，通常情况下都是在自己线程的poolLocal中存取数据。当自己线程的poolLocal中没有数据时，才会尝试加锁去其他线程的poolLocal中“偷”数据。 + +```go +func (p *Pool) Get() interface{} { + if race.Enabled { + race.Disable() + } + l := p.pin() //获取当前线程的poolLocal对象，也就是p.local[pid]。 + x := l.private + l.private = nil + runtime_procUnpin() + if x == nil { + l.Lock() + last := len(l.shared) - 1 + if last >= 0 { + x = l.shared[last] + l.shared = l.shared[:last] + } + l.Unlock() + if x == nil { + x = p.getSlow() + } + } + if race.Enabled { + race.Enable() + if x != nil { + race.Acquire(poolRaceAddr(x)) + } + } + if x == nil && p.New != nil { + x = p.New() + } + return x +} +``` + +为什么这里要锁住。答案在getSlow中。因为当shared中没有数据的时候，会尝试去其他的poolLocal的shared中偷数据。Pool.Get的时候，首先会在local数组中获取当前线程对应的poolLocal对象。如果private中有数据，则取出来直接返回。如果没有则先锁住shared，有数据则直接返回。 + + + +Go语言的goroutine虽然可以创建很多，但是真正能物理上并发运行的goroutine数量是有限的，是由runtime.GOMAXPROCS(0)设置的。所以这个Pool高效的设计的地方就在于将数据分散在了各个真正并发的线程中，每个线程优先从自己的poolLocal中获取数据，很大程度上降低了锁竞争。 + + + +### 七. 正确使用锁的八个注意点 + +1. 尽量减少锁的持有时间，毕竟使用锁是有代价的，通过减少锁的持有时间来减轻这个代价： + +* 细化锁的粒度。通过细化锁的粒度来减少锁的持有时间以及避免在持有锁操作的时候做各种耗时的操作。 +* 不要在持有锁的时候做 IO 操作。尽量只通过持有锁来保护 IO 操作需要的资源而不是 IO 操作本身： + +```go + +func doSomething() { + m.Lock() + item := ... + http.Get() // 各种耗时的 IO 操作 + m.Unlock() +} + +// 改为 +func doSomething() { + m.Lock() + item := ... + m.Unlock() + + http.Get() +} +``` + + + + + +2. 善用 defer 来确保在函数内正确释放了锁 + +尤其是在那些内部有好几个通过 if err != nil 判断来提前返回的函数中，通过 defer 可以确保不会遗漏释放锁操作，避免出现死锁问题，以及避免函数内非预期的 panic 导致死锁的问题： + +```go +func doSomething() { + m.Lock() + defer m.Unlock() + + err := ... + if err != nil { + return + } + + err = ... + if err != nil { + return + } + + ... + return +} +``` + +3. 不过使用 defer 的时候也要注意别因为习惯性的 defer m.Unlock() 导致无意中在持有锁的时候做了 IO 操作，出现了非预期的持有锁时间太长的问题。 + +```go +// 非预期的在持有锁期间做 IO 操作 +func doSomething() { + m.Lock() + defer m.Unlock() + + item := ... + http.Get() // 各种耗时的 IO 操作 +} +``` + + + +4. copy 结构体操作可能导致非预期的死锁 + +copy 结构体时，如果结构体中有锁的话，记得重新初始化一个锁对象，否则会出现非预期的死锁： + +```go +type User struct { + sync.Mutex + + name string +} + +func main() { + u1 := &User{name: "test"} + u1.Lock() + defer u1.Unlock() + + tmp := *u1 // 取出u1的值 + u2 := &tmp // 将指向u1的指针赋值给u2 , 实现结构体的拷贝 + // u2.Mutex = sync.Mutex{} // 没有这一行就会死锁 + + fmt.Printf("%#p\n", u1) + fmt.Printf("%#p\n", u2) + + u2.Lock() + defer u2.Unlock() +} +``` + + + +5. build/test 时使用 -race 参数以便运行时检测数据竞争问题 + +可以在执行 go build 或 go test 时增加一个 -race 参数来开启数据竞争检测功能，通过这种方式来实现在本地开发环境/CI/测试环境阶段发现程序中可能存在的数据竞争问题： + +```go +type Todo struct { + sync.Mutex + + tasks []string +} + +func (t *Todo) do() { + for _, task := range t.tasks { + fmt.Println(task) + } +} + +func (t *Todo) Add(task string) { + t.Lock() + defer t.Unlock() + + t.tasks = append(t.tasks, task) +} + +func main() { + t := &Todo{} + + for i := 0; i < 2; i++ { + go t.Add(fmt.Sprintf("%d", i)) + } + for i := 0; i < 2; i++ { + t.do() + } +} + + +///////// +$ go build -race -o main . +$ +$ ./main +================== +WARNING: DATA RACE +Read at 0x00c0000a0048 by main goroutine: + main.(*Todo).do() + /Users/xxx/tmp/golang/race/main.go:15 +0x42 + main.main() + /Users/xxx/tmp/golang/race/main.go:34 +0x154 + +Previous write at 0x00c0000a0048 by goroutine 6: + main.(*Todo).Add() + /Users/xxx/tmp/golang/race/main.go:24 +0x11d + +Goroutine 6 (finished) created at: + main.main() + /Users/xxx/tmp/golang/race/main.go:31 +0x127 +================== +0 +================== +WARNING: DATA RACE +Read at 0x00c0000b0010 by main goroutine: + main.(*Todo).do() + /Users/xxx/tmp/golang/race/main.go:15 +0x85 + main.main() + /Users/xxx/tmp/golang/race/main.go:34 +0x154 + +Previous write at 0x00c0000b0010 by goroutine 7: + main.(*Todo).Add() + /Users/xxx/tmp/golang/race/main.go:24 +0xe3 + +Goroutine 7 (finished) created at: + main.main() + /Users/xxx/tmp/golang/race/main.go:31 +0x127 +================== +1 +0 +1 +Found 2 data race(s) +``` + + + +6. 使用 go-deadlock 检测死锁或锁等待问题 + +上面说的在持有锁的时候做 IO 操作或其他非预期的耗时超时的问题，一方面需要在写程序的时候注意一下，另一方面也有可能是无意中代入进去的（比如上面提到的习惯性 defer 导致的）。对于那些无意中代入进去的锁等待的问题人为的去 review 的话通常很难发现，此时就需要用工具来检测了。恰好有一个叫 [go-deadlock](https://github.com/sasha-s/go-deadlock) 的工具可以实现这个功能。 ' + +```go +import ( + "net/http" + "time" + + sync "github.com/sasha-s/go-deadlock" +) + +var mu sync.Mutex +var url = "http://baidu.com:90" + +func do() { + mu.Lock() + defer mu.Unlock() + + u := url + http.Get(u) // 非预期的在持有锁期间做 IO 操作，导致锁等待时间变长 +} + +func main() { + // 检测超过 100 ms 的锁等待 + sync.Opts.DeadlockTimeout = time.Millisecond * 100 + + var wg sync.WaitGroup + for i := 0; i < 3; i++ { + wg.Add(1) + go func() { + defer wg.Done() + do() + }() + } + + wg.Wait() +} + +///////////////////////// +$ go run main.go +POTENTIAL DEADLOCK: +Previous place where the lock was grabbed +goroutine 36 lock 0x1483b90 +main.go:14 main.do { mu.Lock() } <<<<< +main.go:30 main.main.func1 { do() } + +Have been trying to lock it again for more than 100ms +goroutine 35 lock 0x1483b90 +main.go:14 main.do { mu.Lock() } <<<<< +main.go:30 main.main.func1 { do() } + +Here is what goroutine 36 doing now +goroutine 36 [select]: +net/http.(*Transport).getConn(0x14616c0, 0xc00015e150, 0x0, 0x128adb3, 0x4, 0xc000014100, 0xc, 0x0, 0x0, 0xc0000559e8) + /usr/local/Cellar/go/1.11/libexec/src/net/http/transport.go:1004 +0x58e +net/http.(*Transport).roundTrip(0x14616c0, 0xc000160000, 0x203000, 0xc000055c90, 0x11d823a) + /usr/local/Cellar/go/1.11/libexec/src/net/http/transport.go:451 +0x690 +net/http.(*Transport).RoundTrip(0x14616c0, 0xc000160000, 0x14616c0, 0x0, 0x0) + /usr/local/Cellar/go/1.11/libexec/src/net/http/roundtrip.go:17 +0x35 +net/http.send(0xc000160000, 0x12c78a0, 0x14616c0, 0x0, 0x0, 0x0, 0xc00000e030, 0x1708000, 0xc000055d20, 0x1) + /usr/local/Cellar/go/1.11/libexec/src/net/http/client.go:250 +0x14b +net/http.(*Client).send(0x1466200, 0xc000160000, 0x0, 0x0, 0x0, 0xc00000e030, 0x0, 0x1, 0x0) + /usr/local/Cellar/go/1.11/libexec/src/net/http/client.go:174 +0xfa +net/http.(*Client).do(0x1466200, 0xc000160000, 0x0, 0x0, 0x0) + /usr/local/Cellar/go/1.11/libexec/src/net/http/client.go:641 +0x2a8 +net/http.(*Client).Do(0x1466200, 0xc000160000, 0x128adb3, 0x13, 0x0) + /usr/local/Cellar/go/1.11/libexec/src/net/http/client.go:509 +0x35 +net/http.(*Client).Get(0x1466200, 0x128adb3, 0x13, 0xc0000220c0, 0x12412c0, 0xc000055f80) + /usr/local/Cellar/go/1.11/libexec/src/net/http/client.go:398 +0x9d +net/http.Get(0x128adb3, 0x13, 0x1483b90, 0x0, 0xc000114fb8) + /usr/local/Cellar/go/1.11/libexec/src/net/http/client.go:370 +0x41 +main.do() + /Users/xxx/tmp/golang/deadlock/main.go:18 +0x75 +main.main.func1(0xc00009c3f4) + /Users/xxx/tmp/golang/deadlock/main.go:30 +0x48 +created by main.main + /Users/xxx/tmp/golang/deadlock/main.go:28 +0x83 + +exit status 2 +``` + + + +7. 使用go mutux实现 tryLock功能: + + + +8. 改为使用 channel + +有些时候可能使用 channel 会更符合需求，对于这些更适合 channel 的场景可以改为使用 channel 而不是 lock \ No newline at end of file diff --git a/Go/其他教程/14网络编程/网络编程.md b/Go/其他教程/14网络编程/网络编程.md new file mode 100644 index 00000000..ea8df3d3 --- /dev/null +++ b/Go/其他教程/14网络编程/网络编程.md @@ -0,0 +1,631 @@ +## 一、net 包 + +### 1.1 Go-Tcp-Server + +思路, 通过Go提供的API创建出Server端, 然后做如下事 + +1. 创建Server服务端, 绑定监听ip +2. 监听端口 +3. 接受客户端请求, 建立连接 +4. 创建goroutine处理链接 + +```go +package main +import ( + "bufio" + "fmt" + "net" +) + +func process(conn net.Conn) { + defer conn.Close() + for { + reader := bufio.NewReader(conn) + var buf [128]byte + num, err := reader.Read(buf[:]) + if err != nil { + fmt.Printf("read from client error: %v\n", err) + return + } + reciveStr := string(buf[:num]) + fmt.Println("收到客户端的消息: ", reciveStr) + conn.Write([]byte(reciveStr)) + } +} + + +func RunServer(){ + + // 绑定ip , 监听端口 + listen, err := net.Listen("tcp", "127.0.0.1:20000") + if err != nil { + fmt.Printf("error: %v\n", err) + return + } + fmt.Println("server has been start") + // 接受连接 + for { + conn, err := listen.Accept() + if err != nil { + fmt.Printf("error: %v\n", err) + continue + } + // 开启goroutine处理连接 + go process(conn) + } +} + +func main() { + RunServer() +} + + +``` + +### 1.2 Go-Tcp-Client + +```go +package main + +import ( + "bufio" + "fmt" + "net" + "os" + "strings" +) + +func RunClient() { + conn, err := net.Dial("tcp", "127.0.0.1:20000") + if err != nil { + fmt.Printf("error: %v\n", err) + return + } + defer conn.Close() + fmt.Println("client has been start") + inputReader := bufio.NewReader(os.Stdin) + for { + // 处理用户输入 + line, err := inputReader.ReadString('\n') + if err != nil { + fmt.Printf("error: %v\n", err) + break + } + line = strings.TrimSpace(line) + + // 添加退出逻辑 + if strings.ToUpper(line) == "EXIT" { + break + } + // 发送消息 + _, err2 := conn.Write([]byte(line)) + if err2 != nil { + fmt.Printf("error: %v\n", err) + break + } + + // 从服务端读取消息 + arr := [512]byte{} + n ,err:=conn.Read(arr[:]) + if err != nil { + fmt.Printf("error: %v\n", err) + break + } + + // 输出消息 + fmt.Println("从服务端收到: ",string(arr[:n])) + } +} + +func main() { + RunClient() +} + +``` + +### 1.3 Tcp的黏包问题 + + + +#### 1.3.1为什么会出现TCP黏包的问题 + +* **原因之一: ** + + Nagle算法, 它是为了改善网络传输效率, 简单来说就是当我们想提交一部分数据发送出去, Nagle算法不会立刻就把数据发送走, 而是等待一小段时间, 看看还有没有其他的数据需要发送, 如果有的话就将这两段数据一起发送, 改善了网络传输的效率, 但是每次发送数据也变的不确定起来 + + + +* **原因之二:** + + 接收端接收不及时造成的接收端粘包：TCP会把接收到的数据存在自己的缓冲区中，然后通知应用层取数据。当应用层由于某些原因不能及时的把TCP的数据取出来，就会造成TCP缓冲区中存放了几段数据 + + + +#### 1.3.2 如何解决 + +出现”粘包”的关键在于接收方不确定将要传输的数据包的大小，因此我们可以对数据包进行封包和拆包的操作。 + +所以可以自定义协议去实现 + +```go +// 比如client 和 server 约定, 协议的前4个字节规定数据的长度 +// server先解析出数据的长度, 然后再去根据指定的长度读取数据就拿到完整的, 不粘连的数据 + + +// socket_stick/proto/proto.go +package proto + +import ( +"bufio" +"bytes" +"encoding/binary" +) + +// Encode 将消息编码 +func Encode(message string) ([]byte, error) { + // 读取消息的长度，转换成int32类型（占4个字节） + var length = int32(len(message)) + // pkg是指针, 指向带有缓存的buffer内存地址 + var pkg = new(bytes.Buffer) + // 写入消息头 , Write是将 最后一个参数写入 第一个参数的缓存中 + err := binary.Write(pkg, binary.LittleEndian, length) + if err != nil { + return nil, err + } + // 写入消息实体 + err = binary.Write(pkg, binary.LittleEndian, []byte(message)) + if err != nil { + return nil, err + } + return pkg.Bytes(), nil +} + +// Decode 解码消息 +func Decode(reader *bufio.Reader) (string, error) { + // 读取消息的长度 + lengthByte, _ := reader.Peek(4) + // 创建和消息长度相同的缓冲区 + lengthBuff := bytes.NewBuffer(lengthByte) + var length int32 + // todo 注意这里的read方法, 将缓冲区的长度读取入length中, 需要给他传递进一个指针进去 + err := binary.Read(lengthBuff, binary.LittleEndian, &length) + if err != nil { + return "", err + } + // Buffered返回缓冲中现有的可读取的字节数。 + if int32(reader.Buffered()) < length+4 { + return "", err + } + + // 创建 (4+数据长度)字节的切片, 临时存储 + pack := make([]byte, int(4+length)) + // 从reader里面读取当前大小的数据 4+下一条完整的信息的长度 大小的数据 + _, err = reader.Read(pack) + if err != nil { + return "", err + } + // 将开头的4字节切到, 剩下的就是完整的一条数据 + return string(pack[4:]), nil +} + +``` + + + +### 1.4 Go-UDP-Server + +```go +import ( + "fmt" + "net" +) +func main() { + listen, err := net.ListenUDP("udp", &net.UDPAddr{ + IP: net.IPv4(0, 0, 0, 0), + Port: 20000, + }) + + if err != nil { + fmt.Printf("error: %v\n", err) + return + } + + defer listen.Close() + + for { + // 读取 + arr := [1024]byte{} + n,addr,err:=listen.ReadFromUDP(arr[:]) + if err != nil { + fmt.Printf("error: %v\n", err) + continue + } + // 打印 + fmt.Printf("data:%v addr:%v count:%v",string(arr[:n]),addr,n) + + // 发送 + _,err=listen.WriteToUDP(arr[:n],addr) + if err != nil { + fmt.Printf("error: %v\n", err) + continue + } + } +} +``` + + + + + +### 1.5 Go-UDP-Client + + + +```go +import ( + "fmt" + "net" +) + +func main() { + listen,err:=net.DialUDP("udp",nil,&net.UDPAddr{ + IP: net.IPv4(0,0,0,0), + Port: 20000, + }) + if err != nil { + fmt.Printf("error: %v\n", err) + return + } + defer listen.Close() + + sendData:="hi server" + _,err=listen.Write([]byte(sendData)) + if err != nil { + fmt.Printf("error: %v\n", err) + return + } + + data:=make([]byte,4096) + n,addr,err:=listen.ReadFromUDP(data) + if err != nil { + fmt.Printf("error: %v\n", err) + return + } + fmt.Printf("data:%v addr:%v count:%v",string(data[:n]),addr,n) +} +``` + + + +## 二、http 包 + +### 2.1 Http、Https请求总览 + +Get、Head、Post和PostForm函数发出HTTP/HTTPS请求。 + +```go +resp, err := http.Get("http://example.com/") +... +resp, err := http.Post("http://example.com/upload", "image/jpeg", &buf) +... +resp, err := http.PostForm("http://example.com/form", + url.Values{"key": {"Value"}, "id": {"123"}}) +``` + +**程序在使用完response之后必须关闭回复的主体** + +```go +resp, err := http.Get("http://example.com/") +if err != nil { + // handle error +} +// do +defer resp.Body.Close() +body, err := ioutil.ReadAll(resp.Body) +// ... +``` + +### 2.2 默认的Server + +通过http包下面的 `ListenAndServe`方法可以启动一个HTTP服务器，处理器的参数通常默认为nil， 表示要使用默认的`DefaultServeMux`作为处理器 + +```go +http.Handle("/foo", fooHandler) +http.HandleFunc("/bar", func(w http.ResponseWriter, r *http.Request) { + fmt.Fprintf(w, "Hello, %q", html.EscapeString(r.URL.Path)) +}) +log.Fatal(http.ListenAndServe(":8080", nil)) +``` + + + +### 2.3 自定义Server + +```go +func main() { + myServer:=&http.Server{ + Addr: ":8080", + Handler: nil, + TLSConfig: nil, + ReadTimeout: 0, + ReadHeaderTimeout: 0, + WriteTimeout: 0, + IdleTimeout: 0, + MaxHeaderBytes: 0, + TLSNextProto: nil, + ConnState: nil, + ErrorLog: nil, + BaseContext: nil, + ConnContext: nil, + } + myServer.ListenAndServe() +} + +``` + +### 2.4 Get请求 + +#### 2.4.1 不带参数的Get请求 + + 发送http请求的Client端 + +```go +func main(){ + + res,err:=http.Get("http://www.baidu.com") + if err != nil { + fmt.Printf("error: %v\n", err) + return + } + + // 别忘记关闭响应体 + defer res.Body.Close() + + fmt.Println("res . status code",res.StatusCode) + fmt.Println("res . status proto",res.Proto) + data,err:=ioutil.ReadAll(res.Body) + if err != nil { + fmt.Printf("error: %v\n", err) + return + } + fmt.Println(string(data)) +} + +``` + +#### 2.4.2 带参数的Get请求 + +请求需要携带的参数， 使用内置的 net/url 标准库来实现 + +```go +func main(){ + + // 使用Go提供的url包添加参数 + apiUrl:="http://127.0.0.1:8888/get/info" + data:=url.Values{} + data.Set("name","tom") + data.Set("age","23") + u,err:=url.ParseRequestURI(apiUrl) + + if err != nil { + fmt.Printf("error: %v\n", err) + return + } + u.RawQuery = data.Encode() + + // 发送请求 + res,err:=http.Get(u.String()) + if err != nil { + fmt.Printf("error: %v\n", err) + return + } + defer res.Body.Close() + + bytes,err2:=ioutil.ReadAll(res.Body) + if err2 != nil { + fmt.Printf("error: %v\n", err) + return + } + + fmt.Println(string(bytes)) +} +``` + +编写server端验证 + +```go +func handler(writer http.ResponseWriter,request *http.Request) { + defer request.Body.Close() + data:=request.URL.Query() + name:=data.Get("name") + age:=data.Get("age") + fmt.Println(name,age) + str:=name+" : "+age + writer.Write([]byte(str)) +} + +func main(){ + // 添加路径与回调函数 + http.HandleFunc("/get/info/",handler) + // 开启服务器，绑定端口 + err:=http.ListenAndServe("127.0.0.1:8888",nil) + if err != nil { + fmt.Printf("error: %v\n", err) + return + } +} + +``` + + + +**注意点： 如果报错说 `**[Http: panic serving 127.0.0.1:34804; runtime error: invalid memory address](https://forum.golangbridge.org/t/http-panic-serving-127-0-0-1-34804-runtime-error-invalid-memory-address-or-nil-pointer-dereference/16922) ` 非法的内存地址， 那很可能我们在代码中的某一处， 没有做验证，直接使用一个nil类型的值** + + + +### 2.5 Post请求 + +Http-Server 端、接收client的POST请求 + +```go +func main() { + // 使用Go的http包， 模拟客户端发送Post请求 + url:="http://127.0.0.1:20000/addUserInfo" + + // 表单类型的数据 + contentType := "application/x-www-form-urlencoded" + // json对象类型 + //contentType:="application/json" + data:=`{"name":"tom","age":23}` + + res,err:=http.Post(url,contentType,strings.NewReader(data)) + if err != nil { + fmt.Printf("error: %v\n", err) + return + } + // 关闭Body + defer res.Body.Close() + + // + bytes,err:=ioutil.ReadAll(res.Body) + if err != nil { + fmt.Printf("error: %v\n", err) + return + } + fmt.Println("收到响应： ",string(bytes)) +} +``` + + + +如下Demo， 使用http发送 post请求 ，模拟提交表单数据 + +发送json类型的数据， 还是发送from表单类型的数据，使用contentType控制 + +```go +func handler(writer http.ResponseWriter, request *http.Request) { + // 不要忘记关闭Body + defer request.Body.Close() + err := request.ParseForm() + if err != nil { + fmt.Printf("error: %v\n", err) + return + } + + fmt.Println("请求表单为：", request.PostForm) + fmt.Println("表单中的参数为：", request.PostForm.Get("name"), " : ", request.PostForm.Get("age")) + + // 读取数据 + bytes, err := ioutil.ReadAll(request.Body) + if err != nil { + fmt.Printf("error: %v\n", err) + return + } + fmt.Println("接受到请求体为：", string(bytes)) + + // 写回响应数据 + res := `{"status"：200}` + writer.Write([]byte(res)) +} + +func main() { + http.HandleFunc("/addUserInfo", handler) + err := http.ListenAndServe("127.0.0.1:20000", nil) + if err != nil { + fmt.Printf("error: %v\n", err) + return + } +} +``` + + + +### 2.6 自定义Client + +要管理Http客户端的头部域，重定向策略，和其他设置，创建一个Client + +```go +func main() { + client := &http.Client{ + Transport: nil, + CheckRedirect: nil, + Jar: nil, + Timeout: 0, + } + + url := "http://www.baidu.com" + client.Get(url) + + req, err := http.NewRequest("GET", url, nil) + if err != nil { + fmt.Printf("error: %v\n", err) + return + } + req.Header.Add("If-None-Match",`W/"wyzzy"`) + + client.Do(req) +} + +``` + + + +### 2.7 自定义Transport + +自定义协议： 管理代理，TLS（也叫SSL,用于Https）、keep-alive、压缩和其他设置 + +```go + +func main() { + tr:= &http.Transport{ + Proxy: nil, + DialContext: nil, + Dial: nil, + DialTLSContext: nil, + DialTLS: nil, + TLSClientConfig: nil, + TLSHandshakeTimeout: 0, + DisableKeepAlives: false, + DisableCompression: false, + MaxIdleConns: 0, + MaxIdleConnsPerHost: 0, + MaxConnsPerHost: 0, + IdleConnTimeout: 0, + ResponseHeaderTimeout: 0, + ExpectContinueTimeout: 0, + TLSNextProto: nil, + ProxyConnectHeader: nil, + MaxResponseHeaderBytes: 0, + WriteBufferSize: 0, + ReadBufferSize: 0, + ForceAttemptHTTP2: false, + } + client := &http.Client{Transport: tr} + resp, err := client.Get("https://example.com") + +} + +``` + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Go/其他教程/15测试模块/Snipaste_2020-04-07_06-26-10.png b/Go/其他教程/15测试模块/Snipaste_2020-04-07_06-26-10.png new file mode 100644 index 0000000000000000000000000000000000000000..55230d3765722913222d34f2688009337954f107 GIT binary patch literal 2472 zcmY+^dpw)>9tZH~X1!ReyI@C4UtKR&DXOEWL{60wN;cY%2$njT6H4lqn`_riUu}tD z!J&D%-AXnY(U7Ph*+g6`8cC!=IPqFvXRq_e^ZcIg_xF3A*XQ};`@Z!> zc+lQG_Im&Tz+Px@Km-7=gKU0=?0V09C)~#v&CBj64{teLZaiHSRbv~Vs^ifCUUQ;21 z780{8r>q{}zpPVT*qN3b1C~z>sGO;8ywq5JX*!$3^e&-ge18|lyoj~px3k?+&hKv8 z94H=MTrWMF)OW5a)?*Y#<{{cbmxvV~)xj(>ytVmMiWR8S(I`-l0ca#$8Q|Z_)aHkh4qf)(B3v zi8kFjG>poTe)P*l&A0pWds(XK{`%zx-a}?QkQUfQ<3>~y*<^-FY#5Ozra4MAkJi0h z%h%;idDv9wRtU>Wh)1|EaScUnYN@8q=a^2PKdxGy#(GxvNp#mU|J z>y0+BNY_E!xzAZpTZ}ziBd+;Tu$QGnKljDm(&wTjTqzx|ZczCRV88Fx zGF-*PcC=h08+E;7rNZyaLCy)R%<^&jl?~?0-rWy2K1m8_GO0P`Uc%T#qGA1;n@(;k zb@*3a$<0>a-SYugJ<+p{%4k@hZOMIx1|)OiUArI?C@&;qSKk184=lweOO<2Qg#75| zFVrJ!qvBIqMP1(f%g$l%QnB2QcCDu@P~Nx(qvIhfoZ97?MUY5=ypEz{A;*5`AAPUr zUl@5mYoJEha1WIz5&eil!m}NjXI6f#0RrbcCeom$y4j(AYBtXX<{KWWs3f8e&1y;)#nsP zGb0aQzIY4B-+Yxa*Qvy#bt?1L(5w^TwKrwqQ#Tg^Em2?Eq)R(ll41b>ysFwdU6`3jaR8Z5#gBa_ zpZobv?{)yP*%1A%Gp4bwICiaa@x)H^{yml!)Vj69C3c!^i>BvO0wedCyD7EteN`=; zNhWb&`$2Qv|Ae0vGc21g_cOA|0q>jhgA59ei_6?!Nd&6=$r;#WZH*TwJAJy|F^oq1I@z28j zM#22OT*t}Pt1%hMHRW1xy|f4DXwu!iF`biyL6%G)^<3eRmd>7e!;!3!q8sq;>C`u6 z+MiUCw^aT{g^3z2`9%$$rB!5^Jbc*hC)J0*qcwyb`Ux&WN5imA1z(w?xG2bTP$Q+|mg;$wi4U;K&=s9(d6FH}LWf>aerCKaDywoKwIa z1g~sPR8nPAV?b6L1YVNO9sfOxG7DOB*csAsBF1j-9d1`iCV3?UJ0)45R)i`dvuk@v z(SlaBqVu9Un`LBl9W&LeB4D7!w1sUDFN$`IeMxk_VsURiDi+id^)$U=Mrp+2U`$ z_Bd(r@qtz{rBWAzT#gvKthK*?*g=Gxg0Mb}0bBfG{gLg-x5llB{xUA%`49{CgX@wjeuL)Z5`F#7EO9gZ z#zV!db9vr}&$q@|x{T9eymaDqv)?T~8KL+$lhhUulfT$xA7?6@i7^VFRiL* zNosKs^>Xr=h#CD)tU9;m1Wj_6*+@q&s{^5d7e^*nYdeRlEYd+NA#4B7Ea=gzw_?XV z@i@Y=cARIzV`DE4RWNwa0P|7!Rr9#v3dILZtEf- npz4OhU&Bc^3-P!iAMo7+Xq555Kf}zk41flP2Q>SC_04|)bEX_g literal 0 HcmV?d00001 diff --git a/Go/其他教程/15测试模块/Snipaste_2020-04-07_06-29-13.png b/Go/其他教程/15测试模块/Snipaste_2020-04-07_06-29-13.png new file mode 100644 index 0000000000000000000000000000000000000000..597815ead7310a757de6c6a384ebba03ec87e98b GIT binary patch literal 3605 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 literal 0 HcmV?d00001 diff --git a/Go/其他教程/15测试模块/Snipaste_2020-04-07_06-36-32.png b/Go/其他教程/15测试模块/Snipaste_2020-04-07_06-36-32.png new file mode 100644 index 0000000000000000000000000000000000000000..b2059d87d382de031af11da6eee1d7964e3171f3 GIT binary patch literal 5050 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 literal 0 HcmV?d00001 diff --git a/Go/其他教程/15测试模块/Snipaste_2020-04-07_06-52-02.png b/Go/其他教程/15测试模块/Snipaste_2020-04-07_06-52-02.png new file mode 100644 index 0000000000000000000000000000000000000000..dc8497fdac285c2d8309e668bdcbeeb1a54bf356 GIT binary patch literal 3620 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 literal 0 HcmV?d00001 diff --git a/Go/其他教程/15测试模块/Snipaste_2020-04-07_07-00-55.png b/Go/其他教程/15测试模块/Snipaste_2020-04-07_07-00-55.png new file mode 100644 index 0000000000000000000000000000000000000000..07ef109699afaae3f6ee79b3671e52e0aa18e218 GIT binary patch literal 7235 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 literal 0 HcmV?d00001 diff --git a/Go/其他教程/15测试模块/Snipaste_2020-04-07_07-03-11.png b/Go/其他教程/15测试模块/Snipaste_2020-04-07_07-03-11.png new file mode 100644 index 0000000000000000000000000000000000000000..e64796af342297aacc8559c999f9927aadfffa0d GIT binary patch literal 8248 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

8Hh%SSU1AagDmTh3cb{EFuV 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 literal 0 HcmV?d00001 diff --git a/Go/其他教程/15测试模块/Snipaste_2020-04-07_07-06-09.png b/Go/其他教程/15测试模块/Snipaste_2020-04-07_07-06-09.png new file mode 100644 index 0000000000000000000000000000000000000000..28433f6f80d6891924cef5db971ba7e67ccee6cd GIT binary patch literal 14456 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 Qu?%z)a@w8zeekva0Eabk5&!@I literal 0 HcmV?d00001 diff --git a/Go/其他教程/15测试模块/Snipaste_2020-04-07_07-30-40.png b/Go/其他教程/15测试模块/Snipaste_2020-04-07_07-30-40.png new file mode 100644 index 0000000000000000000000000000000000000000..859e4153433b841fb82921b24b9342ff34ad3071 GIT binary patch literal 5808 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 literal 0 HcmV?d00001 diff --git a/Go/其他教程/15测试模块/Snipaste_2020-04-07_07-47-12.png b/Go/其他教程/15测试模块/Snipaste_2020-04-07_07-47-12.png new file mode 100644 index 0000000000000000000000000000000000000000..81da4d575271980b95b3c697ee5d7c1f9dae3761 GIT binary patch literal 20982 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 literal 0 HcmV?d00001 diff --git a/Go/其他教程/15测试模块/Snipaste_2020-04-07_08-18-20.png b/Go/其他教程/15测试模块/Snipaste_2020-04-07_08-18-20.png new file mode 100644 index 0000000000000000000000000000000000000000..624360ba3bf62010f405a32ad6e07bf3611a923a GIT binary patch literal 5870 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 IrEC-VUx$|p`~Uy| literal 0 HcmV?d00001 diff --git a/Go/其他教程/15测试模块/Snipaste_2020-04-07_09-21-01.png b/Go/其他教程/15测试模块/Snipaste_2020-04-07_09-21-01.png new file mode 100644 index 0000000000000000000000000000000000000000..ff20165777be5c9db46e3896bfe7adf288049a9e GIT binary patch literal 45260 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

-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 X_p<5qS{-A6&Oo|%3~v|Rw0rVjx9ecz literal 0 HcmV?d00001 diff --git a/Go/其他教程/15测试模块/测试模块.md b/Go/其他教程/15测试模块/测试模块.md new file mode 100644 index 00000000..f7248d85 --- /dev/null +++ b/Go/其他教程/15测试模块/测试模块.md @@ -0,0 +1,639 @@ +### 一、go test 工具 + +Go为了我们提供了成体系内置的测试工具 + +测试依赖命令 `go test` + +按照约定，对于`go test`来说，所有以`_test.go` 为后缀名的源代码文件都是需要测试的一部分，而不会被`go build`命令编译进最终的可执行文件中 + +在`*test.go`中有三种类型的函数，单元测试函数，基准测试函数和示例函数 + +| 类型 | 格式 | 作用 | +| -------- | --------------------- | ---------------------- | +| 测试函数 | 函数名前缀为Test | 测试程序的逻辑是否正确 | +| 基准函数 | 函数名前缀为Benchmark | 测试函数性能 | +| 示例函数 | 前缀名为Example | 提供实例文档 | + +**当我们执行 `go test` 命令时， 遍历项目中所有的 `*_test.go` 文件中符合上述命名规则的函数，然后生成一个临时main包去调用相关的测试函数，然后运行 -> 构建测试结果 -> 清理测试生成的临时文件** + + + +### 二、测试函数 + +> **如果使用编译器为Golang , 可以不使用下面的命令...** , 但是使用命令行,有丰富的参数供我们选择 + +**使用测试函数主要是看看我们的代码能不能跑通** + +#### 2.1 格式： + +所有的测试函数都需要如下要求 + +* 导入 `testing`包 +* 函数名以Test开头 + +基本格式如下： + +```go +func TestAdd(t *testing.T){ + // ... +} +``` + +其中的参数t用来**报告测试失败和附加的日志信息**， testing t 还有如下的方法 + +```go +func (c *T) Error(args ...interface{}) +func (c *T) Errorf(format string, args ...interface{}) +func (c *T) Fail() +func (c *T) FailNow() +func (c *T) Failed() bool +func (c *T) Fatal(args ...interface{}) +func (c *T) Fatalf(format string, args ...interface{}) +func (c *T) Log(args ...interface{}) +func (c *T) Logf(format string, args ...interface{}) +func (c *T) Name() string +func (t *T) Parallel() +func (t *T) Run(name string, f func(t *T)) bool +func (c *T) Skip(args ...interface{}) +func (c *T) SkipNow() +func (c *T) Skipf(format string, args ...interface{}) +func (c *T) Skipped() bool +``` + +#### 2.2 示例： + +在测试之前， 我们得先有一个需要被测试的模块， 如下随便写个模块待会就测试它 + +```go +/*按照给定的sep， 完成str的切割*/ +func Split(str,sep string)(result []string){ + i:=strings.Index(str,sep) + for i>-1{ + result = append(result,str[:i]) + str = str[i+1:] + i=strings.Index(str,sep) + } + result = append(result,str) + return +} + +``` + +测试函数: + +```go +func TestSplit(t *testing.T) { + // 运行函数， 得到结果 + got:=Split("a:b:c",":") + // 期望的结果 + want:=[]string{"a","b","c"} + //slice不能直接进行比较， 借助反射包里卖弄的DeepEquals比较 + if !reflect.DeepEqual(got,want){ + // 使用T, 输出错误日志 + t.Errorf("except:%v , got:%v",want,got) + } +} +``` + + + +测试命令 : go test + +结果如下: + +![](Snipaste_2020-04-07_06-26-10.png) + + + +测试命令: go test -v + +**可以查看到测试函数是谁, 耗费了多少时间** + +![](Snipaste_2020-04-07_06-29-13.png) + + + +测试未通过, 会按我们预先的定义, 打印错误日志 + +![](Snipaste_2020-04-07_06-31-59.png) + + + +如果我们已经确定了未通过测试的函数的函数名, 我们通过`-run="FuncName"` 参数, 明确指定仅测试函数名为FuncName 的方法 , 他是一个正则表达式, 当函数名匹配上时, 才会被 go test 运行 + +![](Snipaste_2020-04-07_06-36-32.png) + + + +如果我们通过-run="不存在的方法名" , go test 会提示我们没有可以测试的函数 + +![](Snipaste_2020-04-07_06-37-22.png) + + + +### 三、测试组 + +使用测试组一次性测试多组数据 + +```go +func TestSplit(t *testing.T) { + // 定义测试类型 + type test struct { + input string + seq string + want []string + } + // 定义存储测试用例的切片 + tests:=[]test{ + {input:"a:b:c",seq:":",want:[]string{"a","b","c"}}, + {input:"a:b:c",seq:",",want:[]string{"a:b:c"}}, + {input:"abcd",seq:"bc",want:[]string{"a","d"}}, + } + + // 遍历切片,测试 + for _,tc:=range tests{ + got:=Split(tc.input,tc.seq) + if !reflect.DeepEqual(got,tc.want){ + t.Errorf("got:%#v , want:%#v",got,tc.want) + } + } +} +``` + +测试: + +![](Snipaste_2020-04-07_06-52-02.png) + + + +### 四、子测试 + +上面的测试组是存在问题的, 测试组中可能有多个测试, 但是我们没办法一眼就判断出测试组中那个测试出现问题了 , 这时可以考虑子测试 + + + +* 我们可以使用map去解决这个事, 将上面的切片换成map + +```go + +/* + 1. 方法名以Test开头 + 2. 参数位置传入参数 *testing.T +*/ +func TestSplit(t *testing.T) { + // 定义测试类型 + type test struct { + input string + seq string + want []string + } + // 定义存储测试用例的切片 + tests:=map[string]test{ + "t1":{input:"a:b:c",seq:":",want:[]string{"a","b","c"}}, + "t2":{input:"a:b:c",seq:",",want:[]string{"a:b:c"}}, + "t3":{input:"abcd",seq:"bc",want:[]string{"a","d"}}, + } + + // 遍历切片,测试 + for _,tc:=range tests{ + got:=Split(tc.input,tc.seq) + if !reflect.DeepEqual(got,tc.want){ + t.Errorf("got:%#v , want:%#v",got,tc.want) + } + } +} + +``` + + + +* Go1.7中也添加了测试组 , 我们可以按照如下的方式执行 t.Run 执行子测试 + +```go +/* + 1. 方法名以Test开头 + 2. 参数位置传入参数 *testing.T +*/ +func TestSplit(t *testing.T) { + // 定义测试类型 + type test struct { + input string + seq string + want []string + } + // 定义存储测试用例的切片 + tests:=map[string]test{ + "t1":{input:"a:b:c",seq:":",want:[]string{"a","b","c"}}, + "t2":{input:"a:b:c",seq:",",want:[]string{"a:b:c"}}, + "t3":{input:"abcd",seq:"bc",want:[]string{"a","d"}}, + } + + // 遍历切片,测试 + for key,tc:=range tests{ + // 使用,t.Run(name,func) 完成子测试 + t.Run(key, func(t *testing.T) { + got:=Split(tc.input,tc.seq) + if !reflect.DeepEqual(got,tc.want){ + t.Errorf("got:%#v , want:%#v",got,tc.want) + } + }) + } +} +``` + + + +测试结果: + +![](Snipaste_2020-04-07_07-00-55.png) + + + +### 五、测试覆盖率 + +测试覆盖率是你的代码被测试套件覆盖的百分比。通常我们使用的都是语句的覆盖率，也就是在测试中至少被运行一次的代码占总代码的比例。 + + + +Go提供内置功能来检查你的代码覆盖率。我们可以使用`go test -cover`来查看测试覆盖率。例如 + +![](Snipaste_2020-04-07_07-03-11.png) + + + +也可以使用 -coverprofile 参数, 将覆盖率输出到每一个具体的文件 + +```bash +go test -v -coverprofile=./c.out +``` + +查看生成结果 + +![](Snipaste_2020-04-07_07-06-09.png) + + + +使用如下命令, 将c.out 文件以html的形式打开 + +```go +go tool cover -html=c.out +``` + +![](C:\Users\acer\AppData\Local\Temp\1586214486688.png) + +红色部分是未被覆盖的部分 + + + +### 六、基准测试 + +基准测试目的是检测程序的性能 + +命名格式要求 + +* 测试函数以 `benchMarkXXX` 为前缀 +* 入参位置需要参数 `*testing.B` + +```go +func BenchmarkName(b *testing.B){ + // ... +} +``` + + + +`testing.B`有如下的方法 + +```go +func (c *B) Error(args ...interface{}) +func (c *B) Errorf(format string, args ...interface{}) +func (c *B) Fail() +func (c *B) FailNow() +func (c *B) Failed() bool +func (c *B) Fatal(args ...interface{}) +func (c *B) Fatalf(format string, args ...interface{}) +func (c *B) Log(args ...interface{}) +func (c *B) Logf(format string, args ...interface{}) +func (c *B) Name() string +func (b *B) ReportAllocs() +func (b *B) ResetTimer() +func (b *B) Run(name string, f func(b *B)) bool +func (b *B) RunParallel(body func(*PB)) +func (b *B) SetBytes(n int64) +func (b *B) SetParallelism(p int) +func (c *B) Skip(args ...interface{}) +func (c *B) SkipNow() +func (c *B) Skipf(format string, args ...interface{}) +func (c *B) Skipped() bool +func (b *B) StartTimer() +func (b *B) StopTimer() +``` + + + +#### 6.1 基准测试示例 + +```go +func BenchmarkSplit(t *testing.B) { + for i:=0;i + + + +### flag的参数类型 + +flag包支持的命令行参数类型有`bool`、`int`、`int64`、`uint`、`uint64`、`float` `float64`、`string`、`duration`。 + +| flag参数 | 有效值 | +| ------------ | ------------------------------------------------------------ | +| 字符串flag | 合法字符串 | +| 整数flag | 1234、0664、0x1234等类型，也可以是负数。 | +| 浮点数flag | 合法浮点数 | +| bool类型flag | 1, 0, t, f, T, F, true, false, TRUE, FALSE, True, False。 | +| 时间段flag | 任何合法的时间段字符串。如”300ms”、”-1.5h”、”2h45m”。 合法的单位有”ns”、”us” /“µs”、”ms”、”s”、”m”、”h”。 | + +###注册flag参数的方式 + +#### 将结果保存在 `*type`指针中 + +```go + import "flag" + + // flag.type 的返回值是指针 + var ip = flag.Int("flagname", 1234, "help message for flagname") + ip := flag.Int("flagname", 1234, "help message for flagname") +``` + +#### 将结果保存在变量中 + +```go + var flagvar int + flag.IntVar(&flagvar, "flagname", 1234, "help message for flagname") +``` + +#### 自定义flag类型 + +```go +// 默认值就是该变量的初始值。 +flag.Var(&flagVal, "name", "help message for flagname") +``` + + + +### `flagParse()` + +**所有的flag完成注册之后， 使用函数`flag.Parse()` 进行解析** + +解析后，注册进flag的参数可以通过`flag.Args() ` 或者`flag.Args(i)`取出 + +- `-flag xxx` （使用空格，一个`-`符号） +- `--flag xxx` （使用空格，两个`-`符号） +- `-flag=xxx` （使用等号，一个`-`符号） +- `--flag=xxx` （使用等号，两个`-`符号） + + + +其他flag函数 + +```go +flag.Args() ////返回命令行参数后的其他参数，以[]string类型 +flag.NArg() //返回命令行参数后的其他参数个数 +flag.NFlag() //返回使用的命令行参数个数 +``` + + + +### 示例 + +```go +func main() { + //定义命令行参数方式1 + var name string + var age int + var married bool + var delay time.Duration + flag.StringVar(&name, "name", "张三", "姓名") + flag.IntVar(&age, "age", 18, "年龄") + flag.BoolVar(&married, "married", false, "婚否") + flag.DurationVar(&delay, "d", 0, "延迟的时间间隔") + + //解析命令行参数 + flag.Parse() + fmt.Println(name, age, married, delay) + //返回命令行参数后的其他参数 + fmt.Println(flag.Args()) + //返回命令行参数后的其他参数个数 + fmt.Println(flag.NArg()) + //返回使用的命令行参数个数 + fmt.Println(flag.NFlag()) +} +``` + +命令行参数提示： + +```go +$ ./flag_demo -help +Usage of ./flag_demo: + -age int + 年龄 (default 18) + -d duration + 时间间隔 + -married + 婚否 + -name string + 姓名 (default "张三") +``` + +正常使用命令行flag参数 + +```go +$ ./flag_demo -name 沙河娜扎 --age 28 -married=false -d=1h30m +沙河娜扎 28 false 1h30m0s +[] +0 +4 +``` + + + + + + + + + + + +### os.Args + +如果不想使用flag标准库可以使用os.Args简单的获取到命令行参数 + +```go +func main() { + if len(os.Args) > 0{ + for index,args :=range os.Args{ + fmt.Printf("index: %v value:%v",index,args) + } + } +} +``` + +os.Args中，存储启动编译好的go文件时输入的所有参数， **第一个参数是可执行文件本身** \ No newline at end of file diff --git a/Go/其他教程/18gomodule/Snipaste_2020-04-10_08-08-25.png b/Go/其他教程/18gomodule/Snipaste_2020-04-10_08-08-25.png new file mode 100644 index 0000000000000000000000000000000000000000..e97e5ebaa535a96f0482f5f00d29b5326b749b58 GIT binary patch literal 6199 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 Hul@Ev+8C-h literal 0 HcmV?d00001 diff --git a/Go/其他教程/18gomodule/Snipaste_2020-04-10_08-09-56.png b/Go/其他教程/18gomodule/Snipaste_2020-04-10_08-09-56.png new file mode 100644 index 0000000000000000000000000000000000000000..a53373b8d01cbfd3b02a51546443e3bbba2f7d70 GIT binary patch literal 5780 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 W9J5$OX%s6y09fa-cBz*A>;D2CoCwqa literal 0 HcmV?d00001 diff --git a/Go/其他教程/18gomodule/Snipaste_2020-04-10_08-11-08.png b/Go/其他教程/18gomodule/Snipaste_2020-04-10_08-11-08.png new file mode 100644 index 0000000000000000000000000000000000000000..3c11f709d339c27e649bfaed427ea3c592f8d3fd GIT binary patch literal 9607 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 AQUCw| literal 0 HcmV?d00001 diff --git a/Go/其他教程/18gomodule/Snipaste_2020-04-10_08-18-47.png b/Go/其他教程/18gomodule/Snipaste_2020-04-10_08-18-47.png new file mode 100644 index 0000000000000000000000000000000000000000..e1c24c118ad56c1f501529b2c55ff378b73ce991 GIT binary patch literal 4571 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 ZkRW+8JO7>J?Z5V8f7R(q&EN0*`kx4rs=xpM literal 0 HcmV?d00001 diff --git a/Go/其他教程/18gomodule/Snipaste_2020-04-10_08-20-16.png b/Go/其他教程/18gomodule/Snipaste_2020-04-10_08-20-16.png new file mode 100644 index 0000000000000000000000000000000000000000..6d5d006cec6014b6873226f87e48a9b9f8e9f2dd GIT binary patch literal 4866 zcmdT|XH-*JxV_2#eumdOu$I^?uxQ?mFvRcYWvFeZFt+od~fq z6+0qx1ONaru-Oe;064H9c+dJ-STIi7^;8L_!@*|GVE`ch@t@~Fri!?%VDUGEi4(#u z$OnPE6Y34v1^Ncx2}5|pBnQ3%z_Bdw4P$6z{?gZIe<<}~_m3$eTxv&ZT%*1_8?N~C z1?>=^q!|`a&%B-|0`;pua_k`PP=jr-t?-9%kM&*Rg#S!50B% zs`>lA8~p0x2a!K%0f2;J(E;GiuLs0{2MIsl0|3<Rv%`p5;8- z`1<1cg%NneWc8qG$Vf;8L{tZT6IuPm<{Px)U`j?5df9Ea@~Q_R{Lg)IVU(fcyd*18 zH$G~<3-Xz7WdhRd&2DNAC&TMhD_r{ngfyusAzfNKW9TN`X7wwkqP%!LjhRw6rPmS8 zB*Wh9MYf{nQqL+|?&myv_)xi`hdL;=Mn=<8-6yW5TEDG%xscu|g{+Rfs_sZ3b6W#_ z8hCY$Z(QfCh2hQTJVSXxQB{oG_VH!vg^aCE$YpO*=y48)SkC08&^onq3JT`rDLR{8 zc(u5jyb}wb-2ys;x*qn~UrowXy8!vtr%N1M%}IXk>33`YY$w*BZ}H#q&^$LpQx4~T ze$tRm>znvaPESCy?tNdp^czoEGqUZB9Z4@<=j3)2Dp`4r-^-BWf!BMK0~!6pWF(wD zW9r--)Z|*OT!dEeVdJ#rrO6dpQ)`6D5U3rjN@NEXHSStTUz^@FHI%Q9GOKDs?zvUz)5a1#%V@vRyM*+jyMU zWS$m>&wcU>H!!|5`(1iMlRF42Yxq+|b2V!=7QQ9pTC5z%cj5=BaPPS;%#RvnVa0A( zqf;&h@#5)I(j%WBdH8ivqCJ(11f8ME9S=w%baR-*6t>>W@6uTs&UEMuMR>CZ{&7sF z+n{4OK!+AatT=zGBA!N1Wy{2>rj~V!f;{Ul#Dx@xs@F5g_kRQw+*4KZ!)V3erj3?U zH<02BD(6tmpeI=W2=XRcDzX*b^0$Sp{o)G+TKZd;G1^IKw;i@7{y`k(Wi?JHLl%J z=^l_127CB+c2t$hk66lf0-eQFU=|M5Mw|rm_2Zj=2Z!EoYq1{mU{mWAF%h#H%!-ph*@bSD?yNq0*_{w$pNVvgP_VM~*WjXGv>GDruBCMaDO z?V*a@y}ienyu~K^w=^px#^9D90&75QnrK#8s|__Xjrwp$tw8+w&Z+rP#mq|ArG3f$ zp&OoQG0|r|g%PFiT!X~Kvs#9zH9Fpe7+V5}#5lUaqS+XqlHYvX#VnjggYdZ-TN<8k z5n1}T0{)&{*aNRNXt;xLFQl!_8JQp1ci%1@AZZH)$@WUgRSEee!cNjaMLM(h+8u3Y zYEQ#h4l|t{j9>7}OGS4Fh5d*1w9d}<*$_M8wk*8{+ya8(Oz3S$eLc#*7%*QmH%2+U z)Vi7)oE!czm44THSwtA&EWiEsY+3O4pgy;+F1j1vD`vXxKH9i}8hlj^-|A zy7zy~R%(9!JGlHx{lwNTgCoNEdjC(l9kf)a*q6WX!Bv;LuM$)s`O2ijf)W&D&ugO<^Q92VSF4&s10;&YwFsUY1ZE zm!CTDEbdHr6SVwvffcu{wh?kpQ1`ZW#}vkty7pgfB?g4fuOHMO=@wz0nKt@N_#$7hS^2P4kJXX8>0?eC&eTnvxkCqrho;-gwD z@h(frF-V%=j-mrnK94_2V=k6%i%{^oc=t<(lC6y+%~zpRd(dcz+M4=Ou)K_I-b6<3 zllyWq&vH|$2GpOc=1V7OT%<@emXzys3d%-!(ToHrN7kcT;St&|3{|J5{sYmjIY#J2 zlkksP&7z<8lFDN+G3dX0I3aI8FRRLi{jj_2na13(AlPW0>?+6$w&-RTJ{AsK;8flk zOVKRaKPqm*wbtX7!j!sRq&Uh55Rf@4jj#+4@uCpV`dTK6S0}b(^HnQajYO`b?8L4` zK4sl}{d0|BggySE!%}&A&u2Cw<&2nhbO$HR)jEN$V%h)4^5OB{nhiEfKHQc23+2zz zu5C;`nu&qQu?2vn6uDwBcy)?zqbN0AuOOo$pzIS}La%H6;i)B=@U79})4EOWa@qQC zm;N~z{Q;4rX*OzjDOi9Gi;B969)eI)qGN~xo0$%k^2Hpxw&EpaS4m1RZ`=Z#$EseY zV7N@x!*+)x2fsF22g!~_g&;NiU{XYy< zyW?Q^syS%nV?fPLR}ybyHwj*30zAl>$@M=Z=zn-Mq+&-yJ{$U#_IIzteUKf|%~WTQ zoG^tYZFq<%IZ|1soDqq_N&esb^!&E8xDr|MT&GNKM36;KH}l9W1%Y1@aw>WSt-! zDYL{{`RJ{RZ9@*3I?u+bVeo5P)(D?tyZ(Z_pRT0E?hg`+JvDrQ+bWK)z9na#e{&A^ zft^nGfnU`Zo3AULo+xEIbNiQEhWAq3WB9FF4uzyjZ#;W>=&cM@C-M*x>PB9XkiYI0J`kw}F zmzTzf3HT0sRvVipwtYyiQG=7sB!3AKE3~0PCGS7op`)q{ZM7m?EyHW&SCPzspgS{q z8w+}h-C8sr50ucXZrFDJtIwX|?s!QUcXDOUZ(VZT>!Js#0W(19@W(29RxcE8#8jRs zW+c?8nQpYjfT#A1GYn)HKQ<>LJ@$uwm8)hq#9FytEF5Kf6Y8S9w@@Yurs;J)uN^9l zJFZnH4&KAW6}@w`N@g>Hy!AUWOX!_k-{O%ZZQY+Camnugz&KNzJLNlTt&k5eZ%^LZ}&N3ck>q&z>aoe6hzIWJ9*1A^Sg;o``+h`Xp|9VJtQ;Y3tjV0H^ zUozEK(o?h^KZ>E)2aJVXL@c7{{JzU=Z`6v^J0iTdmGjzQX&ISPe8wd4h33qaQTw2Z? zSh>2ZH>$L>>I0S$UpR-Hsbob#_+y1LwP}3%={-EZ#jFzN(FXc=;4alNA(># zEad#NJ$_skbKUn;zZO>ZFc$){elcs7JMnA<0gYvtfSi~M*8A=Rw6xPNkuTUxqRArOdwoSicDDVI1u+fp|+kxfb!f4css-)IB&RMT8*EPI~w@r2wvVwq(# zyxsg9(bB2;`nq{p%FA_g_~Ckn7PBwM0bTs|x`Ai*oG|dkdppKpJEr~dFHaQi`}vvc z=I8ASr4N?m4#n19(E^Y1;qiX`Uxo+tmC)9iGl-vFNjy%FL|G;>6c(!Rb)lBWy#Eya zEQ7Iz354!OFsyY%(Zd<{Qq}oYlBBv{a4>{Mqq#H&7oTNjSQ`v~yUjuh>+e?-$-G3_ zx8QCNW!gtuH{DWLtvCu}E1tL4LLwt2S>M)hEuJ}ypExAhe%^nw$ck;LxQy$`i9EDa7gEWHSLE zP=0_#WIsRK-%@6_y^Zp_e?Mbz-VTXupwpGGk)LLy>`MCi4TPBma@4eAq9gp5sUuL{ zY<2Hfa36Bt9pr|xRX4b@w^@Av&{PjCNmrrjh0n6I)tufKWvP28GBZ*R_E0StyR!-pBgHOWhRmr-5{5w zMiN9NN9c6?+FGcZOPyI@gZ_`ntQ4ky3-oeaFQ;AxcwiXj{P2A^dgn)X2>de$1mbNm zFei@+6A?^XU2%9109a&I{ixBF4M!k)mLf3Df>ZXIEOiLcx5}VjytV!ZVfM`X13*u9 z&mYVGG$zp4*x1!Ohv4ogrwSGMku!V`Qmf&f1>YSv=r4Kz$WBl^P+%dY{JkZvM!xzQ zP7=8Um8IeYANUJw86x}6DKm4nIdo2H`Y2!|9HOl8?=Fnvt50_T;I>bb0dIy}DfT7M zHFxJx?IDVb%^%@)`B@*e1%}P#Pud}Ak+u8I!kg2=!0+!!NA7jwsCk%mG#miRk0c2U ftN&>4aQ2JnX!jGG6%&Df1%OSgZd6~t{peo+F)>js literal 0 HcmV?d00001 diff --git a/Go/其他教程/18gomodule/Snipaste_2020-04-10_08-21-14.png b/Go/其他教程/18gomodule/Snipaste_2020-04-10_08-21-14.png new file mode 100644 index 0000000000000000000000000000000000000000..7cf81b0d301e9dd5290e1cc640362db60b12030b GIT binary patch literal 9402 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 literal 0 HcmV?d00001 diff --git a/Go/其他教程/18gomodule/go-module.md b/Go/其他教程/18gomodule/go-module.md new file mode 100644 index 00000000..472bbae3 --- /dev/null +++ b/Go/其他教程/18gomodule/go-module.md @@ -0,0 +1,187 @@ +### 一. go-module + +在Go的1.11版本之后， 官方推出了版本管理工具，并且从G1.13版本之后， go module 将成为Go默认的版本依赖工具 + + + +### 二. GO111MODULE + +要启用`go module` 支持首先需要配置环境变量 ， `GO111MODULE` 通过他可以开启或者关闭模块支持 ， 它有如下三个可选值 + +* `GO111MODULE=off` 禁用模块支持， 编译时会从 GOPATH和Vendor文件夹中查找依赖 +* `GO111MODULE=on` 启用模块支持，编译时会忽略GOPATH和Vendor ， 直接从 `go.mod`中查找配置 +* `GO111MODULE=auto` 当前项目在 $Path/src 外， 且根路径有`go.mod`时开启模块支持 + + + +**一般我们使用 on 就可以了 , 这也就意味着, 以后写代码,不用必须在goPath中编写了, 任何地方都可以写** + +当我们启用模块支持后, go module将在我们项目的根路径下生成两个文件,` go.mod 和 go.sum` + +通过`go get`命令可以查找生成当前项目中的依赖关系, 同时生成一个`go.sum`记录每一个依赖库的版本和hash + + + +### 三. 设置代理 + +很多库都是谷歌公司自己出的, 但是在国内, 谷歌被强了, 故我们设置代理, 间接访问 + +Go1.11之后的版本设置 + +```bash +# 在windowsshang +set GOPROXY=https://goproxy.cn +# mac +export GOPROXY=https://goproxy.cn +``` + +Go1.13之后设置 + +``` +go env -w GOPROXY=https://goproxy.cn,direct +``` + + + +### 四. 常见命令 + +```bash +go mod init # 初始化,创建go.mod +go mod download # 下载依赖的module到本地的cache中, 默认是 $GOPATH/pkg/mod + +go mod edit # 编辑go.mod文件 +go mod edit -fmt # 快捷格式化go.mod文件 + +go mod graph # 打印模块依赖图 +go mod tidy # 添加缺失的mod, 删除没有的module +go mod vendor # 将依赖复制到vendor中 +go mod verify # 校验依赖 +go mod why # 解释为什么需要依赖 +``` + + + +### 五. 示例: + +* 开启 + +```bash +# go1.13版本后, go mod默认是开启的 +# 通过如下命令 go env 可以看到 GO111MODULE +# 如果没有开启的话, 我们使用 如下命令开启 +# windows +set GO111MODULE=on +# mac +export GO111MODULE=on +``` + +![](Snipaste_2020-04-10_08-08-25.png) + + + +* 初始化 + +```go +go mod init +``` + +![](Snipaste_2020-04-10_08-09-56.png) + + + +查看文件内容 + +![](Snipaste_2020-04-10_08-11-08.png) + + + + + +* 设置代理 + +```go +go env -w GOPROXY=https://goproxy.cn,direct +``` + + + +比如 , 我们依赖了 github上的库, 那go原生没有的代码, 我们只能去github上下载 + +![](Snipaste_2020-04-10_08-20-16.png) + +结果如下: + +![](Snipaste_2020-04-10_08-18-47.png) + + + +下载的位置: 默认会下载到 $GOPATH / pkg 目录下面 + +![](Snipaste_2020-04-10_08-21-14.png) + + + + + +再次查看go.mod文件可以发现已经将我们下载的文件加入进去了 + +![](Snipaste_2020-04-10_08-22-03.png) + + + +默认`go get`下载的都是最新的版本, 我们可以通过去github上找一个自己需要的版本, 然后明确下载它在 + +github上的某一个分支, 因为每一个分支都有tag , 下载时, 指定tag就ok + + + +第一步: 改`go.mod` 将其换成我们希望的版本 + +![](Snipaste_2020-04-10_08-27-34.png) + + + +第二步: 校验是否存在: `go mod verify` + +如果存在, 返回 all modules verified + +如果不存在,返回 Not Found + + + +第三步: 使用 `go mod download` 下载指定的依赖 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Go/其他教程/19mysqlx/mysqlx.md b/Go/其他教程/19mysqlx/mysqlx.md new file mode 100644 index 00000000..9f79f2bc --- /dev/null +++ b/Go/其他教程/19mysqlx/mysqlx.md @@ -0,0 +1,455 @@ +### 一. mysql + +go-sql-driver : + +#### 1.1 下载 + +``` +go get -u github.com/go-sql-driver/mysql +``` + +但是手动下载时, golang导入时很不好用, 基本上是导入不了, 一直爆红 + +如果用golang开发, 不如是用快捷键下载 + +### 二. 编码 + +#### 2.1 实体的封装结构体 + +```go +// 实体的结构体 +type user struct { + id int + name string +} +``` + + + +#### 2.2 初始化连接 + +```go +// 初始化连接 +func initDB() (err error) { + db, err = sql.Open("mysql", "root:root@tcp(127.0.0.1:3306)/test") + if err != nil { + panic(err) + } + // todo 不要在这里关闭它, 函数一结束,defer就执行了 + // defer db.Close() + err = db.Ping() + if err != nil { + return err + } + return nil +} +``` + + + +#### 2.3 设置最大连接数, 最大空闲数 + +通过如下两个函数, 设置数据库连接池的最大连接数和连接池中的最大空闲数 + +```go +// 默认n是0, 表示没有设置最大上限 , 如果n<0 , 表示不设置最大连接 +func (db *DB) SetMaxOpenConns(n int) + +// 如果最大空闲数比最大连接数还大, 那么最大空闲数 会被设置成 最大连接数 +// 如果n<0 , 表示不设置 +func (db *DB) SetMaxIdleConns(n int) +``` + + + +#### 2.4 单行查询 + +```go +func queryRow(sqlstr string) { + var u user + // 通过Scan , 将查询出的结果映射到 + err := db.QueryRow(sqlstr).Scan(&u.id, &u.name) + if err != nil { + fmt.Printf("error: %v\n", err) + return + } + fmt.Printf("user.id:%v user:name:%v\n", u.id, u.name) +} + +``` + + + +#### 2.5 多行查询 + +```go +func queryRows() { + sqlStr := "select * from user where id >?" + rows,err:=db.Query(sqlStr,0) + if err != nil { + fmt.Printf("error: %v\n", err) + return + } + // 关闭rows 保持的数据库连接 + defer rows.Close() + // 这里有点像迭代器模式 + for rows.Next(){ + var u user + err= rows.Scan(&u.id,&u.name) + if err != nil { + fmt.Printf("error: %v\n", err) + return + } + fmt.Printf("id: %v name:%v",u.id,u.name) + } +} +``` + + + + + +#### 2.6 插入数据 + +```go +func insertData(){ + // strSql:="insert into user values(?,?)" + // result,err:=db.Exec(strSql,nil,"tom") + + //strSql1:="insert into user(id,name) values(?,?)" + //result,err:=db.Exec(strSql1,nil,"tom") + + strSql2:="insert into user(name) values(?)" + result,err:=db.Exec(strSql2,"tom") + if err != nil { + fmt.Printf("error: %v\n", err) + return + } + // 获取插入数据的id + id,err:=result.LastInsertId() + if err != nil { + fmt.Printf("error: %v\n", err) + return + } + fmt.Println("last insert id : ",id) + + // 响应行数 + rows,err:=result.RowsAffected() + if err != nil { + fmt.Printf("error: %v\n", err) + return + } + fmt.Println("row affected : ",rows) +} +``` + + + +#### 2.7 更新 + +```go +func updateUser (){ + sqlStr := "update user set user.name = ? where id =?" + result,err:=db.Exec(sqlStr,"jerry",5) + if err != nil { + fmt.Printf("error: %v\n", err) + return + } + id,err:=result.LastInsertId() + if err != nil { + fmt.Printf("error: %v\n", err) + return + } + fmt.Println("last insert id : ",id) + + affectRow,err:=result.RowsAffected() + if err != nil { + fmt.Printf("error: %v\n", err) + return + } + fmt.Println("row affected : ",affectRow) + +} + +``` + + + +#### 2.8 刪除 + +```go +func deleteUserById(targetId int) { + sqlStr := "delete from user where id = ?" + result,err:=db.Exec(sqlStr,targetId) + if err != nil { + fmt.Printf("error: %v\n", err) + return + } + + id, err := result.LastInsertId() + if err != nil { + fmt.Printf("error: %v\n", err) + return + } + fmt.Println("last insert id : ", id) + + affectRow, err := result.RowsAffected() + if err != nil { + fmt.Printf("error: %v\n", err) + return + } + fmt.Println("row affected : ", affectRow) +} + +``` + + + +### 三. Sql预处理 + +#### 3.1 什么是sql预处理? + +* 普通sql执行过程 + * 从客户端对sql中的占位符进行替换,得到完整的sql + * 客户端将完整的sql , 发送到 MysqlServer + * MysqlServer执行sql , 返回给客户端结果 +* 预处理过程 + * Sql被分成两部分 , 命令部分, 预处理部分 + * 先把命令部分发送给Mysql服务端, Mysql服务端进行Sql的预处理 + * 把数据部分发送给Mysql服务端, 让MysqlServer用起替换命令部分的占位符 + * MysqlServer 执行sql , 返回给客户端结果 + + + + + +#### 3.2 为什么要预处理? + +* 优化Mysql服务器重复执行sql的流程, 一次编译, 下次就不用重新编译sql了, 节省编译成本 + +* 避免sql注入问题 + + ```go + // sql注入示例 + func sqlInjectDemo(name string) { + // 像这样自己拼接sql, 很容易造成sql注入 + sqlStr := fmt.Sprintf("select id, name, age from user where name='%s'", name) + fmt.Printf("SQL:%s\n", sqlStr) + + var users []user + err := db.Select(&users, sqlStr) + if err != nil { + fmt.Printf("exec failed, err:%v\n", err) + return + } + for _, u := range users { + fmt.Printf("user:%#v\n", u) + } + } + + sqlInjectDemo("xxx' or 1=1#") + sqlInjectDemo("xxx' union select * from user #") + sqlInjectDemo("xxx' and (select count(*) from user) <10 #") + ``` + +#### 3.3 Go的Sql预处理 + +```go +func (db *DB) Prepare(query string) (*Stmt, error) +``` + +```go +func prepareQuery(){ + sqlStr:= "select * from user where id > ?" + + // ******************************** + stat,err:=db.Prepare(sqlStr) + if err != nil { + fmt.Printf("error: %v\n", err) + return + } + // ******************************** + defer stat.Close() + // *************多行, Query , 单行QueryRow()******************* + rows,err:=stat.Query(0) + if err != nil { + fmt.Printf("error: %v\n", err) + return + } + defer rows.Close() + + for rows.Next() { + var u user + err:=rows.Scan(&u.id,&u.name) + if err != nil { + fmt.Printf("error: %v\n", err) + return + } + fmt.Printf("id:%v name:%v",u.id,u.name) + } +} +``` + + + +### 四. 事务 + +Go语言中使用如下三个方法实现Mysql中的事务操作 + +```go +// 开启事务, 方法返回一个事物 +func (db *DB) Begin() (*Tx, error) + +// 由事务执行sql +sqlStr1 := "Update user set age=30 where id=?" +_, err = tx.Exec(sqlStr1, 2) + +// 由tx发起提交事务的操作 +func (tx *Tx) Commit() error + +// 在err不为空, 或者是其他的情况下, 由tx发起回滚 +func (tx *Tx) Rollback() error +``` + + + +### 五. sqlx + +第三方库`sqlx`能够简化操作，提高开发效率。 + +#### 5.1 安装 + +```go +go get github.com/jmoiron/sqlx +``` + +推荐将这个依赖收到写入import块中, 然后通过goland的快捷键导入 + + + +#### 5.2 连接数据库 + +```go + +var db *sqlx.DB + +func initDb() (er error) { + db, er = sqlx.Connect("mysql", "root:root@tcp(127.0.0.1:3306)/test") + if er != nil { + fmt.Printf("error: %v\n", er) + return er + } + db.SetMaxOpenConns(200) + db.SetMaxIdleConns(100) + return nil +} +``` + + + +#### 5.3 踩坑 + +报错: `scannable dest type struct with >1 columns (2) in result` + +其实原因看看下面的代码就大概能猜出来 + +```go + +type User struct { + id int `db:"id"` + name string `db:"name"` +} + +func GetUserById(id int) { + sqlStr := "select id, name from user where id =?" + var u User + // 问题就出在这里 , sqlx底层通过v := reflect.ValueOf(dest) ... 为user赋值的 + // 所以上面的我们的结构体首字母需要大写才行, 不然怎么反射的了呢? + err:=db.Get(&u, sqlStr, id) + if err != nil { + fmt.Printf("error: %v\n", err) + return + } + fmt.Println(u.id , ":", u.name) +} +``` + + + +#### 5.4 查找 + +```go + // 单行 + sqlStr := "select id, name from user where id =?" + err:=db.Get(&u, sqlStr, id) + + // 多行 + sqlStr := "select id, name, age from user where id > ?" + var users []user + err := db.Select(&users, sqlStr, 0) +``` + + + +#### 5.5 删除,更新,修改 + +删除,更新,修改和原生的sql 用法基本一直 + + + +#### 5.6 事务 + +sqlx相对原生的sql提供了 db.Beginx() , db.MustExec() , 用来简化错误处理的过程 + +示例: + +```go +func transactionDemo() { + tx, err := db.Beginx() + if err != nil { + fmt.Printf("error: %v\n", err) + tx.Rollback() + return + } + + sql1 := "" + tx.MustExec(sql1, 1) + sql2 := "" + tx.MustExec(sql2, 1) + + err = tx.Commit() + if err != nil { + tx.Rollback() + fmt.Println("commit error:",err) + return + } + fmt.Println("success") +} +``` + + + +### 六. sql中的占位符 + +| 数据库 | 占位符语法 | +| ---------- | ------------ | +| MySQL | `?` | +| PostgreSQL | `$1`, `$2`等 | +| SQLite | `?` 和`$1` | +| Oracle | `:name` | + + + + + + + + + + + +``` +defer rows.Close() ???? 不确定 + // 循环读取结果集中的数据 + for rows.Next() { +``` \ No newline at end of file