全面認(rèn)識(shí)JavaScript的Number對(duì)象

全面認(rèn)識(shí)JavaScript的Number對(duì)象

首先一個(gè)是對(duì)JavaScript中Number的理解：JavaScript中函數(shù)是一等公民，寫在代碼中的 Array/Object/String/Number/Function等等其實(shí)都是一個(gè)構(gòu)造函數(shù)，是用來(lái)生成相應(yīng)的數(shù)據(jù)類型的變量的。

JavaScript的Number對(duì)象是經(jīng)過(guò)封裝的能讓你處理數(shù)字值的對(duì)象。Number對(duì)象由Number()構(gòu)造器創(chuàng)建。

語(yǔ)法：

  new Number(value);

  // 參數(shù)
  value // 被創(chuàng)建對(duì)象的數(shù)字值
Number對(duì)象主要用于：
  • 如果參數(shù)無(wú)法被轉(zhuǎn)換為數(shù)字，則返回NaN
  • 在非構(gòu)造器上下文中(如：沒(méi)有new操作符)，Number能被用來(lái)執(zhí)行類型轉(zhuǎn)換。

========== 屬性 ==========

Number.EPSILON屬性表示1與Number可表示的大于1的最小浮點(diǎn)數(shù)之間的差值。
屬性的屬性特性 值
writable false
enumerable false
configurable false

EPSILON屬性的值接近于2.2204460492503130808472633361816E-16，或者 2^-52。

示例：

  let x = 0.2;
  let y = 0.3;
  let z = 0.1;

  console.log(Math.abs(x - y + z) < Number.EPSILON); // true

  console.log(Math.abs(x - y + z)); // 2.7755575615628914e-17
  console.log(Number.EPSILON); // 2.220446049250313e-16
Number.MAX_SAFE_INTEGER/Number.MIN_SAFE_INTEGER代表在JavaScript中最大/最小的安全的integer型數(shù)字(2^53 - 1/-(2^53 - 1))
屬性的屬性特性 值
writable false
enumerable false
configurable false

MAX_SAFE_INTEGER的值是9007199254740991，形成這個(gè)數(shù)字的原因是JavaScript在IEEE 754中使用double-precision floating-point format numbers（不懂）作為規(guī)定。在這個(gè)規(guī)定中能安全的表示數(shù)字的范圍在-(2^53 - 1)到2^53 - 1之間。

這里安全存儲(chǔ)的意思是指能夠準(zhǔn)確區(qū)分兩個(gè)不相同的值，例如 Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2 將得到 true的結(jié)果，而這在數(shù)學(xué)上是錯(cuò)誤的

Number.MAX_VALUE/Number.MIN_VALUE表示在JavaScript里所能表示的最大/最小數(shù)值。
屬性的屬性特性 值
writable false
enumerable false
configurable false

MAX_VALUE屬性值接近于1.79E+308。大于MAX_VALUE的值代表'Infinity'。

Number.NEGATIVE_INFINITY/Number.POSITIVE_INFINITY屬性表示負(fù)無(wú)窮大/正無(wú)窮大。
屬性的屬性特性 值
writable false
enumerable false
configurable false

Number.NEGATIVE_INFINITY的值和全局對(duì)象Infinity屬性的負(fù)值相同。

該值的行為同數(shù)學(xué)上的無(wú)窮大（infinity）有一點(diǎn)兒不同：
  • 任何正值，包括POSITIVE_INFINITY，乘以NEGATIVE_INFINITY都為NEGATIVE_INFINITY
  • 任何正值，包括POSITIVE_INFINITY，乘以POSITIVE_INFINITY都為POSITIVE_INFINITY。
  • 任何負(fù)值，包括NEGATIVE_INFINITY，乘以NEGATIVE_INFINITY都為POSITIVE_INFINITY
  • 任何負(fù)值，包括NEGATIVE_INFINITY，乘以POSITIVE_INFINITY都為NEGATIVE_INFINITY
  • 0 乘以 NEGATIVE_INFINITY/POSITIVE_INFINITY 為 NaN
  • NaN 乘以 NEGATIVE_INFINITY/POSITIVE_INFINITY 為 NaN
  • NEGATIVE_INFINITY除以任何負(fù)值（除了NEGATIVE_INFINITY）為POSITIVE_INFINITY
  • POSITIVE_INFINITY除以NEGATIVE_INFINITY以外的任何負(fù)值為NEGATIVE_INFINITY
  • NEGATIVE_INFINITY除以任何正值（除了POSITIVE_INFINITY）為NEGATIVE_INFINITY
  • POSITIVE_INFINITY除以POSITIVE_INFINITY以外的任何正值為POSITIVE_INFINITY
  • NEGATIVE_INFINITY除以NEGATIVE_INFINITY或POSITIVE_INFINITY是 NaN
  • POSITIVE_INFINITY除以NEGATIVE_INFINITY或POSITIVE_INFINITY為 NaN
  • 任何數(shù)除以NEGATIVE_INFINITY/POSITIVE_INFINITY為 0
