28.11.2022 в 12:35

Некоторые из библиотек golang для времени и временных задач

Избегайте изобретать велосипед заново. Если есть какие-то хорошие библиотеки, мы просто используем их напрямую, нет необходимости выполнять какую-то дублирующую работу, если эти библиотеки не могут удовлетворить потребности, может быть отправлен запрос на извлечение или клонирование их, улучшение их, оптимизация их, текущая предпосылка заключается в том, что вы должны их знать.

Эта статья дает вам некоторую информацию о времени и аналогичной функции linux cron библиотеки задач синхронизации.

jinzhu/now

jinzhu написал несколько хороших библиотек Go в дополнение к вкладу gorm, jinzhu/now - одна из них.

В настоящее время стандартная библиотека Go предоставляет библиотеку о времени time, которая может удовлетворить 80% наших сценариев, но для некоторых специальных сценариев использовать стандартную библиотеку проблематично, и то же самое верно для некоторых других языков программирования, связанные со временем функции в стандартной библиотеке не удобны для использования в некоторых специальных сценариях jinzhu предоставляет библиотеку now для удовлетворения потребностей некоторых специальных сценариев, она особенно удобна в использовании.

Наиболее важные функции этой библиотеки я разделил на две категории:

функции, которые вычисляют первый и последний день;
синтаксического анализа.

Конечно, он также содержит функции для нахождения четырех сезонов, а также функции для явного нахождения воскресенья-понедельника (в некоторых странах и регионах воскресенье считается началом недели, в некоторых — понедельник), что более важно. редко используется, поэтому мы не будем его вводить.

Функции для вычисления начального и последнего моментов

Учитывая время, вы можете получить момент начала этой минуты, момент начала этого часа, момент начала этого дня, момент начала этой недели, момент начала этого месяца, момент начала этого сезона, момент начала этого полугодия, момент начала этого года.

import "github.com/jinzhu/now"
time.Now() // 2013-11-18 17:51:49.123456789 Mon
now.BeginningOfMinute()        // 2013-11-18 17:51:00 Mon
now.BeginningOfHour()          // 2013-11-18 17:00:00 Mon
now.BeginningOfDay()           // 2013-11-18 00:00:00 Mon
now.BeginningOfWeek()          // 2013-11-17 00:00:00 Sun
now.BeginningOfMonth()         // 2013-11-01 00:00:00 Fri
now.BeginningOfQuarter()       // 2013-10-01 00:00:00 Tue
now.BeginningOfYear()          // 2013-01-01 00:00:00 Tue

Или последний момент этой минуты этого момента, последний момент этого часа, последний момент этого дня, последний момент этой недели, последний момент этого месяца, последний момент этого сезона, последний момент это полгода, последний момент этого года.

now.EndOfMinute()              // 2013-11-18 17:51:59.999999999 Mon
now.EndOfHour()                // 2013-11-18 17:59:59.999999999 Mon
now.EndOfDay()                 // 2013-11-18 23:59:59.999999999 Mon
now.EndOfWeek()                // 2013-11-23 23:59:59.999999999 Sat
now.EndOfMonth()               // 2013-11-30 23:59:59.999999999 Sat
now.EndOfQuarter()             // 2013-12-31 23:59:59.999999999 Tue
now.EndOfYear()                // 2013-12-31 23:59:59.999999999 Tue
now.WeekStartDay = time.Monday // Set Monday as the first day of the week, default Sunday is the first day of the week
now.EndOfWeek()                // 2013-11-24 23:59:59.999999999 Sun

Если вы запрашиваете момент начала и момент окончания текущего часа, вы можете воспользоваться функциями пакета, который предоставляет удобные функции, такие как момент начала текущего часа.

_ = time.BeginningOfHour()

Его исходный код выглядит следующим образом.

func BeginningOfHour() time.Time {
    return With(time.Now()).BeginningOfHour()
}

Вы также можете установить определенный часовой пояс, формат даты и то, начинается ли первый день недели с понедельника или воскресенья.

