object — property, method আর reference

১ · Object কী — নাম দেওয়া ঘর দিয়ে একটি জিনিসের ছবি

মডিউল ২-এ আপনি একটি একটি মান নিয়ে কাজ করেছেন — একটি দাম, একটি নাম, একটি true. কিন্তু বাস্তবের কোনো জিনিস একটিমাত্র মান দিয়ে বোঝানো যায় না। একটি অনলাইন দোকানের একজন গ্রাহকের কথা ভাবুন: তাঁর নাম আছে, ফোন নম্বর আছে, ঠিকানা আছে, তিনি এ পর্যন্ত কয়টি অর্ডার দিয়েছেন সেই সংখ্যা আছে। এগুলো আলাদা আলাদা variable-এ রাখলে — customerName, customerPhone, customerDistrict — দশজন গ্রাহকের জন্য চল্লিশটি variable লাগবে, আর কোন ফোন কার, তা মেলানো কঠিন হবে।

সমাধান হলো সব তথ্য একটি ব্যাগে ভরে ব্যাগটির একটি নাম দেওয়া। JavaScript-এ এই ব্যাগের নাম object. Object-এর ভেতরে প্রতিটি তথ্য একটি নাম (key) আর একটি মান (value) নিয়ে থাকে। এই জোড়াকে বলে property. সবচেয়ে সহজে object বানানো যায় বাঁকা বন্ধনী { } দিয়ে — একে বলে object literal:

const customer = {
  name: "Riya Akter",          // key: name, value: একটি string
  phone: "01711-000000",
  orders: 3,                   // value যেকোনো টাইপ হতে পারে
  verified: true,
  address: {                   // object-এর ভেতরে আরেকটি object
    district: "Khulna",
    area: "Sonadanga",
  },
};

দুটি বড় ধারণা — শুরুতেই মনে রাখুন

JavaScript-এ প্রায় সবকিছুই শেষ পর্যন্ত object: array একটি বিশেষ object (পর্ব ১৫), function একটি object, তারিখ একটি object, ব্রাউজারের পাতাটিও object-এর গাছ (DOM, পর্ব ৩৭)। আর সার্ভার থেকে আসা JSON ডেটা (পর্ব ১৯) দেখতে হুবহু object literal-এর মতো। তাই এই পর্বটি পুরো মডিউল ৩-এর ভিত্তি।

২ · Property পড়া, লেখা আর মোছা — dot বনাম bracket

Property পড়ার দুটি উপায়। প্রথমটি dot notation — object-এর নাম, একটি ডট, তারপর key: customer.name. দ্বিতীয়টি bracket notation — তৃতীয় বন্ধনীর ভেতরে key একটি string হিসেবে: customer["name"]. দুটোই একই মান দেয়। তাহলে দুটো কেন?

customer.name;                 // "Riya Akter"
customer["name"];              // একই
customer.address.district;     // "Khulna" — ডট পরপর চলে

const field = "phone";
customer[field];               // "01711-000000" — key variable-এ
customer.field;                // undefined — "field" নামের key খোঁজে!

const product = { "পণ্যের নাম": "মিনিকেট চাল", "unit-price": 80 };
product["পণ্যের নাম"];          // space আছে → bracket ছাড়া উপায় নেই
product["unit-price"];         // product.unit-price হতো product.unit − price

যোগ, বদল আর মোছা

Java-র মতো ভাষায় object-এর field আগে থেকে ঘোষণা করতে হয়। JavaScript-এ object খোলা খাতা — যেকোনো সময় নতুন property লেখা যায়:

customer.email = "riya@example.com";   // ছিল না → নতুন property যোগ
customer.orders = 4;                   // ছিল → মান বদল
customer.orders += 1;                  // 5
delete customer.verified;              // property পুরোপুরি মুছে ফেলা
customer.verified;                     // undefined (আর নেই)
customer.nickname;                     // undefined (কখনো ছিলই না)

