Kalkulator Wieku — Dokładny Wiek w Latach, Miesiącach i Dniach

Co robi ten kalkulator

Wpisz swoją datę urodzenia, a otrzymasz dokładny wiek — w latach, miesiącach i dniach — w taki sposób, w jaki byś go wymówił ("Mam 33 lata, 4 miesiące i 5 dni"). Pokazuje również ten sam wiek przeliczony czysto w miesiącach, tygodniach, dniach, godzinach, minutach i sekundach, dzień tygodnia, w którym się urodziłeś, oraz ile czasu pozostało do następnych urodzin.

Pozostaw drugie pole na dzisiejszą datę, aby poznać swój obecny wiek, lub zmień je na dowolną datę z przeszłości lub przyszłości, aby znaleźć swój wiek na tę datę.

Jedna zasada, która sprawia, że liczenie wieku jest trudne: miesiące i lata nie zawierają stałej liczby dni. Luty ma 28 lub 29; inne miesiące mają 30 lub 31. Dlatego "1 miesiąc" oznacza "ten sam dzień miesiąca, jeden miesiąc później" — nie "30 dni". Ten kalkulator stosuje tę zasadę kalendarza, dlatego może różnić się o dzień lub dwa od narzędzi, które dzielą przez 30 lub 365.

Jak obliczany jest wiek

Wiek to różnica między dwiema datami. Istnieją dwa uczciwe sposoby pomiaru tej różnicy, a to narzędzie pokazuje oba.

1. Wiek kalendarzowy (lata, miesiące, dni). Policz pełne lata od urodzin, potem pełne miesiące, potem pozostałe dni:

1. Policz pełne lata od urodzenia.
2. Od ostatnich urodzin policz pełne miesiące.
3. Stamtąd policz pozostałe dni.

Delikatna część to krok 3 przy granicach miesięcy. Ktoś urodzony 31 stycznia, mierzony 1 marca, ma 1 miesiąc i 1 dzień — ponieważ "jeden miesiąc po 31 stycznia" przypada na 28/29 lutego (nie ma 31 lutego), a 1 marca to jeden dzień po tym. Ten kalkulator ogranicza się do końca krótszego miesiąca, zgodnie z powszechnie używaną regułą dateutil.relativedelta, tak aby urodziny na koniec miesiąca nigdy nie dały ujemnej liczby dni.

2. Całkowity upłynięty czas (dni, godziny, sekundy). Dla danych "twój wiek w innych jednostkach" dwie daty są konwertowane na liczbę pełnych dni i mnożone:

$\text{dni} = \left\lfloor \frac{\text{data docelowa} - \text{data urodzenia}}{86{,}400{,}000 \text{ ms}} \right\rfloor$

Obie daty są najpierw przypięte do północy UTC, aby zmiany czasu letniego nie mogły dodać ani usunąć godziny i zaburzyć liczby dni. Tygodnie to dni ÷ 7 (zaokrąglone w dół); godziny, minuty i sekundy to liczba dni przeskalowana.

Dlaczego nie po prostu podzielić dni przez 365? Ponieważ będziesz dryfować. Podzielenie 7305 dni przez 365 daje 20,01 roku; podzielenie przez 365,25 daje 20,00 — ale żadne z nich nie wie, które lata były latami przestępnymi lub które miesiące faktycznie przeżyłeś. Liczenie kalendarza jest dokładne; dzielenie dni jest przybliżeniem. Użyj wieku kalendarza dla "ile mam lat", a całkowitych dni/tygodni dla precyzyjnej pracy ze upływem czasu (harmonogram leków, czasy trwania projektów, odliczanie kamieni milowych).

Pracowany przykład

Urodzony 1 stycznia 2000, mierzony 1 stycznia 2020:

7 305 dni = 20 × 365 + 5 dni przestępnych (2000, 2004, 2008, 2012, 2016). Ten jeden szczegół — pięć dodatkowych dni, które większość ludzi zapomina — to dokładnie powód, dla którego kalkulator pokonuje matematykę mentalną.

Wiek w kodzie

Ta sama kalkulacja w każdym języku. Dla wieku kalendarza preferuj wbudowaną bibliotekę daty zamiast ręcznej arytmetyki — już zna lata przestępne i długości miesięcy.

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

Często zadawane pytania

Ile dokładnie mam lat? Wpisz swoją datę urodzenia i zostaw datę docelową na dzisiaj. Kalkulator pokaże twój wiek w latach, miesiącach i dniach, a następnie powtórzy go w całkowitych dniach, tygodniach, godzinach i sekundach.

Dlaczego mój wiek różni się od innego kalkulatora? Prawie zawsze są to pozostałe dni w miesiącu. Narzędzia różnią się w sposobie liczenia dni po ostatnim pełnym miesiącu na granicy miesięcy. Ten kalkulator ogranicza się do krótszego miesiąca (konwencja relativedelta); narzędzie, które dzieli przez 30, będzie różnić się o dzień lub dwa.

Czy obsługuje lata przestępne i urodziny 29 lutego? Tak. Liczby dni obejmują każdy dzień przestępny w zakresie, a urodziny 29 lutego są mierzone w stosunku do 28 lutego / 1 marca w latach nieprzestępnych bez przepełnienia.

Czy mogę obliczyć wiek na datę z przeszłości lub przyszłości? Tak — ustaw pole "Wiek na datę" na dowolną datę. Przyszła data mówi ci, ile będziesz mieć lat wtedy; przeszła data, ile miałeś.

A co z strefami czasowymi? Daty są normalizowane do UTC przed liczeniem, więc całkowita liczba dni jest stabilna niezależnie od tego, gdzie się znajdujesz, czy zmienia się czas letni.

Źródła

1. Python dateutil — relativedelta (reguła wieku kalendarza miesiąc/dzień, którą stosuje to narzędzie).
2. Java Platform — Period.between i ChronoUnit.DAYS.
3. Microsoft Excel — funkcja DATEDIF.
4. MDN Web Docs — Date.
5. Dershowitz, N., & Reingold, E. M. Calendrical Calculations: The Ultimate Edition. Cambridge University Press, 2018.