What is the 'new' keyword in JavaScript?

Question

The new keyword in JavaScript can be quite confusing when it is first encountered, as people tend to think that JavaScript is not an object-oriented programming language.

• What is it?
• What problems does it solve?
• When is it appropriate and when not?

• Chetan S: Also, related thread - stackoverflow.com/questions/383402/…
• MartianMartian: read these examples first folks, developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…

Answer 1

It does 5 things:

1. It creates a new object. The type of this object is simply object.
2. It sets this new object's internal, inaccessible, [[prototype]] (i.e. __proto__) property to be the constructor function's external, accessible, prototype object (every function object automatically has a prototype property).
3. It makes the this variable point to the newly created object.
4. It executes the constructor function, using the newly created object whenever this is mentioned.
5. It returns the newly created object, unless the constructor function returns a non-null object reference. In this case, that object reference is returned instead.

Note: constructor function refers to the function after the new keyword, as in

new ConstructorFunction(arg1, arg2)

Once this is done, if an undefined property of the new object is requested, the script will check the object's [[prototype]] object for the property instead. This is how you can get something similar to traditional class inheritance in JavaScript.

The most difficult part about this is point number 2. Every object (including functions) has this internal property called [[prototype]]. It can only be set at object creation time, either with new, with Object.create, or based on the literal (functions default to Function.prototype, numbers to Number.prototype, etc.). It can only be read with Object.getPrototypeOf(someObject). There is no other way to get or set this value.

Functions, in addition to the hidden [[prototype]] property, also have a property called prototype, and it is this that you can access, and modify, to provide inherited properties and methods for the objects you make.

---

Here is an example:

ObjMaker = function() { this.a = 'first'; };
// `ObjMaker` is just a function, there's nothing special about it
// that makes it a constructor.
ObjMaker.prototype.b = 'second';
// like all functions, ObjMaker has an accessible `prototype` property that 
// we can alter. I just added a property called 'b' to it. Like 
// all objects, ObjMaker also has an inaccessible `[[prototype]]` property
// that we can't do anything with
obj1 = new ObjMaker();
// 3 things just happened.
// A new, empty object was created called `obj1`. At first `obj1` 
// was just `{}`. The `[[prototype]]` property of `obj1` was then set to the current
// object value of the `ObjMaker.prototype` (if `ObjMaker.prototype` is later
// assigned a new object value, `obj1`'s `[[prototype]]` will not change, but you
// can alter the properties of `ObjMaker.prototype` to add to both the
// `prototype` and `[[prototype]]`). The `ObjMaker` function was executed, with
// `obj1` in place of `this`... so `obj1.a` was set to 'first'.
obj1.a;
// returns 'first'
obj1.b;
// `obj1` doesn't have a property called 'b', so JavaScript checks 
// its `[[prototype]]`. Its `[[prototype]]` is the same as `ObjMaker.prototype`
// `ObjMaker.prototype` has a property called 'b' with value 'second'
// returns 'second'

It's like class inheritance because now, any objects you make using new ObjMaker() will also appear to have inherited the 'b' property.

If you want something like a subclass, then you do this:

SubObjMaker = function () {};
SubObjMaker.prototype = new ObjMaker(); // note: this pattern is deprecated!
// Because we used 'new', the [[prototype]] property of SubObjMaker.prototype
// is now set to the object value of ObjMaker.prototype.
// The modern way to do this is with Object.create(), which was added in ECMAScript 5:
// SubObjMaker.prototype = Object.create(ObjMaker.prototype);
SubObjMaker.prototype.c = 'third'; 
obj2 = new SubObjMaker();
// [[prototype]] property of obj2 is now set to SubObjMaker.prototype
// Remember that the [[prototype]] property of SubObjMaker.prototype
// is ObjMaker.prototype. So now obj2 has a prototype chain!
// obj2 ---> SubObjMaker.prototype ---> ObjMaker.prototype
obj2.c;
// returns 'third', from SubObjMaker.prototype
obj2.b;
// returns 'second', from ObjMaker.prototype
obj2.a;
// returns 'first', from SubObjMaker.prototype, because SubObjMaker.prototype 
// was created with the ObjMaker function, which assigned a for us

---

I read a ton of rubbish on this subject before finally finding this page, where this is explained very well with nice diagrams.