myConfig := &now.Config{
    WeekStartDay: time.Monday,
    TimeLocation: location,
    TimeFormats: []string{"2006-01-02 15:04:05"},
}
t := time.Date(2013, 11, 18, 17, 51, 49, 123456789, time.Now().Location()) // // 2013-11-18 17:51:49.123456789 Mon
myConfig.With(t).BeginningOfWeek()         // 2013-11-18 00:00:00 Mon

Анализ даты

Метод синтаксического анализа даты библиотеки разметки предоставляется в виде примеров, таких как 2006-01-02 15:04:05, этот метод синтаксического анализа довольно особенный, часто нам нужно проверять справочную документацию, чтобы правильно установить соответствующий формат, и синтаксический анализ не слишком хорош при отказоустойчивости.

Библиотека jizhu/now обеспечивает отказоустойчивый синтаксический анализ, который повторяет формат времени стандартной библиотеки и пытается проанализировать его, используя один из этих форматов. Он обрабатывает как обходы, так и регулярные выражения, поэтому, если вам нужна производительность и более четкий формат даты, хорошо использовать синтаксический анализ стандартной библиотеки, но если вы не стремитесь к максимальной производительности, этот синтаксический анализ может быть очень отказоустойчивым, вам не нужно запоминать шаблон формата, просто введите строку даты, и она будет проанализирована. (Также можно было бы сделать с помощью оптимизации, которая позволяет пользователям предоставлять определенные шаблоны формата даты в дополнение к формату даты, предоставляемому стандартной библиотекой, и устанавливать приоритет)

// Parse(string) (time.Time, error)
t, err := now.Parse("2017")                // 2017-01-01 00:00:00, nil
t, err := now.Parse("2017-10")             // 2017-10-01 00:00:00, nil
t, err := now.Parse("2017-10-13")          // 2017-10-13 00:00:00, nil
t, err := now.Parse("1999-12-12 12")       // 1999-12-12 12:00:00, nil
t, err := now.Parse("1999-12-12 12:20")    // 1999-12-12 12:20:00, nil
t, err := now.Parse("1999-12-12 12:20:21") // 1999-12-12 12:20:21, nil
t, err := now.Parse("10-13")               // 2013-10-13 00:00:00, nil
t, err := now.Parse("12:20")               // 2013-11-18 12:20:00, nil
t, err := now.Parse("12:20:13")            // 2013-11-18 12:20:13, nil
t, err := now.Parse("14")                  // 2013-11-18 14:00:00, nil
t, err := now.Parse("99:99")               // 2013-11-18 12:20:00, Can't parse string as time: 99:99
// MustParse must parse string to time or it will panic
now.MustParse("2013-01-13")             // 2013-01-13 00:00:00
now.MustParse("02-17")                  // 2013-02-17 00:00:00
now.MustParse("2-17")                   // 2013-02-17 00:00:00
now.MustParse("8")                      // 2013-11-18 08:00:00
now.MustParse("2002-10-12 22:14")       // 2002-10-12 22:14:00
now.MustParse("99:99")                  // panic: Can't parse string as time: 99:99

carbon

golang-module/carbon — это легкая, семантическая, удобная для разработчиков библиотека обработки времени golang с поддержкой цепочки вызовов, разработанная gouguoyin.

Он предоставляет очень богатый набор функций, которые в целом разделены на несколько категорий.

Создание экземпляра carbon

В зависимости от параметров существует множество способов их создания, ниже приведен лишь список из нескольких способов их создания.

carbon.CreateFromTimestamp(0).ToString() // 1970-01-01 08:00:00 +0800 CST
carbon.CreateFromTimestampMilli(1649735755981).ToString() // 2022-04-12 11:55:55.981 +0800 CST
carbon.CreateFromDate(2020, 8, 5).ToString() // // 2020-08-05 13:14:15 +0800 CST
carbon.CreateFromTime(13, 14, 15).ToString() // 2020-08-05 13:14:15 +0800 CST

Взаимопревращение со стандартными библиотеками.

// Convert time.Time to Carbon
carbon.Time2Carbon(time.Now())
// Convert Carbon to time.Time
carbon.Now().Carbon2Time()

Вчера, сегодня и завтра, а также преобразование в строки - вот некоторые из приведенных ниже примеров.

