Calculator de Vârstă — Vârstă Exactă în Ani, Luni și Zile

Ce face acest calculator

Introdu data ta de naștere și ți spune exact cât de bătrân ești — în ani, luni și zile — exact cum ai spune cu voce tare ("Am 33 de ani, 4 luni și 5 zile"). Arată și aceeași vârstă calculată pur în luni, săptămâni, zile, ore, minute și secunde, ziua săptămânii în care te-ai născut și cât timp până la următoarea ta zi de naștere.

Lasă al doilea câmp pe data de azi pentru vârsta ta actuală, sau schimbă-o la orice dată din trecut sau viitor pentru a-ți afla vârsta la acea dată.

Regula care face vârstele complicate: lunile și anii nu sunt un număr fix de zile. Februarie are 28 sau 29; alte luni au 30 sau 31. Deci "1 lună" înseamnă "același număr de zi, o lună mai târziu" — nu "30 de zile." Acest calculator urmează regula calendarului, motiv pentru care poate diferi cu o zi sau două de instrumente care doar împart la 30 sau 365.

Cum se calculează vârsta ta

Vârsta este diferența între două date. Există două moduri oneste de a măsura acea diferență, iar acest instrument arată ambele.

1. Vârsta calendaristică (ani, luni, zile). Numără ani întregi de la ziua ta de naștere, apoi luni întregi, apoi zilele rămase:

1. Numără ani completi de la naștere.
2. De la ultima zi de naștere, numără lunile complete.
3. De acolo, numără zilele rămase.

Partea subtilă este pasul 3 lângă limitele lunilor. Cineva născut pe 31 ianuarie, măsurat pe 1 martie, are 1 lună și 1 zi — pentru că "o lună după 31 ianuarie" se întinde pe 28/29 februarie (nu există 31 februarie), iar 1 martie este o zi după aceea. Acest calculator se fixează la sfârșitul lunii mai scurte, potrivind regula dateutil.relativedelta utilizată pe scară largă, deci zilele de naștere la sfârșitul lunii nu produc niciodată un număr negativ de zile.

2. Timp total scurs (zile, ore, secunde). Pentru cifrele "vârsta ta în alte unități", cele două date sunt convertite într-o numărare a zilelor întregi și înmulțite:

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

Ambele date sunt fixate la miezul nopții UTC mai întâi, deci schimbările orei de vară nu pot adăuga sau scădea o oră și arunca din greșeală numărarea zilelor. Săptămânile sunt zile ÷ 7 (rotunjite în jos); ore, minute și secunde sunt numărarea zilelor scalată în sus.

De ce nu doar împarți zilele la 365? Pentru că ai deriva. Împărțirea 7.305 zile la 365 dă 20,01 ani; împărțirea la 365,25 dă 20,00 — dar nici una nu știe care ani au fost ani bisecți sau care luni ai trăit cu adevărat. Numărarea calendaristică este exactă; împărțirea zilelor este o aproximare. Folosește vârsta calendaristică pentru "cât de bătrân sunt", și zile/săptămâni totale pentru munca precisă cu timp scurs (sincronizarea medicamentelor, durate de proiecte, numărări la reper).

Exemplu lucrat

Născut 1 ianuarie 2000, măsurat 1 ianuarie 2020:

Cei 7.305 zile = 20 × 365 + 5 zile bisecte (2000, 2004, 2008, 2012, 2016). Acel singur detaliu — cinci zile suplimentare pe care majoritatea oamenilor le uită — este exact de ce un calculator bate calculul mental.

Vârstă în cod

Același calcul în fiecare limbă. Pentru vârsta calendaristică, preferă o bibliotecă de date încorporată în locul aritmeticii făcute manual — aceasta deja știe ani bisecți și lungimi de luni.

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

Întrebări frecvente

Cât de bătrân sunt exact? Introdu data ta de naștere și lasă ținta pe astazi. Calculatorul arată vârsta ta în ani, luni și zile, și o repetă în total zile, săptămâni, ore și secunde.

De ce vârsta mea diferă de alt calculator? Aproape întotdeauna restul lunii/zile. Instrumentele nu sunt de acord cum să numere zilele după ultima lună completă la limitele lunilor. Aceasta se fixează pe luna mai scurtă (convenția relativedelta); un instrument care împarte la 30 va diferi cu o zi sau două.

Tratează ani bisecți și zile de naștere pe 29 februarie? Da. Numărările zilelor includ fiecare zi bisectă în interval, iar o zi de naștere pe 29 februarie este măsurată pe 28 februarie / 1 martie în ani non-bisecți fără a se depăși.

Pot calcula vârsta pe o dată din trecut sau viitor? Da — setează câmpul "Vârstă la dată" la orice dată. O dată viitoare ți spune cât de bătrân vei fi atunci; o dată din trecut, cât de bătrân erai.

Ce zici de fusuri orare? Datele sunt normalizate la UTC înainte de numărare, deci totalul zilei întregi este stabil indiferent unde ești sau dacă ora de vară s-a schimbat.

Surse

1. Python dateutil — relativedelta (regula lunii/zile de vârstă calendaristică pe care o urmează acest instrument).
2. Java Platform — Period.between și ChronoUnit.DAYS.
3. Microsoft Excel — DATEDIF function.
4. MDN Web Docs — Date.
5. Dershowitz, N., & Reingold, E. M. Calendrical Calculations: The Ultimate Edition. Cambridge University Press, 2018.