package main
​
import (
    "fmt"
    "time"
)
​
/*
全局变量:常驻内存 污染全局
局部变量:不常驻内存 不会污染全局
闭包:可以让一个变量常驻内存 并且不污染全局
​
*/
//闭包handler 内部函数引用外部函数变量
func bb() func(y int) int {
    bbnum := 10
    return func(y int) int {
        bbnum += y
        return bbnum
    }
}
​
type newfunc func(int, int) int //定义一个函数格式 为  newfunc
// 求两个数的和 两个参数类型相同 前面参数的int可以省略 多个返回值 用括号括起来 逗号隔开
func add(a, b int) int {
    return a + b
}
func returndata(a, b int) (int, int) {
    return a, b
}
​
func newfunc2(a, b int, c newfunc) int {
    return c(a, b)
}
​
// 直接给返回值命名 直接通过return返回
func returndata2(a, b int) (c int, d int) {
    c = a
    d = b
    return
}
​
// 可变参数 无限参数 传来的参数 默认合并为一个切片
func add2(a ...int) int {
    sum := 0
    for _, v := range a {
        sum += v
    }
    return sum
}
​
// 递归函数 求出数字递减的和
func dg(n int) int {
    if n == 1 {
        return 1
    } else {
        return n + dg(n-1)
    }
}
​
// panic 异常处理 程序崩溃 停止运行
// recover 异常恢复 程序继续运行 只能在defer中使用
func panicTest() {
    defer func() {
        if err := recover(); err != nil {
            fmt.Println("recover:", err)
        }
    }()
    panic("这是一个错误")
}
​
func main() {
    //调用函数
    result := add(10, 20)
    //打印结果
    println(result)
    result2 := add2(10, 20, 30, 40, 50)
    println(result2)
    a, b := returndata(10, 20)
    println(a, b)
    c, d := returndata2(10, 20)
    println(c, d)
    //匿名函数 自动执行
    func(x int) {
        println(x)
    }(10)
    //也可以赋值给变量
    n := func(x int) int {
        return x * x
    }
    println(n(5))
    //定义参数为新建的函数格式
    f := newfunc(add) //给变量f赋值 调用add函数
    var g newfunc     //定义变量g 类型为newfunc
    g = add           //给变量g赋值 调用add函数
    println(f(10, 20))
    println(g(10, 20))
​
    h := newfunc2(10, 20, add) //调用函数 传入参数 10 20 调用add函数
    println(h)
​
    //defer 延迟调用 defer注册要延迟执行的函数时 该函数所有的参数都需要确定其值
    defer println("hello world")
    //使用匿名函数 多个defer 从下往上执行
    defer func() {
        println("defer func")
    }()
    // dg := dg(100)
    // println(dg)
    //闭包里面的变量 不会立即销毁 而是一直存在内存中 直到函数结束 不污染全局
    bbnum := bb()
    println(bbnum(10))     //20
    println(bbnum(10))     //30
    fmt.Println(bbnum(10)) //40
    panicTest()
    //日期函数
    year := time.Now().Year()
    month := time.Now().Month()
    day := time.Now().Day()
    hour := time.Now().Hour()
    minute := time.Now().Minute()
    second := time.Now().Second()
    days := time.Now().Weekday()
​
    fmt.Println("当前日期:", year, "年", month, "月", day, "日", hour, "时", minute, "分", second, "秒")
    fmt.Printf("当前日期: %02d 年 %02d 月 %02d 日 %02d 时 %02d 分 %02d 秒\n", year, month, day, hour, minute, second)
    fmt.Println("今天是星期", days)
    //骚操作 固定格式  2006-01-02 15:04:05 24小时制度  2006-01-02 03:04:05 12小时制度
    timestr := time.Now().Format("2006-01-02 15:04:05")
    fmt.Println(timestr)
    //时间戳 秒
    timenum := time.Now().Unix()
    timenum2 := time.Now().UnixMilli() //毫秒级
    timenum3 := time.Now().UnixNano()  //纳秒级
    //时间戳转时间对象
    timeobj := time.Unix(timenum, 0)
    timestr2 := timeobj.Format("2006-01-02 15:04:05")
    //str转时间对象
    timeobj2, _ := time.Parse("2006-01-02 15:04:05", timestr)
    //时间对象转时间戳
    timenum4 := timeobj2.Unix()
    //加时间
    timeobj3 := time.Now().Add(time.Hour)
    timestr3 := timeobj3.Format("2006-01-02 15:04:05")
    fmt.Println(timenum, timenum2, timenum3, timestr2, timenum4, timestr3)
    //定时器 每2秒执行一次
    timer := time.NewTicker(time.Second * 2)
    tic := 0
    for v := range timer.C {
        tic++
        if tic > 5 {
            timer.Stop() //停止定时器
            break
        }
        fmt.Println("定时器执行", v)
    }
    //休眠一秒
    time.Sleep(time.Second)
}
​

延伸阅读

golang使用gorm 操作数据库

学习golang(七)

学习golang(十)

学习golang(一)

学习golang(九)