勤続年数（◯年◯か月◯日）

<?php
declare(strict_types=1);

/**
 * 勤続年数（◯年◯か月◯日）。
 * v2: 入社日に k か月を足し（行き先の月に同じ日がなければ末日にする）、基準日を超えない最大の k を数える。
 * DateTime::diff の「年・月・日」は月末の数え方が違うので使わず、日数（->days）だけを使う。
 * 存在しない日付は checkdate() で invalid_date にする（new DateTimeImmutable('2025-02-30') は 3月2日に繰り越すため）。
 */
function parseYmd(string $s): ?array
{
    if (!preg_match('/^(\d{4})-(\d{2})-(\d{2})$/', $s, $m) || !checkdate((int) $m[2], (int) $m[3], (int) $m[1])) {
        return null;
    }
    return [(int) $m[1], (int) $m[2], (int) $m[3]];
}

function addMonths(array $ymd, int $k): DateTimeImmutable
{
    [$y, $m, $d] = $ymd;
    $t = $y * 12 + ($m - 1) + $k;
    $ty = intdiv($t, 12);
    $tm = $t % 12 + 1;
    $last = (int) (new DateTimeImmutable(sprintf('%04d-%02d-01', $ty, $tm)))->format('t');
    return new DateTimeImmutable(sprintf('%04d-%02d-%02d', $ty, $tm, min($d, $last)));
}

/** @return array<string, int|string> */
function calcService(string $join, string $base): array
{
    $j = parseYmd($join);
    $b = parseYmd($base);
    if ($j === null || $b === null) {
        return ['error' => 'invalid_date'];
    }
    $jd = new DateTimeImmutable($join);
    $bd = new DateTimeImmutable($base);
    if ($bd < $jd) {
        return ['error' => 'base_before_join'];
    }
    $k = ($b[0] - $j[0]) * 12 + ($b[1] - $j[1]);
    while ($k > 0 && addMonths($j, $k) > $bd) {
        $k--;
    }
    return ['years' => intdiv($k, 12), 'months' => $k % 12, 'days' => addMonths($j, $k)->diff($bd)->days,
        'total_months' => $k, 'total_days' => $jd->diff($bd)->days];
}

<?php
declare(strict_types=1);

/**
 * 勤続年数（◯年◯か月◯日）。
 * v1: よくある書き方（DateTimeImmutable::diff に任せる）。
 * @return array<string, int|string>
 */
function calcService(string $join, string $base): array
{
    $j = new DateTimeImmutable($join);
    $b = new DateTimeImmutable($base);
    if ($b < $j) {
        return ['error' => 'base_before_join'];
    }
    $d = $j->diff($b);
    return ['years' => $d->y, 'months' => $d->m, 'days' => $d->d, 'total_months' => $d->y * 12 + $d->m, 'total_days' => $d->days];
}

"""勤続年数（◯年◯か月◯日）。

v2: 入社日に k か月を足し（行き先の月に同じ日がなければ末日にする）、基準日を超えない最大の k を数える。
「前の月の日数を借りる」書き方は月末で日数がマイナスになるので使わない。存在しない日付は invalid_date。
"""
import calendar
from datetime import date


def add_months(d: date, k: int) -> date:
    t = d.year * 12 + (d.month - 1) + k
    y, m0 = divmod(t, 12)
    return date(y, m0 + 1, min(d.day, calendar.monthrange(y, m0 + 1)[1]))


def calc_service(join: str, base: str) -> dict:
    try:
        j, b = date.fromisoformat(join), date.fromisoformat(base)
    except ValueError:
        return {"error": "invalid_date"}
    if b < j:
        return {"error": "base_before_join"}
    k = (b.year - j.year) * 12 + (b.month - j.month)
    while k > 0 and add_months(j, k) > b:
        k -= 1
    return {"years": k // 12, "months": k % 12, "days": (b - add_months(j, k)).days,
            "total_months": k, "total_days": (b - j).days}

"""勤続年数（◯年◯か月◯日）。

v1: よくある書き方（年・月・日をそれぞれ引き、日がマイナスなら前の月の日数を借りる）。
"""
import calendar
from datetime import date


def calc_service(join: str, base: str) -> dict:
    j = date.fromisoformat(join)
    b = date.fromisoformat(base)
    if b < j:
        return {"error": "base_before_join"}
    years, months, days = b.year - j.year, b.month - j.month, b.day - j.day
    if days < 0:
        months -= 1
        py, pm = (b.year, b.month - 1) if b.month > 1 else (b.year - 1, 12)
        days += calendar.monthrange(py, pm)[1]  # 前の月の日数を借りる
    if months < 0:
        years -= 1
        months += 12
    return {"years": years, "months": months, "days": days, "total_months": years * 12 + months, "total_days": (b - j).days}

package main

import "time"

