JavaScript使用对象

创建对象

1，使用构造函数创建对象
var name = new Object();创建空对象
var name = new Array();使用内置构造函数创建对象
也可以自定义对象如下Box

function Box(w,h){ 		// 构造函数
   this.w = w; 		// 构造函数的成员
   this.h = h; 		// 构造函数的成员
}
var box1 = new Box(4,5); 		// 实例并初始化构造函数

2，使用对象直接量创建对象

var o = {							// 对象直接量
    a : 1, 							// 定义属性
    b : true						// 定义属性
}

var o = {							// 对象直接量
    a : function(){					// 属性值为函数
        return 1;
    }
}
alert(o.a());				// 附加小括号读取属性值，即调用方法
var o = {							// 对象直接量
    a : [1,2,3] 					// 属性值为数组
}
alert(o.a[0]); 				// 使用下标来读取属性包含的元素值

3，使用create（）方法创建对象
var newObj = Object.create(prototype , descriptors)
prototype:必选参数，原型的对象，可以为null
descriptors：可选参数，包含一个或多个属性描述符的对象
数据属性描述符包含value特性，writable是否可修改属性，enumerable是否可枚举属性，configurable是否可删除特性和删除属性特性

var newObj = Object.create(null, {
            size: {
                value: "large",
                enumerable: true
            },
            shape: {
                value: "round",
                enumerable: true
            }
        });
document.write(newObj.size + "<br/>");			//large
document.write(newObj.shape + "<br/>");			//round
document.write(Object.getPrototypeOf(newObj));	//null

操作对象

对象除了包含属性，还包含：
prototype对象的原型：指向另一个对象，本对象属性继承自他的原型对象
class对象的类：标识对象类型的字符串
extensible flag对象的扩展标记：指明了是否可以向该对象添加新属性

引用对象

对象赋值时，a1=a，当delete a后，a不存在但是a1依然存在没有被删除

赋值对象

利用for/in语句遍历对象成员，进行赋值

function F(x,y){ 	// 构造函数F
    this.x = x; 	// 本地属性x
    this.y = y; 	// 本地属性y
    this.add = function(){	// 本地方法add()
        return this.x + this.y;
    }
}
F.prototype.mul = function(){	// 原型方法mul()
    return this.x * this.y;
}
var f = new F(2,3) 	// 实例化构造函数，并进行初始化
var o = {} 	// 定义一个空对象o
for(var i in f){ 	// 遍历构造函数的实例，把它的所有成员赋值给对象o
    o[i] = f[i]; 
}
alert(o.x); 	// 返回2
alert(o.y); 	// 返回3
alert(o.add());	// 返回5
alert(o.mul());	// 返回6

//对于该复制法，还可以进行封装，使其具有较大的灵活性：
Function.prototype.extend = function(o){ 	
// 为Function扩展复制的方法
    for(var i in o){ 	// 遍历参数对象
        this.constructor.prototype[i] = o[i]; 
        // 把参数对象成员复制给当前对象的构造函数原型对象
    }
}

销毁对象

JavaScript提供一套垃圾回收机制，能够自动回收无用存储单元，当单元没有被任何变量引用时，JavaScript会自动侦测，并运行垃圾回收程序把这些对象注销，以释放内存。当函数对象被执行完毕，垃圾回收程序就自动被运行，释放函数所占用的资源，并释放局部变量。另外如果对象处于一种不可预知的情况下，也会被回收处理。
定义对象引用变量为null即废除对象（a=null）

操作属性

定义属性

冒号左侧属性名，右侧属性值，属性间用逗号隔开
ECMAScript5增加了两个静态函数，用来指定对象定义属性：Object.defineProperty和Object.defineProperties
1，Object.defineProperty用来添加新属性，修改现有属性
Object.defineProperty（object，propertyname，descriptor）
object表示修改的对象，propertyname表示包含属性名称的字符串，descriptor表示针对属性的描述符

var obj = {};
Object.defineProperty(obj, "newDataProperty", {
    value: 101,
    writable: true,
    enumerable: true,
    configurable: true
});
obj.newDataProperty = 102;
document.write(obj.newDataProperty );	//102

var obj = {};
Object.defineProperty(obj, "newAccessorProperty", {
    set: function (x) {
        this.newaccpropvalue = x*x;
    },
    get: function () {
        return "<h1>" + this.newaccpropvalue + "</h1>" ;
    },
    enumerable: true,
    configurable: true
});
obj.newAccessorProperty = 30;
document.write( obj.newAccessorProperty ); //<h1>900</h1>

2，Object.defineProperties（object，descriptor）

var obj = {};
Object.defineProperties(obj, {
    newDataProperty: {
        value: 101,
        writable: true,
        enumerable: true,
        configurable: true
    },
    newAccessorProperty: {
        set: function (x) {
            this.newaccpropvalue = x;
        },
        get: function () {
            return this.newaccpropvalue;
        },
        enumerable: true,
        configurable: true
    }});
