Date

Date.now() 返回表示方法执行时日期和时间的毫秒数

1
Date.now() === new Date().getTime()  // -> true

Date.toLocaleString()
参数：

  • locales String or Array
  • options Object

options 属性及说明

属性 说明 可选值
weekday 星期 ‘narrow’:最短 S;’short’:缩写 Sun;’long’:长 Sunday
era 纪元 ‘narrow’:最短 A;’short’:缩写 AD;’long’:长 Anno Domini(公元，西元)
year 年 ‘2-digit’: 21年;’numeric’:2021年
month 月 ‘2-digit’: 09月;’numeric’:9月
day 日 ‘2-digit’: 09日;’numeric’:9日
hour 小时 ‘2-digit’: 下午03时;’numeric’:下午3时
hour12 小时 默认值:true，即使用12小时制。false为使用24小时制
minute 分钟 同年月日时
second 秒 同年月日时
timeZone 时区
timeZoneName 时区显示格式 ‘short’:短 ‘UTC’;’long’:长 ‘协调世界时’

toLocaleString()

语法：

1
dateObj.toLocaleString(locales,options)

返回值：根据当地语言规定返回代表着时间的字符串

1
2
3
4
5
6
// 没有指定语言环境（locale）时，返回一个使用默认语言环境和格式设置（options）的格式化字符串
const date = new Date()
date.toLocaleString() // '2021/9/17 下午3:04:46'
date.toLocaleString('en-US) // '9/17/2021, 3:06:02 PM'
// locales为数组时，默认使用第一个参数，如果第一个参数的语言不支持，则使用第二个，依此类推
date.toLocaleString(['abc','zh-CN']) // '2021/9/17 下午3:12:40'

日期格式化方法

方法 参数 返回值 类型
toDateString() 无 显示日期中的 周几、月、日、年（以美式英语的形式） 字符串
toTimeString() 无 显示日期中的时、分、秒和时区（以美式英语的形式） 字符串
toLocaleDateString() locales,options 返回指定语言环境(locale)和格式设置(options)的日期对象日期部分 字符串
toLocaleTimeString() locales,options 返回指定语言环境(locale)和格式设置(options)的日期对象时间部分 字符串
toUTCString() 无 返回使用UTC时区表示给定日期的字符串 字符串

日期格式化方法

RegExp

标记：

符号 说明
g 全局
i 不区分大小写
m 多行模式，表示查找到一行文本末尾时会继续查找
y 粘附模式，表示只查找从 lastIndex 开始及之后的字符串
u Unicode模式，启用 Unicode 匹配
s dotAll模式，表示元字符 . 匹配任何字符（包括 \n 或 \r ）s

元字符：

符号 说明
* 出现 0 或 多次
+ 出现 1 或 多次
? 出现 0 或 1 次
. 任意字符
- 如 a-z，表示从 a 到 z
^(出现在中括号的开头) 表示否定。如/[^2]/ 表示匹配不包含2的值
\w 等同于[A-Za-z0-9_]
\W 等同于[^A-Za-z0-9_]
\d 数字，等同于[0-9]
\D 非数字，等同于[^0-9]
\s 匹配空格、回车符、制表符、换行符和换页符，类似于[\r\t\n\v]
\S 不匹配空格、回车符、制表符、换行符和换页符，类似于[^\r\t\n\v]
() 检查字符组

？的问题：

1
2
3
4
5
6
7
8
9
10
11
// 懒惰匹配
let str = 'speeeeedeeeeedeeeeed'
str.match(/sp[a-z]*d/) // [speeeeedeeeeedeeeeed]
str.match(/sp[a-z]*?d/) // [speeeeed]

// 可选的
let amlj = 'color'
let brt = 'colour'
let regExp = /colou?r/
regExp.test(amlj) // true
regExp.test(brt) // true

先行断言：告诉 JavaScript 在字符串中向前查找的匹配模式。当想要在同一个字符串上搜寻多个匹配模式时，这可能非常有用

  • 正向先行断言：查看并确保搜索匹配模式中的元素存在，但实际上并不匹配。语法：(?=...)，其中 ... 就是需要存在但不会被匹配的部分
  • 负向先行断言：查看并确保搜索匹配模式中的元素不存在。语法：(?!...)，其中 ... 是希望不存在的匹配模式。如果负向先行断言部分不存在，将返回匹配模式的其余部分
1
2
3
4
5
6
7
8
9
10
11
12
13
14
let quit = "qu";
let noquit = "qt";
let quRegex= /q(?=u)/;
let qRegex = /q(?!u)/;
quit.match(quRegex);
noquit.match(qRegex);

// 3 到 6 个字符且至少包含一个数字
let password = "abc123";
let checkPass = /(?=\w{3,6})(?=\D*\d)/;
checkPass.test(password);

// 大于 5 个字符且有两个连续数字的密码
let regExp = /(?=\w{6,})(?=\D*\d{2})/

原始值包装类型

为了方便操作原始值，ECMAScript 提供了 3 种特殊的引用类型：Boolean、Number 和 String。每当用到某个原始值的方法或属性时，后台都会创建一个相应原始包装类型的对象，从而暴露出操作原始值的各种方法。例子：

1
2
let s1 = 'some'
let s2 = s1.substring(2)

原始值调用方法实现逻辑：当第二行访问 s1 时，是以 读模式 访问的，也就是要从内存中读取变量保存的值。在以读模式访问字符串值得任何时候，后台都会执行以下3步：
1、创建一个 String 类型的实例；
2、调用实例上的特定方法；
3、销毁实例。
相当于执行了如下3行代码：

1
2
3
let s1 = new String('some')
let s2 = s1.substring(2)
s1 = null

引用类型与原始值包装类型的主要区别在于对象的生命周期。在通过 new 实例化引用类型后，得到的实例会在离开作用域时被销毁，而自动创建的原始值包装对象则只存在于访问它的那行代码执行期间。这意味着不能在运行时给原始值添加属性和方法

在原始值包装类型的实例上调用 typeof 会返回 ‘object’

Object 构造函数作为一个工厂方法，能够根据传入值的类型返回相应原始值包装类型的实例

1
2
let obj = new Object('aaa') // 创建一个 String 的实例
obj instanceof String  // true

Boolean

Boolean 的实例会重写 valueOf() 方法，返回一个原始值 true 或 false。toString() 方法被调用时也会被覆盖，返回字符串 ‘true’ 或 ‘false’

Number

与 Boolean 类型一样，Number 类型重写了 valueOf()、toLocaleString() 和 toString() 方法。valueOf() 方法返回 Number 对象表示的原始数值，两外两个方法返回数值字符串。toString() 方法可选地接收一个表示基数的参数，并返回相应基数形式的数值字符串

除了继承的方法，Number 类型还提供了几个用于将数值格式化为字符串的方法：

  • toFixed() 返回包含指定小数点位数的数值字符串

toFixed() 方法可以表示有 0 ~ 20 个小数位的数值。某些浏览器可能支持更大的范围，但这是通常被支持的范围

  • toExponential() 返回包含指定小数点位数的以科学计数法（也称为指数计数法）表示的数值字符串
  • toPrecision() 会根据情况返回最合理的输出结果，可能是固定长度，也可能是科学计数法形式。该方法接收一个参数，表示结果中数字的总位数（不包含指数）。如果参数是一个非整数值，将会向下舍入到最接近的整数
1
2
3
4
let num = 99
console.log(num.toPrecision(1)) // 1e+2   因为99不能只用1位数字来表示，所以这个方法就将它舍入为100
console.log(num.toPrecision(2)) // 99
console.log(num.toPrecision(3)) // 99.0

本质上，toPrecision() 方法会根据数值和精度来决定调用 toFixed() 还是 toExponential()

toPrecision() 方法可以表示带 1~21 个小数位的数位

String

JavaScript 字符串使用了两种 Unicode 编码混合的策略：UCS-2 和 UTF-16。对于可以采用16位编码的字符（U+0000 ~ U+FFFF)，这两种编码实际上是一样的

