JavaScript Math 對象

時間 2019-11-25

原文原文鏈接

本文由我從網上整理而來、、、

Math 對象用於在 JavaScript 進行常見的數學計算。javascript

與 String、Date 對象不一樣的是，Math 對象並非對象的類，沒有構造函數 Math()，所以無需建立 Math 對象而能夠直接使用 Math 對象。一樣的，Math 對象內的方法也是靜態方法，能夠經過 Math.function 的方式直接使用。html

提示

若是進行普通的加減乘除等運算，請參考《JavaScript 運算符》一節的具體內容。java

Math 對象屬性

JavaScript 提供 8 種 Math 對象的屬性，表示一些經常使用的算術值：dom

屬性	說明
Math.E	算術常量 e，即天然對數的底數（約等於2.718）
Math.LN2	2 的天然對數（約等於0.693）
Math.LN10	10 的天然對數（約等於2.302）
Math.LOG2E	以 2 爲底的 e 的對數（約等於 1.414）
Math.LOG10E	以 10 爲底的 e 的對數（約等於0.434）
Math.PI	圓周率（約等於3.14159）
Math.SQRT1_2	2 的平方根的倒數（約等於 0.707）
Math.SQRT2	2 的平方根（約等於 1.414）

使用 Math 的屬性

Math 對象的上述屬性能夠直接使用：ide

<script language="JavaScript">

var pi = Math.PI;
document.write( pi );

</script>

運行該例子，輸出：函數

3.141592653589793

Math 對象方法

Math 對象還提供了以下方法用於處理常見的數學計算：spa

方法	說明
Math.abs	獲得數的絕對值
Math.acos	獲得數的反餘弦值
Math.asin	獲得數的反正弦值
Math.atan	獲得數的反正切值
Math.atan2(y,x)	從 x 軸到點 (x,y) 的角度值（介於 -PI 與 PI 弧度之間）
Math.ceil	向上取整（大於或等於當前數的整數），與 floor() 相反
Math.cos	獲得數的餘弦值
Math.exp(x)	獲得 e 的 x 次冪
Math.floor	向下取整（小於或等於當前數的整數），與 ceil() 相反
Math.log	獲得數的天然對數值（底爲e）
Math.max	獲得參數中最大的數，與 min() 相反
Math.min	獲得參數中最小的數，與 max() 相反
Math.pow(x,y)	獲得 x 的 y 次冪的值
Math.random	獲得 0 ~ 1 之間的隨機數
Math.round	按照四捨五入的規則取整
Math.sin	獲得一個數字的正弦值
Math.sqrt	獲得一個數的平方根
Math.tan	獲得一個數字的正切值

1. Math 對象

1.1 介紹

　　Math 對象，是數學對象，提供對數據的數學計算，如：獲取絕對值、向上取整等。無構造函數，沒法被初始化，只提供靜態屬性和方法。對象

1.2 構造函數

　　無：Math 對象無構造函數，沒法被初始化，只提供靜態屬性和方法。

1.3 靜態屬性

1.3.1 Math.E ：常量e。返回天然對數的底數：2.718281828459045

1.3.2 Math.PI ：常量π。返回圓周率的值：3.141592653589793

1.4 靜態方法

1.4.1 Math.sin(value) ：正弦函數
1.4.2 Math.cos(value) ：餘弦函數
1.4.3 Math.tan(value) ：正切函數
1.4.4 Math.asin(value) ：反正弦函數
1.4.5 Math.acos(value) ：反餘弦函數
1.4.6 Math.atan(value) ：反正切函數

1.4.7 Math.abs(value) ：返回絕對值

參數：

①value {Number | NumberStr} ：數字或者純數字的字符串。

返回值：

{Number} 返回參數的絕對值數字。若參數不爲數字，返回NaN。

