Cron Expression Parser

Tolka cron-uttryck till läsbara beskrivningar och förhandsgranska nästa körtider

Prova ett exempel

Cron-uttryck

minute hour day(month) month day(week)

Läsbar beskrivning

At 9:00 AM, Mon, Tue, Wed, Thu, Fri

Fältuppdelning

Minute

0

0–59

Hour

9

0–23

Day (month)

*

1–31

Month

*

1–12

Day (week)

1-5

0–6

Nästa 10 schemalagda körningar

12026-03-26 09:00:00
22026-03-27 09:00:00
32026-03-30 09:00:00
42026-03-31 09:00:00
52026-04-01 09:00:00
62026-04-02 09:00:00
72026-04-03 09:00:00
82026-04-06 09:00:00
92026-04-07 09:00:00
102026-04-08 09:00:00

Vad är tolkning av cron-uttryck?

Ett cron-uttryck är en sträng med fem fält åtskilda av mellanslag som definierar ett återkommande schema. Formatet uppstod i Unix cron-demonen, som skrevs av Ken Thompson för Version 7 Unix år 1979. Varje fält representerar en tidsenhet: minut, timme, dag i månaden, månad och veckodag. Att tolka ett cron-uttryck innebär att omvandla denna kompakta notation till en läsbar beskrivning och en konkret lista över kommande körningstider.

Standardformatet med fem fält används av crontab på Linux och macOS, av CI/CD-plattformar som GitHub Actions och GitLab CI, av molnschemaläggare i AWS (EventBridge), Google Cloud Scheduler och Azure Functions, samt av jobbschemaläggningsbibliotek i alla större programmeringsspråk. Vissa system utökar formatet till sex eller sju fält genom att lägga till ett sekundfält eller ett årsfält, men den femfältslayout som definieras av POSIX är den gemensamma basen som alla implementationer delar.

Att tolka cron-uttryck för hand är felbenäget. Samspelet mellan fälten skapar icke-uppenbara scheman: 0 9 1-7 * 1 betyder inte 'varje måndag i den första veckan' utan snarare 'den 1:a till 7:e varje månad ELLER vilken måndag som helst.' En cron-tolk eliminerar denna tvetydighet genom att expandera varje fält, tillämpa kombinationsreglerna och producera de faktiska tidsstämplarna när jobbet kommer att köras.

Varför använda denna cron-tolk?

Att läsa ett cron-uttryck som 30 */6 1,15 * * från en konfigurationsfil och veta exakt när det körs kräver huvudräkning över fem fält. Denna tolk gör det arbetet direkt.

Omedelbar tolkning
Skriv eller klistra in ett cron-uttryck och se den läsbara beskrivningen och de nästa 10 schemalagda körtiderna direkt. Ingen skicka-knapp, ingen omladdning.
🔒
Integritetsfokuserad bearbetning
All tolkning sker lokalt i din webbläsare. Dina cron-uttryck och schemaläggningsdata lämnar aldrig din enhet.
📋
Fält-för-fält-uppdelning
Vart och ett av de fem fälten tolkas och visas individuellt med de upplösta värdena. Se på ett ögonblick vilket fält som styr schemat.
🔄
Inget konto krävs
Öppna sidan och börja tolka. Ingen inloggning, ingen API-nyckel, ingen installation. Fungerar på valfri enhet med en modern webbläsare.

Användningsfall för cron-tolkaren

Frontend-utvecklare
Verifiera cron-uttryck i administratörspaneler och schemaläggningsgränssnitt innan de skickas till backend. Bekräfta att schemat en användare valde i en rullgardinsmeny matchar den cron-sträng som formuläret genererade.
Backend-ingenjör
Felsök schemalagda jobb som körs vid oväntade tidpunkter. Klistra in cron-uttrycket från din uppgiftsköskonfiguration (Celery, Sidekiq, Quartz) och kontrollera om nästa körtider stämmer med förväntningarna.
DevOps / SRE
Granska cron-scheman i CI/CD-pipelines, Kubernetes CronJobs och molnschemaläggningskonfigurationer. Verifiera att säkerhetskopieringsjobb, certifikatförnyelser och städskript är korrekt tidssatta innan driftsättning.
QA-ingenjör
Validera att schemalagda uppgifter i testmiljön matchar produktionsschemat. Fånga ett-steg-fel i månads- eller veckodagsfält innan de orsakar uteblivna körningar i produktion.
Dataingenjör
Kontrollera cron-utlösarna för ETL-pipelines och datasynkroniseringsjobb. Bekräfta att extraheringsfönster inte överlappar och att nedströmsberoenden har tillräcklig ledtid.
Student / Nybörjare
Lär dig cron-syntax genom att experimentera med olika uttryck och se resultaten i realtid. Bygg intuition för hur jokertecken, intervall och stegvärden samverkar.