Number.NaN表示“非數(shù)字”。和NaN相同。
屬性的屬性特性 值
writable false
enumerable false
configurable false
示例：

  console.log(Number.MAX_SAFE_INTEGER); // 9007199254740991
  console.log(Number.MIN_SAFE_INTEGER); // -9007199254740991
  console.log(Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2) // true
  console.log(Number.MAX_SAFE_INTEGER + 1); // 9007199254740992
  console.log(Number.MAX_SAFE_INTEGER + 2); // 9007199254740992 , 加不上去了

  console.log(Number.MAX_VALUE); // 1.7976931348623157e+308
  console.log(Number.MIN_VALUE); // 5e-324
  console.log(Number.MAX_VALUE === Number.MAX_VALUE + 1); // true
  console.log(Number.MAX_VALUE + 1); //  1.7976931348623157e+308 ,再加也不會(huì)更大
  console.log(Infinity); // Infinity
  console.log(Number.MAX_VALUE < Infinity); // true

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

  console.log(Number.NaN); // NaN
  console.log(NaN); // NaN
  console.log(Number.NaN === Number.NaN); // false
  console.log(Number.NaN === NaN); // false, NaN不等于任何值，包括自身
  console.log(Object.is(Number.NaN, NaN)); // true
Number.prototype屬性表示Number構(gòu)造函數(shù)的原型
屬性的屬性特性 值
writable false
enumerable false
configurable false

所有Number實(shí)例都繼承自Number.prototype。

========== 方法 ==========

根據(jù)個(gè)人的理解，將方法進(jìn)行分類

值類型判斷類：isNaN/isFinite/isInteger/isSafeInteger

1.Number.isNaN()確定傳遞的值是否為NaN和其類型是Number。它是原始的全局isNaN的強(qiáng)大的版本。
語(yǔ)法：

  Number.isNaN(value);

  // 參數(shù)
  value // 要被檢測(cè)是否是NaN的值

  // 返回值：一個(gè)布爾值，表示給定的值是否是NaN
附：全局的isNaN()函數(shù)用來(lái)確定一個(gè)值是否為NaN。
語(yǔ)法：

  isNaN(testValue);

  // 參數(shù)
  testValue // 要被檢測(cè)的值

  // 返回值：如果給定值為NaN則返回值為true;否則為false
為什么要專門出一個(gè)方法判斷是否是NaN：與JavaScript中其他的值不同，NaN不能通過(guò)相等操作符（== 和 ===）來(lái)判斷，NaN === NaN 和 NaN == NaN都返回false。
NaN值如何產(chǎn)生：
  • 當(dāng)算數(shù)運(yùn)算返回一個(gè)未定義的或無(wú)法表示的值時(shí)，NaN就產(chǎn)生了。
  • 將某些不能強(qiáng)制轉(zhuǎn)換為數(shù)值的非數(shù)值轉(zhuǎn)換為數(shù)值的時(shí)候，也會(huì)得到NaN。
  • 0除以0會(huì)返回NaN，但是其他數(shù)除以0則不會(huì)返回NaN。

