潛說js對象和數組

複製代碼 代碼如下:
/*
數組和對象 【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();