খেয়াল করুন, customer একটি const — তবুও ভেতরে বদলানো গেল। পর্ব ০৭-এ দেখেছেন, const শুধু বলে “এই নামটি অন্য object-এ সরানো যাবে না” (customer = {} হলে TypeError). ভেতরের property বদলানো একটি mutation, আর const তা আটকায় না। আটকাতে চাইলে Object.freeze (অংশ ৭)।

ES2015-এর দুটি সুবিধা — shorthand আর computed key

প্রায়ই variable-এর নাম আর key-এর নাম একই হয়: { name: name, phone: phone }. ES2015 (ES6) থেকে লিখতে পারেন শুধু { name, phone } — একে বলে property shorthand. আর key-টি নিজেই যদি হিসাব করে বের করতে হয়, object literal-এর ভেতরেই bracket ব্যবহার করুন — computed property name:

const name = "Riya", phone = "01711-000000";
const c = { name, phone };                 // { name: "Riya", phone: "01711-000000" }

const lang = "bn";
const labels = {
  [`title_${lang}`]: "অর্ডারের তালিকা",    // key হবে "title_bn"
  [1 + 1]: "দুই",                          // key হবে "2"
};

Computed key বিশেষ কাজে আসে যখন একটি function একটি ফর্মের ঘর আপডেট করে: function setField(form, key, value) { return { ...form, [key]: value }; } — কোন ঘর বদলাবে, তা চলার সময় ঠিক হয়। এখানে ...form হলো spread, যা অংশ ৬-এ দেখবেন।

৩ · Method আর this — object নিজের ডেটা নিয়ে কাজ করে

পর্ব ১৩-এ দেখেছেন, function একটি মান — তাই তাকে object-এর property হিসেবেও রাখা যায়। এমন property-কে বলে method. নতুন কোনো জিনিস নয়; শুধু এমন একটি property, যার মান একটি function. লেখার তিনটি রূপ:

const cart = {
  owner: "Riya",
  items: [{ price: 80, qty: 5 }, { price: 120, qty: 2 }],

  total() {                          // ✅ method shorthand (ES2015)
    let sum = 0;
    for (const it of this.items) sum += it.price * it.qty;
    return sum;
  },
  greet: function () {               // পুরোনো রূপ — একই কাজ করে
    return "স্বাগতম, " + this.owner;
  },
  badGreet: () => "স্বাগতম, " + this.owner,   // ❌ arrow: this ভুল
};

cart.total();      // 640
cart.greet();      // "স্বাগতম, Riya"
cart.badGreet();   // "স্বাগতম, undefined"

this-এর মূল নিয়ম — কে ডাকছে, ডটের বাঁ পাশে কে

সাধারণ function বা method-এর ভেতরে this কাকে দেখাবে, তা লেখার সময় ঠিক হয় না — ঠিক হয় ডাকার সময়. সবচেয়ে সাধারণ নিয়ম: obj.method() আকারে ডাকলে this হলো ডটের বাঁ পাশের object. তাই একই function দুটি object-এ বসালে দুই জায়গায় দুই রকম this পাবে।

এর একটি উল্টো ফাঁদ আছে। Method-কে object থেকে আলাদা করে একটি variable-এ নিলে, বা callback হিসেবে পাঠালে, ডটের বাঁ পাশে আর কেউ থাকে না:

const greet = cart.greet;    // শুধু function-টি নেওয়া হলো, object নয়
greet();                     // this আর cart নয় → owner পাওয়া যায় না
setTimeout(cart.greet, 100); // একই সমস্যা — timer সাধারণ function হিসেবে ডাকে

Strict mode-এ (module ও class-এর ভেতরে স্বয়ংক্রিয়) greet()-এর ভেতরে this হয় undefined, আর this.owner পড়তে গেলে TypeError আসে। সাধারণ script-এ this হয় global object, তাই চুপচাপ ভুল মান আসে। setTimeout-এর বেলায় ব্রাউজার this হিসেবে সবসময় global object window দেয় — তাতেও owner নেই। সমাধান — setTimeout(() => cart.greet(), 100) বা bind. this-এর পুরো চারটি নিয়ম, call, apply আর bind আসবে পর্ব ২৪-এ। এই পর্বের জন্য একটি বাক্য যথেষ্ট:

