- 引用值（或者对象）是某个特定引用类型的实例。
- 新对象通过使用 new 操作符后跟一个构造函数（constructor）来创建。构造函数就是用来创建新对象的函数。
- 在 ECMAScript 中，引用类型是把数据和功能组织到一起的结构，经常被人错误地称作“类”。
- 虽然从技术上讲 JavaScript 是一门面向对象语言，但 ECMAScript 缺少传统的面向对象编程语言所具备的某些基本结构，包括类和接口。
- 引用类型有时候也被称为对象定义，因为它们描述了自己的对象应有的属性和方法。
- 函数也是一种引用类型。
-
如果没有输入任何参数，则 Date 的构造器会依据系统设置的当前时间来创建一个 Date 对象。
-
JavaScript 的时间由世界标准时间（UTC）1970 年 1 月 1 日开始，用毫秒计时，一天由 86,400,000 毫秒组成。
- Date 对象的范围是 -100,000,000 天至 100,000,000 天（等效的毫秒值）
-
Date 类型重写了 toLocaleString() 、 toString() 。
- 现代浏览器在这两个方法的输出上已经趋于一致。在比较老的浏览器上，每个方法返回的结果可能在每个浏览器上都是不同的。
- 这些差异意味着 toLocaleString() 和 toString() 可能只对调试有用，不能用于显示。
-
Date 类型的 valueOf() 方法根本就不返回字符串，这个方法被重写后返回的是日期的毫秒表示。
- toDateString() 显示日期中的周几、月、日、年（格式特定于实现）；
- toTimeString() 显示日期中的时、分、秒和时区（格式特定于实现）；
- toLocaleDateString() 显示日期中的周几、月、日、年（格式特定于实现和地区）；
- toLocaleTimeString() 显示日期中的时、分、秒（格式特定于实现和地区）；
- toUTCString() 显示完整的 UTC 日期（格式特定于实现）。
注意：这些方法会因浏览器而异。因此不能用于在用户界面上一致地显示日期。
类方法：
- Date.now() ： 返回自 1970 年 1 月 1 日 00:00:00 (UTC) 到当前时间的毫秒数。
- Date.parse() ： 接收一个表示日期的字符串参数，尝试将这个字符串转换为表示该日期的毫秒数。
- Date.UTC() ： UTC 方法接受以逗号隔开的日期参数，返回 1970-1-1 00:00:00 UTC 到指定的日期之间的毫秒数。
实例方法：
| 方法 | 说明 |
|---|---|
| getTime() | 返回日期的毫秒表示；与 valueOf() 相同 |
| setTime(milliseconds) | 设置日期的毫秒表示，从而修改整个日期 |
| getFullYear() | 返回 4 位数年（即 2019 而不是 19） |
| getUTCFullYear() | 返回 UTC 日期的 4 位数年 |
| setFullYear(year) | 设置日期的年（ year 必须是 4 位数） |
| setUTCFullYear(year) | 设置 UTC 日期的年（ year 必须是 4 位数） |
| getMonth() | 返回日期的月（0 表示 1 月，11 表示 12 月） |
| getUTCMonth() | 返回 UTC 日期的月（0 表示 1 月，11 表示 12 月） |
| setMonth(month) | 设置日期的月（ month 为大于 0 的数值，大于 11 加年） |
| setUTCMonth(month) | 设置 UTC 日期的月（ month 为大于 0 的数值，大于 11 加年） |
| getDate() | 返回日期中的日（1~31） |
| getUTCDate() | 返回 UTC 日期中的日（1~31） |
| setDate(date) | 设置日期中的日（如果 date 大于该月天数，则加月） |
| setUTCDate(date) | 设置 UTC 日期中的日（如果 date 大于该月天数，则加月） |
| getDay() | 返回日期中表示周几的数值（0 表示周日，6 表示周六） |
| getUTCDay() | 返回 UTC 日期中表示周几的数值（0 表示周日，6 表示周六） |
| getHours() | 返回日期中的时（0~23） |
| getUTCHours() | 返回 UTC 日期中的时（0~23） |
| setHours(hours) | 设置日期中的时（如果 hours 大于 23，则加日） |
| setUTCHours(hours) | 设置 UTC 日期中的时（如果 hours 大于 23，则加日） |
| getMinutes() | 返回日期中的分（0~59） |
| getUTCMinutes() | 返回 UTC 日期中的分（0~59） |
| setMinutes(minutes) | 设置日期中的分（如果 minutes 大于 59，则加时） |
| setUTCMinutes(minutes) | 设置 UTC 日期中的分（如果 minutes 大于 59，则加时） |
| getSeconds() | 返回日期中的秒（0~59） |
| getUTCSeconds() | 返回 UTC 日期中的秒（0~59） |
| setSeconds(seconds) | 设置日期中的秒（如果 seconds 大于 59，则加分） |
| setUTCSeconds(seconds) | 设置 UTC 日期中的秒（如果 seconds 大于 59，则加分） |
| getMilliseconds() | 返回日期中的毫秒 |
| getUTCMilliseconds() | 返回 UTC 日期中的毫秒 |
| setMilliseconds(milliseconds) | 设置日期中的毫秒 |
| setUTCMilliseconds(milliseconds) | 设置 UTC 日期中的毫秒 |
| getTimezoneOffset() | 返回协调世界时（UTC）相对于当前时区的时间差值，单位为分钟。 |
语法：let expression = /pattern/flags;
- pattern （模式）可以是任何简单或复杂的正则表达式，包括字符类、限定符、分组、向前查找和反向引用。
- 每个正则表达式可以带零个或多个 flags （标记），用于控制正则表达式的行为。
- g ：全局模式，表示查找字符串的全部内容，而不是找到第一个匹配的内容就结束。
- i ：不区分大小写，表示在查找匹配时忽略 pattern 和字符串的大小写。
- m ：多行模式，表示查找到一行文本末尾时会继续查找。
- y ：粘附模式，表示只查找从 lastIndex 开始及之后的字符串。
- u ：Unicode 模式，启用 Unicode 匹配。
- s ： dotAll 模式，表示元字符. 匹配任何字符（包括 \n 或 \r ）。
以下三种表达式都会创建相同的正则表达式：
/ab+c/i; //字面量形式
new RegExp("ab+c", "i"); // 首个参数为字符串模式的构造函数
new RegExp(/ab+c/, "i"); // 首个参数为常规字面量的构造函数所有元字符在模式中也必须转义，包括：
( [ { \ ^ $ | ) ] } ? * + .
示例：
// 匹配第一个"bat"或"cat"，忽略大小写
let pattern1 = /[bc]at/i;
// 匹配第一个"[bc]at"，忽略大小写
let pattern2 = /\[bc\]at/i;
// 匹配所有以"at"结尾的三字符组合，忽略大小写
let pattern3 = /.at/gi;
// 匹配所有".at"，忽略大小写
let pattern4 = /\.at/gi;因为 RegExp 的模式参数是字符串，所以在某些情况下需要二次转义。所有元字符都必须二次转义，包括转义字符序列。
示例：
字面量模式 及使用 RegExp 构造函数创建时对应的字符串
/\[bc\]at/ "\\[bc\\]at"
/\.at/ "\\.at"
/name\/age/ "name\\/age"
/\d.\d{1,2}/ "\\d.\\d{1,2}"
/\w\\hello\\123/ "\\w\\\\hello\\\\123"注意：非标准的 RegExp 构造函数的属性，不要在生产环境中使用它们。
| 全 名 | 简 写 | 说 明 （都是非标准特性） |
|---|---|---|
| RegExp.input | RegExp.$_ | 最后搜索的字符串 |
| RegExp.lastMatch | RegExp.$& | 最后匹配的文本 |
| RegExp.lastParen | RegExp.$+ | 最后匹配的捕获组 |
| RegExp.leftContext | RegExp.$` | input 字符串中出现在 lastMatch 前面的文本 |
| RegExp.rightContext | RegExp.$' | input 字符串中出现在 lastMatch 后面的文本 |
| RegExp.$1-$9 | 无 | 获取指定索引的括号匹配项. |
| RegExp.lastIndex | 无 | (标准)正则表达式的一个可读可写的整型属性，用来指定下一次匹配的起始索引。 |
| 实例属性 | 作用 |
|---|---|
| global | 布尔值，表示是否设置了 g 标记。 |
| ignoreCase | 布尔值，表示是否设置了 i 标记。 |
| unicode | 布尔值，表示是否设置了 u 标记。 |
| sticky | 布尔值，表示是否设置了 y 标记。 |
| lastIndex | 整数，表示在源字符串中下一次搜索的开始位置，始终从 0 开始。 |
| multiline | 布尔值，表示是否设置了 m 标记。 |
| dotAll | 布尔值，表示是否设置了 s 标记。 |
| source | 正则表达式的字面量字符串（不是传给构造函数的模式字符串），没有开头和结尾的斜杠。 |
| flags | 正则表达式的标记字符串。始终以字面量而非传入构造函数的字符串模式形式返回（没有前后斜杠）。 |
let pattern1 = /\[bc\]at/i;
console.log(pattern1.global); // false
console.log(pattern1.ignoreCase); // true
console.log(pattern1.multiline); // false
console.log(pattern1.lastIndex); // 0
console.log(pattern1.source); // "\[bc\]at"
console.log(pattern1.flags); // "i"RegExp.prototype.exec(str)：
regexObj.exec(str): 在一个指定字符串中执行一个搜索匹配。返回一个结果数组或 null。- 如果匹配成功，exec() 方法返回一个数组（匹配的全部字符串、括号中的分组捕获、额外的属性 index 和 input），并更新正则表达式对象的 lastIndex 属性。
- index 是字符串中匹配模式的起始位置，
- input 是要查找的字符串。
- 如果匹配失败，exec() 方法返回 null，并将 lastIndex 重置为 0 。
具体可参看 MDN 的对应RegExp.prototype.exec()的示例，比较清晰。
更常用可能只是为了判断是否匹配（true 或 false）。
RegExp.prototype.test(str)：
regexObj.test(str)： 执行一个检索，用来查看正则表达式与指定的字符串是否匹配。返回 true 或 false。
RegExp.prototype.toString():
regexObj.toString(): 无参数，返回一个表示该正则表达式的字符串。
- 为了方便操作原始值，ECMAScript 提供了 3 种特殊的引用类型： Boolean 、 Number 和 String 。
- 每当用到某个原始值的方法或属性时，后台都会创建一个相应原始包装类型的对象，从而暴露出操作原始值的各种方法。
let s1 = "some text";
let s2 = s1.substring(2);
/*
第二行访问 s1 时，是以读模式访问的，也就是要从内存中读取变量保存的值。
在以读模式访问字符串值的任何时候，后台都会执行以下 3 步：
(1) 创建一个 String 类型的实例；
(2) 调用实例上的特定方法；
(3) 销毁实例。
这种行为可以让原始值拥有对象的行为。
*/引用类型与原始值包装类型的主要区别在于对象的生命周期。
- 在通过 new 实例化引用类型后，得到的实例会在离开作用域时被销毁。
- 自动创建的原始值包装对象则只存在于访问它的那行代码执行期间。这意味着不能在运行时给原始值添加属性和方法。
let s1 = "some text";
s1.color = "red";
console.log(s1.color); // undefined
/*
这里的第二行代码尝试给字符串 s1 添加了一个 color 属性。可是，第三行代码访问 color 属性时，它却不见了。
原因就是第二行代码运行时会临时创建一个 String 对象，而当第三行代码执行时，这个对象已经被销毁了。
实际上，第三行代码在这里创建了自己的 String 对象，但这个对象没有 color 属性。
*/可以显式地使用 Boolean 、 Number 和 String 构造函数创建原始值包装对象。不过应该在确实必要时再这么做，否则容易让开发者疑惑，分不清它们到底是原始值还是引用值。
注意，使用 new 调用原始值包装类型的构造函数，与调用同名的转型函数并不一样。
let value = "25";
let number = Number(value); // 转型函数
console.log(typeof number); // "number"
let obj = new Number(value); // 构造函数
console.log(typeof obj); // "object"- Boolean 对象是一个布尔值的对象包装器。
- 如果需要，作为第一个参数传递的值将转换为布尔值。
- 如果省略或值 0，-0，null，false，NaN，undefined，或空字符串（""），该对象具有的初始值 false。
- 所有其他值，包括任何对象，空数组（[]）或字符串"false"，都会创建一个初始值为 true 的对象。
- 注意不要将基本类型中的布尔值 true 和 false 与值为 true 和 false 的 Boolean 对象弄混了。
- 其值不是 undefined 或 null 的任何对象（包括其值为 false 的布尔对象）在传递给条件语句时都将计算为 true。
不要用创建 Boolean 对象的方式将一个非布尔值转化成布尔值，直接将 Boolean 当做转换函数来使用即可
let x = Boolean(expression); // 推荐
let x = !!expression; // 推荐
let x = new Boolean(expression); // 不太好理解原始布尔值和 Boolean 对象之间的区别非常重要，强烈建议永远不要使用后者。
Boolean.prototype.valueOf()
- valueOf() 方法返回一个 Boolean 对象的原始值。
Boolean.prototype.toString()
- toString() 方法返回指定的布尔对象的字符串形式。
const x = new Boolean();
console.log(x.valueOf()); // false
const y = new Boolean("Mozilla");
console.log(y.valueOf()); // true
const flag1 = new Boolean(true);
console.log(flag1.toString()); // true
const flag2 = new Boolean(1);
console.log(flag2.toString()); // true- Number 是对应数值的引用类型。要创建一个 Number 对象，就使用 Number 构造函数并传入一个数值.
- 不建议直接实例化 Number 对象。在处理原始数值和引用数值时， typeof 和 instacnceof 操作符会返回不同的结果.
| 属性 | 作用 |
|---|---|
| Number.EPSILON | 两个可表示数之间的最小间隔(即 1 与 Number 可表示的大于 1 的最小的浮点数之间的差值。)。 |
| Number.MAX_SAFE_INTEGER | JavaScript 中最大的安全整数 (2^53 - 1)。 |
| Number.MAX_VALUE | 能表示的最大正数。最小的负数是 -MAX_VALUE。 |
| Number.MIN_SAFE_INTEGER | JavaScript 中最小的安全整数 (-(2^53 - 1)). |
| Number.MIN_VALUE | 能表示的最小正数即最接近 0 的正数 (实际上不会变成 0)。最大的负数是 -MIN_VALUE。 |
| Number.NaN | 特殊的“非数字”值。 |
| Number.NEGATIVE_INFINITY | 特殊的负无穷大值，在溢出时返回该值。 |
| Number.POSITIVE_INFINITY | 特殊的正无穷大值，在溢出时返回该值。 |
| 方法 | 作用 |
|---|---|
| Number.isNaN() | 确定传递的值是否是 NaN。 |
| Number.isFinite() | 确定传递的值类型及本身是否是有限数。 |
| Number.isInteger() | 确定传递的值类型是“number”，且是整数。 |
| Number.isSafeInteger() | 确定传递的值是否为安全整数 ( -(2^53 - 1) 至 2^53 - 1 之间)。 |
| Number.parseFloat() | 和全局对象 parseFloat() 一样。 解析一个参数（必要时先转换为字符串）并返回一个浮点数 |
| Number.parseInt() | 和全局对象 parseInt() 一样。 parseInt(string, radix) 解析一个字符串并返回指定基数的十进制整数， radix 是 2-36 之间的整数，表示被解析字符串的基数。 |
| 方法 | 作用 |
|---|---|
| Number.prototype.toExponential(fractionDigits) | 以指数表示法返回该数值字符串表示形式。 fractionDigits:可选。一个整数，用来指定小数点后有几位数字。 |
| Number.prototype.toFixed(digits) | 使用定点表示法来格式化一个数值。 digits 小数点后数字的个数；介于 0 到 20 （包括）之间，实现环境可能支持更大范围。如果忽略该参数，则默认为 0。 |
| Number.prototype.toLocaleString([locales [, options]]) | 返回这个数字在特定语言环境下的表示字符串。 参数可选 |
| Number.prototype.toPrecision(precision) | 以指定的精度返回该数值对象的字符串表示。 precision：可选， 指定有效数个数的整数 |
| Number.prototype.toString([radix]) | 指定 Number 对象的字符串表示形式。 radix 指定要用于数字到字符串的转换的基数(从 2 到 36)。如果未指定 radix 参数，则默认值为 10。 |
| Number.prototype.valueOf() | 返回一个被 Number 对象包装的原始值。 |
String 对象的方法可以在所有字符串原始值上调用。3 个继承的方法 valueOf() 、 toLocaleString()和 toString() 都返回对象的原始字符串值。 每个 String 对象都有一个 length 属性，表示字符串中字符的数量。
- 即使字符串中包含双字节字符（而不是单字节的 ASCII 字符），也仍然会按单字符来计数(例如中文)。
- JavaScript 字符串由 16 位码元（code unit）组成。对多数字符来说，每 16 位码元对应一个字符。
- 换句话说，字符串的 length 属性表示字符串包含多少 16 位码元
对于 U+0000~U+FFFF 范围内的字符， length 、 charAt() 、 charCodeAt() 和 fromCharCode()返回的结果都跟预期是一样的。
- 这是因为在这个范围内，每个字符都是用 16 位表示的，而这几个方法也都基于 16 位码元完成操作。只要字符编码大小与码元大小一一对应，这些方法就能如期工作。
js 字符串(String)
String 全局对象是一个用于字符串或一个字符序列的构造函数。
基本字符串和字符串对象的区别:
- 字符串字面量 (通过单引号或双引号定义) 和 直接调用 String 方法(没有通过 new 生成字符串对象实例)的字符串都是基本字符串。
- JavaScript 会自动将基本字符串转换为字符串对象，只有将基本字符串转化为字符串对象之后才可以使用字符串对象的方法。
- 当基本字符串需要调用一个字符串对象才有的方法或者查询值的时候(基本字符串是没有这些方法的)，JavaScript 会自动将基本字符串转化为字符串对象并且调用相应的方法或者执行查询。
| 方法名 | 作用 |
|---|---|
| String.fromCharCode(num1[, ...[, numN]]) | 返回由指定的 UTF-16 代码单元序列创建的字符串。 |
| String.fromCodePoint(num1[, ...[, numN]]) | 返回使用指定的代码点序列创建的字符串。 |
String.raw(callSite, ...substitutions)或 String.rawtemplateString |
通过模板字符串创建字符串。 |
String.prototype.length 返回了字符串的长度。
(原型方法:String.prototype.xxx())
以下都不改变原字符串
| 方法 | 作用 |
|---|---|
| str.charAt(index) | 从一个字符串中返回指定的字符。如果没有提供索引，charAt() 将使用 0。指定的 index 值超出了该范围，返回一个空字符串。 |
| str.charCodeAt(index) | 返回 0 到 65535 之间的整数，表示给定索引处的 UTF-16 代码单元 |
| str.codePointAt(index) | 返回 一个 Unicode 编码点值的非负整数。 |
| str.concat(str2, [, ...strN]) | 将一个或多个字符串与原字符串连接合并，形成一个新的字符串并返回。 如果参数不是字符串类型，它们在连接之前将会被转换成字符串。强烈建议使用赋值操作符（+, +=）代替 concat 方法。 |
| str.endsWith(searchString[, length]) | 判断当前字符串是否是以另外一个给定的子字符串“结尾”的，根据判断结果返回 true 或 false。 |
| str.includes(searchString[, position]) | 判断一个字符串是否包含在另一个字符串中，根据情况返回 true 或 false。(是区分大小写的) |
| str.indexOf(searchValue [, fromIndex]) | 返回调用它的 String 对象中第一次出现的指定值的索引，从 fromIndex 处进行搜索。如果未找到该值，则返回 -1。 |
| str.lastIndexOf(searchValue[, fromIndex]) | 返回调用 String 对象的指定值最后一次出现的索引，在一个字符串中的指定位置 fromIndex 处从后向前搜索。如果没找到这个特定值则返回-1 。 |
| str.match(regexp) | 返回一个字符串匹配正则表达式的结果。 |
| str.matchAll(regexp) | 返回一个包含所有匹配正则表达式的结果及分组捕获组的迭代器。(如果没有 /g 标志，matchAll 会抛出异常。) |
| str.normalize([form]) | 按照指定的一种 Unicode 正规形式将当前字符串正规化。（如果该值不是字符串，则首先将其转换为一个字符串）。form 有 4 种:"NFC"(默认)、"NFD"、"NFKC"，或 "NFKD" |
| str.padEnd(targetLength [, padString]) | 用一个字符串填充当前字符串（如果需要的话则重复填充），返回填充后达到指定长度的字符串。从当前字符串的末尾（右侧）开始填充。 |
| str.padStart(targetLength [, padString]) | 用另一个字符串填充当前字符串(如果需要的话，会重复多次)，以便产生的字符串达到给定的长度。从当前字符串的左侧开始填充。 |
| str.repeat(count) | 构造并返回一个新字符串，该字符串包含被连接在一起的指定数量的字符串的副本。count 介于 0 和 +Infinity 之间的整数。 |
| str.replace(regexp|substr, newSubStr|function) | 返回一个由替换值（replacement）替换部分或所有的模式（pattern）匹配项后的新字符串。 |
| str.replaceAll(regexp|substr, newSubstr|function) | 返回一个新字符串，新字符串所有满足 pattern 的部分都已被 replacement 替换。 |
| str.search(regexp) | 执行正则表达式和 String 对象之间的一个搜索匹配。返回首次出现的索引或者-1(没有匹配项) |
| str.slice(beginIndex[, endIndex]) | 提取某个字符串的一部分，并返回一个新的字符串，且不会改动原字符串。 |
| str.split([separator[, limit]]) | 使用指定的分隔符字符串将一个 String 对象分割成子字符串数组，以一个指定的分割字串来决定每个拆分的位置。 |
| str.startsWith(searchString[, position]) | 判断当前字符串是否以另外一个给定的子字符串开头，并根据判断结果返回 true 或 false。 |
| str.substring(indexStart[, indexEnd]) | 返回一个字符串在开始索引到结束索引之间的一个子集, 或从开始索引直到字符串的末尾的一个子集。 |
| str.toLocaleLowerCase([locale, locale, ...]) | 根据任何指定区域语言环境设置的大小写映射，返回调用字符串被转换为小写的格式。 |
| str.toLocaleUpperCase([locale, locale, ...]) | 根据本地主机语言环境把字符串转换为大写格式，并返回转换后的字符串。 |
| str.toLowerCase() | 调用该方法的字符串值转为小写形式，并返回(一个新的字符串)。toLowerCase 不会影响字符串本身的值。 |
| str.toUpperCase() | 调用该方法的字符串转为大写形式并返回（如果调用该方法的值不是字符串类型会被强制转换）。 |
| str.trim() | 从一个字符串的两端删除空白字符,返回两端去掉空白的新字符串。在这个上下文中的空白字符是所有的空白字符 (space, tab, no-break space 等) 以及所有行终止符字符（如 LF，CR 等）。 |
| str.trimEnd()/str.trimRight() | 从一个字符串的末端移除空白字符。trimRight() 是这个方法的别名。返回一个新字符串。 |
| str.trimStart()/str.trimLeft() | 从字符串的开头删除空格。trimLeft() 是此方法的别名。返回一个新字符串 |
| str.valueOf() | 返回 String 对象的原始值 |
| str.toString() | 返回指定对象的字符串形式。(个人注:在 String 类型下,valueOf()和 toString()返回是一样的,但其他引用类型就不一定是了) |
| referenceStr.localeCompare(compareString[, locales[, options]]) | 返回一个数字来指示一个参考字符串是否在排序顺序前面或之后或与给定字符串相同。 如果引用字符存在于比较字符之前则为负数; 如果引用字符存在于比较字符之后则为正数; 相等的时候返回 0 . |
| str[@@iterator]() | [@@iterator]()方法返回一个新的 Iterator 对象，它遍历字符串的代码点，返回每一个代码点的字符串值。 |
- JavaScript 字符
- normalize()方法
- 字符串操作方法
- 字符串位置方法
- 字符串包含方法
- trim()方法
- repeat()方法
- padStart()和 padEnd()方法
- 字符串迭代与解构
- 字符串大小写转换
- 字符串模式匹配方法
- localeCompare()方法
ECMA-262 对内置对象的定义是“任何由 ECMAScript 实现提供、与宿主环境无关，并在 ECMAScript 程序开始执行时就存在的对象”。
这就意味着，开发者不用显式地实例化内置对象，因为它们已经实例化好了。
可以參考 MDN《JavaScript 标准内置对象》了解所有标准内置对象。
注意：简单查了一下，单例内置对象的“单例”大家都只是说了 Global 和 Math，但具体什么含义、怎么得来的並没有描述很清楚。所以，我这里也只是认为重点是学习一些内置对象的使用而已。根据《JavaScript 高级程序设计(第四版)》的内容，放置了 Global 和 Math 两个内置对象。或许区别是在于 Math 不是一个构造器。Math 的所有属性与方法都是静态的。
MDN 对全局对象的介绍可见链接。
Global 对象是 ECMAScript 中最特别的对象，因为代码不会显式地访问它。
ECMA-262 规定 Global 对象为一种兜底对象，它所针对的是不属于任何对象的属性和方法。
事实上，不存在全局变量或全局函数这种东西。在全局作用域中定义的变量和函数都会变成 Global 对象的属性 。
在 Web 浏览器中，脚本没有专门作为后台任务启动的任何代码都将 Window 作为其全局对象。
window 对象是浏览器中的全局对象。任何全局变量或者全局函数都可以通过 window 的属性来访问。
可参看 MDN 的Web API 接口參考之 Window了解更多细节。
简单说来，就是上述“JavaScript 标准内置对象”中为全局函数的部分。简单列示如下：
| 函数 | 描述 |
|---|---|
| decodeURI() | 解码由 encodeURI 创建或其它流程得到的统一资源标识符（URI）。 |
| decodeURIComponent() | 解码由 encodeURIComponent 方法或者其它类似方法编码的部分统一资源标识符（URI）。 |
| encodeURI() | 特定字符的每个实例替换为一个、两个、三或四转义序列来对统一资源标识符 (URI) 进行编码。 |
| encodeURIComponent() | 通过将一个，两个，三个或四个表示字符的 UTF-8 编码的转义序列替换某些字符的每个实例来编码 URI。 |
| eval() | 将传入的字符串当做 JavaScript 代码进行执行。 |
| isFinite() | 判断被传入的参数值是否为一个有限数值。 |
| isNaN() | 确定一个值是否为 NaN 。 |
| parseFloat() | 解析一个参数（必要时先转换为字符串）并返回一个浮点数。 |
| parseInt(string,radix) | 解析一个字符串并返回指定基数的十进制整数， radix 是 2-36 之间的整数，表示被解析字符串的基数。。 |
| String() | 把对象的值转换为字符串(转型函数)。 |
| Number() | 把对象的值转换为数字(转型函数)。 |
| Boolean() | 把对象的值转换为布尔值(转型函数)。 |
包括：
- 像 undefined 、 NaN 和 Infinity 等特殊值都是 Global 对象的属性。
- 所有原生引用类型构造函数，比如 Object 和 Function ，也都是 Global 对象的属性。
简单说来，就是上述“JavaScript 标准内置对象”中为特殊值和大部分的内置对象。
| 属 性 | 说 明 |
|---|---|
| undefined | 特殊值 undefined |
| NaN | 特殊值 NaN |
| Infinity | 特殊值 Infinity |
| Object | Object 的构造函数 |
| Array | Array 的构造函数 |
| Function | Function 的构造函数 |
| Boolean | Boolean 的构造函数 |
| String | String 的构造函数 |
| Number | Number 的构造函数 |
| Date | Date 的构造函数 |
| RegExp | RegExp 的构造函数 |
| Symbol | Symbol 的伪构造函数(不能 new) |
| Error | Error 的构造函数 |
| EvalError | EvalError 的构造函数 |
| RangeError | RangeError 的构造函数 |
| ReferenceError | ReferenceError 的构造函数 |
| SyntaxError | SyntaxError 的构造函数 |
| TypeError | TypeError 的构造函数 |
| URIError | URIError 的构造函数 |
Math 是一个内置对象，它拥有一些数学常数属性和数学函数方法。Math 不是一个函数对象。
- 与其他全局对象不同的是，Math 不是一个构造器。Math 的所有属性与方法都是静态的。
Math 用于 Number 类型。它不支持 BigInt。
Math 对象上提供的计算要比直接在 JavaScript 实现的快得多，因为 Math 对象上的计算使用了 JavaScript 引擎中更高效的实现和处理器指令。
但使用 Math 计算的问题是精度会因浏览器、操作系统、指令集和硬件而异。
主要用于保存数学中的一些特殊值。
| 属 性 | 说 明 |
|---|---|
| Math.E | 欧拉常数，也是自然对数的底数，约等于 2.718。 |
| Math.LN2 | 2 的自然对数，约等于 0.693。 |
| Math.LN10 | 10 的自然对数，约等于 2.303。 |
| Math.LOG2E | 以 2 为底的 E 的对数，约等于 1.443。 |
| Math.LOG10E | 以 10 为底的 E 的对数，约等于 0.434。 |
| Math.PI | 圆周率，一个圆的周长和直径之比，约等于 3.14159。 |
| Math.SQRT1_2 | 二分之一 ½ 的平方根，同时也是 2 的平方根的倒数，约等于 0.707。 |
| Math.SQRT2 | 2 的平方根，约等于 1.414。 |
常用的方法列表
| 分类 | 属 性 | 说 明 |
|---|---|---|
| Math.min() | 返回零个或更多个数值的最小值。 | |
| Math.max() | 返回一组数中的最大值。 | |
| 舍入方法 | Math.ceil() | 返回大于或等于一个给定数字的最小整数(向上取整)。 |
| Math.floor() | 返回小于或等于一个给定数字的最大整数(向下取整)。 | |
| Math.round() | 返回一个数字四舍五入后最接近的整数(四舍五入)。 | |
| Math.fround() | 将任意的数字转换为离它最近的单精度（32 位）浮点数形式的数字。 | |
| 随机数 | Math.random() | 返回一个浮点数, 伪随机数在范围从 0 到小于 1，即[0,1)。 |
| 其他方法 | Math.abs(x) | 返回 x 的绝对值 |
| Math.exp(x) | 返回 Math.E 的 x 次幂 | |
| Math.expm1(x) | 等于 Math.exp(x) - 1 | |
| Math.log(x) | 返回 x 的自然对数 | |
| Math.log1p(x) | 等于 1 + Math.log(x) | |
| Math.pow(x, power) | 返回 x 的 power 次幂 | |
| Math.hypot(...nums) | 返回 nums 中每个数平方和的平方根 | |
| Math.clz32(x) | 返回 32 位整数 x 的前置零的数量 | |
| Math.sign(x) | 返回表示 x 符号的 1 、 0 、 -0 或 -1 | |
| Math.trunc(x) | 返回 x 的整数部分，删除所有小数 | |
| Math.sqrt(x) | 返回 x 的平方根 | |
| Math.cbrt(x) | 返回 x 的立方根 | |
| Math.acos(x) | 返回 x 的反余弦 | |
| Math.acosh(x) | 返回 x 的反双曲余弦 | |
| Math.asin(x) | 返回 x 的反正弦 | |
| Math.asinh(x) | 返回 x 的反双曲正弦 | |
| Math.atan(x) | 返回 x 的反正切 | |
| Math.atanh(x) | 返回 x 的反双曲正切 | |
| Math.atan2(y, x) | 返回 y/x 的反正切 | |
| Math.cos(x) | 返回 x 的余弦 | |
| Math.sin(x) | 返回 x 的正弦 | |
| Math.tan(x) | 返回 x 的正切 |
更多参看JavaScript 标准内置对象之 Math了解。
需要注意的是，三角函数 sin()、cos()、tan()、asin()、acos()、atan() 和 atan2() 返回的值是弧度而非角度。
若要转换，弧度除以 (Math.PI / 180) 即可转换为角度，同理，角度乘以这个数则能转换为弧度。
需要注意的是，很多 Math 函数都有一个精度，而且这个精度在不同实现中也是不相同的。这意味着不同的浏览器会给出不同的结果，甚至，在不同的系统或架构下，相同的 JS 引擎也会给出不同的结果！
JavaScript 中的对象称为引用值，几种内置的引用类型可用于创建特定类型的对象。
- 引用值与传统面向对象编程语言中的类相似，但实现不同。
- Date 类型提供关于日期和时间的信息，包括当前日期、时间及相关计算。
- RegExp 类型是 ECMAScript 支持正则表达式的接口，提供了大多数基础的和部分高级的正则表达式功能。
JavaScript 比较独特的一点是，函数实际上是 Function 类型的实例，也就是说函数也是对象。因为函数也是对象，所以函数也有方法，可以用于增强其能力。
由于原始值包装类型的存在，JavaScript 中的原始值可以被当成对象来使用。有 3 种原始值包装类型： Boolean 、 Number 和 String 。它们都具备如下特点：
- 每种包装类型都映射到同名的原始类型。
- 以读模式访问原始值时，后台会实例化一个原始值包装类型的对象，借助这个对象可以操作相应的数据。
- 涉及原始值的语句执行完毕后，包装对象就会被销毁。
当代码开始执行时，全局上下文中会存在两个内置对象： Global 和 Math 。
- 其中， Global 对象在大多数 ECMAScript 实现中无法直接访问。不过，浏览器将其实现为 window 对象。
- 所有全局变量和函数都是 Global 对象的属性。
- Math 对象包含辅助完成复杂计算的属性和方法。