OneYoung

Appearance

1.Math静态属性 ​

Math 是一个内置对象，它拥有一些数学常数属性和数学函数方法。Math 不是一个函数对象。

Math 用于 Number 类型。它不支持 BigInt。

TIP

与其他全局对象不同的是，Math 不是一个构造器。

Math 的所有属性与方法都是静态的。

js
// Uncaught TypeError: Math is not a constructor
new Math()

Math.E ​

Math.E 属性表示自然对数的底数（或称为基数）e，约等于 2.718。

Math.E=e≈2.718

Math.LN2 ​

Math.LN2 属性表示 2 的自然对数，约为 0.693：

Math.LN2=ln(2)≈0.693

MATH.LN10 ​

Math.LN10 属性表示 10 的自然对数，约为 2.302：

Math.LN10=ln(10)≈2.302

Math.LOG2E ​

Math.LOG2E 属性表示以 2 为底数，e 的对数，约为 1.442：

Math.LOG2E=log2(e)≈1.442

Math.LOG10E ​

Math.LOG10E 属性表示以 10 为底数，e 的对数，约为 0.434：

Math.LOG10E=log10(e)≈0.434

Math.SQRT1_2 ​

Math.SQRT1_2 属性表示 1/2 的平方根，约为 0.707：

Math.SQRT1_2=√2/2≈0.707

Math.SQRT2 ​

Math.SQRT2 属性表示 2 的平方根，约为 1.414：

Math.SQRT2≈1.414

Math.PI ​

Math.PI 表示一个圆的周长与直径的比例，约为 3.1415926：

Math.PI=π≈3.1415926

2.Math静态方法 ​

Math.sin() ​

Math.sin() 函数返回一个数值的正弦值。

sin 方法返回一个 -1 到 1 之间的数值，表示给定角度（单位：弧度）的正弦值。

js
Math.sin(0)           // 0
Math.sin(1)           // 0.8414709848078965

Math.sin(Math.PI / 2) // 1

Math.cos() ​

Math.cos() 函数返回一个数值的余弦值。

js
Math.cos(0)           // 1
Math.cos(1)           // 0.5403023058681398

Math.cos(Math.PI)     // -1
Math.cos(2 * Math.PI) // 1

Math.tan() ​

Math.tan() 方法返回一个数值的正切值。

js
console.log(Math.tan(0))       // 0
console.log(Math.tan(Math.PI)) // -1.2246467991473532e-16

Math.asin() ​

Math.asin() 方法返回一个数值的反正弦（单位为弧度）。

Math.asin(x)

asin 方法接受 -1 到 1 之间的数值作为参数。如果接受的参数值超出范围，则返回 NaN。

js
Math.asin(-2)  // NaN
Math.asin(-1)  // -1.5707963267948966 (-pi/2)
Math.asin(0)   // 0
Math.asin(0.5) // 0.5235987755982989
Math.asin(1)   // 1.570796326794897 (pi/2)
Math.asin(2)   // NaN

Math.acos() ​

Math.acos() 返回一个数的反余弦值（单位为弧度）。

Math.acos(x)

acos 方法以 -1 到 1 的一个数为参数，返回一个 0 到 pi （弧度）的数值。

如果传入的参数值超出了限定的范围，将返回 NaN。

js
Math.acos(-2)  // NaN
Math.acos(-1)  // 3.141592653589793
Math.acos(0)   // 1.5707963267948966
Math.acos(0.5) // 1.0471975511965979
Math.acos(1)   // 0
Math.acos(2)   // NaN

Math.atan() ​

Math.atan() 函数返回一个数值的反正切（以弧度为单位）。

Math.atan(x)

js
Math.atan(1)  // 0.7853981633974483
Math.atan(0)  // 0

Math.abs() ​

Math.abs(x) 函数返回指定数字 x 的绝对值。

js
Math.abs('-1')     // 1
Math.abs(-2)       // 2
Math.abs(null)     // 0
Math.abs("string") // NaN
Math.abs()         // NaN

Math.log() ​

Math.log() 函数返回一个数的自然对数。

js
Math.log(-1) // NaN, out of range
Math.log(0)  // -Infinity
Math.log(1)  // 0
Math.log(10) // 2.302585092994046

