Åldersräknare — Exakt ålder i år, månader och dagar

Vad denna miniräknare gör

Ange ditt födelsedatum och den talar om för dig exakt hur gammal du är – i år, månader och dagar – samma sätt som du skulle säga det högt ("Jag är 33 år, 4 månader och 5 dagar gammal"). Den visar också samma ålder räknad rent i månader, veckor, dagar, timmar, minuter och sekunder, vilken veckodag du föddes på och hur lång tid det är till din nästa födelsedag.

Lämna det andra fältet på dagens datum för din nuvarande ålder, eller ändra det till ett tidigare eller framtida datum för att hitta din ålder på det datumet.

Den ena regel som gör ålder knepig: månader och år är inte ett fast antal dagar. Februari har 28 eller 29; andra månader har 30 eller 31. Så "1 månad" betyder "samma datumtal, en månad senare" – inte "30 dagar". Den här räknaren följer denna kalenderregel, vilket är varför den kan skilja sig med en dag eller två från verktyg som bara delar med 30 eller 365.

Hur din ålder räknas

Ålder är gapet mellan två datum. Det finns två ärliga sätt att mäta det gapet, och detta verktyg visar båda.

1. Kalenderålder (år, månader, dagar). Räkna hela år från din födelsedag, sedan hela månader, sedan de återstående dagarna:

1. Räkna fullständiga år sedan födseln.
2. Från den senaste födelsedagen, räkna fullständiga månader.
3. Från där, räkna de återstående dagarna.

Den subtila delen är steg 3 nära månadsgränser. Någon född på 31 januari, mätt på 1 mars, är 1 månad och 1 dag gammal – eftersom "en månad efter jan 31" landar på feb 28/29 (det finns ingen feb 31), och mars 1 är en dag efter det. Den här räknaren fäster vid slutet av den kortare månaden, vilket matchar den allmänt använda dateutil.relativedelta-regeln så månadsslutet födseldagar aldrig producerar ett negativt dagtal.

2. Total förfluten tid (dagar, timmar, sekunder). För "din ålder i andra enheter"-siffrorna konverteras de två datumen till ett antal hela dagar och multipliceras ut:

$\text{days} = \left\lfloor \frac{\text{target date} - \text{birth date}}{86{,}400{,}000 \text{ ms}} \right\rfloor$

Båda datumen är fastnålda till UTC midnatt först, så ändringar av sommar-/vintertid kan inte lägga till eller ta bort en timme och kasta dagräkningen. Veckor är dagar ÷ 7 (avrundat nedåt); timmar, minuter och sekunder är dagräkningen skalad upp.

Varför inte bara dividera dagar med 365? Eftersom du skulle driva. Att dividera 7 305 dagar med 365 ger 20,01 år; dividering med 365,25 ger 20,00 – men ingen av dem vet vilka år som var skottår eller vilka månader du faktiskt levde genom. Kalenderräkning är exakt; dag-delning är en approximation. Använd kalenderålder för "hur gammal är jag", och totala dagar/veckor för exakt förfluten tid arbete (medicintiming, projektvaraktigheter, milstolpnedräkningar).

Arbetade exempel

Född 1 januari 2000, mätt 1 januari 2020:

De 7 305 dagarna = 20 × 365 + 5 skottdagar (2000, 2004, 2008, 2012, 2016). Den enkla detaljen – fem extra dagar de flesta glömmer – är exakt varför en räknare slår huvudräkning.

Ålder i kod

Samma beräkning på varje språk. För kalenderålder, föredra ett inbyggt datumbibliotek framför handskrivna aritmetik – det vet redan skottår och månadslängder.

1' Whole days between two dates (A1 = birth, B1 = target):
2=B1-A1
3
4' Calendar age in complete years / months / leftover days:
5=DATEDIF(A1, B1, "y") & " years, " & DATEDIF(A1, B1, "ym") & " months, " & DATEDIF(A1, B1, "md") & " days"
6

1from dateutil.relativedelta import relativedelta
2from datetime import date
3
4birth, target = date(2000, 1, 1), date(2020, 1, 1)
5
6age = relativedelta(target, birth)          # calendar age
7print(f"{age.years}y {age.months}m {age.days}d")
8
9total_days = (target - birth).days           # total elapsed days
10print(total_days)                            # 7305
11

