摘要：操作符，會將數(shù)值改變正數(shù)變成負(fù)數(shù)負(fù)數(shù)變成正數(shù)。同時，也說明了，使用兩個邏輯非操作符和的操作結(jié)果相同。操作符得到的是余數(shù)。不相等操作符有兩種。

這篇筆記的內(nèi)容對應(yīng)的是《JavaScript高級程序設(shè)計(第三版)》中的第三章。

遞增和遞減操作符

遞增和遞減操作符有兩個 ++ 和 --。一元操作符使用的時候，可以前置也可以后置。由于兩個操作方式類似，先只說明 ++，-- 類比就可以了。

使用 ++ 操作符，相當(dāng)于使用了一個簡化的語句：

var age = 27;
age++; // 這里相當(dāng)于 age = age + 1; 的簡化
console.log(age); // 28

前置 ++，先加后用；后置 ++，先用后加

前置操作：先加后用

var age = 27;
var num = ++age;       // 相當(dāng)于 age = age + 1; var num = age; 的簡寫
console.log(age, num); // 28 28

后置操作：先用后加

var age = 27;
var num = age++;       // 相當(dāng)于 var num = age; age = age + 1; 的簡寫
console.log(age, num); // 28 27

思考，下面的代碼是什么樣的簡寫？

var num1 = 12;
var num2 = 10;
var num3 = num1++ + ++num2;
console.log(num1, num2, num3); // 13 11 23

全寫形式如下：

var num1 = 12;
var num2 = 10;
// ============
num2 = num2 + 1;
var num3 = num1 + num2;
num1 = num1 + 1;
// ============
console.log(num1, num2, num3); // 13 11 23

一元加和減操作符

一元加和減操作符包括 + 和 -。

+ 放在數(shù)值前面，不會修改數(shù)值的內(nèi)容。

var num = 123;
num = +num; // 123

+ 放在任意數(shù)據(jù)類型之前，都會發(fā)生數(shù)據(jù)類型轉(zhuǎn)換；轉(zhuǎn)換的結(jié)果和使用 Number 方法的結(jié)果相同。可以理解成 Number 方法的簡寫形式。

+true        // 1
Number(true) // 1

- 操作符，會將數(shù)值改變：正數(shù)變成負(fù)數(shù)；負(fù)數(shù)變成正數(shù)。

var num = 123;
num = -num; // -123

邏輯非(!):

邏輯非就是取反操作，操作結(jié)果如下：

操作數(shù) | 結(jié)果
-|-
true | false
false | true

邏輯非操作符后面可以跟任意數(shù)據(jù)類型的數(shù)據(jù)，操作結(jié)果就是 !Boolean()。也就是通過 Boolean() 函數(shù)得到的布爾類型值的取反操作。

!NaN          // true
!Boolean(NaN) // true

同時，也說明了，使用兩個邏輯非操作符和 Boolean() 的操作結(jié)果相同。

!!NaN          // false
Boolean(NaN)   // false

邏輯與(&&):

第一個操作數(shù) | 第二個操作數(shù) | 結(jié)果
-|-|-
true | true | true
true | false | false
false | true | false
false | false | false

邏輯與操作符也被稱為短路操作符，也就是，第一個操作數(shù)的結(jié)果為 false，那么就不會執(zhí)行第二個操作數(shù)了。

var num = (3>2) && 5; // 第一個操作數(shù)的結(jié)果是true，因此num的結(jié)果為第二個操作數(shù)的結(jié)果 5
console.log(num); // 5

var num = (3<2) && 5; // 第一個操作數(shù)的結(jié)果是false，因此num的結(jié)果為第一個操作數(shù)的結(jié)果 false
console.log(num); // false

邏輯或(||):

第一個操作數(shù) | 第二個操作數(shù) | 結(jié)果
-|-|-
true | true | true
true | false | true
false | true | true
false | false | false

邏輯或也是一種短路操作符，如果第一個操作數(shù)的結(jié)果為 true，那么就不會執(zhí)行第二個操作數(shù)了。

var num = (3>2) || 5; // 第一個操作數(shù)的結(jié)果是 true，最終的結(jié)果是第一個操作數(shù)的值
console.log(num); // true

