复合数据类型:数组和切片 Slice

开发 后端
正是因为其长度固定,所以相比于切片,在开发过程中用的是比较少的。但数组是切片的基础,理解了数组,再学习切片就容易多了。

[[414265]]

公司 Tony 老师这两天请假,找来了他的好朋友 Kevin 顶班,这两个人的风格真是相差十万八千里。

Tony 性格缓慢,手法轻柔。到底有多轻呢?洗头发的时候我都怀疑他是不是怕把我头发弄湿。

Kevin 则完全不同,嗓音洪亮,风风火火。说是洗头发,但我感觉他就是在扇我脑袋。眼前水花四溅,雾气缭绕,仿佛都能看见彩虹。

理发的小感受,夸张了点儿。

经过上一篇的学习,对 Go 应该已经越来越有感觉了,今天来点更高级的内容:复杂数据类型。

本篇主要介绍数组和切片 slice,开整~

数组

数组有两个特点:

  • 固定长度
  • 元素类型相同

正是因为其长度固定,所以相比于切片,在开发过程中用的是比较少的。但数组是切片的基础,理解了数组,再学习切片就容易多了。

声明和初始化

声明一个长度是 3,元素类型是 int 的数组。通过索引来访问数组元素,索引从 0 到数组长度减 1,内置函数 len 可以获取数组长度。

  1. var a [3]int 
  2. // 输出数组第一个元素 
  3. fmt.Println(a[0]) // 0 
  4. // 输出数组长度 
  5. fmt.Println(len(a)) // 3 

数组初始值为元素类型零值,也可以用数组字面量初始化数组。

  1. // 数组字面量初始化 
  2. var b [3]int = [3]int{1, 2, 3} 
  3. var c [3]int = [3]int{1, 2} 
  4. fmt.Println(b)    // [1 2 3] 
  5. fmt.Println(c[2]) // 0 

如果没有显示指定数组长度,而是用 ...,那么数组长度由实际的元素数量决定。

  1. // 使用 ... 
  2. d := [...]int{1, 2, 3, 4, 5} 
  3. fmt.Printf("%T\n", d) // [5]int 

还可以指定索引位置来初始化,如果没有指定数组长度,则长度由索引来决定。

  1. // 指定索引位置初始化 
  2. e := [4]int{5, 2: 10} 
  3. f := [...]int{2, 4: 6} 
  4. fmt.Println(e) // [5 0 10 0] 
  5. fmt.Println(f) // [2 0 0 0 6] 

多维数组

多维数组的声明和初始化同理,这里以二维数组来举例说明,有一点需要注意,多维数组仅第一维允许使用 ...。

  1. // 二维数组 
  2. var g [4][2]int 
  3. h := [4][2]int{{10, 11}, {20, 21}, {30, 31}, {40, 41}} 
  4. // 声明并初始化外层数组中索引为 1 和 3 的元素 
  5. i := [4][2]int{1: {20, 21}, 3: {40, 41}} 
  6. // 声明并初始化外层数组和内层数组的单个元素 
  7. j := [...][2]int{1: {0: 20}, 3: {1: 41}} 
  8. fmt.Println(g, h, i, j) 

使用数组

只要数组元素是可比较的,那么数组就是可比较的,而且数组长度也是数组类型的一部分。

所以 [3]int 和 [4]int 是两种不同的类型。

  1. // 数组比较 
  2. a1 := [2]int{1, 2} 
  3. a2 := [...]int{1, 2} 
  4. a3 := [2]int{1, 3} 
  5. // a4 := [3]int{1, 2} 
  6. fmt.Println(a1 == a2, a1 == a3, a2 == a3) // true false false 
  7. // fmt.Println(a1 == a4)                     // invalid operation: a1 == a4 (mismatched types [2]int and [3]int

