物件與陣列是JavaScript資料組織的兩大基石。以下依據《JavaScript權威指南》第五版的脈絡,把常用語法與容易忽略的細節整理成一份可查閱的筆記。
物件是一個無序的屬性集合,每個屬性都有自己的名字與值。
var obj = {};
var obj = {name: 'maxthon'};
var obj = {name: {}, text: []};
也可以搭配 new 運算符:
var a = new Array();
var d = new Date();
var r = new RegExp('javascript', 'i');
var o = new Object(); // 等同 var o = {};
這裡有個值得留意的點:new 後面跟的是建構函式,所以 typeof Array 與 typeof Object 都會回傳 'function'。Object 是 Function 的實例,而 Function 本身也是個特殊的物件、同時是 Object 的實例。
var t = {};
t.text = 'hello';
t.o = {};
t.o.name = 'rd';
t.n = [];
var t = { "text": "hello" };
console.log(t.text); // 'hello'
除了用點(.)存取,也可以用中括號 [],裡面放屬性名字串。後者看起來囉嗦,但因為屬性名可以是變數,在很多動態場景下反而特別好用。另外提醒:宣告變數要用 var,但宣告物件屬性時不能用 var。
var F = function () {};
F.prototype.name = 'RD';
var obj = new F;
for (var key in obj) {
console.log(key); // name
}
// 只列舉物件自身,不沿原型鏈往上找
for (var key in obj) {
if (obj.hasOwnProperty(key)) {
console.log(key);
}
}
注意 for...in 不會列舉出預先定義的屬性,例如 toString。
window.a = 'rd';
console.log(a in window); // true
var F = function () {};
F.prototype.name = 'RD';
var obj = new F;
console.log('name' in obj); // true
var toString = Object.prototype.toString;
if (obj.getName && toString.call(obj.getName) === '[object Function]') {
obj.getName();
}
順帶一提:null == undefined 為 true,但 null !== undefined 也為 true——兩者互等卻不同型。
delete obj.name;
同樣地,delete 無法刪除用 var 宣告的變數。至於「關聯陣列」的用法,本質上就是利用中括號語法:
obj.name;
obj['name']; // name 是字串
for (var key in obj) {
console.log(key); // key 是屬性名,此處作為值存在
}
JavaScript物件其實就是把字串(屬性名)對應到值的映射。
JavaScript中所有物件都繼承自 Object 類。
指向該物件的建構函式:
var F = function () {};
var f = new F;
console.log(f.constructor == F); // true
// 建構函式的原型上存在 constructor 屬性指向自己
F.prototype.constructor == F;
若把某個建構函式的 prototype 整個換掉,constructor 的指向也會跟著改變:
var F = function () {};
var G = function () {};
G.prototype = new F;
var g = new G;
console.log(g.constructor == F); // true
console.log(g.constructor == G); // false
// 這種情況可用 g instanceof F 來判斷
{'name': 'maxthon'}.toString(); // '[object Object]'
['a', 'b', 1, false, ['e','f'], {}].toString();
// "a,b,1,false,e,f,[object Object]"
function t() { console.log('test'); }
t.toString(); // 回傳函式原始碼
陣列呼叫 toString 會把元素串成字串,其他物件會變成 [object Object],而函式呼叫原始的 toString 則能得到程式碼本身。
toLocaleString():回傳物件的在地化字串表示。valueOf():轉換為基本型別時會用到,常與 toString 搭配。hasOwnProperty():判斷屬性是否為物件自身所有。propertyIsEnumerable():判斷屬性是否可被列舉。isPrototypeOf():若 a 是 b 的原型則回傳 true。var o = {};
Object.prototype.isPrototypeOf(o); // true
Object.isPrototypeOf(o); // false
o.isPrototypeOf(Object.prototype); // false
Function.prototype.isPrototypeOf(Object); // true
陣列是有序的值集合,每個值稱為元素,對應一個從0開始的下標。元素可以是任何型別——陣列、物件、null、undefined 都行。
var arr = [];
var arr = new Array();
var t = '';
var arr = [1, 2, 3, null, undefined, [], {}, t];
用 new 建立陣列有三種情況值得區分:
var arr = new Array(); // [],與直接量相同
var arr = new Array(5); // 長度為5的空陣列,直接量做不到這件事
console.log(arr); // [],引擎會忽略 undefined 項
var arr = new Array('5'); // 值為 ['5']
var arr = new Array('test'); // 值為 ['test']
也就是說,只有傳入單一數字時才會被解讀為長度,其他型別都會被當成元素。
value = array[0]; a[1] = 3.14; i = 2; a[i] = 3; a[a[i]] = a[0]; array.test = 'rd'; // 陣列本質上是物件,也能掛一般屬性
合法的陣列下標是大於等於0且小於2的32次方減1的整數。其他值會被轉成字串並當作一般的物件屬性名,不再是下標。
另外要注意長度的自動擴展:
var array = []; array[9] = 10; // 長度自動變成10 // 引擎只為下標9配置記憶體,其餘下標實際上是空的 var array = []; array.length = 10; // 也可以直接設定長度 array[array.length] = 4;
delete 只是把元素設為 undefined,元素本身仍然存在:
var a = [1, 2, 3]; delete a[1]; console.log(a); // [1, undefined, 3]
要真正移除元素,可以考慮 shift()(移除第一個)、pop()(移除最後一個)、splice()(移除一段連續範圍),或直接修正 length。書中亦提到:用 var 宣告的變數是永久性的,用 delete 刪除會引發錯誤(不過在瀏覽器開發者工具中通常仍能刪除)。
var array = [1, 2, 3, 4, 5];
for (var i = 0, l = array.length; i < l; i++) {
console.log(array[i]);
}
array.forEach(function (item, index, arr) {
console.log(item);
});
把 length 提前存成區域變數是個小習慣,可以省去每次迴圈都讀取屬性的開銷。
var array = [1, 2, 3, 4, 5];
array.join(); // "1,2,3,4,5"
array.join('-'); // "1-2-3-4-5"
它是 String.split() 的相反操作。
var array = [1, 2, 3, 4, 5]; array.reverse(); // [5, 4, 3, 2, 1],會修改原陣列
var array = [1, 3, 2, 4, 5, 3]; array.sort(); // [1, 2, 3, 3, 4, 5]
若陣列中含有未定義元素,排序時會被放到最後。同時也可以自訂排序邏輯:比較函式接收兩個參數,若第一個應排在第二個之前,回傳小於0的數;反之回傳大於0的數;相等則回傳0。
array.sort(function (a, b) {
return b - a;
});
一個實用範例——奇數在前偶數在後,各自由小到大:
[1, 2, 3, 4, 5, 6, 7, 2, 4, 5, 1].sort(function (a, b) {
if (a % 2 && b % 2) { return a - b; }
if (a % 2) { return -1; }
if (b % 2) { return 1; }
return a - b;
});
合併陣列,但不做深度合併:
var a = [1, 2, 3]; a.concat(4, 5); // [1, 2, 3, 4, 5] a.concat([4, 5]); // [1, 2, 3, 4, 5] a.concat([4, 5], [8, 9]); // [1, 2, 3, 4, 5, 8, 9] a.concat([4, 5], [6, [10, 19]]); // [1, 2, 3, 4, 5, 6, [10, 19]]
最後一行可以看到,多層嵌套的陣列只會被攤平一層。
擷取子陣列,不修改原陣列:
var a = [1, 2, 3, 4, 5]; a.slice(0, 3); // [1, 2, 3] a.slice(3); // [4, 5] a.slice(1, -1); // [2, 3, 4] a.slice(-3, -2); // [3]
兩點規則:不包含第二個參數指定的位置;負值會轉換為「負值 + 陣列長度」。所以 a.slice(1, -1) 等價於 a.slice(1, 4),a.slice(-3, -2) 等價於 a.slice(2, 3)。
從指定位置刪除若干元素,再插入新元素;回傳被刪除的元素所組成的陣列,原陣列會被改變:
var a = [1, 2, 3, 4, 5, 6, 7, 8]; a.splice(4); // 回傳 [5, 6, 7, 8],此時 a 為 [1, 2, 3, 4] a.splice(1, 2); // 回傳 [2, 3],此時 a 為 [1, 4] a.splice(1, 1); // 回傳 [4],此時 a 為 [1] var a = [1, 2, 3, 4, 5]; a.splice(2, 0, 'a', 'b'); // [1, 2, 'a', 'b', 3, 4, 5] a.splice(2, 2, [1, 2], 3); // 回傳 ['a', 'b'],此時 a 為 [1, 2, [1, 2], 3, 3, 4, 5]
第二個參數之後的參數會直接插入到陣列中,第一個參數也可以為負數。
var stack = []; stack.push(1, 2); // stack: [1, 2],回傳 2 stack.pop(); // stack: [1],回傳被刪除的值 2 stack.push(3); // stack: [1, 3],回傳 2 stack.pop(); // stack: [1],回傳 3 stack.push([4, 5]); // stack: [1, [4, 5]],回傳 2 stack.pop(); // stack: [1],回傳 [4, 5]
push() 把一個或多個元素附加到陣列尾端並回傳新長度;pop() 刪除最後一個元素、減少長度並回傳該值。兩者都直接修改原陣列,而不是產生副本。unshift() 與 shift() 行為相同,只是改從陣列頭部操作。
[1, 2, 4].toString(); // "1,2,4" ['a', 'b', 'c'].toString(); // "a,b,c"
效果等同於無參數的 join()。
後續標準新增的方法包括 map、every、some、filter、forEach、indexOf、lastIndexOf、isArray 等,讓陣列操作比早期只能靠迴圈時簡潔許多。
最後要區分陣列狀物件(array-like)——它們有 length 與數字索引,但實際上不是陣列,常見的有:
arguments 物件document.getElementsByTagName() 回傳的集合這類物件若想用陣列方法,通常需要先轉型,例如 [].slice.call(arrayLike)。