随笔 - 241 文章 - 1 评论 - 58 阅读 - 85万

Golang数据类型切片（slice）

前言

Go中的数组数据类型的长度在声明之后就无法修改了，切片是基于数组实现的，切片是动态数组，切片是1种可变长度的序列。它支持扩容。

切片不保存值，只保存（len、cap、底层数组的指针），在底层引用数组的值也就是引用数据类型，

接触了Go中arry、slice，会感觉到Python里面的list数据类型是如此的便捷，感谢Python的作者吧。

Go相对于Python来说是比较偏向底层的语言，为什么只能在arry、slice中只能存相同数据类型的值，是因为Go仅仅选中1块连续的内存地址。

而Python的list可以存不同的数据类型，是因为Python解释器会帮我们通过算法查找散列在不连续内存上的不同内存地址来获取值。

所以Go执行效率高，但是Python开发效率高。

切片和数组不同的是：

每个切片底层都对应1个数组，为这个切片存值，所以slice类型变量在没有初始化前没有分配内存、所以就根本没有默认值 =nil，因为你没有初始化指定长度和元素的数据类型，怎么给你分配这个底层数组呢？

//声明1个数组变量
var a1 [3]int
fmt.Println(a1)//声明完了就有默认值
//声明1个切片类型的变量
var s1 []int
fmt.Println(s1 == nil)

引子

为什么在Go中有了数组，还需要1个可变长度的切片呢？因为数组需要支持扩容！

package main
 
import "fmt"
 
func arraySum(x [3]int) int {
    sum := 0
    for _, v := range x {
        sum = sum + v
    }
    return sum
}
 
func main() {
    a1 := [3]int{1, 2, 3}
    //如果函数的参数定义了参数的长度，只能传长度为3的数组，所以数组有一定的局限性
    total := arraySum(a1)
    fmt.Println(total)
}
 
//.\main.go:14:24: array index 3 out of bounds [0:3]

切片的定义和初始化

切片类型和数组类型一样，想要使用，就必须要定义和初始化，不同之处已经提到，切片不需要指定切片的长度。

自定义切片

package main
 
import (
    "fmt"
)
 
func main() {
    //切片的定义
    var s1 []int //存放元素不限定，仅限定数据类型
    var s2 []string
    fmt.Println(s1 == nil) //在初始化之前切片的值=nil
    fmt.Println(s2 == nil)
    //切片的初始化
    s1 = []int{1, 2, 3}
    s2 = []string{"刘德华", "郭富城", "黎明", "梁朝伟"}
    //切片的长度和容量
    fmt.Printf("长度：%d 容量：%d", len(s1), cap(s1))
}

由数组得到切片 slice := arry [ : ]

package main
 
import "fmt"
 
var a1 [3]string
 
func main() {
    a1 = [3]string{"a", "b", "c"}
    // fmt.Printf("%T\n", a1)
    s1:=a1[:]//数组变成了1个切片,但是使用a1数组存储数据！
    // fmt.Printf("%T\n", a1)
    s1[0]="1"
    s1[1]="2"
    s1[2]="3"
    // s1[3]="4"
    // s1[5]="5"
    fmt.Println(s1)
     
}

package main
 
import (
    "fmt"
)
 
func main() {
 
    a1 := [...]int{1, 2, 3, 4, 5, 6, 69}
    s1 := a1[0:2]
    s2 := a1[:4]
    s3 := a1[2:]
    s4 := a1[:]
    fmt.Println(s1, s2, s3, s4)
    //切片的容量:是指底层数组的从切边的第1个元素-----》最后1个元素的数量
    fmt.Printf("切片的长度：%d 切片的容量：%d\n", len(s1), cap(s1))
    fmt.Printf("切片的长度：%d 切片的容量：%d\n", len(s2), cap(s2))
    fmt.Printf("切片的长度：%d 切片的容量：%d\n", len(s3), cap(s3))
 
}

切片的内存管理机制

如果我对切片A再进行切片([区间])或者变量赋值就会拿到1个新的切片B，如果给切片B追加元素那么会影响会怎样呢？

如果我们对切片B进行了appen，那么B的lengh就会不同于A。

