• 周期时间计算方法《二》

    1. package main
    2.  
    3. import (
    4. 	"fmt"
    5. 	"sort"
    6. 	"strconv"
    7. 	"strings"
    8. 	"time"
    9. )
    10.  
    11. /*
    12. 创建会议时相关参数:
    13. wholeType		Int 	是否全天会议
    14. startTime		int	UTC Unix时间戳，以秒为单位。必填,若是周期会议为周期会议的第一场开始时间
    15. length	    	int	时长(按分钟传递) ， 必填， 有值
    16. timezone		String	按照标准的时区传递：如Asia/Chongqing等， 必填
    17. cycleRole		Json格式	周期规则(可为空)。空代表非循环会议；否则为循环会议
    18. repeatCount		Int	循环的次数,范围2 - 100
    19. repeatEndDate	Int	周期的结束时间，如果客户选择结束时间时，参数为当天的23:59:59，并不是会议的最后一场会议的结束时间
    21. 说明: startTime非创建会议时指定的时间戳, 而是周期会议的第一场开始时间, 由客户端计算(满足周期规则且最近的)
    22. 举例: 创建会议时开始时间为 2018/01/25 18:00(周四), 周期规则为每周一、三、五, 实际传递的startTime为1516960800(2018/01/26 18:00)
    23. TODO: 服务器对startTime进行验证
    24. */
    25.  
    26. type TRecurrenceInfo struct {
    27. 	EventId           uint64 `json:"-"`
    28. 	Frequency         string `json:"frequency,omitempty"`     // daily, weekly, monthly, yearly
    29. 	Interval          int64  `json:"interval,omitempty"`      // 每几天(1-365)/周(1-52)/月(1-12)/年(1-10)
    30. 	ByDay             string `json:"byday,omitempty"`         // 星期几(SU,MO,TU,WE,TH,FR,SA), CSV格式字符串, 所以存在可能为多个
    31. 	ByMonth           string `json:"bymonth,omitempty"`       // 几月(1-12)
    32. 	ByMonthDay        string `json:"bymonthday,omitempty"`    // 几号(1-31)
    33. 	BySetPos          string `json:"bysetpos,omitempty"`      // 第几周(1-5)
    34. 	RecurrenceCount   int64  `json:"repeatcount,omitempty"`   // 循环次数(2-100)
    35. 	RecurrenceEndDate int64  `json:"repeatenddate,omitempty"` // 时间戳(秒)
    36. }
    37. type TRecurrenceInfoList []*TRecurrenceInfo
    38.  
    39. func (r *TRecurrenceInfo) EqualTo(rhs *TRecurrenceInfo) bool {
    40. 	return r.Frequency == rhs.Frequency &&
    41. 		r.Interval == rhs.Interval &&
    42. 		r.ByDay == rhs.ByDay &&
    43. 		r.ByMonth == rhs.ByMonth &&
    44. 		r.ByMonthDay == rhs.ByMonthDay &&
    45. 		r.BySetPos == rhs.BySetPos &&
    46. 		r.RecurrenceCount == rhs.RecurrenceCount &&
    47. 		r.RecurrenceEndDate == rhs.RecurrenceEndDate
    48. }
    49.  
    50. const (
    51. 	DayDuration   = int64(time.Hour) * 24
    52. 	WeekDuration  = int64(time.Hour) * 24 * 7
    53. 	MonthDuration = int64(time.Hour) * 24 * 30
    54. 	YearDuration  = int64(time.Hour) * 24 * 365
    55. )
    56.  
    57. //@index 表示的是周期会议里的第几天
    58. //@fstStartTime 预约会议的开始的时间，不一定是第一场周期会议的时间，比如，对于以“周”为周期，每周工作日这种case,如果是周六预约会议，每个工作日的五点开始会议，那么，这个fstStartTime则表示周六五点这个时间
    59. //@fstEndTime 预约会议的结束时间，不一定是第一场周期会议的时间
    60. func (rule *TRecurrenceInfo) GetRecurrenceTime(index, fstStartTime, fstEndTime int64, loc *time.Location) (start, end time.Time) {
    61. 	if index < 0 {
    62. 		return
    63. 	}
    64.  
    65. 	// 处理周期会议
    66. 	var deltaDuration int64 = 0
    67. 	if rule.RecurrenceCount > 0 {
    68. 		if index >= rule.RecurrenceCount {
    69. 			return
    70. 		}
    71. 	}
    72.  
    73. 	start = time.Unix(fstStartTime, 0).In(loc)
    74. 	end = time.Unix(fstEndTime, 0).In(loc)
    75.  
    76. 	interval := rule.Interval
    77. 	switch strings.ToUpper(rule.Frequency) {
    78. 	case DayRecurrenceFrequency:
    79. 		deltaDuration = index * interval * DayDuration
    80. 		start = start.Add(time.Duration(deltaDuration))
    81. 		end = end.Add(time.Duration(deltaDuration))
    82. 	case WeekRecurrenceFrequency:
    83. 		dayList := strings.Split(rule.ByDay, ",")
    84. 		dayLen := int64(len(dayList))
    85. 		if dayLen == 0 {
    86. 			//case:ByDay:"MO"
    87. 			dayList = append(dayList, rule.ByDay)
    88. 		}
    89. 		if len(dayList) > 0 {
    90. 			//获取周期会议的第一场时间
    91. 			start, end = rule.GetWeekRuleFstDay(start, end, loc)
    92. 			startWeekday := start.Weekday()
    93. 			firstDay := string(WeekdayString(startWeekday))
    94. 			firstDayInt := int64(startWeekday)
    95. 			//周期会议的第一场，这一天是周期规则中第几个
    96. 			//比如：会议开始时间是周二，周期规则为每周二三五，则可以算出，符合规则中的第1个规则
    97. 			offset := 0
    98. 			for i, day := range dayList {
    99. 				if day == firstDay {
    100. 					offset = i
    101. 					break
    102. 				}
    103. 			}
    104. 			indexForRule := index + int64(offset)
    105. 			i := indexForRule / dayLen // 第i周
    106. 			j := indexForRule % dayLen // 第i周第j个规则
    107.  
    108. 			// 计算第i周的时间间隔
    109. 			deltaDuration = i * interval * WeekDuration
    110. 			dayInt := int64(WeekdayInt(dayList[j]))
    111. 			// 星期日为0，转换为7, 客户端顺序为星期一、二、三、四、五、六、日
    112. 			if dayInt == 0 {
    113. 				dayInt = 7
    114. 			}
    115. 			if firstDayInt == 0 {
    116. 				firstDayInt = 7
    117. 			}
    118. 			// 加上与第一场间隔的天数, 有可能为负数
    119. 			delta := (dayInt - firstDayInt) * DayDuration
    120. 			deltaDuration += delta
    121. 			//fmt.Println("start:", start, "end:", end, "dayList:", dayList, "startWeekday:", startWeekday, "offset:", offset, "indexForRule:", indexForRule, "i:", i, "j:", j, "dayInt:", dayInt, "firstDayInt", firstDayInt)
    122. 			start = start.Add(time.Duration(deltaDuration))
    123. 			end = end.Add(time.Duration(deltaDuration))
    124. 		}
    125. 	case MonthRecurrenceFrequency:
    126. 		if rule.BySetPos == "" {
    127. 			dayList := strings.Split(rule.ByMonthDay, ",") //比如：ByMonthDay:"2,3,4,5,6"
    128. 			dayLen := int64(len(dayList))
    129. 			if dayLen == 0 {
    130. 				//case:ByMonthDay:"2"
    131. 				dayList = append(dayList, rule.ByMonthDay)
    132. 			}
    133. 			if len(dayList) > 0 {
    134. 				//获取周期会议的第一场时间
    135. 				start, end = rule.GetMonthRuleFstDay(start, end, dayList, loc)
    136. 				_, _, startMonthDay := start.Date()
    137. 				offset := 0 //表示符合第几个周期规则
    138. 				//周期会议的第一场，这一天是周期规则中第几个
    139. 				//比如：会议开始时间是20号，周期规则为每月1，5，10，20，25号，则可以算出，符合规则中的第四个规则
    140. 				for i, day := range dayList {
    141. 					if ToInt64(day, 0) == int64(startMonthDay) {
    142. 						offset = i
    143. 						break
    144. 					}
    145. 				}
    146. 				//第几场周期会议相对于第一场会议，间隔几个月，第几个月的第几天
    147. 				indexForRule := index + int64(offset)
    148. 				i := indexForRule / dayLen // 第i月
    149. 				j := indexForRule % dayLen // 第i月第j个规则
    150.  
    151. 				// 计算第i月的时间间隔
    152. 				nextMonthTime := start.AddDate(0, int(i*interval), 0)
    153. 				deltaDuration = int64(nextMonthTime.Sub(start))
    154. 				dayInt := ToInt64(dayList[j], 0)
    155. 				//fmt.Println("dayList:", dayList, "startMonthDay:", startMonthDay, "offset:", offset, "indexForRule:", indexForRule, "i:", i, "j:", j, "dayInt:", dayInt)
    156. 				// 加上与开始时间间隔的天数, 有可能为负数
    157. 				delta := (dayInt - int64(startMonthDay)) * DayDuration
    158. 				deltaDuration += delta
    159. 				start = start.Add(time.Duration(deltaDuration))
    160. 				end = end.Add(time.Duration(deltaDuration))
    161. 				break
    162. 			}
    163. 		} else {
    164. 			bySetPos := ToInt64(rule.BySetPos, 1)
    165. 			year, month, _ := start.Date()
    166. 			hour, minute, sec := start.Clock()
    167. 			start = Date(year, month+time.Month(index*interval), int(bySetPos),
    168. 				WeekdayInt(rule.ByDay), hour, minute, sec, start.Location())
    169.  
    170. 			year, month, _ = end.Date()
    171. 			hour, minute, sec = start.Clock()
    172. 			end = Date(year, month+time.Month(index*interval), int(bySetPos),
    173. 				WeekdayInt(rule.ByDay), hour, minute, sec, end.Location())
    174. 		}
    175.  
    176. 	case YearRecurrenceFrequency:
    177. 		if rule.BySetPos == "" {
    178. 			nextYearTime := start.AddDate(int(index*interval), 0, 0)
    179. 			deltaDuration = int64(nextYearTime.Sub(start))
    180. 			start = start.Add(time.Duration(deltaDuration))
    181. 			end = end.Add(time.Duration(deltaDuration))
    182. 		} else {
    183. 			bySetPos := ToInt64(rule.BySetPos, 1)
    184. 			year, month, _ := start.Date()
    185. 			hour, minute, sec := start.Clock()
    186. 			start = Date(year+int(index*interval), month, int(bySetPos),
    187. 				WeekdayInt(rule.ByDay), hour, minute, sec, start.Location())
    188.  
    189. 			year, month, _ = end.Date()
    190. 			hour, minute, sec = end.Clock()
    191. 			end = Date(year+int(index*interval), month, int(bySetPos),
    192. 				WeekdayInt(rule.ByDay), hour, minute, sec, end.Location())
    193. 		}
    194. 	}
    195.  
    196. 	if rule.RecurrenceEndDate == 0 {
    197. 		return
    198. 	}
    199.  
    200. 	last := time.Unix(rule.RecurrenceEndDate, 0).In(start.Location())
    201. 	if start.After(last) {
    202. 		start = time.Time{}
    203. 		end = time.Time{}
    204. 	}
    205.  
    206. 	return
    207. }
    208.  
    209. func (rule *TRecurrenceInfo) convertDayList() []int {
    210. 	dayList := strings.Split(rule.ByDay, ",")
    211. 	if len(dayList) == 0 {
    212. 		dayList = append(dayList, rule.ByDay)
    213. 	}
    214. 	dayWeekInts := make([]int, 0)
    215. 	for _, day := range dayList {
    216. 		dayWeekInt := int(WeekdayInt(day))
    217. 		if dayWeekInt == 0 {
    218. 			dayWeekInt = 7
    219. 		}
    220. 		dayWeekInts = append(dayWeekInts, dayWeekInt)
    221. 	}
    222. 	sort.Ints(dayWeekInts)
    223. 	return dayWeekInts
    224. }
    225.  
    226. //获取周规则的周期会议的第一场会议
    227. func (rule *TRecurrenceInfo) GetWeekRuleFstDay(start, end time.Time, loc *time.Location) (fstStartTime, fstEndTime time.Time) {
    228. 	startWeekday := start.Weekday()
    229. 	startWeekDayInt := int64(startWeekday)
    230. 	dayList := rule.convertDayList()
    231. 	//因为，传进来的参数，不是符合周期规则的会议开始时间，而是，当天预约会议的开始时间
    232. 	//因此，当传进来的时间，不是周期规则的时间，则计算出周期会议第一场的开始时间
    233.  
    234. 	//周期规则中的第几个规则,比如：周期规则是周的一，三，五。
    235. 	//如果是周二约的会议，那么周期会议的第一场应该是周三，offset就是1即周期规则中的第二个。
    236. 	//如果是周六约的会议，那么第一场就应该是下周一，offset取0
    237. 	//如果是周五预约的会议，那么这个时间就是第一场的时间，直接返回
    238. 	offset := 0
    239. 	for i, day := range dayList {
    240. 		dayInt := ToInt64(day, 0)
    241. 		if dayInt == startWeekDayInt {
    242. 			fstStartTime = start
    243. 			fstEndTime = end
    244. 			return
    245. 		}
    246. 		if dayInt > startWeekDayInt {
    247. 			offset = i
    248. 			break
    249. 		}
    250. 	}
    251. 	fstWeekDay := int64(dayList[offset])
    252. 	var deleduration int64
    253. 	deleduration = (fstWeekDay - startWeekDayInt) * DayDuration
    254. 	if deleduration < 0 {
    255. 		deleduration = (int64(7) - startWeekDayInt + fstWeekDay) * DayDuration
    256. 	}
    257. 	fstStartTime = start.Add(time.Duration(deleduration))
    258. 	fstEndTime = end.Add(time.Duration(deleduration))
    259. 	return
    260. }
    261.  
    262. //获取月规则的周期会议的第一场会议
    263. func (rule *TRecurrenceInfo) GetMonthRuleFstDay(start, end time.Time, dayList []string, loc *time.Location) (fstStartTime, fstEndTime time.Time) {
    264. 	_, _, startMonthDay := start.Date()
    265. 	//因为，传进来的参数，不是符合周期规则的会议开始时间，而是，当天预约会议的开始时间
    266. 	//因此，当传进来的时间，不是周期规则的时间，则计算出周期会议第一场的开始时间
    267.  
    268. 	//周期规则中的第几个规则,比如：周期规则是每个月的5，10，15，20号。
    269. 	//如果是11号约的会议，那么周期会议的第一场应该是15号，offset就是2即周期规则中的第三个。
    270. 	//如果是21号约的会议，那么第一场就应该是下个月的5号，offset取0
    271. 	//如果是20号预约的会议，那么这个时间就是第一场的时间，直接返回
    272. 	offset := 0
    273. 	for i, day := range dayList {
    274. 		dayInt := ToInt64(day, 0)
    275. 		if dayInt == int64(startMonthDay) {
    276. 			fstStartTime = start
    277. 			fstEndTime = end
    278. 			return
    279. 		}
    280. 		if dayInt > int64(startMonthDay) {
    281. 			offset = i
    282. 			break
    283. 		}
    284. 	}
    285. 	dayInt := int(ToInt64(dayList[offset], 0))
    286. 	year, month, _ := start.Date()
    287. 	hour, minute, sec := start.Clock()
    288. 	if offset == 0 {
    289. 		month = month + 1
    290. 	}
    291. 	fstStartTime = time.Date(year, month, dayInt, hour, minute, sec, 0, loc)
    292. 	year, month, _ = end.Date()
    293. 	hour, minute, sec = end.Clock()
    294. 	fstEndTime = time.Date(year, month, dayInt, hour, minute, sec, 0, loc)
    295. 	return
    296. }
    297.  
    298. func Date(year int, month time.Month, monthWeek int, weekDay time.Weekday, hour, minute, sec int, loc *time.Location) time.Time {
    299. 	monthFstDayTime := time.Date(year, month, 1, hour, minute, sec, 0, loc) //一号
    300. 	week := monthFstDayTime.Weekday()
    301.  
    302. 	var monthDay int = 1
    303. 	if week != time.Sunday { // 算出第一个星期天到底是几号
    304. 		monthDay = 1 + int(time.Sunday) - int(week)
    305. 	}
    306.  
    307. 	monthDay = monthDay + (monthWeek * 7) + int(weekDay)
    308.  
    309. 	return time.Date(year, month, monthDay, hour, minute, sec, 0, loc)
    310. }
    311.  
    312. func ToInt64(v interface{}, defaultVal int64) int64 {
    313. 	if v == nil {
    314. 		return defaultVal
    315. 	}
    316.  
    317. 	switch v.(type) {
    318. 	case bool:
    319. 		if v.(bool) {
    320. 			return 1
    321. 		}
    322. 		return 0
    323. 	case string:
    324. 		i, err := strconv.ParseInt(v.(string), 10, 64)
    325. 		if err != nil {
    326. 			return defaultVal
    327. 		}
    328. 		return i
    329. 	case uint64:
    330. 		return int64(v.(uint64))
    331. 	case int64:
    332. 		return int64(v.(int64))
    333. 	case int:
    334. 		return int64(v.(int))
    335. 	case int32:
    336. 		return int64(v.(int32))
    337. 	case uint32:
    338. 		return int64(v.(uint32))
    339. 	case float64:
    340. 		return int64(v.(float64))
    341. 	case int8:
    342. 		return int64(v.(int8))
    343. 	case uint8:
    344. 		return int64(v.(uint8))
    345. 	}
    346. 	return defaultVal
    347. }
    348.  
    349. // the frequency an event recurs
    350. type RecurrenceFrequency string
    351.  
    352. const (
    353. 	SecondRecurrenceFrequency RecurrenceFrequency = "SECONDLY"
    354. 	MinuteRecurrenceFrequency                     = "MINUTELY"
    355. 	HourRecurrenceFrequency                       = "HOURLY"
    356. 	DayRecurrenceFrequency                        = "DAILY"
    357. 	WeekRecurrenceFrequency                       = "WEEKLY"
    358. 	MonthRecurrenceFrequency                      = "MONTHLY"
    359. 	YearRecurrenceFrequency                       = "YEARLY"
    360. )
    361.  
    362. // the frequency an event recurs
    363. type RecurrenceWeekday string
    364.  
    365. const (
    366. 	MondayRecurrenceWeekday    RecurrenceWeekday = "MO"
    367. 	TuesdayRecurrenceWeekday                     = "TU"
    368. 	WednesdayRecurrenceWeekday                   = "WE"
    369. 	ThursdayRecurrenceWeekday                    = "TH"
    370. 	FridayRecurrenceWeekday                      = "FR"
    371. 	SaturdayRecurrenceWeekday                    = "SA"
    372. 	SundayRecurrenceWeekday                      = "SU"
    373. )
    374.  
    375. func WeekdayString(weekday time.Weekday) RecurrenceWeekday {
    376. 	var r RecurrenceWeekday
    377. 	switch weekday {
    378. 	case time.Sunday:
    379. 		r = SundayRecurrenceWeekday
    380. 	case time.Monday:
    381. 		r = MondayRecurrenceWeekday
    382. 	case time.Tuesday:
    383. 		r = TuesdayRecurrenceWeekday
    384. 	case time.Wednesday:
    385. 		r = WednesdayRecurrenceWeekday
    386. 	case time.Thursday:
    387. 		r = ThursdayRecurrenceWeekday
    388. 	case time.Friday:
    389. 		r = FridayRecurrenceWeekday
    390. 	case time.Saturday:
    391. 		return SaturdayRecurrenceWeekday
    392. 	}
    393. 	return r
    394. }
    395.  
    396. func WeekdayInt(s string) time.Weekday {
    397. 	var r time.Weekday
    398. 	switch RecurrenceWeekday(s) {
    399. 	case SundayRecurrenceWeekday:
    400. 		r = time.Sunday
    401. 	case MondayRecurrenceWeekday:
    402. 		r = time.Monday
    403. 	case TuesdayRecurrenceWeekday:
    404. 		r = time.Tuesday
    405. 	case WednesdayRecurrenceWeekday:
    406. 		r = time.Wednesday
    407. 	case ThursdayRecurrenceWeekday:
    408. 		r = time.Thursday
    409. 	case FridayRecurrenceWeekday:
    410. 		r = time.Friday
    411. 	case SaturdayRecurrenceWeekday:
    412. 		r = time.Saturday
    413. 	}
    414. 	return r
    415. }
    416.  
    417. func main() {
    418. 	GetWeekRuleRecurrenceTime()
    419. 	GetWeekRuleRecurrenceTime2()
    420. 	GetWeekRuleRecurrenceTime3()
    421. 	GetWeekRuleRecurrenceTime4()
    422. 	GetWeekRuleRecurrenceTime11()
    423. 	GetWeekRuleRecurrenceTime22()
    424. 	GetWeekRuleRecurrenceTime33()
    425. 	GetWeekRuleRecurrenceTime44()
    426. 	GetMonthRuleRecurrenceTime()
    427. 	GetMonthRuleRecurrenceTime2()
    428. 	GetMonthRuleRecurrenceTime3()
    429. 	GetMonthRuleRecurrenceTime4()
    430. 	GetMonthRuleRecurrenceTime11()
    431. 	GetMonthRuleRecurrenceTime22()
    432. 	GetMonthRuleRecurrenceTime33()
    433. 	GetMonthRuleRecurrenceTime44()
    434. }
    435.  
    436. func GetWeekRuleRecurrenceTime() {
    437. 	start := time.Now()
    438. 	defer func() {
    439. 		cost := time.Since(start)
    440. 		fmt.Println("TestGetRecurrenceTimeWeek cost=", cost)
    441. 	}()
    442. 	fmt.Println("####################TestGetRecurrenceTimeWeek...")
    443. 	loc, _ := time.LoadLocation("Asia/Shanghai")
    444. 	fstStartTime := int64(1661331600) // 2022-08-24 17:00:00  //周三
    445. 	fstEndTime := int64(1661335200)   // 2022-08-24 18:00:00
    446. 	recurr := TRecurrenceInfo{}
    447. 	recurr.Frequency = "weekly"
    448. 	recurr.Interval = 1
    449. 	recurr.ByDay = "TU,SU" // 星期二、日
    450.  
    451. 	for i := 0; i <= 10; i++ {
    452. 		start, end := recurr.GetRecurrenceTime(int64(i), fstStartTime, fstEndTime, loc)
    453. 		fmt.Println("start:", start, "end:", end)
    454. 	}
    455. }
    456.  
    457. func GetWeekRuleRecurrenceTime2() {
    458. 	start := time.Now()
    459. 	defer func() {
    460. 		cost := time.Since(start)
    461. 		fmt.Println("TestGetRecurrenceTimeWeek cost=", cost)
    462. 	}()
    463. 	fmt.Println("####################TestGetRecurrenceTimeWeek2...")
    464. 	loc, _ := time.LoadLocation("Asia/Shanghai")
    465. 	fstStartTime := int64(1661331600) // 2022-08-24 17:00:00  //周三
    466. 	fstEndTime := int64(1661335200)   // 2022-08-24 18:00:00
    467. 	recurr := TRecurrenceInfo{}
    468. 	recurr.Frequency = "weekly"
    469. 	recurr.Interval = 1
    470. 	recurr.ByDay = "TU,WE,SU" // 星期二、三、日
    471.  
    472. 	for i := 0; i <= 10; i++ {
    473. 		start, end := recurr.GetRecurrenceTime(int64(i), fstStartTime, fstEndTime, loc)
    474. 		fmt.Println("start:", start, "end:", end)
    475. 	}
    476. }
    477.  
    478. func GetWeekRuleRecurrenceTime3() {
    479. 	start := time.Now()
    480. 	defer func() {
    481. 		cost := time.Since(start)
    482. 		fmt.Println("TestGetRecurrenceTimeWeek cost=", cost)
    483. 	}()
    484. 	fmt.Println("####################TestGetRecurrenceTimeWeek3...")
    485. 	loc, _ := time.LoadLocation("Asia/Shanghai")
    486. 	fstStartTime := int64(1661331600) // 2022-08-24 17:00:00  //周三
    487. 	fstEndTime := int64(1661335200)   // 2022-08-24 18:00:00
    488. 	recurr := TRecurrenceInfo{}
    489. 	recurr.Frequency = "weekly"
    490. 	recurr.Interval = 1
    491. 	recurr.ByDay = "MO,TU" // 星期一、二
    492.  
    493. 	for i := 0; i <= 10; i++ {
    494. 		start, end := recurr.GetRecurrenceTime(int64(i), fstStartTime, fstEndTime, loc)
    495. 		fmt.Println("start:", start, "end:", end)
    496. 	}
    497. }
    498.  
    499. func GetWeekRuleRecurrenceTime4() {
    500. 	start := time.Now()
    501. 	defer func() {
    502. 		cost := time.Since(start)
    503. 		fmt.Println("TestGetRecurrenceTimeWeek cost=", cost)
    504. 	}()
    505. 	fmt.Println("####################TestGetRecurrenceTimeWeek4...")
    506. 	loc, _ := time.LoadLocation("Asia/Shanghai")
    507. 	fstStartTime := int64(1661331600) // 2022-08-24 17:00:00  //周三
    508. 	fstEndTime := int64(1661335200)   // 2022-08-24 18:00:00
    509. 	recurr := TRecurrenceInfo{}
    510. 	recurr.Frequency = "weekly"
    511. 	recurr.Interval = 1
    512. 	recurr.ByDay = "WE" // 星期三
    513.  
    514. 	for i := 0; i <= 10; i++ {
    515. 		start, end := recurr.GetRecurrenceTime(int64(i), fstStartTime, fstEndTime, loc)
    516. 		fmt.Println("start:", start, "end:", end)
    517. 	}
    518. }
    519.  
    520. func GetWeekRuleRecurrenceTime11() {
    521. 	start := time.Now()
    522. 	defer func() {
    523. 		cost := time.Since(start)
    524. 		fmt.Println("TestGetRecurrenceTimeWeek11 cost=", cost)
    525. 	}()
    526. 	fmt.Println("####################TestGetRecurrenceTimeWeek11...")
    527. 	loc, _ := time.LoadLocation("Asia/Shanghai")
    528. 	fstStartTime := int64(1661331600) // 2022-08-24 17:00:00  //周三
    529. 	fstEndTime := int64(1661335200)   // 2022-08-24 18:00:00
    530. 	recurr := TRecurrenceInfo{}
    531. 	recurr.Frequency = "weekly"
    532. 	recurr.Interval = 2
    533. 	recurr.ByDay = "TU,SU" // 星期二、日
    534.  
    535. 	for i := 0; i <= 10; i++ {
    536. 		start, end := recurr.GetRecurrenceTime(int64(i), fstStartTime, fstEndTime, loc)
    537. 		fmt.Println("start:", start, "end:", end)
    538. 	}
    539. }
    540.  
    541. func GetWeekRuleRecurrenceTime22() {
    542. 	start := time.Now()
    543. 	defer func() {
    544. 		cost := time.Since(start)
    545. 		fmt.Println("TestGetRecurrenceTimeWeek cost=", cost)
    546. 	}()
    547. 	fmt.Println("####################TestGetRecurrenceTimeWeek22...")
    548. 	loc, _ := time.LoadLocation("Asia/Shanghai")
    549. 	fstStartTime := int64(1661331600) // 2022-08-24 17:00:00  //周三
    550. 	fstEndTime := int64(1661335200)   // 2022-08-24 18:00:00
    551. 	recurr := TRecurrenceInfo{}
    552. 	recurr.Frequency = "weekly"
    553. 	recurr.Interval = 2
    554. 	recurr.ByDay = "TU,WE,SU" // 星期二、三、日
    555.  
    556. 	for i := 0; i <= 10; i++ {
    557. 		start, end := recurr.GetRecurrenceTime(int64(i), fstStartTime, fstEndTime, loc)
    558. 		fmt.Println("start:", start, "end:", end)
    559. 	}
    560. }
    561.  
    562. func GetWeekRuleRecurrenceTime33() {
    563. 	start := time.Now()
    564. 	defer func() {
    565. 		cost := time.Since(start)
    566. 		fmt.Println("TestGetRecurrenceTimeWeek cost=", cost)
    567. 	}()
    568. 	fmt.Println("####################TestGetRecurrenceTimeWeek33...")
    569. 	loc, _ := time.LoadLocation("Asia/Shanghai")
    570. 	fstStartTime := int64(1661331600) // 2022-08-24 17:00:00  //周三
    571. 	fstEndTime := int64(1661335200)   // 2022-08-24 18:00:00
    572. 	recurr := TRecurrenceInfo{}
    573. 	recurr.Frequency = "weekly"
    574. 	recurr.Interval = 2
    575. 	recurr.ByDay = "MO,TU" // 星期一、二
    576.  
    577. 	for i := 0; i <= 10; i++ {
    578. 		start, end := recurr.GetRecurrenceTime(int64(i), fstStartTime, fstEndTime, loc)
    579. 		fmt.Println("start:", start, "end:", end)
    580. 	}
    581. }
    582.  
    583. func GetWeekRuleRecurrenceTime44() {
    584. 	start := time.Now()
    585. 	defer func() {
    586. 		cost := time.Since(start)
    587. 		fmt.Println("TestGetRecurrenceTimeWeek cost=", cost)
    588. 	}()
    589. 	fmt.Println("####################TestGetRecurrenceTimeWeek44...")
    590. 	loc, _ := time.LoadLocation("Asia/Shanghai")
    591. 	fstStartTime := int64(1661331600) // 2022-08-24 17:00:00  //周三
    592. 	fstEndTime := int64(1661335200)   // 2022-08-24 18:00:00
    593. 	recurr := TRecurrenceInfo{}
    594. 	recurr.Frequency = "weekly"
    595. 	recurr.Interval = 2
    596. 	recurr.ByDay = "WE" // 星期三
    597.  
    598. 	for i := 0; i <= 10; i++ {
    599. 		start, end := recurr.GetRecurrenceTime(int64(i), fstStartTime, fstEndTime, loc)
    600. 		fmt.Println("start:", start, "end:", end)
    601. 	}
    602. }
    603.  
    604. func GetMonthRuleRecurrenceTime() {
    605. 	start := time.Now()
    606. 	defer func() {
    607. 		cost := time.Since(start)
    608. 		fmt.Println("TestGetRecurrenceTimeMonth cost=", cost)
    609. 	}()
    610. 	fmt.Println("####################TestGetRecurrenceTimeMonth1...")
    611. 	loc, _ := time.LoadLocation("Asia/Shanghai")
    612. 	fstStartTime := int64(1661331600) // 2022-08-24 17:00:00
    613. 	fstEndTime := int64(1661335200)   // 2022-08-24 18:00:00
    614. 	recurr := TRecurrenceInfo{}
    615. 	recurr.Frequency = "monthly"
    616. 	recurr.Interval = 1
    617. 	recurr.ByMonthDay = "2,3,4,5,6"
    618.  
    619. 	for i := 0; i <= 10; i++ {
    620. 		start, end := recurr.GetRecurrenceTime(int64(i), fstStartTime, fstEndTime, loc)
    621. 		fmt.Println("start:", start, "end:", end)
    622. 	}
    623. }
    624.  
    625. func GetMonthRuleRecurrenceTime2() {
    626. 	start := time.Now()
    627. 	defer func() {
    628. 		cost := time.Since(start)
    629. 		fmt.Println("TestGetRecurrenceTimeMonth2 cost=", cost)
    630. 	}()
    631. 	fmt.Println("####################TestGetRecurrenceTimeMonth2...")
    632. 	loc, _ := time.LoadLocation("Asia/Shanghai")
    633. 	fstStartTime := int64(1661331600) // 2022-08-24 17:00:00
    634. 	fstEndTime := int64(1661335200)   // 2022-08-24 18:00:00
    635. 	recurr := TRecurrenceInfo{}
    636. 	recurr.Frequency = "monthly"
    637. 	recurr.Interval = 1
    638. 	recurr.ByMonthDay = "2,3,4,5,6,25,26,28"
    639.  
    640. 	for i := 0; i <= 10; i++ {
    641. 		start, end := recurr.GetRecurrenceTime(int64(i), fstStartTime, fstEndTime, loc)
    642. 		fmt.Println("start:", start, "end:", end)
    643. 	}
    644. }
    645.  
    646. func GetMonthRuleRecurrenceTime3() {
    647. 	start := time.Now()
    648. 	defer func() {
    649. 		cost := time.Since(start)
    650. 		fmt.Println("TestGetRecurrenceTimeMonth3 cost=", cost)
    651. 	}()
    652. 	fmt.Println("####################TestGetRecurrenceTimeMonth3...")
    653. 	loc, _ := time.LoadLocation("Asia/Shanghai")
    654. 	fstStartTime := int64(1661331600) // 2022-08-24 17:00:00
    655. 	fstEndTime := int64(1661335200)   // 2022-08-24 18:00:00
    656. 	recurr := TRecurrenceInfo{}
    657. 	recurr.Frequency = "monthly"
    658. 	recurr.Interval = 1
    659. 	recurr.ByMonthDay = "2,3,4,5,6,24,25,26,28"
    660.  
    661. 	for i := 0; i <= 10; i++ {
    662. 		start, end := recurr.GetRecurrenceTime(int64(i), fstStartTime, fstEndTime, loc)
    663. 		fmt.Println("start:", start, "end:", end)
    664. 	}
    665. }
    666.  
    667. func GetMonthRuleRecurrenceTime4() {
    668. 	start := time.Now()
    669. 	defer func() {
    670. 		cost := time.Since(start)
    671. 		fmt.Println("TestGetRecurrenceTimeMonth4 cost=", cost)
    672. 	}()
    673. 	fmt.Println("####################TestGetRecurrenceTimeMonth4...")
    674. 	loc, _ := time.LoadLocation("Asia/Shanghai")
    675. 	fstStartTime := int64(1661331600) // 2022-08-24 17:00:00
    676. 	fstEndTime := int64(1661335200)   // 2022-08-24 18:00:00
    677. 	recurr := TRecurrenceInfo{}
    678. 	recurr.Frequency = "monthly"
    679. 	recurr.Interval = 1
    680. 	recurr.ByMonthDay = "24"
    681.  
    682. 	for i := 0; i <= 10; i++ {
    683. 		start, end := recurr.GetRecurrenceTime(int64(i), fstStartTime, fstEndTime, loc)
    684. 		fmt.Println("start:", start, "end:", end)
    685. 	}
    686. }
    687.  
    688. func GetMonthRuleRecurrenceTime11() {
    689. 	start := time.Now()
    690. 	defer func() {
    691. 		cost := time.Since(start)
    692. 		fmt.Println("TestGetRecurrenceTimeMonth cost=", cost)
    693. 	}()
    694. 	fmt.Println("####################TestGetRecurrenceTimeMonth11...")
    695. 	loc, _ := time.LoadLocation("Asia/Shanghai")
    696. 	fstStartTime := int64(1661331600) // 2022-08-24 17:00:00
    697. 	fstEndTime := int64(1661335200)   // 2022-08-24 18:00:00
    698. 	recurr := TRecurrenceInfo{}
    699. 	recurr.Frequency = "monthly"
    700. 	recurr.Interval = 2
    701. 	recurr.ByMonthDay = "2,3,4,5,6"
    702.  
    703. 	for i := 0; i <= 10; i++ {
    704. 		start, end := recurr.GetRecurrenceTime(int64(i), fstStartTime, fstEndTime, loc)
    705. 		fmt.Println("start:", start, "end:", end)
    706. 	}
    707. }
    708.  
    709. func GetMonthRuleRecurrenceTime22() {
    710. 	start := time.Now()
    711. 	defer func() {
    712. 		cost := time.Since(start)
    713. 		fmt.Println("TestGetRecurrenceTimeMonth2 cost=", cost)
    714. 	}()
    715. 	fmt.Println("####################TestGetRecurrenceTimeMonth22...")
    716. 	loc, _ := time.LoadLocation("Asia/Shanghai")
    717. 	fstStartTime := int64(1661331600) // 2022-08-24 17:00:00
    718. 	fstEndTime := int64(1661335200)   // 2022-08-24 18:00:00
    719. 	recurr := TRecurrenceInfo{}
    720. 	recurr.Frequency = "monthly"
    721. 	recurr.Interval = 2
    722. 	recurr.ByMonthDay = "2,3,4,5,6,25,26,28"
    723.  
    724. 	for i := 0; i <= 10; i++ {
    725. 		start, end := recurr.GetRecurrenceTime(int64(i), fstStartTime, fstEndTime, loc)
    726. 		fmt.Println("start:", start, "end:", end)
    727. 	}
    728. }
    729.  
    730. func GetMonthRuleRecurrenceTime33() {
    731. 	start := time.Now()
    732. 	defer func() {
    733. 		cost := time.Since(start)
    734. 		fmt.Println("TestGetRecurrenceTimeMonth3 cost=", cost)
    735. 	}()
    736. 	fmt.Println("####################TestGetRecurrenceTimeMonth3...")
    737. 	loc, _ := time.LoadLocation("Asia/Shanghai")
    738. 	fstStartTime := int64(1661331600) // 2022-08-24 17:00:00
    739. 	fstEndTime := int64(1661335200)   // 2022-08-24 18:00:00
    740. 	recurr := TRecurrenceInfo{}
    741. 	recurr.Frequency = "monthly"
    742. 	recurr.Interval = 2
    743. 	recurr.ByMonthDay = "2,3,4,5,6,24,25,26,28"
    744.  
    745. 	for i := 0; i <= 10; i++ {
    746. 		start, end := recurr.GetRecurrenceTime(int64(i), fstStartTime, fstEndTime, loc)
    747. 		fmt.Println("start:", start, "end:", end)
    748. 	}
    749. }
    750.  
    751. func GetMonthRuleRecurrenceTime44() {
    752. 	start := time.Now()
    753. 	defer func() {
    754. 		cost := time.Since(start)
    755. 		fmt.Println("TestGetRecurrenceTimeMonth4 cost=", cost)
    756. 	}()
    757. 	fmt.Println("####################TestGetRecurrenceTimeMonth44...")
    758. 	loc, _ := time.LoadLocation("Asia/Shanghai")
    759. 	fstStartTime := int64(1661331600) // 2022-08-24 17:00:00
    760. 	fstEndTime := int64(1661335200)   // 2022-08-24 18:00:00
    761. 	recurr := TRecurrenceInfo{}
    762. 	recurr.Frequency = "monthly"
    763. 	recurr.Interval = 2
    764. 	recurr.ByMonthDay = "24"
    765.  
    766. 	for i := 0; i <= 10; i++ {
    767. 		start, end := recurr.GetRecurrenceTime(int64(i), fstStartTime, fstEndTime, loc)
    768. 		fmt.Println("start:", start, "end:", end)
    769. 	}
    770. }

  • 相关阅读:
    STM32笔记
    arima模型python代码
    RNN/LSTM学习记录
    中国人民大学与加拿大女王大学金融硕士——人生总要逼自己一把
    axios和SpringMVC数据交互（一维二维数组，JSON/form形式，@RequestBody/@RequestParam）
    PDF头部报错:Evaluation Warning : The document was created with Spire.PDF for Java.
    九章云极DataCanvas公司完成D1轮融资
    矩阵论复习提纲
    Spring——Bean管理XML方式
    什么样的企业最需要MES？
  • 原文地址：https://blog.csdn.net/ezreal_pan/article/details/126508646