2、工厂格局

这种工厂情势并不是设计形式中的工厂方法，代码如下：

    function createObj(name, age) {
        var o = new Object();
        o.name = name;
        o.age = age;
        o.sayHello= function() {
            alert("Hello Word!");
        }
        return o;
    }

    var obj = createBlog("Tom", "88");

这种情势好多了，然而也设有一个题材，就是没办法知道一个对象是何许项目；console.log(typeof
obj);//object

3、构造函数形式

function Person(name,age,job){
    this.name=name;
    this.age=age;
    this.job=job;
    this.sayNmae=function(){
        alert(this.name);
    }
}
var persong1=new Person("Join",18,"农民");
var persong2=new Person("Join",18,"地主");

构造函数形式看起来oop（面向对象）多了，下边两种情势存在的题目在结构情势中都不设有了（创制对象的代码可以复用、对象类型可以识别）看起来世界挺美好，遗憾的是

这种依然存在一个题材；

1、每一个格局都要在每个实例上再也创建一次（问题不大）；

2、从地点例子可以看来每个person 实例都蕴含一个不等的function
实例；不要忘了ECMAScript中的函数也是目的，所以地点的代码与下部的代码等价（紧要会造成不同的功用域和剖析问题）

    function Person(name,age,job){
        this.name=name;
        this.age=age;
        this.job=job;
        this.sayNmae=new function(){
            alert(this.name);
        }
    }

alert(person1.sayNmae==person2.sayNmae)// false

当然这个问题也是能解决的，就是把方法移到外面，让他成为全局的函数，但是这样一来该函数就只能由widows对象调用了，而且如果存在多个方法，就会存在多个全局函数，那我们自定义的的引用类型
就丝毫没有封装可言了。
好在这些问题都可言通过原型模式来解决；
说了一大堆废话进入正题：原型,他是一个对象;

原生对象的模子

JS 原生的引用类型，都是运用这种形式开创的。如
在Array.prototype.sort()，能够找到sort()方法。

搜寻原理

当代码读取某个对象的特性或者措施时都会履行三回搜索，首先从从目标自我开端，借使存在则赶回给定的性能名或者方法名，不存在继续查找指针（_ECMAScript，proto_）指向的原型对象，如下面的代码 persong1.sayNmae。首先解析器会问：”对象实例person1有sayName吗？”，答：没有，然后继续寻找，问person1的原型有”sayName
吗？”，答：有，读取原型对象中的函数；这就是五个实例共享原型中属性、方法的基本原理；

因此可知当实例中与原型中设有一样的性质名时会读取实例的属性名，可是他们中间不设有引用问题，即你设置了实例的属性为null，并不会潜移默化到原型中的属性，他们毕竟是属于不同的目标；

function特征

在js中一切都是对象，当我们写function 时js
就会同时创建它的prototype对象（原型对象），这一个目的涵盖一个性能prototype(原型)，这多少个特性是一个指针，该指针指向原型对象，

该目标的效果是一定项目（该类型实例的目标）的持有实例共享属性和章程；

function Person(name,age,job){

    this.name=name;
    this.age=age;
    this.job=job;
}
Person.prototype.sayNmae=function(){
    alert(this.name);
}
var persong1=new Person("Join",18,"农民");
var persong2=new Person("Join",18,"地主");

alert(persong1.sayNmae==persong2.sayNmae)// true

创立对象模式

2、继承；

原型动态性

原型是目标，对象是援引类型，所以当在原型中干了些什么事情，都能登时在实例对象上影响出来；

1、字面量

var obj={name:”join”,age:18}

var obj1={name:”Tom”,age:88}

当我们需要创制两个特性只有值不相同的靶猪时，这种情势就喜剧来了，会招致大量的冗余代码，最要害的是代码无法复用；

实例之New 操作符

创办一个实例经常会经历以下4步：

1、创造一个新的目的；

2、将构造函数的功用域赋给新对象（this指针指向这多少个新的目的）；

3、执行构造函数中的代码（还会将该对象的__proto__本着了函数的prototype对象）；

4、再次回到该目标；

急需注意的地方是当调用构造函数创设一个新指标后，该目的内部将含有一个指正（内部属性
_proto_）,指向构造函数的原型对象（prototype
对象），该属性在ES6中貌似规范化了；

原型形式的题材

当我们把引用类型属性添加到原型对象时，会招致数据共享的题材，如在person
中把一个数组放到原型对象中，此时持有的靶子都会共享那多少个数组：

friedns:[“tom”,”Join”,”Elie”];

当大家之中一个实例对这一个目的举行push(“Tem”);

持有的实例都可以访问到”Tem”;

先看js 此前成立对象的点子存在的题材；

Prototype对象

在默认境况下拥有原型对象都会自动获取一个属性Constructor（构造函数属性）这一个特性包含一个针对性prototype属性所在的函数指针；

更简约的原型语法

当大家要添加三个艺术时，没必要每一回都写类似这样的代码
Person.Prototype.XXX=function(){//doing something}

Person.Prototype={

constructor:Person,//注意这里要重写

sayAge:function(){ alert(this.age);},

sayJob:function(){ alert(this.job);}

}

那里为什么要重写constructor呢，很粗略每创制一个函数，就会同时成立它的prototype对象（原型对象），这多少个目的也会拿到constructor属性，

而地方大家重写了默认的prototype对象，因而constructor这时并从未针对Person，而是指向新object构造函数，所以这边要重写constructor让他本着Person;

缘何会有原型这一个定义；

1、优雅的创设对象；

实例、构造函数、原型对象关系

开创的各类实例都会有一个之中属性_proto_ 指向构造函数的原型对象；

构造函数存在prototype 属性指向该函数的原型对象；

地点person代码如图：

ECMAScript 1

美术的不得了下次试试思维导图这多少个工具；

瞩目实例只跟原型对象有关系；

总结

1、创设function 就会同时创造它的prototype对象（原型对象），function也是目标实际在原型对象中也存在一个默认的_proto_
指向函数的原型对象（Function.prototype）；

2、JS 每个对象中都设有_proto_，函数对象才存在prototype
属性，所以会看到有些博客说JS
对象分为二种：一种是Object（自定义），一种是function；

3、实例话对象就会把function中的prototype属性值赋给目的实例的_proto_；

4、原型是一个目的，大家得以重写该对象；

自我JS新手有误之处还请见谅，顺便提出错误，让我们这么些新手有上扬！

结合使用构造函数与原型形式

按照下面数据共享的问题，解决方案常常是：属性写在构造函数中，方法写在原型中，这样各样实例都会有友好属性，同时又共享着艺术的引用，这样既能最大限度的节约了内存；

澳门新莆京网站app

ECMAScriptjavaScript-原型、继承-01