Mr笔记

Appearance

Date ​

[TOC]

索引 ​

静态方法：

  • Date.now()：()，用于获取当前时刻的 UTC 时间戳。
  • Date.parse()：(dateString)，用于解析日期字符串并返回对应的时间戳。
  • Date.UTC()：(时间组件)，用于根据 UTC 时区生成指定日期的时间戳（毫秒）。

方法：

构造函数：

  • new Date()：(timestamp? | dateString? | 时间组件?)，用于创建日期对象的核心构造函数，支持多种参数形式。

获取时间信息：

  • date.getTime()：()，用于获取日期对象对应的时间戳（毫秒）。
  • date.getFullYear()：()，用于获取日期对象在本地时区的年份值（四位数格式）。
  • date.getMonth()：()，用于获取日期对象在本地时区的月份值。月份索引从 0 开始计数（0 = 一月，11 = 十二月）。
  • date.getDate()：()，用于获取日期对象在本地时区的月份中的日期（即一个月中的第几天）。日期值从 1 开始计数（1 表示该月的第一天）。
  • date.getHours()：()，用于获取日期对象在本地时区的小时值（24小时制）。范围从 0 到 23（0 = 午夜，12 = 中午，23 = 晚上11点）。
  • date.getMinutes()：()，用于获取日期对象在本地时区的分钟值。范围从 0 到 59（0 = 整点，59 = 整点前一分钟）。
  • date.getSeconds()：()，用于获取日期对象在本地时区的秒值。范围从 0 到 59（0 = 整分，59 = 整分前一秒）。
  • date.getMilliseconds()：()，用于获取日期对象在本地时区的毫秒值。范围从 0 到 999（0 = 整秒，999 = 整秒前一毫秒）。

设置时间信息：

  • date.setTime()：(timestamp)，用于通过 Unix 时间戳精确设置日期对象的时间。这是最底层的日期设置方法，直接操作毫秒级时间值。
  • date.setFullYear()：(year,month?,day?)，用于设置日期对象的年份（本地时区），并可同时设置月份和日期。
  • date.setMonth()：(month,day?)，用于设置日期对象的月份（本地时区），并可同时设置日期（月份中的第几天）。
  • date.setDate()：(day)，用于设置日期对象的月份中的日期（本地时区）。
  • date.setHours()：(hours,minutes?,seconds?,ms?)，用于设置日期对象的小时值（基于本地时区），并可同时设置分钟、秒和毫秒。
  • date.setMinutes()：(minutes,seconds?,ms?)，用于设置日期对象的分钟值（基于本地时区），并可同时设置秒和毫秒值。
  • date.setSeconds()：(seconds,ms?)，用于设置日期对象的秒值（基于本地时区），并可同时设置毫秒值。
  • date.setMilliseconds()：(ms)，用于设置日期对象的毫秒值（基于本地时区）。这是最精细的时间设置方法。

Date ​

静态方法 ​

now()@ ​

Date.now()：()，用于获取当前时刻的 UTC 时间戳。

  • 返回：

  • timestamp：number，返回自 1970-01-01 00:00:00 UTC（Unix 纪元）以来经过的毫秒数。

核心特性：

  1. UTC 时间基准：

    返回值始终基于 UTC 时间（协调世界时），不受本地时区影响：

    js
    // 北京时间 UTC+8 的开发者执行：
Date.now(); // 返回的值与 UTC+0 时区开发者获取的值相同

  2. 对比 getTime()：

    对比 new Date().getTime() 更高效：

    js
    // 性能对比（约快 2-5 倍）
const t1 = Date.now();          // ✅ 直接获取时间戳
const t2 = new Date().getTime(); // ❌ 需要创建临时对象

  3. 单调递增保证：

    返回值是严格单调递增的，即使系统时间被手动修改：

    js
    // 示例：
const t1 = Date.now(); // 1720609200000
// 人为将系统时间调快 1 小时
const t2 = Date.now(); // 1720612800000 (仍大于 t1)

  4. 时间精度限制：

    受系统限制，浏览器中精度通常为 1ms，但某些环境（如 Web Worker）可能达到 5μs（微秒）。

  5. 不可用于高精度计时：

    对于纳秒级精度需求，使用 performance.now()【TODO】：

    js
    // 微秒级精度（浏览器环境）
const highResTime = performance.now();

  6. 与 new Date() 转换：

    可轻松转换为标准日期对象：

    js
    const timestamp = Date.now();
const dateObj = new Date(timestamp);

示例：

  1. ****：

    js

  2. ****：

    js

  3. ****：

    js

进阶扩展：

  1. ****：

    js

  2. ****：

    js

  3. ****：

    js

parse() ​

Date.parse()：(dateString)，用于解析日期字符串并返回对应的时间戳。

  • dateString：string，表示日期的字符串。

  • 返回：

  • timestamp：number|NaN，返回值：

    • number：自 1970-01-01 00:00:00 UTC 起的毫秒数。
    • NaN：如果字符串无法被解析为有效日期返回NaN。

核心特性：

  1. 支持的日期格式：

    1. ISO 8601 格式（推荐）：

      js
      "2024-01-01"
"2024-01-01T12:30:45"         // 本地时间
"2024-01-01T12:30:45Z"        // UTC 时间
"2024-01-01T12:30:45+08:00"   // 指定时区

    2. RFC 2822 格式：

      js
      "Mon, 01 Jan 2024 12:30:45 GMT"
