对象

创建对象

• 方式1-字面量表示，推荐使用

var a = {};

• 方式2-调用构造函数,不推荐使用

var obj = new Object();
//Object是所有对象的基础

• 方式3 ，自定义方法,形式和函数一样，为了区分，构造函数命名严格按照大驼峰形式（所有单词首字母大写）

function Person(){}
var person = new Person();

Object的所有实例都有下列属性和方法,因此所有的对象都有这些属性和方法

• constructor
• hasOwnProperty(propertyName)
  --->propertyName必须为字符串类型
• propertyIsEnunerable(propertyName)
  --->propertyName必须为字符串类型
• isPrototypeOf(object)
• toString()
• valueOf()
• toLocaleString()

使用构造函数创建对象模式

    function Person(name,age,job){
        this.name=name;
        this.age=age;
        this.job=job;
        this.sayName=function(){
            console.log(this.name);
        };
    }
    var person1 = new Person('xiaoli',29,'doctor');
    var person1 = new Person('xiaozhang',38,'teacher');
    console.log(person1.constructor ==Person);//true
    console.log(person2.constructor ==Person);//true

构造函数原理

构造函数和普通函数的唯一区别就是名字要首字母大写和要用new实例化
要创建Person的实例，必须使用new，以这种方式调用构造函数实际上会经历4个阶段

• 创建一个新对象
• 新对象名字叫this（构造函数的作用域赋予新对象）
• 执行构造函数中的代码（为这个新对象添加属性）this.xxx=xxx;
• 返回新对象 return this

构造函数的注意点

• 不同实例的同名函数是不相等的。
• 所以创建两个完成同样任务的Function实例没有必要,况且由this对象在，根本不用再执行代码前就把函数绑定在特定对象上
• 把函数定义转移到构造函数外部来解决这个问题

    function Person(name,age,job){
        this.name=name;
        this.age=age;
        this.job=job;
        this.sayName=sayName;
    }
    function sayName(){
            console.log(this.name);
        }
    var person1 = new Person('xiaoli',29,'doctor');
    var person1 = new Person('xiaozhang',38,'teacher');

但是这样又有新的问题。

• 在全局作用域中定义的sayName只能被某个函数调用，
• 如果需要定义很多方法，那就要定义很多全局函数，没有封装性
• 通过原型模式来解决

原型模式

我们创建的每一个函数都有prototype属性，prototype也是对象，是构造函数制造出来的对象的公共祖先，创造出来的原型可以继承原型里面的属性和方法

• JavaScript 的所有对象中都包含了一个 __proto__ 内部属性，这个属性所对应的就是该对象的原型
• JavaScript 的函数对象，除了原型 __proto__ 之外，还预置了 prototype 属性
• 当函数对象作为构造函数创建实例时，该 prototype 属性值将被作为实例对象的原型 __proto__。

---

• prototype是通过调用构造函数而创建的那个对象实例，的原型对象

不必再构造函数中定义对象实例的信息，而是将信息直接添加到原型对象中

function Person(){}
Person.prototype.name="lia";
Person.prototype.age=19;
Person.prototype.sayName=function(){
    console.log(this.name);
};
var person1 = new Person();
var person2 = new Person();
person1.sayName();
person2.sayName();

理解原型对象

• 无论什么时候，只要创建了一个新函数，就会为该函数创建一个prototype属性。这个属性指向函数的原型对象
• 在默认情况下，所有原型对象都会自动获得一个constructor(构造函数)属性，这个属性是一个指向prototype属性所在函数的指针，

Person.prototype.constructor指向Person

• 创建一个自定义的构造函数后，其原型对象只会默认取得constructor属性，至于其他方法，都是从Object继承来的
• 构造函数初始化时，新建的this空对象其实不是空的，里面自带一条__proto__:Person.prototype,用来指引实例函数寻找他的原型
• 在调用构造函数创建一个新实例后，该实例的内部将包含一个指针，指向该构造函数的原型对象。es5管这个指针叫[[prototype]]
• 脚本中没有标准的方法访问[[prototype]]，但Firefox,safari和chrome在每个对象上都支持一个属性proto,而在其他实现中，这个属性对脚本则是完全不可见的。
• 这个链接存在于 实例函数 和 构造函数的原型对象 之间，而不是存在于实例和构造函数之间
• 函数才有prototype，实例对象只有有proto， 而函数有的proto是因为函数是Function的实例对象

以以上 Person构造函数为例

• Person.prototype指向了原型对象，而Person.prototype.cunstructor又指向了Person,

---

其他注意点

• 当为对象实例添加一个属性是，这个属性会 <em>屏蔽</em> 原型对象中保存的同名属性。（添加这个同名属性只会阻止我们访问原型对象中的那个属性，而不会修改那个属性。）。即使这个属性为null
• 但是，使用delete操作符可以完全删除实例属性，从而可以可以重新访问原型中的属性

