map, filter, reduce আর সাজানো — array method দিয়ে ডেটার পাইপলাইন

১ · লুপ থেকে বর্ণনায় — “কীভাবে” নয়, “কী চাই”

পর্ব ১৫-এ array বানানো, বদলানো আর খোঁজা দেখেছেন। এবার একটি বাস্তব কাজ ভাবুন। একটি অনলাইন মুদি দোকানের কার্টে কয়েকটি পণ্য আছে। কিছু পণ্য স্টকে নেই। আপনাকে স্টকে থাকা পণ্যগুলোর মোট দাম বের করতে হবে। পর্ব ১২-এর লুপ দিয়ে লিখলে এমন দাঁড়ায়:

let total = 0;
for (let i = 0; i < cart.length; i++) {
  if (cart[i].inStock) {
    total += cart[i].price * cart[i].qty;
  }
}

কাজ করে। কিন্তু পড়ার সময় আপনার মাথাকে অনেক কিছু সামলাতে হয়: একটি counter i, শুরুর মান, থামার শর্ত, এক এক করে বাড়ানো, একটি শর্ত, আর একটি চলমান যোগফল। আসল উদ্দেশ্য — “স্টকে থাকাগুলো রাখো, প্রতিটির দাম বের করো, সব যোগ করো” — এই যন্ত্রপাতির নিচে চাপা পড়ে যায়। একই কাজ array method দিয়ে:

const total = cart
  .filter((item) => item.inStock)            // কোনগুলো রাখব
  .map((item) => item.price * item.qty)     // প্রতিটিকে কী বানাব
  .reduce((sum, x) => sum + x, 0);          // সব মিলিয়ে একটি মান

এই ধরনের লেখাকে বলে declarative (কী চাই, তা বর্ণনা করা), আর লুপের ধরনকে imperative (ধাপে ধাপে কীভাবে করতে হবে, তা নির্দেশ দেওয়া)। দুটোই বৈধ, আর লুপের এখনো জায়গা আছে (অংশ ৭-এ দেখবেন কখন)। কিন্তু তালিকা নিয়ে বেশিরভাগ দৈনন্দিন কাজ তিনটি প্রশ্নের একটি:

প্রতিটি method একটি callback নেয় — আর সেটি তিনটি জিনিস পায়

পর্ব ১৩-এ দেখেছেন, function একটি মান, আর যে function অন্য function নেয় সেটি higher-order function. এই পর্বের প্রতিটি method ঠিক তাই। আপনি একটি callback দেন, আর method array-এর প্রতিটি উপাদানের জন্য সেটিকে ডাকে — প্রতিবার তিনটি argument দিয়ে:

বেশিরভাগ সময় আপনি শুধু প্রথমটি ব্যবহার করবেন: (item) => item.price. বাকি দুটি JavaScript-এ চুপচাপ উপেক্ষিত হয় — পর্ব ১৩-এ দেখেছেন, বাড়তি argument কোনো error দেয় না। এই নিরীহ নিয়মটিই অংশ ২-এর সবচেয়ে বিখ্যাত ফাঁদের জন্ম দেয়। আরেকটি কম ব্যবহৃত জিনিস: বেশিরভাগ method একটি দ্বিতীয় argument thisArg নেয় — arr.map(fn, obj) লিখলে fn-এর ভেতরে this হবে obj. Arrow function-এর নিজের this নেই বলে সেখানে এটি কাজই করে না; আধুনিক কোডে প্রায় দেখবেন না (this পর্ব ২৪-এ)।

২ · forEach আর map — প্রতিটির জন্য কাজ, প্রতিটিকে বদলানো

forEach — শুধু কাজ করো, কিছু ফেরত দিও না

forEach প্রতিটি উপাদানের জন্য আপনার function ডাকে — ব্যস। ফল জমা করে না, ফেরত দেয় undefined. তাই এর ব্যবহার শুধু side effect-এর জন্য: console-এ ছাপা, পাতায় কিছু বসানো, কোথাও পাঠানো। orders.forEach((o) => console.log(o.id)) ঠিক আছে।

