Golang——包

作者: Cici冬雪 | 来源:发表于2020-06-09 19:36 被阅读0次

linux下golang的安装
01 mac-go开发环境搭建
golang环境准备
Golang开发环境设置
centos安装golang
Closure in Golang
golang中encoding/pem包
win10下 Golang 开发环境搭建
Golang——包
Golang基础（一）

包package是源码(.go文件)的集合。

package 包名

注意：

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

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

包的导入

import "包的路径"

注意：

import导入语句通常放到文件开头包声明语句的下面。
导入的包名需要使用双引号包裹起来。
报名是从$GOPATH/src后开始计算的，使用/进行路径分隔。

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

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

示例代码：

自定义包名

package 别名 包名

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

package _ "包的路径"

init()初始化函数

Go语言在导入包时候自动出发内部的init()函数调用。
init()函数没有参数也没有返回值，在程序中自动调用执行，不能主动去调用。

image.png

导入包顺序

image.png

Demo

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

image.png

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

时间戳
从1970年1月1日（08:00:00GMT）至当前时间的总毫秒数，也被成为Unix时间戳（UnixTimestamp）。
使用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类型代表两个时间点之间经过的时间，以纳秒为单位。可表示的最长时间段大约为290年。定义的时间间隔常量如下：

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微秒