ES6入门 ___ 数值的扩展

一、二进制和八进制表示法

ES6 提供了二进制和八进制数值的新写法，分别用前缀0b（或 0B）和 0o（或0O）表示

0b111110111 === 503 // true
0o767 === 503 // true

从 ES5 开始，在严格模式中，八进制数值就不再允许使用前缀 0 表示，ES6 进一步确定，要使用前缀 0o 表示。

如果要将使用 0b 和 0x 前缀的字符串数值转为十进制数值，要使用 Number 方法。

Number('0b111') // 7
Number('0o10') // 8

二、Number.isFinite()、Number.isNaN()

Number.isFinite() 用来检查一个数值是否为有限的（finite）

Number.isFinite(15) // true
Number.isFinite(Infinity) // false
Number.isFinite('foo') // false
Number.isFinite(NaN) // false
Number.isFinite('15') // false
Number.isFinite(true) // false

ES5 可以通过下面的代码部署 Number.isFinite 方法

;(function (global) {
  var global_isFinite = global.isFinite
  
  Object.define
Property(Number, 'isFinite', {
    value: function isFinite(value) {
      return typeof value === 'number' && global_isFinite(value)
    },
    configurable: true,
    enumerable: false,
    writable: true
  })
})(this)

Number.isNaN 用来检查一个值是否为 NaN

Number.isNaN(NaN) // true
Number.isNaN(15) // false
Number.isNaN(true) // false

ES5 可以通过下面的代码部署 Number.isNaN()

;(function (global) {
  var global_isNaN = global.isNaN
  
  Object.define




Property(Number, 'isNaN'. {
    value: function isNaN(value) {
      return typeof value === 'number' && global_isNaN(value)
    },
    configurable: true,
    enumerable: false,
    writable: true
  })
})(this)

这两个新方法与传统的全局方法 isFinite() 和 isNaN() 的区别在于，传统方法先调用 Number() 将非数值转为数值，再进行判断，而新方法只对数值有效，对于非数值一律返回false。Number.isNaN() 只有对 NaN 才返回 true，非NaN 一律返回false。

三、Number.parseInt()、Number.parseFloat()

ES6 将全局方法 parseInt() 和 parseFloat() 移植到了 Number 对象上面，行为完全保持不变。

// ES5 的写法
parseInt('12.34') // 12
parseFloat('123.45#') // 123.45

// ES6 的写法
Number.parseInt('12.34') // 12
Number.parseFloat('123.45#') // 123.45

Number.parseInt = parseInt // true
Number.parseFloat = parseFloat // true

这样做的目的是逐步减少全局性方法，使得语言逐步模块化

四、Number.isInteger()

Number.isInterger() 用来判断一个值是否为整数。
需要注意的是，在 JavaScript 内部，整数和浮点数是同样的储存方法，所以 3 和 3.0 被视为同一个值

Number.isInteger(25) // true
Number.isInteger(25.0) // true

ES5 可以通过下面的代码部署 Number.isInteger()

;(function(global) {
  var floor = Math.floor,
      isFinite = global.isFinite
  Object.defineProperty(Number, 'isInteger', {
    value: function isInteger(value) {
      return typeof value === 'number' && isFinite(value) && floor(value) === value
    },
    configurable: true,
    enumerable: false,
    writable: true
  })
})(this)

五、Number.EPSILON

ES6 在Number 对象上面新增一个极小的常量——Number.EPSILON，引入一个这么小的量，目的在于为浮点数计算设置一个误差范围。如果误差能够小于 Number.EPSILON，就认为可以得到正确结果

Number.EPSILON
// 2.220446049250313e-16

0.1 + 0.2 - 0.3
// 5.551115123125783e-17
(0.1 + 0.2 - 0.3).toFixed(20)
// "0.00000000000000005551"

(0.1 + 0.2 - 0.3) < Number.EPSILON
// true

