Blog

Creating objects using literal notation and new Object()

In JavaScript programming, programmers can create objects using two primary methods.

Using literal notation for object creation in JavaScript programs.

Using the new Object() constructor to create a new program object.

Here both the above methods provide you permission to create a new object. But the syntax and behavior of both these methods to create a new program object are different.

So, let’s understand the new object creation process in JavaScript programming.

Creating an object using literal notation in JavaScript.

Object literal notation is a basic method of creating a new object in JavaScript programming. You define an object to be created by combining its default properties and methods inside curly braces ({}). Where each property in the new object to be created is defined as a key-value pair.

Literal notation creation syntax.

let objectName = {

  key1: value1,

  key2: value2,

  key3: value3

};

Object key is the name of the property.

Here the value property in the new object is the value related to the object being created, which can be a class string, number, array, function, data type order etc. in the new object creation.

Literal notation creation object example.

let employee = {

  emp_name: “David”,

  emp_age: 44,

  message: function() {

    console.log(“Hi, i am ” + this.emp_name);

  }

};

console.log(employee.emp_name);  // result is – david

console.log(employee.emp_age);   // result is – 44

employee.message();            // result is – Hi, i am David

• Literal notation creation object – In the above object program example, the Employee object has emp_name and emp_age in properties, and an object method message, which displays a text message. Here the this keyword references the object inside the method.

Benefits of Object Literal Notation in JavaScript.

• Concise syntax – JavaScript programmer can create a new object without the need of any constructor method.
• Improved readability – Literal notation structure in JavaScript program is clear and easy to understand. Due to which large complex program project program source code becomes more readable and understandable.
• Automatic assignment – You can assign key-value pairs directly to the program object being created, and the data types of JavaScript program values ​​like string, number, etc. can be applied.

Creating an object using the new Object() constructor in JavaScript.

The new Object() syntax in JavaScript programs uses the object constructor function to create a new empty object. Then, as per the requirement, programmers can add object properties to the newly created object using dot notation or bracket notation.

The syntax of the new Object() constructor.

let objectName = new Object();

objectName.key1 = value1;

objectName.key2 = value2;

Example of the new Object() constructor.

let course = new Object();

course.name = “Javascript”;

course.duration = “1 month”;

course.price = 999;

course.previewInfo = function() {

  console.log(`${this.price} ${this.duration} ${this.name}`);

};

console.log(course.name);          // result is – Javascript

console.log(course.price);         // result is – 999

course.previewInfo();              // result is – 999 1 month Javascript

• Explanation of the new Object() constructor – Here in this example above, the course object is created using the new Object() constructor, and then object properties and methods are added to it using dot notation.

Advantages of the new Object() constructor in JavaScript.

• Dynamic object creation – This is useful in JavaScript programs when you need to create an empty object and then populate it dynamically. For example, when the properties of the object are defined in runtime order.
• More explicit – This is a more explicit method of creating new objects in JavaScript programs, and you can use it whenever you need it when you use constructors.

Comparing the literal notation and new Object() Methods.

Which new Object method should you use in JavaScript programs?

• Use object literal notation in JavaScript programs if.
• When you are creating a simple object, and know the object properties ahead of time.
• You prefer detailed, readable program source code over new object creation.
• Use new Object() in JavaScript programs if.
• When you are dynamically creating objects in a program, and the program is adding object properties and object methods at runtime.

Object Bonus – Adding object methods and accessing properties.

In any JavaScript program, both the new object methods allow the programmer to add new methods in the same order and access object properties. Here is an example demonstrating both the new object methods.

Adding methods to object and accessing properties example.

// create Object with Literal Notation

let employee = {

  emp_name: “Mathew”,

  emp_age: 48,

  previewinfo: function() {

    console.log(“Hi my name is – ” + this.emp_name);

    console.log(“My age is – ” + this.emp_age);

  }

};

// create object with new Object() Constructor

let full_time_employee = new Object();

full_time_employee.name = “Rock”;

full_time_employee.age = 45;

full_time_employee.previewinfo = function() {

  console.log(“Hi, my name is – ” + this.name);

};

employee.previewinfo();        // result is – Hi my name is – Mathew My age is – 48

full_time_employee.previewinfo(); // result is – Hi, my name is – Rock

Here, both the new object creation methods are valid for adding object properties (name, age) and object methods (previewinfo) to the object. Whereas, literal notation is usually preferred in JavaScript programming for its simplicity.

Conclusion of new Object and new Object() in JavaScript.

• Object literal notation – New literal notation is the easiest and most basic process of creating an object in a JavaScript program. When you know the properties while constructing an object, it is detailed and ideal for the object being created.
• new Object() constructor – This is a more efficient new constructor process method that is useful when dynamically creating new objects, but is less commonly used due to the design simplicity of object literal notation.