fmt.Sprintf("%s", carbon.Now()) // 2020-08-05 13:14:15
carbon.Now().ToString() // 2020-08-05 13:14:15 +0800 CST
carbon.Now().ToDateTimeString() // 2020-08-05 13:14:15
// Today's date.
carbon.Now().ToDateString() // 2020-08-05
// Today's time.
carbon.Now().ToTimeString() // 13:14:15
// At this moment yesterday.
fmt.Sprintf("%s", carbon.Yesterday()) // 2020-08-04 13:14:15
carbon.Yesterday().ToString() // 2020-08-04 13:14:15 +0800 CST
// This moment of tomorrow.
fmt.Sprintf("%s", carbon.Tomorrow()) // 2020-08-06 13:14:15
carbon.Tomorrow().ToString() // 2020-08-06 13:14:15 +0800 CST
carbon.Tomorrow().ToDateTimeString() // 2020-08-06 13:14:15

Несколько примеров форматирования строк.

// Outputs a datetime string.
carbon.Parse("2020-08-05T13:14:15.999999999+08:00").ToDateTimeString() // 2020-08-05 13:14:15
// Outputs a datetime string containing milliseconds.
carbon.Parse("2020-08-05T13:14:15.999999999+08:00").ToDateTimeMilliString() // 2020-08-05 13:14:15.999
// Outputs a datetime string with microseconds.
carbon.Parse("2020-08-05T13:14:15.999999999+08:00").ToDateTimeMicroString() // 2020-08-05 13:14:15.999999
// Outputs a datetime string with nanoseconds.
carbon.Parse("2020-08-05T13:14:15.999999999+08:00").ToDateTimeNanoString() // 2020-08-05 13:14:15.999999999

Разбор

Carbon parsing выполняется в стандартном формате или формате шаблона, стандартный формат выглядит следующим образом.

carbon.Parse("now").ToString() // 2020-08-05 13:14:15 +0800 CST
carbon.Parse("yesterday").ToString() // 2020-08-04 13:14:15 +0800 CST
carbon.Parse("tomorrow").ToString() // 2020-08-06 13:14:15 +0800 CST
carbon.Parse("2020").ToString() // 2020-01-01 00:00:00 +0800 CST
carbon.Parse("2020-8").ToString() // 2020-08-01 00:00:00 +0800 CST
carbon.Parse("2020-08").ToString() // 2020-08-01 00:00:00 +0800 CST
carbon.Parse("2020-8-5").ToString() // 2020-08-05 00:00:00 +0800 CST
carbon.Parse("2020-8-05").ToString() // 2020-08-05 00:00:00 +0800 CST
carbon.Parse("2020-08-05").ToString() // 2020-08-05 00:00:00 +0800 CST
carbon.Parse("2020-08-05.999").ToString() // 2020-08-05 00:00:00.999 +0800 CST
carbon.Parse("2020-08-05.999999").ToString() // 2020-08-05 00:00:00.999999 +0800 CST
carbon.Parse("2020-08-05.999999999").ToString() // 2020-08-05 00:00:00.999999999 +0800 CST
carbon.Parse("2020-8-5 13:14:15").ToString() // 2020-08-05 13:14:15 +0800 CST
carbon.Parse("2020-8-05 13:14:15").ToString() // 2020-08-05 13:14:15 +0800 CST
carbon.Parse("2020-08-05T13:14:15.999999999+08:00").ToString() // 2020-08-05 13:14:15.999999999 +0800 CST
carbon.Parse("20200805").ToString() // 2020-08-05 00:00:00 +0800 CST
carbon.Parse("20200805131415.999999999+08:00").ToString() // 2020-08-05 13:14:15.999999999 +0800 CST

Формат шаблона:

carbon.ParseByFormat("2020|08|05 13|14|15", "Y|m|d H|i|s").ToDateTimeString() // 2020-08-05 13:14:15
carbon.ParseByFormat("It is 2020-08-05 13:14:15", "\\I\\t \\i\\s Y-m-d H:i:s").ToDateTimeString() // 2020-08-05 13:14:15
carbon.ParseByFormat("今天是 2020年08月05日13时14分15秒", "今天是 Y年m月d日H时i分s秒").ToDateTimeString() // 2020-08-05 13:14:15
carbon.ParseByFormat("2020-08-05 13:14:15", "Y-m-d H:i:s", carbon.Tokyo).ToDateTimeString() // 2020-08-05 14:14:15

