[ JavaScript Gossip ] JavaScript 核心 : 這些東西不簡單 (型態轉換)

轉載自 這裡 
在程式語言的分類上，有所謂強型別（Strong type）、弱型別（Weak type）語言，強弱之別是相對的，沒有絕對之分野. 如 Java 偏向強型別語言，在 Java 中運算或操作，較少有自動之型態轉換，舉例來說，字串就是字串，在 Java 中絕不可能直接作以下之操作 : 

view plaincopy to clipboardprint?

1. String number1 = "3";  
2. String number2 = "2";  
3. int result = number1 - number2; // error  

在強型別中，型態轉換或剖析必須明確操作。例如 : 

view plaincopy to clipboardprint?

1. String number1 = "3";  
2. String number2 = "2";  
3. int result = Integer.parseInt(number1) - Integer.parseInt(number2); // 明確指定淚行轉換  

JavaScript 是弱型別語言，字串的減法操作卻是可行的: 

> var number1 = '3'; var number2 = '2'; 
undefined 
> var result = number1 - number2 
undefined 
> result 
1 
> typeof result 
'number'

強型別語言必須明確進行型態轉換或剖析，避免了許多非預期的型態轉換錯誤，然而帶來了語法上的冗長，弱型別語言則相反，取得了語法簡潔的優點，但必須多注意非預期型態轉換的問題. JavaScript 的基本型態 number、string 與 boolean，會在必要的時候，自動型態轉換為對應的包裹物件 Number、String 與 Boolean。例如 : 

> var num = 10 
undefined 
> var binary = num.toString(2) 
undefined 
> binary 
'1010' 
> var binary = (10).toString(2) 
undefined 
> binary 
'1010'

num 變數指定的 10 型態是 number，但在作 toString() 操作時則是物件方有的方法，此時會自動使用 Number 實例來包裹 10 這個 number，因此你才可以操作 toString()。如果是實字表示，則可以加上 () 後直接操作 toString()， 同樣會為你自動進行型態轉換. 類似地，在對 string 作操作時，若必要，也會自動包裹為 String 的實例: 

> var text = 'john' 
undefined 
> text.toUpperCase() 
'JOHN' 
> 'john'.toUpperCase() 
'JOHN'

toUpperCase() 是 String 上定義的方法，執行環境必要時，會將 string 使用 String 包裹，才讓你操作 toUpperCase() 方法. 你可以直接建立包裹物件。例如 : 

js> var num = new Number(10); 
> var text = new String('john'); 
> typeof 10; 
number 
> typeof num; 
object 
> typeof 'john'; 
string 
> typeof text; 
object

關於Number、String與Boolean上可操作的方法，可參考 : 

* Number 
* String 
* Boolean

你也可以使用 parseInt()、parseFloat() 將字串轉換為數值，其好處是會自動忽略字串尾端非數字部份。例如 : 

js> parseInt('10 years old...XD'); 
10 
> parseFloat('3.14159......'); 
3.14159 
> parseInt('010', 10) 
10 
> parseInt('010', 8) // 使用 8 進位解析 
8

後兩個 parseInt() 分別指定了基數為 10 進位或 8 進位，如果字串以 0 開頭，則基數為 10 進位或 8 進位沒有定義，建議明確指定基數. 
對於字串，如果代表數字的話，可使用 +、-、*、/ 來作運算，不過要注意，+ 優先作字串的串接，而非轉換為數字作加法， -、*、/ 則會轉換為數字. 例如 : 

> '6' + '2' 
'62' 
> '6' - '2' 
4 
> '6' * '2' 
12 
> '6' / '2' 
3

在 JavaScript 中若結合布林值作 +、-、*、/ 等運算，true 會被當作 1，而 false 會被當作 0, 例如 : 

> 1 + true; 
2 
> 1 + false; 
1

布林值很有趣，在真假判斷式中，所有東西都可以轉換為布林值。一個口訣是 : 除了0、NaN、''、null、undefinied 是假的（false）之外，其它都是真的（true）。這些就是所謂 False Family成員! 例如，若物件上不存在某個特性，直接取用該特性會得到 undefined 的值，所以若想知道某物件上是否存在該特性，則可以如下 : 

> function exist(obj) 
... { 
... if(obj.x) { console.log('x exist.') } 
... else { console.log('x doesn\'t exist.') } 
... } 
undefined 
> var o = {} 
undefined 
> exist(o) 
x doesn't exist. 
undefined 
> o.x = 10 
10 
> exist(o) 
x exist. 
undefined

在 if 中，如果取得 undefined，則會當作 false，若取得特性值，只要不是 0，就會當作 true。如果你想避免 x 被設為 0、NaN、''、null 而造成誤判，則可以作更嚴格的檢查。例如 : 

view plaincopy to clipboardprint?

1. function exist(obj) {  
2.      if(typeof(obj.x) != 'undefined') {  
3.          output += 'x exists.\n';  
4.      } else {  
5.          output += 'x doesn\'t exist.\n';  
6.      }  
7. }  

型態轉換也會發生在相等性比較時，在 JavaScript 中有兩個相等性運算子 == 與 ===，都可以判斷值或物件參考是否相同，簡單來說，前者會嘗試將 == 兩邊轉換為同一型態，再比較是否相等，但後者只要 === 兩邊型態不一，就會判斷為false. 例如 : 

> '' == 0; 
true 
> '' === 0; 
false 
> null == undefined; 
true 
> null === undefined; 
false 
> 1 == true; 
true 
> 1 === true; 
false

簡單來說，== 執行較寬鬆的比較，可允許型態轉換後的比較，=== 執行較嚴格的比較，型態必須相同才有可能為true。不過，不確定時還是作測試來得好. 例如 : 

js> false == undefined; 
false // 是不是跟預期不一樣???

在弱型別語言中，型態轉換往往自動發生，最好還是實際測試了解結果，避免不必要的型態轉換而發生誤判或錯誤的運算結果。以上例而言，你還可以明確指定轉換 : 

js> false == Boolean(undefined); // 手動進行型態轉換 
true