দুটি সীমাবদ্ধতা মনে রাখুন। এক, forEach মাঝপথে থামানো যায় না। Callback-এর ভেতরে break লিখলে SyntaxError, কারণ break শুধু লুপের ভেতরে চলে, আর callback একটি আলাদা function. return লিখলে শুধু সেই একটি কল শেষ হয় — পরের উপাদানে আবার চলে। থামাতে চাইলে for…of লুপ (পর্ব ১২), অথবা find/some/every ব্যবহার করুন — এরা উত্তর পেলেই থেমে যায়। দুই, forEach async callback-এর জন্য অপেক্ষা করে না — এর গল্প পর্ব ৩৪-এ।

map — একটি থেকে একটি

map প্রতিটি উপাদানকে আপনার callback-এ পাঠায়, আর callback যা ফেরত দেয় তা দিয়ে একটি নতুন array বানায়। নিয়ম সহজ: ৫টি ঢুকলে ৫টি বেরোবে, একই ক্রমে। মূল array অক্ষত থাকে।

• দামের তালিকা থেকে VAT-সহ দাম: prices.map((p) => p * 1.15)
• object থেকে একটি field তুলে আনা: students.map((s) => s.name)
• ডেটা থেকে পাতায় দেখানোর লেখা: items.map((i) => `${i.name} — ৳${i.price}`)

Callback কিছু ফেরত না দিলে কী হয়? প্রতিটির জায়গায় undefined. সবচেয়ে সাধারণ কারণ পর্ব ১৩-এর block body: items.map((i) => { i.price * 2 }) — বাঁকা বন্ধনী দিলে return নিজে লিখতে হয়। ফল [undefined, undefined, …].

React-ধাঁচের আপডেট — id দেখে একটি উপাদান বদলানো

একটি to-do তালিকায় id ৩-এর কাজটি “শেষ” চিহ্নিত করতে হবে। পুরোনো ধরন হলো খুঁজে বের করে সরাসরি বদলে দেওয়া: todos.find((t) => t.id === 3).done = true — এটি মূল object-কে mutation করে। React-এর মতো framework বদল ধরতে পারে reference বদলালে, তাই সেখানে নিয়ম হলো: বদলাবেন না, নতুন বানান।

const updated = todos.map((t) =>
  t.id === 3 ? { ...t, done: true } : t
);

বিখ্যাত ফাঁদ — ["1", "7", "11"].map(parseInt)

একটি ফর্ম থেকে সংখ্যাগুলো string হিসেবে এসেছে। কেউ চতুর হয়ে লিখলেন ["1", "7", "11"].map(parseInt) — parseInt তো একটি function, সরাসরি পাঠিয়ে দিলেই হয়! ফল আসে [1, NaN, 3]. কেন? মনে রাখুন, map callback-কে তিনটি argument দেয়, আর parseInt দ্বিতীয় argument হিসেবে নেয় radix — সংখ্যাটি কোন ভিত্তিতে লেখা (পর্ব ১০)। ধাপে ধাপে দেখুন:

1["1", "7", "11"].map(parseInt);2// map প্রতিবার ডাকে: fn(element, index, array)3// parseInt-এর চেহারা:  parseInt(string, radix)4["1", "7", "11"].map((s) => parseInt(s, 10));

৩ · filter, find, some, every — বাছাই আর প্রশ্ন

filter-এর callback একটি প্রশ্নের উত্তর দেয়: “এটি কি রাখব?” এমন হ্যাঁ/না উত্তর দেওয়া function-কে বলে predicate. Callback যা ফেরত দেয় তা truthy হলে উপাদানটি নতুন array-তে যায়, falsy হলে বাদ। খেয়াল করুন: উপাদানটিই যায়, callback-এর ফল নয় — filter কিছু বদলায় না, শুধু বাছে।

• স্টকে থাকা পণ্য: products.filter((p) => p.stock > 0)
• ঢাকার অর্ডার: orders.filter((o) => o.district === "ঢাকা")
• ফাঁকা নাম বাদ: names.filter((n) => n.trim() !== "")
• falsy মান সব বাদ: values.filter(Boolean) — এখানে Boolean নিজেই predicate; তবে এতে 0-ও বাদ পড়ে, যা হয়তো বৈধ ডেটা ছিল (পর্ব ০৮)।