৪ · Property আছে কি না, সব property ঘোরা, আর key-এর ক্রম

“এই গ্রাহকের কি email আছে?” — প্রশ্নটি সহজ মনে হয়, কিন্তু উত্তরের আগে জানতে হবে JavaScript একটি property কীভাবে খোঁজে। প্রতিটি সাধারণ object-এর পেছনে লুকানো একটি সংযোগ থাকে আরেকটি object-এর দিকে, যার নাম prototype. নিজের ভেতরে key না পেলে engine সেই prototype-এ খোঁজে, তারপর তারও prototype-এ — এভাবে একটি শিকল ধরে। এই শিকলকে বলে prototype chain. পুরো গল্প পর্ব ২৫-এ; এখানে শুধু খোঁজার ক্রমটি দেখুন।

const cust = { name: "Riya" };
// cust-এর prototype → Object.prototype → null

cust.name   → নিজের ভেতরে "name" আছে → "Riya"

cust-এ "toString" নেই
Object.prototype-এ আছে → সেই function পাওয়া গেল

cust-এ নেই → Object.prototype-এ নেই → null
ফল: undefined (কোনো error নয়)

"toString" in cust            → true   // শিকল ধরে খোঁজে
Object.hasOwn(cust, "toString") → false  // শুধু নিজের
Object.hasOwn(cust, "name")     → true

আছে কি না যাচাইয়ের চারটি উপায়

Object.hasOwn ES2022-এ যুক্ত হয়েছে পুরোনো hasOwnProperty-এর দুটি সমস্যা দূর করতে। (১) Object.create(null) দিয়ে বানানো object-এর কোনো prototype নেই, তাই তাতে hasOwnProperty method-ই নেই — ডাকলে TypeError. (২) ডেটার ভেতরে কেউ hasOwnProperty নামেই একটি key পাঠালে (যেমন user-এর form থেকে), সেই key আসল method-কে ঢেকে দেয়। Object.hasOwn(obj, key) object-এর ওপর নির্ভর করে না, তাই দুই ক্ষেত্রেই ঠিক কাজ করে।

আর গভীরের property পড়ার সময় মাঝপথে কিছু undefined হতে পারে — তখন পর্ব ০৮-এর optional chaining ?. আর ?? আপনার বন্ধু: customer.address?.district ?? "জেলা জানা নেই". address না থাকলে TypeError-এর বদলে undefined, তারপর ?? একটি ডিফল্ট বসায়।

সব property ঘুরে দেখা

একটি object-এর সব key বা মান নিয়ে কাজ করতে তিনটি static method আছে। তিনটিই শুধু নিজের আর enumerable (তালিকায় দেখানো যায় এমন) string key দেখে, আর একটি array ফেরত দেয়:

const stock = { rice: 50, dal: 20, oil: 0 };

Object.keys(stock);      // [ 'rice', 'dal', 'oil' ]
Object.values(stock);    // [ 50, 20, 0 ]
Object.entries(stock);   // [ [ 'rice', 50 ], [ 'dal', 20 ], [ 'oil', 0 ] ]

for (const [item, qty] of Object.entries(stock)) {
  if (qty === 0) console.log(item + " শেষ — নতুন অর্ডার দিন");
}

const prices = Object.fromEntries([["rice", 80], ["dal", 120]]);
// { rice: 80, dal: 120 } — entries থেকে আবার object

পর্ব ১২-এ for…in দেখেছিলেন। এটিও key ঘোরে, কিন্তু একটি বড় পার্থক্য: for…in prototype chain-এর enumerable property-গুলোও দেখায়. সাধারণ object literal-এ এর প্রভাব চোখে পড়ে না, কারণ Object.prototype-এর method-গুলো enumerable নয়। কিন্তু কোনো পুরোনো লাইব্রেরি Object.prototype-এ কিছু যোগ করলে, বা object অন্য object থেকে উত্তরাধিকার পেলে, for…in সেগুলোও তুলে আনে। তাই পুরোনো কোডে প্রায়ই দেখবেন for (k in obj) { if (Object.hasOwn(obj, k)) … }. নতুন কোডে সহজ নিয়ম: object ঘুরতে Object.keys/entries + for…of.

