Leeftijdscalculator — Exacte leeftijd in jaren, maanden & dagen

Wat deze calculator doet

Voer je geboortedatum in en het vertelt je precies hoe oud je bent — in jaren, maanden en dagen — op dezelfde manier als je het zou zeggen ("Ik ben 33 jaar, 4 maanden en 5 dagen oud"). Het toont ook dezelfde leeftijd uitgerekend in maanden, weken, dagen, uren, minuten en seconden, de weekdag waarop je bent geboren, en hoe lang tot je volgende verjaardag.

Laat het tweede veld op vandaag staan voor je huidige leeftijd, of wijzig het naar een willekeurige voorbije of toekomstige datum om je leeftijd op die datum te vinden.

De ene regel die leeftijden lastig maakt: maanden en jaren zijn geen vast aantal dagen. Februari heeft 28 of 29; andere maanden hebben 30 of 31. Dus "1 maand" betekent "dezelfde dagaantal, één maand later" — niet "30 dagen." Deze calculator volgt die kalenderregel, daarom kan deze tot één of twee dagen verschillen van tools die simpel delen door 30 of 365.

Hoe je leeftijd wordt berekend

Leeftijd is het verschil tussen twee datums. Er zijn twee eerlijke manieren om dat verschil te meten, en deze tool toont beide.

1. Kalenderleeftijd (jaren, maanden, dagen). Tel hele jaren vanaf je geboortedag, dan hele maanden, dan de resterende dagen:

1. Tel volle jaren sinds geboorte.
2. Vanaf de laatste verjaardag, tel volle maanden.
3. Daarvandaan, tel de resterende dagen.

Het subtiele gedeelte is stap 3 bij maandgrenzen. Iemand geboren op 31 januari, gemeten op 1 maart, is 1 maand en 1 dag oud — omdat "één maand na jan 31" landt op feb 28/29 (er is geen feb 31), en maart 1 is één dag voorbij dat. Deze calculator beperkt tot het einde van de kortere maand, overeenkomstig met de veel gebruikte dateutil.relativedelta regel zodat verjaardagen aan maandende nooit een negatief dagaantal opleveren.

2. Totale verstreken tijd (dagen, uren, seconden). Voor de "je leeftijd in andere eenheden" cijfers, worden de twee datums omgezet naar een aantal hele dagen en vermenigvuldigd:

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

Beide datums worden eerst vastgezet op UTC middernacht, dus veranderingen in zomerlijktijdregeling kunnen geen uur toevoegen of verwijderen en het dagaantal verstoren. Weken zijn dagen ÷ 7 (afgerond naar beneden); uren, minuten en seconden zijn het dagaantal opgeschaald.

Waarom niet gewoon dagen delen door 365? Omdat je zou afdrijven. 7.305 dagen delen door 365 geeft 20,01 jaar; delen door 365,25 geeft 20,00 — maar geen van beide weet welke jaren schrikkeljaren waren of welke maanden je echt hebt doorleefd. Kalendertellingen zijn exact; dag-delen is een benadering. Gebruik kalenderleeftijd voor "hoe oud ben ik," en totale dagen/weken voor nauwkeurig verstrijken-tijdwerk (medicijntiming, projectduur, mijlpaalbijtrekking).

Uitgewerkt voorbeeld

Geboren 1 januari 2000, gemeten 1 januari 2020:

De 7.305 dagen = 20 × 365 + 5 schrikkeldagen (2000, 2004, 2008, 2012, 2016). Dit ene detail — vijf extra dagen die de meeste mensen vergeten — is exact waarom een calculator mentale wiskunde verslaat.

Leeftijd in code

De dezelfde berekening in elke taal. Voor kalenderleeftijd, verkies een ingebouwde datumbibliotheek boven zelf bedachte rekenkunde — het kent al schrikkeljaren en maandlengten.

1' Hele dagen tussen twee datums (A1 = geboorte, B1 = doel):
2=B1-A1
3
4' Kalenderleeftijd in volle jaren / maanden / resterende dagen:
5=DATEDIF(A1, B1, "y") & " jaren, " & DATEDIF(A1, B1, "ym") & " maanden, " & DATEDIF(A1, B1, "md") & " dagen"
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

Veelgestelde vragen

Hoe oud ben ik precies? Voer je geboortedatum in en laat het doel op vandaag. De calculator toont je leeftijd in jaren, maanden en dagen, en herhaalt het in totale dagen, weken, uren en seconden.

Waarom verschilt mijn leeftijd van een andere calculator? Bijna altijd de maand/dag rest. Tools verschillen in hoe ze de dagen tellen na de laatste volle maand bij maandgrenzen. Deze beperkt tot de kortere maand (de relativedelta conventie); een tool die door 30 deelt, zal met een dag of twee verschillen.

Werkt het met schrikkeljaren en verjaardag op 29 februari? Ja. Dagtotalen bevatten elke schrikkeldag in bereik, en een verjaardag op 29 februari wordt gemeten tegen 28 feb / 1 mrt in niet-schrikkeljaren zonder over te lopen.

Kan ik leeftijd op een voorbije of toekomstige datum berekenen? Ja — stel het "Leeftijd op datum" veld in op een willekeurige datum. Een toekomstige datum vertelt je hoe oud je dan bent; een voorbije datum, hoe oud je was.

Wat met tijdzones? Datums worden genormaliseerd naar UTC vóór tellen, dus het hele-dag totaal is stabiel ongeacht waar je bent of of zomerlijktijdregeling veranderde.

Bronnen

1. Python dateutil — relativedelta (de kalenderleeftijd maand/dag regel die deze tool volgt).
2. Java Platform — Period.between en ChronoUnit.DAYS.
3. Microsoft Excel — DATEDIF functie.
4. MDN Web Docs — Date.
5. Dershowitz, N., & Reingold, E. M. Calendrical Calculations: The Ultimate Edition. Cambridge University Press, 2018.