復制代碼 代碼如下:
/*
數組和對象 【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; // 'function'
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;
// 如果對象 obj, 含有方法 getName, 則執行它;
if (obj.getName && toString.call(obj.getName) === '[object Function]') ) {
obj.getName();
}
// 補充：
console.log(null == undefined); // true;
console.log(null !== undefined); // true;
/* 刪除屬性 */
delete obj.name;
// 補充: 使用 delete 操作符, 不能刪除使用 var 聲明的變量;
/* 作為關聯數組的對象 */
// 取對象屬性：
obj.name;
obj['name']; // 這裡 name 為字符串.
// 使用 [] 表示時, 屬性名是用字符串來表示的. 那麼可
// 在運行過程中進行添加等操作
// 注：當此屬性是做為變量傳遞時, 特別有用.
// 又稱 關聯數組
/* 映射： JavaScript 對象把字符串(屬性名) 映射成值. */
for (var key in obj) {
console.log(key); // key 屬性名, 此處 做為值存在.
}
/*
通用的 Object 屬性和方法
JavaScript 中所有對象都繼承自 Object 類;
1, constructor 屬性.
指向其構造函數.
*/
var F = function () {};
var f = new F;
console.log(f.constructor == F); // true
// 構造函數的原型存在屬性 constructor 指向自己;
F.prototype.constructor == F;
// 補充：
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;
/*
2, toString() 方法
*/
{'name': 'maxthon'}.toString(); // '[object Object]'
/* 數組使用 toString 方法, 把會元素組成字符串, 其它對象會轉化為 [object Object];
函數使用原始 toString 方法, 會得到函數源碼 */
['a', 'b', 1, false, ['e','f'], {}].toString();
// "a,b,1,false,e,f,[object Object]"
function t() {
console.log('test');
}
t.toString();
// 源碼
/*
3, toLocalString();
返回對象的一個本地化字符串
4, valueOf();
在轉化為基本類型時, 會使用到. valueOf/toString.
5, hasOwnProperty();
6, propertyIsEnumberable();
是否可枚舉出來;
7, isPrototyeOf();
a.isPrototyeOf(b);
如果 a 是 b 的原型, 則返回 true;
*/
var o = {}; // new Object;
Object.prototype.isPrototyeOf(o); // true;
Object.isPrototyeOf(o); // false;
o.isPrototyeOf(Object.prototype); // false;
Function.prototype.isPrototyeOf(Object); // true;
/* 【閉包是存在函數實例, 垃圾沒有回收是存在賦值引用】 */
/*
數組: 有序的、值的集合;
每個值, 也叫元素, 對應一個下標;
下標是從 0 開始;
數組中值, 可以為任何類型. 數組, 對象, null, undefined.
*/
// 創建.
var arr = [];
var arr = new Array();
var t = '';
var arr = [1,2,3, null, undefined, [], {}, t];
/* 使用 new 操作符創建數組的3種情況: */
var arr = new Array(); // [], 和直接量相同
var arr = new Array(5); // 長度為 5; []直接量是無法做到的.
console.log(arr); // []; JavaScript 引擎會無視 undefined;
var arr = new Array('5'); // 值為 ['5'];
var arr = new Array('test'); // 值為 ['test'];
/* 相關實例 */
var s = [1, 2, 3];
s[5] = 'a';
console.log(s);
[1, 2, 3, undefined, undefined, 'a']
/* 數組的讀和寫 */
value = array[0];
a[1] = 3.14;
i = 2;
a[i] = 3;
a[a[i]] = a[0];
// 數組 -> 對象 -> 屬性
array.test = 'rd';
// 數組下標大於等於 0, 並且小於 2的32次方 減 1 的整數.
// 其它值, JavaScript 會轉化成字符串, 做為對象屬性的名字, 不再是下標.
var array = [];
array[9] = 10; // array 長度會變成 10;
// 注： JavaScript 解釋器只給數組下標為 9 的元素分配內存, 其它下標無.
var array = [];
array.length = 10; // 添加 array 的長度;
array[array.length] = 4;
/* 刪除數組元素 */
// delete 運算符把一個數組元素設置為 undefined 值, 但是元素本身還是存在的.
// 真正刪除, 可以使用: Array.shift();【刪除第一個】 Array.pop();【刪除最後一個】 Array.splice();【從一個數組中刪除一個連續范圍】 或修正 Array.length 長度;
/* 相關實例 */
var a = [1, 2, 3];
delete a[1];
console.log(a); // [1, undefined, 3];
/* 補充： JavaScript 權威指南 第五版 59頁
由 var 聲明的變量是永久性的, 也就是說, 用 delete 運算符來刪除這些變量將會引發錯誤.
但： 在開發者工具裡面, 是可以刪除的. 而在網頁中, 正如書上所寫.
*/
/* 數組長度 */
[].length;
/* 遍歷數組 */
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 長度, 前面已提過 */
/* 多維數組 */
[[1], [2]]
/* 數組方法 */
// join
var array = [1, 2, 3, 4, 5];
var str = array.join(); // 1,2,3,4,5
var str = array.join('-'); // 1-2-3-4-5
// 注： 此方法與 String.split() 方法相反;
// reverse();
var array = [1, 2, 3, 4, 5];
array.reverse(); // [5, 4, 3, 2, 1]
// 注：修改原數組;
// sort();
var array = [1, 3, 2, 4, 5, 3];
array.sort();// [1, 2, 3, 3, 4, 5];
/* 注： 數組中存在未定義元素, 把這些元素放到最後 */
/* 同時可自定義排序, sort(func);
func 接收兩個參數, 如果第一個參數應該位於第二個參數之前, 那麼比較函數將返回一個小於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;
});
// concat() 方法. 合並數組, 但不深度合並
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] ]
// slice() 方法. 源數組不改變.
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(1, -1 + 5)
a.slice(1, 4);
a.slice(-3, -2); // [3]
a.slice(-3 + 5, -2 + 5);
a.slice(2, 3);
/* 注：
不包括第二個參數指定的元素.
負值轉化為: 負值 + 數組長度
*/
// splice(pos[, len[, a, b]]) 方法. 刪除指定位置開始後, 指定長度元素, 再綴加元素;
// 返回刪除元素組成的數組. 原數組改變.
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]
/* 注：
第二個參數後的參數, 直接插入到處理數組中。
第一個參數可為負數.
*/
// push() 方法和pop() 方法.
// push() 可以將一個或多個新元素附加到數組的尾部, 然後返回數組新長度;
// pop() 刪除數組中的最後一個元素, 減少數組的長度, 返回它刪除的值.
// 注：兩個方法都在原數組上修改, 而非生成一個修改過的數組副本.
var stack = [];
stack.push(1, 2); // stack: [1, 2]; return 2;
stack.pop(); // stack: [1]; return 2; 刪除的元素值
stack.push(3); // stack: [1, 3]; return 2;
stack.pop(); // stack: [1]; return 3; 刪除的元素值
stack.push([4, 5]); // stack: [1, [4, 5]]returm 2;
stack.pop(); // stack: [1]; return [4, 5]; 刪除的元素值
// unshift() 方法和 shift() 方法. 同上, 從數組頭開始.
// toString() 方法和 toLocalString()
[1, 2, 4].toString(); // 1,2,3;
['a', 'b', 'c'].toString(); // 'a,b,c';
// 和無參數的 join 方法相同.
/* jsapi 新添方法：map, every, some, filter, forEach, indexOf, lastIndexOf, isArray */
/* 類似數組的對象 */
arguments
document.getElementsByTagName();