JavaScript: Date, 41–57

1
2
3
4
5
6
7
8
9
10
11
12
13// Inclusive ranges: two comparisons, derived by negating "they miss".
const overlaps = (aStart, aEnd, bStart, bEnd) => aStart <= bEnd && bStart <= aEnd;

// Half-open ranges, where touching does not count as overlapping.
const overlapsHalfOpen = (aStart, aEnd, bStart, bEnd) => aStart < bEnd && bStart < aEnd;

const d = (day) => new Date(2026, 0, day);      // January 2026, for brevity

// A 1-15, B 10-20, C 20-25, inside 5-8, touching 15-20.
console.log('1-15 vs 10-20:', overlaps(d(1), d(15), d(10), d(20)));
console.log('1-15 vs 20-25:', overlaps(d(1), d(15), d(20), d(25)));
console.log('1-15 vs 15-20:', overlaps(d(1), d(15), d(15), d(20)), '<- touching, inclusive');
console.log('1-15 vs 15-20:', overlapsHalfOpen(d(1), d(15), d(15), d(20)), '<- touching, half-open');

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15const iso = (d) => d.getFullYear() + '-' +
  String(d.getMonth() + 1).padStart(2, '0') + '-' +
  String(d.getDate()).padStart(2, '0');

// Always a fresh Date, so nothing the caller holds can be mutated through it.
function clampDate(date, min, max) {
  return new Date(Math.min(Math.max(date.getTime(), min.getTime()), max.getTime()));
}

const min = new Date(2026, 0, 10);
const max = new Date(2026, 0, 20);

console.log('15/01 clamped to 10-20:', iso(clampDate(new Date(2026, 0, 15), min, max)));
console.log('01/01 clamped to 10-20:', iso(clampDate(new Date(2026, 0, 1), min, max)), '<- pulled up');
console.log('31/01 clamped to 10-20:', iso(clampDate(new Date(2026, 0, 31), min, max)), '<- pulled down');

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31const SECOND = 1000;
const MINUTE = 60 * SECOND;
const HOUR = 60 * MINUTE;
const DAY = 24 * HOUR;

// Largest first, so the first match is the coarsest sensible unit.
const UNITS = [
  ['year', 31536000], ['month', 2592000], ['week', 604800],
  ['day', 86400], ['hour', 3600], ['minute', 60], ['second', 1],
];

function relativeTime(then, now) {
  const seconds = Math.round((now - then) / 1000);   // positive = in the past
  const size = Math.abs(seconds);
  if (size < 45) return 'just now';

  const [name, length] = UNITS.find((unit) => size >= unit[1]);
  const count = Math.floor(size / length);
  const label = count + ' ' + name + (count === 1 ? '' : 's');   // no "1 days"
  return seconds > 0 ? label + ' ago' : 'in ' + label;
}

// Offsets are built in milliseconds from one fixed instant, so this is the same
// in every time zone.
const now = new Date(2026, 0, 15, 12, 0, 0);
const off = (ms) => new Date(now.getTime() - ms);

console.log('3 days back   ->', relativeTime(off(3 * DAY), now));
console.log('1 day back    ->', relativeTime(off(DAY), now));
console.log('2 hours ahead ->', relativeTime(off(-2 * HOUR), now));
console.log('the live clock ->', relativeTime(off(90 * MINUTE), new Date(now.getTime())));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24const MONTH_NAMES = [
  'January', 'February', 'March', 'April', 'May', 'June',
  'July', 'August', 'September', 'October', 'November', 'December',
];

function ordinal(n) {
  const lastTwo = n % 100;
  if (lastTwo >= 11 && lastTwo <= 13) return n + 'th';   // eleventh, twelfth, thirteenth

  switch (n % 10) {
    case 1: return n + 'st';
    case 2: return n + 'nd';
    case 3: return n + 'rd';
    default: return n + 'th';
  }
}

const withOrdinal = (date) =>
  ordinal(date.getDate()) + ' ' + MONTH_NAMES[date.getMonth()] + ' ' + date.getFullYear();

