JavaScript: Date, 1–40

1
2
3
4
5
6
7
8
9
10
11
12
13
14// The month is ZERO-BASED. January is 0, December is 11.
const jan15 = new Date(2026, 0, 15);      // 15 January 2026, local midnight
const dec25 = new Date(2026, 11, 25);     // 25 December 2026

// A wrapper that takes the month the way a human writes it, 1 to 12.
function makeDate(year, humanMonth, day) {
  return new Date(year, humanMonth - 1, day);
}

console.log('parts of 15/01/2026 ->', jan15.getFullYear(), jan15.getMonth(), jan15.getDate());
console.log('as a string         ->', jan15.toDateString());

// The live clock, shown and never asserted: it is different every time you run.
console.log('right now           ->', new Date().toDateString());

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18// 9 March 2026 at 14:30:45.250, local.
const stamp = new Date(2026, 2, 9, 14, 30, 45, 250);

function fields(date) {
  return {
    year: date.getFullYear(),
    month: date.getMonth(),          // 0 to 11
    day: date.getDate(),             // 1 to 31, the day of the MONTH
    weekday: date.getDay(),          // 0 to 6, the day of the WEEK, 0 = Sunday
    hours: date.getHours(),
    minutes: date.getMinutes(),
    seconds: date.getSeconds(),
    ms: date.getMilliseconds(),
  };
}

console.log(fields(stamp));
console.log('the live clock, never asserted:', fields(new Date()).year);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15// getDay() returns 0 for Sunday, so index 0 must be Sunday.
const DAY_NAMES = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];

const dayName = (date) => DAY_NAMES[date.getDay()];
const shortDayName = (date) => dayName(date).slice(0, 3);   // derived, so it cannot drift

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

console.log('15/01/2026 ->', dayName(thursday), '/', shortDayName(thursday));
console.log('18/01/2026 ->', dayName(sunday), '/', shortDayName(sunday));

// The locale-aware version. Shown only: its output depends on the machine's
// language settings, so it is not something a test can pin down.
console.log('toLocaleDateString ->', thursday.toLocaleDateString(undefined, { weekday: 'long' }));

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

const monthName = (date) => MONTH_NAMES[date.getMonth()];
const shortMonthName = (date) => monthName(date).slice(0, 3);

// From a human 1-to-12 number. Out-of-range returns null rather than undefined,
// so a caller can tell "no such month" from "you forgot an argument".
function nameOfMonthNumber(humanMonth) {
  if (!Number.isInteger(humanMonth) || humanMonth < 1 || humanMonth > 12) return null;
  return MONTH_NAMES[humanMonth - 1];
}

console.log('15/01/2026 ->', monthName(new Date(2026, 0, 15)));
console.log('25/12/2026 ->', monthName(new Date(2026, 11, 25)));
console.log('month 1 by number ->', nameOfMonthNumber(1));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18const pad2 = (n) => String(n).padStart(2, '0');

// Local getters, so the answer is the date the reader would call today.
function toIsoDate(date) {
  return date.getFullYear() + '-' + pad2(date.getMonth() + 1) + '-' + pad2(date.getDate());
}

const fifth = new Date(2026, 0, 5);     // 5 January 2026

console.log('5 January 2026  ->', toIsoDate(fifth));
console.log('25 December     ->', toIsoDate(new Date(2026, 11, 25)));

// The shortcut, and why it is not the same thing. toISOString() converts to UTC
// first, so east of Greenwich a late evening comes back as the NEXT day and
// west of it an early morning comes back as the previous one.
const evening = new Date(2026, 0, 5, 23, 30);
console.log('local  :', toIsoDate(evening));
console.log('via UTC:', evening.toISOString().slice(0, 10), '<- may differ, depending on the zone');

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18const pad2 = (n) => String(n).padStart(2, '0');

function parts(date) {
  return {
    dd: pad2(date.getDate()),
    mm: pad2(date.getMonth() + 1),
    yyyy: String(date.getFullYear()),
  };
}

const dayFirst = (date) => { const p = parts(date); return p.dd + '/' + p.mm + '/' + p.yyyy; };
const monthFirst = (date) => { const p = parts(date); return p.mm + '/' + p.dd + '/' + p.yyyy; };

const fifthOfJanuary = new Date(2026, 0, 5);

