回调和递归

回调：将一个函数以参数的形式传入到另一个函数中，并且在那个函数中执行

        function fn1(fn){
            fn();
        }
        function fn2(){
            console.log("aaaa");
        }
        fn1(fn2);            

设置回调:

1、回调一般用于当处理某件事情需要等待时，设置回调
2、当不需要关心具体后续需要处理的事情时，设置回调

setTimeout(超时执行的函数，超时时间，执行函数的参数) 返回一个id数

var id=setTimeout(fn,2000,5);//异步，一定时间后处理问题
        function fn(n){
            console.log(n);
            clearTimeout(id);//清除这个超时函数
        }

setInterval(fn，2000)，间隔2秒就会执行一次函数fn，循环执行，直到条件不满足

var id=setInterval(fn,2000);
        var num=0;
        function fn(){
            num++;
            console.log("aa");
            if(num>3) clearInterval(id);
        } 

用回调写一个路灯的循环 异步

        var id;
        function setLinght(){
            arguments[0](arguments[1],arguments[2]);
        }
        function redLinght(fn,fn2){
            clearTimeout(id);
            console.log("红灯");
            id=setTimeout(fn,2000,fn2,arguments.callee);
        }
        function yellowLinght(fn,fn2){
            clearTimeout(id);
            console.log("黄灯");
            id=setTimeout(fn,2000,fn2,arguments.callee);
        }
        function greenLinght(fn,fn2){
            clearTimeout(id);
            console.log("绿灯");
            id=setTimeout(fn,2000,fn2,arguments.callee);
        }
        setLinght(redLinght,yellowLinght,greenLinght); 

递归：函数内执行当前函数自身函数

        var i=0;
        function fn1(){
            if(i<3) fn1();//不满足条件，就继续执行fn1()
            i++; 
        }

用递归写一个对象的复制

            var obj={
            a:1,
            b:2,
            c:{
                a:1,
                b:2,
                c:{
                    a:1,
                    b:2,
                    c:{
                        a:1,
                        b:2,
                        c:3
                    }
                }
            },
            d:{
                a:{
                    a:1,
                    b:{
                        a:1
                    },
                    c:{
                        b:2
                    }
                },
                b:{
                    a:1,
                    b:{
                        c:3
                    },
                    c:{
                        d:4
                    }
                },
                c:{
                    a:1,
                    b:{
                        e:function(){
                            console.log("a");
                        }
                    },
                    c:{
                        
                    }
                }
            }
        }
        //浅复制：
        /* var obj1={};
        for(var prop in obj){
            obj1[prop]=obj[prop];
        }
        obj.a=10;//在第一层不会发生改变
        obj.c.a=10;//在第二层就会发生改变
        console.log(obj1); */

        //深复制：
        function cloneObj(obj,target){
            target=target || {};
            for(var prop in obj){
                if(typeof obj[prop]==="object" && obj[prop]!==null){
                    target[prop]={};
                    cloneObj(obj[prop],target[prop])
                }else{
                    target[prop]=obj[prop];
                }
            }
            return target;
        }
        var obj1=cloneObj(obj);
        obj.c.a=10;//在第二层不会发生改变
        obj.d.b.b.c=10;//在第第层也会发生改变
        console.log(obj1);