回调递归案例

回调案例

红绿灯

 var id;
  function setLight() {
    arguments[0](arguments[1], arguments[2]);
  }
  function redLight(fn, fn2) {   //两个参数就是下次和下下次要执行的函数。
    clearTimeout(id);
    console.log("红");
    id = setTimeout(fn, 2000, fn2, arguments.callee); //yellowLight(greenLight,redLigth);  
  }/*
        //fn 为将要延迟执行的函数，fn2为在下个延迟函数中下次执行的函数。 
        arguments.callee 表示在下个延迟函数中的下下个要执行的函数
        fn2与arguments.callee 带入到下个函数中后就变成了参数fn与fn2
   */

  function yellowLight(fn, fn2) {  //yellowLight(greenLight,redLigth);
    clearTimeout(id);
    console.log("黄");
    id = setTimeout(fn, 2000, fn2, arguments.callee); //greenLight(red,yellow)
  }
  function greenLight(fn,fn2) {
    clearTimeout(id);
    console.log("绿");
    id = setTimeout(fn, 2000, fn2, arguments.callee); //
  }
  setLight(redLight, yellowLight, greenLight);

累加

function fn1(fn, i, sum) {
    if (i === undefined) (i = 1), (sum = 1);
    i++;
    if (i > 100) {
      return sum;
    }
    return fn(arguments.callee, i, sum);
  }

  function fn2(fn, i, sum) {
    sum += i;
    return fn(arguments.callee, i, sum);
  }
  /* function fn3(fn, i, sum) {
    sum *= i;
    return fn(arguments.callee, i, sum);
  } */

  var sum = fn1(fn2);
  console.log(sum);

递归

深复制对象

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;
}

DOM树

function getDOMObj(parent,obj){
        obj=obj || {};
        parent=parent || document.body;
        if(parent.id) obj[parent.id]=parent;
        for(var i=0;i<parent.children.length;i++){
            getDOMObj(parent.children[i],obj);
        }
        return obj;
    }

 
   var obj=getDOMObj();
    console.log(obj);