Key কোন ক্রমে আসে?

অনেকে ভাবেন object-এর key-এর কোনো নির্দিষ্ট ক্রম নেই। আধুনিক JavaScript-এ আছে, আর নিয়মটি একটু অদ্ভুত: প্রথমে integer-এর মতো দেখতে key-গুলো ছোট থেকে বড় ক্রমে, তারপর বাকি string key-গুলো যে ক্রমে যোগ হয়েছিল সেই ক্রমে (তারপর Symbol key, যা Object.keys দেখায় না)। ধাপে ধাপে দেখুন:

1const codes = {};2codes.b = 1;3codes[10] = "x";4codes.a = 2;5codes[2] = "y";6codes["-1"] = "z";7console.log(Object.keys(codes));

৫ · Reference — variable-এ object থাকে না, থাকে তার ঠিকানা

এবার এই পর্বের সবচেয়ে গুরুত্বপূর্ণ অংশ। পর্ব ০৫-এ দেখেছেন, engine-এর মেমরিতে দুটি এলাকা — stack আর heap. let n = 5 লিখলে ৫ মানটি সরাসরি variable-এর ঘরে বসে। কিন্তু const a = { qty: 1 } লিখলে object-টি তৈরি হয় heap-এ, আর a-এর ঘরে বসে শুধু একটি reference — “object-টি heap-এর ওই জায়গায় আছে”, এই তথ্য। তাহলে const b = a লিখলে কী কপি হয়? Object নয় — শুধু ঠিকানা। ধাপে ধাপে দেখুন:

1const a = { qty: 1 };2const b = a;3b.qty = 5;4console.log(a.qty);5const c = { ...a };6c.qty = 9;7console.log(a.qty, c.qty, a === b, a === c);

Function-এ object পাঠালে — কলকারীও বদল দেখে

পর্ব ১৩-এ দেখেছেন, argument parameter-এ কপি হয়ে যায়। Object-এর বেলায় কপি হয় reference — তাই function-এর ভেতরের parameter আর বাইরের variable একই object দেখায়। একে কখনো কখনো pass by sharing বলা হয়:

function applyDiscount(order) {
  order.total = order.total * 0.9;   // ❌ কলকারীর object-ই বদলে গেল
  return order;
}
function withDiscount(order) {
  return { ...order, total: order.total * 0.9 };   // ✅ নতুন object
}

function replace(order) {
  order = { total: 0 };   // শুধু local নামটি নতুন object দেখাল
}                         // বাইরের object অক্ষত

React, Redux, Vue-এর মতো আধুনিক framework এই নিয়মের ওপর দাঁড়িয়ে আছে। React ঠিক করে কোন অংশ নতুন করে আঁকবে “state-এর reference বদলেছে কি না” দেখে। আপনি যদি পুরোনো object-এর ভেতরে বদল করে একই reference পাঠান, React প্রায়ই বুঝতে পারে না যে কিছু বদলেছে — পাতা পুরোনো দেখায়। তাই সেখানে নিয়ম: বদলাবেন না, নতুন object বানান।

এবার reference আর কপির সব আচরণ নিজে চালিয়ে দেখুন:

const customer = { name: "Riya", address: { district: "Khulna" } };
const alias = customer;              // নতুন object নয়, একই ঠিকানা
alias.name = "Riya Akter";
console.log(customer.name, alias === customer);

const shallow = { ...customer };     // ওপরের স্তরের কপি
shallow.name = "Other";
shallow.address.district = "Jashore";
console.log(customer.name, customer.address.district);

const deep = structuredClone(customer);
deep.address.district = "Dhaka";
console.log(customer.address.district, deep.address.district);

console.log({ a: 1 } === { a: 1 }, Object.hasOwn(customer, "name"),
  Object.hasOwn(customer, "toString"), "toString" in customer);

const codes = { b: 1, 10: "x", a: 2, 2: "y", "-1": "z" };
console.log(Object.keys(codes));

৬ · কপি — shallow আর deep

