Numbers

More ways to write a number

在實際使用大數字的時候，我們會用縮寫，像是 10 億會寫成 1bn，在程式裡也可以使用縮寫。

let billion = 1e9;  // 1 billion, literally: 1 and 9 zeroes
alert( 7.3e9 );  // 7.3 billions (7,300,000,000)

1e3 = 1 * 1000
1.23e6 = 1.23 * 1000000

let ms = 0.000001;
let ms = 1e-6; // six zeroes to the left from 1

// -3 divides by 1 with 3 zeroes
1e-3 = 1 / 1000 (=0.001)

// -6 divides by 1 with 6 zeroes
1.23e-6 = 1.23 / 1000000 (=0.00000123)

Hex, binary and octal numbers

hex 在 JavaScript 被廣泛應用，簡短的縮寫 0x + number 。

alert( 0xff ); // 255
alert( 0xFF ); // 255 (the same, case doesn't matter)

let a = 0b11111111; // binary form of 255
let b = 0o377; // octal form of 255
alert( a == b ); // true, the same number 255 at both sides

toString(base)

num.toString(base) 方法可以將 num 返回 string 用 base 數字系統。

• base = 16，16進位，返回 0-9 a-f。

• base = 2，2進位，返回 0-1。

• base = 36，36進位，返回 0-9 a-z。

let num = 255;

alert( num.toString(16) );  // ff
alert( num.toString(2) );   // 11111111

Two dots to call a method

如果要對數字直接使用方法要用 .. 如果使用 . JavaScript 會認為使用小數點會造成錯誤。

alert( 123456..toString(36) ); // 2n9c
alert( (123456).toString(36) ); // same 

Rounding

• Math.floor：無條件退位

• Math.ceil：無條件進位

• Math.round：四捨五入

• Math.trunc (not supported by Internet Explorer)：無條件捨去

	Math.floor	Math.ceil	Math.round	Math.trunc
3.1	3	4	3	3
3.6	3	4	4	3
-1.1	-2	-1	-1	-1
-1.6	-2	-1	-2	-1

以上都是進位到整數的方法，若需要盡味道特定小數點後幾位，有 2 種方法：

1. Multiply-and-divide.

   let num = 1.23456;
   
   alert( Math.floor(num * 100) / 100 ); // 1.23456 -> 123.456 -> 123 -> 1.23

2. toFixed(n) 方法四捨五入數字返回 string 在用 Number()、+返回數字。

   let num = 12.34;
   alert( num.toFixed(1) ); // "12.3"
   
   let num = 12.36;
   alert( num.toFixed(1) ); // "12.4"
   
   let num = 12.34;
   alert( num.toFixed(5) ); // "12.34000", added zeroes to make exactly 5 digits

Imprecise calculations

數字用 64-bit 系統儲存，52-bit 用來儲存數字，11-bit 儲存小數點，1-bit 儲存正負符號。

// 數字太大
alert( 1e500 ); // Infinity

// 如同 10 進位 1/3 的運算無法整除，2 進位的系統也有無法整除的數字，造成不精確的小數位產生，其他語言也有相同情形。
alert( 0.1 + 0.2 == 0.3 ); // false
alert( 0.1 + 0.2 ); // 0.30000000000000004

// 解決的方法用 toFixed()
let sum = 0.1 + 0.2;
alert( +sum.toFixed(2) ); // 0.3

// 乘除運算可以降低錯誤但仍有錯誤產生
alert( (0.1 * 10 + 0.2 * 10) / 10 ); // 0.3
alert( (0.28 * 100 + 0.14 * 100) / 100); // 0.4200000000000001

The funny thing

// Hello! I'm a self-increasing number!
alert( 9999999999999999 ); // shows 10000000000000000

// 每個數字都有 1-bit 紀錄正負符號，因此有 +0 -0 產生，但這不影響計算。

Tests: isFinite and isNaN

number 類型有 2 個特別的值 Infinity NaN 需要特別的方法檢測他們。

• isNaN(value) 轉換參數為 number 檢測是否為 NaN，返回布林值。

  alert( isNaN(NaN) ); // true
  alert( isNaN("str") ); // true
  
  alert( NaN === NaN ); // false

• isFinite(value) 轉換參數為 number 檢測是否為 Infinity ，返回布林值。

  alert( isFinite("15") ); // true
  alert( isFinite("str") ); // false, because a special value: NaN
  alert( isFinite(Infinity) ); // false, because a special value: Infinity
  
  let num = +prompt("Enter a number", '');
  // will be true unless you enter Infinity, -Infinity or not a number
  alert( isFinite(num) );

parseInt and parseFloat

通常在類型轉換的時候數字後有單位，像是 '100px'、'12pt'，這時要使用 parseInt and parseFloat。

// 一般的轉換無法忽略單位
alert( +"100px" ); // NaN

// parseInt and parseFloat 讀取數字直到非數字
alert( parseInt('100px') ); // 100
alert( parseFloat('12.5em') ); // 12.5

// parseInt 返回整數，paseFloat 返回小數
alert( parseInt('12.3') ); // 12, only the integer part is returned
alert( parseFloat('12.3.4') ); // 12.3, the second point stops the reading

// 一開始就是非數字無法讀取
alert( parseInt('a123') ); // NaN, the first symbol stops the process

// parseInt(str, radix) 第 2 個參數設定讀取的數字系統
alert( parseInt('0xff', 16) ); // 255
alert( parseInt('ff', 16) ); // 255, without 0x also works

alert( parseInt('2n9c', 36) ); // 123456

Other math functions

• Math.random() 隨機產生介於 0-1 的數字，不包含 1。

  alert( Math.random() ); // 0.1234567894322
  alert( Math.random() ); // 0.5435252343232
  alert( Math.random() ); // ... (any random numbers)

• Math.max(a, b, c...) / Math.min(a, b, c...) 返回最大 / 最小的數字。

  alert( Math.max(3, 5, -10, 0, 1) ); // 5
  alert( Math.min(1, 2) ); // 1

• Math.pow(n, power) 返回數字的次方

  alert( Math.pow(2, 10) ); // 2 in power 10 = 1024