Array

和其他语言的数组不同。

数组是值类型，赋值和传参会复制整个数组，而不是指针。
数组长度必须是常量，且是类型的组成部分。2[int] 和 3[int] 是不同类型。
支持 ==、!= 操作符，因为内存总是被初始化过。
指针数组 [n]*T、数组指针 *[n]T

初始化

a := [3]int{1, 2} // 未初始化元素值为 0
b := [...]int{1, 2, 3, 4} // 通过初始化确定数组长度

值拷贝会造成性能问题，通常会使用 slice，或数组指针。

len、cap

返回数组的长度与容量。

a := [2]int{}
println(len(a), cap(a)) // 2, 2

Slice

既然数组是值类型无法方便地传递给函数，肯定提供了方便的指针类型。

slice 并不是数组或数组指针，内部通过指针和相关属性引用数组片段，以实现变长方案。

slice 本质上是一个指向底层数组的结构体。

struct Slice 
{
    byte* array; // actual data
    uintgo len; // number of elements
    uintgo cap; // allocated number of elements
}

引用类型。但自身是结构体，值拷贝传递。
每部分只有 8 个字节，长度永远不会超过 24 字节，在使用时不需要传递 silce 的地址，直接使用值传递。
属性 len 表示可用元素数量，读写操作不能超过该限制。
属性 cap 表⽰最⼤扩张容量，不能超出数组限制。
如果 slice == nil，那么 len、cap 结果都等于 0。

data := [...]int{0, 1, 2, 3, 4, 5, 6}
// len = high - low
// cap = max - low
slice := data[1:4:5] // [low : high : max]

slice 读写操作实际目标是底层数组，需要注意索引号的区别。

创建

直接创建 slice 对象，自动分配底层数组。

// 索引位置 8 的值为 100
s1 := []int{0, 1, 2, 8:100} // 通过初始化表达式构造，创建时可使用索引号
fmt.Println(s1, len(s1), cap(s1))

s2 := make([]int, 6, 8) // 使用 make 创建，指定 len 和 cap 值
fmt.Println(s2, len(s2), cap(s2))

s3 := make([]int, 6) // 省略 cap，相当于 cap = len。
fmt.Println(s3, len(s3), cap(s3))

输出

[0 1 2 3 0 0 0 0 100] 9 9
[0 0 0 0 0 0] 6 8
[0 0 0 0 0 0] 6 6

使用 make 动态创建 slice，避免数组必须用常量做长度的麻烦。还可以用指针直接访问底层数组，变成普通数组操作。

s := []int{0, 1, 2, 3}
p := &s[2] // *int 获取底层数组元素指针

fmt.Println(s) // [0 1 102 3]

[][]T，是指元素类型为 []T。

reslice

基于现有 slice 对象创建新 slcie 对象，以便在 cap 允许范围内调整属性。

新对象依旧指向原底层数组

s := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
s1 := s[2:5] // [2 3 4]
s2 := s1[2:6:7] // [4 5 6 7]
s3 := s2[3:6] // Error

append

append 向 slice 尾部添加数据，返回新的 slice 对象。简单说就是在 array[slice.high] 后面写数据，会修改底层数组的值。

data := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
s := data[:3]

s2 := append(s, 100, 200) // 添加多个值。
s3 := append(s2, s...) // ... 解构赋值，相当于把 silce 展开

fmt.Println(data)
fmt.Println(s)
fmt.Println(s2)
fmt.Println(s3)

输出

[0 1 2 100 200 0 1 2 8 9]
[0 1 2]
[0 1 2 100 200]
[0 1 2 100 200 0 1 2]

追加后的容量一旦超过 slice.cap 的限制，会重新分配底层数组，即便原数组并未填满。

通常以 2 倍容量重新分配底层数组。在⼤批量添加数据时，建议⼀次性分配⾜够⼤的空间，以减少内存分配和数据复制开销。或初始化⾜够⻓的 len 属性，改⽤索引号进⾏操作。及时释放不再使⽤的 slice 对象，避免持有过期数组，造成 GC ⽆法回收。

remove

官方并没有 remove 的相关接口，可以使用 append 变相实现该接口。

// 删除第五个元素
index := 5
s := append(s[:index], s[index + 1:]...)

insert

官方也没有往指定位置插入元素的接口，依旧可以使用 append 实现。

temp := append([]string{}, s[index:]...)
s = append(s[:index], "insert")
s = append(s, temp...)

copy

函数 copy 在两个 slice 之间复制数据，复制长度以 len 小的为准，复制较小的个数。两个 slice 允许指向同一底层数组，允许元素区间重叠。

copy(to, from)

data := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
s := data[8:] // [8, 9]
s2 := data[:5] // [0, 1, 2, 3, 4]
copy(s2, s) // 从 s 复制到 s2
fmt.Println(s2) // [8, 9, 2, 3, 4]
fmt.Println(data) // 底层数组被改变 [8, 9, 2, 3, 4, 5, 6, 7, 8, 9]

应及时将所需数据 copy 到较⼩的 slice，以便释放超⼤号底层数组内存。

Map

引用类型，Hash 表在任何语言中都有，C++ 中是 std::map<>， Java 中是 Hashamp<>，在 Go 中则内置 map 不需要引入任何库。

map 的键必须支持比较运算 == 和 !=，可以是 string、number、pointer、array、struct 等。值可以是任意类型，没有限制，取值的时候如果不存在就返回零值。

map 本质上是一个字典指针

type Map_K_V struct {
    // ...
}

type map[K]V struct {
    impl *Map_k_V
}

预先给 make 函数⼀个合理元素数量参数，有助于提升性能。因为事先申请⼀⼤块内存，可避免后续操作时频繁扩张。

m := make(map[string]int, 1000)

常见操作

m := map[string]int{
    "a": 1,
}

// 判断 key 是否存在
if v, ok := m["a"]; ok {
    println(v)
}


// 不存在的 key 返回零值
m["b"] // 0

// 新增或修改
m["b"] = 2

// 删除，如果 key 不存在不会出错
delete(map, key)

// 获取键值对数量
println(len(m))

// 迭代，随机顺序返回
// range 返回 value 的临时拷贝
for k, v := range m {
    println(k, v)
}

从 map 中取回的是一个 value 临时复制品，对其成员修改不会改变源对象。

正确的做法是完整对象替换或使用指针作为 value。

Struct

值语义，赋值和传参会复制全部内容。可⽤ "_" 定义补位字段，支持指向自身类型的指针成员。

支持 ==、!= 操作符。

type Node struct {
    _ int
    id int
    data *byte
    next *Node
}

type User struct {
    id int
    name string
}

user1 := User{1, "Tom"}
user2 := User{1, "Tom"}

fmt.Println(user1 == user2) // true

空结构 "节省" 内存，⽐如⽤来实现 set 数据结构，或者实现没有 "状态" 只有⽅法的 "静态类"。

var null struct{}

set := make(map[string]struct{})
set["a"] = null

匿名字段

匿名字段本质上是一种语法糖，只是一个与成员类型同名，且不包含包名的字段。被匿名嵌入的可以是任何类型，也包括指针。

type User struct {
    name string
}

type Manager struct {
    User // 匿名字段
    title string
}

m := Manager{
    User: User{"Tom"}, // 匿名字段的显式字段名，和类型名相同。
    title: "Administrator",
}

m.name = "jack" // 访问匿名字段成员

可以像访问普通字段一样访问匿名字段成员，编译器从外向内逐级查找所有层次的匿名字段，直到发现目标或出错。

外层同名字段会遮蔽嵌⼊字段成员，相同层次的同名字段也会让编译器⽆所适从。解决⽅法是使⽤显式字段名。

本质上就是不能有歧义，不能同时找到两个，而不知道使用哪一个。

面向对象

面向对象三大特征里，Go 仅支持封装，尽管匿名字段的内存布局和行为类似继承。没有 class 关键字，没有继承、多态等等。

内存布局和 C struct 相同，没有任何附加的 object 信息。

type User struct {
    id int
    name string
}

type Manager struct {
    User
    title string
}

m := Manager{User{1, "Tom"}, "Administrator"}

// var u User = m // Error: cannot use m (type Manager) as type User in assignment. 没有继承自然没有多态

var u User = m.User // 同类型拷贝

内存布局

    |<-------- User:24 ------->|<-- title:16 -->|
    +-------------+------------+----------------+              +---------------+
 m  |      1      |    string  |     string     |              | Administrator | [n]byte 
    +-------------+------------+----------------+              +---------------+
                        |               |                              |
                        |               +--->>>------------->>>--------+
                        |
                        +--->>>----------------------------------------+
                                                                       |
                        +--->>>-------------------------------------+  |
                        |                                           |  |
    +-------------+------------+                                 +-------------+
 u  |     1       |    string  |                                 |    Tom      |  [n]byte
    +-------------+------------+                                 +-------------+                                  |<-   id:8  ->|<- name:16->|

小礼物走一走，来简书关注我

作者：流年1004
链接：https://www.jianshu.com/p/b9b83cdf3094
來源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。

posted on 2018-08-20 17:20 彬彬在线阅读(119) 评论(0) 编辑收藏举报

刷新页面返回顶部

彬彬博客园

公告