var num = (3<2) || 5; // 第一個操作數(shù)的值是 false，最終結(jié)果是第二個操作數(shù)的值
console.log(num); // 5

乘性操作符有三種：* / %。使用乘性操作符的時候，會首先通過 Number() 方法轉(zhuǎn)化操作數(shù)，然后再做運(yùn)算。

/ 操作符得到的結(jié)果不像其他語言一樣只得到整數(shù)，而是得到最終的結(jié)果。

console.log(2 / 3); // 0.6666666666666666
console.log(3 / 2); // 1.5
console.log(4 / 2); // 2

% 操作符得到的是余數(shù)。

console.log(3 % 2); // 1

通過 / 和 % 得到余數(shù)和結(jié)果。

function func(num1, num2) {
  return {
    res: ~~(num1 / num2), // ~~ 的作用是取整數(shù)
    yus: num1 % num2
  }
}

var res = func(17, 3);
console.log(`結(jié)果：${res.res}，余數(shù)：${res.yus}`); // 結(jié)果：5，余數(shù)：2

加性操作符有兩個：+ -。

+ 操作符，在操作數(shù)不是數(shù)值的情況下，會先通過 String() 方法將操作數(shù)轉(zhuǎn)成字符串，然后字符串相加。

console.log("5" + "2"); // "52"

- 操作符，在操作數(shù)不是數(shù)值的情況下，會通過 Number() 方法將操作數(shù)轉(zhuǎn)成數(shù)值，然后操作。

console.log("5" - "2"); // 3

關(guān)系運(yùn)算符有四個：> >= < <=。比較的規(guī)則，一般是把操作數(shù)轉(zhuǎn)成數(shù)值，然后進(jìn)行比較。

var res1 = "3" < 2; // "3" 會轉(zhuǎn)成數(shù)值 3，然后比較

比較字符串，會比較字符串對應(yīng)位置上的字符編碼：

var res1 = "abc" < "aBc"; // false
console.log("a : " + "a".charCodeAt(0)); // 97
console.log("b : " + "b".charCodeAt(0)); // 98
console.log("B : " + "B".charCodeAt(0)); // 66
console.log("c : " + "c".charCodeAt(0)); // 99

上面代碼中，b 的編碼大于 B 的編碼，因此為 false。

相等操作符有兩種：== ===。不相等操作符有兩種 != !==。

== : 僅比較值是否相等

=== : 不僅比較值，還要比較數(shù)據(jù)類型

一些特殊情況：

表達(dá)式 | 值
-|-
null == undefined | true
"NaN" == NaN | false
5 == NaN | false
NaN == NaN | false
NaN != NaN | true
false == 0 | true
true == 1 | true
true == 2 | false
undefined == 0 | false
null == 0 | false
"5" == 5 | true
"5" === 5 | false

三目運(yùn)算符的語法：variable = boolean_expression ? true_value : false_value。其實是對 if-else 語句的簡寫：

if(boolean_expression) {
  // true_value
} else {
  // false_value
}

保存兩個數(shù)中的最大值：

var num1 = 3;
var num2 = 4;
var res = num1 > num2 ? num1 : num2; // 4

逗號運(yùn)算符可以用于一條語句中執(zhí)行多個操作。

用于聲明多個變量：

var num1 = 1, num2 = 2, num3 = 3;

用于賦值，總是會把最后一個逗號后面的值賦值給變量：

var num = (1, 2, 3, 4, 5); // 5

可以用于 ++ 操作符的理解：

var num1 = 10;
var num2 = 12;
var res = 0;
res = num1++ + ++num2; // 23

最后一句代碼可以通過逗號運(yùn)算符，理解成下面的形式：

num2 = num2 + 1, res = num1 + num2, num1 = num1 + 1;

由于語句在編程中經(jīng)常使用，更多的細(xì)節(jié)，在實際使用的過程中會逐漸加深理解，因此，這里只記錄一下基本語法。

單個條件的語法：

if (condition) {
  // ...
} else {
  // ...
}

多個條件的語法：

