对象

1. 创建对象的方式

1. 对象字面量

var obj = {
    name: 'qiqi',
    age: 25
}

2. 通过Object构造器创建对象

var obj = new Object();
obj.name = 'qi';

以上两种方法缺点： 每创建一个对象，都要重新声明一次。产生大量重复代码。

3. 通过工厂模式创建对象

function Person(name){
    var o = new Object();
    o.name = name;
    return o;
}
var person1 = Person('aaa');

缺点：当创建多个相似对象时，无法识别是由那个对象创建的。

4. 通过构造函数创建对象

function Person(name, age) {
    this.name = name;
    this.age = age;
    this.read = function(){
        console.log('read');
    }
}

var person1 = new Person('qiqi', 25)

• new操作符执行的事情
  1. 创建一个新对象
  2. 构造函数作用域指向新对象（this指向新对象,该新对象的原型指向构造函数的prototype属性）
  3. 执行构造函数代码（为新对象设置属性）
  4. 返回新对象（若构造函数返回新对象则为该对象，若返回为空。返回this对象）
     缺点： 当创建多个实例是，每个实例都会创建一个read函数

5. 通过原型创建对象

function Person() {}  
Person.prototype.z = 3;
var person1 = new Person();  
person1.x = 10;

原型链.png

• 理解原型与原型链
  • 创建一个Person函数对象
  • Person函数对象默认带一个prototype属性，指向一个对象，该对象是Person的原型对象 （箭头3）
  • 每个原型对象都有一个constructor属性，指向prototype属性所在函数（如：Person） （箭头4）
  • 通过new关键字构造一个person1实例 （箭头1）
  • 每个实例person1都有一个constructor属性，指向构造这个实例的构造器Person （箭头2）
  • 每个实例（如：person1）内部有一个指针__proto__指向构造函数的原型对象 （箭头5）
  • 访问一个实例的属性和方法，现在实例本身中找，没有找到就在__proto__指针指向的原型对象上找。这就是原型链（红色箭头）
  • 每个对象都是Object（）实例，都继承了Object.prototype上的属性和方法（例如： tostring）
  • Object.prototype指向null,访问对象属性时，沿着原型链一直向上查找，直到null
  • in判断属性是否在对象的原型链上，hasOwnProperty判断该对象本身是否有该属性。
  • propertyIsEnumerable属性能否被枚举
  • delete操作，只能删除对象本身的属性，不能删除原型链上的属性
• 总结：通过new关键字创建的对象，可以继承原型链上的属性，又不会修改原型链上的属性

function Person() {}   //创建一个Person函数对象

Person.prototype.z = 3;
Person.prototype.list = ['a', 'b'];   //一个实例对list操作后，另一个实例也跟着改变

var person1 = new Person();  
person1.x = 1;

'z' in person1  //true
person1.hasOwnProperty('z') //false
person1.hasOwnProperty('x')  //true

person1.propertyIsEnumerable('x')  //true
person1.propertyIsEnumerable('toString')  //false

person1.z = 5
person1.hasOwnProperty('x')  //true

delete person1.z
person1.hasOwnProperty('z')  //false
Person.prototype.z  //3

console.log(person1.z)  //3   原型对象属性
console.log(typeof person1.toString) // function

person1.constructor  //Person

Person.prototype.constructor  //Person

Person.prototype === person1.__proto__  //true

var a = {}
a.__proto__ === Object.prototype  //true

//Person.prototype = {name: 'a'}  与  Person.prototype.name = 'a' 的区别
 
 
//Person.prototype = {name: 'a'}
Person.prototype.constructor === Person //true
 
 
//Person.prototype = {name: 'a'},  {}是Object的实例，{}.constructor指向Object
Person.prototype.constructor === Object //true
 
 
Person.prototype = {
    constructor: 'Person'
    name: 'a'
}

缺点： 当一个实例对原型对象上的属性操作后（比如： list），另一个实例也跟着改变。

6. 构造函数定义属性与原型对象定义方法相结合（应用广泛）

function Person(name) {
    this.name = name;
}
Person.prototype = {
    constructor: Person,
    aFun: function() {
        console.log('ddd')
    }
}
 
 
var person1 = new Person('q');

7. 通过Object.create创建对象

var obj = Object.create({x: 1})

obj.x  //1
obj.hasOwnProperty('x')  //false

Object.create是Object内置的方法，接受一个对象参数。生成一个新对象，并且新对象的原型指向参数对象。

2.

• Object.keys(对象)获取对象上的属性, 不返回属性特性enumerable: false的

var o = {a: 1, b:2}
Object.keys(o)   //["a", "b"]