全局isNaN()的怪異行為：如果isNaN函數(shù)的參數(shù)不是Number，isNaN函數(shù)會(huì)首先嘗試將這個(gè)參數(shù)轉(zhuǎn)換為數(shù)值，然后才會(huì)對(duì)轉(zhuǎn)換后的結(jié)果是否是NaN進(jìn)行判斷。因此，對(duì)于能被強(qiáng)制轉(zhuǎn)換為有效的非NaN數(shù)值來(lái)說(shuō)（空字符串和布爾值分別會(huì)被強(qiáng)制轉(zhuǎn)換為數(shù)值0和1），進(jìn)而會(huì)返回false。這讓人感到怪異，因?yàn)榭兆址黠@不是數(shù)值。這起源于“不是數(shù)值”在基于IEEE-754數(shù)值的浮點(diǎn)計(jì)算體質(zhì)中代表了一種特定的含義。isNaN函數(shù)其實(shí)等同于回答了一個(gè)問(wèn)題：被測(cè)試的值在被強(qiáng)制轉(zhuǎn)換成數(shù)值時(shí)，會(huì)不會(huì)返回IEEE-754中所謂的“不是數(shù)值”。

因此，通過(guò)Number.isNaN()來(lái)檢測(cè)是否是一個(gè)NaN是一種更可靠的方法。也可通過(guò)表達(dá)式（x != x)來(lái)檢測(cè)變量x是否是NaN。

Number.isNaN()和isNaN()相比，前者不會(huì)強(qiáng)制將參數(shù)轉(zhuǎn)換成數(shù)字，只有在參數(shù)是真正的數(shù)字類型，且值為NaN的時(shí)候才會(huì)返回true。

Polyfill

  var isNaN = function(value) {
    let n = Number(value); // 先轉(zhuǎn)換為Number
    return n != n; // 利用NaN不等于自身進(jìn)行判斷
  }

  Number.isNaN = Number.isNaN || function(value) {
    //非Number類型直接返回false
    return typeof value === 'Number' && isNaN(value); 
  }
示例：
  
  console.log(isNaN(NaN)); // true
  console.log(Number.isNaN(NaN)); // true

  console.log(isNaN(37)); // false
  console.log(Number.isNaN(37)); // false

  console.log(Number.isNaN('37')); // false
  console.log(isNaN('37')); // false

  console.log(Number.isNaN(undefined)); // false
  console.log(isNaN(undefined)); // true
  console.log(Number(undefined)); // NaN

  console.log(Number.isNaN({})); // false
  console.log(isNaN({})); // true
  console.log(Number({})); // NaN

  console.log(Number.isNaN('37,5')); // false
  console.log(isNaN('37,5')); // true
  console.log(Number('37,5')); // NaN

  console.log(Number.isNaN('123ABC')); // false
  console.log(isNaN('123ABC')); // true
  console.log(Number('123ABC')); // NaN

  console.log(Number.isNaN(new Date().toString())); // false
  console.log(isNaN(new Date().toString())); // true
  console.log(Number(new Date().toString())); // NaN

  console.log(Number.isNaN(true)); // false
  console.log(isNaN(true)); // false
  console.log(Number(true)); // 1

  console.log(Number.isNaN(null)); // false
  console.log(isNaN(null)); // false
  console.log(Number(null)); // 0

  console.log(Number.isNaN('')); // false
  console.log(isNaN('')); // false
  console.log(Number('')); // 0

  console.log(Number.isNaN(' ')); // false
  console.log(isNaN(' ')); // false
  console.log(Number(' ')); // 0

  console.log(Number.isNaN(new Date())) // false
  console.log(isNaN(new Date())); // false
  console.log(Number(new Date())); // 1558496426074

個(gè)人總結(jié)：只要不是NaN任何值放入Number.isNaN()都會(huì)返回false。對(duì)于isNaN()能被Number()轉(zhuǎn)換成數(shù)字的或本身就是數(shù)字返回false，不能轉(zhuǎn)為數(shù)字的會(huì)返回true。（即：如果忽略掉能被轉(zhuǎn)成數(shù)字的字符串，所有數(shù)字對(duì)于isNaN()都返回false，非數(shù)字都返回true)

2.Number.isFinite()用來(lái)檢測(cè)傳入的參數(shù)是否是一個(gè)有窮數(shù)。
語(yǔ)法：

  Number.isFinite(value);

  // 參數(shù)
  value // 要被檢測(cè)有窮性的值。

  // 返回值：一個(gè)布爾值表示給定的值是否是一個(gè)有窮數(shù)
