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 时间戳实现代码. 复制代码代码示例: <? ...
随机推荐
- go 学习笔记之有意思的变量和不安分的常量
首先希望学习 Go 语言的爱好者至少拥有其他语言的编程经验,如果是完全零基础的小白用户,本教程可能并不适合阅读或尝试阅读看看,系列笔记的目标是站在其他语言的角度学习新的语言,理解 Go 语言,进而写出 ...
- mybatis一对多双向映射
连表查询 select id resultType resultMap resultType和resultMap不能同时使用 association 属性 映射到多对一中的“一”方的“复杂类 ...
- Python3 反射
反射 python面向对象中的反射:通过字符串的形式操作对象相关的属性 hasattr(obj,name) # hasattr(obj, name) # 判断一个对象是否有指定的属性name,返回Tr ...
- 用python实现银行家算法
编制模拟银行家算法的程序,并以下面给出的例子验证所编写的程序的正确性. 进程 已占资源 最大需求数 资源种类 A B C D A B C D P0 0 0 1 2 0 0 1 2 P1 1 0 0 0 ...
- 多线程 共享资源 同步锁 java
Java多线程编程:Lock synchronized是java中的一个关键字,也就是说是Java语言内置的特性.那么为什么会出现Lock呢? 如果一个代码块被synchronized修饰了,当一 ...
- 基于vue手写tree插件那点事
目录 iview提供的控件 手写控件 手写控件扩展 手写控件总结 # 加入战队 微信公众号 主题 Tree树形控件在前端开发中必不可少,对于数据的展示现在网站大都采取树形展示.因为大数据全部展示出来对 ...
- java io读取性能对比
背景 从最早bio的只支持阻塞的bio(同步阻塞) 到默认阻塞支持非阻塞nio(同步非阻塞+同步阻塞)(此时加入mmap类) 再到aio(异步非阻塞) 虽然这些api改变了调用模式,但真正执行效率上是 ...
- python学习之并发编程
目录 一.并发编程之多进程 1.multiprocessing模块介绍 2.Process类的介绍 3.Process类的使用 3.1 创建开启子进程的两种方式 3.2 获取进程pid 3.3验证进程 ...
- mybatis 源码分析（七）KeyGenerator 详解
一.KeyGenerator 概述 在平时开发的时候经常会有这样的需求,插入数据返回主键,或者插入数据之前需要获取主键,这样的需求在 mybatis 中也是支持的,其中主要的逻辑部分就在 KeyGen ...
- java学习之String类
标签(空格分隔): String类 String 的概述 class StringDemo{ public static void main(String[] args){ String s1=&qu ...