网站首页 返回列表像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

Go语言中的Array、Slice、Map、Set和Struct解析

2020-06-10 04:17:14 admin 968

Go语言的数据类型和其他语言诸如Java，Python有相似之处，也有自己独特的地方。这篇文章主要讨论了几种数据结构类型(Composite
Types)的初始化以及基本使用方法。

## Array

Go中Array是固定长度的数组，因为其长度固定，所以在实际编程中Array很少被直接使用，动态数组Slice更为通用。

### 初始化

Array的初始化方式如下：

var a [3]int
    var a = [3]int{1, 2, 3}
    
    var a = [3]int{1, 2, 3}
    fmt.Println(a[2]) // "3"
    
    var b = [...]int{1, 2, 3}
    fmt.Printf("%T\n", b) // "[3]int"

### 遍历

Array的遍历方式很有Python风格：

for idx, v := range a {
        fmt.Printf("d% %d\n", idx, v)
    }

要注意的是，迭代过程中v是索引位置值的拷贝，因此变量v的地址每次循环都是相同的。如果要得到每个元素的真实地址可以用`&a[idx]`

Array还可以直接给指定index元素赋值：

r := [...]int{99:-1} // 前99个均为0，第100个元素为-1

### 多维数组

// 声明一个二维数组
    var array [4][2]int
    // 使用数组字面值声明并初始化
    array := [4][2]int{{10, 11}, {20, 21}, {30, 31}, {40, 41}}
    // 指定外部数组索引位置初始化
    array := [4][2]int{1: {20, 21}, 3: {40, 41}�}
    // 同时指定内外部数组索引位置初始化
    array := [4][2]int{1: {0: 20}, 3: {1: 41}}

## Slice

Slice(切片)是Go中所谓的动态数组，但与动态数组也有一些区别。Go中slice的创建方法有很多种，我们一个一个来看。

### 初始化

首先是最直接的`make`方式创建slice：

s1 := make([]string, 5) // 只指定slice长度
    s2 := make([]string, 5, 7) //第二个参数指slice的容量

slice的实现建立在底层数组之上，容量指的是底层数组的长度。slice也可以直接以赋值的方式创建：

// 创建一个字符串 slice
    // 长度和容量都是 5
    slice := []string{"Red", "Blue", "Green", "Yellow", "Pink"}
    
    // 创建一个字符串 slice
    // 初始化一个有100个元素的空的字符串 slice
    slice := []string{99: ""}

除此之外，slice也可以在array的基础上创建：

months := [...]string{1: "January", /* ... */, 12:"December"}
    Q2 := months[4:7] // ["April", "May", "June"], len=3, cap=9
    summer := months[6:9] // ["June", "July", "August"], len=3, cap=7

### Empty slice和nil slice

在Go中empty slice和nil slice是一对非常容易混淆的概念。他们两者表面上很相似：长度和容量都为0。但是区别在于nil
slice是没有底层数组的，nil slice可以被看作是未初始化的slice。

对于nil slice，当我们想要表示一个并不存在的slice时它变得非常有用，比如一个返回slice的函数中发生 **异常** 的时候。

empty slice包含0个元素并且底层数组没有分配存储空间。当我们想要表示一个 **空集** 合时它很有用处，比如一个数据库查询返回0个结果。

var s []int
    s = nil // len(s) == 0, s == nil
    s = []int(nil) // len(s) = 0, s == nil
    s = []int{} // len(s) = 0, s != nil

值得注意的一点是，在判断slice是否为空时，我们应该用`len(s) == 0`而非`s == nil`。

### Slice 增长

// 创建一个长度和容量都为5的 slice
    slice := []int{10, 20, 30, 40, 50}
    // 创建一个新的 slice
    newSlice := slice[1:3]
    // 为新的 slice append 一个值
    newSlice = append(newSlice, 60)

前面提到过，重叠的slice会共享底层数组，所以在未超出容量的条件下，append的新值也会同时改变slice对应位置的值。如果newSlice增加值后超过slice原容量长度：

// 创建一个长度和容量都为5的 slice
    slice := []int{10, 20, 30, 40, 50}
    // 创建一个新的 slice
    newSlice := slice[1:]
    // 为新的 slice append 一个值
    newSlice = append(newSlice, 60)

slice不会改变，cap仍旧是5。

对于容量不足的slice，如果append则会创建新的底层数组，拷贝已存在的值和将要被附加的新值——容量会是现有元素的两倍(前提是元素个数小于1000)，如果元素个数超过1000，那么容量会以
1.25 倍来增长。

// 创建长度和容量都为4的 slice
    slice := []int{10, 20, 30, 40}
    // 附加一个新值到 slice，因为超出了容量，所以会创建新的底层数组
    newSlice := append(slice, 50)

