Golang的切片学习

感谢参考原文-http://bjbsair.com/2020-03-27/tech-info/7060.html
因为数组的长度是固定的并且数组长度属于类型的一部分，所以数组有很多的局限性。例如：

func arraySum(x [3]int) int{  
    sum := 0  
    for _, v := range x{  
        sum = sum + v  
    }  
    return sum  
}

这个求和函数只能接受 [3]int 类型，其他的都不支持。再比如，

a := [3]int{1, 2, 3}

数组a中已经有三个元素了，我们就不能再继续往数组a中添加新元素。

切片

切片（Slice）是一个拥有相同类型元素的可变长度的序列。它是基于数组类型做的一层封装。它非常灵活，支持自动扩容。

切片是一个引用类型，它的内部结构包含地址、长度和容量。切片一般用于快速地操作一块数据集合。

切片的定义

声明切片类型的基本语法如下：

var name []T

其中，

name:表示变量名
T:表示切片中的元素类型
举个例子：

func main() {  
    // 声明切片类型  
    var a []string              //声明一个字符串切片  
    var b = []int{}             //声明一个整型切片并初始化  
    var c = []bool{false, true} //声明一个布尔切片并初始化  
    var d = []bool{false, true} //声明一个布尔切片并初始化  
    fmt.Println(a)              //[]  
    fmt.Println(b)              //[]  
    fmt.Println(c)              //[false true]  
    fmt.Println(a == nil)       //true  
    fmt.Println(b == nil)       //false  
    fmt.Println(c == nil)       //false  
    // fmt.Println(c == d)   //切片是引用类型，不支持直接比较，只能和nil比较  
}

切片的长度和容量

切片拥有自己的长度和容量，我们可以通过使用内置的len()函数求长度，使用内置的cap()函数求切片的容量。

基于数组定义切片

由于切片的底层就是一个数组，所以我们可以基于数组定义切片。

func main() {  
    // 基于数组定义切片  
    a := [5]int{55, 56, 57, 58, 59}  
    b := a[1:4]                     //基于数组a创建切片，包括元素a[1],a[2],a[3]  
    fmt.Println(b)                  //[56 57 58]  
    fmt.Printf("type of b:%T\n", b) //type of b:[]int  
}

还支持如下方式：

c := a[1:] //[56 57 58 59]  
d := a[:4] //[55 56 57 58]  
e := a[:]  //[55 56 57 58 59]

切片再切片

除了基于数组得到切片，我们还可以通过切片来得到切片。

func main() {  
    //切片再切片  
    a := [...]string{"北京", "上海", "广州", "深圳", "成都", "重庆"}  
    fmt.Printf("a:%v type:%T len:%d  cap:%d\n", a, a, len(a), cap(a))  
    b := a[1:3]  
    fmt.Printf("b:%v type:%T len:%d  cap:%d\n", b, b, len(b), cap(b))  
    c := b[1:5]  
    fmt.Printf("c:%v type:%T len:%d  cap:%d\n", c, c, len(c), cap(c))  
}

输出：

a:[北京 上海 广州 深圳 成都 重庆] type:[6]string len:6  cap:6  
b:[上海 广州] type:[]string len:2  cap:5  
c:[广州 深圳 成都 重庆] type:[]string len:4  cap:4

注意：对切片进行再切片时，索引不能超过原数组的长度，否则会出现索引越界的错误。

使用make()函数构造切片

我们上面都是基于数组来创建的切片，如果需要动态的创建一个切片，我们就需要使用内置的 make() 函数，格式如下：

make([]T, size, cap)

其中：

T:切片的元素类型
size:切片中元素的数量
cap:切片的容量

举个例子：

func main() {  
    a := make([]int, 2, 10)  
    fmt.Println(a)      //[0 0]  
    fmt.Println(len(a)) //2  
    fmt.Println(cap(a)) //10  
}

上面代码中 a 的内部存储空间已经分配了10个，但实际上只用了2个。容量并不会影响当前元素的个数，所以 len(a) 返回2， cap(a) 则返回该切片的容量。

