【Golang】Golang进阶系列教程--Go 语言数组和切片的区别

浅浅的花香味﹌ 2023-10-14 09:38 18阅读 0赞

#### 文章目录 ####

*  前言
 *  数组
 *   *  声明以及初始化
     *  函数参数
 *  切片
 *   *  声明以及初始化
     *  函数参数
 *  总结

## 前言 ##

在 Go 语言中，数组和切片看起来很像，但其实它们又有很多的不同之处，这篇文章就来说说它们到底有哪些不同。

数组和切片是两个常用的数据结构。它们都可以用于存储一组相同类型的元素，但在底层实现和使用方式上存在一些重要的区别。

Go 中数组的长度是不可改变的，而 Slice 解决的就是对不定长数组的需求。他们的区别主要有两点

## 数组 ##

数组是同一种数据类型元素的集合，数组在定义时需要指定长度和元素类型。  
![在这里插入图片描述][70197552056442318a6d9c11692d4fec.png]

例如：\[4\]int 表示一个包含四个整数的数组，数组的大小是固定的。并且长度是其类型的一部分（\[4\]int 和 \[5\]int 是不同的、不兼容的类型）。  
数组元素可以通过索引来访问，比如表达式 s\[n\] 表示访问第 n 个元素，索引从零开始。

### 声明以及初始化 ###

func main() {
        
        var nums [3]int   // 声明并初始化为默认零值
        var nums1 = [4]int{
        1, 2, 3, 4}  // 声明同时初始化
        var nums2 = [...]int{
        1, 2, 3, 4, 5} // ...可以表示后面初始化值的长度
        fmt.Println(nums)    // [0 0 0]
        fmt.Println(nums1)   // [1 2 3 4]
        fmt.Println(nums2)   // [1 2 3 4 5]
    }

### 函数参数 ###

如果数组作为函数的参数，那么实际传递的是一份数组的拷贝，而不是数组的指针。这也就意味着，在函数中修改数组的元素是不会影响到原始数组的。  
![在这里插入图片描述][6be5f46846424dc1b840566c4431bb0f.png]

package main
    
    import (
        "fmt"
    )
    
    func Add(numbers [5]int) {
        
        for i := 0; i < len(numbers); i++ {
        
            numbers[i] = numbers[i] + 1
        }
        fmt.Println("numbers in Add:", numbers) // [2 3 4 5 6]
    }
    
    func main() {
        
        // declare and initialize the array
        var numbers [5]int
        for i := 0; i < len(numbers); i++ {
        
            numbers[i] = i + 1
        }
    
        Add(numbers)
        fmt.Println("numbers in main:", numbers) // [1 2 3 4 5]
    }

## 切片 ##

数组的使用场景相对有限，切片才更加常用。  
切片（Slice）是一个拥有相同类型元素的可变长度的序列。它是基于数组类型做的一层封装。它非常灵活，支持自动扩容。  
![在这里插入图片描述][eaeda3d75f5a4808bf09b401bb4ce862.png]

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

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

底层源码定义如下：

type slice struct {
        
        array unsafe.Pointer
        len   int
        cap   int
    }

### 声明以及初始化 ###

func main() {
        
        var nums []int  // 声明切片
        fmt.Println(len(nums), cap(nums)) // 0 0
        nums = append(nums, 1)   // 初始化
        fmt.Println(len(nums), cap(nums)) // 1 1
    
        nums1 := []int{
        1,2,3,4}    // 声明并初始化
        fmt.Println(len(nums1), cap(nums1))    // 4 4
    
        nums2 := make([]int,3,5)   // 使用make()函数构造切片
        fmt.Println(len(nums2), cap(nums2))    // 3 5
    }

### 函数参数 ###

当切片作为函数参数时，和数组是不同的，如果一个函数接受一个切片参数，它对切片元素所做的更改将对调用者可见，类似于将指针传递给了底层数组。

package main
    
    import (
        "fmt"
    )
    
    func Add(numbers []int) {
        
        for i := 0; i < len(numbers); i++ {
        
            numbers[i] = numbers[i] + 1
        }
        fmt.Println("numbers in Add:", numbers) // [2 3 4 5 6]
    }
    
    func main() {
        
        var numbers []int
        for i := 0; i < 5; i++ {
        
            numbers = append(numbers, i+1)
        }
    
        Add(numbers)
    
        fmt.Println("numbers in main:", numbers) // [2 3 4 5 6]
    }

再看一下上面的例子，把参数由数组变成切片，Add 函数中的修改会影响到 main 函数。

## 总结 ##

最后来总结一下，面试时也可以这么来回答：

*  数组是一个长度固定的数据类型，其长度在定义时就已经确定，不能动态改变；切片是一个长度可变的数据类型，其长度在定义时可以为空，也可以指定一个初始长度。
 *  数组的内存空间是在定义时分配的，其大小是固定的；切片的内存空间是在运行时动态分配的，其大小是可变的。
 *  当数组作为函数参数时，函数操作的是数组的一个副本，不会影响原始数组；当切片作为函数参数时，函数操作的是切片的引用，会影响原始切片。
 *  切片还有容量的概念，它指的是分配的内存空间。

[70197552056442318a6d9c11692d4fec.png]: https://img-blog.csdnimg.cn/70197552056442318a6d9c11692d4fec.png
[6be5f46846424dc1b840566c4431bb0f.png]: https://img-blog.csdnimg.cn/6be5f46846424dc1b840566c4431bb0f.png
[eaeda3d75f5a4808bf09b401bb4ce862.png]: https://img-blog.csdnimg.cn/eaeda3d75f5a4808bf09b401bb4ce862.png