Number数据类型

最新推荐文章于 2022-11-27 16:29:16 发布

前端全栈分享站

最新推荐文章于 2022-11-27 16:29:16 发布

阅读量797

点赞数

分类专栏： JavaScript 栏文章标签： javascript 原型模式 java

CSDN-CRJ

本文链接：https://blog.csdn.net/CRJ453027119/article/details/127635364

版权

JavaScript 栏专栏收录该内容

8 篇文章 0 订阅

订阅专栏

Number数据类型

属性

序号	方法	描述
1	`Number.EPSILON`	两个可表示(representable)数之间的最小间隔。
2	`Number.MAX_SAFE_INTEGER`	JavaScript 中最大的安全整数 (`253- 1`)。
3	`Number.MAX_VALUE`	能表示的最大正数。最小的负数是`-MAX_VALUE`。
4	`Number.MIN_SAFE_INTEGER`	JavaScript 中最小的安全整数 (`-(253- 1)`).
5	`Number.MIN_VALUE`	能表示的最小正数即最接近 0 的正数 (实际上不会变成 0)。最大的负数是`-MIN_VALUE`。
6	`Number.NaN`	特殊的“非数字”值
7	`Number.NEGATIVE_INFINITY`	特殊的负无穷大值，在溢出时返回该值。
8	`Number.POSITIVE_INFINITY`	特殊的正无穷大值，在溢出时返回改值。
9	`Number.prototype`	Number 对象上允许的额外属性。

方法

序号	方法	描述
1	`Number.isNaN()`	确定传递的值是否是 NaN。
2	`Number.isFinite()`	确定传递的值类型及本身是否是有限数。
3	`Number.isInteger()`	确定传递的值类型是“number”，且是整数。
4	`Number.isSafeInteger()`	确定传递的值是否为安全整数 ( -`(253 - 1)` 至 `253 - 1之间`)。
5	`Number.parseInt()`	`Number.parseInt()`和全局对象`parseInt()` 一样。
6	`Number.parseFloat()`	`Number.parseFloat()`和全局对象`parseFloat()` 一样。

实例方法

序号	方法	描述
1	`Number.prototype.toExponential()`	返回一个以指数表示法表示数字的字符串。
2	`Number.prototype.toFixed()`	返回以定点表示法表示数字的字符串。
3	`Number.prototype.toLocaleString()`	返回具有此数字的语言敏感表示形式的字符串。覆盖Object.prototype.toLocaleString（）方法。
4	`Number.prototype.toPrecision()`	返回一个字符串，以定点或指数表示法表示指定精度的数字。
5	`Number.prototype.toString()`	返回一个以指定基数（基数）表示指定对象的字符串。重写Object.prototype.toString（）方法。
6	`Number.prototype.valueOf()`	返回指定对象的原始值。重写Object.prototype.valueOf（）方法。

Number 详细描述

Number()

（1）如果是Boolean值，true和false将分别转换为1和0。
（2）如果是数字值，只是简单的传入和返回。
（3）如果是null值，返回0。
（4）如果是undefined,返回NaN。
（5）如果是字符串，遵循下列规则：

如果字符串截去开头和结尾的空白字符后，不是纯数字字符串，那么最终返回结果为NaN。
如果是字符串中只包含数字（包括前面带正号或负号的情况），则将其转换为十进制数值，即“1”变成1，“123”会变成123，而“011”会变成11（前导的零被忽略了）；
如果字符串中包含有效的浮点格式，如“1.1”，则将其转换为对应的浮点数值（同样也会忽略前导零）；
如果字符串中包含有效的十六进制格式，例如”0xf”，则将其他转换为相同大小的十进制整数值；
如果字符串是空的（不包含任何字符），则将其转换为0；
如果字符串中包含除上述格式之外的字符，则将其他转换成NaN.

（6）如果是对象，则调用对象的valueOf()方法，然后依照前面的规则转换返回的值。如果转换的结果是NaN，则调用的对象的toString()方法，然后再次依照前面的规则转换返回的字符串值。

