var f = function () { // function body }; 

function f() { // function body } 

function f() { // function body } 
console.log(f.name); // "f" 
console.log(f); // f() 

console.log(f.name); // "f" 
console.log(f); // f() 
function f() { // function body } 

var a = 0; 
console.log(a); // 0 or a()"有良心的艺术家"那样的"有良心的程序员"，这句话很拗口吧）


函数式声明




function f() {} 



看起来是




var f = function f(){}; 



的简写。而




var a = function b(){}; 


的表达式，创建一个函数并把内置的name属性赋值为"b"，然后把这个函数赋值给变量a，你可以在外部使用a()来调用它，但却不能使用b(），因为函数已被赋值给a，所以不会再自动创建一个变量b，除非你使用var b = a声明一个变量b。当然这个函数的name是"b"而不是"a"。


使用Function构造函数也可用来创建函数：




var f = new Function("a,b,c","return a+b+c;"); 



这种方式其实是在全局作用域内生成一个匿名函数，并把它赋值给变量f。


2、递归调用


递归被用来简化许多问题，这需要在一个函数体中调用它自己：




// 一个简单的阶乘函数 
var f = function (x) { 
  if (x === 1) { 
    return 1; 
  } else { 
    return x * f(x - 1); 
  } 
}; 



Javascript中函数的巨大灵活性，导致在递归时使用函数名遇到困难，对于上面的变量式声明，f是一个变量，所以它的值很容易被替换：




var fn = f; 
f = function () {}; 


函数是个值，它被赋给fn，我们期待使用fn(5)可以计算出一个数值，但是由于函数内部依然引用的是变量f，于是它不能正常工作了。


函数式的声明看起来好些，但很可惜：




function f(x) { 
  if (x === 1) { 
    return 1; 
  } else { 
    return x * f(x - 1); 
  } 
} 
var fn = f; 
f = function () {}; // may been warning by browser 
fn(5); // NaN 


看起来，一旦我们定义了一个递归函数，便须注意不要轻易改变变量的名字。


上面谈论的都是函数式调用，函数还有其它调用方式，比如当作对象方法调用。


我们常常这样声明对象：




var obj1 = { 
  num ： 5， 
  fac ： function (x) { 
    // function body 
  } 
}; 


声明一个匿名函数并把它赋值给对象的属性（fac）。


如果我们想要在这里写一个递归，就要引用属性本身：




var obj1 = { 
  num : 5, 
  fac : function (x) { 
    if (x === 1) { 
      return 1; 
    } else { 
      return x * obj1.fac(x - 1); 
    } 
  } 
}; 



当然，它也会遭遇和函数调用方式一样的问题：




var obj2 = {fac: obj1.fac}; 
obj1 = {}; 
obj2.fac(5); // Sadness 



方法被赋值给obj2的fac属性后，内部依然要引用obj1.fac，于是…失败了。


换一种方式会有所改进：




var obj1 = { 
   num : 5, 
   fac : function (x) { 
    if (x === 1) { 
      return 1; 
    } else { 
      return x * this.fac(x - 1); 
    } 
  } 
}; 
var obj2 = {fac: obj1.fac}; 
obj1 = {}; 
obj2.fac(5); // ok 


通过this关键字获取函数执行时的context中的属性，这样执行obj2.fac时，函数内部便会引用obj2的fac属性。


可是函数还可以被任意修改context来调用，那就是万能的call和apply：




obj3 = {}; 
obj1.fac.call(obj3, 5); // dead again 


于是递归函数又不能正常工作了。


我们应该试着解决这种问题，还记得前面提到的一种函数声明的方式吗？




var a = function b(){}; 


这种声明方式叫做内联函数（inline function），虽然在函数外没有声明变量b，但是在函数内部，是可以使用b()来调用自己的，于是




var fn = function f(x) { 
  // try if you write "var f = 0；" here 
  if (x === 1) { 
    return 1; 
  } else { 
    return x * f(x - 1); 
  } 
}; 
var fn2 = fn; 
fn = null; 
fn2(5); // OK 




 // here show the difference between "var f = function f() {}" and "function f() {}" 
var f = function f(x) { 
  if (x === 1) { 
    return 1; 
  } else { 
    return x * f(x - 1); 
  } 
}; 
var fn2 = f; 
f = null; 
fn2(5); // OK 




var obj1 = { 
  num : 5, 
  fac : function f(x) { 
    if (x === 1) { 
      return 1; 
    } else { 
      return x * f(x - 1); 
    } 
  } 
}; 
var obj2 = {fac: obj1.fac}; 
obj1 = {}; 
obj2.fac(5); // ok 
 
var obj3 = {}; 
obj1.fac.call(obj3, 5); // ok 



就这样，我们有了一个可以在内部使用的名字，而不用担心递归函数被赋值给谁以及以何种方式被调用。


Javascript函数内部的arguments对象，有一个callee属性，指向的是函数本身。因此也可以使用arguments.callee在内部调用函数：




function f(x) { 
  if (x === 1) { 
    return 1; 
  } else { 
    return x * arguments.callee(x - 1); 
  } 
} 



但arguments.callee是一个已经准备被弃用的属性，很可能会在未来的ECMAscript版本中消失，在ECMAscript 5中"use strict"时，不能使用arguments.callee。


最后一个建议是：如果要声明一个递归函数，请慎用new Function这种方式，Function构造函数创建的函数在每次被调用时，都会重新编译出一个函数，递归调用会引发性能问题——你会发现你的内存很快就被耗光了。


以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。