切片的本质

切片的本质就是对底层数组的封装，它包含了三个信息：底层数组的指针、切片的长度（len）和切片的容量（cap）。

举个例子，现在有一个数组 a := [8]int{0, 1, 2, 3, 4, 5, 6, 7} ，切片 s1 := a[:5] ，相应示意图如下。

Golang基础之切片

image.png

切片 s2 := a[3:6] ，相应示意图如下：

Golang基础之切片

image.png

切片不能直接比较

切片之间是不能比较的，我们不能使用 == 操作符来判断两个切片是否含有全部相等元素。切片唯一合法的比较操作是和 nil 比较。一个 nil 值的切片并没有底层数组，一个 nil 值的切片的长度和容量都是0。但是我们不能说一个长度和容量都是0的切片一定是 nil ，例如下面的示例：

var s1 []int         //len(s1)=0;cap(s1)=0;s1==nil  
s2 := []int{}        //len(s2)=0;cap(s2)=0;s2!=nil  
s3 := make([]int, 0) //len(s3)=0;cap(s3)=0;s3!=nil

所以要判断一个切片是否是空的，要是用 len(s) == 0 来判断，不应该使用 s == nil 来判断。

切片的赋值拷贝

下面的代码中演示了拷贝前后两个变量共享底层数组，对一个切片的修改会影响另一个切片的内容，这点需要特别注意。

func main() {  
    s1 := make([]int, 3) //[0 0 0]  
    s2 := s1             //将s1直接赋值给s2，s1和s2共用一个底层数组  
    s2[0] = 100  
    fmt.Println(s1) //[100 0 0]  
    fmt.Println(s2) //[100 0 0]  
      
    arra1 := [3]int{1, 2, 3}  
    arra2 := arra1  
    arra2[0] = 0  
    fmt.Println(arra1)  // [1 2 3]  
    fmt.Println(arra2)  // [0 2 3]  
      
}

切片遍历

切片的遍历方式和数组是一致的，支持索引遍历和 for range 遍历。

func main() {  
    s := []int{1, 3, 5}  
  
    for i := 0; i < len(s); i++ {  
        fmt.Println(i, s[i])  
    }  
  
    for index, value := range s {  
        fmt.Println(index, value)  
    }  
}

append()方法为切片添加元素

Go语言的内建函数 append() 可以为切片动态添加元素，每个切片会指向一个底层数组，这个数组的容量够用就添加新增元素。当底层数组不能容纳新增的元素时，切片就会自动按照一定的策略进行“扩容”，此时该切片指向的底层数组就会更换。“扩容”操作往往发生在 append() 函数调用时，所以我们通常都需要用原变量接收append函数的返回值。

举个例子：

func main() {  
    //append()添加元素和切片扩容  
    var numSlice []int  
    for i := 0; i < 10; i++ {  
        numSlice = append(numSlice, i)  
        fmt.Printf("%v  len:%d  cap:%d  ptr:%p\n", numSlice, len(numSlice), cap(numSlice), numSlice)  
    }  
}

输出：

[0]  len:1  cap:1  ptr:0xc0000a8000  
[0 1]  len:2  cap:2  ptr:0xc0000a8040  
[0 1 2]  len:3  cap:4  ptr:0xc0000b2020  
[0 1 2 3]  len:4  cap:4  ptr:0xc0000b2020  
[0 1 2 3 4]  len:5  cap:8  ptr:0xc0000b6000  
[0 1 2 3 4 5]  len:6  cap:8  ptr:0xc0000b6000  
[0 1 2 3 4 5 6]  len:7  cap:8  ptr:0xc0000b6000  
[0 1 2 3 4 5 6 7]  len:8  cap:8  ptr:0xc0000b6000  
[0 1 2 3 4 5 6 7 8]  len:9  cap:16  ptr:0xc0000b8000  
[0 1 2 3 4 5 6 7 8 9]  len:10  cap:16  ptr:0xc0000b8000

从上面的结果可以看出：

append()

append()函数还支持一次性追加多个元素。例如：

