JS Date 对象
Date 对象是 JavaScript 内置的对象，通过它您可以访问计算机系统的时间，此外，Date 对象中还提供了多种用于管理、操作和格式化时间/日期的方法。
创建 Date 对象
在开始处理时间和日期之前，我们需要先创建一个 Date 对象。与其他对象（数组对象、字符串对象等）不同，Date 对象不能直接声明，必须通过 Date() 函数定义。
JavaScript 中提供了四种不同的方法来创建 Date 对象，如下所示
var time = new Date();
var time = new Date(milliseconds);
var time = new Date(datestring);
var time = new Date(year, month, date[, hour, minute, second, millisecond]);
参数说明如下：
- 不提供参数：若调用 Date() 函数时不提供参数，则创建一个包含当前时间和日期的 Date 对象；
- milliseconds（毫秒）：若提供一个数值作为参数，则会将这个参数视为一个以毫秒为单位的时间值，并返回自 1970-01-01 00:00:00 起，经过指定毫秒数的时间，例如 new Date(5000) 会返回一个 1970-01-01 00:00:00 经过 5000 毫秒之后的时间；
- datestring（日期字符串）：若提供一个字符串形式的日期作为参数，则会将其转换为具体的时间，日期的字符串形式有两种，如下所示：
- YYYY/MM/dd HH:mm:ss（推荐）：若省略时间部分，则返回的 Date 对象的时间为 00:00:00；
- YYYY-MM-dd HH:mm:ss：若省略时间部分，则返回的 Date 对象的时间为 08:00:00（加上本地时区），若不省略，在 IE 浏览器中会转换失败。
- 将具体的年月日、时分秒转换为 Date 对象，其中：
- year：表示年，为了避免错误的产生，推荐使用四位的数字来表示年份；
- month：表示月，0 代表 1 月，1 代表 2 月，以此类推；
- date：表示月份中的某一天，1 代表 1 号，2 代表 2 号，以此类推；
- hour：表示时，以 24 小时制表示，取值范围为 0 ~ 23；
- minute：表示分，取值范围为 0 ~ 59；
- second：表示秒，取值范围为 0 ~ 59；
- millisecond：表示毫秒，取值范围为 0 ~ 999。
var time1 = new Date();
var time2 = new Date(1517356800000);
var time3 = new Date("2022/03/22 10:22:14");
var time4 = new Date(2099, 9, 12, 15, 16, 17);
document.write(time1 + "
"); // 输出：Tue Mar 22 2022 10:22:52 GMT+0800 (中国标准时间)
document.write(time2 + "
"); // 输出：Wed Jan 31 2018 08:00:00 GMT+0800 (中国标准时间)
document.write(time3 + "
"); // 输出：Tue Mar 22 2022 10:22:14 GMT+0800 (中国标准时间)
document.write(time4 + "
"); // 输出：Mon Oct 12 2099 15:16:17 GMT+0800 (中国标准时间)
Date 对象中的属性
下表中列举了 Date 属性中提供的属性及其描述：
| 属性 | 描述 |
|---|---|
| constructor | 返回创建 Date 对象的原型函数 |
| prototype | 通过该属性您可以向对象中添加属性和方法 |
var time = new Date();
Date.prototype.name = null;
time.name = "JavaScript";
document.write(time.constructor + "
"); // 输出：function Date() { [native code] }
document.write(time.name + "
"); // 输出：JavaScript
Date 对象中的方法
Date 对象中的方法
| 方法 | 描述 |
|---|---|
| getDate() | 从 Date 对象返回一个月中的某一天 (1 ~ 31) |
| getDay() | 从 Date 对象返回一周中的某一天 (0 ~ 6) |
| getMonth() | 从 Date 对象返回月份 (0 ~ 11) |
| getFullYear() | 从 Date 对象返回四位数字的年份 |
| getYear() | 已废弃，请使用 getFullYear() 方法代替 |
| getHours() | 返回 Date 对象的小时 (0 ~ 23) |
| getMinutes() | 返回 Date 对象的分钟 (0 ~ 59) |
| getSeconds() | 返回 Date 对象的秒数 (0 ~ 59) |
| getMilliseconds() | 返回 Date 对象的毫秒(0 ~ 999) |
| getTime() | 返回 1970 年 1 月 1 日至今的毫秒数 |
| getTimezoneOffset() | 返回本地时间与格林威治标准时间 (GMT) 的分钟差 |
| getUTCDate() | 根据通用时间从 Date 对象返回月中的一天 (1 ~ 31) |
| getUTCDay() | 根据通用时间从 Date 对象返回周中的一天 (0 ~ 6) |
| getUTCMonth() | 根据通用时间从 Date 对象返回月份 (0 ~ 11) |
| getUTCFullYear() | 根据通用时间从 Date 对象返回四位数的年份 |
| getUTCHours() | 根据通用时间返回 Date 对象的小时 (0 ~ 23) |
| getUTCMinutes() | 根据通用时间返回 Date 对象的分钟 (0 ~ 59) |
| getUTCSeconds() | 根据通用时间返回 Date 对象的秒钟 (0 ~ 59) |
| getUTCMilliseconds() | 根据通用时间返回 Date 对象的毫秒(0 ~ 999) |
| parse() | 返回1970年1月1日午夜到指定日期（字符串）的毫秒数 |
| setDate() | 设置 Date 对象中月的某一天 (1 ~ 31) |
| setMonth() | 设置 Date 对象中月份 (0 ~ 11) |
| setFullYear() | 设置 Date 对象中的年份（四位数字） |
| setYear() | 已废弃，请使用 setFullYear() 方法代替 |
| setHours() | 设置 Date 对象中的小时 (0 ~ 23) |
| setMinutes() | 设置 Date 对象中的分钟 (0 ~ 59) |
| setSeconds() | 设置 Date 对象中的秒钟 (0 ~ 59) |
| setMilliseconds() | 设置 Date 对象中的毫秒 (0 ~ 999) |
| setTime() | 以毫秒设置 Date 对象 |
| setUTCDate() | 根据通用时间设置 Date 对象中月份的一天 (1 ~ 31) |
| setUTCMonth() | 根据通用时间设置 Date 对象中的月份 (0 ~ 11) |
| setUTCFullYear() | 根据通用时间设置 Date 对象中的年份（四位数字） |
| setUTCHours() | 根据通用时间设置 Date 对象中的小时 (0 ~ 23) |
| setUTCMinutes() | 根据通用时间设置 Date 对象中的分钟 (0 ~ 59) |
| setUTCSeconds() | 根据通用时间设置 Date 对象中的秒钟 (0 ~ 59) |
| setUTCMilliseconds() | 根据通用时间设置 Date 对象中的毫秒 (0 ~ 999) |
| toSource() | 返回该对象的源代码 |
| toString() | 把 Date 对象转换为字符串 |
| toTimeString() | 把 Date 对象的时间部分转换为字符串 |
| toDateString() | 把 Date 对象的日期部分转换为字符串 |
| toGMTString() | 已废弃，请使用 toUTCString() 方法代替 |
| toUTCString() | 根据通用时间，把 Date 对象转换为字符串 |
| toLocaleString() | 根据本地时间格式，把 Date 对象转换为字符串 |
| toLocaleTimeString() | 根据本地时间格式，把 Date 对象的时间部分转换为字符串 |
| toLocaleDateString() | 根据本地时间格式，把 Date 对象的日期部分转换为字符串 |
| UTC() | 根据通用时间返回 1970 年 1 月 1 日 到指定日期的毫秒数 |
| valueOf() | 返回 Date 对象的原始值 |
var time = new Date();
document.write(time.getDate() + "
"); // 输出：22
document.write(time.getDay() + "
"); // 输出：5
document.write(time.getFullYear() + "
"); // 输出：2022
document.write(time.getHours() + "
"); // 输出：11
document.write(time.getMonth() + "
"); // 输出：2
document.write(time.getTime() + "
"); // 输出：1647916764940
document.write(time.getUTCDate() + "
"); // 输出：22
document.write(time.toDateString() + "
"); // 输出：Tue Mar 22 2022
document.write(time.toString() + "
"); // 输出：Tue Mar 22 2022 10:39:24 GMT+0800 (中国标准时间)
document.write(time.toLocaleDateString() + "
"); // 输出：2022/3/22
document.write(time.toLocaleTimeString() + "
"); // 输出：10:39:24
document.write(time.toLocaleString() + "
"); // 输出：2022/3/22 10:39:24
JS Math对象
Math 是 JavaScript 中的一个内置对象，其中提供了一些数学中常用的常量值和函数，用来实现一些数学中常见计算，例如计算平均数、求绝对值、四舍五入等
与前面介绍的几个对象（例如 Number 对象、String 对象、Array 对象等）不同，调用 Math 对象中的属性和方法无需预先使用 new 运算符来创建它，直接将 Math 作为对象调用即可
var pi_val = Math.PI; // 数学中 π 的值：3.141592653589793
var abs_val = Math.sin(-5.35); // -5.35 的绝对值：5.35
Math 对象中的属性
下表中列举了 Math 对象中提供的属性及其描述信息：
| 属性 | 描述 |
|---|---|
| E | 返回算术常量 e，即自然对数的底数（约等于 2.718） |
| LN2 | 返回 2 的自然对数（约等于 0.693） |
| LN10 | 返回 10 的自然对数（约等于 2.302） |
| LOG2E | 返回以 2 为底的 e 的对数（约等于 1.443） |
| LOG10E | 返回以 10 为底的 e 的对数（约等于 0.434） |
| PI | 返回圆周率 π（约等于 3.14159） |
| SQRT1_2 | 返回返回 2 的平方根的倒数（约等于 0.707） |
| SQRT2 | 返回 2 的平方根（约等于 1.414） |
document.write(Math.E + "
"); // 输出：2.718281828459045
document.write(Math.LN2 + "
"); // 输出：0.6931471805599453
document.write(Math.LN10 + "
"); // 输出：2.302585092994046
document.write(Math.LOG2E + "
"); // 输出：1.4426950408889634
document.write(Math.LOG10E + "
"); // 输出：0.4342944819032518
document.write(Math.PI + "
"); // 输出：3.141592653589793
document.write(Math.SQRT1_2 + "
"); // 输出：0.7071067811865476
document.write(Math.SQRT2 + "
"); // 输出：1.4142135623730951
Math 对象中的方法
| 方法 | 描述 |
|---|---|
| abs(x) | 返回 x 的绝对值 |
| acos(x) | 返回 x 的反余弦值 |
| acosh(x) | 返回 x 的反双曲余弦值 |
| asin(x) | 返回 x 的反正弦值 |
| asinh(x) | 返回 x 的反双曲正弦值 |
| atan(x) | 返回 x 的反正切值 |
| atanh(x) | 返回 x 的反双曲正切值 |
| atan2(y,x) | 返回 y/x 的反正切值 |
| cbrt(x) | 返回 x 的立方根 |
| ceil(x) | 对 x 进行向上取整，即返回大于 x 的最小整数 |
| clz32(x) | 返回将 x 转换成 32 无符号整形数字的二进制形式后，开头 0 的个数 |
| cos(x) | 返回 x 的余弦值 |
| cosh(x) | 返回 x 的双曲余弦值 |
| exp(x) | 返回算术常量 e 的 x 次方，即 Ex |
| expm1(x) | 返回 exp(x) - 1 的值 |
| floor(x) | 对 x 进行向下取整，即返回小于 x 的最大整数 |
| fround(x) | 返回最接近 x 的单精度浮点数 |
| hypot([x, [y, [...]]]) | 返回所有参数平方和的平方根 |
| imul(x, y) | 将参数 x、y 分别转换位 32 位整数，并返回它们相乘后的结果 |
| log(x) | 返回 x 的自然对数 |
| log1p(x) | 返回 x 加 1 后的自然对数 |
| log10(x) | 返回 x 以 10 为底的对数 |
| log2(x) | 返回 x 以 2 为底的对数 |
| max([x, [y, [...]]]) | 返回多个参数中的最大值 |
| min([x, [y, [...]]]) | 返回多个参数中的最小值 |
| pow(x,y) | 返回 x 的 y 次幂 |
| random() | 返回一个 0 到 1 之间的随机数 |
| round(x) | 返回 x 四舍五入后的整数 |
| sign(x) | 返回 x 的符号，即一个数是正数、负数还是 0 |
| sin(x) | 返回 x 的正弦值 |
| sinh(x) | 返回 x 的双曲正弦值 |
| sqrt(x) | 返回 x 的平方根 |
| tan(x) | 返回 x 的正切值 |
| tanh(x) | 返回 x 的双曲正切值 |
| toSource() | 返回字符串"Math" |
| trunc(x) | 返回 x 的整数部分 |
| valueOf() | 返回 Math 对象的原始值 |
document.write(Math.abs(-3.1415) + "
"); // 输出：3.1415
document.write(Math.acos(0.5) + "
"); // 输出：1.0471975511965979
document.write(Math.ceil(1.45) + "
"); // 输出：2
document.write(Math.exp(1) + "
"); // 输出：2.718281828459045
document.write(Math.floor(5.99) + "
"); // 输出：5
document.write(Math.log(6) + "
"); // 输出：1.791759469228055
document.write(Math.max(4, 8, 1, 9) + "
"); // 输出：9
document.write(Math.min(4, 8, 1, 9) + "
"); // 输出：1
document.write(Math.random() + "
"); // 输出：0.9172594288928195
document.write(Math.pow(2, 3) + "
"); // 输出：8
document.write(Math.sign(-123) + "
"); // 输出：-1
document.write(Math.sqrt(125) + "
"); // 输出：11.180339887498949
JS RegExp 对象
JavaScript 字符串是在编程中使用最多的一种数据类型，很多地方都需要对字符串进行操作，例如判断一个字符串是否为一个合法的 E-mail 地址、从字符串截取指定的部分等。
正则表达式是一种用于匹配字符串或特殊字符的一种逻辑公式，所谓逻辑公式就是由一些特定字符组合成的，用来表示某些规则的特殊字符串，可以表达对字符串数据的过滤逻辑。
在 JavaScript 中需要借助 RegExp 对象来使用正则表达式，要创建 RegExp 对象有两种方法
var patt = new RegExp(pattern, modifiers);
var patt = /pattern/modifiers;
pattern：正则表达式，按照正则表达式的语法定义的正则表达式；
modifiers：修饰符，用来设置字符串的匹配模式，可选值如下表所示：
| 修饰符 | 描述 |
|---|---|
| i | 执行对大小写不敏感的匹配 |
| g | 执行全局匹配（查找所有的匹配项，而非在找到第一个匹配项后停止） |
| m | 执行多行匹配 |
| s | 允许使用.匹配换行符 |
| u | 使用 Unicode 码的模式进行匹配 |
| y | 执行“粘性”搜索，匹配从目标字符串的当前位置开始 |
注意：当使用 new 关键字创建 RegExp 对象时，需要将正则表达式中的特殊字符转义，即在特殊字符前加反斜杠\，例如\w+。
定义正则表达式
正则表达式由字母、数字、标点以及一些特殊特殊字符组成，例如/abc/、/(\d+).\d*/，可以在正则表达式中使用的特殊字符如下表所示
| 特殊字符 | 含义 |
|---|---|
| \ | 转义字符，在非特殊字符之前使用反斜杠表示下一个字符是特殊字符，不能按照字面理解，例如\b表示一个字符边界；在特殊字符之前使用反斜杠则表示下一个字符不是特殊字符，应该按照字面理解。例如反斜杠本身，若要在正则表达式中定义一个反斜杠，则需要在反斜杠前再添加一个反斜杠\。 |
| ^ | 匹配字符串的开头，如果设置了修饰符 m，则也可以匹配换行符后紧跟的位置。 例如“/^A/”并不会匹配“an A”中的“A”，但是会匹配“An E”中的“A”。 |
| $ | 匹配字符串的末尾，如果设置了修饰符 m，则也可以匹配换行符之前的位置。 例如“/t$/”并不会匹配“eater”中的“t”，但是会匹配“eat”中的“t”。 |
| * | 匹配前一个表达式 0 次或多次，等价于 {0,}。例如“/bo*/”能够匹配“A ghost boooooed”中的“booooo”和“A bird warbled”中的“b”，但是在“A goat grunted”中不会匹配任何内容。 |
| + | 匹配前面一个表达式 1 次或者多次，等价于 {1,}。例如“/a+/”能够匹配“candy”中的“a”和“caaaaaaandy”中所有的“a”，但是在“cndy”中不会匹配任何内容。 |
| ? | 匹配前面一个表达式 0 次或者 1 次，等价于 {0,1}。例如“/e?le?/”能够匹配“angel”中的“el”，“angle”中的“le”以及“oslo”中的“l”。 |
| . | 匹配除换行符之外的任何单个字符。例如“/.n/”将会匹配“nay, an apple is on the tree”中的“an”和“on”。 |
| (x) | 匹配“x”并记住这一匹配项，这里的括号被称为捕获括号。 |
| (?:x) | 匹配“x”但是不记住匹配项，这里的括号被称为非捕获括号。 |
| x(?=y) | 当“x”后面跟着“y”时，匹配其中的“x”。例如“/Jack(?=Sprat)/”会匹配后面跟着“Sprat”的“Jack”，“/Jack(?=Sprat|Frost)/”会匹配后面跟着“Sprat”或者是“Frost”的“Jack”。注意：无论是“Sprat”还是“Frost”都不是匹配结果的一部分。 |
| (?<=y)x | 当“x”前面是“y”时，匹配其中的“x”。例如“/(?<=Jack)Sprat/”会匹配前面未“Sprat”的“Jack”，“/(?<=JackITom)Sprat/”会匹配前面为“Jack”或者“Tom”的“Sprat”。注意：无论是“Jack”和“Tom”都不是匹配结果的一部分。 |
| x(?!y) | 当“x”后面不是“y”时，匹配其中的“x”。 例如“/\d+(?!.)/”会匹配“3.141”中的“141”，而不是“3.141”。 |
| (? | 当“x”前面不是“y”时，匹配其中的“x”。 |
| xIy | 匹配“x”或者“y”。 例如“/green|red/”能够匹配“green apple”中的“green”和“red apple”中的“red”。 |
| {n} | n 是一个正整数，表示匹配前一个字符 n 次。例如“/a{2}/”不会匹配“candy”中的“a”，但是能够匹配“caandy”中所有的“a”，以及“caaandy”中的前两个“a”。 |
| {n,} | n 是一个正整数，表示匹配前一个字符至少 n 次。例如“/a{2,}/”能够匹配“aa”、“aaaa”或“aaaaa”，但不会匹配“a”。 |
| {n,m} | n 和 m 都是整数，表示匹配前一个字符至少 n 次，最多 m 次，如果 n 或 m 等于 0，则表示忽略这个值。例如“/a{1, 3}/”能够匹配“candy”中的“a”，“caandy”中的前两个“a”，“caaaaaaandy”中的前三个“a”。 |
| [xyz | ] 转义序列，匹配 x、y 或 z，您也可以使用破折号-来指定一个字符范围。例如“[abcd]”和“[a-d]”是一样的，它们都能匹配“brisket”中的“b”,“city”中的“c”。 |
| [^xyz] | 反向字符集，匹配除 x、y、z 以外的任何字符，您通用也可以使用破折号-来指定一个字符范围。例如“[abc]”和“[a-c]”是一样的，它们都能匹配“brisket”中的“r”，“chop”中的“h”。 |
| [\b] | 匹配一个退格符，注意：不要和 \b 混淆。 |
| \b | 匹配一个单词的边界，即单词的开始或末尾。例如“/\bm/”能够匹配“moon”中的“m”，但不会匹配“imoon”中的“m”。 |
| \B | 匹配一个非单词边界。例如“er\B”能匹配“verb”中的“er”，但不能匹配“never”中的“er”。 |
| \cX | 当 X 是 A 到 Z 之间的字符时，匹配字符串中的一个控制符。例如“/\cM/”能够匹配字符串中的“control-M(U+000D)”。 |
| \d | 匹配一个数字，等价于“[0-9]”。例如“/\d/”或者“/[0-9]/”能够匹配“B2 is the suite number.”中的“2”。 |
| \D | 匹配一个非数字字符，等价于“[^0-9]”。 例如“/\D/”或者“/[^0-9]/”能够匹配“B2 is the suite number.”中的“B”。 |
| \f | 匹配一个换页符 (U+000C)。 |
| \n | 匹配一个换行符 (U+000A)。 |
| \r | 匹配一个回车符 (U+000D)。 |
| \s | 匹配一个空白字符，包括空格、制表符、换页符和换行符，等价于“[ \f\n\r\t\v\u00a0\u1680\u180e\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]”。例如“/\s\w*/”能够匹配“foo bar.”中的“bar”。 |
| \S | 匹配一个非空白字符，等价于“[^\f\n\r\t\v\u00a0\u1680\u180e\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]”。例如“/\S\w*/”能够匹配“foo bar.”中的“foo”。 |
| \t | 匹配一个水平制表符 (U+0009)。 |
| \v | 匹配一个垂直制表符 (U+000B)。 |
| \w | 匹配一个单字字符（字母、数字或者下划线），等价于“[A-Za-z0-9_]”。例如“/\w/”能够匹配“apple,”中的“a”，“$5.28,”中的“5”和“3D.”中的“3”。 |
| \W | 匹配一个非单字字符，等价于“[A-Za-z0-9_]”。例如“/\W/”或者“/[A-Za-z0-9_]/”能够匹配“50%.”中的“%”。 |
| \n | 获取最后的第 n 个匹配的值。比如“/apple(,)\sorange\1/”能够匹配“apple, orange, cherry, peach.”中的“apple, orange,”。 |
| \0 | 匹配 NULL（U+0000）字符，不要在这后面跟其它小数，因为 \0 |
| \xhh | 匹配一个两位十六进制数（\x00-\xFF）表示的字符。 |
| \uhhhh | 匹配一个四位十六进制数表示的 UTF-16 代码单元。 |
| \u{hhhh}或\u{hhhhh} | （仅在设置了修饰符 u 时）匹配一个十六进制数表示的 Unicode 字符。 |
提示：在正则表达式中.、*、?、+、[、]、(、)、{、}、^、$、|、\等字符被赋予了特殊的含义，若要在正则表达式中使用这些字符的原本意思时，需要在这些字符前添加反斜线进行转义，例如若要匹配.，则必须编写为.。
使用正则表达式
JavaScript RegExp 对象中提供了一些列方法来执行正则表达式，如下表所示
| 方法 | 描述 |
|---|---|
| compile() | 在 1.5 版本中已废弃，编译正则表达式 |
| exec() | 在字符串搜索匹配项，并返回一个数组，若没有匹配项则返回 null |
| test() | 测试字符串是否与正则表达式匹配，匹配则返回 true，不匹配则返回 false |
| toString() | 返回表示指定对象的字符串 |
此外 String 对象中也提供了一些方法来执行正则表达式
| 方法 | 描述 |
|---|---|
| search() | 在字符串中搜索匹配项，并返回第一个匹配的结果，若没有找到匹配项则返回 -1 |
| match() | 在字符串搜索匹配项，并返回一个数组，若没有匹配项则返回 null |
| matchAll() | 在字符串搜索所有匹配项，并返回一个迭代器（iterator） |
| replace() | 替换字符串中与正则表达式相匹配的部分 |
| split() | 按照正则表达式将字符串拆分为一个字符串数组 |
除了方法外，RegExp 对象中还提供了一些属性
| 属性 | 描述 |
|---|---|
| constructor | 返回一个函数，该函数是一个创建 RegExp 对象的原型 |
| global | 判断是否设置了修饰符 "g" |
| ignoreCase | 判断是否设置了修饰符 "i" |
| lastIndex | 用于规定下次匹配的起始位置 |
| multiline | 判断是否设置了修饰符 "m" |
| source | 返回正则表达式的匹配模式 |
var str = "Hello World!";
var reg = /[a-g]/g;
document.write(reg.exec(str) + "
"); // 输出：e
document.write(reg.test(str) + "
"); // 输出：true
document.write(reg.toString() + "
"); // 输出：/[a-g]/g
document.write(str.search(reg) + "
"); // 输出：1
document.write(str.match(reg) + "
"); // 输出：e,d
document.write(str.matchAll(reg) + "
"); // 输出：[object RegExp String Iterator]
document.write(str.replace(reg, "+") + "
"); // 输出：H+llo Worl+!
document.write(str.split(reg) + "
"); // 输出：H,llo Worl,!