cron表达式助手（专业版）

> 企业级cron表达式工具。高级语法+时区转换+冲突检测+优化建议+执行预览，全功能覆盖。
将复杂的cron表达式编写交给专业工具处理。专业版在免费版基础语法之上，新增高级特殊字符（L/W/#）、时区转换与对比、表达式冲突检测、智能优化建议、执行时间预计算五大高级能力，满足企业级调度场景对表达式精度和可靠性的严苛要求.

架构总览

输入定义

┌──────────────────────────────────────────────────────────────┐
│              cron表达式助手 (专业版 PRO)                      │
├──────────────────────────────────────────────────────────────┤
│                                                                │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐         │
│  │ 基础语法     │  │ 高级语法     │  │ 扩展格式     │         │
│  │ * / - ,     │  │ L W # ?  ✅  │  │ 7字段  ✅    │         │
│  └──────────────┘  └──────────────┘  └──────────────┘         │
│         │                │                │                    │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐         │
│  │ 时区转换     │  │ 冲突检测     │  │ 优化建议     │         │
│  │  ✅PRO       │  │  ✅PRO       │  │  ✅PRO       │         │
│  │ 多时区对比   │  │ 日周互斥     │  │ 合并/简化    │         │
│  └──────────────┘  └──────────────┘  └──────────────┘         │
│         │                │                │                    │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐         │
│  │ 执行预览     │  │ 多平台适配   │  │ 批量处理     │         │
│  │  ✅PRO       │  │  ✅PRO       │  │  ✅PRO       │         │
│  │ 未来N次      │  │ Quartz/Spring│  │ 导入/导出    │         │
│  └──────────────┘  └──────────────┘  └──────────────┘         │
└──────────────────────────────────────────────────────────────┘

即刻上手

1. 阅读## 核心能力章节了解skill功能
2. 按## 依赖说明配置环境
3. 执行所需能力对应的命令
4. 参考## 错误处理章节处理异常
5. 查看## FAQ解答常见疑问

30秒上手（高级语法）

class ProCronMate:
    """cron表达式助手（专业版核心）"""
    def __init__(self):
        self.advanced_chars = {"L": "最后", "W": "最近工作日", "#": "第N个", "?": "不指定"}
    def translate_advanced(self, cron_expr):
        """翻译含高级语法的表达式"""
        parts = cron_expr.split()
        if len(parts) not in [5, 7]:
            return "格式错误：需5或7个字段"
        if len(parts) == 7:
            sec, min_, hour, day, mon, dow, year = parts
            prefix = f"每年{year}年 " if year != "*" else ""
        else:
            min_, hour, day, mon, dow = parts
            sec = None
            prefix = ""
        desc = []
        if sec and sec != "0" and sec != "*":
            desc.append(f"{sec}秒")
        if "/" in min_ and hour == "*":
            desc.append(f"每{min_.split('/')[1]}分钟")
        elif "/" in hour:
            desc.append(f"每{hour.split('/')[1]}小时")
        elif min_ == "0" and hour == "*":
            desc.append("每小时整点")
        elif min_ != "*" and hour != "*":
            desc.append(f"{int(hour):02d}:{int(min_):02d}")
        if "L" in day:
            desc.append("每月最后一天")
        elif "W" in day:
            base = day.replace("W", "")
            desc.append(f"每月{base}号最近的工作日")
        elif day not in ["*", "?"]:
            desc.append(f"每月{day}号")
        if "#" in dow:
            day_num, nth = dow.split("#")
            names = {0:"日",1:"一",2:"二",3:"三",4:"四",5:"五",6:"六"}
            d_name = names.get(int(day_num), day_num)
            ordinals = {1:"领先个",2:"第二个",3:"第三个",4:"第四个",5:"第五个"}
            nth_name = ordinals.get(int(nth), f"第{nth}个")
            desc.append(f"每月{nth_name}周{d_name}")
        elif dow == "1-5":
            desc.append("（仅工作日）")
        elif dow == "6,0":
            desc.append("（仅周末）")
        elif dow not in ["*", "?"]:
            names = {0:"日",1:"一",2:"二",3:"三",4:"四",5:"五",6:"六"}
            try:
                desc.append(f"（周{names[int(dow)]}）")
            except (ValueError, KeyError):
        return prefix + " ".join(desc) + " 执行"
    def preview_next_runs(self, cron_expr, count=5, base_time=None):
        """预计算未来N次执行时间"""
        from datetime import datetime, timedelta
        if base_time is None:
            base_time = datetime.now()
        if len(parts) != 5:
            return ["仅支持5字段格式预览"]
        min_f, hour_f, day_f, mon_f, dow_f = parts
        runs = []
        current = base_time.replace(second=0, microsecond=0)
        while len(runs) < count and current < base_time + timedelta(days=366):
            current += timedelta(minutes=1)
            if not self._match_field(current.minute, min_f, 0, 59):
                continue