原型链-使用proto连接

任意一个函数（包括构造函数）都有一个prototype属性，指向该函数的原型对象，同样任意一个构造函数实例化的对象，都有一个proto属性

Grande.prototype.lastname="你爷爷";
function Grande(){}
var grande = new Grande();

Father.prototype=grande;
function Father (){}
var father = new Father();

Son.prototype=father;
function Son (){}
var son = new Son();
console.log(son.lastname);//你爷爷

Grande.prototype.proto--->Object.prototype

• 绝大多数对象的最终，都会继承自Object.protype

var obj = Object.create(null)
这样就没有原型了，因为null和undefined没有toString方法

• 重写toString方法

            Number.prototype.toString=function(){
                return "你要返回的东西";
            }

方法

isPrototypeOf()

console.log(Person.prototype.isPrototypeOf(person1));//true
console.log(Person.prototype.isPrototypeOf(person2));//true
//因为Person1和Person2内部都有一个指向Person的指针，所以返回true

Object.getPrototypeOf

返回这个对象的原型

hasOwnPrototype()

一个属性是存在实例中，而不是存在于原型对象中，返回ture，继承自Object
使用for-in循环是，会循环实例和原型对象里面的属性，

确认属性是原型中的属性

function hasPrototypeProperty(object,name){
    return (name in object) && !object.hasOwnPrototype(name);
}
//左边的卡确认是实例或者原型的属性，左边返回ture后，右边的如果是原型里面的属性，则整体返回true

proto和prototype的联系和区别

function a() {
    //console.log("I'am a function.");
}
//b是实例化对象，a是构造函数
 var b = new a();
 console.log(b.__proto__ == a.prototype); //true
 //一个对象的隐式原型指向构造该对象的构造函数的原型，这也保证了实例能够访问在构造函数原型中定义的属性和方法。
console.log(Object.getPrototypeOf(b) == a.prototype); //true

区别：

• 区别：prototype是构造函数访问原型对象，proto是对象实例访问原型对象。
• proto是每个对象都有的一个属性，而prototype是函数才会有的属性!!!
• 使用Object.getPrototypeOf()代替proto

注意： 函数才有prototype，实例对象只有有proto， 而函数有的proto是因为函数是Function的实例对象

继承

借用构造函数法

在构造函数中 使用Parent.call(this)的方法继承父类属性。

原理： 将子类的this使用父类的构造函数跑一遍

缺点： Parent原型链上的属性和方法并不会被子类继承

function Parent() {
  this.name = 'parent'
}

function Child() {
  Parent.call(this);
  this.type = 'child'
}

原型链实现继承

原理：把子类的prototype（原型对象）直接设置为父类的实例

Son.prototype=new Father();

缺点：当子类对象上进行值修改时，如果是修改的原始类型的值，那么会在实例上新建这样一个值；
但如果是引用类型的话，他就会去修改子类上唯一一个父类实例里面的这个引用类型，这会影响所有子类实例

继承圣杯模式

* 继承圣杯模式

var inherit =(function(){
    var F = function(){};//利用闭包，实现变量私有化
    return function(Target,Origin){
        F.prototype = Origin.prototype;
        Target.prototype= new F();
        //通过原型链连接
        Targer.prototype.constructor = Target;
        Target.prototype.uber = Origin.prototype;
    }
}());

---

对象的遍历

for in

var obj= {
    name:123,
    age:33，
    __proto__:{
        lastName:deng;
    }
}
for(bar i in obj){
    //为了不访问到原型里面的方法
    if(obj.hasOwnProperty(i)){
        console,log(i+":"+obj[i]);
    }
}
//i是一个字符串，如果写成obj.i,系统会转换成obj['i']，就成属性读取，，所以必须要写方括号，
//如果是系统自带的原型，没程序员设置，他就不会打印出来，。要程序员自己设置的原型，才会被打印出来

object.name与object["name"]

• 使用方括号读取对象属性（替代点方式）-比较灵活

var obj = {
    name:"xiaoli"
}
obj.name;//用这种方式访问，会在后台转换成方括号模式
obj['name'];
//这两种方式，本质来说是一样的，方括号比较灵活

• 应用

 var deng = {
     wife1:{name:"1111"},
     wife2:{name:"22222"},
     wife3:{name:"3333"},
     wife4:{name:"4444"},
     sayWife:function(num){
         console.log(deng['wife'+num]);
     }  
 }

模拟Jquery实现链式编程

var deng = {
    smoke : function(){
       console.log("smoking...");
       return this
    },
    sayHi:function(){
        console.log("hello");
        return this;
    }
}
deng.smoke().sayHi();