let d = new Date('December 17, 1995 03:24:00');
console.log(Number(d)); // 819199440000

Number('123')     // 123
Number('12.3')    // 12.3
Number('')        // 0
Number('0x11')    // 17
Number('0b11')    // 3
Number('0o11')    // 9
Number('foo')     // NaN
Number('100a')    // NaN
Number(true);     //1
Number(false) // 0
Number("000011"); //11
Number(1) // 1
Number(100) // 100
Number(null) // 0
Number(undefined) // NaN

// 规则一
Number("1") // 1
Number("123") // 123
Number("010") // 10 (前导的0会被忽略)
Number("-10") // -10

// 规则2
Number("1.1") // 1.1
Number("0.1") // 0.1
Number("0000.1") // 0.1 (前导的0会被忽略)

// 规则3
Number(0xf) // 15

// 规则4
Number("") // 0
Number(" ") // 0
Number('') // 0

// 规则5
Number("Hello Wolrd") // NaN
Number("0ff6600") // NaN
Number("ff6600") // NaN
Number("0.1a") // NaN
Number("10a") // NaN
Number("a10.1") // NaN

var goodsList = {
    'pop':
}

var arr = [1,2,3,4]
Number(arr)

NAN

Not a Number：不是一个数，但它属于数值类型

NaN的特点

NaN和任何值进行操作都会返回NaN
NaN与任何值都不相等，包括NaN本身

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

属性1、Number.EPSILON

Number.EPSILON 实际上是 JavaScript 能够表示的最小精度，它表示 1 和大于 1 的最小浮点数之间的差，相当于 2 的 -52 次方

let num1 = Number.EPSILON
let num2 = Math.pow(2, -52) 
console.log(num1); // 2.220446049250313e-16
console.log(num2); // 2.220446049250313e-16
console.log(num1 === num2); // true

实例一 : 我们可以用它来设置能够接受的误差范围，比如，误差范围设为 2 的 -50 次方，如果两个浮点数的差小于这个值，我们就认为这两个浮点数相等

function withErrorMargin(left, right) {
  // Math.abs() 绝对值                  
  // Math.pow() 函数返回基数（base）的指数（exponent）次幂
  return Math.abs(left - right) < Number.EPSILON * Math.pow(2, 2);
}
0.1 + 0.2 === 0.3 // false
withErrorMargin(0.1 + 0.2, 0.3) // true
1.1 + 1.3 === 2.4 // false
withErrorMargin(1.1 + 1.3, 2.4) // true

属性2、Number.MAX_SAFE_INTEGER

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

let num1 = Number.MAX_SAFE_INTEGER
let num2 = Math.pow(2, 53) - 1 
console.log(num1); // 9007199254740991
console.log(num2); // 9007199254740991
console.log(num1 === num2); // true

属性3、Number.MAX_VALUE

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

let num = Number.MAX_VALUE
console.log(num); // 1.7976931348623157e+308

实例一：下面的代码求两个数值的乘积。如果结果小于等于 MAX_VALUE，则调用 func1函数；否则，调用 func2 函数。

if (num1 * num2 <= Number.MAX_VALUE) {
  func1();
} else {
  func2();
}

属性4、Number.MIN_SAFE_INTEGER

**Number.MIN_SAFE_INTEGER**代表在 JavaScript中最小的安全的integer型数字 (-(253- 1)).

let num1 = Number.MIN_SAFE_INTEGER
let num2 = -(Math.pow(2, 53) - 1)
console.log(num1); // -9007199254740991
console.log(num2); // -9007199254740991
console.log(num1 === num2); // true

属性5、Number.MIN_VALUE

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

let num = Number.MIN_VALUE
console.log(num); // 5e-324

实例一：

if (num1 / num2 >= Number.MIN_VALUE) {
  func1();
} else {
  func2();
}

属性6、Number.NaN

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

let num = Number.NaN
console.log(num); // NaN

属性7、8、Number.NEGATIVE_INFINITY | Number.POSITIVE_INFINITY

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

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

