JavaScript小細節點羅列（2）

break 語句和 continue 語句

break語句和continue語句都具備跳轉做用，可讓代碼不按既有的順序執行。

break語句用於跳出代碼塊或循環。

var i = 0;

while(i < 100) {
  console.log('i 當前爲：' + i);
  i++;
  if (i === 10) break;
}

continue語句用於當即終止本輪循環，返回循環結構的頭部，開始下一輪循環。

var i = 0;

while (i < 100){
  i++;
  if (i % 2 === 0) continue;
  console.log('i 當前爲：' + i);
}

注意除了break，continue語句以外，還有一個return語句表示從被調函數返回到主調函數繼續執行，返回時可附帶一個返回值，由return後面的參數指定。return後函數就結束了，後面的語句再也不執行.

標籤（label）

JavaScript 語言容許，語句的前面有標籤（label），至關於定位符，用於跳轉到程序的任意位置，標籤能夠是任意的標識符，但不能是保留字，語句部分能夠是任意語句。

標籤一般與break語句和continue語句配合使用，跳出特定的循環。

top:
  for (var i = 0; i < 3; i++){
    for (var j = 0; j < 3; j++){
      if (i === 1 && j === 1) break top;
      console.log('i=' + i + ', j=' + j);
    }
  }
// i=0, j=0
// i=0, j=1
// i=0, j=2
// i=1, j=0

變量提高（Hoisting）

1. Hoisting 的做用範圍是隨着函數做用域的。我理解在這裏還沒有講到函數做用域，不過能夠提一句提醒讀者注意，而後連接至做用域的部分進一步探討；

2. 「Hoisting 只對 var 聲明的變量有效」，不盡然如此。變量聲明的提高並不是 hoisting 的所有，JavaScript 有四種讓聲明在做用域內得到提高的途徑（按優先級）：

－語言定義的聲明，如 this 和 arguments。你不能在做用域內從新定義叫作 this 的變量，是由於 this 是語言自動定義的聲明，而且它的優先級最高，也就是被 Hoisting 到最頂上了，沒人能覆蓋它

－形式參數。雖然咱們無需用 var 來修飾形式參數，可是形式參數的確也是變量，而且被自動提高到次高的優先級

－函數聲明。除了 var 之外，function declaration 也能夠定義新的命名，而且一樣會被 hoisting 至做用域頂部，僅次於前二者

－最後，是本文提到的常規變量，也就是 var 聲明的變量

整數和浮點數

JavaScript 內部，全部數字都是以64位浮點數形式儲存，即便整數也是如此。因此，1與1.0是相同的，是同一個數。

這就是說，JavaScript 語言的底層根本沒有整數，全部數字都是小數（64位浮點數）。容易形成混淆的是，某些運算只有整數才能完成，此時 JavaScript 會自動把64位浮點數，轉成32位整數，而後再進行運算。

因爲浮點數不是精確的值，因此涉及小數的比較和運算要特別當心。

0.1 + 0.2 === 0.3
// false

0.3 / 0.1
// 2.9999999999999996

(0.3 - 0.2) === (0.2 - 0.1)
// false

精度最多隻能到53個二進制位，這意味着，絕對值小於等於2的53次方的整數，即-253到253，均可以精確表示。

Math.pow(2, 53)
// 9007199254740992
 
Math.pow(2, 53) + 1
// 9007199254740992

Math.pow(2, 53) + 2
// 9007199254740994

Math.pow(2, 53) + 3
// 9007199254740996

Math.pow(2, 53) + 4
// 9007199254740996

上面代碼中，大於2的53次方之後，整數運算的結果開始出現錯誤。因此，大於2的53次方的數值，都沒法保持精度。因爲2的53次方是一個16位的十進制數值，因此簡單的法則就是，JavaScript 對15位的十進制數均可以精確處理。

Math.pow(2, 53)
// 9007199254740992

// 多出的三個有效數字，將沒法保存
9007199254740992111
// 9007199254740992000

根據標準，64位浮點數的指數部分的長度是11個二進制位，意味着指數部分的最大值是2047（2的11次方減1）。也就是說，64位浮點數的指數部分的值最大爲2047，分出一半表示負數，則 JavaScript 可以表示的數值範圍爲21024到2-1023（開區間），超出這個範圍的數沒法表示。

