原型以及原型链

先知知识:
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里面找

看下图，

1. 我们要找到f.toString()，首先在f中找，但是f中我们只定义了一个printf的属性，那么我们只能去f的隐式原型里面找有没有这个属性，
2. 同时，Foo是f的构造函数，所以f.proto===Foo.prototype;
   这里的f.proto和Foo.prototype都是对象。
   Foo.prototype里面也没有这个属性；
3. 继续从Foo的隐式原型里面查找；
   同时，Foo.prototype.proto===Object.prototype;

4. 最后注意，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

1. 看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

2. 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
  请问你看懂了吗？

相关面试题：

1. 如何准确判断一个变量是数组类型？
   先排除typeof；为什么？

   
   typeof.png

我们应该利用instanceof，用于判断引用类型属于哪个构造函数，通过原型链查找,其规则如下面所示：
Instanceof运算符的第一个变量是一个对象，暂时称为A；第二个变量一般是一个函数，暂时称为B
判断队则是：沿着A的proto这条线来找，同时沿着B的prototype这条线来找，如果两条线能找到同一个引用，即同一个对象，那么就返回true。如果找到终点还未重合，则返回false。

一层一层向上查找，看arr的构造函数是不是Array。

instanceof.png

但是instanceof在某些IE版本中不正确，我们也可以用下面这种方法：

语法

---

Array.isArray(object)

---

判断数组.png

2. 写一个原型链继承的例子
   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区域，就会有警告框弹出来
    })
  

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

   1. 值变量类型

         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属性也在同一个地方，所以都会改变。

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

   1. 创建一个对象

   2. this指向这个新对象

   3. 对this赋值

   4. 返回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
      

5. 以下运行结果可以返回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