package main

import (
    "fmt"
    "reflect"
    "slices"
    "sort"
)

type User struct {
    name string
    age  int
}

func main() {
    arr := [3]int{1, 2, 3}
    slice := arr[1:2]
    fmt.Println(arr, len(arr), reflect.TypeOf(arr), "\n", slice, len(slice), reflect.TypeOf(slice))
    fmt.Println(slice)
    cc := append(slice, 1, 1)
    fmt.Println(slice) //slice值,长度不变
    fmt.Println(cc)

    var nullSlice []int
    //fmt.Println(nullSlice[0])
    var arr2 [0]int = [0]int{}
    fmt.Println(len(nullSlice), nullSlice == nil, reflect.TypeOf(nullSlice), reflect.TypeOf(arr2))
    //fmt.Println(arr2 == nil) 数组不能与nil判断, slice可以的
    arrList := [...]int{1, 7, 5, 4, 8} //数组与[3]int
    arrList2 := []int{}                //空切片 编译时创建
    arrList3 := make([]int, 0, 5)      //空切片 运行时动态创建 1.20+两者的效果差不多 ,长度为0, 初始为10, 可能传变量进来, 这样
    fmt.Println(len(arrList), arrList, arrList2, arrList3)
    //sort.Ints(arrList) //不支持数组直接排序, 要转成切片
    sort.Ints(arrList[:])                            // 转成切片再排序 从小到大排序
    sort.Sort(sort.Reverse(sort.IntSlice(arrList3))) //从大到小排序

    fmt.Println(len(arrList), arrList)
    arrList3 = append(arrList3, 4, 8, 6, 8, 7, 9)
    sort.Slice(arrList3, func(i, j int) bool {
        // func里面i,j是索引
        return arrList3[i] < arrList3[j]
    })
    // 源码中推荐使用slices.Sort, 而直接用sort.Ints调用
    slices.Sort(arrList3)
    slices.SortStableFunc(arrList3, func(i int, j int) int {
        // func里面i,j是具体对象
        return i - j
    })
    // 可以排对象
    users := []User{
        {"Jack", 30},
        {"Bobo", 20},
    }
    slices.SortFunc(users, func(a, b User) int {
        return a.age - b.age
    })

    fmt.Println(users)
}

package main

import "fmt"

// map映射字典, 是内部结构 无序的key-value, key为基础类型, value为任意类型, 使用前要初始化
func main() {
    var userMap = map[string]string{
        "A": "B",
        "B": "C",
        "4": "",
    }
    fmt.Println(userMap)
    // 显示出"4"对应的值
    fmt.Printf("%#v\n", userMap["4"])
    // 返回第一个是数值, 第二值是判断是否取到, 可为空
    val := userMap["A"]
    val, OK := userMap["E"]
    // 判断是否拿到
    fmt.Println(val, OK)
    delete(userMap, "B")
    fmt.Println(userMap)

    var aMap = make(map[string]string)
    var bMap = map[int]string{} //复杂类型要初始化, {}
    fmt.Println(aMap, bMap)
}

package main

import "fmt"

func main() {
    a := 5
    if a < 3 {
        fmt.Println("a < 3")
    } else if a < 5 {
        fmt.Println("a < 5")
    } else {
        fmt.Println("a >=5")
    }

    //switch,支持两个判断, 用,分隔, 默认自带了类似break的效果
    switch a {
    case 1, 2:
        fmt.Println("1或2")
    case 3, 4, 5:
        fmt.Println("3,4,5")
        // fallthrough可以继续执行下面的判断
        fallthrough
    case 6:
        fmt.Println("6")
    default:
        fmt.Println("default")
    }
}

package main

import (
    "fmt"
    "maps"
    "sort"
    "time"
)

// 没有while, 只有后缀式i++, 没前缀写法
func main() {
    var sum int
    for i := 1; i < 10; i++ {
        sum += i
    }
    fmt.Println(sum)
    for {
        sum++
        if sum > 100 {
            break
        }
    }
    fmt.Println(sum)

    list := []string{
        "a", "b", "c", "d", "e", "f", "g", "h", "i", "j",
    }
    for i := 0; i < len(list); i++ {
        fmt.Println(list[i])
    }
    //遍历
    for i, c := range list {
        fmt.Println(i, c)
    }

    userMap := map[string]string{
        "a": "b",
        "e": "f",
        "b": "c",
    }
    for k, v := range userMap {
        fmt.Println(k, v)
    }
    // 返回key的迭代器
    keysIter := maps.Keys(userMap)
    keys := make([]string, len(userMap))
    for k := range keysIter {
        keys = append(keys, k)
    }
    sort.Strings(keys)
    fmt.Println("keys:", keys)

    for {
        fmt.Println(time.Now())
        time.Sleep(time.Second)
    }
}