Или стандартный режим компоновки библиотеки Go:

carbon.ParseByLayout("2020|08|05 13|14|15", "2006|01|02 15|04|05").ToDateTimeString() // 2020-08-05 13:14:15
carbon.ParseByLayout("It is 2020-08-05 13:14:15", "It is 2006-01-02 15:04:05").ToDateTimeString() // 2020-08-05 13:14:15
carbon.ParseByLayout("今天是 2020年08月05日13时14分15秒", "今天是 2006年01月02日15时04分05秒").ToDateTimeString() // 2020-08-05 13:14:15
carbon.ParseByLayout("2020-08-05 13:14:15", "2006-01-02 15:04:05", carbon.Tokyo).ToDateTimeString() // 2020-08-05 14:14:15

Начальный момент и конечный момент

Аналогично функции jizhu/now, чтобы найти начальную и конечную точки момента.

// Start of this century
carbon.Parse("2020-08-05 13:14:15").StartOfCentury().ToDateTimeString() // 2000-01-01 00:00:00
// End of this century
carbon.Parse("2020-08-05 13:14:15").EndOfCentury().ToDateTimeString() // 2999-12-31 23:59:59
// Start time of this era
carbon.Parse("2020-08-05 13:14:15").StartOfDecade().ToDateTimeString() // 2020-01-01 00:00:00
carbon.Parse("2021-08-05 13:14:15").StartOfDecade().ToDateTimeString() // 2020-01-01 00:00:00
carbon.Parse("2029-08-05 13:14:15").StartOfDecade().ToDateTimeString() // 2020-01-01 00:00:00
// End of this era
carbon.Parse("2020-08-05 13:14:15").EndOfDecade().ToDateTimeString() // 2029-12-31 23:59:59
carbon.Parse("2021-08-05 13:14:15").EndOfDecade().ToDateTimeString() // 2029-12-31 23:59:59
carbon.Parse("2029-08-05 13:14:15").EndOfDecade().ToDateTimeString() // 2029-12-31 23:59:59
// Start time of this year
carbon.Parse("2020-08-05 13:14:15").StartOfYear().ToDateTimeString() // 2020-01-01 00:00:00
// End of the year
carbon.Parse("2020-08-05 13:14:15").EndOfYear().ToDateTimeString() // 2020-12-31 23:59:59
// Start of the quarter
carbon.Parse("2020-08-05 13:14:15").StartOfQuarter().ToDateTimeString() // 2020-07-01 00:00:00
// End of the quarter
carbon.Parse("2020-08-05 13:14:15").EndOfQuarter().ToDateTimeString() // 2020-09-30 23:59:59
......
// Start time of this minute
carbon.Parse("2020-08-05 13:14:15").StartOfMinute().ToDateTimeString() // 2020-08-05 13:14:00
// End time of this minute
carbon.Parse("2020-08-05 13:14:15").EndOfMinute().ToDateTimeString() // 2020-08-05 13:14:59
// Start time of this second
carbon.Parse("2020-08-05 13:14:15").StartOfSecond().ToString() // 2020-08-05 13:14:15 +0800 CST
// End time of this second
carbon.Parse("2020-08-05 13:14:15").EndOfSecond().ToString() // 2020-08-05 13:14:15.999999999 +0800 CST

Путешествие во времени

Обеспечивает функцию сдвига времени, увеличения времени или уменьшения времени до другого момента времени.

