Ndtyjky

Very simply said, new X is Object.create(X.prototype) with additionally running the constructor function. (And giving the constructor the chance to return the actual object that should be the result of the expression instead of this.)

That’s it. :)

The rest of the answers are just confusing, because apparently nobody else reads the definition of new either. ;)

Here are the steps that happen internally for both calls:

(Hint: the only difference is in step 3)

new Test():

1. create new Object() obj


2. set obj.__proto__ to Test.prototype
   


3. return Test.call(obj) || obj;
// normally obj is returned but constructors in JS can return a value

Object.create( Test.prototype )

1. create new Object() obj


2. set obj.__proto__ to Test.prototype
   


3. return obj;

So basically Object.create doesn't execute the constructor.

Let me try to explain (more on Blog) :

1. When you write Car constructor var Car = function(){}, this is how things are internally:
   
   We have one {prototype} hidden link to Function.prototype which is not accessible and one prototype link to Car.prototype which is accessible and has an actual constructor of Car. Both Function.prototype and Car.prototype have hidden links to Object.prototype.


2. 
   

   When we want to create two equivalent objects by using the new operator and create method then we have to do it like this: Honda = new Car(); and Maruti = Object.create(Car.prototype).
   What is happening?

   
   
   

   Honda = new Car(); — When you create an object like this then hidden {prototype} property is pointed to Car.prototype. So here, the {prototype} of the Honda object will always be Car.prototype — we don't have any option to change the {prototype} property of the object. What if I want to change the prototype of our newly created object?
   Maruti = Object.create(Car.prototype) — When you create an object like this you have an extra option to choose your object's {prototype} property. If you want Car.prototype as the {prototype} then pass it as a parameter in the function. If you don't want any {prototype} for your object then you can pass null like this: Maruti = Object.create(null).

   
   

Conclusion — By using the method Object.create you have the freedom to choose your object {prototype} property. In new Car();, you don't have that freedom.

Preferred way in OO JavaScript :

Suppose we have two objects a and b.

var a = new Object();

var b = new Object();

Now, suppose a has some methods which b also wants to access. For that, we require object inheritance (a should be the prototype of b only if we want access to those methods). If we check the prototypes of a and b then we will find out that they share the prototype Object.prototype.

Object.prototype.isPrototypeOf(b); //true

a.isPrototypeOf(b); //false (the problem comes into the picture here).

Problem — we want object a as the prototype of b, but here we created object b with the prototype Object.prototype.
Solution — ECMAScript 5 introduced Object.create(), to achieve such inheritance easily. If we create object b like this:

var b = Object.create(a);

then,

a.isPrototypeOf(b);// true (problem solved, you included object a in the prototype chain of object b.)

So, if you are doing object oriented scripting then Object.create() is very useful for inheritance.

This:

var foo = new Foo();

and

var foo = Object.create(Foo.prototype);

are quite similar. One important difference is that new Foo actually runs constructor code, whereas Object.create will not execute code such as

function Foo() {

    alert("This constructor does not run with Object.create");

}

Note that if you use the two-parameter version of Object.create() then you can do much more powerful things.

The difference is the so-called "pseudoclassical vs. prototypal inheritance". The suggestion is to use only one type in your code, not mixing the two.

In pseudoclassical inheritance (with "new" operator), imagine that you first define a pseudo-class, and then create objects from that class. For example, define a pseudo-class "Person", and then create "Alice" and "Bob" from "Person".

In prototypal inheritance (using Object.create), you directly create a specific person "Alice", and then create another person "Bob" using "Alice" as a prototype. There is no "class" here; all are objects.

Internally, JavaScript uses "prototypal inheritance"; the "pseudoclassical" way is just some sugar.

See this link for a comparison of the two ways.

function Test(){

    this.prop1 = 'prop1';

    this.prop2 = 'prop2';

    this.func1 = function(){

        return this.prop1 + this.prop2;

    }

};



Test.prototype.protoProp1 = 'protoProp1';

Test.prototype.protoProp2 = 'protoProp2';

var newKeywordTest = new Test();

var objectCreateTest = Object.create(Test.prototype);



/* Object.create   */

console.log(objectCreateTest.prop1); // undefined

console.log(objectCreateTest.protoProp1); // protoProp1 

console.log(objectCreateTest.__proto__.protoProp1); // protoProp1



