原型链整理

/*判断类型*/
    function show(x){
        /*undefined,number,string,boolean属于简单的值类型，值类型的判断用typeof*/
        console.log(typeof x);//undefined
        console.log(typeof 10);//number
        console.log(typeof 'abc');//string
        console.log(typeof true);//boolean
        /*函数，数组，对象，null,new Number(10)都是对象，都是引用类型，引用类型的判断用instanceof*/
        /*一切引用类型都是对象*/
        console.log(typeof function(){});//function
        console.log(typeof [1,'a',true]);//object
        console.log(typeof {a:10,b:20});//object
        console.log(typeof null);//object
        console.log(typeof new Number(10));//object

        console.log(function(){} instanceof Object);//true
        console.log( [1,'a',true] instanceof Object);//true
        console.log({a:10,b:20} instanceof Object);//true
        console.log(null instanceof Object);//false
        console.log(new Number(10) instanceof Object);//true
    }

/*对象都是通过函数创建的*/
    var  obj={a:10,b:2};
    var obj=new Object();/*代码的本质*/
        obj.a=10;
        obj.b=20;
    /*每个函数都有一个属性叫prototype，这个prototype的属性值是一个对象（属性的集合）
    * 默认的只有一个叫做constructor的属性指向这个函数本身*/
        function  name(){
            console.log(555)
        }
        name.prototype.liuhao=function(){
            console.log(555555)
        }
        console.log(name.prototype)/
        console.log(name.prototype.constructor)
    /*Fn是一个函数，fn对象是从Fn函数new出来的，这样fn对象就可以调用Fn.prototype中的属性*/
    function Fn(){}
    Fn.prototype.name="liuhao";
    Fn.prototype.getYear=function(){
        return 1998;
    }
    var fn=new Fn();
    console.log(fn.name)
    console.log(fn.__proto__===Fn.prototype)//__proto__：隐式原型
    /*每个函数function都有一个prototype,即原型。每个对象都有一个__proto__,隐式原型*/
    /*每个对象都有一个__proto__属性，指向创建该对象的函数的prototype*/
    /*Object.prototype确是一个特例--它的__proto__指向的是null*/
    /*函数是谁创建出来的--是Function*/
    function fn2(x,y){
        return x+y;
    }
    console.log(fn2(1,2));
    var fn1=new Function("x",'y',"return x+y");

/*instanceof  A instanceof B
* instanceof 的判断规则是：沿着A的__proto__这条线来找，同时沿着B的prototype
* 这条线来找，如果这两条线能找到同一个引用，即同一个对象，那么就返回true
* 如果找到终点还未重合，则返回false
* instanceof 表示的就是一种继承关系，或者原型链的结构
* 访问一个对象的属性时，先在基本属性中查找，如果没有，再沿着__proto__这条链
* 向上找，这就是原型链
* */