附：全局的isFinite()函數(shù)用來(lái)判斷被傳入的參數(shù)值是否是一個(gè)有限數(shù)值。在必要情況下，參數(shù)會(huì)首先轉(zhuǎn)為一個(gè)數(shù)值。
語(yǔ)法：

  isFinite(testValue);

  // 參數(shù)
  testValue // 用來(lái)檢測(cè)有限性的值。

  // isFinite 方法檢測(cè)它參數(shù)的數(shù)值。如果參數(shù)是 NaN，正無(wú)窮大或者負(fù)無(wú)窮大，會(huì)返回false，其他返回 true。

Number.isFinite()和全局的isFinite()相比，不會(huì)強(qiáng)制將一個(gè)非數(shù)值的參數(shù)轉(zhuǎn)換成數(shù)值，這就意味著，只有數(shù)值類型的值，且是有窮的，才返回true。

Polyfill

  Number.isFinite = Number.isFinite || function(value) {
    return typeof value === 'number' && isFinite(value);
  }
示例：

  console.log(Number.isFinite(Infinity)); // false
  console.log(isFinite(Infinity)); // false

  console.log(Number.isFinite(NaN)); // false
  console.log(isFinite(NaN)); // false

  console.log(Number.isFinite(2e64)); // true
  console.log(isFinite(2e64)); // true

  console.log(Number.isFinite('0')); // false
  console.log(isFinite('0')); // true

  console.log(Number.isFinite(undefined)); // false
  console.log(isFinite(undefined)); // false
  console.log(Number(undefined)); // NaN

  console.log(Number.isFinite(null)); // false
  console.log(isFinite(null)); // true
  console.log(Number(null)); // 0

個(gè)人總結(jié)：只有為Number的值且是有限的時(shí)候Numebr.isFinite()會(huì)返回true。而isFinite()在參數(shù)經(jīng)過(guò)Number轉(zhuǎn)換后再判斷是否是有限的。正無(wú)窮、負(fù)無(wú)窮和NaN都不是有限數(shù)字。

3.Number.isInteger()用來(lái)判斷給定的參數(shù)是否為整數(shù)。
語(yǔ)法：

  Number.isInteger(value);

  // 返回值：判斷給定的值是否是整數(shù)的Boolean值。如果被檢測(cè)的值是整數(shù)，則返回 true，否則返回 false。注意 NaN 和正負(fù) Infinity 不是整數(shù)。
示例：

  console.log(Number.isInteger(0)); // true
  console.log(Number.isInteger(-0)); // true
  console.log(Number.isInteger(0.1)); // false
  console.log(Number.isInteger(Math.PI)); // false
  console.log(Number.isInteger(Infinity)); // false
  console.log(Number.isInteger(-Infinity)); // false
  console.log(Number.isInteger(NaN)); // false
  console.log(Number.isInteger('10')); // false
  console.log(Number.isInteger(true)); // false
  console.log(Number.isInteger(false)); // false
  console.log(Number.isInteger([1])); // false

個(gè)人總結(jié)：只有是Number類型的值并且是整數(shù)才會(huì)返回true，Infinity和NaN都不是整數(shù)。

Polyfill

  Number.isInteger = Number.isInteger || function(value) {
    return typeof value === 'number' && isFinite(value) && Math.floor(value) === value;
  }
4.Number.isSafeInteger()用來(lái)判斷傳入的參數(shù)是否是一個(gè)“安全整數(shù)”

比如：2^53-1是一個(gè)安全整數(shù)，它能被精確表示，在任何IEEE-754舍入模式下，沒(méi)有其他整數(shù)舍入結(jié)果為該整數(shù)。作為對(duì)比，2^53就不是一個(gè)安全整數(shù)，它能夠使用IEEE-754表示，但是2^53+1不能使用IEEE-757直接表示，在就近舍入和向零舍入中，會(huì)被舍入為2^53。

安全整數(shù)范圍為-(2^53-1)到2^53-1之間的整數(shù)，包含-(2^53-1)和2^53-1

語(yǔ)法：

  Number.isSafeInteger(testValue);

  // 返回值：一個(gè)布爾值表示給定的值是否是一個(gè)安全整數(shù)
