অপারেটর, truthy/falsy, ?? আর ?. — মান মিলিয়ে নতুন মান

১ · অপারেটর কী — মান মিলিয়ে নতুন মান

চায়ের দোকানে হিসাব করার সময় দোকানদার বলেন, “দুই কাপ চা ১৫ টাকা করে, সাথে একটা বিস্কুট ১০ টাকা।” মাথায় হিসাব চলে 2 * 15 + 10. এখানে তিনটি সংখ্যা আছে, আর দুটি চিহ্ন — * আর +. চিহ্নগুলো সংখ্যাগুলোকে মিলিয়ে একটি নতুন মান বানায়: ৪০।

প্রোগ্রামিংয়ে এই চিহ্নগুলোকে বলে operator, আর যাদের ওপর কাজ করে তাদের বলে operand. Operator আর operand মিলে তৈরি হয় একটি expression — এমন কোড, যা হিসাব করলে একটি মান পাওয়া যায়। পুরো পর্বের মূল কথা একটি বাক্যে: প্রতিটি operator কিছু মান নেয় আর একটি নতুন মান ফেরত দেয়। কোন মান ফেরত দেয়, সেটিই এই পর্বে খুঁটিয়ে দেখব।

Operand কয়টি লাগে, সেই হিসাবে operator তিন রকম:

বেশিরভাগ ভাষায় logical অপারেটর (&&, ||) সবসময় true বা false দেয়। JavaScript এখানে আলাদা: এরা ফেরত দেয় নিজেদের একটি operand, আর কোনটি দেবে তা ঠিক হয় সেই মান “truthy” না “falsy” তা দেখে। এই একটি নিয়ম থেকেই এসেছে JavaScript-এর অনেক জনপ্রিয় কৌশল — আর অনেক বাগও। তাই আধুনিক JavaScript-এ দুটি নতুন অপারেটর যোগ হয়েছে, ?? আর ?. — অনুপস্থিত ডেটা নিরাপদে সামলানোর জন্য।

২ · গাণিতিক অপারেটর — যোগ-বিয়োগ থেকে ভাগশেষ আর ঘাত

প্রথমে চেনা জিনিস। JavaScript-এ সংখ্যার হিসাবের জন্য সাতটি মূল operator:

খেয়াল করুন, 7 / 2 দেয় 3.5, C বা Java-র মতো 3 নয়। JavaScript-এ সাধারণ সংখ্যার একটিই টাইপ — number, যা ভেতরে ৬৪-বিট floating-point (দশমিক বিন্দুওয়ালা) সংখ্যা। পূর্ণসংখ্যার ভাগ চাইলে লিখতে হয় Math.trunc(7 / 2). দশমিক সংখ্যার কারণে 0.1 * 3 কেন 0.30000000000000004 দেয়, সেই গল্প পর্ব ১০-এ।

+ দুটি কাজ করে — যোগ আর string জোড়া। কোনো একটি operand string হলেই জোড়ার কাজ জেতে, তাই "3" + 1 হয় "31". কিন্তু -, *, / শুধু সংখ্যা চেনে, তাই string-কে সংখ্যায় বদলে নেয়। পর্ব ০৬-এর এই ফাঁদটি ফর্মের ইনপুটে সবচেয়ে বেশি ধরা পড়ে — ইনপুট বক্সের মান সবসময় string.

ভাগশেষ আর ঋণাত্মক সংখ্যা

% দিয়ে আমরা জোড়-বিজোড় যাচাই করি (n % 2 === 0), বা ঘড়ির হিসাব করি। কিন্তু ঋণাত্মক সংখ্যায় একটি চমক আছে: JavaScript-এ %-এর ফলের চিহ্ন হয় ভাজ্যের (বাম দিকের সংখ্যার) মতো।

-7 % 3          // -1   (গণিতের "mod" হলে 2 হতো)
7 % -3          // 1
((-7 % 3) + 3) % 3   // 2  — সবসময় ধনাত্মক ভাগশেষ চাইলে
5.5 % 2         // 1.5  — দশমিকেও চলে

ঘাত — **, আর দুটি বিশেষ নিয়ম

ES2016-এর আগে ঘাতের জন্য লিখতে হতো Math.pow(2, 10); এখন 2 ** 10. দুটি নিয়ম মনে রাখুন। প্রথমত, ** ডান দিক থেকে হিসাব হয়: 2 ** 3 ** 2 মানে 2 ** (3 ** 2) = 2 ** 9 = 512, 64 নয় — গণিতে 2³² যেভাবে পড়ি। দ্বিতীয়ত, -2 ** 2 লিখলে ফল নয়, error আসে:

SyntaxError: Unary operator used immediately before exponentiation expression. Parenthesis must be used to disambiguate operator precedence

এটি V8-এর (Chrome, Edge, Node.js) বার্তা। গণিতে −2² মানে −4, কিন্তু অনেকে পড়েন (−2)² = 4. এই দ্বিধা এড়াতে JavaScript আপনাকে বন্ধনী দিয়ে স্পষ্ট করতে বাধ্য করে: (-2) ** 2 → 4, বা -(2 ** 2) → -4. পঞ্চম ভাবনার প্রশ্নে এর ইতিহাস আছে।

++ আর -- — আগে না পরে

i++ (postfix) আগে পুরোনো মান ফেরত দেয়, তারপর বাড়ায়। ++i (prefix) আগে বাড়ায়, তারপর নতুন মান দেয়। let n = 5; হলে n++ দেয় 5 (এখন n = 6), তারপর ++n দেয় 7. আলাদা লাইনে একা লিখলে (i++;) দুটির কোনো পার্থক্য নেই। সমস্যা হয় যখন একই expression-এ মিশিয়ে লেখা হয় — arr[i++] = i জাতীয় কোড পড়তে কঠিন, এড়িয়ে চলুন। অনেক style guide তাই i += 1 লেখার পরামর্শ দেয়।

৩ · Assignment আর তুলনা — মান বসানো, মান মেলানো

= গণিতের “সমান” নয় — এটি “ডান দিকের মান বাম দিকের variable-এ বসাও”। আর এটিও একটি expression: x = 5 নিজে 5 ফেরত দেয়। এজন্যই a = b = 0 কাজ করে — ডান দিক থেকে: আগে b = 0, তার ফল 0 যায় a-তে। আবার এজন্যই if (x = 5) লিখলে (===-এর বদলে ভুল করে) কোনো error আসে না — মান বসে, আর শর্ত সবসময় সত্য হয়।

কোনো variable-এর নিজের মানের সাথে হিসাব করে আবার তাতেই রাখার জন্য আছে compound assignment:

তুলনা — < > <= >=

তুলনার অপারেটর সবসময় true বা false দেয়। সংখ্যায় এরা যা আশা করেন তাই করে। আসল মজা string-এ। দুটি string তুলনা হয় অক্ষর ধরে ধরে, প্রতিটি অক্ষরের Unicode নম্বর দেখে — অভিধানের মতো, কিন্তু অভিধানের নিয়মে নয়। আরও নির্দিষ্টভাবে, JavaScript string-কে UTF-16 code unit-এর সারি হিসেবে রাখে, আর তুলনা হয় সেই নম্বরগুলো দিয়ে (বিস্তারিত পর্ব ০৯-এ)।

শিক্ষার্থীর রোল নম্বর বা দাম string হিসেবে এলে (যেমন JSON বা ফর্ম থেকে) সাজানো ভুল হয় — "100" আসে "20"-এর আগে। তাই তুলনার আগে Number() দিয়ে সংখ্যায় বদলে নিন। আর মানুষের পড়ার মতো করে নাম সাজাতে (বড়-ছোট হাতের অক্ষর বা বাংলা বর্ণমালার নিয়মে) localeCompare ব্যবহার করুন — পর্ব ০৯ আর ২০-এ দেখবেন।

ভিন্ন টাইপের মান তুলনা করলে JavaScript সাধারণত দুটিকেই সংখ্যায় বদলায়: null >= 0 হয় true (null → 0), কিন্তু undefined > -1 হয় false (undefined → NaN, আর NaN-এর সাথে প্রতিটি তুলনা false). আরেকটি ক্লাসিক: 1 < 2 < 3 → true, কিন্তু 3 > 2 > 1 → false. কারণ বাম থেকে হিসাব: 3 > 2 = true, তারপর true > 1 মানে 1 > 1 = false. শিকল করা তুলনা JavaScript-এ গণিতের মতো কাজ করে না; লিখুন a > b && b > c.

৪ · Truthy আর falsy — “হ্যাঁ” আর “না”-এর বাইরের মান