var citySlice []string  
// 追加一个元素  
citySlice = append(citySlice, "北京")  
// 追加多个元素  
citySlice = append(citySlice, "上海", "广州", "深圳")  
// 追加切片  
a := []string{"成都", "重庆"}  
citySlice = append(citySlice, a...)  
fmt.Println(citySlice) //[北京 上海 广州 深圳 成都 重庆]  
  
### 切片的扩容策略  
  
可以通过查看`$GOROOT/src/runtime/slice.go`源码，其中扩容相关代码如下：  
  
```go  
newcap := old.cap  
doublecap := newcap + newcap  
if cap > doublecap {  
    newcap = cap  
} else {  
    if old.len < 1024 {  
        newcap = doublecap  
    } else {  
        // Check 0 < newcap to detect overflow  
        // and prevent an infinite loop.  
        for 0 < newcap && newcap < cap {  
            newcap += newcap / 4  
        }  
        // Set newcap to the requested cap when  
        // the newcap calculation overflowed.  
        if newcap <= 0 {  
            newcap = cap  
        }  
    }  
}

从上面的代码可以看出以下内容：

首先判断，如果新申请容量（cap）大于2倍的旧容量（old.cap），最终容量（newcap）就是新申请的容量（cap）。
否则判断，如果旧切片的长度小于1024，则最终容量(newcap)就是旧容量(old.cap)的两倍，即（newcap=doublecap），
否则判断，如果旧切片长度大于等于1024，则最终容量（newcap）从旧容量（old.cap）开始循环增加原来的1/4，即（newcap=old.cap,for {newcap += newcap/4}）直到最终容量（newcap）大于等于新申请的容量(cap)，即（newcap >= cap）
如果最终容量（cap）计算值溢出，则最终容量（cap）就是新申请容量（cap）。

需要注意的是，切片扩容还会根据切片中元素的类型不同而做不同的处理，比如 int 和 string 类型的处理方式就不一样。

使用copy()函数复制切片

首先我们来看一个问题：

func main() {  
    a := []int{1, 2, 3, 4, 5}  
    b := a  
    fmt.Println(a) //[1 2 3 4 5]  
    fmt.Println(b) //[1 2 3 4 5]  
    b[0] = 1000  
    fmt.Println(a) //[1000 2 3 4 5]  
    fmt.Println(b) //[1000 2 3 4 5]  
}

由于切片是引用类型，所以a和b其实都指向了同一块内存地址。修改b的同时a的值也会发生变化。

Go语言内建的 copy() 函数可以迅速地将一个切片的数据复制到另外一个切片空间中， copy() 函数的使用格式如下：

copy(destSlice, srcSlice []T)

其中：

srcSlice: 数据来源切片
destSlice: 目标切片

举个例子：

func main() {  
    // copy()复制切片  
    a := []int{1, 2, 3, 4, 5}  
    c := make([]int, 5, 5)  
    copy(c, a)     //使用copy()函数将切片a中的元素复制到切片c  
    fmt.Println(a) //[1 2 3 4 5]  
    fmt.Println(c) //[1 2 3 4 5]  
    c[0] = 1000  
    fmt.Println(a) //[1 2 3 4 5]  
    fmt.Println(c) //[1000 2 3 4 5]  
}

从切片中删除元素

Go语言中并没有删除切片元素的专用方法，我们可以使用切片本身的特性来删除元素。代码如下：

func main() {  
    // 从切片中删除元素  
    a := []int{30, 31, 32, 33, 34, 35, 36, 37}  
    // 要删除索引为2的元素  
    a = append(a[:2], a[3:]...)  
    fmt.Println(a) //[30 31 33 34 35 36 37]  
}

总结一下就是：要从切片a中删除索引为 index 的元素，操作方法是 a = append(a[:index], a[index+1:]...)感谢参考原文-http://bjbsair.com/2020-03-27/tech-info/7060/
因为数组的长度是固定的并且数组长度属于类型的一部分，所以数组有很多的局限性。例如：

func arraySum(x [3]int) int{  
    sum := 0  
    for _, v := range x{  
        sum = sum + v  
    }  
    return sum  
}

这个求和函数只能接受 [3]int 类型，其他的都不支持。再比如，

a := [3]int{1, 2, 3}

数组a中已经有三个元素了，我们就不能再继续往数组a中添加新元素。

切片

切片（Slice）是一个拥有相同类型元素的可变长度的序列。它是基于数组类型做的一层封装。它非常灵活，支持自动扩容。

切片是一个引用类型，它的内部结构包含地址、长度和容量。切片一般用于快速地操作一块数据集合。

切片的定义

声明切片类型的基本语法如下：

var name []T

其中，

name:表示变量名
T:表示切片中的元素类型
举个例子：

func main() {  
    // 声明切片类型  
    var a []string              //声明一个字符串切片  
    var b = []int{}             //声明一个整型切片并初始化  
    var c = []bool{false, true} //声明一个布尔切片并初始化  
    var d = []bool{false, true} //声明一个布尔切片并初始化  
    fmt.Println(a)              //[]  
    fmt.Println(b)              //[]  
    fmt.Println(c)              //[false true]  
    fmt.Println(a == nil)       //true  
    fmt.Println(b == nil)       //false  
    fmt.Println(c == nil)       //false  
    // fmt.Println(c == d)   //切片是引用类型，不支持直接比较，只能和nil比较  
}

切片的长度和容量

切片拥有自己的长度和容量，我们可以通过使用内置的len()函数求长度，使用内置的cap()函数求切片的容量。

基于数组定义切片

由于切片的底层就是一个数组，所以我们可以基于数组定义切片。

func main() {  
    // 基于数组定义切片  
    a := [5]int{55, 56, 57, 58, 59}  
    b := a[1:4]                     //基于数组a创建切片，包括元素a[1],a[2],a[3]  
    fmt.Println(b)                  //[56 57 58]  
    fmt.Printf("type of b:%T\n", b) //type of b:[]int  
}

还支持如下方式：

c := a[1:] //[56 57 58 59]  
d := a[:4] //[55 56 57 58]  
e := a[:]  //[55 56 57 58 59]

切片再切片

除了基于数组得到切片，我们还可以通过切片来得到切片。

func main() {  
    //切片再切片  
    a := [...]string{"北京", "上海", "广州", "深圳", "成都", "重庆"}  
    fmt.Printf("a:%v type:%T len:%d  cap:%d\n", a, a, len(a), cap(a))  
    b := a[1:3]  
    fmt.Printf("b:%v type:%T len:%d  cap:%d\n", b, b, len(b), cap(b))  
    c := b[1:5]  
    fmt.Printf("c:%v type:%T len:%d  cap:%d\n", c, c, len(c), cap(c))  
}

输出：

a:[北京 上海 广州 深圳 成都 重庆] type:[6]string len:6  cap:6  
b:[上海 广州] type:[]string len:2  cap:5  
c:[广州 深圳 成都 重庆] type:[]string len:4  cap:4

注意：对切片进行再切片时，索引不能超过原数组的长度，否则会出现索引越界的错误。

使用make()函数构造切片

我们上面都是基于数组来创建的切片，如果需要动态的创建一个切片，我们就需要使用内置的 make() 函数，格式如下：

make([]T, size, cap)

其中：

T:切片的元素类型
size:切片中元素的数量
cap:切片的容量

举个例子：

func main() {  
    a := make([]int, 2, 10)  
    fmt.Println(a)      //[0 0]  
    fmt.Println(len(a)) //2  
    fmt.Println(cap(a)) //10  
}

上面代码中 a 的内部存储空间已经分配了10个，但实际上只用了2个。容量并不会影响当前元素的个数，所以 len(a) 返回2， cap(a) 则返回该切片的容量。

切片的本质

切片的本质就是对底层数组的封装，它包含了三个信息：底层数组的指针、切片的长度（len）和切片的容量（cap）。

举个例子，现在有一个数组 a := [8]int{0, 1, 2, 3, 4, 5, 6, 7} ，切片 s1 := a[:5] ，相应示意图如下。

image.png

切片 s2 := a[3:6] ，相应示意图如下：

image.png

切片不能直接比较

var s1 []int         //len(s1)=0;cap(s1)=0;s1==nil  
s2 := []int{}        //len(s2)=0;cap(s2)=0;s2!=nil  
s3 := make([]int, 0) //len(s3)=0;cap(s3)=0;s3!=nil

所以要判断一个切片是否是空的，要是用 len(s) == 0 来判断，不应该使用 s == nil 来判断。

切片的赋值拷贝

下面的代码中演示了拷贝前后两个变量共享底层数组，对一个切片的修改会影响另一个切片的内容，这点需要特别注意。

func main() {  
    s1 := make([]int, 3) //[0 0 0]  
    s2 := s1             //将s1直接赋值给s2，s1和s2共用一个底层数组  
    s2[0] = 100  
    fmt.Println(s1) //[100 0 0]  
    fmt.Println(s2) //[100 0 0]  
      
    arra1 := [3]int{1, 2, 3}  
    arra2 := arra1  
    arra2[0] = 0  
    fmt.Println(arra1)  // [1 2 3]  
    fmt.Println(arra2)  // [0 2 3]  
      
}

切片遍历

切片的遍历方式和数组是一致的，支持索引遍历和 for range 遍历。

func main() {  
    s := []int{1, 3, 5}  
  
    for i := 0; i < len(s); i++ {  
        fmt.Println(i, s[i])  
    }  
  
    for index, value := range s {  
        fmt.Println(index, value)  
    }  
}

append()方法为切片添加元素

举个例子：

func main() {  
    //append()添加元素和切片扩容  
    var numSlice []int  
    for i := 0; i < 10; i++ {  
        numSlice = append(numSlice, i)  
        fmt.Printf("%v  len:%d  cap:%d  ptr:%p\n", numSlice, len(numSlice), cap(numSlice), numSlice)  
    }  
}

输出：

[0]  len:1  cap:1  ptr:0xc0000a8000  
[0 1]  len:2  cap:2  ptr:0xc0000a8040  
[0 1 2]  len:3  cap:4  ptr:0xc0000b2020  
[0 1 2 3]  len:4  cap:4  ptr:0xc0000b2020  
[0 1 2 3 4]  len:5  cap:8  ptr:0xc0000b6000  
[0 1 2 3 4 5]  len:6  cap:8  ptr:0xc0000b6000  
[0 1 2 3 4 5 6]  len:7  cap:8  ptr:0xc0000b6000  
[0 1 2 3 4 5 6 7]  len:8  cap:8  ptr:0xc0000b6000  
[0 1 2 3 4 5 6 7 8]  len:9  cap:16  ptr:0xc0000b8000  
[0 1 2 3 4 5 6 7 8 9]  len:10  cap:16  ptr:0xc0000b8000

从上面的结果可以看出：

append()

append()函数还支持一次性追加多个元素。例如：

var citySlice []string  
// 追加一个元素  
citySlice = append(citySlice, "北京")  
// 追加多个元素  
citySlice = append(citySlice, "上海", "广州", "深圳")  
// 追加切片  
a := []string{"成都", "重庆"}  
citySlice = append(citySlice, a...)  
fmt.Println(citySlice) //[北京 上海 广州 深圳 成都 重庆]  
  
### 切片的扩容策略  
  
可以通过查看`$GOROOT/src/runtime/slice.go`源码，其中扩容相关代码如下：  
  
```go  
newcap := old.cap  
doublecap := newcap + newcap  
if cap > doublecap {  
    newcap = cap  
} else {  
    if old.len < 1024 {  
        newcap = doublecap  
    } else {  
        // Check 0 < newcap to detect overflow  
        // and prevent an infinite loop.  
        for 0 < newcap && newcap < cap {  
            newcap += newcap / 4  
        }  
        // Set newcap to the requested cap when  
        // the newcap calculation overflowed.  
        if newcap <= 0 {  
            newcap = cap  
        }  
    }  
}

