Golang 基础语法学习

_下划线表示 只能写，不能读取
一般用于函数，多个返回值的情况

无符号：正数
byte -- uint8
rune -- int32
fallthrough 穿透

    aa:=3
    switch aa {
    case 3:
        fallthrough
    case 2:
        fallthrough
    case 1:
        fmt.Println(aa)
    case 5:
        fmt.Println(aa)
    case 10:
        fmt.Println(aa)
        fmt.Println("12123131")
        fmt.Println("2333333")
        fallthrough
    case 32:
        fmt.Println(aa)
    }

没有while关键字

    i:=1
    for  {
        i++
        fmt.Println(i)
        if i>1000 {
            break
        }
    }

for变形写法

for i:=1;;{
        i++
        fmt.Println(i)
        if i>1000 {
            break
        }
    }
    i:=1
    for ;;{
        i++
        fmt.Println(i)
        if i>2000 {
            break
        }
    }

随机数= =。。

    fmt.Println(time.Now())
    fmt.Printf("%T\n",time.Now())
    timestmp:=time.Now().Unix()//秒的时间戳

    fmt.Println(timestmp)

    timestmp1:=time.Now().UnixNano()//纳秒的时间戳
    fmt.Println(timestmp1)

    rand.Seed(timestmp1)//获取随机数的种子数
    fmt.Println(rand.Intn(10))

数组是定长的

    var a = [5]int{1, 2, 3, 4, 5}
    fmt.Println(a)
    var b = [5]int{1: 1, 2: 3}
    fmt.Println(b)
    c := [...]int{1, 2, 3, 4} //长度自动推断
    fmt.Println(c)
    d := [...]int{1: 3, 2: 6} //长度自动推断
    fmt.Println(d)
    e := [5]string{"1", "2", "3", "4", "5"}
    
    for i := 0; i < len(e); i++ {

        fmt.Print(a[i])
        if i == len(e)-1 {
            fmt.Println("")
        }
    }

    for _, value := range e {
        fmt.Print(value, "\n")
    }

    for index, value := range a {
        fmt.Println(index, value)
    }


[1 2 3 4 5]
[0 1 3 0 0]
[1 2 3 4]
[0 3 6]
12345
1
2
3
4
5
0 1
1 2
2 3
3 4
4 5

切片 抽象的数组 slice
是一个引用类型的容器，指向一个底层数组

s2 := []int{1, 2, 3, 4}
    fmt.Println(s2)
    s3 := [5]int{1, 2, 3, 4}

    fmt.Printf("%T,%T\n", s1, s3)

    s4 := make([]int, 3, 10) //切片类型、长度、容量
    fmt.Println(len(s4), cap(s4))
    s4[0] = 1
    s4[1] = 2
    s4[2] = 3
    s4 = append(s4, 5, 1, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3) //超过容量的话，会重新分配地址，所以最好还是指向原来的
    fmt.Println(s4)
    fmt.Println(len(s4), cap(s4))

    s4 = append(s4, s2...) //超过容量的话，会自动扩容（成倍），重新分配地址，所以最好还是指向原来的
    fmt.Println(len(s4), cap(s4))

    aa := [10]int{1, 2, 3, 4, 5, 5, 56, 6, 6, 6}
    s5 := aa[0:3]//下标0-3的，包含边界值
    fmt.Println(s5)
    s9 := aa[2:]//下标2后边所有的，包含下标2的元素
    fmt.Println(s9)

       q := []int{4, 5, 6, 7}
    r := []int{111,222,333}
    r = append(r,q...)//只能拼接两个切片= =。。
    fmt.Println("拼接后的切片%v",r)

深浅拷贝
因为切片是引用类型，直接拷贝的是地址。属于浅拷贝，引用类型的copy都是浅copy
深copy 拷贝的是数据本身

    s2 := []int{1, 2, 3, 4}
    s6 := []int{
        233, 123, 456, 678, 789}
      copy(s6, s2)
    fmt.Println("拷贝之后的数组", s6)

拷贝之后的数组 [1 2 3 4 789]

会覆盖掉相同下标