如果没有超出容量，切片A、B会同用1个底层数组。

如果超出了原来容量则创建新的底层数组以支撑这个新的切片。

v1 := make([]int, 3, 5)
fmt.Println(v1,len(v1),cap(v1)) //v1=[0 0 0]
v2 := append(v1, 8)
fmt.Println(v2,len(v2),cap(v2)) //v2=[0 0 0 8]
fmt.Println(v1,len(v1),cap(v1))
//v2切片的长度经过append之后len=4,切片v1(不同于v2)的长度还是3,他的len决定了v1不会看到8
    //[0 0 0]
    //[0 0 0 8]
    //[0 0 0]

在Python里面对列表进行切片会开辟1块内存地址存储产生的新列表肯定不会影响。

在golang中如果对切片的切片进行apend操作，append的值会直接覆盖底层数组中值。

Go会.........因为你对1个切片，切几次产生的 “新”切片，只是指针、长度不同，本质都引用了同1个底层数组。

　　//6.删除元素：go语言没有直接删除切片元素的API
    var numberList= []string{"a","b","c","c","d","e"}
    deleteIndex:=2
    //删除c：切片numberList的切片["a","b"]追加了["c","d","e"]相当于操作了底层数组把原来的c、c、d覆盖成了c、d、e
    numberList=append(numberList[0:deleteIndex],numberList[deleteIndex+1:]...)
    //本质原因还是切片numberList和切片numberList的切片["a","b"]共同引用了同1个底层数组
    fmt.Println(numberList)

切片自动扩容的内存管理机制

1.每1个切片底层都对应了1个数组来保存值，而切片保存这个底层数组的长度（len）、容量（ cap）、底层数组的位置（point）。

v1:=make([]int,1,3)
fmt.Println(len(v1),cap(v1))

2.切片append元素（不产生扩容的情况）

切片追加元素时，在不会产生扩容的情况下，append之后产生的新切片和原切片引用同1个底层数组。

所以对切片进行再次切片时产生的新切片们，本质上就是引用的还是1个底层数组，只不过它们的长度不同，从这块内存上获取数据的起始位置不一样。

v1:=make([]int,1,3)
v2:=append(v1,66) //返回新的切片v2
fmt.Println(v1) //[0]
fmt.Println(v2) //[0,66]
v1[0]=99
fmt.Println(v1) //[99]
fmt.Println(v2) //[99 66]
fmt.Printf("v1的内存地址：%p,v2的内存地址:%p。",v1,v2)

3.切片在追加（append）元素时，出现了扩容。

一旦出现了扩容就会产生1个新的底层数组来保存原来的数据和新的数据。

所以新、旧切片使用了2个不同的底层数组。它们之间的修改操作不再彼此影响！

v1 :=[]int{11,22,33}  //创建1个切片长度为3，容量为3
fmt.Printf("%v 的长度为：%d,容量为%d.\n",v1,len(v1),cap(v1))
---------------------------------------------------------------
v2:=append(v1,44)    //apend时产生了扩容，长度为4，容量为6
fmt.Printf("%p\n",v2)
v1[0]=101
v2[0]=222
fmt.Printf("%v的长度为：%d,容量为%d.\n",v1,len(v1),cap(v1))
fmt.Printf("%v的长度为：%d,容量为%d.\n",v2,len(v2),cap(v2))

切片为引用类型论证

Go中的切片底层都有1个数组支撑，切引用这个底层数组的值，所以底层数组改变，切片的值也改变；

// package main
 
// import (
//  "fmt"
// )
 
// func main() {
//  //切片的定义
//  var s1 []int //存放元素不限定，仅限定数据类型
//  var s2 []string
//  fmt.Println(s1 == nil) //在初始化之前切片的值=nil
//  fmt.Println(s2 == nil)
//  //切片的初始化
//  s1 = []int{1, 2, 3}
//  s2 = []string{"刘德华", "郭富城", "黎明", "梁朝伟"}
//  //切片的长度和容量
//  fmt.Printf("长度：%d 容量：%d", len(s1), cap(s1))
// }
 
// package main
 
