Age Calculator in Perl: Calculate Age from Date of Birth

Building an age calculator in Perl is a practical way to explore date and time handling. Perl provides core Time::Piece objects for common calendar operations, while the widely used DateTime distribution provides richer calendar arithmetic, durations, parsing, and time-zone support.

This guide shows how to calculate completed age from a date of birth, use a fixed reference date, validate dates, calculate elapsed days, handle leap years and February 29, produce years-months-days results, parse ISO dates, and organize the logic into reusable Perl functions. The examples deliberately keep the date of birth as a calendar date rather than treating age as a fixed number of seconds.

Quick answer

For a simple completed-years calculation, compare the birth month and day with the reference month and day after subtracting the years:

sub age_in_years {
    my ($dob, $ref) = @_;

    my $age = $ref->year - $dob->year;
    $age-- if $ref->mon * 100 + $ref->mday
           < $dob->mon * 100 + $dob->mday;

    return $age;
}

Use Time::Piece for straightforward date objects, or DateTime when your application needs calendar-aware durations, month arithmetic, parsing, or explicit time-zone behavior. The latter’s documentation distinguishes calendar durations from absolute elapsed time because months and years do not have fixed lengths. citeturn10search1turn10search2

Table of contents

Why use Perl for an age calculator

Perl is well suited to small data-processing utilities, command-line scripts, web applications, and larger systems. For age calculation, the important distinction is between a calendar age and an elapsed-time measurement. A person who has a birthday today becomes one year older even though the number of seconds in a year varies.

Perl’s Time::Piece module provides object-oriented wrappers around local and GMT time and includes methods such as is_leap_year, month_last_day, add_days, add_months, and add_years. The separate DateTime ecosystem provides more extensive calendar arithmetic and duration objects. citeturn10search2turn10search0

Perl date and time options

Perl’s own documentation notes that date and time processing has many available modules and specifically points readers toward DateTime for comprehensive date and time representation. citeturn9search11turn9search8

Build a basic age calculator

With Time::Piece, parse the date strings into date objects and compare the birthday components. Keeping the reference date as an argument makes the function deterministic and easy to test.

use strict;
use warnings;
use Time::Piece;

sub age_in_years {
    my ($dob, $ref) = @_;

    die "DOB must not be after reference date
" if $dob > $ref;

    my $age = $ref->year - $dob->year;
    my $ref_md = $ref->mon * 100 + $ref->mday;
    my $dob_md = $dob->mon * 100 + $dob->mday;

    $age-- if $ref_md < $dob_md;
    return $age;
}

my $dob = Time::Piece->strptime("1990-05-17", "%Y-%m-%d");
my $ref = Time::Piece->strptime("2026-09-22", "%Y-%m-%d");

print age_in_years($dob, $ref), "
";

The example prints 36. If the reference date is before May 17 in 2026, the function returns 35 because the birthday has not occurred in that reference year.

Use today’s date

When the calculator should use the current local date, localtime can create a Time::Piece object. For a UTC-based application, use gmtime instead.

use Time::Piece;

my $today = localtime;
my $age = age_in_years($dob, $today);

print "Age: $age
";

Make the choice of local time or UTC part of the application’s specification. A user-facing birthday calculator normally cares about the calendar date in the user’s relevant locale, while a server-side policy may define its reference date in UTC.

Calculate age on a fixed reference date

A fixed reference date is especially useful for eligibility rules, historical reports, data migration, and automated tests. It prevents a test from changing simply because the system clock moved to the next day.

my $dob = Time::Piece->strptime("1990-12-10", "%Y-%m-%d");
my $reference = Time::Piece->strptime("2026-09-22", "%Y-%m-%d");

print age_in_years($dob, $reference), "
";  # 35

The reference date is September 22, while the birthday is December 10, so the completed age is 35. On December 10, the same person becomes 36 under the completed-years convention.

Validate the date of birth

Validation should happen before age calculation. With Time::Piece->strptime, malformed input can be rejected by the parser. You should also explicitly reject a DOB that is later than the reference date.

