Go时间技巧

一、时间格式化与转化

日期字符串（2014-11-12 11:45:26）需要转化为Go的time类型
一般使用Parse(layout, value string) (Time, error)方法处理，但是Go中默认使用UTC时区，会导致日期时间转化错误！！
在time.Now()中获取的时间是本地时区时间。
解决方案：使用ParseInLocation方法手动指定时区

timeTransited, err := time.ParseInLocation(format, objToTrans, location)

//解析方法
layout := "2006-01-02 15:04:05" str := "2014-11-12 11:45:26" t, err := time.ParseInLocation(layout, str, time.Local)

封装方法：

package utils  
  
import (  
   "errors"  
   "time")  
  
const (  
   // DefaultStandTimeFormat 标准时间字符串格式  
   DefaultStandTimeFormat string = "2022-06-30 00:00:00"  
)  
  
// CheckTimeBetweenObjAndObj  
// @Description: 检查时间是否在指定时间范围内（默认时区本地）  
// @param startTime 开始时间  
// @param endTime 结束时间  
// @param objTime 目标时间  
// @return bool  
func CheckTimeBetweenObjAndObj(startTime time.Time, endTime time.Time, objTime time.Time) bool {  
   if !objTime.IsZero() {  
      return startTime.Before(objTime) && endTime.After(objTime)  
   } else {  
      return false  
   }  
}  
  
// TransformTimeFormFormat  
// @Description: 时间转化方法，字符串时间转化为标准时间time  
// @param objToTrans  
// @param transFormedAns  
// @return error  
func TransformTimeFormFormat(objToTrans string, location *time.Location, format string) (*time.Time, error) {  
   if objToTrans == "" {  
      return nil, errors.New("pleas input trans obj and receiveObj !")  
   } else {  
      if location == nil {  
         location = time.Local  
      }  
      if format == "" {  
         format = DefaultStandTimeFormat  
      }  
      timeTransited, err := time.ParseInLocation(format, objToTrans, location)  
      if err != nil {  
         return nil, err  
      }  
      return &timeTransited, nil  
   }  
}

二、时间范围

1. 小于 && 小于

   //
   now := time.Now()
   //现在在xxx之前。返回的是bool
   now.Before()
   //现在在xxx之后。返回的是bool
   now.After()

