array — তৈরি, বদলানো আর খোঁজা

১ · array কী — ক্রমে সাজানো মানের তালিকা, আর ভেতরে একটি object

আগের পর্বে object দেখেছেন — নাম দিয়ে মান রাখা: student.name, student.roll. কিন্তু অনেক সময় নাম দরকার নেই, দরকার ক্রম: বাজারের তালিকা, ক্লাসের সবার নম্বর, ডাক্তারের চেম্বারে অপেক্ষার সারি। “প্রথমটি”, “তৃতীয়টি”, “শেষটি” — এভাবেই আমরা এদের কথা বলি।

এর জন্য array. Array হলো ক্রমে সাজানো মানের একটি তালিকা, যার প্রতিটি মানের একটি সংখ্যা-ঠিকানা থাকে — index. প্রথম মানের index 0, দ্বিতীয়টির 1, আর শেষটির length - 1.

JavaScript-এর array তিনটি দিক থেকে C বা Java-র array থেকে আলাদা:

২ · array তৈরি — literal, Array.of, Array.from আর new Array-এর ফাঁদ

প্রতিদিনের কাজে array তৈরির উপায় একটাই — array literal, অর্থাৎ বর্গবন্ধনীর ভেতরে কমা দিয়ে মান: [], [320, 145, 199]. শেষ মানের পরে একটি বাড়তি কমা (trailing comma) রাখাও বৈধ — লম্বা তালিকায় নতুন লাইন যোগ করা সহজ হয়। কিন্তু আরও তিনটি উপায় জানা দরকার, কারণ এদের একটি বিখ্যাত ফাঁদ:

Array constructor-এর আচরণ argument-এর সংখ্যার ওপর নির্ভর করে: একটি number দিলে সেটি “দৈর্ঘ্য”, বেশি দিলে “উপাদান”। এই দ্বৈত আচরণ গোলমেলে বলেই ES2015-এ Array.of এসেছে — যা দেবেন, সবসময় উপাদান। আর Array.from দুটি কাজ একসাথে করে: যেকোনো iterable বা array-র মতো জিনিস থেকে আসল array বানায়, আর দ্বিতীয় argument হিসেবে একটি function দিলে প্রতিটি উপাদান বানানোর সময়ই রূপান্তর করে নেয়।

ফাঁকা ঘর (hole) — new Array(3).map(...) কেন কিছুই করে না

ধরুন ১ থেকে ৫ পর্যন্ত রোল নম্বরের array চান। অনেকে লেখেন:

const rolls = new Array(5).map((_, i) => i + 1);
console.log(rolls);   // [ <5 empty items> ] — Node-এর আউটপুট

প্রত্যাশা ছিল [ 1, 2, 3, 4, 5 ]. কেন হলো না? new Array(5) শুধু length 5 বসায় — "0" থেকে "4" নামের কোনো property তৈরি করে না। এমন না-থাকা ঘরকে বলে hole, আর যে array-তে hole আছে তাকে sparse array. map, forEach, filter-এর মতো পুরোনো method hole-গুলো টপকে যায় — callback একবারও ডাকে না। সমাধান দুটি:

• Array.from({ length: 5 }, (_, i) => i + 1) — সবচেয়ে পরিষ্কার; প্রতিটি ঘর আসল মান পায়।
• new Array(5).fill(0) — আগে প্রতিটি ঘর ভরে দিন, তারপর map.

৩ · index, length আর at() — পড়া, লেখা আর কেটে ছোট করা

Index দিয়ে পড়া আর লেখা দুটোই বর্গবন্ধনীতে: cart[0] পড়ে প্রথম পণ্য, cart[1] = 'মসুর ডাল' দ্বিতীয়টি বদলে দেয়। সীমার বাইরে পড়লে — cart[10] — কোনো error নয়, undefined. এই “চুপচাপ undefined” সুবিধাও, বিপদও: পর্ব ১২-এর off-by-one বাগ ঠিক এখান থেকেই NaN বানায়।

length — শুধু পড়ার নয়, লেখারও

