构造函数模式拓展

 <script>
        function Fn() {
            this.x = 100;//->f1
            this.getX = function () {
                console.log(this.x);//this需要看getX执行的时候才能知道
            }
        }
        Fn();//这么写不是构造函数
        var f1 = new Fn();
        var f1 = new Fn;//不需要传参数可以省略括号
        f1.getX();//方法中的this是f1->100
        var ss = f1.getX;
        ss();//方法中的this是window ->undefined

        //2.this的问题：在勒种出现的this.xxx中的this都是当前类的实例，而某一个
        //属性值是一个方法的话，方法中的this需要看方法执行的时候前面是否有.才能知道this是谁

          function Fn() {
                var num = 10;
                this.x = 100;
                this.getX = function () {
                    console.log(this.x);
                }
            }
            var f1 = new Fn;
            console.log(f1.num);//->undefined
            //3.类有普通函数的一面，当函数执行的收var num其实只是当前形成的私有作用域中的私有变量而已.
            //他和我们的f1这个实力没有任何的关系；只有this.xxx=xxx才相当于给f1这个实力增加私有的属性和
            //方法，才和我们的f1有关系...
             function Fn() {
                    this.x = 100;
                    this.getX = function () {
                        console.log(this.x);
                    }
                    return {name : "zhufeng"};
                }
                var f1 = new Fn;
                console.log(f1);
                f1.getX();//fi is not function
            //4.在构造函数模式中，浏览器会默认的把我们的实例返回(返回的是一个对象数据类型的值)，若我们自己手动写了return返回;
            //返回的是一个基本数据类型的值，当前实例是不变的，例如return 100;
            //反悔的是一个引用数据类型的值，当前的实例会被自己返回的值给替换掉,例如:return{name:"zhufeng"}我们的f1就不在是Fn的实例
            //了，而是对象{name:"zhufeng"};
                function Fn() {
                        this.x = 100;
                        this.getX = function () {
                            console.log(this.x);
                        }
                    }
                    var f1 = new Fn;
                    //5.检查某一个实例是否属于这个类->instanceof
                    console.log(f1 instanceof Fn);//->true
                     console.log(f1 instanceof Array);//->false
                      console.log(f1 instanceof Object);//->true
                    //因为所有的实例都是对象数据类型的，而每一个对象数据类型都是object这个内置类的一个实例，所以
                    //f1也是他的一个实例
                    //对于检测数据类型来说，typeof有自己的局限性，不能细分object下的对象，数组，正则，
                    var a = [];
                    console.log(a instanceof Array);//->true a是一个数组
                function Fn() {
                        this.x = 100;
                        this.getX = function () {
                            console.log(this.x);
                        }
                    }
                    var f1 = new Fn;
                    var f2 = new Fn;
                    //6.f1和f2都是fn这个类的一个实例，都拥有x和getX两个属性，但是这两个属性是个字私有的属性
                    //所以：
                    console.log(f1.getX===f2.getX);//->false

                    //in：检测某一个属性是否属于这个对象 attr in object不管是私有的属性还是公有的属性，只要存在，用in来检测都是true
                    //
                    console.log("getX" in f1);//->true 
                    //hsOwnProperty:用来检测某一个属性是否为这个对象的私有属性
                    //这个方法只能检测私有的属性
                    console.log(f1.hasOwnProperty("getX"));//->true "getX"是f1的私有属性

                    //思考：某一个属性是否为该对象的公有属性：hasPubProperty
                    function hasPubProperty(obj,attr) {
                        // 首先保证是他的一个属性，并且还不是私有的属性，那么就是公有的属性
                        return (attr in obj) && !obj.hasPubProperty(attr);

                    }  
                    console.log(hasPubProperty(f1,"getX"));//->false


                    //7.isPrototypeof是用来判断指定对象object1是否存在于另一个对象object2的原型链中，是则返回true，否则返回false
        </script>