若是一個數大於等於2的1024次方，那麼就會發生「正向溢出」，即 JavaScript 沒法表示這麼大的數，這時就會返回Infinity。

Math.pow(2, 1024) // Infinity
Math.pow(2, -1075) // 0

parseInt()

對於那些會自動轉爲科學計數法的數字，parseInt會將科學計數法的表示方法視爲字符串，所以致使一些奇怪的結果。

parseInt(1000000000000000000000.5) // 1
// 等同於
parseInt('1e+21') // 1

parseInt(0.0000008) // 8
// 等同於
parseInt('8e-7') // 8

parseInt方法還能夠接受第二個參數（2到36之間），表示被解析的值的進制，返回該值對應的十進制數。默認狀況下，parseInt的第二個參數爲10，即默認是十進制轉十進制。

parseInt('1000', 2) // 8
parseInt('1000', 6) // 216
parseInt('1000', 8) // 512

isFinite()

isFinite方法返回一個布爾值，表示某個值是否爲正常的數值。

isFinite(Infinity) // false
isFinite(-Infinity) // false
isFinite(NaN) // false
isFinite(-1) // true

with語句

它的做用是操做同一個對象的多個屬性時，提供一些書寫的方便。

var obj = {
  p1: 1,
  p2: 2,
};
with (obj) {
  p1 = 4;
  p2 = 5;
}
// 等同於
obj.p1 = 4;
obj.p2 = 5;

注意，若是with區塊內部有變量的賦值操做，必須是當前對象已經存在的屬性，不然會創造一個當前做用域的全局變量。

var obj = {};
with (obj) {
  p1 = 4;
  p2 = 5;
}

obj.p1 // undefined
p1 // 4

位運算符

二進制或運算符（or）：符號爲|，表示若兩個二進制位都爲0，則結果爲0，不然爲1。
二進制與運算符（and）：符號爲&，表示若兩個二進制位都爲1，則結果爲1，不然爲0。
二進制否運算符（not）：符號爲~，表示對一個二進制位取反。
異或運算符（xor）：符號爲^，表示若兩個二進制位不相同，則結果爲1，不然爲0。
左移運算符（left shift）：符號爲<<
右移運算符（right shift）：符號爲>>
帶符號位的右移運算符（zero filled right shift）：符號爲>>>

void 運算符

void運算符的做用是執行一個表達式，而後不返回任何值，或者說返回undefined。

下面是一個更實際的例子，用戶點擊連接提交表單，可是不產生頁面跳轉。

<a href="javascript: void(document.form.submit())">
  提交
</a>

圓括號的做用

圓括號不是運算符，而是一種語法結構。它一共有兩種用法：一種是把表達式放在圓括號之中，提高運算的優先級；另外一種是跟在函數的後面，做用是調用函數。

Number(Object)

簡單的規則是，Number方法的參數是對象時，將返回NaN，除非是包含單個數值的數組。

Number({a: 1}) // NaN
Number([1, 2, 3]) // NaN
Number([5]) // 5

之因此會這樣，是由於Number背後的轉換規則比較複雜。

第一步，調用對象自身的valueOf方法。若是返回原始類型的值，則直接對該值使用Number函數，再也不進行後續步驟。

第二步，若是valueOf方法返回的仍是對象，則改成調用對象自身的toString方法。若是toString方法返回原始類型的值，則對該值使用Number函數，再也不進行後續步驟。

第三步，若是toString方法返回的是對象，就報錯。

String(Object)

String方法的參數若是是對象，返回一個類型字符串；若是是數組，返回該數組的字符串形式。

String({a: 1}) // "[object Object]"
String([1, 2, 3]) // "1,2,3"

String方法背後的轉換規則，與Number方法基本相同，只是互換了valueOf方法和toString方法的執行順序。

先調用對象自身的toString方法。若是返回原始類型的值，則對該值使用String函數，再也不進行如下步驟。

若是toString方法返回的是對象，再調用原對象的valueOf方法。若是valueOf方法返回原始類型的值，則對該值使用String函數，再也不進行如下步驟。

若是valueOf方法返回的是對象，就報錯。

原生錯誤類型

