int: int8, int16, int32(rune), int64
uint: uint8(byte), uint16, uint32, uint64
float32, float64
string
复数：complex64, complex128
复数有实部和虚部，complex64的实部和虚部为32位，complex128的实部和虚部为64位。
array -- 固定长度的数组
int8 range: -128 127
int16 range: -32768 32767
int32 range: -2147483648 2147483647
int64 range: -9223372036854775808 9223372036854775807
int32: 0x3e6f54ff 1047483647
int16: 0x54ff 21759
// 输出各数值范围
fmt.Println("int8 range:", math.MinInt8, math.MaxInt8)
rune // int32 的别名 代表一个 Unicode 码
Go 语言中不允许将整型强制转换为布尔型.,布尔型无法参与数值运算，也无法与其他类型进行转换。
当一个变量被声明之后，系统自动赋予它该类型的零值： int 为 0，float 为 0.0，bool 为 false，string 为空字符串
切片slice、map、channel、interface、function的默认为 nil
值类型：int、float、bool、string、数组array、结构体struct
引用类型：指针、切片slice、map、接口interface、函数func、管道chan
给新的变量赋值时(拷贝时)，为拷贝，直接开辟新的内存地址存储值。
给新的变量赋值时(拷贝时)，为浅拷贝，新的变量通过指针指向原来的内存地址。可以使用copy关键字实现引用类型的深拷贝。
当如果没有任何一个变量引用这个地址时，这个地址就会被GC垃圾回收。
var c, d int = 1, 2
g, h := 123, "hello"
a int
b bool
)
匿名变量的特点是一个下画线_，这本身就是一个特殊的标识符，被称为空白标识符。它可以像其他标识符那样用于变量的声明或赋值（任何类型都可以赋值给它），但任何赋给这个标识符的值都将被抛弃，因此这些值不能在后续的代码中使用，也不可以使用这个标识符作为变量对其它变量进行赋值或运算。
return 10, 20
}
func main(){
a, _ := GetData()
_, b := GetData()
fmt.Println(a, b)
}
需要注意的是匿名变量不占用内存空间，不会分配内存。匿名变量与匿名变量之间也不会因为多次声明而无法使用。
- 局部变量
- 全局变量以 var 关键字开头外部包中使用首字母必须大写
- 形式参数形式参数会作为函数的局部变量来使用
var arr0 [5]int = [5]int{1, 2, 3}
var arr1 = [5]int{1, 2, 3, 4, 5}
var arr2 = [...]int{1, 2, 3, 4, 5, 6}
var str = [5]string{3: "hello world", 4: "tom"}
局部：
a := [3]int{1, 2} // 未初始化元素值为 0。
b := [...]int{1, 2, 3, 4} // 通过初始化值确定数组长度。
c := [5]int{2: 100, 4: 200} // 使用索引号初始化元素。
d := [...]struct {
name string
age uint8
}{
{"user1", 10}, // 可省略元素类型。
{"user2", 20}, // 别忘了最后一行的逗号。
}
var arr0 [5]int = [5]int{1, 2, 3}
var arr1 = [5]int{1, 2, 3, 4, 5}
var arr2 = [...]int{1, 2, 3, 4, 5, 6}
var str = [5]string{3: "hello world", 4: "tom"}
func main() {
a := [3]int{1, 2} // 未初始化元素值为 0。
b := [...]int{1, 2, 3, 4} // 通过初始化值确定数组长度。
c := [5]int{2: 100, 4: 200} // 使用引号初始化元素。
d := [...]struct {
name string
age uint8
}{
{"user1", 10}, // 可省略元素类型。
{"user2", 20}, // 别忘了最后一行的逗号。
}
fmt.Println(arr0, arr1, arr2, str)
fmt.Println(a, b, c, d)
}
[1 2 3 0 0] [1 2 3 4 5] [1 2 3 4 5 6] [ hello world tom]
[1 2 0] [1 2 3 4] [0 0 100 0 200] [{user1 10} {user2 20}]
var arr0 [5][3]int
var arr1 [2][3]int = [...][3]int{{1, 2, 3}, {7, 8, 9}}
局部：
a := [2][3]int{{1, 2, 3}, {4, 5, 6}}
b := [...][2]int{{1, 1}, {2, 2}, {3, 3}} // 第 2 纬度不能用 "..."。
var arr1 [2][3]int = [...][3]int{{1, 2, 3}, {7, 8, 9}}
func main() {
a := [2][3]int{{1, 2, 3}, {4, 5, 6}}
b := [...][2]int{{1, 1}, {2, 2}, {3, 3}} // 第 2 纬度不能用 "..."。
fmt.Println(arr0, arr1)
fmt.Println(a, b)
}
[[0 0 0] [0 0 0] [0 0 0] [0 0 0] [0 0 0]] [[1 2 3] [7 8 9]]
[[1 2 3] [4 5 6]] [[1 1] [2 2] [3 3]]
内置函数 len 和 cap 都返回数组长度 (元素数量)。如：
println(len(a), cap(a)) //得到 2 2
var f [2][3]int = [...][3]int{{1, 2, 3}, {7, 8, 9}}
for k1, v1 := range f {
for k2, v2 := range v1 {
fmt.Printf("(%d,%d)=%d ", k1, k2, v2)
}
fmt.Println()
}
}
输出结果：
(0,0)=1 (0,1)=2 (0,2)=3
(1,0)=7 (1,1)=8 (1,2)=9
import "fmt"
func printArr(arr *[5]int) {
arr[0] = 10
for i, v := range arr {
fmt.Println(i, v)
}
}
func main() {
var arr1 [5]int
printArr(&arr1)
fmt.Println(arr1)
arr2 := [...]int{2, 4, 6, 8, 10}
printArr(&arr2)
fmt.Println(arr2)
}
需要说明，slice 并不是数组或数组指针。它通过内部指针和相关属性引用数组片段，以实现变长方案。
1. 切片：切片是数组的一个引用，因此切片是引用类型。但自身是结构体，值拷贝传递。
2. 切片的长度可以改变，因此，切片是一个可变的数组。
3. 切片遍历方式和数组一样，可以用len()求长度。表示可用元素数量，读写操作不能超过该限制。
4. cap可以求出slice最大扩张容量，不能超出数组限制。0 <= len(slice) <= len(array)，其中array是slice引用的数组。
5. 切片的定义：var 变量名 []类型，比如 var str []string var arr []int。
6. 如果 slice == nil，那么 len、cap 结果都等于 0。
import "fmt"
func main() {
//1.声明切片
var s1 []int
if s1 == nil {
fmt.Println("是空")
} else {
fmt.Println("不是空")
}
// 2.:=
s2 := []int{}
// 3.make()
var s3 []int = make([]int, 0)
fmt.Println(s1, s2, s3)
// 4.初始化赋值
var s4 []int = make([]int, 0, 0)
fmt.Println(s4)
s5 := []int{1, 2, 3}
fmt.Println(s5)
// 5.从数组切片
arr := [5]int{1, 2, 3, 4, 5}
var s6 []int
// 前包后不包
s6 = arr[1:4]
fmt.Println(s6)
}
var arr = [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
var slice0 []int = arr[start:end]
var slice1 []int = arr[:end]
var slice2 []int = arr[start:]
var slice3 []int = arr[:]
var slice4 = arr[:len(arr)-1] //去掉切片的最后一个元素
局部：
arr2 := [...]int{9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
slice5 := arr[start:end]
slice6 := arr[:end]
slice7 := arr[start:]
slice8 := arr[:]
slice9 := arr[:len(arr)-1] //去掉切片的最后一个元素
import (
"fmt"
)
var arr = [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
var slice0 []int = arr[2:8]
var slice1 []int = arr[0:6] //可以简写为 var slice []int = arr[:end]
var slice2 []int = arr[5:10] //可以简写为 var slice[]int = arr[start:]
var slice3 []int = arr[0:len(arr)] //var slice []int = arr[:]
var slice4 = arr[:len(arr)-1] //去掉切片的最后一个元素
func main() {
fmt.Printf("全局变量：arr %v\n", arr)
fmt.Printf("全局变量：slice0 %v\n", slice0)
fmt.Printf("全局变量：slice1 %v\n", slice1)
fmt.Printf("全局变量：slice2 %v\n", slice2)
fmt.Printf("全局变量：slice3 %v\n", slice3)
fmt.Printf("全局变量：slice4 %v\n", slice4)
fmt.Printf("-----------------------------------\n")
arr2 := [...]int{9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
slice5 := arr[2:8]
slice6 := arr[0:6] //可以简写为 slice := arr[:end]
slice7 := arr[5:10] //可以简写为 slice := arr[start:]
slice8 := arr[0:len(arr)] //slice := arr[:]
slice9 := arr[:len(arr)-1] //去掉切片的最后一个元素
fmt.Printf("局部变量： arr2 %v\n", arr2)
fmt.Printf("局部变量： slice5 %v\n", slice5)
fmt.Printf("局部变量： slice6 %v\n", slice6)
fmt.Printf("局部变量： slice7 %v\n", slice7)
fmt.Printf("局部变量： slice8 %v\n", slice8)
fmt.Printf("局部变量： slice9 %v\n", slice9)
}
全局变量：arr [0 1 2 3 4 5 6 7 8 9]
全局变量：slice0 [2 3 4 5 6 7]
全局变量：slice1 [0 1 2 3 4 5]
全局变量：slice2 [5 6 7 8 9]
全局变量：slice3 [0 1 2 3 4 5 6 7 8 9]
全局变量：slice4 [0 1 2 3 4 5 6 7 8]
-----------------------------------
局部变量： arr2 [9 8 7 6 5 4 3 2 1 0]
局部变量： slice5 [2 3 4 5 6 7]
局部变量： slice6 [0 1 2 3 4 5]
局部变量： slice7 [5 6 7 8 9]
局部变量： slice8 [0 1 2 3 4 5 6 7 8 9]
局部变量： slice9 [0 1 2 3 4 5 6 7 8]
var slice []type = make([]type, len)
slice := make([]type, len)
slice := make([]type, len, cap)
使用 make 动态创建slice，避免了数组必须用常量做长度的麻烦。还可用指针直接访问底层数组，退化成普通数组操作。
import "fmt"
func main() {
s := []int{0, 1, 2, 3}
p := &s[2] // *int, 获取底层数组元素指针。
*p += 100
fmt.Println(s)
}
[]int{1, 2, 3},
[]int{100, 200},
[]int{11, 22, 33, 44},
}
fmt.Println(data)
[[1 2 3] [100 200] [11 22 33 44]]
import (
"fmt"
)
func main() {
var a = []int{1, 2, 3}
fmt.Printf("slice a : %v\n", a)
var b = []int{4, 5, 6}
fmt.Printf("slice b : %v\n", b)
c := append(a, b...)
fmt.Printf("slice c : %v\n", c)
d := append(c, 7)
fmt.Printf("slice d : %v\n", d)
e := append(d, 8, 9, 10)
fmt.Printf("slice e : %v\n", e)
}
slice b : [4 5 6]
slice c : [1 2 3 4 5 6]
slice d : [1 2 3 4 5 6 7]
slice e : [1 2 3 4 5 6 7 8 9 10]
append ：向 slice 尾部添加数据，返回新的 slice 对象。
import (
"fmt"
)
func main() {
s1 := make([]int, 0, 5)
fmt.Printf("%p\n", &s1) //0xc42000a060
s2 := append(s1, 1)
fmt.Printf("%p\n", &s2)//0xc42000a080
fmt.Println(s1, s2) //[] [1]
}
4.5. 超出原 slice.cap 限制，就会重新分配底层数组，即便原数组并未填满。
func main() {
data := [...]int{0, 1, 2, 3, 4, 10: 0}
s := data[:2:3]
s = append(s, 100, 200) // 一次 append 两个值，超出 s.cap 限制。
fmt.Println(s, data) // 重新分配底层数组，与原数组无关。
fmt.Println(&s[0], &data[0]) // 比对底层数组起始指针。
//得到 [0 1 100 200] [0 1 2 3 4 0 0 0 0 0 0]
//0xc4200160f0 0xc420070060
}
从输出结果可以看出，append 后的 s 重新分配了底层数组，并复制数据。如果只追加一个值，则不会超过 s.cap 限制，也就不会重新分配。 通常以 2 倍容量重新分配底层数组。在大批量添加数据时，建议一次性分配足够大的空间，以减少内存分配和数据复制开销。或初始化足够长的 len 属性，改用索引号进行操作。及时释放不再使用的 slice 对象，避免持有过期数组，造成 GC 无法回收。
import (
"fmt"
)
func main() {
s := make([]int, 0, 1)
c := cap(s)
for i := 0; i < 50; i++ {
s = append(s, i)
if n := cap(s); n > c {
fmt.Printf("cap: %d -> %d\n", c, n)
c = n
}
}
}
cap: 2 -> 4
cap: 4 -> 8
cap: 8 -> 16
cap: 16 -> 32
cap: 32 -> 64
import (
"fmt"
)
func main() {
s1 := []int{1, 2, 3, 4, 5}
fmt.Printf("slice s1 : %v\n", s1)
s2 := make([]int, 10)
fmt.Printf("slice s2 : %v\n", s2)
copy(s2, s1)
fmt.Printf("copied slice s1 : %v\n", s1)
fmt.Printf("copied slice s2 : %v\n", s2)
s3 := []int{1, 2, 3}
fmt.Printf("slice s3 : %v\n", s3)
s3 = append(s3, s2...)
fmt.Printf("appended slice s3 : %v\n", s3)
s3 = append(s3, 4, 5, 6)
fmt.Printf("last slice s3 : %v\n", s3)
}
slice s2 : [0 0 0 0 0 0 0 0 0 0]
copied slice s1 : [1 2 3 4 5]
copied slice s2 : [1 2 3 4 5 0 0 0 0 0]
slice s3 : [1 2 3]
appended slice s3 : [1 2 3 1 2 3 4 5 0 0 0 0 0]
last slice s3 : [1 2 3 1 2 3 4 5 0 0 0 0 0 4 5 6]
copy ：函数 copy 在两个 slice 间复制数据，复制长度以 len 小的为准。两个 slice 可指向同一底层数组，允许元素区间重叠。
import (
"fmt"
)
func main() {
data := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
fmt.Println("array data : ", data)
s1 := data[8:]
s2 := data[:5]
fmt.Printf("slice s1 : %v\n", s1)
fmt.Printf("slice s2 : %v\n", s2)
copy(s2, s1)
fmt.Printf("copied slice s1 : %v\n", s1)
fmt.Printf("copied slice s2 : %v\n", s2)
fmt.Println("last array data : ", data)
}
array data : [0 1 2 3 4 5 6 7 8 9]
slice s1 : [8 9]
slice s2 : [0 1 2 3 4]
copied slice s1 : [8 9]
copied slice s2 : [8 9 2 3 4]
last array data : [8 9 2 3 4 5 6 7 8 9]
应及时将所需数据 copy 到较小的 slice，以便释放超大号底层数组内存。
func main() {
data := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
slice := data[:]
for index, value := range slice {
fmt.Printf("inde : %v , value : %v\n", index, value)
}
}
inde : 1 , value : 1 等.....
fmt.Printf(a : %v , len(a) : %v\n", a, len(a))//a : [1 3 4 5] , len(a) : 4
b := a[1:2]
fmt.Printf("b : %v , len(b) : %v\n", b, len(b))// b: [3]
c := b[0:3]
fmt.Printf("c : %v , len(c) : %v\n", c, len(c))// c: [3,4,5]
注意：
c := b[0:3] 的结果为什么是[3,4,5]:上述b的结果是切片[3] 由于bb是切片[3]，它只有一个元素。尝试使用索引0到3的范围去索引这个切片会导致一个越界的错误。在Go中，当一个切片被越界索引时，它会返回一个新的切片，该切片与原始切片共享底层数组，但具有指定的长度和容量。
在这种情况下，bb[0:3]返回的切片将是[3 4 5]。这是因为：
·起始索引0对应于原始切片的第一个元素（在这种情况下，这是3）。
·结束索引3对应于原始切片的第四个元素（越界到5）。
因此，c的结果是切片[3 4 5]。
4.11. 字符串和切片（string and slice）
string底层就是一个byte的数组，因此，也可以进行切片操作。
s := []byte(str) //中文字符需要用[]rune(str)
s[6] = 'G'
s = s[:8]
s = append(s, '!')
str = string(s)
fmt.Println(str)//Hello Go!
s := []rune(str)
s[3] = '嘿'
s[4] = '哈'
s[12] = 'g'
s = s[:14]
str = string(s)
fmt.Println(str)// 你好，嘿哈！Hello go
4.12 a[x:y:z] 切片内容 [x:y] 切片长度: y-x 切片容量:z-x
golang slice data[:6:8] 两个冒号的理解
常规slice , data[6:8]，从第6位到第8位（返回6， 7），长度len为2， 最大可扩充长度cap为4（6-9）
另一种写法： data[:6:8] 每个数字前都有个冒号， slice内容为data从0到第6位，长度len为6，最大扩充项cap设置为8
slice := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
d1 := slice[6:8]
fmt.Println(d1, len(d1), cap(d1))//[6 7] 2 4
d2 := slice[:6:8]
fmt.Println(d2, len(d2), cap(d2))//[0 1 2 3 4 5] 6 8
str := strings.Replace(strings.Trim(fmt.Sprint(要转换的数组或切片), "[]"), " ", ",", -1)
str := strings.Replace(strings.Trim(fmt.Sprint(slice), "[]"), " ", ",", -1)
fmt.Printf("%T,%v", str, str) //得到string, 0,1,2,3
import (
"fmt"
)
func main() {
str := "hello world"
s1 := str[0:5]
fmt.Println(s1)//hello
s2 := str[6:]
fmt.Println(s2)//world
}
Go语言中的函数传参都是值拷贝，当我们想要修改某个变量的时候，我们可以创建一个指向该变量地址的指针变量。传递数据使用指针，而无须拷贝数据。类型指针不能进行偏移和运算。Go语言中的指针操作非常简单，只需要记住两个符号：
和基础类型数据相同，在使用指针变量之前我们首先需要申明指针，声明格式如下：var var_name *var-type，其中的var-type 为指针类型，var_name 为指针变量名，* 号用于指定变量是作为一个指针。
var fp *float32 /* 指向浮点型 */
指针的初始化就是取出相对应的变量地址对指针进行赋值，具体如下：
var ip *int /* 声明指针变量 */
ip = &a /* 指针变量的存储地址 */
b := &a
fmt.Printf("a:%d ptr:%p\n", a, &a) // a:10 ptr:0xc00001a078
fmt.Printf("b:%p type:%T\n", b, b) // b:0xc00001a078 type:*int
fmt.Println(&b) // 0xc00000e018
在对普通变量使用&操作符取地址后会获得这个变量的指针，然后可以对指针使用*操作，也就是指针取值，代码如下。
//指针取值
a := 10
b := &a // 取变量a的地址，将指针保存到b中
fmt.Printf("type of b:%T\n", b)
c := *b // 指针取值（根据指针去内存取值）
fmt.Printf("type of c:%T\n", c)
fmt.Printf("value of c:%v\n", c)
}
得到：
type of b:*int
type of c:int
value of c:10
总结： 取地址操作符&和取值操作符*是一对互补操作符，&取出地址，*根据地址取出地址指向的值。
变量、指针地址、指针变量、取地址、取值的相互关系和特性如下：\
1.对变量进行取地址（&）操作，可以获得这个变量的指针变量。
2.指针变量的值是指针地址。
3.对指针变量进行取值（*）操作，可以获得指针变量指向的原变量的值。
x = 100
}
func modify2(x *int) {
*x = 100
}
func main() {
a := 10
modify1(a)
fmt.Println(a) // 10
modify2(&a)
fmt.Println(a) // 100
}
当一个指针被定义后没有分配到任何变量时，它的值为 nil，也称为空指针。
var p *string
fmt.Println(p)
fmt.Printf("p的值是%s/n", p)
if p != nil {
fmt.Println("非空")
} else {
fmt.Println("空值")
}
}
new它是一个内置的函数，它的函数签名： func new(Type) *Type
1.Type表示类型，new函数只接受一个参数，这个参数是一个类型
2.*Type表示类型指针，new函数返回一个指向该类型内存地址的指针。
new函数不太常用，使用new函数得到的是一个类型的指针，并且该指针对应的值为该类型的零值。举个例子：
a := new(int)
b := new(bool)
fmt.Printf("%T\n", a) // *int
fmt.Printf("%T\n", b) // *bool
fmt.Println(*a) // 0
fmt.Println(*b) // false
}
如var a *int只是声明了一个指针变量a但是没有初始化，指针作为引用类型需要初始化后才会拥有内存空间，才可以给它赋值。应该按照如下方式使用内置的new函数对a进行初始化之后就可以正常对其赋值了：
var a *int
a = new(int)
*a = 10
fmt.Println(*a)
}
make也是用于内存分配的，区别于new，它只用于slice、map以及chan的内存创建，而且它返回的类型就是这三个类型本身，而不是他们的指针类型，因为这三种类型就是引用类型，所以就没有必要返回他们的指针了。make函数的函数签名如下：
func make(t Type, size ...IntegerType) Type
make函数是无可替代的，我们在使用slice、map以及channel的时候，都需要使用make进行初始化，然后才可以对它们进行操作。
var b map[string]int只是声明变量b是一个map类型的变量，需要像下面的示例代码一样使用make函数进行初始化操作之后，才能对其进行键值对赋值：
var b map[string]int
b = make(map[string]int, 10)
b["测试"] = 100
fmt.Println(b)
}
2.make只用于slice、map以及channel的初始化，返回的还是这三个引用类型本身；
3.而new用于类型的内存分配，并且内存对应的值为类型零值，返回的是指向类型的指针。
map是一种无序的基于key-value的数据结构，Go语言中的map是引用类型，必须初始化才能使用。
Go语言中 map的定义语法如下 map[KeyType]ValueType
其中，KeyType:表示键的类型， ValueType:表示键对应的值的类型。
map类型的变量默认初始值为nil，需要使用make()函数来分配内存。语法为：
make(map[KeyType]ValueType, [cap])
其中cap表示map的容量，该参数虽然不是必须的，但是我们应该在初始化map的时候就为其指定一个合适的容量。
var result = make(map[string]interface{})
map中的数据都是成对出现的，map的基本使用示例代码如下：
var result = make(map[string]interface{})
//局部
scoreMap := make(map[string]int, 8)
scoreMap["张三"] = 90
scoreMap["小明"] = 100
fmt.Println(scoreMap)
fmt.Println(scoreMap["小明"])
fmt.Printf("type of a:%T\n", scoreMap)
}
100
type of a:map[string]int
userInfo := map[string]string{
"username": "pprof.cn",
"password": "123456",
}
fmt.Println(userInfo) //
}
scoreMap := make(map[string]int)
scoreMap["张三"] = 90
scoreMap["小明"] = 100
// 如果key存在ok为true,v为对应的值；不存在ok为false,v为值类型的零值
v, ok := scoreMap["张三"]
if ok {
fmt.Println(v)
} else {
fmt.Println("查无此人")
}
}
scoreMap := make(map[string]int)
scoreMap["张三"] = 90
scoreMap["小明"] = 100
scoreMap["王五"] = 60
for k, v := range scoreMap {
fmt.Println(k, v)
}
}
scoreMap := make(map[string]int)
scoreMap["张三"] = 90
scoreMap["小明"] = 100
scoreMap["王五"] = 60
for k := range scoreMap {
fmt.Println(k)
}
}
使用delete()内建函数从map中删除一组键值对，delete()函数的格式如下：
key:表示要删除的键值对的键
scoreMap := make(map[string]int)
scoreMap["张三"] = 90
scoreMap["小明"] = 100
scoreMap["王五"] = 60
delete(scoreMap, "小明")//将小明:100从map中删除
for k,v := range scoreMap{
fmt.Println(k, v)
}
}
var result = make(map[string]interface{}) //值是inteface表示值可以是任意类型的
var bb = map[string]interface{}{
"name": "1111",
"age": 11,
}
var mapSlice = make([]map[string]string, 3)
for index, value := range mapSlice {
fmt.Printf("index:%d value:%v\n", index, value)
}
fmt.Println("after init")
// 对切片中的map元素进行初始化
mapSlice[0] = make(map[string]string, 10)
mapSlice[0]["name"] = "王五"
mapSlice[0]["password"] = "123456"
mapSlice[0]["address"] = "红旗大街"
for index, value := range mapSlice {
fmt.Printf("index:%d value:%v\n", index, value)
}
}
var sliceMap = make(map[string][]string, 3)
fmt.Println(sliceMap)
fmt.Println("after init")
key := "中国"
value, ok := sliceMap[key]
if !ok {
value = make([]string, 0, 2)
}
value = append(value, "北京", "上海")
sliceMap[key] = value
fmt.Println(sliceMap)
}
在Go语言中有一些基本的数据类型，如string、整型、浮点型、布尔等数据类型，Go语言中可以使用type关键字来定义自定义类型。
自定义类型是定义了一个全新的类型。我们可以基于内置的基本类型定义，也可以通过struct定义。例如：
通过Type关键字的定义，MyInt就是一种新的类型，它具有int的特性。
Go语言提供了一种自定义数据类型，可以封装多个基本数据类型，这种数据类型叫结构体，英文名称struct。 也就是我们可以通过struct来定义自己的类型了。
使用type和struct关键字来定义结构体，具体代码格式如下：
字段名 字段类型
字段名 字段类型
…
}
2.字段名：表示结构体字段名。结构体中的字段名必须唯一。
3.字段类型：表示结构体字段的具体类型。
name, city string
age int8
}
只有当结构体实例化时，才会真正地分配内存。也就是必须实例化后才能使用结构体的字段。
结构体本身也是一种类型，我们可以像声明内置类型一样使用var关键字声明结构体类型。
name string
city string
age int8
}
func main() {
var p1 person
p1.name = "pprof.cn"
p1.city = "北京"
p1.age = 18
fmt.Printf("p1=%v\n", p1) //p1={pprof.cn 北京 18}
fmt.Printf("p1=%#v\n", p1) //p1=main.person{name:"pprof.cn", city:"北京", age:18}
}
我们通过.来访问结构体的字段（成员变量）,例如p1.name和p1.age等。
import (
"fmt"
)
func main() {
var user struct{Name string; Age int}
user.Name = "pprof.cn"
user.Age = 18
fmt.Printf("%#v\n", user)
}
我们还可以通过使用new关键字对结构体进行实例化，得到的是结构体的地址。 格式如下：
fmt.Printf("%T\n", p2) //*main.person
fmt.Printf("p2=%#v\n", p2) //p2=&main.person{name:"", city:"", age:0}
需要注意的是在Go语言中支持对结构体指针直接使用.来访问结构体的成员。
p2.name = "测试"
p2.age = 18
p2.city = "北京"
fmt.Printf("p2=%#v\n", p2) //p2=&main.person{name:"测试", city:"北京", age:18}
使用&对结构体进行取地址操作相当于对该结构体类型进行了一次new实例化操作。
fmt.Printf("%T\n", p3) //*main.person
fmt.Printf("p3=%#v\n", p3) //p3=&main.person{name:"", city:"", age:0}
p3.name = "博客"
p3.age = 30
p3.city = "成都"
fmt.Printf("p3=%#v\n", p3) //p3=&main.person{name:"博客", city:"成都", age:30}
p3.name = "博客"其实在底层是(*p3).name = "博客"，这是Go语言帮我们实现的语法糖。
name string
city string
age int8
}
func main() {
var p4 person
fmt.Printf("p4=%#v\n", p4) //p4=main.person{name:"", city:"", age:0}
}
使用键值对对结构体进行初始化时，键对应结构体的字段，值对应该字段的初始值。
name: "pprof.cn",
city: "北京",
age: 18,
}
fmt.Printf("p5=%#v\n", p5) //p5=main.person{name:"pprof.cn", city:"北京", age:18}
name: "pprof.cn",
city: "北京",
age: 18,
}
fmt.Printf("p6=%#v\n", p6) //p6=&main.person{name:"pprof.cn", city:"北京", age:18}
当某些字段没有初始值的时候，该字段可以不写。此时，没有指定初始值的字段的值就是该字段类型的零值。
city: "北京",
}
fmt.Printf("p7=%#v\n", p7) //p7=&main.person{name:"", city:"北京", age:0}
初始化结构体的时候可以简写，也就是初始化的时候不写键，直接写值：
"pprof.cn",
"北京",
18,
}
fmt.Printf("p8=%#v\n", p8) //p8=&main.person{name:"pprof.cn", city:"北京", age:18}
2.初始值的填充顺序必须与字段在结构体中的声明顺序一致。
3.该方式不能和键值初始化方式混用。
a int8
b int8
c int8
d int8
}
n := test{
1, 2, 3, 4,
}
fmt.Printf("n.a %p\n", &n.a)
fmt.Printf("n.b %p\n", &n.b)
fmt.Printf("n.c %p\n", &n.c)
fmt.Printf("n.d %p\n", &n.d)
n.b 0xc0000a0061
n.c 0xc0000a0062
n.d 0xc0000a0063
Go语言的结构体没有构造函数，我们可以自己实现。 例如，下方的代码就实现了一个person的构造函数。 因为struct是值类型，如果结构体比较复杂的话，值拷贝性能开销会比较大，所以该构造函数返回的是结构体指针类型。
func newPerson(name, city string, age int8) *person {
return &person{
name: name,
city: city,
age: age,
}
}
p9 := newPerson("pprof.cn", "测试", 90)
fmt.Printf("%#v\n", p9)
Go语言中的方法（Method）是一种作用于特定类型变量的函数。这种特定类型变量叫做接收者（Receiver）。接收者的概念就类似于其他语言中的this或者 self。
func (接收者变量 接收者类型) 方法名(参数列表) (返回参数) {
函数体
}
1.接收者变量：接收者中的参数变量名在命名时，官方建议使用接收者类型名的第一个小写字母，而不是self、this之类的命名。例如，Person类型的接收者变量应该命名为 p，Connector类型的接收者变量应该命名为c等。
2.接收者类型：接收者类型和参数类似，可以是指针类型和非指针类型。
3.方法名、参数列表、返回参数：具体格式与函数定义相同。
type Person struct {
name string
age int8
}
//NewPerson 构造函数
func NewPerson(name string, age int8) *Person {
return &Person{
name: name,
age: age,
}
}
//Dream Person做梦的方法
func (p Person) Dream() {
fmt.Printf("%s的梦想是学好Go语言！\n", p.name)
}
func main() {
p1 := NewPerson("测试", 25)
p1.Dream()
}
方法与函数的区别是，函数不属于任何类型，方法属于特定的类型。
指针类型的接收者由一个结构体的指针组成，由于指针的特性，调用方法时修改接收者指针的任意成员变量，在方法结束后，修改都是有效的。这种方式就十分接近于其他语言中面向对象中的this或者self。 例如我们为Person添加一个SetAge方法，来修改实例变量的年龄。
// 使用指针接收者
func (p *Person) SetAge(newAge int8) {
p.age = newAge
}
p1 := NewPerson("测试", 25)
fmt.Println(p1.age) // 25
p1.SetAge(30)
fmt.Println(p1.age) // 30
}
当方法作用于值类型接收者时，Go语言会在代码运行时将接收者的值复制一份。在值类型接收者的方法中可以获取接收者的成员值，但修改操作只是针对副本，无法修改接收者变量本身。
// 使用值接收者
func (p Person) SetAge2(newAge int8) {
p.age = newAge
}
func main() {
p1 := NewPerson("测试", 25)
p1.Dream()
fmt.Println(p1.age) // 25
p1.SetAge2(30) // (*p1).SetAge2(30)
fmt.Println(p1.age) // 25
}
2.接收者是拷贝代价比较大的大对象
3.保证一致性，如果有某个方法使用了指针接收者，那么其他的方法也应该使用指针接收者。
在Go语言中，接收者的类型可以是任何类型，不仅仅是结构体，任何类型都可以拥有方法。 举个例子，我们基于内置的int类型使用type关键字可以定义新的自定义类型，然后为我们的自定义类型添加方法。
type MyInt int
//SayHello 为MyInt添加一个SayHello的方法
func (m MyInt) SayHello() {
fmt.Println("Hello, 我是一个int。")
}
func main() {
var m1 MyInt
m1.SayHello() //Hello, 我是一个int。
m1 = 100
fmt.Printf("%#v %T\n", m1, m1) //100 main.MyInt
}
注意事项： 非本地类型不能定义方法，也就是说我们不能给别的包的类型定义方法。
结构体允许其成员字段在声明时没有字段名而只有类型，这种没有名字的字段就称为匿名字段。
type Person struct {
string
int
}
func main() {
p1 := Person{
"pprof.cn",
18,
}
fmt.Printf("%#v\n", p1) //main.Person{string:"pprof.cn", int:18}
fmt.Println(p1.string, p1.int) //pprof.cn 18
}
匿名字段默认采用类型名作为字段名，结构体要求字段名称必须唯一，因此一个结构体中同种类型的匿名字段只能有一个。
type Address struct {
Province string
City string
}
//User 用户结构体
type User struct {
Name string
Gender string
Address Address
}
func main() {
user1 := User{
Name: "pprof",
Gender: "女",
Address: Address{
Province: "黑龙江",
City: "哈尔滨",
},
}
fmt.Printf("user1=%#v\n", user1)//user1=main.User{Name:"pprof", Gender:"女", Address:main.Address{Province:"黑龙江", City:"哈尔滨"}}
}
type Address struct {
Province string
City string
}
//User 用户结构体
type User struct {
Name string
Gender string
Address //匿名结构体
}
func main() {
var user2 User
user2.Name = "pprof"
user2.Gender = "女"
user2.Address.Province = "黑龙江" //通过匿名结构体.字段名访问
user2.City = "哈尔滨" //直接访问匿名结构体的字段名
fmt.Printf("user2=%#v\n", user2) //user2=main.User{Name:"pprof", Gender:"女", Address:main.Address{Province:"黑龙江", City:"哈尔滨"}}
}
当访问结构体成员时会先在结构体中查找该字段，找不到再去匿名结构体中查找。
嵌套结构体内部可能存在相同的字段名。这个时候为了避免歧义需要指定具体的内嵌结构体的字段。
type Address struct {
Province string
City string
CreateTime string
}
//Email 邮箱结构体
type Email struct {
Account string
CreateTime string
}
//User 用户结构体
type User struct {
Name string
Gender string
Address
}
func main() {
var user3 User
user3.Name = "pprof"
user3.Gender = "女"
// user3.CreateTime = "2019" //ambiguous selector user3.CreateTime
user3.Address.CreateTime = "2000" //指定Address结构体中的CreateTime
user3.Email.CreateTime = "2000" //指定Email结构体中的CreateTime
}
Go语言中使用结构体也可以实现其他编程语言中面向对象的继承。
type Animal struct {
name string
}
func (a *Animal) move() {
fmt.Printf("%s会动！\n", a.name)
}
//Dog 狗
type Dog struct {
Feet int8
*Animal //通过嵌套匿名结构体实现继承
}
func (d *Dog) wang() {
fmt.Printf("%s会汪汪汪~\n", d.name)
}
func main() {
d1 := &Dog{
Feet: 4,
Animal: &Animal{ //注意嵌套的是结构体指针
name: "乐乐",
},
}
d1.wang() //乐乐会汪汪汪~
d1.move() //乐乐会动！
}
结构体中字段大写开头表示可公开访问，小写表示私有（仅在定义当前结构体的包中可访问）。
JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。易于人阅读和编写。同时也易于机器解析和生成。JSON键值对是用来保存JS对象的一种方式，键/值对组合中的键名写在前面并用双引号""包裹，使用冒号:分隔，然后紧接着值；多个键值之间使用英文,分隔。
type Student struct {
ID int
Gender string
Name string
}
//Class 班级
type Class struct {
Title string
Students []*Student
}
func main() {
c := &Class{
Title: "101",
Students: make([]*Student, 0, 200),
}
for i := 0; i < 10; i++ {
stu := &Student{
Name: fmt.Sprintf("stu%02d", i),
Gender: "男",
ID: i,
}
c.Students = append(c.Students, stu)
}
//JSON序列化：结构体-->JSON格式的字符串
data, err := json.Marshal(c)
if err != nil {
fmt.Println("json marshal failed")
return
}
fmt.Printf("json:%s\n", data)
//JSON反序列化：JSON格式的字符串-->结构体
str := `{"Title":"101","Students":[{"ID":0,"Gender":"男","Name":"stu00"},{"ID":1,"Gender":"男","Name":"stu01"},{"ID":2,"Gender":"男","Name":"stu02"},{"ID":3,"Gender":"男","Name":"stu03"},{"ID":4,"Gender":"男","Name":"stu04"},{"ID":5,"Gender":"男","Name":"stu05"},{"ID":6,"Gender":"男","Name":"stu06"},{"ID":7,"Gender":"男","Name":"stu07"},{"ID":8,"Gender":"男","Name":"stu08"},{"ID":9,"Gender":"男","Name":"stu09"}]}`
c1 := &Class{}
err = json.Unmarshal([]byte(str), c1)
if err != nil {
fmt.Println("json unmarshal failed!")
return
}
fmt.Printf("%#v\n", c1)
}
Tag是结构体的元信息，可以在运行的时候通过反射的机制读取出来。
Tag在结构体字段的后方定义，由一对反引号包裹起来，具体的格式如下：
结构体标签由一个或多个键值对组成。键与值使用冒号分隔，值用双引号括起来。键值对之间使用一个空格分隔。 注意事项： 为结构体编写Tag时，必须严格遵守键值对的规则。结构体标签的解析代码的容错能力很差，一旦格式写错，编译和运行时都不会提示任何错误，通过反射也无法正确取值。例如不要在key和value之间添加空格。
例如我们为Student结构体的每个字段定义json序列化时使用的Tag：
type Student struct {
ID int `json:"id"` //通过指定tag实现json序列化该字段时的key
Gender string //json序列化是默认使用字段名作为key
name string //私有不能被json包访问
}
func main() {
s1 := Student{
ID: 1,
Gender: "女",
name: "pprof",
}
data, err := json.Marshal(s1)
if err != nil {
fmt.Println("json marshal failed!")
return
}
fmt.Printf("json str:%s\n", data) //json str:{"id":1,"Gender":"女"}
}
类型别名规定：TypeAlias只是Type的别名，本质上TypeAlias与Type是同一个类型
我们之前见过的rune和byte就是类型别名，他们的定义如下：
type rune = int32
类型别名与类型定义表面上看只有一个等号的差异，我们通过下面的这段代码来理解它们之间的区别。
type NewInt int
//类型别名
type MyInt = int
func main() {
var a NewInt
var b MyInt
fmt.Printf("type of a:%T\n", a) //type of a:main.NewInt
fmt.Printf("type of b:%T\n", b) //type of b:int
}
结果显示a的类型是main.NewInt，表示main包下定义的NewInt类型。b的类型是int。MyInt类型只会在代码中存在，编译完成时并不会有MyInt类型。
for i, n := 0, length(s); i < n; i++ { // 避免多次调用 length 函数。
println(i, s[i])
}
Golang range类似迭代器操作，返回 (索引, 值) 或 (键, 值)。
for 循环的 range 格式可以对 slice、map、数组、字符串等进行迭代循环。格式如下：
for key, value := range oldMap {
newMap[key] = value
}
// 忽略 index。
for _, c := range s {
println(c)
}
fallthrough（穿透）会强制执行后面的case语句，不管下一条表达式的结果是否为true
2. 这些调用直到 return 前才被执。因此，可以用来做资源清理。
3. 多个defer语句，按先进后出的方式执行。
4. defer语句中的变量，在defer声明时就决定了。
2. 锁资源释放
3. 数据库连接释放
Go 语言拥有一些不需要进行导入操作就可以使用的内置函数。它们有时可以针对不同的类型进行操作，例如：len、cap 和 append，或必须用于系统级的操作，例如：panic。因此，它们需要直接获得编译器的支持。
append -- 用来追加元素到数组、slice中,返回修改后的数组、slice
close -- 主要用来关闭channel
delete -- 从map中删除key对应的value
panic -- 停止常规的goroutine （panic和recover：用来做错误处理）
recover -- 允许程序定义goroutine的panic动作
imag -- 返回complex的实部 （complex、real imag：用于创建和操作复数）
real -- 返回complex的虚部
make -- 用来分配内存，返回Type本身(只能应用于slice, map, channel)
new -- 用来分配内存，主要用来分配值类型，比如int、struct。返回指向Type的指针
cap -- capacity是容量的意思，用于返回某个类型的最大容量（只能用于切片和 map）
copy -- 用于复制和连接slice，返回复制的数目
len -- 来求长度，比如string、array、slice、map、channel ，返回长度
print、println -- 底层打印函数，在部署环境中建议使用 fmt 包
Go强制要求使用显式类型转换。所以语法更能确定语句及表达式的明确含义
转换的时候如果大的转给小的，会有精度损失（数据溢出）比如int64转int8
// 将v转成T类型，但是v本身的数据类型并不会改变，只是把v变量的值类型转成T
var a int32 = 1999999 // 小转大一样要显示转换
var b float64 = float64(a) // a转b a本身数据类型并不会改变，只是把a的值(1999999)转成了float64
Sprintf和printf的区别：printf是将一个格式化的字符串打印到控制台，Sprintf是转换为字符串
上述的参数列表：多个参数以逗号分隔，个数必须与格式化样式中的个数一一对应，否则运行时会报错。
fmt.Printf("str的类型： %T\t 值：%v\n ", str, str)
fmt.Printf("str的类型： %T\t 值：%v\n ", str, str)
fmt.Printf("str的类型： %T\t 值：%v\n ", str, str)
fmt.Printf("str的类型： %T\t 值：%v\n ", str, str)
str = strconv.FormatInt(int64(num), 10)
fmt.Printf("str的类型： %T\t 值：%v\n ", str, str)
// strconv.FormatInt也可以用来转换进制，比如将10进制转换为2进制，其它进制，换掉后面的数字就可以了
str = strconv.FormatInt(123, 2)
fmt.Printf("str的类型： %T\t 值：%v\n ", str, str)
str = strconv.FormatFloat(num2, 'f', 10, 64)
fmt.Printf("str的类型： %T\t 值：%v\n ", str, str)
str = strconv.FormatBool(false)
fmt.Printf("str的类型： %T\t 值：%v\n ", str, str)
fmt.Printf("str的类型： %T\t 值：%v\n ", str, str)
将string类型转换成基本数据类型时，要确保string类型能够转成有有效的数据
例：可以把"123"转成int类型，但是不可以将"aaa"转成int类型，编译器不会报错，go会把它变成默认值0，因为go会判断这个值能不能转成有效的数据，如果不可以会按照该数据的数据类型的默认值赋值。
i, _ = strconv.ParseInt(str, 10, 64)
fmt.Printf("i的类型： %T\t 值：%v\n ", i, i)
f, _ = strconv.ParseFloat(str, 64)
fmt.Printf("f的类型： %T\t 值：%v\n ", f, f)
fmt.Printf("b的类型： %T\t 值：%v\n ", b, b)
fmt.Printf("s的类型： %T\t 值：%v\n ", s, s)
如name.(string) 将interface{}类型的name转换成string
fmt.Println(daName.(string))
注：若不确定interface类型时候，使用变量名.(type)结合switch case来做判断。
case string:
// 将interface转为string字符串类型
op, ok := value.(string)
fmt.Println(op, ok)
case int32:
// 将interface转为int32类型
op, ok := value.(int32)
fmt.Println(op, ok)
case int64:
// 将interface转为int64类型
op, ok := value.(int64)
fmt.Println(op, ok)
case User:
// 将interface转为User struct类型，并使用其Name对象
op, ok := value.(User)
fmt.Println(op.Name, ok)
case []int:
// 将interface转为切片类型
op := make([]int, 0) //[]
op = value.([]int)
fmt.Println(op)
default:
fmt.Println("unknown")
}
var str = string([]byte{97, 98, 99})
输出：b = [105 116 122 104 117 122 104 117]
byte类型的切片（[]byte）与string可以相互转换：
fmt.Printf("bslice的类型是: %T，值是：%v", bslice,bslice) //得到
fmt.Printf("type:%T value:%#v\n", str, str)
func Atoi(s string) (i int, err error)
num1, err := strconv.Atoi(str1)
fmt.Printf("type:%T value:%#v\n", num1, num1)
num2, err := strconv.Atoi(str2)
fmt.Printf("type:%T value:%#v\n", num2, num2)
Parse 系列函数用于将字符串转换为指定类型的值，其中包括 ParseBool()、ParseFloat()、ParseInt()、ParseUint()。
1) ParseBool() 函数用于将字符串转换为 bool 类型的值，它只能接受 1、0、t、f、T、F、true、false、True、False、TRUE、FALSE，其它的值均返回错误，函数签名如下。
func ParseBool(str string) (value bool, err error)
ParseInt() 函数用于返回字符串表示的整数值（可以包含正负号），函数签名如下：
func ParseInt(s string, base int, bitSize int) (i int64, err error)
base 指定进制，取值范围是 2 到 36。如果 base 为 0，则会从字符串前置判断，“0x”是 16 进制，“0”是 8 进制，否则是 10 进制。
bitSize 指定结果必须能无溢出赋值的整数类型，0、8、16、32、64 分别代表 int、int8、int16、int32、int64。
返回的 err 是 *NumErr 类型的，如果语法有误，err.Error = ErrSyntax，如果结果超出类型范围 err.Error = ErrRange。
Print 和 Println：用于将数据输出到标准输出（通常是终端）。
Printf：用于将格式化的数据输出到标准输出。它使用类似 C 语言的格式化字符串，可以通过占位符指定输出数据的格式和位置。
11.2 Sprint、Sprintln 和 Sprintf
Sprint、Sprintln 和 Sprintf 是 Go 语言 fmt 包提供的函数，用于将格式化的数据转换为字符串。
这些函数的命名类似于 Print、Println 和 Printf 函数，但是它们不是将数据输出到标准输出，而是将数据格式化为字符串并返回。
Sprint 函数将传入的数据格式化为字符串，并返回该字符串。它接受可变数量的参数，并按照指定的格式进行格式化。
Sprintln 函数与 Sprint 函数类似，但在每个参数之间会添加一个空格，并在最后添加一个换行符（\n）。
Sprintf 函数根据指定的格式将传入的数据格式化为字符串，并返回该字符串。它接受一个格式化字符串作为第一个参数，然后根据该格式化字符串和后续的参数进行格式化。
var info1 = fmt.Sprint("Name:", name, ", Age:", age, ", Height:", height)
var info2 = fmt.Sprintln("Name:", name, ", Age:", age, ", Height:", height)
var info3 = fmt.Sprintf("Name: %s, Age: %d, Height: %.2f", name, age, height)
Fprint、Fprintln 和 Fprintf 是 Go 语言 fmt 包提供的函数，用于将格式化的数据输出到指定的 io.Writer。
这些函数与 Print、Println 和 Printf 函数类似，但是它们不是将数据输出到标准输出，而是将数据格式化后输出到指定的 io.Writer，例如文件、网络连接等。
· Fprint 函数将传入的数据格式化为字符串，并将结果输出到指定的 io.Writer。它接受一个 io.Writer 类型的参数作为第一个参数，后面可以跟上可变数量的参数。
· Fprintln 函数与 Fprint 函数类似，但在每个参数之间会添加一个空格，并在最后添加一个换行符（\n）。
· Fprintf 函数根据指定的格式将传入的数据格式化为字符串，并将结果输出到指定的 io.Writer。它接受一个 io.Writer 类型的参数作为第一个参数，后面跟着一个格式化字符串和后续的参数。
%#v：获取数据的值，如果是结构体，会携带结构体名和字段名。
%s 输出以原生的UTF8字节表示的字符，如果console不支持utf8编码，则会乱码
%v 使用默认格式输出值，或者如果方法存在，则使用类性值的String()方法输出自定义值
fmt.Printf("%c", 0x82d7)// 输出苗
fmt.Printf("%d,%d,%d", 10, 010, 0x10)// 输出10,8,16
三个数据： 10 十进制，010 八进制，0x10 十六进制
%q 同 %c 类似，都是Unicode 码转字符，只是结果多了单引号。
fmt.Printf("%q", 0x82d7)// 输出'苗'
汉字对应表：字体编辑用中日韩汉字Unicode编码表 - 编著：资深中韩翻译金圣镇 金圣镇
%x、%#x 十六进制表示，字母形式为小写 a-f，%#x 输出带 0x 开头。
fmt.Printf("%x, %#x", 13, 13)// 输出d, 0xd
%X、%#X十六进制表示，字母形式为小写 A-F，%#X 输出带 0X 开头。
fmt.Printf("%X, %#X", 13, 13)// 输出D, 0XD
fmt.Printf("%U", 0x82d7)// 输出U+82D7
fmt.Printf("%#U", 0x82d7)// 输出U+82D7 '苗'
fmt.Printf("%b", 0.1)// 输出7205759403792794p-56
浮点数，%.2f 表示保留 2 位小数，%f 默认保留 6 位，%f 与 %F 等价。
保留的规则我现在还没有搞清楚，有时候符合四舍五入，有时候不符合，容我下来研究下，再告诉大家。
fmt.Printf("%f", 10.2)// 输出10.200000
fmt.Printf("%.2f|%.2f", 10.232, 10.235)// 输出10.23|10.23
fmt.Printf("%q", "老苗")// 输出"老苗"
指针%p、%#p ：地址，使用十六进制表示，%p 带 0x，%#p 不带。
num := 2s := []int{1, 2}fmt.Printf("%p|%p", &num, s)
// 输出0xc00000a1d0|0xc00000a1e0
对切片进行排序(string类型的切片): sort.Strings(slice)
var slice = []string{"a", "f", "d"}
sort.Strings(slice)
fmt.Println(slice) //[a d f]
判断字符串是否以prefix开头：strings.HasPrefix(str, "he")
s := "hello world hello world"
//判断字符串s是否以prefix开头
ret := strings.HasPrefix(s, "he")
fmt.Println(ret)
![蓝桥杯[OJ 1621]挑选子串-CPP-双指针](https://img-blog.csdnimg.cn/direct/00c28d4bf0a045b9a67958f18ce37e78.png)