if-এর শর্তে আপনি শুধু true/false নয়, যেকোনো মান দিতে পারেন: if (name), if (cart.length), if (user). তখন JavaScript মানটিকে মনে মনে boolean-এ বদলে নেয়। যে মান false-এ বদলায় তাকে বলে falsy, আর যে মান true-এ বদলায় তাকে truthy.

সুখবর হলো, falsy মানের তালিকা ছোট আর নির্দিষ্ট — ঠিক ৮টি। এগুলো মুখস্থ রাখুন; বাকি সব truthy.

যেকোনো মানের truthiness নিজে দেখতে Boolean(v) বা দুবার “না” — !!v লিখুন: !!"0" → true, !!NaN → false. একক ! মানটিকে boolean-এ বদলে উল্টে দেয়; দুবার দিলে শুধু বদলটুকু থাকে।

৫ · &&, || আর ! — operand ফেরত, আর short-circuit

এবার পর্বের সবচেয়ে গুরুত্বপূর্ণ নিয়ম। JavaScript-এর logical অপারেটর এভাবে কাজ করে:

তাই "রহিম" || "অতিথি" দেয় "রহিম", true নয়। আর 0 && "কিছু" দেয় 0, false নয়। if-এর ভেতরে এই পার্থক্য চোখে পড়ে না, কারণ if ফলটিকে আবার truthy/falsy হিসেবে দেখে। কিন্তু ফলটি কোনো variable-এ রাখলে বা পাতায় দেখালে পার্থক্য স্পষ্ট। শুধু ! সবসময় সত্যিকারের boolean দেয়।

দ্বিতীয় অংশটিও সমান গুরুত্বপূর্ণ: short-circuit evaluation. বাম দিক দেখেই উত্তর জানা হয়ে গেলে ডান দিকের expression চালানোই হয় না। “অথবা”-তে একটি সত্য পেলেই যথেষ্ট; “এবং”-এ একটি মিথ্যা পেলেই যথেষ্ট। এর সবচেয়ে কাজের ব্যবহার — নেই এমন object-এর property পড়ার আগে পাহারা বসানো:

1let user = null;2const name = user && user.name;3console.log(name);4user = { name: "সুমি" };5console.log(user && user.name);

Short-circuit-এর আরও কয়েকটি পরিচিত ব্যবহার: isLoggedIn && showDashboard() — লগইন থাকলেই function চলবে; callback && callback() — callback দেওয়া থাকলেই ডাকা হবে। এগুলো চলে, তবে if দিয়ে লিখলে সাধারণত পড়তে সহজ হয়। React-এর মতো framework-এ {count && <List />} লেখার একটি বিখ্যাত বাগ আছে: count = 0 হলে পাতায় একটি “0” দেখায় — কারণ && falsy বাম দিক 0-কেই ফেরত দেয়।

বাস্তব উদাহরণ — ছাড় পাবেন কে?

একটি অনলাইন দোকানের নিয়ম: “সদস্য হলে এবং কেনাকাটা ৫০০ টাকা বা বেশি হলে ছাড়; অথবা কুপন থাকলে যেকোনো অবস্থায় ছাড়।”

const isMember  = true;
const total     = 450;
const hasCoupon = false;

const eligible = (isMember && total >= 500) || hasCoupon;
// (true && false) || false  →  false || false  →  false

৬ · ডিফল্ট মান — ||-এর বাগ আর ??-এর সমাধান

বহু বছর ধরে JavaScript-এ ডিফল্ট মান দেওয়ার প্রচলিত কৌশল ছিল ||: const name = input || "অতিথি"; — input ফাঁকা হলে “অতিথি”। কাজ করে, যতক্ষণ না বৈধ মানটি নিজেই falsy হয়।

একটি ই-কমার্স সাইট ভাবুন। দোকানদার প্রতিটি পণ্যের ডেলিভারি চার্জ ঠিক করতে পারেন; না দিলে ডিফল্ট ৬০ টাকা। একটি পণ্যে তিনি ইচ্ছে করে লিখলেন 0 — ফ্রি ডেলিভারি। কোডে আছে const charge = product.deliveryCharge || 60;. ফল: ক্রেতার কাছ থেকে ৬০ টাকা কাটা হলো! কারণ 0 falsy, আর ||-এর চোখে falsy মানে “নেই”।

