函数的返回值、回调与递归

函数返回值及其的作用

function fn(){
 var a = 1;
 a +=5;
 return a；
}

返回局部变量

function fn(a,b) {
  a+=b;
  return a;
}

返回函数参数

function fn(a,b) {
  if(a>b) return;
  console.log(a+b)
}

跳出，切断，不继续执行当前函数。

函数执行时，将会返回函数中的return内容，如果函数后没有return，或者说return后没有内容时，将会返回一个undefined值。

函数中执行其他函数时，一个函数内容执行完成后才会执行当前函数。

当需要执行多个函数时，我们可以在一个大的函数中统一进行调配。

函数的回调及用法

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

function fn(fn1){
   fn1();
}
function fn1(){
  console.log('你好')
}

回调一般用于处理某件事情需要等待时，设置回调。

var id = setTimeout(fn,2000,1);//定时器
function fn(n){
    console.log(n);
    clearTimeout(id)//清除定时器
}

或者说当不需要关心具体后续需要处理的事情时，使用回调函数。

function fn(a,b,f0){
  if(isNaN(a)||isNaN(b)) return '请输入正确数字'
  return f0(a,b);
}
function f1(a,b) {
  return a+b;
}
function f2(a,b) {
  return a-b;
}
var s = fn(3,5,f1)
console.log(s)

回调函数还可以完成 一些循环，但需要局部传参返回值。

function fn1(fn,i,sum) {
   if(i===undefined) {i=1,sum=1;}
   i++;
   if(i>100) return sum;
   fn(arguments.callee,i,sum)
}
function fn2(fn,i,sum){
  return sum+=i;
  fn(argumengts.callee,i,sum)
}
var sum = f1(f2);
console.log(sum)

函数中递归的使用

函数内执行当前自身函数

var i = 0;
function fn(){
  i++;
  if(i<10) fn();
  console.log(i)
}

规矩内存大小设置递归次数，如果设置太多则会造成堆栈上限溢出。

var i = 0;
function fn(){
  i++;
  if(i<100000000) fn();
  console.log(i)
}

如果执行上面的代码就会出现下面这种情况，这就是堆栈上限溢出报错。

在递归中，最常见的就是遍历对象的操作，递归可以进行深复制。

var obj = {
   a:1,
   b:1,
   c:{
       a:1,
       b:{
          a:1
          b:1
          c:{
              a:{
                 a:1,
                 b:1,
                 c:{}
              }
          }
       }
      c:{
        a:1,
        b:{
          a:1
        }
        c:1;
      }
   }
}//随机创建一个对象
function cloneObj(obj,target){
  target = target || {};
  for (var key in obj){
      if(typeof obj[key] === 'object' && obj[key] !== null){
          target[key] = {};
          cloneObj(obj[key],target[key]);
      }
      else{
        target[key] = obj[key];
      }
  }
  return target;
}
var obj1 = cloneObj(obj);
console.log(obj1)

递归再循环中是一个普遍使用的东西，也可以让我们更加进行方便。