/* new    */

console.log(newKeywordTest.prop1); // prop1

console.log(newKeywordTest.__proto__.protoProp1); // protoProp1

Summary:

1) with new keyword there are two things to note;

a) function is used as a constructor

b) function.prototype object is passed to the __proto__ property ... or where __proto__ is not supported, it is the second place where the new object looks to find properties

2) with Object.create(obj.prototype) you are constructing an object (obj.prototype) and passing it to the intended object ..with the difference that now new object's __proto__ is also pointing to obj.prototype (please ref ans by xj9 for that)

Internally Object.create does this:

Object.create = function (o) {

    function F() {}

    F.prototype = o;

    return new F();

};

The syntax just takes away the illusion that JavaScript uses Classical Inheritance.

Accordingly to this answer and to this video new keyword does next things:

1. Creates new object.




2. Links new object to constructor function (prototype).




3. Makes this variable point to the new object.




4. Executes constructor function using the new object and implicit perform return this;




5. Assigns constructor function name to new object's property constructor.

Object.create performs only 1st and 2nd steps!!!

Object creation variants.

Variant 1 : 'new Object()' -> Object constructor without arguments.

var p1 = new Object(); // 'new Object()' create and return empty object -> {}



var p2 = new Object(); // 'new Object()' create and return empty object -> {}



console.log(p1); // empty object -> {}



console.log(p2); // empty object -> {}



// p1 and p2 are pointers to different objects

console.log(p1 === p2); // false



console.log(p1.prototype); // undefined



// empty object which is in fact Object.prototype

console.log(p1.__proto__); // {}



// empty object to which p1.__proto__ points

console.log(Object.prototype); // {}



console.log(p1.__proto__ === Object.prototype); // true



// null, which is in fact Object.prototype.__proto__

console.log(p1.__proto__.__proto__); // null



console.log(Object.prototype.__proto__); // null

Variant 2 : 'new Object(person)' -> Object constructor with argument.

const person = {

    name: 'no name',

    lastName: 'no lastName',

    age: -1

}



// 'new Object(person)' return 'person', which is pointer to the object ->

//  -> { name: 'no name', lastName: 'no lastName', age: -1 }

var p1 = new Object(person);



// 'new Object(person)' return 'person', which is pointer to the object ->

//  -> { name: 'no name', lastName: 'no lastName', age: -1 }

var p2 = new Object(person);



// person, p1 and p2 are pointers to the same object

console.log(p1 === p2); // true

console.log(p1 === person); // true

console.log(p2 === person); // true



p1.name = 'John'; // change 'name' by 'p1'

p2.lastName = 'Doe'; // change 'lastName' by 'p2'

person.age = 25; // change 'age' by 'person'



// when print 'p1', 'p2' and 'person', it's the same result,

// because the object they points is the same

console.log(p1); // { name: 'John', lastName: 'Doe', age: 25 }

console.log(p2); // { name: 'John', lastName: 'Doe', age: 25 }

console.log(person); // { name: 'John', lastName: 'Doe', age: 25 }

Variant 3.1 : 'Object.create(person)'. Use Object.create with simple object 'person'. 'Object.create(person)' will create(and return) new empty object and add property '__proto__' to the same new empty object. This property '__proto__' will point to the object 'person'.

const person = {

        name: 'no name',

        lastName: 'no lastName',

        age: -1,

        getInfo: function getName() {

           return `${this.name} ${this.lastName}, ${this.age}!`;

    }

}



var p1 = Object.create(person);



var p2 = Object.create(person);



// 'p1.__proto__' and 'p2.__proto__' points to

// the same object -> 'person'

// { name: 'no name', lastName: 'no lastName', age: -1, getInfo: [Function: getName] }

console.log(p1.__proto__);

console.log(p2.__proto__);

console.log(p1.__proto__ === p2.__proto__); // true



console.log(person.__proto__); // {}(which is the Object.prototype)



// 'person', 'p1' and 'p2' are different

console.log(p1 === person); // false

console.log(p1 === p2); // false

console.log(p2 === person); // false



// { name: 'no name', lastName: 'no lastName', age: -1, getInfo: [Function: getName] }

console.log(person);



console.log(p1); // empty object - {}



console.log(p2); // empty object - {}



// add properties to object 'p1'