• Blub: Just wanted to add: There is in fact a way to access the internal [[prototype]], by __proto__. This is however non-standard, and only supported by relatively new browsers (and not all of them). There is a standardized way coming up, namely Object.getPrototypeOf(obj), but it is Ecmascript3.1, and is itself only supported on new browers - again. It is generally recommended to not use that property though, stuff gets complicated real fast inside there.
• Jim Blackler: Question: what happens differently if ObjMaker is defined as a function that returns a value?
• Engineer: @LonelyPixel new exists so that you don't have to write factory methods to construct/copy functions/objects. It means, "Copy this, making it just like its parent 'class'; do so efficiently and correctly; and store inheritance info that is accessible only to me, JS, internally". To do so, it modifies the otherwise inaccessible internal prototype of the new object to opaquely encapsulate the inherited members, mimicking classical OO inheritance chains (which aren't runtime modifiable). You can simulate this without new, but inheritance will be runtime modifiable. Good? Bad? Up to you.
• charlie roberts: a small point to add: a call to a constructor, when preceded by the new keyword, automatically returns the created object; there is no need to explicitly return it from within the constructor.
• Tom Pažourek: There is a note that says Notice that this pattern is deprecated!. What is the correct up-to-date pattern to set the prototype of a class?

Answer 2

Suppose you have this function:

var Foo = function(){
 this.A = 1;
 this.B = 2;
};

If you call this as a stand-alone function like so:

Foo();

Executing this function will add two properties to the window object (A and B). It adds it to the window because window is the object that called the function when you execute it like that, and this in a function is the object that called the function. In JavaScript at least.

Now, call it like this with new:

var bar = new Foo();

When you add new to a function call, a new object is created (just var bar = new Object()) and the this within the function points to the new Object you just created, instead of to the object that called the function. So bar is now an object with the properties A and B. Any function can be a constructor; it just doesn't always make sense.

• MaksymB: Depends on execution context. In my case (Qt scripting) it's just a global object.
• Jürgen Paul: will this cause more memory usage?
• Dávid Horváth: because window is the object that called the function - must be: because window is the object that contains the function.
• Dávid Horváth: @Taurus In a web browser a non-method function will be a method of window implicitly. Even in a closure, even if anonymus. However, in the example it is a simple method invocation on window: Foo(); => [default context].Foo(); => window.Foo();. In this expression window is the context (not only the caller, which does not matter).
• Dávid Horváth: @Taurus Basicly yes. However in ECMA 6 and 7 things are more complex (see lambdas, classes, etc).

Answer 3

In addition to Daniel Howard's answer, here is what new does (or at least seems to do):

function New(func) {
 var res = {};
 if (func.prototype !== null) {
 res.__proto__ = func.prototype;
 }
 var ret = func.apply(res, Array.prototype.slice.call(arguments, 1));
 if ((typeof ret === "object" || typeof ret === "function") && ret !== null) {
 return ret;
 }
 return res;
}

While

var obj = New(A, 1, 2);

is equivalent to

var obj = new A(1, 2);

• damphat: I found that javascript is easier to understand than english :v
• Tom Pažourek: Excellent answer. I have one tiny question: How can it be possible for func.prototype to be null? Could you please elaborate a bit on that?
• basilikum: @tomp you could override the prototype property, by simply writing A.prototype = null; In that case new A() will result in on object, thats internal prototype points to the Object object: jsfiddle.net/Mk42Z
• Oriol: The typeof check might be wrong because a host object could produce something different than "object" or "function". To test if something is an object, I prefer Object(ret) === ret.
• basilikum: @Oriol thank you for the comment. It is true what you say and any actual test should be done in more robust way. However, I think for this conceptual answer, the typeof test just makes it easier to understand what is going on behind the scenes.

Answer 4

For beginners to understand it better

Try out the following code in the browser console.

function Foo() {
 return this;
}
var a = Foo(); // Returns the 'window' object
var b = new Foo(); // Returns an empty object of foo
a instanceof Window; // True
a instanceof Foo; // False
b instanceof Window; // False
b instanceof Foo; // True

Now you can read the community wiki answer :)