Math.log2() ​

Math.log2() 函数返回一个数字以 2 为底的对数。

js
Math.log2(2)     // 1
Math.log2(1024)  // 10
Math.log2(1)     // 0
Math.log2(0)     // -Infinity
Math.log2(-2)    // NaN
Math.log2("1024")// 10
Math.log2("foo") // NaN

Math.log10() ​

Math.log10() 函数返回一个数字以 10 为底的对数。

js
Math.log10(10)   // 1
Math.log10(100)  // 2
Math.log10("100")// 2
Math.log10(1)    // 0
Math.log10(0)    // -Infinity
Math.log10(-2)   // NaN
Math.log10("foo")// NaN

Math.sqrt() ​

Math.sqrt() 函数返回一个数的平方根。

js
Math.sqrt(9) // 3
Math.sqrt(2) // 1.414213562373095

Math.sqrt(1)  // 1
Math.sqrt(0)  // 0
Math.sqrt(-1) // NaN
Math.sqrt(-0) // -0

Math.cbrt() ​

Math.cbrt() 函数返回一个数的立方根。

js
Math.cbrt(NaN) // NaN
Math.cbrt(-1) // -1
Math.cbrt(-0) // -0
Math.cbrt(-Infinity) // -Infinity
Math.cbrt(0) // 0
Math.cbrt(1) // 1
Math.cbrt(Infinity) // Infinity
Math.cbrt(null) // 0
Math.cbrt(2)  // 1.2599210498948734

Math.pow() ​

幂运算。

Math.pow() 函数返回基数（base）的指数（exponent）次幂，即 base^exponent。

Math.pow(base, exponent)

js
console.log(Math.pow(7, 3))
// expected output: 343

console.log(Math.pow(4, 0.5))
// expected output: 2

console.log(Math.pow(7, -2))
// expected output: 0.02040816326530612
// 即(1/49)

console.log(Math.pow(-7, 0.5))
// expected output: NaN

Math.min() ​

Math.min() 返回零个或更多个数值的最小值。

js
console.log(Math.min(1, 3, 2))
// expected output: 1

console.log(Math.min(-1, -3, -2))
// expected output: -3

const array1 = [1, 3, 2]
console.log(Math.min(...array1))
// expected output: 1

Math.max() ​

Math.max() 函数返回一组数中的最大值。

js
console.log(Math.max(1, 3, 2))
// expected output: 3

console.log(Math.max(-1, -3, -2))
// expected output: -1

const array1 = [1, 3, 2]
console.log(Math.max(...array1))
// expected output: 3

Math.ceil() ​

ceil 意为天花板。顾名思义，向上取整。

Math.ceil() 函数返回大于或等于一个给定数字的最小整数。

js
console.log(Math.ceil(.95))
// expected output: 1
console.log(Math.ceil(4))
// expected output: 4
console.log(Math.ceil(7.004))
// expected output: 8
console.log(Math.ceil(-7.004))
// expected output: -7

Math.floor() ​

floor 意为地板。顾名思义，向下取整。

Math.floor() 返回小于或等于一个给定数字的最大整数。

js
Math.floor( 45.95)
// 45
Math.floor( 45.05)
// 45
Math.floor( 4 )
// 4
Math.floor(-45.05)
// -46
Math.floor(-45.95)
// -46

Math.round() ​

Math.round() 函数返回一个数字四舍五入后最接近的整数。

Math.round(x)

js
console.log(Math.round(20.49))    //20
console.log(Math.round(20.5))     //21
console.log(Math.round(-20.5))    //-20
console.log(Math.round(-20.51))   //-21

Math.random() ​

Math.random() 函数返回一个浮点型伪随机数字。范围在 [0, 1) 之间。

Math.sign() ​

Math.sign() 函数返回一个数字的符号, 指示数字是正数，负数还是零。

js
Math.sign(3)     //  1
Math.sign(-3)    // -1
Math.sign("-3")  // -1
Math.sign(0)     //  0
Math.sign(-0)    // -0
Math.sign(NaN)   // NaN
Math.sign("foo") // NaN
Math.sign()      // NaN

Math.trunc() ​