length সবসময় “সবচেয়ে বড় index + 1”. এটি নিজে থেকে বাড়ে, আর আপনি নিজেও এতে মান বসাতে পারেন:

const a = [1, 2, 3, 4, 5];
a.length = 2;        // a → [ 1, 2 ]          — শেষের তিনটি মুছে গেল
a[5] = 9;            // a → [ 1, 2, <3 empty items>, 9 ], length 6
a.length = 0;        // a → []                — array খালি করার চেনা কৌশল

length ছোট করলে বাড়তি উপাদান সত্যিই মুছে যায় — ফেরত আনা যায় না। আর সীমার অনেক বাইরে লিখলে মাঝখানে hole তৈরি হয়। length-এর সর্বোচ্চ মান 2³² − 1 (৪২৯ কোটির কিছু বেশি); তার বেশি চাইলে RangeError: Invalid array length.

at() — শেষ থেকে গোনা

শেষ উপাদান চাই? পুরোনো উপায় arr[arr.length - 1] — লম্বা আর ভুলপ্রবণ। Python-এর অভ্যাসে arr[-1] লিখলে আসে undefined, কারণ JavaScript-এ -1 একটি সাধারণ property-নাম — arr[-1] = 'x' লিখলে "-1" নামের একটি property তৈরি হয়, length বদলায় না। তাই ES2022-এ যুক্ত হয়েছে at(): [10, 20, 30].at(-1) দেয় 30, at(-2) দেয় 20, at(0) দেয় 10. String-এও at() আছে।

Hole আর delete — কেন delete arr[i] নয়

Array থেকে একটি উপাদান মুছতে delete arr[1] লিখলে উপাদানটি যায়, কিন্তু ঘরটি থেকে যায় ফাঁকা হয়ে: [1, 2, 3] হয় [ 1, <1 empty item>, 3 ], length তখনো 3. পরের উপাদানগুলো সরে আসে না। ফাঁকা ঘর পড়লে undefined আসে, কিন্তু forEach সেটি টপকে যায়, for…of টপকায় না — একেক জায়গায় একেক আচরণ। উপাদান মুছতে হলে splice বা toSpliced (পরের দুই অংশ)। আধুনিক engine hole-যুক্ত array-কে ধীর পথে চালায় (ভাবনার প্রশ্ন ১), তাই hole এড়িয়ে চলাই নিয়ম।

৪ · যোগ আর বাদ — push, pop, shift, unshift, splice, slice

একটি অনলাইন দোকানের কার্ট আর একটি ডাক্তারের চেম্বারের অপেক্ষার তালিকা — দুটোই array, কিন্তু কাজের ধরন আলাদা। কার্টে শেষে পণ্য যোগ হয়, যেকোনো জায়গা থেকে বাদ যায়। অপেক্ষার তালিকায় নতুন রোগী দাঁড়ান পেছনে, ডাক পান সামনের জন। প্রতিটি কাজের জন্য আলাদা method:

লক্ষ করুন push নতুন array নয়, নতুন দৈর্ঘ্য ফেরত দেয়। তাই cart = cart.push('চিনি') লিখলে cart হয়ে যায় একটি সংখ্যা — চেনা ভুল।

শেষ প্রান্ত দ্রুত, শুরুর প্রান্ত ধীর

push/pop শুধু শেষ প্রান্তে কাজ করে — অন্য কোনো উপাদান সরাতে হয় না। এই জোড়া দিয়ে একটি stack (শেষে ঢোকে, শেষেরটা আগে বেরোয়) বানানো যায়। unshift/shift শুরুতে কাজ করে, তাই বাকি সব উপাদানের index এক ঘর সরাতে হয় — তালিকা যত বড়, তত বেশি কাজ (সাধারণভাবে O(n)). অপেক্ষার তালিকা — একটি queue — push দিয়ে পেছনে যোগ আর shift দিয়ে সামনের জনকে ডাকা — ছোট তালিকায় একদম ঠিক। Engine কিছু ক্ষেত্রে shift-কে কৌশলে দ্রুত করে, কিন্তু লাখো উপাদানের queue-তে তার ওপর ভরসা না করে সামনের index একটি আলাদা variable-এ রাখুন, বা একটি আসল queue কাঠামো ব্যবহার করুন (DSA কোর্সে বিস্তারিত)।