1function calendarAge(birth, target) {
2  let months = (target.getUTCFullYear() - birth.getUTCFullYear()) * 12
3             + (target.getUTCMonth() - birth.getUTCMonth());
4  const anchor = new Date(Date.UTC(birth.getUTCFullYear(), birth.getUTCMonth() + months, birth.getUTCDate()));
5  if (anchor > target) months--;
6  return { years: Math.floor(months / 12), months: months % 12 };
7}
8
9const birth = new Date(Date.UTC(2000, 0, 1));
10const target = new Date(Date.UTC(2020, 0, 1));
11const totalDays = Math.floor((target - birth) / 86400000); // 7305
12

1import java.time.LocalDate;
2import java.time.Period;
3import java.time.temporal.ChronoUnit;
4
5LocalDate birth = LocalDate.of(2000, 1, 1);
6LocalDate target = LocalDate.of(2020, 1, 1);
7
8Period age = Period.between(birth, target);   // 20y 0m 0d
9long totalDays = ChronoUnit.DAYS.between(birth, target); // 7305
10

1using System;
2
3var birth = new DateTime(2000, 1, 1);
4var target = new DateTime(2020, 1, 1);
5
6int years = target.Year - birth.Year;
7if (birth.AddYears(years) > target) years--;   // not birthday yet
8long totalDays = (target - birth).Days;         // 7305
9

1#include <chrono>
2using namespace std::chrono;
3
4// C++20 calendar types
5sys_days birth = year{2000}/1/1;
6sys_days target = year{2020}/1/1;
7
8auto total_days = (target - birth).count();     // 7305
9years_months_days ymd_diff{birth, target};      // year_month_day arithmetic
10

1package main
2
3import "time"
4
5func main() {
6    birth := time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)
7    target := time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)
8    totalDays := int(target.Sub(birth).Hours() / 24) // 7305
9    _ = totalDays
10}
11

1use chrono::{NaiveDate, Datelike};
2
3let birth = NaiveDate::from_ymd_opt(2000, 1, 1).unwrap();
4let target = NaiveDate::from_ymd_opt(2020, 1, 1).unwrap();
5
6let total_days = (target - birth).num_days(); // 7305
7let years = target.year() - birth.year();     // adjust if birthday not reached
8

1<?php
2$birth = new DateTime('2000-01-01');
3$target = new DateTime('2020-01-01');
4$diff = $birth->diff($target);
5
6echo "{$diff->y}y {$diff->m}m {$diff->d}d\n"; // 20y 0m 0d
7echo $diff->days;                             // 7305
8

1require 'date'
2
3birth  = Date.new(2000, 1, 1)
4target = Date.new(2020, 1, 1)
5
6total_days = (target - birth).to_i           # 7305
7years = target.year - birth.year
8years -= 1 if birth.next_year(years) > target
9

1birth  <- as.Date("2000-01-01")
2target <- as.Date("2020-01-01")
3
4total_days <- as.integer(target - birth)     # 7305
5

Vanliga frågor

Hur gammal är jag exakt? Ange ditt födelsedatum och lämna målet på idag. Räknaren visar din ålder i år, månader och dagar, och upprepar den i totala dagar, veckor, timmar och sekunder.

Varför skiljer min ålder från en annan räknare? Nästan alltid månaden/dag resten. Verktyg är oense om hur man räknar dagarna efter den senaste hela månaden vid månadsgränser. Den här fäster vid den kortare månaden (konventionen relativedelta); ett verktyg som delar med 30 kommer att skilja sig med en dag eller två.

Hanterar den skottår och feb 29-födseldagar? Ja. Dagräkningarna inkluderar varje skottdag i intervallet, och en 29 februari födelsedag mäts mot 28 feb / 1 mars i icke-skottår utan att svämma över.

Kan jag beräkna ålder på ett tidigare eller framtida datum? Ja – ställ in "Ålder på datum"-fältet på vilket datum som helst. Ett framtida datum säger dig hur gammal du kommer att vara då; ett tidigare datum, hur gammal du var.

Vad sägs om tidszoner? Datum normaliseras till UTC innan räkning, så det totala hela dagstalet är stabilt oavsett var du är eller om sommar-/vintertid förändrades.

Källor

1. Python dateutil — relativedelta (kalenderålder månad/dag-regeln denna verktyg följer).
2. Java Platform — Period.between och ChronoUnit.DAYS.
3. Microsoft Excel — DATEDIF funktion.
4. MDN Web Docs — Date.
5. Dershowitz, N., & Reingold, E. M. Calendrical Calculations: The Ultimate Edition. Cambridge University Press, 2018.