এই সমস্যার জন্য ES2020-এ এসেছে nullish coalescing অপারেটর ??. a ?? b মানে: a যদি null বা undefined হয় তবেই b, নইলে a. এই দুটি মানকে একসাথে বলে nullish — “সত্যিই কোনো মান নেই”। 0, "", false — এরা মান, তাই ?? এদের রেখে দেয়।

|| তাহলে কি বাতিল? না — যখন আপনি সত্যিই ফাঁকা string-কেও “নেই” ধরতে চান, তখন ||-ই ঠিক। যেমন নাম: displayName || "অতিথি" — কেউ নামের ঘর ফাঁকা রেখে দিলে “অতিথি” দেখানোই উচিত। প্রশ্নটা নিজেকে করুন: ০ বা ফাঁকা string কি এখানে বৈধ মান? হ্যাঁ হলে ??.

Logical assignment — &&=, ||=, ??= (ES2021)

ES2021 তিনটি সংক্ষিপ্ত রূপ যোগ করেছে, যা logical অপারেটর আর assignment মেলায় — logical assignment:

• x ??= 10 — x nullish হলে তবেই 10 বসাও। (প্রায় x ?? (x = 10))
• x ||= 10 — x falsy হলে তবেই 10 বসাও।
• x &&= f(x) — x truthy হলে তবেই নতুন মান বসাও।

এরাও short-circuit করে: শর্ত না মিললে assignment হয়ই না। তাই settings.theme ??= "light" আগে থেকে থাকা theme কখনো মুছবে না। এবার সব একসাথে চালিয়ে দেখুন:

const falsy = [false, 0, -0, 0n, "", null, undefined, NaN];
console.log(falsy.some(v => Boolean(v)));   // কোনোটি কি truthy?
console.log(Boolean("0"), Boolean("false"), Boolean([]), Boolean({}));

// || আর && operand ফেরত দেয়, true/false নয়
console.log("রহিম" || "অতিথি");
console.log("" || "অতিথি");
console.log(0 && "কখনো আসবে না");
console.log(5 && "দুটোই truthy");

// ডেলিভারি চার্জ: দোকানদার ইচ্ছে করে 0 দিয়েছেন
const userCharge = 0;
console.log("|| দিয়ে:", userCharge || 60, "| ?? দিয়ে:", userCharge ?? 60);

// logical assignment (ES2021)
const settings = { theme: null, volume: 0 };
settings.theme ??= "light";    // null ছিল → বসল
settings.volume ??= 50;        // 0 আছে → বদলাল না
settings.fontSize ||= 16;      // ছিলই না → বসল
console.log(settings);

৭ · Optional chaining ?. — ভেতরের ডেটা নিরাপদে পড়া

বাস্তব অ্যাপে ডেটা আসে API থেকে, আর সেটি প্রায়ই অসম্পূর্ণ। একটি ডেলিভারি অ্যাপে অর্ডারের ভেতরে ক্রেতা, ক্রেতার ভেতরে ঠিকানা, ঠিকানার ভেতরে জেলা। কোনো অর্ডারে ঠিকানাই দেওয়া নেই। সরাসরি order.customer.address.district লিখলে পাবেন:

TypeError: Cannot read properties of undefined (reading 'district')

আগে এর সমাধান ছিল লম্বা && শিকল: order && order.customer && order.customer.address && order.customer.address.district. ES2020 দিয়েছে optional chaining: ?. — বাম দিকের মান nullish হলে সেখানেই থেমে পুরো expression undefined দেয়, error নয়। আর ??-এর সাথে মিলিয়ে দেওয়া যায় ডিফল্ট:

const district = order?.customer?.address?.district ?? "অজানা";

?.-এর তিনটি রূপ আছে — property, function কল আর index:

• obj?.prop — property পড়া।
• obj?.[key] বা arr?.[0] — বন্ধনী দিয়ে property বা index পড়া।
• fn?.() বা obj.method?.() — function থাকলে তবেই ডাকো। দেখতে অদ্ভুত, কিন্তু কারণ আছে: a?.[0] না লিখে a?[0] লিখলে parser ternary-র ? : ভেবে বসত।

const orders = [
  { id: 1, customer: { address: { district: "রাজশাহী" } } },
  { id: 2, customer: { name: "সুমি" } },
  { id: 3 },
  null,
];

for (const order of orders) {
  const district = order?.customer?.address?.district ?? "অজানা";
  console.log(order?.id ?? "?", district);
}

