2024-01-25 16:07:48 +08:00
|
|
|
package util
|
|
|
|
|
|
|
|
import (
|
2024-06-26 12:17:41 +08:00
|
|
|
"apigo.cc/apigo/plugin"
|
2024-01-25 16:07:48 +08:00
|
|
|
"encoding/hex"
|
|
|
|
"github.com/ssgo/u"
|
|
|
|
"gopkg.in/yaml.v3"
|
2024-07-04 11:14:34 +08:00
|
|
|
"time"
|
2024-01-25 16:07:48 +08:00
|
|
|
)
|
|
|
|
|
|
|
|
func init() {
|
|
|
|
plugin.Register(plugin.Plugin{
|
2024-07-04 11:14:34 +08:00
|
|
|
Id: "apigo.cc/apigo/plugins/util",
|
2024-01-25 16:07:48 +08:00
|
|
|
Name: "基础工具",
|
|
|
|
JsCode: `
|
2024-07-04 11:14:34 +08:00
|
|
|
${OBJECT}.formatDate = function (date, fmt) {
|
2024-01-25 16:07:48 +08:00
|
|
|
let ret
|
|
|
|
if (!date) return ''
|
|
|
|
if (!fmt) fmt = 'YYYY-mm-dd HH:MM:SS'
|
|
|
|
const opt = {
|
|
|
|
'YYYY': date.getFullYear().toString(),
|
|
|
|
'YY': date.getFullYear().toString().substring(2),
|
|
|
|
'm+': (date.getMonth() + 1).toString(),
|
|
|
|
'd+': date.getDate().toString(),
|
|
|
|
'H+': date.getHours().toString(),
|
|
|
|
'h+': (date.getHours() % 12).toString(),
|
|
|
|
'APM': (date.getHours() > 12 ? 'PM' : 'AM'),
|
|
|
|
'M+': date.getMinutes().toString(),
|
|
|
|
'S+': date.getSeconds().toString(),
|
|
|
|
'YW': 'W' + Math.ceil(((date.getTime() - new Date(date.getFullYear(), 0, 0))) / (24 * 60 * 60 * 1000) / 7),
|
|
|
|
}
|
|
|
|
for (let k in opt) {
|
|
|
|
ret = new RegExp('(' + k + ')').exec(fmt)
|
|
|
|
if (ret) {
|
|
|
|
fmt = fmt.replace(ret[1], (ret[1].length == 1) ? (opt[k]) : (opt[k].padStart(ret[1].length, '0')))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return fmt
|
|
|
|
}
|
|
|
|
|
2024-07-04 11:14:34 +08:00
|
|
|
${OBJECT}.parseDate = function (str) {
|
2024-01-25 16:07:48 +08:00
|
|
|
if (typeof str === 'number') str = str + ''
|
|
|
|
if (/^\d+[\\.]?\d*$/.test(str)) {
|
|
|
|
if (str.length === 10) str += '000'
|
2024-07-04 11:14:34 +08:00
|
|
|
return new Date(${OBJECT}.int(str))
|
2024-01-25 16:07:48 +08:00
|
|
|
}
|
|
|
|
if (str.length === 19) {
|
|
|
|
return new Date(parseInt(str.substr(0, 4)), parseInt(str.substr(5, 2)) - 1, parseInt(str.substr(8, 2)), parseInt(str.substr(11, 2)), parseInt(str.substr(14, 2)), parseInt(str.substr(17, 2)))
|
|
|
|
} else if (str.length === 10) {
|
|
|
|
return new Date(parseInt(str.substr(0, 4)), parseInt(str.substr(5, 2)) - 1, parseInt(str.substr(8, 2)))
|
|
|
|
} else if (str.length === 7) {
|
|
|
|
return new Date(parseInt(str.substr(0, 4)), parseInt(str.substr(5, 2)) - 1, 1)
|
|
|
|
} else if (str.length === 8) {
|
|
|
|
let date = new Date()
|
|
|
|
return new Date(date.getFullYear(), date.getMonth(), date.getDate(), parseInt(str.substr(0, 2)), parseInt(str.substr(3, 2)), parseInt(str.substr(6, 2)))
|
|
|
|
} else if (str.length === 5) {
|
|
|
|
let date = new Date()
|
|
|
|
return new Date(date.getFullYear(), date.getMonth(), date.getDate(), parseInt(str.substr(0, 2)), parseInt(str.substr(3, 2)), 0)
|
|
|
|
}
|
|
|
|
return new Date(str)
|
|
|
|
}
|
|
|
|
|
2024-07-04 11:14:34 +08:00
|
|
|
${OBJECT}.int = function (v) {
|
2024-01-25 16:07:48 +08:00
|
|
|
if (!v) return 0
|
|
|
|
if (typeof v === 'number' || v instanceof Number) return v
|
|
|
|
if (typeof v === 'object') v = v.toString ? v.toString() : ''
|
|
|
|
if (typeof v !== 'string') return 0
|
|
|
|
try {
|
|
|
|
return Math.round(parseFloat(v.replace(/,/g, '').trim())) || 0
|
|
|
|
} catch (e) {
|
|
|
|
return 0
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-07-04 11:14:34 +08:00
|
|
|
${OBJECT}.float = function (v) {
|
2024-01-25 16:07:48 +08:00
|
|
|
if (!v) return 0.0
|
|
|
|
if (typeof v === 'number' || v instanceof Number) return v
|
|
|
|
if (typeof v === 'object') v = v.toString ? v.toString() : ''
|
|
|
|
if (typeof v !== 'string') return 0.0
|
|
|
|
try {
|
|
|
|
return parseFloat(v.replace(/,/g, '').trim()) || 0.0
|
|
|
|
} catch (e) {
|
|
|
|
return 0.0
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-07-04 11:14:34 +08:00
|
|
|
${OBJECT}.str = function (v) {
|
2024-01-25 16:07:48 +08:00
|
|
|
if (!v) return ''
|
|
|
|
if (typeof v === 'string') return v
|
|
|
|
if (v.toString) return v.toString()
|
|
|
|
return ''
|
|
|
|
}
|
|
|
|
|
2024-07-04 11:14:34 +08:00
|
|
|
${OBJECT}.keysBy = function (obj, ...fieldAndValues) {
|
2024-01-25 16:07:48 +08:00
|
|
|
let keys = []
|
|
|
|
for (let k in obj) {
|
|
|
|
let match = true
|
|
|
|
if (fieldAndValues.length === 1) {
|
|
|
|
// 查找一位数组
|
|
|
|
if (obj[k] != fieldAndValues[0]) {
|
|
|
|
match = false
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// 查找二维数组
|
|
|
|
for (let i = 0; i < fieldAndValues.length; i += 2) {
|
|
|
|
if (obj[k][fieldAndValues[i]] != fieldAndValues[i + 1]) {
|
|
|
|
match = false
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (match) {
|
|
|
|
keys.push(k)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return keys
|
|
|
|
}
|
|
|
|
|
2024-07-04 11:14:34 +08:00
|
|
|
${OBJECT}.listBy = function (obj, ...fieldAndValues) {
|
2024-01-25 16:07:48 +08:00
|
|
|
let list = obj instanceof Array || obj instanceof NodeList ? [] : {}
|
2024-07-04 11:14:34 +08:00
|
|
|
let keys = ${OBJECT}.keysBy(obj, ...fieldAndValues)
|
2024-01-25 16:07:48 +08:00
|
|
|
for (let k of keys) {
|
|
|
|
if (obj instanceof Array || obj instanceof NodeList) {
|
|
|
|
list.push(obj[k])
|
|
|
|
} else {
|
|
|
|
list[k] = obj[k]
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return list
|
|
|
|
}
|
|
|
|
|
2024-07-04 11:14:34 +08:00
|
|
|
${OBJECT}.hasBy = function (obj, ...fieldAndValues) {
|
|
|
|
let keys = ${OBJECT}.keysBy(obj, ...fieldAndValues)
|
2024-01-25 16:07:48 +08:00
|
|
|
return keys.length > 0
|
|
|
|
}
|
|
|
|
|
2024-07-04 11:14:34 +08:00
|
|
|
${OBJECT}.getBy = function (obj, ...fieldAndValues) {
|
|
|
|
let keys = ${OBJECT}.keysBy(obj, ...fieldAndValues)
|
2024-01-25 16:07:48 +08:00
|
|
|
if (keys.length > 0) return obj[keys[0]]
|
|
|
|
return null
|
|
|
|
}
|
|
|
|
|
2024-07-04 11:14:34 +08:00
|
|
|
${OBJECT}.setBy = function (obj, value, ...fieldAndValues) {
|
|
|
|
let keys = ${OBJECT}.keysBy(obj, ...fieldAndValues)
|
2024-01-25 16:07:48 +08:00
|
|
|
if (keys.length > 0) obj[keys[0]] = value
|
|
|
|
}
|
|
|
|
|
2024-07-04 11:14:34 +08:00
|
|
|
${OBJECT}.indexBy = function (obj, ...fieldAndValues) {
|
|
|
|
let keys = ${OBJECT}.keysBy(obj, ...fieldAndValues)
|
2024-01-25 16:07:48 +08:00
|
|
|
if (keys.length > 0) {
|
2024-07-04 11:14:34 +08:00
|
|
|
return obj instanceof Array || obj instanceof NodeList ? ${OBJECT}.int(keys[0]) : keys[0]
|
2024-01-25 16:07:48 +08:00
|
|
|
}
|
|
|
|
return -1
|
|
|
|
}
|
|
|
|
|
2024-07-04 11:14:34 +08:00
|
|
|
${OBJECT}.removeBy = function (obj, ...fieldAndValues) {
|
|
|
|
let keys = ${OBJECT}.keysBy(obj, ...fieldAndValues)
|
2024-01-25 16:07:48 +08:00
|
|
|
let n = 0
|
|
|
|
for (let i = keys.length - 1; i >= 0; i--) {
|
|
|
|
let k = keys[i]
|
|
|
|
if (obj instanceof Array || obj instanceof NodeList) {
|
|
|
|
obj.splice(k, 1)
|
|
|
|
} else {
|
|
|
|
delete obj[k]
|
|
|
|
}
|
|
|
|
n++
|
|
|
|
}
|
|
|
|
return n
|
|
|
|
}
|
|
|
|
|
2024-07-04 11:14:34 +08:00
|
|
|
${OBJECT}.removeArrayItem = function (list, item) {
|
2024-01-25 16:07:48 +08:00
|
|
|
let pos = list.indexOf(item)
|
|
|
|
if (pos !== -1) list.splice(pos, 1)
|
|
|
|
}
|
|
|
|
|
2024-07-04 11:14:34 +08:00
|
|
|
${OBJECT}.last = function (arr) {
|
2024-01-25 16:07:48 +08:00
|
|
|
if (arr && arr.length) {
|
|
|
|
return arr[arr.length - 1]
|
|
|
|
}
|
|
|
|
return null
|
|
|
|
}
|
|
|
|
|
2024-07-04 11:14:34 +08:00
|
|
|
${OBJECT}.len = function (obj) {
|
2024-01-25 16:07:48 +08:00
|
|
|
if (obj instanceof Array || obj instanceof NodeList) {
|
|
|
|
return obj.length
|
|
|
|
} else {
|
|
|
|
let n = 0
|
|
|
|
for (let k in obj) n++
|
|
|
|
return n
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-07-04 11:14:34 +08:00
|
|
|
${OBJECT}.mergeBy = function (olds, news, ...fields) {
|
2024-01-25 16:07:48 +08:00
|
|
|
if (!olds) return news
|
|
|
|
for (let newItem of news) {
|
|
|
|
let fieldAndValues = []
|
|
|
|
for (let field of fields) {
|
|
|
|
fieldAndValues.push(field, newItem[field])
|
|
|
|
}
|
2024-07-04 11:14:34 +08:00
|
|
|
let oldIndex = ${OBJECT}.indexBy(olds, ...fieldAndValues)
|
2024-01-25 16:07:48 +08:00
|
|
|
if (oldIndex === -1) {
|
|
|
|
olds.push(newItem)
|
|
|
|
} else {
|
|
|
|
olds[oldIndex] = newItem
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return olds
|
|
|
|
}
|
|
|
|
|
2024-07-04 11:14:34 +08:00
|
|
|
${OBJECT}.sortBy = function (obj, field, isReverse = false, sortType) {
|
2024-01-25 16:07:48 +08:00
|
|
|
let list = obj instanceof Array || obj instanceof NodeList ? [] : {}
|
|
|
|
let sortedKeys = {}
|
|
|
|
let sortArr = []
|
|
|
|
for (let k in obj) {
|
|
|
|
let v = ''
|
|
|
|
if (field instanceof Array) {
|
|
|
|
for (let f of field) v += obj[k][f]
|
|
|
|
} else {
|
|
|
|
v = obj[k][field]
|
|
|
|
}
|
|
|
|
if (!sortedKeys[v]) {
|
|
|
|
sortedKeys[v] = true
|
|
|
|
sortArr.push(v)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
sortArr.sort((a, b) => {
|
|
|
|
if(sortType === 'int'){
|
2024-07-04 11:14:34 +08:00
|
|
|
a = ${OBJECT}.int(a)
|
|
|
|
b = ${OBJECT}.int(b)
|
2024-01-25 16:07:48 +08:00
|
|
|
} else if(sortType === 'float'){
|
2024-07-04 11:14:34 +08:00
|
|
|
a = ${OBJECT}.float(a)
|
|
|
|
b = ${OBJECT}.float(b)
|
2024-01-25 16:07:48 +08:00
|
|
|
}
|
|
|
|
if (a == b) return 0
|
|
|
|
if (typeof a === 'number' && typeof b === 'number') {
|
|
|
|
return isReverse ? b - a : a - b
|
|
|
|
} else {
|
|
|
|
return (isReverse ? a < b : a > b) ? 1 : -1
|
|
|
|
}
|
|
|
|
})
|
|
|
|
for (let sortKey of sortArr) {
|
|
|
|
for (let k in obj) {
|
|
|
|
let v = ''
|
|
|
|
if (field instanceof Array) {
|
|
|
|
for (let f of field) v += obj[k][f]
|
|
|
|
} else {
|
|
|
|
v = obj[k][field]
|
|
|
|
}
|
|
|
|
|
|
|
|
if (obj instanceof Array || obj instanceof NodeList) {
|
|
|
|
if (v == sortKey) list.push(obj[k])
|
|
|
|
} else {
|
|
|
|
if (v == sortKey) list[k] = obj[k]
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return list
|
|
|
|
}
|
|
|
|
|
2024-07-04 11:14:34 +08:00
|
|
|
${OBJECT}.in = function (v1, v2) {
|
|
|
|
if (!(v1 instanceof Array)) v1 = ${OBJECT}.split(v1, /,\s*/)
|
2024-01-25 16:07:48 +08:00
|
|
|
return v1.indexOf(String(v2)) !== -1
|
|
|
|
}
|
|
|
|
|
2024-07-04 11:14:34 +08:00
|
|
|
${OBJECT}.uniquePush = function (arr, ...values) {
|
2024-01-25 16:07:48 +08:00
|
|
|
for (let v of values) {
|
|
|
|
if (arr.indexOf(v) === -1) arr.push(v)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-07-04 11:14:34 +08:00
|
|
|
${OBJECT}.clearEmpty = function (arr) {
|
2024-01-25 16:07:48 +08:00
|
|
|
let a = []
|
|
|
|
for (let v of arr) if (v) a.push(v)
|
|
|
|
return a
|
|
|
|
}
|
|
|
|
|
2024-07-04 11:14:34 +08:00
|
|
|
${OBJECT}.split = function (v1, v2) {
|
|
|
|
return ${OBJECT}.clearEmpty(${OBJECT}.str(v1).split(v2))
|
2024-01-25 16:07:48 +08:00
|
|
|
}
|
|
|
|
|
2024-07-04 11:14:34 +08:00
|
|
|
${OBJECT}.join = function (arr, separator) {
|
|
|
|
return ${OBJECT}.clearEmpty(arr).join(separator)
|
2024-01-25 16:07:48 +08:00
|
|
|
}
|
|
|
|
|
2024-07-04 11:14:34 +08:00
|
|
|
${OBJECT}.copy = function (obj, isDeepCopy) {
|
2024-01-25 16:07:48 +08:00
|
|
|
let newObj
|
|
|
|
if (obj instanceof Array || obj instanceof NodeList) {
|
|
|
|
newObj = []
|
|
|
|
for (let o of obj) {
|
2024-07-04 11:14:34 +08:00
|
|
|
if (isDeepCopy && typeof o === 'object' && o) o = ${OBJECT}.copy(o)
|
2024-01-25 16:07:48 +08:00
|
|
|
newObj.push(o)
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
newObj = {}
|
|
|
|
for (let k in obj) {
|
|
|
|
let v = obj[k]
|
2024-07-04 11:14:34 +08:00
|
|
|
if (isDeepCopy && typeof v === 'object' && v) v = ${OBJECT}.copy(v)
|
2024-01-25 16:07:48 +08:00
|
|
|
newObj[k] = v
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return newObj
|
|
|
|
}
|
|
|
|
|
|
|
|
`,
|
|
|
|
Objects: map[string]interface{}{
|
|
|
|
// makeToken 生成指定长度的随机二进制数组
|
|
|
|
// makeToken size token长度
|
|
|
|
// makeToken return Hex编码的字符串
|
|
|
|
"makeToken": func(size int) string {
|
|
|
|
return hex.EncodeToString(u.MakeToken(size))
|
|
|
|
},
|
|
|
|
|
|
|
|
// makeTokenBytes 生成指定长度的随机二进制数组
|
|
|
|
// makeTokenBytes size token长度
|
|
|
|
// makeTokenBytes return 二进制数据
|
|
|
|
"makeTokenBytes": u.MakeToken,
|
|
|
|
|
|
|
|
// makeId 生成指定长度的随机ID
|
|
|
|
// makeId size ID长度(6~20)
|
|
|
|
// makeId return 二进制数据
|
|
|
|
"makeId": func(size int) string {
|
|
|
|
if size > 20 {
|
|
|
|
return u.UniqueId()
|
|
|
|
} else if size > 14 {
|
|
|
|
return u.UniqueId()[0:size]
|
|
|
|
} else if size > 12 {
|
|
|
|
return u.ShortUniqueId()[0:size]
|
|
|
|
} else if size > 10 {
|
|
|
|
return u.Id12()[0:size]
|
|
|
|
} else if size > 8 {
|
|
|
|
return u.Id10()[0:size]
|
|
|
|
} else if size >= 6 {
|
|
|
|
return u.Id8()[0:size]
|
|
|
|
} else {
|
|
|
|
return u.Id6()
|
|
|
|
}
|
|
|
|
},
|
|
|
|
|
|
|
|
// encodeYaml 将对象转换为YAML格式
|
|
|
|
// encodeYaml content 对象
|
|
|
|
// encodeYaml return YAML字符串
|
|
|
|
"encodeYaml": func(content interface{}) (string, error) {
|
|
|
|
buf, err := yaml.Marshal(content)
|
|
|
|
return string(buf), err
|
|
|
|
},
|
|
|
|
// decodeYaml 将YAML转化为对象
|
|
|
|
// decodeYaml content YAML字符串
|
|
|
|
// decodeYaml return 对象
|
|
|
|
"decodeYaml": func(content string) (interface{}, error) {
|
|
|
|
var data interface{}
|
|
|
|
err := yaml.Unmarshal([]byte(content), &data)
|
|
|
|
return data, err
|
|
|
|
},
|
2024-07-04 11:14:34 +08:00
|
|
|
|
|
|
|
"now": func() *Time {
|
|
|
|
return &Time{tm: time.Now()}
|
|
|
|
},
|
|
|
|
|
|
|
|
"makeTime": func(year, month, day, hour, min, sec, msec int, location *string) *Time {
|
|
|
|
loc := time.Local
|
|
|
|
if location != nil {
|
|
|
|
if loc2, err := time.LoadLocation(*location); err == nil {
|
|
|
|
loc = loc2
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return makeTime(time.Date(year, time.Month(month), day, hour, min, sec, msec*1000000, loc))
|
|
|
|
},
|
|
|
|
|
|
|
|
"unixTime": func(milliUnix int64) *Time {
|
|
|
|
return makeTime(time.UnixMilli(milliUnix))
|
|
|
|
},
|
|
|
|
"int": func(v any) int { return 0 },
|
|
|
|
"float": func(v any) float64 { return 0 },
|
|
|
|
"str": func(v any) string { return "" },
|
|
|
|
"keysBy": func(obj []any, fieldAndValues ...any) []string { return nil },
|
|
|
|
"listBy": func(obj []any, fieldAndValues ...any) []any { return nil },
|
|
|
|
"hasBy": func(obj []any, fieldAndValues ...any) bool { return false },
|
|
|
|
"getBy": func(obj []any, fieldAndValues ...any) any { return nil },
|
|
|
|
"setBy": func(obj []any, value any, fieldAndValues ...any) {},
|
|
|
|
"indexBy": func(obj []any, fieldAndValues ...any) int { return 0 },
|
|
|
|
"removeBy": func(obj []any, fieldAndValues ...any) int { return 0 },
|
|
|
|
"removeArrayItem": func(list []any, item any) {},
|
|
|
|
"last": func(arr []any) any { return nil },
|
|
|
|
"len": func(obj any) int { return 0 },
|
|
|
|
"mergeBy": func(olds []any, news []any, fields ...string) []any { return nil },
|
|
|
|
"sortBy": func(arr []any, field string, isReverse *bool, sortType *string) []any { return nil },
|
|
|
|
"in": func(arr []any, v any) bool { return false },
|
|
|
|
"uniquePush": func(arr []any, values ...any) {},
|
|
|
|
"clearEmpty": func(arr []any) []any { return nil },
|
|
|
|
"split": func(str string, separator string) []string { return nil },
|
|
|
|
"join": func(arr []any, separator string) string { return "" },
|
|
|
|
"copy": func(obj any, isDeepCopy bool) any { return nil },
|
2024-01-25 16:07:48 +08:00
|
|
|
},
|
|
|
|
})
|
|
|
|
}
|
2024-07-04 11:14:34 +08:00
|
|
|
|
|
|
|
func makeTime(tm time.Time) *Time {
|
|
|
|
return &Time{tm: tm}
|
|
|
|
}
|
|
|
|
|
|
|
|
type Time struct {
|
|
|
|
tm time.Time
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t *Time) After(u *Time) bool {
|
|
|
|
return t.tm.After(u.tm)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t *Time) Before(u *Time) bool {
|
|
|
|
return t.tm.Before(u.tm)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t *Time) Compare(u *Time) int {
|
|
|
|
return t.tm.Compare(u.tm)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t *Time) Equal(u *Time) bool {
|
|
|
|
return t.tm.Equal(u.tm)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t *Time) Year() int {
|
|
|
|
return t.tm.Year()
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t *Time) Month() int {
|
|
|
|
return int(t.tm.Month())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t *Time) Day() int {
|
|
|
|
return t.tm.Day()
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t *Time) Weekday() int {
|
|
|
|
return int(t.tm.Weekday())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t *Time) ISOWeek() (year, week int) {
|
|
|
|
return t.tm.ISOWeek()
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t *Time) Hour() int {
|
|
|
|
return t.tm.Hour()
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t *Time) Minute() int {
|
|
|
|
return t.tm.Minute()
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t *Time) Second() int {
|
|
|
|
return t.tm.Second()
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t *Time) Millisecond() int {
|
|
|
|
return t.tm.Nanosecond() / 1000000
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t *Time) YearDay() int {
|
|
|
|
return t.tm.YearDay()
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t *Time) Add(msec int) *Time {
|
|
|
|
return makeTime(t.tm.Add(time.Duration(msec) * time.Millisecond))
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t *Time) Sub(u *Time) int {
|
|
|
|
return int(t.tm.Sub(u.tm) / time.Millisecond)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t *Time) AddDate(years int, months int, days int) *Time {
|
|
|
|
return makeTime(t.tm.AddDate(years, months, days))
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t *Time) UTC() *Time {
|
|
|
|
return makeTime(t.tm.UTC())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t *Time) Local() *Time {
|
|
|
|
return makeTime(t.tm.Local())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t *Time) Location() string {
|
|
|
|
return t.tm.Location().String()
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t *Time) Zone() string {
|
|
|
|
name, _ := t.tm.Zone()
|
|
|
|
return name
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t *Time) ZoneOffset() int {
|
|
|
|
_, offset := t.tm.Zone()
|
|
|
|
return offset
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t *Time) Unix() int64 {
|
|
|
|
return t.tm.UnixMilli()
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t *Time) Format(fmt *string) string {
|
|
|
|
if fmt == nil || *fmt == "" {
|
|
|
|
fmt2 := "2006-01-02 15:04:05"
|
|
|
|
fmt = &fmt2
|
|
|
|
}
|
|
|
|
return t.tm.Format(*fmt)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t *Time) String() string {
|
|
|
|
return t.Format(nil)
|
|
|
|
}
|