console.log('1 to 5  :', [1, 2, 3, 4, 5].map(ordinal).join(' '));
console.log('11 to 13:', [11, 12, 13].map(ordinal).join(' '), '<- the exception');
console.log('21 to 23:', [21, 22, 23].map(ordinal).join(' '), '<- back to the pattern');
console.log('15/01/2026 ->', withOrdinal(new Date(2026, 0, 15)));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33const DAY_NAMES = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
const MONTH_NAMES = [
  'January', 'February', 'March', 'April', 'May', 'June',
  'July', 'August', 'September', 'October', 'November', 'December',
];

const pad2 = (n) => String(n).padStart(2, '0');

// Day first: "Thursday, 15 January 2026".
const longDate = (date) =>
  DAY_NAMES[date.getDay()] + ', ' + date.getDate() + ' ' +
  MONTH_NAMES[date.getMonth()] + ' ' + date.getFullYear();

const shortDate = (date) =>
  DAY_NAMES[date.getDay()].slice(0, 3) + ', ' + date.getDate() + ' ' +
  MONTH_NAMES[date.getMonth()].slice(0, 3) + ' ' + date.getFullYear();

function longDateTime(date) {
  const h24 = date.getHours();
  const h12 = h24 % 12 === 0 ? 12 : h24 % 12;
  const suffix = h24 < 12 ? 'AM' : 'PM';
  return longDate(date) + ' at ' + h12 + ':' + pad2(date.getMinutes()) + ' ' + suffix;
}

const afternoon = new Date(2026, 0, 15, 14, 30);

console.log(longDate(afternoon));
console.log(shortDate(afternoon));
console.log(longDateTime(afternoon));

// The built-in, which translates and reorders for the reader's locale. Shown
// only: on a machine set to fr-FR this prints "jeudi 15 janvier 2026".
console.log('toLocaleDateString:', afternoon.toLocaleDateString(undefined, { dateStyle: 'full' }));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42const MS_PER_DAY = 86400000;
const isWeekendDay = (weekday) => weekday === 0 || weekday === 6;

// Both ends re-expressed as UTC midnight, so every step below is exactly 24 hours.
const utcDay = (date) => Date.UTC(date.getFullYear(), date.getMonth(), date.getDate());

function workingDaysBetween(from, to) {
  const start = utcDay(from);
  const end = utcDay(to);
  if (end < start) return 0;                        // a backwards range spans nothing

  const span = (end - start) / MS_PER_DAY + 1;      // + 1 because both ends count
  let count = 0;
  for (let i = 0; i < span; i++) {
    if (!isWeekendDay(new Date(start + i * MS_PER_DAY).getUTCDay())) count++;
  }
  return count;
}

// The version that looks equivalent and is not: a local cursor compared against
// a local end date. Correct in a fixed-offset zone, one day short in Santiago or
// Havana, where the clocks change AT midnight and the cursor drifts to 01:00.
function localCursorVersion(from, to) {
  const last = new Date(to.getFullYear(), to.getMonth(), to.getDate());
  const cursor = new Date(from.getFullYear(), from.getMonth(), from.getDate());
  let count = 0;
  while (cursor <= last) {
    if (!isWeekendDay(cursor.getDay())) count++;
    cursor.setDate(cursor.getDate() + 1);
  }
  return count;
}

// January 2026: the 12th is a Monday, the 16th a Friday, the 17th a Saturday.
const monday = new Date(2026, 0, 12);
const friday = new Date(2026, 0, 16);

console.log('Mon 12 to Fri 16:', workingDaysBetween(monday, friday));
console.log('Mon 12 to Sun 18:', workingDaysBetween(monday, new Date(2026, 0, 18)));
console.log('all of January   :', workingDaysBetween(new Date(2026, 0, 1), new Date(2026, 0, 31)));
console.log('all of 2026, in UTC:', workingDaysBetween(new Date(2026, 0, 1), new Date(2026, 11, 31)));
console.log('all of 2026, local cursor:', localCursorVersion(new Date(2026, 0, 1), new Date(2026, 11, 31)), '<- 260 in America/Santiago');

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25const iso = (d) => d.getFullYear() + '-' +
  String(d.getMonth() + 1).padStart(2, '0') + '-' +
  String(d.getDate()).padStart(2, '0');

const isWeekend = (date) => date.getDay() === 0 || date.getDay() === 6;