示例：

  console.log(Number.isSafeInteger(3)); // true
  console.log(Number.isSafeInteger(Math.pow(2,53))); // false
  console.log(Number.isSafeInteger(Math.pow(2,53)-1)); // true
  console.log(Number.isSafeInteger(NaN)); // false
  console.log(Number.isSafeInteger(Infinity)); // false
  console.log(Number.isSafeInteger('3')); // false
  console.log(Number.isSafeInteger(3.1)); // false
  console.log(Number.isSafeInteger(3.0)); // true
Polyfill

  Number.isSafeInteger = Number.isSafeInteger || function(value) {
    return Number.isInteger(value) && Math.abs(value) <= Number.MAX_SAFE_INTEGER;
  }

類型轉(zhuǎn)換類：parseFloat/parseInt

1.Number.parseInt()方法依據(jù)指定基數(shù)[參數(shù)radix的值]，把字符串[參數(shù)string的值]解析成整數(shù)。
語(yǔ)法：

  Number.parseInt(string[, radix]);
Number.parseInt()與parseInt()函數(shù)是同一個(gè)函數(shù)：Number.parseInt === parseInt;// true
附：parseInt()函數(shù)解析一個(gè)字符串參數(shù)，并返回一個(gè)指定基數(shù)的整數(shù)。
語(yǔ)法：

  parseInt(string, radix);

  // 參數(shù) 
  string // 要被解析的值。如果參數(shù)不是一個(gè)字符串，則將其轉(zhuǎn)換為字符串。字符串開頭的空白符將會(huì)被忽略。
  radix // 一個(gè)介于2和36之間的整數(shù)，表示上述字符串的基數(shù)。比如參數(shù)'10'表示使用我們通常使用的十進(jìn)制數(shù)值系統(tǒng)。始終指定此參數(shù)可以取消閱讀該代碼時(shí)的困惑并且保證轉(zhuǎn)換結(jié)果可預(yù)測(cè)。當(dāng)未指定基數(shù)時(shí)，不同的實(shí)現(xiàn)會(huì)產(chǎn)生不同的結(jié)果，通常將默認(rèn)值認(rèn)為10。

  // 返回值：返回解析后的整數(shù)值。如果被解析的第一個(gè)字符無(wú)法被轉(zhuǎn)化成數(shù)值類型，則返回NaN
  
  // 注： radix參數(shù)為n將會(huì)把第一個(gè)參數(shù)看作是一個(gè)數(shù)的n進(jìn)制表示，而返回的值則是十進(jìn)制的。

一些數(shù)中可能包含e字符，使用parseInt去截取包含e字符數(shù)值部分會(huì)造成難以預(yù)料的結(jié)果。


  console.log(parseInt('6.022e23', 10)); // 6
  console.log(parseInt(6.022e23, 10)); // 6

如果parseInt遇到了不屬于radix參數(shù)所指定的基數(shù)中的字符那么該字符和其后的字符都將被忽略。接著返回已經(jīng)解析的整數(shù)部分。parseInt將截取整數(shù)部分。開頭和結(jié)尾的空白符允許存在，會(huì)被忽略。


  console.log(parseInt('F', 16)); // 15
  console.log(parseInt('FXX123', 16)); // 15,X和X之后的字符被省略
  console.log(parseInt('15 * 3', 10)); // 15
  console.log(parseInt(1123, 2)); // 3

在基數(shù)為undefined，或者基數(shù)為0或者沒(méi)有指定的情況下，JavaScript作如下處理：

  • 如果字符串string以'0x'或者'0X'開頭，則基數(shù)是16（16進(jìn)制）
  • 如果字符串string以'0'開頭，基數(shù)是8（八進(jìn)制）或者10（十進(jìn)制），那么具體是哪個(gè)基數(shù)由實(shí)現(xiàn)環(huán)境決定。ECMAScript 5規(guī)定使用10，但是并不是所有瀏覽器都遵循這個(gè)規(guī)定。因此，永遠(yuǎn)都要給出明確的radix參數(shù)值。
  • 如果字符串string以其他任何值開頭，則基數(shù)是10（十進(jìn)制）

  console.log(parseInt('012')); // 12 
  console.log(parseInt('012', 8)); // 10 
  console.log(parseInt('08')); // 8
  console.log(parseInt('08', 8)); // 0
  console.log(parseInt('0xF')); // 15
  console.log(parseInt('F', 16)); // 15

  // 可見chrome瀏覽器認(rèn)為0開頭的基數(shù)是10

