├── 01-Go语言基础
└── README.md
├── 02-Go语言进阶
└── README.md
├── 03-Go语言库包
├── README.md
└── sendmail.go
├── 04-Go语言算法
└── README.md
├── 05-Go产品开发
└── README.md
├── 06-Go语言源码
└── README.md
├── 07-Go加密解密
└── README.md
└── README.md
/01-Go语言基础/README.md:
--------------------------------------------------------------------------------
1 | # 01-Go语言基础
2 |
3 | 01-Go语言基础
4 |
5 |
--------------------------------------------------------------------------------
/02-Go语言进阶/README.md:
--------------------------------------------------------------------------------
1 | # 02-Go语言进阶
2 |
3 | 02-Go语言进阶
4 |
5 |
--------------------------------------------------------------------------------
/03-Go语言库包/README.md:
--------------------------------------------------------------------------------
1 | # 03-Go语言库包
2 |
3 | 03-Go语言库包
4 |
5 |
--------------------------------------------------------------------------------
/03-Go语言库包/sendmail.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "bufio"
5 | "encoding/base64"
6 | "flag"
7 | "fmt"
8 | "io"
9 | "log"
10 | "net/smtp"
11 | "os"
12 | "strings"
13 | "time"
14 | )
15 |
16 | //发送邮件的逻辑函数。这个例子大部分是66所写，感谢66。
17 | func SendMail(user, password, host, to, subject, body, mailtype string) error {
18 | hp := strings.Split(host, ":")
19 | auth := smtp.PlainAuth("", user, password, hp[0])
20 | var content_type string
21 | if mailtype == "html" {
22 | content_type = "Content-Type: text/" + mailtype + "; charset=UTF-8"
23 | } else {
24 | content_type = "Content-Type: text/plain" + "; charset=UTF-8"
25 | }
26 |
27 | // msg := []byte("To: " + to + "\r\nFrom: " + user + "<" + user + ">\r\nSubject: " + subject + "\r\n" + content_type + "\r\n\r\n" + body)
28 | msg := []byte("To: " + to + "\r\nFrom: " + "fajianren" + "<" + user + ">\r\nSubject: " + subject + "\r\n" + content_type + "\r\n\r\n" + body)
29 |
30 | send_to := strings.Split(to, ";")
31 | err := smtp.SendMail(host, auth, user, send_to, msg)
32 | return err
33 | }
34 |
35 | func main() {
36 | // 日志保存到文件中-开始
37 | filename := time.Now().Format("20060102150405") + ".log"
38 | f, err := os.OpenFile(filename, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0666)
39 | if err != nil {
40 | log.Fatal(err)
41 | }
42 | defer f.Close()
43 | writers := []io.Writer{
44 | f,
45 | os.Stdout}
46 | fileAndStdoutWriter := io.MultiWriter(writers...)
47 | logger := log.New(fileAndStdoutWriter, "", log.Ldate|log.Ltime)
48 | // 日志保存到文件中-结束
49 |
50 | url := "http://127.0.0.1"
51 |
52 | host := "smtp.163.com:25"
53 | username := "username@163.com"
54 | password := "password"
55 |
56 | logger.Println("程序启动，准备发送邮件！")
57 |
58 | var toFileList string
59 |
60 | flag.StringVar(&toFileList, "f", "", "指定发送的文件，换行结束。")
61 | flag.Parse()
62 |
63 | if toFileList == "" {
64 | fmt.Print("请通过参数 -f 指定接收的邮箱列表！")
65 | return
66 | }
67 | if !strings.HasSuffix(url, "/") {
68 | url += "/"
69 | }
70 | if toFileList != "" {
71 | f, _ := os.Open(toFileList)
72 | defer f.Close()
73 | r := bufio.NewReader(f)
74 | for {
75 | if line, _, err := r.ReadLine(); err == nil {
76 | email := string(line)
77 | diaoyuurl := url + email[0:strings.Index(email, "@")]
78 |
79 | subject := "=?UTF-8?B?" + base64.StdEncoding.EncodeToString([]byte("紧急通知：体检报名")) + "?="
80 | body := "全体同事：
为了解和掌握员工健康状况、确保员工合理安排健康检查和职业病危害因素检测活动。
本年度体检计划将进行调整，从8月开始将分批次安排员工进行上岗前职业健康检查以及在岗期间职业健康检查。
请打开如下链接选择合适的时间进行体检报名。每个批次人数报满即止，报名时间截止9月3日。
请尽快点击下面链接按照步骤进行报名！
第一步：点击填写报名信息第二步：点击查看是否报名成功"
81 | logger.Println("准备 " + email + " 发送邮件！")
82 | if err := SendMail(username, password, host, email, subject, body, "html"); err != nil {
83 | logger.Println("邮件 "+email+" 发送失败！\n", err.Error())
84 | } else {
85 | logger.Println("邮件 " + email + " 发送成功！")
86 | time.Sleep(time.Duration(3) * time.Second)
87 | logger.Println("休眠 3 秒继续发送！请耐心等待！")
88 | }
89 | } else {
90 | break
91 | }
92 | }
93 | }
94 | logger.Println("邮件已经全部发送完毕！")
95 |
96 | }
--------------------------------------------------------------------------------
/04-Go语言算法/README.md:
--------------------------------------------------------------------------------
1 | # 04-Go语言算法
2 |
3 | 04-Go语言算法
4 |
5 |
--------------------------------------------------------------------------------
/05-Go产品开发/README.md:
--------------------------------------------------------------------------------
1 | # 05-Go产品开发
2 |
3 | 05-Go产品开发
4 |
5 |
--------------------------------------------------------------------------------
/06-Go语言源码/README.md:
--------------------------------------------------------------------------------
1 | # 06-Go语言源码
2 |
3 | 06-Go语言源码
4 |
5 |
--------------------------------------------------------------------------------
/07-Go加密解密/README.md:
--------------------------------------------------------------------------------
1 | # 07-Go加密解密
2 |
3 | 07-Go加密解密
4 |
5 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # 《365天深入理解Go语言》
2 |
3 | 本书籍是记录自己在学习Go语言的过程中遇到的问题与思考。写作过程中大量参考借鉴甚至是复制了其他类似的项目。感谢每一个开源项目，致敬每一位Gopher！尽可能的熟练使用Go语言，尽可能的深入理解Go语言。努力成为Go语言特长型程序员。**学习Go语言，面向信仰编程！** 作者：[0e0w](https://github.com/0e0w)。Less is More or Less is Less.
4 |
5 | 本项目创建于2020年9月1日，最近的一次更新时间为2022年11月8日。本项目会持续更新，直到海枯石烂。
6 |
7 | 项目暂时计划共七章。项目未完成，持续更新整理中！**今天你学习Go语言了吗？**
8 |
9 | - [01-Go语言基础](https://github.com/LearnGolang/365Golang#01-go%E8%AF%AD%E8%A8%80%E5%9F%BA%E7%A1%80)
10 | - [02-Go语言进阶](https://github.com/LearnGolang/365Golang#02-go%E8%AF%AD%E8%A8%80%E8%BF%9B%E9%98%B6)
11 | - [03-Go语言库包](https://github.com/LearnGolang/365Golang#03-go%E8%AF%AD%E8%A8%80%E5%BA%93%E5%8C%85)
12 | - [04-Go语言算法](https://github.com/LearnGolang/365Golang#04-go%E8%AF%AD%E8%A8%80%E7%AE%97%E6%B3%95)
13 | - [05-Go产品开发](https://github.com/LearnGolang/365Golang#05-go%E4%BA%A7%E5%93%81%E5%BC%80%E5%8F%91)
14 | - [06-Go语言源码](https://github.com/LearnGolang/365Golang#06-go%E8%AF%AD%E8%A8%80%E6%BA%90%E7%A0%81)
15 | - [07-Go加密解密](https://github.com/LearnGolang/365Golang#07-go%E5%8A%A0%E5%AF%86%E8%A7%A3%E5%AF%86)
16 |
17 | ## 01-Go语言基础
18 |
19 | 基础不牢地动山摇，此理论不仅适用于建筑行业，在学习Go语言中更是这样！最基础的内容，也需要反复学习，多次试验，刻意练习，之后直至达到深入理解的境界！
20 |
21 |
22 | Day001: 基础-Go语言入门
23 |
24 | - [x] 本节说明：本节介绍Go语言的历史与发展。
25 | - [x] 程序语言概述：程序语言是用来定义计算机程序的形式语言。它是一种被标准化的交流技巧，用来向计算机发出指令，一种能够让程序员准确地定义计算机所需要使用数据的计算机语言，并精确地定义在不同情况下所应当采取的行动。最早的编程语言是在电脑发明之前产生的，当时是用来控制提花织布机及自动演奏钢琴的动作。在电脑领域已发明了上千不同的编程语言，而且每年仍有新的编程语言诞生。
26 | - [x] Go语言概述：Go语言是Google开发的一种静态强类型、编译型、并发型，并具有垃圾回收功能的编程语言。通过Go语言可以容易的构造出简单、可靠且高效的软件。 Go语言本身也是开源的，编译器、库和工具的源代码都可以免费获得。
27 |
28 | - Go语言是由[Robert Griesemer](https://github.com/griesemer)、[Rob Pike](https://github.com/robpike)、[Ken Thompson](https://baike.baidu.com/item/Ken%20Thompson/3441433)在2007年9月开始设计，之后[Ian Lance Taylor](https://github.com/ianlancetaylor/)、[Russ Cox](https://github.com/rsc)加入项目。Go语言于2009年11月正式宣布推出，成为开放源代码项目，支持Linux、macOS、Windows等操作系统。在2012年发布了Go1稳定版本，目前稳定版本是Go1.19。
29 | - Go语言没有构造或析构函数、没有运算符重载、没有形参默认值、没有异常、没有宏、没有函数注解、没有线程局部存储。Go语言在1.18 中正式支持泛型。
30 | - Go 语言不是面向对象编程语言：没有类继承，甚至没有类。Go语言以一种不同寻常的方式来诠释面向对象程序设计。
31 | - Go语言有垃圾回收、有包系统、有一等公民函数、有词法作用域、有系统调用接口等。
32 | - [x] Go语言特点：Go语言和其他语言相比的优势是什么？
33 |
34 | - 快速编译，高效执行，易于开发。
35 | - 对于网络通信、并发和并行编程有很好的支持，可以更好地利用大量的分布式和多核的计算机。
36 | - Go语言通过 goroutine 这种轻量级线程的概念来实现这个目标，然后通过 channel 来实现各个 goroutine 之间的通信。它们实现了分段栈增长和 goroutine 在线程基础上多路复用技术的自动化。
37 | - Go语言从本质上（程序和结构方面）来实现并发编程。
38 | - Go语言作为强类型语言，隐式的类型转换是不被允许的。一条原则：让所有的东西都是显式的。
39 | - Go语言本身是由C语言开发的，而不是Go语言（Go1.5开始自举）。
40 | - Go语言的二进制文件体积是最大的（每个可执行文件都包含 runtime）。
41 | - Go语言做为一门静态语言，但却和很多动态脚本语言一样得灵活。
42 | - [x] Go语言资源：有大量的教程和代码想项目案例。
43 |
44 | - https://github.com/golang
45 | - https://github.com/LearnGolang
46 |
47 |
48 | - [x] Go语言安装：[官网下载](https://golang.org/dl/)后，直接按照安装说明安装即可。
49 | - Linux：在Ubuntu虚拟机里面开发使用Go语言：
50 |
51 | ```
52 | wget https://golang.google.cn/dl/go1.18.linux-amd64.tar.gz
53 | tar -C /usr/local -xzf go1.18.linux-amd64.tar.gz
54 | vi ~/.bashrc
55 | export PATH=/usr/local/go/bin:$PATH
56 | source .bashrc
57 | ```
58 |
59 | - Windows：https://golang.google.cn/dl/go1.18.windows-amd64.msi
60 |
61 | ```
62 | https://golang.google.cn/dl/go1.18.windows-amd64.msi
63 | ```
64 |
65 | - macOS
66 |
67 | ```
68 | https://golang.google.cn/dl/go1.18.darwin-amd64.pkg
69 | ```
70 |
71 | - [x] Go环境变量：
72 | - 设置GOPATH：
73 |
74 | ```
75 | mkdir ~/go
76 | echo "GOPATH=$HOME/go" >> ~/.bashrc
77 | echo "export GOPATH" >> ~/.bashrc
78 | echo "PATH=\$PATH:\$GOPATH/bin # Add GOPATH/bin to PATH for scripting" >> ~/.bashrc
79 | source ~/.bashrc
80 | ```
81 |
82 | - 设置Go env
83 |
84 | ```
85 | go env -w GO111MODULE=off
86 | ```
87 |
88 | - [x] Go语言编辑器：
89 |
90 | - [Goland](https://www.jetbrains.com/go)：JetBrains 公司的 Go 开发工具。
91 | - [Visual Studio Code](https://code.visualstudio.com)：代码开发神器。
92 | - [LiteIDE](http://liteide.org)：一款开源跨平台轻量级的Go语言IDE。
93 |
94 | - [x] Go语言命令：
95 |
96 | - 运行go程序：
97 |
98 | ```
99 | go run main.go
100 | ```
101 |
102 | - 打包成可执行程序：
103 |
104 | ```
105 | // 直接编译
106 | go build main.go
107 | //去掉符号表去掉调试信息
108 | go build -ldflags "-w -s" main.go
109 | go build -ldflags="-s -w" main.go
110 | //实现无窗口运行
111 | go build -ldflags "-w -s -H windowsgui" main.go
112 | ```
113 |
114 | - 生成不同平台下的可执行程序：需配置GOPATH。
115 |
116 | ```
117 | // Linux下编译Mac, Windows平台的64位可执行程序：
118 | CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build main.go
119 | CGO_ENABLED=0 GOOS=darwin GOARCH=amd64 go build main.go
120 |
121 | // Linux下编译Mac, Windows平台的32位可执行程序：
122 | CGO_ENABLED=0 GOOS=windows GOARCH=386 go build main.go
123 | CGO_ENABLED=0 GOOS=darwin GOARCH=386 go build main.go
124 | ```
125 |
126 | ```
127 | // Windows下编译Mac, Linux平台的64位可执行程序：将下面代码保存为bat格式执行即可。
128 |
129 | @echo off
130 | go build -ldflags "-w -s" Banli.go
131 |
132 | @echo off
133 | SET CGO_ENABLED=0
134 | SET GOOS=windows
135 | SET GOARCH=386
136 | go build -o Banli32.exe -ldflags "-w -s" Banli.go
137 |
138 | @echo off
139 | SET CGO_ENABLED=0
140 | SET GOOS=linux
141 | SET GOARCH=amd64
142 | go build -o Banli_linux -ldflags "-w -s" Banli.go
143 |
144 | @echo off
145 | SET CGO_ENABLED=0
146 | SET GOOS=darwin
147 | SET GOARCH=amd64
148 | go build -o Banli_darwin -ldflags "-w -s" Banli.go
149 | ```
150 |
151 | ```
152 | // Mac下编译Linux, Windows平台的64位可执行程序：
153 | CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build main.go
154 | CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build main.go
155 | ```
156 |
157 | - 安装依赖：
158 |
159 | ```
160 | go mod tidy
161 | go mod download
162 | go get -u github.com/0e0w/365GoLang
163 | ```
164 |
165 | - 格式化Go代码：
166 |
167 | ```
168 | gofmt
169 | ```
170 |
171 | - 查看Go环境配置：
172 |
173 | ```
174 | go env
175 | ```
176 |
177 | - 第三方包进行部署：
178 |
179 | ```
180 | go install
181 | ```
182 |
183 | - 其他的go命令：
184 |
185 | ```
186 | bug start a bug report
187 | build compile packages and dependencies
188 | clean remove object files and cached files
189 | doc show documentation for package or symbol
190 | env print Go environment information
191 | fix update packages to use new APIs
192 | fmt gofmt (reformat) package sources
193 | generate generate Go files by processing source
194 | get add dependencies to current module and install them
195 | install compile and install packages and dependencies
196 | list list packages or modules
197 | mod module maintenance
198 | run compile and run Go program
199 | test test packages
200 | tool run specified go tool
201 | version print Go version
202 | vet report likely mistakes in packages
203 | ```
204 |
205 | - 从GOPATH/src目录开始引入包，需关闭go mod模式：
206 |
207 | ```
208 | export GO111MODULE=off
209 | ```
210 |
211 | - [x] Go语言代理：
212 |
213 | - Go语言大量项目托管在Github，导致国内IP进行构建程序时会很慢，可使用下列的代理加快构建。
214 |
215 | ```
216 | https://mirrors.aliyun.com/goproxy/
217 | https://goproxy.io/zh/
218 | ```
219 |
220 | ```
221 | go env -w GO111MODULE=on
222 | go env -w GOPROXY=https://goproxy.cn,direct
223 | ```
224 |
225 | - [x] 一个例子：Hello World！
226 |
227 | ```go
228 | package main
229 |
230 | import (
231 | "fmt"
232 | )
233 |
234 | func main() {
235 | fmt.Println("Hello World!")
236 | }
237 | ```
238 |
239 |
240 | - 包声明：package main表示一个可独立执行的程序，每个 Go 应用程序都包含一个名为 main 的包。
241 | - 在完成包的 import 之后，开始对常量、变量和类型的定义或声明。
242 | - 引入包：使用import圆括号进行引入包。
243 |
244 | - 引入标准包
245 | - 引入第三方包
246 |
247 | - [x] Go语言名称：
248 |
249 | - 程序一般由关键字、常量、变量、运算符、类型和函数组成。 程序中可能会使用到这些分隔符：括号 ()，中括号 [] 和大括号 {}。 程序中可能会使用到这些标点符号：.、,、;、: 和 …。
250 | - 在变量与运算符间加入空格，程序看起来更加美观。
251 | - 标识符：用来命名变量、类型等程序实体。一个标识符就是一个或是多个字母( A ~ Z 和 a ~ z)数字(0~9)、下划线_组成的序列，但是第一个字符必须是字母或下划线而不能是数字。
252 |
253 | - [x] Go语言关键字：关键字是一些特殊的用来帮助编译器理解和解析源代码的单词。Go语言中有**25个**关键字或保留字。关键字只能用在程序语法允许的地方，不能作为名称使用。
254 |
255 | - 声明代码元素：const、func、import、package、type、var
256 | - 组合类型表示：chan、interface、map、struct
257 | - 流程控制语句：break、case、continue、default、else、fallthrough、for、goto、if、switch、select、range、return
258 | - 特殊的关键字：defer、go。也可以看作是流程控制关键字， 但它们有一些特殊的作用。
259 |
260 | - [x] 预定义标识符：三十几个内置的预申明的常量、类型和函数。所有的类型名、变量名、常量名、跳转标签、包名和包的引入名都必须是标识符。
261 |
262 | - 常量：true、flase、iota、nil
263 | - 类型：int、int8、int16、int32、int64、uint、uint8、uint16、uint32、uint64、uintptr、float32、float64、complex128、complex64、bool、byte、rune、string、error
264 | - 函数：make、len、cap、new、append、copy、close、delete、complex、real、imag、panic、recover
265 |
266 | - [x] Go语言声明：声明是给一个程序实体命名，并设定其部分或全部属性。
267 |
268 | - 有4个主要的声明：变量（var）、常量（const）、类型（type）、函数（func）
269 |
270 | - 函数的声明包含一个名字、一个参数列表、一个可选的返回值列表以及函数体。
271 |
272 | - [x] Go编码规范：https://golang.org/ref/spec
273 |
274 | - [x] 可见性规则：
275 |
276 | - 在Go语言中，标识符必须以一个大写字母开头，这样才可以被外部包的代码所使用，这被称为导出。标识符如果以小写字母开头，则对包外是不可见的，但是他们在整个包的内部是可见并且可用的。但是包名不管在什么情况下都必须小写。
277 | - 在设计Go语言时，设计者们也希望确保它不是过于以ASCII为中心，这意味着需要从7位ASCII的范围来扩展标识符的空间。 所以Go语言标识符规定必须是Unicode定义的字母或数字，标识符是一个或多个Unicode字母和数字的序列， 标识符中的第一个字符必须是Unicode字母。
278 | - 总而言之，为了确保我们的标识符能正常导出，我们建议在开发中还是尽量使用ASCII 码来作为标识符，虽然设计者们在避免以ASCII 码为中心，但出于习惯我们还是服从于这个现实。
279 |
280 | - [x] 命名规范：
281 |
282 | - 当某个函数需要被外部包调用的时候需要使用大写字母开头，并遵循 Pascal 命名法（“大驼峰式命名法”）；否则就遵循“小驼峰式命名法”，即第一个单词的首字母小写，其余单词的首字母大写。
283 | - 单词之间不以空格断开或连接号（-）、底线（_）连结，第一个单词首字母采用大写字母；后续单词的首字母亦用大写字母，例如：FirstName、LastName。每一个单词的首字母都采用大写字母的命名格式，被称为“Pascal命名法”，源自于Pascal语言的命名惯例，也有人称之为“大驼峰式命名法”（Upper Camel Case），为驼峰式大小写的子集。
284 | - Go 语言追求简洁的代码风格，并通过 gofmt 强制实现风格统一。
285 |
286 | - [x] 语法惯例：
287 |
288 | - Go 语言也使用分号作为语句的结束，但一般会省略分号。像在标识符后面；整数、浮点、复数、Rune或字符串等字面量后面；关键字break、continue、fallthrough、或者return后面；操作符或标点符号++、--、)、]或}之后等等都可以使用分号，但是往往会省略掉，像LiteIDE编辑器会在保存.go文件时自动过滤掉这些分号，所以在Go语言开发中一般不用过多关注分号的使用。
289 | - 左大括号 { 不能单独一行，这是编译器的强制规定，否则你在使用 gofmt 时就会出现错误提示“ expected declaration, found '{' ”。右大括号 } 需要单独一行。
290 | - 在定义接口名时也有惯例，接口的名字由方法名加 [e]r 后缀组成，例如 Printer、Reader、Writer、Logger、Converter 等等。还有一些不常用的方式（当后缀 er 不合适时），比如 Recoverable，此时接口名以 able 结尾，或者以 I 开头（像 .NET 或 Java 中那样）。
291 |
292 | - [x] 注释：尽管高级编程语言代码比底层机器指令友好和易懂，我们还是需要一些注释来帮助自己和其他程序员理解我们所写的代码。
293 |
294 | - 行注释：使用双斜线//开始，一般后面紧跟一个空格。行注释是Go语言中最常见的注释形式，在标准包中，一般都采用行注释，建议采用这种方式。
295 | - 块注释：使用 /* */，块注释不能嵌套。块注释一般用于包描述或注释成块的代码片段。
296 |
297 |
298 |
299 | Day002: 数据-Go语言变量
300 |
301 | - [x] 本节说明：本节介绍Go语言变量的相关内容。
302 |
303 | - [x] 程序语言的变量：变量（英语：Variable，scalar）是指一个包含部分已知或未知数值或信息（即一个值）的存储地址，以及相对应之符号名称（识别字）。通常使用变量名称引用存储值；将名称和内容分开能让被使用的名称独立于所表示的精确消息之外。电脑源代码中的识别字能在执行期间绑扎一个值，且该变量的值可能在程序执行期间改变。 程序设计中的变量不一定能直接对应到数学中所谓的变量之概念。在程序设计中，变量的值不一定要为方程或数学公式之一部分。程序设计中的变量可使用在一段可重复的程序：在一处赋值，然后使用于另一处，接着在一次赋值，且以相同方式再使用一次（见迭代）。程序设计中的变量通常会给定一个较长的名称，以描述其用途；数学中的变量通常较为简洁，只给定一、两个字母，以方便抄写及操作。 一个变量的存储地址可以被不同的识别字所引用，这种情况称之为别名。使用其中一个识别字为变量赋值，将会改变透过另一个识别字访问的值。
304 |
305 | - 什么是变量？程序变量是如何实现的？变量有什么用处？
306 | - 变量是指一个包含部分已知或未知数值或信息（即一个值）之存储地址，以及相对应之符号名称。通常使用变量名称引用存储值。
307 | - 变量是程序在运行时存储在内存中并且可以被更改的有名字的值。
308 |
309 | - [x] Go语言变量概述：
310 |
311 | - Go语言中所有的变量值都是类型确定值。每个局部声明的变量至少要被有效使用一次。
312 | - Go语言变量标识符由字母、数字、下划线组成，首字母不能是数字，区分大小写。
313 | - Go语言规范中，下划线“_”也被认为是字母。
314 | - Go语言声明变量时将变量的类型放在变量的名称后面。
315 | - Go语言变量有2种声明方式，var标准变量申明和短变量声明。
316 |
317 | - [x] Go语言标准变量声明：
318 |
319 | - 使用var声明，声明之后需要进行初始化。未初始化时是对应数据的零值。
320 | - Go语言变量的命名规则遵循骆驼命名法。
321 | - 下列的因式分解关键字的写法一般用于声明全局变量。
322 |
323 | ```go
324 | var (
325 | a int
326 | b bool
327 | str string
328 | 浮点 float32 // 中文可以作为变量标识符
329 | )
330 | ```
331 |
332 | ```go
333 | // 变量a，b都是指针类型
334 | var a, b *int
335 | ```
336 |
337 | - 声明变量之后，变量会自动初始化，初始值对应类型的零值。当一个变量被var声明之后，系统自动赋予它该类型的零值。所有的内存在 Go 中都是经过初始化的。数字类型对应的是0、布尔类型对应的是flase、字符串类型对应的是""、接口和引用类型对应的是nil。
338 |
339 | ```go
340 | var name type = expression
341 | var i, j, k int
342 | var b, f, s, = true, 2.3, "four"
343 | ```
344 |
345 | - [x] Go语言短变量声明：
346 |
347 | - 在函数内部声明变量可以使用短变量声明方式。
348 |
349 | - 变量初始化时省略变量的类型会由系统自动推断。短变量声明时会同时进行初始化。
350 |
351 | - 短变量声明是变量声明的首选形式，但是只能用在函数体内，不可以用于全局变量的声明与赋值。
352 |
353 | - 全局变量和简式声明的变量尽量不要同名，否则很容易产生偶然的变量隐藏Accidental Variable Shadowing。
354 |
355 | - 使用操作符 := 可以高效地创建一个新的变量，称之为初始化声明。name := expression
356 |
357 | ```go
358 | a := 5
359 | a, b, c := 5, 7, "abc"
360 | ```
361 |
362 | - [x] Go语言变量赋值：
363 |
364 | - 多变量可以在同一行进行赋值，也称为并行或同时或平行赋值。
365 |
366 | ```go
367 | a, b, c = 5, 7, "abc"
368 | ```
369 |
370 | - 并行赋值也被用于当一个函数返回多个返回值时，比如这里的 val 和错误 err 是通过调用 Func1 函数同时得到：
371 |
372 | ```go
373 | val, err = Func1(var1)
374 | ```
375 |
376 | - [x] Go语言空白标识符 _ ：
377 |
378 | - 空白标识符是一个特殊的标识符.它可以像其他标识符那样用于变量的声明或赋值（任何类型都可以赋值给它），但任何赋给这个标识符的值都将被抛弃，因此这些值不能在后续的代码中使用，也不可以使用这个标识符作为变量对其它变量进行赋值或运算。
379 | - 空白标识符 _ 也被用于抛弃值，如值 5 在：_, b = 5, 7 中被抛弃。
380 | - 由于Go语言有个强制规定，在函数内一定要使用声明的变量，但未使用的全局变量是没问题的。为了避免有未使用的变量，代码将编译失败，我们可以将该未使用的变量改为 _。
381 | - 另外，在Go语言中，如果引入的包未使用，也不能通过编译。有时我们需要引入的包，比如需要init()，或者调试代码时我们可能去掉了某些包的功能使用，你可以添加一个下划线标记符，_，来作为这个包的名字，从而避免编译失败。下滑线标记符用于引入，但不使用。
382 |
383 | - [x] Go语言零值nil：
384 |
385 | - nil 标志符用于表示interface、函数、maps、slices、channels、error、指针等的“零值”。如果你不指定变量的类型，编译器将无法编译你的代码，因为它猜不出具体的类型。
386 |
387 | - [x] 变量参考：
388 |
389 | - [变量 (程序设计)](https://zh.wikipedia.org/wiki/%E5%8F%98%E9%87%8F_(%E7%A8%8B%E5%BA%8F%E8%AE%BE%E8%AE%A1))
390 |
391 | - [ ] 本节案例：
392 |
393 |
394 |
395 | Day003: 数据-Go语言常量
396 |
397 | - [x] 本节说明：本节介绍Go语言常量的内容。
398 |
399 | - [x] 程序语言的常量：
400 |
401 | - 什么是常量？程序语言为什么需要常量？常量的优缺点？
402 | - 常量又称常数，是一个在程序正常执行过程中始终不会改变的值。也就是说，这个值是恒定的。常数可以分为不同的数据类型。
403 |
404 | - [x] Go语言常量概述：
405 |
406 | - 常量使用关键字 const 定义，用来存储不会改变的数据。
407 | - 常量不能被重新赋予任何值。常量名建议使用大写字母。
408 | - 存储在常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。
409 | - 常量声明中的等号=表示“绑定”而非“赋值”。每个常量描述将一个或多个字面量绑定到各自对应的有名常量上。每个有名常量其实代表着一个字面常量。
410 | - 常量可以直接声明在包中（全局常量），也可以声明在函数体中（局部常量）。
411 |
412 | - [x] Go语言常量定义：
413 |
414 | - 常量的定义格式：const identifier [type] = value，例如：
415 |
416 | ```go
417 | const Pi = 3.14159
418 | ```
419 |
420 | - Go语言常量定义可以指定常量类型，但不是必需的。如果定义常量时没有指定类型，那么它与字面常量一样，是无类型（untyped）的常量。
421 |
422 | - 一个未指定类型的常量被使用时，会根据其使用环境而推断出它所需要具备的类型。
423 |
424 | ```go
425 | 显式类型定义：const b string = "abc"
426 | 隐式类型定义：const b = "abc"
427 | ```
428 | - 常量也可以在单行进行多重赋值：
429 |
430 | ```go
431 | const a, b, c = 1, false, "str" //多重赋值
432 | ```
433 |
434 | - [x] Go语言 特殊常量：iota
435 |
436 | - iota 在 const关键字出现时将被重置为 0，const 中每新增一行常量声明将使 iota 计数一次。
437 | - iota 可理解为 const 语句块中的行索引。
438 | - iota 可以被用作枚举值。第一个 iota 等于 0，每当 iota 在新的一行被使用时，它的值都会自动加 1。
439 |
440 | ```go
441 | const (
442 | a = iota
443 | b = iota
444 | c = iota
445 | )
446 | ```
447 |
448 | 第一个 iota 等于 0，每当 iota 在新的一行被使用时，它的值都会自动加 1；所以 a=0, b=1, c=2 可以简写为如下形式：
449 |
450 | ```go
451 | const (
452 | a = iota
453 | b
454 | c
455 | )
456 | ```
457 |
458 | 如果对b重新赋值之后，a, b, c分别为0, 8, 8，新的常量b声明后，iota 不再向下赋值，后面常量如果没有赋值，则继承上一个常量值。
459 |
460 | ```go
461 | const (
462 | a = iota
463 | b = 8
464 | c
465 | )
466 | ```
467 |
468 | 使用位左移与 iota 计数配合可优雅地实现存储单位的常量枚举：
469 |
470 | ```go
471 | type ByteSize float64
472 | const (
473 | _ = iota // 通过赋值给空白标识符来忽略值
474 | KB ByteSize = 1<<(10*iota)
475 | MB
476 | GB
477 | TB
478 | )
479 | ```
480 |
481 |
482 |
483 | Day004: 数据-Go基本数据
484 |
485 | - [x] 本节说明：本节介绍Go语言的基本数据类型。
486 |
487 | - [ ] 程序语言的数据类型：
488 | - 程序语言的基本数据类型
489 | - 在PHP中有那些基础数据类型？
490 | - 在Java中有那些基础数据类型？
491 | - ......
492 |
493 | - [ ] Go语言基本数据类型概述：
494 |
495 | - 在Go语言中共有N种，分别是：布尔、数值、字符串、
496 |
497 | - 在Go语言中，数据类型用于声明函数和变量。
498 | - 数据类型的出现是为了把数据分成所需内存大小不同的数据，编程的时候需要用大数据的时候才需要申请大内存，就可以充分利用内存。
499 | - 在大多数高级编程语言中，数据通常被抽象为各种类型（type）和值（value）。
500 | - 一个类型可以看作是值的模板。一个值可以看作是某个类型的实例。
501 | - 大多数编程语言支持自定 义类型和若干预定义类型（即内置类型）。
502 | - 一门语言的类型系统是这门语言的灵魂。Go语言拥有独特的灵魂。
503 |
504 | **一、布尔类型：**
505 |
506 |
507 | - 布尔型的值只可以是常量 true 或者 false。布尔类型的初值是false。
508 | - 两个类型相同的值可以使用相等 == 或者不等 != 运算符来进行比较并获得一个布尔型的值。
509 | - 非运算符：!T -> false、!F -> true
510 |
511 | - 和运算符：T && T -> true、T && F -> false、F && T -> false、F && F -> false
512 |
513 |
514 | - 或运算符：T || T -> true、T || F -> true、F || T -> true、F || F -> false
515 |
516 | **二、数值类型：**
517 |
518 | - Go语言支持整型和浮点型数字，并且支持复数，其中位的运算采用补码。整型 int 和浮点型 float32、float64。
519 | - Go语言中没有 float 类型。Go语言中只有 float32 和 float64。没有double类型。
520 | - 整型的零值为 0，浮点型的零值为 0.0。
521 | - 整数：rune是int32的内置别名。
522 |
523 | ```
524 | int8（-128 -> 127）
525 | int16（-32768 -> 32767）
526 | int32（-2,147,483,648 -> 2,147,483,647）
527 | int64（-9,223,372,036,854,775,808 -> 9,223,372,036,854,775,807）
528 | ```
529 |
530 | - 无符号整数：byte是uint8的内置别名。
531 |
532 | ```
533 | uint8（0 -> 255）
534 | uint16（0 -> 65,535）
535 | uint32（0 -> 4,294,967,295）
536 | uint64（0 -> 18,446,744,073,709,551,615）
537 | ```
538 |
539 | - 浮点型（IEEE-754 标准）：
540 |
541 | ```
542 | float32（+- 1e-45 -> +- 3.4 * 1e38）
543 | float64（+- 5 * 1e-324 -> 107 * 1e308）
544 | ```
545 |
546 | - 字节型：byte 型，也就是uint8类型。代表了ASCII码的一个字符。
547 |
548 | ```go
549 | vat bt byte
550 | bt = 'a'
551 | fmt.Println(bt)
552 | //打印97
553 | ```
554 |
555 | **三、字符串类型：**
556 |
557 | - 从逻辑上说，一个字符串值表示一段文本。 在内存中，一个字符串存储为一个字节 （byte）序列。
558 | - Go语言中可以使用反引号或者双引号来定义字符串。反引号表示原生的字符串，不进行转义。
559 | - Go语言中的string类型是一种值类型，存储的字符串是不可变的，如果要修改string内容需要将string转换为[]byte或[]rune，并且修改后的string内容是重新分配的。
560 | - Go语言中的string类型是一种值类型，存储的字符串是不可变的，如果要修改string内容需要将string转换为[]byte或[]rune，并且修改后的string内容是重新分配的。
561 | - 字符串是字节的定长数组。字符串的零值是为长度为零的字符串，即空字符串 ""。
562 | - 一般的比较运算符（==、!=、<、<=、>=、>）通过在内存中按字节比较来实现字符串的对比。可以通过函数 len() 来获取字符串所占的字节长度，例如：len(str)。
563 | - 在Go中，字符串值是UTF-8编码的， 甚至所有的Go源代码都必须是UTF-8编码的。
564 | - 字符串的内容（纯字节）可以通过标准索引法来获取，在中括号 [] 内写入索引，索引从 0 开始计数。
565 | - 解释字符串：该类字符串使用双引号括起来，其中的相关的转义字符将被替换，这些转义字符包括：
566 |
567 | ```
568 | \n：换行符
569 | \r：回车符
570 | \t：tab 键
571 | \u 或 \U：Unicode 字符
572 | \\：反斜杠自身
573 | ```
574 |
575 | - 非解释字符串：
576 |
577 | ```
578 | `This is a raw string \n` 中的 `\n\` 会被原样输出。
579 | ```
580 |
581 | - 字符串拼接：使用运算符+、fmt.Sprintf()、strings.Join()、bytes.Buffer、strings.Builder
582 |
583 | - 标准库中有四个包对字符串处理尤为重要：bytes、strings、strconv和unicode包。
584 |
585 | - [字符串参考1](https://github.com/unknwon/the-way-to-go_ZH_CN/blob/master/eBook/04.7.md)
586 |
587 | - 格式化输出：fmt.Printf()
588 |
589 | ```
590 | %d //整型格式
591 | %c //字符型
592 | %s //字符串格式
593 | %v //自动匹配类型
594 | %T //数据类型
595 | ```
596 |
597 | - 数据类型转换：int(a)
598 |
599 | - [x] 组合类型分类：
600 |
601 | - 指针类型 - 类C指针。
602 | - 结构体类型 - 类C结构体。
603 | - 函数类型 - 函数类型在Go中是一种一等公民类别。
604 | - 容器类型，包括:
605 | - 数组类型 - 定长容器类型。
606 | - 切片类型 - 动态长度和容量容器类型。
607 | - 映射类型（map）- 也常称为字典类型。在标准编译器中映射是使用哈希表实现的。
608 | - 通道类型 - 通道用来同步并发的协程。
609 | - 接口类型 - 接口在反射和多态中发挥着重要角色。
610 |
611 | ```go
612 | // 假设T为任意一个类型，Tkey为一个支持比较的类型。
613 |
614 | *T // 一个指针类型
615 | [5]T // 一个元素类型为T、元素个数为5的数组类型
616 | []T // 一个元素类型为T的切片类型
617 | map[Tkey]T // 一个键值类型为Tkey、元素类型为T的映射类型
618 |
619 | // 一个结构体类型
620 | struct {
621 | name string
622 | age int
623 | }
624 |
625 | // 一个函数类型
626 | func(int) (bool, string)
627 |
628 | // 一个接口类型
629 | interface {
630 | Method0(string) int
631 | Method1() (int, bool)
632 | }
633 |
634 | // 几个通道类型
635 | chan T
636 | chan<- T
637 | <-chan T
638 | ```
639 |
640 | - [ ] 类型的种类：
641 |
642 | - 每种上面提到的基本类型和组合类型都对应着一个类型种类（kind）。除了这些种类，今后将要介绍的非类型安全指针类型属于另外一个新的类型种类。
643 |
644 | - 所以，目前（Go 1.15），Go有26个类型种类。
645 |
646 | - [ ] 语法-类型定义：
647 |
648 | - 在Go语言中，我们可以用type关键字来定义新的类型。
649 | - 一些类型定义的例子：
650 |
651 | ```go
652 | // 下面这些新定义的类型和它们的源类型都是基本类型。
653 | type (
654 | MyInt int
655 | Age int
656 | Text string
657 | )
658 |
659 | // 下面这些新定义的类型和它们的源类型都是组合类型。
660 | type IntPtr *int
661 | type Book struct{author, title string; pages int}
662 | type Convert func(in0 int, in1 bool)(out0 int, out1 string)
663 | type StringArray [5]string
664 | type StringSlice []string
665 |
666 | func f() {
667 | // 这三个新定义的类型名称只能在此函数内使用。
668 | type PersonAge map[string]int
669 | type MessageQueue chan string
670 | type Reader interface{Read([]byte) int}
671 | }
672 | ```
673 |
674 | - [ ] 类型别名声明：
675 |
676 | - 给一个类型另取一个别名：
677 |
678 | ```go
679 | type bigint int64
680 | var a bigint
681 | ```
682 |
683 | ```go
684 | type (
685 | Name = string
686 | Age = int
687 | )
688 |
689 | type table = map[string]int
690 | type Table = map[Name]Age
691 | ```
692 |
693 | - [ ] 定义类型和非定义类型：
694 |
695 | - [ ] 有名类型和无名类型：
696 |
697 | - [ ] 底层类型：
698 | - 在Go语言中，每个类型都有一个底层类型。
699 | - 一个内置类型的底层类型为它自己。
700 | - unsafe标准库包中定义的Pointer类型的底层类型是它自己。
701 | - 一个非定义类型（必为一个组合类型）的底层类型为它自己。
702 | - 在一个类型声明中，新声明的类型和源类型共享底层类型。
703 | - 一个例子：
704 |
705 | ```go
706 | // 这四个类型的底层类型均为内置类型int。
707 | type (
708 | MyInt int
709 | Age MyInt
710 | )
711 |
712 | // 下面这三个新声明的类型的底层类型各不相同。
713 | type (
714 | IntSlice []int // 底层类型为[]int
715 | MyIntSlice []MyInt // 底层类型为[]MyInt
716 | AgeSlice []Age // 底层类型为[]Age
717 | )
718 |
719 | // 类型[]Age、Ages和AgeSlice的底层类型均为[]Age。
720 | type Ages AgeSlice
721 | ```
722 |
723 | - [ ] 值、值部、值尺寸
724 |
725 | - 一个类型的一个实例称为此类型的一个值。一个类型可以有很多不同的值，其中一个为它的零值。 同一类型的不同值共享很多相同的属性。
726 | - 每个类型有一个零值。一个类型的零值可以看作是此类型的默认值。 预声明的标识符nil可以看作是切片、映射、函数、通道、指针（包括非类型安全指针）和接口类型的零值的字面量表示。 我们以后可以在Go中的nil一文中了解到关于nil的各种事实。
727 |
728 | - [x] 本节案例：
729 |
730 |
731 |
732 |
733 |
734 | Day005: 数据-Go语言指针
735 |
736 | - [x] 本节说明：本节介绍Go语言指针(pointer)的相关内容。
737 |
738 | - [ ] 程序语言的指针：
739 |
740 | - 什么是指针？指针的意义？为什么需要指针？指针的优点是什么？什么是内存？什么是内存地址？
741 | - 指针就是内存地址。内存地址是一种用于软件及硬件等不同层级中的数据概念，用来访问电脑主存中的数据。指针是存储另一个变量的内存地址的变量。一个指针中存储的内存地址是另外一个值的地址。
742 |
743 | - [x] Go语言指针概述：
744 |
745 | - 虽然Go语言吸收融合了很多其语言中的各种特性，但是Go语言主要被归入C语言家族。其中一个重要的原因是Go语言和C语言一样，也支持指针。但Go语言中的指针相比C语言指针有很多限制。Go语言不支持指针运算。
746 | - 指针是Go语言中的一种类型分类（kind）。一个指针是某个指针类型的一个值。一个指针可以存储一个内存地址。
747 | - 一个指针值存储着另一个值的地址，除非此指针值是一个nil空指针。我们可以说此指针引用着另外一个值，或者说另外一个值正被此指针所引用。
748 | - 将一个含有（直接或者间接）指针字段的结构体类型称为一个指针包裹类型，将一个含有（直接或者间接）指针的类型称为指针持有者类型。
749 |
750 | - [ ] Go语言指针操作：
751 |
752 | 一、获取指针值：
753 | - 可以用内置函数new来为任何类型的值开辟一块内存并将此内存块的起始地址做为此值的地址返回。 假设T是任一类型，则函数调用new(T)返回一个类型为*T的指针值。 存储在返回指针值所表示的地址处的值（可被看作是一个匿名变量）为T的零值。
754 | - 可以用前置取地址操作符&来获取一个可寻址的值的地址。 对于一个类型为T的可寻址的值t，我们可以用&t来取得它的地址。&t的类型为*T。
755 |
756 | 二、指针引用：
757 |
758 | - 一个指针中存储着另一个值的地址，则此指针值引用着另一个值。同时另一个值当前至少有一个引用。
759 | - 一个指针引用着另外一个值，也就是此指针指向另外一个值。
760 |
761 | - [x] 内存地址介绍：
762 |
763 | - 一个内存地址表示操作系统管理的整个内存中的一个偏移量（相对于从整个内存的起始，以字节计数）。
764 | - 一个内存地址用一个操作系统原生字（native word）来存储。
765 | - 一个原生字在32位操作系统上占4个字节，在64位操作系统上占8个字节。
766 | - 内存地址的字面形式常用整数的十六进制字面量来表示，比如0x1234CDEF。
767 |
768 | - [ ] 指针类型和值：
769 | - 在Go语言中，一个非定义指针类型的字面形式为\*T，其中T为一个任意类型。
770 |
771 | - 类型T称为指针类型\*T的基类型（base type）。 如果一个指针类型的基类型为T，则我们可以称此指针类型为一个T指针类型。
772 | - 虽然我们可以声明定义指针类型，但是一般不推荐这么做。非定义指针类型的可读性更高。
773 | - 如果一个指针类型的底层类型是\*T，则它的基类型为T。
774 | - 如果两个非定义指针类型的基类型为同一类型，则这两个非定义指针类型亦为同一类型。
775 | - 如果一个指针类型的基类型为T，则此指针类型的值只能存储类型为T的值的地址。
776 | - 一个值的地址是指此值的直接部分占据的内存的起始地址。
777 | - 一些指针类型的例子：
778 | ```go
779 | *int // 一个基类型为int的非定义指针类型。
780 | **int // 一个多级非定义指针类型，它的基类型为*int。
781 |
782 | type Ptr *int // Ptr是一个定义的指针类型，它的基类型为int。
783 | type PP *Ptr // PP是一个定义的多级指针类型，它的基类型为Ptr。
784 | ```
785 |
786 | - 指针类型的零值的字面量使用预声明的nil来表示。一个nil指针（常称为空指针）中不存储任何地址。
787 |
788 | - [ ] 指针解引用：
789 | - 解引用一个nil指针将产生一个恐慌。
790 | - 取地址和解引用例子：
791 | ```go
792 | package main
793 |
794 | import "fmt"
795 |
796 | func main() {
797 | p0 := new(int) // p0指向一个int类型的零值
798 | fmt.Println(p0) // （打印出一个十六进制形式的地址）
799 | fmt.Println(*p0) // 0
800 |
801 | x := *p0 // x是p0所引用的值的一个复制。
802 | p1, p2 := &x, &x // p1和p2中都存储着x的地址。
803 | // x、*p1和*p2表示着同一个int值。
804 | fmt.Println(p1 == p2) // true
805 | fmt.Println(p0 == p1) // false
806 | p3 := &*p0 // <=> p3 := &(*p0)
807 | // <=> p3 := p0
808 | // p3和p0中存储的地址是一样的。
809 | fmt.Println(p0 == p3) // true
810 | *p0, *p1 = 123, 789
811 | fmt.Println(*p2, x, *p3) // 789 789 123
812 |
813 | fmt.Printf("%T, %T \n", *p0, x) // int, int
814 | fmt.Printf("%T, %T \n", p0, p1) // *int, *int
815 | }
816 | ```
817 |
818 | - [ ] Go指针的一些限制：
819 | - Go语言指针一般不支持算术运算。
820 | - 一个指针类型的值不能被随意转换为另一个指针类型。
821 | - 一个指针值不能和其它任一指针类型的值进行比较。
822 | - 一个指针值不能被赋值给其它任意类型的指针值。
823 | - 上述Go语言指针的限制是可以被打破的。unsafe标准库包中提供的非类型安全指针（unsafe.Pointer）机制可以被用来打破上述Go语言指针的安全限制。
824 |
825 | - [ ] 指针参考：[指针参考1](https://github.com/ffhelicopter/Go42/blob/master/content/42_24_pointer.md)、[指针参考2](https://github.com/unknwon/the-way-to-go_ZH_CN/blob/master/eBook/04.9.md)、[指针参考3](https://gfw.go101.org/article/pointer.html)
826 |
827 |
828 |
829 | Day006: 数据-Go语言数组
830 |
831 | - [x] 本节说明：本节介绍Go语言数组(array)的相关内容。
832 |
833 | - [ ] 程序语言的数组：
834 |
835 | - 什么是数组？数组可以做什么？
836 | - 以 [] 符号标识的数组类型几乎在所有的编程语言中都是一个基本主力。
837 |
838 | - [x] Go语言数组概述：
839 |
840 | - Go语言数组(Array)是表示具有相同类型的一组已知编号并且长度固定的数据项序列。
841 | - 一个数组可以由零个或多个元素组成。
842 | - 数组类型可以是任意的原始类型例如整型、字符串或者自定义类型。
843 | - 数组长度必须是一个常量表达式，并且必须是一个非负整数。
844 | - 因为数组的长度是固定的，所以在Go语言中很少直接使用数组。
845 | - 数组长度也是数组类型的一部分，所以[5]int和[10]int是属于不同类型的。
846 |
847 | - [x] Go语言数组声明：
848 |
849 | - Go语言数组声明需要指定元素类型及元素个数。语法格式如下：
850 |
851 | ```go
852 | var 数组变量名 [元素数量]Type
853 | var a [3]int // 定义三个整数的数组
854 | ```
855 |
856 | - Go 语言中的数组是一种值类型，所以可以通过 new() 来创建：
857 |
858 | ```go
859 | var arr1 = new([5]int)
860 | ```
861 |
862 | - [x] 初始化数组：
863 |
864 | - 初始化数组中 {} 中的元素个数不能大于 [] 中的数字。
865 |
866 | - [x] 访问数组元素：
867 |
868 | - 数组元素可以通过索引（位置）来读取。格式为数组名后加中括号，中括号中为索引的值。
869 |
870 | ```go
871 | var team [3]string
872 | team[0] = "hammer"
873 | team[1] = "soldier"
874 | team[2] = "mum"
875 | for k, v := range team {
876 | fmt.Println(k, v)
877 | }
878 | ```
879 |
880 | - [x] 多维数组：
881 |
882 | - 数数组通常是一维的，但是可以用来组装成多维数组例如：
883 |
884 | ```
885 | [3][5]int
886 | [2][2][2]float64
887 | ```
888 |
889 | - [x] 将数组传递给函数：
890 |
891 | - 把一个大数组传递给函数会消耗很多内存。有两种方法可以避免这种现象：
892 |
893 | 1、传递数组的指针
894 |
895 | 2、使用数组的切片
896 |
897 | - [ ] 本节案例：
898 |
899 | - [ ] 数组参考：
900 |
901 | - https://go-recipes.dev/go-arrays-and-slices-d773893f06fb
902 |
903 |
904 |
905 |
906 | Day007: 数据-Go语言切片
907 |
908 | - [x] 本节说明：本节介绍Go语言切片(slice)的相关内容。
909 |
910 | - [ ] 程序语言的切片：
911 |
912 | - 什么是切片？
913 |
914 | - [x] Go语言切片概述：
915 |
916 | - Go语言切片是对数组的抽象。切片是对底层数组一个连续片段的引用，所以切片是一个引用类型。
917 | - 切片提供对该数组中编号的元素序列的访问。未初始化切片的值为nil。
918 | - Go语言数组的长度不可改变，但切片可以追加元素，在追加时可以使切片的容量增大。
919 | - 因为切片是引用，不需要使用额外的内存且比使用数组更有效率，所以在Go代码中切片比数组更常用。
920 |
921 | - [x] Go语言切片声明：
922 |
923 | - 切片有俩种定义方式：[]type、make()
924 |
925 | ```go
926 | var 切片变量名 []type // 声明一个未指定大小的数组来定义切片
927 | var silice = []int{2,4,6}
928 | var silice = []string{"aaa","bbb","ccc"}
929 | ```
930 |
931 | ```go
932 | var slice1 []type = make([]type, len,cap)// 使用make()函数来创建切片
933 | ```
934 |
935 | - [x] 将切片传递给函数：函数的参数为切片
936 |
937 | ```go
938 | func sum(a []int) int {
939 | s := 0
940 | for i := 0; i < len(a); i++ {
941 | s += a[i]
942 | }
943 | return s
944 | }
945 |
946 | func main() {
947 | var arr = [5]int{0, 1, 2, 3, 4}
948 | sum(arr[:])
949 | }
950 | ```
951 |
952 | - [x] Go语言切片重组：
953 |
954 | - 通过改变切片长度得到新切片的过程称之为切片重组 reslicing。
955 | - 在一个切片基础上重新划分一个切片时，新的切片会继续引用原有切片的数组。
956 | - 为了避免这个陷阱，我们需要从临时的切片中使用内置函数copy()，拷贝数据到新切片。
957 |
958 | - [ ] 切片初始化：
959 |
960 | - [ ] 空(nil)切片：
961 |
962 | - [ ] 切片参考：[参考1：Go Slice全面指南](https://mp.weixin.qq.com/s/rYY6TnZcb0FIWjouD2cznQ)、[切片参考2](https://github.com/unknwon/the-way-to-go_ZH_CN/blob/master/eBook/07.2.md)
963 |
964 | - [ ] 本节案例：
965 |
966 |
967 |
968 | Day008: 数据-Go语言映射
969 |
970 | - [x] 本节说明：本节介绍集合Go语言映射(Map)的相关内容。
971 |
972 | - [ ] 程序语言的映射
973 |
974 | - 什么是映射？
975 |
976 | - [x] Go语言映射概述：
977 |
978 | - Go语言中的映射(Map)类型也称之为映射、字典、集合。
979 | - Map是一种元素对（pair）的无序集合，pair的一个元素是key，对应的另一个元素是value，Map结构也称为关联数组或字典。
980 | - Map重要的一点是通过key来快速检索数据，key类似于索引，指向数据的值。
981 | - Map是一种集合，所以我们可以像迭代数组和切片那样迭代它。不过，Map 是无序的，我们无法决定它的返回顺序，这是因为 Map是使用 hash 表来实现的。
982 | - 在声明的时候不需要知道 Map的长度，Map是可以动态增长的。
983 | - 不要使用new，永远用make来构造map。为什么？
984 |
985 | - [x] Go语言申明映射：
986 |
987 | - map是引用类型，可以使用如下声明：
988 |
989 | ```go
990 | var map1 map[keytype]valuetype
991 | var map1 map[string]int
992 | map1 = map[string]int{"one": 1, "two": 2}
993 | ```
994 |
995 | - 可以使用内建函数 make 也可以使用 map 关键字来定义 Map。
996 |
997 | ```go
998 | // 声明变量，默认 map 是 nil
999 | var map_variable map[key_data_type]value_data_type
1000 |
1001 | // 使用 make 函数
1002 | map_variable := make(map[key_data_type]value_data_type)
1003 |
1004 | var m map[string]int
1005 |
1006 | // 声明但未初始化map，此时是map的零值状态
1007 | map1 := make(map[string]string, 5)
1008 |
1009 | map2 := make(map[string]string)
1010 |
1011 | // 创建了初始化了一个空的的map，这个时候没有任何元素
1012 | map3 := map[string]string{}
1013 |
1014 | // map中有三个值
1015 | map4 := map[string]string{"a": "1", "b": "2", "c": "3"}
1016 | ```
1017 |
1018 | - 一个示例：
1019 |
1020 | ```go
1021 | package main
1022 | import "fmt"
1023 |
1024 | func main() {
1025 | var mapLit map[string]int
1026 | //var mapCreated map[string]float32
1027 | var mapAssigned map[string]int
1028 |
1029 | mapLit = map[string]int{"one": 1, "two": 2}
1030 | mapCreated := make(map[string]float32)
1031 | mapAssigned = mapLit
1032 |
1033 | mapCreated["key1"] = 4.5
1034 | mapCreated["key2"] = 3.14159
1035 | mapAssigned["two"] = 3
1036 |
1037 | fmt.Printf("Map literal at \"one\" is: %d\n", mapLit["one"])
1038 | fmt.Printf("Map created at \"key2\" is: %f\n", mapCreated["key2"])
1039 | fmt.Printf("Map assigned at \"two\" is: %d\n", mapLit["two"])
1040 | fmt.Printf("Map literal at \"ten\" is: %d\n", mapLit["ten"])
1041 | }
1042 | ```
1043 |
1044 | - for-range与map
1045 |
1046 | ```go
1047 | // 使用 for 循环构造 map
1048 | for key, value := range map1 {
1049 | ...
1050 | }
1051 | ```
1052 |
1053 | ```go
1054 | // 只获取值
1055 | for _, value := range map1 {
1056 | ...
1057 | }
1058 | ```
1059 |
1060 | ```go
1061 | // 只获取 key
1062 | for key := range map1 {
1063 | fmt.Printf("key is: %d\n", key)
1064 | }
1065 | ```
1066 |
1067 | - [x] Go语言容器：
1068 |
1069 | - Go语言中有三种一等公民容器类型：数组、切片和映射。
1070 | - 有时候，字符串类型和通道类型也属于容器类型。
1071 | - 每个容器（值）用来表示和存储一个元素（element）序列或集合。一个容器中的所有元素的类型是相同的。此相同的类型称为此容器的类型的元素类型（或简称此容器的元素类型）。
1072 | - 存储在一个容器中的每个元素值都关联着一个键值（key）。每个元素可以通过它的键值而被访问到。
1073 | - 每个容器值有一个长度属性，用来表明此容器中当前存储了多少个元素。
1074 | - 每个数组值仅由一个直接部分组成，而一个切片或者映射值是由一个直接部分和一个可能的被此直接部分引用着的间接部分组成。
1075 | - 容器字面量是不可寻址的但可以被取地址。
1076 |
1077 | - [x] 非定义容器类型的字面表示：
1078 |
1079 | - 数组类型：[N]T
1080 |
1081 | - 切片类型：[]T
1082 |
1083 | - 映射类型：map[K]T
1084 |
1085 | - 说明：T可为任意类型，表示一个容器类型的元素类型。N必须为非负整数常量。K必须为一个可比较类型，K指定了映射类型的键值类型。
1086 |
1087 | - 一些例子：
1088 |
1089 | ```go
1090 | const Size = 32
1091 |
1092 | type Person struct {
1093 | name string
1094 | age int
1095 | }
1096 |
1097 | // 数组类型
1098 | [5]string
1099 | [Size]int
1100 | [16][]byte // 元素类型为一个切片类型：[]byte
1101 | [100]Person // 元素类型为一个结构体类型：Person
1102 |
1103 | // 切片类型
1104 | []bool
1105 | []int64
1106 | []map[int]bool // 元素类型为一个映射类型：map[int]bool
1107 | []*int // 元素类型为一个指针类型：*int
1108 |
1109 | // 映射类型
1110 | map[string]int
1111 | map[int]bool
1112 | map[int16][6]string // 元素类型为一个数组类型：[6]string
1113 | map[bool][]string // 元素类型为一个切片类型：[]string
1114 | map[struct{x int}]*int8 // 元素类型为一个指针类型：*int8；
1115 | // 键值类型为一个结构体类型。
1116 | ```
1117 |
1118 | - [ ] 查看容器值的长度和容量：
1119 |
1120 | - 长度：len()
1121 | - 容量：cap()
1122 | - 说明：数组值的长度和容量永不改变。切片值的长度和容量可在运行时改变。
1123 |
1124 | - [ ] 读取和修改容器元素：
1125 |
1126 | - 一个容器值v中存储的对应着键值k的元素用语法形式v[k]来表示。 v[k]为一个元素索引表达式。
1127 |
1128 | - [ ] 添加和删除容器元素：
1129 |
1130 | - [ ] 使用内置make函数来创建切片和映射：
1131 |
1132 | - [ ] 使用内置new函数来创建容器值：
1133 |
1134 | - [ ] 从数组或者切片派生切片（取子切片）：
1135 |
1136 | - [ ] 使用内置copy函数来复制切片元素：
1137 |
1138 | - [ ] 遍历容器元素：
1139 |
1140 | - 一个例子：
1141 |
1142 | ```go
1143 | for key, element = range aContainer {
1144 | // 使用key和element ...
1145 | }
1146 | ```
1147 |
1148 | - [ ] 把数组指针当做数组来使用：
1149 |
1150 | - [ ] 单独修改一个切片的长度或者容量：
1151 |
1152 | - [ ] 容器参考：[容器参考链接1](https://gfw.go101.org/article/container.html)
1153 |
1154 |
1155 |
1156 | Day009: 数据-Go的结构体
1157 |
1158 | - [x] 本节说明：本节介绍Go语言结构体(struct)的相关内容。
1159 |
1160 | - [ ] 程序语言的结构体：
1161 |
1162 | - 为什么是结构体？
1163 |
1164 | - [x] Go语言结构体概述：
1165 |
1166 | - Go语言通过类型别名（alias types）和结构体的形式支持用户自定义类型，或者叫定制类型。
1167 | - 一个带属性的结构体试图表示一个现实世界中的实体。
1168 | - 结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。结构体中可以定义不同类型的数据。
1169 | - 结构体是复合类型（composite types），它由一系列属性组成，每个属性都有自己的类型和值的，结构体通过属性把数据聚集在一起。结构体也是值类型，因此可以通过new函数来创建。
1170 | - 组成结构体类型的那些数据称为 字段（fields）。每个字段都有一个类型和一个名字；在一个结构体中，字段名字必须是唯一的。
1171 | - Go语言结构体不支持字段联合（union）。
1172 | - 方法（Method）可以访问这些数据，就好像它们是这个独立实体的一部分。
1173 |
1174 | - [x] Go语言声明结构体：
1175 | - 结构体定义需要使用 type 和 struct 语句。结构体中有一个或多个成员。type 语句设定了结构体的名称。结构体的格式如下：
1176 |
1177 | ```go
1178 | struct {
1179 | title, author string
1180 | pages int
1181 | X, Y bool
1182 | }
1183 | ```
1184 |
1185 | - `type T struct {a, b int}` 也是合法的语法，它更适用于简单的结构体。
1186 | - 一个空结构体：struct {}
1187 | - 一旦定义了结构体类型，它就能用于变量的声明。
1188 | - 结构体的字段可以是任何类型，甚至是结构体本身，也可以是函数或者接口。可以声明结构体类型的一个变量，然后像下面这样给它的字段赋值：
1189 |
1190 | ```go
1191 | var s T
1192 | s.a = 5
1193 | s.b = 8
1194 | ```
1195 |
1196 | - 一些结构体例子：
1197 | ```go
1198 | package main
1199 | import "fmt"
1200 |
1201 | type struct1 struct {
1202 | i1 int
1203 | f1 float32
1204 | str string
1205 | }
1206 |
1207 | func main() {
1208 | ms := new(struct1)
1209 | ms.i1 = 10
1210 | ms.f1 = 15.5
1211 | ms.str= "Chris"
1212 |
1213 | fmt.Printf("The int is: %d\n", ms.i1)
1214 | fmt.Printf("The float is: %f\n", ms.f1)
1215 | fmt.Printf("The string is: %s\n", ms.str)
1216 | fmt.Println(ms)
1217 | }
1218 | ```
1219 |
1220 | ```go
1221 | package main
1222 |
1223 | import (
1224 | "fmt"
1225 | )
1226 |
1227 | type Book struct {
1228 | title, author string
1229 | pages int
1230 | }
1231 |
1232 | func main() {
1233 | book := Book{"Go语言笔记", "0e0w", 365}
1234 | fmt.Println(book)
1235 |
1236 | // 使用带字段名的组合字面量来表示结构体值。
1237 | book = Book{author: "0e0w", pages: 365, title: "Go语言笔记"}
1238 | book = Book{}
1239 | book = Book{author: "0e0w"}
1240 |
1241 | // 使用选择器来访问和修改字段值。
1242 | var book2 Book // <=> book2 := Book{}
1243 | book2.author = "Tapir"
1244 | book2.pages = 300
1245 | fmt.Println(book.pages) // 300
1246 | }
1247 |
1248 | func f() {
1249 | book1 := Book{pages: 300}
1250 | book2 := Book{"Go语言笔记", "0e0w", 365}
1251 |
1252 | book2 = book1
1253 | // 上面这行和下面这三行是等价的。
1254 | book2.title = book1.title
1255 | book2.author = book1.author
1256 | book2.pages = book1.pages
1257 | }
1258 | ```
1259 |
1260 | - [x] 访问结构体成员：
1261 | - 如果要访问结构体成员，需要使用点号 . 操作符，格式为：
1262 | ```go
1263 | 结构体.成员名
1264 | ```
1265 |
1266 | - [x] 结构体特性：
1267 | - 结构体的内存布局：Go 语言中，结构体和它所包含的数据在内存中是以连续块的形式存在的，即使结构体中嵌套有其他的结构体，这在性能上带来了很大的优势。
1268 | - 递归结构体：递归结构体类型可以通过引用自身指针来定义。这在定义链表或二叉树的节点时特别有用，此时节点包含指向临近节点的链接。
1269 | - 可见性：通过参考应用可见性规则，如果结构体名不能导出，可使用 new 函数使用工厂方法的方法达到同样的目的。
1270 | - 带标签的结构体：结构体中的字段除了有名字和类型外，还可以有一个可选的标签（tag）。它是一个附属于字段的字符串，可以是文档或其他的重要标记。标签的内容不可以在一般的编程中使用，只有 reflect 包能获取它。
1271 |
1272 | - [ ] 结构体参考：[结构体参考1](https://github.com/ffhelicopter/Go42/blob/master/content/42_18_struct.md)、[结构体参考2](https://github.com/unknwon/the-way-to-go_ZH_CN/blob/master/eBook/10.1.md)、[结构体参考3](https://gfw.go101.org/article/struct.html)
1273 |
1274 | - [x] 本节案例：
1275 |
1276 | ```go
1277 | package main
1278 |
1279 | import (
1280 | "fmt"
1281 | )
1282 |
1283 | type Human struct {
1284 | name string // 姓名
1285 | Gender string // 性别
1286 | Age int // 年龄
1287 | string // 匿名字段
1288 | }
1289 |
1290 | type Student struct {
1291 | Human // 匿名字段
1292 | Room int // 教室
1293 | int // 匿名字段
1294 | }
1295 |
1296 | func main() {
1297 | //使用new方式
1298 | stu := new(Student)
1299 | stu.Room = 102
1300 | stu.Human.name = "Titan"
1301 | stu.Gender = "男"
1302 | stu.Human.Age = 14
1303 | stu.Human.string = "Student"
1304 |
1305 | fmt.Println("stu is:", stu)
1306 | fmt.Printf("Student.Room is: %d\n", stu.Room)
1307 | fmt.Printf("Student.int is: %d\n", stu.int) // 初始化时已自动给予零值：0
1308 | fmt.Printf("Student.Human.name is: %s\n", stu.name) // (*stu).name
1309 | fmt.Printf("Student.Human.Gender is: %s\n", stu.Gender)
1310 | fmt.Printf("Student.Human.Age is: %d\n", stu.Age)
1311 | fmt.Printf("Student.Human.string is: %s\n", stu.string)
1312 |
1313 | // 使用结构体字面量赋值
1314 | stud := Student{Room: 102, Human: Human{"Hawking", "男", 14, "Monitor"}}
1315 |
1316 | fmt.Println("stud is:", stud)
1317 | fmt.Printf("Student.Room is: %d\n", stud.Room)
1318 | fmt.Printf("Student.int is: %d\n", stud.int) // 初始化时已自动给予零值：0
1319 | fmt.Printf("Student.Human.name is: %s\n", stud.Human.name)
1320 | fmt.Printf("Student.Human.Gender is: %s\n", stud.Human.Gender)
1321 | fmt.Printf("Student.Human.Age is: %d\n", stud.Human.Age)
1322 | fmt.Printf("Student.Human.string is: %s\n", stud.Human.string)
1323 | }
1324 | ```
1325 |
1326 |
1327 |
1328 | Day010: 语法-Go基本语法
1329 |
1330 | - [x] 本节说明：本节介绍表达式、语句和简单语句的相关内容。
1331 |
1332 | - [ ] 程序语言的语法：
1333 |
1334 | - [x] Go语言语法概述：
1335 |
1336 | - 一个表达式表示一个值，而一条语句表示一个操作。
1337 | - 和很多其它流行语言一样，Go也支持break、continue和goto等跳转语句。 另外，Go 还支持一个特有的fallthrough跳转语句。
1338 | - Go语言不需要在语句或声明后面是有分号结尾。
1339 |
1340 | - [x] 简单语句类型：
1341 |
1342 | - 变量短声明语句。
1343 | - 纯赋值语句，包括x op= y这种运算形式。
1344 | - 有返回结果的函数或方法调用，以及通道的接收数据操作。
1345 | - 通道的发送数据操作。
1346 | - 空语句。
1347 | - 自增（x++）和自减（x--）语句。
1348 |
1349 | - [ ] 非简单语句类型：
1350 |
1351 | - 标准变量声明语句。
1352 | - 常量声明语句。
1353 | - 类型声明语句。
1354 | - 包引入语句。
1355 | - 显式代码块。
1356 | - 函数声明。
1357 | - 流程控制跳转语句。
1358 | - 函数返回（return）语句。
1359 | - 延迟函数调用和协程创建语句。
1360 |
1361 | - [ ] 三种基本的流程控制：
1362 |
1363 | - if-else条件分支代码块。
1364 | - switch-case多条件分支代码块
1365 | - for循环代码块。
1366 |
1367 | - [ ] 特定类型相关的流程控制代码块：
1368 |
1369 | - 容器类型相关的for-range循环代码块。
1370 | - 接口类型相关的type-switch多条件分支代码块。
1371 | - 通道类型相关的select-case多分支代码块。
1372 |
1373 | - [ ] 本节案例
1374 |
1375 |
1376 |
1377 | Day011: 语句-Go运算符号
1378 |
1379 | - [x] 本节说明：本节介绍Go运算符相关内容。
1380 |
1381 | - [ ] 数学中的运算符：
1382 |
1383 | - 什么是运算符？有那些运算符？程序语言有那些运算符？
1384 |
1385 | - [ ] 程序语言的运算符号：
1386 |
1387 | - [ ] Go语言运算符：
1388 |
1389 | - [x] Go语言运算符-算术运算符：
1390 |
1391 | | 算术运算符 | 描述 | 实例 |
1392 | | :--------- | :--- | :----------------- |
1393 | | + | 相加 | A + B 输出结果 30 |
1394 | | - | 相减 | A - B 输出结果 -10 |
1395 | | * | 相乘 | A * B 输出结果 200 |
1396 | | / | 相除 | B / A 输出结果 2 |
1397 | | % | 求余 | B % A 输出结果 0 |
1398 | | ++ | 自增 | A++ 输出结果 11 |
1399 | | -- | 自减 | A-- 输出结果 9 |
1400 |
1401 | - [x] Go语言运算符-比较运算符：
1402 |
1403 | | 运算符 | 描述 | 实例 |
1404 | | :----- | :----------------------------------------------------------: | :---------------- |
1405 | | == | 检查两个值是否相等，如果相等返回 True 否则返回 False。 | (A == B) 为 False |
1406 | | != | 检查两个值是否不相等，如果不相等返回 True 否则返回 False。 | (A != B) 为 True |
1407 | | > | 检查左边值是否大于右边值，如果是返回 True 否则返回 False。 | (A > B) 为 False |
1408 | | < | 检查左边值是否小于右边值，如果是返回 True 否则返回 False。 | (A < B) 为 True |
1409 | | >= | 检查左边值是否大于等于右边值，如果是返回 True 否则返回 False。 | (A >= B) 为 False |
1410 | | <= | 检查左边值是否小于等于右边值，如果是返回 True 否则返回 False。 | (A <= B) 为 True |
1411 |
1412 | - [x] Go语言运算符-逻辑运算符：
1413 |
1414 | - Go支持两种布尔二元运算符和一种布尔一元运算符。
1415 |
1416 | | 运算符 | 描述 | 实例 |
1417 | | :----: | :----: | :----------------: |
1418 | | && | 逻辑与 | (A && B) 为 False |
1419 | | \|\| | 逻辑或 | (A \|\| B) 为 True |
1420 | | ! | 逻辑非 | !(A && B) 为 True |
1421 |
1422 | - [x] Go语言运算符-位运算符：
1423 |
1424 | 位运算符对整数在内存中的二进制位进行操作。 下表列出了位运算符 &，|，和 ^ 的计算：
1425 |
1426 | | p | q | p & q | p \| q | p ^ q |
1427 | | :--- | :--- | :---- | :----- | :---: |
1428 | | 0 | 0 | 0 | 0 | 0 |
1429 | | 0 | 1 | 0 | 1 | 1 |
1430 | | 1 | 1 | 1 | 1 | 0 |
1431 | | 1 | 0 | 0 | 1 | 1 |
1432 |
1433 | | 运算符 | 描述 | 实例 |
1434 | | :----: | :----------------------------------------: | :------------------------------------: |
1435 | | & | 其功能是参与运算的两数各对应的二进位相与。 | (A & B) 结果为 12, 二进制为 0000 1100 |
1436 | | \| | 其功能是参与运算的两数各对应的二进位相或 | (A \| B) 结果为 61, 二进制为 0011 1101 |
1437 | | ^ | 二进位相异或，两对应的二进位相异时结果为1 | (A ^ B) 结果为 49, 二进制为 0011 0001 |
1438 | | << | | A << 2 结果为 240 ，二进制为 1111 0000 |
1439 | | >> | | A >> 2 结果为 15 ，二进制 |
1440 |
1441 | - [x] Go语言运算符-赋值运算符：
1442 |
1443 | | 运算符 | 描述 | 实例 |
1444 | | :----: | :--------------: | :-----------------------------------: |
1445 | | = | 简单的赋值运算符 | C = A + B 将 A + B 表达式结果赋值给 C |
1446 | | += | 相加后再赋值 | C += A 等于 C = C + A |
1447 | | -= | 相减后再赋值 | C -= A 等于 C = C - A |
1448 | | *= | 相乘后再赋值 | C *= A 等于 C = C * A |
1449 | | /= | 相除后再赋值 | C /= A 等于 C = C / A |
1450 | | %= | 求余后再赋值 | C %= A 等于 C = C % A |
1451 | | <<= | 左移后赋值 | C <<= 2 等于 C = C << 2 |
1452 | | >>= | 右移后赋值 | C >>= 2 等于 C = C >> 2 |
1453 | | &= | 按位与后赋值 | C &= 2 等于 C = C & 2 |
1454 | | ^= | 按位异或后赋值 | C ^= 2 等于 C = C ^ 2 |
1455 | | \|= | 按位或后赋值 | C \|= 2 等于 C = C \| 2 |
1456 |
1457 | - [x] Go语言运算符-波浪运算符：
1458 |
1459 | ```go
1460 | package main
1461 |
1462 | import "log"
1463 |
1464 | type customString string
1465 |
1466 | func Println[T ~int | ~string](v T) {
1467 | log.Println(v)
1468 | }
1469 | func main() {
1470 | Println(customString("Hello world!"))
1471 | }
1472 | ```
1473 |
1474 | - [x] Go语言运算符-其他运算符：
1475 |
1476 | | 运算符 | 描述 | 实例 |
1477 | | :----- | :--------------- | :------------------------: |
1478 | | & | 返回变量存储地址 | &a; 将给出变量的实际地址。 |
1479 | | * | 指针变量。 | *a; 是一个指针变量 |
1480 |
1481 | - [x] 运算符优先级：
1482 |
1483 | | 优先级 | 运算符 |
1484 | | :----: | :--------------: |
1485 | | 5 | * / % << >> & &^ |
1486 | | 4 | + - \| ^ |
1487 | | 3 | == != < <= > >= |
1488 | | 2 | && |
1489 | | 1 | \|\| |
1490 |
1491 | - [ ] 几个特殊运算符：
1492 |
1493 | - 位清除 &^：将指定位置上的值设置为 0。将运算符左边数据相异的位保留，相同位清零 ：
1494 |
1495 | - [ ] 本节案例：
1496 |
1497 |
1498 |
1499 |
1500 | Day012: 语句-Go条件判断
1501 |
1502 | - [x] 本节说明：本节介绍Go语言条件判断语句的相关内容。
1503 |
1504 | - [ ] 程序语言的条件判断：
1505 |
1506 | - 什么是条件语句？什么是判断？什么情况下需要条件语句？
1507 |
1508 | - [x] Go语言条件判断概述：
1509 |
1510 | - 条件语句需要指定一个或多个条件，通过测试条件是否为 true 来决定是否执行指定语句，当条件为 false 的情况在执行另外的语句。
1511 |
1512 | - [x] if语句：
1513 |
1514 | - if 语句用于测试某个条件（布尔型或逻辑型）的语句。由一个布尔表达式或关系运算符后紧跟一个或多个语句组成。
1515 |
1516 | ```go
1517 | if 布尔表达式 {
1518 | /* 在布尔表达式为 true 时执行 */
1519 | }
1520 | ```
1521 |
1522 | - [x] if...else 语句：
1523 |
1524 | - if 语句后可以使用可选的else语句, else语句中的表达式在布尔表达式为 false 时执行。
1525 |
1526 | ```go
1527 | if 布尔表达式 {
1528 | /* 在布尔表达式为 true 时执行 */
1529 | } else {
1530 | /* 在布尔表达式为 false 时执行 */
1531 | }
1532 | ```
1533 |
1534 | - [x] if 嵌套语句：
1535 |
1536 | - 你可以在 if 或 else if 语句中嵌入一个或多个 if 或 else if 语句。
1537 |
1538 | ```go
1539 | if 布尔表达式 1 {
1540 | /* 在布尔表达式 1 为 true 时执行 */
1541 | if 布尔表达式 2 {
1542 | /* 在布尔表达式 2 为 true 时执行 */
1543 | }
1544 | }
1545 | ```
1546 |
1547 | - 三层嵌套。
1548 |
1549 | ```go
1550 | if condition1 {
1551 | // do something
1552 | } else if condition2 {
1553 | // do something else
1554 | } else {
1555 | // catch-all or default
1556 | }
1557 | ```
1558 |
1559 | - [x] if条件判断语句案例：
1560 |
1561 | - 案例1：
1562 |
1563 | ```go
1564 | if a := 10; a == 10 {
1565 | fmt.Println("=10")
1566 | } else if a > 10 {
1567 | fmt.Println(">10")
1568 | } else if a < 10 {
1569 | fmt.Println("<10")
1570 | } else {
1571 | fmt.Println("这是不可能的!")
1572 | }
1573 | ```
1574 |
1575 | - 案例2
1576 |
1577 | ```go
1578 | if a := 10; a == 10 {
1579 | fmt.Println("10")
1580 | } else {
1581 | fmt.Println("not 10")
1582 | }
1583 | ```
1584 |
1585 | - 案例3
1586 |
1587 | ```go
1588 | a := 10 // 初始化赋值语句
1589 | if a == 10 {
1590 | fmt.Println("10")
1591 | } else {
1592 | fmt.Println("not 10")
1593 | }
1594 | ```
1595 |
1596 | - [x] switch 语句：
1597 |
1598 | - switch语句是存在多个条件判断的情况下，分别执行其对应的语句。
1599 |
1600 | - switch语句默认情况下 case 最后自带 break 语句，匹配成功后就不会执行其他 case。
1601 |
1602 | - 如果我们需要执行后面的 case，可以使用 fallthrough 。
1603 |
1604 | - switch后面可以写变量本身。和case后面的变量进行比较之后进行执行对应语句。
1605 |
1606 | ```go
1607 | switch var1 {
1608 | case val1:
1609 | ...
1610 | case val2:
1611 | ...
1612 | default:
1613 | ...
1614 | }
1615 | ```
1616 |
1617 | - 任何支持进行相等判断的类型都可以作为测试表达式的条件，包括 int、string、指针等。
1618 |
1619 | ```go
1620 | package main
1621 |
1622 | import "fmt"
1623 |
1624 | func main() {
1625 | var num1 int = 7
1626 |
1627 | switch { //无条件执行
1628 | case num1 < 0:
1629 | fmt.Println("Number is negative")
1630 | case num1 > 0 && num1 < 10:
1631 | fmt.Println("Number is between 0 and 10")
1632 | default:
1633 | fmt.Println("Number is 10 or greater")
1634 | }
1635 | }
1636 | ```
1637 |
1638 | - [ ] [switch 参考1](https://github.com/unknwon/the-way-to-go_ZH_CN/blob/master/eBook/05.3.md)
1639 |
1640 | - [x] select 语句：
1641 |
1642 | - select 结构，用于 channel 的选择。
1643 | - select 是 Go 中的一个控制结构，类似于 switch 语句。每个 case 必须是一个通信操作，要么是发送要么是接收。
1644 | - select 随机执行一个可运行的 case。如果没有 case 可运行，它将阻塞，直到有 case 可运行。一个默认的子句应该总是可运行的。
1645 | - select没有条件表达式，一直在等待分支进入可运行状态。
1646 |
1647 | ```go
1648 | select {
1649 | case communication clause :
1650 | statement(s);
1651 | case communication clause :
1652 | statement(s);
1653 | /* 你可以定义任意数量的 case */
1654 | default : /* 可选 */
1655 | statement(s);
1656 | }
1657 | ```
1658 |
1659 | 注意：Go 没有三目运算符，所以不支持 ?: 形式的条件判断。
1660 |
1661 | - [ ] [select参考1](https://github.com/unknwon/the-way-to-go_ZH_CN/blob/master/eBook/05.1.md)
1662 |
1663 | - [ ] 本节案例：
1664 |
1665 |
1666 |
1667 |
1668 | Day013: 语句-Go循环语句
1669 |
1670 | - [x] 本节说明：本节介绍Go语言循环语句的相关内容。
1671 |
1672 | - [ ] 程序语言的循环：
1673 |
1674 | - 什么是循环？为什么需要循环？最多循环多少层？
1675 |
1676 | - [ ] Go语言循环语句概述：
1677 |
1678 | - 在Go语言中只有for循环一种循环结构。
1679 | - 在实际问题中有大量的具有规律性的重复操作，在程序开发中便需要重复执行某些语句。
1680 |
1681 | - [x] for循环：重复执行语句
1682 |
1683 | - **Go语言中只有 for 结构可以重复执行某些语句**。
1684 | - for循环是一个循环控制结构，可以执行指定次数的循环。
1685 | - Go语言的for循环有 3 种形式，只有其中的一种使用分号。
1686 |
1687 | - **基于计数器的迭代**：
1688 |
1689 | ```go
1690 | for 初始化条件; 判断条件; 条件变化 {}
1691 | for init; condition; post { }
1692 | // init： 一般为赋值表达式，给控制变量赋初值；
1693 | // condition： 关系表达式或逻辑表达式，循环控制条件；
1694 | // post： 一般为赋值表达式，给控制变量增量或减量。
1695 | // 在循环中同时使用多个计数器：
1696 | for i, j := 0, N; i < j; i, j = i+1, j-1 {}
1697 | ```
1698 |
1699 | ```go
1700 | package main
1701 |
1702 | import "fmt"
1703 |
1704 | func main() {
1705 | for i := 0; i < 5; i++ {
1706 | fmt.Printf("This is the %d iteration\n", i)
1707 | }
1708 | }
1709 | ```
1710 |
1711 | - **基于条件判断的迭代**：
1712 |
1713 | ```go
1714 | package main
1715 |
1716 | import "fmt"
1717 |
1718 | func main() {
1719 | var i int = 5
1720 |
1721 | for i >= 0 {
1722 | i = i - 1
1723 | fmt.Printf("The variable i is now: %d\n", i)
1724 | }
1725 | }
1726 | ```
1727 |
1728 | - **无限循环：**
1729 |
1730 | 条件语句是可以被省略的，如 i:=0; ; i++ 或 for { } 或 for ;; { }（;; 会在使用 gofmt 时被移除）：这些循环的本质就是无限循环。最后一个形式可以被改写为 for true { }，但一般情况下都会直接写
1731 |
1732 | ```go
1733 | for { }
1734 | ```
1735 |
1736 | ```go
1737 | for t, err = p.Token(); err == nil; t, err = p.Token() {
1738 | ...
1739 | }
1740 | ```
1741 |
1742 | ```go
1743 | package main
1744 |
1745 | import "fmt"
1746 |
1747 | func main() {
1748 | sum := 0
1749 | for {
1750 | sum++ // 无限循环下去
1751 | }
1752 | fmt.Println(sum) // 无法输出
1753 | }
1754 | ```
1755 |
1756 | - **for-range 结构：**
1757 |
1758 | for 循环的 range 格式可以对 slice、map、数组、字符串等进行迭代循环。
1759 |
1760 | 在循环中可以同时使用多个计数器：
1761 |
1762 | ```go
1763 | for key, value := range oldMap {
1764 | newMap[key] = value
1765 | }
1766 | ```
1767 |
1768 | ```go
1769 | package main
1770 | import "fmt"
1771 |
1772 | func main() {
1773 | strings := []string{"google", "runoob"}
1774 | for i, s := range strings {
1775 | fmt.Println(i, s)
1776 | }
1777 | numbers := [6]int{1, 2, 3, 5}
1778 | for i,x:= range numbers {
1779 | fmt.Printf("第 %d 位 x 的值 = %d\n", i,x)
1780 | }
1781 | }
1782 | ```
1783 |
1784 | - [x] 循环嵌套：在循环内使用循环。
1785 |
1786 | - 使用方法：
1787 |
1788 | ```go
1789 | for [condition | ( init; condition; increment ) | Range]
1790 | {
1791 | for [condition | ( init; condition; increment ) | Range]
1792 | {
1793 | statement(s);
1794 | }
1795 | statement(s);
1796 | }
1797 | ```
1798 |
1799 | - 使用循环嵌套来输出 2 到 100 间的素数：
1800 |
1801 | ```go
1802 | package main
1803 | import "fmt"
1804 | func main() {
1805 | /* 定义局部变量 */
1806 | var i, j int
1807 | for i=2; i < 100; i++ {
1808 | for j=2; j <= (i/j); j++ {
1809 | if(i%j==0) {
1810 | break; // 如果发现因子，则不是素数
1811 | }
1812 | }
1813 | if(j > (i/j)) {
1814 | fmt.Printf("%d 是素数\n", i);
1815 | }
1816 | }
1817 | }
1818 | ```
1819 |
1820 | - [x] 循环控制语句：
1821 |
1822 | - break 语句：
1823 |
1824 | break可用于for、switch、select语句中。
1825 |
1826 | 用于循环语句中跳出循环，并开始执行循环之后的语句。
1827 |
1828 | break 在 switch（开关语句）中在执行一条 case 后跳出语句的作用。
1829 |
1830 | 在多重循环中，可以用标号 label 标出想 break 的循环。
1831 |
1832 | ```go
1833 | break
1834 | ```
1835 |
1836 | ```go
1837 | for {
1838 | i = i - 1
1839 | fmt.Printf("The variable i is now: %d\n", i)
1840 | if i < 0 {
1841 | break
1842 | }
1843 | }
1844 | ```
1845 |
1846 | ```go
1847 | i := 0
1848 | for { // for循环条件永真，会一直循环
1849 | if i >= 10 { // if条件判断i是否大于10
1850 | break // if大于10的话就break跳出for循环
1851 | }
1852 | i++ // i+1
1853 | g.Println(i) // 打印i
1854 | }
1855 | ```
1856 |
1857 | - continue语句：
1858 |
1859 | continue只能用于for循环。跳过当前循环执行下一次循环语句。
1860 |
1861 | for 循环中，执行 continue 语句会触发 for 增量语句的执行。
1862 |
1863 | 在多重循环中，可以用标号 label 标出想 continue 的循环。
1864 |
1865 | ```go
1866 | continue
1867 | ```
1868 |
1869 | ```go
1870 | package main
1871 |
1872 | func main() {
1873 | for i := 0; i < 10; i++ {
1874 | if i == 5 { // 判断i等于5时跳出for循环
1875 | continue
1876 | }
1877 | print(i)
1878 | print(" ")
1879 | }
1880 | }
1881 | ```
1882 |
1883 | - goto 语句：
1884 |
1885 | Go语言的 goto 语句可以无条件地转移到过程中指定的行。
1886 |
1887 | goto语句可以用在任何地方，但是不能跨函数使用。
1888 |
1889 | goto 语句通常与条件语句配合使用。可用来实现条件转移， 构成循环，跳出循环体等功能。
1890 |
1891 | 但是，在结构化程序设计中一般不主张使用 goto 语句， 以免造成程序流程的混乱，使理解和调试程序都产生困难。
1892 |
1893 | ```go
1894 | goto End //goto是关键字，End是用户起的名字，叫做标签
1895 | .......
1896 | End:
1897 | fmt.Print("aaa")
1898 | ```
1899 |
1900 | ```go
1901 | package main
1902 |
1903 | func main() {
1904 | i:=0
1905 | HERE:
1906 | print(i)
1907 | i++
1908 | if i==5 {
1909 | return // 跳出函数
1910 | }
1911 | goto HERE
1912 | }
1913 | ```
1914 |
1915 | - return语句：
1916 |
1917 | 如果 return 语句使用在普通的 函数 中，则表示跳出该函数，不再执行函数中 return 后面的代码，可以理解成终止函数。
1918 |
1919 | 如果 return 语句使用在 main 函数中，表示终止 main 函数，也就是终止程序的运行。
1920 |
1921 | - [ ] 本节案例：
1922 |
1923 |
1924 |
1925 |
1926 | Day014: 函数-Go语言函数
1927 |
1928 | - [x] 本节说明：本节介绍Go语言函数的相关内容。
1929 |
1930 | - [ ] 程序语言的函数：
1931 |
1932 | - 什么是函数？为什么需要函数？函数解决了那些问题？
1933 |
1934 | - [ ] Go语言函数概述：
1935 |
1936 | - 在Go语言中，函数是一等公民类型。换句话说，可以把函数当作值来使用。
1937 | - 函数是基本的代码块，用于执行一个任务。Go语言最少需要有 main函数。
1938 | - main函数是在启动后第一个执行的函数（如果有 init函数则会先执行该函数）。main函数没有参数，没有返回类型。
1939 | - Go语言是编译型语言，函数编写的顺序是无关紧要的。但鉴于可读性的需求，最好把main函数写在文件的前面，其他函数按照一定逻辑顺序进行编写（例如函数被调用的顺序）。
1940 | - Go语言标准库提供了多种内置函数。不需要导入包，可直接使用。
1941 | - Go语言1.18开始支持泛型（generic），目前支持多种类型的函数。
1942 | - Go语言有三种类型的函数：1、普通的带有名字的函数。2、匿名函数或者lambda函数。3、方法
1943 |
1944 | - [x] Go语言声明函数：
1945 | - 函数声明会告诉编译器，函数的名称，返回类型和参数。
1946 |
1947 | - Go语言函数不支持输入参数默认值。每个返回结果的默认值是它的类型的零值。
1948 |
1949 | - 任何一个函数都不能被声明在另一个函数体内。 虽然匿名函数可以定义在函数体内，但匿名函数定义不属于函数声明。
1950 |
1951 | - Go语言函数基本组成：关键字func、函数名、参数列表、返回值、函数体和返回语句。语法如下：
1952 | ```GO
1953 | func 函数名(参数) 返回类型{
1954 | 函数体
1955 | }
1956 | ```
1957 |
1958 | - 无参数无返回的函数：
1959 |
1960 | ```go
1961 | func MyFunc(){
1962 | }
1963 | ```
1964 |
1965 | - 有参数无返回的函数：
1966 |
1967 | ```go
1968 | func main() {
1969 | Myfunc("url", "t")
1970 | }
1971 |
1972 | func Myfunc(aa, bb string) {
1973 | fmt.Println(aa)
1974 | fmt.Println(bb)
1975 | }
1976 | ```
1977 |
1978 | - 不定参数类型：不定参数只能是形参中的最后一个参数。
1979 |
1980 | ```go
1981 | func Myfunc(args ...int) {
1982 | fmt.Println(aa)
1983 | fmt.Println(bb)
1984 | }
1985 | ```
1986 |
1987 | - 无参数有返回的函数：有返回值的函数需要通过return返回。
1988 |
1989 | ```go
1990 | func MyFunc() int {
1991 | }
1992 | ```
1993 |
1994 | - 有参数有返回的函数：
1995 |
1996 | ```go
1997 | func main() {
1998 | max, min := MaxAndMin(10, 20)
1999 | fmt.Println(max, min)
2000 | }
2001 |
2002 | func MaxAndMin(a, b int) (max, min int) {
2003 | if a > b {
2004 | max = a
2005 | min = b
2006 | } else {
2007 | max = b
2008 | min = a
2009 | }
2010 | return
2011 | }
2012 | ```
2013 |
2014 | - [x] Go语言函数参数：
2015 | - 函数定义时，它的形参一般是有名字的，不过我们也可以定义没有形参名的函数，只有相应的形参类型，就像这样：func f(int, int, float64)。
2016 | - 函数如果使用参数，该变量可称为函数的形参。形参就像定义在函数体内的局部变量。
2017 | - 没有参数的函数通常被称为niladic函数（niladic function），就像main.main()。
2018 | - 调用函数，可以通过两种方式来传递参数：
2019 |
2020 | 1、按值传递(call by value)：值传递是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。
2021 |
2022 | 2、按引用传递(call by reference)：引用传递是指在调用函数时将实际参数的地址传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。
2023 |
2024 | ```go
2025 | package main
2026 |
2027 | import "fmt"
2028 |
2029 | func main() {
2030 | fmt.Printf("Multiply 2 * 5 * 6 = %d\n", MultiPly3Nums(2, 5, 6))
2031 | // var i1 int = MultiPly3Nums(2, 5, 6)
2032 | // fmt.Printf("MultiPly 2 * 5 * 6 = %d\n", i1)
2033 | }
2034 |
2035 | func MultiPly3Nums(a int, b int, c int) int {
2036 | // var product int = a * b * c
2037 | // return product
2038 | return a * b * c
2039 | }
2040 | ```
2041 |
2042 | - [x] Go语言函数返回值：
2043 |
2044 | - Go语言的函数通常情况下会有多个返回值。
2045 |
2046 | - 尽量使用命名返回值：这样会使代码更清晰、更简短，更加容易读懂。
2047 |
2048 | - 一个例子：
2049 |
2050 | ```go
2051 | package main
2052 | import "fmt"
2053 | func swap(x, y string) (string, string) {
2054 | return y, x
2055 | }
2056 | func main() {
2057 | a, b := swap("Google", "Runoob")
2058 | fmt.Println(a, b)
2059 | }
2060 | ```
2061 |
2062 | - [ ] Go语言函数调用：
2063 |
2064 | - 已经声明的函数可以通过它的名称和一个实参列表来调用。
2065 |
2066 | - 函数的声明可以出现在它的调用之前，也可以出现在它的调用之后。
2067 |
2068 | - 函数调用可以被延迟执行或者在另一个协程（goroutine）中执行。
2069 |
2070 | - 当创建函数时，定义了函数需要做什么，通过调用该函数来执行指定任务。
2071 |
2072 | - 函数调用流程：先调用的函数后返回。先进后出。
2073 |
2074 | - 调用函数，向函数传递参数，并返回值。
2075 |
2076 | ```go
2077 | pack1.Function(arg1, arg2, …, argn)
2078 | ```
2079 |
2080 | 上面的代码中Function 是 pack1 包里面的一个函数，括号里的是被调用函数的实参（argument）：这些值被传递给被调用函数的形参。
2081 |
2082 | ```go
2083 | package main
2084 |
2085 | func main() {
2086 | greeting()
2087 | }
2088 |
2089 | func greeting() {
2090 | println("aa")
2091 | }
2092 | ```
2093 |
2094 | - 一个函数也可以作为其他函数的参数。只要这个被调用函数的返回值个数、返回值类型和返回值的顺序与调用函数所需求的实参是一致的。
2095 |
2096 | - 函数也可以以申明的方式被使用，作为一个函数类型，就像：
2097 |
2098 | ```go
2099 | type binOp func(int, int) int
2100 | ```
2101 |
2102 | 这里不需要函数体 {}。
2103 |
2104 | - 函数是一等值（first-class value）：它们可以赋值给变量，就像 add := binOp 一样。
2105 |
2106 | - [ ] 延迟函数调用：
2107 |
2108 | - 在Go语言中，一个函数调用可以跟在一个defer关键字后面，形成一个延迟函数调用。
2109 |
2110 | - 和协程调用类似，被延迟的函数调用的所有返回值必须全部被舍弃。
2111 |
2112 | - 当一个函数调用被延迟后，它不会立即被执行。它将被推入由当前协程维护的一个延迟调用堆栈。
2113 | - 延迟调用例子：
2114 |
2115 | ```go
2116 | defer fmt.Println("3")
2117 | defer fmt.Println("2")
2118 | fmt.Println("1")
2119 | // 打印 1 2 3
2120 | ```
2121 |
2122 | - [x] Go语言回调函数：
2123 |
2124 | - 一个函数可以作为其它函数的参数进行传递，然后在其它函数内调用执行，一般称之为回调。
2125 |
2126 | ```go
2127 | package main
2128 |
2129 | import (
2130 | "fmt"
2131 | )
2132 |
2133 | func main() {
2134 | callback(1, Add)
2135 | }
2136 |
2137 | func Add(a, b int) {
2138 | fmt.Printf("The sum of %d and %d is: %d\n", a, b, a+b)
2139 | }
2140 |
2141 | func callback(y int, f func(int, int)) {
2142 | f(y, 2) // this becomes Add(1, 2)
2143 | }
2144 | ```
2145 |
2146 | - [ ] Go语言递归函数：
2147 |
2148 | - 函数自己调用自己。
2149 |
2150 | - [x] Go语言匿名函数：
2151 | - 当我们不希望给函数起名字的时候，可以使用匿名函数，例如：func(x, y int) int { return x + y }。
2152 | - 关键字 defer经常配合匿名函数使用，它可以用于改变函数的命名返回值。
2153 | - 匿名函数同样被称之为闭包（函数式语言的术语）：它们被允许调用定义在其它环境下的变量。
2154 | - 包可使得某个函数捕捉到一些外部状态，例如：函数被创建时的状态。
2155 | - Go语言中的所有的自定义函数（包括声明的函数和匿名函数）都可以被视为闭包。一个闭包继承了函数所声明时的作用域。这种状态（作用域内的变量）都被共享到闭包的环境中，因此这些变量可以在闭包中被操作，直到被销毁。
2156 | - 一个匿名函数在定义后可以被立即调用。
2157 | - 闭包经常被用作包装函数：它们会预先定义好 1 个或多个参数以用于包装。
2158 |
2159 | ```go
2160 | func() {
2161 | sum := 0
2162 | for i := 1; i <= 1e6; i++ {
2163 | sum += i
2164 | }
2165 | }()
2166 | ```
2167 |
2168 | - [x] 函数用法：
2169 | - 函数作为另外一个函数的实参：函数定义后可作为另外一个函数的实参数传入。
2170 | - 闭包：闭包是匿名函数，可在动态编程中使用。
2171 |
2172 | - [ ] 本节案例：
2173 |
2174 |
2175 |
2176 |
2177 | Day015: 函数-Go语言方法
2178 |
2179 | - [x] 本节说明：本节介绍Go语言方法相关内容。
2180 |
2181 | - [ ] 程序语言的方法：
2182 |
2183 | - 什么是方法？
2184 |
2185 | - [x] Go语言方法概述：
2186 |
2187 | - 方法是包含了接收者的函数。接收者可以是命名类型或者结构体类型的一个值或者是一个指针。
2188 | - 在Go语言中，结构体就像是类的一种简化形式，Go方法是作用在接收者（receiver）上的一个函数，接收者是某种类型的变量。因此方法是一种特殊类型的函数。
2189 | - 接收者类型可以是（几乎）任何类型，不仅仅是结构体类型。任何类型都可以有方法，甚至可以是函数类型，可以是 int、bool、string 或数组的别名类型。但是接收者不能是一个接口类型，因为接口是一个抽象定义，但是方法却是具体实现。
2190 | - 接收者不能是一个指针类型，但是它可以是任何其他允许类型的指针。
2191 | - 一个类型加上它的方法等价于面向对象中的一个类。
2192 | - Go语言支持一些面向对象编程特性，方法是这些所支持的一个特性。
2193 |
2194 | - [ ] Go语言声明方法：
2195 |
2196 | - Go语言方法的申明和普通函数声明类似，在函数名前放一个变量，即是一个方法。这个附加的参数会将该函数附加到这种类型上，即相当于为这种类型定义了一个独占的方法。这个参数是接受者。
2197 | - 在Go语言中，可以为类型T和*T显式地声明一个方法，其中类型T必须满足四个条件：`T`必须是一个定义类型；`T`必须和此方法声明定义在同一个代码包中；`T`不能是一个指针类型；`T`不能是一个接口类型。
2198 |
2199 | - [ ] Go语言方法接受者：
2200 |
2201 | - 值接收者
2202 | - 指针接收者
2203 |
2204 | - [ ] Go语言方法案例：
2205 |
2206 | - 示例一：函数和方法的使用对比
2207 |
2208 | ```go
2209 | package main
2210 |
2211 | import (
2212 | "fmt"
2213 | "math"
2214 | )
2215 |
2216 | type Point struct{ X, Y float64 }
2217 |
2218 | // traditional function
2219 | func Distance(p, q Point) float64 {
2220 | return math.Hypot(q.X-p.X, q.Y-p.Y)
2221 | }
2222 |
2223 | // same thing, but as a method of the Point type
2224 | func (p Point) Distance(q Point) float64 {
2225 | return math.Hypot(q.X-p.X, q.Y-p.Y)
2226 | }
2227 |
2228 | func main() {
2229 | p := Point{1, 2}
2230 | q := Point{4, 6}
2231 | fmt.Println(Distance(p, q)) // "5", function call
2232 | fmt.Println(p.Distance(q)) // "5", method call
2233 | }
2234 |
2235 | ```
2236 |
2237 | - 示例二：
2238 |
2239 | ```go
2240 | package main
2241 |
2242 | import (
2243 | "fmt"
2244 | )
2245 |
2246 | /* 定义结构体 */
2247 | type Circle struct {
2248 | radius float64
2249 | }
2250 |
2251 | func main() {
2252 | var c1 Circle
2253 | c1.radius = 10.00
2254 | fmt.Println("圆的面积 = ", c1.getArea())
2255 | }
2256 |
2257 | //该 method 属于 Circle 类型对象中的方法
2258 | func (c Circle) getArea() float64 {
2259 | //c.radius 即为 Circle 类型对象中的属性
2260 | return 3.14 * c.radius * c.radius
2261 | }
2262 | ```
2263 |
2264 | - [ ] 参考链接：[方法参考1](https://github.com/ffhelicopter/Go42/blob/master/content/42_20_method.md)、[方法参考2](https://github.com/unknwon/the-way-to-go_ZH_CN/blob/master/eBook/10.6.md)、[方法参考3](https://gfw.go101.org/article/method.html)
2265 |
2266 |
2267 |
2268 | Day016: 数据-Go语言接口
2269 |
2270 | - [x] 本节说明：本节介绍Go语言接口(interface)的相关内容。
2271 |
2272 | - [ ] 程序语言接口：
2273 |
2274 | - 什么是接口？
2275 |
2276 | - [x] Go语言接口概述：
2277 |
2278 | - Go语言接口类型是对其他类型行为的概括与抽象。
2279 |
2280 | - Go语言的接口非常灵活，通过接口可以实现很多面向对象的特性。
2281 |
2282 | - Go语言接口定义了一组方法，这些方法不包含具体实现代码。它们是抽象的。接口里也不能包含变量。
2283 |
2284 | - Go语言中的所有类型包括自定义类型都实现了interface{}接口，所有的类型如string、 int、 int64甚至是自定义的结构体类型都拥有interface{}空接口，这一点interface{}和Java中的Object类比较相似。
2285 |
2286 | - 一个接口可以包含一个或多个其他的接口，但是在接口内不能嵌入结构体，也不能嵌入接口自身。
2287 |
2288 | - 空接口interface{}可以被当做任意类型的数值。
2289 |
2290 | - 接口的定义是非常棒的，而且也是实现Go语言中多态性的唯一途径。
2291 |
2292 | - Go语言中的接口都很简短，通常它们会包含0个或最多3个方法。
2293 |
2294 | - 使用接口可以使代码更具有普适性。
2295 |
2296 | - 接口类型的未初始化变量的值为nil。
2297 |
2298 | ```go
2299 | var i interface{} = 99 // i可以是任何类型
2300 | i = 44.09
2301 | i = "All" // i 可接受任意类型的赋值
2302 | ```
2303 |
2304 | - [x] Go语言接口定义：
2305 | - 接口是一组抽象方法的集合，它必须由其他非接口类型实现，不能自我实现。Go 语言通过它可以实现很多面向对象的特性。通过如下格式定义接口：
2306 |
2307 | ```go
2308 | type Namer interface {
2309 | Method1(param_list) return_type
2310 | Method2(param_list) return_type
2311 | ...
2312 | }
2313 | ```
2314 |
2315 | - [x] Go语言接口案例：
2316 |
2317 | - 示例1：
2318 |
2319 | ```go
2320 | package main
2321 |
2322 | import "fmt"
2323 |
2324 | type Shaper interface {
2325 | Area() float32
2326 | }
2327 |
2328 | type Square struct {
2329 | side float32
2330 | }
2331 |
2332 | func (sq *Square) Area() float32 {
2333 | return sq.side * sq.side
2334 | }
2335 |
2336 | func main() {
2337 | sq1 := new(Square)
2338 | sq1.side = 2
2339 |
2340 | var areaIntf Shaper
2341 | areaIntf = sq1
2342 | fmt.Printf("The square has area: %f\n", areaIntf.Area())
2343 | }
2344 |
2345 | ```
2346 |
2347 | - 示例2：接口嵌套接口。接口File包含了ReadWrite和Lock的所有方法，它还额外有一个Close()方法。
2348 |
2349 | ```go
2350 | type ReadWrite interface {
2351 | Read(b Buffer) bool
2352 | Write(b Buffer) bool
2353 | }
2354 |
2355 | type Lock interface {
2356 | Lock()
2357 | Unlock()
2358 | }
2359 |
2360 | type File interface {
2361 | ReadWrite
2362 | Lock
2363 | Close()
2364 | }
2365 | ```
2366 |
2367 | - [ ] 接口排序：
2368 |
2369 | - 使用 Sorter 接口排序
2370 |
2371 | - [ ] 参考链接：[接口参考1](https://github.com/ffhelicopter/Go42/blob/master/content/42_19_interface.md)、[接口参考2](https://github.com/unknwon/the-way-to-go_ZH_CN/blob/master/eBook/11.1.md)、[接口参考3](https://gfw.go101.org/article/interface.html)
2372 |
2373 |
2374 |
2375 | Day017: 并发-Go协程并发
2376 |
2377 | - [x] 本节说明：本节介绍Go语言并发协程(goroutine)相关内容。
2378 |
2379 | - [ ] 程序语言并发：
2380 |
2381 | - 线程、进程、协程
2382 |
2383 | - [x] Go语言协程goroutine概述：
2384 |
2385 | - Go语言原生支持应用之间的通信（网络，客户端和服务端，分布式计算）和程序的并发。
2386 | - Go语言协程比其他语言协程更强大，也很容易从协程的逻辑复用到Go协程。
2387 | - 在Go语言中，协程是创建计算的唯一途径。
2388 | - Go语言不支持创建系统线程，协程是一个Go程序内部唯一的并发实现方式。
2389 |
2390 | - [ ] 协程goroutine用法：
2391 |
2392 | - 使用go关键字。
2393 | - 启动一个新的协程时，协程的调用会立即返回。与函数不同，程序控制不会去等待 Go 协程执行完毕。在调用 Go 协程之后，程序控制会立即返回到代码的下一行，忽略该协程的任何返回值。
2394 | - 如果希望运行其他 Go 协程，Go 主协程必须继续运行着。如果 Go 主协程终止，则程序终止，于是其他 Go 协程也不会继续运行。
2395 |
2396 | - [x] 协程goroutine案例：
2397 |
2398 | - 案例一：使用延时来返回协程的返回值
2399 |
2400 | ```go
2401 | func main() {
2402 | start := time.Now()
2403 | go tester()
2404 | time.Sleep(1 * time.Millisecond)
2405 | end := time.Now()
2406 | delta := end.Sub(start)
2407 | g.Println(delta)
2408 | }
2409 |
2410 | func tester() {
2411 | i := 0
2412 | HERE:
2413 | g.Println(i)
2414 | i++
2415 | if i == 10 {
2416 | return
2417 | }
2418 | goto HERE
2419 | }
2420 | ```
2421 |
2422 | - [ ] 恐慌：一些致命性错误不属于恐慌。对于官方标准编译器来说，很多致命性错误（比如堆栈溢出和内存不足）不能被恢复。它们一旦产生，程序将崩溃。
2423 |
2424 | - 产生一个恐慌
2425 | - 消除一个恐慌
2426 |
2427 | - [ ] 恢复：
2428 |
2429 | - [x] 参考链接：[协程参考1](https://github.com/unknwon/the-way-to-go_ZH_CN/blob/master/eBook/14.1.md)、[协程参考2](https://gfw.go101.org/article/control-flows-more.html)
2430 |
2431 | - [ ] 本节案例：
2432 |
2433 |
2434 |
2435 | Day018: 并发-Go语言通道
2436 |
2437 | - [x] 本节说明：本节介绍Go语言通道(channel)的相关内容。
2438 |
2439 | - [x] Go语言通道channel概述：
2440 | - Go语言设计团队的首任负责人Rob Pike对并发编程的一个建议是：**不要让计算通过共享内存来通讯，而应该通过通讯来共享内存**。 通道就是这种哲学的一个设计结果。在Go语言中，可以认为一个计算就是一个协程。channel是协程之间互相通信的通道，协程之间可以通过它发送消息和接收消息。
2441 | - 通过共享内存来通讯和通过通讯来共享内存是并发编程中的两种编程风格。
2442 | - 一个通道可以看作是在一个程序内部的一个先进先出（FIFO：first in first out）数据队列。 一些协程可以向此通道发送数据，另外一些协程可以从此通道接收数据。
2443 | - 通道是Go语言中的一等公民类型，是Go语言的招牌特性之一。 和协程一起使用，这两个招牌特性使得使用Go进行并发编程变得方便和有趣，降低了并发编程的难度。通道的主要作用是用来实现并发同步。
2444 | - 通道是进程内的通信方式，因此通过通道传递对象的行为与函数调用时参数传递行为比较一致，比如也可以传递指针等。
2445 | - 通道可以想像成Go语言协程之间通信的管道。如同管道中的水会从一端流到另一端，通过使用信道，数据也可以从一端发送，在另一端接收。
2446 | - 通道的一个问题是通道的编程体验常常很有趣以至于程序员们经常在并非是通道的最佳应用场景中仍坚持使用通道。
2447 |
2448 | - [ ] 通道类型和值：
2449 | - 和数组、切片以及映射类型一样，每个通道类型也有一个元素类型。 一个通道只能传送它的（通道类型的）元素类型的值。
2450 | - 通道可以是双向的，也可以是单向的。
2451 | 1、字面形式`chan T`表示一个元素类型为`T`的双向通道类型。 编译器允许从此类型的值中接收和向此类型的值中发送数据。
2452 | 2、字面形式`chan<- T`表示一个元素类型为`T`的单向发送通道类型。 编译器不允许从此类型的值中接收数据。
2453 | 3、字面形式`<-chan T`表示一个元素类型为`T`的单向接收通道类型。 编译器不允许向此类型的值中发送数据。
2454 | - 一个非零通道值必须通过内置的make函数来创建。 比如make(chan int, 10)将创建一个元素类型为int的通道值。 第二个参数指定了欲创建的通道的容量。此第二个实参是可选的，它的默认值为0。
2455 |
2456 | - [ ] 通道值的比较：
2457 |
2458 | - 所有通道类型均为可比较类型。比较这两个通道的结果为布尔值。
2459 |
2460 | - [ ] 通道操作：
2461 | - 同一个操作符 <- 既用于发送也用于接收，但Go会根据操作对象弄明白该干什么。
2462 | - Go语言中有五种通道相关的操作。假设一个通道为ch，下面列出了这五种操作的语法或者函数调用：
2463 | 1、调用内置函数close来关闭一个通道：
2464 |
2465 | ```go
2466 | close(ch)
2467 | ```
2468 | 2、向通道ch发送一个值v。ch不能为单向接收通道。<-称为数据发送操作符。
2469 | ```go
2470 | ch <- v
2471 | ```
2472 | 3、从通道ch接收一个值。
2473 | ```go
2474 | <-ch
2475 | ```
2476 | 4、查询一个通道的容量。
2477 | ```go
2478 | cap(ch)
2479 | ```
2480 | 5、查询一个通道的长度。
2481 | ```go
2482 | len(ch)
2483 | ```
2484 | - 通道可以分为三类：
2485 | 1、零值（nil）通道。
2486 | 2、非零值但已关闭的通道。
2487 | 3、非零值并且尚未关闭的通道。
2488 |
2489 | | 操作 | 一个零值nil通道 | 一个非零值但已关闭的通道 | 一个非零值且尚未关闭的通道 |
2490 | | :------: | :-------------: | :----------------------: | :------------------------: |
2491 | | 关闭 | 产生恐慌 | 产生恐慌 | 成功关闭(C) |
2492 | | 发送数据 | 永久阻塞 | 产生恐慌 | 阻塞或者成功发送(B) |
2493 | | 接收数据 | 永久阻塞 | 永不阻塞(D) | 阻塞或者成功接收(A) |
2494 |
2495 | - [ ] 死锁：
2496 |
2497 | - [ ] 恐慌绝望：
2498 |
2499 | - [ ] 通道案例：
2500 | - 通道案例一：
2501 |
2502 | ```go
2503 | package main
2504 |
2505 | import (
2506 | "fmt"
2507 | )
2508 |
2509 | func hello(done chan bool) {
2510 | fmt.Println("Hello world goroutine")
2511 | done <- true
2512 | }
2513 | func main() {
2514 | done := make(chan bool)
2515 | go hello(done)
2516 | <-done
2517 | fmt.Println("main function")
2518 | }
2519 | ```
2520 |
2521 | - 通道案例二：
2522 |
2523 | ```go
2524 | package main
2525 |
2526 | import (
2527 | "fmt"
2528 | "time"
2529 | )
2530 |
2531 | func main() {
2532 | c := make(chan int) // 一个非缓冲通道
2533 | go func(ch chan<- int, x int) {
2534 | time.Sleep(time.Second)
2535 | // <-ch // 此操作编译不通过
2536 | ch <- x*x // 阻塞在此，直到发送的值被接收
2537 | }(c, 3)
2538 | done := make(chan struct{})
2539 | go func(ch <-chan int) {
2540 | n := <-ch // 阻塞在此，直到有值发送到c
2541 | fmt.Println(n) // 9
2542 | // ch <- 123 // 此操作编译不通过
2543 | time.Sleep(time.Second)
2544 | done <- struct{}{}
2545 | }(c)
2546 | <-done // 阻塞在此，直到有值发送到done
2547 | fmt.Println("bye")
2548 | }
2549 | ```
2550 |
2551 | - 通道案例三：
2552 |
2553 | ```go
2554 | package main
2555 |
2556 | import "fmt"
2557 |
2558 | func main() {
2559 | c := make(chan int, 2) // 一个容量为2的缓冲通道
2560 | c <- 3
2561 | c <- 5
2562 | close(c)
2563 | fmt.Println(len(c), cap(c)) // 2 2
2564 | x, ok := <-c
2565 | fmt.Println(x, ok) // 3 true
2566 | fmt.Println(len(c), cap(c)) // 1 2
2567 | x, ok = <-c
2568 | fmt.Println(x, ok) // 5 true
2569 | fmt.Println(len(c), cap(c)) // 0 2
2570 | x, ok = <-c
2571 | fmt.Println(x, ok) // 0 false
2572 | x, ok = <-c
2573 | fmt.Println(x, ok) // 0 false
2574 | fmt.Println(len(c), cap(c)) // 0 2
2575 | close(c) // 此行将产生一个恐慌
2576 | c <- 7 // 如果上一行不存在，此行也将产生一个恐慌。
2577 | }
2578 | ```
2579 |
2580 | - 通道案例四：
2581 |
2582 | ```go
2583 | package main
2584 |
2585 | import (
2586 | "fmt"
2587 | "time"
2588 | )
2589 |
2590 | func main() {
2591 | var ball = make(chan string)
2592 | kickBall := func(playerName string) {
2593 | for {
2594 | fmt.Print(<-ball, "传球", "\n")
2595 | time.Sleep(time.Second)
2596 | ball <- playerName
2597 | }
2598 | }
2599 | go kickBall("张三")
2600 | go kickBall("李四")
2601 | go kickBall("王二麻子")
2602 | go kickBall("刘大")
2603 | ball <- "裁判" // 开球
2604 | var c chan bool // 一个零值nil通道
2605 | <-c // 永久阻塞在此
2606 | }
2607 | ```
2608 |
2609 | - 通道案例五：
2610 |
2611 | ```go
2612 | // chanmain
2613 | package main
2614 |
2615 | import (
2616 | "fmt"
2617 | )
2618 |
2619 | func main() {
2620 | done := make(chan bool)
2621 | data := make(chan int)
2622 | go xfz(data, done)
2623 | go scz(data)
2624 | <-done
2625 |
2626 | }
2627 |
2628 | func xfz(data chan int, done chan bool) {
2629 | for x := range data {
2630 | fmt.Println("recv:", x)
2631 | }
2632 | done <- true
2633 | }
2634 |
2635 | func scz(data chan int) {
2636 | for i := 0; i < 100; i++ {
2637 | data <- i
2638 | }
2639 | close(data)
2640 | }
2641 | ```
2642 |
2643 | - [ ] 本节参考：[通道参考1](https://github.com/ffhelicopter/Go42/blob/master/content/42_22_channel.md)、[通道参考2](https://github.com/unknwon/the-way-to-go_ZH_CN/blob/master/eBook/14.2.md)、[通道参考3](https://blog.csdn.net/ytd7777/article/details/85004371)、[通道参考4](https://gfw.go101.org/article/channel.html)
2644 |
2645 | - [ ] 本节案例：
2646 |
2647 |
2648 |
2649 |
2650 | ## 02-Go语言进阶
2651 |
2652 |
2653 | Day023: 测试-Go语言测试
2654 |
2655 | - [ ] 本节说明：本节介绍Go语言测试的相关内容。
2656 |
2657 | - [x] Go语言介绍：
2658 |
2659 | - Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。
2660 |
2661 | - [x] Go语言命令：
2662 |
2663 | - go run hello.go //编译运行hello.go
2664 |
2665 | - [ ] 本节案例：
2666 |
2667 |
2668 |
2669 | Day017: 错误-Go错误处理
2670 |
2671 | - [x] 本节说明：本节介绍Go语言中的错误处理。
2672 |
2673 | - [x] 错误处理介绍：
2674 |
2675 | - Go语言中没有像 Java等语言的 try/catch异常机制，不能执行抛异常操作。但是有defer-panic-and-recover 机制。这种机制就是错误处理。
2676 | - Go语言的设计者觉得try/catch 机制的使用太泛滥了，而且从底层向更高的层级抛异常太耗费资源。他们给Go语言设计的机制也可以 “捕捉” 异常，但是更轻量，并且只应该作为（处理错误的）最后的手段。
2677 | - Go语言是怎么处理普通错误的呢？通过在函数和方法中返回错误对象作为它们的唯一或最后一个返回值——如果返回 nil，则没有错误发生——并且主调（calling）函数总是应该检查收到的错误。
2678 | - Go语言检查和报告错误条件的惯有方式：
2679 | - 产生错误的函数会返回两个变量，一个值和一个错误码；如果后者是 nil 就是成功，非 nil 就是发生了错误。
2680 | - 为了防止发生错误时正在执行的函数（如果有必要的话甚至会是整个程序）被中止，在调用函数后必须检查错误。
2681 |
2682 | - [x] 错误处理：
2683 |
2684 | - Go 有一个预先定义的 error 接口类型：
2685 |
2686 | ```go
2687 | type error interface {
2688 | Error() string
2689 | }
2690 | ```
2691 |
2692 | - [ ] 定义错误：
2693 |
2694 | - [ ] [错误参考1](https://github.com/unknwon/the-way-to-go_ZH_CN/blob/master/eBook/13.1.md)
2695 |
2696 | - [ ] 本节案例：
2697 |
2698 |
2699 |
2700 | Day024: 进阶-Go同步与锁
2701 |
2702 | - [ ] 本节说明：
2703 |
2704 | - [x] Go语言介绍：
2705 |
2706 | - Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。
2707 |
2708 | - [x] Go语言命令：
2709 |
2710 | - go run hello.go //编译运行hello.go
2711 |
2712 | - [ ] 本节案例：
2713 |
2714 |
2715 |
2716 | Day024: 对象-Go面向对象
2717 |
2718 | - [x] 本节说明：本节介绍Go语言面向对象的相关内容。
2719 |
2720 | - [ ] Go面向对象：
2721 |
2722 | - Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。
2723 |
2724 | - [ ] [面向对象参考1](https://github.com/unknwon/the-way-to-go_ZH_CN/blob/master/eBook/11.13.md)
2725 |
2726 | - [ ] 本节案例：
2727 |
2728 |
2729 |
2730 |
2731 | Day025: 数据-Go语言反射
2732 |
2733 | - [x] 本节说明：本节介绍Go语言反射(reflect)相关内容。
2734 |
2735 | - [ ] 反射概念介绍：
2736 |
2737 | - 在计算机科学中，反射是指计算机程序在运行时（Run time）可以访问、检测和修改它本身状态或行为的一种能力。用比喻来说，反射就是程序在运行的时候能够“观察”并且修改自己的行为。
2738 |
2739 | - [ ] Go语言反射介绍：
2740 |
2741 | - 反射是程序执行时检查其所拥有的结构。尤其是类型的一种能力。是元编程的一种形式。
2742 |
2743 | - [ ] [反射参考1](http://c.biancheng.net/golang/reflect/)、[反射参考2](https://www.cnblogs.com/qcrao-2018/p/10822655.html)、
2744 |
2745 | - [ ] 本节案例：
2746 |
2747 |
2748 |
2749 | Day026: 泛型-Go语言泛型
2750 |
2751 | - [ ] 本节说明：本节介绍Go语言中泛型的相关内容。
2752 |
2753 | - [x] 泛型介绍：
2754 |
2755 | - 泛型程序设计（generic programming）是程序设计语言的一种风格或范式。泛型允许程序员在强类型程序设计语言中编写代码时使用一些以后才指定的类型，在实例化时作为参数指明这些类型。各种程序设计语言和其编译器、运行环境对泛型的支持均不一样。Ada、Delphi、Eiffel、Java、C#、F#、Swift和Visual Basic .NET称之为泛型（generics）；ML、Scala和Haskell称之为参数多态（parametric polymorphism）；C++和D称之为模板。具有广泛影响的1994年版的《Design Patterns》一书称之为参数化类型（parameterized type）。
2756 | - 泛型就是把类型当成参数。
2757 |
2758 | - [x] Go语言中的泛型：
2759 |
2760 | - Go目前不支持自定义泛型。
2761 | - 泛型指日可待！
2762 |
2763 | - [ ] 泛型的优点？为什么需要泛型？
2764 |
2765 | - [ ] 本节案例：
2766 |
2767 |
2768 |
2769 | Day027: 进阶-Go反序列化
2770 |
2771 | - [ ] 本节说明：
2772 |
2773 | - [x] Go语言介绍：
2774 |
2775 | - Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。
2776 |
2777 | - [x] Go语言命令：
2778 |
2779 | - go run hello.go //编译运行hello.go
2780 |
2781 | - [ ] 本节案例：
2782 |
2783 |
2784 |
2785 |
2786 | Day028: 进阶-Go垃圾回收
2787 |
2788 | - [ ] 本节说明：
2789 |
2790 | - [x] Go语言介绍：
2791 |
2792 | - Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。
2793 |
2794 | - [x] Go语言命令：
2795 |
2796 | - go run hello.go //编译运行hello.go
2797 |
2798 | - [ ] [垃圾回收参考1](https://github.com/unknwon/the-way-to-go_ZH_CN/blob/master/eBook/10.8.md)
2799 |
2800 | - [ ] 本节案例：
2801 |
2802 |
2803 |
2804 | Day029: 函数-Go内置函数
2805 |
2806 | - [x] 本节说明：本节介绍Go语言内置函数的相关内容。
2807 |
2808 | - [x] Go内置函数介绍：
2809 |
2810 | - 不引入任何库包而调用一个内置函数。
2811 | - 不需要进行导入操作就可以使用的内置函数。它们有时可以针对不同的类型进行操作，例如：len、cap 和 append，或必须用于系统级的操作，例如：panic。因此，它们需要直接获得编译器的支持。
2812 | - 内置函数和自定义函数有很多差别。其中一个差别是很多内置函数支持泛型参数，但自定义函数不支持。
2813 |
2814 | - [x] Go语言命令：
2815 |
2816 | - go run hello.go //编译运行hello.go
2817 |
2818 | - [ ] 本节案例：
2819 |
2820 |
2821 |
2822 | Day000: 进阶-Go内存结构
2823 |
2824 | - [ ] 本节说明：
2825 |
2826 | - [x] Go语言介绍：
2827 |
2828 | - Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。
2829 |
2830 | - [x] Go语言命令：
2831 |
2832 | - go run hello.go //编译运行hello.go
2833 |
2834 | - [ ] 本节案例：
2835 |
2836 |
2837 |
2838 | Day000: 进阶-Go语言进阶
2839 |
2840 | - [ ] 本节说明：
2841 |
2842 | - [x] Go语言介绍：
2843 |
2844 | - Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。
2845 |
2846 | - [x] Go语言命令：
2847 |
2848 | - go run hello.go //编译运行hello.go
2849 |
2850 | - [ ] 本节案例：
2851 |
2852 |
2853 |
2854 | ## 03-Go语言库包
2855 |
2856 | 本章节包括大量的案例，这些案例是Go语言官方标准库的使用教学。也包括优秀的第三方库，利用这些第三方库可以构建更完善的项目代码。
2857 |
2858 |
2859 | Day301: 库包-Go包的管理
2860 |
2861 | - [x] 本节说明：本节介绍Go语言库包的相关内容。
2862 | - [x] Go语言标准库概述：
2863 | - Go语言标准库就是Go包。需要import导入之后使用某些功能。
2864 | - 像 fmt、os 等这样具有常用功能的内置包在Go语言中有 150 个以上，它们被称为标准库，大部分(一些底层的除外)内置于Go本身。
2865 | - [ ] 包发布：
2866 | - [ ] 本节案例：
2867 |
2868 |
2869 |
2870 | Day302: 库包-Go命令控制
2871 |
2872 | - [x] 本节说明：本节介绍命令控制的相关内容。主要是flag标准库的使用。
2873 | - [x] Go语言介绍：
2874 |
2875 | - Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。
2876 | - [x] Go语言命令：
2877 |
2878 | - go run hello.go //编译运行hello.go
2879 |
2880 | - [ ] 本节案例：
2881 |
2882 |
2883 |
2884 | Day303: 库包-Go请求响应
2885 |
2886 | - [x] 本节说明：本节介绍Go语言中请求响应的内容。
2887 |
2888 | - [x] HTTP请求响应：
2889 | - 在漏洞利用或是在漏洞验证过程中， 经常使用到的一个方法就是对一个URL发送一个请求，然后从响应中获取相关数据来判断漏洞是否存在。
2890 | - 本小节内容是漏洞验证中较为重要的部分。
2891 |
2892 | - [ ] 请求响应包：
2893 |
2894 | - net/http
2895 |
2896 | - [x] 请求响应案例：
2897 | - 访问并读取页面：
2898 |
2899 | ```go
2900 | package main
2901 |
2902 | import (
2903 | "fmt"
2904 | "net/http"
2905 | )
2906 |
2907 | var urls = []string{
2908 | "http://www.google.com",
2909 | "http://golang.org",
2910 | "http://blog.golang.org",
2911 | }
2912 |
2913 | func main() {
2914 | for _, url := range urls {
2915 | resp, err := http.Head(url)
2916 | if err != nil {
2917 | fmt.Println("Error:", url, err)
2918 | }
2919 | fmt.Println(url, ": ", resp.Status)
2920 | }
2921 | }
2922 | ```
2923 |
2924 | - [ ] 发送GET参数请求：
2925 |
2926 | - [x] 发送POST参数请求：
2927 |
2928 | - 案例一：直接传入post参数
2929 |
2930 | ```go
2931 | payloads := "http://www.baidu.com/admin"
2932 | postStr := `username=admin&password=123456`
2933 | req, err := http.NewRequest("POST", payloads, strings.NewReader(postStr))
2934 | req.Header.Set("Accept-Encoding", "")
2935 | req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:68.0) Gecko/20100101 Firefox/68.0")
2936 | req.Header.Set("Content-Type", " application/x-www-form-urlencoded")
2937 | ```
2938 |
2939 | - 案例二：base64加密之后进行传参
2940 |
2941 | ```go
2942 | payloads := "http://www.baidu.com/admin"
2943 | base64Table2 := "REJTVEVQIFYzLjAgICAgI"
2944 | re, e := base64.StdEncoding.DecodeString(base64Table2)
2945 | if e != nil {
2946 | return nil
2947 | }
2948 | data := string(re)
2949 | req, err := http.NewRequest("POST", payloads, strings.NewReader(data))
2950 | req.Header.Set("Accept-Encoding", "")
2951 | req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:68.0) Gecko/20100101 Firefox/68.0")
2952 | req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
2953 | ```
2954 |
2955 | - 案例三：使用json格式进行传参
2956 |
2957 | ```go
2958 | payloads := "http://www.baidu.com/admin"
2959 | data := url.Values{"start":{"0"}, "offset":{"xxxx"}}
2960 | req, err := http.NewRequest("POST", payloads, strings.NewReader(data.Encode())
2961 | req.Header.Set("Accept-Encoding", "")
2962 | req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:68.0) Gecko/20100101 Firefox/68.0")
2963 | req.Header.Set("Content-Type", "application/json;charset=UTF-8")
2964 | req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
2965 | ```
2966 |
2967 | - [ ] 发送cookie参数请求：
2968 |
2969 | - [ ] 本节案例：
2970 |
2971 |
2972 |
2973 | Day304: 库包-Go配置文件
2974 |
2975 | - [ ] 本节说明：
2976 | - [x] Go语言介绍：
2977 |
2978 | - Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。
2979 | - [x] Go语言命令：
2980 |
2981 | - go run hello.go //编译运行hello.go
2982 | - [ ] 本节案例：
2983 |
2984 |
2985 |
2986 | Day305: 库包-Go文本文件
2987 |
2988 | - [x] 本节说明：本节介绍Go语言处理文本文件格式的相关内容，包括文件的读取、文件的写入等。
2989 |
2990 | - [x] Go文本处理：也就是处理TXT格式的文件。
2991 |
2992 | - 文本处理在Go语言安全开发中用到的比较多，在安全开发中经常会将文本文件的内容作为参数传递给函数，根据响应状态进行漏洞扫描与漏洞验证。 比如带扫描的网站列表，要爆破的账号密码列表等。
2993 |
2994 | - [x] 按行读取文本文件：
2995 |
2996 | - ioutil：案例一：按行读取之按行打印内容
2997 |
2998 | ```go
2999 | b, err := ioutil.ReadFile(filename)
3000 | if err != nil {
3001 | fmt.Println("Open file error!", err)
3002 | }
3003 | fmt.Println(string(b))
3004 | return string(b)
3005 | ```
3006 |
3007 | - os.File：案例二：按行读取之按行打印内容
3008 |
3009 | ```go
3010 | package main
3011 |
3012 | import (
3013 | "fmt"
3014 | "os"
3015 | )
3016 |
3017 | func main() {
3018 | userFile := "asatxie.txt"
3019 | fl, err := os.Open(userFile)
3020 | if err != nil {
3021 | fmt.Println(userFile, err)
3022 | return
3023 | }
3024 | defer fl.Close()
3025 | buf := make([]byte, 1024)
3026 | for {
3027 | n, _ := fl.Read(buf)
3028 | if 0 == n {
3029 | break
3030 | }
3031 | os.Stdout.Write(buf[:n])
3032 | }
3033 | }
3034 | ```
3035 |
3036 | - bufio：案例三：按行读取之按行打印内容
3037 |
3038 | ```go
3039 | package main
3040 |
3041 | import (
3042 | "bufio"
3043 | "fmt"
3044 | "io"
3045 | "os"
3046 | "strings"
3047 | )
3048 |
3049 | func main() {
3050 | fileName := "ip.txt"
3051 | file, err := os.OpenFile(fileName, os.O_RDWR, 0666)
3052 | if err != nil {
3053 | fmt.Println("Open file error!", err)
3054 | return
3055 | }
3056 | defer file.Close()
3057 |
3058 | stat, err := file.Stat()
3059 | if err != nil {
3060 | panic(err)
3061 | }
3062 |
3063 | var size = stat.Size()
3064 | fmt.Println("file size=", size)
3065 |
3066 | buf := bufio.NewReader(file)
3067 | for {
3068 | line, err := buf.ReadString('\n')
3069 | line = strings.TrimSpace(line)
3070 | // 实际编程中处理line即可
3071 | fmt.Println(line)
3072 | if err != nil {
3073 | if err == io.EOF {
3074 | fmt.Println("File read ok!")
3075 | break
3076 | } else {
3077 | fmt.Println("Read file error!", err)
3078 | return
3079 | }
3080 | }
3081 | }
3082 | }
3083 |
3084 | ```
3085 |
3086 | - 案例四：
3087 |
3088 | ```go
3089 | func main(){
3090 | lines, err := LineReader("file.txt", 0)
3091 | if err != nil {
3092 | }
3093 | for line := range lines {
3094 | fmt.Println(line)
3095 | }
3096 | }
3097 |
3098 | func LineReader(filename string, noff int64) (chan string,error) {
3099 | fp, err := os.Open(filename)
3100 | if err != nil {
3101 | return nil, err
3102 | }
3103 |
3104 | // if offset defined then start from there
3105 | if noff > 0 {
3106 | // and go to the start of the line
3107 | b := make([]byte, 1)
3108 | for b[0] != '\n' {
3109 | noff--
3110 | //fp.Seek(noff, os.SEEK_SET)
3111 | fp.Read(b)
3112 | }
3113 | noff++
3114 | }
3115 | out := make(chan string)
3116 | go func() {
3117 | defer fp.Close()
3118 | // we need to close the out channel in order
3119 | // to signal the end-of-data condition
3120 | defer close(out)
3121 | scanner := bufio.NewScanner(fp)
3122 | scanner.Split(bufio.ScanLines)
3123 | for scanner.Scan() {
3124 | noff, _ = fp.Seek(0, os.SEEK_CUR)
3125 | out <- scanner.Text()
3126 | }
3127 | }()
3128 |
3129 | return out, nil
3130 | }
3131 | ```
3132 |
3133 | - [ ] 把文本文件作为参数：
3134 |
3135 | - [ ] 把结果写入到文本文件中：
3136 |
3137 | - 案例一：
3138 |
3139 | ```go
3140 | package main
3141 |
3142 | import (
3143 | "fmt"
3144 | "os"
3145 | )
3146 |
3147 | func main() {
3148 | userFile := "astaxie.txt"
3149 | fout, err := os.Create(userFile)
3150 | if err != nil {
3151 | fmt.Println(userFile, err)
3152 | return
3153 | }
3154 | defer fout.Close()
3155 | for i := 0; i < 10; i++ {
3156 | fout.WriteString("Just a test!\r\n")
3157 | fout.Write([]byte("Just a test!\r\n"))
3158 | }
3159 | }
3160 |
3161 | ```
3162 |
3163 | - 案例二：将值传递给domain即可
3164 |
3165 | ```go
3166 | fileName := "is.txt"
3167 | fd, _ := os.OpenFile(fileName, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0644)
3168 | s := strings.Join([]string{domain, "\t", "\n"}, "")
3169 | buf := []byte(s)
3170 | fd.Write(buf)
3171 | fd.Close()
3172 | ```
3173 |
3174 | - [x] [读写数据参考1](https://github.com/unknwon/the-way-to-go_ZH_CN/blob/master/eBook/12.0.md)、[文本处理参考1](http://c.biancheng.net/golang/102/)、[golang 逐行读取文件](https://www.cnblogs.com/rojas/p/4395866.html)、[Go语言文件读取的一些总结](https://segmentfault.com/a/1190000023691973)
3175 |
3176 | - [ ] 本节案例：
3177 |
3178 |
3179 |
3180 |
3181 | Day306: 库包-Go电子表格
3182 |
3183 | - [ ] 本节说明：
3184 | - [x] Go语言介绍：
3185 |
3186 | - Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。
3187 | - [x] Go语言命令：
3188 |
3189 | - go run hello.go //编译运行hello.go
3190 | - [ ] 本节案例：
3191 |
3192 |
3193 |
3194 | Day307: 库包-Go数据入库
3195 |
3196 | - [ ] 本节说明：
3197 | - [x] Go语言介绍：
3198 |
3199 | - Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。
3200 | - [x] Go语言命令：
3201 |
3202 | - go run hello.go //编译运行hello.go
3203 | - [ ] 本节案例：
3204 |
3205 |
3206 |
3207 | Day308: 库包-Go日志记录
3208 |
3209 | - [x] 本节说明：本节是用来介绍Go日志的相关内容，包括日志记录等。
3210 |
3211 | - [x] log标准库：
3212 |
3213 | ```go
3214 | package main
3215 |
3216 | import (
3217 | "io"
3218 | "log"
3219 | "os"
3220 | "time"
3221 | )
3222 |
3223 | func main() {
3224 | // 日志保存到文件中-开始
3225 | filename := time.Now().Format("app-20060102150405") + ".log"
3226 | f, err := os.OpenFile(filename, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0666)
3227 | if err != nil {
3228 | log.Fatal(err)
3229 | }
3230 | defer f.Close()
3231 | writers := []io.Writer{
3232 | f,
3233 | os.Stdout}
3234 | fileAndStdoutWriter := io.MultiWriter(writers...)
3235 | logger := log.New(fileAndStdoutWriter, "", log.Ldate|log.Ltime)
3236 | // 日志保存到文件中-结束
3237 |
3238 | logger.Println("Hello World!")
3239 |
3240 | }
3241 | ```
3242 |
3243 | - [ ] 本节案例：
3244 |
3245 |
3246 |
3247 | Day309: 库包-Go错误处理
3248 |
3249 | - [ ] 本节说明：
3250 | - [x] Go语言介绍：
3251 |
3252 | - Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。
3253 | - [x] Go语言命令：
3254 |
3255 | - go run hello.go //编译运行hello.go
3256 | - [ ] 本节案例：
3257 |
3258 |
3259 |
3260 | Day309: 库包-Go单元测试
3261 |
3262 | - [ ] 本节说明：
3263 | - [x] Go语言介绍：
3264 |
3265 | - Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。
3266 | - [x] Go语言命令：
3267 |
3268 | - go run hello.go //编译运行hello.go
3269 | - [ ] 本节案例：
3270 |
3271 |
3272 |
3273 | Day310: 库包-Go协程任务
3274 |
3275 | - [ ] 本节说明：
3276 | - [x] Go语言介绍：
3277 |
3278 | - Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。
3279 | - [x] Go语言命令：
3280 |
3281 | - go run hello.go //编译运行hello.go
3282 | - [ ] 本节案例：
3283 |
3284 |
3285 |
3286 | Day311: 库包-Go电子邮件
3287 |
3288 | - [ ] 本节说明：本节介绍Go语言中电子邮件的发送内容。
3289 |
3290 | - [x] net/smtp标准库：
3291 |
3292 | - [ ] 本节案例：
3293 |
3294 |
3295 |
3296 | Day000: 库包-Go时间日期
3297 |
3298 | - [ ] 本节说明：本节介绍Go语言中时间和日期的相关内容。
3299 | - [ ] Go语言时间操作：
3300 | - [ ] Go语言日期操作：
3301 | - [x] 一些具体使用的例子。
3302 | - 计算函数执行时间：
3303 |
3304 | ```go
3305 | start := time.Now()
3306 | end := time.Now()
3307 | delta := end.Sub(start)
3308 | fmt.Printf("all time: %s\n", delta)
3309 | ```
3310 |
3311 | - 计算日期差值：
3312 |
3313 | - [ ] [时间日期参考1](https://github.com/unknwon/the-way-to-go_ZH_CN/blob/master/eBook/04.8.md)、[时间日期参考2](https://github.com/unknwon/the-way-to-go_ZH_CN/blob/master/eBook/06.11.md)
3314 |
3315 | - [ ] 本节案例：
3316 |
3317 |
3318 |
3319 | Day000: 库包-Go输入输出
3320 |
3321 | - [x] 本节说明：本节介绍Go语言中输入输出的相关内容。
3322 | - [x] Go语言输入输出：
3323 |
3324 | - Go语言标准库就是Go包。需要import导入之后使用某些功能。
3325 | - [ ] 输入案例参考：
3326 | - 案例1：
3327 |
3328 | ```
3329 | package main
3330 |
3331 | import (
3332 | "fmt"
3333 | )
3334 |
3335 | func main() {
3336 | var a int
3337 | fmt.Printf("请输入a:")
3338 | fmt.Scanf("%d", &a)
3339 | //fmt.Scan(&a)
3340 | fmt.Println("a =", a)
3341 |
3342 | }
3343 | ```
3344 |
3345 | - [ ] 本节案例：
3346 |
3347 |
3348 |
3349 | Day000: 库包-Go正则匹配
3350 | - [x] 本节说明：本节介绍Go语言中正则匹配的相关内容。
3351 | - [x] Go语言正则匹配：
3352 | - 在请求响应中经常会根据响应的内容作出判断及操作。也经常需要对响应的内容进行信息提取之后进行下一步的操作，操作的过程中会经常使用正则匹配的方法进行。
3353 | - [x] Go语言命令：
3354 | - go run hello.go //编译运行hello.go
3355 | - [ ] 本节案例：
3356 |
3357 |
3358 |
3359 | Day000: 库包-Go精密计算
3360 |
3361 | - [ ] 本节说明：
3362 | - [x] Go语言介绍：
3363 |
3364 | - Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。
3365 | - [x] Go语言命令：
3366 |
3367 | - go run hello.go //编译运行hello.go
3368 | - [ ] 本节案例：
3369 |
3370 |
3371 |
3372 | Day000: 库包-Go读写数据
3373 |
3374 | - [ ] 本节说明：
3375 | - [x] Go语言介绍：
3376 |
3377 | - Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。
3378 | - [x] Go语言命令：
3379 |
3380 | - go run hello.go //编译运行hello.go
3381 |
3382 | - [ ] 本节案例：
3383 |
3384 |
3385 |
3386 | Day000: 库包-Go保存数据
3387 |
3388 | - [ ] 本节说明：
3389 | - [x] Go语言介绍：
3390 |
3391 | - Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。
3392 | - [x] Go语言命令：
3393 |
3394 | - go run hello.go //编译运行hello.go
3395 | - [ ] 本节案例：
3396 |
3397 |
3398 |
3399 | Day000: 库包-Go语言库包
3400 |
3401 | - [ ] 本节说明：
3402 | - [x] Go语言介绍：
3403 |
3404 | - Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。
3405 | - [x] Go语言命令：
3406 |
3407 | - go run hello.go //编译运行hello.go
3408 | - [ ] 本节案例：
3409 |
3410 |
3411 |
3412 | Day000: 库包-Go语言库包
3413 |
3414 | - [ ] 本节说明：
3415 | - [x] Go语言介绍：
3416 |
3417 | - Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。
3418 | - [x] Go语言命令：
3419 |
3420 | - go run hello.go //编译运行hello.go
3421 | - [ ] 本节案例：
3422 |
3423 |
3424 |
3425 | Day000: 库包-Go语言库包
3426 |
3427 | - [ ] 本节说明：
3428 | - [x] Go语言介绍：
3429 |
3430 | - Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。
3431 | - [x] Go语言命令：
3432 |
3433 | - go run hello.go //编译运行hello.go
3434 | - [ ] 本节案例：
3435 |
3436 |
3437 |
3438 | ## 04-Go语言算法
3439 |
3440 |
3441 | Day000: 算法-Go排序算法
3442 |
3443 | - [ ] 本节说明：
3444 | - [x] 排序算法介绍：
3445 |
3446 | - 递归函数、递归算法、
3447 | - [ ] Go排序算法：
3448 | - [ ] 本节案例：
3449 |
3450 |
3451 |
3452 | Day000: 算法-Go递归算法
3453 | - [ ] 本节说明：
3454 | - [x] 递归算法介绍：
3455 | - 递归函数、递归算法、
3456 | - [ ] Go递归算法：
3457 | - [ ] 本节案例：
3458 |
3459 |
3460 |
3461 | Day000: 算法-Go分治算法
3462 |
3463 | - [ ] 本节说明：
3464 | - [x] 分治算法介绍：
3465 |
3466 | - 递归函数、递归算法、
3467 | - [ ] Go分治算法：
3468 | - [ ] 本节案例：
3469 |
3470 |
3471 |
3472 | Day000: 算法-Go动态规划
3473 |
3474 | - [ ] 本节说明：
3475 | - [x] 动态规划算法介绍：
3476 |
3477 | - 递归函数、递归算法
3478 | - [ ] Go动态规划算法：
3479 | - [ ] 本节案例：
3480 |
3481 |
3482 |
3483 | Day000: 算法-Go贪心算法
3484 |
3485 | - [ ] 本节说明：
3486 | - [x] 贪心算法介绍：
3487 |
3488 | - 递归函数、递归算法
3489 | - [ ] Go贪心算法：
3490 | - [ ] 本节案例：
3491 |
3492 |
3493 |
3494 | Day000: 算法-Go二叉算法
3495 |
3496 | - [ ] 本节说明：本节介绍二叉树算法的相关内容。
3497 | - [x] 二叉树算法介绍：
3498 |
3499 | - 递归函数、递归算法
3500 | - [ ] Go贪心算法：
3501 | - [ ] 本节案例：
3502 |
3503 |
3504 |
3505 | Day000: 算法-Go回溯算法
3506 |
3507 | - [ ] 本节说明：
3508 | - [ ] 回溯算法介绍：
3509 | - [x] Go回溯算法：
3510 |
3511 | - 递归函数、递归算法、
3512 | - [ ] 本节案例：
3513 |
3514 |
3515 |
3516 | Day000: 算法-Go搜索算法
3517 |
3518 | - [ ] 本节说明：
3519 | - [ ] 搜索算法介绍：
3520 | - [x] Go搜索算法：
3521 |
3522 | - 递归函数、递归算法、
3523 | - [ ] 本节案例：
3524 |
3525 |
3526 |
3527 | Day000: 算法-Go随机算法
3528 |
3529 | - [ ] 本节说明：
3530 | - [ ] 随机算法：
3531 | - [x] Go随机算法：
3532 |
3533 | - 递归函数、递归算法、
3534 | - [ ] 本节案例：
3535 |
3536 |
3537 |
3538 | Day000: 算法-Go图论算法
3539 | - [ ] 本节说明：
3540 | - [ ] 图论算法介绍：
3541 | - [x] Go图论算法：
3542 | - 递归函数、递归算法、
3543 | - [ ] 本节案例：
3544 |
3545 |
3546 |
3547 | Day000: 算法-Go数论算法
3548 |
3549 | - [ ] 本节说明：
3550 | - [ ] 数论算法介绍：
3551 | - [x] Go数论算法：
3552 |
3553 | - 递归函数、递归算法、
3554 | - [ ] 本节案例：
3555 |
3556 |
3557 |
3558 | Day000: 算法-Go完全算法
3559 |
3560 | - [ ] 本节说明：
3561 | - [ ] 完全算法介绍：
3562 | - [x] Go完全算法：
3563 |
3564 | - 递归函数、递归算法、
3565 | - [ ] 本节案例：
3566 |
3567 |
3568 |
3569 | Day000: 算法-Go漏桶算法
3570 |
3571 | - [ ] 本节说明：本节介绍漏桶算法的相关内容。
3572 | - [ ] 漏桶算法介绍：
3573 | - [x] Go漏桶算法：
3574 |
3575 | - Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。
3576 | - [ ] [漏桶算法参考1](https://github.com/unknwon/the-way-to-go_ZH_CN/blob/master/eBook/14.15.md)
3577 | - [ ] 本节案例：
3578 |
3579 |
3580 |
3581 |
3582 | ## 05-Go产品开发
3583 |
3584 | 本章节是在深入学习Go语言的基础上开发安全项目的实例。包括域名扫描、漏洞扫描、密码爆破、病毒免杀等项目。方便在红队攻防领域或是渗透测试领域有自己开发的完善的武器库。
3585 |
3586 |
3587 | Day000: 安全-Go域名扫描
3588 |
3589 | - [x] 本节说明：本节介绍通过Go语言进行子域名发现的相关内容。
3590 | - [x] 子域名发现方法：二级三级域名的发现无外乎下面的这几种方法。
3591 | - 搜索引擎搜索：通过搜索引擎搜索子域名是一种比较好的域名收集方法。
3592 | - 子域名爆破法：通过子域名爆破收集子域名也是很好的方法。
3593 | - [ ] 子域名爆破原理：
3594 | - [ ] 子域名字典整理：
3595 | - [ ] 项目成品：
3596 | - [SubDomainG](https://github.com/0e0w/SubDomainG)：未开源
3597 |
3598 |
3599 |
3600 | Day000: 安全-Go目录扫描
3601 |
3602 | - [ ] 本节说明：
3603 | - [x] Go语言介绍：
3604 |
3605 | - Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。
3606 | - [x] Go语言命令：
3607 |
3608 | - go run hello.go //编译运行hello.go
3609 | - [ ] 本节案例：
3610 |
3611 |
3612 |
3613 |
3614 | Day000: 安全-Go端口扫描
3615 |
3616 | - [ ] 本节说明：
3617 | - [x] Go语言介绍：
3618 |
3619 | - Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。
3620 | - [x] Go语言命令：
3621 |
3622 | - go run hello.go //编译运行hello.go
3623 | - [ ] 本节案例：
3624 |
3625 |
3626 |
3627 |
3628 | Day000: 安全-Go密码爆破
3629 |
3630 | - [ ] 本节说明：
3631 | - [x] Go语言介绍：
3632 |
3633 | - Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。
3634 | - [x] Go语言命令：
3635 |
3636 | - go run hello.go //编译运行hello.go
3637 | - [ ] 本节案例：
3638 |
3639 |
3640 |
3641 |
3642 | Day000: 安全-Go漏洞扫描
3643 |
3644 | - [ ] 本节说明：
3645 | - [x] Go语言介绍：
3646 |
3647 | - Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。
3648 | - [x] Go语言命令：
3649 |
3650 | - go run hello.go //编译运行hello.go
3651 | - [ ] 本节案例：
3652 |
3653 |
3654 |
3655 | Day000: 安全-Go隧道代理
3656 |
3657 | - [ ] 本节说明：
3658 | - [x] Go语言介绍：
3659 |
3660 | - Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。
3661 | - [x] Go语言命令：
3662 |
3663 | - go run hello.go //编译运行hello.go
3664 | - [ ] 本节案例：
3665 |
3666 |
3667 |
3668 | Day000: 安全-Go病毒免杀
3669 |
3670 | - [ ] 本节说明：
3671 | - [x] Go语言介绍：
3672 |
3673 | - Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。
3674 | - [x] Go语言命令：
3675 |
3676 | - go run hello.go //编译运行hello.go
3677 | - [ ] 本节案例：
3678 |
3679 |
3680 |
3681 |
3682 | Day000: 安全-Go代码审计
3683 |
3684 | - [ ] 本节说明：
3685 | - [x] Go语言介绍：
3686 |
3687 | - Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。
3688 | - [x] Go语言命令：
3689 |
3690 | - go run hello.go //编译运行hello.go
3691 | - [ ] 本节案例：
3692 |
3693 |
3694 | ## 06-Go语言源码
3695 |
3696 | 本章节是深入理解Go语言必须要学习的内容。包括Go语言底层的功能实现方式，通过深入阅读Go语言源码达到真正深入理解Go语言的境界。
3697 |
3698 |
3699 | Day000: 源码-Go漏洞扫描
3700 |
3701 | - [ ] 本节说明：
3702 | - [x] Go语言介绍：
3703 |
3704 | - Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。
3705 | - [x] Go语言命令：
3706 |
3707 | - go run hello.go //编译运行hello.go
3708 | - [ ] 本节案例：
3709 |
3710 |
3711 |
3712 |
3713 | Day000: 源码-Go域名扫描
3714 |
3715 | - [ ] 本节说明：
3716 | - [x] Go语言介绍：
3717 |
3718 | - Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。
3719 | - [x] Go语言命令：
3720 |
3721 | - go run hello.go //编译运行hello.go
3722 | - [ ] 本节案例：
3723 |
3724 |
3725 |
3726 |
3727 | ## 07-Go加密解密
3728 |
3729 | 本章节是关于逆向工程的内容，包括Go语言开发项目的逆向工程等。
3730 |
3731 |
3732 | Day000: 逆向-Go授权认证
3733 |
3734 | - [ ] 本节说明：
3735 | - [x] Go语言介绍：
3736 |
3737 | - Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。
3738 | - [x] [逆向工程参考1](https://www.anquanke.com/member/122079)
3739 | - [ ] 本节案例：
3740 |
3741 |
3742 |
3743 | Day000: 逆向-Go逆向工程
3744 |
3745 | - [ ] 本节说明：
3746 | - [x] Go语言介绍：
3747 |
3748 | - Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。
3749 | - [x] Go语言命令：
3750 |
3751 | - go run hello.go //编译运行hello.go
3752 | - [ ] 本节案例：
3753 |
3754 |
3755 |
3756 | ## 更新记录
3757 |
3758 | ## 致谢名单
3759 |
3760 | 特别感谢：[柴树杉](https://github.com/golang-china/gopl-zh)、[无闻](https://github.com/Unknwon/the-way-to-go_ZH_CN)、[李骁](https://github.com/ffhelicopter/Go42)、[老貘](https://gfw.go101.org/article/101.html)、[王炳明](https://github.com/iswbm)、[韩茹](https://github.com/rubyhan1314)
3761 |
3762 | - https://github.com/0e0w/LearnGolang
3763 | - https://www.runoob.com/go/go-tutorial.html
3764 | - https://github.com/ffhelicopter/Go42
3765 | - https://github.com/unknwon/the-way-to-go_ZH_CN
3766 | - https://github.com/golang101/golang101
3767 | - https://github.com/iswbm/GolangCodingTime
3768 | - https://space.bilibili.com/353694001
3769 |
3770 | ## Stargazers
3771 |
3772 | [](https://github.com/LearnGolang/365Golang/stargazers)
3773 |
3774 | ## Forkers
3775 |
3776 | [](https://github.com/LearnGolang/365Golang/network/members)
3777 |
3778 |
3779 | [](https://starchart.cc/LearnGolang/365Golang)
--------------------------------------------------------------------------------