Math.trunc() 方法会将数字的小数部分去掉，只保留整数部分。

Math.trunc(value)

传入该方法的参数会被隐式转换成数字类型。

js
Math.trunc(13.37)    // 13
Math.trunc(42.84)    // 42
Math.trunc(0.123)    //  0
Math.trunc(-0.123)   // -0
Math.trunc("-1.123") // -1
Math.trunc(NaN)      // NaN
Math.trunc("foo")    // NaN
Math.trunc()         // NaN

3.window上的相关方法 ​

parseInt ​

window.parseInt() 解析一个字符串并返回指定基数的十进制整数。

parseInt(string, radix)

  • string: 目标解析字符串。如果参数不是一个字符串，则将其转换为字符串(使用 ToString 抽象操作)。字符串开头的空白符将会被忽略。
  • radix: 2 - 36 之间的整数，表示被解析字符串的基数。默认值并不是 10。

TIP

如果 radix 是 undefined、0 或未指定的，JavaScript 会假定以下情况：

  1. 如果目标解析字符串 string 以 0x 或 0X 开头，那么 radix 被假定为 16，字符串的其余部分被当做十六进制数去解析。
  2. 如果目标解析字符串 string 以 0 开头，radix 被假定为 8（八进制）或 10（十进制）。具体选择哪一个 radix 取决于实现。ECMAScript 5 澄清了应该使用 10 (十进制)，但不是所有的浏览器都支持。因此，在使用 parseInt 时，一定要指定一个 radix。
  3. 如果如果目标解析字符串 string 以任何其他值开头，radix 是 10 (十进制)。
js
// 以下例子的返回值均是 15
parseInt('0xF', 16)
parseInt('F', 16)
parseInt('17', 8)
parseInt(021, 8)
// parseInt(015, 8) 返回 13
parseInt('015', 10) 
parseInt(15.99, 10)
parseInt('15,123', 10)
parseInt('FXX123', 16)
parseInt('1111', 2)
parseInt('15 * 3', 10)
parseInt('15e2', 10)
parseInt('15px', 10)
parseInt('12', 13)

parseFloat ​

window.parseFloat() 函数解析一个参数（必要时先转换为字符串）并返回一个浮点数。

parseFloat(string)

  1. 如果 parseFloat 在解析过程中遇到了正号（+）、负号（-）、数字（0-9）、小数点（.）、或者科学记数法中的指数（e 或 E）以外的字符，则它会忽略该字符以及之后的所有字符，返回当前已经解析到的浮点数。
  2. 第二个小数点的出现也会使解析停止（在这之前的字符都会被解析）。
  3. 参数首位和末位的空白符会被忽略。
  4. 如果参数字符串的第一个字符不能被解析成为数字,则 parseFloat 返回 NaN。
  5. parseFloat 也可以解析并返回 Infinity。
  6. parseFloat 解析 BigInt 为 Numbers, 丢失精度。因为末位 n 字符被丢弃。
js
// 以下例子均返回 3.14
parseFloat(3.14)
parseFloat('3.14')
parseFloat('  3.14  ')
parseFloat('314e-2')
parseFloat('0.0314E+2')
parseFloat('3.14some non-digit characters')
parseFloat({ toString: function() { return "3.14" } })

Number ​

Number 是内置对象。

它本身挂载了一些静态属性和静态方法。

Number 也可以当做构造函数或者普通函数来使用。

js
// 构造函数
var a = new Number('123')
console.log(a) // Number {123}
// 普通函数（通常可用作类型转换）
var b = Number('123')
console.log(b) // 123
console.log(a === b) // false

4.Number静态属性 ​

Number.EPSILON ​

Number.EPSILON 是 Es6 中的新增属性。

TIP

单词 EPSILON 的英语发音为 /epsilon/，中文音译为艾普西龙。

它指的是第五个希腊字母 ε，而 ε 在数学中有一种含义表示非常小。

Number.EPSILON 属性表示 1 与 Number 可表示的大于 1 的最小的浮点数之间的差值。

由于 JavaScript 采用的是 IEEE754 规定的双精度64位浮点数，而对于 64 位浮点数来说，大于 1 的最小浮点数为 1.00..001，小数点后面有连续的 51 个 0，这个值减去 1 之后，就等于 2 的 -52 次方。