let num = Number.NEGATIVE_INFINITY 
console.log(num); // -Infinity
    
// 任何正值，包括 POSITIVE_INFINITY，乘以 NEGATIVE_INFINITY 为 NEGATIVE_INFINITY。
console.log(12 * num); // -Infinity
// 任何负值，包括 NEGATIVE_INFINITY，乘以 NEGATIVE_INFINITY 为 POSITIVE_INFINITY。
console.log(-12 * num); // Infinity
// 0 乘以 NEGATIVE_INFINITY 为 NaN.
console.log(0 * num); // NaN
// NaN 乘以 NEGATIVE_INFINITY 为 NaN.
console.log(NaN * num); // NaN
// NEGATIVE_INFINITY 除以任何负值（除了 NEGATIVE_INFINITY）为 POSITIVE_INFINITY。
console.log(num / -12); // Infinity
// NEGATIVE_INFINITY 除以任何正值（除了 POSITIVE_INFINITY）为 NEGATIVE_INFINITY。
console.log(num / 12); // -Infinity
// NEGATIVE_INFINITY 除以 NEGATIVE_INFINITY 或 POSITIVE_INFINITY 是 NaN。
console.log(num / num); // NaN
// 任何数除以 NEGATIVE_INFINITY 为 0。
console.log(12 / num); // -0

实例一：赋值给变量smallNumber一个明显小于 JavaScript 中的最小值的值。当 if语句执行时，smallNumber值为 “-Infinity”，因此在继续执行代码前，smallNumber被设为一个更容易管理的值。

var smallNumber = (-Number.MAX_VALUE) * 2;
if (smallNumber === Number.NEGATIVE_INFINITY) {
  smallNumber = returnFinite();
}

实例二：赋值给变量bigNumber一个大于 JavaScript 中最大值的值。当 if语句执行时，变量bigNumber值为 “Infinity”，因此在继续执行代码前，为变量bigNumber设置一个容易管理的值。

var bigNumber = Number.MAX_VALUE * 2;
if (bigNumber == Number.POSITIVE_INFINITY) {
  bigNumber = returnFinite();
}

方法1、Number.isNaN()

**Number.isNaN()**方法确定传递的值是否为NaN和其类型是Number。它是原始的全局isNaN()的更强大的版本。

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

和全局函数isNaN()相比，该方法不会强制将参数转换成数字，只有在参数是真正的数字类型，且值为NaN的时候才会返回true。

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

Number.isNaN('NaN');      // false
Number.isNaN(undefined);  // false
Number.isNaN({});         // false
Number.isNaN('blabla');   // false
Number.isNaN(true);   // false
Number.isNaN(null);   // false
Number.isNaN(37);     // false
Number.isNaN('37');   // false
Number.isNaN('37.37');// false
Number.isNaN('');     // false
Number.isNaN(' ');    // false

isNaN函数

用于检测一个变量不是数值（Number）类型。isNaN()接收一个参数，这个参数可以是任何类型。这个函数会尝试把传入的参数转换为数值，某些不是数值的值会直接转换成数值，例如字符串"10"或Boolean值,不能转换为数值的值返回true，能转换的返回false。