// import (
//  "fmt"
// )
 
// func main() {
 
//  a1 := [...]int{1, 2, 3, 4, 5, 6, 69}
//  s1 := a1[0:2]
//  s2 := a1[:4]
//  s3 := a1[2:]
//  s4 := a1[:]
//  fmt.Println(s1, s2, s3, s4)
//  //切片的容量:是指底层数组的从切边的第1个元素-----》最后1个元素的数量
//  fmt.Printf("切片的长度：%d 切片的容量：%d\n", len(s1), cap(s1))
//  fmt.Printf("切片的长度：%d 切片的容量：%d\n", len(s2), cap(s2))
//  fmt.Printf("切片的长度：%d 切片的容量：%d\n", len(s3), cap(s3))
 
// }
 
package main
 
import (
    "fmt"
)
 
func main() {
    a1 := [...]int{1, 2, 3, 4}
    s1 := a1[:3]
    fmt.Println(s1)
    a1[0] = 666  //修改了a1数组，但是s1引用着a1
    s2 := a1[:3]
    fmt.Println(s2)
 
}

切片常见操作

package main

import "fmt"

func main() {
    //1.获取切片的长度和容量
    var userList = []string{"alex", "eric", "润洪涛"}
    fmt.Println(len(userList), cap(userList))
    //2.s索引获取和修改值
    fmt.Println(userList[0])
    userList[0] = "李杰"
    fmt.Println(userList)
    //3.切片再切片:本质上引用同1个底层数组，但起始位置不一致
    v1 := userList[0:2]
    v2 := userList[1:]
    v3 := userList[:3]
    fmt.Println(v1, v2, v3)
    //4.切片追加元素
    v4:=append(userList,"小明","二狗","小刚子")
    fmt.Printf("%p---%p\n",userList,v4)
    //5.切片合并
    var extendList=[]string{"小何","小黑"}
    v5:=append(userList,extendList ...)
    fmt.Printf("%p----%p\n",userList,v5)
    fmt.Println(v5)
    //6.切片删除元素：go语言没有直接删除切片元素的API
    var numberList= []string{"a","b","c","c","d","e"}
    deleteIndex:=2
    //删除c：切片numberList的切片["a","b"]追加了["c","d","e"]相当于操作了底层数组把原来的c、c、d覆盖成了c、d、e
    numberList=append(numberList[0:deleteIndex],numberList[deleteIndex+1:]...)
    //本质原因还是切片numberList和切片numberList的切片["a","b"]共同引用了同1个底层数组
    fmt.Println(numberList)

    //7.切片插入元素
    var userList1= []string{"a","b","d","e"}
    insertIndex:=2
    newUserList:=make([]string,0,len(userList1)+1) //长度=0，数组中没数据，就是不初始化值=[]
    newUserList=append(newUserList,userList1[:insertIndex]...)
    newUserList=append(newUserList,"c")
    newUserList=append(newUserList,userList1[insertIndex:]...)
    fmt.Println(numberList)
    //错误的想法
    result:=append(userList1[:insertIndex],"c")
    result=append(result,userList1[insertIndex:]...)
    fmt.Println(result)

    //8.循环切片
    for i:=0;i<len(newUserList);i++{
        fmt.Println(newUserList[i])
    }
    //8.for range collection
    for i, v := range newUserList {
        fmt.Println(i,v)
    }


}

切片常见操作

使用make函数构造切片

特点：可以指定切片的长度和容量

package main
 
import "fmt"
 
func main() {
    //使用make函数创建切片
    s1 := make([]string, 10, 20) //string数据类型，指定长度为10，容量为20
    fmt.Printf("s1=%v len(s1)=%d cap(s1)=%d\n", s1, len(s1), cap(s1))
    //s1=[         ] len(s1)=10 cap(s1)=20
    s2 := make([]int, 0, 10)
    fmt.Printf("s2=%v len(s2)=%d cap(s2)=%d\n", s2, len(s2), cap(s2))
    //s2=[] len(s2)=0 cap(s2)=10
 
}

如何判断1个空的slice

package main
 
import "fmt"
 
