原型以及原型链

先知知识:
function,array,object都属于对象
对象是函数创建的，而函数却又是一种对象

  console.log(typeof function(){})// function
  console.log(typeof [1,2,3])  //object
  console.log(typeof {a:1}) //object

function 显得有点不合群啊，但这是有原因的。
对！函数是一种对象，但是函数却不像数组一样——你可以说数组是对象的一种，因为数组就像是对象的一个子集一样。但是函数与对象之间，却不仅仅是一种包含和被包含的关系，函数和对象之间的关系比较复杂，甚至有一点鸡生蛋蛋生鸡的逻辑。

    console.log(Function instanceof Function)//true
    console.log(Function instanceof Object) //true
    console.log(Object instanceof Function) //true

这个时候，你心里会在想：上面这些是什么鬼！什么东西！
不要急，先继续往下看。

对于继承的理解：
所有对象都具有_proto__属性，所有函数都具有prototype属性，Fn是一个函数（具有prototype属性），fn对象是从Fn函数new出来的，那么fn函数可以调用Fn.prototype中的所有属性。
也就是说，我们在访问一个对象的属性时，会现在基本属性中查找，如果没有，我们就会沿着它的_proto__属性这条链往上面找，也就是原型链。

Function.prototype是一个普通的对象，所以它的构造函数是Object,所以它的_proto_是不是也指向Object.prototype？

答案是肯定的。因为Function.prototype指向的对象也是一个普通的被Object创建的对象，所以也遵循基本的规则。
var a = { } //一般推荐这么写

var a = new Object( )  //等于上式

var b = [ ] //一般推荐这么写

var b = new Array( ) //等于上式

function Foo(){

}//一般推荐这么写

var Foo = new Function() //等于上式

也就是说对象都是通过函数来创建的，平常我们看到的var obj = {a:1}这个只是语法糖，其实也是通过构造函数来实现的。

var obj = new Object();
obj.a = 10;
obj.b = 20;

Foo()的构造函数是Function
对象a的构造函数是Object
数组b的构造函数是Array

重点规则：

所有的引用类型（函数，对象，数组）都是拥有对象特性，可以随意扩展属性（null除外）。
所有的引用类型都有一个_proto_属性（也称为隐式属性），其属性值是一个普通对象。

所有的函数都有一个prototype属性（也称为显式属性），其属性值也是一个普通对象。（Function默认的只有一个叫做constructor的属性，指向这个函数本身。如下图）

image.png

例如，我们的Object（这是一个构造函数来着，所以它也是函数）的prototype就拥有许多默认的方法，如下：

image.png

当我们新建一个对象，即var obj = {a:1},这个obj也拥有Object.prototype上所有的属性和方法。

所有的应用类型的_proto_属性相当于它的构造函数的prototype属性
```
  var obj = {};
  console.log(obj._proto_===Object.prototype)   //true
```

上面是一条很重要的性质。

    function Foo(name){
      this.name=name;
    }
    var f = new Foo('zhangsan');
    f.printf = function(){
      alert(this.name);
    }
    f.toString();   //这个要去f._proto_.proto里面找

看下图，

我们要找到f.toString()，首先在f中找，但是f中我们只定义了一个printf的属性，那么我们只能去f的隐式原型里面找有没有这个属性，
同时，Foo是f的构造函数，所以f.proto===Foo.prototype;
这里的f.proto和Foo.prototype都是对象。
Foo.prototype里面也没有这个属性；
继续从Foo的隐式原型里面查找；
同时，Foo.prototype.proto===Object.prototype;
最后注意，js中规定：Object.prototype=null;为了避免死循环。

原型链.png

image.png

如果你能看懂这张神图，也就说明你已经懂了什么是原型什么是原型链。

https://www.cnblogs.com/wangfupeng1988/p/3977924.html