একটিই চাই, বা শুধু হ্যাঁ/না — find, findIndex, some, every

পর্ব ১৫-এ এগুলোর পরিচয় পেয়েছেন। এখানে predicate-এর চোখে আরেকবার দেখুন, কারণ এরা filter-এর “তাড়াতাড়ি থামা” আত্মীয়:

শেষ কলামটি পরীক্ষায় প্রায়ই আসে: [].every(fn) কেন true? গণিতের যুক্তিতে, “সবাই শর্ত মানে” মিথ্যা হতে হলে অন্তত একজন না-মানা সদস্য লাগবে — খালি দলে কেউ নেই, তাই কথাটি সত্য। একে বলে vacuous truth. বাস্তবে এর মানে: “কার্টের সব পণ্য কি স্টকে আছে?” — খালি কার্টে উত্তর true, তাই চেকআউট বোতাম চালু করার আগে cart.length > 0-ও যাচাই করুন।

some আর every পর্ব ০৮-এর short-circuit-এর মতো আচরণ করে — উত্তর জানা হয়ে গেলেই থামে। ১০ লাখ অর্ডারের প্রথমটিতেই বাতিল অর্ডার পেলে orders.some((o) => o.cancelled) বাকি ৯,৯৯,৯৯৯টি দেখেই না। filter(…).length > 0 লিখলে সবগুলো দেখে একটি অপ্রয়োজনীয় array-ও বানায় — একই উত্তর, অনেক বেশি কাজ।

flatMap — একটি থেকে কয়েকটি (বা শূন্য)

map সবসময় একটির বদলে একটি দেয়। কিন্তু ধরুন প্রতিটি অর্ডারে কয়েকটি পণ্য, আর আপনি সব অর্ডারের সব পণ্যের একটি সমতল তালিকা চান। orders.map((o) => o.items) দেবে array-এর array: [["চাল", "ডাল"], ["তেল"]]. flatMap (ES2019) একই কাজ করে, তারপর এক স্তর সমতল করে: orders.flatMap((o) => o.items) → ["চাল", "ডাল", "তেল"].

একটি চতুর ব্যবহার: callback থেকে [] ফেরত দিলে উপাদানটি বাদ পড়ে, [x] দিলে থাকে — তাই flatMap একসাথে filter আর map দুটোই করতে পারে। যেমন বাক্যগুলোকে শব্দে ভাঙা: sentences.flatMap((s) => s.split(" ")).

৪ · reduce — পুরো তালিকাকে একটি মানে নামিয়ে আনা

map আর filter array থেকে array দেয়। কিন্তু অনেক সময় আপনি চান একটিমাত্র উত্তর: মোট দাম, সবচেয়ে দামি পণ্য, প্রতিটি শব্দ কতবার এসেছে তার হিসাব। এখানে আসে reduce. পর্ব ১২-এ লুপের accumulator দেখেছেন — একটি শুরু-মান, প্রতিটি ঘোরায় তাতে কিছু যোগ। reduce ঠিক সেই নকশাকে একটি method বানিয়েছে:

array.reduce((acc, element, index, array) => newAcc, initialValue);

Callback পায় এখন পর্যন্ত জমা হওয়া ফল (acc) আর এখনকার উপাদান; তাকে ফেরত দিতে হবে নতুন জমা ফল। পরের কলে সেই ফলই acc হয়ে আসে। শেষ কলের ফেরত মানই reduce-এর উত্তর। তিনটি দামের যোগফল ধাপে ধাপে দেখুন:

1const prices = [120, 80, 45];2const total = prices.reduce(3  (sum, p) => sum + p,4  05);

কেন সবসময় initial value দেবেন

Initial value ঐচ্ছিক, কিন্তু না দেওয়া প্রায় সবসময় ভুল। তিনটি কারণ:

1. খালি array-এ program ভাঙে। [].reduce((a, b) => a + b) চালালে Chrome, Edge আর Node.js-এ (V8) বার্তা আসে TypeError: Reduce of empty array with no initial value. আজকের অর্ডার তালিকা খালি হতেই পারে — আর ঠিক সেদিন রিপোর্ট পাতা ভেঙে যাবে। Initial value দিলে [].reduce((a, b) => a + b, 0) শান্তভাবে 0 দেয়।
2. Object-এর array-এ ভুল ফল। cart.reduce((sum, item) => sum + item.price) — প্রথম কলে sum হলো পুরো প্রথম object, সংখ্যা নয়! Object + সংখ্যা মানে string জোড়া: ফল আসে "[object Object]80"-এর মতো অর্থহীন কিছু (পর্ব ০৬-এর coercion).
3. একটি উপাদানে callback চলেই না। Initial value ছাড়া এক উপাদানের array-এ reduce callback না ডেকেই সেই উপাদানটি ফেরত দেয় — কোনো রূপান্তর হয় না। ফলের type বদলে যেতে পারে।

Initial value accumulator-এর type-ও ঠিক করে দেয়: যোগফলে 0, গুণফলে 1, তালিকা বানাতে [], হিসাবের খাতা বানাতে {}. reduceRight একই কাজ করে শেষ উপাদান থেকে শুরু করে — যোগে ক্রম কোনো পার্থক্য করে না, কিন্তু string জোড়া বা function একের পর এক চালানোর (composition, পর্ব ২৩) সময় ক্রম গুরুত্বপূর্ণ।

reduce দিয়ে গোনা — একটি বাংলা বাক্যে শব্দের সংখ্যা

reduce-এর accumulator সংখ্যাই হতে হবে, এমন নয়। একটি object-কে খাতা বানিয়ে প্রতিটি শব্দ কতবার এল, গোনা যায়:

const words = "আমি ভাত খাই আমি মাছ খাই আমি".split(" ");
const freq = words.reduce((acc, w) => {
  acc[w] = (acc[w] ?? 0) + 1;   // আগে না থাকলে 0 ধরে 1 যোগ
  return acc;                   // return ভুললে পরের কলে acc = undefined
}, {});
// { 'আমি': 3, 'ভাত': 1, 'খাই': 2, 'মাছ': 1 }

৫ · Chaining — ডেটার পাইপলাইন

map আর filter নতুন array ফেরত দেয়, আর array-এর ওপর আবার method ডাকা যায়। তাই একটির পর একটি জুড়ে দেওয়া যায় — একে বলে method chaining. প্রতিটি ধাপ আগের ধাপের ফল নেয়, ঠিক কারখানার লাইনের মতো। পুরো জিনিসটিকে বলে একটি data pipeline. একটি মুদি দোকানের অর্ডার তালিকা কীভাবে ধাপে ধাপে একটি মোট আয়ে পরিণত হয়, দেখুন:

{ item: "চাল", price: 120, qty: 2, inStock: true  }
{ item: "ডাল", price: 80,  qty: 1, inStock: false }
{ item: "তেল", price: 45,  qty: 3, inStock: true  }
{ item: "চিনি", price: 140, qty: 1, inStock: true  }
{ item: "আটা", price: 60,  qty: 4, inStock: true  }

{ item: "চাল", price: 120, qty: 2, ... }
{ item: "তেল", price: 45,  qty: 3, ... }
{ item: "চিনি", price: 140, qty: 1, ... }
{ item: "আটা", price: 60,  qty: 4, ... }

(একই object-গুলো — কপি নয়, reference)

[ 240, 135, 140, 240 ]

চাল 120×2 = 240
তেল  45×3 = 135
চিনি 140×1 = 140
আটা  60×4 = 240

0 → 240 → 375 → 515 → 755

মোট আয়: 755 টাকা
orders এখনো ৫টি, অক্ষত

পাইপলাইনের সৌন্দর্য হলো প্রতিটি ধাপ আলাদাভাবে পরীক্ষা করা যায়। কোনো সন্দেহ হলে মাঝখানে একটি লাইন কেটে console.log করুন — মাঝের array-টি দেখতে পাবেন। আর ধাপের ক্রম গুরুত্বপূর্ণ: আগে filter, তারপর map — এতে বাদ পড়া উপাদানের জন্য অকারণে হিসাব হয় না। এবার নিজে চালান — মোট আয়, সবচেয়ে বেশি বিক্রির ৩টি পণ্য, আর অংশ ২–৪-এর তিনটি ফাঁদ:

const orders = [
  { item: "চাল", price: 120, qty: 2, inStock: true },
  { item: "ডাল", price: 80, qty: 1, inStock: false },
  { item: "তেল", price: 45, qty: 3, inStock: true },
  { item: "চিনি", price: 140, qty: 1, inStock: true },
  { item: "আটা", price: 60, qty: 4, inStock: true },
];
const lines = orders
  .filter((o) => o.inStock)
  .map((o) => ({ item: o.item, total: o.price * o.qty }));
const revenue = lines.reduce((sum, l) => sum + l.total, 0);
const top3 = lines.toSorted((a, b) => b.total - a.total)
  .slice(0, 3).map((l) => l.item);
console.log(revenue, top3, orders.length);

console.log(["1", "7", "11"].map(parseInt), ["1", "7", "11"].map(Number));
const doubled = [];
console.log([1, 2].forEach((x) => doubled.push(x * 2)), doubled);
try { [].reduce((a, b) => a + b); }
catch (e) { console.log(e.name + ": " + e.message); }

লেবেলের উদাহরণ — বাছাই করা পণ্যে ১০% ছাড়

একটি দোকানের ঈদ অফার: শুধু “মুদি” ক্যাটাগরির পণ্যে ১০% ছাড়, আর প্রতিটির জন্য একটি দামের লেবেল চাই। সব পণ্যই তালিকায় থাকবে, শুধু কিছুর দাম বদলাবে — তাই এটি filter নয়, map-এর ভেতরে একটি শর্ত:

const labels = products.map((p) => {
  const price = p.category === "মুদি" ? Math.round(p.price * 0.9) : p.price;
  return `${p.name}: ৳${price}`;
});
// [ 'চাল: ৳108', 'সাবান: ৳50', 'ডাল: ৳72' ]  (চাল 120, সাবান 50, ডাল 80 হলে)

৬ · সাজানো — sort-এর ডিফল্ট ফাঁদ আর comparator

পর্ব ১৩-এ একঝলক দেখেছেন: [10, 9, 100].sort() দেয় [10, 100, 9]. এটা কোনো বাগ নয় — এটাই নিয়ম। comparator না দিলে sort প্রতিটি উপাদানকে string বানিয়ে অভিধানের মতো অক্ষর ধরে ধরে তুলনা করে — একে বলে lexicographic order. তারপর comparator দিলে কী হয়, আর sort কীভাবে মূল array বদলে দেয় — ধাপে ধাপে দেখুন:

1const nums = [10, 9, 100];2nums.sort();3nums.sort((a, b) => a - b);4const desc = nums.toSorted((a, b) => b - a);

বাংলা নাম সাজানো — localeCompare

String-এর ক্ষেত্রে ডিফল্ট sort তুলনা করে UTF-16 code unit (পর্ব ০৯) দিয়ে। ইংরেজিতে এর ফল অদ্ভুত: সব বড় হাতের অক্ষর ছোট হাতের আগে, তাই "Zara" আসে "apple"-এর আগে। বাংলায় কোড পয়েন্টের ক্রম মোটামুটি বর্ণমালার মতো, তবে যুক্তাক্ষর, নুকতা আর ভিন্নভাবে লেখা একই অক্ষরে (যেমন “য়” দুই রকমভাবে লেখা যায়) গোলমাল হতে পারে। ভাষার নিয়ম মেনে সাজাতে localeCompare ব্যবহার করুন:

const fruits = ["আম", "কলা", "আনারস", "লিচু", "জাম"];
fruits.toSorted((a, b) => a.localeCompare(b, "bn"));
// [ 'আনারস', 'আম', 'কলা', 'জাম', 'লিচু' ]

Stability — সমান হলে আগের ক্রম থাকে কি?