"Mon, 01 Jan 2024 12:30:45 +0800"

    3. 非标准格式（浏览器兼容）：

      js
      "January 1, 2024"
"1/1/2024"
"Jan 1 2024 12:30:45"

  2. 时区处理规则：

    • 包含 Z（UTC）或时区偏移（如 +08:00）时 → 按指定时区解析
    • 无时区标识时 → 默认解析为 本地时区时间
    js
    // 北京时间 (UTC+8)
Date.parse("2024-01-01T00:00:00");       // → 本地时间 1704009600000 (UTC+8)
Date.parse("2024-01-01T00:00:00Z");      // → UTC 时间 1704038400000

  3. 日期组件要求：

    • 必须包含 年 和 月 组件
    • 日默认为 1，时间默认为 00:00:00
    js
    Date.parse("2024-01");          // 等效于 "2024-01-01T00:00:00"
Date.parse("2024");              // 无效！返回 NaN

  4. 严格模式限制：

    无效日期（如 2月30日）返回 NaN

    js
    Date.parse("2024-02-30");       // NaN（无效日期）

示例：

  1. 基础解析：

    js
    // ISO 8601 格式
Date.parse("2024-01-01");          // 1704038400000 (UTC)
Date.parse("2024-01-01T12:30:45"); // 本地时间解析

// RFC 2822 格式
Date.parse("Mon, 01 Jan 2024 12:30:45 GMT"); // 1704112245000

UTC() ​

Date.UTC()：(时间组件)，用于根据 UTC 时区生成指定日期的时间戳（毫秒）。

  • 时间组件：year,monthIndex,day?,hours?,minutes?,seconds?,milliseconds?，时间组件参数。
  • 返回：
  • imestamp：number|NaN，返回值：
    • number：自 1970-01-01 00:00:00 UTC 起的毫秒数。
    • NaN：如果参数无法转换为有效数值返回NaN。

核心特性：

  1. 纯 UTC 时间计算：

    所有参数均被解释为 UTC 时间，不受运行时区影响：

    js
    // 无论用户时区如何，结果相同
Date.UTC(2024, 0, 1); // 始终返回 1704067200000

  2. 对比 new Date()：

    • Date.UTC()：参数视为 UTC，返回时间戳。
    • new Date()：参数视为 本地时区，返回 Date 对象。
    js
    // 北京时间 UTC+8
Date.UTC(2024,0,1);          // 1704067200000 (UTC)
new Date(2024,0,1).getTime(); // 1704038400000 (UTC+8)

  3. 自动日期修正：

    支持自动计算无效日期：

    js
    // 2024年2月30日 → 自动转为3月1日
Date.UTC(2024, 2, 30); // 1709251200000 (2024-03-01 UTC)

  4. 参数类型转换：

    非数值参数会被强制转换：

    js
    Date.UTC("2024", "0"); // 有效 → 1704067200000
Date.UTC(null, 0);     // null→0 → 1970-01-01
Date.UTC(2024, "abc"); // NaN

示例：

  1. 基础用法：

    js
    // 2024年1月1日 00:00:00 UTC
Date.UTC(2024, 0); // 1704067200000

// 2024年7月4日 12:30:45.500 UTC
Date.UTC(2024, 6, 4, 12, 30, 45, 500); 

// 年份 0-99 → 1900-1999
Date.UTC(99, 0);   // 915148800000 (1999-01-01)

// 负数为公元前
Date.UTC(-1, 0);   // -62167219200000 (1 BC)

方法 ​

构造函数 ​

new Date()@ ​

new Date()：(timestamp? | dateString? | 时间组件?)，用于创建日期对象的核心构造函数，支持多种参数形式。

  • 无参数?：创建当前日期时间。

  • timestamp?：number，从 Unix 纪元计算的毫秒数。

  • dateString?：string，被解析的日期

  • 时间组件?：year,monthIndex,day,hours,minutes,seconds,milliseconds，时间组件参数。

  • 返回：

  • date：Date|Invalid Date，返回值：

    • Date：表示指定时间的日期对象。
    • Invalid Date：当参数无法解析时返回 Invalid Date。

语法：

js
// 四种调用方式
new Date();                     // 1. 无参数
new Date(timestamp);            // 2. 时间戳（毫秒）
new Date(dateString);           // 3. 日期字符串
new Date(year, monthIndex[, ...]); // 4. 时间组件参数