从上面的代码可以看出以下内容：

首先判断，如果新申请容量（cap）大于2倍的旧容量（old.cap），最终容量（newcap）就是新申请的容量（cap）。
否则判断，如果旧切片的长度小于1024，则最终容量(newcap)就是旧容量(old.cap)的两倍，即（newcap=doublecap），
否则判断，如果旧切片长度大于等于1024，则最终容量（newcap）从旧容量（old.cap）开始循环增加原来的1/4，即（newcap=old.cap,for {newcap += newcap/4}）直到最终容量（newcap）大于等于新申请的容量(cap)，即（newcap >= cap）
如果最终容量（cap）计算值溢出，则最终容量（cap）就是新申请容量（cap）。

需要注意的是，切片扩容还会根据切片中元素的类型不同而做不同的处理，比如 int 和 string 类型的处理方式就不一样。

使用copy()函数复制切片

首先我们来看一个问题：

func main() {  
    a := []int{1, 2, 3, 4, 5}  
    b := a  
    fmt.Println(a) //[1 2 3 4 5]  
    fmt.Println(b) //[1 2 3 4 5]  
    b[0] = 1000  
    fmt.Println(a) //[1000 2 3 4 5]  
    fmt.Println(b) //[1000 2 3 4 5]  
}

由于切片是引用类型，所以a和b其实都指向了同一块内存地址。修改b的同时a的值也会发生变化。

