js es5

严格模式

<script>
'use strict'
//1.变量名必须先申明在使用
//num=10;console.log(num)
//2.不能随意删除已经声明好的变量 delete num
//3.严格模式下的全局作用域函数的this是指向undefined
function fn(){
	console.log(this)//undefined
}
fn();
//4.严格模式下，如果构造函数不加new，this会报错
function Star(){
this.sex='nan'
}
Star();console.log(window.sex);//报错 undefined.sex是错误的
//平时的创建实列是不会报错的
var ldh=new Star();
//6.定时器this依然指向的还是window
//7.事件和对象还是指向的调用者
//8.函数不能有同名参数
a=1;a=2;
function fn1(){
console.log(a+a)
}
fn1(1,2)
//9.函数不能在非函数代码块中出现
if(true){
function fn2(){

}
</script>

高阶函数

//函数可以作为参数传递
function fn(a,b,callback){
	console.log(a+b);
	callback&&callback();
	}
	

闭包

	<ul class="nav">
        <li>西红柿</li>
        <li>土豆</li>
        <li>空心菜</li>
        <li>白菜</li>
    </ul>
    <script>
        //闭包(closure)指有权访问另一个函数作用域中变量的函数
        //闭包：fun这个函数作用域访问了另外一个函数fn 里面的局部变量 num
        /* function fn(){
            var num=10;
            function fun(){
                console.log(num);
            }
            fun();
        }
        fn(); */
       /*  function fn(){
            var num=10;
            function fun(){
                console.log(num); 
            }
            return fun;
        }
        var a=fn();
        a(); */
        /* function fn(){
            var num=10;
            return function(){
                console.log(num); 
            }
        }
        var a=fn();
        a(); */
        //传统方式
        var lis=document.querySelector('.nav').querySelectorAll('li');
        for(var i=0;i<lis.length;i++){
            lis[i].index=i;
            lis[i].onclick=function(){
                console.log(this.index);
                
            }
        }
        //闭包方式
        var lis1=document.querySelector('.nav').querySelectorAll('li');
        for(var i=0;i<lis1.length;i++){
            (function(i){
                lis1[i].onclick=function(){
                    console.log(i);
                }
            })(i)
        }
        //闭包2
       var lis=document.querySelector('.nav').querySelectorAll('li');
       for(var i=0;i<lis.length;i++){
            (function(i){
                setTimeout(function(){
                    console.log(lis[i].innerHTML);
                    
                },3000)
            })(i);
        } 
	//没有形成闭包this指向的是window
        var name='the window';
        var object={
            name:'my object',
            getNameFunc:function(){
                return function(){
                        return this.name;
                }
            }
        }
        console.log(object.getNameFunc()());
        //形成了闭包
        var name='the window';
        var object={
            name:'my object',
            getNameFunc:function(){
                var that=this;
                return function(){
                        return that.name;
                }
            }
        }
        console.log(object.getNameFunc()());
    </script>
    

递归

//递归函数自己调用自己  如果不用return中断会栈溢出死循环
    /* var num=1;
    function fn(){
        console.log('第'+num+'个');
        if(num==6){
            return;
        }
        num++;
        fn();
    }
    fn(); */
    // 斐波那契数列 1 1 2 3 5 8
    function fb(n){
        if(n===1||n===2){
            return 1;
        }
        return fb(n-1)+fb(n-2);
    }
    console.log(fb(5));
    //fb(4)+fb(3) fb(4)=fb(3)+fb(2) fb(3)=fb(2)+fb(1) fb(2)=1 
    //递归的累加
    function add(n){
        if(n===1){
            return 1;
        }
        return add(n)+add(n-1);
    }
    console.log(add(5));