如果一個(gè)字符不能被轉(zhuǎn)換成數(shù)字，parseInt返回NaN。 算數(shù)上NaN不是任何一個(gè)進(jìn)制下的數(shù)。


  console.log(parseInt('Hello', 8)); // NaN
  console.log(parseInt('546', 2)); // NaN
  console.log(parseInt('-F', 16)); // -15
  console.log(parseInt('  -0F', 16)); // -15
  console.log(parseInt('  -0xF  ', 16)); // -15
  console.log(parseInt('-15e01', 10)); // -15

  console.log(parseInt(4.9, 10)); // 4
  console.log(parseInt(4.7 * 1e22, 10)); // 4 非常大的數(shù)值變成4
  console.log(parseInt(0.00000000000000434, 10)); // 4 非常小的數(shù)值變成4
  console.log(parseInt(0.0000000000000034, 10)); // 3 非常小的數(shù)值變成3
  console.log(parseInt(0.04, 10)); // 0

一個(gè)更嚴(yán)格的解析函數(shù)：MDN上的一個(gè)方法，但是感覺和parseInt差別很大，這個(gè)方法指示找出數(shù)字然后顯示，和進(jìn)制也沒(méi)有太大關(guān)系。


  let filterInt = function(value) {
    if(/^(\-|\+)?([0-9]+|Infinity)$/.test(value)){
      return Number(value);
    } else {
      return NaN;
    }
  };
2.Number.parseFloat()可以把一個(gè)字符串解析成浮點(diǎn)數(shù)。該方法和全局parseFloat()函數(shù)相同，并且處于ECMAScript 6 規(guī)范中。
附：parseFloat()函數(shù)解析一個(gè)字符串參數(shù)并返回一個(gè)浮點(diǎn)數(shù)。
語(yǔ)法：

  parseFloat(value);

  // 參數(shù)
  value // 需要被解析成為浮點(diǎn)數(shù)的值

  // 返回值：給定值被解析成浮點(diǎn)數(shù)，如果給定值不能被轉(zhuǎn)換成數(shù)值，則返回NaN
parseFloat將它的字符串參數(shù)解析成為浮點(diǎn)數(shù)并返回.如果在解析過(guò)程中遇到了正負(fù)號(hào)(+或-),數(shù)字(0-9),小數(shù)點(diǎn),或者科學(xué)記數(shù)法中的指數(shù)(e或E)以外的字符,則它會(huì)忽略該字符以及之后的所有字符,返回當(dāng)前已經(jīng)解析到的浮點(diǎn)數(shù).同時(shí)參數(shù)字符串首位的空白符會(huì)被忽略。

如果參數(shù)字符串的第一個(gè)字符不能被解析成為數(shù)字,則parseFloat返回NaN。


  console.log(parseFloat('3.14')) // 3.14
  console.log(parseFloat('3.14.15')) // 3.14
  console.log(parseFloat('314e-2')) // 3.14
  console.log(parseFloat('314e-2e-1')) // 3.14
  console.log(parseFloat('0.0314E+2')) // 3.14
  console.log(parseFloat('0.0314E+2E+1')) // 3.14
  console.log(parseFloat('3.14more non-digit characters')) // 3.14
  console.log(parseFloat('FF2')); // NaN

更嚴(yán)格的轉(zhuǎn)換函數(shù)：


  let filterFloat = function(value) {
    if(/^(\-|\+)?|(\.\d+)(\d+(\.\d+)?|(\d+\.)|Infinity)$/
      .test(value)){
      return Number(value);
    } else {
      return NaN;
    }
  }
  console.log(filterFloat('3.14')) // 3.14
  console.log(filterFloat('3.14.15')) // NaN
  console.log(filterFloat('314e-2')) // 3.14
  console.log(filterFloat('314e-2e-1')) // NaN
  console.log(filterFloat('0.0314E+2')) // 3.14
  console.log(filterFloat('0.0314E+2E+1')) // NaN
  console.log(filterFloat('3.14more non-digit characters')); // NaN

========== 實(shí)例屬性 =========