sub parse_date {
    my ($text) = @_;

    return eval {
        Time::Piece->strptime($text, "%Y-%m-%d");
    };
}

my $dob = parse_date("1990-05-17");
die "Invalid date
" unless $dob;
die "DOB is in the future
" if $dob > $reference;

In production code, distinguish invalid syntax, an impossible calendar date, and a future DOB when those cases need different API responses. Do not silently substitute another date when parsing fails.

Calculate elapsed days and weeks

Completed age is different from the number of days since birth. For elapsed-day calculations, Time::Piece supports epoch-based arithmetic, while DateTime offers calendar-aware duration methods. Choose based on whether you need a fixed elapsed-time measurement or a calendar duration.

my $dob = Time::Piece->strptime("2020-01-01", "%Y-%m-%d");
my $ref = Time::Piece->strptime("2020-01-31", "%Y-%m-%d");

my $days = int(($ref - $dob) / ONE_DAY);
my $weeks = int($days / 7);
my $remaining_days = $days % 7;

print "$days days = $weeks weeks and $remaining_days days
";

For applications where daylight-saving transitions or time zones matter, avoid assuming that every calendar day is exactly 86,400 elapsed seconds. If the requirement is specifically “calendar days between two dates,” a date-oriented API such as DateTime’s day-delta methods is clearer. citeturn10search1

Handle leap years and February 29

Leap years are a classic source of date-calculation bugs. Time::Piece exposes is_leap_year and month_last_day, so the application can ask the date object rather than reimplementing the calendar rule. citeturn10search2

my $date = Time::Piece->strptime("2024-02-29", "%Y-%m-%d");

print $date->is_leap_year ? "Leap year
" : "Common year
";
print $date->month_last_day, "
";  # 29

February 29 also exposes an important business-rule question: what happens to a February 29 birthday in a non-leap year? Some applications observe February 28 and others March 1. There is no universal application policy, so document the convention and test it explicitly.

Calculate years, months and days

For a calendar-aware years-months-days result, DateTime is convenient because subtracting two DateTime objects produces a DateTime::Duration. The duration can retain month and day components instead of pretending that every month has the same length. citeturn10search1turn10search0

use DateTime;

my $dob = DateTime->new(
    year => 1990, month => 5, day => 17,
    time_zone => 'floating'
);

my $ref = DateTime->new(
    year => 2026, month => 9, day => 22,
    time_zone => 'floating'
);

my $duration = $ref->subtract_datetime($dob);

my ($years, $months, $days) =
    $duration->in_units('years', 'months', 'days');

print "$years years, $months months, $days days
";

The exact interpretation of a DateTime duration depends on the units and calendar arithmetic involved. DateTime’s documentation explicitly warns that months cannot generally be converted into a fixed number of days or seconds. This is why a calendar duration is preferable when the desired answer is expressed as years, months, and days. citeturn10search0

Parse and format ISO dates

ISO-style YYYY-MM-DD input is a good choice for an age-calculator API because it avoids ambiguous month/day ordering. Time::Piece provides strptime for parsing formatted strings. citeturn10search2

my $date = Time::Piece->strptime(
    "1987-11-03",
    "%Y-%m-%d"
);

print $date->strftime("%Y-%m-%d"), "
";

Keep parsed values as date objects during calculations and format them only at the presentation boundary. That prevents display formatting from leaking into the calculation logic.

Time zones and date versus time

A date of birth normally identifies a calendar date rather than a precise instant. If the user enters May 17, the age calculation generally should not depend on the hour at which the record was created.

When exact instants matter, DateTime supports explicit time zones and conversion between them. Its documentation also describes a floating time zone for calculations where a time zone is intentionally irrelevant. citeturn10search1

For a web application, decide whether the reference date is based on the user’s local calendar, an account-specific time zone, or UTC. Then apply that policy consistently when turning the current clock into the reference date.

Build a reusable Perl module

A reusable module separates parsing, validation, and age calculation from the web form or command-line interface. Here is a compact version using DateTime.

package AgeCalculator;

