init()初始化函数 - Golang教程网

package

package 包名

注意：

一个文件夹下面只能有一个包，同样一个包的文件不能改在多个文件夹下。
包名和文件夹名可以不一样，包名不能包括-符号。
包名为main的包为应用程序的入口包，编译时不包含main包的源代码时不会得到可执行文件。

如果想在一个包中引用另一个包里的标识符（如变量、常量、类型、函数等），该标识符必须是对外可见的（public）。在Go语言中只需要将标识符的首字母大写就可以让标识符对外可见。

包的导入

import "包的路径"

注意：

双引号$GOPATH/src/

import "包名1"
import (
  "包名2"   //系统包

  "包名3"  //自定义包
)

示例代码：

自定义包名

package 别名 包名

匿名导入包
只希望导入包，而不使用包内部的数据。
匿名导入的包与其它导入的包一样都会编译到可执行过文件中。

package _ "包的路径"

init()初始化函数

init()init()

导入包顺序

Demo

目录结构是src/code/lvdx6/com/backend/testproject下的main和test目录

package main

import (
    "fmt"

    "code/lvdx6/com/backend/testproject/test"
)

func init(){
    fmt.Println("main package main.go init()")
}

func main(){
    fmt.Println("main package main.go调用test package的test.go中的方法")
    test.Test()
    fmt.Println("main package main.go调用同一个包下的haha.go中的方法")
    Haha() 
}

package main


import "fmt"

func init() {
    fmt.Println("main package haha.go init()")
}

func Haha() {
    fmt.Println("main package haha.go")
}

package test

import "fmt"

func init() {
    fmt.Println("test package test.go init()")
}

func Test() {
    fmt.Println("test package test.go")
}

输出结果是

# go run main.go haha.go
test package test.go init()
main package main.go init()
main package haha.go init()
main package main.go调用test package的test.go中的方法
test package test.go
main package main.go调用同一个包下的haha.go中的方法
main package haha.go

time包

package main

import (
    "fmt"
    "time"
)

func main(){
    now := time.Now()
    fmt.Printf("当前时间是：%#v\n", now)

    year := now.Year()
    month := now.Month()
    day := now.Day()
    hour := now.Hour()
    minute := now.Minute()
    second := now.Second()
        //获取纳秒
    // ns := now.Nanosecond()
    fmt.Printf("当前时间是：%d-%02d-%02d %02d:%02d:%02d\n", year, month, day, hour, minute, second)
}
输出结果是
当前时间是：time.Time{wall:0xbfafe8044ab66a98, ext:5005601, loc:(*time.Location)(0x58bb80)}
当前时间是：2020-06-09 14:13:37

time.Unix()

package main

import (
    "fmt"
    "time"
)

func main(){
    now := time.Now()
    fmt.Printf("当前时间是：%#v\n", now)

    //获取时间戳
    timestamp1 := now.Unix()
    timestamp2 := now.UnixNano()
    fmt.Printf("当前时间戳是：%#v\n", timestamp1)
    fmt.Printf("当前时间戳（纳秒）是：%#v\n", timestamp2)

    //使用time.Unix()函数讲时间戳转为时间格式
    timeObj := time.Unix(timestamp1, 0)
    fmt.Println(timeObj)
    fmt.Printf("使用time.Unix()函数讲时间戳转为时间格式是：%#v\n", timeObj)
    fmt.Printf("当前时间是：%d-%02d-%02d %02d:%02d:%02d\n", timeObj.Year(), timeObj.Month(), timeObj.Day(), timeObj.Hour(), timeObj.Minute(), timeObj.Second())
}

时间格式化
使用Format进行格式化，不是常见的Y-m-d H:M:S格式化，而是使用Go的诞生时间2006年1月2号15点04分（2006 1 2 3 4）。

2006表示年
1、01表示月，带0表示2位数，不带0是原始
2、02表示日，带0表示2位数，不带0是原始
15表示小时
4、04表示分，带0表示2位数，不带0是原始
5、05表示秒，带0表示2位数，不带0是原始
000、999表示纳秒

package main

import (
    "fmt"
    "time"
)

func main(){
    now := time.Now()
    fmt.Println(now.Format("2006-01-02 15:04:05"))
    fmt.Println(now.Format("2006-1-2 15:4:5"))
    fmt.Println(now.Format("2006/01/02 15:04:05"))
    fmt.Println(now.Format("15:04:05 2006/01/02"))
    fmt.Println(now.Format("2006/01/02"))

    // 纳秒
    fmt.Println(now.Format("2006-01-02 15:04:05.000"))
    fmt.Println(now.Format("2006-01-02 15:04:05.999"))
}
输出结果是
2020-06-09 16:47:19
2020-6-9 16:47:19
2020/06/09 16:47:19
16:47:19 2020/06/09
2020/06/09
2020-06-09 16:47:19.575
2020-06-09 16:47:19.575

time.Tick(时间间隔)

package main

import (
    "fmt"
    "time"
)

func main(){
    //定义一个1秒间隔的定时器
    ticker := time.Tick(time.Second)
    for i := range ticker {
        //每秒都会执行的任务
        func(){
            fmt.Println(i)
        }()
    }
}

Duration类型纳秒

const (
    Nanosecond  Duration = 1
    Microsecond          = 1000 * Nanosecond
    Millisecond          = 1000 * Microsecond
    Second               = 1000 * Millisecond
    Minute               = 60 * Second
    Hour                 = 60 * Minute
)

time小练习

package main

import (
    "fmt"
    "time"
)

func formatTime(t time.Time) string {
    return t.Format("2006/01/02 15:04:05")
}

//计算一段代码执行微秒数
func calTime() {
    //方法一：
    start := time.Now().UnixNano() / 1000
    time.Sleep(time.Millisecond * 30)
    end := time.Now().UnixNano() / 1000
    fmt.Printf("耗费了%d微秒\n", end - start)

    //方法二：
    start2 := time.Now()
    time.Sleep(time.Millisecond * 30)
    fmt.Printf("耗费了%d微秒\n", time.Since(start2) / 1000)
}

func main(){
    now := time.Now()
    newTime := formatTime(now)
    fmt.Println(newTime)

    calTime()
}
输出结果是
2020/06/09 19:34:05
耗费了30020微秒
耗费了30040微秒