Number 的属性与办法

Number(value)

// 创立数字对象
let n = new Number(10) //{10}
// 类型转换
Number("10") //10
Number("0x11")//17
Number("-Infinity") //-Infinity
Number("0A") //NaN
Number(10n) //10

1 Number 上的属性

1. Number.EPSILON
2. Number.MIN_VALUE
3. Number.MAX_VALUE
4. Number.MIN_SAFE_INTEGER
5. Number.MAX_SAFE_INTEGER
6. Number.NEGATIVE_INFINITY
7. Number.POSITIVE_INFINITY

1.1 Number.EPSILON

1 与 大于 1 可示意的浮点数 之间的 差值 2^-52

2 ** (-52) == Number.EPSILON //true

1.2 Number.MIN_VALUE Number.MAX_VALUE

MIN_VALUE最靠近 0 的 正值 约为 5 ^-324
MAX_VALUE 最大值 约为 1.79³⁰⁸
大于 MAX_VALUE 的值为Infinity

1.3 Number.MIN_SAFE_INTEGER Number.MAX_SAFE_INTEGER

MIN_SAFE_INTEGER为最小平安 整数 -(2⁵³-1)
MAX_SAFE_INTEGER 为最大平安 整数 2⁵³-1

Number.MIN_SAFE_INTEGER == -(2 ** (53) - 1) //true
Number.MAX_SAFE_INTEGER == 2 ** (53) - 1//true

1.4 Number.NEGATIVE_INFINITY Number.POSITIVE_INFINITY

NEGATIVE_INFINITY : -Infinity
POSITIVE_INFINITY : Infinity

• 0 乘两者都为 NaN
• 两者相互除为 NaN
• 任何数除以两者都为 0

仅判断无穷时倡议应用 isFinite

2 Number 上的办法

1. Number.isFinite()
2. Number.isInteger()
3. Number.isSafeInteger()
4. Number.isNaN()
5. Number.parseInt()
6. Number.parseFloat()

2.1 Number.isFinite(value) isFinite(value)

是否 有穷

// 无穷
let n1 = -Infinity
Nnmber.isFinite(n1)//false
isFinite(n1)//false
// 有穷
let n2 = 0
Nnmber.isFinite(n2)//true
isFinite(n2)//true
// 字符串
let n3 = '0'
Nnmber.isFinite(n3)//false
isFinite(n3)//true

isFinite()有 类型转换 ，举荐应用
然而不能在外面将 bigInt 转换成 Number

2.2 Number.isInterger(value) Number.isSafeInteger(value)

是否为 整数 是否为 平安整数

Number.isInteger(2**100)//true
Number.isInteger('0')//false
Number.isInteger(0.1)//false
Number.isSafeInteger(2**100)//false

2.3 Number.isNaN(value) isNaN(value)

判断是否 非数字

// 一般字符串
Number.isNaN('a')//false
isNaN('a')//true
//NaN 字符串
Number.isNaN('NaN')//false
isNaN('NaN')//true
// 数值字符串
Number.isNaN('10')//false
isNaN('10')//false

Number.isNaN() 无类型转换，为 NaN 时返回 true，不是 Number 类型均返回 false
isNaN()有隐式 类型转换，不是 Number 类型也可，转换后为非数字或者 NaN 返回 true，也不反对 bigInt

2.4 Number.parseInt(string,radix) Number.parseFloat(string)

期待接管一个 字符串 进行转化

/**
 * 无进制参数 
 */
// 字符串
parseInt("011x")//11
parseInt("0x11")//17
// 数字
parseInt(011) //9
parseInt(0b11)//3
parseInt(0x11)//17
/**
 * 有进制参数
 */
// 字符串
parseInt("011x",8)//9
// 数字
parseInt(011,8)//NaN 011->"9"->NaN

• 无进制参数时

• 参数一为字符串：辨认 10 进制或 16 进制 (0x 结尾) 转换为 10 进制
  参数一为数字：辨认 2、8、16 进制，转为 10 进制 再转为 字符串

• 有进制参数时 2-36

• 参数一为字符串：基于指定进制截取字符串，转为 10 进制
  参数一为数字：先辨认进制，转为 10 进制再转为字符串，作为字符串再进行上述操作