js
console.log(Number.EPSILON)                      // 2.220446049250313e-16

console.log(Number.EPSILON.toFixed(20))          // 0.00000000000000022204

console.log(Number.EPSILON === Math.pow(2, -52)) // true

Number.EPSILON 实际上是 JavaScript 能够表示的最小精度。

当计算过程中的数字出现比该精度还小的精度，计算就会出现误差：

js
console.log(0.1 + 0.2 - 0.3)               // 5.551115123125783e-17

console.log((0.1 + 0.2 - 0.3).toFixed(20)) // 0.00000000000000005551

很明显，0.00000000000000005551 小于精度 0.00000000000000022204。

这也是为什么 0.1 + 0.2 不等于 0.3 的原因。出现了精度丢失。

Number.MIN_VALUE ​

Number.MIN_VALUE 属性表示在 JavaScript 里所能表示的最小正值。

MIN_VALUE 属性是 JavaScript 里最接近 0 的正值，而不是最小的负值。

MAX_VALUE 属性值接近于 5e-324。

js
console.log(Number.MIN_VALUE) // 5e-324

Number.MAX_VALUE ​

Number.MAX_VALUE 属性表示在 JavaScript 里所能表示的最大数值。

MAX_VALUE 属性值接近于 1.79E+308。

js
console.log(Number.MAX_VALUE) // 1.7976931348623157e+308

WARNING

大于 MAX_VALUE 的值代表 Infinity。

MDN 上的这句话并不严谨。可参考为什么Number.MAX_VALUE+1不是Infinity

TIP

Number.MAX_VALUE 代表的是 JavaScript 的最大表示数值。

而 Number.MAX_SAFE_INTEGER 代表的是 JavaScript 的最大正确计算整数值。

这二者并不冲突。

Number.MIN_SAFE_INTEGER ​

Number.MIN_SAFE_INTEGER 常量代表在 JavaScript 中最小安全整数 (-(2^53 - 1))。

JavaScript 的数字存储使用的是 IEEE754 规定的双精度64位浮点数标准，该标准的数值范围即是 [-(2^53 - 1), 2^53 - 1]。

js
console.log(Number.MIN_SAFE_INTEGER) // -9007199254740991

console.log(-(Math.pow(2, 53) - 1))  // -9007199254740991

Number.MAX_SAFE_INTEGER ​

Number.MAX_SAFE_INTEGER 常量表示在 JavaScript 中的最大安全整数（maxinum safe integer)（2^53 - 1）。

JavaScript 的数字存储使用的是 IEEE754 规定的双精度64位浮点数标准，该标准的数值范围即是 [-(2^53 - 1), 2^53 - 1]。

js
console.log(Number.MAX_SAFE_INTEGER) // 9007199254740991

console.log(Math.pow(2, 53) - 1)     // 9007199254740991

另外，最大安全整数的含义是指 JavaScript 能够正确区分、计算的最大整数。

js
// 下述表达式在数学角度明显是错误的，但由于计算范围已经超越了 `JS` 的最大计算能力，所以结果是 true。

console.log(Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2 ) // true

Number.NEGATIVE_INFINITY ​

Number.NEGATIVE_INFINITY 属性表示负无穷大。

Number.NEGATIVE_INFINITY 的值和全局对象的 Infinity 属性的负值相同。

js
console.log(Number.NEGATIVE_INFINITY === -Infinity) // true

该值的行为同数学上的无穷大（infinity）有一点儿不同：

  • 任何正值，包括 POSITIVE_INFINITY，乘以 NEGATIVE_INFINITY 为 NEGATIVE_INFINITY。
  • 任何负值，包括 NEGATIVE_INFINITY，乘以 NEGATIVE_INFINITY 为 POSITIVE_INFINITY。
  • 0 乘以 NEGATIVE_INFINITY 为 NaN。
  • NaN 乘以 NEGATIVE_INFINITY 为 NaN。
  • NEGATIVE_INFINITY 除以任何负值（除了 NEGATIVE_INFINITY）为 POSITIVE_INFINITY。
  • NEGATIVE_INFINITY 除以任何正值（除了 POSITIVE_INFINITY）为 NEGATIVE_INFINITY。
  • NEGATIVE_INFINITY 除以 NEGATIVE_INFINITY 或 POSITIVE_INFINITY 是 NaN。
  • 任何数除以 NEGATIVE_INFINITY 为 0。