UTF-16(16-bit Unicode Transformation Format) 是 UCS-2(2-byte Universal Character Set) 拓展，它可以表示BMP的字符。UTF-16 使用一个或者两个16位的码元来表示码位，这样就可以对0到0x10FFFF的码位进行编码

例如：在UCS-2和UTF-16中，BMP中的字符U+00A9 copyright sign（©）都被编码为0x00A9。
但是在BMP之外的字符，例如 𝌆，只能用UTF-16进行编码，使用两个16位码元来表示：0xD834 0xDF06。这被称为 代理对。一个代理对仅表示一个字符，而不是两个。UCS-2并没有代理对的概念，所以会将0xD834 0xDF06解释为两个字符。 —- 原文出处

1、JavaScript 字符
length、charAt()、charCodeAt()、fromCharCode()是基于16位码元完成操作的。16位只能唯一表示 65536 个字符，被称为 基本多语言平面（BMP）。为了表示更多的字符，Unicode 采用了一个策略，即每个字符使用另外16位去选择一个 增补平面。这种每个字符使用两个16位码元的策略称为 代理对

在涉及增补平面的字符时，上述字符串方法会出问题。如下例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// 笑脸表情的编码是 U+1F60A
// 0x1F60A === 128522
let message = 'ab😊de'

console.log(message.length) // 6
console.log(message.charAt(1)) // b
console.log(message.charAt(2)) // <?>
console.log(message.charAt(3)) // <?>
console.log(message.charAt(4)) // d