Number.prototype.constructor 返回創(chuàng)建該實(shí)例對(duì)象的構(gòu)造函數(shù)，默認(rèn)為Number對(duì)象

========= 實(shí)例方法 ==========

所有Number實(shí)例都繼承自Number.prototype。被修改的 Number 構(gòu)造器的原型對(duì)象對(duì)全部 Number 實(shí)例都生效。

修改表示形式類: toExponential/toFixed/toPrecision

1.toFixed()方法使用定點(diǎn)表示法來(lái)格式化一個(gè)數(shù)。

語(yǔ)法：

  numObj.toFixed(digits);

  // 參數(shù)
  digits // 小數(shù)點(diǎn)后數(shù)字的個(gè)數(shù)；介于0 到 20（包括）之間，實(shí)現(xiàn)環(huán)境可能支持更大范圍。如果忽略該參數(shù)，則默認(rèn)為0。

  // 返回值：所給數(shù)值的定點(diǎn)數(shù)表示法的字符串形式

  // 拋出異常
  rangeError // 如果 digits 參數(shù)太小或太大。0 到 20（包括）之間的值不會(huì)引起 RangeError。實(shí)現(xiàn)環(huán)境（implementations）也可以支持更大或更小的值。

  TypeError // 如果該方法在一個(gè)非Number類型的對(duì)象上調(diào)用。

一個(gè)數(shù)值的字符串表現(xiàn)形式，不使用指數(shù)計(jì)數(shù)法，而是在小數(shù)點(diǎn)后有digits位數(shù)字。該數(shù)值在必要時(shí)進(jìn)行四舍五入，另外在必要時(shí)會(huì)用0來(lái)填充小數(shù)部分，以便小數(shù)部分有指定的位數(shù)。如果數(shù)值大于1e+21，該方法會(huì)簡(jiǎn)單調(diào)用Number.prototype.toString()并返回一個(gè)指數(shù)計(jì)數(shù)法格式的字符串。


  let numObj = 12345.6789;

  console.log(numObj.toFixed()); // '12346'
  console.log(numObj.toFixed(1)); // '12345.7'
  console.log(numObj.toFixed(6)); // '12345.678900'

  console.log((1.23e+20).toFixed(2)); // '123000000000000000000.00'
  console.log((1.23e+22).toFixed(2)); // '1.23e+22' 大于1e+21會(huì)返回指數(shù)計(jì)數(shù)法
  console.log((1.23e-10).toFixed(2)); // '0.0'

  console.log(2.34.toFixed(1)); // '2.3'
  console.log(-2.34.toFixed(1)); // -2.3 由于操作符優(yōu)先級(jí)，負(fù)數(shù)不會(huì)返回字符串
  console.log((-2.34).toFixed(1)); // '-2.3' 若用括號(hào)提高優(yōu)先級(jí)，則返回字符串
2.toExponential() 以指數(shù)表示法返回該數(shù)值字符串表示形式。
語(yǔ)法：

  numObj.toExponential(fractionDigits);

  // 參數(shù)
  fractionDigits // 可選。一個(gè)整數(shù)，用來(lái)指定小數(shù)點(diǎn)后有幾位數(shù)字。默認(rèn)情況下用盡可能多的位數(shù)來(lái)顯示數(shù)字

  // 返回值：一個(gè)用冪的形式來(lái)表示Number對(duì)象的字符串

  // 異常
  RangeError // 如果 fractionDigits 太小或太大將會(huì)拋出該錯(cuò)誤。介于 0 和 20（包括20）之間的值不會(huì)引起 RangeError 。 執(zhí)行環(huán)境也可以支持更大或更小范圍。

  TypeError // 如果該方法在一個(gè)非數(shù)值類型對(duì)象上調(diào)用。

對(duì)數(shù)值字面量使用toExponential()方法，且該數(shù)值沒(méi)有小數(shù)點(diǎn)和指數(shù)時(shí)，應(yīng)該在該數(shù)值與該方法之間隔開一個(gè)空格，以避免點(diǎn)號(hào)被解釋為一個(gè)小數(shù)點(diǎn)。也可以使用兩個(gè)點(diǎn)號(hào)調(diào)用該方法。

