我最近对此进行了大量研究，但尚未得到真正可靠的答案。我在某处读到，当 JavaScript 引擎遇到函数语句时会创建一个新的 Function() 对象，这让我相信它可能是一个对象的子对象(因此成为一个对象)。所以我给 Douglas Crockford 发了邮件，他的回答是:

Not exactly, because a function statement does not call the compiler.

But it produces a similar result.

此外，据我所知，您不能在函数构造函数上调用成员，除非它已被实例化为一个新对象。所以这是行不通的:

function myFunction(){
    this.myProperty = "Am I an object!";
}
myFunction.myProperty; // myFunction is not a function
myFunction().myProperty; // myFunction has no properties

但是，这会起作用:

function myFunction(){
    this.myProperty = "Am I an object!";
}
var myFunctionVar = new myFunction();
myFunctionVar.myProperty;

这只是语义问题吗……在整个编程世界中，对象何时真正成为对象，以及它如何映射到 JavaScript？

最佳答案

函数和构造函数并没有什么神奇之处。 JavaScript 中的所有对象都是……好吧，对象。但是有些对象比其他对象更特殊:即内置对象。区别主要在于以下几个方面:

1. 对象的一般处理。例子:
   • 数字和字符串是不可变的(⇒ 常量)。没有定义任何方法来在内部更改它们——结果总是产生新对象。虽然它们有一些固有方法，但您无法更改它们或添加新方法。任何这样做的尝试都将被忽略。
   • null 和 undefined 是特殊对象。任何对这些对象使用方法或定义新方法的尝试都会导致异常。
2. 适用的运营商。 JavaScript 不允许(重新)定义操作符，因此我们坚持使用可用的操作符。
   • 数字对算术运算符有特殊的处理方式:+、-、*、/。
   • 字符串有一种特殊的方式来处理连接运算符:+。
   • 函数有一种特殊的方式来处理“调用”运算符:() 和new 运算符。后者天生就知道如何使用构造函数的 prototype 属性，构造一个具有适当内部链接到原型(prototype)的对象，并在其上调用构造函数来设置 this 正确。

如果您查看 ECMAScript 标准 (PDF)，您会发现所有这些“额外”功能都被定义为方法和属性，但其中许多不能直接供程序员使用。其中一些将在标准 ES3.1 的新修订版中公开(2008 年 12 月 15 日草案:PDF)。一个属性 (__proto__) 是 already exposed in Firefox .

现在我们可以直接回答您的问题了。是的，一个函数对象是有属性的，我们可以随意添加/删除它们:

var fun = function(){/* ... */};
fun.foo = 2;
console.log(fun.foo);  // 2
fun.bar = "Ha!";
console.log(fun.bar);  // Ha!

函数实际做什么并不重要——它永远不会发挥作用，因为我们没有调用它!现在让我们定义它:

fun = function(){ this.life = 42; };

它本身不是一个构造函数，它是一个在其上下文上运行的函数。我们可以轻松提供它:

var context = {ford: "perfect"};

// now let's call our function on our context
fun.call(context);

// it didn't create new object, it modified the context:
console.log(context.ford);           // perfect
console.log(context.life);           // 42
console.log(context instanceof fun); // false

如您所见，它向已存在的对象添加了一个属性。

为了将我们的函数用作构造函数，我们必须使用 new 运算符:

var baz = new fun();

// new empty object was created, and fun() was executed on it:
console.log(baz.life);           // 42
console.log(baz instanceof fun); // true

如您所见，new 使我们的函数成为构造函数。 new 完成了以下操作:

1. 已创建新的空对象 ({})。
2. 它的内部原型(prototype)属性被设置为fun.prototype。在我们的例子中，它将是一个空对象 ({})，因为我们没有以任何方式修改它。
3. fun() 以这个新对象作为上下文被调用。

修改新对象取决于我们的函数。通常它设置对象的属性，但它可以做任何它喜欢的事情。

有趣的琐事:

• 因为构造函数只是一个对象，我们可以计算它:

  var A = function(val){ this.a = val; };
  var B = function(val){ this.b = val; };
  var C = function(flag){ return flag ? A : B; };
  
  // now let's create an object:
  var x = new (C(true))(42);
  
  // what kind of object is that?
  console.log(x instanceof C); // false
  console.log(x instanceof B); // false
  console.log(x instanceof A); // true
  // it is of A
  
  // let's inspect it
  console.log(x.a); // 42
  console.log(x.b); // undefined
  
  // now let's create another object:
  var y = new (C(false))(33);
  
  // what kind of object is that?
  console.log(y instanceof C); // false
  console.log(y instanceof B); // true
  console.log(y instanceof A); // false
  // it is of B
  
  // let's inspect it
  console.log(y.a); // undefined
  console.log(y.b); // 33
  
  // cool, heh?
  

• 构造函数可以返回一个值来覆盖新创建的对象:

  var A = function(flag){
    if(flag){
      // let's return something completely different
      return {ford: "perfect"};
    }
    // let's modify the object
    this.life = 42;
  };
  
  // now let's create two objects:
  var x = new A(false);
  var y = new A(true);
  
  // let's inspect x
  console.log(x instanceof A); // true
  console.log(x.ford);         // undefined
  console.log(x.life);         // 42
  
  // let's inspect y
  console.log(y instanceof A); // false
  console.log(y.ford);         // perfect
  console.log(y.life);         // undefined
  

  如您所见，x 是 A 的原型(prototype)和所有内容，而 y 是我们从构造函数。

关于javascript - 为什么在 JavaScript 中函数既是构造函数又是对象？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/372202/