const api = { getCoupon: undefined, items: [{ price: 250 }] };
console.log(api.getCoupon?.());      // function নেই → ডাকা হলো না
console.log(api.items?.[0]?.price);  // index দিয়ে পড়া
console.log(api.tags?.[0]);          // tags-ই নেই

৮ · আরও কিছু অপারেটর — ternary থেকে bitwise

Ternary — শর্ত ? ক : খ

JavaScript-এর একমাত্র তিন-operand অপারেটর: শর্ত truthy হলে প্রথম মান, নইলে দ্বিতীয়। const fee = isStudent ? 20 : 50; এটি একটি expression, তাই সরাসরি variable-এ বা template literal-এ বসানো যায় — if তা পারে না। দুই স্তর পর্যন্ত ঠিক আছে; তার বেশি নেস্ট করলে পড়া কঠিন — তখন if/switch ভালো (পর্ব ১১)। Ternary ডান দিক থেকে জোড়া লাগে, তাই a ? b : c ? d : e মানে a ? b : (c ? d : e).

টাইপ আর সম্পর্ক যাচাইয়ের অপারেটর

in আর ?./??-এর পার্থক্য সূক্ষ্ম: { phone: undefined }-এ "phone" in obj হলো true (property আছে, মান undefined), কিন্তু obj.phone ?? "নেই" দেয় “নেই”। “property আছে কি না” আর “মান আছে কি না” আলাদা প্রশ্ন। আর delete শুধু property মোছে, variable বা মেমরি নয় — মেমরি মোছে garbage collector (পর্ব ০৫)। পর্ব ০৫-এ দেখেছেন, delete object-এর hidden class-ও নষ্ট করতে পারে; property-কে “খালি” বোঝাতে অনেক সময় null বসানোই ভালো।

Bitwise অপারেটর — ৩২টি বাতি

Bitwise অপারেটর সংখ্যাকে দেখে বাইনারি অঙ্কের (bit) সারি হিসেবে, আর প্রতিটি bit আলাদাভাবে মেলায়। একটি গুরুত্বপূর্ণ তথ্য: JavaScript-এর number ৬৪-বিট দশমিক সংখ্যা হলেও bitwise কাজের আগে সংখ্যাটিকে ৩২-বিটের পূর্ণসংখ্যায় বদলে নেওয়া হয় — দশমিক অংশ বাদ, ৩২ বিটের বাইরের অংশ বাদ।

৩২-বিটে বদলানোর প্রভাব চোখে দেখা যায়: 3.9 | 0 → 3, 2147483648 | 0 → -2147483648, আর 4294967296 | 0 → 0. পুরোনো কোডে দশমিক কাটতে ~~x বা x | 0 দেখবেন — বড় সংখ্যায় এটি ভুল ফল দেয়, তাই Math.trunc(x) লিখুন।

Bitwise-এর সবচেয়ে বাস্তব ব্যবহার হলো bit flag — একটি সংখ্যার ভেতরে কয়েকটি হ্যাঁ/না তথ্য রাখা। একটি অফিস-অ্যাপে ব্যবহারকারীর অনুমতি ভাবুন: পড়া, লেখা, মোছা। প্রতিটি অনুমতি একটি আলাদা bit — ঘরের সুইচবোর্ডের আলাদা আলাদা সুইচের মতো:

const READ = 1, WRITE = 2, DELETE = 4;   // 0b001, 0b010, 0b100

let perm = READ | WRITE;          // 3   (011) — পড়া আর লেখা চালু
(perm & WRITE) !== 0;             // true  — লেখার অনুমতি আছে?
(perm & DELETE) !== 0;            // false — মোছার অনুমতি নেই

perm |= DELETE;                   // 7   (111) — মোছার সুইচ চালু
perm &= ~WRITE;                   // 5   (101) — লেখার সুইচ বন্ধ
perm.toString(2);                 // "101"

এক নজরে আগামীর অপারেটর — spread ...

তিনটি বিন্দু ... দেখতে অপারেটরের মতো, কিন্তু আনুষ্ঠানিকভাবে এটি spread syntax: [...a, ...b] দুটি array জুড়ে দেয়, { ...user, city: "খুলনা" } object কপি করে একটি property বদলায়, Math.max(...nums) array-কে আলাদা argument-এ ভেঙে দেয়। পর্ব ১৭-এ এটি বিস্তারিত দেখবেন।

৯ · অগ্রাধিকার আর associativity — কে আগে হিসাব হবে

