Aldersberegner — Præcis alder i år, måneder og dage

Hvad denne lommeregner gør

Indtast din fødselsdato, og den fortæller dig præcis, hvor gammel du er — i år, måneder og dage — på samme måde som du ville sige det højt ("Jeg er 33 år, 4 måneder og 5 dage gammel"). Den viser også samme alder talt rent i måneder, uger, dage, timer, minutter og sekunder, den ugedag du blev født på, og hvor længe til din næste fødselsdag.

Lad det andet felt stå på dagens dato for at få din nuværende alder, eller ændr det til en vilkårlig dato før eller i fremtiden for at finde din alder på den dato.

Den ene regel der gør aldersberegning vanskelig: Måneder og år er ikke et fast antal dage. Februar har 28 eller 29; andre måneder har 30 eller 31. Så "1 måned" betyder "det samme dagnummer, en måned senere" — ikke "30 dage." Denne lommeregner følger denne kalenderregel, hvilket er grunden til at den kan afvige med en dag eller to fra værktøjer der bare dividerer med 30 eller 365.

Hvordan din alder beregnes

Alder er kløften mellem to datoer. Der er to ærlige måder at måle den kløft på, og dette værktøj viser begge.

1. Kalenderalder (år, måneder, dage). Tæl hele år fra din fødselsdag, derefter hele måneder, derefter de resterende dage:

1. Tæl hele år siden fødslen.
2. Fra sidste fødselsdag, tæl hele måneder.
3. Derfra, tæl de resterende dage.

Den subtile del er trin 3 nær månedgrænserne. Nogen født den 31. januar, målt den 1. marts, er 1 måned og 1 dag gammel — fordi "en måned efter 31. januar" lander på 28./29. februar (der er ingen 31. februar), og 1. marts er en dag efter det. Denne lommeregner klemmer til slutningen af den kortere måned, hvilket svarer til den vidt brugte dateutil.relativedelta regel, så fødsler på månedsslutningen aldrig producerer en negativ dagcount.

2. Samlet forløbet tid (dage, timer, sekunder). For figurerne "din alder i andre enheder" konverteres de to datoer til et antal hele dage og ganges ud:

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

Begge datoer er fastgjort til UTC midnat først, så sommertidsskift kan ikke tilføje eller fjerne en time og ødelægge dagtellingen. Uger er dage ÷ 7 (afrundet ned); timer, minutter og sekunder er dagtellingen skaleret op.

Hvorfor ikke bare dividere dage med 365? Fordi du ville drive. Division af 7.305 dage med 365 giver 20,01 år; dividering med 365,25 giver 20,00 — men ingen ved hvilke år der var skudår eller hvilke måneder du faktisk levede gennem. Kalenderoptælling er præcis; dag-division er en tilnærmelse. Brug kalenderalder for "hvor gammel er jeg," og totale dage/uger for præcis forløbet-tid arbejde (medicintiming, projektvarighed, milepælsnedetællinger).

Arbejdet eksempel

Født 1. januar 2000, målt 1. januar 2020:

De 7.305 dage = 20 × 365 + 5 skuddage (2000, 2004, 2008, 2012, 2016). Den eneste detalje — fem ekstra dage som de fleste mennesker glemmer — er præcis hvorfor en lommeregner slår mentalt regnearbejde.

Alder i kode

Den samme beregning på hvert sprog. For kalenderalder, foretrækker en indbygget datobibliotek frem for håndskrevet aritmetik — den ved allerede skudår og månedslængder.

1' Hele dage mellem to datoer (A1 = fødsel, B1 = mål):
2=B1-A1
3
4' Kalenderalder i fuldførte år / måneder / resterende dage:
5=DATEDIF(A1, B1, "y") & " år, " & DATEDIF(A1, B1, "ym") & " måneder, " & DATEDIF(A1, B1, "md") & " dage"
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

Almindelige spørgsmål

Hvor gammel er jeg præcist? Indtast din fødselsdato og lad målmålet stå på i dag. Lommeregneren viser din alder i år, måneder og dage, og gentager det i samlet dage, uger, timer og sekunder.

Hvorfor adskiller min alder sig fra en anden lommeregner? Næsten altid måned/dag-resten. Værktøjer er uenige om, hvordan man tæller dagene efter den sidste hele måned ved månedgrænserne. Denne klemmer til den kortere måned (konventionen relativedelta); et værktøj der dividerer med 30 vil afvige med en dag eller to.

Håndterer det skudår og 29. februar-fødsler? Ja. Dagtellingerne omfatter hver skuddag i intervallet, og en 29. februar-fødsel måles mod 28. februar / 1. marts i ikke-skudår uden overløb.

Kan jeg beregne alder på en tidligere eller fremtidig dato? Ja — sæt feltet "Alder på dato" til en vilkårlig dato. En fremtidig dato fortæller dig hvor gammel du er derefter; en tidligere dato, hvor gammel du var.

Hvad med tidszoner? Datoer normaliseres til UTC før tælling, så den hele-dage-total er stabil uanset hvor du er eller om sommertid ændrede.

kilder

1. Python dateutil — relativedelta (kalenderalderens måned/dag-regel som dette værktøj følger).
2. Java Platform — Period.between og 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.