console.log(message.charCodeAt(1)); // 98 
console.log(message.charCodeAt(2)); // 55357 
console.log(message.charCodeAt(3)); // 56842 
console.log(message.charCodeAt(4)); // 100

console.log(String.fromCodePoint(0x1F60A)); // 😊

console.log(String.fromCharCode(97, 98, 55357, 56842, 100, 101)); // ab😊de

以上例子，fromCharCode() 方法仍然返回正确的结果，因为它实际上是基于提供的二进制表示直接组合成字符串。浏览器可以正确解析代理对（由两个码元构成），并正确的将其识别为一个 Unicode 笑脸字符

使用 codePointAt() 可以正确解析即包含单码元字符又包含代理对字符的字符串，该方法接收字符串的索引并返回该索引对应字符所对应的码点(code point)。码点是 Unicode 中一个字符的完整标识。

1
2
3
4
5
6
7
8
let message = "ab☺de";

message.length // -> 6

console.log(message.codePointAt(1)); // 98
console.log(message.codePointAt(2)); // 128522
console.log(message.codePointAt(3)); // 56842 --> 错误码点
console.log(message.codePointAt(4)); // 100

如果传入的码元索引并非代理对的开头，就会返回错误的码点。这种错误只有检测单个字符的时候才会出现，可以通过从左到右按正确的码元数遍历字符串来规避。迭代字符串可以智能的识别代理对的码点：

1
console.log([..."ab☺de"]); // ["a", "b", "☺", "d", "e"]

fromCodePoint() 接收任意数量的码点，返回对应字符串拼接起来的字符串：

1
2
console.log(String.fromCharCode(97, 98, 55357, 56842, 100, 101)); // ab☺de 
console.log(String.fromCodePoint(97, 98, 128522, 100, 101)); // ab☺de

2、normalize() 方法
某些字符串即有BMP字符表示，也有代理对表示，如：

1
2
3
4
5
6
7
// U+00C5：上面带圆圈的大写拉丁字母 A
console.log(String.fromCharCode(0x00C5)); // Å
// U+212B：长度单位“埃”
console.log(String.fromCharCode(0x212B)); // Å
// U+004：大写拉丁字母 A
// U+030A：上面加个圆圈
console.log(String.fromCharCode(0x0041, 0x030A)); // Å

而且这三个字符互不相等

1
2
3
4
5
6
7
8
9
let a1 = String.fromCharCode(0x00C5),
 a2 = String.fromCharCode(0x212B),
 a3 = String.fromCharCode(0x0041, 0x030A);

console.log(a1, a2, a3); // Å, Å, Å

console.log(a1 === a2); // false
console.log(a1 === a3); // false
console.log(a2 === a3); // fals

为了解决这种问题，Unicode 提供了4种规范化形式，可以将类似上面的字符规范为一致的格式，无论底层字符的代码是什么。这四种规范化形式是：NFD（Normalization Form D）、NFC（Normalization Form C）、NFKD（Normalization Form KD）和 NFKC（Normalization Form KC）。可以使用 normalize()方法对字符串应用上述规范化形式，使用时需要传入表示哪种形式的字符串：”NFD”、”NFC”、”NFKD”或”NFKC”
通过比较字符串与其调用 normalize() 的返回值，就可以知道该字符串是否已经规范化了

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
let a1 = String.fromCharCode(0x00C5),
 a2 = String.fromCharCode(0x212B),
 a3 = String.fromCharCode(0x0041, 0x030A);

// U+00C5 是对 0+212B 进行 NFC/NFKC 规范化之后的结果
console.log(a1 === a1.normalize("NFD")); // false
console.log(a1 === a1.normalize("NFC")); // true
console.log(a1 === a1.normalize("NFKD")); // false
console.log(a1 === a1.normalize("NFKC")); // true

