Which way is best for creating an object in JavaScript? Is `var` necessary before an object property?

stackoverflow.com › questions › 6843951 › which-way-is-best-for-creating-an-object-in-javascript-is-var-necessary-befor

There is no best way, it depends on your use case.

Use way 1 if you want to create several similar objects. In your example, Person (you should start the name with a capital letter) is called the constructor function. This is similar to classes in other OO languages.
Use way 2 if you only need one object of a kind (like a singleton). If you want this object to inherit from another one, then you have to use a constructor function though.
Use way 3 if you want to initialize properties of the object depending on other properties of it or if you have dynamic property names.

Update: As requested examples for the third way.

Dependent properties:

The following does not work as this does not refer to book. There is no way to initialize a property with values of other properties in a object literal:

var book = {
    price: somePrice * discount,
    pages: 500,
    pricePerPage: this.price / this.pages
};

instead, you could do:

var book = {
    price: somePrice * discount,
    pages: 500
};
book.pricePerPage = book.price / book.pages;
// or book['pricePerPage'] = book.price / book.pages;

Dynamic property names:

If the property name is stored in some variable or created through some expression, then you have to use bracket notation:

var name = 'propertyName';

// the property will be `name`, not `propertyName`
var obj = {
    name: 42
}; 

// same here
obj.name = 42;

// this works, it will set `propertyName`
obj[name] = 42;

Answer from Felix Kling on Stack Overflow

Mozilla

developer.mozilla.org › en-US › docs › Web › JavaScript › Guide › Working_with_objects

Working with objects - JavaScript | MDN

August 21, 2026 - For example, this example creates an object named myCar, with properties named make, model, and year, with their values set to "Ford", "Mustang", and 1969: ... Like JavaScript variables, property names are case sensitive. Property names can only be strings or Symbols — all keys are converted to strings unless they are Symbols. Array indices are, in fact, properties with string keys that contain integers.

W3Schools

w3schools.com › js › js_object_definition.asp

JavaScript Object Definitions

An object literal is a list of property key:values inside curly braces { }. {firstName:"John", lastName:"Doe", age:50, eyeColor:"blue"}; // Create an Object const person = { firstName: "John", lastName: "Doe", age: 50, eyeColor: "blue" }; Try it Yourself »

Discussions

Which way is best for creating an object in JavaScript? Is `var` necessary before an object property? - Stack Overflow

So far I saw three ways for creating an object in JavaScript. Which way is best for creating an object and why? I also saw that in all of these examples the keyword var is not used before a proper... More on stackoverflow.com

stackoverflow.com

ecmascript 5 - Is there any reason to use Object.create() or new in JavaScript? - Stack Overflow

I've been using the new keyword in JavaScript so far. I have been reading about Object.create and I wonder if I should use it instead. What I don't quite get is that I often need to run constructio... More on stackoverflow.com

stackoverflow.com

Understanding Object.create() in JavaScript

In this case, Student is a function when you updated NinthGrader's prototype (although all functions are also objects in JS), and does not have a gender (the gender prop exists on the student instance carl and not the function that created carl). More on reddit.com

r/learnprogramming

2

1

January 10, 2022

Which way is the best way to create objects in Javascript?

EDIT: This post has been published--refined and expanded--as a SitePoint article. https://www.sitepoint.com/javascript-object-creation-patterns-best-practises/ So, here's how things evolved. Simple objects. Obviously the simplest way to make an object in JavaScript is an object literal. var o = { x: 42, y: 3.14, f: function() {}, g: function() {} }; But there's a drawback. If you need to use the same type of object in other places, then you'll end up copy-pasting the object's structure and initialization. The fix... 2) Factory functions. Objects are created, initialized, and returned from functions. function thing() { return { x: 42, y: 3.14, f: function() {}, g: function() {} }; } var o = thing(); But there's a drawback. We're creating fresh copies of functions "f" and "g" with each object. It would be better if all "thing" objects could share just one copy of each function. (Note: JavaScript engines are heavily optimized, so this issue is less important today than it used to be.) The fix... 3) Delegating to prototypes. JavaScript makes it easy to delegate property accesses to other objects through what we call the prototype chain. var thingPrototype = { f: function() {}, g: function() {} }; function thing() { var o = Object.create(thingPrototype); o.x = 42; o.y = 3.14; return o; } var o = thing(); This is such a common pattern that the language has some built-in support. A prototype object is created automatically for each function. thing.prototype.f = function() {}; thing.prototype.g = function() {}; function thing() { var o = Object.create(thing.prototype); o.x = 42; o.y = 3.14; return o; } var o = thing(); But there's a drawback. This is going to result in some repetition. In the "thing" function, the first and last lines are going to be repeated almost verbatim in every such delegating-to-prototype-factory-function. The fix... 4) Consolidate the repetition. function create(func) { var o = Object.create(func.prototype); func.call(o); return o; } Thing.prototype.f = function() {}; Thing.prototype.g = function() {}; function Thing() { this.x = 42; this.y = 3.14; } var o = create(Thing); The repetitive lines from "thing" have been moved into "create" and made generic to operate on any such function. This too is such a common pattern that the language has some built-in support. The "create" function we defined is actually a rudimentary version of the "new" keyword. Thing.prototype.f = function() {}; Thing.prototype.g = function() {}; function Thing() { this.x = 42; this.y = 3.14; } var o = new Thing; We've now arrived at ES5 classes. They are object creation functions that delegate shared properties to a prototype object and rely on the new keyword to handle repetitive logic. But there's a drawback. It's verbose and ugly. And implementing the notion of inheritance is even more verbose and ugly. The fix... 5) ES6 classes. They offer a significantly cleaner syntax for doing the same thing. class Thing { constructor() { this.x = 42; this.y = 3.14; } f() {} g() {} } var o = new Thing; More on reddit.com

r/javascript

78

249

March 27, 2016

Videos