Number 上的类型转换与全局上的作用一样，倡议简写
这两个办法会先 截取 后面非法的局部进行转换
parseFloat() 将字符串转为小数或 NaN

3 原型上的办法

1. Number.prototype.toFixed()
2. Number.prototype.toPrecision()
3. Number.prototype.toExponential()
4. Number.prototype.toLocaleString()
5. Number.prototype.toString()
6. Number.prototype.valueOf()

3.1 toFixed(digits)

定点 表示法格式化一个数值 返回 字符串
digits 0-20 默认为 0

• 能够解决小数转成二进制后加和不精确

  // 四舍五入
  2.55.toFixed(1) //"2.5"
  2.35.toFixed(1) //"2.4"
  // 解决精度问题
  0.1+0.2 //0.30000000000000004
  parseFloat((0.1+0.2).toFixed(10)) //0.3

  toFixed()在四舍五入时会因精度问题不精确，但也仅限于保留位的 下一位为 5 时
  加和的误差值往往是多一个很小的值或少一个很小的值，toFixed 齐全能够满足日常需要

3.2 toPrecision(precision)

保留 有效数字 (从第一个不为 0 的数开始) 返回 字符串
precision 1-100

// 四舍五入
2.35.toPrecision(2) //"2.4"
2.55.toPrecision(2) //"2.5"
// 返回指数
225.55.toPrecision(2) //"226"
let a = 225.55.toPrecision(2) //"2.3e+2"
parseFloat(a) //230
parseInt(a)//2

toPrecison 的四舍五入与 toFixed 的统一
上有效位数小于整数位数时返回指数
parseFloat 能够转化指数模式的字符串

3.3 toExponential(fractionDigits)

指数表示法，指定 小数点后的位数 返回 字符串
fractionDigits 0-20

// 四舍五入
2.35.toExponential(1) //"2.4e+0"
2.55.toExponential(1) //"2.5e+0"
// 指数示意
225.55.toExponential(1)//"2.3e+2"
225.55.toExponential(2)//"2.26e+2"
0.0035.toExponential(2)//"3.50e-3"

四舍五入与 toFixed 统一
与 toPrecision 比拟，toExponential 始终返回 整数只有 1 位 的指数
两者在示意指数时，都会将第一个不为 0 的数作为整数位

3.4 toLocaleString(locales,options)

将数字转成特定语言环境下的 字符串

locales：'en-IN' 印度分隔 
'zh-Hans-CN-u-nu-hanidec' 中文十进制分隔 
'ar-EG' 阿拉伯数字 
...

options：style：decimal 纯数字格局(默认)
        currency 货币格局 USD EUR CNY
        percent 百分比格局
        unit 单位格局(测试中)
minimumIntegerDigits 整数数字最小数目 1-21
minimumFractionDigits 小数位数的最小数目 0-20
maximumFractionDigits 小数位数的最大数目 0-20 纯数字默认为 3
minimumSignificantDigits 有效数字的最小数目 1-21
maximumSignificantDigits 有效数字的最大数量 1-21

全副参数详见 MDN

// 解决小数精度问题
(0.1+0.2).toLocaleString() //"0.3"
//locales 参数
let n = 1234.5678
n.toLocaleString('zh-u-nu-hanidec')// 一, 二三四. 五六八
a.toLocaleString('ar-EG')//١٬٢٣٤٫٥٦٨
//options 参数
n.toLocaleString('zh-u-nu-hanidec',{maximumFractionDigits:10})// 一, 二三四. 五六七八

默认保留小数位为 3 等价于 toFixed(3)
四舍五入与 toFixed 统一

3.5 toString(radix)

转换为指定基数的 字符串 2-36 默认为 10

// 默认值
(11).toString() //'11'
0b11.toString() //'3'
0o11.toString() //'9'
011.toString() //'9'
0x11.toString() //'17'

// 指定进制
0.1.toString(2)
//'0.0001100110011001100110011001100110011001100110011001101'
0x10.toString(16) //'10'

先辨认数字的进制再转换为指定基数的字符串
能够看到 0.1 转换为二进制为 有限循环小数，能够解释为什么0.1 + 0.2 != 0.3

valueOf()

将数字对象转化为原始值

let a = new Number("10")
let b = a.valueOf()
console.log(a,b) // {10} 10