// U+212B 是未规范化的
console.log(a2 === a2.normalize("NFD")); // false
console.log(a2 === a2.normalize("NFC")); // false
console.log(a2 === a2.normalize("NFKD")); // false
console.log(a2 === a2.normalize("NFKC")); // false

// U+0041/U+030A 是对 0+212B 进行 NFD/NFKD 规范化之后的结果
console.log(a3 === a3.normalize("NFD")); // true
console.log(a3 === a3.normalize("NFC")); // false
console.log(a3 === a3.normalize("NFKD")); // true
console.log(a3 === a3.normalize("NFKC")); // false

// 选择同一种规范化形式可以让比较操作符返回正确的结果：
let a1 = String.fromCharCode(0x00C5),
 a2 = String.fromCharCode(0x212B),
 a3 = String.fromCharCode(0x0041, 0x030A);

console.log(a1.normalize("NFD") === a2.normalize("NFD")); // true
console.log(a2.normalize("NFKC") === a3.normalize("NFKC")); // true
console.log(a1.normalize("NFC") === a3.normalize("NFC")); // true

3、字符串操作方法

1
2
3
4
5
6
7
8
9
slice(m,n) // 从索引m开始，到索引n结束（不包括n）
substr(m,n) // 从索引m开始，截取n个
substring(m,n) // 从索引m开始，到索引n结束（不包括n）
// 返回新字符串，且都不修改原始字符串

// 当传入的参数为负数时
slice() // 负数值会被替换为 负数值+字符串长度
substr() // 第一个负数值换为 负数值+字符串长度，第二个换为 0
substring() // 所有负数值都换为0。如果m>n，则调换位置

4、字符串包含方法
startsWith()：判断当前字符串是否以给定的字符串开头，返回 true 或 false

1
2
3
4
5
6
const str = 'foobarbaz';

console.log(str.startsWith('foo')) // true

// 该方法支持第二个参数，表示搜索开始的位置，默认值为0
console.log(str.startsWith('foo',1)) // false

endsWith()：判断当前字符串是否以给定的字符串结尾，返回 true 或 false

1
2
3
4
5
6
const str = 'foobarbaz'

console.log(str.endsWith('baz')) // true

// 该方法支持第二个参数，表示 str 的长度，默认值为 str.length
console.log(str.endsWith('baz',6)) // false str的长度为6，即str='foobar'

includes()：判断一个字符串是否包含在另一个字符串种，返回 true 或 false

1
2
3
4
5
6
7

const str = 'foobarbaz'

console.log(str.includes('bar')) // true

// 该方法支持第二个参数，从指定索引的位置开始搜寻，默认值为0
console.log(str.includes('bar',4)) // false

以上三个方法都区分大小写

5、repeat()
接收一个整数参数，表示要将字符串复制多少次，然后返回拼接所有副本后的结果

1
2
3
4
5
let str = 'an'
console.log(str.repeat(5) + ' banana') // 'ananananan banana'

// 参数值应介于 0 和 +Infinity 之间
console.log(str.repeat(-2)) // Uncaught RangeError: Invalid count value

6、padStart() 和 padEnd()
用给定的字符串填充当前字符串（如果需要的话，会重复多次），以便产生的字符串达到给定的长度。从左侧（start）或者右侧（end）开始填充

语法：

1
2
str.padStart(length, padString)
str.padEnd(length, padString)

参数：
length：指定的长度。如果这个长度小于当前字符串的长度，则返回当前字符串本身
padString：填充的字符串。如果填充的字符串长度超过了需要的长度，则将其截断以匹配指定长度。默认值为 ‘’(U+0020 空字符串)

返回值：
形成的新字符串

1
2
3
4
let str = 'abc'
str.padStart(10) // '       abc'
str.padEnd(10,'foo') // 'abcfoofoof'
str.padStart(1) // 'abc'

7、字符串迭代与解构
字符串原型上暴露了一个 [Symbol.iterator]() 方法，表示可以迭代字符串的每个字符

可以使用 for-of 迭代，也可以使用解构操作符来解构

1
2
3
4
5
6
7
8
9
10
11
for (const c of "abcde") {
    console.log(c)
}
// a
// b
// c
// d
// e

let message = "abcde";
console.log([...message]); // ["a", "b", "c", "d", "e"]

