Core Concepts in JavaScript

Flexibility,
Inheritance,
Encapsulation,
Functional Programming

JavaScript is a versatile programming language that supports multiple paradigms, including object-oriented programming (OOP) and functional programming (FP). Understanding the principles of flexibility, inheritance, encapsulation, and functional programming helps developers write efficient, scalable, and maintainable code.

1. Flexibility in JavaScript

What is Flexibility?

Flexibility in JavaScript refers to the ability to write dynamic, adaptable, and less rigid code. JavaScript's dynamic typing, first-class functions, prototypal inheritance, and loose syntax make it highly flexible.

Why Use Flexibility?

Dynamic Behavior – Variables can store different types of values during runtime.
Code Reusability – Functions can be assigned to variables, passed as arguments, and returned.
Adaptability – Objects can be modified on the fly by adding or removing properties/methods.
Extensibility – Easy to extend existing objects and functions.

Example – Dynamic Object Modification

let person = {
    name: "Alice",
    age: 25
};

// Adding a new property dynamically
person.job = "Developer";
console.log(person);  // { name: 'Alice', age: 25, job: 'Developer' }

Example – Dynamic Function Assignment

let greet = function(name) {
    return "Hello, " + name;
};

// Reassign the function to behave differently
greet = (name) => "Hi, " + name;

console.log(greet("Bob"));  // Hi, Bob

2. Inheritance in JavaScript

What is Inheritance?

Inheritance is the mechanism by which one object inherits properties and methods from another object. JavaScript uses prototypal inheritance, allowing objects to inherit directly from other objects.

Why Use Inheritance?

Code Reuse – Share methods and properties between objects.
Extend Functionality – Add or override properties/methods in child objects without modifying parent objects.
Hierarchy – Organize code through a structured inheritance chain.

How Inheritance Works in JavaScript

Prototype Chain – JavaScript objects have an internal link (__proto__) to another object (their prototype).
Class-Based Inheritance (ES6) – Modern JavaScript supports class syntax, but it's syntactic sugar over prototypal inheritance.

Example – Prototypal Inheritance

let animal = {
    type: "Mammal",
    sound() {
        return "Some sound";
    }
};

let dog = Object.create(animal);
dog.bark = function() {
    return "Woof!";
};

console.log(dog.type);  // Inherited: Mammal
console.log(dog.bark());  // Woof!

Example – Class-Based Inheritance

class Animal {
    constructor(name) {
        this.name = name;
    }
    sound() {
        return "Animal sound";
    }
}

class Dog extends Animal {
    sound() {
        return "Bark";
    }
}

let myDog = new Dog("Rex");
console.log(myDog.sound());  // Bark

3. Encapsulation in JavaScript

What is Encapsulation?

Encapsulation is the practice of hiding internal details of an object and exposing only necessary parts through public methods. This ensures data protection and controlled access.

Why Use Encapsulation?

Data Security – Prevent accidental modifications.
Simplified Interface – Expose only essential parts of the object.
Maintainability – Internal implementation can change without affecting other parts of the code.

How to Achieve Encapsulation?

Use closures and private variables.
Use getter/setter methods for controlled access.
Use ES6 classes with private fields (#).

Example – Private Variables Using Closures

function createCounter() {
    let count = 0;

    return {
        increment() {
            count++;
            return count;
        },
        getCount() {
            return count;
        }
    };
}

let counter = createCounter();
console.log(counter.increment());  // 1
console.log(counter.count);  // undefined (private)

Example – Private Class Fields (ES6)

class Person {
    #age = 0;  // Private field

    setAge(value) {
        if (value > 0) {
            this.#age = value;
        }
    }

    getAge() {
        return this.#age;
    }
}

let person = new Person();
person.setAge(30);
console.log(person.getAge());  // 30
console.log(person.#age);  // Error: Private field

4. Functional Programming in JavaScript

What is Functional Programming?

Functional programming (FP) is a paradigm that treats functions as first-class citizens and emphasizes pure functions, immutability, and higher-order functions.

Why Use Functional Programming?

Predictability – Pure functions always return the same output for the same input.
Immutability – State does not change, reducing bugs.
Simplified Debugging – Functions are isolated and independent.
Reusability – Modular functions can be reused across the application.

Core Concepts of Functional Programming

Pure Functions – No side effects, same output for same input.
Higher-Order Functions – Functions that accept other functions as arguments or return them are known as higher-order functions.
Immutability – Data cannot be modified directly.
Recursion – Replaces loops through function calls.

Example – Pure Function

function add(a, b) {
    return a + b;
}
console.log(add(5, 5));  // 10

Example – Higher-Order Function

function applyOperation(a, b, operation) {
    return operation(a, b);
}

let multiply = (x, y) => x * y;
console.log(applyOperation(3, 4, multiply));  // 12

Example – Immutability

const numbers = [1, 2, 3];
const newNumbers = numbers.map(num => num * 2);
console.log(newNumbers);  // [2, 4, 6]

JavaScript’s flexibility, inheritance, encapsulation, and functional programming make it a powerful language for building both simple scripts and complex web applications. These principles encourage clean, modular, maintainable, and efficient code, fostering better software design and performance.

Core Concepts in JavaScript