# 日期时间函数 本文介绍日期时间函数的语法规则，包括参数解释、函数示例等。 在DSL加工逻辑中，日志中的所有值都以字符串的形式存储，需要根据场景对数据类型进行转换。 日志中时间主要有以下三种数据类型，您可以根据本文提供的日期时间函数进行日期时间格式转换。 - 字符串，例如2022/07/03 02-41-26。 - Unix时间戳，例如1559500886。 - 日期时间对象，例如2022-07-01 10:10:10+08:00或者2022-07-01 10:10:10。 Unix时间戳本质上也是字符串。本文的日期时间函数中，只有dt_parse、dt_str和dt_parsetimestamp函数支持以上三种数据类型作为参数。 #### 函数列表 | **类型** | **函数** | **说明** | |---|---|---| | 通用日期时间转换 | [dt_parse] | 将值或时间表达式的值转换为日期时间对象。 | | 通用日期时间转换 | [dt_str] | 将值或时间表达式的值转换为字符串。 | | 通用日期时间转换 | [dt_parsetimestamp] | 将值或时间表达式的值转换为Unix时间戳。 | | 通用日期时间转换 | [dt_prop] | 获取值或时间表达式值的特定属性，包括所属day、year等。 | | 获取日期时间 | [dt_now] | 获取当前日期时间对象。 | | 获取日期时间 | [dt_today] | 获取当前日期，不含时间。 | | 获取日期时间 | [dt_utcnow] | 获取当前时区的当前日期时间对象。 | | 获取日期时间 | [dt_fromtimestamp] | 将Unix时间戳转换为日期时间对象。 | | 获取日期时间 | [dt_utcfromtimestamp] | 将Unix时间戳转换为当前时区的日期时间对象。 | | 获取日期时间 | [dt_strptime] | 将时间字符串解析为日期时间对象。 | | 获取Unix时间戳 | [dt_currentstamp] | 获取当前Unix时间戳。 | | 获取Unix时间戳 | [dt_totimestamp] | 将日期时间对象转换为Unix时间戳。 | | 获取日期时间字符串 | [dt_strftime] | 将日期时间对象按照指定格式转换为字符串。 | | 获取日期时间字符串 | [dt_strftimestamp] | 将Unix时间戳按照指定格式转换为字符串。 | | 修改日期时间 | [dt_truncate] | 从值或时间表达式中截取指定的时间粒度。 | | 修改日期时间 | [dt_add] | 根据指定的时间粒度修改值或时间表达式的值。 | | 修改日期时间 | [dt_MO] | dt_add函数中传递给weekday参数的值，用于表示特定星期一的偏移量。 | | 修改日期时间 | [dt_TU] | dt_add函数中传递给weekday参数的值，用于表示特定星期二的偏移量。 | | 修改日期时间 | [dt_WE] | dt_add函数中传递给weekday参数的值，用于表示特定星期三的偏移量。 | | 修改日期时间 | [dt_TH] | dt_add函数中传递给weekday参数的值，用于表示特定星期四的偏移量。 | | 修改日期时间 | [dt_FR] | dt_add函数中传递给weekday参数的值，用于表示特定星期五的偏移量。 | | 修改日期时间 | [dt_SA] | dt_add函数中传递给weekday参数的值，用于表示特定星期六的偏移量。 | | 修改日期时间 | [dt_SU] | dt_add函数中传递给weekday参数的值，用于表示特定星期日的偏移量。 | | 修改日期时区 | [dt_astimezone] | 将值或时间表达式的值转换为特定时区的日期时间对象。 | | 获取差异 | [dt_diff] | 按照特定粒度获取两个值或时间表达式值的差异值。 | #### dt_parse 将值或时间表达式的值转换为日期时间对象。 - **函数格式** ``` dt_parse(value, tz=None) ``` - **参数说明** | **参数名称** | **参数类型** | **是否必填** | **说明** | |---|---|---|---| | value | 字符串、Unix时间戳或日期时间对象 | 是 | 值或时间表达式。 | | tz | String | 否 | 表示时区，默认为None。 | - **返回结果** 返回转换后的日期时间对象。 - **函数示例** 1. 示例1：将time字段的值转化成日期时间。 - 测试数据 ``` { "time": "1559500886" } ``` - 加工规则 ``` e_set("test_time", dt_parse(v("time"))) ``` - 加工结果 ``` time: 1559500886 test_time: 2019-06-02 18:41:26 ``` 2. 示例2：将time字段的值转化成日期时间，时区是上海。 - 测试数据 ``` { "time": "2019-06-01 10:10:10", "tz": "Asia/Shanghai" } ``` - 加工规则 ``` e_set("test_time", dt_parse(v("time"),tz=v("tz"))) ``` - 加工结果 ``` time: 2019-06-01 10:10:10 tz: Asia/Shanghai test_time: 2019-06-01 10:10:10+08:00 ``` #### dt_str 将值或时间表达式的值转换为字符串。 - **函数格式** ``` dt_str(value, fmt="format_string", tz=None) ``` - **参数说明** | **参数名称** | **参数类型** | **是否必填** | **说明** | |---|---|---|---| | value | 字符串、Unix时间戳或日期时间对象 | 是 | 值或时间表达式。 | | fmt | String | 否 | 格式化字符串。 | | tz | String | 否 | 表示时区。 | - **返回结果** 返回转换后的时间字符串。 - **函数示例** 1. 示例1：把time字段的值转换成fmt形式，时区东京。 - 测试数据 ``` { "time": "2019-06-03 02:41:26", "fmt": "%Y/%m/%d %H-%M-%S" , "tz": "Asia/Tokyo" } ``` - 加工规则 ``` e_set("dt_str", dt_str(v("time"),fmt=v("fmt"),tz=v("tz"))) ``` - 加工结果 ``` { "time": "2019-06-03 02:41:26" "fmt": "%Y/%m/%d %H-%M-%S" "tz": "Asia/Tokyo" "dt_str": "2019/06/03 02-41-26" } ``` 2. 示例2：把time字段的值（Unix时间戳）转换成fmt形式。 - 测试数据 ``` { "time": "1559500886", "fmt": "%Y/%m/%d %H-%M-%S" } ``` - 加工规则 ``` e_set("dt_str", dt_str(v("time"),fmt=v("fmt"))) ``` - 加工结果 ``` time: 1559500886 fmt: %Y/%m/%d %H-%M-%S dt_str: 2019/06/02 18-41-26 ``` 3. 示例3：把time字段的值转换成默认形式。 - 测试数据 ``` { "time": "2019-06-03 02:41:26" } ``` - 加工规则 ``` e_set("dt_str", dt_str(v("time"))) ``` - 加工结果 ``` time: 2019-06-03 02:41:26 dt_str: 2019-06-03 02:41:26 ``` #### dt_parsetimestamp 将值或时间表达式的值转换为Unix时间戳。 - **函数格式** ``` dt_parsetimestamp(value, tz=None) ``` - **参数说明** | **参数名称** | **参数类型** | **是否必填** | **说明** | |---|---|---|---| | value | 字符串、Unix时间戳或日期时间对象 | 是 | 值或时间表达式。 | | tz | String | 否 | 表示时区，默认为None。 | - **返回结果** 返回转换后的Unix时间戳。 - **函数示例** 1. 示例1：把time字段的值转换成时间戳，时区是北京。 - 测试数据 ``` { "time": "2019-06-03 2:41:26", "tz": "Asia/Tokyo" } ``` - 加工规则 ``` e_set("dt_parsetimestamp", dt_parsetimestamp(v("time"),v("tz"))) ``` - 加工结果 ``` time: 2019-06-03 2:41:26 tz: Asia/Tokyo dt_parsetimestamp: 1559497286 ``` 2. 示例2：把time字段的值转换成Unix时间戳。 - 测试数据 ``` { "time": "2019-06-03 2:41:26" } ``` - 加工规则 ``` e_set("dt_parsetimestamp",dt_parsetimestamp(v("time"))) ``` - 加工结果 ``` time: 2019-06-03 2:41:26 dt_parsetimestamp: 1559529686 ``` 3. 示例3：把time字段的值转换成Unix时间戳。 - 测试数据 ``` { "time": "2019-06-03 2:41:26" } ``` - 加工规则 ``` e_set("dt_parsetimestamp",dt_parsetimestamp(v("time"))) ``` - 加工结果 ``` time: 2019-06-03 02:41:26 dt_parsetimestamp: 1559500886 ``` #### dt_prop 获取值或时间表达式值的特定属性，包括所属day、year等。 - **函数格式** ``` dt_prop(value, props) ``` - **参数说明** | **参数名称** | **参数类型** | **是否必填** | **说明** | |---|---|---|---| | value | 字符串、Unix时间戳或日期时间对象 | 是 | 值或时间表达式。 | | props | String | 是 | 需要获取的时间属性。 例如属性名为year，则只会输出年份。 参数值可以为day、year、month、hour、second、minute、microsecond、weekday、weekdayname、weekdayshortname、monthname、monthshortname、dayofyear、dayofweek、weekofyear、weekofyear_m、tzname、weekofmonth。 | - **返回结果** 返回提取的属性。 - **函数示例** 1. 示例1：提取time字段的值的day属性值。 - 测试数据 ``` { "time": "2018-10-2 09:11:40" } ``` - 加工规则 ``` e_set("dt_parsetimestamp",dt_prop(dt_parse(v("time")),"day")) ``` - 加工结果 ``` time: 2018-10-2 09:11:40 dt_parsetimestamp: 2 ``` 2. 示例2：提取time字段的值的year属性值。 - 测试数据 ``` { "time": "2018-10-2 09:11:40" } ``` - 加工规则 ``` e_set("dt_parsetimestamp",dt_prop(dt_parse(v("time")),"year")) ``` - 加工结果 ``` time: 2018-10-2 09:11:40 dt_parsetimestamp: 2018 ``` 3. 示例3：提取time字段的值的weekdayname属性值。 - 测试数据 ``` { "time": "2018-10-2 09:11:40" } ``` - 加工规则 ``` e_set("dt_prop",dt_prop(dt_parse(v("time")),"weekdayname")) ``` - 加工结果 ``` time: 2018-10-2 09:11:40 dt_prop: Tuesday ``` 4. 示例4：提取time字段的值的weekofyear属性值。 - 测试数据 ``` { "time": "2018-10-2 09:11:40" } ``` - 加工规则 ``` e_set("dt_prop",dt_prop(dt_parse(v("time")),"weekofyear")) ``` - 加工结果 ``` time: 2018-10-2 09:11:40 dt_prop: 39 ``` #### dt_now 获取当前日期时间对象。 - **函数格式** dt_now(tz=None) - **参数说明** | **参数名称** | **参数类型** | **是否必填** | **说明** | |---|---|---|---| | tz | String | 否 | 表示时区，默认为None。 | - **返回结果** 返回指定时区的时间对象。 - **函数示例** 获取当前时间，时区是上海。 - 测试数据 ``` { "tz": "Asia/Shanghai" } ``` - 加工规则 ``` e_set("dt_now",dt_now(tz=v("tz"))) ``` - 加工结果 ``` tz: Asia/Shanghai dt_now: 2022-06-30 11:21:25.111836+08:00 ``` #### dt_today 获取当前日期，不含时间。 - **函数格式** ``` dt_today(tz=None) ``` - **参数说明** | **参数名称** | **参数类型** | **是否必填** | **说明** | |---|---|---|---| | tz | String | 否 | 表示时区，默认为None。 | - **返回结果** 返回指定时区的日期对象。 - **函数示例** 获取当前日期，不含时间。 - 测试数据 ``` {} ``` - 加工规则 ``` e_set("dt_today", dt_today()) ``` - 加工结果 ``` dt_today: 2022-06-30 00:00:00 ``` #### dt_utcnow 获取当前UTC时间。 - **函数格式** ``` dt_utcnow() ``` - **参数说明** 无。 - **返回结果** 返回当前UTC时间。 - **函数示例** 获取当前UTC时间。 - 测试数据 ``` {} ``` - 加工规则 ``` e_set("dt_utcnow",dt_utcnow()) ``` - 加工结果 ``` dt_utcnow:2022-06-30 03:33:56.614005 ``` #### dt_fromtimestamp 将Unix时间戳转换为日期时间对象。 - **函数格式** ``` dt_fromtimestamp(value, tz=None) ``` - **参数说明** | **参数名称** | **参数类型** | **是否必填** | **说明** | |---|---|---|---| | value | String | 是 | 值或时间表达式。 | | tz | String | 否 | 表示时区，默认为None。 | - **返回结果** 返回转换后的日期时间。 - **函数示例** 1. 示例1：把time字段的值转化成日期时间对象。 - 测试数据 ``` { "time": "1559500886" } ``` - 加工规则 ``` e_set("dt_fromtimestamp",dt_fromtimestamp(v("time"))) ``` - 加工结果 ``` time: 1559500886 dt_fromtimestamp: 2019-06-02 18:41:26 ``` 2. 示例2：把time字段的值转化成日期时间对象，时区上海。 - 测试数据 ``` { "time": "1559500886", "tz": "Asia/Shanghai" } ``` - 加工规则 ``` e_set("dt_fromtimestamp",dt_fromtimestamp(v("time"),tz=v("tz"))) ``` - 加工结果 ``` time: 1559500886 tz: Asia/Shanghai dt_fromtimestamp: 2019-06-03 02:41:26 ``` #### dt_utcfromtimestamp 将Unix时间戳转换为当前时区的日期时间对象。 - **函数格式** ``` dt_utcfromtimestamp(value) ``` - **参数说明** | **参数名称** | **参数类型** | **是否必填** | **说明** | |---|---|---|---| | value | String | 是 | 值或时间表达式。 | - **返回结果** 返回转换后的日期时间对象。 - **函数示例** - 测试数据 ``` { "time": "1559500886" } ``` - 加工规则 ``` e_set("dt_utcfromtimestamp",dt_utcfromtimestamp(v("time"))) ``` - 加工结果 ``` time: 1559500886 dt_utcfromtimestamp: 2019-06-02 18:41:26 ``` #### dt_strptime 将时间字符串解析为日期时间对象。 - **函数格式** ``` dt_strptime(value, "format_string") ``` - **参数说明** | **参数名称** | **参数类型** | **是否必填** | **说明** | |---|---|---|---| | value | String | 是 | 值或时间表达式。 | | fmt | String | 否 | 格式化字符串。 | - **返回结果** 返回解析后的日期时间对象。 - **函数示例** - 测试数据 ``` { "time": "2019/06/03 02-41-26", "fmt": "%Y/%m/%d %H-%M-%S" } ``` - 加工规则 ``` e_set("dt_strptime",dt_strptime(v("time"),v("fmt"))) ``` - 加工结果 ``` time: 2019/06/03 02-41-26 fmt: %Y/%m/%d %H-%M-%S dt_strptime: 2019-06-03 02:41:26 ``` #### dt_currentstamp 获取当前Unix时间戳。 - **函数格式** ``` dt_currentstamp(value, normalize='floor') ``` - **参数说明** | **参数名称** | **参数类型** | **是否必填** | **说明** | |---|---|---|---| | value | String | 是 | 值或时间表达式。 | | normalize | String | 否 | 计算结果数字格式。参数取值为： - floor（默认值）：向下取整。 - int：取整。 - round：四舍五入。 - ceil：向上取整。 | - **返回结果** 返回当前Unix时间戳。 - **函数示例** - 测试数据 ``` {} ``` - 加工规则 ``` e_set("dt_currentstamp",dt_currentstamp()) ``` - 加工结果 ``` dt_currentstamp: 1656560437 ``` #### dt_totimestamp 将日期时间对象转换为Unix时间戳。 - **函数格式** ``` dt_totimestamp(timeexpression) ``` - **参数说明** | **参数名称** | **参数类型** | **是否必填** | **说明** | |---|---|---|---| | timeexpression | 日期时间对象 | 是 | 需要被转换的日期时间对象。 | - **返回结果** 返回转换后的Unix时间戳。 - **函数示例** - 测试数据 ``` { "time": "2019-06-03 2:41:26" } ``` - 加工规则 ``` e_set("dt_totimestamp",dt_totimestamp(dt_parse(v("time")))) ``` - 加工结果 ``` time: 2019-06-03 2:41:26 dt_totimestamp: 1559529686 ``` #### dt_strftime 将日期时间对象按照指定格式转换为字符串。 - **函数格式** ``` dt_strftime(timeexpression, "format_string") ``` - **参数说明** | **参数名称** | **参数类型** | **是否必填** | **说明** | |---|---|---|---| | timeexpression | 日期时间对象 | 是 | 需要被转换的日期时间对象。 | | format_string | String | 是 | 格式化字符串。 | - **返回结果** 返回格式化后的字符串。 - **函数示例** 将time字段的值按照fmt格式转换。 - 测试数据 ``` { "time": "2019-06-03 2:41:26", "fmt": "%Y/%m/%d %H-%M-%S" } ``` - 加工规则 ``` e_set("dt_strftime",dt_strftime(dt_parse(v("time")),v("fmt"))) ``` - 加工结果 ``` time: 2019-06-03 2:41:26 fmt: %Y/%m/%d %H-%M-%S dt_strftime: 2019/06/03 02-41-26 ``` #### dt_strftimestamp 将Unix时间戳按照指定格式转换为字符串。 - **函数格式** ``` dt_strftimestamp(value, fmt="format_string", tz=None) ``` - **参数说明** | **参数名称** | **参数类型** | **是否必填** | **说明** | |---|---|---|---| | value | String | 是 | 需要被转换的Unix时间戳。 | | fmt | String | 是 | 格式化字符串。 | | tz | String | 否 | 表示时区，默认为None。 | - **返回结果** 返回格式化后的字符串。 - **函数示例** 1. 示例1 - 测试数据 ``` { "time": "1559500886", "fmt": "%Y/%m/%d %H-%M-%S" } ``` - 加工规则 ``` e_set("dt_strftimestamp",dt_strftimestamp(v("time"),v("fmt"))) ``` - 加工结果 ``` time: 1559500886 fmt: %Y/%m/%d %H-%M-%S dt_strftimestamp: 2019/06/02 18-41-26 ``` 2. 示例2 - 测试数据 ``` { "time": "1559500886", "fmt": "%Y/%m/%d %H-%M-%S", "tz": "Asia/shanghai" } ``` - 加工规则 ``` e_set("dt_strftimestamp",dt_strftimestamp(v("time"),v("fmt"),v("tz"))) ``` - 加工结果 ``` dt_strftimestamp:2019/06/03 03-41-26 fmt:%Y/%m/%d %H-%M-%S time:1559500886 tz:Asia/shanghai ``` #### dt_truncate 从值或时间表达式中截取指定的时间粒度。 - **函数格式** ``` dt_truncate(value, unit='day') ``` - **参数说明** | **参数名称** | **参数类型** | **是否必填** | **说明** | |---|---|---|---| | value | 字符串、Unix时间戳或日期时间对象 | 是 | 值或时间表达式。 | | unit | String | 是 | 需要获取的时间属性粒度。 默认为day。可选second 、minute、\_minute（例如：5_minute, 19_minute, 2_minute等）、hour、day、week、month、quarter、half_year、year。 | - **返回结果** 返回提取的特定时间粒度。 - **函数示例** 1. 示例1 - 测试数据 ``` { "time": "2019-06-03 2:41:26", "unit": "year" } ``` - 加工规则 ``` e_set("dt_truncate",dt_truncate(v("time"),v("unit"))) ``` - 加工结果 ``` time: 2019-06-03 2:41:26 unit: year dt_truncate: 2019-01-01 00:00:00 ``` 2. 示例2 - 测试数据 ``` { "time": "2019-06-03 2:41:26", "unit": "hour" } ``` - 加工规则 ``` e_set("dt_truncate",dt_truncate(v("time"),v("unit"))) ``` - 加工结果 ``` time: 2019-06-03 2:41:26 unit: hour dt_truncate: 2019-06-03 02:00:00 ``` #### dt_add 根据指定的时间粒度修改值或时间表达式的值。 - **函数格式** ``` dt_add(value, dt1=None, dt2=None, year(s)=None, month(s)=None, day(s)=None, hour(s)=None, minute(s)=None, second(s)=None, microsecond(s)=None, week(s)=None, weekday=None) ``` - **参数说明** | **参数名称** | **参数类型** | **是否必填** | **说明** | |---|---|---|---| | value | 字符串、Unix时间戳或日期时间对象 | 是 | 日期时间表达式。 | | dt1 | 字符串、Unix时间戳或日期时间对象 | 否 | 日期时间表达式，默认为None。 | | dt2 | 字符串、Unix时间戳或日期时间对象 | 否 | 日期时间表达式，默认为None。 | | year/years | Number | 否 | - year：表示需要替换的年份，例如year=2020，默认为None。 - years：表示需要增加年份的数量，如years=1表示在原来year的基础上再增加一年。 | | day/days | Number | 否 | - day：表示需要替换的天，例如day=1，默认为None。 - days：表示需要增加天的数量，如days=1表示在原来day的基础上加一天。 | | hour/hours | Number | 否 | - hour：表示需要替换的小时，例如hour=1，默认为None。 - hours：表示需要增加小时的数量，如hours=1表示在原来hour的基础上加一小时。 | | minute/minutes | Number | 否 | - minute：表示需要替换的分钟，例如minute=1，默认为None。 - minutes：表示需要增加分钟的数量，如minutes=1表示在原来minute的基础上加一分钟。 | | second/seconds | Number | 否 | - second：表示需要替换的秒数，例如second=1，默认为None。 - seconds：表示需要增加秒的数量，如seconds=1表示在原来second的基础上加一秒钟。 | | microsecond/microseconds | Number | 否 | - microsecond：表示需要替换的毫秒数，例如microsecond=1，默认为None。 - microseconds：表示需要增加毫秒的数量，microseconds=1表示在原来microsecond的基础上加一毫秒。 | | week/weeks | Number | 否 | - week：表示需要偏移的周数，例如week=1，默认为None。 - weeks：表示需要增加周的数量，weeks=1表示在原来week的基础上加一周。 | | weekday | Number | 否 | 表示需要偏移的工作日，例如weekday=dt_MO(1)，默认为None。 | - **返回结果** 返回修改后的时间表达式。 - **函数示例** 1. 示例1 - 测试数据 ``` { "dt": "2018-10-10 1:2:3", "dt1": "2018-11-3 11:12:13", "dt2": "2018-10-1 10:10:10" } ``` - 加工规则 ``` e_set("dt_add",dt_add(dt_parse(v("dt")), dt1=dt_parse(v("dt1")), dt2=dt_parse(v("dt2")))) ``` - 加工结果 ``` dt:2018-10-10 1:2:3 dt1:2018-11-3 11:12:13 dt2:2018-10-1 10:10:10 dt_add:2018-11-12 02:04:06 ``` 2. 示例2 - 测试数据 ``` { "dt": "2018-10-11 02:03:04", "year": "2019" } ``` year: 2019 - 加工规则 ``` e_set("dt_add", dt_add(dt_parse(v("dt")), year=ct_int(v("year")))) ``` - 加工结果 ``` dt:2018-10-11 02:03:04 dt_add:2019-10-11 02:03:04 year:2019 ``` #### dt_MO dt_add函数中传递给weekday参数的值，用于表示特定星期一的偏移量。 - **函数格式** ``` dt_MO(Integer_or_negative) ``` - **参数说明** | **参数名称** | **参数类型** | **是否必填** | **说明** | |---|---|---|---| | Integer_or_negative | Number | 是 | 传入偏移量。如果需要传入负数，请使用op_neg(positive) 。例如-1用op_neg(1)表示。 | - **返回结果** 返回偏移后的时间。 - **函数示例** - 测试数据 ``` { "time": "2019-08-13 02:03:04" } ``` - 加工规则 ``` e_set("dt_MO",dt_add(v("time"),weekday=dt_MO(1))) ``` - 加工结果 ``` time: 2019-08-13 02:03:04 dt_MO: 2019-08-19 02:03:04 ``` #### dt_TU dt_add函数中传递给weekday参数的值，用于表示特定星期二的偏移量。 - **函数格式** ``` dt_TU(Integer_or_negative) ``` - **参数说明** | **参数名称** | **参数类型** | **是否必填** | **说明** | |---|---|---|---| | Integer_or_negative | Number | 是 | 传入偏移量。如果需要传入负数，请使用op_neg(positive) 。例如-1用op_neg(1)表示。 | - **返回结果** 返回偏移后的时间。 - **函数示例** - 测试数据 ``` { "time": "2023-06-17 02:03:04" } ``` - 加工规则 ``` e_set("dt_TU",dt_add(v("time"),weekday=dt_TU(1))) ``` - 加工结果 ``` time: 2023-06-17 02:03:04 dt_TU: 2023-06-20 02:03:04 ``` #### dt_WE dt_add函数中传递给weekday参数的值，用于表示特定星期三的偏移量。 - **函数格式** ``` dt_WE(Integer_or_negative) ``` - **参数说明** | **参数名称** | **参数类型** | **是否必填** | **说明** | |---|---|---|---| | Integer_or_negative | Number | 是 | 传入偏移量。如果需要传入负数，请使用op_neg(positive) 。例如-1用op_neg(1)表示。 | - **返回结果** 返回偏移后的时间。 - **函数示例** - 测试数据 ``` { "time": "2023-06-17 02:03:04" } ``` - 加工规则 ``` e_set("dt_WE",dt_add(v("time"),weekday=dt_WE(1))) ``` - 加工结果 ``` time: 2023-06-17 02:03:04 dt_WE: 2023-06-21 02:03:04 ``` #### dt_TH dt_add函数中传递给weekday参数的值，用于表示特定星期四的偏移量。 - **函数格式** ``` dt_TH(Integer_or_negative) ``` - **参数说明** | **参数名称** | **参数类型** | **是否必填** | **说明** | |---|---|---|---| | Integer_or_negative | Number | 是 | 传入偏移量。如果需要传入负数，请使用op_neg(positive) 。例如-1用op_neg(1)表示。 | - **返回结果** 返回偏移后的时间。 - **函数示例** - 测试数据 ``` { "time": "2023-06-17 02:03:04" } ``` - 加工规则 ``` e_set("dt_TH",dt_add(v("time"),weekday=dt_TH(1))) ``` - 加工结果 ``` time: 2023-06-17 02:03:04 dt_TH: 2023-06-22 02:03:04 ``` #### dt_FR dt_add函数中传递给weekday参数的值，用于表示特定星期五的偏移量。 - **函数格式** ``` dt_FR(Integer_or_negative) ``` - **参数说明** | **参数名称** | **参数类型** | **是否必填** | **说明** | |---|---|---|---| | Integer_or_negative | Number | 是 | 传入偏移量。如果需要传入负数，请使用op_neg(positive) 。例如-1用op_neg(1)表示。 | - **返回结果** 返回偏移后的时间。 - **函数示例** - 测试数据 ``` { "time": "2023-06-17 02:03:04" } ``` - 加工规则 ``` e_set("dt_FR",dt_add(v("time"),weekday=dt_FR(1))) ``` - 加工结果 ``` time: 2023-06-17 02:03:04 dt_FR: 2023-06-23 02:03:04 ``` #### dt_SA dt_add函数中传递给weekday参数的值，用于表示特定星期六的偏移量。 - **函数格式** ``` dt_SA(Integer_or_negative) ``` - **参数说明** | **参数名称** | **参数类型** | **是否必填** | **说明** | |---|---|---|---| | Integer_or_negative | Number | 是 | 传入偏移量。如果需要传入负数，请使用op_neg(positive) 。例如-1用op_neg(1)表示。 | - **返回结果** 返回偏移后的时间。 - **函数示例** - 测试数据 ``` { "time": "2023-06-17 02:03:04" } ``` - 加工规则 ``` e_set("dt_SA",dt_add(v("time"),weekday=dt_SA(1))) ``` - 加工结果 ``` dt_SA：2023-06-17 02:03:04 time: 2023-06-17 02:03:04 ``` #### dt_SU dt_add函数中传递给weekday参数的值，用于表示特定星期日的偏移量。 - **函数格式** ``` dt_SU(Integer_or_negative) ``` - **参数说明** | **参数名称** | **参数类型** | **是否必填** | **说明** | |---|---|---|---| | Integer_or_negative | Number | 是 | 传入偏移量。如果需要传入负数，请使用op_neg(positive) 。例如-1用op_neg(1)表示。 | - **返回结果** 返回偏移后的时间。 - **函数示例** - 测试数据 ``` { "time": "2023-06-17 02:03:04" } ``` - 加工规则 ``` e_set("dt_SU",dt_add(v("time"),weekday=dt_SU(1))) ``` - 加工结果 ``` dt_SU：2023-06-18 02:03:04 time: 2023-06-17 02:03:04 ``` #### dt_astimezone 将值或时间表达式的值转换为特定时区的日期时间对象。 - **函数格式** ``` dt_astimezone(value, tz, reset=false) ``` - **参数说明** | **参数名称** | **参数类型** | **是否必填** | **说明** | |---|---|---|---| | value | 字符串、Unix时间戳或日期时间对象 | 是 | 值或时间表达式。 | | tz | String | 否 | 表示时区，默认为None。 | | reset | Bool | 否 | 表示是否对时区重新设置，默认为false表示不设置。如果为true则返回原时间加上设置的时区。 | - **返回结果** 返回特定时区的日期时间对象。 - **函数示例** 1. 示例1 - 测试数据 ``` { "time": "2019-06-03 2:41:26", "tz": "UTC" } ``` - 加工规则 ``` e_set("dt_astimezone",dt_astimezone(dt_parse(v("time")), v("tz"))) ``` - 加工结果 ``` time: 2019-06-03 2:41:26 tz: UTC dt_astimezone: 2019-06-03 02:41:26+00:00 ``` 2. 示例2 - 测试数据 ``` { "time": "2019-06-01 10:10:10+10:00", "tz": "Asia/shanghai" } ``` - 加工规则 ``` e_set("dt_astimezone",dt_astimezone(v("time"), v("tz"),reset=true)) ``` - 加工结果 ``` time: 2019-06-01 10:10:10+10:00 tz: Asia/shanghai dt_astimezone: 2019-06-01 10:10:10+08:00 ``` 3. 示例3 - 测试数据 ``` { "time": "2019-06-01 10:10:10+08:00", "tz": "Asia/shanghai" } ``` - 加工规则 ``` e_set("dt_astimezone",dt_astimezone(v("time"), v("tz"),reset=false)) e_set("dt_astimezone_true",dt_astimezone(v("time"), v("tz"),reset=true)) ``` - 加工结果 ``` dt_astimezone: 2019-06-01 10:10:10+08:00 dt_astimezone_true: 2019-06-01 10:10:10+08:00 time:2019-06-01 10:10:10+08:00 tz:Asia/shanghai ``` #### dt_diff 按照特定粒度获取两个值或时间表达式值的差异值。 - **函数格式** ``` dt_diff(value1, value2, unit='second', normalize='floor') ``` - **参数说明** | **参数名称** | **参数类型** | **是否必填** | **说明** | |---|---|---|---| | value1 | 字符串、Unix时间戳或日期时间对象 | 是 | 值或时间表达式。 | | value2 | 字符串、Unix时间戳或日期时间对象 | 是 | 值或时间表达式。 | | unit | String | 否 | 按照输入时间属性返回，默认second。也可以是microsecond、millisecond、minutes、hours、day等。 | | normalize | String | 否 | 计算结果数字格式。取值为： - floor（默认值）：向下取整。 - int：取整。 - round：保留N位小数。 - ceil：向上取整。 | - **返回结果** 返回按照特定粒度获取的两个值的差异值。 - **函数示例** 1. 示例1：对time1和time2字段的值，按照秒计算差异值。 - 测试数据 ``` { "time1": "2018-10-1 10:10:10", "time2": "2018-10-1 10:10:10" } ``` - 加工规则 ``` e_set("diff",dt_diff(v("time1"), v("time2"))) ``` - 加工结果 ``` time1: 2018-10-1 10:10:10 time2: 2018-10-1 10:10:10 diff: 0 ``` 2. 示例2：对time1和time2字段的值，按照秒计算差异值。 - 测试数据 ``` { "time1": "2018-10-1 11:10:10", "time2": "2018-10-1 10:10:10" } ``` - 加工规则 ``` e_set("diff",dt_diff(v("time1"), v("time2"))) ``` - 加工结果 ``` time1: 2018-10-1 11:10:10 time2: 2018-10-1 10:10:10 diff: 3600 ``` 3. 示例3：对time1和time2字段的值，按照微秒计算差异值。 - 测试数据 ``` { "time1": "2018-10-1 11:10:11", "time2": "2018-10-1 10:10:10", "unit": "microsecond" } ``` - 加工规则 ``` e_set("diff",dt_diff(v("time1"), v("time2"),v("unit"))) ``` - 加工结果 ``` diff:3601000000 time1:2018-10-1 11:10:11 time2:2018-10-1 10:10:10 unit:microsecond ``` 4. 示例4：对time1和time2字段的值，按照分钟计算差异值，向下取整。 - 测试数据 ``` { "time1":"2018-10-1 11:11:59", "time2":"2018-10-1 10:10:00", "unit":"minute", "normalize":"floor" } ``` - 加工规则 ``` e_set("diff", dt_diff(v("time1"), v("time2"), v("unit"), v("normalize"))) ``` - 加工结果 ``` diff:61 normalize:floor time1:2018-10-1 11:11:59 time2:2018-10-1 10:10:00 unit:minute ``` 5. 示例5：对time1和time2字段的值，按照秒计算差异值，向下取整。 - 测试数据 ``` { "time1": "10:00:00", "time2": "11:00:00", "unit": "second" , "normalize": "floor" } ``` - 加工规则 ``` e_set("diff", dt_diff(v("time1"), v("time2"), v("unit"), v("normalize"))) ``` 加工结果 ``` diff:-3600 normalize:floor time1:10:00:00 time2:11:00:00 unit:second ```