একটি stable sort সমান উপাদানগুলোর আগের আপেক্ষিক ক্রম বদলায় না। অংশ ৫-এর কোডে চাল আর আটার বিক্রি সমান ছিল, আর চাল আগেই থাকল — stability-র কারণে। ES2019 থেকে মানদণ্ড sort-কে stable হতে বাধ্য করেছে; এর আগে কিছু engine-এ বড় array-তে সমান উপাদানের ক্রম এলোমেলো হতে পারত (ইতিহাস ভাবনার প্রশ্ন ৪-এ)। Stability-র বাস্তব সুবিধা: আগে নাম দিয়ে সাজিয়ে তারপর GPA দিয়ে সাজালে, একই GPA-র মধ্যে নামের ক্রম রয়ে যায়।

sort মূল array বদলায় — toSorted দেয় নতুন

sort একটি in-place অপারেশন: মূল array-টিই সাজিয়ে দেয়, আর সেই একই array ফেরত দেয়। ফলে const ranked = students.sort(…) লিখলে ranked আর students একই array — যে কোডটি মূল ক্রমের ওপর নির্ভর করছিল (যেমন রোল নম্বরের তালিকা), সেটি চুপচাপ ভেঙে যায়। পুরোনো সমাধান ছিল আগে কপি করা: [...students].sort(…). ES2023 থেকে সরাসরি students.toSorted(…). একই পরিবারে আরও তিনটি এসেছে: toReversed() (reverse-এর বদলে), toSpliced() (splice-এর বদলে), আর with(index, value) (arr[i] = v-এর বদলে)।

একাধিক key — GPA বেশি আগে, সমান হলে নাম অনুযায়ী

মেধাতালিকা বানাতে প্রথমে GPA বড় থেকে ছোট, আর GPA সমান হলে নামের বর্ণানুক্রমে। Comparator-এ || ব্যবহার করুন: প্রথম তুলনা ০ (সমান) হলে falsy, তখন দ্বিতীয় তুলনা চলে।

const students = [
  { name: "রহিম", gpa: 4.5 }, { name: "আয়েশা", gpa: 5.0 },
  { name: "করিম", gpa: 4.5 }, { name: "তানিয়া", gpa: 5.0 },
  { name: "নাসির", gpa: 4.0 }];
const ranked = students.toSorted(
  (a, b) => b.gpa - a.gpa || a.name.localeCompare(b.name, "bn")
);
console.log(ranked.map((s) => `${s.name} ${s.gpa}`).join(", "));
console.log(students[0].name, [10, 9, 100].toSorted());

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

const counts = orders.reduce((acc, o) => {
  acc[o.district] = (acc[o.district] ?? 0) + 1;
  return acc;
}, {});
console.log(JSON.stringify(counts));
console.log([...new Set(orders.map((o) => o.district))]);

৭ · Group, গোনা, unique — আর কখন reduce নয়

জেলাভিত্তিক অর্ডার — Object.groupBy আর reduce

একটি e-commerce সাইটে ডেলিভারি দল জেলা ধরে অর্ডার ভাগ করে। Object.groupBy (ES2024) ঠিক এই কাজের জন্য: একটি array আর একটি callback নেয়, callback প্রতিটি উপাদানের জন্য একটি key ফেরত দেয়, আর ফল একটি object যার প্রতিটি key-তে সেই দলের উপাদানগুলোর array. ফলের object-এর prototype নেই (null prototype), তাই "toString" নামের জেলাও নিরাপদ। একই পরিবারে Map.groupBy আছে, যা Map (পর্ব ১৮) ফেরত দেয় — key string না হলে সেটি ব্যবহার করুন।

তবে এটি নতুন: Chrome আর Edge-এ ২০২৩ সাল থেকে, Node.js-এ ভার্সন 21 থেকে। Node 20 বা পুরোনো ব্রাউজারে চালাতে হলে reduce-ভিত্তিক বিকল্প লিখুন — সব জায়গায় চলে:

const byDistrict = orders.reduce((acc, o) => {
  (acc[o.district] ??= []).push(o);   // দল না থাকলে বানাও, তারপর যোগ করো
  return acc;
}, {});

Unique — Set দিয়ে পুনরাবৃত্তি বাদ