Number.POSITIVE_INFINITY ​

Number.POSITIVE_INFINITY 属性表示正无穷大。

Number.POSITIVE_INFINITY 的值同全局对象 Infinity 属性的值相同。

js
console.log(Number.POSITIVE_INFINITY === Infinity) // true

该值的表现同数学上的无穷大有点儿不同：

  • 任何正值，包括 POSITIVE_INFINITY，乘以 POSITIVE_INFINITY 为 POSITIVE_INFINITY。
  • 任何负值，包括 NEGATIVE_INFINITY，乘以 POSITIVE_INFINITY 为 NEGATIVE_INFINITY。
  • 0 乘以 POSITIVE_INFINITY 为 NaN。
  • NaN 乘以 POSITIVE_INFINITY 为 NaN。
  • POSITIVE_INFINITY 除以 NEGATIVE_INFINITY 以外的任何负值为 NEGATIVE_INFINITY。
  • POSITIVE_INFINITY 除以 POSITIVE_INFINITY 以外的任何正值为 POSITIVE_INFINITY。
  • POSITIVE_INFINITY 除以 NEGATIVE_INFINITY 或 POSITIVE_INFINITY 为 NaN。
  • 任何数除以 POSITIVE_INFINITY 为 0。

Number.NaN ​

Number.NaN 表示非数字（Not-A-Number）。和 NaN 相同。

js
console.log(typeof(Number.NaN)) // 'number'

console.log(Number.NaN === NaN) // false

5.Number静态方法 ​

Number.isFinite() ​

Number.isFinite() 方法用来检测传入的参数是否是一个有穷数。

Number.isFinite(value)

  • value：number 类型。非 number 类型不会进行隐式转换。
js
console.log(Number.isFinite(Infinity)) // false

console.log(Number.isFinite(1 / 0))    // false

console.log(Number.isFinite(1 / 1))    // true

TIP

和全局的 isFinite() 函数相比，这个方法不会强制将一个非数值的参数转换成数值。

这就意味着，只有数值类型的值，且是有穷的（finite），才返回 true。

js
console.log(Number.isFinite(1))   // true

console.log(Number.isFinite('1')) // false

Number.isInteger() ​

Number.isInteger() 方法用来判断给定的参数是否为整数。

Number.isInteger(value)

  • value：number 类型。非 number 类型不会进行隐式转换。
js
console.log(Number.isInteger('1'))      // false

console.log(Number.isInteger(1))        // true

console.log(Number.isInteger(Math.PI))  // false

Number.isNaN() ​

Number.isNaN() 方法确定传递的值是否为 NaN，并且检查其类型是否为 Number。

js
Number.isNaN(NaN);        // true
Number.isNaN(Number.NaN); // true
Number.isNaN(0 / 0)       // true

// 下面这几个如果使用全局的 isNaN() 时，会返回 true。
Number.isNaN("NaN");      // false，字符串 "NaN" 不会被隐式转换成数字 NaN。
Number.isNaN(undefined);  // false
Number.isNaN({});         // false
Number.isNaN("blabla");   // false

// 下面的都返回 false
Number.isNaN(true);
Number.isNaN(null);
Number.isNaN(37);
Number.isNaN("37");
Number.isNaN("37.37");
Number.isNaN("");
Number.isNaN(" ");

TIP

在 JavaScript 中，NaN 最特殊的地方就是，我们不能使用相等运算符 == 和 === 来判断一个值是否是 NaN，因为 NaN == NaN 和 NaN === NaN 都会返回 false。因此，必须要有一个判断值是否是 NaN 的方法。

和全局函数 isNaN() 相比，Number.isNaN() 不会自行将参数转换成数字，只有在参数是值为 NaN 的数字时，才会返回 true。

Number.isSafeInteger() ​

Number.isSafeInteger() 方法用来判断传入的参数值是否是一个安全整数（safe integer）。