obj.newAccessorProperty = 10;
document.write ( obj.newAccessorProperty ); //10

访问属性

通过点运算符实现
遍历对象属性：
o = { // 定义对象
x:1,
y:2,
z:3
}
for(var i in o){ // 遍历对象属性
alert(o[i]); // 读取对象的属性值
}
如果读取不存在不会抛出异常而是返回undefined
Object.getPrototypeOf返回指定对象的原型
Object.getOwnPropertyNames返回指定对象私有属性的名称
Object.getOwnPropertyDescriptor能够获取指定对象的私有属性的描述符

赋值和删除属性

var o = {	// 定义对象
    x:1,
    y:2
}
o.x =2; 	// 设置属性的新值，将覆盖原来的值
o["y"] = 1; 	// 设置属性的新值，将覆盖原来的值
alert(o["x"]);	// 返回2
alert(o.y); 	// 返回1

var o = { x:1}	// 定义对象
delete o.x; 	// 删除对象的属性x
alert(o.x); 	// 返回undefined

获取属性时可以使用点运算符，也可以使用数组形式，如：o[“x”]

使用方法

对象属性也可以是方法
如果运行方法时，应该加（）

function f(){	// 定义方法
    return this.x + this.y;
}
function MyClass(x,y){ 	// 自定义类
    this.x= x;
    this.y = y;
    this.add = f; 	// 把方法封装在类中，这样每个示例都拥有了该方法
}
var o = new MyClass(10,20); 	// 实例化类，并初始化参数值
alert(o.add());	// 调用方法，返回值30

使用默认原型方法

Object对象默认定义了许多原型方法

toString（）

返回对象的字符串表示
构造函数名.tostring返回源代码
函数对象名.tostring返回[object,object……]
可以自己对原型函数进行扩展
Object.prototype.toString=function（）{ }；来修改自带的tostring函数

function Me(){}	// 自定义数据类型
Me.prototype.toString = function(){
	// 自定义Me数据类型的toString()方法
    return "[object Me]"; 
}
var me = new Me();
alert(me.toString());	// 返回"[object Me]"
alert(Object.prototype.toString.apply(me)); 
// 默认返回"[object Object]"

使用valueOf（）

返回对象的原始值
如Date对象的valueOf方法返回值为当前日期对象的毫秒数
也可以重写valueOf（）方法，同上toString（）方法
Object.prototype.valueOf=function(){ }

function Point(x,y){ 	// 自定义数据类型
    this.x = x;
    this.y = y;
}
Point.prototype.valueOf = function(){
// 自定义Point数据类型的valueOf ()方法
    return "(" + this.x + "," + this.y + ")";
}
var p = new Point(26,68);
alert(p.valueOf());	// 返回当前对象的值"(26,68)"
alert(Object.prototype.valueOf.apply(p)); 	
// 默认返回值为"[object Object]"

alert§表示调用p.valueOf()

检测私有属性

f.hasOwnProperty(“name”)返回true或者false，只能是直接属性关系，不能是属性的属性，不连接
例如：

var o = {	// 对象直接量
    o1 : {	// 子对象直接量
        o2 :{ 	// 孙子对象直接量
            name : 1	// 孙子对象直接量的属性
        }
    }
};
alert(o.hasOwnProperty("o1"));	// 返回true，说明o1是o的私有属性
alert(o.hasOwnProperty("o2"));	// 返回false，说明o2不是o的私有属性
alert(o.o1.hasOwnProperty("o2"));	// 返回true，说明o2是o1的私有属性
alert(o.o1.hasOwnProperty("name"));	// 返回false，说明name不是o1的私有属性
alert(o.o1.o2.hasOwnProperty("name"));	// 返回true，说明name不是o2的私有属性

使用原型

定义原型相当于定义构造函数

原型属性和本地属性

原型属性表示构造函数的属性，本地属性表示实例化的属性
实例化本地属性，属性值会覆盖原型属性，如果删除delete本地属性后，属性值会返回原型属性的值

function p(x,y,z){ 	// 构造函数
    this.x = x; 	// 声明本地属性x并赋参数x的值
    this.y = y; 	// 声明本地属性y并赋参数y的值
    this.z = z; 	// 声明本地属性z并赋参数z的值
}
p.prototype.del = function(){	// 定义原型方法
    for(var i in this){ 	
    // 遍历本地对象，删除实例对象内的所有属性和方法
        delete this[i];
    }
}
p.prototype = new p(1,2,3); 
// 实例化构造函数p，并把实例对象传递给原型对象
var p1 = new p(10,20,30); 	// 实例化构造函数p为p1
alert(p1.x); 	// 返回10，本地属性x的值
alert(p1.y); 	// 返回20，本地属性y的值
alert(p1.z); 	// 返回30，本地属性z的值
p1.del();	// 调用原型方法，删除所有本地属性
alert(p1.x); 	// 返回1，原型属性x的值
alert(p1.y); 	// 返回2，原型属性y的值
alert(p1.z); 	// 返回3，原型属性z的值