2. 在一个范围内

   // Package utils  
   // @author: BaiYZ  
   // @description:  
   // @file: time.go  
   // @version: 1.0.0  
   // @date: 7/14/2022 9:44 上午  
   package utils  
     
   import (  
      "errors"  
      "time")  
     
   const (  
      // DEFAULTTIMETEMPLATE 默认时间格式  
      DEFAULTTIMETEMPLATE = "2006-01-02 15:04:05"  
   )  
     
   // JudgeTimeBetweenTheRangeUseTime  
   // @Description: 判断目标时间是否在制定时间范围内（左闭右开，左开右闭..）  
   // @param startTime 开始时间  
   // @param endTime 结束时间  
   // @param objTime 目标时间  
   // @param left 是否允许左区间取值  
   // @param right 是否允许右区间取值  
   // @return bool true/false  
   // @return error 错误  
   func JudgeTimeBetweenTheRangeUseTime(startTime time.Time, endTime time.Time, objTime time.Time, left bool, right bool) (bool, error) {  
      if left {  
         if right && (objTime.Before(startTime) || objTime.After(endTime)) {  
            return false, nil  
         }  
         if !right && (objTime.Before(startTime) || (objTime.After(endTime) || objTime.Equal(endTime))) {  
            return false, nil  
         }  
         return true, nil  
      } else {  
         if right && ((objTime.Before(startTime) || objTime.Equal(startTime)) || objTime.After(endTime)) {  
            return false, nil  
         }  
         if !right && ((objTime.Before(startTime) || objTime.Equal(startTime)) || (objTime.After(endTime) || objTime.Equal(endTime))) {  
            return false, nil  
         }  
         return true, nil  
      }  
   }  
     
   // JudgeTimeBetweenTheRangeUseTimeInterface  
   // @Description: 通用时间区间判断，支持time类型以及字符串类型（格式：2006-01-02 15:04:05）string string string 、string string time 、time time time  
   // @param startTime 开始  
   // @param endTime 结束  
   // @param objTime 目标  
   // @param location 时区  
   // @param left 左区间  
   // @param right 右区间  
   // @return bool 结果  
   // @return error 错误  
   func JudgeTimeBetweenTheRangeUseTimeInterface(startTime interface{}, endTime interface{}, objTime interface{}, location *time.Location, left bool, right bool) (bool, error) {  
      if location == nil {  
         location = time.Local  
      }  
      if objTime == nil {  
         objTime = time.Local  
      }  
      // 进行类型断言  
      start, startOk := startTime.(time.Time)  
      end, endOk := endTime.(time.Time)  
      obj, objOk := objTime.(time.Time)  
      if startOk && endOk && objOk {  
         ans, err := JudgeTimeBetweenTheRangeUseTime(start, end, obj, left, right)  
         if err != nil {  
            return false, err  
         }  
         return ans, nil  
      }  
      // 全部字符串类型断言  
      startStr, startOk := startTime.(string)  
      endStr, endOk := endTime.(string)  
      objStr, objOk := objTime.(string)  
      if startOk && endOk && objOk {  
         start, err := GetTimeUseStringTemplate(startStr, location)  
         if err != nil {  
            return false, err  
         }  
         end, err := GetTimeUseStringTemplate(endStr, location)  
         if err != nil {  
            return false, err  
         }  
         obj, err := GetTimeUseStringTemplate(objStr, location)  
         if err != nil {  
            return false, err  
         }  
         ans, err := JudgeTimeBetweenTheRangeUseTime(start, end, obj, left, right)  
         if err != nil {  
            return false, err  
         }  
         return ans, nil  
      }  
     
      // 前两个字符串 后一个time类型  
      startT, startOk := startTime.(string)  
      endT, endOk := endTime.(string)  
      objT, objOk := objTime.(time.Time)  
      if startOk && endOk && objOk {  
         start, err := GetTimeUseStringTemplate(startT, location)  
         if err != nil {  
            return false, err  
         }  
         end, err := GetTimeUseStringTemplate(endT, location)  
         if err != nil {  
            return false, err  
         }  
         ans, err := JudgeTimeBetweenTheRangeUseTime(start, end, objT, left, right)  
         if err != nil {  
            return false, err  
         }  
         return ans, nil  
      }  
      return false, errors.New("do not support to trans")  
   }  
     
   // GetTimeUseStringTemplate  
   // @Description: 通过制定字符串以及时区转化为time.Time对象，支持默认值 不传递字符串模板使用默认，不传递时区使用本地时区 "2006-01-02 15:04:05"// @param timeToTrans 待转化的时间字符串  
   // @param location 时区  
   // @return time.Time  
   // @return error  
   func GetTimeUseStringTemplate(timeToTrans string, location *time.Location) (time.Time, error) {  
      if timeToTrans == "" {  
         return time.Time{}, errors.New("invade time string , can't be trans")  
      } else if location != nil {  
         return time.ParseInLocation(DEFAULTTIMETEMPLATE, timeToTrans, location)  
      } else {  
         return time.ParseInLocation(DEFAULTTIMETEMPLATE, timeToTrans, time.Local)  
      }}

测试：

// Package  
// @author: BaiYZ  
// @description:  
// @file: time_test.go  
// @version: 1.0.0  
// @date: 7/14/2022 10:56 上午  
package utils  
  
import (  
   "fmt"  
   "testing"   "time")  
  
func TestGetTimeUseStringTemplate(t *testing.T) {  
   template, err := GetTimeUseStringTemplate("2022-02-02 00:00:00", time.Local)  
   if err != nil {  
      fmt.Printf("err is : %v\n", err)  
   }   fmt.Println(template)  
}  
func TestJudgeTimeBetweenTheRangeUseTime(t *testing.T) {  
   start, _ := GetTimeUseStringTemplate("2022-02-02 00:00:00", time.Local)  
   end, _ := GetTimeUseStringTemplate("2022-02-04 00:00:00", time.Local)  
   now, _ := GetTimeUseStringTemplate("2022-02-03 00:00:00", time.Local)  
   ans, err := JudgeTimeBetweenTheRangeUseTime(start, end, now, false, false)  
   if err != nil {  
      fmt.Printf("err is : %v\n", err)  
   }   fmt.Printf("start is :%v\n end is :%v\n now is :%v\n ans is :%v\n", start, end, now, ans)  
  
}  
func TestJudgeTimeBetweenTheRangeUseTimeString(t *testing.T) {  
   template, err := GetTimeUseStringTemplate("2022-07-14 05:00:00", time.Local)  
   if err != nil {  
      return  
   }  
   timeString, err := JudgeTimeBetweenTheRangeUseTimeInterface("2022-07-14 00:00:00", "2022-07-15 00:00:00", template, time.Local, true, true)  
   if err != nil {  
      fmt.Printf("err is : %v\n", err)  
   }   fmt.Printf("ans is :%v\n", timeString)  
  
}  
func TestDemo(t *testing.T) {  
   a := "2022-07-14 06:00:01"  
   b := "2022-07-14 06:00:00"  
  
   fmt.Println(a == b)  
}