class, inheritance আর private field

১ · Class কী — একই ছাঁচে অনেক object

পর্ব ১৪-এ আপনি object literal দিয়ে একজন গ্রাহকের ছবি এঁকেছিলেন। এবার ধরুন আপনি একটি মোবাইল ব্যাংকিং অ্যাপ বানাচ্ছেন। প্রতিটি অ্যাকাউন্টের একজন মালিক আর একটি ব্যালেন্স আছে, আর প্রতিটি অ্যাকাউন্টে একই কাজ চলে: টাকা জমা, টাকা তোলা, ব্যালেন্স দেখা। হাজারটি অ্যাকাউন্টের জন্য হাজারবার একই object literal লিখবেন না। দরকার একটি ছাঁচ — যেখানে একবার বলা থাকবে “একটি অ্যাকাউন্টের কী কী থাকে আর সে কী কী পারে”, তারপর সেই ছাঁচ থেকে যত খুশি অ্যাকাউন্ট বানানো যাবে।

এই ছাঁচের নাম class. Class থেকে তৈরি প্রতিটি object-কে বলে সেই class-এর instance. আর instance তৈরির মুহূর্তে যে বিশেষ function চলে, নতুন object-এর প্রথম মানগুলো বসায়, তার নাম constructor:

class BankAccount {
  constructor(owner, balance) {   // new চলার সময় একবার চলে
    this.owner = owner;           // this = এইমাত্র তৈরি নতুন object
    this.balance = balance;
  }
  deposit(amount) {               // method — সব অ্যাকাউন্টের জন্য একটাই
    this.balance += amount;
  }
}

const rahim = new BankAccount("রহিম", 500);
const karim = new BankAccount("করিম", 2000);
rahim.deposit(100);
rahim.balance;                    // 600
karim.balance;                    // 2000 — আলাদা object, আলাদা ডেটা

Class একটি function — কিন্তু বিশেষ ধরনের

একটি চমক: typeof BankAccount দেয় "function". JavaScript-এ class আসলে একটি constructor function, যেটি পর্ব ২৫-এ দেখা function BankAccount(owner) { this.owner = owner; }-এর মতোই কাজ করে। তবে পার্থক্যও আছে, আর প্রথম পার্থক্যটি একটি পুরোনো বাগ বন্ধ করে। পুরোনো constructor function-কে ভুল করে new ছাড়া ডাকলে this হতো global object, আর owner চুপচাপ global variable হয়ে যেত। Class-কে new ছাড়া ডাকলে সাথে সাথে error:

TypeError: Class constructor BankAccount cannot be invoked without 'new'

(এই বার্তাটি Chrome, Edge আর Node.js-এর; Firefox একই কথা অন্যভাবে বলে।) অর্থাৎ class “ভুলভাবে ব্যবহার করা কঠিন” — এটিই এর মূল সুবিধা।

২ · Class আসলে কী বানায় — prototype-এর ওপর পরিষ্কার লেখা

পর্ব ২৫-এ দেখেছেন, ES2015-এর আগে “class” বানানো হতো দুই ধাপে: একটি constructor function, আর তার prototype-এ হাতে হাতে method বসানো। class একই জিনিস এক জায়গায়, পরিষ্কারভাবে লেখার উপায় — এ ধরনের সুবিধাকে বলে syntactic sugar. পাশাপাশি দেখুন:

// ES5 — পুরোনো ধরন
function OldAccount(owner) {
  this.owner = owner;
}
OldAccount.prototype.deposit = function (amount) { /* … */ };

// ES2015 — class
class BankAccount {
  constructor(owner) { this.owner = owner; }
  deposit(amount) { /* … */ }
}

Object.getOwnPropertyNames(new BankAccount("রহিম"));   // [ 'owner' ]
Object.getOwnPropertyNames(BankAccount.prototype);    // [ 'constructor', 'deposit' ]

তবে “শুধু sugar” কথাটি পুরো সত্য নয়। পুরোনো ধরনের সাথে class-এর কয়েকটি গুরুত্বপূর্ণ পার্থক্য আছে:

