package main

import (
    "fmt"
    "time"
)

func init() {
    fmt.Println("init1")
}
func init() {
    fmt.Println("init2")
}

// 无返回值
func say(name, msg string) {
    fmt.Println(name, msg)
}

// 指定类型返回值
func add(numList ...int) int {
    var sum int
    for _, num := range numList {
        sum += num
    }
    return sum
}

// 多个返回值
func fun1() (int, string) {
    return 1, "hello"
}

// 命名返回值
func func2() (OK bool) {
    OK = true
    return OK
}

// 高阶函数 1.接收一个函数作为参数 2.或者返回一个函数
func awaitAdd(waitSeconds int) func(numList ...int) int {
    //time.Second是Duration类型的, 本质是int64, waitSeconds是int类型的不允许隐式转换, 可以用time.Duration来显示转换
    time.Sleep(time.Duration(waitSeconds) * time.Second)
    return func(numList ...int) int {
        //闭包 可以访问外层的变量waitSeconds
        //time.Sleep(time.Duration(waitSeconds) * time.Second)
        sum := 0
        for _, num := range numList {
            sum += num
        }
        return sum
    }
}

func main() {
    say("Tom", "hello world")
    sum := add(5, 6, 7, 8)
    fmt.Println(sum)

    var getName = func(name string) string {
        return name
    }

    fmt.Println(getName("Tom"))
    var login = func() {
        fmt.Println("login func")
    }
    var register = func() {
        fmt.Println("register func")
    }
    // 映射函数
    funcMap := map[int]func(){
        1: login,
        2: register,
    }
    index := 1
    function, ok := funcMap[index]
    if ok {
        function()
    }
    start := time.Now()
    sum = awaitAdd(2)(1, 2, 3)
    // 计算时间差
    subTime := time.Since(start)
    fmt.Println(sum, subTime)
    // 取地址, 取值, 只有指针概念, 指针不能运算, 如p++之类的没有,没有引用概念,
    var test = "name"
    var tmp = &test
    *tmp = "new name"
    // 在return之前调用, 哪个写在后面, 哪个先调用, 压入的
    defer fmt.Println("defer1")
    defer fmt.Println("defer2")

    fmt.Println(test)

}

package main

import (
    "encoding/json"
    "fmt"
)

type Class struct {
    // 首字母大写, 可以包导出, 在其它包中可使用
    Name string
}
type Student struct {
    // 首字母小写, 只能本包中使用
    name      string `json:"name"` //配置json的Tag, 转成json时就是指定的名字了
    ClassName Class  `json:"className"`
    Test      int    `json:"test"`
    Password  string `json:"-"`             //这个字段不会转成json
    Age       int    `json:"age,omitempty"` //如果这个字段为空值, 此字段就不转json
    // 或者直接写Class, 一个类型名称就行了
}

// 值传递, 复制了整个Student结构
func (stu Student) SetName(name string) {
    fmt.Printf("SetName中stu的指针%p\n", &stu)
    stu.name = name
}

// 指针传递
// 警告说有值方法, 又有指针方法, Struct Student has methods on both value and pointer receivers. Such usage is not recommended by the Go Documentation.
func (stu *Student) SetName2(name string) {
    fmt.Printf("SetName2中stu的指针%p\n", stu)
    stu.name = name
}

type Animal struct {
    Name string
}
type Cat struct {
    Animal
}

func main() {
    var stu = Student{name: "Tom", ClassName: Class{"一年级"}}
    fmt.Printf("main中stu的指针%p\n", &stu)
    stu.ClassName.Name = "二年级"
    stu.SetName("newName")
    // 值传递不会改到stu的name, 里面修改的复制对象
    fmt.Println(stu)
    // 指针传递
    stu.SetName2("newName2")
    fmt.Println(stu)

    var cat Cat
    // 可以直接取对应成员的成员变量, 相当继承
    cat.Name = "cat"
    // 转成json
    byteData, err := json.Marshal(stu)
    if err != nil {
        fmt.Println(err)
    } else {
        fmt.Println(string(byteData))
    }
}

package main

import "fmt"

// 在go中, 自定义类型指的是使用type关键字定义的新类型, 它可以是基本类型的别名, 也可以是结构体, 函数等组合而成的新类型.
// 自定义类型可以帮助我们更好的抽象和封装数据, 让代码更加易读, 易懂, 易维护
type Code int      //自定义类型 类型定义
type MyCode = Code //类型别名, 类型名字打印类型时, 输出原始类型

// 类型别名不能绑定方法, 打印类型时是原始类型, 和原始类型比较, 类型不能转换
const (
    SuccessCode    Code = 0
    NetErrorCode   Code = 1
    OtherErrorCode Code = 2
)

// 相当于code对象了
func (code Code) getMsgCode() string {
    switch code {
    case SuccessCode:
        return "success"
    case NetErrorCode:
        return "net error"
    case OtherErrorCode:
        return "other error"
    }
    return "unknow code"
}
func (code Code) OK() (Code, string) {
    return code, code.getMsgCode()
}

func (code MyCode) Test() {
    fmt.Println(code.getMsgCode())
}

func webServer(name string) (code Code, msg string) {
    fmt.Println("Web Server:", name)
    switch name {
    case "animal":
        return SuccessCode.OK()
    case "animal2":
        return NetErrorCode.OK()
    case "animal3":
        return OtherErrorCode.OK()
    }
    return OtherErrorCode.OK()
}

func main() {
    myCode := new(MyCode)
    myCode.OK()
    fmt.Printf("myCode: %v, %T\n", myCode, myCode)
    var a Code = 1
    var b MyCode = 1
    if a == b {
        fmt.Println("a==b")
    } else {
        fmt.Println("a!=b")
    }
}

package main

import "fmt"

// 接口是一组权包含方法名, 参数, 返回的未具体实现的方法集合
// 接口默认是值传递
type SingInterface interface {
    Sing()
}

// 空接口可以接受任何类型, 任何类型都实现了空接口
type EmptyInterface interface{}
type Chicken struct {
    Name string
}

type Dog struct {
    Name string
}

func (chicken Chicken) Sing() {
    fmt.Println(chicken.Name, " is sing")
}

func (dog *Dog) Sing() {
    fmt.Println(dog.Name, " is sing")
}

func sing(singInterface SingInterface) {
    //接口断言, xx.(type)
    ch, OK := singInterface.(Chicken)
    if OK {
        fmt.Println("是chicken", ch)
    } else {
        fmt.Println("不是chicken")
    }
    singInterface.Sing()

    switch singInterface.(type) {
    case Chicken:
        fmt.Println("Chicken")
    case *Dog:
        fmt.Println("*Dog")
    default:
        fmt.Println("未知")
    }
}

func Print(empty EmptyInterface) {
    fmt.Println(empty)
}

// any = interface{}
func Print2(empty interface{}) {
    fmt.Println(empty)
}

func main() {
    c := Chicken{"Chicken"}
    d := Dog{"Dog"}

    sing(c)
    sing(&d)

    Print2(d)
}