golang时间转换
1.datetime转换成时间字符串
package main
import (
"fmt"
"reflect"
"time"
)
func main() {
now := time.Now() // 当前 datetime 时间
fmt.Println(reflect.TypeOf(now)) // 打印当前时间的类型
fmt.Println(now) // 打印当前时间
fmt.Println("***********************")
t1 := now.Format("2006-01-02 15:04:05") // 把当前 datetime 时间转换成时间字符串
fmt.Println(t1)
fmt.Println(reflect.TypeOf(t1))
}
程序执行结果
time.Time
2019-09-16 17:51:01.2357834 +0800 CST m=+0.004988701
***********************
2019-09-16 17:51:01
string
2.datetime转换成时间戳
package main
import (
"fmt"
"time"
)
func parse_datetime_to_timestamp(d time.Time) int64 {
unix_time := d.Unix()
return unix_time
}
func main() {
now := time.Now() // 当前 datetime 时间
t1 := parse_datetime_to_timestamp(now) // 转换成时间戳
tomorrow := now.AddDate(0, 0, +1) // 一天之后的 datetime 时间
t2 := parse_datetime_to_timestamp(tomorrow) // 转换成时间戳
fmt.Println(t1)
fmt.Println(t2)
}
程序执行结果
1568631868
1568718268
3.时间戳转换成时间字符串
package main
import (
"fmt"
"time"
)
func parse_timestamp_to_timestr(t int64, flag int) string {
var time_str string
if flag == 1 {
time_str = time.Unix(t, 0).Format("2006.01.02")
} else if flag == 2 {
time_str = time.Unix(t, 0).Format("2006-01-02 15:04:05")
} else if flag == 3 {
time_str = time.Unix(t, 0).Format("2006-01-02 15:04")
} else {
time_str = time.Unix(t, 0).Format("2006-01-02")
}
return time_str
}
func main() {
var t1 int64
t1 = 1567778332
str1 := parse_timestamp_to_timestr(t1,3)
fmt.Println(str1)
}
程序执行结果
2019-09-06 21:58
4.时间字符串转换成时间戳
package main
import (
"fmt"
"time"
)
func parse_timestr_to_timestamp(time_str string, flag int) int64 {
var t int64
loc, _ := time.LoadLocation("Local")
if flag == 1 {
t1, _ := time.ParseInLocation("2006.01.02 15:04:05", time_str, loc)
t = t1.Unix()
} else if flag == 2 {
t1, _ := time.ParseInLocation("2006-01-02 15:04", time_str, loc)
t = t1.Unix()
} else if flag == 3 {
t1, _ := time.ParseInLocation("2006-01-02", time_str, loc)
t = t1.Unix()
} else if flag == 4 {
t1, _ := time.ParseInLocation("2006.01.02", time_str, loc)
t = t1.Unix()
} else {
t1, _ := time.ParseInLocation("2006-01-02 15:04:05", time_str, loc)
t = t1.Unix()
}
return t
}
func main() {
time_str1 := "2019-09-16 00:00:00"
time_str2 := "2019-09-16 15:04"
time_str3 := "2019-09-16"
time_str4 := "2019.09.18"
t1 := parse_timestr_to_timestamp(time_str1,5)
fmt.Println(t1)
t2 := parse_timestr_to_timestamp(time_str2,2)
fmt.Println(t2)
t3 := parse_timestr_to_timestamp(time_str3,3)
fmt.Println(t3)
t4 := parse_timestr_to_timestamp(time_str4,4)
fmt.Println(t4)
}
程序执行结果
1568563200
1568617440
1568563200
1568736000
5.时间戳转换成datetime时间
package main
import (
"fmt"
"time"
)
func parse_timestamp_to_datetime(t int64) time.Time {
return time.Unix(t,0)
}
func main() {
var t1 int64
t1 = 1568634050
time1 := parse_timestamp_to_datetime(t1)
fmt.Println(time1)
}
程序执行结果
2019-09-16 19:40:50 +0800 CST
6.时间字符串转换成时间戳
package main
import (
"fmt"
"time"
)
func parse_timestr_to_datetime(time_str string, flag int) time.Time {
if flag == 1 {
t, error1 := time.Parse("2006-01-02 15:04:05", time_str)
if error1 != nil {
panic(error1)
}
return t
} else if flag == 2 {
t, error2 := time.Parse("2006-01-02 15:04", time_str)
if error2 != nil {
panic(error2)
}
return t
} else if flag == 3 {
t, error3 := time.Parse("2006-01-02", time_str)
if error3 != nil {
panic(error3)
}
return t
} else if flag == 4 {
t, error4 := time.Parse("2006.01.02 15:04:05", time_str)
if error4 != nil {
panic(error4)
}
return t
} else if flag == 5 {
t, error5 := time.Parse("2006.01.02 15:04", time_str)
if error5 != nil {
panic(error5)
}
return t
} else {
t, err := time.Parse("2006.01.02", time_str)
if err != nil {
panic(err)
}
return t
}
}
func main() {
time_str1 := "2019-09-16 15:04:05"
t1 := parse_timestr_to_datetime(time_str1, 1)
fmt.Println(t1)
time_str2 := "2019-09-16 15:04"
t2 := parse_timestr_to_datetime(time_str2, 2)
fmt.Println(t2)
time_str3 := "2019-09-16"
t3 := parse_timestr_to_datetime(time_str3, 3)
fmt.Println(t3)
time_str4 := "2019.09.16 15:04:05"
t4 := parse_timestr_to_datetime(time_str4, 4)
fmt.Println(t4)
time_str5 := "2019.09.16 15:04"
t5 := parse_timestr_to_datetime(time_str5, 5)
fmt.Println(t5)
time_str6 := "2019.09.16"
t6 := parse_timestr_to_datetime(time_str6, 6)
fmt.Println(t6)
}
程序执行结果
2019-09-16 15:04:05 +0000 UTC
2019-09-16 15:04:00 +0000 UTC
2019-09-16 00:00:00 +0000 UTC
2019-09-16 15:04:05 +0000 UTC
2019-09-16 15:04:00 +0000 UTC
2019-09-16 00:00:00 +0000 UTC
7.日期加减操作
package main
import (
"fmt"
"time"
)
func main() {
now := time.Now() // 当前 datetime时间
tomorrow := now.AddDate(0, 0, +1) // 一天之后的时间
fmt.Println(tomorrow)
day_after_15 := now.AddDate(0, 0, -15) // 15天之前的时间
fmt.Println(day_after_15)
}
程序执行结果
2019-09-17 17:55:59.4755575 +0800 CST
2019-09-01 17:55:59.4755575 +0800 CST
总结：
import (
"fmt"
"time"
)
func parse_datetime_to_timestr(t time.Time, flag int) string {
/**
把 datetime 转换成 时间字符串
t: datetime 时间，比如：2019-09-17 09:45:42.5962359 +0800 CST m=+0.003989201
flag: 标识位，决定输出的时间字符串的格式
*/
var time_str string
if flag == 1 {
time_str = t.Format("2006-01-02 15:04:05")
} else if flag == 2 {
time_str = t.Format("2006-01-02 15:04")
} else if flag == 3 {
time_str = t.Format("2006-01-02")
} else if flag == 4 {
time_str = t.Format("2006.01.02 15:04:05")
} else if flag == 6 {
time_str = t.Format("2006.01.02 15:04")
} else {
time_str = t.Format("2006.01.02")
}
return time_str
}
func parse_datetime_to_timestamp(t time.Time) int64 {
/**
把 datetime 转换成时间戳
t: datetime 时间
*/
return t.Unix()
}
func parse_timestr_to_datetime(time_str string, flag int) time.Time {
/**
把时间字符串转换成 datetime 时间
time_str: 时间字符串，比如：2019-09-17 15:04:05
flag: 标识位，决定输入的时间字符串的格式
*/
if flag == 1 {
t, error1 := time.Parse("2006-01-02 15:04:05", time_str)
if error1 != nil {
panic(error1)
}
return t
} else if flag == 2 {
t, error2 := time.Parse("2006-01-02 15:04", time_str)
if error2 != nil {
panic(error2)
}
return t
} else if flag == 3 {
t, error3 := time.Parse("2006-01-02", time_str)
if error3 != nil {
panic(error3)
}
return t
} else if flag == 4 {
t, error4 := time.Parse("2006.01.02 15:04:05", time_str)
if error4 != nil {
panic(error4)
}
return t
} else if flag == 5 {
t, error5 := time.Parse("2006.01.02 15:04", time_str)
if error5 != nil {
panic(error5)
}
return t
} else {
t, err := time.Parse("2006.01.02", time_str)
if err != nil {
panic(err)
}
return t
}
}
func parse_timestr_to_timestamp(time_str string, flag int) int64 {
/**
把时间字符串转换成时间戳
time_str: 时间字符串，比如：2019-09-17 09:45:42
flag: 标识位，决定传入的时间字符串的格式
*/
var t int64
loc, _ := time.LoadLocation("Local")
if flag == 1 {
t1, _ := time.ParseInLocation("2006.01.02 15:04:05", time_str, loc)
t = t1.Unix()
} else if flag == 2 {
t1, _ := time.ParseInLocation("2006-01-02 15:04", time_str, loc)
t = t1.Unix()
} else if flag == 3 {
t1, _ := time.ParseInLocation("2006-01-02", time_str, loc)
t = t1.Unix()
} else if flag == 4 {
t1, _ := time.ParseInLocation("2006.01.02", time_str, loc)
t = t1.Unix()
} else {
t1, _ := time.ParseInLocation("2006-01-02 15:04:05", time_str, loc)
t = t1.Unix()
}
return t
}
func parse_timestamp_to_timestr(stamp int64, flag int) string {
/**
把时间戳转换成时间字符串
stamp: 时间戳，比如：1568685105，调用此方法时需先声明为 int64 类型
flag: 标识位，决定输入的时间字符串的格式
*/
var time_str string
if flag == 1 {
time_str = time.Unix(stamp, 0).Format("2006-01-02")
} else if flag == 2 {
time_str = time.Unix(stamp, 0).Format("2006-01-02 15:04:05")
} else if flag == 3 {
time_str = time.Unix(stamp, 0).Format("2006-01-02 15:04")
} else if flag == 4 {
time_str = time.Unix(stamp, 0).Format("2006.01.02 15:04:05")
} else if flag == 5 {
time_str = time.Unix(stamp, 0).Format("2006.01.02 15:04")
} else {
time_str = time.Unix(stamp, 0).Format("2006.01.02")
}
return time_str
}
func parse_timestamp_to_datetime(t int64) time.Time {
/**
时间戳转换成 datetime 时间
*/
return time.Unix(t, 0)
}
func get_after_day(day_range, flag int) time.Time {
/**
获取多少天,多少月或者多少年之前或之后的时间
day_range: 间隔的天数，月数或者年份数
flag: 决定是取天数，月数还是年数
*/
now := time.Now()
var tmp_day time.Time
if flag == 1 {
tmp_day = now.AddDate(day_range, 0, 0)
} else if flag == 2 {
tmp_day = now.AddDate(0, day_range, 0)
} else {
tmp_day = now.AddDate(0, 0, day_range)
}
return tmp_day
}
func get_after_time(time_range string) time.Time {
/**
获取多少小时，分钟及秒之前或之后的时间
time_range: 时间差，比如：
10h 获取10小时之后的时间
-10h 获取10小时之前的时间
10m 获取10分钟之后的时间
-10m 获取10分钟之后的时间
10s 获取10秒之后的时间
-10s 获取10秒之后的时间
*/
m, _ := time.ParseDuration(time_range)
tmp := time.Now().Add(m)
return tmp
}
func get_current(t time.Time) {
current_year := t.Year() // 获取年份
fmt.Println(current_year)
current_month := t.Month() // 获取月份
fmt.Println(current_month)
current_day := t.Day() // 获取天数
fmt.Println(current_day)
current_hour := t.Hour() // 获取小时数
fmt.Println(current_hour)
current_minute := t.Minute() // 获取分钟数
fmt.Println(current_minute)
current_second := t.Second() // 获取秒数
fmt.Println(current_second)
current_nanosecond := t.Nanosecond() // 获取纳秒数
fmt.Println(current_nanosecond)
}
golang时间转换的更多相关文章
- golang 时间转换的问题
一般在获取到时间字符串,需要将时间字符串格式化为golang的"time.Time"对象的时候,通常有2个函数,分别是. time.Parse(layout, value stri ...
- [jquery]将当前时间转换成yyyymmdd格式
如题: function nowtime(){//将当前时间转换成yyyymmdd格式 var mydate = new Date(); var str = "" + mydate ...
- MySQL 日期、时间转换函数
MySQL 日期.时间转换函数:date_format(date,format), time_format(time,format) 能够把一个日期/时间转换成各种各样的字符串格式.它是 str_to ...
- java时间类型的转换/获取当前时间/将时间转换成String/将String转换成时间
对于我的脑子,我已经服气了...写了N遍的东西,就是记不住...既然记不住那就记下来... 利用java获取当前的时间(String类型,年-月-日 时:分:秒) //我要获取当前的日期 Date d ...
- inner join ,left join ,right join 以及java时间转换
1.inner join ,left join 与 right join (from 百度知道) 例表aaid adate1 a12 a23 a3表bbid bdate1 ...
- Python基本时间转换
时间转换 python中处理时间的时候,最常用的就是字符形式与时间戳之间的转换. 把最基本的转换在这里记下来 string -> timestamp import time import dat ...
- Date类型时间转换
/* 时间转换start */ public static void main(String args[]) { Date nowTime = new Date(); System.out.print ...
- unix环境C编程之日期时间转换
1.理清概念 1.1.日历时间: 含义:国际标准时间1970年1月1日00:00:00以来经过的秒数. 数据类型:time_t.实际上是long的别名. 1.2.tm结构时间: 含义:结构 ...
- php时间转换unix时间戳
本文介绍了php编程中unix时间戳转换的小例子,有关php时间转换.php时间戳的实例代码,有需要的朋友参考下. 第一部分,php 时间转换unix 时间戳实现代码. 复制代码代码示例: <? ...
随机推荐
- netty源码解解析(4.0)-17 ChannelHandler: IdleStateHandler实现
io.netty.handler.timeout.IdleStateHandler功能是监测Channel上read, write或者这两者的空闲状态.当Channel超过了指定的空闲时间时,这个Ha ...
- .netcore持续集成测试篇之测试方法改造
系列目录 通过前面两节讲解,我们的测试类中已经有两个测试方法了,总体上如下 public class mvc20 { private readonly HttpClient _client; publ ...
- Java学习|Exception和Error有什么区别？
典型回答: Exception和Error都继承了Throwable类,java中只有Throwable类型的实例才能被Throw(抛出)或者catch(捕获). Exceptio ...
- Mysql优化-mysql分区
背景:由于我负责i西科教务处系统,i西科用户量达到20000人左右,那么假设每人每星期10门讲课,数据库记录信息将是20万条,如果不将课程表进行分区或分表,就会造成爆表的情况,如此看来,分区是必须要做 ...
- JVM面试十问
1. JVM运行时划分哪几个区域?哪些区域是线程共享的?哪些区域是线程独占的? JVM运行时一共划分:程序计数器.虚拟机栈.堆.本地方法栈.方法区. 线程共享的数据区域:堆.方法区. 线程独享的数据区 ...
- 十分钟入门流处理框架Flink --实时报表场景的应用
随着业务的发展,数据量剧增,我们一些简单报表大盘类的任务,就不能简单的依赖于RDBMS了,而是依赖于数仓之类的大数据平台. 数仓有着巨量数据的存储能力,但是一般都存在一定数据延迟,所以要想完全依赖数数 ...
- 5.MySQL数据库操作步骤
第一步:登录到MySQL服务器 第二步:选择当前要操作的数据库 第三步:设置请求和返回数据的字符集 第四步:执行SQL语句 l 增加记录:INSERT INTO news(title,content) ...
- 自己实现spring核心功能 三
前言 前两篇已经基本实现了spring的核心功能,下面讲到的参数绑定是属于springMvc的范畴了.本篇主要将请求到servlet后怎么去做映射和处理.首先来看一看dispatherServlet的 ...
- WebSocket和HTTP协议的区别
HTTP: 1,无状态协议. 2,短连接.(Ajax轮询方式或Long poll方式实现“持久连接”状态) 2,被动型. 客户端请求->服务器端响应.服务端不能主动联系客户端,只能有客户端发 ...
- 【数据结构】8.java源码关于HashMap
1.hashmap的底层数据结构 众所皆知map的底层结构是类似邻接表的结构,但是进入1.8之后,链表模式再一定情况下又会转换为红黑树在JDK8中,当链表长度达到8,并且hash桶容量超过64(MIN ...