变量的作用域

全局变量：函数外部定义的变量，函数内部和外部都可以访问，它的值可以共享
局部变量：函数内部定义的变量，函数内部可以访问，外部无法访问。函数内部访问变量时，先在内部查找是否有此变量，如果有，就使用内部变量，如果没有，就去外部查找
函数内部如果不用'var'关键字定义变量，变量可能会变成全局变量，如果用严格模式解析会报错

var a = 12;  #全局变量
function aa(){
    var b = 7;  #局部变量
}

封闭函数

封闭函数定义：(function(){……})()

;;(function(){
            var str = 'xxx';
            alert(str);
        })();//最后的()表示马上执行 或调用

封闭函数其他的写法：在匿名函数前加“！”或者“~”，之后加“()”

函数用变量方式定义：先定义再使用

var myAlert = function(){
            alert('hello!');
        }

闭包函数

闭包的本质就是函数嵌套，就是在函数里面定义函数，
内部函数可以引用外部函数的参数和变量
参数和变量不会被垃圾回收机制给回收
闭包的用途：可以存循环的索引值、做私有变量计数器

/闭包的封闭函数写法
        var cc = (function(b){
            var a = 12;
            function bb(){
                alert(a);
                alert(b);
            }
            return bb;
        })(24);
        cc();

单体创建函数

var Tom = {
            // 创建属性
            name:'tom',
            age:18,

            // 创建方法
            showName:function(){
                alert(this.name);
            },
            showAge:function(){
                alert(this.age);
            }
        }

        //调用属性
        alert(Tom.name);
        alert(Tom.age);
        
        //调用方法
        Tom.showName();

工厂模式创建对象

创建一个有参函数 在函数里面创建一个空的对象，使用单体创建函数和关键字 this 建造一个类对象！

function Person(name,age,job){
            //创建一个空对象
            // var o = new Object();//方式一
            var o = {};//方式二

            o.name = name;
            o.age = age;
            o.job = job;

            o.showName = function(){
                alert(this.name);
            }
            o.showAge = function(){
                alert(this.age);
            }
            o.showJob = function(){
                alert(this.job);
            }

            return o;
        }

        var Tom = Person('tom',18,'汤姆猫');  #创建对象
        Tom.showJob();

        var Jack = Person('jack',19,'杰克鼠');
        Jack.showJob();  

函数构造

new的作用就相当于工厂模式中最开始创建了一个空对象，最后把对象返回

        var Bob = new Person('bob',18,'产品汪');
        Bob.showJob();

        alert(Bob.showName == Alex.showName);//false

原型函数

先去自己的对象中找showName函数，再去构造函数的原型找
重写自身对象中的方法，不会影响其它对象

Person.prototype.showAge = function(){
                alert(this.age);
            }  #关键字prototype

函数的继承

属性用call或者apply的方式来继承

Fclass.call(this, name, age); # 继承的父类属性
this.job = job; #自己的属性

方法继承：将父类的一个实例赋值给子类的原型属性

    Sclass.prototype.showJob = function(){
            alert(this.job);
        }