【GO语言学习 基础篇】05 复杂数据类型

源代码

go语言基础

---

数组

a:= [3]int(1, 2,3)
        // 数组名称 ：=[数组长度]元素类型（元素1，元素2，元素3......）
        b := [...]int() //可变长度数组

        //  for --- range ---

        // 二维数组

        two :=[3][3]int{
                {1, 2, 3},
                {1, 2, 3},
                {1, 2, 3},
    }
        // 三维数组差不多 可以自行探索

切片

切片是数组的一部分，是一种浅拷贝，是对于数组的引用，因此如果改变切片的内容，原数组的数据也会改变

但是也有例外 在切片后面使用append增加一个数据，那么切片就会变成一个新的数组

还有一个 copy的用法在下面的代码中没有写，但是可以研究，

package main

    import "fmt"

    func createSlice() {
        // 切片[]Type 数组[n]Type  Type 是数据类型的意思
        // 声明整形切片
        var numberList []int
        fmt.Println(numberList)

        // 声明一个空切片
        var numberListEmpty []int
        fmt.Println(numberListEmpty)

        // make声明方式 make([]Type,size,cap) 3是len，6是cap 包含默认值
        numList := make([]int, 3, 6)
        fmt.Println(numList)
        // 指针 point: 是指向第一个切片元素对应底层数组元素的地址
        // 长度 size : 切片中的元素个数
        // 容量 cap  : 从切片的开始位置到底层数据的结尾位置

        arr := [...]string{"dddd", "yyds", "awsl", "yysy", "xswl"}
        var s1 = arr[1:4] // 数组变量[起始位置:结束位置] 左闭右开区间
        fmt.Println(arr)
        fmt.Println(s1)
        /*
        []
        []
        [0 0 0]
        [dddd yyds awsl yysy xswl]
        // 数组变量[起始位置:结束位置] 结束位置不包含，切片的数组个数应该是结束位置-起始位置
        var s1 = arr[1:4]
        [yyds awsl yysy]
        */
    }

    func sliceLenAndCap() {
        s := make([]int, 3, 5)
        fmt.Println(len(s))
        fmt.Println(cap(s))
    }

    func outOfSlice() {
        s := make([]int, 3, 5)
        fmt.Println(s)
        // fmt.Println(s[10])
    }

    func emptySlice() {
        var numberList []int
        fmt.Println(numberList == nil)

        fmt.Println(len(numberList) == 0)
    }

    func modifySlice() {
        var arr = [...]string{"c", "c++", "c#"}
        s := arr[:]
        fmt.Println(arr)
        fmt.Println(s)
        // 这里的结果可以看出是浅拷贝
        s[0] = "go"
        fmt.Println(arr)
        fmt.Println(s)
    }

    func appendSliceData() {
        s := []string{"c", "c++", "c#"}
        // 追加一个元素 这里的结果就可以看出是新建了一个数组
        s = append(s, "go")
        fmt.Println(s)
        fmt.Println(cap(s))
        // 追加两个元素
        s = append(s, "php", "html")
        fmt.Println(s)
        fmt.Println(cap(s))
        // 追加一个切片
        s = append(s, []string{"c", "c++", "c#"}...)
        fmt.Println(s)
        fmt.Println(cap(s))

        /*
        一旦发现追加的装不下，那么就会进行扩容，
        每次扩容是原有的2倍，扩容的方式是新建一片空间将原有的复制进去
        */
    }

    func mSlice() {
        numList := [][]string{
            {"1", "c"},
            {"2", "c++"},
            {"3", "c#"},
        }
        fmt.Println(numList)
    }

    func main() {
        createSlice()
        fmt.Println("---------------------------------")
        sliceLenAndCap()
        fmt.Println("---------------------------------")
        outOfSlice()
        fmt.Println("---------------------------------")
        emptySlice()
        fmt.Println("---------------------------------")
        modifySlice()
        fmt.Println("---------------------------------")
        appendSliceData()
        fmt.Println("---------------------------------")
        mSlice()
    }

map

map 在很多语言中都有，在 go 中也很常用，值得注意的是，在后续的应用中，本人喜欢把 map 和 JSON 结合使用用于传数据，这也是本人所接触的项目中常用的使用方法，可玩性很强。

package main

import (
    "fmt"
)

// map是引用类型
func createMap() {
    // make(map[keyType]ValueType)
    // map是无序的
    // 创建相同数据类型的键值对
    steps := make(map[string]string)
    fmt.Println(steps)

    // 键值对类型不同
    scores := make(map[string]int)
    fmt.Println(scores)

    // 通过字面值创建map
    var steps2 = map[string]string{
        "1": "c",
        "2": "go",
        "3": "python",
    }
    fmt.Println(steps2)

    fmt.Println()

    steps3 := map[string]string{
        "1": "c",
        "2": "go",
        "3": "python",
    }
    fmt.Println(steps3)

}

func mapAddData() {
    m := make(map[string]string)
    // 添加元素
    m["1"] = "c"
    fmt.Println(m)
    // 更新元素
    m["1"] = "go"
    fmt.Println(m)
    // 获取元素
    fmt.Println(m["1"])
    // 删除元素
    delete(m, "1")
    fmt.Println(m)

    // 判断键值是否存在 value,ok := map[key]
    steps3 := map[string]string{
        "1": "c",
        "2": "go",
        "3": "python",
    }
    fmt.Println(steps3)
    v3, ok := steps3["1"]
    fmt.Println(v3) // 如果有值 那么就返回一个值
    fmt.Println(ok) // 如果有值 在返回值的同时给ok赋值为true

    v4, ok := steps3["4"]
    fmt.Println(v4) // 如果没有值 那么就没有返回值
    fmt.Println(ok) // 如果没有值 同时给ok赋值为true

    // 遍历map for range
    for key, value := range steps3 {
        fmt.Printf("key:%s,value:%s\n", key, value)
    }
    // len()获取map长度
    fmt.Println(len(steps3))

}

func mapByReference() {
    // map是引用类型

    steps3 := map[string]string{
        "1": "c",
        "2": "go",
        "3": "python",
    }
    fmt.Println(steps3)
    newStep3 := steps3
    fmt.Println("---------------------------------")
    newStep3["1"] = "java"
    newStep3["2"] = "html"
    newStep3["3"] = "php"
    fmt.Println("---------------ssss------------------")
    fmt.Println(steps3["4"] == "4")
    fmt.Println("----------------ssss-----------------")
    fmt.Println(newStep3)

}

func main() {
    createMap()
    fmt.Println("---------------------------------")
    mapAddData()
    fmt.Println("---------------------------------")
    mapByReference()
    fmt.Println("---------------------------------")
    count := 5
    for count != 0 {
        fmt.Println(count)
        count = count - 1
    }

}