// Three centuries later
carbon.Parse("2020-02-29 13:14:15").AddCenturies(3).ToDateTimeString() // 2320-02-29 13:14:15
// After three centuries (months do not overflow)
carbon.Parse("2020-02-29 13:14:15").AddCenturiesNoOverflow(3).ToDateTimeString() // 2320-02-29 13:14:15
......
// Three centuries later
carbon.Parse("2020-02-29 13:14:15").AddCenturies(3).ToDateTimeString() // 2320-02-29 13:14:15
// After three centuries (months do not overflow)
carbon.Parse("2020-02-29 13:14:15").AddCenturiesNoOverflow(3).ToDateTimeString() // 2320-02-29 13:14:15
......
// Three nanoseconds later
carbon.Parse("2020-08-05 13:14:15.222222222").AddNanoseconds(3).ToString() // 2020-08-05 13:14:15.222222225 +0800 CST
// One nanosecond later
carbon.Parse("2020-08-05 13:14:15.222222222").AddNanossecond().ToString() // 2020-08-05 13:14:15.222222223 +0800 CST
// Three nanoseconds ago
carbon.Parse("2020-08-05 13:14:15.222222222").SubNanosseconds(3).ToString() // 2020-08-05 13:14:15.222222219 +0800 CST
// One nanosecond ago
carbon.Parse("2020-08-05 13:14:15.222222222").SubNanossecond().ToString() // 2020-08-05 13:14:15.222222221 +0800 CST

Некоторым людям нравится этот мелкозернистый подход, довольно хороший. Но, видя так много методов, которые обеспечивают аналогичную функциональность, можно предоставить метод, а затем второй модуль, указанный с типом enum, чтобы о временном сдвиге заботился один метод, который легче изучать и поддерживать, например, можно спроектировать его следующим образом:

carbon.Parse("2020-02-29 13:14:15").Add(3, carbon.Century)
carbon.Parse("2020-02-29 13:14:15").Add(3, carbon.Nano)

Разница во времени

Найдите разницу между двумя временами, например:

// How many years difference
carbon.Parse("2021-08-05 13:14:15").DiffInYears(carbon.Parse("2020-08-05 13:14:15")) // -1
// Difference in how many years (absolute value)
carbon.Parse("2021-08-05 13:14:15").DiffAbsInYears(carbon.Parse("2020-08-05 13:14:15")) // 1
...
// How many seconds difference
carbon.Parse("2020-08-05 13:14:15").DiffInSeconds(carbon.Parse("2020-08-05 13:14:14")) // -1
// How many seconds difference (absolute value)
carbon.Parse("2020-08-05 13:14:15").DiffAbsInSeconds(carbon.Parse("2020-08-05 13:14:14")) // 1
// Difference string
carbon.Now().DiffInString() // just now
carbon.Now().AddYearsNoOverflow(1).DiffInString() // -1 year
carbon.Now().SubYearsNoOverflow(1).DiffInString() // 1 year
// Difference string (absolute value)
carbon.Now().DiffAbsInString(carbon.Now()) // just now
carbon.Now().AddYearsNoOverflow(1).DiffAbsInString(carbon.Now()) // 1 year
carbon.Now().SubYearsNoOverflow(1).DiffAbsInString(carbon.Now()) // 1 year

Некоторые временные суждения

Например.

carbon.Parse("0").IsZero() // true
carbon.Parse("0000-00-00 00:00:00").IsZero() // true
carbon.Parse("0").IsZero() // true
carbon.Parse("0000-00-00 00:00:00").IsZero() // true
// Whether it is a leap year
carbon.Parse("2020-08-05 13:14:15").IsLeapYear() // true
// Is it a long year
carbon.Parse("2020-08-05 13:14:15").IsLongYear() // true
// Is it January
carbon.Parse("2020-08-05 13:14:15").IsJanuary() // false
// Whether it is a leap year
carbon.Parse("2020-08-05 13:14:15").IsLeapYear() // true
// Is it a long year
carbon.Parse("2020-08-05 13:14:15").IsLongYear() // true
// Is it January
carbon.Parse("2020-08-05 13:14:15").IsJanuary() // false

Установка единицы времени

