数学对象Math

一、 Number 对象

JavaScript 的 Number 对象

Number 对象是经过封装的能让你处理数字值的对象。Number 对象由 Number() 构造器创建。

Number 对象主要用于：

如果参数无法被转换为数字，则返回 NaN。

在非构造器上下文中 (如：没有 new 操作符)，Number 能被用来执行类型转换。

JavaScript 数字

JavaScript 数字可以使用也可以不使用小数点来书写：

var pi=3.14; // 使用小数点

var x=34; // 不使用小数点

极大或极小的数字可通过科学（指数）计数法来写：

var y=123e5; // 12300000

var z=123e-5; // 0.00123

整数特性

2.1 取值范围

在JavaScript中，数字不分为整数类型和浮点型类型，所有的数字都是由浮点型类型。JavaScript采用IEEE754标准定义的64位浮点格式表示数字，它能表示最大值为±1.7976931348623157 x 10308，最小值为±5 x 10 -324。

在解析序列化的JSON时，如果JSON解析器将它们强制转换为Number类型，那么超出此范围的整数值可能会被破坏。

2.2 精度

整数（不使用小数点或指数计数法）最多为 15 位。

实例

var x = 999999999999999; // x 为 999999999999999

var y = 9999999999999999; // y 为 10000000000000000

小数的最大位数是 17，但是浮点运算并不总是 100% 准确：

实例

var x = 0.2+0.1;

document.getElementById("demo").innerHTML = x; // 输出结果为 0.30000000000000004

解决方案：

方法一：指定要保留的小数位数(0.1+0.2).toFixed(1) = 0.3;这个方法toFixed是进行四舍五入的也不是很精准，对于计算金额这种严谨的问题，不推荐使用，而且不同浏览器对toFixed的计算结果也存在差异。

方法二：将浮点数乘以（扩大）10的n次方倍，把浮点数变为整数后再进行相应的运算，最后将得到的结果除以（缩小）10的n次方倍。

console.log( （1*10 - 0.8*10）/10 ); //输出 0.2

console.log( 6 * 0.7*10/10 ); //输出 4.2

console.log( (0.1*10 + 0.2*10)/10 ); //输出 0.3

console.log( （0.1 *10+ 0.7*10）/10 ); //输出 0.8

console.log( 1.2 *10/（0.2 *10） ); //输出 6

转换数字字符串为数字

Number("123") // 123

Number("") // 0

Number("0x11") // 17注：0x代表十六进制的数字

Number("0b11") // 3 二进制

Number("0o11") // 9 八进制

Number("foo") // NaN

Number("100a") // NaN

八进制和十六进制

如果前缀为 0，则 JavaScript 会把数值常量解释为八进制数，如果前缀为 0 和 "x"，则解释为十六进制数。

实例

var y = 0o377;

var z = 0xFF;

注意：绝不要在数字前面写零，除非您需要进行八进制转换。

默认情况下，JavaScript 数字为十进制显示。

但是你可以使用 toString() 方法输出16进制、8进制、2进制。

实例

var myNumber=128;

myNumber.toString(16); // 返回 80

myNumber.toString(8); // 返回 200

myNumber.toString(2); // 返回 10000000

无穷大（Infinity）

当数字运算结果超过了JavaScript所能表示的数字上限（溢出），结果为一个特殊的无穷大（infinity）值，在JavaScript中以Infinity表示。同样地，当负数的值超过了JavaScript所能表示的负数范围，结果为负无穷大，在JavaScript中以-Infinity表示。无穷大值的行为特性和我们所期望的是一致的：基于它们的加、减、乘和除运算结果还是无穷大（当然还保留它们的正负号）。

NaN - 非数字值

NaN 属性是代表非数字值的特殊值。该属性用于指示某个值不是数字。可以把 Number 对象设置为该值，来指示其不是数字值。

你可以使用 isNaN() 全局函数来判断一个值是否是 NaN 值。

var x = 1000 / "Apple";

isNaN(x); // 返回 true

var y = 100 / "1000";

isNaN(y); // 返回 false

除以0是无穷大，无穷大是一个数字:

var x = 1000 / 0;

isNaN(x); // 返回 false

数字可以是数字或者对象

数字可以私有数据进行初始化，就像 x = 123;

JavaScript 数字对象初始化数据， var y = new Number(123);

