JS里的闭包

一、封闭函数

封闭函数的定义：将函数封装起来
一般写法：(function(){-----})()最后的括号表示马上执行
！function(){----}()
~ function(){-----}()
封闭函数的另外两种写法

二、用变量来定义函数

原来的写法可以在函数本身之前调用
aa();
function aa(){-----};
用变量定义函数 若先调用会报错只能在定义之后调用
var xx = function (){-----};
xx();

三、闭包

function aa(b){
            var a = 12;
            function bb(){
                alert(a);
                alert(b);
            }
            return bb;
        }
        var cc = aa(24);
        cc();
用封闭函数写
（function(b){
    var a =3;
    function bb(){
        alert(a)
        alert(b)
        }
    return bb;
    }(23)();

四、封闭函数存循环索引值

闭包的用途一：存值

    for(var i=0;i<10;i++){
        (function(k){
            xx.[k].onclick=function(){
                alert(k);        
            }
        })(i);
    }

闭包用途二:私有变量计数器

var count = (function(){
    var a =0;
    function bb(){
        a++;
        return a;
    }
    return bb;
})();
alert(count());//变量a自增一次

五、闭包做选项卡

window.onload = function(){
    var but = document = getElementById("input")
    var con = document.getElementById("div1")
    //循环所有选项卡
    for(var i=0;i

主要还是闭包的存值得作用

六、获取地址栏参数

window.onload = function{
    var da = window.location.serch;
    var sa = window.location.hash;
    alert(da);//?aa = tom  返回键值对的样式
    alert(sa);//#12 
}

七、Math

var num = Math.random();//随机0-1的数
var a =10
var b =20
var num = Math.random()*(b-a)+a;//10-20的随机数

八、面向对象

1、单体创建对象

var Tom = {
    //属性
    name:"erha"
    age:22
    //方法
    showName:function(){
        alert(this.name)
    }
}
alert(Tom.name);//调用属性
Tom.showName();//调用方法

2、工厂模式创建对象

function Person(name,age){
    //创建一个空对象
    //方式一 var o = Object();
    // 方式二 var 0 = {};
    o.name = name;
    o.age = age;
    o.showAge = function(){
        alert(this.name)
    }
    return o;
}
var Tom = Person("tom",12);//新对象
Tom.showAge();//调用

3、构造函数

function Person(name,age){
    this.name = name;
    this.age = age;
    this.showAge = function(){
        alert(this.age);
    };
}
//new 相当于工厂模式中最开始创建了一个空对象，最后把对象返回
var Bob = new Person("bob",22)
Bob.showAge();

4、原形模式

function Person(name,age){
    this.name = name;
    this.age = age;
    Person.prototype.showName = function(){
        alert(name)
    };
}
var Tom = new Person("tom",33);
Tom.showName();//调用
Tom.showName = function(){
    alert("我的名字："  +this.name);
};//重写方法 优先调用自己重写的函数 不会影响其他对象

5、call 和 aplly
二者都可以改变当前的this，区别在于apply方法要将参数放入数组中再传参

function aa(a,b){
            alert('我的this是' + this + ',我的a是' + a + ',我的b是' + b);
        }
        //我的this是[object Window],我的a是2,我的b是3
        // aa(2,3);
        //我的this是abc,我的a是2,我的b是3
        // aa.call('abc',2,3);
        //我的this是abc,我的a是2,我的b是3
        aa.apply('abc', [2,3]);

6、继承

//父类
function Fclass (name){
    this.name = name;
    };
    Fclass.prototype.showName = function(){
        alert(this.name);
    };
    function Sclass (name,age){
        Fclass.call(this,name);
        this.age = age;
    };
    //方法继承
    Sclass.prototype = new Fclass();
    Sclasss.prototype.shoeAge = function(){
        alert(this.age);
    };
    var son = new Sclass("son",33);
    son.showName();
    son.showAge();

九、新增选择器

window.onload = function(){
            var oDiv = document.querySelector('#div1');
            alert(oDiv);//弹出[object HTMLDivElement]，表示选择了该Div
            //如果要选择多个元素用querySelectorAll
            var aLi = document.querySelectorAll('.list li');
            alert(aLi.length);//8
        }