示例：

 
         Math.abs( 
         '123' 
         );  
         // => 123 ：純數字字符串 
        
         Math.abs( 
         '-123' 
         );  
         // => 123 
        
         Math.abs(123);  
         // => 123 
        
         Math.abs(-123);  
         // => 123 
        
         Math.abs( 
         '123a' 
         );  
         // => NaN ：非純數字字符串

1.4.8 Math.ceil(value) ：對一個數向上取整，並非四捨五入

參數：

①value {Number | NumberStr} ：數字或者純數字的字符串。

返回值：

{Number} 返回取整後的值。若參數不爲數字，返回NaN。

示例：

 
         Math.ceil(2.7);  
         // => 3 
        
         Math.ceil(2.3);  
         // => 3 ：2.3 向上取整返回 3 
        
         Math.ceil(-2.7);  
         // => -2 
        
         Math.ceil(-2.3);  
         // => -2 
        
         Math.ceil( 
         '2.7' 
         );  
         // => 3 ：純數字字符串 
        
         Math.ceil( 
         '2.7a' 
         );  
         // => NaN ：非純數字字符串

1.4.9 Math.floor(value) ：對一個數向下取整，並非四捨五入

參數：

①value {Number | NumberStr} ：數字或者純數字的字符串。

返回值：

{Number} 返回取整後的值。若參數不爲數字，返回NaN。

示例：

 
         Math.floor(2.7);  
         // => 2 
        
         Math.floor(2.3);  
         // => 2 
        
         Math.floor(-2.7);  
         // => -3 ：-2.7 向下取整返回 -3 
        
         Math.floor(-2.3);  
         // => -3 
        
         Math.floor( 
         '2.7' 
         );  
         // => 2 ：純數字字符串 
        
         Math.floor( 
         '2.7a' 
         );  
         // => NaN ：非純數字字符串

1.4.10 Math.max(value1,value2...valueN) ：返回參數中最大的值

參數：

①value1,value2.....valueN {Number | NumberStr} ：數字或者純數字的字符串。

返回值：

{Number} 返回最大值。若一個參數不爲數字，返回NaN。

示例：

 
         Math.max(1, 2, 3, 4, 5);  
         // => 5 
        
         Math.max(1, 2, 3, 4,  
         '5'  
         );  
         // => 5 
        
         Math.max(1, 2, 3, 4,  
         'a' 
         );  
         // => NaN

1.4.11 Math.min(value1,value2...valueN) ：返回參數中最小的值

參數：

①value1,value2.....valueN {Number | NumberStr} ：數字或者純數字的字符串。

返回值：

{Number} 返回最大值。若一個參數不爲數字，返回NaN。

示例：

 
         Math.min(1, 2, 3, 4, 5);  
         // => 1 
        
         Math.min( 
         '1' 
         , 2, 3, 4, 5);  
         // => 1 
        
         Math.min(1, 2, 3, 4,  
         'a' 
         );  
         // => NaN

1.4.12 Math.pow(x,y) ：返回x的y次方

參數：

①x {Number | NumberStr} ：數字或者純數字的字符串。

②y {Number | NumberStr} ：數字或者純數字的字符串。

返回值：

{Number} 返回x的y次方。若一個參數不爲數字，返回NaN。

示例：

 
         Math.pow(2, 3);  
         // => 8 ：2的3次方 
        
         Math.pow(3, 2);  
         // => 9 ：3的2次方 
        
         Math.pow( 
         '4' 
         , 2);  
         // => 16 ：4的2次方 
        
         Math.pow( 
         '2a' 
         , 2);  
         // => NaN

1.4.13 Math.random() ：返回一個僞隨機數,大於0，小於1.0

參數：無

返回值：

{Number} 返回一個僞隨機數,大於0，小於1.0

示例：

 
         Math.random();  
         // => 0.8982374747283757 
        
         Math.random();  
         // => 0.39617531932890415 
        
         Math.random();  
         // => 0.35413061641156673 
        
         Math.random();  
         // => 0.054441051790490746

1.4.14 Math.round(value) ：四捨五入後取整