// Setting area
carbon.Parse("2020-07-05 13:14:15").SetLocale("en").DiffForHumans() // 1 month ago
carbon.Parse("2020-07-05 13:14:15").SetLocale("zh-CN").DiffForHumans() // 1 月前
// Set the year, month, day, hour, minute and second
carbon.Parse("2020-01-01").SetDateTime(2019, 2, 2, 13, 14, 15).ToString() // 2019-02-02 13:14:15 +0800 CST
carbon.Parse("2020-01-01").SetDateTime(2019, 2, 31, 13, 14, 15).ToString() // 2019-03-03 13:14:15 +0800 CST
// Set year, month, day, hour, minute, second, millisecond
carbon.Parse("2020-01-01").SetDateTimeMilli(2019, 2, 2, 13, 14, 15, 999).ToString() // 2019-02-02 13:14:15.999 +0800 CST
carbon.Parse("2020-01-01").SetDateTimeMilli(2019, 2, 31, 13, 14, 15, 999).ToString() // 2019-03-03 13:14:15.999 +0800 CST
// Set year, month, day, hour, minute, second, microsecond
carbon.Parse("2020-01-01").SetDateTimeMicro(2019, 2, 2, 13, 14, 15, 999999).ToString() // 2019-02-02 13:14:15.999999 +0800 CST
carbon.Parse("2020-01-01").SetDateTimeMicro(2019, 2, 31, 13, 14, 15, 999999).ToString() // 2019-03-03 13:14:15.999999 +0800 CST
// Set year, month, day, hour, minute, second, nanosecond
carbon.Parse("2020-01-01").SetDateTimeNano(2019, 2, 2, 13, 14, 15, 999999999).ToString() // 2019-02-02 13:14:15.999999999 +0800 CST
carbon.Parse("2020-01-01").SetDateTimeNano(2019, 2, 31, 13, 14, 15, 999999999).ToString() // 2019-03-03 13:14:15.999999999 +0800 CST

Получение единицы времени

// Get current area
carbon.Now().Locale() // en
carbon.Now().SetLocale("zh-CN").Locale() // zh-CN
// Get current horoscope
carbon.Now().Constellation() // Leo
carbon.Now().SetLocale("en").Constellation() // Leo
carbon.Now().SetLocale("zh-CN").Constellation() // 狮子座
// Get the current season
carbon.Now().Season() // Summer
carbon.Now().SetLocale("en").Season() // Summer
carbon.Now().SetLocale("zh-CN").Season() // 夏季

Carbon также предоставляет методы получения гороскопов, сезонов и лунных календарей, а также поддержку разработки кодеков json и форматов дат базы данных.

В целом, carbon предоставляет очень богатый, простой подход, который позволяет вам обрабатывать datetime без необходимости выполнять дополнительную работу.

robfig/cron

При разработке бизнеса мы часто устанавливаем некоторые таймеры, в некоторых случаях мы используем для этого Ticker, но мы хотим более детально контролировать задачи синхронизации, мы должны придумать другой способ, первое, что приходит на ум, это функция cron Linux, очень гибкая, поэтому есть соответствующая библиотека в экосистеме Go, здесь, чтобы познакомить вас с двумя.

robfig/cron - это библиотека временных задач, совместимая с форматом Linux cron, и она также предоставляет расширенный формат, который поддерживает настройки второй степени детализации, формат, совместимый с хорошо известной библиотекой Java Tigger, quartz. Мы представляем его в формате Linux cron.

Хотя cron предоставляет AddFunc, AddJob, Schedule, но сходства в том, что мы обычно используем addFunc для добавления задач по расписанию. Первый параметр AddFunc - это выражение cron, а второй параметр - это функция, которая должна выполняться при запуске пакета выражений, определенного в cron. Пример использования cron выглядит следующим образом.

c := cron.New()
c.AddFunc("30 * * * *", func() { fmt.Println("Runs at 30 minutes of each hour.") })
c.AddFunc("30 3-6,20-23 * * *", func() { fmt.Println("Runs daily from 3-6am, 8-11pm for 30 minutes.") })
c.AddFunc("CRON_TZ=Asia/Shanghai 30 04 * * *", func() { fmt.Println("Runs at 04:30 BST daily.") }) // If not specified, the time zone of the machine is used by default.
c.AddFunc("@hourly",      func() { fmt.Println("Runs every hour. Start after 1 hour.") })
c.AddFunc("@every 1h30m", func() { fmt.Println("Runs every hour and 30 minutes, starts at 1 hour and 30 minutes.") })
c.Start()
...
// Functions are executed asynchronously in their goroutines.
...
// You can safely add tasks during this period.
c.AddFunc("@daily", func() { fmt.Println("Daily execution") })
...
// You can check the status of the task.
inspect(c.Entries())
...
c.Remove(entryID) // Remove a task.
...
c.Stop()  // No further follow-up tasks will be performed.

