15-Go语言time和strconv包

最新推荐文章于 2023-05-11 07:53:24 发布

置顶爱写代码的小男孩

最新推荐文章于 2023-05-11 07:53:24 发布

阅读量440

点赞数 2

分类专栏： Golang 文章标签： golang 运维开发后端

本文链接：https://blog.csdn.net/weixin_38753143/article/details/125582974

版权

Golang 专栏收录该内容

36 篇文章 8 订阅

订阅专栏

time包

时间和日期是我们编程中经常会用到的，本文主要介绍了Go语言内置的time包的基本用法。time包提供了一些关于时间显示和测量用的函数。time包中日历的计算采用的是公历，不考虑润秒。

时间类型

Go语言中使用的time.Time类型表示时间。我们可以通过time.Now函数获取当前的时间对象，然后从时间对象中可获取到年、月、日、时、分、秒等信息。

func timeDemo1() {
	now := time.Now() //获取当前时间
	fmt.Printf("current time:%v\n", now)

	year := now.Year()      //年
	month := now.Month()    //月
	day := now.Day()        //日
	hour := now.Hour()      //时
	miniute := now.Minute() //分
	second := now.Second()  //秒
	fmt.Println(year, month, day, hour, miniute, second)

}

Location 和time zone

Go语言中使用location来映射具体的时区。时区（Time Zone）是根据世界各国家与地区不同的经度而划分的时间定义，全球共分为24个时区。中国差不多跨5个时区，但为了使用方便只用东八区的标准时即北京时间为准。

下面的示例代码中使用beijing来表示东八区8小时的偏移量，其中time.FixedZone和time.LoadLocation这两个函数则用来获取location的信息。

// timezoneDemo时区示例
func timezoneDemo() {
	//中国没有夏令时，使用一个固定的8小时差。
	secondsEastOFUTC := int((8 * time.Hour).Seconds())
	//FixedZone 返回始终使用给定区域名和偏移量（UTC 以东秒）的Location。
	beijing := time.FixedZone("Beijing Time", secondsEastOFUTC)
	fmt.Println(beijing)

	//如果当前系统有时区数据库，则可以加载一个位置到对应的时区
	//例如，加载纽约所在时区
	newYork, err := time.LoadLocation("America/New_York") //UTC-05:00
	if err != nil {
		fmt.Println("load NewYork location failed", err)
		return
	}
	fmt.Println(newYork)
	//加载上海所在时区
	shanghai, err := time.LoadLocation("Asia/Shanghai") //UTC+08:00
	//加载东京所在时区
	tokey, err := time.LoadLocation("Asia/Tokyo") //UTC+09:00
	fmt.Println(shanghai, tokey)

	//创建时间对象需要指定位置。常用的位置是time.Local(当地时间)和time.UTC(Utc时间)
	timeInUTC := time.Date(2009, 1, 1, 12, 0, 0, 0, time.UTC)
	sameTimeBeijing := time.Date(2009, 1, 1, 12, 0, 0, 0, beijing)
	sameTimeNewYork := time.Date(2009, 1, 1, 12, 0, 0, 0, newYork)

	//北京时间比UTC早8小时，纽约时间比UTC晚5小时。所以上面两个实际表示的一个时间
	timesAreEqual := timeInUTC.Equal(sameTimeBeijing)
	timesAreEqual1 := timeInUTC.Equal(sameTimeNewYork)

	fmt.Println(timesAreEqual, timesAreEqual1)
}

Unix Time

Unix Time是自1970年1月1日 00:00:00 UTC 至当前时间经过的总秒数。下面的代码片段演示了如何基于时间对象获取到Unix 时间。

//timestampDemo时间戳
func timestampDemo() {
	now := time.Now()        //获取当前时间
	timesamp := now.Unix()   //秒级时间戳
	milli := now.UnixMilli() //毫秒shijianch
	micro := now.UnixMicro() //微妙时间戳
	nano := now.UnixNano()   //纳秒时间戳
	fmt.Println(timesamp, milli, micro, nano)

}

time包还提供了一系列将int64类型的时间戳转换为时间对象的方法。

//timesamp2Time将时间戳转为时间对象
func timesamp2Time() {
	//获取北京时间所在东八区时区对象
	secondsEastOFUTC := int((8 * time.Hour).Seconds())
	beijing := time.FixedZone("Beijing Time", secondsEastOFUTC)

	//北京时间2022-02-22 22:22:22.000000022 +0800 CST
	t := time.Date(2022, 02, 22, 22, 22, 22, 22, beijing)

	var (
		sec  = t.Unix()
		mesc = t.UnixMilli()
		usec = t.UnixMicro()
	)

	//将秒级时间戳转为时间对象（第二个参数为不足1秒的纳秒数）
	timeObj := time.Unix(sec, 22)
	fmt.Println(timeObj) //2022-02-22 22:22:22.000000022 +0800 CST
	timeObj1 := time.UnixMilli(mesc)
	fmt.Println(timeObj1) //2022-02-22 22:22:22 +0800 CST
	timeObj2 := time.UnixMicro(usec)
	fmt.Println(timeObj2) //2022-02-22 22:22:22 +0800 CST

}