### 多维slice

初始化同理：

slice := [][]int{{10}, {20, 30}}

需要注意的是使用 append 方法时的行为，比如我们现在对 slice[0] 增加一个元素：

slice := [][]int{{10}, {20, 30}}
    slice[0] = append(slice[0], 20)

那么只有 slice[0] 会重新创建底层数组，slice[1] 则不会。

### 函数间传递

由于slice相当于是指向底层数组的指针，所以slice的传递非常廉价方便：

slice := make([]int, 1e6)
    slice = foo(slice)
    func foo(slice []int) []int {
        ...
        return slice
    }

### 基于slice的stack实现

首先给出empty slice，然后利用append实现：

stack := []int{}
    
    stack = append(stack, 1) // push
    stack = stack[:len(stack) - 1] // pop
    top := stack[len(stack) - 1] // peek method

## Map

### 初始化

总的来说map是键值对的无序组合。Map的初始化如下：

m := make(map[int]string)
    m := map[string]int {
        "alice": 31,
        "bob": 34,
    }

map 的键可以是任意内建类型或者是 struct 类型，map 的值可以是使用 ==操作符的表达式。 _ **slice，function 和 包含
slice 的 struct 类型不可以作为 map 的键**_ ，否则会编译错误：

dict := map[[]string]int{}
    Compiler Exception:
    invalid map key type []string

同样，nil map不能存放键值对：

var colors map[string]string
    colors["Red"] = "#da1337"
    Runtime Error:
    panic: runtime error: assignment to entry in nil map

### 删除

map的删除操作很简单：

delete (m, "alice") // remove element m["alice"]

如果map中不存在某个键值对，对其进行操作也是安全的，map会在操作时给它附上默认值：

m ["charlie"]++ // m["charlie"] = 1

检查是否存在该值：

age , ok := m["bob"]

ok作为flag，如果返回`true`则表明含有该key，如果返回`false`则该key不存在。

### 函数间传递

函数间传递的map **不是map的拷贝** ，所以如果我们在函数中改变了 map，那么所有引用 map 的地方都会改变。

## Set

Go中没有直接的set的实现，原因在于set可以十分简单地利用map实现：

set := make(map(int)bool)

## struct

### 初始化

Struct是把零个或者多个变量组合在一起的整体。其初始化如下：

type Employee struct {
        ID int
        Name string
        DoB time.Time
    }
    
    var e Employee
    em1 := Employee{1, "name", "time..."}
    em2 := Employee{ID: 1, Name: "name", DoB: "19930701"}
    
    em1.ID = 1 // 调用

嵌套式初始化如下：

Wheel {
        Circle: Circle {
            Point: Point {
                X: 8
                Y: 8
            },
            Radius: 5
        }
        Spokes: 20
    }

### 函数间传递

Struct在函数间传递如果直接传递则是copy，想要改变其中的值，可以传递指针。

pp := &Employee{1, ...}
    
    // It is equivalent to...
    pp := new(Employee)
    *pp = Employee{1, ...}

### Embedding机制

Struct的embedding机制允许我们把struct作为匿名域放到另一个struct里面，省去了很多书写的麻烦：

type Point struct {
        X, Y int
    }
    
    type Circle struct {
        Point
        Radius int
    }
    
    type Wheel struct {
        Circle
        Spokes int
    }
    
    var w Wheel
    w.X = 8 // equivalent to w.Circle.Point.X = 8
    w.Y = 8 // equivalent to w.Circle.Point.Y = 8
    w.Radius = 5 // equivalent to w.Circle.Radius = 8
    w.Spokes = 20

**References:**  
[1] _Donovan, Alan AA, and Brian W. Kernighan. The Go programming language.
Addison-Wesley Professional, 2015._  
[2]
_[http://www.jb51.net/article/56828.htm](https://link.jianshu.com?t=http://www.jb51.net/article/56828.htm)_

更多文章请见
[http://davidcorn.github.io](https://link.jianshu.com?t=http://davidcorn.github.io)

转载文章，原文链接： Go语言中的Array、Slice、Map、Set和Struct解析

关键字词go Array

分享到：

上一篇：Go中的Channel——range和select

下一篇：go语言坑之list删除所有元素

如需留言，请登录，没有账号？请注册

0 条评论 0 人参与

网站首页 返回列表像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

Go语言中的Array、Slice、Map、Set和Struct解析

zhou 2年前

zhou 2年前

zhou 2年前

zhou 2年前

武云 2年前

网站首页 返回列表 像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

Go语言中的Array、Slice、Map、Set和Struct解析

zhou 2年前

zhou 2年前

zhou 2年前

zhou 2年前

武云 2年前

网站首页返回列表像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。