splice — যেকোনো জায়গায় কাটা আর বসানো

splice array-র সবচেয়ে শক্তিশালী — আর সবচেয়ে ভুল-বোঝা — method. তিন অংশ: কোথা থেকে (start), কয়টি বাদ (deleteCount), আর সেখানে কী বসবে (...items). একটি বাসের সারির আসন-কোড দিয়ে ধাপে ধাপে দেখুন:

1const row = ['A', 'B', 'C', 'D', 'E'];2const out = row.splice(1, 2, 'X', 'Y', 'Z');3console.log(row, out);

slice — নাম কাছাকাছি, কাজ উল্টো

slice(start, end) একটি অংশের কপি দেয়, আসল array ছোঁয় না। end-এর ঘরটি বাদ থাকে: [1, 2, 3, 4].slice(1, 3) দেয় [ 2, 3 ]. ঋণাত্মক index চলে — slice(-2) দেয় শেষ দুটি। কোনো argument না দিলে slice() পুরো array-র কপি। মনে রাখার কৌশল: splice-এ বাড়তি “p” — সে array-তে হাত দেয় (permanent change). আর concat কয়েকটি array জোড়া লাগিয়ে নতুন array দেয়: [5, 1].concat([7], 8) → [ 5, 1, 7, 8 ]; আধুনিক কোডে একই কাজ প্রায়ই spread দিয়ে — [...a, ...b] (পর্ব ১৭)।

৫ · বদলায়, নাকি নতুন দেয় — sort বনাম toSorted আর ES2023-এর কপি-method

ধরুন একটি দোকানের অ্যাপে পণ্যের দামের তালিকা আছে, যোগ করার ক্রমে। এক জায়গায় তালিকাটি যেমন আছে তেমন দেখাতে হবে, আরেক জায়গায় কম দাম থেকে বেশি। সাজাতে sort() ডাকলেন — আর হঠাৎ প্রথম জায়গার ক্রমও বদলে গেল। কেন? ধাপে ধাপে মেমরির ছবিতে দেখুন:

const prices = [320, 145, 199];
const shown  = prices;   // "যোগ করার ক্রমে" দেখানোর তালিকা

variable            heap (আসল array)
prices ──┐
         ├──▶ #1 [320, 145, 199]
shown  ──┘

prices.sort();

prices ──┐
         ├──▶ #1 [145, 199, 320]   ← নতুন array নয়, #1 নিজেই
shown  ──┘

prices.sort() === prices   // true — সেই একই array ফেরত

console.log(shown);
[ 145, 199, 320 ]
// "যোগ করার ক্রমে" তালিকা আর যোগ করার ক্রমে নেই।
// কোনো error নেই, কোনো সতর্কবার্তা নেই।

// আবার শুরু থেকে: prices = shown = #1 [320, 145, 199]
const cheapFirst = prices.toSorted();

prices ──┐
         ├──▶ #1 [320, 145, 199]       ← অক্ষত
shown  ──┘
cheapFirst ──▶ #2 [145, 199, 320]    ← নতুন

বদলায় (in place)        নতুন array দেয় (ES2023)
arr.sort()               arr.toSorted()
arr.reverse()            arr.toReversed()
arr.splice(i, n, …)      arr.toSpliced(i, n, …)
arr[i] = v               arr.with(i, v)

এবার সব একসাথে চালিয়ে দেখুন — কার্টে যোগ-বাদ, সাজানো কপি, id দিয়ে একটি পণ্য বাদ দেওয়া, আর অপেক্ষার তালিকা:

const cart = ['চাল', 'ডাল', 'তেল'];
cart.push('চিনি');                     // শেষে যোগ — cart বদলাল
const removed = cart.splice(1, 1);     // index 1 থেকে ১টি বাদ
console.log(cart, removed);