Формат cron

Наименования	Обязательная настройка	Допустимые значения	Разрешенные специальные символы
Минуты	Да	0-59	* / , -
Часы	Да	0-23	* / , -
День месяца	Да	1-31	* / , - ?
Месяц	Да	1-12 или JAN-DEC	* / , -
День недели	Да	0-6 или SUN-SAT	* / , - ?

Википедия также описывает формат cron:

# ┌─────────── minute (0 - 59)
# │ ┌─────────── hour (0 - 23)
# │ │ ┌─────────── day of the month (1 - 31)
# │ │ │ ┌─────────── month (1 - 12)
# │ │ │ │ ┌─────────── day of the week (0 - 6) (Sunday to Saturday;
# │ │ │ │ │                                   7 is also Sunday on some systems)
# │ │ │ │ │
# │ │ │ │ │
# * * * * * <command to execute>

Специальные символы представляют:

*: представляет каждое значение, удовлетворяющее этому полю;
/: представляет количество шагов во временном диапазоне, например, первое поле */5 представляет каждые 5 минут, что является 5,10,15,20,25,30,35,40,45,50,55,00 минут;
,: представляет набор списков, например, пятое поле MON,WED,FRI означает, что оно будет запускаться каждый понедельник, среду и пятницу;
-: представляет диапазон, например, второе поле 10-15 означает, что оно будет запущено в 10, 11, 12, 13, 14, 15 часов каждый день;
?: иногда может находиться в третьем и пятом полях вместо *.

Также эта библиотека предоставляет несколько предопределенных форм.

Предопределенные типы	Описание	Уравнение эквивалентной цены
@yearly (или @annually)	В нулевой час 1 января каждого года	0 0 1 1 *
@monthly	В первый день месяца в нулевой час	0 0 1 * *
@weekly	В первый день недели в ноль часов, то есть в воскресенье в ноль часов	0 0 * * 0
@daily (или @midnight)	Запускается ежедневно при нуле	0 0 * * *
@hourly	Запускается в начале каждого часа	0 * * * *

go-co-op/gocron

go-co-op/gocron - это еще одна отличная библиотека временных задач.

В нем представлены богатые примеры, поэтому с ним легко начать, и вы можете легко применить его к своим проектам. Его синтаксический анализ cron использует вышеупомянутую библиотеку robfig/cron, и вы можете использовать формат cron для реализации задач по времени:

package main
import (
    "time"
    "github.com/go-co-op/gocron"
)
var task = func() {}
func main() {
    s := gocron.NewScheduler(time.UTC)
    _, _ = s.Cron("*/1 * * * *").Do(task) // Execute every minute.
    _, _ = s.Cron("0 1 * * *").Do(task)   // Runs daily at 1:00.
    _, _ = s.Cron("0 0 * * 6,0").Do(task) // Runs at 0:00 on weekends.
}

Но он также предоставляет другие удобные для пользователя настройки. Не обязательно использовать конфигурацию cron.

s := gocron.NewScheduler(time.UTC)
s.Every(5).Seconds().Do(func(){ ... })
// Every 5 minutes
s.Every("5m").Do(func(){ ... })
// Every 5 days
s.Every(5).Days().Do(func(){ ... })
s.Every(1).Month(1, 2, 3).Do(func(){ ... })
// set time
s.Every(1).Day().At("10:30").Do(func(){ ... })
// set multiple times
s.Every(1).Day().At("10:30;08:00").Do(func(){ ... })
s.Every(1).Day().At("10:30").At("08:00").Do(func(){ ... })
// Schedule each last day of the month
s.Every(1).MonthLastDay().Do(func(){ ... })
// Or each last day of every other month
s.Every(2).MonthLastDay().Do(func(){ ... })
// cron expressions supported
s.Cron("*/1 * * * *").Do(task) // every minute
// Asynchronous execution to avoid tasks blocking the scheduler.
s.StartAsync()

#Golang

407

Войти на сайт