原型、原型链

javascript中的继承是通过原型链实现
原型链：访问一个对象的属性时，先在基本属性中查找，如果没有，再沿着__proto__这条链向上找，这就是原型链。

                fn.__proto__ === Fn.prototype   //实例的‘隐式原型’===实例的函数的‘原型’
Instanceof运算符：第一个变量是一个对象，暂时称为A；第二个变量一般是一个函数，暂时称为B。

Instanceof的判断：沿着A的__proto__这条线来找，同时沿着B的prototype这条线来找，如果两条线能找到同一个引用，即同一个对象，那么就返回true。如果找到终点还未重合，则返回false。
                   console.log(Object instanceof Function)//true
                   console.log(Function instanceof Object)//true
                   console.log(Function instanceof Function)//true

原型链图解：

 

原型链继承的属性和方法：

Function.prototype.属性和方法

Object.prototype上的属性和方法

实践一下

  此句值千金：万物皆对象 函数调用OR对象调用
      //1. 前奏
        /**
         *  function Base(){} var obj=new Base();
         *  new 一下实际上做了以下几件事
            var obj = {};
            obj.__proto__ = Base.prototype;
            Base.call(obj);
            第一行，我们创建了一个空对象obj
            第二行，我们将这个空对象的__proto__成员指向了Base函数对象prototype成员对象
            第三行，我们将Base函数中this上的成员赋值给obj 
         * **/

      //例一
        Object.prototype.a = function () {
            console.log('我是Object中的a')
        }
        Object.prototype.b = function () {
            console.log('我是Object中的b')
        }
        Function.prototype.a = function () {
            console.log('我是Function中的a')
        }
        Function.prototype.b = function () {
            console.log('我是Function中的b')
        }
        function F() {
            this.a = function () {
                console.log('我是F中的a')
            }
        }
        F.prototype.a = function () {
            console.log('我是F的prototype中的a')
        }
        var f = new F();

    //f.__proto__==F.prototype F.prototype.__proto__==Object.prototype 
        f.a();//我是f实例在基本属性中的a 我是F中的a
        f.b();//实例上没有 在原型链上找 我是Object中的b

   //F.__proto__==Function.prototype Function.prototype.__proto__==Object.prototype 
        F.a();//我是Function中的a
        F.b();//我是Function中的b 

        //Object是函数 继承自Function
   //Object.__proto__==Function.prototype Function.prototype.__proto__==Object.prototype 
        Object.a();//我是Function中的a
        Object.b();//我是Function中的b

        //Function自身是函数 继承自自己
  //Function.__proto__==Function.prototype Function.prototype.__proto__==Object.prototype 
        Function.a();//我是Function中的a
        Function.b();//我是Function中的b

        //例二
        Object.prototype.a = function () { console.log('a') }
        Function.prototype.b = function () { console.log('b') }
        function F(){}
        var f = new F();
        f.a();//a
        f.b();// f.b is not function
        F.a();// a
        F.b();// b
        var c = 1;
        console.a();// a
        console.b();//console.b is not a function
        c.a();// a
        c.b();// c.b is not a function
        console.log.a();// a
        console.log.b();// b

       /**
        * 在js中，万物皆对象，只要在Object.prototype上写的方法，万物都能访问到；
        * 而Function.prototype上的方法，只有能通过()方式调用的函数，才能访问到；
        * 因此我只需要查看这个对象可不可以通过函数()的形式调用，就能确定他是否能访问Function.prototype。
        * 再次回顾这个问题，f仅仅是个对象，f()是会报not is a function错误的，而F()是可以调用的函数，一下子得出 a 报错 a b的答案，学到了是不是感觉自己也棒棒哒~~~
        * **/
 的确 此句值千金：万物皆对象 函数调用OR对象调用