func main() {
    var s1 []int
    fmt.Println(s1 == nil) //true
    //切片在赋值阶段才会 创建1个底层数组 来存储该切片的值，所以在没有真正赋值前切片没有对应的底层数组，所以此时的切片值为nil
    s1 = []int{}
    //如果创建了1个空的切片，它的底层就绑定了1个数组（该数组为空）,所以此时的切片不为nil
    fmt.Println(s1 == nil)//false
    //那么我们判断1个切片是否为空时应该 判断slice的长度是否为0
    fmt.Println(len(s1))
 
}

切片扩容策略

As I mentioned 每个切片都会指向一个底层数组（固定长度），当切片扩容时它所指向的定长数组就不能容纳新的元素，所以当底层数组不能容纳新增的元素时，切片就会自动按照一定的策略进行“扩容”，此时该切片指向的底层数组就会更换。“扩容”操作往往发生在append()函数调用时，所以我们通常都需要用原变量接收append函数的返回值。

//切片的扩容策略
 
package main
 
import (
    "fmt"
)
 
var numSlice []int
 
func main() {
    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:0xc000012098
[0 1]  len:2  cap:2  ptr:0xc0000120f0
[0 1 2]  len:3  cap:4  ptr:0xc00000a3e0
[0 1 2 3]  len:4  cap:4  ptr:0xc00000a3e0
[0 1 2 3 4]  len:5  cap:8  ptr:0xc000010200
[0 1 2 3 4 5]  len:6  cap:8  ptr:0xc000010200
[0 1 2 3 4 5 6]  len:7  cap:8  ptr:0xc000010200
[0 1 2 3 4 5 6 7]  len:8  cap:8  ptr:0xc000010200
[0 1 2 3 4 5 6 7 8]  len:9  cap:16  ptr:0xc000068080
[0 1 2 3 4 5 6 7 8 9]  len:10  cap:16  ptr:0xc000068080
*/

首先判断，如果新申请容量（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类型的扩容策略就不一样。

可以通过查看$GOROOT/src/runtime/slice.go源码，其中扩容相关代码如下：

ewcap := 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
        }
    }
}

切片嵌套

package main

import "fmt"

func main() {
    v1 := []int{11, 22, 33, 44, 55, 66}
    fmt.Println(v1)
    //切片套切片
    v2 := [][]int{[]int{1, 2}, []int{3, 4}}
    fmt.Println(v2)
    //切片套数组
    v3 := [][2]int{[2]int{1, 2}, [2]int{3, 4}}
    fmt.Println(v3)
    
}

切片嵌套

slice数据copy（深度拷贝）

既然slice是引用的数据类型，那么我们如何进行深度拷贝？

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

package main
 
import "fmt"
 
func main() {
    s1 := []int{1, 3, 5}
    s2 := s1
    var s3 = make([]int, 3, 5) //[0 0 0] 注意make创建的切片是有默认值的不是空的
    fmt.Println(s1, s2, s3)
    //Go语言内建的copy()函数可以迅速地将一个切片的数据复制到另外一个切片空间中，copy()函数的使用格式如下：
    copy(s3, s1) //参数1:目标序列 参数2：源序列
    s1[0]=100 
    fmt.Println(s1, s2, s3)
    /*
    s1为[100 3 5] 
    s2为[100 3 5]
    s3为[1 3 5]
    s1和s2指向的还是同1个底层数组
    copy的操作仅仅是将s1里面的元素，copy到s3里面，但引用了s3引用了1个新的底层数组
    */
 
}

切片数据删除元素

Go中没有内置的方法，对切片中的元素进行删除操作；

package main
 
import "fmt"
 
func main() {
    //从切片中删除元素
    s1 := []string{"齐国", "楚国", "美国", "日本", "燕国", "韩国", "赵国", "魏国", "秦国"}
    //美国和日本不属于战国七雄，怎么把它删除掉？
    fmt.Println(s1)
    s1 = append(s1[:2], s1[4:]...)
    fmt.Println(s1)
 
}

切片==比较

slice中的数据真正存储在底层数组中，slice是引用数据类型不支持==比较，那我们如何对slice进行相等的比较呢？