• Nelu: Good answer. Also - leaving out return this; yields the same output.
• Mikko Rantalainen: And the explanation for why return this; doesn't change the behavior is that the operator new is magical in creating the new object and executing the constructor and if the return value of the constructor is undefined (no return clause or just return;) or null (special case: return null;) then the newly created object (this inside the constructor) will be used as the value of new operator, otherwise the value of new is the returned value. I don't know the rationale for this behavior but I'd guess "due historical reasons".

Answer 5

so it's probably not for creating instances of object

It's used exactly for that. You define a function constructor like so:

function Person(name) {
 this.name = name;
}
var john = new Person('John');

However the extra benefit that ECMAScript has is you can extend with the .prototype property, so we can do something like...

Person.prototype.getName = function() { return this.name; }

All objects created from this constructor will now have a getName because of the prototype chain that they have access to.

• meder omuraliev: function constructors are used like classes, there is no class keyword but you can pretty much do the same thing.
• Greg: There kindof is a class keyword - class is reserved for future use
• Greg: Incidentally that's why you use .className not .class to set a CSS class

Answer 6

JavaScript is an object-oriented programming language and it's used exactly for creating instances. It's prototype-based, rather than class-based, but that does not mean that it is not object-oriented.

• JustAMartin: I like to say that JavaScript seems to be even more object-oriented than all those class-based languages. In JavaScript everything you write immediately becomes an object, but in class-based languages you first write declarations and only later you create specific instances (objects) of classes. And JavaScript prototype seems to vaguely remind all that VTABLE stuff for class-based languages.

Answer 7

Summary:

The new keyword is used in JavaScript to create a object from a constructor function. The new keyword has to be placed before the constructor function call and will do the following things:

1. Creates a new object
2. Sets the prototype of this object to the constructor function's prototype property
3. Binds the this keyword to the newly created object and executes the constructor function
4. Returns the newly created object

Example:

function Dog (age) {
 this.age = age;
}
const doggie = new Dog(12);
console.log(doggie);
console.log(Object.getPrototypeOf(doggie) === Dog.prototype) // true

What exactly happens:

1. const doggie says: We need memory for declaring a variable.
2. The assignment operator = says: We are going to initialize this variable with the expression after the =
3. The expression is new Dog(12). The JavaScript engine sees the new keyword, creates a new object and sets the prototype to Dog.prototype
4. The constructor function is executed with the this value set to the new object. In this step is where the age is assigned to the new created doggie object.
5. The newly created object is returned and assigned to the variable doggie.

Answer 8

Please take a look at my observation on case III below. It is about what happens when you have an explicit return statement in a function which you are newing up. Have a look at the below cases:

Case I:

var Foo = function(){
 this.A = 1;
 this.B = 2;
};
console.log(Foo()); //prints undefined
console.log(window.A); //prints 1

Above is a plain case of calling the anonymous function pointed by variable Foo. When you call this function it returns undefined. Since there isn’t any explicit return statement, the JavaScript interpreter forcefully inserts a return undefined; statement at the end of the function. So the above code sample is equivalent to:

var Foo = function(){
 this.A = 1;
 this.B = 2;
 return undefined;
};
console.log(Foo()); //prints undefined
console.log(window.A); //prints 1

When Foo function is invoked window is the default invocation object (contextual this) which gets new A and B properties.

Case II:

var Foo = function(){
 this.A = 1;
 this.B = 2;
};
var bar = new Foo();
console.log(bar()); //illegal isn't pointing to a function but an object
console.log(bar.A); //prints 1

Here the JavaScript interpreter, seeing the new keyword, creates a new object which acts as the invocation object (contextual this) of anonymous function pointed by Foo. In this case A and B become properties on the newly created object (in place of window object). Since you don't have any explicit return statement, JavaScript interpreter forcefully inserts a return statement to return the new object created due to usage of new keyword.

Case III:

var Foo = function(){
 this.A = 1;
 this.B = 2;
 return {C:20,D:30};
};
var bar = new Foo();
console.log(bar.C);//prints 20
console.log(bar.A); //prints undefined. bar is not pointing to the object which got created due to new keyword.

Here again, the JavaScript interpreter, seeing the new keyword, creates a new object which acts as the invocation object (contextual this) of anonymous function pointed by Foo. Again, A and B become properties on the newly created object. But this time you have an explicit return statement so JavaScript interpreter will not do anything of its own.

