Calcolatore di Età — Età Esatta in Anni, Mesi e Giorni

Cosa fa questo calcolatore

Inserisci la tua data di nascita e ti dice esattamente quanti anni hai — in anni, mesi e giorni — nello stesso modo in cui lo diresti a voce ("Ho 33 anni, 4 mesi e 5 giorni"). Mostra anche la stessa età contata in mesi, settimane, giorni, ore, minuti e secondi totali, il giorno della settimana in cui sei nato, e quanto tempo manca al tuo prossimo compleanno.

Lascia il secondo campo sulla data odierna per ottenere la tua età attuale, o cambialo con qualsiasi data passata o futura per trovare la tua età in quella data.

La regola che rende gli anni complicati: i mesi e gli anni non sono un numero fisso di giorni. Febbraio ha 28 o 29 giorni; gli altri mesi hanno 30 o 31. Quindi "1 mese" significa "lo stesso giorno del mese, un mese dopo" — non "30 giorni." Questo calcolatore segue questa regola del calendario, per cui può differire di un giorno o due dai calcolatori che dividono semplicemente per 30 o 365.

Come viene calcolata la tua età

L'età è il divario tra due date. Ci sono due modi onesti di misurare quel divario, e questo strumento mostra entrambi.

1. Età del calendario (anni, mesi, giorni). Conta gli anni interi dalla tua nascita, poi i mesi interi, quindi i giorni rimanenti:

1. Conta gli anni completi dalla nascita.
2. Dall'ultimo compleanno, conta i mesi completi.
3. Da lì, conta i giorni rimanenti.

La parte subdola è il passaggio 3 vicino ai confini del mese. Qualcuno nato il 31 gennaio, misurato il 1° marzo, ha 1 mese e 1 giorno — perché "un mese dopo il 31 gennaio" arriva al 28/29 febbraio (non esiste il 31 febbraio), e il 1° marzo è un giorno dopo. Questo calcolatore fissa la fine del mese più breve, in linea con la regola ampiamente utilizzata di dateutil.relativedelta, quindi i compleanni di fine mese non producono mai un conteggio negativo di giorni.

2. Tempo totale trascorso (giorni, ore, secondi). Per i valori "la tua età in altre unità", le due date vengono convertite in un conteggio di giorni interi e poi moltiplicate:

$\text{giorni} = \left\lfloor \frac{\text{data target} - \text{data di nascita}}{86{,}400{,}000 \text{ ms}} \right\rfloor$

Entrambe le date vengono prima ancorate a mezzanotte UTC, quindi i cambiamenti dell'ora legale non possono aggiungere o togliere un'ora e far perdere il conteggio dei giorni. Le settimane sono giorni ÷ 7 (arrotondati per difetto); ore, minuti e secondi sono il conteggio dei giorni moltiplicato.

Perché non dividere semplicemente i giorni per 365? Perché staresti alla deriva. Dividere 7.305 giorni per 365 dà 20,01 anni; dividere per 365,25 dà 20,00 — ma nessuno sa quali anni erano bisestili o quali mesi hai effettivamente vissuto. Il conteggio del calendario è esatto; la divisione per giorni è un'approssimazione. Usa l'età del calendario per "quanti anni ho", e i giorni/settimane totali per i lavori di tempo trascorso preciso (tempistica dei farmaci, durate dei progetti, conteggi dei traguardi).

Esempio pratico

Nato il 1° gennaio 2000, misurato il 1° gennaio 2020:

I 7.305 giorni = 20 × 365 + 5 giorni bisestili (2000, 2004, 2008, 2012, 2016). Questo singolo dettaglio — cinque giorni extra che la maggior parte delle persone dimentica — è esattamente il motivo per cui un calcolatore batte la matematica mentale.

Età nel codice

Lo stesso calcolo in ogni linguaggio. Per l'età del calendario, preferisci una libreria di date integrata invece di un'aritmetica manuale — sa già dei anni bisestili e delle lunghezze dei mesi.

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

Domande frequenti

Quanti anni ho esattamente? Inserisci la tua data di nascita e lascia il target sulla data odierna. Il calcolatore mostra la tua età in anni, mesi e giorni, e la ripete in giorni, settimane, ore e secondi totali.

Perché la mia età differisce da un altro calcolatore? Quasi sempre il resto del mese/giorno. I calcolatori non sono d'accordo su come contare i giorni dopo l'ultimo mese intero ai confini del mese. Questo fissa il mese più breve (la convenzione relativedelta); uno strumento che divide per 30 differirà di un giorno o due.

Gestisce gli anni bisestili e i compleanni del 29 febbraio? Sì. I conteggi dei giorni includono ogni giorno bisestile nell'intervallo, e un compleanno del 29 febbraio viene misurato contro il 28 febbraio / 1° marzo negli anni non bisestili senza overflow.

Posso calcolare l'età in una data passata o futura? Sì — imposta il campo "Età alla data" su qualsiasi data. Una data futura ti dice quanti anni avrai allora; una data passata, quanti anni avevi.

E i fusi orari? Le date vengono normalizzate a UTC prima del conteggio, quindi il totale del giorno intero è stabile indipendentemente da dove ti trovi o da eventuali cambiamenti dell'ora legale.

Fonti

1. Python dateutil — relativedelta (la regola del mese/giorno dell'età del calendario che segue questo strumento).
2. Java Platform — Period.between e ChronoUnit.DAYS.
3. Microsoft Excel — funzione DATEDIF.
4. MDN Web Docs — Date.
5. Dershowitz, N., & Reingold, E. M. Calendrical Calculations: The Ultimate Edition. Cambridge University Press, 2018.