[toc]
# 每日英語
1. `expression` 表達式
1. `condition` 條件
1. `modified` 改變
# 關系操作符
小于(<)、大于(>)、小于等于(<=)和大于等于(>=)這幾個關系操作符用于對兩個值進行比較,這幾個操作符都返回一個布爾值
```javascript
var result1 = 5 > 3; //true
var result2 = 5 < 3; //false
console.log(result1);
console.log(result2);
```
```javascript
console.log(3 < 2); //false
console.log(3 > 2); // true
console.log(3 >= 2); // true
console.log(3 <= 2); // false
console.log(2 <= 2); // true
```
當關系操作符的操作數使用了非數值時,也要進行數據轉換
1. 如果兩個操作數都是數值,則執行數值比較。
1. 如果兩個操作數都是字符串,則比較兩個字符串對應的字符編碼值。
```javascript
console.log("hello" >= "world"); // false
console.log("hello" > "world"); // false
```
1. 如果一個操作數是數值,則將另一個操作數轉換為一個數值,然后執行數值比較。
```javascript
console.log(123 > "123"); //false
console.log(123 >= "123"); //true
console.log(123 >= "123hello"); // false
console.log(123 >= []); // true
```
1. 如果一個操作數是對象,則調用這個對象的 valueOf() 方法,用得到的結果按照前面的規則執行比較。如果對象沒有 valueOf() 方法,則調用 toString() 方法,并用得到的結果根據前面的規則執行比較。
1. 如果一個操作數是布爾值,則先將其轉換為數值,然后再執行比較。
```javascript
console.log(1 > false); // true
console.log(1 > true); // false
```
由于大寫字母的字符編碼全部小于小寫字母的字符編碼
```javascript
var result = "Brick" < "alphabet"; //true
console.log(result);
```
```javascript
var result = "Brick".toLowerCase() < "alphabet".toLowerCase(); //false
console.log(result);
```
```javascript
var result = "23" < "3";
console.log(result);
```
```javascript
var result = "23" < 3;
console.log(result);
```
```javascript
var result = "a" < 3;
console.log(result);
```
由于字母 "a" 不能轉換成合理的數值,因此就被轉換成了 NaN 。
根據規則,任何操作數與 NaN 進行關系比較,結果都是 false 。
```javascript
var result1 = NaN < 3; //false
var result2 = NaN >= 3; //false
console.log(result1);
console.log(result2);
```
```javascript
var result = "Brick" < "alphabet"; // true
var result = "Brick".toLowerCase() < "alphabet".toLowerCase(); // false
var result = "23" < 3; // false
var result = "a" < 3; // false
var result = "a" > 3; // false
console.log(result);
```
# 相等操作符
確定兩個變量是否相等是編程中的一個非常重要的操作。在比較字符串、數值和布爾值的相等性時, 問題還比較簡單。但在涉及到對象的比較時,問題就變得復雜了。最早的 ECMAScript 中的相等和不等 操作符會在執行比較之前,先將對象轉換成相似的類型。后來,有人提出了這種轉換到底是否合理的質疑。最后,ECMAScript 的解決方案就是提供兩組操作符:
**相等和不相等——先轉換再比較,全等和不全等——僅比較而不轉換。**
1. 相等和不相等
ECMAScript 中的相等操作符由兩個等于號( == )表示,如果兩個操作數相等,則返回 true 。
而不相等操作符由嘆號后跟等于號( != )表示,如果兩個操作數不相等,則返回 true 。
這兩個操作符都會先轉換操作數,然后再比較它們的相等性。
在轉換不同的數據類型時,相等和不相等操作符遵循下列基本規則:
1. 如果有一個操作數是布爾值,則在比較相等性之前先將其轉換為數值—— false 轉換為 0,而 true 轉換為 1;
```javascript
console.log(false == 1); // false
console.log(false == 0); // true
console.log(true == 0); // false
console.log(true == 1); // true
```
1. 如果一個操作數是字符串,另一個操作數是數值,在比較相等性之前先將字符串轉換為數值;
```javascript
console.log("123" == 123); // true
console.log("123hello" == 123); // false
console.log("[]" == 0); // false
console.log([] == 0); // true
```
1. 如果一個操作數是對象,另一個操作數不是,則調用對象的 valueOf() 方法,用得到的基本類型值按照前面的規則進行比較;這兩個操作符在進行比較時則要遵循下列規則。
1. null 和 undefined 是相等的。
1. 要比較相等性之前,不能將 null 和 undefined 轉換成其他任何值。
1. 如果有一個操作數是 NaN ,則相等操作符返回 false ,而不相等操作符返回 true 。重要提示: 即使兩個操作數都是 NaN ,相等操作符也返回 false ;因為按照規則, NaN 不等于 NaN 。
```javascript
console.log(null == undefined); // true
console.log(NaN == 0); // false
console.log(NaN == "hello"); // false
console.log(NaN == NaN); // false
```
1. 如果兩個操作數都是對象,則比較它們是不是同一個對象。如果兩個操作數都指向同一個對象, 則相等操作符返回 true ;否則,返回 false 。
```javascript
console.log([] == []); // false
console.log(new Array() == new Array()); // false
var a = [];
var b = a;
console.log(a == b); // true
```
```javascript
console.log(null == undefined); // true
console.log(true == 1); // true
console.log("NaN" == NaN); // false
console.log(true == 2); // false
console.log(5 == NaN); // false
console.log(undefined == 0); // false
console.log(NaN == NaN); // false
console.log(null == 0); // false
console.log(NaN != 3); // true
console.log(NaN == 3); // false
console.log("5" == 5); // true
console.log(false == 0); // true
console.log(NaN > NaN); // false
console.log(NaN < NaN); // false
```
## 全等和不全等
除了在比較之前不轉換操作數之外,全等和不全等操作符與相等和不相等操作符沒有什么區別。全等操作符由 3 個等于號( === )表示,它只在兩個操作數未經轉換就相等的情況下返回 true
```javascript
var result1 = "55" == 55; //true,因為轉換后相等
var result2 = "55" === 55; //false,因為不同的數據類型不相等
console.log(result1);
console.log(result2);
```
不全等操作符由一個嘆號后跟兩個等于號( !== )表示,它在兩個操作數未經轉換就不相等的情況下返回 true
```Javascript
var result1 = ("55" != 55); //false,因為轉換后相等
var result2 = ("55" !== 55); //true,因為不同的數據類型不相等
console.log(result1);
console.log(result2);
```
```javascript
console.log("123" === 123); // false
console.log("" === []); // false
console.log(0 === []); // false
console.log(null === undefined); // false
```
null == undefined 會返回 true ,因為它們是類似的值;
但 null === undefined 會返回 false ,因為它們是不同類型的值。
由于相等和不相等操作符存在類型轉換問題,而為了保持代碼中數據類型的完整性,推薦使用全等和不全等操作符
# 條件操作符(三元運算)
## 表達式和語句
```javascript
var age = 17; // 語句
123 > 13; // 表達式
```
有結果的語句, 就叫表達式
`variable = boolean_expression ? true_value : false_value;`
本質上,這行代碼的含義就是基于對 boolean_expression 求值的結果,決定給變量 variable 賦什么值。
如果求值結果為 true ,則給變量 variable 賦 true_value 值;如果求值結果為 false , 則給變量 variable 賦 false_value 值。
`var max = (num1 > num2) ? num1 : num2;`
```javascript
var a = 123 > 333 ? "yes" : "no";
console.log(a); // no
```
```javascript
var a = 3;
var b = 1;
var c = 4;
var max = (a > b ? a : b) > c ? (a > b ? a : b) : c;
console.log(max);
```
比 if 語句更簡單
```javascript
var a = 3;
var b = 4;
var c;
if (a > b) {
c = a;
} else {
c = b;
}
console.log(c); // 4
```
```javascript
var a = 3;
var b = 4;
var c = 1;
var max;
if (a > b) {
max = a;
} else {
max = b;
}
if (max < c) {
max = c;
}
console.log(max); // 4
```
# 賦值操作符
> 簡單的賦值操作符由等于號( = )表示,其作用就是把右側的值賦給左側的變量
```Javascript
var num = 10;
console.log(num)
```
如果在等于號( = )前面再添加乘性操作符、加性操作符或位操作符,就可以完成復合賦值操作。
這種復合賦值操作相當于是對下面常規表達式的簡寫形式:
```javascript
var num+=10
var num = 10;
num = num + 10;
```
```javascript
var a = "hello";
console.log((a += "world")); // helloworld
// var a = "hello";
// a = a + "world";
```
每個主要算術操作符(以及個別的其他操作符)都有對應的復合賦值操作符。這些操作符如下所示:
`乘/賦值( *= );`
`除/賦值( /= );`
`模/賦值( %= );`
`加/賦值( += );`
`減/賦值( -= );`
<!-- `左移/賦值( <<= );` -->
<!-- `無符號右移/賦值( >>>= )。` -->
```javascript
var a = 123;
console.log((a *= 10)); // 1230
var b = 10;
console.log((b /= 10)); // 1
// b/=10 ====> b = b/10
var c = 13;
console.log((c -= 1)); // 12
var d = 24;
console.log((d %= 5)); // 4
```
**設計這些操作符的主要目的就是簡化賦值操作。使用它們不會帶來任何性能的提升。**(測試時間)
```javascript
// var a = "hello";
// var b = a+="world";
// console.log(b);
var a = "hello";
var b = a + "world";
console.log(b);
```
# 逗號操作符
> 使用逗號操作符可以在一條語句中執行多個操作
```Javascript
var num1=1, num2=2, num3=3;
```
逗號操作符還可以用于賦值。
在用于賦值時,逗號操作符總會返回表達式中的最后一項
```javascript
var num = (5, 1, 4, 8, 0); // num 的值為 0
```
```javascript
var num = (1, 2, 3, 4, 5);
console.log(num); // 5
var num = 1;
num = 2;
num = 3;
num = 4;
num = 5;
console.log(num); // 5
```
- 每日單詞
- JavaScript 入門
- JavaScript 基礎
- JavaScript 基礎回顧
- JavaScript 函數
- 匿名函數,多維數組,數據類型轉換
- JavaScript 類型轉換, 變量作用域
- js 運算符(一)
- js 運算符(二)
- js 流程控制語句
- JavaScript 掃盲日
- JavaScript 牛刀小試(一)
- JavaScript 牛刀小試(二)
- JavaScript 再談函數
- JavaScript-BOM
- JavaScript-定時器(一)
- JavaScript-定時器(二)
- 番外-輪播圖源碼
- JavaScript 輪播圖和 DOM 簡介
- JavaScript-DOM 基礎-NODE 接口-屬性
- JavaScript-DOM 基礎-NODE 接口-方法
- NodeList-接口-HTMLCollection-接口
- Document 節點
- CSS 復習與擴展(一)
- CSS 復習與擴展(二)
- 走進 jQuery 的世界
- 使用 jquery
- 使用 jquery-2
- jquery 中高級
- jquery 備忘清單-1
- jquery 備忘清單-2
- 聊聊 json
- jquery 備忘清單-3