The thing to note in case III is that the object being created due to new keyword got lost from your radar. bar is actually pointing to a completely different object which is not the one which JavaScript interpreter created due to the new keyword.

Quoting David Flanagan from JavaScript: The Definitive Guide (6th Edition), Chapter 4, Page # 62:

When an object creation expression is evaluated, JavaScript first creates a new empty object, just like the one created by the object initializer {}. Next, it invokes the specified function with the specified arguments, passing the new object as the value of the this keyword. The function can then use this to initialize the properties of the newly created object. Functions written for use as constructors do not return a value, and the value of the object creation expression is the newly created and initialized object. If a constructor does return an object value, that value becomes the value of the object creation expression and the newly created object is discarded.

Additional information:

The functions used in the code snippet of the above cases have special names in the JavaScript world as below:

Case #	Name
Case I	Constructor function
Case II	Constructor function
Case III	Factory function

You can read about the difference between constructor functions and factory functions in this thread.

Code smell in case III - Factory functions should not be used with the new keyword which I've shown in the code snippet above. I've done so deliberately only to explain the concept.

• appu: your case 3, is a gr8 observation

Answer 9

JavaScript is a dynamic programming language which supports the object-oriented programming paradigm, and it is used for creating new instances of objects.

Classes are not necessary for objects. JavaScript is a prototype-based language.

Answer 10

The new keyword changes the context under which the function is being run and returns a pointer to that context.

When you don't use the new keyword, the context under which function Vehicle() runs is the same context from which you are calling the Vehicle function. The this keyword will refer to the same context. When you use new Vehicle(), a new context is created so the keyword this inside the function refers to the new context. What you get in return is the newly created context.

• appu: That's a very insightful answer in terms of scope. Gr8 addition to the answer.

Answer 11

Sometimes code is easier than words:

var func1 = function (x) { this.x = x; } // Used with 'new' only
var func2 = function (x) { var z={}; z.x = x; return z; } // Used both ways
func1.prototype.y = 11;
func2.prototype.y = 12;
A1 = new func1(1); // Has A1.x AND A1.y
A2 = func1(1); // Undefined ('this' refers to 'window')
B1 = new func2(2); // Has B1.x ONLY
B2 = func2(2); // Has B2.x ONLY

For me, as long as I do not prototype, I use the style of func2 as it gives me a bit more flexibility inside and outside the function.

• sunny_dev: B1 = new func2(2); <- Why this will not have B1.y ?
• Eagle: @sunny_dev I'm not a JS expert, but probably because func2 is returning directly a value (z object), instead of working/returning with internal values (this)

Answer 12

Every function has a prototype object that’s automatically set as the prototype of the objects created with that function.

You guys can check easily:

const a = { name: "something" };
console.log(a.prototype); // 'undefined' because it is not directly accessible
const b = function () {
 console.log("somethign");
};
console.log(b.prototype); // Returns b {}

But every function and objects has the __proto__ property which points to the prototype of that object or function. __proto__ and prototype are two different terms. I think we can make this comment: "Every object is linked to a prototype via the proto" But __proto__ does not exist in JavaScript. This property is added by browser just to help for debugging.

console.log(a.__proto__); // Returns {}
console.log(b.__proto__); // Returns [Function]

You guys can check this on the terminal easily. So what is a constructor function?

function CreateObject(name, age) {
 this.name = name;
 this.age = age
}

Five things that pay attention first:

1. When the constructor function is invoked with new, the function’s internal [[Construct]] method is called to create a new instance object and allocate memory.

2. We are not using return keyword. new will handle it.

3. The name of the function is capitalized, so when developers see your code they can understand that they have to use the new keyword.

4. We do not use the arrow function. Because the value of the this parameter is picked up at the moment that the arrow function is created which is "window". Arrow functions are lexically scoped, not dynamically. Lexically here means locally. The arrow function carries its local "this" value.

5. Unlike regular functions, arrow functions can never be called with the new keyword, because they do not have the [[Construct]] method. The prototype property also does not exist for arrow functions.

    const me = new CreateObject("yilmaz", "21")
   

   new invokes the function and then creates an empty object {} and then adds "name" key with the value of "name", and "age" key with the value of argument "age".

When we invoke a function, a new execution context is created with "this" and "arguments", and that is why "new" has access to these arguments.