function addBusinessDays(date, count) {
  const copy = new Date(date);
  const step = count < 0 ? -1 : 1;
  let remaining = Math.abs(count);

  while (remaining > 0) {
    copy.setDate(copy.getDate() + step);   // move first, then decide whether it counted
    if (!isWeekend(copy)) remaining--;
  }
  return copy;
}

// January 2026: Mon 12, Fri 16, Sat 17, Mon 19, Fri 23, Mon 26.
const friday = new Date(2026, 0, 16);

console.log('Fri 16 + 1 ->', iso(addBusinessDays(friday, 1)), '<- Monday');
console.log('Fri 16 + 5 ->', iso(addBusinessDays(friday, 5)), '<- the next Friday');
console.log('Sat 17 + 1 ->', iso(addBusinessDays(new Date(2026, 0, 17), 1)));
console.log('Mon 19 - 1 ->', iso(addBusinessDays(new Date(2026, 0, 19), -1)), '<- back to Friday');

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27const iso = (d) => d.getFullYear() + '-' +
  String(d.getMonth() + 1).padStart(2, '0') + '-' +
  String(d.getDate()).padStart(2, '0');

const justTheDate = (date) => new Date(date.getFullYear(), date.getMonth(), date.getDate());

// Strictly after: today never counts, so a matching weekday jumps a week.
function nextWeekday(from, weekday) {
  const copy = justTheDate(from);
  const gap = (weekday - copy.getDay() + 7) % 7 || 7;   // 0 becomes 7
  copy.setDate(copy.getDate() + gap);
  return copy;
}

// On or after: today counts if it matches.
function weekdayOnOrAfter(from, weekday) {
  const copy = justTheDate(from);
  copy.setDate(copy.getDate() + ((weekday - copy.getDay() + 7) % 7));
  return copy;
}

const thursday = new Date(2026, 0, 15);   // 15 January 2026

console.log('from Thu 15/01, next Monday  :', iso(nextWeekday(thursday, 1)));
console.log('from Thu 15/01, next Friday  :', iso(nextWeekday(thursday, 5)));
console.log('from Thu 15/01, next Thursday:', iso(nextWeekday(thursday, 4)), '<- a week on');
console.log('from Thu 15/01, Thursday on or after:', iso(weekdayOnOrAfter(thursday, 4)), '<- today');

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24const iso = (d) => d.getFullYear() + '-' +
  String(d.getMonth() + 1).padStart(2, '0') + '-' +
  String(d.getDate()).padStart(2, '0');

const daysInMonth = (year, month) => new Date(year, month + 1, 0).getDate();

function nthWeekdayOfMonth(year, month, weekday, n) {
  const firstOfMonth = new Date(year, month, 1);
  const firstMatch = 1 + ((weekday - firstOfMonth.getDay() + 7) % 7);
  const day = firstMatch + (n - 1) * 7;
  if (day > daysInMonth(year, month)) return null;      // there is no fifth one
  return new Date(year, month, day);
}

function lastWeekdayOfMonth(year, month, weekday) {
  const last = new Date(year, month + 1, 0);            // the last day of the month
  last.setDate(last.getDate() - ((last.getDay() - weekday + 7) % 7));
  return last;
}

console.log('third Thursday of January 2026:', iso(nthWeekdayOfMonth(2026, 0, 4, 3)));
console.log('first Monday   of January 2026:', iso(nthWeekdayOfMonth(2026, 0, 1, 1)));
console.log('fifth Monday   of January 2026:', nthWeekdayOfMonth(2026, 0, 1, 5), '<- there is not one');
console.log('last Friday    of January 2026:', iso(lastWeekdayOfMonth(2026, 0, 5)));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19const MS_PER_DAY = 86400000;

function isoWeek(date) {
  // Re-express the local calendar date as UTC, where every day is 24 hours.
  const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));

  const dayNumber = d.getUTCDay() || 7;              // Monday 1 ... Sunday 7
  d.setUTCDate(d.getUTCDate() + 4 - dayNumber);      // jump to this week's Thursday

  // That Thursday's year is the week-numbering year, by definition.
  const firstOfYear = Date.UTC(d.getUTCFullYear(), 0, 1);
  return Math.ceil(((d.getTime() - firstOfYear) / MS_PER_DAY + 1) / 7);
}