hour, hour_f, 0, 23):
                continue
_match_day(current, day_f):
                continue
month, mon_f, 1, 12):
                continue
weekday() + 1 if current.weekday() < 6 else 0, dow_f, 0, 7):
                continue
            runs.append(current.strftime("%Y-%m-%d %H:%M (%a)"))
        return runs
    def _match_field(self, value, field, min_val, max_val):
        """检查值是否匹配字段"""
        if field == "*" or field == "?":
            return True
        if "/" in field:
            base, step = field.split("/")
            step = int(step)
            if base == "*":
                return value % step == 0
            return (value - int(base)) % step == 0
        if "," in field:
            return str(value) in field.split(",")
        if "-" in field:
            start, end = map(int, field.split("-"))
            return start <= value <= end
        return value == int(field)
    def _match_day(self, dt, day_field):
        """检查日字段（含高级语法）"""
        if day_field == "*" or day_field == "?":
            return True
        if "L" in day_field:
            import calendar
            last_day = calendar.monthrange(dt.year, dt.month)[1]
            return dt.day == last_day
        if "W" in day_field:
            base = int(day_field.replace("W", ""))
            if dt.weekday() < 5:  # 工作日
                if base - 3 <= dt.day <= base + 3:
                    return True
            return False
        return self._match_field(dt.day, day_field, 1, 31)
mate = ProCronMate()
print(mate.translate_advanced("0 0 L * *"))        # 每月最后一天 00:00 执行
print(mate.translate_advanced("0 0 15W * *"))       # 每月15号最近的工作日 00:00 执行
print(mate.translate_advanced("0 9 ? * 2#1"))       # 每月领先个周一 09:00 执行
print(mate. * 5#3"))       # 每月第三个周五 09:00 执行
runs = mate.preview_next_runs("0 8 * * 1-5", count=5)
for i, run in enumerate(runs, 1):
    print(f"第{i}次：{run}")

120秒标准搭建

配置时区转换与冲突检测：

from datetime import datetime, timedelta
class AdvancedCronMate(ProCronMate):
    """高级cron表达式助手"""
    def convert_timezone(self, cron_expr, from_tz, to_tz):
        """时区转换"""
            return None, "仅支持5字段格式"
        min_f, hour_f, day_f, mon_f, dow_f = parts
        tz_offsets = {
            "UTC": 0, "Asia/Shanghai": 8, "Asia/Tokyo": 9,
            "America/New_York": -5, "America/Los_Angeles": -8,
            "Europe/London": 0, "Europe/Paris": 1,
            "Australia/Sydney": 10, "Asia/Dubai": 4,
            "Asia/Kolkata": 5, "Asia/Singapore": 8,
        }
        from_offset = tz_offsets.get(from_tz, 0)
        to_offset = tz_offsets.get(to_tz, 0)
        diff = to_offset - from_offset
        if diff == 0:
            return cron_expr, f"同时区，无需转换"
        if hour_f == "*":
            new_hour = "*"
        elif "/" in hour_f:
            new_hour = hour_f  # 步长保持不变
        elif "-" in hour_f:
            start, end = map(int, hour_f.split("-"))
            new_start = (start + diff) % 24
            new_end = (end + diff) % 24
            new_hour = f"{new_start}-{new_end}"
        else:
            try:
                h = int(hour_f)
                new_h = (h + diff) % 24
                new_hour = str(new_h)
            except ValueError:
                new_hour = hour_f
        new_cron = f"{min_f} {new_hour} {day_f} {mon_f} {dow_f}"
        return new_cron, f"{from_tz}(UTC{from_offset:+d}) → {to_tz}(UTC{to_offset:+d})，偏移{diff:+d}小时"
    def detect_conflicts(self, cron_expr):
        """检测表达式冲突"""
            return []
        min_f, hour_f, day_f, mon_f, dow_f = parts
        conflicts = []
        if day_f not in ["*", "?"] and dow_f not in ["*", "?"]:
            conflicts.append({
                "type": "day_week_conflict",
                "severity": "warning",
                "message": f"日字段({day_f})和周字段({dow_f})同时指定",
                "suggestion": "在标准cron中，日和周为OR关系（满足任一即执行）。如需AND关系，请在一个字段使用'?'"
            })
        if day_f == "30" and (mon_f == "2" or mon_f == "*"):
                "type": "impossible_date",
                "severity": "error",
                "message": "2月没有30号",
                "suggestion": "2月最多28或29天，请调整日期"
            })
        if day_f == "31":
            short_months = [2, 4, 6, 9, 11]
            if mon_f == "*":
                    "type": "skipped_months",
                    "severity": "info",
                    "message": "31号在2/4/6/9/11月不会执行",
                    "suggestion": "这些月没有31号，任务会跳过。如需月末执行，考虑使用L语法"
                })
        return conflicts
    def optimize(self, cron_expr):
        """表达式优化建议"""
            return cron_expr, []
        suggestions = []
        min_f, hour_f, day_f, mon_f, dow_f = parts
        if "," in min_f:
            nums = sorted(int(x) for x in min_f.split(","))
            if len(nums) >= 3:
                diff = nums[1] - nums[0]
                if all(nums[i+1] - nums[i] == diff for i in range(len(nums)-1)):
                    simplified = f"{nums[0]}-{nums[-1]}/{diff}"
                    suggestions.append(f"分钟字段'{min_f}'可简化为'{simplified}'（等差数列）")
                    min_f = simplified
        if mon_f != "*" and day_f == "*" and dow_f == "*":