// v2: 入社日に k か月を足し（行き先の月に同じ日がなければ末日にする）、基準日を超えない最大の k を数える。
// time.AddDate は 1月31日 + 1か月 を 3月3日に繰り越すので使わず、末日にそろえる処理を書く。
// 存在しない日付は time.Parse がエラーにするので invalid_date として返す。
func addMonths(t time.Time, k int) time.Time {
	idx := t.Year()*12 + int(t.Month()) - 1 + k
	y, m := idx/12, time.Month(idx%12+1)
	last := time.Date(y, m+1, 0, 0, 0, 0, 0, time.UTC).Day()
	return time.Date(y, m, min(t.Day(), last), 0, 0, 0, 0, time.UTC)
}

func daysBetween(a, b time.Time) int { return int(b.Sub(a).Hours()) / 24 } // どちらも UTC の 0:00 なので割り切れる

// CalcService は勤続年数を求める。
func CalcService(join, base string) (map[string]any, error) {
	j, err1 := time.Parse("2006-01-02", join)
	b, err2 := time.Parse("2006-01-02", base)
	if err1 != nil || err2 != nil {
		return map[string]any{"error": "invalid_date"}, nil
	}
	if b.Before(j) {
		return map[string]any{"error": "base_before_join"}, nil
	}
	k := (b.Year()-j.Year())*12 + int(b.Month()) - int(j.Month())
	for k > 0 && addMonths(j, k).After(b) {
		k--
	}
	return map[string]any{"years": k / 12, "months": k % 12, "days": daysBetween(addMonths(j, k), b),
		"total_months": k, "total_days": daysBetween(j, b)}, nil
}

package main

import "time"

// v1: よくある書き方（time.Parse で読み、年・月・日をそれぞれ引き、日がマイナスなら前の月の日数を借りる）。

// CalcService は勤続年数を求める。
func CalcService(join, base string) (map[string]any, error) {
	j, err := time.Parse("2006-01-02", join)
	if err != nil {
		return nil, err
	}
	b, err := time.Parse("2006-01-02", base)
	if err != nil {
		return nil, err
	}
	if b.Before(j) {
		return map[string]any{"error": "base_before_join"}, nil
	}
	years := b.Year() - j.Year()
	months := int(b.Month()) - int(j.Month())
	days := b.Day() - j.Day()
	if days < 0 {
		months--
		days += time.Date(b.Year(), b.Month(), 0, 0, 0, 0, 0, time.UTC).Day() // 前の月の日数を借りる
	}
	if months < 0 {
		years--
		months += 12
	}
	totalDays := int(b.Sub(j).Hours() / 24)
	return map[string]any{"years": years, "months": months, "days": days, "total_months": years*12 + months, "total_days": totalDays}, nil
}

// 勤続年数（◯年◯か月◯日）。
// v2: 入社日に k か月を足し（行き先の月に同じ日がなければ末日にする）、基準日を超えない最大の k を数える。
// 日数は Date.UTC で数える（タイムゾーンと夏時間の影響を受けない）。存在しない日付は invalid_date。

const DAY = 86400000;
const daysInMonth = (y, m) => new Date(Date.UTC(y, m, 0)).getUTCDate();

function parse(s) {
  const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(s);
  if (!m) return null;
  const [y, mo, d] = m.slice(1).map(Number);
  return mo >= 1 && mo <= 12 && d >= 1 && d <= daysInMonth(y, mo) ? { y, m: mo, d } : null;
}

function addMonths({ y, m, d }, k) {
  const t = y * 12 + (m - 1) + k;
  const ty = Math.floor(t / 12);
  const tm = (t % 12) + 1;
  return { y: ty, m: tm, d: Math.min(d, daysInMonth(ty, tm)) };
}

const serial = ({ y, m, d }) => Date.UTC(y, m - 1, d) / DAY; // 1970-01-01 からの日数（整数）

export function calcService({ join, base }) {
  const j = parse(join);
  const b = parse(base);
  if (!j || !b) return { error: "invalid_date" };
  if (serial(b) < serial(j)) return { error: "base_before_join" };
  let k = (b.y - j.y) * 12 + (b.m - j.m);
  while (k > 0 && serial(addMonths(j, k)) > serial(b)) k--;
  return {
    years: Math.floor(k / 12), months: k % 12, days: serial(b) - serial(addMonths(j, k)),
    total_months: k, total_days: serial(b) - serial(j),
  };
}

// 勤続年数（◯年◯か月◯日）。
// v1: よくある書き方（Date で読み、年・月・日をそれぞれ引き、日がマイナスなら前の月の日数を借りる）。

const toDate = (s) => {
  const [y, m, d] = s.split("-").map(Number);
  return new Date(y, m - 1, d);
};

export function calcService({ join, base }) {
  const j = toDate(join);
  const b = toDate(base);
  if (b < j) return { error: "base_before_join" };
  let years = b.getFullYear() - j.getFullYear();
  let months = b.getMonth() - j.getMonth();
  let days = b.getDate() - j.getDate();
  if (days < 0) {
    months -= 1;
    days += new Date(b.getFullYear(), b.getMonth(), 0).getDate(); // 前の月の日数を借りる
  }
  if (months < 0) {
    years -= 1;
    months += 12;
  }
  const totalDays = Math.floor((b - j) / (1000 * 60 * 60 * 24));
  return { years, months, days, total_months: years * 12 + months, total_days: totalDays };
}