var x = 123;

var y = new Number(123);

typeof(x) // 返回 Number

typeof(y) // 返回 Object

var x = 123;

var y = new Number(123);

(x === y) // 为 false，因为 x 是一个数字，y 是一个对象

使用 Number 转换 Date 对象

下例使用 Number 作为函数来转换 Date 对象为数字值：

var d = new Date("December 17, 1995 03:24:00");

print(Number(d));

这将输出 "819199440000"。

toFixed() 方法

toFixed() 方法可把 Number 四舍五入为指定小数位数的数字。

语法

NumberObject.toFixed(num)

参数描述

num 必需。规定小数的位数，是 0 ~ 20 之间的值，包括 0 和 20，有些实现可以支持更大的数值范围。如果省略了该参数，将用 0 代替。

返回值

返回 NumberObject 的字符串表示，不采用指数计数法，小数点后有固定的 num 位数字。如果必要，该数字会被舍入，也可以用 0 补足，以便它达到指定的长度。如果 num 大于 le+21，则该方法只调用 NumberObject.toString()，返回采用指数计数法表示的字符串。

实例，我们将把数字舍入为仅有一位小数的数字：

var num = new Number(13.37);

document.write (num.toFixed(1)) // 13.4

toPrecision() 方法

toPrecision() 方法可在对象的值超出指定位数时将其转换为指数计数法。

语法 number.toPrecision(x)

参数值

参数描述

x 必需。规定必须被转换为指数计数法的最小位数。该参数是 1 ~ 21 之间（且包括 1 和 21）的值。有效实现允许有选择地支持更大或更小的 num。如果省略了该参数，则调用方法 toString()，而不是把数字转换成十进制的值。

返回值: String 指定精度的数字格式

用不同进制把数字格式化为指定的长度:

var num = new Number(13.3714);

var a = num.toPrecision();

var b = num.toPrecision(2);

var c = num.toPrecision(3);

var d = num.toPrecision(10);

a,b,c, 和 d 输出结果:

13.3714

13.4

13.37140000

二、 JavaScript Math（算数）对象

Math 对象用于执行数学任务。

Math 对象并不像 Date 和 String 那样是对象的类，因此没有构造函数 Math()。

事例：

var x = Math.PI; // 返回PI

var y = Math.sqrt(16); // 返回16的平方根

1. Math 对象属性

属性	描述
E	返回算术常量 e，即自然对数的底数（约等于2.718）。Math.E
LN2	返回 2 的自然对数（约等于0.693）。
LN10	返回 10 的自然对数（约等于2.302）。
LOG2E	返回以 2 为底的 e 的对数（约等于 1.4426950408889634）。
LOG10E	返回以 10 为底的 e 的对数（约等于0.434）。
PI	返回圆周率（约等于3.14159）。
SQRT1_2	返回 2 的平方根的倒数（约等于 0.707）。
SQRT2	返回 2 的平方根（约等于 1.414）。

2. Math 对象方法

方法	描述
abs(x)	返回 x 的绝对值。
acos(x)	返回 x 的反余弦值。
asin(x)	返回 x 的反正弦值。
atan(x)	以介于 -PI/2 与 PI/2 弧度之间的数值来返回 x 的反正切值。
atan2(y,x)	返回从 x 轴到点 (x,y) 的角度（介于 -PI/2 与 PI/2 弧度之间）。
ceil(x)	对数进行上舍入。
cos(x)	返回数的余弦。
exp(x)	返回 Ex 的指数。
floor(x)	对 x 进行下舍入。
log(x)	返回数的自然对数（底为e）。
max(x,y,z,...,n)	返回 x,y,z,...,n 中的最高值。
min(x,y,z,...,n)	返回 x,y,z,...,n中的最低值。
pow(x,y)	返回 x 的 y 次幂。
random()	返回 0 ~ 1 之间的随机数。
round(x)	四舍五入取整。
sin(x)	返回数的正弦。
sqrt(x)	返回数的平方根。
tan(x)	返回角的正切。

1) abs() 方法

返回一个数的绝对值:

Math.abs(-7.25);

输出结果:

7.25

2) ceil() 方法

ceil() 方法[si:l]可对一个数进行上舍入，向上取整。

如果参数是一个整数，该值不变。