কোন কোন জেলা থেকে অর্ডার এসেছে, প্রতিটি একবার করে? [...new Set(arr)] — একটি Set একই মান দ্বিতীয়বার রাখে না, আর spread তাকে আবার array বানায়। প্রথমবার দেখা ক্রম বজায় থাকে। Set কীভাবে কাজ করে, কেন এটি filter + indexOf-এর চেয়ে অনেক দ্রুত, আর object-এর ক্ষেত্রে কেন কাজ করে না (object-এর তুলনা হয় reference দিয়ে) — পুরোটা পর্ব ১৮-এ।

পারফরম্যান্স আর পাঠযোগ্যতা — আগে পাঠযোগ্যতা

একটি যুক্তিসংগত প্রশ্ন: filter → map → reduce মানে তিনবার ঘোরা আর দুটি মাঝের array. একটিমাত্র reduce বা for লুপে সব করলে কি দ্রুত হয় না? হ্যাঁ, সামান্য। কিন্তু তিনটি কথা মনে রাখুন:

• বেশিরভাগ তালিকা ছোট। একটি কার্টে ২০টি পণ্য, একটি পাতায় ১০০টি অর্ডার — এখানে পার্থক্য মাইক্রোসেকেন্ডের। আধুনিক engine (পর্ব ০৫-এর JIT) এই ছোট callback-গুলো খুব ভালোভাবে অপটিমাইজ করে।
• পাঠযোগ্যতার দাম বেশি। কোড লেখা হয় একবার, পড়া হয় শতবার। একটি বাগ খুঁজতে আধঘণ্টা বাঁচানো কয়েক মাইক্রোসেকেন্ডের চেয়ে অনেক বেশি মূল্যবান।
• মেপে তারপর বদলান। লাখো উপাদান, প্রতি সেকেন্ডে বহুবার — এমন জায়গায় DevTools-এর profiler (পর্ব ৫৩) দিয়ে মেপে দেখুন সত্যিই এখানে সময় যাচ্ছে কি না। তখন একটি সাধারণ for লুপ সম্পূর্ণ গ্রহণযোগ্য।

আর উল্টো দিকের ভুলটিও আছে: সবকিছু reduce দিয়ে করা। reduce এত শক্তিশালী যে map, filter, find — সবই এটি দিয়ে লেখা যায়। কিন্তু arr.reduce((acc, x) => x > 0 ? [...acc, x * 2] : acc, []) পড়তে যত সময় লাগে, arr.filter((x) => x > 0).map((x) => x * 2) পড়তে তার অর্ধেকও লাগে না — আর প্রথমটি প্রতিবার নতুন array কপি করে বলে বড় তালিকায় আসলে অনেক বেশি ধীর। নিয়ম: যে method-এর নাম আপনার উদ্দেশ্য বলে, সেটি ব্যবহার করুন। reduce রাখুন যখন সত্যিই অনেক থেকে একটি মান বানাচ্ছেন — যোগফল, গোনা, group, সবচেয়ে বড়টি।

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

“অর্ডার তালিকা থেকে জেলাভিত্তিক মোট আয় বের করো” — AI-কে বললে কয়েক সেকেন্ডে কোড পাবেন। প্রায়ই তা চলবেও। কিন্তু array নিয়ে AI-এর কয়েকটি নির্দিষ্ট অভ্যাস আছে, যা ছোট টেস্ট ডেটায় ধরা পড়ে না, পড়ে বাস্তব ডেটায়:

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

• প্রতিটি sort-এ comparator আছে, আর সংখ্যার তালিকায় ৯, ১০, ১০০ দিয়ে চালিয়ে দেখেছি
• পাওয়া array-তে sort, reverse, splice, push নেই — দরকার হলে toSorted বা কপি
• প্রতিটি reduce-এ initial value আছে, আর খালি array দিয়ে চালিয়েছি
• নতুন array বানাতে forEach + push নয়, map/filter ব্যবহার হয়েছে
• কোনো built-in বা লাইব্রেরি function সরাসরি callback হিসেবে পাঠানো হয়নি (map(parseInt)-এর মতো)
• Block body-র callback-এ return আছে (map থেকে undefined-এর তালিকা আসছে না)
• ব্যবহৃত নতুন feature (toSorted, Object.groupBy) আমার লক্ষ্য পরিবেশে চলে