slice

布尔型：t
　　整　型：d
　　浮点型：g
　　复数型：g
　　字符串：s
　　通　道：p
　　指　针：p

需要说明，slice 并不是数组或数组指针。它通过内部指针和相关属性引 用数组片段，以 实现变长方案

使 make 动态创建 slice，避免了数组必须用 常量做 长度的 麻烦。还可 用指针直接访问 底层数组，退化成普通数组操作。

s := []int{0, 1, 2, 3}

p := &s[2] // *int, 获取底层数组元素指针。
**p += 100
fmt.Println(s)
输出
[0 1 102 3]

MAP

myMap = make(map[string] PersonInfo)    //创建  string 键类型  PersonInfo 值类型

package main

import "fmt"

type PersonInfo struct {
    ID      string
    Name    string
    Address string
}

func main() {
    var personDB map[string]PersonInfo
    personDB = make(map[string]PersonInfo)

    personDB["12345"] = PersonInfo{"12345", "Tom", "Room 203,..."}
    personDB["1"] = PersonInfo{"1", "Jack", "Room 101,..."}
    person, ok := personDB["12345"]
    if ok {
        fmt.Println("Found person", person.Name, "with ID 1234.")
    } else {
        fmt.Println("Did not find person with ID 1234.")
    }
}

switch

package main

import "fmt"



func main() {
    var Num int = 1
    
    switch {
    case 0 <= Num && Num <= 3:
        fmt.Printf("0-3")
    case 4 <= Num && Num <= 6:
        fmt.Printf("4-6")
    case 7 <= Num && Num <= 9:
        fmt.Printf("7-9")
    }

}

package main

import "fmt"

func main() {
    var i int = 1
    switch i {
    case 0:
        fmt.Printf("0")
    case 1:
        fmt.Printf("1")
    case 2:
        fallthrough
    case 3:
        fmt.Printf("3")
    case 4, 5, 6:
        fmt.Printf("4, 5, 6")
    default:
        fmt.Printf("Default")
    }

}

循环语句

跳转语句

函数不定参数

package main

import "fmt"

func main() {
    myfunc(1, 2, 3, 4, 5)
}
func myfunc(args ...int) {
    for _, arg := range args {
        fmt.Println(arg)
    }
}

package main

import "fmt"

func main() {
    var v1 int = 1
    var v2 int64 = 234
    var v3 string = "hello"
    var v4 float32 = 1.234
    MyPrintf(v1, v2, v3, v4)
}
func MyPrintf(args ...interface{}) {
    for _, arg := range args {
        switch arg.(type) {
        case int:

            fmt.Println(arg, "is an int value.")
        case string:
            fmt.Println(arg, "is a string value.")
        case int64:
            fmt.Println(arg, "is an int64 value.")
        default:
            fmt.Println(arg, "is an unknown type.")
        }
    }
}

package main

import (
    "fmt"
)

type User struct {
    id   int
    name string
}
type Manager struct {
    User
    title string
}

func main() {
    m := Manager{User{1, "Tom"}, "Administrator"}
    var u User = m.User
    fmt.Println(m, u)
}


//输出 :   {{1 Tom} Administrator} {1 Tom}