时间间隔

time.Duration是time包定义的一个类型，它代表两个时间点之间经过的时间，以纳秒为单位。

time.Duration表示一段时间间隔

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

例如：time.Duration表示1纳秒，time.Second表示1秒。

时间操作

Add

Go语言的时间对象有提供Add方法如下：

func (t Time) Add(d Duration) Time

举个例子，⚽️一个小时的时间

func add() {
	now := time.Now()
	later := now.Add(time.Hour)
	fmt.Println(later)
}

Sub

求两个时间之间的差值：

func (t Time) Sub(u Time) Duration

返回一个时间段t-u。如果结果超出了Duration可以表示的最大值/最小值，将返回最大值/最小值。要获取时间点t-d（d为Duration），可以使用t.Add(-d)。

Equal

func (t Time) Equal(u Time) bool

判断两个时间是否相同，会考虑时区的影响，因此不同时区标准的时间也可以正确比较。本方法和用t==u不同，这种方法还会比较地点和时区信息。

Before

func (t Time) Before(u Time) bool

如果t代表的时间点在u之前，返回真；否则返回假。

After

func (t Time) After(u Time) bool

如果t代表的时间点在u之后，返回真；否则返回假。

定时器

使用time.Tick（时间间隔）来设置定时器，定时器本质上是一个通道(channel)。

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

时间格式化

time.Format函数能将一个时间对象格式化输出为指定布局的文本表示形式，需要注意的是GO语言中时间格式化不是常见的Y-m-d H:M:S,而是使用2006-01-02 13:04:05.000。

其中

2006：年（Y）
01：月（m）
02：日（d）
15：时（H）
04：分（M）
05：秒（S）

补充

如果想格式化为12小时格式，需在格式化布局中添加PM。
小数部分想保留指定位数就写0，如果想省略末尾可能的0就写 9。

//formatDemo时间格式化
func formatDemo() {
	now := time.Now()

	//格式化模版为 2006-01-02 15:04:05

	//24小时制
	fmt.Println(now.Format("2006-01-02 15:04:05 Mon Jan")) //2022-03-01 09:31:16 Tue Mar
	//12小时制
	fmt.Println(now.Format("2006-01-02 15:04:05 PM Mon Jan")) //2022-03-01 09:31:16 AM Tue Mar

	//小数点后写0，因为有3个0所以格式化输出的结果也保留3为小数
	fmt.Println(now.Format("2006/01/02 14:04:05.000")) //2022/03/01 331:31:16.377
	//小数点后写9，会省略末尾可能出现的0
	fmt.Println(now.Format("2006/01/02 14:04:05.999")) //2022/03/01 331:31:16.377

	//只格式化时分秒部分
	fmt.Println(now.Format("15:04:05")) //09:31:16
	//只格式化日期部分
	fmt.Println(now.Format("2006.01.02")) //2022.03.01

}

解析字符串格式的时间

对于从文本的时间表示中解析时间对象，time包中提供了time.Parse和time.ParseInLocation两个函数。

func parseDemo() {
	//在没有时区指示符的情况下，time.Parse返回的是UTC时间
	timeObj, err := time.Parse("2006/01/02 15:04:05", "2022/10/05 11:25:20")
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(timeObj) //2022-10-05 11:25:20 +0000 UTC

	//在有时区指示符的情况下，time.Parse返回对应时区的时间表示
	// RFC3339     = "2006-01-02T15:04:05Z07:00"
	timeObj1, err := time.Parse(time.RFC3339, "2022-10-05T11:25:20+08:00") 
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(timeObj1)//2022-10-05 11:25:20 +0800 CST
}

time.ParseInLocation函数需要在解析时额外指定时区信息。

func parseDemo1() {
	now := time.Now()
	fmt.Println(now) //2022-03-01 10:20:55.807453 +0800 CST m=+0.000081141
	//加载时区
	loc, err := time.LoadLocation("Asia/Shanghai")
	if err != nil {
		fmt.Println(err)
		return
	}

	//按照指定的时区和指定格式解析字符串时间
	timeObj, err := time.ParseInLocation("2006/01/02 15:04:05", "2022/10/05 11:25:20", loc)
	if err != nil {
		return
	}
	fmt.Println(timeObj)          //2022-10-05 11:25:20 +0800 CST
	fmt.Println(timeObj.Sub(now)) //5233h4m24.192547s
}

练习

1、获取当前时间，格式化输出为2017/06/19 20:30:05格式

//1、获取当前时间，格式化输出为2017/06/19 20:30:05格式
func ex1() {
	now := time.Now()
	fmt.Println(now.Format("2006/01/02 15:04:05")) //2022/03/01 10:26:30
}