• SyntaxError 對象是解析代碼時發生的語法錯誤。

• ReferenceError 對象是引用一個不存在的變量時發生的錯誤。

• angeError 對象是一個值超出有效範圍時發生的錯誤。主要有幾種狀況，一是數組長度爲負數，二是Number對象的方法參數超出範圍，以及函數堆棧超過最大值。

• TypeError 對象是變量或參數不是預期類型時發生的錯誤。好比，對字符串、布爾值、數值等原始類型的值使用new命令，就會拋出這種錯誤，由於new命令的參數應該是一個構造函數。

• URIError 對象是 URI 相關函數的參數不正確時拋出的錯誤，主要涉及encodeURI()、decodeURI()、encodeURIComponent()、decodeURIComponent()、escape()和unescape()這六個函數。

• eval 函數沒有被正確執行時，會拋出EvalError錯誤。該錯誤類型已經再也不使用了，只是爲了保證與之前代碼兼容，才繼續保留。

var err1 = new Error('出錯了！');
var err2 = new RangeError('出錯了，變量超出有效範圍！');
var err3 = new TypeError('出錯了，變量類型無效！');

err1.message // "出錯了！"
err2.message // "出錯了，變量超出有效範圍！"
err3.message // "出錯了，變量類型無效！"

finally 代碼塊

try...catch結構容許在最後添加一個finally代碼塊，表示不論是否出現錯誤，都必需在最後運行的語句。

function cleansUp() {
  try {
    throw new Error('出錯了……');
    console.log('此行不會執行');
  } finally {
    console.log('完成清理工做');
  }
}

cleansUp()
// 完成清理工做
// Error: 出錯了……

map()

map方法不只能夠用於數組，還能夠用於字符串，用來遍歷字符串的每一個字符。可是，不能直接使用，而要經過函數的call方法間接使用，或者先將字符串轉爲數組，而後使用。

var upper = function (x) {
  return x.toUpperCase();
};

[].map.call('abc', upper)
// [ 'A', 'B', 'C' ]

// 或者
'abc'.split('').map(upper)
// [ 'A', 'B', 'C' ]

其餘相似數組的對象（好比document.querySelectorAll方法返回DOM節點集合），也能夠用上面的方法遍歷。

map方法還能夠接受第二個參數，表示回調函數執行時this所指向的對象。

var arr = ['a', 'b', 'c'];

[1, 2].map(function(e){
  return this[e];
}, arr)
// ['b', 'c']

若是數組有空位，map方法的回調函數在這個位置不會執行，會跳過數組的空位。

Array(2).map(function (){
  console.log('enter...');
  return 1;
})
// [, ,]

reduce()，reduceRight()

reduce方法和reduceRight方法依次處理數組的每一個成員，最終累計爲一個值。

它們的差異是，reduce是從左到右處理（從第一個成員到最後一個成員），reduceRight則是從右到左（從最後一個成員到第一個成員），其餘徹底同樣。

這兩個方法的第一個參數都是一個函數。該函數接受如下四個參數。

累積變量，默認爲數組的第一個成員
當前變量，默認爲數組的第二個成員
當前位置（從0開始）
原數組

[1, 2, 3, 4, 5].reduce(function(x, y){
  console.log(x, y)
  return x + y;
});
// 1 2
// 3 3
// 6 4
// 10 5
//最後結果：15

Object.keys()，Object.getOwnPropertyNames()

Object.keys方法和Object.getOwnPropertyNames方法都用來遍歷對象的屬性。

Object.keys方法的參數是一個對象，返回一個數組。該數組的成員都是該對象自身的（而不是繼承的）全部屬性名。

Object.getOwnPropertyNames方法與Object.keys相似，也是接受一個對象做爲參數，返回一個數組，包含了該對象自身的全部屬性名。

對於通常的對象來講，Object.keys()和Object.getOwnPropertyNames()返回的結果是同樣的。只有涉及不可枚舉屬性時，纔會有不同的結果。Object.keys方法只返回可枚舉的屬性，Object.getOwnPropertyNames方法還返回不可枚舉的屬性名。

var a = ['Hello', 'World'];

Object.keys(a) // ["0", "1"]
Object.getOwnPropertyNames(a) // ["0", "1", "length"]