8、字符串模式匹配方法
1、match()
语法：

1
str.match(str|RegExp)

参数：
字符串或者正则表达式

返回值：
返回一个数组：第一个元素是与整个模式匹配的字符串，其余元素是与表达式种的捕获组匹配的字符串（如果有的话）

1
2
3
4
5
6
7
8
9
10
11
let text = "cat, bat, sat, fat"
let res = text.match('at')
console.log(res) // ['at', index: 1, input: 'cat, bat, sat, fat', groups: undefined]
console.log(res.length) // 1
console.log(res.index) // 1

let res2 = text.match(/.at/) // .表示可以是任意字符
console.log(res2) // ['cat', index: 0, input: 'cat, bat, sat, fat', groups: undefined]

let res3 = text.match(/.at/g)
console.log(res3) // ['cat', 'bat', 'sat', 'fat']

2、search()
语法：

1
str.search(str|RegExp)

参数：
同 match()

返回值：
返回第一个匹配的位置索引，没找到则返回 -1

1
2
3
let text = "cat, bat, sat, fat";
let pos = text.search(/at/);
console.log(pos); // 1

3、replace()
语法：

1
str.replace(str|RegExp, str|function)

参数：
第一个参数可以是一个字符串或者正则表达式；第二个参数可以是一个字符串或者函数

返回值：
返回一个替换后的新字符串，不改变原字符串

  • 不使用正则的情况下，每次执行只能替换一个字符，返回替换后的新字符串；正则加全局（g），可以替换所有匹配的字符
  • 如果第二个参数是函数，函数执行多少次取决于捕获多少次，每次执行的 arguments 包含三项：匹配的字符、匹配项在字符串中的索引，原字符串，return 返回的结果就是当前此次捕获替换的内容
  • 第二个参数是字符串的情况下，下表中的特殊字符串序列，可以用来插入正则表达式操作的值
