Difference between Object.create(prototype) and Object(prototype)

Question

A quick but hard-to-google question:

var child = Object.create(parent.prototype);

var child = Object(parent.prototype);

Are they identical?

edit:

My question was raised by this two examples of inheritPrototype functions used to implement the Parasitic Combination Inheritance Pattern.

function inheritPrototype(childObject, parentObject) {
    var copyOfParent = Object.create(parentObject.prototype);
    copyOfParent.constructor = childObject;
    childObject.prototype = copyOfParent;
}

http://javascriptissexy.com/oop-in-javascript-what-you-need-to-know/

function inheritPrototype(subType, superType){
    var prototype = object(superType.prototype); 
    prototype.constructor = subType; 
    subType.prototype = prototype;
}

"Parasitic Combination Inheritance" in Professional JavaScript for Web Developers

http://stackoverflow.com/questions/2709612/using-object-create-instead-of-new — Yellen, Apr 24 '15 at 11:55
that already answered one point, thanks! the small 'object' was a quote not a typo - a quotet typo in that case, i guess ;) — hwechselberg, Apr 24 '15 at 12:29

score 3 · Accepted Answer · edited May 23 '17 at 11:58

No they are not identical see below:

Object.create(prototype) will create a new prototype which inherits from the prototype passed as argument
Object(obj) or new Object(obj) will create a new instance of obj calling the constructor as well.

Now since prototypes are javascript objects as well, the difference can be minimal. However Object.create can handle constructors which may need arguments, while new Object() will not

Further info in this SO related answer (e.g differential inheritance, custom properties and so on)

References:

UPDATE after OP edit

In my OOP javascript framework Classy.js there is this polyfill around Object.create for older browsers which might shed light on your further question between differences:

   Create = Obj.create || function( proto, properties ) {
        var Type = function () {}, TypeObject;
        Type[PROTO] = proto;
        TypeObject = new Type( );
        TypeObject[__PROTO__] = proto;
        if ( 'object' === typeOf(properties) ) defineProperties(TypeObject, properties);
        return TypeObject;
    }

This polyfill can handle arbitrary constructors (with arguments) like Object.create can, and also make sure that the __proto__ is assigned correctly. The pattern using Object(prototype) in question is an attempt to (weakly-)reference the prototype.

@hwechselberg, it is the same as `Object(obj)` since any prototype is also an (javascript) object. `Object` will call the constructor which may have issues for constructors having arguments (or complex constructors), unlike `Object.create`. There are cother differences as well (per the referenced link)\. See also [`Object.create` on MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/create) — Nikos M., Apr 24 '15 at 13:44
@hwechselberg, updated answer with polyfill around `Object.create` of OOP lib to see differences more clearly — Nikos M., Apr 26 '15 at 10:40

Manwal · Answer 2 · 2015-04-24T12:10:01.700

No they are not same:

Object(X) or new Object(X) are same as Object.create(X.prototype)

Object(X) will create object and run Constructor( ie. the newly created object inherits from the constructor's prototype). Object.create(X.prototype) is creating object with additionally running Constructor.

Object(X) or new Object(X) are not as Object.create()

Object.create() is creating object without running Constructor( ie. it will create an object that doesn't inherit from anything)

score 1 · Answer 3 · edited May 23 '17 at 12:06

1

New Object sets the child to be the parent:

var parent = {name : 'proto'};
var child = new Object(parent);
console.log(child === parent);//=true
//if I set child.name it will change parent.name

Object create returns an object instance that uses the first argument as it's proto (first prototype used in the prototype chain).

child = Object.create(parent);
console.log(child === parent);//=false
//I can set child.name because it will be shadowed
//  and will not change parent.name
console.log(child.hasOwnProperty('name'));//=false

More on prototype can be found here: https://stackoverflow.com/a/16063711/1641941

edited May 23 '17 at 12:06

Community

1
1

answered Apr 24 '15 at 12:12

HMR

37,593
24
91
160

thanks. but in those examples it was Object.create(parent.**prototype**) and new Object(parent.**prototype**) - so is still don't completely see trough – hwechselberg Apr 24 '15 at 12:40
@hwechselberg Sorry, didn't see that. But why would you set child.prototype to parent.prototype when you do child.prototype = new Object(parent.prototype) then child.prototype === parent.prototype You don't want that in inheritance as you want the Child.prototype to be an (empty) object with it's proto set to what you want to inherit (explained in the link in my answer) You want to lengthen the prototype chain (Child.prototype => Parent.prototype => Object.prototype) not replace Child.prototype with Parent.prototype: (Child.prototype === Patent.prototype => Object.prototype) – HMR Apr 24 '15 at 16:29

Difference between Object.create(prototype) and Object(prototype)

3 Answers3