24 JavaScript Object Methods That You Should Know

Hey! JavaScript Developers, In this post we will discuss javascript object methods that you must know to work with object-oriented programming in JavaScript. Objects are vital parts of every programming language once you know how to work with them you can build projects that solve real-life problems.

In this post, we will discuss basic concepts of JS Object like how to create an object in javascript, add & access properties of an object, how to freeze and seal object, etc.

Also Read: JavaScript Array Methods That You Should Know

Apart from these basic concepts, we will walk through advanced concepts like Prototypal Inheritance, Class Inheritance, Encapsulation, Polymorphism, Factory Pattern, singleton pattern, etc

So let’s dive into JavaScript Object!

24 JavaScript Object Methods That You Should Know

Creating An Objects:	1) Object Literal 2) using New Object() 3) Using Constructor Function 4) Using Object.create() 5) Using ES6 Classes
Accessing The Properties of Object:	1) Accessing Properties using Dot Notation 2) Accessing Properties using Bracket Notation
JavaScript Object Methods:	1) Object. assign() 2) Object.defineProperty() 3) Object.defineProperties() 4) Object.freeze() 5) Object.seal() 6) object.is() 7) Object.create()
JavaScript Object Methods For Getting Properties & Keys:	1) Object.keys() 2) Object.values() 3) Object.entries() 4) Object.getIwnPropertyNames() 5) Object.getOwnPropertyDescriptor() 6) Object.hasOwn()
Js Prototypes & Inheritance:	1) Object.getPrototypeOf() 2) Object.setPrototypeof()
Javascript Object Methods (other useful):	1) Object.isExtensible() 2) Object.preventExtensions()

Also Read: How To Make CRUD API’s With MongoDB With Express

3 Ways Of Creating An Object In JavaScript:

• Object Literal: We can create an object in javascript by using an object name & curly braces & inside it, we can assign methods & properties as shown in the following code:

let person = {
name: "Hemant",
age: "22"
}

• Using New Object() : The second way to create an object literals in JavaScript is by using a new Object() & assigning properties with dot notation as shown in the following code:

let person = new Object();
person.name = "John";
person.age = 30;

• Using Classes ES6: The third & best way to create an object in JavaScript is with the class keyword introduced in ES6 as shown in the following code:

class Person {
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }
}
let person = new Person("John", 30);

Accessing The Properties Of Object

• Dot Notation: We can access the properties of a created object using the dot notation as shown in the following code box ( accessing the name of the object that we have created above ):

person.name = "John";
console.log(person.name); // "John"

• Bracket Notation: The alternate way to access the properties of an object is by using Bracket Notation as shown in the following code box:

person["name"] = "John";
console.log(person["name"]); // "John"

JavaScript Methods To Manipulate Object

• Object. assign(): With the Help Of .assign Method we can assign values from one or more source objects to a target object as shown in the following code:

let target = { a: 1 };
let source = { b: 2, c: 3 };
Object.assign(target, source);
console.log(target); // { a: 1, b: 2, c: 3 }

• Object.freeze(): With the help of .freeze() method we can make the object immutable means we cannot add new properties to that object as shown in the following code:

let obj = { prop: 1 };
Object.freeze(obj);
obj.prop = 2; // No effect
console.log(obj.prop); // 1

• Object.seal(): This method seals an object which then prevents new properties from being added & existing properties from being removed as shown in the following code:

let obj = { prop: 1 };
Object.seal(obj);
obj.newProp = 2; // No effect
console.log(obj.newProp); // undefined

• object.is(): The Object.is() method in JavaScript helps to determine whether two values are the same in a more precise manner as compared to the traditional === operator. This method accepts two parameters value1 & value2 to compare

console.log(Object.is(42, 42)); // true
console.log(Object.is(0, 0)); // true
console.log(Object.is(0, -0)); // false

• Object.create(): This method creates a new object with the specified object and properties as shown in the following code:

let newObject = Object.create(person);
console.log(newObject.name); // "John"

Js Objects For Getting Object Properties & keys

• Object.keys(): Object .keys() returns an array of a given object as shown in the following code:

console.log(Object.keys(person)); // ["name", "age"]

• Object.values(): Object.values() returns an array of values as shown in the following code:

console.log(Object.values(person)); // ["John", 30]

• Object.entries(): Returns a separate array of keys & values as shown in the following code:

console.log(Object.entries(person)); // [["name", "John"], ["age", 30]]

• Object.getOwnPropertyNames(): Returns an array of all properties found directly in a given object as shown in the following code:

console.log(Object.getOwnPropertyNames(person)); // ["name", "age"]

• Object.hasOwn(): Tells whether the specified object has the specified property as a direct property in true or false as shown in the following code:

console.log(Object.hasOwn(person, "name")); // true

Js Other Useful Methods:

• Object.isExtensible(): This JavaScript Object method helps us to determine if an object is extensible that new properties can be added to it or not.

let obj = {};
console.log(Object.isExtensible(obj)); // true

• Object.preventExtensions() : This method prevents new properties from ever being added to an object as shown in the following code:

let obj = {};
Object.preventExtensions(obj);
obj.newProp = “test”; // No effect
console.log(obj.newProp); // undefined

Some Advanced Object Features

1. Property Attributes Like ( writable, enumerable, configurable )
2. Object Cloning
3. JSON.stringify
4. JSON.parse()

• Writable, enumerable, configurable: The javascript object also has properties like writable, enumerable & configurable as shown in the following code:

let obj = {};
Object.defineProperty(obj, 'name', {
  value: 'Alice',
  writable: false,
  enumerable: true,
  configurable: true
});
console.log(obj.name); // "Alice"
obj.name = 'Bob'; // No effect because writable is false

• Object Cloning: We can clone a particular object with the help of Object. assign method. This method accepts two arguments first blank braces & second object to clone as shown in the following code:

let original = { name: 'Alice' };
let clone = Object.assign({}, original);
console.log(clone); // { name: 'Alice' }

• JSON.stringify: Json. stringify helps us to convert JavaScript objects into a JSON String as shown in the following code:

let obj = { name: 'Alice', age: 25 };
let jsonString = JSON.stringify(obj);
console.log(jsonString); // '{"name":"Alice","age":25}'

• JSON.parse(): JSON.parse() is one of the useful methods of Javascript it helps us to parse the JSON String into a JavaScript Object as shown in the following code:

let jsonString = '{"name":"Alice","age":25}';
let obj = JSON.parse(jsonString);
console.log(obj); // { name: 'Alice', age: 25 }

Conclusion On JavaScript Object Method

Understanding all the above JavaScript Object Methods Helps You To Be a Better programmer and create software that is efficient in solving the real-world problems. Js Objects are fundamental to structuring and manipulating data. The Key Takeaways of these posts are as follows:

1. Efficiency In Data handling
2. Dynamic & Flexible Code
3. Enhanced Data Integrity
4. Improved Debugging & Maintenance.

About Author