字符序列 替换文本
$$ $
$& 插入匹配的子串
$’ 插入当前匹配的子串右边的内容。与 RegExp.rightContext 相同
$` 插入当前匹配的子串左边的内容。与 RegExp.leftContext 相同
$n 假如第一个参数是正则对象，并且n是小于100的非负整数，那么插入第n个括号匹配的字符串。提示：索引是从1开始，如果不存在第n个分组，那么将会把匹配到的内容替换为字面量。比如不存在第3个分组，就会用 $3 替换匹配到的内容
$ Name是一个分组名称。如果在正则表达式中不存在分组（或者没有匹配），这个变量将被处理为空字符串。只有在支持命名分组捕获的浏览器中才能使用 
1
2
3
4
5
6
7
8
9
var re = /(\w+)\s(\w+)/;
var str = "John Smith";
var newstr = str.replace(re, "$2, $1");
// Smith, John

var str = '20151213';
var ary = ['零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖', ];
str = str.replace(/\d/g, (...params) => ary[params[0]])
console.log(str) // 贰零壹伍壹贰壹叁

9、localeCompare()
返回一个数字（-1、0、1）来指示传入的字符串是否排在该字符串之前（1）、之后（-1）或相同（0）

1
2
3
4
let str = 'yellow'
str.localeCompare('blue') // 1
str.localeCompare('zoo') // -1
str.localeCompare('yellow') // 0

该方法也支持 locales 和 options 参数，详见 -> MDN

单例内置对象

任何由 ECMAScript 实现提供、与宿主环境无关，并在 ECMAScript 程序开始执行时就存在的对象称为 内置对象

Global

Global 对象是 ECMAScript 中最特别的对象，因为代码不会显式地访问它。ECMA-262 规定 Global 对象为一种兜底对象。在全局作用域中定义的变量和函数都会变成 Global 对象的属性。isNaN()、isFinite()、parseInt()、parseFloat() 都是 Global 对象的方法。除了这些，还有另外的方法：

1、URL编码方法
encodeURI() & decodeURI()：编/解码统一资源标识符（URI），不会编/解码属于 URL 组件的特殊字符，比如冒号、斜杠、问号、井号

encodeURIComponent() & decodeURIComponent()：编/解码统一资源标识符（URI），会编码它发现的所有非标准字符

1
2
3
4
5
6
7
8
9
10
let url = "http://www.wrox.com/illegal value.js#start"

encodeURI(url) // 'http://www.wrox.com/illegal%20value.js#start'  仅对 空格 进行了编码
encodeURIComponent(url) // 'http%3A%2F%2Fwww.wrox.com%2Fillegal%20value.js%23start' 冒号 斜杠 空格 井号 都进行了编码


let url2 = 'http%3A%2F%2Fwww.wrox.com%2Fillegal%20value.js%23start'

decodeURI(url2) // 'http%3A%2F%2Fwww.wrox.com%2Fillegal value.js%23start' 仅对 空格 进行了解码
decodeURIComponent(url2) // 'http://www.wrox.com/illegal value.js#start' 对 冒号 斜杠 空格 井号 都进行了解码

2、eval()

eval() 方法是一个完整的 ECMAScript 解释器，它接收一个参数，即一个要执行的 ECMAScript（JavaScript）字符串

当解释器发现 eval() 调用时，会将参数解释为实际的 ECMAScript 语句，然后将其插入到该位置。通过 eval() 执行的代码属于该调用所在上下文，被执行的代码与该上下文拥有相同的作用域链

通过 eval() 定义的任何变量和函数都不会被提升，这是因为 eval() 中的字符串只是在 eval() 执行的时候才会被创建

严格模式下，在 eval() 内部创建的变量和函数无法被外部访问，赋值给 eval() 也会报错

3、Global对象属性

Global 对象有很多属性，像 undefined、NaN、Infinity 等特殊值都是 Global 对象的属性。此外，所有原生引用类型构造函数，也都是 Global 对象的属性。下表列出了所有这些属性：

属性 说明
undefined 特殊值 undefined
NaN 特殊值 NaN
Infinity 特殊值 Infinity
Object Object 的构造函数
Array Array 的构造函数
Function Function 的构造函数
Boolean Boolean 的构造函数
String String 的构造函数
Number Number 的构造函数
Date Date 的构造函数
RegExp RegExp 的构造函数
Symbol Symbol 的构造函数
Error Error 的构造函数
EvalError EvalError 的构造函数
RangeError RangeError 的构造函数 当一个值不在其所允许的范围或者集合中时，会抛出此错误
ReferenceError ReferenceError 的构造函数 引用错误
SyntaxError SyntaxError 的构造函数 语法错误
TypeError TypeError 的构造函数 类型错误
URIError URIError 的构造函数 表示以一种错误的方式使用全局URI处理函数而产生的错误。当向全局 URI 处理函数传递一个不合法的URI时，URIError 错误会被抛出

4、window 对象
虽然 ECMAScript-262 没有规定直接访问 Global 对象的方式，但浏览器将 window 对象实现为 Global 对象的代理

也可以通过另一种方法获取到 Global 对象

1
2
3
let global = function fn(){
    return this
}()

Math

Math 对象上提供的计算要比直接在 JavaScript 实现的快得多，因为 Math 对象上的计算使用了 JavaScript 引擎中更高效的实现和处理器指令。但使用 Math 计算的问题是精度会因浏览器、操作系统、指令集和硬件而异

1、Math 对象
下表列出了 Math 对象上主要用于保存数学中的一些特殊值的属性

属性 说明
Math.E 自然对数的基数 e 的值
Math.LN10 10 为底的自然对数
Math.LN2 2 为底的自然对数
Math.LOG2E 以 2 为底 e 的对数
Math.LOG10E 以 10 为底 e 的对数
Math.PI Π 的值
Math.SQRT_2 1/2 的平方根
Math.SQRT2 2 的平方根

2、舍入方法

  • Math.ceil()：向上取整
  • Math.floor()：向下取整
  • Math.round()：四舍五入
  • Math.fround()：返回数值最接近的单精度（32位）浮点值表示 –> MDN

3、其他方法

方法 说明
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)、-0(负0)、-1(负数)或 NaN。传入的参数会被隐士转换为数字类型
Math.trunc(x) 返回 x 的整数部分，删除所有小数
Math.sqrt(x) 返回 x 的平方根
Math.chrt(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 的正切

即便这些方法都是由 ECMA-262 定义的，对正弦、余弦、正切等计算的实现仍然取决于浏览器，因此，这些方法的精度可能因实现而异

小结

当代码开始执行时，全局上下文中会存在两个内置对象：Global 和 Math。其中 Global 对象在大多数 ECMAScript 实现中无法直接访问。不过，浏览器将其实现为 window 对象。所有全局变量和函数都是 Global 对象的属性。Math 对象包含辅助完成复杂计算的属性和方法