平常我們都是不建議在程式碼上編寫一些比較難理解的程式碼，例如 x == y 和 'A' > 'B' 。這篇文章或許不能給你帶來什麼大的幫助，但是卻可以讓你瞭解一些你可能沒接觸到的知識點。

由於有些參考資料來源於 ECMA 規範，所以感興趣的可能需要先看《讀懂 ECMAScript 規格》這篇文章，當然也可以忽略。

型別之間的轉換表

首先我們需要先了解基本的型別轉換規則。

粗體需要特別留意的，可能跟你想象中的不一樣。

這裡根據上面的表格列舉些例子：

數字轉字串

這個最常用了，這個也很好理解。

String(123)

或者

const a = 123;
a.toString();

將字串轉換為數字

Number("3.14")    // 返回 3.14
Number(" ")       // 返回 0
Number("")        // 返回 0
Number("99 88")   // 返回 NaN
 

字串轉布林值

Boolean('test')  // 返回 true
Boolean('0')  // 返回 false
Boolean('000')  // 返回 true

== 比較運算子

規則來源於ECMA 相關規範 Abstract Equality Comparison。

==等同運算子的兩邊的型別不一樣的時候，會有型別自動轉換規則。

相同的型別可以直接比較（相當於===比較），無需自動轉換，不同型別有下面幾種自動轉換規則（x == y），規則優先順序自上而下：

如果 x 是 null，y 是 undefined，返回 true

null==undefined

如果 x 是 undefined，y 是 null，返回 true

undefined==null

如果 x 是 Number，y 是 String，將 y 轉化成 Number，然後再比較

0 == '0' // true
0 == '1' // false

如果 x 是 String，y 是 Number，將 x 轉化成 Number，然後再比較

'0' == 0 // true
'1' == 0 // false

如果 x 是 Boolean，那麼將 x 轉化成 Number，然後再比較

true == 0 // false
true == 1 // true
true == 2 // false
true == 'test' // false
false == 0 // true
false == 1 // false
false == 2 // false
false == 'test' // false

如果 y 是 Boolean，那麼將 y 轉化成 Number，然後再比較

0 == true // false
1 == true // true
2 == true // false
'test' == true // false
0 == false // true
1 == false // false
2 == false // false
'test' == false // false

如果 x 是 String 或者 Number，y 是 Object，那麼將 y 轉化成基本型別，再進行比較

const a = {}
1 == a    // false
'1' == a  // false

如果 x 是 Object，y 是 String 或者 Number，將 x 轉化成基本型別，再進行比較

const a = {}
a == 1    // false
a == '1'  // false

其他情況均返回 false

const a = {}
a == null
a == undefined
0 == null
'2' == null
false  === null

即使我們搞懂了==的規則，還是建議使用===這種嚴格的運算子來替代==。

資源搜尋網站大全 https://www.renrenfan.com.cn 廣州VI設計公司https://www.houdianzi.com

> 或者 < 比較運算子

規則來源於ECMA 相關規範 Abstract Relational Comparison。

x < y的規則步驟如下（規則優先順序自上而下）：

x 和 y 需要轉換為原始資料型別（ToPrimitive）

var px = ToPrimitive(x)
var py = ToPrimitive(y)
// 下面會沿用這兩個變數的

除開原始的資料型別 undefined、null、boolean、number、string、 symbol，其他的都屬於物件，所以可以理解為這個 ToPrimitive 只對物件有作用。（還有個特殊的NaN，不需要轉換，NaN 可以理解為一種特殊的 number，typeof NaN === 'number'）。

如果 x 或者 y 是物件，需要做轉換處理，由於這裡涉及的比較深，這裡還是簡單的說一下，知道有這回事就好。

var a = {}
a < 'f' // true
a < 'F' // false
// a 會轉變為 [object Object]
// 相當於運行了 a.valueOf().toString()

為什麼不直接 a.toString() 呢，看下下面的例子你就懂了（會首先執行 valueOf，如果返回的是物件則再執行 toString，否則直接返回 valueOf 的返回值）

var d = new Date(1572594637602)
d < 1572594637603 // true
d < 1572594637601 // false
// d 會轉變為 1572594637602 (當前時間轉變的成的毫秒時間戳)
// 相當於運行了 a.valueOf()

如果重寫了 valueOf 方法，那麼預期結果就不一樣了

var d = {}
// 這裡重寫定義了valueOf
d.valueOf = () => 1
d < 2 // true
d < 0 // false
// d 會轉變為 1
// 相當於運行了 a.valueOf()

更多的例子

var a = {}
a < 1 // false，相當於，Number(a) < 1
a < 'a' // true，相當於 '[object Object]' < 'a'
a < '[' // false，相當於 '[object Object]' < '['
var b = function(){}
b < 'g' // true，相當於 'function(){}' < 'g'
b < 'e' // false，相當於 'function(){}' < 'e'

如果 px 和 py 都是字串

如果 py 是 px 的字首，返回 false

'test'<'te'

如果 px 是 py 的字首，返回 true

'test'<'test1'

如果 px 不是 py 的字首，而且 py 也不是 px 的字首

那麼需要從 px 和 py 的最小索引（假設是 k）對應的字元的 UTF-16 程式碼單元值進行對比。

假設 m = px.charCodeAt(k)，n = py.charCodeAt(k)，那麼如果 m < n，返回 true，否則返回 false。

'A' < 'B' // true
// 相當於 'A'.charCodeAt(0) < 'B'.charCodeAt(0)

更加複雜點的例子

'ABC' < 'ABD' // true
// 相當於 
// var a = 'ABC'.charCodeAt(0) < 'ABD'.charCodeAt(0) // false
// var b = 'ABC'.charCodeAt(1) < 'ABD'.charCodeAt(1) // false
// var c = 'ABC'.charCodeAt(2) < 'ABD'.charCodeAt(2) // true
// a || b || c

其他情況 px 和 py 一律轉為數字型別進行比較

var nx = Number(px)
var ny = Number(py)

例子

'2' < 3 // true
'2' < 1 // false

x > y的道理一樣，這裡就不多說了。