const sorted = cart.toSorted();        // নতুন array — cart অক্ষত
console.log(cart, sorted, cart === sorted);

const items = [{ id: 7, name: 'চাল' }, { id: 9, name: 'তেল' }];
const i = items.findIndex(it => it.id === 9);
const next = items.toSpliced(i, 1);    // id 9 ছাড়া নতুন array
console.log(items.length, next.length, next[0] === items[0]);

const queue = ['রহিম', 'করিম'];         // চেম্বারের অপেক্ষার তালিকা
queue.push('সুমি');                     // নতুন রোগী পেছনে
console.log(queue.shift(), queue);      // সামনের জন ডাক পেলেন

৬ · খোঁজা — indexOf, includes, find, some, every আর NaN-এর রহস্য

খোঁজার প্রশ্ন তিন রকম, আর প্রতিটির জন্য আলাদা method:

প্রথম দলটি একটি নির্দিষ্ট মান খোঁজে। বাকিরা একটি function নেয় — যা প্রতিটি উপাদান দেখে true/false বলে। হ্যাঁ/না উত্তর দেওয়া এমন function-কে বলে predicate; এটি একটি callback, যাকে method নিজে প্রতিটি উপাদানের জন্য ডাকে। find, some, every উত্তর পাওয়ামাত্র থামে — বাকি উপাদান দেখে না। findLast আর findLastIndex ES2023-এ যুক্ত — শেষ থেকে খোঁজে। Callback-নির্ভর method-এর পুরো জগৎ (map, filter, reduce) পর্ব ১৬-এ।

খেয়াল করুন: every খালি array-তে true দেয় — “খালি ক্লাসের সবাই পাস করেছে” কথাটি গণিতের ভাষায় সত্য, কারণ ফেল করা কাউকে দেখানো যায় না। এতে বাস্তব বাগ হয়: “সব পণ্য স্টকে আছে?” প্রশ্নে খালি কার্টও true পায়।

indexOf কেন NaN খুঁজে পায় না

পর্ব ১০-এ দেখেছেন, NaN === NaN হলো false — NaN নিজের সমানও নয়। indexOf তুলনা করে === দিয়ে, তাই [NaN].indexOf(NaN) দেয় -1. ES2016-এ আসা includes অন্য একটি তুলনা ব্যবহার করে — SameValueZero, যেখানে NaN নিজের সমান — তাই [NaN].includes(NaN) হলো true. সেন্সর রিডিং বা হিসাবের ফলের তালিকায় “কোনো ভুল (NaN) মান আছে কি?” জানতে তাই includes, বা findIndex(Number.isNaN). দুই তুলনার এই অদ্ভুত সহাবস্থানের ইতিহাস ভাবনার প্রশ্ন ৩-এ।

Array.isArray — array কি না, নিশ্চিত হওয়ার একমাত্র ভরসাযোগ্য উপায়

typeof [] দেয় 'object' — কোনো কাজের নয়। arr instanceof Array সাধারণত চলে, কিন্তু অন্য iframe-এ তৈরি array-তে false দেয়, কারণ প্রতিটি iframe-এর নিজের আলাদা Array আছে। ES5 (২০০৯) থেকে আছে Array.isArray(x) — সব ক্ষেত্রে ঠিক উত্তর দেয়।

এবার ক্লাসের নম্বরের তালিকায় খোঁজা চালিয়ে দেখুন — লুপ দিয়ে টপার, মান খোঁজা, শর্তে খোঁজা আর NaN-এর পার্থক্য:

const marks = [72, 88, 65, 88, 91, 59];

let best = 0;                               // টপারের index
for (let i = 1; i < marks.length; i++) {
  if (marks[i] > marks[best]) best = i;
}
console.log('টপার: রোল', best + 1, '— নম্বর', marks[best]);

console.log(marks.indexOf(88), marks.lastIndexOf(88), marks.includes(100));
console.log(marks.find(m => m < 60), marks.findIndex(m => m > 90));
console.log(marks.findLast(m => m > 80), marks.some(m => m < 33), marks.every(m => m >= 33));