// 1 January 2026 is a Thursday, so week 1 of 2026 starts on Monday 29 December 2025.
console.log('29/12/2025 ->', isoWeek(new Date(2025, 11, 29)), '<- already week 1 of 2026');
console.log('28/12/2025 ->', isoWeek(new Date(2025, 11, 28)), '<- still week 52 of 2025');
console.log('15/01/2026 ->', isoWeek(new Date(2026, 0, 15)));
console.log('31/12/2026 ->', isoWeek(new Date(2026, 11, 31)), '<- 2026 has 53 weeks');

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24const MS_PER_DAY = 86400000;

function isoWeekParts(date) {
  const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
  const weekday = d.getUTCDay() || 7;                 // 1 Monday ... 7 Sunday

  d.setUTCDate(d.getUTCDate() + 4 - weekday);         // this week's Thursday
  const weekYear = d.getUTCFullYear();                // which owns the week

  const firstOfYear = Date.UTC(weekYear, 0, 1);
  const week = Math.ceil(((d.getTime() - firstOfYear) / MS_PER_DAY + 1) / 7);

  return { weekYear, week, weekday };
}

function isoWeekDate(date) {
  const p = isoWeekParts(date);
  return p.weekYear + '-W' + String(p.week).padStart(2, '0') + '-' + p.weekday;
}

console.log('15/01/2026 ->', isoWeekDate(new Date(2026, 0, 15)));
console.log('29/12/2025 ->', isoWeekDate(new Date(2025, 11, 29)), '<- a 2025 date in the 2026 week year');
console.log('01/01/2027 ->', isoWeekDate(new Date(2027, 0, 1)), '<- a 2027 date in the 2026 week year');
console.log('parts:', isoWeekParts(new Date(2026, 0, 15)));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22function ageParts(birth, on) {
  let years = on.getFullYear() - birth.getFullYear();
  let months = on.getMonth() - birth.getMonth();
  let days = on.getDate() - birth.getDate();

  if (days < 0) {
    months--;
    // Borrow from the month before `on`: day 0 of that month is its last day.
    days += new Date(on.getFullYear(), on.getMonth(), 0).getDate();
  }
  if (months < 0) {
    years--;
    months += 12;
  }
  return { years, months, days };
}

const birth = new Date(1990, 5, 15);      // 15 June 1990

console.log('15/06/1990 to 15/01/2026:', ageParts(birth, new Date(2026, 0, 15)));
console.log('20/06/1990 to 15/01/2026:', ageParts(new Date(1990, 5, 20), new Date(2026, 0, 15)));
console.log('today                   :', ageParts(birth, new Date()), '<- shown, never asserted');

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20const MS_PER_DAY = 86400000;

const noon = new Date(2026, 5, 15, 12, 0, 0);    // 15 June 2026, local midday

// Two different operations that people treat as the same one.
const byMilliseconds = new Date(noon.getTime() + MS_PER_DAY);

const byCalendar = new Date(noon);
byCalendar.setDate(byCalendar.getDate() + 1);

// A hundred calendar days on, still at midday whatever happens to the clocks.
const hundredDays = new Date(noon);
hundredDays.setDate(hundredDays.getDate() + 100);

const offsetChanged = byCalendar.getTimezoneOffset() !== noon.getTimezoneOffset();

console.log('start        :', noon.getHours() + ':00 on the', noon.getDate() + 'th');
console.log('+86400000ms  :', byMilliseconds.getHours() + ':00 on the', byMilliseconds.getDate() + 'th');
console.log('+1 calendar day:', byCalendar.getHours() + ':00 on the', byCalendar.getDate() + 'th');
console.log('did the offset change between them?', offsetChanged, '(false in a zone with no DST)');

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37const iso = (d) => d.getFullYear() + '-' +
  String(d.getMonth() + 1).padStart(2, '0') + '-' +
  String(d.getDate()).padStart(2, '0');

const daysInMonth = (year, month) => new Date(year, month + 1, 0).getDate();

// Anchored: the original day number is re-applied to each month, so a short
// February borrows nothing from March.
function monthlyAnchored(start, count) {
  const anchorDay = start.getDate();
  const out = [];
  for (let i = 0; i < count; i++) {
    const first = new Date(start.getFullYear(), start.getMonth() + i, 1);   // handles the year roll
    const year = first.getFullYear();
    const month = first.getMonth();
    out.push(new Date(year, month, Math.min(anchorDay, daysInMonth(year, month))));
  }
  return out;
}