Go语言内建的 copy() 函数可以迅速地将一个切片的数据复制到另外一个切片空间中， copy() 函数的使用格式如下：

copy(destSlice, srcSlice []T)

其中：

srcSlice: 数据来源切片
destSlice: 目标切片

举个例子：

func main() {  
    // copy()复制切片  
    a := []int{1, 2, 3, 4, 5}  
    c := make([]int, 5, 5)  
    copy(c, a)     //使用copy()函数将切片a中的元素复制到切片c  
    fmt.Println(a) //[1 2 3 4 5]  
    fmt.Println(c) //[1 2 3 4 5]  
    c[0] = 1000  
    fmt.Println(a) //[1 2 3 4 5]  
    fmt.Println(c) //[1000 2 3 4 5]  
}

从切片中删除元素

Go语言中并没有删除切片元素的专用方法，我们可以使用切片本身的特性来删除元素。代码如下：

func main() {  
    // 从切片中删除元素  
    a := []int{30, 31, 32, 33, 34, 35, 36, 37}  
    // 要删除索引为2的元素  
    a = append(a[:2], a[3:]...)  
    fmt.Println(a) //[30 31 33 34 35 36 37]  
}

总结一下就是：要从切片a中删除索引为 index 的元素，操作方法是 a = append(a[:index], a[index+1:]...)

最后编辑于：2020.04.03 23:08:12

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 205,236评论 6赞 478
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 87,867评论 2赞 381
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 151,715评论 0赞 340
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 54,899评论 1赞 278
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 63,895评论 5赞 368
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 48,733评论 1赞 283
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 38,085评论 3赞 399
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 36,722评论 0赞 258
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 43,025评论 1赞 300
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 35,696评论 2赞 323
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 37,816评论 1赞 333
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 33,447评论 4赞 322
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 39,057评论 3赞 307
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 30,009评论 0赞 19
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 31,254评论 1赞 260
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 45,204评论 2赞 352
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 42,561评论 2赞 343

Golang的切片学习

切片

切片的定义

切片的长度和容量

基于数组定义切片

切片再切片

使用make()函数构造切片

切片的本质

切片不能直接比较

切片的赋值拷贝

切片遍历

append()方法为切片添加元素

使用copy()函数复制切片

从切片中删除元素

切片

切片的定义

切片的长度和容量

基于数组定义切片

切片再切片

使用make()函数构造切片

切片的本质

切片不能直接比较

切片的赋值拷贝

切片遍历

append()方法为切片添加元素

使用copy()函数复制切片

从切片中删除元素

推荐阅读更多精彩内容