একটি object-এর আলাদা কপি বানানোর তিনটি সাধারণ উপায় আছে, আর দুটি গোত্রে ভাগ করা যায়:

Shallow copy-এর ফাঁদটি এত সাধারণ যে আলাদা করে ধাপে ধাপে দেখা দরকার:

1const order = { id: 1, address: { city: "Dhaka" } };2const copy = { ...order };3copy.id = 2;4copy.address.city = "Khulna";5console.log(order.id, order.address.city);6const safe = structuredClone(order);7safe.address.city = "Sylhet";8console.log(order.address.city);

Shallow কপি দিয়েও নিরাপদে ভেতরের স্তর বদলানো যায় — যে স্তর বদলাবেন, সেটিও spread করুন: { ...order, address: { ...order.address, city: "Khulna" } }. React-এ state বদলানোর এটিই প্রচলিত ধরন। Object.assign(target, ...sources) একই কাজ করে, তবে প্রথম argument-টিকেই বদলে দেয় — তাই Object.assign({}, a, b) লিখলে নতুন object, Object.assign(a, b) লিখলে a বদলায়। Spread আর destructuring-এর পুরো ব্যবহার পর্ব ১৭-এ।

Deep copy — structuredClone বনাম পুরোনো JSON কৌশল

structuredClone ২০২২ সালের দিকে সব প্রধান ব্রাউজারে এসেছে (Node.js-এ 17 থেকে)। এর আগে বহু বছর ধরে মানুষ গভীর কপির জন্য একটি কৌশল লিখত — JSON.parse(JSON.stringify(obj)): object-কে JSON লেখায় বদলাও, তারপর আবার পড়ো। কাজ চলে, কিন্তু চুপচাপ ডেটা হারায়:

তাই নিয়ম: সাধারণ ডেটার গভীর কপি দরকার হলে structuredClone. তবে মনে রাখুন, প্রতিবার গভীর কপি করা ব্যয়বহুল — বড় ডেটায় প্রায়ই শুধু যে স্তর বদলাবেন, সেটুকু spread করাই ভালো। JSON আর structuredClone-এর বিস্তারিত পর্ব ১৯-এ।

৭ · Object-কে রক্ষা ও নিয়ন্ত্রণ — freeze, seal, descriptor আর getter/setter

একটি দোকানের সেটিংস — VAT হার, ডেলিভারি চার্জ, মুদ্রা — অ্যাপ চলার সময় কেউ ভুল করে বদলে দিলে প্রতিটি রসিদ ভুল হবে। JavaScript তিন মাত্রার সুরক্ষা দেয়:

নিষিদ্ধ কাজ করলে কী হয়, তা নির্ভর করে mode-এর ওপর। সাধারণ script-এ কাজটি চুপচাপ উপেক্ষিত হয় — কোনো error নেই, মান বদলায় না। Strict mode-এ (ES module আর class-এর ভেতরে সবসময়) TypeError আসে, যেমন Node.js-এ: TypeError: Cannot assign to read only property 'vat' of object '#<Object>'. চুপচাপ ব্যর্থতা খুঁজে পাওয়া কঠিন, তাই আধুনিক কোড module হিসেবে লেখাই ভালো।

Property descriptor — প্রতিটি ঘরের লুকানো তিনটি সুইচ

এ পর্যন্ত property মানে ছিল key আর value. আসলে প্রতিটি property-র সাথে তিনটি লুকানো boolean সুইচ থাকে, যেগুলো মিলে property descriptor:

• writable — মান বদলানো যাবে কি না।
• enumerable — Object.keys, for…in, spread আর JSON.stringify-এ দেখা যাবে কি না।
• configurable — property মোছা বা সুইচগুলো আবার বদলানো যাবে কি না।

Object.getOwnPropertyDescriptor({ vat: 0.15 }, "vat");
// { value: 0.15, writable: true, enumerable: true, configurable: true }

const order = { id: 1042 };
Object.defineProperty(order, "secretCode", { value: "X9" });
Object.getOwnPropertyDescriptor(order, "secretCode");
// { value: 'X9', writable: false, enumerable: false, configurable: false }
Object.keys(order);       // [ 'id' ] — secretCode লুকানো
order.secretCode;         // 'X9' — তবে সরাসরি পড়া যায়