use strict;
use warnings;
use DateTime;

sub age_in_years {
    my ($dob, $reference) = @_;

    die "DOB must not be in the future
"
        if DateTime->compare($dob, $reference) > 0;

    my $age = $reference->year - $dob->year;

    my $birthday = $dob->clone(
        year => $reference->year
    );

    $age-- if $birthday > $reference;

    return $age;
}

sub elapsed_days {
    my ($dob, $reference) = @_;

    my $duration = $reference->delta_days($dob);
    return $duration->in_units('days');
}

1;

Returning structured errors instead of throwing exceptions may be preferable in an API. The key design principle is the same: the calculation receives validated date objects and a clearly defined reference date.

Test the calculator

Use fixed dates in tests so the expected age never changes with the current day. Include a birthday that has already occurred, a birthday still ahead, an invalid input, a future DOB, a leap-year date, and month-end cases.

use Test::More;

is(
    age_in_years(
        Time::Piece->strptime("1990-05-17", "%Y-%m-%d"),
        Time::Piece->strptime("2026-09-22", "%Y-%m-%d")
    ),
    36,
    "birthday has occurred"
);

is(
    age_in_years(
        Time::Piece->strptime("1990-12-10", "%Y-%m-%d"),
        Time::Piece->strptime("2026-09-22", "%Y-%m-%d")
    ),
    35,
    "birthday has not occurred"
);

done_testing;

Boundary tests are more valuable than a single ordinary example. In particular, test the day immediately before a birthday, the birthday itself, February 28, February 29, March 1, and dates at the end of months with 30 or 31 days.

Common mistakes

Perl compared with other languages

For related implementations, see our guides for Erlang, Elixir, Rust, Go, Java, Python, and Julia.

Frequently asked questions

How do I calculate age in Perl?

Parse the DOB and reference date into date objects, subtract the years, and subtract one if the birthday has not occurred in the reference year. Validate that the DOB is not after the reference date.

Does Perl have a date module?

Yes. Time::Piece is part of the Perl ecosystem for object-oriented time handling, while DateTime is a widely used distribution for more comprehensive date and time representation. citeturn10search2turn10search1

How can I calculate years, months and days in Perl?

With DateTime, subtract the two DateTime objects and inspect the resulting DateTime::Duration in the desired calendar units. This avoids treating months as a fixed number of days. citeturn10search0

How do I handle February 29 birthdays?

Define a business rule for non-leap years, such as February 28 or March 1, and test it. Do not assume the application has a universal rule.

Can Perl calculate elapsed days between dates?

Yes. Time::Piece can be used for elapsed-time arithmetic, while DateTime provides calendar-specific day-delta methods. Choose the method according to whether you need elapsed time or calendar-day difference. citeturn10search1turn10search2

Should an age calculator use local time or UTC?

Use the time basis defined by the application. A user-facing calculator may use the user’s relevant local calendar, while a centralized service may define its reference date in UTC.

Perl date and time references

• Perl documentation — official Perl documentation and reference.
• Time::Piece documentation — parsing, calendar calculations, leap years, and date comparisons.
• DateTime documentation — calendar-aware arithmetic, durations, and time zones.
• DateTime::Duration documentation — calendar and clock duration behavior.

Image credits

The Perl Code Logo is from Wikimedia Commons and is licensed under CC BY-SA 4.0; attribution is to Chipthrasher. The Perl source-code image is from Wikimedia Commons and is licensed under CC BY-SA 3.0 and GFDL. Check the original Commons file pages for the applicable license terms and attribution requirements before reusing these images elsewhere. citeturn11search0turn9search10

Final takeaway

An age calculator in Perl becomes reliable when calendar age is kept separate from raw elapsed seconds. Use Time::Piece for straightforward date objects and calculations, or DateTime when the application needs richer calendar durations and time-zone behavior.

Validate the DOB, define the reference-date policy, handle February 29 explicitly, test birthday boundaries, and keep parsing separate from calculation. Those practices make the same logic suitable for a Perl script, API, web application, or scheduled data-processing job.