স্কুলে শিখেছেন: গুণ-ভাগ আগে, যোগ-বিয়োগ পরে। 2 + 3 * 4 = 14, 20 নয়। JavaScript-এর প্রতিটি অপারেটরেরও এমন একটি স্তর আছে — operator precedence. আর একই স্তরের দুটি অপারেটর পাশাপাশি এলে কোন দিক থেকে জোড়া লাগবে, তা ঠিক করে associativity: 10 - 4 - 3 বাম থেকে ((10 - 4) - 3 = 3), কিন্তু 2 ** 3 ** 2 আর a = b = 0 ডান থেকে।

পুরো তালিকা মুখস্থ করার দরকার নেই। তিনটি জিনিস মনে রাখুন: গণিতের নিয়ম গণিতের মতোই; তুলনা হয় logical-এর আগে (তাই a > 0 && b > 0-এ বন্ধনী লাগে না); আর && হয় ||-এর আগে। সন্দেহ হলে বন্ধনী দিন — বন্ধনী কখনো ভুল নয়। এবার একটি ক্লাসিক প্রশ্ন ধাপে ধাপে দেখুন:

a || b && c

প্রশ্ন: বাম থেকে ডানে পড়ব — (a || b) && c ?

a || (b && c)

||  ← মূল অপারেটর (সবার শেষে হিসাব)
├─ a
└─ b && c

0 || (b && c)

0 falsy → উত্তর এখনো জানা নেই → ডান দিক লাগবে

0 || ("রহিম" && "")
0 || ""

b truthy → && ফেরত দেয় c-কে, অর্থাৎ ""

0 || ""   →   ""

দুটিই falsy → || শেষ operand ফেরত দেয়
(a || b) && c ধরলেও এখানে "" আসত — কিন্তু অন্য মানে আলাদা হবে

??-কে || বা &&-এর সাথে বন্ধনী ছাড়া মেশানো যায় না

a ?? b || c — এর মানে কী হওয়া উচিত? (a ?? b) || c, নাকি a ?? (b || c)? দুটিই যুক্তিসঙ্গত, আর ভুল বেছে নিলে চুপচাপ বাগ। তাই TC39 সিদ্ধান্ত নিয়েছে: অনুমান নয়, error. Chrome বা Node.js-এ লিখে দেখুন:

null ?? 0 || 1   →   SyntaxError: Unexpected token '||'
0 || null ?? 5   →   SyntaxError: Unexpected token '??'

সমাধান: বন্ধনী — (0 || null) ?? 5 দেয় 5. এটি SyntaxError, তাই parse করার সময়েই ধরা পড়ে: ফাইলের একটি লাইনও চলবে না (পর্ব ০৫)। &&-এর সাথেও একই নিয়ম (Unexpected token '&&'). তৃতীয় ভাবনার প্রশ্নে এই সিদ্ধান্তের পেছনের যুক্তি আছে।

১০ · AI-এর যুগে — ডিফল্ট, শিকল আর অগ্রাধিকারের ভুল ধরা

AI কোড লেখে লক্ষ লক্ষ পুরোনো উদাহরণ দেখে শিখে। ২০২০-এর আগের JavaScript-এ ?? আর ?. ছিল না, তাই সেই সময়ের কোডে সব জায়গায় || আর && শিকল। AI এই অভ্যাসগুলো এখনো প্রায়ই নকল করে। কোড দেখতে ঠিক, চলেও — শুধু ০ বা ফাঁকা string এলে চুপচাপ ভুল করে।

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

• প্রতিটি || ডিফল্টের জন্য ভেবেছি — ০, "", false কি বৈধ? হলে ??
• ০, ফাঁকা string, null আর undefined — চারটি দিয়েই কোডটি চালিয়ে দেখেছি
• &&/||-এর ফল যেখানে variable-এ যাচ্ছে, সেখানে boolean আশা করছি কি না দেখেছি
• ?. শুধু সেখানে আছে যেখানে ডেটা না থাকা স্বাভাবিক; অন্য জায়গায় স্পষ্ট error-ই ভালো
• &&, ||, ??, ternary একসাথে থাকলে বন্ধনী দিয়ে অর্থ স্পষ্ট করেছি
• & আর &&, | আর ||, = আর === — এক অক্ষরের ভুল খুঁজেছি (ESLint এগুলো ধরতে সাহায্য করে, পর্ব ৪৬)