What are Object Methods in JavaScript?

Object methods in JavaScript are functions that belong to an object. They allow objects to perform actions, manipulate their properties, or interact with other objects. These methods provide functionality directly tied to the object they belong to.

Why Use Object Methods?

Encapsulation of Behavior: Object methods encapsulate logic or actions that are specific to an object.
Reuse and Maintainability: Methods can be reused across multiple objects, promoting maintainable and modular code.
Context-Aware: Methods often rely on the object’s properties and maintain a context (this) that references the current object.

How to Use Object Methods

Defining an Object Method

Inside an Object Literal:

const obj = {
    property: "value",
    methodName: function () {
        console.log("Method executed!");
    }
};
obj.methodName();  // Output: Method executed!

Using ES6 Shorthand:

const obj = {
    property: "value",
    methodName() {
        console.log("ES6 shorthand method!");
    }
};
obj.methodName();  // Output: ES6 shorthand method!

Adding Methods Dynamically:

const obj = {};
obj.sayHello = function () {
    console.log("Hello!");
};
obj.sayHello();  // Output: Hello!

Common JavaScript Object Methods

JavaScript has built-in methods provided by the Object global object and methods you can define yourself.

1. Custom Object Methods

These are user-defined functions that act as methods for specific objects.

Example: Custom Method

const person = {
    name: "Alice",
    greet() {
        return `Hello, my name is ${this.name}.`;
    }
};
console.log(person.greet());  // Output: Hello, my name is Alice.

2. Built-in Object Methods

Method	Description	Example
`Object.keys(obj)`	Returns an array of the object's own property keys.	`Object.keys({ a: 1, b: 2 })` → `['a', 'b']`
`Object.values(obj)`	Returns an array of the object's own property values.	`Object.values({ a: 1, b: 2 })` → `[1, 2]`
`Object.entries(obj)`	Returns an array of key-value pairs for the object's properties.	`Object.entries({ a: 1, b: 2 })` → `[['a', 1], ['b', 2]]`
`Object.assign(target)`	Copies properties from one or more source objects to a target object.	`Object.assign({}, { a: 1 }, { b: 2 })` → `{ a: 1, b: 2 }`
`Object.freeze(obj)`	Prevents modifications to the object (makes it immutable).	`Object.freeze({ a: 1 })`
`Object.seal(obj)`	Prevents adding/removing properties but allows modification of existing ones.	`Object.seal({ a: 1 })`
`Object.hasOwn(obj, key)`	Checks if the object has a specific property (introduced in ES2022).	`Object.hasOwn({ a: 1 }, 'a')` → `true`
`Object.is(value1, value2)`	Compares two values for equality, similar to `===` but more reliable for `NaN` and `-0`.	`Object.is(NaN, NaN)` → `true`

Examples of Using Object Methods

1. Iterating Through Object Properties

const car = { brand: "Toyota", model: "Corolla", year: 2022 };

Object.keys(car).forEach(key => {
    console.log(`${key}: ${car[key]}`);
});
// Output:
// brand: Toyota
// model: Corolla
// year: 2022

2. Copying an Object

const original = { a: 1, b: 2 };
const copy = Object.assign({}, original);
console.log(copy);  // { a: 1, b: 2 }

3. Checking Property Existence

const obj = { name: "Alice", age: 25 };
console.log(Object.hasOwn(obj, "name"));  // true
console.log(Object.hasOwn(obj, "gender"));  // false

4. Making an Object Immutable

const user = { username: "admin" };
Object.freeze(user);

user.username = "guest";  // This line will have no effect
console.log(user.username);  // Output: admin

Advanced Example: Combining Custom and Built-In Methods

const library = {
    books: {
        "The Hobbit": { author: "J.R.R. Tolkien", year: 1937 },
        "1984": { author: "George Orwell", year: 1949 }
    },

    listBooks() {
        return Object.keys(this.books).join(", ");
    },

    addBook(title, author, year) {
        this.books[title] = { author, year };
    }
};

// Using the methods
console.log(library.listBooks());  // The Hobbit, 1984
library.addBook("Dune", "Frank Herbert", 1965);
console.log(library.listBooks());  // The Hobbit, 1984, Dune

When to Use Object Methods

Data Processing: When working with objects containing structured data.
Encapsulation: Grouping related logic with the data it operates on.
Inheritance: Reusing and extending behavior in class-based or prototype-based systems.
Dynamic Object Manipulation: Managing objects dynamically in real-time applications.

Why Use Object Methods?

Encapsulation of Logic: Keeps data and behavior together for better readability and organization.
Code Reusability: Methods can be reused across multiple instances or objects.
Dynamic Programming: Allows for real-time addition, removal, and manipulation of object properties and methods.
Alignment with OOP Principles: Adheres to object-oriented programming concepts like encapsulation and modularity.

JavaScript object methods provide powerful tools for creating, managing, and interacting with objects. Whether you're using custom methods for encapsulating logic or built-in methods for tasks like iteration, comparison, or immutability, object methods are essential for efficient and organized JavaScript programming. By combining these tools, you can write cleaner, reusable, and maintainable code.

What are Object Methods in JavaScript?