Syntaxreferens för cron-uttryck

Ett standard-cron-uttryck har fem blankstegsavgränsade fält. Varje fält accepterar heltal, jokertecken, intervall, listor och stegvärden. Tabellen nedan visar tillåtet intervall och operatorer för varje fält.

FältIntervallOperatorerBeskrivning
Minute0–59* , - /Minute within the hour
Hour0–23* , - /Hour of the day (24-hour)
Day (month)1–31* , - /Day of the month
Month1–12* , - /Month of the year (or JAN–DEC)
Day (week)0–6* , - /Day of the week (0 = Sunday, or SUN–SAT)

Fyra specialtecken styr hur värden matchas inom varje fält:

TeckenNamnBeteende
*WildcardMatches every possible value in the field. * in the minute field means "every minute."
,ListSeparates individual values. 1,15 in the day field means "the 1st and 15th."
-RangeDefines an inclusive range. 1-5 in the day-of-week field means "Monday through Friday."
/StepDefines an interval. */10 in the minute field means "every 10 minutes." 5/15 means "5, 20, 35, 50."

Här är vanliga cron-uttryck som täcker de flesta schemaläggningsbehov:

UttryckSchema
* * * * *Every minute
0 * * * *Every hour (at minute 0)
*/15 * * * *Every 15 minutes
0 9 * * *Every day at 9:00 AM
0 9 * * 1-5Weekdays at 9:00 AM
30 2 * * 0Every Sunday at 2:30 AM
0 0 1 * *First day of every month at midnight
0 0 * * 1Every Monday at midnight
0 0 1 1 *January 1st at midnight (yearly)
0 */6 * * *Every 6 hours
5,35 * * * *At minute 5 and 35 of every hour
0 9-17 * * 1-5Every hour from 9 AM to 5 PM, weekdays

Kodexempel

Så här tolkar du cron-uttryck och beräknar nästa körtider i populära språk:

JavaScript (Node.js)
import cronstrue from 'cronstrue';

// Parse cron to human-readable text
cronstrue.toString('0 9 * * 1-5');
// → "At 09:00 AM, Monday through Friday"

cronstrue.toString('*/15 * * * *');
// → "Every 15 minutes"

// Validate with cron-parser and get next run times
import { parseExpression } from 'cron-parser';

const interval = parseExpression('30 2 * * 0');
console.log(interval.next().toISOString());
// → next Sunday at 02:30 UTC

// Iterate over the next 5 runs
for (let i = 0; i < 5; i++) {
  console.log(interval.next().toString());
}
Python
from crontab import CronTab
from croniter import croniter
from datetime import datetime

# Parse and describe a cron expression
cron = CronTab('0 9 * * 1-5')
print(cron.next(default_utc=True))
# → seconds until next run

# Get the next 5 run times with croniter
base = datetime.now()
cron_iter = croniter('0 9 * * 1-5', base)
for _ in range(5):
    print(cron_iter.get_next(datetime))
# → next 5 weekday 09:00 timestamps

# Check if a specific time matches
print(croniter.match('*/15 * * * *', datetime(2026, 3, 25, 10, 30)))
# → True (minute 30 is divisible by 15)
Go
package main

import (
    "fmt"
    "time"
    "github.com/robfig/cron/v3"
)