append(f"月字段指定了'{mon_f}'，但日和周为'*'，确认是否需要限定具体日期")
        optimized = f"{min_f} {hour_f} {day_f} {mon_f} {dow_f}"
        return optimized, suggestions
mate = AdvancedCronMate()
converted, info = mate.convert_timezone("0 9 * * 1-5", "Asia/Shanghai", "America/New_York")
print(f"原表达式：0 9 * * 1-5 (上海)")
print(f"转换后：{converted} (纽约)")
print(f"说明：{info}")
conflicts = mate.detect_conflicts("0 0 15 * 1")
for c in conflicts:
    print(f"[{c['severity']}] {c['message']}")
    print(f"  建议：{c['suggestion']}")
optimized, suggestions = mate.optimize("0,15,30,45 * * * *")
print(f"\n优化后：{optimized}")
for s in suggestions:
    print(f"  建议：{s}")

300秒完整配置

配置多平台适配与批量处理：

class EnterpriseCronMate(AdvancedCronMate):
    """企业级cron表达式助手"""
    def adapt_format(self, cron_expr, target_platform):
        """适配不同平台格式"""
        if target_platform == "linux":
            if len(parts) == 5:
                return cron_expr, "已是标准Linux格式"
            elif len(parts) == 7:
                return f"{' '.join(parts[1:6])}", "去掉秒和年字段"
            elif len(parts) == 6:
join(parts[1:6])}", "去掉秒字段"
        elif target_platform == "quartz":
            if len(parts) == 5:
                return f"0 {' '.join(parts)}", "添加秒字段'0'"
            elif len(parts) == 7:
                return cron_expr, "已是Quartz格式"
            elif len(parts) == 6:
                return cron_expr, "已是Quartz格式"
        elif target_platform == "spring":
            if len(parts) == 5:
join(parts)}", "添加秒字段'0'"
            elif len(parts) == 6:
                return cron_expr, "已是Spring格式"
            elif len(parts) == 7:
join(parts[:6])}", "去掉年字段"
        elif target_platform == "aws":
            if len(parts) == 5:
                year = datetime.now().year
