Go 基础
Last updated
Last updated
[Golang教程 - 菜鸟教程](Go 基础教程 - Golang教程 - 菜鸟教程l)
package main // 包名称
import "fmt"
func main() { // main: 函数名
fmt.Println("Hello world") // Hello world
fmt.Println("1+1=",1+1) // 1+1= 2
var name = "golong" // 变量名
fmt.Println(name)
}标识符的名称必须以字母或下划线（_）开头。并且名称中可能包含字母“ a-z”或“ A-Z”或数字0-9，以及字符“
标识符的名称不能以数字开头。
标识符的名称区分大小写。
关键字不能用作标识符名称。
标识符名称的长度没有限制，但是建议仅使用4到15个字母的最佳长度。
例如:
// 有效的标识符:
_geeks23
geeks
gek23sd
Geeks
geeKs
geeks_geeks
// 无效的标识符:
212geeks
if
default// 常量
true(真), false(假), iota(计数器), nil(空)
// 类型
int, in和uint都包含相同的大小，无论是32位还是64位。
int8, 8位有符号整数
int16, 16位有符号整数
int32, 32位有符号整数
int64, 64位有符号整数
uint, in和uint都包含相同的大小，无论是32位还是64位。
uint8, 8位无符号整数
uint16, 16位无符号整数
uint32, 32位无符号整数
uint64, 64位无符号整数
uintptr, 它是无符号整数类型。它的宽度未定义，但是可以容纳指针值的所有位。
float32,
float64,
complex128,
complex64,
bool,
byte, 它是int8的同义词。
rune, 它是int32的同义词，也表示Unicode代码点
string,
error
// 函数
make, 分配并初始化切片、map、channel对象；
len, 返回长度，取决于具体类型；字符串返回字节数；channel返回缓存元素的个数；
cap, 返回容量，取决于具体类型；切片返回底层数组长度；channel返回缓存容量；
new, 分配内存，返回类型指针；不初始化切片，map，channel；
append, 将元素追加到切片，返回更新后的切片；若容量不足，则新分配一个底层数组；
copy, 切片复制，返回被复制的数量，即len(src)、len(dst)中较小的；支持字符串复制到字节切片；
close, 关闭channel；必须是双向channel或只发送channel；已关闭的channel在接收时第二参数返回false；
delete, 根据键删除map中的元素；
complex,
real,
imag,
panic, 终止程序，引发异常；
recover defer函数中调用，捕获panic错误信息；break
case
chan
const
continue
default
defer
else
fallthrough
for
func
go
goto
if
import
interface
map
package
range
return
select
struct
switch
type
var基本类型：数字(int)，字符串(string)和布尔值(bool)属于此类别。
聚合类型：数组和结构属于此类别。
引用类型：指针，切片，map集合，函数和Channel属于此类别。
接口类型
Println :可以打印出字符串，和变量
Printf : 只可以打印出格式化的字符串,可以输出字符串类型的变量
//使用字符串
package main
import "fmt"
func main() {
//用于存储字符串的str变量
str := "nhooo"
//显示字符串的长度
fmt.Println("字符串的长度:%d", len(str)) //字符串的长度:%d 5
fmt.Printf("字符串的长度:%d", len(str)) //字符串的长度:5
//显示字符串
fmt.Println("\n字符串是: %s", str) // 字符串是: %s nhooo
fmt.Printf("\n字符串是: %s", str) // 字符串是: nhooo
// 显示str变量的类型
fmt.Println("\nstr的类型是: %T", str) // str的类型是: %T nhooo
fmt.Printf("\nstr的类型是: %T", str) // str的类型是: string
}变量命名规则： 变量名称必须以字母或下划线（_）开头。并且名称中可能包含字母“ a-z”或“ A-Z”或数字0-9，以及字符" _"
创建变量的方法
使用var关键字
使用短变量声明运算符（:=）---> 只能在局部使用，不能全局
声明变量
}
变量类型: int%!(EXTRA int=0, string=, float64=0, int=111, int=222, int=333, int=2, string=abc, float64=11.44, int=2, string=3, float64=11.11, int=800, string=NHOOO, float64=47.56)
## Go 变量作用域
- 局部变量（在块或函数内部声明）
- 全局变量（在块或函数外部声明）
> 局部变量: 函数内定义的变量，函数外无法调用
> 全局变量: 函数外定义的变量，可在任何部分访问
> 如果同时存在同一的变量名称，局部变量 > 全局变量
```go
//全局变量
package main
import "fmt"
// 全局变量声明
var _var1 int = 100
func main() {
// 主函数内部的局部变量
var _var2 int = 200
//显示全局变量
fmt.Printf("全局变量 _var1 的值是 : %d\n", _var1 ) // 100
//显示局部变量
fmt.Printf("局部变量 _var2 的值是 : %d\n", _var2 ) // 200
//调用函数
display()
}
func display() {
// 显示全局变量
fmt.Printf("全局变量 _var1 的值是 : %d\n", _var1 ) // 100
}常量就像变量一样声明，但是使用 const 关键字作为前缀来声明具有特定类型的常量。不能使用 := 语法声明。
典型
package main
import "fmt"
func main() {
const mydefault = true // 赋值声明变量
type myBool bool
var new1Bool = mydefault
var new2Bool myBool = mydefault
// new1Bool = new2Bool 不允许这样使用
fmt.Println(new1Bool)
fmt.Println(new2Bool)
}+ - * / %
% 当第一个操作数除以第二个操作数时，'％'运算符返回余数。例如，x％y。
package main
import "fmt"
func main() {
a := 1
b := 2
fmt.Println(a+b) // 3
fmt.Println(a-b) // -1
fmt.Println(a*b) // 2
fmt.Println(a/b) // 0
fmt.Println(a%b) // 1
}== , != , > , < , >= , <=
package main
import "fmt"
func main() {
a := 1
b := 2
fmt.Println(a==b) // 返回： false
fmt.Println(a!=b) // 返回： true
fmt.Println(a>b) // 返回： false
fmt.Println(a<b) // 返回： true
fmt.Println(a>=b) // 返回： false
fmt.Println(a<=b) // 返回： true
}&&(逻辑AND), ||(逻辑或), !(逻辑非)
package main
import "fmt"
func main() {
p := 1
q := 2
if p != q && p <= q {
fmt.Println("True") // True
}
if p != q || p <= q {
fmt.Println("True") // True
}
if !(p == q) {
fmt.Println("True") // True
}
}＆（按位与）：将两个数字作为操作数，并对两个数字的每一位进行“与”运算。仅当两个位均为1时，AND的结果才为1。
| （按位或）：将两个数字作为操作数，并对两个数字的每一位进行“或”运算。两个位中的任何一个为1，OR的结果为1。
^（按位XOR）：将两个数字作为操作数，并对两个数字的每一位进行XOR。如果两个位不同，则XOR的结果为1。
<<（左移）：取两个数字，左移第一个操作数的位，第二个操作数决定移位的位数。
（右移）：取两个数字，右移第一个操作数的位，第二个操作数决定移位的位数。
＆^（AND NOT）：(按位清除)运算符，该运算符的实际操作为&(^)操作。
package main
import "fmt"
func main() {
p := 456
q := 793
fmt.Printf("计算结果是： p & q = %d", p & q) // 计算结果是： p & q = 264
fmt.Printf("\n计算结果是： p | q = %d", p | q) // 计算结果是： p | q = 985
fmt.Printf("\n计算结果是： p ^ q = %d", p ^ q) // 计算结果是： p ^ q = 721
fmt.Printf("\n计算结果是： p << q = %d", p << q) // 计算结果是： p << q = 0
fmt.Printf("\n计算结果是： p >> q = %d", p >> q) // 计算结果是： p >> q = 0
fmt.Printf("\n计算结果是： p &^ q = %d", p &^ q) // 计算结果是： p &^ q = 192
}赋值运算符用于为变量赋值(运算) 注意: 右侧的值必须与左侧的变量具有相同的数据类型，否则编译器将抛出错误
= , += , -= , *= , /= , %= , &= , ^= , |=
package main
import "fmt"
func main() {
p := 1
q := 2
// “=”(简单赋值)
p = q
fmt.Println(p) // 2
// “+=”(加法赋值)
p += q
fmt.Println(p) // 4, 由于上面运算已经赋值,所以是 p=2+q
//“-=”(减法赋值)
p -= q
fmt.Println(p) // 2,由于上面运算已经赋值,所以是 p=4-q
// “*=”(乘法赋值)
p *= q
fmt.Println(p) // 4,由于上面运算已经赋值,所以是 p=2*q
// “/=”(除法赋值)
p /= q
fmt.Println(p) // 2,由于上面运算已经赋值,所以是 p=4/2
// “%=”(求模赋值)
p %= q
fmt.Println(p) // 2,由于上面运算已经赋值,所以是 p=4/2
}＆：此运算符返回变量的地址。
*：此运算符提供指向变量的指针。
<-：该运算符的名称为接收。它用于从通道接收值。
package main
import "fmt"
func main() {
a := 23
b := &a
fmt.Println(*b) // 23
*b = 78
fmt.Println(a) // 78
}注意：由于Golang具有强大的类型系统，因此不允许在表达式中混合使用数字类型（例如加，减，乘，除等），并且不允许在两个混合类型之间执行赋值类型。
package main
import "fmt"
func main() {
/*
// 显示类型转换
var a int = 985
var b uint = uint(a)
var c int64 = int64(a)
var d float64 = float64(a)
fmt.Printf("转换类型： %T",b,c,d) // 转换类型： uint%!(EXTRA int64=985, float64=985)
*/
/*
// 计算平均值
var a int = 446
var b int = 23
var c float32
c = float32(a) / float32(b)
fmt.Printf("平均值 = %f",c) // 平均值 = 19.391304
*/
}package main
import "fmt"
func main() {
var a int = 100
// if 语句
if(condition) {
//condition为真,执行
}
// if...else 语句
if (condition) {
// if条件为true，执行此代码块
} else {
// if条件为false，执行此代码块
}
// 嵌套if 语句
if (condition1) {
// 当条件1为真时执行
if (condition2) {
// 当条件2为真时执行
}
}
// if...else...if 语句
if(condition_1) {
//condition_1为true,执行这里的代码块
} else if(condition_2) {
//condition_2为true,执行这里的代码块
}else {
//没有条件为true时,执行这里代码块
}
}如果数组，字符串，切片或map集合为空，则for循环不会抛出错误并继续其流程。换句话说，如果数组，字符串，切片或map为nil，则for循环的迭代次数为零。
语法:
for initialization; condition; post{
// 语句....
}initialization: 可选,循环开始之前执行(如变量声明，递增，赋值，函数)
condition: 布尔表达式，该表达式在循环的每次迭代开始时计算。如果条件语句的值为true，则执行循环。
post: for循环体之后执行。在post语句之后，条件语句再次计算条件语句的值是否为false，然后循环结束
package main
import "fmt"
func main() {
// initialization 是 i := 0 ， condition 是 i < 4 ; post 是 i++
// 意思: 定义变量i=0,从0开始，直到 i < 4 为真，每次循环之后 i+1
for i :=0; i < 4; i++ {
fmt.Println(i)
}
}
// 输出:
0
1
2
3package main
import "fmt"
func main() {
// 无限循环
for {
fmt.Printf("nhooo\n")
}
}package main
import "fmt"
func main() {
//while循环
//for循环执行到
//i <3条件为真
i:= 0
for i < 3 {
i += 2
}
fmt.Println(i)
}package main
import "fmt"
func main() {
// 定义一个数组
_var := bytestring{"a","b","c"}
// index和j是分配迭代值的变量。它们也称为迭代变量。
// 第二个变量，即j是可选的。
// 范围表达式在循环开始之前被评估一次。
// index和j存储 _var 的值
// index存储单个字符串和的索引号
// j存储给定数组的单个字符串
for index,j := range _var{
fmt.Println(index, j)
}
}
// 输出
0 a
1 b
2 cpackage main
import "fmt"
func main() {
for index, j := range "abcd" {
fmt.Println(index, j ,string(j))
// 0 97 a
// 1 98 b
// 2 99 c
// 3 100 d
}
for index, j := range "abcd" {
fmt.Printf("%U 的索引值为 %d\n", j, index,string(j))
// %!(EXTRA string=a)U+0062 的索引值为 1
// %!(EXTRA string=b)U+0063 的索引值为 2
// %!(EXTRA string=c)U+0064 的索引值为 3
// %!(EXTRA string=d)
}
}package main
import "fmt"
func main() {
res := map[int]string{
111: "a",
222: "b",
333: "c",
}
for k, v := range res {
fmt.Println(k, v)
}
}
// 输出
111 a
222 b
333 cpackage main
import "fmt"
func main() {
// 使用 channel
chnl := make(chan int)
go func() {
chnl <- 100
chnl <- 1000
chnl <- 10000
chnl <- 100000
close(chnl)
}()
for i := range chnl {
fmt.Println(i)
}
}break ---> 终止其所在的循环或语句
continue ---> 在循环中，表示结束本次循环，进行下次循环。
goto ---> 表示无条件跳转到标号处执行。
package main
import "fmt"
func main() {
_x := 0
Lable1: for _x < 8 {
if(_x == 5) {
_x = _x + 1
goto Lable1
}
fmt.Println("值为:", _x)
_x++;
}
}
// 输出
值为: 0
值为: 1
值为: 2
值为: 3
值为: 4
值为: 6
值为: 7表达式 switch
类型 switch
语法:
switch optstatement; optexpression{
case expression1: Statement..
case expression2: Statement..
...
default: Statement..
}package main
import "fmt"
// 同时使用两种语句, 如可选语句, day:=4 和表达式 如：day
func main() {
switch day := 2; day{
case 1:
fmt.Println(1)
case 2:
fmt.Println(2) // 输出2
case 3:
fmt.Println(3)
default:
fmt.Println("I don't know")
}
}switch语句不带可选语句和表达式
package main
import "fmt"
func main() {
var value int = 2
switch {
case value == 1:
fmt.Println(1)
case value == 2:
fmt.Println(2)
case value == 3:
fmt.Println(3)
default:
fmt.Println("I don't know")
}
}package main
import "fmt"
func main() {
var value string = "e"
//没有默认语句的switch语句，case语句中的多个值
switch value {
case "a":
fmt.Println("aaa")
case "b", "c":
fmt.Println("bbb")
case "d", "e", "f":
fmt.Println("ccc")
}
}package main
import (
"fmt"
)
func outType(v interface{}) {
switch v.(type) {
case int:
fmt.Println(v, "is int")
case string:
fmt.Println(v, "is string")
case bool:
fmt.Println(v, "is bool")
}
}
func main() {
outType(1024) // 1024 is int
outType("pig") // pig is string
outType(true) // true is bool
}语法
select{
case SendOrReceive1: // 语句
case SendOrReceive2: // 语句
case SendOrReceive3: // 语句
.......
default: // Statement
}设置默认值
package main
import "fmt"
func main() {
// 创建通道
c := make(chan int)
select {
case <-c:
default:
fmt.Println("default")
}
}语法
func function_name(Parameter_list)(Return_type){
// function body.....
}func: Go关键字，用于创建函数
function_name: 函数名称
Parmeter_list: 包含函数参数名称和类型
Return_type: 可选，包含函数返回值类型，如果在函数中使用return_type，则必须在函数中使用return语句。
package main
import "fmt"
// 此函数需要传两个 int 类型的值， 返回的值也是 int 类型
func abc(length, width int) int {
res := length + width
return res
}
func main() {
fmt.Println(abc(10,10)) // 调用函数
}当您要在函数中传递切片时，使用可变参数函数。
当我们不知道参数的数量时，使用可变参数函数。
在程序中使用可变参数函数时，它可以增加程序的可读性。
package main
import (
"fmt"
"strings"
)
// 可变参数函数联接字符串
func jsonStr(element ...string) string{
return strings.Join(element, "-")
}
func main() {
// 无参数
fmt.Println(jsonStr())
// 多参数
fmt.Println(jsonStr("a","b"))
fmt.Println(jsonStr("a","b","c","d"))
//在可变函数中传递一个切片
element:= []string{"geeks", "FOR", "geeks"}
fmt.Println(jsonStr(element...))
}定义格式
func(参数列表)(返回参数列表){
函数体
}在定义时调用匿名函数
func(data int) {
fmt.Println("hello", data)
}(100) // (100)，表示对匿名函数进行调用，传递参数为 100。将匿名函数赋值给变量
// 将匿名函数体保存到f()中
f := func(data int) {
fmt.Println("hello", data)
}
f(100)匿名函数用作回调函数
实现对切片的遍历操作，遍历中访问每个元素的操作使用匿名函数来实现，用户传入不同的匿名函数体可以实现对元素不同的遍历操作
简单实用
package main
import (
"fmt"
)
func main() {
// 匿名函数，无参数
func() {
fmt.Println("hello world")
}()
// 匿名函数，有参数
func(ele string) {
fmt.Println(ele)
}('hello world')
}匿名函数作为参数传递给其他函数。
package main
import (
"fmt"
)
// 匿名函数作为参数传递
func GFG(i func(p, q string)string) {
fmt.Println(i ("Geeks", "for"))
}
func main() {
// 匿名函数，传参
value := func(p, q string) string{
return p + q + "mmp"
}
GFG(value)
}从另一个函数返回匿名函数。(常用于回调函数)
package main
import (
"fmt"
)
// 返回匿名函数
func GFG() func(i, j string)string{
myf := func(i,j string)string{
return i + j + "hello world"
}
return myf
}
func main() {
// 调用匿名函数并传值
value := GFG()
fmt.Println(value("weblcome ", "to "))
}函数内部进行的任何更改都不会反映在调用者的实际参数中
package main
import "fmt"
func modify(Z int) {
fmt.Println(Z) // 10
Z = 79
}
func main() {
var Z int = 10
fmt.Println("调用前:", Z) // 10
modify(Z) // 调用修改函数
fmt.Println("调用后:", Z) // 10
}指针概念： 在函数调用中，我们传递变量的地址，并使用解引用运算符*修改值
package main
import (
"fmt"
)
func modify(Z *int) {
*Z = 70
}
func main() {
var Zz int = 10
modify(&Zz) // 通过引用调用传递变量Z地址,指针方式
fmt.Println(Zz) // 70
}首先先看下函数语法
func function_name(parameter_list)(return_type_list){
// code...
}function_name：它是函数的名称。
parameter-list：它包含函数参数的名称和类型。
return_type_list：这是可选的，它包含函数返回的值的类型。如果在函数中使用return_type，则必须在函数中使用return语句。
package main
import (
"fmt"
)
// myfunc返回3个int类型的值
func myfunc(p, q int) (int,int,int) {
return p - q, p * q, p + q
}
func main() {
var _var1, _var2, _var3 = myfunc(5,7)
fmt.Println(_var1,_var2,_var3) // -2 35 12
}允许为返回值提供名称。你也可以在代码中使用这些变量名。
语法
// name1和name2是返回值的名称，而para1和para2是函数的参数。
func function_name(para1, para2 int)(name1 int, name2 int){
// code...
}
或
func function_name(para1, para2 int)(name1, name2 int){
// code...
}package main
import (
"fmt"
)
func myfunc(p,q int) (age1 int, age2 int) {
age1 = p + q
age2 = p * q
return // Go编译器将自动返回参数
}
func main() {
var res1, res2 = myfunc(2, 4)
fmt.Println(res1, res2) // 6 8
}只需使用_（下划线）。它允许编译器忽略该特定变量的错误(declared and not used)。
package main
import "fmt"
func main() {
//调用函数
//函数返回两个值
//分配给mul和空白标识符（忽略）
mul, _ := mul_div(105, 7)
//只使用mul变量
fmt.Println("105 x 7 = ", mul)
}
//函数返回两个
//整数类型的值
func mul_div(n1 int, n2 int) (int, int) {
//返回值
return n1 * n2, n1 / n2
}init()函数的主要目的是初始化无法在全局上下文中初始化的全局变量。
package main
import "fmt"
//多个init()函数,必须放在 main 之前
func init() {
fmt.Println("Welcome to init() function")
}
func init() {
fmt.Println("Hello! init() function")
}
func main() {
fmt.Println("Welcome to main() function")
}同一程序中允许多个defer语句，并且它们按LIFO（后进先出）顺序执行
在defer语句中，将在执行defer语句时（而不是在调用它们时）评估参数。
defer语句通常用于确保在完成文件处理后关闭文件，关闭通道或捕获程序中的紧急情况。
语法
// 函数
defer func func_name(parameter_list Type) return_type{
// Code
}
// 方法
defer func (receiver Type) method_name(parameter_list){
// Code
}
defer func (parameter_list)(return_type){
// code
}()后进先出延迟执行
package main
import "fmt"
func add(a1, a2 int) int {
res := a1 + a2
fmt.Println("Result: ", res)
return 0
}
func main() {
fmt.Println("Start")
// 多个延迟,已LIFO顺序执行
defer fmt.Println("End")
defer add(1,2)
defer add(3,4)
fmt.Println("烟")
}
// 执行顺序
Start
烟
Result: 7
Result: 3
End语法
var array_name[length]Type
或
var array_name[length]Typle{item1, item2, item3, ...itemN}package main
import "fmt"
func main() {
// 创建字符串类型数组
var arr [3]string
// 使用索引分配元素
arr[0] = "a"
arr[1] = "b"
arr[2] = "c"
// 使用索引输出元素
fmt.Println(arr[0],arr[1],arr[2]) // a b c
}array_name:= [length]Type{item1, item2, item3,...itemN}[object Object]package main
import "fmt"
func main() {
// 数组的简写声明
arr := [4]string{"a","b","c"}
// for 循环访问数组
for i := 0; i < len(arr); i++ {
fmt.Println(arr[i])
}
}数组是一维的，但是允许创建多维数组。多维数组是相同类型数组的数组
语法
Array_name[Length1][Length2]..[LengthN]Typepackage main
import "fmt"
func main() {
// 使用 var 关键字创建二维数组
// var arr1 [2][2]int
// arr1[0][0] = 100
// arr1[0][1] = 200
// arr1[1][0] = 300
// arr1[1][1] = 400
// 使用简单声明二维数组
arr := [3][3]string {
{"a","b","c"},
{"1","2","3"},
{"m","n","p"},
}
for x := 0; x < len(arr); x++ {
for y := 0; y < len(arr); y++ {
fmt.Println(arr[x][y])
}
fmt.Println("------------")
}
}
// 输出
a
b
c
------------
1
2
3
------------
m
n
p
------------... 在长度位置处可见，则数组的长度由初始化的元素确定
//数组中省略号的使用方法
package main
import "fmt"
func main() {
//创建大小已确定的数组,根据其中元素的数量,使用省略号
myarray := [...]string{"a", "b", "c", "d"}
fmt.Println("数组元素: ", myarray) // 数组元素: [a b c d]
//数组的长度 由...决定 使用len()方法
fmt.Println("数组的长度为:", len(myarray)) // 数组的长度为: 4
}package main
import "fmt"
func main() {
arr1 := [3]int{9, 7, 6}
arr2 := [...]int{9, 7, 6}
arr3 := [...]int{6, 7, 9}
//使用==运算符比较数组
fmt.Println(arr1 == arr2) // true
fmt.Println(arr1 == arr3) // false
}同一程序中允许多个defer语句，并且它们按LIFO（后进先出）顺序执行
在defer语句中，将在执行defer语句时（而不是在调用它们时）评估参数。
defer语句通常用于确保在完成文件处理后关闭文件，关闭通道或捕获程序中的紧急情况。
语法
// 函数
defer func func_name(parameter_list Type) return_type{
// Code
}
// 方法
defer func (receiver Type) method_name(parameter_list){
// Code
}
defer func (parameter_list)(return_type){
// code
}()后进先出延迟执行
package main
import "fmt"
func add(a1, a2 int) int {
res := a1 + a2
fmt.Println("Result: ", res)
return 0
}
func main() {
fmt.Println("Start")
// 多个延迟,已LIFO顺序执行
defer fmt.Println("End")
defer add(1,2)
defer add(3,4)
fmt.Println("烟")
}
// 执行顺序
Start
烟
Result: 7
Result: 3
End语法
var array_name[length]Type
或
var array_name[length]Typle{item1, item2, item3, ...itemN}package main
import "fmt"
func main() {
// 创建字符串类型数组
var arr [3]string
// 使用索引分配元素
arr[0] = "a"
arr[1] = "b"
arr[2] = "c"
// 使用索引输出元素
fmt.Println(arr[0],arr[1],arr[2]) // a b c
}array_name:= [length]Type{item1, item2, item3,...itemN}[object Object]package main
import "fmt"
func main() {
// 数组的简写声明
arr := [4]string{"a","b","c"}
// for 循环访问数组
for i := 0; i < len(arr); i++ {
fmt.Println(arr[i])
}
}数组是一维的，但是允许创建多维数组。多维数组是相同类型数组的数组
语法
Array_name[Length1][Length2]..[LengthN]Typepackage main
import "fmt"
func main() {
// 使用 var 关键字创建二维数组
// var arr1 [2][2]int
// arr1[0][0] = 100
// arr1[0][1] = 200
// arr1[1][0] = 300
// arr1[1][1] = 400
// 使用简单声明二维数组
arr := [3][3]string {
{"a","b","c"},
{"1","2","3"},
{"m","n","p"},
}
for x := 0; x < len(arr); x++ {
for y := 0; y < len(arr); y++ {
fmt.Println(arr[x][y])
}
fmt.Println("------------")
}
}
// 输出
a
b
c
------------
1
2
3
------------
m
n
p
------------... 在长度位置处可见，则数组的长度由初始化的元素确定
//数组中省略号的使用方法
package main
import "fmt"
func main() {
//创建大小已确定的数组,根据其中元素的数量,使用省略号
myarray := [...]string{"a", "b", "c", "d"}
fmt.Println("数组元素: ", myarray) // 数组元素: [a b c d]
//数组的长度 由...决定 使用len()方法
fmt.Println("数组的长度为:", len(myarray)) // 数组的长度为: 4
}package main
import "fmt"
func main() {
arr1 := [3]int{9, 7, 6}
arr2 := [...]int{9, 7, 6}
arr3 := [...]int{6, 7, 9}
//使用==运算符比较数组
fmt.Println(arr1 == arr2) // true
fmt.Println(arr1 == arr3) // false
}语法
// 按值创建数组的副本， 副改变，主不变
arr := arr1
// 通过引用创建数组的副本, 副本改变，主数组也改变
arr := &arr1将1或多维数组传递给该函数
语法
//对于指定大小的数组
func function_name(variable_name [size]type){
// Code
}
//对于无大小的数组
func function_name(variable_name []type){
// Code
}package main
import "fmt"
func myfunc(a [6]int, size int) int { // 接受两个参数，第一个参数6位int类型，第二个参数int类型, 返回int类型
var k, val, r int
for k = 0; k < size; k++ {
val += a[k]
}
r = val / size
return r
}
func main() {
//创建数组
var arr = [6]int{1,2,3,4,5,6}
// 初始化数组，并将数组作为参数传递
var res int = myfunc(arr, 6)
fmt.Println(res)
}数组是固定大小
切片大小可伸缩
在内部，切片和数组相连，切片是对基础数组的引用
切片中的第一个索引位置始终为0，而最后一个索引位置将为（切片的长度– 1）。
切片声明： []T 或 []T{} 或 []T{value1, value2, value3, ...value n}
package main
import "fmt"
func main() {
// 定义一个数组，数组长度最大是8, 数组索引下标从0开始
arr := [8]string{"a","b","c","d","e","f","g"}
fmt.Println("数组：",arr) // 数组： [a b c d e f g ]
// 如何定义切片
// 1、使用var关键字,创建切片
// var my_slice_1 = []string{"nhooos", "for", "nhooos"}
// 2、创建切片，使用简写声明
// my_slice_2 := []int{12, 45, 67, 56, 43, 34, 45}
// 切片数组
myslice := arr[1:3] // 切片下标1开始，3结束，不包括3,也就是长度2
fmt.Println("切片:",myslice) // 切片: [b c]
fmt.Println("切片长度:", len(myslice)) // 切片长度：2 (3-1,两个数值)
fmt.Println("切片容量:",cap(myslice)) // 切片容量: 7 (最多存储)
fmt.Println(arr[0:]) // [a b c d e f g ]
fmt.Println(arr[:0]) // []
fmt.Println(arr[:3]) // [a b c]
fmt.Println(arr[:]) // [a b c d e f g ]
}make()函数用于创建一个空切片
语法：
func make([]T, len, cap) []T ;
[]T 类型， len 长度, cap 容量(可选,默认和长度一样))
package main
import "fmt"
// 语法： func make([]T, len, cap) []T ; []T 类型， len 长度, cap 容量(可选,默认和长度一样))
func main() {
var _slice = make([]int, 4, 7)
fmt.Printf("切片内容: %v,\n切片长度: %d, \n切片容量: %d\n", _slice, len(_slice), cap(_slice))
// 切片内容: [0 0 0 0],
// 切片长度: 4,
// 切片容量: 7
}package main
import "fmt"
func main() {
// 创建切片， 并遍历切片
_slice2 := []string{"a","b","c"}
// 方法一
for s := 0; s < len(_slice2); s++ {
fmt.Println(_slice2[s])
}
// 方法
// 如果您不想获取元素的索引值，则可以使用空格（_）代替索引变量
for _, v := range _slice2 {
fmt.Println(v)
}
}package main
import "fmt"
func main() {
// 多维切片
_slice3 := [][]string{
[]string{"a","aa"},
[]string{"b","bb"},
{"c","cc"},
{"d","dd"},
}
fmt.Println(_slice3)
}判断两个[]byte是否相等
package main
import (
"bytes"
"fmt"
)
func main() {
// 判断两个[]byte是否相等
a := []byte{0,1,2,3}
b := []byte{0,1,2,3}
c := []byte{1,1,2,3}
fmt.Println(bytes.Equal(a,b)) // true
fmt.Println(bytes.Equal(a,c)) // false
}使用reflect判断slice是否相等
深度比较两个对象包括它们内部包含的元素是否都相等： 语法: func DeepEqual(x, y interface{}) bool
牺牲了性能
package main
import (
"reflect"
"fmt"
)
func main() {
a := []int{1, 2, 3, 4}
b := []int{1, 3, 2, 4}
c := []int{1, 2, 3, 4}
// 见证黑魔法
fmt.Println(reflect.DeepEqual(a,b)) // false
fmt.Println(reflect.DeepEqual(a,c)) // true
}手写切片是否相等判断
性能比 reflect 快
package main
import (
"fmt"
)
// 以 int 类型为
func testEq(var1, var2 []int) bool {
// 如果切片为空，那么另一个切片也必须为空
if(var1 == nil) != (var2 == nil) {
return false;
}
// 判断切片长度,如果两个切片长度不相等
if len(var1) != len(var2) {
return false;
}
// for 循环遍历，通过下标判断是否一样
for i := range var1 {
if var1[i] != var2[i] {
return false
}
}
// 如果都通过，则返回 true
return true;
}
func main() {
a := []int{1, 2, 3, 4}
b := []int{1, 3, 2, 4}
c := []int{1, 2, 3, 4}
// 见证黑魔法
fmt.Println(testEq(a,b)) // false
fmt.Println(testEq(a,c)) // true
}Go语言的标准库提供了sort包，其中包含用于对int，float64和字符串切片进行排序的不同类型的排序方法。 这些函数始终按升序对可用元素进行切片排序
package main
import (
"fmt"
"sort"
)
func main() {
//创建切片
slc1 := []string{"Python", "Java", "C#", "Go", "Ruby"}
slc2 := []int{45, 67, 23, 90, 33, 21, 56, 78, 89}
//切片使用排序函数
sort.Strings(slc1)
sort.Ints(slc2)
// IntsAreSorted 判断是否已经按照升序排序，如果是返回true, 如果不是返回false
fmt.Println(sort.IntsAreSorted(slc2))
fmt.Println("\n排序后:")
fmt.Println("Slice 1: ", slc1) // Slice 1: [C# Go Java Python Ruby]
fmt.Println("Slice 2: ", slc2) // Slice 2: [21 23 33 45 56 67 78 89 90]
}语法
func Split(o_slice, sep []byte) [][]byte
o_slice是字节片
sep是分隔符。
如果sep为空，则它将在每个UTF-8序列之后拆分package main
import "fmt"
func modify(sls []int) {
sls[0] = 90
}
func main() {
a := []int{89,90,91}
modify(a[:])
fmt.Println(a) // [90 90 91]
}package main
import (
"strings"
"fmt"
)
func main() {
a := "aabb"
b := "hello"
// 方式一，没有比较运算符来的方便
fmt.Println(strings.Compare(a,b)) // a < b, 返回 -1
fmt.Println(strings.Compare(a,a)) // a = a, 返回 0
fmt.Println(strings.Compare(b,a)) // b > a, 返回 1
// 方式二，使用比较运算符
fmt.Println(a == b) // 不相等，返回 false
fmt.Println(a > b) // a 没有 b 字符串多,返回 false
fmt.Println(a < b) // b 比 a 字符串多,返回 true
// 方式三，使用 strings.EqualFold
fmt.Println(strings.EqualFold("aa","aa")) // 返回 true
fmt.Println(strings.EqualFold("aa","aabb")) // 返回 false
}语法
// 子串 substr 在 s 中，返回 true ---> 整体字符必须在 s 中存在
func Contains(s, substr string) bool
// chars 中任何一个 Unicode 代码点在 s 中，返回 true ---> 如果当中随便一个字符在 s 中，那么就返回 true
func ContainsAny(s, chars string) bool
// Unicode 代码点 r 在 s 中，返回 true
func ContainsRune(s string, r rune) boolpackage main
import (
"fmt"
"strings"
)
func main() {
fmt.Println(strings.Contains("team", "t")) // true
fmt.Println(strings.Contains("team", "ta")) // false
fmt.Println(strings.ContainsAny("team", "i")) // false
fmt.Println(strings.ContainsAny("failure", "u & i")) // true
}当 sep 为空时，Count 的返回值是：utf8.RuneCountInString(s) + 1 Count 是计算子串在字符串中出现的无重叠的次数
语法
func Count(s, sep string) intpackage main
import (
"fmt"
"strings"
)
func main() {
fmt.Println(strings.Count("fivevev", "vev")) // 1 , 无重叠次数
fmt.Println(strings.Count("aba", "a")) // 2， 字符出现的次数
fmt.Println(strings.Count("aba", "")) // 4， sep步数为空，则 +1
fmt.Println(len("aa")) // 2， 字符数量
}该包提供了六个三组分割函数：Fields 和 FieldsFunc、Split 和 SplitAfter、SplitN 和 SplitAfterN。
语法
func Fields(s string) []string
func FieldsFunc(s string, f func(rune) bool) []stringFields
用一个或多个连续的空格分隔字符串 s，返回子字符串的数组（slice）如果字符串 s 只包含空格，则返回空列表 ([]string 的长度为 0）
package main
import (
"fmt"
"strings"
)
func main() {
fmt.Printf("Field: %q", strings.Fields(" a b c"))
}
// 结果
Field: ["a" "b" "c"]FieldsFunc
可以通过回调函数来指定分隔字符串 s 的字符， 也可自定义回调
package main
import (
"fmt"
"strings"
"unicode"
)
func main() {
fmt.Println(strings.FieldsFunc(" foo bar baz ", unicode.IsSpace))
}
// 结果
[foo bar baz]Split 和 SplitAfter、 SplitN 和 SplitAfterN
这四个函数都是通过 sep 进行分割，返回[]string。如果 sep 为空，相当于分成一个个的 UTF-8 字符 Split(s, sep) 和 SplitN(s, sep, -1) 等价；SplitAfter(s, sep) 和 SplitAfterN(s, sep, -1) 等价。
语法
func Split(s, sep string) []string { return genSplit(s, sep, 0, -1) }
func SplitAfter(s, sep string) []string { return genSplit(s, sep, len(sep), -1) }
func SplitN(s, sep string, n int) []string { return genSplit(s, sep, 0, n) }
func SplitAfterN(s, sep string, n int) []string { return genSplit(s, sep, len(sep), n) }package main
import (
"fmt"
"strings"
)
func main() {
fmt.Printf("%q\n", strings.Split("a,b,c", "")) // ["a" "," "b" "," "c"]
fmt.Printf("%q\n", strings.Split("a,b,c", ",")) // ["a" "b" "c"]
fmt.Printf("%q\n", strings.SplitAfter("a,b,c", ",")) // ["a," "b," "c"]
fmt.Printf("%q\n", strings.SplitN("a,b,c", ",", 2)) // ["a" "b,c"]
fmt.Printf("%q\n", strings.SplitAfterN("a,b,c,d,f", ",", 2)) // ["a," "b,c,d,f"]
}package main
import (
"fmt"
"strings"
)
func main() {
fmt.Println(strings.HasPrefix("aaabbb","a")) // true, 判断前缀
fmt.Println(strings.HasSuffix("aaabbb","b")) // true，判断后缀
}// 在 s 中查找 sep 的第一次出现，返回第一次出现的索引
func Index(s, sep string) int
// 在 s 中查找字节 c 的第一次出现，返回第一次出现的索引
func IndexByte(s string, c byte) int
// chars 中任何一个 Unicode 代码点在 s 中首次出现的位置
func IndexAny(s, chars string) int
// 查找字符 c 在 s 中第一次出现的位置，其中 c 满足 f(c) 返回 true
func IndexFunc(s string, f func(rune) bool) int
// Unicode 代码点 r 在 s 中第一次出现的位置
func IndexRune(s string, r rune) int
// 有三个对应的查找最后一次出现的位置
func LastIndex(s, sep string) int
func LastIndexByte(s string, c byte) int
func LastIndexAny(s, chars string) int
func LastIndexFunc(s string, f func(rune) bool) int将字符串数组（或 slice）连接起来可以通过 Join 实现，函数签名如下：
package main
import (
"fmt"
"strings"
)
func main() {
fmt.Println(strings.Join([]string{"name=aaa","age=18"},"&")) // 使用&拼接切片或者数组
}
// 结果
name=aaa&age=18将 s 重复 count 次，如果 count 为负数或返回值长度 len(s)*count 超出 string 上限会导致 panic
语法
func Repeat(s string, count int) stringfmt.Println("ba" + strings.Repeat("na", 2))
// 输出结果
bananapackage main
import (
"fmt"
"strings"
"unicode"
)
func main() {
mapping := func(r rune) rune {
switch {
case r >= 'A' && r <= 'Z': // 大写字母转小写
return r + 32
case r >= 'a' && r <= 'z': // 小写字母不处理
return r
case unicode.Is(unicode.Han, r): // 汉字换行
return '\n'
}
return -1 // 过滤所有非字母、汉字的字符
}
fmt.Println(strings.Map(mapping, "Hello你#￥%……\n（'World\n,好Hello^(&(*界gopher..."))
}
//
hello
world
hello
gopher语法
// 用 new 替换 s 中的 old，一共替换 n 个。
// 如果 n < 0，则不限制替换次数，即全部替换
func Replace(s, old, new string, n int) string //-> old 是 s 当中需要替换的字符
// 该函数内部直接调用了函数 Replace(s, old, new , -1)
func ReplaceAll(s, old, new string) stringfmt.Println(strings.Replace("oink oink oink", "k", "ky", 2)) // oinky oinky oink
fmt.Println(strings.Replace("oink oink oink", "oink", "moo", -1)) // moo moo moo
fmt.Println(strings.ReplaceAll("oink oink oink", "oink", "moo")) // moo moo moo语法
func ToLower(s string) string
func ToLowerSpecial(c unicode.SpecialCase, s string) string
func ToUpper(s string) string
func ToUpperSpecial(c unicode.SpecialCase, s string) string
func Title(s string) string // 将 s 每个单词的首字母大写
func ToTitle(s string) string // 将 s 的每个字母大写
func ToTitleSpecial(c unicode.SpecialCase, s string) string // 将 s 的每个字母大写，并且会将一些特殊字母转换为其对应的特殊大写字母。package main
import (
"fmt"
"strings"
)
func main() {
fmt.Println(strings.ToLower("AAA")) // 全部转换小写
fmt.Println(strings.ToUpper("aaa")) // 全部转换大写
fmt.Println(strings.ToLower("Ā Á Ǎ À")) // 全部转换特殊字符为小写
fmt.Println(strings.ToUpper("ā á ǎ à")) // 全部转换特殊字符为大写
fmt.Println(strings.Title("āáǎà ōóǒò êēéěè")) // 首字母大写
fmt.Println(strings.ToTitle("āáǎà ōóǒò êēéěè")) // 全部大写
fmt.Println(strings.ToTitleSpecial(unicode.TurkishCase, "āáǎà ōóǒò êēéěè")) // 全部大写包含特殊字符
}// 将 s 左侧和右侧中匹配 cutset 中的任一字符的字符去掉
func Trim(s string, cutset string) string
// 将 s 左侧的匹配 cutset 中的任一字符的字符去掉
func TrimLeft(s string, cutset string) string
// 将 s 右侧的匹配 cutset 中的任一字符的字符去掉
func TrimRight(s string, cutset string) string
// 如果 s 的前缀为 prefix 则返回去掉前缀后的 string , 否则 s 没有变化。
func TrimPrefix(s, prefix string) string
// 如果 s 的后缀为 suffix 则返回去掉后缀后的 string , 否则 s 没有变化。
func TrimSuffix(s, suffix string) string
// 将 s 左侧和右侧的间隔符去掉。常见间隔符包括：'\t', '\n', '\v', '\f', '\r', ' ', U+0085 (NEL)
func TrimSpace(s string) string
// 将 s 左侧和右侧的匹配 f 的字符去掉
func TrimFunc(s string, f func(rune) bool) string
// 将 s 左侧的匹配 f 的字符去掉
func TrimLeftFunc(s string, f func(rune) bool) string
// 将 s 右侧的匹配 f 的字符去掉
func TrimRightFunc(s string, f func(rune) bool) stringx := "!!!@@@你好,!@#$ Gophers###$$$"
fmt.Println(strings.Trim(x, "@#$!%^&*()_+=-")) // 你好,!@#$ Gophers
fmt.Println(strings.TrimLeft(x, "@#$!%^&*()_+=-")) // 你好,!@#$ Gophers###$$$
fmt.Println(strings.TrimRight(x, "@#$!%^&*()_+=-")) // !!!@@@你好,!@#$ Gophers
fmt.Println(strings.TrimSpace(" \t\n Hello, Gophers \n\t\r\n")) // Hello, Gophers
fmt.Println(strings.TrimPrefix(x, "!")) // !!@@@你好,!@#$ Gophers###$$$
fmt.Println(strings.TrimSuffix(x, "$")) // !!!@@@你好,!@#$ Gophers###$$
f := func(r rune) bool {
return !unicode.Is(unicode.Han, r) // 非汉字返回 true
}
fmt.Println(strings.TrimFunc(x, f)) // 你好
fmt.Println(strings.TrimLeftFunc(x, f)) // 你好,!@#$ Gophers###$$$
fmt.Println(strings.TrimRightFunc(x, f)) // !!!@@@你好进行多个替换
r := strings.NewReplacer("<", "<", ">", ">") // < 替换成 < > 替换成 >
fmt.Println(r.Replace("This is <b>HTML</b>!")) // This is <b>HTML</b>!替换结果写入到文件
func (r *Replacer) WriteString(w io.Writer, s string) (n int, err error)不支持继承但支持组合的轻量级类。
声明结构、 访问结构、修改结构、指针地址
package main
import (
"fmt"
)
type _Class struct {
name string
gender string
age int
}
func main() {
// 声明 struct 类型变量
var student _Class
fmt.Println(student) // { 0} , int 类型，默认为0
// 声明初始化结构
_st1 := _Class{"tom","boy", 18} // 方法一
_st2 := _Class{name:"tom", gender:"boy", age:18} // 方法二
_st3 := _Class{name:"tom"} // 方法三
fmt.Println(_st1) // {tom boy 18}
fmt.Println(_st2) // {tom boy 18}
fmt.Println(_st3) // {tom 0}
// 访问定义的结构文字
fmt.Println(_st1.name) // tom
fmt.Println(_st1.gender) // boy
fmt.Println(_st1.age) // 18
// 修改结构值
_st1.name = "google"
fmt.Println(_st1) // {google boy 18}
// 定义变量，并获取指向结构体的指针，既内存地址
_get := &_Class{"a","b",1}
fmt.Println((*_get).name) // a
fmt.Println(_get.name) // a
}如果结构彼此相等（就其字段值而言），则运算符和方法均返回true；否则，返回false。并且，如果比较的变量属于不同的结构，则编译器将给出错误
// 使用 reflect 下的 DeeplyEqual 方法
package main
import (
"fmt"
"reflect"
)
type _Class struct {
name string
gender string
age int
}
func main() {
_st1 := _Class{"a","女",18}
_st2 := _Class{"a","女",18}
_st3 := _Class{"a","女",19}
fmt.Println(reflect.DeepEqual(_st1, _st2)) // true
fmt.Println(reflect.DeepEqual(_st1, _st3)) // false
}语法
type struct_name_1 struct{
// Fields
}
type struct_name_2 struct{
variable_name struct_name_1
}package main
import (
"fmt"
)
type User struct {
name string
gender string
age int
}
// 嵌套结构
type Group struct {
group User
}
func main() {
_g := Group{
group: User{name:"tom", gender: "girl", age: 18}, // 另起一行必须要加上,号
}
fmt.Println(_g) // {{tom girl 18}}
fmt.Println(_g.group.name) // tom， 访问结构属性
}匿名结构
package main
import (
"fmt"
)
func main() {
// 创建和初始化一次性匿名结构
Student := struct {
name string
gender string
age int
}{
name: "张三",
gender: "女",
age: 18,
}
fmt.Println(Student) // {张三 女 18}
_Student
}匿名字段
package main
import "fmt"
//创建一个结构匿名字段
type student struct {
int
string
float64
}
// Main function
func main() {
// 将值分配给匿名,学生结构的字段
value := student{123, "Bud", 8900.23}
fmt.Println("入学人数 : ", value.int) // 入学人数 : 123
fmt.Println("学生姓名 : ", value.string) // 学生姓名 : Bud
fmt.Println("套餐价格 : ", value.float64) // 套餐价格 : 8900.23
}不允许
// 不允许创建两个或多个相同类型的字段
type student struct{
int
int
}package main
import "fmt"
type Group struct {
group string
}
type User struct {
uname string
Group
}
func main() {
var _u User
_u.uname = "小明"
_u.group = "技术部"
fmt.Println(_u) // {小明 {技术部}}
}//使用匿名函数作为Go结构中的一个字段
package main
import "fmt"
//创建结构
type Author struct {
name string
language string
Tarticles int
Particles int
Pending func(int, int) int
}
func main() {
//初始化结构字段
result := Author{
name: "Sonia",
language: "Java",
Tarticles: 340,
Particles: 259,
Pending: func(Ta int, Pa int) int {
return Ta - Pa
},
}
fmt.Println("作者姓名: ", result.name)
fmt.Println("语言: ", result.language)
fmt.Println("文章总数: ", result.Tarticles)
fmt.Println("发表文章总数: ", result.Particles)
fmt.Println("待处理文章: ", result.Pending(result.Tarticles, result.Particles))
// 作者姓名: Sonia
// 语言: Java
// 文章总数: 340
// 发表文章总数: 259
// 待处理文章: 81
}//使用匿名函数作为Go结构中的一个字段
package main
import "fmt"
func main() {
b := 255
var a *int = &b
fmt.Println(a) // 变量的指针地址 0xc00018c000
fmt.Println(b) // 变量值
}//使用匿名函数作为Go结构中的一个字段
package main
import "fmt"
func main() {
b := 255
a := &b // 引用
fmt.Println(a) // 打印指针地址
fmt.Println(*a) // 解引用
}//使用匿名函数作为Go结构中的一个字段
package main
import "fmt"
func change(val *int) {
*val = 55
}
func main() {
a := 59
b := &a // 把 b 的值指向 a 的指针地址
change(b) // 传递指针给函数，并修改指针地址
fmt.Println(a)
}package main
import "fmt"
func res() *int {
//局部变量, 函数内部使用简短运算符声明
status := 200
return &status
}
func main() {
//调用函数
response := res()
fmt.Println(response) // 0xc000014048 指针地址
fmt.Println(*response) // 200 变量值
}package main
import "fmt"
type group struct {
name string
}
func main() {
test := group{"abc"}
pts := &test
pts.name = "xyz"
fmt.Println(pts) // &{xyz}
fmt.Println(*pts) // {xyz}
fmt.Println(test) // {xyz}
}== 运算符：如果两个指针都指向同一个变量，则此运算符返回true。或如果两个指针都指向不同的变量，则返回false。
!= 运算符：如果两个指针都指向同一个变量，则此运算符返回false。或如果两个指针都指向不同的变量，则返回true。
package main
import "fmt"
func main() {
val1 := 2345
val2 := 567
//创建和初始化指针
var p1 *int
p1 = &val1
p2 := &val2
p3 := &val1
// 使用 != 运算符比较指针
res1 := &p1 != &p2
fmt.Println("p1指针不等于p2指针吗: ", res1)
res2 := p1 != p2
fmt.Println("p1指针不等于p2指针吗: ", res2)
res3 := p1 != p3
fmt.Println("p1指针不等于p3指针吗: ", res3)
res4 := p2 != p3
fmt.Println("p2指针不等于p3指针吗: ", res4)
res5 := &p3 != &p1
fmt.Println("p3指针不等于p1指针吗: ", res5)
}package main
import "fmt"
func main() {
// 创建一个容量为8个的数组
arr := [8]int{1,2,3,4,5,6,7,8}
// 定义循环变量类型
// var x int
// 创建一个容量为 5 的指针
var p [5]*int
// 给p分配指针地址
for x := 0; x < len(p); x++ {
p[x] = &arr[x]
}
// 打印容量为5的指针地址的值
for x := 0; x < len(p); x++ {
fmt.Println(*p[x])
}
fmt.Println("数组容量：", cap(arr))
fmt.Println("指针容量：", cap(p))
fmt.Println("指针容量：", cap(p))
fmt.Println("指针长度：", len(p))
// 1
// 2
// 3
// 4
// 5
// 数组容量： 8
// 指针容量： 5
// 指针容量： 5
// 指针长度： 5
}package main
import "fmt"
// 创建一个个结构体
type Student struct {
name string
gender string
age int
}
// 定义Reciver()方法，作为 Student 接收器类型
func (e Student) Reciver() {
fmt.Printf("Student of %s is %s %d", e.name, e.gender, e.age)
}
// 赋值，并调用 Student 类型的 Reciver() 方法
func main() {
emps := Student{"Tom", "women", 18}
emps.Reciver() // Student of Tom is women 18
}
// 理解： 在 Student 结构体类型上创建了一个 Reciver() 方法， Reciver() 在方法的内部访问了接收器 e Student，
// 并使用接收器 e，并打印 Student 的 name、gender 和 age 这 3 个字段等同于
// Reciver() 方法被转化为一个函数，Student 结构体被当做参数传递给它。
package main
import "fmt"
// 创建一个个结构体
type Student struct {
name string
gender string
age int
}
// Reciver()方法被转化为一个函数，把 Student 当做参数传入。
func Reciver(e Student) {
fmt.Printf("Student of %s is %s %d", e.name, e.gender, e.age)
}
// 赋值，并调用 Student 类型的 Reciver() 方法
func main() {
emps := Student{"Tom", "women", 18}
Reciver(emps) // Student of Tom is women 18
}package main
import (
"fmt"
"math"
)
// 结构体 R1
type R1 struct {
lenght int
width int
}
// 结构体 R2
type R2 struct {
radius float64
}
// R1 接收器, 使用 return 返回
func (r R1) gago() int {
return r.lenght + r.width
}
// R2 接收器， 使用 return 返回
func (c R2) gago() float64 {
return math.Pi * c.radius * c.radius
}
func main() {
r := R1{lenght: 5, width: 10}
fmt.Println(r.gago()) // 15
c := R2{radius: 12}
fmt.Println(c.gago()) // 452.3893421169302
}指针接收器： 考虑下一个结构体有很多的字段。在方法内使用这个结构体做为值接收器需要拷贝整个结构体，这是很昂贵的。在这种情况下使用指针接收器，结构体不会被拷贝，只会传递一个指针到方法内部使用。
值接收器： 除了指针接收器外，在其他的所有情况，都可以被使用值接收器
package main
import (
"fmt"
)
type Student struct {
name string
age int
}
/* 使用值接收器 */
func (e Student) ModifyName(newName string) {
e.name = newName
}
/* 使用指针接收器 */
func (e *Student) ModifyAge(newAge int) {
e.age = newAge
}
func main() {
e := Student{name: "tom", age: 20,}
e.ModifyName("jack aaaa") // 调用值接收器
fmt.Println(e.name) // tom,发现前后都是一样,值没有改变
e.ModifyAge(50)
fmt.Println(e.age) // 50， 发现值已经改变，变成50
}package main
import (
"fmt"
)
type address struct {
city string
state string
}
func (e address) fullAddress() {
fmt.Println(e.city , e.state)
}
// 匿名结构体
type person struct {
firstName string
lastName string
address
}
func main() {
p := person{
firstName: "张",
lastName: "三",
address: address{
city: "BeiJing",
state: "JinShuiQu",
},
}
p.fullAddress() // BeiJing JinShuiQu
}当一个函数有一个值参数，它只能接受一个值参数
当一个方法有一个值接收器，它可以接受值接收器和指针接收器。
package main
import (
"fmt"
)
type rectangle struct {
length int
width int
}
func area(r rectangle) {
fmt.Printf("Area Function result: %d\n", (r.length * r.width))
}
func (r rectangle) area() {
fmt.Printf("Area Method result: %d\n", (r.length * r.width))
}
func main() {
r := rectangle{
length: 10,
width: 5,
}
area(r) // Area Function result: 50, 等同如下
r.area() // Area Method result: 50， 等同如上
p := &r
/*
compilation error, cannot use p (type *rectangle) as type rectangle
in argument to area
*/
//area(p)
p.area()//通过指针调用值接收器
}和值参数相类似，函数使用指针参数只接受指针，而使用指针接收器的方法可以使用值接收器和指针接收器。
package main
import (
"fmt"
)
type rectangle struct {
length int
width int
}
// 定义了一个接受指针参数的函数 perimeter
func perimeter(r *rectangle) {
fmt.Println("perimeter function output:", 2*(r.length+r.width))
}
// 定义了一个有一个指针接收器的方法
func (r *rectangle) perimeter() {
fmt.Println("perimeter method output:", 2*(r.length+r.width))
}
func main() {
r := rectangle{
length: 10,
width: 5,
}
p := &r //pointer to r
perimeter(p) // perimeter function output: 30
p.perimeter() // perimeter method output: 30
/*
cannot use r (type rectangle) as type *rectangle in argument to perimeter
*/
//perimeter(r)
r.perimeter()//使用值来调用指针接收器 perimeter method output: 30
}package main
import "fmt"
// 为内置类型 int 创建一个类型别名，然后创建一个以该类型别名为接收器的方法
// 为 int 创建了一个类型别名 myInt。我们定义了一个以 myInt 为接收器的的方法 add。
type myInt int
func (a myInt) add(b myInt) myInt {
return a + b
}
func main() {
num1 := myInt(5)
num2 := myInt(10)
sum := num1.add(num2)
fmt.Println("Sum is", sum)
}静态接口
动态接口
语法:
type interface_name interface{
//方法签名
}package main
import "fmt"
// 定义接口
type MyApi interface {
// 定义接口下的方法,返回 rune 类型切片
Response() []rune
}
// 声明类型
type MyString string
// 接收器接受类型 MyString，并添加 Response() []rune 方法
func (ms MyString) Response() []rune {
// 方便操作,重新赋值返回值
var _data []rune
// 循环遍历类型 MyString, 也就是 ms 传值字符串
for _, i := range ms {
// 单引号表示字符，双引号表示字符串
if i == 'a' || i == 'e' {
_data = append(_data, i)
}
}
return _data
}
func main() {
name := MyString("Sam Anderson")
var api MyApi
// name 是 MyString 类型，api 类型是 Myapi
// 把 name 赋值给 api, api.Response() 调用 MyString 类型 Response()方法
api = name
fmt.Printf("%c", api.Response()) // [a e]
}根据公司员工的个人薪资，计算公司的总支出。为了简单起见，我们假定支出的单位都是美元。 公司员工有着不同的薪资结构,以永久工和合同工薪酬为例
package main
import (
"fmt"
)
// 创建接口， 薪资计算器
type SalaryCalculator interface {
CalculateSalary() int
}
// 永久雇员工资结构体
type Permanent struct {
empId int
basicpay int
pf int
}
// 合同员工工资结构体
type Contract struct {
empId int
basicpay int
}
// 永久雇员的工资是基本工资和公积金的总和
func (p Permanent) CalculateSalary() int {
return p.basicpay + p.pf
}
// 合同工的工资是单独的基本工资
func (c Contract) CalculateSalary() int {
return c.basicpay
}
/*
作用说明：总费用是通过遍历SalaryCalculator切片并求和来计算的雇员个人的工资
方法说明：该方法接收一个 SalaryCalculator 接口的切片（[]SalaryCalculator）作为参数
*/
func totalExpense(s []SalaryCalculator) {
// 设置初始总费用为：0
expense := 0
for _, v := range s {
expense = expense + v.CalculateSalary()
}
fmt.Printf("公司每月工资总费用 $%d", expense)
}
func main() {
pemp1 := Permanent{1, 5000, 20} // 第一个永久雇员的工资
pemp2 := Permanent{2, 6000, 30} // 第二个永久雇员的工资
cemp1 := Contract{3, 3000} // 合同工的工资
employees := []SalaryCalculator{pemp1, pemp2, cemp1}
totalExpense(employees) // 执行上面的方法
}把接口看作内部的一个元组 (type, value)。 type 是接口底层的具体类型（Concrete Type），而 value 是具体类型的值。
Test 接口只有一个方法 Tester()，而 MyFloat 类型实现了该接口。 我们把变量 f（MyFloat 类型）赋值给了 t（Test 类型）。现在 t 的具体类型为 MyFloat，而 t 的值为 89.7。
package main
import "fmt"
// 定义接口， Test 接口只有一个方法 Tester()
type Test interface {
Tester()
}
// 定义变量 MyFloat 为 float64
type MyFloat float64
// 定义接收器， MyFloat 类型实现了该接口
func (m MyFloat) Tester() {
fmt.Println(m)
}
func main() {
var t Test // 赋值 t 为接口
f := MyFloat(98.1) // 赋值 f 的变量值
t = f // 把 f (MyFloat) 类型的值赋值给 t ,t 的类型变成 MyFloat
t.Tester() // 调用接收器方法， 输出: 98.1
}没有包含方法的接口称为空接口。空接口表示为interface{}。由于空接口没有方法，因此所有类型都实现了空接口。
package main
import "fmt"
// describe(i interface{}) 函数接收空接口作为参数，因此，可以给这个函数传递任何类型
func describe(i interface{}) {
fmt.Printf("Type = %T, value = %v\n", i, i)
}
func main() {
s := "Hello World"
describe(s) // Type = string, value = Hello World
i := 55
describe(i) // Type = int, value = 55
// 匿名结构体
strt := struct {
name string
}{
name: "Hungry",
}
describe(strt) // Type = struct { name string }, value = {Hungry}
}类型断言的语法是 i.(T)
package main
import "fmt"
// 如果 i 的具体类型是 T，那么 v 赋值为 i 的底层值，而 ok 赋值为 true。
// 如果 i 的具体类型不是 T，那么 ok 赋值为 false，v 赋值为 T 类型的零值，此时程序不会报错。
// v, ok := i.(T)
func assert(i interface{}) {
v, ok := i.(int)
fmt.Println(v, ok)
}
func main() {
var s interface{} = 56
assert(s) // 56 true
var i interface{} = "Steven Paul"
assert(i) // 0 false
}i.(T) , 而对于类型选择，类型 T 由关键字 type 代替
package main
import "fmt"
// switch i.(type) 表示一个类型选择。每个 case 语句都把 i 的具体类型和一个指定类型进行了比较。如果 case 匹配成功，会打印出相应的语句
func FindType(i interface{}) {
switch i.(type) {
case string:
fmt.Printf("String %s\n", i.(string)) // String aaa
case int:
fmt.Printf("Int %d\n", i.(int)) // Int 111
default:
fmt.Printf("Unknow type\n") // Unknow type
}
}
func main() {
FindType("aaa")
FindType(111)
FindType(111.11)
}还可以将一个类型和接口相比较。如果一个类型实现了接口，那么该类型与其实现的接口就可以互相比较。
package main
import "fmt"
// 定义一个接口
type Describer interface {
Db()
}
// 定义结构体
type Person struct {
name string
age int
}
// 接收器
func (p Person) Db() {
fmt.Printf("%s is %d years old", p.name, p.age)
}
// 定义一个方法
func findType(i interface{}) {
switch v := i.(type) {
case Describer:
v.Db()
default:
fmt.Printf("Unknow type\n")
}
}
func main() {
findType("aaaa") // Unknow type
// 结构体 Person 实现了 Describer 接口
p := Person{
name: "girl",
age: 18,
}
findType(p) // girl is 18 years old
}package main
import "fmt"
// 定义一个接口
type Describer interface {
Db()
}
// 定义一个结构体
type Person struct {
name string
age int
}
// 定义一个值接收器实现接口
func (p Person) Db() {
fmt.Printf("%s is %d years old\n", p.name, p.age)
}
type Address struct {
state string
country string
}
// 定义一个指针接收器实现接口
func (a *Address) Db() {
fmt.Printf("Statee %s Country %s", a.state, a.country)
}
func main() {
var d1 Describer // 赋值接口变量
p1 := Person{"tom", 29}
d1 = p1 // 赋值值给接口
d1.Db() // 调用接口方法： tom is 29 years old
p2 := Person{"Harry", 18}
d1 = &p2 // 赋值指针给接口
d1.Db() // 调用接口方法： Harry is 18 years old
/*
使用值接受者声明的方法，既可以用值来调用，也能用指针调用
*/
var d2 Describer
a := Address{"China","ShangHai"}
fmt.Println(&a) // &{China ShangHai} ,可以看出 &{China ShangHai}
d2 = &a
d2.Db() // 调用接口方法： Statee China Country ShangHai
/*
对于使用指针接受者的方法，用一个指针或者一个可取得地址的值来调用都是合法的。但接口中存储的具体值（Concrete Value）并不能取到地址，
*/
}package main
import (
"fmt"
)
// 薪资计算器接口
type SalaryCalculator interface {
DisplaySalary()
}
// 离开计算器接口
type LeaveCalculator interface {
CalculateLeavesLeft() int
}
type Employee struct {
firstName string
lastName string
basicPay int
pf int
totalLeaves int
leavesTaken int
}
func (e Employee) DisplaySalary() {
fmt.Printf("%s %s has salary $%d", e.firstName, e.lastName, (e.basicPay + e.pf))
}
func (e Employee) CalculateLeavesLeft() int {
return e.totalLeaves - e.leavesTaken
}
func main() {
e := Employee {
firstName: "Naveen",
lastName: "Ramanathan",
basicPay: 5000,
pf: 200,
totalLeaves: 30,
leavesTaken: 5,
}
var s SalaryCalculator = e
s.DisplaySalary() // Naveen Ramanathan has salary $5200
var l LeaveCalculator = e
fmt.Println("\nLeaves left =", l.CalculateLeavesLeft()) // Leaves left = 25
}
// 声明了两个接口：SalaryCalculator 和 LeaveCalculator。
// 定义了结构体 Employee, 实现了 SalaryCalculator 接口的 DisplaySalary 方法, 又实现了LeaveCalculator 接口里的 CalculateLeavesLeft 方法
// 于是 Employee 就实现了 SalaryCalculator 和 LeaveCalculator 两个接口。接口的零值是 nil。对于值为 nil 的接口，其底层值（Underlying Value）和具体类型（Concrete Type）都为 nil。
package main
import "fmt"
type Describer interface {
Describe()
}
func main() {
var d1 Describer
if d1 == nil {
fmt.Printf("d1 is nil and has type %T value %v\n", d1, d1)
// d1 is nil and has type <nil> value <nil>
}
}指针类型实现接口：
package main
import (
"fmt"
)
type Stu struct{}
func (St *Stu) Show() {
fmt.Println("aaaaa")
}
type People interface {
Show()
}
func main() {
var p People = &Stu{} // 传递结构体指针
p.Show() // aaaaa
}值类型实现接口：
package main
import (
"fmt"
)
type Stu struct{}
func (St Stu) Show() {
fmt.Println("aaaaa")
}
type People interface {
Show()
}
func main() {
var p People = Stu{} // 值类型
p.Show() // aaaaa
}通过函数封装接口实现：
package main
import (
"fmt"
)
type Stu struct{}
func (St *Stu) Show() {
fmt.Println("aaaaa")
}
type People interface {
Show()
}
// 实现接口
func Line() People {
var stu *Stu
return stu
}
func main() {
p := Line()
p.Show()
}Go 编程语言原生支持并发。Go 使用 Go 协程（Goroutine） 和信道（Channel）来处理并发
启动一个新的协程时，协程的调用会立即返回。与函数不同，程序控制不会去等待 Go 协程执行完毕。在调用 Go 协程之后，程序控制会立即返回到代码的下一行，忽略该协程的任何返回值。
如果希望运行其他 Go 协程，Go 主协程必须继续运行着。如果 Go 主协程终止，则程序终止，于是其他 Go 协程也不会继续运行。
package main
import (
"fmt"
"time"
)
func hello() {
fmt.Println("Helo world")
}
func main() {
go hello()
// time.Sleep(1 * time.Second) , 如果想输出 hello 函数方法,使用休眠，以便等待其他协程执行完毕
fmt.Println("main") // main
}
// 调用了 go hello() 之后，程序控制没有等待 hello 协程结束，立即返回到了代码下一行，打印 main function。接着由于没有其他可执行的代码，Go 主协程终止，于是 hello 协程就没有机会运行了。启动了两个 Go 协程。现在，这两个协程并发地运行。numbers 协程首先休眠 250 微秒，接着打印 1，然后再次休眠，打印 2，依此类推，一直到打印 5 结束。alphabete 协程同样打印从 a 到 e 的字母，并且每次有 400 微秒的休眠时间。 Go 主协程启动了 numbers 和 alphabete 两个 Go 协程，休眠了 3000 微秒后终止程序。
package main
import (
"fmt"
"time"
)
func numbers() {
for i := 0; i <= 5;i ++ {
time.Sleep(250 * time.Millisecond)
fmt.Printf("%d",i)
}
}
func alphabets() {
for i := 'a'; i <= 'e'; i++ {
time.Sleep(400 * time.Millisecond)
fmt.Printf("%c ", i)
}
}
func main() {
go numbers()
go alphabets()
time.Sleep(3000 * time.Millisecond)
fmt.Println("main terminated")
}
// 0a 12b 3c 45d e main terminatedGo 协程之间的管道，通过使用信道，数据也可以从一端发送，在另一端接收。实现 Go 协程间的通信。
信道的声明
所有信道都关联了一个类型。信道只能运输这种类型的数据，而运输其他类型的数据都是非法的。
package main
import (
"fmt"
)
func main() {
var a chan int // 定义信道 a， 类型 int,默认零值
if a == nil {
a := make(chan int) // 用 make 来定义信道
fmt.Printf("Type of a is %T", a) // Type of a is chan int
}
}信道进行发送和接收
默认是阻塞
data := <- a // 读取信道 a
a <- data // 写入信道 apackage main
import (
"fmt"
)
// Go 主协程发生了阻塞，等待信道 done 发送的数据。该信道作为参数传递给了协程 hello，
// hello 打印出 Hello world , done 写入数据。
// 当完成写入时，Go 主协程会通过信道 done 接收数据，于是它解除阻塞状态，打印出文本 main
/*
创建了一个 bool 类型的信道 done，并把 done 作为参数传递给了 hello 协程
通过信道 done 接收数据, 这一行代码发生了阻塞，
除非有协程向 done 写入数据，否则程序不会跳到下一行代码
于是，这就不需要用以前的 time.Sleep 来阻止 Go 主协程退出了。
*/
func hello(done chan bool) {
fmt.Println("Hello world")
done <- true // done 接收写入数据
}
func main() {
done := make(chan bool)
go hello(done)
<- done // 读取数据
fmt.Println("main")
}
/*
Hello world
main
*/ 在一个单独的 Go 协程计算平方和，而在另一个协程计算立方和，最后在 Go 主协程把平方和与立方和相加。
package main
import (
"fmt"
)
func calcSquares(number int, squareop chan int) {
sum := 0
for number != 0 {
digit := number % 10
sum += digit * digit
number /= 10
}
squareop <- sum
}
func calcCubes(number int, cubeop chan int) {
sum := 0
for number != 0 {
digit := number % 10
sum += digit * digit * digit
number /= 10
}
cubeop <- sum
}
func main() {
number := 589
sqrch := make(chan int)
cubech := make(chan int)
go calcSquares(number, sqrch)
go calcCubes(number, cubech)
squares, cubes := <-sqrch, <-cubech
fmt.Println("Final output", squares + cubes)
}死锁
当 Go 协程给一个信道发送数据时，照理说会有其他 Go 协程来接收数据。如果没有的话，程序就会在运行时触发 panic，形成死锁。
package main
func main() {
ch := make(chan int)
ch <- 5
}// 错误信息
fatal error: all goroutines are asleep - deadlock!
goroutine 1 [chan send]:
main.main()
/tmp/sandbox249677995/main.go:6 +0x80单向信道
信道转换,把一个双向信道转换成唯送信道或者唯收（Receive Only）信道都是行得通的
package main
import "fmt"
func sendData(sendch chan<- int) {
sendch <- 10
}
func main() {
cha1 := make(chan int)
go sendData(cha1)
fmt.Println(<-cha1)
}我们创建了一个双向信道 cha1。在第 11 行 cha1 作为参数传递给了 sendData 协程。在第 5 行，函数 sendData 里的参数 sendch chan<- int 把 cha1 转换为一个唯送信道。于是该信道在 sendData 协程里是一个唯送信道，而在 Go 主协程里是一个双向信道。该程序最终打印输出 10。
关闭信道和使用 for range 遍历信道
成功接收信道所发送的数据，那么 ok 等于 true。而如果 ok 等于 false
v, ok := <- ch
package main
import (
"fmt"
)
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)
}
}producer 协程会从 0 到 9 写入信道 chn1，然后关闭该信道。 主函数有一个无限的 for 循环，使用变量 ok 检查信道是否已经关闭。如果 ok 等于 false，说明信道已经关闭，于是退出 for 循环。如果 ok 等于 true，会打印出接收到的值和 ok 的值。
Received 0 true
Received 1 true
Received 2 true
Received 3 true
Received 4 true
Received 5 true
Received 6 true
Received 7 true
Received 8 true
Received 9 true优化
for range 循环用于在一个信道关闭之前，从信道接收数据。
package main
import (
"fmt"
)
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 range 循环从信道 ch 接收数据，直到该信道关闭。一旦关闭了 ch，循环会自动结束。该程序会输出：
for v := range ch {
fmt.Println("Received ",v)
}
}Received 0
Received 1
Received 2
Received 3
Received 4
Received 5
Received 6
Received 7
Received 8
Received 9创建一个有缓冲（Buffer）的信道。只在缓冲已满的情况，才会阻塞向缓冲信道（Buffered Channel）发送数据。同样，只有在缓冲为空的时候，才会阻塞从缓冲信道接收数据。
语法
// 信道有缓冲 capacity 应该大于 0。无缓冲信道的容量默认为
ch := make(chan type, capacity)package main
import (
"fmt"
"time"
)
func write(ch chan int) {
for i := 0; i < 6; i++ {
ch <- i
fmt.Println("Successfully wrote", i, "to ch")
}
close(ch)
}
func main() {
// 缓冲值是 2
ch := make(chan int, 2)
go write(ch)
// <- ch
time.Sleep(1 * time.Second)
for v := range ch {
fmt.Println("read value", v,"from ch")
time.Sleep(1 * time.Second)
}
}Successfully wrote 0 to ch
Successfully wrote 1 to ch
read value 0 from ch
Successfully wrote 2 to ch
read value 1 from ch
Successfully wrote 3 to ch
read value 2 from ch
Successfully wrote 4 to ch
read value 3 from ch
Successfully wrote 5 to ch
read value 4 from ch
read value 5 from ch死锁
package main
import (
"fmt"
)
func main() {
ch := make(chan string, 2)
ch <- "naveen"
ch <- "paul"
ch <- "steve"
fmt.Println(<-ch)
fmt.Println(<-ch)
}在上面程序里，我们向容量为 2 的缓冲信道写入 3 个字符串。当在程序控制到达第 3 次写入时，由于它超出了信道的容量，因此这次写入发生了阻塞。现在想要这次写操作能够进行下去，必须要有其它协程来读取这个信道的数据。但在本例中，并没有并发协程来读取这个信道，因此这里会发生死锁（deadlock）。程序会在运行时触发 panic
fatal error: all goroutines are asleep - deadlock!
goroutine 1 [chan send]:
main.main()
/tmp/sandbox274756028/main.go:11 +0x100长度 vs 容量
缓冲信道的容量是指信道可以存储的值的数量。我们在使用 make 函数创建缓冲信道的时候会指定容量大小。
缓冲信道的长度是指信道中当前排队的元素个数。
package main
import (
"fmt"
)
func main() {
ch := make(chan string, 3)
ch <- "naveen"
ch <- "paul"
fmt.Println("capacity is", cap(ch)) // 信道容量 capacity is 3
fmt.Println("length is", len(ch)) // 信道长度 length is 2
fmt.Println("read value", <-ch) // 打印内容 read value naveen
fmt.Println("new length is", len(ch)) // 使用过后的长度 new length is 1
}WaitGroup 用于等待一批 Go 协程执行结束。程序控制会一直阻塞，直到这些协程全部执行完毕
假设我们有 3 个并发执行的 Go 协程（由 Go 主协程生成）。Go 主协程需要等待这 3 个协程执行结束后，才会终止。这就可以用 WaitGroup 来实现。
package main
import (
"fmt"
"sync"
"time"
)
func process(i int, wg *sync.WaitGroup) {
fmt.Println("started Goroutine ", i)
time.Sleep(2 * time.Second)
fmt.Printf("Goroutine %d ended\n", i)
wg.Done() // 减少计数器，调用 WaitGroup 的 Done() 方法
}
func main() {
no := 3
var wg sync.WaitGroup // 创建 WaitGroup 类型变量，初始值为 0
for i := 0; i < no; i++ {
wg.Add(1) // 调用 WaitGroup 的 Add 并传递一个 int 时.,WaitGroup 的计数器会加上 Add 的传参
go process(i, &wg)
}
wg.Wait() // Wait() 方法会阻塞调用它的 Go 协程，直到计数器变为 0 后才会停止阻塞
fmt.Println("All go routines finished executing")
}// 由于 Go 协程的执行顺序不一定
started Goroutine 2
started Goroutine 1
started Goroutine 0
Goroutine 0 ended
Goroutine 1 ended
Goroutine 2 ended
All go routines finished executing工作池缓冲信道实现
1、创建一个 Go 携程池，监听一个等待作业分配的输入型缓冲信道
2、将作业添加到该输入型缓冲信道中
3、作业完成后，再将结果写入一个输出型缓冲信道
4、从输出型缓冲信道读取并打印结果
package main
import (
"fmt"
"sync"
"time"
"math/rand"
)
// 第一步： 创建结构体，表示作业和结果
type Job struct {
id int
randomno int // 用于计算其每位数之和
}
type Result struct {
job Job // 表示所对应的作业
sumofdigits int // 表示计算的结果（每位数字之和）
}
// 第二步：创建用于接受作业和写入结果的缓冲信道
var jobs = make(chan Job, 10)
var results = make(chan Result, 10)
// digits 函数的任务实际上就是计算整数的每一位之和，最后返回该结果
func digits(number int) int {
// 默认结果未 0
sum := 0
// 赋值变量
no := number
for no != 0 {
digits := no % 10
sum += digits
no /= 10
}
// 为了模拟出 digits 在计算过程中花费了一段时间，我们在函数内添加了两秒的休眠时间
time.Sleep(1 * time.Second)
return sum
}
// 然后，我们写一个创建工作协程的函数
/*
创建一个工作者 worker, 读取 jobs 信道的数据，根据当前的 job 和 digits 的返回值，
创建了一个 Result 结构体变量，然后将结果写入 results 缓冲信道。
worker 函数接收一个 WaitGroup 类型的 wg 作为参数，当所有的 jobs 完成时候，调用 Done() 方法
*/
func worker(wg *sync.WaitGroup) {
for job := range jobs {
output := Result{job, digits(job.randomno)}
results <- output
}
wg.Done()
}
// creatWorkerPool 函数创建了一个 Go 协程的工作池
/*
函数的参数是需要创建的工作协程的数量
在创建 Go 协程之前，它调用了 wg.Add(1)方法，于是 WaitGroup 计数器递增，
接下来，我们创建工作协程，并向 worker 函数传递 wg 地址。
创建了需要的工作协程后，函数调用了 wg.Wait()，等待所有的 Go 协程执行完毕。
所有协程完成执行之后，函数会关闭 results 信道。
因为所有协程都已经执行完毕，于是不再需要向 results 信道写入数据
*/
func createWorkerPool(noOfWorkers int) {
var wg sync.WaitGroup
for i := 0; i < noOfWorkers; i++ {
wg.Add(1)
go worker(&wg)
}
wg.Wait()
close(results)
}
// 现在我们已经有了工作池，继续编写一个函数，把作业分配给工作者
/*
allocate 函数接收所需创建的作业数量作为输入参数，生成了最大值为 9 的伪随机数，并使用该随机数创建了 Job 结构体变量。
这个函数把 for 循环的计数器 i 作为 id，最后把创建的结构体变量写入 jobs 信道。当写入所有的 job 时，它关闭了 jobs 信道。
*/
func allocate(noOfJobs int) {
for i := 0; i < noOfJobs ; i++ {
randomno := rand.Intn(9)
job := Job{i, randomno}
jobs <- job
}
close(jobs)
}
// 创建一个读取 results 信道和打印输出的函数。
/*
result 函数读取 results 信道，并打印出 job 的 id、输入的随机数、该随机数的每位数之和。
result 函数也接受 done 信道作为参数，当打印所有结果时，done 会被写入 true。
*/
func result(done chan bool) {
for result := range results {
fmt.Printf("Job id %d, input random no %d , sum of digits %d\n", result.job.id, result.job.randomno, result.sumofdigits)
}
done <- true
}
func main() {
startTime := time.Now()
noOfJobs := 10
go allocate(noOfJobs)
done := make(chan bool)
go result(done)
noOfWorkers := 5
createWorkerPool(noOfWorkers)
<-done
endTime := time.Now()
diff := endTime.Sub(startTime)
fmt.Println("total time taken ", diff.Seconds(), "seconds")
}Job id 4, input random no 4 , sum of digits 4
Job id 1, input random no 6 , sum of digits 6
Job id 0, input random no 5 , sum of digits 5
Job id 2, input random no 2 , sum of digits 2
Job id 3, input random no 2 , sum of digits 2
Job id 5, input random no 6 , sum of digits 6
Job id 7, input random no 8 , sum of digits 8
Job id 6, input random no 7 , sum of digits 7
Job id 8, input random no 4 , sum of digits 4
Job id 9, input random no 6 , sum of digits 6
total time taken 2.000395302 seconds随着工作协程数量增加，完成作业的总时间会减少。你们可以练习一下：在 main 函数里修改 noOfJobs 和 noOfWorkers 的值，并试着去分析一下结果。
select 语句用于在多个发送/接收信道操作中进行选择。select 语句会一直阻塞，直到发送/接收操作准备就绪。如果有多个信道操作准备完毕，select 会随机地选取其中之一执行。该语法与 switch 类似，所不同的是，这里的每个 case 语句都是信道操作
在没有 case 准备就绪时，可以执行 select 语句中的默认情况（Default Case）。这通常用于防止 select 语句一直阻塞。
package main
import (
"fmt"
"time"
)
func process(ch chan string) {
time.Sleep(10500 * time.Millisecond)
ch <- "process successfull"
}
func main() {
ch := make(chan string)
go process(ch)
for {
time.Sleep(1000 * time.Millisecond)
select {
case v := <- ch:
fmt.Println("received value:", v)
return
default:
fmt.Println("No have value")
}
}
}
/*
并发地调用了 process 协程之后，主协程启动了一个无限循环。
这个无限循环在每一次迭代开始时，都会先休眠 1000 毫秒（1 秒），然后执行一个 select 操作。
在最开始的 10500 毫秒中，由于 process 协程在 10500 毫秒后才会向 ch 信道写入数据，因此 select 语句的第一个 case（即 case v := <-ch:）并未就绪。
所以在这期间，程序会执行默认情况，该程序会打印 10 次 no value received。
在 10.5 秒之后，process 协程会在第 10 行向 ch 写入 process successful。
现在，就可以执行 select 语句的第一个 case 了，程序会打印 received value: process successful，然后程序终止。该程序会输出：
*/ package main
func main() {
ch := make(chan string)
select {
case <-ch:
}
}// 创建了一个信道 ch。我们在 select 内部（第 6 行），试图读取信道 ch。由于没有 Go 协程向该信道写入数据，因此 select 语句会一直阻塞，导致死锁。该程序会触发运行时 panic，报错信息如下：
fatal error: all goroutines are asleep - deadlock!
goroutine 1 [chan receive]:
main.main()
/tmp/sandbox416567824/main.go:6 +0x80如果存在默认情况，就不会发生死锁，因为在没有其他 case 准备就绪时，会执行默认情况。我们用默认情况重写后
package main
import "fmt"
func main() {
ch := make(chan string)
select {
case <-ch:
default:
fmt.Println("default case executed")
}
}如果 select 只含有值为 nil 的信道，也同样会执行默认情况。
package main
import "fmt"
func main() {
var ch chan string
select {
case v := <-ch:
fmt.Println("received value", v)
default:
fmt.Println("default case executed")
}
}
/*
ch 等于 nil，而我们试图在 select 中读取 ch（第 8 行）。如果没有默认情况，select 会一直阻塞，导致死锁。由于我们在 select 内部加入了默认情况，程序会执行它
*/ 当 select 由多个 case 准备就绪时，将会随机地选取其中之一去执行。
package main
import (
"fmt"
"time"
)
func server1(ch chan string) {
ch <- "from server1"
}
func server2(ch chan string) {
ch <- "from server2"
}
func main() {
output1 := make(chan string)
output2 := make(chan string)
go server1(output1)
go server2(output2)
time.Sleep(1 * time.Second)
select {
case s1 := <-output1:
fmt.Println(s1)
case s2 := <-output2:
fmt.Println(s2)
}
}除非有 case 执行，select 语句就会一直阻塞着。在这里，select 语句没有任何 case，因此它会一直阻塞，导致死锁。
ackage main
func main() {
select {}
}临界区： 当程序并发地运行时，多个 Go 协程不应该同时访问那些修改共享资源的代码。这些修改共享资源的代码称为临界区
Mutex 用于提供一种加锁机制（Locking Mechanism），可确保在某时刻只有一个协程在临界区运行，以防止出现竞态条件。
方法
mutex.Lock()
mutex.Unlock()
mutex.Lock()
x = x + 1
mutex.Unlock()
// 如果有一个 Go 协程已经持有了锁（Lock），当其他协程试图获得该锁时，这些协程会被阻塞，直到 Mutex 解除锁定为止我们创建了 1000 个 Go 协程。如果每个协程对 x 加 1，最终 x 期望的值应该是 1000, 使用 Mutex，修复竞态条件的问题。
package main
import (
"fmt"
"sync"
)
var x = 0
func increment(wg *sync.WaitGroup, m *sync.Mutex) {
m.Lock()
x = x + 1
m.Unlock()
wg.Done()
}
/*
我们修改了 increment 函数，将增加 x 的代码（x = x + 1）放置在 m.Lock() 和 m.Unlock()之间。现在这段代码不存在竞态条件了，因为任何时刻都只允许一个协程执行这段代码。
*/
func main() {
var w sync.WaitGroup
var m sync.Mutex // 定义加锁
for i := 0; i < 1000; i++ {
w.Add(1)
go increment(&w, &m)
}
w.Wait()
fmt.Println("Final value of x", x) // Final value of x 1000
}信道来处理竞态条件
package main
import (
"fmt"
"sync"
)
var x = 0
func increment(wg *sync.WaitGroup,ch chan bool) {
ch <- true
x = x + 1
<- ch
wg.Done()
}
func main() {
var w sync.WaitGroup
ch := make(chan bool, 1)
for i := 0; i < 10; i++{
w.Add(1)
go increment(&w,ch)
}
w.Wait()
fmt.Println("Finshed value of x", x) // Finshed value of x 10
}当 Go 协程需要与其他协程通信时，可以使用信道。
而当只允许一个协程访问临界区时，可以使用 Mutex。
63 + 49 + 39.60
使用结构体，而非类
Go 不支持类，而是提供了结构体。结构体中可以添加方法。这样可以将数据和操作数据的方法绑定在一起，实现与类相似的效果。
opp/
├── employee
│ └── employee.go
└── main.goemployee.go
package employee
import (
"fmt"
)
type employee struct {
firstName string
lastName string
totalLeaves int
leavesTaken int
}
/*
Go 不支持类，但结构体能够很好地取代类，而以 New(parameters) 签名的方法可以替代构造器。
提供了一个可引用的 New 函数，该函数接收必要的参数，返回一个新创建的 employee 结构体变量。
*/
func New(firstName string, lastName string, totalLeave int, leavesTaken int) employee {
e := employee {firstName, lastName, totalLeave, leavesTaken}
return e
}
func (e employee) LeavesRemaining() {
fmt.Printf("%s %s has %d leaves remaining", e.firstName, e.lastName, (e.totalLeaves - e.leavesTaken))
}main.go
package main
import "oop/employee"
func main() {
e := employee.New("Sam", "Adolf", 30, 20)
e.LeavesRemaining() // Sam Adolf has 10 leaves remaining
}Go 不支持继承，但它支持组合（Composition）。组合一般定义为“合并在一起”。汽车就是一个关于组合的例子：一辆汽车由车轮、引擎和其他各种部件组合在一起。
例如: 组合的典型例子就是博客帖子。每一个博客的帖子都有标题、内容和作者信息
package main
import (
"fmt"
)
/*
1、创建 author 结构体， author 字段有 firename、lastname、bio
2、添加了 fullName() 方法，其中 author 作为接受者类型，该方法返回作者的全名
*/
type author struct {
firstName string
lastName string
bio string
}
func (a author) fullName() string {
return fmt.Sprintf("%s %s", a.firstName, a.lastName)
}
/*
1、post 结构体的字段有 title、content, 嵌套匿名字段 author
2、post 可以访问 author 结构体的所有字段和方法
3、post 结构体添加了 details() 方法，用于打印标题、内容和作者的全名与简介
*/
type post struct {
title string
content string
author // 嵌套匿名字段 author
}
func (p post) details() {
fmt.Println("Title: ", p.title)
fmt.Println("Content: ", p.content)
fmt.Println("Author: ", p.fullName())
fmt.Println("Bio: ", p.bio)
}
func main() {
author1 := author{"张", "三", "Golang"}
post1 := post{"标题", "内容", author1}
post1.details()
}Title: 标题
Content: 内容
Author: 张 三
Bio: Golang进一步处理这个示例，使用博客帖子的切片来创建一个网站
package main
import (
"fmt"
)
/*
1、创建 author 结构体， author 字段有 firename、lastname、bio
2、添加了 fullName() 方法，其中 author 作为接受者类型，该方法返回作者的全名
*/
type author struct {
firstName string
lastName string
bio string
}
func (a author) fullName() string {
return fmt.Sprintf("%s %s", a.firstName, a.lastName)
}
/*
1、post 结构体的字段有 title、content, 嵌套匿名字段 author
2、post 可以访问 author 结构体的所有字段和方法
3、post 结构体添加了 details() 方法，用于打印标题、内容和作者的全名与简介
*/
type post struct {
title string
content string
author // 嵌套匿名字段 author
}
func (p post) details() {
fmt.Println("Title: ", p.title)
fmt.Println("Content: ", p.content)
fmt.Println("Author: ", p.fullName())
fmt.Println("Bio: ", p.bio)
}
/*
结构体切片的嵌套，
使用博客帖子的切片来创建一个网站
*/
type website struct {
posts []post // 结构体不能嵌套一个匿名切片,需要指定一个字段名来嵌套
}
func (w website) contents() {
fmt.Println("Contents of Website\n")
for _, v := range w.posts {
v.details()
fmt.Println()
}
}
func main() {
author1 := author{"张", "三", "Golang"}
post1 := post{
"Inheritance in Go",
"Go supports composition instead of inheritance",
author1,
}
post2 := post{
"Struct instead of Classes in Go",
"Go does not support classes but methods can be added to structs",
author1,
}
post3 := post{
"Concurrency",
"Go is a concurrent language and not a parallel one",
author1,
}
w := website{
posts: []post{post1,post2, post3},
}
w.contents()
}Contents of Website
Title: Inheritance in Go
Content: Go supports composition instead of inheritance
Author: 张 三
Bio: Golang
Title: Struct instead of Classes in Go
Content: Go does not support classes but methods can be added to structs
Author: 张 三
Bio: Golang
Title: Concurrency
Content: Go is a concurrent language and not a parallel one
Author: 张 三
Bio: Golang63 + 49 + 39.60
所有实现了接口的类型，都可以把它的值保存在一个接口类型的变量中。在 Go 中，我们使用接口的这种特性来实现多态。
假设某个虚构的组织所获得的收入来源于两个项目：fixed billing 和 time and material。该组织的净收益等于这两个项目的收入总和
package main
import "fmt"
// 定义一个接口, 接口里有两个方法
type Inome interface {
calculate() int // 计算并返回项目的收入
source() string // 返回项目名称
}
// 项目类型一
type FixedBilling struct {
projectName string // 项目名称
biddedAmount int // 该项目投标的金额
}
// 项目类型二
type TimeAndMaterial struct {
projectName string // 项目名称
noOfHours int
hourlyRate int
}
// 下一步我们给这些结构体类型定义方法，计算并返回实际收入和项目名称。
// 由于 FixedBilling 和 TimeAndMaterial 两个结构体都定义了 Income 接口的两个方法：calculate() 和 source()，
// 因此这两个结构体都实现了 Income 接口。
func (fb FixedBilling) calculate() int {
return fb.biddedAmount // 返回FixedBilling实际收入
}
func (fb FixedBilling) source() string {
return fb.projectName // 返回FixedBilling项目名称。
}
func (tm TimeAndMaterial) calculate() int {
return tm.noOfHours * tm.hourlyRate // 返回 TimeAndMaterial 实际收入,收入等于 noOfHours 和 hourlyRate 的乘积
}
func (tm TimeAndMaterial) source() string {
return tm.projectName // 返回 TimeAndMaterial 项目名称。
}
/*
声明一个 calculateNetIncome 函数，用来计算并打印总收入。
接收一个 Income 接口类型的切片作为参数。该函数会遍历这个接口切片，并依个调用 calculate() 方法，计算出总收入。该函数同样也会通过调用 source() 显示收入来源。根据 Income 接口的具体类型，程序会调用不同的 calculate() 和 source() 方法。于是，我们在 calculateNetIncome 函数中就实现了多态。
*/
func calculateNetIncome(ic []Inome) {
var netincome int = 0
for _, i := range ic {
fmt.Printf("Income From %s = $%d\n", i.source(), i.calculate())
netincome += i.calculate()
}
fmt.Printf("Net income of organisation = $%d", netincome)
}
/*
main 函数中，我们创建了三个项目，有两个是 FixedBilling 类型，一个是 TimeAndMaterial 类型。接着我们创建了一个 Income 类型的切片，存放了这三个项目。由于这三个项目都实现了 Interface 接口，因此可以把这三个项目放入 Income 切片。最后我们将该切片作为参数，调用了 calculateNetIncome 函数，显示了项目不同的收益和收入来源。
如果在该组织以后增加了新的收入来源，calculateNetIncome 无需修改一行代码，就可以正确地计算总收入了。:smile:
*/
func main() {
project1 := FixedBilling{projectName: "Project 1", biddedAmount: 5000}
project2 := FixedBilling{projectName: "Project 2", biddedAmount: 10000}
project3 := TimeAndMaterial{projectName: "Project 3", noOfHours: 160, hourlyRate: 25}
incomeStreams := []Inome{project1, project2, project3} // 定义接口传值切片
calculateNetIncome(incomeStreams)
}Income From Project 1 = $5000
Income From Project 2 = $10000
Income From Project 3 = $4000
Net income of organisation = $19000// 上面代码添加
type Advertisement struct {
adName string
CPC int
noOfClicks int
}
func (a Advertisement) calculate() int {
return a.CPC * a.noOfClicks
}
func (a Advertisement) source() string {
return a.adName
}
// 上面main代码修改如下
func main() {
project1 := FixedBilling{projectName: "Project 1", biddedAmount: 5000}
project2 := FixedBilling{projectName: "Project 2", biddedAmount: 10000}
project3 := TimeAndMaterial{projectName: "Project 3", noOfHours: 160, hourlyRate: 25}
bannerAd := Advertisement{adName: "Banner Ad", CPC: 2, noOfClicks: 500}
popupAd := Advertisement{adName: "Popup Ad", CPC: 5, noOfClicks: 750}
incomeStreams := []Income{project1, project2, project3, bannerAd, popupAd}
calculateNetIncome(incomeStreams)
}Income From Project 1 = $5000
Income From Project 2 = $10000
Income From Project 3 = $4000
Income From Banner Ad = $1000
Income From Popup Ad = $3750
Net income of organisation = $23750尽管我们新增了收益流，但却完全没有修改 calculateNetIncome 函数。这就是多态带来的好处。由于新的 Advertisement 同样实现了 Income 接口，所以我们能够向 incomeStreams 切片添加 Advertisement。calculateNetIncome 无需修改，因为它能够调用 Advertisement 类型的 calculate() 和 source() 方法。
package main
import (
"fmt"
"os"
)
/*
在处理错误时，通常都是将返回的错误与 nil 比较
nil 值表示了没有错误发生，而非 nil 值表示出现了错误
*/
func main() {
f, err := os.Open("/test.txt")
if err != nil {
fmt.Println(err) // open /test.txt: no such file or directory
return
}
fmt.Println(f.Name())
}type error interface {
Error() string
}1、断言底层结构体类型，使用结构体字段获取更多信息
package main
import (
"fmt"
"os"
)
func main() {
f, err := os.Open("/test.txt")
// 使用了类型断言（Type Assertion）来获取 error 接口的底层值
if err, ok := err.(*os.PathError); ok {
fmt.Println("File at path", err.Path, "failed to open")
return
}
fmt.Println(f.Name(), "opened successfully")
}2、断言底层结构体类型，调用方法获取更多信息
编写一个程序，断言 *DNSError 类型，并调用这些方法来确定该错误是临时性错误，还是由超时导致的。
package main
import (
"fmt"
"net"
)
func main() {
addr, err := net.LookupHost("golangbot123.com")
if err, ok := err.(*net.DNSError); ok {
if err.Timeout() {
fmt.Println("operation timed out")
} else if err.Temporary() {
fmt.Println("temporary error")
} else {
fmt.Println("generic error: ", err)
}
return
}
fmt.Println(addr)
}3、直接比较
查询了模式为 [ 的文件，然而这个模式写的不正确。我们检查了该错误是否为 nil。为了获取该错误的更多信息，将 error 直接与 filepath.ErrBadPattern 相比较。如果该条件满足，那么该错误就是由模式错误导致的
package main
import (
"fmt"
"path/filepath"
)
func main() {
files, error := filepath.Glob("[")
if error != nil && error == filepath.ErrBadPattern {
fmt.Println(error)
return
}
fmt.Println("matched files", files)
}4、不可忽略错误
package main
import (
"fmt"
"path/filepath"
)
func main() {
// 通过使用 _ 空白标识符，我忽略了 Glob 函数返回的错误
files, _ := filepath.Glob("[")
fmt.Println("matched files", files) // matched files []
}package main
import (
"errors"
"fmt"
"math"
)
/*
定义方法，接收一个 float64 类型参数，返回 float64 和 error
New 函数自定义返回的错误信息
*/
func circleArea(radius float64) (float64, error) {
if radius < 0 {
return 0, errors.New("radius is less than zero")
}
return math.Pi * radius * radius, nil
}
func main() {
radius := -20.0
area, err := circleArea(radius)
// 检查错误是否等于 nil。如果不是 nil，我们会打印出错误并返回，否则我们会打印出圆的面积
if err != nil {
fmt.Println(err)
return
}
fmt.Printf("Area of circle %0.2f", area)
}上面错误是固定的，如果我们想给错误信息添加额外的信息，比如把半径值打印出来
Errorf 函数会根据格式说明符，规定错误的格式，并返回一个符合该错误的字符串。
package main
import (
"fmt"
"math"
)
func circleArea(radius float64) (float64, error) {
if radius < 0 {
return 0, fmt.Errorf("Area calculation failed, radius %0.2f is less than zero", radius)
}
return math.Pi * radius * radius, nil
}
func main() {
radius := -20.0
area, err := circleArea(radius)
if err != nil {
fmt.Println(err)
return
}
fmt.Printf("Area of circle %0.2f", area)
}package main
import (
"fmt"
"math"
)
type areaError struct {
err string
radius float64
}
func (e *areaError) Error() string {
return fmt.Sprintf("radius %0.2f: %s", e.radius, e.err)
}
func circleArea(radius float64) (float64, error) {
if radius < 0 {
return 0, &areaError{"radius is negative", radius}
}
return math.Pi * radius * radius, nil
}
func main() {
radius := -20.0
area, err := circleArea(radius)
if err != nil {
if err, ok := err.(*areaError); ok {
fmt.Printf("Radius %0.2f is less than zero", err.radius)
return
}
fmt.Println(err)
return
}
fmt.Printf("Area of rectangle1 %0.2f", area)
}编写一个计算矩形面积的程序。如果长或宽小于零，程序就会打印出错误。
// 第一步就是创建一个表示错误的结构体。
// 有了错误类型，我们来实现 error 接口，并给该错误类型添加两个方法，使它提供了更多的错误信息
package main
import "fmt"
type areaError struct {
err string //error description
length float64 //length which caused the error
width float64 //width which caused the error
}
// Error() string 方法中返回了关于错误的描述
func (e *areaError) Error() string {
return e.err
}
// 当 length 小于零时，lengthNegative() bool 方法返回 true
func (e *areaError) lengthNegative() bool {
return e.length < 0
}
// 当 width 小于零时，widthNegative() bool 方法返回 true
func (e *areaError) widthNegative() bool {
return e.width < 0
}
// rectArea 函数检查了长或宽是否小于零，如果小于零，rectArea 会返回一个错误信息，否则 rectArea 会返回矩形的面积和一个值为 nil 的错误。
func rectArea(length, width float64) (float64, error) {
err := ""
if length < 0 {
err += "length is less than zero"
}
if width < 0 {
if err == "" {
err = "width is less than zero"
} else {
err += ", width is less than zero"
}
}
if err != "" {
return 0, &areaError{err, length, width}
}
return length * width, nil
}
/*
我们检查了错误是否为 nil。如果错误值不是 nil，我们会在下一行断言 *areaError 类型。
然后，我们使用 lengthNegative() 和 widthNegative() 方法，检查错误的原因是长度小于零还是宽度小于零。
这样我们就使用了错误结构体类型的方法，来提供更多的错误信息。
如果没有错误发生，就会打印矩形的面积。
*/
func main() {
length, width := -5.0, -9.0
area, err := rectArea(length, width)
if err != nil {
if err, ok := err.(*areaError); ok {
if err.lengthNegative() {
fmt.Printf("error: length %0.2f is less than zero\n", err.length)
}
if err.widthNegative() {
fmt.Printf("error: width %0.2f is less than zero\n", err.width)
}
return
}
fmt.Println(err)
return
}
fmt.Println("area of rect", area)
}error: length -5.00 is less than zero
error: width -9.00 is less than zero有些情况，当程序发生异常时，无法继续运行。在这种情况下，我们会使用 panic 来终止程序
可以认为 panic 和 recover 与其他语言中的 try-catch-finally 语句类似
发生了一个不能恢复的错误，此时程序不能继续运行。 一个例子就是 web 服务器无法绑定所要求的端口。在这种情况下，就应该使用 panic，因为如果不能绑定端口，啥也做不了。
panic 有两个合理的用例。
1、发生了一个不能恢复的错误，此时程序不能继续运行。 一个例子就是 web 服务器无法绑定所要求的端口。在这种情况下，就应该使用 panic，因为如果不能绑定端口，啥也做不了。
2、发生了一个编程上的错误。 假如我们有一个接收指针参数的方法，而其他人使用 nil 作为参数调用了它。在这种情况下，我们可以使用 panic，因为这是一个编程错误：用 nil 参数调用了一个只能接收合法指针的方法。
package main
import (
"fmt"
)
func fullName(firstName *string, lastName *string) {
if firstName == nil {
panic("runtime error: first name cannot be nil")
}
if lastName == nil {
panic("runtime error: last name cannot be nil")
}
fmt.Printf("%s %s\n", *firstName, *lastName)
fmt.Println("returned normally from fullName")
}
func main() {
firstName := "Elon"
fullName(&firstName, nil)
fmt.Println("returned normally from main")
}// 当出现了 panic 时，程序就会终止运行，打印出传入 panic 的参数
panic: runtime error: last name cannot be nil
// 接着打印出堆栈跟踪
goroutine 1 [running]:
main.fullName(0x1040c128, 0x0)
/tmp/sandbox135038844/main.go:12 +0x120
main.main()
/tmp/sandbox135038844/main.go:20 +0x80当函数发生 panic 时，它会终止运行，在执行完所有的延迟函数后，程序控制返回到该函数的调用方。这样的过程会一直持续下去，直到当前协程的所有函数都返回退出，然后程序会打印出 panic 信息，接着打印出堆栈跟踪，最后程序终止。
发生 panic 时，首先执行了延迟函数，接着控制返回到函数调用方，调用方的延迟函数继续运行，直到到达顶层调用函数。
package main
import (
"fmt"
)
func fullName(firstName *string, lastName *string) {
defer fmt.Println("deferred call in fullName")
if firstName == nil {
panic("runtime error: first name cannot be nil")
}
if lastName == nil {
panic("runtime error: last name cannot be nil")
}
fmt.Printf("%s %s\n", *firstName, *lastName)
fmt.Println("returned normally from fullName")
}
func main() {
defer fmt.Println("deferred call in main")
firstName := "Elon"
fullName(&firstName, nil)
fmt.Println("returned normally from main")
}This program prints,
deferred call in fullName
deferred call in main
panic: runtime error: last name cannot be nil
goroutine 1 [running]:
main.fullName(0x1042bf90, 0x0)
/tmp/sandbox060731990/main.go:13 +0x280
main.main()
/tmp/sandbox060731990/main.go:22 +0xc0recover 是一个内建函数，用于重新获得 panic 协程的控制。
只有在延迟函数的内部，调用 recover 才有用
在延迟函数内调用 recover，可以取到 panic 的错误信息，并且停止 panic 续发事件（Panicking Sequence），程序运行恢复正常
如果在延迟函数的外部调用 recover，就不能停止 panic 续发事件。
package main
import (
"fmt"
)
// recoverName() 函数调用了 recover()，返回了调用 panic 的传参
func recoverName() {
if r := recover(); r!= nil {
fmt.Println("recovered from ", r)
}
}
func fullName(firstName *string, lastName *string) {
// 当 fullName 发生 panic 时，会调用延迟函数 recoverName()，
// 它使用了 recover() 来停止 panic 续发事件。
defer recoverName()
if firstName == nil {
panic("runtime error: first name cannot be nil")
}
if lastName == nil {
panic("runtime error: last name cannot be nil")
}
fmt.Printf("%s %s\n", *firstName, *lastName)
fmt.Println("returned normally from fullName")
}
func main() {
defer fmt.Println("deferred call in main")
firstName := "Elon"
fullName(&firstName, nil)
fmt.Println("returned normally from main")
}recovered from runtime error: last name cannot be nil
returned normally from main
deferred call in main只有在相同的 Go 协程中调用 recover 才管用。recover 不能恢复一个不同协程的 panic
package main
import (
"fmt"
"time"
)
func recovery() {
if r := recover(); r != nil {
fmt.Println("recovered:", r)
}
}
func a() {
defer recovery()
fmt.Println("Inside A")
go b() // 不在同一个协程
time.Sleep(1 * time.Second)
}
func b() {
fmt.Println("Inside B")
panic("oh! B panicked")
}
func main() {
a()
fmt.Println("normally returned from main")
}Inside A
Inside B
panic: oh! B panicked
goroutine 5 [running]:
main.b()
/tmp/sandbox388039916/main.go:23 +0x80
created by main.a
/tmp/sandbox388039916/main.go:17 +0xc0由 go b() 修改为 b()，就可以恢复 panic 了， 因为 panic 发生在与 recover 相同的协程里。
当我们恢复 panic 时，我们就释放了它的堆栈跟踪。实际上，在上述程序里，恢复 panic 之后，我们就失去了堆栈跟踪。
有办法可以打印出堆栈跟踪，就是使用 Debug 包中的 PrintStack 函数。
import (
"fmt"
"runtime/debug"
)
func r() {
if r := recover(); r != nil {
fmt.Println("Recovered", r)
debug.PrintStack()
}
}
func a() {
defer r()
n := []int{5, 7, 4}
fmt.Println(n[3])
fmt.Println("normally returned from a")
}
func main() {
a()
fmt.Println("normally returned from main")
}// 首先已经恢复了 panic，打印出 Recovered runtime error: index out of range。此外，我们也打印出了堆栈跟踪。在恢复了 panic 之后，还打印出 normally returned from main。
Recovered runtime error: index out of range
goroutine 1 [running]:
runtime/debug.Stack(0x1042beb8, 0x2, 0x2, 0x1c)
/usr/local/go/src/runtime/debug/stack.go:24 +0xc0
runtime/debug.PrintStack()
/usr/local/go/src/runtime/debug/stack.go:16 +0x20
main.r()
/tmp/sandbox949178097/main.go:11 +0xe0
panic(0xf0a80, 0x17cd50)
/usr/local/go/src/runtime/panic.go:491 +0x2c0
main.a()
/tmp/sandbox949178097/main.go:18 +0x80
main.main()
/tmp/sandbox949178097/main.go:23 +0x20
normally returned from main可以把函数赋值给变量，也可以把函数作为其他函数的参数或者返回值
1、 匿名函数赋值变量
package main
import "fmt"
func main() {
a := func() {
fmt.Println("Hello wolrd")
}
a()
fmt.Printf("%T", a)
}Hello wolrd
func()2、匿名函数立即调用
package main
import (
"fmt"
)
func main() {
func() {
fmt.Println("hello world first class function")
}()
}hello world first class function3、向匿名函数传递参数
package main
import (
"fmt"
)
func main() {
func(n string) {
fmt.Println("Welcome", n)
}("Gophers")
}Welcome Gopherspackage main
import "fmt"
// 创建一个新的函数类型 add, 接收两个整型类型，并返回一个整型
type add func(a int, b int) int
func main() {
var a add = func(a int, b int) int {
return a + b
}
s := a(5, 6)
fmt.Println("Sum", s) // Sum 11
}高阶函数（Hiher-order Function）定义为：满足下列条件之一的函数：
接收一个或多个函数作为参数
返回值是一个函数
把函数作为参数，传递给其它函数
package main
import "fmt"
// 函数 simple 接收一个函数参数（该函数接收两个 int 参数，返回一个 a 整型）
func simple(a func(a, b int) int) {
fmt.Println(a(60,7))
}
func main() {
// 创建了一个匿名函数 f，其签名符合 simple 函数的参数
f := func(a, b int) int {
return a + b
}
simple(f) // 67
}在其它函数中返回函数
package main
import (
"fmt"
)
// simple 函数返回了一个函数，并接受两个 int 参数，返回一个 int。
func simple() func(a, b int) int {
f := func(a, b int) int {
return a + b
}
return f
}
func main() {
/*
调用了 simple 函数。我们把 simple 的返回值赋值给了 s
调用了 s，并向它传递了两个 int 参数
*/
s := simple()
fmt.Println(s(60, 7)) // 67
}当一个函数所访问的变量定义在函数体的外部时,称这样的匿名函数为闭包
package main
import "fmt"
func main() {
a := 5
// 访问了变量 a，而 a 存在于函数体的外部。因此这个匿名函数就是闭包。
func() {
fmt.Println("a=",a) // a= 5
}()
}每一个闭包都会绑定一个它自己的外围变量
package main
import (
"fmt"
)
// 函数 appendStr 返回了一个闭包
func appendStr() func(string) string {
t := "Hello"
c := func(b string) string {
t = t + " " + b
return t
}
return c
}
func main() {
a := appendStr()
b := appendStr()
fmt.Println(a("World")) // Hello World
fmt.Println(b("Everyone")) // Hello Everyone
fmt.Println(a("Gopher")) // Hello World Gopher
fmt.Println(b("!")) // Hello Everyone !
}package main
import (
"fmt"
)
type student struct {
firstName string
lastName string
grade string
country string
}
/*
filter 的第二个参数是一个函数
这个函数接收 student 参数，返回一个 bool 值
*/
func filter(s []student, f func(student) bool) []student {
var r []student
for _, v := range s {
if f(v) == true {
r = append(r, v)
}
}
return r
}
func main() {
s1 := student{
firstName: "Naveen",
lastName: "Ramanathan",
grade: "A",
country: "India",
}
s2 := student{
firstName: "Samuel",
lastName: "Johnson",
grade: "B",
country: "USA",
}
s := []student{s1, s2}
// 这个函数作为参数传递给了 filter 函数
f := filter(s, func(s student) bool {
if s.grade == "B" {
return true
}
return false
})
fmt.Println(f)
}示例二： 对切片的每个元素执行相同的操作，并返回结果
package main
import (
"fmt"
)
func iMap(s []int, f func(int) int) []int {
var r []int
for _, v := range s {
r = append(r, f(v))
}
return r
}
func main() {
a := []int{5, 6, 7, 8, 9}
r := iMap(a, func(n int) int {
return n * 5
})
fmt.Println(r) // [25 30 35 40 45]
}反射就是程序能够在运行时检查变量和值，求出它们的类型
reflect.Type: 表示 interface{} 具体类型
reflect.Value: 表示它的具体值
reflect.TypeOf() 返回 reflect.Type
reflect.ValueOf() 返回 reflect.Value
reflect.Kind: 表示该类型的特定类别
NumField(): 返回结构体中字段的数量
Field(): 返回字段 i 的 reflect.Value。
reflect 实现了运行时反射。reflect 包会帮助识别 interface{} 变量的底层具体类型和具体值
// 通用查询生成器,可以适用于任何结构体类型
package main
import (
"fmt"
"reflect"
)
type order struct {
ordId int
customerId int
}
// createQuery 函数接收 interface{} 作为参数
// 程序打印了接口的具体类型和具体值。
func createQuery(q interface{}) {
t := reflect.TypeOf(q) // reflect.TypeOf 接收了参数 interface{}，返回了reflect.Type
v := reflect.ValueOf(q) // 返回了 reflect.Value
fmt.Println("Type ", t) // Type main.order
fmt.Println("Value ", v) // Value {456 56}
}
func main() {
o := order{
ordId: 456,
customerId: 56,
}
createQuery(o)
}Type 表示 interface{} 的实际类型（在这里是 main.Order)，而 Kind 表示该类型的特定类别
package main
import (
"fmt"
"reflect"
)
type order struct {
ordId int
customerId int
}
func createQuery(q interface{}) {
t := reflect.TypeOf(q) // 实际类型main.order
k := t.Kind() // 该类型的特定类别（在这里是 struct）。
fmt.Println("Type ", t) // Type main.order
fmt.Println("Kind ", k) // Kind struct
}
func main() {
o := order{
ordId: 456,
customerId: 56,
}
createQuery(o)
}package main
import (
"fmt"
"reflect"
)
type order struct {
ordId int
customerId int
}
func createQuery(q interface{}) {
/*
1、判断类型是否是结构体
2、NumField 方法只能在结构体上使用
*/
if reflect.ValueOf(q).Kind() == reflect.Struct {
v := reflect.ValueOf(q)
fmt.Println("Number of fields", v.NumField())
for i := 0; i < v.NumField(); i++ {
fmt.Printf("Field:%d type:%T value:%v\n", i, v.Field(i), v.Field(i))
}
}
}
func main() {
o := order{
ordId: 456,
customerId: 56,
}
createQuery(o)
}Number of fields 2
Field:0 type:reflect.Value value:456
Field:1 type:reflect.Value value:56Int 和 String 可以帮助我们分别取出 reflect.Value 作为 int64 和 string。
package main
import (
"fmt"
"reflect"
)
func main() {
a := 56
x := reflect.ValueOf(a).Int()
fmt.Printf("type:%T value:%v\n", x, x) // type:int64 value:56
b := "Naveen"
y := reflect.ValueOf(b).String()
fmt.Printf("type:%T value:%v\n", y, y) // type:string value:Naveen
}package main
import (
"fmt"
"reflect"
)
type order struct {
ordId int
customerId int
}
type employee struct {
name string
id int
address string
salary int
country string
}
func createQuery(q interface{}) {
if reflect.ValueOf(q).Kind() == reflect.Struct {
t := reflect.TypeOf(q).Name()
query := fmt.Sprintf("insert into %s values(", t)
v := reflect.ValueOf(q)
for i := 0; i < v.NumField(); i++ {
switch v.Field(i).Kind() {
case reflect.Int:
if i == 0 {
query = fmt.Sprintf("%s%d", query, v.Field(i).Int())
} else {
query = fmt.Sprintf("%s, %d", query, v.Field(i).Int())
}
case reflect.String:
if i == 0 {
query = fmt.Sprintf("%s\"%s\"", query, v.Field(i).String())
} else {
query = fmt.Sprintf("%s, \"%s\"", query, v.Field(i).String())
}
default:
fmt.Println("Unsupported type")
return
}
}
query = fmt.Sprintf("%s)", query)
fmt.Println(query)
return
}
fmt.Println("unsupported type")
}
func main() {
o := order{
ordId: 456,
customerId: 56,
}
createQuery(o)
e := employee{
name: "Naveen",
id: 565,
address: "Coimbatore",
salary: 90000,
country: "India",
}
createQuery(e)
i := 90
createQuery(i)
}Map 是一种无序的键值对的集合。Map 最重要的一点是通过 key 来快速检索数据，key 类似于索引，指向数据的值。
/* 声明变量， 默认 map 是 nil */
var map_variable map[key_data_type]value_data_type
/* 使用 make 函数*/
map_variable := make(map[key_data_type]value_data_type)
// 如果不初始化 map，那么就会创建一个 nil map。nil map 不能用来存放键值对package main
import "fmt"
func main() {
var contryMap map[string]string // 创建集合
contryMap = make(map[string]string)
// map 插入key - value 对
contryMap ["中国"] = "北京"
contryMap ["美国"] = "纽约"
contryMap ["泰国"] = "曼谷"
contryMap ["英国"] = "伦敦"
// 使用键输出对应的首都地址
for contry := range contryMap {
fmt.Println(contry, " 首都是", contryMap [contry])
}
// 查看元素在集合中是否存在
capital, ok := contryMap ["迪拜"]
if(ok) {
fmt.Println("迪拜 首都是", capital)
} else {
fmt.Println("迪拜 首都不存在")
}
}英国 首都是 伦敦
中国 首都是 北京
美国 首都是 纽约
泰国 首都是 曼谷
迪拜 首都不存在delete() 函数用于删除集合的元素, 参数为 map 和其对应的 key
package main
import "fmt"
func main() {
/* 创建map */
countryCapitalMap := map[string]string{"France": "Paris", "Italy": "Rome", "Japan": "Tokyo", "India": "New delhi"}
/*删除元素*/
delete(countryCapitalMap, "France")
/*打印地图*/
for country := range countryCapitalMap {
fmt.Println(country, "首都是", countryCapitalMap [ country ])
}
}Italy 首都是 Rome
Japan 首都是 Tokyo
India 首都是 New delhipackage main
import "fmt"
func main() {
// 方法一: 变量声明和初始化，显示类型
var _var1 = 1
// 方法二： 变量声明和初始化，指定变量类型，不声明值
var _var2 int
var _var3 string
var _var4 float64
// 方法三：同时声明和初始化多个同类型变量
var _var5, _var6, _var7 int = 111, 222 , 333
// 方法四：同时声明和初始化多个不同类型变量
var _var8, _var9, _var10 = 2, "abc", 11.44// 方法五：短变量声明, 内置变量
_var11 := 2
_var12 := "3"
_var13 := 11.11
// 方法五：短变量声明, 多变量声明
_var14, _var15, _var16 := 800, "NHOOO", 47.56
fmt.Printf("变量类型: %T", _var1,_var2,_var3,_var4,_var5,_var6,_var7,_var8,_var9,_var10,_var11,_var12,_var13,_var14,_var15,_var16)