Humanize a timestamp as "3 hours ago" snippet

function relativeTime(date, now = new Date()) {
  const rtf = new Intl.RelativeTimeFormat('en', { numeric: 'auto' });
  const UNITS = [
    ['year',   60 * 60 * 24 * 365],
    ['month',  60 * 60 * 24 * 30],
    ['day',    60 * 60 * 24],
    ['hour',   60 * 60],
    ['minute', 60],
    ['second', 1],
  ];
  const delta = (date.getTime() - now.getTime()) / 1000; // seconds, past is negative
  for (const [unit, secs] of UNITS) {
    if (Math.abs(delta) >= secs || unit === 'second') {
      return rtf.format(Math.round(delta / secs), unit);
    }
  }
}

relativeTime(new Date(Date.now() - 3 * 60 * 60 * 1000)); // '3 hours ago'

export function relativeTime(
  delta: number, // epoch milliseconds of the instant to describe
  now: Date = new Date(),
): string {
  const rtf = new Intl.RelativeTimeFormat('en', { numeric: 'auto' });
  const UNITS: ReadonlyArray<[Intl.RelativeTimeFormatUnit, number]> = [
    ['year', 31_536_000],
    ['month', 2_592_000],
    ['day', 86_400],
    ['hour', 3_600],
    ['minute', 60],
    ['second', 1],
  ];
  const secs = (delta - now.getTime()) / 1000;
  for (const [unit, size] of UNITS) {
    if (Math.abs(secs) >= size || unit === 'second') {
      return rtf.format(Math.round(secs / size), unit);
    }
  }
}

import (
	"fmt"
	"time"
)

// RelativeTime renders t as "3 hours ago" relative to now (same time zone!).
func RelativeTime(t, now time.Time) string {
	d := now.Sub(t) // time.Duration — int64 nanoseconds
	switch {
	case d < time.Minute:
		return fmt.Sprintf("%d seconds ago", int(d.Seconds()))
	case d < time.Hour:
		return fmt.Sprintf("%d minutes ago", int(d.Minutes()))
	case d < 24*time.Hour:
		return fmt.Sprintf("%d hours ago", int(d.Hours()))
	case d < 30*24*time.Hour:
		return fmt.Sprintf("%d days ago", int(d.Hours())/24)
	case d < 365*24*time.Hour:
		return fmt.Sprintf("%d months ago", int(d.Hours())/24/30)
	default:
		return fmt.Sprintf("%d years ago", int(d.Hours())/24/365)
	}
}

use chrono::{DateTime, Utc};

fn relative_time(t: DateTime<Utc>, now: DateTime<Utc>) -> String {
    // TimeDelta (now - t) flattened to whole seconds for the table
    let s = (now - t).num_seconds().max(0);
    match s {
        0..=44 => "a few seconds ago".into(),
        45..=89 => "a minute ago".into(),
        90..=2_699 => format!("{} minutes ago", (s + 30) / 60),
        2_700..=5_399 => "an hour ago".into(),
        5_400..=86_399 => format!("{} hours ago", (s + 1_800) / 3_600),
        86_400..=2_591_999 => format!("{} days ago", s / 86_400),
        2_592_000..=31_535_999 => format!("about {} months ago", s / 2_592_000),
        _ => format!("about {} years ago", s / 31_536_000),
    }
}

function relative_time(int $epochThen, ?int $now = null): string
{
    $now ??= time();
    $delta = $epochThen - $now;  // < 0 means the past
    $abs = abs($delta);         // threshold on the magnitude…

    foreach (
        [31536000 => 'year', 2592000 => 'month', 86400 => 'day',
         3600 => 'hour', 60 => 'minute', 1 => 'second'] as $size => $unit
    ) {
        if ($abs >= $size) {
            $n = intdiv($abs, $size);
            $phrase = $n === 1 ? "a $unit" : "$n {$unit}s";
            return $delta < 0 ? "$phrase ago" : "in $phrase"; // …sign re-attached here
        }
    }
}

from datetime import datetime, timezone