Getter আর setter — property-র মতো দেখতে, ভেতরে function

একটি অর্ডারের মোট দাম আলাদা property হিসেবে রাখলে সমস্যা: কেউ পণ্যের সংখ্যা বদলাল কিন্তু total আপডেট করতে ভুলে গেল — দুটি তথ্য আর মেলে না। ভালো সমাধান হলো total-কে প্রতিবার পড়ার সময় হিসাব করা। getter ঠিক এটিই করে: দেখতে সাধারণ property (order.total, বন্ধনী ছাড়া), কিন্তু পড়ার সময় একটি function চলে। আর setter চলে মান বসানোর সময় — যাচাই বা রূপান্তরের সুযোগ দেয়:

const customer = {
  first: "Riya",
  last: "Akter",
  get fullName() {                    // পড়লে চলে
    return `${this.first} ${this.last}`;
  },
  set fullName(value) {               // বসালে চলে
    const parts = value.split(" ");
    this.first = parts[0];
    this.last = parts[1];
  },
};
customer.fullName;                    // "Riya Akter"
customer.fullName = "Nadia Islam";    // setter ভাগ করে দুই ঘরে রাখল
customer.first;                       // "Nadia"

৮ · বাস্তব ডেটা মডেল — একটি ই-কমার্স অর্ডার, Object.groupBy আর Map-এর সাথে তুলনা

এবার সব একসাথে। একটি অনলাইন দোকানের অর্ডার বাস্তবে এমন দেখায় — সার্ভার থেকে JSON হিসেবে আসে, আর JavaScript-এ হয়ে যায় nested object আর array-এর গাছ:

{
  "id": 1042,
  "customer": { "name": "Riya Akter", "phone": "01711-000000" },
  "shipping": { "district": "Khulna", "area": "Sonadanga", "fee": 120 },
  "items": [
    { "sku": "RICE-5KG", "name": "মিনিকেট চাল ৫ কেজি", "price": 420, "qty": 2 },
    { "sku": "DAL-1KG", "name": "মসুর ডাল ১ কেজি", "price": 140, "qty": 1 }
  ],
  "payment": { "method": "bKash", "paid": true },
  "status": "packed"
}

এমন ডেটা নিয়ে কাজ করার কয়েকটি ভালো অভ্যাস:

• যা হিসাব করা যায়, তা জমা রাখবেন না। মোট দাম items থেকে বের হয় — getter বা function দিয়ে হিসাব করুন, আলাদা total ঘর রাখলে একসময় মিলবে না।
• গভীরে নিরাপদে পড়ুন। order.payment?.method ?? "অজানা" — কোনো স্তর না থাকলে অ্যাপ ভাঙবে না। কিন্তু সব জায়গায় ?. ছিটিয়ে দেবেন না; যে ঘর অবশ্যই থাকার কথা, তা না থাকলে আগেভাগে error দেওয়াই ভালো।
• Key-এর নাম স্থির রাখুন। এক জায়গায় qty, আরেক জায়গায় quantity — ভুল বানানের key undefined দেয়, error নয়। পর্ব ৪৭-এর TypeScript এই ভুল লেখার সময়েই ধরে।
• স্টক বদলানোর মতো mutation এক জায়গায় রাখুন। “স্টক কমাও” কাজটি একটি function-এ, যাতে কোথায় কোথায় object বদলায়, তা খুঁজে পাওয়া যায়।

Object.groupBy — অর্ডারগুলো জেলা অনুযায়ী ভাগ করা

ডেলিভারি টিম জানতে চায়: কোন জেলায় কয়টি অর্ডার? আগে এর জন্য লুপ চালিয়ে হাতে object বানাতে হতো। ES2024-এ এসেছে Object.groupBy(তালিকা, callback): callback প্রতিটি উপাদানের জন্য একটি key ফেরত দেয়, আর ফলাফল একটি object, যার প্রতিটি key-তে সেই দলের উপাদানের array. Edge/Chrome 117 আর তার পরের সংস্করণে এটি আছে; Node.js-এ আছে 21 থেকে — Node 20-এ নেই, তাই পুরোনো Node-এ চালানোর কোডে সাবধান। ফলাফল object-টির কোনো prototype নেই (Object.create(null)-এর মতো), তাই তাতে toString বা hasOwnProperty method নেই — যাচাইয়ে Object.hasOwn ব্যবহার করুন।

