From c5a594387fc6b462c2b123e06165e6282fb6767f Mon Sep 17 00:00:00 2001
From: iamsaief <saiefalemon@gmail.com>
Date: Wed, 15 May 2024 14:45:38 +0600
Subject: [PATCH 01/12] added bn translation 1-28

---
 .gitignore            |    1 +
 README.md             |    1 +
 bn-BD/README_bn-BD.md | 5146 +++++++++++++++++++++++++++++++++++++++++
 3 files changed, 5148 insertions(+)
 create mode 100644 .gitignore
 create mode 100644 bn-BD/README_bn-BD.md

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 00000000..600d2d33
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+.vscode
\ No newline at end of file
diff --git a/README.md b/README.md
index b203a060..33993983 100644
--- a/README.md
+++ b/README.md
@@ -45,6 +45,7 @@ From basic to advanced: test how well you know JavaScript, refresh your knowledg
 - [🇻🇳 Tiếng Việt](./vi-VI/README-vi.md)
 - [🇨🇳 简体中文](./zh-CN/README-zh_CN.md)
 - [🇹🇼 繁體中文](./zh-TW/README_zh-TW.md)
+- [🇧🇩 বাংলা](./bn-BD/README_bn-BD.md)
 
 </p>
 </details>
diff --git a/bn-BD/README_bn-BD.md b/bn-BD/README_bn-BD.md
new file mode 100644
index 00000000..7f8d0060
--- /dev/null
+++ b/bn-BD/README_bn-BD.md
@@ -0,0 +1,5146 @@
+<div align="center">
+  <img height="60" src="https://img.icons8.com/color/344/javascript.png">
+  <h1>বাংলায় জাভাস্ক্রিপ্ট প্রশ্নোত্তর 🇧🇩</h1>
+</div>
+
+<p align="center">
+<b>বেসিক থেকে এডভ্যান্স:</b> আপনি কতটুকু জাভাস্ক্রিপ্ট জানেন পরীক্ষা করুন, আপনার জ্ঞানকে একটু ঝালাই করে নিন অথবা আপনার ইন্টার্ভিউর জন্য প্রস্তুতি নিন 💪। এই রিপো নিয়িমিত আপডেট করা হয় নতুন প্রশ্নত্তর দিয়ে। উত্তরগুলো কল্যাপ্সড আকারে আছে, দেখার জন্য উত্তর এ ক্লিক করুন। অবসরে আনন্দের জন্য আমি এটাকে বাংলায় অনুবাদ করেছি, ভুল ত্রুটি মার্জনা করবেন। আপনার প্রোগ্রামিং যাত্রার জন্য শুভকামনা 💛। </p>
+
+<p align="center">আমার সাথে যোগাযোগ করতে চাইলে,</p>
+
+<p align="center">
+  <a href="https://www.facebook.com/saiefalemon">Facebook</a> || <a href="https://www.linkedin.com/in/saiefalemon">LinkedIn</a> || <a href="https://www.iamsaief.com/">Blog</a>
+</p>
+
+---
+
+<details><summary><strong> যে যে ভাষায় অনুবাদগুলো আছে তার লিস্ট - 🇸🇦🇪🇬🇧🇦🇩🇪🇪🇸🇫🇷🇮🇩🇯🇵🇰🇷🇳🇱🇧🇷🇷🇺🇹🇭🇹🇷🇺🇦🇻🇳🇨🇳🇹🇼🇽🇰🇧🇩</strong></summary>
+<p>
+
+- [🇸🇦 العربية](./ar-AR/README_AR.md)
+- [🇪🇬 اللغة العامية](./ar-EG/README_ar-EG.md)
+- [🇧🇦 Bosanski](./bs-BS/README-bs_BS.md)
+- [🇩🇪 Deutsch](./de-DE/README.md)
+- [🇪🇸 Español](./es-ES/README-ES.md)
+- [🇫🇷 Français](./fr-FR/README_fr-FR.md)
+- [🇮🇩 Indonesia](./id-ID/README.md)
+- [🇮🇹 Italiano](./it-IT/README.md)
+- [🇯🇵 日本語](./ja-JA/README-ja_JA.md)
+- [🇰🇷 한국어](./ko-KR/README-ko_KR.md)
+- [🇳🇱 Nederlands](./nl-NL/README.md)
+- [🇵🇱 Polski](./pl-PL/README.md)
+- [🇧🇷 Português Brasil](./pt-BR/README_pt_BR.md)
+- [🇷o Română](./ro-RO/README.ro.md)
+- [🇷🇺 Русский](./ru-RU/README.md)
+- [🇽🇰 Shqip](./sq-KS/README_sq_KS.md)
+- [🇹🇭 ไทย](./th-TH/README-th_TH.md)
+- [🇹🇷 Türkçe](./tr-TR/README-tr_TR.md)
+- [🇺🇦 Українська мова](./uk-UA/README.md)
+- [🇻🇳 Tiếng Việt](./vi-VI/README-vi.md)
+- [🇨🇳 简体中文](./zh-CN/README-zh_CN.md)
+- [🇹🇼 繁體中文](./zh-TW/README_zh-TW.md)
+- [🇧🇩 বাংলা](./bn-BD/README_bn-BD.md)
+
+</p>
+</details>
+
+---
+
+###### 1. এটার আউটপুট কোনটা?
+
+```javascript
+function sayHi() {
+  console.log(name);
+  console.log(age);
+  var name = "Lydia";
+  let age = 21;
+}
+
+sayHi();
+```
+
+- A: `Lydia` and `undefined`
+- B: `Lydia` and `ReferenceError`
+- C: `ReferenceError` and `21`
+- D: `undefined` and `ReferenceError`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: D
+
+আমরা ফাংশনের ভেতরে প্রথমে `var` কিওয়ার্ড দিয়ে ভেরিয়েবল ডিক্লেয়ার করেছি। মানে হল ভেরিয়েবলটি হইস্টেড (মেমরিতে জায়গা নিচ্ছে রান করার সময়) হয়ে যাচ্ছে ডিফল্ট ভ্যালু `undefined` দিয়ে যতক্ষন না পর্যন্ত যে লাইনে ডিক্লেয়ার করা হয়েছে সেখানে যাচ্ছে। যে লাইনে আমরা এটাকে লগ করার চেষ্টা করছি তার আগ পর্যন্ত এটাকে ডিফাইন করা হয়নি, তাই এটা এখন পর্যন্ত `undefined` ভ্যালুকেই ধরে রেখেছে।
+
+`let` কিওয়ার্ড (এবং `const`) দিয়ে ভেরিয়েবল নিলে সেটাও হইস্টেড হয় তবে `var` এর মত ইনিশিয়ালাইজ হয় না। যে লাইনে ডিক্লেয়ার (ইনিশিয়ালাইজ) করা হয়েছে তার আগে তাদেরকে এক্সেস (রিড/রাইট) করা যায় না। এটাকে "টেম্পোরাল ডেড জোন বলা হয়"। যখন ভেরিয়েবলকে ডিক্লেয়ার করার আগেই তাকে এক্সেস করার চেষ্টা করা হয় তখন জাভাস্ক্রিপ্ট `ReferenceError` ছুঁঁড়ে দেয়।
+
+</p>
+</details>
+
+---
+
+###### 2. এটার আউটপুট কোনটা?
+
+```javascript
+for (var i = 0; i < 3; i++) {
+  setTimeout(() => console.log(i), 1);
+}
+
+for (let i = 0; i < 3; i++) {
+  setTimeout(() => console.log(i), 1);
+}
+```
+
+- A: `0 1 2` and `0 1 2`
+- B: `0 1 2` and `3 3 3`
+- C: `3 3 3` and `0 1 2`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+জাভাস্ক্রিপ্টের ইভেন্ট কিউয়ের জন্য `setTimeout` কলব্যাক ফাংশনটি কল হয়েছে লুপটি রান হওয়ার পরে। যেহেতু ১ম লুপে `var` কিওয়ার্ড ব্যাবহৃত হয়েছে এটার ভ্যালু তাই গ্লোবাল। লুপ চলাকালীন আমরা `i` এর ভ্যালু প্রতিবার `1` করে বাড়িয়েছি উনারি `++` অপারেটর দিয়ে। যতক্ষণে `setTimeout` কলব্যাক ফাংশনটি কল হয়েছে, ১ম উদাহরনের ক্ষেত্রে, `i` এর ভ্যালু ততক্ষণে `3` হয়ে গেছে।
+
+২য় লুপে, `i` ভ্যারিরিয়েবল ডিক্লেয়ার করা হয়েছে `let` কিওয়ার্ড দিয়ে, `let` কিওয়ার্ড (এবং `const`) দিয়ে নেয়া ভেরিয়েবগুলো ব্লক-স্কোপড (ব্লক হচ্ছে `{}` এর মধ্যে থাকা কিছু)। লুপ চলাকালীন প্রতিবারই `i` এর নতুন ভ্যালু হবে এবং প্রতিটি ভ্যালুই লুপের ভেতরে স্কোপড থাকবে।
+
+</p>
+</details>
+
+---
+
+###### 3. এটার আউটপুট কোনটা?
+
+```javascript
+const shape = {
+  radius: 10,
+  diameter() {
+    return this.radius * 2;
+  },
+  perimeter: () => 2 * Math.PI * this.radius,
+};
+
+console.log(shape.diameter());
+console.log(shape.perimeter());
+```
+
+- A: `20` and `62.83185307179586`
+- B: `20` and `NaN`
+- C: `20` and `63`
+- D: `NaN` and `63`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: B
+
+> খেয়াল করুন এখানে `diameter` একটি সাধারন ফাংশন অন্যদিকে `perimeter` হচ্ছে একটি অ্যারো ফাংশন।
+
+অ্যারো ফাংশনের `this` কিওয়ার্ড গ্লোবাল স্কোপকে রেফার (পয়েন্ট) করে, কিন্তু সাধারন ফাংশনের নিজের স্কোপেই পয়েন্ট করে। মানে হল, যখন আমরা `perimeter` কে কল করছি এটা shape অব্জেক্ট কে রেফার করছে না বরং গ্লোবাল স্কোপকে করছে (উদাহরনস্বরূপ - window)। 
+
+যেহেতু অ্যারো ফাংশনের স্কোপে `radius` এর কোন ভ্যালু নেই `this.radius` রিটার্ন করছে `undefined` একে ২ দিয়ে গুন করার ফলে (`2 * Math.PI`) ফলাফল আসছে `NaN`.
+
+</p>
+</details>
+
+---
+
+###### 4. এটার আউটপুট কোনটা?
+
+```javascript
++true;
+!"Lydia";
+```
+
+- A: `1` and `false`
+- B: `false` and `NaN`
+- C: `false` and `false`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: A
+
+এখানে ইউনারি (`+`) অপারেটরটি চেষ্টা করেছে তার অপারেন্ডকে নাম্বার এ পরিবর্তন করার। `true` হয় `1`, এবং `false` হয় `0`।
+
+`'Lydia'` স্ট্রিং টি একটি সত্য ভ্যালু। আমরা এখানে আসলে `!` দিয়ে যেটা জিজ্ঞেস করছি "এই সত্য ভ্যালুটি কি মিথ্যা ?"। এটি ফলাফল দিচ্ছে `false`।
+
+
+</p>
+</details>
+
+---
+
+###### 5. এখানে কোনটি সত্য?
+
+```javascript
+const bird = {
+  size: "small",
+};
+
+const mouse = {
+  name: "Mickey",
+  small: true,
+};
+```
+
+- A: `mouse.bird.size` is not valid
+- B: `mouse[bird.size]` is not valid
+- C: `mouse[bird["size"]]` is not valid
+- D: All of them are valid
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: A
+
+জাভাস্ক্রিপ্টে অব্জক্টের সকল কি-ই হচ্ছে স্ট্রিং (যদি না এটা কোন সংকেত হয়)। যদিওবা আমরা এদেরকে স্ট্রিং হিসেবে লিখে নাও থাকি, ভেতরে ভেতরে তা সবসময়ই স্ট্রিং এ পরিবর্তন হয়ে যায়।
+
+জাভাস্ক্রিপ্ট স্টেটম্যান্ট কে ভাষান্তর (মেশিনের ভাষা) করে। যখন ব্র্যাকেট নোটেশন ব্যবহৃত হয়, এটা শুরুর ব্র্যাকেট `[` পেলে তা শেষ ব্র্যাকেট পর্যন্ত `]` যেতে থাকে। তারপরই কেবল এটার মান নির্ণয় করা হবে।
+
+অন্যদিকে, ডট নোটেশনের বেলায় এরকমটা ঘটে না। `mouse` এর মধ্যে `bird` নামের কোন কি নেই, তার মানে হচ্ছে `mouse.bird` হয় `undefined`। এরপর ডট নোটেশন ব্যাবহার (`mouse.bird.size`) করে আমরা জানতে চাচ্ছি `size` এর ভ্যালু । যেহেতু `mouse.bird` হয় `undefined`, আমরা আসলে জানতে চাচ্ছি `undefined.size`। এটা বৈধ নয়, এবং `Cannot read property "size" of undefined` -র মত একটা এরর ছুঁড়ে দেয়া হবে।
+
+</p>
+</details>
+
+---
+
+###### 6. এটার আউটপুট কোনটা?
+
+```javascript
+let c = { greeting: "Hey!" };
+let d;
+
+d = c;
+c.greeting = "Hello";
+console.log(d.greeting);
+```
+
+- A: `Hello`
+- B: `Hey!`
+- C: `undefined`
+- D: `ReferenceError`
+- E: `TypeError`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: A
+
+জাভাস্ক্রিপ্টে, সব অবজেক্টই কাজ করে রেফারেন্স হিসেবে, যখন আমরা একটিকে অন্যটির সমান ভ্যালু সেট করছি তখন রেফারেন্সই সেট হচ্ছে।
+
+প্রথমে, ভেরিয়েবল `c` একটা অবজেক্টের মান ধরে রাখে। পরবর্তিতে সেই ভ্যালিউই আমরা `d` তে অ্যাসাইন করছি যেটায় আদতে আছে `c` অবজেক্টের রেফারেন্স।
+
+<img src="https://i.imgur.com/ko5k0fs.png" width="200">
+
+যখন আপনি একটি অবজেক্টের মান পরিবর্তন করছেন, আপনি সবগুলোকেই পরিবর্তন করছেন।
+
+</p>
+</details>
+
+---
+
+###### 7. এটার আউটপুট কোনটা?
+
+```javascript
+let a = 3;
+let b = new Number(3);
+let c = 3;
+
+console.log(a == b);
+console.log(a === b);
+console.log(b === c);
+```
+
+- A: `true` `false` `true`
+- B: `false` `false` `true`
+- C: `true` `false` `false`
+- D: `false` `true` `true`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+`new Number()` হল একটি বিল্ট-ইন ফাংশন কন্সট্রাক্টর। যদিও এটা নাম্বার এর মত দেখতে কিন্তু এটি আসলে নাম্বার নয়ঃ এটাতে আর অনেকগুলো ফিচার আছে এবং এটি একটি অবজেক্ট।
+
+যখন আমরা `==` অপারেটর (সমতুল্য অপারেটর) ব্যাবহার করি, এটা কেবল ভ্যালু সমান কিনা তুলনা করে। `a` ও `b` দুটার ভ্যালুই `3` তাই ফলাফল হয় `true`। 
+
+অন্যদিকে, যখন আমরা `===` অপারেটর (কঠোর-সমতুল্য অপারেটর) ব্যাবহার করি, এটা ভ্যালু এবং টাইপ দুটাই সমান কিনা তুলনা করে। এক্ষত্রে `new Number()` যেহেতু নাম্বর নয় অবেজেক্ট। দুটই ফলাফল দেয় `false`।
+
+</p>
+</details>
+
+---
+
+###### 8. এটার আউটপুট কোনটা?
+
+```javascript
+class Chameleon {
+  static colorChange(newColor) {
+    this.newColor = newColor;
+    return this.newColor;
+  }
+
+  constructor({ newColor = "green" } = {}) {
+    this.newColor = newColor;
+  }
+}
+
+const freddie = new Chameleon({ newColor: "purple" });
+console.log(freddie.colorChange("orange"));
+```
+
+- A: `orange`
+- B: `purple`
+- C: `green`
+- D: `TypeError`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: D
+
+এখানে `colorChange` একটি স্ট্যাটিক ফাংশন। এদের ডিজাইন প্যাটার্ন হল, কেবল যে কন্সট্রাক্টরে এদের তৈরি করা হবে তার বাইরে থেকে এক্সেস করা যাবে না, এবং কোন চিলড্রেনে পাস করা যাবে না বা ক্লাস ইন্সটেন্স দিয়ে কলও করা যাবে না। যেহেতু `freddie` Chameleon ক্লাসের একটি ইন্সটেন্স, তাই সে স্ট্যাটিক ফাংশনকে কল করতে পারবে না। ফলে `TypeError` ছোঁড়া হয়।
+
+</p>
+</details>
+
+---
+
+###### 9. এটার আউটপুট কোনটা?
+
+```javascript
+let greeting;
+greetign = {}; // Typo!
+console.log(greetign);
+```
+
+- A: `{}`
+- B: `ReferenceError: greetign is not defined`
+- C: `undefined`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: A
+
+এটা অবজেক্টকে লগ করছে, কারন আমরা খালি অবজেক্টটিকে তৈরি করেছি গ্লোবাল অবজেক্টের মধ্যে! যখন `greeting` কে `greetign` ভুল বানান এ লিখেছি, জেএস ইন্টারপ্রেটার দেখছে এমনঃ 
+
+1. নোড জেওএস এ - `global.greetign = {}`। 
+2. ব্রাউজার এ - `window.greetign = {}`, `frames.greetign = {}` এবং `self.greetign`। 
+3. ওয়েব ওয়ার্কার্স এ - `self.greetign`। 
+4. অন্য সকল এনভায়র্ন্মেন্টে - `globalThis.greetign`।
+
+এটাকে এড়ানোর জন্য আমরা `"use strict"` ব্যাবহার করতে পারি । এটা নিশ্চিত করবে যে আপনি ভেরিয়েবলকে কোন কিছু দিয়ে অ্যাসাইন করার আগে তাকে ডিক্লেয়ার করেছেন কিনা । 
+
+</p>
+</details>
+
+---
+
+###### 10. আমরা এটা করলে কি ঘটবে?
+
+```javascript
+function bark() {
+  console.log("Woof!");
+}
+
+bark.animal = "dog";
+```
+
+- A: Nothing, this is totally fine!
+- B: `SyntaxError`. You cannot add properties to a function this way.
+- C: `"Woof"` gets logged.
+- D: `ReferenceError`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: A
+
+জাভাস্ক্রিপ্টে এটা সম্ভব, কারন ফাংশনগুলো হয় অবজেক্ট! (প্রিমিটিভ টাইপ বাদে সবকিছুই অবজেক্ট)
+
+ফাংশনগুলো হয় বিশেষ ধরনের অবজেক্ট। যে কোডটা আপনি লিখেছেন এটা আসল ফাংশন নয়। ফাংশনটি হচ্ছে একটি অবজেক্ট যার প্রপার্টিস রয়েছে। এই প্রোপার্টিগুলোকে কল করা যায়।
+
+
+</p>
+</details>
+
+---
+
+###### 11. এটার আউটপুট কোনটা?
+
+```javascript
+function Person(firstName, lastName) {
+  this.firstName = firstName;
+  this.lastName = lastName;
+}
+
+const member = new Person("Lydia", "Hallie");
+Person.getFullName = function () {
+  return `${this.firstName} ${this.lastName}`;
+};
+
+console.log(member.getFullName());
+```
+
+- A: `TypeError`
+- B: `SyntaxError`
+- C: `Lydia Hallie`
+- D: `undefined` `undefined`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: A
+
+জাভাস্ক্রিপ্টে, ফাংশনগুলো হয় অবজেক্ট, অতএব, `getFullName` মেথডটি কন্সট্রাক্টর ফাংশনের অবজেক্টের সাথে যুক্ত হয়। একারনেই, আমরা `Person.getFullName()` কে কল করতে পারছি কিন্তু `member.getFullName` ছুঁড়ে দিচ্ছে `TypeError`।
+
+আপনি যদি একটি মেথডকে অবজেক্টের সকল ইন্সট্যান্সের জন্য ব্যবহারযোগ্য করতে চান তাহলে আপনার এটাকে যুক্ত করতে হবে প্রটোটাইপ প্রোপার্টিতে।
+
+```js
+Person.prototype.getFullName = function () {
+  return `${this.firstName} ${this.lastName}`;
+};
+```
+
+</p>
+</details>
+
+---
+
+###### 12. এটার আউটপুট কোনটা?
+
+```javascript
+function Person(firstName, lastName) {
+  this.firstName = firstName;
+  this.lastName = lastName;
+}
+
+const lydia = new Person("Lydia", "Hallie");
+const sarah = Person("Sarah", "Smith");
+
+console.log(lydia);
+console.log(sarah);
+```
+
+- A: `Person {firstName: "Lydia", lastName: "Hallie"}` and `undefined`
+- B: `Person {firstName: "Lydia", lastName: "Hallie"}` and `Person {firstName: "Sarah", lastName: "Smith"}`
+- C: `Person {firstName: "Lydia", lastName: "Hallie"}` and `{}`
+- D: `Person {firstName: "Lydia", lastName: "Hallie"}` and `ReferenceError`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: A
+
+আমরা `sarah` -র জন্য `new` কিওয়ার্ডটি ব্যবহার করিনি। যখন `new` কিওয়ার্ড ব্যবহার করা হয় `this` রেফার করে আমরা তৈরি করা নতুন খালি অবজেক্টিকে। অন্যদিকে, যদি আপনি `new` যুক্ত না করেন, `this` রেফার করবে **গ্লোবাল অবজেক্টকে** !
+
+আমরা বলছি `this.firstName` সমান হল `"Sarah"` এবং `this.lastName` হল `"Smith"`। আমরা এখানে আসলে যেটা বলছি সেটা হল, ডিফাইন করছি `global.firstName = 'Sarah'` এবং `global.lastName = 'Smith'`। যেহেতু `Person` ফাংশন কোন ফলাফল রিটার্ন করছে না তাই `sarah` নিজেই হয়ে আছে `undefined`।
+
+</p>
+</details>
+
+---
+
+###### 13. What are the three phases of event propagation?
+
+- A: Target > Capturing > Bubbling
+- B: Bubbling > Target > Capturing
+- C: Target > Bubbling > Capturing
+- D: Capturing > Target > Bubbling
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: D
+
+**ক্যাপচারিং** অবস্থার সময়, ইভেন্ট ডমের (DOM) পুর্বপুরুষ উপাদান থেকে **লক্ষ্য** -র দিকে যায়। তারপর এটা **লক্ষ্য** উপাদানে পৌঁছালে **বাবলিং** শুরু হয়।
+
+<img src="https://i.imgur.com/N18oRgd.png" width="200">
+
+</p>
+</details>
+
+---
+
+###### 14. সকল অবজেক্টের প্রোটোটাইপ আছে?
+
+- A: true
+- B: false
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: B
+
+**বেইজ অবজেক্ট** ছাড়া সকল অবজেক্টের প্রোটোটাইপ আছে। বেইজ অবজেক্ট হল সে অবজেক্ট যেটা ইউজার তৈরি করেছে অথবা `new` কিওয়ার্ডটি ব্যবহার করে তৈরি করা হয়েছে। বেইজ অবজেক্টের কিছু বিল্টইন মেথড ব্যবহারের বৈধ অনুমতি আছে, যেমন `.toString`। এই কারনেই আপনি জাভাস্ক্রিপ্টের বিল্টইন মেথড ব্যবহার করতে পারেন! এইরকম মেথডগুলো প্রোটোটাইপের আয়তাধীনে থাকে। যদিও জাভাস্ক্রিপ্ট আপনার অবজেক্টে সরাসরি এগুলোকে খুঁজে পায় না, প্রোটোটাইপ চেইনের ভেতর দিয়ে যেয়ে খুঁজে বের করে, ফলে আপনি এগুলো ব্যবহারের বৈধ অনুমতি পান।
+
+</p>
+</details>
+
+---
+
+###### 15. এটার আউটপুট কোনটা?
+
+```javascript
+function sum(a, b) {
+  return a + b;
+}
+
+sum(1, "2");
+```
+
+- A: `NaN`
+- B: `TypeError`
+- C: `"12"`
+- D: `3`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+জাভাস্ক্রিপ্ট একটি **ডায়নামিক টাইপ ভাষাঃ** আমরা ভেরিয়েবলের টাইপ নির্দিষ্ট করি না। আপনি জানতে পারেন না ভ্যালু স্বয়ংক্রিয়ভাবেই এক টাইপ থেকে অন্য টাইপে পরিবর্তন হয়ে যায়, যেটাকে বলা হয় **কোয়ার্শন (coercion)**। এটা হল এক টাইপ থেকে অন্য টাইপে পরিবর্তন হওয়া।
+
+এই উদাহরনে, জাভাস্ক্রিপ্ট এই ফাংশনটিকে যুক্তিসঙ্গত ও এর একটি ফলাফল রিটার্ন করার জন্য `1` নাম্বারটিকে স্ট্রিং এ পরিবর্তন করেছে। নাম্বার `1` ও স্ট্রিং `"2"` এর যোগের বেলায় নাম্বারটিকে স্ট্রিং হিসেবে ধরা হয়েছে। আমরা দুটো স্ট্রিং কে যুক্ত করতে পারি এভাবে, `"Hello" + "World"`, তাই এখানে `"1" + "2"` ফলাফল রিটার্ন করছে `"12"`। 
+
+</p>
+</details>
+
+---
+
+###### 16. এটার আউটপুট কোনটা?
+
+```javascript
+let number = 0;
+console.log(number++);
+console.log(++number);
+console.log(number);
+```
+
+- A: `1` `1` `2`
+- B: `1` `2` `2`
+- C: `0` `2` `2`
+- D: `0` `1` `2`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+**পোস্টফিক্স** ইউনারি অপারেটর `++`:
+1. ফলাফল রিটার্ন করে (এক্ষেত্রে রিটার্ন করে `0`)
+2. ভ্যালুর মান বৃদ্ধি করে (নাম্বারটি এখন `1`)
+
+**প্রিফিক্স** ইউনারি অপারেটর `++`:
+1. ভ্যালুর মান বৃদ্ধি করে (নাম্বারটি এখন `2`)
+2. ফলাফল রিটার্ন করে (এক্ষেত্রে রিটার্ন করে `2`)
+
+এজন্যই উত্তরটি হয় `0 2 2`
+
+</p>
+</details>
+
+---
+
+###### 17. এটার আউটপুট কোনটা?
+
+```javascript
+function getPersonInfo(one, two, three) {
+  console.log(one);
+  console.log(two);
+  console.log(three);
+}
+
+const person = "Lydia";
+const age = 21;
+
+getPersonInfo`${person} is ${age} years old`;
+```
+
+- A: `"Lydia"` `21` `["", " is ", " years old"]`
+- B: `["", " is ", " years old"]` `"Lydia"` `21`
+- C: `"Lydia"` `["", " is ", " years old"]` `21`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: B
+
+যদি আপনি _ট্যাগড টেম্পলেট লিটারেলস_ ব্যবহার করেন, আর্গুমেন্টের ১ম ভ্যালুটি সবসময় হয় ট্যাগড স্ট্রিং গুলোর একটি অ্যারে। বাকি আর্গুমেন্টের ভ্যালুগুলো হয় যেই এক্সপ্রেশনগুলো পাঠানো হয় তার ভ্যালু।
+
+</p>
+</details>
+
+---
+
+###### 18. এটার আউটপুট কোনটা?
+
+```javascript
+function checkAge(data) {
+  if (data === { age: 18 }) {
+    console.log("You are an adult!");
+  } else if (data == { age: 18 }) {
+    console.log("You are still an adult.");
+  } else {
+    console.log(`Hmm.. You don't have an age I guess`);
+  }
+}
+
+checkAge({ age: 18 });
+```
+
+- A: `You are an adult!`
+- B: `You are still an adult.`
+- C: `Hmm.. You don't have an age I guess`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+সমতা পরীক্ষা করার ক্ষেত্রে, মৌলিক টাইপগুলো (primitives) _ভ্যালু_ এবং অবজেক্ট টাইপগুলো _রেফেরান্স_ দ্বারা তুলনা করা হয়। জাভাস্ক্রিপ্ট চেক করে অবজেক্টগুলোতে একই মেমরি লোকেশনের রেফারেন্স আছে কিনা।
+
+যেদুটো অবজেক্টকে আমরা তুলনা করছি তাদের সেটা নেইঃ প্যারামিটারে আমরা যে অবজেক্টকে পাঠিয়েছি সেটার মেমরি লোকেশনের রেফারেন্স যেই অবজেক্টটা সমতা চেক করার জন্য ব্যাবহার করেছি তার থেকে আলাদা।
+
+একারনে দুটোই `{ age: 18 } === { age: 18 }` এবং `{ age: 18 } == { age: 18 }` রিটার্ন করে `false`
+
+</p>
+</details>
+
+---
+
+###### 19. এটার আউটপুট কোনটা?
+
+```javascript
+function getAge(...args) {
+  console.log(typeof args);
+}
+
+getAge(21);
+```
+
+- A: `"number"`
+- B: `"array"`
+- C: `"object"`
+- D: `"NaN"`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+এখানে রেস্ট প্যারামিটারটি (`...args`) আমাদেরকে বাকি সব আর্গুমেন্টসকে একটি অ্যারেতে "সংগ্রহ" করতে দেয়। একটি অ্যারে হয় একটি অবজেক্ট, তাই `typeof args` রিটার্ন করে `"object"`। 
+
+</p>
+</details>
+
+---
+
+###### 20. এটার আউটপুট কোনটা?
+
+```javascript
+function getAge() {
+  "use strict";
+  age = 21;
+  console.log(age);
+}
+
+getAge();
+```
+
+- A: `21`
+- B: `undefined`
+- C: `ReferenceError`
+- D: `TypeError`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+`"use strict"` দ্বারা আপনি এটা নিশ্চিত করতে পারেন যে আপনি দুর্ঘটনাবশত গ্লোবাল ভ্যারিয়েবল ডিক্লেয়ার করছেন না। আমরা কোথাও `age` ভ্যারিয়েবলটি ডিক্লেয়ার করিনি এবং যেহেতু আমরা `"use strict"` ব্যাবহার করেছি, এটা _রেফারেন্স এরর_ ছুঁড়ে দেবে। যদি আমরা ব্যাবহার না করতাম `"use strict"`, হয়ত এটা কাজ করত, যেহেতু `age` প্রপার্টিটি গ্লোবাল অবজেক্টে যুক্ত হত।
+
+</p>
+</details>
+
+---
+
+###### 21. কোনটি `sum` এর ভ্যালু হবে?
+
+```javascript
+const sum = eval("10*10+5");
+```
+
+- A: `105`
+- B: `"105"`
+- C: `TypeError`
+- D: `"10*10+5"`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: A
+
+`eval` একটি স্ট্রিং হিসাবে পাস করা কোডকে মূল্যায়ন করে। যদি এটি একটি অভিব্যক্তি (expression)  হয়, যেমন এই ক্ষেত্রে, এটি অভিব্যক্তি মূল্যায়ন করেছে। অভিব্যক্তিটি হল `10 * 10 + 5`। এটি ফলাফল রিটার্ন করে `105`।
+
+</p>
+</details>
+
+---
+
+###### 22. কতক্ষণ cool_secret এক্সেসযোগ্য?
+
+```javascript
+sessionStorage.setItem("cool_secret", 123);
+```
+
+- A: Forever, the data doesn't get lost.
+- B: When the user closes the tab.
+- C: When the user closes the entire browser, not only the tab.
+- D: When the user shuts off their computer.
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: B
+
+ট্যাবটি বন্ধ করার পরে `sessionStorage` সংরক্ষিত ডেটা সরানো হয়।
+
+আপনি `localStorage` ব্যবহার করলে, ডেটা চিরকালের জন্য সেখানে থাকবে, যদি না উদাহরণস্বরূপ `localStorage.clear()` কল করা হয়।
+
+</p>
+</details>
+
+---
+
+###### 23. এটার আউটপুট কোনটা?
+
+```javascript
+var num = 8;
+var num = 10;
+
+console.log(num);
+```
+
+- A: `8`
+- B: `10`
+- C: `SyntaxError`
+- D: `ReferenceError`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: B
+
+`var` কীওয়ার্ড দিয়ে, আপনি একই নামের একাধিক ভেরিয়েবল ঘোষণা করতে পারেন। তারপর ভেরিয়েবলটি সর্বশেষ মান ধরে রাখবে।
+
+এটি কিন্তু আপনি `let` বা `const` দিয়ে করতে পারবেন না যেহেতু সেগুলি ব্লক-স্কোপড এবং সেইজন্য পুনরায় ডিক্লেয়ার করা যাবে না।
+
+</p>
+</details>
+
+---
+
+###### 24. এটার আউটপুট কোনটা?
+
+```javascript
+const obj = { 1: "a", 2: "b", 3: "c" };
+const set = new Set([1, 2, 3, 4, 5]);
+
+obj.hasOwnProperty("1");
+obj.hasOwnProperty(1);
+set.has("1");
+set.has(1);
+```
+
+- A: `false` `true` `false` `true`
+- B: `false` `true` `true` `true`
+- C: `true` `true` `false` `true`
+- D: `true` `true` `true` `true`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+সমস্ত অবজেক্ট কী (প্রতীকগুলি ব্যতীত) ভেতরে ভেতরে স্ট্রিং, এমনকি আপনি নিজে স্ট্রিং হিসাবে এটিকে না লিখে থাকলেও৷ `obj.hasOwnProperty('1')` ও এই কারনেই `true` রিটার্ন করে।
+
+একটি সেটের জন্য এটি সেভাবে কাজ করে না। আমাদের সেটে কোন `'1'` নেই: `set.has('1')` রিটার্ন করে `false`। এটির নিউমেরিক টাইপ (সংখ্যাসূচক প্রকার) আছে `1`, `set.has(1)` রিটার্ন করে `true`।
+
+</p>
+</details>
+
+---
+
+###### 25. এটার আউটপুট কোনটা?
+
+```javascript
+const obj = { a: "one", b: "two", a: "three" };
+console.log(obj);
+```
+
+- A: `{ a: "one", b: "two" }`
+- B: `{ b: "two", a: "three" }`
+- C: `{ a: "three", b: "two" }`
+- D: `SyntaxError`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+আপনার যদি একই নামের দুটি কী থাকে তবে কীটি প্রতিস্থাপন করা হবে। এটি এখনও তার প্রথম অবস্থানে থাকবে, তবে সর্বশেষ নির্দিষ্ট করা ভ্যালুটি সহ।
+
+</p>
+</details>
+
+---
+
+###### 26. জাভাস্ক্রিপ্ট গ্লোবাল এক্সিকিউশন কনটেক্সট আপনার জন্য দুটি জিনিস তৈরি করে: গ্লোবাল অবজেক্ট এবং "this" কীওয়ার্ড।
+
+- A: true
+- B: false
+- C: it depends
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: A
+
+বেস এক্সিকিউশন কনটেক্সট হল গ্লোবাল এক্সিকিউশন কনটেক্সট: এটি আপনার কোডের সর্বত্র অ্যাক্সেসযোগ্য।
+
+</p>
+</details>
+
+---
+
+###### 27. এটার আউটপুট কোনটা?
+
+```javascript
+for (let i = 1; i < 5; i++) {
+  if (i === 3) continue;
+  console.log(i);
+}
+```
+
+- A: `1` `2`
+- B: `1` `2` `3`
+- C: `1` `2` `4`
+- D: `1` `3` `4`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+`continue` স্টেটমেন্ট (বিবৃতি) একটি ইটারেশন (ইটারেশন) এড়িয়ে যায় যদি একটি নির্দিষ্ট শর্ত  `true` রিটার্ন করে।
+
+</p>
+</details>
+
+---
+
+###### 28. এটার আউটপুট কোনটা?
+
+```javascript
+String.prototype.giveLydiaPizza = () => {
+  return "Just give Lydia pizza already!";
+};
+
+const name = "Lydia";
+
+console.log(name.giveLydiaPizza());
+```
+
+- A: `"Just give Lydia pizza already!"`
+- B: `TypeError: not a function`
+- C: `SyntaxError`
+- D: `undefined`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: A
+
+`String` হল একটি বিল্ট-ইন কনস্ট্রাক্টর, যেটিতে আমরা প্রপার্টি গুলো যোগ করতে পারি। আমি এর প্রোটোটাইপে একটি মেথড যোগ করেছি। প্রিমিটিভ স্ট্রিংগুলি স্বয়ংক্রিয়ভাবে একটি স্ট্রিং অবজেক্টে রূপান্তরিত হয় স্ট্রিং প্রোটোটাইপ ফাংশন দ্বারা। সুতরাং, সমস্ত স্ট্রিং এর (স্ট্রিং অবজেক্ট) সেই মেথডের অ্যাক্সেস আছে!
+
+জাভাস্ক্রিপ্টে এটাকে **প্রোটোটাইপ ইনহেরিটেন্স** বলা হয়। প্রোটোটাইপ ইনহেরিটেন্স হল একটি নির্দিষ্ট টাইপের (যেমন স্ট্রিং) এর সমস্ত ইন্সট্যান্সগুলির মধ্যে প্রোপার্টিস এবং মেথডগুলি শেয়ার করার একটি উপায় এবং এভাবেই আপনার দেওয়া `giveLydiaPizza` মেথডটি আপনার তৈরি করা প্রতিটি স্ট্রিংয়ের জন্য অ্যাক্সেসেবল হয়ে যায়। এটি একযোগে সমস্ত স্ট্রিংগুলিতে একটি নতুন প্রোপার্টি যুক্ত করার মতো!
+
+</p>
+</details>
+
+---
+
+###### 29. এটার আউটপুট কোনটা?
+
+```javascript
+const a = {};
+const b = { key: "b" };
+const c = { key: "c" };
+
+a[b] = 123;
+a[c] = 456;
+
+console.log(a[b]);
+```
+
+- A: `123`
+- B: `456`
+- C: `undefined`
+- D: `ReferenceError`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: B
+
+Object keys are automatically converted into strings. We are trying to set an object as a key to object `a`, with the value of `123`.
+
+However, when we stringify an object, it becomes `"[object Object]"`. So what we are saying here, is that `a["[object Object]"] = 123`. Then, we can try to do the same again. `c` is another object that we are implicitly stringifying. So then, `a["[object Object]"] = 456`.
+
+Then, we log `a[b]`, which is actually `a["[object Object]"]`. We just set that to `456`, so it returns `456`.
+
+</p>
+</details>
+
+---
+
+###### 30. এটার আউটপুট কোনটা?
+
+```javascript
+const foo = () => console.log("First");
+const bar = () => setTimeout(() => console.log("Second"));
+const baz = () => console.log("Third");
+
+bar();
+foo();
+baz();
+```
+
+- A: `First` `Second` `Third`
+- B: `First` `Third` `Second`
+- C: `Second` `First` `Third`
+- D: `Second` `Third` `First`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: B
+
+We have a `setTimeout` function and invoked it first. Yet, it was logged last.
+
+This is because in browsers, we don't just have the runtime engine, we also have something called a `WebAPI`. The `WebAPI` gives us the `setTimeout` function to start with, and for example the DOM.
+
+After the _callback_ is pushed to the WebAPI, the `setTimeout` function itself (but not the callback!) is popped off the stack.
+
+<img src="https://i.imgur.com/X5wsHOg.png" width="200">
+
+Now, `foo` gets invoked, and `"First"` is being logged.
+
+<img src="https://i.imgur.com/Pvc0dGq.png" width="200">
+
+`foo` is popped off the stack, and `baz` gets invoked. `"Third"` gets logged.
+
+<img src="https://i.imgur.com/WhA2bCP.png" width="200">
+
+The WebAPI can't just add stuff to the stack whenever it's ready. Instead, it pushes the callback function to something called the _queue_.
+
+<img src="https://i.imgur.com/NSnDZmU.png" width="200">
+
+This is where an event loop starts to work. An **event loop** looks at the stack and task queue. If the stack is empty, it takes the first thing on the queue and pushes it onto the stack.
+
+<img src="https://i.imgur.com/uyiScAI.png" width="200">
+
+`bar` gets invoked, `"Second"` gets logged, and it's popped off the stack.
+
+</p>
+</details>
+
+---
+
+###### 31. What is the event.target when clicking the button?
+
+```html
+<div onclick="console.log('first div')">
+  <div onclick="console.log('second div')">
+    <button onclick="console.log('button')">Click!</button>
+  </div>
+</div>
+```
+
+- A: Outer `div`
+- B: Inner `div`
+- C: `button`
+- D: An array of all nested elements.
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+The deepest nested element that caused the event is the target of the event. You can stop bubbling by `event.stopPropagation`
+
+</p>
+</details>
+
+---
+
+###### 32. When you click the paragraph, what's the logged output?
+
+```html
+<div onclick="console.log('div')">
+  <p onclick="console.log('p')">Click here!</p>
+</div>
+```
+
+- A: `p` `div`
+- B: `div` `p`
+- C: `p`
+- D: `div`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: A
+
+If we click `p`, we see two logs: `p` and `div`. During event propagation, there are 3 phases: capturing, targeting, and bubbling. By default, event handlers are executed in the bubbling phase (unless you set `useCapture` to `true`). It goes from the deepest nested element outwards.
+
+</p>
+</details>
+
+---
+
+###### 33. এটার আউটপুট কোনটা?
+
+```javascript
+const person = { name: "Lydia" };
+
+function sayHi(age) {
+  return `${this.name} is ${age}`;
+}
+
+console.log(sayHi.call(person, 21));
+console.log(sayHi.bind(person, 21));
+```
+
+- A: `undefined is 21` `Lydia is 21`
+- B: `function` `function`
+- C: `Lydia is 21` `Lydia is 21`
+- D: `Lydia is 21` `function`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: D
+
+With both, we can pass the object to which we want the `this` keyword to refer to. However, `.call` is also _executed immediately_!
+
+`.bind.` returns a _copy_ of the function, but with a bound context! It is not executed immediately.
+
+</p>
+</details>
+
+---
+
+###### 34. এটার আউটপুট কোনটা?
+
+```javascript
+function sayHi() {
+  return (() => 0)();
+}
+
+console.log(typeof sayHi());
+```
+
+- A: `"object"`
+- B: `"number"`
+- C: `"function"`
+- D: `"undefined"`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: B
+
+The `sayHi` function returns the returned value of the immediately invoked function expression (IIFE). This function returned `0`, which is type `"number"`.
+FYI: `typeof` can return the following list of values: `undefined`, `boolean`, `number`, `bigint`, `string`, `symbol`, `function` and `object`. Note that `typeof null` returns `"object"`.
+
+</p>
+</details>
+
+---
+
+###### 35. Which of these values are falsy?
+
+```javascript
+0;
+new Number(0);
+("");
+(" ");
+new Boolean(false);
+undefined;
+```
+
+- A: `0`, `''`, `undefined`
+- B: `0`, `new Number(0)`, `''`, `new Boolean(false)`, `undefined`
+- C: `0`, `''`, `new Boolean(false)`, `undefined`
+- D: All of them are falsy
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: A
+
+There are 8 falsy values:
+
+- `undefined`
+- `null`
+- `NaN`
+- `false`
+- `''` (empty string)
+- `0`
+- `-0`
+- `0n` (BigInt(0))
+
+Function constructors, like `new Number` and `new Boolean` are truthy.
+
+</p>
+</details>
+
+---
+
+###### 36. এটার আউটপুট কোনটা?
+
+```javascript
+console.log(typeof typeof 1);
+```
+
+- A: `"number"`
+- B: `"string"`
+- C: `"object"`
+- D: `"undefined"`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: B
+
+`typeof 1` returns `"number"`.
+`typeof "number"` returns `"string"`
+
+</p>
+</details>
+
+---
+
+###### 37. এটার আউটপুট কোনটা?
+
+```javascript
+const numbers = [1, 2, 3];
+numbers[10] = 11;
+console.log(numbers);
+```
+
+- A: `[1, 2, 3, null x 7, 11]`
+- B: `[1, 2, 3, 11]`
+- C: `[1, 2, 3, empty x 7, 11]`
+- D: `SyntaxError`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+When you set a value to an element in an array that exceeds the length of the array, JavaScript creates something called "empty slots". These actually have the value of `undefined`, but you will see something like:
+
+`[1, 2, 3, empty x 7, 11]`
+
+depending on where you run it (it's different for every browser, node, etc.)
+
+</p>
+</details>
+
+---
+
+###### 38. এটার আউটপুট কোনটা?
+
+```javascript
+(() => {
+  let x, y;
+  try {
+    throw new Error();
+  } catch (x) {
+    (x = 1), (y = 2);
+    console.log(x);
+  }
+  console.log(x);
+  console.log(y);
+})();
+```
+
+- A: `1` `undefined` `2`
+- B: `undefined` `undefined` `undefined`
+- C: `1` `1` `2`
+- D: `1` `undefined` `undefined`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: A
+
+The `catch` block receives the argument `x`. This is not the same `x` as the variable when we pass arguments. This variable `x` is block-scoped.
+
+Later, we set this block-scoped variable equal to `1`, and set the value of the variable `y`. Now, we log the block-scoped variable `x`, which is equal to `1`.
+
+Outside of the `catch` block, `x` is still `undefined`, and `y` is `2`. When we want to `console.log(x)` outside of the `catch` block, it returns `undefined`, and `y` returns `2`.
+
+</p>
+</details>
+
+---
+
+###### 39. Everything in JavaScript is either a...
+
+- A: primitive or object
+- B: function or object
+- C: trick question! only objects
+- D: number or object
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: A
+
+JavaScript only has primitive types and objects.
+
+Primitive types are `boolean`, `null`, `undefined`, `bigint`, `number`, `string`, and `symbol`.
+
+What differentiates a primitive from an object is that primitives do not have any properties or methods; however, you'll note that `'foo'.toUpperCase()` evaluates to `'FOO'` and does not result in a `TypeError`. This is because when you try to access a property or method on a primitive like a string, JavaScript will implicitly wrap the primitive type using one of the wrapper classes, i.e. `String`, and then immediately discard the wrapper after the expression evaluates. All primitives except for `null` and `undefined` exhibit this behavior.
+
+</p>
+</details>
+
+---
+
+###### 40. এটার আউটপুট কোনটা?
+
+```javascript
+[
+  [0, 1],
+  [2, 3],
+].reduce(
+  (acc, cur) => {
+    return acc.concat(cur);
+  },
+  [1, 2]
+);
+```
+
+- A: `[0, 1, 2, 3, 1, 2]`
+- B: `[6, 1, 2]`
+- C: `[1, 2, 0, 1, 2, 3]`
+- D: `[1, 2, 6]`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+`[1, 2]` is our initial value. This is the value we start with, and the value of the very first `acc`. During the first round, `acc` is `[1,2]`, and `cur` is `[0, 1]`. We concatenate them, which results in `[1, 2, 0, 1]`.
+
+Then, `[1, 2, 0, 1]` is `acc` and `[2, 3]` is `cur`. We concatenate them, and get `[1, 2, 0, 1, 2, 3]`
+
+</p>
+</details>
+
+---
+
+###### 41. এটার আউটপুট কোনটা?
+
+```javascript
+!!null;
+!!"";
+!!1;
+```
+
+- A: `false` `true` `false`
+- B: `false` `false` `true`
+- C: `false` `true` `true`
+- D: `true` `true` `false`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: B
+
+`null` is falsy. `!null` returns `true`. `!true` returns `false`.
+
+`""` is falsy. `!""` returns `true`. `!true` returns `false`.
+
+`1` is truthy. `!1` returns `false`. `!false` returns `true`.
+
+</p>
+</details>
+
+---
+
+###### 42. What does the `setInterval` method return in the browser?
+
+```javascript
+setInterval(() => console.log("Hi"), 1000);
+```
+
+- A: a unique id
+- B: the amount of milliseconds specified
+- C: the passed function
+- D: `undefined`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: A
+
+It returns a unique id. This id can be used to clear that interval with the `clearInterval()` function.
+
+</p>
+</details>
+
+---
+
+###### 43. What does this return?
+
+```javascript
+[..."Lydia"];
+```
+
+- A: `["L", "y", "d", "i", "a"]`
+- B: `["Lydia"]`
+- C: `[[], "Lydia"]`
+- D: `[["L", "y", "d", "i", "a"]]`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: A
+
+A string is an iterable. The spread operator maps every character of an iterable to one element.
+
+</p>
+</details>
+
+---
+
+###### 44. এটার আউটপুট কোনটা?
+
+```javascript
+function* generator(i) {
+  yield i;
+  yield i * 2;
+}
+
+const gen = generator(10);
+
+console.log(gen.next().value);
+console.log(gen.next().value);
+```
+
+- A: `[0, 10], [10, 20]`
+- B: `20, 20`
+- C: `10, 20`
+- D: `0, 10 and 10, 20`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+Regular functions cannot be stopped mid-way after invocation. However, a generator function can be "stopped" midway, and later continue from where it stopped. Every time a generator function encounters a `yield` keyword, the function yields the value specified after it. Note that the generator function in that case doesn’t _return_ the value, it _yields_ the value.
+
+First, we initialize the generator function with `i` equal to `10`. We invoke the generator function using the `next()` method. The first time we invoke the generator function, `i` is equal to `10`. It encounters the first `yield` keyword: it yields the value of `i`. The generator is now "paused", and `10` gets logged.
+
+Then, we invoke the function again with the `next()` method. It starts to continue where it stopped previously, still with `i` equal to `10`. Now, it encounters the next `yield` keyword, and yields `i * 2`. `i` is equal to `10`, so it returns `10 * 2`, which is `20`. This results in `10, 20`.
+
+</p>
+</details>
+
+---
+
+###### 45. What does this return?
+
+```javascript
+const firstPromise = new Promise((res, rej) => {
+  setTimeout(res, 500, "one");
+});
+
+const secondPromise = new Promise((res, rej) => {
+  setTimeout(res, 100, "two");
+});
+
+Promise.race([firstPromise, secondPromise]).then((res) => console.log(res));
+```
+
+- A: `"one"`
+- B: `"two"`
+- C: `"two" "one"`
+- D: `"one" "two"`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: B
+
+When we pass multiple promises to the `Promise.race` method, it resolves/rejects the _first_ promise that resolves/rejects. To the `setTimeout` method, we pass a timer: 500ms for the first promise (`firstPromise`), and 100ms for the second promise (`secondPromise`). This means that the `secondPromise` resolves first with the value of `'two'`. `res` now holds the value of `'two'`, which gets logged.
+
+</p>
+</details>
+
+---
+
+###### 46. এটার আউটপুট কোনটা?
+
+```javascript
+let person = { name: "Lydia" };
+const members = [person];
+person = null;
+
+console.log(members);
+```
+
+- A: `null`
+- B: `[null]`
+- C: `[{}]`
+- D: `[{ name: "Lydia" }]`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: D
+
+First, we declare a variable `person` with the value of an object that has a `name` property.
+
+<img src="https://i.imgur.com/TML1MbS.png" width="200">
+
+Then, we declare a variable called `members`. We set the first element of that array equal to the value of the `person` variable. Objects interact by _reference_ when setting them equal to each other. When you assign a reference from one variable to another, you make a _copy_ of that reference. (note that they don't have the _same_ reference!)
+
+<img src="https://i.imgur.com/FSG5K3F.png" width="300">
+
+Then, we set the variable `person` equal to `null`.
+
+<img src="https://i.imgur.com/sYjcsMT.png" width="300">
+
+We are only modifying the value of the `person` variable, and not the first element in the array, since that element has a different (copied) reference to the object. The first element in `members` still holds its reference to the original object. When we log the `members` array, the first element still holds the value of the object, which gets logged.
+
+</p>
+</details>
+
+---
+
+###### 47. এটার আউটপুট কোনটা?
+
+```javascript
+const person = {
+  name: "Lydia",
+  age: 21,
+};
+
+for (const item in person) {
+  console.log(item);
+}
+```
+
+- A: `{ name: "Lydia" }, { age: 21 }`
+- B: `"name", "age"`
+- C: `"Lydia", 21`
+- D: `["name", "Lydia"], ["age", 21]`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: B
+
+With a `for-in` loop, we can iterate through object keys, in this case `name` and `age`. Under the hood, object keys are strings (if they're not a Symbol). On every loop, we set the value of `item` equal to the current key it’s iterating over. First, `item` is equal to `name`, and gets logged. Then, `item` is equal to `age`, which gets logged.
+
+</p>
+</details>
+
+---
+
+###### 48. এটার আউটপুট কোনটা?
+
+```javascript
+console.log(3 + 4 + "5");
+```
+
+- A: `"345"`
+- B: `"75"`
+- C: `12`
+- D: `"12"`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: B
+
+Operator associativity is the order in which the compiler evaluates the expressions, either left-to-right or right-to-left. This only happens if all operators have the _same_ precedence. We only have one type of operator: `+`. For addition, the associativity is left-to-right.
+
+`3 + 4` gets evaluated first. This results in the number `7`.
+
+`7 + '5'` results in `"75"` because of coercion. JavaScript converts the number `7` into a string, see question 15. We can concatenate two strings using the `+`operator. `"7" + "5"` results in `"75"`.
+
+</p>
+</details>
+
+---
+
+###### 49. What's the value of `num`?
+
+```javascript
+const num = parseInt("7*6", 10);
+```
+
+- A: `42`
+- B: `"42"`
+- C: `7`
+- D: `NaN`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+Only the first number in the string is returned. Based on the _radix_ (the second argument in order to specify what type of number we want to parse it to: base 10, hexadecimal, octal, binary, etc.), the `parseInt` checks whether the characters in the string are valid. Once it encounters a character that isn't a valid number in the radix, it stops parsing and ignores the following characters.
+
+`*` is not a valid number. It only parses `"7"` into the decimal `7`. `num` now holds the value of `7`.
+
+</p>
+</details>
+
+---
+
+###### 50. এটার আউটপুট কোনটা?
+
+```javascript
+[1, 2, 3].map((num) => {
+  if (typeof num === "number") return;
+  return num * 2;
+});
+```
+
+- A: `[]`
+- B: `[null, null, null]`
+- C: `[undefined, undefined, undefined]`
+- D: `[ 3 x empty ]`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+When mapping over the array, the value of `num` is equal to the element it’s currently looping over. In this case, the elements are numbers, so the condition of the if statement `typeof num === "number"` returns `true`. The map function creates a new array and inserts the values returned from the function.
+
+However, we don’t return a value. When we don’t return a value from the function, the function returns `undefined`. For every element in the array, the function block gets called, so for each element we return `undefined`.
+
+</p>
+</details>
+
+---
+
+###### 51. এটার আউটপুট কোনটা?
+
+```javascript
+function getInfo(member, year) {
+  member.name = "Lydia";
+  year = "1998";
+}
+
+const person = { name: "Sarah" };
+const birthYear = "1997";
+
+getInfo(person, birthYear);
+
+console.log(person, birthYear);
+```
+
+- A: `{ name: "Lydia" }, "1997"`
+- B: `{ name: "Sarah" }, "1998"`
+- C: `{ name: "Lydia" }, "1998"`
+- D: `{ name: "Sarah" }, "1997"`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: A
+
+Arguments are passed by _value_, unless their value is an object, then they're passed by _reference_. `birthYear` is passed by value, since it's a string, not an object. When we pass arguments by value, a _copy_ of that value is created (see question 46).
+
+The variable `birthYear` has a reference to the value `"1997"`. The argument `year` also has a reference to the value `"1997"`, but it's not the same value as `birthYear` has a reference to. When we update the value of `year` by setting `year` equal to `"1998"`, we are only updating the value of `year`. `birthYear` is still equal to `"1997"`.
+
+The value of `person` is an object. The argument `member` has a (copied) reference to the _same_ object. When we modify a property of the object `member` has a reference to, the value of `person` will also be modified, since they both have a reference to the same object. `person`'s `name` property is now equal to the value `"Lydia"`
+
+</p>
+</details>
+
+---
+
+###### 52. এটার আউটপুট কোনটা?
+
+```javascript
+function greeting() {
+  throw "Hello world!";
+}
+
+function sayHi() {
+  try {
+    const data = greeting();
+    console.log("It worked!", data);
+  } catch (e) {
+    console.log("Oh no an error:", e);
+  }
+}
+
+sayHi();
+```
+
+- A: `It worked! Hello world!`
+- B: `Oh no an error: undefined`
+- C: `SyntaxError: can only throw Error objects`
+- D: `Oh no an error: Hello world!`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: D
+
+With the `throw` statement, we can create custom errors. With this statement, you can throw exceptions. An exception can be a <b>string</b>, a <b>number</b>, a <b>boolean</b> or an <b>object</b>. In this case, our exception is the string `'Hello world!'`.
+
+With the `catch` statement, we can specify what to do if an exception is thrown in the `try` block. An exception is thrown: the string `'Hello world!'`. `e` is now equal to that string, which we log. This results in `'Oh an error: Hello world!'`.
+
+</p>
+</details>
+
+---
+
+###### 53. এটার আউটপুট কোনটা?
+
+```javascript
+function Car() {
+  this.make = "Lamborghini";
+  return { make: "Maserati" };
+}
+
+const myCar = new Car();
+console.log(myCar.make);
+```
+
+- A: `"Lamborghini"`
+- B: `"Maserati"`
+- C: `ReferenceError`
+- D: `TypeError`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: B
+
+When a constructor function is called with the `new` keyword, it creates an object and sets the `this` keyword to refer to that object. By default, if the constructor function doesn't explicitly return anything, it will return the newly created object.
+
+In this case, the constructor function `Car` explicitly returns a new object with `make` set to `"Maserati"`, which overrides the default behavior. Therefore, when `new Car()` is called, the _returned_ object is assigned to `myCar`, resulting in the output being `"Maserati"` when `myCar.make` is accessed.
+
+</p>
+</details>
+
+---
+
+###### 54. এটার আউটপুট কোনটা?
+
+```javascript
+(() => {
+  let x = (y = 10);
+})();
+
+console.log(typeof x);
+console.log(typeof y);
+```
+
+- A: `"undefined", "number"`
+- B: `"number", "number"`
+- C: `"object", "number"`
+- D: `"number", "undefined"`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: A
+
+`let x = (y = 10);` is actually shorthand for:
+
+```javascript
+y = 10;
+let x = y;
+```
+
+When we set `y` equal to `10`, we actually add a property `y` to the global object (`window` in the browser, `global` in Node). In a browser, `window.y` is now equal to `10`.
+
+Then, we declare a variable `x` with the value of `y`, which is `10`. Variables declared with the `let` keyword are _block scoped_, they are only defined within the block they're declared in; the immediately invoked function expression (IIFE) in this case. When we use the `typeof` operator, the operand `x` is not defined: we are trying to access `x` outside of the block it's declared in. This means that `x` is not defined. Values who haven't been assigned a value or declared are of type `"undefined"`. `console.log(typeof x)` returns `"undefined"`.
+
+However, we created a global variable `y` when setting `y` equal to `10`. This value is accessible anywhere in our code. `y` is defined, and holds a value of type `"number"`. `console.log(typeof y)` returns `"number"`.
+
+</p>
+</details>
+
+---
+
+###### 55. এটার আউটপুট কোনটা?
+
+```javascript
+class Dog {
+  constructor(name) {
+    this.name = name;
+  }
+}
+
+Dog.prototype.bark = function () {
+  console.log(`Woof I am ${this.name}`);
+};
+
+const pet = new Dog("Mara");
+
+pet.bark();
+
+delete Dog.prototype.bark;
+
+pet.bark();
+```
+
+- A: `"Woof I am Mara"`, `TypeError`
+- B: `"Woof I am Mara"`, `"Woof I am Mara"`
+- C: `"Woof I am Mara"`, `undefined`
+- D: `TypeError`, `TypeError`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: A
+
+We can delete properties from objects using the `delete` keyword, also on the prototype. By deleting a property on the prototype, it is not available anymore in the prototype chain. In this case, the `bark` function is not available anymore on the prototype after `delete Dog.prototype.bark`, yet we still try to access it.
+
+When we try to invoke something that is not a function, a `TypeError` is thrown. In this case `TypeError: pet.bark is not a function`, since `pet.bark` is `undefined`.
+
+</p>
+</details>
+
+---
+
+###### 56. এটার আউটপুট কোনটা?
+
+```javascript
+const set = new Set([1, 1, 2, 3, 4]);
+
+console.log(set);
+```
+
+- A: `[1, 1, 2, 3, 4]`
+- B: `[1, 2, 3, 4]`
+- C: `{1, 1, 2, 3, 4}`
+- D: `{1, 2, 3, 4}`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: D
+
+The `Set` object is a collection of _unique_ values: a value can only occur once in a set.
+
+We passed the iterable `[1, 1, 2, 3, 4]` with a duplicate value `1`. Since we cannot have two of the same values in a set, one of them is removed. This results in `{1, 2, 3, 4}`.
+
+</p>
+</details>
+
+---
+
+###### 57. এটার আউটপুট কোনটা?
+
+```javascript
+// counter.js
+let counter = 10;
+export default counter;
+```
+
+```javascript
+// index.js
+import myCounter from "./counter";
+
+myCounter += 1;
+
+console.log(myCounter);
+```
+
+- A: `10`
+- B: `11`
+- C: `Error`
+- D: `NaN`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+An imported module is _read-only_: you cannot modify the imported module. Only the module that exports them can change its value.
+
+When we try to increment the value of `myCounter`, it throws an error: `myCounter` is read-only and cannot be modified.
+
+</p>
+</details>
+
+---
+
+###### 58. এটার আউটপুট কোনটা?
+
+```javascript
+const name = "Lydia";
+age = 21;
+
+console.log(delete name);
+console.log(delete age);
+```
+
+- A: `false`, `true`
+- B: `"Lydia"`, `21`
+- C: `true`, `true`
+- D: `undefined`, `undefined`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: A
+
+The `delete` operator returns a boolean value: `true` on a successful deletion, else it'll return `false`. However, variables declared with the `var`, `const`, or `let` keywords cannot be deleted using the `delete` operator.
+
+The `name` variable was declared with a `const` keyword, so its deletion is not successful: `false` is returned. When we set `age` equal to `21`, we actually added a property called `age` to the global object. You can successfully delete properties from objects this way, also the global object, so `delete age` returns `true`.
+
+</p>
+</details>
+
+---
+
+###### 59. এটার আউটপুট কোনটা?
+
+```javascript
+const numbers = [1, 2, 3, 4, 5];
+const [y] = numbers;
+
+console.log(y);
+```
+
+- A: `[[1, 2, 3, 4, 5]]`
+- B: `[1, 2, 3, 4, 5]`
+- C: `1`
+- D: `[1]`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+We can unpack values from arrays or properties from objects through destructuring. For example:
+
+```javascript
+[a, b] = [1, 2];
+```
+
+<img src="https://i.imgur.com/ADFpVop.png" width="200">
+
+The value of `a` is now `1`, and the value of `b` is now `2`. What we actually did in the question, is:
+
+```javascript
+[y] = [1, 2, 3, 4, 5];
+```
+
+<img src="https://i.imgur.com/NzGkMNk.png" width="200">
+
+This means that the value of `y` is equal to the first value in the array, which is the number `1`. When we log `y`, `1` is returned.
+
+</p>
+</details>
+
+---
+
+###### 60. এটার আউটপুট কোনটা?
+
+```javascript
+const user = { name: "Lydia", age: 21 };
+const admin = { admin: true, ...user };
+
+console.log(admin);
+```
+
+- A: `{ admin: true, user: { name: "Lydia", age: 21 } }`
+- B: `{ admin: true, name: "Lydia", age: 21 }`
+- C: `{ admin: true, user: ["Lydia", 21] }`
+- D: `{ admin: true }`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: B
+
+It's possible to combine objects using the spread operator `...`. It lets you create copies of the key/value pairs of one object, and add them to another object. In this case, we create copies of the `user` object, and add them to the `admin` object. The `admin` object now contains the copied key/value pairs, which results in `{ admin: true, name: "Lydia", age: 21 }`.
+
+</p>
+</details>
+
+---
+
+###### 61. এটার আউটপুট কোনটা?
+
+```javascript
+const person = { name: "Lydia" };
+
+Object.defineProperty(person, "age", { value: 21 });
+
+console.log(person);
+console.log(Object.keys(person));
+```
+
+- A: `{ name: "Lydia", age: 21 }`, `["name", "age"]`
+- B: `{ name: "Lydia", age: 21 }`, `["name"]`
+- C: `{ name: "Lydia"}`, `["name", "age"]`
+- D: `{ name: "Lydia"}`, `["age"]`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: B
+
+With the `defineProperty` method, we can add new properties to an object, or modify existing ones. When we add a property to an object using the `defineProperty` method, they are by default _not enumerable_. The `Object.keys` method returns all _enumerable_ property names from an object, in this case only `"name"`.
+
+Properties added using the `defineProperty` method are immutable by default. You can override this behavior using the `writable`, `configurable` and `enumerable` properties. This way, the `defineProperty` method gives you a lot more control over the properties you're adding to an object.
+
+</p>
+</details>
+
+---
+
+###### 62. এটার আউটপুট কোনটা?
+
+```javascript
+const settings = {
+  username: "lydiahallie",
+  level: 19,
+  health: 90,
+};
+
+const data = JSON.stringify(settings, ["level", "health"]);
+console.log(data);
+```
+
+- A: `"{"level":19, "health":90}"`
+- B: `"{"username": "lydiahallie"}"`
+- C: `"["level", "health"]"`
+- D: `"{"username": "lydiahallie", "level":19, "health":90}"`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: A
+
+The second argument of `JSON.stringify` is the _replacer_. The replacer can either be a function or an array, and lets you control what and how the values should be stringified.
+
+If the replacer is an _array_, only the property names included in the array will be added to the JSON string. In this case, only the properties with the names `"level"` and `"health"` are included, `"username"` is excluded. `data` is now equal to `"{"level":19, "health":90}"`.
+
+If the replacer is a _function_, this function gets called on every property in the object you're stringifying. The value returned from this function will be the value of the property when it's added to the JSON string. If the value is `undefined`, this property is excluded from the JSON string.
+
+</p>
+</details>
+
+---
+
+###### 63. এটার আউটপুট কোনটা?
+
+```javascript
+let num = 10;
+
+const increaseNumber = () => num++;
+const increasePassedNumber = (number) => number++;
+
+const num1 = increaseNumber();
+const num2 = increasePassedNumber(num1);
+
+console.log(num1);
+console.log(num2);
+```
+
+- A: `10`, `10`
+- B: `10`, `11`
+- C: `11`, `11`
+- D: `11`, `12`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: A
+
+The unary operator `++` _first returns_ the value of the operand, _then increments_ the value of the operand. The value of `num1` is `10`, since the `increaseNumber` function first returns the value of `num`, which is `10`, and only increments the value of `num` afterward.
+
+`num2` is `10`, since we passed `num1` to the `increasePassedNumber`. `number` is equal to `10`(the value of `num1`). Again, the unary operator `++` _first returns_ the value of the operand, _then increments_ the value of the operand. The value of `number` is `10`, so `num2` is equal to `10`.
+
+</p>
+</details>
+
+---
+
+###### 64. এটার আউটপুট কোনটা?
+
+```javascript
+const value = { number: 10 };
+
+const multiply = (x = { ...value }) => {
+  console.log((x.number *= 2));
+};
+
+multiply();
+multiply();
+multiply(value);
+multiply(value);
+```
+
+- A: `20`, `40`, `80`, `160`
+- B: `20`, `40`, `20`, `40`
+- C: `20`, `20`, `20`, `40`
+- D: `NaN`, `NaN`, `20`, `40`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+In ES6, we can initialize parameters with a default value. The value of the parameter will be the default value, if no other value has been passed to the function, or if the value of the parameter is `"undefined"`. In this case, we spread the properties of the `value` object into a new object, so `x` has the default value of `{ number: 10 }`.
+
+The default argument is evaluated at _call time_! Every time we call the function, a _new_ object is created. We invoke the `multiply` function the first two times without passing a value: `x` has the default value of `{ number: 10 }`. We then log the multiplied value of that number, which is `20`.
+
+The third time we invoke multiply, we do pass an argument: the object called `value`. The `*=` operator is actually shorthand for `x.number = x.number * 2`: we modify the value of `x.number`, and log the multiplied value `20`.
+
+The fourth time, we pass the `value` object again. `x.number` was previously modified to `20`, so `x.number *= 2` logs `40`.
+
+</p>
+</details>
+
+---
+
+###### 65. এটার আউটপুট কোনটা?
+
+```javascript
+[1, 2, 3, 4].reduce((x, y) => console.log(x, y));
+```
+
+- A: `1` `2` and `3` `3` and `6` `4`
+- B: `1` `2` and `2` `3` and `3` `4`
+- C: `1` `undefined` and `2` `undefined` and `3` `undefined` and `4` `undefined`
+- D: `1` `2` and `undefined` `3` and `undefined` `4`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: D
+
+The first argument that the `reduce` method receives is the _accumulator_, `x` in this case. The second argument is the _current value_, `y`. With the reduce method, we execute a callback function on every element in the array, which could ultimately result in one single value.
+
+In this example, we are not returning any values, we are simply logging the values of the accumulator and the current value.
+
+The value of the accumulator is equal to the previously returned value of the callback function. If you don't pass the optional `initialValue` argument to the `reduce` method, the accumulator is equal to the first element on the first call.
+
+On the first call, the accumulator (`x`) is `1`, and the current value (`y`) is `2`. We don't return from the callback function, we log the accumulator, and the current values: `1` and `2` get logged.
+
+If you don't return a value from a function, it returns `undefined`. On the next call, the accumulator is `undefined`, and the current value is `3`. `undefined` and `3` get logged.
+
+On the fourth call, we again don't return from the callback function. The accumulator is again `undefined`, and the current value is `4`. `undefined` and `4` get logged.
+
+</p>
+</details>
+  
+---
+
+###### 66. With which constructor can we successfully extend the `Dog` class?
+
+```javascript
+class Dog {
+  constructor(name) {
+    this.name = name;
+  }
+};
+
+class Labrador extends Dog {
+  // 1
+  constructor(name, size) {
+    this.size = size;
+  }
+  // 2
+  constructor(name, size) {
+    super(name);
+    this.size = size;
+  }
+  // 3
+  constructor(size) {
+    super(name);
+    this.size = size;
+  }
+  // 4
+  constructor(name, size) {
+    this.name = name;
+    this.size = size;
+  }
+
+};
+```
+
+- A: 1
+- B: 2
+- C: 3
+- D: 4
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: B
+
+In a derived class, you cannot access the `this` keyword before calling `super`. If you try to do that, it will throw a ReferenceError: 1 and 4 would throw a reference error.
+
+With the `super` keyword, we call that parent class's constructor with the given arguments. The parent's constructor receives the `name` argument, so we need to pass `name` to `super`.
+
+The `Labrador` class receives two arguments, `name` since it extends `Dog`, and `size` as an extra property on the `Labrador` class. They both need to be passed to the constructor function on `Labrador`, which is done correctly using constructor 2.
+
+</p>
+</details>
+
+---
+
+###### 67. এটার আউটপুট কোনটা?
+
+```javascript
+// index.js
+console.log("running index.js");
+import { sum } from "./sum.js";
+console.log(sum(1, 2));
+
+// sum.js
+console.log("running sum.js");
+export const sum = (a, b) => a + b;
+```
+
+- A: `running index.js`, `running sum.js`, `3`
+- B: `running sum.js`, `running index.js`, `3`
+- C: `running sum.js`, `3`, `running index.js`
+- D: `running index.js`, `undefined`, `running sum.js`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: B
+
+With the `import` keyword, all imported modules are _pre-parsed_. This means that the imported modules get run _first_, and the code in the file that imports the module gets executed _after_.
+
+This is a difference between `require()` in CommonJS and `import`! With `require()`, you can load dependencies on demand while the code is being run. If we had used `require` instead of `import`, `running index.js`, `running sum.js`, `3` would have been logged to the console.
+
+</p>
+</details>
+
+---
+
+###### 68. এটার আউটপুট কোনটা?
+
+```javascript
+console.log(Number(2) === Number(2));
+console.log(Boolean(false) === Boolean(false));
+console.log(Symbol("foo") === Symbol("foo"));
+```
+
+- A: `true`, `true`, `false`
+- B: `false`, `true`, `false`
+- C: `true`, `false`, `true`
+- D: `true`, `true`, `true`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: A
+
+Every Symbol is entirely unique. The purpose of the argument passed to the Symbol is to give the Symbol a description. The value of the Symbol is not dependent on the passed argument. As we test equality, we are creating two entirely new symbols: the first `Symbol('foo')`, and the second `Symbol('foo')`. These two values are unique and not equal to each other, `Symbol('foo') === Symbol('foo')` returns `false`.
+
+</p>
+</details>
+
+---
+
+###### 69. এটার আউটপুট কোনটা?
+
+```javascript
+const name = "Lydia Hallie";
+console.log(name.padStart(13));
+console.log(name.padStart(2));
+```
+
+- A: `"Lydia Hallie"`, `"Lydia Hallie"`
+- B: `" Lydia Hallie"`, `" Lydia Hallie"` (`"[13x whitespace]Lydia Hallie"`, `"[2x whitespace]Lydia Hallie"`)
+- C: `" Lydia Hallie"`, `"Lydia Hallie"` (`"[1x whitespace]Lydia Hallie"`, `"Lydia Hallie"`)
+- D: `"Lydia Hallie"`, `"Lyd"`,
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+With the `padStart` method, we can add padding to the beginning of a string. The value passed to this method is the _total_ length of the string together with the padding. The string `"Lydia Hallie"` has a length of `12`. `name.padStart(13)` inserts 1 space at the start of the string, because 12 + 1 is 13.
+
+If the argument passed to the `padStart` method is smaller than the length of the array, no padding will be added.
+
+</p>
+</details>
+
+---
+
+###### 70. এটার আউটপুট কোনটা?
+
+```javascript
+console.log("🥑" + "💻");
+```
+
+- A: `"🥑💻"`
+- B: `257548`
+- C: A string containing their code points
+- D: Error
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: A
+
+With the `+` operator, you can concatenate strings. In this case, we are concatenating the string `"🥑"` with the string `"💻"`, resulting in `"🥑💻"`.
+
+</p>
+</details>
+
+---
+
+###### 71. How can we log the values that are commented out after the console.log statement?
+
+```javascript
+function* startGame() {
+  const উত্তর = yield "Do you love JavaScript?";
+  if (উত্তর !== "Yes") {
+    return "Oh wow... Guess we're done here";
+  }
+  return "JavaScript loves you back ❤️";
+}
+
+const game = startGame();
+console.log(/* 1 */); // Do you love JavaScript?
+console.log(/* 2 */); // JavaScript loves you back ❤️
+```
+
+- A: `game.next("Yes").value` and `game.next().value`
+- B: `game.next.value("Yes")` and `game.next.value()`
+- C: `game.next().value` and `game.next("Yes").value`
+- D: `game.next.value()` and `game.next.value("Yes")`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+A generator function "pauses" its execution when it sees the `yield` keyword. First, we have to let the function yield the string "Do you love JavaScript?", which can be done by calling `game.next().value`.
+
+Every line is executed, until it finds the first `yield` keyword. There is a `yield` keyword on the first line within the function: the execution stops with the first yield! _This means that the variable `উত্তর` is not defined yet!_
+
+When we call `game.next("Yes").value`, the previous `yield` is replaced with the value of the parameters passed to the `next()` function, `"Yes"` in this case. The value of the variable `উত্তর` is now equal to `"Yes"`. The condition of the if-statement returns `false`, and `JavaScript loves you back ❤️` gets logged.
+
+</p>
+</details>
+
+---
+
+###### 72. এটার আউটপুট কোনটা?
+
+```javascript
+console.log(String.raw`Hello\nworld`);
+```
+
+- A: `Hello world!`
+- B: `Hello` <br />&nbsp; &nbsp; &nbsp;`world`
+- C: `Hello\nworld`
+- D: `Hello\n` <br /> &nbsp; &nbsp; &nbsp;`world`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+`String.raw` returns a string where the escapes (`\n`, `\v`, `\t` etc.) are ignored! Backslashes can be an issue since you could end up with something like:
+
+`` const path = `C:\Documents\Projects\table.html` ``
+
+Which would result in:
+
+`"C:DocumentsProjects able.html"`
+
+With `String.raw`, it would simply ignore the escape and print:
+
+`C:\Documents\Projects\table.html`
+
+In this case, the string is `Hello\nworld`, which gets logged.
+
+</p>
+</details>
+
+---
+
+###### 73. এটার আউটপুট কোনটা?
+
+```javascript
+async function getData() {
+  return await Promise.resolve("I made it!");
+}
+
+const data = getData();
+console.log(data);
+```
+
+- A: `"I made it!"`
+- B: `Promise {<resolved>: "I made it!"}`
+- C: `Promise {<pending>}`
+- D: `undefined`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+An async function always returns a promise. The `await` still has to wait for the promise to resolve: a pending promise gets returned when we call `getData()` in order to set `data` equal to it.
+
+If we wanted to get access to the resolved value `"I made it"`, we could have used the `.then()` method on `data`:
+
+`data.then(res => console.log(res))`
+
+This would've logged `"I made it!"`
+
+</p>
+</details>
+
+---
+
+###### 74. এটার আউটপুট কোনটা?
+
+```javascript
+function addToList(item, list) {
+  return list.push(item);
+}
+
+const result = addToList("apple", ["banana"]);
+console.log(result);
+```
+
+- A: `['apple', 'banana']`
+- B: `2`
+- C: `true`
+- D: `undefined`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: B
+
+The `.push()` method returns the _length_ of the new array! Previously, the array contained one element (the string `"banana"`) and had a length of `1`. After adding the string `"apple"` to the array, the array contains two elements, and has a length of `2`. This gets returned from the `addToList` function.
+
+The `push` method modifies the original array. If you wanted to return the _array_ from the function rather than the _length of the array_, you should have returned `list` after pushing `item` to it.
+
+</p>
+</details>
+
+---
+
+###### 75. এটার আউটপুট কোনটা?
+
+```javascript
+const box = { x: 10, y: 20 };
+
+Object.freeze(box);
+
+const shape = box;
+shape.x = 100;
+
+console.log(shape);
+```
+
+- A: `{ x: 100, y: 20 }`
+- B: `{ x: 10, y: 20 }`
+- C: `{ x: 100 }`
+- D: `ReferenceError`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: B
+
+`Object.freeze` makes it impossible to add, remove, or modify properties of an object (unless the property's value is another object).
+
+When we create the variable `shape` and set it equal to the frozen object `box`, `shape` also refers to a frozen object. You can check whether an object is frozen by using `Object.isFrozen`. In this case, `Object.isFrozen(shape)` would return true, since the variable `shape` has a reference to a frozen object.
+
+Since `shape` is frozen, and since the value of `x` is not an object, we cannot modify the property `x`. `x` is still equal to `10`, and `{ x: 10, y: 20 }` gets logged.
+
+</p>
+</details>
+
+---
+
+###### 76. এটার আউটপুট কোনটা?
+
+```javascript
+const { firstName: myName } = { firstName: "Lydia" };
+
+console.log(firstName);
+```
+
+- A: `"Lydia"`
+- B: `"myName"`
+- C: `undefined`
+- D: `ReferenceError`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: D
+
+By using [destructuring assignment](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment) syntax we can unpack values from arrays, or properties from objects, into distinct variables:
+
+```javascript
+const { firstName } = { firstName: "Lydia" };
+// ES5 version:
+// var firstName = { firstName: 'Lydia' }.firstName;
+
+console.log(firstName); // "Lydia"
+```
+
+Also, a property can be unpacked from an object and assigned to a variable with a different name than the object property:
+
+```javascript
+const { firstName: myName } = { firstName: "Lydia" };
+// ES5 version:
+// var myName = { firstName: 'Lydia' }.firstName;
+
+console.log(myName); // "Lydia"
+console.log(firstName); // Uncaught ReferenceError: firstName is not defined
+```
+
+Therefore, `firstName` does not exist as a variable, thus attempting to access its value will raise a `ReferenceError`.
+
+**Note:** Be aware of the `global scope` properties:
+
+```javascript
+const { name: myName } = { name: "Lydia" };
+
+console.log(myName); // "lydia"
+console.log(name); // "" ----- Browser e.g. Chrome
+console.log(name); // ReferenceError: name is not defined  ----- NodeJS
+```
+
+Whenever Javascript is unable to find a variable within the _current scope_, it climbs up the [Scope chain](https://github.com/getify/You-Dont-Know-JS/blob/2nd-ed/scope-closures/ch3.md) and searches for it and if it reaches the top-level scope, aka **Global scope**, and still doesn't find it, it will throw a `ReferenceError`.
+
+- In **Browsers** such as _Chrome_, `name` is a _deprecated global scope property_. In this example, the code is running inside _global scope_ and there is no user-defined local variable for `name`, therefore it searches the predefined _variables/properties_ in the global scope which is in the case of browsers, it searches through `window` object and it will extract the [window.name](https://developer.mozilla.org/en-US/docs/Web/API/Window/name) value which is equal to an **empty string**.
+
+- In **NodeJS**, there is no such property on the `global` object, thus attempting to access a non-existent variable will raise a [ReferenceError](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Not_defined).
+
+</p>
+</details>
+
+---
+
+###### 77. Is this a pure function?
+
+```javascript
+function sum(a, b) {
+  return a + b;
+}
+```
+
+- A: Yes
+- B: No
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: A
+
+A pure function is a function that _always_ returns the same result, if the same arguments are passed.
+
+The `sum` function always returns the same result. If we pass `1` and `2`, it will _always_ return `3` without side effects. If we pass `5` and `10`, it will _always_ return `15`, and so on. This is the definition of a pure function.
+
+</p>
+</details>
+
+---
+
+###### 78. What is the output?
+
+```javascript
+const add = () => {
+  const cache = {};
+  return (num) => {
+    if (num in cache) {
+      return `From cache! ${cache[num]}`;
+    } else {
+      const result = num + 10;
+      cache[num] = result;
+      return `Calculated! ${result}`;
+    }
+  };
+};
+
+const addFunction = add();
+console.log(addFunction(10));
+console.log(addFunction(10));
+console.log(addFunction(5 * 2));
+```
+
+- A: `Calculated! 20` `Calculated! 20` `Calculated! 20`
+- B: `Calculated! 20` `From cache! 20` `Calculated! 20`
+- C: `Calculated! 20` `From cache! 20` `From cache! 20`
+- D: `Calculated! 20` `From cache! 20` `Error`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+The `add` function is a _memoized_ function. With memoization, we can cache the results of a function in order to speed up its execution. In this case, we create a `cache` object that stores the previously returned values.
+
+If we call the `addFunction` function again with the same argument, it first checks whether it has already gotten that value in its cache. If that's the case, the cache value will be returned, which saves execution time. Otherwise, if it's not cached, it will calculate the value and store it afterward.
+
+We call the `addFunction` function three times with the same value: on the first invocation, the value of the function when `num` is equal to `10` isn't cached yet. The condition of the if-statement `num in cache` returns `false`, and the else block gets executed: `Calculated! 20` gets logged, and the value of the result gets added to the cache object. `cache` now looks like `{ 10: 20 }`.
+
+The second time, the `cache` object contains the value that gets returned for `10`. The condition of the if-statement `num in cache` returns `true`, and `'From cache! 20'` gets logged.
+
+The third time, we pass `5 * 2` to the function which gets evaluated to `10`. The `cache` object contains the value that gets returned for `10`. The condition of the if-statement `num in cache` returns `true`, and `'From cache! 20'` gets logged.
+
+</p>
+</details>
+
+---
+
+###### 79. What is the output?
+
+```javascript
+const myLifeSummedUp = ["☕", "💻", "🍷", "🍫"];
+
+for (let item in myLifeSummedUp) {
+  console.log(item);
+}
+
+for (let item of myLifeSummedUp) {
+  console.log(item);
+}
+```
+
+- A: `0` `1` `2` `3` and `"☕"` `"💻"` `"🍷"` `"🍫"`
+- B: `"☕"` `"💻"` `"🍷"` `"🍫"` and `"☕"` `"💻"` `"🍷"` `"🍫"`
+- C: `"☕"` `"💻"` `"🍷"` `"🍫"` and `0` `1` `2` `3`
+- D: `0` `1` `2` `3` and `{0: "☕", 1: "💻", 2: "🍷", 3: "🍫"}`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: A
+
+With a _for-in_ loop, we can iterate over **enumerable** properties. In an array, the enumerable properties are the "keys" of array elements, which are actually their indexes. You could see an array as:
+
+`{0: "☕", 1: "💻", 2: "🍷", 3: "🍫"}`
+
+Where the keys are the enumerable properties. `0` `1` `2` `3` get logged.
+
+With a _for-of_ loop, we can iterate over **iterables**. An array is an iterable. When we iterate over the array, the variable "item" is equal to the element it's currently iterating over, `"☕"` `"💻"` `"🍷"` `"🍫"` get logged.
+
+</p>
+</details>
+
+---
+
+###### 80. What is the output?
+
+```javascript
+const list = [1 + 2, 1 * 2, 1 / 2];
+console.log(list);
+```
+
+- A: `["1 + 2", "1 * 2", "1 / 2"]`
+- B: `["12", 2, 0.5]`
+- C: `[3, 2, 0.5]`
+- D: `[1, 1, 1]`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+Array elements can hold any value. Numbers, strings, objects, other arrays, null, boolean values, undefined, and other expressions such as dates, functions, and calculations.
+
+The element will be equal to the returned value. `1 + 2` returns `3`, `1 * 2` returns `2`, and `1 / 2` returns `0.5`.
+
+</p>
+</details>
+
+---
+
+###### 81. What is the output?
+
+```javascript
+function sayHi(name) {
+  return `Hi there, ${name}`;
+}
+
+console.log(sayHi());
+```
+
+- A: `Hi there,`
+- B: `Hi there, undefined`
+- C: `Hi there, null`
+- D: `ReferenceError`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: B
+
+By default, arguments have the value of `undefined`, unless a value has been passed to the function. In this case, we didn't pass a value for the `name` argument. `name` is equal to `undefined` which gets logged.
+
+In ES6, we can overwrite this default `undefined` value with default parameters. For example:
+
+`function sayHi(name = "Lydia") { ... }`
+
+In this case, if we didn't pass a value or if we passed `undefined`, `name` would always be equal to the string `Lydia`
+
+</p>
+</details>
+
+---
+
+###### 82. What is the output?
+
+```javascript
+var status = "😎";
+
+setTimeout(() => {
+  const status = "😍";
+
+  const data = {
+    status: "🥑",
+    getStatus() {
+      return this.status;
+    },
+  };
+
+  console.log(data.getStatus());
+  console.log(data.getStatus.call(this));
+}, 0);
+```
+
+- A: `"🥑"` and `"😍"`
+- B: `"🥑"` and `"😎"`
+- C: `"😍"` and `"😎"`
+- D: `"😎"` and `"😎"`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: B
+
+The value of the `this` keyword is dependent on where you use it. In a **method**, like the `getStatus` method, the `this` keyword refers to _the object that the method belongs to_. The method belongs to the `data` object, so `this` refers to the `data` object. When we log `this.status`, the `status` property on the `data` object gets logged, which is `"🥑"`.
+
+With the `call` method, we can change the object to which the `this` keyword refers. In **functions**, the `this` keyword refers to the _the object that the function belongs to_. We declared the `setTimeout` function on the _global object_, so within the `setTimeout` function, the `this` keyword refers to the _global object_. On the global object, there is a variable called _status_ with the value of `"😎"`. When logging `this.status`, `"😎"` gets logged.
+
+</p>
+</details>
+
+---
+
+###### 83. What is the output?
+
+```javascript
+const person = {
+  name: "Lydia",
+  age: 21,
+};
+
+let city = person.city;
+city = "Amsterdam";
+
+console.log(person);
+```
+
+- A: `{ name: "Lydia", age: 21 }`
+- B: `{ name: "Lydia", age: 21, city: "Amsterdam" }`
+- C: `{ name: "Lydia", age: 21, city: undefined }`
+- D: `"Amsterdam"`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: A
+
+We set the variable `city` equal to the value of the property called `city` on the `person` object. There is no property on this object called `city`, so the variable `city` has the value of `undefined`.
+
+Note that we are _not_ referencing the `person` object itself! We simply set the variable `city` equal to the current value of the `city` property on the `person` object.
+
+Then, we set `city` equal to the string `"Amsterdam"`. This doesn't change the person object: there is no reference to that object.
+
+When logging the `person` object, the unmodified object gets returned.
+
+</p>
+</details>
+
+---
+
+###### 84. What is the output?
+
+```javascript
+function checkAge(age) {
+  if (age < 18) {
+    const message = "Sorry, you're too young.";
+  } else {
+    const message = "Yay! You're old enough!";
+  }
+
+  return message;
+}
+
+console.log(checkAge(21));
+```
+
+- A: `"Sorry, you're too young."`
+- B: `"Yay! You're old enough!"`
+- C: `ReferenceError`
+- D: `undefined`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+Variables with the `const` and `let` keywords are _block-scoped_. A block is anything between curly brackets (`{ }`). In this case, the curly brackets of the if/else statements. You cannot reference a variable outside of the block it's declared in, a ReferenceError gets thrown.
+
+</p>
+</details>
+
+---
+
+###### 85. What kind of information would get logged?
+
+```javascript
+fetch("https://www.website.com/api/user/1")
+  .then((res) => res.json())
+  .then((res) => console.log(res));
+```
+
+- A: The result of the `fetch` method.
+- B: The result of the second invocation of the `fetch` method.
+- C: The result of the callback in the previous `.then()`.
+- D: It would always be undefined.
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+The value of `res` in the second `.then` is equal to the returned value of the previous `.then`. You can keep chaining `.then`s like this, where the value is passed to the next handler.
+
+</p>
+</details>
+
+---
+
+###### 86. Which option is a way to set `hasName` equal to `true`, provided you cannot pass `true` as an argument?
+
+```javascript
+function getName(name) {
+  const hasName = //
+}
+```
+
+- A: `!!name`
+- B: `name`
+- C: `new Boolean(name)`
+- D: `name.length`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: A
+
+With `!!name`, we determine whether the value of `name` is truthy or falsy. If the name is truthy, which we want to test for, `!name` returns `false`. `!false` (which is what `!!name` practically is) returns `true`.
+
+By setting `hasName` equal to `name`, you set `hasName` equal to whatever value you passed to the `getName` function, not the boolean value `true`.
+
+`new Boolean(true)` returns an object wrapper, not the boolean value itself.
+
+`name.length` returns the length of the passed argument, not whether it's `true`.
+
+</p>
+</details>
+
+---
+
+###### 87. এটার আউটপুট কোনটা?
+
+```javascript
+console.log("I want pizza"[0]);
+```
+
+- A: `"""`
+- B: `"I"`
+- C: `SyntaxError`
+- D: `undefined`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: B
+
+In order to get a character at a specific index of a string, you can use bracket notation. The first character in the string has index 0, and so on. In this case, we want to get the element with index 0, the character `"I'`, which gets logged.
+
+Note that this method is not supported in IE7 and below. In that case, use `.charAt()`.
+
+</p>
+</details>
+
+---
+
+###### 88. এটার আউটপুট কোনটা?
+
+```javascript
+function sum(num1, num2 = num1) {
+  console.log(num1 + num2);
+}
+
+sum(10);
+```
+
+- A: `NaN`
+- B: `20`
+- C: `ReferenceError`
+- D: `undefined`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: B
+
+You can set a default parameter's value equal to another parameter of the function, as long as they've been defined _before_ the default parameter. We pass the value `10` to the `sum` function. If the `sum` function only receives 1 argument, it means that the value for `num2` is not passed, and the value of `num1` is equal to the passed value `10` in this case. The default value of `num2` is the value of `num1`, which is `10`. `num1 + num2` returns `20`.
+
+If you're trying to set a default parameter's value equal to a parameter that is defined _after_ (to the right), the parameter's value hasn't been initialized yet, which will throw an error.
+
+</p>
+</details>
+
+---
+
+###### 89. এটার আউটপুট কোনটা?
+
+```javascript
+// module.js
+export default () => "Hello world";
+export const name = "Lydia";
+
+// index.js
+import * as data from "./module";
+
+console.log(data);
+```
+
+- A: `{ default: function default(), name: "Lydia" }`
+- B: `{ default: function default() }`
+- C: `{ default: "Hello world", name: "Lydia" }`
+- D: Global object of `module.js`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: A
+
+With the `import * as name` syntax, we import _all exports_ from the `module.js` file into the `index.js` file as a new object called `data` is created. In the `module.js` file, there are two exports: the default export, and a named export. The default export is a function that returns the string `"Hello World"`, and the named export is a variable called `name` which has the value of the string `"Lydia"`.
+
+The `data` object has a `default` property for the default export, other properties have the names of the named exports and their corresponding values.
+
+</p>
+</details>
+
+---
+
+###### 90. এটার আউটপুট কোনটা?
+
+```javascript
+class Person {
+  constructor(name) {
+    this.name = name;
+  }
+}
+
+const member = new Person("John");
+console.log(typeof member);
+```
+
+- A: `"class"`
+- B: `"function"`
+- C: `"object"`
+- D: `"string"`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+Classes are syntactical sugar for function constructors. The equivalent of the `Person` class as a function constructor would be:
+
+```javascript
+function Person(name) {
+  this.name = name;
+}
+```
+
+Calling a function constructor with `new` results in the creation of an instance of `Person`, `typeof` keyword returns `"object"` for an instance. `typeof member` returns `"object"`.
+
+</p>
+</details>
+
+---
+
+###### 91. এটার আউটপুট কোনটা?
+
+```javascript
+let newList = [1, 2, 3].push(4);
+
+console.log(newList.push(5));
+```
+
+- A: `[1, 2, 3, 4, 5]`
+- B: `[1, 2, 3, 5]`
+- C: `[1, 2, 3, 4]`
+- D: `Error`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: D
+
+The `.push` method returns the _new length_ of the array, not the array itself! By setting `newList` equal to `[1, 2, 3].push(4)`, we set `newList` equal to the new length of the array: `4`.
+
+Then, we try to use the `.push` method on `newList`. Since `newList` is the numerical value `4`, we cannot use the `.push` method: a TypeError is thrown.
+
+</p>
+</details>
+
+---
+
+###### 92. এটার আউটপুট কোনটা?
+
+```javascript
+function giveLydiaPizza() {
+  return "Here is pizza!";
+}
+
+const giveLydiaChocolate = () =>
+  "Here's chocolate... now go hit the gym already.";
+
+console.log(giveLydiaPizza.prototype);
+console.log(giveLydiaChocolate.prototype);
+```
+
+- A: `{ constructor: ...}` `{ constructor: ...}`
+- B: `{}` `{ constructor: ...}`
+- C: `{ constructor: ...}` `{}`
+- D: `{ constructor: ...}` `undefined`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: D
+
+Regular functions, such as the `giveLydiaPizza` function, have a `prototype` property, which is an object (prototype object) with a `constructor` property. Arrow functions however, such as the `giveLydiaChocolate` function, do not have this `prototype` property. `undefined` gets returned when trying to access the `prototype` property using `giveLydiaChocolate.prototype`.
+
+</p>
+</details>
+
+---
+
+###### 93. এটার আউটপুট কোনটা?
+
+```javascript
+const person = {
+  name: "Lydia",
+  age: 21,
+};
+
+for (const [x, y] of Object.entries(person)) {
+  console.log(x, y);
+}
+```
+
+- A: `name` `Lydia` and `age` `21`
+- B: `["name", "Lydia"]` and `["age", 21]`
+- C: `["name", "age"]` and `undefined`
+- D: `Error`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: A
+
+`Object.entries(person)` returns an array of nested arrays, containing the keys and objects:
+
+`[ [ 'name', 'Lydia' ], [ 'age', 21 ] ]`
+
+Using the `for-of` loop, we can iterate over each element in the array, the subarrays in this case. We can destructure the subarrays instantly in the for-of loop, using `const [x, y]`. `x` is equal to the first element in the subarray, `y` is equal to the second element in the subarray.
+
+The first subarray is `[ "name", "Lydia" ]`, with `x` equal to `"name"`, and `y` equal to `"Lydia"`, which get logged.
+The second subarray is `[ "age", 21 ]`, with `x` equal to `"age"`, and `y` equal to `21`, which get logged.
+
+</p>
+</details>
+
+---
+
+###### 94. এটার আউটপুট কোনটা?
+
+```javascript
+function getItems(fruitList, ...args, favoriteFruit) {
+  return [...fruitList, ...args, favoriteFruit]
+}
+
+getItems(["banana", "apple"], "pear", "orange")
+```
+
+- A: `["banana", "apple", "pear", "orange"]`
+- B: `[["banana", "apple"], "pear", "orange"]`
+- C: `["banana", "apple", ["pear"], "orange"]`
+- D: `SyntaxError`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: D
+
+`...args` is a rest parameter. The rest parameter's value is an array containing all remaining arguments, **and can only be the last parameter**! In this example, the rest parameter was the second parameter. This is not possible, and will throw a syntax error.
+
+```javascript
+function getItems(fruitList, favoriteFruit, ...args) {
+  return [...fruitList, ...args, favoriteFruit];
+}
+
+getItems(["banana", "apple"], "pear", "orange");
+```
+
+The above example works. This returns the array `[ 'banana', 'apple', 'orange', 'pear' ]`
+
+</p>
+</details>
+
+---
+
+###### 95. এটার আউটপুট কোনটা?
+
+```javascript
+function nums(a, b) {
+  if (a > b) console.log("a is bigger");
+  else console.log("b is bigger");
+  return;
+  a + b;
+}
+
+console.log(nums(4, 2));
+console.log(nums(1, 2));
+```
+
+- A: `a is bigger`, `6` and `b is bigger`, `3`
+- B: `a is bigger`, `undefined` and `b is bigger`, `undefined`
+- C: `undefined` and `undefined`
+- D: `SyntaxError`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: B
+
+In JavaScript, we don't _have_ to write the semicolon (`;`) explicitly, however the JavaScript engine still adds them after statements. This is called **Automatic Semicolon Insertion**. A statement can for example be variables, or keywords like `throw`, `return`, `break`, etc.
+
+Here, we wrote a `return` statement, and another value `a + b` on a _new line_. However, since it's a new line, the engine doesn't know that it's actually the value that we wanted to return. Instead, it automatically added a semicolon after `return`. You could see this as:
+
+```javascript
+return;
+a + b;
+```
+
+This means that `a + b` is never reached, since a function stops running after the `return` keyword. If no value gets returned, like here, the function returns `undefined`. Note that there is no automatic insertion after `if/else` statements!
+
+</p>
+</details>
+
+---
+
+###### 96. এটার আউটপুট কোনটা?
+
+```javascript
+class Person {
+  constructor() {
+    this.name = "Lydia";
+  }
+}
+
+Person = class AnotherPerson {
+  constructor() {
+    this.name = "Sarah";
+  }
+};
+
+const member = new Person();
+console.log(member.name);
+```
+
+- A: `"Lydia"`
+- B: `"Sarah"`
+- C: `Error: cannot redeclare Person`
+- D: `SyntaxError`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: B
+
+We can set classes equal to other classes/function constructors. In this case, we set `Person` equal to `AnotherPerson`. The name on this constructor is `Sarah`, so the name property on the new `Person` instance `member` is `"Sarah"`.
+
+</p>
+</details>
+
+---
+
+###### 97. এটার আউটপুট কোনটা?
+
+```javascript
+const info = {
+  [Symbol("a")]: "b",
+};
+
+console.log(info);
+console.log(Object.keys(info));
+```
+
+- A: `{Symbol('a'): 'b'}` and `["{Symbol('a')"]`
+- B: `{}` and `[]`
+- C: `{ a: "b" }` and `["a"]`
+- D: `{Symbol('a'): 'b'}` and `[]`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: D
+
+A Symbol is not _enumerable_. The Object.keys method returns all _enumerable_ key properties on an object. The Symbol won't be visible, and an empty array is returned. When logging the entire object, all properties will be visible, even non-enumerable ones.
+
+This is one of the many qualities of a symbol: besides representing an entirely unique value (which prevents accidental name collision on objects, for example when working with 2 libraries that want to add properties to the same object), you can also "hide" properties on objects this way (although not entirely. You can still access symbols using the `Object.getOwnPropertySymbols()` method).
+
+</p>
+</details>
+
+---
+
+###### 98. এটার আউটপুট কোনটা?
+
+```javascript
+const getList = ([x, ...y]) => [x, y]
+const getUser = user => { name: user.name, age: user.age }
+
+const list = [1, 2, 3, 4]
+const user = { name: "Lydia", age: 21 }
+
+console.log(getList(list))
+console.log(getUser(user))
+```
+
+- A: `[1, [2, 3, 4]]` and `SyntaxError`
+- B: `[1, [2, 3, 4]]` and `{ name: "Lydia", age: 21 }`
+- C: `[1, 2, 3, 4]` and `{ name: "Lydia", age: 21 }`
+- D: `Error` and `{ name: "Lydia", age: 21 }`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: A
+
+The `getList` function receives an array as its argument. Between the parentheses of the `getList` function, we destructure this array right away. You could see this as:
+
+`[x, ...y] = [1, 2, 3, 4]`
+
+With the rest parameter `...y`, we put all "remaining" arguments in an array. The remaining arguments are `2`, `3` and `4` in this case. The value of `y` is an array, containing all the rest parameters. The value of `x` is equal to `1` in this case, so when we log `[x, y]`, `[1, [2, 3, 4]]` gets logged.
+
+The `getUser` function receives an object. With arrow functions, we don't _have_ to write curly brackets if we just return one value. However, if you want to instantly return an _object_ from an arrow function, you have to write it between parentheses, otherwise everything between the two braces will be interpreted as a block statement. In this case the code between the braces is not a valid JavaScript code, so a `SyntaxError` gets thrown.
+
+The following function would have returned an object:
+
+`const getUser = user => ({ name: user.name, age: user.age })`
+
+</p>
+</details>
+
+---
+
+###### 99. এটার আউটপুট কোনটা?
+
+```javascript
+const name = "Lydia";
+
+console.log(name());
+```
+
+- A: `SyntaxError`
+- B: `ReferenceError`
+- C: `TypeError`
+- D: `undefined`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+The variable `name` holds the value of a string, which is not a function, and thus cannot be invoked.
+
+TypeErrors get thrown when a value is not of the expected type. JavaScript expected `name` to be a function since we're trying to invoke it. It was a string however, so a TypeError gets thrown: name is not a function!
+
+SyntaxErrors get thrown when you've written something that isn't valid JavaScript, for example when you've written the word `return` as `retrun`.
+ReferenceErrors get thrown when JavaScript isn't able to find a reference to a value that you're trying to access.
+
+</p>
+</details>
+
+---
+
+###### 100. What's the value of output?
+
+```javascript
+// 🎉✨ This is my 100th question! ✨🎉
+
+const output = `${[] && "Im"}possible!
+You should${"" && `n't`} see a therapist after so much JavaScript lol`;
+```
+
+- A: `possible! You should see a therapist after so much JavaScript lol`
+- B: `Impossible! You should see a therapist after so much JavaScript lol`
+- C: `possible! You shouldn't see a therapist after so much JavaScript lol`
+- D: `Impossible! You shouldn't see a therapist after so much JavaScript lol`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: B
+
+`[]` is a truthy value. With the `&&` operator, the right-hand value will be returned if the left-hand value is a truthy value. In this case, the left-hand value `[]` is a truthy value, so `"Im'` gets returned.
+
+`""` is a falsy value. If the left-hand value is falsy, nothing gets returned. `n't` doesn't get returned.
+
+</p>
+</details>
+
+---
+
+###### 101. What's the value of output?
+
+```javascript
+const one = false || {} || null;
+const two = null || false || "";
+const three = [] || 0 || true;
+
+console.log(one, two, three);
+```
+
+- A: `false` `null` `[]`
+- B: `null` `""` `true`
+- C: `{}` `""` `[]`
+- D: `null` `null` `true`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+With the `||` operator, we can return the first truthy operand. If all values are falsy, the last operand gets returned.
+
+`(false || {} || null)`: the empty object `{}` is a truthy value. This is the first (and only) truthy value, which gets returned. `one` is equal to `{}`.
+
+`(null || false || "")`: all operands are falsy values. This means that the last operand, `""` gets returned. `two` is equal to `""`.
+
+`([] || 0 || "")`: the empty array`[]` is a truthy value. This is the first truthy value, which gets returned. `three` is equal to `[]`.
+
+</p>
+</details>
+
+---
+
+###### 102. What's the value of output?
+
+```javascript
+const myPromise = () => Promise.resolve("I have resolved!");
+
+function firstFunction() {
+  myPromise().then((res) => console.log(res));
+  console.log("second");
+}
+
+async function secondFunction() {
+  console.log(await myPromise());
+  console.log("second");
+}
+
+firstFunction();
+secondFunction();
+```
+
+- A: `I have resolved!`, `second` and `I have resolved!`, `second`
+- B: `second`, `I have resolved!` and `second`, `I have resolved!`
+- C: `I have resolved!`, `second` and `second`, `I have resolved!`
+- D: `second`, `I have resolved!` and `I have resolved!`, `second`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: D
+
+With a promise, we basically say _I want to execute this function, but I'll put it aside for now while it's running since this might take a while. Only when a certain value is resolved (or rejected), and when the call stack is empty, I want to use this value._
+
+We can get this value with both `.then` and the `await` keywords in an `async` function. Although we can get a promise's value with both `.then` and `await`, they work a bit differently.
+
+In the `firstFunction`, we (sort of) put the myPromise function aside while it was running, but continued running the other code, which is `console.log('second')` in this case. Then, the function resolved with the string `I have resolved`, which then got logged after it saw that the callstack was empty.
+
+With the await keyword in `secondFunction`, we literally pause the execution of an async function until the value has been resolved before moving to the next line.
+
+This means that it waited for the `myPromise` to resolve with the value `I have resolved`, and only once that happened, we moved to the next line: `second` got logged.
+
+</p>
+</details>
+
+---
+
+###### 103. What's the value of output?
+
+```javascript
+const set = new Set();
+
+set.add(1);
+set.add("Lydia");
+set.add({ name: "Lydia" });
+
+for (let item of set) {
+  console.log(item + 2);
+}
+```
+
+- A: `3`, `NaN`, `NaN`
+- B: `3`, `7`, `NaN`
+- C: `3`, `Lydia2`, `[object Object]2`
+- D: `"12"`, `Lydia2`, `[object Object]2`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+The `+` operator is not only used for adding numerical values, but we can also use it to concatenate strings. Whenever the JavaScript engine sees that one or more values are not a number, it coerces the number into a string.
+
+The first one is `1`, which is a numerical value. `1 + 2` returns the number 3.
+
+However, the second one is a string `"Lydia"`. `"Lydia"` is a string and `2` is a number: `2` gets coerced into a string. `"Lydia"` and `"2"` get concatenated, which results in the string `"Lydia2"`.
+
+`{ name: "Lydia" }` is an object. Neither a number nor an object is a string, so it stringifies both. Whenever we stringify a regular object, it becomes `"[object Object]"`. `"[object Object]"` concatenated with `"2"` becomes `"[object Object]2"`.
+
+</p>
+</details>
+
+---
+
+###### 104. What's its value?
+
+```javascript
+Promise.resolve(5);
+```
+
+- A: `5`
+- B: `Promise {<pending>: 5}`
+- C: `Promise {<fulfilled>: 5}`
+- D: `Error`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+We can pass any type of value we want to `Promise.resolve`, either a promise or a non-promise. The method itself returns a promise with the resolved value (`<fulfilled>`). If you pass a regular function, it'll be a resolved promise with a regular value. If you pass a promise, it'll be a resolved promise with the resolved value of that passed promise.
+
+In this case, we just passed the numerical value `5`. It returns a resolved promise with the value `5`.
+
+</p>
+</details>
+
+---
+
+###### 105. What's its value?
+
+```javascript
+function compareMembers(person1, person2 = person) {
+  if (person1 !== person2) {
+    console.log("Not the same!");
+  } else {
+    console.log("They are the same!");
+  }
+}
+
+const person = { name: "Lydia" };
+
+compareMembers(person);
+```
+
+- A: `Not the same!`
+- B: `They are the same!`
+- C: `ReferenceError`
+- D: `SyntaxError`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: B
+
+Objects are passed by reference. When we check objects for strict equality (`===`), we're comparing their references.
+
+We set the default value for `person2` equal to the `person` object, and passed the `person` object as the value for `person1`.
+
+This means that both values have a reference to the same spot in memory, thus they are equal.
+
+The code block in the `else` statement gets run, and `They are the same!` gets logged.
+
+</p>
+</details>
+
+---
+
+###### 106. What's its value?
+
+```javascript
+const colorConfig = {
+  red: true,
+  blue: false,
+  green: true,
+  black: true,
+  yellow: false,
+};
+
+const colors = ["pink", "red", "blue"];
+
+console.log(colorConfig.colors[1]);
+```
+
+- A: `true`
+- B: `false`
+- C: `undefined`
+- D: `TypeError`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: D
+
+In JavaScript, we have two ways to access properties on an object: bracket notation, or dot notation. In this example, we use dot notation (`colorConfig.colors`) instead of bracket notation (`colorConfig["colors"]`).
+
+With dot notation, JavaScript tries to find the property on the object with that exact name. In this example, JavaScript tries to find a property called `colors` on the `colorConfig` object. There is no property called `colors`, so this returns `undefined`. Then, we try to access the value of the first element by using `[1]`. We cannot do this on a value that's `undefined`, so it throws a `TypeError`: `Cannot read property '1' of undefined`.
+
+JavaScript interprets (or unboxes) statements. When we use bracket notation, it sees the first opening bracket `[` and keeps going until it finds the closing bracket `]`. Only then, it will evaluate the statement. If we would've used `colorConfig[colors[1]]`, it would have returned the value of the `red` property on the `colorConfig` object.
+
+</p>
+</details>
+
+---
+
+###### 107. What's its value?
+
+```javascript
+console.log("❤️" === "❤️");
+```
+
+- A: `true`
+- B: `false`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: A
+
+Under the hood, emojis are unicodes. The unicodes for the heart emoji is `"U+2764 U+FE0F"`. These are always the same for the same emojis, so we're comparing two equal strings to each other, which returns true.
+
+</p>
+</details>
+
+---
+
+###### 108. Which of these methods modifies the original array?
+
+```javascript
+const emojis = ["✨", "🥑", "😍"];
+
+emojis.map((x) => x + "✨");
+emojis.filter((x) => x !== "🥑");
+emojis.find((x) => x !== "🥑");
+emojis.reduce((acc, cur) => acc + "✨");
+emojis.slice(1, 2, "✨");
+emojis.splice(1, 2, "✨");
+```
+
+- A: `All of them`
+- B: `map` `reduce` `slice` `splice`
+- C: `map` `slice` `splice`
+- D: `splice`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: D
+
+With `splice` method, we modify the original array by deleting, replacing or adding elements. In this case, we removed 2 items from index 1 (we removed `'🥑'` and `'😍'`) and added the ✨ emoji instead.
+
+`map`, `filter` and `slice` return a new array, `find` returns an element, and `reduce` returns a reduced value.
+
+</p>
+</details>
+
+---
+
+###### 109. এটার আউটপুট কোনটা?
+
+```javascript
+const food = ["🍕", "🍫", "🥑", "🍔"];
+const info = { favoriteFood: food[0] };
+
+info.favoriteFood = "🍝";
+
+console.log(food);
+```
+
+- A: `['🍕', '🍫', '🥑', '🍔']`
+- B: `['🍝', '🍫', '🥑', '🍔']`
+- C: `['🍝', '🍕', '🍫', '🥑', '🍔']`
+- D: `ReferenceError`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: A
+
+We set the value of the `favoriteFood` property on the `info` object equal to the string with the pizza emoji, `'🍕'`. A string is a primitive data type. In JavaScript, primitive data types don't interact by reference.
+
+In JavaScript, primitive data types (everything that's not an object) interact by _value_. In this case, we set the value of the `favoriteFood` property on the `info` object equal to the value of the first element in the `food` array, the string with the pizza emoji in this case (`'🍕'`). A string is a primitive data type, and interact by value (see my [blogpost](https://www.theavocoder.com/complete-javascript/2018/12/21/by-value-vs-by-reference) if you're interested in learning more)
+
+Then, we change the value of the `favoriteFood` property on the `info` object. The `food` array hasn't changed, since the value of `favoriteFood` was merely a _copy_ of the value of the first element in the array, and doesn't have a reference to the same spot in memory as the element on `food[0]`. When we log food, it's still the original array, `['🍕', '🍫', '🥑', '🍔']`.
+
+</p>
+</details>
+
+---
+
+###### 110. What does this method do?
+
+```javascript
+JSON.parse();
+```
+
+- A: Parses JSON to a JavaScript value
+- B: Parses a JavaScript object to JSON
+- C: Parses any JavaScript value to JSON
+- D: Parses JSON to a JavaScript object only
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: A
+
+With the `JSON.parse()` method, we can parse JSON string to a JavaScript value.
+
+```javascript
+// Stringifying a number into valid JSON, then parsing the JSON string to a JavaScript value:
+const jsonNumber = JSON.stringify(4); // '4'
+JSON.parse(jsonNumber); // 4
+
+// Stringifying an array value into valid JSON, then parsing the JSON string to a JavaScript value:
+const jsonArray = JSON.stringify([1, 2, 3]); // '[1, 2, 3]'
+JSON.parse(jsonArray); // [1, 2, 3]
+
+// Stringifying an object  into valid JSON, then parsing the JSON string to a JavaScript value:
+const jsonArray = JSON.stringify({ name: "Lydia" }); // '{"name":"Lydia"}'
+JSON.parse(jsonArray); // { name: 'Lydia' }
+```
+
+</p>
+</details>
+
+---
+
+###### 111. এটার আউটপুট কোনটা?
+
+```javascript
+let name = "Lydia";
+
+function getName() {
+  console.log(name);
+  let name = "Sarah";
+}
+
+getName();
+```
+
+- A: Lydia
+- B: Sarah
+- C: `undefined`
+- D: `ReferenceError`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: D
+
+Each function has its own _execution context_ (or _scope_). The `getName` function first looks within its own context (scope) to see if it contains the variable `name` we're trying to access. In this case, the `getName` function contains its own `name` variable: we declare the variable `name` with the `let` keyword, and with the value of `'Sarah'`.
+
+Variables with the `let` keyword (and `const`) are hoisted, but unlike `var`, don't get <i>initialized</i>. They are not accessible before the line we declare (initialize) them. This is called the "temporal dead zone". When we try to access the variables before they are declared, JavaScript throws a `ReferenceError`.
+
+If we wouldn't have declared the `name` variable within the `getName` function, the javascript engine would've looked down the _scope chain_. The outer scope has a variable called `name` with the value of `Lydia`. In that case, it would've logged `Lydia`.
+
+```javascript
+let name = "Lydia";
+
+function getName() {
+  console.log(name);
+}
+
+getName(); // Lydia
+```
+
+</p>
+</details>
+
+---
+
+###### 112. এটার আউটপুট কোনটা?
+
+```javascript
+function* generatorOne() {
+  yield ["a", "b", "c"];
+}
+
+function* generatorTwo() {
+  yield* ["a", "b", "c"];
+}
+
+const one = generatorOne();
+const two = generatorTwo();
+
+console.log(one.next().value);
+console.log(two.next().value);
+```
+
+- A: `a` and `a`
+- B: `a` and `undefined`
+- C: `['a', 'b', 'c']` and `a`
+- D: `a` and `['a', 'b', 'c']`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+With the `yield` keyword, we `yield` values in a generator function. With the `yield*` keyword, we can yield values from another generator function, or iterable object (for example an array).
+
+In `generatorOne`, we yield the entire array `['a', 'b', 'c']` using the `yield` keyword. The value of `value` property on the object returned by the `next` method on `one` (`one.next().value`) is equal to the entire array `['a', 'b', 'c']`.
+
+```javascript
+console.log(one.next().value); // ['a', 'b', 'c']
+console.log(one.next().value); // undefined
+```
+
+In `generatorTwo`, we use the `yield*` keyword. This means that the first yielded value of `two`, is equal to the first yielded value in the iterator. The iterator is the array `['a', 'b', 'c']`. The first yielded value is `a`, so the first time we call `two.next().value`, `a` is returned.
+
+```javascript
+console.log(two.next().value); // 'a'
+console.log(two.next().value); // 'b'
+console.log(two.next().value); // 'c'
+console.log(two.next().value); // undefined
+```
+
+</p>
+</details>
+
+---
+
+###### 113. এটার আউটপুট কোনটা?
+
+```javascript
+console.log(`${((x) => x)("I love")} to program`);
+```
+
+- A: `I love to program`
+- B: `undefined to program`
+- C: `${(x => x)('I love') to program`
+- D: `TypeError`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: A
+
+Expressions within template literals are evaluated first. This means that the string will contain the returned value of the expression, the immediately invoked function `(x => x)('I love')` in this case. We pass the value `'I love'` as an argument to the `x => x` arrow function. `x` is equal to `'I love'`, which gets returned. This results in `I love to program`.
+
+</p>
+</details>
+
+---
+
+###### 114. What will happen?
+
+```javascript
+let config = {
+  alert: setInterval(() => {
+    console.log("Alert!");
+  }, 1000),
+};
+
+config = null;
+```
+
+- A: The `setInterval` callback won't be invoked
+- B: The `setInterval` callback gets invoked once
+- C: The `setInterval` callback will still be called every second
+- D: We never invoked `config.alert()`, config is `null`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+Normally when we set objects equal to `null`, those objects get _garbage collected_ as there is no reference anymore to that object. However, since the callback function within `setInterval` is an arrow function (thus bound to the `config` object), the callback function still holds a reference to the `config` object.
+As long as there is a reference, the object won't get garbage collected.
+Since this is an interval, setting `config` to `null` or `delete`-ing `config.alert` won't garbage-collect the interval, so the interval will still be called.
+It should be cleared with `clearInterval(config.alert)` to remove it from memory.
+Since it was not cleared, the `setInterval` callback function will still get invoked every 1000ms (1s).
+
+</p>
+</details>
+
+---
+
+###### 115. Which method(s) will return the value `'Hello world!'`?
+
+```javascript
+const myMap = new Map();
+const myFunc = () => "greeting";
+
+myMap.set(myFunc, "Hello world!");
+
+//1
+myMap.get("greeting");
+//2
+myMap.get(myFunc);
+//3
+myMap.get(() => "greeting");
+```
+
+- A: 1
+- B: 2
+- C: 2 and 3
+- D: All of them
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: B
+
+When adding a key/value pair using the `set` method, the key will be the value of the first argument passed to the `set` function, and the value will be the second argument passed to the `set` function. The key is the _function_ `() => 'greeting'` in this case, and the value `'Hello world'`. `myMap` is now `{ () => 'greeting' => 'Hello world!' }`.
+
+1 is wrong, since the key is not `'greeting'` but `() => 'greeting'`.
+3 is wrong, since we're creating a new function by passing it as a parameter to the `get` method. Object interacts by _reference_. Functions are objects, which is why two functions are never strictly equal, even if they are identical: they have a reference to a different spot in memory.
+
+</p>
+</details>
+
+---
+
+###### 116. এটার আউটপুট কোনটা?
+
+```javascript
+const person = {
+  name: "Lydia",
+  age: 21,
+};
+
+const changeAge = (x = { ...person }) => (x.age += 1);
+const changeAgeAndName = (x = { ...person }) => {
+  x.age += 1;
+  x.name = "Sarah";
+};
+
+changeAge(person);
+changeAgeAndName();
+
+console.log(person);
+```
+
+- A: `{name: "Sarah", age: 22}`
+- B: `{name: "Sarah", age: 23}`
+- C: `{name: "Lydia", age: 22}`
+- D: `{name: "Lydia", age: 23}`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+Both the `changeAge` and `changeAgeAndName` functions have a default parameter, namely a _newly_ created object `{ ...person }`. This object has copies of all the key/values in the `person` object.
+
+First, we invoke the `changeAge` function and pass the `person` object as its argument. This function increases the value of the `age` property by 1. `person` is now `{ name: "Lydia", age: 22 }`.
+
+Then, we invoke the `changeAgeAndName` function, however we don't pass a parameter. Instead, the value of `x` is equal to a _new_ object: `{ ...person }`. Since it's a new object, it doesn't affect the values of the properties on the `person` object. `person` is still equal to `{ name: "Lydia", age: 22 }`.
+
+</p>
+</details>
+
+---
+
+###### 117. Which of the following options will return `6`?
+
+```javascript
+function sumValues(x, y, z) {
+  return x + y + z;
+}
+```
+
+- A: `sumValues([...1, 2, 3])`
+- B: `sumValues([...[1, 2, 3]])`
+- C: `sumValues(...[1, 2, 3])`
+- D: `sumValues([1, 2, 3])`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+With the spread operator `...`, we can _spread_ iterables to individual elements. The `sumValues` function receives three arguments: `x`, `y` and `z`. `...[1, 2, 3]` will result in `1, 2, 3`, which we pass to the `sumValues` function.
+
+</p>
+</details>
+
+---
+
+###### 118. এটার আউটপুট কোনটা?
+
+```javascript
+let num = 1;
+const list = ["🥳", "🤠", "🥰", "🤪"];
+
+console.log(list[(num += 1)]);
+```
+
+- A: `🤠`
+- B: `🥰`
+- C: `SyntaxError`
+- D: `ReferenceError`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: B
+
+With the `+=` operator, we're incrementing the value of `num` by `1`. `num` had the initial value `1`, so `1 + 1` is `2`. The item on the second index in the `list` array is 🥰, `console.log(list[2])` prints 🥰.
+
+</p>
+</details>
+
+---
+
+###### 119. এটার আউটপুট কোনটা?
+
+```javascript
+const person = {
+  firstName: "Lydia",
+  lastName: "Hallie",
+  pet: {
+    name: "Mara",
+    breed: "Dutch Tulip Hound",
+  },
+  getFullName() {
+    return `${this.firstName} ${this.lastName}`;
+  },
+};
+
+console.log(person.pet?.name);
+console.log(person.pet?.family?.name);
+console.log(person.getFullName?.());
+console.log(member.getLastName?.());
+```
+
+- A: `undefined` `undefined` `undefined` `undefined`
+- B: `Mara` `undefined` `Lydia Hallie` `ReferenceError`
+- C: `Mara` `null` `Lydia Hallie` `null`
+- D: `null` `ReferenceError` `null` `ReferenceError`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: B
+
+With the optional chaining operator `?.`, we no longer have to explicitly check whether the deeper nested values are valid or not. If we're trying to access a property on an `undefined` or `null` value (_nullish_), the expression short-circuits and returns `undefined`.
+
+`person.pet?.name`: `person` has a property named `pet`: `person.pet` is not nullish. It has a property called `name`, and returns `Mara`.
+`person.pet?.family?.name`: `person` has a property named `pet`: `person.pet` is not nullish. `pet` does _not_ have a property called `family`, `person.pet.family` is nullish. The expression returns `undefined`.
+`person.getFullName?.()`: `person` has a property named `getFullName`: `person.getFullName()` is not nullish and can get invoked, which returns `Lydia Hallie`.
+`member.getLastName?.()`: variable `member` is non-existent therefore a `ReferenceError` gets thrown!
+
+</p>
+</details>
+
+---
+
+###### 120. এটার আউটপুট কোনটা?
+
+```javascript
+const groceries = ["banana", "apple", "peanuts"];
+
+if (groceries.indexOf("banana")) {
+  console.log("We have to buy bananas!");
+} else {
+  console.log(`We don't have to buy bananas!`);
+}
+```
+
+- A: We have to buy bananas!
+- B: We don't have to buy bananas
+- C: `undefined`
+- D: `1`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: B
+
+We passed the condition `groceries.indexOf("banana")` to the if-statement. `groceries.indexOf("banana")` returns `0`, which is a falsy value. Since the condition in the if-statement is falsy, the code in the `else` block runs, and `We don't have to buy bananas!` gets logged.
+
+</p>
+</details>
+
+---
+
+###### 121. এটার আউটপুট কোনটা?
+
+```javascript
+const config = {
+  languages: [],
+  set language(lang) {
+    return this.languages.push(lang);
+  },
+};
+
+console.log(config.language);
+```
+
+- A: `function language(lang) { this.languages.push(lang }`
+- B: `0`
+- C: `[]`
+- D: `undefined`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: D
+
+The `language` method is a `setter`. Setters don't hold an actual value, their purpose is to _modify_ properties. When calling a `setter` method, `undefined` gets returned.
+
+</p>
+</details>
+
+---
+
+###### 122. এটার আউটপুট কোনটা?
+
+```javascript
+const name = "Lydia Hallie";
+
+console.log(!typeof name === "object");
+console.log(!typeof name === "string");
+```
+
+- A: `false` `true`
+- B: `true` `false`
+- C: `false` `false`
+- D: `true` `true`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+`typeof name` returns `"string"`. The string `"string"` is a truthy value, so `!typeof name` returns the boolean value `false`. `false === "object"` and `false === "string"` both return`false`.
+
+(If we wanted to check whether the type was (un)equal to a certain type, we should've written `!==` instead of `!typeof`)
+
+</p>
+</details>
+
+---
+
+###### 123. এটার আউটপুট কোনটা?
+
+```javascript
+const add = (x) => (y) => (z) => {
+  console.log(x, y, z);
+  return x + y + z;
+};
+
+add(4)(5)(6);
+```
+
+- A: `4` `5` `6`
+- B: `6` `5` `4`
+- C: `4` `function` `function`
+- D: `undefined` `undefined` `6`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: A
+
+The `add` function returns an arrow function, which returns an arrow function, which returns an arrow function (still with me?). The first function receives an argument `x` with the value of `4`. We invoke the second function, which receives an argument `y` with the value `5`. Then we invoke the third function, which receives an argument `z` with the value `6`. When we're trying to access the value `x`, `y` and `z` within the last arrow function, the JS engine goes up the scope chain in order to find the values for `x` and `y` accordingly. This returns `4` `5` `6`.
+
+</p>
+</details>
+
+---
+
+###### 124. এটার আউটপুট কোনটা?
+
+```javascript
+async function* range(start, end) {
+  for (let i = start; i <= end; i++) {
+    yield Promise.resolve(i);
+  }
+}
+
+(async () => {
+  const gen = range(1, 3);
+  for await (const item of gen) {
+    console.log(item);
+  }
+})();
+```
+
+- A: `Promise {1}` `Promise {2}` `Promise {3}`
+- B: `Promise {<pending>}` `Promise {<pending>}` `Promise {<pending>}`
+- C: `1` `2` `3`
+- D: `undefined` `undefined` `undefined`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+The generator function `range` returns an async object with promises for each item in the range we pass: `Promise{1}`, `Promise{2}`, `Promise{3}`. We set the variable `gen` equal to the async object, after which we loop over it using a `for await ... of` loop. We set the variable `item` equal to the returned Promise values: first `Promise{1}`, then `Promise{2}`, then `Promise{3}`. Since we're _awaiting_ the value of `item`, the resolved promise, the resolved _values_ of the promises get returned: `1`, `2`, then `3`.
+
+</p>
+</details>
+
+---
+
+###### 125. এটার আউটপুট কোনটা?
+
+```javascript
+const myFunc = ({ x, y, z }) => {
+  console.log(x, y, z);
+};
+
+myFunc(1, 2, 3);
+```
+
+- A: `1` `2` `3`
+- B: `{1: 1}` `{2: 2}` `{3: 3}`
+- C: `{ 1: undefined }` `undefined` `undefined`
+- D: `undefined` `undefined` `undefined`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: D
+
+`myFunc` expects an object with properties `x`, `y` and `z` as its argument. Since we're only passing three separate numeric values (1, 2, 3) instead of one object with properties `x`, `y` and `z` ({x: 1, y: 2, z: 3}), `x`, `y` and `z` have their default value of `undefined`.
+
+</p>
+</details>
+
+---
+
+###### 126. এটার আউটপুট কোনটা?
+
+```javascript
+function getFine(speed, amount) {
+  const formattedSpeed = new Intl.NumberFormat("en-US", {
+    style: "unit",
+    unit: "mile-per-hour",
+  }).format(speed);
+
+  const formattedAmount = new Intl.NumberFormat("en-US", {
+    style: "currency",
+    currency: "USD",
+  }).format(amount);
+
+  return `The driver drove ${formattedSpeed} and has to pay ${formattedAmount}`;
+}
+
+console.log(getFine(130, 300));
+```
+
+- A: The driver drove 130 and has to pay 300
+- B: The driver drove 130 mph and has to pay \$300.00
+- C: The driver drove undefined and has to pay undefined
+- D: The driver drove 130.00 and has to pay 300.00
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: B
+
+With the `Intl.NumberFormat` method, we can format numeric values to any locale. We format the numeric value `130` to the `en-US` locale as a `unit` in `mile-per-hour`, which results in `130 mph`. The numeric value `300` to the `en-US` locale as a `currency` in `USD` results in `$300.00`.
+
+</p>
+</details>
+
+---
+
+###### 127. এটার আউটপুট কোনটা?
+
+```javascript
+const spookyItems = ["👻", "🎃", "🕸"];
+({ item: spookyItems[3] } = { item: "💀" });
+
+console.log(spookyItems);
+```
+
+- A: `["👻", "🎃", "🕸"]`
+- B: `["👻", "🎃", "🕸", "💀"]`
+- C: `["👻", "🎃", "🕸", { item: "💀" }]`
+- D: `["👻", "🎃", "🕸", "[object Object]"]`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: B
+
+By destructuring objects, we can unpack values from the right-hand object, and assign the unpacked value to the value of the same property name on the left-hand object. In this case, we're assigning the value "💀" to `spookyItems[3]`. This means that we're modifying the `spookyItems` array, we're adding the "💀" to it. When logging `spookyItems`, `["👻", "🎃", "🕸", "💀"]` gets logged.
+
+</p>
+</details>
+
+---
+
+###### 128. এটার আউটপুট কোনটা?
+
+```javascript
+const name = "Lydia Hallie";
+const age = 21;
+
+console.log(Number.isNaN(name));
+console.log(Number.isNaN(age));
+
+console.log(isNaN(name));
+console.log(isNaN(age));
+```
+
+- A: `true` `false` `true` `false`
+- B: `true` `false` `false` `false`
+- C: `false` `false` `true` `false`
+- D: `false` `true` `false` `true`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+With the `Number.isNaN` method, you can check if the value you pass is a _numeric value_ and equal to `NaN`. `name` is not a numeric value, so `Number.isNaN(name)` returns `false`. `age` is a numeric value, but is not equal to `NaN`, so `Number.isNaN(age)` returns `false`.
+
+With the `isNaN` method, you can check if the value you pass is not a number. `name` is not a number, so `isNaN(name)` returns true. `age` is a number, so `isNaN(age)` returns `false`.
+
+</p>
+</details>
+
+---
+
+###### 129. এটার আউটপুট কোনটা?
+
+```javascript
+const randomValue = 21;
+
+function getInfo() {
+  console.log(typeof randomValue);
+  const randomValue = "Lydia Hallie";
+}
+
+getInfo();
+```
+
+- A: `"number"`
+- B: `"string"`
+- C: `undefined`
+- D: `ReferenceError`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: D
+
+Variables declared with the `const` keyword are not referenceable before their initialization: this is called the _temporal dead zone_. In the `getInfo` function, the variable `randomValue` is scoped in the functional scope of `getInfo`. On the line where we want to log the value of `typeof randomValue`, the variable `randomValue` isn't initialized yet: a `ReferenceError` gets thrown! The engine didn't go down the scope chain since we declared the variable `randomValue` in the `getInfo` function.
+
+</p>
+</details>
+
+---
+
+###### 130. এটার আউটপুট কোনটা?
+
+```javascript
+const myPromise = Promise.resolve("Woah some cool data");
+
+(async () => {
+  try {
+    console.log(await myPromise);
+  } catch {
+    throw new Error(`Oops didn't work`);
+  } finally {
+    console.log("Oh finally!");
+  }
+})();
+```
+
+- A: `Woah some cool data`
+- B: `Oh finally!`
+- C: `Woah some cool data` `Oh finally!`
+- D: `Oops didn't work` `Oh finally!`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+In the `try` block, we're logging the awaited value of the `myPromise` variable: `"Woah some cool data"`. Since no errors were thrown in the `try` block, the code in the `catch` block doesn't run. The code in the `finally` block _always_ runs, `"Oh finally!"` gets logged.
+
+</p>
+</details>
+
+---
+
+###### 131. এটার আউটপুট কোনটা?
+
+```javascript
+const emojis = ["🥑", ["✨", "✨", ["🍕", "🍕"]]];
+
+console.log(emojis.flat(1));
+```
+
+- A: `['🥑', ['✨', '✨', ['🍕', '🍕']]]`
+- B: `['🥑', '✨', '✨', ['🍕', '🍕']]`
+- C: `['🥑', ['✨', '✨', '🍕', '🍕']]`
+- D: `['🥑', '✨', '✨', '🍕', '🍕']`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: B
+
+With the `flat` method, we can create a new, flattened array. The depth of the flattened array depends on the value that we pass. In this case, we passed the value `1` (which we didn't have to, that's the default value), meaning that only the arrays on the first depth will be concatenated. `['🥑']` and `['✨', '✨', ['🍕', '🍕']]` in this case. Concatenating these two arrays results in `['🥑', '✨', '✨', ['🍕', '🍕']]`.
+
+</p>
+</details>
+
+---
+
+###### 132. এটার আউটপুট কোনটা?
+
+```javascript
+class Counter {
+  constructor() {
+    this.count = 0;
+  }
+
+  increment() {
+    this.count++;
+  }
+}
+
+const counterOne = new Counter();
+counterOne.increment();
+counterOne.increment();
+
+const counterTwo = counterOne;
+counterTwo.increment();
+
+console.log(counterOne.count);
+```
+
+- A: `0`
+- B: `1`
+- C: `2`
+- D: `3`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: D
+
+`counterOne` is an instance of the `Counter` class. The counter class contains a `count` property on its constructor, and an `increment` method. First, we invoked the `increment` method twice by calling `counterOne.increment()`. Currently, `counterOne.count` is `2`.
+
+<img src="https://i.imgur.com/KxLlTm9.png" width="400">
+
+Then, we create a new variable `counterTwo`, and set it equal to `counterOne`. Since objects interact by reference, we're just creating a new reference to the same spot in memory that `counterOne` points to. Since it has the same spot in memory, any changes made to the object that `counterTwo` has a reference to, also apply to `counterOne`. Currently, `counterTwo.count` is `2`.
+
+We invoke `counterTwo.increment()`, which sets `count` to `3`. Then, we log the count on `counterOne`, which logs `3`.
+
+<img src="https://i.imgur.com/BNBHXmc.png" width="400">
+
+</p>
+</details>
+
+---
+
+###### 133. এটার আউটপুট কোনটা?
+
+```javascript
+const myPromise = Promise.resolve(Promise.resolve("Promise"));
+
+function funcOne() {
+  setTimeout(() => console.log("Timeout 1!"), 0);
+  myPromise.then((res) => res).then((res) => console.log(`${res} 1!`));
+  console.log("Last line 1!");
+}
+
+async function funcTwo() {
+  const res = await myPromise;
+  console.log(`${res} 2!`);
+  setTimeout(() => console.log("Timeout 2!"), 0);
+  console.log("Last line 2!");
+}
+
+funcOne();
+funcTwo();
+```
+
+- A: `Promise 1! Last line 1! Promise 2! Last line 2! Timeout 1! Timeout 2!`
+- B: `Last line 1! Timeout 1! Promise 1! Last line 2! Promise2! Timeout 2! `
+- C: `Last line 1! Promise 2! Last line 2! Promise 1! Timeout 1! Timeout 2!`
+- D: `Timeout 1! Promise 1! Last line 1! Promise 2! Timeout 2! Last line 2!`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+First, we invoke `funcOne`. On the first line of `funcOne`, we call the _asynchronous_ `setTimeout` function, from which the callback is sent to the Web API. (see my article on the event loop <a href="https://dev.to/lydiahallie/javascript-visualized-event-loop-3dif">here</a>.)
+
+Then we call the `myPromise` promise, which is an _asynchronous_ operation. Pay attention, that now only the first then clause was added to the microtask queue.
+
+Both the promise and the timeout are asynchronous operations, the function keeps on running while it's busy completing the promise and handling the `setTimeout` callback. This means that `Last line 1!` gets logged first, since this is not an asynchonous operation.
+
+Since the callstack is not empty yet, the `setTimeout` function and promise in `funcOne` cannot get added to the callstack yet.
+
+In `funcTwo`, the variable `res` gets `Promise` because `Promise.resolve(Promise.resolve('Promise'))` is equivalent to `Promise.resolve('Promise')` since resolving a promise just resolves it's value. The `await` in this line stops the execution of the function until it receives the resolution of the promise and then keeps on running synchronously until completion, so `Promise 2!` and then `Last line 2!` are logged and the `setTimeout` is sent to the Web API. If the first then clause in `funcOne` had its own log statement, it would be printed before `Promise 2!`. Howewer, it executed silently and put the second then clause in microtask queue. So, the second clause will be printed after `Promise 2!`.
+
+Then the call stack is empty. Promises are _microtasks_ so they are resolved first when the call stack is empty so `Promise 1!` gets to be logged.
+
+Now, since `funcTwo` popped off the call stack, the call stack is empty. The callbacks waiting in the queue (`() => console.log("Timeout 1!")` from `funcOne`, and `() => console.log("Timeout 2!")` from `funcTwo`) get added to the call stack one by one. The first callback logs `Timeout 1!`, and gets popped off the stack. Then, the second callback logs `Timeout 2!`, and gets popped off the stack.
+
+</p>
+</details>
+
+---
+
+###### 134. How can we invoke `sum` in `sum.js` from `index.js?`
+
+```javascript
+// sum.js
+export default function sum(x) {
+  return x + x;
+}
+
+// index.js
+import * as sum from "./sum";
+```
+
+- A: `sum(4)`
+- B: `sum.sum(4)`
+- C: `sum.default(4)`
+- D: Default aren't imported with `*`, only named exports
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+With the asterisk `*`, we import all exported values from that file, both default and named. If we had the following file:
+
+```javascript
+// info.js
+export const name = "Lydia";
+export const age = 21;
+export default "I love JavaScript";
+
+// index.js
+import * as info from "./info";
+console.log(info);
+```
+
+The following would get logged:
+
+```javascript
+{
+  default: "I love JavaScript",
+  name: "Lydia",
+  age: 21
+}
+```
+
+For the `sum` example, it means that the imported value `sum` looks like this:
+
+```javascript
+{ default: function sum(x) { return x + x } }
+```
+
+We can invoke this function, by calling `sum.default`
+
+</p>
+</details>
+
+---
+
+###### 135. এটার আউটপুট কোনটা?
+
+```javascript
+const handler = {
+  set: () => console.log("Added a new property!"),
+  get: () => console.log("Accessed a property!"),
+};
+
+const person = new Proxy({}, handler);
+
+person.name = "Lydia";
+person.name;
+```
+
+- A: `Added a new property!`
+- B: `Accessed a property!`
+- C: `Added a new property!` `Accessed a property!`
+- D: Nothing gets logged
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+With a Proxy object, we can add custom behavior to an object that we pass to it as the second argument. In this case, we pass the `handler` object which contains two properties: `set` and `get`. `set` gets invoked whenever we _set_ property values, and `get` gets invoked whenever we _get_ (access) property values.
+
+The first argument is an empty object `{}`, which is the value of `person`. To this object, the custom behavior specified in the `handler` object gets added. If we add a property to the `person` object, `set` will get invoked. If we access a property on the `person` object, `get` gets invoked.
+
+First, we added a new property `name` to the proxy object (`person.name = "Lydia"`). `set` gets invoked, and logs `"Added a new property!"`.
+
+Then, we access a property value on the proxy object, and the `get` property on the handler object is invoked. `"Accessed a property!"` gets logged.
+
+</p>
+</details>
+
+---
+
+###### 136. Which of the following will modify the `person` object?
+
+```javascript
+const person = { name: "Lydia Hallie" };
+
+Object.seal(person);
+```
+
+- A: `person.name = "Evan Bacon"`
+- B: `person.age = 21`
+- C: `delete person.name`
+- D: `Object.assign(person, { age: 21 })`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: A
+
+With `Object.seal` we can prevent new properties from being _added_, or existing properties to be _removed_.
+
+However, you can still modify the value of existing properties.
+
+</p>
+</details>
+
+---
+
+###### 137. Which of the following will modify the `person` object?
+
+```javascript
+const person = {
+  name: "Lydia Hallie",
+  address: {
+    street: "100 Main St",
+  },
+};
+
+Object.freeze(person);
+```
+
+- A: `person.name = "Evan Bacon"`
+- B: `delete person.address`
+- C: `person.address.street = "101 Main St"`
+- D: `person.pet = { name: "Mara" }`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+The `Object.freeze` method _freezes_ an object. No properties can be added, modified, or removed.
+
+However, it only _shallowly_ freezes the object, meaning that only _direct_ properties on the object are frozen. If the property is another object, like `address` in this case, the properties on that object aren't frozen, and can be modified.
+
+</p>
+</details>
+
+---
+
+###### 138. এটার আউটপুট কোনটা?
+
+```javascript
+const add = (x) => x + x;
+
+function myFunc(num = 2, value = add(num)) {
+  console.log(num, value);
+}
+
+myFunc();
+myFunc(3);
+```
+
+- A: `2` `4` and `3` `6`
+- B: `2` `NaN` and `3` `NaN`
+- C: `2` `Error` and `3` `6`
+- D: `2` `4` and `3` `Error`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: A
+
+First, we invoked `myFunc()` without passing any arguments. Since we didn't pass arguments, `num` and `value` got their default values: num is `2`, and `value` is the returned value of the function `add`. To the `add` function, we pass `num` as an argument, which had the value of `2`. `add` returns `4`, which is the value of `value`.
+
+Then, we invoked `myFunc(3)` and passed the value `3` as the value for the argument `num`. We didn't pass an argument for `value`. Since we didn't pass a value for the `value` argument, it got the default value: the returned value of the `add` function. To `add`, we pass `num`, which has the value of `3`. `add` returns `6`, which is the value of `value`.
+
+</p>
+</details>
+
+---
+
+###### 139. এটার আউটপুট কোনটা?
+
+```javascript
+class Counter {
+  #number = 10;
+
+  increment() {
+    this.#number++;
+  }
+
+  getNum() {
+    return this.#number;
+  }
+}
+
+const counter = new Counter();
+counter.increment();
+
+console.log(counter.#number);
+```
+
+- A: `10`
+- B: `11`
+- C: `undefined`
+- D: `SyntaxError`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: D
+
+In ES2020, we can add private variables in classes by using the `#`. We cannot access these variables outside of the class. When we try to log `counter.#number`, a SyntaxError gets thrown: we cannot access it outside the `Counter` class!
+
+</p>
+</details>
+
+---
+
+###### 140. What's missing?
+
+```javascript
+const teams = [
+  { name: "Team 1", members: ["Paul", "Lisa"] },
+  { name: "Team 2", members: ["Laura", "Tim"] },
+];
+
+function* getMembers(members) {
+  for (let i = 0; i < members.length; i++) {
+    yield members[i];
+  }
+}
+
+function* getTeams(teams) {
+  for (let i = 0; i < teams.length; i++) {
+    // ✨ SOMETHING IS MISSING HERE ✨
+  }
+}
+
+const obj = getTeams(teams);
+obj.next(); // { value: "Paul", done: false }
+obj.next(); // { value: "Lisa", done: false }
+```
+
+- A: `yield getMembers(teams[i].members)`
+- B: `yield* getMembers(teams[i].members)`
+- C: `return getMembers(teams[i].members)`
+- D: `return yield getMembers(teams[i].members)`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: B
+
+In order to iterate over the `members` in each element in the `teams` array, we need to pass `teams[i].members` to the `getMembers` generator function. The generator function returns a generator object. In order to iterate over each element in this generator object, we need to use `yield*`.
+
+If we would've written `yield`, `return yield`, or `return`, the entire generator function would've gotten returned the first time we called the `next` method.
+
+</p>
+</details>
+
+---
+
+###### 141. এটার আউটপুট কোনটা?
+
+```javascript
+const person = {
+  name: "Lydia Hallie",
+  hobbies: ["coding"],
+};
+
+function addHobby(hobby, hobbies = person.hobbies) {
+  hobbies.push(hobby);
+  return hobbies;
+}
+
+addHobby("running", []);
+addHobby("dancing");
+addHobby("baking", person.hobbies);
+
+console.log(person.hobbies);
+```
+
+- A: `["coding"]`
+- B: `["coding", "dancing"]`
+- C: `["coding", "dancing", "baking"]`
+- D: `["coding", "running", "dancing", "baking"]`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+The `addHobby` function receives two arguments, `hobby` and `hobbies` with the default value of the `hobbies` array on the `person` object.
+
+First, we invoke the `addHobby` function, and pass `"running"` as the value for `hobby` and an empty array as the value for `hobbies`. Since we pass an empty array as the value for `hobbies`, `"running"` gets added to this empty array.
+
+Then, we invoke the `addHobby` function, and pass `"dancing"` as the value for `hobby`. We didn't pass a value for `hobbies`, so it gets the default value, the `hobbies` property on the `person` object. We push the hobby `dancing` to the `person.hobbies` array.
+
+Last, we invoke the `addHobby` function, and pass `"baking"` as the value for `hobby`, and the `person.hobbies` array as the value for `hobbies`. We push the hobby `baking` to the `person.hobbies` array.
+
+After pushing `dancing` and `baking`, the value of `person.hobbies` is `["coding", "dancing", "baking"]`
+
+</p>
+</details>
+
+---
+
+###### 142. এটার আউটপুট কোনটা?
+
+```javascript
+class Bird {
+  constructor() {
+    console.log("I'm a bird. 🦢");
+  }
+}
+
+class Flamingo extends Bird {
+  constructor() {
+    console.log("I'm pink. 🌸");
+    super();
+  }
+}
+
+const pet = new Flamingo();
+```
+
+- A: `I'm pink. 🌸`
+- B: `I'm pink. 🌸` `I'm a bird. 🦢`
+- C: `I'm a bird. 🦢` `I'm pink. 🌸`
+- D: Nothing, we didn't call any method
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: B
+
+We create the variable `pet` which is an instance of the `Flamingo` class. When we instantiate this instance, the `constructor` on `Flamingo` gets called. First, `"I'm pink. 🌸"` gets logged, after which we call `super()`. `super()` calls the constructor of the parent class, `Bird`. The constructor in `Bird` gets called, and logs `"I'm a bird. 🦢"`.
+
+</p>
+</details>
+
+---
+
+###### 143. Which of the options result(s) in an error?
+
+```javascript
+const emojis = ["🎄", "🎅🏼", "🎁", "⭐"];
+
+/* 1 */ emojis.push("🦌");
+/* 2 */ emojis.splice(0, 2);
+/* 3 */ emojis = [...emojis, "🥂"];
+/* 4 */ emojis.length = 0;
+```
+
+- A: 1
+- B: 1 and 2
+- C: 3 and 4
+- D: 3
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: D
+
+The `const` keyword simply means we cannot _redeclare_ the value of that variable, it's _read-only_. However, the value itself isn't immutable. The properties on the `emojis` array can be modified, for example by pushing new values, splicing them, or setting the length of the array to 0.
+
+</p>
+</details>
+
+---
+
+###### 144. What do we need to add to the `person` object to get `["Lydia Hallie", 21]` as the output of `[...person]`?
+
+```javascript
+const person = {
+  name: "Lydia Hallie",
+  age: 21
+}
+
+[...person] // ["Lydia Hallie", 21]
+```
+
+- A: Nothing, object are iterable by default
+- B: `*[Symbol.iterator]() { for (let x in this) yield* this[x] }`
+- C: `*[Symbol.iterator]() { yield* Object.values(this) }`
+- D: `*[Symbol.iterator]() { for (let x in this) yield this }`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+Objects aren't iterable by default. An iterable is an iterable if the iterator protocol is present. We can add this manually by adding the iterator symbol `[Symbol.iterator]`, which has to return a generator object, for example by making it a generator function `*[Symbol.iterator]() {}`. This generator function has to yield the `Object.values` of the `person` object if we want it to return the array `["Lydia Hallie", 21]`: `yield* Object.values(this)`.
+
+</p>
+</details>
+
+---
+
+###### 145. এটার আউটপুট কোনটা?
+
+```javascript
+let count = 0;
+const nums = [0, 1, 2, 3];
+
+nums.forEach((num) => {
+  if (num) count += 1;
+});
+
+console.log(count);
+```
+
+- A: 1
+- B: 2
+- C: 3
+- D: 4
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+The `if` condition within the `forEach` loop checks whether the value of `num` is truthy or falsy. Since the first number in the `nums` array is `0`, a falsy value, the `if` statement's code block won't be executed. `count` only gets incremented for the other 3 numbers in the `nums` array, `1`, `2` and `3`. Since `count` gets incremented by `1` 3 times, the value of `count` is `3`.
+
+</p>
+</details>
+
+---
+
+###### 146. এটার আউটপুট কোনটা?
+
+```javascript
+function getFruit(fruits) {
+  console.log(fruits?.[1]?.[1]);
+}
+
+getFruit([["🍊", "🍌"], ["🍍"]]);
+getFruit();
+getFruit([["🍍"], ["🍊", "🍌"]]);
+```
+
+- A: `null`, `undefined`, 🍌
+- B: `[]`, `null`, 🍌
+- C: `[]`, `[]`, 🍌
+- D: `undefined`, `undefined`, 🍌
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: D
+
+The `?` allows us to optionally access deeper nested properties within objects. We're trying to log the item on index `1` within the subarray that's on index `1` of the `fruits` array. If the subarray on index `1` in the `fruits` array doesn't exist, it'll simply return `undefined`. If the subarray on index `1` in the `fruits` array exists, but this subarray doesn't have an item on its `1` index, it'll also return `undefined`.
+
+First, we're trying to log the second item in the `['🍍']` subarray of `[['🍊', '🍌'], ['🍍']]`. This subarray only contains one item, which means there is no item on index `1`, and returns `undefined`.
+
+Then, we're invoking the `getFruits` function without passing a value as an argument, which means that `fruits` has a value of `undefined` by default. Since we're conditionally chaining the item on index `1` of`fruits`, it returns `undefined` since this item on index `1` does not exist.
+
+Lastly, we're trying to log the second item in the `['🍊', '🍌']` subarray of `['🍍'], ['🍊', '🍌']`. The item on index `1` within this subarray is `🍌`, which gets logged.
+
+</p>
+</details>
+
+---
+
+###### 147. এটার আউটপুট কোনটা?
+
+```javascript
+class Calc {
+  constructor() {
+    this.count = 0;
+  }
+
+  increase() {
+    this.count++;
+  }
+}
+
+const calc = new Calc();
+new Calc().increase();
+
+console.log(calc.count);
+```
+
+- A: `0`
+- B: `1`
+- C: `undefined`
+- D: `ReferenceError`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: A
+
+We set the variable `calc` equal to a new instance of the `Calc` class. Then, we instantiate a new instance of `Calc`, and invoke the `increase` method on this instance. Since the count property is within the constructor of the `Calc` class, the count property is not shared on the prototype of `Calc`. This means that the value of count has not been updated for the instance calc points to, count is still `0`.
+
+</p>
+</details>
+
+---
+
+###### 148. এটার আউটপুট কোনটা?
+
+```javascript
+const user = {
+  email: "e@mail.com",
+  password: "12345",
+};
+
+const updateUser = ({ email, password }) => {
+  if (email) {
+    Object.assign(user, { email });
+  }
+
+  if (password) {
+    user.password = password;
+  }
+
+  return user;
+};
+
+const updatedUser = updateUser({ email: "new@email.com" });
+
+console.log(updatedUser === user);
+```
+
+- A: `false`
+- B: `true`
+- C: `TypeError`
+- D: `ReferenceError`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: B
+
+The `updateUser` function updates the values of the `email` and `password` properties on user, if their values are passed to the function, after which the function returns the `user` object. The returned value of the `updateUser` function is the `user` object, which means that the value of updatedUser is a reference to the same `user` object that `user` points to. `updatedUser === user` equals `true`.
+
+</p>
+</details>
+
+---
+
+###### 149. এটার আউটপুট কোনটা?
+
+```javascript
+const fruit = ["🍌", "🍊", "🍎"];
+
+fruit.slice(0, 1);
+fruit.splice(0, 1);
+fruit.unshift("🍇");
+
+console.log(fruit);
+```
+
+- A: `['🍌', '🍊', '🍎']`
+- B: `['🍊', '🍎']`
+- C: `['🍇', '🍊', '🍎']`
+- D: `['🍇', '🍌', '🍊', '🍎']`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+First, we invoke the `slice` method on the fruit array. The slice method does not modify the original array, but returns the value that it sliced off the array: the banana emoji.
+Then, we invoke the `splice` method on the fruit array. The splice method does modify the original array, which means that the fruit array now consists of `['🍊', '🍎']`.
+At last, we invoke the `unshift` method on the `fruit` array, which modifies the original array by adding the provided value, ‘🍇’ in this case, as the first element in the array. The fruit array now consists of `['🍇', '🍊', '🍎']`.
+
+</p>
+</details>
+
+---
+
+###### 150. এটার আউটপুট কোনটা?
+
+```javascript
+const animals = {};
+let dog = { emoji: "🐶" };
+let cat = { emoji: "🐈" };
+
+animals[dog] = { ...dog, name: "Mara" };
+animals[cat] = { ...cat, name: "Sara" };
+
+console.log(animals[dog]);
+```
+
+- A: `{ emoji: "🐶", name: "Mara" }`
+- B: `{ emoji: "🐈", name: "Sara" }`
+- C: `undefined`
+- D: `ReferenceError`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: B
+
+Object keys are converted to strings.
+
+Since the value of `dog` is an object, `animals[dog]` actually means that we’re creating a new property called `"[object Object]"` equal to the new object. `animals["[object Object]"]` is now equal to `{ emoji: "🐶", name: "Mara"}`.
+
+`cat` is also an object, which means that `animals[cat]` actually means that we’re overwriting the value of `animals["[object Object]"]` with the new cat properties.
+
+Logging `animals[dog]`, or actually `animals["[object Object]"]` since converting the `dog` object to a string results `"[object Object]"`, returns the `{ emoji: "🐈", name: "Sara" }`.
+
+</p>
+</details>
+
+---
+
+###### 151. এটার আউটপুট কোনটা?
+
+```javascript
+const user = {
+  email: "my@email.com",
+  updateEmail: (email) => {
+    this.email = email;
+  },
+};
+
+user.updateEmail("new@email.com");
+console.log(user.email);
+```
+
+- A: `my@email.com`
+- B: `new@email.com`
+- C: `undefined`
+- D: `ReferenceError`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: A
+
+The `updateEmail` function is an arrow function, and is not bound to the `user` object. This means that the `this` keyword is not referring to the `user` object, but refers to the global scope in this case. The value of `email` within the `user` object does not get updated. When logging the value of `user.email`, the original value of `my@email.com` gets returned.
+
+</p>
+</details>
+
+---
+
+###### 152. এটার আউটপুট কোনটা?
+
+```javascript
+const promise1 = Promise.resolve("First");
+const promise2 = Promise.resolve("Second");
+const promise3 = Promise.reject("Third");
+const promise4 = Promise.resolve("Fourth");
+
+const runPromises = async () => {
+  const res1 = await Promise.all([promise1, promise2]);
+  const res2 = await Promise.all([promise3, promise4]);
+  return [res1, res2];
+};
+
+runPromises()
+  .then((res) => console.log(res))
+  .catch((err) => console.log(err));
+```
+
+- A: `[['First', 'Second'], ['Fourth']]`
+- B: `[['First', 'Second'], ['Third', 'Fourth']]`
+- C: `[['First', 'Second']]`
+- D: `'Third'`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: D
+
+The `Promise.all` method runs the passed promises in parallel. If one promise fails, the `Promise.all` method _rejects_ with the value of the rejected promise. In this case, `promise3` is rejected with the value `"Third"`. We’re catching the rejected value in the chained `catch` method on the `runPromises` invocation to catch any errors within the `runPromises` function. Only `"Third"` gets logged, since `promise3` is rejected with this value.
+
+</p>
+</details>
+
+---
+
+###### 153. What should the value of `method` be to log `{ name: "Lydia", age: 22 }`?
+
+```javascript
+const keys = ["name", "age"];
+const values = ["Lydia", 22];
+
+const method =
+  /* ?? */
+  Object[method](
+    keys.map((_, i) => {
+      return [keys[i], values[i]];
+    })
+  ); // { name: "Lydia", age: 22 }
+```
+
+- A: `entries`
+- B: `values`
+- C: `fromEntries`
+- D: `forEach`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+The `fromEntries` method turns a 2d array into an object. The first element in each subarray will be the key, and the second element in each subarray will be the value. In this case, we’re mapping over the `keys` array, which returns an array that the first element is the item on the key array on the current index, and the second element is the item of the values array on the current index.
+
+This creates an array of subarrays containing the correct keys and values, which results in `{ name: "Lydia", age: 22 }`
+
+</p>
+</details>
+
+---
+
+###### 154. এটার আউটপুট কোনটা?
+
+```javascript
+const createMember = ({ email, address = {} }) => {
+  const validEmail = /.+\@.+\..+/.test(email);
+  if (!validEmail) throw new Error("Valid email pls");
+
+  return {
+    email,
+    address: address ? address : null,
+  };
+};
+
+const member = createMember({ email: "my@email.com" });
+console.log(member);
+```
+
+- A: `{ email: "my@email.com", address: null }`
+- B: `{ email: "my@email.com" }`
+- C: `{ email: "my@email.com", address: {} }`
+- D: `{ email: "my@email.com", address: undefined }`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: C
+
+The default value of `address` is an empty object `{}`. When we set the variable `member` equal to the object returned by the `createMember` function, we didn't pass a value for the address, which means that the value of the address is the default empty object `{}`. An empty object is a truthy value, which means that the condition of the `address ? address : null` conditional returns `true`. The value of the address is the empty object `{}`.
+
+</p>
+</details>
+
+---
+
+###### 155. এটার আউটপুট কোনটা?
+
+```javascript
+let randomValue = { name: "Lydia" };
+randomValue = 23;
+
+if (!typeof randomValue === "string") {
+  console.log("It's not a string!");
+} else {
+  console.log("Yay it's a string!");
+}
+```
+
+- A: `It's not a string!`
+- B: `Yay it's a string!`
+- C: `TypeError`
+- D: `undefined`
+
+<details><summary><b>উত্তর দেখুন</b></summary>
+<p>
+
+#### উত্তর: B
+
+The condition within the `if` statement checks whether the value of `!typeof randomValue` is equal to `"string"`. The `!` operator converts the value to a boolean value. If the value is truthy, the returned value will be `false`, if the value is falsy, the returned value will be `true`. In this case, the returned value of `typeof randomValue` is the truthy value `"number"`, meaning that the value of `!typeof randomValue` is the boolean value `false`.
+
+`!typeof randomValue === "string"` always returns false, since we're actually checking `false === "string"`. Since the condition returned `false`, the code block of the `else` statement gets run, and `Yay it's a string!` gets logged.
+
+</p>
+</details>

From 6fd5ba15ed93a887adbcb0fae91dae72c1833a5c Mon Sep 17 00:00:00 2001
From: iamsaief <saiefalemon@gmail.com>
Date: Mon, 20 May 2024 04:48:36 +0600
Subject: [PATCH 02/12] added translation till 44

---
 README.md             |   2 +-
 bn-BD/README_bn-BD.md | 532 +++++++++++++++++++++---------------------
 2 files changed, 270 insertions(+), 264 deletions(-)

diff --git a/README.md b/README.md
index 33993983..91f9b967 100644
--- a/README.md
+++ b/README.md
@@ -20,7 +20,7 @@ From basic to advanced: test how well you know JavaScript, refresh your knowledg
 | Feel free to use them in a project! 😃 I would _really_ appreciate a reference to this repo, I create the questions and explanations (yes I'm sad lol) and the community helps me so much to maintain and improve it! 💪🏼 Thank you and have fun! |
 | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
 
-<details><summary><strong> See 20 Available Translations 🇸🇦🇪🇬🇧🇦🇩🇪🇪🇸🇫🇷🇮🇩🇯🇵🇰🇷🇳🇱🇧🇷🇷🇺🇹🇭🇹🇷🇺🇦🇻🇳🇨🇳🇹🇼🇽🇰</strong></summary>
+<details><summary><strong> See 21 Available Translations 🇸🇦🇪🇬🇧🇦🇩🇪🇪🇸🇫🇷🇮🇩🇯🇵🇰🇷🇳🇱🇧🇷🇷🇺🇹🇭🇹🇷🇺🇦🇻🇳🇨🇳🇹🇼🇽🇰🇧🇩</strong></summary>
 <p>
 
 - [🇸🇦 العربية](./ar-AR/README_AR.md)
diff --git a/bn-BD/README_bn-BD.md b/bn-BD/README_bn-BD.md
index 7f8d0060..d9a00cf2 100644
--- a/bn-BD/README_bn-BD.md
+++ b/bn-BD/README_bn-BD.md
@@ -52,7 +52,7 @@
 function sayHi() {
   console.log(name);
   console.log(age);
-  var name = "Lydia";
+  var name = 'Lydia';
   let age = 21;
 }
 
@@ -135,7 +135,7 @@ console.log(shape.perimeter());
 
 > খেয়াল করুন এখানে `diameter` একটি সাধারন ফাংশন অন্যদিকে `perimeter` হচ্ছে একটি অ্যারো ফাংশন।
 
-অ্যারো ফাংশনের `this` কিওয়ার্ড গ্লোবাল স্কোপকে রেফার (পয়েন্ট) করে, কিন্তু সাধারন ফাংশনের নিজের স্কোপেই পয়েন্ট করে। মানে হল, যখন আমরা `perimeter` কে কল করছি এটা shape অব্জেক্ট কে রেফার করছে না বরং গ্লোবাল স্কোপকে করছে (উদাহরনস্বরূপ - window)। 
+অ্যারো ফাংশনের `this` কিওয়ার্ড গ্লোবাল স্কোপকে রেফার (পয়েন্ট) করে, কিন্তু সাধারন ফাংশনের নিজের স্কোপেই পয়েন্ট করে। মানে হল, যখন আমরা `perimeter` কে কল করছি এটা shape অব্জেক্ট কে রেফার করছে না বরং গ্লোবাল স্কোপকে করছে (উদাহরনস্বরূপ - window)।
 
 যেহেতু অ্যারো ফাংশনের স্কোপে `radius` এর কোন ভ্যালু নেই `this.radius` রিটার্ন করছে `undefined` একে ২ দিয়ে গুন করার ফলে (`2 * Math.PI`) ফলাফল আসছে `NaN`.
 
@@ -148,7 +148,7 @@ console.log(shape.perimeter());
 
 ```javascript
 +true;
-!"Lydia";
+!'Lydia';
 ```
 
 - A: `1` and `false`
@@ -164,7 +164,6 @@ console.log(shape.perimeter());
 
 `'Lydia'` স্ট্রিং টি একটি সত্য ভ্যালু। আমরা এখানে আসলে `!` দিয়ে যেটা জিজ্ঞেস করছি "এই সত্য ভ্যালুটি কি মিথ্যা ?"। এটি ফলাফল দিচ্ছে `false`।
 
-
 </p>
 </details>
 
@@ -174,11 +173,11 @@ console.log(shape.perimeter());
 
 ```javascript
 const bird = {
-  size: "small",
+  size: 'small',
 };
 
 const mouse = {
-  name: "Mickey",
+  name: 'Mickey',
   small: true,
 };
 ```
@@ -207,11 +206,11 @@ const mouse = {
 ###### 6. এটার আউটপুট কোনটা?
 
 ```javascript
-let c = { greeting: "Hey!" };
+let c = { greeting: 'Hey!' };
 let d;
 
 d = c;
-c.greeting = "Hello";
+c.greeting = 'Hello';
 console.log(d.greeting);
 ```
 
@@ -263,7 +262,7 @@ console.log(b === c);
 
 `new Number()` হল একটি বিল্ট-ইন ফাংশন কন্সট্রাক্টর। যদিও এটা নাম্বার এর মত দেখতে কিন্তু এটি আসলে নাম্বার নয়ঃ এটাতে আর অনেকগুলো ফিচার আছে এবং এটি একটি অবজেক্ট।
 
-যখন আমরা `==` অপারেটর (সমতুল্য অপারেটর) ব্যাবহার করি, এটা কেবল ভ্যালু সমান কিনা তুলনা করে। `a` ও `b` দুটার ভ্যালুই `3` তাই ফলাফল হয় `true`। 
+যখন আমরা `==` অপারেটর (সমতুল্য অপারেটর) ব্যাবহার করি, এটা কেবল ভ্যালু সমান কিনা তুলনা করে। `a` ও `b` দুটার ভ্যালুই `3` তাই ফলাফল হয় `true`।
 
 অন্যদিকে, যখন আমরা `===` অপারেটর (কঠোর-সমতুল্য অপারেটর) ব্যাবহার করি, এটা ভ্যালু এবং টাইপ দুটাই সমান কিনা তুলনা করে। এক্ষত্রে `new Number()` যেহেতু নাম্বর নয় অবেজেক্ট। দুটই ফলাফল দেয় `false`।
 
@@ -281,13 +280,13 @@ class Chameleon {
     return this.newColor;
   }
 
-  constructor({ newColor = "green" } = {}) {
+  constructor({ newColor = 'green' } = {}) {
     this.newColor = newColor;
   }
 }
 
-const freddie = new Chameleon({ newColor: "purple" });
-console.log(freddie.colorChange("orange"));
+const freddie = new Chameleon({ newColor: 'purple' });
+console.log(freddie.colorChange('orange'));
 ```
 
 - A: `orange`
@@ -324,14 +323,14 @@ console.log(greetign);
 
 #### উত্তর: A
 
-এটা অবজেক্টকে লগ করছে, কারন আমরা খালি অবজেক্টটিকে তৈরি করেছি গ্লোবাল অবজেক্টের মধ্যে! যখন `greeting` কে `greetign` ভুল বানান এ লিখেছি, জেএস ইন্টারপ্রেটার দেখছে এমনঃ 
+এটা অবজেক্টকে লগ করছে, কারন আমরা খালি অবজেক্টটিকে তৈরি করেছি গ্লোবাল অবজেক্টের মধ্যে! যখন `greeting` কে `greetign` ভুল বানান এ লিখেছি, জেএস ইন্টারপ্রেটার দেখছে এমনঃ
 
-1. নোড জেওএস এ - `global.greetign = {}`। 
-2. ব্রাউজার এ - `window.greetign = {}`, `frames.greetign = {}` এবং `self.greetign`। 
-3. ওয়েব ওয়ার্কার্স এ - `self.greetign`। 
+1. নোড জেওএস এ - `global.greetign = {}`।
+2. ব্রাউজার এ - `window.greetign = {}`, `frames.greetign = {}` এবং `self.greetign`।
+3. ওয়েব ওয়ার্কার্স এ - `self.greetign`।
 4. অন্য সকল এনভায়র্ন্মেন্টে - `globalThis.greetign`।
 
-এটাকে এড়ানোর জন্য আমরা `"use strict"` ব্যাবহার করতে পারি । এটা নিশ্চিত করবে যে আপনি ভেরিয়েবলকে কোন কিছু দিয়ে অ্যাসাইন করার আগে তাকে ডিক্লেয়ার করেছেন কিনা । 
+এটাকে এড়ানোর জন্য আমরা `"use strict"` ব্যাবহার করতে পারি । এটা নিশ্চিত করবে যে আপনি ভেরিয়েবলকে কোন কিছু দিয়ে অ্যাসাইন করার আগে তাকে ডিক্লেয়ার করেছেন কিনা ।
 
 </p>
 </details>
@@ -342,10 +341,10 @@ console.log(greetign);
 
 ```javascript
 function bark() {
-  console.log("Woof!");
+  console.log('Woof!');
 }
 
-bark.animal = "dog";
+bark.animal = 'dog';
 ```
 
 - A: Nothing, this is totally fine!
@@ -362,7 +361,6 @@ bark.animal = "dog";
 
 ফাংশনগুলো হয় বিশেষ ধরনের অবজেক্ট। যে কোডটা আপনি লিখেছেন এটা আসল ফাংশন নয়। ফাংশনটি হচ্ছে একটি অবজেক্ট যার প্রপার্টিস রয়েছে। এই প্রোপার্টিগুলোকে কল করা যায়।
 
-
 </p>
 </details>
 
@@ -376,7 +374,7 @@ function Person(firstName, lastName) {
   this.lastName = lastName;
 }
 
-const member = new Person("Lydia", "Hallie");
+const member = new Person('Lydia', 'Hallie');
 Person.getFullName = function () {
   return `${this.firstName} ${this.lastName}`;
 };
@@ -417,8 +415,8 @@ function Person(firstName, lastName) {
   this.lastName = lastName;
 }
 
-const lydia = new Person("Lydia", "Hallie");
-const sarah = Person("Sarah", "Smith");
+const lydia = new Person('Lydia', 'Hallie');
+const sarah = Person('Sarah', 'Smith');
 
 console.log(lydia);
 console.log(sarah);
@@ -488,7 +486,7 @@ function sum(a, b) {
   return a + b;
 }
 
-sum(1, "2");
+sum(1, '2');
 ```
 
 - A: `NaN`
@@ -503,7 +501,7 @@ sum(1, "2");
 
 জাভাস্ক্রিপ্ট একটি **ডায়নামিক টাইপ ভাষাঃ** আমরা ভেরিয়েবলের টাইপ নির্দিষ্ট করি না। আপনি জানতে পারেন না ভ্যালু স্বয়ংক্রিয়ভাবেই এক টাইপ থেকে অন্য টাইপে পরিবর্তন হয়ে যায়, যেটাকে বলা হয় **কোয়ার্শন (coercion)**। এটা হল এক টাইপ থেকে অন্য টাইপে পরিবর্তন হওয়া।
 
-এই উদাহরনে, জাভাস্ক্রিপ্ট এই ফাংশনটিকে যুক্তিসঙ্গত ও এর একটি ফলাফল রিটার্ন করার জন্য `1` নাম্বারটিকে স্ট্রিং এ পরিবর্তন করেছে। নাম্বার `1` ও স্ট্রিং `"2"` এর যোগের বেলায় নাম্বারটিকে স্ট্রিং হিসেবে ধরা হয়েছে। আমরা দুটো স্ট্রিং কে যুক্ত করতে পারি এভাবে, `"Hello" + "World"`, তাই এখানে `"1" + "2"` ফলাফল রিটার্ন করছে `"12"`। 
+এই উদাহরনে, জাভাস্ক্রিপ্ট এই ফাংশনটিকে যুক্তিসঙ্গত ও এর একটি ফলাফল রিটার্ন করার জন্য `1` নাম্বারটিকে স্ট্রিং এ পরিবর্তন করেছে। নাম্বার `1` ও স্ট্রিং `"2"` এর যোগের বেলায় নাম্বারটিকে স্ট্রিং হিসেবে ধরা হয়েছে। আমরা দুটো স্ট্রিং কে যুক্ত করতে পারি এভাবে, `"Hello" + "World"`, তাই এখানে `"1" + "2"` ফলাফল রিটার্ন করছে `"12"`।
 
 </p>
 </details>
@@ -530,10 +528,12 @@ console.log(number);
 #### উত্তর: C
 
 **পোস্টফিক্স** ইউনারি অপারেটর `++`:
+
 1. ফলাফল রিটার্ন করে (এক্ষেত্রে রিটার্ন করে `0`)
 2. ভ্যালুর মান বৃদ্ধি করে (নাম্বারটি এখন `1`)
 
 **প্রিফিক্স** ইউনারি অপারেটর `++`:
+
 1. ভ্যালুর মান বৃদ্ধি করে (নাম্বারটি এখন `2`)
 2. ফলাফল রিটার্ন করে (এক্ষেত্রে রিটার্ন করে `2`)
 
@@ -553,7 +553,7 @@ function getPersonInfo(one, two, three) {
   console.log(three);
 }
 
-const person = "Lydia";
+const person = 'Lydia';
 const age = 21;
 
 getPersonInfo`${person} is ${age} years old`;
@@ -580,9 +580,9 @@ getPersonInfo`${person} is ${age} years old`;
 ```javascript
 function checkAge(data) {
   if (data === { age: 18 }) {
-    console.log("You are an adult!");
+    console.log('You are an adult!');
   } else if (data == { age: 18 }) {
-    console.log("You are still an adult.");
+    console.log('You are still an adult.');
   } else {
     console.log(`Hmm.. You don't have an age I guess`);
   }
@@ -631,7 +631,7 @@ getAge(21);
 
 #### উত্তর: C
 
-এখানে রেস্ট প্যারামিটারটি (`...args`) আমাদেরকে বাকি সব আর্গুমেন্টসকে একটি অ্যারেতে "সংগ্রহ" করতে দেয়। একটি অ্যারে হয় একটি অবজেক্ট, তাই `typeof args` রিটার্ন করে `"object"`। 
+এখানে রেস্ট প্যারামিটারটি (`...args`) আমাদেরকে বাকি সব আর্গুমেন্টসকে একটি অ্যারেতে "সংগ্রহ" করতে দেয়। একটি অ্যারে হয় একটি অবজেক্ট, তাই `typeof args` রিটার্ন করে `"object"`।
 
 </p>
 </details>
@@ -642,7 +642,7 @@ getAge(21);
 
 ```javascript
 function getAge() {
-  "use strict";
+  'use strict';
   age = 21;
   console.log(age);
 }
@@ -670,7 +670,7 @@ getAge();
 ###### 21. কোনটি `sum` এর ভ্যালু হবে?
 
 ```javascript
-const sum = eval("10*10+5");
+const sum = eval('10*10+5');
 ```
 
 - A: `105`
@@ -683,7 +683,7 @@ const sum = eval("10*10+5");
 
 #### উত্তর: A
 
-`eval` একটি স্ট্রিং হিসাবে পাস করা কোডকে মূল্যায়ন করে। যদি এটি একটি অভিব্যক্তি (expression)  হয়, যেমন এই ক্ষেত্রে, এটি অভিব্যক্তি মূল্যায়ন করেছে। অভিব্যক্তিটি হল `10 * 10 + 5`। এটি ফলাফল রিটার্ন করে `105`।
+`eval` একটি স্ট্রিং হিসাবে পাস করা কোডকে মূল্যায়ন করে। যদি এটি একটি অভিব্যক্তি (expression) হয়, যেমন এই ক্ষেত্রে, এটি অভিব্যক্তি মূল্যায়ন করেছে। অভিব্যক্তিটি হল `10 * 10 + 5`। এটি ফলাফল রিটার্ন করে `105`।
 
 </p>
 </details>
@@ -693,7 +693,7 @@ const sum = eval("10*10+5");
 ###### 22. কতক্ষণ cool_secret এক্সেসযোগ্য?
 
 ```javascript
-sessionStorage.setItem("cool_secret", 123);
+sessionStorage.setItem('cool_secret', 123);
 ```
 
 - A: Forever, the data doesn't get lost.
@@ -746,12 +746,12 @@ console.log(num);
 ###### 24. এটার আউটপুট কোনটা?
 
 ```javascript
-const obj = { 1: "a", 2: "b", 3: "c" };
+const obj = { 1: 'a', 2: 'b', 3: 'c' };
 const set = new Set([1, 2, 3, 4, 5]);
 
-obj.hasOwnProperty("1");
+obj.hasOwnProperty('1');
 obj.hasOwnProperty(1);
-set.has("1");
+set.has('1');
 set.has(1);
 ```
 
@@ -777,7 +777,7 @@ set.has(1);
 ###### 25. এটার আউটপুট কোনটা?
 
 ```javascript
-const obj = { a: "one", b: "two", a: "three" };
+const obj = { a: 'one', b: 'two', a: 'three' };
 console.log(obj);
 ```
 
@@ -835,7 +835,7 @@ for (let i = 1; i < 5; i++) {
 
 #### উত্তর: C
 
-`continue` স্টেটমেন্ট (বিবৃতি) একটি ইটারেশন (ইটারেশন) এড়িয়ে যায় যদি একটি নির্দিষ্ট শর্ত  `true` রিটার্ন করে।
+`continue` স্টেটমেন্ট (বিবৃতি) একটি ইটারেশন (ইটারেশন) এড়িয়ে যায় যদি একটি নির্দিষ্ট শর্ত `true` রিটার্ন করে।
 
 </p>
 </details>
@@ -846,10 +846,10 @@ for (let i = 1; i < 5; i++) {
 
 ```javascript
 String.prototype.giveLydiaPizza = () => {
-  return "Just give Lydia pizza already!";
+  return 'Just give Lydia pizza already!';
 };
 
-const name = "Lydia";
+const name = 'Lydia';
 
 console.log(name.giveLydiaPizza());
 ```
@@ -877,8 +877,8 @@ console.log(name.giveLydiaPizza());
 
 ```javascript
 const a = {};
-const b = { key: "b" };
-const c = { key: "c" };
+const b = { key: 'b' };
+const c = { key: 'c' };
 
 a[b] = 123;
 a[c] = 456;
@@ -896,11 +896,11 @@ console.log(a[b]);
 
 #### উত্তর: B
 
-Object keys are automatically converted into strings. We are trying to set an object as a key to object `a`, with the value of `123`.
+অবজেক্টের কিগুলো স্বয়ংক্রিয়ভাবে স্ট্রিং এ পরিবর্তন হয়ে যায়। আমরা `123` ভ্যালুটি দিয়ে `a` অবজেক্টের কি হিসেবে একটি অবজেক্টকেই কে সেট করার চেষ্টা করছি।
 
-However, when we stringify an object, it becomes `"[object Object]"`. So what we are saying here, is that `a["[object Object]"] = 123`. Then, we can try to do the same again. `c` is another object that we are implicitly stringifying. So then, `a["[object Object]"] = 456`.
+যাইহোক, যখন আমরা কোন অবজেক্টকে স্ট্রিংফাই করি তখন সেটি `"[object Object]"` হয়ে যায়। তাহলে এখানে আমরা যা বলছি সেটি হল, `a["[object Object]"] = 123`। তারপর আমরা একি কাজ করার চেষ্টা করেছি। `c` হল অন্য একটি অবজেক্ট যেটাকে আমরা পরোক্ষভাবে স্ট্রিংফাই করছি। তাহলে, `a["[object Object]"] = 456`।
 
-Then, we log `a[b]`, which is actually `a["[object Object]"]`. We just set that to `456`, so it returns `456`.
+তারপর আমরা `a[b]` লগ করি, যেটা আসলে `a["[object Object]"]`। আমরা কেবলই এটাকে সেট করেছি `456`, তাই এটা ফলাফল রিটার্ন করছে `456`।
 
 </p>
 </details>
@@ -910,9 +910,9 @@ Then, we log `a[b]`, which is actually `a["[object Object]"]`. We just set that
 ###### 30. এটার আউটপুট কোনটা?
 
 ```javascript
-const foo = () => console.log("First");
-const bar = () => setTimeout(() => console.log("Second"));
-const baz = () => console.log("Third");
+const foo = () => console.log('First');
+const bar = () => setTimeout(() => console.log('Second'));
+const baz = () => console.log('Third');
 
 bar();
 foo();
@@ -929,38 +929,38 @@ baz();
 
 #### উত্তর: B
 
-We have a `setTimeout` function and invoked it first. Yet, it was logged last.
+আমাদের একটি `setTimeout` ফাংশন আছে এবং এটিই আগে কল হয়েছে। তবু এটি শেষে লগ হয়েছে।
 
-This is because in browsers, we don't just have the runtime engine, we also have something called a `WebAPI`. The `WebAPI` gives us the `setTimeout` function to start with, and for example the DOM.
+এর কারন হল ব্রাউজারে কেবল রানটাইম ইঞ্জিনই নেই, আমাদের কাছে `WebAPI` নামেও কিছু একটা জিনিস আছে। এই `WebAPI`-ই আমাদের শুরু করার জন্য `setTimeout` ফাংশন দেয়, এবং উদাহরণস্বরূপ DOM।
 
-After the _callback_ is pushed to the WebAPI, the `setTimeout` function itself (but not the callback!) is popped off the stack.
+_কলব্যাক_ ফাংশনটিকে WebAPI এ পুশ করার পর `setTimeout` ফাংশনটি নিজেই কল স্ট্যাক থেকে পপ হয়ে যায়।
 
 <img src="https://i.imgur.com/X5wsHOg.png" width="200">
 
-Now, `foo` gets invoked, and `"First"` is being logged.
+এখন `foo` কে কল করা হচ্ছে এবং `"First"` লগ করা হয়েছে।
 
 <img src="https://i.imgur.com/Pvc0dGq.png" width="200">
 
-`foo` is popped off the stack, and `baz` gets invoked. `"Third"` gets logged.
+কল স্ট্যাক থেকে `foo` পপ হয়ে যায়, এবং `baz` কল করা হয়। `"Third"` লগ করা হয়েছে।
 
 <img src="https://i.imgur.com/WhA2bCP.png" width="200">
 
-The WebAPI can't just add stuff to the stack whenever it's ready. Instead, it pushes the callback function to something called the _queue_.
+`WebAPI` প্রস্তুত হলেই সে কল স্ট্যাকে কিছু যুক্ত করতে পারে না। তার পরিবর্তে সে কলব্যাক ফাংশন গুলিকে টাস্ক কিউ নামক কিছুতে পুশ করে দেয়।
 
 <img src="https://i.imgur.com/NSnDZmU.png" width="200">
 
-This is where an event loop starts to work. An **event loop** looks at the stack and task queue. If the stack is empty, it takes the first thing on the queue and pushes it onto the stack.
+এখানেই একটি _ইভেন্ট লুপ_ কাজ করতে শুরু করে। একটি _ইভেন্ট লুপ_ কল স্ট্যাক ও টাস্ক কিউর দিকে নজর রাখে। যদি স্ট্যাক খালি থাকে এটা কিউ থেকে ১ম জিনিসটাকে নিয়ে স্ট্যাকে পুশ করে দেয়।
 
 <img src="https://i.imgur.com/uyiScAI.png" width="200">
 
-`bar` gets invoked, `"Second"` gets logged, and it's popped off the stack.
+`bar` কল করা হয়ে, তাই `"Second"` লগ হয়েছে, এবং এটা স্ট্যাক থেকে পপ হয়ে যায়।
 
 </p>
 </details>
 
 ---
 
-###### 31. What is the event.target when clicking the button?
+###### 31. বাটনে ক্লিক করলে event.target কোনটি হবে?
 
 ```html
 <div onclick="console.log('first div')">
@@ -980,14 +980,14 @@ This is where an event loop starts to work. An **event loop** looks at the stack
 
 #### উত্তর: C
 
-The deepest nested element that caused the event is the target of the event. You can stop bubbling by `event.stopPropagation`
+ইভেন্টের টার্গেট হচ্ছে ডমের গভীরতম নেস্টেড এলিম্যান্ট যে ইনভেনটি ঘটিয়েছে।
 
 </p>
 </details>
 
 ---
 
-###### 32. When you click the paragraph, what's the logged output?
+###### 32. যখন প্যারাগ্রাফে ক্লিক করবেন, লগ আউটপুট কোনটি হবে?
 
 ```html
 <div onclick="console.log('div')">
@@ -1007,6 +1007,9 @@ The deepest nested element that caused the event is the target of the event. You
 
 If we click `p`, we see two logs: `p` and `div`. During event propagation, there are 3 phases: capturing, targeting, and bubbling. By default, event handlers are executed in the bubbling phase (unless you set `useCapture` to `true`). It goes from the deepest nested element outwards.
 
+`p` তে ক্লিক করলেই আমরা ২টা লগ দেখতে পাইঃ `p` ও `div`।
+ইভেন্ট প্রোপাগেশন এর সময় ৩টা পর্যায় থাকে ক্যাপচারিং, টারগেটিং, ও বাবলিং। স্বাবাবিকভাবেই ইভেন্ট হ্যান্ডলারগুলো কাজ করে বাবলিং পর্যায়ে (যদি না আপনি `capture` কে `true` করে দেন)। এটা গভীরতম নেস্টেড এলিম্যান্ট থেকে বাহিরের (প্যারেন্টের) দিকে যায়।
+
 </p>
 </details>
 
@@ -1015,7 +1018,7 @@ If we click `p`, we see two logs: `p` and `div`. During event propagation, there
 ###### 33. এটার আউটপুট কোনটা?
 
 ```javascript
-const person = { name: "Lydia" };
+const person = { name: 'Lydia' };
 
 function sayHi(age) {
   return `${this.name} is ${age}`;
@@ -1035,9 +1038,9 @@ console.log(sayHi.bind(person, 21));
 
 #### উত্তর: D
 
-With both, we can pass the object to which we want the `this` keyword to refer to. However, `.call` is also _executed immediately_!
+`.call` ও `.bind` দুটি দিয়েই আমরা `this` কিওয়ার্ডটি রেফার করা অবজেক্ট পাস করতে পারি। কিন্তু `.call` একই সাথে কলও হয়ে যাচ্ছে।
 
-`.bind.` returns a _copy_ of the function, but with a bound context! It is not executed immediately.
+`.bind.` এর বেলায় সে _ফাংশনের কপি_'র সাথে `this` এর একটি কার্যকর (bound) কনট্যাক্স রিটার্ন করে। কিন্তু একই সাথে কল হয় না।
 
 </p>
 </details>
@@ -1064,21 +1067,22 @@ console.log(typeof sayHi());
 
 #### উত্তর: B
 
-The `sayHi` function returns the returned value of the immediately invoked function expression (IIFE). This function returned `0`, which is type `"number"`.
-FYI: `typeof` can return the following list of values: `undefined`, `boolean`, `number`, `bigint`, `string`, `symbol`, `function` and `object`. Note that `typeof null` returns `"object"`.
+`sayHi` ফাংশনটি ইমিডিয়েটলি ইনভোকড ফাংশন এক্সপ্রেশনের (IIFE) রিটার্ন ভ্যালুটিই রিটার্ন করছে। এই ফাংশনটি রিটার্ন করেছে `0` যেটির টাইপ হচ্ছে একটি `"number"`।
+
+> জেনে রাখুনঃ `typeof` লিস্টে উল্লেখিত ভ্যালুগুলো রিটার্ন করতে পারেঃ `undefined`, `boolean`, `number`, `bigint`, `string`, `symbol`, `function` এবং `object`। মনে রাখবেন যে `typeof null` কিন্তু `"object"` রিটার্ন করে।
 
 </p>
 </details>
 
 ---
 
-###### 35. Which of these values are falsy?
+###### 35. কোন ভ্যালুগুলো মিথ্যা হয়?
 
 ```javascript
 0;
 new Number(0);
-("");
-(" ");
+('');
+(' ');
 new Boolean(false);
 undefined;
 ```
@@ -1093,7 +1097,7 @@ undefined;
 
 #### উত্তর: A
 
-There are 8 falsy values:
+মোট ৮ রকমের মিথ্যা ভ্যালু হয়ঃ
 
 - `undefined`
 - `null`
@@ -1104,7 +1108,7 @@ There are 8 falsy values:
 - `-0`
 - `0n` (BigInt(0))
 
-Function constructors, like `new Number` and `new Boolean` are truthy.
+ফাংশন কন্সট্রাক্টরগুলো, যেমন `new Number` ও `new Boolean` সবসময় সত্য হয়। জাভাস্ক্রিপ্টে ফাংশনগুলো হয় অবজেক্ট এবং এরা রেফারেন্স টাইপ। রেফারেন্স টাইপ কখনো মিথ্যা হয় না।
 
 </p>
 </details>
@@ -1127,8 +1131,8 @@ console.log(typeof typeof 1);
 
 #### উত্তর: B
 
-`typeof 1` returns `"number"`.
-`typeof "number"` returns `"string"`
+`typeof 1` রিটার্ন করে `"number"`.
+আর `typeof "number"` রিটার্ন করে `"string"`
 
 </p>
 </details>
@@ -1153,11 +1157,11 @@ console.log(numbers);
 
 #### উত্তর: C
 
-When you set a value to an element in an array that exceeds the length of the array, JavaScript creates something called "empty slots". These actually have the value of `undefined`, but you will see something like:
+আপনি যখন অ্যারের এমন কোন ইনডেক্সে একটি ভ্যালু সেট করেন যেটা অ্যারের দৈর্ঘ্যকে অতিক্রম করে ফেলে, জাভাস্ক্রিপ্ট তখন "empty slots" নামে কিছু তিরি করে। এটার ভ্যালু আসলে `undefined` কিন্তু আপনি দেখতে পাবেন এমন কিছুঃ
 
 `[1, 2, 3, empty x 7, 11]`
 
-depending on where you run it (it's different for every browser, node, etc.)
+জাভাস্ক্রিপ্ট কোথায় চলছে তার উপর ভিত্তি করে (এটা প্রতিটি ব্রউজার, নোড ইত্যাদির জন্য আলাদা)
 
 </p>
 </details>
@@ -1190,18 +1194,18 @@ depending on where you run it (it's different for every browser, node, etc.)
 
 #### উত্তর: A
 
-The `catch` block receives the argument `x`. This is not the same `x` as the variable when we pass arguments. This variable `x` is block-scoped.
+`catch` ব্লকটি একটি আর্গুমেন্ট `x` রিসিভ করেছে। আমরা যখন আর্গুমেটস পাস করছি এটা আর `x` ভ্যারিয়েবল একই নয়। এই `x` ভ্যারিয়েবলটি হল ব্লক-স্কোপড।
 
-Later, we set this block-scoped variable equal to `1`, and set the value of the variable `y`. Now, we log the block-scoped variable `x`, which is equal to `1`.
+পরবর্তীতে, আমরা ব্লক-স্কোপড ভ্যারিয়েবলটির ভ্যালু সেট করছি `1` এবং `y` ভ্যারিয়েবলটির ভ্যালু সেট করছি `2`। এখন, আমরা লগ করছি ব্লক-স্কোপড `x` ভ্যারিয়েবলটি, যেটা সমান হল `1`।
 
-Outside of the `catch` block, `x` is still `undefined`, and `y` is `2`. When we want to `console.log(x)` outside of the `catch` block, it returns `undefined`, and `y` returns `2`.
+ক্যাচ-ব্লকের বাইরে `x` ভ্যারিয়েবলটি এখনো `undefined` এবং `y` হল `2`। যখন ক্যাচ-ব্লকের বাইরে `console.log(x)` করতে চাচ্ছি, এটা রিটার্ন করে `undefined`, এবং `y` রিটার্ন করে `2`।
 
 </p>
 </details>
 
 ---
 
-###### 39. Everything in JavaScript is either a...
+###### 39. জাভাস্ক্রিপ্টে সবকিছুই হয় একটি ...... ।
 
 - A: primitive or object
 - B: function or object
@@ -1213,11 +1217,11 @@ Outside of the `catch` block, `x` is still `undefined`, and `y` is `2`. When we
 
 #### উত্তর: A
 
-JavaScript only has primitive types and objects.
+জাভাস্ক্রিপ্টে আছে কেবল প্রিমিটিভ (মৌলিক) টাইপ ও অবজেক্ট।
 
-Primitive types are `boolean`, `null`, `undefined`, `bigint`, `number`, `string`, and `symbol`.
+প্রিমিটিভ (মৌলিক) টাইপগুলো হল - `boolean`, `null`, `undefined`, `bigint`, `number`, `string`, ও `symbol`।
 
-What differentiates a primitive from an object is that primitives do not have any properties or methods; however, you'll note that `'foo'.toUpperCase()` evaluates to `'FOO'` and does not result in a `TypeError`. This is because when you try to access a property or method on a primitive like a string, JavaScript will implicitly wrap the primitive type using one of the wrapper classes, i.e. `String`, and then immediately discard the wrapper after the expression evaluates. All primitives except for `null` and `undefined` exhibit this behavior.
+প্রিমিটিভ টাইপের কোন প্রোপার্টিস/মেথড নেই এটাই একটি প্রিমিটিভ টাইপকে অবজেক্ট থেকে আলাদা করেছে; অন্যদিকে আপনি খেয়াল করবেন যে `'foo'.toUpperCase()` গননা করছে `'FOO'` এবং কোন `TypeError`ও দেয় না। এটার কারন হল, আপনি যখন কোন প্রিমিটিভ টাইপ যেমন স্ট্রিং দিয়ে কোন প্রোপার্টিস/মেথড কে ব্যবহার করতে চাচ্ছেন, জাভাস্ক্রিপ্ট তখন প্রিমিটিভ টাইপকে র‍্যাপার ক্লাসগুলোর একটি যেমন, `String` দিয়ে মুড়ে দেয়, এবং মান গননা হয়ে যাওয়ার সাথে সাথেই সেটি বাতিল হয়ে যায়। `null` ও `undefined` বাদে সকল প্রিমিটিভই একই ব্যবহার প্রদর্শন করে।
 
 </p>
 </details>
@@ -1248,9 +1252,9 @@ What differentiates a primitive from an object is that primitives do not have an
 
 #### উত্তর: C
 
-`[1, 2]` is our initial value. This is the value we start with, and the value of the very first `acc`. During the first round, `acc` is `[1,2]`, and `cur` is `[0, 1]`. We concatenate them, which results in `[1, 2, 0, 1]`.
+এখানে `[1, 2]` আমাদের প্রথমিক ভ্যালু। এই ভ্যালুটি দিয়েই আমরা শুরু করব এবং এটাই `acc` এর ১ম ভ্যালু। ১ম রাউন্ডের সময়, `acc` হয় `[1,2]`, এবং `cur` হয় `[0, 1]`। আমরা তাদেরকে যুক্ত করছি, যেটার ফলাফল হল `[1, 2, 0, 1]`।
 
-Then, `[1, 2, 0, 1]` is `acc` and `[2, 3]` is `cur`. We concatenate them, and get `[1, 2, 0, 1, 2, 3]`
+পরবর্তীতে ২য়/শেষ ধাপে, `acc` হয় `[1, 2, 0, 1]` এবং `cur` হয় `[2, 3]`, আমরা তাদেরকে যুক্ত করে ফলাফল পাচ্ছি `[1, 2, 0, 1, 2, 3]`।
 
 </p>
 </details>
@@ -1261,7 +1265,7 @@ Then, `[1, 2, 0, 1]` is `acc` and `[2, 3]` is `cur`. We concatenate them, and ge
 
 ```javascript
 !!null;
-!!"";
+!!'';
 !!1;
 ```
 
@@ -1275,21 +1279,23 @@ Then, `[1, 2, 0, 1]` is `acc` and `[2, 3]` is `cur`. We concatenate them, and ge
 
 #### উত্তর: B
 
-`null` is falsy. `!null` returns `true`. `!true` returns `false`.
+`null` হল মিথ্যা। `!null` রিটার্ন করে `true`। `!true` রিটার্ন করে `false`.
+
+`""` হল মিথ্যা। `!""` রিটার্ন করে `true`। `!true` রিটার্ন করে `false`।
 
-`""` is falsy. `!""` returns `true`. `!true` returns `false`.
+`1` হল সত্য। `!1` রিটার্ন করে `false`। `!false` রিটার্ন করে `true`।
 
-`1` is truthy. `!1` returns `false`. `!false` returns `true`.
+তাই সঠিক হল - `false` `false` `true`।
 
 </p>
 </details>
 
 ---
 
-###### 42. What does the `setInterval` method return in the browser?
+###### 42. এই `setInterval` মেথডটি ব্রাউজারে কি রিটার্ন করে?
 
 ```javascript
-setInterval(() => console.log("Hi"), 1000);
+setInterval(() => console.log('Hi'), 1000);
 ```
 
 - A: a unique id
@@ -1302,17 +1308,17 @@ setInterval(() => console.log("Hi"), 1000);
 
 #### উত্তর: A
 
-It returns a unique id. This id can be used to clear that interval with the `clearInterval()` function.
+যদিও এটি বাউজারে ১ সেকেন্ড পর পর `'Hi'` লগ করেই যাবে কিন্তু `setInterval` মেথডটি একটি অনন্য আইডি (unique id) রিটার্ন করে। এই পুর্যায়ক্রমিক কাজকে `clearInterval()` দিয়ে মুছে ফেলতে ঐ আইডি ব্যবহার করা হয়।
 
 </p>
 </details>
 
 ---
 
-###### 43. What does this return?
+###### 43. এটা কি রিটার্ন করে?
 
 ```javascript
-[..."Lydia"];
+[...'Lydia'];
 ```
 
 - A: `["L", "y", "d", "i", "a"]`
@@ -1325,7 +1331,7 @@ It returns a unique id. This id can be used to clear that interval with the `cle
 
 #### উত্তর: A
 
-A string is an iterable. The spread operator maps every character of an iterable to one element.
+স্ট্রিং একটি পুনরাবৃত্তিযোগ্য টাইপ। স্প্রেড অপারেটর পুনরাবৃত্তিযোগ্য প্রতিটি অক্ষরকে ম্যাপ করে একটি এলিমেন্টে নিয়ে আসে। তাই ফলাফল হয় `["L", "y", "d", "i", "a"]`।
 
 </p>
 </details>
@@ -1356,11 +1362,11 @@ console.log(gen.next().value);
 
 #### উত্তর: C
 
-Regular functions cannot be stopped mid-way after invocation. However, a generator function can be "stopped" midway, and later continue from where it stopped. Every time a generator function encounters a `yield` keyword, the function yields the value specified after it. Note that the generator function in that case doesn’t _return_ the value, it _yields_ the value.
+সাধারন ফাংশনকে কল করার পর মাঝপথে থামিয়ে দেয়া যায় না। অন্যদিকে, জেনারেটর ফাংশনকে মাঝপথে থামিয়ে দেয়া যায়, এবং যেখানে থামানো হয়েছিলো সেখান থেকেই পুনরায় শুরু করা যায়। জেনারেটর ফাংশন প্রতিবার একটি `yield` কীওয়ার্ডের মুখোমুখি হয়, তখন ফাংশনটি তার পরের নির্দিষ্ট করা ভ্যালুটি প্রদান করে। মনে রাখবেন যে সেই ক্ষেত্রে জেনারেটর ফাংশন মানটি _রিটার্ন_ করে না, এটি মানটিকে _ইল্ড_ করে (ফলাফল প্রদান)।
 
-First, we initialize the generator function with `i` equal to `10`. We invoke the generator function using the `next()` method. The first time we invoke the generator function, `i` is equal to `10`. It encounters the first `yield` keyword: it yields the value of `i`. The generator is now "paused", and `10` gets logged.
+প্রথমে, আমরা জেনারেটর ফাংশনটি শুরু করি `i` এর সমান `10` দিয়ে। আমরা `next()` মেথডটি ব্যবহার করে জেনারেটর ফাংশন চালু করি। প্রথমবার যখন আমরা জেনারেটর ফাংশন চালু করি, `i` সমান `10`। এটি প্রথম `yield` কীওয়ার্ডের মুখোমুখি হয়: এটি `i` এর মান প্রদান করে। জেনারেটরটি এখন "paused" করা হয়েছে এবং `10` লগ হয়ে গেছে।
 
-Then, we invoke the function again with the `next()` method. It starts to continue where it stopped previously, still with `i` equal to `10`. Now, it encounters the next `yield` keyword, and yields `i * 2`. `i` is equal to `10`, so it returns `10 * 2`, which is `20`. This results in `10, 20`.
+তারপর, আমরা আবার `next()` মেথডটি ব্যবহার করে ফাংশনটি চালু করি। এখনও `i` এর সমান `10` নিয়ে এটি পূর্বে যেখানে থামে সেখান থেকেই চালিয়ে যেতে শুরু করে। এখন, এটি পরবর্তী `yield` কীওয়ার্ডের মুখোমুখি হয় এবং `i * 2` পায়। `i` হল `10` এর সমান, তাই এটি `10 * 2`, যা প্রদান করে `20`। এর ফলে `10, 20` পাচ্ছি।
 
 </p>
 </details>
@@ -1371,11 +1377,11 @@ Then, we invoke the function again with the `next()` method. It starts to contin
 
 ```javascript
 const firstPromise = new Promise((res, rej) => {
-  setTimeout(res, 500, "one");
+  setTimeout(res, 500, 'one');
 });
 
 const secondPromise = new Promise((res, rej) => {
-  setTimeout(res, 100, "two");
+  setTimeout(res, 100, 'two');
 });
 
 Promise.race([firstPromise, secondPromise]).then((res) => console.log(res));
@@ -1401,7 +1407,7 @@ When we pass multiple promises to the `Promise.race` method, it resolves/rejects
 ###### 46. এটার আউটপুট কোনটা?
 
 ```javascript
-let person = { name: "Lydia" };
+let person = { name: 'Lydia' };
 const members = [person];
 person = null;
 
@@ -1441,7 +1447,7 @@ We are only modifying the value of the `person` variable, and not the first elem
 
 ```javascript
 const person = {
-  name: "Lydia",
+  name: 'Lydia',
   age: 21,
 };
 
@@ -1470,7 +1476,7 @@ With a `for-in` loop, we can iterate through object keys, in this case `name` an
 ###### 48. এটার আউটপুট কোনটা?
 
 ```javascript
-console.log(3 + 4 + "5");
+console.log(3 + 4 + '5');
 ```
 
 - A: `"345"`
@@ -1497,7 +1503,7 @@ Operator associativity is the order in which the compiler evaluates the expressi
 ###### 49. What's the value of `num`?
 
 ```javascript
-const num = parseInt("7*6", 10);
+const num = parseInt('7*6', 10);
 ```
 
 - A: `42`
@@ -1523,7 +1529,7 @@ Only the first number in the string is returned. Based on the _radix_ (the secon
 
 ```javascript
 [1, 2, 3].map((num) => {
-  if (typeof num === "number") return;
+  if (typeof num === 'number') return;
   return num * 2;
 });
 ```
@@ -1551,12 +1557,12 @@ However, we don’t return a value. When we don’t return a value from the func
 
 ```javascript
 function getInfo(member, year) {
-  member.name = "Lydia";
-  year = "1998";
+  member.name = 'Lydia';
+  year = '1998';
 }
 
-const person = { name: "Sarah" };
-const birthYear = "1997";
+const person = { name: 'Sarah' };
+const birthYear = '1997';
 
 getInfo(person, birthYear);
 
@@ -1588,15 +1594,15 @@ The value of `person` is an object. The argument `member` has a (copied) referen
 
 ```javascript
 function greeting() {
-  throw "Hello world!";
+  throw 'Hello world!';
 }
 
 function sayHi() {
   try {
     const data = greeting();
-    console.log("It worked!", data);
+    console.log('It worked!', data);
   } catch (e) {
-    console.log("Oh no an error:", e);
+    console.log('Oh no an error:', e);
   }
 }
 
@@ -1626,8 +1632,8 @@ With the `catch` statement, we can specify what to do if an exception is thrown
 
 ```javascript
 function Car() {
-  this.make = "Lamborghini";
-  return { make: "Maserati" };
+  this.make = 'Lamborghini';
+  return { make: 'Maserati' };
 }
 
 const myCar = new Car();
@@ -1705,7 +1711,7 @@ Dog.prototype.bark = function () {
   console.log(`Woof I am ${this.name}`);
 };
 
-const pet = new Dog("Mara");
+const pet = new Dog('Mara');
 
 pet.bark();
 
@@ -1770,7 +1776,7 @@ export default counter;
 
 ```javascript
 // index.js
-import myCounter from "./counter";
+import myCounter from './counter';
 
 myCounter += 1;
 
@@ -1799,7 +1805,7 @@ When we try to increment the value of `myCounter`, it throws an error: `myCounte
 ###### 58. এটার আউটপুট কোনটা?
 
 ```javascript
-const name = "Lydia";
+const name = 'Lydia';
 age = 21;
 
 console.log(delete name);
@@ -1870,7 +1876,7 @@ This means that the value of `y` is equal to the first value in the array, which
 ###### 60. এটার আউটপুট কোনটা?
 
 ```javascript
-const user = { name: "Lydia", age: 21 };
+const user = { name: 'Lydia', age: 21 };
 const admin = { admin: true, ...user };
 
 console.log(admin);
@@ -1896,9 +1902,9 @@ It's possible to combine objects using the spread operator `...`. It lets you cr
 ###### 61. এটার আউটপুট কোনটা?
 
 ```javascript
-const person = { name: "Lydia" };
+const person = { name: 'Lydia' };
 
-Object.defineProperty(person, "age", { value: 21 });
+Object.defineProperty(person, 'age', { value: 21 });
 
 console.log(person);
 console.log(Object.keys(person));
@@ -1927,12 +1933,12 @@ Properties added using the `defineProperty` method are immutable by default. You
 
 ```javascript
 const settings = {
-  username: "lydiahallie",
+  username: 'lydiahallie',
   level: 19,
   health: 90,
 };
 
-const data = JSON.stringify(settings, ["level", "health"]);
+const data = JSON.stringify(settings, ['level', 'health']);
 console.log(data);
 ```
 
@@ -2120,12 +2126,12 @@ The `Labrador` class receives two arguments, `name` since it extends `Dog`, and
 
 ```javascript
 // index.js
-console.log("running index.js");
-import { sum } from "./sum.js";
+console.log('running index.js');
+import { sum } from './sum.js';
 console.log(sum(1, 2));
 
 // sum.js
-console.log("running sum.js");
+console.log('running sum.js');
 export const sum = (a, b) => a + b;
 ```
 
@@ -2153,7 +2159,7 @@ This is a difference between `require()` in CommonJS and `import`! With `require
 ```javascript
 console.log(Number(2) === Number(2));
 console.log(Boolean(false) === Boolean(false));
-console.log(Symbol("foo") === Symbol("foo"));
+console.log(Symbol('foo') === Symbol('foo'));
 ```
 
 - A: `true`, `true`, `false`
@@ -2176,7 +2182,7 @@ Every Symbol is entirely unique. The purpose of the argument passed to the Symbo
 ###### 69. এটার আউটপুট কোনটা?
 
 ```javascript
-const name = "Lydia Hallie";
+const name = 'Lydia Hallie';
 console.log(name.padStart(13));
 console.log(name.padStart(2));
 ```
@@ -2203,7 +2209,7 @@ If the argument passed to the `padStart` method is smaller than the length of th
 ###### 70. এটার আউটপুট কোনটা?
 
 ```javascript
-console.log("🥑" + "💻");
+console.log('🥑' + '💻');
 ```
 
 - A: `"🥑💻"`
@@ -2227,11 +2233,11 @@ With the `+` operator, you can concatenate strings. In this case, we are concate
 
 ```javascript
 function* startGame() {
-  const উত্তর = yield "Do you love JavaScript?";
-  if (উত্তর !== "Yes") {
+  const উত্তর = yield 'Do you love JavaScript?';
+  if (উত্তর !== 'Yes') {
     return "Oh wow... Guess we're done here";
   }
-  return "JavaScript loves you back ❤️";
+  return 'JavaScript loves you back ❤️';
 }
 
 const game = startGame();
@@ -2299,7 +2305,7 @@ In this case, the string is `Hello\nworld`, which gets logged.
 
 ```javascript
 async function getData() {
-  return await Promise.resolve("I made it!");
+  return await Promise.resolve('I made it!');
 }
 
 const data = getData();
@@ -2336,7 +2342,7 @@ function addToList(item, list) {
   return list.push(item);
 }
 
-const result = addToList("apple", ["banana"]);
+const result = addToList('apple', ['banana']);
 console.log(result);
 ```
 
@@ -2396,7 +2402,7 @@ Since `shape` is frozen, and since the value of `x` is not an object, we cannot
 ###### 76. এটার আউটপুট কোনটা?
 
 ```javascript
-const { firstName: myName } = { firstName: "Lydia" };
+const { firstName: myName } = { firstName: 'Lydia' };
 
 console.log(firstName);
 ```
@@ -2414,7 +2420,7 @@ console.log(firstName);
 By using [destructuring assignment](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment) syntax we can unpack values from arrays, or properties from objects, into distinct variables:
 
 ```javascript
-const { firstName } = { firstName: "Lydia" };
+const { firstName } = { firstName: 'Lydia' };
 // ES5 version:
 // var firstName = { firstName: 'Lydia' }.firstName;
 
@@ -2424,7 +2430,7 @@ console.log(firstName); // "Lydia"
 Also, a property can be unpacked from an object and assigned to a variable with a different name than the object property:
 
 ```javascript
-const { firstName: myName } = { firstName: "Lydia" };
+const { firstName: myName } = { firstName: 'Lydia' };
 // ES5 version:
 // var myName = { firstName: 'Lydia' }.firstName;
 
@@ -2437,7 +2443,7 @@ Therefore, `firstName` does not exist as a variable, thus attempting to access i
 **Note:** Be aware of the `global scope` properties:
 
 ```javascript
-const { name: myName } = { name: "Lydia" };
+const { name: myName } = { name: 'Lydia' };
 
 console.log(myName); // "lydia"
 console.log(name); // "" ----- Browser e.g. Chrome
@@ -2530,7 +2536,7 @@ The third time, we pass `5 * 2` to the function which gets evaluated to `10`. Th
 ###### 79. What is the output?
 
 ```javascript
-const myLifeSummedUp = ["☕", "💻", "🍷", "🍫"];
+const myLifeSummedUp = ['☕', '💻', '🍷', '🍫'];
 
 for (let item in myLifeSummedUp) {
   console.log(item);
@@ -2626,13 +2632,13 @@ In this case, if we didn't pass a value or if we passed `undefined`, `name` woul
 ###### 82. What is the output?
 
 ```javascript
-var status = "😎";
+var status = '😎';
 
 setTimeout(() => {
-  const status = "😍";
+  const status = '😍';
 
   const data = {
-    status: "🥑",
+    status: '🥑',
     getStatus() {
       return this.status;
     },
@@ -2666,12 +2672,12 @@ With the `call` method, we can change the object to which the `this` keyword ref
 
 ```javascript
 const person = {
-  name: "Lydia",
+  name: 'Lydia',
   age: 21,
 };
 
 let city = person.city;
-city = "Amsterdam";
+city = 'Amsterdam';
 
 console.log(person);
 ```
@@ -2735,7 +2741,7 @@ Variables with the `const` and `let` keywords are _block-scoped_. A block is any
 ###### 85. What kind of information would get logged?
 
 ```javascript
-fetch("https://www.website.com/api/user/1")
+fetch('https://www.website.com/api/user/1')
   .then((res) => res.json())
   .then((res) => console.log(res));
 ```
@@ -2791,7 +2797,7 @@ By setting `hasName` equal to `name`, you set `hasName` equal to whatever value
 ###### 87. এটার আউটপুট কোনটা?
 
 ```javascript
-console.log("I want pizza"[0]);
+console.log('I want pizza'[0]);
 ```
 
 - A: `"""`
@@ -2846,11 +2852,11 @@ If you're trying to set a default parameter's value equal to a parameter that is
 
 ```javascript
 // module.js
-export default () => "Hello world";
-export const name = "Lydia";
+export default () => 'Hello world';
+export const name = 'Lydia';
 
 // index.js
-import * as data from "./module";
+import * as data from './module';
 
 console.log(data);
 ```
@@ -2883,7 +2889,7 @@ class Person {
   }
 }
 
-const member = new Person("John");
+const member = new Person('John');
 console.log(typeof member);
 ```
 
@@ -2943,7 +2949,7 @@ Then, we try to use the `.push` method on `newList`. Since `newList` is the nume
 
 ```javascript
 function giveLydiaPizza() {
-  return "Here is pizza!";
+  return 'Here is pizza!';
 }
 
 const giveLydiaChocolate = () =>
@@ -2974,7 +2980,7 @@ Regular functions, such as the `giveLydiaPizza` function, have a `prototype` pro
 
 ```javascript
 const person = {
-  name: "Lydia",
+  name: 'Lydia',
   age: 21,
 };
 
@@ -3034,7 +3040,7 @@ function getItems(fruitList, favoriteFruit, ...args) {
   return [...fruitList, ...args, favoriteFruit];
 }
 
-getItems(["banana", "apple"], "pear", "orange");
+getItems(['banana', 'apple'], 'pear', 'orange');
 ```
 
 The above example works. This returns the array `[ 'banana', 'apple', 'orange', 'pear' ]`
@@ -3048,8 +3054,8 @@ The above example works. This returns the array `[ 'banana', 'apple', 'orange',
 
 ```javascript
 function nums(a, b) {
-  if (a > b) console.log("a is bigger");
-  else console.log("b is bigger");
+  if (a > b) console.log('a is bigger');
+  else console.log('b is bigger');
   return;
   a + b;
 }
@@ -3089,13 +3095,13 @@ This means that `a + b` is never reached, since a function stops running after t
 ```javascript
 class Person {
   constructor() {
-    this.name = "Lydia";
+    this.name = 'Lydia';
   }
 }
 
 Person = class AnotherPerson {
   constructor() {
-    this.name = "Sarah";
+    this.name = 'Sarah';
   }
 };
 
@@ -3124,7 +3130,7 @@ We can set classes equal to other classes/function constructors. In this case, w
 
 ```javascript
 const info = {
-  [Symbol("a")]: "b",
+  [Symbol('a')]: 'b',
 };
 
 console.log(info);
@@ -3193,7 +3199,7 @@ The following function would have returned an object:
 ###### 99. এটার আউটপুট কোনটা?
 
 ```javascript
-const name = "Lydia";
+const name = 'Lydia';
 
 console.log(name());
 ```
@@ -3225,8 +3231,8 @@ ReferenceErrors get thrown when JavaScript isn't able to find a reference to a v
 ```javascript
 // 🎉✨ This is my 100th question! ✨🎉
 
-const output = `${[] && "Im"}possible!
-You should${"" && `n't`} see a therapist after so much JavaScript lol`;
+const output = `${[] && 'Im'}possible!
+You should${'' && `n't`} see a therapist after so much JavaScript lol`;
 ```
 
 - A: `possible! You should see a therapist after so much JavaScript lol`
@@ -3252,7 +3258,7 @@ You should${"" && `n't`} see a therapist after so much JavaScript lol`;
 
 ```javascript
 const one = false || {} || null;
-const two = null || false || "";
+const two = null || false || '';
 const three = [] || 0 || true;
 
 console.log(one, two, three);
@@ -3284,16 +3290,16 @@ With the `||` operator, we can return the first truthy operand. If all values ar
 ###### 102. What's the value of output?
 
 ```javascript
-const myPromise = () => Promise.resolve("I have resolved!");
+const myPromise = () => Promise.resolve('I have resolved!');
 
 function firstFunction() {
   myPromise().then((res) => console.log(res));
-  console.log("second");
+  console.log('second');
 }
 
 async function secondFunction() {
   console.log(await myPromise());
-  console.log("second");
+  console.log('second');
 }
 
 firstFunction();
@@ -3331,8 +3337,8 @@ This means that it waited for the `myPromise` to resolve with the value `I have
 const set = new Set();
 
 set.add(1);
-set.add("Lydia");
-set.add({ name: "Lydia" });
+set.add('Lydia');
+set.add({ name: 'Lydia' });
 
 for (let item of set) {
   console.log(item + 2);
@@ -3392,13 +3398,13 @@ In this case, we just passed the numerical value `5`. It returns a resolved prom
 ```javascript
 function compareMembers(person1, person2 = person) {
   if (person1 !== person2) {
-    console.log("Not the same!");
+    console.log('Not the same!');
   } else {
-    console.log("They are the same!");
+    console.log('They are the same!');
   }
 }
 
-const person = { name: "Lydia" };
+const person = { name: 'Lydia' };
 
 compareMembers(person);
 ```
@@ -3437,7 +3443,7 @@ const colorConfig = {
   yellow: false,
 };
 
-const colors = ["pink", "red", "blue"];
+const colors = ['pink', 'red', 'blue'];
 
 console.log(colorConfig.colors[1]);
 ```
@@ -3466,7 +3472,7 @@ JavaScript interprets (or unboxes) statements. When we use bracket notation, it
 ###### 107. What's its value?
 
 ```javascript
-console.log("❤️" === "❤️");
+console.log('❤️' === '❤️');
 ```
 
 - A: `true`
@@ -3487,14 +3493,14 @@ Under the hood, emojis are unicodes. The unicodes for the heart emoji is `"U+276
 ###### 108. Which of these methods modifies the original array?
 
 ```javascript
-const emojis = ["✨", "🥑", "😍"];
+const emojis = ['✨', '🥑', '😍'];
 
-emojis.map((x) => x + "✨");
-emojis.filter((x) => x !== "🥑");
-emojis.find((x) => x !== "🥑");
-emojis.reduce((acc, cur) => acc + "✨");
-emojis.slice(1, 2, "✨");
-emojis.splice(1, 2, "✨");
+emojis.map((x) => x + '✨');
+emojis.filter((x) => x !== '🥑');
+emojis.find((x) => x !== '🥑');
+emojis.reduce((acc, cur) => acc + '✨');
+emojis.slice(1, 2, '✨');
+emojis.splice(1, 2, '✨');
 ```
 
 - A: `All of them`
@@ -3519,10 +3525,10 @@ With `splice` method, we modify the original array by deleting, replacing or add
 ###### 109. এটার আউটপুট কোনটা?
 
 ```javascript
-const food = ["🍕", "🍫", "🥑", "🍔"];
+const food = ['🍕', '🍫', '🥑', '🍔'];
 const info = { favoriteFood: food[0] };
 
-info.favoriteFood = "🍝";
+info.favoriteFood = '🍝';
 
 console.log(food);
 ```
@@ -3576,7 +3582,7 @@ const jsonArray = JSON.stringify([1, 2, 3]); // '[1, 2, 3]'
 JSON.parse(jsonArray); // [1, 2, 3]
 
 // Stringifying an object  into valid JSON, then parsing the JSON string to a JavaScript value:
-const jsonArray = JSON.stringify({ name: "Lydia" }); // '{"name":"Lydia"}'
+const jsonArray = JSON.stringify({ name: 'Lydia' }); // '{"name":"Lydia"}'
 JSON.parse(jsonArray); // { name: 'Lydia' }
 ```
 
@@ -3588,11 +3594,11 @@ JSON.parse(jsonArray); // { name: 'Lydia' }
 ###### 111. এটার আউটপুট কোনটা?
 
 ```javascript
-let name = "Lydia";
+let name = 'Lydia';
 
 function getName() {
   console.log(name);
-  let name = "Sarah";
+  let name = 'Sarah';
 }
 
 getName();
@@ -3615,7 +3621,7 @@ Variables with the `let` keyword (and `const`) are hoisted, but unlike `var`, do
 If we wouldn't have declared the `name` variable within the `getName` function, the javascript engine would've looked down the _scope chain_. The outer scope has a variable called `name` with the value of `Lydia`. In that case, it would've logged `Lydia`.
 
 ```javascript
-let name = "Lydia";
+let name = 'Lydia';
 
 function getName() {
   console.log(name);
@@ -3633,11 +3639,11 @@ getName(); // Lydia
 
 ```javascript
 function* generatorOne() {
-  yield ["a", "b", "c"];
+  yield ['a', 'b', 'c'];
 }
 
 function* generatorTwo() {
-  yield* ["a", "b", "c"];
+  yield* ['a', 'b', 'c'];
 }
 
 const one = generatorOne();
@@ -3683,7 +3689,7 @@ console.log(two.next().value); // undefined
 ###### 113. এটার আউটপুট কোনটা?
 
 ```javascript
-console.log(`${((x) => x)("I love")} to program`);
+console.log(`${((x) => x)('I love')} to program`);
 ```
 
 - A: `I love to program`
@@ -3708,7 +3714,7 @@ Expressions within template literals are evaluated first. This means that the st
 ```javascript
 let config = {
   alert: setInterval(() => {
-    console.log("Alert!");
+    console.log('Alert!');
   }, 1000),
 };
 
@@ -3740,16 +3746,16 @@ Since it was not cleared, the `setInterval` callback function will still get inv
 
 ```javascript
 const myMap = new Map();
-const myFunc = () => "greeting";
+const myFunc = () => 'greeting';
 
-myMap.set(myFunc, "Hello world!");
+myMap.set(myFunc, 'Hello world!');
 
 //1
-myMap.get("greeting");
+myMap.get('greeting');
 //2
 myMap.get(myFunc);
 //3
-myMap.get(() => "greeting");
+myMap.get(() => 'greeting');
 ```
 
 - A: 1
@@ -3776,14 +3782,14 @@ When adding a key/value pair using the `set` method, the key will be the value o
 
 ```javascript
 const person = {
-  name: "Lydia",
+  name: 'Lydia',
   age: 21,
 };
 
 const changeAge = (x = { ...person }) => (x.age += 1);
 const changeAgeAndName = (x = { ...person }) => {
   x.age += 1;
-  x.name = "Sarah";
+  x.name = 'Sarah';
 };
 
 changeAge(person);
@@ -3842,7 +3848,7 @@ With the spread operator `...`, we can _spread_ iterables to individual elements
 
 ```javascript
 let num = 1;
-const list = ["🥳", "🤠", "🥰", "🤪"];
+const list = ['🥳', '🤠', '🥰', '🤪'];
 
 console.log(list[(num += 1)]);
 ```
@@ -3868,11 +3874,11 @@ With the `+=` operator, we're incrementing the value of `num` by `1`. `num` had
 
 ```javascript
 const person = {
-  firstName: "Lydia",
-  lastName: "Hallie",
+  firstName: 'Lydia',
+  lastName: 'Hallie',
   pet: {
-    name: "Mara",
-    breed: "Dutch Tulip Hound",
+    name: 'Mara',
+    breed: 'Dutch Tulip Hound',
   },
   getFullName() {
     return `${this.firstName} ${this.lastName}`;
@@ -3910,10 +3916,10 @@ With the optional chaining operator `?.`, we no longer have to explicitly check
 ###### 120. এটার আউটপুট কোনটা?
 
 ```javascript
-const groceries = ["banana", "apple", "peanuts"];
+const groceries = ['banana', 'apple', 'peanuts'];
 
-if (groceries.indexOf("banana")) {
-  console.log("We have to buy bananas!");
+if (groceries.indexOf('banana')) {
+  console.log('We have to buy bananas!');
 } else {
   console.log(`We don't have to buy bananas!`);
 }
@@ -3969,10 +3975,10 @@ The `language` method is a `setter`. Setters don't hold an actual value, their p
 ###### 122. এটার আউটপুট কোনটা?
 
 ```javascript
-const name = "Lydia Hallie";
+const name = 'Lydia Hallie';
 
-console.log(!typeof name === "object");
-console.log(!typeof name === "string");
+console.log(!typeof name === 'object');
+console.log(!typeof name === 'string');
 ```
 
 - A: `false` `true`
@@ -4087,14 +4093,14 @@ myFunc(1, 2, 3);
 
 ```javascript
 function getFine(speed, amount) {
-  const formattedSpeed = new Intl.NumberFormat("en-US", {
-    style: "unit",
-    unit: "mile-per-hour",
+  const formattedSpeed = new Intl.NumberFormat('en-US', {
+    style: 'unit',
+    unit: 'mile-per-hour',
   }).format(speed);
 
-  const formattedAmount = new Intl.NumberFormat("en-US", {
-    style: "currency",
-    currency: "USD",
+  const formattedAmount = new Intl.NumberFormat('en-US', {
+    style: 'currency',
+    currency: 'USD',
   }).format(amount);
 
   return `The driver drove ${formattedSpeed} and has to pay ${formattedAmount}`;
@@ -4123,8 +4129,8 @@ With the `Intl.NumberFormat` method, we can format numeric values to any locale.
 ###### 127. এটার আউটপুট কোনটা?
 
 ```javascript
-const spookyItems = ["👻", "🎃", "🕸"];
-({ item: spookyItems[3] } = { item: "💀" });
+const spookyItems = ['👻', '🎃', '🕸'];
+({ item: spookyItems[3] } = { item: '💀' });
 
 console.log(spookyItems);
 ```
@@ -4149,7 +4155,7 @@ By destructuring objects, we can unpack values from the right-hand object, and a
 ###### 128. এটার আউটপুট কোনটা?
 
 ```javascript
-const name = "Lydia Hallie";
+const name = 'Lydia Hallie';
 const age = 21;
 
 console.log(Number.isNaN(name));
@@ -4185,7 +4191,7 @@ const randomValue = 21;
 
 function getInfo() {
   console.log(typeof randomValue);
-  const randomValue = "Lydia Hallie";
+  const randomValue = 'Lydia Hallie';
 }
 
 getInfo();
@@ -4211,7 +4217,7 @@ Variables declared with the `const` keyword are not referenceable before their i
 ###### 130. এটার আউটপুট কোনটা?
 
 ```javascript
-const myPromise = Promise.resolve("Woah some cool data");
+const myPromise = Promise.resolve('Woah some cool data');
 
 (async () => {
   try {
@@ -4219,7 +4225,7 @@ const myPromise = Promise.resolve("Woah some cool data");
   } catch {
     throw new Error(`Oops didn't work`);
   } finally {
-    console.log("Oh finally!");
+    console.log('Oh finally!');
   }
 })();
 ```
@@ -4244,7 +4250,7 @@ In the `try` block, we're logging the awaited value of the `myPromise` variable:
 ###### 131. এটার আউটপুট কোনটা?
 
 ```javascript
-const emojis = ["🥑", ["✨", "✨", ["🍕", "🍕"]]];
+const emojis = ['🥑', ['✨', '✨', ['🍕', '🍕']]];
 
 console.log(emojis.flat(1));
 ```
@@ -4317,19 +4323,19 @@ We invoke `counterTwo.increment()`, which sets `count` to `3`. Then, we log the
 ###### 133. এটার আউটপুট কোনটা?
 
 ```javascript
-const myPromise = Promise.resolve(Promise.resolve("Promise"));
+const myPromise = Promise.resolve(Promise.resolve('Promise'));
 
 function funcOne() {
-  setTimeout(() => console.log("Timeout 1!"), 0);
+  setTimeout(() => console.log('Timeout 1!'), 0);
   myPromise.then((res) => res).then((res) => console.log(`${res} 1!`));
-  console.log("Last line 1!");
+  console.log('Last line 1!');
 }
 
 async function funcTwo() {
   const res = await myPromise;
   console.log(`${res} 2!`);
-  setTimeout(() => console.log("Timeout 2!"), 0);
-  console.log("Last line 2!");
+  setTimeout(() => console.log('Timeout 2!'), 0);
+  console.log('Last line 2!');
 }
 
 funcOne();
@@ -4374,7 +4380,7 @@ export default function sum(x) {
 }
 
 // index.js
-import * as sum from "./sum";
+import * as sum from './sum';
 ```
 
 - A: `sum(4)`
@@ -4391,12 +4397,12 @@ With the asterisk `*`, we import all exported values from that file, both defaul
 
 ```javascript
 // info.js
-export const name = "Lydia";
+export const name = 'Lydia';
 export const age = 21;
-export default "I love JavaScript";
+export default 'I love JavaScript';
 
 // index.js
-import * as info from "./info";
+import * as info from './info';
 console.log(info);
 ```
 
@@ -4427,13 +4433,13 @@ We can invoke this function, by calling `sum.default`
 
 ```javascript
 const handler = {
-  set: () => console.log("Added a new property!"),
-  get: () => console.log("Accessed a property!"),
+  set: () => console.log('Added a new property!'),
+  get: () => console.log('Accessed a property!'),
 };
 
 const person = new Proxy({}, handler);
 
-person.name = "Lydia";
+person.name = 'Lydia';
 person.name;
 ```
 
@@ -4463,7 +4469,7 @@ Then, we access a property value on the proxy object, and the `get` property on
 ###### 136. Which of the following will modify the `person` object?
 
 ```javascript
-const person = { name: "Lydia Hallie" };
+const person = { name: 'Lydia Hallie' };
 
 Object.seal(person);
 ```
@@ -4491,9 +4497,9 @@ However, you can still modify the value of existing properties.
 
 ```javascript
 const person = {
-  name: "Lydia Hallie",
+  name: 'Lydia Hallie',
   address: {
-    street: "100 Main St",
+    street: '100 Main St',
   },
 };
 
@@ -4593,8 +4599,8 @@ In ES2020, we can add private variables in classes by using the `#`. We cannot a
 
 ```javascript
 const teams = [
-  { name: "Team 1", members: ["Paul", "Lisa"] },
-  { name: "Team 2", members: ["Laura", "Tim"] },
+  { name: 'Team 1', members: ['Paul', 'Lisa'] },
+  { name: 'Team 2', members: ['Laura', 'Tim'] },
 ];
 
 function* getMembers(members) {
@@ -4637,8 +4643,8 @@ If we would've written `yield`, `return yield`, or `return`, the entire generato
 
 ```javascript
 const person = {
-  name: "Lydia Hallie",
-  hobbies: ["coding"],
+  name: 'Lydia Hallie',
+  hobbies: ['coding'],
 };
 
 function addHobby(hobby, hobbies = person.hobbies) {
@@ -4646,9 +4652,9 @@ function addHobby(hobby, hobbies = person.hobbies) {
   return hobbies;
 }
 
-addHobby("running", []);
-addHobby("dancing");
-addHobby("baking", person.hobbies);
+addHobby('running', []);
+addHobby('dancing');
+addHobby('baking', person.hobbies);
 
 console.log(person.hobbies);
 ```
@@ -4717,11 +4723,11 @@ We create the variable `pet` which is an instance of the `Flamingo` class. When
 ###### 143. Which of the options result(s) in an error?
 
 ```javascript
-const emojis = ["🎄", "🎅🏼", "🎁", "⭐"];
+const emojis = ['🎄', '🎅🏼', '🎁', '⭐'];
 
-/* 1 */ emojis.push("🦌");
+/* 1 */ emojis.push('🦌');
 /* 2 */ emojis.splice(0, 2);
-/* 3 */ emojis = [...emojis, "🥂"];
+/* 3 */ emojis = [...emojis, '🥂'];
 /* 4 */ emojis.length = 0;
 ```
 
@@ -4807,9 +4813,9 @@ function getFruit(fruits) {
   console.log(fruits?.[1]?.[1]);
 }
 
-getFruit([["🍊", "🍌"], ["🍍"]]);
+getFruit([['🍊', '🍌'], ['🍍']]);
 getFruit();
-getFruit([["🍍"], ["🍊", "🍌"]]);
+getFruit([['🍍'], ['🍊', '🍌']]);
 ```
 
 - A: `null`, `undefined`, 🍌
@@ -4875,8 +4881,8 @@ We set the variable `calc` equal to a new instance of the `Calc` class. Then, we
 
 ```javascript
 const user = {
-  email: "e@mail.com",
-  password: "12345",
+  email: 'e@mail.com',
+  password: '12345',
 };
 
 const updateUser = ({ email, password }) => {
@@ -4891,7 +4897,7 @@ const updateUser = ({ email, password }) => {
   return user;
 };
 
-const updatedUser = updateUser({ email: "new@email.com" });
+const updatedUser = updateUser({ email: 'new@email.com' });
 
 console.log(updatedUser === user);
 ```
@@ -4916,11 +4922,11 @@ The `updateUser` function updates the values of the `email` and `password` prope
 ###### 149. এটার আউটপুট কোনটা?
 
 ```javascript
-const fruit = ["🍌", "🍊", "🍎"];
+const fruit = ['🍌', '🍊', '🍎'];
 
 fruit.slice(0, 1);
 fruit.splice(0, 1);
-fruit.unshift("🍇");
+fruit.unshift('🍇');
 
 console.log(fruit);
 ```
@@ -4948,11 +4954,11 @@ At last, we invoke the `unshift` method on the `fruit` array, which modifies the
 
 ```javascript
 const animals = {};
-let dog = { emoji: "🐶" };
-let cat = { emoji: "🐈" };
+let dog = { emoji: '🐶' };
+let cat = { emoji: '🐈' };
 
-animals[dog] = { ...dog, name: "Mara" };
-animals[cat] = { ...cat, name: "Sara" };
+animals[dog] = { ...dog, name: 'Mara' };
+animals[cat] = { ...cat, name: 'Sara' };
 
 console.log(animals[dog]);
 ```
@@ -4984,13 +4990,13 @@ Logging `animals[dog]`, or actually `animals["[object Object]"]` since convertin
 
 ```javascript
 const user = {
-  email: "my@email.com",
+  email: 'my@email.com',
   updateEmail: (email) => {
     this.email = email;
   },
 };
 
-user.updateEmail("new@email.com");
+user.updateEmail('new@email.com');
 console.log(user.email);
 ```
 
@@ -5014,10 +5020,10 @@ The `updateEmail` function is an arrow function, and is not bound to the `user`
 ###### 152. এটার আউটপুট কোনটা?
 
 ```javascript
-const promise1 = Promise.resolve("First");
-const promise2 = Promise.resolve("Second");
-const promise3 = Promise.reject("Third");
-const promise4 = Promise.resolve("Fourth");
+const promise1 = Promise.resolve('First');
+const promise2 = Promise.resolve('Second');
+const promise3 = Promise.reject('Third');
+const promise4 = Promise.resolve('Fourth');
 
 const runPromises = async () => {
   const res1 = await Promise.all([promise1, promise2]);
@@ -5050,8 +5056,8 @@ The `Promise.all` method runs the passed promises in parallel. If one promise fa
 ###### 153. What should the value of `method` be to log `{ name: "Lydia", age: 22 }`?
 
 ```javascript
-const keys = ["name", "age"];
-const values = ["Lydia", 22];
+const keys = ['name', 'age'];
+const values = ['Lydia', 22];
 
 const method =
   /* ?? */
@@ -5086,7 +5092,7 @@ This creates an array of subarrays containing the correct keys and values, which
 ```javascript
 const createMember = ({ email, address = {} }) => {
   const validEmail = /.+\@.+\..+/.test(email);
-  if (!validEmail) throw new Error("Valid email pls");
+  if (!validEmail) throw new Error('Valid email pls');
 
   return {
     email,
@@ -5094,7 +5100,7 @@ const createMember = ({ email, address = {} }) => {
   };
 };
 
-const member = createMember({ email: "my@email.com" });
+const member = createMember({ email: 'my@email.com' });
 console.log(member);
 ```
 
@@ -5118,10 +5124,10 @@ The default value of `address` is an empty object `{}`. When we set the variable
 ###### 155. এটার আউটপুট কোনটা?
 
 ```javascript
-let randomValue = { name: "Lydia" };
+let randomValue = { name: 'Lydia' };
 randomValue = 23;
 
-if (!typeof randomValue === "string") {
+if (!typeof randomValue === 'string') {
   console.log("It's not a string!");
 } else {
   console.log("Yay it's a string!");

From 70d1278b545d1218964b3e6555947f91d366dc5a Mon Sep 17 00:00:00 2001
From: iamsaief <saiefalemon@gmail.com>
Date: Thu, 23 May 2024 04:09:10 +0600
Subject: [PATCH 03/12] added translation till 50

---
 bn-BD/README_bn-BD.md | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/bn-BD/README_bn-BD.md b/bn-BD/README_bn-BD.md
index d9a00cf2..6eb10aab 100644
--- a/bn-BD/README_bn-BD.md
+++ b/bn-BD/README_bn-BD.md
@@ -1397,7 +1397,7 @@ Promise.race([firstPromise, secondPromise]).then((res) => console.log(res));
 
 #### উত্তর: B
 
-When we pass multiple promises to the `Promise.race` method, it resolves/rejects the _first_ promise that resolves/rejects. To the `setTimeout` method, we pass a timer: 500ms for the first promise (`firstPromise`), and 100ms for the second promise (`secondPromise`). This means that the `secondPromise` resolves first with the value of `'two'`. `res` now holds the value of `'two'`, which gets logged.
+যখন `Promise.race` মেথডে আমরা একাধিক প্রোমিস পাস করি, _১ম_ যে প্রমিসটি রিসলভ/রিজেক্ট হয় তাকেই এটা রিসলভ/রিজেক্ট করে। `setTimeout` মেথডে আমরা একটি টাইমার পাস করেছিঃ ১ম প্রমিসে (`firstPromise`) 500ms এবং ২য় প্রমিসে (`secondPromise`) 100ms। এর মানে হল, `secondPromise`টি `'two'` ভ্যালু নিয়ে প্রথমে রিজলভ হয়। তাই `res` এর ভ্যালুটিই (`'two'`) লগ হচ্ছে।
 
 </p>
 </details>
@@ -1424,19 +1424,19 @@ console.log(members);
 
 #### উত্তর: D
 
-First, we declare a variable `person` with the value of an object that has a `name` property.
+১মে, আমরা একটি ভ্যারিয়েবল `person` ডিক্লেয়ার করেছি, এটি একটি অবজেক্ট যার একটি `name` প্রোপার্টি (কি) আছে।
 
 <img src="https://i.imgur.com/TML1MbS.png" width="200">
 
-Then, we declare a variable called `members`. We set the first element of that array equal to the value of the `person` variable. Objects interact by _reference_ when setting them equal to each other. When you assign a reference from one variable to another, you make a _copy_ of that reference. (note that they don't have the _same_ reference!)
+তারপর আমরা আরও একটি ভ্যারিয়েবল ডিক্লেয়ার করেছি `members` নামে। এটি একটি অ্যারে যার ১ম ইনডেক্সটির ভ্যালু সমান হচ্ছে `person` ভ্যারিয়েলবটি। যখন অবজেক্টকে একে ওপরের সমান সেট করা হয় এরা _রেফারেন্স_ এর মাধ্যমে কাজ করে। যখন আপনি একটি ভ্যারিয়েবলকে অ্যাসাইন করছেন অন্য ভ্যরিয়েবলের রেফারেন্স, আপনি আসলে ঐ রেফারেন্সের একটি _কপি_ করছেন। _মনে রাখবেন তাদের কাছে কিন্তু একই রেফারেন্স নেই_ !
 
 <img src="https://i.imgur.com/FSG5K3F.png" width="300">
 
-Then, we set the variable `person` equal to `null`.
+পরবর্তিতে `person` ভ্যায়েবলকে আমরা সেট করছি সমান সমান `null`।
 
 <img src="https://i.imgur.com/sYjcsMT.png" width="300">
 
-We are only modifying the value of the `person` variable, and not the first element in the array, since that element has a different (copied) reference to the object. The first element in `members` still holds its reference to the original object. When we log the `members` array, the first element still holds the value of the object, which gets logged.
+আমরা কেবল `person` ভ্যায়েবলকে পরিবর্তন করেছি, অ্যারের ১ম এলিমেন্টকে নয়, যেহেতু ঐ এলিমেন্টির কাছে অবজেক্টের ভিন্ন (কপিকৃত) একটি রেফারেন্স আছে। `members` অ্যারের ১ম এলিমেন্টটি এখনো আসল অবজেক্টির রেফারেন্সটি ধরে রেখেছে তাই ১ম এলিমেন্টটি তার ভ্যালুও ধরে রেখেছে আসল অবজেক্টির ভ্যালুকেই। ফলে যখন `members` অ্যারেকে লগ করা হয় সেটাই লগ হয়েছে।
 
 </p>
 </details>
@@ -1466,7 +1466,7 @@ for (const item in person) {
 
 #### উত্তর: B
 
-With a `for-in` loop, we can iterate through object keys, in this case `name` and `age`. Under the hood, object keys are strings (if they're not a Symbol). On every loop, we set the value of `item` equal to the current key it’s iterating over. First, `item` is equal to `name`, and gets logged. Then, `item` is equal to `age`, which gets logged.
+`for-in` লুপ ব্যবহার করে আমরা কেবল অবজেক্টের কি-গুলির মধ্যেই পুনরাবৃত্তি করতে পারি, এক্ষেত্রে `name` ও `age`। ভেতরে ভেতরে অবজেক্ট কীগুলি হল স্ট্রিং (যদি তারা কোন একটি প্রতীক (Symbol) না হয়)। প্রতিটি লুপে, আমরা `item` মানটি বর্তমান কী-টির সমান সেট করি যার পুনরাবৃত্তি হচ্ছে। ১মে, `item`-টি `name`-এর সমান, এবং লগ করা হয়। তারপর, `item`-টি `age`-এর সমান, যা লগ হয়।
 
 </p>
 </details>
@@ -1489,18 +1489,18 @@ console.log(3 + 4 + '5');
 
 #### উত্তর: B
 
-Operator associativity is the order in which the compiler evaluates the expressions, either left-to-right or right-to-left. This only happens if all operators have the _same_ precedence. We only have one type of operator: `+`. For addition, the associativity is left-to-right.
+**অপারেটর অ্যাসোসিয়েটিভিটি** হল সেই ক্রম যেখানে কম্পাইলার বাম-থেকে-ডান বা ডান-থেকে-বামে এক্সপ্রেশনকে মূল্যায়ন করে। এটি শুধুমাত্র তখনই ঘটে যখন সমস্ত অপারেটরের _একই_ অগ্রাধিকার থাকে। আমাদের শুধুমাত্র এক ধরনের অপারেটর আছে: `+`। উপরন্তু, অ্যাসোসিয়েটিভিটি বাম থেকে ডান।
 
-`3 + 4` gets evaluated first. This results in the number `7`.
+১মে `3 + 4` মূল্যায়ন করা হয়। এর ফলে সংখ্যাটি `7` হয়।
 
-`7 + '5'` results in `"75"` because of coercion. JavaScript converts the number `7` into a string, see question 15. We can concatenate two strings using the `+`operator. `"7" + "5"` results in `"75"`.
+**কোয়ার্শন** এর ফলে `7 + '5'` এর ফলাফল হয় `"75"`। জাভাস্ক্রিপ্ট `7` নম্বরটিকে একটি স্ট্রিংয়ে রূপান্তর করে, [প্রশ্ন 15 দেখুন](#15-এটার-আউটপুট-কোনটা)। আমরা `+` অপারেটর ব্যবহার করে দুটি স্ট্রিংকে সংযুক্ত করতে পারি। `"7" + "5"` ফলাফলে `"75"`।
 
 </p>
 </details>
 
 ---
 
-###### 49. What's the value of `num`?
+###### 49. `num` এর ভ্যালু কোনটি?
 
 ```javascript
 const num = parseInt('7*6', 10);
@@ -1516,9 +1516,9 @@ const num = parseInt('7*6', 10);
 
 #### উত্তর: C
 
-Only the first number in the string is returned. Based on the _radix_ (the second argument in order to specify what type of number we want to parse it to: base 10, hexadecimal, octal, binary, etc.), the `parseInt` checks whether the characters in the string are valid. Once it encounters a character that isn't a valid number in the radix, it stops parsing and ignores the following characters.
+স্ট্রিং এর শুধুমাত্র প্রথম সংখ্যাটি রিটার্ন করা হয়েছে। _radix_ এর উপর ভিত্তি করে স্ট্রিং-এর অক্ষরগুলি বৈধ কিনা তা পরীক্ষা করে (২য় আর্গুমেন্টই নির্দিষ্ট করে আমরা কোন ধরনের সংখ্যাকে পার্স করতে চাই: ডেসিমাল - 10, হেক্সাডেসিমাল - 16, অক্টাল - 8, বাইনারি - 2, ইত্যাদি)। এটি যখন একবার এমন একটি অক্ষরের মুখোমুখি হয় যা রেডিক্সে একটি বৈধ সংখ্যা নয়, তখন পার্সিং বন্ধ করে দেয় এবং পরবর্তি অক্ষরগুলিকে উপেক্ষা করে।
 
-`*` is not a valid number. It only parses `"7"` into the decimal `7`. `num` now holds the value of `7`.
+`*` একটি বৈধ সংখ্যা নয়। এটি শুধুমাত্র `"7"` কে ডেসিমাল `7`-এ পার্স করে। `num` মান তাই `7`।
 
 </p>
 </details>
@@ -1544,9 +1544,9 @@ Only the first number in the string is returned. Based on the _radix_ (the secon
 
 #### উত্তর: C
 
-When mapping over the array, the value of `num` is equal to the element it’s currently looping over. In this case, the elements are numbers, so the condition of the if statement `typeof num === "number"` returns `true`. The map function creates a new array and inserts the values returned from the function.
+অ্যারের উপর ম্যাপিং করার সময়, `num` এর মানটি বর্তমানে লুপ করা হচ্ছে সেই এলিমেন্টের সমান। এই ক্ষেত্রে, এলিমেন্টগুলো সংখ্যা, তাই if স্টেটমেন্টের শর্তটি`typeof num === "number"` - `true` রিটার্ন করে। ম্যাপ ফাংশন একটি নতুন অ্যারে তৈরি করে এবং ফাংশন থেকে রিটার্ন করা ভ্যালুগুলো সেটাতে যুক্ত করে।
 
-However, we don’t return a value. When we don’t return a value from the function, the function returns `undefined`. For every element in the array, the function block gets called, so for each element we return `undefined`.
+অন্যদিকে, আমরা কোন ভ্যালুই রিটার্ন করি নি। যখন ফাংশন থেকে কোন একটি ভ্যালু রিটার্ন করা হয় না, ফাংশন `undefined` রিটার্ন করে। অ্যারের প্রতিটি এলিমেন্টের জন্য, ফাংশন ব্লক কল করা হয়, তাই প্রতিটি এলিমেন্টের জন্য আমরা `undefined` রিটার্ন করছি।
 
 </p>
 </details>

From 5a217b412b30c94ac2e01c7ca0808572fd6f242c Mon Sep 17 00:00:00 2001
From: iamsaief <saiefalemon@gmail.com>
Date: Mon, 27 May 2024 04:54:03 +0600
Subject: [PATCH 04/12] added translation till 65

---
 bn-BD/README_bn-BD.md | 80 +++++++++++++++++++++----------------------
 1 file changed, 40 insertions(+), 40 deletions(-)

diff --git a/bn-BD/README_bn-BD.md b/bn-BD/README_bn-BD.md
index 6eb10aab..1f798452 100644
--- a/bn-BD/README_bn-BD.md
+++ b/bn-BD/README_bn-BD.md
@@ -1579,11 +1579,11 @@ console.log(person, birthYear);
 
 #### উত্তর: A
 
-Arguments are passed by _value_, unless their value is an object, then they're passed by _reference_. `birthYear` is passed by value, since it's a string, not an object. When we pass arguments by value, a _copy_ of that value is created (see question 46).
+আর্গুমেন্টসগুলো হল পাসড বাই _ভ্যালু_, যদি না তারা অবজেক্ট হয়, তবে তারা পাসড বাই _রেফারেন্স_। যেহেতু `birthYear` একটি স্ট্রিং এটি পাসড বাই ভ্যালু। যখন আমরা আর্গুমেন্টসগুলো পাস করি _ভ্যালু_ হিসেবে, ঐ ভ্যালুর একটি _কপি_ তৈরি হয়। [(প্রশ্ন ৪৬ দেখুন)](#46-এটার-আউটপুট-কোনটা)
 
-The variable `birthYear` has a reference to the value `"1997"`. The argument `year` also has a reference to the value `"1997"`, but it's not the same value as `birthYear` has a reference to. When we update the value of `year` by setting `year` equal to `"1998"`, we are only updating the value of `year`. `birthYear` is still equal to `"1997"`.
+`birthYear` ভ্যারিয়েবলটির কাছে `"1997"` ভ্যালুর একটি রেফারেন্স আছে। `year` আর্গুমেন্টের কাছেও `"1997"` ভ্যালুর একটি রেফারেন্স আছে, কিন্তু দুটি রেফারেন্স একি নয়। মানে হল, ফাংশনের ভেতরে আমরা যখন `year` এর ভ্যালুকে আপডেট করছি `"1998"` এর সমান করে, আমরা কেবল `year` এর ভ্যালিটিই পরিবর্তন করছি। `birthYear` এর ভ্যালু এখনো সমান হচ্ছে `"1997"`।
 
-The value of `person` is an object. The argument `member` has a (copied) reference to the _same_ object. When we modify a property of the object `member` has a reference to, the value of `person` will also be modified, since they both have a reference to the same object. `person`'s `name` property is now equal to the value `"Lydia"`
+অন্যদিকে, `person` হল একটি অবজেক্ট। এই অবজেক্টের রেফারেন্স পাস হয়েছে `member` আর্গুমেন্টিটির কাছে। যখন আমরা অবজেক্টের কোন প্রপার্টিকে পরিবর্তন করছি যেটার রেফারেন্স আছে `member` এর কাছে, তাই `person` অবজেক্টও পরিবর্তন হচ্ছে যাচ্ছে। যেহেতু তাদের রেফারেন্স একই। ফলে `person`-এর `name` প্রোপার্টিটি এখন সমান হল `"Lydia"`।
 
 </p>
 </details>
@@ -1619,9 +1619,9 @@ sayHi();
 
 #### উত্তর: D
 
-With the `throw` statement, we can create custom errors. With this statement, you can throw exceptions. An exception can be a <b>string</b>, a <b>number</b>, a <b>boolean</b> or an <b>object</b>. In this case, our exception is the string `'Hello world!'`.
+`throw` স্টেটমেন্ট ব্যবহার করে আমরা কাস্টম এররস তৈরি করে এক্সসেপশন থ্রো করতে পারি। এক্সসেপশনস হতে পারে **string**, **number**, **boolean**, অথবা একটি **অবজেক্ট** । এক্ষেত্রে, এক্সসেপশন হল একটি স্ট্রিং `'Hello world!'`।
 
-With the `catch` statement, we can specify what to do if an exception is thrown in the `try` block. An exception is thrown: the string `'Hello world!'`. `e` is now equal to that string, which we log. This results in `'Oh an error: Hello world!'`.
+`catch` স্টেটমেন্ট ব্যবহার করে আমরা এটা নির্দিস্ট করতে পারি যে _কি করা হবে_ যখন `try` ব্লক থেকে কোন এক্সসেপশন থ্রো করা হয়। এক্সসেপশন থ্রো করা হয়েছেঃ `'Hello world!'` স্ট্রিংটি। `e` হল এই স্ট্রিংটির সমান, যেটা লগ করা হয়েছে। তাই ফলাফল হয়েছে `'Oh an error: Hello world!'`।
 
 </p>
 </details>
@@ -1650,9 +1650,9 @@ console.log(myCar.make);
 
 #### উত্তর: B
 
-When a constructor function is called with the `new` keyword, it creates an object and sets the `this` keyword to refer to that object. By default, if the constructor function doesn't explicitly return anything, it will return the newly created object.
+যখন একটি কনস্ট্রাক্টর ফাংশনকে `new` কীওয়ার্ড দিয়ে কল করা হয়, তখন এটি একটি অবজেক্ট তৈরি করে এবং এটাকে রেফার করার জন্য `this` কীওয়ার্ডটি সেট করে। ডিফল্টরূপে, যদি কনস্ট্রাক্টর ফাংশন সরাসরি কিছু রিটার্ন না করে, তবে এটি নতুন তৈরিকৃত অবজেক্টকেই রিটার্ন করবে।
 
-In this case, the constructor function `Car` explicitly returns a new object with `make` set to `"Maserati"`, which overrides the default behavior. Therefore, when `new Car()` is called, the _returned_ object is assigned to `myCar`, resulting in the output being `"Maserati"` when `myCar.make` is accessed.
+এই ক্ষেত্রে, কনস্ট্রাক্টর ফাংশন `Car` সরাসরি একটি নতুন অবজেক্ট রিটার্ন করে যার সাথে `make` প্রোপার্টিকে সেট করা হয় `"Maserati"`, যা ডিফল্ট আচরনকে ওভাররাইড করে। তাই, যখন `new Car()` কল করা হয়, তখন _returned_ অবজেক্টটি `myCar`-এ অ্যাসাইন করা হয়, যার ফলে `myCar.make`কে অ্যাক্সেস করা হলে আউটপুট `"Maserati"` হয়।
 
 </p>
 </details>
@@ -1680,18 +1680,18 @@ console.log(typeof y);
 
 #### উত্তর: A
 
-`let x = (y = 10);` is actually shorthand for:
+`let x = (y = 10);` আসলে হচ্ছে নিচের উল্লেখিত অংশের সংক্ষিপ্তরূপ ঃ
 
 ```javascript
 y = 10;
 let x = y;
 ```
 
-When we set `y` equal to `10`, we actually add a property `y` to the global object (`window` in the browser, `global` in Node). In a browser, `window.y` is now equal to `10`.
+আমরা যখন `y` কে সেট করি `10` এর সমান তখন আমরা আসলে গ্লোবাল অবজেক্টে একটি প্রপার্টি `y` যোগ করি (ব্রাউজারে `উইন্ডো`, নোডে `গ্লোবাল`)। একটি ব্রাউজারে, `window.y` এখন `10` এর সমান।
 
-Then, we declare a variable `x` with the value of `y`, which is `10`. Variables declared with the `let` keyword are _block scoped_, they are only defined within the block they're declared in; the immediately invoked function expression (IIFE) in this case. When we use the `typeof` operator, the operand `x` is not defined: we are trying to access `x` outside of the block it's declared in. This means that `x` is not defined. Values who haven't been assigned a value or declared are of type `"undefined"`. `console.log(typeof x)` returns `"undefined"`.
+তারপর, আমরা `y` এর ভ্যালু সহ একটি ভেরিয়েবল `x` ডিক্লেয়ার করি, যা `10`। `let` কীওয়ার্ডের সাথে ডিক্লেয়ার করা ভেরিয়েবলগুলি হল _block scoped_, তারা শুধুমাত্র যে ব্লকে ডিক্লেয়ার করা হয়েছে তার মধ্যেই ডিফাইনকৃত (সংজ্ঞায়িত) থাকবে; এই ক্ষেত্রে ইমিডিয়েটলি ইনভোকড ফাংশন এক্সপ্রেশন (IIFE)। যখন আমরা `typeof` অপারেটর ব্যবহার করছি, সেখানে অপারেন্ড `x` ডিফাইন হয়নি: আমরা যে ব্লকে এটি ঘোষণা করা হয়েছে তার বাইরে `x`-কে অ্যাক্সেস করার চেষ্টা করছি। এখানে `x` ডিফাইন হয়নি। যে মানগুলিকে একটি মান অ্যাসাইন করা হয়নি বা ডিক্লেয়ার করা হয়নি সেগুলি `"undefined"` হয় টাইপের। তাই `console.log(typeof x)` `"undefined"` রিটার্ন করেছে।
 
-However, we created a global variable `y` when setting `y` equal to `10`. This value is accessible anywhere in our code. `y` is defined, and holds a value of type `"number"`. `console.log(typeof y)` returns `"number"`.
+অন্যদিকে, আমরা `y` কে `10` এর সমান সেট করে একটি গ্লোবাল ভ্যেরিয়েবল তৈরি করেছি `y`। এই ভ্যালুটি কোডের যেকোন অংশ থেকেই অ্যাক্সেস করা যাবে। `y` যেহেতু একটি `"number"` টাইপ দিয়ে ডিফাইন হয়েছে, `console.log(typeof y)` রিটার্ন করেছে `"number"`।
 
 </p>
 </details>
@@ -1730,9 +1730,9 @@ pet.bark();
 
 #### উত্তর: A
 
-We can delete properties from objects using the `delete` keyword, also on the prototype. By deleting a property on the prototype, it is not available anymore in the prototype chain. In this case, the `bark` function is not available anymore on the prototype after `delete Dog.prototype.bark`, yet we still try to access it.
+`delete` কিওয়ার্ড ব্যবহার করে অবজেক্টের প্রোপার্টিস মুছে ফেলতে পারি, একইভাবে প্রোটোটাইপ থেকেও মুছে ফেলতে পারি। একটি প্রোপার্টিকে প্রোটোটাইপ থেকে মুছে ফেললে তাকে প্রোটোটাইপ চেইনে আর পাওয়া যায় না। এক্ষেত্রে, `delete Dog.prototype.bark`-এর পরে `bark` ফাংশনটি প্রোটোটাইপ চেইনে আর নেই, তবুও আমরা এটি অ্যাক্সেস করার চেষ্টা করেছি।
 
-When we try to invoke something that is not a function, a `TypeError` is thrown. In this case `TypeError: pet.bark is not a function`, since `pet.bark` is `undefined`.
+যখন আমরা ফাংশন নয় এমন কোনো কিছুকে কল করার চেষ্টা করি, তখন একটি `TypeError` থ্রো করা হয়। এই ক্ষেত্রে `TypeError: pet.bark is not a function`, যেহেতু `pet.bark` `undefined`।
 
 </p>
 </details>
@@ -1757,9 +1757,9 @@ console.log(set);
 
 #### উত্তর: D
 
-The `Set` object is a collection of _unique_ values: a value can only occur once in a set.
+`Set` অবজেক্টটি হল _অনন্য_ ভ্যালুসমুহের একটি সংগ্রহ: একটি সেটে একই মান কেবল একবারই থাকতে পারে।
 
-We passed the iterable `[1, 1, 2, 3, 4]` with a duplicate value `1`. Since we cannot have two of the same values in a set, one of them is removed. This results in `{1, 2, 3, 4}`.
+আমরা একটি অ্যারে `[1, 1, 2, 3, 4]` পাস করেছি যেখানে একটি ডুপ্লিকেট মান `1` আছে। যেহেতু আমাদের একটি সেটে একই মান দুটি থাকতে পারে না, তাদের মধ্যে একটি সরানো হয়। তাই ফলাফল হয়ছে `{1, 2, 3, 4}`।
 
 </p>
 </details>
@@ -1793,9 +1793,9 @@ console.log(myCounter);
 
 #### উত্তর: C
 
-An imported module is _read-only_: you cannot modify the imported module. Only the module that exports them can change its value.
+একটি ইম্পোর্ট করা মডিউল হল _শুধুমাত্র পড়া যায়_: আপনি ইম্পোর্ট করা মডিউল পরিবর্তন করতে পারবেন না। শুধুমাত্র যে মডিউল তাদের এক্সপোর্ট করে সেই কেবল মানের পরিবর্তন করতে পারে।
 
-When we try to increment the value of `myCounter`, it throws an error: `myCounter` is read-only and cannot be modified.
+যখন আমরা `myCounter` এর মান বৃদ্ধি করার চেষ্টা করি, এটি একটি এরর ছুড়ে দেয়া হয়: `myCounter` is read-only and cannot be modified.
 
 </p>
 </details>
@@ -1822,9 +1822,9 @@ console.log(delete age);
 
 #### উত্তর: A
 
-The `delete` operator returns a boolean value: `true` on a successful deletion, else it'll return `false`. However, variables declared with the `var`, `const`, or `let` keywords cannot be deleted using the `delete` operator.
+`delete` অপারেটর একটি বুলিয়ান মান রিটার্ন করে: ডিলিট সফল হলে `true`, অন্যথায় এটি `false` প্রদান করবে। অন্যদিকে, `var`, `const`, বা `let` কীওয়ার্ডের দিয়ে ডিক্লেয়ার করা ভেরিয়েবল `delete` অপারেটর ব্যবহার করে মুছে ফেলা যায় না।
 
-The `name` variable was declared with a `const` keyword, so its deletion is not successful: `false` is returned. When we set `age` equal to `21`, we actually added a property called `age` to the global object. You can successfully delete properties from objects this way, also the global object, so `delete age` returns `true`.
+`name` ভেরিয়েবলটিকে একটি `const` কীওয়ার্ড দিয়ে ডিক্লেয়ার করা হয়েছিল, তাই এটি মুছে ফেলা সফল হয়নি: `false` রিটার্ন করা হয়েছে। যখন আমরা `age` সমান `21` সেট করি, আমরা আসলে গ্লোবাল অবজেক্টে `age` নামক একটি প্রপার্টি যোগ করি। আপনি সফলভাবে অবজেক্টগুলো থেকে এইভাবে প্রপার্টিগুলি মুছে ফেলতে পারেন, গ্লোবাল অবজেক্ট থেকেও তাই `delete age` `true` রিটার্ন করে।
 
 </p>
 </details>
@@ -1850,7 +1850,7 @@ console.log(y);
 
 #### উত্তর: C
 
-We can unpack values from arrays or properties from objects through destructuring. For example:
+আমরা ডিস্ট্রাকচারের মাধ্যমে অ্যারের ভ্যালু বা অবজেক্ট প্রোপার্টিস বের করে আনতে পারি। উদাহরণ স্বরূপ:
 
 ```javascript
 [a, b] = [1, 2];
@@ -1858,7 +1858,7 @@ We can unpack values from arrays or properties from objects through destructurin
 
 <img src="https://i.imgur.com/ADFpVop.png" width="200">
 
-The value of `a` is now `1`, and the value of `b` is now `2`. What we actually did in the question, is:
+`a`-এর ভ্যালুটি এখন `1` এবং `b` -এর ভ্যালু এখন `2`। আমরা আসলে এই প্রশ্নের বেলায় যেটা করেছিঃ
 
 ```javascript
 [y] = [1, 2, 3, 4, 5];
@@ -1866,7 +1866,7 @@ The value of `a` is now `1`, and the value of `b` is now `2`. What we actually d
 
 <img src="https://i.imgur.com/NzGkMNk.png" width="200">
 
-This means that the value of `y` is equal to the first value in the array, which is the number `1`. When we log `y`, `1` is returned.
+এর মানে হল, `y` এর ভ্যালু সমান হয় অ্যারের ১ম এলিমেন্টের ভ্যালু, এই ভ্যালুটিি হল `1` সংখ্যাটি। তাই `y` কে যখন লগ করছি রিটার্ন পাই `1`।
 
 </p>
 </details>
@@ -1892,7 +1892,7 @@ console.log(admin);
 
 #### উত্তর: B
 
-It's possible to combine objects using the spread operator `...`. It lets you create copies of the key/value pairs of one object, and add them to another object. In this case, we create copies of the `user` object, and add them to the `admin` object. The `admin` object now contains the copied key/value pairs, which results in `{ admin: true, name: "Lydia", age: 21 }`.
+স্প্রেড অপারেটর `...` দিয়ে অবজেক্টগুলোকে একত্রিত করা সম্ভব। এর মাধ্যমে একটি অবজেক্টের কি/ভ্যালু জোড়াদ্বয়ের কপি তৈরি করতে পারবেন এবং অন্য অবজেক্টে তাদের যুক্ত করতে পারবেন। এক্ষেত্রে, আমরা `user` অবজেক্টের কপি তৈরি করেছি এবং `admin` অবজেক্টে যুক্ত করেছি। তাই `admin` অবজেক্টে এখন কি/ভ্যালু জোড়ার কপিও রয়েছে, ফলে লগ করায় `{ admin: true, name: "Lydia", age: 21 }` রিটার্ন পাই।
 
 </p>
 </details>
@@ -1920,9 +1920,9 @@ console.log(Object.keys(person));
 
 #### উত্তর: B
 
-With the `defineProperty` method, we can add new properties to an object, or modify existing ones. When we add a property to an object using the `defineProperty` method, they are by default _not enumerable_. The `Object.keys` method returns all _enumerable_ property names from an object, in this case only `"name"`.
+`defineProperty` মেথডের সাহায্যে, আমরা একটি অবজেক্টে নতুন প্রোপার্টিস যোগ করতে পারি বা বিদ্যমানগুলিকে সংশোধন করতে পারি। যখন আমরা `defineProperty` মেথডের ব্যবহার করে কোনো অবজেক্টে একটি প্রোপার্টি যোগ করি, তখন সেগুলি ডিফল্টরূপে _গণনাযোগ্য নয়_ (_not enumerable_)। `Object.keys` মেথড একটি অবজেক্টের সমস্ত _গণনাযোগ্য_ প্রোপার্টিসের নাম রিটার্ন করে, এই ক্ষেত্রে শুধুমাত্র `"name"`।
 
-Properties added using the `defineProperty` method are immutable by default. You can override this behavior using the `writable`, `configurable` and `enumerable` properties. This way, the `defineProperty` method gives you a lot more control over the properties you're adding to an object.
+`defineProperty` মেথড ব্যবহার করে যোগ করা প্রোপার্টিসগুলি ডিফল্টরূপে অপরিবর্তনীয়। এ আচরণটিকে আপনি ওভাররাইড করতে পারেন `writable`, `configurable` ও `enumerable` প্রোপার্টিসগুলি ব্যবহার করে। এইভাবে, `defineProperty` মেথড আপনাকে একটি অবজেক্টে যে প্রোপার্টিসগুলি যোগ করছেন তার উপর অনেক বেশি নিয়ন্ত্রণ দেয়।
 
 </p>
 </details>
@@ -1952,11 +1952,11 @@ console.log(data);
 
 #### উত্তর: A
 
-The second argument of `JSON.stringify` is the _replacer_. The replacer can either be a function or an array, and lets you control what and how the values should be stringified.
+`JSON.stringify` এর দ্বিতীয় আর্গুমেন্ট হল _replacer_। রিপ্লেসার একটি ফাংশন বা একটি অ্যারে হতে পারে এবং এটি আপনাকে নিয়ন্ত্রণ করতে দেয় ভ্যালুগুলো কি ও কীভাবে তারা স্ট্রিংফাই হবে সেটা।
 
-If the replacer is an _array_, only the property names included in the array will be added to the JSON string. In this case, only the properties with the names `"level"` and `"health"` are included, `"username"` is excluded. `data` is now equal to `"{"level":19, "health":90}"`.
+যদি রিপ্লেসার একটি _array_ হয়, শুধুমাত্র অ্যারেতে অন্তর্ভুক্ত প্রোপার্টিসের নামগুলি JSON স্ট্রিংয়ে যোগ করা হবে। এই ক্ষেত্রে, শুধুমাত্র `"level"` এবং `"health"` নামের প্রোপার্টিসগুলি অন্তর্ভুক্ত করা হয়েছে, `"username"` বাদ দেওয়া হয়েছে। তাই `data` এখন `"{"level":19, "health":90}"` এর সমান।
 
-If the replacer is a _function_, this function gets called on every property in the object you're stringifying. The value returned from this function will be the value of the property when it's added to the JSON string. If the value is `undefined`, this property is excluded from the JSON string.
+যদি রিপ্লেসারটি একটি _function_ হয়, তাহলে আপনি যে অবজেক্টকে স্ট্রিংফাই করছেন তার প্রতিটি প্রোপার্টিসের জন্য এই ফাংশনটি কল করা হবে। এই ফাংশন থেকে রিটার্ন করা ভ্যালুই হবে সেই প্রোপার্টিসের ভ্যালু যখন এটি JSON স্ট্রিং-এ যোগ করা হয়। ভ্যালুটি যদি `undefined` হয়, তাহলে এই প্রপার্টিটি JSON স্ট্রিং থেকে বাদ দেওয়া হবে।
 
 </p>
 </details>
@@ -1988,9 +1988,9 @@ console.log(num2);
 
 #### উত্তর: A
 
-The unary operator `++` _first returns_ the value of the operand, _then increments_ the value of the operand. The value of `num1` is `10`, since the `increaseNumber` function first returns the value of `num`, which is `10`, and only increments the value of `num` afterward.
+ইউনারি অপারেটর `++` _প্রথমে অপারেন্ডের মান রিটার্ন করে_, তারপর অপারেন্ডের মান বৃদ্ধি করে। `num1`-এর ভ্যালু `10`, যেহেতু `increaseNumber` ফাংশনটি প্রথমে ভ্যালুটিকে রিটার্ন করে, যেটা হল `10`, তারপরই কেবল ভ্যালুটিকে বৃদ্ধি করে।
 
-`num2` is `10`, since we passed `num1` to the `increasePassedNumber`. `number` is equal to `10`(the value of `num1`). Again, the unary operator `++` _first returns_ the value of the operand, _then increments_ the value of the operand. The value of `number` is `10`, so `num2` is equal to `10`.
+`num2` হল `10`, যেহেতু আমরা `num1` কে `increasePassedNumber`-এ পাস করেছি। `number` সমান হল `10` (`num1` এর মান)। আবার, ইউনারী অপারেটর `++` _প্রথমে অপারেন্ডের মান রিটার্ন করে_, তারপর অপারেন্ডের মান বৃদ্ধি করে। তাই `number` এর ভ্যালু হল `10`, ফলে `num2` সমানও হয় `10`।
 
 </p>
 </details>
@@ -2022,13 +2022,13 @@ multiply(value);
 
 #### উত্তর: C
 
-In ES6, we can initialize parameters with a default value. The value of the parameter will be the default value, if no other value has been passed to the function, or if the value of the parameter is `"undefined"`. In this case, we spread the properties of the `value` object into a new object, so `x` has the default value of `{ number: 10 }`.
+ইএস৬ এ, আমরা ফাংশনের প্যারামিটারকে একটি ডিফল্ট ভ্যালু দিয়ে ইনিশিয়ালাইজ করতে পারি। প্যারামিটারের ভ্যালুটিই ডিফল্ট হিসেবে থেকে যায় যদি না ফাংশনে অন্য কোন ভ্যালু পাস করা হয়, অথবা প্যারামিটারের ভ্যালুটি `"undefined"` হয়। এক্ষেত্রে, আমরা `value` অবজেক্টের প্রোপার্টিসগুলোকে নতুন অবজেক্টে স্প্রেড করেছি, তাই `x`-এর কাছে ডিফল্ট ভ্যালু থাকছে `{ number: 10 }`।
 
-The default argument is evaluated at _call time_! Every time we call the function, a _new_ object is created. We invoke the `multiply` function the first two times without passing a value: `x` has the default value of `{ number: 10 }`. We then log the multiplied value of that number, which is `20`.
+ডিফল্ট আর্গুমেন্টটির মান নির্নয় হয়ছে ফাংশন _কলের সময়_ ! আমরা প্রতিবার ফাংশন করছি, একটি _নতুন_ অবজেক্ট তৈরি হচ্ছে। প্রথম দুবার আমরা কোন ভ্যালু পাস না করেই `multiply` ফাংশকে চালিয়েছিঃ তাই `x`-এর কাছে ডিফল্ট ভ্যালুটি থাকছে `{ number: 10 }`। তারপর আমরা গুণফল লগ করেছি, যেটি হয় `20`।
 
-The third time we invoke multiply, we do pass an argument: the object called `value`. The `*=` operator is actually shorthand for `x.number = x.number * 2`: we modify the value of `x.number`, and log the multiplied value `20`.
+৩য় বার, `multiply` ফাংশকে চালিয়েছি, আর্গুমেন্ট এ `value` অবজেক্টকে পাস করে। `*=` অপারেটরটি আসলে `x.number = x.number * 2` এর সংক্ষিপ্তরূপঃ আমরা `x.number`-এর ভ্যালুকে পরিবর্তন করেছি এবং গুণফল `20`-কে লগ করেছি।
 
-The fourth time, we pass the `value` object again. `x.number` was previously modified to `20`, so `x.number *= 2` logs `40`.
+৪র্থ বারে, আমরা আবার `value` অবজেক্টকে পাস করেছি। যেহেতু আগেরবার `x.number`-এর ভ্যালুকে পরিবর্তন করে `20` পেয়েছিলাম, অবজেক্ট যেহেতু রেফারেন্স টাইপ তাই এখন `x.number *= 2` লগ করে `40` পাচ্ছি।
 
 </p>
 </details>
@@ -2051,17 +2051,17 @@ The fourth time, we pass the `value` object again. `x.number` was previously mod
 
 #### উত্তর: D
 
-The first argument that the `reduce` method receives is the _accumulator_, `x` in this case. The second argument is the _current value_, `y`. With the reduce method, we execute a callback function on every element in the array, which could ultimately result in one single value.
+`reduce` মেথড ১ম যে আর্গুমেন্টটি নেয় তাকে বলা হয় _accumulator_, এক্ষেত্রে সেটা `x`। ২য় আর্গুমেন্টটিকে বলা হয় _current value_, `y`। `reduce` মেথডের মাধ্যমে, আমরা অ্যারের প্রতীটি এলিমেন্টের জন্য একটি কলব্যাক ফাংশন চালাই, যা শেষ পর্যন্ত একটি একক মানের ফলাফল প্রদান করে।
 
-In this example, we are not returning any values, we are simply logging the values of the accumulator and the current value.
+এই উদাহরনের বেলায়, আমরা কোন ভ্যালুকেই রিটার্ন করছি না, কেবল দুটি ভ্যালুকে _accumulator_ ও _current value_ লগ করছি
 
-The value of the accumulator is equal to the previously returned value of the callback function. If you don't pass the optional `initialValue` argument to the `reduce` method, the accumulator is equal to the first element on the first call.
+_accumulator_ এর ভ্যালুটি কলব্যাক ফাংশনের আগেরবারের রিটার্ন করা ভ্যালুর সমান হয়। `reduce` মেথডের আর্গুমেন্টে আপনি যদি অপশনাল ভ্যালু `initialValue` পাস না করেন, তবে ১ম কলের সময় _accumulator_ এর ভ্যালু সমান হয় অ্যারের ১ম এলিমেন্টটি।
 
-On the first call, the accumulator (`x`) is `1`, and the current value (`y`) is `2`. We don't return from the callback function, we log the accumulator, and the current values: `1` and `2` get logged.
+১ম কলে, _accumulator_ (`x`) হয় `1` এবং _current value_ (`y`) হয় `2`। আমরা কলব্যাক ফাংশন থেকে কোন ভ্যালুকেই রিটার্ন করছি না, কেবল _accumulator_ ও _current value_ ভ্যালু লগ করছিঃ `1` ও `2` লগ হয়েছে।
 
-If you don't return a value from a function, it returns `undefined`. On the next call, the accumulator is `undefined`, and the current value is `3`. `undefined` and `3` get logged.
+আপনি যদি ফাংশন থেকে কিছু রিটার্ন না করেন তবে, এটা `undefined` রিটার্ন করে। তাই পরবর্তি কলে, _accumulator_ হয় `undefined` _current value_ হয় `3`। `undefined` ও `3` লগ হয়েছে।
 
-On the fourth call, we again don't return from the callback function. The accumulator is again `undefined`, and the current value is `4`. `undefined` and `4` get logged.
+৪র্থ কলে, আমরা আবারও কলব্যাক ফাংশন থেকে রিটার্ন করছি না। তাই _accumulator_ আবারও হয় `undefined`, এবং _current value_ হয় `4`। `undefined` ও `4` লগ হয়েছে।
 
 </p>
 </details>

From b236c778a5ba9a79d7ea8576a0f556d4357e6361 Mon Sep 17 00:00:00 2001
From: iamsaief <saiefalemon@gmail.com>
Date: Sun, 2 Jun 2024 09:50:34 +0600
Subject: [PATCH 05/12] added translation till 80

---
 bn-BD/README_bn-BD.md | 98 ++++++++++++++++++++++---------------------
 1 file changed, 50 insertions(+), 48 deletions(-)

diff --git a/bn-BD/README_bn-BD.md b/bn-BD/README_bn-BD.md
index 1f798452..f292c293 100644
--- a/bn-BD/README_bn-BD.md
+++ b/bn-BD/README_bn-BD.md
@@ -2068,7 +2068,7 @@ _accumulator_ এর ভ্যালুটি কলব্যাক ফাংশ
   
 ---
 
-###### 66. With which constructor can we successfully extend the `Dog` class?
+###### 66. কোন কন্সট্রাক্টরটি দিয়ে আমরা সফলভাবে `Dog` ক্লাসকে এক্সটেন্ড করতে পারি?
 
 ```javascript
 class Dog {
@@ -2111,11 +2111,11 @@ class Labrador extends Dog {
 
 #### উত্তর: B
 
-In a derived class, you cannot access the `this` keyword before calling `super`. If you try to do that, it will throw a ReferenceError: 1 and 4 would throw a reference error.
+একটি ডিরাইভড ক্লাসে, আপনি `super` কল করার আগে `this` কীওয়ার্ড অ্যাক্সেস করতে পারবেন না। আপনি যদি এটি করার চেষ্টা করেন তবে এটি একটি রেফারেন্স এরর (ReferenceError) থ্রো করবে: 1 এবং 4 একটি রেফারেন্স এরর থ্রো করবে।
 
-With the `super` keyword, we call that parent class's constructor with the given arguments. The parent's constructor receives the `name` argument, so we need to pass `name` to `super`.
+`super` কীওয়ার্ড দিয়ে, আমরা প্রদত্ত আর্গুমেন্ট সহ সেই প্যারেন্ট ক্লাসের কনস্ট্রাক্টরকে কল করি। প্যারেন্টের কন্সট্রাক্টর `name` আর্গুমেন্ট নেয়, তাই `super`-এ আমাদের `name` পাস করতে হবে।
 
-The `Labrador` class receives two arguments, `name` since it extends `Dog`, and `size` as an extra property on the `Labrador` class. They both need to be passed to the constructor function on `Labrador`, which is done correctly using constructor 2.
+`Labrador` ক্লাস দুটি আর্গুমেন্ট নেয়, `name` যেহেতু এটি `Dog` ক্লাসকে এক্সটেন্ড করে এবং `size` কে `Labrador` ক্লাসে একটি অতিরিক্ত প্রোপার্টি হিসাবে এক্সটেন্ড করে। তাদের উভয়কেই `Labrador`-এর কনস্ট্রাক্টর ফাংশনে পাস করতে হবে, যা কনস্ট্রাক্টর 2 ব্যবহার করে সঠিকভাবে করা হয়েছে।
 
 </p>
 </details>
@@ -2145,9 +2145,9 @@ export const sum = (a, b) => a + b;
 
 #### উত্তর: B
 
-With the `import` keyword, all imported modules are _pre-parsed_. This means that the imported modules get run _first_, and the code in the file that imports the module gets executed _after_.
+`import` কীওয়ার্ড ব্যবহৃত হলে, `import` করা সমস্ত মডিউল _প্রি-পার্স_ করা হয়। এর মানে হল যে ইম্পোর্ট করা মডিউলগুলি _প্রথমে_ চালানো হয়, এবং যে ফাইলে মডিউলটি ইম্পোর্ট করা হয় তার কোড _পরবর্তীতে_ চলবে।
 
-This is a difference between `require()` in CommonJS and `import`! With `require()`, you can load dependencies on demand while the code is being run. If we had used `require` instead of `import`, `running index.js`, `running sum.js`, `3` would have been logged to the console.
+এটি CommonJS-এ `require()` এবং `import` এর মধ্যে একটি পার্থক্য! `require()` দিয়ে, কোড চালানোর সময় আপনি প্রয়োজন অনুযায়ী ডিপেন্ডেন্সিগুলো লোড করতে পারেন। আমরা যদি `import` এর পরিবর্তে `require` ব্যবহার করতাম, কনসোলে লগ হতোঃ `running index.js`, `running sum.js`, `3`।
 
 </p>
 </details>
@@ -2172,7 +2172,7 @@ console.log(Symbol('foo') === Symbol('foo'));
 
 #### উত্তর: A
 
-Every Symbol is entirely unique. The purpose of the argument passed to the Symbol is to give the Symbol a description. The value of the Symbol is not dependent on the passed argument. As we test equality, we are creating two entirely new symbols: the first `Symbol('foo')`, and the second `Symbol('foo')`. These two values are unique and not equal to each other, `Symbol('foo') === Symbol('foo')` returns `false`.
+প্রতিটি Symbol সম্পূর্ণ অনন্য। Symbol-এ পাস করা আর্গুমেন্টটির উদ্দেশ্য হল Symbol-টিকে একটি বর্ণনা দেওয়া। Symbol-এর মান পাস করা আর্গুমেন্টের উপর নির্ভর করে না। আমরা সমতা পরীক্ষা করার সময়, আমরা দুটি সম্পূর্ণ নতুন Symbol তৈরি করছি: প্রথম `Symbol('foo')`, এবং দ্বিতীয় `Symbol('foo')`। এই দুটি মান অনন্য এবং একে অপরের সমান নয়, তাই `Symbol('foo') === Symbol('foo')` `false` রিটার্ন করে।
 
 </p>
 </details>
@@ -2197,9 +2197,9 @@ console.log(name.padStart(2));
 
 #### উত্তর: C
 
-With the `padStart` method, we can add padding to the beginning of a string. The value passed to this method is the _total_ length of the string together with the padding. The string `"Lydia Hallie"` has a length of `12`. `name.padStart(13)` inserts 1 space at the start of the string, because 12 + 1 is 13.
+`padStart` পদ্ধতির সাহায্যে, আমরা একটি স্ট্রিংয়ের শুরুতে প্যাডিং (শূন্যস্থান) যোগ করতে পারি। এই পদ্ধতিতে পাস করা মান হল প্যাডিংয়ের সাথে স্ট্রিংয়ের _মোট_ দৈর্ঘ্য। স্ট্রিং `"Lydia Hallie"` এর দৈর্ঘ্য `12`। `name.padStart(13)` স্ট্রিং এর শুরুতে 1টি শূন্যস্থান যুক্ত করার কারনে _মোট_ দৈর্ঘ্য 12 + 1 অর্থাৎ 13 হয়।
 
-If the argument passed to the `padStart` method is smaller than the length of the array, no padding will be added.
+যদি `padStart` পদ্ধতিতে পাস করা আর্গুমেন্ট স্ট্রিং-এর দৈর্ঘ্যের চেয়ে ছোট হয়, তাহলে কোনো প্যাডিং যোগ করা হবে না।
 
 </p>
 </details>
@@ -2222,19 +2222,19 @@ console.log('🥑' + '💻');
 
 #### উত্তর: A
 
-With the `+` operator, you can concatenate strings. In this case, we are concatenating the string `"🥑"` with the string `"💻"`, resulting in `"🥑💻"`.
+`+` অপারেটর দিয়ে, আপনি স্ট্রিং যুক্ত করতে পারেন। এক্ষেত্রে, আমরা স্ট্রিং `"🥑"` কে স্ট্রিং `"💻"` -এর সাথে যুক্ত করছি, যার ফলাফল `"🥑💻"`।
 
 </p>
 </details>
 
 ---
 
-###### 71. How can we log the values that are commented out after the console.log statement?
+###### 71. `console.log` স্ট্যাটম্যান্ট এর পরে কমেন্ট করা ভ্যালুটিকে আমরা কিভাবে লগ করতে পারি?
 
 ```javascript
 function* startGame() {
-  const উত্তর = yield 'Do you love JavaScript?';
-  if (উত্তর !== 'Yes') {
+  const answer = yield 'Do you love JavaScript?';
+  if (answer !== 'Yes') {
     return "Oh wow... Guess we're done here";
   }
   return 'JavaScript loves you back ❤️';
@@ -2255,11 +2255,11 @@ console.log(/* 2 */); // JavaScript loves you back ❤️
 
 #### উত্তর: C
 
-A generator function "pauses" its execution when it sees the `yield` keyword. First, we have to let the function yield the string "Do you love JavaScript?", which can be done by calling `game.next().value`.
+একটি জেনারেটর ফাংশন যখন `yield` কীওয়ার্ডটি দেখে তখন তার চলমান অবস্থায় "বিরতি দেয়" ("pauses" execution)। প্রথমত, আমাদের ফাংশনটি থেকে "Do you love JavaScript?" স্ট্রিংটি পেতে হবে, যা `game.next().value` কল করে পাওয়া যাবে।
 
-Every line is executed, until it finds the first `yield` keyword. There is a `yield` keyword on the first line within the function: the execution stops with the first yield! _This means that the variable `উত্তর` is not defined yet!_
+প্রতিটি লাইন চালনা করা হয়, যতক্ষণ না এটি প্রথম `yield` কীওয়ার্ড খুঁজে পায়। ফাংশনের মধ্যে প্রথম লাইনে একটি `yield` কীওয়ার্ড আছে: প্রথম ফলাফলের (yield) সাথেই এক্সিকিউশন বন্ধ হয়ে যায়! _এর মানে হল `answer` ভেরিয়েবল এখনো ডিফাইন করা হয়নি!_
 
-When we call `game.next("Yes").value`, the previous `yield` is replaced with the value of the parameters passed to the `next()` function, `"Yes"` in this case. The value of the variable `উত্তর` is now equal to `"Yes"`. The condition of the if-statement returns `false`, and `JavaScript loves you back ❤️` gets logged.
+যখন আমরা `game.next("Yes").value` কল করি, তখন আগের `yield`টিকে `next()` ফাংশনে পাস করা প্যারামিটারের মান দিয়ে প্রতিস্থাপিত করা হয়, এই ক্ষেত্রে `"Yes"` দিয়ে। ভেরিয়েবল `answer` এর মান এখন `"Yes"` এর সমান। ইফ-স্ট্যাটম্যান্টের শর্ত `false` রিটার্ন করে এবং `JavaScript loves you back ❤️` লগ হয়ে যায়।
 
 </p>
 </details>
@@ -2282,19 +2282,19 @@ console.log(String.raw`Hello\nworld`);
 
 #### উত্তর: C
 
-`String.raw` returns a string where the escapes (`\n`, `\v`, `\t` etc.) are ignored! Backslashes can be an issue since you could end up with something like:
+`String.raw` একটি স্ট্রিং রিটার্ন করে যেখানে এস্কেপ ক্যারেক্টার (`\n`, `\v`, `\t` ইত্যাদি) উপেক্ষা করা হয়! ব্যাকস্ল্যাশগুলি একটি সমস্যা হতে পারে যখন আপনি এমন কিছু পাবেন:
 
 `` const path = `C:\Documents\Projects\table.html` ``
 
-Which would result in:
+যার ফলে আউটপুট হবে:
 
 `"C:DocumentsProjects able.html"`
 
-With `String.raw`, it would simply ignore the escape and print:
+`String.raw` ব্যবহার করলে, এটি কেবল এস্কেপ ক্যারেক্টার উপেক্ষা করবে এবং প্রিন্ট করবে:
 
 `C:\Documents\Projects\table.html`
 
-In this case, the string is `Hello\nworld`, which gets logged.
+এই ক্ষেত্রে, লগ হওয়া স্ট্রিংটি হল `Hello\nworld`।
 
 </p>
 </details>
@@ -2322,13 +2322,13 @@ console.log(data);
 
 #### উত্তর: C
 
-An async function always returns a promise. The `await` still has to wait for the promise to resolve: a pending promise gets returned when we call `getData()` in order to set `data` equal to it.
+একটি **async** ফাংশন সর্বদা একটি প্রতিশ্রুতি (promise) রিটার্ন করে। প্রমিস সমাধানের (resolve) জন্য `await`কে এখনও অপেক্ষা করতে হচ্ছে: যখন `getData()` কল করে এটির মানকে `data`-র সমান সেট করা হয় তখন আসলে একটি অমীমাংসিত (pending) প্রমিস রিটার্ন ভ্যালু হিসেবে পাওয়া যায়।
 
-If we wanted to get access to the resolved value `"I made it"`, we could have used the `.then()` method on `data`:
+যদি আমরা প্রমিস সমাধানের ভ্যালুর - `"I made it"` অ্যাক্সেস পেতে চাইতাম, তাহলে `data`-তে `.then()` মেথড ব্যবহার করতে হত:
 
 `data.then(res => console.log(res))`
 
-This would've logged `"I made it!"`
+তবেই এটি লগ করত `"I made it!"`৷
 
 </p>
 </details>
@@ -2356,9 +2356,9 @@ console.log(result);
 
 #### উত্তর: B
 
-The `.push()` method returns the _length_ of the new array! Previously, the array contained one element (the string `"banana"`) and had a length of `1`. After adding the string `"apple"` to the array, the array contains two elements, and has a length of `2`. This gets returned from the `addToList` function.
+`.push()` মেথড নতুন অ্যারের _length_ রিটার্ন করে! পূর্বে, অ্যারেতে একটি এলিমেন্ট ছিল (স্ট্রিং `"banana"`) এবং এর দৈর্ঘ্য ছিল `1`। অ্যারেতে স্ট্রিং `"apple"` যোগ করার পর, অ্যারের মোট এলিমেন্ট হয় দুটি এবং এর দৈর্ঘ্য হয় `2`। এটিই 'addToList' ফাংশন থেকে রিটার্ন আসছে।
 
-The `push` method modifies the original array. If you wanted to return the _array_ from the function rather than the _length of the array_, you should have returned `list` after pushing `item` to it.
+`push` মেথডটি মূল অ্যারেকে পরিবর্তন করে। আপনি যদি _অ্যারের দৈর্ঘ্যে_-র পরিবর্তে ফাংশন থেকে _array_-টি রিটার্ন চাইতেন, তাহলে `item`-কে পুশ করার পরে আপনার উচিত ছিল `list`-কে রিটার্ন করা।
 
 </p>
 </details>
@@ -2388,11 +2388,11 @@ console.log(shape);
 
 #### উত্তর: B
 
-`Object.freeze` makes it impossible to add, remove, or modify properties of an object (unless the property's value is another object).
+`Object.freeze` অবজেক্টে কোন প্রোপার্টি যোগ, বাদ বা সংশোধন করা অসম্ভব করে তোলে (যদি না প্রোপার্টির মান অন্য কোনো অবজেক্ট হয়)।
 
-When we create the variable `shape` and set it equal to the frozen object `box`, `shape` also refers to a frozen object. You can check whether an object is frozen by using `Object.isFrozen`. In this case, `Object.isFrozen(shape)` would return true, since the variable `shape` has a reference to a frozen object.
+যখন আমরা ভেরিয়েবল `shape` তৈরি করি এবং তাকে ফ্রোজেন অবজেক্ট `box` এর সমান সেট করি, `shape`-ও সেই ফ্রোজেন অবজেক্টকে রেফার করে। আপনি `Object.isFrozen` ব্যবহার করে কোনো অবজেক্ট ফ্রোজেন হয়েছে কিনা তা পরীক্ষা করতে পারেন। এই ক্ষেত্রে, `Object.isFrozen(shape)` true রিটার্ন করবে, কারন ভেরিয়েবল `shape`-এর কাছে একটি ফ্রোজেন অবজেক্টের রেফারেন্স আছে।
 
-Since `shape` is frozen, and since the value of `x` is not an object, we cannot modify the property `x`. `x` is still equal to `10`, and `{ x: 10, y: 20 }` gets logged.
+যেহেতু `shape` ফ্রোজেন হয়েছে, এবং `x` এর মান কোনো অবজেক্ট নয়, তাই আমরা `x` প্রোপার্টিকে পরিবর্তন করতে পারি না। `x` এখনও `10` এর সমান, এবং `{ x: 10, y: 20 }` লগ করা হয়েছে।
 
 </p>
 </details>
@@ -2417,7 +2417,7 @@ console.log(firstName);
 
 #### উত্তর: D
 
-By using [destructuring assignment](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment) syntax we can unpack values from arrays, or properties from objects, into distinct variables:
+[ডিস্ট্রাকচারিং অ্যাসাইনমেন্ট](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment) সিনট্যাক্স ব্যবহার করে, আমরা অ্যারের ভ্যালু, বা অবজেক্টের প্রোপার্টি বের করে আলাদা ভ্যারিয়েবলে রাখতে পারিঃ
 
 ```javascript
 const { firstName } = { firstName: 'Lydia' };
@@ -2427,7 +2427,7 @@ const { firstName } = { firstName: 'Lydia' };
 console.log(firstName); // "Lydia"
 ```
 
-Also, a property can be unpacked from an object and assigned to a variable with a different name than the object property:
+আবার, অবজেক্ট থেকে প্রোপার্টি বের করে অবজেক্টের ঐ প্রোপার্টির নামে না রেখে অন্য নামের ভ্যারিয়েবলেও রাখতে পারিঃ
 
 ```javascript
 const { firstName: myName } = { firstName: 'Lydia' };
@@ -2438,9 +2438,9 @@ console.log(myName); // "Lydia"
 console.log(firstName); // Uncaught ReferenceError: firstName is not defined
 ```
 
-Therefore, `firstName` does not exist as a variable, thus attempting to access its value will raise a `ReferenceError`.
+অতএব, `firstName` একটি ভেরিয়েবল হিসেবে আর নেই, এইভাবে এর মান অ্যাক্সেস করার চেষ্টা করলে `ReferenceError` তৈরি হবে।
 
-**Note:** Be aware of the `global scope` properties:
+**দ্রষ্টব্য:** `গ্লোবাল স্কোপ` বৈশিষ্ট্য সম্পর্কে সচেতন থাকুন:
 
 ```javascript
 const { name: myName } = { name: 'Lydia' };
@@ -2450,18 +2450,18 @@ console.log(name); // "" ----- Browser e.g. Chrome
 console.log(name); // ReferenceError: name is not defined  ----- NodeJS
 ```
 
-Whenever Javascript is unable to find a variable within the _current scope_, it climbs up the [Scope chain](https://github.com/getify/You-Dont-Know-JS/blob/2nd-ed/scope-closures/ch3.md) and searches for it and if it reaches the top-level scope, aka **Global scope**, and still doesn't find it, it will throw a `ReferenceError`.
+জাভাস্ক্রিপ্ট যখনই একটি ভেরিয়েবলকে তার _বর্তমান স্কোপে_ খুঁজে পায় না, তখন এটিকে খুঁজে পাওয়ার জন্য [স্কোপ চেইন](https://github.com/getify/You-Dont-Know-JS/blob/2nd-ed/scope-closures/ch3.md)-এর উপরে ওঠে এবং যদি এটি শীর্ষ-স্তরের স্কোপে পৌঁছায়, ওরফে **গ্লোবাল স্কোপ**, এবং এখানেও খুঁজে না পায়, তাহলে এটি একটি `ReferenceError` থ্রো করবে।
 
-- In **Browsers** such as _Chrome_, `name` is a _deprecated global scope property_. In this example, the code is running inside _global scope_ and there is no user-defined local variable for `name`, therefore it searches the predefined _variables/properties_ in the global scope which is in the case of browsers, it searches through `window` object and it will extract the [window.name](https://developer.mozilla.org/en-US/docs/Web/API/Window/name) value which is equal to an **empty string**.
+- **ব্রাউজারে** যেমন _Chrome_, `name` হল একটি _ডেপ্রিকেটেড গ্লোবাল স্কোপ প্রপার্টি_। এই উদাহরনে, কোডটি _global scope_ এর ভিতরে চলছে এবং `name` এর জন্য কোনো ইউজার-ডিফাইন্ড লোকাল ভেরিয়েবল নেই, তাই এটি পূর্বনির্ধারিত _ভেরিয়েবল/প্রোপার্টি_ গ্লোবাল স্কোপে খুঁজে দেখে যা ব্রাউজারের ক্ষেত্রে, `window` অবজেক্টের ভেতরে খুঁজবে এবং এটি [window.name](https://developer.mozilla.org/en-US/docs/Web/API/Window/name) মানটি বের করবে একটি **খালি স্ট্রিং** এর সমান।
 
-- In **NodeJS**, there is no such property on the `global` object, thus attempting to access a non-existent variable will raise a [ReferenceError](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Not_defined).
+- **নোডজেএস**-এ, `গ্লোবাল` অবজেক্টে এমন কোনো প্রপার্টি নেই, এইভাবে অস্তিত্বহীন ভেরিয়েবল অ্যাক্সেস করার চেষ্টা করলে একটি [ReferenceError](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Not_defined) তৈরি হয়।
 
 </p>
 </details>
 
 ---
 
-###### 77. Is this a pure function?
+###### 77. এটি কি একটি বিশুদ্ধ ফাংশন?
 
 ```javascript
 function sum(a, b) {
@@ -2477,9 +2477,9 @@ function sum(a, b) {
 
 #### উত্তর: A
 
-A pure function is a function that _always_ returns the same result, if the same arguments are passed.
+একটি বিশুদ্ধ ফাংশন হল এমন একটি ফাংশন যা _সবসময়_ একই ফলাফল প্রদান করে, যদি একই আর্গুমেন্ট পাস করা হয়।
 
-The `sum` function always returns the same result. If we pass `1` and `2`, it will _always_ return `3` without side effects. If we pass `5` and `10`, it will _always_ return `15`, and so on. This is the definition of a pure function.
+`sum` ফাংশন সবসময় একই ফলাফল প্রদান করে। যদি আমরা `1` এবং `2` পাস করি, এটি _সবসময়_ পার্শ্ব প্রতিক্রিয়া ছাড়াই `3` রিটার্ন করে। যদি আমরা `5` এবং `10` পাস করি, তাহলে এটি _সবসময়_ `15` রিটার্ন করে, ইত্যাদি। এটিই হলো একটি বিশুদ্ধ ফাংশনের সংজ্ঞা।
 
 </p>
 </details>
@@ -2518,15 +2518,17 @@ console.log(addFunction(5 * 2));
 
 #### উত্তর: C
 
-The `add` function is a _memoized_ function. With memoization, we can cache the results of a function in order to speed up its execution. In this case, we create a `cache` object that stores the previously returned values.
+`add` ফাংশনটি একটি _memoized_ ফাংশন। মেমোাআইজেশনের সাহায্যে, আমরা একটি ফাংশনের ফলাফলগুলি ক্যাশ করতে পারি (ভবিষ্যতে ব্যবহারের জন্য আলাদাভাবে সংরক্ষণ করার পদ্ধতি) যাতে এটি কার্যকর করার (execution) গতি বাড়ানো যায়। এই ক্ষেত্রে, আমরা একটি `cache` অবজেক্ট তৈরি করেছি যা পূর্বের রিটার্ন করা ভ্যালুগুলো সংরক্ষণ করে।
 
-If we call the `addFunction` function again with the same argument, it first checks whether it has already gotten that value in its cache. If that's the case, the cache value will be returned, which saves execution time. Otherwise, if it's not cached, it will calculate the value and store it afterward.
+> যেহেতু এখানে `add` ফাংশনটি অন্য একটি ফাংশনকে রিটার্ন করছে যে তার স্কোপের বাহিরের ভ্যালু,`cache` অবজেক্টকে, এক্সেস করছে। ফলে এখানে একটি [ক্লোজার](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Closures) তৈরি হয়েছে।
 
-We call the `addFunction` function three times with the same value: on the first invocation, the value of the function when `num` is equal to `10` isn't cached yet. The condition of the if-statement `num in cache` returns `false`, and the else block gets executed: `Calculated! 20` gets logged, and the value of the result gets added to the cache object. `cache` now looks like `{ 10: 20 }`.
+যদি আমরা একই আর্গুমেন্টের সাথে আবার `addFunction` ফাংশনকে কল করি, এটি প্রথমে পরীক্ষা করে যে সেই ভ্যালুটি ইতিমধ্যে cache-থেকে পেয়েছে কিনা। যদি পায়, cache-থেকেই রিটার্ন করা হবে, যা এক্সিকিউশনের সময় বাঁচায়। অন্যথায়, cache-থেকে না পেলে, এটি গণনা করে প্রাপ্ত ভ্যালুটি সংরক্ষণ করবে।
 
-The second time, the `cache` object contains the value that gets returned for `10`. The condition of the if-statement `num in cache` returns `true`, and `'From cache! 20'` gets logged.
+আমরা একই ভ্যালু দিয়ে `addFunction` ফাংশনকে কল করছি ৩ বারঃ ১ম কলের সময়, ফাংশনের ভ্যালু cache-এ নেই যখন `num` সমান সমান হয় `10`। ইফ-স্টেটম্যান্টের শর্ত `num in cache` রিটার্ন করে `false`, এবং এলস ব্লক এক্সিকিউট হয়েছেঃ `Calculated! 20` লগ হয়, এবং result-এর ভ্যালু cache অবজেক্টে সংরক্ষিত হয়। `cache` এখন হয় - `{ 10: 20 }`।
 
-The third time, we pass `5 * 2` to the function which gets evaluated to `10`. The `cache` object contains the value that gets returned for `10`. The condition of the if-statement `num in cache` returns `true`, and `'From cache! 20'` gets logged.
+২য় বারে, `cache` অবজেক্টে `10` এর জন্য যে ভ্যালুটি রিটার্ন করা হয়েছিলো সেটি আছে। ইফ-স্টেটম্যানন্টের শর্ত `num in cache` রিটার্ন করে `true`, এবং লগ হয় `'From cache! 20'`।
+
+৩য় বারে, ফাংশনে আমরা পাস করেছি `5 * 2` যেটা মূল্যায়িত হয় `10`। `cache` অবজেক্টে `10` এর জন্য যে ভ্যালুটি রিটার্ন করা হয়েছিলো সেটি আছে। ইফ-স্টেটম্যানন্টের শর্ত `num in cache` রিটার্ন করে `true`, এবং লগ হয় `'From cache! 20'`।
 
 </p>
 </details>
@@ -2557,13 +2559,13 @@ for (let item of myLifeSummedUp) {
 
 #### উত্তর: A
 
-With a _for-in_ loop, we can iterate over **enumerable** properties. In an array, the enumerable properties are the "keys" of array elements, which are actually their indexes. You could see an array as:
+একটি _for-in_ লুপ দিয়ে, আমরা **গণনাযোগ্য (enumerable)** প্রোপার্টির উপর লুপ চালাতে পারি। অ্যারেতে গণনাযোগ্য প্রোপার্টিগুলো হয় অ্যারের এলিমেন্টের "কী", যা আসলে তাদের ইনডেক্স। আপনি অ্যারেটিকে দেখতে পাবেন এমন:
 
 `{0: "☕", 1: "💻", 2: "🍷", 3: "🍫"}`
 
-Where the keys are the enumerable properties. `0` `1` `2` `3` get logged.
+যেখানে কীগুলি গণনাযোগ্য প্রোপার্টি। তাই `0` `1` `2` `3` লগ হয়েছে।
 
-With a _for-of_ loop, we can iterate over **iterables**. An array is an iterable. When we iterate over the array, the variable "item" is equal to the element it's currently iterating over, `"☕"` `"💻"` `"🍷"` `"🍫"` get logged.
+একটি _for-of_ লুপ দিয়ে, আমরা **পুনরাবৃত্তিযোগ্য (iteables)** এর উপর লুপ চালাতে পারি। অ্যারে পুনরাবৃত্তিযোগ্য। যখন আমরা অ্যারের উপর লুপ চালাই, তখন "item" ভেরিয়েবলটি বর্তমানে পুনরাবৃত্তি হচ্ছে সেই এলিমেন্টের সমান। তাই `"☕"` `"💻"` `"🍷"` `"🍫"` লগ হয়েছে।
 
 </p>
 </details>
@@ -2587,9 +2589,9 @@ console.log(list);
 
 #### উত্তর: C
 
-Array elements can hold any value. Numbers, strings, objects, other arrays, null, boolean values, undefined, and other expressions such as dates, functions, and calculations.
+অ্যারে এলিমেন্টগুলো যেকোন টাইপের ভ্যালু রাখতে পারে। নাম্বার, স্ট্রিং, অঞ্জেক্ট, অন্য অ্যারে, নাল, বুলিয়ান, আন্ডিফাইন্ড, এবং অন্যান্য এক্সপ্রেশন যেমন, তারিখ, ফাংশন, ও যেগুলো গননা যোগ্য।
 
-The element will be equal to the returned value. `1 + 2` returns `3`, `1 * 2` returns `2`, and `1 / 2` returns `0.5`.
+এলিমেন্টগুলো সমান হবে তার রিটার্ন ভ্যালু। `1 + 2` রিটার্ন করে `3`, `1 * 2` রিটার্ন করে `2`, এবং `1 / 2` রিটার্ন করে `0.5`।
 
 </p>
 </details>

From dcc887f101c631e38b354b39dea6305acb91e823 Mon Sep 17 00:00:00 2001
From: iamsaief <saiefalemon@gmail.com>
Date: Tue, 4 Jun 2024 07:54:11 +0600
Subject: [PATCH 06/12] added translation till 90

---
 bn-BD/README_bn-BD.md | 64 +++++++++++++++++++++----------------------
 1 file changed, 32 insertions(+), 32 deletions(-)

diff --git a/bn-BD/README_bn-BD.md b/bn-BD/README_bn-BD.md
index f292c293..ac3379fe 100644
--- a/bn-BD/README_bn-BD.md
+++ b/bn-BD/README_bn-BD.md
@@ -2486,7 +2486,7 @@ function sum(a, b) {
 
 ---
 
-###### 78. What is the output?
+###### 78. এটার আউটপুট কোনটা?
 
 ```javascript
 const add = () => {
@@ -2535,7 +2535,7 @@ console.log(addFunction(5 * 2));
 
 ---
 
-###### 79. What is the output?
+###### 79. এটার আউটপুট কোনটা?
 
 ```javascript
 const myLifeSummedUp = ['☕', '💻', '🍷', '🍫'];
@@ -2572,7 +2572,7 @@ for (let item of myLifeSummedUp) {
 
 ---
 
-###### 80. What is the output?
+###### 80. এটার আউটপুট কোনটা?
 
 ```javascript
 const list = [1 + 2, 1 * 2, 1 / 2];
@@ -2598,7 +2598,7 @@ console.log(list);
 
 ---
 
-###### 81. What is the output?
+###### 81. এটার আউটপুট কোনটা?
 
 ```javascript
 function sayHi(name) {
@@ -2618,20 +2618,20 @@ console.log(sayHi());
 
 #### উত্তর: B
 
-By default, arguments have the value of `undefined`, unless a value has been passed to the function. In this case, we didn't pass a value for the `name` argument. `name` is equal to `undefined` which gets logged.
+ডিফল্টভাবে, আর্গুমেন্টগুলোর ভ্যালু থাকে `undefined`, যদি ফাংশনে কোন একটি ভ্যালু পাস করা না হয়। এক্ষেত্রে, আমরা `name` আর্গুমেন্টের জন্য কোন ভ্যালু পাস করি নি। `name` সমান হয় `undefined`, যেটি লগ হয়েছে।
 
-In ES6, we can overwrite this default `undefined` value with default parameters. For example:
+ইএস৬ এ, আমরা এই ডিফল্ট ভ্যালু `undefined` কে ওভাররাইট করতে পারি ডিফল্ট প্যারামিটার দিয়ে। উদাহরনসরূপঃ
 
 `function sayHi(name = "Lydia") { ... }`
 
-In this case, if we didn't pass a value or if we passed `undefined`, `name` would always be equal to the string `Lydia`
+এক্ষেত্রে, আমরা যদি কোন একটি ভ্যালু পাস না করি বা `undefined` পাস করি, `name` এর ভ্যালু সবসময় `Lydia` স্ট্রিংটির সমান হবে।
 
 </p>
 </details>
 
 ---
 
-###### 82. What is the output?
+###### 82. এটার আউটপুট কোনটা?
 
 ```javascript
 var status = '😎';
@@ -2661,16 +2661,16 @@ setTimeout(() => {
 
 #### উত্তর: B
 
-The value of the `this` keyword is dependent on where you use it. In a **method**, like the `getStatus` method, the `this` keyword refers to _the object that the method belongs to_. The method belongs to the `data` object, so `this` refers to the `data` object. When we log `this.status`, the `status` property on the `data` object gets logged, which is `"🥑"`.
+`this` কীওয়ার্ডের মান নির্ভর করে আপনি এটি কোথায় ব্যবহার করছেন তার উপর। একটি **মেথডে**-এ, যেমন `getStatus` মেথডে, `this` কীওয়ার্ডটি _সেই অবজেক্টকে বোঝায় মেথডটি যার ভেতরে থাকে_। মেথডটি `data` অবজেক্টের অন্তর্গত, `this` তাই `data` অবজেক্টকে রেফার করে। যখন আমরা `this.status` লগ করি, `data` অবজেক্টের `status` প্রোপার্টি লগ হয়, যার ভ্যালু `"🥑"`।
 
-With the `call` method, we can change the object to which the `this` keyword refers. In **functions**, the `this` keyword refers to the _the object that the function belongs to_. We declared the `setTimeout` function on the _global object_, so within the `setTimeout` function, the `this` keyword refers to the _global object_. On the global object, there is a variable called _status_ with the value of `"😎"`. When logging `this.status`, `"😎"` gets logged.
+`call` মেথডের মাধ্যমে, আমরা অবজেক্টকে পরিবর্তন করতে পারি `this` কীওয়ার্ডটি যাকে রেফার করে। **ফাংশন**-এ, `this` কীওয়ার্ডটি _সেই অবজেক্টকে বোঝায় যেটি ফাংশনটির অন্তর্গত_। আমরা _গ্লোবাল অবজেক্ট_-এ `setTimeout` ফাংশন ডিক্লেয়ার করেছি, তাই `setTimeout` ফাংশনের মধ্যে, `this` কীওয়ার্ডটি _গ্লোবাল অবজেক্ট_ কে রেফার করে। গ্লোবাল অবজেক্টে, _status_ নামক একটি ভেরিয়েবল আছে যার ভ্যালু `"😎"`। তাই `this.status` লগ করায় `"😎"` লগ হয়।
 
 </p>
 </details>
 
 ---
 
-###### 83. What is the output?
+###### 83. এটার আউটপুট কোনটা?
 
 ```javascript
 const person = {
@@ -2694,20 +2694,20 @@ console.log(person);
 
 #### উত্তর: A
 
-We set the variable `city` equal to the value of the property called `city` on the `person` object. There is no property on this object called `city`, so the variable `city` has the value of `undefined`.
+আমরা `city` ভ্যারিয়েবলের ভ্যালু সমান সেট করছি `person` অবজেক্টের `city` নামক প্রোপার্টির ভ্যালুকে। এই অবজেক্টে `city` নামক কোন প্রোপার্টি নেই, তাই `city` ভ্যারিয়েবলের ভ্যালু থাকছে `undefined`।
 
-Note that we are _not_ referencing the `person` object itself! We simply set the variable `city` equal to the current value of the `city` property on the `person` object.
+খেয়াল করুন আমরা কিন্তু `person` অবজেক্টিকে রেফারেন্স (নির্দেশ) _করছি না_! আমরা সাধারন ভাবেই `city` ভ্যারিয়েবলের ভ্যালু সমান সেট করছি `person` অবজেক্টের `city` নামক প্রোপার্টির বর্তমান ভ্যালুকে।
 
-Then, we set `city` equal to the string `"Amsterdam"`. This doesn't change the person object: there is no reference to that object.
+পরবর্তিতে, `city` সমান সেট করছি একটি স্ট্রিং-`"Amsterdam"`। এটা person অবজেক্টে কোন পরিবর্তন করছে নাঃ এখানে ঐ অবজেক্টের কোন রেফারেন্স নেই।
 
-When logging the `person` object, the unmodified object gets returned.
+যখন `person` অবজেক্টিকে লগ করা হয়েছে, অপরিবর্তিত অবজেক্টিই রিটার্ন হয়েছে।
 
 </p>
 </details>
 
 ---
 
-###### 84. What is the output?
+###### 84. এটার আউটপুট কোনটা?
 
 ```javascript
 function checkAge(age) {
@@ -2733,14 +2733,14 @@ console.log(checkAge(21));
 
 #### উত্তর: C
 
-Variables with the `const` and `let` keywords are _block-scoped_. A block is anything between curly brackets (`{ }`). In this case, the curly brackets of the if/else statements. You cannot reference a variable outside of the block it's declared in, a ReferenceError gets thrown.
+`const` ও `let` কিওয়ার্ড দিয়ে ভ্যারিয়েবলগুলো হয় _ব্লক-স্কোপড_। একটি ব্লক হলো কার্লি ব্র্যাকেটের (`{ }`) ভেতরের যেকোন কিছুই। এক্ষেত্রে, ইফ-এলস স্টেটমেন্টের কার্লি ব্র্যাকেট। আপনি কোন ভ্যারিয়েবলকে যে ব্লকে তাদের ডিক্লেয়ার করা হয়েছে তার বাইরে থেকে রেফারেন্স করতে পারবেন না, একটি ReferenceError হয়।
 
 </p>
 </details>
 
 ---
 
-###### 85. What kind of information would get logged?
+###### 85. এখানে কি ধরনের তথ্য লগ হতে পারে?
 
 ```javascript
 fetch('https://www.website.com/api/user/1')
@@ -2758,14 +2758,14 @@ fetch('https://www.website.com/api/user/1')
 
 #### উত্তর: C
 
-The value of `res` in the second `.then` is equal to the returned value of the previous `.then`. You can keep chaining `.then`s like this, where the value is passed to the next handler.
+২য় `.then`-এ `res` এর ভ্যালু পূর্ববর্তী `.then`-এর রিটার্ন করা ভ্যালুর সমান। আপনি এভাবে `.then`-গুলোর চেইন করতে পারেন, যেখানে বর্তমান ভ্যালুটি পরবর্তী হ্যান্ডলারের কাছে চলে যায়।
 
 </p>
 </details>
 
 ---
 
-###### 86. Which option is a way to set `hasName` equal to `true`, provided you cannot pass `true` as an argument?
+###### 86. কোন অপশনটি `hasName` কে `true` এর সমান সেট করার একটি উপায়, যদি আপনি `true` কে একটি আর্গুমেন্ট হিসেবে পাস করতে না পারেন?
 
 ```javascript
 function getName(name) {
@@ -2783,13 +2783,13 @@ function getName(name) {
 
 #### উত্তর: A
 
-With `!!name`, we determine whether the value of `name` is truthy or falsy. If the name is truthy, which we want to test for, `!name` returns `false`. `!false` (which is what `!!name` practically is) returns `true`.
+A-র ক্ষেত্রে, `!!name` দিয়ে, আমরা নির্ধারণ করি `name` এর ভ্যালু সত্য নাকি মিথ্যা। যদি নামটি সত্য হয়, যার জন্য আমরা পরীক্ষা করতে চাই, `!name` রিটার্ন করে `false`। `!false` (যেটি বাস্তবিকভাবেই `!!name`) রিটার্ন করে `true`।
 
-By setting `hasName` equal to `name`, you set `hasName` equal to whatever value you passed to the `getName` function, not the boolean value `true`.
+B-র ক্ষেত্রে, `hasName` সমান `name` সেট করার মাধ্যমে, আপনি `hasName` সমান করছেন `getName` ফাংশনে পাস করা যেকোন ভ্যালু, বুলিয়ান `true` ভ্যালু নয়।
 
-`new Boolean(true)` returns an object wrapper, not the boolean value itself.
+C-র ক্ষেত্রে, `new Boolean(true)` একটি অবজেক্ট র‍্যাপার রিটার্ন করে, তার বুলিয়ান ভ্যালুকে নয়।
 
-`name.length` returns the length of the passed argument, not whether it's `true`.
+D-র ক্ষেত্রে, `name.length` রিটার্ন করে পাস করা আর্গুমেন্টের দৈর্ঘ্য, এটি `true` কিনা তা নয়।
 
 </p>
 </details>
@@ -2812,9 +2812,9 @@ console.log('I want pizza'[0]);
 
 #### উত্তর: B
 
-In order to get a character at a specific index of a string, you can use bracket notation. The first character in the string has index 0, and so on. In this case, we want to get the element with index 0, the character `"I'`, which gets logged.
+স্ট্রি-এর কোন নির্দিষ্ট ইনডেক্সের অক্ষরকে পাওয়ার জন্য, আপনি ব্র্যাকেট নোটেশন ব্যবহার করতে পারেন। স্ট্রি-এর ১ম অক্ষরের ইনডেক্স হয় 0, এবং এভাবে পরের ইনডেক্সগুলোতে বাকি অক্ষরগুলো থাকে। এক্ষেত্রে, আমরা 0 ইনডেক্সের এলিমেন্টকে পেতে চাচ্ছি, `"I'` অক্ষরটি, যেটা লগ হয়েছে।
 
-Note that this method is not supported in IE7 and below. In that case, use `.charAt()`.
+মনে রাখবেন যে এই মেথডটি IE7 এবং নীচে সাপোর্ট করে না। সেক্ষেত্রে `.charAt()` ব্যবহার করুন।
 
 </p>
 </details>
@@ -2841,9 +2841,9 @@ sum(10);
 
 #### উত্তর: B
 
-You can set a default parameter's value equal to another parameter of the function, as long as they've been defined _before_ the default parameter. We pass the value `10` to the `sum` function. If the `sum` function only receives 1 argument, it means that the value for `num2` is not passed, and the value of `num1` is equal to the passed value `10` in this case. The default value of `num2` is the value of `num1`, which is `10`. `num1 + num2` returns `20`.
+আপনি ফাংশনের ডিফল্ট প্যারামিটারের ভ্যালুকে সমান অন্য প্যারামিটার করতে পারবেন, যতক্ষণ পর্যন্ত তারা ডিফল্ট প্যারামিটারের _আগে_ ডিফাইন করা থাকে। আমরা `sum` ফাংশনে `10` ভ্যালুকে পাস করছি। যদি `sum` ফাংশন একটি আর্গুমেন্ট রিসিভ করে, এর মানে হলো `num2` এর ভ্যালু পাস করা হয়নি, এবং `num1` এর ভ্যালু সমান হল পাস করা ভ্যালুটি `10` এক্ষেত্রে। `num2` এর ডিফল্ট ভ্যালু হল `num1`, যেটা `10`। `num1 + num2` রিটার্ন করেছে `20`।
 
-If you're trying to set a default parameter's value equal to a parameter that is defined _after_ (to the right), the parameter's value hasn't been initialized yet, which will throw an error.
+যদি আপনি ডিফল্ট প্যারামিটারের ভ্যালুকে সমান অন্য প্যারামিটার করতে চান যেটা _পরে_ ডিফাইন করা হয়েছে (ডান পাশের প্যারামিটার), প্যারামিটারের ভ্যালুটি তখনো ইনিশিয়ালাইজ (ভ্যালু সেট করা) হয় নি, সেটি একটি এরর থ্রো করবে।
 
 </p>
 </details>
@@ -2873,9 +2873,9 @@ console.log(data);
 
 #### উত্তর: A
 
-With the `import * as name` syntax, we import _all exports_ from the `module.js` file into the `index.js` file as a new object called `data` is created. In the `module.js` file, there are two exports: the default export, and a named export. The default export is a function that returns the string `"Hello World"`, and the named export is a variable called `name` which has the value of the string `"Lydia"`.
+`import * as name` সিনট্যাক্স দিয়ে, আমরা `module.js` ফাইল থেকে _সকল এক্সপোর্ট_-গুলোকে `index.js` ফাইলে ইম্পোর্ট করছি `data` নামের একটি নতুন অবজেক্ট হিসেবে। `module.js` ফাইলে, দুটি এক্সপোর্ট আছেঃ ডিফল্ট এক্সপোর্ট ও একটি নেমড এক্সপোর্ট। ডিফল্ট এক্সপোর্টটি একটি অ্যারো ফাংশন যে `"Hello World"` স্ট্রিংটি রিটার্ন করছে, এবং নেমড এক্সপোর্টটি হল `name` নামের এটি ভ্যারিয়েবল যেটির ভ্যালু হল `"Lydia"` স্ট্রিংটি।
 
-The `data` object has a `default` property for the default export, other properties have the names of the named exports and their corresponding values.
+`data` অবজেক্টটিতে ডিফল্ট এক্সপোর্টের জন্য একটি প্রোপার্টি আছে `default`, অন্যান্য প্রোপার্টিতে আছে নেমড এক্সপোর্টের নামগুলো ও তাদের সংশ্লিষ্ট ভ্যালু।
 
 </p>
 </details>
@@ -2905,7 +2905,7 @@ console.log(typeof member);
 
 #### উত্তর: C
 
-Classes are syntactical sugar for function constructors. The equivalent of the `Person` class as a function constructor would be:
+ক্লাসগুলি হলো ফাংশন কনস্ট্রাক্টরদের জন্য _সিনট্যাক্টিক সুগার_। একটি ফাংশন কনস্ট্রাক্টর হিসেবে `Person` ক্লাসের সমতুল্য হবে এমন:
 
 ```javascript
 function Person(name) {
@@ -2913,7 +2913,7 @@ function Person(name) {
 }
 ```
 
-Calling a function constructor with `new` results in the creation of an instance of `Person`, `typeof` keyword returns `"object"` for an instance. `typeof member` returns `"object"`.
+একটি ফাংশন কনস্ট্রাক্টরকে `new` কীওয়ার্ড দিয়ে কল করার ফলে `Person` এর একটি উদাহরন/নিদর্শন (instance) তৈরি হয়, `typeof` কীওয়ার্ড একটি ইন্সট্যান্সের জন্য `"object"` রিটার্ন করে। `typeof member` রিটার্ন করে `"object"`, যেটা লগ হয়।
 
 </p>
 </details>

From beac838386130f8cb2e449c58509fd91755216bb Mon Sep 17 00:00:00 2001
From: iamsaief <saiefalemon@gmail.com>
Date: Fri, 7 Jun 2024 09:10:31 +0600
Subject: [PATCH 07/12] =?UTF-8?q?added=20translation=20till=20100!=20?=
 =?UTF-8?q?=F0=9F=8E=89=E2=9C=A8?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 bn-BD/README_bn-BD.md | 60 ++++++++++++++++++++++---------------------
 1 file changed, 31 insertions(+), 29 deletions(-)

diff --git a/bn-BD/README_bn-BD.md b/bn-BD/README_bn-BD.md
index ac3379fe..3a1c2292 100644
--- a/bn-BD/README_bn-BD.md
+++ b/bn-BD/README_bn-BD.md
@@ -2938,9 +2938,9 @@ console.log(newList.push(5));
 
 #### উত্তর: D
 
-The `.push` method returns the _new length_ of the array, not the array itself! By setting `newList` equal to `[1, 2, 3].push(4)`, we set `newList` equal to the new length of the array: `4`.
+`.push` মেথড অ্যারের নতুন দৈর্ঘ্য ফেরত দেয়, অ্যারেটিকে নয়! `newList` কে `[1, 2, 3].push(4)` এর সমান সেট করার মাধ্যমে আমরা `newList` কে অ্যারের নতুন দৈর্ঘ্য `4` এর সমান করেছি।
 
-Then, we try to use the `.push` method on `newList`. Since `newList` is the numerical value `4`, we cannot use the `.push` method: a TypeError is thrown.
+তারপর, আমরা `.push` মেথডকে `newList` এ ব্যবহার করার চেষ্টা করি। যেহেতু `newList` হল একটি সংখ্যাগত মান `4`, তাই আমরা `.push` মেথড ব্যবহার করতে পারি না: একটি টাইপ এরর (TypeError) প্রদর্শিত হয়।
 
 </p>
 </details>
@@ -2971,7 +2971,7 @@ console.log(giveLydiaChocolate.prototype);
 
 #### উত্তর: D
 
-Regular functions, such as the `giveLydiaPizza` function, have a `prototype` property, which is an object (prototype object) with a `constructor` property. Arrow functions however, such as the `giveLydiaChocolate` function, do not have this `prototype` property. `undefined` gets returned when trying to access the `prototype` property using `giveLydiaChocolate.prototype`.
+সাধারণ ফাংশনগুলির, যেমন `giveLydiaPizza` ফাংশনের, একটি `prototype` প্রপার্টি থাকে, যা একটি অবজেক্ট (প্রোটোটাইপ অবজেক্ট) এবং এতে একটি `constructor` প্রপার্টি থাকে। তবে, অ্যারো ফাংশনগুলির, যেমন `giveLydiaChocolate` ফাংশনের, এই `prototype` প্রপার্টি থাকে না। যখন `giveLydiaChocolate.prototype` প্রপার্টি অ্যাক্সেস করার চেষ্টা করা হয়, তখন `undefined` রিটার্ন করা হয়।
 
 </p>
 </details>
@@ -3001,14 +3001,15 @@ for (const [x, y] of Object.entries(person)) {
 
 #### উত্তর: A
 
-`Object.entries(person)` returns an array of nested arrays, containing the keys and objects:
+`Object.entries(person)` একটি নেস্টেড অ্যারের একটি অ্যারে রিটার্ন করে, যার প্রতিটি এলিমেন্টে থাকে কী এবং ভ্যালু:
 
 `[ [ 'name', 'Lydia' ], [ 'age', 21 ] ]`
 
-Using the `for-of` loop, we can iterate over each element in the array, the subarrays in this case. We can destructure the subarrays instantly in the for-of loop, using `const [x, y]`. `x` is equal to the first element in the subarray, `y` is equal to the second element in the subarray.
+`for-of` লুপ ব্যবহার করে, আমরা অ্যারের প্রতিটি এলিমেন্টের, এই ক্ষেত্রে সাবঅ্যারেগুলি, তে ইটারেট করতে পারি। আমরা `for-of` লুপে সাবঅ্যারেগুলিকে সাথে সাথে ডিস্ট্রাকচার করতে পারি, `const [x, y]` ব্যবহার করে। `x` সাবঅ্যারের প্রথম এলিমেন্টের সমান হয়, `y` সাবঅ্যারের দ্বিতীয় এলিমেন্টের সমান হয়।
 
-The first subarray is `[ "name", "Lydia" ]`, with `x` equal to `"name"`, and `y` equal to `"Lydia"`, which get logged.
-The second subarray is `[ "age", 21 ]`, with `x` equal to `"age"`, and `y` equal to `21`, which get logged.
+প্রথম সাবঅ্যারে `[ "name", "Lydia" ]`, যেখানে `x` `"name"` এর সমান এবং `y` `"Lydia"` এর সমান, যা লগ করা হয়।
+
+দ্বিতীয় সাবঅ্যারে `[ "age", 21 ]`, যেখানে `x` `"age"` এর সমান এবং `y` `21` এর সমান, যা লগ করা হয়।
 
 </p>
 </details>
@@ -3035,7 +3036,7 @@ getItems(["banana", "apple"], "pear", "orange")
 
 #### উত্তর: D
 
-`...args` is a rest parameter. The rest parameter's value is an array containing all remaining arguments, **and can only be the last parameter**! In this example, the rest parameter was the second parameter. This is not possible, and will throw a syntax error.
+`...args` হল একটি রেস্ট প্যারামিটার। রেস্ট প্যারামিটারের মান একটি অ্যারে হয় যা সমস্ত অবশিষ্ট আর্গুমেন্ট ধারণ করে, **এবং এটি শুধুমাত্র শেষ প্যারামিটার হতে পারে**! এই উদাহরণে, রেস্ট প্যারামিটারটি দ্বিতীয় প্যারামিটার ছিল। এটি সম্ভব নয় এবং একটি সিনট্যাক্স এরর ঘটাবে।
 
 ```javascript
 function getItems(fruitList, favoriteFruit, ...args) {
@@ -3045,7 +3046,7 @@ function getItems(fruitList, favoriteFruit, ...args) {
 getItems(['banana', 'apple'], 'pear', 'orange');
 ```
 
-The above example works. This returns the array `[ 'banana', 'apple', 'orange', 'pear' ]`
+উপরের উদাহরণটি সঠিকভাবে কাজ করে। এটি অ্যারে `[ 'banana', 'apple', 'orange', 'pear' ]` রিটার্ন করে দেয়।
 
 </p>
 </details>
@@ -3076,16 +3077,16 @@ console.log(nums(1, 2));
 
 #### উত্তর: B
 
-In JavaScript, we don't _have_ to write the semicolon (`;`) explicitly, however the JavaScript engine still adds them after statements. This is called **Automatic Semicolon Insertion**. A statement can for example be variables, or keywords like `throw`, `return`, `break`, etc.
+জাভাস্ক্রিপ্টে, আমাদের স্পষ্টভাবে সেমিকোলন (`;`) _না লিখলে হবে_, তবে জাভাস্ক্রিপ্ট ইঞ্জিনই স্টেটম্যান্টের পরে সেগুলি যোগ করে দেয়। এটিকে **স্বয়ংক্রিয় সেমিকোলন সংযোজন** (Automatic Semicolon Insertion) বলা হয়। একটি স্টেটম্যান্ট হতে পারে উদাহরণস্বরূপ ভেরিয়েবলগুলি, বা কীওয়ার্ড যেমন `throw`, `return`, `break`, ইত্যাদি।
 
-Here, we wrote a `return` statement, and another value `a + b` on a _new line_. However, since it's a new line, the engine doesn't know that it's actually the value that we wanted to return. Instead, it automatically added a semicolon after `return`. You could see this as:
+এখানে, আমরা একটি `return` স্টেটম্যান্টের লিখেছি, এবং আরেকটি মান `a + b` একটি _নতুন লাইনে_। তবে, যেহেতু এটি একটি নতুন লাইন, ইঞ্জিন জানে না যে এটি আসলে সেই মান যা আমরা ফেরত দিতে চেয়েছিলাম। পরিবর্তে, এটি স্বয়ংক্রিয়ভাবে `return` এর পরে একটি সেমিকোলন যোগ করেছে। আপনি এরকম ভাবতে পারেন:
 
 ```javascript
 return;
 a + b;
 ```
 
-This means that `a + b` is never reached, since a function stops running after the `return` keyword. If no value gets returned, like here, the function returns `undefined`. Note that there is no automatic insertion after `if/else` statements!
+এর মানে হল যে `a + b`-তে কখনই পৌঁছানো হয় না, কারণ একটি ফাংশন `return` কীওয়ার্ডের পরে চলা বন্ধ করে দেয়। যদি কোনও মান রিটার্ন না করা হয়, যেমন এখানে, ফাংশন `undefined` রিটার্ন করে। লক্ষ্য করবেন যে `if/else` স্টেটম্যান্টের পরে কোনও স্বয়ংক্রিয় সংযোজন নেই!
 
 </p>
 </details>
@@ -3121,7 +3122,7 @@ console.log(member.name);
 
 #### উত্তর: B
 
-We can set classes equal to other classes/function constructors. In this case, we set `Person` equal to `AnotherPerson`. The name on this constructor is `Sarah`, so the name property on the new `Person` instance `member` is `"Sarah"`.
+আমরা ক্লাসগুলিকে অন্য ক্লাস/ফাংশন কনস্ট্রাক্টরের সমান সেট করতে পারি। এই ক্ষেত্রে, আমরা `Person`-কে `AnotherPerson` এর সমান করেছি। এই কনস্ট্রাক্টরের নাম `Sarah`, তাই নতুন `Person` ইনস্ট্যান্স `member` এর name প্রপার্টি `"Sarah"` হবে।
 
 </p>
 </details>
@@ -3149,9 +3150,9 @@ console.log(Object.keys(info));
 
 #### উত্তর: D
 
-A Symbol is not _enumerable_. The Object.keys method returns all _enumerable_ key properties on an object. The Symbol won't be visible, and an empty array is returned. When logging the entire object, all properties will be visible, even non-enumerable ones.
+একটি Symbol _enumerable_ নয়। Object.keys মেথড একটি অবজেক্টের সমস্ত _enumerable_ কী প্রপার্টিগুলি রিটার্ন করে। Symbol দৃশ্যমান হবে না, এবং একটি খালি অ্যারে রিটার্ন করে। পুরো অবজেক্টটি লগ করলে, সমস্ত প্রপার্টি দৃশ্যমান হবে, এমনকি non-enumerable প্রপার্টিগুলিও।
 
-This is one of the many qualities of a symbol: besides representing an entirely unique value (which prevents accidental name collision on objects, for example when working with 2 libraries that want to add properties to the same object), you can also "hide" properties on objects this way (although not entirely. You can still access symbols using the `Object.getOwnPropertySymbols()` method).
+এটি একটি Symbol এর অনেক গুণাবলীর মধ্যে একটি: সম্পূর্ণ অনন্য মান উপস্থাপন করার পাশাপাশি (যা অবজেক্টগুলিতে আকস্মিক নাম সংঘর্ষ প্রতিরোধ করে, উদাহরণস্বরূপ যখন দুটি লাইব্রেরি অবজেক্টে একই প্রপার্টি যোগ করতে চায়), আপনি এই উপায়ে অবজেক্টগুলিতে প্রপার্টিগুলি "লুকাতে" পারেন (যদিও সম্পূর্ণরূপে নয়। আপনি এখনও `Object.getOwnPropertySymbols()` মেথড ব্যবহার করে Symbol গুলিতে অ্যাক্সেস করতে পারেন)।
 
 </p>
 </details>
@@ -3181,15 +3182,15 @@ console.log(getUser(user))
 
 #### উত্তর: A
 
-The `getList` function receives an array as its argument. Between the parentheses of the `getList` function, we destructure this array right away. You could see this as:
+`getList` ফাংশনটি একটি অ্যারে আর্গুমেন্ট হিসাবে গ্রহণ করে। `getList` ফাংশনের বন্ধনীর মধ্যে, আমরা এই অ্যারেটি সাথে সাথে ডিস্ট্রাকচার করি। আপনি এটি এভাবে দেখতে পারেন:
 
 `[x, ...y] = [1, 2, 3, 4]`
 
-With the rest parameter `...y`, we put all "remaining" arguments in an array. The remaining arguments are `2`, `3` and `4` in this case. The value of `y` is an array, containing all the rest parameters. The value of `x` is equal to `1` in this case, so when we log `[x, y]`, `[1, [2, 3, 4]]` gets logged.
+রেস্ট প্যারামিটার `...y` ব্যবহার করে, আমরা সমস্ত "অবশিষ্ট" আর্গুমেন্টগুলিকে একটি অ্যারেতে রাখি। এই ক্ষেত্রে অবশিষ্ট আর্গুমেন্টগুলি হল `2`, `3` এবং `4`। `y` এর মান একটি অ্যারে, যা সমস্ত রেস্ট প্যারামিটার ধারণ করে। `x` এর মান এই ক্ষেত্রে `1`, তাই যখন আমরা `[x, y]` লগ করি, তখন `[1, [2, 3, 4]]` লগ হয়।
 
-The `getUser` function receives an object. With arrow functions, we don't _have_ to write curly brackets if we just return one value. However, if you want to instantly return an _object_ from an arrow function, you have to write it between parentheses, otherwise everything between the two braces will be interpreted as a block statement. In this case the code between the braces is not a valid JavaScript code, so a `SyntaxError` gets thrown.
+`getUser` ফাংশনটি একটি অবজেক্ট গ্রহণ করে। অ্যারো ফাংশনের ক্ষেত্রে, আমরা যদি কেবল একটি মান ফেরত দিতে চাই তবে আমাদের কার্লি ব্র্যাকেট লিখতে _হবে না_। তবে, যদি আপনি অ্যারো ফাংশন থেকে সাথে সাথে একটি _অবজেক্ট_ ফেরত দিতে চান, তবে আপনাকে এটি বন্ধনীর মধ্যে লিখতে হবে, অন্যথায় দুটি ব্রেসের মধ্যে থাকা সবকিছু একটি ব্লক স্টেটমেন্ট হিসাবে গণ্য করা হবে। এই ক্ষেত্রে ব্রেসের মধ্যে থাকা কোডটি একটি বৈধ জাভাস্ক্রিপ্ট কোড নয়, তাই একটি `SyntaxError` প্রদর্শিত হয়।
 
-The following function would have returned an object:
+নিম্নলিখিত ফাংশনটি একটি অবজেক্ট ফেরত দিত:
 
 `const getUser = user => ({ name: user.name, age: user.age })`
 
@@ -3216,19 +3217,20 @@ console.log(name());
 
 #### উত্তর: C
 
-The variable `name` holds the value of a string, which is not a function, and thus cannot be invoked.
+ভেরিয়েবল `name` একটি স্ট্রিং মান ধারণ করে, যা একটি ফাংশন নয়, এবং তাই এটি ইনভোক (কল) করা সম্ভব নয়।
+
+`TypeErrors` তখন প্রদর্শিত হয় যখন কোনও মান প্রত্যাশিত টাইপের না হয়। জাভাস্ক্রিপ্ট আশা করেছিল যে `name` একটি ফাংশন হবে কারণ আমরা এটি ইনভোক করার চেষ্টা করছি। কিন্তু এটি একটি স্ট্রিং ছিল, তাই একটি TypeError প্রদর্শিত হয়: name is not a function!
 
-TypeErrors get thrown when a value is not of the expected type. JavaScript expected `name` to be a function since we're trying to invoke it. It was a string however, so a TypeError gets thrown: name is not a function!
+`SyntaxErrors` তখন প্রদর্শিত হয় যখন আপনি এমন কিছু লিখেছেন যা বৈধ জাভাস্ক্রিপ্ট নয়, উদাহরণস্বরূপ যখন আপনি `return` শব্দটিকে `retrun` হিসাবে লিখেছেন।
 
-SyntaxErrors get thrown when you've written something that isn't valid JavaScript, for example when you've written the word `return` as `retrun`.
-ReferenceErrors get thrown when JavaScript isn't able to find a reference to a value that you're trying to access.
+`ReferenceErrors` তখন প্রদর্শিত হয় যখন জাভাস্ক্রিপ্ট সেই মানটির রেফারেন্স খুঁজে পায় না যা আপনি অ্যাক্সেস করার চেষ্টা করছেন।
 
 </p>
 </details>
 
 ---
 
-###### 100. What's the value of output?
+###### 100. এটার আউটপুটের ভ্যালু কি?
 
 ```javascript
 // 🎉✨ This is my 100th question! ✨🎉
@@ -3247,16 +3249,16 @@ You should${'' && `n't`} see a therapist after so much JavaScript lol`;
 
 #### উত্তর: B
 
-`[]` is a truthy value. With the `&&` operator, the right-hand value will be returned if the left-hand value is a truthy value. In this case, the left-hand value `[]` is a truthy value, so `"Im'` gets returned.
+`[]` একটি truthy মান। `&&` অপারেটরের সাথে, বাম পাশের মান যদি একটি truthy মান হয়, তাহলে ডান পাশের মানটি ফেরত দেওয়া হবে। এই ক্ষেত্রে, বাম পাশের মান `[]` একটি truthy মান, তাই `"I'm"` ফেরত দেওয়া হয়।
 
-`""` is a falsy value. If the left-hand value is falsy, nothing gets returned. `n't` doesn't get returned.
+`""` একটি falsy মান। যদি বাম পাশের মান falsy হয়, তাহলে কিছুই ফেরত দেওয়া হয় না। `n't` ফেরত দেওয়া হয় না।
 
 </p>
 </details>
 
 ---
 
-###### 101. What's the value of output?
+###### 101. এটার আউটপুটের ভ্যালু কি?
 
 ```javascript
 const one = false || {} || null;
@@ -3289,7 +3291,7 @@ With the `||` operator, we can return the first truthy operand. If all values ar
 
 ---
 
-###### 102. What's the value of output?
+###### 102. এটার আউটপুটের ভ্যালু কি?
 
 ```javascript
 const myPromise = () => Promise.resolve('I have resolved!');
@@ -3333,7 +3335,7 @@ This means that it waited for the `myPromise` to resolve with the value `I have
 
 ---
 
-###### 103. What's the value of output?
+###### 103. এটার আউটপুটের ভ্যালু কি?
 
 ```javascript
 const set = new Set();

From 917bb1b21952b8bae36defc263b3df2b2b6f177f Mon Sep 17 00:00:00 2001
From: iamsaief <saiefalemon@gmail.com>
Date: Sun, 9 Jun 2024 06:48:56 +0600
Subject: [PATCH 08/12] added translation till 112

---
 bn-BD/README_bn-BD.md | 84 +++++++++++++++++++++----------------------
 1 file changed, 41 insertions(+), 43 deletions(-)

diff --git a/bn-BD/README_bn-BD.md b/bn-BD/README_bn-BD.md
index 3a1c2292..fb94bcef 100644
--- a/bn-BD/README_bn-BD.md
+++ b/bn-BD/README_bn-BD.md
@@ -499,7 +499,7 @@ sum(1, '2');
 
 #### উত্তর: C
 
-জাভাস্ক্রিপ্ট একটি **ডায়নামিক টাইপ ভাষাঃ** আমরা ভেরিয়েবলের টাইপ নির্দিষ্ট করি না। আপনি জানতে পারেন না ভ্যালু স্বয়ংক্রিয়ভাবেই এক টাইপ থেকে অন্য টাইপে পরিবর্তন হয়ে যায়, যেটাকে বলা হয় **কোয়ার্শন (coercion)**। এটা হল এক টাইপ থেকে অন্য টাইপে পরিবর্তন হওয়া।
+জাভাস্ক্রিপ্ট একটি **ডায়নামিক টাইপ ভাষাঃ** আমরা ভেরিয়েবলের টাইপ নির্দিষ্ট করি না। আপনি জানতে পারেন না ভ্যালু স্বয়ংক্রিয়ভাবেই এক টাইপ থেকে অন্য টাইপে পরিবর্তন হয়ে যায়, যেটাকে বলা হয় **কোয়ার্শন [coercion](<(coercion)[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#type_coercion]>)**। এটা হল এক টাইপ থেকে অন্য টাইপে পরিবর্তন হওয়া।
 
 এই উদাহরনে, জাভাস্ক্রিপ্ট এই ফাংশনটিকে যুক্তিসঙ্গত ও এর একটি ফলাফল রিটার্ন করার জন্য `1` নাম্বারটিকে স্ট্রিং এ পরিবর্তন করেছে। নাম্বার `1` ও স্ট্রিং `"2"` এর যোগের বেলায় নাম্বারটিকে স্ট্রিং হিসেবে ধরা হয়েছে। আমরা দুটো স্ট্রিং কে যুক্ত করতে পারি এভাবে, `"Hello" + "World"`, তাই এখানে `"1" + "2"` ফলাফল রিটার্ন করছে `"12"`।
 
@@ -3278,13 +3278,13 @@ console.log(one, two, three);
 
 #### উত্তর: C
 
-With the `||` operator, we can return the first truthy operand. If all values are falsy, the last operand gets returned.
+`||` অপারেটরের সাহায্যে, আমরা **প্রথম সত্য অপারেন্ডটি** রিটার্ন করাতে পারি। যদি সমস্ত মান মিথ্যা হয়, **শেষ অপারেন্ডটি** রিটার্ন করে।
 
-`(false || {} || null)`: the empty object `{}` is a truthy value. This is the first (and only) truthy value, which gets returned. `one` is equal to `{}`.
+`(false || {} || null)`: খালি অবজেক্ট `{}` একটি সত্য মান। এটি প্রথম (এবং একমাত্র) সত্য মান, যা রিটার্ন হয়। `one` সমান `{}`।
 
-`(null || false || "")`: all operands are falsy values. This means that the last operand, `""` gets returned. `two` is equal to `""`.
+`(null || false || "")`: সমস্ত অপারেন্ড মিথ্যা মান। এর মানে হল শেষ অপারেন্ড, `""` রিটার্ন করা হয়। `two` সমান `""`।
 
-`([] || 0 || "")`: the empty array`[]` is a truthy value. This is the first truthy value, which gets returned. `three` is equal to `[]`.
+`([] || 0 || "")`: খালি অ্যারে`[]` একটি সত্য মান। এই প্রথম সত্য মান, যা রিটার্ন করা হয়. `three` সমান `[]`।
 
 </p>
 </details>
@@ -3320,15 +3320,15 @@ secondFunction();
 
 #### উত্তর: D
 
-With a promise, we basically say _I want to execute this function, but I'll put it aside for now while it's running since this might take a while. Only when a certain value is resolved (or rejected), and when the call stack is empty, I want to use this value._
+একটি প্রমিসের মাধ্যমে, আমরা মূলত বলি, _আমি এই ফাংশনটি চালাতে চাই, কিন্তু এটি সম্পূর্ণ হতে সময় লাগতে পারে বলে এখন এটিকে একপাশে রেখে দেব। যখন কোন নির্দিষ্ট ভ্যালু রিসল্ভ (বা রিজেক্ট) হয়, এবং যখন কল স্ট্যাক খালি থাকে, ঠিক তখনই আমি এই ভ্যালুটি ব্যবহার করতে চাই।_
 
-We can get this value with both `.then` and the `await` keywords in an `async` function. Although we can get a promise's value with both `.then` and `await`, they work a bit differently.
+একটি `async` ফাংশন থেকে এই ভ্যালুটি আমরা `.then` এবং `await` কিওয়ার্ড দুটি দিয়েই পেতে পারি। যদিও আমরা `.then` এবং `await` দুভাবেই প্রমিসের ভ্যালু পেতে পারি, তবে এরা একটু ভিন্নভাবে কাজ করে।
 
-In the `firstFunction`, we (sort of) put the myPromise function aside while it was running, but continued running the other code, which is `console.log('second')` in this case. Then, the function resolved with the string `I have resolved`, which then got logged after it saw that the callstack was empty.
+- `firstFunction` এ, আমরা (যেন) myPromise ফাংশনটিকে একপাশে রেখে দিয়েছিলাম যখন এটি চলমান ছিল, কিন্তু অন্য কোডগুলো চলতে থাকে, এই ক্ষেত্রে `console.log('second')`। তারপর ফাংশনটি "I have resolved" স্ট্রিং নিয়ে রিসল্ভ হয়, এবং এটিই পরবর্তিতে লগ হয়েছে যখন সে কল স্ট্যাক খালি পেয়েছে।
 
-With the await keyword in `secondFunction`, we literally pause the execution of an async function until the value has been resolved before moving to the next line.
+- `secondFunction` এ, `await` কিওয়ার্ডের সাহায্যে আমরা আক্ষরিক অর্থে একটি `async` ফাংশনের কার্যক্রমকে বিরতি দিয়ে ভ্যালুটি নিশ্চিত (রিসল্ভ) না হওয়া পর্যন্ত অপেক্ষা করি, তারপর পরের লাইনে যাই।
 
-This means that it waited for the `myPromise` to resolve with the value `I have resolved`, and only once that happened, we moved to the next line: `second` got logged.
+  এর মানে হল, এটি `myPromise` ফাংশনটির `I have resolved` স্ট্রিং নিয়ে রিসল্ভ হওয়া পর্যন্ত অপেক্ষা করে, এবং কেবল তা ঘটার পরেই আমরা পরের লাইনে গিয়েছি: `second` লগ হয়েছে।
 
 </p>
 </details>
@@ -3359,20 +3359,20 @@ for (let item of set) {
 
 #### উত্তর: C
 
-The `+` operator is not only used for adding numerical values, but we can also use it to concatenate strings. Whenever the JavaScript engine sees that one or more values are not a number, it coerces the number into a string.
+`+` অপারেটরটি শুধুমাত্র সংখ্যাসূচক ভ্যালুই যোগ করার জন্য ব্যবহার করা হয় না, আমরা স্ট্রিং সংযুক্ত (concatenate) করতেও এটি ব্যবহার করতে পারি। যখনই জাভাস্ক্রিপ্ট ইঞ্জিন দেখে যে এক বা একাধিক ভ্যালুগুলো একটি সংখ্যা নয়, এটি সংখ্যাটিকে একটি স্ট্রিংয়ে পরিবর্তন করে, এটাকে বলা হয় কোয়ার্শন ([coercion]([https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#type_coercion]))।
 
-The first one is `1`, which is a numerical value. `1 + 2` returns the number 3.
+প্রথমটি হল `1`, যা একটি সংখ্যাসূচক ভ্যালু। `1 + 2` রিটার্ন করে নাম্বার `3`।
 
-However, the second one is a string `"Lydia"`. `"Lydia"` is a string and `2` is a number: `2` gets coerced into a string. `"Lydia"` and `"2"` get concatenated, which results in the string `"Lydia2"`.
+অন্যদিকে, দ্বিতীয়টি একটি স্ট্রিং `"Lydia"`। `"Lydia"` একটি স্ট্রিং এবং `2` হল একটি সংখ্যা: তাই `2` একটি স্ট্রিংয়ে পরিবর্তিত হয়। `"Lydia"` এবং `"2"` একত্রিত হয়, যার ফলে `"Lydia2"` স্ট্রিং রিটার্ন করে।
 
-`{ name: "Lydia" }` is an object. Neither a number nor an object is a string, so it stringifies both. Whenever we stringify a regular object, it becomes `"[object Object]"`. `"[object Object]"` concatenated with `"2"` becomes `"[object Object]2"`.
+`{ name: "Lydia" }` হল অবজেক্ট। একটি নাম্বার বা অবজেক্ট কোনটাই স্ট্রিং নয়, তাই এ দুটি স্ট্রিংফাই হয়। যখনি আমরা একটি সাধারণ অবজেক্টকে স্ট্রিংফাই করি এটা হয়ে যায় - `"[object Object]"`। `"[object Object]"` `"2"` এর সাথে একত্রিত হয়ে রিটার্ন করে `"[object Object]2"`।
 
 </p>
 </details>
 
 ---
 
-###### 104. What's its value?
+###### 104. এটার ভ্যালুটি কি হবে?
 
 ```javascript
 Promise.resolve(5);
@@ -3388,16 +3388,16 @@ Promise.resolve(5);
 
 #### উত্তর: C
 
-We can pass any type of value we want to `Promise.resolve`, either a promise or a non-promise. The method itself returns a promise with the resolved value (`<fulfilled>`). If you pass a regular function, it'll be a resolved promise with a regular value. If you pass a promise, it'll be a resolved promise with the resolved value of that passed promise.
+`Promise.resolve` এ আমরা যেকোন টাইপের ভ্যালু পাস করতে পারি, একটি প্রমিস বা নন-প্রমিস। মেথডটি নিজেই রিসল্ভ হওয়া ভ্যালুটি (`<fulfilled>`) সহ একটি প্রমিস রিটার্ন করে। যদি আপনি একটি একটি রেগুলার ফাংশন পাস করেন, এটা একটি রেগুলার ভ্যালু সহ একটি রিসল্ভ প্রমিস হবে। যদি প্রমিস পাস করেন, এটা পাস করা ঐ প্রমিসের রিসল্ভ ভ্যালু সহ একটি রিসল্ভ প্রমিস হবে।
 
-In this case, we just passed the numerical value `5`. It returns a resolved promise with the value `5`.
+এক্ষেত্রে, আমরা কেবল পাস করেছি একটি সংখ্যাসূচক ভ্যালু `5`। তাই এটা `5` ভ্যালুটিসহ একটি রিসল্ভ প্রমিস রিটার্ন করেছে।
 
 </p>
 </details>
 
 ---
 
-###### 105. What's its value?
+###### 105. এটার ভ্যালুটি কি হবে?
 
 ```javascript
 function compareMembers(person1, person2 = person) {
@@ -3423,20 +3423,18 @@ compareMembers(person);
 
 #### উত্তর: B
 
-Objects are passed by reference. When we check objects for strict equality (`===`), we're comparing their references.
+অবজেক্ট পাস হয় রেফারেন্স দ্বারা। যখন আমরা কঠোর সমতার (strict equality `===`) জন্য অবজেক্টগুলি পরীক্ষা করি, তখন আমরা আদতে তাদের রেফারেন্সগুলি তুলনা করছি।
 
-We set the default value for `person2` equal to the `person` object, and passed the `person` object as the value for `person1`.
+আমরা `person2`-এর একটি ডিফল্ট ভ্যালু সমান সেট করেছি `person` অবজেক্টকে এবং `person1`-এর ভ্যালু হিসেবেও একই অবজেক্ট `person`কে পাস করেছি। এর মানে হল যে উভয় ভ্যালুর কাছেই মেমরির একই লোকেশনের রেফারেন্স রয়ছে, এইভাবে তারা সমান হয়।
 
-This means that both values have a reference to the same spot in memory, thus they are equal.
-
-The code block in the `else` statement gets run, and `They are the same!` gets logged.
+ফলে, `else` স্টেটম্যান্টের কোড ব্লকটি কার্যকর হয়, এবং `They are the same!` লগ হয়।
 
 </p>
 </details>
 
 ---
 
-###### 106. What's its value?
+###### 106. এটার ভ্যালুটি কি হবে?
 
 ```javascript
 const colorConfig = {
@@ -3462,18 +3460,18 @@ console.log(colorConfig.colors[1]);
 
 #### উত্তর: D
 
-In JavaScript, we have two ways to access properties on an object: bracket notation, or dot notation. In this example, we use dot notation (`colorConfig.colors`) instead of bracket notation (`colorConfig["colors"]`).
+জাভাস্ক্রিপ্টে, একটি অবজেক্টের প্রোপার্টির ভ্যালু আমরা দুইভাবে এক্সেস করতে পারিঃ ব্র্যাকেট নোটেশন, অথবা ডট নোটেশন। এই উদাহরনে, আমরা ডট নোটেশন (`colorConfig.colors`) ব্যাবহার করেছি ব্র্যাকেট নোটেশনের (`colorConfig["colors"]`) পরিবর্তে।
 
-With dot notation, JavaScript tries to find the property on the object with that exact name. In this example, JavaScript tries to find a property called `colors` on the `colorConfig` object. There is no property called `colors`, so this returns `undefined`. Then, we try to access the value of the first element by using `[1]`. We cannot do this on a value that's `undefined`, so it throws a `TypeError`: `Cannot read property '1' of undefined`.
+ডট নোটেশনের মাধ্যমে, জাভাস্ক্রিপ্ট অবজেক্টে নির্দিষ্ট নাম ধরে প্রোপার্টির ভ্যালু খুঁজে পাওয়ার চেষ্টা করে। এই উদাহরনে, জাভাস্ক্রিপ্ট `colorConfig` অবজেক্টে `colors` প্রোপার্টির ভ্যালু খুঁজে পাওয়ার চেষ্টা করেছে। এখানে `colors` নামে কোন প্রোপার্টি খুঁজে না পাওয়ায় রিটার্ন করছে `undefined`। এরপর আমরা `[1]` ব্যবহার করে ১ম এলিমেন্টকে এক্সেস করার চেষ্টা করছি। কিন্তু আমরা এটা করতে পারি না যার ভ্যালু `undefined`, তাই এটি টাইপ এরর ঘটাবে - `TypeError`: `Cannot read property '1' of undefined`।
 
-JavaScript interprets (or unboxes) statements. When we use bracket notation, it sees the first opening bracket `[` and keeps going until it finds the closing bracket `]`. Only then, it will evaluate the statement. If we would've used `colorConfig[colors[1]]`, it would have returned the value of the `red` property on the `colorConfig` object.
+জাভাস্ক্রিপ্ট স্টেটম্যান্টগুলোকে ভাষান্তর করে (মেশিনের ভাষায়)। যখন ব্র্যাকেট নোটেশন ব্যবহৃত হয়, এটা শুরুর ব্র্যাকেট `[` পেলে তার শেষ ব্র্যাকেট পর্যন্ত `]` যেতে থাকে। তারপরই কেবল এটার মান নির্ণয় করা হবে। আমরা যদি `colorConfig[colors[1]]` ব্যবহার করতাম, এটা `colorConfig` অবজেক্টের `red` প্রপার্টির ভ্যালু রিটার্ন করত।
 
 </p>
 </details>
 
 ---
 
-###### 107. What's its value?
+###### 107. এটার ভ্যালুটি কি হবে?
 
 ```javascript
 console.log('❤️' === '❤️');
@@ -3487,14 +3485,14 @@ console.log('❤️' === '❤️');
 
 #### উত্তর: A
 
-Under the hood, emojis are unicodes. The unicodes for the heart emoji is `"U+2764 U+FE0F"`. These are always the same for the same emojis, so we're comparing two equal strings to each other, which returns true.
+ভেতরে ভেতরে, ইমোজিগুলি হল ইউনিকোড৷ হার্ট ইমোজির ইউনিকোড হল `"U+2764 U+FE0F"`। এই ভ্যালুগুলো একই ইমোজিগুলির জন্য সবসময় একই, তাই আমরা দুটি স্ট্রিংকে একে অপরের সমান কিনা তুলনা করছি, যা সত্য রিটার্ন করে।
 
 </p>
 </details>
 
 ---
 
-###### 108. Which of these methods modifies the original array?
+###### 108. এই মেথডগুলির মধ্যে কোনটি মূল অ্যারে পরিবর্তন করে?
 
 ```javascript
 const emojis = ['✨', '🥑', '😍'];
@@ -3517,9 +3515,9 @@ emojis.splice(1, 2, '✨');
 
 #### উত্তর: D
 
-With `splice` method, we modify the original array by deleting, replacing or adding elements. In this case, we removed 2 items from index 1 (we removed `'🥑'` and `'😍'`) and added the ✨ emoji instead.
+`splice` মেথডের সাহায্যে, আমরা মূল অ্যারে পরিবর্তন করি তার এলিমেন্টগুলি বাদ, প্রতিস্থাপন বা যোগ করার মাধ্যমে। এই ক্ষেত্রে, আমরা ইনডেক্স 1 থেকে 2টি এলিমেন্টকে সরিয়ে (আমরা `'🥑'` এবং `'😍'` সরিয়ে দিয়েছি) নতুন ✨ ইমোজি যোগ করেছি।
 
-`map`, `filter` and `slice` return a new array, `find` returns an element, and `reduce` returns a reduced value.
+`map`, `filter` এবং `slice` একটি নতুন অ্যারে রিটার্ন করে, `find` একটি এলিমেন্ট রিটার্ন করে এবং `reduce` একটি হ্রাসকৃত/একত্রিত ভ্যালু রিটার্ন করে।
 
 </p>
 </details>
@@ -3547,18 +3545,18 @@ console.log(food);
 
 #### উত্তর: A
 
-We set the value of the `favoriteFood` property on the `info` object equal to the string with the pizza emoji, `'🍕'`. A string is a primitive data type. In JavaScript, primitive data types don't interact by reference.
+আমরা `info` অবজেক্টের `favoriteFood` প্রপার্টির ভ্যালু সমান সেট করেছি পিৎজা ইমোজির স্ট্রিং `'🍕'`কে। স্ট্রিং হচ্ছে একটি প্রিমিটিভ ডেটা টাইপ। জাভাস্ক্রিপ্টে, প্রিমিটিভ ডেটা টাইপগুলো ইন্টারঅ্যাক্ট করে ভ্যালু দ্বারা রেফারেন্স দ্বারা নয়।
 
-In JavaScript, primitive data types (everything that's not an object) interact by _value_. In this case, we set the value of the `favoriteFood` property on the `info` object equal to the value of the first element in the `food` array, the string with the pizza emoji in this case (`'🍕'`). A string is a primitive data type, and interact by value (see my [blogpost](https://www.theavocoder.com/complete-javascript/2018/12/21/by-value-vs-by-reference) if you're interested in learning more)
+জাভাস্ক্রিপ্টে, প্রিমিটিভ ডেটা টাইপ (অবজেক্ট ছাড়া সবকিছুই) তাদের _value_ দ্বারা ইন্টারঅ্যাক্ট করে। এই ক্ষেত্রে, আমরা `info` অবজেক্টের `favoriteFood` প্রপার্টির ভ্যালু সমান সেট করেছি `food` অ্যারের প্রথম এলিমেন্টের ভ্যালু, এই ক্ষেত্রে পিৎজা ইমোজির স্ট্রিং (`'🍕'` )।
 
-Then, we change the value of the `favoriteFood` property on the `info` object. The `food` array hasn't changed, since the value of `favoriteFood` was merely a _copy_ of the value of the first element in the array, and doesn't have a reference to the same spot in memory as the element on `food[0]`. When we log food, it's still the original array, `['🍕', '🍫', '🥑', '🍔']`.
+তারপর, আমরা `info` অবজেক্টে `favoriteFood` প্রপার্টির ভ্যালু পরিবর্তন করি। `food` অ্যারে পরিবর্তিত হয়নি, যেহেতু `favoriteFood`-এর ভ্যালুটি কেবল অ্যারের প্রথম এলিমেন্টের ভ্যালুর একটি _copy_ ছিল, এবং একই মেমরি লোকেশনের `food[0]` এলিমেন্টের মত কোন রেফারেন্স নয়। যখন food লগ করা হয়, এটা এখনো অরিজিনাল অ্যারেই আছে, `['🍕', '🍫', '🥑', '🍔']`।
 
 </p>
 </details>
 
 ---
 
-###### 110. What does this method do?
+###### 110. এই মেথডটি কি করে?
 
 ```javascript
 JSON.parse();
@@ -3574,7 +3572,7 @@ JSON.parse();
 
 #### উত্তর: A
 
-With the `JSON.parse()` method, we can parse JSON string to a JavaScript value.
+`JSON.parse()` মেথড ব্যাবহার করে, আমারা JSON স্ট্রিংকে একটি জাভাস্ক্রিপ্ট ভ্যালুতে পার্স করতে পারি।
 
 ```javascript
 // Stringifying a number into valid JSON, then parsing the JSON string to a JavaScript value:
@@ -3585,9 +3583,9 @@ JSON.parse(jsonNumber); // 4
 const jsonArray = JSON.stringify([1, 2, 3]); // '[1, 2, 3]'
 JSON.parse(jsonArray); // [1, 2, 3]
 
-// Stringifying an object  into valid JSON, then parsing the JSON string to a JavaScript value:
-const jsonArray = JSON.stringify({ name: 'Lydia' }); // '{"name":"Lydia"}'
-JSON.parse(jsonArray); // { name: 'Lydia' }
+// Stringifying an object into valid JSON, then parsing the JSON string to a JavaScript value:
+const jsonObject = JSON.stringify({ name: 'Lydia' }); // '{"name":"Lydia"}'
+JSON.parse(jsonObject); // { name: 'Lydia' }
 ```
 
 </p>
@@ -3618,11 +3616,11 @@ getName();
 
 #### উত্তর: D
 
-Each function has its own _execution context_ (or _scope_). The `getName` function first looks within its own context (scope) to see if it contains the variable `name` we're trying to access. In this case, the `getName` function contains its own `name` variable: we declare the variable `name` with the `let` keyword, and with the value of `'Sarah'`.
+প্রতিটি ফাংশনের নিজস্ব _execution context_ (বা _scope_) আছে। `getName` ফাংশনটিতে যে ভ্যারিয়েবলকে এক্সেস করা হচ্ছে যেমন, `name` তাকে প্রথমে তার নিজস্ব _context_ (বা _scope_)-এ খুঁজে দেখছে। এক্ষেত্রে, `getName` ফাংশনে তার নিজস্ব `name` ভ্যারিয়েবল আছেঃ আমরা `name` ভ্যারিয়েবলকে ডিক্লেয়ার করেছি `let` কিওয়ার্ড দিয়ে এবং ইনিশিয়ালাইজ করেছি একটি স্ট্রিং - `'Sarah'`।
 
-Variables with the `let` keyword (and `const`) are hoisted, but unlike `var`, don't get <i>initialized</i>. They are not accessible before the line we declare (initialize) them. This is called the "temporal dead zone". When we try to access the variables before they are declared, JavaScript throws a `ReferenceError`.
+`let` কিওয়ার্ড (এবং `const`) দিয়ে ভেরিয়েবল নিলে সেটাও **হইস্টেড হয়** তবে `var` এর মত **ইনিশিয়ালাইজ হয় না**। যে লাইনে ডিক্লেয়ার (ইনিশিয়ালাইজ) করা হয়েছে তার আগে তাদেরকে এক্সেস (রিড/রাইট) করা যায় না। এটাকে **"টেম্পোরাল ডেড জোন"** বলা হয়। যখন ভেরিয়েবলকে ডিক্লেয়ার করার আগেই তাকে এক্সেস করার চেষ্টা করা হয় তখন জাভাস্ক্রিপ্ট `ReferenceError` ছুঁঁড়ে দেয়।
 
-If we wouldn't have declared the `name` variable within the `getName` function, the javascript engine would've looked down the _scope chain_. The outer scope has a variable called `name` with the value of `Lydia`. In that case, it would've logged `Lydia`.
+যদি `name` ভ্যারিয়েবলটিকে আমরা `getName` ফাংশনে ডিক্লেয়ার না করতাম, জাভাস্ক্রিপ্ট ইঞ্জিন তাকে _scope chain_ এর ভিতর খুঁজে দেখত। বাইরের স্কোপেও একটি `name` ভ্যারিয়াবল আছে যার ভ্যালু একটি স্ট্রিং - `Lydia`। এক্ষেত্রে, এটা লগ করত `Lydia`।
 
 ```javascript
 let name = 'Lydia';

From b1d37523a1bd7156c256f5f3a7de5440004a193a Mon Sep 17 00:00:00 2001
From: iamsaief <saiefalemon@gmail.com>
Date: Thu, 13 Jun 2024 13:46:35 +0600
Subject: [PATCH 09/12] added translation till 122

---
 bn-BD/README_bn-BD.md | 62 ++++++++++++++++++++++---------------------
 1 file changed, 32 insertions(+), 30 deletions(-)

diff --git a/bn-BD/README_bn-BD.md b/bn-BD/README_bn-BD.md
index fb94bcef..5284585b 100644
--- a/bn-BD/README_bn-BD.md
+++ b/bn-BD/README_bn-BD.md
@@ -3665,16 +3665,17 @@ console.log(two.next().value);
 
 #### উত্তর: C
 
-With the `yield` keyword, we `yield` values in a generator function. With the `yield*` keyword, we can yield values from another generator function, or iterable object (for example an array).
+`yield` কিওয়ার্ড দিয়ে, আমরা জেনারেটর ফাংশন থেকে ভ্যালুগুলো `yield` করতে পারি। `yield*` কিওয়ার্ড দিয়ে, আমরা অন্য জেনারেটর ফাংশন থেকে ভ্যালুগুলো, বা ইটারেবল অবজেক্ট (যেমন একটি অ্যারে) থেকে ভ্যালুগুলো `yield` করতে পারি।
 
-In `generatorOne`, we yield the entire array `['a', 'b', 'c']` using the `yield` keyword. The value of `value` property on the object returned by the `next` method on `one` (`one.next().value`) is equal to the entire array `['a', 'b', 'c']`.
+`generatorOne` এ, আমরা `yield` কিওয়ার্ড ব্যবহার করে সম্পুর্ন অ্যারে `['a', 'b', 'c']` -কে `yield` করছি।
+`one` এর ক্ষেত্রে, (`one.next().value`) এর `next` মেথডের রিটার্ন করা অবজেক্টে `value` প্রোপার্টির ভ্যালু সমান হলো সম্পুর্ন অ্যারেটি- `['a', 'b', 'c']`।
 
 ```javascript
 console.log(one.next().value); // ['a', 'b', 'c']
 console.log(one.next().value); // undefined
 ```
 
-In `generatorTwo`, we use the `yield*` keyword. This means that the first yielded value of `two`, is equal to the first yielded value in the iterator. The iterator is the array `['a', 'b', 'c']`. The first yielded value is `a`, so the first time we call `two.next().value`, `a` is returned.
+`generatorTwo` এ, আমরা `yield*` কিওয়ার্ড ব্যবহার করেছি। এর মানে হলো, `two` এ প্রথম yield হওয়া ভ্যালু সমান হচ্ছে ইটারেটরের (`['a', 'b', 'c']`) প্রথম yield হওয়া ভ্যালু। প্রথম yield হওয়া ভ্যালু হলো `a`, তাই প্রথমবার `two.next().value` কল করলে রিটার্ন করে `a`।
 
 ```javascript
 console.log(two.next().value); // 'a'
@@ -3704,14 +3705,14 @@ console.log(`${((x) => x)('I love')} to program`);
 
 #### উত্তর: A
 
-Expressions within template literals are evaluated first. This means that the string will contain the returned value of the expression, the immediately invoked function `(x => x)('I love')` in this case. We pass the value `'I love'` as an argument to the `x => x` arrow function. `x` is equal to `'I love'`, which gets returned. This results in `I love to program`.
+টেমপ্লেট লিটারেলের মধ্যে থাকা এক্সপ্রেশনের মান নির্ণয় হয় সর্বপ্রথমে। এর মানে হলো, এক্সপ্রেশন থেকে রিটার্ন করা ভ্যালুটি স্ট্রিং এর মধ্যে থাকবে, এক্ষেত্রে, `(x => x)('I love')` ইমিডিয়েটলি ইনভোকড ফাংশন। আমরা `x => x` অ্যারো ফাংশনের একটি আর্গুমেন্ট হিসেবে `'I love'` স্ট্রিংটি পাস করছি। তাই `x` সমান হয় `'I love'`, যেটা রিটার্ন করা হয়। তাই ফলাফল হিসেবে `I love to program` পাওয়া যাচ্ছে।
 
 </p>
 </details>
 
 ---
 
-###### 114. What will happen?
+###### 114. এখানে কি ঘটবে?
 
 ```javascript
 let config = {
@@ -3733,18 +3734,16 @@ config = null;
 
 #### উত্তর: C
 
-Normally when we set objects equal to `null`, those objects get _garbage collected_ as there is no reference anymore to that object. However, since the callback function within `setInterval` is an arrow function (thus bound to the `config` object), the callback function still holds a reference to the `config` object.
-As long as there is a reference, the object won't get garbage collected.
-Since this is an interval, setting `config` to `null` or `delete`-ing `config.alert` won't garbage-collect the interval, so the interval will still be called.
-It should be cleared with `clearInterval(config.alert)` to remove it from memory.
-Since it was not cleared, the `setInterval` callback function will still get invoked every 1000ms (1s).
+সধারনত যখন আমরা অবজেক্ট সমান `null` সেট করি, সেই অবজেক্টগুলো _গারবেজ কালেক্টেড_ হয়ে যায় যেহেতু ঐ অবজেক্টের আর কোন রেফারেন্স থাকে না। অন্যদিকে, যেহেতু `setInterval` এর কলব্যাক ফাংশনটি একটি অ্যারো ফাংশন (এজন্য `config` অবজেক্টের ভেতর আবদ্ধ থাকছে), কলব্যাক ফাংশনটি এখনো `config` অবজেক্টের রেফারেন্স ধরে রেখেছে।
+
+যতক্ষণ পর্যন্ত রেফারেন্স থাকছে, অবজেক্টটি _গারবেজ কালেক্টেড_ হবে না। যেহেতু এটি ইন্টারভাল (টাইমার), `config` অবজেক্টকে `null` সেট করা বা `delete` করলেও ইন্টারভাল _গারবেজ কালেক্টেড_ হবে না, তাই ইন্টারভালটি এখনো কল হবে। এটাকে মেমরি থেকে মুছে ফেলার জন্য একে ক্লিয়ার করা উচিৎ `clearInterval(config.alert)` দিয়ে। যেহেতু এটি ক্লিয়ার হয়নি, `setInterval` এর কলব্যাক ফাংশনটি এখনো কল হতে থাকবে প্রতি ১০০০ মিলিসেকেন্ড (১ সেকেন্ড) পরপর।
 
 </p>
 </details>
 
 ---
 
-###### 115. Which method(s) will return the value `'Hello world!'`?
+###### 115. কোন মেথড(গুলো) `'Hello world!'` ভ্যালুটি রিটার্ন করবে?
 
 ```javascript
 const myMap = new Map();
@@ -3770,12 +3769,12 @@ myMap.get(() => 'greeting');
 
 #### উত্তর: B
 
-When adding a key/value pair using the `set` method, the key will be the value of the first argument passed to the `set` function, and the value will be the second argument passed to the `set` function. The key is the _function_ `() => 'greeting'` in this case, and the value `'Hello world'`. `myMap` is now `{ () => 'greeting' => 'Hello world!' }`.
+যখন `set` মেথড ব্যবহার করে কি/ভ্যালু জোড় যুক্ত করা হয়, `set` মেথডে পাস করা প্রথম আর্গুমেন্ট হবে _কি_ এবং দ্বিতীয়টি হবে _ভ্যালু_। এক্ষেত্রে _কি_ হলো _function_ `() => 'greeting'` এবং _ভ্যালু_ হলো `'Hello world'`। ফলে `myMap` এখন হয় এমন - `{ () => 'greeting' => 'Hello world!' }`
 
-1 is wrong, since the key is not `'greeting'` but `() => 'greeting'`.
-3 is wrong, since we're creating a new function by passing it as a parameter to the `get` method. Object interacts by _reference_. Functions are objects, which is why two functions are never strictly equal, even if they are identical: they have a reference to a different spot in memory.
+**1**, `myMap.get('greeting')`টি ভুল, যেহতু কি `'greeting'` নয় বরং `() => 'greeting'`।
+
+**3**, `myMap.get(() => 'greeting')` টিও ভুল, যেহেতু আমরা নতুন একটি ফাংশন তৈরি করছি এটাকে প্যারামিটার হিসেবে `set` মেথডে পাস করার মাধ্যমে। অবজেক্ট _reference_ দ্বারা ইন্টারঅ্যাক্ট করে। ফাংশন হল অবজেক্ট, যে কারণে দুটি ফাংশন কখনোই কঠোরভাবে সমান হয় না, এমনকি তারা যদি হুবহু একই হয়: তাদের কাছে মেমরিতে আলাদা আলাদা রেফারেন্স থাকে।
 
-</p>
 </details>
 
 ---
@@ -3810,18 +3809,18 @@ console.log(person);
 
 #### উত্তর: C
 
-Both the `changeAge` and `changeAgeAndName` functions have a default parameter, namely a _newly_ created object `{ ...person }`. This object has copies of all the key/values in the `person` object.
+`changeAge` এবং `changeAgeAndName` উভয় ফাংশনেরই একটি ডিফল্ট প্যারামিটার আছে, উল্লেখ্য এরা _নতুন_ তৈরিকৃত অবজেক্ট `{ ...person }`। এই অবজেক্টে `person` অবজেক্টের সমস্ত কী/ভ্যালুগুলির কপি রয়েছে৷
 
-First, we invoke the `changeAge` function and pass the `person` object as its argument. This function increases the value of the `age` property by 1. `person` is now `{ name: "Lydia", age: 22 }`.
+প্রথমত, আমরা `changeAge` ফাংশনকে কল করি এবং `person` অবজেক্টটিকে এর আর্গুমেন্ট হিসেবে পাস করি। এই ফাংশনটি `age` প্রোপার্টির মান 1 দ্বারা বৃদ্ধি করে। `person` এখন `{ name: "Lydia", age: 22 }`।
 
-Then, we invoke the `changeAgeAndName` function, however we don't pass a parameter. Instead, the value of `x` is equal to a _new_ object: `{ ...person }`. Since it's a new object, it doesn't affect the values of the properties on the `person` object. `person` is still equal to `{ name: "Lydia", age: 22 }`.
+তারপর, আমরা `changeAgeAndName` ফাংশন কল করি, তবে আমরা কোনো প্যারামিটার পাস করিনি। ফলে, `x` এর ভ্যালু সমান হয় _নতুন_ তৈরিকৃত অবজেক্ট `{ ...person }`। যেহেতু এটি একটি নতুন অবজেক্ট, এটি `person` অবজেক্টের কোন প্রোপার্টির ভ্যালুকে প্রভাবিত করে না। `person` এখনও `{ name: "Lydia", age: 22 }` এর সমান।
 
 </p>
 </details>
 
 ---
 
-###### 117. Which of the following options will return `6`?
+###### 117. উল্লেখ্য কোন অপশনটি রিটার্ন করে `6`?
 
 ```javascript
 function sumValues(x, y, z) {
@@ -3839,7 +3838,7 @@ function sumValues(x, y, z) {
 
 #### উত্তর: C
 
-With the spread operator `...`, we can _spread_ iterables to individual elements. The `sumValues` function receives three arguments: `x`, `y` and `z`. `...[1, 2, 3]` will result in `1, 2, 3`, which we pass to the `sumValues` function.
+স্প্রেড অপারেটর দিয়ে `...`, আমরা ইটারেবল গুলোকে আলদা এলিমেন্টে স্প্রেড করতে পারি। `sumValues` ফাংশনটি ৩টি আর্গুমেন্ট রিসিভ করছে `x`, `y` ও `z`। কেবল `...[1, 2, 3]` -এর ফলাফল হয় `1, 2, 3`, যেটা আমরা `sumValues` ফাংশনে পাস করেছি।
 
 </p>
 </details>
@@ -3865,7 +3864,7 @@ console.log(list[(num += 1)]);
 
 #### উত্তর: B
 
-With the `+=` operator, we're incrementing the value of `num` by `1`. `num` had the initial value `1`, so `1 + 1` is `2`. The item on the second index in the `list` array is 🥰, `console.log(list[2])` prints 🥰.
+`+=` অপারেটর দিয়ে, আমরা `num` এর ভ্যালু `1` বৃদ্ধি করছি। `num` এর প্রাথমিক ভ্যালু ছিল `1`, ফলে `1 + 1` হয় `2`। `list` অ্যারের ২ নাম্বার ইনডেক্স আইটেমের ভ্যালু পাওয়া যায় 🥰, `console.log(list[2])` প্রিন্ট করছে 🥰।
 
 </p>
 </details>
@@ -3903,12 +3902,15 @@ console.log(member.getLastName?.());
 
 #### উত্তর: B
 
-With the optional chaining operator `?.`, we no longer have to explicitly check whether the deeper nested values are valid or not. If we're trying to access a property on an `undefined` or `null` value (_nullish_), the expression short-circuits and returns `undefined`.
+অপশনাল চেইনিং অপারেটর `?.` দিয়ে, কোন ডিপার নেস্টেড ভ্যালুগুলো ভ্যালিড কিনা তা আমাদের সরাসরি চেক করার প্রয়োজন হয় না যে। যদি আমরা কোন `undefined` বা `null` ভ্যালু (_নালিশ_) কে এক্সেস করার চেষ্টা করি, এক্সপ্রেশনটি সেখানেই কাজ করা বন্ধ করে দেয় এবং `undefined` রিটার্ন করে।
+
+- `person.pet?.name` এর ক্ষেত্রে, `person` অবজেক্টে `pet` প্রোপার্টি আছেঃ `person.pet` নালিশ নয়। এটায় `name` নামের একটি প্রোপার্টি আছে, এবং রিটার্ন করছে `Mara`।
+
+- `person.pet?.family?.name` এর ক্ষেত্রে, `person` অবজেক্টে `pet` প্রোপার্টি আছেঃ `person.pet` নালিশ নয়। এটায় `family` নামের কোন প্রোপার্টি নেই, `person.pet.family` হলো নালিশ। এক্সপ্রেশনটি `undefined` রিটার্ন করে।
+
+- `person.getFullName?.()` এর ক্ষত্রে, `person` অবজেক্টে `getFullName` প্রোপার্টি আছেঃ `person.getFullName()` নালিশ নয় এবং কল করতে পেরেছে, যেটা `Lydia Hallie` রিটার্ন করছে।
 
-`person.pet?.name`: `person` has a property named `pet`: `person.pet` is not nullish. It has a property called `name`, and returns `Mara`.
-`person.pet?.family?.name`: `person` has a property named `pet`: `person.pet` is not nullish. `pet` does _not_ have a property called `family`, `person.pet.family` is nullish. The expression returns `undefined`.
-`person.getFullName?.()`: `person` has a property named `getFullName`: `person.getFullName()` is not nullish and can get invoked, which returns `Lydia Hallie`.
-`member.getLastName?.()`: variable `member` is non-existent therefore a `ReferenceError` gets thrown!
+- `member.getLastName?.()` এর ক্ষেত্রে, `member` ভ্যারিয়েবলটিকেই পাওয়া যাচ্ছে না বলে `ReferenceError` ঘটছে।
 
 </p>
 </details>
@@ -3937,7 +3939,7 @@ if (groceries.indexOf('banana')) {
 
 #### উত্তর: B
 
-We passed the condition `groceries.indexOf("banana")` to the if-statement. `groceries.indexOf("banana")` returns `0`, which is a falsy value. Since the condition in the if-statement is falsy, the code in the `else` block runs, and `We don't have to buy bananas!` gets logged.
+আমরা ইফ-এলস স্টেটমেন্টে `groceries.indexOf("banana")` শর্ত দিয়েছি। `groceries.indexOf("banana")` রিটার্ন করে `0`, যেটা ফলসি ভ্যালু। যেতেতু ইফ-এলস স্টেটমেন্টের শর্ত ফলসি, তাই `else` ব্লকের কোডটি চলেছে, এবং `We don't have to buy bananas!` লগ হয়েছে।
 
 </p>
 </details>
@@ -3967,7 +3969,7 @@ console.log(config.language);
 
 #### উত্তর: D
 
-The `language` method is a `setter`. Setters don't hold an actual value, their purpose is to _modify_ properties. When calling a `setter` method, `undefined` gets returned.
+`language` মেথডটি হলো একটি `setter`। Setters কোন ভ্যালুকেই ধরে রাখে না, তাদের উদ্দ্যেশই হলো প্রোপার্টিগুলোকে পরিবর্তন করা। যখন `setter` মেথড কল করা হয়, `undefined` রিটার্ন করে।
 
 </p>
 </details>
@@ -3993,9 +3995,9 @@ console.log(!typeof name === 'string');
 
 #### উত্তর: C
 
-`typeof name` returns `"string"`. The string `"string"` is a truthy value, so `!typeof name` returns the boolean value `false`. `false === "object"` and `false === "string"` both return`false`.
+`typeof name` রিটার্ন করে `"string"`। স্ট্রিং - `"string"` হলো একটি সত্য ভ্যালু, তাই `!typeof name` রিটার্ন করে বুলিয়ান ভ্যালু `false`। `false === "object"` এবং `false === "string"` উভয়েই রিটার্ন করে `false`।
 
-(If we wanted to check whether the type was (un)equal to a certain type, we should've written `!==` instead of `!typeof`)
+(যদি আমরা চেক করতে চাইতাম যে কোন একটি টাইপ একটি নির্দিষ্ট টাইপের (অ)সমান কিনা, আমাদের `!typeof` এর পরিবর্তে `!==` লেখা উচিৎ ছিল ।)
 
 </p>
 </details>

From 098e645ce5c2900ca3771562f7767eb4d7ab1b6c Mon Sep 17 00:00:00 2001
From: iamsaief <saiefalemon@gmail.com>
Date: Sat, 20 Jul 2024 22:50:18 +0600
Subject: [PATCH 10/12] added translation till 133

---
 bn-BD/README_bn-BD.md | 460 +++++++++++++++++++++---------------------
 1 file changed, 232 insertions(+), 228 deletions(-)

diff --git a/bn-BD/README_bn-BD.md b/bn-BD/README_bn-BD.md
index 5284585b..af201342 100644
--- a/bn-BD/README_bn-BD.md
+++ b/bn-BD/README_bn-BD.md
@@ -52,7 +52,7 @@
 function sayHi() {
   console.log(name);
   console.log(age);
-  var name = 'Lydia';
+  var name = "Lydia";
   let age = 21;
 }
 
@@ -148,7 +148,7 @@ console.log(shape.perimeter());
 
 ```javascript
 +true;
-!'Lydia';
+!"Lydia";
 ```
 
 - A: `1` and `false`
@@ -173,11 +173,11 @@ console.log(shape.perimeter());
 
 ```javascript
 const bird = {
-  size: 'small',
+  size: "small",
 };
 
 const mouse = {
-  name: 'Mickey',
+  name: "Mickey",
   small: true,
 };
 ```
@@ -206,11 +206,11 @@ const mouse = {
 ###### 6. এটার আউটপুট কোনটা?
 
 ```javascript
-let c = { greeting: 'Hey!' };
+let c = { greeting: "Hey!" };
 let d;
 
 d = c;
-c.greeting = 'Hello';
+c.greeting = "Hello";
 console.log(d.greeting);
 ```
 
@@ -280,13 +280,13 @@ class Chameleon {
     return this.newColor;
   }
 
-  constructor({ newColor = 'green' } = {}) {
+  constructor({ newColor = "green" } = {}) {
     this.newColor = newColor;
   }
 }
 
-const freddie = new Chameleon({ newColor: 'purple' });
-console.log(freddie.colorChange('orange'));
+const freddie = new Chameleon({ newColor: "purple" });
+console.log(freddie.colorChange("orange"));
 ```
 
 - A: `orange`
@@ -341,10 +341,10 @@ console.log(greetign);
 
 ```javascript
 function bark() {
-  console.log('Woof!');
+  console.log("Woof!");
 }
 
-bark.animal = 'dog';
+bark.animal = "dog";
 ```
 
 - A: Nothing, this is totally fine!
@@ -374,7 +374,7 @@ function Person(firstName, lastName) {
   this.lastName = lastName;
 }
 
-const member = new Person('Lydia', 'Hallie');
+const member = new Person("Lydia", "Hallie");
 Person.getFullName = function () {
   return `${this.firstName} ${this.lastName}`;
 };
@@ -415,8 +415,8 @@ function Person(firstName, lastName) {
   this.lastName = lastName;
 }
 
-const lydia = new Person('Lydia', 'Hallie');
-const sarah = Person('Sarah', 'Smith');
+const lydia = new Person("Lydia", "Hallie");
+const sarah = Person("Sarah", "Smith");
 
 console.log(lydia);
 console.log(sarah);
@@ -486,7 +486,7 @@ function sum(a, b) {
   return a + b;
 }
 
-sum(1, '2');
+sum(1, "2");
 ```
 
 - A: `NaN`
@@ -553,7 +553,7 @@ function getPersonInfo(one, two, three) {
   console.log(three);
 }
 
-const person = 'Lydia';
+const person = "Lydia";
 const age = 21;
 
 getPersonInfo`${person} is ${age} years old`;
@@ -580,9 +580,9 @@ getPersonInfo`${person} is ${age} years old`;
 ```javascript
 function checkAge(data) {
   if (data === { age: 18 }) {
-    console.log('You are an adult!');
+    console.log("You are an adult!");
   } else if (data == { age: 18 }) {
-    console.log('You are still an adult.');
+    console.log("You are still an adult.");
   } else {
     console.log(`Hmm.. You don't have an age I guess`);
   }
@@ -642,7 +642,7 @@ getAge(21);
 
 ```javascript
 function getAge() {
-  'use strict';
+  "use strict";
   age = 21;
   console.log(age);
 }
@@ -670,7 +670,7 @@ getAge();
 ###### 21. কোনটি `sum` এর ভ্যালু হবে?
 
 ```javascript
-const sum = eval('10*10+5');
+const sum = eval("10*10+5");
 ```
 
 - A: `105`
@@ -693,7 +693,7 @@ const sum = eval('10*10+5');
 ###### 22. কতক্ষণ cool_secret এক্সেসযোগ্য?
 
 ```javascript
-sessionStorage.setItem('cool_secret', 123);
+sessionStorage.setItem("cool_secret", 123);
 ```
 
 - A: Forever, the data doesn't get lost.
@@ -746,12 +746,12 @@ console.log(num);
 ###### 24. এটার আউটপুট কোনটা?
 
 ```javascript
-const obj = { 1: 'a', 2: 'b', 3: 'c' };
+const obj = { 1: "a", 2: "b", 3: "c" };
 const set = new Set([1, 2, 3, 4, 5]);
 
-obj.hasOwnProperty('1');
+obj.hasOwnProperty("1");
 obj.hasOwnProperty(1);
-set.has('1');
+set.has("1");
 set.has(1);
 ```
 
@@ -777,7 +777,7 @@ set.has(1);
 ###### 25. এটার আউটপুট কোনটা?
 
 ```javascript
-const obj = { a: 'one', b: 'two', a: 'three' };
+const obj = { a: "one", b: "two", a: "three" };
 console.log(obj);
 ```
 
@@ -846,10 +846,10 @@ for (let i = 1; i < 5; i++) {
 
 ```javascript
 String.prototype.giveLydiaPizza = () => {
-  return 'Just give Lydia pizza already!';
+  return "Just give Lydia pizza already!";
 };
 
-const name = 'Lydia';
+const name = "Lydia";
 
 console.log(name.giveLydiaPizza());
 ```
@@ -877,8 +877,8 @@ console.log(name.giveLydiaPizza());
 
 ```javascript
 const a = {};
-const b = { key: 'b' };
-const c = { key: 'c' };
+const b = { key: "b" };
+const c = { key: "c" };
 
 a[b] = 123;
 a[c] = 456;
@@ -910,9 +910,9 @@ console.log(a[b]);
 ###### 30. এটার আউটপুট কোনটা?
 
 ```javascript
-const foo = () => console.log('First');
-const bar = () => setTimeout(() => console.log('Second'));
-const baz = () => console.log('Third');
+const foo = () => console.log("First");
+const bar = () => setTimeout(() => console.log("Second"));
+const baz = () => console.log("Third");
 
 bar();
 foo();
@@ -1018,7 +1018,7 @@ If we click `p`, we see two logs: `p` and `div`. During event propagation, there
 ###### 33. এটার আউটপুট কোনটা?
 
 ```javascript
-const person = { name: 'Lydia' };
+const person = { name: "Lydia" };
 
 function sayHi(age) {
   return `${this.name} is ${age}`;
@@ -1081,8 +1081,8 @@ console.log(typeof sayHi());
 ```javascript
 0;
 new Number(0);
-('');
-(' ');
+("");
+(" ");
 new Boolean(false);
 undefined;
 ```
@@ -1265,7 +1265,7 @@ console.log(numbers);
 
 ```javascript
 !!null;
-!!'';
+!!"";
 !!1;
 ```
 
@@ -1295,7 +1295,7 @@ console.log(numbers);
 ###### 42. এই `setInterval` মেথডটি ব্রাউজারে কি রিটার্ন করে?
 
 ```javascript
-setInterval(() => console.log('Hi'), 1000);
+setInterval(() => console.log("Hi"), 1000);
 ```
 
 - A: a unique id
@@ -1318,7 +1318,7 @@ setInterval(() => console.log('Hi'), 1000);
 ###### 43. এটা কি রিটার্ন করে?
 
 ```javascript
-[...'Lydia'];
+[..."Lydia"];
 ```
 
 - A: `["L", "y", "d", "i", "a"]`
@@ -1377,11 +1377,11 @@ console.log(gen.next().value);
 
 ```javascript
 const firstPromise = new Promise((res, rej) => {
-  setTimeout(res, 500, 'one');
+  setTimeout(res, 500, "one");
 });
 
 const secondPromise = new Promise((res, rej) => {
-  setTimeout(res, 100, 'two');
+  setTimeout(res, 100, "two");
 });
 
 Promise.race([firstPromise, secondPromise]).then((res) => console.log(res));
@@ -1407,7 +1407,7 @@ Promise.race([firstPromise, secondPromise]).then((res) => console.log(res));
 ###### 46. এটার আউটপুট কোনটা?
 
 ```javascript
-let person = { name: 'Lydia' };
+let person = { name: "Lydia" };
 const members = [person];
 person = null;
 
@@ -1447,7 +1447,7 @@ console.log(members);
 
 ```javascript
 const person = {
-  name: 'Lydia',
+  name: "Lydia",
   age: 21,
 };
 
@@ -1476,7 +1476,7 @@ for (const item in person) {
 ###### 48. এটার আউটপুট কোনটা?
 
 ```javascript
-console.log(3 + 4 + '5');
+console.log(3 + 4 + "5");
 ```
 
 - A: `"345"`
@@ -1503,7 +1503,7 @@ console.log(3 + 4 + '5');
 ###### 49. `num` এর ভ্যালু কোনটি?
 
 ```javascript
-const num = parseInt('7*6', 10);
+const num = parseInt("7*6", 10);
 ```
 
 - A: `42`
@@ -1529,7 +1529,7 @@ const num = parseInt('7*6', 10);
 
 ```javascript
 [1, 2, 3].map((num) => {
-  if (typeof num === 'number') return;
+  if (typeof num === "number") return;
   return num * 2;
 });
 ```
@@ -1557,12 +1557,12 @@ const num = parseInt('7*6', 10);
 
 ```javascript
 function getInfo(member, year) {
-  member.name = 'Lydia';
-  year = '1998';
+  member.name = "Lydia";
+  year = "1998";
 }
 
-const person = { name: 'Sarah' };
-const birthYear = '1997';
+const person = { name: "Sarah" };
+const birthYear = "1997";
 
 getInfo(person, birthYear);
 
@@ -1594,15 +1594,15 @@ console.log(person, birthYear);
 
 ```javascript
 function greeting() {
-  throw 'Hello world!';
+  throw "Hello world!";
 }
 
 function sayHi() {
   try {
     const data = greeting();
-    console.log('It worked!', data);
+    console.log("It worked!", data);
   } catch (e) {
-    console.log('Oh no an error:', e);
+    console.log("Oh no an error:", e);
   }
 }
 
@@ -1632,8 +1632,8 @@ sayHi();
 
 ```javascript
 function Car() {
-  this.make = 'Lamborghini';
-  return { make: 'Maserati' };
+  this.make = "Lamborghini";
+  return { make: "Maserati" };
 }
 
 const myCar = new Car();
@@ -1711,7 +1711,7 @@ Dog.prototype.bark = function () {
   console.log(`Woof I am ${this.name}`);
 };
 
-const pet = new Dog('Mara');
+const pet = new Dog("Mara");
 
 pet.bark();
 
@@ -1776,7 +1776,7 @@ export default counter;
 
 ```javascript
 // index.js
-import myCounter from './counter';
+import myCounter from "./counter";
 
 myCounter += 1;
 
@@ -1805,7 +1805,7 @@ console.log(myCounter);
 ###### 58. এটার আউটপুট কোনটা?
 
 ```javascript
-const name = 'Lydia';
+const name = "Lydia";
 age = 21;
 
 console.log(delete name);
@@ -1876,7 +1876,7 @@ console.log(y);
 ###### 60. এটার আউটপুট কোনটা?
 
 ```javascript
-const user = { name: 'Lydia', age: 21 };
+const user = { name: "Lydia", age: 21 };
 const admin = { admin: true, ...user };
 
 console.log(admin);
@@ -1902,9 +1902,9 @@ console.log(admin);
 ###### 61. এটার আউটপুট কোনটা?
 
 ```javascript
-const person = { name: 'Lydia' };
+const person = { name: "Lydia" };
 
-Object.defineProperty(person, 'age', { value: 21 });
+Object.defineProperty(person, "age", { value: 21 });
 
 console.log(person);
 console.log(Object.keys(person));
@@ -1933,12 +1933,12 @@ console.log(Object.keys(person));
 
 ```javascript
 const settings = {
-  username: 'lydiahallie',
+  username: "lydiahallie",
   level: 19,
   health: 90,
 };
 
-const data = JSON.stringify(settings, ['level', 'health']);
+const data = JSON.stringify(settings, ["level", "health"]);
 console.log(data);
 ```
 
@@ -2126,12 +2126,12 @@ class Labrador extends Dog {
 
 ```javascript
 // index.js
-console.log('running index.js');
-import { sum } from './sum.js';
+console.log("running index.js");
+import { sum } from "./sum.js";
 console.log(sum(1, 2));
 
 // sum.js
-console.log('running sum.js');
+console.log("running sum.js");
 export const sum = (a, b) => a + b;
 ```
 
@@ -2159,7 +2159,7 @@ export const sum = (a, b) => a + b;
 ```javascript
 console.log(Number(2) === Number(2));
 console.log(Boolean(false) === Boolean(false));
-console.log(Symbol('foo') === Symbol('foo'));
+console.log(Symbol("foo") === Symbol("foo"));
 ```
 
 - A: `true`, `true`, `false`
@@ -2182,7 +2182,7 @@ console.log(Symbol('foo') === Symbol('foo'));
 ###### 69. এটার আউটপুট কোনটা?
 
 ```javascript
-const name = 'Lydia Hallie';
+const name = "Lydia Hallie";
 console.log(name.padStart(13));
 console.log(name.padStart(2));
 ```
@@ -2209,7 +2209,7 @@ console.log(name.padStart(2));
 ###### 70. এটার আউটপুট কোনটা?
 
 ```javascript
-console.log('🥑' + '💻');
+console.log("🥑" + "💻");
 ```
 
 - A: `"🥑💻"`
@@ -2233,11 +2233,11 @@ console.log('🥑' + '💻');
 
 ```javascript
 function* startGame() {
-  const answer = yield 'Do you love JavaScript?';
-  if (answer !== 'Yes') {
+  const answer = yield "Do you love JavaScript?";
+  if (answer !== "Yes") {
     return "Oh wow... Guess we're done here";
   }
-  return 'JavaScript loves you back ❤️';
+  return "JavaScript loves you back ❤️";
 }
 
 const game = startGame();
@@ -2305,7 +2305,7 @@ console.log(String.raw`Hello\nworld`);
 
 ```javascript
 async function getData() {
-  return await Promise.resolve('I made it!');
+  return await Promise.resolve("I made it!");
 }
 
 const data = getData();
@@ -2342,7 +2342,7 @@ function addToList(item, list) {
   return list.push(item);
 }
 
-const result = addToList('apple', ['banana']);
+const result = addToList("apple", ["banana"]);
 console.log(result);
 ```
 
@@ -2402,7 +2402,7 @@ console.log(shape);
 ###### 76. এটার আউটপুট কোনটা?
 
 ```javascript
-const { firstName: myName } = { firstName: 'Lydia' };
+const { firstName: myName } = { firstName: "Lydia" };
 
 console.log(firstName);
 ```
@@ -2420,7 +2420,7 @@ console.log(firstName);
 [ডিস্ট্রাকচারিং অ্যাসাইনমেন্ট](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment) সিনট্যাক্স ব্যবহার করে, আমরা অ্যারের ভ্যালু, বা অবজেক্টের প্রোপার্টি বের করে আলাদা ভ্যারিয়েবলে রাখতে পারিঃ
 
 ```javascript
-const { firstName } = { firstName: 'Lydia' };
+const { firstName } = { firstName: "Lydia" };
 // ES5 version:
 // var firstName = { firstName: 'Lydia' }.firstName;
 
@@ -2430,7 +2430,7 @@ console.log(firstName); // "Lydia"
 আবার, অবজেক্ট থেকে প্রোপার্টি বের করে অবজেক্টের ঐ প্রোপার্টির নামে না রেখে অন্য নামের ভ্যারিয়েবলেও রাখতে পারিঃ
 
 ```javascript
-const { firstName: myName } = { firstName: 'Lydia' };
+const { firstName: myName } = { firstName: "Lydia" };
 // ES5 version:
 // var myName = { firstName: 'Lydia' }.firstName;
 
@@ -2443,7 +2443,7 @@ console.log(firstName); // Uncaught ReferenceError: firstName is not defined
 **দ্রষ্টব্য:** `গ্লোবাল স্কোপ` বৈশিষ্ট্য সম্পর্কে সচেতন থাকুন:
 
 ```javascript
-const { name: myName } = { name: 'Lydia' };
+const { name: myName } = { name: "Lydia" };
 
 console.log(myName); // "lydia"
 console.log(name); // "" ----- Browser e.g. Chrome
@@ -2538,7 +2538,7 @@ console.log(addFunction(5 * 2));
 ###### 79. এটার আউটপুট কোনটা?
 
 ```javascript
-const myLifeSummedUp = ['☕', '💻', '🍷', '🍫'];
+const myLifeSummedUp = ["☕", "💻", "🍷", "🍫"];
 
 for (let item in myLifeSummedUp) {
   console.log(item);
@@ -2634,13 +2634,13 @@ console.log(sayHi());
 ###### 82. এটার আউটপুট কোনটা?
 
 ```javascript
-var status = '😎';
+var status = "😎";
 
 setTimeout(() => {
-  const status = '😍';
+  const status = "😍";
 
   const data = {
-    status: '🥑',
+    status: "🥑",
     getStatus() {
       return this.status;
     },
@@ -2674,12 +2674,12 @@ setTimeout(() => {
 
 ```javascript
 const person = {
-  name: 'Lydia',
+  name: "Lydia",
   age: 21,
 };
 
 let city = person.city;
-city = 'Amsterdam';
+city = "Amsterdam";
 
 console.log(person);
 ```
@@ -2743,7 +2743,7 @@ console.log(checkAge(21));
 ###### 85. এখানে কি ধরনের তথ্য লগ হতে পারে?
 
 ```javascript
-fetch('https://www.website.com/api/user/1')
+fetch("https://www.website.com/api/user/1")
   .then((res) => res.json())
   .then((res) => console.log(res));
 ```
@@ -2799,7 +2799,7 @@ D-র ক্ষেত্রে, `name.length` রিটার্ন করে 
 ###### 87. এটার আউটপুট কোনটা?
 
 ```javascript
-console.log('I want pizza'[0]);
+console.log("I want pizza"[0]);
 ```
 
 - A: `"""`
@@ -2854,11 +2854,11 @@ sum(10);
 
 ```javascript
 // module.js
-export default () => 'Hello world';
-export const name = 'Lydia';
+export default () => "Hello world";
+export const name = "Lydia";
 
 // index.js
-import * as data from './module';
+import * as data from "./module";
 
 console.log(data);
 ```
@@ -2891,7 +2891,7 @@ class Person {
   }
 }
 
-const member = new Person('John');
+const member = new Person("John");
 console.log(typeof member);
 ```
 
@@ -2951,11 +2951,10 @@ console.log(newList.push(5));
 
 ```javascript
 function giveLydiaPizza() {
-  return 'Here is pizza!';
+  return "Here is pizza!";
 }
 
-const giveLydiaChocolate = () =>
-  "Here's chocolate... now go hit the gym already.";
+const giveLydiaChocolate = () => "Here's chocolate... now go hit the gym already.";
 
 console.log(giveLydiaPizza.prototype);
 console.log(giveLydiaChocolate.prototype);
@@ -2982,7 +2981,7 @@ console.log(giveLydiaChocolate.prototype);
 
 ```javascript
 const person = {
-  name: 'Lydia',
+  name: "Lydia",
   age: 21,
 };
 
@@ -3043,7 +3042,7 @@ function getItems(fruitList, favoriteFruit, ...args) {
   return [...fruitList, ...args, favoriteFruit];
 }
 
-getItems(['banana', 'apple'], 'pear', 'orange');
+getItems(["banana", "apple"], "pear", "orange");
 ```
 
 উপরের উদাহরণটি সঠিকভাবে কাজ করে। এটি অ্যারে `[ 'banana', 'apple', 'orange', 'pear' ]` রিটার্ন করে দেয়।
@@ -3057,8 +3056,8 @@ getItems(['banana', 'apple'], 'pear', 'orange');
 
 ```javascript
 function nums(a, b) {
-  if (a > b) console.log('a is bigger');
-  else console.log('b is bigger');
+  if (a > b) console.log("a is bigger");
+  else console.log("b is bigger");
   return;
   a + b;
 }
@@ -3098,13 +3097,13 @@ a + b;
 ```javascript
 class Person {
   constructor() {
-    this.name = 'Lydia';
+    this.name = "Lydia";
   }
 }
 
 Person = class AnotherPerson {
   constructor() {
-    this.name = 'Sarah';
+    this.name = "Sarah";
   }
 };
 
@@ -3133,7 +3132,7 @@ console.log(member.name);
 
 ```javascript
 const info = {
-  [Symbol('a')]: 'b',
+  [Symbol("a")]: "b",
 };
 
 console.log(info);
@@ -3202,7 +3201,7 @@ console.log(getUser(user))
 ###### 99. এটার আউটপুট কোনটা?
 
 ```javascript
-const name = 'Lydia';
+const name = "Lydia";
 
 console.log(name());
 ```
@@ -3235,8 +3234,8 @@ console.log(name());
 ```javascript
 // 🎉✨ This is my 100th question! ✨🎉
 
-const output = `${[] && 'Im'}possible!
-You should${'' && `n't`} see a therapist after so much JavaScript lol`;
+const output = `${[] && "Im"}possible!
+You should${"" && `n't`} see a therapist after so much JavaScript lol`;
 ```
 
 - A: `possible! You should see a therapist after so much JavaScript lol`
@@ -3262,7 +3261,7 @@ You should${'' && `n't`} see a therapist after so much JavaScript lol`;
 
 ```javascript
 const one = false || {} || null;
-const two = null || false || '';
+const two = null || false || "";
 const three = [] || 0 || true;
 
 console.log(one, two, three);
@@ -3294,16 +3293,16 @@ console.log(one, two, three);
 ###### 102. এটার আউটপুটের ভ্যালু কি?
 
 ```javascript
-const myPromise = () => Promise.resolve('I have resolved!');
+const myPromise = () => Promise.resolve("I have resolved!");
 
 function firstFunction() {
   myPromise().then((res) => console.log(res));
-  console.log('second');
+  console.log("second");
 }
 
 async function secondFunction() {
   console.log(await myPromise());
-  console.log('second');
+  console.log("second");
 }
 
 firstFunction();
@@ -3341,8 +3340,8 @@ secondFunction();
 const set = new Set();
 
 set.add(1);
-set.add('Lydia');
-set.add({ name: 'Lydia' });
+set.add("Lydia");
+set.add({ name: "Lydia" });
 
 for (let item of set) {
   console.log(item + 2);
@@ -3402,13 +3401,13 @@ Promise.resolve(5);
 ```javascript
 function compareMembers(person1, person2 = person) {
   if (person1 !== person2) {
-    console.log('Not the same!');
+    console.log("Not the same!");
   } else {
-    console.log('They are the same!');
+    console.log("They are the same!");
   }
 }
 
-const person = { name: 'Lydia' };
+const person = { name: "Lydia" };
 
 compareMembers(person);
 ```
@@ -3445,7 +3444,7 @@ const colorConfig = {
   yellow: false,
 };
 
-const colors = ['pink', 'red', 'blue'];
+const colors = ["pink", "red", "blue"];
 
 console.log(colorConfig.colors[1]);
 ```
@@ -3474,7 +3473,7 @@ console.log(colorConfig.colors[1]);
 ###### 107. এটার ভ্যালুটি কি হবে?
 
 ```javascript
-console.log('❤️' === '❤️');
+console.log("❤️" === "❤️");
 ```
 
 - A: `true`
@@ -3495,14 +3494,14 @@ console.log('❤️' === '❤️');
 ###### 108. এই মেথডগুলির মধ্যে কোনটি মূল অ্যারে পরিবর্তন করে?
 
 ```javascript
-const emojis = ['✨', '🥑', '😍'];
+const emojis = ["✨", "🥑", "😍"];
 
-emojis.map((x) => x + '✨');
-emojis.filter((x) => x !== '🥑');
-emojis.find((x) => x !== '🥑');
-emojis.reduce((acc, cur) => acc + '✨');
-emojis.slice(1, 2, '✨');
-emojis.splice(1, 2, '✨');
+emojis.map((x) => x + "✨");
+emojis.filter((x) => x !== "🥑");
+emojis.find((x) => x !== "🥑");
+emojis.reduce((acc, cur) => acc + "✨");
+emojis.slice(1, 2, "✨");
+emojis.splice(1, 2, "✨");
 ```
 
 - A: `All of them`
@@ -3527,10 +3526,10 @@ emojis.splice(1, 2, '✨');
 ###### 109. এটার আউটপুট কোনটা?
 
 ```javascript
-const food = ['🍕', '🍫', '🥑', '🍔'];
+const food = ["🍕", "🍫", "🥑", "🍔"];
 const info = { favoriteFood: food[0] };
 
-info.favoriteFood = '🍝';
+info.favoriteFood = "🍝";
 
 console.log(food);
 ```
@@ -3584,7 +3583,7 @@ const jsonArray = JSON.stringify([1, 2, 3]); // '[1, 2, 3]'
 JSON.parse(jsonArray); // [1, 2, 3]
 
 // Stringifying an object into valid JSON, then parsing the JSON string to a JavaScript value:
-const jsonObject = JSON.stringify({ name: 'Lydia' }); // '{"name":"Lydia"}'
+const jsonObject = JSON.stringify({ name: "Lydia" }); // '{"name":"Lydia"}'
 JSON.parse(jsonObject); // { name: 'Lydia' }
 ```
 
@@ -3596,11 +3595,11 @@ JSON.parse(jsonObject); // { name: 'Lydia' }
 ###### 111. এটার আউটপুট কোনটা?
 
 ```javascript
-let name = 'Lydia';
+let name = "Lydia";
 
 function getName() {
   console.log(name);
-  let name = 'Sarah';
+  let name = "Sarah";
 }
 
 getName();
@@ -3623,7 +3622,7 @@ getName();
 যদি `name` ভ্যারিয়েবলটিকে আমরা `getName` ফাংশনে ডিক্লেয়ার না করতাম, জাভাস্ক্রিপ্ট ইঞ্জিন তাকে _scope chain_ এর ভিতর খুঁজে দেখত। বাইরের স্কোপেও একটি `name` ভ্যারিয়াবল আছে যার ভ্যালু একটি স্ট্রিং - `Lydia`। এক্ষেত্রে, এটা লগ করত `Lydia`।
 
 ```javascript
-let name = 'Lydia';
+let name = "Lydia";
 
 function getName() {
   console.log(name);
@@ -3641,11 +3640,11 @@ getName(); // Lydia
 
 ```javascript
 function* generatorOne() {
-  yield ['a', 'b', 'c'];
+  yield ["a", "b", "c"];
 }
 
 function* generatorTwo() {
-  yield* ['a', 'b', 'c'];
+  yield* ["a", "b", "c"];
 }
 
 const one = generatorOne();
@@ -3692,7 +3691,7 @@ console.log(two.next().value); // undefined
 ###### 113. এটার আউটপুট কোনটা?
 
 ```javascript
-console.log(`${((x) => x)('I love')} to program`);
+console.log(`${((x) => x)("I love")} to program`);
 ```
 
 - A: `I love to program`
@@ -3717,7 +3716,7 @@ console.log(`${((x) => x)('I love')} to program`);
 ```javascript
 let config = {
   alert: setInterval(() => {
-    console.log('Alert!');
+    console.log("Alert!");
   }, 1000),
 };
 
@@ -3747,16 +3746,16 @@ config = null;
 
 ```javascript
 const myMap = new Map();
-const myFunc = () => 'greeting';
+const myFunc = () => "greeting";
 
-myMap.set(myFunc, 'Hello world!');
+myMap.set(myFunc, "Hello world!");
 
 //1
-myMap.get('greeting');
+myMap.get("greeting");
 //2
 myMap.get(myFunc);
 //3
-myMap.get(() => 'greeting');
+myMap.get(() => "greeting");
 ```
 
 - A: 1
@@ -3783,14 +3782,14 @@ myMap.get(() => 'greeting');
 
 ```javascript
 const person = {
-  name: 'Lydia',
+  name: "Lydia",
   age: 21,
 };
 
 const changeAge = (x = { ...person }) => (x.age += 1);
 const changeAgeAndName = (x = { ...person }) => {
   x.age += 1;
-  x.name = 'Sarah';
+  x.name = "Sarah";
 };
 
 changeAge(person);
@@ -3849,7 +3848,7 @@ function sumValues(x, y, z) {
 
 ```javascript
 let num = 1;
-const list = ['🥳', '🤠', '🥰', '🤪'];
+const list = ["🥳", "🤠", "🥰", "🤪"];
 
 console.log(list[(num += 1)]);
 ```
@@ -3875,11 +3874,11 @@ console.log(list[(num += 1)]);
 
 ```javascript
 const person = {
-  firstName: 'Lydia',
-  lastName: 'Hallie',
+  firstName: "Lydia",
+  lastName: "Hallie",
   pet: {
-    name: 'Mara',
-    breed: 'Dutch Tulip Hound',
+    name: "Mara",
+    breed: "Dutch Tulip Hound",
   },
   getFullName() {
     return `${this.firstName} ${this.lastName}`;
@@ -3920,10 +3919,10 @@ console.log(member.getLastName?.());
 ###### 120. এটার আউটপুট কোনটা?
 
 ```javascript
-const groceries = ['banana', 'apple', 'peanuts'];
+const groceries = ["banana", "apple", "peanuts"];
 
-if (groceries.indexOf('banana')) {
-  console.log('We have to buy bananas!');
+if (groceries.indexOf("banana")) {
+  console.log("We have to buy bananas!");
 } else {
   console.log(`We don't have to buy bananas!`);
 }
@@ -3979,10 +3978,10 @@ console.log(config.language);
 ###### 122. এটার আউটপুট কোনটা?
 
 ```javascript
-const name = 'Lydia Hallie';
+const name = "Lydia Hallie";
 
-console.log(!typeof name === 'object');
-console.log(!typeof name === 'string');
+console.log(!typeof name === "object");
+console.log(!typeof name === "string");
 ```
 
 - A: `false` `true`
@@ -4025,7 +4024,10 @@ add(4)(5)(6);
 
 #### উত্তর: A
 
-The `add` function returns an arrow function, which returns an arrow function, which returns an arrow function (still with me?). The first function receives an argument `x` with the value of `4`. We invoke the second function, which receives an argument `y` with the value `5`. Then we invoke the third function, which receives an argument `z` with the value `6`. When we're trying to access the value `x`, `y` and `z` within the last arrow function, the JS engine goes up the scope chain in order to find the values for `x` and `y` accordingly. This returns `4` `5` `6`.
+`add` ফাংশনটি একটি অ্যারো ফাংশন রিটার্ন করে (একে বলা হয় curried function), যেটা একটি অ্যারো ফাংশন রিটার্ন করে, যেটা একটি অ্যারো ফাংশন রিটার্ন করে (মাথা খারাপ হচ্ছে নাতো 🤯)। ১ম ফাংশন একটি আর্গুমেন্ট রিসিভ করে `x` যার ভ্যালু হলো `4`। আমরা ২য় ফাংশনটি কল করি, যেটা একটি আর্গুমেন্ট রিসিভ করে `y` যার ভ্যালু হলো `5`। এরপর আমরা ৩য় ফাংশনটি কল করি, যেটা একটি আর্গুমেন্ট রিসিভ করে `z` যার ভ্যালু হলো `6`। আমরা যখন শেষ অ্যারো ফাংশনে `x`, `y` ও `z` ভ্যালুকে এক্সেস করার চেষ্টা করছি, জাভাস্ক্রিপ্ট ইঞ্জিন `x` ও `y` এর ভ্যালুগুলোর জন্য তাদের অবস্থান অনুসারে স্কোপ চেইনের উপরে যাচ্ছে। লগ করছে `4` `5` `6` এবং রিটার্ন করছে `15`।
+
+> - ক্যারি ফাংশন (curried functions) ক্লোজার ([closures](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Closures)) এর মাধ্যমে একাধিক ফাংশন কলের মধ্যে স্টেট মেইন্টেইন করে। প্রতিটি রিটার্ন হওয়া ফাংশন তার স্কোপ ভ্যারিয়েবলের ভ্যালুকে মনে রাখে।
+> - যখন আপনি `add(4)(5)(6)` কল করছেন, ইনার ফাংশনগুলোতে `x` ও `y` এর ভ্যালু যথাক্রমে, `4` ও `5` এর এক্সেস এখনো থাকছে, যদিও তারা ভিন্ন কনট্যাক্সে চলে।
 
 </p>
 </details>
@@ -4059,7 +4061,7 @@ async function* range(start, end) {
 
 #### উত্তর: C
 
-The generator function `range` returns an async object with promises for each item in the range we pass: `Promise{1}`, `Promise{2}`, `Promise{3}`. We set the variable `gen` equal to the async object, after which we loop over it using a `for await ... of` loop. We set the variable `item` equal to the returned Promise values: first `Promise{1}`, then `Promise{2}`, then `Promise{3}`. Since we're _awaiting_ the value of `item`, the resolved promise, the resolved _values_ of the promises get returned: `1`, `2`, then `3`.
+আমরা যে রেঞ্জটি পাস করছি তাদের প্রতিটির জন্য জেনারেটর ফাংশন `range` প্রমিসসহ একটি এসিঙ্ক অবজেক্ট রিটার্ন করেঃ `Promise{1}`, `Promise{2}`, `Promise{3}`। `gen` ভ্যারিয়েবল সমান সেট করছি এই এসিঙ্ক অবজেক্টিকে, পরবর্তিতে যেটার উপর আমরা `for await ... of` লুপ চালাচ্ছি। এখানে `item` ভ্যারিয়েবল সমান সেট করছি রিটার্ন করা প্রমিস ভ্যালুগুলোকেঃ ১মে `Promise{1}`, পরবর্তিতে `Promise{2}`, পরবর্তিতে `Promise{3}`। যেহেতু আমরা `item` ভ্যারিয়েবলের জন্য _awaiting_ করছি, তাই প্রমিসের রিসল্ভড _ভ্যালুগুলোই_ রিটার্ন হচ্ছেঃ `1`, `2`, ও `3`।
 
 </p>
 </details>
@@ -4086,7 +4088,7 @@ myFunc(1, 2, 3);
 
 #### উত্তর: D
 
-`myFunc` expects an object with properties `x`, `y` and `z` as its argument. Since we're only passing three separate numeric values (1, 2, 3) instead of one object with properties `x`, `y` and `z` ({x: 1, y: 2, z: 3}), `x`, `y` and `z` have their default value of `undefined`.
+`myFunc` ফাংশনটি আর্গুমেন্টে আশা করছে একটি অবজেক্ট যার `x`, `y` ও `z` প্রোপার্টিগুলো আছে। যেহেতু আমরা একটি `x`, `y` ও `z` প্রোপার্টিসহ একটি অবজেক্টের পরিবর্তে ({x: 1, y: 2, z: 3}) আলাদা আলদা সংখ্যাসুচক ভ্যালু (1, 2, 3) পাস করছি, `x`, `y` ও `z`এর ভ্যালুগুলো তাদের ডিফল্ট ভ্যালু `undefined`-ই থাকছে।q
 
 </p>
 </details>
@@ -4097,14 +4099,14 @@ myFunc(1, 2, 3);
 
 ```javascript
 function getFine(speed, amount) {
-  const formattedSpeed = new Intl.NumberFormat('en-US', {
-    style: 'unit',
-    unit: 'mile-per-hour',
+  const formattedSpeed = new Intl.NumberFormat("en-US", {
+    style: "unit",
+    unit: "mile-per-hour",
   }).format(speed);
 
-  const formattedAmount = new Intl.NumberFormat('en-US', {
-    style: 'currency',
-    currency: 'USD',
+  const formattedAmount = new Intl.NumberFormat("en-US", {
+    style: "currency",
+    currency: "USD",
   }).format(amount);
 
   return `The driver drove ${formattedSpeed} and has to pay ${formattedAmount}`;
@@ -4123,7 +4125,7 @@ console.log(getFine(130, 300));
 
 #### উত্তর: B
 
-With the `Intl.NumberFormat` method, we can format numeric values to any locale. We format the numeric value `130` to the `en-US` locale as a `unit` in `mile-per-hour`, which results in `130 mph`. The numeric value `300` to the `en-US` locale as a `currency` in `USD` results in `$300.00`.
+`Intl.NumberFormat` মেথড ব্যাবহার করে সংখ্যাসুচক ভ্যালুকে কোন একটি লোকালে ফরম্যাট করতে পারি। আমরা সংখ্যাসুচক ভ্যালু `130` কে `unit` হিসেবে `mile-per-hour` দিয়ে `en-US` লোকালে ফরম্যাট করেছি, যেটা ফলাফল দিয়েছে `130 mph`। একইভাবে সংখ্যাসুচক ভ্যালু `300` কে `currency` হিসেবে `USD` দিয়ে `en-US` লোকালে ফরম্যাট করেছি যেটার ফলাফল হয় `$300.00`।
 
 </p>
 </details>
@@ -4133,8 +4135,8 @@ With the `Intl.NumberFormat` method, we can format numeric values to any locale.
 ###### 127. এটার আউটপুট কোনটা?
 
 ```javascript
-const spookyItems = ['👻', '🎃', '🕸'];
-({ item: spookyItems[3] } = { item: '💀' });
+const spookyItems = ["👻", "🎃", "🕸"];
+({ item: spookyItems[3] } = { item: "💀" });
 
 console.log(spookyItems);
 ```
@@ -4149,7 +4151,7 @@ console.log(spookyItems);
 
 #### উত্তর: B
 
-By destructuring objects, we can unpack values from the right-hand object, and assign the unpacked value to the value of the same property name on the left-hand object. In this case, we're assigning the value "💀" to `spookyItems[3]`. This means that we're modifying the `spookyItems` array, we're adding the "💀" to it. When logging `spookyItems`, `["👻", "🎃", "🕸", "💀"]` gets logged.
+অবজেক্ট ডিস্ট্রাকচারিং ([ডিস্ট্রাকচারিং অ্যাসাইনমেন্ট](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment)) এর মাধ্যমে, ডানপক্ষের অবজেক্টের ভ্যালুগুলোকে বের করে বামপক্ষের অবজেক্টের একই নামের প্রোপার্টির ভ্যালু দিয়ে অ্যাসাইন করতে পারি। এক্ষেত্রে, আমরা "💀" ভ্যালুটিকে `spookyItems[3]`-তে অ্যাসাইন করছি। এর মানে হলো, "💀" ভ্যালুটিকে যুক্ত করে আমরা `spookyItems` অ্যারেকে পরিবর্তন করেছি। তাই `spookyItems` কে লগ করায় `["👻", "🎃", "🕸", "💀"]` লগ হয়েছে।
 
 </p>
 </details>
@@ -4159,7 +4161,7 @@ By destructuring objects, we can unpack values from the right-hand object, and a
 ###### 128. এটার আউটপুট কোনটা?
 
 ```javascript
-const name = 'Lydia Hallie';
+const name = "Lydia Hallie";
 const age = 21;
 
 console.log(Number.isNaN(name));
@@ -4179,9 +4181,9 @@ console.log(isNaN(age));
 
 #### উত্তর: C
 
-With the `Number.isNaN` method, you can check if the value you pass is a _numeric value_ and equal to `NaN`. `name` is not a numeric value, so `Number.isNaN(name)` returns `false`. `age` is a numeric value, but is not equal to `NaN`, so `Number.isNaN(age)` returns `false`.
+`Number.isNaN` মেথডের মাধ্যমে, আপনি চেক করতে পারেন যে ভ্যালুটি আপনি পাস করছেন সেটা _সংখ্যাসুচক ভ্যালু_ এবং _`NaN`_ এর সমান হচ্ছে কিনা। `name` সংখ্যাসুচক ভ্যালু নয়, তাই `Number.isNaN(name)` রিটার্ন করছে `false`। `age` সংখ্যাসুচক ভ্যালু কিন্তু `NaN` এর সমান নয়, তাই `Number.isNaN(age)` রিটার্ন করছে `false`।
 
-With the `isNaN` method, you can check if the value you pass is not a number. `name` is not a number, so `isNaN(name)` returns true. `age` is a number, so `isNaN(age)` returns `false`.
+অন্যদিকে `isNaN` মেথডের মাধ্যমে, আপনি কেবল চেক করতে পারেন যে ভ্যালুটি আপনি পাস করছেন সেটা কোন _সংখ্যা নয়_ কিনা। `name` কোন সংখ্যা নয়, তাই `isNaN(name)` রিটার্ন করছে `true`। `age` একটি সংখ্যা, তাই `isNaN(age)` রিটার্ন করছে `false`
 
 </p>
 </details>
@@ -4195,7 +4197,7 @@ const randomValue = 21;
 
 function getInfo() {
   console.log(typeof randomValue);
-  const randomValue = 'Lydia Hallie';
+  const randomValue = "Lydia Hallie";
 }
 
 getInfo();
@@ -4211,7 +4213,9 @@ getInfo();
 
 #### উত্তর: D
 
-Variables declared with the `const` keyword are not referenceable before their initialization: this is called the _temporal dead zone_. In the `getInfo` function, the variable `randomValue` is scoped in the functional scope of `getInfo`. On the line where we want to log the value of `typeof randomValue`, the variable `randomValue` isn't initialized yet: a `ReferenceError` gets thrown! The engine didn't go down the scope chain since we declared the variable `randomValue` in the `getInfo` function.
+`const` (ও `let`) কিওয়ার্ড দিয়ে ডিক্লেয়ার করা ভ্যারিয়েবলগুলো যে লাইনে ডিক্লেয়ার (ইনিশিয়ালাইজ) করা হয়েছে তার আগে এদেরকে এক্সেস (রিড/রাইট) বা রেফারেন্স করা যায় না। এটাকে **"টেম্পোরাল ডেড জোন"** বলা হয়। তাই ভেরিয়েবলকে ইনিশিয়ালাইজেশনের আগে এক্সেস করার চেষ্টা করা হলে জাভাস্ক্রিপ্ট `ReferenceError` দেয়।
+
+`getInfo` ফাংশনের `randomValue` ভেরিয়েবলটির স্কোপ হচ্ছে তার ফাংশনাল স্কোপ - `getInfo`। যে লাইনে আমরা `typeof randomValue` এর ভ্যালুকে লগ করছি, তখনো `randomValue` ইনিশিয়ালাইজ হয়নিঃ একটি `ReferenceError` হচ্ছে! জাভাস্ক্রিপ্ট ইঞ্জিন স্কোপ চেইনে খুঁজে দেখছে না যেহেতু আমরা `randomValue` ভেরিয়েবলটিকে `getInfo` ফাংশনেই ডিক্লেয়ার করেছি।
 
 </p>
 </details>
@@ -4221,7 +4225,7 @@ Variables declared with the `const` keyword are not referenceable before their i
 ###### 130. এটার আউটপুট কোনটা?
 
 ```javascript
-const myPromise = Promise.resolve('Woah some cool data');
+const myPromise = Promise.resolve("Woah some cool data");
 
 (async () => {
   try {
@@ -4229,7 +4233,7 @@ const myPromise = Promise.resolve('Woah some cool data');
   } catch {
     throw new Error(`Oops didn't work`);
   } finally {
-    console.log('Oh finally!');
+    console.log("Oh finally!");
   }
 })();
 ```
@@ -4244,7 +4248,7 @@ const myPromise = Promise.resolve('Woah some cool data');
 
 #### উত্তর: C
 
-In the `try` block, we're logging the awaited value of the `myPromise` variable: `"Woah some cool data"`. Since no errors were thrown in the `try` block, the code in the `catch` block doesn't run. The code in the `finally` block _always_ runs, `"Oh finally!"` gets logged.
+`try` ব্লকে, আমরা `myPromise` ভেরিয়েবলের অপেক্ষিত ভ্যালুটি লগ করার চেষ্টা করছি: `"Woah some cool data"`। যেহেতু `try` ব্লকে কোনো এরর থ্রো হয়নি, `catch` ব্লকের কোড রান হয় না। `finally` ব্লকের কোড _সবসময়ই_ রান হয়, তাই `"Oh finally!"` লগ হয়।
 
 </p>
 </details>
@@ -4254,7 +4258,7 @@ In the `try` block, we're logging the awaited value of the `myPromise` variable:
 ###### 131. এটার আউটপুট কোনটা?
 
 ```javascript
-const emojis = ['🥑', ['✨', '✨', ['🍕', '🍕']]];
+const emojis = ["🥑", ["✨", "✨", ["🍕", "🍕"]]];
 
 console.log(emojis.flat(1));
 ```
@@ -4269,7 +4273,7 @@ console.log(emojis.flat(1));
 
 #### উত্তর: B
 
-With the `flat` method, we can create a new, flattened array. The depth of the flattened array depends on the value that we pass. In this case, we passed the value `1` (which we didn't have to, that's the default value), meaning that only the arrays on the first depth will be concatenated. `['🥑']` and `['✨', '✨', ['🍕', '🍕']]` in this case. Concatenating these two arrays results in `['🥑', '✨', '✨', ['🍕', '🍕']]`.
+`flat` পদ্ধতির সাহায্যে, আমরা একটি নতুন, সমতলকৃত অ্যারে তৈরি করতে পারি। সমতলকৃত অ্যারের গভীরতা নির্ভর করে যে মানটি আমরা পাস করি তার উপর। এই ক্ষেত্রে, আমরা মান `1` পাস করেছি (যা আমাদের পাস না করলেও হত, এটি ডিফল্ট মান), এর অর্থ হল কেবলমাত্র প্রথম স্তরের অ্যারেগুলি সংযুক্ত হবে। এই ক্ষেত্রে `['🥑']` এবং `['✨', '✨', ['🍕', '🍕']]`। এই দুটি অ্যারে সংযুক্ত করার ফলে `['🥑', '✨', '✨', ['🍕', '🍕']]` পাওয়া যায়।
 
 </p>
 </details>
@@ -4309,13 +4313,13 @@ console.log(counterOne.count);
 
 #### উত্তর: D
 
-`counterOne` is an instance of the `Counter` class. The counter class contains a `count` property on its constructor, and an `increment` method. First, we invoked the `increment` method twice by calling `counterOne.increment()`. Currently, `counterOne.count` is `2`.
+`counterOne` হল `Counter` ক্লাসের একটি ইনস্ট্যান্স। `Counter` ক্লাসের কনস্ট্রাক্টরে একটি `count` প্রপার্টি এবং একটি `increment` মেথড রয়েছে। প্রথমে, আমরা `counterOne.increment()` কল করে `increment` মেথড দু'বার কল করেছি। বর্তমানে, `counterOne.count` হল `2`।
 
 <img src="https://i.imgur.com/KxLlTm9.png" width="400">
 
-Then, we create a new variable `counterTwo`, and set it equal to `counterOne`. Since objects interact by reference, we're just creating a new reference to the same spot in memory that `counterOne` points to. Since it has the same spot in memory, any changes made to the object that `counterTwo` has a reference to, also apply to `counterOne`. Currently, `counterTwo.count` is `2`.
+তারপর, আমরা একটি নতুন ভেরিয়েবল `counterTwo` তৈরি করি এবং এটিকে `counterOne` এর সমান সেট করি। যেহেতু অবজেক্টগুলি রেফারেন্স দ্বারা ইন্টারঅ্যাক্ট করে, আমরা কেবল `counterOne` যে মেমরির লোকেশনে নির্দেশ করে তার একটি নতুন রেফারেন্স তৈরি করছি। যেহেতু এটি একই মেমরি লোকেশনে নির্দেশ করে, তাই `counterTwo` যেই অবজেক্টটির রেফারেন্স দেয় তাতে করা যেকোনো পরিবর্তন `counterOne` এর ক্ষেত্রেও প্রযোজ্য হবে। বর্তমানে, `counterTwo.count` হল `2`।
 
-We invoke `counterTwo.increment()`, which sets `count` to `3`. Then, we log the count on `counterOne`, which logs `3`.
+আমরা `counterTwo.increment()` কল করি, যা `count` কে সেট করে `3`। তারপর, আমরা `counterOne` এর `count` লগ করি, যা লগ করে `3`।
 
 <img src="https://i.imgur.com/BNBHXmc.png" width="400">
 
@@ -4327,19 +4331,19 @@ We invoke `counterTwo.increment()`, which sets `count` to `3`. Then, we log the
 ###### 133. এটার আউটপুট কোনটা?
 
 ```javascript
-const myPromise = Promise.resolve(Promise.resolve('Promise'));
+const myPromise = Promise.resolve(Promise.resolve("Promise"));
 
 function funcOne() {
-  setTimeout(() => console.log('Timeout 1!'), 0);
+  setTimeout(() => console.log("Timeout 1!"), 0);
   myPromise.then((res) => res).then((res) => console.log(`${res} 1!`));
-  console.log('Last line 1!');
+  console.log("Last line 1!");
 }
 
 async function funcTwo() {
   const res = await myPromise;
   console.log(`${res} 2!`);
-  setTimeout(() => console.log('Timeout 2!'), 0);
-  console.log('Last line 2!');
+  setTimeout(() => console.log("Timeout 2!"), 0);
+  console.log("Last line 2!");
 }
 
 funcOne();
@@ -4356,19 +4360,19 @@ funcTwo();
 
 #### উত্তর: C
 
-First, we invoke `funcOne`. On the first line of `funcOne`, we call the _asynchronous_ `setTimeout` function, from which the callback is sent to the Web API. (see my article on the event loop <a href="https://dev.to/lydiahallie/javascript-visualized-event-loop-3dif">here</a>.)
+প্রথমে, আমরা `funcOne` ফাংশন চালিয়েছি। `funcOne` এর ১ম লাইনে আমরা _অ্যাসিঙ্ক্রোনাস_ `setTimeout` ফাংশনটি কল করছি, যেখান থেকে কলব্যাকটি Web API এ পাঠানো হয়েছে। (ইভেন্ট লুপের আর্টিক্যালটি পড়ুন <a href="https://dev.to/lydiahallie/javascript-visualized-event-loop-3dif">এখান থেকে</a>.)
 
-Then we call the `myPromise` promise, which is an _asynchronous_ operation. Pay attention, that now only the first then clause was added to the microtask queue.
+পরবর্তিতে আমরা `myPromise` প্রমিসটি কল করেছি যেটা _অ্যাসিঙ্ক্রোনাস_ অপারেশন। মনোযোগ দিন, এখন কেবল `.then()` চেইনের ১ম অংশটি মাইক্রোটাস্ক কিউতে যুক্ত হয়েছে।
 
-Both the promise and the timeout are asynchronous operations, the function keeps on running while it's busy completing the promise and handling the `setTimeout` callback. This means that `Last line 1!` gets logged first, since this is not an asynchonous operation.
+প্রমিস ও টাইম-আউট দুটোই _অ্যাসিঙ্ক্রোনাস_ অপারেশন, ফাংশনটি চলতেই থাকে যখন সে প্রমিস সমাধান এবং টাইম-আউট কলব্যাক হ্যান্ডেল করতে থাকে। এর মানে হলো `Last line 1!` লগ হচ্ছে প্রথমে, যেহেতু এটা কোন _অ্যাসিঙ্ক্রোনাস_ অপারেশন নয়।
 
-Since the callstack is not empty yet, the `setTimeout` function and promise in `funcOne` cannot get added to the callstack yet.
+যেহেতু কলস্ট্যাক এখনো খালি নয় তাই `funcOne` এর `setTimeout` ফাংশন ও `myPromise` প্রমিস তখনো কলস্ট্যাক এ আসতে পারে না।
 
-In `funcTwo`, the variable `res` gets `Promise` because `Promise.resolve(Promise.resolve('Promise'))` is equivalent to `Promise.resolve('Promise')` since resolving a promise just resolves it's value. The `await` in this line stops the execution of the function until it receives the resolution of the promise and then keeps on running synchronously until completion, so `Promise 2!` and then `Last line 2!` are logged and the `setTimeout` is sent to the Web API. If the first then clause in `funcOne` had its own log statement, it would be printed before `Promise 2!`. Howewer, it executed silently and put the second then clause in microtask queue. So, the second clause will be printed after `Promise 2!`.
+`funcTwo` এ, `res` ভয়ারেয়েবলটি একটি `Promise` পাচ্ছে কারন `Promise.resolve(Promise.resolve('Promise'))` এর সমমান হলো `Promise.resolve('Promise')` যেহেতু একটি প্রমিস সমাধান করা মানে হলো এর ভ্যালুটিকেই সমাধান করা। `await` এর জন্য এই লাইনে ফাংশনটির এক্সিকিউশন থেমে থাকবে যতক্ষণ পর্যন্ত না সে প্রমিস সমাধান ভ্যালু পাচ্ছে এবং সিঙ্ক্রনাসভাবে শেষ হওয়া পর্যন্ত চলতে থাকে, তাই `Promise 2!` ও এর পরে `Last line 2!` লগ হয় এবং `setTimeout` Web API কে পাঠানো হয়। যদি `funcOne` ফাংশনে `.then()` এর ১ম অংশ নিজের কোন লগ স্টেটমেন্ট থাকত, সেটা `Promise 2!` এর আগে প্রিন্ট হত। যাই হোক, এটা চুপচাপ এক্সিকিউট হয় এবং `.then()` এর ২য় অংশকে মাইক্রোটাস্ক কিউতে পাঠিয়ে দেয়। তাই, ২য় অংশটি `Promise 2!` এর পরেই প্রিন্ট হবে।
 
-Then the call stack is empty. Promises are _microtasks_ so they are resolved first when the call stack is empty so `Promise 1!` gets to be logged.
+পরের ধাপে, কল স্ট্যাক খালি। প্রমিসগুলো _মাইক্রোটাস্ক_ ফলে তাঁরা প্রথমে রিসলভ হবে যখন কল স্ট্যাক খালি থাকবে তাই `Promise 1!` লগ হয়েছে।
 
-Now, since `funcTwo` popped off the call stack, the call stack is empty. The callbacks waiting in the queue (`() => console.log("Timeout 1!")` from `funcOne`, and `() => console.log("Timeout 2!")` from `funcTwo`) get added to the call stack one by one. The first callback logs `Timeout 1!`, and gets popped off the stack. Then, the second callback logs `Timeout 2!`, and gets popped off the stack.
+এখন যেহতু `funcTwo` কল স্ট্যাক থেকে রেব হয়ে যায়, কল স্ট্যাক খালি থাকছে। কিউতে যে কলব্যাকগুলি অপেক্ষা করছে (`funcOne` এর - `() => console.log("Timeout 1!")` এবং `funcTwo` এর `() => console.log("Timeout 2!")`) তারা একের পর এক কল স্ট্যাক এ যুক্ত হয়। ১ম কলব্যাক লগ করে `Timeout 1!`, এবং কল স্ট্যাক থেকে রেব হয়ে যায়। এরপর, ২য় কলব্যাক লগ করে `Timeout 2!`, এবং কল স্ট্যাক থেকে রেব হয়ে যায়।
 
 </p>
 </details>
@@ -4384,7 +4388,7 @@ export default function sum(x) {
 }
 
 // index.js
-import * as sum from './sum';
+import * as sum from "./sum";
 ```
 
 - A: `sum(4)`
@@ -4401,12 +4405,12 @@ With the asterisk `*`, we import all exported values from that file, both defaul
 
 ```javascript
 // info.js
-export const name = 'Lydia';
+export const name = "Lydia";
 export const age = 21;
-export default 'I love JavaScript';
+export default "I love JavaScript";
 
 // index.js
-import * as info from './info';
+import * as info from "./info";
 console.log(info);
 ```
 
@@ -4437,13 +4441,13 @@ We can invoke this function, by calling `sum.default`
 
 ```javascript
 const handler = {
-  set: () => console.log('Added a new property!'),
-  get: () => console.log('Accessed a property!'),
+  set: () => console.log("Added a new property!"),
+  get: () => console.log("Accessed a property!"),
 };
 
 const person = new Proxy({}, handler);
 
-person.name = 'Lydia';
+person.name = "Lydia";
 person.name;
 ```
 
@@ -4473,7 +4477,7 @@ Then, we access a property value on the proxy object, and the `get` property on
 ###### 136. Which of the following will modify the `person` object?
 
 ```javascript
-const person = { name: 'Lydia Hallie' };
+const person = { name: "Lydia Hallie" };
 
 Object.seal(person);
 ```
@@ -4501,9 +4505,9 @@ However, you can still modify the value of existing properties.
 
 ```javascript
 const person = {
-  name: 'Lydia Hallie',
+  name: "Lydia Hallie",
   address: {
-    street: '100 Main St',
+    street: "100 Main St",
   },
 };
 
@@ -4603,8 +4607,8 @@ In ES2020, we can add private variables in classes by using the `#`. We cannot a
 
 ```javascript
 const teams = [
-  { name: 'Team 1', members: ['Paul', 'Lisa'] },
-  { name: 'Team 2', members: ['Laura', 'Tim'] },
+  { name: "Team 1", members: ["Paul", "Lisa"] },
+  { name: "Team 2", members: ["Laura", "Tim"] },
 ];
 
 function* getMembers(members) {
@@ -4647,8 +4651,8 @@ If we would've written `yield`, `return yield`, or `return`, the entire generato
 
 ```javascript
 const person = {
-  name: 'Lydia Hallie',
-  hobbies: ['coding'],
+  name: "Lydia Hallie",
+  hobbies: ["coding"],
 };
 
 function addHobby(hobby, hobbies = person.hobbies) {
@@ -4656,9 +4660,9 @@ function addHobby(hobby, hobbies = person.hobbies) {
   return hobbies;
 }
 
-addHobby('running', []);
-addHobby('dancing');
-addHobby('baking', person.hobbies);
+addHobby("running", []);
+addHobby("dancing");
+addHobby("baking", person.hobbies);
 
 console.log(person.hobbies);
 ```
@@ -4727,11 +4731,11 @@ We create the variable `pet` which is an instance of the `Flamingo` class. When
 ###### 143. Which of the options result(s) in an error?
 
 ```javascript
-const emojis = ['🎄', '🎅🏼', '🎁', '⭐'];
+const emojis = ["🎄", "🎅🏼", "🎁", "⭐"];
 
-/* 1 */ emojis.push('🦌');
+/* 1 */ emojis.push("🦌");
 /* 2 */ emojis.splice(0, 2);
-/* 3 */ emojis = [...emojis, '🥂'];
+/* 3 */ emojis = [...emojis, "🥂"];
 /* 4 */ emojis.length = 0;
 ```
 
@@ -4817,9 +4821,9 @@ function getFruit(fruits) {
   console.log(fruits?.[1]?.[1]);
 }
 
-getFruit([['🍊', '🍌'], ['🍍']]);
+getFruit([["🍊", "🍌"], ["🍍"]]);
 getFruit();
-getFruit([['🍍'], ['🍊', '🍌']]);
+getFruit([["🍍"], ["🍊", "🍌"]]);
 ```
 
 - A: `null`, `undefined`, 🍌
@@ -4885,8 +4889,8 @@ We set the variable `calc` equal to a new instance of the `Calc` class. Then, we
 
 ```javascript
 const user = {
-  email: 'e@mail.com',
-  password: '12345',
+  email: "e@mail.com",
+  password: "12345",
 };
 
 const updateUser = ({ email, password }) => {
@@ -4901,7 +4905,7 @@ const updateUser = ({ email, password }) => {
   return user;
 };
 
-const updatedUser = updateUser({ email: 'new@email.com' });
+const updatedUser = updateUser({ email: "new@email.com" });
 
 console.log(updatedUser === user);
 ```
@@ -4926,11 +4930,11 @@ The `updateUser` function updates the values of the `email` and `password` prope
 ###### 149. এটার আউটপুট কোনটা?
 
 ```javascript
-const fruit = ['🍌', '🍊', '🍎'];
+const fruit = ["🍌", "🍊", "🍎"];
 
 fruit.slice(0, 1);
 fruit.splice(0, 1);
-fruit.unshift('🍇');
+fruit.unshift("🍇");
 
 console.log(fruit);
 ```
@@ -4958,11 +4962,11 @@ At last, we invoke the `unshift` method on the `fruit` array, which modifies the
 
 ```javascript
 const animals = {};
-let dog = { emoji: '🐶' };
-let cat = { emoji: '🐈' };
+let dog = { emoji: "🐶" };
+let cat = { emoji: "🐈" };
 
-animals[dog] = { ...dog, name: 'Mara' };
-animals[cat] = { ...cat, name: 'Sara' };
+animals[dog] = { ...dog, name: "Mara" };
+animals[cat] = { ...cat, name: "Sara" };
 
 console.log(animals[dog]);
 ```
@@ -4994,13 +4998,13 @@ Logging `animals[dog]`, or actually `animals["[object Object]"]` since convertin
 
 ```javascript
 const user = {
-  email: 'my@email.com',
+  email: "my@email.com",
   updateEmail: (email) => {
     this.email = email;
   },
 };
 
-user.updateEmail('new@email.com');
+user.updateEmail("new@email.com");
 console.log(user.email);
 ```
 
@@ -5024,10 +5028,10 @@ The `updateEmail` function is an arrow function, and is not bound to the `user`
 ###### 152. এটার আউটপুট কোনটা?
 
 ```javascript
-const promise1 = Promise.resolve('First');
-const promise2 = Promise.resolve('Second');
-const promise3 = Promise.reject('Third');
-const promise4 = Promise.resolve('Fourth');
+const promise1 = Promise.resolve("First");
+const promise2 = Promise.resolve("Second");
+const promise3 = Promise.reject("Third");
+const promise4 = Promise.resolve("Fourth");
 
 const runPromises = async () => {
   const res1 = await Promise.all([promise1, promise2]);
@@ -5060,8 +5064,8 @@ The `Promise.all` method runs the passed promises in parallel. If one promise fa
 ###### 153. What should the value of `method` be to log `{ name: "Lydia", age: 22 }`?
 
 ```javascript
-const keys = ['name', 'age'];
-const values = ['Lydia', 22];
+const keys = ["name", "age"];
+const values = ["Lydia", 22];
 
 const method =
   /* ?? */
@@ -5096,7 +5100,7 @@ This creates an array of subarrays containing the correct keys and values, which
 ```javascript
 const createMember = ({ email, address = {} }) => {
   const validEmail = /.+\@.+\..+/.test(email);
-  if (!validEmail) throw new Error('Valid email pls');
+  if (!validEmail) throw new Error("Valid email pls");
 
   return {
     email,
@@ -5104,7 +5108,7 @@ const createMember = ({ email, address = {} }) => {
   };
 };
 
-const member = createMember({ email: 'my@email.com' });
+const member = createMember({ email: "my@email.com" });
 console.log(member);
 ```
 
@@ -5128,10 +5132,10 @@ The default value of `address` is an empty object `{}`. When we set the variable
 ###### 155. এটার আউটপুট কোনটা?
 
 ```javascript
-let randomValue = { name: 'Lydia' };
+let randomValue = { name: "Lydia" };
 randomValue = 23;
 
-if (!typeof randomValue === 'string') {
+if (!typeof randomValue === "string") {
   console.log("It's not a string!");
 } else {
   console.log("Yay it's a string!");

From fe2dddb69328d08555952d4cbeb765ebb65a8237 Mon Sep 17 00:00:00 2001
From: iamsaief <saiefalemon@gmail.com>
Date: Tue, 23 Jul 2024 02:43:11 +0600
Subject: [PATCH 11/12] added translation till 150

---
 bn-BD/README_bn-BD.md | 92 +++++++++++++++++++++----------------------
 1 file changed, 46 insertions(+), 46 deletions(-)

diff --git a/bn-BD/README_bn-BD.md b/bn-BD/README_bn-BD.md
index af201342..4ac18dad 100644
--- a/bn-BD/README_bn-BD.md
+++ b/bn-BD/README_bn-BD.md
@@ -4379,7 +4379,7 @@ funcTwo();
 
 ---
 
-###### 134. How can we invoke `sum` in `sum.js` from `index.js?`
+###### 134. কিভাবে আমরা `sum.js` এর `sum` কে `index.js` থেকে কল করতে পারি?
 
 ```javascript
 // sum.js
@@ -4401,7 +4401,7 @@ import * as sum from "./sum";
 
 #### উত্তর: C
 
-With the asterisk `*`, we import all exported values from that file, both default and named. If we had the following file:
+এখানে এস্টেরিস্ক `*` দিয়ে, আমরা ওই ফাইলের সকল এক্সপোর্ট ভ্যালুগুলোকে ইম্পোর্ট করেছি, _ডিফল্ট_ ও _নেমড_ দুটোই। যদি আমাদের নিচে উল্লেখিত ফাইল থাকতঃ
 
 ```javascript
 // info.js
@@ -4414,7 +4414,7 @@ import * as info from "./info";
 console.log(info);
 ```
 
-The following would get logged:
+তবে নিচে উল্লেখিতভাবে লগ হতঃ
 
 ```javascript
 {
@@ -4424,13 +4424,13 @@ The following would get logged:
 }
 ```
 
-For the `sum` example, it means that the imported value `sum` looks like this:
+`sum` উদাহরণের বেলায়, এটা বোঝায় যে ইম্পোর্ট করা `sum` ভ্যালুটি এরকম দেখাবেঃ
 
 ```javascript
 { default: function sum(x) { return x + x } }
 ```
 
-We can invoke this function, by calling `sum.default`
+আমরা এই ফানংশনটিকে চালাতে পারি, `sum.default` কল করার মাধ্যমে।
 
 </p>
 </details>
@@ -4461,20 +4461,20 @@ person.name;
 
 #### উত্তর: C
 
-With a Proxy object, we can add custom behavior to an object that we pass to it as the second argument. In this case, we pass the `handler` object which contains two properties: `set` and `get`. `set` gets invoked whenever we _set_ property values, and `get` gets invoked whenever we _get_ (access) property values.
+Proxy অবজেক্ট দিয়ে, আমরা কোন একটি অবজেক্টে কাস্টম অচারন যুক্ত করতে পারি যেটাকে ২য় আর্গুমেন্ট হিসেবে পাস করি। এক্ষেত্রে, `handler` অবজেক্ট পাস করেছি যেটায় দুটি প্রোপার্টিস আছেঃ `set` এবং `get`। `set` কল হয় যখনি আমরা কোন প্রোপার্টির ভ্যালু _সেট_ করি, এবং `get` কল হয় যখনি আমরা কোন প্রোপার্টির ভ্যালু _পেতে_ চাই (এক্সেস করি)।
 
-The first argument is an empty object `{}`, which is the value of `person`. To this object, the custom behavior specified in the `handler` object gets added. If we add a property to the `person` object, `set` will get invoked. If we access a property on the `person` object, `get` gets invoked.
+প্রথম আর্গুমেন্টটি হলো একটি ফাঁকা অবজেক্ট `{}`, যেটা `person` অবজেক্টের ভ্যালু। এই অবজেক্টে, `handler` অবজেক্টে বর্নীত কাস্টম আচরণগুলো যুক্ত হয়েছে। যদি আমরা `person` অবজেক্টের কোন প্রোপার্টি যুক্ত করি, `set` কল হবে। যদি আমরা `person` অবজেক্টের কোন প্রোপার্টি এক্সেস করি, `get` কল হবে।
 
-First, we added a new property `name` to the proxy object (`person.name = "Lydia"`). `set` gets invoked, and logs `"Added a new property!"`.
+প্রথমে, আমরা প্রক্সি অবজেক্টে নতুন প্রোপার্টি `name` যুক্ত করেছি (`person.name = "Lydia"`)। `set` কল হবে, এবং লগ করে `"Added a new property!"`।
 
-Then, we access a property value on the proxy object, and the `get` property on the handler object is invoked. `"Accessed a property!"` gets logged.
+এরপরে, আমরা প্রক্সি অবজেক্টের একটি প্রোপার্টি এক্সেস করছি, এবং হ্যান্ডলার অবজেক্টের `get` প্রোপার্টি কল হয়। `"Accessed a property!"` লগ হয়।
 
 </p>
 </details>
 
 ---
 
-###### 136. Which of the following will modify the `person` object?
+###### 136. নিচের কোনটি `person` অবজেক্টকে পরিবর্তন করবে?
 
 ```javascript
 const person = { name: "Lydia Hallie" };
@@ -4492,16 +4492,16 @@ Object.seal(person);
 
 #### উত্তর: A
 
-With `Object.seal` we can prevent new properties from being _added_, or existing properties to be _removed_.
+`Object.seal` ব্যবহার করে, আমরা অবজেক্টে কোন নতুন প্রোপার্টি _যুক্ত_ করায় বাধা দিতে পারে, অথবা কোন প্রোপার্টি _মুছে_ ফেলায় বাধা দিতে পারি।
 
-However, you can still modify the value of existing properties.
+কিন্তু, আপনি এখনো বিদ্যমান কোন প্রোপার্টির ভ্যালুকে পরিবর্তন করতে পারবেন। যেমন, `person.name = "Evan Bacon"`।
 
 </p>
 </details>
 
 ---
 
-###### 137. Which of the following will modify the `person` object?
+###### 137. নিচের কোনটি `person` অবজেক্টকে পরিবর্তন করবে?
 
 ```javascript
 const person = {
@@ -4524,9 +4524,9 @@ Object.freeze(person);
 
 #### উত্তর: C
 
-The `Object.freeze` method _freezes_ an object. No properties can be added, modified, or removed.
+`Object.freeze` ব্যবহার করে, একটি অবজেক্টকে _সংরক্ষিত_ বা _ফ্রিজ_ করতে পারেন। অর্থাৎ কোন প্রোপার্টি যুক্ত করা, মুছে ফেলা, বা পরিবর্তন করা যাবে না।
 
-However, it only _shallowly_ freezes the object, meaning that only _direct_ properties on the object are frozen. If the property is another object, like `address` in this case, the properties on that object aren't frozen, and can be modified.
+কিন্তু, এটা কেবল _অগভীরভাবে_ অবজেক্টকে ফ্রিজ করে, মানে হলো যে এটি অবজেক্টের কেবল _প্রতক্ষ্য_ প্রোপার্টিস (first level) গুলোকে ফ্রিজ করে, যেমন এক্ষেত্রে `address`, এই অবজেক্টের প্রোপার্টিসগুলো ফ্রিজ হয়নি, এবং েদের প্রইবর্তন করা যাবে। যেমন, `person.address.street = "101 Main St"`।
 
 </p>
 </details>
@@ -4556,9 +4556,9 @@ myFunc(3);
 
 #### উত্তর: A
 
-First, we invoked `myFunc()` without passing any arguments. Since we didn't pass arguments, `num` and `value` got their default values: num is `2`, and `value` is the returned value of the function `add`. To the `add` function, we pass `num` as an argument, which had the value of `2`. `add` returns `4`, which is the value of `value`.
+প্রথমে, আমরা কোন আর্গুমেন্ট ছাড়াই `myFunc()` কে কল করেছি। যেহেতু কো নার্গুমেন্ট পাস করিনি, `num` ও `value` তাদের ভ্যালু হিসেবে ডিফল্ট ভ্যালুই পাচ্ছেঃ `num` হল `2`, এবং `value` হল `add` ফাংশনের রিটার্ন ভ্যালু। `add` ফাংশনে আমরা একটি আর্গুমেন্ট পাস করেছি `num`, যেটার ভ্যালু হল `2`। `add` ফাংশন রিটার্ন করে `4`, এটাই হলো `value`-র ভ্যালু।
 
-Then, we invoked `myFunc(3)` and passed the value `3` as the value for the argument `num`. We didn't pass an argument for `value`. Since we didn't pass a value for the `value` argument, it got the default value: the returned value of the `add` function. To `add`, we pass `num`, which has the value of `3`. `add` returns `6`, which is the value of `value`.
+পরবর্তীতে, আমরা `myFunc(3)` করছি, এখানে `3` কে পাস করছি `num` আর্গুমেন্টের ভ্যালু হিসেবে। আমরা `value` আর্গুমেন্টের কোন ভ্যালু পাস করিনি, এটা ডিফল্ট ভ্যালু পাচ্ছেঃ `add` ফাংশনের রিটার্ন ভ্যালু। `add` ফাংশনে আমরা `num` পাস করেছি, যেটার ভ্যালু `3`। `add` ফাংশনের রিটার্ন করে `6`, এটাই হলো `value`-র ভ্যালু।
 
 </p>
 </details>
@@ -4596,14 +4596,14 @@ console.log(counter.#number);
 
 #### উত্তর: D
 
-In ES2020, we can add private variables in classes by using the `#`. We cannot access these variables outside of the class. When we try to log `counter.#number`, a SyntaxError gets thrown: we cannot access it outside the `Counter` class!
+ইএস২০২০ এ, ক্লাসের ভেতর আমারা প্রাইভেট ভ্যারিয়েবল যুক্ত করতে পারি `#` ব্যাবহার করে। আমরা এই ভ্যারিয়েবলগুলোকে ক্লাসের বাইরে থেকে এক্সেস করতে পারি না। যখন `counter.#number` কে লগ করার চেষ্টা করা হয়, SyntaxError ছোড়া হয়ঃ we cannot access it outside the `Counter` class!
 
 </p>
 </details>
 
 ---
 
-###### 140. What's missing?
+###### 140. এখানে মিসিং অংশে কি হবে?
 
 ```javascript
 const teams = [
@@ -4638,9 +4638,9 @@ obj.next(); // { value: "Lisa", done: false }
 
 #### উত্তর: B
 
-In order to iterate over the `members` in each element in the `teams` array, we need to pass `teams[i].members` to the `getMembers` generator function. The generator function returns a generator object. In order to iterate over each element in this generator object, we need to use `yield*`.
+`teams` অ্যারের প্রতিটি এলিমেন্টের জন্য `members` এর উপর লুপ চালাতে হলে, `getMembers` জেনারেটর ফাংশনে `teams[i].members` কে পাস করতে হবে। জেনারেটর ফাংশন রিটার্ন করে একটি জেনারেটর অবজেক্ট। জেনারেটর অবজেক্টের প্রতিটি এলিমেন্টের উপর লুপ চালানোন্র জন্য, আমাদেরকে `yield*` ব্যবহার করতে হবে।
 
-If we would've written `yield`, `return yield`, or `return`, the entire generator function would've gotten returned the first time we called the `next` method.
+যদি আমরা `yield`, `return yield`, বা `return` লিখতাম, সম্পুর্ন জেনেরাটর ফাংশনটি রিটার্ন পেতাম প্রথমবার `next` মেথড করার পরে।
 
 </p>
 </details>
@@ -4677,15 +4677,13 @@ console.log(person.hobbies);
 
 #### উত্তর: C
 
-The `addHobby` function receives two arguments, `hobby` and `hobbies` with the default value of the `hobbies` array on the `person` object.
+`addHobby` ফাংশনটি ২টি আর্গুমেন্ট গ্রহণ করে, `hobby` ও `hobbies` - যার ডিফল্ট ভ্যালু হলো `person` অবজেক্টের `hobbies` অ্যারে।
 
-First, we invoke the `addHobby` function, and pass `"running"` as the value for `hobby` and an empty array as the value for `hobbies`. Since we pass an empty array as the value for `hobbies`, `"running"` gets added to this empty array.
+প্রথমে, আমরা `addHobby` ফাংশনটি কল করছি এবং `hobby`-এর ভ্যালু পাস করছি `"running"` এবং `hobbies`-এর ভ্যালু পাস করছি একটি ফাঁকা অ্যারে। যেহেতু একটি ফাঁকা অ্যারে পাস করছি `hobbies`-এর ভ্যালু হিসেবে, `"running"` যুক্ত হচ্ছে এই ফাঁকা অ্যারেতে।
 
-Then, we invoke the `addHobby` function, and pass `"dancing"` as the value for `hobby`. We didn't pass a value for `hobbies`, so it gets the default value, the `hobbies` property on the `person` object. We push the hobby `dancing` to the `person.hobbies` array.
+এরপরে, আমরা `addHobby` ফাংশনটি কল করছি এবং `hobby`-এর ভ্যালু পাস করছি `"dancing"`। `hobbies` এর জন্য আমরা কোন ভ্যালু পাস করিনি, তাই এটার ভ্যালু হয় ডিফল্ট ভ্যালুটিই, ভ্যালুটি হলো `person` অবজেক্টের `hobbies` অ্যারে। আমরা `person.hobbies` অ্যারেতে `"dancing"` যুক্ত (পুশ) করছি।
 
-Last, we invoke the `addHobby` function, and pass `"baking"` as the value for `hobby`, and the `person.hobbies` array as the value for `hobbies`. We push the hobby `baking` to the `person.hobbies` array.
-
-After pushing `dancing` and `baking`, the value of `person.hobbies` is `["coding", "dancing", "baking"]`
+সর্শেষে, আমরা `addHobby` ফাংশনটি কল করছি এবং `hobby`-এর ভ্যালু পাস করছি `"baking"`, এবং `hobbies`-এর ভ্যালু পাস করছি `person.hobbies` অ্যারেটি। আমরা `person.hobbies` অ্যারেতে `"baking"` যুক্ত (পুশ) করছি।
 
 </p>
 </details>
@@ -4721,14 +4719,14 @@ const pet = new Flamingo();
 
 #### উত্তর: B
 
-We create the variable `pet` which is an instance of the `Flamingo` class. When we instantiate this instance, the `constructor` on `Flamingo` gets called. First, `"I'm pink. 🌸"` gets logged, after which we call `super()`. `super()` calls the constructor of the parent class, `Bird`. The constructor in `Bird` gets called, and logs `"I'm a bird. 🦢"`.
+আমরা `pet` ভ্যারিয়েবলটি তৈরি করেছি যেটা `Flamingo` ক্লাসের একটি ইন্সট্যান্স। যখন আমরা এই ইন্সট্যান্সটিকে ইন্সট্যানশিয়েট (`new Flamingo()`) করি, `Flamingo` ক্লাসের কন্সট্রাক্টর কল হয়। প্রথমে, `"I'm pink. 🌸"` লগ হয়, এরপরে আমরা `super()` কল করি। `super()` প্যারেন্ট ক্লাস `Bird`-এর কন্সট্রাক্টরকে কল করে। `Bird` ক্লাসের কন্সট্রাক্টর কল হয় এবং লগ করে `"I'm a bird. 🦢"`।
 
 </p>
 </details>
 
 ---
 
-###### 143. Which of the options result(s) in an error?
+###### 143. কোন অপশনটি এরর রেজাল্ট দেয়?
 
 ```javascript
 const emojis = ["🎄", "🎅🏼", "🎁", "⭐"];
@@ -4749,14 +4747,14 @@ const emojis = ["🎄", "🎅🏼", "🎁", "⭐"];
 
 #### উত্তর: D
 
-The `const` keyword simply means we cannot _redeclare_ the value of that variable, it's _read-only_. However, the value itself isn't immutable. The properties on the `emojis` array can be modified, for example by pushing new values, splicing them, or setting the length of the array to 0.
+`const` কিওয়ার্ড দিয়ে নেয়া কোন ভ্যারিয়েবলের ভ্যালুকে আমরা _রিডিক্লেয়ার_ করতে পারব না (`emojis = [...emojis, "🥂"]`), এটা কেবল _রিড-অনলি_। কিন্তু ভ্যারিয়েবলের ভ্যালুগুলো নিজেরা অপরিবর্তনীয় নয়। অর্থাৎ `emojis` অ্যারের এলিমেন্টগুলোকে পরিবর্তন করা যাবে, উদাহরণস্বরূপ, নতুন ভ্যালু পুশ (যুক্ত) করা (`emojis.push("🦌")`), স্প্লাইস করা (নির্দিষ্ট ইনডেক্সে ভ্যালু যুক্ত করা) (`emojis.splice(0, 2)`), বা অ্যারের লেন্থকে জিরো (`emojis.length = 0`) সেট করা।
 
 </p>
 </details>
 
 ---
 
-###### 144. What do we need to add to the `person` object to get `["Lydia Hallie", 21]` as the output of `[...person]`?
+###### 144. `[...person]` এর আউটপুট `["Lydia Hallie", 21]` পেতে হলে `person` অবজেক্টে আমাদের কি যুক্ত করতে হবে?
 
 ```javascript
 const person = {
@@ -4777,7 +4775,7 @@ const person = {
 
 #### উত্তর: C
 
-Objects aren't iterable by default. An iterable is an iterable if the iterator protocol is present. We can add this manually by adding the iterator symbol `[Symbol.iterator]`, which has to return a generator object, for example by making it a generator function `*[Symbol.iterator]() {}`. This generator function has to yield the `Object.values` of the `person` object if we want it to return the array `["Lydia Hallie", 21]`: `yield* Object.values(this)`.
+অবজেক্ট ডিফল্টভাবে ইটারেবল নয়। একটি ইটারেবল ইটারেবল হয় যদি ইটারেটর প্রোটোকল থাকে। আমরা এটা নিজারা যুক্ত করতে পারি ইটারেটর সিম্বল `[Symbol.iterator]` যুক্ত করার মাধ্যমে, যেটাকে একটি জেনারেটর অবজেক্ট রিটার্ন করতে হবে, উদাহরণস্বরূপ এটাকে একটি জেনারেটর ফাংশন `*[Symbol.iterator]() {}` করার মাধ্যমে। এই জেনারেটর ফাংশন `person` অবজেক্টের `Object.values` কে ইল্ড করতে হবে যদি আমরা চাই এটা অ্যারেটি রিটার্ন করবেঃ `["Lydia Hallie", 21]`: `yield* Object.values(this)`
 
 </p>
 </details>
@@ -4807,7 +4805,7 @@ console.log(count);
 
 #### উত্তর: C
 
-The `if` condition within the `forEach` loop checks whether the value of `num` is truthy or falsy. Since the first number in the `nums` array is `0`, a falsy value, the `if` statement's code block won't be executed. `count` only gets incremented for the other 3 numbers in the `nums` array, `1`, `2` and `3`. Since `count` gets incremented by `1` 3 times, the value of `count` is `3`.
+`forEach` লুপের `if` শর্তটি চেক করছে `num` এর ভ্যালু ট্রুথি বা ফলসি কিনা। যেহেতু `num` অ্যারের ১ম নাম্বারটি `0`, একটি ফলসি ভ্যালু, তাই `if` স্টেটমেন্টের কোড ব্লকটি চলবে না। `count` কেবল অন্য ৩টি নাম্বারের জন্য বৃদ্ধি পাবে, `1`, `2` ও `3`। যেহেতু `count` `1` করে ৩বার বৃদ্ধি পায়, `count` এর ভ্যালু এখন হয়েছে `3`।
 
 </p>
 </details>
@@ -4836,13 +4834,13 @@ getFruit([["🍍"], ["🍊", "🍌"]]);
 
 #### উত্তর: D
 
-The `?` allows us to optionally access deeper nested properties within objects. We're trying to log the item on index `1` within the subarray that's on index `1` of the `fruits` array. If the subarray on index `1` in the `fruits` array doesn't exist, it'll simply return `undefined`. If the subarray on index `1` in the `fruits` array exists, but this subarray doesn't have an item on its `1` index, it'll also return `undefined`.
+`?.` ব্যবহার করে আমরা অবজেক্টের ডিপার নেস্টেড কোন প্রোপার্টিকে অপশনালি এক্সেস করতে পারি। আমরা চেষ্টা করছি সাব-অ্যারের ইনডেক্স `1` আইটেমটিকে লগ করার যেটা `fruits` অ্যারের ইনডেক্স `1` এ অবস্থিত। যদি `fruits` অ্যারের ইনডেক্স `1` এ সাব-অ্যারেটিকে পাওয়া না যায়, এটা `undefined` রিটার্ন করবে। যদি `fruits` অ্যারের ইনডেক্স `1` এ সাব-অ্যারেটিকে পাওয়া যায়, কিন্তু সাব-অ্যারেতে ইনডেক্স `1` আইটেমটিকে পাওয়া না যায় তখনও এটা `undefined` রিটার্ন করবে।
 
-First, we're trying to log the second item in the `['🍍']` subarray of `[['🍊', '🍌'], ['🍍']]`. This subarray only contains one item, which means there is no item on index `1`, and returns `undefined`.
+প্রথমে, আমরা লগ করার চেষ্টা করছি `[['🍊', '🍌'], ['🍍']]`-অ্যারেটির সাব-অ্যারে `['🍍']` থেকে দ্বিতীয় আইটেমটি। এই সাব-অ্যারেতে কেবল একটি আইটেমই আছে, যার মানে হল এর ইনডেক্স `1`-এ কিছু নেই তাই `undefined` রিটার্ন করছে।
 
-Then, we're invoking the `getFruits` function without passing a value as an argument, which means that `fruits` has a value of `undefined` by default. Since we're conditionally chaining the item on index `1` of`fruits`, it returns `undefined` since this item on index `1` does not exist.
+এরপর, `getFruits` ফাংশনটিকে কল করেছি কোন ভ্যালুকে আর্গুমেন্ট হিসেবে পাস না করেই, যার মানে হয় `fruits` এর ডিফল্ট ভ্যালু পাচ্ছে `undefined`। যেহেতু, আমরা `fruits` অ্যারের ইনডেক্স `1` আইটেমকে কন্ডিশনালি চেইনিং করছি, এটা `undefined` রিটার্ন করছে কারন ইনডেক্স `1` এর আইটেম নেই।
 
-Lastly, we're trying to log the second item in the `['🍊', '🍌']` subarray of `['🍍'], ['🍊', '🍌']`. The item on index `1` within this subarray is `🍌`, which gets logged.
+সর্বশেষে, আমরা চেষ্টা লগ করার করছি `[["🍍"], ["🍊", "🍌"]]`-অ্যারেটির সাব-অ্যারে `['🍊', '🍌']` থেকে দ্বিতীয় আইটেমটি। সাব-অ্যারের ইনডেক্স `1` এর আইটেমটি হল `🍌`, এটিই লগ হয়েছে।
 
 </p>
 </details>
@@ -4878,7 +4876,7 @@ console.log(calc.count);
 
 #### উত্তর: A
 
-We set the variable `calc` equal to a new instance of the `Calc` class. Then, we instantiate a new instance of `Calc`, and invoke the `increase` method on this instance. Since the count property is within the constructor of the `Calc` class, the count property is not shared on the prototype of `Calc`. This means that the value of count has not been updated for the instance calc points to, count is still `0`.
+আমরা `calc` ভ্যারিয়েবলকে সেট করেছি `Calc` ক্লাসের নতুন ইন্সট্যান্সের সমান। এরপর, আমরা `Calc` ক্লাসের নতুন একটি ইন্সট্যান্সকে ইন্সট্যান্সিয়েট করেছি, এবং এই ইন্সট্যান্স দিয়ে `increase` মেথড কল করেছি। যেহেতু `count` প্রোপার্টিটি `Calc` ক্লাসের কন্সট্রাক্টরের ভেতর আছে, তাই এই প্রোপার্টিটি `Calc` ক্লাসের প্রোটোটাইপে শেয়ার হয়নি। এর মানে হল যে `count` প্রোপার্টির ভ্যালুটির কোন পরিবর্তন হয়নি নতুন ইন্সট্যান্স যে `Calc` ক্লাসকে পয়েন্ট করছে তার জন্য, তাই `count` এখনো `0`।
 
 </p>
 </details>
@@ -4920,7 +4918,7 @@ console.log(updatedUser === user);
 
 #### উত্তর: B
 
-The `updateUser` function updates the values of the `email` and `password` properties on user, if their values are passed to the function, after which the function returns the `user` object. The returned value of the `updateUser` function is the `user` object, which means that the value of updatedUser is a reference to the same `user` object that `user` points to. `updatedUser === user` equals `true`.
+`updateUser` ফাংশনটি `user` অবজেক্টের `email` ও `password` প্রোপার্টির ভ্যালুকে পরিবর্তন করে যদি ফাংশনে তাদের ভ্যালুগুলোকে পাস করা হয়, এরপরে ফাংশনটি `user` অবজেক্টটিকে রিটার্ন করে। `updateUser` ফাংশনটির রিটার্ন ভ্যালুটি হল `user` অবজেক্ট, যার মানে `updateUser` এর ভ্যালুটি হল একই `user` অবজেক্টের রেফারেন্স যেটা `user` পয়েন্ট করছে। ফলে `updatedUser === user` সমান হচ্ছে `true`।
 
 </p>
 </details>
@@ -4949,9 +4947,11 @@ console.log(fruit);
 
 #### উত্তর: C
 
-First, we invoke the `slice` method on the fruit array. The slice method does not modify the original array, but returns the value that it sliced off the array: the banana emoji.
-Then, we invoke the `splice` method on the fruit array. The splice method does modify the original array, which means that the fruit array now consists of `['🍊', '🍎']`.
-At last, we invoke the `unshift` method on the `fruit` array, which modifies the original array by adding the provided value, ‘🍇’ in this case, as the first element in the array. The fruit array now consists of `['🍇', '🍊', '🍎']`.
+প্রথমে, আমরা `fruit` অ্যারেতে `slice` মেথড কল করেছি। `slice` মেথড আসল অ্যারেকে পরিবর্তন করে না, কিন্তু অ্যারে থেকে খন্ডিত (স্লাইস) করে আনা আইটেম/গুলো রিটার্ন করেঃ এক্ষেত্রে, কলার ইমজি `'🍌'`।
+
+এরপরে, আমরা `fruit` অ্যারেতে `splice` মেথড কল করেছি। `splice` মেথড আসল অ্যারেকে পরিবর্তন করে, যার মানে হল, এখন `fruit` অ্যারেতে অবশিষ্ট আছে `['🍊', '🍎']`।
+
+সর্বশেষে, আমরা `fruit` অ্যারেতে `unshift` মেথড কল করেছি। `unshift` মেথডে পাস করা ভ্যালু/গুলোকে অ্যারেতে যুক্ত করার মাধ্যমে সে আসল অ্যারেকে পরিবর্তন করে, এক্ষেত্রে অ্যারের প্রথম এলিমেন্ট হিসেবে। তাই এখন `fruit` অ্যারেটিতে থাকছে `['🍇', '🍊', '🍎']`।
 
 </p>
 </details>
@@ -4981,13 +4981,13 @@ console.log(animals[dog]);
 
 #### উত্তর: B
 
-Object keys are converted to strings.
+অবজেক্টের কি-গুলোকে জাভাস্ক্রিপ্ট ইঞ্জিন স্ট্রিং-এ পরিবর্তন করে।
 
-Since the value of `dog` is an object, `animals[dog]` actually means that we’re creating a new property called `"[object Object]"` equal to the new object. `animals["[object Object]"]` is now equal to `{ emoji: "🐶", name: "Mara"}`.
+যেহেতু `dog` এর ভ্যালুটি একটি অবজেক্ট, `animals[dog]` এর মানে আমরা আসলে নতুন একটি অবজেক্ট সমান সেট করছি `"[object Object]"` নামের নতুন একটি প্রোপার্টি। ফলে এখন `animals["[object Object]"]` এর সমান হলো `{ emoji: "🐶", name: "Mara"}`।
 
-`cat` is also an object, which means that `animals[cat]` actually means that we’re overwriting the value of `animals["[object Object]"]` with the new cat properties.
+`cat`-ও একটি অবজেক্ট, যার মানে হলো `animals[cat]` আসলে `animals["[object Object]"]` এর ভ্যালুকে ওভাররাইড করা হয়েছে নতুন cat প্রোপার্টি দিয়ে অর্থাৎ `animals["[object Object]"]` সমান এখন `{ emoji: "🐈", name: "Sara" }`।
 
-Logging `animals[dog]`, or actually `animals["[object Object]"]` since converting the `dog` object to a string results `"[object Object]"`, returns the `{ emoji: "🐈", name: "Sara" }`.
+`animals[dog]` কে লগ করা, আসলে `animals["[object Object]"]` কেই লগ করা যেহেতু `dog` অবজেক্টকে স্ট্রিং এ পরিবর্তন করলে পাওয়া যায় `"[object Object]"` যেটা রিটার্ন করে `{ emoji: "🐈", name: "Sara" }`।
 
 </p>
 </details>

From 142843e48cbabbce7eb7f3afbf4cb3b4f5bd3469 Mon Sep 17 00:00:00 2001
From: iamsaief <saiefalemon@gmail.com>
Date: Tue, 23 Jul 2024 06:12:37 +0600
Subject: [PATCH 12/12] =?UTF-8?q?added=20translation=20till=20155,=20the?=
 =?UTF-8?q?=20end=20=F0=9F=8E=89?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 bn-BD/README_bn-BD.md | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/bn-BD/README_bn-BD.md b/bn-BD/README_bn-BD.md
index 4ac18dad..b170d6e9 100644
--- a/bn-BD/README_bn-BD.md
+++ b/bn-BD/README_bn-BD.md
@@ -441,7 +441,7 @@ console.log(sarah);
 
 ---
 
-###### 13. What are the three phases of event propagation?
+###### 13. ইভেন্ট প্রোপাগেশনের ৩টি ধাপ কি কি?
 
 - A: Target > Capturing > Bubbling
 - B: Bubbling > Target > Capturing
@@ -1373,7 +1373,7 @@ console.log(gen.next().value);
 
 ---
 
-###### 45. What does this return?
+###### 45. এটা কি রিটার্ন করে?
 
 ```javascript
 const firstPromise = new Promise((res, rej) => {
@@ -5018,7 +5018,7 @@ console.log(user.email);
 
 #### উত্তর: A
 
-The `updateEmail` function is an arrow function, and is not bound to the `user` object. This means that the `this` keyword is not referring to the `user` object, but refers to the global scope in this case. The value of `email` within the `user` object does not get updated. When logging the value of `user.email`, the original value of `my@email.com` gets returned.
+এখানে `updateEmail` একটি অ্যারো ফাংশন, এবং এর স্কোপ `user` অবজেক্টে বাধ্য নয়। এর মানে হলো যে `this` কীওয়ার্ডটি `user` অবজেক্টকে রেফার করছে না, বরং এক্ষেত্রে গ্লোবাল স্কোপকে রেফার করছে। `user` অবজেক্টের `email` প্রোপার্টির ভ্যালুটি পরিবর্তন হচ্ছে না। ফলে যখন `user.email`-এর ভ্যালুকে লগ করা হয়েছে, আসল ভ্যালুটিই-`my@email.com` রিটার্ন হয়েছে।
 
 </p>
 </details>
@@ -5054,14 +5054,14 @@ runPromises()
 
 #### উত্তর: D
 
-The `Promise.all` method runs the passed promises in parallel. If one promise fails, the `Promise.all` method _rejects_ with the value of the rejected promise. In this case, `promise3` is rejected with the value `"Third"`. We’re catching the rejected value in the chained `catch` method on the `runPromises` invocation to catch any errors within the `runPromises` function. Only `"Third"` gets logged, since `promise3` is rejected with this value.
+`Promise.all` মেথডটি পাস করা সকল প্রমিসগুলোকে সমান্তরালভাবে/একই সাথে রান করে। যদি একটা প্রমিস ফেইল করে, `Promise.all` মেথড রিজেক্ট করা প্রমিসের ভ্যালুটি দিয়ে _রিজেক্ট_ করবে। এক্ষেত্রে, `promise3` রিজেক্ট হয়েছে `"Third"` ভ্যালুটি দিয়ে। আমরা এই রিজেক্ট ভ্যালুটিই ক্যাচ করছি চেইন `.catch` মেথডে যখন `runPromises` চলার সময় এই ফাংশনের কোন এরর ক্যাচ করছি। কেবল `"Third"`-ই লগ হয়েছে, যেহেতু `promise3` রিজেক্ট হয়েছে `"Third"` ভ্যালুটি দিয়ে।
 
 </p>
 </details>
 
 ---
 
-###### 153. What should the value of `method` be to log `{ name: "Lydia", age: 22 }`?
+###### 153. `{ name: "Lydia", age: 22 }` লগ করা জন্য `method` এর ভ্যালুটি কি হওয়া উচিৎ?
 
 ```javascript
 const keys = ["name", "age"];
@@ -5086,9 +5086,9 @@ const method =
 
 #### উত্তর: C
 
-The `fromEntries` method turns a 2d array into an object. The first element in each subarray will be the key, and the second element in each subarray will be the value. In this case, we’re mapping over the `keys` array, which returns an array that the first element is the item on the key array on the current index, and the second element is the item of the values array on the current index.
+`fromEntries` মেথডটি একটি 2D অ্যারেকে অবজেক্টে পরিবর্তন করে। প্রতিটি সাব-অ্যারের ১ম এলিমেন্টটি হবে নির্দিষ্ট কি এবং ২য় এলিমেন্টটি হবে এই কি-এর ভ্যালু। এক্ষেত্রে, আমরা `keys` অ্যারের উপর ম্যাপ চালাচ্ছি, যেটা এমন একটি অ্যারে রিটার্ন করে যার ১ম এলিমেন্টটি হয় বর্তমান ইনডেক্সের জন্য কি-অ্যারের আইটেম, এবং ২য় এলিমেন্টটি হয় বর্তমান ইনডেক্সের জন্য ভ্যালু-অ্যারের আইটেম।
 
-This creates an array of subarrays containing the correct keys and values, which results in `{ name: "Lydia", age: 22 }`
+এটা সাব-অ্যারেগুলোর একটি অ্যারে তৈরি করে যেটাতে সঠিক কি-ভ্যালু গুলো থাকে, এটারই ফলাফল হয়েছে `{ name: "Lydia", age: 22 }`
 
 </p>
 </details>
@@ -5122,7 +5122,7 @@ console.log(member);
 
 #### উত্তর: C
 
-The default value of `address` is an empty object `{}`. When we set the variable `member` equal to the object returned by the `createMember` function, we didn't pass a value for the address, which means that the value of the address is the default empty object `{}`. An empty object is a truthy value, which means that the condition of the `address ? address : null` conditional returns `true`. The value of the address is the empty object `{}`.
+এখানে `address` এর ডিফল্ট ভ্যালু একটি ফাঁকা অবজেক্ট `{}`। যখন আমরা `member` ভ্যারিয়েবলকে সেট করছি `createMember` ফাংশনের রিটার্ন ভ্যালুর সমান, আমরা address এর কোন ভ্যালু পাস করিনি, এর মানে হলো যে `address` এর ভ্যালু থাকছে তার ডিফল্ট ভ্যালু ফাঁকা অবজেক্ট `{}`। আর ফাঁকা অবজেক্ট একটি ট্রুথি ভ্যালু, যার মানে `address ? address : null`-কন্ডিশনাল এর শর্তটি `true` রিটার্ন করছে। `address` এর ভ্যালু ফাঁকা অবজেক্ট `{}`, ফলে `{ email: "my@email.com", address: {} }` লগ হয়েছে।
 
 </p>
 </details>
@@ -5152,9 +5152,9 @@ if (!typeof randomValue === "string") {
 
 #### উত্তর: B
 
-The condition within the `if` statement checks whether the value of `!typeof randomValue` is equal to `"string"`. The `!` operator converts the value to a boolean value. If the value is truthy, the returned value will be `false`, if the value is falsy, the returned value will be `true`. In this case, the returned value of `typeof randomValue` is the truthy value `"number"`, meaning that the value of `!typeof randomValue` is the boolean value `false`.
+এখানে `if` স্টেটমেন্টের শর্তটি চেক করছে `!typeof randomValue`-এর ভ্যালু সমান `"string"` হয় কিনা। `!` অপারেটরটি ভ্যালুটিকে পরিবর্তন করে একটি বুলিয়ান ভ্যালুতে। যদি ভ্যালুটি _ট্রুথি_ হয়, রিটার্ন ভ্যালু হবে `false`, যদি ভ্যালুটি _ফলসি_ হয়, রিটার্ন ভ্যালুটি হবে `true`। এক্ষেত্রে, `typeof randomValue`-এর রিটার্ন ভ্যালু হয় `"number"`-এর ট্রুথি ভ্যালু, মানে হলো যে `!typeof randomValue`-এর ভ্যালু হয় বুলিয়ান `false` ভ্যালু।
 
-`!typeof randomValue === "string"` always returns false, since we're actually checking `false === "string"`. Since the condition returned `false`, the code block of the `else` statement gets run, and `Yay it's a string!` gets logged.
+`!typeof randomValue === "string"` সবসময় `false` রিটার্ন করে, যেহেতু আমরা আসলে চেক করছি `false === "string"` কিনা। ফলে শর্তটি `false` রিটার্ন করে, `else` স্টেটমেন্টের কোড ব্লকটি রান হয়, এবং `Yay it's a string!` লগ হয়।
 
 </p>
 </details>