// (properties with the same names like in object 'person')

p1.name = 'John';

p1.lastName = 'Doe';

p1.age = 25;



// add properties to object 'p2'

// (properties with the same names like in object 'person')

p2.name = 'Tom';

p2.lastName = 'Harrison';

p2.age = 38;



// { name: 'no name', lastName: 'no lastName', age: -1, getInfo: [Function: getName] }

console.log(person);



// { name: 'John', lastName: 'Doe', age: 25 }

console.log(p1);



// { name: 'Tom', lastName: 'Harrison', age: 38 }

console.log(p2);



// use by '__proto__'(link from 'p1' to 'person'),

// person's function 'getInfo'

console.log(p1.getInfo()); // John Doe, 25!



// use by '__proto__'(link from 'p2' to 'person'),

// person's function 'getInfo'

console.log(p2.getInfo()); // Tom Harrison, 38!

Variant 3.2 : 'Object.create(Object.prototype)'. Use Object.create with built-in object -> 'Object.prototype'. 'Object.create(Object.prototype)' will create(and return) new empty object and add property '__proto__' to the same new empty object. This property '__proto__' will point to the object 'Object.prototype'.

// 'Object.create(Object.prototype)' :

// 1. create and return empty object -> {}.

// 2. add to 'p1' property '__proto__', which is link to 'Object.prototype'

var p1 = Object.create(Object.prototype);



// 'Object.create(Object.prototype)' :

// 1. create and return empty object -> {}.

// 2. add to 'p2' property '__proto__', which is link to 'Object.prototype'

var p2 = Object.create(Object.prototype);



console.log(p1); // {}



console.log(p2); // {}



console.log(p1 === p2); // false



console.log(p1.prototype); // undefined



console.log(p2.prototype); // undefined



console.log(p1.__proto__ === Object.prototype); // true



console.log(p2.__proto__ === Object.prototype); // true

Variant 4 : 'new SomeFunction()'

// 'this' in constructor-function 'Person'

// represents a new instace,

// that will be created by 'new Person(...)'

// and returned implicitly

function Person(name, lastName, age) {



    this.name = name;

    this.lastName = lastName;

    this.age = age;



    //-----------------------------------------------------------------

    // !--- only for demonstration ---

    // if add function 'getInfo' into

    // constructor-function 'Person',

    // then all instances will have a copy of the function 'getInfo'!

    //

    // this.getInfo: function getInfo() {

    //  return this.name + " " + this.lastName + ", " + this.age + "!";

    // }

    //-----------------------------------------------------------------

}



// 'Person.prototype' is an empty object

// (before add function 'getInfo')

console.log(Person.prototype); // Person {}



// With 'getInfo' added to 'Person.prototype',

// instances by their properties '__proto__',

// will have access to the function 'getInfo'.

// With this approach, instances not need

// a copy of the function 'getInfo' for every instance.

Person.prototype.getInfo = function getInfo() {

    return this.name + " " + this.lastName + ", " + this.age + "!";

}



// after function 'getInfo' is added to 'Person.prototype'

console.log(Person.prototype); // Person { getInfo: [Function: getInfo] }



// create instance 'p1'

var p1 = new Person('John', 'Doe', 25);



// create instance 'p2'

var p2 = new Person('Tom', 'Harrison', 38);



// Person { name: 'John', lastName: 'Doe', age: 25 }

console.log(p1);



// Person { name: 'Tom', lastName: 'Harrison', age: 38 }

console.log(p2);



// 'p1.__proto__' points to 'Person.prototype'

console.log(p1.__proto__); // Person { getInfo: [Function: getInfo] }



// 'p2.__proto__' points to 'Person.prototype'

console.log(p2.__proto__); // Person { getInfo: [Function: getInfo] }



console.log(p1.__proto__ === p2.__proto__); // true



// 'p1' and 'p2' points to different objects(instaces of 'Person')

console.log(p1 === p2); // false



// 'p1' by its property '__proto__' reaches 'Person.prototype.getInfo' 

// and use 'getInfo' with 'p1'-instance's data

console.log(p1.getInfo()); // John Doe, 25!



// 'p2' by its property '__proto__' reaches 'Person.prototype.getInfo' 

// and use 'getInfo' with 'p2'-instance's data

console.log(p2.getInfo()); // Tom Harrison, 38!