需要借助reflect包中的deepEqual方法。

package main
 
import (
    "fmt"
    "reflect"
)
func main() {
    //在go中数组是支持比较的，因为它是值类型
    a1 := [3]int{1, 2, 3}
    a2 := [3]int{1, 2, 3}
    s1 := []int{1, 2, 3}
    s2 := []int{1, 2, 3}
    fmt.Println(a1 == a2)
    //在go中对2个slice进行比较需要借助refelect
    fmt.Println(reflect.DeepEqual(s1, s2))
 
}

切片排序和元素索引

我们可以借助go语言内置的sort包对切片进行排序。

在查找切片某1元素的index位置时，需要提前对切片进行排序这一点和Python/JS有很大不同。

JavaScript

arry1=[3,19,88]
console.log(arry1.indexOf(88))

Python

l1=[1,12,2]
print(l1.index(2))

Golang

在Golang中我们需要自己进行循环遍历然后seek到某个在slice中的index位置，

或者借助sort包中的search功能，但是该功能的实现为二分法查找法，所以我们需要对since提前进行排序。

package main
 
import (
    "fmt"
    "sort"
)
 
func main() {
    //切片排序
    numberList := []int{
        1993, 1955, 1988, 1990, 1958,
    }
    sort.Ints(numberList)
    fmt.Println(numberList)
    //切片倒序
    sort.Sort(sort.Reverse(sort.IntSlice(numberList)))
    fmt.Println(numberList)
    //字符串排序
    nameList := []string{"aa", "bbx", "xx"}
    sort.Strings(nameList)
    fmt.Println(nameList)
 
    //在切片中查询元素
    fmt.Println(numberList)
    books := []string{"Hello", "World", "Ni", "Hao", "Mei", "Nv"}
    //必须先排序之后才能获取索引，因为SearchStrings使用二分法查找，有序是前提。
    sort.Strings(books)
    fmt.Println("现在你看到的是排序后的books", books)
    fmt.Println(sort.SearchStrings(books, "Ni"))
 
}

Go切片面试题

练习

package main

import "fmt"

func main() {
    /*
            1.简述切片和数组的区别？
            区别1.切片变量赋值之后产生的新，在新切片在不扩容的前提下，如果修改了元素，底层数组和共同引用这一数组的切片会受影响
            区别2.数组变量赋值之后产生的新数组，不会和原数组使用1块内存。
            区别3：切片支持自动扩容，数组不可以。

            2.简述new和make的区别？
            new返回的是一个对象的指针类型，make返回的是一个对象
            make初始比new多了2个参数，make可以帮助我们设置数据类型的默认长度、默认容量

            3.看代码写结果
            v1:=make([]int,2,5)
            fmt.Println(v1[0],len(v1),cap(v1))
            结果---0 2 5
            4.看代码写结果
            v1 := make([]int, 2, 5)
            v2 := append(v1, 123)
            //[0 0 123]
            fmt.Println(v2)
            //2 5
            fmt.Println(len(v1), cap(v1))
            //3 5
            fmt.Println(len(v2), cap(v2)
            5.看代码写结果:切片扩容了
            v1 := make([]int, 2, 2)
            v2 := append(v1, 123)
            v1[0]=99
            fmt.Println(v1)
            fmt.Println(v2)

            6.看代码写结果：切片没有扩容
            var v1=make([]int,2,2)
            v2:=v1[0:2]
            v1[0]=11
            fmt.Println(v1)
            fmt.Println(v2)
            //[11 0]
            //[11 0]
        7.看代码猜结果
        v1:=[][]int{[]int{11,22,33,44},[]int{44,55}}
        v1[0][2]=333
        fmt.Println(v1) //[[11 22 333 44] [44 55]]

        8.看代码写结果
        v1:=[][]int{[]int{11,22,33,44},[]int{44,55}}
        v2:=v1[0]
        v2[1]=222
        fmt.Println(v1)
        fmt.Println(v2)
        [[11 222 33 44] [44 55]]
        [11 222 33 44]

        10.看代码写结果
        v1:=[][]int{[]int{11,22,33,44},[]int{44,55}}
        v2:=append(v1[0],99) //扩容了产生了新的底层数组 [11 22 33 44 99]
        v2[2]=444
        fmt.Println(v1) //[[11 22 33 44] [444 55]]

        11.看代码写结果
        v1 := [][]int{make([]int, 2, 5), make([]int, 2, 3)} //[[0 0] [0 0]]
        v2 := append(v1[0], 99)                             //v2=[0 0 99]没有扩容
        v2[0] = 66                                          //v2=[66 0 99]
        fmt.Println(v2)
        fmt.Println(v1) //由于v1的len没有改变，所以它看到的是 [[66 0] [0 0]]





    */
    v1 := [][]int{make([]int, 2, 5), make([]int, 2, 3)} //[[0 0] [0 0]]
    v2 := append(v1[0], 99)                             //v2=[0 0 99]没有扩容
    v2[0] = 66                                          //v2=[66 0 99]
    fmt.Println(v2)
    fmt.Println(v1) //由于v1的len没有改变，所以它看到的是 [[66 0] [0 0]]

}