參數：

①value {Number | NumberStr} ：數字或者純數字的字符串。

返回值：

{Integer} 返回參數四捨五入後的整數。若參數不爲數字，返回NaN。

示例：

 
         Math.round(2.5);  
         // => 3 
        
         Math.round(2.4);  
         // => 2 
        
         Math.round(-2.6);  
         // => -3 
        
         Math.round(-2.5);  
         // => -2 ：-2.5四捨五入爲 -2 
        
         Math.round(-2.4);  
         // => -2 
        
         Math.round( 
         '2.7' 
         );  
         // => 3 ：純數字字符串 
        
         Math.round( 
         '2.7a' 
         );  
         // => NaN ：非純數字字符串

1.4.15 Math.sqrt(value) ：返回參數的平方根

參數：

①value {Number | NumberStr} ：數字或者純數字的字符串

返回值：

{Number} 返回參數的平方根

示例：

 
         console.log( Math.sqrt(9) );  
         // => 3 
        
         console.log( Math.sqrt(16) );  
         // => 4 
        
         console.log( Math.sqrt( 
         '25' 
         ) );  
         // => 5 
        
         console.log( Math.sqrt( 
         'a' 
         ) );  
         // => NaN

2. Number 對象

2.1 介紹

　　Number 對象，是數字對象，包含js中的整數、浮點數等等。

2.2 定義

2.3 靜態屬性

2.3.1 Number.MAX_VALUE ：表示JS中最大的數字，約爲 1.79e+308

2.3.2 Number.MIN_VALUE ：表示JS中最小的數字，約爲 5e-324

2.3.3 Number.NaN ：返回NaN，表示非數字值，與任意其餘數字不等，也包括NaN自己。應使用Number.isNaN() 來進行判斷。

2.3.4 Number.NEGATIVE_INFINITY ：返回 -Infinity ，表示負無窮。

2.3.5 Number.POSITIVE_INFINITY ：返回 Infinity ，表示正無窮。進行計算的值大於Number.MAX_VALUE就返回 Infinity 。

2.4 靜態方法

2.4.1 Number.isInteger(value) ：判斷參數是否爲整數

參數：

①value {Number} ：數字

返回值：

{Boolean} 返回參數是否爲整數。純整數的字符串也返回false。

示例：

 
         Number.isInteger(1);  
         // => true 
        
         Number.isInteger(1.1);  
         // => false 
        
         Number.isInteger( 
         '1' 
         );  
         // => false ：純整數的字符串也返回false 
        
         Number.isInteger( 
         '1.1' 
         );  
         // => false 
        
         Number.isInteger( 
         'a' 
         );  
         // => false ：非字符串返回false

2.4.2 Number.isNaN(value) ：判斷參數是否爲NaN

參數：

①value {Object} ：任意類型

返回值：

{Boolean} 返回參數是否爲NaN 。

示例：

 
         Number.isNaN(NaN);  
         // => true 
        
         Number.isNaN( 
         'NaN' 
         );  
         // => false :'NaN'字符串，並不爲NaN 
        
         Number.isNaN(1);  
         // => false 
        
         Number.isNaN( 
         '1' 
         );  
         // => false

2.4.3 Number.parseFloat(value) ：把參數轉換爲浮點數

參數：

①value {Number | NumberStr} ：數字或者純數字的字符串

返回值：

{Integer | Float} 返回整數或浮點數數值

示例：

 
         Number.parseFloat(1);  
         // => 1 ：整數仍是返回整數 
        
         Number.parseFloat(1.1);  
         // => 1.1 
        
         Number.parseFloat( 
         '1aaa' 
         );  
         // => 1 ：字符串前面爲數字的，只返回數字 
        
         Number.parseFloat( 
         '1.1aaa' 
         );  
         // => 1.1 
        
         Number.parseFloat( 
         'a1' 
         );  
         // => NaN ：非數字開頭，返回NaN 
        
         Number.parseFloat( 
         'a' 
         );  
         // => NaN

