Életkor kalkulátor — Pontos életkor évben, hónapban és napban

Mit csinál ez a kalkulátor

Adja meg születési dátumát, és azt mondja meg pontosan hány éves — évben, hónapban és napban — ugyanúgy, ahogy hangosan mondanád ("33 éves, 4 hónapos és 5 napos vagyok"). Az ugyanazon korát tisztán hónapokban, hetekben, napokban, órákban, percekben és másodpercekben is megjeleníti, az születési hét napja, és mennyi ideig van a következő születésnapjáig.

Hagyja a második mezőt mai dátumon az aktuális korához, vagy módosítsa bármely múlt vagy jövő dátumra, hogy megtalálja az arra a dátumra vonatkozó korát.

Az az egy szabály, amely bonyolulttá teszi az korokat: a hónapok és évek nem egy rögzített napok száma. február 28 vagy 29; más hónapok 30 vagy 31. Tehát "1 hónap" azt jelenti "ugyanaz a napszám, egy hónappal később" — nem "30 nap." Ez a kalkulátor követi ezt a naptári szabályt, ezért akár 1-2 nappal eltérhet azoktól az eszközöktől, amelyek csak 30-val vagy 365-tel osztanak.

Hogyan számítják ki az életed

Az életkor a két dátum közötti különbség. Két becsületes módja van ennek a különbségnek a mérésére, és ez az eszköz mindkettőt megjeleníti.

1. Naptári kor (évek, hónapok, napok). Számold össze az egész éveket a születésnapodtól, majd az egész hónapokat, majd a maradék napokat:

1. A születés óta teljes évek számlálása.
2. Az utolsó születésnaptól számolj teljes hónapokat.
3. Innen számold meg a hátralévő napokat.

A finom rész a 3. lépés a hónaphatárok közelében. Valaki, aki január 31-én született, március 1-én mérve, 1 hónap és 1 nap régi — mert "egy hónappal január 31 után" február 28/29-re esik (nincs február 31), és március 1. egy nappal később van. Ez a kalkulátor a rövidebb hónap végéhez rögzít, megfelelve a széles körben használt dateutil.relativedelta szabálynak, így a hónapvégi születések soha nem termelnek negatív napszámlálást.

2. Teljes eltelt idő (napok, órák, másodpercek). Az "az életed más egységekben" számok esetén a két dátum teljes napok számlálásává konvertálódik és szorzódik:

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

Mindkét dátumot először UTC éjfélig rögzítik, így a nyári időszámítás módosulásai nem adhatnak vagy dobhatnak le egy órát és nem dobhatják el a napszámlálást. A hetek napok ÷ 7 (lefelé kerekítve); az órák, percek és másodpercek a napszámlálásnál felskalázódnak.

Miért nem csak napok 365-tel való osztása? Mert sodródnál. 7 305 nap 365-tel való osztása 20,01 évet ad; a 365,25-tel való osztás 20,00-t ad — de egyik sem tudja, hogy mely évek voltak szökőévek vagy hogy mely hónapok éltek valójában. A naptári számlálás pontos; a napok osztása egy közelítés. Használja az "hány éves vagyok" naptári korát, és a teljes napok / hetek számát a pontos eltelt idő munkájához (gyógyszeradagolás időzítése, projektidőtartamok, mérföldkő visszaszámlálás).

Megoldott példa

Született 2000. január 1-én, mérve 2020. január 1-én:

A 7,305 nap = 20 × 365 + 5 szökőnap (2000, 2004, 2008, 2012, 2016). Ez az egyetlen részlet — öt extra nap, amit a legtöbb ember elfelejt — pontosan azért, hogy egy kalkulátor legyőz a mentális matematikát.

Élet a kódban

Az ugyanaz a számítás minden nyelvben. Naptári kor esetén a beépített dátumkönyvtárat részesítsd előnyben a kézzel gördített aritmetika helyett — már ismeri a szökőéveket és a hónapok hosszát.

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

Gyakori kérdések

Pontosan hány éves vagyok? Adja meg születési dátumát, és hagyja a célt mai dátumon. A kalkulátor megjeleníti az életed évben, hónapban és napban, és megismétli azt teljes napok, hetek, órák és másodpercek számában.

Miért különbözik az életkorom egy másik kalkulátortól? Szinte mindig a hónap/nap maradék. Az eszközök nem értenek egyet abban, hogy hogyan kell számlálni a napokat az utolsó teljes hónap után a hónaphatárok. Ez az rögzít a rövidebb hónapra (a relativedelta megállapodás); egy eszköz, amely 30-val oszt, akár 1-2 nappal is eltérhet.

Kezeli a szökőéveket és február 29-i születésnapokat? Igen. A napszámlálások a tartományon belüli minden szökőnapot tartalmazzák, és a február 29-i születésnap a nem szökőévekben február 28. / március 1-hez képest mérve, túlcsordulás nélkül.

Kiszámíthatom az életet egy múltbeli vagy jövőbeli dátumon? Igen — állítsa be az "Életkor időpontja" mezőt bármely dátumra. A jövő dátuma megmondja, mennyire leszel akkor régi; egy korábbi dátum, mennyire voltál régi.

Mit szólsz az időzónákhoz? A dátumok az UTC-re normalizálódnak számlálás előtt, így az egész napi összeg stabil, függetlenül attól, hogy hol vagy vagy hogy a nyári időszámítás megváltozott-e.

Források

1. Python dateutil — relativedelta (a naptári kori hónap/napi szabály, amely ezt az eszközt követi).
2. Java Platform — Period.between és ChronoUnit.DAYS.
3. Microsoft Excel — DATEDIF funkció.
4. MDN Web Docs — Date.
5. Dershowitz, N., & Reingold, E. M. Calendrical Calculations: The Ultimate Edition. Cambridge University Press, 2018.