注意：ceil() 方法执行的是向上取整计算，它返回的是大于或等于函数参数，并且与之最接近的整数。

对一个数进行上舍入:

Math.ceil(1.4)

输出结果: 2

3) floor() 方法

floor() 方法返回小于等于输入值的最大整数。

如果传递的参数是一个整数，该值不变。

返回小于等于x的最大整数:

Math.floor(1.6);

以上实例将输出：1

4) round() 方法

round() 方法可把一个数字舍入为最接近的整数。

注意： 2.49 将舍入2 , 2.5 将舍入 3。

round() 方法可把一个数字舍入为最接近的整数：

Math.round(2.5);

输出结果： 3

5) random() 方法

random() 方法可返回介于 0（包含） ~ 1（不包含）之间的一个随机数。

返回介于 0（包含） ~ 1（不包含）之间的一个随机数：

Math.random();

输出结果：//随机数

取得介于 1 到 10 之间的一个随机数：

Math.floor((Math.random()*10)+1);

知识拓展：

属性

Number.EPSILON

两个可表示(representable)数之间的最小间隔。

这是ES6 在 Number 对象上面，新增的一个极小的常量 Number.EPSILON。根据规格，它表示1与大于1的最小浮点数之间的差。

对于64位浮点数来说，大于1的最小浮点数相当于二进制的1.00..001，小数点后面有连续51个零，这个值减去1之后，就等于2的-52次方。

Number.EPSILON === Math.pow(2, -52)

// true

Number.EPSILON

// 2.220446049250313e-16

Number.EPSILON.toFixed(20)

// "0.00000000000000022204" toFixed() 方法可把 Number 四舍五入为指定小数位数的数字。

Number.EPSILON 实际上是 JavaScript 能够表示的最小精度，误差如果小于这个值，就可以认为已经没有意义了，即不存在误差了。

其实引入一个这么小的量的目的，在于为浮点数计算，设置一个误差范围。我们知道浮点数计算是不精确的。

0.1 + 0.2

// 0.30000000000000004

0.1 + 0.2 - 0.3

// 5.551115123125783e-17

5.551115123125783e-17.toFixed(20)

// '0.00000000000000005551'

0.1 + 0.2 === 0.3 // false

这也就验证了为什么 0.1+0.2与0.3的到的结果是 false。

Number.EPSILON 可以用来设置“能够接受的误差范围”。比如，误差范围设为2的-50次方（即Number.EPSILON*Math.pow(2,2)），即如果两个浮点数的差小于这个值，我们就认为这两个浮点数相等。

5.551115123125783e-17 < Number.EPSILON * Math.pow(2, 2)

// true

因此，Number.EPSILON 的实质是一个可以接受的最小误差范围。

Number.MAX_SAFE_INTEGER

JavaScript 中最大的安全整数 (253 - 1)。

MAX_SAFE_INTEGER 是一个值为 9007199254740991的常量。

因为Javascript的数字存储使用了IEEE 754中规定的双精度浮点数数据类型，而这一数据类型能够安全存储 -(253 - 1) 到 253 - 1 之间的数值（包含边界值）。

这里安全存储的意思是指能够准确区分两个不相同的值，例如 Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2 将得到 true的结果，而这在数学上是错误的.

由于 MAX_SAFE_INTEGER 是Number的一个静态属性，所以不用自己动手为Number对象创建Number.MAX_SAFE_INTEGER这一属性，就可以直接使用它。

Number.MAX_VALUE

能表示的最大正数。最小的负数是 -MAX_VALUE。

MAX_VALUE 属性是 JavaScript 中可表示的最大的数。它的近似值为 1.7976931348623157 x 10308。

Number.MIN_SAFE_INTEGER

JavaScript 中最小的安全整数 (-(253 - 1)).

Number.MIN_VALUE

能表示的最小正数即最接近 0 的正数 (实际上不会变成 0)。它的近似值为 5 x 10-324。

最大的负数是 -MIN_VALUE。

Number.NaN

特殊的“非数字”值。

Number.NEGATIVE_INFINITY

特殊的负无穷大值，在溢出时返回该值。

Number.NEGATIVE_INFINITY 是一个特殊值，它在算术运算或函数生成一个比 JavaScript 能表示的最小负数还小的数（也就是比 -Number.MAX_VALUE 还小的数）时返回。

