判斷變數是否已初始化,最簡短的寫法是 if (x) {}——它同時排除了 undefined、null、空字串與 0。但要注意,若 0 是合法值,這寫法就會誤判,該用 if (x !== undefined) 才準確。
宣告函式不必標註回傳值與參數型別,結尾的分號也可省略:
function sum(i1, i2){ return i1 + i2 }
匿名函式可以宣告後立刻執行:
var f = function(i1, i2){ return i1 + i2; };
alert(f(1, 2));
alert(function(i1, i2){ return i1 + i2; }(3, 4));
JavaScript 沒有 class 關鍵字(ES6 之前),但建構函式加上 this 就能做出近似效果,還能動態增加屬性:
function Person(name, age){
this.Name = name;
this.Age = age;
this.SayHello = function(){
alert('Hello, My name is ' + name + ' I am ' + age + ' years old.');
};
}
var p1 = new Person('lorry', 21);
p1.SayHello();
p1.Gender = '男'; // 執行期動態加屬性
alert(p1.Gender);
定義陣列不必預先指定長度;它同時也能當字典、當堆疊使用:
var dict = new Array();
dict['我'] = 'wo';
dict['愛'] = 'ai';
alert(dict['我']);
alert(dict.愛); // 動態語言特性,像存取屬性一樣
for (var k in dict) { alert(k); } // in 取出的是 key
for (var v of dict) { alert(v); } // of 取出的是 value
var arr = [1, 2, 3, 4, 5]; // 簡化寫法
var obj = { "lorry": 21, "cloud": 20 }; // 字典風格
注意:用 in 或 of 搭配陣列時行為與直覺不同,in 取索引、of 取值。另外 for...in 會把原型鏈上的可列舉屬性也掃進來,處理純陣列時用傳統 for 迴圈或 forEach 更安全。
var s = 'Hello, world!';
s[0]; // 'H'
s[13]; // undefined(超出範圍不報錯)
s.toUpperCase(); // 'HELLO, WORLD!'
s.toLowerCase(); // 'hello, world!'
s.indexOf('world'); // 7
s.indexOf('World'); // -1(區分大小寫)
s.substring(0, 5); // 'hello'(不含索引 5)
s.substring(7); // 'world'
字串是不可變的,以下寫法不會報錯,但完全無效:
var s = 'Test'; s[0] = 'X'; alert(s); // 仍是 'Test'
var xiaoming = { name: '小明', birth: 1990, 'middle-school': 'No.1 Middle School' };
xiaoming.name;
xiaoming['middle-school']; // 屬性名含特殊字元時只能用中括號
'name' in xiaoming; // true
'toString' in xiaoming; // true ← 繼承而來的也在裡面
xiaoming.hasOwnProperty('name'); // true,自身擁有
xiaoming.hasOwnProperty('toString'); // false,是繼承的
var m = new Map([['Michael', 95], ['Bob', 75]]);
m.get('Michael'); // 95
m.set('Adam', 67);
m.has('Adam'); // true
m.delete('Adam');
var a = ['A', 'B', 'C'];
a.forEach(function(element, index, array){ alert(element); });
var s = new Set(['A', 'B', 'C']);
s.forEach(function(element, set){ alert(element); }); // Set 沒有索引
var m = new Map([[1, 'x'], [2, 'y']]);
m.forEach(function(value, key, map){ alert(value); }); // Map 參數順序是 value, key, map
// map:逐項轉換,回傳同長度的新陣列
[1, 2, 3, 4].map(function(x){ return x * x; }); // [1, 4, 9, 16]
[1, 2, 3].map(String); // ['1', '2', '3']
// reduce:累積計算
[1, 2, 3, 4, 5].reduce(function(x, y){ return x + y; }); // 15
[1, 2, 5, 8, 0].reduce(function(x, y){ return x * 10 + y; }); // 12580
// filter:保留回傳 true 的項目
[0,1,2,3,4,5].filter(function(x){ return x % 2 === 0; }); // [0, 2, 4]
['A', '', 'B', null, 'C', ' '].filter(function(s){ return s && s.trim(); }); // ['A', 'B', 'C']
// sort:預設轉字串排序,數字排序必須自己給比較函式
[10, 20, 1, 2].sort(); // [1, 10, 2, 20]
[10, 20, 1, 2].sort(function(a, b){ return a - b; }); // [1, 2, 10, 20]
sort() 會直接改動原陣列,若需保留原資料要先 slice() 複製一份。
閉包就是「函式 + 它所捕獲的變數環境」。三種典型用法:
// 1. 延後計算
function lazy_sum(arr){
return function(){
return arr.reduce(function(x, y){ return x + y; });
};
}
var f = lazy_sum([1, 2, 3]);
alert(f()); // 6,直到呼叫 f 才真的加總
// 2. 封裝私有變數
function createCounter(init){
var n = init || 0;
return { add: function(){ n += 1; return n; } };
}
var c = createCounter();
c.add(); c.add(); // 外部無法直接存取 n
// 3. 產生特定次方函式
function make_pow(y){
return function(x){ return Math.pow(x, y); };
}
var pow2 = make_pow(2), pow3 = make_pow(3);
pow2(3); // 9
pow3(3); // 27
閉包最經典的陷阱是迴圈捕獲:
function count(){
var arr = [];
for (var i = 1; i <= 3; i++) {
arr.push(function(){ return i * i; });
}
return arr;
}
count().forEach(function(f){ alert(f()); }); // 16 16 16,全是 16
因為三個函式共用同一個 i,而迴圈結束後 i 已經是 4。解法有兩個:用另一層函式把值綁進參數,或改用 let(每次迭代都有獨立綁定):
arr.push(function(n){ return function(){ return n * n; }; }(i)); // 得到 1、4、9
for (let i = 1; i <= 3; i++) { arr.push(() => i * i); } // 同樣正確
var f = x => x * x * x;
f(3); // 27
// generator 函式用 function* 宣告,yield 暫停並產出值
function* fib(max){
var t, a = 0, b = 1, n = 1;
while (n <= max) {
yield a;
t = a + b; a = b; b = t; n++;
}
}
for (var x of fib(10)) { document.write(x + ' '); } // 0 1 1 2 3 5 8 ...
// 自增 ID 產生器,不必宣告全域變數
function* next_id(){ for (var x = 1; x < 100; yield x++); }
var g = next_id();
g.next().value; // 1
g.next().value; // 2
這些觀念幾乎涵蓋了 JavaScript 日常開發的核心:型別轉換的自動性、陣列高階方法的組合、閉包的作用域捕獲,以及新一代語法帶來的簡潔寫法。逐項動手跑一遍,比只看筆記有效得多。