核心特性：

  1. 时区处理规则：

    • new Date()：本地时区
    • new Date(timestamp)：UTC（时间戳无时区概念）
    • new Date(dateString)：依赖字符串（无时区标识 → 本地时间）
    • new Date(year, monthIndex...：本地时区

  2. 对比 Date.UTC()：

    js
    // 北京时间 = UTC + 8
new Date(2024, 0, 1);          // 本地时间：2024-01-01T00:00:00+08:00
new Date(Date.UTC(2024, 0, 1)); // UTC 时间：2024-01-01T00:00:00Z

  3. 自动类型转换：

    非数值参数自动转换：

    js
    new Date("2024");       // 字符串 → 尝试解析
new Date(2024, "0");    // "0" → 0 (数字)
new Date(null);         // null → 0 (时间戳0)

  4. 月份陷阱：月份索引从 0 开始：

    js
    new Date(2024, 0, 1); // 2024年1月1日
new Date(2024, 11, 31); // 2024年12月31日

  5. 字符串解析格式差异：

    差异：

    • 美国: MM/DD/YYYY
    • 其他地区: DD/MM/YYYY
    js
    // 美国: MM/DD/YYYY | 其他地区: DD/MM/YYYY
new Date("01/02/2024"); // 可能解析为 1月2日 或 2月1日

    推荐：推荐始终使用 ISO 8601 格式：

    js
    new Date("2024-01-02"); // 明确 2024年1月2日

示例：

  1. 基础创建：

    js
    // 当前时间（本地时区）
const now = new Date(); 

// 指定时间戳（UTC）
const timestamp = 1704067200000;
const date1 = new Date(timestamp); // 2024-01-01T00:00:00.000Z

// 通过字符串
const date2 = new Date("2024-01-01T08:00:00+08:00"); 

// 通过时间组件（本地时区）
const date3 = new Date(2024, 0, 1, 12, 30); // 2024-01-01 12:30 (本地时间)

  2. 时区转换：

    • UTC 时间 → 本地时间字符串：utcDate.toLocaleString()

      js
      // UTC 时间 → 本地时间字符串
const utcDate = new Date("2024-01-01T00:00:00Z");
console.log(utcDate.toLocaleString()); // 北京时间: "2024/1/1 08:00:00"

    • 本地时间组件 → UTC 字符串：localDate.toISOString()

      js
      // 本地时间组件 → UTC 字符串
const localDate = new Date(2024, 0, 1);
console.log(localDate.toISOString()); // "2023-12-31T16:00:00.000Z" (UTC)

  3. 结合其他方法：

    js
    // 1. 转换为时间戳
const timestamp = new Date().getTime(); 

// 2. 转换为 ISO 字符串
const isoString = new Date().toISOString();

// 3. 获取本地时间字符串
const localString = new Date().toLocaleString("zh-CN", {
  year: 'numeric',
  month: '2-digit',
  day: '2-digit'
}); // "2024/01/01"

获取时间信息 ​

getTime()@ ​

date.getTime()：()，用于获取日期对象对应的时间戳（毫秒）。

  • 返回：
  • timestamp：number|NaN，返回值：
    • number：自 1970-01-01 00:00:00 UTC 到该日期时间的毫秒数。
    • NaN：如果日期对象无效，返回NaN。

核心特性：

  1. 时区无关性：

    返回值始终基于 UTC 时间，不受本地时区影响：

    js
    // 北京时间 2024-01-01 08:00:00 (UTC+8)
const date = new Date("2024-01-01T08:00:00+08:00");
date.getTime(); // 1704067200000 (等同于 UTC 时间 2024-01-01T00:00:00Z)

  2. 可直接参与数值运算：

    由于与 valueOf() 等价，所以会在数值运算中自动调用：

    js
    const date = new Date();
date.getTime() === date.valueOf(); // true

// 直接参与数值运算
const diff = new Date() - date; // 等价于 Date.now() - date.getTime()

示例：

  1. 基础用法：

    js
    const now = new Date();
console.log(now.getTime()); // 输出：1720609200000

const specificDate = new Date("2024-01-01T00:00:00Z");
console.log(specificDate.getTime()); // 1704067200000

  2. 倒计时实现：

    js
    function startCountdown(targetDate) {
  const timer = setInterval(() => {
    const now = Date.now();
    const diff = targetDate.getTime() - now;
    
    if (diff <= 0) {
      clearInterval(timer);
      console.log("时间到！");
      return;
    }
    
    const seconds = Math.floor(diff / 1000) % 60;
    const minutes = Math.floor(diff / 60000) % 60;
    console.log(`剩余时间：${minutes}分${seconds}秒`);
  }, 1000);
}

// 10分钟后触发
const target = new Date();
target.setMinutes(target.getMinutes() + 10);
startCountdown(target);
getFullYear()@ ​

date.getFullYear()：()，用于获取日期对象在本地时区的年份值（四位数格式）。

  • 返回：

  • year：number|NaN，返回四位数年份（本地时区）；如果日期对象无效返回NaN。

核心特性：

  1. 始终返回四位数年份：

    与已废弃的 getYear() 不同，不会返回两位数年份：

    js
    const date = new Date(1999, 0, 1);
date.getFullYear(); // 1999（四位数）
date.getYear();     // 99（已废弃方法）

  2. 基于本地时区：

    返回值取决于运行环境的时区设置：

    js
    // UTC 时间 2023-12-31T23:00:00Z
const date = new Date("2023-12-31T23:00:00Z");

// 北京时间 (UTC+8)
date.getFullYear(); // 2024（已过元旦）

// 纽约时间 (UTC-5)
// 同一时刻在纽约仍是 2023-12-31 18:00 → 返回 2023

  3. 支持公元前年份：

    返回负数表示公元前：

    js
    const bcDate = new Date("-000044-03-15"); // 公元前44年
bcDate.getFullYear(); // -44

示例：

  1. 基础用法：

    js
    const now = new Date();
console.log(now.getFullYear()); // 2025

const moonLanding = new Date(1969, 6, 20, 20, 18);
console.log(moonLanding.getFullYear()); // 1969

  2. 闰年判断：

    能被4整除且不能被100整除的年份是闰年。 能被100整除且能被400整除的年份是闰年。 能被100整除且不能被400整除的年份不是闰年。

    js
    function isLeapYear(year) {
  return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
}

const year = new Date().getFullYear();
console.log(`${year}年${isLeapYear(year) ? '是' : '不是'}闰年`);
getMonth()@ ​

date.getMonth()：()，用于获取日期对象在本地时区的月份值。月份索引从 0 开始计数（0 = 一月，11 = 十二月）。

  • 返回：

  • month：number|NaN，范围：0-11，月份索引（本地时区）；如果日期对象无效返回NaN。

核心特性：

  1. 月份索引从 0 开始：

    这是最常见的混淆点：

    js
    const julyDate = new Date(2024, 6, 1); // 2024年7月1日
julyDate.getMonth(); // 6（不是7）

  2. 基于本地时区：

    返回值取决于运行环境的时区设置：

    js
    // UTC 时间 2024-01-01T00:00:00Z
const date = new Date("2024-01-01T00:00:00Z");

// 北京时间 (UTC+8): 2024-01-01 08:00 → 0（一月）
// 纽约时间 (UTC-5): 2023-12-31 19:00 → 11（十二月）

  3. 自动日期修正不影响返回值：

    即使日期被自动修正，返回值仍反映设置时的月份：

    js
    const date = new Date(2024, 0, 32); // 2024年1月32日 → 自动修正为2月1日
date.getMonth(); // 1（二月）

示例：

  1. 基础用法：

    js
    const now = new Date();
console.log(now.getMonth()); // 6（如果当前是七月）

const christmas = new Date(2024, 11, 25); // 2024年12月25日
console.log(christmas.getMonth()); // 11
getDate()@ ​

date.getDate()：()，用于获取日期对象在本地时区的月份中的日期（即一个月中的第几天）。日期值从 1 开始计数（1 表示该月的第一天）。

  • 返回：

  • date：number|NaN，范围：1-31，月份中的日期（本地时区）；如果日期对象无效返回NaN。

核心特性：

  1. 日期从 1 开始计数：

    与 getMonth() 不同，日期值是实际日历日期：

    js
    const date = new Date(2024, 6, 1); // 2024年7月1日
date.getDate(); // 1（不是0）

  2. 基于本地时区：

    返回值取决于运行环境的时区设置：

    js
    // UTC 时间 2024-01-01T00:00:00Z
const date = new Date("2024-01-01T00:00:00Z");

// 北京时间 (UTC+8): 2024-01-01 08:00 → 1（1日）
// 纽约时间 (UTC-5): 2023-12-31 19:00 → 31（31日）

  3. 自动修正日期：

    即使创建时使用无效日期，返回值也会修正为有效日期：

    js
    // 2024年2月30日 → 自动修正为3月1日
const date = new Date(2024, 1, 30); // 2024年2月只有29天
date.getDate(); // 1（3月1日）

  4. 对比 getDay()：

    • getDate()：日期（1-31）
    • getDay()：星期几（0-6）

示例：

  1. 基础用法：

    js
    const now = new Date();
console.log(now.getDate()); // 10（如果今天是7月10日）

const christmas = new Date(2024, 11, 25); // 2024年12月25日
console.log(christmas.getDate()); // 25
getHours()@ ​

date.getHours()：()，用于获取日期对象在本地时区的小时值（24小时制）。范围从 0 到 23（0 = 午夜，12 = 中午，23 = 晚上11点）。

  • 返回：

  • hours：number|NaN，范围：0-23，返回小时值（本地时区）；如果日期对象无效返回NaN。

核心特性：

  1. 24小时制：

    返回值始终是0到23之间的整数，没有区分AM/PM：

    js
    const noon = new Date(2024, 0, 1, 12); // 2024年1月1日中午12点
noon.getHours(); // 12

const midnight = new Date(2024, 0, 1, 0); // 2024年1月1日午夜
midnight.getHours(); // 0

  2. 基于本地时区

    返回值取决于运行环境的时区设置：

    js
    // UTC 时间 2024-01-01T00:00:00Z
const date = new Date("2024-01-01T00:00:00Z");

// 北京时间 (UTC+8): 2024-01-01 08:00 → 8
// 伦敦时间 (UTC+0): 2024-01-01 00:00 → 0
// 纽约时间 (UTC-5): 2023-12-31 19:00 → 19

  3. 自动时间修正

    如果创建时使用超出范围的小时值，会自动调整日期：

    js
    // 25小时 → 自动调整为第二天1点
const date = new Date(2024, 0, 1, 25); // 2024年1月2日1点
date.getHours(); // 1

示例：

  1. 基础用法：

    js
    const now = new Date();
console.log(now.getHours()); // 返回当前小时（0-23）

const newYear = new Date(2024, 0, 1, 0, 0, 0); // 2024年1月1日午夜
console.log(newYear.getHours()); // 0
getMinutes()@ ​

date.getMinutes()：()，用于获取日期对象在本地时区的分钟值。范围从 0 到 59（0 = 整点，59 = 整点前一分钟）。

  • 返回：

  • minutes：number|NaN，范围：0-59，返回分钟值（本地时区）；如果日期对象无效返回NaN。

核心特性：

  1. 基于本地时区

    返回值取决于运行环境的时区设置：

    js
    // UTC 时间 2024-01-01T15:30:00Z
const date = new Date("2024-01-01T15:30:00Z");

// 北京时间 (UTC+8): 2024-01-01 23:30 → 30
// 纽约时间 (UTC-5): 2024-01-01 10:30 → 30

  2. 自动时间修正

    如果创建时使用超出范围的分钟值，会自动调整时间：

    js
    // 70分钟 → 自动调整为下一小时10分钟
const date = new Date(2024, 0, 1, 15, 70); // 2024年1月1日16:10
date.getMinutes(); // 10

示例：

  1. 基础用法：

    js
    const now = new Date();
console.log(now.getMinutes()); // 返回当前分钟（0-59）

const newYear = new Date(2024, 0, 1, 0, 5, 0); // 2024年1月1日00:05
console.log(newYear.getMinutes()); // 5

  2. 分钟值补零显示：

    单数分钟通常需要格式化为两位数：

    js
    const minutes = date.getMinutes();
const formatted = minutes.toString().padStart(2, '0'); // "05" 而不是 "5"
getSeconds()@ ​

date.getSeconds()：()，用于获取日期对象在本地时区的秒值。范围从 0 到 59（0 = 整分，59 = 整分前一秒）。

  • 返回：

  • seconds：number|NaN，范围：0-59，返回秒值（本地时区）；如果日期对象无效返回NaN。

核心特性：

  1. 基于本地时区：

    返回值取决于运行环境的时区设置，但秒值通常不受时区影响：

    js
    // UTC 时间 2024-01-01T15:30:45Z
const date = new Date("2024-01-01T15:30:45Z");

// 北京时间 (UTC+8): 2024-01-01 23:30:45 → 45
// 纽约时间 (UTC-5): 2024-01-01 10:30:45 → 45

  2. 自动时间修正：

    如果创建时使用超出范围的秒值，会自动调整时间：

    js
    // 75秒 → 自动调整为下一分15秒
const date = new Date(2024, 0, 1, 15, 45, 75); // 2024年1月1日15:46:15
date.getSeconds(); // 15

  3. 闰秒处理：

    JavaScript 不处理闰秒（61秒），会自动转换为下一分钟：

    js
    // 闰秒会被转换为下一分钟的0秒
const leapSecond = new Date(2023, 11, 31, 23, 59, 61); // 2024年1月1日00:00:01
leapSecond.getSeconds(); // 1

示例：

  1. 基础用法：

    js
    const now = new Date();
console.log(now.getSeconds()); // 返回当前秒（0-59）

const newYear = new Date(2024, 0, 1, 0, 0, 10); // 2024年1月1日00:00:10
console.log(newYear.getSeconds()); // 10

  2. 秒值补零显示：

    单数秒通常需要格式化为两位数：

    js
    const seconds = date.getSeconds();
const formatted = seconds.toString().padStart(2, '0'); // "05" 而不是 "5"
getMilliseconds() ​

date.getMilliseconds()：()，用于获取日期对象在本地时区的毫秒值。范围从 0 到 999（0 = 整秒，999 = 整秒前一毫秒）。

  • 返回：

  • milliSeconds：number|NaN，范围：0-999，返回毫秒值（本地时区）；如果日期对象无效返回NaN。

核心特性：

  1. 基于本地时区

    返回值取决于运行环境的时区设置，但毫秒值通常不受时区影响：

    js
    // UTC 时间 2024-01-01T15:30:45.250Z
const date = new Date("2024-01-01T15:30:45.250Z");

// 北京时间 (UTC+8): 2024-01-01 23:30:45.250 → 250
// 纽约时间 (UTC-5): 2024-01-01 10:30:45.250 → 250

  2. 自动时间修正

    如果创建时使用超出范围的毫秒值，会自动调整时间：

    js
    // 1500毫秒 → 自动调整为下一秒500毫秒
const date = new Date(2024, 0, 1, 15, 45, 30, 1500); // 2024年1月1日15:45:31.500
date.getMilliseconds(); // 500

  3. 毫秒值显示格式

    通常需要格式化为三位数：

    js
    const ms = date.getMilliseconds();
const formatted = ms.toString().padStart(3, '0'); // "005" 而不是 "5"

  4. 精度限制

    浏览器/Node.js 的定时器精度通常为 4ms 左右：

    js
    // 连续获取时间可能显示相同毫秒值
console.log(new Date().getMilliseconds());
console.log(new Date().getMilliseconds()); // 可能相同

  5. 性能考虑

    高频调用可能影响性能：

    js
    // 避免在紧凑循环中频繁创建Date对象
const start = new Date();
for (let i = 0; i < 1000000; i++) {
  // 错误：每次迭代都创建新对象
  // const now = new Date().getMilliseconds();
}

// 正确：使用性能API
const startTime = performance.now();
for (let i = 0; i < 1000000; i++) {
  const elapsed = performance.now() - startTime;
}

示例：

  1. 基础用法：

    js
    const now = new Date();
console.log(now.getMilliseconds()); // 返回当前毫秒（0-999）

const preciseTime = new Date(2024, 0, 1, 0, 0, 0, 250); // 2024年1月1日00:00:00.250
console.log(preciseTime.getMilliseconds()); // 250

设置时间信息 ​

setTime() ​

date.setTime()：(timestamp)，用于通过 Unix 时间戳精确设置日期对象的时间。这是最底层的日期设置方法，直接操作毫秒级时间值。

  • timestamp：number， 1970-01-01 00:00:00 UTC（Unix 纪元）起计的毫秒数。特殊值处理：

    • NaN：将日期设为 Invalid Date。

    • 超出范围的值：自动修正到有效范围（-8,640,000,000,000,000 到 8,640,000,000,000,000）。

  • 返回：

  • newTimestamp：number|NaN，返回设置后的时间戳（毫秒数）；如果参数无效或设置失败返回NaN。

核心特性：

  1. 毫秒级精确控制：

    直接操作时间戳，实现最高精度设置：

    js
    const date = new Date();
date.setTime(1704067200000); // 精确设置为 2024-01-01T00:00:00.000Z

  2. 时区无关操作：

    时间戳始终基于 UTC，不受本地时区影响：

    js
    // 北京时间 UTC+8
const date = new Date();
date.setTime(1704067200000); // UTC 时间 2024-01-01T00:00:00Z
console.log(date.toString()); // "Mon Jan 01 2024 08:00:00 GMT+0800" (北京时间)

  3. 自动修正范围：

    处理超出合法范围的时间值：自动修正为最大值

    js
    const date = new Date();

// 超过最大安全值（约 275760年）
date.setTime(8640000000000001); // 自动修正为最大值
console.log(date); // "Sat Sep 13 275760 00:00:00"

// 负值（公元前）
date.setTime(-62167219200000); // 1 BC
console.log(date.getFullYear()); // -1（公元前1年）

  4. 参数类型强制转换：

    非数值参数会被转换为数字：

    js
    const date = new Date();

// 字符串转换为数字
date.setTime("1704067200000"); // 有效

// null 转换为 0（1970-01-01）
date.setTime(null); // 0

// 无效字符串 → NaN
date.setTime("invalid"); // NaN (日期变为 Invalid Date)

  5. 最大/最小安全范围

    JavaScript 日期支持范围：

    js
    // 最大安全值
new Date().setTime(8640000000000000); // "Sep 13 275760"

// 最小安全值
new Date().setTime(-8640000000000000); // "Apr 20 -271821"

  6. 与 new Date(timestamp) 等价

    以下两种方式效果相同：

    js
    // 方式1：构造函数
const date1 = new Date(1704067200000);

// 方式2：setTime
const date2 = new Date();
date2.setTime(1704067200000);

示例：

  1. 基础用法：

    js
    const date = new Date();
const newTimestamp = date.setTime(1704067200000); // 设为2024-01-01 UTC

console.log(date.toISOString()); // "2024-01-01T00:00:00.000Z"
console.log(newTimestamp); // 1704067200000
setFullYear() ​

date.setFullYear()：(year,month?,day?)，用于设置日期对象的年份（本地时区），并可同时设置月份和日期。

  • year：number，四位数的年份。

  • month?：number，月份索引（0-11）。

  • day?：number，日期。

  • 返回：

  • newTimestamp：number|NaN，返回设置后的时间戳（毫秒数）。如果参数无效或设置失败返回NaN。

核心特性：

  1. 本地时区操作

    所有参数被视为本地时区时间：

    js
    // 北京时间 UTC+8
const date = new Date("2024-01-01T00:00:00Z"); // UTC时间
date.setFullYear(2025); // 设置为北京时间2025年1月1日08:00:00

  2. 自动日期修正

    处理无效日期（如2月30日）：

    js
    const date = new Date(2024, 1, 29); // 2024-02-29（闰年）
date.setFullYear(2023); // 自动调整为2023-03-01（2023年非闰年）

  3. 部分更新机制

    未指定的参数保持原值：

    js
    const date = new Date(2024, 5, 15, 12, 30); // 2024-06-15 12:30
date.setFullYear(2025); // 2025-06-15 12:30（月份/日期/时间不变）

示例：

  1. 基础用法：

    js
    const date = new Date(2024, 6, 10); // 2024-07-10

// 只改年份
date.setFullYear(2025);
console.log(date.getFullYear()); // 2025

// 改年份和月份（注意月份索引）
date.setFullYear(2026, 11); // 2026年12月（月份索引11）
console.log(date.toISOString()); // "2026-12-10T00:00:00.000Z"

// 改年/月/日
date.setFullYear(2027, 0, 1); // 2027年1月1日
console.log(date.getDate()); // 1
setMonth() ​

date.setMonth()：(month,day?)，用于设置日期对象的月份（本地时区），并可同时设置日期（月份中的第几天）。

  • month：number，月份索引（0-11）。

  • day?：number，日期。

  • 返回：

  • newTimestamp：number|NaN，返回设置后的时间戳（毫秒数）。如果参数无效或设置失败返回NaN。

核心特性：

  1. 本地时区操作

    所有参数被视为本地时区时间：

    js
    // 北京时间 UTC+8
const date = new Date("2024-01-01T00:00:00Z"); // UTC时间
date.setMonth(5); // 设置为北京时间6月1日08:00:00

  2. 自动日期修正

    处理无效日期（如4月31日）：

    js
    const date = new Date(2024, 0, 31); // 2024-01-31
date.setMonth(3); // 自动调整为2024-04-30（4月没有31日）

  3. 部分更新机制

    未指定的日期参数保持原值：

    js
    const date = new Date(2024, 5, 15, 12, 30); // 2024-06-15 12:30
date.setMonth(7); // 2024-08-15 12:30（日期和时间不变）

示例：

  1. 基础用法

    js
    const date = new Date(2024, 6, 10); // 2024-07-10

// 只改月份
date.setMonth(8); // 设置为9月（月份索引8）
console.log(date.getMonth()); // 8（9月）

// 改月份和日期
date.setMonth(11, 25); // 设置为12月25日（月份索引11）
console.log(date.toISOString()); // "2024-12-25T00:00:00.000Z"
setDate() ​

date.setDate()：(day)，用于设置日期对象的月份中的日期（本地时区）。

  • day：number，月份中的日期。

  • 返回：

  • newTimestamp：number|NaN，返回设置后的时间戳（毫秒数）。如果参数无效或设置失败返回NaN。

核心特性：

  1. 本地时区操作

    参数被视为本地时区的日期：

    js
    // 北京时间 UTC+8
const date = new Date("2024-01-01T00:00:00Z"); // UTC时间
date.setDate(15); // 设置为北京时间1月15日08:00:00

  2. 自动月份/年份修正

    处理跨月和跨年情况：

    js
    const date = new Date(2024, 0, 15); // 2024-01-15

// 向后推算（超出当月天数）
date.setDate(32); // 2024-02-01（1月有31天）

// 向前推算（负值）
date.setDate(0);  // 2024-01-31（上个月最后一天）
date.setDate(-1); // 2024-01-30（上个月倒数第二天）

  3. 保持时间不变

    只修改日期部分，时间部分保持不变：

    js
    const date = new Date(2024, 5, 15, 12, 30); // 2024-06-15 12:30
date.setDate(20); // 2024-06-20 12:30（时间不变）

示例：

  1. 基础用法：

    js
    const date = new Date(2024, 6, 10); // 2024-07-10

// 修改日期
date.setDate(25); // 设置为7月25日
console.log(date.getDate()); // 25

// 跨月设置
date.setDate(32); // 8月1日（7月有31天）
console.log(date.toDateString()); // "Thu Aug 01 2024"

// 负值设置
date.setDate(0); // 7月31日（上个月最后一天）
setHours() ​

date.setHours()：(hours,minutes?,seconds?,ms?)，用于设置日期对象的小时值（基于本地时区），并可同时设置分钟、秒和毫秒。

  • hours：number，范围：0-23，小时值。
  • minutes?：number，范围：0-59，分钟值。
  • seconds?：number，范围：0-59，秒值。
  • ms?：number，范围：0-999，毫秒值。
  • 返回：
  • newTimestamp：number|NaN，返回设置后的时间戳（毫秒数）。如果参数无效或设置失败返回NaN。

核心特性：

  1. 本地时区操作

    所有参数被视为本地时区时间：

    js
    // 北京时间 UTC+8
const date = new Date("2024-01-01T00:00:00Z"); // UTC时间
date.setHours(12); // 设置为北京时间1月1日20:00:00 UTC（12+8=20）

  2. 自动日期修正

    处理跨日情况：

    js
    const date = new Date(2024, 0, 1, 23); // 2024-01-01 23:00
date.setHours(25); // 2024-01-02 01:00（25-24=1小时，日期+1天）

  3. 部分更新机制

    未指定的参数保持原值：

    js
    const date = new Date(2024, 0, 1, 12, 30, 45, 500); // 12:30:45.500
date.setHours(15); // 15:30:45.500（分钟/秒/毫秒不变）

  4. 24小时制

    小时参数使用24小时制：

    js
    // 设置下午3点
date.setHours(15); // 正确
date.setHours(3);  // 错误（这是凌晨3点）

  5. 参数类型转换

    非数值参数强制转换：

    js
    const date = new Date();
date.setHours("12"); // 有效 → 12点
date.setHours(null); // 0 → 0点
date.setHours("abc"); // NaN → 无效日期

示例：

  1. 基础用法：

    js
    const date = new Date(2024, 6, 10, 9, 0); // 2024-07-10 09:00

// 只改小时
date.setHours(14); // 14:00
console.log(date.getHours()); // 14

// 改小时和分钟
date.setHours(16, 30); // 16:30
console.log(date.toLocaleTimeString()); // "16:30:00"

// 改小时、分钟、秒
date.setHours(18, 45, 15); // 18:45:15
console.log(date.getSeconds()); // 15

// 完整设置
date.setHours(20, 0, 0, 0); // 20:00:00.000
setMinutes() ​

date.setMinutes()：(minutes,seconds?,ms?)，用于设置日期对象的分钟值（基于本地时区），并可同时设置秒和毫秒值。

  • minutes：number，范围：0-59，分钟值。

  • seconds?：number，范围：0-59，秒值。

  • ms?：number，范围：0-999，毫秒值。

  • 返回：

  • newTimestamp：number|NaN，返回设置后的时间戳（毫秒数）。如果参数无效或设置失败返回NaN。

核心特性：

  1. 本地时区操作

    所有参数被视为本地时区时间：

    js
    // 北京时间 UTC+8
const date = new Date("2024-01-01T08:00:00Z"); // UTC时间对应北京时间16:00
date.setMinutes(30); // 设置为北京时间16:30

  2. 自动时间修正

    处理跨小时情况：

    js
    const date = new Date(2024, 0, 1, 23, 59); // 2024-01-01 23:59
date.setMinutes(61); // 2024-01-02 00:01（分钟>59，小时+1）

  3. 部分更新机制

    未指定的参数保持原值：

    js
    const date = new Date(2024, 0, 1, 12, 30, 45, 500); // 12:30:45.500
date.setMinutes(45); // 12:45:45.500（秒/毫秒不变）

  4. 参数类型转换

    非数值参数强制转换：

    js
    const date = new Date();
date.setMinutes("30"); // 有效 → 30分
date.setMinutes(null); // 0 → 0分
date.setMinutes("abc"); // NaN → 无效日期

示例：

  1. 基础用法

    js
    const date = new Date(2024, 6, 10, 14, 0); // 2024-07-10 14:00

// 只改分钟
date.setMinutes(30); // 14:30
console.log(date.getMinutes()); // 30

// 改分钟和秒
date.setMinutes(45, 15); // 14:45:15
console.log(date.toLocaleTimeString()); // "14:45:15"

// 完整设置
date.setMinutes(50, 20, 500); // 14:50:20.500
setSeconds() ​

date.setSeconds()：(seconds,ms?)，用于设置日期对象的秒值（基于本地时区），并可同时设置毫秒值。

  • seconds：number，范围：0-59，秒值。

  • ms?：number，范围：0-999，毫秒值。

  • 返回：

  • newTimestamp：number|NaN，返回设置后的时间戳（毫秒数）。如果参数无效或设置失败返回NaN。

核心特性：

  1. 本地时区操作

    所有参数被视为本地时区时间：

    js
    // 北京时间 UTC+8
const date = new Date("2024-01-01T08:00:00Z"); // UTC时间对应北京时间16:00
date.setSeconds(30); // 设置为北京时间16:00:30

  2. 自动时间修正

    处理跨分钟情况：

    js
    const date = new Date(2024, 0, 1, 23, 59, 59); // 2024-01-01 23:59:59
date.setSeconds(61); // 2024-01-02 00:00:01（秒>59，分钟+1）

  3. 部分更新机制

    未指定的参数保持原值：

    js
    const date = new Date(2024, 0, 1, 12, 30, 45, 500); // 12:30:45.500
date.setSeconds(15); // 12:30:15.500（毫秒不变）

  4. 参数类型转换

    非数值参数强制转换：

    js
    const date = new Date();
date.setSeconds("30"); // 有效 → 30秒
date.setSeconds(null); // 0 → 0秒
date.setSeconds("abc"); // NaN → 无效日期

  5. 闰秒处理

    js
    const date = new Date(2023, 11, 31, 23, 59, 59);
date.setSeconds(61); // 2024-01-01 00:00:01（非闰秒）

示例：

  1. 基础用法：

    js
    const date = new Date(2024, 6, 10, 14, 30, 0); // 2024-07-10 14:30:00

// 只改秒数
date.setSeconds(45); // 14:30:45
console.log(date.getSeconds()); // 45

// 改秒数和毫秒
date.setSeconds(15, 250); // 14:30:15.250
setMilliseconds() ​

date.setMilliseconds()：(ms)，用于设置日期对象的毫秒值（基于本地时区）。这是最精细的时间设置方法。

  • ms：number，范围：0-999，毫秒值。

  • 返回：

  • newTimestamp：number|NaN，返回设置后的时间戳（毫秒数）。如果参数无效或设置失败返回NaN。

核心特性：

  1. 本地时区操作

    参数被视为本地时区时间：

    js
    // 北京时间 UTC+8
const date = new Date("2024-01-01T08:00:00Z"); // UTC时间对应北京时间16:00
date.setMilliseconds(500); // 设置为北京时间16:00:00.500

  2. 自动时间修正

    处理跨秒情况：

    js
    const date = new Date(2024, 0, 1, 23, 59, 59, 999); // 2024-01-01 23:59:59.999
date.setMilliseconds(1000); // 2024-01-02 00:00:00.000（毫秒>999，秒+1）

  3. 最高精度控制

    提供 JS 原生的最高时间精度：

    js
    const date = new Date();
date.setMilliseconds(123); // 精确到毫秒级

  4. 精度限制

    实际精度受系统限制（通常1-15ms）：

    js
    // 连续设置可能得到相同值
const d1 = new Date(); d1.setMilliseconds(100);
const d2 = new Date(); d2.setMilliseconds(100);
console.log(d1.getTime() === d2.getTime()); // 可能为true

  5. 参数类型转换

    非数值参数强制转换：

    js
    const date = new Date();
date.setMilliseconds("500"); // 有效 → 500毫秒
date.setMilliseconds(null);  // 0 → 0毫秒
date.setMilliseconds("abc"); // NaN → 无效日期

示例：

  1. 基础用法：

    js
    const date = new Date(2024, 6, 10, 14, 30, 45, 0); // 2024-07-10 14:30:45.000

// 设置毫秒值
date.setMilliseconds(500); // 14:30:45.500
console.log(date.getMilliseconds()); // 500

// 超范围设置
date.setMilliseconds(1500); // 14:30:46.500（秒+1）