Blog

1. Object-Oriented JavaScript (OOJS) Kya Hoti Hai?

Object-Oriented JavaScript ek programming style hai jisme code ko objects ke form mein organize kiya jata hai. JavaScript mein object ek aise entity hoti hai jo properties (variables) aur methods (functions) ko hold karti hai. OOJS ka main goal hota hai code ko reusable, maintainable aur modular banana.

JavaScript mein objects create karne ke liye hum constructor functions, prototypes ya ES6 classes ka use karte hain. Inheritance, encapsulation aur abstraction jaise concepts OOJS mein follow kiye jaate hain. Jaise hi kisi object se related logic ko alag rakha jata hai, code samajhna aur manage karna asaan ho jata hai.

OOJS real-world cheezon jaise sochne mein help karta hai, jisse development process aur efficient ho jaati hai.

Features of OOJS:

• Encapsulation – data aur behavior ko ek unit mein bundle karna
• Abstraction – complexity ko chhupana
• Inheritance – property/methods ka reuse
• Polymorphism – same method ka alag behavior

JavaScript mein objects banane ke kai tarike hain — sabse pehle samjhte hain Object Literals.

2. Object Literals:

JavaScript mein object literals ek simple aur convenient tareeka hai objects create karne ka. Yeh ek comma-separated list hoti hai key-value pairs ki, jo curly braces {} ke andar likhi jaati hai. Har key ek property name hoti hai aur uske aage likha value us property ka data hota hai.

let person = {
  name: "Sandeep",
  age: 24,
  greet: function () {
    console.log("Hello, " + this.name);
  }
};

Explanation in Hinglish:

• person ek object hai.
• name aur age uske properties hain.
• greet() ek method hai jo object ke andar define ki gayi hai.
• this keyword object ke current reference ko point karta hai.

Use kab karein?
Jab aapko sirf ek ya chhoti quantity mein objects banane ho. Lekin agar aapko ek hi structure ke kai objects banane ho, to object literals se kaam mushkil ho jata hai — tab use hote hain Constructor Functions.

3. Constructor Functions:

JavaScript mein constructor functions ek special type ke function hote hain jo objects banane ke liye use kiye jaate hain. Jab hum kisi function ko new keyword ke saath call karte hain, to wo function ek naya object create karta hai aur this keyword us naye object ko refer karta hai. Constructor function ka naam usually capital letter se start hota hai (jaise Person, Car, etc.) taaki pata chale ki ye ek constructor hai. Iske andar hum properties aur methods define kar sakte hain jo har naye object mein honge.

function Person(name, age) {
  this.name = name;
  this.age = age;
  this.greet = function () {
    console.log("Hi, my name is " + this.name);
  };
}

let p1 = new Person("Amit", 30);
let p2 = new Person("Priya", 28);

Explanation:

• Person() function ek constructor hai.
• this keyword har naye object ke context mein hota hai.
• p1 aur p2 do alag-alag object instances hain.

Problem kya thi? Har instance ke sath method copy ho rahi hai (memory zyada use ho rahi hai). Iska solution hai prototype ya ES6 Classes.

4. ES6 Classes & Inheritance:

ES6 classes JavaScript mein ek naya syntax hai jo object-oriented programming ko easy aur readable banata hai. Class ek blueprint hoti hai jisme properties aur methods define ki jaati hain. Isse naye objects create kiye ja sakte hain using the new keyword. Inheritance ka matlab hota hai ek class (child class) dusri class (parent class) ke features ko inherit kare. Ye reuse aur code organization ke liye kaafi useful hota hai. extends keyword se inheritance hota hai, aur super() function parent class ke constructor ko call karne ke liye use kiya jata hai. ES6 classes actually under the hood function-based hi hoti hain, but inka syntax modern aur cleaner hai. Ye feature large scale applications ke liye bahut beneficial hai.

class Person {
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }

  greet() {
    console.log(`Hello, I am ${this.name}`);
  }
}

let p = new Person("Neha", 22);

Explanation:

• class Person ek blueprint hai.
• constructor() ek special method hai jo object create karte waqt call hoti hai.
• greet() method directly prototype mein store hoti hai – memory efficient.

Inheritance:

Inheritance JavaScript mein ek concept hai jisme ek object ya class doosre object ya class ke properties aur methods ko access kar sakta hai. Isse code reuse hota hai, aur naye features bina purana code likhe add kiye ja sakte hain. JavaScript mein inheritance mainly prototype-based hota hai, jisme ek object dusre object ke prototype se linked hota hai. ES6 ke baad, class-based syntax bhi introduce hua jisme class aur extends keywords ka use karke inheritance implement karte hain. Child class parent class ke saare features ko inherit kar leti hai, aur agar zarurat ho to methods ko override bhi kar sakti hai. Inheritance se maintainable aur organized code likhna easy ho jata hai, especially in large applications.

class Student extends Person {
  constructor(name, age, grade) {
    super(name, age); // parent class ka constructor call
    this.grade = grade;
  }

  study() {
    console.log(`${this.name} is studying in grade ${this.grade}`);
  }
}

let s1 = new Student("Rahul", 15, 10);
s1.greet(); // Inherited from Person
s1.study(); // Own method

Explanation:

• Student class ne Person ko extend kiya.
• super() ka use karke parent class ka constructor call kiya.
• greet() method Person se inherit hui hai.

Ye real-life inheritance jaisa hi hota hai – ek child apne parent ke properties use karta hai.

5. Static & Instance Methods:

JavaScript mein methods do tarah ke hote hain — Static methods aur Instance methods.

Static methods kisi class ke directly class name ke through call kiye jaate hain, bina object banaye. Yeh methods mostly utility ya helper functions ke liye use hote hain. Example: Math.random() ek static method hai.

Instance methods, object ke instance par kaam karte hain. Inhe use karne ke liye class ka object banana padta hai. Ye methods object ki properties ko access kar sakte hain using this keyword.

Instance Method:

class Car {
  drive() {
    console.log("Driving the car");
  }
}

let c = new Car();
c.drive(); // Instance method call

Static Method:

class MathUtils {
  static add(a, b) {
    return a + b;
  }
}

console.log(MathUtils.add(5, 3)); // Static method call

Difference:

Summary:

• Object Literals – Simple aur quick tarika, ek ya do object ke liye.
• Constructor Functions – Ek hi structure ke kai objects banane ke liye.
• ES6 Classes – Modern way to define classes, readable and memory-efficient.
• Inheritance – Ek class doosri class ke features ko use kar sakti hai.
• Static Methods – Class ke level par; Instance Methods – Object ke level par.

Quiz: Test Your Knowledge on Object-Oriented JavaScript (OOJS)

Bonus: Practical Application!

Aaj hi Object-Oriented JavaScript (OOJS) ke concepts ko explore karke apne JavaScript skills ko next level par le jaayein!

OOJS ko sahi tareeke se samajhne ke liye isme istemal hone wale core concepts jaise objects, classes, constructors, inheritance, encapsulation, aur prototypes ka upayog karein. Inka use karke aap apne JavaScript code ko aur bhi modular, reusable aur powerful bana sakte hain!