By default, this inside the constructor function will point to the "window" object, but new changes it. "this" points to the empty object {} that is created and then properties are added to newly created object. If you had any variable that defined without "this" property will no be added to the object.

function CreateObject(name, age) {
 this.name = name;
 this.age = age;
 const myJob = "developer"
}

myJob property will not added to the object because there is nothing referencing to the newly created object.

 const me = {name: "yilmaz", age: 21} // There isn't any 'myJob' key

In the beginning I said every function has a "prototype" property, including constructor functions. We can add methods to the prototype of the constructor, so every object that created from that function will have access to it.

 CreateObject.prototype.myActions = function() { /* Define something */ }

Now "me" object can use the "myActions" method.

JavaScript has built-in constructor functions: Function, Boolean, Number, String, etc.

If I create

const a = new Number(5);
console.log(a); // [Number: 5]
console.log(typeof a); // object

Anything that is created by using new has the type of object. Now "a" has access all of the methods that are stored inside Number.prototype. If I defined

const b = 5;
console.log(a === b); // 'false'

a and b are 5 but a is object and b is primitive. Even though b is primitive type, when it is created, JavaScript automatically wraps it with Number(), so b has access to all of the methods that inside Number.prototype.

A constructor function is useful when you want to create multiple similar objects with the same properties and methods. That way you will not be allocating extra memory so your code will run more efficiently.

• Soner from The Ottoman Empire: abi anlatim guzel tesekkurler +1 ledim de, what is the btw Constructor function and Class in JS?
• Yilmaz: I have to write in english otherwise it would be considered as scam :) Class is like a factory. Imagine like a car factory. Each car has its own properties and methods: like color, having 4 wheels, having a motor etc. So the constructor is where you construct the car like a production unit of the factory. Whenever you create a new car, specific attributes of the car will be built in the constructor. for example, not all cars have the same color. so we pass the color when we construct or initiate the car. So each car will have color, so it will be specified in the constructor
• Yilmaz: properties in the constructor will be stored inside the car object or car instance. imagine you construct 1000 car instances, and this will take up too much space. So properties that each car will have in common are specified outside the constructor. For example every car has 4 wheels. so it is stored in the prototype. attributes are stored in prototype, are not stored inside each car object. instead it will be stored in one place and you will use it when it is needed. this is called prototypical inheritance. i hope my explanation is clear enough :)
• Peter Mortensen: What are you quoting? Daniel Howard's answer?
• Peter Mortensen: Re "window": But only in a web browser context? (E.g., not Node.js?)

Answer 13

The new keyword is for creating new object instances. And yes, JavaScript is a dynamic programming language, which supports the object-oriented programming paradigm. The convention about the object naming is: always use a capital letter for objects that are supposed to be instantiated by the new keyword.

obj = new Element();

Answer 14

JavaScript is not an object-oriented programming (OOP) language. Therefore the look up process in JavaScript works using a delegation process, also known as prototype delegation or prototypical inheritance.

If you try to get the value of a property from an object that it doesn't have, the JavaScript engine looks to the object's prototype (and its prototype, one step above at a time). It's prototype chain until the chain ends up to null which is Object.prototype == null (Standard Object Prototype).

At this point, if the property or method is not defined then undefined is returned.

Important! Functions are are first-class objects.

Functions = Function + Objects Combo

FunctionName.prototype = { shared SubObject }

{
 // other properties
 prototype: {
 // shared space which automatically gets [[prototype]] linkage
 when "new" keyword is used on creating instance of "Constructor
 Function"
 }
}

Thus with the new keyword, some of the task that were manually done, e.g.,

1. Manual object creation, e.g., newObj.
2. Hidden bond creation using proto (AKA: dunder proto) in the JavaScript specification [[prototype]] (i.e., proto)
3. referencing and assign properties to newObj
4. return of the newObj object.

All is done manually.

function CreateObj(value1, value2) {
 const newObj = {};
 newObj.property1 = value1;
 newObj.property2 = value2;
 return newObj;
}
var obj = CreateObj(10,20);
obj.__proto__ === Object.prototype; // true
Object.getPrototypeOf(obj) === Object.prototype // true

JavaScript keyword new helps to automate this process:

1. A new object literal is created identified by this:{}
2. referencing and assign properties to this
3. Hidden bond creation [[prototype]] (i.e. proto) to Function.prototype shared space.
4. implicit return of this object {}

function CreateObj(value1, value2) {
 this.property1 = value1;
 this.property2 = value2;
}
var obj = new CreateObj(10,20);
obj.__proto__ === CreateObj.prototype // true
Object.getPrototypeOf(obj) == CreateObj.prototype // true

Calling a constructor function without the new keyword:

=> this: Window

function CreateObj(value1, value2) {
 var isWindowObj = this === window;
 console.log("Is Pointing to Window Object", isWindowObj);
 this.property1 = value1;
 this.property2 = value2;
}
var obj = new CreateObj(10,20); // Is Pointing to Window Object false
var obj = CreateObj(10,20); // Is Pointing to Window Object true
window.property1; // 10
window.property2; // 20

Answer 15

The new keyword creates instances of objects using functions as a constructor. For instance:

var Foo = function() {};
Foo.prototype.bar = 'bar';
var foo = new Foo();
foo instanceof Foo; // true

Instances inherit from the prototype of the constructor function. So given the example above...

foo.bar; // 'bar'

• reko_t: The new keyword basically associates the function as the constructor already; you don't need to return anything. You can just do: function foo(x) { this.bar = x; } var obj = new foo(10); alert(obj.bar)
• Chetan S: You need not return objects from constructor function unless you specifically want to, for a purpose. For example, if you have to return a specific object instance instead of creating a new object every time (for whatever reason). In your example, however, it is totally unnecessary.
• eyelidlessness: Well, it was an example. You can return an object. There's many patterns used in this scenario, I provided one as a "for instance", hence my words "for instance".

Answer 16

Well, JavaScript per se can differ greatly from platform to platform as it is always an implementation of the original specification ECMAScript (ES).

In any case, independently of the implementation, all JavaScript implementations that follow the ECMAScript specification right, will give you an object-oriented language. According to the ES standard:

ECMAScript is an object-oriented programming language for performing computations and manipulating computational objects within a host environment.

So now that we have agreed that JavaScript is an implementation of ECMAScript and therefore it is an object-oriented language. The definition of the new operation in any object-oriented language, says that such a keyword is used to create an object instance from a class of a certain type (including anonymous types, in cases like C#).

In ECMAScript we don't use classes, as you can read from the specifications:

ECMAScript does not use classes such as those in C++, Smalltalk, or Java. Instead objects may be created in various ways including via a literal notation or via constructors which create objects and then execute code that initializes all or part of them by assigning initial values to their properties. Each constructor is a function that has a property named ― prototype ‖ that is used to implement prototype - based inheritance and shared properties. Objects are created by using constructors in new expressions; for example, new Date(2009,11) creates a new Date object. Invoking a constructor without using new has consequences that depend on the constructor. For example, Date() produces a string representation of the current date and time rather than an object.

Answer 17

It has 3 stages:

1.Create: It creates a new object, and sets this object's [[prototype]] property to be the prototype property of the constructor function.

2.Execute: It makes this point to the newly created object and executes the constructor function.

3.Return: In normal case, it will return the newly created object. However, if you explicitly return a non-null object or a function , this value is returned instead. To be mentioned, if you return a non-null value, but it is not an object(such as Symbol value, undefined, NaN), this value is ignored and the newly created object is returned.

function myNew(constructor, ...args) {
 const obj = {}
 Object.setPrototypeOf(obj, constructor.prototype)
 
 const returnedVal = constructor.apply(obj, args)
 
 if (
 typeof returnedVal === 'function' 
 || (typeof returnedVal === 'object' && returnedVal !== null)) {
 return returnedVal
 }
 return obj
}

For more info and the tests for myNew, you can read my blog: https://medium.com/@magenta2127/how-does-the-new-operator-work-f7eaac692026

Answer 18

The question has already answered many times but I just wanted to share my experience. In javascript new keyword creates an object of class. In javascript, you can create class using a function which can be called class function.

function MyClass() {
 this.name = 'kazi!'
 this.init = () => {
 console.log('I am init func')
 } 
}

Now you can call the above class function and it's function as below.

let obj = new MyClass()
obj.init()
console.log(obj.name). // prints 'Kazi!'