Class hoist হয় না, আর class-এর ভেতরে strict mode

পর্ব ০৭-এ দেখেছেন, function declaration-কে ঘোষণার আগেই ডাকা যায় (hoisting), কিন্তু let/const-এর একটি TDZ থাকে। Class আচরণ করে let-এর মতো:

const a = new Wallet();   // ReferenceError: Cannot access 'Wallet' before initialization
class Wallet {}

class Shop {
  open() {
    total = 0;            // ReferenceError: total is not defined (strict mode!)
  }
}

Class expression — class-ও একটি মান

Function-এর মতো class-ও একটি মান — variable-এ রাখা যায়, function-এ পাঠানো যায়, function থেকে ফেরত দেওয়া যায়: const Wallet = class { … };. একে বলে class expression. প্রতিদিন খুব বেশি লাগে না, কিন্তু অংশ ৮-এর mixin পুরোপুরি এর ওপর দাঁড়িয়ে — একটি function, যা একটি class নেয় আর নতুন class ফেরত দেয়।

৩ · Class field আর #private — ডেটা সত্যিই গোপন রাখা

আগের উদাহরণে একটি গুরুতর সমস্যা আছে: যে কেউ rahim.balance = 1000000 লিখে দিতে পারে। কোনো যাচাই নেই, কোনো লেনদেনের হিসাব নেই। বাস্তব ব্যাংকে ব্যালেন্স বদলায় শুধু জমা বা তোলার নিয়ম মেনে। এই নীতির নাম encapsulation — ডেটা ভেতরে লুকিয়ে রাখা, আর বাইরের জগৎকে শুধু নিয়ন্ত্রিত কয়েকটি দরজা (method) দেওয়া।

Public class field — constructor-এর বাইরে ঘর ঘোষণা

ES2022 থেকে class-এর body-তে সরাসরি field ঘোষণা করা যায়, constructor ছাড়াই: status = "active";. একে বলে class field. প্রতিটি instance তৈরির সময় এটি instance-এর নিজের property হিসেবে বসে — prototype-এ নয়। সুবিধা: class খুললেই এক নজরে দেখা যায় object-এর কী কী ঘর থাকবে, আর সব instance একই ক্রমে একই property পায় (পর্ব ০৫-এর hidden class খুশি থাকে)।

Field কখন বসে, সেই ক্রমটি গুরুত্বপূর্ণ: সাধারণ (parent নেই এমন) class-এ field-গুলো বসে constructor-এর body চলার ঠিক আগে, যে ক্রমে লেখা সেই ক্রমে। তাই constructor-এর ভেতরে field-এর মান পাওয়া যায়, আর এক field আগের field ব্যবহার করতে পারে। Child class-এ ক্রমটি একটু আলাদা — অংশ ৫-এর stepper-এ দেখবেন।

Private field আর private method — নামের শুরুতে #

নামের আগে # বসালে field হয়ে যায় private field: শুধু সেই class-এর body-র ভেতরের কোড এটি পড়তে বা লিখতে পারে। একইভাবে #validate() { … } একটি private method — বাইরের কেউ ডাকতে পারে না। দুটোই ES2022-এ যুক্ত হয়েছে, আর আধুনিক সব browser ও Node.js-এ চলে।

class BankAccount {
  #balance = 0;                   // private field — বাইরে অদৃশ্য
  #validate(amount) {             // private method
    if (!(amount > 0)) throw new RangeError("ভুল পরিমাণ");
  }
  deposit(amount) {
    this.#validate(amount);       // ভেতর থেকে — বৈধ
    this.#balance += amount;
  }
}
const acc = new BankAccount();
acc.balance;        // undefined — "balance" নামে সাধারণ property নেই
acc["#balance"];    // undefined — এটি শুধু "#balance" নামের একটি string key
// acc.#balance;    // SyntaxError — পুরো ফাইলই চলবে না