js
Number.isSafeInteger(3);                    // true
Number.isSafeInteger(Math.pow(2, 53))       // false
Number.isSafeInteger(Math.pow(2, 53) - 1)   // true
Number.isSafeInteger(NaN);                  // false
Number.isSafeInteger(Infinity);             // false
Number.isSafeInteger("3");                  // false
Number.isSafeInteger(3.1);                  // false
Number.isSafeInteger(3.0);                  // true

Number.parseInt() ​

Number.parseInt() 方法依据指定基数 radix，把字符串 string 解析成整数。

TIP

这个方法和全局的 parseInt() 函数具有一样的函数功能。

ECMAScript 6添加了这部分 (其目的是对全局变量进行模块化)。

js
console.log(Number.parseInt === parseInt) // true

可见window.parseInt

Number.parseFloat() ​

Number.parseFloat() 方法可以把一个字符串解析成浮点数。

TIP

这个方法和全局的 parseFloat() 函数具有一样的函数功能。

ECMAScript 6添加了这部分 (其目的是对全局变量进行模块化)。

js
console.log(Number.parseFloat === parseFloat) // true

可见window.parseFloat

6.Number原型方法 ​

number.toPrecision() ​

toPrecision() 方法以指定的精度返回该数值对象的字符串表示。

numObj.toPrecision(precision)

js
var numObj = 5.123456;
console.log(numObj.toPrecision());  //输出 5.123456
console.log(numObj.toPrecision(5)); //输出 5.1235
console.log(numObj.toPrecision(2)); //输出 5.1
console.log(numObj.toPrecision(1)); //输出 5

// 注意：在某些情况下会以指数表示法返回
console.log((1234.5).toPrecision(2)); // "1.2e+3"

number.toExponential() ​

toExponential() 方法以指数表示法返回该数值字符串表示形式。

numObj.toExponential(fractionDigits)

  • fractionDigits: 可选。一个整数，用来指定小数点后有几位数字。默认情况下用尽可能多的位数来显示数字。
js
var numObj = 77.1234

console.log(numObj.toExponential())   // 7.71234e+1

console.log(numObj.toExponential(4))  // 7.7123e+1

console.log(numObj.toExponential(2))  // 7.71e+1

console.log(77.1234.toExponential())  // 7.71234e+1
// 数值没有小数点和指数时，应该在该数值与该方法之间隔开一个空格，以避免点号被解释为一个小数点。也可以使用两个点号调用该方法。
console.log(77 .toExponential())      // 7.7e+1

number.toFixed() ​

toFixed() 方法使用定点表示法来格式化一个数值。返回值是一个字符串。

numObj.toFixed(digits)

  • digits: 小数点后数字的个数；介于 0 到 20 （包括）之间，实现环境可能支持更大范围。如果忽略该参数，则默认为 0。
js
var numObj = 12345.6789;

numObj.toFixed();         // 返回 "12346"：进行四舍六入五看情况，不包括小数部分
numObj.toFixed(1);        // 返回 "12345.7"：进行四舍六入五看情况

numObj.toFixed(6);        // 返回 "12345.678900"：用0填充

(1.23e+20).toFixed(2);    // 返回 "123000000000000000000.00"

(1.23e-10).toFixed(2);    // 返回 "0.00"

2.34.toFixed(1);          // 返回 "2.3"

2.35.toFixed(1)           // 返回 '2.4'. Note it rounds up

2.55.toFixed(1)           // 返回 '2.5'. Note it rounds down - see warning above

-2.34.toFixed(1);         // 返回 -2.3 （由于操作符优先级，负数不会返回字符串）

(-2.34).toFixed(1);       // 返回 "-2.3" （若用括号提高优先级，则返回字符串）

number.toString() ​

可参考string.toString

number.valueOf() ​

valueOf() 方法返回一个被 Number 对象包装的原始值。

TIP

该方法通常是由 JavaScript 引擎在内部隐式调用的，而不是由用户在代码中显式调用的。

js
var numObj = new Number(10);
console.log(typeof numObj)  // object

var num = numObj.valueOf()
console.log(num);           // 10
console.log(typeof num)     // number