if (condition1) {
  // ...
} else if (condition2) {
  // ... 
} else {
  // ...
}

語法如下：

do {
  // ...
} while (expression);

循環(huán)至少會被執(zhí)行一次。

var i = 0;
do {
  console.log("hi~~ " + i++);
} while (i > 1);

// hi~~ 0

語法如下：

while (expression) {
  // ...
}

不滿足條件，循環(huán)不會執(zhí)行：

var i = 0;
while (i > 1) {
  console.log("hi~~ " + i++);
}

語法如下：

for (initalization; expression; post-loop-expression) {
  // ...
}

求出 1-100 的和。

var sum = 0;
for (var i = 1; i <= 100; i++) {
  sum += i;
}
console.log("1 + ... + 100 = " + sum);

for-in 語句是一種精準(zhǔn)的迭代語句，可以用來枚舉對象的屬性。

for (property in expression) {
  // ...
}

例子如下：

for (var item in window) { // 循環(huán)BOM中window對象中的屬性
  console.log(item);
}

如果被迭代對象的屬性值是 null 或者 undefined，for-in 語句會報出錯誤，因此，應(yīng)該做容錯處理。

for (var item in window) { // 循環(huán)BOM中window對象中的屬性
  if(item !== null && item !== undefined){ // 容錯處理
    console.log(item);
  }
}

break 和 continue 用來在循環(huán)中精準(zhǔn)控制代碼的執(zhí)行。

continue 是退出當(dāng)前循環(huán)，繼續(xù)執(zhí)行下一個循環(huán)

breank 是退出整個循環(huán)

for (var i = 0; i < 10; i++) {
  if (i === 5) {
    break; // i 等于 5 的時候，退出當(dāng)前循環(huán)
  }
  console.log("i = " + i);
}

上面代碼中，當(dāng) i 等于 5 的時候，循環(huán)就不再執(zhí)行了。

for (var i = 0; i < 10; i++) {
  if (i === 5) {
    continue; // 當(dāng) i 等于 5 的時候，退出當(dāng)前循環(huán)，接著下一次循環(huán)
  }
  console.log("i = " + i);
}

上面代碼中，當(dāng) i 等于 5 的時候，就不會輸出，然后接著執(zhí)行 i 等于 6 的情況。

語法如下：

switch (expression) {
  case value:
    // ...
    break;
  case value:
    // ...
    break;
  default:
    // ...
    break;
}

其中需要說明的是，判斷的每一項是 expression 的值與 value 是否全等。

switch ("1") {
  case 1:
    console.log("相等");
    break;
  default:
    console.log("全等");
    break;
}

// "全等"

一個函數(shù)的組成由：關(guān)鍵字function、函數(shù)名、函數(shù)參數(shù)、函數(shù)體、返回值

function 函數(shù)名(參數(shù)1, 參數(shù)2, ..., 參數(shù)n) {
  函數(shù)體
  return 返回值;
}

一個簡單的求兩數(shù)之和的函數(shù)。

function getSum(num1, num2) {
  return num1 + num2;
}
console.log("1 + 2 = " + getSum(1, 2));

注意：不能把函數(shù)名和函數(shù)參數(shù)命名為 eval 或 arguments。

ECMAScript 中，傳遞函數(shù)的參數(shù)比較自由，可以不用和定義函數(shù)的參數(shù)保持一致。

function getSum(num1, num2) {
  return num1 + num2;
}
console.log(getSum());          // 不傳參數(shù)
console.log(getSum(1));         // 傳一個參數(shù)
console.log(getSum(1, 2));      // 傳兩個參數(shù)
console.log(getSum(1, 2, 3));   // 傳三個參數(shù)

其實在函數(shù)的內(nèi)部，始終存在一個類似于數(shù)組的對象 arguments，通過這個對象，可以實現(xiàn)不同的個數(shù)參數(shù)的傳遞。

function getSum(num1, num2) {
  console.log(typeof arguments);
  for (var i = 0; i < arguments.length; i++) {
    console.log("arguments[" + i + "] = " + arguments[i]);
  }
}
getSum()
getSum(1)
getSum(1, 2)
getSum(1, 2, 3)