Go 学习笔记03.数组 切片 map字典 range遍历

数组

arrays.go

go run arrays.go

package main

import "fmt"

func main() {

	/*
	   go的`数组`,是固定长度
	   []创建，[5] 指定数组长度
	   [5]int -> 创建一个长度为5的数组，元素类型是int型
	   没有指定数组，使用初始类型值，数组是[0,0,0,0,0]
	*/
	var a [5]int
	fmt.Println("emp:", a)
	// 更改index为4的值为100，index从0开始
	a[4] = 100
	fmt.Println("set:", a)
	fmt.Println("get:", a[4])
	// len 返回数组长度
	fmt.Println("len:", len(a))

	/*
	   创建数组并直接给定初始值
	*/
	b := [5]int{1, 2, 3, 4, 5}
	fmt.Println("dcl:", b)

	// 二维数组[2] 创建[a,b]
	// [2]type -> type是[3]int
	// 创建的数组为 [[0,0,0] [0,0,0]]
	var twoD [2][3]int

	// 更改数组值
	fmt.Println(twoD)
	for i := 0; i < 2; i++ {
		for j := 0; j < 3; j++ {
			twoD[i][j] = i + j
		}
	}
	fmt.Println("2d: ", twoD)
}

切片

Slice 切片是 Go 中一个关键的数据类型

slices.ho

// _Slice_ 是 Go 中一个关键的数据类型，是一个比数组更
// 加强大的序列接口

package main

import "fmt"

func main() {

    // 不想数组，slice 的类型仅有它所包含的元素决定（不像
    // 数组中还需要元素的个数）。要创建一个长度非零的空
    // slice，需要使用内建的方法 `make`。这里我们创建了一
    // 个长度为3的 `string` 类型 slice（初始化为零值）。
    
    // 使用make([]string,3)
    // 创建长度为3,元素为字符串的切片
    // [ ]
    s := make([]string, 3)
    fmt.Println("emp:", s)

    s[0] = "a"
    s[1] = "b"
    s[2] = "c"
    fmt.Println("set:", s)
    fmt.Println("get:", s[2])
    fmt.Println("len:", len(s))

    // 使用内建的append,向切片末端添加值，可以添加多个
    s = append(s, "d")
    s = append(s, "e", "f")
    fmt.Println("apd:", s)

    // 创建一个空切片，长度和s相同，然后复制
    c := make([]string, len(s))
    copy(c, s)
    fmt.Println("cpy:", c)

    // 还可以进行 `切片`操作
    l := s[2:5]
    fmt.Println("sl1:", l)

    // 0-5 不含s[5]
    l = s[:5]
    fmt.Println("sl2:", l)

    // s[2] 到最后一个
    l = s[2:]
    fmt.Println("sl3:", l)

    // 声明并初始化切边
    // 可以不适用make创建，未指定大小的
    t := []string{"g", "h", "i"}
    fmt.Println("dcl:", t)

    // Slice 可以组成多维数据结构。内部的 slice 长度可以不
    // 同，这和多位数组不同。
    twoD := make([][]int, 3)
    for i := 0; i < 3; i++ {
        innerLen := i + 1
        twoD[i] = make([]int, innerLen)
        for j := 0; j < innerLen; j++ {
            twoD[i][j] = i + j
        }
    }
    fmt.Println("2d: ", twoD)
}

总结

# 1.使用make,len是初始长度，cap是容量
s :=make([]int,len,cap) 

# 2.直接初始化切片
s :=[] int {1,2,3} 

# 3.通过对`切片`操作,生产切片
s := arr[:]
s := arr[startIndex:endIndex] 
s := arr[startIndex:] 
s := arr[:endIndex] 

# 4. 通过对切片进行`切片`操作
s1 := s[startIndex:endIndex] 

关联数组 map

map 是 Go 内置关联数据类型（在一些其他的语言中称为哈希 或者字典 ）。

// map 字典

package main

import "fmt"

func main() {

    // make(map[key-type]value-type)
    m := make(map[string]int)

    // 使用典型的 `make[key] = val` 语法来设置键值对。
    m["k1"] = 7
    m["k2"] = 13

    // 使用例如 `Println` 来打印一个 map 将会输出所有的
    // 键值对。
    fmt.Println("map:", m)

    // 通过key,获取value
    v1 := m["k1"]
    fmt.Println("v1: ", v1)

    // 长度
    fmt.Println("len:", len(m))

    // 删除key-value
    delete(m, "k2")
    fmt.Println("map:", m)

    // 如果不存在，它也会返回，不过是0,""等初始值，但其实这个key不在map中
    val := m["k999"]
    fmt.Println("prs:", val)
    // 这种情况下，我们可以在增加一个接收值，表示是否在map中，true/false
    // 使用_ ，是因为如果定义变量不使用会报错，_就没问题
    _,prs := m["k888"]
    fmt.Println("prs:", prs)

    // 你也可以通过这个语法在同一行申明和初始化一个新的
    // map。
    n := map[string]int{"foo": 1, "bar": 2}
    fmt.Println("map:", n)
}

range 遍历

range.go

for index,value := range obj {

}

// _range_ 迭代各种各样的数据结构。让我们来看看如何在我们
// 已经学过的数据结构上使用 `range` 吧。

package main

import "fmt"

func main() {

    // 遍历切片
    nums := []int{2, 3, 4}
    sum := 0
    for _, num := range nums {
        sum += num
    }
    fmt.Println("sum:", sum)

    // 遍历切片,接收index
    for i, num := range nums {
        if num == 3 {
            fmt.Println("index:", i)
        }
    }

    // 遍历map字典
    kvs := map[string]string{"a": "apple", "b": "banana"}
    for k, v := range kvs {
        fmt.Printf("%s -> %s\n", k, v)
    }

    // 遍历字符串
    for i, c := range "go" {
        fmt.Println(i, c)
    }
}

sum: 9
index: 1
a -> apple
b -> banana
0 103
1 111