2、编写程序统计一段代码的执行耗时时间，单位精确到微秒

//2、编写程序统计一段代码的执行耗时时间，单位精确到微秒
func ex2() {
	start := time.Now().UnixMicro()
	for i := 0; i < 10; i++ {
		time.Sleep(time.Second)
	}
	end := time.Now().UnixMicro()
	duration := end - start
	fmt.Println(duration) //10023133
}

strconv包

strconv包实现了基本数据类型与其字符串表示的转换，主要有以下常用的函数：Atoi()、Itoa()、parse系列、format系列，append系列。

string与int类型转换

这一组函数是平时编程用的最多的。

Atoi()

Atoi()函数用于将字符串类型的整数转换为int类型，函数签名如下：

func Atoi(s string)(i int,err error)

如果传入的字符串参数无法转换为int类型，就会返回错误。

func atoiDemo1() {
	s1 := "100"
	i1, err := strconv.Atoi(s1)
	if err != nil {
		fmt.Println("can't convert to int")
	} else {
		fmt.Printf("type :%T value: %v\n", i1, i1) //type :int value: 100
	}
}

Itoa()

Itoa()函数用于将int类型数据转换为对用的字符串表示，具体的函数签名如下。

func Itoa(i int)string

示例代码：

func itoademo() {
	i1 := 200
	s := strconv.Itoa(i1)
	fmt.Printf("type :%T value: %v\n", s, s) //type :string value: 200
}

parse系列函数

Parse类函数用于转换字符串为给定类型的值：ParseBool() ParseFloat() ParseInt() ParseUint()。

ParseBool()

func ParseBool(str string)(value bool,err error)

返回字符串表示的bool值。它接受1、0、t、f、T、F、true、false、True、False、TRUE、FALSE；否则返回错误。

ParseInt()

func ParseInt(s string, base int, bitSize int) (i int64, err error)

返回字符串表示的整数值，接受正负号。

base指定进制（2到36），如果base为0，则会从字符串前置判断，”0x”是16进制，”0”是8进制，否则是10进制；

bitSize指定结果必须能无溢出赋值的整数类型，0、8、16、32、64 分别代表 int、int8、int16、int32、int64；

返回的err是*NumErr类型的，如果语法有误，err.Error = ErrSyntax；如果结果超出类型范围err.Error = ErrRange。

ParseUnit()

func ParseUint(s string, base int, bitSize int) (n uint64, err error)

ParseUint类似ParseInt但不接受正负号，用于无符号整型。

ParseFloat()

func ParseFloat(s string, bitSize int) (f float64, err error)

解析一个表示浮点数的字符串并返回其值。

如果s合乎语法规则，函数会返回最为接近s表示值的一个浮点数（使用IEEE754规范舍入）。

bitSize指定了期望的接收类型，32是float32（返回值可以不改变精确值的赋值给float32），64是float64；

返回值err是*NumErr类型的，语法有误的，err.Error=ErrSyntax；结果超出表示范围的，返回值f为±Inf，err.Error= ErrRange。

代码示例

func parseDemo5() {
	b, err := strconv.ParseBool("true")
	f, err := strconv.ParseFloat("3.1415", 64)
	i, err := strconv.ParseInt("-2", 10, 64)
	u, err := strconv.ParseUint("-2", 10, 64)
}

Format系列函数

Format系列函数实现了将给定类型数据格式化为string类型数据的功能。

FormatBool()

func FormatBool(b bool) string

根据b的值返回”true”或”false”。

FormatInt()

func FormatInt(i int64, base int) string

返回i的base进制的字符串表示。base 必须在2到36之间，结果中会使用小写字母’a’到’z’表示大于10的数字。

FormatUint()

func FormatUint(i uint64, base int) string

是FormatInt的无符号整数版本。

FormatFloat()

func FormatFloat(f float64, fmt byte, prec, bitSize int) string

函数将浮点数表示为字符串并返回。

bitSize表示f的来源类型（32：float32、64：float64），会据此进行舍入。

fmt表示格式：’f’（-ddd.dddd）、’b’（-ddddp±ddd，指数为二进制）、’e’（-d.dddde±dd，十进制指数）、’E’（-d.ddddE±dd，十进制指数）、’g’（指数很大时用’e’格式，否则’f’格式）、’G’（指数很大时用’E’格式，否则’f’格式）。

prec控制精度（排除指数部分）：对’f’、’e’、’E’，它表示小数点后的数字个数；对’g’、’G’，它控制总的数字个数。如果prec 为-1，则代表使用最少数量的、但又必需的数字来表示f。

代码示例

s1 := strconv.FormatBool(true)
s2 := strconv.FormatFloat(3.1415, 'E', -1, 64)
s3 := strconv.FormatInt(-2, 16)
s4 := strconv.FormatUint(2, 16)

爱写代码的小男孩

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录