func main() {
    // Parse a standard 5-field cron expression
    parser := cron.NewParser(cron.Minute | cron.Hour | cron.Dom | cron.Month | cron.Dow)
    schedule, err := parser.Parse("0 9 * * 1-5")
    if err != nil {
        panic(err)
    }

    // Calculate the next 5 run times
    now := time.Now()
    for i := 0; i < 5; i++ {
        now = schedule.Next(now)
        fmt.Println(now)
    }
    // → next 5 weekday 09:00 timestamps
}
Bash (crontab)
# List current user's cron jobs
crontab -l

# Edit cron jobs interactively
crontab -e

# Add a job: run backup.sh every day at 2:30 AM
# (append to crontab via pipe)
(crontab -l 2>/dev/null; echo "30 2 * * * /home/user/backup.sh") | crontab -

# Check syntax with a dry-run parse (requires cronie or busybox)
# The system will reject invalid expressions when saving

# View cron logs on systemd-based Linux
journalctl -u cron --since "1 hour ago"

Vanliga frågor

Vad är skillnaden mellan 5-fälts och 6-fälts cron-uttryck?
Standardformatet (POSIX) har 5 fält: minut, timme, dag-i-månaden, månad, veckodag. Vissa verktyg som Quartz Scheduler och Spring lägger till ett sekundfält i början, vilket ger 6 fält. AWS EventBridge använder 6 fält med ett årsfält i slutet. Denna tolk stöder standardformatet med 5 fält, vilket är kompatibelt med crontab, GitHub Actions, Kubernetes CronJobs och de flesta schemaläggningsbibliotek.
Hur hanterar cron dag-i-månaden och veckodag tillsammans?
När båda fälten är begränsade (inte *) använder cron ELLER-logik: jobbet körs när något av villkoren är uppfyllt. Till exempel betyder 0 9 15 * 1 'kl. 9:00 den 15:e varje månad ELLER varje måndag.' Detta är en vanlig källa till förvirring. Om båda fälten är satta till * körs jobbet varje dag.
Vilken tidszon använder cron?
Traditionell crontab körs i systemets lokala tidszon. Kubernetes CronJobs är som standard inställda på kube-controller-managers tidszon (vanligtvis UTC) men stöder ett valfritt .spec.timeZone-fält sedan Kubernetes 1.25. AWS EventBridge och Google Cloud Scheduler låter dig ange tidszon per schema. Kontrollera alltid vilken tidszon din schemaläggare använder innan du driftsätter ett cron-jobb.
Kan cron köra ett jobb var 30:e sekund?
Standard 5-fälts cron stöder inte schemaläggning under minutnivå. Det minsta intervallet är en minut (*/1 eller *). För att köra något var 30:e sekund behöver du antingen en 6-fälts cron med sekundfält (Quartz, Spring), ett omslagsskript som väntar 30 sekunder och körs igen, eller en annan schemaläggningsmetod som systemd-timers med OnCalendar.
Är 0 detsamma som 7 för veckodagsfältet?
I de flesta cron-implementationer representerar både 0 och 7 söndag. Denna konvention kommer från den ursprungliga Unix cron. Vissa system (Quartz) använder dock 1 för söndag och 7 för lördag. POSIX definierar intervallet som 0–6 där 0 = söndag. Om din schemaläggare accepterar namngivna dagar (SUN, MON) bör du använda dessa för att undvika tvetydighet.
Vad händer om jag anger en dag-i-månaden som inte existerar?
Om du schemalägger ett jobb den 31:a (0 0 31 * *) körs det inte i månader med färre än 31 dagar. Cron rullar inte över till nästa månad. Februari hoppas alltid över, liksom april, juni, september och november. För att köra sista dagen varje månad stöder vissa cron-implementationer L-modifikatorn (0 0 L * *), men standard POSIX cron gör det inte.
Hur testar jag ett cron-uttryck innan jag driftsätter det?
Använd en online-tolk som denna för att se nästa körtider och verifiera att schemat matchar ditt syfte. För validering i produktion erbjuder de flesta cron-bibliotek en funktion för beräkning av nästa körning: cron-parser i Node.js, croniter i Python, robfig/cron i Go. Kör uttrycket genom ett av dessa i din testsvit för att bekräfta de nästa N körningstiderna innan driftsättning.