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

喜欢ヅ旅行 2023-07-25 14:10 21阅读 0赞

### 数组 ###

`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