When deciding between using a constructor or object literal, think about whether you need multiple instances of the object. Constructors allow for creating multiple instances, while object literals are essentially singletons with public variables and methods.

// create the objects:
var objLit = {
  x: 0,
  y: 0,
  z: 0,
  add: function () {
    return this.x + this.y + this.z;
  }
};

var ObjCon = function(_x, _y, _z) {
  var x = _x; // private
  var y = _y; // private
  this.z = _z; // public
  this.add = function () {
    return x + y + this.z; // note x, y doesn't need this.
  };
};

// utilize the objects:
objLit.x = 3;
objLit.y = 2;
objLit.z = 1;
console.log(objLit.add());

var objConInstance = new ObjCon(5,4,3); // create an instance of ObjCon
console.log(objConInstance.add());
console.log((new ObjCon(7,8,9)).add()); // another instance of ObjCon
console.log(objConInstance.add()); // same result, unaffected by previous line

A different approach to creating consistent objects is by utilizing a function that generates an object:

function generateObject() {
    var instance = {
        publicAttribute: "a public attribute",
        anotherPublicAttribute: function () {
            alert(instance.publicAttribute);
        }
    };

    var hidden = "this is a private variable"

    function hiddenFunction() { // private method
        hidden += "!"; // can modify private variables
        instance.publicAttribute = "foo";     
    }

    instance.publicMethod = function () {
        hidden += "?"; // this method can also manipulate private variables
    }

    instance.additionalPublicAttribute = "baz";

    return instance; // this is the constructed object
}

generateObject.static = "This is useful for adding a static attribute/method";

var foo = generateObject();
foo.publicMethod(); // works fine
alert(foo.publicAttribute); // works fine
foo.hiddenFunction(); // throws an error!
foo.hidden // throws an error!

Because functions in JavaScript serve as closures, we are able to incorporate private variables and methods without needing to use new.

Referenced from regarding private variables in JavaScript.

Displayed below are three different approaches to creating an object: Object Literal syntax, a Function Constructor, and the use of Object.create(). Object literal syntax allows for the immediate creation of an object, with its __prototype__ being the Object object, granting access to all the properties and methods of Object. This method is best suited for storing a single instance of data from a design pattern perspective.

A function constructor contains a unique property called .prototype, which serves as the __prototype__ for objects created by the constructor. Any properties or methods added to the .prototype property will be accessible to all instances created by this constructor. Use a constructor when multiple instances of data or specific object behavior are required. Additionally, the function constructor provides a way to simulate private/public development patterns by placing shared methods on the .prototype.

Object.create() creates objects using an object literal as the __prototype__ for instances. Properties and methods defined in the object literal will be inherited by all objects created through this method, enabling true prototypal inheritance. This is considered a favorable approach.

// Example Objects

// Simple Object Literal
var mySimpleObj = {
    prop1 : "value",
    prop2 : "value"
}

// Function Constructor
function PersonObjConstr()  {
    var privateProp = "this is private";
    this.firstname = "John";
    this.lastname = "Doe";
}
PersonObjConstr.prototype.greetFullName = function()    {
    return "PersonObjConstr says: Hello " + this.firstname + 
    " " + this.lastname;
};

// Object Literal
var personObjLit = {
    firstname : "John",
    lastname: "Doe",
    greetFullName : function() {
        return "personObjLit says: Hello " + this.firstname +
        ", " + this.lastname;
    }
} 

var newVar = mySimpleObj.prop1;
var newName = new PersonObjConstr();
var newName2 = Object.create(personObjLit);

When deciding between using a constructor function or an object literal to create objects in JavaScript, consider your specific needs. If you require (semi-)private variables or functions within your object, a constructor function is the appropriate choice. On the other hand, if your object only consists of properties and methods, an object literal will work just fine.

function SomeConstructor(){
    var x = 5;
    this.multiply5 = function(i){
        return x*i;
    }
}
var myObj = new SomeConstructor;

var SomeLiteral = {
    multiply5: function(i){ return i*5; }
}

The multiply5 method in both myObj and SomeLiteral performs the same task. The key distinction lies in the use of a private variable by myObj. This feature can be beneficial in certain scenarios. For the most part, however, an object literal serves as a sufficient and elegant means of creating a JavaScript object.

https://i.sstatic.net/t8oIM.png

Are you looking for a single instance of the object on the page - Consider using literals.

If you only need to transfer data with simple GET and SET methods, then DTO objects are the way to go - Utilize literals.

If your goal is to create real objects with method behaviors, multiple instances, adhere to OOP principles, and utilize inheritance - Constructor functions are the ideal choice.

Check out this YouTube video for a detailed explanation about the differences between literals and constructor functions: https://www.youtube.com/watch?v=dVoAq2D3n44

As explained on https://www.example.com/object-literals

By using an object literal, you can both define and create a single object with just one statement.

In addition

An object literal only creates a singular object. At times, it is desirable to have an object type that enables the creation of multiple objects of the same type.

Opt for object literal as it is succinct and has greater potential for growth when incorporating initial values.

Creating new objects in JavaScript using the Object() constructor function can be slower and more verbose. It is generally recommended to use literal notation instead.

Explore Udacity's Object-Oriented JavaScript course

It seems to me that private methods can indeed be included in object literals. See the example code provided below:

var myObject = {

   publicMethod: function () {
      privateMethod1();
      privateMethod2(); 
      
      function privateMethod1(){
          console.log('i am privateMethod1');
      } 
      
      function privateMethod2(){
          console.log('i am privateMethod2');
      } 
   }

}

Personal preference, but I find myself gravitating towards using object literals whenever possible.

Exploring the efficiency of property access on literals, constructors, and classes, this benchmark provides insights into the varying access times across different methods. While literal properties appear to have slightly slower access times overall compared to class and constructor properties, the most sluggish performance comes from getters and setters in object literals. Surprisingly, getters and setters in classes and constructors exhibit faster access times than other methods. For more details, you can check out the benchmark: here https://i.sstatic.net/CA8h9.png