def relative_time(dt: datetime, now: datetime | None = None) -> str:
    now = now or datetime.now(timezone.utc)
    secs = (now - dt).total_seconds()  # aware − aware, same zone
    age = abs(secs)
    for unit, size in (('year', 31_536_000), ('month', 2_592_000),
                       ('day', 86_400), ('hour', 3_600),
                       ('minute', 60), ('second', 1)):
        if age >= size or unit == 'second':
            n = int(age // size)
            plural = '' if n == 1 else 's'
            return f'{n} {unit}{plural} ago' if secs > 0 else f'in {n} {unit}{plural}'

using System;

static string RelativeTime(DateTimeOffset then, DateTimeOffset now)
{
    TimeSpan d = now - then;             // positive = the past
    bool past = d >= TimeSpan.Zero;
    TimeSpan a = d.Duration();           // TimeSpan's abs()

    (int n, string unit) = a switch
    {
        _ when a >= TimeSpan.FromDays(365)  => (a.Days / 365, "year"),
        _ when a >= TimeSpan.FromDays(30)   => (a.Days / 30, "month"),
        _ when a >= TimeSpan.FromDays(1)    => (a.Days, "day"),
        _ when a >= TimeSpan.FromHours(1)   => (a.Hours, "hour"),
        _ when a >= TimeSpan.FromMinutes(1) => (a.Minutes, "minute"),
        _ => (a.Seconds, "second"),
    };

    string phrase = $"{n} {unit}{(n == 1 ? "" : "s")}";
    return past ? $"{phrase} ago" : $"in {phrase}";
}

import java.time.Duration;
import java.time.Instant;
import java.time.Period;
import java.time.ZoneOffset;

static String relativeTime(Instant then, Instant now) {
    long secs = Duration.between(then, now).abs().getSeconds();
    long n;
    String unit;
    if (secs < 60)           { n = secs;            unit = "second"; }
    else if (secs < 3600)    { n = secs / 60;       unit = "minute"; }
    else if (secs < 86400)   { n = secs / 3600;     unit = "hour";   }
    else if (secs < 2592000) { n = secs / 86400;    unit = "day";    }
    else {
        // Duration tops out at days — months/years are calendar math
        long months = Period.between(
                then.atZone(ZoneOffset.UTC).toLocalDate(),
                now.atZone(ZoneOffset.UTC).toLocalDate()).toTotalMonths();
        if (months < 12) return months + (months == 1 ? " month ago" : " months ago");
        long years = months / 12;
        return years + (years == 1 ? " year ago" : " years ago");
    }
    return n + " " + unit + (n == 1 ? " ago" : "s ago");
}

import Foundation

func relativeTime(_ date: Date, relativeTo now: Date = Date()) -> String {
    let formatter = RelativeDateTimeFormatter()
    formatter.unitsStyle = .abbreviated  // '3h ago'; .full → '3 hours ago'
    formatter.dateTimeStyle = .named     // 'yesterday' when it lands exactly
    formatter.locale = Locale(identifier: "en_US")
    return formatter.localizedString(for: date, relativeTo: now)
}

print(relativeTime(Date(timeIntervalSinceNow: -3 * 3600)))  // '3h ago'

import java.time.Duration
import java.time.Instant
import java.time.Period
import java.time.ZoneOffset

fun relativeTime(then: Instant, now: Instant = Instant.now()): String {
    val secs = Duration.between(then, now).abs().seconds
    val (n, unit) = when {
        secs < 60 -> secs to "second"
        secs < 3_600 -> secs / 60 to "minute"
        secs < 86_400 -> secs / 3_600 to "hour"
        secs < 2_592_000 -> secs / 86_400 to "day"
        else -> {
            // Duration has no months — that half lives in Period
            val months = Period.between(
                then.atZone(ZoneOffset.UTC).toLocalDate(),
                now.atZone(ZoneOffset.UTC).toLocalDate()
            ).toTotalMonths()
            if (months < 12) return "$months month${if (months == 1L) "" else "s"} ago"
            val years = months / 12
            return "$years year${if (years == 1L) "" else "s"} ago"
        }
    }
    return "$n $unit${if (n == 1L) "" else "s"} ago"
}

def relative_time(t, now = Time.now)
  secs = (now - t).to_i.abs   # Time#− is Float seconds — to_i it
  table = { 'year' => 31_536_000, 'month' => 2_592_000, 'day' => 86_400,
            'hour' => 3_600, 'minute' => 60 }
  unit, size = table.find { |_, s| secs >= s } || ['second', 1]
  n = secs / size
  phrase = "#{n} #{unit}#{'s' unless n == 1}"
  now < t ? "in #{phrase}" : "#{phrase} ago"
end

const std = @import("std");

/// `then` / `now` are epoch SECONDS (std.time.timestamp()).
fn relativeTime(buf: []u8, then: i64, now: i64) ![]u8 {
    const delta = now - then;
    const past = delta >= 0;
    const secs: u64 = @abs(delta);

    const Unit = struct { name: []const u8, size: u64 };
    const table = [_]Unit{
        .{ .name = "year", .size = 365 * 86400 }, // flat 365 — no calendar
        .{ .name = "month", .size = 30 * 86400 }, // flat 30 — 'about a month'
        .{ .name = "day", .size = 86400 },
        .{ .name = "hour", .size = 3600 },
        .{ .name = "minute", .size = 60 },
        .{ .name = "second", .size = 1 },
    };

    for (table) |u| {
        if (secs >= u.size) {
            const n = secs / u.size;
            const plural: []const u8 = if (n == 1) "" else "s";
            return if (past)
                std.fmt.bufPrint(buf, "{d} {s}{s} ago", .{ n, u.name, plural })
            else
                std.fmt.bufPrint(buf, "in {d} {s}{s}", .{ n, u.name, plural });
        }
    }
    return std.fmt.bufPrint(buf, "now", .{});
}