Kontrollera direkt om något år är ett skottår. Ta reda på: Är 2024 ett skottår? Är 2025 ett skottår? Använder officiella gregorianska kalenderregler. Perfekt för planering, kodning och datumvalidering.
Ett skottår lägger till en extra dag—den 29 februari—i vår kalender och sträcker året till 366 dagar istället för de vanliga 365. Här är varför detta spelar roll: Jorden tar ungefär 365,25 dagar för att kretsa runt solen, inte exakt 365. Den där kvartstimmen skiljer sig. Utan skottår skulle vår kalender glida iväg med nästan 24 dagar varje sekel, vilket så småningom skulle placera sommaren i december.
Matematiken är elegant. Vart fjärde år samlar vi ihop dessa kvartstimmar (0,25 × 4 = 1) och lägger till en hel dag i februari. Detta håller vår kalender i linje med jordens faktiska omloppsbana och säkerställer att årstiderna stannar där de hör hemma.
Snabb verifiering gör stor skillnad när du planerar händelser år framöver, validerar historiska datum eller felsöker datumhanterande kod. Ange vilket 4-siffrigt år som helst, och du får ett omedelbart svar baserat på de exakta reglerna definierade i gregorianska kalenderns standard.
Att använda detta verktyg tar bara sekunder:
Att testa flera år går snabbt—ingen sidomladdning behövs. Verktyget fungerar på alla enheter: dator, surfplatta eller telefon.
Kontrollen validerar din inmatning för att säkerställa korrekta resultat:
När något är fel, kommer du att se ett specifikt felmeddelande som "Ange ett giltigt 4-siffrigt år" eller "Året måste vara ett positivt tal". Detta förhindrar beräkningsfel och vägleder dig till rätt inmatningsformat.
Enligt gregorianska kalenderns regler följs ett tresystems regelverk. Så fungerar det:
Regel 1: Delbar med 4? Det är ett skottår.
Regel 2: Men vänta—delbar med 100? Inte ett skottår.
Regel 3: Avvakta—delbar med 400? Det ÄR faktiskt ett skottår.
I praktiken innebär detta:
år mod 400 = 0 → Skottår (exempel: 2000)år mod 100 = 0 → Inte ett skottår (exempel: 1900)år mod 4 = 0 → Skottår (exempel: 2024)Varför undantaget för sekelår? Utan det skulle vi överjustera. Jordens omloppsbana är 365,2422 dagar, inte 365,25, så den enkla regeln "vart fjärde år" lägger till för mycket tid. Justeringen var 400:e år finjusterar kalendern och håller den exakt inom 26 sekunder per år. Den precisionen innebär att vi inte behöver justera kalendern på tusentals år.
Algoritmen använder ett beslutsträd som kontrollerar delbarhet i en specifik ordning. Här är vad som händer bakom kulisserna:
Steg 1: Kontrollera delbarhet med 400 först.
Steg 2: Kontrollera delbarhet med 100.
Steg 3: Kontrollera delbarhet med 4.
Ordningen spelar roll. Om du kontrollerade delbarhet med 100 före 400, skulle du felaktigt utesluta år som 2000. Att börja med 400-kontrollen fångar upp dessa speciella sekelskiftes skottår tidigt, vilket är både mer exakt och beräkningsmässigt effektivt.
De flesta programmeringsspråk använder modulo-operatorn (%) för delbarhetskontrroller. När year % n = 0, delas året jämnt av n utan någon rest. Denna enkla operator gör skottårskontroll enkel att implementera i vilket språk som helst, som du kommer att se i kodexemplen nedan.
Resultat visas på vanligt språk:
Året upprepas i meddelandet så att du alltid vet vilket år du just har kontrollerat—användbart när du testar flera år i rad. Ingen tvetydighet, inget tekniskt språk. Bara ett tydligt ja eller nej-svar som visas direkt.
Här är där kontroll av skottår blir avgörande i verkliga scenarier:
Vid utveckling av kalenderapplikationer, datumväljare eller schemaläggningssystem förhindrar korrekt hantering av skottår datakorruption. En vanlig bugg: att hårdkoda februari till 28 dagar orsakar krascher när användare försöker välja 29 februari under ett skottår. Under testning kontrollerar utvecklare ofta gränsfall som 2000 (skottår trots att det är delbart med 100) och 1900 (inte ett skottår trots att det är delbart med 4).
Bröllopsplanerare och konferensarrangörer som bokar lokaler år i förväg måste verifiera om 29 februari finns för deras målår. Att boka en lokal för "29 februari 2025" skulle vara ett dyrt misstag—2025 är inte ett skottår. Detta verktyg förhindrar sådana fel innan kontrakt skrivs under.
Finansiella system använder dagsräkningskonventioner för ränteberäkningar, obligationsprissättning och skattemässig rapportering. Dessa beräkningar måste ta hänsyn till år med 366 dagar kontra år med 365 dagar. Att göra fel påverkar upplupen ränta, amorteringsplaner för lån och regelefterlevnad.
Genealoger och historiker som verifierar födelsebevis, historiska händelser eller arkivdatum behöver bekräfta om ett påstått 29 februari-datum över huvud taget är möjligt. Innan man lägger ner timmar på att spåra dokument från "29 februari 1900" vill man veta att det datumet aldrig existerade—1900 var inte ett skottår.
Lärare som förklarar delbarhetregler, kalendersystem eller astronomin bakom tidsberäkning kan använda detta verktyg för direkta demonstrationer. Elever ser omedelbart varför 2000 är ett skottår men 1900 inte är, vilket gör undantagsregeln konkret snarare än abstrakt.
Människor födda 29 februari upplever bara sin faktiska födelsedag vart fjärde år. Att beräkna deras ålder korrekt—särskilt för juridiska ändamål som rösträtt eller pensionsförmåner—kräver att man exakt vet vilka år som inkluderade 29 februari sedan deras födelse.
Om du arbetar med datum och kalendrar kan dessa kompletterande verktyg vara till hjälp:
Att få vår kalender att matcha jordens omloppsbana har tagit över 2 000 år av förfining.
Julius Caesar, rådgiven av den egyptiske astronomen Sosigenes, introducerade det första systematiska skottårssystemet. Vart fjärde år skulle få en extra dag, vilket i genomsnitt gav 365,25 dagar per år. Detta var revolutionerande—den tidigare romerska kalendern hade blivit så missanpassad med årstiderna att den rutinmässigt behövde manuella korrigeringar.
Det julianska systemet fungerade tillräckligt bra i århundraden. Men det fanns ett problem: jordens omloppsbana är inte exakt 365,25 dagar. Den är 365,2422 dagar—ungefär 11 minuter kortare. Det lilla felet ackumuleras. Under 128 år förskjuts kalendern en hel dag framför solåret.
Under 1500-talet hade den julianska kalendern förskjutits 10 dagar framåt. Påsk, beräknad baserad på vårdagjämningen, inträffade vid fel datum. Detta störde påve Gregorius XIII tillräckligt för att beställa en fullständig kalenderreform.
Lösningen, utvecklad av astronomerna Aloysius Lilius och Christopher Clavius, var elegant:
Den gregorianska reformen var matematiskt precis. Under det julianska systemet fanns det 100 skottår var 400:e år. Det gregorianska systemet reducerar det till 97 (genom att ta bort tre sekelår som är delbara med 100 men inte 400).
Detta skapar ett genomsnittligt år på 365,2425 dagar (365 + 97/400). Jämför det med jordens faktiska omloppstid på 365,2422 dagar—en skillnad på endast 26 sekunder per år. Vid den takten kommer kalendern endast att förskjutas en dag var 3 300:e år.
Katolska länder antog den nya kalendern omedelbart 1582. Protestantiska och ortodoxa länder vägrade, och såg det som påvligt övergrepp. Storbritannien och dess amerikanska kolonier bytte inte förrän 1752, då de var tvungna att hoppa över 11 dagar (2 september följdes av 14 september). Folk protesterade på gatorna, övertygade om att staten hade "stulit" 11 dagar av deras liv.
Ryssland antog inte den gregorianska kalendern förrän 1918, efter den bolsjevikiska revolutionen. Därför inträffade "Oktoberrevolutionen" i november enligt gregoriansk räkning. Grekland väntade till 1923, och Turkiet blev det sista stora landet att byta 1926.
Idag är den gregorianska kalendern den internationella civila standarden. Skottårsreglerna är kodifierade i ISO 8601, den internationella datum- och tidstandarden. Varje större programmeringsspråk inkluderar skottårslogik i sina datumhanteringsbibliotek, vilket säkerställer konsekventa beräkningar över hela världen.
Om du implementerar skottårslogik i din egen applikation, här är hur du gör det korrekt i flera språk. Varje exempel följer samma algoritm—kontrollera delbarhet med 400 först, sedan 100, sedan 4—för att säkerställa kantfall som 2000 hanteras korrekt.
1def is_leap_year(year):
2 """
3 Kontrollera om ett år är ett skottår enligt den gregorianska kalenderns regler.
4 Returnerar True om skottår, False annars.
5 """
6 if year % 400 == 0:
7 return True
8 elif year % 100 == 0:
9 return False
10 elif year % 4 == 0:
11 return True
12 else:
13 return False
14
15# Exempelanvändning:
16year = 2024
17if is_leap_year(year):
18 print(f"Ja, {year} är ett skottår")
19else:
20 print(f"Nej, {year} är inte ett skottår")
21
22# Testa med flera år
23test_years = [2000, 1900, 2024, 2023, 1600, 2100]
24for year in test_years:
25 result = "är" if is_leap_year(year) else "är inte"
26 print(f"{year} {result} ett skottår")
271function isLeapYear(year) {
2 /**
3 * Kontrollera om ett år är ett skottår enligt den gregorianska kalenderns regler.
4 * Returnerar true om skottår, false annars.
5 */
6 if (year % 400 === 0) {
7 return true;
8 } else if (year % 100 === 0) {
9 return false;
10 } else if (year % 4 === 0) {
11 return true;
12 } else {
13 return false;
14 }
15}
16
17// Alternativ kompakt version
18function isLeapYearCompact(year) {
19 return (year % 4 === 0 && year % 100 !== 0) || (year % 400 === 0);
20}
21
22// Exempelanvändning:
23const year = 2024;
24if (isLeapYear(year)) {
25 console.log(`Ja, ${year} är ett skottår`);
26} else {
27 console.log(`Nej, ${year} är inte ett skottår`);
28}
29
30// Testa med flera år
31const testYears = [2000, 1900, 2024, 2023, 1600, 2100];
32testYears.forEach(year => {
33 const result = isLeapYear(year) ? "är" : "är inte";
34 console.log(`${year} ${result} ett skottår`);
35});
361public class LeapYearChecker {
2 /**
3 * Kontrollera om ett år är ett skottår enligt den gregorianska kalenderns regler.
4 * @param year Året som ska kontrolleras
5 * @return true om skottår, false annars
6 */
7 public static boolean isLeapYear(int year) {
8 if (year % 400 == 0) {
9 return true;
10 } else if (year % 100 == 0) {
11 return false;
12 } else if (year % 4 == 0) {
13 return true;
14 } else {
15 return false;
16 }
17 }
18
19 public static void main(String[] args) {
20 int year = 2024;
21 if (isLeapYear(year)) {
22 System.out.println("Ja, " + year + " är ett skottår");
23 } else {
24 System.out.println("Nej, " + year + " är inte ett skottår");
25 }
26
27 // Testa med flera år
28 int[] testYears = {2000, 1900, 2024, 2023, 1600, 2100};
29 for (int testYear : testYears) {
30 String result = isLeapYear(testYear) ? "är" : "är inte";
31 System.out.println(testYear + " " + result + " ett skottår");
32 }
33 }
34}
351' Excel VBA-funktion för skottårskontroll
2Function IsLeapYear(year As Integer) As Boolean
3 ' Kontrollera om ett år är ett skottår enligt den gregorianska kalenderns regler
4 ' Returnerar True om skottår, False annars
5
6 If year Mod 400 = 0 Then
7 IsLeapYear = True
8 ElseIf year Mod 100 = 0 Then
9 IsLeapYear = False
10 ElseIf year Mod 4 = 0 Then
11 IsLeapYear = True
12 Else
13 IsLeapYear = False
14 End If
15End Function
16
17' Användning i Excel-cell:
18' =IF(IsLeapYear(A1), "Ja, " & A1 & " är ett skottår", "Nej, " & A1 & " är inte ett skottår")
191#include <stdio.h>
2#include <stdbool.h>
3
4/**
5 * Kontrollera om ett år är ett skottår enligt den gregorianska kalenderns regler.
6 * Returnerar true om skottår, false annars.
7 */
8bool is_leap_year(int year) {
9 if (year % 400 == 0) {
10 return true;
11 } else if (year % 100 == 0) {
12 return false;
13 } else if (year % 4 == 0) {
14 return true;
15 } else {
16 return false;
17 }
18}
19
20int main() {
21 int year = 2024;
22
23 if (is_leap_year(year)) {
24 printf("Ja, %d är ett skottår\n", year);
25 } else {
26 printf("Nej, %d är inte ett skottår\n", year);
27 }
28
29 // Testa med flera år
30 int test_years[] = {2000, 1900, 2024, 2023, 1600, 2100};
31 int num_years = sizeof(test_years) / sizeof(test_years[0]);
32
33 for (int i = 0; i < num_years; i++) {
34 const char *result = is_leap_year(test_years[i]) ? "är" : "är inte";
35 printf("%d %s ett skottår\n", test_years[i], result);
36 }
37
38 return 0;
39}
40Den kompakta JavaScript-versionen visar hur du kan uttrycka hela regeln som ett enda booleskt uttryck: (year % 4 === 0 && year % 100 !== 0) || (year % 400 === 0). Även om den är koncis, är if-else-strukturen ofta tydligare för underhåll och felsökning.
Låt oss gå igenom specifika exempel för att se hur reglerna tillämpas:
2024 (typiskt skottår)
2000 (det knepiga sekelåret)
1900 (sekelåret som inte var)
2023 (vanligt icke-skottår)
2100 (framtida sekelår)
1600 (historiskt sekel-skottår)
Under varje 400-årsperiod finns exakt 97 skottår:
Detta mönster upprepas för evigt, vilket gör kalendarberäkningar förutsägbara över sekler.
F: Är 2024 ett skottår?
Ja. 2024 är delbart med 4 och är inte ett sekelår, så det kvalificerar sig som ett skottår. Februari 2024 hade 29 dagar.
F: Är 2025 ett skottår?
Nej. 2025 är inte delbart med 4 (2025 ÷ 4 = 506,25), så det är ett vanligt år med 365 dagar. Februari 2025 kommer att ha endast 28 dagar.
F: Kommer 2028 att vara ett skottår?
Ja. 2028 följer standardmönstret—delbart med 4, inte ett sekelår—vilket gör det till ett skottår med 366 dagar.
F: Varför var 2000 ett skottår men 1900 inte?
Sekelår följer en strängare regel. De måste vara delbara med 400 för att kvalificera sig som skottår. Eftersom 2000 ÷ 400 = 5 (heltal), var det ett skottår. Men 1900 ÷ 400 = 4,75 (inte heltal), så 1900 var inte ett skottår. Detta överraskar många.
F: Vad är regeln för skottår?
Delbart med 4? Skottår. Delbart med 100? Inte ett skottår. Delbart med 400? Skottår ändå. Reglerna tillämpas i exakt denna ordning för att hantera gränsfall korrekt.
F: Varför behöver vi skottår?
Jorden kretsar kring solen på 365,2422 dagar, inte exakt 365. Utan skottår skulle vår kalender förskjutas 24 dagar varje sekel. Sommaren skulle så småningom inträffa på vintern. Skottår håller kalendern synkroniserad med jordens faktiska omloppsbana och bevarar årstiderna.
F: Hur ofta inträffar skottår?
Generellt vart fjärde år, men med undantag. Under vilken 400-årsperiod som helst finns det exakt 97 skottår (inte 100), tack vare sekelårsregeln.
F: Kommer 2100 att vara ett skottår?
Nej. Som ett sekelår måste 2100 vara delbart med 400 för att kvalificera sig, och det är det inte (2100 ÷ 400 = 5,25). Nästa sekelår som är skottår efter 2000 kommer att vara 2400.
F: Vad händer om man är född den 29 februari?
Personer födda på skottdagen (29 februari) har bara sin faktiska födelsedag vart fjärde år. Under icke-skottår firar de vanligtvis den 28 februari eller 1 mars. Juridiskt sett betraktar de flesta jurisdiktioner den 28 februari som deras födelsedag för ålderrelaterade syften.
F: Hur exakt är den gregorianska kalendern?
Extremt exakt. Den förskjuts bara med 26 sekunder per år—ungefär en dag var 3 300:e år. Jämför det med den julianska kalendern, som förskjöts en dag var 128:e år.
Upptäck fler verktyg som kan vara användbara för din arbetsflöde