অর্ডারের getter, freeze-এর সীমা আর groupBy — একসাথে চালিয়ে দেখুন:

const order = {
  id: 1042,
  items: [{ name: "চাল", price: 80, qty: 5 }, { name: "ডাল", price: 120, qty: 2 }],
  get total() {
    let sum = 0;
    for (const it of this.items) sum += it.price * it.qty;
    return sum;
  },
};
console.log(order.total);
order.items[1].qty = 3;               // ডেটা বদলালে total নিজেই বদলায়
console.log(order.total, Object.keys(order));

const settings = Object.freeze({ vat: 0.15, theme: { dark: false } });
settings.vat = 0;                     // strict mode নয় — চুপচাপ উপেক্ষা
settings.theme.dark = true;           // ভেতরের object freeze হয়নি!
console.log(settings.vat, settings.theme.dark, Object.isFrozen(settings));

const orders = [
  { id: 1, district: "ঢাকা" }, { id: 2, district: "খুলনা" }, { id: 3, district: "ঢাকা" },
];
const byDistrict = Object.groupBy(orders, (o) => o.district);
console.log(Object.keys(byDistrict), byDistrict["ঢাকা"].length);

Object নাকি Map?

Object দিয়ে “নাম → মান” তালিকা (dictionary) বানানো খুব প্রচলিত — পর্ব ১১-এ lookup table হিসেবেও দেখেছেন। কিন্তু JavaScript-এ এর জন্য একটি বিশেষ জিনিস আছে: Map (ES2015). কোনটি কখন:

সহজ নিয়ম: একটি নির্দিষ্ট “জিনিস”-এর ছবি (গ্রাহক, অর্ডার — key আগে থেকে জানা) → object. চলার সময় তৈরি হওয়া বা user-এর দেওয়া key, অথবা string নয় এমন key → Map. User-এর দেওয়া key সরাসরি সাধারণ object-এ বসানোর আরেকটি ঝুঁকি আছে: "__proto__"-এর মতো বিশেষ key prototype বদলে দিতে পারে — একে বলে prototype pollution, এটি একটি পরিচিত নিরাপত্তা দুর্বলতা। প্রতিরোধ: এমন ক্ষেত্রে Map বা Object.create(null) ব্যবহার করুন, আর বাইরের key যাচাই করুন। Map, Set আর WeakMap পর্ব ১৮-এ।

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

AI টুল object নিয়ে কোড খুব দ্রুত লেখে, আর তা দেখতে পরিষ্কারও লাগে। কিন্তু reference-এর বাগগুলো চোখে পড়ে না — কোড চলে, শুধু অন্য কোথাও একটি মান অকারণে বদলে যায়। Object নিয়ে AI-এর সবচেয়ে সাধারণ ভুলগুলো:

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

• প্রতিটি function পাওয়া object বা array বদলায় কি না দেখেছি — obj.x =, delete, push, Object.assign(obj, …) খুঁজেছি
• যেখানে “কপি” বলা হয়েছে, সেখানে আসলেই নতুন object তৈরি হয়েছে — শুধু = নয়
• Nested ডেটার কপিতে ভেতরের স্তর ভাগাভাগি থেকে যাচ্ছে কি না ভেবেছি
• গভীর কপিতে JSON কৌশল থাকলে Date, undefined, Map হারাচ্ছে কি না দেখেছি
• for…in থাকলে সেটি Object.keys/entries দিয়ে বদলেছি বা Object.hasOwn যাচাই যোগ করেছি
• Object.freeze থাকলে ভেতরের object-ও জমানো দরকার কি না দেখেছি
• User-এর দেওয়া key সাধারণ object-এ বসানো হলে Map বা যাচাইয়ের কথা ভেবেছি