Number.EPSILON 的实质是一个可以接受的误差范围

六、安全整数和 Number.isSadeInteger()

JavaScript 能够准确表示的整数范围在 -2^53 到 2^53 之间（不含两个端点），超过这个范围就无法精确表示，ES6 引入了 Number.MAX_SAFE_INTEGER 和 Number.MIN_SAFE_INTEGER 两个常量用来表示这个范围的上下限

Number.MAX_SAFE_INTEGER === Math.pow(2, 53) - 1
// true
Number.MAX_SAFE_INTEGER === 9007199254740991
// true

Number.MIN_SAFE_INTEGER === -Number.MAX_SAFE_INTEGER
// true
Number.MIN_SAFE_INTEGER === -9007199254740991
// true

Number.isSafeInteger() 则用来判断一个整数是否落在这个范围之内

Number.isSafeInteger(3) // true
Number.isSafeInteger(9007199254740991) // true
Number.isSafeInteger(9007199254740992) // false

七、Math 对象的扩展

ES6 在 Math 对象上新增了 17个与数学相关的方法。所有这些方法都是静态方法，只能在 Math 对象上调用。

7.1、Math.trunc()

Math.trunc 方法用于去除一个数的小数部分，返回整数部分

Math.trunc(4. 1) // 4
Math.trunc(4. 9) // 4
Math.trunc(-4.1) // -4

对于非数值，Math.trunc 内部使用 Number 方法将其先转为数值
对于空值和无法截取整数的值，返回NaN

对于没有部署这个方法的环境，可以用下面的代码模拟。

Math.trunc = Math.trunc || function(x) {
  return x < 0 ? Math.ceil(x) : Math.floor(x)
}

7.2、Math.sign()

Math.sign 方法用来判断一个数到底是正数、负数、还是零。对于非数值，会先将其转换为数值。
其返回值有 5 中情况：

参数为正数，返回 +1
参数为负数，返回 -1
参数为0，返回 0
参数为-0，返回 -0
其他值，返回 NaN

Math.sign(-5) // -1
Math.sign(5) // 1
Math.sign(-0) // -0
Math.sign(0) // 0
Math.sign('foo') // NaN

对于没有部署这个方法的环境，可以用下面的代码模拟

Math.sign = Math.sign || function(x) {
  x = +x // 转换成数字
  if (x === 0 || isNaN(x)) {
    return x
  }
  return x > 0 ? 1 : -1
}

7.3Math.cbrt()

Math.cbrt 方法用于计算一个数的立方根

Math.cbrt(-1) // -1
Math.cbrt(0) // 0
Math.cbrt(1) // 1
Math.cbrt(2) // 1.2599210498948732

对于非数值，Math.cbrt 方法内部也是先使用 Number 方法将其转为数值

对于没有部署这个方法的环境，可以用下面的代码模拟

Math.cbrt = Math.cbrt || function(x) {
  var y = Math.pow(Math.abs(x), 1/3)
  return x < 0 ? -y : y
}

7.4、Math.clz32()

Math.clz32 方法返回一个数的 32位无符号整数形式有多少前导 0

Math.clz32(0) // 32
Math.clz32(1) // 31

左移运算符（<<）与 Math.clz32 方法直接相关
对于小数，Math.clz32 方法只考虑整数部分。
对于空值或其他类型的值，Math.clz32 方法会将他们先转换为数值，然后再计算。

7.5、Math.imul()

Math.imul 方法返回两个数以32 位带符号整数形式相乘的结果，返回的也是一个32 位的带符号整数

Math.imul(2, 4) // 8
Math.imul(-1, 8) // -8
Math.imul(-2, -2) // 4

7.6、Math.fround()

Math.fround 方法返回一个数的单精度浮点数形式。

Math.fround(0) // 0
Math.fround(1) // 1
Math.fround(1.337) // 1.3370000123977661
Math.fround(1.5) // 1.5

