golang--操作日期

写在前面

UTC时间：世界协调时间，比北京时间少8小时（2022-12-15 03:16:14.793008672 +0000 UTC m=+1775.212342083）

1. 容器中的时间可能和在电脑本地的不一样。time.Now()在容器也可能获取到的是UTC时间2022-12-15 03:16:14.793008672 +0000 UTC m=+1775.212342083。在电脑本地获取的是2022-12-15 11:06:23.5031029 +0800 CST m=+0.186318401

概览

golang 的time包里一共包含了几个类型的结构体：

1. Constants ：常量
2. type ParseError：描述解析时间字符串时出现的错误。
3. type Weekday：代表一周的某一天
4. type Month：代表一年的某个月。
5. type Location：代表一个（关联到某个时间点的）地点，以及该地点所在的时区。
6. type Time：代表一个纳秒精度的时间点。
7. type Duration：代表两个时间点之间经过的时间，以纳秒为单位。可表示的最长时间段大约290年。
8. type Timer：代表单次时间事件
9. type Ticker：保管一个通道，并每隔一段时间向其传递"tick"。（反复的）

时间间隔

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

	now := time.Now()        // 获取当前时间			
	timestamp := now.Unix()  // 秒级时间戳			1658223718
	milli := now.UnixMilli() // 毫秒时间戳 Go1.17+	1658223718098
	micro := now.UnixMicro() // 微秒时间戳 Go1.17+	1658223718098170
	nano := now.UnixNano()   // 纳秒时间戳			1658223718098170800
	fmt.Println(timestamp, milli, micro, nano)   

时区

//创建时间对象需要指定位置。
//常用的位置是 time.Local（当地时间） 和 time.UTC（UTC时间）。
//timeInLocal := time.Date(2009, 1, 1, 20, 0, 0, 0, time.Local)  // 系统本地时间
//北京时间（东八区）比UTC早8小时
// timezoneDemo 时区示例
func timezoneDemo() {
	// 中国没有夏令时，使用一个固定的8小时的UTC时差。
	// 对于很多其他国家需要考虑夏令时。
	secondsEastOfUTC := int((8 * time.Hour).Seconds())
	// FixedZone 返回始终使用给定区域名称和偏移量(UTC 以东秒)的 Location。
	beijing := time.FixedZone("Beijing Time", secondsEastOfUTC)

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

	// 创建时间对象需要指定位置。常用的位置是 time.Local（当地时间） 和 time.UTC（UTC时间）。
	//timeInLocal := time.Date(2009, 1, 1, 20, 0, 0, 0, time.Local)  // 系统本地时间
	timeInUTC := time.Date(2009, 1, 1, 12, 0, 0, 0, time.UTC)
	sameTimeInBeijing := time.Date(2009, 1, 1, 20, 0, 0, 0, beijing)
	sameTimeInNewYork := time.Date(2009, 1, 1, 7, 0, 0, 0, newYork)

	// 北京时间（东八区）比UTC早8小时，所以上面两个时间看似差了8小时，但表示的是同一个时间
	timesAreEqual := timeInUTC.Equal(sameTimeInBeijing)
	fmt.Println(timesAreEqual)

	// 纽约（西五区）比UTC晚5小时，所以上面两个时间看似差了5小时，但表示的是同一个时间
	timesAreEqual = timeInUTC.Equal(sameTimeInNewYork)
	fmt.Println(timesAreEqual)
}

带TZ的格林威治时间字符串转时间格式

to, _ := time.Parse("2006-01-02T15:04:05Z", "2022-12-14T02:27:19.000Z")
stamp := to.Format("2006-01-02 15:04:05")

var timeLayout = "2006-01-02 15:04:05"

字符串转time.time

ts := "2022-11-08 17:25:00"
ttt ,err := time.ParseInLocation(timeLayout,ts,time.Local)

int64转time.time

ttt := time.Now().UnixMilli()
fmt.Println(ttt)
nt := int64(ttt + 10000)
fmt.Println("nt=",nt)
time.UnixMilli(nt)

将字符串日期去除时间部分（也就是时分秒）

func DateStringWipeOffTime(date string) string {
	date = strings.TrimPrefix(date, " ")
	date = strings.TrimSuffix(date, " ")
	if strings.Contains(date, " ") {
		i := strings.Index(date, " ")
		date = date[:i]
		return date
	}
	return date
}

给字符串日期加上时间部分（默认部分）

func DateStringAddTime(date string) string {
	date = strings.TrimPrefix(date, " ")
	date = strings.TrimSuffix(date, " ")
	if strings.Contains(date, " ") {
		return date
	}
	date = date + " 00:00:00"
	return date
}

根据字符串日期获取本地时间（int64类型）

func StringToLocationInt64(date string) int64 {
	loc, _ := time.LoadLocation("Local")
	if strings.Contains(date, " ") {
		dateTime, _ := time.ParseInLocation(timeLayout, date, loc)
		dateTimeInt := dateTime.Unix()
		return dateTimeInt
	}
	dateTime, _ := time.ParseInLocation("2006-01-02", date, loc)
	dateTimeInt := dateTime.Unix()
	return dateTimeInt
}

字符串日期转time.Time不要时分秒部分

func StringToDateWithOutTime(date string) string {
	dateTimeInt := StringToLocationInt64(date)
	result := time.Unix(dateTimeInt, 0).Format("2006-01-02")
	return result
}

字符串日期转time.Time，保留时分秒部分

func StringToDateWithInTime(date string) string {
	dateTimeInt := StringToLocationInt64(date)
	result := time.Unix(dateTimeInt, 0).Format(timeLayout)
	return result
}

日期计算，增加指定天数，不保留时分秒

func DateAddDayWhitOutTime(date string, days int) string {
	dateTimeInt := int(StringToLocationInt64(date))
	oneDay := 86400
	addingDays := oneDay * days
	dateTimeInt += addingDays
	dateTimeString := time.Unix(int64(dateTimeInt), 0).Format("2006-01-02")
	return dateTimeString
}

日期计算，增加指定天数，保留时分秒

func DateAddDayWhitInTime(date string, days int) string {
	dateTimeInt := int(StringToLocationInt64(date))
	oneDay := 86400
	addingDays := oneDay * days
	dateTimeInt += addingDays
	dateTimeString := time.Unix(int64(dateTimeInt), 0).Format("2006-01-02 15:04:05")
	return dateTimeString
}

定时器

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

使用时间排序结构体数组

type DataDo struct {
	TimeStamp   time.Time `json:"timeStamp"`
}
type DataDoSlice []DataDo

func (dds DataDoSlice) Len() int{
	return len(dds)
}

func (dds DataDoSlice) Swap(i,j int){
	dds[i],dds[j] = dds[j],dds[i]
}
//时间小到大排序
func (dds DataDoSlice) Less(i,j int) bool{ 
	return dds[j].TimeStamp.Before(dds[i].TimeStamp)
}