console.log( isNaN(NaN ) // true 
console.log( isNaN(10 ) // false
console.log( isNaN('10') // false
console.log( isNaN('blue') // true
console.log(isNaN( true )) // false (true会被转换成1)

总结：

isNaN意思是：是不是非数值，是的话返回true，所有能被该函数转换能Number类型的值，都返回false。
在使用isNaN进行检测的时候，首先会验证检测的值是否为数字类型，如果不是，先基于Number()这个方法，把值转换成数字类型，然后再检测。
空字符串、空数组、布尔值、null会转成数值，所以isNaN函数返回false。
空对象、函数、undefined不能转换成数值，返回true。

方法2、Number.isFinite()

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

和全局的 isFinite()函数相比，这个方法不会强制将一个非数值的参数转换成数值，这就意味着，只有数值类型的值，且是有穷的（finite），才返回 true。

Number.isFinite(Infinity);  // false
Number.isFinite(NaN);       // false
Number.isFinite(-Infinity); // false

Number.isFinite(0);         // true
Number.isFinite(2e64);      // true

Number.isFinite('0');       // false, would've been true with
                            // global isFinite('0')
Number.isFinite(null);      // false, would've been true with
                            // global isFinite(null)

方法3、Number.isInteger

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

如果被检测的值是整数，则返回true，否则返回false。注意NaN和正负Infinity不是整数。

Number.isInteger(0);         // true
Number.isInteger(1);         // true
Number.isInteger(-100000);   // true

Number.isInteger(0.1);       // false
Number.isInteger(Math.PI);   // false

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
Number.isInteger([]);        // false
Number.isInteger({});        // false

方法4、Number.isSafeInteger

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

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

方法5、Number.parseInt

**Number.parseInt()**方法可以根据给定的进制数把一个字符串解析成整数。

parseInt()函数可以将字符串转换成一个整数，与Number()函数相比，parseInt()函数不仅可以解析纯数字字符串，也可以解析以数字开头的部分数字字符串(非数字部分字符串在转换过程中会被去除)。
（1）如果第一个字符不是数字字符或者负号，parseInt()就会返回NaN; 也就是说，用parseInt()转换空字符串会返回NaN。
（2）如果第一个字符是数字字符，parseInt()会继续解析第二个字符，直到解析完所有后续字符或者遇到了一个非数字字符。
（3）如果字符串以”0x”开头且后跟数字字符，就会将其当作一个十六进制整数。
（4）如果字符串以”0”开头且后跟数字字符，就会将其当作一个八进制整数。
（5）parseInt()函数增加了第二参数用于指定转换时使用的基数（即多少进制）。
（6）当parseInt()函数所解析的是浮点数字符串时，取整操作所使用的方法为“向下取整”。

let num1=parseInt("num123");    //NaN
let num2=parseInt("");          //NaN
let num3=parseInt("123.45")     //123
let num4=parseInt("101010",2)   //42
let num5=parseInt("123num")     //123
let num6=parseInt("0xff")       //255
parseInt("123abc") // 123
parseInt("") // NaN
parseInt("12.5px") // 12
parseInt("0xA") // 10 (16进制)
parseInt("0xf") // 15 (16进制)
parseInt("070") // 70
parseInt("70") // 70

方法6、Number.parseFloat

**Number.parseFloat()**方法可以把一个字符串解析成浮点数。该方法与全局的parseFloat()函数相同，并且处于 ECMAScript 6 规范中（用于全局变量的模块化）。

与parseInt()一样，parseFloat()也可以解析以数字开头的部分数字字符串(非数字部分字符串在转换过程中会被去除)。与parseInt()不同的是，parseFloat()可以将字符串转换成浮点数；但同时，parseFloat()只接受一个参数，且仅能处理10进制字符串。
（1）字符串中的第一个小数点是有效的，而第二个小数点就是无效的了，因此它后面的字符串将被忽略。
（2）如果字符串包含的是一个可解析为整数的数（没有小数点，或者小数点后面都是零），parseFloat()会返回整数。

let num1=parseFloat("1234blue");    //1234
let num2=parseFloat("0xA");         //0
let num3=parseFloat("0908.5");      //908.5
let num4=parseFloat("3.125e7");     //31250000
let num5=parseFloat("123.45.67")    //123.45
let num6=parseFloat("")             //NaN
let num7=parseFloat("num123")       //NaN
parseFloat("3.14") // 3.14
parseFloat("-3.14") //-3.14
parseFloat("+3.14") //3.14
parseFloat("0003.14") // 3.14
parseFloat(" 3.14 ") // 3.14
parseFloat("3.14abc") // 3.14
parseFloat("3.14.5678") // 3.14
parseFloat("abc3.14") // NaN
parseFloat("abc123") // NaN
parseFloat("123abc") // 123

实例方法1、number.toExponential

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

let numObj = 77.1234;
console.log(numObj.toExponential());  // logs 7.71234e+1
console.log(numObj.toExponential(4)); // logs 7.7123e+1
console.log(numObj.toExponential(2)); // logs 7.71e+1
console.log(77.1234.toExponential()); // logs 7.71234e+1
console.log(77.toExponential());     // logs 7.7e+1

实例方法2、number.toFixed

toFixed()方法使用定点表示法来格式化一个数。

let numObj = 12345.6789;
numObj.toFixed();       // Returns '12346': note rounding, no fractional part
numObj.toFixed(1);      // Returns '12345.7': note rounding
numObj.toFixed(6);      // Returns '12345.678900': note added zeros
(1.23e+20).toFixed(2);  // Returns '123000000000000000000.00'
(1.23e-10).toFixed(2);  // Returns '0.00'
2.34.toFixed(1);        // Returns '2.3'
2.35.toFixed(1);        // Returns '2.4'. Note that it rounds up in this case.
-2.34.toFixed(1);       // Returns -2.3 (due to operator precedence, negative number literals don't return a string...)
(-2.34).toFixed(1);     // Returns '-2.3' (...unless you use parentheses)

实例方法3、number.toLocaleString

toLocaleString()方法返回这个数字在特定语言环境下的表示字符串。

新的locales和options参数让应用程序可以指定要进行格式转换的语言，并且定制函数的行为。在旧的实现中，会忽略locales和options参数，使用的语言环境和返回的字符串的形式完全取决于实现方式。

numObj.toLocaleString([locales [, options]])
var number = 3500;
console.log(number.toLocaleString()); // Displays "3,500" if in U.S. English locale
var number = 123456.789;
console.log(number.toLocaleString('de-DE'));
// → 123.456,789
console.log(number.toLocaleString('ar-EG'));
// → ١٢٣٤٥٦٫٧٨٩
console.log(number.toLocaleString('en-IN'));
// → 1,23,456.789
console.log(number.toLocaleString('zh-Hans-CN-u-nu-hanidec'));
// → 一二三,四五六.七八九
console.log(number.toLocaleString(['ban', 'id']));
// → 123.456,789


var number = 123456.789;

console.log(number.toLocaleString('de-DE', { style: 'currency', currency: 'EUR' }));
// → 123.456,79 €

console.log(number.toLocaleString('ja-JP', { style: 'currency', currency: 'JPY' }))
// → ￥123,457

console.log(number.toLocaleString('en-IN', { maximumSignificantDigits: 3 }));
// → 1,23,000

var num = 30000.65;
console.log(num.toLocaleString(undefined, {minimumFractionDigits: 2, maximumFractionDigits: 2}));
// → "30,000.65" where English is the default language, or
// → "30.000,65" where German is the default language, or
// → "30 000,65" where French is the default language

实例方法4、number.toPrecision

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

let numObj = 5.123456;
console.log(numObj.toPrecision());    // logs '5.123456'
console.log(numObj.toPrecision(5));   // logs '5.1235'
console.log(numObj.toPrecision(2));   // logs '5.1'
console.log(numObj.toPrecision(1));   // logs '5'

numObj = 0.000123
console.log(numObj.toPrecision());    // logs '0.000123'
console.log(numObj.toPrecision(5));   // logs '0.00012300'
console.log(numObj.toPrecision(2));   // logs '0.00012'
console.log(numObj.toPrecision(1));   // logs '0.0001' 

// note that exponential notation might be returned in some circumstances
console.log((1234.5).toPrecision(2)); // logs '1.2e+3'

实例方法5、number.toString

**toString()**方法返回指定Number 对象的字符串表示形式。

var count = 10;
console.log(count.toString());    // displays '10'
console.log((17).toString());     // displays '17'
console.log((17.2).toString());   // displays '17.2'
var x = 6;
console.log(x.toString(2));       // displays '110'
console.log((254).toString(16));  // displays 'fe'
console.log((-10).toString(2));   // displays '-1010'
console.log((-0xff).toString(2)); // displays '-11111111'

实例方法6、number.valueOf

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

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

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