那些无法用 64个二进制为精确表示的小数。这是，Math.fround 方法会返回最接近这个小数的单精度浮点数。

对于没有部署这个方法的环境，可以用下面的代码模拟

Math.fround= Math.fround|| function(x) {
  return new Float32Array([x])[0]
}

7.7、Math.hypot()

Math.hypot 方法返回所有参数的平方和的平方根

Math.hypot(3, 4) // 5

如果参数不是数值，Math.hypot 方法会将其转为数值。只要有一个参数无法转为数值，就会返回 NaN

7.8、对数方法

ES6 新增了4个对数相关方法
1. Math.expm1()
Math.expm1(x)返回 e^x - 1，即Math.exp(x) - 1

Math.expm1(-1)

2. Math.log1p()
Math.log1p(x) 方法返回 ln(1 + x)，即 Math.log(1 + x)。如果 x 小于 -1，则返回 NaN

Math.log1p(1) // 0.6931471805599453
Math.log1p(0) // 0
Math.log1p(-1) // -Infinity

3. Math.log10()
Math.log10(x) 返回以10 为底的 x 的对数。如果x 小于 0，则返回 NaN

Math.log10(2) // 0.3010299956639812
Math.log10(1) // 0

4. Math.log2()
Math.log2(x) 返回以 2 为底的x 的对数。如果 x 小于 0，则返回 NaN

Math.log2(3) // 1.584962500721156
Math.log2(2) // 1
Math.log2(1) // 0

7.9、双曲函数方法

ES6新增了 6个双曲函数方法：

Math.sinh(x) 返回x 的双曲正弦
Math.cosh(x) 返回 x 的双曲余弦
Math.tanh(x) 返回 x 的双曲正切
Math.asinh(x) 返回 x 的反双曲正弦
Math.acosh(x) 返回 x 的反双曲余弦
Math.atanh(x) 返回 x 的反双曲正切

八、Math.signbit()

Math.sign() 用来判断一个值的正负，但是如果参数是 -0，他便会返回 -0

Math.sign(-0)

这种情况下，判断符号位的正负时，Math.sign() 不是很有用。实际编程中，判断一个值是+0 还是 -0 非常麻烦，因为他们是相等的。

目前，有一个提案中引入了 Math.signbit() 方法判断一个数的符号位是否已经设置。

九、指数运算符

ES2016 新增了一个指数运算符（**）

2 ** 2 // 4
2 ** 3 // 8

指数运算符可以与等号结合，形成一个新的赋值运算符（**=）

let a = 1.5
a **= 2
// 等同于 a = a * a

let b = 4
b **= 3
// 等同于 b = b * b * b

十、Integer 数据类型

JavaScript 所有数字都保存成 64位浮点数，这决定了整数的精确程度只能到53个二进制位。大于这个范围的整数，JavaScript 是无法精确表示的，这使得 JavaScript 不适合进行科学和金融方面的精确计算。

现在有一个提案提案，其中引入了新的数据类型 Integer（整数）来解决这个问题。整数类型的数据只用来表示整数，没有位数的限制，任何位数的整数都可以精确表示。
提案

ES6入门 ___ 数值的扩展

一、二进制 和 八进制 表示法

二、Number.isFinite()、Number.isNaN()

三、Number.parseInt()、Number.parseFloat()

四、Number.isInteger()

五、Number.EPSILON

六、安全整数 和 Number.isSadeInteger()

七、Math 对象的扩展

7.1、Math.trunc()

7.2、Math.sign()

7.3Math.cbrt()

7.4、Math.clz32()

7.5、Math.imul()

7.6、Math.fround()

7.7、Math.hypot()

7.8、对数方法

7.9、双曲函数方法

八、Math.signbit()

九、指数运算符

十、Integer 数据类型

你可能感兴趣的:(ES6入门 ___ 数值的扩展)

一、二进制和八进制表示法

六、安全整数和 Number.isSadeInteger()