数组遍历:

  1. // 数组遍历 
  2. for i, n := range e { 
  3.     fmt.Println(i, n) 

值类型

Go 数组是值类型,赋值和传参都会复制整个数组。

从输出结果可以看出来,内容都是相同的,但地址不同。

  1. package main 
  2.  
  3. import "fmt" 
  4.  
  5. func main() { 
  6.     // 数组复制 
  7.     x := [2]int{10, 20} 
  8.     y := x 
  9.     fmt.Printf("x: %p, %v\n", &x, x) // x: 0xc00012e020, [10 20] 
  10.     fmt.Printf("y: %p, %v\n", &y, y) // y: 0xc00012e030, [10 20] 
  11.     test(x) 
  12.  
  13. func test(a [2]int) { 
  14.     fmt.Printf("a: %p, %v\n", &a, a) // a: 0xc00012e060, [10 20] 

再来看看函数传参的情况:

  1. package main 
  2.  
  3. import "fmt" 
  4.  
  5. func main() { 
  6.     x := [2]int{10, 20} 
  7.  
  8.     // 传参 
  9.     modify(x) 
  10.     fmt.Println("main: ", x) // main:  [10 20] 
  11.  
  12. func modify(a [2]int) { 
  13.     a[0] = 30 
  14.     fmt.Println("modify: ", a) // modify:  [30 20] 

同样从结果可以看到,modify 中数组内容修改后,main 中数组内容并没有变化。

那么,有没有可能在函数内修改,而影响到函数外呢?答案是可以的,接下来要说的切片就可以做到。

切片 slice

切片是一种引用类型,它有三个属性:指针,长度和容量。

  1. 指针:指向 slice 可以访问到的第一个元素。
  2. 长度:slice 中元素个数。
  3. 容量:slice 起始元素到底层数组最后一个元素间的元素个数。

看到这样的解释是不是一脸懵呢?别慌,咱们来详细解释一下。

它的底层结构是这样的:

再来看一个例子,看看到底各部分都是什么意思。

底层是一个包含 10 个整型元素的数组,data1 指向数组第 4 个元素,长度是 3,容量取到数组最后一个元素,是 7。data2 指向数组第 5 个元素,长度是 4,容量是 6。

创建切片

创建切片有两种方式:

第一种方式是基于数组创建:

  1. // 基于数组创建切片 
  2. var array = [...]int{1, 2, 3, 4, 5, 6, 7, 8} 
  3.  
  4. s1 := array[3:6] 
  5. s2 := array[:5] 
  6. s3 := array[4:] 
  7. s4 := array[:] 
  8.  
  9. fmt.Printf("s1: %v\n", s1) // s1: [4 5 6] 
  10. fmt.Printf("s2: %v\n", s2) // s2: [1 2 3 4 5] 
  11. fmt.Printf("s3: %v\n", s3) // s3: [5 6 7 8] 
  12. fmt.Printf("s4: %v\n", s4) // s4: [1 2 3 4 5 6 7 8] 

第二种方式是使用内置函数 make 来创建:

  1. // 使用 make 创建切片 
  2. // len: 10, cap: 10 
  3. a := make([]int, 10) 
  4. // len: 10, cap: 15 
  5. b := make([]int, 10, 15) 
  6.  
  7. fmt.Printf("a: %v, len: %d, cap: %d\n", a, len(a), cap(a)) 
  8. fmt.Printf("b: %v, len: %d, cap: %d\n", b, len(b), cap(b)) 

使用切片

遍历

和遍历数组方法相同。

  1. // 切片遍历 
  2. for i, n := range s1 { 
  3.     fmt.Println(i, n) 

比较

不能使用 == 来测试两个 slice 是否有相同元素,但 slice 可以和 nil 比。slice

类型的零值是 nil,表示没有对应的底层数组,而且长度和容量都是零。

但也要注意,长度和容量都是零的,其值也并不一定是 nil。

  1. // 比较 
  2. var s []int 
  3. fmt.Println(len(s) == 0, s == nil) // true true 
  4. s = nil 
  5. fmt.Println(len(s) == 0, s == nil) // true true 
  6. s = []int(nil) 
  7. fmt.Println(len(s) == 0, s == nil) // true true 
  8. s = []int{} 
  9. fmt.Println(len(s) == 0, s == nil) // true false 

所以,判断 slice 是否为空,要用内置函数 len,而不是判断其是否为 nil。

追加元素

使用内置函数 append。

  1. // 追加 
  2. s5 := append(s4, 9) 
  3. fmt.Printf("s5: %v\n", s5) // s5: [1 2 3 4 5 6 7 8 9] 
  4. s6 := append(s4, 10, 11) 
  5. fmt.Printf("s6: %v\n", s6) // s5: [1 2 3 4 5 6 7 8 10 11] 

追加另一个切片,需要在另一个切片后面跟三个点。

  1. // 追加另一个切片 
  2. s7 := []int{12, 13} 
  3. s7 = append(s7, s6...) 
  4. fmt.Printf("s7: %v\n", s7) // s7: [12 13 1 2 3 4 5 6 7 8 10 11] 

复制

  1. // 复制 
  2. s8 := []int{1, 2, 3, 4, 5} 
  3. s9 := []int{5, 4, 3} 
  4. s10 := []int{6} 
  5.  
  6. copy(s8, s9) 
  7. fmt.Printf("s8: %v\n", s8) // s8: [5 4 3 4 5] 
  8. copy(s10, s9) 
  9. fmt.Printf("s10: %v\n", s10) // s10: [5] 

引用类型

上文介绍数组时说过,数组属于值类型,所以在传参时会复制整个数组内容,如果数组很大的话,是很影响性能的。而传递切片只会复制切片本身,并不影响底层数组,是很高效的。

  1. package main 
  2.  
  3. import "fmt" 
  4.  
  5. func main() { 
  6.     s9 := []int{5, 4, 3} 
  7.  
  8.     // 传参 
  9.     modify(s9) 
  10.     fmt.Println("main: ", s9) // main:  [30 4 3] 
  11.  
  12. func modify(a []int) { 
  13.     a[0] = 30 
  14.     fmt.Println("modify: ", a) // modify:  [30 4 3] 

在 modify 中修改的值会影响到 main 中。

总结

本文学习了复合数据类型的前两种:数组和切片。分别介绍了它们的创建,常用操作,以及函数间的传递。

数组长度固定,是切片的基础;切片长度可变,多一个容量属性,其指针指向的底层结构就是数组。

在函数传参过程中,数组如果很大的话,很影响效率,而切片则解决了这个问题,效率更高。

在日常开发中,使用切片的频率会更高一些。

本文转载自微信公众号「AlwaysBeta」,可以通过以下二维码关注。转载本文请联系AlwaysBeta公众号。

 

责任编辑:武晓燕 来源: AlwaysBeta
相关推荐

2021-08-02 07:02:18

数据结构体Struct

2009-11-30 16:33:17

PHP复合数据类型ar

2021-03-02 21:52:48

Hive数据类型

2023-05-23 18:11:12

Rust数组元组

2016-08-18 14:13:55

JavaScript基本数据引用数据

2010-07-22 17:57:40

2021-04-19 15:35:13

NumPy组合数组

2022-03-21 19:45:06

序列数组Python

2011-05-26 13:54:04

Json

2010-10-15 13:28:34

MySql数据类型

2011-06-08 15:31:43

JAVA多维数组

2022-06-02 13:54:04

Go数组切片

2023-11-28 11:44:54

Go切片

2023-03-27 10:04:27

数据类型浮点型布尔型

2021-04-16 07:19:04

Hive数据类型Hql

2014-01-05 17:08:09

PostgreSQL数据类型

2019-08-12 11:40:48

数据库SQLite3数据类型

2020-10-26 13:46:07

Java基础入门篇

2023-03-29 08:03:53

2024-10-15 08:57:08

Go语言切片
点赞
收藏

51CTO技术栈公众号