切片练习

基于slice实现队列和栈

package main
 
import "fmt"
 
func main() {
    //基于切片实现一个队列
    queue := []string{}
    queue = append(queue, "a", "b", "c")
    fmt.Println(queue[0])
    queue = queue[1:]
    fmt.Println(queue[0])
    queue = queue[1:]
    fmt.Println(queue[0])
    //基于切片实现一个栈
    stack := []string{}
    stack = append(stack, "a", "b", "c")
    fmt.Println(stack[len(stack)-1])
    stack = stack[:len(stack)-1]
    fmt.Println(stack[len(stack)-1])
    stack = stack[:len(stack)-1]
    fmt.Println(stack[len(stack)-1])
 
}

面试题1

package main
 
import "fmt"
 
func main() {
 
    a1 := [...]int{1, 3, 5} //数组
    s1 := a1[:]             //切片
    fmt.Println(s1, len(s1), cap(s1))
    s1 = append(s1[:1], s1[2:]...)
    fmt.Println(s1, len(s1), cap(s1))
    fmt.Println(a1) //底层数组：[1 5 5]
}
 
/*
每1个切片都会指向1个底层数组来帮这个切片存储数据（就就像  前端和数据库的关系），切片本身不保存数据值
底层数组就是占用了1块连续的内存
程序员在引用某底层数组的任意1个切片（前端）修改了底层数组（数据库）数据都会发生变化
】
*/

面试题2

package main
 
import "fmt"
 
func main() {
    s1 := make([]int, 5, 10)
    //坑就在make()make创造的切片已经开辟内存了，所以此时s1=[0 0 0 0 0 0 ]
    for i := 0; i < 10; i++ {
        s1 = append(s1, i)
    }
    fmt.Println(s1) //[0 0 0 0 0 0 1 2 3 4 5 6 7 8 9]
 
}

初始化1个6行7列的数组

var bigArry [6][]int
func main() {
    for i := 0;i<6;i++ {
        bigArry[i] = make([]int,7)
    }
    fmt.Println(bigArry)
    bigArry=[6][]int{
        []int{0,0,0,0,0,0,0},
        []int{0,0,0,0,0,0,0},
        []int{0,0,0,0,0,0,0},
        []int{0,0,0,0,0,0,0},
        []int{0,0,0,0,0,0,0},
        []int{0,0,0,0,0,0,0},
    }
    fmt.Println(bigArry)
}

公告

昵称： Martin8866
园龄： 7年11个月
粉丝： 350
关注： 44

+加关注

2025年3月

日

一

二

三

四

五

六

Golang数据类型切片（slice）

前言

引子

切片的定义和初始化

Go切片面试题

公告

搜索

常用链接

积分与排名

随笔分类

随笔档案

阅读排行榜

评论排行榜

推荐排行榜

最新评论

Golang数据类型 切片（slice）

前言

引子

切片的定义和初始化

Go切片面试题

公告

搜索

常用链接

积分与排名

随笔分类

随笔档案

阅读排行榜

评论排行榜

推荐排行榜

最新评论

Golang数据类型切片（slice）