demand

Time format conversion is more troublesome, I wrote a tool, you can through these methods in the tool call each other into the format you want, the code is as follows, the new function will be added later

The implementation code

package utils

import "time"

const (
 TIMEFORMAT = "20060102150405"
 NORMALTIMEFORMAT = "2006-01-02 15:04:05"
)

//  The current time
func GetTime() time.Time{
 return time.Now()
}

//  Formatted as :20060102150405
func GetTimeString(t time.Time) string {
 return t.Format(TIMEFORMAT)
}

//  Formatted as :2006-01-02 15:04:05
func GetNormalTimeString(t time.Time) string {
 return t.Format(NORMALTIMEFORMAT)
}

//  Convert to timestamp -> Number of seconds
func GetTimeUnix(t time.Time) int64 {
 return t.Unix()
}

//  Convert to timestamp -> Number of milliseconds
func GetTimeMills(t time.Time) int64 {
 return t.UnixNano() / 1e6
}

//  The timestamp turns the time
func GetTimeByInt(t1 int64) time.Time{
 return time.Unix(t1,0)
}

//  String rotation time
func GetTimeByString(timestring string) (time.Time,error){
 if timestring == "" {
 return time.Time{},nil
 }
 return time.ParseInLocation(TIMEFORMAT, timestring, time.Local)
}

//  Standard string rotation time
func GetTimeByNormalString(timestring string) (time.Time,error){
 if timestring == "" {
 return time.Time{},nil
 }
 return time.ParseInLocation(NORMALTIMEFORMAT, timestring, time.Local)
}

//  Compare the two time sizes
func CompareTime(t1 ,t2 time.Time) bool {
 return t1.Before(t2)
}

// n Hours after the time string
func GetNextHourTime(s string, n int64) string {
 t2, _ := time.ParseInLocation(TIMEFORMAT, s, time.Local)
 t1 := t2.Add(time.Hour * time.Duration(n))
 return GetTimeString(t1)
}

//  Calculate the time difference between the two
func GetHourDiffer(start_time, end_time string) float32 {
 var hour float32
 t1, err := time.ParseInLocation(TIMEFORMAT, start_time, time.Local)
 t2, err := time.ParseInLocation(TIMEFORMAT, end_time, time.Local)
 if err == nil && CompareTime(t1,t2) {
 diff := GetTimeUnix(t2) - GetTimeUnix(t1)
 hour = float32(diff) / 3600
 return hour
 }
 return hour
}

//  Determine if the current time is on the hour
func Checkhours() bool {
 _, m, s := GetTime().Clock()
 if m == s && m == 0 && s == 0 {
 return true
 }
 return false
}

//  The time string is converted to a standard string
func StringToNormalString(t string) string {
 if !(len(TIMEFORMAT) == len(t) || len(SHORTTIMESTRING) == len(t)) {
 return t
 }
 if len(SHORTTIMESTRING) == len(t) {
 t += "000000"
 }
 if len(TIMEFORMAT) == len(t) {
 t1,err:= GetTimeByString(t)
 if err != nil {
 return t
 }
 t = GetTimeString(t1)
 }
 return t
}

Determine whether a point in time is after a point in time

Procedure: This is very simple for timestamps, but for others you need to convert to time to compare

  stringToTime, _ := time.Parse("2006-01-02 15:04:05", "2017-12-12 12:00:00")
  beforeOrAfter := stringToTime.After(time.Now())
  if beforeOrAfter == true {
    fmt.Println("2017-12-12 12:00:00 in tNow after !")
  } else {
    fmt.Println("2017-12-12 12:00:00 in tNow before !")
  }

Judge how much time has passed between one time and the other Process: This is compared in Time’s way

  beginTime :=time.Now()
  time.Sleep(time.Second*1)
  durtime:= time.Since(beginTime)
  fmt.Println(" Gone from the present: ",durtime)