// Chained: each step works from the previous RESULT, so the February clamp sticks.
function monthlyChained(start, count) {
  const out = [new Date(start)];
  while (out.length < count) {
    const previous = out[out.length - 1];
    const day = previous.getDate();
    const next = new Date(previous.getFullYear(), previous.getMonth() + 1, 1);
    next.setDate(Math.min(day, daysInMonth(next.getFullYear(), next.getMonth())));
    out.push(next);
  }
  return out;
}

const endOfJanuary = new Date(2026, 0, 31);

console.log('anchored:', monthlyAnchored(endOfJanuary, 4).map(iso).join(' '));
console.log('chained :', monthlyChained(endOfJanuary, 4).map(iso).join(' '), '<- stuck on the 28th');

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32// Date, optionally followed by T or a space and a time. Nothing else accepted.
const PATTERN = /^(\d{4})-(\d{2})-(\d{2})(?:[T ](\d{2}):(\d{2})(?::(\d{2}))?)?$/;

function parseLocalIso(text) {
  if (typeof text !== 'string') return null;
  const match = PATTERN.exec(text);
  if (!match) return null;

  const year = Number(match[1]);
  const month = Number(match[2]) - 1;
  const day = Number(match[3]);
  const hours = match[4] === undefined ? 0 : Number(match[4]);
  const minutes = match[5] === undefined ? 0 : Number(match[5]);
  const seconds = match[6] === undefined ? 0 : Number(match[6]);
  if (hours > 23 || minutes > 59 || seconds > 59) return null;

  const date = new Date(year, month, day, hours, minutes, seconds);

  // The constructor rolls impossible dates instead of refusing them, so read the
  // parts back: if they changed, the input was not a real date.
  if (date.getFullYear() !== year || date.getMonth() !== month || date.getDate() !== day) {
    return null;
  }
  return date;
}

const parsed = parseLocalIso('2026-01-15T09:30');

console.log("'2026-01-15'       ->", parseLocalIso('2026-01-15').toDateString());
console.log("'2026-01-15T09:30' ->", parsed.getHours() + ':' + parsed.getMinutes());
console.log("'2026-02-30'       ->", parseLocalIso('2026-02-30'), '<- refused');
console.log("'15/01/2026'       ->", parseLocalIso('15/01/2026'), '<- refused');

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15// month is 1-12 here, the way a form sends it.
function isRealDate(year, month, day) {
  if (![year, month, day].every(Number.isInteger)) return false;
  if (month < 1 || month > 12) return false;
  if (day < 1 || day > 31) return false;

  const date = new Date(year, month - 1, day);
  return date.getFullYear() === year
    && date.getMonth() === month - 1
    && date.getDate() === day;          // unchanged, so nothing was rolled
}

console.log('30/02/2026:', isRealDate(2026, 2, 30), '| new Date says', new Date(2026, 1, 30).toDateString());
console.log('29/02/2024:', isRealDate(2024, 2, 29));
console.log('31/04/2026:', isRealDate(2026, 4, 31), '| new Date says', new Date(2026, 3, 31).toDateString());

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27const daysInMonth = (year, month) => new Date(year, month + 1, 0).getDate();

function monthGrid(year, month, firstDayOfWeek) {
  const firstWeekday = new Date(year, month, 1).getDay();
  const lead = (firstWeekday - firstDayOfWeek + 7) % 7;      // blanks before the 1st

  const cells = [];
  for (let i = 0; i < lead; i++) cells.push(null);
  for (let day = 1; day <= daysInMonth(year, month); day++) cells.push(day);
  while (cells.length % 7 !== 0) cells.push(null);           // blanks after the last

  const weeks = [];
  for (let i = 0; i < cells.length; i += 7) weeks.push(cells.slice(i, i + 7));
  return weeks;
}

const january = monthGrid(2026, 0, 1);        // Monday-first
const januarySunday = monthGrid(2026, 0, 0);  // Sunday-first

const row = january.findIndex((week) => week.includes(15));
const column = january[row].indexOf(15);

console.log('January 2026, Monday first:');
for (const week of january) {
  console.log(week.map((d) => (d === null ? '  ' : String(d).padStart(2))).join(' '));
}
console.log('the 15th sits at row', row, 'column', column);