上图中的“Foo.prototype”也是一个对象,它的_proto_指向哪里？
在说明“Foo.prototype”之前，先说一下自定义函数(我们自己建的构造函数）的prototype。自定义函数的prototype本质上就是和 var obj = {} 是一样的，都是被Object创建，所以它的_proto_指向的就是Object.prototype。

Function,Object,Array这些构造函数的构造函数都是Function

看f1,f2=new Foo()这条线

var Foo = {a:1}
var f1 = new Foo() //f1的构造函数是Foo
f1._proto_ === Foo.prototype
Foo.prototype 是一个对象（里面有好多属性值啥的），所以Foo.prototype的构造函数来自Objcect
然后我们又规定了Object.proyotype._proto_ = null
好好感受一下。

自定义函数Foo._proto_指向Function.prototype，Object._proto_指向Function.prototype

o1,o2=new Object()

o1._proto_ === Object.prototype;
Object 是一个构造函数，其实Object 是由Function 产生的，也就是说，Object的构造函数是Function
Object._proto_ === Function.prototype
Function.prototype是对象，所以它的构造函数是Object
Function.prototype._proto_ === Object.prototype
Function的构造函数还是Function,所以就有了
Function._proto_ === Function.prototype
请问你看懂了吗？

语法

Array.isArray(object)

判断数组.png

写一个原型链继承的例子
script代码

便于理解的例子

 function Animal(){   //构造函数首字母一般要用大写
     this.eat = function(){
         alert("eat");
     }
   }

   function Dog(){
     this.bark = function(){
        alert("bark");
     }
 }
   Dog.prototype = new Animal(); //Dog的显式原型就是Animal new出来的一个对象，所以Dog里面的显式原型也含有eat这个属性
   var hashiqi = new Dog();
   hashiqi.bark();   //页面会弹出“bark”的警告框

最后hasiqi也能调用bark()这个方法。
hashiqi.proto ===Dog.prototype

另外一个比较贴近实战的例子
关于封装DOM查询的例子

  function Elem(id){
   this.elem = document.getElementById(id);    //Elem是一个构造函数，
 //将获取到的整个element（对象）都放在this的elem属性里面，便于DOM操作
  }

 Elem.prototype.html = function(val){
 var elem = this.elem;    //将this.elem放在elem变量（在这里是一个对象）里面
 if(val){ 
   elem.innerHTML = val;   //将va;赋值给这个变量的innerHTML
   return this; //链式操作
 }else{
 return elem.innerHTML;
         }
  }
 Elem.prototype.on = function(type,fn){
 var elem = this.elem;   //相同的，将this.elem放在elem变量（在这里是一个对象）里面
 elem.addEventListener(type,fn);  //向元素添加事件的方法，http://www.runoob.com/jsref/met-element-addeventlistener.html
 }

  var div1= new Elem('div1');  //这里的div1要就是你想要取的元素的id了
  div1.html(''); //div1也继承了Elem的原型的属性。这里是可以调用的，当然这里也可以用div.html('helloworld')
  div1.on('click',function(){
     alert("我被点击了"); //点击对应Id区域，就会有警告框弹出来
  })

按照存储方式区分js变量类型

值变量类型

   var a = 10;
   var b = a;
   a = 11;
   console.log(b) //10

不同的变量的信息存放在不同的内存块中，对其中一个进行操作，另外一个不受影响

2. 引用变量类型

        var obj1 = {x:100}
        var obj2 = new obj1;
        obj1.x = 101;
        console.log(obj2.x) //101

类似于指针，引用变量类型时，obj1和obj2都指向同一个内存块，当obj1的x属性改变，obj2的x属性也在同一个地方，所以都会改变。

简述一下new一个对象的过程
前提：有一个构造函数

创建一个对象
this指向这个新对象
对this赋值

返回this

 function Person(name,age){
     this.name = name;
     this.age = age;
 }
 var p = new Person('zhangsan',19);
 console.log(p.name);   //zhangsan
 console.log(p.age);   //19

以下运行结果可以返回true的是

 function Book(){};
 var b1 = new Book();
 var b2 = new Book();
 b1.__proto__ === Object.prototype //false
 Book._proto__ === Function.prototype //true
 b1.__proto__ === b2.__proto__  //true
 b1.__proto__ === Book.prototype  //true

原型以及原型链

语法

你可能感兴趣的:(原型以及原型链)