join(parts)} {year}", "添加年字段"
            elif len(parts) == 6:
                return cron_expr, "已是AWS格式"
        return cron_expr, "未知平台"
    def batch_validate(self, expressions):
        """批量验证"""
        results = []
        for expr in expressions:
            parts = expr.split()
            if len(parts) not in [5, 6, 7]:
                results.append({"expr": expr, "valid": False, "error": "字段数错误"})
                continue
            results.append({"expr": expr, "valid": True, "fields": len(parts)})
        return results
    def export_templates(self, format="json"):
        """导出模板库"""
        import json
        templates = {
            "basic": {
                "每分钟": "* * * * *",
                "每5分钟": "*/5 * * * *",
                "每小时整点": "0 * * * *",
                "每天0点": "0 0 * * *",
                "每天8点": "0 8 * * *",
            },
            "advanced": {
                "每月最后一天": "0 0 L * *",
                "每月15号最近工作日": "0 0 15W * *",
                "每月领先个周一": "0 9 ? * 2#1",
                "每月第三个周五": "0 9 ? * 5#3",
                "每月最后一个工作日": "0 17 LW * *",
            },
            "business": {
                "工作日早会": "0 9 * * 1-5",
                "工作日晚报": "0 18 * * 1-5",
                "周一计划会": "0 10 * * 1",
                "周五总结会": "0 16 * * 5",
                "月初对账": "0 0 1 * *",
                "月末结算": "0 0 L * *",
            }
        if format == "json":
            return json.dumps(templates, ensure_ascii=False, indent=2)
        return templates
mate = EnterpriseCronMate()
for platform in ["linux", "quartz", "spring", "aws"]:
    adapted, note = mate.adapt_format("0 8 * * 1-5", platform)
    print(f"{platform:10} → {adapted:25} ({note})")
exprs = ["0 8 * * 1-5", "*/15 * * * *", "0 0 L * *", "invalid", "0 0 0 1 *"]
results = mate.batch_validate(exprs)
for r in results:
    status = "✓" if r["valid"] else "✗"
    print(f"{status} {r['expr']}")

功能亮点

高级特殊字符（专业版）

mate = ProCronMate()
cron = "0 17 LW * *"
print(mate.translate_advanced(cron))

场景二：跨时区任务配置（跨国团队负责人）

场景描述：北京团队设定9点任务，需确认纽约团队的对应时间.

mate = AdvancedCronMate()
convert_timezone("0 9 * * 1-5", "Asia/Shanghai", "America/New_York")
print(f"北京 9:00 → 纽约：{converted}")
print(info)

场景三：表达式审查与优化（技术负责人）

场景描述：审查团队所有定时任务表达式，优化可简化的项.

mate = AdvancedCronMate()
exprs = ["0,15,30,45 * * * *", "0 0 * * 1-5", "0 0 15 * 1"]
for expr in exprs:
    print(f"{expr} → {optimized}")
    for s in suggestions:
        print(f"  建议：{s}")

场景四：调度冲突排查（运维工程师）

场景描述：定时任务未按预期执行，排查表达式冲突.

mate = AdvancedCronMate()
conflicts = mate.detect_conflicts("0 0 15 * 1")
for c in conflicts:
    print(f"[{c['severity']}] {c['message']}: {c['suggestion']}")

场景五：执行时间模拟预览（测试工程师）

场景描述：配置复杂表达式后，预览未来5次执行时间验证正确性.

mate = ProCronMate()
runs = mate.preview_next_runs("0 9 ? * 2#1", count=5)
print("每月领先个周一未来5次执行：")
for i, run in enumerate(runs, 1):
    print(f"  第{i}次：{run}")

场景六：多平台cron迁移（DevOps工程师）

场景描述：将Linux crontab表达式迁移到Quartz调度器.

mate = EnterpriseCronMate()
adapt_format("0 8 * * 1-5", "quartz")
print(f"Linux → Quartz: {adapted} ({note})")

支持文档

Q1: cron表达式助手(专业版)支持哪些输入格式？

A1: 企业级cron表达式工具专业版，含高级语法L/W/#、时区转换、冲突检测、优化建议、执行预览.。cron表达式助手专业版是面向企业级场景的完整cron表达式工具。支持文本指令和结构化参数输入，具体格式参考使用流程章节。

Q2: 使用cron表达式助手(专业版)需要什么前置条件？

A2: 请确认运行环境满足依赖说明中的要求。cron表达式助手(专业版)基于Markdown指令驱动，无需额外安装包。

Q3: 命令行执行失败怎么办？

A3: 检查命令参数是否正确，确认运行环境支持exec能力。如遇权限问题，请参照错误处理章节排查。

安全告示

> 注: 本SKILL.md超过500行上限, 已截断尾部非核心章节以满足L1格式要求。完整内容见版本库历史。