js对象

var ps =[{name:'hjd',age:18,friends:['a','b']},{}];
// alert(ps[0].friends[0]);

function createUserFactory(name,age){
var user = new Object();
user.name = name;
user.age = age;
return user;
}
//通过工厂方式创建对象，解决的对象不能复用的问题，但是无法检测对象user1的数据类型
var user1 = createUserFactory('aa', 18);
//alert(user1.name);


/*
通过构造函数的方式创建,可以检测对象的类型
缺点：每一个对象中都会存在一个方法的拷贝，如果对象的行为很多的话
空间的占用率就会大大增加，决解办法为将方法抽离为全局的。
*/
function Person(name,age){
this.name = name;
this.age = age;
this.say=function (){
alert(this.name+this.age);
}
}
var p1 = new Person()


//原型创建
function Member(){

}
Member.prototype.name = "hjd";
Member.prototype.age= 15;
//m1有隐藏属性_prop_指向原型
var m1 = new Member();

//在m1自己的空间找不到就会去原型中寻找
alert(m1.name);

//在m1的空间里存储，不会改变原型中的。只在查询的时候覆盖。
m1.age=18;

alert(m1.age);

//检测某个对象是否是某个函数的原型
alert(Member.prototype.isPrototypeOf(m1));
//检测某个属性是否是自己的属性
alert(m1.hasOwnProperty("name"));
//删除自己的空间的属性
delete m1.age;
//检测某个对象在原型或者自己种是否包含某个属性，通过in
alert("name" in m1);

=========================================================================

function Person(name,age,friends){
//属性定义在构造函数中
this.name = name;
this.age = age;
this.friends = friends;
}

Person.prototype={
constructor:Person,
//方法定义在原型中
say:function(){
alert(this.name+this.friends);
}
}
//避免了原型带来的问题，使用组合构造函数和原型来实现对象的创建
var  p1 = new Person('hjd', 18, ['aaa','bbb']);
p1.say();


//动态原型创建
function Person(name,age,friends){
//属性定义在构造函数中
this.name = name;
this.age = age;
this.friends = friends;
if(!Person.prototype.say){
Person.prototype.say=function(){
alert(this.name+this.friends);
}
}

}