我是段花花花花花花
| 导读 | es6， 全称 ecmascript 6.0 ，是 javascript 的下一个版本标准，2015.06 发版。 |
数值的表示
二进制表示法新写法: 前缀 0b 或 0b 。
console.log(0b11 === 3); // true console.log(0b11 === 3); // true
八进制表示法新写法: 前缀 0o 或 0o 。
console.log(0o11 === 9); // true console.log(0o11 === 9); // true
常量
number.epsilon
number.epsilon 属性表示 1 与大于 1 的最小浮点数之间的差。
它的值接近于 2.2204460492503130808472633361816e-16，或者 2-52。
测试数值是否在误差范围内:
0.1 0.2 === 0.3; // false // 在误差范围内即视为相等 equal = (math.abs(0.1 - 0.3 0.2) < number.epsilon);="">
属性特性
writable：false enumerable：false configurable：false
最大/最小安全整数
安全整数
安全整数表示在 javascript 中能够精确表示的整数，安全整数的范围在 2 的 -53 次方到 2 的 53 次方之间（不包括两个端点），超过这个范围的整数无法精确表示。
最大安全整数
安全整数范围的上限，即 2 的 53 次方减 1 。
number.max_safe_integer 1 === number.max_safe_integer 2; // true number.max_safe_integer === number.max_safe_integer 1; // false number.max_safe_integer - 1 === number.max_safe_integer - 2; // false
最小安全整数
安全整数范围的下限，即 2 的 53 次方减 1 的负数。
number.min_safe_integer 1 === number.min_safe_integer 2; // false number.min_safe_integer === number.min_safe_integer - 1; // false number.min_safe_integer - 1 === number.min_safe_integer - 2; // true
属性特性
writable：false enumerable：false configurable：false
方法
number 对象新方法
number.isfinite()
用于检查一个数值是否为有限的（ finite ），即不是 infinity
console.log( number.isfinite(1)); // true
console.log( number.isfinite(0.1)); // true
// nan 不是有限的
console.log( number.isfinite(nan)); // false
console.log( number.isfinite(infinity)); // false
console.log( number.isfinite(-infinity)); // false
// number.isfinate 没有隐式的 number() 类型转换，所有非数值都返回 false
console.log( number.isfinite('foo')); // false
console.log( number.isfinite('15')); // false
console.log( number.isfinite(true)); // false
number.isnan()
用于检查一个值是否为 nan 。
console.log(number.isnan(nan)); // true
console.log(number.isnan('true'/0)); // true
// 在全局的 isnan() 中，以下皆返回 true，因为在判断前会将非数值向数值转换
// 而 number.isnan() 不存在隐式的 number() 类型转换，非 nan 全部返回 false
number.isnan("nan"); // false
number.isnan(undefined); // false
number.isnan({}); // false
number.isnan("true"); // false
从全局移植到 number 对象的方法
逐步减少全局方法，用于全局变量的模块化。
方法的行为没有发生改变。
number.parseint()
用于将给定字符串转化为指定进制的整数。
// 不指定进制时默认为 10 进制
number.parseint('12.34'); // 12
number.parseint(12.34); // 12
// 指定进制
number.parseint('0011',2); // 3
// 与全局的 parseint() 函数是同一个函数
number.parseint === parseint; // true
number.parsefloat()
用于把一个字符串解析成浮点数。
number.parsefloat('123.45') // 123.45
number.parsefloat('123.45abc') // 123.45
// 无法被解析成浮点数，则返回 nan
number.parsefloat('abc') // nan
// 与全局的 parsefloat() 方法是同一个方法
number.parsefloat === parsefloat // true
number.isinteger()
用于判断给定的参数是否为整数。
number.isinteger(value)
number.isinteger(0); // true
// javascript 内部，整数和浮点数采用的是同样的储存方法,因此 1 与 1.0 被视为相同的值
number.isinteger(1); // true
number.isinteger(1.0); // true
number.isinteger(1.1); // false
number.isinteger(math.pi); // false
// nan 和正负 infinity 不是整数
number.isinteger(nan); // false
number.isinteger(infinity); // false
number.isinteger(-infinity); // false
number.isinteger("10"); // false
number.isinteger(true); // false
number.isinteger(false); // false
number.isinteger([1]); // false
// 数值的精度超过 53 个二进制位时，由于第 54 位及后面的位被丢弃，会产生误判
number.isinteger(1.0000000000000001) // true
// 一个数值的绝对值小于 number.min_value（5e-324），即小于 javascript 能够分辨
// 的最小值，会被自动转为 0，也会产生误判
number.isinteger(5e-324); // false
number.isinteger(5e-325); // true
number.issafeinteger()
用于判断数值是否在安全范围内。
number.issafeinteger(number.min_safe_integer - 1); // false
number.issafeinteger(number.max_safe_integer 1); // false
math 对象的扩展
es6 在 math 对象上新增了 17 个数学相关的静态方法，这些方法只能在 math 中调用。
普通计算
math.cbrt
用于计算一个数的立方根。
math.cbrt(1); // 1
math.cbrt(0); // 0
math.cbrt(-1); // -1
// 会对非数值进行转换
math.cbrt('1'); // 1
// 非数值且无法转换为数值时返回 nan
math.cbrt('hhh'); // nan
math.imul
两个数以 32 位带符号整数形式相乘的结果，返回的也是一个 32 位的带符号整数。
// 大多数情况下，结果与 a * b 相同 math.imul(1, 2); // 2
// 用于正确返回大数乘法结果中的低位数值 math.imul(0x7fffffff, 0x7fffffff); // 1
math.hypot
用于计算所有参数的平方和的平方根。
math.hypot(3, 4); // 5
// 非数值会先被转换为数值后进行计算
math.hypot(1, 2, '3'); // 3.741657386773941
math.hypot(true); // 1
math.hypot(false); // 0
// 空值会被转换为 0
math.hypot(); // 0
math.hypot([]); // 0
// 参数为 infinity 或 -infinity 返回 infinity
math.hypot(infinity); // infinity
math.hypot(-infinity); // infinity
// 参数中存在无法转换为数值的参数时返回 nan
math.hypot(nan); // nan
math.hypot(3, 4, 'foo'); // nan
math.hypot({}); // nan
math.clz32
用于返回数字的32 位无符号整数形式的前导0的个数。
math.clz32(0); // 32
math.clz32(1); // 31
math.clz32(0b01000000000100000000000000000000); // 1
// 当参数为小数时，只考虑整数部分
math.clz32(0.5); // 32
// 对于空值或非数值，会转化为数值再进行计算
math.clz32('1'); // 31
math.clz32(); // 32
math.clz32([]); // 32
math.clz32({}); // 32
math.clz32(nan); // 32
math.clz32(infinity); // 32
math.clz32(-infinity); // 32
math.clz32(undefined); // 32
math.clz32('hhh'); // 32
数字处理
math.trunc
用于返回数字的整数部分。
math.trunc(12.3); // 12
math.trunc(12); // 12
// 整数部分为 0 时也会判断符号
math.trunc(-0.5); // -0
math.trunc(0.5); // 0
// math.trunc 会将非数值转为数值再进行处理
math.trunc("12.3"); // 12
// 空值或无法转化为数值时时返回 nan
math.trunc(); // nan
math.trunc(nan); // nan
math.trunc("hhh"); // nan
math.trunc("123.2hhh"); // nan
math.fround
用于获取数字的32位单精度浮点数形式。
// 对于 2 的 24 次方取负至 2 的 24 次方之间的整数（不含两个端点），返回结果与参数本身一致
math.fround(-(2**24) 1); // -16777215
math.fround(2 ** 24 - 1); // 16777215
// 用于将 64 位双精度浮点数转为 32 位单精度浮点数
math.fround(1.234) // 1.125
// 当小数的精度超过 24 个二进制位，会丢失精度
math.fround(0.3); // 0.30000001192092896
// 参数为 nan 或 infinity 时返回本身
math.fround(nan) // nan
math.fround(infinity) // infinity
// 参数为其他非数值类型时会将参数进行转换
math.fround('5'); // 5
math.fround(true); // 1
math.fround(null); // 0
math.fround([]); // 0
math.fround({}); // nan
判断
math.sign
判断数字的符号（正、负、0）。
math.sign(1); // 1
math.sign(-1); // -1
// 参数为 0 时，不同符号的返回不同
math.sign(0); // 0
math.sign(-0); // -0
// 判断前会对非数值进行转换
math.sign('1'); // 1
math.sign('-1'); // -1
// 参数为非数值（无法转换为数值）时返回 nan
math.sign(nan); // nan
math.sign('hhh'); // nan
对数方法
math.expm1()
用于计算 e 的 x 次方减 1 的结果，即 math.exp(x) - 1 。
math.expm1(1); // 1.718281828459045
math.expm1(0); // 0
math.expm1(-1); // -0.6321205588285577
// 会对非数值进行转换
math.expm1('0'); //0
// 参数不为数值且无法转换为数值时返回 nan
math.expm1(nan); // nan
math.log1p(x)
用于计算1 x 的自然对数，即 math.log(1 x) 。
math.log1p(1); // 0.6931471805599453 math.log1p(0); // 0 math.log1p(-1); // -infinity // 参数小于 -1 时返回 nan math.log1p(-2); // nan
math.log10(x)
用于计算以 10 为底的 x 的对数。
math.log10(1); // 0
// 计算前对非数值进行转换
math.log10('1'); // 0
// 参数为0时返回 -infinity
math.log10(0); // -infinity
// 参数小于0或参数不为数值（且无法转换为数值）时返回 nan
math.log10(-1); // nan
math.log2()
用于计算 2 为底的 x 的对数。
math.log2(1); // 0
// 计算前对非数值进行转换
math.log2('1'); // 0
// 参数为0时返回 -infinity
math.log2(0); // -infinity
// 参数小于0或参数不为数值（且无法转换为数值）时返回 nan
math.log2(-1); // nan
双曲函数方法
- math.sinh(x): 用于计算双曲正弦。
- math.cosh(x): 用于计算双曲余弦。
- math.tanh(x): 用于计算双曲正切。
- math.asinh(x): 用于计算反双曲正弦。
- math.acosh(x): 用于计算反双曲余弦。
- math.atanh(x): 用于计算反双曲正切。
指数运算符
1 ** 2; // 1 // 右结合，从右至左计算 2 ** 2 ** 3; // 256 // **= let exam = 2; exam ** = 2; // 4