console.log('5 January 2026, day first  :', dayFirst(fifthOfJanuary));
console.log('5 January 2026, month first:', monthFirst(fifthOfJanuary));
console.log('the same eight characters mean two different days');

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16const pad2 = (n) => String(n).padStart(2, '0');

function clock12(date) {
  const h24 = date.getHours();
  const suffix = h24 < 12 ? 'AM' : 'PM';        // 12:00 is PM, so < and not <=
  const h12 = h24 % 12 === 0 ? 12 : h24 % 12;   // 0 and 12 both display as 12
  return h12 + ':' + pad2(date.getMinutes()) + ' ' + suffix;
}

// Six times on one day, 15 January 2026.
const at = (h, m) => new Date(2026, 0, 15, h, m);

for (const [h, m] of [[0, 5], [9, 7], [12, 0], [12, 30], [13, 45], [23, 59]]) {
  console.log(pad2(h) + ':' + pad2(m), '->', clock12(at(h, m)));
}
console.log('right now:', clock12(new Date()));   // shown, not asserted

1
2
3
4
5
6
7
8
9
10
11// Day 0 of the NEXT month is the last day of THIS month. The constructor does
// the leap-year arithmetic, so there is no rule to get wrong here.
const daysInMonth = (year, month) => new Date(year, month + 1, 0).getDate();

// The lengths for a whole year, January first.
const yearLengths = (year) => Array.from({ length: 12 }, (unused, m) => daysInMonth(year, m));

console.log('February 2026:', daysInMonth(2026, 1));
console.log('February 2024:', daysInMonth(2024, 1), '<- leap year');
console.log('2026:', yearLengths(2026).join(' '));
console.log('day 0 of March 2026 is', new Date(2026, 2, 0).toDateString());

