標簽（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方法返回的是對象，就報錯。

原生錯誤類型

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"]

相信看了本文案例你已經掌握了方法，更多精彩請關注Gxl網其它相關文章！

推薦閱讀：

React中有哪些類定義組件

navigator.clipboard瀏覽器怎么制作原生剪貼板

聲明：本網頁內容旨在傳播知識，若有侵權等問題請及時與本網聯系，我們將在第一時間刪除處理。TEL:177 7030 7066 E-MAIL:11247931@qq.com