Slice

一个slice由三个部分构成：指针、长度和容量。
指针指向第一个slice元素对应的底层数组元素的地址，要注意的是slice的第一个元素并不一定就是数组的第一个元素。
长度对应slice中元素的数目；
长度不能超过容量，容量一般是从slice的开始位置到底层数据的结尾位置。
内置的len和cap函数分别返回slice的长度和容量。

定义

切片其实就是可变长的数组，在定义的时候，不定义其长度，但是可以指定其最大长度。

1 2	var stu []string var stu = make([]string, 5) // 指定最大长度

在定义的时候，可以初始化，初始化多少个元素，那么他的最大长度就是多少

1 2	var stu []string{"a", "b", "c"} fmt.Printf("len=%d, cap=%d\n", len(stu), cap(stu))

append

append 函数，是在切片后面追加元素，具体如下

1	stu = append(stu, "x")

访问子序列

切片提供了访问其子序列的功能，操作s[i:j]，其中0 ≤ i≤ j≤ cap(s)，用于创建一个新的slice，引用s的从第i个元素开始到第j-1个元素的子序列。新的slice将只有j-i个元素，具体用法是：

1
2
3

var new = stu[1:2]
var new1 = stu[1:]
var new2 = stu[:2]

如果切片超出 cap(s) 的话，会抛出异常。

注：多个slice之间可以共享底层的数据，并且引用的数组部分区间可能重叠

循环

1
2
3

for k, v := range stu {
  fmt.Printf("k=%d, v=%s\n", k, v)
}

map

哈希表是一种巧妙并且实用的数据结构。它是一个无序的key/value对的集合，其中所有的key不能重复，通过给定的key可以操作对应的value。

定义

# 用 make 创建
var m = make([string]int)

# 字面值创建
m := map[string]int{
  "a": 1,
  "b": 2,  // 注意这里的逗号，不能省略
}

访问

使用下标的方式进行访问

fmt.Println(m["a"], m["b"])

m["a"] = 100
fmt.Println(m)

使用 delete 删除元素

1	delete(m, "a")

循环

1
2
3

for k, v := range m {
  fmt.Printf("k=%s, v=%d\n", k, v)
}

代码汇总

package main

import "fmt"

func main() {
  // stu := make([]string, 5)
  // stu[0] = "a"

  // var stu []string
  // stu = append(stu, "a")
  // stu = append(stu, "b")

  var stu = []string{"a", "b", "c", "d"}
  fmt.Println(stu)
  fmt.Printf("len=%d,cap=%d\n", len(stu), cap(stu))

  var new = stu[1:3]
  stu[1] = "bbb"
  fmt.Println(new)

  for k, v := range stu {
    fmt.Printf("k=%d, v=%s\n", k, v)
  }

  m := map[string]int{
    "a": 1,
    "b": 2,
  }
  m["c"] = 3
  fmt.Println(m)
  delete(m, "a")
  fmt.Println(m)

  for k, v := range m {
    fmt.Printf("k=%s, v=%d\n", k, v)
  }
}

Happy Coding