Beget function in JavaScript: The Good Parts

I am reading JavaScript: The Good Parts. In the book, a beget function is defined. Its purpose is to create and return a new object, which uses the other object as its prototype. Why does the beget function instantiate a new function instead of an object?

if( typeof Object.beget !== 'function' ){
    Object.beget = function(o){
          var F =new Function(){}; // this line, why it cannot be var F = new Object();
          F.prototype = o;
   开发者_StackOverflow中文版       return new F();
    }
}

This has everything to do with the new keyword. In JavaScript, new only works with functions (which are a special type of object).

• If you use new on just about any function, you will get an object back.

  alert(typeof console.log); // function
  var dumb = new console.log();  // dumb is an object
  

• The type of object you get back depends on that function's prototype object.

  alert(typeof console.log.prototype); // object, any new objects created by the new keyword will be of this type.
  alert(typeof Function.prototype); // function, new objects are functions.
  alert(typeof new Function()); // function, see?
  alert(typeof (function(){})); // function, using literal syntax, equivalent
  

• You may have noticed from above that Function itself is a function. In fact, all of the built-in constructors are functions (Function, Object, Number, Array, etc). Capitalization is just a convention to distinguish how you use a function.

So to get back to your question, the author uses an empty Function object simply because it can be used as a constructor. Objects cannot. He then changes the constructor's prototype, so that it will return objects of that type.

Object.beget = function(o) {
    var F = new Function(); // now F can be used as a constructor. 
    F.prototype = o; // All new objects F creates will be based on o.
    return new F();
};

To add on to previous answers and avoid some confusion, this beget() function was replaced with create() via an errata, so different books seem to have different version of the code. The book on Safari Books Online has it printed like this:

if (typeof Object.create !== 'function') {
    Object.create = function (o) {
        var F = function () {};
        F.prototype = o;
        return new F();
    };
}

Note that it no longer encourages the use of the new keyword on line 3.

In my opinion,as the MDN said

The new operator creates an instance of a user-defined object type or of one of the built-in object types that has a constructor function.

Syntax

new constructor[([arguments])]

Parameters

constructor

A function that specifies the type of the object instance.

arguments

A list of values that the constructor will be called with.

So,wo have to use a function to create a new instance.

For example:

var list = new Array();
typeof Array;//"function"

This Array is not a object,but a constructor function.

For one thing, you can't use () on a generic object nor on anything else that isn't a function. You'll get an error something like "TypeError: F is not a function."

      // create a temporary function
      var F =new Function(){};
      // set the prototype of the function to be o
      F.prototype = o;
      // create a new object from the function
      return new F();

Because that's how new works. new creates a new object and places F.prototype in the prototype chain.

new F() === Object.create(F.prototype)

My books is

if (typeof Object.beget !== 'function') {
    Object.beget = function (o) {
        var F = function () {};
        F.prototype = o;
        return new F();
    };
}

your answer is in the book only. The beget method created a new object and that object is used as its prototype.

Below line is used to check if beget method is already used or not !

if( typeof Object.beget !== 'function' )

And then.. A constructor, F, is defined, its prototype is set to the passed in object and then a new instance is returned.