JavaScript 显示 NEGATIVE_INFINITY 时使用的是 -Infinity。这个值的算术行为和无穷大非常相似。例如，任何数乘无穷大结果仍为无穷大，任何数被无穷大除的结果为 0。

var x=(-Number.MAX_VALUE)*2

if (x==Number.NEGATIVE_INFINITY)

{

document.write("Value of x: " + x);

}

输出： Value of x: -Infinity

Number.POSITIVE_INFINITY

特殊的正无穷大值，在溢出时返回改值。

Number.prototype

Number 对象上允许的额外属性。

方法

Number.isNaN()

确定传递的值是否是 NaN。

Number.isFinite()

确定传递的值类型及本身是否是有限数。

Number.isInteger()

确定传递的值类型是“number”，且是整数。

Number.isInteger(25) // true

Number.isInteger(25.0) // true

Number.isInteger(25.1) // false

Number.isInteger("15") // false

Number.isInteger(true) // false

Number.isSafeInteger()

确定传递的值是否为安全整数 ( -(253 - 1) 至 253 - 1之间)。

5. Number.toInteger()

计算传递的值并将其转换为整数 (或无穷大)。

toFixed() 方法可把 Number 四舍五入为指定小数位数的数字。

语法

NumberObject.toFixed(num)

参数描述

num 必需。规定小数的位数，是 0 ~ 20 之间的值，包括 0 和 20，有些实现可以支持更大的数值范围。如果省略了该参数，将用 0 代替。

返回值：

6. Number.parseFloat()

和全局对象 parseFloat() 一样。

parseFloat() 函数可解析一个字符串，并返回一个浮点数。

该函数指定字符串中的首个字符是否是数字。如果是，则对字符串进行解析，直到到达数字的末端为止，然后以数字返回该数字，而不是作为字符串。

语法

parseFloat(string)

参数描述

string 必需。要被解析的字符串。

注意：字符串中只返回第一个数字。

注意：开头和结尾的空格是允许的。

注意：如果字符串的第一个字符不能被转换为数字，那么 parseFloat() 会返回 NaN。

document.write(parseFloat("10") + " ");

document.write(parseFloat("10.33") + " ");

document.write(parseFloat("34 45 66") + " ");

document.write(parseFloat(" 60 ") + " ");

document.write(parseFloat("40 years") + " ");

document.write(parseFloat("He was 40") + " ");

以上实例输出结果:

10.33

NaN

7. Number.parseInt()

和全局对象 parseInt() 一样。

parseInt() 函数可解析一个字符串，并返回一个整数。

当参数 radix 的值为 0，或没有设置该参数时，parseInt() 会根据 string 来判断数字的基数。

当忽略参数 radix , JavaScript 默认数字的基数如下:

如果 string 以 "0x" 开头，parseInt() 会把 string 的其余部分解析为十六进制的整数。

如果 string 以 0 开头，那么 ECMAScript v3 允许 parseInt() 的一个实现把其后的字符解析为八进制或十六进制的数字。

如果 string 以 1 ~ 9 的数字开头，parseInt() 将把它解析为十进制的整数。

语法

parseInt(string, radix)

参数描述

string 必需。要被解析的字符串。

radix 可选。表示要解析的数字的基数（进制）。该值介于 2 ~ 36 之间。

注意：只有字符串中的第一个数字会被返回。

注意：开头和结尾的空格是允许的。

注意：如果字符串的第一个字符不能被转换为数字，那么 parseInt() 会返回 NaN。

注意：在字符串以"0"为开始时旧的浏览器默认使用八进制基数。ECMAScript 5，默认的是十进制的基数。

document.write(parseInt("10") + " ");

document.write(parseInt("10.33") + " ");

document.write(parseInt("34 45 66") + " ");

document.write(parseInt(" 60 ") + " ");

document.write(parseInt("40 years") + " ");

document.write(parseInt("He was 40") + " ");

document.write(" ");

document.write(parseInt("10",10)+ " ");

document.write(parseInt("010")+ " ");

document.write(parseInt("10",8)+ " ");

document.write(parseInt("0x10")+ " ");

document.write(parseInt("10",16)+ " ");

结果：

NaN

posted @ 2021-08-10 14:18 小黄耗子阅读(294) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

数学对象Math

公告