class BankAccount {
  #balance = 0;
  deposit(a) { this.#balance += a; }   // ✅ একই class-এর body
  get balance() { return this.#balance; }
}

console.log("শুরু");          // এটিও ছাপা হবে না!
const acc = new BankAccount();
acc.#balance = 1000000;

SyntaxError: Private field '#balance' must be declared in an enclosing class

acc["#balance"]     → undefined  // string key, private নয়
acc._balance        → undefined
Object.keys(acc)    → []
JSON.stringify(acc) → "{}"

class BankAccount {
  #balance = 0;
  static peek(o) { return o.#balance; }   // ব্যাকরণে বৈধ
}
BankAccount.peek({ balance: 5 });

TypeError: Cannot read private member #balance from an object whose class did not declare it

static isAccount(o) { return #balance in o; }

BankAccount.isAccount(new BankAccount())  → true
BankAccount.isAccount({ balance: 5 })     → false

এবার পুরো BankAccount — private field, private method, getter, toJSON, static fromJSON আর brand check একসাথে চালিয়ে দেখুন:

class BankAccount {
  #balance = 0;                                    // private field
  constructor(owner, opening = 0) {
    this.owner = owner;
    if (opening > 0) this.deposit(opening);
  }
  #validate(amount) {                              // private method
    if (!(amount > 0)) throw new RangeError(`ভুল পরিমাণ: ${amount}`);
  }
  deposit(amount) { this.#validate(amount); this.#balance += amount; }
  withdraw(amount) {
    this.#validate(amount);
    if (amount > this.#balance) throw new RangeError("ব্যালেন্স যথেষ্ট নয়");
    this.#balance -= amount;
  }
  get balance() { return this.#balance; }
  toJSON() { return { owner: this.owner, balance: this.#balance }; }
  static fromJSON(text) { const d = JSON.parse(text); return new BankAccount(d.owner, d.balance); }
  static isAccount(obj) { return #balance in obj; }
}
const acc = new BankAccount("রহিম", 500); acc.deposit(200); acc.withdraw(100);
console.log(acc.owner, acc.balance, Object.getOwnPropertyNames(acc));
try { acc.withdraw(5000); } catch (e) { console.log(e.name, e.message); }
const back = BankAccount.fromJSON(JSON.stringify(acc));
console.log(JSON.stringify(back), BankAccount.isAccount(back), BankAccount.isAccount({ balance: 600 }));

৪ · Getter, setter আর static — নিয়ন্ত্রিত দরজা আর class-এর নিজের জিনিস

Getter আর setter — property-র চেহারায় যাচাই

পর্ব ১৪-এ object literal-এ getter আর setter দেখেছেন। Class-এ এরা আরও কাজের, কারণ private field-এর সাথে জোড়া বাঁধে: ডেটা থাকে #price-এ, আর বাইরের জগৎ দেখে একটি সাধারণ দেখতে price property, যার পেছনে যাচাই চলে।

class Product {
  #price = 0;
  constructor(name, price) {
    this.name = name;
    this.price = price;            // setter চলে — শুরু থেকেই যাচাই
  }
  get price() { return this.#price; }
  set price(value) {
    if (!Number.isFinite(value) || value < 0) {
      throw new RangeError(`দাম ঠিক নয়: ${value}`);
    }
    this.#price = Math.round(value * 100) / 100;   // পয়সা পর্যন্ত
  }
  get priceWithVat() { return this.#price * 1.15; }   // শুধু পড়ার জন্য
}
const rice = new Product("মিনিকেট চাল", 80);
rice.price = 85.456;    // setter → 85.46
rice.price = -5;        // RangeError: দাম ঠিক নয়: -5

static — instance-এর নয়, class-এর নিজের

কিছু কাজ কোনো নির্দিষ্ট অ্যাকাউন্টের নয়, পুরো অ্যাকাউন্ট-ধারণার। যেমন JSON লেখা থেকে একটি অ্যাকাউন্ট বানানো, বা দুটি অ্যাকাউন্টের তুলনা। এগুলো static method — ডাকা হয় class-এর নাম দিয়ে (BankAccount.fromJSON(text)), কোনো instance দিয়ে নয়। আপনি আগেই অনেক static method ব্যবহার করেছেন: Math.max, Array.from, Object.keys, Number.isFinite.

fromJSON-এর মতো method-কে বলে factory method: constructor-এর বদলে একটি নামওয়ালা দরজা দিয়ে object তৈরি। সুবিধা হলো নাম থেকেই উদ্দেশ্য বোঝা যায় — Money.fromPaisa(12550) আর Money.fromTaka(125.5) একই constructor-এ দুই অর্থের সংখ্যা পাঠানোর চেয়ে অনেক পরিষ্কার।

Static field, static #private আর static block (ES2022)

Static field (static vatRate = 0.15;) সব instance-এর ভাগের একটি মান রাখে, আর static #opened = 0; class-এর ভেতরের গোপন গণনা। কিন্তু কখনো class তৈরির মুহূর্তে একাধিক লাইনের প্রস্তুতি দরকার — একটি টেবিল ভরা, একটি সেটিং যাচাই করা। এর জন্য ES2022-এ এসেছে static block:

class VatTable {
  static rates = new Map();
  static {                                  // class তৈরির সময় একবার চলে
    for (const [item, rate] of [["চাল", 0], ["মোবাইল", 0.15]]) {
      this.rates.set(item, rate);           // এখানে this = VatTable
    }
  }
  static of(item) { return VatTable.rates.get(item) ?? 0.15; }
}
VatTable.of("চাল");       // 0
VatTable.of("ল্যাপটপ");   // 0.15 — তালিকায় নেই, তাই ডিফল্ট

৫ · extends আর super — inheritance-এর পুরো যাত্রা

ব্যাংকে সাধারণ অ্যাকাউন্ট ছাড়াও সঞ্চয়ী অ্যাকাউন্ট আছে। এতে জমা, তোলা, ব্যালেন্স — সব একই; বাড়তি শুধু সুদ যোগ, আর মাসে তোলার একটি সীমা। সব কোড আবার লেখা অপচয়। Inheritance বলে: নতুন class পুরোনো class-এর সব কিছু উত্তরাধিকার হিসেবে পাক, আর শুধু পার্থক্যটুকু লিখুক। JavaScript-এ এর keyword extends:

class SavingsAccount extends BankAccount {   // BankAccount = parent (superclass)
  interestPaid = 0;                          // child-এর নিজের field
  constructor(owner, opening, rate) {
    super(owner, opening);                   // ১. আগে parent-এর constructor
    this.rate = rate;                        // ২. তারপর this ব্যবহার
  }
  addInterest() {                            // নতুন method
    const interest = Math.round(this.balance * this.rate);
    this.deposit(interest);                  // parent-এর method
    this.interestPaid += interest;
  }
  withdraw(amount) {                         // override — একই নামে নতুন নিয়ম
    if (amount > 20000) throw new RangeError("এক বারে ২০,০০০-এর বেশি নয়");
    super.withdraw(amount);                  // বাকি কাজ parent-এর withdraw
  }
}

new SavingsAccount(...) — ঠিক কোন ক্রমে কী হয়

সাধারণ class-এ new প্রথমেই একটি খালি object বানিয়ে constructor-কে দেয়। Child class-এ তা হয় না — আর এই পার্থক্যই super()-এর নিয়মের মূল কারণ। ধাপে ধাপে দেখুন:

1class BankAccount {2  #balance = 0;3  constructor(owner, opening) {4    this.owner = owner; this.deposit(opening);5  } /* deposit, withdraw … */ }6class SavingsAccount extends BankAccount {7  interestPaid = 0;8  constructor(owner, opening, rate) {9    super(owner, opening);10    this.rate = rate;11  } }12const s = new SavingsAccount("করিম", 1000, 0.06);

এই ক্রম থেকেই super()-এর নিয়ম আসে: child-এর constructor-এ this ছোঁয়ার আগে, বা constructor থেকে ফেরার আগে, super() ডাকতেই হবে — কারণ তার আগে object-ই নেই। ভুলে গেলে (Chrome/Node.js-এর বার্তা):

ReferenceError: Must call super constructor in derived class before accessing 'this' or returning from derived constructor

Child-এ constructor একেবারেই না লিখলে কোনো সমস্যা নেই — engine নিজে constructor(...args) { super(...args); } বসিয়ে দেয়। সমস্যা হয় constructor লিখে super() ভুলে গেলে, বা তার আগে this ব্যবহার করলে।

Method lookup — override করা method কোনটি চলে?

s.withdraw(500) লিখলে দুটি withdraw আছে — child-এর আর parent-এর। কোনটি চলবে? উত্তর আসে পর্ব ২৫-এর prototype chain থেকে: engine নিচ থেকে ওপরে খোঁজে, আর প্রথম যেটি পায় সেটিই চালায়।

s.withdraw(500)
→ s-এর নিজের property-তে "withdraw" নেই // method instance-এ থাকে না

→ SavingsAccount.prototype.withdraw পাওয়া গেল — এটিই চলে
// parent-এর withdraw "ঢাকা পড়ে গেল" (shadowing)

s → SavingsAccount.prototype (নেই)
→ BankAccount.prototype.deposit পাওয়া গেল

child-এর withdraw-এর ভেতরে super.withdraw
→ খোঁজা শুরু BankAccount.prototype থেকে, s থেকে নয়
→ parent-এর withdraw চলে, this তখনো s

s.toString → … → Object.prototype.toString
s.fly      → … → null → undefined
s.fly()    → TypeError: s.fly is not a function

এবার Product → DigitalProduct দিয়ে override, super.method(), field-এর ক্রম আর instanceof একসাথে চালিয়ে দেখুন:

class Product {
  category = "সাধারণ";                             // public field
  constructor(name, price) {
    this.name = name;
    this.price = price;
    this.seenByParent = this.category;              // parent constructor কী দেখে?
  }
  deliveryCharge() { return this.price >= 1000 ? 0 : 60; }
  describe() { return `${this.name}: ৳${this.price} + ডেলিভারি ৳${this.deliveryCharge()}`; }
}
class DigitalProduct extends Product {
  category = "ডিজিটাল";
  constructor(name, price, sizeMB) {
    super(name, price);                             // আগে parent, তারপর this
    this.sizeMB = sizeMB;
  }
  deliveryCharge() { return 0; }                    // override
  describe() { return `${super.describe()} (${this.sizeMB} MB)`; }
}
const cart = [new Product("রাইস কুকার", 2500), new Product("হেডফোন", 800), new DigitalProduct("ই-বুক", 150, 12)];
for (const item of cart) console.log(item.describe());
const ebook = cart[2];
console.log(ebook.seenByParent, ebook.category, ebook instanceof Product);
console.log(Object.getOwnPropertyNames(DigitalProduct.prototype), Object.hasOwn(ebook, "describe"));

৬ · Polymorphism, instanceof আর built-in class extend করা

আগের উদাহরণের লুপটি আবার দেখুন: for (const item of cart) item.describe(). লুপ জানে না, জানার দরকারও নেই, কোনটি সাধারণ পণ্য আর কোনটি ডিজিটাল। প্রতিটি object নিজেই জানে নিজের deliveryCharge কীভাবে হিসাব করতে হয়। একই ডাক, ভিন্ন object-এ ভিন্ন আচরণ — একে বলে polymorphism. ক্ষেত্রফলের একটি ছোট উদাহরণ:

class Shape {
  area() { throw new Error(`${this.constructor.name} area() লেখেনি`); }
  toString() { return `${this.constructor.name} (ক্ষেত্রফল ${this.area().toFixed(2)})`; }
}
class Circle extends Shape {
  constructor(r) { super(); this.r = r; }
  area() { return Math.PI * this.r ** 2; }
}
class Rectangle extends Shape {
  constructor(w, h) { super(); this.w = w; this.h = h; }
  area() { return this.w * this.h; }
}
const shapes = [new Circle(1), new Rectangle(3, 4)];
shapes.map(String);   // [ 'Circle (ক্ষেত্রফল 3.14)', 'Rectangle (ক্ষেত্রফল 12.00)' ]
shapes.reduce((sum, s) => sum + s.area(), 0).toFixed(2);   // '15.14'

instanceof — কী যাচাই করে, কী করে না

instanceof প্রশ্ন করে: “X.prototype কি এই object-এর prototype chain-এর কোথাও আছে?” তাই ebook instanceof DigitalProduct, ebook instanceof Product, ebook instanceof Object — তিনটিই true. দুটি সীমা মনে রাখুন। (১) এটি শুধু শিকল দেখে, তাই Object.setPrototypeOf দিয়ে ঠকানো যায়, আর JSON.parse থেকে আসা সাধারণ object কখনো instanceof BankAccount নয়, দেখতে যতই মিলুক। (২) iframe বা আলাদা window-এর Array আরেকটি Array constructor থেকে তৈরি, তাই সেখানে instanceof Array মিথ্যা হতে পারে — array যাচাইয়ে Array.isArray ভালো। নিজের class-এর নিশ্চিত পরিচয় চাইলে অংশ ৩-এর #field in obj.

Built-in class extend করা — TakaList extends Array, AppError extends Error

ES5-এ Array-এর একটি “child” বানানো ঠিকভাবে সম্ভব ছিল না — length-এর বিশেষ আচরণ পাওয়া যেত না। Class-এ সম্ভব, কারণ অংশ ৫-এ দেখেছেন: child-এ object বানায় parent (এখানে Array নিজে), তাই object-টি একটি আসল array.

class TakaList extends Array {
  total() { return this.reduce((s, x) => s + x, 0); }
}
const prices = TakaList.of(120, 80, 450);
prices.total();                         // 650
const doubled = prices.map((x) => x * 2);
doubled instanceof TakaList;            // true — map-ও TakaList ফেরত দেয়
doubled.total();                        // 1300

class AppError extends Error {
  constructor(message, options) {
    super(message, options);            // options-এ { cause } পাঠানো যায়
    this.name = "AppError";
  }
}
String(new AppError("পেমেন্ট ব্যর্থ"));   // 'AppError: পেমেন্ট ব্যর্থ'

toString আর Symbol.toStringTag

একটি সাধারণ class instance-কে string-এ বদলালে আসে অকেজো "[object Object]". দুটি উপায়ে তা বদলানো যায়: একটি toString() method লেখা (Shape-এর মতো), যা template literal আর String(x)-এ ব্যবহার হয়; অথবা get [Symbol.toStringTag]() { return "Product"; } — তখন Object.prototype.toString.call(p) দেয় "[object Product]". দ্বিতীয়টি মূলত লাইব্রেরি আর ডিবাগিং-এর জন্য; Symbol দিয়ে ভাষার এমন hook-গুলো পর্ব ২৮-এ।

৭ · Class-এর তিনটি ব্যবহারিক ফাঁদ — হারানো this, JSON আর field-এর অর্থ

ফাঁদ ১: method-কে callback হিসেবে পাঠালে this হারায়

পর্ব ২৪-এ দেখেছেন, this ঠিক হয় ডাকার ধরনে। Class-এর method-কে আলাদা করে পাঠালে — button-এর click handler বা setTimeout-এ — ডটের বাঁ পাশে আর instance থাকে না — পরিচিত lost this বাগ। আর class-এর body strict, তাই this হয় undefined:

class Counter {
  count = 0;
  decrement() { this.count--; }            // prototype-এ, সবার ভাগের
  increment = () => { this.count++; };     // arrow field — প্রতিটি instance-এর নিজের
}
const k = new Counter();
const inc = k.increment, dec = k.decrement;
inc(); inc();          // ঠিক চলে — arrow-এর this চিরকাল k
k.count;               // 2
dec();                 // TypeError: Cannot read properties of undefined (reading 'count')
// সমাধানের অন্য উপায়: button.addEventListener("click", () => k.decrement());

কিন্তু এর দাম আছে, তাই “সব method arrow field বানাও” — AI-এর এই অভ্যাস ভালো নয়:

• প্রতিটি instance-এ নতুন function. new Counter().increment === k.increment হলো false. দশ হাজার object মানে দশ হাজার function — prototype method-এ একটাই।
• Override আর super ঠিকমতো চলে না। Arrow field prototype-এ নেই, তাই child-এ super.increment() লিখলে কিছু পাওয়া যায় না (undefined). আর child-এর prototype method parent-এর arrow field-কে override করতে পারে না — instance-এর নিজের property সবসময় আগে পাওয়া যায়।
• টেস্টে prototype ধরে বদলানো যায় না, আর DevTools-এ প্রতিটি object-এ বাড়তি property দেখা যায়।

নিয়ম: method সাধারণভাবে prototype-এ লিখুন; শুধু যেগুলো সত্যিই callback হিসেবে বাইরে যায়, সেখানে arrow field বা ডাকার জায়গায় ছোট arrow (() => k.decrement())।

ফাঁদ ২: JSON-এ গেলে class হারায়

পর্ব ১৯-এ দেখেছেন, JSON.stringify শুধু নিজের, enumerable, সাধারণ property লেখে। Class instance-এর ক্ষেত্রে এর মানে: method যায় না (সেগুলো prototype-এ), private field যায় না (#balance কোনো property-ই নয়)। toJSON ছাড়া BankAccount হয়ে যেত শুধু {"owner":"রহিম"}. আর উল্টো দিকে JSON.parse সবসময় সাধারণ object দেয় — parsed.deposit হলো undefined, parsed instanceof BankAccount মিথ্যা।

তাই localStorage বা সার্ভারে class-এর ডেটা পাঠানোর প্রচলিত জোড়া হলো: toJSON() দিয়ে ঠিক করুন কী লেখা হবে, আর একটি static fromJSON() দিয়ে লেখা থেকে আবার আসল instance বানান — অংশ ৩-এর runnable কোডে ঠিক এটিই করেছেন। fromJSON-এ constructor-এর মধ্য দিয়ে গেলে আরেকটি লাভ: বাইরে থেকে আসা ডেটাও আপনার যাচাইয়ের নিয়ম পার হয়।

ফাঁদ ৩: class field মানে “define”, “assign” নয়

একটি সূক্ষ্ম কিন্তু বাস্তব পার্থক্য। Constructor-এ this.price = 100 হলো সাধারণ assignment — parent-এর prototype-এ price-এর setter থাকলে সেটি চলে। কিন্তু class field price = 100; property-টি সরাসরি instance-এ define করে (Object.defineProperty-এর মতো), তাই parent-এর setter চলে না, আর instance-এর নিজের property সেই getter/setter-কে ঢেকে দেয়। পুরোনো Babel বা TypeScript সেটিং-এ লেখা কোড নতুন সেটিং-এ গেলে এই কারণে আচরণ বদলে যেতে পারে — ভাবনার প্রশ্ন ৪-এ এর ইতিহাস।

৮ · Composition বনাম inheritance — আর কখন class নয়

Inheritance শক্তিশালী, কিন্তু একটি “is-a” (এটি একটি ওটা) সম্পর্ক চিরকালের জন্য বেঁধে দেয়। ধরুন আপনার দোকানে Product → PhysicalProduct → FragileProduct আছে। এবার এল “ডিজিটাল কিন্তু উপহার হিসেবে মোড়ানো যায়” — এটি কোন শাখায়? “ভঙ্গুর আর সাথে ঠান্ডা রাখতে হয়”? গাছ যত গভীর হয়, তত দেখা যায় বাস্তবের জিনিস একটি গাছে বসে না। ওপরের class-এ ছোট একটি বদল নিচের সব class-কে অপ্রত্যাশিতভাবে ভাঙতে পারে — একে বলে fragile base class সমস্যা।

বিকল্প হলো composition: “is-a”-এর বদলে “has-a” (এর একটি ওটা আছে)। পণ্য নিজে ডেলিভারির হিসাব জানবে না; তার কাছে একটি ডেলিভারি-নিয়ম object থাকবে, যেটি বদলানো যায়:

const courier = { charge: (p) => (p.price >= 1000 ? 0 : 60) };
const download = { charge: () => 0 };
const giftWrap = { extra: 30 };

class Product {
  constructor(name, price, delivery, addOns = []) {
    Object.assign(this, { name, price, delivery, addOns });   // has-a
  }
  total() {
    const extras = this.addOns.reduce((s, a) => s + a.extra, 0);
    return this.price + this.delivery.charge(this) + extras;
  }
}
new Product("ই-বুক", 150, download, [giftWrap]).total();   // 180
new Product("হেডফোন", 800, courier).total();               // 860

Mixin — একাধিক জায়গা থেকে আচরণ ধার করা

JavaScript-এ একটি class শুধু একটি parent extend করতে পারে। কিন্তু কখনো একই আচরণ — যেমন “নিজেকে JSON-এ লিখতে পারা” — একেবারে আলাদা গাছের class-গুলোতে দরকার। সমাধান mixin. সবচেয়ে পরিষ্কার রূপ হলো এমন একটি function, যা একটি class নেয় আর তাকে extend করা নতুন class ফেরত দেয় (অংশ ২-এর class expression):

const Serializable = (Base) => class extends Base {
  serialize() { return JSON.stringify(this); }
};
const Timestamped = (Base) => class extends Base {
  stamp(at) { this.updatedAt = at; return this; }
};

class Customer { constructor(name) { this.name = name; } }
class SmartCustomer extends Serializable(Timestamped(Customer)) {}

const c = new SmartCustomer("নীলা").stamp("2026-10-19");
c.serialize();            // '{"name":"নীলা","updatedAt":"2026-10-19"}'
c instanceof Customer;    // true

কখন class আদৌ লাগবে না

Java থেকে আসা অনেকে সবকিছু class দিয়ে শুরু করেন। JavaScript-এ এর দরকার নেই, আর প্রায়ই সরল কোডই ভালো:

একটি ভালো পরীক্ষা: যদি class-এ শুধু একটি constructor আর একটি method থাকে, বা সব method static হয়, তাহলে সেটি সম্ভবত একটি function বা একটি module হওয়া উচিত ছিল। React নিজেও ২০১৯ সালের দিকে hooks এনে class component থেকে function component-এ সরে গেছে — অনেকটা এই কারণেই।

৯ · AI-এর যুগে — AI-এর লেখা class-কোড যাচাই করা

AI টুল class খুব পছন্দ করে, কারণ তাদের শেখার ডেটায় Java আর C#-এর কোড প্রচুর। ফলে JavaScript-এ এমন class-কোড আসে যা দেখতে গোছানো, কিন্তু ভাষার শক্তি ব্যবহার করে না বা পুরোনো অভ্যাসে লেখা। সবচেয়ে সাধারণ ভুলগুলো:

AI-এর লেখা class-কোড হাতে পেলে — যাচাইয়ের চেকলিস্ট

• গোপন রাখার কথা এমন ডেটা # দিয়ে লেখা, _ দিয়ে নয়
• প্রতিটি child constructor-এ this-এর আগে super(...) আছে, আর ঠিক argument যাচ্ছে
• Inheritance-এর গভীরতা গুনেছি; দুই স্তরের বেশি হলে composition দিয়ে সরল করা যায় কি না ভেবেছি
• Arrow function field শুধু callback-এর জন্য; বাকি method prototype-এ
• Override করা method-এ parent-এর কাজ দরকার হলে super.method() ডাকা হয়েছে
• JSON-এ পাঠানো বা ফেরত আনা class-এর জন্য toJSON/fromJSON আছে
• শুধু static method বা একটিমাত্র method-ওয়ালা class থাকলে সেটি function বা module হতে পারত কি না দেখেছি