如果一個(gè)數(shù)值的小數(shù)位數(shù)多于fractionDigits參數(shù)所提供的，則該數(shù)值將會(huì)在fractionDigits指定的小數(shù)位數(shù)處四舍五入（四舍五入規(guī)則參考toFixed方法的描述）。


  let numObj = 12345.6789;

  console.log(numObj.toExponential()); // '1.23456789e+4'
  console.log(numObj.toExponential(1)); // '1.2e+4'
  console.log(numObj.toExponential(10)); // '1.2345678900e+4'

  console.log( 77.toExponential()); // Uncaught SyntaxError: Invalid or unexpected token
  console.log( 77 .toExponential()); // 7.7e+1
  console.log( 77..toExponential()); // 7.7e+1
3.toPrecision()以指定的精度返回?cái)?shù)值對(duì)象的字符串表示。
語(yǔ)法：

  numObj.toPrecision(precision);

  // 參數(shù)
  precision // 可選。一個(gè)用來(lái)指定有效數(shù)個(gè)數(shù)的整數(shù)。

  // 返回值：以定點(diǎn)表示法或指數(shù)表示法表示的一個(gè)數(shù)值對(duì)象的字符串表示，四舍五入到precision參數(shù)指定的顯示數(shù)字位數(shù)（四舍五入規(guī)則參考toFixed里方法的描述）
  
  // 如果忽略 precision 參數(shù)，則該方法表現(xiàn)類似于 Number.prototype.toString()。如果該參數(shù)是一個(gè)非整數(shù)值，將會(huì)向下舍入到最接近的整數(shù)。
   
  // 異常 rangeError
  // 如果 precison 參數(shù)不在 1 和 100 （包括）之間，將會(huì)拋出一個(gè) RangeError 。執(zhí)行環(huán)境也可以支持更大或更小的范圍。ECMA-262 只需要最多 21 位顯示數(shù)字。
示例：

  let numObj = 12345.6789;

  console.log(numObj.toPrecision()); // 12345.6789
  console.log(numObj.toPrecision(5)); // 12346
  console.log(numObj.toPrecision(10)); // 12345.67890
  console.log(numObj.toPrecision(1)); // 1e+4

公有方法: toString/toLocaleString/valueOf

1.toString()返回指定Number對(duì)象的字符串表示形式。
語(yǔ)法：

  numObj.toString([radix]);

  radix // 指定要用于數(shù)字到字符串的轉(zhuǎn)換的基數(shù)（從2到36）。如果未指定radix參數(shù)，則默認(rèn)值為10。

  // 異常信息
  RangeError // 如果 toString() 的 radix 參數(shù)不在 2 到 36 之間，將會(huì)拋出一個(gè) RangeError。

Number覆蓋了Object對(duì)象上的toString()方法，它不是繼承的Object.prototype.toString()。

如果對(duì)象是負(fù)數(shù)，則會(huì)保留負(fù)號(hào)。即使radix是2時(shí)也是如此：返回的字符串包含一個(gè)負(fù)號(hào)（-）前綴和正數(shù)的二進(jìn)制表示，不是數(shù)值的二進(jìn)制補(bǔ)碼。


  let count = 10;

  console.log(count.toString()); // 10
  console.log(17.toString()); // Uncaught SyntaxError: Invalid or unexpected token
  console.log(17 .toString()); // 17
  console.log((17).toString()); // 17
  console.log(17.2.toString()); // 17.2

  console.log(254 .toString(16)); // fe
  console.log(-10 .toString(2)); // -1010

  // 還是要注意點(diǎn)號(hào)的意義
2.toLocaleString()方法涉及到字符編碼，隨后學(xué)習(xí): Number.prototype.toLocaleString
3.valueOf()返回一個(gè)被Number對(duì)象包裝的原始值。
語(yǔ)法：

  numObj.valueOf();

  // 返回值： 表示指定Number對(duì)象的原始值的數(shù)字
示例：

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

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

  console.log(10 .valueOf()); // 10
  console.log(typeof 10 .valueOf()); // number

參考文檔：https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Number

最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請(qǐng)聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時(shí)請(qǐng)結(jié)合常識(shí)與多方信息審慎甄別。
平臺(tái)聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點(diǎn)，簡(jiǎn)書系信息發(fā)布平臺(tái)，僅提供信息存儲(chǔ)服務(wù)。

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容