2.4.4 Number.parseInt(value) ：把參數轉換爲整數

參數：

①value {Number | NumberStr} ：數字或者純數字的字符串

返回值：

{Integer} 返回整數數值

示例：

 
         Number.parseInt(1);  
         // => 1 
        
         Number.parseInt(1.1);  
         // => 1 ：浮點數返回整數 
        
         Number.parseInt( 
         '1aaa' 
         );  
         // => 1 ：字符串前面爲數字的，只返回數字 
        
         Number.parseInt( 
         '1.1aaa' 
         );  
         // => 1 
        
         Number.parseInt( 
         'a1' 
         );  
         // => NaN ：非數字開頭，返回NaN 
        
         Number.parseInt( 
         'a' 
         );  
         // => NaN

2.5 實例方法

2.5.1 toExponential(value) ：將一個數字轉爲指數類型，參數表示小數點後的位數

參數：

①value {Number} ：表示小數點後的位數

返回值：

{String} 返回轉換後的指數類型字符串

示例：

 
         (123456789).toExponential(2);  
         // => 1.23e+8 ：小數點2位 
        
         (123456789).toExponential(5);  
         // => 1.23457e+8 ：小數點5位 
        
         (123456789).toExponential(10);  
         // => 1.2345678900e+8 ：小數點10位，不足位數用0補位

2.5.2 toFixed(value) ：將一個數字轉換爲指定小數位數的字符串。不傳入參數，就是沒小數位。返回值爲四捨五入

參數：

①value {Number} ：表示小數點後的位數

返回值：

{String} 返回轉換後的字符串；不夠小數位以0填充；返回值爲四捨五入後的值

示例：

 
         console.log((1).toFixed(2));  
         // => 1.00 
        
         console.log((1.2).toFixed(2));  
         // => 1.20 ：不足位數，以0補位 
        
         console.log((1.277).toFixed(2));  
         // => 1.28 ：進行了四捨五入

2.5.3 toString() ：使用指定的進制，將一個數字轉換爲字符串。不傳入參數，默認爲十進制。

參數：

①value {Number} ：表示進制數，取值範圍：2到36

返回值：

{String} 轉換後進制的字符串

示例：

 
         (10).toString();  
         // => 10 ：默認爲十進制 
        
         (10).toString(2);  
         // => 1010 ：二進制 
        
         (10).toString(10);  
         // => 10 ：十進制 
        
         (10).toString(16);  
         // => a ：十六進制

2.6 應用場景

2.6.1 浮點數的加減乘除異常

說明：Js中的2個浮點數進行加減乘除運算，會返回異常的數值，如：0.2+0.7，返回0.899999999999。可使用toFixed()方法，指定小數位。

示例：

 
         console.log(0.2 + 0.7);  
         // => 0.8999999999999999 
        
         console.log(0.7 - 0.5);  
         // => 0.19999999999999996 
        
         console.log(3.03 * 10);  
         // => 30.299999999999997 
        
         // 使用toFixed()方法 
        
         console.log( (0.2 + 0.7).toFixed(2) );  
         // => 0.90 
        
         console.log( (0.7 - 0.5).toFixed(2) );  
         // => 0.20  
        
         console.log( (3.03 * 10).toFixed(2) );  
         // => 30.30

2.6.2 減法運算

說明：Js中進行減法運算時，會先把先後的值轉換爲數值再進行運算。若轉換失敗，返回NaN。

示例：

 
         console.log( 
         '1'  
         - 0);  
         // => 1 ：純數字字符串減去0，能夠快速轉換爲Nubmer對象 
        
         console.log( ( 
         '1'  
         - 0).toFixed(2) );  
         // => 1.00 ：快速轉換爲Nubmer對象後調用實例方法 
        
         console.log( 
         '1'  
         -  
         'a' 
         );  
         // => NaN ：一方沒法轉換爲Nubmer對象