Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.geeksforgeeks.org/abstraction-in-javascript/ below:

Abstraction in JavaScript - GeeksforGeeks

Last Updated : 05 Aug, 2025

In JavaScript, Abstraction can be defined as the concept of hiding the inner complex workings of an object and exposing only the essential features to the user.

• Hiding Complexity: Implementation is hidden, it shows only the necessary details.
• Modularity: Code is organized in a reusable form, which improves maintainability and readability.
• Security: Important data cannot be directly accessed, they are hidden.
• Reusability: The code can be reused across different applications.

In JavaScript, abstraction is often achieved through functions, classes, and modules that encapsulate behaviour and expose only the necessary parts to the outside world.

class P{
    constructor(name, age) {
        this.name = name;
        this.age = age;
    }
    getD() {
        return `${this.name} is ${this.age} years old.`;
    }
}
const p1 = new P("Anuj", 30);
console.log(p1.getD()); 

Anuj is 30 years old.

In this example

• The class P encapsulates both data (name, age) and behaviour (getD method).
• The getD() method provides a simple, reusable way to retrieve a formatted description.
• Creating an instance (p1) and calling getD() is straightforward, with the underlying logic hidden.
• You can create multiple instances of P, each maintaining its own data while reusing the same logic.

The JavaScript does not provide built-in support for implementing the abstraction like the other programming language gives. However we can implement abstraction in JavaScript using functions, objects, closures, and classes.

Functions are one of the most simple ways to introduce abstraction in JavaScript. They allow you to wrap complex logic into a reusable block of code, exposing only the function name and parameters.

function a(radius) {
    return Math.PI * radius * radius;
}
console.log(a(5)); 

Classes and objects provide a more structured way to achieve abstraction by bundling related properties and methods into a single unit.

const car = {
    brand: "Toyota",
    start: function() {
        console.log("Car started");
    }
};

car.start();

Closures help in abstraction by restricting access to certain variables, making them private.

function Count() {
    let c1 = 0;
    return {
        inc: function() {
            c1++;
            console.log(c1);
        }
    };
}

const c2 = Count();
c2.inc(); 
c2.inc(); 

ES6 classes help implement abstraction by using constructor functions and private fields (using closures or symbols).

class B{
    #balance;
    constructor(B1) {
        this.#balance = B1;
    }
    deposit(amount) {
        this.#balance += amount;
        console.log(`Deposited: $${amount}`);
    }
    getB() {
        return this.#balance;
    }
}

const a1 = new B(1000);
a1.deposit(500);
console.log(a1.getB()); 

Deposited: $500
1500

• API Development: Abstraction can be used to create the APIs where the only necessary functionality is exposed and internal logic is hidden.
• Database Operations: Database interactions are abstracted using Object-Relational Mapping (ORM) frameworks, so developers work with high-level models instead of raw SQL queries.
• Middleware in Web Servers: Web servers use middleware functions to abstract authentication, logging, and error handling.
• Security and Encryption: Sensitive operations like password hashing and encryption are abstracted into reusable functions, preventing direct manipulation of security mechanisms.

• Better Code Quality: Your code will be simpler and easier to read.
• No Repeated Code: You’ll store shared logic in one place instead of copying it everywhere.
• Easier Updates: Changing one piece of logic won’t break other parts of the application.
• Team-Friendly: Developers can work on different parts without needing to know every detail of the codebase.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4