|
本帖最后由 QAQ 于 2018-10-8 21:59 编辑
- .版本 2
- .程序集 程序集1
- .程序集变量 平年表, 整数型, , "0"
- .程序集变量 闰年表, 整数型, , "0"
- .子程序 _启动子程序, 整数型, , 请在本子程序中放置易模块初始化代码
- 平年表 = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
- 闰年表 = { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
- _临时子程序 () ' 在初始化代码执行完毕后调用测试代码
- 返回 (0) ' 可以根据您的需要返回任意数值
- .子程序 _临时子程序
- .局部变量 时间, 日期时间型
- .局部变量 旧时间, 日期时间型
- .局部变量 时间戳, 长整数型
- .局部变量 旧时间戳, 长整数型
- .局部变量 年, 长整数型
- .局部变量 月, 字节型
- .局部变量 日, 字节型
- .局部变量 时, 字节型
- .局部变量 分, 字节型
- .局部变量 秒, 字节型
- .局部变量 星期, 字节型
- .局部变量 年2, 长整数型
- .局部变量 月2, 字节型
- .局部变量 日2, 字节型
- .局部变量 时2, 字节型
- .局部变量 分2, 字节型
- .局部变量 秒2, 字节型
- .局部变量 星期2, 字节型
- .局部变量 毫秒, 短整数型
- .局部变量 毫秒2, 短整数型
- 时间 = [2000年1月1日]
- .循环判断首 ()
- 时间 = 修复日期时间型 (增减时间 (时间, 8, 1))
- 年 = 取年份 (时间)
- 月 = 取月份 (时间)
- 日 = 取日 (时间)
- 时 = 取小时 (时间)
- 分 = 取分钟 (时间)
- 秒 = 取秒 (时间)
- 星期 = 取星期几 (时间)
- 毫秒 = 取随机数 (0, 999)
- 时间戳 = 长时间戳_转换 (年, 月, 日, 时, 分, 秒, 毫秒, 8)
- .如果真 (长时间戳_还原 (时间戳, 年2, 月2, 日2, 星期2, 时2, 分2, 秒2, 毫秒2, 8) = 假)
- 输出调试文本 (年2, 月2, 日2, 时2, 分2, 秒2)
- 暂停 ()
- .如果真结束
- .如果真 (年2 ≠ 年 或 月2 ≠ 月 或 日2 ≠ 日 或 时2 ≠ 时 或 分2 ≠ 分 或 秒2 ≠ 秒 或 星期2 ≠ 星期 或 毫秒2 ≠ 毫秒)
- 输出调试文本 (年2, 月2, 日2, 时2, 分2, 秒2, 毫秒2)
- 暂停 ()
- .如果真结束
- .如果真 (旧时间戳 ≠ 0)
- .如果真 (到长整数 (时间戳 \ 1000) - 到长整数 (旧时间戳 \ 1000) ≠ 取时间间隔 (时间, 旧时间, 8))
- 输出调试文本 (到长整数 (时间戳 \ 1000) - 到长整数 (旧时间戳 \ 1000), 取时间间隔 (时间, 旧时间, 8), 时间, 旧时间)
- 暂停 ()
- .如果真结束
- .如果真 (取随机数 (, ) = 0)
- 输出调试文本 (“随机输出调试文本”, 到长整数 (时间戳 \ 1000) - 到长整数 (旧时间戳 \ 1000), 取时间间隔 (时间, 旧时间, 8), 时间, 时间戳, 到字节集 (时间戳))
- .如果真结束
- .如果真结束
- 旧时间 = 时间
- 旧时间戳 = 时间戳
- .循环判断尾 (时间 ≤ [9999年12月31日])
- 输出调试文本 (“完成”)
- .子程序 是否为闰年, 逻辑型
- .参数 年, 长整数型
- 返回 (年 % 4 = 0 且 年 % 100 ≠ 0 或 年 % 400 = 0)
- .子程序 取年天数, 长整数型
- .参数 年, 长整数型
- 返回 (年 × 365 + 取闰年数 (年))
- .子程序 天数到年, 长整数型
- .参数 天, 长整数型
- .局部变量 四百年周期, 长整数型
- .局部变量 一百年周期, 长整数型
- .局部变量 四年周期, 长整数型
- .局部变量 一年周期, 长整数型
- .局部变量 余天, 长整数型
- .局部变量 计数, 整数型
- .局部变量 年, 整数型
- 余天 = 天
- 四百年周期 = 余天 \ 146097
- 余天 = 余天 % 146097
- 一百年周期 = 余天 \ 36524
- 余天 = 余天 % 36524
- 四年周期 = 余天 \ 1461
- 余天 = 余天 % 1461
- .判断开始 (余天 ≤ 365)
- 一年周期 = 0
- .判断 (余天 ≤ 730)
- 一年周期 = 1
- .判断 (余天 ≤ 1095)
- 一年周期 = 2
- .默认
- 一年周期 = 3
- .判断结束
- 返回 (一年周期 + 四年周期 × 4 + 一百年周期 × 100 + 四百年周期 × 400)
- .子程序 取闰年数, 长整数型
- .参数 年, 长整数型
- 返回 (年 \ 4 - 年 \ 100 + 年 \ 400)
- .子程序 取年月天数, 字节型
- .参数 年, 长整数型
- .参数 月, 字节型
- 返回 (选择 (是否为闰年 (年), 闰年表 [月], 平年表 [月]))
- .子程序 日期时间是否有效, 逻辑型
- .参数 年, 长整数型
- .参数 月, 字节型
- .参数 日, 字节型
- .参数 时, 字节型, 可空
- .参数 分, 字节型, 可空
- .参数 秒, 字节型, 可空
- .参数 毫秒, 整数型, 可空
- .判断开始 (时 > 23 或 分 > 59 或 秒 > 59 或 毫秒 > 999 或 毫秒 < 0)
- 返回 (假)
- .判断 (年 < 0 或 月 < 1 或 日 < 1 或 月 > 12)
- 返回 (假)
- .默认
- 返回 (日 ≤ 选择 (是否为闰年 (年), 闰年表 [月], 平年表 [月]))
- .判断结束
- .子程序 到文本星期, 文本型
- .参数 星期, 字节型
- .局部变量 文本星期, 文本型, , "0"
- .如果真 (星期 < 1 或 星期 > 7)
- 返回 (“”)
- .如果真结束
- 文本星期 = { “星期日”, “星期一”, “星期二”, “星期三”, “星期四”, “星期五”, “星期六” }
- 返回 (文本星期 [星期])
- .子程序 取当前年天数, 整数型
- .参数 年, 整数型
- 返回 (选择 (是否为闰年 (年), 366, 365))
- .子程序 年月日算星期, 字节型, , 已知年月日求星期几,星期日为1、星期1为2、以此类推,失败返回0
- .参数 年, 长整数型, , 不能为负数 范围:0~9223372036854775807
- .参数 月, 字节型
- .参数 日, 字节型
- .局部变量 年代码, 整数型
- .局部变量 月代码, 整数型, , "0"
- .局部变量 星期, 字节型
- .判断开始 (日期时间是否有效 (年, 月, 日) = 假)
- 返回 (0)
- .判断 (是否为闰年 (年))
- 年代码 = (取元旦星期 (年) + 2) % 7
- 月代码 = { 5, 1, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4 }
- .默认
- 年代码 = (取元旦星期 (年) + 8) % 7
- 月代码 = { 6, 2, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4 }
- .判断结束
- 星期 = (年代码 + 月代码 [月] + 日) % 7
- .如果真 (星期 = 0)
- 星期 = 7
- .如果真结束
- 返回 (星期)
- .子程序 取元旦星期, 整数型
- .参数 年, 长整数型
- 返回 ((1 + 取年天数 (年) - 取当前年天数 (年)) % 7)
- .子程序 年月日到天, 长整数型
- .参数 年, 长整数型
- .参数 月, 字节型
- .参数 日, 字节型
- .局部变量 闰年, 逻辑型
- 闰年 = 是否为闰年 (年)
- 返回 (月日到天 (月, 日, 闰年) - 到字节 (闰年) + 取年天数 (年))
- .子程序 天到年月日
- .参数 天, 长整数型
- .参数 年, 长整数型, 参考
- .参数 月, 字节型, 参考
- .参数 日, 字节型, 参考
- .局部变量 闰年, 逻辑型
- .局部变量 剩天, 整数型
- 年 = 天数到年 (天)
- .如果真 (年 % 100 = 0)
- 年 = 天数到年 (天 - 1)
- .如果真结束
- 闰年 = 是否为闰年 (年)
- 剩天 = 天 - 取年天数 (年)
- 天到月日 (剩天 + 到字节 (闰年), 月, 日, 闰年)
- .子程序 月日到天, 短整数型
- .参数 月, 字节型
- .参数 日, 字节型
- .参数 闰年, 逻辑型, 可空
- .局部变量 表, 短整数型, , "0"
- .如果 (闰年)
- 表 = { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335 }
- .否则
- 表 = { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 }
- .如果结束
- 返回 (表 [月] + 日)
- .子程序 天到月日
- .参数 天, 长整数型
- .参数 月, 字节型, 参考
- .参数 日, 字节型, 参考
- .参数 闰年, 逻辑型, 可空
- .局部变量 表, 短整数型, , "0"
- .局部变量 计数, 整数型
- .如果 (闰年)
- 表 = { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335 }
- .否则
- 表 = { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 }
- .如果结束
- .变量循环首 (12, 1, -1, 计数)
- .如果真 (天 > 表 [计数])
- 月 = 计数
- 日 = 天 - 表 [计数]
- 跳出循环 ()
- .如果真结束
- .变量循环尾 ()
- .子程序 长时间戳_转换, 长整数型, 公开, 返回0年1月1日到指定日期经过的毫秒数(UTC时间),失败返回-1
- .参数 年, 长整数型, , 范围0~∞ (超过2.9亿年容易出现溢出错误)
- .参数 月, 字节型, , 范围1~12
- .参数 日, 字节型, , 范围1~当月最大天数
- .参数 时, 字节型, 可空, 0~23
- .参数 分, 字节型, 可空, 0~59
- .参数 秒, 字节型, 可空, 0~59
- .参数 毫秒, 短整数型, 可空, 0~999
- .参数 时区, 小数型, , 当地国家对应的时区,中国为8 范围 -12~12
- .局部变量 返回值, 长整数型
- .如果真 (日期时间是否有效 (年, 月, 日, 时, 分, 秒, 毫秒) = 假)
- 返回 (-1)
- .如果真结束
- 返回值 = 时分秒到秒 (时, 分, 秒) × 1000 + 毫秒
- 返回值 = 年月日到天 (年, 月, 日) × 86400000 - 时区 × 3600000 + 返回值
- .如果真 (返回值 < 0)
- 返回 (-1)
- .如果真结束
- 返回 (返回值)
- .子程序 长时间戳_还原, 逻辑型, 公开, 将64位时间戳还原成年月日时分秒毫秒
- .参数 时间戳, 长整数型, , 不能为负数,精度毫秒
- .参数 年, 长整数型, 参考, 范围0~∞
- .参数 月, 字节型, 参考, 范围1~12
- .参数 日, 字节型, 参考, 范围1~当月最大天数
- .参数 星期, 字节型, 参考 可空, 周日为1、周一为2
- .参数 时, 字节型, 参考 可空, 范围0~23
- .参数 分, 字节型, 参考 可空, 范围0~59
- .参数 秒, 字节型, 参考 可空, 范围0~59
- .参数 毫秒, 短整数型, 参考 可空, 范围0~999
- .参数 时区, 小数型, , 当地时区 范围-12~12
- 时间戳 = 时间戳 + 时区 × 3600000
- .如果真 (时间戳 < 0)
- 返回 (假)
- .如果真结束
- 毫秒 = 时间戳 % 1000
- 时间戳 = 时间戳 \ 1000
- 秒到时分秒 (时间戳 % 86400, 时, 分, 秒)
- 时间戳 = 时间戳 \ 86400
- 天到年月日 (时间戳, 年, 月, 日)
- 星期 = 年月日算星期 (年, 月, 日)
- 返回 (真)
- .子程序 时分秒到秒, 整数型
- .参数 时, 字节型, , 0~23
- .参数 分, 字节型, , 0~59
- .参数 秒, 字节型, , 0~59
- 返回 (时 × 3600 + 分 × 60 + 秒)
- .子程序 秒到时分秒
- .参数 总秒, 整数型, , 0~86399
- .参数 时, 字节型, 参考, 0~23
- .参数 分, 字节型, 参考, 0~59
- .参数 秒, 字节型, 参考, 0~59
- 时 = 总秒 ÷ 3600 % 24
- 分 = 总秒 ÷ 60 % 60
- 秒 = 总秒 % 60
- .子程序 修复日期时间型, 日期时间型, , 如果计算时间时出现错误可用此方法修复
- .参数 时间, 日期时间型
- 返回 (到时间 (到文本 (时间)))
复制代码 |
评分
-
1
查看全部评分
-
|