1.Go概述
程序是一段计算机指令的有序组合。程序=算法+数据结构。任何程序都可以将模块通过三种基本的控制结构（顺序、分支、循环）进行组合来实现。
Go（也称为Golang）是一种由Google开发的开源编程语言。设计目标是使编程更简单、高效和可靠。Go旨在提供高性能、简洁且易于理解的语法。它结合了传统编译型语言的速度和性能，以及动态类型语言的易用性和便捷性。
Go语言特性：
1.静态编译
2.少即是多，语法简洁简单，可读性强
3.原生支持并发编程
4.Duck模型的非侵入式接口
5.强调组合，组合优于继承
6.支持多种操作系统和体系结构的交叉编译,这里的 targetOS 是目标操作系统（如 windows、linux、darwin 等），targetArchitecture 是目标体系结构（如 amd64、arm、386 等）。
GOOS=targetOS GOARCH=targetArchitecture go build
GOOS=windows GOARCH=amd64 go build
7.大量使用接口和内置函数来提高代码的复用度
8.支持和C 语言相互调用的机制（CGO），Go 中使用 C 包来调用 C 函数，以及使用特殊的类型来处理在 Go 和 C 之间传递的数据。以下是一个简单的示例，展示了如何在 Go 中调用 C 函数：
#include <stdio.h>
void helloFromC() {
printf("Hello from C!\n");
}
package main
/*
#cgo CFLAGS: -g -Wall
void helloFromC();
*/
import "C"
func main() {
C.helloFromC()
}
9.精确依赖，并通过增量编译、并行编译以及缓存编译结果来缩短编译时间
Go语言基本命令：
2.Go基本语法
Go语言中共有25个关键字，是静态强类型语言。
强类型：编译器会确认每个变量应有的类型，错误使用将引发错误；
静态：仅支持编译时自动推断类型
Go语言中的条件语句，if判断后面不需要()，同时if可带一个初始化子语句用；跟条件分开。同时Go也不支持三元运算符
/*
if SimpleStmt;Expression {
statement
......
}
*/
if i:=10;i>8 {
//条件语句
}
switch语句说明：
注意：math.Floor(num)函数用于返回小于num的最小整数
同时，switch是惰性求值，只有在需要求值时才去计算表达式，从而降低消耗，提升性能。
for循环：
1.GO 的循环语句只有for ,没有while/do while
2.for 语句后面同样不用加( )
3.for语句的三个部分,省略任何一个时，分号不能省略
4.只留条件判断时，可以不用分号 （相当于while语句）
5.全部省略,变为无限循环
//while:
for experssion {
}
//无限循环
for {
if state {
break
}
}
goto 可以跟标签更紧密合作，可以代替break 跳出多重循环
手动实现排序
手写实现的冒泡排序，Go代码如下所示：
这里需要注意，切片作为参数传递是引用传递！
func bubbleSort(nums []int){
n:=len(nums)
// 这里i是定义排序好的数量
for i:=0;i<n-1;i++ {
// 每次排序都是从第一个元素开始冒泡
for j:=0;j<n-1-i;j++ {
if nums[j]>nums[j+1] {
nums[j+1],nums[j]=nums[j],nums[j+1]
}
}
}
}
手写实现插入排序，Go代码如下所示：
func insertSort(nums []int){
n:=len(nums)
// 从无序组第二个元素开始依次插入有序组中
for i:=1;i<n;i++{
key:=nums[i]
j:=i-1
for j>=0 && key<nums[j]{
nums[j+1]=nums[j]
j--
}
nums[j+1]=key
}
}
手动实现快速排序，具体Go代码如下
func quickSort(nums []int){
n:=len(nums)
if n<2 {
return
}
// 定义基准线
pivot:=nums[0]
low,high:=0,n-1
for low<=high {
if nums[low]<=pivot{
low++
}else{
nums[low],nums[high]=nums[high],nums[low]
high--
}
}
// 交换基准元素位置
nums[0],nums[high]=nums[high],nums[0]
// 递归排序左右子数组
quickSort(nums[:high])
quickSort(nums[high+1:])
}
3.基础数据类型及运算
Go语言中基础数据类型有：整型、浮点型、复数、布尔型、字符型、字符串型以及错误类型
可以用 reflect.TypeOf 函数来查看类型名称
1.基础类型
1.整型
整型按照是否有符号可以分为：有符号位和无符号位；
整型按照位数可以分为：int int8 int 16 int32 int32 int64
这里需要注意：不同的整型之间是不能直接比较，不能直接运算
2.浮点数
浮点数主要包括float32和float64
标准库math包中的函数都使用float64
3.复数
复数由两个浮点数表示，一个实部、一个虚部
有两种复数类型，即complex64（两个float32组成）和complex128（两个float64组成）
有三个内置复数处理函数
complex(float,float) 创建复数
real() 获取实部
image() 获取虚部
package main
import (
"fmt"
)
func main() {
// 创建复数
var comp1 complex64 = complex(2, 3) // 实部为2，虚部为3
comp2 := complex(4.5, 7.1) // 使用默认类型complex128
// 输出复数
fmt.Println("Complex 1:", comp1)
fmt.Println("Complex 2:", comp2)
// 访问实部和虚部
fmt.Println("Real part of Complex 1:", real(comp1)) // 输出实部
fmt.Println("Imaginary part of Complex 1:", imag(comp1)) // 输出虚部
}
4.布尔类型
布尔值主要包括true和false，类型长度为1byte
布尔类型无法被其他类型赋值，也不支持类型转换
这里布尔类型不支持用0和1表示真假
if 和for 语句的条件部分必须是布尔类型的值或表达式
2.运算符
运算符主要包括算术运算符、关系运算符、逻辑运算符、赋值运算符以及位运算符
1.算术运算符
算术运算符主要包括加减乘除、取模、自增、自减
**注意：**Go语言自增只支持变量++,不支持++变量，自减也是
2.关系运算符
关系运算符主要包括
==
!=
>
<
>=
<=
注意：由于布尔类型不支持转换整型，因此不等式连写，例如x<y<z这种语法是错误的！
3.逻辑运算符
逻辑运算符主要包括取反！、且&&、或||
4.赋值运算符
5.位运算符
位运算符包括
<< 左移 相当于乘以2
>> 右移 相当于除以2
& 位与
| 位或
^ 异或
位运算只对整数其作用，是底层运算，效率较高！
4.集合数据类型
Go语言中主要有三种类型的集合，分别是数组Array、切片Slice以及Map
1.数组
数组是同类元素的集合，数组变量声明后，其元素类型、数组长度均不可变
数组声明：
// 只声明未赋值H
var arr1 [5]int
// 直接赋值
arr2:=[3]int{1,2,3}
// 数组长度由初始化数量确定
arr3:=[...]int{1,2,3} //...不可省略
// 对含有下标的元素赋初值 其余元素保持零值
arr4:=[4]{0:99,3:100}
数组复制：
数组变量之间进行复制会拷贝整个数组（值拷贝）
a := [...]string{"USA", "China", "India", "Germany"}
b := a
b[0] = "Singapore"
fmt.Println("a is ", a)
fmt.Println("b is ", b)
//a is [USA China India Germany]
//b is [Singapore China India Germany]
数组传参：
与数组复制类型，只是实参拷贝一份给形参，函数调用结束则销毁，二者相互独立，传递大数组时效率较低！
func changeLocal(num [5]int) {
num[0] = 55
fmt.Println("inside function ", num)
}
func main() {
num := [...]int{5, 6, 7, 8, 8}
fmt.Println("before passing to function ", num)
changeLocal(num) //num is passed by value
fmt.Println("after passing to function ", num)
}
//before passing to function [5 6 7 8 8]
//inside function [55 6 7 8 8]
//after passing to function [5 6 7 8 8]
数组遍历：
数组遍历可以采用for循环遍历或range遍历
// for循环
a := [...]float64{67.7, 89.8, 21, 78}
for i := 0; i < len(a); i++ {
fmt.Printf("%d th element of a is %.2f\n", i, a[i])
}
// range遍历
a := [...]float64{67.7, 89.8, 21, 78}
for i, v := range a { // 第一个参数为序号，第二个为变量
fmt.Printf("%d the element of a is %.2f\n", i, v)
}
//0 the element of a is 67.70
//1 the element of a is 89.80
//2 the element of a is 21.00
//3 the element of a is 78.00
此外，range遍历的两个参数，如果只用一个会报错，可以用_占位符来表示只用一个参数
多维数组：
a := [3][2]string{
{"lion", "tiger"},
{"cat", "dog"},
{"pigeon", "peacock"}, //此处,不可忽略，否则报错
}
for _, v1 := range a {
for _, v2 := range v1 {
fmt.Printf("%s ", v2)
}
fmt.Printf("\n")
}
2.切片
由于数组的定长性和值拷贝限制其使用，因此提供切片使用，即提供长度可变的数组引用
切片声明时不能给定底层数组大小，否则变成了数组声明，同时可以使用内置函数make来声明和初始化！
切片是引用类型，不支持==运算
创建切片：
这里需要注意，如果创建切片时指定底层数组，一旦切片改变，底层数组元素也会发生改变，因为切片是对原数组的引用。因此，多个切片可以共享同一个底层数组。
// 指定底层数组创建
a := [5]int{76, 77, 78, 79, 80}//底层数组
s1 := a[0:4] // from a[0] to a[3]
s2 := a[:4] // from a[0] to a[3]
s3 := a[2:5] // from a[2] to a[4]
s4 := a[2:] // from a[2] to a[4]
fmt.Printf("%v\n%v\n%v\n%v", s1, s2, s3, s4)
//[76 77 78 79]
//[76 77 78 79]
//[78 79 80]
//[78 79 80]
// 同时创建数组和切片
//指定数组大小，只创建数组
c := [3]int{6, 7, 8}
//不指定数组大小，返回切片引用，底层数组匿名
d := []int{6, 7, 8}
//用...推断数组大小，只创建数组
e := [...]int{6, 7, 8}
内置函数 len() 返回切片当前长度
内置函数cap()返回切片底层数组容量
切片动态增加：
内置函数 append() 动态扩展切片，在底层数组容量范围内，会直接覆盖底层数组元素
package main
import "fmt"
func main() {
arr := [7]int{9, 8, 7, 6, 5, 4, 3}
sli := arr[1:3]
sli = append(sli, 20) // 增加一个20，切片容量扩展一倍
fmt.Printf("%v\n", arr) //[9 8 7 20 5 4 3]
fmt.Printf("%v\n", sli) //[8 7 20]
}
切片动态增加时，当超过底层数组容量大小时，会重新创建底层数组，并转移数据
切片增长在元素小于1000时，成倍增长，超过1000，增长速率大概为1.25
cars := []string{"Ferrari", "Honda", "Ford"}
fmt.Println("cars:", cars, "length", len(cars), "capacity", cap(cars))
//cars: [Ferrari Honda Ford] length 3 capacity 3
fmt.Printf("%x\n", &cars[0])
//c000080330
cars = append(cars, "Toyota")
fmt.Println("cars:", cars, "length", len(cars), "capacity", cap(cars))
//cars: [Ferrari Honda Ford Toyota] length 4 capacity 6 //why 6
fmt.Printf("%x\n", &cars[0])
//c0000a4000 //Why
切片合并：
内置函数 append() 还支持切片的合并，用…运算符把对应切片所有元素都取出
veggies := []string{"potatoes", "tomatoes", "brinjal"}
fruits := []string{"oranges", "apples"}
food := append(veggies, fruits...) //... 不可忽略
fmt.Println("food:", food)
//food: [potatoes tomatoes brinjal oranges apples]
切片传参：
在函数传参时，复制的是结构体拷贝，实现引用传递
func subtactOne(numbers []int) {
for i := range numbers {
numbers[i] -= 2
}
}
func main() {
nos := []int{8, 7, 6}
fmt.Println("slice before function call", nos)
//slice before function call [8 7 6]
subtactOne(nos)
fmt.Println("slice after function call", nos)
//slice after function call [6 5 4]
}
多维切片：
多维切片比多维数组灵活，每行元素个数不必相同
pls := [][]string{
{"C", "C++", "C#"},
{"JavaScript"},
{"Go", "Rust"},
}
for _, v1 := range pls {
for _, v2 := range v1 {
fmt.Printf("%s ", v2)
}
fmt.Printf("\n")
}
//C C++ C#
//JavaScript
//Go Rust
3.Map
Map用于存储一系列无序的键值对，是引用类型，不支持==运算（nil除外）
Map不是线程安全的，不支持并发写
1.初始化
Map零值不可用，只声明不初始化为nil值，不分配底层存储空间，不能添加元素
用字面量或make函数进行初始化后可以添加元素
var m1 map[string]int
fmt.Println(m1 == nil)
//true
//m1["a"] = 1 //error
m2 := map[string]int{}
fmt.Println(m2 == nil)
//false
m2["a"] = 1 //ok
m3 := make(map[string]int)
fmt.Println(m3 == nil)
//false
m3["a"] = 1 //ok
2.赋值
可在Map初始化后进行元素赋值，也可在Map初始化时直接元素赋值
personSalary := make(map[string]int)
personSalary["steve"] = 12000
personSalary["jamie"] = 15000
personSalary["mike"] = 9000
//初始化时，直接赋值
personSalary := map[string]int{
"steve": 12000,
"jamie": 15000,
}
3.元素查找
Map元素通过下标访问其实可以返回两个值（底层实际为函数，Comma-ok 法）
1.对应的value
2.对应的key是否存在的布尔值
personSalary := map[string]int{
"steve": 12000,
"jamie": 15000,
}
value, ok := personSalary["joe"]
if ok == true {
fmt.Println("Salary of joe is", value)
} else {
fmt.Println("joe not found")
}
4.Map元素遍历
Map元素可以使用range 遍历，但不保证顺序
personSalary := map[string]int{
"steve": 12000,
"jamie": 15000,
}
personSalary["mike"] = 9000
for key, value := range personSalary {
fmt.Printf("personSalary[%s] = %d\n", key, value)
}
//personSalary[mike] = 9000
//personSalary[steve] = 12000
// personSalary[jamie] = 15000
5.Map元素删除
使用内置函数delete()删除Map元素
1.key存在，对应元素被删除
2.key不存在，什么都不发生
personSalary := map[string]int{
"steve": 12000,
"jamie": 15000,
}
personSalary["mike"] = 9000
fmt.Println("map before deletion", personSalary)
delete(personSalary, "steve")
fmt.Println("map after deletion", personSalary)
//map before deletion map[jamie:15000 mike:9000 steve:12000]
//map after deletion map[jamie:15000 mike:9000]
5.Go函数
函数效率高则程序效率高，建议多用标准库函数
1.函数定义
//语法格式
func funcName(paramList)(resultList) {
coding ……
}
//paramList = input1 type1,input2 type2 ……
//resultList = output1 type1,output2 type2 ……
//多个相邻相同类型参数可以使用简写
func add(a, b int) int {
return a + b
}
Go函数中可以有多个返回值，同时返回值可以有变量名，并在函数体内可见。
**注意：**不支持函数重载，因为重载只是偶尔有用，但在实践中会引起无解和导致脆弱性
2.参数（不定参数）
不定参数，形参数目可变、不确定
不定参数声明语法格式： param … type
不定参数的形参在函数内是切片
func sum(nums ...int) int {
total := 0
for _, num := range nums {
total += num
}
return total
}
上述不定参数是不定数量，但类型是相同的，如果要实现不定数量，同时不定类型，则需要通过接口类型interface{}作为参数实现
func printAll(vals ...interface{}) {
for _, val := range vals {
fmt.Println(val)
}
}
3.匿名函数
匿名函数相当于函数字面量，可以使用函数的地方就可以使用匿名函数
//匿名函数直接调用
func(a,b int )int{
return a-b
}(5,4)
//匿名函数赋值给函数变量
var sum = func(a,b int )int{
return a+b
}
//函数作为返回值
func getFun(op string) func(a,b int )int {
return func(a,b int )int{
return a+b
}
}
4.闭包
闭包=函数+引用环境，常见于在函数内部定义匿名函数，并且该匿名函数访问定义它的外部函数的作用域
package main
import "fmt"
func main() {
// 外部函数外的变量
outsideVar := 10
// 内部函数，形成闭包
closureFunc := func() {
fmt.Println(outsideVar) // 闭包函数内部访问外部变量
}
closureFunc() // 调用闭包函数
}
函数柯里化：
函数柯里化就是把接收多个参数的函数变换成接收单一参数的函数
函数柯里化是一种将多参数函数转换为一系列单参数函数的过程。这种转换的结果是，原始函数可以通过一系列较少参数的函数来调用。
5.延迟调用（defer）
Go函数支持defer进行延迟调用
defer类似OOP语言异常处理中的final子句，常用来保证系统的资源的回收和释放。
defer Println("last")
Println("main body")
Println("first")
//main body
//first
//last
使用defer函数时，会把当时的实参值传递给形参，即使后序实参发生变化也不影响函数结果！
a := 5
defer fmt.Println(“defer 注册函数时的a值", a)
a = 10
fmt.Println(“普通函数的a值", a)
//普通函数的a值 10
//defer 注册函数时的a值 5
此外，使用多个defer时，这些defer调用以先进后出（FILO）顺序在函数返回前被执行！
name := "Naveen"
fmt.Printf("Original String: %s\n", string(name))
fmt.Printf("Reversed String: ")
for _, v := range []rune(name) {
defer fmt.Printf("%c", v)
}
//Original String: Naveen
//Reversed String: neevaN
6.递归函数
形式上：一个正在执行的函数调用了自身(直接递归).
递归不能无限制调用，因为栈空间有限
递归中必须有完成终极任务的语句
递归调用参数逐渐逼近结束条件
递归的目的是简化设计使程序易读，但通常效率较低
6.结构体和方法
1.结构体
1.结构体定义
结构体把有内在联系的不同类型的数据统一成一个整体，使它们相互关联
结构体是变量的集合，从外部看是一个实体
type Employee struct{
firstName string
lastName string
age int
salary int
}
2.带标签的结构体
结构体中的字段除了名字和类型外，还可以有一个可选的标签（tag）
标签是一个附属于字段的字符串，用于描述字段信息
标签还可以按key1:“value1” key2:“value2”键值对进行修饰，来提供编码、解码、ORM等转化辅助
可以使用反射，获取结构体标签中的每一个键值对
package main
import (
"fmt"
"reflect"
)
type Person struct {
Name string `json:"name" validate:"required"`
Age int `json:"age" validate:"min=18"`
}
func main() {
p := Person{Name: "Alice", Age: 25}
// 获取结构体字段的标签信息
t := reflect.TypeOf(p)
for i := 0; i < t.NumField(); i++ {
field := t.Field(i)
fmt.Printf("Field: %s, Tag: %s\n", field.Name, field.Tag)
}
}
3.结构变量初始化
1.可以使用字段名初始化，这样不需要按顺序，未指定的字段为零值
emp1 := Employee{
firstName: "Sam",
age: 25,
salary: 500,
lastName: “Anderson”, //逗号不能忽略
}
2.用字面量初始化，按字段类型声明顺序并全部设置，顺序不对或遗漏字段报错
emp2 := Employee{"Thomas", "Paul", 29, 800}
4.访问修改字段值
1.采用 结构变量.字段
emp := Employee{"Thomas", "Paul", 29, 800}
fmt.Println(emp.age)
2.采用（*结构变量指针）.字段
emp := &Employee{"Sam", "Anderson", 55, 6000}
fmt.Println("First Name:", (*emp).firstName)
3.采用 结构变量指针.字段，不支持->
emp := &Employee{"Sam", "Anderson", 55, 6000}
fmt.Println("First Name:", emp.firstName)
4.匿名字段
结构体字段也可以省略字段名，字段名默认为对应数据类型名称（数据类型不能重复）
type Person struct {
string
int
}
p := Person{"Naveen", 50}
p.int =60
2.方法
方法是对具体类型行为的封装，本质上是绑定到该类型的函数。
OO语言的方法通常有个隐藏的this或self指针来指向对象，Go把这个隐藏指针暴露出来，称为接受者。
func (t Type) funcName(paramList)(resultList)
func (t *Type) funcName(paramList)(resultList)
1.方法实例
type Employee struct {
name string
salary int
currency string
}
//定义方法
func (e Employee) displaySalary() {
fmt.Printf("Salary of %s is %s%d", e.name, e.currency, e.salary)
}
func main() {
emp1 := Employee{
name: "Sam Adolf",
salary: 5000,
currency: "$",
}
emp1.displaySalary()
}
其实方法可以使用等价的函数实现，具体如下所示：
type Employee struct {
name string
salary int
currency string
}
func displaySalary(e Employee) {
fmt.Printf("Salary of %s is %s%d", e.name, e.currency, e.salary)
}
func main() {
emp1 := Employee{
name: "Sam Adolf",
salary: 5000,
currency: "$",
}
displaySalary(emp1)
}
既然函数可以做，那为什么还需要方法呢？
在 Go 语言中，方法和等价的函数都能完成类似的工作。虽然它们可以完成相同的任务，但方法和函数之间存在一些差异和适用场景，其中方法更适合于特定类型的操作和面向对象的编程。
GO 的函数不能重载，导致不同类型不能用同名函数，而不同类型的方法可以同名
GO 不支持class ,使用结构代替类，结构字段用来封装对象属性，方法用来封装对象的行为
此外，方法并非结构体专有，所有自定义类型都可以定义方法
type myInt int //自定义类型
func (a *myInt) add(b myInt) myInt {
return *a + b
}
num1 := myInt(5)
num2 := myInt(10)
sum := num1.add(num2)
7.接口
Go语言中的接口是Duck模型的非侵入式接口，与传统的接口不同，非侵入式接口其具体类型实现接口不需要显式声明，只要其方法集是接口的超集，编译时会进行对应校验！
GO 接口只有方法签名，没有数据字段，没有函数体代码
类型的方法集是多个接口的超集，则实现多个接口
1.接口类定义
// 命令接口类型
type interfaceName interface{//接口类型命名通常以er为后缀
methodName(paramList)(resultList)
otherInterfaceName
}
// 匿名接口类型
interface{
methodName(paramList)(resultList)
otherInterfaceName
}
而如果匿名接口中方法集为空，即是interface{}是一种空接口，所有的类型都实现了空接口，都可以赋值或传递给空接口。
2.接口初始化
只声明未赋值的接口变量为nil
接口变量初始化需要把接口绑定到具体类型实例
未初始化的接口变量不能调用其方法
方法的接收者才能给接口变量赋值
接口变量的值包括底层类型的值和具体类型
package main
import (
"fmt"
)
// 接口定义
type Speaker interface {
Speak() string
}
// 实现接口的结构体
type Dog struct{}
// Dog 结构体实现 Speak 方法
func (d Dog) Speak() string {
return "Woof!"
}
// 创建接口的实例
func NewSpeaker() Speaker {
return Dog{} // 返回一个 Dog 类型，它满足了 Speaker 接口
}
func main() {
// 初始化接口并调用方法
speaker := NewSpeaker()
fmt.Println(speaker.Speak())
}
此外，一个接口可以包含一个或者多个接口，即嵌套接口
type ReadWrite interface {
Read(b Buffer) bool
Write(b Buffer) bool
}
type File interface{
ReadWrite
close() bool
}
3.接口类型断言
接口类型断言用来判断实现某个接口的变量是否为某个类型
若是，则返回该类型的值和true
不是，则返回该类型的零值和false
// interfaceName.(typeName)
var a interface{} = 56
v, ok := a.(int)
fmt.Println(v, ok)
//56 true
var b interface{} = true
v, ok = b.(int)
fmt.Println(v, ok)
//0 false
4.接口类型查询
接口类型查询是使用swtich语句确定接口变量底层类型
.(type)只能用于switch表达式是因为变量底层类型判断只能用接口类型断言，go 只能判断变量内存格式是否匹配某种类型，并按某种类型来解析值
func findType(i interface{}) {
switch i.(type) {//.(type)只能用于switch表达式
case string:
fmt.Printf("string and value is %s\n", i.(string))
case int:
fmt.Printf("int and value is %d\n", i.(int))
default:
fmt.Printf("Unknown type\n")
}
}
findType(77)
findType(89.98)
// int and value is 77
// Unknown typ
5.Stringer接口
Stringer 接口是 Go 语言中的一个接口，它只包含一个方法：String()，用于返回该类型的字符串表示形式。这个接口通常被用来自定义类型的字符串输出格式。
在 Go 语言中，如果某个类型实现了 Stringer 接口，那么你可以使用 fmt 包中的打印方法（如 Println 或 Sprintf）来自定义该类型的输出方式。
以下是 Stringer 接口的定义：
type Stringer interface {
String() string
}
接口的 String() 方法返回一个字符串。实现了 Stringer 接口的类型可以定义自己的 String() 方法，以便自定义该类型的字符串输出。
以下是一个简单的示例，演示了如何使用 Stringer 接口：
package main
import (
"fmt"
)
type Person struct {
Name string
Age int
}
// 实现 Stringer 接口
func (p Person) String() string {
return fmt.Sprintf("%s is %d years old", p.Name, p.Age)
}
func main() {
person := Person{"Alice", 30}
fmt.Println(person) // 输出: Alice is 30 years old
}
在这个例子中，Person 类型实现了 Stringer 接口，重写了 String() 方法，这样当我们使用 fmt.Println 打印 Person 类型的变量时，会调用 String() 方法，并输出该类型的自定义字符串格式。
总结，实现了Stringer接口的类型变量，使用fmt.Println方法打印该对象时，可以按照指定一定的格式输出，与Java中重写toString方法类似。
6.Sorter接口
标准库的sort包，定义排序要实现三个方法：
//Len() 反映元素个数的方法
//Less(i, j) 比较第 i 和 j 个元素
//Swap(i, j) 交换第 i 和 j 个元素
// 具体Sorter接口定义如下
type Sorter interface {
Len() int
Less(i, j int) bool
Swap(i, j int)
}
请基于Sorter接口实现冒泡排序：
package main
import (
"fmt"
)
type Sorter interface {
Len() int
Less(i, j int) bool
Swap(i, j int)
}
type IntArray []int
func (arr IntArray) Len() int {
return len(arr)
}
func (arr IntArray) Less(i, j int) bool {
return arr[i] < arr[j]
}
func (arr IntArray) Swap(i, j int) {
arr[i], arr[j] = arr[j], arr[i]
}
func BubbleSort(data Sorter) {
n := data.Len()
for i := 0; i < n-1; i++ {
for j := 0; j < n-i-1; j++ {
if data.Less(j+1, j) {
data.Swap(j, j+1)
}
}
}
}
func main() {
array := IntArray{64, 34, 25, 12, 22, 11, 90}
fmt.Println("Unsorted array:", array)
BubbleSort(array)
fmt.Println("Sorted array:", array)
}
7.接口特性
接口特性简称动静结合
接口静态特性：
支持在编译阶段的类型检查：当一个接口类型变量被赋值时，编译器会检查右值的类型是否实现了该接口方法集合中的所有方法。
接口动态特性：
即：使用空接口变量可以使用不同类型的变量赋值
在运行时存储在接口类型变量中的值的真实类型。比如：var i interface{} = 13中接口变量i的动态类型为int。
在运行时可以被赋值为不同的动态类型变量，从而支持运行时多态。
8.反射
变量的最基本信息是类型和值，反射可以在程序运行时检查变量的类型和值
通过反射可以获取结构体变量的各字段信息，甚至包括结构字段的tag信息
package main
import (
"fmt"
"reflect"
)
type Person struct {
Id int //首字母大写表示公开字段
Name string
Sex string
}
func (this Person) Call() {
fmt.Println("我正在打电话")
}
func getTypeAndValue(object interface{}) {
//动态获取对象object的类型信息
objectType := reflect.TypeOf(object)
objectValue := reflect.ValueOf(object)
fmt.Println("type =", objectType.Name())
fmt.Println("type =", objectType, "value =", objectValue)
// objectType.NumField() 获取字段的总数
for i := 0; i < objectType.NumField(); i++ {
field := objectType.Field(i)
value := objectValue.Field(i)
fmt.Printf("type %d = %v\n", i, field.Type)
fmt.Printf("name %d = %v\n", i, field.Name)
fmt.Printf("value %d = %v\n", i, value.Interface())
}
for i := 0; i < objectValue.NumMethod(); i++ {
method := objectValue.Method(i)
method.Call(nil)
}
}
func main() {
person := Person{1, "nancy", "mail"}
getTypeAndValue(person)
}
8.错误处理
Go语言里没有异常机制，只有错误处理，错误通过函数的多返回值来处理
Go语言的错误主要有：编译时错误、运行时错误以及逻辑错误
Go语言的错误处理方式
1.可处理，通过函数返回错误进行处理
2.不可处理，通过panic抛出错误，退出程序
1.error接口
通过error 接口 实现错误处理的标准模式，打印错误时自动调用Error()函数
type error interface{
Error() string
}
可能出错的函数最后一个返回值为错误类型，检查该返回值是否为nil，是则处理错误，否则正常调用
f, err := os.Open("/test.txt")
if err != nil {
fmt.Println(err)
return
}
fmt.Println(f.Name(), "opened successfully")
2.if快乐路径原则
“快乐路径”原则是编程中的一种设计理念，其指导思想是使函数的主要路径尽可能保持“快乐”，也就是函数的主要工作或逻辑能够尽快完成，而不被意外情况干扰。
一个例子就是通过合理的错误检查和返回，将错误处理逻辑放在函数的开头，而将主要逻辑和处理放在函数的主要部分。这样可以尽早退出函数并返回错误，但同时保持主要逻辑在函数主体内部，让主逻辑尽可能快乐。
func PerformTask(param int) (result int, err error) {
// 错误检查放在前面
if param < 0 {
return 0, errors.New("param cannot be negative")
}
// 主逻辑放在主体内部
// 这里是函数的主要逻辑，称为快乐路径
result = param * 2
return result, nil
}
3.自定义错误
error是Go语言内置的接口类型，只有一个方法Error()，用于返回错误信息的字符串表示。
标准库中errors包提供了创建简单错误信息的函数。
package main
import (
"errors"
"fmt"
)
func divide(a, b int) (int, error) {
if b == 0 {
return 0, errors.New("division by zero")
}
return a / b, nil
}
func main() {
result, err := divide(6, 2)
if err != nil {
fmt.Println("Error:", err)
} else {
fmt.Println("Result:", result)
}
result, err = divide(3, 0)
if err != nil {
fmt.Println("Error:", err)
} else {
fmt.Println("Result:", result)
}
}
此外，还可以使用fmt包的Errorf 函数创建自定义错误！
package main
import (
"fmt"
)
func someFunction() error {
return fmt.Errorf("This is a more detailed error: %s", "specific error message")
}
func main() {
err := someFunction()
if err != nil {
fmt.Println("Error:", err)
}
}
当多处错误处理存在代码重复时，可以使用goto集中处理错误！
err := firstCheckError()
if err != nil {
goto onExit
}
err = secondCheckError()
if err != nil {
goto onExit
}
// 正常处理代码
onExit:
fmt.Println(err)
exitProcess()
4.panic
panic 是 Go 语言中的内建函数之一，用于在发生不可恢复的错误时引发程序中止。panic 会停止当前函数的执行，并向调用者传播一个引发恐慌的信号，随后程序将被终止。
通常情况下，panic 用于处理严重错误，如数组越界、空指针引用等。当它被调用时，程序将停止执行当前函数，开始执行延迟（defer）函数，然后程序会崩溃，并显示 panic 产生的错误信息。 在遇到 panic 时，程序的正常流程会被打破，不会再继续执行当前任务。
在开发过程中，尽量避免使用 panic，而应该在可以预测和处理的情况下使用错误返回（error returns）或其他适当的处理方式，因为 panic 不可恢复，容易引起程序不稳定。
package main
import "fmt"
func someFunc() {
// 模拟一个无法处理的错误
err := someErrorOccurred()
if err != nil {
panic("An unexpected error occurred: " + err.Error())
}
}
func main() {
fmt.Println("Starting the program.")
someFunc()
fmt.Println("End of the program.")
}
5.recover
在 Go 语言中，recover 函数用于恢复程序的执行，从恐慌状态（panic）中恢复。recover 只有在延迟函数（defer）的内部调用时才会生效。
通常情况下，recover 与 defer 配合使用，以便在程序进入恐慌状态时恢复程序执行。
下面是一个使用 recover 来捕获并处理恐慌状态的示例：
package main
import (
"fmt"
)
func recoverDemo() {
if r := recover(); r != nil {
fmt.Println("Recovered:", r)
}
}
func someFunc() {
defer recoverDemo()
// 模拟一个恐慌状态
panic("Something went wrong!")
}
func main() {
fmt.Println("Starting the program.")
someFunc()
fmt.Println("End of the program.")
}
在这个示例中，recoverDemo 函数作为一个延迟函数（defer）在 someFunc 中执行。当 someFunc 函数引发了恐慌状态，recoverDemo 中的 recover 函数捕获到这个恐慌，然后打印出了错误信息。
请注意，recover 函数只在延迟函数中有效。在非延迟函数中调用 recover 是无效的，且只有在恐慌状态发生时才能捕获错误信息。
9.并发
1.进程、线程、协程
进程是程序在内存中运行时，操作系统对其进行资源分配和调度的独立单位
线程是进程的一个执行实体，是进程内部进行的一条执行路径，是 CPU 调度和分派的基本单位，它是比进程更小的能独立运行的基本单位
每个进程至少包括一个线程，每个进程的初始线程被称为主线程，主线程终止，进程终止
协程是轻量级的线程，一个线程可以拥有多个协程
进程和线程是操作系统级的，协程是编译器级的。协程不被操作系统内核管理，而完全由程序控制，因此没有线程切换的开销。和多线程比，数量越多，协程的性能优势就越明显。协程的最大优势在于其轻量级，可以轻松创建上万个而不会导致系统资源衰竭
2.goroutine
在Go语言中，Goroutine是并发执行的基本单元。它们是Go运行时环境中的轻量级线程，由Go调度器分配到逻辑处理器上执行。Goroutine的运行并不依赖于物理处理器或操作系统线程。每个逻辑处理器（P）负责运行Goroutine，多个P可以运行在一个物理处理器（CPU）上。
3.协程通信
不要通过共享内存来通信，而是通过通信来共享内存
协程间的通信常见是两种方式：
1.共享数据：很多语言采用共享内存来实现程序数据同步，确保程序以合乎逻辑的方式执行。在程序执行过程中，进程或线程可能对共享数据加锁，以禁止其他进程或线程修改它。总体编程复杂性高
2.消息机制：每个并发单元是独立个体，多个并发单元的数据不共享，通过消息通信来同步数据。
4.channel通道
通道是一种特殊的类型，同时只能有一个 goroutine 访问通道进行发送和获取数据。
通道写入和读取使用 <- 运算符
写入 ：通道<-变量
读取： 变量<-通道
5.缓冲通道
通道包括无缓冲通道和有缓冲通道
无缓冲通道 make(chan datatype)
有缓冲通道 make(chan datatype，capacity)
无缓冲通道只能存储一条消息，有缓冲通道可以根据make函数的capacity参数存储n条消息，按FIFO读出
func receiver(c chan string) {
for msg := range c {
fmt.Println(msg)
}
}
func main() {
messages := make(chan string, 2)
messages <- "hello"
messages <- "world"
go receiver(messages)
time.Sleep(time.Second * 1)
}//hello world
此外，还能使用内置函数返回缓冲通道状态
len()获取通道当前缓存数
cap()获取通道缓存容量
ch := make(chan string, 3)
ch <- "naveen"
ch <- "paul"
fmt.Println("capacity is", cap(ch))
fmt.Println("length is", len(ch))
fmt.Println("read value", <-ch)
fmt.Println("new length is", len(ch))
//capacity is 3
//length is 2
//read value naveen
//new length is 1
无缓冲通道，写入等待读取，读取等待写入，在双方准备好之前是阻塞的
有缓冲通道，通道已满时的写入会等待，通道已空的读取会等待
6.关闭通道
关闭通道使用内置函数close(),实际上是关闭写入，即发送者告诉接收者不会再有数据发往通道
接收者能够在通道接收数据的同时，获取通道是否已关闭的参数 。
func producer(chnl chan int) {
for i := 0; i < 10; i++ {
chnl <- i
}
close(chnl)
}
func main() {
ch := make(chan int)
go producer(ch)
for {
v, ok := <-ch
if ok == false {
break
}
fmt.Println("Received ", v, ok)
}
}
此外，for range能够自动判断通道是否关闭，具体代码如下所示：
func producer(chnl chan int) {
for i := 0; i < 10; i++ {
chnl <- i
}
close(chnl)
}
func main() {
ch := make(chan int)
go producer(ch)
for v := range ch {
fmt.Println("Received ",v)
}
}
7.WaitGroup
sync.WaitGroup 用于等待一组 Go 协程执行完成后再执行主程序的方法。它提供了一个简单的机制，以便主程序知道其他所有协程何时执行完成。
在使用 sync.WaitGroup 时，主要有三个函数：
Add(int)：增加要等待的协程数量。Done()：标志已完成的协程。Wait()：等待所有的协程都完成。
通常，Add 函数用于计数要等待的协程数量，然后在协程的函数中使用 Done 标志已经执行完毕，最后使用 Wait 阻塞主程序，直到所有协程都执行完毕。
以下是一个示例，演示了 sync.WaitGroup 的用法：
package main
import (
"fmt"
"sync"
"time"
)
func worker(id int, wg *sync.WaitGroup) {
defer wg.Done() // 标志协程完成
fmt.Printf("Worker %d starting\n", id)
time.Sleep(time.Second) // 模拟工作
fmt.Printf("Worker %d done\n", id)
}
func main() {
var wg sync.WaitGroup
for i := 1; i <= 5; i++ {
wg.Add(1) // 增加等待的协程数量
go worker(i, &wg)
}
wg.Wait() // 等待协程执行完成
fmt.Println("All workers have finished")
}
在这个示例中，我们启动了五个协程，每个协程模拟一些工作（通过 time.Sleep 模拟）。Add 用于增加要等待的协程数量，Done 标志协程已执行完成，而 Wait 阻塞了主程序直到所有的协程都执行完毕。
8.猜数字例题
这里分享一道使用协程的例题，具体例题如下：感兴趣的小伙伴可以尝试一下
9.计时器Timer
协程间的通信需设置超时等辅助机制
一次性计时器：定时器只计时一次，结束便停止
package main
import (
"fmt"
"time"
)
func main() {
timer1 := time.NewTimer(2 * time.Second)
<-timer1.C // 阻塞等待定时器信号
fmt.Println("Timer 1 expired")
timer2 := time.NewTimer(1 * time.Second)
go func() {
<-timer2.C
fmt.Println("Timer 2 expired")
}()
stop2 := timer2.Stop() // 停止定时器2
if stop2 {
fmt.Println("Timer 2 stopped")
}
}
10.定时器Ticker
周期性定时器：定时器周期性进行计时，除非主动停止，否则将永久运行
在Go语言中，time.Ticker 是用于重复间隔性触发操作的工具。与 time.Timer 不同，time.Ticker 会在一定的时间间隔内重复向通道发送时间事件。
主要方法如下所示：
func NewTicker(d Duration) *Ticker 指定一个时间创建一个Ticker ， Ticker一经创建便开始计时，不需要额外的启动命令
func (t *Ticker) Stop() 停止计时，但管道不会被关闭
示例代码如下所示：
package main
import (
"fmt"
"time"
)
func main() {
ticker := time.NewTicker(1 * time.Second)
defer ticker.Stop()
for {
select {
case <-ticker.C:
fmt.Println("Ticker ticked")
}
}
}
11.select
多路复用是在一个信道上传输多路信号或数据流，比如网线
select 借用网络多路复用的概念，用于监听多个通道，同时响应多个通道
多个通道都没有可写或可读的状态，select 会阻塞
有一个通道是可写或可读的， select 会执行该通道语句
有多个通道是可写或可读的， select 会随机选择其中一个执行
select 语句是 Go 语言用于处理通道操作的关键工具。它可以同时监听多个通道操作，一旦某个通道可操作（有消息可以接收或发送），就执行相应的 case 语句。select 语句有点类似于 switch 语句，但是专门用于通道的操作。
下面是一个示例，演示了 select 语句的用法：
package main
import (
"fmt"
"time"
)
func main() {
ch1 := make(chan string)
ch2 := make(chan string)
go func() {
time.Sleep(2 * time.Second)
ch1 <- "one"
}()
go func() {
time.Sleep(1 * time.Second)
ch2 <- "two"
}()
for i := 0; i < 2; i++ {
select {
case msg1 := <-ch1:
fmt.Println("Received", msg1)
case msg2 := <-ch2:
fmt.Println("Received", msg2)
}
}
}
在这个示例中，通过两个协程向两个不同的通道 ch1 和 ch2 发送消息。select 语句会监听这两个通道的状态，一旦有数据可接收，就执行相应的 case 语句，最终输出接收到的消息。
12.Mutex
多个线程同时竞争使用某个变量可能会导致结果失控
mutex，互斥锁，用来保证某个变量在任一时刻，只能有一个线程访问；mutex 用Lock()和Unlock()来创建资源的临界区，这一区间内的代码是线程安全的，任何一个时间点都只能有一个goroutine执行这段区间的代码
mutex 也可以用通道来代替，通道底层基于mutex，即mutex性能更高，通常不涉及线程交互数据的用mutex，其他性能要求不敏感用通道
package main
import (
"fmt"
"sync"
)
var count = 0
var mutex sync.Mutex
func increment() {
mutex.Lock() // 通过 Lock() 方法锁住共享资源
count++
mutex.Unlock() // 通过 Unlock() 方法解锁共享资源
}
func main() {
var wg sync.WaitGroup
for i := 0; i < 1000; i++ {
wg.Add(1)
go func() {
defer wg.Done()
increment()
}()
}
wg.Wait()
fmt.Println("Count:", count)
}
13.RWMutex
Mutex 在大量并发时，同一时刻只有一个协程持有锁，其他阻塞等待，性能下降
RWMutex在Mutex的基础之上增加了读、写的信号量，并使用了类似引用计数的读锁数量，可使多个协程持有读锁，适合应用在具有一定并发量且读多写少的场合。
注意：
RWMutex中可以申请多个读锁，有读锁时申请写锁将会被阻塞
只要有写锁，后序申请读锁和写锁都会被阻塞
主要方法如下：
func (rw *RWMutex) Lock() //申请写锁
func (rw *RWMutex) Unlock() //释放写锁
func (rw *RWMutex) RLock() //申请读锁
func (rw *RWMutex) RUnlock()//释放读锁
package main
import (
"fmt"
"sync"
)
var sharedData int
var rwMutex sync.RWMutex
func readData() {
rwMutex.RLock() // 读取共享资源时使用 RLock() 方法
defer rwMutex.RUnlock()
fmt.Println("Read Data:", sharedData)
}
func writeData(value int) {
rwMutex.Lock() // 写入共享资源时使用 Lock() 方法
defer rwMutex.Unlock()
sharedData = value
fmt.Println("Write Data:", value)
}
func main() {
// 读取数据
for i := 0; i < 5; i++ {
go readData()
}
// 写入数据
for i := 0; i < 5; i++ {
go writeData(i)
}
// 等待所有协程执行完毕
fmt.Scanln()
}