const readings = [12, NaN, 15];             // সেন্সরের রিডিং
console.log(readings.indexOf(NaN), readings.includes(NaN));
console.log(Array.isArray(marks), typeof marks);

৭ · array একটি reference — ভাগাভাগি, === আর কপি

পর্ব ১৪-এ object-এর ক্ষেত্রে দেখেছেন, variable-এ object নিজে থাকে না, থাকে তার reference — heap-এ রাখা আসল জিনিসের ঠিকানা। Array-ও object, তাই একই নিয়ম। এর সবচেয়ে চমকে দেওয়া ফল: = দিয়ে “কপি” করলে আসলে কপি হয় না। ধাপে ধাপে দেখুন:

1const a = ['চা'];2const b = a;3b.push('বিস্কুট');4const c = [...a];5c.push('কেক');6console.log(a, c, a === b, a === c);

কপি কতটা গভীর? — shallow copy

[...a], slice(), Array.from(a), এমনকি toSorted() — সবাই shallow copy বানায়: শুধু উপরের স্তরের তালিকাটি নতুন, ভেতরের object বা array আগের মতোই ভাগাভাগি। const m = [[1, 2], [3, 4]]; const c = [...m]; c[0].push(9); — এরপর m হয় [ [ 1, 2, 9 ], [ 3, 4 ] ] (Node-এ চালিয়ে দেখা)। অংশ ৫-এর কোডে next[0] === items[0] সত্য হওয়ার কারণও এটাই। পুরো গভীর কপির উপায় structuredClone — পর্ব ১৯-এ।

৮ · join, flat, 2D array, array-like আর typed array

Array থেকে লেখা — join আর toString

join(sep) সব উপাদান string-এ বদলে মাঝে sep বসিয়ে জোড়া দেয়: ['চাল', 'ডাল'].join(', ') → 'চাল, ডাল'. sep না দিলে কমা। null আর undefined হয়ে যায় খালি লেখা: [1, null, undefined, 2].join('-') → '1---2'. toString() হলো join(',')-এর মতো, আর template literal বা +-এ array বসালে এটিই ডাকা হয় — তাই [] + [] হলো খালি string (পর্ব ০৬-এর coercion).

ভাঁজ খোলা — flat আর flatMap

Array-র ভেতরে array থাকলে flat() এক স্তর খুলে দেয়: [1, [2, [3, [4]]]].flat() → [ 1, 2, [ 3, [ 4 ] ] ]; সব স্তর খুলতে flat(Infinity) → [ 1, 2, 3, 4 ]. flatMap(fn) প্রতিটি উপাদান থেকে একটি array বানিয়ে এক স্তর খুলে দেয় — যেমন প্রতিটি অর্ডার থেকে তার পণ্যগুলোর একটি লম্বা তালিকা। দুটিই ES2019 থেকে, আর নতুন array দেয়। flatMap ভালো করে বুঝতে map জানা দরকার — পর্ব ১৬।

2D array — বাসের আসন-নকশা

একটি দূরপাল্লার বাসে সারি আর কলামে আসন। প্রতিটি সারি একটি array, আর পুরো বাস সারিগুলোর array — একে বলে multidimensional array. seats[r][c] মানে আগে সারি, তারপর কলাম:

// null = খালি আসন, নাম = বুক করা
const seats = [
  ['রহিম', null,   'সুমি'],     // সারি 0 (A)
  [null,   'করিম', null  ],     // সারি 1 (B)
];
seats[1][0] = 'নীলা';           // B1 আসন বুক
const free = seats.flat().filter(s => s === null).length;
console.log(free);               // প্রত্যাশিত আউটপুট: 2

// নতুন খালি বাস: ১০ সারি × ৪ কলাম — প্রতিটি সারি আলাদা array
const bus = Array.from({ length: 10 }, () => new Array(4).fill(null));

