github.com/zhongdalu/gf@v1.0.0/g/os/gtime/gtime_time.go (about)

     1  // Copyright 2018 gf Author(https://github.com/zhongdalu/gf). All Rights Reserved.
     2  //
     3  // This Source Code Form is subject to the terms of the MIT License.
     4  // If a copy of the MIT was not distributed with this file,
     5  // You can obtain one at https://github.com/zhongdalu/gf.
     6  
     7  package gtime
     8  
     9  import (
    10  	"time"
    11  )
    12  
    13  type Time struct {
    14  	time.Time
    15  }
    16  
    17  // 创建一个空的时间对象，参数可以是标准库时间对象，可选
    18  func New(t ...time.Time) *Time {
    19  	if len(t) > 0 {
    20  		return NewFromTime(t[0])
    21  	}
    22  	return &Time{
    23  		time.Time{},
    24  	}
    25  }
    26  
    27  // 当前时间对象
    28  func Now() *Time {
    29  	return &Time{
    30  		time.Now(),
    31  	}
    32  }
    33  
    34  // 标准时间对象转换为自定义的时间对象
    35  func NewFromTime(t time.Time) *Time {
    36  	return &Time{
    37  		t,
    38  	}
    39  }
    40  
    41  // 从字符串转换为时间对象，复杂的时间字符串需要给定格式
    42  func NewFromStr(str string) *Time {
    43  	if t, err := StrToTime(str); err == nil {
    44  		return t
    45  	}
    46  	return nil
    47  }
    48  
    49  // 从字符串转换为时间对象，指定字符串时间格式，format格式形如：Y-m-d H:i:s
    50  func NewFromStrFormat(str string, format string) *Time {
    51  	if t, err := StrToTimeFormat(str, format); err == nil {
    52  		return t
    53  	}
    54  	return nil
    55  }
    56  
    57  // 从字符串转换为时间对象，通过标准库layout格式进行解析，layout格式形如：2006-01-02 15:04:05
    58  func NewFromStrLayout(str string, layout string) *Time {
    59  	if t, err := StrToTimeLayout(str, layout); err == nil {
    60  		return t
    61  	}
    62  	return nil
    63  }
    64  
    65  // 时间戳转换为时间对象，时间戳支持到纳秒的数值
    66  func NewFromTimeStamp(timestamp int64) *Time {
    67  	if timestamp == 0 {
    68  		return &Time{}
    69  	}
    70  	for timestamp < 1e18 {
    71  		timestamp *= 10
    72  	}
    73  	return &Time{
    74  		time.Unix(int64(timestamp/1e9), timestamp%1e9),
    75  	}
    76  }
    77  
    78  // 秒数(时间戳)
    79  func (t *Time) Second() int64 {
    80  	return t.UnixNano() / 1e9
    81  }
    82  
    83  // 纳秒数
    84  func (t *Time) Nanosecond() int64 {
    85  	return t.UnixNano()
    86  }
    87  
    88  // 微秒数
    89  func (t *Time) Microsecond() int64 {
    90  	return t.UnixNano() / 1e3
    91  }
    92  
    93  // 毫秒数
    94  func (t *Time) Millisecond() int64 {
    95  	return t.UnixNano() / 1e6
    96  }
    97  
    98  // 转换为字符串
    99  func (t *Time) String() string {
   100  	return t.Format("Y-m-d H:i:s")
   101  }
   102  
   103  // Deprecated.
   104  // Directly use t.Time instead.
   105  func (t *Time) ToTime() time.Time {
   106  	return t.Time
   107  }
   108  
   109  // 复制当前时间对象
   110  func (t *Time) Clone() *Time {
   111  	return New(t.Time)
   112  }
   113  
   114  // 当前时间加上指定时间段
   115  func (t *Time) Add(d time.Duration) *Time {
   116  	t.Time = t.Time.Add(d)
   117  	return t
   118  }
   119  
   120  // 当前时间加上指定时间段(使用字符串格式)
   121  func (t *Time) AddStr(duration string) error {
   122  	if d, err := time.ParseDuration(duration); err != nil {
   123  		return err
   124  	} else {
   125  		t.Time = t.Time.Add(d)
   126  	}
   127  	return nil
   128  }
   129  
   130  // 时区转换为指定的时区(通过time.Location)
   131  func (t *Time) ToLocation(location *time.Location) *Time {
   132  	t.Time = t.Time.In(location)
   133  	return t
   134  }
   135  
   136  // 时区转换为指定的时区(通过时区名称，如：Asia/Shanghai)
   137  func (t *Time) ToZone(zone string) (*Time, error) {
   138  	if l, err := time.LoadLocation(zone); err == nil {
   139  		t.Time = t.Time.In(l)
   140  		return t, nil
   141  	} else {
   142  		return nil, err
   143  	}
   144  }
   145  
   146  // 时区转换为UTC时区
   147  func (t *Time) UTC() *Time {
   148  	t.Time = t.Time.UTC()
   149  	return t
   150  }
   151  
   152  // 时区转换为当前设定的Local时区
   153  func (t *Time) Local() *Time {
   154  	t.Time = t.Time.Local()
   155  	return t
   156  }
   157  
   158  // 时间日期计算
   159  func (t *Time) AddDate(years int, months int, days int) *Time {
   160  	t.Time = t.Time.AddDate(years, months, days)
   161  	return t
   162  }
   163  
   164  // Round将舍入t的结果返回到d的最接近的倍数(从零时间开始)。
   165  // 中间值的舍入行为是向上舍入。 如果d <= 0，Round返回t剥离任何单调时钟读数但不改变。
   166  // Round作为零时间以来的绝对持续时间运行; 它不适用于当时的演示形式。
   167  // 因此，Round(Hour)可能会返回非零分钟的时间，具体取决于时间的位置。
   168  func (t *Time) Round(d time.Duration) *Time {
   169  	t.Time = t.Time.Round(d)
   170  	return t
   171  }
   172  
   173  // Truncate将舍入t的结果返回到d的倍数(从零时间开始)。 如果d <= 0，则Truncate返回t剥离任何单调时钟读数但不改变。
   174  // 截断时间作为零时间以来的绝对持续时间运行; 它不适用于当时的演示形式。
   175  // 因此，截断（小时）可能会返回非零分钟的时间，具体取决于时间的位置。
   176  func (t *Time) Truncate(d time.Duration) *Time {
   177  	t.Time = t.Time.Truncate(d)
   178  	return t
   179  }
   180  
   181  // MarshalJSON implements the interface MarshalJSON for json.Marshal.
   182  func (t *Time) MarshalJSON() ([]byte, error) {
   183  	return []byte(`"` + t.String() + `"`), nil
   184  }