Go:学习笔记兼吐槽(3)
数组
golang 中,数组是值类型。
数组的声明
var arr [10]int
数组的初始化
var arr1 [3]int = [3]int{1, 2, 3}
var arr2 = [3]int{4, 5, 6}
var arr3 = [...]int{7, 8, 9}
var arr4 = [...]int{1: 100, 2: 200, 3: 300}
用 for-range 遍历数组
基本语法:
for index, value := range 数组变量{
}
其中:index
为数组下标,value
是该下标位置的值。
长度是数组类型的一部分
长度是数组类型的一部分,就是说数组不可以脱离长度而存在。听起来不太明白,我们来看下面的一个示例就明白了,这真的是一个大坑。
假设,我们现在要写一个排序函数,c# 中,我们会这样定义:
public void sort(int[] array)
{
}
但是,在 golang 中,这是不行的。
func main() {
var arr [3]int = [3]int{1, 2, 3}
sort(arr)
}
func sort(array []int){
}
sort(arr)
这句编译就会报错:cannot use arr (type [3]int) as type []int in argument to sort。因为 sort
函数的参数 array []int
是一个切片,不是数组,将数组作为参数传给 sort
就会报类型不匹配。
如果一定需要以数组作为参数传递,sort
的参数必须定义成数组,就是带上长度:
func sort(array [3]int){
}
这么定义这函数还有啥用?吐槽一万字…
虽然有切片可以用来实现我们的功能,但是,数组就变得有点鸡肋了。
切片 slice
切片是引用类型,类似于 c# 中的 list
。内部维护一个数组,当追加元素超出切片容量时,切片自动扩容。(跟 list
是一样的机制。)
切片的声明
var arr []int
切片的使用
//方法一:
var arr1 [5]int = [5]int{1, 2, 3, 4, 5}
slice1 := arr1[1: 3] //这里的使用跟 python 很像
//方法二:
var slice2 []int = make([]int, 5, 10)
//方法三:
var slice3 []int = []int{1, 2, 3, 4, 5}
使用 make
初始化切片,make
的三个参数依次为:切片数据类型,切片长度,切片容量。
给切片追加元素
//方法一:追加一个或多个同类型
var slice1 []int = make([]int, 5, 10)
slice1 = append(slice1, 100, 200)
fmt.printf("%v\n", slice1)
//方法二:追加切片(只能是切片,不可以是数组)
var slice2 []int = []int{1, 2, 3, 4, 5}
slice1 = append(slice1, slice2...) // 三个点不能少
fmt.printf("%v", slice1)
append
函数也很搞笑,其返回值必须赋值给一个切片,否则编译都过不了。如果一个切片调用append
追加元素后,又赋值给了自己(我们一般也是这么用的),则切片的地址不会发生改变(除非发生了扩容)。如果 切片 1 调用append
后赋值给了 切片 2,则 切片 1 保持未追加前的原样不变,另生成一个新的切片赋给 切片 2。
示例:
var slice1 []int = make([]int, 5, 10)
fmt.printf("%v %p\n", slice1, &slice1) // [0 0 0 0 0] 0xc000004460
slice1 = append(slice1, 100)
fmt.printf("%v %p\n", slice1, &slice1) // [0 0 0 0 0 100] 0xc000004460
slice2 := append(slice1, 200)
fmt.printf("%v %p\n", slice1, &slice1) // [0 0 0 0 0 100] 0xc000004460
fmt.printf("%v %p\n", slice2, &slice2) // [0 0 0 0 0 100 200] 0xc0000044e0
映射 map
就是字典。
map 的声明
var m map[int]string
map 的使用
// 方式一:使用 make 函数
m := make(map[int]string, 10)
// 方式二:直接赋值
m := map[int]string{
1: "张三",
2: "李四",
}
make
方法的第一个参数是 map 的数据类型,第二个参数是初始容量。
注意,如果是方式二直接赋值,最后一个 key-value 后面也要加逗号。
删除元素
delete(map, key)
参数:
- map:要删除元素的 map
- key:要删除的 key,当 key 在 map 中不存在时,不进行任何操作,也不报错。
golang 中 map 没有类似其他语言中的 clear
方法,如果要一次性删除全部元素,可遍历 map 逐一删除,或者重新 make
一下使其指向一个新的内存空间。
查找元素
val, finded := m[1]
if finded{
fmt.println(val)
}
遍历元素
只能用 for-range 遍历
for k, v := range m{
fmt.printf("%v: %v\n", k, v)
}
结构体 struct
- golang 中没有类(class),go 中的结构体(struct)和其他语言中的类有同等的地位。可以理解为 golang 是基于 struct 来实现面向对象。
- golang 中面向对象编程非常简洁,去掉了传统 oop 语言中的继承、方法重载、构造函数、析构函数、隐藏的 this 指针等等。
- golang 仍然有面向对象编程的封装、继承、多态的特性,只是实现方式和其他 oop 语言不一样。
- 结构体是值类型。结构体的所有字段在内存中是连续的。
结构体的声明
type 结构体名称 struct{
field1 type
field2 type
}
p1 := person{}
p1.name = "tom"
p1.age = 10
// 或者
p2 := person{"jerry", 5}
结构体的使用
type person struct{
name string
age int
}
结构体指针
// 方式一:
var person1 *person = new(person)
(*person1).name = "tom"
(*person1).age = 10
fmt.println(*person1)
// 方式二:
person2 := new(person)
person2.name = "tom"
person2.age = 10
fmt.println(*person2)
// 方式三:
var person3 *person = &person{"jerry", 5}
fmt.println(*person3)
这三种方式定义的都是结构体指针,因为是指针,所以给字段赋值的标准方式应该是方式一的写法,但是 go 的设计者为了程序员使用方便,给出了一个语法糖,使 (*person1).name = "tom"
简化为 person1.name = "tom"
,即方式二的写法,编译时,会自动加上取值运算。而方式三的写法可以直接赋值。
结构体标签
struct 的每个字段上可以定义一个标签(tag),该标签可以通过反射机制获取,最常见的使用场景就是序列化和反序列化。
type person struct{
name string `json:"name"`
age int `json:"age"`
}
p := person{"张三", 30}
jsonstr, err := json.marshal(p)
if err == nil {
fmt.println(string(jsonstr)) // {"name":"张三","age":30}
}
上一篇: 赵匡胤为什么不传位给赵德芳?原因是什么
下一篇: kubernetes系列10—存储卷详解