শেষ লাইনটি লক্ষ করুন: new Array(10).fill(new Array(4).fill(null)) লিখলে দশটি সারিই একই array হতো — একজন A1 বুক করলে সব সারির প্রথম আসন বুক দেখাত (অংশ ২-এর সতর্কবার্তা)। গণিতের matrix, খেলার বোর্ড (দাবা, লুডু), বা spreadsheet-এর ঘর — সব একই ছকে। অনেক বড় সংখ্যার matrix-এ (ছবি প্রক্রিয়া, মেশিন লার্নিং) array-র ভেতরে array ধীর; সেখানে একটি লম্বা typed array-তে r * cols + c index ব্যবহার করা হয় — নিচে দেখুন।

Array-র মতো, কিন্তু array নয় — array-like

কিছু জিনিসের length আর সংখ্যা-index আছে, কিন্তু array-র method নেই — একে বলে array-like. দুটি চেনা উদাহরণ: পুরোনো ধাঁচের function-এর arguments object (পর্ব ১৩), আর পাতা থেকে খুঁজে পাওয়া element-এর তালিকা NodeList (document.querySelectorAll('li'), পর্ব ৩৭)। Array.isArray(arguments) হলো false, তাই arguments.includes নেই। সমাধান — Array.from(x) বা [...x] দিয়ে আসল array বানানো, তারপর যা খুশি। Array.from এমন object-ও নেয় যা iterable নয়, শুধু length আছে — অংশ ২-এর { length: 5 } কৌশল এই কারণেই কাজ করে।

Typed array — এক টাইপের সংখ্যা, নির্দিষ্ট আকার, দ্রুত

সাধারণ array যেকোনো কিছু রাখে, বাড়ে-কমে — এই নমনীয়তার দাম গতি আর মেমরি। ছবি, অডিও, ফাইলের bytes, 3D গ্রাফিক্স বা WebAssembly-র মতো কাজে লাগে লাখো একই ধরনের সংখ্যা, পাশাপাশি মেমরিতে। এর জন্য typed array: Uint8Array (০–২৫৫), Int32Array, Float64Array ইত্যাদি। এদের আকার স্থির, প্রতিটি ঘরে নির্দিষ্ট টাইপ — new Uint8Array([300, 2])-এ 300 ঢোকে না, মোড়ানো হয়ে 44 হয় (300 − 256). ভেতরের কাঁচা মেমরিটির নাম ArrayBuffer. প্রতিদিনের অ্যাপে এদের দরকার কম, কিন্তু Node-এর Buffer (পর্ব ৪৯), fetch-এ ফাইল নামানো বা canvas-এর pixel — সবখানে এরাই। ইতিহাস ভাবনার প্রশ্ন ৪-এ।

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

“কার্ট থেকে একটি পণ্য বাদ দেওয়ার function লিখে দাও” — AI মুহূর্তে লিখে দেবে, আর একটি সাধারণ পরীক্ষায় চলবেও। কিন্তু array-র বাগ প্রায়ই লুকিয়ে থাকে কে কোন array বদলাল সেই প্রশ্নে, আর সীমানায় — না-পাওয়া id, খালি তালিকা, NaN. পুরোনো টিউটোরিয়াল থেকে শেখা AI-এর চেনা ভুলগুলো:

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

• প্রতিটি method-এর পাশে লিখে দেখেছি — বদলায়, নাকি নতুন দেয়? আর ফেরত দেয় কী (length, উপাদান, বাদ পড়াগুলো, নতুন array)?
• Function-এ পাওয়া কোনো array-তে push, sort, reverse, splice বা arr[i] = নেই — বা থাকলে সেটি ইচ্ছাকৃত ও নথিভুক্ত
• indexOf/findIndex-এর -1 আর find-এর undefined — “না পেলে” অবস্থা সামলানো আছে
• NaN খোঁজায় includes বা Number.isNaN; কোথাও delete arr[i] বা new Array(n).map নেই
• “কপি” মানে কতটা গভীর বুঝে নিয়েছি — ভেতরের object বদলালে আসলটিও বদলাবে কি না
• খালি array, এক উপাদানের array আর না-থাকা মান — তিন সীমানায় চালিয়ে দেখেছি