1
2
3
4
5
6
7
8const isLeapYear = (year) => (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;

// An independent check: if 29 February exists, the date does not roll into March.
const hasFeb29 = (year) => new Date(year, 1, 29).getDate() === 29;

for (const y of [1900, 2000, 2023, 2024, 2100, 2400]) {
  console.log(y, isLeapYear(y) ? 'leap' : 'common', '| 29 Feb exists:', hasFeb29(y));
}

1
2
3
4
5
6
7
8
9
10const daysInMonth = (year, month) => new Date(year, month + 1, 0).getDate();
const februaryDays = (year) => daysInMonth(year, 1);

// 29 February 2023 does not exist. The constructor does not complain.
const rolled = new Date(2023, 1, 29);
const real = new Date(2024, 1, 29);

console.log('February 2023:', februaryDays(2023), '| February 2024:', februaryDays(2024));
console.log('new Date(2023, 1, 29) ->', rolled.toDateString(), '<- March!');
console.log('new Date(2024, 1, 29) ->', real.toDateString());

1
2
3
4
5
6
7
8
9
10
11
12
13const MS_PER_DAY = 24 * 60 * 60 * 1000;
const isLeapYear = (year) => (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;

const daysInYear = (year) => (isLeapYear(year) ? 366 : 365);

// Measured instead of looked up. Date.UTC because in UTC every day is exactly
// 24 hours; a local year with a daylight-saving change is not, so the same
// division on local dates can come out as 364.958.
const measured = (year) => (Date.UTC(year + 1, 0, 1) - Date.UTC(year, 0, 1)) / MS_PER_DAY;

console.log('2026:', daysInYear(2026), '| measured:', measured(2026));
console.log('2024:', daysInYear(2024), '| measured:', measured(2024));
console.log('1900:', daysInYear(1900), '| 2000:', daysInYear(2000));

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 isWeekend = (date) => date.getDay() === 0 || date.getDay() === 6;

// Not universal: much of the Middle East treats Friday and Saturday as the
// weekend, so the days belong to the caller, not to the function.
const isWeekendWhere = (date, weekendDays) => weekendDays.includes(date.getDay());

function weekendDaysIn(year, month) {
  const last = new Date(year, month + 1, 0).getDate();
  let count = 0;
  for (let day = 1; day <= last; day++) {
    if (isWeekend(new Date(year, month, day))) count++;
  }
  return count;
}

// 16 to 19 January 2026: Friday, Saturday, Sunday, Monday.
const friday = new Date(2026, 0, 16);
const saturday = new Date(2026, 0, 17);
const sunday = new Date(2026, 0, 18);
const monday = new Date(2026, 0, 19);

for (const d of [friday, saturday, sunday, monday]) {
  console.log(d.toDateString(), '-> weekend:', isWeekend(d));
}
console.log('weekend days in January 2026:', weekendDaysIn(2026, 0));

1
2
3
4
5
6
7
8
9
10
11
12
13
14const isValidDate = (value) =>
  value instanceof Date && !Number.isNaN(value.getTime());

const bad = new Date('not a date');
const good = new Date(2026, 0, 15);

console.log('bad  ->', String(bad), '| valid:', isValidDate(bad));
console.log('good ->', good.toDateString(), '| valid:', isValidDate(good));
console.log('typeof bad:', typeof bad, '| instanceof Date:', bad instanceof Date);
console.log('new Date(undefined) valid?', isValidDate(new Date(undefined)));

// Out-of-range days in a string are NOT reliable ground: engines disagree about
// whether '2026-02-30' is invalid or is rolled into 2 March. Shown, not asserted.
console.log("new Date('2026-02-30') ->", String(new Date('2026-02-30')));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18const sample = new Date(2026, 0, 15);

// getYear is Annex B: kept alive only so old pages keep working. Guarded so
// this runs anywhere.
const legacyYear = typeof sample.getYear === 'function' ? sample.getYear() : 'not implemented';

// The same 1900 offset lives in the constructor: a year of 0 to 99 means 1900+y.
const ninetyNine = new Date(99, 0, 1);
const twentySix = new Date(26, 0, 1);

// To mean the actual year 26, set it explicitly.
const yearTwentySix = new Date(2026, 0, 1);
yearTwentySix.setFullYear(26);

console.log('getFullYear:', sample.getFullYear(), '| getYear:', legacyYear);
console.log('new Date(99, 0, 1)  ->', ninetyNine.getFullYear());
console.log('new Date(26, 0, 1)  ->', twentySix.getFullYear());
console.log('setFullYear(26)     ->', yearTwentySix.getFullYear());

1
2
3
4
5
6
7
8
9
10
11
12const MS_PER_DAY = 86400000;

const epoch = new Date(0);
const dayAfter = new Date(MS_PER_DAY);
const dayBefore = new Date(-MS_PER_DAY);

// A timestamp is an INSTANT, not a calendar date. toISOString shows it in UTC,
// which is the only reading that is the same everywhere.
console.log('0             ->', epoch.toISOString());
console.log('86400000      ->', dayAfter.toISOString());
console.log('-86400000     ->', dayBefore.toISOString());
console.log('local reading of 0:', epoch.getFullYear(), '<- 1969 west of Greenwich');

1
2
3
4
5
6
7
8
9
10
11
12// Date.UTC returns a timestamp, not a Date, so it has to be wrapped.
const stamp = Date.UTC(2026, 0, 15, 9, 30);      // month still zero-based
const utc = new Date(stamp);

// The offset is minutes of UTC minus local: -60 for a zone an hour ahead.
const offset = utc.getTimezoneOffset();
const utcMinutes = utc.getUTCHours() * 60 + utc.getUTCMinutes();
const localMinutes = utc.getHours() * 60 + utc.getMinutes();

console.log('ISO      :', utc.toISOString());
console.log('UTC parts:', utc.getUTCFullYear(), utc.getUTCMonth(), utc.getUTCDate(), utc.getUTCHours() + ':' + utc.getUTCMinutes());
console.log('this machine is', -offset, 'minutes from UTC, so locally it reads', utc.getHours() + ':' + utc.getMinutes());

1
2
3
4
5
6
7const parsed = new Date('2026-01-15');          // date only  -> UTC midnight
const withTime = new Date('2026-01-15T00:00:00'); // has a time -> LOCAL midnight

console.log('bare string   :', parsed.toISOString());
console.log('  UTC date    :', parsed.getUTCDate(), '<- always 15');
console.log('  local date  :', parsed.getDate(), '<- 15 here, 14 west of Greenwich');
console.log('with a time   :', withTime.getDate(), '<- always 15, in any zone');

1
2
3
4
5
6
7
8
9
10
11
12
13
14const bare = new Date('2026-01-15');            // ISO, date only -> UTC
const slashes = new Date('2026/01/15');         // legacy parser  -> local
const localIso = new Date('2026-01-15T00:00:00'); // ISO, no offset -> local
const zulu = new Date('2026-01-15T00:00:00Z');  // ISO with Z      -> UTC
const plusOne = new Date('2026-01-15T00:00:00+01:00');

// The gap between a local reading and a UTC reading IS the zone offset.
const offset = slashes.getTimezoneOffset();

console.log('bare     :', bare.toISOString());
console.log('slashes  :', slashes.toISOString(), '<- moves with the machine zone');
console.log('localIso :', localIso.toISOString(), '<- same as slashes');
console.log('zulu     :', zulu.toISOString());
console.log('+01:00   :', plusOne.toISOString());

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

const monthTwelve = new Date(2026, 12, 1);     // the 13th month of 2026
const monthMinusOne = new Date(2026, -1, 1);   // the month before January
const dayThirtyTwo = new Date(2026, 0, 32);    // 32 January
const dayZero = new Date(2026, 0, 0);          // the day before 1 January

console.log('new Date(2026, 12, 1) ->', iso(monthTwelve));
console.log('new Date(2026, -1, 1) ->', iso(monthMinusOne));
console.log('new Date(2026, 0, 32) ->', iso(dayThirtyTwo));
console.log('new Date(2026, 0, 0)  ->', iso(dayZero));
console.log('new Date(2026, 0, 15, 25) ->', iso(new Date(2026, 0, 15, 25)), 'at hour', new Date(2026, 0, 15, 25).getHours());

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20const d = new Date(2026, 0, 31);            // 31 January 2026
const returned = d.setDate(d.getDate() + 1); // asked for the 32nd

// Chaining reads well and does not work: the setter handed back a number.
let chainError = '';
try {
  const other = new Date(2026, 0, 31);
  other.setDate(1).getFullYear();
} catch (err) {
  chainError = err.constructor.name;
}

// setDate(0) steps back to the last day of the previous month.
const backwards = new Date(2026, 2, 15);     // 15 March 2026
backwards.setDate(0);

console.log('returned:', returned, typeof returned);
console.log('the object itself moved to', d.toDateString());
console.log('chaining threw a', chainError);
console.log('setDate(0) from 15 March ->', backwards.toDateString());

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16// A real copy. Mutating it leaves the source alone.
const start = new Date(2026, 0, 15);
const copy = new Date(start);
copy.setDate(20);

// Not a copy: one object with two names.
const shared = new Date(2026, 0, 15);
const alias = shared;
alias.setDate(20);          // this moves `shared` as well

const viaTimestamp = new Date(start.getTime());
const twin = new Date(start);   // built and left alone

console.log('start :', start.toDateString(), '<- untouched');
console.log('copy  :', copy.toDateString());
console.log('shared:', shared.toDateString(), '<- moved by the alias');

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

function addDays(date, days) {
  const copy = new Date(date);
  copy.setDate(copy.getDate() + days);   // out-of-range days roll into the next month
  return copy;
}

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

console.log('31/01/2026 + 1 ->', iso(addDays(endOfJanuary, 1)));
console.log('31/12/2026 + 1 ->', iso(addDays(new Date(2026, 11, 31), 1)));
console.log('01/01/2026 - 1 ->', iso(addDays(new Date(2026, 0, 1), -1)));
console.log('the input is still', iso(endOfJanuary));

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

function addDays(date, days) {
  const copy = new Date(date);
  copy.setDate(copy.getDate() + days);
  return copy;
}

const addWeeks = (date, weeks) => addDays(date, weeks * 7);

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

console.log('+1 week  ->', iso(addWeeks(thursday, 1)));
console.log('-2 weeks ->', iso(addWeeks(thursday, -2)));
console.log('+52 weeks->', iso(addWeeks(new Date(2026, 0, 1), 52)), '<- still 2026');

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 daysInMonth = (year, month) => new Date(year, month + 1, 0).getDate();

// The obvious version. 31 January + 1 month asks for 31 February.
function naiveAddMonths(date, months) {
  const copy = new Date(date);
  copy.setMonth(copy.getMonth() + months);
  return copy;
}

function addMonths(date, months) {
  const day = date.getDate();
  const copy = new Date(date);
  copy.setDate(1);                                 // a day every month has
  copy.setMonth(copy.getMonth() + months);
  copy.setDate(Math.min(day, daysInMonth(copy.getFullYear(), copy.getMonth())));
  return copy;
}

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

console.log('naive  31/01/2026 + 1 month ->', iso(naiveAddMonths(endOfJanuary, 1)), '<- March');
console.log('clamped 31/01/2026 + 1 month ->', iso(addMonths(endOfJanuary, 1)));
console.log('clamped 31/01/2024 + 1 month ->', iso(addMonths(new Date(2024, 0, 31), 1)), '<- leap year');

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
26const 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 naiveAddYears(date, years) {
  const copy = new Date(date);
  copy.setFullYear(copy.getFullYear() + years);
  return copy;
}

function addYears(date, years) {
  const day = date.getDate();
  const copy = new Date(date);
  copy.setDate(1);
  copy.setFullYear(date.getFullYear() + years);
  copy.setDate(Math.min(day, daysInMonth(copy.getFullYear(), copy.getMonth())));
  return copy;
}

const leapDay = new Date(2024, 1, 29);   // 29 February 2024

console.log('naive   29/02/2024 + 1 year ->', iso(naiveAddYears(leapDay, 1)), '<- March');
console.log('clamped 29/02/2024 + 1 year ->', iso(addYears(leapDay, 1)));
console.log('clamped 29/02/2024 + 4 years->', iso(addYears(leapDay, 4)), '<- fits again');

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

// Take the local calendar date and re-express it as UTC midnight. UTC has no
// daylight saving, so the subtraction below is an exact number of days.
const utcDay = (date) => Date.UTC(date.getFullYear(), date.getMonth(), date.getDate());

const daysBetween = (from, to) => (utcDay(to) - utcDay(from)) / MS_PER_DAY;

// What happens if you subtract the raw instants instead.
const lateEvening = new Date(2026, 0, 1, 23, 59);
const nextMorning = new Date(2026, 0, 2, 0, 1);
const rawFloor = Math.floor((nextMorning - lateEvening) / MS_PER_DAY);

console.log('01/01/2026 to 31/01/2026 :', daysBetween(new Date(2026, 0, 1), new Date(2026, 0, 31)));
console.log('31/01/2026 to 01/03/2026 :', daysBetween(new Date(2026, 0, 31), new Date(2026, 2, 1)));
console.log('two minutes apart, over midnight: dates', daysBetween(lateEvening, nextMorning), 'vs raw floor', rawFloor);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17function ageOn(birth, on) {
  let age = on.getFullYear() - birth.getFullYear();

  const birthdayStillToCome =
    on.getMonth() < birth.getMonth() ||
    (on.getMonth() === birth.getMonth() && on.getDate() < birth.getDate());

  if (birthdayStillToCome) age--;
  return age;
}

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

console.log('on 15/01/2026:', ageOn(birth, new Date(2026, 0, 15)));
console.log('on 14/06/2026:', ageOn(birth, new Date(2026, 5, 14)), '<- day before the birthday');
console.log('on 15/06/2026:', ageOn(birth, new Date(2026, 5, 15)), '<- on the day');
console.log('today        :', ageOn(birth, new Date()), '<- shown, never asserted');

1
2
3
4
5
6
7
8
9
10
11
12
13function monthsBetween(from, to) {
  if (to < from) return -monthsBetween(to, from);   // symmetric, so the sign is honest

  let months = (to.getFullYear() - from.getFullYear()) * 12 + (to.getMonth() - from.getMonth());
  if (to.getDate() < from.getDate()) months--;      // the day of the month has not come round
  return months;
}

const jan15 = new Date(2026, 0, 15);

console.log('15/01 to 15/03:', monthsBetween(jan15, new Date(2026, 2, 15)));
console.log('15/01 to 14/03:', monthsBetween(jan15, new Date(2026, 2, 14)), '<- a day short');
console.log('31/01 to 28/02:', monthsBetween(new Date(2026, 0, 31), new Date(2026, 1, 28)), '<- debatable');

1
2
3
4
5
6
7
8const a = new Date(2026, 0, 15);
const b = new Date(2026, 0, 15);      // same instant, different object
const later = new Date(2026, 0, 16);

console.log('a === b  :', a === b, '<- object identity');
console.log('a <= b   :', a <= b, ' a >= b:', a >= b, '<- numeric comparison');
console.log('a < later:', a < later);
console.log('b - a    :', b - a, 'ms');

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');

const dates = [new Date(2026, 2, 1), new Date(2026, 0, 15), new Date(2026, 1, 20)];

// slice() first: sort mutates the array it is given.
const oldestFirst = dates.slice().sort((x, y) => x - y);
const newestFirst = dates.slice().sort((x, y) => y - x);
const noComparator = dates.slice().sort();

console.log('as given    :', dates.map(iso).join(' '));
console.log('oldest first:', oldestFirst.map(iso).join(' '));
console.log('no comparator:', noComparator.map(iso).join(' '), '<- alphabetical');
console.log('why:', dates.map((d) => String(d).slice(0, 3)).join(' '), '-> Fri, Sun, Thu sorts F, S, T');

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

const dates = [new Date(2026, 2, 1), new Date(2026, 0, 15), new Date(2026, 1, 20)];

// Math.min converts each date to a number, so spreading dates straight in works.
const earliest = new Date(Math.min(...dates));
const latest = new Date(Math.max(...dates));

// The empty case, guarded. Without the guard you get Infinity, and
// new Date(Infinity) is an Invalid Date that then spreads silently.
const earliestOf = (list) => (list.length === 0 ? null : new Date(Math.min(...list)));

console.log('earliest:', iso(earliest), '| latest:', iso(latest));
console.log('Math.min() with nothing ->', Math.min(), '-> new Date(Infinity) is', String(new Date(Math.min())));

1
2
3
4
5
6
7
8
9
10
11
12
13const isSameDay = (a, b) =>
  a.getFullYear() === b.getFullYear() &&
  a.getMonth() === b.getMonth() &&
  a.getDate() === b.getDate();

const morning = new Date(2026, 0, 15, 8, 0);
const evening = new Date(2026, 0, 15, 22, 30);
const justBeforeMidnight = new Date(2026, 0, 15, 23, 59, 59, 999);
const justAfterMidnight = new Date(2026, 0, 16, 0, 0, 30);

console.log('08:00 and 22:30 on the 15th:', isSameDay(morning, evening));
console.log('23:59:59.999 and 00:00:30  :', isSameDay(justBeforeMidnight, justAfterMidnight), '<- 31ms apart');
console.log('their timestamps differ by', justAfterMidnight - justBeforeMidnight, 'ms');

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20function startOfDay(date) {
  const copy = new Date(date);
  copy.setHours(0, 0, 0, 0);          // hours, minutes, seconds, milliseconds
  return copy;
}

function endOfDay(date) {
  const copy = new Date(date);
  copy.setHours(23, 59, 59, 999);
  return copy;
}

// 15 January 2026, mid-afternoon. A date with no clock change anywhere, which
// is what makes the length assertion below safe to write.
const afternoon = new Date(2026, 0, 15, 15, 42, 17, 88);

console.log('given :', afternoon.toString().slice(0, 24));
console.log('start :', startOfDay(afternoon).toString().slice(0, 24));
console.log('end   :', endOfDay(afternoon).toString().slice(0, 24));
console.log('the input is still', afternoon.getHours() + ':' + afternoon.getMinutes());

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');

function startOfWeek(date, firstDay) {
  const copy = new Date(date);
  copy.setHours(0, 0, 0, 0);
  const shift = (copy.getDay() - firstDay + 7) % 7;   // + 7 so it is never negative
  copy.setDate(copy.getDate() - shift);
  return copy;
}

function endOfWeek(date, firstDay) {
  const copy = startOfWeek(date, firstDay);
  copy.setDate(copy.getDate() + 6);                   // six, not seven
  return copy;
}

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

console.log('Thu 15/01, week from Sunday:', iso(startOfWeek(thursday, 0)), 'to', iso(endOfWeek(thursday, 0)));
console.log('Thu 15/01, week from Monday:', iso(startOfWeek(thursday, 1)), 'to', iso(endOfWeek(thursday, 1)));
console.log('Sun 18/01, week from Monday:', iso(startOfWeek(sunday, 1)), '<- last Monday, not today');

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

// Built from parts, so both come back at local midnight with no setHours call.
const startOfMonth = (date) => new Date(date.getFullYear(), date.getMonth(), 1);
const endOfMonth = (date) => new Date(date.getFullYear(), date.getMonth() + 1, 0);

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

console.log('January 2026 :', iso(startOfMonth(midJanuary)), 'to', iso(endOfMonth(midJanuary)));
console.log('February 2026:', iso(endOfMonth(new Date(2026, 1, 10))));
console.log('February 2024:', iso(endOfMonth(new Date(2024, 1, 10))), '<- leap year');
console.log('December 2026:', iso(endOfMonth(new Date(2026, 11, 5))));

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

const quarterOf = (date) => Math.floor(date.getMonth() / 3) + 1;

const startOfQuarter = (date) =>
  new Date(date.getFullYear(), (quarterOf(date) - 1) * 3, 1);

const endOfQuarter = (date) =>
  new Date(date.getFullYear(), quarterOf(date) * 3, 0);

const may = new Date(2026, 4, 15);      // 15 May 2026

console.log('15/05/2026 is in Q' + quarterOf(may));
console.log('that quarter runs', iso(startOfQuarter(may)), 'to', iso(endOfQuarter(may)));
console.log('every month:', Array.from({ length: 12 }, (unused, m) => quarterOf(new Date(2026, m, 1))).join(''));

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

function dayOfYear(date) {
  const firstOfJanuary = Date.UTC(date.getFullYear(), 0, 1);
  const thisDay = Date.UTC(date.getFullYear(), date.getMonth(), date.getDate());
  return (thisDay - firstOfJanuary) / MS_PER_DAY + 1;   // + 1 so 1 January is day 1
}

// The inverse, leaning on the constructor's overflow: day 60 of January is
// 1 March in a common year, which is exactly the date wanted.
const fromDayOfYear = (year, day) => new Date(year, 0, day);

const iso = (d) => d.getFullYear() + '-' +
  String(d.getMonth() + 1).padStart(2, '0') + '-' +
  String(d.getDate()).padStart(2, '0');

console.log('01/01/2026 ->', dayOfYear(new Date(2026, 0, 1)));
console.log('01/03/2026 ->', dayOfYear(new Date(2026, 2, 1)));
console.log('01/03/2024 ->', dayOfYear(new Date(2024, 2, 1)), '<- one more, 29 February is behind it');
console.log('day 60 of 2026 ->', iso(fromDayOfYear(2026, 60)));

1
2
3
4
5
6
7
8
9
10
11
12
13const toUnixSeconds = (date) => Math.floor(date.getTime() / 1000);
const fromUnixSeconds = (seconds) => new Date(seconds * 1000);

const instant = new Date(Date.UTC(2026, 0, 15));

// The mistake: a seconds value passed straight in.
const asSeconds = new Date(1000000000);          // read as milliseconds -> 1970
const asMilliseconds = new Date(1000000000 * 1000);

console.log('date -> seconds:', toUnixSeconds(instant));
console.log('seconds -> date:', fromUnixSeconds(1768435200).toISOString());
console.log('1000000000 as ms:', asSeconds.toISOString(), '<- eleven days after the epoch');
console.log('1000000000 as s :', asMilliseconds.toISOString(), '<- September 2001');

1
2
3
4
5
6
7
8
9
10
11
12const start = new Date(Date.UTC(2026, 0, 15));
const end = new Date(Date.UTC(2026, 0, 16));

const difference = end - start;      // number: - forces both sides to numbers
const joined = start + end;          // string: + prefers the string form

console.log('getTime  :', start.getTime());
console.log('valueOf  :', start.valueOf());
console.log('Number(d):', Number(start));
console.log('end - start:', difference, typeof difference);
console.log('start + end:', typeof joined, '<- two long date strings glued together');
console.log('JSON       :', JSON.stringify(start));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16const isWithin = (date, from, to) => date >= from && date <= to;
const isWithinHalfOpen = (date, from, to) => date >= from && date < to;

const endOfDay = (date) => {
  const copy = new Date(date);
  copy.setHours(23, 59, 59, 999);
  return copy;
};

const from = new Date(2026, 0, 1);
const to = new Date(2026, 0, 15);
const lateOnTheLastDay = new Date(2026, 0, 15, 23, 0);

console.log('01/01 to 15/01 contains 10/01 :', isWithin(new Date(2026, 0, 10), from, to));
console.log('...contains 15/01 at 23:00    :', isWithin(lateOnTheLastDay, from, to), '<- surprise');
console.log('...with the end pushed to 23:59:59.999:', isWithin(lateOnTheLastDay, from, endOfDay(to)));