From 051904af27ec92120a65b8dbb58e349c191ea016 Mon Sep 17 00:00:00 2001
From: May Kittens Devour Your Soul <yoshimitsu002@gmail.com>
Date: Wed, 2 Aug 2023 20:22:42 +0200
Subject: [PATCH 01/31] Update README-bs_BS.md

---
 bs-BS/README-bs_BS.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/bs-BS/README-bs_BS.md b/bs-BS/README-bs_BS.md
index 5c63bb02..3bbd0e0b 100644
--- a/bs-BS/README-bs_BS.md
+++ b/bs-BS/README-bs_BS.md
@@ -67,10 +67,10 @@ još nismo definirali varijablu na liniji gdje pokušavamo prijaviti
 varijabla `name`, tako da još uvijek sadrži vrijednost` undefined`.
 
 Varijable s ključnom riječi `let` (i` const`) su podignute, ali za razliku od njih
-`var`, ne bivaju <i> inicijalizirane </i>. Nisu dostupni prije
-linije na kojo ih proglašavamo (inicijaliziramo). To se naziva "temporal dead zone".
+`var`, ne bivaju <i> inicijalizirane </i>. Nisu dostupne prije
+linije na kojoj ih proglašavamo (inicijaliziramo). To se naziva "temporal dead zone".
 Kada pokušamo pristupiti varijablama prije nego što budu deklarirane,
-JavaScript iz bacuje `ReferenceError`.
+JavaScript izbacuje `ReferenceError`.
 
 </p>
 </details>

From c6086e1179fa153f2cb82706a5f198ed3beeadbb Mon Sep 17 00:00:00 2001
From: May Kittens Devour Your Soul <yoshimitsu002@gmail.com>
Date: Wed, 2 Aug 2023 20:34:49 +0200
Subject: [PATCH 02/31] Update README-bs_BS.md

---
 bs-BS/README-bs_BS.md | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/bs-BS/README-bs_BS.md b/bs-BS/README-bs_BS.md
index 3bbd0e0b..65ee11f7 100644
--- a/bs-BS/README-bs_BS.md
+++ b/bs-BS/README-bs_BS.md
@@ -253,7 +253,7 @@ console.log(d.greeting);
 
 #### Odgovor: A
 
-U JavaScriptu, svi objekti međusobno djeluju * referencom * kada ih postavljaju
+U JavaScriptu, svi objekti međusobno djeluju *referencom* kada ih postavljaju
 jednaki.
 
 Prvo, varijabla `c` sadrži vrijednost objekta. Kasnije dodijelimo `d`
@@ -290,15 +290,15 @@ console.log(b === c);
 
 #### Odgovor: C
 
-`new Number ()` je ugrađeni konstruktor function. Iako izgleda
+`new Number ()` je ugrađena konstruktor funkcija. Iako izgleda
 kao broj, to zapravo nije broj: ima gomilu ekstra dodataka
 pa je zbog toga objekt.
 
-Kada koristimo `==` operatora, on samo provjerava ima li isti
+Kada koristimo `==` operator, on samo provjerava ima li isti
 *vrijednost*. Obje imaju vrijednost `3`, pa se vraća 'true'.
 
 Međutim, kada koristimo `===` operator, obje vrijednosti * i * trebaju biti
-isto. To nije: `new Number ()` nije broj, to je ** objekt **.
+iste. To nije: `new Number ()` nije broj, to je ** objekt **.
 Oba vraćaju "false"
 
 </p>
@@ -376,7 +376,7 @@ da ste deklarirali varijablu prije nego je postavite na bilo što.
 
 * * * * *
 
-###### 10. Što se događa kada to učinimo?
+###### 10. Što se događa kada učinimo ovo?
 
 ```javascript
 function bark() {
@@ -396,11 +396,11 @@ bark.animal = "dog";
 
 #### Odgovor: A
 
-To je moguće u JavaScriptu, jer su funkcije objekti!
+Ovo je moguće u JavaScriptu, jer su funkcije objekti!
 (Sve osim primitivnih tipova su objekti)
 
 function je posebna vrsta objekta. Kod koji sami napišete
-nije stvarna function. function je objekt sa svojstvima.
+nije stvarna funkcija. function je objekt sa svojstvima.
 Ova nekretnina je nepovratna.
 
 </p>
@@ -435,7 +435,7 @@ console.log(member.getFullName());
 #### Odgovor: A
 
 Ne možete dodati svojstva konstruktoru kao što možete s uobičajenim
-objekti. Ako želite dodati značajku svim objektima odjednom, imate
+objektima. Ako želite dodati značajku svim objektima odjednom, imate
 umjesto toga koristiti prototip. Dakle, u ovom slučaju,
 
 ```{.js}
@@ -444,12 +444,12 @@ Person.prototype.getFullName = function () {
 };
 ```
 
-bi učinio `member.getFullName ()`. Zašto je to korisno? Reći će mo
+bi učinio `member.getFullName ()`. Zašto je to korisno? Reći ćemo
 da smo tu metodu dodali samom konstruktoru. Možda ne svaki
 Primjer "Person" trebao je ovu metodu. To bi trošilo puno memorije
 scopa (prostora), jer bi oni još uvijek imali tu svojinu, koja uzima memoriju
 scopa za svaku instancu. Umjesto toga, ako ga samo dodamo prototipu, mi
-će mo je imati na jednom mjestu u memoriji, ali svi imaju pristup!
+ćemo je imati na jednom mjestu u memoriji, ali svi imaju pristup!
 
 </p>
 </details>

From 133e907093ba5bf447f25aab44d831f6694825ce Mon Sep 17 00:00:00 2001
From: Mohammed Nasif <99568326+Mohammed-Nasif@users.noreply.github.com>
Date: Fri, 11 Aug 2023 11:46:12 -0700
Subject: [PATCH 03/31] Update README.md

###### 23. What's the output?

The Answer description was not clear as the reason is that the variable declared with let couldn't be redeclared.
---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 97cde89e..7627f92e 100644
--- a/README.md
+++ b/README.md
@@ -739,7 +739,7 @@ console.log(num);
 
 With the `var` keyword, you can declare multiple variables with the same name. The variable will then hold the latest value.
 
-You cannot do this with `let` or `const` since they're block-scoped.
+You cannot do this with `let` or `const` since they couldn't be redeclared.
 
 </p>
 </details>

From d8f096396becd18256123479e42c7a0290b52771 Mon Sep 17 00:00:00 2001
From: alexb017 <alexbacirea@gmail.com>
Date: Mon, 21 Aug 2023 00:06:22 +0300
Subject: [PATCH 04/31] Add romanian translation

---
 README.md             | 624 ++++++++++++++--------------
 ar-AR/README_AR.md    | 362 ++++++++++-------
 bs-BS/README-bs_BS.md | 249 ++++++------
 de-DE/README.md       | 925 +++++++++++++++++++++---------------------
 es-ES/README-ES.md    | 495 +++++++++++-----------
 fr-FR/README_fr-FR.md |  44 +-
 id-ID/README.md       | 546 ++++++++++++-------------
 it-IT/README.md       | 654 ++++++++++++++---------------
 ja-JA/README-ja_JA.md | 375 +++++++++--------
 ko-KR/README-ko_KR.md | 514 +++++++++++------------
 nl-NL/README.md       | 619 ++++++++++++++--------------
 pl-PL/README.md       | 126 +++---
 pt-BR/README_pt_BR.md | 116 +++---
 ro-RO/README.ro.md    |  49 +++
 ru-RU/README.md       | 825 ++++++++++++++++++-------------------
 sq-KS/README_sq_KS.md | 653 ++++++++++++++---------------
 th-TH/README.md       | 385 +++++++++---------
 tr-TR/README-tr_TR.md | 316 ++++++++-------
 uk-UA/README.md       |  35 +-
 vi-VI/README-vi.md    | 829 ++++++++++++++++++-------------------
 20 files changed, 4441 insertions(+), 4300 deletions(-)
 create mode 100644 ro-RO/README.ro.md

diff --git a/README.md b/README.md
index 97cde89e..031b0f72 100644
--- a/README.md
+++ b/README.md
@@ -10,10 +10,11 @@ From basic to advanced: test how well you know JavaScript, refresh your knowledg
 
 Feel free to reach out to me! 😊 <br />
 <a href="https://www.instagram.com/theavocoder">Instagram</a> || <a href="https://www.twitter.com/lydiahallie">Twitter</a> || <a href="https://www.linkedin.com/in/lydia-hallie">LinkedIn</a> || <a href="https://www.lydiahallie.dev">Blog</a>
+
 </div>
 
-| 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!   |
-|---|
+| 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! |
+| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
 
 ---
 
@@ -33,6 +34,7 @@ Feel free to reach out to me! 😊 <br />
 - [🇳🇱 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)
@@ -53,7 +55,7 @@ Feel free to reach out to me! 😊 <br />
 function sayHi() {
   console.log(name);
   console.log(age);
-  var name = 'Lydia';
+  var name = "Lydia";
   let age = 21;
 }
 
@@ -149,7 +151,7 @@ There is no value `radius` on that object, which returns `NaN`.
 
 ```javascript
 +true;
-!'Lydia';
+!"Lydia";
 ```
 
 - A: `1` and `false`
@@ -174,11 +176,11 @@ The string `'Lydia'` is a truthy value. What we're actually asking, is "is this
 
 ```javascript
 const bird = {
-  size: 'small',
+  size: "small",
 };
 
 const mouse = {
-  name: 'Mickey',
+  name: "Mickey",
   small: true,
 };
 ```
@@ -209,11 +211,11 @@ However, with dot notation, this doesn't happen. `mouse` does not have a key cal
 ###### 6. What's the output?
 
 ```javascript
-let c = { greeting: 'Hey!' };
+let c = { greeting: "Hey!" };
 let d;
 
 d = c;
-c.greeting = 'Hello';
+c.greeting = "Hello";
 console.log(d.greeting);
 ```
 
@@ -283,13 +285,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`
@@ -344,10 +346,10 @@ In order to avoid this, we can use `"use strict"`. This makes sure that you have
 
 ```javascript
 function bark() {
-  console.log('Woof!');
+  console.log("Woof!");
 }
 
-bark.animal = 'dog';
+bark.animal = "dog";
 ```
 
 - A: Nothing, this is totally fine!
@@ -377,8 +379,8 @@ function Person(firstName, lastName) {
   this.lastName = lastName;
 }
 
-const member = new Person('Lydia', 'Hallie');
-Person.getFullName = function() {
+const member = new Person("Lydia", "Hallie");
+Person.getFullName = function () {
   return `${this.firstName} ${this.lastName}`;
 };
 
@@ -395,12 +397,12 @@ console.log(member.getFullName());
 
 #### Answer: A
 
-In JavaScript, functions are objects, and therefore, the method `getFullName` gets added to the constructor function object itself. For that reason, we can call `Person.getFullName()`, but `member.getFullName` throws a `TypeError`. 
+In JavaScript, functions are objects, and therefore, the method `getFullName` gets added to the constructor function object itself. For that reason, we can call `Person.getFullName()`, but `member.getFullName` throws a `TypeError`.
 
 If you want a method to be available to all object instances, you have to add it to the prototype property:
 
 ```js
-Person.prototype.getFullName = function() {
+Person.prototype.getFullName = function () {
   return `${this.firstName} ${this.lastName}`;
 };
 ```
@@ -418,8 +420,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);
@@ -489,7 +491,7 @@ function sum(a, b) {
   return a + b;
 }
 
-sum(1, '2');
+sum(1, "2");
 ```
 
 - A: `NaN`
@@ -556,7 +558,7 @@ function getPersonInfo(one, two, three) {
   console.log(three);
 }
 
-const person = 'Lydia';
+const person = "Lydia";
 const age = 21;
 
 getPersonInfo`${person} is ${age} years old`;
@@ -583,9 +585,9 @@ If you use tagged template literals, the value of the first argument is always a
 ```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`);
   }
@@ -645,7 +647,7 @@ The rest parameter (`...args`) lets us "collect" all remaining arguments into an
 
 ```javascript
 function getAge() {
-  'use strict';
+  "use strict";
   age = 21;
   console.log(age);
 }
@@ -673,7 +675,7 @@ With `"use strict"`, you can make sure that you don't accidentally declare globa
 ###### 21. What's the value of `sum`?
 
 ```javascript
-const sum = eval('10*10+5');
+const sum = eval("10*10+5");
 ```
 
 - A: `105`
@@ -696,7 +698,7 @@ const sum = eval('10*10+5');
 ###### 22. How long is cool_secret accessible?
 
 ```javascript
-sessionStorage.setItem('cool_secret', 123);
+sessionStorage.setItem("cool_secret", 123);
 ```
 
 - A: Forever, the data doesn't get lost.
@@ -749,12 +751,12 @@ You cannot do this with `let` or `const` since they're block-scoped.
 ###### 24. What's the output?
 
 ```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);
 ```
 
@@ -780,7 +782,7 @@ It doesn't work that way for a set. There is no `'1'` in our set: `set.has('1')`
 ###### 25. What's the output?
 
 ```javascript
-const obj = { a: 'one', b: 'two', a: 'three' };
+const obj = { a: "one", b: "two", a: "three" };
 console.log(obj);
 ```
 
@@ -849,12 +851,12 @@ The `continue` statement skips an iteration if a certain condition returns `true
 
 ```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())
+console.log(name.giveLydiaPizza());
 ```
 
 - A: `"Just give Lydia pizza already!"`
@@ -878,8 +880,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;
@@ -911,9 +913,9 @@ Then, we log `a[b]`, which is actually `a["[object Object]"]`. We just set that
 ###### 30. What's the output?
 
 ```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();
@@ -966,9 +968,7 @@ This is where an event loop starts to work. An **event loop** looks at the stack
 ```html
 <div onclick="console.log('first div')">
   <div onclick="console.log('second div')">
-    <button onclick="console.log('button')">
-      Click!
-    </button>
+    <button onclick="console.log('button')">Click!</button>
   </div>
 </div>
 ```
@@ -994,9 +994,7 @@ The deepest nested element that caused the event is the target of the event. You
 
 ```html
 <div onclick="console.log('div')">
-  <p onclick="console.log('p')">
-    Click here!
-  </p>
+  <p onclick="console.log('p')">Click here!</p>
 </div>
 ```
 
@@ -1020,7 +1018,7 @@ If we click `p`, we see two logs: `p` and `div`. During event propagation, there
 ###### 33. What's the output?
 
 ```javascript
-const person = { name: 'Lydia' };
+const person = { name: "Lydia" };
 
 function sayHi(age) {
   return `${this.name} is ${age}`;
@@ -1070,7 +1068,6 @@ console.log(typeof sayHi());
 #### Answer: 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>
@@ -1083,8 +1080,8 @@ FYI: `typeof` can return the following list of values: `undefined`, `boolean`, `
 ```javascript
 0;
 new Number(0);
-('');
-(' ');
+("");
+(" ");
 new Boolean(false);
 undefined;
 ```
@@ -1233,11 +1230,14 @@ What differentiates a primitive from an object is that primitives do not have an
 ###### 40. What's the output?
 
 ```javascript
-[[0, 1], [2, 3]].reduce(
+[
+  [0, 1],
+  [2, 3],
+].reduce(
   (acc, cur) => {
     return acc.concat(cur);
   },
-  [1, 2],
+  [1, 2]
 );
 ```
 
@@ -1264,7 +1264,7 @@ Then, `[1, 2, 0, 1]` is `acc` and `[2, 3]` is `cur`. We concatenate them, and ge
 
 ```javascript
 !!null;
-!!'';
+!!"";
 !!1;
 ```
 
@@ -1292,7 +1292,7 @@ Then, `[1, 2, 0, 1]` is `acc` and `[2, 3]` is `cur`. We concatenate them, and ge
 ###### 42. What does the `setInterval` method return in the browser?
 
 ```javascript
-setInterval(() => console.log('Hi'), 1000);
+setInterval(() => console.log("Hi"), 1000);
 ```
 
 - A: a unique id
@@ -1315,7 +1315,7 @@ It returns a unique id. This id can be used to clear that interval with the `cle
 ###### 43. What does this return?
 
 ```javascript
-[...'Lydia'];
+[..."Lydia"];
 ```
 
 - A: `["L", "y", "d", "i", "a"]`
@@ -1374,14 +1374,14 @@ 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));
+Promise.race([firstPromise, secondPromise]).then((res) => console.log(res));
 ```
 
 - A: `"one"`
@@ -1404,7 +1404,7 @@ When we pass multiple promises to the `Promise.race` method, it resolves/rejects
 ###### 46. What's the output?
 
 ```javascript
-let person = { name: 'Lydia' };
+let person = { name: "Lydia" };
 const members = [person];
 person = null;
 
@@ -1444,7 +1444,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,
 };
 
@@ -1473,7 +1473,7 @@ With a `for-in` loop, we can iterate through object keys, in this case `name` an
 ###### 48. What's the output?
 
 ```javascript
-console.log(3 + 4 + '5');
+console.log(3 + 4 + "5");
 ```
 
 - A: `"345"`
@@ -1500,7 +1500,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`
@@ -1525,8 +1525,8 @@ Only the first numbers in the string is returned. Based on the _radix_ (the seco
 ###### 50. What's the output?
 
 ```javascript
-[1, 2, 3].map(num => {
-  if (typeof num === 'number') return;
+[1, 2, 3].map((num) => {
+  if (typeof num === "number") return;
   return num * 2;
 });
 ```
@@ -1554,12 +1554,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);
 
@@ -1591,15 +1591,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);
   }
 }
 
@@ -1629,8 +1629,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();
@@ -1704,11 +1704,11 @@ class Dog {
   }
 }
 
-Dog.prototype.bark = function() {
+Dog.prototype.bark = function () {
   console.log(`Woof I am ${this.name}`);
 };
 
-const pet = new Dog('Mara');
+const pet = new Dog("Mara");
 
 pet.bark();
 
@@ -1773,7 +1773,7 @@ export default counter;
 
 ```javascript
 // index.js
-import myCounter from './counter';
+import myCounter from "./counter";
 
 myCounter += 1;
 
@@ -1802,7 +1802,7 @@ When we try to increment the value of `myCounter`, it throws an error: `myCounte
 ###### 58. What's the output?
 
 ```javascript
-const name = 'Lydia';
+const name = "Lydia";
 age = 21;
 
 console.log(delete name);
@@ -1873,7 +1873,7 @@ This means that the value of `y` is equal to the first value in the array, which
 ###### 60. What's the output?
 
 ```javascript
-const user = { name: 'Lydia', age: 21 };
+const user = { name: "Lydia", age: 21 };
 const admin = { admin: true, ...user };
 
 console.log(admin);
@@ -1899,9 +1899,9 @@ It's possible to combine objects using the spread operator `...`. It lets you cr
 ###### 61. What's the output?
 
 ```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));
@@ -1930,12 +1930,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);
 ```
 
@@ -1966,7 +1966,7 @@ If the replacer is a _function_, this function gets called on every property in
 let num = 10;
 
 const increaseNumber = () => num++;
-const increasePassedNumber = number => number++;
+const increasePassedNumber = (number) => number++;
 
 const num1 = increaseNumber();
 const num2 = increasePassedNumber(num1);
@@ -2123,12 +2123,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;
 ```
 
@@ -2156,7 +2156,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`
@@ -2179,7 +2179,7 @@ Every Symbol is entirely unique. The purpose of the argument passed to the Symbo
 ###### 69. What's the output?
 
 ```javascript
-const name = 'Lydia Hallie';
+const name = "Lydia Hallie";
 console.log(name.padStart(13));
 console.log(name.padStart(2));
 ```
@@ -2206,7 +2206,7 @@ If the argument passed to the `padStart` method is smaller than the length of th
 ###### 70. What's the output?
 
 ```javascript
-console.log('🥑' + '💻');
+console.log("🥑" + "💻");
 ```
 
 - A: `"🥑💻"`
@@ -2230,11 +2230,11 @@ With the `+` operator, you can concatenate strings. In this case, we are concate
 
 ```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();
@@ -2302,7 +2302,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();
@@ -2339,7 +2339,7 @@ function addToList(item, list) {
   return list.push(item);
 }
 
-const result = addToList('apple', ['banana']);
+const result = addToList("apple", ["banana"]);
 console.log(result);
 ```
 
@@ -2399,7 +2399,7 @@ Since `shape` is frozen, and since the value of `x` is not an object, we cannot
 ###### 76. What's the output?
 
 ```javascript
-const { firstName: myName } = { firstName: 'Lydia' };
+const { firstName: myName } = { firstName: "Lydia" };
 
 console.log(firstName);
 ```
@@ -2417,7 +2417,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;
 
@@ -2427,7 +2427,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;
 
@@ -2440,12 +2440,11 @@ 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
 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`.
@@ -2489,7 +2488,7 @@ The `sum` function always returns the same result. If we pass `1` and `2`, it wi
 ```javascript
 const add = () => {
   const cache = {};
-  return num => {
+  return (num) => {
     if (num in cache) {
       return `From cache! ${cache[num]}`;
     } else {
@@ -2534,7 +2533,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);
@@ -2630,13 +2629,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;
     },
@@ -2670,12 +2669,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);
 ```
@@ -2739,9 +2738,9 @@ Variables with the `const` and `let` keyword are _block-scoped_. A block is anyt
 ###### 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));
+fetch("https://www.website.com/api/user/1")
+  .then((res) => res.json())
+  .then((res) => console.log(res));
 ```
 
 - A: The result of the `fetch` method.
@@ -2795,7 +2794,7 @@ By setting `hasName` equal to `name`, you set `hasName` equal to whatever value
 ###### 87. What's the output?
 
 ```javascript
-console.log('I want pizza'[0]);
+console.log("I want pizza"[0]);
 ```
 
 - A: `"""`
@@ -2850,11 +2849,11 @@ If you're trying to set a default parameter's value equal to a parameter which i
 
 ```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);
 ```
@@ -2887,7 +2886,7 @@ class Person {
   }
 }
 
-const member = new Person('John');
+const member = new Person("John");
 console.log(typeof member);
 ```
 
@@ -2947,7 +2946,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 = () =>
@@ -2978,7 +2977,7 @@ Regular functions, such as the `giveLydiaPizza` function, have a `prototype` pro
 
 ```javascript
 const person = {
-  name: 'Lydia',
+  name: "Lydia",
   age: 21,
 };
 
@@ -3038,7 +3037,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' ]`
@@ -3052,9 +3051,9 @@ 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');
-  return
+  if (a > b) console.log("a is bigger");
+  else console.log("b is bigger");
+  return;
   a + b;
 }
 
@@ -3093,13 +3092,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";
   }
 };
 
@@ -3128,7 +3127,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);
@@ -3183,7 +3182,7 @@ The `getList` function receives an array as its argument. Between the parenthese
 
 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 `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:
 
@@ -3197,7 +3196,7 @@ The following function would have returned an object:
 ###### 99. What's the output?
 
 ```javascript
-const name = 'Lydia';
+const name = "Lydia";
 
 console.log(name());
 ```
@@ -3229,8 +3228,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`
@@ -3256,7 +3255,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);
@@ -3288,16 +3287,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');
+  myPromise().then((res) => console.log(res));
+  console.log("second");
 }
 
 async function secondFunction() {
   console.log(await myPromise());
-  console.log('second');
+  console.log("second");
 }
 
 firstFunction();
@@ -3335,8 +3334,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);
@@ -3396,13 +3395,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);
 ```
@@ -3441,7 +3440,7 @@ const colorConfig = {
   yellow: false,
 };
 
-const colors = ['pink', 'red', 'blue'];
+const colors = ["pink", "red", "blue"];
 
 console.log(colorConfig.colors[1]);
 ```
@@ -3470,7 +3469,7 @@ JavaScript interprets (or unboxes) statements. When we use bracket notation, it
 ###### 107. What's its value?
 
 ```javascript
-console.log('❤️' === '❤️');
+console.log("❤️" === "❤️");
 ```
 
 - A: `true`
@@ -3491,14 +3490,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`
@@ -3523,10 +3522,10 @@ With `splice` method, we modify the original array by deleting, replacing or add
 ###### 109. What's the output?
 
 ```javascript
-const food = ['🍕', '🍫', '🥑', '🍔'];
+const food = ["🍕", "🍫", "🥑", "🍔"];
 const info = { favoriteFood: food[0] };
 
-info.favoriteFood = '🍝';
+info.favoriteFood = "🍝";
 
 console.log(food);
 ```
@@ -3580,7 +3579,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' }
 ```
 
@@ -3592,11 +3591,11 @@ JSON.parse(jsonArray); // { name: 'Lydia' }
 ###### 111. What's the output?
 
 ```javascript
-let name = 'Lydia';
+let name = "Lydia";
 
 function getName() {
   console.log(name);
-  let name = 'Sarah';
+  let name = "Sarah";
 }
 
 getName();
@@ -3619,7 +3618,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);
@@ -3637,11 +3636,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();
@@ -3687,7 +3686,7 @@ console.log(two.next().value); // undefined
 ###### 113. What's the output?
 
 ```javascript
-console.log(`${(x => x)('I love')} to program`);
+console.log(`${((x) => x)("I love")} to program`);
 ```
 
 - A: `I love to program`
@@ -3712,7 +3711,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),
 };
 
@@ -3729,9 +3728,9 @@ config = null;
 
 #### Answer: 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. 
+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).
 
@@ -3744,16 +3743,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
@@ -3780,14 +3779,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);
@@ -3846,7 +3845,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)]);
 ```
@@ -3872,11 +3871,11 @@ With the `+=` operand, we're incrementing the value of `num` by `1`. `num` had t
 
 ```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}`;
@@ -3914,10 +3913,10 @@ With the optional chaining operator `?.`, we no longer have to explicitly check
 ###### 120. What's the output?
 
 ```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!`);
 }
@@ -3973,10 +3972,10 @@ The `language` method is a `setter`. Setters don't hold an actual value, their p
 ###### 122. What's the output?
 
 ```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`
@@ -4001,7 +4000,7 @@ console.log(!typeof name === 'string');
 ###### 123. What's the output?
 
 ```javascript
-const add = x => y => z => {
+const add = (x) => (y) => (z) => {
   console.log(x, y, z);
   return x + y + z;
 };
@@ -4091,20 +4090,20 @@ 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}`;
 }
 
-console.log(getFine(130, 300))
+console.log(getFine(130, 300));
 ```
 
 - A: The driver drove 130 and has to pay 300
@@ -4127,8 +4126,8 @@ With the `Intl.NumberFormat` method, we can format numeric values to any locale.
 ###### 127. What's the output?
 
 ```javascript
-const spookyItems = ['👻', '🎃', '🕸'];
-({ item: spookyItems[3] } = { item: '💀' });
+const spookyItems = ["👻", "🎃", "🕸"];
+({ item: spookyItems[3] } = { item: "💀" });
 
 console.log(spookyItems);
 ```
@@ -4153,7 +4152,7 @@ By destructuring objects, we can unpack values from the right-hand object, and a
 ###### 128. What's the output?
 
 ```javascript
-const name = 'Lydia Hallie';
+const name = "Lydia Hallie";
 const age = 21;
 
 console.log(Number.isNaN(name));
@@ -4189,7 +4188,7 @@ const randomValue = 21;
 
 function getInfo() {
   console.log(typeof randomValue);
-  const randomValue = 'Lydia Hallie';
+  const randomValue = "Lydia Hallie";
 }
 
 getInfo();
@@ -4215,7 +4214,7 @@ Variables declared with the `const` keyword are not referenceable before their i
 ###### 130. What's the output?
 
 ```javascript
-const myPromise = Promise.resolve('Woah some cool data');
+const myPromise = Promise.resolve("Woah some cool data");
 
 (async () => {
   try {
@@ -4223,7 +4222,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!");
   }
 })();
 ```
@@ -4248,7 +4247,7 @@ In the `try` block, we're logging the awaited value of the `myPromise` variable:
 ###### 131. What's the output?
 
 ```javascript
-const emojis = ['🥑', ['✨', '✨', ['🍕', '🍕']]];
+const emojis = ["🥑", ["✨", "✨", ["🍕", "🍕"]]];
 
 console.log(emojis.flat(1));
 ```
@@ -4321,19 +4320,19 @@ We invoke `counterTwo.increment()`, which sets `count` to `3`. Then, we log the
 ###### 133. What's the output?
 
 ```javascript
-const myPromise = Promise.resolve(Promise.resolve('Promise'));
+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!');
+  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!');
+  console.log(`${res} 2!`);
+  setTimeout(() => console.log("Timeout 2!"), 0);
+  console.log("Last line 2!");
 }
 
 funcOne();
@@ -4354,7 +4353,7 @@ First, we invoke `funcOne`. On the first line of `funcOne`, we call the _asynchr
 
 Then we call the `myPromise` promise, which is an _asynchronous_ operation.
 
-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. 
+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.
 
@@ -4378,7 +4377,7 @@ export default function sum(x) {
 }
 
 // index.js
-import * as sum from './sum';
+import * as sum from "./sum";
 ```
 
 - A: `sum(4)`
@@ -4395,12 +4394,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);
 ```
 
@@ -4431,13 +4430,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;
 ```
 
@@ -4467,7 +4466,7 @@ Then, we access a property value on the proxy object, the `get` property on the
 ###### 136. Which of the following will modify the `person` object?
 
 ```javascript
-const person = { name: 'Lydia Hallie' };
+const person = { name: "Lydia Hallie" };
 
 Object.seal(person);
 ```
@@ -4495,9 +4494,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",
   },
 };
 
@@ -4526,7 +4525,7 @@ However, it only _shallowly_ freezes the object, meaning that only _direct_ prop
 ###### 138. What's the output?
 
 ```javascript
-const add = x => x + x;
+const add = (x) => x + x;
 
 function myFunc(num = 2, value = add(num)) {
   console.log(num, value);
@@ -4559,21 +4558,21 @@ Then, we invoked `myFunc(3)` and passed the value `3` as the value for the argum
 
 ```javascript
 class Counter {
-  #number = 10
+  #number = 10;
 
   increment() {
-    this.#number++
+    this.#number++;
   }
 
   getNum() {
-    return this.#number
+    return this.#number;
   }
 }
 
-const counter = new Counter()
-counter.increment()
+const counter = new Counter();
+counter.increment();
 
-console.log(counter.#number)
+console.log(counter.#number);
 ```
 
 - A: `10`
@@ -4597,8 +4596,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) {
@@ -4641,8 +4640,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) {
@@ -4650,9 +4649,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);
 ```
@@ -4721,11 +4720,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;
 ```
 
@@ -4780,11 +4779,11 @@ Objects aren't iterable by default. An iterable is an iterable if the iterator p
 let count = 0;
 const nums = [0, 1, 2, 3];
 
-nums.forEach(num => {
-	if (num) count += 1
-})
+nums.forEach((num) => {
+  if (num) count += 1;
+});
 
-console.log(count)
+console.log(count);
 ```
 
 - A: 1
@@ -4808,12 +4807,12 @@ The `if` condition within the `forEach` loop checks whether the value of `num` i
 
 ```javascript
 function getFruit(fruits) {
-	console.log(fruits?.[1]?.[1])
+  console.log(fruits?.[1]?.[1]);
 }
 
-getFruit([['🍊', '🍌'], ['🍍']])
-getFruit()
-getFruit([['🍍'], ['🍊', '🍌']])
+getFruit([["🍊", "🍌"], ["🍍"]]);
+getFruit();
+getFruit([["🍍"], ["🍊", "🍌"]]);
 ```
 
 - A: `null`, `undefined`, 🍌
@@ -4826,11 +4825,11 @@ getFruit([['🍍'], ['🍊', '🍌']])
 
 #### Answer: 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`. 
+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. 
+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.
 
@@ -4843,19 +4842,19 @@ Lastly, we're trying to log the second item in the `['🍊', '🍌']` subarray o
 
 ```javascript
 class Calc {
-	constructor() {
-		this.count = 0 
-	}
+  constructor() {
+    this.count = 0;
+  }
 
-	increase() {
-		this.count ++
-	}
+  increase() {
+    this.count++;
+  }
 }
 
-const calc = new Calc()
-new Calc().increase()
+const calc = new Calc();
+new Calc().increase();
 
-console.log(calc.count)
+console.log(calc.count);
 ```
 
 - A: `0`
@@ -4879,25 +4878,25 @@ 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 }) => {
-	if (email) {
-		Object.assign(user, { email })
-	}
+  if (email) {
+    Object.assign(user, { email });
+  }
 
-	if (password) {
-		user.password = password
-	}
+  if (password) {
+    user.password = password;
+  }
 
-	return user
-}
+  return user;
+};
 
-const updatedUser = updateUser({ email: "new@email.com" })
+const updatedUser = updateUser({ email: "new@email.com" });
 
-console.log(updatedUser === user)
+console.log(updatedUser === user);
 ```
 
 - A: `false`
@@ -4920,13 +4919,13 @@ The `updateUser` function updates the values of the `email` and `password` prope
 ###### 149. What's the output?
 
 ```javascript
-const fruit = ['🍌', '🍊', '🍎']
+const fruit = ["🍌", "🍊", "🍎"];
 
-fruit.slice(0, 1)
-fruit.splice(0, 1)
-fruit.unshift('🍇')
+fruit.slice(0, 1);
+fruit.splice(0, 1);
+fruit.unshift("🍇");
 
-console.log(fruit)
+console.log(fruit);
 ```
 
 - A: `['🍌', '🍊', '🍎']`
@@ -4941,7 +4940,7 @@ console.log(fruit)
 
 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 `['🍇', '🍊', '🍎']`.
+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>
@@ -4952,13 +4951,13 @@ 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])
+console.log(animals[dog]);
 ```
 
 - A: `{ emoji: "🐶", name: "Mara" }`
@@ -4971,11 +4970,11 @@ console.log(animals[dog])
 
 #### Answer: B
 
-Object keys are converted to strings. 
+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"}`.
+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. 
+`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" }`.
 
@@ -4988,14 +4987,14 @@ Logging `animals[dog]`, or actually `animals["object Object"]` since converting
 
 ```javascript
 const user = {
-	email: "my@email.com",
-	updateEmail: email => {
-		this.email = email
-	}
-}
+  email: "my@email.com",
+  updateEmail: (email) => {
+    this.email = email;
+  },
+};
 
-user.updateEmail("new@email.com")
-console.log(user.email)
+user.updateEmail("new@email.com");
+console.log(user.email);
 ```
 
 - A: `my@email.com`
@@ -5008,7 +5007,7 @@ console.log(user.email)
 
 #### Answer: 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. 
+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>
@@ -5018,20 +5017,20 @@ The `updateEmail` function is an arrow function, and is not bound to the `user`
 ###### 152. What's the output?
 
 ```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])
-	const res2  = await Promise.all([promise3, promise4])
-	return [res1, res2]
-}
+  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))
+  .then((res) => console.log(res))
+  .catch((err) => console.log(err));
 ```
 
 - A: `[['First', 'Second'], ['Fourth']]`
@@ -5044,23 +5043,26 @@ runPromises()
 
 #### Answer: 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` 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` rejected with this value.
+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` 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` rejected with this value.
 
 </p>
 </details>
 
 ---
 
-###### 153. What should the value of `method` be to log `{ name: "Lydia", age: 22 }`? 
+###### 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 = /* ?? */
-Object[method](keys.map((_, i) => {
-	return [keys[i], values[i]]
-})) // { name: "Lydia", age: 22 }
+const method =
+  /* ?? */
+  Object[method](
+    keys.map((_, i) => {
+      return [keys[i], values[i]];
+    })
+  ); // { name: "Lydia", age: 22 }
 ```
 
 - A: `entries`
@@ -5073,7 +5075,7 @@ Object[method](keys.map((_, i) => {
 
 #### Answer: 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 which 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. 
+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 which 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 }`
 
@@ -5085,18 +5087,18 @@ This creates an array of subarrays containing the correct keys and values, which
 ###### 154. What's the output?
 
 ```javascript
-const createMember = ({ email, address = {}}) => {
-	const validEmail = /.+\@.+\..+/.test(email)
-	if (!validEmail) throw new Error("Valid email pls")
+const createMember = ({ email, address = {} }) => {
+  const validEmail = /.+\@.+\..+/.test(email);
+  if (!validEmail) throw new Error("Valid email pls");
 
-	return {
-		email,
-		address: address ? address : null
-	}
-}
+  return {
+    email,
+    address: address ? address : null,
+  };
+};
 
-const member = createMember({ email: "my@email.com" })
-console.log(member)
+const member = createMember({ email: "my@email.com" });
+console.log(member);
 ```
 
 - A: `{ email: "my@email.com", address: null }`
@@ -5119,13 +5121,13 @@ The default value of `address` is an empty object `{}`. When we set the variable
 ###### 155. What's the output?
 
 ```javascript
-let randomValue = { name: "Lydia" }
-randomValue = 23
+let randomValue = { name: "Lydia" };
+randomValue = 23;
 
 if (!typeof randomValue === "string") {
-	console.log("It's not a string!")
+  console.log("It's not a string!");
 } else {
-	console.log("Yay it's a string!")
+  console.log("Yay it's a string!");
 }
 ```
 
diff --git a/ar-AR/README_AR.md b/ar-AR/README_AR.md
index 6d5638e7..9c1210e2 100644
--- a/ar-AR/README_AR.md
+++ b/ar-AR/README_AR.md
@@ -1,16 +1,14 @@
-
-
 <div dir='rtl'>
 
 # قائــمة أسئلة جافا سكريبت (مستوى متقدم)
+
 أقوم بنشر عدة أسئلة جافاسكريبت بصورة يومية على حسابي في [انستغرام](https://www.instagram.com/theavocoder/).
 
 تتدرج الأسئلة إبتداءا من المستوى الأساسي أو البسيط الى المستوى المتقدم لإختبار مدى معرفتك بلغة الجافا سكريبت, قم بمراجعة و إنعاش معرفتك باللغة قليلا, أو قم بالتجهيز لمقابلة عمل لوظيفة مبرمج عن طريق هذه الأسئلة!
 
 أقوم بتحديث هذا المستودع أسبوعيا بإضافة المزيد من الأسئلة. :muscle: :rocket:
 
-
-الأجوبة توجد في الجزء المطوي بالأسفل أدناه تحت كل سؤال على حدة, فقط قم بالضغط على كلمة الإجابة لكي تحصل على الإجابة, حظا موفقا  :heart: 
+الأجوبة توجد في الجزء المطوي بالأسفل أدناه تحت كل سؤال على حدة, فقط قم بالضغط على كلمة الإجابة لكي تحصل على الإجابة, حظا موفقا :heart:
 
 اللغات المتوفرة:
 
@@ -27,6 +25,7 @@
 - [🇳🇱 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)
@@ -37,8 +36,7 @@
 - [🇹🇼 繁體中文](../zh-TW/README_zh-TW.md)
 </div>
 
-____________
-
+---
 
 1. ماهو الناتج ؟
 
@@ -64,10 +62,10 @@ sayHi();
 <div dir='rtl'>
 الإجابة هي الخيار الرابع : D
 
-في داخل الدالة, قمنا أولا بتعريف المتغير `name` مع الكلمة المفتاحية `var`. و هذا يعني ان المتغير قد حصلت له عملية hoisting  والتي تعني انه قد تم حجز مساحة لهذا المتغير في هذه اللحظة مع قيمة مبدئية و التي هي  `undefined`  إلى ان نقوم فعليا بتعريف قيمة له لاحقا.
+في داخل الدالة, قمنا أولا بتعريف المتغير `name` مع الكلمة المفتاحية `var`. و هذا يعني ان المتغير قد حصلت له عملية hoisting والتي تعني انه قد تم حجز مساحة لهذا المتغير في هذه اللحظة مع قيمة مبدئية و التي هي `undefined` إلى ان نقوم فعليا بتعريف قيمة له لاحقا.
 لم نقم بتعريف المتغير `name` بعد عندما قمنا بطباعته في السطر الاول من الدالة, لهذا لايزال يحمل القيمة `undefined`.
-  </br>
-المتغيرات التي تم تعريفها بجانب الكلمات المفتاحية `let` و  `const` يتم عمل عملية hoisting لها أيضا, ولكن على عكس المتغيرات التي يتم تعريفها بجانب الكلمة المفتاحية `var`, لا يتم تعريفها او الوصول اليها مالم نقم بإضافة قيمة لها فعليا. و يسمى هذا بال"temporal dead zone".عندما نحاول الوصول الى المتغيرات من النوع `let`قبل ان يتم تعريفها, نتحصل على الخطأ التالي  `ReferenceError`.  
+</br>
+المتغيرات التي تم تعريفها بجانب الكلمات المفتاحية `let` و `const` يتم عمل عملية hoisting لها أيضا, ولكن على عكس المتغيرات التي يتم تعريفها بجانب الكلمة المفتاحية `var`, لا يتم تعريفها او الوصول اليها مالم نقم بإضافة قيمة لها فعليا. و يسمى هذا بال"temporal dead zone".عندما نحاول الوصول الى المتغيرات من النوع `let`قبل ان يتم تعريفها, نتحصل على الخطأ التالي `ReferenceError`.
 
 </p>
 </details>
@@ -97,8 +95,8 @@ for (let i = 0; i < 3; i++) {
 <div dir='rtl'>
 الإجابة هي الخيار الثالث: C
 
-بسبب ترتيب تسلسل الأحداث في الجافا سكريبت, دالة `setTimeout` والتي هي دالة من نوع callbackقد تم استدعائها بعد ان تم تنفيذ ال loop. بماأن المتغير `i` في الloop  الاولى قد تم تعريفه عن طريق الكلمة المفتاحية `var` فإن هذه القيمة هي global. أثناء تنفيذ هذه ال loop قد تم إضافة 1 الى المتغير `var` في كل دورة باستخدام العملية `++`. بنهاية الدورة و عندما تم استدعاء الدالة `setTimeout` كانت قيمة المتغير `i` قد أصبحت تساوي `3` في المثال الأول.        
-في الloop  الثانية ,تم تعريف المتغير `i` باستخدام الكلمة المفتاحية `let`  المتغيرات التي يتم تعريفها باستخدام الكلمات المفتاحية `let`  و `const` هي متغيرات تنتمي فقط للBlock  الذي تم تعريفها بداخله, والذي هو بين القوسين, أثناءتنفيذ الloop, سنقوم بالتحصل على قيمة جديدة للمتغير `i` في نهاية كل دورة  , وأي قيمة تكون منتمية للScope  بداخل الloop.
+بسبب ترتيب تسلسل الأحداث في الجافا سكريبت, دالة `setTimeout` والتي هي دالة من نوع callbackقد تم استدعائها بعد ان تم تنفيذ ال loop. بماأن المتغير `i` في الloop الاولى قد تم تعريفه عن طريق الكلمة المفتاحية `var` فإن هذه القيمة هي global. أثناء تنفيذ هذه ال loop قد تم إضافة 1 الى المتغير `var` في كل دورة باستخدام العملية `++`. بنهاية الدورة و عندما تم استدعاء الدالة `setTimeout` كانت قيمة المتغير `i` قد أصبحت تساوي `3` في المثال الأول.  
+في الloop الثانية ,تم تعريف المتغير `i` باستخدام الكلمة المفتاحية `let` المتغيرات التي يتم تعريفها باستخدام الكلمات المفتاحية `let` و `const` هي متغيرات تنتمي فقط للBlock الذي تم تعريفها بداخله, والذي هو بين القوسين, أثناءتنفيذ الloop, سنقوم بالتحصل على قيمة جديدة للمتغير `i` في نهاية كل دورة , وأي قيمة تكون منتمية للScope بداخل الloop.
 
 </p>
 </details>
@@ -114,7 +112,7 @@ const shape = {
   diameter() {
     return this.radius * 2;
   },
-  perimeter: () => 2 * Math.PI * this.radius
+  perimeter: () => 2 * Math.PI * this.radius,
 };
 
 shape.diameter();
@@ -136,14 +134,13 @@ shape.perimeter();
 
 لا توجد قيمة `radius` في ذلك ال object لهذا يقوم بإرجاع القيمة `undefined`.
 
-
 </p>
 </details>
 </div>
 
 ---
 
-4. ماهو الناتج؟ 
+4. ماهو الناتج؟
 
 ```javascript
 +true;
@@ -160,23 +157,24 @@ shape.perimeter();
 الجواب هو الخيار الأول : A
 
 عملية الزيادة الأحادية هنا وجدت لكي تقوم بتحويل المعامل الى رقم, `true` هي `1` , و `false` هي `0`.  
- المتغير من نوع string `'Lydia'` هو قيمة صدقية أو حقيقية, بمعنى أنها تساوي `true` . السؤال الذي نقوم بطرحه هنا, هو هل هذه القيمة الصدقية هي قيمة غير صدقية؟ اي تساوي `false`؟ لهذا نتحصل على الجواب `false`.   
+ المتغير من نوع string `'Lydia'` هو قيمة صدقية أو حقيقية, بمعنى أنها تساوي `true` . السؤال الذي نقوم بطرحه هنا, هو هل هذه القيمة الصدقية هي قيمة غير صدقية؟ اي تساوي `false`؟ لهذا نتحصل على الجواب `false`.
+
 </p>
 </details>
 </div>
 
 ---
 
-5. أي الإجابات هو إجابة صحيحة؟ 
+5. أي الإجابات هو إجابة صحيحة؟
 
 ```javascript
 const bird = {
-  size: "small"
+  size: "small",
 };
 
 const mouse = {
   name: "Mickey",
-  small: true
+  small: true,
 };
 ```
 
@@ -190,20 +188,21 @@ const mouse = {
 <div dir='rtl'>
 الجواب هو الخيار الأول: A
 
-في لغة الجافا سكريبت, جميع مفاتيح الobjects  هي من النوع string. الا اذا كانت عبارة عن  symbol. حتى ولو أننا في بعض المرات لانقوم بوضع نوعها على انها string  بصورة صريحة, ولكنها دائما يتم تحويلها الى نوع string  وراء الكواليس.
+في لغة الجافا سكريبت, جميع مفاتيح الobjects هي من النوع string. الا اذا كانت عبارة عن symbol. حتى ولو أننا في بعض المرات لانقوم بوضع نوعها على انها string بصورة صريحة, ولكنها دائما يتم تحويلها الى نوع string وراء الكواليس.
 
-لغة الجافاسكريبت تقوم بترجمةال statements.عندما نقوم باستعمال ال bracket notation, تقوم الجافا سكريبت اولا برؤية أول فتحة للقوس `[` و تقوم بالمتابعة الى ان تجد قفلة هذا القوس `]`.فقط عندما تصل الى قفلة القوس حتى تقوم بتقييم ال statement و من ثم معالجتها. 
+لغة الجافاسكريبت تقوم بترجمةال statements.عندما نقوم باستعمال ال bracket notation, تقوم الجافا سكريبت اولا برؤية أول فتحة للقوس `[` و تقوم بالمتابعة الى ان تجد قفلة هذا القوس `]`.فقط عندما تصل الى قفلة القوس حتى تقوم بتقييم ال statement و من ثم معالجتها.
 `mouse[bird.size]`: اولا تقوم بتقييم`bird.size`, والتي هي تساوي `"small"`. `mouse["small"]` تقوم بإرجاع`true`
 
-ولكن في المقابل, عندما نقوم بإستخدام ال dot notation,لا يتم معالجة الأمر هكذا. `mouse` ليس لديها مفتاح يسمى `bird`, و هذا يعني أن `mouse.bird` هي قيمة `undefined`. بالتالي نقوم بالسؤال عن ال`size` بإستخدام ال dot notation: للسؤال عن قيمة  `mouse.bird.size`.
-وبما أن `mouse.bird`قيمتها `undefined` ف نحن فعليا نقوم بالسؤال عن `undefined.size` و التي هي بالتأكيد غير صحيحة و غير صالحة و ستقوم بإرجاع error مشابه ل `Cannot read property "size" of undefined`.    
+ولكن في المقابل, عندما نقوم بإستخدام ال dot notation,لا يتم معالجة الأمر هكذا. `mouse` ليس لديها مفتاح يسمى `bird`, و هذا يعني أن `mouse.bird` هي قيمة `undefined`. بالتالي نقوم بالسؤال عن ال`size` بإستخدام ال dot notation: للسؤال عن قيمة `mouse.bird.size`.
+وبما أن `mouse.bird`قيمتها `undefined` ف نحن فعليا نقوم بالسؤال عن `undefined.size` و التي هي بالتأكيد غير صحيحة و غير صالحة و ستقوم بإرجاع error مشابه ل `Cannot read property "size" of undefined`.
+
 </p>
 </details>
 </div>
 
 ---
 
-6. ماهو الناتج؟ 
+6. ماهو الناتج؟
 
 ```javascript
 let c = { greeting: "Hey!" };
@@ -231,7 +230,7 @@ console.log(d.greeting);
 
 <img src="https://i.imgur.com/ko5k0fs.png" width="200">
 
-لذا, عندما تقوم بتغيير object واحد , انت فعليا تقوم بتغيير جميع الobjects. 
+لذا, عندما تقوم بتغيير object واحد , انت فعليا تقوم بتغيير جميع الobjects.
 
 </p>
 </details>
@@ -261,13 +260,13 @@ console.log(b === c);
 <div dir='rtl'>
 الجواب هو الخيار الثالث: C
 
-`new Number()` هي دالة من نوع built-in function constructer. على الرغم من أنها تبدو كرقم, ولكنها في الحقيقة ليس رقم, هي عبارة عن object  ولديها العديد العديد من المميزات.
-  
+`new Number()` هي دالة من نوع built-in function constructer. على الرغم من أنها تبدو كرقم, ولكنها في الحقيقة ليس رقم, هي عبارة عن object ولديها العديد العديد من المميزات.
+
 عندما نقوم بإستخدام العلامة او العامل `==`, هي تقوم فقط بالتحقق من إذا ماكان لديها same _value_.كلا الطرفين قيمتهم تساوي `3` لهذا تقوم بإرجاع `true`.
 
-و لكن على الرغم من هذا, عندما نقوم بإستخدام العملية أو المعامل `===`, كلا القيمة _and_ النوع يجب ان يكونا نفس الشيء. 
+و لكن على الرغم من هذا, عندما نقوم بإستخدام العملية أو المعامل `===`, كلا القيمة _and_ النوع يجب ان يكونا نفس الشيء.
 
-هي ليست `new Number()` هي ليست عبارة عن رقم, هي عبارة عن **object** , وكلاهما سيقومان بإرجاع `false.`   
+هي ليست `new Number()` هي ليست عبارة عن رقم, هي عبارة عن **object** , وكلاهما سيقومان بإرجاع `false.`
 
 </p>
 </details>
@@ -275,7 +274,7 @@ console.log(b === c);
 
 ---
 
-8. ماهو الناتج؟ 
+8. ماهو الناتج؟
 
 ```javascript
 class Chameleon {
@@ -303,7 +302,8 @@ console.log(freddie.colorChange("orange"));
 <div dir='rtl'>
 الجواب هو الخيار الرابع: D
 
-الدالة `colorChange` هي دالة static, و الدوال التي هي من نوع static هي دوال صممت لكي يتم استخدامها فقط في الconstructor  الذي تم تعريفها به, و ليس من الممكن ان يتم تمريرها او استخدامها من قبل اي مكون children. بما أن `freddie` هي متغير children فإن الدالة لم يتم تمريرها اليه و هي غير متوفرة في ال instant من  `freddie` لذا نتحصل على الخطأ `TypeError` .    
+الدالة `colorChange` هي دالة static, و الدوال التي هي من نوع static هي دوال صممت لكي يتم استخدامها فقط في الconstructor الذي تم تعريفها به, و ليس من الممكن ان يتم تمريرها او استخدامها من قبل اي مكون children. بما أن `freddie` هي متغير children فإن الدالة لم يتم تمريرها اليه و هي غير متوفرة في ال instant من `freddie` لذا نتحصل على الخطأ `TypeError` .
+
 </p>
 </details>
 </div>
@@ -327,16 +327,17 @@ console.log(greetign);
 <div dir='rtl'>
 الجواب هو الخيار الأول : A
 
-تقوم بعمل log على الconsole  ل object. و لأننا قمنا بإنشاء object فارغ في global object! عندما قمنا بالخطأ بطباعة  `greetign` بدل ان نقوم بطباعتها بصورة صحيحة هكذا `greeting`, هنا قام مترجم الجافاسكريبت بترجمة الآتي `global.greetign = {}` أو `window.greetign = {}` في المتصفح.   
+تقوم بعمل log على الconsole ل object. و لأننا قمنا بإنشاء object فارغ في global object! عندما قمنا بالخطأ بطباعة `greetign` بدل ان نقوم بطباعتها بصورة صحيحة هكذا `greeting`, هنا قام مترجم الجافاسكريبت بترجمة الآتي `global.greetign = {}` أو `window.greetign = {}` في المتصفح.
+
+لكي نتجنب حدوث مثل هذه الحالة, بإمكاننا إستخدام `"use strict"`. بفعل هذه الخطوة ستتأكد من أنك قد عرفت المتغير قبل ان تساويه بأي شي آخر.
 
-لكي نتجنب حدوث مثل هذه الحالة, بإمكاننا إستخدام `"use strict"`. بفعل هذه الخطوة ستتأكد من أنك قد عرفت المتغير قبل ان تساويه بأي شي آخر. 
 </p>
 </details>
 </div>
 
 ---
 
- 10. ما الذي يحدث عندما نقوم بعمل الآتي؟ 
+10. ما الذي يحدث عندما نقوم بعمل الآتي؟
 
 ```javascript
 function bark() {
@@ -359,6 +360,7 @@ bark.animal = "dog";
 هذا ممكن في لغة الجافاسكريبت, لأن الدوال هي عبارة عن objects, (كل شيء بداخل الأنواع التي هي primitive هو عبارة عن object)
 
 الدالة هي عبارة عن نوع خاص من الobjects, الكود الذي تقوم بكتابته بنفسك هو ليس بالدالة الفعلية, الدالة هي object لديه خصائص. و هذه الخاصية قابلة للمناداة
+
 </p>
 </details>
 </div>
@@ -374,7 +376,7 @@ function Person(firstName, lastName) {
 }
 
 const member = new Person("Lydia", "Hallie");
-Person.getFullName = function() {
+Person.getFullName = function () {
   return `${this.firstName} ${this.lastName}`;
 };
 
@@ -392,10 +394,11 @@ console.log(member.getFullName());
 الجواب هو الخيار الأول: A
 
 ليس بإمكانك اضافة الخصائص ل constructor كما تقوم بإضافة الخصائص للobjects. إذا أردت أن تضيف مميزات لكل الobjects مرة واحدة, سيجب عليك أن تقوم بإستخدام الprototype. لذا في هذه الحالة,
+
 </div>
 
 ```js
-Person.prototype.getFullName = function() {
+Person.prototype.getFullName = function () {
   return `${this.firstName} ${this.lastName}`;
 };
 ```
@@ -434,9 +437,10 @@ console.log(sarah);
 <div dir='rtl'>
 الجواب هو الخيار الأول: A
 
-للمتغير `sarah` لم نقم بإستخدام الكلمة المفتاحية `new`, عندإستخدام الكلمة المفتاحية `new` ف هي تشير الى ال object  الخالي او الفارغ الذي قمنا بإنشاءه, و لكن اذا لم تقم بإضافة`new` ف هي ستشير الى ال **global object**!.  
+للمتغير `sarah` لم نقم بإستخدام الكلمة المفتاحية `new`, عندإستخدام الكلمة المفتاحية `new` ف هي تشير الى ال object الخالي او الفارغ الذي قمنا بإنشاءه, و لكن اذا لم تقم بإضافة`new` ف هي ستشير الى ال **global object**!.
+
+نحن نقول بأن `this.firstName` تساوي `"Sarah"` و `this.lastName` تساوي `"Smith"`. ماقمنا بفعله حقا هنا, هو أنه قمنا بتعريف `global.firstName = 'Sarah'` و `global.lastName = 'Smith'`. المتغير `sarah` لا يظل `undefined`.
 
-نحن نقول بأن `this.firstName` تساوي `"Sarah"` و `this.lastName` تساوي `"Smith"`. ماقمنا بفعله حقا هنا, هو أنه قمنا بتعريف `global.firstName = 'Sarah'` و `global.lastName = 'Smith'`. المتغير `sarah` لا يظل `undefined`.     
 </p>
 </details>
 </div>
@@ -457,7 +461,7 @@ console.log(sarah);
 <div dir='rtl'>
 الجواب هو الخيار الرابع: D
 
-أثناء مرحلة ال**capturing**, الevent تمر عبر العناصر العليا, أي العناصر الآباء إلى أن تصل الى العنصر المقصود أو المراد, حينها تتمكن من الوصول الى العنصر **target** , و حينها تبدأ عملية ال **bubbling**. 
+أثناء مرحلة ال**capturing**, الevent تمر عبر العناصر العليا, أي العناصر الآباء إلى أن تصل الى العنصر المقصود أو المراد, حينها تتمكن من الوصول الى العنصر **target** , و حينها تبدأ عملية ال **bubbling**.
 
 <img src="https://i.imgur.com/N18oRgd.png" width="200">
 
@@ -479,7 +483,8 @@ console.log(sarah);
 <div dir='rtl'>
 الجواب هو الخيار الثاني: B
 
-جميع الobjects  لديها prototypes, عدا ال objects من نوع **base object**. الobject من نوع base object هو عبارة عن object  تم إنشاءه من قبل المستخدم, أو تم إنشاءه عن طريق إستخدام الكلمة المفتاحية `new`. الbase object  لديه حق الوصول الى بعض ال methods و الخصائص. مثال: `.toString`. هذا هو السبب الذي يمكنك من إستخدام built-in JavaScript methods, مثل هذه ال methods جميعها متاحة في ال ptototype, على الرغم من أن لغة الجافا سكريبت ليس بإمكانها أن تجدها بصورة مباشرة من الobject  الذي قمت أنت بإنشاءه, و لكنها تذهب الى سلسلة الprototype  حيث بإمكانها ان تجده هناك, مما يجعله قابل للوصول من قبلك, أي بإمكانك أن تصل إليه.   
+جميع الobjects لديها prototypes, عدا ال objects من نوع **base object**. الobject من نوع base object هو عبارة عن object تم إنشاءه من قبل المستخدم, أو تم إنشاءه عن طريق إستخدام الكلمة المفتاحية `new`. الbase object لديه حق الوصول الى بعض ال methods و الخصائص. مثال: `.toString`. هذا هو السبب الذي يمكنك من إستخدام built-in JavaScript methods, مثل هذه ال methods جميعها متاحة في ال ptototype, على الرغم من أن لغة الجافا سكريبت ليس بإمكانها أن تجدها بصورة مباشرة من الobject الذي قمت أنت بإنشاءه, و لكنها تذهب الى سلسلة الprototype حيث بإمكانها ان تجده هناك, مما يجعله قابل للوصول من قبلك, أي بإمكانك أن تصل إليه.
+
 </p>
 </details>
 </div>
@@ -506,9 +511,10 @@ sum(1, "2");
 <div dir='rtl'>
 الجواب هو الخيار الثالث: C
 
-لغة الجافاسكريبت هي لغة **dynamically typed language** بمعنى أننا لا نقوم بتعريف نوع معين للمتغيرات, المتغيرات بصورة أوتوماتيكية يتم تحويلها الى أنواع أخرى بدون أن تعرف أنت ذلك, وهذا يسمى ب _implicit type coercion_. **Coercion** تعني بأنك تقوم بالتحويل من نوع الى آخر.  
+لغة الجافاسكريبت هي لغة **dynamically typed language** بمعنى أننا لا نقوم بتعريف نوع معين للمتغيرات, المتغيرات بصورة أوتوماتيكية يتم تحويلها الى أنواع أخرى بدون أن تعرف أنت ذلك, وهذا يسمى ب _implicit type coercion_. **Coercion** تعني بأنك تقوم بالتحويل من نوع الى آخر.
+
+في هذا المثال, لغة الجافاسكريبت تقوم بتحويل الرقم `1` الى string, لكي تستطيع الدالةأن تقوم بعملها و تتمكن من إرجاع قيمة. أثناء قيام عملية إضافةالمتغير من النوع number و الذي هو (`1`) و المتغير من النوع string والذي هو (`'2'`), الرقم تم التعامل معه ك string, بهذه الطريقة سنتمكن من عمل عملية concatenate للمتغيرين من نوع string ك مثال `"Hello" + "World"`, لهذا مايحدث هنا هو عبارة عن `"1" + "2"` و الذي بدوره يقوم بإرجاع `"12"`.
 
-في هذا المثال, لغة الجافاسكريبت تقوم بتحويل الرقم `1` الى string, لكي تستطيع الدالةأن تقوم بعملها و تتمكن من إرجاع قيمة. أثناء قيام عملية إضافةالمتغير من النوع number  و الذي هو (`1`) و المتغير من النوع string  والذي هو (`'2'`), الرقم تم التعامل معه ك string,  بهذه الطريقة سنتمكن من عمل عملية concatenate للمتغيرين من نوع string ك مثال `"Hello" + "World"`, لهذا مايحدث هنا هو عبارة عن `"1" + "2"` و الذي بدوره يقوم بإرجاع `"12"`.      
 </p>
 </details>
 </div>
@@ -541,8 +547,8 @@ console.log(number);
 
 ال **prefix** العامل الأحادي `++`:
 
-1. تقوم بزيادة القيمة(number الآن تساوي  `2`)
-2. تقوم بإٍرجاع القيمة (هذه ترجع  `2`)
+1. تقوم بزيادة القيمة(number الآن تساوي `2`)
+2. تقوم بإٍرجاع القيمة (هذه ترجع `2`)
 
 هذا يقوم بإرجاع `0 2 2`.
 
@@ -552,7 +558,7 @@ console.log(number);
 
 ---
 
-17.ماهو الناتج؟   
+17.ماهو الناتج؟
 
 ```javascript
 function getPersonInfo(one, two, three) {
@@ -576,7 +582,8 @@ getPersonInfo`${person} is ${age} years old`;
 <div dir='rtl'>
 الجواب هو الخيار الثاني: B
 
-اذا قمت بإستخدام tagged template literals, فإن قيمة ال argument الأول هي دائما عبارة عن array والذي نوع قيمها عبارة عن string, ماتبقى من الarguments تتحصل على القيم من الpassed expressions. 
+اذا قمت بإستخدام tagged template literals, فإن قيمة ال argument الأول هي دائما عبارة عن array والذي نوع قيمها عبارة عن string, ماتبقى من الarguments تتحصل على القيم من الpassed expressions.
+
 </p>
 </details>
 </div>
@@ -608,11 +615,11 @@ checkAge({ age: 18 });
 <div dir='rtl'>
 الجواب هو الخيار الثالث: C
 
-عندما نقوم بإختبار المساواة أو التساوي بين طرفين, ال primitives يتم مقارنتها عن طريق قيمها, بينما ال objects  يتم مقارنتها عن طريق الreference الذي يتبع لها, لغة الجافاسكريبت تتحقق عن إذا ماكان الrefrence الذي يتبع لobject يشير الى نفس الموقع في الذاكرة. 
+عندما نقوم بإختبار المساواة أو التساوي بين طرفين, ال primitives يتم مقارنتها عن طريق قيمها, بينما ال objects يتم مقارنتها عن طريق الreference الذي يتبع لها, لغة الجافاسكريبت تتحقق عن إذا ماكان الrefrence الذي يتبع لobject يشير الى نفس الموقع في الذاكرة.
 
-لدينا هنا اثنان من ال objects والتي نقوم بعمل مقارنة بينهما, واللذان بدورهما ليس لديهما ذلك, الobject الذي قمنا بتمريره ك parameter يشير الى موقع مختلف في الذاكرة من الموقع الذي يشير اليه الobject  الثاني و الذي تم استخدامه للتحق من شرط المساواة.
+لدينا هنا اثنان من ال objects والتي نقوم بعمل مقارنة بينهما, واللذان بدورهما ليس لديهما ذلك, الobject الذي قمنا بتمريره ك parameter يشير الى موقع مختلف في الذاكرة من الموقع الذي يشير اليه الobject الثاني و الذي تم استخدامه للتحق من شرط المساواة.
 
-لهذا كلا من  `{ age: 18 } === { age: 18 }` و  `{ age: 18 } == { age: 18 }` يرجعان `false`.
+لهذا كلا من `{ age: 18 } === { age: 18 }` و `{ age: 18 } == { age: 18 }` يرجعان `false`.
 
 </p>
 </details>
@@ -640,14 +647,15 @@ getAge(21);
 <div dir='rtl'>
 الجواب هو الخيار الثالث: C
 
-العامل spread `...args` يقوم بإرجاع array مع  arguments. الarray  هي object, لذا فإن `typeof args` تقوم بإرجاع  `"object"`.   
+العامل spread `...args` يقوم بإرجاع array مع arguments. الarray هي object, لذا فإن `typeof args` تقوم بإرجاع `"object"`.
+
 </p>
 </details>
 </div>
 
 ---
 
-20. ماهو الناتج؟ 
+20. ماهو الناتج؟
 
 ```javascript
 function getAge() {
@@ -669,7 +677,8 @@ getAge();
 <div dir='rtl'>
 الجواب هو الخيار الثالث: C
 
-بإستخدام `"use strict"`, يمكنك التأكد بأنك لن تقوم عن طريق الخطأ بتعريف global variables. نحن لم نقم قط بتعريف المتغير `age`, و بما أننا قمنا بإستخدام `"use strict"` ستقوم بإرجاع reference error. اذا لم نقم بإستخدام `"use strict"` لكانت قد أدت المطلوب, بما أن الخاصية `age` تم إضافتها لل global object.      
+بإستخدام `"use strict"`, يمكنك التأكد بأنك لن تقوم عن طريق الخطأ بتعريف global variables. نحن لم نقم قط بتعريف المتغير `age`, و بما أننا قمنا بإستخدام `"use strict"` ستقوم بإرجاع reference error. اذا لم نقم بإستخدام `"use strict"` لكانت قد أدت المطلوب, بما أن الخاصية `age` تم إضافتها لل global object.
+
 </p>
 </details>
 </div>
@@ -678,7 +687,7 @@ getAge();
 
 <div dir='rtl'>
 21. ماهي القيمة التي تحملها `sum`؟ 
-</div> 
+</div>
 
 ```javascript
 const sum = eval("10*10+5");
@@ -694,7 +703,8 @@ const sum = eval("10*10+5");
 <div dir='rtl'>
 الجواب هو الخيار الأول : A
 
-`eval` تقوم بتقييم الكود الذي تم تمريره ك string. إذا كان عبارة عن expression كما في هذه الحالة, فإنها تقوم بتقييم ال expression. ال expression هو `10 * 10 + 5`. و هذا بدوره يقوم بإرجاع الرقم `105`.   
+`eval` تقوم بتقييم الكود الذي تم تمريره ك string. إذا كان عبارة عن expression كما في هذه الحالة, فإنها تقوم بتقييم ال expression. ال expression هو `10 * 10 + 5`. و هذا بدوره يقوم بإرجاع الرقم `105`.
+
 </p>
 </details>
 </div>
@@ -708,6 +718,7 @@ const sum = eval("10*10+5");
 ```javascript
 sessionStorage.setItem("cool_secret", 123);
 ```
+
 <div dir='rtl'>
   
 A - الى الأبد, فالبيانات لايمكن أن تفقد.
@@ -717,6 +728,7 @@ B - عندما يقوم المستخدم بقفل ال tab.
 C - عندما يقوم المستخدم بقفل نافذه المتصفح , ليس فقط الtab.
 
 D - عندما يقوم المستخدم بقفل جهاز الكمبيوتر.
+
 </div>
 
 <details><summary><b>الإجابة</b></summary>
@@ -724,16 +736,17 @@ D - عندما يقوم المستخدم بقفل جهاز الكمبيوتر.
 <div dir='rtl'>
 الجواب هو الخيار الثاني: B
   
-البيانات التي يتم تخزينها في `sessionStorage` يتم فقدها بعد قفل ال tab. 
+البيانات التي يتم تخزينها في `sessionStorage` يتم فقدها بعد قفل ال tab.
+
+إذا قمت بإستخدام `localStorage`, البيانات ستكون مخزنة هناك الى الأبد, و لكن اذا قمت بإستثناء ان تقوم بمناداة الدالة Clear كما في التالي `localStorage.clear()` عندها ستفقد هذه البيانات.:
 
-إذا قمت بإستخدام `localStorage`, البيانات ستكون مخزنة هناك الى الأبد, و لكن اذا قمت بإستثناء ان تقوم بمناداة الدالة Clear كما في التالي `localStorage.clear()` عندها ستفقد هذه البيانات.:  
 </p>
 </details>
 </div>
 
 ---
 
-23. ماهو الناتج؟ 
+23. ماهو الناتج؟
 
 ```javascript
 var num = 8;
@@ -752,9 +765,10 @@ console.log(num);
 <div dir='rtl'>
 الجواب هو الخيار الثاني: B
 
-مع الكلمة المفتاحية `var` بإمكانك تريف عدد من المتغيرات تحمل نفس الإسم, و المتغير سيقوم بأخذ آخر قيمة تمت إضافتها اليه.  
+مع الكلمة المفتاحية `var` بإمكانك تريف عدد من المتغيرات تحمل نفس الإسم, و المتغير سيقوم بأخذ آخر قيمة تمت إضافتها اليه.
+
+ليس بإمكانك أن تفعل هذا مع `let` أو `const` بما أن الكلمتان المفتاحيتان عبارة عن block-scoped, بمعنى أن القيمة ستكون متاحة في نطاق الBlock الذي تم تعريفها به.
 
-ليس بإمكانك أن تفعل هذا مع `let` أو `const` بما أن الكلمتان المفتاحيتان عبارة عن block-scoped, بمعنى أن القيمة ستكون متاحة في نطاق الBlock  الذي تم تعريفها به.   
 </p>
 </details>
 </div>
@@ -783,16 +797,17 @@ set.has(1);
 <div dir='rtl'>
 الجواب هو الخيار الثالث: C
 
-كل مفاتيح ال object (عدا الSymbols)هي عبارة عن strings وراء الكواليس, حتى لو لم تقم بكتابة ذلك صراحة بنفسك ك string, لهذا دائما `obj.hasOwnProperty('1')` تقوم بإرجاع القيمة true.  
+كل مفاتيح ال object (عدا الSymbols)هي عبارة عن strings وراء الكواليس, حتى لو لم تقم بكتابة ذلك صراحة بنفسك ك string, لهذا دائما `obj.hasOwnProperty('1')` تقوم بإرجاع القيمة true.
+
+ولكنها لا تعمل بهذا الشكل مع set, ليس هنالك `'1'` من ضمن set, لهذا `set.has('1')` تقوم بإرجاع `false`, لديها القيمة الرقمية `1` أي من النوع number, `set.has(1)` تقوم بإرجاع `true`.
 
-ولكنها لا تعمل بهذا الشكل مع set, ليس هنالك `'1'` من ضمن set, لهذا `set.has('1')` تقوم بإرجاع `false`, لديها القيمة الرقمية `1` أي من النوع number, `set.has(1)` تقوم بإرجاع `true`.     
 </p>
 </details>
 </div>
 
 ---
 
-25. ماهو الناتج؟ 
+25. ماهو الناتج؟
 
 ```javascript
 const obj = { a: "one", b: "two", a: "three" };
@@ -822,7 +837,7 @@ console.log(obj);
 
 - A: true
 - B: false
-- C: تعتمد على 
+- C: تعتمد على
 
 <details><summary><b>الإجابة</b></summary>
 <p>
@@ -830,9 +845,10 @@ console.log(obj);
 الجواب هو الخيارالأول: A
 
 سياق التنفيذ الأساسي هو سياق تنفيذ الglobal, وهي الشيء الذي يمكن الوصول إليه من أي مكان في الكود الذي ببرنامجك.
+
 </p>
 </details>
-</div> 
+</div>
 
 ---
 
@@ -855,7 +871,8 @@ for (let i = 1; i < 5; i++) {
 <div dir='rtl'>
 الجواب هو الخيار الثالث: C
 
-العبارة `continue`  تقوم بتخطي دورة التكرار إذا وجد شرط معين يقوم بإرجاع `true`.  
+العبارة `continue` تقوم بتخطي دورة التكرار إذا وجد شرط معين يقوم بإرجاع `true`.
+
 </p>
 </details>
 </div>
@@ -871,7 +888,7 @@ String.prototype.giveLydiaPizza = () => {
 
 const name = "Lydia";
 
-console.log(name.giveLydiaPizza())
+console.log(name.giveLydiaPizza());
 ```
 
 - A: `"Just give Lydia pizza already!"`
@@ -884,14 +901,15 @@ console.log(name.giveLydiaPizza())
 <div dir='rtl'>
 الجواب هو الخيار الأول : A
 
-`String` هي built-in constructor, و لهذا سنتمكن من إضافة خصائص لها. لقد قمت بإضافة method للprototype الخاص ب `String`. Primitive strings يتمتحويلهم بصورة اوتوماتيكية الى objects من نوع string, و التي بدورها تم انشائها عن طريق دالة ال string prototype, لهذا جميع الstrings و التي هي string objects  لديها حق الوصول الى الmethod.   
+`String` هي built-in constructor, و لهذا سنتمكن من إضافة خصائص لها. لقد قمت بإضافة method للprototype الخاص ب `String`. Primitive strings يتمتحويلهم بصورة اوتوماتيكية الى objects من نوع string, و التي بدورها تم انشائها عن طريق دالة ال string prototype, لهذا جميع الstrings و التي هي string objects لديها حق الوصول الى الmethod.
+
 </p>
 </details>
 </div>
 
 ---
 
-29. ماهو الناتج؟ 
+29. ماهو الناتج؟
 
 ```javascript
 const a = {};
@@ -914,12 +932,13 @@ console.log(a[b]);
 <div dir='rtl'>
 الجواب هو الخيار الثاني : B
 
-مفاتيح ال object يتم تحويلها اوتوماتيكيا الى strings. نحن نحاول أن نقوم بجعل  object عبارة عن مفتاح للobject `a`, و الذي يحمل القيمة `123`.  
+مفاتيح ال object يتم تحويلها اوتوماتيكيا الى strings. نحن نحاول أن نقوم بجعل object عبارة عن مفتاح للobject `a`, و الذي يحمل القيمة `123`.
 
 و لكن, عندما نقوم بمحاول جعل object الى نوع string, سيصبح `"[object Object]"`. لذا ما نحاول أن نقوله هنا, هو أن `a["object Object"] = 123`.
-إذا, سنحاول أن نفعل هذا مرة أخرى , `c` هو object آخر سنقوم بتحويله الى string بصورة صريحة, لذا `a["object Object"] = 456`.  
+إذا, سنحاول أن نفعل هذا مرة أخرى , `c` هو object آخر سنقوم بتحويله الى string بصورة صريحة, لذا `a["object Object"] = 456`.
+
+إذاَ, نحن نقوم بعمل log ل `a[b]`, و التي هي في الحقيقة `a["object Object"]`. و نحن قبل قليل قمنا بوضع قيمتها التي تساوي `456`, لذا ستقوم بإرجاع `456`.
 
-إذاَ, نحن نقوم بعمل log ل `a[b]`, و التي هي في الحقيقة `a["object Object"]`. و نحن قبل قليل قمنا بوضع قيمتها التي تساوي `456`, لذا ستقوم بإرجاع `456`.    
 </p>
 </details>
 </div>
@@ -950,17 +969,17 @@ baz();
 
 لدينا الدالة `setTimeout` والتي تم استدعائها أولا, و لكن تم الخروج منها آخراً.
 
-هذا لأن في المتصفح, ليس لدينا محرَك من نوع runtime, أيضا لدينا مايعرف ب `WebAPI`. هذا ال`WebAPI` يقوم بإعطائنا الدالة `setTimeout`  لكي نبدأ بها, على سبيل المثال: DOM.
+هذا لأن في المتصفح, ليس لدينا محرَك من نوع runtime, أيضا لدينا مايعرف ب `WebAPI`. هذا ال`WebAPI` يقوم بإعطائنا الدالة `setTimeout` لكي نبدأ بها, على سبيل المثال: DOM.
 
 بعد ان يتم ارسال و البدء بتنفيذ ال _callback_ الى الWebAPI, الدالة `setTimeout` نفسها (ليس ال callback!) يتم اخراجها من الstack.
 
 <img src="https://i.imgur.com/X5wsHOg.png" width="200">
 
-الآن, `foo` يتم إدخالها و البدء بتنفيذها, بينما `"First"` يتم تسجيل دخولها.  
+الآن, `foo` يتم إدخالها و البدء بتنفيذها, بينما `"First"` يتم تسجيل دخولها.
 
 <img src="https://i.imgur.com/Pvc0dGq.png" width="200">
 
-`foo` يتم إخراجها من ال stack, بينما `baz` يتم إدخالها و البدأ بتنفيذها. `"Third"` يتم تسجيل دخولها. 
+`foo` يتم إخراجها من ال stack, بينما `baz` يتم إدخالها و البدأ بتنفيذها. `"Third"` يتم تسجيل دخولها.
 
 <img src="https://i.imgur.com/WhA2bCP.png" width="200">
 
@@ -968,17 +987,19 @@ baz();
 
 <img src="https://i.imgur.com/NSnDZmU.png" width="200">
 
-هنا تحديدا المكان الذي تبدأ فيه الloop بالعمل. 
+هنا تحديدا المكان الذي تبدأ فيه الloop بالعمل.
 ال **event loop** تنظر الى الstack و ال task queue, إذا كانت الstack خاوية, فهي تقوم بأخذ أول شيء في الqueue. و تقوم بإدخاله الى stack.
 
 <img src="https://i.imgur.com/uyiScAI.png" width="200">
 
-`bar` يتم إدخالها و البدأ بتنفيذها, `"Second"` يتم تسجيل دخولها, و من ثم إخراجها من الstack. 
+`bar` يتم إدخالها و البدأ بتنفيذها, `"Second"` يتم تسجيل دخولها, و من ثم إخراجها من الstack.
+
 </p>
 </details>
 </div>
 
 ---
+
 <div dir='rtl'>
 31. ماهو ال event.target عندما نقوم بالضغط على الزر
 </div>
@@ -986,14 +1007,12 @@ baz();
 ```html
 <div onclick="console.log('first div')">
   <div onclick="console.log('second div')">
-    <button onclick="console.log('button')">
-      Click!
-    </button>
+    <button onclick="console.log('button')">Click!</button>
   </div>
 </div>
 ```
 
-- A:  الخارجي `div`
+- A: الخارجي `div`
 - B: الداخلي `div`
 - C: `button`
 - D: array تحتوي على جميع العناصرالمتداخلة.
@@ -1003,7 +1022,8 @@ baz();
 <div dir='rtl'>
 الجواب هو الخيار الثالث: C
 
-العنصر المتداخل الأعمق الذي تسبب بتنفيذ الevent  هو العنصر الذي يستهدفه هذا الevent, بإمكانك إيقاف ال bubbling عن طريق `event.stopPropagation`.
+العنصر المتداخل الأعمق الذي تسبب بتنفيذ الevent هو العنصر الذي يستهدفه هذا الevent, بإمكانك إيقاف ال bubbling عن طريق `event.stopPropagation`.
+
 </p>
 </details>
 </div>
@@ -1016,9 +1036,7 @@ baz();
 
 ```html
 <div onclick="console.log('div')">
-  <p onclick="console.log('p')">
-    Click here!
-  </p>
+  <p onclick="console.log('p')">Click here!</p>
 </div>
 ```
 
@@ -1032,7 +1050,8 @@ baz();
 <div dir='rtl'>
 الجواب هو الخيار الأول: A
 
-إذا قمنا بالضغط على `p` سنرى إثنان من الlogs, ألا و هما `p` و `div`, أثناء عملية event propagation, هنالك ثلاث مراحل: الا وهي capturing, target و bubbling. بصورة افتراضية, الevent handlers يتم تنفيذهم في مرحلة الbubbling (إلا في حال أنك قمت بضبط قيمة `useCapture` ل `true` ). هي تتسلسل ابتداءا من أعمق عنصر متداخل تصاعدا الى الأقل عمقاً. 
+إذا قمنا بالضغط على `p` سنرى إثنان من الlogs, ألا و هما `p` و `div`, أثناء عملية event propagation, هنالك ثلاث مراحل: الا وهي capturing, target و bubbling. بصورة افتراضية, الevent handlers يتم تنفيذهم في مرحلة الbubbling (إلا في حال أنك قمت بضبط قيمة `useCapture` ل `true` ). هي تتسلسل ابتداءا من أعمق عنصر متداخل تصاعدا الى الأقل عمقاً.
+
 </p>
 </details>
 </div>
@@ -1062,9 +1081,10 @@ sayHi.bind(person, 21);
 <div dir='rtl'>
 الجواب هو الخيار الرابع: D
 
-في الحالتين, بإمكاننا تمرير ال object الذي نود أن تشير اليه الكلمة المفتاحية `this`, ولكن, `.call` هي أيضا تم تنفيذها حالا.  
+في الحالتين, بإمكاننا تمرير ال object الذي نود أن تشير اليه الكلمة المفتاحية `this`, ولكن, `.call` هي أيضا تم تنفيذها حالا.
 
 `.bind.` تقوم بإرجاع نسخة من الدالة, ولكن مع سياق محدد, لذا هي لا يتم تنفيذها حالاً.
+
 </p>
 </details>
 </div>
@@ -1091,9 +1111,10 @@ console.log(typeof sayHi());
 <div dir='rtl'>
 الجواب هو الخيار الثاني: B
 
-دالة `sayHi` تقوم بإرجاع القيمة المرجعة من الدالة المناداة في اللحظة (IIFE). هذه الدالة تقوم بإرجاع `0`, و الذي نوعه عبارة عن `"number"`.   
+دالة `sayHi` تقوم بإرجاع القيمة المرجعة من الدالة المناداة في اللحظة (IIFE). هذه الدالة تقوم بإرجاع `0`, و الذي نوعه عبارة عن `"number"`.
+
+لمعلوماتك: لدينا فقط سبعة أنواع من ال built-in و هي : `null`, `undefined`, `boolean`, `number`, `string`, `object`, و `symbol`, و `bigint`.`"function"` هي ليست نوع, وبما أن الدوال عبارة عن objects, ف هي ليست من النوع `"object"`.
 
-لمعلوماتك: لدينا فقط سبعة أنواع من ال built-in و هي : `null`, `undefined`, `boolean`, `number`, `string`, `object`, و `symbol`, و `bigint`.`"function"` هي ليست نوع, وبما أن الدوال عبارة عن objects, ف هي ليست من النوع `"object"`.  
 </p>
 </details>
 </div>
@@ -1130,7 +1151,7 @@ undefined;
 - `''` (empty string)
 - `false`
 
-Function constructors, مثل `new Number` و  `new Boolean` هي قيم صحيحية.
+Function constructors, مثل `new Number` و `new Boolean` هي قيم صحيحية.
 
 </p>
 </details>
@@ -1186,6 +1207,7 @@ console.log(numbers);
 `[1, 2, 3, 7 x empty, 11]`
 
 وذلك يعتمد على المكان الذي قمت فيه بتشغيل البرنامج ( هو مختلف لكل متصفح, node, ...الخ)
+
 </p>
 </details>
 </div>
@@ -1220,9 +1242,10 @@ console.log(numbers);
 
 النطاق أو الblock `catch`يستقبل ال arguemnt الذي يساوي `x`, هذا ليس نفس القيمة `x` عندما قمنا بتمرير الarguments, هذا المتغير `x` هو متغير block-scoped, أي يتم التعامل معه أو مناداته فقط بداخل الblock الذي تم تعريفه به.
 
-لاحقا, قمنا بضبط القيمة `1` لهذا المتغير من نوع block-scoped, وقمنا أيضا بضبط قيمة للمتغير `y`. الآن نحن نقوم بطباعة قيمة المتغير الذي من نوع block-scoped و الذي هو `x` عن طريق الlog, و الذي هو يساوي `1`.    
+لاحقا, قمنا بضبط القيمة `1` لهذا المتغير من نوع block-scoped, وقمنا أيضا بضبط قيمة للمتغير `y`. الآن نحن نقوم بطباعة قيمة المتغير الذي من نوع block-scoped و الذي هو `x` عن طريق الlog, و الذي هو يساوي `1`.
+
+بخارج نطاق ال`catch` block, `x` هي لاتزال `undefined`, و قيمة ال `y` تساوي `2`. عندما نريد طباعة قيمة ال x عن طريق الlog خارج نطاق ال `catch` block, فهي تقوم بإرجاع `undefined`, و ال `y` تقوم بإرجاع `2`.
 
-بخارج نطاق ال`catch` block, `x` هي لاتزال `undefined`, و قيمة ال `y` تساوي `2`. عندما نريد طباعة قيمة ال x عن طريق الlog خارج نطاق ال `catch` block, فهي تقوم بإرجاع `undefined`, و ال `y` تقوم بإرجاع `2`.      
 </p>
 </details>
 </div>
@@ -1243,19 +1266,23 @@ console.log(numbers);
 
 لغة الجافاسكريبت لديها فقط primitive types و objects.
 
-نقصد بال Primitive types:  `boolean`, `null`, `undefined`, `bigint`, `number`, `string`, و `symbol`.
+نقصد بال Primitive types: `boolean`, `null`, `undefined`, `bigint`, `number`, `string`, و `symbol`.
+
+مايميز ال primitive من ال object هو أن ال primitives ليس لديها أي خصائص أو methods; ولكنك ستلاحظ أن `'foo'.toUpperCase()`يتم تقييمها ومعالجتها الى `'FOO'`و لا نتحصل على الخطأ `TypeError`. هذا لأنه عندما تحاول الوصول الى خاصية أو method لمتغير من من نوع primitive مثل ال string, فإن لغة الجافاسكريبت ستقوم بشكل ضمني بعمل wrap لل object بإستخدام واحدة من ال wrapper Classes, أي مانعنيه `String`, و لاحقا بصورة مباشرة يقوم بالتخلص من الwrapper, بعد أن يتم تقييم و تنفيذ الexpression. جميع الprimitives, ماعدا `null` و `undefined` تقوم بعمل هذه العملية.
 
-مايميز ال primitive من ال object هو أن ال primitives ليس لديها أي خصائص أو methods; ولكنك ستلاحظ أن `'foo'.toUpperCase()`يتم تقييمها ومعالجتها الى `'FOO'`و لا نتحصل على الخطأ `TypeError`. هذا لأنه عندما تحاول الوصول الى خاصية أو method لمتغير من من نوع primitive مثل ال string, فإن لغة الجافاسكريبت ستقوم بشكل ضمني بعمل wrap لل object بإستخدام واحدة من ال wrapper Classes, أي مانعنيه `String`, و لاحقا بصورة مباشرة يقوم بالتخلص من الwrapper, بعد أن يتم تقييم و تنفيذ الexpression.  جميع الprimitives, ماعدا `null` و `undefined` تقوم بعمل هذه العملية.    
 </p>
 </details>
 </div>
 
 ---
 
-40. ماهو الناتج؟ 
+40. ماهو الناتج؟
 
 ```javascript
-[[0, 1], [2, 3]].reduce(
+[
+  [0, 1],
+  [2, 3],
+].reduce(
   (acc, cur) => {
     return acc.concat(cur);
   },
@@ -1275,7 +1302,8 @@ console.log(numbers);
 
 `[1, 2]` هي القيمة المبدئية.هذه القيمة هي التي بدأنا بها, و هي القيمة الأولى ل `acc`. أثناء الدورة الأولى`acc` تساوي `[1,2]` و `cur` تساوي `[0, 1]`, عندما نقوم بدمجهما سويا عن طريق concat يصبح لدينا الناتج `[1, 2, 0, 1]`.
 
-إذاً, `[1, 2, 0, 1]`  هي `acc` و `[2, 3]` هي `cur`. نقوم بدمجهما سوية و نتحصل على `[1, 2, 0, 1, 2, 3]`.
+إذاً, `[1, 2, 0, 1]` هي `acc` و `[2, 3]` هي `cur`. نقوم بدمجهما سوية و نتحصل على `[1, 2, 0, 1, 2, 3]`.
+
 </p>
 </details>
 </div>
@@ -1302,27 +1330,29 @@ console.log(numbers);
 
 `null` قيمة خطئية.
 
-`!null` تقوم بإرجاع `true`. 
+`!null` تقوم بإرجاع `true`.
 
 `!true` تقوم بإرجاع `false`.
-*********
- 
+
+---
+
 `""` قيمة خطئية.
 
-`!""`تقوم بإرجاع `true`. 
+`!""`تقوم بإرجاع `true`.
 
 `!true` تقوم بإرجاع `false`.
-*********
-   
+
+---
+
 `1` قيمة صحيحية.
 
 `!1` تقوم بإرجاع `false`.
 
-`!false` تقوم بإرجاع `true`. 
+`!false` تقوم بإرجاع `true`.
 
 </p>
 </details>
-</div> 
+</div>
 
 ---
 
@@ -1338,11 +1368,10 @@ setInterval(() => console.log("Hi"), 1000);
 <div dir='rtl'>
 
 A - رقم فريد أو متفرد id
- 
- 
- B - قيمة محددة لل milliseconds
 
- C - الدالة التي تم تمريرها 
+B - قيمة محددة لل milliseconds
+
+C - الدالة التي تم تمريرها
 
 `undefined` - D
 
@@ -1353,14 +1382,15 @@ A - رقم فريد أو متفرد id
 <div dir='rtl'>
 الجواب هو الخيار الأول: A
 
-تقوم بإرجاع ال id الفريد, هذا الid يمكن استخدامه لكي يقوم بتصفير عداد الفترات المفصلة أي الinterval عن طريق استخدام الدالة `clearInterval()` 
+تقوم بإرجاع ال id الفريد, هذا الid يمكن استخدامه لكي يقوم بتصفير عداد الفترات المفصلة أي الinterval عن طريق استخدام الدالة `clearInterval()`
+
 </p>
 </details>
 </div>
 
 ---
 
-43. مالذي يتم ارجاعه بعد تنفيذ الكود أدناه؟ 
+43. مالذي يتم ارجاعه بعد تنفيذ الكود أدناه؟
 
 ```javascript
 [..."Lydia"];
@@ -1377,6 +1407,7 @@ A - رقم فريد أو متفرد id
 الجواب هو الخيار الأول: A
 
 الstring هي تكرارية, و عملية الspread (...) تقوم بتحويل اي حرف تم فيه تنفيذ فئة تكرارية الى عنصر منفرد واحد.
+
 </p>
 </details>
 </div>
@@ -1407,11 +1438,12 @@ console.log(gen.next().value);
 <div dir='rtl'>
 الجواب هو الخيار الثالث: C
 
-الدوال العادية ليس بإمكانها ان تتوقف في وسط التنفيذ بعد أن يتم مناداتها, و لكن الدوال من نوع generator من الممكن أن يتم ايقافها وسط التنفيذ, و لاحقا يتم مواصلة تنفيذها من حيث المكان الذي توقفت به. في كل مرة تواجه فيها الدالة من نوع generator الكلمة المفتاحية `yield`, فإن الدالة تخضع أو تستسلم للقيمة المحددة بعدها. مع ملاحظة أن الدالة من نوع generator  في هذه الحالة, لاتقوم بإرجاع القيمة, بل تخضع لتلك القيمة. 
+الدوال العادية ليس بإمكانها ان تتوقف في وسط التنفيذ بعد أن يتم مناداتها, و لكن الدوال من نوع generator من الممكن أن يتم ايقافها وسط التنفيذ, و لاحقا يتم مواصلة تنفيذها من حيث المكان الذي توقفت به. في كل مرة تواجه فيها الدالة من نوع generator الكلمة المفتاحية `yield`, فإن الدالة تخضع أو تستسلم للقيمة المحددة بعدها. مع ملاحظة أن الدالة من نوع generator في هذه الحالة, لاتقوم بإرجاع القيمة, بل تخضع لتلك القيمة.
 
 أولا, نقوم بإنشاء الدالة من نوع generator مع وجود المتغير `i` مساوي ل `10`. نقوم بمناداة الدالةمن نوع generator باستخدام الدالة `next()`. في المرة الأولى التي ننادي فيها الدالة من نوع generator, فإن ال `i` تساوي `10`. هي تواجه الكلمة المفتاحية `yield`, فتخضع لقيمة ال `i`. الدالة generator في هذه اللحظة تم توقيفها مؤقتا, و القيمة `10` تم طباعتها عن طريق log.
 
-اذاً, نقوم بمناداة الدالة مرة أخرى عن طريق الدالة `next()`, هي تبدأ لتواصل من المكان الذي تم توقفيها فيه مؤقتا سابقاً, و ماتزال قيمة `i` تساوي `10`. الآن هي تواجه الكلمة المفتاحية `yield` التالية, و تواجه `i * 2`. `i` تساوي `10`,لهذا تقوم بإرجاع `10 * 2` و التي هي تساوي `20`, و هذا سيوصلنا للنتيجة `10, 20`.         
+اذاً, نقوم بمناداة الدالة مرة أخرى عن طريق الدالة `next()`, هي تبدأ لتواصل من المكان الذي تم توقفيها فيه مؤقتا سابقاً, و ماتزال قيمة `i` تساوي `10`. الآن هي تواجه الكلمة المفتاحية `yield` التالية, و تواجه `i * 2`. `i` تساوي `10`,لهذا تقوم بإرجاع `10 * 2` و التي هي تساوي `20`, و هذا سيوصلنا للنتيجة `10, 20`.
+
 </p>
 </details>
 </div>
@@ -1429,7 +1461,7 @@ const secondPromise = new Promise((res, rej) => {
   setTimeout(res, 100, "two");
 });
 
-Promise.race([firstPromise, secondPromise]).then(res => console.log(res));
+Promise.race([firstPromise, secondPromise]).then((res) => console.log(res));
 ```
 
 - A: `"one"`
@@ -1442,7 +1474,8 @@ Promise.race([firstPromise, secondPromise]).then(res => console.log(res));
 <div dir='rtl'>
 الجواب هو الخيار الثاني: B
 
-عندما نقوم بتمرير عدد من الpromises للدالة `Promise.race`. فهي تقوم برفض أو فصل الpromise  الاولى. للدالة `setTimeout` نحن نقوم بتمرير timer: 500ms لل promise الأولى و التي هي (`firstPromise`), و 100ms اي 100ملي ثانية للpromise الثانية والتي هي (`secondPromise`) هذا يعني ان ال `secondPromise` يتم فصلها اولاً مع القيمة `'two'`. `res` الآن تحمل قيمة `'two'`, وهي التي تم طباعتها عن طريق الlog.        
+عندما نقوم بتمرير عدد من الpromises للدالة `Promise.race`. فهي تقوم برفض أو فصل الpromise الاولى. للدالة `setTimeout` نحن نقوم بتمرير timer: 500ms لل promise الأولى و التي هي (`firstPromise`), و 100ms اي 100ملي ثانية للpromise الثانية والتي هي (`secondPromise`) هذا يعني ان ال `secondPromise` يتم فصلها اولاً مع القيمة `'two'`. `res` الآن تحمل قيمة `'two'`, وهي التي تم طباعتها عن طريق الlog.
+
 </p>
 </details>
 </div>
@@ -1469,7 +1502,7 @@ console.log(members);
 <div dir='rtl'>
 الجواب هو الخيار الرابع: D
 
-أولا, نقوم بتعريف المتغير `person` مع قيمة عبارة عن object لديه الخاصية `name`.  
+أولا, نقوم بتعريف المتغير `person` مع قيمة عبارة عن object لديه الخاصية `name`.
 
 <img src="https://i.imgur.com/TML1MbS.png" width="200">
 
@@ -1478,11 +1511,12 @@ console.log(members);
 
 <img src="https://i.imgur.com/FSG5K3F.png" width="300">
 
-ثم , نقوم بضبط قمية المتغير `person` بقيمة تساوي `null`.  
+ثم , نقوم بضبط قمية المتغير `person` بقيمة تساوي `null`.
 
 <img src="https://i.imgur.com/sYjcsMT.png" width="300">
 
-نحن فقط نقوم بتعديل قيمة المتغير `person`, وليس أول عنصر في ال array, بما أن ذلك العنصر لديه refrence منسوخ من ال object. أول عنصر في `members` لا يزال لديه refrence للobject الأصلي. و عندما نقوم بطباع الarray `members` عن طريق الlog, فإن العنصر الأول لايزال يحمل قيمة الobject, و التي سيتم طباعتها عن طريق log.  
+نحن فقط نقوم بتعديل قيمة المتغير `person`, وليس أول عنصر في ال array, بما أن ذلك العنصر لديه refrence منسوخ من ال object. أول عنصر في `members` لا يزال لديه refrence للobject الأصلي. و عندما نقوم بطباع الarray `members` عن طريق الlog, فإن العنصر الأول لايزال يحمل قيمة الobject, و التي سيتم طباعتها عن طريق log.
+
 </p>
 </details>
 </div>
@@ -1494,7 +1528,7 @@ console.log(members);
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21
+  age: 21,
 };
 
 for (const item in person) {
@@ -1512,7 +1546,8 @@ for (const item in person) {
 <div dir='rtl'>
 الجواب هو الخيار الثاني: B
 
-بإستخدام `for-in` التكرارية, بامكاننا أن نصل الى جميع المفاتيح التي تخص object معين. في هذه الحالة `name` و `age`. ماوراء الكواليس, مفاتيح ال objects هي عبارة عن strings (إذا لم تكن هذه المفاتيح عبارة عن symbol), في أي حلقة من الحلقات التكرارية, نقوم بضبط القيمة `item`مساوية للمفتاح الحالي الذي هي تتكرر فيه اوعنده. أولا `item`  تساوي `name`, و يتم طباعتها عن طريق الlog, ثم `item` تساوي `age` و التي ايضا تم طباعتها عن طريق الlog.
+بإستخدام `for-in` التكرارية, بامكاننا أن نصل الى جميع المفاتيح التي تخص object معين. في هذه الحالة `name` و `age`. ماوراء الكواليس, مفاتيح ال objects هي عبارة عن strings (إذا لم تكن هذه المفاتيح عبارة عن symbol), في أي حلقة من الحلقات التكرارية, نقوم بضبط القيمة `item`مساوية للمفتاح الحالي الذي هي تتكرر فيه اوعنده. أولا `item` تساوي `name`, و يتم طباعتها عن طريق الlog, ثم `item` تساوي `age` و التي ايضا تم طباعتها عن طريق الlog.
+
 </p>
 </details>
 </div>
@@ -1535,11 +1570,12 @@ console.log(3 + 4 + "5");
 <div dir='rtl'>
 الجواب هو الخيار الثاني: B
 
-Operator associativity او ترابطية العامل هي الترتيب أو التسلسل الذي يقيم به الcompiler ال expressions, ف هو إما أن يكون من اليسار الى اليمين أو من اليمين الى اليسار. هذا يحدث فقط إذا كان جميع الoperators لديها نفس الأسبقية. لدينا فقط نوع واحد من الoperator ألا و هو `+`. بالإضافة الى التالي, الترابطية هي من اليسار الى اليمين.  
+Operator associativity او ترابطية العامل هي الترتيب أو التسلسل الذي يقيم به الcompiler ال expressions, ف هو إما أن يكون من اليسار الى اليمين أو من اليمين الى اليسار. هذا يحدث فقط إذا كان جميع الoperators لديها نفس الأسبقية. لدينا فقط نوع واحد من الoperator ألا و هو `+`. بالإضافة الى التالي, الترابطية هي من اليسار الى اليمين.
 
 `3 + 4` يتم تقييمها أولا. هذا مايعطينا الناتج الذي هو عبارة عن الرقم `7`.
 
-`7 + '5'` تقوم بإرجاع الناتج `"75"` بسبب عملية ال coercion وهي العمليةالتي تقوم بالتحويل من نوع الى آخر, لغة الجافاسكريبت تقوم بتحويل الرقم `7` الى النوع string, أنظرالى السؤال رقم 15 في الأعلى. بإمكاننا عمل concatenate لمتغيرين من النوع string بإستخدام العملية `+`. `"7" + "5"` سترجع الناتج `"75"`.   
+`7 + '5'` تقوم بإرجاع الناتج `"75"` بسبب عملية ال coercion وهي العمليةالتي تقوم بالتحويل من نوع الى آخر, لغة الجافاسكريبت تقوم بتحويل الرقم `7` الى النوع string, أنظرالى السؤال رقم 15 في الأعلى. بإمكاننا عمل concatenate لمتغيرين من النوع string بإستخدام العملية `+`. `"7" + "5"` سترجع الناتج `"75"`.
+
 </p>
 </details>
 </div>
@@ -1564,9 +1600,10 @@ const num = parseInt("7*6", 10);
 <div dir='rtl'>
 الجواب هو الخيار الثالث: C
 
-فقط الأرقام الأولى في الstring يتم إرجاعها. بناءاً على _radix_ (الargument الثاني لكي يتم تحديدنوعية الرقم الذي نود أن نقوم بعمل parse له الى: base 10, hexadecimal, octal, binary, الخ. ). تقوم `parseInt` بالتحقق عن إذا ماكانت الحروف في الstring صالحة. و بمجرد أن تجد حرف غير صالح في ال radix, ف هي تقوم بإيقاف عملية الparsing مباشرة و تتجاهل الحروف التي تليه.   
+فقط الأرقام الأولى في الstring يتم إرجاعها. بناءاً على _radix_ (الargument الثاني لكي يتم تحديدنوعية الرقم الذي نود أن نقوم بعمل parse له الى: base 10, hexadecimal, octal, binary, الخ. ). تقوم `parseInt` بالتحقق عن إذا ماكانت الحروف في الstring صالحة. و بمجرد أن تجد حرف غير صالح في ال radix, ف هي تقوم بإيقاف عملية الparsing مباشرة و تتجاهل الحروف التي تليه.
+
+`*` ليست رقم صالح. هي فقط تقوم بعمل parse ل `"7"` الى عدد عشري `7`. `num` الآن تحمل القيمة `7`.
 
-`*` ليست رقم صالح. هي فقط تقوم بعمل parse ل `"7"` الى عدد عشري `7`. `num` الآن تحمل القيمة `7`.   
 </p>
 </details>
 </div>
@@ -1576,7 +1613,7 @@ const num = parseInt("7*6", 10);
 50. ماهو الناتج؟
 
 ```javascript
-[1, 2, 3].map(num => {
+[1, 2, 3].map((num) => {
   if (typeof num === "number") return;
   return num * 2;
 });
@@ -1592,9 +1629,10 @@ const num = parseInt("7*6", 10);
 <div dir='rtl'>
 الجواب هو الخيار الثالث: C
 
-عندما يتم عمل mapping لل array, فإن قيمة `num` ستساوي قيمة العنصر الذي يتم حاليا المرور به, فكما نعرف أن الmapping يدور على جميع عناصر الarray. في هذه الحالة, العناصر عبارة عن أرقام, لهذا فإن شرط ال if statement `typeof num === "number"` يقوم بإرجاع `true`. دالة map  تقوم بإنشاء array جديدة, و إدخال القيم المرجعة من الدالة في هذه الarray.
+عندما يتم عمل mapping لل array, فإن قيمة `num` ستساوي قيمة العنصر الذي يتم حاليا المرور به, فكما نعرف أن الmapping يدور على جميع عناصر الarray. في هذه الحالة, العناصر عبارة عن أرقام, لهذا فإن شرط ال if statement `typeof num === "number"` يقوم بإرجاع `true`. دالة map تقوم بإنشاء array جديدة, و إدخال القيم المرجعة من الدالة في هذه الarray.
+
+ولكن, لا نقوم بإرجاع قيمة. عندما لا نقوم بإرجاع قيمة من الدالة, فإن الدالة تقوم بإرجاع `undefined`. لكل عنصرٍ في الarray, فإن نطاق الدالة او نعني الfunction block يتم مناداته, لهذا لأي عنصر نقوم بإرجاع `undefined`.
 
-ولكن, لا نقوم بإرجاع قيمة. عندما لا نقوم بإرجاع قيمة من الدالة, فإن الدالة تقوم بإرجاع `undefined`. لكل عنصرٍ في الarray, فإن نطاق الدالة او نعني الfunction block يتم مناداته, لهذا لأي عنصر نقوم بإرجاع `undefined`.  
 </p>
 </details>
 </div>
@@ -1631,7 +1669,8 @@ console.log(person, birthYear);
 
 المتغير `birthYear` لديه refrence للقيمة `"1997"`. الargument `year` أيضا لديه refrence للقيمة `"1997"`, لكنها ليست نفس القيمة التي `birthYear` لديها refrence لها. عندما نقوم بتحديث قيمة `year` عن طريق ضبط `year` تساوي ل `"1998"`, نحن فقط نقوم بتحديث قيمة `year`. `birthYear` لا تزال تساوي `"1997"`.
 
-قيمة `person` هي object. الargument `member` لديه نسخة refrence لنفس الobject. عندما نقوم بتعديل او تحديث خاصية للobject `member`و الذي لديه refrence لها, فإن قيمة `person` ستتعدل و تتغير أيضا,بما أن كلاهما لديهما refrence لنفس الobject. الخصائص `person` و `name` هما الأىن مساويان للقيمة `"Lydia"`.      
+قيمة `person` هي object. الargument `member` لديه نسخة refrence لنفس الobject. عندما نقوم بتعديل او تحديث خاصية للobject `member`و الذي لديه refrence لها, فإن قيمة `person` ستتعدل و تتغير أيضا,بما أن كلاهما لديهما refrence لنفس الobject. الخصائص `person` و `name` هما الأىن مساويان للقيمة `"Lydia"`.
+
 </p>
 </details>
 </div>
@@ -1667,16 +1706,17 @@ sayHi();
 <div dir='rtl'>
 الجواب هو الخيار الرابع: D
 
-مع عبارة `throw` , بإمكاننا إنشاء errors حسب الطلب, أي ليست كا الإخطاء العامة في اللغة, بإستخدام هذه العبارة بإمكانك أن تضع exception, الexception يمكن أن يكون : <b>string</b>,  <b>number</b>, <b>boolean</b> أو <b>object</b>. في هذه الحالة, الexcption لدينا هو ال string `'Hello world'`.
+مع عبارة `throw` , بإمكاننا إنشاء errors حسب الطلب, أي ليست كا الإخطاء العامة في اللغة, بإستخدام هذه العبارة بإمكانك أن تضع exception, الexception يمكن أن يكون : <b>string</b>, <b>number</b>, <b>boolean</b> أو <b>object</b>. في هذه الحالة, الexcption لدينا هو ال string `'Hello world'`.
+
+مع عبارة `catch`, بإمكاننا ان نحدد ما الذي يتوجب فعله عندما يتم وضع أو إلقاء الexception في نطاق ال `try`. تم إلقاء أو وضع exception: الstring `'Hello world'`. `e` الآن تساوي تلك الstring,log. هذا سيعطينا النتيجة `'Oh an error: Hello world'`.
 
-مع عبارة `catch`, بإمكاننا ان نحدد ما الذي يتوجب فعله عندما يتم وضع أو إلقاء الexception في نطاق ال `try`. تم إلقاء أو وضع exception: الstring `'Hello world'`.  `e` الآن تساوي تلك الstring,log. هذا سيعطينا النتيجة `'Oh an error: Hello world'`.  
 </p>
 </details>
 </div>
 
 ---
 
-53. ماهو الناتج؟ 
+53. ماهو الناتج؟
 
 ```javascript
 function Car() {
@@ -1698,7 +1738,8 @@ console.log(myCar.make);
 <div dir='rtl'>
 الجواب هو الخيار الثاني: B
 
-عندما تقوم بإرجاع خاصية, فإن قيمة هذه الخاصية هي تساوي القيمة المرجعة, ليس القيمة التي تم ضبطها في دالة الconstructor. نقوم بإرجاع ال string `"Maserati"`, لذا فإن `myCar.make` تساوي `"Maserati"`.   
+عندما تقوم بإرجاع خاصية, فإن قيمة هذه الخاصية هي تساوي القيمة المرجعة, ليس القيمة التي تم ضبطها في دالة الconstructor. نقوم بإرجاع ال string `"Maserati"`, لذا فإن `myCar.make` تساوي `"Maserati"`.
+
 </p>
 </details>
 </div>
@@ -1726,7 +1767,8 @@ console.log(typeof y);
 <div dir='rtl'>
 الجواب هو الخيار الأول : A
 
-`let x = y = 10;` هي في الحقيقة إختصار ل: 
+`let x = y = 10;` هي في الحقيقة إختصار ل:
+
 </div>
 
 ```javascript
@@ -1736,11 +1778,12 @@ let x = y;
 
 <div dir='rtl'>
   
-عندما نقوم بضبط قيمة`y` لكي تساوي `10`, فنحن فعليا نقوم بإضافة الخاصية `y` للglobal object. (`window` في المتصفح, `global` في Node). في المتصفح, `window.y` الآن تساوي `10`. 
+عندما نقوم بضبط قيمة`y` لكي تساوي `10`, فنحن فعليا نقوم بإضافة الخاصية `y` للglobal object. (`window` في المتصفح, `global` في Node). في المتصفح, `window.y` الآن تساوي `10`.
 
 ثم, عندما نقوم بتعريف المتغير `x` بالقيمة `y` و التي هي في الحقيقة تساوي `10`. المتغيرات التي يتم تعريفها بالكلمة المفتاحية `let`هي متغيرات block scoped, أي يتم التعامل معها في النطاق الذي تم تعريفها فيه فقط, الدالة المناداة حاليا في هذه الحالة أي immediately-invoked function (IIFE). عندما نقوم بإستخدام العملية `typeof`, فإن المعامل `x` ليس معرف, نحن نحاول الوصول الى `x` خارج النطاق الذي تم تعريفه بها. هذا يعني أن `x` ليست معرفة. المتغيرات التي لم يتم وضع قيمة لها أو لم يتم تعريفها هي من النوع `"undefined"`. `console.log(typeof x)` تقوم بإرجاع `"undefined"`.
 
-ولكن, نحن قمنا بإنشاء و تعريف global variable `y` عندما قمنا بضبط قيمة `y` لتساوي `10`. هذه القيمة يمكن الوصول إليها من أي مكان في البرنامج. `y` هي معرفة, و لديها قيمة من النوع `"number"`.  `console.log(typeof y)` تقوم بإرجاع `"number"`.   
+ولكن, نحن قمنا بإنشاء و تعريف global variable `y` عندما قمنا بضبط قيمة `y` لتساوي `10`. هذه القيمة يمكن الوصول إليها من أي مكان في البرنامج. `y` هي معرفة, و لديها قيمة من النوع `"number"`. `console.log(typeof y)` تقوم بإرجاع `"number"`.
+
 </p>
 </details>
 </div>
@@ -1756,7 +1799,7 @@ class Dog {
   }
 }
 
-Dog.prototype.bark = function() {
+Dog.prototype.bark = function () {
   console.log(`Woof I am ${this.name}`);
 };
 
@@ -1779,9 +1822,10 @@ pet.bark();
 <div dir='rtl'>
 الجواب هو الخيار الأول: A
   
-بإمكاننا مسح خصائص object معين عن طريق استخدام الكلمة المفتاحية `delete`, أيضا يمكن فعل هذا في ال prototype. بمسح خاصية معينة من الprototype,  فهي سيتم مسحها وبالتالي لن تكون موجودة في سلسلة الprototype. في هذه الحالة فإن الدالة `bark`  لن تكون موجودة بعد الآن في الprototype بعد `delete Dog.prototype.bark`, ولكن بالرغم من هذا فنحن نحاول الوصول إليها.   
+بإمكاننا مسح خصائص object معين عن طريق استخدام الكلمة المفتاحية `delete`, أيضا يمكن فعل هذا في ال prototype. بمسح خاصية معينة من الprototype,  فهي سيتم مسحها وبالتالي لن تكون موجودة في سلسلة الprototype. في هذه الحالة فإن الدالة `bark`  لن تكون موجودة بعد الآن في الprototype بعد `delete Dog.prototype.bark`, ولكن بالرغم من هذا فنحن نحاول الوصول إليها.
+
+عندما نحاول أن ننادي شيئا ما في دالة و هو ليس موجود في هذه الدالة, فإننا سنتحصل على الخطأ `TypeError`, و في هذه الحالة `TypeError: pet.bark is not a function` بما أن `pet.bark` هي `undefined`.
 
-عندما نحاول أن ننادي شيئا ما في دالة و هو ليس موجود في هذه الدالة, فإننا سنتحصل على الخطأ `TypeError`, و في هذه الحالة `TypeError: pet.bark is not a function` بما أن `pet.bark` هي `undefined`.   
 </p>
 </details>
 </div>
@@ -1806,9 +1850,10 @@ console.log(set);
 <div dir='rtl'>
 الجواب هو الخيار الرابع: D
 
-ال object `Set` هو مجموعة من القيم الفريدة, أي القيمة بإمكانها أن تتواجد مرة واحدة فقط في المجموعة. 
+ال object `Set` هو مجموعة من القيم الفريدة, أي القيمة بإمكانها أن تتواجد مرة واحدة فقط في المجموعة.
+
+نقوم بتمرير التكراري أي نعني الiterable `[1, 1, 2, 3, 4]` بوجود قيمة مكررة ألا وهي `1` . بما أننا لا يمكن أن نضع قيمة واحدة مرتين في مجموعة, فإن واحدة من القيم المكررة سيتم إزالتها, و سيكون الناتج: `{1, 2, 3, 4}`.
 
-نقوم بتمرير التكراري أي نعني الiterable `[1, 1, 2, 3, 4]`  بوجود قيمة مكررة ألا وهي `1` . بما أننا لا يمكن أن نضع قيمة واحدة مرتين في مجموعة, فإن واحدة من القيم المكررة سيتم إزالتها, و سيكون الناتج: `{1, 2, 3, 4}`. 
 </p>
 </details>
 </div>
@@ -1844,7 +1889,8 @@ console.log(myCounter);
 
 هنا يوجد لدينا module مستورد وهو قابل للقراءة فقط, ليس بإمكانك تعديل او تحديث الmodule المستورد, أي imported module. فقط الmodule الذي قام بتصديره هو القادر على تغيير قيمته.
 
-عندما نحاول أن نزيد قيمة المتغير `myCounter`, سنتحصل على الخطأ `myCounter` هو قابل للقراءة فقط و ليس من الممكن تعديله.  
+عندما نحاول أن نزيد قيمة المتغير `myCounter`, سنتحصل على الخطأ `myCounter` هو قابل للقراءة فقط و ليس من الممكن تعديله.
+
 </p>
 </details>
 </div>
@@ -1871,9 +1917,10 @@ console.log(delete age);
 <div dir='rtl'>
 الجواب هو الخيار الأول: A
   
-العامل `delete` تقوم بإرجاع قيمة boolen و هي `true` عندما تتم عملية المسح بنجاح, خلاف ذلك ستقوم بإرجاع `false`, ولكن المتغيرات المعرفة بالكلمات المفتاحية `var`, `const` أو `let` ليس بالإمكان مسحها بإستخدام العامل `delete`.        
+العامل `delete` تقوم بإرجاع قيمة boolen و هي `true` عندما تتم عملية المسح بنجاح, خلاف ذلك ستقوم بإرجاع `false`, ولكن المتغيرات المعرفة بالكلمات المفتاحية `var`, `const` أو `let` ليس بالإمكان مسحها بإستخدام العامل `delete`.
+
+المتغير `name` تم تعريفه باستخدام الكلمة المفتاحية `const`, لهذا فإن عملية مسحه لم تتم بنجاح, وتم إرجاع القيمة `false`, عندما نقوم بضبط المتغير `age` ليساوي القيمة `21` فإننا فعليا نقوم بإضافة خاصية تسمى `age` للglobal object. بإمكانك أن تمسح خصائص من الobjects بنجاح بإستخدام هذه الطريقة , أيضا الglobal objects, لذا فإن `delete age` تقوم بإرجاع `true`.
 
-المتغير `name` تم تعريفه باستخدام الكلمة المفتاحية `const`, لهذا فإن عملية مسحه لم تتم بنجاح, وتم إرجاع القيمة `false`, عندما نقوم بضبط المتغير `age` ليساوي القيمة `21` فإننا فعليا نقوم بإضافة خاصية تسمى `age` للglobal object. بإمكانك أن تمسح خصائص من الobjects بنجاح بإستخدام هذه الطريقة , أيضا الglobal objects, لذا فإن `delete age` تقوم بإرجاع `true`.         
 </p>
 </details>
 
@@ -1898,7 +1945,8 @@ console.log(y);
 <div dir='rtl'>
 الجواب هو الخيار الثالث: C
 
-بإمكاننا إستخراج أو استخلاص القيم من arrays أو من objects عن طريق إستخدام الdestructing, على سبيل المثال: 
+بإمكاننا إستخراج أو استخلاص القيم من arrays أو من objects عن طريق إستخدام الdestructing, على سبيل المثال:
+
 </div>
 
 ```javascript
@@ -1908,7 +1956,8 @@ console.log(y);
 <div dir='rtl'>
 <img src="https://i.imgur.com/ADFpVop.png" width="200">
 
-قيمة `a` الآن تساوي `1`, و قيمة `b` الآن تساوي `2`. ماقمنا بفعله حقاً في هذا السؤال هو:     
+قيمة `a` الآن تساوي `1`, و قيمة `b` الآن تساوي `2`. ماقمنا بفعله حقاً في هذا السؤال هو:
+
 </div>
 
 ```javascript
@@ -1918,7 +1967,8 @@ console.log(y);
 <div dir='rtl'>
 <img src="https://i.imgur.com/NzGkMNk.png" width="200">
 
-هذا يعني أن قيمة `y` هي مساوية للقيمة الأولى في الarray, والتي هي عبارة عن نوع رقم يساوي `1`, عندما نقوم بطباعة `y` عن طريق الlog, فإن القيمة `1` هي التي يتم إرجاعها.     
+هذا يعني أن قيمة `y` هي مساوية للقيمة الأولى في الarray, والتي هي عبارة عن نوع رقم يساوي `1`, عندما نقوم بطباعة `y` عن طريق الlog, فإن القيمة `1` هي التي يتم إرجاعها.
+
 </p>
 </details>
 </div>
@@ -1944,7 +1994,8 @@ console.log(admin);
 <div dir='rtl'>
 الجواب هو الخيار الثاني: B
 
-من الممكن دمج الobjects بإستخدام العامل spread `...`. هي تمكنك من إنشاء نسخ من أزواج ال key/value أي أزواج المفاتيح و القيم التي تنتمي الى object معين, و إضافتهم الى object آخر. في هذه الحالة, نحن نقوم بعمل نسخ من الobject `user`, و من ثم إضافتهم الى ال obejct `admin`. ال object `admin` الآن يتضمن نسخ عبارة عن أزواج مفاتيح و قيم, و هذا ما سبب في إعطاء النتيجة `{ admin: true, name: "Lydia", age: 21 }`.  
+من الممكن دمج الobjects بإستخدام العامل spread `...`. هي تمكنك من إنشاء نسخ من أزواج ال key/value أي أزواج المفاتيح و القيم التي تنتمي الى object معين, و إضافتهم الى object آخر. في هذه الحالة, نحن نقوم بعمل نسخ من الobject `user`, و من ثم إضافتهم الى ال obejct `admin`. ال object `admin` الآن يتضمن نسخ عبارة عن أزواج مفاتيح و قيم, و هذا ما سبب في إعطاء النتيجة `{ admin: true, name: "Lydia", age: 21 }`.
+
 </p>
 </details>
 </div>
@@ -1972,9 +2023,10 @@ console.log(Object.keys(person));
 <div dir='rtl'>
 الجواب هو الخيار الثاني: B
 
-مع إستخدام  `defineProperty` method, بإمكاننا إضافة خصائص جديدة لobject معين,أو تعديل خصائصه الحالية,. عندما نقوم بإضافة خاصية لobject بإستخدام `defineProperty` method, ف هي بطبيعة الحال ليست enumerable. ال `Object.keys` method تقوم بإرجاع جميع أسامي الخصائص من object معين و التي هي جميعها enumerable, في هذه الحالة `"name"` فقط.       
+مع إستخدام `defineProperty` method, بإمكاننا إضافة خصائص جديدة لobject معين,أو تعديل خصائصه الحالية,. عندما نقوم بإضافة خاصية لobject بإستخدام `defineProperty` method, ف هي بطبيعة الحال ليست enumerable. ال `Object.keys` method تقوم بإرجاع جميع أسامي الخصائص من object معين و التي هي جميعها enumerable, في هذه الحالة `"name"` فقط.
+
+الخصائص التي تم إضافتها بإستخدام `defineProperty` method هي بطبيعة الحال غير قابلة للتغيير أو التعديل. بإمكانك عمل override بإستخدام الخصائص `writable`, `configurable` و `enumerable`. بهذه الطريقة, ال `defineProperty` method ستعطيك تحكم أكثر بكثير على الخصائص التي قمت بإضافتها الى object معين.
 
-الخصائص التي تم إضافتها بإستخدام `defineProperty` method هي بطبيعة الحال غير قابلة للتغيير أو التعديل. بإمكانك عمل override بإستخدام الخصائص `writable`, `configurable` و `enumerable`.  بهذه الطريقة, ال `defineProperty` method ستعطيك تحكم أكثر بكثير على الخصائص التي قمت بإضافتها الى object معين.  
 </p>
 </details>
 </div>
@@ -1987,7 +2039,7 @@ console.log(Object.keys(person));
 const settings = {
   username: "lydiahallie",
   level: 19,
-  health: 90
+  health: 90,
 };
 
 const data = JSON.stringify(settings, ["level", "health"]);
@@ -2004,11 +2056,12 @@ console.log(data);
 <div dir='rtl'>
 الجواب هو الخيار الأول : A
 
-ال argument الثاني من `JSON.stringify` هو replacer أي حالٍ محل شيء آخر, الreplacer إما أن يكون دالة أو يكون array, و سيمكنك من التحكم في كيفية و ماهية امكانية عمل stringified للقيم, أي تحويلها الى string.   
+ال argument الثاني من `JSON.stringify` هو replacer أي حالٍ محل شيء آخر, الreplacer إما أن يكون دالة أو يكون array, و سيمكنك من التحكم في كيفية و ماهية امكانية عمل stringified للقيم, أي تحويلها الى string.
 
-إذا كان الreplacer هو عبارة عن array, فإن الخصائص التي أساميها مضمنة في الarray هي فقط التي يمكن إضافتها الى ال JSON string. في هذه الحالة, الخصائص التي تحمل الأسامي `"level"` و `"health"` فقط هي المضمنة, `"username"` غير مضمنة. `data` الآن تساوي `"{"level":19, "health":90}"`.   
+إذا كان الreplacer هو عبارة عن array, فإن الخصائص التي أساميها مضمنة في الarray هي فقط التي يمكن إضافتها الى ال JSON string. في هذه الحالة, الخصائص التي تحمل الأسامي `"level"` و `"health"` فقط هي المضمنة, `"username"` غير مضمنة. `data` الآن تساوي `"{"level":19, "health":90}"`.
+
+إذا كان الreplacer عبارة عن دالة, فإن هذه الدالة يتم مناداتها عند أي خاصية في الobject أنت تقوم بعمل stringifying لها.القيمة المرجعة من هذه الدالة ستكون قيمة الخاصية عندما تم إضافتها ل JSON string. إذا كانت القيمة `undefined`, فإن هذه الخاصية سيتم إستبعادها من الJSON string.
 
-إذا كان الreplacer عبارة عن دالة, فإن هذه الدالة يتم مناداتها عند أي خاصية في الobject أنت تقوم بعمل stringifying لها.القيمة المرجعة من هذه الدالة ستكون قيمة الخاصية عندما تم إضافتها ل JSON string. إذا كانت القيمة `undefined`, فإن هذه الخاصية سيتم إستبعادها من الJSON string.  
 </p>
 </details>
 </div>
@@ -2021,7 +2074,7 @@ console.log(data);
 let num = 10;
 
 const increaseNumber = () => num++;
-const increasePassedNumber = number => number++;
+const increasePassedNumber = (number) => number++;
 
 const num1 = increaseNumber();
 const num2 = increasePassedNumber(num1);
@@ -2040,9 +2093,10 @@ console.log(num2);
 <div dir='rtl'>
 الجواب هو الخيار الأول : A
 
-العامل الأحادي `++` يقوم أولا بإرجاع قيمة المعامل, ثم يقوم بزيادة قيمة هذا المعامل. قيمة `num1` تساوي `10`, و بما أن دالة `increaseNumber` أولا تقوم بإرجاع قيمة `num` و التي هي تساوي `10`, و تقوم بزيادة قيمة `num` لاحقاً فقط.       
+العامل الأحادي `++` يقوم أولا بإرجاع قيمة المعامل, ثم يقوم بزيادة قيمة هذا المعامل. قيمة `num1` تساوي `10`, و بما أن دالة `increaseNumber` أولا تقوم بإرجاع قيمة `num` و التي هي تساوي `10`, و تقوم بزيادة قيمة `num` لاحقاً فقط.
+
+`num2` تساوي`10`, وبما أننا نقوم بتمرير `num1` ل `increasePassedNumber`. فإن `number` تساوي `10` والتي هي قيمة`num1`. مجدداً, العامل الأحادي `++`, أولاً يقوم بإرجاع قيمة المعامل, و من ثم زيادة قيمة المعامل. قيمة `number` تساوي`10`, إذاً `num2` تساوي `10`.
 
-`num2` تساوي`10`, وبما أننا نقوم بتمرير `num1` ل `increasePassedNumber`. فإن `number` تساوي `10` والتي هي قيمة`num1`. مجدداً, العامل الأحادي `++`, أولاً يقوم بإرجاع قيمة المعامل, و من ثم زيادة قيمة المعامل. قيمة `number` تساوي`10`, إذاً `num2` تساوي `10`.         
 </p>
 </details>
 </div>
diff --git a/bs-BS/README-bs_BS.md b/bs-BS/README-bs_BS.md
index 65ee11f7..2ff41568 100644
--- a/bs-BS/README-bs_BS.md
+++ b/bs-BS/README-bs_BS.md
@@ -1,8 +1,9 @@
 # Popis (naprednih) JavaScript pitanja
+
 =======================================
 
 Svakodnevno postavljam JavaScript pitanja s višestrukim izborom na moj
-[Instagram](https://www.instagram.com/theavocoder), koja  također objavljujem
+[Instagram](https://www.instagram.com/theavocoder), koja također objavljujem
 ovdje!
 
 Od osnovnog do naprednog: testirajte koliko dobro znate JavaScript, osvježite svoj
@@ -25,6 +26,7 @@ kliknite na njih da biste ih proširili. Sretno :heart:
 - [🇳🇱 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)
@@ -34,7 +36,7 @@ kliknite na njih da biste ih proširili. Sretno :heart:
 - [🇨🇳 简体中文](../zh-CN/README-zh_CN.md)
 - [🇹🇼 繁體中文](../zh-TW/README_zh-TW.md)
 
-* * * * *
+---
 
 ###### 1. Što je izlaz?
 
@@ -75,7 +77,7 @@ JavaScript izbacuje `ReferenceError`.
 </p>
 </details>
 
-* * * * *
+---
 
 ###### 2. Što je izlaz?
 
@@ -99,7 +101,7 @@ for (let i = 0; i < 3; i++) {
 #### Odgovor: C
 
 Zbog reda događaja u JavaScriptu, povratni poziv `setTimeout`
-function se zove * nakon što je izvršena petlja. Od
+function se zove \* nakon što je izvršena petlja. Od
 varijabla `i` u prvoj petlji je deklarirana pomoću ključne riječi` var`,
 ta je vrijednost bila globalna. Tijekom petlje povećavamo vrijednost `i`
 svaki put '1', koristeći unarni operator `++`. Do vremena
@@ -114,7 +116,7 @@ block-scoped (blok je sve između `{}`). Tijekom svake iteracije,
 </p>
 </details>
 
-* * * * *
+---
 
 ###### 3. Što je izlaz?
 
@@ -124,7 +126,7 @@ const shape = {
   diameter() {
     return this.radius * 2;
   },
-  perimeter: () => 2 * Math.PI * this.radius
+  perimeter: () => 2 * Math.PI * this.radius,
 };
 
 shape.diameter();
@@ -154,7 +156,7 @@ Na tom objektu nema vrijednosti `radius` koja vraća` undefined`.
 </p>
 </details>
 
-* * * * *
+---
 
 ###### 4. Što je izlaz?
 
@@ -181,18 +183,18 @@ Niz '' Lydia '' je istinita vrijednost. Ono što zapravo tražimo jest
 </p>
 </details>
 
-* * * * *
+---
 
 ###### 5. Koja je istina?
 
 ```javascript
 const bird = {
-  size: "small"
+  size: "small",
 };
 
 const mouse = {
   name: "Mickey",
-  small: true
+  small: true,
 };
 ```
 
@@ -207,7 +209,7 @@ const mouse = {
 #### Odgovor: A
 
 U JavaScriptu su svi key-evi objekta stringovi (osim ako to nije simbol). Čak
-iako ih možda ne * upisujemo kao * nizove, oni se uvijek pretvaraju
+iako ih možda ne _ upisujemo kao _ nizove, oni se uvijek pretvaraju
 u String ispod "haube".
 
 JavaScript tumači (ili odlaže) izjave. Kada koristimo zagradu
@@ -228,8 +230,7 @@ To nije valjano, a bit će u pitanju pogreška slična onoj
 </p>
 </details>
 
-* * * * *
-
+---
 
 ###### 6. Što je izlaz?
 
@@ -253,7 +254,7 @@ console.log(d.greeting);
 
 #### Odgovor: A
 
-U JavaScriptu, svi objekti međusobno djeluju *referencom* kada ih postavljaju
+U JavaScriptu, svi objekti međusobno djeluju _referencom_ kada ih postavljaju
 jednaki.
 
 Prvo, varijabla `c` sadrži vrijednost objekta. Kasnije dodijelimo `d`
@@ -266,7 +267,7 @@ Kada promijenite jedan objekt, mijenjate ih sve.
 </p>
 </details>
 
-* * * * *
+---
 
 ###### 7. Što je izlaz?
 
@@ -280,10 +281,10 @@ console.log(a === b);
 console.log(b === c);
 ```
 
-- A: `true`` false` `true`
-- B: `false`` false` `true`
-- C: `true`` false` `false`
-- D: `false`` true` `true`
+- A: ` true`` false ` `true`
+- B: ` false`` false ` `true`
+- C: ` true`` false ` `false`
+- D: ` false`` true ` `true`
 
 <details> <summary> <b> Odgovor </b> </summary>
 </p>
@@ -295,16 +296,16 @@ kao broj, to zapravo nije broj: ima gomilu ekstra dodataka
 pa je zbog toga objekt.
 
 Kada koristimo `==` operator, on samo provjerava ima li isti
-*vrijednost*. Obje imaju vrijednost `3`, pa se vraća 'true'.
+_vrijednost_. Obje imaju vrijednost `3`, pa se vraća 'true'.
 
-Međutim, kada koristimo `===` operator, obje vrijednosti * i * trebaju biti
+Međutim, kada koristimo `===` operator, obje vrijednosti _ i _ trebaju biti
 iste. To nije: `new Number ()` nije broj, to je ** objekt **.
 Oba vraćaju "false"
 
 </p>
 </details>
 
-* * * * *
+---
 
 ###### 8. Što je izlaz?
 
@@ -335,7 +336,7 @@ freddie.colorChange("orange");
 #### Odgovor: D
 
 function `colorChange` je statična. Namijenjene su statičkim metodama
-žive samo na konstruktoru u kojem su stvoreni i ne mogu biti proslijeđeni 
+žive samo na konstruktoru u kojem su stvoreni i ne mogu biti proslijeđeni
 bilo kojem childu. Budući da je `freddie` child, function je
 nije proslijeđena, i nije dostupan na `freddie` instanci: a
 Izbačen je `TypeError`.
@@ -343,7 +344,7 @@ Izbačen je `TypeError`.
 </p>
 </details>
 
-* * * * *
+---
 
 ###### 9. Što je izlaz?
 
@@ -351,7 +352,6 @@ Izbačen je `TypeError`.
 let greeting;
 greetign = {}; // Typo!
 console.log(greetign);
-
 ```
 
 - A: `{}`
@@ -374,7 +374,7 @@ da ste deklarirali varijablu prije nego je postavite na bilo što.
 </p>
 </details>
 
-* * * * *
+---
 
 ###### 10. Što se događa kada učinimo ovo?
 
@@ -406,7 +406,7 @@ Ova nekretnina je nepovratna.
 </p>
 </details>
 
-* * * * *
+---
 
 ###### 11. Kakav je rezultat?
 
@@ -417,7 +417,7 @@ function Person(firstName, lastName) {
 }
 
 const member = new Person("Lydia", "Hallie");
-Person.getFullName = function() {
+Person.getFullName = function () {
   return `${this.firstName} ${this.lastName}`;
 };
 
@@ -427,7 +427,7 @@ console.log(member.getFullName());
 - A: `TypeError`
 - B: `SyntaxError`
 - C: "Lydia Hallie"
-- D: `undefined`` undefined`
+- D: ` undefined`` undefined `
 
 <details> <summary> <b> Odgovor </b> </summary>
 </p>
@@ -454,7 +454,7 @@ scopa za svaku instancu. Umjesto toga, ako ga samo dodamo prototipu, mi
 </p>
 </details>
 
-* * * * *
+---
 
 ###### 12. Što je izlaz?
 
@@ -473,10 +473,10 @@ console.log(sarah);
 
 - A: `Person {ime:" Lydia ", prezime:" Hallie "} i` undefined`
 - B: `Person {ime:" Lydia ", prezime:" Hallie "} i
-    `Person {ime:" Sarah ", prezime:" Smith "}`
+  `Person {ime:" Sarah ", prezime:" Smith "}`
 - C: `Person {ime:" Lydia ", prezime:" Hallie "}` i `{}`
 - D: `Person {ime:" Lydia ", prezime:" Hallie "} i
-    `ReferenceError`
+  `ReferenceError`
 
 <details> <summary> <b> Odgovor </b> </summary>
 </p>
@@ -495,7 +495,7 @@ sam je ostavljen 'undefined'.
 </p>
 </details>
 
-* * * * *
+---
 
 ###### 13. Koje su tri faze propagiranja događaja?
 
@@ -504,7 +504,6 @@ sam je ostavljen 'undefined'.
 - C: Target > Bubbling > Capturing
 - D: Capturing > Target > Bubbling
 
-
 <details> <summary> <b> Odgovor </b> </summary>
 </p>
 
@@ -519,11 +518,11 @@ i ** bubbling **.
 </p>
 </details>
 
-* * * * *
+---
 
 ###### 14. Svi objekti imaju prototipove.
 
--   Istinito
+- Istinito
 - B: lažno
 
 <details> <summary> <b> Odgovor </b> </summary>
@@ -541,7 +540,7 @@ nalazi ga tamo, što ga čini dostupnim.
 </p>
 </details>
 
-* * * * *
+---
 
 ###### 15. Što je izlaz?
 
@@ -565,20 +564,20 @@ sum(1, "2");
 
 JavaScript je ** dinamički upisani jezik **: ne navodimo što
 vrste su određene varijable. Vrijednosti se mogu automatski pretvoriti u
-drugi tip bez vašeg znanja, koji se zove * implicitni tip
-prisila *. ** Prisila ** pretvara iz jednog tipa u drugi.
+drugi tip bez vašeg znanja, koji se zove _ implicitni tip
+prisila _. ** Prisila ** pretvara iz jednog tipa u drugi.
 
 U ovom primjeru JavaScript pretvara broj `1` u niz, u
 kako bi function imala smisla i vratila vrijednost. Tijekom
 dodavanje numeričkog tipa (`1`) i tipa niza (` '2'`), broja
 se tretira kao niz. Možemo slično spojiti
-"" Zdravo "+" Svijet "`, tako da se ovdje događa ``````````````````
-vraća `" 12 "`.
+"" Zdravo "+" Svijet "` , tako da se ovdje događa ``````````````````
+vraća  `" 12 "`.
 
 </p>
 </details>
 
-* * * * *
+---
 
 ###### 16. Što je izlaz?
 
@@ -589,10 +588,10 @@ console.log(++number);
 console.log(number);
 ```
 
-- A: `1`` 1` `2`
-- B: `1`` 2` `2`
-- C: `0`` 2` `2`
-- D: `0`` 1` `2`
+- A: ` 1`` 1 ` `2`
+- B: ` 1`` 2 ` `2`
+- C: ` 0`` 2 ` `2`
+- D: ` 0`` 1 ` `2`
 
 <details> <summary> <b> Odgovor </b> </summary>
 </p>
@@ -614,7 +613,7 @@ Ovo vraća `0 2 2`.
 </p>
 </details>
 
-* * * * *
+---
 
 ###### 17. Što je izlaz?
 
@@ -647,7 +646,7 @@ vrijednosti prošlih izraza!
 </p>
 </details>
 
-* * * * *
+---
 
 ###### 18. Što je izlaz?
 
@@ -674,8 +673,8 @@ checkAge({ age: 18 });
 
 #### Odgovor: C
 
-Prilikom ispitivanja jednakosti, primitivi se uspoređuju prema njihovoj * vrijednosti *, dok
-objekti se uspoređuju prema njihovoj * referenci *. JavaScript provjerava ako
+Prilikom ispitivanja jednakosti, primitivi se uspoređuju prema njihovoj _ vrijednosti _, dok
+objekti se uspoređuju prema njihovoj _ referenci _. JavaScript provjerava ako
 objekti imaju referencu na isto mjesto u memoriji.
 
 Dva predmeta koje uspoređujemo nemaju: objekt mi
@@ -688,12 +687,11 @@ Zato i `{age: 18} === {age: 18}` i
 </p>
 </details>
 
-* * * * *
+---
 
 ###### 19. Što je izlaz?
 
 ```javascript
-
 function getAge(...args) {
   console.log(typeof args);
 }
@@ -717,7 +715,7 @@ array je objekt, pa `typeof args` vraća` `objekt '`
 </p>
 </details>
 
-* * * * *
+---
 
 ###### 20. Što je izlaz?
 
@@ -741,16 +739,16 @@ getAge();
 
 #### Odgovor: C
 
-Sa `` use strict '', možete se uvjeriti da nije slučajno
+Sa `use strict '', možete se uvjeriti da nije slučajno
 deklarisana globalna varijabla. Nikada nismo objavili varijablu "age" i
-budući da koristimo `` use strict '', ona će načiniti referentnu pogrešku. Ako mi
+budući da koristimo` use strict '', ona će načiniti referentnu pogrešku. Ako mi
 nije koristio "" strict ", to bi išlo od vlasništva
 `age` bi se dodao u globalni objekt.
 
 </p>
 </details>
 
-* * * * *
+---
 
 ###### 21. Što je vrijednost `suma '?
 
@@ -775,15 +773,16 @@ kao u ovom slučaju, on ocjenjuje izraz. Izraz je
 </p>
 </details>
 
-* * * * *
+---
 
-###### 22. Koliko dugo je cool \ _secret dostupan?
+###### 22. Koliko dugo je cool \ \_secret dostupan?
 
 ```javascript
 sessionStorage.setItem("cool_secret", 123);
 ```
 
 O: Podaci se zauvijek ne gube.
+
 - B: Kada korisnik zatvori karticu.
 - C: Kada korisnik zatvori cijeli preglednik, ne samo karticu.
 - D: Kada korisnik isključi svoje računalo.
@@ -793,7 +792,7 @@ O: Podaci se zauvijek ne gube.
 
 #### Odgovor: B
 
-Podaci spremljeni u `sessionStorage` se uklanjaju nakon zatvaranja * tab *.
+Podaci spremljeni u `sessionStorage` se uklanjaju nakon zatvaranja _ tab _.
 
 Ako ste koristili `localStorage`, podaci bi bili tamo zauvijek, osim ako
 na primjer, `localStorage.clear ()` je pozvan.
@@ -801,7 +800,7 @@ na primjer, `localStorage.clear ()` je pozvan.
 </p>
 </details>
 
-* * * * *
+---
 
 ###### 23. Što je izlaz?
 
@@ -830,7 +829,7 @@ To ne možete učiniti s `let` ili` const` jer su blokirani.
 </p>
 </details>
 
-* * * * *
+---
 
 ###### 24. Što je izlaz?
 
@@ -844,10 +843,10 @@ 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`
+- A: ` false`` true ` ` false`` true `
+- B: ` false`` true ` ` true`` true `
+- C: ` true`` true ` ` false`` true `
+- D: ` true`` true ` ` true`` true `
 
 <details> <summary> <b> Odgovor </b> </summary>
 </p>
@@ -865,7 +864,7 @@ To ne radi tako za skup. U našem setu ne postoji "1":
 </p>
 </details>
 
-* * * * *
+---
 
 ###### 25. Što je izlaz?
 
@@ -890,11 +889,11 @@ i dalje će biti na prvom mjestu, ali s posljednjom navedenom vrijednošću.
 </p>
 </details>
 
-* * * * *
+---
 
 ###### 26. Globalni kontekst izvođenja JavaScripta za vas stvara dvije stvari: globalni objekt i "ovu" ključnu riječ.
 
--   Istina
+- Istina
 - B: lažno
 - C: to ovisi
 
@@ -909,7 +908,7 @@ dostupno svugdje u vašem kodu.
 </p>
 </details>
 
-* * * * *
+---
 
 ###### 27. Što je izlaz?
 
@@ -918,13 +917,12 @@ 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`
+- A: ` 1`` 2 `
+- B: ` 1`` 2 ` `3`
+- C: ` 1`` 2 ` `4`
+- D: ` 1`` 3 ` `4`
 
 <details> <summary> <b> Odgovor </b> </summary>
 </p>
@@ -937,7 +935,7 @@ vraća "true".
 </p>
 </details>
 
-* * * * *
+---
 
 ###### 28. Što je izlaz?
 
@@ -948,10 +946,10 @@ String.prototype.giveLydiaPizza = () => {
 
 const name = "Lydia";
 
-console.log(name.giveLydiaPizza())
+console.log(name.giveLydiaPizza());
 ```
 
-- A: `` Već daj Lizijinu pizzu! ``
+- A: `Već daj Lizijinu pizzu!`
 - B: `TypeError: nije function`
 - C: `SyntaxError`
 - D: `undefined`
@@ -970,7 +968,7 @@ način!
 </p>
 </details>
 
-* * * * *
+---
 
 ###### 29. Što je izlaz?
 
@@ -1009,7 +1007,7 @@ da na `456`, tako da se vraća` 456`.
 </p>
 </details>
 
-* * * * *
+---
 
 ###### 30. Što je izlaz?
 
@@ -1023,10 +1021,10 @@ foo();
 baz();
 ```
 
-- A: `Prvi`` Drugi` `Treći`
-- B: `Prvi`` Treći` `Drugi`
-- C: `Drugi`` Prvi` `Treći`
-- D: `Drugi`` Treći` `Prvi`
+- A: ` Prvi`` Drugi ` `Treći`
+- B: ` Prvi`` Treći ` `Drugi`
+- C: ` Drugi`` Prvi ` `Treći`
+- D: ` Drugi`` Treći ` `Prvi`
 
 <details> <summary> <b> Odgovor </b> </summary>
 </p>
@@ -1040,7 +1038,7 @@ To je zato što u preglednicima nemamo samo runtime engine, mi
 također imaju nešto što se zove "WebAPI". "WebAPI" nam daje
 `setTimeout` function za početak, i na primjer DOM.
 
-Nakon što je * callback * preusmjeren na WebAPI, function `setTimeout`
+Nakon što je _ callback _ preusmjeren na WebAPI, function `setTimeout`
 sam (ali ne i povratni poziv!) iskače iz stog.
 
 <img src = "https://i.imgur.com/X5wsHOg.png" width = "200">
@@ -1056,11 +1054,11 @@ prijavljeni.
 
 WebAPI ne može jednostavno dodati stvari u stog kad god je spreman.
 Umjesto toga, on povlači funkciju povratnog poziva u nešto što se zove
-*red*.
+_red_.
 
 <img src = "https://i.imgur.com/NSnDZmU.png" width = "200">
 
-Ovo je mjesto gdje petlja događaja počinje raditi. ** ** krug događaja ** gleda
+Ovo je mjesto gdje petlja događaja počinje raditi. \*\* ** krug događaja ** gleda
 red i red za zadatke. Ako je stog prazan, uzima prvi
 stvar u redu i gura je u stog.
 
@@ -1072,7 +1070,7 @@ stog.
 </p>
 </details>
 
-* * * * *
+---
 
 ###### 31. Što je event.target kada kliknete na gumb?
 
@@ -1104,7 +1102,7 @@ događaj. Možete zaustaviti mjehuriće 'event.stopPropagation'
 </p>
 </details>
 
-* * * * *
+---
 
 ###### 32. Kada kliknete na paragraf, što je zapisani izlaz?
 
@@ -1116,8 +1114,8 @@ događaj. Možete zaustaviti mjehuriće 'event.stopPropagation'
 </div>
 ```
 
-- A: `p`` div`
-- B: `div`` p`
+- A: ` p`` div `
+- B: ` div`` p `
 - C: p
 - D: "div"
 
@@ -1135,7 +1133,7 @@ van.
 </p>
 </details>
 
-* * * * *
+---
 
 ###### 33. Što je izlaz?
 
@@ -1150,10 +1148,10 @@ sayHi.call(person, 21);
 sayHi.bind(person, 21);
 ```
 
-- A: `undefined is 21`` Lydia je 21`
+- A: ` undefined is 21`` Lydia je 21 `
 - B: function funkcije
-- C: `Lydia je 21`` Lydia je 21`
-- D: `Lydia je 21`` function`
+- C: ` Lydia je 21`` Lydia je 21 `
+- D: ` Lydia je 21`` function `
 
 <details> <summary> <b> Odgovor </b> </summary>
 </p>
@@ -1161,15 +1159,15 @@ sayHi.bind(person, 21);
 #### Odgovor: D
 
 S oba, možemo proslijediti objekt kojem želimo ključnu riječ "this"
-odnosi se na. Međutim, `.call` se također * izvršava odmah *!
+odnosi se na. Međutim, `.call` se također _ izvršava odmah _!
 
-`.bind.` vraća * copy * funkcije, ali s vezanim kontekstom! To
+`.bind.` vraća _ copy _ funkcije, ali s vezanim kontekstom! To
 se ne izvršava odmah.
 
 </p>
 </details>
 
-* * * * *
+---
 
 ###### 34. Što je izlaz?
 
@@ -1196,13 +1194,13 @@ pozvana function (IIFE). Ova function vratila je `0`, što je tip
 ` "Broj"`.
 
 FYI: postoji samo 7 ugrađenih tipova: `null`,` undefined`, `boolean`,
-"broj", "niz", "objekt" i "simbol". `` function '' nije tip,
-budući da su funkcije objekti, to je tipa `` objekta '`.
+"broj", "niz", "objekt" i "simbol". `function '' nije tip,
+budući da su funkcije objekti, to je tipa` objekta '`.
 
 </p>
 </details>
 
-* * * * *
+---
 
 ###### 35. Koja od ovih vrijednosti su neistinite?
 
@@ -1216,8 +1214,8 @@ undefined;
 ```
 
 - A: `0`,` ```,` undefined`
-- B: `0`,` new Number (0) `,` '' `,` new Boolean (false) `,` undefined '
-- C: `0`,` '' `,` new Boolean (false) `,` undefined`
+- B: `0`,`new Number (0)`,`''`,`new Boolean (false)`,` undefined '
+- C: `0`,`''`,`new Boolean (false)`,` undefined`
 - D: Svi su oni lažni
 
 <details> <summary> <b> Odgovor </b> </summary>
@@ -1239,13 +1237,12 @@ Konstruktori function, kao što su 'new Number' i 'new Boolean' su istiniti.
 </p>
 </details>
 
-* * * * *
+---
 
 ###### 36. Što je izlaz?
 
 ```javascript
 console.log(typeof typeof 1);
-
 ```
 
 - A: `" broj "
@@ -1263,7 +1260,7 @@ console.log(typeof typeof 1);
 </p>
 </details>
 
-* * * * *
+---
 
 ###### 37. Što je izlaz?
 
@@ -1295,7 +1292,7 @@ itd)
 </p>
 </details>
 
-* * * * *
+---
 
 ###### 38. Što je izlaz?
 
@@ -1313,10 +1310,10 @@ itd)
 })();
 ```
 
-- A: `1`` undefined `` 2`
-- B: `undefined`` undefined` `undefined`
-- C: `1`` 1` `2`
-- D: `1`` undefined` `undefined`
+- A: ` 1`` undefined `` 2 `
+- B: ` undefined`` undefined ` `undefined`
+- C: ` 1`` 1 ` `2`
+- D: ` 1`` undefined ` `undefined`
 
 <details> <summary> <b> Odgovor </b> </summary>
 </p>
@@ -1331,13 +1328,13 @@ varijable `y '. Sada, zapisujemo blok-scoped varijablu `x`, koja je
 jednako "1".
 
 Izvan 'catch' bloka, `x 'je i dalje` undefined`, a `y` je` 2`.
-Kada želimo `console.log (x)` izvan `catch` bloka, to
-vraća `undefined` i` y` vraća `2`.
+Kada želimo `console.log (x)`izvan`catch`bloka, to
+vraća`undefined` i` y`vraća`2`.
 
 </p>
 </details>
 
-* * * * *
+---
 
 ###### 39. Sve u JavaScriptu je ili ...
 
@@ -1358,8 +1355,7 @@ Primitivni tipovi su "boolean", "null", "undefined", "bigint", "number",
 
 Ono što razlikuje primitiv od objekta je to što primitivci to ne čine
 imaju bilo kakva svojstva ili metode; međutim, to ćete primijetiti
-`'foo'.toUpperCase ()` vrednuje za' 'FOO'` i ne rezultira a
-`TypeError`. To je zato što kada pokušate pristupiti svojstvu ili metodi
+`'foo'.toUpperCase ()` vrednuje za' 'FOO'`i ne rezultira a`TypeError`. To je zato što kada pokušate pristupiti svojstvu ili metodi
 na primitivnom poput stringa, JavaScript će implicitet omotati objekt
 koristeći jednu od klasa omotača, tj. `String ', a zatim odmah
 odbacite omotač nakon što se izraz procijeni. Svi primitivci
@@ -1368,12 +1364,15 @@ osim "null" i "undefined" pokazuju ovo ponašanje.
 </p>
 </details>
 
-* * * * *
+---
 
 ###### 40. Što je izlaz?
 
 ```javascript
-[[0, 1], [2, 3]].reduce(
+[
+  [0, 1],
+  [2, 3],
+].reduce(
   (acc, cur) => {
     return acc.concat(cur);
   },
@@ -1393,7 +1392,7 @@ osim "null" i "undefined" pokazuju ovo ponašanje.
 
 "[1, 2]" je naša početna vrijednost. To je vrijednost s kojom počinjemo i
 vrijednost prvog `acc`. Tijekom prvog kruga, "acc" je "[1,2]",
-i `cur` je` [0, 1] `. Spojimo ih, što rezultira
+i `cur` je`[0, 1]`. Spojimo ih, što rezultira
 `[1, 2, 0, 1]`.
 
 Tada je `[1, 2, 0, 1]` `acc` i` [2, 3] `````. Ulančavamo se
@@ -1402,7 +1401,7 @@ i dobiti `[1, 2, 0, 1, 2, 3]`
 </p>
 </details>
 
-* * * * *
+---
 
 ###### 41. Što je izlaz?
 
@@ -1412,10 +1411,10 @@ i dobiti `[1, 2, 0, 1, 2, 3]`
 !!1;
 ```
 
-- A: `false`` true` `false`
-- B: `false`` false` `true`
-- C: `false`` true` `true`
-- D: `true`` true` `false`
+- A: ` false`` true ` `false`
+- B: ` false`` false ` `true`
+- C: ` false`` true ` `true`
+- D: ` true`` true ` `false`
 
 <details> <summary> <b> Odgovor </b> </summary>
 </p>
@@ -1431,7 +1430,7 @@ i dobiti `[1, 2, 0, 1, 2, 3]`
 </p>
 </details>
 
-* * * * *
+---
 
 ###### 42. Što se vraća metoda `setInterval`?
 
@@ -1455,7 +1454,7 @@ Vraća jedinstveni ID. Taj se ID može koristiti za brisanje tog intervala
 </p>
 </details>
 
-* * * * *
+---
 
 ###### 43. Što se to vraća?
 
diff --git a/de-DE/README.md b/de-DE/README.md
index 10145050..a9dbd381 100644
--- a/de-DE/README.md
+++ b/de-DE/README.md
@@ -10,10 +10,11 @@ Von einfach bis fortgeschritten: teste, wie gut du JavaScript kennst, frische de
 
 Kontaktiert mich, wenn ihr möchtet! 😊 <br />
 <a href="https://www.instagram.com/theavocoder">Instagram</a> || <a href="https://www.twitter.com/lydiahallie">Twitter</a> || <a href="https://www.linkedin.com/in/lydia-hallie">LinkedIn</a> || <a href="https://www.lydiahallie.dev">Blog</a>
+
 </div>
 
-| Benutzt die Fragen und Lösungen in einem Projekt! 😃  Ich würde mich _sehr_ freuen, wenn ihr dieses Repo verlinkt. Ich erstelle die Fragen und antworten (ja, ich bin traurig, lol) und die Community hilft mir unglaublich dabei, das ganze zu pflegen und verbessern! 💪🏼 Danke und habt Spaß!   |
-|---|
+| Benutzt die Fragen und Lösungen in einem Projekt! 😃 Ich würde mich _sehr_ freuen, wenn ihr dieses Repo verlinkt. Ich erstelle die Fragen und antworten (ja, ich bin traurig, lol) und die Community hilft mir unglaublich dabei, das ganze zu pflegen und verbessern! 💪🏼 Danke und habt Spaß! |
+| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 
 </div>
 
@@ -35,6 +36,7 @@ Kontaktiert mich, wenn ihr möchtet! 😊 <br />
 - [🇳🇱 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)
@@ -53,19 +55,19 @@ Kontaktiert mich, wenn ihr möchtet! 😊 <br />
 
 ```javascript
 function sayHi() {
-	console.log(name);
-	console.log(age);
-	var name = "Lydia";
-	let age = 21;
+  console.log(name);
+  console.log(age);
+  var name = "Lydia";
+  let age = 21;
 }
 
 sayHi();
 ```
 
--   A: `Lydia` und `undefined`
--   B: `Lydia` und `ReferenceError`
--   C: `ReferenceError` und `21`
--   D: `undefined` und `ReferenceError`
+- A: `Lydia` und `undefined`
+- B: `Lydia` und `ReferenceError`
+- C: `ReferenceError` und `21`
+- D: `undefined` und `ReferenceError`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -85,17 +87,17 @@ Variablen mit dem `let` (oder `const`) Keyword werden ebenfalls gehoisted, aber
 
 ```javascript
 for (var i = 0; i < 3; i++) {
-	setTimeout(() => console.log(i), 1);
+  setTimeout(() => console.log(i), 1);
 }
 
 for (let i = 0; i < 3; i++) {
-	setTimeout(() => console.log(i), 1);
+  setTimeout(() => console.log(i), 1);
 }
 ```
 
--   A: `0 1 2` und `0 1 2`
--   B: `0 1 2` und `3 3 3`
--   C: `3 3 3` und `0 1 2`
+- A: `0 1 2` und `0 1 2`
+- B: `0 1 2` und `3 3 3`
+- C: `3 3 3` und `0 1 2`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -115,21 +117,21 @@ In der zweiten Schleife wurde die Variable `i` mit dem `let` Keyword definiert:
 
 ```javascript
 const shape = {
-	radius: 10,
-	diameter() {
-		return this.radius * 2;
-	},
-	perimeter: () => 2 * Math.PI * this.radius,
+  radius: 10,
+  diameter() {
+    return this.radius * 2;
+  },
+  perimeter: () => 2 * Math.PI * this.radius,
 };
 
 shape.diameter();
 shape.perimeter();
 ```
 
--   A: `20` und `62.83185307179586`
--   B: `20` und `NaN`
--   C: `20` und `63`
--   D: `NaN` und `63`
+- A: `20` und `62.83185307179586`
+- B: `20` und `NaN`
+- C: `20` und `63`
+- D: `NaN` und `63`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -154,9 +156,9 @@ Es gibt keinen Wert `radius` in dem Object, daher wird `undefined` zurückgegebe
 !"Lydia";
 ```
 
--   A: `1` und `false`
--   B: `false` und `NaN`
--   C: `false` und `false`
+- A: `1` und `false`
+- B: `false` und `NaN`
+- C: `false` und `false`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -176,19 +178,19 @@ Der String `'Lydia'` ist truthy. Was wir eigentlich fragen ist: "ist dieser trut
 
 ```javascript
 const bird = {
-	size: "small",
+  size: "small",
 };
 
 const mouse = {
-	name: "Mickey",
-	small: true,
+  name: "Mickey",
+  small: true,
 };
 ```
 
--   A: `mouse.bird.size` ist nicht korrekt
--   B: `mouse[bird.size]` ist nicht korrekt
--   C: `mouse[bird["size"]]` ist nicht korrekt
--   D: Keine der Antworten ist korrekt.
+- A: `mouse.bird.size` ist nicht korrekt
+- B: `mouse[bird.size]` ist nicht korrekt
+- C: `mouse[bird["size"]]` ist nicht korrekt
+- D: Keine der Antworten ist korrekt.
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -219,11 +221,11 @@ c.greeting = "Hello";
 console.log(d.greeting);
 ```
 
--   A: `Hello`
--   B: `Hey`
--   C: `undefined`
--   D: `ReferenceError`
--   E: `TypeError`
+- A: `Hello`
+- B: `Hey`
+- C: `undefined`
+- D: `ReferenceError`
+- E: `TypeError`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -255,10 +257,10 @@ console.log(a === b);
 console.log(b === c);
 ```
 
--   A: `true` `false` `true`
--   B: `false` `false` `true`
--   C: `true` `false` `false`
--   D: `false` `true` `true`
+- A: `true` `false` `true`
+- B: `false` `false` `true`
+- C: `true` `false` `false`
+- D: `false` `true` `true`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -280,24 +282,24 @@ Wenn wir aber `===` nutzen müssen sowohl der Wert _als auch_ der Typ übereinst
 
 ```javascript
 class Chameleon {
-	static colorChange(newColor) {
-		this.newColor = newColor;
-		return this.newColor;
-	}
-
-	constructor({ newColor = "green" } = {}) {
-		this.newColor = newColor;
-	}
+  static colorChange(newColor) {
+    this.newColor = newColor;
+    return this.newColor;
+  }
+
+  constructor({ newColor = "green" } = {}) {
+    this.newColor = newColor;
+  }
 }
 
 const freddie = new Chameleon({ newColor: "purple" });
 freddie.colorChange("orange");
 ```
 
--   A: `orange`
--   B: `purple`
--   C: `green`
--   D: `TypeError`
+- A: `orange`
+- B: `purple`
+- C: `green`
+- D: `TypeError`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -319,9 +321,9 @@ greetign = {}; // Typo!
 console.log(greetign);
 ```
 
--   A: `{}`
--   B: `ReferenceError: greetign is not defined`
--   C: `undefined`
+- A: `{}`
+- B: `ReferenceError: greetign is not defined`
+- C: `undefined`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -341,16 +343,16 @@ Um das zu verhindern, können wir `"use strict"` verwenden. Das stellt sicher, d
 
 ```javascript
 function bark() {
-	console.log("Woof!");
+  console.log("Woof!");
 }
 
 bark.animal = "dog";
 ```
 
--   A: Nichts, das ist absolut in Ordnung.
--   B: `SyntaxError`. Man kann einer Funktion keine Properties in der Form zuweisen.
--   C: `undefined`
--   D: `ReferenceError`
+- A: Nichts, das ist absolut in Ordnung.
+- B: `SyntaxError`. Man kann einer Funktion keine Properties in der Form zuweisen.
+- C: `undefined`
+- D: `ReferenceError`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -370,22 +372,22 @@ Eine Funktion ist ein spezieller Typ eines Objekts. Der Code, den wir schreiben
 
 ```javascript
 function Person(firstName, lastName) {
-	this.firstName = firstName;
-	this.lastName = lastName;
+  this.firstName = firstName;
+  this.lastName = lastName;
 }
 
 const member = new Person("Lydia", "Hallie");
-Person.getFullName = function() {
-	return `${this.firstName} ${this.lastName}`;
+Person.getFullName = function () {
+  return `${this.firstName} ${this.lastName}`;
 };
 
 console.log(member.getFullName());
 ```
 
--   A: `TypeError`
--   B: `SyntaxError`
--   C: `Lydia Hallie`
--   D: `undefined` `undefined`
+- A: `TypeError`
+- B: `SyntaxError`
+- C: `Lydia Hallie`
+- D: `undefined` `undefined`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -395,8 +397,8 @@ console.log(member.getFullName());
 Man kann keine Properties einem Constructor zuweisen, wie es bei normalen Objects der Fall ist. Wenn man ein Feature allen Objects zugleich zuweisen möchte, muss man den Prototype verwenden. In diesem Fall also:
 
 ```js
-Person.prototype.getFullName = function() {
-	return `${this.firstName} ${this.lastName}`;
+Person.prototype.getFullName = function () {
+  return `${this.firstName} ${this.lastName}`;
 };
 ```
 
@@ -412,8 +414,8 @@ Stattdessen haben wir sie nur dem Prototype zugewiesen, sodass sie nur an einer
 
 ```javascript
 function Person(firstName, lastName) {
-	this.firstName = firstName;
-	this.lastName = lastName;
+  this.firstName = firstName;
+  this.lastName = lastName;
 }
 
 const lydia = new Person("Lydia", "Hallie");
@@ -423,10 +425,10 @@ console.log(lydia);
 console.log(sarah);
 ```
 
--   A: `Person {firstName: "Lydia", lastName: "Hallie"}` und `undefined`
--   B: `Person {firstName: "Lydia", lastName: "Hallie"}` und `Person {firstName: "Sarah", lastName: "Smith"}`
--   C: `Person {firstName: "Lydia", lastName: "Hallie"}` und `{}`
--   D:`Person {firstName: "Lydia", lastName: "Hallie"}` und `ReferenceError`
+- A: `Person {firstName: "Lydia", lastName: "Hallie"}` und `undefined`
+- B: `Person {firstName: "Lydia", lastName: "Hallie"}` und `Person {firstName: "Sarah", lastName: "Smith"}`
+- C: `Person {firstName: "Lydia", lastName: "Hallie"}` und `{}`
+- D:`Person {firstName: "Lydia", lastName: "Hallie"}` und `ReferenceError`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -444,10 +446,10 @@ Wir haben `this.firstName` den Wert `"Sarah"` zugewiesen und `this.lastName` den
 
 ###### 13. Was sind die drei Phasen der Event Propagation?
 
--   A: Target > Capturing > Bubbling
--   B: Bubbling > Target > Capturing
--   C: Target > Bubbling > Capturing
--   D: Capturing > Target > Bubbling
+- A: Target > Capturing > Bubbling
+- B: Bubbling > Target > Capturing
+- C: Target > Bubbling > Capturing
+- D: Capturing > Target > Bubbling
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -465,8 +467,8 @@ Während der **capturing** Phase geht das Event durch die Elternelemente bis hin
 
 ###### 14. Alle Objekte haben Prototypes.
 
--   A: wahr
--   B: falsch
+- A: wahr
+- B: falsch
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -484,16 +486,16 @@ Alle Objekte haben Prototypes, außer dem **Basis Objekt**. Das Basis Objekt hat
 
 ```javascript
 function sum(a, b) {
-	return a + b;
+  return a + b;
 }
 
 sum(1, "2");
 ```
 
--   A: `NaN`
--   B: `TypeError`
--   C: `"12"`
--   D: `3`
+- A: `NaN`
+- B: `TypeError`
+- C: `"12"`
+- D: `3`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -518,10 +520,10 @@ console.log(++number);
 console.log(number);
 ```
 
--   A: `1` `1` `2`
--   B: `1` `2` `2`
--   C: `0` `2` `2`
--   D: `0` `1` `2`
+- A: `1` `1` `2`
+- B: `1` `2` `2`
+- C: `0` `2` `2`
+- D: `0` `1` `2`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -549,9 +551,9 @@ Der Output ist daher `0 2 2`.
 
 ```javascript
 function getPersonInfo(one, two, three) {
-	console.log(one);
-	console.log(two);
-	console.log(three);
+  console.log(one);
+  console.log(two);
+  console.log(three);
 }
 
 const person = "Lydia";
@@ -560,9 +562,9 @@ 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`
+- A: `"Lydia"` `21` `["", " is ", " years old"]`
+- B: `["", " is ", " years old"]` `"Lydia"` `21`
+- C: `"Lydia"` `["", " is ", " years old"]` `21`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -580,21 +582,21 @@ Wenn man Template Literals verwendet ist das erste Argument immer ein Array der
 
 ```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`);
-	}
+  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`
+- A: `You are an adult!`
+- B: `You are still an adult.`
+- C: `Hmm.. You don't have an age I guess`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -616,16 +618,16 @@ Deshalb werfen sowohl `{ age: 18 } === { age: 18 }` als auch `{ age: 18 } == { a
 
 ```javascript
 function getAge(...args) {
-	console.log(typeof args);
+  console.log(typeof args);
 }
 
 getAge(21);
 ```
 
--   A: `"number"`
--   B: `"array"`
--   C: `"object"`
--   D: `"NaN"`
+- A: `"number"`
+- B: `"array"`
+- C: `"object"`
+- D: `"NaN"`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -643,18 +645,18 @@ Der Spread Operator (`...args`) gibt ein Array mit Argumenten zurück. Ein Array
 
 ```javascript
 function getAge() {
-	"use strict";
-	age = 21;
-	console.log(age);
+  "use strict";
+  age = 21;
+  console.log(age);
 }
 
 getAge();
 ```
 
--   A: `21`
--   B: `undefined`
--   C: `ReferenceError`
--   D: `TypeError`
+- A: `21`
+- B: `undefined`
+- C: `ReferenceError`
+- D: `TypeError`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -674,10 +676,10 @@ Durch `"use strict"` kann man sicher stellen, dass man nicht versehentlich globa
 const sum = eval("10*10+5");
 ```
 
--   A: `105`
--   B: `"105"`
--   C: `TypeError`
--   D: `"10*10+5"`
+- A: `105`
+- B: `"105"`
+- C: `TypeError`
+- D: `"10*10+5"`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -697,10 +699,10 @@ const sum = eval("10*10+5");
 sessionStorage.setItem("cool_secret", 123);
 ```
 
--   A: Für immer, der Wert geht nicht verloren.
--   B: Wenn der User den Tab schließt.
--   C: Wenn der User den Browser schließt, nicht nur den Tab.
--   D: Wenn der User den Computer neu startet.
+- A: Für immer, der Wert geht nicht verloren.
+- B: Wenn der User den Tab schließt.
+- C: Wenn der User den Browser schließt, nicht nur den Tab.
+- D: Wenn der User den Computer neu startet.
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -725,10 +727,10 @@ var num = 10;
 console.log(num);
 ```
 
--   A: `8`
--   B: `10`
--   C: `SyntaxError`
--   D: `ReferenceError`
+- A: `8`
+- B: `10`
+- C: `SyntaxError`
+- D: `ReferenceError`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -756,10 +758,10 @@ 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`
+- A: `false` `true` `false` `true`
+- B: `false` `true` `true` `true`
+- C: `true` `true` `false` `true`
+- D: `true` `true` `true` `true`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -782,10 +784,10 @@ 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`
+- A: `{ a: "one", b: "two" }`
+- B: `{ b: "two", a: "three" }`
+- C: `{ a: "three", b: "two" }`
+- D: `SyntaxError`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -801,9 +803,9 @@ Wenn man zwei Keys mit dem selben Namen hat, wird der erste Key ersetzt. Er wird
 
 ###### 26. Der JavaScript Global Execution Context erstellt zwei Dinge: das globale Objekt und das "this" Keyword.
 
--   A: wahr
--   B: falsch
--   C: kommt darauf an
+- A: wahr
+- B: falsch
+- C: kommt darauf an
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -821,15 +823,15 @@ Der Base Execution Context entspricht dem Global Execution Context und ist über
 
 ```javascript
 for (let i = 1; i < 5; i++) {
-	if (i === 3) continue;
-	console.log(i);
+  if (i === 3) continue;
+  console.log(i);
 }
 ```
 
--   A: `1` `2`
--   B: `1` `2` `3`
--   C: `1` `2` `4`
--   D: `1` `3` `4`
+- A: `1` `2`
+- B: `1` `2` `3`
+- C: `1` `2` `4`
+- D: `1` `3` `4`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -847,18 +849,18 @@ 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";
 
-console.log(name.giveLydiaPizza())
+console.log(name.giveLydiaPizza());
 ```
 
--   A: `"Just give Lydia pizza already!"`
--   B: `TypeError: not a function`
--   C: `SyntaxError`
--   D: `undefined`
+- A: `"Just give Lydia pizza already!"`
+- B: `TypeError: not a function`
+- C: `SyntaxError`
+- D: `undefined`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -885,10 +887,10 @@ a[c] = 456;
 console.log(a[b]);
 ```
 
--   A: `123`
--   B: `456`
--   C: `undefined`
--   D: `ReferenceError`
+- A: `123`
+- B: `456`
+- C: `undefined`
+- D: `ReferenceError`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -918,10 +920,10 @@ foo();
 baz();
 ```
 
--   A: `First` `Second` `Third`
--   B: `First` `Third` `Second`
--   C: `Second` `First` `Third`
--   D: `Second` `Third` `First`
+- A: `First` `Second` `Third`
+- B: `First` `Third` `Second`
+- C: `Second` `First` `Third`
+- D: `Second` `Third` `First`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -963,18 +965,16 @@ Das ist, wo die Event Loop ins Spiel kommt. Die **Event Loop** betrachtet den St
 
 ```html
 <div onclick="console.log('first div')">
-	<div onclick="console.log('second div')">
-		<button onclick="console.log('button')">
-			Click!
-		</button>
-	</div>
+  <div onclick="console.log('second div')">
+    <button onclick="console.log('button')">Click!</button>
+  </div>
 </div>
 ```
 
--   A: Äußerer `div`
--   B: Innerer `div`
--   C: `button`
--   D: Ein Array mit allen genesteten Elementen
+- A: Äußerer `div`
+- B: Innerer `div`
+- C: `button`
+- D: Ein Array mit allen genesteten Elementen
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -992,16 +992,14 @@ Das am tiefsten genestete Element, welches das Event auslöst ist das Event Targ
 
 ```html
 <div onclick="console.log('div')">
-	<p onclick="console.log('p')">
-		Click here!
-	</p>
+  <p onclick="console.log('p')">Click here!</p>
 </div>
 ```
 
--   A: `p` `div`
--   B: `div` `p`
--   C: `p`
--   D: `div`
+- A: `p` `div`
+- B: `div` `p`
+- C: `p`
+- D: `div`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -1021,17 +1019,17 @@ Wenn wir auf den Paragraph klicken, sehen wir zwei logs: `p` und `div`. Während
 const person = { name: "Lydia" };
 
 function sayHi(age) {
-	console.log(`${this.name} is ${age}`);
+  console.log(`${this.name} is ${age}`);
 }
 
 sayHi.call(person, 21);
 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`
+- 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>Antwort</b></summary>
 <p>
@@ -1051,16 +1049,16 @@ In beiden Fällen können wir das Objekt weiter reichen, auf welches sich das `t
 
 ```javascript
 function sayHi() {
-	return (() => 0)();
+  return (() => 0)();
 }
 
 typeof sayHi();
 ```
 
--   A: `"object"`
--   B: `"number"`
--   C: `"function"`
--   D: `"undefined"`
+- A: `"object"`
+- B: `"number"`
+- C: `"function"`
+- D: `"undefined"`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -1087,10 +1085,10 @@ new Boolean(false);
 undefined;
 ```
 
--   A: `0`, `''`, `undefined`
--   B: `0`, `new Number(0)`, `''`, `new Boolean(false)`, `undefined`
--   C: `0`, `''`, `new Boolean(false)`, `undefined`
--   D: Alle sind falsy
+- A: `0`, `''`, `undefined`
+- B: `0`, `new Number(0)`, `''`, `new Boolean(false)`, `undefined`
+- C: `0`, `''`, `new Boolean(false)`, `undefined`
+- D: Alle sind falsy
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -1099,12 +1097,12 @@ undefined;
 
 Es gibt nur 6 falsy typen:
 
--   `undefined`
--   `null`
--   `NaN`
--   `0`
--   `''` (leerer String)
--   `false`
+- `undefined`
+- `null`
+- `NaN`
+- `0`
+- `''` (leerer String)
+- `false`
 
 Funktions-Constructor, wie `new Number` und `new Boolean` sind truthy.
 
@@ -1119,10 +1117,10 @@ Funktions-Constructor, wie `new Number` und `new Boolean` sind truthy.
 console.log(typeof typeof 1);
 ```
 
--   A: `"number"`
--   B: `"string"`
--   C: `"object"`
--   D: `"undefined"`
+- A: `"number"`
+- B: `"string"`
+- C: `"object"`
+- D: `"undefined"`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -1145,10 +1143,10 @@ numbers[10] = 11;
 console.log(numbers);
 ```
 
--   A: `[1, 2, 3, 7 x null, 11]`
--   B: `[1, 2, 3, 11]`
--   C: `[1, 2, 3, 7 x empty, 11]`
--   D: `SyntaxError`
+- A: `[1, 2, 3, 7 x null, 11]`
+- B: `[1, 2, 3, 11]`
+- C: `[1, 2, 3, 7 x empty, 11]`
+- D: `SyntaxError`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -1170,22 +1168,22 @@ abhängig davon wo das Array ausgeführt wird (die Ausgabe ist unterschiedlich f
 
 ```javascript
 (() => {
-	let x, y;
-	try {
-		throw new Error();
-	} catch (x) {
-		(x = 1), (y = 2);
-		console.log(x);
-	}
-	console.log(x);
-	console.log(y);
+  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`
+- A: `1` `undefined` `2`
+- B: `undefined` `undefined` `undefined`
+- C: `1` `1` `2`
+- D: `1` `undefined` `undefined`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -1205,10 +1203,10 @@ Außerhalb des `catch` Blocks ist `x` noch immer `undefined` und `y` ist `2`. We
 
 ###### 39. Alles in JavaScript ist entweder ein ...
 
--   A: Primitive oder Object
--   B: Function oder Object
--   C: Fangfrage: nur Objects!
--   D: Number oder Object
+- A: Primitive oder Object
+- B: Function oder Object
+- C: Fangfrage: nur Objects!
+- D: Number oder Object
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -1229,18 +1227,21 @@ Was einen primitiven Typ von einem Objekt unterscheidet ist, dass Primitive kein
 ###### 40. Was wird ausgegeben?
 
 ```javascript
-[[0, 1], [2, 3]].reduce(
-	(acc, cur) => {
-		return acc.concat(cur);
-	},
-	[1, 2],
+[
+  [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]`
+- 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>Antwort</b></summary>
 <p>
@@ -1264,10 +1265,10 @@ Dann entspricht `acc` gleich `[1, 2, 0, 1]` und `cur` ist gleich `[2, 3]`. Wir v
 !!1;
 ```
 
--   A: `false` `true` `false`
--   B: `false` `false` `true`
--   C: `false` `true` `true`
--   D: `true` `true` `false`
+- A: `false` `true` `false`
+- B: `false` `false` `true`
+- C: `false` `true` `true`
+- D: `true` `true` `false`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -1291,10 +1292,10 @@ Dann entspricht `acc` gleich `[1, 2, 0, 1]` und `cur` ist gleich `[2, 3]`. Wir v
 setInterval(() => console.log("Hi"), 1000);
 ```
 
--   A: Eine unique id
--   B: Die definierte Anzahl von Millisekunden
--   C: Die Callback Function
--   D: `undefined`
+- A: Eine unique id
+- B: Die definierte Anzahl von Millisekunden
+- C: Die Callback Function
+- D: `undefined`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -1314,10 +1315,10 @@ Es gibt eine unique id zurück. Diese id kann zum Beispiel verwendet werden um d
 [..."Lydia"];
 ```
 
--   A: `["L", "y", "d", "i", "a"]`
--   B: `["Lydia"]`
--   C: `[[], "Lydia"]`
--   D: `[["L", "y", "d", "i", "a"]]`
+- A: `["L", "y", "d", "i", "a"]`
+- B: `["Lydia"]`
+- C: `[[], "Lydia"]`
+- D: `[["L", "y", "d", "i", "a"]]`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -1377,7 +1378,7 @@ const secondPromise = new Promise((res, rej) => {
   setTimeout(res, 100, "two");
 });
 
-Promise.race([firstPromise, secondPromise]).then(res => console.log(res));
+Promise.race([firstPromise, secondPromise]).then((res) => console.log(res));
 ```
 
 - A: `"one"`
@@ -1441,7 +1442,7 @@ Wir ändern nur den Wert der Variable `person` und nicht das erste Element im Ar
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21
+  age: 21,
 };
 
 for (const item in person) {
@@ -1521,7 +1522,7 @@ Nur die erste Zahl im String wird ausgegeben. Aufgrund des _radix_ (das zweite A
 ###### 50. Was wird ausgegeben?
 
 ```javascript
-[1, 2, 3].map(num => {
+[1, 2, 3].map((num) => {
   if (typeof num === "number") return;
   return num * 2;
 });
@@ -1687,7 +1688,6 @@ Da wir die Variable `y` aber global erstellt haben ist ihr Wert `10` auch hier v
 </p>
 </details>
 
-
 ---
 
 ###### 55. Was wird ausgegeben?
@@ -1699,7 +1699,7 @@ class Dog {
   }
 }
 
-Dog.prototype.bark = function() {
+Dog.prototype.bark = function () {
   console.log(`Woof I am ${this.name}`);
 };
 
@@ -1814,7 +1814,7 @@ console.log(delete age);
 
 #### Antwort: A
 
-Der `delete` Operator gibt einen Boolean Wert zurück: `true` bei erfolgreichem entfernen, oder andernfalls `false`. Variablen, die mit `var`, `let` oder `const` deklariert werden, können andererseits  nicht mit `delete` entfernt werden.
+Der `delete` Operator gibt einen Boolean Wert zurück: `true` bei erfolgreichem entfernen, oder andernfalls `false`. Variablen, die mit `var`, `let` oder `const` deklariert werden, können andererseits nicht mit `delete` entfernt werden.
 
 Der Wert von `name` wurde mit `const` deklariert, weshalb `delete` nicht möglich ist und `false` zurückgegeben wird. Als wir `age` den Wert `21` zugewiesen haben, haben wir eine Property `age` zum globalen Objekt hinzugefügt. Diese Properties kann man mit `delete` entfernen, sodass `delete age` `true` zurückgibt.
 
@@ -1927,7 +1927,7 @@ Properties, die mit `defineProperty` erstellt wurden sind standardmäßig unver
 const settings = {
   username: "lydiahallie",
   level: 19,
-  health: 90
+  health: 90,
 };
 
 const data = JSON.stringify(settings, ["level", "health"]);
@@ -1961,7 +1961,7 @@ Wenn der Replacer eine _Funktion_ ist, so wird diese Funktion für jede Property
 let num = 10;
 
 const increaseNumber = () => num++;
-const increasePassedNumber = number => number++;
+const increasePassedNumber = (number) => number++;
 
 const num1 = increaseNumber();
 const num2 = increasePassedNumber(num1);
@@ -1987,8 +1987,6 @@ Der unäre Operator `++` _gibt zuerst_ den Wert des Operanden aus und _erhöht d
 </p>
 </details>
 
-
-
 ---
 
 ###### <a name=20190707></a>64. Was wird ausgegeben?
@@ -2056,6 +2054,7 @@ Beim ersten Call ist der Akkumulator (`x`) gleich `1` und der aktuelle Wert (`y`
 Wenn wir keinen Wert einer Funktion ausgeben wird `undefined` ausgegeben. Beim nächsten Call ist der Akkumulator daher `undefined` und der aktuelle Wert ist `3`. `undefined` und `3` werden geloggt.
 
 Beim vierten Call geben wir wieder nichts aus, sodass der Akkumulator wieder `undefined` ist und der aktuelle Wert `4`. `undefined` und `4` werden geloggt.
+
 </p>
 </details>
 
@@ -2109,6 +2108,7 @@ In einer abgeleiteten Klasse kann das `this` Keyword nicht aufgerufen werden, be
 Mit dem `super` Keyword können wir den Constructor der Elternklasse mit gegebenen Argumenten aufrufen. Der Constructor der Elternklasse erhält das `name` Argument, sodass wir `name` an `super` übergeben müssen.
 
 Die `Dog` Klasse erhält zwei Argumente, `name` da es `Animal` erweitert und `size` als extra Property der `Dog` Klasse. Beide müssen an die Constructor Funktion von `Dog` übergeben werden, was nur bei Constructor 2 richtig ist.
+
 </p>
 </details>
 
@@ -2149,9 +2149,9 @@ Das ist der große Unterschied zwischen `require()` in CommonJS und `import`. Mi
 ###### 68. Was wird ausgegeben?
 
 ```javascript
-console.log(Number(2) === Number(2))
-console.log(Boolean(false) === Boolean(false))
-console.log(Symbol('foo') === Symbol('foo'))
+console.log(Number(2) === Number(2));
+console.log(Boolean(false) === Boolean(false));
+console.log(Symbol("foo") === Symbol("foo"));
 ```
 
 - A: `true`, `true`, `false`
@@ -2174,9 +2174,9 @@ Jedes Symbol ist eindeutig. Der Sinn des Argumentes, welches an das Symbol weite
 ###### 69. Was wird ausgegeben?
 
 ```javascript
-const name = "Lydia Hallie"
-console.log(name.padStart(13))
-console.log(name.padStart(2))
+const name = "Lydia Hallie";
+console.log(name.padStart(13));
+console.log(name.padStart(2));
 ```
 
 - A: `"Lydia Hallie"`, `"Lydia Hallie"`
@@ -2451,7 +2451,7 @@ Die `sum` Funktion gibt daher immer das gleiche Ergebnis aus. Wenn wir `1` und `
 ```javascript
 const add = () => {
   const cache = {};
-  return num => {
+  return (num) => {
     if (num in cache) {
       return `From cache! ${cache[num]}`;
     } else {
@@ -2496,21 +2496,21 @@ Beim dritten Mal geben wir `5 * 2` als Argument in die Funktion ein, was `10` er
 ###### <a name=20190726></a>79. Was wird ausgegeben?
 
 ```javascript
-const myLifeSummedUp = ["☕", "💻", "🍷", "🍫"]
+const myLifeSummedUp = ["☕", "💻", "🍷", "🍫"];
 
 for (let item in myLifeSummedUp) {
-  console.log(item)
+  console.log(item);
 }
 
 for (let item of myLifeSummedUp) {
-  console.log(item)
+  console.log(item);
 }
 ```
 
 - A: `0` `1` `2` `3` und `"☕"` ` "💻"` `"🍷"` `"🍫"`
 - B: `"☕"` ` "💻"` `"🍷"` `"🍫"` und `"☕"` ` "💻"` `"🍷"` `"🍫"`
 - C: `"☕"` ` "💻"` `"🍷"` `"🍫"` und `0` `1` `2` `3`
-- D:  `0` `1` `2` `3` und `{0: "☕", 1: "💻", 2: "🍷", 3: "🍫"}`
+- D: `0` `1` `2` `3` und `{0: "☕", 1: "💻", 2: "🍷", 3: "🍫"}`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -2533,14 +2533,14 @@ Mit einer _for-of_ Schleife können wir über **wiederholbare** Elemente iterier
 ###### 80. Was wird ausgegeben?
 
 ```javascript
-const list = [1 + 2, 1 * 2, 1 / 2]
-console.log(list)
+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]`
+- D: `[1, 1, 1]`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -2560,16 +2560,16 @@ Das Element ist gleich dem ausgegebenen Wert. `1 + 2` ergibt `3`, `1 * 2` ergibt
 
 ```javascript
 function sayHi(name) {
-  return `Hi there, ${name}`
+  return `Hi there, ${name}`;
 }
 
-console.log(sayHi())
+console.log(sayHi());
 ```
 
 - A: `Hi there, `
 - B: `Hi there, undefined`
 - C: `Hi there, null`
-- D:  `ReferenceError`
+- D: `ReferenceError`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -2592,21 +2592,21 @@ In diesem Fall, falls wir kein Argument oder `undefined` eingeben ist `name` imm
 ###### 82. Was wird ausgegeben?
 
 ```javascript
-var status = "😎"
+var status = "😎";
 
 setTimeout(() => {
-  const status = "😍"
+  const status = "😍";
 
   const data = {
     status: "🥑",
     getStatus() {
-      return this.status
-    }
-  }
+      return this.status;
+    },
+  };
 
-  console.log(data.getStatus())
-  console.log(data.getStatus.call(this))
-}, 0)
+  console.log(data.getStatus());
+  console.log(data.getStatus.call(this));
+}, 0);
 ```
 
 - A: `"🥑"` und `"😍"`
@@ -2623,7 +2623,6 @@ Der Wert des `this` Keywords hängt davon ab, wo es verwendet wird. In einer **M
 
 Mit der `call` Methode können wir das Objekt, auf welches sich das `this` Keyword bezieht ändern. In **Funktionen** bezieht sich `this` auf das _Objekt, zu dem die Funktion gehört_. Wir erklären die `setTimeout` Funktion im _globalen Objekt_, sodass sich `this` in `setTimeout` auf das _globale Objekt_ bezieht. Im globalen Objekt gibt es _status_ mit dem Wert `"😎"`, was geloggt wird.
 
-
 </p>
 </details>
 
@@ -2634,13 +2633,13 @@ Mit der `call` Methode können wir das Objekt, auf welches sich das `this` Keywo
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21
-}
+  age: 21,
+};
 
-let city = person.city
-city = "Amsterdam"
+let city = person.city;
+city = "Amsterdam";
 
-console.log(person)
+console.log(person);
 ```
 
 - A: `{ name: "Lydia", age: 21 }`
@@ -2671,15 +2670,15 @@ Wenn wir `person` loggen bekommen wir daher das unveränderte Objekt angezeigt.
 ```javascript
 function checkAge(age) {
   if (age < 18) {
-    const message = "Sorry, you're too young."
+    const message = "Sorry, you're too young.";
   } else {
-    const message = "Yay! You're old enough!"
+    const message = "Yay! You're old enough!";
   }
 
-  return message
+  return message;
 }
 
-console.log(checkAge(21))
+console.log(checkAge(21));
 ```
 
 - A: `"Sorry, you're too young."`
@@ -2702,9 +2701,9 @@ Variablen mit dem `const` und `let` Keyword sind _block-scoped_. Ein Block ist a
 ###### 85. Welche Information wird geloggt?
 
 ```javascript
-fetch('https://www.website.com/api/user/1')
-  .then(res => res.json())
-  .then(res => console.log(res))
+fetch("https://www.website.com/api/user/1")
+  .then((res) => res.json())
+  .then((res) => console.log(res));
 ```
 
 - A: Das Ergebnis der `fetch` Methode.
@@ -2749,16 +2748,16 @@ Wenn wir `hasName` gleich `name` setzen, so beinhaltet `hasName` den Wert von `n
 `new Boolean(true)` gibt einen Objekt Wrapper aus, nicht ein Boolean ansich.
 
 `name.length` gibt die Länge des Arguments aus, nicht den Boolean Wert.
+
 </p>
 </details>
 
-
 ---
 
 ###### <a name=20190805></a>87. Was wird ausgegeben?
 
 ```javascript
-console.log("I want pizza"[0])
+console.log("I want pizza"[0]);
 ```
 
 - A: `"""`
@@ -2784,10 +2783,10 @@ Diese Methode funktioniert nicht in IE7 und davor. Hier muss `.charAt()` verwend
 
 ```javascript
 function sum(num1, num2 = num1) {
-  console.log(num1 + num2)
+  console.log(num1 + num2);
 }
 
-sum(10)
+sum(10);
 ```
 
 - A: `NaN`
@@ -2813,13 +2812,13 @@ Wenn man den Wert des Standard Paramenters gleich dem Parameter setztm der _dana
 
 ```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)
+console.log(data);
 ```
 
 - A: `{ default: function default(), name: "Lydia" }`
@@ -2846,12 +2845,12 @@ Das `data` Objekt hat eine Standard Property für alle Standard Exporte, andere
 ```javascript
 class Person {
   constructor(name) {
-    this.name = name
+    this.name = name;
   }
 }
 
-const member = new Person("John")
-console.log(typeof member)
+const member = new Person("John");
+console.log(typeof member);
 ```
 
 - A: `"class"`
@@ -2868,7 +2867,7 @@ Klassen sind syntaktischer Zucker für Funktionskontruktoren. Das Equivalent der
 
 ```javascript
 function Person() {
-  this.name = name
+  this.name = name;
 }
 ```
 
@@ -2882,9 +2881,9 @@ Das Aufrufen eines Funktionskonstruktors mit `new` hat zur Folge, dass eine Inst
 ###### 91. Was wird ausgegeben?
 
 ```javascript
-let newList = [1, 2, 3].push(4)
+let newList = [1, 2, 3].push(4);
 
-console.log(newList.push(5))
+console.log(newList.push(5));
 ```
 
 - A: `[1, 2, 3, 4, 5]`
@@ -2910,13 +2909,14 @@ Dann versuchen wir die `.push` Methode auf `newList` anzuwenden. Da `newList` de
 
 ```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)
+console.log(giveLydiaPizza.prototype);
+console.log(giveLydiaChocolate.prototype);
 ```
 
 - A: `{ constructor: ...}` `{ constructor: ...}`
@@ -2941,11 +2941,11 @@ Reguläre Funktionen wie `giveLydiaPizza` haben eine `prototype` Property, die e
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21
-}
+  age: 21,
+};
 
 for (const [x, y] of Object.entries(person)) {
-  console.log(x, y)
+  console.log(x, y);
 }
 ```
 
@@ -2997,13 +2997,14 @@ getItems(["banana", "apple"], "pear", "orange")
 
 ```javascript
 function getItems(fruitList, favoriteFruit, ...args) {
-  return [...fruitList, ...args, favoriteFruit]
+  return [...fruitList, ...args, favoriteFruit];
 }
 
-getItems(["banana", "apple"], "pear", "orange")
+getItems(["banana", "apple"], "pear", "orange");
 ```
 
 Dieses Beispiel würde funktionieren und `[ 'banana', 'apple', 'orange', 'pear' ]` ausgeben.
+
 </p>
 </details>
 
@@ -3013,17 +3014,14 @@ Dieses Beispiel würde funktionieren und `[ 'banana', 'apple', 'orange', 'pear'
 
 ```javascript
 function nums(a, b) {
-  if
-  (a > b)
-  console.log('a is bigger')
-  else
-  console.log('b is bigger')
-  return
-  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))
+console.log(nums(4, 2));
+console.log(nums(1, 2));
 ```
 
 - A: `a is bigger`, `6` und `b is bigger`, `3`
@@ -3041,8 +3039,8 @@ In JavaScript muss das Semikolon _nicht_ explizit gesetzt werden, allerdings set
 In unserem Beispiel haben wir ein `return` Statement gefolgt von einem anderen Wert `a + b` auf der _nächsten Zeile_. Da es eine neue Zeile ist, weiß JavaScript nicht, dass das der Wert ist, den wir eigentlich ausgeben wollten. Stattdessen wird automatisch ein Semikolon nach `return` gesetzt, was man wiefolgt lesen kann:
 
 ```javascript
-  return;
-  a + b
+return;
+a + b;
 ```
 
 Das bedeutet, dass `a + b` nie erreicht wird, da die Funktion auf der Zeile davor mit dem `return` Keyword endet. Wenn wie hier kein Wert ausgegeben wird, gibt die Funktion `undefined` aus.
@@ -3058,18 +3056,18 @@ Bedenke: Semikolons werden **nicht** automatisch nach `if/else` Statements geset
 ```javascript
 class Person {
   constructor() {
-    this.name = "Lydia"
+    this.name = "Lydia";
   }
 }
 
 Person = class AnotherPerson {
   constructor() {
-    this.name = "Sarah"
+    this.name = "Sarah";
   }
-}
+};
 
-const member = new Person()
-console.log(member.name)
+const member = new Person();
+console.log(member.name);
 ```
 
 - A: `"Lydia"`
@@ -3093,11 +3091,11 @@ Wir können Klassen gleich anderen Klassen oder Funktions Konstruktoren setzen.
 
 ```javascript
 const info = {
-  [Symbol('a')]: 'b'
-}
+  [Symbol("a")]: "b",
+};
 
-console.log(info)
-console.log(Object.keys(info))
+console.log(info);
+console.log(Object.keys(info));
 ```
 
 - A: `{Symbol('a'): 'b'}` und `["{Symbol('a')"]`
@@ -3145,13 +3143,13 @@ console.log(getUser(user))
 
 Die `getList` Funktion bekommt ein Array als Argument zugewiesen. Zwischen den Klammern der `getList` Funktion wird das Array direkt destrukturiert. Man könnte das auch wiefolgt sehen:
 
- `[x, ...y] = [1, 2, 3, 4]`
+`[x, ...y] = [1, 2, 3, 4]`
 
 Mit dem Rest Parameter `...y` packen wir alle übrigen Argumente in ein Array. Die übrigen Argumente sind in dem Fall `2`, `3` und `4`. Der Wert von `y` ist ein Array mit den restlichen Parametern. Der Wert von `x` ist gleich `1` sodass `[1, [2, 3, 4]]` geloggt wird.
 
 Die `getUser` Funktion bekommt ein Objekt zugewiesen. Bei Arrow Funktionen müssen wir keine geschweiften Klammern verwenden, wenn wir nur einen Wert ausgeben. Wenn wir aber ein _Objekt_ von einer Arrow Funktion ausgeben lassen möchten, so muss dieses zwischen Klammern stehen, ansonsten wird nichts ausgegeben. Die folgende Funktion hätte ein Objekt ausgegeben:
 
-```const getUser = user => ({ name: user.name, age: user.age })```
+`const getUser = user => ({ name: user.name, age: user.age })`
 
 Da kein Wert ausgegeben wird, gibt die Funktion `undefined` aus.
 
@@ -3163,9 +3161,9 @@ Da kein Wert ausgegeben wird, gibt die Funktion `undefined` aus.
 ###### 99. Was wird ausgegeben?
 
 ```javascript
-const name = "Lydia"
+const name = "Lydia";
 
-console.log(name())
+console.log(name());
 ```
 
 - A: `SyntaxError`
@@ -3196,8 +3194,8 @@ ReferenceErrors werden ausgeworfen, wenn JavaScript eine Referenz zu einem Wert
 ```javascript
 // 🎉✨ Das ist unsere 100. Frage! ✨🎉
 
-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`
@@ -3222,11 +3220,11 @@ You should${'' && `n't`} see a therapist after so much JavaScript lol`
 ###### 101. Was wird ausgegeben?
 
 ```javascript
-const one = (false || {} || null)
-const two = (null || false || "")
-const three = ([] || 0 || true)
+const one = false || {} || null;
+const two = null || false || "";
+const three = [] || 0 || true;
 
-console.log(one, two, three)
+console.log(one, two, three);
 ```
 
 - A: `false` `null` `[]`
@@ -3255,16 +3253,16 @@ Mit dem `||` Operator geben wir den ersten truthy Operand aus. Wenn alle Werte f
 ###### 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')
+  myPromise().then((res) => console.log(res));
+  console.log("second");
 }
 
 async function secondFunction() {
-  console.log(await myPromise())
-  console.log('second')
+  console.log(await myPromise());
+  console.log("second");
 }
 ```
 
@@ -3297,14 +3295,14 @@ Das bedeutet, dass auf `myPromise` gewartet und dann der Wert `I have resolved`
 ###### 103. Was wird ausgegeben?
 
 ```javascript
-const set = new Set()
+const set = new Set();
 
-set.add(1)
-set.add("Lydia")
-set.add({ name: "Lydia" })
+set.add(1);
+set.add("Lydia");
+set.add({ name: "Lydia" });
 
 for (let item of set) {
-  console.log(item + 2)
+  console.log(item + 2);
 }
 ```
 
@@ -3334,7 +3332,7 @@ Der zweite Wert hingegen ist der String `"Lydia"`. `"Lydia"` ist ein String und
 ###### 104. Was wird ausgegeben?
 
 ```javascript
-Promise.resolve(5)
+Promise.resolve(5);
 ```
 
 - A: `5`
@@ -3361,15 +3359,15 @@ In diesem Fall haben wir nur die Zahl `5` übergeben und diese wird genauso ausg
 ```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)
+compareMembers(person);
 ```
 
 - A: `Not the same!`
@@ -3404,11 +3402,11 @@ const colorConfig = {
   green: true,
   black: true,
   yellow: false,
-}
+};
 
-const colors = ["pink", "red", "blue"]
+const colors = ["pink", "red", "blue"];
 
-console.log(colorConfig.colors[1])
+console.log(colorConfig.colors[1]);
 ```
 
 - A: `true`
@@ -3435,7 +3433,7 @@ JavaScript interpretiert Statements. Wenn wir Klammern-Notation verwenden wird d
 ###### 107. Was wird ausgegeben?
 
 ```javascript
-console.log('❤️' === '❤️')
+console.log("❤️" === "❤️");
 ```
 
 - A: `true`
@@ -3456,14 +3454,14 @@ Emojis sind im Endeffekt nur Unicodes. Der Unicode für das Herz Emoji ist `"U+2
 ###### 108. Welche Methode verändert das ursprüngliche 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`
@@ -3483,18 +3481,17 @@ Mit der `splice` Methode ändern wir das ursprüngliche Array durch löschen, er
 </p>
 </details>
 
-
 ---
 
 ###### <a name=20191009></a>109. Was wird ausgegeben?
 
 ```javascript
-const food = ['🍕', '🍫', '🥑', '🍔']
-const info = { favoriteFood: food[0] }
+const food = ["🍕", "🍫", "🥑", "🍔"];
+const info = { favoriteFood: food[0] };
 
-info.favoriteFood = '🍝'
+info.favoriteFood = "🍝";
 
-console.log(food)
+console.log(food);
 ```
 
 - A: `['🍕', '🍫', '🥑', '🍔']`
@@ -3519,7 +3516,7 @@ Dann ändern wir den Wert von `favoriteFood` am `info` Objekt. Das `food` Array
 ###### 110. Was macht diese Methode?
 
 ```javascript
-JSON.parse()
+JSON.parse();
 ```
 
 - A: Parsed JSON in einen JavaScript Wert
@@ -3536,16 +3533,16 @@ Mit der `JSON.parse()` Methode können wir einen JSON String zu einem JavaScript
 
 ```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
+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]
+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' }
+const jsonArray = JSON.stringify({ name: "Lydia" }); // '{"name":"Lydia"}'
+JSON.parse(jsonArray); // { name: 'Lydia' }
 ```
 
 </p>
@@ -3556,14 +3553,14 @@ JSON.parse(jsonArray) // { name: 'Lydia' }
 ###### 111. Was wird ausgegeben?
 
 ```javascript
-let name = 'Lydia'
+let name = "Lydia";
 
 function getName() {
-  console.log(name)
-  let name = 'Sarah'
+  console.log(name);
+  let name = "Sarah";
 }
 
-getName()
+getName();
 ```
 
 - A: Lydia
@@ -3583,13 +3580,13 @@ Variablen mit dem `let` und `const` Keyword werden gehoisted, aber entgegen `var
 Hätten wir die `name` Variable nicht innerhalb `getName` deklariert, so hätte JavaScript außerhalb der Funktion in der _Scope-Kette_ weitergesucht. Der äußere Scope beinhaltet ebenfalls eine Variable `name` mit dem Wert `'Lydia'`. In diesem Fall wäre `Lydia` geloggt worden.
 
 ```javascript
-let name = 'Lydia'
+let name = "Lydia";
 
 function getName() {
-  console.log(name)
+  console.log(name);
 }
 
-getName() // Lydia
+getName(); // Lydia
 ```
 
 </p>
@@ -3601,18 +3598,18 @@ 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()
-const two = generatorTwo()
+const one = generatorOne();
+const two = generatorTwo();
 
-console.log(one.next().value)
-console.log(two.next().value)
+console.log(one.next().value);
+console.log(two.next().value);
 ```
 
 - A: `a` and `a`
@@ -3630,17 +3627,17 @@ Mit dem `yield` Keyword, halten wir Werte in einer Generator-Funktion. Mit dem `
 In `generatorOne` halten wir das gesamte Array `['a', 'b', 'c']` mit dem `yield` Keyword. Der Wert von `value` am Objekt gibt die `next` Methode an `one` (`one.next().value`) aus, was dem gesamten Array entspricht: `['a', 'b', 'c']`.
 
 ```javascript
-console.log(one.next().value) // ['a', 'b', 'c']
-console.log(one.next().value) // undefined
+console.log(one.next().value); // ['a', 'b', 'c']
+console.log(one.next().value); // undefined
 ```
 
 In `generatorTwo` verwenden wir das `yield*` Keyword. Das bedeutet, dass der erste gehaltene Wert von `two` gleich dem ersten gehaltenen Wert ist. Das ist das Array `['a', 'b', 'c']`. Der erste gehaltene Wert ist `a`, was ausgegeben wird.
 
 ```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
+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>
@@ -3651,7 +3648,7 @@ console.log(two.next().value) // undefined
 ###### 113. Was wird ausgegeben?
 
 ```javascript
-console.log(`${(x => x)('I love')} to program`)
+console.log(`${((x) => x)("I love")} to program`);
 ```
 
 - A: `I love to program`
@@ -3741,19 +3738,19 @@ Beim Setzen eines Key/Wert Paars mit der `set` Methode wird der Key als erstes A
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21
-}
+  age: 21,
+};
 
-const changeAge = (x = { ...person }) => x.age += 1
+const changeAge = (x = { ...person }) => (x.age += 1);
 const changeAgeAndName = (x = { ...person }) => {
-  x.age += 1
-  x.name = "Sarah"
-}
+  x.age += 1;
+  x.name = "Sarah";
+};
 
-changeAge(person)
-changeAgeAndName()
+changeAge(person);
+changeAgeAndName();
 
-console.log(person)
+console.log(person);
 ```
 
 - A: `{name: "Sarah", age: 22}`
@@ -3781,7 +3778,7 @@ Dann führen wir `changeAgeAndName` aus, allerdings ohne Parameter. Stattdessen
 
 ```javascript
 function sumValues(x, y, z) {
-	return x + y + z;
+  return x + y + z;
 }
 ```
 
@@ -3832,15 +3829,15 @@ Mit dem`+=` Operanden erhöhen wir den Wert von `num` um `1`. `num` hatte den ur
 
 ```javascript
 const person = {
-	firstName: "Lydia",
-	lastName: "Hallie",
-	pet: {
-		name: "Mara",
-		breed: "Dutch Tulip Hound"
-	},
-	getFullName() {
-		return `${this.firstName} ${this.lastName}`;
-	}
+  firstName: "Lydia",
+  lastName: "Hallie",
+  pet: {
+    name: "Mara",
+    breed: "Dutch Tulip Hound",
+  },
+  getFullName() {
+    return `${this.firstName} ${this.lastName}`;
+  },
 };
 
 console.log(person.pet?.name);
@@ -3877,9 +3874,9 @@ Mit den optionalen Kettenoperator `?.` müssen wir nicht mehr prüfen, ob die ti
 const groceries = ["banana", "apple", "peanuts"];
 
 if (groceries.indexOf("banana")) {
-	console.log("We have to buy bananas!");
+  console.log("We have to buy bananas!");
 } else {
-	console.log(`We don't have to buy bananas!`);
+  console.log(`We don't have to buy bananas!`);
 }
 ```
 
@@ -3904,10 +3901,10 @@ Wir haben die Kondition `groceries.indexOf("banana")` an das if-Statement überg
 
 ```javascript
 const config = {
-	languages: [],
-	set language(lang) {
-		return this.languages.push(lang);
-	}
+  languages: [],
+  set language(lang) {
+    return this.languages.push(lang);
+  },
 };
 
 console.log(config.language);
@@ -3961,9 +3958,9 @@ console.log(!typeof name === "string");
 ###### 123. Was ist der Output??
 
 ```javascript
-const add = x => y => z => {
-	console.log(x, y, z);
-	return x + y + z;
+const add = (x) => (y) => (z) => {
+  console.log(x, y, z);
+  return x + y + z;
 };
 
 add(4)(5)(6);
@@ -3990,16 +3987,16 @@ Die `add` Funktion gibt eine Arrow Funktion zurück, welche eine Arrow Funktion
 
 ```javascript
 async function* range(start, end) {
-	for (let i = start; i <= end; i++) {
-		yield Promise.resolve(i);
-	}
+  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);
-	}
+  const gen = range(1, 3);
+  for await (const item of gen) {
+    console.log(item);
+  }
 })();
 ```
 
@@ -4024,7 +4021,7 @@ Die Generator-Funktion `range` gibt ein asynchrones Objekt mit Promisen für jed
 
 ```javascript
 const myFunc = ({ x, y, z }) => {
-	console.log(x, y, z);
+  console.log(x, y, z);
 };
 
 myFunc(1, 2, 3);
@@ -4051,20 +4048,20 @@ 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}`;
 }
 
-console.log(getFine(130, 300))
+console.log(getFine(130, 300));
 ```
 
 - A: The driver drove 130 and has to pay 300
@@ -4087,8 +4084,8 @@ Mit der Methode `Intl.NumberFormat` können wir einen numerischen Wert in einen
 ###### 127. Was ist der Output?
 
 ```javascript
-const spookyItems = ['👻', '🎃', '🕸'];
-({ item: spookyItems[3] } = { item: '💀' });
+const spookyItems = ["👻", "🎃", "🕸"];
+({ item: spookyItems[3] } = { item: "💀" });
 
 console.log(spookyItems);
 ```
@@ -4113,7 +4110,7 @@ Durch die destrukturierende Zuweisung können wir Werte des Ojekts von der recht
 ###### 128. Was ist der Output?
 
 ```javascript
-const name = 'Lydia Hallie';
+const name = "Lydia Hallie";
 const age = 21;
 
 console.log(Number.isNaN(name));
@@ -4133,7 +4130,7 @@ console.log(isNaN(age));
 
 #### Antwort: C
 
-Mit der Methode `Number.isNaN` kann geprüft werden, ob der übergebene Parameter vom Typ _Number_ mit Wert  `NaN` ist. `name` ist kein numerischer Wert, deswegen ist der Rückgabewert von `Number.isNaN(name)` in diesem Fall `false`. `age` ist zwar ein numerischer Wert, aber nicht gleich `NaN`, weswegen `Number.isNaN(age)` `false` ausgibt.
+Mit der Methode `Number.isNaN` kann geprüft werden, ob der übergebene Parameter vom Typ _Number_ mit Wert `NaN` ist. `name` ist kein numerischer Wert, deswegen ist der Rückgabewert von `Number.isNaN(name)` in diesem Fall `false`. `age` ist zwar ein numerischer Wert, aber nicht gleich `NaN`, weswegen `Number.isNaN(age)` `false` ausgibt.
 
 Die Methode `isNaN` prüft, ob der Eingabeparameter nicht vom Typ _Number_ ist. `name` ist ein String, darum gibt `isNaN(name)` `true` zurück. `age` ist ein numerischer Wert, weswegen `isNaN(age)` `false` ausgibt.
 
@@ -4149,7 +4146,7 @@ const randomValue = 21;
 
 function getInfo() {
   console.log(typeof randomValue);
-  const randomValue = 'Lydia Hallie';
+  const randomValue = "Lydia Hallie";
 }
 
 getInfo();
@@ -4175,7 +4172,7 @@ Variablen die mit `const` deklariert werden, können nicht vor ihrer Initialisie
 ###### 130. Was ist der Output?
 
 ```javascript
-const myPromise = Promise.resolve('Woah some cool data');
+const myPromise = Promise.resolve("Woah some cool data");
 
 (async () => {
   try {
@@ -4183,7 +4180,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!");
   }
 })();
 ```
@@ -4208,7 +4205,7 @@ Im `try`-Block loggen wir den mit dem `await`-Operator den Wert der Variable `my
 ###### 131. Was ist der Output?
 
 ```javascript
-const emojis = ['🥑', ['✨', '✨', ['🍕', '🍕']]];
+const emojis = ["🥑", ["✨", "✨", ["🍕", "🍕"]]];
 
 console.log(emojis.flat(1));
 ```
@@ -4281,19 +4278,19 @@ Wir rufen nun `counterTwo.increment()` auf, wodurch der Wert von `count` auf `3`
 ###### 133. Was ist der Output?
 
 ```javascript
-const myPromise = Promise.resolve(Promise.resolve('Promise!'));
+const myPromise = Promise.resolve(Promise.resolve("Promise!"));
 
 function funcOne() {
-  myPromise.then(res => res).then(res => console.log(res));
-  setTimeout(() => console.log('Timeout!', 0));
-  console.log('Last line!');
+  myPromise.then((res) => res).then((res) => console.log(res));
+  setTimeout(() => console.log("Timeout!", 0));
+  console.log("Last line!");
 }
 
 async function funcTwo() {
   const res = await myPromise;
   console.log(await res);
-  setTimeout(() => console.log('Timeout!', 0));
-  console.log('Last line!');
+  setTimeout(() => console.log("Timeout!", 0));
+  console.log("Last line!");
 }
 
 funcOne();
@@ -4321,4 +4318,4 @@ Die nächste Zeile ist die _asynchrone_ Funktion `setTimeout`, deren Callback an
 Wir kommen zur letzten Zeile in `funcTwo`, die `Last line!` in der Console ausgibt. Da `funcTwo` abgearbeitet und aus dem Call Stack entfernt wurde, ist der Call Stack leer. Die wartenden Callbacks (`() => console.log("Timeout!")` aus `funcOne` und `() => console.log("Timeout!")` aus `funcTwo`) werden dem Call Stack nacheinander hinzugefügt. Der erste Callback loggt `Timeout!` und wird aus dem Stack entfernt. Anschließend loggt der zweite Callback `Timeout!` und wird aus dem Stack entfernt. Somit ist das Ergebnis `Last line! Promise! Promise! Last line! Timeout! Timeout!`
 
 </p>
-</details>
\ No newline at end of file
+</details>
diff --git a/es-ES/README-ES.md b/es-ES/README-ES.md
index 5c3ddc40..577e66f0 100644
--- a/es-ES/README-ES.md
+++ b/es-ES/README-ES.md
@@ -1,17 +1,16 @@
+# Lista de preguntas (avanzadas) de JavaScript
 
-# Lista de preguntas (avanzadas) de JavaScript 
+Publico diariamente preguntas de opción múltiple en JavaScript en mi [Instagram](https://www.instagram.com/theavocoder), ¡que también publicaré aquí!
 
- Publico diariamente preguntas de opción múltiple en JavaScript en mi [Instagram](https://www.instagram.com/theavocoder), ¡que también publicaré aquí! 
- 
- Desde lo básico a lo avanzado: comprueba si realmente conoces _Javascript_, actualiza tus conocimientos o simplemente prepárate para tu próxima entrevista 💪 🚀 Actualizaré este repo semanalmente con nuevas preguntas.
- 
- Las respuestas se encuentran en las secciones contraídas debajo de las preguntas, simplemente haz clic en ellas para expandirlas. Buena suerte ❤️
+Desde lo básico a lo avanzado: comprueba si realmente conoces _Javascript_, actualiza tus conocimientos o simplemente prepárate para tu próxima entrevista 💪 🚀 Actualizaré este repo semanalmente con nuevas preguntas.
+
+Las respuestas se encuentran en las secciones contraídas debajo de las preguntas, simplemente haz clic en ellas para expandirlas. Buena suerte ❤️
 
 ¿Quieres recibir un email cada vez que agregue más preguntas? <br />
 <a target="_blank" href="https://www.theavocoder.com/subscribe"><b>✨✉Suscríbete a las actualizaciones por email✉✨</b></a>
 
-
 Lista de lenguajes disponibles:
+
 - [🇸🇦 العربية](../ar-AR/README_AR.md)
 - [🇪🇬 اللغة العامية](../ar-EG/README_ar-EG.md)
 - [🇧🇦 Bosanski](../bs-BS/README-bs_BS.md)
@@ -25,6 +24,7 @@ Lista de lenguajes disponibles:
 - [🇳🇱 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)
@@ -34,7 +34,6 @@ Lista de lenguajes disponibles:
 - [🇨🇳 简体中文](../zh-CN/README-zh_CN.md)
 - [🇹🇼 繁體中文](../zh-TW/README_zh-TW.md)
 
-
 ---
 
 ###### 1. ¿Qué devuelve la siguiente función?
@@ -63,6 +62,7 @@ sayHi();
 Dentro de la función, primero declaramos la variable `name` con la palabra reservada ` var`. Esto significa que la variable se _eleva_ (el espacio de memoria se configura durante la fase de creación. Hace referencia al termino [hoisting](https://developer.mozilla.org/es/docs/Glossary/Hoisting)) con el valor predeterminado de `indefinido`, hasta que realmente llegamos a la línea donde definimos la variable. Aún no hemos definido la variable en la línea donde intentamos registrar la variable `name`, por lo que aún mantiene el valor de` undefined`.
 
 Las variables con la palabra clave `let` (y` const`) se _elevan_, pero a diferencia de `var`, no se inicializa <i> </i>. No son accesibles antes de la línea que los declaramos (inicializamos). Esto se llama la ["zona muerta temporal"](https://wesbos.com/temporal-dead-zone/). Cuando intentamos acceder a las variables antes de que se declaren, JavaScript lanza un `ReferenceError`
+
 </p>
 </details>
 
@@ -106,7 +106,7 @@ const shape = {
   diameter() {
     return this.radius * 2;
   },
-  perimeter: () => 2 * Math.PI * this.radius
+  perimeter: () => 2 * Math.PI * this.radius,
 };
 
 shape.diameter();
@@ -163,12 +163,12 @@ En el segundo caso la cadena `'Lydia'` es un valor verdadero. Lo que realmente e
 
 ```javascript
 const bird = {
-  size: "small"
+  size: "small",
 };
 
 const mouse = {
   name: "Mickey",
-  small: true
+  small: true,
 };
 ```
 
@@ -186,7 +186,7 @@ En JavaScript, todas las _keys_ son cadenas (a menos que sea un símbolo). A pes
 
 JavaScript interpreta declaraciones. Cuando usamos la notación de corchetes, ve el corchete de apertura `[` y continúa hasta que encuentra el corchete de cierre `]`. Solo de esta manera se evaluará la afirmación.
 
-`mouse [bird.size]`: Primero evalúa `bird.size`, que es` "small" `. `mouse ["small"]` devuelve `true`
+`mouse [bird.size]`: Primero evalúa `bird.size`, que es`"small"`. `mouse ["small"]` devuelve `true`
 
 Sin embargo, con la notación de puntos, esto no sucede. `mouse` no tiene una clave llamada` bird`, lo que significa que `mouse.bird` es` undefined`. Luego, pedimos el `tamaño` usando la notación de puntos:` mouse.bird.size`. Como `mouse.bird` es` undefined`, en realidad estamos preguntando `undefined.size`. Esto no es válido y generará un error similar `al Cannot read property "size" of undefined`
 
@@ -363,7 +363,7 @@ function Person(firstName, lastName) {
 const member = new Person("Lydia", "Hallie");
 Person.getFullName = function () {
   return `${this.firstName} ${this.lastName}`;
-}
+};
 
 console.log(member.getFullName());
 ```
@@ -420,7 +420,7 @@ console.log(sarah);
 
 Para `sarah`, no usamos la palabra reservada `new`. Cuando se usa `new`, se refiere al nuevo objeto vacío que creamos. Sin embargo, si no se agrega `new', se refiere al **objeto global**!
 
-En el ejemplo `this.firstName` equivale a `"Sarah"` y `this.lastName` equivale a `"Smith"`. Lo que realmente hicimos fue definir `global.firstName = `Sarah'` y `global.lastName = `Smith'`. La misma `sarah` se deja `indefinida`.
+En el ejemplo `this.firstName` equivale a `"Sarah"` y `this.lastName` equivale a `"Smith"`. Lo que realmente hicimos fue definir `global.firstName = `Sarah'`y`global.lastName = `Smith'`. La misma `sarah` se deja `indefinida`.
 
 </p>
 </details>
@@ -487,7 +487,7 @@ sum(1, "2");
 
 JavaScript es un **lenguaje dinámicamente tipado** o de tipado débil, esto significa que no es necesario declarar el tipo de variable antes de usarla pues será determinado automáticamente cuando el programa comience a ser procesado. Los valores se pueden convertir automáticamente en otro tipo sin que se sepa, esto se llama denomina _implicit type coercion_ (Más info [aquí](https://medium.com/@ManuCastrillonM/entendiendo-la-coerci%C3%B3n-en-javascript-bc202d22d23f)). **La coerción es la conversión de un tipo a otro.**
 
-En este ejemplo, JavaScript convierte el número `1` en una cadena, para que la función tenga sentido y devuelva un valor. Durante la suma de un tipo numérico (`1`) y un tipo de cadena (`'2'`), el número se trata como una cadena. Podemos concatenar cadenas como `"Hello" + "World"``, así que lo que está pasando aquí es `"1" + "2"` que devuelve `"12"`
+En este ejemplo, JavaScript convierte el número `1` en una cadena, para que la función tenga sentido y devuelva un valor. Durante la suma de un tipo numérico (`1`) y un tipo de cadena (`'2'`), el número se trata como una cadena. Podemos concatenar cadenas como ` "Hello" + "World"``, así que lo que está pasando aquí es  `"1" + "2"`que devuelve`"12"`
 
 </p>
 </details>
@@ -554,8 +554,8 @@ getPersonInfo`${person} is ${age} years old`;
 
 #### Respuesta correcta: B
 
-
 _Tagged templates_ es un caso de uso de [template literals](https://codeburst.io/javascript-template-literals-tag-functions-for-beginners-758a041160e1). Una _plantilla etiquetada_ es una llamada de función que utiliza una plantilla literal de la que obtener sus argumentos. Si se usan literales de plantillas etiquetadas, el valor del primer argumento es siempre una matriz de los valores de las cadenas. El resto de los argumentos obtienen los valores de las expresiones pasadas.
+
 </p>
 </details>
 
@@ -755,7 +755,6 @@ Todas las claves de un objeto (excepto los símbolos) actúan como cadenas, incl
 
 No funciona así para un conjunto. No hay un "1" en nuestro set: `set.has('1')` devuelve `falso`. Tiene el tipo numérico `1`, `set.has(1)` devuelve `true`.
 
-
 </p>
 </details>
 
@@ -821,7 +820,8 @@ for (let i = 1; i < 5; i++) {
 <p>
 
 #### Respuesta correcta: C
-La sentencia `continue` omite una iteración si una cierta condición, en este caso `(i === 3)`,  devuelve `true`.
+
+La sentencia `continue` omite una iteración si una cierta condición, en este caso `(i === 3)`, devuelve `true`.
 
 </p>
 </details>
@@ -837,7 +837,7 @@ String.prototype.giveLydiaPizza = () => {
 
 const name = "Lydia";
 
-console.log(name.giveLydiaPizza())
+console.log(name.giveLydiaPizza());
 ```
 
 - A: `"Just give Lydia pizza already!"`
@@ -921,7 +921,7 @@ Después de que la _callback_ es empujada a la WebAPI, la función `setTimeout`
 
 <img src="https://i.imgur.com/X5wsHOg.png" width="200">
 
-Ahora, `foo` es invocado, y ``"First"`` está siendo registrado.
+Ahora, `foo` es invocado, y `"First"` está siendo registrado.
 
 <img src="https://i.imgur.com/Pvc0dGq.png" width="200">
 
@@ -949,9 +949,7 @@ Se invoca el `bar`, se registra el `"Second"` y se quita de la pila.
 ```html
 <div onclick="console.log('first div')">
   <div onclick="console.log('second div')">
-    <button onclick="console.log('button')">
-      Click!
-    </button>
+    <button onclick="console.log('button')">Click!</button>
   </div>
 </div>
 ```
@@ -977,9 +975,7 @@ El elemento anidado más profundo que causa el evento es el destino de ese event
 
 ```html
 <div onclick="console.log('div')">
-  <p onclick="console.log('p')">
-    Click here!
-  </p>
+  <p onclick="console.log('p')">Click here!</p>
 </div>
 ```
 
@@ -1023,7 +1019,7 @@ sayHi.bind(person, 21);
 
 #### Respuesta correcta: D
 
-En ambos  podemos pasar el objeto al que queremos que se refiera la palabra reservada `this`. Sin embargo, la diferencia es que `.call` es *ejecutado inmediatamente*!
+En ambos podemos pasar el objeto al que queremos que se refiera la palabra reservada `this`. Sin embargo, la diferencia es que `.call` es _ejecutado inmediatamente_!
 
 `.bind` devuelve una copia de la función, pero con un contexto enlazado. Es decir, no se ejecuta de inmediato.
 
@@ -1091,7 +1087,6 @@ Solo hay seis valores falsos:
 - `''` (cadena vacía)
 - `false`
 
-
 Los constructores de funciones, como `new Number` y `new Boolean` son correctos.
 
 </p>
@@ -1215,7 +1210,10 @@ Lo que diferencia a un tipo primitivo de un objeto es que los primeros no tienen
 ###### 40. ¿Qué devuelve la siguiente función?
 
 ```javascript
-[[0, 1], [2, 3]].reduce(
+[
+  [0, 1],
+  [2, 3],
+].reduce(
   (acc, cur) => {
     return acc.concat(cur);
   },
@@ -1233,7 +1231,7 @@ Lo que diferencia a un tipo primitivo de un objeto es que los primeros no tienen
 
 #### Respuesta correcta: C
 
-`[1, 2]` es nuestro valor inicial. Este es el valor con el que empezamos y el valor del primer `acc`. Durante la primera ronda, `acc` es` [1,2] `, y `cur` es `[0, 1]`. Los concatenamos, lo que resulta en `[1, 2, 0, 1]`.
+`[1, 2]` es nuestro valor inicial. Este es el valor con el que empezamos y el valor del primer `acc`. Durante la primera ronda, `acc` es`[1,2]`, y `cur` es `[0, 1]`. Los concatenamos, lo que resulta en `[1, 2, 0, 1]`.
 
 Entonces, `[1, 2, 0, 1]` es `acc` y` [2, 3]` es `cur`. Los concatenamos, y obtenemos `[1, 2, 0, 1, 2, 3]`
 
@@ -1363,7 +1361,7 @@ const secondPromise = new Promise((res, rej) => {
   setTimeout(res, 100, "two");
 });
 
-Promise.race([firstPromise, secondPromise]).then(res => console.log(res));
+Promise.race([firstPromise, secondPromise]).then((res) => console.log(res));
 ```
 
 - A: `"one"`
@@ -1427,7 +1425,7 @@ Solo estamos modificando el valor de la variable `person`, y no el primer elemen
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21
+  age: 21,
 };
 
 for (const item in person) {
@@ -1507,7 +1505,7 @@ Solo el primer número en el string es devuelto. Según en la _base_ seleccionad
 ###### 50. ¿Cuál es el resultado?
 
 ```javascript
-[1, 2, 3].map(num => {
+[1, 2, 3].map((num) => {
   if (typeof num === "number") return;
   return num * 2;
 });
@@ -1684,7 +1682,7 @@ class Dog {
   }
 }
 
-Dog.prototype.bark = function() {
+Dog.prototype.bark = function () {
   console.log(`Woof I am ${this.name}`);
 };
 
@@ -1912,7 +1910,7 @@ Las propiedades añadidas usando el método `defineProperty` son inmutables por
 const settings = {
   username: "lydiahallie",
   level: 19,
-  health: 90
+  health: 90,
 };
 
 const data = JSON.stringify(settings, ["level", "health"]);
@@ -1946,7 +1944,7 @@ Si el reemplazador es una _función_, esta función es llamada en cada propiedad
 let num = 10;
 
 const increaseNumber = () => num++;
-const increasePassedNumber = number => number++;
+const increasePassedNumber = (number) => number++;
 
 const num1 = increaseNumber();
 const num2 = increasePassedNumber(num1);
@@ -2036,7 +2034,7 @@ El valor del acumulador es igual al valor previamente devuelto por la función d
 
 En la primera llamada, el acumulador (`x`) es `1`, y el valor actual (`y`) es `2`. No devolvemos desde la función de callback, mostramos por consola el acumulador y el valor actual: se muestra `1` y `2`.
 
-Si no devuelves un valor de una función, se devuelve `undefined`. En la siguiente llamada, el acumulador es `undefined`, y el valor actual es `3`. Se muestra por consola `undefined` y `3`.  
+Si no devuelves un valor de una función, se devuelve `undefined`. En la siguiente llamada, el acumulador es `undefined`, y el valor actual es `3`. Se muestra por consola `undefined` y `3`.
 
 En la cuarta llamada, otra vez no devolvemos desde la función de callback. El acumulador es una vez más `undefined`, y el valor actual es `4`. Se muestra por consola `undefined` y `4`.
 
@@ -2055,7 +2053,7 @@ class Dog {
 };
 
 class Labrador extends Dog {
-  // 1 
+  // 1
   constructor(name, size) {
     this.size = size;
   }
@@ -2069,7 +2067,7 @@ class Labrador extends Dog {
     super(name);
     this.size = size;
   }
-  // 4 
+  // 4
   constructor(name, size) {
     this.name = name;
     this.size = size;
@@ -2103,12 +2101,12 @@ La clase `Labrador` recibe dos argumentos, `name` porque extiende de `Dog`, y `s
 
 ```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;
 ```
 
@@ -2124,7 +2122,7 @@ export const sum = (a, b) => a + b;
 
 Con `import`, todos los módulos importados son _pre-convertidos_. Esto significa que los módulos importados son ejecutados _primero_, y el código en el fichero que importa el módulo se ejecuta _después_.
 
-¡Esto es una diferencia existente entre `require()` en CommonJS e `import`! Con `require()`, puedes cargar dependencias bajo demanda mientras el código está siendo ejecutado. Si hubiéramos usado `require` en lugar de `import`, se habría mostrado por consola `running index.js`, `running sum.js`, `3`. 
+¡Esto es una diferencia existente entre `require()` en CommonJS e `import`! Con `require()`, puedes cargar dependencias bajo demanda mientras el código está siendo ejecutado. Si hubiéramos usado `require` en lugar de `import`, se habría mostrado por consola `running index.js`, `running sum.js`, `3`.
 
 </p>
 </details>
@@ -2134,9 +2132,9 @@ Con `import`, todos los módulos importados son _pre-convertidos_. Esto signific
 ###### 68. ¿Cuál es el resultado?
 
 ```javascript
-console.log(Number(2) === Number(2))
-console.log(Boolean(false) === Boolean(false))
-console.log(Symbol('foo') === Symbol('foo'))
+console.log(Number(2) === Number(2));
+console.log(Boolean(false) === Boolean(false));
+console.log(Symbol("foo") === Symbol("foo"));
 ```
 
 - A: `true`, `true`, `false`
@@ -2159,15 +2157,15 @@ Cada Symbol es completamente único. El propósito del argumento pasado a Symbol
 ###### 69. ¿Cuál es el resultado?
 
 ```javascript
-const name = "Lydia Hallie"
-console.log(name.padStart(13))
-console.log(name.padStart(2))
+const name = "Lydia Hallie";
+console.log(name.padStart(13));
+console.log(name.padStart(2));
 ```
 
 - A: `"Lydia Hallie"`, `"Lydia Hallie"`
 - B: `"           Lydia Hallie"`, `"  Lydia Hallie"` (`"[13 espacios en blanco]Lydia Hallie"`, `"[2 espacios en blanco]Lydia Hallie"`)
 - C: `" Lydia Hallie"`, `"Lydia Hallie"` (`"[1 espacio en blanco]Lydia Hallie"`, `"Lydia Hallie"`)
-- D: `"Lydia Hallie"`, `"Lyd"`, 
+- D: `"Lydia Hallie"`, `"Lyd"`,
 
 <details><summary><b>Solución</b></summary>
 <p>
@@ -2435,7 +2433,7 @@ La función `sum` siempre devuelve el mismo resultado. Si pasamos `1` y `2`, _si
 ```javascript
 const add = () => {
   const cache = {};
-  return num => {
+  return (num) => {
     if (num in cache) {
       return `From cache! ${cache[num]}`;
     } else {
@@ -2480,21 +2478,21 @@ La tercera vez, pasamos `5 * 2` a la función, que se evalúa como `10`. El obje
 ###### 79. ¿Cuál es el resultado?
 
 ```javascript
-const myLifeSummedUp = ["☕", "💻", "🍷", "🍫"]
+const myLifeSummedUp = ["☕", "💻", "🍷", "🍫"];
 
 for (let item in myLifeSummedUp) {
-  console.log(item)
+  console.log(item);
 }
 
 for (let item of myLifeSummedUp) {
-  console.log(item)
+  console.log(item);
 }
 ```
 
 - A: `0` `1` `2` `3` y `"☕"` ` "💻"` `"🍷"` `"🍫"`
 - B: `"☕"` ` "💻"` `"🍷"` `"🍫"` y `"☕"` ` "💻"` `"🍷"` `"🍫"`
 - C: `"☕"` ` "💻"` `"🍷"` `"🍫"` y `0` `1` `2` `3`
-- D:  `0` `1` `2` `3` y `{0: "☕", 1: "💻", 2: "🍷", 3: "🍫"}`
+- D: `0` `1` `2` `3` y `{0: "☕", 1: "💻", 2: "🍷", 3: "🍫"}`
 
 <details><summary><b>Solución</b></summary>
 <p>
@@ -2517,14 +2515,14 @@ Con un bucle _for-of_, podemos iterar sobre **iterables**. Un array es un iterab
 ###### 80. ¿Cuál es el resultado?
 
 ```javascript
-const list = [1 + 2, 1 * 2, 1 / 2]
-console.log(list)
+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]`
+- D: `[1, 1, 1]`
 
 <details><summary><b>Solución</b></summary>
 <p>
@@ -2544,16 +2542,16 @@ El elemento será igual al valor retornado. `1 + 2` devuelve `3`, `1 * 2` devuel
 
 ```javascript
 function sayHi(name) {
-  return `Hi there, ${name}`
+  return `Hi there, ${name}`;
 }
 
-console.log(sayHi())
+console.log(sayHi());
 ```
 
 - A: `Hi there, `
 - B: `Hi there, undefined`
 - C: `Hi there, null`
-- D:  `ReferenceError`
+- D: `ReferenceError`
 
 <details><summary><b>Solución</b></summary>
 <p>
@@ -2576,21 +2574,21 @@ En ese caso, si no pasáramos un valor o si pasáramos `undefined`, `name` siemp
 ###### 82. ¿Cuál es el resultado?
 
 ```javascript
-var status = "😎"
+var status = "😎";
 
 setTimeout(() => {
-  const status = "😍"
+  const status = "😍";
 
   const data = {
     status: "🥑",
     getStatus() {
-      return this.status
-    }
-  }
+      return this.status;
+    },
+  };
 
-  console.log(data.getStatus())
-  console.log(data.getStatus.call(this))
-}, 0)
+  console.log(data.getStatus());
+  console.log(data.getStatus.call(this));
+}, 0);
 ```
 
 - A: `"🥑"` y `"😍"`
@@ -2617,13 +2615,13 @@ Con el método `call`, podemos cambiar el objeto al cual `this` referencia. En *
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21
-}
+  age: 21,
+};
 
-let city = person.city
-city = "Amsterdam"
+let city = person.city;
+city = "Amsterdam";
 
-console.log(person)
+console.log(person);
 ```
 
 - A: `{ name: "Lydia", age: 21 }`
@@ -2654,15 +2652,15 @@ Cuando se muestra por consola el objeto `person`, se devuelve el objeto sin modi
 ```javascript
 function checkAge(age) {
   if (age < 18) {
-    const message = "Sorry, you're too young."
+    const message = "Sorry, you're too young.";
   } else {
-    const message = "Yay! You're old enough!"
+    const message = "Yay! You're old enough!";
   }
 
-  return message
+  return message;
 }
 
-console.log(checkAge(21))
+console.log(checkAge(21));
 ```
 
 - A: `"Sorry, you're too young."`
@@ -2685,15 +2683,15 @@ Las variables con `const` y `let` tienen _alcance de bloque_. Un bloque es cualq
 ###### 85. ¿Qué tipo de información se mostrará por consola?
 
 ```javascript
-fetch('https://www.website.com/api/user/1')
-  .then(res => res.json())
-  .then(res => console.log(res))
+fetch("https://www.website.com/api/user/1")
+  .then((res) => res.json())
+  .then((res) => console.log(res));
 ```
 
 - A: El resultado del método `fetch`.
 - B: El resultado de la segunda invocación del método `fetch`.
 - C: El resultado de callback en el `.then()` anterior.
-- D: Sería siempre `undefined`. 
+- D: Sería siempre `undefined`.
 
 <details><summary><b>Solución</b></summary>
 <p>
@@ -2741,7 +2739,7 @@ Asignándole a `hasName` el valor de `name`, asignas a `hasName` cualquier valor
 ###### 87. ¿Cuál es el resultado?
 
 ```javascript
-console.log("I want pizza"[0])
+console.log("I want pizza"[0]);
 ```
 
 - A: `"""`
@@ -2767,10 +2765,10 @@ Observa que este método no está soportado en IE7 y versiones anteriores. En es
 
 ```javascript
 function sum(num1, num2 = num1) {
-  console.log(num1 + num2)
+  console.log(num1 + num2);
 }
 
-sum(10)
+sum(10);
 ```
 
 - A: `NaN`
@@ -2795,14 +2793,14 @@ Si estuvieras intentando asignar un valor por defecto a un parámetro igual a ot
 ###### 89. ¿Cuál es el resultado?
 
 ```javascript
-// module.js 
-export default () => "Hello world"
-export const name = "Lydia"
+// module.js
+export default () => "Hello world";
+export const name = "Lydia";
 
-// index.js 
-import * as data from "./module"
+// index.js
+import * as data from "./module";
 
-console.log(data)
+console.log(data);
 ```
 
 - A: `{ default: function default(), name: "Lydia" }`
@@ -2829,12 +2827,12 @@ El objeto `data` tiene una propiedad `default` para la exportación por defecto,
 ```javascript
 class Person {
   constructor(name) {
-    this.name = name
+    this.name = name;
   }
 }
 
-const member = new Person("John")
-console.log(typeof member)
+const member = new Person("John");
+console.log(typeof member);
 ```
 
 - A: `"class"`
@@ -2851,11 +2849,11 @@ Las clases son azúcar sintáctico para los constructores de funciones. El equiv
 
 ```javascript
 function Person() {
-  this.name = name
+  this.name = name;
 }
 ```
 
-Llamar a un constructor de funciones con `new` crea una instancia de `Person`, `typeof` devuelve `"object"` con una instancia. `typeof member` devuelve `"object"`. 
+Llamar a un constructor de funciones con `new` crea una instancia de `Person`, `typeof` devuelve `"object"` con una instancia. `typeof member` devuelve `"object"`.
 
 </p>
 </details>
@@ -2865,9 +2863,9 @@ Llamar a un constructor de funciones con `new` crea una instancia de `Person`, `
 ###### 91. ¿Cuál es el resultado?
 
 ```javascript
-let newList = [1, 2, 3].push(4)
+let newList = [1, 2, 3].push(4);
 
-console.log(newList.push(5))
+console.log(newList.push(5));
 ```
 
 - A: `[1, 2, 3, 4, 5]`
@@ -2893,17 +2891,18 @@ Después, intentamos usar el método `.push` en `newList`. Como `newList` es el
 
 ```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)
+console.log(giveLydiaPizza.prototype);
+console.log(giveLydiaChocolate.prototype);
 ```
 
-- A: `{ constructor: ...}` `{ constructor: ...}` 
-- B: `{}` `{ constructor: ...}` 
+- A: `{ constructor: ...}` `{ constructor: ...}`
+- B: `{}` `{ constructor: ...}`
 - C: `{ constructor: ...}` `{}`
 - D: `{ constructor: ...}` `undefined`
 
@@ -2924,16 +2923,16 @@ Las funciones regulares, como la función `giveLydiaPizza`, tienen la propiedad
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21
-}
+  age: 21,
+};
 
 for (const [x, y] of Object.entries(person)) {
-  console.log(x, y)
+  console.log(x, y);
 }
 ```
 
 - A: `name` `Lydia` y `age` `21`
-- B: `["name", "Lydia"]` y `["age", 21]` 
+- B: `["name", "Lydia"]` y `["age", 21]`
 - C: `["name", "age"]` y `undefined`
 - D: `Error`
 
@@ -2944,7 +2943,7 @@ for (const [x, y] of Object.entries(person)) {
 
 `Object.entries(person)` devuelve un array de arrays anidados, conteniendo claves y objetos:
 
-`[ [ 'name', 'Lydia' ], [ 'age', 21 ] ]` 
+`[ [ 'name', 'Lydia' ], [ 'age', 21 ] ]`
 
 Usando el bucle `for-of`, podemos iterar sobre cada elemento en el array, los subarrays en este caso. Podemos desestructurar los subarrays instantáneamente en el bucle for-of, usando `const [x, y]`. `x` es igual al primer elemento del subarray, `y` es igual al segundo elemento en el subarray.
 
@@ -2968,7 +2967,7 @@ getItems(["banana", "apple"], "pear", "orange")
 ```
 
 - A: `["banana", "apple", "pear", "orange"]`
-- B: `[["banana", "apple"], "pear", "orange"]` 
+- B: `[["banana", "apple"], "pear", "orange"]`
 - C: `["banana", "apple", ["pear"], "orange"]`
 - D: `SyntaxError`
 
@@ -2981,13 +2980,14 @@ getItems(["banana", "apple"], "pear", "orange")
 
 ```javascript
 function getItems(fruitList, favoriteFruit, ...args) {
-  return [...fruitList, ...args, favoriteFruit]
+  return [...fruitList, ...args, favoriteFruit];
 }
 
-getItems(["banana", "apple"], "pear", "orange")
+getItems(["banana", "apple"], "pear", "orange");
 ```
 
 El ejemplo de arriba sí que funciona. Devuelve el array `[ 'banana', 'apple', 'orange', 'pear' ]`
+
 </p>
 </details>
 
@@ -2997,17 +2997,14 @@ El ejemplo de arriba sí que funciona. Devuelve el array `[ 'banana', 'apple', '
 
 ```javascript
 function nums(a, b) {
-  if
-  (a > b)
-  console.log('a is bigger')
-  else 
-  console.log('b is bigger')
-  return 
-  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))
+console.log(nums(4, 2));
+console.log(nums(1, 2));
 ```
 
 - A: `a is bigger`, `6` y `b is bigger`, `3`
@@ -3020,13 +3017,13 @@ console.log(nums(1, 2))
 
 #### Answer: B
 
-En JavaScript, no _tenemos_ que escribir el punto y coma (`;`) de forma explicita, sin embargo el motor de JavaScript todavía las añade al final de cada sentencia. Esto se denomina **Insercción automática de punto y coma**. Una sentencia puede ser, por ejemplo, variables, o palabras clave como `throw`, `return`, `break`, etc. 
+En JavaScript, no _tenemos_ que escribir el punto y coma (`;`) de forma explicita, sin embargo el motor de JavaScript todavía las añade al final de cada sentencia. Esto se denomina **Insercción automática de punto y coma**. Una sentencia puede ser, por ejemplo, variables, o palabras clave como `throw`, `return`, `break`, etc.
 
 Aqui, escribimos una sentencia `return`, y otra sentencia de valor `a + b` en una _nueva línea_. Sin embargo, como es una línea nueva, el motor no sabe que en realidad es el valor que queríamos devolver. En cambio, añadió automáticamente un punto y coma después de `return`. Puedes ver esto como:
 
 ```javascript
-  return;
-  a + b
+return;
+a + b;
 ```
 
 Esto significa que nunca se alcanza `a + b`, ya que una función deja de ejecutarse después de la palabra clave` return`. Si no se devuelve ningún valor, como aquí, la función devuelve `undefined`. ¡Ten en cuenta que no hay inserción automática después de las sentencias `if/else`!
@@ -3041,18 +3038,18 @@ Esto significa que nunca se alcanza `a + b`, ya que una función deja de ejecuta
 ```javascript
 class Person {
   constructor() {
-    this.name = "Lydia"
+    this.name = "Lydia";
   }
 }
 
 Person = class AnotherPerson {
   constructor() {
-    this.name = "Sarah"
+    this.name = "Sarah";
   }
-}
+};
 
-const member = new Person()
-console.log(member.name)
+const member = new Person();
+console.log(member.name);
 ```
 
 - A: `"Lydia"`
@@ -3076,11 +3073,11 @@ Podemos establecer clases iguales a otros constructures de clases/funciones. En
 
 ```javascript
 const info = {
-  [Symbol('a')]: 'b'
-}
+  [Symbol("a")]: "b",
+};
 
-console.log(info)
-console.log(Object.keys(info))
+console.log(info);
+console.log(Object.keys(info));
 ```
 
 - A: `{Symbol('a'): 'b'}` y `["{Symbol('a')"]`
@@ -3127,13 +3124,13 @@ console.log(getUser(user))
 
 La función `getList` recibe un array argumento. Entre los paréntesis de la función `getList`, desestructuramos este array de inmediato. Podrías ver esto como:
 
- `[x, ...y] = [1, 2, 3, 4]`
+`[x, ...y] = [1, 2, 3, 4]`
 
 Con el parámetro rest `...y`, ponemos todos los argumentos "restantes" en un array. Los argumentos restantes son `2`, `3` and `4` en este caso. El valor de `y` es un array, conteniendo todos los parámetros restantes. El valor de `x` es igual a `1` en este caso, por la tanto cuando registramos `[x, y]`, se imprime `[1, [2, 3, 4]]`.
 
- La función `getUser` recibe un objeto. Con las funciones flecha, no _tenemos_ que escribir llaves cuando simplemente devolvemos un valor. Sin embargo, si quieres devolver un _objeto_ desde una función llave, tienes que escribir el objeto entre paréntesis, ¡de otra manera no se devuelve ningún valor! La siguiente función habría devuelto un objeto:
+La función `getUser` recibe un objeto. Con las funciones flecha, no _tenemos_ que escribir llaves cuando simplemente devolvemos un valor. Sin embargo, si quieres devolver un _objeto_ desde una función llave, tienes que escribir el objeto entre paréntesis, ¡de otra manera no se devuelve ningún valor! La siguiente función habría devuelto un objeto:
 
-```const getUser = user => ({ name: user.name, age: user.age })```
+`const getUser = user => ({ name: user.name, age: user.age })`
 
 Como no se devuelve ningún valor en este caso, la función devuelve `undefined`.
 
@@ -3145,9 +3142,9 @@ Como no se devuelve ningún valor en este caso, la función devuelve `undefined`
 ###### 99. ¿Cuál es el resultado?
 
 ```javascript
-const name = "Lydia"
+const name = "Lydia";
 
-console.log(name())
+console.log(name());
 ```
 
 - A: `SyntaxError`
@@ -3160,11 +3157,11 @@ console.log(name())
 
 #### Answer: C
 
-La variable `name` contiene el valor de una cadena, que no es una función, por lo tanto no puede invocar. 
+La variable `name` contiene el valor de una cadena, que no es una función, por lo tanto no puede invocar.
 
 Se genera una excepción de tipo TypeError cuando un valor no es del tipo esperado. JavaScript esperaba que `name` fuera una función ya que estamos intentando invocarla. Era una cadena sin embargo, por lo tanto se lanza una excepción del tipo TypeError: name is not a function!
 
-Se lanzan errores del tipo SyntaxError cuando has escrito algo que no es válido JavaScript, pro ejemplo cuando has escrito `return` como `retrun`. 
+Se lanzan errores del tipo SyntaxError cuando has escrito algo que no es válido JavaScript, pro ejemplo cuando has escrito `return` como `retrun`.
 Se lanzan errores del tipo ReferenceError cuando JavaScript no puede encontrar una referencia a un valor al que estás intentando acceder.
 
 </p>
@@ -3177,8 +3174,8 @@ Se lanzan errores del tipo ReferenceError cuando JavaScript no puede encontrar u
 ```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`
@@ -3203,11 +3200,11 @@ You should${'' && `n't`} see a therapist after so much JavaScript lol`
 ###### 101. ¿Cuál es el valor de la salida?
 
 ```javascript
-const one = (false || {} || null)
-const two = (null || false || "")
-const three = ([] || 0 || true)
+const one = false || {} || null;
+const two = null || false || "";
+const three = [] || 0 || true;
 
-console.log(one, two, three)
+console.log(one, two, three);
 ```
 
 - A: `false` `null` `[]`
@@ -3236,20 +3233,20 @@ Con el operador `||`, podemos devolver el primer operando verdadero. Si todos lo
 ###### 102. ¿Cuál es el valor de la salida?
 
 ```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')
+  myPromise().then((res) => console.log(res));
+  console.log("second");
 }
 
 async function secondFunction() {
-  console.log(await myPromise())
-  console.log('second')
+  console.log(await myPromise());
+  console.log("second");
 }
 
-firstFunction()
-secondFunction()
+firstFunction();
+secondFunction();
 ```
 
 - A: `I have resolved!`, `second` y `I have resolved!`, `second`
@@ -3264,13 +3261,13 @@ secondFunction()
 
 Con una promesa, básicamente decimos _Quiero ejecutar esta función, pero la dejaré a un lado por ahora mientras se está ejecutando, ya que esto puede llevar un tiempo. Solo cuando se resuelve (o se rechaza) un cierto valor, y cuando la pila de llamadas está vacía, quiero usar este valor._
 
-Podemos obtener este valor con las palabras clave `.then` y `await` en una función `async`. Aunque podemos obtener el valor de una promesa tanto con `.then` como con` wait ', funcionan de manera un poco diferente. 
+Podemos obtener este valor con las palabras clave `.then` y `await` en una función `async`. Aunque podemos obtener el valor de una promesa tanto con `.then` como con` wait ', funcionan de manera un poco diferente.
 
-En la función `firstFunction`, dejamos (de algún modo) a un lado la función myPromise mientras se estaba ejecutando, y seguimos ejecutando el otro código, que es `console.log('second')` en este caso. Luego, la función se resolvió con la cadena `I have resolved`, que luego se imprimió una vez que pila de llamadas quedó vacía. 
+En la función `firstFunction`, dejamos (de algún modo) a un lado la función myPromise mientras se estaba ejecutando, y seguimos ejecutando el otro código, que es `console.log('second')` en este caso. Luego, la función se resolvió con la cadena `I have resolved`, que luego se imprimió una vez que pila de llamadas quedó vacía.
 
 Con la palabra clave await en `secondFunction`, literalmente hacemos una pausa en la ejecución de una función asíncrona hasta que el valor se haya resuelto antes de pasar a la siguiente línea de código.
 
-Esto significa que se esperó a que `myPromise` resolviera con el valor `I have resolved`, y solo una vez que eso sucedió, pasamos a la siguiente línea: `second` que se imprime. 
+Esto significa que se esperó a que `myPromise` resolviera con el valor `I have resolved`, y solo una vez que eso sucedió, pasamos a la siguiente línea: `second` que se imprime.
 
 </p>
 </details>
@@ -3280,14 +3277,14 @@ Esto significa que se esperó a que `myPromise` resolviera con el valor `I have
 ###### 103. ¿Cuál es el valor de la salida?
 
 ```javascript
-const set = new Set()
+const set = new Set();
 
-set.add(1)
-set.add("Lydia")
-set.add({ name: "Lydia" })
+set.add(1);
+set.add("Lydia");
+set.add({ name: "Lydia" });
 
 for (let item of set) {
-  console.log(item + 2)
+  console.log(item + 2);
 }
 ```
 
@@ -3301,11 +3298,11 @@ for (let item of set) {
 
 #### Answer: C
 
-El operador `+` no solo se usa para sumar valores numéricos, sino que también podemos usarlo para concatenar cadenas. Cada vez que el motor de JavaScript ve que uno o más valores no son un número, coerce el número en una cadena. 
+El operador `+` no solo se usa para sumar valores numéricos, sino que también podemos usarlo para concatenar cadenas. Cada vez que el motor de JavaScript ve que uno o más valores no son un número, coerce el número en una cadena.
 
 El primero es `1`, que es un valor numérico. `1 + 2` devuelve el número 3.
 
-Sin embargo, el segundo es la cadena `"Lydia"`. `"Lydia"` es una cadena y `2` es un número: `2` coerce a una cadena. `"Lydia"` y `"2"` son concatenados, cuyo resultado es la cadena `"Lydia2"`. 
+Sin embargo, el segundo es la cadena `"Lydia"`. `"Lydia"` es una cadena y `2` es un número: `2` coerce a una cadena. `"Lydia"` y `"2"` son concatenados, cuyo resultado es la cadena `"Lydia2"`.
 
 `{ name: "Lydia" }` es un objeto. Ni un número ni un objeto son una cadena, así que se convierten a cadena ambos. Cada vez que convertimos un objeto estandar, se convierte en `"[Object object]"`. `"[Object object]"` concatenado con `"2"` resulta en `"[Object object]2"`.
 
@@ -3317,7 +3314,7 @@ Sin embargo, el segundo es la cadena `"Lydia"`. `"Lydia"` es una cadena y `2` es
 ###### 104. ¿Cuál es el valor?
 
 ```javascript
-Promise.resolve(5)
+Promise.resolve(5);
 ```
 
 - A: `5`
@@ -3332,7 +3329,7 @@ Promise.resolve(5)
 
 Podemos pasar cualquier tipo de valor que queramos a `Promise.resolve`, ya sea una promesa o no promesa. El método en sí mismo devuelve una promesa con el valor resuelto (`<fulfilled>`). Si pasas una función estandar, será una promesa resuelta con un valor normal. Si pasas una promesa, será una promesa resuelta con el valor resuelto de esa promesa pasada.
 
-En este caso, acabamos de pasar el valor numérico `5`. Devuelve una promesa resuelta con el valor `5`. 
+En este caso, acabamos de pasar el valor numérico `5`. Devuelve una promesa resuelta con el valor `5`.
 
 </p>
 </details>
@@ -3344,15 +3341,15 @@ En este caso, acabamos de pasar el valor numérico `5`. Devuelve una promesa res
 ```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)
+compareMembers(person);
 ```
 
 - A: `Not the same!`
@@ -3365,13 +3362,13 @@ compareMembers(person)
 
 #### Answer: B
 
-Los objetos se pasan por referencia. Cuando verificamos la igualdad estricta de los objetos (`===`), estamos comparando sus referencias. 
+Los objetos se pasan por referencia. Cuando verificamos la igualdad estricta de los objetos (`===`), estamos comparando sus referencias.
 
 Establecemos el valor por defecto para `person2` igual al objeto `person`, y pasamos el objeto `person` como el valor de `person1`.
 
 Esto significa que ambos valores tienen una referencia al mismo punto en la memoria, por lo tanto, son iguales.
 
-El bloque de código en la instrucción `else` se ejecuta, y se imprime `They are the same!`. 
+El bloque de código en la instrucción `else` se ejecuta, y se imprime `They are the same!`.
 
 </p>
 </details>
@@ -3387,11 +3384,11 @@ const colorConfig = {
   green: true,
   black: true,
   yellow: false,
-}
+};
 
-const colors = ["pink", "red", "blue"]
+const colors = ["pink", "red", "blue"];
 
-console.log(colorConfig.colors[1])
+console.log(colorConfig.colors[1]);
 ```
 
 - A: `true`
@@ -3404,11 +3401,11 @@ console.log(colorConfig.colors[1])
 
 #### Answer: D
 
-En JavaScript, tenemos dos formas de acceder a las propiedades de un objeto: notación por corchetes o notación por punto. En este ejemplo, usamos la notación por punto (`colorConfig.colors`) en lugar de la notación por corchetes (`colorConfig["colors"]`). 
+En JavaScript, tenemos dos formas de acceder a las propiedades de un objeto: notación por corchetes o notación por punto. En este ejemplo, usamos la notación por punto (`colorConfig.colors`) en lugar de la notación por corchetes (`colorConfig["colors"]`).
 
 Con la notación por punto, JavaScript intenta encontrar la propiedad en el objeto con ese nombre exacto. En este ejemplo, JavaScript intenta encontrar una propiedad llamada `colors` en el objeto `colorConfig`. No hay propiedad llamada `colors`, por lo que devuelve `undefined`. Luego, intentamos acceder al valor del primer elemento usando `[1]`. No podemos hacer esto en un valor que sea `undefined`, por lo que lanza una expeción `TypeError`: `Cannot read property '1' of undefined`.
 
-JavaScript interpreta (o descompone) las sentencias. Cuando usamos la notación por corchetes, ve el primer corchete de apertura `[` y continúa hasta que encuentra el corchete de cierre `]`. Solo entonces, evaluará la declaración. Si hubiéramos utilizado `colorConfig[colors[1]]`, habría devuelto el valor de la propiedad `red` del objeto `colorConfig`. 
+JavaScript interpreta (o descompone) las sentencias. Cuando usamos la notación por corchetes, ve el primer corchete de apertura `[` y continúa hasta que encuentra el corchete de cierre `]`. Solo entonces, evaluará la declaración. Si hubiéramos utilizado `colorConfig[colors[1]]`, habría devuelto el valor de la propiedad `red` del objeto `colorConfig`.
 
 </p>
 </details>
@@ -3418,7 +3415,7 @@ JavaScript interpreta (o descompone) las sentencias. Cuando usamos la notación
 ###### 107. ¿Cuál es el valor?
 
 ```javascript
-console.log('❤️' === '❤️')
+console.log("❤️" === "❤️");
 ```
 
 - A: `true`
@@ -3429,7 +3426,7 @@ console.log('❤️' === '❤️')
 
 #### Answer: A
 
-Bajo el capó, los emojis son caracteres unicode. Los valores unicode para el emoji del corazón son `"U+2764 U+FE0F"`. Estos son siempre los mismos para los mismos emojis, por lo que estamos comparando dos cadenas iguales entre sí, lo que devuelve verdadero. 
+Bajo el capó, los emojis son caracteres unicode. Los valores unicode para el emoji del corazón son `"U+2764 U+FE0F"`. Estos son siempre los mismos para los mismos emojis, por lo que estamos comparando dos cadenas iguales entre sí, lo que devuelve verdadero.
 
 </p>
 </details>
@@ -3439,19 +3436,19 @@ Bajo el capó, los emojis son caracteres unicode. Los valores unicode para el em
 ###### 108. ¿Cuál de estos métodos modifica el array original?
 
 ```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`
 - B: `map` `reduce` `slice` `splice`
-- C: `map` `slice` `splice` 
+- C: `map` `slice` `splice`
 - D: `splice`
 
 <details><summary><b>Solución</b></summary>
@@ -3459,7 +3456,7 @@ emojis.splice(1, 2, '✨')
 
 #### Answer: D
 
-Con el método `splice`, modificamos el array original eliminando, reemplazando o agregando elementos. En este caso, eliminamos 2 elementos desde el índice 1 (eliminamos `'🥑'` y `'😍'`) y agregamos el emoji ✨ en su lugar. 
+Con el método `splice`, modificamos el array original eliminando, reemplazando o agregando elementos. En este caso, eliminamos 2 elementos desde el índice 1 (eliminamos `'🥑'` y `'😍'`) y agregamos el emoji ✨ en su lugar.
 
 `map`, `filter` y `slice` devuelven un nuevo array, `find` devuelve un elemento, y `reduce` devuelve un valor reducido.
 
@@ -3471,17 +3468,17 @@ Con el método `splice`, modificamos el array original eliminando, reemplazando
 ###### <a name=20191009></a>109. ¿Cuál es el resultado?
 
 ```javascript
-const food = ['🍕', '🍫', '🥑', '🍔']
-const info = { favoriteFood: food[0] }
+const food = ["🍕", "🍫", "🥑", "🍔"];
+const info = { favoriteFood: food[0] };
 
-info.favoriteFood = '🍝'
+info.favoriteFood = "🍝";
 
-console.log(food)
+console.log(food);
 ```
 
 - A: `['🍕', '🍫', '🥑', '🍔']`
 - B: `['🍝', '🍫', '🥑', '🍔']`
-- C: `['🍝', '🍕', '🍫', '🥑', '🍔']` 
+- C: `['🍝', '🍕', '🍫', '🥑', '🍔']`
 - D: `ReferenceError`
 
 <details><summary><b>Solución</b></summary>
@@ -3489,7 +3486,7 @@ console.log(food)
 
 #### Answer: A
 
-Establecemos el valor de la propiedad `favoriteFood` en el objeto` info` igual a la cadena con el emoji de la pizza, `'🍕'`. Una cadena es un tipo de dato primitivo. En JavaScript, los tipos de datos primitivos actúan por referencia 
+Establecemos el valor de la propiedad `favoriteFood` en el objeto` info` igual a la cadena con el emoji de la pizza, `'🍕'`. Una cadena es un tipo de dato primitivo. En JavaScript, los tipos de datos primitivos actúan por referencia
 
 En JavaScript, los tipos de datos primitivos (todo aquello que no es un objeto) interactúan por _valor_. En este caso, establecemos el valor de la propiedad `favoriteFood` en el objeto` info` igual al valor del primer elemento en el array `food`, la cadena del emoji de la pizza en este caso (`'🍕'`). Una cadena es un tipo de datos primitivo e interactúa por valor (consulte mi [artículo](https://www.theavocoder.com/complete-javascript/2018/12/21/by-value-vs-by-reference) si estás interesado en aprender más)
 
@@ -3503,7 +3500,7 @@ Luego, cambiamos el valor de la propiedad `favoriteFood` en el objeto` info`. El
 ###### 110. ¿Qué hace este método?
 
 ```javascript
-JSON.parse()
+JSON.parse();
 ```
 
 - A: Parses JSON to a JavaScript value
@@ -3516,20 +3513,20 @@ JSON.parse()
 
 #### Answer: A
 
-Con el método `JSON.parse()`, podemos convertir la cadena de texto en formato JSON a un valor en JavaScript. 
+Con el método `JSON.parse()`, podemos convertir la cadena de texto en formato JSON a un valor en JavaScript.
 
 ```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
+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]
+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' }
+const jsonArray = JSON.stringify({ name: "Lydia" }); // '{"name":"Lydia"}'
+JSON.parse(jsonArray); // { name: 'Lydia' }
 ```
 
 </p>
@@ -3537,17 +3534,17 @@ JSON.parse(jsonArray) // { name: 'Lydia' }
 
 ---
 
-###### 111. ¿Cuál es el resultado? 
+###### 111. ¿Cuál es el resultado?
 
 ```javascript
-let name = 'Lydia'
+let name = "Lydia";
 
 function getName() {
-  console.log(name)
-  let name = 'Sarah'
+  console.log(name);
+  let name = "Sarah";
 }
 
-getName()
+getName();
 ```
 
 - A: Lydia
@@ -3560,20 +3557,20 @@ getName()
 
 #### Answer: D
 
-Cada función tiene su propio _contexto de ejecución_ (o _ámbito_). La función `getName` primero mira dentro de su propio contexto (ámbito) para ver si contiene la variable `name` a la que estamos intentando acceder. En este caso, la función `getName` contiene su propia variable `name`: declaramos la variable `name` con la palabra clave` let`, y con el valor de `'Sarah'`. 
+Cada función tiene su propio _contexto de ejecución_ (o _ámbito_). La función `getName` primero mira dentro de su propio contexto (ámbito) para ver si contiene la variable `name` a la que estamos intentando acceder. En este caso, la función `getName` contiene su propia variable `name`: declaramos la variable `name` con la palabra clave` let`, y con el valor de `'Sarah'`.
 
-Las variables con la palabra clave `let` (y `const`) se mueven al comienzo (hoisting), pero a diferencia de `var`, no se <i>inicializan</i>. No son accesibles antes de la línea en la que las declaramos (inicializamos). Esto se llama la "zona muerta temporal". Cuando intentamos acceder a las variables antes de que se declaren, JavaScript genera una excepción del tipo `ReferenceError`. 
+Las variables con la palabra clave `let` (y `const`) se mueven al comienzo (hoisting), pero a diferencia de `var`, no se <i>inicializan</i>. No son accesibles antes de la línea en la que las declaramos (inicializamos). Esto se llama la "zona muerta temporal". Cuando intentamos acceder a las variables antes de que se declaren, JavaScript genera una excepción del tipo `ReferenceError`.
 
-Si no hubiéramos declarado la variable `name` dentro de la función `getName`, el motor de JavaScript habría mirado hacia abajo _ámbito encadenado_. El alcance externo tiene una variable llamada `name` con el valor de `Lydia`. En ese caso, habría imprimido `Lydia`. 
+Si no hubiéramos declarado la variable `name` dentro de la función `getName`, el motor de JavaScript habría mirado hacia abajo _ámbito encadenado_. El alcance externo tiene una variable llamada `name` con el valor de `Lydia`. En ese caso, habría imprimido `Lydia`.
 
 ```javascript
-let name = 'Lydia'
+let name = "Lydia";
 
 function getName() {
-  console.log(name)
+  console.log(name);
 }
 
-getName() // Lydia
+getName(); // Lydia
 ```
 
 </p>
@@ -3585,18 +3582,18 @@ 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()
-const two = generatorTwo()
+const one = generatorOne();
+const two = generatorTwo();
 
-console.log(one.next().value)
-console.log(two.next().value)
+console.log(one.next().value);
+console.log(two.next().value);
 ```
 
 - A: `a` y `a`
@@ -3614,17 +3611,17 @@ Con la palabra clave `yield`, cedemos valores en una función generadora. Con la
 En la función `generatorOne`, cedemos todo el array `['a', 'b', 'c']` usando la palabra clave `yield`. El valor de la propiedad `value` en el objeto devuelto por el método `next` en `one` (`one.next().value`) es igual a todo el array `['a', 'b', 'c']`.
 
 ```javascript
-console.log(one.next().value) // ['a', 'b', 'c']
-console.log(one.next().value) // undefined
+console.log(one.next().value); // ['a', 'b', 'c']
+console.log(one.next().value); // undefined
 ```
 
-En la función `generatorTwo`, usamos la palabra clave `yield*`. Esto significa que el primer valor cedido de `two` es igual al primer valor cedido en el iterador. El iterador es el array `['a', 'b', 'c']`. El primer valor producido es `a`, por lo que la primera vez que llamamos a `two.next().value`, se devuelve `a`. 
+En la función `generatorTwo`, usamos la palabra clave `yield*`. Esto significa que el primer valor cedido de `two` es igual al primer valor cedido en el iterador. El iterador es el array `['a', 'b', 'c']`. El primer valor producido es `a`, por lo que la primera vez que llamamos a `two.next().value`, se devuelve `a`.
 
 ```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
+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>
@@ -3635,7 +3632,7 @@ console.log(two.next().value) // undefined
 ###### 113. ¿Cuál es el resultado?
 
 ```javascript
-console.log(`${(x => x)('I love')} to program`)
+console.log(`${((x) => x)("I love")} to program`);
 ```
 
 - A: `I love to program`
@@ -3648,7 +3645,7 @@ console.log(`${(x => x)('I love')} to program`)
 
 #### Answer: A
 
-Las expresiones dentro de las plantillas de cadena de texto se evalúan primero. Esto significa que la cadena contendrá el valor devuelto de la expresión, la función invocada inmediatamente `(x => x)('I love')` en este caso. Pasamos el valor `'I love'` como argumento para la función de flecha `x => x`. `x` es igual a `'I love'`, que se devuelve tal cual. Esto da como resultado `I love to program`. 
+Las expresiones dentro de las plantillas de cadena de texto se evalúan primero. Esto significa que la cadena contendrá el valor devuelto de la expresión, la función invocada inmediatamente `(x => x)('I love')` en este caso. Pasamos el valor `'I love'` como argumento para la función de flecha `x => x`. `x` es igual a `'I love'`, que se devuelve tal cual. Esto da como resultado `I love to program`.
 
 </p>
 </details>
@@ -3660,11 +3657,11 @@ Las expresiones dentro de las plantillas de cadena de texto se evalúan primero.
 ```javascript
 let config = {
   alert: setInterval(() => {
-    console.log('Alert!')
-  }, 1000)
-}
+    console.log("Alert!");
+  }, 1000),
+};
 
-config = null
+config = null;
 ```
 
 - A: The `setInterval` callback won't be invoked
@@ -3687,17 +3684,17 @@ Normalmente, cuando establecemos objetos iguales a `null`, esos objetos se recog
 ###### 115. ¿Qué método(s) devolverá el valor `'Hello world!'`?
 
 ```javascript
-const myMap = new Map()
-const myFunc = () => 'greeting'
+const myMap = new Map();
+const myFunc = () => "greeting";
 
-myMap.set(myFunc, 'Hello world!')
+myMap.set(myFunc, "Hello world!");
 
 //1
-myMap.get('greeting')
+myMap.get("greeting");
 //2
-myMap.get(myFunc)
+myMap.get(myFunc);
 //3
-myMap.get(() => 'greeting')
+myMap.get(() => "greeting");
 ```
 
 - A: 1
@@ -3710,10 +3707,10 @@ myMap.get(() => 'greeting')
 
 #### Answer: B
 
-Al agregar un par clave/valor utilizando el método `set`, la clave será el valor del primer argumento pasado a la función `set`, y el valor será el segundo argumento pasado a la función `set`. La clave es la _función_ `() => 'greeting'` en este caso, y el valor `'Hello world'`. `myMap` ahora es `{ () => 'greeting' => 'Hello world!' }`. 
+Al agregar un par clave/valor utilizando el método `set`, la clave será el valor del primer argumento pasado a la función `set`, y el valor será el segundo argumento pasado a la función `set`. La clave es la _función_ `() => 'greeting'` en este caso, y el valor `'Hello world'`. `myMap` ahora es `{ () => 'greeting' => 'Hello world!' }`.
 
 1 es incorrecto, ya que la clave no es `'greeting'` sino `() => 'greeting'`.
-3 es incorrecto, ya que estamos creando una nueva función pasándola como parámetro al método `get`. El objeto interactúa por _referencia_. Las funciones son objetos, por eso dos funciones nunca son estrictamente iguales, aunque sean idénticas: tienen una referencia a un punto diferente en la memoria. 
+3 es incorrecto, ya que estamos creando una nueva función pasándola como parámetro al método `get`. El objeto interactúa por _referencia_. Las funciones son objetos, por eso dos funciones nunca son estrictamente iguales, aunque sean idénticas: tienen una referencia a un punto diferente en la memoria.
 
 </p>
 </details>
@@ -3725,19 +3722,19 @@ Al agregar un par clave/valor utilizando el método `set`, la clave será el val
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21
-}
+  age: 21,
+};
 
-const changeAge = (x = { ...person }) => x.age += 1
+const changeAge = (x = { ...person }) => (x.age += 1);
 const changeAgeAndName = (x = { ...person }) => {
-  x.age += 1
-  x.name = "Sarah"
-}
+  x.age += 1;
+  x.name = "Sarah";
+};
 
-changeAge(person)
-changeAgeAndName()
+changeAge(person);
+changeAgeAndName();
 
-console.log(person)
+console.log(person);
 ```
 
 - A: `{name: "Sarah", age: 22}`
@@ -3750,7 +3747,7 @@ console.log(person)
 
 #### Answer: C
 
-Tanto las funciones `changeAge` como `changeAgeAndName` tienen un parámetro por defecto, a saber, un objeto _nuevo_ creado `{ ...person }`. Este objeto tiene copias de todos los pares clave/valor en el objeto `person`. 
+Tanto las funciones `changeAge` como `changeAgeAndName` tienen un parámetro por defecto, a saber, un objeto _nuevo_ creado `{ ...person }`. Este objeto tiene copias de todos los pares clave/valor en el objeto `person`.
 
 Primero, invocamos la función `changeAge` y le pasamos el objeto `person` como argumento. Esta función aumenta el valor de la propiedad `age` en 1. `person` ahora es `{name: "Lydia", age: 22}`.
 
diff --git a/fr-FR/README_fr-FR.md b/fr-FR/README_fr-FR.md
index cce10323..cbdbee30 100644
--- a/fr-FR/README_fr-FR.md
+++ b/fr-FR/README_fr-FR.md
@@ -19,6 +19,7 @@ Les réponses se trouvent dans les sections repliées en dessous des questions,
 - [🇳🇱 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)
@@ -100,7 +101,7 @@ const shape = {
   diameter() {
     return this.radius * 2;
   },
-  perimeter: () => 2 * Math.PI * this.radius
+  perimeter: () => 2 * Math.PI * this.radius,
 };
 
 shape.diameter();
@@ -157,12 +158,12 @@ La chaîne de caractère `'Lydia'` est une valeur considérée comme vraie _(tru
 
 ```javascript
 const bird = {
-  size: "small"
+  size: "small",
 };
 
 const mouse = {
   name: "Mickey",
-  small: true
+  small: true,
 };
 ```
 
@@ -358,7 +359,7 @@ function Person(firstName, lastName) {
 }
 
 const member = new Person("Lydia", "Hallie");
-Person.getFullName = function() {
+Person.getFullName = function () {
   return `${this.firstName} ${this.lastName}`;
 };
 
@@ -378,7 +379,7 @@ console.log(member.getFullName());
 Vous ne pouvez pas ajouter de propriétés à un constructeur comme pour des objets normaux. Si vous voulez ajouter une fonctionnalité pour tous les objets en une fois, vous devez utiliser le prototype. Donc dans ce cas,
 
 ```js
-Person.prototype.getFullName = function() {
+Person.prototype.getFullName = function () {
   return `${this.firstName} ${this.lastName}`;
 };
 ```
@@ -834,7 +835,7 @@ String.prototype.giveLydiaPizza = () => {
 
 const name = "Lydia";
 
-console.log(name.giveLydiaPizza())
+console.log(name.giveLydiaPizza());
 ```
 
 - A: `"Just give Lydia pizza already!"`
@@ -946,9 +947,7 @@ C'est ici qu'une boucle d'événement commence à fonctionner. La **boucle d'év
 ```html
 <div onclick="console.log('first div')">
   <div onclick="console.log('second div')">
-    <button onclick="console.log('button')">
-      Click!
-    </button>
+    <button onclick="console.log('button')">Click!</button>
   </div>
 </div>
 ```
@@ -974,9 +973,7 @@ L'élément imbriqué le plus profond qui a provoqué l'événement est la cible
 
 ```html
 <div onclick="console.log('div')">
-  <p onclick="console.log('p')">
-    Click here!
-  </p>
+  <p onclick="console.log('p')">Click here!</p>
 </div>
 ```
 
@@ -1201,7 +1198,7 @@ JavaScript n'a que des types et des objets primitifs.
 
 Les types primitifs sont `boolean`, `null`, `undefined`, `bigint`, `number`, `string` et `symbol`.
 
-Ce qui différencie une primitive d'un objet, c'est que les primitives n'ont aucune propriété ou méthode. Cependant, vous remarquerez que  `'foo'.toUpperCase()` est évalué à `'FOO'` et n'entraîne pas de `TypeError`. En effet, lorsque vous essayez d'accéder à une propriété ou à une méthode sur une primitive telle qu'une chaîne, JavaScript encapsule implicitement l'objet à l'aide de l'une des classes d'encapsulation, à savoir `String`, puis supprime immédiatement l'encapsulation après l'évaluation de l'expression. Toutes les primitives à l'exception de `null` et` undefined` présentent ce comportement.
+Ce qui différencie une primitive d'un objet, c'est que les primitives n'ont aucune propriété ou méthode. Cependant, vous remarquerez que `'foo'.toUpperCase()` est évalué à `'FOO'` et n'entraîne pas de `TypeError`. En effet, lorsque vous essayez d'accéder à une propriété ou à une méthode sur une primitive telle qu'une chaîne, JavaScript encapsule implicitement l'objet à l'aide de l'une des classes d'encapsulation, à savoir `String`, puis supprime immédiatement l'encapsulation après l'évaluation de l'expression. Toutes les primitives à l'exception de `null` et` undefined` présentent ce comportement.
 
 </p>
 </details>
@@ -1211,7 +1208,10 @@ Ce qui différencie une primitive d'un objet, c'est que les primitives n'ont auc
 ###### 40. Quelle est la sortie ?
 
 ```javascript
-[[0, 1], [2, 3]].reduce(
+[
+  [0, 1],
+  [2, 3],
+].reduce(
   (acc, cur) => {
     return acc.concat(cur);
   },
@@ -1359,7 +1359,7 @@ const secondPromise = new Promise((res, rej) => {
   setTimeout(res, 100, "two");
 });
 
-Promise.race([firstPromise, secondPromise]).then(res => console.log(res));
+Promise.race([firstPromise, secondPromise]).then((res) => console.log(res));
 ```
 
 - A: `"one"`
@@ -1423,7 +1423,7 @@ Nous modifions seulement la valeur de la variable `person`, et non le premier é
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21
+  age: 21,
 };
 
 for (const item in person) {
@@ -1503,7 +1503,7 @@ Seuls les premiers nombres de la chaîne sont renvoyés. Basé sur la base dix (
 ###### 50. Quelle est la sortie ?
 
 ```javascript
-[1, 2, 3].map(num => {
+[1, 2, 3].map((num) => {
   if (typeof num === "number") return;
   return num * 2;
 });
@@ -1680,7 +1680,7 @@ class Dog {
   }
 }
 
-Dog.prototype.bark = function() {
+Dog.prototype.bark = function () {
   console.log(`Woof I am ${this.name}`);
 };
 
@@ -1908,7 +1908,7 @@ Les propriétés ajoutées à l'aide de la méthode `defineProperty` sont immuab
 const settings = {
   username: "lydiahallie",
   level: 19,
-  health: 90
+  health: 90,
 };
 
 const data = JSON.stringify(settings, ["level", "health"]);
@@ -1942,7 +1942,7 @@ Si le remplaçant est une _fonction_, cette fonction est appelée sur chaque pro
 let num = 10;
 
 const increaseNumber = () => num++;
-const increasePassedNumber = number => number++;
+const increasePassedNumber = (number) => number++;
 
 const num1 = increaseNumber();
 const num2 = increasePassedNumber(num1);
@@ -1963,7 +1963,7 @@ console.log(num2);
 
 L'opérateur arithmétique `++` _renvoie en premier_ la valeur de l'opérande, _puis incrémente_ la valeur de l'opérande. La valeur de `num1` est égale à `10`, puisque la fonction `increaseNumber` renvoie d'abord la valeur de `num`, qui correspond à `10`, et augmente la valeur de `num` par la suite.
 
-`num2` est égal à `10`, puisque nous avons passé `num1` à la commande `increasePassedNumber`. `number` est égal à `10` (la valeur de `num1`). Encore une fois, l'opérateur arithmétique `++` _renvoie d'abord_ la valeur de l'opérande, puis incrémente_ la valeur de l'opérande. La valeur de `nombre` est `10`, donc `num2` est égal à `10`.
+`num2` est égal à `10`, puisque nous avons passé `num1` à la commande `increasePassedNumber`. `number` est égal à `10` (la valeur de `num1`). Encore une fois, l'opérateur arithmétique `++` _renvoie d'abord_ la valeur de l'opérande, puis incrémente\_ la valeur de l'opérande. La valeur de `nombre` est `10`, donc `num2` est égal à `10`.
 
 </p>
 </details>
@@ -1997,7 +1997,7 @@ multiply(value);
 
 Dans ES6, nous pouvons initialiser les paramètres avec une valeur par défaut. La valeur du paramètre sera la valeur par défaut, si aucune autre valeur n'a été passée à la fonction, ou si la valeur du paramètre est `"undefined"`. Dans ce cas, nous répartissons les propriétés de l'objet `value` dans un nouvel objet, donc `x` a la valeur par défaut `{number: 10}`.
 
-L'argument par défaut est évalué at _call time_! Chaque fois que nous appelons la fonction, un a _new_ object  créé. Nous invoquons la fonction `multiply` les deux premières fois sans passer de valeur: `x` a la valeur par défaut `{number: 10}`. Nous enregistrons ensuite la valeur multipliée de ce nombre, qui est `20`.
+L'argument par défaut est évalué at _call time_! Chaque fois que nous appelons la fonction, un a _new_ object créé. Nous invoquons la fonction `multiply` les deux premières fois sans passer de valeur: `x` a la valeur par défaut `{number: 10}`. Nous enregistrons ensuite la valeur multipliée de ce nombre, qui est `20`.
 
 La troisième fois que nous invoquons multiplier, nous passons un argument: l'objet appelé `value`. L'opérateur `* =` est en fait un raccourci pour `x.number = x.number * 2`: nous modifions la valeur de `x.number`, et enregistrons la valeur multipliée `20`.
 
diff --git a/id-ID/README.md b/id-ID/README.md
index 26a566cc..3da87c42 100644
--- a/id-ID/README.md
+++ b/id-ID/README.md
@@ -1,10 +1,10 @@
 <h1>Pertanyaan JavaScript</h1>
 
-  ---
+---
 
-  <span>Saya post pertanyaan pilihan ganda ke [Instagram](https://www.instagram.com/theavocoder) **stories** saya, yang saya post juga di sini ! update terakhir: <a href=#20191224><b>December 24th</b></a>
+<span>Saya post pertanyaan pilihan ganda ke [Instagram](https://www.instagram.com/theavocoder) **stories** saya, yang saya post juga di sini ! update terakhir: <a href=#20191224><b>December 24th</b></a>
 
-  Mulai tingkat dasar ke mahir: tes seberapa paham kamu tentang javascript, segarkan sedikit pengetahuan kamu, atau bersiap-siap untuk coding interview kamu! :muscle: :rocket: Saya update repo ini secara berkala dengan pertanyaan baru. Saya masukkan jawaban dibagian yang **tersembunyi** di bawah pertanyaan, cukup klik pada bagian itu untuk menampilkannya. Pertanyaan ini hanya untuk bersenang-senang, Semoga berhasil :heart:</span>
+Mulai tingkat dasar ke mahir: tes seberapa paham kamu tentang javascript, segarkan sedikit pengetahuan kamu, atau bersiap-siap untuk coding interview kamu! :muscle: :rocket: Saya update repo ini secara berkala dengan pertanyaan baru. Saya masukkan jawaban dibagian yang **tersembunyi** di bawah pertanyaan, cukup klik pada bagian itu untuk menampilkannya. Pertanyaan ini hanya untuk bersenang-senang, Semoga berhasil :heart:</span>
 
 Jangan sungkan untuk terhubung dengan saya! 😊 <br />
 <a href="https://www.instagram.com/theavocoder">Instagram</a> || <a href="https://www.twitter.com/lydiahallie">Twitter</a> || <a href="https:/www.linkedin.com/in/lydia-hallie">LinkedIn</a> || <a href="www.lydiahallie.dev">Blog</a>
@@ -29,6 +29,7 @@ Jangan sungkan untuk terhubung dengan saya! 😊 <br />
 - [🇳🇱 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)
@@ -49,7 +50,7 @@ Jangan sungkan untuk terhubung dengan saya! 😊 <br />
 function sayHi() {
   console.log(name);
   console.log(age);
-  var name = 'Lydia';
+  var name = "Lydia";
   let age = 21;
 }
 
@@ -69,6 +70,7 @@ sayHi();
 Di dalam function, kita membuat sebuah variabel `name` dan variabel tersebut di deklarasikan menggunakan `var`. Artinya variable tersebut di hoisting (dalam fase pembuatan ini menggunakan memory penyimpanan) dengan isi standar-nya `undefined`, saat javascript mengeksekusi baris code pembuatan variabel-nya. variabel `name` isinya masih undefined, jadi isi dari variabel tersebut `undefined`
 
 Mendeklarasikan varibel menggunakan `let` (dan `const`) juga terkena hoisting, tidak seperti `var`, variabel declaration `let` dan `const` tidak ditentukan isi standar-nya. `let` dan `const` tidak bisa diakses sebelum di tentukan dulu isi-nya. Kejadian ini disebut "temporal dead zone". Saat kita mencoba memanggil variabel yang belum ditentukan isi-nya, Javascript mengeluarkan error `ReferenceError`.
+
 </p>
 </details>
 
@@ -95,9 +97,10 @@ for (let i = 0; i < 3; i++) {
 
 #### Jawaban: C
 
-Karena antrean peristiwa di JavaScript, fungsi callback `setTimeout` disebut _after_ loop telah dijalankan. Karena variabel `i` di loop pertama dideklarasikan menggunakan kata kunci` var`, nilai ini adalah global. Selama perulangan, kita menambah nilai `i` sebesar `1` setiap kali, menggunakan operator unary` ++ `. Pada saat fungsi callback `setTimeout` dipanggil,` i` sama dengan `3` di contoh pertama.
+Karena antrean peristiwa di JavaScript, fungsi callback `setTimeout` disebut _after_ loop telah dijalankan. Karena variabel `i` di loop pertama dideklarasikan menggunakan kata kunci` var`, nilai ini adalah global. Selama perulangan, kita menambah nilai `i` sebesar `1` setiap kali, menggunakan operator unary`++`. Pada saat fungsi callback `setTimeout` dipanggil,` i` sama dengan `3` di contoh pertama.
 
 Pada perulangan kedua, variabel `i` dideklarasikan menggunakan kata kunci` let`: variabel yang dideklarasikan dengan kata kunci `let` (dan` const`) memiliki cakupan blok (blok adalah apa saja di antara `{}`). Selama setiap iterasi, `i` akan memiliki nilai baru, dan setiap nilai dicakup di dalam loop.
+
 </p>
 </details>
 
@@ -143,7 +146,7 @@ Tidak ada nilai 'radius' pada objek itu, yang mengembalikan 'tidak ditentukan'.
 
 ```javascript
 +true;
-!'Lydia';
+!"Lydia";
 ```
 
 - A: `1` dan `false`
@@ -157,8 +160,7 @@ Tidak ada nilai 'radius' pada objek itu, yang mengembalikan 'tidak ditentukan'.
 
 Tia unary plus mencoba mengonversi operan menjadi angka. `true` adalah` 1`, dan `false` adalah` 0`.
 
-String "'Lydia'` adalah nilai yang benar. Apa yang sebenarnya kami tanyakan adalah "apakah nilai kebenaran ini salah?". Ini mengembalikan `salah`.
-
+String "'Lydia'`adalah nilai yang benar. Apa yang sebenarnya kami tanyakan adalah "apakah nilai kebenaran ini salah?". Ini mengembalikan`salah`.
 
 </p>
 </details>
@@ -169,11 +171,11 @@ String "'Lydia'` adalah nilai yang benar. Apa yang sebenarnya kami tanyakan adal
 
 ```javascript
 const bird = {
-  size: 'small',
+  size: "small",
 };
 
 const mouse = {
-  name: 'Mickey',
+  name: "Mickey",
   small: true,
 };
 ```
@@ -187,6 +189,7 @@ const mouse = {
 <p>
 
 #### Jawaban: A
+
 Pada JavaScript, semua kunci objek adalah string (kecuali jika itu berupa Simbol). Meskipun kita mungkin tidak mengetiknya sebagai string, tetap saja mereka selalu berubah menjadi string didalamnya.
 
 JavaScript menginterpretasikan (atau membuka) pernyataan-pernyataan. Saat kita menggunakan notasi kurung siku, ia melihat kurung buka pertama `[` dan terus berjalan sampai menemukan kurung tutup `]`. Baru setelah itu akan mengevaluasi pernyataannya. `mouse[bird.size]`: Pertama, ini mengevaluasi `bird.size`, yang mana `"small"`. `mouse["small"]` mengembalikan nilai `true`.
@@ -201,11 +204,11 @@ Namun, dengan notasi dot (.), hal ini tidak terjadi. `mouse` tidak memiliki kunc
 ###### 6. Apa yang akan tampil?
 
 ```javascript
-let c = { greeting: 'Hey!' };
+let c = { greeting: "Hey!" };
 let d;
 
 d = c;
-c.greeting = 'Hello';
+c.greeting = "Hello";
 console.log(d.greeting);
 ```
 
@@ -275,13 +278,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`
@@ -331,10 +334,10 @@ Untuk menghindari hal ini, kita bisa menggunakan `" use strict "`. Ini memastika
 
 ```javascript
 function bark() {
-  console.log('Woof!');
+  console.log("Woof!");
 }
 
-bark.animal = 'dog';
+bark.animal = "dog";
 ```
 
 - A: Nothing, this is totally fine!
@@ -364,8 +367,8 @@ function Person(firstName, lastName) {
   this.lastName = lastName;
 }
 
-const member = new Person('Lydia', 'Hallie');
-Person.getFullName = function() {
+const member = new Person("Lydia", "Hallie");
+Person.getFullName = function () {
   return `${this.firstName} ${this.lastName}`;
 };
 
@@ -385,7 +388,7 @@ console.log(member.getFullName());
 Anda tidak dapat menambahkan properti ke constructor seperti yang Anda lakukan dengan objek biasa. Jika Anda ingin menambahkan fitur ke semua objek sekaligus, Anda harus menggunakan prototipe sebagai gantinya. Jadi dalam kasus ini:
 
 ```js
-Person.prototype.getFullName = function() {
+Person.prototype.getFullName = function () {
   return `${this.firstName} ${this.lastName}`;
 };
 ```
@@ -405,8 +408,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);
@@ -476,7 +479,7 @@ function sum(a, b) {
   return a + b;
 }
 
-sum(1, '2');
+sum(1, "2");
 ```
 
 - A: `NaN`
@@ -543,7 +546,7 @@ function getPersonInfo(one, two, three) {
   console.log(three);
 }
 
-const person = 'Lydia';
+const person = "Lydia";
 const age = 21;
 
 getPersonInfo`${person} is ${age} years old`;
@@ -570,9 +573,9 @@ Jika Anda menggunakan literal template yang diberi tag, nilai argumen pertama se
 ```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`);
   }
@@ -632,7 +635,7 @@ Parameter sisanya (`... args`.) Memungkinkan kita "mengumpulkan" semua argumen y
 
 ```javascript
 function getAge() {
-  'use strict';
+  "use strict";
   age = 21;
   console.log(age);
 }
@@ -660,7 +663,7 @@ Dengan `" use strict "`, Anda dapat memastikan bahwa Anda tidak mendeklarasikan
 ###### 21. What's value of `sum`?
 
 ```javascript
-const sum = eval('10*10+5');
+const sum = eval("10*10+5");
 ```
 
 - A: `105`
@@ -683,7 +686,7 @@ const sum = eval('10*10+5');
 ###### 22. Sampai berapa lama kah cool_secret dapat diakses?
 
 ```javascript
-sessionStorage.setItem('cool_secret', 123);
+sessionStorage.setItem("cool_secret", 123);
 ```
 
 - A: Selamanya, data tersebut tidak akan hilang.
@@ -736,12 +739,12 @@ Anda tidak dapat melakukan ini dengan `let` atau `const` karena mereka block-sco
 ###### 24. Apa yang akan tampil?
 
 ```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);
 ```
 
@@ -767,7 +770,7 @@ It doesn't work that way for a set. There is no `'1'` in our set: `set.has('1')`
 ###### 25. Apa yang akan tampil?
 
 ```javascript
-const obj = { a: 'one', b: 'two', a: 'three' };
+const obj = { a: "one", b: "two", a: "three" };
 console.log(obj);
 ```
 
@@ -836,12 +839,12 @@ Pernyataan `continue` melewatkan iterasi jika kondisi tertentu mengembalikan `tr
 
 ```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())
+console.log(name.giveLydiaPizza());
 ```
 
 - A: `"Just give Lydia pizza already!"`
@@ -865,8 +868,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;
@@ -898,9 +901,9 @@ Then, we log `a[b]`, which is actually `a["object Object"]`. We just set that to
 ###### 30. Apa yang akan tampil?
 
 ```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();
@@ -953,9 +956,7 @@ Di sinilah serangkaian acara mulai bekerja. Sebuah **event loop** (putaran kejad
 ```html
 <div onclick="console.log('first div')">
   <div onclick="console.log('second div')">
-    <button onclick="console.log('button')">
-      Click!
-    </button>
+    <button onclick="console.log('button')">Click!</button>
   </div>
 </div>
 ```
@@ -981,9 +982,7 @@ The deepest nested element that caused the event is the target of the event. You
 
 ```html
 <div onclick="console.log('div')">
-  <p onclick="console.log('p')">
-    Click here!
-  </p>
+  <p onclick="console.log('p')">Click here!</p>
 </div>
 ```
 
@@ -1007,7 +1006,7 @@ If we click `p`, we see two logs: `p` and `div`. During event propagation, there
 ###### 33. Apa yang akan tampil?
 
 ```javascript
-const person = { name: 'Lydia' };
+const person = { name: "Lydia" };
 
 function sayHi(age) {
   return `${this.name} is ${age}`;
@@ -1070,8 +1069,8 @@ FYI: there are only 7 built-in types: `null`, `undefined`, `boolean`, `number`,
 ```javascript
 0;
 new Number(0);
-('');
-(' ');
+("");
+(" ");
 new Boolean(false);
 undefined;
 ```
@@ -1218,11 +1217,14 @@ What differentiates a primitive from an object is that primitives do not have an
 ###### 40. Apa yang akan tampil?
 
 ```javascript
-[[0, 1], [2, 3]].reduce(
+[
+  [0, 1],
+  [2, 3],
+].reduce(
   (acc, cur) => {
     return acc.concat(cur);
   },
-  [1, 2],
+  [1, 2]
 );
 ```
 
@@ -1249,7 +1251,7 @@ Then, `[1, 2, 0, 1]` is `acc` and `[2, 3]` is `cur`. We concatenate them, and ge
 
 ```javascript
 !!null;
-!!'';
+!!"";
 !!1;
 ```
 
@@ -1277,7 +1279,7 @@ Then, `[1, 2, 0, 1]` is `acc` and `[2, 3]` is `cur`. We concatenate them, and ge
 ###### 42. What does the `setInterval` method return in the browser?
 
 ```javascript
-setInterval(() => console.log('Hi'), 1000);
+setInterval(() => console.log("Hi"), 1000);
 ```
 
 - A: a unique id
@@ -1300,7 +1302,7 @@ Itu adalah mengembalikan sebuah id unik. id unik dapat digunakan untuk menghapus
 ###### 43. What does this return?
 
 ```javascript
-[...'Lydia'];
+[..."Lydia"];
 ```
 
 - A: `["L", "y", "d", "i", "a"]`
@@ -1359,14 +1361,14 @@ 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));
+Promise.race([firstPromise, secondPromise]).then((res) => console.log(res));
 ```
 
 - A: `"one"`
@@ -1389,7 +1391,7 @@ When we pass multiple promises to the `Promise.race` method, it resolves/rejects
 ###### 46. Apa yang akan tampil?
 
 ```javascript
-let person = { name: 'Lydia' };
+let person = { name: "Lydia" };
 const members = [person];
 person = null;
 
@@ -1429,7 +1431,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,
 };
 
@@ -1458,7 +1460,7 @@ With a `for-in` loop, we can iterate through object keys, in this case `name` an
 ###### 48. Apa yang akan tampil?
 
 ```javascript
-console.log(3 + 4 + '5');
+console.log(3 + 4 + "5");
 ```
 
 - A: `"345"`
@@ -1485,7 +1487,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`
@@ -1510,8 +1512,8 @@ Only the first numbers in the string is returned. Based on the _radix_ (the seco
 ###### 50. What's the output`?
 
 ```javascript
-[1, 2, 3].map(num => {
-  if (typeof num === 'number') return;
+[1, 2, 3].map((num) => {
+  if (typeof num === "number") return;
   return num * 2;
 });
 ```
@@ -1539,12 +1541,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);
 
@@ -1576,15 +1578,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);
   }
 }
 
@@ -1614,8 +1616,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();
@@ -1687,11 +1689,11 @@ class Dog {
   }
 }
 
-Dog.prototype.bark = function() {
+Dog.prototype.bark = function () {
   console.log(`Woof I am ${this.name}`);
 };
 
-const pet = new Dog('Mara');
+const pet = new Dog("Mara");
 
 pet.bark();
 
@@ -1756,7 +1758,7 @@ export default counter;
 
 ```javascript
 // index.js
-import myCounter from './counter';
+import myCounter from "./counter";
 
 myCounter += 1;
 
@@ -1777,7 +1779,6 @@ Modul yang diimpor adalah _read-only_: Anda tidak dapat mengubah modul yang diim
 
 Ketika kita mencoba untuk menambah nilai `myCounter`, itu melemparkan kesalahan: `myCounter` adalah baca-saja dan tidak dapat dimodifikasi.
 
-
 </p>
 </details>
 
@@ -1786,7 +1787,7 @@ Ketika kita mencoba untuk menambah nilai `myCounter`, itu melemparkan kesalahan:
 ###### 58. Apa yang akan tampil?
 
 ```javascript
-const name = 'Lydia';
+const name = "Lydia";
 age = 21;
 
 console.log(delete name);
@@ -1857,7 +1858,7 @@ This means that the value of `y` is equal to the first value in the array, which
 ###### 60. Apa yang akan tampil?
 
 ```javascript
-const user = { name: 'Lydia', age: 21 };
+const user = { name: "Lydia", age: 21 };
 const admin = { admin: true, ...user };
 
 console.log(admin);
@@ -1883,9 +1884,9 @@ It's possible to combine objects using the spread operator `...`. It lets you cr
 ###### 61. Apa yang akan tampil?
 
 ```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));
@@ -1914,12 +1915,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);
 ```
 
@@ -1950,7 +1951,7 @@ If the replacer is a _function_, this function gets called on every property in
 let num = 10;
 
 const increaseNumber = () => num++;
-const increasePassedNumber = number => number++;
+const increasePassedNumber = (number) => number++;
 
 const num1 = increaseNumber();
 const num2 = increasePassedNumber(num1);
@@ -2106,12 +2107,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;
 ```
 
@@ -2139,7 +2140,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`
@@ -2162,7 +2163,7 @@ Every Symbol is entirely unique. The purpose of the argument passed to the Symbo
 ###### 69. Apa yang akan tampil?
 
 ```javascript
-const name = 'Lydia Hallie';
+const name = "Lydia Hallie";
 console.log(name.padStart(13));
 console.log(name.padStart(2));
 ```
@@ -2189,7 +2190,7 @@ If the argument passed to the `padStart` method is smaller than the length of th
 ###### 70. Apa yang akan tampil?
 
 ```javascript
-console.log('🥑' + '💻');
+console.log("🥑" + "💻");
 ```
 
 - A: `"🥑💻"`
@@ -2213,11 +2214,11 @@ With the `+` operator, you can concatenate strings. In this case, we are concate
 
 ```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 gone here";
   }
-  return 'JavaScript loves you back ❤️';
+  return "JavaScript loves you back ❤️";
 }
 
 const game = startGame();
@@ -2285,7 +2286,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();
@@ -2322,7 +2323,7 @@ function addToList(item, list) {
   return list.push(item);
 }
 
-const result = addToList('apple', ['banana']);
+const result = addToList("apple", ["banana"]);
 console.log(result);
 ```
 
@@ -2382,7 +2383,7 @@ Since `shape` is frozen, and since the value of `x` is not an object, we cannot
 ###### 76. Apa yang akan tampil?
 
 ```javascript
-const { name: myName } = { name: 'Lydia' };
+const { name: myName } = { name: "Lydia" };
 
 console.log(name);
 ```
@@ -2438,7 +2439,7 @@ The `sum` function always returns the same result. If we pass `1` and `2`, it wi
 ```javascript
 const add = () => {
   const cache = {};
-  return num => {
+  return (num) => {
     if (num in cache) {
       return `From cache! ${cache[num]}`;
     } else {
@@ -2483,7 +2484,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);
@@ -2579,13 +2580,13 @@ Pada kasus ini, juka kita tidak mengisi nilai atau mengisi `undefined`, `name` a
 ###### 82. What is the output?
 
 ```javascript
-var status = '😎';
+var status = "😎";
 
 setTimeout(() => {
-  const status = '😍';
+  const status = "😍";
 
   const data = {
-    status: '🥑',
+    status: "🥑",
     getStatus() {
       return this.status;
     },
@@ -2619,12 +2620,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);
 ```
@@ -2688,9 +2689,9 @@ Variables with the `const` and `let` keyword are _block-scoped_. A block is anyt
 ###### 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))
+fetch("https://www.website.com/api/user/1")
+  .then((res) => res.json())
+  .then((res) => console.log(res));
 ```
 
 - A: The result of the `fetch` method.
@@ -2744,7 +2745,7 @@ By setting `hasName` equal to `name`, you set `hasName` equal to whatever value
 ###### 87. Apa yang akan tampil?
 
 ```javascript
-console.log('I want pizza'[0]);
+console.log("I want pizza"[0]);
 ```
 
 - A: `"""`
@@ -2799,11 +2800,11 @@ If you're trying to set a default parameter's value equal to a parameter which i
 
 ```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);
 ```
@@ -2836,7 +2837,7 @@ class Person {
   }
 }
 
-const member = new Person('John');
+const member = new Person("John");
 console.log(typeof member);
 ```
 
@@ -2896,7 +2897,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 = () =>
@@ -2927,7 +2928,7 @@ Regular functions, such as the `giveLydiaPizza` function, have a `prototype` pro
 
 ```javascript
 const person = {
-  name: 'Lydia',
+  name: "Lydia",
   age: 21,
 };
 
@@ -2987,7 +2988,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' ]`
@@ -3001,8 +3002,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;
 }
@@ -3042,13 +3043,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";
   }
 };
 
@@ -3077,7 +3078,7 @@ Kita dapat mengatur kelas yang sama dengan kelas / fungsi konstruktor lainnya. D
 
 ```javascript
 const info = {
-  [Symbol('a')]: 'b',
+  [Symbol("a")]: "b",
 };
 
 console.log(info);
@@ -3096,7 +3097,7 @@ console.log(Object.keys(info));
 
 Simbol bukanlah merupakan suatu _enumerable_. Metode Object.keys akan mengembalikan semua properti kunci _enumerable_ pada sebuah objek. Simbol tidak akan terlihat, dan array kosong dikembalikan. Saat mencatat seluruh objek, semua properti akan terlihat, bahkan yang bukan non-enumerable.
 
-Ini adalah salah satu dari banyak kualitas simbol: Disamping selain mewakili nilai yang sepenuhnya unik  (yang mencegah terjadinya benturan nama yang tidak disengaja pada objek, misalnya saat bekerja dengan 2 library yang ingin menambahkan properti ke objek yang sama),  anda juga dapat "menyembunyikan"  properti pada objek dengan cara ini (meskipun tidak seluruhnya. Anda masih dapat mengakses simbol menggunakan metode `Object.getOwnPropertySymbols()`).
+Ini adalah salah satu dari banyak kualitas simbol: Disamping selain mewakili nilai yang sepenuhnya unik (yang mencegah terjadinya benturan nama yang tidak disengaja pada objek, misalnya saat bekerja dengan 2 library yang ingin menambahkan properti ke objek yang sama), anda juga dapat "menyembunyikan" properti pada objek dengan cara ini (meskipun tidak seluruhnya. Anda masih dapat mengakses simbol menggunakan metode `Object.getOwnPropertySymbols()`).
 
 </p>
 </details>
@@ -3130,7 +3131,7 @@ Fungsi `getList` menerima array sebagai argumennya. Di antara tanda kurung pada
 
 `[x, ...y] = [1, 2, 3, 4]`
 
-Dengan parameter sisa `...y`, kita akan meletakkan semua argumen "yang tersisa" dalam array. Dalam kasus ini argumen yang tersisa adalah `2`, `3` dan `4`. Nilai dari `y` merupakan suatu array, yang berisi semua parameter lainnya. Pada kasus ini nilai dari `x` sama dengan `1`, jadi saat kita mencatat `[x, y]`,  maka catatannya `[1, [2, 3, 4]]`.
+Dengan parameter sisa `...y`, kita akan meletakkan semua argumen "yang tersisa" dalam array. Dalam kasus ini argumen yang tersisa adalah `2`, `3` dan `4`. Nilai dari `y` merupakan suatu array, yang berisi semua parameter lainnya. Pada kasus ini nilai dari `x` sama dengan `1`, jadi saat kita mencatat `[x, y]`, maka catatannya `[1, [2, 3, 4]]`.
 
 Fungsi `getUser` menerima sebuah objek. Dengan fungsi tanda panah, kita tidak _perlu_ menulis tanda kurung kurawal jika hanya mengembalikan satu nilai. Namun, jika anda mengembalikan nilai _object_ dari fungsi tanda panah, Anda harus menuliskannya di antara tanda kurung, jika tidak maka tidak ada nilai yang dikembalikan! Fungsi berikut akan mengembalikan sebuah objek:
 
@@ -3146,7 +3147,7 @@ Karena tidak ada nilai yang dikembalikan dalam kasus ini, maka fungsi akan menge
 ###### 99. Apa yang akan tampil?
 
 ```javascript
-const name = 'Lydia';
+const name = "Lydia";
 
 console.log(name());
 ```
@@ -3178,8 +3179,8 @@ ReferenceErrors muncul ketika JavaScript tidak dapat menemukan nilai referensi k
 ```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`
@@ -3205,7 +3206,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);
@@ -3237,16 +3238,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');
+  myPromise().then((res) => console.log(res));
+  console.log("second");
 }
 
 async function secondFunction() {
   console.log(await myPromise());
-  console.log('second');
+  console.log("second");
 }
 
 firstFunction();
@@ -3284,8 +3285,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);
@@ -3345,13 +3346,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);
 ```
@@ -3390,7 +3391,7 @@ const colorConfig = {
   yellow: false,
 };
 
-const colors = ['pink', 'red', 'blue'];
+const colors = ["pink", "red", "blue"];
 
 console.log(colorConfig.colors[1]);
 ```
@@ -3419,7 +3420,7 @@ JavaScript interprets (or unboxes) statements. When we use bracket notation, it
 ###### 107. Apakah hasil nilai dibawah ini ?
 
 ```javascript
-console.log('❤️' === '❤️');
+console.log("❤️" === "❤️");
 ```
 
 - A: `true`
@@ -3472,10 +3473,10 @@ Metode `splice`, akan memodifikasi array aslinya dengan cara menghapus, menggant
 ###### <a name=20191009></a>109. Apa yang akan tampil?
 
 ```javascript
-const food = ['🍕', '🍫', '🥑', '🍔'];
+const food = ["🍕", "🍫", "🥑", "🍔"];
 const info = { favoriteFood: food[0] };
 
-info.favoriteFood = '🍝';
+info.favoriteFood = "🍝";
 
 console.log(food);
 ```
@@ -3529,7 +3530,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' }
 ```
 
@@ -3541,11 +3542,11 @@ JSON.parse(jsonArray); // { name: 'Lydia' }
 ###### 111. Apa yang akan tampil?
 
 ```javascript
-let name = 'Lydia';
+let name = "Lydia";
 
 function getName() {
   console.log(name);
-  let name = 'Sarah';
+  let name = "Sarah";
 }
 
 getName();
@@ -3568,7 +3569,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);
@@ -3586,11 +3587,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();
@@ -3636,7 +3637,7 @@ console.log(two.next().value); // undefined
 ###### 113. Apa yang akan tampil?
 
 ```javascript
-console.log(`${(x => x)('I love')} to program`);
+console.log(`${((x) => x)("I love")} to program`);
 ```
 
 - A: `I love to program`
@@ -3661,7 +3662,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),
 };
 
@@ -3689,16 +3690,16 @@ Normally when we set objects equal to `null`, those objects get _garbage collect
 
 ```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
@@ -3725,14 +3726,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);
@@ -3791,7 +3792,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)]);
 ```
@@ -3817,11 +3818,11 @@ With the `+=` operand, we're incrementing the value of `num` by `1`. `num` had t
 
 ```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}`;
@@ -3859,10 +3860,10 @@ With the optional chaining operator `?.`, we no longer have to explicitly check
 ###### 120. Apa yang akan tampil?
 
 ```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!`);
 }
@@ -3918,10 +3919,10 @@ The `language` method is a `setter`. Setters don't hold an actual value, their p
 ###### 122. Apa yang akan tampil?
 
 ```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`
@@ -3946,7 +3947,7 @@ console.log(!typeof name === 'string');
 ###### 123. Apa yang akan tampil?
 
 ```javascript
-const add = x => y => z => {
+const add = (x) => (y) => (z) => {
   console.log(x, y, z);
   return x + y + z;
 };
@@ -4072,8 +4073,8 @@ With the `Intl.NumberFormat` method, we can format numeric values to any locale.
 ###### 127. Apa yang akan tampil?
 
 ```javascript
-const spookyItems = ['👻', '🎃', '🕸'];
-({ item: spookyItems[3] } = { item: '💀' });
+const spookyItems = ["👻", "🎃", "🕸"];
+({ item: spookyItems[3] } = { item: "💀" });
 
 console.log(spookyItems);
 ```
@@ -4098,7 +4099,7 @@ By destructuring objects, we can unpack values from the right-hand object, and a
 ###### 128. Apa yang akan tampil?
 
 ```javascript
-const name = 'Lydia Hallie';
+const name = "Lydia Hallie";
 const age = 21;
 
 console.log(Number.isNaN(name));
@@ -4134,7 +4135,7 @@ const randomValue = 21;
 
 function getInfo() {
   console.log(typeof randomValue);
-  const randomValue = 'Lydia Hallie';
+  const randomValue = "Lydia Hallie";
 }
 
 getInfo();
@@ -4160,7 +4161,7 @@ Variables declared with the `const` keyword are not referencable before their in
 ###### 130. Apa yang akan tampil?
 
 ```javascript
-const myPromise = Promise.resolve('Woah some cool data');
+const myPromise = Promise.resolve("Woah some cool data");
 
 (async () => {
   try {
@@ -4168,7 +4169,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!");
   }
 })();
 ```
@@ -4193,7 +4194,7 @@ In the `try` block, we're logging the awaited value of the `myPromise` variable:
 ###### 131. Apa yang akan tampil?
 
 ```javascript
-const emojis = ['🥑', ['✨', '✨', ['🍕', '🍕']]];
+const emojis = ["🥑", ["✨", "✨", ["🍕", "🍕"]]];
 
 console.log(emojis.flat(1));
 ```
@@ -4266,19 +4267,19 @@ We invoke the `counterTwo.increment()`, which sets the `count` to `3`. Then, we
 ###### 133. Apa yang akan tampil?
 
 ```javascript
-const myPromise = Promise.resolve(Promise.resolve('Promise!'));
+const myPromise = Promise.resolve(Promise.resolve("Promise!"));
 
 function funcOne() {
-  myPromise.then(res => res).then(res => console.log(res));
-  setTimeout(() => console.log('Timeout!', 0));
-  console.log('Last line!');
+  myPromise.then((res) => res).then((res) => console.log(res));
+  setTimeout(() => console.log("Timeout!", 0));
+  console.log("Last line!");
 }
 
 async function funcTwo() {
   const res = await myPromise;
   console.log(await res);
-  setTimeout(() => console.log('Timeout!', 0));
-  console.log('Last line!');
+  setTimeout(() => console.log("Timeout!", 0));
+  console.log("Last line!");
 }
 
 funcOne();
@@ -4319,7 +4320,7 @@ export default function sum(x) {
 }
 
 // index.js
-import * as sum from './sum';
+import * as sum from "./sum";
 ```
 
 - A: `sum(4)`
@@ -4336,12 +4337,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);
 ```
 
@@ -4372,13 +4373,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;
 ```
 
@@ -4408,7 +4409,7 @@ Then, we access a property value on the proxy object, the `get` property on the
 ###### 136. Which of the following will modify the `person` object?
 
 ```javascript
-const person = { name: 'Lydia Hallie' };
+const person = { name: "Lydia Hallie" };
 
 Object.seal(person);
 ```
@@ -4436,9 +4437,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",
   },
 };
 
@@ -4468,9 +4469,9 @@ However, it only _shallowly_ freezes the object, meaning that only _direct_ prop
 
 ```javascript
 const person = {
-  name: 'Lydia Hallie',
+  name: "Lydia Hallie",
   address: {
-    street: '100 Main St',
+    street: "100 Main St",
   },
 };
 
@@ -4499,7 +4500,7 @@ However, it only _shallowly_ freezes the object, meaning that only _direct_ prop
 ###### 139. Apa yang akan tampil?
 
 ```javascript
-const add = x => x + x;
+const add = (x) => x + x;
 
 function myFunc(num = 2, value = add(num)) {
   console.log(num, value);
@@ -4532,21 +4533,21 @@ Then, we invoked `myFunc(3)` and passed the value `3` as the value for the argum
 
 ```javascript
 class Counter {
-  #number = 10
+  #number = 10;
 
   increment() {
-    this.#number++
+    this.#number++;
   }
 
   getNum() {
-    return this.#number
+    return this.#number;
   }
 }
 
-const counter = new Counter()
-counter.increment()
+const counter = new Counter();
+counter.increment();
 
-console.log(counter.#number)
+console.log(counter.#number);
 ```
 
 - A: `10`
@@ -4570,8 +4571,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) {
@@ -4614,8 +4615,8 @@ Jika kita telah menulis `yield`, `return yield`, atau `return`, maka seluruh fun
 
 ```javascript
 const person = {
-  name: 'Lydia Hallie',
-  hobbies: ['coding'],
+  name: "Lydia Hallie",
+  hobbies: ["coding"],
 };
 
 function addHobby(hobby, hobbies = person.hobbies) {
@@ -4623,9 +4624,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);
 ```
@@ -4694,11 +4695,11 @@ Kita membuat variabel `pet` yang merupakan turunan dari class `Flamingo`. Saat k
 ###### 144. Manakah dari pilihan di bawah ini yang salah?
 
 ```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;
 ```
 
@@ -4741,7 +4742,7 @@ const person = {
 #### Jawaban: C
 
 Objek tidak dapat diulang secara default. Sebuah iterable adalah sebuah iterable jika protokol iterator ada. Kita dapat menambahkan ini secara manual dengan menambahkan simbol iterator
- `[Symbol.iterator]`, dimana harus mengembalikan objek generator, sebagai contoh dengan membuat fungsi generator `*[Symbol.iterator]() {}`. Fungsi generator ini harus menghasilkan `Object.values` dari objek `person` jika kita mau mengembalikan array `["Lydia Hallie", 21]`: `yield* Object.values(this)`.
+`[Symbol.iterator]`, dimana harus mengembalikan objek generator, sebagai contoh dengan membuat fungsi generator `*[Symbol.iterator]() {}`. Fungsi generator ini harus menghasilkan `Object.values` dari objek `person` jika kita mau mengembalikan array `["Lydia Hallie", 21]`: `yield* Object.values(this)`.
 
 </p>
 </details>
@@ -4754,11 +4755,11 @@ Objek tidak dapat diulang secara default. Sebuah iterable adalah sebuah iterable
 let count = 0;
 const nums = [0, 1, 2, 3];
 
-nums.forEach(num => {
-	if (num) count += 1
-})
+nums.forEach((num) => {
+  if (num) count += 1;
+});
 
-console.log(count)
+console.log(count);
 ```
 
 - A: 1
@@ -4782,19 +4783,19 @@ Pernyataan `if` didalam perulangan `forEach` akan mengecek apakah nilai dari `nu
 
 ```javascript
 class Calc {
-	constructor() {
-		this.count = 0
-	}
+  constructor() {
+    this.count = 0;
+  }
 
-	increase() {
-		this.count ++
-	}
+  increase() {
+    this.count++;
+  }
 }
 
-const calc = new Calc()
-new Calc().increase()
+const calc = new Calc();
+new Calc().increase();
 
-console.log(calc.count)
+console.log(calc.count);
 ```
 
 - A: `0`
@@ -4818,25 +4819,25 @@ Kami mengatur variabel `calc` sama dengan instance baru dari class `Calc`. Kemud
 
 ```javascript
 const user = {
-	email: "e@mail.com",
-	password: "12345"
-}
+  email: "e@mail.com",
+  password: "12345",
+};
 
 const updateUser = ({ email, password }) => {
-	if (email) {
-		Object.assign(user, { email })
-	}
+  if (email) {
+    Object.assign(user, { email });
+  }
 
-	if (password) {
-		user.password = password
-	}
+  if (password) {
+    user.password = password;
+  }
 
-	return user
-}
+  return user;
+};
 
-const updatedUser = updateUser({ email: "new@email.com" })
+const updatedUser = updateUser({ email: "new@email.com" });
 
-console.log(updatedUser === user)
+console.log(updatedUser === user);
 ```
 
 - A: `false`
@@ -4857,12 +4858,13 @@ Fungsi `updateUser` memperbarui nilai properti `email` dan `password` pada pengg
 ---
 
 ###### 149. Apa hasilnya?
+
 ```javascript
-const fruit = ['🍌', '🍊', '🍎']
+const fruit = ["🍌", "🍊", "🍎"];
 
-fruit.slice(0, 1)
-fruit.splice(0, 1)
-fruit.unshift('🍇')
+fruit.slice(0, 1);
+fruit.splice(0, 1);
+fruit.unshift("🍇");
 ```
 
 - A: `['🍌', '🍊', '🍎']`
@@ -4888,13 +4890,13 @@ Akhirnya, kita memanggil metode `unshift` pada array `fruit`, yang memodifikasi
 
 ```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])
+console.log(animals[dog]);
 ```
 
 - A: `{ emoji: "🐶", name: "Mara" }`
@@ -4909,9 +4911,9 @@ console.log(animals[dog])
 
 Kunci objek diubah menjadi string.
 
-Karena nilai `dog` adalah sebuah objek,  `animals[dog]`sebenarnya berarti kita membuat properti baru bernama `"object Object"`yang sama dengan objek baru. `animals["object Object"]` sekarang sama dengan `{ emoji: "🐶", name: "Mara"}`.
+Karena nilai `dog` adalah sebuah objek, `animals[dog]`sebenarnya berarti kita membuat properti baru bernama `"object Object"`yang sama dengan objek baru. `animals["object Object"]` sekarang sama dengan `{ emoji: "🐶", name: "Mara"}`.
 
-`cat` juga merupakan objek, yang berarti bahwa `animals[cat]` sebenarnya berarti bahwa kami menimpa nilai `animals[``"``object Object``"``]` dengan properti cat yang baru.
+`cat` juga merupakan objek, yang berarti bahwa `animals[cat]` sebenarnya berarti bahwa kami menimpa nilai ` animals[``"``object Object``"``] ` dengan properti cat yang baru.
 
 Mencatat `animals[dog]`, atau sebenarnya `animals["object Object"]` karena mengonversi objek `dog` menjadi string menghasilkan `"object Object"`, mengembalikan `{emoji: "🐈", nama: "Sara"}`.
 
@@ -4924,10 +4926,10 @@ Mencatat `animals[dog]`, atau sebenarnya `animals["object Object"]` karena mengo
 
 ```javascript
 const user = {
-        email: "my@email.com",
-        updateEmail: (email) => {
-          this.email = email;
-        },
+  email: "my@email.com",
+  updateEmail: (email) => {
+    this.email = email;
+  },
 };
 
 user.updateEmail("new@email.com");
@@ -4954,20 +4956,20 @@ Fungsi `updateEmail` adalah fungsi panah, dan tidak terikat ke objek `user`. Art
 ###### 152. Apa hasilnya?
 
 ```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]);
-      const res2 = await Promise.all([promise3, promise4]);
-      return [res1, res2];
-}
+  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))
+  .then((res) => console.log(res))
+  .catch((err) => console.log(err));
 ```
 
 - A: `[['First', 'Second'], ['Fourth']]`
@@ -5024,18 +5026,18 @@ Ini membuat array subarray yang berisi kunci dan nilai yang benar, yang menghasi
 ###### 154. Apa hasilnya?
 
 ```javascript
-const createMember = ({ email, address = {}}) => {
-	const validEmail = /.+\@.+\..+/.test(email)
-	if (!validEmail) throw new Error("Valid email pls")
+const createMember = ({ email, address = {} }) => {
+  const validEmail = /.+\@.+\..+/.test(email);
+  if (!validEmail) throw new Error("Valid email pls");
 
-	return {
-		email,
-		address: address ? address : null
-	}
-}
+  return {
+    email,
+    address: address ? address : null,
+  };
+};
 
-const member = createMember({ email: "my@email.com" })
-console.log(member)
+const member = createMember({ email: "my@email.com" });
+console.log(member);
 ```
 
 - A: `{ email: "my@email.com", address: null }`
@@ -5058,13 +5060,13 @@ Nilai default dari `address` adalah objek kosong `{}`. Saat kita menyetel variab
 ###### 155. Apa hasilnya?
 
 ```javascript
-let randomValue = { name: "Lydia" }
-randomValue = 23
+let randomValue = { name: "Lydia" };
+randomValue = 23;
 
 if (!typeof randomValue === "string") {
-	console.log("It's not a string!")
+  console.log("It's not a string!");
 } else {
-	console.log("Yay it's a string!")
+  console.log("Yay it's a string!");
 }
 ```
 
diff --git a/it-IT/README.md b/it-IT/README.md
index 71b71ca5..8b116031 100644
--- a/it-IT/README.md
+++ b/it-IT/README.md
@@ -8,13 +8,12 @@
 
 Da base ad avanzato: metti alla prova quanto conosci JavaScript, rinfresca un po' le tue conoscenze o preparati per il tuo colloquio di programmazione! :muscle: :rocket: Aggiorno regolarmente questo repository con nuove domande. Ho aggiunto le risposte nelle **sezioni compresse** sotto le domande, cliccaci sopra per espanderle. È solo per divertimento, buona fortuna! :heart:
 
-
 Sentiti libero di contattarmi! 😊 <br />
 <a href="https://www.instagram.com/theavocoder">Instagram</a> || <a href="https://www.twitter.com/lydiahallie">Twitter</a> || <a href="https://www.linkedin.com/in/lydia-hallie">LinkedIn</a> || <a href="https://www.lydiahallie.dev">Blog</a>
-</div>
 
-| Sentiti libero di usarli in un progetto! 😃  Apprezzerei _molto_ un riferimento a questa repository, creo le domande e le spiegazioni (sì, sono triste lol) e la community mi aiuta tantissimo a mantenerlo e migliorarlo! 💪🏼 Grazie e buon divertimento!  |
+</div>
 
+| Sentiti libero di usarli in un progetto! 😃 Apprezzerei _molto_ un riferimento a questa repository, creo le domande e le spiegazioni (sì, sono triste lol) e la community mi aiuta tantissimo a mantenerlo e migliorarlo! 💪🏼 Grazie e buon divertimento! |
 
 Traduzione a cura di: <a href="https://github.com/luciacenetiempo">Lucia Cenetiempo</a>
 |---|
@@ -37,6 +36,7 @@ Traduzione a cura di: <a href="https://github.com/luciacenetiempo">Lucia Cenetie
 - [🇳🇱 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)
@@ -57,7 +57,7 @@ Traduzione a cura di: <a href="https://github.com/luciacenetiempo">Lucia Cenetie
 function sayHi() {
   console.log(name);
   console.log(age);
-  var name = 'Lydia';
+  var name = "Lydia";
   let age = 21;
 }
 
@@ -75,8 +75,8 @@ sayHi();
 
 #### Risposta: D
 
-All'interno della funzione, dichiariamo prima la variabile `name` con la parola chiave `var`. Ciò significa che la variabile viene sollevata all'interno del codice (ovvero lo spazio di memoria viene impostato durante la fase di creazione) e viene inizializzata con il valore predefinito di `undefined`, finché non arriviamo effettivamente alla riga in cui la definiamo. 
-Al momento in cui proviamo ad eseguire il log della variabile `name` non l'abbiamo ancora dichiarata, quindi mantiene il valore di `undefined`. 
+All'interno della funzione, dichiariamo prima la variabile `name` con la parola chiave `var`. Ciò significa che la variabile viene sollevata all'interno del codice (ovvero lo spazio di memoria viene impostato durante la fase di creazione) e viene inizializzata con il valore predefinito di `undefined`, finché non arriviamo effettivamente alla riga in cui la definiamo.
+Al momento in cui proviamo ad eseguire il log della variabile `name` non l'abbiamo ancora dichiarata, quindi mantiene il valore di `undefined`.
 
 Le variabili dichiarate con la chiave `let` (o `const`) vengono sollevate, ma a differenza delle variabili dichiarate con `var`, non vengono <i>inizializzate</i>. Per questo motivo non sono accessibili prima della loro dichiarazione (dove le inizializzaimo). Questa è chiamata "temporal dead zone". Quando proviamo ad accedere alle variabili prima che vengano dichiarate, JavaScript genera un `ReferenceError`.
 
@@ -155,7 +155,7 @@ Non troviamo quindi alcun valore `radius` in quell'oggetto e quindi viene restit
 
 ```javascript
 +true;
-!'Lydia';
+!"Lydia";
 ```
 
 - A: `1` and `false`
@@ -180,11 +180,11 @@ La stringa `'Lydia'` è un valore veritiero. Quello che in realtà ci stiamo chi
 
 ```javascript
 const bird = {
-  size: 'small',
+  size: "small",
 };
 
 const mouse = {
-  name: 'Mickey',
+  name: "Mickey",
   small: true,
 };
 ```
@@ -215,11 +215,11 @@ Con l'utilizzo del punto questo non accade perché `mouse` non ha una chiave chi
 ###### 6. Qual è l'output?
 
 ```javascript
-let c = { greeting: 'Hey!' };
+let c = { greeting: "Hey!" };
 let d;
 
 d = c;
-c.greeting = 'Hello';
+c.greeting = "Hello";
 console.log(d.greeting);
 ```
 
@@ -289,13 +289,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`
@@ -347,10 +347,10 @@ Per evitare ciò, possiamo usare `"use strict"`. Questo assicura di aver dichiar
 
 ```javascript
 function bark() {
-  console.log('Woof!');
+  console.log("Woof!");
 }
 
-bark.animal = 'dog';
+bark.animal = "dog";
 ```
 
 - A: Niente, va benissimo!
@@ -380,8 +380,8 @@ function Person(firstName, lastName) {
   this.lastName = lastName;
 }
 
-const member = new Person('Lydia', 'Hallie');
-Person.getFullName = function() {
+const member = new Person("Lydia", "Hallie");
+Person.getFullName = function () {
   return `${this.firstName} ${this.lastName}`;
 };
 
@@ -402,9 +402,8 @@ In JavaScript, le funzioni sono oggetti e quindi il metodo `getFullName` viene a
 
 Se vuoi che un metodo sia disponibile per tutte le istanze dell'oggetto, devi aggiungerlo alla proprietà del prototipo:
 
-
 ```js
-Person.prototype.getFullName = function() {
+Person.prototype.getFullName = function () {
   return `${this.firstName} ${this.lastName}`;
 };
 ```
@@ -422,8 +421,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);
@@ -493,7 +492,7 @@ function sum(a, b) {
   return a + b;
 }
 
-sum(1, '2');
+sum(1, "2");
 ```
 
 - A: `NaN`
@@ -544,7 +543,7 @@ Utilizzando l'operatore unario come **prefisso** `++number` succede che:
 1. Incrementa prima il valore (il numero è ora `2`)
 2. Restituisce subito dopo il valore già incrementato (`2`)
 
-Quindi il nostro log sarà  `0 2 2`.
+Quindi il nostro log sarà `0 2 2`.
 
 </p>
 </details>
@@ -560,7 +559,7 @@ function getPersonInfo(one, two, three) {
   console.log(three);
 }
 
-const person = 'Lydia';
+const person = "Lydia";
 const age = 21;
 
 getPersonInfo`${person} is ${age} years old`;
@@ -575,7 +574,7 @@ getPersonInfo`${person} is ${age} years old`;
 
 #### Risposta: B
 
-Utilizzando i template literals, il valore del primo argomento sarà un array di valori della stringa. Gli altri argomenti prenderanno i valori dell'espressione passata. 
+Utilizzando i template literals, il valore del primo argomento sarà un array di valori della stringa. Gli altri argomenti prenderanno i valori dell'espressione passata.
 
 </p>
 </details>
@@ -587,9 +586,9 @@ Utilizzando i template literals, il valore del primo argomento sarà un array di
 ```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`);
   }
@@ -649,7 +648,7 @@ Il parametro rest (`...args`) ci permette di "collettare" tutti gli argomenti in
 
 ```javascript
 function getAge() {
-  'use strict';
+  "use strict";
   age = 21;
   console.log(age);
 }
@@ -677,7 +676,7 @@ Con `"use strict"`, puoi assicurarti di non dichiarare variabili globali per sba
 ###### 21. Qual è il valore di `sum`?
 
 ```javascript
-const sum = eval('10*10+5');
+const sum = eval("10*10+5");
 ```
 
 - A: `105`
@@ -700,7 +699,7 @@ const sum = eval('10*10+5');
 ###### 22. Per quanto tempo cool_secret è accessibile?
 
 ```javascript
-sessionStorage.setItem('cool_secret', 123);
+sessionStorage.setItem("cool_secret", 123);
 ```
 
 - A: Per sempre, i dati non vanno persi.
@@ -753,12 +752,12 @@ Non puoi farlo con `let` o `const` poiché sono block-scoped.
 ###### 24. Qual è l'output?
 
 ```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);
 ```
 
@@ -784,7 +783,7 @@ Per i set non funziona allo stesso modo degli oggetti. Non c'è alcun `'1'` nel
 ###### 25. Qual è l'output?
 
 ```javascript
-const obj = { a: 'one', b: 'two', a: 'three' };
+const obj = { a: "one", b: "two", a: "three" };
 console.log(obj);
 ```
 
@@ -853,12 +852,12 @@ L'istruzione `continue` salta un'iterazione se una certa condizione restituisce
 
 ```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())
+console.log(name.giveLydiaPizza());
 ```
 
 - A: `"Just give Lydia pizza already!"`
@@ -871,7 +870,7 @@ console.log(name.giveLydiaPizza())
 
 #### Risposta: A
 
-`String` è un costruttore built-in, a cui possiamo aggiungere proprietà. In questo caso è stato appena aggiunto un metodo al suo prototipo. 
+`String` è un costruttore built-in, a cui possiamo aggiungere proprietà. In questo caso è stato appena aggiunto un metodo al suo prototipo.
 Le stringhe primitive vengono automaticamente convertite in un oggetto stringa, generato dalla string prototype function. Quindi, tutte le stringhe hanno accesso a quel metodo!
 
 </p>
@@ -883,8 +882,8 @@ Le stringhe primitive vengono automaticamente convertite in un oggetto stringa,
 
 ```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;
@@ -916,9 +915,9 @@ Quindi, quando facciamo console.log di `a[b]`, che in realtà è `a["[object Obj
 ###### 30. Qual è l'output?
 
 ```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();
@@ -971,9 +970,7 @@ La WebAPI non può semplicemente aggiungere elementi allo stack ogni volta che 
 ```html
 <div onclick="console.log('first div')">
   <div onclick="console.log('second div')">
-    <button onclick="console.log('button')">
-      Click!
-    </button>
+    <button onclick="console.log('button')">Click!</button>
   </div>
 </div>
 ```
@@ -999,9 +996,7 @@ L'elemento annidato più in profondità è quello che ha causato l'evento ed è
 
 ```html
 <div onclick="console.log('div')">
-  <p onclick="console.log('p')">
-    Click here!
-  </p>
+  <p onclick="console.log('p')">Click here!</p>
 </div>
 ```
 
@@ -1025,7 +1020,7 @@ Se clicchiamo su `p`, vediamo due log: `p` e `div`. Durante la propagazione dell
 ###### 33. Qual è l'output?
 
 ```javascript
-const person = { name: 'Lydia' };
+const person = { name: "Lydia" };
 
 function sayHi(age) {
   return `${this.name} is ${age}`;
@@ -1088,8 +1083,8 @@ Ci sono solo 7 tipi built-in: `null`, `undefined`, `boolean`, `number`, `string`
 ```javascript
 0;
 new Number(0);
-('');
-(' ');
+("");
+(" ");
 new Boolean(false);
 undefined;
 ```
@@ -1238,11 +1233,14 @@ Ciò che differenzia un tipo primitivo da un oggetto è che i primitivi non hann
 ###### 40. Qual è l'output?
 
 ```javascript
-[[0, 1], [2, 3]].reduce(
+[
+  [0, 1],
+  [2, 3],
+].reduce(
   (acc, cur) => {
     return acc.concat(cur);
   },
-  [1, 2],
+  [1, 2]
 );
 ```
 
@@ -1259,6 +1257,7 @@ Ciò che differenzia un tipo primitivo da un oggetto è che i primitivi non hann
 `[1, 2]` rappresenta il nostro valore interno. Ovvero il valore con cui iniziamo e il valore del primo `acc`. Durante il primo round, `acc` è `[1,2]` e `cur` è `[0, 1]`. Li concateniamo ottenendo `[1, 2, 0, 1]`.
 
 A questo punto `acc` corrisponderà a `[1, 2, 0, 1]` e `cur` sarà ancora `[2, 3]`. Li concateniamo e otteniamo `[1, 2, 0, 1, 2, 3]`
+
 </p>
 </details>
 
@@ -1268,7 +1267,7 @@ A questo punto `acc` corrisponderà a `[1, 2, 0, 1]` e `cur` sarà ancora `[2, 3
 
 ```javascript
 !!null;
-!!'';
+!!"";
 !!1;
 ```
 
@@ -1296,7 +1295,7 @@ A questo punto `acc` corrisponderà a `[1, 2, 0, 1]` e `cur` sarà ancora `[2, 3
 ###### 42. Cosa restituisce il metodo `setInterval` nel browser?
 
 ```javascript
-setInterval(() => console.log('Hi'), 1000);
+setInterval(() => console.log("Hi"), 1000);
 ```
 
 - A: un ID univoco
@@ -1319,7 +1318,7 @@ Restituisce un ID univoco. Questo id può essere usato per cancellare quell'inte
 ###### 43. Cosa restituisce?
 
 ```javascript
-[...'Lydia'];
+[..."Lydia"];
 ```
 
 - A: `["L", "y", "d", "i", "a"]`
@@ -1378,14 +1377,14 @@ Invochiamo di nuovo la funzione con il metodo `next()`. Inizia a continuare da d
 
 ```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));
+Promise.race([firstPromise, secondPromise]).then((res) => console.log(res));
 ```
 
 - A: `"one"`
@@ -1408,7 +1407,7 @@ Quando passiamo più promises al metodo `Promise.race`, questo risolve/rifiuta l
 ###### 46. Qual è l'output?
 
 ```javascript
-let person = { name: 'Lydia' };
+let person = { name: "Lydia" };
 const members = [person];
 person = null;
 
@@ -1448,7 +1447,7 @@ Stiamo modificando solo il valore della variabile `person`, e non il primo eleme
 
 ```javascript
 const person = {
-  name: 'Lydia',
+  name: "Lydia",
   age: 21,
 };
 
@@ -1477,7 +1476,7 @@ Con il ciclo `for-in`, possiamo iterare le chiavi degli oggetti, in questo caso
 ###### 48. Qual è l'output?
 
 ```javascript
-console.log(3 + 4 + '5');
+console.log(3 + 4 + "5");
 ```
 
 - A: `"345"`
@@ -1504,7 +1503,7 @@ L'associazione è l'ordine in cui il compilatore valuta le espressioni, da sinis
 ###### 49. Qual è il valore di `num`?
 
 ```javascript
-const num = parseInt('7*6', 10);
+const num = parseInt("7*6", 10);
 ```
 
 - A: `42`
@@ -1529,8 +1528,8 @@ Viene restituito solo il primo valore della stringa. In base alla _radice_ (ovve
 ###### 50. Qual è l'output?
 
 ```javascript
-[1, 2, 3].map(num => {
-  if (typeof num === 'number') return;
+[1, 2, 3].map((num) => {
+  if (typeof num === "number") return;
   return num * 2;
 });
 ```
@@ -1558,12 +1557,12 @@ Tuttavia, non ritorniamo un valore. Quando non ritorniamo un valore dalla funzio
 
 ```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);
 
@@ -1585,6 +1584,7 @@ Gli argomenti vengono passati come _valori_, a meno che il loro valore non sia u
 La variabile `birthYear` ha un riferimento al valore `"1997"`. Anche l'argomento `year` fa riferimento al valore `"1997"`, ma non è lo stesso valore a cui fa riferimento `birthYear`. Quando aggiorniamo il valore di `year` impostando `year` uguale a `"1998"`, stiamo solo aggiornando il valore di `year`. `birthYear` è ancora uguale a `"1997"`.
 
 Il valore di `person` è un oggetto. L'argomento `member` ha un riferimento (copiato) dello stesso oggetto. Quando modifichiamo una proprietà dell'oggetto a cui `member` fa riferimento, verrà modificato anche il valore di `person`, poiché entrambi hanno un riferimento allo stesso oggetto. La proprietà `name` di `person` è ora uguale al valore `"Lydia"`
+
 </p>
 </details>
 
@@ -1594,15 +1594,15 @@ Il valore di `person` è un oggetto. L'argomento `member` ha un riferimento (cop
 
 ```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 @@ Con l'istruzione `catch`, possiamo specificare cosa fare se viene generata un'ec
 
 ```javascript
 function Car() {
-  this.make = 'Lamborghini';
-  return { make: 'Maserati' };
+  this.make = "Lamborghini";
+  return { make: "Maserati" };
 }
 
 const myCar = new Car();
@@ -1705,11 +1705,11 @@ class Dog {
   }
 }
 
-Dog.prototype.bark = function() {
+Dog.prototype.bark = function () {
   console.log(`Woof I am ${this.name}`);
 };
 
-const pet = new Dog('Mara');
+const pet = new Dog("Mara");
 
 pet.bark();
 
@@ -1774,7 +1774,7 @@ export default counter;
 
 ```javascript
 // index.js
-import myCounter from './counter';
+import myCounter from "./counter";
 
 myCounter += 1;
 
@@ -1803,7 +1803,7 @@ Quando proviamo ad incrementare il valore di `myCounter`, viene generato un erro
 ###### 58. Qual è l'output?
 
 ```javascript
-const name = 'Lydia';
+const name = "Lydia";
 age = 21;
 
 console.log(delete name);
@@ -1874,7 +1874,7 @@ Questo significa che il valore di `y` è uguale al primo valore nell'array, che
 ###### 60. Qual è l'output?
 
 ```javascript
-const user = { name: 'Lydia', age: 21 };
+const user = { name: "Lydia", age: 21 };
 const admin = { admin: true, ...user };
 
 console.log(admin);
@@ -1900,9 +1900,9 @@ console.log(admin);
 ###### 61. Qual è l'output?
 
 ```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));
@@ -1931,12 +1931,12 @@ Le proprietà aggiunte usando il metodo `defineProperty` sono immutabili per imp
 
 ```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);
 ```
 
@@ -1967,7 +1967,7 @@ Se il replacer è una _funzione_, questa funzione viene chiamata su ogni proprie
 let num = 10;
 
 const increaseNumber = () => num++;
-const increasePassedNumber = number => number++;
+const increasePassedNumber = (number) => number++;
 
 const num1 = increaseNumber();
 const num2 = increasePassedNumber(num1);
@@ -2049,7 +2049,7 @@ La quarta volta, passiamo di nuovo l'oggetto `value`, in questo caso `x.number`
 
 #### Risposta: D
 
-Il primo argomento che il metodo `reduce` riceve è l'_accumulatore_, in questo caso `x`. Il secondo argomento è il _valore corrente_ `y`. 
+Il primo argomento che il metodo `reduce` riceve è l'_accumulatore_, in questo caso `x`. Il secondo argomento è il _valore corrente_ `y`.
 Con il metodo reduce, eseguiamo una funzione di callback su ogni elemento dell'array, che alla fine potrebbe risultare in un singolo valore.
 
 In questo esempio, non stiamo restituendo alcun valore, stiamo semplicemente loggando i valori dell'accumulatore e il valore corrente.
@@ -2061,6 +2061,7 @@ Alla prima chiamata, l'accumulatore (`x`) è `1` e il valore corrente (`y`) è `
 Se non restituisci un valore da una funzione questa restituisce `undefined`. Alla chiamata successiva, l'accumulatore è `undefined` e il valore corrente è "3". `undefined` e `3` vengono loggati.
 
 Alla quarta chiamata, di nuovo non facciamo un return dalla funzione di callback. L'accumulatore è di nuovo `undefined` e il valore corrente è "4". `undefined` e `4` vengono loggati.
+
 </p>
 </details>
   
@@ -2124,12 +2125,12 @@ La classe `Labrador` riceve due argomenti, `name` poiché estende `Dog`, e `size
 
 ```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;
 ```
 
@@ -2157,7 +2158,7 @@ Questa è una delle differenze tra `require()` in CommonJS e `import`. Con `requ
 ```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`
@@ -2180,7 +2181,7 @@ Ogni Simbolo è unico. Lo scopo dell'argomento passato a Symbol è di dargli una
 ###### 69. Qual è l'output?
 
 ```javascript
-const name = 'Lydia Hallie';
+const name = "Lydia Hallie";
 console.log(name.padStart(13));
 console.log(name.padStart(2));
 ```
@@ -2207,7 +2208,7 @@ Se l'argomento passato al metodo `padStart` è inferiore alla lunghezza dell'arr
 ###### 70. Qual è l'output?
 
 ```javascript
-console.log('🥑' + '💻');
+console.log("🥑" + "💻");
 ```
 
 - A: `"🥑💻"`
@@ -2231,11 +2232,11 @@ Con l'operatore `+` puoi concatenare stringhe. In questo caso, stiamo concatenan
 
 ```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 gone here";
   }
-  return 'JavaScript loves you back ❤️';
+  return "JavaScript loves you back ❤️";
 }
 
 const game = startGame();
@@ -2303,7 +2304,7 @@ In questo caso, è la stringa `Hello\nworld` che viene loggata.
 
 ```javascript
 async function getData() {
-  return await Promise.resolve('I made it!');
+  return await Promise.resolve("I made it!");
 }
 
 const data = getData();
@@ -2340,7 +2341,7 @@ function addToList(item, list) {
   return list.push(item);
 }
 
-const result = addToList('apple', ['banana']);
+const result = addToList("apple", ["banana"]);
 console.log(result);
 ```
 
@@ -2354,10 +2355,10 @@ console.log(result);
 
 #### Risposta: B
 
-Il metodo `.push()` restituisce la _lunghezza_ del nuovo array! 
-Inizialmente, l'array conteneva un solo elemento (la stringa `"banana"`) e aveva una lunghezza di `1`. Dopo aver aggiunto la stringa `"apple"` allo stesso array, questo contiene due elementi e ha una lunghezza di `2` 
+Il metodo `.push()` restituisce la _lunghezza_ del nuovo array!
+Inizialmente, l'array conteneva un solo elemento (la stringa `"banana"`) e aveva una lunghezza di `1`. Dopo aver aggiunto la stringa `"apple"` allo stesso array, questo contiene due elementi e ha una lunghezza di `2`
 
-Attraverso la funzione `addToList`, il metodo `push` modifica l'array originale. 
+Attraverso la funzione `addToList`, il metodo `push` modifica l'array originale.
 Per restituire l'_array_ dalla funzione invece della _lunghezza dell'array_, serve fare un return di `list` dopo aver inserito l'`item`.
 
 </p>
@@ -2390,10 +2391,10 @@ console.log(shape);
 
 `Object.freeze` rende impossibile aggiungere, rimuovere o modificare le proprietà di un oggetto (a meno che il valore della proprietà non sia un altro oggetto).
 
-Quando creiamo la variabile `shape` e la impostiamo come all'oggetto congelato `box`, anche `shape` si riferisce ad un oggetto congelato. 
+Quando creiamo la variabile `shape` e la impostiamo come all'oggetto congelato `box`, anche `shape` si riferisce ad un oggetto congelato.
 Puoi controllare se un oggetto è congelato usando `Object.isFrozen`. In questo caso, `Object.isFrozen(shape)` restituisce true, poiché la variabile `shape` ha un riferimento a un oggetto congelato.
 
-Poiché `shape` è congelata, e poiché il valore di `x` non è un oggetto, non possiamo modificare la proprietà `x`. 
+Poiché `shape` è congelata, e poiché il valore di `x` non è un oggetto, non possiamo modificare la proprietà `x`.
 `x` è ancora uguale a `10` e `{ x: 10, y: 20 }` viene loggato.
 
 </p>
@@ -2404,7 +2405,7 @@ Poiché `shape` è congelata, e poiché il valore di `x` non è un oggetto, non
 ###### 76. Qual è l'output?
 
 ```javascript
-const { name: myName } = { name: 'Lydia' };
+const { name: myName } = { name: "Lydia" };
 
 console.log(name);
 ```
@@ -2460,7 +2461,7 @@ La funzione `sum` restituisce sempre lo stesso risultato. Se le passiamo `1` e `
 ```javascript
 const add = () => {
   const cache = {};
-  return num => {
+  return (num) => {
     if (num in cache) {
       return `From cache! ${cache[num]}`;
     } else {
@@ -2487,13 +2488,13 @@ console.log(addFunction(5 * 2));
 
 #### Risposta: C
 
-La funzione `add` è una funzione _memoizzata_. Con la memorizzazione, possiamo memorizzare nella cache i risultati di una funzione per velocizzarne l'esecuzione. 
+La funzione `add` è una funzione _memoizzata_. Con la memorizzazione, possiamo memorizzare nella cache i risultati di una funzione per velocizzarne l'esecuzione.
 In questo caso, creiamo un oggetto `cache` che memorizza i valori precedentemente restituiti.
 
 Se chiamiamo di nuovo la funzione `addFunction` con lo stesso argomento, prima controlla se ha già ottenuto quel valore nella sua cache, in tal caso, verrà restituito il valore della cache, consentendo di risparmiare tempo di esecuzione. Altrimenti, se non è memorizzato nella cache, calcolerà il valore e lo memorizzerà in seguito.
 
-Chiamiamo la funzione `addFunction` tre volte con lo stesso valore: alla prima chiamata, il valore della funzione quando `num` è uguale a `10` non è ancora memorizzato nella cache. 
-La condizione dell'istruzione if `num in cache` restituisce `false`, e il blocco else viene eseguito: `Calculated! 20` viene loggato e il valore del risultato viene aggiunto all'oggetto cache. 
+Chiamiamo la funzione `addFunction` tre volte con lo stesso valore: alla prima chiamata, il valore della funzione quando `num` è uguale a `10` non è ancora memorizzato nella cache.
+La condizione dell'istruzione if `num in cache` restituisce `false`, e il blocco else viene eseguito: `Calculated! 20` viene loggato e il valore del risultato viene aggiunto all'oggetto cache.
 `cache` ora è uguale a `{ 10: 20 }`.
 
 La seconda volta, l'oggetto `cache` contiene il valore che viene restituito per `10`. La condizione dell'istruzione if `num in cache` restituisce `true` e `'From cache! 20'` viene loggato.
@@ -2508,7 +2509,7 @@ La terza volta, passiamo `5 * 2` alla funzione che viene valutata a `10`. L'ogge
 ###### 79. Qual è l'output?
 
 ```javascript
-const myLifeSummedUp = ['☕', '💻', '🍷', '🍫'];
+const myLifeSummedUp = ["☕", "💻", "🍷", "🍫"];
 
 for (let item in myLifeSummedUp) {
   console.log(item);
@@ -2604,13 +2605,13 @@ In questo caso, se non abbiamo passato un valore o se abbiamo passato `undefined
 ###### 82. Qual è l'output?
 
 ```javascript
-var status = '😎';
+var status = "😎";
 
 setTimeout(() => {
-  const status = '😍';
+  const status = "😍";
 
   const data = {
-    status: '🥑',
+    status: "🥑",
     getStatus() {
       return this.status;
     },
@@ -2644,12 +2645,12 @@ Con il metodo `call` possiamo cambiare l'oggetto a cui fa riferimento la parola
 
 ```javascript
 const person = {
-  name: 'Lydia',
+  name: "Lydia",
   age: 21,
 };
 
 let city = person.city;
-city = 'Amsterdam';
+city = "Amsterdam";
 
 console.log(person);
 ```
@@ -2713,9 +2714,9 @@ Le variabili con la chiave `const` e `let` sono _block-scoped_. Un blocco è qua
 ###### 85. Che tipo di informazioni verrebbero loggate?
 
 ```javascript
-fetch('https://www.website.com/api/user/1')
-  .then(res => res.json())
-  .then(res => console.log(res));
+fetch("https://www.website.com/api/user/1")
+  .then((res) => res.json())
+  .then((res) => console.log(res));
 ```
 
 - A: Il risultato del metodo `fetch`.
@@ -2753,7 +2754,7 @@ function getName(name) {
 
 #### Risposta: A
 
-Con `!!name`, determiniamo se il valore di `name` è vero o falso. Se il nome è vero, cosa che vogliamo testare, `!name` restituisce `false`. 
+Con `!!name`, determiniamo se il valore di `name` è vero o falso. Se il nome è vero, cosa che vogliamo testare, `!name` restituisce `false`.
 `!false` (che è `!!name`) restituisce `true`.
 
 Impostando `hasName` uguale a `name`, imposti `hasName` uguale a qualsiasi valore passato alla funzione `getName`, non il valore booleano `true`.
@@ -2770,7 +2771,7 @@ Impostando `hasName` uguale a `name`, imposti `hasName` uguale a qualsiasi valor
 ###### 87. Qual è l'output?
 
 ```javascript
-console.log('I want pizza'[0]);
+console.log("I want pizza"[0]);
 ```
 
 - A: `"""`
@@ -2815,6 +2816,7 @@ sum(10);
 È possibile impostare il valore di un parametro predefinito uguale a un altro parametro della funzione, purché sia stato definito _prima_ del parametro predefinito. Passiamo il valore `10` alla funzione `sum`. Se la funzione `sum` riceve solo 1 argomento, significa che il valore di `num2` non è passato e il valore di `num1` è uguale al valore passato `10` in questo caso. Il valore predefinito di `num2` è il valore di `num1`, che è `10`. `num1 + num2` restituisce `20`.
 
 Se stai cercando di impostare il valore di un parametro predefinito uguale a un parametro che è definito _dopo_ (a destra), il valore del parametro non è stato ancora inizializzato, il che genererà un errore.
+
 </p>
 </details>
 
@@ -2824,11 +2826,11 @@ Se stai cercando di impostare il valore di un parametro predefinito uguale a un
 
 ```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);
 ```
@@ -2861,7 +2863,7 @@ class Person {
   }
 }
 
-const member = new Person('John');
+const member = new Person("John");
 console.log(typeof member);
 ```
 
@@ -2921,7 +2923,7 @@ Quindi quando proviamo a usare il metodo `.push` su `newList` poiché `newList`
 
 ```javascript
 function giveLydiaPizza() {
-  return 'Here is pizza!';
+  return "Here is pizza!";
 }
 
 const giveLydiaChocolate = () =>
@@ -2942,6 +2944,7 @@ console.log(giveLydiaChocolate.prototype);
 #### Risposta: D
 
 Le funzioni regolari, come la funzione `giveLydiaPizza`, hanno una proprietà `prototipo`, che è un oggetto (prototype object) con un `costruttore`. Tuttavia, le arrow functions, come la funzione `giveLydiaChocolate`, non hanno una proprietà `prototype`. Viene quindi restituito `undefined` quando si tenta di accedere alla proprietà `prototype` usando `giveLydiaChocolate.prototype`.
+
 </p>
 </details>
 
@@ -2951,7 +2954,7 @@ Le funzioni regolari, come la funzione `giveLydiaPizza`, hanno una proprietà `p
 
 ```javascript
 const person = {
-  name: 'Lydia',
+  name: "Lydia",
   age: 21,
 };
 
@@ -3011,7 +3014,7 @@ function getItems(fruitList, favoriteFruit, ...args) {
   return [...fruitList, ...args, favoriteFruit];
 }
 
-getItems(['banana', 'apple'], 'pear', 'orange');
+getItems(["banana", "apple"], "pear", "orange");
 ```
 
 L'esempio qui sopra invece funziona e restituisce l'array `[ 'banana', 'apple', 'orange', 'pear' ]`
@@ -3025,9 +3028,9 @@ L'esempio qui sopra invece funziona e restituisce l'array `[ 'banana', 'apple',
 
 ```javascript
 function nums(a, b) {
-  if (a > b) console.log('a is bigger');
-  else console.log('b is bigger');
-  return
+  if (a > b) console.log("a is bigger");
+  else console.log("b is bigger");
+  return;
   a + b;
 }
 
@@ -3045,10 +3048,10 @@ console.log(nums(1, 2));
 
 #### Risposta: B
 
-In JavaScript, non _è necessario_ scrivere il punto e virgola (`;`) in modo esplicito poiché il motore JavaScript li aggiunge comunque dopo le istruzioni. 
+In JavaScript, non _è necessario_ scrivere il punto e virgola (`;`) in modo esplicito poiché il motore JavaScript li aggiunge comunque dopo le istruzioni.
 Questo procedimento è chiamato **Automatic Semicolon Insertion**. Un'istruzione può ad esempio essere una variabile o parole chiave come `throw`, `return`, `break`, ecc.
 
-Qui, abbiamo scritto un'istruzione di `return` e un altro valore `a + b` su una _nuova riga_. Tuttavia, trattandosi di una nuova linea, il motore non sa che in realtà è il valore che volevamo restituire. Invece, ha aggiunto automaticamente un punto e virgola dopo `return`. 
+Qui, abbiamo scritto un'istruzione di `return` e un altro valore `a + b` su una _nuova riga_. Tuttavia, trattandosi di una nuova linea, il motore non sa che in realtà è il valore che volevamo restituire. Invece, ha aggiunto automaticamente un punto e virgola dopo `return`.
 
 Potresti considerare ad esempio:
 
@@ -3057,7 +3060,7 @@ return;
 a + b;
 ```
 
-`a + b` non viene mai raggiunto, poiché la funzione smette di funzionare dopo la parola chiave `return`. 
+`a + b` non viene mai raggiunto, poiché la funzione smette di funzionare dopo la parola chiave `return`.
 Se non viene restituito alcun valore, come qui, la funzione restituisce `undefined`. Nota: non c'è un inserimento automatico dopo le istruzioni `if/else`!
 
 </p>
@@ -3070,13 +3073,13 @@ Se non viene restituito alcun valore, come qui, la funzione restituisce `undefin
 ```javascript
 class Person {
   constructor() {
-    this.name = 'Lydia';
+    this.name = "Lydia";
   }
 }
 
 Person = class AnotherPerson {
   constructor() {
-    this.name = 'Sarah';
+    this.name = "Sarah";
   }
 };
 
@@ -3094,7 +3097,7 @@ console.log(member.name);
 
 #### Risposta: B
 
-Possiamo impostare classi uguali ad altre classi/costruttori di funzioni. In questo caso, impostiamo `Person` uguale a `AnotherPerson`. Il name su questo costruttore è `Sarah`, quindi la proprietà del nome di`Person` sulla nuova istanza `member`  è `"Sarah"`.
+Possiamo impostare classi uguali ad altre classi/costruttori di funzioni. In questo caso, impostiamo `Person` uguale a `AnotherPerson`. Il name su questo costruttore è `Sarah`, quindi la proprietà del nome di`Person` sulla nuova istanza `member` è `"Sarah"`.
 
 </p>
 </details>
@@ -3105,7 +3108,7 @@ Possiamo impostare classi uguali ad altre classi/costruttori di funzioni. In que
 
 ```javascript
 const info = {
-  [Symbol('a')]: 'b',
+  [Symbol("a")]: "b",
 };
 
 console.log(info);
@@ -3158,7 +3161,7 @@ La funzione `getList` riceve un array come argomento. Tra le parentesi della fun
 
 `[x, ...y] = [1, 2, 3, 4]`
 
-Con il parametro rest `...y`, mettiamo tutti gli argomenti "rimanenti" in un array. Gli argomenti rimanenti sono `2`, `3` e `4` in questo caso. 
+Con il parametro rest `...y`, mettiamo tutti gli argomenti "rimanenti" in un array. Gli argomenti rimanenti sono `2`, `3` e `4` in questo caso.
 Il valore di `y` è un array, contenente tutti i parametri rimanenti. Il valore di `x` è uguale a `1` in questo caso, quindi quando facciamo un console.log di `[x, y]`, viene loggato `[1, [2, 3, 4]]`.
 
 La funzione `getUser` riceve un oggetto. Con le arrow functions, non _è necessario_ scrivere parentesi graffe se restituiamo solo un valore. Tuttavia, se vuoi restituire istantaneamente un _oggetto_ da una arrow function, devi scriverlo tra parentesi tonde, altrimenti tutto ciò che si trova tra le due parentesi graffe verrà interpretato come un'istruzione di blocco. In questo caso il codice tra parentesi non è un codice JavaScript valido, quindi viene generato un `SyntaxError`.
@@ -3175,7 +3178,7 @@ La seguente funzione avrebbe restituito un oggetto:
 ###### 99. Qual è l'output?
 
 ```javascript
-const name = 'Lydia';
+const name = "Lydia";
 
 console.log(name());
 ```
@@ -3207,8 +3210,8 @@ I ReferenceErrors vengono generati quando JavaScript non è in grado di trovare
 ```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`
@@ -3234,7 +3237,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);
@@ -3266,16 +3269,16 @@ Con l'operatore `||` possiamo restituire il primo operando veritiero. Se tutti i
 ###### 102. Qual è il valore dell'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');
+  myPromise().then((res) => console.log(res));
+  console.log("second");
 }
 
 async function secondFunction() {
   console.log(await myPromise());
-  console.log('second');
+  console.log("second");
 }
 
 firstFunction();
@@ -3313,8 +3316,8 @@ Ciò significa che ha aspettato che `myPromise` si risolvesse con il valore `I h
 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);
@@ -3374,13 +3377,13 @@ In questo caso, abbiamo appena passato il valore numerico `5`. Restituisce una p
 ```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);
 ```
@@ -3419,7 +3422,7 @@ const colorConfig = {
   yellow: false,
 };
 
-const colors = ['pink', 'red', 'blue'];
+const colors = ["pink", "red", "blue"];
 
 console.log(colorConfig.colors[1]);
 ```
@@ -3448,7 +3451,7 @@ JavaScript interpreta (o decomprime) le istruzioni. Quando usiamo la notazione t
 ###### 107. Qual è il suo valore?
 
 ```javascript
-console.log('❤️' === '❤️');
+console.log("❤️" === "❤️");
 ```
 
 - A: `true`
@@ -3469,14 +3472,14 @@ Le emoji sono unicode. L'unicode per l'emoji del cuore è `"U+2764 U+FE0F"`. Que
 ###### 108. Quale di questi metodi modifica l'array originale?
 
 ```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`
@@ -3492,6 +3495,7 @@ emojis.splice(1, 2, '✨');
 Con il metodo `splice` modifichiamo l'array originale cancellando, sostituendo o aggiungendo elementi. In questo caso, abbiamo rimosso 2 elementi dall'indice 1 (abbiamo rimosso `'🥑'` e `'😍'`) e aggiunto invece l'emoji ✨.
 
 `map`, `filter` e `slice` restituiscono un nuovo array, `find` restituisce un elemento e `reduce` restituisce un valore ridotto.
+
 </p>
 </details>
 
@@ -3500,10 +3504,10 @@ Con il metodo `splice` modifichiamo l'array originale cancellando, sostituendo o
 ###### 109. Qual è l'output?
 
 ```javascript
-const food = ['🍕', '🍫', '🥑', '🍔'];
+const food = ["🍕", "🍫", "🥑", "🍔"];
 const info = { favoriteFood: food[0] };
 
-info.favoriteFood = '🍝';
+info.favoriteFood = "🍝";
 
 console.log(food);
 ```
@@ -3523,6 +3527,7 @@ Impostiamo il valore della proprietà `favoriteFood` sull'oggetto `info` uguale
 In JavaScript, i tipi di dati primitivi (tutto ciò che non è un oggetto) interagiscono per _value_. In questo caso, impostiamo il valore della proprietà `favoriteFood` sull'oggetto `info` uguale al valore del primo elemento nell'array `food`, in questo caso la stringa con l'emoji della pizza (`'🍕'`). Una stringa è un tipo di dati primitivo e interagisce per valore (vedi il mio [blogpost](https://www.theavocoder.com/complete-javascript/2018/12/21/by-value-vs-by-reference) se sei interessato a saperne di più).
 
 Quindi, cambiamo il valore della proprietà `favoriteFood` sull'oggetto `info`. L'array `food` non è cambiato, poiché il valore di `favoriteFood` era semplicemente una _copia_ del valore del primo elemento nell'array e non ha un riferimento allo stesso punto in memoria dell'elemento su ` food[0]`. Quando logghiamo food, è ancora l'array originale, `['🍕', '🍫', '🥑', '🍔']`.
+
 </p>
 </details>
 
@@ -3556,7 +3561,7 @@ const jsonArray = JSON.stringify([1, 2, 3]); // '[1, 2, 3]'
 JSON.parse(jsonArray); // [1, 2, 3]
 
 // Stringhiamo un object in un JSON valido, quindi analizziamo la stringa JSON come valore JavaScript:
-const jsonArray = JSON.stringify({ name: 'Lydia' }); // '{"name":"Lydia"}'
+const jsonArray = JSON.stringify({ name: "Lydia" }); // '{"name":"Lydia"}'
 JSON.parse(jsonArray); // { name: 'Lydia' }
 ```
 
@@ -3568,11 +3573,11 @@ JSON.parse(jsonArray); // { name: 'Lydia' }
 ###### 111. Qual è l'output?
 
 ```javascript
-let name = 'Lydia';
+let name = "Lydia";
 
 function getName() {
   console.log(name);
-  let name = 'Sarah';
+  let name = "Sarah";
 }
 
 getName();
@@ -3595,7 +3600,7 @@ Le variabili con la chiave `let` (e `const`) vengono sollevate, ma a differenza
 Se non avessimo dichiarato la variabile `name` all'interno della funzione `getName`, JavaScript avrebbe esaminato la _scope chain_. Lo scope esterno ha una variabile chiamata `name` con il valore di `Lydia`. In tal caso, avrebbe loggato "Lydia".
 
 ```javascript
-let name = 'Lydia';
+let name = "Lydia";
 
 function getName() {
   console.log(name);
@@ -3613,11 +3618,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();
@@ -3663,7 +3668,7 @@ console.log(two.next().value); // undefined
 ###### 113. Qual è l'output?
 
 ```javascript
-console.log(`${(x => x)('I love')} to program`);
+console.log(`${((x) => x)("I love")} to program`);
 ```
 
 - A: `I love to program`
@@ -3688,7 +3693,7 @@ Le espressioni all'interno dei template literals vengono valutate per prime. Ci
 ```javascript
 let config = {
   alert: setInterval(() => {
-    console.log('Alert!');
+    console.log("Alert!");
   }, 1000),
 };
 
@@ -3720,16 +3725,16 @@ Dal momento che non è stato cancellato, la funzione di callback `setInterval` v
 
 ```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
@@ -3756,14 +3761,14 @@ Quando si aggiunge una coppia chiave/valore usando il metodo `set`, la chiave sa
 
 ```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);
@@ -3787,6 +3792,7 @@ Entrambe le funzioni `changeAge` e `changeAgeAndName` hanno un parametro predefi
 Per prima cosa, invochiamo la funzione `changeAge` e passiamo l'oggetto `person` come argomento. Questa funzione aumenta il valore della proprietà `age` di 1. `person` ora è `{ name: "Lydia", age: 22 }`.
 
 Quindi, invochiamo la funzione `changeAgeAndName`, tuttavia non passiamo un parametro. Invece, il valore di `x` è uguale a un _nuovo_ oggetto: `{ ...person }`. Poiché si tratta di un nuovo oggetto, non influisce sui valori delle proprietà sull'oggetto `person`. `person` è ancora uguale a `{ name: "Lydia", age: 22 }`.
+
 </p>
 </details>
 
@@ -3821,7 +3827,7 @@ Con l'operatore spread `...`, possiamo _distribuire_ gli iterabili come singoli
 
 ```javascript
 let num = 1;
-const list = ['🥳', '🤠', '🥰', '🤪'];
+const list = ["🥳", "🤠", "🥰", "🤪"];
 
 console.log(list[(num += 1)]);
 ```
@@ -3847,11 +3853,11 @@ Con l'operando `+=`, stiamo incrementando il valore di `num` di `1`. `num` aveva
 
 ```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}`;
@@ -3889,10 +3895,10 @@ Con l'operatore di concatenamento opzionale `?.`, non è più necessario verific
 ###### 120. Qual è l'output?
 
 ```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!`);
 }
@@ -3948,10 +3954,10 @@ Il metodo `language` è un `setter`. I setter non detengono un valore effettivo,
 ###### 122. Qual è l'output?
 
 ```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`
@@ -3967,6 +3973,7 @@ console.log(!typeof name === 'string');
 `typeof name` restituisce `"string"`. La stringa `"string"` è un valore veritiero, quindi `!typeof name` restituisce il valore booleano `false`. `false === "object"` e `false === "string"` restituiscono entrambi `false`.
 
 (Se volessimo verificare se il tipo era (non)uguale a un certo tipo, avremmo dovuto scrivere `!==` invece di `!typeof`)
+
 </p>
 </details>
 
@@ -3975,7 +3982,7 @@ console.log(!typeof name === 'string');
 ###### 123. Qual è l'output?
 
 ```javascript
-const add = x => y => z => {
+const add = (x) => (y) => (z) => {
   console.log(x, y, z);
   return x + y + z;
 };
@@ -3993,7 +4000,7 @@ add(4)(5)(6);
 
 #### Risposta: A
 
-La funzione `add` restituisce una arrow function, che restituisce una arrow function, che restituisce arrow function (mi segui ancora?). 
+La funzione `add` restituisce una arrow function, che restituisce una arrow function, che restituisce arrow function (mi segui ancora?).
 La prima funzione riceve un argomento `x` con il valore di `4`. Invochiamo la seconda funzione, che riceve un argomento `y` con il valore `5`. Quindi invochiamo la terza funzione, che riceve un argomento `z` con il valore `6`. Quando si tenta di accedere ai valori `x`, `y` e `z` all'interno dell'ultima arrow function, il motore JS risale la catena dell'ambito per trovare i valori per `x` e `y`. Questo restituisce `4` `5` `6`.
 
 </p>
@@ -4066,20 +4073,20 @@ 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}`;
 }
 
-console.log(getFine(130, 300))
+console.log(getFine(130, 300));
 ```
 
 - A: The driver drove 130 and has to pay 300
@@ -4102,8 +4109,8 @@ Con il metodo `Intl.NumberFormat`, possiamo formattare i valori numerici in qual
 ###### 127. Qual è l'output?
 
 ```javascript
-const spookyItems = ['👻', '🎃', '🕸'];
-({ item: spookyItems[3] } = { item: '💀' });
+const spookyItems = ["👻", "🎃", "🕸"];
+({ item: spookyItems[3] } = { item: "💀" });
 
 console.log(spookyItems);
 ```
@@ -4128,7 +4135,7 @@ Destrutturando gli oggetti, possiamo decomprimere i valori dall'oggetto di destr
 ###### 128. Qual è l'output?
 
 ```javascript
-const name = 'Lydia Hallie';
+const name = "Lydia Hallie";
 const age = 21;
 
 console.log(Number.isNaN(name));
@@ -4151,6 +4158,7 @@ console.log(isNaN(age));
 Con il metodo `Number.isNaN`, puoi controllare se il valore passato è un _valore numerico_ e uguale a `NaN`. `name` non è un valore numerico, quindi `Number.isNaN(name)` restituisce `false`. `age` è un valore numerico, ma non è uguale a `NaN`, quindi `Numero.isNaN(age)` restituisce `false`.
 
 Con il metodo `isNaN`, puoi verificare se il valore che passi non è un numero. `name` non è un numero, quindi `isNaN(name)` restituisce true. `age` è un numero, quindi `isNaN(age)` restituisce `false`.
+
 </p>
 </details>
 
@@ -4163,7 +4171,7 @@ const randomValue = 21;
 
 function getInfo() {
   console.log(typeof randomValue);
-  const randomValue = 'Lydia Hallie';
+  const randomValue = "Lydia Hallie";
 }
 
 getInfo();
@@ -4180,6 +4188,7 @@ getInfo();
 #### Risposta: D
 
 Le variabili dichiarate con la chiave `const` non sono referenziabili prima della loro inizializzazione: questa viene chiamata _temporal dead zone_. Nella funzione `getInfo`, la variabile `randomValue` ha lo scopo nell'ambito funzionale di `getInfo`. Nella riga in cui vogliamo registrare il valore di `typeof randomValue`, la variabile `randomValue` non è ancora inizializzata: viene lanciato un `ReferenceError`! Il motore non è andato giù per la catena dell'ambito poiché abbiamo dichiarato la variabile `randomValue` nella funzione `getInfo`.
+
 </p>
 </details>
 
@@ -4188,7 +4197,7 @@ Le variabili dichiarate con la chiave `const` non sono referenziabili prima dell
 ###### 130. Qual è l'output?
 
 ```javascript
-const myPromise = Promise.resolve('Woah some cool data');
+const myPromise = Promise.resolve("Woah some cool data");
 
 (async () => {
   try {
@@ -4196,7 +4205,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!");
   }
 })();
 ```
@@ -4221,7 +4230,7 @@ Nel blocco `try`, stiamo loggando il valore atteso della variabile `myPromise`:
 ###### 131. Qual è l'output?
 
 ```javascript
-const emojis = ['🥑', ['✨', '✨', ['🍕', '🍕']]];
+const emojis = ["🥑", ["✨", "✨", ["🍕", "🍕"]]];
 
 console.log(emojis.flat(1));
 ```
@@ -4237,6 +4246,7 @@ console.log(emojis.flat(1));
 #### Risposta: B
 
 Con il metodo `flat`, possiamo creare un nuovo array appiattito. La profondità dell'array appiattito dipende dal valore che passiamo. In questo caso, abbiamo passato il valore `1` (cosa che non dovevamo fare, questo è il valore predefinito), il che significa che solo gli array sulla prima profondità verranno concatenati. `['🥑']` e `['✨', '✨', ['🍕', '🍕']]` in questo caso. Concatenando questi due array si ottengono `['🥑', '✨', '✨', ['🍕', '🍕']]`.
+
 </p>
 </details>
 
@@ -4293,19 +4303,19 @@ Invochiamo `counterTwo.increment()`, che imposta `count` su `3`. Quindi, logghia
 ###### 133. Qual è l'output?
 
 ```javascript
-const myPromise = Promise.resolve(Promise.resolve('Promise'));
+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!');
+  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!');
+  console.log(`${res} 2!`);
+  setTimeout(() => console.log("Timeout 2!"), 0);
+  console.log("Last line 2!");
 }
 
 funcOne();
@@ -4335,6 +4345,7 @@ In `funcTwo`, la variabile `res` ottiene `Promise` perché `Promise.resolve(Prom
 Quindi lo stack di chiamate è vuoto. Le promise sono _microattività_, quindi vengono risolte per prime quando lo stack di chiamate è vuoto, quindi `Promise 1!` viene registrato.
 
 Ora, da quando `funcTwo` è uscito dallo stack delle chiamate, lo stack delle chiamate è vuoto. Le callback in attesa nella coda (`() => console.log("Timeout 1!")` da `funcOne`, e `() => console.log("Timeout 2!")` da `funcTwo`) vengono aggiunti allo stack di chiamate uno per uno. Il primo callback registra `Timeout 1!` e viene eliminato dallo stack. Quindi, il secondo callback registra `Timeout 2!` e viene eliminato dallo stack.
+
 </p>
 </details>
 
@@ -4349,7 +4360,7 @@ export default function sum(x) {
 }
 
 // index.js
-import * as sum from './sum';
+import * as sum from "./sum";
 ```
 
 - A: `sum(4)`
@@ -4366,12 +4377,12 @@ Con l'asterisco `*`, importiamo tutti i valori esportati da quel file, sia prede
 
 ```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);
 ```
 
@@ -4402,13 +4413,13 @@ Possiamo invocare questa funzione, chiamando `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;
 ```
 
@@ -4438,7 +4449,7 @@ Quindi, accediamo a un valore di proprietà sull'oggetto proxy, la proprietà `g
 ###### 136. Quale delle seguenti opzioni modificherà l'oggetto `persona`?
 
 ```javascript
-const person = { name: 'Lydia Hallie' };
+const person = { name: "Lydia Hallie" };
 
 Object.seal(person);
 ```
@@ -4466,9 +4477,9 @@ Tuttavia, puoi comunque modificare il valore delle proprietà esistenti.
 
 ```javascript
 const person = {
-  name: 'Lydia Hallie',
+  name: "Lydia Hallie",
   address: {
-    street: '100 Main St',
+    street: "100 Main St",
   },
 };
 
@@ -4497,7 +4508,7 @@ Tuttavia, blocca solo _poco profondamente_ l'oggetto, il che significa che solo
 ###### 138. Qual è l'output?
 
 ```javascript
-const add = x => x + x;
+const add = (x) => x + x;
 
 function myFunc(num = 2, value = add(num)) {
   console.log(num, value);
@@ -4519,7 +4530,7 @@ myFunc(3);
 
 Per prima cosa, abbiamo invocato `myFunc()` senza passare alcun argomento. Dal momento che non abbiamo passato argomenti, `num` e `value` hanno i loro valori predefiniti: num è `2` e `value` il valore restituito dalla funzione `add`. Alla funzione `add`, passiamo `num` come argomento, che aveva il valore di `2`. `add` restituisce `4`, che è il valore di `value`.
 
-Quindi, abbiamo invocato `myFunc(3)` e passato il valore `3` come valore per l'argomento `num`. Non abbiamo passato un argomento per `value`. 
+Quindi, abbiamo invocato `myFunc(3)` e passato il valore `3` come valore per l'argomento `num`. Non abbiamo passato un argomento per `value`.
 Poiché non abbiamo passato un valore per l'argomento `value`, ha ottenuto il valore predefinito: il valore restituito dalla funzione `add`. Ad `add` passiamo `num`, che ha il valore di `3`. `add` restituisce `6`, che è il valore di `value`.
 
 </p>
@@ -4531,21 +4542,21 @@ Poiché non abbiamo passato un valore per l'argomento `value`, ha ottenuto il va
 
 ```javascript
 class Counter {
-  #number = 10
+  #number = 10;
 
   increment() {
-    this.#number++
+    this.#number++;
   }
 
   getNum() {
-    return this.#number
+    return this.#number;
   }
 }
 
-const counter = new Counter()
-counter.increment()
+const counter = new Counter();
+counter.increment();
 
-console.log(counter.#number)
+console.log(counter.#number);
 ```
 
 - A: `10`
@@ -4569,8 +4580,8 @@ In ES2020, possiamo aggiungere variabili private nelle classi usando `#`. Non po
 
 ```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) {
@@ -4613,8 +4624,8 @@ Se avessimo scritto `yield`, `return yield` o `return`, l'intera funzione del ge
 
 ```javascript
 const person = {
-  name: 'Lydia Hallie',
-  hobbies: ['coding'],
+  name: "Lydia Hallie",
+  hobbies: ["coding"],
 };
 
 function addHobby(hobby, hobbies = person.hobbies) {
@@ -4622,9 +4633,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);
 ```
@@ -4683,7 +4694,7 @@ const pet = new Flamingo();
 
 #### Risposta: B
 
-Creiamo la variabile `pet` che è un'istanza della classe `Flamingo`. Quando istanziamo questa istanza, il `constructor` su `Flamingo` viene chiamato. Per prima cosa, `"I'm pink. 🌸"` viene loggato, dopodiché chiamiamo `super()`. 
+Creiamo la variabile `pet` che è un'istanza della classe `Flamingo`. Quando istanziamo questa istanza, il `constructor` su `Flamingo` viene chiamato. Per prima cosa, `"I'm pink. 🌸"` viene loggato, dopodiché chiamiamo `super()`.
 
 `super()` chiama il costruttore della classe genitore, `Bird`. Il costruttore in `Bird` viene chiamato e registra `"I'm a bird. 🦢"`.
 
@@ -4695,11 +4706,11 @@ Creiamo la variabile `pet` che è un'istanza della classe `Flamingo`. Quando ist
 ###### 143. Quale delle opzioni genera un errore?
 
 ```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;
 ```
 
@@ -4741,7 +4752,7 @@ const person = {
 
 #### Risposta: C
 
-Gli oggetti non sono iterabili per impostazione predefinita. Un iterabile è un iterabile se è presente il protocollo iteratore. 
+Gli oggetti non sono iterabili per impostazione predefinita. Un iterabile è un iterabile se è presente il protocollo iteratore.
 Possiamo aggiungerlo manualmente aggiungendo il simbolo dell'iteratore `[Symbol.iterator]`, che deve restituire un oggetto generatore, ad esempio trasformandolo in una funzione del generatore `*[Symbol.iterator]() {}`. Questa funzione di generazione deve fornire gli `Object.values` dell'oggetto `person` se vogliamo che restituisca l'array `["Lydia Hallie", 21]`: `yield* Object.values(this)`.
 
 </p>
@@ -4755,11 +4766,11 @@ Possiamo aggiungerlo manualmente aggiungendo il simbolo dell'iteratore `[Symbol.
 let count = 0;
 const nums = [0, 1, 2, 3];
 
-nums.forEach(num => {
-	if (num) count += 1
-})
+nums.forEach((num) => {
+  if (num) count += 1;
+});
 
-console.log(count)
+console.log(count);
 ```
 
 - A: 1
@@ -4783,12 +4794,12 @@ La condizione `if` all'interno del ciclo `forEach` controlla se il valore di `nu
 
 ```javascript
 function getFruit(fruits) {
-	console.log(fruits?.[1]?.[1])
+  console.log(fruits?.[1]?.[1]);
 }
 
-getFruit([['🍊', '🍌'], ['🍍']])
-getFruit()
-getFruit([['🍍'], ['🍊', '🍌']])
+getFruit([["🍊", "🍌"], ["🍍"]]);
+getFruit();
+getFruit([["🍍"], ["🍊", "🍌"]]);
 ```
 
 - A: `null`, `undefined`, 🍌
@@ -4808,6 +4819,7 @@ Innanzitutto, stiamo cercando di registrare il secondo elemento nel sottoarray `
 Quindi, stiamo invocando la funzione `getFruits` senza passare un valore come argomento, il che significa che `fruits` ha un valore di `undefined` per impostazione predefinita. Poiché stiamo concatenando condizionatamente l'elemento sull'indice `1` di `fruits`, restituisce `undefined` poiché questo elemento sull'indice `1` non esiste.
 
 Infine, stiamo cercando di registrare il secondo elemento nel sottoarray `['🍊', '🍌']` di `['🍍'], ['🍊', '🍌']`. L'elemento nell'indice `1` all'interno di questo sottoarray è `🍌`, che viene registrato.
+
 </p>
 </details>
 
@@ -4817,19 +4829,19 @@ Infine, stiamo cercando di registrare il secondo elemento nel sottoarray `['🍊
 
 ```javascript
 class Calc {
-	constructor() {
-		this.count = 0 
-	}
+  constructor() {
+    this.count = 0;
+  }
 
-	increase() {
-		this.count ++
-	}
+  increase() {
+    this.count++;
+  }
 }
 
-const calc = new Calc()
-new Calc().increase()
+const calc = new Calc();
+new Calc().increase();
 
-console.log(calc.count)
+console.log(calc.count);
 ```
 
 - A: `0`
@@ -4843,6 +4855,7 @@ console.log(calc.count)
 #### Risposta: A
 
 Impostiamo la variabile `calc` uguale a una nuova istanza della classe `Calc`. Quindi, istanziamo una nuova `Calc` e invochiamo il metodo `increase` su questa istanza. Poiché la proprietà count è all'interno del costruttore della classe `Calc`, la proprietà count non è condivisa sul prototipo di `Calc`. Ciò significa che il valore di count non è stato aggiornato per l'istanza a cui punta il calc, count è ancora `0`.
+
 </p>
 </details>
 
@@ -4852,25 +4865,25 @@ Impostiamo la variabile `calc` uguale a una nuova istanza della classe `Calc`. Q
 
 ```javascript
 const user = {
-	email: "e@mail.com",
-	password: "12345"
-}
+  email: "e@mail.com",
+  password: "12345",
+};
 
 const updateUser = ({ email, password }) => {
-	if (email) {
-		Object.assign(user, { email })
-	}
+  if (email) {
+    Object.assign(user, { email });
+  }
 
-	if (password) {
-		user.password = password
-	}
+  if (password) {
+    user.password = password;
+  }
 
-	return user
-}
+  return user;
+};
 
-const updatedUser = updateUser({ email: "new@email.com" })
+const updatedUser = updateUser({ email: "new@email.com" });
 
-console.log(updatedUser === user)
+console.log(updatedUser === user);
 ```
 
 - A: `false`
@@ -4893,13 +4906,13 @@ La funzione `updateUser` aggiorna i valori delle proprietà `email` e `password`
 ###### 149. Qual è l'output?
 
 ```javascript
-const fruit = ['🍌', '🍊', '🍎']
+const fruit = ["🍌", "🍊", "🍎"];
 
-fruit.slice(0, 1)
-fruit.splice(0, 1)
-fruit.unshift('🍇')
+fruit.slice(0, 1);
+fruit.splice(0, 1);
+fruit.unshift("🍇");
 
-console.log(fruit)
+console.log(fruit);
 ```
 
 - A: `['🍌', '🍊', '🍎']`
@@ -4925,13 +4938,13 @@ Infine, invochiamo il metodo `unshift` sull'array `fruit`, che modifica l'array
 
 ```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])
+console.log(animals[dog]);
 ```
 
 - A: `{ emoji: "🐶", name: "Mara" }`
@@ -4946,12 +4959,12 @@ console.log(animals[dog])
 
 Le chiavi degli oggetti vengono convertite in stringhe.
 
-Poiché il valore di `dog` è un oggetto, `animals[dog]` significa in realtà che stiamo creando una nuova proprietà chiamata `"object Object"` uguale al nuovo oggetto. 
+Poiché il valore di `dog` è un oggetto, `animals[dog]` significa in realtà che stiamo creando una nuova proprietà chiamata `"object Object"` uguale al nuovo oggetto.
 `animals["object Object"]` è ora uguale a `{ emoji: "🐶", name: "Mara"}`.
 
 Anche `cat` è un oggetto, il che significa che `animals[cat]` in realtà stiamo sovrascrivendo il valore di `animals["object Object"]` con le nuove proprietà cat.
 
-Loggando `animals[dog]`, o effettivamente `animals["object Object"]`, poiché la conversione dell'oggetto `dog` in una stringa risulta `"object Object"`, restituisce  `{ emoji: "🐈", name: "Sara" }`.
+Loggando `animals[dog]`, o effettivamente `animals["object Object"]`, poiché la conversione dell'oggetto `dog` in una stringa risulta `"object Object"`, restituisce `{ emoji: "🐈", name: "Sara" }`.
 
 </p>
 </details>
@@ -4962,14 +4975,14 @@ Loggando `animals[dog]`, o effettivamente `animals["object Object"]`, poiché la
 
 ```javascript
 const user = {
-	email: "my@email.com",
-	updateEmail: email => {
-		this.email = email
-	}
-}
+  email: "my@email.com",
+  updateEmail: (email) => {
+    this.email = email;
+  },
+};
 
-user.updateEmail("new@email.com")
-console.log(user.email)
+user.updateEmail("new@email.com");
+console.log(user.email);
 ```
 
 - A: `my@email.com`
@@ -4992,20 +5005,20 @@ La funzione `updateEmail` è una arrow function e non è legata all'oggetto `use
 ###### 152. Qual è l'output?
 
 ```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])
-	const res2  = await Promise.all([promise3, promise4])
-	return [res1, res2]
-}
+  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))
+  .then((res) => console.log(res))
+  .catch((err) => console.log(err));
 ```
 
 - A: `[['First', 'Second'], ['Fourth']]`
@@ -5025,16 +5038,19 @@ Il metodo `Promise.all` esegue le promise passate in parallelo. Se una promise f
 
 ---
 
-###### 153. Quale dovrebbe essere il valore di `method` per loggare ` {nome: "Lydia", età: 22} `?
+###### 153. Quale dovrebbe essere il valore di `method` per loggare `{nome: "Lydia", età: 22}`?
 
 ```javascript
-const keys = ["name", "age"]
-const values = ["Lydia", 22]
+const keys = ["name", "age"];
+const values = ["Lydia", 22];
 
-const method = /* ?? */
-Object[method](keys.map((_, i) => {
-	return [keys[i], values[i]]
-})) // { name: "Lydia", age: 22 }
+const method =
+  /* ?? */
+  Object[method](
+    keys.map((_, i) => {
+      return [keys[i], values[i]];
+    })
+  ); // { name: "Lydia", age: 22 }
 ```
 
 - A: `entries`
@@ -5059,18 +5075,18 @@ Questo crea una matrice di sottoarray contenenti le chiavi e i valori corretti,
 ###### 154. Qual è l'output?
 
 ```javascript
-const createMember = ({ email, address = {}}) => {
-	const validEmail = /.+\@.+\..+/.test(email)
-	if (!validEmail) throw new Error("Valid email pls")
+const createMember = ({ email, address = {} }) => {
+  const validEmail = /.+\@.+\..+/.test(email);
+  if (!validEmail) throw new Error("Valid email pls");
 
-	return {
-		email,
-		address: address ? address : null
-	}
-}
+  return {
+    email,
+    address: address ? address : null,
+  };
+};
 
-const member = createMember({ email: "my@email.com" })
-console.log(member)
+const member = createMember({ email: "my@email.com" });
+console.log(member);
 ```
 
 - A: `{ email: "my@email.com", address: null }`
@@ -5093,13 +5109,13 @@ Il valore predefinito di `address` è un oggetto vuoto `{}`. Quando abbiamo impo
 ###### 155. Qual è l'output?
 
 ```javascript
-let randomValue = { name: "Lydia" }
-randomValue = 23
+let randomValue = { name: "Lydia" };
+randomValue = 23;
 
 if (!typeof randomValue === "string") {
-	console.log("It's not a string!")
+  console.log("It's not a string!");
 } else {
-	console.log("Yay it's a string!")
+  console.log("Yay it's a string!");
 }
 ```
 
diff --git a/ja-JA/README-ja_JA.md b/ja-JA/README-ja_JA.md
index 1cc85d76..6fcf3655 100644
--- a/ja-JA/README-ja_JA.md
+++ b/ja-JA/README-ja_JA.md
@@ -1,13 +1,13 @@
-# JavaScript  (高度な) 問題集
+# JavaScript (高度な) 問題集
 
-私は毎日、JavaScriptに関する選択問題を [Instagram](https://www.instagram.com/theavocoder)に投稿していますが、ここにも投稿します。
+私は毎日、JavaScript に関する選択問題を [Instagram](https://www.instagram.com/theavocoder)に投稿していますが、ここにも投稿します。
 
-初級から上級まで： JavaScriptの知識のテストを行ったり、知識を少し深めたり、コーディング面接の準備をしてください。:muscle: :rocket: 私はこのレポを毎週新しい質問で更新します。Last update: <a href=#20190629><b>June 29th</b></a>
+初級から上級まで： JavaScript の知識のテストを行ったり、知識を少し深めたり、コーディング面接の準備をしてください。:muscle: :rocket: 私はこのレポを毎週新しい質問で更新します。Last update: <a href=#20190629><b>June 29th</b></a>
 
 答えは質問の下の折りたたまれたセクションにあります、クリックすればそれを広げられます。幸運を祈ります。:heart:
 
-
 利用可能な言語リスト:
+
 - [🇸🇦 العربية](../ar-AR/README_AR.md)
 - [🇪🇬 اللغة العامية](../ar-EG/README_ar-EG.md)
 - [🇧🇦 Bosanski](../bs-BS/README-bs_BS.md)
@@ -21,6 +21,7 @@
 - [🇳🇱 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)
@@ -55,13 +56,13 @@ sayHi();
 
 #### 答え: D
 
-関数内で、まず `var`キーワードを使って `name`変数を宣言します。これは、変数が定義されている行に実際に到達するまで、変数がデフォルト値の `undefined`で初期化される（作成時にメモリ空間が設定される）ことを意味します。 
+関数内で、まず `var`キーワードを使って `name`変数を宣言します。これは、変数が定義されている行に実際に到達するまで、変数がデフォルト値の `undefined`で初期化される（作成時にメモリ空間が設定される）ことを意味します。
 
 `name`変数をログ出力を実行している行では、まだ変数を定義していませんので、`undefined`の値を保持しています。
 
 `let`キーワード（または`const`）を持つ変数は持ち上げられますが、 `var`とは異なり、初期化されません。それらを宣言（初期化）する行の前にはアクセスできません。これは"temporal dead zone"と呼ばれます。
 
-宣言される前に変数にアクセスしようとすると、JavaScriptは `ReferenceError`を投げます。
+宣言される前に変数にアクセスしようとすると、JavaScript は `ReferenceError`を投げます。
 
 </p>
 </details>
@@ -89,9 +90,9 @@ for (let i = 0; i < 3; i++) {
 
 #### 答え: C
 
-JavaScriptのイベントキューのため、`setTimeout`コールバック関数はループが実行された後に呼び出されます。最初のループの変数 `i`は`var`キーワードを使って宣言されているので、この値はグローバル変数となります。ループの間、単項演算子 `++`を使用して、毎回 `i`の値を`1`ずつインクリメントしました。 最初の例では `setTimeout`コールバック関数が呼び出されるまでに`i`は`3`となりました。
+JavaScript のイベントキューのため、`setTimeout`コールバック関数はループが実行された後に呼び出されます。最初のループの変数 `i`は`var`キーワードを使って宣言されているので、この値はグローバル変数となります。ループの間、単項演算子 `++`を使用して、毎回 `i`の値を`1`ずつインクリメントしました。 最初の例では `setTimeout`コールバック関数が呼び出されるまでに`i`は`3`となりました。
 
-2番目のループでは、変数 `i`が `let`キーワードを使って宣言されました。 `let`（または`const`）キーワードで宣言された変数はブロックスコープです（ブロックは `{}`の間のものです）。それぞれの繰り返しの間、 `i`は新しい値を持ち、それぞれの値はループの内側にあります。
+2 番目のループでは、変数 `i`が `let`キーワードを使って宣言されました。 `let`（または`const`）キーワードで宣言された変数はブロックスコープです（ブロックは `{}`の間のものです）。それぞれの繰り返しの間、 `i`は新しい値を持ち、それぞれの値はループの内側にあります。
 
 </p>
 </details>
@@ -106,7 +107,7 @@ const shape = {
   diameter() {
     return this.radius * 2;
   },
-  perimeter: () => 2 * Math.PI * this.radius
+  perimeter: () => 2 * Math.PI * this.radius,
 };
 
 shape.diameter();
@@ -125,7 +126,7 @@ shape.perimeter();
 
 `diameter`の値は正則関数であり、`perimeter`の値はアロー関数です。
 
-アロー関数では、`this`キーワードは通常の関数とは異なり、現在の周囲の範囲を参照します。これは、`perimeter`関数を呼ぶと、shapeオブジェクトではなく、その周囲の範囲（例えば window）を参照することを意味します。
+アロー関数では、`this`キーワードは通常の関数とは異なり、現在の周囲の範囲を参照します。これは、`perimeter`関数を呼ぶと、shape オブジェクトではなく、その周囲の範囲（例えば window）を参照することを意味します。
 
 そのオブジェクトには`radius`という値はなく、`undefined`を返します。
 
@@ -152,7 +153,7 @@ shape.perimeter();
 
 単項プラスは、オペランドを数値に変換しようとします。`true`は`1`、`false`は`0`です
 
-文字列「Lydia」は truthy valueです。ここで求めているのは、「このtruthy valueは、falsyなのか」ということです。これは `false`を返します。
+文字列「Lydia」は truthy value です。ここで求めているのは、「この truthy value は、falsy なのか」ということです。これは `false`を返します。
 
 </p>
 </details>
@@ -163,12 +164,12 @@ shape.perimeter();
 
 ```javascript
 const bird = {
-  size: "small"
+  size: "small",
 };
 
 const mouse = {
   name: "Mickey",
-  small: true
+  small: true,
 };
 ```
 
@@ -182,15 +183,15 @@ const mouse = {
 
 #### 答え: A
 
-JavaScriptでは、すべてのオブジェクトキーは文字列です（Symbolでない限り）。たとえそれを文字列として入力していなくても、それらは常にフードの下で文字列に変換されます。
+JavaScript では、すべてのオブジェクトキーは文字列です（Symbol でない限り）。たとえそれを文字列として入力していなくても、それらは常にフードの下で文字列に変換されます。
 
-JavaScriptは、ステートメントを解釈（または、ボックス解除）します。大括弧表記を使用すると、最初の左大括弧 `[`を見て、右大括弧 `]`が見つかるまで進みます。その時だけ、そのステートメントを評価します。
+JavaScript は、ステートメントを解釈（または、ボックス解除）します。大括弧表記を使用すると、最初の左大括弧 `[`を見て、右大括弧 `]`が見つかるまで進みます。その時だけ、そのステートメントを評価します。
 
 `mouse [bird.size]`： まず最初に、`bird.size`が評価されます。これは文字列の `"small"`となります。 `mouse["small"]`は、`true`を返します。
 
 しかし、ドット表記では、これは起こりません。 `mouse`は`bird`と呼ばれるキーを持っていません。 つまり`mouse.bird`は`undefined`となります。
 
-また、ドット表記を使って `size`を求めます： `mouse.bird.size`。 mouse.birdは未定義なので、実際にはundefined.sizeを要求しています。これは有効ではないので、`Cannot read property "size" of undefined`ような、エラーをスローします。
+また、ドット表記を使って `size`を求めます： `mouse.bird.size`。 mouse.bird は未定義なので、実際には undefined.size を要求しています。これは有効ではないので、`Cannot read property "size" of undefined`ような、エラーをスローします。
 
 </p>
 </details>
@@ -221,13 +222,13 @@ console.log(d.greeting);
 
 #### 答え: A
 
-JavaScriptでは、すべてのオブジェクトは互いに等しく設定すると参照によって相互作用します。
+JavaScript では、すべてのオブジェクトは互いに等しく設定すると参照によって相互作用します。
 
 まず、変数`c`は、オブジェクトに対する値を保持します。その後、`c`オブジェクトに対して持っている値と同じ参照で`d`に代入します。
 
 <img src="https://i.imgur.com/ko5k0fs.png" width="200">
 
-1つのオブジェクトを変更すると、それらすべてが変更されます。
+1 つのオブジェクトを変更すると、それらすべてが変更されます。
 
 </p>
 </details>
@@ -260,7 +261,7 @@ console.log(b === c);
 
 `==`演算子を使うとき、同じ値を持っているかどうか？ をチェックするだけとなります。それらは両方とも`3`の値を持っているので、それは`true`を返します。
 
-しかし、`===`演算子を使う時は、値と型は同じであるべきです。 そうでないので: `new Number()`は数値ではなく、**オブジェクト**となります。なので、両方ともfalseを返します。
+しかし、`===`演算子を使う時は、値と型は同じであるべきです。 そうでないので: `new Number()`は数値ではなく、**オブジェクト**となります。なので、両方とも false を返します。
 
 </p>
 </details>
@@ -321,7 +322,7 @@ console.log(greetign);
 
 #### 答え: A
 
-グローバルオブジェクトに、空のオブジェクトを作成したばかりなので、オブジェクトはログ出力されます。`greeting`を`greetign`と誤って入力した場合、JSインタプリタは実際にこれを `global.greetign = {}`（またはブラウザの `window.greetign = {}`）と見なします。
+グローバルオブジェクトに、空のオブジェクトを作成したばかりなので、オブジェクトはログ出力されます。`greeting`を`greetign`と誤って入力した場合、JS インタプリタは実際にこれを `global.greetign = {}`（またはブラウザの `window.greetign = {}`）と見なします。
 
 これを避けるために、"use strict"を使用する事ができます。これにより、変数を何かに設定する前に、変数宣言したことを確認できます。
 
@@ -350,7 +351,7 @@ bark.animal = "dog";
 
 #### 答え: A
 
-関数はオブジェクトとなるので、これはJavaScriptで可能です。（プリミティブ型以外はすべてオブジェクトです。）
+関数はオブジェクトとなるので、これは JavaScript で可能です。（プリミティブ型以外はすべてオブジェクトです。）
 
 関数は特別な種類のオブジェクトです。自分で書いたコードは実際の機能ではありません。関数はプロパティを持つオブジェクトです。よって、このプロパティは呼び出し可能となります。
 
@@ -368,7 +369,7 @@ function Person(firstName, lastName) {
 }
 
 const member = new Person("Lydia", "Hallie");
-Person.getFullName = function() {
+Person.getFullName = function () {
   return `${this.firstName} ${this.lastName}`;
 };
 
@@ -388,7 +389,7 @@ console.log(member.getFullName());
 通常のオブジェクトのようにコンストラクタにプロパティを追加することはできません。一度にすべてのオブジェクトに機能を追加したい場合は、代わりにプロトタイプを使用する必要があります。だからこの場合は、
 
 ```js
-Person.prototype.getFullName = function() {
+Person.prototype.getFullName = function () {
   return `${this.firstName} ${this.lastName}`;
 };
 ```
@@ -397,7 +398,7 @@ Person.prototype.getFullName = function() {
 
 その場合、多くのメモリスペースを浪費する事でしょう。なぜならそれらはまだその特性を持ち、それは各インスタンスのためにメモリスペースを消費するからです。
 
-その代わりに、プロトタイプに追加するだけであれば、メモリ内の1箇所に配置するだけで、すべてのユーザーがアクセスできます。
+その代わりに、プロトタイプに追加するだけであれば、メモリ内の 1 箇所に配置するだけで、すべてのユーザーがアクセスできます。
 
 </p>
 </details>
@@ -440,7 +441,7 @@ console.log(sarah);
 
 ---
 
-###### 13. イベント伝播の3つの段階はどれですか？
+###### 13. イベント伝播の 3 つの段階はどれですか？
 
 - A: Target > Capturing > Bubbling
 - B: Bubbling > Target > Capturing
@@ -473,9 +474,9 @@ console.log(sarah);
 
 **基本オブジェクト**を除き、すべてのオブジェクトにプロトタイプがあります。ベースオブジェクトは`.toString`のようないくつかのメソッドとプロパティにアクセスできます。
 
-これが、組み込みのJavaScriptメソッドを使用できる理由です。このような方法はすべてプロトタイプで利用できます。 
+これが、組み込みの JavaScript メソッドを使用できる理由です。このような方法はすべてプロトタイプで利用できます。
 
-JavaScriptはそれをあなたのオブジェクト上で直接見つけることはできませんが、プロトタイプチェーンをたどり、見つけます。
+JavaScript はそれをあなたのオブジェクト上で直接見つけることはできませんが、プロトタイプチェーンをたどり、見つけます。
 
 </p>
 </details>
@@ -502,9 +503,9 @@ sum(1, "2");
 
 #### 答え: C
 
-JavaScriptは、**動的に型付けされた言語**です。: 特定の変数がどんな型であるかは指定しません。知らないうちに、値が自動的に別の型に変換されることがあります。この事を`implicit type coercion`と呼ばれてます。 **Coercion**は、ある型から別の型に変換しています。
+JavaScript は、**動的に型付けされた言語**です。: 特定の変数がどんな型であるかは指定しません。知らないうちに、値が自動的に別の型に変換されることがあります。この事を`implicit type coercion`と呼ばれてます。 **Coercion**は、ある型から別の型に変換しています。
 
-この例では、関数が意味を成して値を返すために、JavaScriptは数字の`1`を文字列に変換します。数値型（`1`）と 文字列型（`'2'`）の追加中は、数字は文字列として扱われます。 
+この例では、関数が意味を成して値を返すために、JavaScript は数字の`1`を文字列に変換します。数値型（`1`）と 文字列型（`'2'`）の追加中は、数字は文字列として扱われます。
 
 `"Hello"+"World"`のように文字列を連結することができるので、ここで起こっているのは`"1"+"2"`で、これは `"12"`を返します。
 
@@ -534,13 +535,11 @@ console.log(number);
 
 **接尾辞** 単項演算子 `++`：
 
-1.値を返す（これは`0`を返す）
-2.値を増やす（numberは現在`1`です）
+1.値を返す（これは`0`を返す） 2.値を増やす（number は現在`1`です）
 
 **接頭辞** 単項演算子 `++`：
 
-1.値を増やす（数値は2になります）
-2.値を返す（これは`2`を返します）
+1.値を増やす（数値は 2 になります） 2.値を返す（これは`2`を返します）
 
 これは`0 2 2`を返します。
 
@@ -605,9 +604,9 @@ checkAge({ age: 18 });
 
 #### 答え: C
 
-等価性をテストするとき、プリミティブはそれらの値によって比較され、オブジェクトはそれらの参照によって比較されます。 JavaScriptは、オブジェクトがメモリ内の同じ場所への参照を持っているかどうかを確認します。
+等価性をテストするとき、プリミティブはそれらの値によって比較され、オブジェクトはそれらの参照によって比較されます。 JavaScript は、オブジェクトがメモリ内の同じ場所への参照を持っているかどうかを確認します。
 
-比較している2つのオブジェクトにはそれがありません。パラメータとして渡したオブジェクトが、等価性を確認するために使用したオブジェクトとは異なるメモリ内の場所を参照しています。
+比較している 2 つのオブジェクトにはそれがありません。パラメータとして渡したオブジェクトが、等価性を確認するために使用したオブジェクトとは異なるメモリ内の場所を参照しています。
 
 これが `{ age: 18 } === { age: 18 }`と、`{ age: 18 } == { age: 18 }`の両方が、`false`を返す理由です。
 
@@ -665,7 +664,7 @@ getAge();
 
 #### 答え: C
 
-`"use strict"`を使うと、誤ってグローバル変数を宣言しないようにすることができます。変数`age`を宣言したことは一度もありませんし、`"use strict"`を使っているので参照エラーになります。 
+`"use strict"`を使うと、誤ってグローバル変数を宣言しないようにすることができます。変数`age`を宣言したことは一度もありませんし、`"use strict"`を使っているので参照エラーになります。
 
 `"use strict"`を使用しなかった場合は、プロパティ`age`がグローバルオブジェクトに追加されたことになるので、それは機能します。
 
@@ -674,7 +673,7 @@ getAge();
 
 ---
 
-###### 21. sumの値は何？
+###### 21. sum の値は何？
 
 ```javascript
 const sum = eval("10*10+5");
@@ -697,7 +696,7 @@ const sum = eval("10*10+5");
 
 ---
 
-###### 22. cool_secretは、どのくらいの期間アクセス可能ですか？
+###### 22. cool_secret は、どのくらいの期間アクセス可能ですか？
 
 ```javascript
 sessionStorage.setItem("cool_secret", 123);
@@ -772,9 +771,9 @@ set.has(1);
 
 #### 答え: C
 
-すべてのオブジェクトキー（Symbolsを除く）は、文字列として自分で入力しなくても、内部では文字列です。これが、`obj.hasOwnProperty('1')`も​​trueを返す理由です。
+すべてのオブジェクトキー（Symbols を除く）は、文字列として自分で入力しなくても、内部では文字列です。これが、`obj.hasOwnProperty('1')`も ​​true を返す理由です。
 
-setではそうはいきません。上記のsetには`'1'` はありません: `set.has('1')`は、`false`を返します。数値型`1`の`set.has(1)`は、`true`を返します。
+set ではそうはいきません。上記の set には`'1'` はありません: `set.has('1')`は、`false`を返します。数値型`1`の`set.has(1)`は、`true`を返します。
 
 </p>
 </details>
@@ -798,14 +797,14 @@ console.log(obj);
 
 #### 答え: C
 
-同じ名前のキーが2つある場合、最初の位置にあるキーは置き換えられ、最後に指定された値になります。
+同じ名前のキーが 2 つある場合、最初の位置にあるキーは置き換えられ、最後に指定された値になります。
 
 </p>
 </details>
 
 ---
 
-###### 26. JavaScriptのglobal execution contextは、2つを作成します。: それはグローバルオブジェクトと "this"キーワードです。
+###### 26. JavaScript の global execution context は、2 つを作成します。: それはグローバルオブジェクトと "this"キーワードです。
 
 - A: true
 - B: false
@@ -816,7 +815,7 @@ console.log(obj);
 
 #### 答え: A
 
-基本的なexecution contextは、グローバルな実行コンテキストです。それはあなたのコードの至る所でアクセス可能なものです。
+基本的な execution context は、グローバルな実行コンテキストです。それはあなたのコードの至る所でアクセス可能なものです。
 
 </p>
 </details>
@@ -858,7 +857,7 @@ String.prototype.giveLydiaPizza = () => {
 
 const name = "Lydia";
 
-console.log(name.giveLydiaPizza())
+console.log(name.giveLydiaPizza());
 ```
 
 - A: `"Just give Lydia pizza already!"`
@@ -905,9 +904,9 @@ console.log(a[b]);
 
 #### 答え: B
 
-オブジェクトキーは自動的に文字列に変換されます。オブジェクトaのキーとして、値123で設定しようとしています。
+オブジェクトキーは自動的に文字列に変換されます。オブジェクト a のキーとして、値 123 で設定しようとしています。
 
-しかし、オブジェクトを文字列化すると、それは`"[object Object]"`​​になってしまいます。なので、ここで行っているのは、 `a["object Object"] = 123`です。
+しかし、オブジェクトを文字列化すると、それは`"[object Object]"`​​ になってしまいます。なので、ここで行っているのは、 `a["object Object"] = 123`です。
 
 その後、同じことをもう一度試みています。`c`は暗黙のうちに文字列化している別のオブジェクトです。そのため、`a["object Object"] = 456`となります。
 
@@ -942,9 +941,9 @@ baz();
 
 `setTimeout`関数があり、それを最初に呼び出したのですが、それは最後にログ出力されました。
 
-これは、ブラウザにはランタイムエンジンがあるだけでなく、`WebAPI`と呼ばれるものもあるからです。`WebAPI`は最初に`setTimeout`関数を与えてくれます。例えばDOMです。
+これは、ブラウザにはランタイムエンジンがあるだけでなく、`WebAPI`と呼ばれるものもあるからです。`WebAPI`は最初に`setTimeout`関数を与えてくれます。例えば DOM です。
 
-callbackがWebAPIにプッシュされた後、`setTimeout`関数自体（コールバックではありません!）がスタックからポップされます。
+callback が WebAPI にプッシュされた後、`setTimeout`関数自体（コールバックではありません!）がスタックからポップされます。
 
 <img src="https://i.imgur.com/X5wsHOg.png" width="200">
 
@@ -956,11 +955,11 @@ callbackがWebAPIにプッシュされた後、`setTimeout`関数自体（コー
 
 <img src="https://i.imgur.com/WhA2bCP.png" width="200">
 
-WebAPIは、準備が整ったときにスタックに、なにかを追加することはできません。代わりに、コールバック関数を`queue`と呼ばれるものにプッシュします。
+WebAPI は、準備が整ったときにスタックに、なにかを追加することはできません。代わりに、コールバック関数を`queue`と呼ばれるものにプッシュします。
 
 <img src="https://i.imgur.com/NSnDZmU.png" width="200">
 
-event loopが機能し始めるところです。 **event loop**はスタックとタスクキューを調べます。スタックが空の場合は、キューの最初のものを取り出し、それをスタックにプッシュします。
+event loop が機能し始めるところです。 **event loop**はスタックとタスクキューを調べます。スタックが空の場合は、キューの最初のものを取り出し、それをスタックにプッシュします。
 
 <img src="https://i.imgur.com/uyiScAI.png" width="200">
 
@@ -971,14 +970,12 @@ event loopが機能し始めるところです。 **event loop**はスタック
 
 ---
 
-###### 31.ボタンをクリックしたときのevent.targetは何ですか？
+###### 31.ボタンをクリックしたときの event.target は何ですか？
 
 ```html
 <div onclick="console.log('first div')">
   <div onclick="console.log('second div')">
-    <button onclick="console.log('button')">
-      Click!
-    </button>
+    <button onclick="console.log('button')">Click!</button>
   </div>
 </div>
 ```
@@ -1000,14 +997,11 @@ event loopが機能し始めるところです。 **event loop**はスタック
 
 ---
 
-
-###### 32. p要素をクリックすると、ログ出力はどうなりますか。
+###### 32. p 要素をクリックすると、ログ出力はどうなりますか。
 
 ```html
 <div onclick="console.log('div')">
-  <p onclick="console.log('p')">
-    Click here!
-  </p>
+  <p onclick="console.log('p')">Click here!</p>
 </div>
 ```
 
@@ -1021,7 +1015,7 @@ event loopが機能し始めるところです。 **event loop**はスタック
 
 #### 答え: A
 
-`p`をクリックすると、`p`と`div`の2つのログが表示されます。イベント伝播中は、キャプチャ、ターゲット、バブリングの3つのフェーズがあります。
+`p`をクリックすると、`p`と`div`の 2 つのログが表示されます。イベント伝播中は、キャプチャ、ターゲット、バブリングの 3 つのフェーズがあります。
 
 デフォルトでは、イベントハンドラはバブリング段階で実行されます（`useCapture`を`true`に設定しない限り）。最も深くネストした要素から外側に向かって進みます。
 
@@ -1084,14 +1078,14 @@ typeof sayHi();
 
 `sayHi`関数は、即時呼び出し関数式（IIFE）の戻り値を返します。この関数は`0`を返しました。それは`"number"`型です。
 
-参考：7つの組み込み型しかありません： `null`, `undefined`, `boolean`, `number`, `string`, `object`, `symbol`, そして `bigint`。関数はオブジェクトなので、`"function"`型ではなく`"object"`型です。
+参考：7 つの組み込み型しかありません： `null`, `undefined`, `boolean`, `number`, `string`, `object`, `symbol`, そして `bigint`。関数はオブジェクトなので、`"function"`型ではなく`"object"`型です。
 
 </p>
 </details>
 
 ---
 
-###### 35. これらの値のどれがfalsyですか？
+###### 35. これらの値のどれが falsy ですか？
 
 ```javascript
 0;
@@ -1105,14 +1099,14 @@ undefined;
 - A: `0`, `''`, `undefined`
 - B: `0`, `new Number(0)`, `''`, `new Boolean(false)`, `undefined`
 - C: `0`, `''`, `new Boolean(false)`, `undefined`
-- D: これらすべてfalsy
+- D: これらすべて falsy
 
 <details><summary><b>答え</b></summary>
 <p>
 
 #### 答え: A
 
-falsyの値は6つだけです。
+falsy の値は 6 つだけです。
 
 - `undefined`
 - `null`
@@ -1121,7 +1115,7 @@ falsyの値は6つだけです。
 - `''` (empty string)
 - `false`
 
-`new Number`や、`new Boolean`のような関数コンストラクタはtruthyです。
+`new Number`や、`new Boolean`のような関数コンストラクタは truthy です。
 
 </p>
 </details>
@@ -1171,11 +1165,11 @@ console.log(numbers);
 
 #### 答え: C
 
-配列の長さを超える値を配列内の要素に設定すると、JavaScriptでは、"empty slots"と呼ばれるものを作成します。これらは実際には、`undefined`の値を持ちますが、あなたは以下のようなものを見るでしょう
+配列の長さを超える値を配列内の要素に設定すると、JavaScript では、"empty slots"と呼ばれるものを作成します。これらは実際には、`undefined`の値を持ちますが、あなたは以下のようなものを見るでしょう
 
 `[1, 2, 3, 7 x empty, 11]`
 
-実行場所によって異なります（browser、nodeなどによって異なります）。
+実行場所によって異なります（browser、node などによって異なります）。
 
 </p>
 </details>
@@ -1212,18 +1206,18 @@ console.log(numbers);
 
 後に、このブロックスコープ変数を`1`に設定し、変数`y`の値を設定します。ここで、ブロックスコープ変数`x`をログ出力します。これは`1`となります。
 
-`catch`ブロック以外では、`x`は未定義、`y`は2です。 `catch`ブロックの外側で`console.log(x)`した場合は、`undefined`を返し、`y`は`2`を返します。
+`catch`ブロック以外では、`x`は未定義、`y`は 2 です。 `catch`ブロックの外側で`console.log(x)`した場合は、`undefined`を返し、`y`は`2`を返します。
 
 </p>
 </details>
 
 ---
 
-###### 39. JavaScriptのすべてはどちらかです...
+###### 39. JavaScript のすべてはどちらかです...
 
 - A: primitive か object
 - B: function か object
-- C: ひっかけ問題! objectsのみ
+- C: ひっかけ問題! objects のみ
 - D: number か object
 
 <details><summary><b>答え</b></summary>
@@ -1231,13 +1225,13 @@ console.log(numbers);
 
 #### 答え: A
 
-JavaScriptにはプリミティブ型とオブジェクトしかありません。
+JavaScript にはプリミティブ型とオブジェクトしかありません。
 
 プリミティブ型は、`boolean`, `null`, `undefined`, `bigint`, `number`, `string`, そして`symbol`です。
 
 プリミティブとオブジェクトを区別するのは、プリミティブにはプロパティもメソッドもないということです。
 
-ただし、`'foo'.toUpperCase()`は`'FOO'`と評価され、`TypeError`にはなりません。これは、文字列のようなプリミティブのプロパティやメソッドにアクセスしようとすると、JavaScriptがラッパークラスの1つ、すなわち`String`を使ってオブジェクトを暗黙的にラップし、式が評価された後ラッパーを直ちに破棄するためです。 
+ただし、`'foo'.toUpperCase()`は`'FOO'`と評価され、`TypeError`にはなりません。これは、文字列のようなプリミティブのプロパティやメソッドにアクセスしようとすると、JavaScript がラッパークラスの 1 つ、すなわち`String`を使ってオブジェクトを暗黙的にラップし、式が評価された後ラッパーを直ちに破棄するためです。
 
 `null`と`undefined`を除くすべてのプリミティブはこの振る舞いをします。
 
@@ -1249,7 +1243,10 @@ JavaScriptにはプリミティブ型とオブジェクトしかありません
 ###### 40. 何が出力されるでしょうか？
 
 ```javascript
-[[0, 1], [2, 3]].reduce(
+[
+  [0, 1],
+  [2, 3],
+].reduce(
   (acc, cur) => {
     return acc.concat(cur);
   },
@@ -1294,25 +1291,24 @@ JavaScriptにはプリミティブ型とオブジェクトしかありません
 
 #### 答え: B
 
-`null`はfalsyです。`!null`は`true`を返します。`!true`は`false`を返します。
+`null`は falsy です。`!null`は`true`を返します。`!true`は`false`を返します。
 
-`""`はfalsyです。`!""`は`true`を返します。`!true`は`false`を返します。
+`""`は falsy です。`!""`は`true`を返します。`!true`は`false`を返します。
 
-`1`はtruthyです。`!1`は`false`を返します。`!false`は`true`を返します。
+`1`は truthy です。`!1`は`false`を返します。`!false`は`true`を返します。
 
 </p>
 </details>
 
 ---
 
-
 ###### 42. `setInterval`メソッドはブラウザに何を返しますか？
 
 ```javascript
 setInterval(() => console.log("Hi"), 1000);
 ```
 
-- A: ユニークid
+- A: ユニーク id
 - B: 指定されたミリ秒数
 - C: 渡された関数
 - D: `undefined`
@@ -1322,7 +1318,7 @@ setInterval(() => console.log("Hi"), 1000);
 
 #### 答え: A
 
-一意のIDを返します。このIDは `clearInterval()`関数で、その間隔をクリアするために使うことができます。
+一意の ID を返します。この ID は `clearInterval()`関数で、その間隔をクリアするために使うことができます。
 
 </p>
 </details>
@@ -1345,7 +1341,7 @@ setInterval(() => console.log("Hi"), 1000);
 
 #### 答え: A
 
-文字列はイテラブルです。スプレッド演算子は、イテラブルのすべての文字を1つの要素にマッピングします。
+文字列はイテラブルです。スプレッド演算子は、イテラブルのすべての文字を 1 つの要素にマッピングします。
 
 </p>
 </details>
@@ -1402,7 +1398,7 @@ const secondPromise = new Promise((res, rej) => {
   setTimeout(res, 100, "two");
 });
 
-Promise.race([firstPromise, secondPromise]).then(res => console.log(res));
+Promise.race([firstPromise, secondPromise]).then((res) => console.log(res));
 ```
 
 - A: `"one"`
@@ -1417,7 +1413,7 @@ Promise.race([firstPromise, secondPromise]).then(res => console.log(res));
 
 複数のプロミスを`Promise.race`メソッドに渡した時、"resolves/rejects"は、"最初"のプロミスの"resolves/rejects"を行います。
 
-`setTimeout`メソッドには、タイマーを渡します: 最初のプロミスには500ms(`firstPromise`)、2番目のプロミスには100ms(`secondPromise`)。
+`setTimeout`メソッドには、タイマーを渡します: 最初のプロミスには 500ms(`firstPromise`)、2 番目のプロミスには 100ms(`secondPromise`)。
 
 これは、`secondPromise`が最初に`'two'`の値で解決されることを意味します。`res`は`'two'`の値を保持するようになり、ログ出力されます。
 
@@ -1461,7 +1457,7 @@ console.log(members);
 <img src="https://i.imgur.com/sYjcsMT.png" width="300">
 
 その要素はオブジェクトへの異なる（コピーされた）参照を持っているので、`person`変数の値を変更するだけで配列の最初の要素は変更されません。 `members`の最初の要素はまだ元のオブジェクトへの参照を保持しています。
- 
+
 `members`配列をログ出力したとき、最初の要素はまだオブジェクトの値を保持しているので、それがログ出力されます。
 
 </p>
@@ -1474,7 +1470,7 @@ console.log(members);
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21
+  age: 21,
 };
 
 for (const item in person) {
@@ -1517,18 +1513,18 @@ console.log(3 + 4 + "5");
 
 #### 答え: B
 
-演算子結合性は、コンパイラーが式を評価する順序（左から右または右から左）となります。これは、すべての演算子が同じ優先順位を持つ場合にのみ発生します。演算子の種類は1つだけです: `+`。さらに、結合性は左から右です。
+演算子結合性は、コンパイラーが式を評価する順序（左から右または右から左）となります。これは、すべての演算子が同じ優先順位を持つ場合にのみ発生します。演算子の種類は 1 つだけです: `+`。さらに、結合性は左から右です。
 
 `3 + 4`が最初に評価されます。これは数字の`7`になります。
 
-`7 + '5'`は、強制的に`"75"`になります。 JavaScriptでは、数字の`7`を文字列に変換します。質問15を参照してください。2つの文字列を演算子の`+`を使って連結することができます。よって、`"7" + "5"`は、`"75"`になります。
+`7 + '5'`は、強制的に`"75"`になります。 JavaScript では、数字の`7`を文字列に変換します。質問 15 を参照してください。2 つの文字列を演算子の`+`を使って連結することができます。よって、`"7" + "5"`は、`"75"`になります。
 
 </p>
 </details>
 
 ---
 
-###### 49. numの値は何ですか？
+###### 49. num の値は何ですか？
 
 ```javascript
 const num = parseInt("7*6", 10);
@@ -1544,9 +1540,9 @@ const num = parseInt("7*6", 10);
 
 #### 答え: C
 
-文字列の最初の数字だけが返されます。"基数"（解析する数値の種類を指定するための2番目の引数: 基数10, 16進数, 8進数, 2進数など）に基づいて、`parseInt`は文字列内の文字が有効かどうかをチェックします。基数の中で有効な数字ではない文字に出会うと、構文解析を停止して次の文字を無視します。
+文字列の最初の数字だけが返されます。"基数"（解析する数値の種類を指定するための 2 番目の引数: 基数 10, 16 進数, 8 進数, 2 進数など）に基づいて、`parseInt`は文字列内の文字が有効かどうかをチェックします。基数の中で有効な数字ではない文字に出会うと、構文解析を停止して次の文字を無視します。
 
-`*`は、有効な数字ではありません。`"7"`を、10進数の`7`に解析するだけです。そのままnumは`7`の値を保持します。
+`*`は、有効な数字ではありません。`"7"`を、10 進数の`7`に解析するだけです。そのまま num は`7`の値を保持します。
 
 </p>
 </details>
@@ -1556,7 +1552,7 @@ const num = parseInt("7*6", 10);
 ###### 50. 何が出力されるでしょうか？
 
 ```javascript
-[1, 2, 3].map(num => {
+[1, 2, 3].map((num) => {
   if (typeof num === "number") return;
   return num * 2;
 });
@@ -1572,7 +1568,7 @@ const num = parseInt("7*6", 10);
 
 #### 答え: C
 
-配列をマッピングするとき、`num`の値に代入されるのは、ループで渡ってくる要素となります。この場合、要素は数値なので、ifステートメント `typeof num === "number"`の条件は`true`を返します。 map関数は新しい配列を作成して関数から返された値を挿入します。
+配列をマッピングするとき、`num`の値に代入されるのは、ループで渡ってくる要素となります。この場合、要素は数値なので、if ステートメント `typeof num === "number"`の条件は`true`を返します。 map 関数は新しい配列を作成して関数から返された値を挿入します。
 
 ただし、値は返されません。関数から値を返さないと、関数は`undefined`を返します。配列内のすべての要素に対して関数ブロックが呼び出されるので、各要素に対して`undefined`を返します。
 
@@ -1607,7 +1603,7 @@ console.log(person, birthYear);
 
 #### 答え: A
 
-値がオブジェクトでない限り、引数は"値"によって渡され、その後、"参照"によって渡されます。 `birthYear`はオブジェクトではなく文字列なので、値で渡されます。引数を値で渡すと、その値の"コピー"が作成されます（質問46を参照）。
+値がオブジェクトでない限り、引数は"値"によって渡され、その後、"参照"によって渡されます。 `birthYear`はオブジェクトではなく文字列なので、値で渡されます。引数を値で渡すと、その値の"コピー"が作成されます（質問 46 を参照）。
 
 変数`birthYear`は、値`"1997"`への参照を持ちます。引数`year`は、値`"1997"`も参照していますが、それは`birthYear`が参照しているのと同じ値ではありません。`year`に`"1998"`を代入することによって`year`の値を更新したとしても、`year`の値を更新するだけです。`birthYear`はまだ`"1997"`となります。
 
@@ -1715,15 +1711,15 @@ y = 10;
 let x = y;
 ```
 
-`y`に`10`を代入すると、実際にはグローバルオブジェクトにプロパティ`y`が追加されます（ブラウザでは`window`、nodeでは`global`）。ブラウザでは、`window.y`は`10`となりました。
+`y`に`10`を代入すると、実際にはグローバルオブジェクトにプロパティ`y`が追加されます（ブラウザでは`window`、node では`global`）。ブラウザでは、`window.y`は`10`となりました。
 
-それから、変数`x`を`10`である値`y`で宣言します。`let`キーワードで宣言された変数は"ブロックスコープ"となり、宣言されたブロック内でのみ定義されます。この場合は即時関数（IIFE）となります。 
+それから、変数`x`を`10`である値`y`で宣言します。`let`キーワードで宣言された変数は"ブロックスコープ"となり、宣言されたブロック内でのみ定義されます。この場合は即時関数（IIFE）となります。
 
 `typeof`演算子使用時、オペランド`x`は定義されていません: 宣言されているブロックの外側で`x`にアクセスしようとしています。これは`x`が定義されていないことを意味します。
 
 値が割り当てられていない、または宣言されていない値は`"undefined"`型となります。なので`console.log(typeof x)`は`"undefined"`を返します。
 
-yに関しては、`y`に`10`を代入するときにグローバル変数`y`を作成しました。この値は、コード内のどこからでもアクセスできます。`y`が定義されていて、`"number"`型の値を保持します。よって`console.log(typeof y)`は`"number"`を返します。
+y に関しては、`y`に`10`を代入するときにグローバル変数`y`を作成しました。この値は、コード内のどこからでもアクセスできます。`y`が定義されていて、`"number"`型の値を保持します。よって`console.log(typeof y)`は`"number"`を返します。
 
 </p>
 </details>
@@ -1737,7 +1733,7 @@ class Dog {
   }
 }
 
-Dog.prototype.bark = function() {
+Dog.prototype.bark = function () {
   console.log(`Woof I am ${this.name}`);
 };
 
@@ -1789,10 +1785,9 @@ console.log(set);
 
 #### 答え: D
 
-
 `Set`オブジェクトは _unique_ の値の集合です: 値は集合の中で一度だけ現れることができます
 
-値`1`が重複したイテラブル`[1、1、2、3、4]`を渡しました。セット内に同じ値を2つ持つことはできないので、そのうちの1つが削除され`{1、2、3、4}`となります。
+値`1`が重複したイテラブル`[1、1、2、3、4]`を渡しました。セット内に同じ値を 2 つ持つことはできないので、そのうちの 1 つが削除され`{1、2、3、4}`となります。
 
 </p>
 </details>
@@ -1855,9 +1850,9 @@ console.log(delete age);
 
 #### 答え: A
 
-`delete`演算子は、ブール値を返します: 正常に削除された場合はtrue、それ以外の場合はfalseを返します。`var`, `const`または`let`キーワードで宣言された変数は`delete`演算子を使って削除することはできません。
+`delete`演算子は、ブール値を返します: 正常に削除された場合は true、それ以外の場合は false を返します。`var`, `const`または`let`キーワードで宣言された変数は`delete`演算子を使って削除することはできません。
 
-`name`変数は`const`キーワードで宣言されているので、削除は成功しません: `false`が返されます。 
+`name`変数は`const`キーワードで宣言されているので、削除は成功しません: `false`が返されます。
 
 `age`を`21`に設定すると、実際にはグローバルオブジェクトに`age`というプロパティを追加されました。グローバルオブジェクトからもプロパティを削除することができますので、`delete age`は`true`を返します。
 
@@ -1957,7 +1952,7 @@ console.log(Object.keys(person));
 
 #### 答え: B
 
-`defineProperty`メソッドを使うと、オブジェクトに新しいプロパティを追加したり、既存のプロパティを修正することができます。 `defineProperty`メソッドを使ってオブジェクトにプロパティを追加すると、それらはデフォルトでは _列挙できません_。 
+`defineProperty`メソッドを使うと、オブジェクトに新しいプロパティを追加したり、既存のプロパティを修正することができます。 `defineProperty`メソッドを使ってオブジェクトにプロパティを追加すると、それらはデフォルトでは _列挙できません_。
 
 `Object.keys`メソッドはオブジェクトから全ての _enumerable_ （列挙可能）なプロパティ名を返します。上記の場合は`"name"`だけとなります。
 
@@ -1974,7 +1969,7 @@ console.log(Object.keys(person));
 const settings = {
   username: "lydiahallie",
   level: 19,
-  health: 90
+  health: 90,
 };
 
 const data = JSON.stringify(settings, ["level", "health"]);
@@ -1991,11 +1986,11 @@ console.log(data);
 
 #### 答え: A
 
-`JSON.stringify`の2番目の引数は _replacer_ です。replacerは、関数または配列のいずれかにすることができ、値を文字列化する対象とその方法を制御できます。
+`JSON.stringify`の 2 番目の引数は _replacer_ です。replacer は、関数または配列のいずれかにすることができ、値を文字列化する対象とその方法を制御できます。
 
-replacerが _array_ の場合、名前が配列に含まれるプロパティのみがJSON文字列に追加されます。上記の場合、`"level"`と`"health"`という名前のプロパティだけが含まれ、`"username"`は除外されます。`data`は`"{" level "：19、" health "：90}"`となります。
+replacer が _array_ の場合、名前が配列に含まれるプロパティのみが JSON 文字列に追加されます。上記の場合、`"level"`と`"health"`という名前のプロパティだけが含まれ、`"username"`は除外されます。`data`は`"{" level "：19、" health "：90}"`となります。
 
-replacerが _function_ の場合、この関数は文字列化しているオブジェクト内のすべてのプロパティに対して呼び出されます。この関数から返される値は、JSON文字列に追加されたときのプロパティの値になり、値が`undefined`の場合、このプロパティはJSON文字列から除外されます。
+replacer が _function_ の場合、この関数は文字列化しているオブジェクト内のすべてのプロパティに対して呼び出されます。この関数から返される値は、JSON 文字列に追加されたときのプロパティの値になり、値が`undefined`の場合、このプロパティは JSON 文字列から除外されます。
 
 </p>
 </details>
@@ -2008,7 +2003,7 @@ replacerが _function_ の場合、この関数は文字列化しているオブ
 let num = 10;
 
 const increaseNumber = () => num++;
-const increasePassedNumber = number => number++;
+const increasePassedNumber = (number) => number++;
 
 const num1 = increaseNumber();
 const num2 = increasePassedNumber(num1);
@@ -2061,18 +2056,17 @@ multiply(value);
 
 #### 答え: C
 
-
-ES6では、パラメータをデフォルト値で初期化できます。値が関数に渡されていない場合やパラメータの値が `"undefined"`の場合、パラメータの値はデフォルト値になります。上記の場合、`value`オブジェクトのプロパティを新しいオブジェクトに分割代入されるので、`x`のデフォルト値は`{number：10}`になります。
+ES6 では、パラメータをデフォルト値で初期化できます。値が関数に渡されていない場合やパラメータの値が `"undefined"`の場合、パラメータの値はデフォルト値になります。上記の場合、`value`オブジェクトのプロパティを新しいオブジェクトに分割代入されるので、`x`のデフォルト値は`{number：10}`になります。
 
 デフォルトの引数は、_呼び出し時_ に評価されます。関数を呼び出すたびに、_新しい_ オブジェクトが作成されます。
 
-最初に値を渡さずに2回、`multiply`関数を呼び出します: `x`のデフォルト値は `{number：10}`となり、その数の乗算された値、つまり `20`を出力します。
+最初に値を渡さずに 2 回、`multiply`関数を呼び出します: `x`のデフォルト値は `{number：10}`となり、その数の乗算された値、つまり `20`を出力します。
 
-3回目のmultiplyを呼び出すとき、引数を渡します: `value`というオブジェクトです。
+3 回目の multiply を呼び出すとき、引数を渡します: `value`というオブジェクトです。
 
 `*=`演算子は`x.number = x.number * 2`の省略形となります: `x.number`の値は乗算した値に修正され、`20`を出力します。
 
-4回目は、`value`オブジェクトをもう一度渡します。`x.number`は以前は`20`に修正されているので、`x.number *= 2`は`40`を出力します。
+4 回目は、`value`オブジェクトをもう一度渡します。`x.number`は以前は`20`に修正されているので、`x.number *= 2`は`40`を出力します。
 
 </p>
 </details>
@@ -2095,8 +2089,7 @@ ES6では、パラメータをデフォルト値で初期化できます。値
 
 #### 答え: D
 
-
-`reduce`メソッドが受け取る最初の引数は _アキュムレータ_ となります。この場合は`x`です。 2番目の引数は、_現在の値_ `y`です。 reduceメソッドでは、配列内のすべての要素に対してコールバック関数を実行します。これにより、最終的に1つの値が得られます。
+`reduce`メソッドが受け取る最初の引数は _アキュムレータ_ となります。この場合は`x`です。 2 番目の引数は、_現在の値_ `y`です。 reduce メソッドでは、配列内のすべての要素に対してコールバック関数を実行します。これにより、最終的に 1 つの値が得られます。
 
 上記の例では、値を返していません。単にアキュムレータの値と現在の値を記録しています。
 
@@ -2106,14 +2099,14 @@ ES6では、パラメータをデフォルト値で初期化できます。値
 
 関数から値を返さなければ、`undefined`を返します。次の呼び出しでは、アキュムレータは`undefined`で、現在の値は`3`です。`undefined`と`3`が出力されます。
 
-4回目の呼び出しでも、コールバック関数からは戻りません。アキュムレータもまた`undefined`であり、現在の値は`4`となり、`undefined`と`4`が出力されます。
+4 回目の呼び出しでも、コールバック関数からは戻りません。アキュムレータもまた`undefined`であり、現在の値は`4`となり、`undefined`と`4`が出力されます。
 
 </p>
 </details>
   
 ---
 
-###### 66. どのコンストラクタを使えば `Dog` classを継承できるでしょうか？
+###### 66. どのコンストラクタを使えば `Dog` class を継承できるでしょうか？
 
 ```javascript
 class Dog {
@@ -2123,7 +2116,7 @@ class Dog {
 };
 
 class Labrador extends Dog {
-  // 1 
+  // 1
   constructor(name, size) {
     this.size = size;
   }
@@ -2137,7 +2130,7 @@ class Labrador extends Dog {
     super(name);
     this.size = size;
   }
-  // 4 
+  // 4
   constructor(name, size) {
     this.name = name;
     this.size = size;
@@ -2156,13 +2149,14 @@ class Labrador extends Dog {
 
 #### 答え: B
 
-派生クラスでは、`super`を呼び出す前に、`this`キーワードにアクセスすることはできません。そうしようとすると、ReferenceErrorがスローされます: 1と4は参照エラーをスローします。
+派生クラスでは、`super`を呼び出す前に、`this`キーワードにアクセスすることはできません。そうしようとすると、ReferenceError がスローされます: 1 と 4 は参照エラーをスローします。
 
 `super`キーワードを使って、与えられた引数で、その親クラスのコンストラクタを呼び出します。親のコンストラクタは`name`引数を受け取るので、`name`を`super`に渡す必要があります。
 
-`Labrador`クラスは2つの引数、`Dog`を拡張するための`name`と、`Labrador`クラスの追加のプロパティとしての`size`を受け取ります。
+`Labrador`クラスは 2 つの引数、`Dog`を拡張するための`name`と、`Labrador`クラスの追加のプロパティとしての`size`を受け取ります。
+
+両方とも`Labrador`のコンストラクタ関数に渡す必要があります。これはコンストラクタ 2 を使って正しく実行されます。
 
-両方とも`Labrador`のコンストラクタ関数に渡す必要があります。これはコンストラクタ2を使って正しく実行されます。
 </p>
 </details>
 
@@ -2172,12 +2166,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;
 ```
 
@@ -2193,9 +2187,9 @@ export const sum = (a, b) => a + b;
 
 `import`キーワードを使うと、全てのインポートされたモジュールは _事前解析_ されます。これは、インポートされたモジュールが _最初_ に実行され、_その後_ モジュールをインポートしたファイル内のコードが実行されることを意味します。
 
-これはCommonJSの`require()`と`import`の違いです。`require()`を使うと、コードが実行されている間に依存関係をオンデマンドでロードすることができます。 
+これは CommonJS の`require()`と`import`の違いです。`require()`を使うと、コードが実行されている間に依存関係をオンデマンドでロードすることができます。
 
-`import`の代わりに`require`を使用したとしたら、`running index.js`, `running sum.js`, `3`が出力されているはずです。 
+`import`の代わりに`require`を使用したとしたら、`running index.js`, `running sum.js`, `3`が出力されているはずです。
 
 </p>
 </details>
@@ -2205,9 +2199,9 @@ export const sum = (a, b) => a + b;
 ###### 68. 何が出力されるでしょうか？
 
 ```javascript
-console.log(Number(2) === Number(2))
-console.log(Boolean(false) === Boolean(false))
-console.log(Symbol('foo') === Symbol('foo'))
+console.log(Number(2) === Number(2));
+console.log(Boolean(false) === Boolean(false));
+console.log(Symbol("foo") === Symbol("foo"));
 ```
 
 - A: `true`, `true`, `false`
@@ -2220,9 +2214,9 @@ console.log(Symbol('foo') === Symbol('foo'))
 
 #### 答え: A
 
-すべてのシンボルは完全にユニークです。シンボルに渡される引数の目的は、シンボルに説明を与えることです。Symbolの値は渡された引数に依存しません。
+すべてのシンボルは完全にユニークです。シンボルに渡される引数の目的は、シンボルに説明を与えることです。Symbol の値は渡された引数に依存しません。
 
-等価性をテストしているので、2つのまったく新しいシンボルを作成します: 最初の`Symbol('foo')`と、2番目の`Symbol('foo')`です。これら2つの値は一意であり、互いに等しくはありません、なので`Symbol('foo') === Symbol('foo')`は`false`を返します。
+等価性をテストしているので、2 つのまったく新しいシンボルを作成します: 最初の`Symbol('foo')`と、2 番目の`Symbol('foo')`です。これら 2 つの値は一意であり、互いに等しくはありません、なので`Symbol('foo') === Symbol('foo')`は`false`を返します。
 
 </p>
 </details>
@@ -2232,22 +2226,22 @@ console.log(Symbol('foo') === Symbol('foo'))
 ###### 69. 何が出力されるでしょうか？
 
 ```javascript
-const name = "Lydia Hallie"
-console.log(name.padStart(13))
-console.log(name.padStart(2))
+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"`, 
+- D: `"Lydia Hallie"`, `"Lyd"`,
 
 <details><summary><b>答え</b></summary>
 <p>
 
 #### 答え: C
 
-`padStart`メソッドを使うと、文字列の先頭にパディングを追加できます。このメソッドに渡される値は、パディングとともに文字列の長さの _合計_ です。文字列`"Lydia Hallie"`の長さは`12`です。 `name.padStart(13)`は、12 + 1が13であるため、文字列の先頭に1スペースを挿入されます。
+`padStart`メソッドを使うと、文字列の先頭にパディングを追加できます。このメソッドに渡される値は、パディングとともに文字列の長さの _合計_ です。文字列`"Lydia Hallie"`の長さは`12`です。 `name.padStart(13)`は、12 + 1 が 13 であるため、文字列の先頭に 1 スペースを挿入されます。
 
 `padStart`メソッドに渡された引数が、配列の長さよりも小さい場合、パディングは追加されません。
 
@@ -2272,7 +2266,6 @@ console.log("🥑" + "💻");
 
 #### 答え: A
 
-
 `+`演算子を使うと、文字列を連結することができます。この場合、文字列`"🥑"`を文字列`"💻"`と連結して、結果として`"🥑💻"`となります。
 
 </p>
@@ -2280,7 +2273,7 @@ console.log("🥑" + "💻");
 
 ---
 
-###### 71. console.logステートメントの後にコメントアウトされている値を、ログ出力する方法を教えてください。
+###### 71. console.log ステートメントの後にコメントアウトされている値を、ログ出力する方法を教えてください。
 
 ```javascript
 function* startGame() {
@@ -2308,11 +2301,11 @@ console.log(/* 2 */); // JavaScript loves you back ❤️
 
 ジェネレータ関数は、`yield`キーワードを見るとその実行を「一時停止」します。まず、関数に文字列 "Do you love JavaScript?" を返させる必要があります。これは `game.next().value`を呼び出すことによって行うことができます。
 
-最初の`yield`キーワードが見つかるまで、すべての行が実行されます。関数内の最初の行に`yield`キーワードがあります: 実行は最初のyieldで停止します！ _これは変数 `answer`がまだ定義されていないことを意味します！_
+最初の`yield`キーワードが見つかるまで、すべての行が実行されます。関数内の最初の行に`yield`キーワードがあります: 実行は最初の yield で停止します！ _これは変数 `answer`がまだ定義されていないことを意味します！_
 
-`game.next("Yes").value`を呼び出すと、前の`yield`は`next()`関数に渡されたパラメータの値、この場合は`"Yes"`に置き換えられます。変数`answer`の値は現在`"Yes"`となります。 
+`game.next("Yes").value`を呼び出すと、前の`yield`は`next()`関数に渡されたパラメータの値、この場合は`"Yes"`に置き換えられます。変数`answer`の値は現在`"Yes"`となります。
 
-if-statemnetの条件は`false`を返し、`JavaScript loves you back ❤️`が、出力されます。
+if-statemnet の条件は`false`を返し、`JavaScript loves you back ❤️`が、出力されます。
 
 </p>
 </details>
@@ -2375,7 +2368,7 @@ console.log(data);
 
 #### 答え: C
 
-非同期関数は常に、promiseを返します。`await`はpromiseが解決されるのを待たなければなりません: `getData()`を呼び出すと、`data`は保留中のpromiseが返されます。
+非同期関数は常に、promise を返します。`await`は promise が解決されるのを待たなければなりません: `getData()`を呼び出すと、`data`は保留中の promise が返されます。
 
 解決した値`"I made it"`にアクセスしたい場合は、`data`に対して`.then()`メソッドを使用することができます:
 
@@ -2409,10 +2402,10 @@ console.log(result);
 
 #### 答え: B
 
-`.push（）`メソッドは新しい配列の長さを返します。以前は、配列は1つの要素（文字列 `" banana "`）を含み、長さは `1`でした。文字列 `" apple "`を配列に追加した後、配列は2つの要素を含み、長さは `2`になります。これは `addToList`関数から返されます。
+`.push（）`メソッドは新しい配列の長さを返します。以前は、配列は 1 つの要素（文字列 `" banana "`）を含み、長さは `1`でした。文字列 `" apple "`を配列に追加した後、配列は 2 つの要素を含み、長さは `2`になります。これは `addToList`関数から返されます。
 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`メソッドは元の配列を修正します。配列の長さではなく関数から配列を返したい場合は、itemをプッシュした後にlistを返すべきです。
+`push`メソッドは元の配列を修正します。配列の長さではなく関数から配列を返したい場合は、item をプッシュした後に list を返すべきです。
 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>
@@ -2447,7 +2440,7 @@ console.log(shape);
 
 変数`shape`を作成し、フリーズしたオブジェクト`box`に代入すると、`shape`はフリーズしたオブジェクトとなります。オブジェクトがフリーズしているかどうかは `Object.isFrozen`を使って確認できます。
 
-この場合、変数`shape`はフリーズしたオブジェクトへの参照を持っているので、`Object.isFrozen(shape)`はtrueを返します。
+この場合、変数`shape`はフリーズしたオブジェクトへの参照を持っているので、`Object.isFrozen(shape)`は true を返します。
 
 `shape`はフリーズされており、`x`の値はオブジェクトではないので、プロパティ`x`を変更することはできません。
 
@@ -2478,9 +2471,9 @@ console.log(name);
 
 右側のオブジェクトからプロパティ`name`をアンパックするとき、その値`"Lydia"`を`myName`という名前の変数に代入します。
 
-`{name：myName}`を使って、右側の `name`プロパティの値で`myName`という新しい変数を作りたいことをJavaScriptに伝えます。
+`{name：myName}`を使って、右側の `name`プロパティの値で`myName`という新しい変数を作りたいことを JavaScript に伝えます。
 
-定義されていない変数`name`を出力しようとしているので、ReferenceErrorが投げられます。
+定義されていない変数`name`を出力しようとしているので、ReferenceError が投げられます。
 
 </p>
 </details>
@@ -2517,7 +2510,7 @@ function sum(a, b) {
 ```javascript
 const add = () => {
   const cache = {};
-  return num => {
+  return (num) => {
     if (num in cache) {
       return `From cache! ${cache[num]}`;
     } else {
@@ -2548,15 +2541,15 @@ console.log(addFunction(5 * 2));
 
 同じ引数を指定してもう一度`addFunction`関数を呼び出すと、最初にキャッシュ内でその値がすでに取得されているかどうかを調べます。
 
-この場合、cachesの値が返され、実行時間が短縮されます。そうでなくキャッシュされていなければ、値を計算した後にそれを格納します。
+この場合、caches の値が返され、実行時間が短縮されます。そうでなくキャッシュされていなければ、値を計算した後にそれを格納します。
 
-同じ値で3回`addFunction`関数を呼び出します: 最初の呼び出しでは、`num`に`10`を代入した時、関数の値はまだキャッシュされていません。 
+同じ値で 3 回`addFunction`関数を呼び出します: 最初の呼び出しでは、`num`に`10`を代入した時、関数の値はまだキャッシュされていません。
 
-ifステートメントの`num in cache`の条件は`false`を返し、elseブロックが実行されます: `Calculated! 20`が出力され、結果の値がキャッシュオブジェクトに追加されます。 `cache`は現在 `{ 10: 20 }`となります。
+if ステートメントの`num in cache`の条件は`false`を返し、else ブロックが実行されます: `Calculated! 20`が出力され、結果の値がキャッシュオブジェクトに追加されます。 `cache`は現在 `{ 10: 20 }`となります。
 
-2回目は、`cache`オブジェクトは`10`に対して返される値を含みます。 ifステートメントの`num in cache`の条件は`true`となり、`'From cache! 20'`を返します。 よって`'From cache! 20'`が出力されます。
+2 回目は、`cache`オブジェクトは`10`に対して返される値を含みます。 if ステートメントの`num in cache`の条件は`true`となり、`'From cache! 20'`を返します。 よって`'From cache! 20'`が出力されます。
 
-3回目は、`10`に評価される関数に`5 * 2`を渡します。`cache`オブジェクトは`10`に対して返される値を含みます。ifステートメントの`num in cache`の条件は`true`となり、`'From cache! 20'`を返します。 よって`'From cache! 20'`が出力されます。
+3 回目は、`10`に評価される関数に`5 * 2`を渡します。`cache`オブジェクトは`10`に対して返される値を含みます。if ステートメントの`num in cache`の条件は`true`となり、`'From cache! 20'`を返します。 よって`'From cache! 20'`が出力されます。
 
 </p>
 </details>
@@ -2566,21 +2559,21 @@ ifステートメントの`num in cache`の条件は`false`を返し、elseブ
 ###### <a name=20190726></a>79. 何が出力されるでしょうか？
 
 ```javascript
-const myLifeSummedUp = ["☕", "💻", "🍷", "🍫"]
+const myLifeSummedUp = ["☕", "💻", "🍷", "🍫"];
 
 for (let item in myLifeSummedUp) {
-  console.log(item)
+  console.log(item);
 }
 
 for (let item of myLifeSummedUp) {
-  console.log(item)
+  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: "🍫"}`
+- D: `0` `1` `2` `3` and `{0: "☕", 1: "💻", 2: "🍷", 3: "🍫"}`
 
 <details><summary><b>答え</b></summary>
 <p>
@@ -2605,14 +2598,14 @@ _for-of_ ループを使うと、**反復可能オブジェクト**を繰り返
 ###### 80. 何が出力されるでしょうか？
 
 ```javascript
-const list = [1 + 2, 1 * 2, 1 / 2]
-console.log(list)
+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]`
+- D: `[1, 1, 1]`
 
 <details><summary><b>答え</b></summary>
 <p>
@@ -2632,16 +2625,16 @@ console.log(list)
 
 ```javascript
 function sayHi(name) {
-  return `Hi there, ${name}`
+  return `Hi there, ${name}`;
 }
 
-console.log(sayHi())
+console.log(sayHi());
 ```
 
 - A: `Hi there, `
 - B: `Hi there, undefined`
 - C: `Hi there, null`
-- D:  `ReferenceError`
+- D: `ReferenceError`
 
 <details><summary><b>答え</b></summary>
 <p>
@@ -2650,7 +2643,7 @@ console.log(sayHi())
 
 関数に値が渡されていない限り、引数はデフォルトで`undefined`の値を持ちます。上記の場合、`name`引数に値を渡さなかったので、`name`は`undefined`となり出力されます。
 
-ES6では、このデフォルトの`undefined`値を、デフォルトパラメータで上書きすることができます。例:
+ES6 では、このデフォルトの`undefined`値を、デフォルトパラメータで上書きすることができます。例:
 
 `function sayHi(name = "Lydia") { ... }`
 
@@ -2664,21 +2657,21 @@ ES6では、このデフォルトの`undefined`値を、デフォルトパラメ
 ###### 82. 何が出力されるでしょうか？
 
 ```javascript
-var status = "😎"
+var status = "😎";
 
 setTimeout(() => {
-  const status = "😍"
+  const status = "😍";
 
   const data = {
     status: "🥑",
     getStatus() {
-      return this.status
-    }
-  }
+      return this.status;
+    },
+  };
 
-  console.log(data.getStatus())
-  console.log(data.getStatus.call(this))
-}, 0)
+  console.log(data.getStatus());
+  console.log(data.getStatus.call(this));
+}, 0);
 ```
 
 - A: `"🥑"` and `"😍"`
@@ -2695,7 +2688,7 @@ setTimeout(() => {
 
 メソッドは`data`オブジェクトに属しているので、`this`は `data`オブジェクトを参照します。 `this.status`をログ出力すると、`data`オブジェクトの`status`プロパティの`"🥑"`がログ出力されます。
 
-`call`メソッドを使うと、`this`キーワードが参照するオブジェクトを変更することができます。 **関数**では、`this`キーワードは _その関数が属するオブジェクトを参照します_ 。 
+`call`メソッドを使うと、`this`キーワードが参照するオブジェクトを変更することができます。 **関数**では、`this`キーワードは _その関数が属するオブジェクトを参照します_ 。
 
 _グローバルオブジェクトで_ `setTimeout`関数を宣言したので、`setTimeout`関数内では、 `this`キーワードは _グローバルオブジェクト_ を参照します。
 
@@ -2711,13 +2704,13 @@ _グローバルオブジェクトで_ `setTimeout`関数を宣言したので
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21
-}
+  age: 21,
+};
 
-let city = person.city
-city = "Amsterdam"
+let city = person.city;
+city = "Amsterdam";
 
-console.log(person)
+console.log(person);
 ```
 
 - A: `{ name: "Lydia", age: 21 }`
@@ -2734,7 +2727,7 @@ console.log(person)
 
 我々は`person`オブジェクト自身を参照して _いない_ ことに注意してください。`person`オブジェクトの`city`プロパティを、変数`city`に代入するだけです。
 
-それから、`city`に、文字列`"Amsterdam"`を代入しますこれは personオブジェクトを変更しません: そのオブジェクトへの参照はありません。
+それから、`city`に、文字列`"Amsterdam"`を代入しますこれは person オブジェクトを変更しません: そのオブジェクトへの参照はありません。
 
 `person`オブジェクトをログ出力するとき、未修正のオブジェクトが返されます。
 
@@ -2748,15 +2741,15 @@ console.log(person)
 ```javascript
 function checkAge(age) {
   if (age < 18) {
-    const message = "Sorry, you're too young."
+    const message = "Sorry, you're too young.";
   } else {
-    const message = "Yay! You're old enough!"
+    const message = "Yay! You're old enough!";
   }
 
-  return message
+  return message;
 }
 
-console.log(checkAge(21))
+console.log(checkAge(21));
 ```
 
 - A: `"Sorry, you're too young."`
@@ -2769,7 +2762,7 @@ console.log(checkAge(21))
 
 #### 答え: C
 
-`const`と`let`キーワードを持つ変数は _ブロックスコープ_ です。ブロックは中括弧(`{ }`)で囲まれたものです。上記の場合、if/elseステートメントが中括弧となります。宣言されたブロックの外側で変数を参照することはできません。ReferenceError がスローされます。
+`const`と`let`キーワードを持つ変数は _ブロックスコープ_ です。ブロックは中括弧(`{ }`)で囲まれたものです。上記の場合、if/else ステートメントが中括弧となります。宣言されたブロックの外側で変数を参照することはできません。ReferenceError がスローされます。
 
 </p>
 </details>
@@ -2779,29 +2772,29 @@ console.log(checkAge(21))
 ###### 85. どのような情報が出力されますか？
 
 ```javascript
-fetch('https://www.website.com/api/user/1')
-  .then(res => res.json())
-  .then(res => console.log(res))
+fetch("https://www.website.com/api/user/1")
+  .then((res) => res.json())
+  .then((res) => console.log(res));
 ```
 
 - A: `fetch`メソッドの結果
-- B: 2回目の `fetch`メソッド呼び出しの結果
+- B: 2 回目の `fetch`メソッド呼び出しの結果
 - C: 前の`.then()`でのコールバックの結果
-- D: 常に undefined. 
+- D: 常に undefined.
 
 <details><summary><b>答え</b></summary>
 <p>
 
 #### 答え: C
 
-2番目の`.then`の`res`の値は、前の`.then`の戻り値と同じとなります。値が次のハンドラに渡されるように、`.then`を連鎖させることができます。
+2 番目の`.then`の`res`の値は、前の`.then`の戻り値と同じとなります。値が次のハンドラに渡されるように、`.then`を連鎖させることができます。
 
 </p>
 </details>
 
 ---
 
-###### 86. 引数としてtrueを渡すことができない場合、どのオプションが`hasName`を`true`に設定するための方法ですか？
+###### 86. 引数として true を渡すことができない場合、どのオプションが`hasName`を`true`に設定するための方法ですか？
 
 ```javascript
 function getName(name) {
@@ -2819,7 +2812,7 @@ function getName(name) {
 
 #### 答え: A
 
-`!!name`を使って、`name`の値が、truthyか falseyかを判断します。nameがtruthyであり、これをテストしたい場合、`!name`は`false`を返します。`!false`（これは実際には`!!name`です）は`true`を返します。
+`!!name`を使って、`name`の値が、truthy か falsey かを判断します。name が truthy であり、これをテストしたい場合、`!name`は`false`を返します。`!false`（これは実際には`!!name`です）は`true`を返します。
 
 `hasName`に`name`を代入することで、`getName`関数に渡されたどんな値も`hasName`に代入されます。ブール値`true`は設定できません。
 
diff --git a/ko-KR/README-ko_KR.md b/ko-KR/README-ko_KR.md
index 13651a7c..ef2d94e1 100644
--- a/ko-KR/README-ko_KR.md
+++ b/ko-KR/README-ko_KR.md
@@ -34,6 +34,7 @@
 - [🇳🇱 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)
@@ -54,7 +55,7 @@
 function sayHi() {
   console.log(name);
   console.log(age);
-  var name = 'Lydia';
+  var name = "Lydia";
   let age = 21;
 }
 
@@ -150,7 +151,7 @@ console.log(shape.perimeter());
 
 ```javascript
 +true;
-!'Lydia';
+!"Lydia";
 ```
 
 - A: `1` 그리고 `false`
@@ -175,11 +176,11 @@ console.log(shape.perimeter());
 
 ```javascript
 const bird = {
-  size: 'small',
+  size: "small",
 };
 
 const mouse = {
-  name: 'Mickey',
+  name: "Mickey",
   small: true,
 };
 ```
@@ -210,11 +211,11 @@ JavaScript는 문장을 해석(또는 분)해요. 대괄호 표기를 사용하
 ###### 6. 무엇이 출력 될까요?
 
 ```javascript
-let c = { greeting: 'Hey!' };
+let c = { greeting: "Hey!" };
 let d;
 
 d = c;
-c.greeting = 'Hello';
+c.greeting = "Hello";
 console.log(d.greeting);
 ```
 
@@ -229,7 +230,7 @@ console.log(d.greeting);
 
 #### 답: A
 
-JavaScript에서 모든 객체는 서로를 동일하게 설정하면 _참조_로 상호작용해요.
+JavaScript에서 모든 객체는 서로를 동일하게 설정하면 *참조*로 상호작용해요.
 
 우선, 변수 `c`는 객체에 대한 값을 갖고 있어요. 그 후 `c`가 객체에 가지고 있는 것과 동일한 참조를 `d`에 할당해요.
 
@@ -284,13 +285,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`
@@ -340,10 +341,10 @@ console.log(greetign);
 
 ```javascript
 function bark() {
-  console.log('Woof!');
+  console.log("Woof!");
 }
 
-bark.animal = 'dog';
+bark.animal = "dog";
 ```
 
 - A: 별일 없어요, 이건 완전히 괜찮아요!
@@ -373,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}`;
 };
@@ -414,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);
@@ -485,7 +486,7 @@ function sum(a, b) {
   return a + b;
 }
 
-sum(1, '2');
+sum(1, "2");
 ```
 
 - A: `NaN`
@@ -552,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`;
@@ -579,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`);
   }
@@ -641,7 +642,7 @@ rest 파라미터 (`...args`)는 남아있는 모든 인수을 하나의 배열
 
 ```javascript
 function getAge() {
-  'use strict';
+  "use strict";
   age = 21;
   console.log(age);
 }
@@ -669,7 +670,7 @@ getAge();
 ###### 21. `sum`의 값은 무엇일까요?
 
 ```javascript
-const sum = eval('10*10+5');
+const sum = eval("10*10+5");
 ```
 
 - A: `105`
@@ -692,7 +693,7 @@ const sum = eval('10*10+5');
 ###### 22. cool_secret에 몇 시간이나 접근이 가능할까요?
 
 ```javascript
-sessionStorage.setItem('cool_secret', 123);
+sessionStorage.setItem("cool_secret", 123);
 ```
 
 - A: 영원히, 데이터는 사라지지 않아요.
@@ -745,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);
 ```
 
@@ -776,7 +777,7 @@ set에서는 동작하지 않아요. set에는 `'1'`이 없어요: `set.has('1')
 ###### 25. 무엇이 출력 될까요?
 
 ```javascript
-const obj = { a: 'one', b: 'two', a: 'three' };
+const obj = { a: "one", b: "two", a: "three" };
 console.log(obj);
 ```
 
@@ -845,12 +846,12 @@ 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())
+console.log(name.giveLydiaPizza());
 ```
 
 - A: `"Just give Lydia pizza already!"`
@@ -874,8 +875,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;
@@ -907,9 +908,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();
@@ -1012,7 +1013,7 @@ WebAPI는 준비가 될 때마다 stack에 항목을 추가할 수 없어요. 
 ###### 33. 무엇이 출력 될까요?
 
 ```javascript
-const person = { name: 'Lydia' };
+const person = { name: "Lydia" };
 
 function sayHi(age) {
   console.log(`${this.name} is ${age}`);
@@ -1075,8 +1076,8 @@ console.log(typeof sayHi());
 ```javascript
 0;
 new Number(0);
-('');
-(' ');
+("");
+(" ");
 new Boolean(false);
 undefined;
 ```
@@ -1259,7 +1260,7 @@ JavaScript는 원시형과 객체만 가지고 있어요.
 
 ```javascript
 !!null;
-!!'';
+!!"";
 !!1;
 ```
 
@@ -1287,7 +1288,7 @@ JavaScript는 원시형과 객체만 가지고 있어요.
 ###### 42. `setInterval` 메소드는 브라우저에게 무엇을 반환 할까요?
 
 ```javascript
-setInterval(() => console.log('Hi'), 1000);
+setInterval(() => console.log("Hi"), 1000);
 ```
 
 - A: 유니크한 id
@@ -1310,7 +1311,7 @@ setInterval(() => console.log('Hi'), 1000);
 ###### 43. 이것은 무엇을 반환할까요?
 
 ```javascript
-[...'Lydia'];
+[..."Lydia"];
 ```
 
 - A: `["L", "y", "d", "i", "a"]`
@@ -1369,11 +1370,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));
@@ -1399,7 +1400,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;
 
@@ -1420,7 +1421,7 @@ console.log(members);
 
 <img src="https://i.imgur.com/TML1MbS.png" width="200">
 
-그 후, `members`라는 변수를 선언해요. 배열의 첫 번째 요소에 `person` 변수의 값을 대입해요. 서로를 같게 설정하면 _참조_로 상호작용해요. 어떤 변수에서 다른 변수로 참조를 할당하면, 그 참조의 _복사본_ 을 만들어요. (그들은 _같은_ 참조를 가지고 있지 않다는 것을 유의하세요!)
+그 후, `members`라는 변수를 선언해요. 배열의 첫 번째 요소에 `person` 변수의 값을 대입해요. 서로를 같게 설정하면 *참조*로 상호작용해요. 어떤 변수에서 다른 변수로 참조를 할당하면, 그 참조의 _복사본_ 을 만들어요. (그들은 _같은_ 참조를 가지고 있지 않다는 것을 유의하세요!)
 
 <img src="https://i.imgur.com/FSG5K3F.png" width="300">
 
@@ -1439,7 +1440,7 @@ console.log(members);
 
 ```javascript
 const person = {
-  name: 'Lydia',
+  name: "Lydia",
   age: 21,
 };
 
@@ -1468,7 +1469,7 @@ for (const item in person) {
 ###### 48. 무엇이 출력 될까요?
 
 ```javascript
-console.log(3 + 4 + '5');
+console.log(3 + 4 + "5");
 ```
 
 - A: `"345"`
@@ -1495,7 +1496,7 @@ console.log(3 + 4 + '5');
 ###### 49. `num`의 값은 무엇일까요?
 
 ```javascript
-const num = parseInt('7*6', 10);
+const num = parseInt("7*6", 10);
 ```
 
 - A: `42`
@@ -1521,7 +1522,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;
 });
 ```
@@ -1549,12 +1550,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);
 
@@ -1586,15 +1587,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);
   }
 }
 
@@ -1624,8 +1625,8 @@ sayHi();
 
 ```javascript
 function Car() {
-  this.make = 'Lamborghini';
-  return { make: 'Maserati' };
+  this.make = "Lamborghini";
+  return { make: "Maserati" };
 }
 
 const myCar = new Car();
@@ -1701,7 +1702,7 @@ Dog.prototype.bark = function () {
   console.log(`Woof I am ${this.name}`);
 };
 
-const pet = new Dog('Mara');
+const pet = new Dog("Mara");
 
 pet.bark();
 
@@ -1766,7 +1767,7 @@ export default counter;
 
 ```javascript
 // index.js
-import myCounter from './counter';
+import myCounter from "./counter";
 
 myCounter += 1;
 
@@ -1866,7 +1867,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);
@@ -1892,9 +1893,9 @@ spread 연산자 `...` 를 사용해 객체를 결합할 수 있어요. 이것
 ###### 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));
@@ -1923,12 +1924,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);
 ```
 
@@ -1959,7 +1960,7 @@ replacer가 _함수_ 라면, 문자열로 변환 할 객체의 모든 속성에
 let num = 10;
 
 const increaseNumber = () => num++;
-const increasePassedNumber = number => number++;
+const increasePassedNumber = (number) => number++;
 
 const num1 = increaseNumber();
 const num2 = increasePassedNumber(num1);
@@ -2116,12 +2117,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;
 ```
 
@@ -2149,7 +2150,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`
@@ -2172,7 +2173,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));
 ```
@@ -2199,7 +2200,7 @@ console.log(name.padStart(2));
 ###### 70. 무엇이 출력 될까요?
 
 ```javascript
-console.log('🥑' + '💻');
+console.log("🥑" + "💻");
 ```
 
 - A: `"🥑💻"`
@@ -2223,11 +2224,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 gone here";
   }
-  return 'JavaScript loves you back ❤️';
+  return "JavaScript loves you back ❤️";
 }
 
 const game = startGame();
@@ -2295,7 +2296,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();
@@ -2332,7 +2333,7 @@ function addToList(item, list) {
   return list.push(item);
 }
 
-const result = addToList('apple', ['banana']);
+const result = addToList("apple", ["banana"]);
 console.log(result);
 ```
 
@@ -2392,7 +2393,7 @@ console.log(shape);
 ###### 76. 무엇이 출력 될까요?
 
 ```javascript
-const { name: myName } = { name: 'Lydia' };
+const { name: myName } = { name: "Lydia" };
 
 console.log(name);
 ```
@@ -2493,7 +2494,7 @@ console.log(addFunction(5 * 2));
 ###### 79. 무엇이 출력 될까요?
 
 ```javascript
-const myLifeSummedUp = ['☕', '💻', '🍷', '🍫'];
+const myLifeSummedUp = ["☕", "💻", "🍷", "🍫"];
 
 for (let item in myLifeSummedUp) {
   console.log(item);
@@ -2589,13 +2590,13 @@ ES6에서, 기본값 `undefined` 값을 기본값 매개변수로 덮어쓸 수
 ###### 82. 무엇이 출력 될까요?
 
 ```javascript
-var status = '😎';
+var status = "😎";
 
 setTimeout(() => {
-  const status = '😍';
+  const status = "😍";
 
   const data = {
-    status: '🥑',
+    status: "🥑",
     getStatus() {
       return this.status;
     },
@@ -2629,12 +2630,12 @@ setTimeout(() => {
 
 ```javascript
 const person = {
-  name: 'Lydia',
+  name: "Lydia",
   age: 21,
 };
 
 let city = person.city;
-city = 'Amsterdam';
+city = "Amsterdam";
 
 console.log(person);
 ```
@@ -2698,7 +2699,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));
 ```
@@ -2754,7 +2755,7 @@ function getName(name) {
 ###### 87. 무엇이 출력 될까요?
 
 ```javascript
-console.log('I want pizza'[0]);
+console.log("I want pizza"[0]);
 ```
 
 - A: `"""`
@@ -2809,11 +2810,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);
 ```
@@ -2846,7 +2847,7 @@ class Person {
   }
 }
 
-const member = new Person('John');
+const member = new Person("John");
 console.log(typeof member);
 ```
 
@@ -2906,7 +2907,7 @@ console.log(newList.push(5));
 
 ```javascript
 function giveLydiaPizza() {
-  return 'Here is pizza!';
+  return "Here is pizza!";
 }
 
 const giveLydiaChocolate = () =>
@@ -2937,7 +2938,7 @@ console.log(giveLydiaChocolate.prototype);
 
 ```javascript
 const person = {
-  name: 'Lydia',
+  name: "Lydia",
   age: 21,
 };
 
@@ -2997,7 +2998,7 @@ function getItems(fruitList, favoriteFruit, ...args) {
   return [...fruitList, ...args, favoriteFruit];
 }
 
-getItems(['banana', 'apple'], 'pear', 'orange');
+getItems(["banana", "apple"], "pear", "orange");
 ```
 
 위의 예시는 동작해요. 배열 `[ 'banana', 'apple', 'orange', 'pear' ]`을 반환해요.
@@ -3011,8 +3012,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;
 }
@@ -3052,13 +3053,13 @@ a + b;
 ```javascript
 class Person {
   constructor() {
-    this.name = 'Lydia';
+    this.name = "Lydia";
   }
 }
 
 Person = class AnotherPerson {
   constructor() {
-    this.name = 'Sarah';
+    this.name = "Sarah";
   }
 };
 
@@ -3087,7 +3088,7 @@ console.log(member.name);
 
 ```javascript
 const info = {
-  [Symbol('a')]: 'b',
+  [Symbol("a")]: "b",
 };
 
 console.log(info);
@@ -3156,7 +3157,7 @@ rest 파라미터를 사용해 `...y`에 모든 "남은" 인수을 배열에 넣
 ###### 99. 무엇이 출력 될까요?
 
 ```javascript
-const name = 'Lydia';
+const name = "Lydia";
 
 console.log(name());
 ```
@@ -3188,8 +3189,8 @@ ReferenceErrors는 JavaScript가 접근하려고 하는 값의 참조를 찾을
 ```javascript
 // 🎉✨ 이번이 내 100번째 질문이에요! ✨🎉
 
-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`
@@ -3215,7 +3216,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);
@@ -3247,16 +3248,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();
@@ -3294,8 +3295,8 @@ promise를 사용하면, 기본적으로 _이 함수를 실행하고 싶지만,
 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);
@@ -3355,13 +3356,13 @@ promise 또는 non-promise가 아니더라도, 어떤 유형의 값이라도 `Pr
 ```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);
 ```
@@ -3400,7 +3401,7 @@ const colorConfig = {
   yellow: false,
 };
 
-const colors = ['pink', 'red', 'blue'];
+const colors = ["pink", "red", "blue"];
 
 console.log(colorConfig.colors[1]);
 ```
@@ -3429,7 +3430,7 @@ JavaScript 문장을 해석(또는 참조형 변수를 원시 데이터 타입
 ###### 107. 값은 무엇일까요?
 
 ```javascript
-console.log('❤️' === '❤️');
+console.log("❤️" === "❤️");
 ```
 
 - A: `true`
@@ -3450,14 +3451,14 @@ console.log('❤️' === '❤️');
 ###### 108. 다음 중 원본 배열을 수정하는 method는 무엇일까요?
 
 ```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`
@@ -3482,10 +3483,10 @@ emojis.splice(1, 2, '✨');
 ###### 109. 무엇이 출력 될까요?
 
 ```javascript
-const food = ['🍕', '🍫', '🥑', '🍔'];
+const food = ["🍕", "🍫", "🥑", "🍔"];
 const info = { favoriteFood: food[0] };
 
-info.favoriteFood = '🍝';
+info.favoriteFood = "🍝";
 
 console.log(food);
 ```
@@ -3539,7 +3540,7 @@ const jsonArray = JSON.stringify([1, 2, 3]); // '[1, 2, 3]'
 JSON.parse(jsonArray); // [1, 2, 3]
 
 // 객체를 유효한 JSON 문자열로 변환해요, 그리고 나서 JSON 문자열의 구문을 분석해 JavaScript 값으로 생성해요.
-const jsonArray = JSON.stringify({ name: 'Lydia' }); // '{"name":"Lydia"}'
+const jsonArray = JSON.stringify({ name: "Lydia" }); // '{"name":"Lydia"}'
 JSON.parse(jsonArray); // { name: 'Lydia' }
 ```
 
@@ -3551,11 +3552,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();
@@ -3578,7 +3579,7 @@ getName();
 `getName` 함수 안에 `name` 변수를 선언하지 않았다면, javaScript 엔진은 _스코프 체인_ 을 살펴봤을 거예요. 외부 범위에는 값이 `Lydia`인 `name`이라는 변수가 있어요. 이 경우 `Lydia`를 출력할 거예요.
 
 ```javascript
-let name = 'Lydia';
+let name = "Lydia";
 
 function getName() {
   console.log(name);
@@ -3596,11 +3597,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();
@@ -3646,7 +3647,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`
@@ -3671,7 +3672,7 @@ console.log(`${((x) => x)('I love')} to program`);
 ```javascript
 let config = {
   alert: setInterval(() => {
-    console.log('Alert!');
+    console.log("Alert!");
   }, 1000),
 };
 
@@ -3703,16 +3704,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
@@ -3739,14 +3740,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);
@@ -3805,7 +3806,7 @@ function sumValues(x, y, z) {
 
 ```javascript
 let num = 1;
-const list = ['🥳', '🤠', '🥰', '🤪'];
+const list = ["🥳", "🤠", "🥰", "🤪"];
 
 console.log(list[(num += 1)]);
 ```
@@ -3831,11 +3832,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}`;
@@ -3873,10 +3874,10 @@ optional chaining 연산자 `?.`를 사용하면, 더 깊이 중첩된 값이 
 ###### 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!`);
 }
@@ -3932,10 +3933,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`
@@ -4050,14 +4051,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}`;
@@ -4086,8 +4087,8 @@ console.log(getFine(130, 300));
 ###### 127. 무엇이 출력 될까요?
 
 ```javascript
-const spookyItems = ['👻', '🎃', '🕸'];
-({ item: spookyItems[3] } = { item: '💀' });
+const spookyItems = ["👻", "🎃", "🕸"];
+({ item: spookyItems[3] } = { item: "💀" });
 
 console.log(spookyItems);
 ```
@@ -4112,7 +4113,7 @@ console.log(spookyItems);
 ###### 128. 무엇이 출력 될까요?
 
 ```javascript
-const name = 'Lydia Hallie';
+const name = "Lydia Hallie";
 const age = 21;
 
 console.log(Number.isNaN(name));
@@ -4148,7 +4149,7 @@ const randomValue = 21;
 
 function getInfo() {
   console.log(typeof randomValue);
-  const randomValue = 'Lydia Hallie';
+  const randomValue = "Lydia Hallie";
 }
 
 getInfo();
@@ -4174,7 +4175,7 @@ getInfo();
 ###### 130. 무엇이 출력 될까요?
 
 ```javascript
-const myPromise = Promise.resolve('Woah some cool data');
+const myPromise = Promise.resolve("Woah some cool data");
 
 (async () => {
   try {
@@ -4182,7 +4183,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!");
   }
 })();
 ```
@@ -4207,7 +4208,7 @@ const myPromise = Promise.resolve('Woah some cool data');
 ###### 131. 무엇이 출력 될까요?
 
 ```javascript
-const emojis = ['🥑', ['✨', '✨', ['🍕', '🍕']]];
+const emojis = ["🥑", ["✨", "✨", ["🍕", "🍕"]]];
 
 console.log(emojis.flat(1));
 ```
@@ -4280,19 +4281,19 @@ console.log(counterOne.count);
 ###### 133. 무엇이 출력 될까요?
 
 ```javascript
-const myPromise = Promise.resolve(Promise.resolve('Promise!'));
+const myPromise = Promise.resolve(Promise.resolve("Promise!"));
 
 function funcOne() {
   myPromise.then((res) => res).then((res) => console.log(res));
-  setTimeout(() => console.log('Timeout!'), 0);
-  console.log('Last line!');
+  setTimeout(() => console.log("Timeout!"), 0);
+  console.log("Last line!");
 }
 
 async function funcTwo() {
   const res = await myPromise;
   console.log(await res);
-  setTimeout(() => console.log('Timeout!'), 0);
-  console.log('Last line!');
+  setTimeout(() => console.log("Timeout!"), 0);
+  console.log("Last line!");
 }
 
 funcOne();
@@ -4333,7 +4334,7 @@ export default function sum(x) {
 }
 
 // index.js
-import * as sum from './sum';
+import * as sum from "./sum";
 ```
 
 - A: `sum(4)`
@@ -4350,12 +4351,12 @@ import * as sum from './sum';
 
 ```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);
 ```
 
@@ -4386,13 +4387,13 @@ console.log(info);
 
 ```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;
 ```
 
@@ -4422,7 +4423,7 @@ Proxy 객체를 사용하면, 두번째 인수로 전달 한 객체에 사용자
 ###### 136. 다음 중 어느 것이 `person` 객체를 수정 할 수 있을까요?
 
 ```javascript
-const person = { name: 'Lydia Hallie' };
+const person = { name: "Lydia Hallie" };
 
 Object.seal(person);
 ```
@@ -4450,9 +4451,9 @@ Object.seal(person);
 
 ```javascript
 const person = {
-  name: 'Lydia Hallie',
+  name: "Lydia Hallie",
   address: {
-    street: '100 Main St',
+    street: "100 Main St",
   },
 };
 
@@ -4552,8 +4553,8 @@ ES2020에서, `#`을 사용한 private 변수를 추가 할 수 있어요. 클
 
 ```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) {
@@ -4596,8 +4597,8 @@ obj.next(); // { value: "Lisa", done: false }
 
 ```javascript
 const person = {
-  name: 'Lydia Hallie',
-  hobbies: ['coding'],
+  name: "Lydia Hallie",
+  hobbies: ["coding"],
 };
 
 function addHobby(hobby, hobbies = person.hobbies) {
@@ -4605,9 +4606,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);
 ```
@@ -4676,11 +4677,11 @@ const pet = new Flamingo();
 ###### 143. 다음 중 어느 것의 결과가 오류일까요?
 
 ```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;
 ```
 
@@ -4766,9 +4767,9 @@ function getFruit(fruits) {
   console.log(fruits?.[1]?.[1]);
 }
 
-getFruit([['🍊', '🍌'], ['🍍']]);
+getFruit([["🍊", "🍌"], ["🍍"]]);
 getFruit();
-getFruit([['🍍'], ['🍊', '🍌']]);
+getFruit([["🍍"], ["🍊", "🍌"]]);
 ```
 
 - A: `null`, `undefined`, 🍌
@@ -4798,19 +4799,19 @@ getFruit([['🍍'], ['🍊', '🍌']]);
 
 ```javascript
 class Calc {
-	constructor() {
-		this.count = 0 
-	}
+  constructor() {
+    this.count = 0;
+  }
 
-	increase() {
-		this.count ++
-	}
+  increase() {
+    this.count++;
+  }
 }
 
-const calc = new Calc()
-new Calc().increase()
+const calc = new Calc();
+new Calc().increase();
 
-console.log(calc.count)
+console.log(calc.count);
 ```
 
 - A: `0`
@@ -4834,25 +4835,25 @@ console.log(calc.count)
 
 ```javascript
 const user = {
-	email: "e@mail.com",
-	password: "12345"
-}
+  email: "e@mail.com",
+  password: "12345",
+};
 
 const updateUser = ({ email, password }) => {
-	if (email) {
-		Object.assign(user, { email })
-	}
+  if (email) {
+    Object.assign(user, { email });
+  }
 
-	if (password) {
-		user.password = password
-	}
+  if (password) {
+    user.password = password;
+  }
 
-	return user
-}
+  return user;
+};
 
-const updatedUser = updateUser({ email: "new@email.com" })
+const updatedUser = updateUser({ email: "new@email.com" });
 
-console.log(updatedUser === user)
+console.log(updatedUser === user);
 ```
 
 - A: `false`
@@ -4875,13 +4876,13 @@ console.log(updatedUser === user)
 ###### 149. 무엇이 출력 될까요?
 
 ```javascript
-const fruit = ['🍌', '🍊', '🍎']
+const fruit = ["🍌", "🍊", "🍎"];
 
-fruit.slice(0, 1)
-fruit.splice(0, 1)
-fruit.unshift('🍇')
+fruit.slice(0, 1);
+fruit.splice(0, 1);
+fruit.unshift("🍇");
 
-console.log(fruit)
+console.log(fruit);
 ```
 
 - A: `['🍌', '🍊', '🍎']`
@@ -4907,13 +4908,13 @@ console.log(fruit)
 
 ```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])
+console.log(animals[dog]);
 ```
 
 - A: `{ emoji: "🐶", name: "Mara" }`
@@ -4930,7 +4931,7 @@ console.log(animals[dog])
 
 `dog`의 값은 객체 이므로, 사실 `animals[dog]`는 새로운 객체에 `"object Object"`라고 불리는 새로운 속성을 만든 걸 의미해요. 이제 `animals["object Object"]`는 `{ emoji: "🐶", name: "Mara"}`예요.
 
-`cat`도 물론 객체고, 사실 `animals[cat]`은 `animals[``"``object Object``"``]`을 새로운 속성 cat으로 덮어쓰고 있다는 것을 의미해요.
+`cat`도 물론 객체고, 사실 `animals[cat]`은 ` animals[``"``object Object``"``] `을 새로운 속성 cat으로 덮어쓰고 있다는 것을 의미해요.
 
 `animals[dog]` 또는 `animals["object Object"]`(`dog` 객체를 문자열로 변환한 결과는 `"object Object"`)를 출력하면, `{ emoji: "🐈", name: "Sara" }`를 반환해요.
 
@@ -4943,14 +4944,14 @@ console.log(animals[dog])
 
 ```javascript
 const user = {
-	email: "my@email.com",
-	updateEmail: email => {
-		this.email = email
-	}
-}
+  email: "my@email.com",
+  updateEmail: (email) => {
+    this.email = email;
+  },
+};
 
-user.updateEmail("new@email.com")
-console.log(user.email)
+user.updateEmail("new@email.com");
+console.log(user.email);
 ```
 
 - A: `my@email.com`
@@ -4973,20 +4974,20 @@ console.log(user.email)
 ###### 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])
-	const res2  = await Promise.all([promise3, promise4])
-	return [res1, res2]
-}
+  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))
+  .then((res) => console.log(res))
+  .catch((err) => console.log(err));
 ```
 
 - A: `[['First', 'Second'], ['Fourth']]`
@@ -5009,13 +5010,16 @@ runPromises()
 ###### 153. 무엇이 `method`의 값이어야 `{ name: "Lydia", age: 22 }`를 출력할까요?
 
 ```javascript
-const keys = ["name", "age"]
-const values = ["Lydia", 22]
+const keys = ["name", "age"];
+const values = ["Lydia", 22];
 
-const method = /* ?? */
-Object[method](keys.map((_, i) => {
-	return [keys[i], values[i]]
-})) // { name: "Lydia", age: 22 }
+const method =
+  /* ?? */
+  Object[method](
+    keys.map((_, i) => {
+      return [keys[i], values[i]];
+    })
+  ); // { name: "Lydia", age: 22 }
 ```
 
 - A: `entries`
@@ -5040,18 +5044,18 @@ Object[method](keys.map((_, i) => {
 ###### 154. 무엇이 출력 될까요?
 
 ```javascript
-const createMember = ({ email, address = {}}) => {
-	const validEmail = /.+\@.+\..+/.test(email)
-	if (!validEmail) throw new Error("Valid email pls")
+const createMember = ({ email, address = {} }) => {
+  const validEmail = /.+\@.+\..+/.test(email);
+  if (!validEmail) throw new Error("Valid email pls");
 
-	return {
-		email,
-		address: address ? address : null
-	}
-}
+  return {
+    email,
+    address: address ? address : null,
+  };
+};
 
-const member = createMember({ email: "my@email.com" })
-console.log(member)
+const member = createMember({ email: "my@email.com" });
+console.log(member);
 ```
 
 - A: `{ email: "my@email.com", address: null }`
@@ -5074,13 +5078,13 @@ console.log(member)
 ###### 155. 무엇이 출력 될까요?
 
 ```javascript
-let randomValue = { name: "Lydia" }
-randomValue = 23
+let randomValue = { name: "Lydia" };
+randomValue = 23;
 
 if (!typeof randomValue === "string") {
-	console.log("It's not a string!")
+  console.log("It's not a string!");
 } else {
-	console.log("Yay it's a string!")
+  console.log("Yay it's a string!");
 }
 ```
 
diff --git a/nl-NL/README.md b/nl-NL/README.md
index 0400e8ed..1852e0e0 100644
--- a/nl-NL/README.md
+++ b/nl-NL/README.md
@@ -2,14 +2,15 @@
   <img height="60" src="https://img.icons8.com/color/344/javascript.png"> 
   <h1>JavaScript Vragen</h1>
 
-  ---
+---
+
+<span>Ik plaats JavaScript meerkeuzevragen op mijn [Instagram](https://www.instagram.com/theavocoder) **stories**, welke ik ook hier zal plaatsen! Laatste update: <a href=#20191224><b>24 december</b></a>
 
-  <span>Ik plaats JavaScript meerkeuzevragen op mijn [Instagram](https://www.instagram.com/theavocoder) **stories**, welke ik ook hier zal plaatsen! Laatste update: <a href=#20191224><b>24 december</b></a>
+Van beginner naar expert: test hoe goed je JavaScript kent, fris je kennis een beetje op, of bereid je voor op een sollicitatiegesprek! :muscle: :rocket: Ik zal deze repository regelmatig updaten met nieuwe vragen. Ik heb de antwoorden toegevoegd in de **ingeklapte secties** onder een vraag, zodat je er makkelijk op kan klikken om ze uit te klappen. Het is gewoon voor je plezier, veel succes! :heart:</span>
 
-  Van beginner naar expert: test hoe goed je JavaScript kent, fris je kennis een beetje op, of bereid je voor op een sollicitatiegesprek! :muscle: :rocket: Ik zal deze repository regelmatig updaten met nieuwe vragen. Ik heb de antwoorden toegevoegd in de **ingeklapte secties** onder een vraag, zodat je er makkelijk op kan klikken om ze uit te klappen. Het is gewoon voor je plezier, veel succes! :heart:</span>
+Voel je vrij om contact met mij op te nemen! 😊 <br />
+<a href="https://www.instagram.com/theavocoder">Instagram</a> || <a href="https://www.twitter.com/lydiahallie">Twitter</a> || <a href="https:/www.linkedin.com/in/lydia-hallie">LinkedIn</a> || <a href="www.lydiahallie.dev">Blog</a>
 
-  Voel je vrij om contact met mij op te nemen! 😊 <br />
-  <a href="https://www.instagram.com/theavocoder">Instagram</a> || <a href="https://www.twitter.com/lydiahallie">Twitter</a> || <a href="https:/www.linkedin.com/in/lydia-hallie">LinkedIn</a> || <a href="www.lydiahallie.dev">Blog</a>
   </div>
 
 ---
@@ -30,6 +31,7 @@
 - [🇰🇷 한국어](../ko-KR/README-ko_KR.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)
@@ -114,7 +116,7 @@ const shape = {
   diameter() {
     return this.radius * 2;
   },
-  perimeter: () => 2 * Math.PI * this.radius
+  perimeter: () => 2 * Math.PI * this.radius,
 };
 
 console.log(shape.diameter());
@@ -171,12 +173,12 @@ De string `'Lydia'` is een truthy waarde. Wat we eigenlijk vragen, is "is deze t
 
 ```javascript
 const bird = {
-  size: "small"
+  size: "small",
 };
 
 const mouse = {
   name: "Mickey",
-  small: true
+  small: true,
 };
 ```
 
@@ -203,7 +205,6 @@ Echter, met de dot notatie zal dit niet gebeuren. `mouse` heeft geen propertie g
 
 ---
 
-
 ###### 6. Wat is de uitkomst?
 
 ```javascript
@@ -263,7 +264,7 @@ console.log(b === c);
 
 `new Number()` is een ingebouwde functie constructor. En ook al lijkt het misschien op een nummer, dat is het niet. Het is een object en bevat ten opzichte van een nummer veel extra opties.
 
-Wanneer we de `==` operator gebruiken wordt er alleen op de _waarde_ gecheckt. Zowel `a` als `b` bevatten de waarde `3`, dus geeft dit `true` terug. 
+Wanneer we de `==` operator gebruiken wordt er alleen op de _waarde_ gecheckt. Zowel `a` als `b` bevatten de waarde `3`, dus geeft dit `true` terug.
 
 Echter, wanneer we de `===` operator gebruiken wordt er zowel op de _waarde_ als op het _type_ gecheckt. Omdat `new Number()` een **object** is en geen nummer zal dit `false` teruggeven.
 
@@ -371,7 +372,7 @@ function Person(firstName, lastName) {
 }
 
 const member = new Person("Lydia", "Hallie");
-Person.getFullName = function() {
+Person.getFullName = function () {
   return `${this.firstName} ${this.lastName}`;
 };
 
@@ -391,7 +392,7 @@ console.log(member.getFullName());
 Je kunt geen properties toevoegen aan een instantie van een object, zoals je kan met normale objecten. Als je een feature toe wilt voegen aan alle objecten in één keer zul je dit middels de prototype van een object moeten doen. In dit geval,
 
 ```js
-Person.prototype.getFullName = function() {
+Person.prototype.getFullName = function () {
   return `${this.firstName} ${this.lastName}`;
 };
 ```
@@ -847,7 +848,7 @@ String.prototype.giveLydiaPizza = () => {
 
 const name = "Lydia";
 
-console.log(name.giveLydiaPizza())
+console.log(name.giveLydiaPizza());
 ```
 
 - A: `"Just give Lydia pizza already!"`
@@ -943,7 +944,7 @@ De WebAPI kan niet zomaar dingen toevoegen aan de stack. In plaats daarvan wordt
 
 <img src="https://i.imgur.com/NSnDZmU.png" width="200">
 
-Dit is waar de event loop zijn intrede doet. Een ***event loop* naar de stack en de task queue. Als de stack leeg is pakt het het eerste ding op van de queue en zet het op de stack.
+Dit is waar de event loop zijn intrede doet. Een _\*\*event loop_ naar de stack en de task queue. Als de stack leeg is pakt het het eerste ding op van de queue en zet het op de stack.
 
 <img src="https://i.imgur.com/uyiScAI.png" width="200">
 
@@ -959,9 +960,7 @@ Dit is waar de event loop zijn intrede doet. Een ***event loop* naar de stack en
 ```html
 <div onclick="console.log('first div')">
   <div onclick="console.log('second div')">
-    <button onclick="console.log('button')">
-      Click!
-    </button>
+    <button onclick="console.log('button')">Click!</button>
   </div>
 </div>
 ```
@@ -987,9 +986,7 @@ Het diepst geneste element dat het event afvuurt is de target van het event. Je
 
 ```html
 <div onclick="console.log('div')">
-  <p onclick="console.log('p')">
-    Click here!
-  </p>
+  <p onclick="console.log('p')">Click here!</p>
 </div>
 ```
 
@@ -1224,7 +1221,10 @@ Wat primitieven onderscheidt van objecten is dat primitieven geen properties of
 ###### 40. Wat is de uitkomst?
 
 ```javascript
-[[0, 1], [2, 3]].reduce(
+[
+  [0, 1],
+  [2, 3],
+].reduce(
   (acc, cur) => {
     return acc.concat(cur);
   },
@@ -1349,6 +1349,7 @@ console.log(gen.next().value);
 <p>
 
 #### Antwoord: C
+
 Reguliere functies kunnen niet worden gestopt halverwege na de aanroep. Echter, een generator functie kan wel "gestopt" worden halverwege, en later verder gaan waar ik gestopt is. Elke keer als een generator functie het keyword `yield` aantreft levert de functie de waarde op gespecificeerd achter `yield`. Let op dat een generator functie in dat geval niet de waarde _teruggeeft_, maar de waarde _oplevert_.
 
 Eerst initialiseren we de generator functie met `i`, dat gelijk is aan `10`. We roepen de generator functie aan met de `next()` methode. De eerste keer dat we de generator functie aanroepen is `i` gelijk aan `10`. De eerste `yield` wordt aangetroffen: het levert de waarde op van `i`. De generator is nu "gepauzeerd" en `10` wordt gelogd.
@@ -1371,7 +1372,7 @@ const secondPromise = new Promise((res, rej) => {
   setTimeout(res, 100, "two");
 });
 
-Promise.race([firstPromise, secondPromise]).then(res => console.log(res));
+Promise.race([firstPromise, secondPromise]).then((res) => console.log(res));
 ```
 
 - A: `"one"`
@@ -1435,7 +1436,7 @@ We passaen alleen de waarde aan van de `person` variabele en niet van het eerste
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21
+  age: 21,
 };
 
 for (const item in person) {
@@ -1515,7 +1516,7 @@ Alleen het eerste getal in de string wordt geretourneerd. Gebaseerd op de _radix
 ###### 50. Wat is de uitkomst?
 
 ```javascript
-[1, 2, 3].map(num => {
+[1, 2, 3].map((num) => {
   if (typeof num === "number") return;
   return num * 2;
 });
@@ -1565,6 +1566,7 @@ console.log(person, birthYear);
 <p>
 
 #### Antwoord: A
+
 Argumenten worden meegegeven _by value_, tenzij de waarde een object is. Dan worden ze meegegeven _by reference_. `birthYear` is een string en geen object, waardoor het dus doorgegeven wordt _by value_. Wanneer we een argument meegeven _by value_ wordt er een _copy_ aangemaakt van het argument (zie vraag 46).
 
 De variabele `birthYear` heeft een referentie naar de waarde `"1997"`. Het argument `year` heeft ook een referentie naar de waarde '"1997"', maar het is niet dezelfde waarde als waar `birthYear` een referentie naar heeft. Wanneer we de waarde van `year` veranderen naar `"1998"`, veranderen we alleen de waarde van `year`. `birthYear` is nog steeds gelijk aan `"1997"`.
@@ -1691,7 +1693,7 @@ class Dog {
   }
 }
 
-Dog.prototype.bark = function() {
+Dog.prototype.bark = function () {
   console.log(`Woof I am ${this.name}`);
 };
 
@@ -1714,7 +1716,7 @@ pet.bark();
 
 #### Antwoord: A
 
-We kunnen properties verwijderen van een object als we gebruik maken van het `delete` keyword, en ook op het prototype. Bij het verwijderen van een propertie op de prototype zal het niet meer beschikbaar zijn in de prototype chain. In dit geval is de `bark()` methode niet meer beschikbaar op de protoype na `delete Dog.prototype.bark`. 
+We kunnen properties verwijderen van een object als we gebruik maken van het `delete` keyword, en ook op het prototype. Bij het verwijderen van een propertie op de prototype zal het niet meer beschikbaar zijn in de prototype chain. In dit geval is de `bark()` methode niet meer beschikbaar op de protoype na `delete Dog.prototype.bark`.
 
 Wanneer we iets proberen aan te roepen dat geen functie is zal er een `TypeError` gegooid worden. In dit geval `TypeError: pet.bark is not a function`, omdat `pet.bark` `undefined` is.
 
@@ -1904,7 +1906,7 @@ console.log(Object.keys(person));
 
 #### Antwoord: B
 
-Met de `defineProperty` methode kunnen we properties toevoegen aan een object, of bestaande properties aanpassen. Wanneer we properties toevoegen aan een object door gebruik te maken van `defineProperty` zijn deze standaard _not enumerable_. De `Object.keys` methode geeft alle _enumerable_ propertie namen terug van een object, in dit geval alleen `"name"`. 
+Met de `defineProperty` methode kunnen we properties toevoegen aan een object, of bestaande properties aanpassen. Wanneer we properties toevoegen aan een object door gebruik te maken van `defineProperty` zijn deze standaard _not enumerable_. De `Object.keys` methode geeft alle _enumerable_ propertie namen terug van een object, in dit geval alleen `"name"`.
 
 Properties toegevoegd met de `defineProperty` methode zijn standaard onveranderbaar. Je kunt dit gedrag aanpassen door, in het derde argument, de `writable`, `configurable` en `enumerable` opties mee te geven. Op die manier geeft de `defineProperties` je veel controle over de properties die je wilt toevoegen aan een object.
 
@@ -1919,7 +1921,7 @@ Properties toegevoegd met de `defineProperty` methode zijn standaard onveranderb
 const settings = {
   username: "lydiahallie",
   level: 19,
-  health: 90
+  health: 90,
 };
 
 const data = JSON.stringify(settings, ["level", "health"]);
@@ -1953,7 +1955,7 @@ Als de replacer een _functie_ is zal die functie worden aangeroepen over elke pr
 let num = 10;
 
 const increaseNumber = () => num++;
-const increasePassedNumber = number => number++;
+const increasePassedNumber = (number) => number++;
 
 const num1 = increaseNumber();
 const num2 = increasePassedNumber(num1);
@@ -2009,7 +2011,7 @@ multiply(value);
 In ES6 kunnen we parameters initialiseren met een standaard waarde. De waarde van de parameter zal deze standaard waarde behouden zolang er geen andere waarde wordt meegegeven aan de functie, of als de waarde van de parameter `"undefined"` is. In dit geval kopiëren we de properties van het `value` object
 naar een nieuw object gebruikmakend van de spread operator, dus `x` heeft de standaard waarde `{ number: 10 }`.
 
-De standaard waarde wordt geëvalueerd tijdens _call time_ (aanroeptijd)! Elke keer wanneer we de functie aanroepen wordt er een nieuw object aangemaakt. We roepen de `multiply` functie de eerste twee keer aan zonder een waarde mee te geven: `x` heeft de standaard waarde van `{ number: 10 }`. We loggen dan de vermenigvuldigde waarde van dat getal, wat `20` is. 
+De standaard waarde wordt geëvalueerd tijdens _call time_ (aanroeptijd)! Elke keer wanneer we de functie aanroepen wordt er een nieuw object aangemaakt. We roepen de `multiply` functie de eerste twee keer aan zonder een waarde mee te geven: `x` heeft de standaard waarde van `{ number: 10 }`. We loggen dan de vermenigvuldigde waarde van dat getal, wat `20` is.
 
 De derde keer dat we de functie `multiply` aanroepen geven we wel een waarde mee: het object genaamd `value`. De `*=` operator is eigenlijk een verkorting van `x.number = x.number * 2`: we passen de waarde van `x.number` aan en loggen de vermenigvuldigde waarde `20`.
 
@@ -2040,11 +2042,11 @@ Het eerste argument van de `reduce` methode is de _accumulator_, in dit geval `x
 
 In dit voorbeeld geven we geen waarde terug. We loggen enkel the waarden van de accumulator en de huidige waarde.
 
-De waarde van de accumulator is gelijk aan de vorige teruggegeven waarde van de callback functie. Als je niet de optionele `initialValue` meegeeft aan de `reduce` methode, de accumulator is gelijk aan het eerste element tijdens de eerste aanroep. 
+De waarde van de accumulator is gelijk aan de vorige teruggegeven waarde van de callback functie. Als je niet de optionele `initialValue` meegeeft aan de `reduce` methode, de accumulator is gelijk aan het eerste element tijdens de eerste aanroep.
 
 Tijdens de eerste aanroep is de accumulator (`x`) `1` en de huidige waarde (`y`) `2`. We geven niets terug in de callback function, we loggen de accumulator en de huidige waarde: `1` en `2` worden gelogd.
 
-Als je niets teruggeeft in een functie, zal de functie `undefined` teruggeven. Tijdens de volgende aanroep is de accumulator `undefined` en de huidige waarde `3`. `undefined` en `3` worden gelogt. 
+Als je niets teruggeeft in een functie, zal de functie `undefined` teruggeven. Tijdens de volgende aanroep is de accumulator `undefined` en de huidige waarde `3`. `undefined` en `3` worden gelogt.
 
 Tijdens de vierde aanroep geven we wederom niets terug in de callback functie. De accumulator is wederom `undefined`, en de huidige waarde `4`. `undefined` en `4` worden gelogt.
 
@@ -2063,7 +2065,7 @@ class Dog {
 };
 
 class Labrador extends Dog {
-  // 1 
+  // 1
   constructor(name, size) {
     this.size = size;
   }
@@ -2077,7 +2079,7 @@ class Labrador extends Dog {
     super(name);
     this.size = size;
   }
-  // 4 
+  // 4
   constructor(name, size) {
     this.name = name;
     this.size = size;
@@ -2111,12 +2113,12 @@ De `Labrador` class verwacht twee argumenten, `name` omdat het een afgeleide is
 
 ```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;
 ```
 
@@ -2142,9 +2144,9 @@ Dit is een verschil tussen `require()` in CommonJS en `import`! Met `require()`
 ###### 68. Wat is de uitkomst?
 
 ```javascript
-console.log(Number(2) === Number(2))
-console.log(Boolean(false) === Boolean(false))
-console.log(Symbol('foo') === Symbol('foo'))
+console.log(Number(2) === Number(2));
+console.log(Boolean(false) === Boolean(false));
+console.log(Symbol("foo") === Symbol("foo"));
 ```
 
 - A: `true`, `true`, `false`
@@ -2167,22 +2169,22 @@ Elk Symbol is volledig uniek. Het doel van het argument dat meegegeven wordt aan
 ###### 69. Wat is de uitkomst?
 
 ```javascript
-const name = "Lydia Hallie"
-console.log(name.padStart(13))
-console.log(name.padStart(2))
+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"`, 
+- D: `"Lydia Hallie"`, `"Lyd"`,
 
 <details><summary><b>Antwoord</b></summary>
 <p>
 
 #### Antwoord: C
 
-Met de `padStart` methode kunnen we witruimte toevoegen aan het begin van de string. De waarde die meegegeven wordt aan de methode is de _totale_ lengte van de string, samen met de witruimte. De string `"Lydia Hallie"` heeft een lengte van `13`. `name.padStart(13)` plaatst 1 spatie toe aan het begin van de string omdat 12 + 1 = 13. 
+Met de `padStart` methode kunnen we witruimte toevoegen aan het begin van de string. De waarde die meegegeven wordt aan de methode is de _totale_ lengte van de string, samen met de witruimte. De string `"Lydia Hallie"` heeft een lengte van `13`. `name.padStart(13)` plaatst 1 spatie toe aan het begin van de string omdat 12 + 1 = 13.
 
 Als het argument dat we meegeven aan de `padStart` methode kleiner is dan de lengte van de string zullen er geen spaties worden toegevoegd.
 
@@ -2443,7 +2445,7 @@ De `sum` functie geeft altijd dezelfde waarde terug. Als we `1` en `2` meegeven
 ```javascript
 const add = () => {
   const cache = {};
-  return num => {
+  return (num) => {
     if (num in cache) {
       return `From cache! ${cache[num]}`;
     } else {
@@ -2488,21 +2490,21 @@ De derde keer geven we `5 * 2` mee aan de functie wat `10` oplevert. Het `cache`
 ###### 79. Wat is de uitkomst?
 
 ```javascript
-const myLifeSummedUp = ["☕", "💻", "🍷", "🍫"]
+const myLifeSummedUp = ["☕", "💻", "🍷", "🍫"];
 
 for (let item in myLifeSummedUp) {
-  console.log(item)
+  console.log(item);
 }
 
 for (let item of myLifeSummedUp) {
-  console.log(item)
+  console.log(item);
 }
 ```
 
 - A: `0` `1` `2` `3` en `"☕"` ` "💻"` `"🍷"` `"🍫"`
 - B: `"☕"` ` "💻"` `"🍷"` `"🍫"` en `"☕"` ` "💻"` `"🍷"` `"🍫"`
 - C: `"☕"` ` "💻"` `"🍷"` `"🍫"` en `0` `1` `2` `3`
-- D:  `0` `1` `2` `3` en `{0: "☕", 1: "💻", 2: "🍷", 3: "🍫"}`
+- D: `0` `1` `2` `3` en `{0: "☕", 1: "💻", 2: "🍷", 3: "🍫"}`
 
 <details><summary><b>Antwoord</b></summary>
 <p>
@@ -2525,21 +2527,21 @@ Met de _for-of_ loop kunnen we itereren over **iterables**. Een array is een ite
 ###### 80. Wat is de uitkomst?
 
 ```javascript
-const list = [1 + 2, 1 * 2, 1 / 2]
-console.log(list)
+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]`
+- D: `[1, 1, 1]`
 
 <details><summary><b>Antwoord</b></summary>
 <p>
 
 #### Antwoord: C
 
-Array elementen kunnen elke waarde bevatten. Nummers, strings, objecten, andere arrays, null, boolean waarden, undefined en andere expressies zoals datums, functies en berekeningen. 
+Array elementen kunnen elke waarde bevatten. Nummers, strings, objecten, andere arrays, null, boolean waarden, undefined en andere expressies zoals datums, functies en berekeningen.
 
 Het element zal gelijk zijn aan de teruggegeven waarde. `1 + 2` geeft `3` terug, `1 * 2` geeft `2` terug en `1 / 2` geeft `0.5` terug.
 
@@ -2552,16 +2554,16 @@ Het element zal gelijk zijn aan de teruggegeven waarde. `1 + 2` geeft `3` terug,
 
 ```javascript
 function sayHi(name) {
-  return `Hi there, ${name}`
+  return `Hi there, ${name}`;
 }
 
-console.log(sayHi())
+console.log(sayHi());
 ```
 
 - A: `Hi there, `
 - B: `Hi there, undefined`
 - C: `Hi there, null`
-- D:  `ReferenceError`
+- D: `ReferenceError`
 
 <details><summary><b>Antwoord</b></summary>
 <p>
@@ -2574,7 +2576,7 @@ In ES6 kunnen we argumenten een standaard waarde geven. Als voorbeeld:
 
 `function sayHi(name = "Lydia") { ... }`
 
-In dit geval zal de waarde van het argument `name`, als we geen waarde meegeven aan de functie, standaard `Lydia` bevatten. 
+In dit geval zal de waarde van het argument `name`, als we geen waarde meegeven aan de functie, standaard `Lydia` bevatten.
 
 </p>
 </details>
@@ -2584,21 +2586,21 @@ In dit geval zal de waarde van het argument `name`, als we geen waarde meegeven
 ###### 82. Wat is de uitkomst?
 
 ```javascript
-var status = "😎"
+var status = "😎";
 
 setTimeout(() => {
-  const status = "😍"
+  const status = "😍";
 
   const data = {
     status: "🥑",
     getStatus() {
-      return this.status
-    }
-  }
+      return this.status;
+    },
+  };
 
-  console.log(data.getStatus())
-  console.log(data.getStatus.call(this))
-}, 0)
+  console.log(data.getStatus());
+  console.log(data.getStatus.call(this));
+}, 0);
 ```
 
 - A: `"🥑"` en `"😍"`
@@ -2625,13 +2627,13 @@ Met de `call` methode kunnen we het object veranderen waarnaar het keyword `this
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21
-}
+  age: 21,
+};
 
-let city = person.city
-city = "Amsterdam"
+let city = person.city;
+city = "Amsterdam";
 
-console.log(person)
+console.log(person);
 ```
 
 - A: `{ name: "Lydia", age: 21 }`
@@ -2662,15 +2664,15 @@ Wanneer we het object `person` loggen, wordt het onaangepaste object gelogd.
 ```javascript
 function checkAge(age) {
   if (age < 18) {
-    const message = "Sorry, you're too young."
+    const message = "Sorry, you're too young.";
   } else {
-    const message = "Yay! You're old enough!"
+    const message = "Yay! You're old enough!";
   }
 
-  return message
+  return message;
 }
 
-console.log(checkAge(21))
+console.log(checkAge(21));
 ```
 
 - A: `"Sorry, you're too young."`
@@ -2693,9 +2695,9 @@ Variabelen gedeclareerd met de keywords `const` en `let` zijn _block-scoped_. Ee
 ###### 85. Welke informatie zal worden gelogd?
 
 ```javascript
-fetch('https://www.website.com/api/user/1')
-  .then(res => res.json())
-  .then(res => console.log(res))
+fetch("https://www.website.com/api/user/1")
+  .then((res) => res.json())
+  .then((res) => console.log(res));
 ```
 
 - A: Het resultaat van de `fetch` methode.
@@ -2735,7 +2737,7 @@ function getName(name) {
 
 Met `!!name` stellen we vast of de waarde van `name` truthy of falsy is. Als `name` truthy is, dit is wat we willen testen, zal `!name` `false` teruggeven. `!false` (wat `!!name` feitelijk is) geeft `true` terug.
 
-Wanneer we `hasName` vullen met `name`, vullen we het met dat wat we meegeven aan de `getName` functie, niet de boolean waarde `true`. 
+Wanneer we `hasName` vullen met `name`, vullen we het met dat wat we meegeven aan de `getName` functie, niet de boolean waarde `true`.
 
 `new Boolean(true)` geeft een object wrapper terug, niet de boolean waarde zelf.
 
@@ -2749,7 +2751,7 @@ Wanneer we `hasName` vullen met `name`, vullen we het met dat wat we meegeven aa
 ###### 87. Wat is de uitkomst?
 
 ```javascript
-console.log("I want pizza"[0])
+console.log("I want pizza"[0]);
 ```
 
 - A: `"""`
@@ -2775,10 +2777,10 @@ Let op dat deze methode niet ondersteund wordt in IE7 en daaronder. In dat geval
 
 ```javascript
 function sum(num1, num2 = num1) {
-  console.log(num1 + num2)
+  console.log(num1 + num2);
 }
 
-sum(10)
+sum(10);
 ```
 
 - A: `NaN`
@@ -2793,7 +2795,7 @@ sum(10)
 
 Je kunt een parameters standaard waarde gelijk zetten aan een andere parameter van diezelfde functie, zolang deze definieerd is _voor_ de parameter met een standaard waarde. We geen de waarde `10` mee aan de `sum` functie. Als de `sum` functie maar één argument meekrijgt betekent dit dat de waarde van `num2` gevuld wordt met de waarde van `num1`. `10` in dit geval. De standaard waarde van `num2` is de waarde van `num1`, wat `10` is. `num1 + num2` geeft `20` terug.
 
-Als je probeert de standaard waarde van een parameter te vullen met de waarde van een parameter welke gedefinieerd is _na_ de standaard parameter, dan is de parameter nog niet geïnitialiseerd  en wordt er een error gegooid.
+Als je probeert de standaard waarde van een parameter te vullen met de waarde van een parameter welke gedefinieerd is _na_ de standaard parameter, dan is de parameter nog niet geïnitialiseerd en wordt er een error gegooid.
 
 </p>
 </details>
@@ -2803,14 +2805,14 @@ Als je probeert de standaard waarde van een parameter te vullen met de waarde va
 ###### 89. Wat is de uitkomst?
 
 ```javascript
-// module.js 
-export default () => "Hello world"
-export const name = "Lydia"
+// module.js
+export default () => "Hello world";
+export const name = "Lydia";
 
-// index.js 
-import * as data from "./module"
+// index.js
+import * as data from "./module";
 
-console.log(data)
+console.log(data);
 ```
 
 - A: `{ default: function default(), name: "Lydia" }`
@@ -2822,6 +2824,7 @@ console.log(data)
 <p>
 
 #### Antwoord: A
+
 Met de `import * as name` syntax importeren we _alle exports_ van `module.js` bestand in het bestand `index.js` als een nieuw object met de naam `data`. In het bestand `module.js` zijn er twee exports: de standaard export en de benoemde export. De standaard export is een functie dat de string `"Hello world"` teruggeeft, en de benoemde export is de variabele `name` wat de waarde van de string `"Lydia"` bevat.
 
 Het object `data` bevat een propertie `default` voor de standaard export. Andere properties hebben de naam van de benoemde exports en hun corresponderende waarden.
@@ -2836,12 +2839,12 @@ Het object `data` bevat een propertie `default` voor de standaard export. Andere
 ```javascript
 class Person {
   constructor(name) {
-    this.name = name
+    this.name = name;
   }
 }
 
-const member = new Person("John")
-console.log(typeof member)
+const member = new Person("John");
+console.log(typeof member);
 ```
 
 - A: `"class"`
@@ -2858,7 +2861,7 @@ Classes zijn een syntactisch sausje voor functie constructors. Het equivalent va
 
 ```javascript
 function Person() {
-  this.name = name
+  this.name = name;
 }
 ```
 
@@ -2872,9 +2875,9 @@ Het aanroepen van de functie contructor met `new` resulteert in het creëeren va
 ###### 91. Wat is de uitkomst?
 
 ```javascript
-let newList = [1, 2, 3].push(4)
+let newList = [1, 2, 3].push(4);
 
-console.log(newList.push(5))
+console.log(newList.push(5));
 ```
 
 - A: `[1, 2, 3, 4, 5]`
@@ -2900,17 +2903,18 @@ Dan gebruiken we de `.push` methode op `newList`. Omdat `newList` nu de numeriek
 
 ```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)
+console.log(giveLydiaPizza.prototype);
+console.log(giveLydiaChocolate.prototype);
 ```
 
-- A: `{ constructor: ...}` `{ constructor: ...}` 
-- B: `{}` `{ constructor: ...}` 
+- A: `{ constructor: ...}` `{ constructor: ...}`
+- B: `{}` `{ constructor: ...}`
 - C: `{ constructor: ...}` `{}`
 - D: `{ constructor: ...}` `undefined`
 
@@ -2931,16 +2935,16 @@ Reguliere functies zoals de `giveLydiaPizza` functie hebben een `prototype` prop
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21
-}
+  age: 21,
+};
 
 for (const [x, y] of Object.entries(person)) {
-  console.log(x, y)
+  console.log(x, y);
 }
 ```
 
 - A: `name` `Lydia` en `age` `21`
-- B: `["name", "Lydia"]` en `["age", 21]` 
+- B: `["name", "Lydia"]` en `["age", 21]`
 - C: `["name", "age"]` en `undefined`
 - D: `Error`
 
@@ -2951,11 +2955,11 @@ for (const [x, y] of Object.entries(person)) {
 
 `Object.entries(person)` retourneert een array van geneste arrays, welke de keys en objecten bevat:
 
-`[ [ 'name', 'Lydia' ], [ 'age', 21 ] ]` 
+`[ [ 'name', 'Lydia' ], [ 'age', 21 ] ]`
 
 Gebruikmakend van de `for-of` loop kunnen we itereren over elk element in de array, de subarrays in dit geval. We kunnen de subarrays direct destructureren door `const [x, y]` te gebruiken. `x` is gelijk aan het eerste element in de subarray, `y` is gelijk aan het tweede element in de subarray.
 
-De eerste subarray wat wordt gelogd is `[ "name", "Lydia" ]`, waarbij `x` gelijk is aan `"name"` en `y` gelijk is aan `"Lydia"`. 
+De eerste subarray wat wordt gelogd is `[ "name", "Lydia" ]`, waarbij `x` gelijk is aan `"name"` en `y` gelijk is aan `"Lydia"`.
 De tweede subarray wat wordt gelogd is `[ "age", "21" ]`, waarbij `x` gelijk is aan `"age"` en `y` gelijk is aan `"21"`.
 
 </p>
@@ -2974,7 +2978,7 @@ getItems(["banana", "apple"], "pear", "orange")
 ```
 
 - A: `["banana", "apple", "pear", "orange"]`
-- B: `[["banana", "apple"], "pear", "orange"]` 
+- B: `[["banana", "apple"], "pear", "orange"]`
 - C: `["banana", "apple", ["pear"], "orange"]`
 - D: `SyntaxError`
 
@@ -2987,10 +2991,10 @@ getItems(["banana", "apple"], "pear", "orange")
 
 ```javascript
 function getItems(fruitList, favoriteFruit, ...args) {
-  return [...fruitList, ...args, favoriteFruit]
+  return [...fruitList, ...args, favoriteFruit];
 }
 
-getItems(["banana", "apple"], "pear", "orange")
+getItems(["banana", "apple"], "pear", "orange");
 ```
 
 Het bovenstaande voorbeeld werkt. Dit geeft de array `[ 'banana', 'apple', 'orange', 'pear' ]` terug.
@@ -3004,17 +3008,14 @@ Het bovenstaande voorbeeld werkt. Dit geeft de array `[ 'banana', 'apple', 'oran
 
 ```javascript
 function nums(a, b) {
-  if
-  (a > b)
-  console.log('a is bigger')
-  else 
-  console.log('b is bigger')
-  return 
-  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))
+console.log(nums(4, 2));
+console.log(nums(1, 2));
 ```
 
 - A: `a is bigger`, `6` en `b is bigger`, `3`
@@ -3032,8 +3033,8 @@ In JavaScript _hoeven_ we geen puntkomma's te schrijven, alhoewel de JavaScript
 Hier schreven we een `return` statement en op de _nieuwe regel_ `a + b`. Maar omdat het een nieuwe regel betreft weet de engine niet wat we eigenlijk wilde retourneren. In plaats daarvan wordt er na `return` automatisch een puntkomma toegevoegd. Je kunt dit zien als:
 
 ```javascript
-  return;
-  a + b
+return;
+a + b;
 ```
 
 Dat betekent dat `a + b` nooit bereikt zal worden, omdat de functie stopt na het keyword `return`. Als er geen waarde wordt geretourneerd, zoals nu, zal de functie `undefined` teruggeven. Let op dat er geen automatisch insertion plaatsvindt na `if/else` statements!
@@ -3048,18 +3049,18 @@ Dat betekent dat `a + b` nooit bereikt zal worden, omdat de functie stopt na het
 ```javascript
 class Person {
   constructor() {
-    this.name = "Lydia"
+    this.name = "Lydia";
   }
 }
 
 Person = class AnotherPerson {
   constructor() {
-    this.name = "Sarah"
+    this.name = "Sarah";
   }
-}
+};
 
-const member = new Person()
-console.log(member.name)
+const member = new Person();
+console.log(member.name);
 ```
 
 - A: `"Lydia"`
@@ -3083,11 +3084,11 @@ We kunnen classes gelijk zetten tot andere classes/functie constructors. In dit
 
 ```javascript
 const info = {
-  [Symbol('a')]: 'b'
-}
+  [Symbol("a")]: "b",
+};
 
-console.log(info)
-console.log(Object.keys(info))
+console.log(info);
+console.log(Object.keys(info));
 ```
 
 - A: `{Symbol('a'): 'b'}` en `["{Symbol('a')"]`
@@ -3134,13 +3135,13 @@ console.log(getUser(user))
 
 De `getList` functie ontvangt een array als argument. Tussen de haakjes van de `getList` functie destructureren we deze array direct. Je kunt het zien als:
 
- `[x, ...y] = [1, 2, 3, 4]`
+`[x, ...y] = [1, 2, 3, 4]`
 
 Met de rest parameter `...y` stoppen we alle "overgebleven" argumenten in een array. De overgebleven argumenten zijn in dit geval `2`, `3` en `4`. De waarde van `y` is een array die alle rest parameters bevat. De waarde van `x` is gelijk aan `1` in dit geval, dus wanneer we `[x, y]` loggen wordt `[1, [2, 3, 4]]` gelogd.
- 
+
 De `getUser` functie ontvangt een object. Met arrow functies _hoeven_ we geen accolades te gebruiken als we maar één waarde willen retourneren. Echter, als je een _object_ wilt retourneren in een arraow functie zal je het tussen haakjes moeten schrijven. Anders zal er geen waarde geretourneerd worden! De volgende functie zal wel een object geretourneerd hebben:
 
-```const getUser = user => ({ name: user.name, age: user.age })```
+`const getUser = user => ({ name: user.name, age: user.age })`
 
 Omdat er geen waarde geretourneerd wordt in dit geval zal de functie `undefined` retourneren.
 
@@ -3152,9 +3153,9 @@ Omdat er geen waarde geretourneerd wordt in dit geval zal de functie `undefined`
 ###### 99. Wat is de uitkomst?
 
 ```javascript
-const name = "Lydia"
+const name = "Lydia";
 
-console.log(name())
+console.log(name());
 ```
 
 - A: `SyntaxError`
@@ -3184,8 +3185,8 @@ ReferenceErrors worden gegooid wanneer JavaScript niet in staat is een referenti
 ```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`
@@ -3210,11 +3211,11 @@ You should${'' && `n't`} see a therapist after so much JavaScript lol`
 ###### 101. Wat is de waarde van output?
 
 ```javascript
-const one = (false || {} || null)
-const two = (null || false || "")
-const three = ([] || 0 || true)
+const one = false || {} || null;
+const two = null || false || "";
+const three = [] || 0 || true;
 
-console.log(one, two, three)
+console.log(one, two, three);
 ```
 
 - A: `false` `null` `[]`
@@ -3243,20 +3244,20 @@ Met de `||` (or) operator kunnen we de eerste truthy waarde retourneren. Als all
 ###### 102. Wat is de waarde van 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')
+  myPromise().then((res) => console.log(res));
+  console.log("second");
 }
 
 async function secondFunction() {
-  console.log(await myPromise())
-  console.log('second')
+  console.log(await myPromise());
+  console.log("second");
 }
 
-firstFunction()
-secondFunction()
+firstFunction();
+secondFunction();
 ```
 
 - A: `I have resolved!`, `second` en `I have resolved!`, `second`
@@ -3287,14 +3288,14 @@ Dit betekent dat het wacht tot de `myPromise` is opgelost met de waarde `I have
 ###### 103. Wat is de waarde van output?
 
 ```javascript
-const set = new Set()
+const set = new Set();
 
-set.add(1)
-set.add("Lydia")
-set.add({ name: "Lydia" })
+set.add(1);
+set.add("Lydia");
+set.add({ name: "Lydia" });
 
 for (let item of set) {
-  console.log(item + 2)
+  console.log(item + 2);
 }
 ```
 
@@ -3324,7 +3325,7 @@ Echter, de tweede is de string `"Lydia"`. `"Lydia"` is een string en `2` is een
 ###### 104. Wat is de waarde?
 
 ```javascript
-Promise.resolve(5)
+Promise.resolve(5);
 ```
 
 - A: `5`
@@ -3351,15 +3352,15 @@ In dit geval geven we alleen de numerieke waarde `5` mee. Het geeft de opgeloste
 ```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)
+compareMembers(person);
 ```
 
 - A: `Not the same!`
@@ -3394,11 +3395,11 @@ const colorConfig = {
   green: true,
   black: true,
   yellow: false,
-}
+};
 
-const colors = ["pink", "red", "blue"]
+const colors = ["pink", "red", "blue"];
 
-console.log(colorConfig.colors[1])
+console.log(colorConfig.colors[1]);
 ```
 
 - A: `true`
@@ -3425,7 +3426,7 @@ JavaScript interpreteert (of beter gezegd unboxed) statements. Wanneer we blokha
 ###### 107. Wat is de waarde?
 
 ```javascript
-console.log('❤️' === '❤️')
+console.log("❤️" === "❤️");
 ```
 
 - A: `true`
@@ -3446,19 +3447,19 @@ Onder de motorkap zijn emojis unicodes. De unicodes voor het hart zijn `"U+2764
 ###### 108. Welke van onderstaande methoden passen de originele array aan?
 
 ```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`
 - B: `map` `reduce` `slice` `splice`
-- C: `map` `slice` `splice` 
+- C: `map` `slice` `splice`
 - D: `splice`
 
 <details><summary><b>Antwoord</b></summary>
@@ -3478,17 +3479,17 @@ Met de `splice` methode passen we de originele array aan door elementen te verwi
 ###### 109. Wat is de uitkomst?
 
 ```javascript
-const food = ['🍕', '🍫', '🥑', '🍔']
-const info = { favoriteFood: food[0] }
+const food = ["🍕", "🍫", "🥑", "🍔"];
+const info = { favoriteFood: food[0] };
 
-info.favoriteFood = '🍝'
+info.favoriteFood = "🍝";
 
-console.log(food)
+console.log(food);
 ```
 
 - A: `['🍕', '🍫', '🥑', '🍔']`
 - B: `['🍝', '🍫', '🥑', '🍔']`
-- C: `['🍝', '🍕', '🍫', '🥑', '🍔']` 
+- C: `['🍝', '🍕', '🍫', '🥑', '🍔']`
 - D: `ReferenceError`
 
 <details><summary><b>Antwoord</b></summary>
@@ -3510,7 +3511,7 @@ Daarna veranderen we de waarde van de property `favoriteFood` op het object `inf
 ###### 110. Wat doet onderstaande methode?
 
 ```javascript
-JSON.parse()
+JSON.parse();
 ```
 
 - A: Ontleedt JSON naar een JavaScript waarde
@@ -3527,16 +3528,16 @@ Met de `JSON.parse()` methode kunnen we een JSON string parsen naar een JavaScri
 
 ```javascript
 // Stringifying een nummer naar valide JSON, daarna de JSON string parsen naar een JavaScript waarde:
-const jsonNumber = JSON.stringify(4) // '4'
-JSON.parse(jsonNumber) // 4
+const jsonNumber = JSON.stringify(4); // '4'
+JSON.parse(jsonNumber); // 4
 
 // Stringifying een array waarde naar een valide JSON, daarna de JSON string parsen naar een JavaScript waarde:
-const jsonArray = JSON.stringify([1, 2, 3]) // '[1, 2, 3]'
-JSON.parse(jsonArray) // [1, 2, 3]
+const jsonArray = JSON.stringify([1, 2, 3]); // '[1, 2, 3]'
+JSON.parse(jsonArray); // [1, 2, 3]
 
 // Stringifying een object naar valide JSON, daarna de JSON string parsen naar een JavaScript waarde:
-const jsonArray = JSON.stringify({ name: "Lydia" }) // '{"name":"Lydia"}'
-JSON.parse(jsonArray) // { name: 'Lydia' }
+const jsonArray = JSON.stringify({ name: "Lydia" }); // '{"name":"Lydia"}'
+JSON.parse(jsonArray); // { name: 'Lydia' }
 ```
 
 </p>
@@ -3544,17 +3545,17 @@ JSON.parse(jsonArray) // { name: 'Lydia' }
 
 ---
 
-###### 111. Wat is de uitkomst? 
+###### 111. Wat is de uitkomst?
 
 ```javascript
-let name = 'Lydia'
+let name = "Lydia";
 
 function getName() {
-  console.log(name)
-  let name = 'Sarah'
+  console.log(name);
+  let name = "Sarah";
 }
 
-getName()
+getName();
 ```
 
 - A: Lydia
@@ -3574,13 +3575,13 @@ Variabelen gedeclareerd met het keyword `let` (en `const`) worden gehoisted, maa
 Als we de variabele `name` **niet** niet hadden gedeclareerd binnen de `getName` functie zou de JavaScript engine doorgezocht hebben door de _scope chain_. De bovenliggende scope heeft een variabele `name` met de waarde `Lydia`. In dat geval zou `Lydia` gelogged worden.
 
 ```javascript
-let name = 'Lydia'
+let name = "Lydia";
 
 function getName() {
-  console.log(name)
+  console.log(name);
 }
 
-getName() // Lydia
+getName(); // Lydia
 ```
 
 </p>
@@ -3592,18 +3593,18 @@ 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()
-const two = generatorTwo()
+const one = generatorOne();
+const two = generatorTwo();
 
-console.log(one.next().value)
-console.log(two.next().value)
+console.log(one.next().value);
+console.log(two.next().value);
 ```
 
 - A: `a` en `a`
@@ -3621,17 +3622,17 @@ Met het keyword `yield` , we `yield` waarden in een generator functie. Met het k
 In `generatorOne` leveren we de volledige array `['a', 'b', 'c']` op, gebruikmakend van het keyword `yield`. De waarde van de propertie `value` op het object geretourneerd door de `next` methode op `one` (`one.next().value`) is gelijk aan de volledige array `['a', 'b', 'c']`.
 
 ```javascript
-console.log(one.next().value) // ['a', 'b', 'c']
-console.log(one.next().value) // undefined
+console.log(one.next().value); // ['a', 'b', 'c']
+console.log(one.next().value); // undefined
 ```
 
 In `generatorTwo` gebruiken we het keyword `yield*`. Dit betekent dat de eerste opgeleverde waarde van `two` is gelijk aan de eerste opgeleverde waarde in de iterator. The iterator is de array `['a', 'b', 'c']`. De eerste opgeleverde waarde is `a`, dus de eerste keer dat we `two.next().value` aanroepen wordt `a` geretourneerd.
 
 ```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
+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>
@@ -3642,7 +3643,7 @@ console.log(two.next().value) // undefined
 ###### 113. Wat is de uitkomst?
 
 ```javascript
-console.log(`${(x => x)('I love')} to program`)
+console.log(`${((x) => x)("I love")} to program`);
 ```
 
 - A: `I love to program`
@@ -3667,11 +3668,11 @@ Expressies binnen template literals worden eerste geëvalueerd. Dit betekent dat
 ```javascript
 let config = {
   alert: setInterval(() => {
-    console.log('Alert!')
-  }, 1000)
-}
+    console.log("Alert!");
+  }, 1000),
+};
 
-config = null
+config = null;
 ```
 
 - A: De `setInterval` callback zal niet worden aangeroepen
@@ -3694,17 +3695,17 @@ Normaal als we objecten gelijk maken aan `null` worden deze objecten opgeruimd d
 ###### 115. Welke methode(n) zal de waarde `'Hello world!'` teruggeven?
 
 ```javascript
-const myMap = new Map()
-const myFunc = () => 'greeting'
+const myMap = new Map();
+const myFunc = () => "greeting";
 
-myMap.set(myFunc, 'Hello world!')
+myMap.set(myFunc, "Hello world!");
 
 //1
-myMap.get('greeting')
+myMap.get("greeting");
 //2
-myMap.get(myFunc)
+myMap.get(myFunc);
 //3
-myMap.get(() => 'greeting')
+myMap.get(() => "greeting");
 ```
 
 - A: 1
@@ -3732,19 +3733,19 @@ Als een **key/value** paar wordt toegevoegd gebruikmakend van de `set` methode z
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21
-}
+  age: 21,
+};
 
-const changeAge = (x = { ...person }) => x.age += 1
+const changeAge = (x = { ...person }) => (x.age += 1);
 const changeAgeAndName = (x = { ...person }) => {
-  x.age += 1
-  x.name = "Sarah"
-}
+  x.age += 1;
+  x.name = "Sarah";
+};
 
-changeAge(person)
-changeAgeAndName()
+changeAge(person);
+changeAgeAndName();
 
-console.log(person)
+console.log(person);
 ```
 
 - A: `{name: "Sarah", age: 22}`
@@ -3772,7 +3773,7 @@ Dan roepen we de functie `changeAgeAndName` aan, echter geven we geen parameter
 
 ```javascript
 function sumValues(x, y, z) {
-	return x + y + z;
+  return x + y + z;
 }
 ```
 
@@ -3823,15 +3824,15 @@ Met de `+=` operator verhogen we de waarde van `num` met `1`. `num` heeft een in
 
 ```javascript
 const person = {
-	firstName: "Lydia",
-	lastName: "Hallie",
-	pet: {
-		name: "Mara",
-		breed: "Dutch Tulip Hound"
-	},
-	getFullName() {
-		return `${this.firstName} ${this.lastName}`;
-	}
+  firstName: "Lydia",
+  lastName: "Hallie",
+  pet: {
+    name: "Mara",
+    breed: "Dutch Tulip Hound",
+  },
+  getFullName() {
+    return `${this.firstName} ${this.lastName}`;
+  },
 };
 
 console.log(person.pet?.name);
@@ -3854,7 +3855,7 @@ Met de _optional chaining operator_ `?.` hoeven we niet langer expliciet te chec
 
 `person.pet?.name`: `person` heeft een propertie genaamd `pet`: `person.pet` is niet _nullish_. Het heeft een propertie genaamd ``name` en retourneerd `Mara`.
 `person.pet?.family?.name`: `person` heeft een propertie genaamd `pet`: `person.pet` is niet _nullish_. `pet` heeft _geen_ propertie genaamd `family`, `person.pet.family` is _nullish_. De expressie geeft `undefined` terug.
-`person.getFullName?.()`: `person` heeft een propertie genaamd `getFullName`: `person.getFullName()` is niet __nullish__ en kan worden aangeroepen, wat `Lydia Hallie` retourneerd.
+`person.getFullName?.()`: `person` heeft een propertie genaamd `getFullName`: `person.getFullName()` is niet **nullish** en kan worden aangeroepen, wat `Lydia Hallie` retourneerd.
 `member.getLastName?.()`: `member` is niet gedefinieerd: `member.getLastName()` is _nullish_. The expressie geeft `undefined` terug.
 
 </p>
@@ -3868,9 +3869,9 @@ Met de _optional chaining operator_ `?.` hoeven we niet langer expliciet te chec
 const groceries = ["banana", "apple", "peanuts"];
 
 if (groceries.indexOf("banana")) {
-	console.log("We have to buy bananas!");
+  console.log("We have to buy bananas!");
 } else {
-	console.log(`We don't have to buy bananas!`);
+  console.log(`We don't have to buy bananas!`);
 }
 ```
 
@@ -3895,10 +3896,10 @@ We geven de conditie `groceries.indexOf("banana")` mee aan de if-statement. `gro
 
 ```javascript
 const config = {
-	languages: [],
-	set language(lang) {
-		return this.languages.push(lang);
-	}
+  languages: [],
+  set language(lang) {
+    return this.languages.push(lang);
+  },
 };
 
 console.log(config.language);
@@ -3952,9 +3953,9 @@ console.log(!typeof name === "string");
 ###### 123. Wat is de uitkomst?
 
 ```javascript
-const add = x => y => z => {
-	console.log(x, y, z);
-	return x + y + z;
+const add = (x) => (y) => (z) => {
+  console.log(x, y, z);
+  return x + y + z;
 };
 
 add(4)(5)(6);
@@ -3981,16 +3982,16 @@ De `add` functie retourneert een arrow functie, die een arrow functie retourneer
 
 ```javascript
 async function* range(start, end) {
-	for (let i = start; i <= end; i++) {
-		yield Promise.resolve(i);
-	}
+  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);
-	}
+  const gen = range(1, 3);
+  for await (const item of gen) {
+    console.log(item);
+  }
 })();
 ```
 
@@ -4015,7 +4016,7 @@ De generator functie `range` retourneert een async object met promises voor elk
 
 ```javascript
 const myFunc = ({ x, y, z }) => {
-	console.log(x, y, z);
+  console.log(x, y, z);
 };
 
 myFunc(1, 2, 3);
@@ -4139,8 +4140,8 @@ Met de `isNaN` methode kun je checken of een waarde die je meegeeft geen numerie
 const randomValue = 21;
 
 function getInfo() {
-	console.log(typeof randomValue);
-	const randomValue = "Lydia Hallie";
+  console.log(typeof randomValue);
+  const randomValue = "Lydia Hallie";
 }
 
 getInfo();
@@ -4169,13 +4170,13 @@ Variables declared with the `const` keyword are not referencable before their in
 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!");
-	}
+  try {
+    console.log(await myPromise);
+  } catch {
+    throw new Error(`Oops didn't work`);
+  } finally {
+    console.log("Oh finally!");
+  }
 })();
 ```
 
@@ -4225,13 +4226,13 @@ Met de `flat` methode kunnen we een nieuwe platgemaakte array maken. De diepte v
 
 ```javascript
 class Counter {
-	constructor() {
-		this.count = 0;
-	}
+  constructor() {
+    this.count = 0;
+  }
 
-	increment() {
-		this.count++;
-	}
+  increment() {
+    this.count++;
+  }
 }
 
 const counterOne = new Counter();
@@ -4275,16 +4276,16 @@ We roepen `counterTwo.increment()` aan, wat `count` gelijk maakt aan `3`. Als we
 const myPromise = Promise.resolve(Promise.resolve("Promise!"));
 
 function funcOne() {
-	myPromise.then(res => res).then(res => console.log(res));
-	setTimeout(() => console.log("Timeout!", 0));
-	console.log("Last line!");
+  myPromise.then((res) => res).then((res) => console.log(res));
+  setTimeout(() => console.log("Timeout!", 0));
+  console.log("Last line!");
 }
 
 async function funcTwo() {
-	const res = await myPromise;
-	console.log(await res);
-	setTimeout(() => console.log("Timeout!", 0));
-	console.log("Last line!");
+  const res = await myPromise;
+  console.log(await res);
+  setTimeout(() => console.log("Timeout!", 0));
+  console.log("Last line!");
 }
 
 funcOne();
@@ -4301,7 +4302,7 @@ funcTwo();
 
 #### Antwoord: D
 
-Eerst roepen we `funcOne` aan. Op de eerste regel van `funcOne` roepen we de promise `myPromise` aan, wat een _asynchrone_ operatie is. Zolang de JavaScript engine bezig is met het afmaken van de promise wordt de rest van de functie `funcOne` uitgevoerd. De volgende regel is een _asynchrone_ `setTimeout` functie, waarvan de callback functie naar de Web API wordt gestuurd. 
+Eerst roepen we `funcOne` aan. Op de eerste regel van `funcOne` roepen we de promise `myPromise` aan, wat een _asynchrone_ operatie is. Zolang de JavaScript engine bezig is met het afmaken van de promise wordt de rest van de functie `funcOne` uitgevoerd. De volgende regel is een _asynchrone_ `setTimeout` functie, waarvan de callback functie naar de Web API wordt gestuurd.
 
 Zowel de promise als de timeout zijn _asynchrone_ operaties en de functie worden uitgevoerd terwijl de engine bezig is om de promise uit te voeren en de `setTimeout` callback functie af te handelen. Dit betekent dat `Last line!` als eerste wordt gelogd, omdat dit geen _asynchrone_ operatie is. Dit is de laatste regel van `funcOne`. Ondertussen wordt de promise opgelost en `Promise!` wordt gelogd. Echter, omdat we `funcTwo()` aanroepen en de callstack nog niet leeg is kan de callback van de `setTimeout` functie nog niet toegevoegd worden aan de callstack.
 
@@ -4316,12 +4317,12 @@ We komen op de laatste regel van `funcTwo` wat `Last line!` logt naar het consol
 
 ---
 
-###### 134. Hoe kunnen we `sum` uit `sum.js` aanroepen  in `index.js`?`
+###### 134. Hoe kunnen we `sum` uit `sum.js` aanroepen in `index.js`?`
 
 ```javascript
 // sum.js
 export default function sum(x) {
-	return x + x;
+  return x + x;
 }
 
 // index.js
@@ -4378,8 +4379,8 @@ We kunnen deze functie aanvoeren door `sum.default` aan te roepen.
 
 ```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);
@@ -4429,7 +4430,7 @@ Object.seal(person);
 
 #### Antwoord: A
 
-Met `Object.seal`  kunnen we voorkomen dat nieuwe properties kunnen worden _toegevoegd_ of bestaande properties worden _verwijderd_.
+Met `Object.seal` kunnen we voorkomen dat nieuwe properties kunnen worden _toegevoegd_ of bestaande properties worden _verwijderd_.
 
 Echter kunnen van de bestaande properties nog steeds aanpassen.
 
@@ -4442,10 +4443,10 @@ Echter kunnen van de bestaande properties nog steeds aanpassen.
 
 ```javascript
 const person = {
-	name: "Lydia Hallie",
-	address: {
-		street: "100 Main St"
-	}
+  name: "Lydia Hallie",
+  address: {
+    street: "100 Main St",
+  },
 };
 
 Object.freeze(person);
@@ -4473,10 +4474,10 @@ Echter wordt het object enkel _oppervlakkig_ bevroren wat betekent dat alleen _d
 ###### 138. Wat is de uitkomst?
 
 ```javascript
-const add = x => x + x;
+const add = (x) => x + x;
 
 function myFunc(num = 2, value = add(num)) {
-	console.log(num, value);
+  console.log(num, value);
 }
 
 myFunc();
@@ -4506,21 +4507,21 @@ Daarna roepen we de functie `myFunc(3)` aan het geven `3` meet als de waarde voo
 
 ```javascript
 class Counter {
-  #number = 10
+  #number = 10;
 
   increment() {
-    this.#number++
+    this.#number++;
   }
 
   getNum() {
-    return this.#number
+    return this.#number;
   }
 }
 
-const counter = new Counter()
-counter.increment()
+const counter = new Counter();
+counter.increment();
 
-console.log(counter.#number)
+console.log(counter.#number);
 ```
 
 - A: `10`
@@ -4544,20 +4545,20 @@ In ES2020 kunnen we private variabelen toevoegen aan classes door gebruik te mak
 
 ```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) {
-	for (let i = 0; i < members.length; i++) {
-		yield members[i];
-	}
+  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 ✨
-	}
+  for (let i = 0; i < teams.length; i++) {
+    // ✨ SOMETHING IS MISSING HERE ✨
+  }
 }
 
 const obj = getTeams(teams);
@@ -4588,13 +4589,13 @@ Als we `yield`, `return yield`, of `return` hadden geschreven zou de gehele gene
 
 ```javascript
 const person = {
-	name: "Lydia Hallie",
-	hobbies: ["coding"]
+  name: "Lydia Hallie",
+  hobbies: ["coding"],
 };
 
 function addHobby(hobby, hobbies = person.hobbies) {
-	hobbies.push(hobby);
-	return hobbies;
+  hobbies.push(hobby);
+  return hobbies;
 }
 
 addHobby("running", []);
@@ -4633,16 +4634,16 @@ Na het pushen van `dancing` en `baking` is de waarde van `person.hobbies` gelijk
 
 ```javascript
 class Bird {
-	constructor() {
-		console.log("I'm a bird. 🦢");
-	}
+  constructor() {
+    console.log("I'm a bird. 🦢");
+  }
 }
 
 class Flamingo extends Bird {
-	constructor() {
-		console.log("I'm pink. 🌸");
-		super();
-	}
+  constructor() {
+    console.log("I'm pink. 🌸");
+    super();
+  }
 }
 
 const pet = new Flamingo();
diff --git a/pl-PL/README.md b/pl-PL/README.md
index 866f4458..ca8e1a3b 100644
--- a/pl-PL/README.md
+++ b/pl-PL/README.md
@@ -10,10 +10,11 @@ Od podstawowych do zaawansowanych: sprawdź, jak dobrze znasz JavaScript, odświ
 
 Nie krępuj się ze mną kontaktować! 😊 <br />
 <a href="https://www.instagram.com/theavocoder">Instagram</a> || <a href="https://www.twitter.com/lydiahallie">Twitter</a> || <a href="https://www.linkedin.com/in/lydia-hallie">LinkedIn</a> || <a href="https://www.lydiahallie.dev">Blog</a>
+
 </div>
 
-| Śmiało używaj ich w projekcie! 😃  Byłabym _bardzo_ wdzięczna za referencje do tego repozytorium, tworzę pytania i wyjaśnienia (tak, jestem smutna lol) i społeczność bardzo mi pomaga w utrzymaniu i ulepszaniu go! 💪🏼 Dziękuję i baw się dobrze!   |
-|---|
+| Śmiało używaj ich w projekcie! 😃 Byłabym _bardzo_ wdzięczna za referencje do tego repozytorium, tworzę pytania i wyjaśnienia (tak, jestem smutna lol) i społeczność bardzo mi pomaga w utrzymaniu i ulepszaniu go! 💪🏼 Dziękuję i baw się dobrze! |
+| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 
 ---
 
@@ -32,6 +33,7 @@ Nie krępuj się ze mną kontaktować! 😊 <br />
 - [🇰🇷 한국어](./ko-KR/README-ko_KR.md)
 - [🇳🇱 Nederlands](./nl-NL/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)
@@ -52,7 +54,7 @@ Nie krępuj się ze mną kontaktować! 😊 <br />
 function sayHi() {
   console.log(name);
   console.log(age);
-  var name = 'Lydia';
+  var name = "Lydia";
   let age = 21;
 }
 
@@ -148,7 +150,7 @@ Na tym obiekcie nie ma wartości `radius`, co powoduje zwrócenie `NaN` (Not a N
 
 ```javascript
 +true;
-!'Lydia';
+!"Lydia";
 ```
 
 - A: `1` and `false`
@@ -173,11 +175,11 @@ Operator jednoargumentowy plus próbuje przekonwertować operand na liczbę. `tr
 
 ```javascript
 const bird = {
-  size: 'small',
+  size: "small",
 };
 
 const mouse = {
-  name: 'Mickey',
+  name: "Mickey",
   small: true,
 };
 ```
@@ -208,11 +210,11 @@ Jednakże, w przypadku notacji kropkowej, to się nie dzieje. `mouse` nie ma klu
 ###### 6. Jaki jest wynik?
 
 ```javascript
-let c = { greeting: 'Hey!' };
+let c = { greeting: "Hey!" };
 let d;
 
 d = c;
-c.greeting = 'Hello';
+c.greeting = "Hello";
 console.log(d.greeting);
 ```
 
@@ -282,13 +284,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`
@@ -343,10 +345,10 @@ Aby temu zapobiec, możemy użyć `"use strict"`. Powoduje to, że musisz zadekl
 
 ```javascript
 function bark() {
-  console.log('Woof!');
+  console.log("Woof!");
 }
 
-bark.animal = 'dog';
+bark.animal = "dog";
 ```
 
 - A: Nothing, this is totally fine!
@@ -376,8 +378,8 @@ function Person(firstName, lastName) {
   this.lastName = lastName;
 }
 
-const member = new Person('Lydia', 'Hallie');
-Person.getFullName = function() {
+const member = new Person("Lydia", "Hallie");
+Person.getFullName = function () {
   return `${this.firstName} ${this.lastName}`;
 };
 
@@ -399,7 +401,7 @@ W JavaScript funkcje są obiektami, więc metoda `getFullName` jest dodawana do
 Jeśli chcesz, aby metoda była dostępna dla wszystkich instancji obiektów, musisz dodać ją do właściwości prototype:
 
 ```js
-Person.prototype.getFullName = function() {
+Person.prototype.getFullName = function () {
   return `${this.firstName} ${this.lastName}`;
 };
 ```
@@ -417,8 +419,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 +490,7 @@ function sum(a, b) {
   return a + b;
 }
 
-sum(1, '2');
+sum(1, "2");
 ```
 
 - A: `NaN`
@@ -534,7 +536,7 @@ Operator jednoargumentowy **Postfix** `++`:
 1. Zwraca wartość (ten zwraca `0`)
 2. Zwiększa wartość (liczba wynosi teraz `1`)
 
-Operator jednoargumentowy **Prefix**  `++`:
+Operator jednoargumentowy **Prefix** `++`:
 
 1. Zwiększa wartość (liczba wynosi teraz `2`)
 2. Zwraca wartość (to zwraca `2`)
@@ -555,7 +557,7 @@ function getPersonInfo(one, two, three) {
   console.log(three);
 }
 
-const person = 'Lydia';
+const person = "Lydia";
 const age = 21;
 
 getPersonInfo`${person} is ${age} years old`;
@@ -582,9 +584,9 @@ W przypadku użycia `template strings`, wartością pierwszego argumentu jest za
 ```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`);
   }
@@ -644,7 +646,7 @@ Parametr reszty (`...args`) pozwala nam "zbierać" wszystkie pozostałe argument
 
 ```javascript
 function getAge() {
-  'use strict';
+  "use strict";
   age = 21;
   console.log(age);
 }
@@ -672,7 +674,7 @@ Dzięki `"use strict"` możesz upewnić się, że przypadkowo nie zadeklarujesz
 ###### 21. Jaka jest wartość `sum`?
 
 ```javascript
-const sum = eval('10*10+5');
+const sum = eval("10*10+5");
 ```
 
 - A: `105`
@@ -695,7 +697,7 @@ const sum = eval('10*10+5');
 ###### 22. Jak długo cool_secret jest dostępny?
 
 ```javascript
-sessionStorage.setItem('cool_secret', 123);
+sessionStorage.setItem("cool_secret", 123);
 ```
 
 - A: Dane nigdy nie zostaną utracone.
@@ -748,12 +750,12 @@ Nie można tego zrobić za pomocą `let` lub `const`, ponieważ są one blokowe.
 ###### 24. Jaki jest wynik?
 
 ```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);
 ```
 
@@ -779,7 +781,7 @@ Nie działa to w ten sam sposób dla zbioru. W zbiorze nie ma klucza `'1'`:`set.
 ###### 25. Jaki jest wynik?
 
 ```javascript
-const obj = { a: 'one', b: 'two', a: 'three' };
+const obj = { a: "one", b: "two", a: "three" };
 console.log(obj);
 ```
 
@@ -848,12 +850,12 @@ Instrukcja `continue` pomija iterację, jeśli określony warunek zwróci `true`
 
 ```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())
+console.log(name.giveLydiaPizza());
 ```
 
 - A: `"Just give Lydia pizza already!"`
@@ -877,8 +879,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 +912,9 @@ Następnie wyświetlamy w konsoli `a[b]`, co w rzeczywistości jest `a["[obiekt
 ###### 30. Jaki jest wynik?
 
 ```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();
@@ -965,9 +967,7 @@ W tym miejscu zaczyna działać pętla zdarzeń. **Pętla zdarzeń** patrzy na s
 ```html
 <div onclick="console.log('first div')">
   <div onclick="console.log('second div')">
-    <button onclick="console.log('button')">
-      Click!
-    </button>
+    <button onclick="console.log('button')">Click!</button>
   </div>
 </div>
 ```
@@ -993,9 +993,7 @@ Najgłębiej zagnieżdżony element, który spowodował zdarzenie jest celem zda
 
 ```html
 <div onclick="console.log('div')">
-  <p onclick="console.log('p')">
-    Click here!
-  </p>
+  <p onclick="console.log('p')">Click here!</p>
 </div>
 ```
 
@@ -1019,7 +1017,7 @@ Jeśli klikniemy `p`, zobaczymy dwa logi: `p` i `div`. Podczas propagacji zdarze
 ###### 33. Jaki jest wynik?
 
 ```javascript
-const person = { name: 'Lydia' };
+const person = { name: "Lydia" };
 
 function sayHi(age) {
   return `${this.name} is ${age}`;
@@ -1069,7 +1067,6 @@ console.log(typeof sayHi());
 #### Odpowiedź: B
 
 Funkcja `sayHi` zwraca zwróconą wartość natychmiast wywołanego wyrażenia funkcyjnego (IIFE). Ta funkcja zwróciła wartość `0`, która jest typu `"number"`.
-	
 FYI: `typeof` może zwrócić następującą listę wartości: `undefined`, `boolean`, `number`, `bigint`, `string`, `symbol`, `function` i `object`. Zauważ, że `typeof null` zwraca `"object"`.
 
 </p>
@@ -1082,8 +1079,8 @@ FYI: `typeof` może zwrócić następującą listę wartości: `undefined`, `boo
 ```javascript
 0;
 new Number(0);
-('');
-(' ');
+("");
+(" ");
 new Boolean(false);
 undefined;
 ```
@@ -1232,11 +1229,14 @@ To, co odróżnia prymityw od obiektu, to fakt, że prymitywy nie mają żadnych
 ###### 40. Jaki jest wynik?
 
 ```javascript
-[[0, 1], [2, 3]].reduce(
+[
+  [0, 1],
+  [2, 3],
+].reduce(
   (acc, cur) => {
     return acc.concat(cur);
   },
-  [1, 2],
+  [1, 2]
 );
 ```
 
@@ -1263,7 +1263,7 @@ Następnie `[1, 2, 0, 1]` to `acc`, a `[2, 3]` to `cur`. Łączymy je i otrzymuj
 
 ```javascript
 !!null;
-!!'';
+!!"";
 !!1;
 ```
 
@@ -1291,7 +1291,7 @@ Następnie `[1, 2, 0, 1]` to `acc`, a `[2, 3]` to `cur`. Łączymy je i otrzymuj
 ###### 42. Co zwraca metoda `setInterval` w przeglądarce?
 
 ```javascript
-setInterval(() => console.log('Hi'), 1000);
+setInterval(() => console.log("Hi"), 1000);
 ```
 
 - A: unikalny identyfikator
@@ -1314,7 +1314,7 @@ Zwraca unikalny identyfikator. Ten identyfikator może być użyty do wyczyszcze
 ###### 43. Co to zwróci?
 
 ```javascript
-[...'Lydia'];
+[..."Lydia"];
 ```
 
 - A: `["L", "y", "d", "i", "a"]`
@@ -1373,14 +1373,14 @@ Następnie ponownie wywołujemy funkcję za pomocą metody `next()`. Kontynuuje
 
 ```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));
+Promise.race([firstPromise, secondPromise]).then((res) => console.log(res));
 ```
 
 - A: `"one"`
@@ -1403,7 +1403,7 @@ Kiedy przekazujemy wiele 'promise' do metody `Promise.race`, rozwiązuje ona/odr
 ###### 46. Jaki jest wynik?
 
 ```javascript
-let person = { name: 'Lydia' };
+let person = { name: "Lydia" };
 const members = [person];
 person = null;
 
@@ -1443,7 +1443,7 @@ Modyfikujemy tylko wartość zmiennej `person`, a nie pierwszy element w tablicy
 
 ```javascript
 const person = {
-  name: 'Lydia',
+  name: "Lydia",
   age: 21,
 };
 
@@ -1472,7 +1472,7 @@ Za pomocą pętli `for-in` możemy iterować po kluczach obiektów, w tym przypa
 ###### 48. Jaki jest wynik?
 
 ```javascript
-console.log(3 + 4 + '5');
+console.log(3 + 4 + "5");
 ```
 
 - A: `"345"`
@@ -1499,7 +1499,7 @@ Asocjatywność operatorów to kolejność, w jakiej kompilator ocenia wyrażeni
 ###### 49. Jaka jest wartość `num`?
 
 ```javascript
-const num = parseInt('7*6', 10);
+const num = parseInt("7*6", 10);
 ```
 
 - A: `42`
@@ -1524,8 +1524,8 @@ Zwracana jest tylko pierwsza liczba w łańcuchu. W oparciu o _radix_ (drugi arg
 ###### 50. Jaki jest wynik?
 
 ```javascript
-[1, 2, 3].map(num => {
-  if (typeof num === 'number') return;
+[1, 2, 3].map((num) => {
+  if (typeof num === "number") return;
   return num * 2;
 });
 ```
@@ -1545,4 +1545,4 @@ Podczas mapowania tablicy, wartość `num` jest równa elementowi, nad którym a
 Nie zwracamy jednak żadnej wartości. Gdy nie zwracamy wartości z funkcji, funkcja zwraca `undefined`. Dla każdego elementu w tablicy wywoływany jest blok funkcji, więc dla każdego elementu zwracamy `undefined`.
 
 </p>
-</details>
\ No newline at end of file
+</details>
diff --git a/pt-BR/README_pt_BR.md b/pt-BR/README_pt_BR.md
index e59c6a6f..a0a0a211 100644
--- a/pt-BR/README_pt_BR.md
+++ b/pt-BR/README_pt_BR.md
@@ -19,6 +19,7 @@ As respostas estão em seções recolhidas abaixo das questões, basta clicar ne
 - [🇰🇷 한국어](../ko-KR/README-ko_KR.md)
 - [🇳🇱 Nederlands](../nl-NL/README.md)
 - [🇵🇱 Polski](../pl-PL/README.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)
@@ -28,7 +29,6 @@ As respostas estão em seções recolhidas abaixo das questões, basta clicar ne
 - [🇨🇳 简体中文](../zh-CN/README-zh_CN.md)
 - [🇹🇼 繁體中文](../zh-TW/README_zh-TW.md)
 
-
 ---
 
 ###### 1. Qual o resultado?
@@ -101,7 +101,7 @@ const shape = {
   diameter() {
     return this.radius * 2;
   },
-  perimeter: () => 2 * Math.PI * this.radius
+  perimeter: () => 2 * Math.PI * this.radius,
 };
 
 shape.diameter();
@@ -147,8 +147,9 @@ Não há `radius` fora de <i>shape</i>, então retorna `undefined`.
 
 O operador unário `+` tenta converter um operando para um número. `true` é `1`, e `false` é `0`.
 
-A string `'Lydia'` tem valor truthy*. O que estamos realmente perguntando é "Esse valor truthy é falsy?". Isso retorna `false`.  
-###### *Nota do tradutor: <i>truthy</i> é um termo único ao JavaScript que denota valores que podem ser convertidos em um booleano `True`. Sua contraparte é <i>falsy</i>, que são valores que podem ser convertidos em um booleano `false`. Para fins de consistência, mantenho os termos originais. 
+A string `'Lydia'` tem valor truthy\*. O que estamos realmente perguntando é "Esse valor truthy é falsy?". Isso retorna `false`.
+
+###### \*Nota do tradutor: <i>truthy</i> é um termo único ao JavaScript que denota valores que podem ser convertidos em um booleano `True`. Sua contraparte é <i>falsy</i>, que são valores que podem ser convertidos em um booleano `false`. Para fins de consistência, mantenho os termos originais.
 
 </p>
 </details>
@@ -159,12 +160,12 @@ A string `'Lydia'` tem valor truthy*. O que estamos realmente perguntando é "Es
 
 ```javascript
 const bird = {
-  size: "small"
+  size: "small",
 };
 
 const mouse = {
   name: "Mickey",
-  small: true
+  small: true,
 };
 ```
 
@@ -250,7 +251,7 @@ console.log(b === c);
 
 `new Number()` é uma funcção construtura padrão do JavaScript. Ainda que parece com um número, não é realmente um número: Tem um monte de funções extras e é um objeto.
 
-Quando usamos o operador `==`, só conferimos se ambas tem o mesmo <i>valor</i>. Ambas tem o valor de `3`, então retorna `true`. 
+Quando usamos o operador `==`, só conferimos se ambas tem o mesmo <i>valor</i>. Ambas tem o valor de `3`, então retorna `true`.
 
 Contudo, quando usamos o operador `===`, ambos valor <i>e</i> tipo tem de ser o mesmo. E não são: `new Number()` não é um número, é um **objeto**. Ambos retornam `false`.
 
@@ -314,7 +315,7 @@ console.log(greetign);
 
 Cria o log do objeto, pois criamos um objeto vazio no objeto global! Quando erramos a digitação de `greeting` como `greetign`, o interpretador do JavaScript viu isso como `global.greetign = {}` (ou `window.greetign = {}` em um navegador).
 
-Para evitar esse comportamento, podemos usar `"use strict"`. Isso garante que você  tenha declarado uma variável antes de poder inicializá-la com algum valor.
+Para evitar esse comportamento, podemos usar `"use strict"`. Isso garante que você tenha declarado uma variável antes de poder inicializá-la com algum valor.
 
 </p>
 </details>
@@ -359,7 +360,7 @@ function Person(firstName, lastName) {
 }
 
 const member = new Person("Lydia", "Hallie");
-Person.getFullName = function() {
+Person.getFullName = function () {
   return `${this.firstName} ${this.lastName}`;
 };
 
@@ -381,7 +382,7 @@ Você não pode adicionar propriedades para um construtor igual aos objetos norm
 Então nesse caso
 
 ```js
-Person.prototype.getFullName = function() {
+Person.prototype.getFullName = function () {
   return `${this.firstName} ${this.lastName}`;
 };
 ```
@@ -440,7 +441,8 @@ Afirmamos que `this.firstName` vale `"Sarah"` e `this.lastName` vale `"Smith"`.
 #### Resposta: D
 
 Durate a fase do **capturing**, o evento percorre os elementos pais até chegar no elemento algo. Isso alcança o elemento **target**, e o **bubbling** começa.
- ##### *Nota do tradutor: _bubbling_ descreve uma forma específica de propagação de eventos. Em tradução livre é "borbulhar", que indica como os eventos "sobem" a cadeia onde estão aninhados, mas prefiro por manter o original, visto que é o nome dessa forma de propagação.
+
+##### \*Nota do tradutor: _bubbling_ descreve uma forma específica de propagação de eventos. Em tradução livre é "borbulhar", que indica como os eventos "sobem" a cadeia onde estão aninhados, mas prefiro por manter o original, visto que é o nome dessa forma de propagação.
 
 <img src="https://i.imgur.com/N18oRgd.png" width="200">
 
@@ -459,7 +461,7 @@ Durate a fase do **capturing**, o evento percorre os elementos pais até chegar
 
 #### Resposta: B
 
-Todos objetos tem protótipos, exceto pelo **base object**. O base object tem acesso à alguns métodos e propriedades, como `.toString`. É o motivo de podermos usar métodos já embutidos no JavaScript! Todos métodos desse tipo já estão embutidos no protótipo. Apesar do JavaScript não encontrar algum método diretamente no seu objeto, ele percorre a cadeia de protótipos até encontrar no base, o que torna acessível para todo objeto. 
+Todos objetos tem protótipos, exceto pelo **base object**. O base object tem acesso à alguns métodos e propriedades, como `.toString`. É o motivo de podermos usar métodos já embutidos no JavaScript! Todos métodos desse tipo já estão embutidos no protótipo. Apesar do JavaScript não encontrar algum método diretamente no seu objeto, ele percorre a cadeia de protótipos até encontrar no base, o que torna acessível para todo objeto.
 
 </p>
 </details>
@@ -514,7 +516,7 @@ console.log(number);
 
 #### Resposta: C
 
-O operador unário no **sufixo**  `++`:
+O operador unário no **sufixo** `++`:
 
 1. Retorna o valor (retorna o valor `0`)
 2. Incrementa o valor (numero agora é `1`)
@@ -587,7 +589,7 @@ checkAge({ age: 18 });
 
 #### Resposta: C
 
-Quando testamos igualdade, primitivos são comparados por seus _valores_, enquanto objetos são comparados por suas  _referências_. O JavaScript confere se os objetos tem a referência para o mesmo local na memória.
+Quando testamos igualdade, primitivos são comparados por seus _valores_, enquanto objetos são comparados por suas _referências_. O JavaScript confere se os objetos tem a referência para o mesmo local na memória.
 
 Os dois objetos que estamos comparando não são assim: O objeto que passamos como parâmetro faz referência a uma posição na memória diferente daquela que o objeto que usamos para conferir a igualdade.
 
@@ -788,7 +790,7 @@ Se temos duas chaves com o mesmo nome, a última irá substituir a primeira. Ain
 ###### 26. O contexto global de execução do JavaScript cria duas coisas para você: O objeto global, e a palavra-chave `this`.
 
 - A: Verdadeiro
-- B: Falso 
+- B: Falso
 - C: Depende
 
 <details><summary><b>Resposta</b></summary>
@@ -838,7 +840,7 @@ String.prototype.giveLydiaPizza = () => {
 
 const name = "Lydia";
 
-console.log(name.giveLydiaPizza())
+console.log(name.giveLydiaPizza());
 ```
 
 - A: `"Just give Lydia pizza already!"`
@@ -950,9 +952,7 @@ A `WebAPI` não pode simplesmente adicionar coisas ao stack sempre que ficam pro
 ```html
 <div onclick="console.log('first div')">
   <div onclick="console.log('second div')">
-    <button onclick="console.log('button')">
-      Click!
-    </button>
+    <button onclick="console.log('button')">Click!</button>
   </div>
 </div>
 ```
@@ -967,7 +967,7 @@ A `WebAPI` não pode simplesmente adicionar coisas ao stack sempre que ficam pro
 
 #### Resposta: C
 
-O elemento mais interno no aninhamento que causou o evento é o alvo do evento. Você pode parar o _bubbling_ com `event.stopPropagation`. 
+O elemento mais interno no aninhamento que causou o evento é o alvo do evento. Você pode parar o _bubbling_ com `event.stopPropagation`.
 
 </p>
 </details>
@@ -978,9 +978,7 @@ O elemento mais interno no aninhamento que causou o evento é o alvo do evento.
 
 ```html
 <div onclick="console.log('div')">
-  <p onclick="console.log('p')">
-    Click here!
-  </p>
+  <p onclick="console.log('p')">Click here!</p>
 </div>
 ```
 
@@ -1055,7 +1053,7 @@ typeof sayHi();
 
 A função `sayHi` retorna o valor retornado pela arrow function pois ela é uma IIFE (Immediately Invoked Function Expression ou Expressão de Função Invocada Imediatamente). Essa IIFE retornou `0`, que é do tipo `"number"`.
 
-Para saber mais: Só existem 7 tipos já definidos: `null`, `undefined`, `boolean`, `number`, `string`, `object`, `symbol`, e `bigint`. `"function"` não é um tipo, uma vez que  funções são objetos, elas são do tipo `"object"`.
+Para saber mais: Só existem 7 tipos já definidos: `null`, `undefined`, `boolean`, `number`, `string`, `object`, `symbol`, e `bigint`. `"function"` não é um tipo, uma vez que funções são objetos, elas são do tipo `"object"`.
 
 </p>
 </details>
@@ -1215,7 +1213,10 @@ O que diferencia um primitivo de um objeto é que primitivos não possuem métod
 ###### 40. Qual o resultado?
 
 ```javascript
-[[0, 1], [2, 3]].reduce(
+[
+  [0, 1],
+  [2, 3],
+].reduce(
   (acc, cur) => {
     return acc.concat(cur);
   },
@@ -1278,7 +1279,7 @@ setInterval(() => console.log("Hi"), 1000);
 ```
 
 - A: um id único
-- B: a quantidade de  millisegundos especificada
+- B: a quantidade de millisegundos especificada
 - C: a função passada
 - D: `undefined`
 
@@ -1362,7 +1363,7 @@ const secondPromise = new Promise((res, rej) => {
   setTimeout(res, 100, "two");
 });
 
-Promise.race([firstPromise, secondPromise]).then(res => console.log(res));
+Promise.race([firstPromise, secondPromise]).then((res) => console.log(res));
 ```
 
 - A: `"one"`
@@ -1426,7 +1427,7 @@ Estamos apenas modificando o valor da variável `person`, e não o primeiro elem
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21
+  age: 21,
 };
 
 for (const item in person) {
@@ -1506,7 +1507,7 @@ Apenas os primeiros números da string é retornado. Baseado no _radix_ (o segun
 ###### 50. Qual o resultado?
 
 ```javascript
-[1, 2, 3].map(num => {
+[1, 2, 3].map((num) => {
   if (typeof num === "number") return;
   return num * 2;
 });
@@ -1675,7 +1676,7 @@ class Dog {
     this.name = name;
   }
 }
-Dog.prototype.bark = function() {
+Dog.prototype.bark = function () {
   console.log(`Woof I am ${this.name}`);
 };
 const pet = new Dog("Mara");
@@ -1850,7 +1851,6 @@ console.log(admin);
 
 #### Resposta: B
 
-
 É possível combinar objetos usando o operador o spread operator `...`. Ele permite criar cópias dos pares de um objeto e adicioná-las a outro objeto. Nesse caso, criamos cópias do objeto `user` e as adicionamos ao objeto `admin`. O objeto `admin` agora contém os pares de chave/valor copiados, o que resulta em `{ admin: true, name: "Lydia", age: 21 }`.
 
 </p>
@@ -1878,10 +1878,12 @@ console.log(Object.keys(person));
 <p>
 
 #### Resposta: B
-Com o método `defineProperty`, podemos adicionar novas propriedades a um objeto ou modificar propriedades já existentes. Quando adicionamos uma propriedade a um objeto usando o método `defineProperty`, ela é, por padrão, _não enumerável_. O método`Object.keys` retorna todos os nomes de uma propriedade _enumerável_  de um objeto. Nesse caso, apenas `"name"`.
 
-Propriedades adicionadas usando o método `defineProperty` são imutáveis por padrão. Você pode sobrepor esse comportamento usando as propriedade `writable`, `configurable` e `enumerable`. 
+Com o método `defineProperty`, podemos adicionar novas propriedades a um objeto ou modificar propriedades já existentes. Quando adicionamos uma propriedade a um objeto usando o método `defineProperty`, ela é, por padrão, _não enumerável_. O método`Object.keys` retorna todos os nomes de uma propriedade _enumerável_ de um objeto. Nesse caso, apenas `"name"`.
+
+Propriedades adicionadas usando o método `defineProperty` são imutáveis por padrão. Você pode sobrepor esse comportamento usando as propriedade `writable`, `configurable` e `enumerable`.
 Assim, o método `defineProperty` dá a você muito mais controle sobre as propriedades que você está adicionando a um objeto.
+
 </p>
 </details>
 
@@ -1893,7 +1895,7 @@ Assim, o método `defineProperty` dá a você muito mais controle sobre as propr
 const settings = {
   username: "lydiahallie",
   level: 19,
-  health: 90
+  health: 90,
 };
 
 const data = JSON.stringify(settings, ["level", "health"]);
@@ -1915,17 +1917,19 @@ O segundo argumento de `JSON.stringify` é o _substituo_. O substituto pode ser
 Se o substituto (replacer) for um _array_, apenas os nomes de propriedades incluídos no array serão adicionados à string JSON. Nesse caso, apenas as propriedades com os nomes `"level"` ed `"health"` são incluída, `"username"` é excluída. `data` agora é igual a `"{"level":19, "health":90}"`.
 
 Se o substituto (replacer) for uma _função_, essa função é chamada em c ada propriedade no objeto que está sendo "Stringfied". O valor retornado dessa função será o valor da propriedade quanto adicionado à string JSON. Se o valor for `undefined`, essa propriedade é excluída da string JSON.
+
 </p>
 </details>
 
 ---
+
 ###### 63. Qual o resultado?
 
 ```javascript
 let num = 10;
 
 const increaseNumber = () => num++;
-const increasePassedNumber = number => number++;
+const increasePassedNumber = (number) => number++;
 
 const num1 = increaseNumber();
 const num2 = increasePassedNumber(num1);
@@ -1952,6 +1956,7 @@ O operador unário `++` primeiro _retorna_ o valor do operando, depois _incremen
 </details>
 
 ---
+
 ###### 64. Qual o resultado?
 
 ```javascript
@@ -1989,6 +1994,7 @@ Na quarta vez, passamos o objeto `value` novamente. `x.number` foi modificado an
 </details>
 
 ---
+
 ###### 65. Qual o resultado?
 
 ```javascript
@@ -2074,16 +2080,17 @@ A classe `Labrador` recebe dois argumentos, `name`, pois estende `Dog`, e `size`
 </details>
 
 ---
+
 ###### 67. Qual o resultado?
 
 ```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;
 ```
 
@@ -2105,12 +2112,13 @@ Esta é uma diferença entre `require()` no CommonJS e `import`! Com `require()`
 </details>
 
 ---
+
 ###### 68. Qual o resultado?
 
 ```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`
@@ -2129,10 +2137,11 @@ Todo símbolo (Symbol) é totalmente único. O objetivo do argumento passado ao
 </details>
 
 ---
+
 ###### 69. Qual o resultado?
 
 ```javascript
-const name = 'Lydia Hallie';
+const name = "Lydia Hallie";
 console.log(name.padStart(13));
 console.log(name.padStart(2));
 ```
@@ -2155,10 +2164,11 @@ Se o argumento passado para o método `padStart` for menor que o comprimento da
 </details>
 
 ---
+
 ###### 70. Qual o resultado?
 
 ```javascript
-console.log('🥑' + '💻');
+console.log("🥑" + "💻");
 ```
 
 - A: `"🥑💻"`
@@ -2182,11 +2192,11 @@ Com o operador `+`, você pode concatenar seqüências de caracteres (strings).
 
 ```javascript
 function* iniciarJogo() {
-  const resposta = yield 'Você ama JavaScript?';
-  if (resposta !== 'Sim') {
+  const resposta = yield "Você ama JavaScript?";
+  if (resposta !== "Sim") {
     return "Uau... Acho que entramos aqui";
   }
-  return 'O JavaScript também ama você ❤️';
+  return "O JavaScript também ama você ❤️";
 }
 
 const jogo = iniciarJogo();
@@ -2249,11 +2259,12 @@ Neste caso, a string é `Hello\nworld`, que é registrada.
 </details>
 
 ---
+
 ###### 73. Qual o resultado?
 
 ```javascript
 async function getData() {
-  return await Promise.resolve('I made it!');
+  return await Promise.resolve("I made it!");
 }
 
 const data = getData();
@@ -2282,6 +2293,7 @@ Isso teria registrado `"Consegui!"`
 </details>
 
 ---
+
 ###### 74. Qual o resultado?
 
 ```javascript
@@ -2289,7 +2301,7 @@ function addToList(item, list) {
   return list.push(item);
 }
 
-const result = addToList('apple', ['banana']);
+const result = addToList("apple", ["banana"]);
 console.log(result);
 ```
 
@@ -2349,7 +2361,7 @@ Como `shape` está congelado, e como o valor de `x` não é um objeto, não pode
 ###### 76.Qual o resultado?
 
 ```javascript
-const { name: myName } = { name: 'Lydia' };
+const { name: myName } = { name: "Lydia" };
 
 console.log(name);
 ```
@@ -2405,7 +2417,7 @@ A função `sum` sempre retorna o mesmo resultado. Se passarmos `1` e` 2`, ele _
 ```javascript
 const add = () => {
   const cache = {};
-  return num => {
+  return (num) => {
     if (num in cache) {
       return `From cache! ${cache[num]}`;
     } else {
@@ -2436,7 +2448,7 @@ A função `add` é uma função _memoized_ (memorizada). Com a memorização, p
 
 Se chamarmos a função `addFunction` novamente com o mesmo argumento, ela primeiro verifica se já obteve esse valor em seu cache. Se for o caso, o valor dos caches será retornado, o que economiza tempo de execução. Caso contrário, se não estiver armazenado em cache, ele calculará o valor e o armazenará posteriormente.
 
-Chamamos a função `addFunction` três vezes com o mesmo valor: na primeira chamada, o valor da função quando `num` é igual a `10` ainda não é armazenado em cache. A condição da instrução if `num in cache` retorna `false`, e o bloco else é executado: `Calculated! 20` é registrado e o valor do resultado é adicionado ao objeto de cache. `cache` agora se parece com` {10:20} `.
+Chamamos a função `addFunction` três vezes com o mesmo valor: na primeira chamada, o valor da função quando `num` é igual a `10` ainda não é armazenado em cache. A condição da instrução if `num in cache` retorna `false`, e o bloco else é executado: `Calculated! 20` é registrado e o valor do resultado é adicionado ao objeto de cache. `cache` agora se parece com`{10:20}`.
 
 Na segunda vez, o objeto `cache` contém o valor que é retornado para `10`. A condição da instrução if `num in cache` retorna `true`, e `'From cache! 20'` é registrado.
 
@@ -2450,7 +2462,7 @@ Na terceira vez, passamos `5 * 2` para a função que é avaliada como `10`. O o
 ###### 79. Qual o resultado?
 
 ```javascript
-const myLifeSummedUp = ['☕', '💻', '🍷', '🍫'];
+const myLifeSummedUp = ["☕", "💻", "🍷", "🍫"];
 
 for (let item in myLifeSummedUp) {
   console.log(item);
@@ -2475,7 +2487,7 @@ Com um loop _for-in_, podemos iterar sobre propriedades **enumeráveis​​**.
 
 `{0:" ☕ ", 1:" 💻 ", 2:" 🍷 ", 3:" 🍫 "}`
 
-Onde as chaves são as propriedades enumeráveis. `0`` 1` `2`` 3` são registrados.
+Onde as chaves são as propriedades enumeráveis. ` 0`` 1 ` ` 2`` 3 ` são registrados.
 
 Com um loop _for-of_, podemos iterar sobre **iteráveis**. Um array é um iterável. Quando iteramos sobre o array, a variável "item" é igual ao elemento sobre o qual está iterando no momento, `" ☕ "` `" 💻 "` `" 🍷 "` `" 🍫 "` são registrados.
 
@@ -2508,4 +2520,4 @@ O elemento será igual ao valor retornado. `1 + 2` retorna` 3`, `1 * 2` retorna`
 </p>
 </details>
 
----
\ No newline at end of file
+---
diff --git a/ro-RO/README.ro.md b/ro-RO/README.ro.md
new file mode 100644
index 00000000..3205d61c
--- /dev/null
+++ b/ro-RO/README.ro.md
@@ -0,0 +1,49 @@
+<div align="center">
+  <img height="60" src="https://img.icons8.com/color/344/javascript.png">
+  <h1>Întrebări JavaScript</h1>
+
+---
+
+<span>Postez întrebări JavaScript cu opțiuni multiple pe [Instagram](https://www.instagram.com/theavocoder) **stories**, pe care le voi posta și aici! Ultima actualizare: <a href=#20200612><b>12 Iunie</b></a>
+
+De la nivel de bază la avansat: testează cât de bine cunoști JavaScript, reîmprospătează-ți puțin cunoștințele sau pregătește-te pentru interviul tău de codare! :muscle: :rocket: Actualizez acest depozit în mod regulat cu întrebări noi. Am adăugat răspunsurile în **secțiunile restrânse** de sub întrebări, pur și simplu dă clic pe ele pentru a le extinde. Este doar pentru distracție, mult noroc! :heart:</span>
+
+Nu ezita să mă contactezi! 😊 <br />
+<a href="https://www.instagram.com/theavocoder">Instagram</a> || <a href="https://www.twitter.com/lydiahallie">Twitter</a> || <a href="https://www.linkedin.com/in/lydia-hallie">LinkedIn</a> || <a href="https://www.lydiahallie.dev">Blog</a>
+
+</div>
+
+| Simte-te liber să le folosești într-un proiect! 😃 Aș aprecia _cu adevărat_ o referință la acest depozit, eu creez întrebările și explicațiile (da, sunt tristă lol) și comunitatea mă ajută foarte mult să îl mențin și să îl îmbunătățesc! 💪🏼 Mulțumesc și distracție plăcută! |
+| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+
+---
+
+<details><summary><b> Vezi 20 de traduceri disponibile 🇸🇦🇪🇬🇧🇦🇩🇪🇪🇸🇫🇷🇮🇩🇯🇵🇰🇷🇳🇱🇧🇷🇷🇺🇹🇭🇹🇷🇺🇦🇻🇳🇨🇳🇹🇼🇽🇰</b></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)
+- [🇷🇺 Русский](./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)
+
+</p>
+</details>
+
+---
diff --git a/ru-RU/README.md b/ru-RU/README.md
index 17a083ab..35f9e86f 100644
--- a/ru-RU/README.md
+++ b/ru-RU/README.md
@@ -10,10 +10,11 @@
 
 Не стесняйтесь обращаться ко мне (Lydia Hallie)! 😊<br />
 <a href="https://www.instagram.com/theavocoder">Instagram</a> || <a href="https://www.twitter.com/lydiahallie">Twitter</a> || <a href="https://www.linkedin.com/in/lydia-hallie">LinkedIn</a> || <a href="https://www.lydiahallie.dev">Blog</a>
+
 </div>
 
 | Не стесняйтесь использовать эти примеры в проектах! 😃 Я (Lydia Hallie) была бы _действительно_ признателена за ссылку на этот репозиторий. Я добавляю вопросы и объяснения, и сообщество очень помогает мне поддерживать и улучшать все это! 💪🏼 Спасибо и приятного просмотра! |
-|---|
+| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 
 ---
 
@@ -33,6 +34,7 @@
 - [🇳🇱 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)
 - [🇬🇧 English](../README.md)
 - [🇽🇰 Shqip](../sq-KS/README_sq_KS.md)
 - [🇹🇭 ไทย](../th-TH/README-th_TH.md)
@@ -117,7 +119,7 @@ const shape = {
   diameter() {
     return this.radius * 2;
   },
-  perimeter: () => 2 * Math.PI * this.radius
+  perimeter: () => 2 * Math.PI * this.radius,
 };
 
 console.log(shape.diameter());
@@ -149,7 +151,7 @@ console.log(shape.perimeter());
 
 ```javascript
 +true;
-!'Lydia';
+!"Lydia";
 ```
 
 - A: `1` и `false`
@@ -174,12 +176,12 @@ console.log(shape.perimeter());
 
 ```javascript
 const bird = {
-  size: 'small'
+  size: "small",
 };
 
 const mouse = {
-  name: 'Mickey',
-  small: true
+  name: "Mickey",
+  small: true,
 };
 ```
 
@@ -209,11 +211,11 @@ JavaScript интерпретирует (или распаковывает) оп
 ###### 6. Что будет в консоли?
 
 ```javascript
-let c = { greeting: 'Hey!' };
+let c = { greeting: "Hey!" };
 let d;
 
 d = c;
-c.greeting = 'Hello';
+c.greeting = "Hello";
 console.log(d.greeting);
 ```
 
@@ -283,13 +285,13 @@ class Chameleon {
     return this.newColor;
   }
 
-  constructor({ newColor = 'green' } = {}) {
+  constructor({ newColor = "green" } = {}) {
     this.newColor = newColor;
   }
 }
 
-const freddie = new Chameleon({ newColor: 'purple' });
-freddie.colorChange('orange');
+const freddie = new Chameleon({ newColor: "purple" });
+freddie.colorChange("orange");
 ```
 
 - A: `orange`
@@ -344,10 +346,10 @@ console.log(greetign);
 
 ```javascript
 function bark() {
-  console.log('Woof!');
+  console.log("Woof!");
 }
 
-bark.animal = 'dog';
+bark.animal = "dog";
 ```
 
 - A: Ничего, всё в порядке!
@@ -377,10 +379,10 @@ 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}`;
-}
+};
 
 console.log(member.getFullName());
 ```
@@ -402,7 +404,7 @@ console.log(member.getFullName());
 ```js
 Person.prototype.getFullName = function () {
   return `${this.firstName} ${this.lastName}`;
-}
+};
 ```
 
 </p>
@@ -418,8 +420,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);
@@ -489,7 +491,7 @@ function sum(a, b) {
   return a + b;
 }
 
-sum(1, '2');
+sum(1, "2");
 ```
 
 - A: `NaN`
@@ -556,7 +558,7 @@ function getPersonInfo(one, two, three) {
   console.log(three);
 }
 
-const person = 'Lydia';
+const person = "Lydia";
 const age = 21;
 
 getPersonInfo`${person} is ${age} years old`;
@@ -583,9 +585,9 @@ getPersonInfo`${person} is ${age} years old`;
 ```javascript
 function checkAge(data) {
   if (data === { age: 18 }) {
-    console.log('Ты взрослый!');
+    console.log("Ты взрослый!");
   } else if (data == { age: 18 }) {
-    console.log('Ты все еще взрослый.');
+    console.log("Ты все еще взрослый.");
   } else {
     console.log(`Хмм.. Кажется, у тебя нет возраста.`);
   }
@@ -645,7 +647,7 @@ getAge(21);
 
 ```javascript
 function getAge() {
-  'use strict';
+  "use strict";
   age = 21;
   console.log(age);
 }
@@ -673,7 +675,7 @@ getAge();
 ###### 21. Чему будет равно `sum`?
 
 ```javascript
-const sum = eval('10*10+5');
+const sum = eval("10*10+5");
 ```
 
 - A: `105`
@@ -696,7 +698,7 @@ const sum = eval('10*10+5');
 ###### 22. Как долго будет доступен cool_secret?
 
 ```javascript
-sessionStorage.setItem('cool_secret', 123);
+sessionStorage.setItem("cool_secret", 123);
 ```
 
 - A: Всегда, данные не потеряются.
@@ -749,12 +751,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);
 ```
 
@@ -780,7 +782,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);
 ```
 
@@ -849,12 +851,12 @@ 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())
+console.log(name.giveLydiaPizza());
 ```
 
 - A: `"Just give Lydia pizza already!"`
@@ -878,8 +880,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;
@@ -911,9 +913,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();
@@ -966,9 +968,7 @@ WebAPI не может добавлять содержимое в стек ко
 ```html
 <div onclick="console.log('first div')">
   <div onclick="console.log('second div')">
-    <button onclick="console.log('button')">
-      Кликни!
-    </button>
+    <button onclick="console.log('button')">Кликни!</button>
   </div>
 </div>
 ```
@@ -994,9 +994,7 @@ WebAPI не может добавлять содержимое в стек ко
 
 ```html
 <div onclick="console.log('div')">
-  <p onclick="console.log('p')">
-    Кликни меня!
-  </p>
+  <p onclick="console.log('p')">Кликни меня!</p>
 </div>
 ```
 
@@ -1020,7 +1018,7 @@ WebAPI не может добавлять содержимое в стек ко
 ###### 33. Что будет в консоли?
 
 ```javascript
-const person = { name: 'Lydia' };
+const person = { name: "Lydia" };
 
 function sayHi(age) {
   console.log(`${this.name} is ${age}`);
@@ -1233,7 +1231,10 @@ console.log(numbers);
 ###### 40. Каким будет результат?
 
 ```javascript
-[[0, 1], [2, 3]].reduce(
+[
+  [0, 1],
+  [2, 3],
+].reduce(
   (acc, cur) => {
     return acc.concat(cur);
   },
@@ -1264,7 +1265,7 @@ console.log(numbers);
 
 ```javascript
 !!null;
-!!'';
+!!"";
 !!1;
 ```
 
@@ -1292,7 +1293,7 @@ console.log(numbers);
 ###### 42. Что возвращает метод `setInterval` в браузере?
 
 ```javascript
-setInterval(() => console.log('Hi'), 1000);
+setInterval(() => console.log("Hi"), 1000);
 ```
 
 - A: уникальный id
@@ -1315,7 +1316,7 @@ setInterval(() => console.log('Hi'), 1000);
 ###### 43. Каким будет результат?
 
 ```javascript
-[...'Lydia'];
+[..."Lydia"];
 ```
 
 - A: `["L", "y", "d", "i", "a"]`
@@ -1374,14 +1375,14 @@ console.log(gen.next().value);
 
 ```javascript
 const firstPromise = new Promise((res, rej) => {
-  setTimeout(res, 500, 'один');
+  setTimeout(res, 500, "один");
 });
 
 const secondPromise = new Promise((res, rej) => {
-  setTimeout(res, 100, 'два');
+  setTimeout(res, 100, "два");
 });
 
-Promise.race([firstPromise, secondPromise]).then(res => console.log(res));
+Promise.race([firstPromise, secondPromise]).then((res) => console.log(res));
 ```
 
 - A: `"один"`
@@ -1404,7 +1405,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;
 
@@ -1444,8 +1445,8 @@ console.log(members);
 
 ```javascript
 const person = {
-  name: 'Lydia',
-  age: 21
+  name: "Lydia",
+  age: 21,
 };
 
 for (const item in person) {
@@ -1473,7 +1474,7 @@ for (const item in person) {
 ###### 48. Каким будет результат?
 
 ```javascript
-console.log(3 + 4 + '5');
+console.log(3 + 4 + "5");
 ```
 
 - A: `"345"`
@@ -1525,8 +1526,8 @@ const num = parseInt("7*6", 10);
 ###### 50. Каким будет результат?
 
 ```javascript
-[1, 2, 3].map(num => {
-  if (typeof num === 'number') return;
+[1, 2, 3].map((num) => {
+  if (typeof num === "number") return;
   return num * 2;
 });
 ```
@@ -1554,12 +1555,12 @@ const num = parseInt("7*6", 10);
 
 ```javascript
 function getInfo(member, year) {
-  member.name = 'Lydia';
+  member.name = "Lydia";
   year = 1998;
 }
 
-const person = { name: 'Sarah' };
-const birthYear = '1997';
+const person = { name: "Sarah" };
+const birthYear = "1997";
 
 getInfo(person, birthYear);
 
@@ -1578,7 +1579,7 @@ console.log(person, birthYear);
 
 Аргументы передаются _значением_, если их значение не является объектом, то они передаются _ссылкой_. `birthYear` передается по значению, поскольку это строка, а не объект. Когда мы передаем аргументы по значению, создается _копия_ этого значения (см. вопрос 46).
 
-Переменная `birthYear` имеет ссылку на значение `"1997"`. Аргумент `year` также имеет ссылку на значение` "1997" `, но это не то же самое значение, на которое имеется ссылка для `birthYear`. Когда мы обновляем значение `year`, устанавливая `year` равным `"1998"`, мы обновляем только значение `year`. `birthYear` по-прежнему равно `"1997"`.
+Переменная `birthYear` имеет ссылку на значение `"1997"`. Аргумент `year` также имеет ссылку на значение`"1997"`, но это не то же самое значение, на которое имеется ссылка для `birthYear`. Когда мы обновляем значение `year`, устанавливая `year` равным `"1998"`, мы обновляем только значение `year`. `birthYear` по-прежнему равно `"1997"`.
 
 Значение `person` является объектом. Аргумент `member` имеет (скопированную) ссылку на _тот же_ объект. Когда мы изменяем свойство объекта, на который `member` ссылается, значение `person` также будет изменено, поскольку они оба имеют ссылку на один и тот же объект. Свойство `name` объекта `person` теперь равно значению `"Lydia"`.
 
@@ -1591,15 +1592,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);
   }
 }
 
@@ -1629,8 +1630,8 @@ sayHi();
 
 ```javascript
 function Car() {
-  this.make = 'Lamborghini';
-  return { make: 'Maserati' };
+  this.make = "Lamborghini";
+  return { make: "Maserati" };
 }
 
 const myCar = new Car();
@@ -1702,11 +1703,11 @@ class Dog {
   }
 }
 
-Dog.prototype.bark = function() {
+Dog.prototype.bark = function () {
   console.log(`Woof I am ${this.name}`);
 };
 
-const pet = new Dog('Mara');
+const pet = new Dog("Mara");
 
 pet.bark();
 
@@ -1771,7 +1772,7 @@ export default counter;
 
 ```javascript
 // index.js
-import myCounter from './counter';
+import myCounter from "./counter";
 
 myCounter += 1;
 
@@ -1800,7 +1801,7 @@ console.log(myCounter);
 ###### 58. Какой будет вывод?
 
 ```javascript
-const name = 'Lydia';
+const name = "Lydia";
 age = 21;
 
 console.log(delete name);
@@ -1871,7 +1872,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);
@@ -1897,9 +1898,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));
@@ -1928,12 +1929,12 @@ console.log(Object.keys(person));
 
 ```javascript
 const settings = {
-  username: 'lydiahallie',
+  username: "lydiahallie",
   level: 19,
-  health: 90
+  health: 90,
 };
 
-const data = JSON.stringify(settings, ['level', 'health']);
+const data = JSON.stringify(settings, ["level", "health"]);
 console.log(data);
 ```
 
@@ -1964,7 +1965,7 @@ console.log(data);
 let num = 10;
 
 const increaseNumber = () => num++;
-const increasePassedNumber = number => number++;
+const increasePassedNumber = (number) => number++;
 
 const num1 = increaseNumber();
 const num2 = increasePassedNumber(num1);
@@ -2121,12 +2122,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;
 ```
 
@@ -2152,9 +2153,9 @@ export const sum = (a, b) => a + b;
 ###### 68. Какой будет вывод?
 
 ```javascript
-console.log(Number(2) === Number(2))
-console.log(Boolean(false) === Boolean(false))
-console.log(Symbol('foo') === Symbol('foo'))
+console.log(Number(2) === Number(2));
+console.log(Boolean(false) === Boolean(false));
+console.log(Symbol("foo") === Symbol("foo"));
 ```
 
 - A: `true`, `true`, `false`
@@ -2177,9 +2178,9 @@ console.log(Symbol('foo') === Symbol('foo'))
 ###### 69. Какой будет вывод?
 
 ```javascript
-const name = 'Lydia Hallie'
-console.log(name.padStart(13))
-console.log(name.padStart(2))
+const name = "Lydia Hallie";
+console.log(name.padStart(13));
+console.log(name.padStart(2));
 ```
 
 - A: `"Lydia Hallie"`, `"Lydia Hallie"`
@@ -2300,7 +2301,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();
@@ -2337,7 +2338,7 @@ function addToList(item, list) {
   return list.push(item);
 }
 
-const result = addToList('apple', ['banana']);
+const result = addToList("apple", ["banana"]);
 console.log(result);
 ```
 
@@ -2397,7 +2398,7 @@ console.log(shape);
 ###### 76. Какой будет вывод?
 
 ```javascript
-const { firstName: myName } = { firstName: 'Lydia' };
+const { firstName: myName } = { firstName: "Lydia" };
 
 console.log(firstName);
 ```
@@ -2415,7 +2416,7 @@ console.log(firstName);
 Используя [деструктурирующее присваивание](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment), мы можем распаковывать значения из массивов или свойства из объектов в отдельные переменные:
 
 ```javascript
-const { firstName } = { firstName: 'Lydia' };
+const { firstName } = { firstName: "Lydia" };
 // Версия ES5:
 // var firstName = { firstName: 'Lydia' }.firstName;
 
@@ -2425,7 +2426,7 @@ console.log(firstName); // "Lydia"
 Также свойство можно распаковать из объекта и присвоить переменной с именем, отличным от имени свойства объекта:
 
 ```javascript
-const { firstName: myName } = { firstName: 'Lydia' };
+const { firstName: myName } = { firstName: "Lydia" };
 // Версия ES5:
 // var myName = { firstName: 'Lydia' }.firstName;
 
@@ -2438,12 +2439,11 @@ console.log(firstName); // Тут будет ошибка Uncaught ReferenceErro
 **Примечание.** Помните о свойствах глобальной области видимости:
 
 ```javascript
-const { name: myName } = { name: 'Lydia' };
+const { name: myName } = { name: "Lydia" };
 
 console.log(myName); // "lydia"
 console.log(name); // "" ----- Браузер, например, Chrome
 console.log(name); // ReferenceError: name is not defined  ----- NodeJS
-
 ```
 
 Всякий раз, когда Javascript не может найти переменную в _текущей области видимости_, то поднимается вверх по [цепочке областей видимости](https://developer.mozilla.org/ru/docs/Web/JavaScript/Closures#лексическая_область_видимости) и ищет ее на каждом уровне, и если достигает области верхнего уровня, также известной как **Глобальная область**, и все еще не находит нужной ссылки, то выдает `ReferenceError`.
@@ -2487,7 +2487,7 @@ function sum(a, b) {
 ```javascript
 const add = () => {
   const cache = {};
-  return num => {
+  return (num) => {
     if (num in cache) {
       return `From cache! ${cache[num]}`;
     } else {
@@ -2532,21 +2532,21 @@ console.log(addFunction(5 * 2));
 ###### 79. Какой будет вывод?
 
 ```javascript
-const myLifeSummedUp = ['☕', '💻', '🍷', '🍫']
+const myLifeSummedUp = ["☕", "💻", "🍷", "🍫"];
 
 for (let item in myLifeSummedUp) {
-  console.log(item)
+  console.log(item);
 }
 
 for (let item of myLifeSummedUp) {
-  console.log(item)
+  console.log(item);
 }
 ```
 
 - A: `0` `1` `2` `3` и `"☕"` ` "💻"` `"🍷"` `"🍫"`
 - B: `"☕"` ` "💻"` `"🍷"` `"🍫"` и `"☕"` ` "💻"` `"🍷"` `"🍫"`
 - C: `"☕"` ` "💻"` `"🍷"` `"🍫"` и `0` `1` `2` `3`
-- D:  `0` `1` `2` `3` и `{0: "☕", 1: "💻", 2: "🍷", 3: "🍫"}`
+- D: `0` `1` `2` `3` и `{0: "☕", 1: "💻", 2: "🍷", 3: "🍫"}`
 
 <details><summary><b>Ответ</b></summary>
 <p>
@@ -2569,14 +2569,14 @@ for (let item of myLifeSummedUp) {
 ###### 80. Какой будет вывод?
 
 ```javascript
-const list = [1 + 2, 1 * 2, 1 / 2]
-console.log(list)
+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]`
+- D: `[1, 1, 1]`
 
 <details><summary><b>Ответ</b></summary>
 <p>
@@ -2596,16 +2596,16 @@ console.log(list)
 
 ```javascript
 function sayHi(name) {
-  return `Hi there, ${name}`
+  return `Hi there, ${name}`;
 }
 
-console.log(sayHi())
+console.log(sayHi());
 ```
 
 - A: `Hi there, `
 - B: `Hi there, undefined`
 - C: `Hi there, null`
-- D:  `ReferenceError`
+- D: `ReferenceError`
 
 <details><summary><b>Ответ</b></summary>
 <p>
@@ -2628,21 +2628,21 @@ console.log(sayHi())
 ###### 82. Какой будет вывод?
 
 ```javascript
-var status = '😎'
+var status = "😎";
 
 setTimeout(() => {
-  const status = '😍'
+  const status = "😍";
 
   const data = {
-    status: '🥑',
+    status: "🥑",
     getStatus() {
-      return this.status
-    }
-  }
+      return this.status;
+    },
+  };
 
-  console.log(data.getStatus())
-  console.log(data.getStatus.call(this))
-}, 0)
+  console.log(data.getStatus());
+  console.log(data.getStatus.call(this));
+}, 0);
 ```
 
 - A: `"🥑"` и `"😍"`
@@ -2668,14 +2668,14 @@ setTimeout(() => {
 
 ```javascript
 const person = {
-  name: 'Lydia',
-  age: 21
-}
+  name: "Lydia",
+  age: 21,
+};
 
-let city = person.city
-city = 'Amsterdam'
+let city = person.city;
+city = "Amsterdam";
 
-console.log(person)
+console.log(person);
 ```
 
 - A: `{ name: "Lydia", age: 21 }`
@@ -2706,15 +2706,15 @@ console.log(person)
 ```javascript
 function checkAge(age) {
   if (age < 18) {
-    const message = "Sorry, you're too young."
+    const message = "Sorry, you're too young.";
   } else {
-    const message = "Yay! You're old enough!"
+    const message = "Yay! You're old enough!";
   }
 
-  return message
+  return message;
 }
 
-console.log(checkAge(21))
+console.log(checkAge(21));
 ```
 
 - A: `"Sorry, you're too young."`
@@ -2737,9 +2737,9 @@ console.log(checkAge(21))
 ###### 85. Какая информация будетвыведена в лог?
 
 ```javascript
-fetch('https://www.website.com/api/user/1')
-  .then(res => res.json())
-  .then(res => console.log(res))
+fetch("https://www.website.com/api/user/1")
+  .then((res) => res.json())
+  .then((res) => console.log(res));
 ```
 
 - A: Результат метода `fetch`.
@@ -2793,7 +2793,7 @@ function getName(name) {
 ###### 87. Какой будет вывод?
 
 ```javascript
-console.log('I want pizza'[0])
+console.log("I want pizza"[0]);
 ```
 
 - A: `"""`
@@ -2819,10 +2819,10 @@ console.log('I want pizza'[0])
 
 ```javascript
 function sum(num1, num2 = num1) {
-  console.log(num1 + num2)
+  console.log(num1 + num2);
 }
 
-sum(10)
+sum(10);
 ```
 
 - A: `NaN`
@@ -2848,13 +2848,13 @@ 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)
+console.log(data);
 ```
 
 - A: `{ default: function default(), name: "Lydia" }`
@@ -2881,12 +2881,12 @@ console.log(data)
 ```javascript
 class Person {
   constructor(name) {
-    this.name = name
+    this.name = name;
   }
 }
 
-const member = new Person('John')
-console.log(typeof member)
+const member = new Person("John");
+console.log(typeof member);
 ```
 
 - A: `"class"`
@@ -2903,7 +2903,7 @@ console.log(typeof member)
 
 ```javascript
 function Person() {
-  this.name = name
+  this.name = name;
 }
 ```
 
@@ -2917,9 +2917,9 @@ function Person() {
 ###### 91. Какой будет вывод?
 
 ```javascript
-let newList = [1, 2, 3].push(4)
+let newList = [1, 2, 3].push(4);
 
-console.log(newList.push(5))
+console.log(newList.push(5));
 ```
 
 - A: `[1, 2, 3, 4, 5]`
@@ -2945,14 +2945,14 @@ 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."
+  "Here's chocolate... now go hit the gym already.";
 
-console.log(giveLydiaPizza.prototype)
-console.log(giveLydiaChocolate.prototype)
+console.log(giveLydiaPizza.prototype);
+console.log(giveLydiaChocolate.prototype);
 ```
 
 - A: `{ constructor: ...}` `{ constructor: ...}`
@@ -2976,12 +2976,12 @@ console.log(giveLydiaChocolate.prototype)
 
 ```javascript
 const person = {
-  name: 'Lydia',
-  age: 21
-}
+  name: "Lydia",
+  age: 21,
+};
 
 for (const [x, y] of Object.entries(person)) {
-  console.log(x, y)
+  console.log(x, y);
 }
 ```
 
@@ -3033,10 +3033,10 @@ getItems(["banana", "apple"], "pear", "orange")
 
 ```javascript
 function getItems(fruitList, favoriteFruit, ...args) {
-  return [...fruitList, ...args, favoriteFruit]
+  return [...fruitList, ...args, favoriteFruit];
 }
 
-getItems(["banana", "apple"], "pear", "orange")
+getItems(["banana", "apple"], "pear", "orange");
 ```
 
 Приведенный выше пример работает. Это возвращает массив `[ 'banana', 'apple', 'orange', 'pear' ]`
@@ -3050,14 +3050,14 @@ getItems(["banana", "apple"], "pear", "orange")
 
 ```javascript
 function nums(a, b) {
-  if (a > b) console.log('a is bigger')
-  else console.log('b is bigger')
-  return
-    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))
+console.log(nums(4, 2));
+console.log(nums(1, 2));
 ```
 
 - A: `a is bigger`, `6` and `b is bigger`, `3`
@@ -3075,8 +3075,8 @@ console.log(nums(1, 2))
 Здесь мы написали инструкцию `return` и другое значение `a + b` в новой строке. Однако, поскольку это новая линия, движок не знает, что это на самом деле значение, которое мы хотели бы вернуть. Вместо этого он автоматически добавляет точку с запятой после `return`. Вы можете увидеть это как:
 
 ```javascript
-  return;
-  a + b
+return;
+a + b;
 ```
 
 Это означает, что `a + b` никогда не достигается, так как функция перестает выполняться после ключевого слова `return`. Если значение не возвращается, как здесь, функция возвращает значение `undefined`. Обратите внимание, что после операторов `if / else` автоматической вставки нет!
@@ -3091,18 +3091,18 @@ console.log(nums(1, 2))
 ```javascript
 class Person {
   constructor() {
-    this.name = 'Lydia'
+    this.name = "Lydia";
   }
 }
 
 Person = class AnotherPerson {
   constructor() {
-    this.name = 'Sarah'
+    this.name = "Sarah";
   }
-}
+};
 
-const member = new Person()
-console.log(member.name)
+const member = new Person();
+console.log(member.name);
 ```
 
 - A: `"Lydia"`
@@ -3126,11 +3126,11 @@ console.log(member.name)
 
 ```javascript
 const info = {
-  [Symbol('a')]: 'b'
-}
+  [Symbol("a")]: "b",
+};
 
-console.log(info)
-console.log(Object.keys(info))
+console.log(info);
+console.log(Object.keys(info));
 ```
 
 - A: `{Symbol('a'): 'b'}` and `["{Symbol('a')"]`
@@ -3185,7 +3185,7 @@ console.log(getUser(user))
 
 Следующая функция вернула бы объект:
 
-```const getUser = user => ({ name: user.name, age: user.age })```
+`const getUser = user => ({ name: user.name, age: user.age })`
 
 </p>
 </details>
@@ -3195,9 +3195,9 @@ console.log(getUser(user))
 ###### 99. Какой будет вывод?
 
 ```javascript
-const name = 'Lydia'
+const name = "Lydia";
 
-console.log(name())
+console.log(name());
 ```
 
 - A: `SyntaxError`
@@ -3227,8 +3227,8 @@ ReferenceErrors генерируется, когда JavaScript не может
 ```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`
@@ -3253,11 +3253,11 @@ You should${'' && `n't`} see a therapist after so much JavaScript lol`
 ###### 101. Какое значение будет на выходе?
 
 ```javascript
-const one = (false || {} || null)
-const two = (null || false || '')
-const three = ([] || 0 || true)
+const one = false || {} || null;
+const two = null || false || "";
+const three = [] || 0 || true;
 
-console.log(one, two, three)
+console.log(one, two, three);
 ```
 
 - A: `false` `null` `[]`
@@ -3286,20 +3286,20 @@ 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')
+  myPromise().then((res) => console.log(res));
+  console.log("second");
 }
 
 async function secondFunction() {
-  console.log(await myPromise())
-  console.log('second')
+  console.log(await myPromise());
+  console.log("second");
 }
 
-firstFunction()
-secondFunction()
+firstFunction();
+secondFunction();
 ```
 
 - A: `I have resolved!`, `second` and `I have resolved!`, `second`
@@ -3330,14 +3330,14 @@ secondFunction()
 ###### 103. Какое значение будет на выходе?
 
 ```javascript
-const set = new Set()
+const set = new Set();
 
-set.add(1)
-set.add('Lydia')
-set.add({ name: 'Lydia' })
+set.add(1);
+set.add("Lydia");
+set.add({ name: "Lydia" });
 
 for (let item of set) {
-  console.log(item + 2)
+  console.log(item + 2);
 }
 ```
 
@@ -3367,7 +3367,7 @@ for (let item of set) {
 ###### 104. Чему равно значение?
 
 ```javascript
-Promise.resolve(5)
+Promise.resolve(5);
 ```
 
 - A: `5`
@@ -3394,15 +3394,15 @@ 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)
+compareMembers(person);
 ```
 
 - A: `Not the same!`
@@ -3437,11 +3437,11 @@ const colorConfig = {
   green: true,
   black: true,
   yellow: false,
-}
+};
 
-const colors = ['pink', 'red', 'blue']
+const colors = ["pink", "red", "blue"];
 
-console.log(colorConfig.colors[1])
+console.log(colorConfig.colors[1]);
 ```
 
 - A: `true`
@@ -3468,7 +3468,7 @@ JavaScript интерпретирует (или распаковывает) оп
 ###### 107. Чему равно значение?
 
 ```javascript
-console.log('❤️' === '❤️')
+console.log("❤️" === "❤️");
 ```
 
 - A: `true`
@@ -3489,19 +3489,19 @@ 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`
 - B: `map` `reduce` `slice` `splice`
-- C: `map` `slice` `splice` 
+- C: `map` `slice` `splice`
 - D: `splice`
 
 <details><summary><b>Ответ</b></summary>
@@ -3521,17 +3521,17 @@ emojis.splice(1, 2, '✨')
 ###### 109. Какое значение будет на выходе?
 
 ```javascript
-const food = ['🍕', '🍫', '🥑', '🍔']
-const info = { favoriteFood: food[0] }
+const food = ["🍕", "🍫", "🥑", "🍔"];
+const info = { favoriteFood: food[0] };
 
-info.favoriteFood = '🍝'
+info.favoriteFood = "🍝";
 
-console.log(food)
+console.log(food);
 ```
 
 - A: `['🍕', '🍫', '🥑', '🍔']`
 - B: `['🍝', '🍫', '🥑', '🍔']`
-- C: `['🍝', '🍕', '🍫', '🥑', '🍔']` 
+- C: `['🍝', '🍕', '🍫', '🥑', '🍔']`
 - D: `ReferenceError`
 
 <details><summary><b>Ответ</b></summary>
@@ -3553,7 +3553,7 @@ console.log(food)
 ###### 110. Что делает этот метод?
 
 ```javascript
-JSON.parse()
+JSON.parse();
 ```
 
 - A: Разбирает JSON в значение JavaScript
@@ -3570,16 +3570,16 @@ JSON.parse()
 
 ```javascript
 // Преобразование числа в допустимый JSON, затем преобразование строки JSON в значение JavaScript:
-const jsonNumber = JSON.stringify(4) // '4'
-JSON.parse(jsonNumber) // 4
+const jsonNumber = JSON.stringify(4); // '4'
+JSON.parse(jsonNumber); // 4
 
 // Преобразование значения массива в допустимый JSON, затем разбор строки JSON в значение JavaScript:
-const jsonArray = JSON.stringify([1, 2, 3]) // '[1, 2, 3]'
-JSON.parse(jsonArray) // [1, 2, 3]
+const jsonArray = JSON.stringify([1, 2, 3]); // '[1, 2, 3]'
+JSON.parse(jsonArray); // [1, 2, 3]
 
 // Преобразование объекта в допустимый JSON, затем преобразование строки JSON в значение JavaScript:
-const jsonArray = JSON.stringify({ name: 'Lydia' }) // '{"name":"Lydia"}'
-JSON.parse(jsonArray) // { name: 'Lydia' }
+const jsonArray = JSON.stringify({ name: "Lydia" }); // '{"name":"Lydia"}'
+JSON.parse(jsonArray); // { name: 'Lydia' }
 ```
 
 </p>
@@ -3587,17 +3587,17 @@ JSON.parse(jsonArray) // { name: 'Lydia' }
 
 ---
 
-###### 111. Какое значение будет на выходе? 
+###### 111. Какое значение будет на выходе?
 
 ```javascript
-let name = 'Lydia'
+let name = "Lydia";
 
 function getName() {
-  console.log(name)
-  let name = 'Sarah'
+  console.log(name);
+  let name = "Sarah";
 }
 
-getName()
+getName();
 ```
 
 - A: Lydia
@@ -3617,13 +3617,13 @@ getName()
 Если бы мы не объявили переменную `name` в функции `getName`, движок javascript посмотрел бы вниз по _цепочки области действия_. Внешняя область имеет переменную с именем `name` со значением `Lydia`. В этом случае он бы записал `Lydia`.
 
 ```javascript
-let name = 'Lydia'
+let name = "Lydia";
 
 function getName() {
-  console.log(name)
+  console.log(name);
 }
 
-getName() // Lydia
+getName(); // Lydia
 ```
 
 </p>
@@ -3635,18 +3635,18 @@ 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()
-const two = generatorTwo()
+const one = generatorOne();
+const two = generatorTwo();
 
-console.log(one.next().value)
-console.log(two.next().value)
+console.log(one.next().value);
+console.log(two.next().value);
 ```
 
 - A: `a` and `a`
@@ -3664,17 +3664,17 @@ console.log(two.next().value)
 В `generatorOne` мы получаем весь массив `['a', 'b', 'c']`, используя ключевое слово `yield`. Значение свойства `value` для объекта, возвращаемого методом `next` для `one` (`one.next().value`), равно всему массиву `['a', 'b', 'c']`.
 
 ```javascript
-console.log(one.next().value) // ['a', 'b', 'c']
-console.log(one.next().value) // undefined
+console.log(one.next().value); // ['a', 'b', 'c']
+console.log(one.next().value); // undefined
 ```
 
 В файле `generatorTwo` мы используем ключевое слово `yield*`. Это означает, что первое полученное значение `two` равно первому полученному значению в итераторе. Итератор - это массив `['a', 'b', 'c']`. Первым полученным значением является `a`, поэтому в первый раз, когда мы вызываем `two.next().value`, возвращается `a`.
 
 ```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
+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>
@@ -3685,7 +3685,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`
@@ -3710,11 +3710,11 @@ console.log(`${(x => x)('I love')} to program`)
 ```javascript
 let config = {
   alert: setInterval(() => {
-    console.log('Alert!')
-  }, 1000)
-}
+    console.log("Alert!");
+  }, 1000),
+};
 
-config = null
+config = null;
 ```
 
 - A: обратный вызов `setInterval` не будет вызван
@@ -3741,17 +3741,17 @@ config = null
 ###### 115. Какие методы вернут значение `'Hello world!'`?
 
 ```javascript
-const myMap = new Map()
-const myFunc = () => 'greeting'
+const myMap = new Map();
+const myFunc = () => "greeting";
 
-myMap.set(myFunc, 'Hello world!')
+myMap.set(myFunc, "Hello world!");
 
 //1
-myMap.get('greeting')
+myMap.get("greeting");
 //2
-myMap.get(myFunc)
+myMap.get(myFunc);
 //3
-myMap.get(() => 'greeting')
+myMap.get(() => "greeting");
 ```
 
 - A: 1
@@ -3778,20 +3778,20 @@ myMap.get(() => 'greeting')
 
 ```javascript
 const person = {
-  name: 'Lydia',
-  age: 21
-}
+  name: "Lydia",
+  age: 21,
+};
 
-const changeAge = (x = { ...person }) => x.age += 1
+const changeAge = (x = { ...person }) => (x.age += 1);
 const changeAgeAndName = (x = { ...person }) => {
-  x.age += 1
-  x.name = 'Sarah'
-}
+  x.age += 1;
+  x.name = "Sarah";
+};
 
-changeAge(person)
-changeAgeAndName()
+changeAge(person);
+changeAgeAndName();
 
-console.log(person)
+console.log(person);
 ```
 
 - A: `{name: "Sarah", age: 22}`
@@ -3819,7 +3819,7 @@ console.log(person)
 
 ```javascript
 function sumValues(x, y, z) {
-	return x + y + z;
+  return x + y + z;
 }
 ```
 
@@ -3870,15 +3870,15 @@ console.log(list[(num += 1)]);
 
 ```javascript
 const person = {
-	firstName: 'Lydia',
-	lastName: 'Hallie',
-	pet: {
-		name: 'Mara',
-		breed: 'Dutch Tulip Hound'
-	},
-	getFullName() {
-		return `${this.firstName} ${this.lastName}`;
-	}
+  firstName: "Lydia",
+  lastName: "Hallie",
+  pet: {
+    name: "Mara",
+    breed: "Dutch Tulip Hound",
+  },
+  getFullName() {
+    return `${this.firstName} ${this.lastName}`;
+  },
 };
 
 console.log(person.pet?.name);
@@ -3912,12 +3912,12 @@ 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!`);
+  console.log(`We don't have to buy bananas!`);
 }
 ```
 
@@ -3931,7 +3931,7 @@ if (groceries.indexOf('banana')) {
 
 #### Ответ: B
 
-Мы передали условие `groceries.indexOf("banana")` в оператор `if`. `groceries.indexOf("banana")` возвращает `0`, что является ложным значением. Поскольку условие в операторе `if` ложно, выполняется код в блоке `else`, и в лог выводится ``We don't have to buy bananas!``.
+Мы передали условие `groceries.indexOf("banana")` в оператор `if`. `groceries.indexOf("banana")` возвращает `0`, что является ложным значением. Поскольку условие в операторе `if` ложно, выполняется код в блоке `else`, и в лог выводится `We don't have to buy bananas!`.
 
 </p>
 </details>
@@ -3942,10 +3942,10 @@ if (groceries.indexOf('banana')) {
 
 ```javascript
 const config = {
-	languages: [],
-	set language(lang) {
-		return this.languages.push(lang);
-	}
+  languages: [],
+  set language(lang) {
+    return this.languages.push(lang);
+  },
 };
 
 console.log(config.language);
@@ -3971,10 +3971,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`
@@ -3999,9 +3999,9 @@ console.log(!typeof name === 'string');
 ###### 123. Что будет на выходе?
 
 ```javascript
-const add = x => y => z => {
-	console.log(x, y, z);
-	return x + y + z;
+const add = (x) => (y) => (z) => {
+  console.log(x, y, z);
+  return x + y + z;
 };
 
 add(4)(5)(6);
@@ -4028,16 +4028,16 @@ add(4)(5)(6);
 
 ```javascript
 async function* range(start, end) {
-	for (let i = start; i <= end; i++) {
-		yield Promise.resolve(i);
-	}
+  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);
-	}
+  const gen = range(1, 3);
+  for await (const item of gen) {
+    console.log(item);
+  }
 })();
 ```
 
@@ -4062,7 +4062,7 @@ async function* range(start, end) {
 
 ```javascript
 const myFunc = ({ x, y, z }) => {
-	console.log(x, y, z);
+  console.log(x, y, z);
 };
 
 myFunc(1, 2, 3);
@@ -4186,8 +4186,8 @@ console.log(isNaN(age));
 const randomValue = 21;
 
 function getInfo() {
-	console.log(typeof randomValue);
-	const randomValue = 'Lydia Hallie';
+  console.log(typeof randomValue);
+  const randomValue = "Lydia Hallie";
 }
 
 getInfo();
@@ -4213,16 +4213,16 @@ getInfo();
 ###### 130. Что будет на выходе?
 
 ```javascript
-const myPromise = Promise.resolve('Woah some cool data');
+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!');
-	}
+  try {
+    console.log(await myPromise);
+  } catch {
+    throw new Error(`Oops didn't work`);
+  } finally {
+    console.log("Oh finally!");
+  }
 })();
 ```
 
@@ -4246,7 +4246,7 @@ const myPromise = Promise.resolve('Woah some cool data');
 ###### 131. Что будет на выходе?
 
 ```javascript
-const emojis = ['🥑', ['✨', '✨', ['🍕', '🍕']]];
+const emojis = ["🥑", ["✨", "✨", ["🍕", "🍕"]]];
 
 console.log(emojis.flat(1));
 ```
@@ -4319,19 +4319,19 @@ console.log(counterOne.count);
 ###### 133. Что будет на выходе?
 
 ```javascript
-const myPromise = Promise.resolve(Promise.resolve('Promise!'));
+const myPromise = Promise.resolve(Promise.resolve("Promise!"));
 
 function funcOne() {
-  myPromise.then(res => res).then(res => console.log(res));
-  setTimeout(() => console.log('Timeout!', 0));
-  console.log('Last line!');
+  myPromise.then((res) => res).then((res) => console.log(res));
+  setTimeout(() => console.log("Timeout!", 0));
+  console.log("Last line!");
 }
 
 async function funcTwo() {
   const res = await myPromise;
   console.log(await res);
-  setTimeout(() => console.log('Timeout!', 0));
-  console.log('Last line!');
+  setTimeout(() => console.log("Timeout!", 0));
+  console.log("Last line!");
 }
 
 funcOne();
@@ -4376,7 +4376,7 @@ export default function sum(x) {
 }
 
 // index.js
-import * as sum from './sum';
+import * as sum from "./sum";
 ```
 
 - A: `sum(4)`
@@ -4393,12 +4393,12 @@ import * as sum from './sum';
 
 ```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);
 ```
 
@@ -4429,13 +4429,13 @@ console.log(info);
 
 ```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;
 ```
 
@@ -4465,7 +4465,7 @@ C помощью Proxy мы можем добавить собственное 
 ###### 136. Какое из перечисленных действий может модифицировать объект `person`?
 
 ```javascript
-const person = { name: 'Lydia Hallie' };
+const person = { name: "Lydia Hallie" };
 
 Object.seal(person);
 ```
@@ -4493,9 +4493,9 @@ Object.seal(person);
 
 ```javascript
 const person = {
-  name: 'Lydia Hallie',
+  name: "Lydia Hallie",
   address: {
-    street: '100 Main St',
+    street: "100 Main St",
   },
 };
 
@@ -4524,7 +4524,7 @@ Object.freeze(person);
 ###### 138. Что будет на выходе?
 
 ```javascript
-const add = x => x + x;
+const add = (x) => x + x;
 
 function myFunc(num = 2, value = add(num)) {
   console.log(num, value);
@@ -4557,21 +4557,21 @@ myFunc(3);
 
 ```javascript
 class Counter {
-  #number = 10
+  #number = 10;
 
   increment() {
-    this.#number++
+    this.#number++;
   }
 
   getNum() {
-    return this.#number
+    return this.#number;
   }
 }
 
-const counter = new Counter()
-counter.increment()
+const counter = new Counter();
+counter.increment();
 
-console.log(counter.#number)
+console.log(counter.#number);
 ```
 
 - A: `10`
@@ -4595,8 +4595,8 @@ console.log(counter.#number)
 
 ```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) {
@@ -4639,8 +4639,8 @@ obj.next(); // { value: "Lisa", done: false }
 
 ```javascript
 const person = {
-  name: 'Lydia Hallie',
-  hobbies: ['coding'],
+  name: "Lydia Hallie",
+  hobbies: ["coding"],
 };
 
 function addHobby(hobby, hobbies = person.hobbies) {
@@ -4648,9 +4648,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);
 ```
@@ -4719,11 +4719,11 @@ const pet = new Flamingo();
 ###### 143. Какой/какие из вариантов приведет к ошибке?
 
 ```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;
 ```
 
@@ -4778,11 +4778,11 @@ const person = {
 let count = 0;
 const nums = [0, 1, 2, 3];
 
-nums.forEach(num => {
-	if (num) count += 1
-})
+nums.forEach((num) => {
+  if (num) count += 1;
+});
 
-console.log(count)
+console.log(count);
 ```
 
 - A: 1
@@ -4806,12 +4806,12 @@ console.log(count)
 
 ```javascript
 function getFruit(fruits) {
-	console.log(fruits?.[1]?.[1])
+  console.log(fruits?.[1]?.[1]);
 }
 
-getFruit([['🍊', '🍌'], ['🍍']])
-getFruit()
-getFruit([['🍍'], ['🍊', '🍌']])
+getFruit([["🍊", "🍌"], ["🍍"]]);
+getFruit();
+getFruit([["🍍"], ["🍊", "🍌"]]);
 ```
 
 - A: `null`, `undefined`, 🍌
@@ -4841,19 +4841,19 @@ getFruit([['🍍'], ['🍊', '🍌']])
 
 ```javascript
 class Calc {
-	constructor() {
-		this.count = 0 
-	}
+  constructor() {
+    this.count = 0;
+  }
 
-	increase() {
-		this.count ++
-	}
+  increase() {
+    this.count++;
+  }
 }
 
-const calc = new Calc()
-new Calc().increase()
+const calc = new Calc();
+new Calc().increase();
 
-console.log(calc.count)
+console.log(calc.count);
 ```
 
 - A: `0`
@@ -4877,25 +4877,25 @@ console.log(calc.count)
 
 ```javascript
 const user = {
-	email: "e@mail.com",
-	password: "12345"
-}
+  email: "e@mail.com",
+  password: "12345",
+};
 
 const updateUser = ({ email, password }) => {
-	if (email) {
-		Object.assign(user, { email })
-	}
+  if (email) {
+    Object.assign(user, { email });
+  }
 
-	if (password) {
-		user.password = password
-	}
+  if (password) {
+    user.password = password;
+  }
 
-	return user
-}
+  return user;
+};
 
-const updatedUser = updateUser({ email: "new@email.com" })
+const updatedUser = updateUser({ email: "new@email.com" });
 
-console.log(updatedUser === user)
+console.log(updatedUser === user);
 ```
 
 - A: `false`
@@ -4918,13 +4918,13 @@ console.log(updatedUser === user)
 ###### 149. Что будет на выходе?
 
 ```javascript
-const fruit = ['🍌', '🍊', '🍎']
+const fruit = ["🍌", "🍊", "🍎"];
 
-fruit.slice(0, 1)
-fruit.splice(0, 1)
-fruit.unshift('🍇')
+fruit.slice(0, 1);
+fruit.splice(0, 1);
+fruit.unshift("🍇");
 
-console.log(fruit)
+console.log(fruit);
 ```
 
 - A: `['🍌', '🍊', '🍎']`
@@ -4950,13 +4950,13 @@ console.log(fruit)
 
 ```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])
+console.log(animals[dog]);
 ```
 
 - A: `{ emoji: "🐶", name: "Mara" }`
@@ -4986,14 +4986,14 @@ console.log(animals[dog])
 
 ```javascript
 const user = {
-	email: "my@email.com",
-	updateEmail: email => {
-		this.email = email
-	}
-}
+  email: "my@email.com",
+  updateEmail: (email) => {
+    this.email = email;
+  },
+};
 
-user.updateEmail("new@email.com")
-console.log(user.email)
+user.updateEmail("new@email.com");
+console.log(user.email);
 ```
 
 - A: `my@email.com`
@@ -5016,20 +5016,20 @@ console.log(user.email)
 ###### 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])
-	const res2  = await Promise.all([promise3, promise4])
-	return [res1, res2]
-}
+  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))
+  .then((res) => console.log(res))
+  .catch((err) => console.log(err));
 ```
 
 - A: `[['First', 'Second'], ['Fourth']]`
@@ -5052,13 +5052,16 @@ runPromises()
 ###### 153. Каким должно быть значение `method` для регистрации `{ name: "Lydia", age: 22 }`?
 
 ```javascript
-const keys = ["name", "age"]
-const values = ["Lydia", 22]
+const keys = ["name", "age"];
+const values = ["Lydia", 22];
 
-const method = /* ?? */
-Object[method](keys.map((_, i) => {
-	return [keys[i], values[i]]
-})) // { name: "Lydia", age: 22 }
+const method =
+  /* ?? */
+  Object[method](
+    keys.map((_, i) => {
+      return [keys[i], values[i]];
+    })
+  ); // { name: "Lydia", age: 22 }
 ```
 
 - A: `entries`
@@ -5083,18 +5086,18 @@ Object[method](keys.map((_, i) => {
 ###### 154. Что будет на выходе?
 
 ```javascript
-const createMember = ({ email, address = {}}) => {
-	const validEmail = /.+\@.+\..+/.test(email)
-	if (!validEmail) throw new Error("Valid email pls")
+const createMember = ({ email, address = {} }) => {
+  const validEmail = /.+\@.+\..+/.test(email);
+  if (!validEmail) throw new Error("Valid email pls");
 
-	return {
-		email,
-		address: address ? address : null
-	}
-}
+  return {
+    email,
+    address: address ? address : null,
+  };
+};
 
-const member = createMember({ email: "my@email.com" })
-console.log(member)
+const member = createMember({ email: "my@email.com" });
+console.log(member);
 ```
 
 - A: `{ email: "my@email.com", address: null }`
@@ -5117,13 +5120,13 @@ console.log(member)
 ###### 155. Что будет на выходе?
 
 ```javascript
-let randomValue = { name: "Lydia" }
-randomValue = 23
+let randomValue = { name: "Lydia" };
+randomValue = 23;
 
 if (!typeof randomValue === "string") {
-	console.log("It's not a string!")
+  console.log("It's not a string!");
 } else {
-	console.log("Yay it's a string!")
+  console.log("Yay it's a string!");
 }
 ```
 
diff --git a/sq-KS/README_sq_KS.md b/sq-KS/README_sq_KS.md
index aa1eb9dc..8446493c 100644
--- a/sq-KS/README_sq_KS.md
+++ b/sq-KS/README_sq_KS.md
@@ -10,9 +10,10 @@ Nga konceptet bazike tek ato të avancuara: testo se sa mirë e njeh JavaScript-
 
 Mos hezitoni të më kontaktoni! 😊
 <a href="https://www.instagram.com/theavocoder">Instagram</a> || <a href="https://www.twitter.com/lydiahallie">Twitter</a> || <a href="https://www.linkedin.com/in/lydia-hallie">LinkedIn</a> || <a href="https://www.lydiahallie.dev">Blog</a>
+
 </div>
 
-| Ndjehuni të lirë të i përdorni në projektet e juaja |😃  Do të e vlerësoja shumë referencimin tuaj në ketë repositori, unë i krijoj pyetjet dhe poashtu edhe përgjigjet (lol) dhe komuniteti me ndihmon shumë të e përmirësoj dhe të mirëmbajë! 💪🏼 Faleminderit!
+| Ndjehuni të lirë të i përdorni në projektet e juaja |😃 Do të e vlerësoja shumë referencimin tuaj në ketë repositori, unë i krijoj pyetjet dhe poashtu edhe përgjigjet (lol) dhe komuniteti me ndihmon shumë të e përmirësoj dhe të mirëmbajë! 💪🏼 Faleminderit!
 
 ---
 
@@ -32,6 +33,7 @@ Mos hezitoni të më kontaktoni! 😊
 - [🇳🇱 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)
@@ -46,13 +48,13 @@ Mos hezitoni të më kontaktoni! 😊
 
 ---
 
-###### 1.  Cila është vlera e saj?
+###### 1. Cila është vlera e saj?
 
 ```javascript
 function sayHi() {
   console.log(name);
   console.log(age);
-  var name = 'Lydia';
+  var name = "Lydia";
   let age = 21;
 }
 
@@ -78,7 +80,7 @@ Variablat me fjalën kyçe `let` (dhe `const`) hoistohen, por ndryshe nga `var`,
 
 ---
 
-###### 2.  Cila është vlera e saj?
+###### 2. Cila është vlera e saj?
 
 ```javascript
 for (var i = 0; i < 3; i++) {
@@ -99,7 +101,7 @@ for (let i = 0; i < 3; i++) {
 
 #### Përgjigja: C
 
-Për shkak të ***event queque*** në JavaScript, funksioni callback `setTimeout` thirret pas ekzekutimit të unazës. Pasi që variabla `i` në iterimin e parë u deklarua duke përdorur fjalën kyçe `var`, kjo vlerë ishte globale. Gjatë unazës, ne rritëm vlerën e `i` me `1` çdo herë, duke përdorur operatorin unar `++`. Deri në kohën që funksioni callback `setTimeout` u thirr, `i` ishte e barabartë me `3` në unazën e parë.
+Për shkak të **_event queque_** në JavaScript, funksioni callback `setTimeout` thirret pas ekzekutimit të unazës. Pasi që variabla `i` në iterimin e parë u deklarua duke përdorur fjalën kyçe `var`, kjo vlerë ishte globale. Gjatë unazës, ne rritëm vlerën e `i` me `1` çdo herë, duke përdorur operatorin unar `++`. Deri në kohën që funksioni callback `setTimeout` u thirr, `i` ishte e barabartë me `3` në unazën e parë.
 
 Në unazën e dytë, variabla `i` u deklarua duke përdorur fjalën kyçe `let`: variablat e deklaruara me fjalën kyçe `let` (dhe `const`) janë të qasshme në bllok (një bllok është çdo gjë mes `{ }`). Gjatë çdo iteracioni, `i` do të ketë një vlerë të re, dhe çdo vlerë është e qasshme brenda unazës.
 
@@ -148,7 +150,7 @@ Në funksionet shigjeta, fjala kyçe `this` referohet në qasjen në rrethinën
 
 ```javascript
 +true;
-!'Lydia';
+!"Lydia";
 ```
 
 - A: `1` and `false`
@@ -173,11 +175,11 @@ Vargu i karaktereve (stringu) `'Lydia'` konsiderohet si vlerë `true`. Çfarë n
 
 ```javascript
 const bird = {
-  size: 'small',
+  size: "small",
 };
 
 const mouse = {
-  name: 'Mickey',
+  name: "Mickey",
   small: true,
 };
 ```
@@ -208,11 +210,11 @@ Megjithatë, me notacionin pikë, kjo nuk ndodh. `mouse` nuk ka një çelës të
 ###### 6. Cila është vlera e saj?
 
 ```javascript
-let c = { greeting: 'Hey!' };
+let c = { greeting: "Hey!" };
 let d;
 
 d = c;
-c.greeting = 'Hello';
+c.greeting = "Hello";
 console.log(d.greeting);
 ```
 
@@ -266,7 +268,7 @@ console.log(b === c);
 
 Kur përdorim operatorin `==` (operatorin i barazimit), ai kontrollon vetëm nëse ka të njëjtën _vlerë_. Të dy kanë vlerën `3`, kështu që kthen `true`.
 
-Megjithatë, kur përdorim operatorin `===` (operatori i barazisë strikte), të dy vlerat dhe tipi i tyre duhet të jenë të njëjta. Nuk është: `new Number()` nuk është një numër, është një __objekt__. Të dy kthejnë `false`.
+Megjithatë, kur përdorim operatorin `===` (operatori i barazisë strikte), të dy vlerat dhe tipi i tyre duhet të jenë të njëjta. Nuk është: `new Number()` nuk është një numër, është një **objekt**. Të dy kthejnë `false`.
 
 </p>
 </details>
@@ -282,13 +284,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`
@@ -343,10 +345,10 @@ Për të shmangur këtë, ne mund të përdorim `"use strict"`. Kjo siguron që
 
 ```javascript
 function bark() {
-  console.log('Woof!');
+  console.log("Woof!");
 }
 
-bark.animal = 'dog';
+bark.animal = "dog";
 ```
 
 - A: Asgjë, gjithçka është në rregull!
@@ -376,8 +378,8 @@ function Person(firstName, lastName) {
   this.lastName = lastName;
 }
 
-const member = new Person('Lydia', 'Hallie');
-Person.getFullName = function() {
+const member = new Person("Lydia", "Hallie");
+Person.getFullName = function () {
   return `${this.firstName} ${this.lastName}`;
 };
 
@@ -399,7 +401,7 @@ Në JavaScript, funksionet janë objekte dhe për këtë arsye metoda `getFullNa
 Nëse dëshironi që një metodë të jetë e qasshme për të gjitha instancat e objektit, duhet ta shtoni atë në vetinë e quajtur "prototype":
 
 ```js
-Person.prototype.getFullName = function() {
+Person.prototype.getFullName = function () {
   return `${this.firstName} ${this.lastName}`;
 };
 ```
@@ -417,8 +419,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 +490,7 @@ function sum(a, b) {
   return a + b;
 }
 
-sum(1, '2');
+sum(1, "2");
 ```
 
 - A: `NaN`
@@ -501,7 +503,7 @@ sum(1, '2');
 
 #### Përgjigja: C
 
-JavaScript është gjuhë e shkruar në mënyrë dinamike __dynamically typed language__: ne nuk specifikojmë se çfarë tipe janë variablat e caktuara. Vlerat mund të konvertohen automatikisht në një tip tjetër pa e ditur ju dhe ky proces quhet _implicit type coercion_ (shndërrimi i tipit në mënyrë të nënkuptuar). __Coercion__ është shndërrimi nga një tip në një tjetër.
+JavaScript është gjuhë e shkruar në mënyrë dinamike **dynamically typed language**: ne nuk specifikojmë se çfarë tipe janë variablat e caktuara. Vlerat mund të konvertohen automatikisht në një tip tjetër pa e ditur ju dhe ky proces quhet _implicit type coercion_ (shndërrimi i tipit në mënyrë të nënkuptuar). **Coercion** është shndërrimi nga një tip në një tjetër.
 
 Në këtë shembull, JavaScript konverton numrin `1` në string, në mënyrë që për funksionin të ketë kuptim dhe të kthejë një vlerë. Përgjatë mbledhjes të një tipi number (`1`) dhe një tipi string (`'2'`), numri trajtohet si string. Ne mund ti bashkojmë stringjet si `"Hello" + "World"`, kështu që ajo që po ndodh këtu është `"1" + "2"` e cila kthen "12"`.
 
@@ -555,7 +557,7 @@ function getPersonInfo(one, two, three) {
   console.log(three);
 }
 
-const person = 'Lydia';
+const person = "Lydia";
 const age = 21;
 
 getPersonInfo`${person} is ${age} years old`;
@@ -582,9 +584,9 @@ Nëse përdorni literale të shabllonit (template literals) të etiketuar, vlera
 ```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`);
   }
@@ -644,7 +646,7 @@ Parametri "rest" (`...args`) na lejon të "mbledhim" të gjitha argumentet e mbe
 
 ```javascript
 function getAge() {
-  'use strict';
+  "use strict";
   age = 21;
   console.log(age);
 }
@@ -672,7 +674,7 @@ Me `"use strict"`, mund të siguroheni se nuk do të deklaroni variabla globale
 ###### 21. Sa do të jetë vlera e `sum`?
 
 ```javascript
-const sum = eval('10*10+5');
+const sum = eval("10*10+5");
 ```
 
 - A: `105`
@@ -695,7 +697,7 @@ const sum = eval('10*10+5');
 ###### 22. Sa kohë është e qasshme cool_secret?
 
 ```javascript
-sessionStorage.setItem('cool_secret', 123);
+sessionStorage.setItem("cool_secret", 123);
 ```
 
 - A: Përgjithmonë, e dhëna nuk humb.
@@ -748,12 +750,12 @@ Ju nuk mund ta bëni këtë me 'let' ose 'const' pasi ato kanë qasje në bllok
 ###### 24. Cila është vlera e saj?
 
 ```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);
 ```
 
@@ -779,7 +781,7 @@ Nuk funksionon në këtë mënyrë për një "set". Nuk ka asnjë `'1'` në set-
 ###### 25. Cila është vlera e saj?
 
 ```javascript
-const obj = { a: 'one', b: 'two', a: 'three' };
+const obj = { a: "one", b: "two", a: "three" };
 console.log(obj);
 ```
 
@@ -848,12 +850,12 @@ Deklarata `continue` kalon një iterim nëse një kusht i caktuar kthen `true`.
 
 ```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())
+console.log(name.giveLydiaPizza());
 ```
 
 - A: `"Just give Lydia pizza already!"`
@@ -877,8 +879,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 +912,9 @@ Pastaj ne e printojmë `a[b]` e cila është `a["[object Object]"]`. We sapo e v
 ###### 30. Cila është vlera e saj?
 
 ```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();
@@ -965,9 +967,7 @@ Këtu fillon të funksionojë event loop. Një **event loop** shikon "stack" dhe
 ```html
 <div onclick="console.log('first div')">
   <div onclick="console.log('second div')">
-    <button onclick="console.log('button')">
-      Click!
-    </button>
+    <button onclick="console.log('button')">Click!</button>
   </div>
 </div>
 ```
@@ -993,9 +993,7 @@ Elementi më thellë i mbivendosur që shkaktoi ngjarjen është objektivi i ngj
 
 ```html
 <div onclick="console.log('div')">
-  <p onclick="console.log('p')">
-    Click here!
-  </p>
+  <p onclick="console.log('p')">Click here!</p>
 </div>
 ```
 
@@ -1019,7 +1017,7 @@ Nëse klikojmë `p`, shohim dy dalje: `p` dhe `div`. Gjatë "event propagation",
 ###### 33. Cila është vlera e saj?
 
 ```javascript
-const person = { name: 'Lydia' };
+const person = { name: "Lydia" };
 
 function sayHi(age) {
   return `${this.name} is ${age}`;
@@ -1082,8 +1080,8 @@ FYI: `typeof` mund të kthejë listën e mëposhtme të vlerave: `undefined`, `b
 ```javascript
 0;
 new Number(0);
-('');
-(' ');
+("");
+(" ");
 new Boolean(false);
 undefined;
 ```
@@ -1232,11 +1230,14 @@ Ajo që e dallon një tip primitiv nga një objekt është se primitivët nuk ka
 ###### 40. Cila është vlera e saj?
 
 ```javascript
-[[0, 1], [2, 3]].reduce(
+[
+  [0, 1],
+  [2, 3],
+].reduce(
   (acc, cur) => {
     return acc.concat(cur);
   },
-  [1, 2],
+  [1, 2]
 );
 ```
 
@@ -1263,7 +1264,7 @@ Pastaj, `[1, 2, 0, 1]` është `acc` dhe `[2, 3]` është `cur`. I bashkojmë at
 
 ```javascript
 !!null;
-!!'';
+!!"";
 !!1;
 ```
 
@@ -1291,7 +1292,7 @@ Pastaj, `[1, 2, 0, 1]` është `acc` dhe `[2, 3]` është `cur`. I bashkojmë at
 ###### 42. Çfarë do të kthejë në browser funksioni `setInterval`?
 
 ```javascript
-setInterval(() => console.log('Hi'), 1000);
+setInterval(() => console.log("Hi"), 1000);
 ```
 
 - A: një id unike
@@ -1314,7 +1315,7 @@ Kthen një id unike. Kjo id mund të përdoret për të pastruar intervalin me f
 ###### 43. Çfarë do të kthehet si rezultat?
 
 ```javascript
-[...'Lydia'];
+[..."Lydia"];
 ```
 
 - A: `["L", "y", "d", "i", "a"]`
@@ -1334,7 +1335,7 @@ Stringu është i iterueshëm. Operatori i përhapjes (spread operator) iteron 
 
 ---
 
-###### 44.  Cila është vlera e saj?
+###### 44. Cila është vlera e saj?
 
 ```javascript
 function* generator(i) {
@@ -1373,14 +1374,14 @@ Pastaj, ne e thirrim funksionin përsëri me metodën `next()`. Fillon dhe vazhd
 
 ```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));
+Promise.race([firstPromise, secondPromise]).then((res) => console.log(res));
 ```
 
 - A: `"one"`
@@ -1403,7 +1404,7 @@ Kur i kalojmë premtime (promises) të shumta metodës `Promise.race`, ajo zgjid
 ###### 46. Cila është vlera e saj?
 
 ```javascript
-let person = { name: 'Lydia' };
+let person = { name: "Lydia" };
 const members = [person];
 person = null;
 
@@ -1443,7 +1444,7 @@ Ne po e modifikojmë vetëm vlerën e variblës `person`, dhe jo të elementit t
 
 ```javascript
 const person = {
-  name: 'Lydia',
+  name: "Lydia",
   age: 21,
 };
 
@@ -1472,7 +1473,7 @@ Me unazën `for-in`, ne mund të iterojmë përgjatë çelësave të objektit, n
 ###### 48. Cila është vlera e saj?
 
 ```javascript
-console.log(3 + 4 + '5');
+console.log(3 + 4 + "5");
 ```
 
 - A: `"345"`
@@ -1499,7 +1500,7 @@ Radha e veprimeve matematikore të operatorit është rendi në të cilin përpi
 ###### 49. What's the value of `num`?
 
 ```javascript
-const num = parseInt('7*6', 10);
+const num = parseInt("7*6", 10);
 ```
 
 - A: `42`
@@ -1524,8 +1525,8 @@ Kthehen vetëm numrat e parë në string. Bazuar në _radix (bazë)_ (argumenti
 ###### 50. Cila është vlera e saj?
 
 ```javascript
-[1, 2, 3].map(num => {
-  if (typeof num === 'number') return;
+[1, 2, 3].map((num) => {
+  if (typeof num === "number") return;
   return num * 2;
 });
 ```
@@ -1553,12 +1554,12 @@ Megjithatë, ne nuk kthejmë një vlerë. Kur nuk kthejmë një vlerë nga funks
 
 ```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);
 
@@ -1590,15 +1591,15 @@ Vlera e `person` është objekt. Argumenti `member` ka referencë (të kopjuar)
 
 ```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);
   }
 }
 
@@ -1628,8 +1629,8 @@ Me deklaratën `catch`, ne mund të specifikojmë se çfarë të bëjmë nëse n
 
 ```javascript
 function Car() {
-  this.make = 'Lamborghini';
-  return { make: 'Maserati' };
+  this.make = "Lamborghini";
+  return { make: "Maserati" };
 }
 
 const myCar = new Car();
@@ -1703,11 +1704,11 @@ class Dog {
   }
 }
 
-Dog.prototype.bark = function() {
+Dog.prototype.bark = function () {
   console.log(`Woof I am ${this.name}`);
 };
 
-const pet = new Dog('Mara');
+const pet = new Dog("Mara");
 
 pet.bark();
 
@@ -1772,7 +1773,7 @@ export default counter;
 
 ```javascript
 // index.js
-import myCounter from './counter';
+import myCounter from "./counter";
 
 myCounter += 1;
 
@@ -1801,7 +1802,7 @@ Kur tentojmë të rrisim vlerën e `myCounter`, do të marrim një error: `myCou
 ###### 58. Cila është vlera e saj?
 
 ```javascript
-const name = 'Lydia';
+const name = "Lydia";
 age = 21;
 
 console.log(delete name);
@@ -1818,7 +1819,7 @@ console.log(delete age);
 
 #### Përgjigja: A
 
-Operatori "delete" kthen një vlerë booleane: `true` në fshirje të suksesshme, përndryshe do të kthejë `false`. Megjithatë, variablat e deklaruara me fjalën kyçe `var`, `const` ose `let` nuk mund të fshihen duke përdorur operatorin  `delete`.
+Operatori "delete" kthen një vlerë booleane: `true` në fshirje të suksesshme, përndryshe do të kthejë `false`. Megjithatë, variablat e deklaruara me fjalën kyçe `var`, `const` ose `let` nuk mund të fshihen duke përdorur operatorin `delete`.
 
 Variabla `name` u deklarua me fjalën kyçe `const`, kështu që fshirja e saj nuk ishte e suksesshme: u kthye `false`. Kur vendosëm `age` të barabartë me `21`, ne në fakt shtuam një veti të quajtur `age` në objektin global. Ju mund të fshini me sukses vetitë nga objektet në këtë mënyrë, gjithashtu edhe objektin global, kështu që `delete age` kthen `true`.
 
@@ -1872,7 +1873,7 @@ Kjo do të thotë se vlera e `y` është e barabartë me vlerën e parë në arr
 ###### 60. Cila është vlera e saj?
 
 ```javascript
-const user = { name: 'Lydia', age: 21 };
+const user = { name: "Lydia", age: 21 };
 const admin = { admin: true, ...user };
 
 console.log(admin);
@@ -1898,9 +1899,9 @@ console.log(admin);
 ###### 61. Cila është vlera e saj?
 
 ```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));
@@ -1929,12 +1930,12 @@ Vetitë e shtuara duke përdorur metodën `defineProperty` janë të pandryshues
 
 ```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);
 ```
 
@@ -1965,7 +1966,7 @@ Nëse zëvendësuesi është një _funksion_, ky funksion thirret në çdo veti
 let num = 10;
 
 const increaseNumber = () => num++;
-const increasePassedNumber = number => number++;
+const increasePassedNumber = (number) => number++;
 
 const num1 = increaseNumber();
 const num2 = increasePassedNumber(num1);
@@ -1986,7 +1987,7 @@ console.log(num2);
 
 Operatori unar `++` fillimisht kthen vlerën e operandit, pastaj e rrit vlerën e tij. Vlera e `num1` është `10`, meqenëse funksioni `increaseNumber` fillimisht kthen vlerën e `num`, e cila është `10`, dhe vetëm pastaj e rrit vlerën e `num`.
 
-`num2` është `10`, pasi ne e kaluam `num1` si argument tek `increasePassedNumber`. `number` është i barabartë me `10`(vlera e  `num1`). Përsëri, operatori unar `++` _së pari kthen_ vlerën e operandit, dhe pastaj rrit vlerën e tij. Vlera e `number` është `10`, kështu që `num2` është e barabartë me `10`.
+`num2` është `10`, pasi ne e kaluam `num1` si argument tek `increasePassedNumber`. `number` është i barabartë me `10`(vlera e `num1`). Përsëri, operatori unar `++` _së pari kthen_ vlerën e operandit, dhe pastaj rrit vlerën e tij. Vlera e `number` është `10`, kështu që `num2` është e barabartë me `10`.
 
 </p>
 </details>
@@ -2122,12 +2123,12 @@ Klasa `Labrador` merr dy argumente, `name` meqenëse trashëgon klasën 'Dog', d
 
 ```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;
 ```
 
@@ -2155,7 +2156,7 @@ Ky është një dallimi në mes `require()` në CommonJS dhe `import`! Me `requi
 ```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`
@@ -2178,7 +2179,7 @@ console.log(Symbol('foo') === Symbol('foo'));
 ###### 69. Cila është vlera e saj?
 
 ```javascript
-const name = 'Lydia Hallie';
+const name = "Lydia Hallie";
 console.log(name.padStart(13));
 console.log(name.padStart(2));
 ```
@@ -2205,7 +2206,7 @@ Nëse argumenti i kaluar në metodën `padStart` është më i vogël se gjatës
 ###### 70. Cila është vlera e saj?
 
 ```javascript
-console.log('🥑' + '💻');
+console.log("🥑" + "💻");
 ```
 
 - A: `"🥑💻"`
@@ -2229,11 +2230,11 @@ Me operatorin `+`, ju mund të bashkoni vargjet. Në këtë rast, ne po bashkojm
 
 ```javascript
 function* startGame() {
-  const Përgjigja = yield 'Do you love JavaScript?';
-  if (Përgjigja !== 'Yes') {
+  const Përgjigja = yield "Do you love JavaScript?";
+  if (Përgjigja !== "Yes") {
     return "Oh wow... Guess we're done here";
   }
-  return 'JavaScript loves you back ❤️';
+  return "JavaScript loves you back ❤️";
 }
 
 const game = startGame();
@@ -2271,7 +2272,7 @@ console.log(String.raw`Hello\nworld`);
 - A: `Hello world!`
 - B: `Hello` &nbsp; &nbsp; &nbsp;`world`
 - C: `Hello\nworld`
-- D: `Hello\n`  &nbsp; &nbsp; &nbsp;`world`
+- D: `Hello\n` &nbsp; &nbsp; &nbsp;`world`
 
 <details><summary><b>Përgjigja</b></summary>
 <p>
@@ -2301,7 +2302,7 @@ Në këtë rast, `Hello\nworld` do të printohet.
 
 ```javascript
 async function getData() {
-  return await Promise.resolve('I made it!');
+  return await Promise.resolve("I made it!");
 }
 
 const data = getData();
@@ -2338,7 +2339,7 @@ function addToList(item, list) {
   return list.push(item);
 }
 
-const result = addToList('apple', ['banana']);
+const result = addToList("apple", ["banana"]);
 console.log(result);
 ```
 
@@ -2398,7 +2399,7 @@ Meqenëse `shape` është e ngrirë dhe meqenëse vlera e `x` nuk është një o
 ###### 76. Cila është vlera e saj?
 
 ```javascript
-const { firstName: myName } = { firstName: 'Lydia' };
+const { firstName: myName } = { firstName: "Lydia" };
 
 console.log(firstName);
 ```
@@ -2416,7 +2417,7 @@ console.log(firstName);
 Duke përdorur [sintaksen e funksioneve destruktuese](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment) ne mund të targetojmë vlerat nga vargjet, ose vetitë nga objektet, në variabla të veçanta:
 
 ```javascript
-const { firstName } = { firstName: 'Lydia' };
+const { firstName } = { firstName: "Lydia" };
 // versioni i ES5:
 // var firstName = { firstName: 'Lydia' }.firstName;
 
@@ -2426,7 +2427,7 @@ console.log(firstName); // "Lydia"
 Gjithashtu, një veti mund të targetohet nga një objekt dhe t'i caktohet një variableje me një emër të ndryshëm nga vetia e objektit:
 
 ```javascript
-const { firstName: myName } = { firstName: 'Lydia' };
+const { firstName: myName } = { firstName: "Lydia" };
 // versioni i ES5:
 // var myName = { firstName: 'Lydia' }.firstName;
 
@@ -2436,21 +2437,20 @@ console.log(firstName); // Uncaught ReferenceError: firstName is not defined
 
 Prandaj, `firstName` nuk ekziston si variabël, kështu që tentimi për të qasur vlerën e saj do të ngrejë një `ReferenceError`.
 
-**Shënim:** Kujdes nga vetitë e  `global scope`:
+**Shënim:** Kujdes nga vetitë e `global scope`:
 
 ```javascript
-const { name: myName } = { name: 'Lydia' };
+const { name: myName } = { name: "Lydia" };
 
 console.log(myName); // "lydia"
 console.log(name); // "" ----- Browser psh. Chrome
 console.log(name); // ReferenceError: name is not defined  ----- NodeJS
-
 ```
 
-Kurdo që JavaScript nuk mundet të gjejë një varibël në _current scope_, ngrihet në [Scope chain](https://github.com/getify/You-Dont-Know-JS/blob/2nd-ed/scope-closures/ch3.md) dhe kërkon për të dhe në qoftëse e arrin nivelin më të lartë të shtrirjes (the top-level scope), të quajtur  __Global scope__, dhe ende nuk e gjen do të ngrejë `ReferenceError`.
+Kurdo që JavaScript nuk mundet të gjejë një varibël në _current scope_, ngrihet në [Scope chain](https://github.com/getify/You-Dont-Know-JS/blob/2nd-ed/scope-closures/ch3.md) dhe kërkon për të dhe në qoftëse e arrin nivelin më të lartë të shtrirjes (the top-level scope), të quajtur **Global scope**, dhe ende nuk e gjen do të ngrejë `ReferenceError`.
 
-- Në __Browsers__ si _Chrome_, `name` është _vetia e shtrirjes globale e vjetëruar_. Në këtë shembull, kodi funksionon brenda _global scope_ dhe nuk ka asnjë variabël lokale të përcaktuar nga përdoruesi për `name`, prandaj ai kërkon _variables/properties_ të paracaktuara në shtrirjen globale, në këtë rast shfletuesve, ai kërkon përmes objektit `window`, dhe do të nxjerrë vlerën [window.name](https://developer.mozilla.org/en-US/docs/Web/API/Window/name) e cila është e barabartë me një varg __bosh__.
-- Në __NodeJS__, nuk ka një veçori të tillë në objektin `global`, kështu që përpjekja për të iu qasur një variable joekzistente do të ngrejë një [ReferenceError](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Not_defined).
+- Në **Browsers** si _Chrome_, `name` është _vetia e shtrirjes globale e vjetëruar_. Në këtë shembull, kodi funksionon brenda _global scope_ dhe nuk ka asnjë variabël lokale të përcaktuar nga përdoruesi për `name`, prandaj ai kërkon _variables/properties_ të paracaktuara në shtrirjen globale, në këtë rast shfletuesve, ai kërkon përmes objektit `window`, dhe do të nxjerrë vlerën [window.name](https://developer.mozilla.org/en-US/docs/Web/API/Window/name) e cila është e barabartë me një varg **bosh**.
+- Në **NodeJS**, nuk ka një veçori të tillë në objektin `global`, kështu që përpjekja për të iu qasur një variable joekzistente do të ngrejë një [ReferenceError](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Not_defined).
 
 </p>
 </details>
@@ -2482,12 +2482,12 @@ Funksioni `sum` _gjithmonë_ kthen të njëjtin rezultat. Nëse i kalojmë `1` d
 
 ---
 
-###### 78.  Cila është vlera e saj?
+###### 78. Cila është vlera e saj?
 
 ```javascript
 const add = () => {
   const cache = {};
-  return num => {
+  return (num) => {
     if (num in cache) {
       return `From cache! ${cache[num]}`;
     } else {
@@ -2529,10 +2529,10 @@ Herën e tretë, ne kalojmë `5 * 2` te funksioni i cili llogaritet si `10`. Obj
 
 ---
 
-###### 79.  Cila është vlera e saj?
+###### 79. Cila është vlera e saj?
 
 ```javascript
-const myLifeSummedUp = ['☕', '💻', '🍷', '🍫'];
+const myLifeSummedUp = ["☕", "💻", "🍷", "🍫"];
 
 for (let item in myLifeSummedUp) {
   console.log(item);
@@ -2559,14 +2559,14 @@ Me unazën _for-in_, ne mund të iterojmë në vetitë _e numërueshme_. Në nj
 
 Ku çelësat janë vetitë e numërueshme. `0` `1` `2` `3` printohet.
 
-Me unazën _for-of_, ne mund të iterojmë mbi __iterables__. Një array është një "iterable". Kur iterojmë mbi array, variabla "item" është e barabartë me elementin mbi të cilin po iterojmë aktualisht, "☕"` `"💻"` `"🍷"` `"🍫"` printohet.
+Me unazën _for-of_, ne mund të iterojmë mbi **iterables**. Një array është një "iterable". Kur iterojmë mbi array, variabla "item" është e barabartë me elementin mbi të cilin po iterojmë aktualisht, "☕"` `"💻"` `"🍷"` `"🍫"` printohet.
 
 </p>
 </details>
 
 ---
 
-###### 80.  Cila është vlera e saj?
+###### 80. Cila është vlera e saj?
 
 ```javascript
 const list = [1 + 2, 1 * 2, 1 / 2];
@@ -2592,7 +2592,7 @@ Elementi do të jetë i barabartë me vlerën e kthyer. `1 + 2` kthen `3`, `1 *
 
 ---
 
-###### 81.  Cila është vlera e saj?
+###### 81. Cila është vlera e saj?
 
 ```javascript
 function sayHi(name) {
@@ -2625,16 +2625,16 @@ Në këtë rast, nëse ne nuk kalojmë ndonjë vlerë ose e kalojmë `undefined`
 
 ---
 
-###### 82.  Cila është vlera e saj?
+###### 82. Cila është vlera e saj?
 
 ```javascript
-var status = '😎';
+var status = "😎";
 
 setTimeout(() => {
-  const status = '😍';
+  const status = "😍";
 
   const data = {
-    status: '🥑',
+    status: "🥑",
     getStatus() {
       return this.status;
     },
@@ -2655,25 +2655,25 @@ setTimeout(() => {
 
 #### Përgjigja: B
 
-Vlera e fjalës kyçe `this` varet nga vendi ku e përdorni. Në një __metodë__, si metoda `getStatus`, fjala kyçe `this` i referohet _objektit që i përket metoda_. Metoda i përket objektit `data`, kështu që `this` i referohet objektit `data`. Kur printojmë `this.status`, vetia `status` në objektin `data` printohet, që është `"🥑"`.
+Vlera e fjalës kyçe `this` varet nga vendi ku e përdorni. Në një **metodë**, si metoda `getStatus`, fjala kyçe `this` i referohet _objektit që i përket metoda_. Metoda i përket objektit `data`, kështu që `this` i referohet objektit `data`. Kur printojmë `this.status`, vetia `status` në objektin `data` printohet, që është `"🥑"`.
 
-Me metodën `call`, ne mund të ndryshojmë objektin të cilit i referohet fjala kyçe `this`. Në __funksione__, fjala kyçe `this` i referohet _objektit të cilit i përket funksioni_. Ne deklaruam funksionin `setTimeout` në objektin _global_, kështu që brenda funksionit `setTimeout`, fjala kyçe `this` i referohet objektit _global_. Në objektin global, ekziston një variabël e quajtur _status_ me vlerën `"😎"`. Kur printoni `this.status`, `"😎"` printohet.
+Me metodën `call`, ne mund të ndryshojmë objektin të cilit i referohet fjala kyçe `this`. Në **funksione**, fjala kyçe `this` i referohet _objektit të cilit i përket funksioni_. Ne deklaruam funksionin `setTimeout` në objektin _global_, kështu që brenda funksionit `setTimeout`, fjala kyçe `this` i referohet objektit _global_. Në objektin global, ekziston një variabël e quajtur _status_ me vlerën `"😎"`. Kur printoni `this.status`, `"😎"` printohet.
 
 </p>
 </details>
 
 ---
 
-###### 83.  Cila është vlera e saj?
+###### 83. Cila është vlera e saj?
 
 ```javascript
 const person = {
-  name: 'Lydia',
+  name: "Lydia",
   age: 21,
 };
 
 let city = person.city;
-city = 'Amsterdam';
+city = "Amsterdam";
 
 console.log(person);
 ```
@@ -2701,7 +2701,7 @@ Kur printojmë objektin `person`. objekti i pamodifikuar kthehet.
 
 ---
 
-###### 84.  Cila është vlera e saj?
+###### 84. Cila është vlera e saj?
 
 ```javascript
 function checkAge(age) {
@@ -2737,9 +2737,9 @@ Variablat e deklaruara me fjalët kyçe `const` dhe `let` janë të qasshme vet
 ###### 85. Çfarë lloj informacioni do të printohet?
 
 ```javascript
-fetch('https://www.website.com/api/user/1')
-  .then(res => res.json())
-  .then(res => console.log(res));
+fetch("https://www.website.com/api/user/1")
+  .then((res) => res.json())
+  .then((res) => console.log(res));
 ```
 
 - A: Rezultati i metodës `fetch`.
@@ -2793,7 +2793,7 @@ Kur vendosim `hasName` të barabartë me `name`, ju vendosni `hasName` të barab
 ###### 87. Cila është vlera e saj?
 
 ```javascript
-console.log('I want pizza'[0]);
+console.log("I want pizza"[0]);
 ```
 
 - A: `"""`
@@ -2848,11 +2848,11 @@ Në qoftëse provoni të vendosni një vlerë të paradefinuar të barabartë me
 
 ```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);
 ```
@@ -2885,7 +2885,7 @@ class Person {
   }
 }
 
-const member = new Person('John');
+const member = new Person("John");
 console.log(typeof member);
 ```
 
@@ -2934,7 +2934,7 @@ console.log(newList.push(5));
 
 Metoda `.push` kthen _gjatësinë e re_ të array, jo vetë array! Duke vendosur `newList` të barabartë me `[1, 2, 3].push(4)`, e vendosim `newList` të barabartë me gjatësinë e re të array: `4`.
 
-Pastaj, ne provojmë të përdorim metodën `.push`  në `newList`. Meqenëse `newList` është vlera numerike e `4` ne nuk mund të përdorim metodën `.push`: do të ngrihet TypeError.
+Pastaj, ne provojmë të përdorim metodën `.push` në `newList`. Meqenëse `newList` është vlera numerike e `4` ne nuk mund të përdorim metodën `.push`: do të ngrihet TypeError.
 
 </p>
 </details>
@@ -2945,7 +2945,7 @@ Pastaj, ne provojmë të përdorim metodën `.push`  në `newList`. Meqenëse `n
 
 ```javascript
 function giveLydiaPizza() {
-  return 'Here is pizza!';
+  return "Here is pizza!";
 }
 
 const giveLydiaChocolate = () =>
@@ -2976,7 +2976,7 @@ Funskionet e rregullta, të tillë si funksioni `giveLydiaPizza`, kanë vetinë
 
 ```javascript
 const person = {
-  name: 'Lydia',
+  name: "Lydia",
   age: 21,
 };
 
@@ -3035,7 +3035,7 @@ function getItems(fruitList, favoriteFruit, ...args) {
   return [...fruitList, ...args, favoriteFruit];
 }
 
-getItems(['banana', 'apple'], 'pear', 'orange');
+getItems(["banana", "apple"], "pear", "orange");
 ```
 
 Shembulli i mësipërm funskionon. Do të kthejë array `[ 'banana', 'apple', 'orange', 'pear' ]`
@@ -3049,9 +3049,9 @@ Shembulli i mësipërm funskionon. Do të kthejë array `[ 'banana', 'apple', 'o
 
 ```javascript
 function nums(a, b) {
-  if (a > b) console.log('a is bigger');
-  else console.log('b is bigger');
-  return
+  if (a > b) console.log("a is bigger");
+  else console.log("b is bigger");
+  return;
   a + b;
 }
 
@@ -3069,7 +3069,7 @@ console.log(nums(1, 2));
 
 #### Përgjigja: B
 
-Në JavaScript, nuk e duhet të e shkruajmë pikëpresjen `;` në mënyrë eksplicite, sidoqoftë makina e JavaScript prapë i vendos ato pas deklarimeve. Kjo quhet __Automatic Semicolon Insertion__ (vendosja e pikëpresjes automatikisht). Një deklaratë për shembull mund të jetë variabla, ose fjalët kyçe si `throw`, `return`, `break` etj.
+Në JavaScript, nuk e duhet të e shkruajmë pikëpresjen `;` në mënyrë eksplicite, sidoqoftë makina e JavaScript prapë i vendos ato pas deklarimeve. Kjo quhet **Automatic Semicolon Insertion** (vendosja e pikëpresjes automatikisht). Një deklaratë për shembull mund të jetë variabla, ose fjalët kyçe si `throw`, `return`, `break` etj.
 
 Në këtë rast, ne shkruajtëm deklaratën `return`, dhe vlerën tjetër `a + b` në rresht të ri. Sidoqoftë, meqenëse është rresht i ri, makina nuk e di se në të vërtetë ajo është vlera që ne po dëshirojmë të kthejmë. Në vend se të e llogarisë në atë mënyrë, në mënyrë automatike vendoset `return`. Kjo mund të shikohet edhe si kjo sintaksë:
 
@@ -3090,13 +3090,13 @@ Kjo do të thotë se `a + b` nuk arrihet asnjëherë, meqenëse funksioni ndalon
 ```javascript
 class Person {
   constructor() {
-    this.name = 'Lydia';
+    this.name = "Lydia";
   }
 }
 
 Person = class AnotherPerson {
   constructor() {
-    this.name = 'Sarah';
+    this.name = "Sarah";
   }
 };
 
@@ -3125,7 +3125,7 @@ Ne mund të iu shoqërojmë klasave konstruktorët e tjerë të klasave/funksion
 
 ```javascript
 const info = {
-  [Symbol('a')]: 'b',
+  [Symbol("a")]: "b",
 };
 
 console.log(info);
@@ -3142,9 +3142,9 @@ console.log(Object.keys(info));
 
 #### Përgjigja: D
 
-Një Symbol nuk është i _numërueshëm_. Metoda Object.keys kthen të gjithë çelësat e _numërueshëm në një objekt. Symbol nuk do të jetë i dukshëm, dhe një array i zbrazët do të kthehet. Kur e printojmë objektin në tërësi, të gjitha vetitë janë të dukshme, edhe ato të cilat nuk janë te numërueshme.
+Një Symbol nuk është i _numërueshëm_. Metoda Object.keys kthen të gjithë çelësat e \_numërueshëm në një objekt. Symbol nuk do të jetë i dukshëm, dhe një array i zbrazët do të kthehet. Kur e printojmë objektin në tërësi, të gjitha vetitë janë të dukshme, edhe ato të cilat nuk janë te numërueshme.
 
-Kjo është vetëm një nga shumë vetitë e symbol, përveç përfaqësimit të një vlere krejtësisht unike (e cila parandalon konflikt  në emërtim të objekteve, për shembull kur punoni me 2 librari që duan të shtojnë vetitë në të njëjtin objekt), ju gjithashtu mund të "fshehni" vetitë e objekteve në këtë mënyrë (edhe pse jo plotësisht. Ju mund t'i qaseni simboleve duke përdorur metodën `Object.getOwnPropertySymbols()`).
+Kjo është vetëm një nga shumë vetitë e symbol, përveç përfaqësimit të një vlere krejtësisht unike (e cila parandalon konflikt në emërtim të objekteve, për shembull kur punoni me 2 librari që duan të shtojnë vetitë në të njëjtin objekt), ju gjithashtu mund të "fshehni" vetitë e objekteve në këtë mënyrë (edhe pse jo plotësisht. Ju mund t'i qaseni simboleve duke përdorur metodën `Object.getOwnPropertySymbols()`).
 
 </p>
 </details>
@@ -3194,7 +3194,7 @@ Funskioni i meposhtëm do të kthente një objekt:
 ###### 99. Cila është vlera e saj?
 
 ```javascript
-const name = 'Lydia';
+const name = "Lydia";
 
 console.log(name());
 ```
@@ -3226,8 +3226,8 @@ ReferenceErrors ngrihen kur Javascript-i nuk është në gjendje të gjejë refe
 ```javascript
 // 🎉✨ Kjo është pytja jonë e 100! ✨🎉
 
-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`
@@ -3253,7 +3253,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);
@@ -3285,16 +3285,16 @@ Me operatorin `||`, ne mund të kthejmë vlerën e parë "truthy" të operandit.
 ###### 102. Cila është vlera në dalje?
 
 ```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');
+  myPromise().then((res) => console.log(res));
+  console.log("second");
 }
 
 async function secondFunction() {
   console.log(await myPromise());
-  console.log('second');
+  console.log("second");
 }
 
 firstFunction();
@@ -3332,8 +3332,8 @@ Kjo do të thotë se pret për `myPromise` të zgjidhet me vlerën `I have resol
 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);
@@ -3393,13 +3393,13 @@ Në këtë rast, ne vetëm i kaluam si argument vlerën numerike `5`. Kthen 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);
 ```
@@ -3416,7 +3416,7 @@ compareMembers(person);
 
 Objektet vendosen si argumente në bazë të referencës së tyre. Kur i kontrollojmë objektet me operatorin për barazim strikt (`===`), ne po kontorllojmë referencën e tyre.
 
-Ne e paracaktuam vlerën e  `person2` të barabartë me objektin `person`, dhe e kaluam objektin `person` si vlerë të `person1`.
+Ne e paracaktuam vlerën e `person2` të barabartë me objektin `person`, dhe e kaluam objektin `person` si vlerë të `person1`.
 
 Kjo do të thotë që të dy vlerat kanë referencë të e njejta hapësirë memorike, dhe kështu ato janë të barabarta.
 
@@ -3438,7 +3438,7 @@ const colorConfig = {
   yellow: false,
 };
 
-const colors = ['pink', 'red', 'blue'];
+const colors = ["pink", "red", "blue"];
 
 console.log(colorConfig.colors[1]);
 ```
@@ -3467,7 +3467,7 @@ JavaScript i interpreton deklarimet. Kur përdorim notacionin me kllapa të mëd
 ###### 107. Cila është vlera e saj?
 
 ```javascript
-console.log('❤️' === '❤️');
+console.log("❤️" === "❤️");
 ```
 
 - A: `true`
@@ -3488,14 +3488,14 @@ Në prapavijë, emoji-t janë kode të veçanta. Unikodet për emoji-t e zemrës
 ###### 108. Cila nga këto metoda e modifikon array origjinal?
 
 ```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`
@@ -3520,10 +3520,10 @@ Me motodën `splice`, ne modifikojmë array origjinal duke fshirë, zëvendësua
 ###### 109. Cila është vlera e saj?
 
 ```javascript
-const food = ['🍕', '🍫', '🥑', '🍔'];
+const food = ["🍕", "🍫", "🥑", "🍔"];
 const info = { favoriteFood: food[0] };
 
-info.favoriteFood = '🍝';
+info.favoriteFood = "🍝";
 
 console.log(food);
 ```
@@ -3577,7 +3577,7 @@ const jsonArray = JSON.stringify([1, 2, 3]); // '[1, 2, 3]'
 JSON.parse(jsonArray); // [1, 2, 3]
 
 // Stringifimi i një objekti në JSON valid, pastaj parsimi i JSON stringut në një vlerë të JavaScript:
-const jsonArray = JSON.stringify({ name: 'Lydia' }); // '{"name":"Lydia"}'
+const jsonArray = JSON.stringify({ name: "Lydia" }); // '{"name":"Lydia"}'
 JSON.parse(jsonArray); // { name: 'Lydia' }
 ```
 
@@ -3589,11 +3589,11 @@ JSON.parse(jsonArray); // { name: 'Lydia' }
 ###### 111. Cila është vlera e saj?
 
 ```javascript
-let name = 'Lydia';
+let name = "Lydia";
 
 function getName() {
   console.log(name);
-  let name = 'Sarah';
+  let name = "Sarah";
 }
 
 getName();
@@ -3616,7 +3616,7 @@ Variablat me fjalën kyçe `let` (dhe `const`) ngriten (hoistoh-en), por për da
 Nëse nuk do të kishim deklaruar `name` brenda funksionit `getName`, makina e JavaScript do të kishte shikuar poshtë _zingjirit të shtrirjes_. Fusha e jashtme ka variabël të quajtur `name` me vlerë `Lydia`. Në këtë rast, do të kishte printuat `Lydia`.
 
 ```javascript
-let name = 'Lydia';
+let name = "Lydia";
 
 function getName() {
   console.log(name);
@@ -3634,11 +3634,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();
@@ -3684,7 +3684,7 @@ console.log(two.next().value); // undefined
 ###### 113. Cila është vlera e saj?
 
 ```javascript
-console.log(`${(x => x)('I love')} to program`);
+console.log(`${((x) => x)("I love")} to program`);
 ```
 
 - A: `I love to program`
@@ -3709,7 +3709,7 @@ Shprehjet brenda shablloneve literale vlerësohen së pari. Kjo do të thotë q
 ```javascript
 let config = {
   alert: setInterval(() => {
-    console.log('Alert!');
+    console.log("Alert!");
   }, 1000),
 };
 
@@ -3728,7 +3728,7 @@ config = null;
 
 Zakonisht kur i vendosim objektet të barabarta me `null`, ato objekte mirren nga _garbage collector_ pasi nuk ka më referencë për ato objekte. Megjithatë, meqenëse funksioni callback brenda `setInterval` është një funksion me shigjetë (pra i lidhur me objektin `config`), funksioni callback ende mban një referencë për objektin `config`.
 Për sa kohë ka një referencë, objekti nuk do të merret nga 'garbage collector' (menaxhuesi i memories për të u larguar).
-Meqenëse ky është një interval, vendosja e `config` në '`null` ose `delete` `config.alert` nuk do të mbledhet nga garbage-collector për  intervalin, kështu që intervali do të vazhdojë të thirret.
+Meqenëse ky është një interval, vendosja e `config` në '`null` ose `delete` `config.alert` nuk do të mbledhet nga garbage-collector për intervalin, kështu që intervali do të vazhdojë të thirret.
 Për ta hequr nga memoria duhet të e pastrojmë me `clearInterval(config.alert)`.
 Meqenëse nuk u fshi, funksioni `setInterval` callback do të vazhdojë të thirret çdo 1000ms (1s).
 
@@ -3741,16 +3741,16 @@ Meqenëse nuk u fshi, funksioni `setInterval` callback do të vazhdojë të thir
 
 ```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
@@ -3777,14 +3777,14 @@ Kur shtoni një çift çelës/vlerë duke përdorur metodën `set`, çelësi do
 
 ```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);
@@ -3843,7 +3843,7 @@ Me operatorin spread `...`, me mund të _përhapim_ iteruesit në elemente indiv
 
 ```javascript
 let num = 1;
-const list = ['🥳', '🤠', '🥰', '🤪'];
+const list = ["🥳", "🤠", "🥰", "🤪"];
 
 console.log(list[(num += 1)]);
 ```
@@ -3869,11 +3869,11 @@ Me operandin `+=`, ne po rrisim vlerën e `sum` për `1`. `num` kishte vlerën i
 
 ```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}`;
@@ -3911,10 +3911,10 @@ Me operatorin opsional të zinxhirit `?.`, nuk duhet të kontrollojmë më në m
 ###### 120. Cila është vlera e saj?
 
 ```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!`);
 }
@@ -3970,10 +3970,10 @@ Metoda `language` është metodë `setter` (vendosëse). Vendosësit nuk mbajë
 ###### 122. Cila është vlera e saj?
 
 ```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`
@@ -3998,7 +3998,7 @@ console.log(!typeof name === 'string');
 ###### 123. Cila është vlera e saj?
 
 ```javascript
-const add = x => y => z => {
+const add = (x) => (y) => (z) => {
   console.log(x, y, z);
   return x + y + z;
 };
@@ -4016,7 +4016,7 @@ add(4)(5)(6);
 
 #### Përgjigja: A
 
-Funksioni `add` kthen një funksion shigjete, i cili kthen një funksion shigjete, i cili kthen një funksion shigjete. Funksioni i parë merr një argument `x` me vlerën `4`. Ne e thërrasim funksionin e dytë, i cili merr një argument `y` me vlerën `5`. Pastaj thërrasim funksionin e tretë, i cili merr një argument `z` me vlerën `6`. Kur po provojmë të qasemi në vlerën `x`, `y` dhe `z` brenda funksionit të fundit të shigjetës, makina  JS shkon lart në zinxhirin e shtrirjes për të gjetur vlerat për `x` dhe `y` përkatësisht. Kjo kthen `4` `5` `6`.
+Funksioni `add` kthen një funksion shigjete, i cili kthen një funksion shigjete, i cili kthen një funksion shigjete. Funksioni i parë merr një argument `x` me vlerën `4`. Ne e thërrasim funksionin e dytë, i cili merr një argument `y` me vlerën `5`. Pastaj thërrasim funksionin e tretë, i cili merr një argument `z` me vlerën `6`. Kur po provojmë të qasemi në vlerën `x`, `y` dhe `z` brenda funksionit të fundit të shigjetës, makina JS shkon lart në zinxhirin e shtrirjes për të gjetur vlerat për `x` dhe `y` përkatësisht. Kjo kthen `4` `5` `6`.
 
 </p>
 </details>
@@ -4088,20 +4088,20 @@ 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}`;
 }
 
-console.log(getFine(130, 300))
+console.log(getFine(130, 300));
 ```
 
 - A: The driver drove 130 and has to pay 300
@@ -4124,8 +4124,8 @@ Me metoden `Intl.NumberFormat`, ne mund të formatojmë vlerat numerike në çdo
 ###### 127. Cila është vlera e saj?
 
 ```javascript
-const spookyItems = ['👻', '🎃', '🕸'];
-({ item: spookyItems[3] } = { item: '💀' });
+const spookyItems = ["👻", "🎃", "🕸"];
+({ item: spookyItems[3] } = { item: "💀" });
 
 console.log(spookyItems);
 ```
@@ -4150,7 +4150,7 @@ Duke destrukturuar objektet, ne mund të targetojmë vlerat nga objekti i djatht
 ###### 128. Cila është vlera e saj?
 
 ```javascript
-const name = 'Lydia Hallie';
+const name = "Lydia Hallie";
 const age = 21;
 
 console.log(Number.isNaN(name));
@@ -4186,7 +4186,7 @@ const randomValue = 21;
 
 function getInfo() {
   console.log(typeof randomValue);
-  const randomValue = 'Lydia Hallie';
+  const randomValue = "Lydia Hallie";
 }
 
 getInfo();
@@ -4212,7 +4212,7 @@ Variablat e deklaruara me fjalën kyçe `const` nuk janë të referueshme para i
 ###### 130. Cila është vlera e saj?
 
 ```javascript
-const myPromise = Promise.resolve('Woah some cool data');
+const myPromise = Promise.resolve("Woah some cool data");
 
 (async () => {
   try {
@@ -4220,7 +4220,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!");
   }
 })();
 ```
@@ -4245,7 +4245,7 @@ Në bllokun `try`, ne jemi duke printuar vlerën e pritur të variablës `myProm
 ###### 131. Cila është vlera e saj?
 
 ```javascript
-const emojis = ['🥑', ['✨', '✨', ['🍕', '🍕']]];
+const emojis = ["🥑", ["✨", "✨", ["🍕", "🍕"]]];
 
 console.log(emojis.flat(1));
 ```
@@ -4318,19 +4318,19 @@ Ne thërrasim `counterTwo.increment()`, i cili vendos `count` në `3`. Pastaj, p
 ###### 133. Cila është vlera e saj?
 
 ```javascript
-const myPromise = Promise.resolve(Promise.resolve('Promise'));
+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!');
+  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!');
+  console.log(`${res} 2!`);
+  setTimeout(() => console.log("Timeout 2!"), 0);
+  console.log("Last line 2!");
 }
 
 funcOne();
@@ -4375,7 +4375,7 @@ export default function sum(x) {
 }
 
 // index.js
-import * as sum from './sum';
+import * as sum from "./sum";
 ```
 
 - A: `sum(4)`
@@ -4392,12 +4392,12 @@ Me yllin `*`, ne importojmë të gjitha vlerat e eksportuara nga ai fajll, si at
 
 ```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);
 ```
 
@@ -4428,13 +4428,13 @@ Mund të e thërrasim këtë funksion, duke thirrur `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;
 ```
 
@@ -4464,7 +4464,7 @@ Pastaj, ne i qasemi një vlerë të vetisë në objektin proxy, vetia `get` në
 ###### 136. Cili nga opsionet e mëposhtme do të modifikojë objektin `person`?
 
 ```javascript
-const person = { name: 'Lydia Hallie' };
+const person = { name: "Lydia Hallie" };
 
 Object.seal(person);
 ```
@@ -4492,9 +4492,9 @@ Megjithatë, ju ende mund të modifikoni vlerën e vetive ekzistuese.
 
 ```javascript
 const person = {
-  name: 'Lydia Hallie',
+  name: "Lydia Hallie",
   address: {
-    street: '100 Main St',
+    street: "100 Main St",
   },
 };
 
@@ -4523,7 +4523,7 @@ Megjithatë, ajo vetëm _ngrin sipërfaqësisht_ objektin, që do të thotë se
 ###### 138. Cila është vlera e saj?
 
 ```javascript
-const add = x => x + x;
+const add = (x) => x + x;
 
 function myFunc(num = 2, value = add(num)) {
   console.log(num, value);
@@ -4556,21 +4556,21 @@ Më pas, ne thirrëm `myFunc(3)` dhe kaluam vlerën `3` si vlerë për argumenti
 
 ```javascript
 class Counter {
-  #number = 10
+  #number = 10;
 
   increment() {
-    this.#number++
+    this.#number++;
   }
 
   getNum() {
-    return this.#number
+    return this.#number;
   }
 }
 
-const counter = new Counter()
-counter.increment()
+const counter = new Counter();
+counter.increment();
 
-console.log(counter.#number)
+console.log(counter.#number);
 ```
 
 - A: `10`
@@ -4594,8 +4594,8 @@ Në ES2020, mund të shtojmë variabla private në klasa duke përdorur `#`. Nuk
 
 ```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) {
@@ -4638,8 +4638,8 @@ Nëse do të shkruanim `yield`, `return yield`, ose `return`, gjithë funksioni
 
 ```javascript
 const person = {
-  name: 'Lydia Hallie',
-  hobbies: ['coding'],
+  name: "Lydia Hallie",
+  hobbies: ["coding"],
 };
 
 function addHobby(hobby, hobbies = person.hobbies) {
@@ -4647,9 +4647,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);
 ```
@@ -4718,11 +4718,11 @@ Krijojmë variablën `pet` që është një instancë e klasës `Flamingo`. Kur
 ###### 143. Cila nga opsionet rezulton me gabim?
 
 ```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;
 ```
 
@@ -4777,11 +4777,11 @@ Objektet nuk janë të paraprakisht të iterueshme. Një objekt është i iterue
 let count = 0;
 const nums = [0, 1, 2, 3];
 
-nums.forEach(num => {
-	if (num) count += 1
-})
+nums.forEach((num) => {
+  if (num) count += 1;
+});
 
-console.log(count)
+console.log(count);
 ```
 
 - A: 1
@@ -4805,12 +4805,12 @@ Kushti `if` brenda ciklit `forEach` kontrollon nëse vlera e `num` është e vë
 
 ```javascript
 function getFruit(fruits) {
-	console.log(fruits?.[1]?.[1])
+  console.log(fruits?.[1]?.[1]);
 }
 
-getFruit([['🍊', '🍌'], ['🍍']])
-getFruit()
-getFruit([['🍍'], ['🍊', '🍌']])
+getFruit([["🍊", "🍌"], ["🍍"]]);
+getFruit();
+getFruit([["🍍"], ["🍊", "🍌"]]);
 ```
 
 - A: `null`, `undefined`, 🍌
@@ -4825,7 +4825,7 @@ getFruit([['🍍'], ['🍊', '🍌']])
 
 Simboli ? na lejon të i qasemi opsionalisht vetive më të thella brenda objekteve. Ne po provojmë të shfaqim elementin në indeksin 1 brenda në nën-array që është në indeksin 1 të array fruits. Nëse nën-array në indeksin 1 në array fruits nuk ekziston, thjesht do të kthejë undefined. Nëse nën-array në indeksin 1 në vargun fruits ekziston, por ky nën-array nuk ka një artikull në indeksin e tij 1, gjithashtu do të kthejë undefined.
 
-Së pari, ne po përpiqemi të printojmë artikullin e dytë në nën-array `['🍍']` të `[['🍊', '🍌'], ['🍍']]`. Ky nën-array përmban vetëm  një element, që do të thotë se nuk ka element në indeksin `1`, dhe kthen `undefined`.
+Së pari, ne po përpiqemi të printojmë artikullin e dytë në nën-array `['🍍']` të `[['🍊', '🍌'], ['🍍']]`. Ky nën-array përmban vetëm një element, që do të thotë se nuk ka element në indeksin `1`, dhe kthen `undefined`.
 
 Më pas, ne po thërrasim funksionin `getFruits` pa kaluar një vlerë si argument, që do të thotë se `fruits` ka vlerë `undefined` të paracaktuar. Pasi që po lidhim në mënyrë kushtëzuese elementin në indeksin `1` të `fruits`, kthen `undefined` pasi ky element në indeksin `1` nuk ekziston.
 
@@ -4840,19 +4840,19 @@ Së fundmi, po përpiqemi të shfaqim artikullin e dytë në nën-array `['🍊'
 
 ```javascript
 class Calc {
-	constructor() {
-		this.count = 0 
-	}
+  constructor() {
+    this.count = 0;
+  }
 
-	increase() {
-		this.count ++
-	}
+  increase() {
+    this.count++;
+  }
 }
 
-const calc = new Calc()
-new Calc().increase()
+const calc = new Calc();
+new Calc().increase();
 
-console.log(calc.count)
+console.log(calc.count);
 ```
 
 - A: `0`
@@ -4876,25 +4876,25 @@ Ne i caktojmë variablës `calc` të jetë e barabartë me një instancë të re
 
 ```javascript
 const user = {
-	email: "e@mail.com",
-	password: "12345"
-}
+  email: "e@mail.com",
+  password: "12345",
+};
 
 const updateUser = ({ email, password }) => {
-	if (email) {
-		Object.assign(user, { email })
-	}
+  if (email) {
+    Object.assign(user, { email });
+  }
 
-	if (password) {
-		user.password = password
-	}
+  if (password) {
+    user.password = password;
+  }
 
-	return user
-}
+  return user;
+};
 
-const updatedUser = updateUser({ email: "new@email.com" })
+const updatedUser = updateUser({ email: "new@email.com" });
 
-console.log(updatedUser === user)
+console.log(updatedUser === user);
 ```
 
 - A: `false`
@@ -4917,13 +4917,13 @@ Funksioni `updateUser` përditëson vlerat e vetive `email` dhe `password` në u
 ###### 149. Cila është vlera e saj?
 
 ```javascript
-const fruit = ['🍌', '🍊', '🍎']
+const fruit = ["🍌", "🍊", "🍎"];
 
-fruit.slice(0, 1)
-fruit.splice(0, 1)
-fruit.unshift('🍇')
+fruit.slice(0, 1);
+fruit.splice(0, 1);
+fruit.unshift("🍇");
 
-console.log(fruit)
+console.log(fruit);
 ```
 
 - A: `['🍌', '🍊', '🍎']`
@@ -4949,13 +4949,13 @@ Në fund, ne thirrim metodën `unshift` në array e frutave, e cila modifikon ar
 
 ```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])
+console.log(animals[dog]);
 ```
 
 - A: `{ emoji: "🐶", name: "Mara" }`
@@ -4985,14 +4985,14 @@ Duke printuar `animals[dog]`, ose në fakt `animals["object Object"]` pasi që k
 
 ```javascript
 const user = {
-	email: "my@email.com",
-	updateEmail: email => {
-		this.email = email
-	}
-}
+  email: "my@email.com",
+  updateEmail: (email) => {
+    this.email = email;
+  },
+};
 
-user.updateEmail("new@email.com")
-console.log(user.email)
+user.updateEmail("new@email.com");
+console.log(user.email);
 ```
 
 - A: `my@email.com`
@@ -5015,20 +5015,20 @@ Funksioni `updateEmail` është një funksion shigjetë dhe nuk është i lidhur
 ###### 152. Cila është vlera e saj?
 
 ```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])
-	const res2  = await Promise.all([promise3, promise4])
-	return [res1, res2]
-}
+  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))
+  .then((res) => console.log(res))
+  .catch((err) => console.log(err));
 ```
 
 - A: `[['First', 'Second'], ['Fourth']]`
@@ -5051,13 +5051,16 @@ Metoda `Promise.all` ekzekuton premtimet e dhëna si argumente paralelisht. Nës
 ###### 153. Cila duhet të jetë vlera e `method` për të printuar `{ name: "Lydia", age: 22 }`?
 
 ```javascript
-const keys = ["name", "age"]
-const values = ["Lydia", 22]
+const keys = ["name", "age"];
+const values = ["Lydia", 22];
 
-const method = /* ?? */
-Object[method](keys.map((_, i) => {
-	return [keys[i], values[i]]
-})) // { name: "Lydia", age: 22 }
+const method =
+  /* ?? */
+  Object[method](
+    keys.map((_, i) => {
+      return [keys[i], values[i]];
+    })
+  ); // { name: "Lydia", age: 22 }
 ```
 
 - A: `entries`
@@ -5070,7 +5073,7 @@ Object[method](keys.map((_, i) => {
 
 #### Përgjigja: C
 
-Metoda `fromEntries` transformon një array 2d në një objekt. Elementi i parë në çdo nën-array do të jetë çelësi, dhe elementi i dytë në çdo nën-array do të jetë vlera. Në këtë rast, ne jemi duke mapuar mbi array `keys`, i cili kthen një array ku elementi i parë është elementi në array të çelësave në indeksin aktual, dhe elementi i dytë është elementi i vlerave të array  në indeksin aktual.
+Metoda `fromEntries` transformon një array 2d në një objekt. Elementi i parë në çdo nën-array do të jetë çelësi, dhe elementi i dytë në çdo nën-array do të jetë vlera. Në këtë rast, ne jemi duke mapuar mbi array `keys`, i cili kthen një array ku elementi i parë është elementi në array të çelësave në indeksin aktual, dhe elementi i dytë është elementi i vlerave të array në indeksin aktual.
 
 Kjo krijon një array të nën-arrays që përmbajnë çelësat dhe vlerat e duhura, të cilat rezultojnë në `{ name: "Lydia", age: 22 }`
 
@@ -5082,18 +5085,18 @@ Kjo krijon një array të nën-arrays që përmbajnë çelësat dhe vlerat e duh
 ###### 154. Cila është vlera e saj?
 
 ```javascript
-const createMember = ({ email, address = {}}) => {
-	const validEmail = /.+\@.+\..+/.test(email)
-	if (!validEmail) throw new Error("Valid email pls")
+const createMember = ({ email, address = {} }) => {
+  const validEmail = /.+\@.+\..+/.test(email);
+  if (!validEmail) throw new Error("Valid email pls");
 
-	return {
-		email,
-		address: address ? address : null
-	}
-}
+  return {
+    email,
+    address: address ? address : null,
+  };
+};
 
-const member = createMember({ email: "my@email.com" })
-console.log(member)
+const member = createMember({ email: "my@email.com" });
+console.log(member);
 ```
 
 - A: `{ email: "my@email.com", address: null }`
@@ -5116,13 +5119,13 @@ Vlera e paracaktuar e `address` është një objekt i zbrazët `{}`. Kur vendos
 ###### 155. Cila është vlera e saj?
 
 ```javascript
-let randomValue = { name: "Lydia" }
-randomValue = 23
+let randomValue = { name: "Lydia" };
+randomValue = 23;
 
 if (!typeof randomValue === "string") {
-	console.log("It's not a string!")
+  console.log("It's not a string!");
 } else {
-	console.log("Yay it's a string!")
+  console.log("Yay it's a string!");
 }
 ```
 
diff --git a/th-TH/README.md b/th-TH/README.md
index 22550eb2..edcb70ce 100644
--- a/th-TH/README.md
+++ b/th-TH/README.md
@@ -16,8 +16,8 @@
 
 </div>
 
-
 ลิสต์ภาษาอื่นๆ:
+
 - [🇸🇦 العربية](../ar-AR/README_AR.md)
 - [🇪🇬 اللغة العامية](../ar-EG/README_ar-EG.md)
 - [🇧🇦 Bosanski](../bs-BS/README-bs_BS.md)
@@ -32,6 +32,7 @@
 - [🇳🇱 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)
 - [🇹🇷 Türkçe](../tr-TR/README-tr_TR.md)
@@ -40,7 +41,6 @@
 - [🇨🇳 简体中文](../zh-CN/README-zh_CN.md)
 - [🇹🇼 繁體中文](../zh-TW/README_zh-TW.md)
 
-
 ---
 
 ###### 1. ผลลัพธ์ที่ได้คืออะไร?
@@ -113,7 +113,7 @@ const shape = {
   diameter() {
     return this.radius * 2;
   },
-  perimeter: () => 2 * Math.PI * this.radius
+  perimeter: () => 2 * Math.PI * this.radius,
 };
 
 console.log(shape.diameter());
@@ -170,12 +170,12 @@ String `'Lydia'` เป็นค่าความจริง สิ่งท
 
 ```javascript
 const bird = {
-  size: "small"
+  size: "small",
 };
 
 const mouse = {
   name: "Mickey",
-  small: true
+  small: true,
 };
 ```
 
@@ -202,7 +202,6 @@ JavaScript interprets (or unboxes) statements. เมื่อเราใช้
 
 ---
 
-
 ###### 6. ผลลัพธ์ที่ได้คืออะไร?
 
 ```javascript
@@ -370,7 +369,7 @@ function Person(firstName, lastName) {
 }
 
 const member = new Person("Lydia", "Hallie");
-Person.getFullName = function() {
+Person.getFullName = function () {
   return `${this.firstName} ${this.lastName}`;
 };
 
@@ -390,7 +389,7 @@ console.log(member.getFullName());
 You can't add properties to a constructor like you can with regular objects. If you want to add a feature to all objects at once, you have to use the prototype instead. So in this case,
 
 ```js
-Person.prototype.getFullName = function() {
+Person.prototype.getFullName = function () {
   return `${this.firstName} ${this.lastName}`;
 };
 ```
@@ -846,7 +845,7 @@ String.prototype.giveLydiaPizza = () => {
 
 const name = "Lydia";
 
-console.log(name.giveLydiaPizza())
+console.log(name.giveLydiaPizza());
 ```
 
 - A: `"Just give Lydia pizza already!"`
@@ -958,9 +957,7 @@ This is where an event loop starts to work. An **event loop** looks at the stack
 ```html
 <div onclick="console.log('first div')">
   <div onclick="console.log('second div')">
-    <button onclick="console.log('button')">
-      Click!
-    </button>
+    <button onclick="console.log('button')">Click!</button>
   </div>
 </div>
 ```
@@ -986,9 +983,7 @@ The deepest nested element that caused the event is the target of the event. You
 
 ```html
 <div onclick="console.log('div')">
-  <p onclick="console.log('p')">
-    Click here!
-  </p>
+  <p onclick="console.log('p')">Click here!</p>
 </div>
 ```
 
@@ -1064,6 +1059,7 @@ console.log(typeof sayHi());
 The `sayHi` function returns the returned value of the immediately invoked function (IIFE). This function returned `0`, which is type `"number"`.
 
 FYI: there are only 7 built-in types: `null`, `undefined`, `boolean`, `number`, `string`, `object`, `symbol`, และ `bigint`. `"function"` is not a type, since functions are objects, it's of type `"object"`.
+
 </p>
 </details>
 
@@ -1222,7 +1218,10 @@ What differentiates a primitive from an object is that primitives do not have an
 ###### 40. ผลลัพธ์ที่ได้คืออะไร?
 
 ```javascript
-[[0, 1], [2, 3]].reduce(
+[
+  [0, 1],
+  [2, 3],
+].reduce(
   (acc, cur) => {
     return acc.concat(cur);
   },
@@ -1370,7 +1369,7 @@ const secondPromise = new Promise((res, rej) => {
   setTimeout(res, 100, "two");
 });
 
-Promise.race([firstPromise, secondPromise]).then(res => console.log(res));
+Promise.race([firstPromise, secondPromise]).then((res) => console.log(res));
 ```
 
 - A: `"one"`
@@ -1434,7 +1433,7 @@ We are only modifying the value of the `person` variable, and not the first elem
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21
+  age: 21,
 };
 
 for (const item in person) {
@@ -1514,7 +1513,7 @@ Only the first numbers in the string is returned. Based on the _radix_ (the seco
 ###### 50. ผลลัพธ์ที่ได้คืออะไร?
 
 ```javascript
-[1, 2, 3].map(num => {
+[1, 2, 3].map((num) => {
   if (typeof num === "number") return;
   return num * 2;
 });
@@ -1691,7 +1690,7 @@ class Dog {
   }
 }
 
-Dog.prototype.bark = function() {
+Dog.prototype.bark = function () {
   console.log(`Woof I am ${this.name}`);
 };
 
@@ -1919,7 +1918,7 @@ Properties added using the `defineProperty` method are immutable by default. You
 const settings = {
   username: "lydiahallie",
   level: 19,
-  health: 90
+  health: 90,
 };
 
 const data = JSON.stringify(settings, ["level", "health"]);
@@ -1953,7 +1952,7 @@ If the replacer is a _function_, this function gets called on every property in
 let num = 10;
 
 const increaseNumber = () => num++;
-const increasePassedNumber = number => number++;
+const increasePassedNumber = (number) => number++;
 
 const num1 = increaseNumber();
 const num2 = increasePassedNumber(num1);
@@ -2010,9 +2009,9 @@ In ES6, we can initialize parameters with a default value. The value of the para
 
 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 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`. 
+The fourth time, we pass the `value` object again. `x.number` was previously modified to `20`, so `x.number *= 2` logs `40`.
 
 </p>
 </details>
@@ -2035,17 +2034,18 @@ 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. 
+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 current value: `1` และ `2` get logged.  
+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 current value: `1` และ `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` และ `3` 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` และ `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` และ `4` get logged.
+
 </p>
 </details>
   
@@ -2061,7 +2061,7 @@ class Dog {
 };
 
 class Labrador extends Dog {
-  // 1 
+  // 1
   constructor(name, size) {
     this.size = size;
   }
@@ -2075,7 +2075,7 @@ class Labrador extends Dog {
     super(name);
     this.size = size;
   }
-  // 4 
+  // 4
   constructor(name, size) {
     this.name = name;
     this.size = size;
@@ -2096,9 +2096,10 @@ class Labrador extends Dog {
 
 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`. 
+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`, และ `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.
 
-The `Labrador` class receives two arguments, `name` since it extends `Dog`, และ `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>
 
@@ -2108,12 +2109,12 @@ The `Labrador` class receives two arguments, `name` since it 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;
 ```
 
@@ -2129,7 +2130,7 @@ export const sum = (a, b) => a + b;
 
 With the `import` keyword, all imported modules are _pre-parsed_. This means that the imported modules get run _first_, the code in the file which 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 would have used `require` instead of `import`, `running index.js`, `running sum.js`, `3` would have been logged to the console. 
+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 would have used `require` instead of `import`, `running index.js`, `running sum.js`, `3` would have been logged to the console.
 
 </p>
 </details>
@@ -2139,9 +2140,9 @@ This is a difference between `require()` in CommonJS and `import`! With `require
 ###### 68. ผลลัพธ์ที่ได้คืออะไร?
 
 ```javascript
-console.log(Number(2) === Number(2))
-console.log(Boolean(false) === Boolean(false))
-console.log(Symbol('foo') === Symbol('foo'))
+console.log(Number(2) === Number(2));
+console.log(Boolean(false) === Boolean(false));
+console.log(Symbol("foo") === Symbol("foo"));
 ```
 
 - A: `true`, `true`, `false`
@@ -2154,7 +2155,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`. 
+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>
@@ -2164,15 +2165,15 @@ Every Symbol is entirely unique. The purpose of the argument passed to the Symbo
 ###### 69. ผลลัพธ์ที่ได้คืออะไร?
 
 ```javascript
-const name = "Lydia Hallie"
-console.log(name.padStart(13))
-console.log(name.padStart(2))
+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"`, 
+- D: `"Lydia Hallie"`, `"Lyd"`,
 
 <details><summary><b>คำตอบ</b></summary>
 <p>
@@ -2440,7 +2441,7 @@ The `sum` function always returns the same result. If we pass `1` และ `2`,
 ```javascript
 const add = () => {
   const cache = {};
-  return num => {
+  return (num) => {
     if (num in cache) {
       return `From cache! ${cache[num]}`;
     } else {
@@ -2485,21 +2486,21 @@ The third time, we pass `5 * 2` to the function which gets evaluated to `10`. Th
 ###### 79. ผลลัพธ์ที่ได้คืออะไร?
 
 ```javascript
-const myLifeSummedUp = ["☕", "💻", "🍷", "🍫"]
+const myLifeSummedUp = ["☕", "💻", "🍷", "🍫"];
 
 for (let item in myLifeSummedUp) {
-  console.log(item)
+  console.log(item);
 }
 
 for (let item of myLifeSummedUp) {
-  console.log(item)
+  console.log(item);
 }
 ```
 
 - A: `0` `1` `2` `3` และ `"☕"` ` "💻"` `"🍷"` `"🍫"`
 - B: `"☕"` ` "💻"` `"🍷"` `"🍫"` และ `"☕"` ` "💻"` `"🍷"` `"🍫"`
 - C: `"☕"` ` "💻"` `"🍷"` `"🍫"` และ `0` `1` `2` `3`
-- D:  `0` `1` `2` `3` และ `{0: "☕", 1: "💻", 2: "🍷", 3: "🍫"}`
+- D: `0` `1` `2` `3` และ `{0: "☕", 1: "💻", 2: "🍷", 3: "🍫"}`
 
 <details><summary><b>คำตอบ</b></summary>
 <p>
@@ -2522,14 +2523,14 @@ With a _for-of_ loop, we can iterate over **iterables**. An array is an iterable
 ###### 80. ผลลัพธ์ที่ได้คืออะไร?
 
 ```javascript
-const list = [1 + 2, 1 * 2, 1 / 2]
-console.log(list)
+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]`
+- D: `[1, 1, 1]`
 
 <details><summary><b>คำตอบ</b></summary>
 <p>
@@ -2538,7 +2539,7 @@ console.log(list)
 
 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`, และ `1 / 2` returns `0.5`.
+The element will be equal to the returned value. `1 + 2` returns `3`, `1 * 2` returns `2`, และ `1 / 2` returns `0.5`.
 
 </p>
 </details>
@@ -2549,16 +2550,16 @@ The element will be equal to the returned value.  `1 + 2` returns `3`, `1 * 2` r
 
 ```javascript
 function sayHi(name) {
-  return `Hi there, ${name}`
+  return `Hi there, ${name}`;
 }
 
-console.log(sayHi())
+console.log(sayHi());
 ```
 
 - A: `Hi there, `
 - B: `Hi there, undefined`
 - C: `Hi there, null`
-- D:  `ReferenceError`
+- D: `ReferenceError`
 
 <details><summary><b>คำตอบ</b></summary>
 <p>
@@ -2581,21 +2582,21 @@ In this case, if we didn't pass a value or if we passed `undefined`, `name` woul
 ###### 82. ผลลัพธ์ที่ได้คืออะไร?
 
 ```javascript
-var status = "😎"
+var status = "😎";
 
 setTimeout(() => {
-  const status = "😍"
+  const status = "😍";
 
   const data = {
     status: "🥑",
     getStatus() {
-      return this.status
-    }
-  }
+      return this.status;
+    },
+  };
 
-  console.log(data.getStatus())
-  console.log(data.getStatus.call(this))
-}, 0)
+  console.log(data.getStatus());
+  console.log(data.getStatus.call(this));
+}, 0);
 ```
 
 - A: `"🥑"` และ `"😍"`
@@ -2612,7 +2613,6 @@ The value of the `this` keyword is dependent on where you use it. In a **method*
 
 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>
 
@@ -2623,13 +2623,13 @@ With the `call` method, we can change the object to which the `this` keyword ref
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21
-}
+  age: 21,
+};
 
-let city = person.city
-city = "Amsterdam"
+let city = person.city;
+city = "Amsterdam";
 
-console.log(person)
+console.log(person);
 ```
 
 - A: `{ name: "Lydia", age: 21 }`
@@ -2642,13 +2642,13 @@ 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`. 
+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. 
+When logging the `person` object, the unmodified object gets returned.
 
 </p>
 </details>
@@ -2660,15 +2660,15 @@ When logging the `person` object, the unmodified object gets returned.
 ```javascript
 function checkAge(age) {
   if (age < 18) {
-    const message = "Sorry, you're too young."
+    const message = "Sorry, you're too young.";
   } else {
-    const message = "Yay! You're old enough!"
+    const message = "Yay! You're old enough!";
   }
 
-  return message
+  return message;
 }
 
-console.log(checkAge(21))
+console.log(checkAge(21));
 ```
 
 - A: `"Sorry, you're too young."`
@@ -2691,15 +2691,15 @@ Variables with the `const` และ `let` keyword are _block-scoped_. A block i
 ###### 85. ข้อมูลแบบไหนที่เราได้ใน log?
 
 ```javascript
-fetch('https://www.website.com/api/user/1')
-  .then(res => res.json())
-  .then(res => console.log(res))
+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. 
+- D: It would always be undefined.
 
 <details><summary><b>คำตอบ</b></summary>
 <p>
@@ -2747,7 +2747,7 @@ By setting `hasName` equal to `name`, you set `hasName` equal to whatever value
 ###### <a name=20190805></a>87. ผลลัพธ์ที่ได้คืออะไร?
 
 ```javascript
-console.log("I want pizza"[0])
+console.log("I want pizza"[0]);
 ```
 
 - A: `"""`
@@ -2773,10 +2773,10 @@ Note that this method is not supported in IE7 and below. In that case, use `.cha
 
 ```javascript
 function sum(num1, num2 = num1) {
-  console.log(num1 + num2)
+  console.log(num1 + num2);
 }
 
-sum(10)
+sum(10);
 ```
 
 - A: `NaN`
@@ -2789,9 +2789,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`.
+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 which is defined _after_ (to the right), the parameter's value hasn't been initialized yet, which will throw an error. 
+If you're trying to set a default parameter's value equal to a parameter which is defined _after_ (to the right), the parameter's value hasn't been initialized yet, which will throw an error.
 
 </p>
 </details>
@@ -2801,14 +2801,14 @@ If you're trying to set a default parameter's value equal to a parameter which i
 ###### 89. ผลลัพธ์ที่ได้คืออะไร?
 
 ```javascript
-// module.js 
-export default () => "Hello world"
-export const name = "Lydia"
+// module.js
+export default () => "Hello world";
+export const name = "Lydia";
 
-// index.js 
-import * as data from "./module"
+// index.js
+import * as data from "./module";
 
-console.log(data)
+console.log(data);
 ```
 
 - A: `{ default: function default(), name: "Lydia" }`
@@ -2821,9 +2821,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 which returns the string `"Hello World"`, and the named export is a variable called `name` which has the value of the string `"Lydia"`. 
+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 which 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. 
+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>
@@ -2835,12 +2835,12 @@ The `data` object has a `default` property for the default export, other propert
 ```javascript
 class Person {
   constructor(name) {
-    this.name = name
+    this.name = name;
   }
 }
 
-const member = new Person("John")
-console.log(typeof member)
+const member = new Person("John");
+console.log(typeof member);
 ```
 
 - A: `"class"`
@@ -2857,11 +2857,11 @@ Classes are syntactical sugar for function constructors. The equivalent of the `
 
 ```javascript
 function Person() {
-  this.name = 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"`. 
+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>
@@ -2871,9 +2871,9 @@ Calling a function constructor with `new` results in the creation of an instance
 ###### 91. ผลลัพธ์ที่ได้คืออะไร?
 
 ```javascript
-let newList = [1, 2, 3].push(4)
+let newList = [1, 2, 3].push(4);
 
-console.log(newList.push(5))
+console.log(newList.push(5));
 ```
 
 - A: `[1, 2, 3, 4, 5]`
@@ -2886,7 +2886,7 @@ 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`. 
+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.
 
@@ -2899,17 +2899,18 @@ 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 = () => "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)
+console.log(giveLydiaPizza.prototype);
+console.log(giveLydiaChocolate.prototype);
 ```
 
-- A: `{ constructor: ...}` `{ constructor: ...}` 
-- B: `{}` `{ constructor: ...}` 
+- A: `{ constructor: ...}` `{ constructor: ...}`
+- B: `{}` `{ constructor: ...}`
 - C: `{ constructor: ...}` `{}`
 - D: `{ constructor: ...}` `undefined`
 
@@ -2918,7 +2919,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`. 
+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>
@@ -2930,16 +2931,16 @@ Regular functions, such as the `giveLydiaPizza` function, have a `prototype` pro
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21
-}
+  age: 21,
+};
 
 for (const [x, y] of Object.entries(person)) {
-  console.log(x, y)
+  console.log(x, y);
 }
 ```
 
 - A: `name` `Lydia` และ `age` `21`
-- B: `["name", "Lydia"]` และ `["age", 21]` 
+- B: `["name", "Lydia"]` และ `["age", 21]`
 - C: `["name", "age"]` และ `undefined`
 - D: `Error`
 
@@ -2950,9 +2951,9 @@ for (const [x, y] of Object.entries(person)) {
 
 `Object.entries(person)` returns an array of nested arrays, containing the keys and objects:
 
-`[ [ 'name', 'Lydia' ], [ 'age', 21 ] ]` 
+`[ [ '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. 
+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"`, และ `y` equal to `"Lydia"`, which get logged.
 The second subarray is `[ "age", 21 ]`, with `x` equal to `"age"`, และ `y` equal to `21`, which get logged.
@@ -2973,7 +2974,7 @@ getItems(["banana", "apple"], "pear", "orange")
 ```
 
 - A: `["banana", "apple", "pear", "orange"]`
-- B: `[["banana", "apple"], "pear", "orange"]` 
+- B: `[["banana", "apple"], "pear", "orange"]`
 - C: `["banana", "apple", ["pear"], "orange"]`
 - D: `SyntaxError`
 
@@ -2982,17 +2983,18 @@ 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` 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]
+  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' ]`
+
 </p>
 </details>
 
@@ -3002,17 +3004,14 @@ 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')
-  return 
-  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))
+console.log(nums(4, 2));
+console.log(nums(1, 2));
 ```
 
 - A: `a is bigger`, `6` และ `b is bigger`, `3`
@@ -3025,13 +3024,13 @@ 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. 
+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
+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!
@@ -3046,18 +3045,18 @@ 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";
   }
-}
+};
 
-const member = new Person()
-console.log(member.name)
+const member = new Person();
+console.log(member.name);
 ```
 
 - A: `"Lydia"`
@@ -3081,11 +3080,11 @@ 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)
-console.log(Object.keys(info))
+console.log(info);
+console.log(Object.keys(info));
 ```
 
 - A: `{Symbol('a'): 'b'}` และ `["{Symbol('a')"]`
@@ -3132,13 +3131,13 @@ console.log(getUser(user))
 
 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]`
+`[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` และ `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.
+With the rest parameter `...y`, we put all "remaining" arguments in an array. The remaining arguments are `2`, `3` และ `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 return an _object_ from an arrow function, you have to write it between parentheses, otherwise no value gets returned! The following function would have returned an object:
+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 return an _object_ from an arrow function, you have to write it between parentheses, otherwise no value gets returned! The following function would have returned an object:
 
-```const getUser = user => ({ name: user.name, age: user.age })```
+`const getUser = user => ({ name: user.name, age: user.age })`
 
 Since no value gets returned in this case, the function returns `undefined`.
 
@@ -3150,9 +3149,9 @@ Since no value gets returned in this case, the function returns `undefined`.
 ###### 99. ผลลัพธ์ที่ได้คืออะไร?
 
 ```javascript
-const name = "Lydia"
+const name = "Lydia";
 
-console.log(name())
+console.log(name());
 ```
 
 - A: `SyntaxError`
@@ -3165,11 +3164,11 @@ console.log(name())
 
 #### คำตอบ: C
 
-The variable `name` holds the value of a string, which is not a function, thus cannot invoke. 
+The variable `name` holds the value of a string, which is not a function, thus cannot invoke.
 
 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`. 
+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>
@@ -3182,8 +3181,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`
@@ -3208,11 +3207,11 @@ You should${'' && `n't`} see a therapist after so much JavaScript lol`
 ###### 101. ผลลัพธ์ที่ได้คืออะไร?
 
 ```javascript
-const one = (false || {} || null)
-const two = (null || false || "")
-const three = ([] || 0 || true)
+const one = false || {} || null;
+const two = null || false || "";
+const three = [] || 0 || true;
 
-console.log(one, two, three)
+console.log(one, two, three);
 ```
 
 - A: `false` `null` `[]`
@@ -3241,20 +3240,20 @@ With the `||` operator, we can return the first truthy operand. If all values ar
 ###### 102. <a name=20190927></a>ผลลัพธ์ที่ได้คืออะไร?
 
 ```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')
+  myPromise().then((res) => console.log(res));
+  console.log("second");
 }
 
 async function secondFunction() {
-  console.log(await myPromise())
-  console.log('second')
+  console.log(await myPromise());
+  console.log("second");
 }
 
-firstFunction()
-secondFunction()
+firstFunction();
+secondFunction();
 ```
 
 - A: `I have resolved!`, `second` และ `I have resolved!`, `second`
@@ -3269,13 +3268,13 @@ secondFunction()
 
 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` keyword in an `async` function. Although we can get a promise's value with both `.then` และ `await`, they work a bit differently. 
+We can get this value with both `.then` and the `await` keyword in an `async` function. Although we can get a promise's value with both `.then` และ `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. 
+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. 
+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>
@@ -3285,14 +3284,14 @@ This means that it waited for the `myPromise` to resolve with the value `I have
 ###### 103. ผลลัพธ์ที่ได้คืออะไร?
 
 ```javascript
-const set = new Set()
+const set = new Set();
 
-set.add(1)
-set.add("Lydia")
-set.add({ name: "Lydia" })
+set.add(1);
+set.add("Lydia");
+set.add({ name: "Lydia" });
 
 for (let item of set) {
-  console.log(item + 2)
+  console.log(item + 2);
 }
 ```
 
@@ -3306,11 +3305,11 @@ for (let item of set) {
 
 #### คำตอบ: C
 
-The `+` operator is not only used for adding numerica lvalues, 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 `+` operator is not only used for adding numerica lvalues, 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"` และ `"2"` get concatenated, whic hresults in the string `"Lydia2"`. 
+However, the second one is a string `"Lydia"`. `"Lydia"` is a string and `2` is a number: `2` gets coerced into a string. `"Lydia"` และ `"2"` get concatenated, whic hresults 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"`.
 
@@ -3322,7 +3321,7 @@ However, the second one is a string `"Lydia"`. `"Lydia"` is a string and `2` is
 ###### 104. ผลลัพธ์ที่ได้คืออะไร?
 
 ```javascript
-Promise.resolve(5)
+Promise.resolve(5);
 ```
 
 - A: `5`
@@ -3337,7 +3336,7 @@ Promise.resolve(5)
 
 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`. 
+In this case, we just passed the numerical value `5`. It returns a resolved promise with the value `5`.
 
 </p>
 </details>
@@ -3349,15 +3348,15 @@ 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)
+compareMembers(person);
 ```
 
 - A: `Not the same!`
@@ -3370,13 +3369,13 @@ compareMembers(person)
 
 #### คำตอบ: B
 
-Objects are passed by reference. When we check objects for strict equality (`===`), we're comparing their references. 
+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. 
+The code block in the `else` statement gets run, and `They are the same!` gets logged.
 
 </p>
 </details>
@@ -3392,11 +3391,11 @@ const colorConfig = {
   green: true,
   black: true,
   yellow: false,
-}
+};
 
-const colors = ["pink", "red", "blue"]
+const colors = ["pink", "red", "blue"];
 
-console.log(colorConfig.colors[1])
+console.log(colorConfig.colors[1]);
 ```
 
 - A: `true`
@@ -3409,11 +3408,11 @@ 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"]`). 
+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 proprety called `colorConfig`, 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. 
+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>
@@ -3423,7 +3422,7 @@ JavaScript interprets (or unboxes) statements. When we use bracket notation, it
 ###### 107. ผลลัพธ์ที่ได้คืออะไร?
 
 ```javascript
-console.log('❤️' === '❤️')
+console.log("❤️" === "❤️");
 ```
 
 - A: `true`
@@ -3434,7 +3433,7 @@ 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. 
+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>
@@ -3444,19 +3443,19 @@ 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`
 - B: `map` `reduce` `slice` `splice`
-- C: `map` `slice` `splice` 
+- C: `map` `slice` `splice`
 - D: `splice`
 
 <details><summary><b>คำตอบ</b></summary>
@@ -3464,7 +3463,7 @@ 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 added the ✨ emoji instead. 
+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 added the ✨ emoji instead.
 
 `map`, `filter` และ `slice` return a new array, `find` returns an element, and `reduce` returns a reduced value.
 
diff --git a/tr-TR/README-tr_TR.md b/tr-TR/README-tr_TR.md
index e34ae66b..f1abe649 100644
--- a/tr-TR/README-tr_TR.md
+++ b/tr-TR/README-tr_TR.md
@@ -9,7 +9,6 @@ Cevaplar, soruların altında gizlenmiştir. Görmek için sadece tıklayın. İ
 Daha fazla soru eklendikçe eposta almak ister misiniz?<br />
 <a target="_blank" href="https://www.theavocoder.com/subscribe"><b>✨✉Eposta bildirimlerine abone olun✉✨</b></a>
 
-
 Mevcut dillerin listesi:
 
 - [🇸🇦 العربية](../ar-AR/README_AR.md)
@@ -26,6 +25,7 @@ Mevcut dillerin listesi:
 - [🇳🇱 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)
@@ -60,8 +60,9 @@ sayHi();
 #### Cevap: D
 
 Fonksiyonun içinde, önce `var` anahtar kelimesi ile `name` değişkenini tanımladık. Bu demektir ki, değişken varsayılan değeri olan `undefined` ile "hoisting" (hafızada alan oluşturma aşaması) olur, ta ki gerçekten değişkene değer ataması yaptığımız satıra varana dek. `name` değişkenini loglayama çalıştığımız satırda henüz değişkeni tanımlamadık, bu yüzden hala `undefined` değerini saklıyor.
- 
+
 `let` (ve `const`) anahtar kelimelerine sahip değişkenler de "hoisted" olur, ama `var`'ın aksine <i>ilk değer ataması</i> yapılmaz. Değişkenleri tanımladığımız (ilk değer ataması yaptığımız) satırdan önce erişilebilir değillerdir. Bu, "geçici ölü alan / geçici değişmez çıktı alanı", "temporal dead zone", olarak adlandırılır. Değişkenlere, tanımlanmadan önce erişmeye çalıştığımız zaman, Javascript `ReferenceError` hatası fırlatır.
+
 </p>
 </details>
 
@@ -91,6 +92,7 @@ for (let i = 0; i < 3; i++) {
 Javascript'deki olay kuyruğundan dolayı, `setTimeout` callback fonksiyonu, döngü uygulandıktan _sonra_ çağrılır. `i` değişkeni, ilk döngü sırasında `var` anahtar kelimesi ile tanımlandığından, bu değişken globaldir. Döngü boyunca, `++` unary operatörünü kullanarak, `i`'nin değerini her seferinde `1` arttırdık. İlk örnekte, `setTimeout` callback fonksiyonu çağrıldığı zaman, `i`'nin değeri `3`'e eşitti.
 
 İkinci döngüde, `i` değişkeni `let` anahtar kelimesi kullanılarak tanımlandı: `let` (ve `const`) ile tanımlanan değişkenler "block-scope"dur (block `{}` arasındaki herhangi bir şeydir). Her bir tekrarda, `i` yeni değere sahip olacak ve her değer döngü içinde "scoped" olacak.
+
 </p>
 </details>
 
@@ -104,7 +106,7 @@ const shape = {
   diameter() {
     return this.radius * 2;
   },
-  perimeter: () => 2 * Math.PI * this.radius
+  perimeter: () => 2 * Math.PI * this.radius,
 };
 
 console.log(shape.diameter());
@@ -125,7 +127,7 @@ console.log(shape.perimeter());
 
 Arrow fonksiyonlarda, `this` anahtar kelimesi, sıradan fonksiyonların aksine, kendi sardığı mevcut scope'u referans alır. Bu demektir ki, `perimeter`'i çağırdığımız zaman, `shape` objesini değil, kendi sardığı scope'u referans alıyor (örneğin window).
 
-Bu objede, `radius` değeri olmadığından `undefined` döndürüyor. 
+Bu objede, `radius` değeri olmadığından `undefined` döndürüyor.
 
 </p>
 </details>
@@ -150,7 +152,8 @@ Bu objede, `radius` değeri olmadığından `undefined` döndürüyor.
 
 Artı (unary plus), işlemeye çalıştığı değişkeni sayıya çevirmeye çalışır. `true` `1` ve `false` `0` demektir.
 
-`'Lydia'` harf dizisi doğrusal ("truthy") bir değerdir. Aslında sorduğumuz şey, "bu doğrusal değer yanlış-ımsı ("falsy") mı?". Bu da `false` döndürür. 
+`'Lydia'` harf dizisi doğrusal ("truthy") bir değerdir. Aslında sorduğumuz şey, "bu doğrusal değer yanlış-ımsı ("falsy") mı?". Bu da `false` döndürür.
+
 </p>
 </details>
 
@@ -160,12 +163,12 @@ Artı (unary plus), işlemeye çalıştığı değişkeni sayıya çevirmeye ça
 
 ```javascript
 const bird = {
-  size: "small"
+  size: "small",
 };
 
 const mouse = {
   name: "Mickey",
-  small: true
+  small: true,
 };
 ```
 
@@ -186,12 +189,12 @@ Javascript, ifadeleri yorumlar (ya da açar ("unboxes")). Köşeli parentez nota
 `mouse[bird.size]`: Önce `bird.size` çalıştırılır, o da `"small"` demektir. `mouse["small"]`, `true` döndürür.
 
 Ancak, nokta notasyonunda bu gerçekleşmez. `mouse`, `bird` diye bir keye sahip değildir ki bu da `mouse.bird`, `undefined` demektir. Sonra, nokta notasyonunu kullanarak `size`'a ulaşmak istiyoruz: `mouse.bird.size`. `mouse.bird`, `undefined` olduğundan, aslında ulaşmaya çalıştığımız `undefined.size`. Bu geçerli değil ve `Cannot read property "size" of undefined`'a benzer bir hata fırlatacaktır.
+
 </p>
 </details>
 
 ---
 
-
 ###### 6. Çıktısı Nedir?
 
 ```javascript
@@ -253,6 +256,7 @@ console.log(b === c);
 `==` operatörünü kullandığımız zaman, sadece aynı _değer_'e sahip olup olmadığını kontrol eder. İkisi de `3` değerine sahip, yani `true` döndürür.
 
 Ancak, `===` kullandığımız zaman değer _ve_ tip aynı olmalıdır. Öyle değil: `new Number()`, sayı ("number") değildir, **nesne**dir. İkisi de `false` döndürür.
+
 </p>
 </details>
 
@@ -287,6 +291,7 @@ console.log(freddie.colorChange("orange"));
 #### Cevap: D
 
 `colorChange` fonksiyonu statiktir. Statik methodlar, sadece oluşturuldukları kurucuda var olmak için tasarlanmıştır ve herhangi bir "children"a aktarılamaz. `freddie`, "child" olduğundan, fonksiyon aktarılmadı ve `freddie` üzerinden erişilebilir değil: `TypeError` hatası fırlatılır.
+
 </p>
 </details>
 
@@ -312,6 +317,7 @@ console.log(greetign);
 Nesneyi loglar çünkü global nesne üzerinde boş bir nesne oluşturduk. `greeting`'i `greetign` olarak yanlış yazdığımız zaman, JS yorumlayıcısı bunu `global.greetign = {}` olarak gördü (ya da tarayıcı içinde `window.greetign = {}`).
 
 Bundan kaçınmak için, `"use strict"` kullanabiliriz. Bu, bir değişkene herhangi bir atama yapmadan önce tanımladığınızdan emin olmanızı sağlar.
+
 </p>
 </details>
 
@@ -355,7 +361,7 @@ function Person(firstName, lastName) {
 }
 
 const member = new Person("Lydia", "Hallie");
-Person.getFullName = function() {
+Person.getFullName = function () {
   return `${this.firstName} ${this.lastName}`;
 };
 
@@ -373,8 +379,9 @@ console.log(member.getFullName());
 #### Cevap: A
 
 Sıradan fonksiyonlarla yaptığınız gibi bir yapıcıya ("constructor") özellik ekleyemezsiniz. Eğer, tek seferde tüm nesnelere özellik eklemek isterseniz, bunun yerine prototype kullanmalısınız. Yani bu durumda,
+
 ```js
-Person.prototype.getFullName = function() {
+Person.prototype.getFullName = function () {
   return `${this.firstName} ${this.lastName}`;
 };
 ```
@@ -414,6 +421,7 @@ console.log(sarah);
 `sarah` için `new` anahtar kelimesi kullanmadık. `new` kullandığınız zaman, oluşturduğumuz yeni boş nesneyi referans gösterir. Lakin, `new`'i eklemezseniz, **global nesne**'yi referans gösterir!
 
 `this.firstName`, `"Sarah"`'a eşittir ve `this.lastName`, `"Smith"`'e eşittir dedik. Aslında yaptığımız, `global.firstName = 'Sarah'` ve `global.lastName = 'Smith'` diye tanımlamaydı. `sarah`'ın kendisi `undefined` olarak kalır.
+
 </p>
 </details>
 
@@ -431,7 +439,7 @@ console.log(sarah);
 
 #### Cevap: D
 
-**capturing** aşaması süresince, olay ata ("ancestor) elemanlardan hedef elemana doğru gider. Daha sonra **target** elemana ulaşır ve **bubbling** başlar. 
+**capturing** aşaması süresince, olay ata ("ancestor) elemanlardan hedef elemana doğru gider. Daha sonra **target** elemana ulaşır ve **bubbling** başlar.
 
 <img src="https://i.imgur.com/N18oRgd.png" width="200">
 
@@ -451,6 +459,7 @@ console.log(sarah);
 #### Cevap: B
 
 Bütün nesneler prototiplere ("prototypes") sahiptir, **temel nesne**, **base object**, hariç. Temel nesne, kullanıcı tarafından oluşturulmuş nesnedir, ya da `new` anahtar kelimesi kullanarak oluşturulmuş bir nesnedir. Temel nesne bazı method ve özelliklere erişebilir, `.toString` gibi. Yerleşik gelen Javascript methodlarını kullanabilme sebebi budur! Buna benzer tüm methodlar prototip üzerinden erişebilir. Her ne kadar Javascript, methodu direkt olarak nesneniz üzerinden bulamasa da, prototip zinciri üzerinden aşağıya doğru gider ve orada bulur, böylece sizin için erişebilir yapar.
+
 </p>
 </details>
 
@@ -506,7 +515,6 @@ console.log(number);
 
 **son ek**, **postfix**, `++` unary operatörü:
 
-
 1. Değer döndürür (`0` döndürür)
 2. Değeri arttırır (sayı şimdi `1`)
 
@@ -686,7 +694,7 @@ sessionStorage.setItem("cool_secret", 123);
 
 `sessionStorage` içinde saklanan veri _sekme_ kapatıldıktan sonra kaldırılır.
 
-Eğer `localStorage` kullandıysanız, veri sonsuza kadar orada olacaktır, örnek olarak `localStorage.clear()` çalıştırılmadığı sürece. 
+Eğer `localStorage` kullandıysanız, veri sonsuza kadar orada olacaktır, örnek olarak `localStorage.clear()` çalıştırılmadığı sürece.
 
 </p>
 </details>
@@ -829,7 +837,7 @@ String.prototype.giveLydiaPizza = () => {
 
 const name = "Lydia";
 
-console.log(name.giveLydiaPizza())
+console.log(name.giveLydiaPizza());
 ```
 
 - A: `"Just give Lydia pizza already!"`
@@ -941,9 +949,7 @@ Burası olay döngüsünün çalışmaya başlayacapı yerdir. **olay döngüsü
 ```html
 <div onclick="console.log('first div')">
   <div onclick="console.log('second div')">
-    <button onclick="console.log('button')">
-      Click!
-    </button>
+    <button onclick="console.log('button')">Click!</button>
   </div>
 </div>
 ```
@@ -969,9 +975,7 @@ Olaya sebep olan en derindeki iç eleman, olayın hedefidir ("event.target"). `e
 
 ```html
 <div onclick="console.log('div')">
-  <p onclick="console.log('p')">
-    Click here!
-  </p>
+  <p onclick="console.log('p')">Click here!</p>
 </div>
 ```
 
@@ -1185,7 +1189,7 @@ Sonra, bu block-scoped değişkeni `1`'e eşit olarak ayarladık ve `y` değişk
 - A: primitifdir ya da nesnedir
 - B: fonksiyondur or nesnedir
 - C: tuzak soru! sadece nesnedir
-- D: sayıdır (number) ya da nesnedir 
+- D: sayıdır (number) ya da nesnedir
 
 <details><summary><b>Cevap</b></summary>
 <p>
@@ -1206,7 +1210,10 @@ Primitif ve nesneyi birbirinden ayıran, primitif tiplerin herhangi bir özelli
 ###### 40. Çıktısı Nedir?
 
 ```javascript
-[[0, 1], [2, 3]].reduce(
+[
+  [0, 1],
+  [2, 3],
+].reduce(
   (acc, cur) => {
     return acc.concat(cur);
   },
@@ -1332,7 +1339,7 @@ console.log(gen.next().value);
 
 #### Cevap: C
 
-Sıradan fonksiyonlar yürütmenin başlamasının ardından yarı yolda durdurulamaz. Ancak, bir generator fonksiyon yarı yolda "durdurabilir" ve sonra nerede kaldıysa devam edebilir. Bir generator fonksiyon ne zaman `yield` anahtar kelimesiyle karşılaşsa, yield'de belirtilen değeri verir. Dikkat edin, generator fonksiyon değeri _döndürmez_ (_return_), değeri _verir_ (_yield_). 
+Sıradan fonksiyonlar yürütmenin başlamasının ardından yarı yolda durdurulamaz. Ancak, bir generator fonksiyon yarı yolda "durdurabilir" ve sonra nerede kaldıysa devam edebilir. Bir generator fonksiyon ne zaman `yield` anahtar kelimesiyle karşılaşsa, yield'de belirtilen değeri verir. Dikkat edin, generator fonksiyon değeri _döndürmez_ (_return_), değeri _verir_ (_yield_).
 
 Önce, generator fonksiyonu `i`'yi `10`'a eşitleyerek başlatıyoruz. `next()` metodunu kullanarak generator fonksiyonu çalıştırıyoruz. İlk kez generator fonksiyonu çalıştırdığımızda, `i` `10`'a eşit. Fonksiyon ilk `yield` anahtar kelimesi ile karşılaşıyor: `i`'nin değerini veriyor. Generatır şimdi "durdu", ve `10` loglandı.
 
@@ -1354,7 +1361,7 @@ const secondPromise = new Promise((res, rej) => {
   setTimeout(res, 100, "two");
 });
 
-Promise.race([firstPromise, secondPromise]).then(res => console.log(res));
+Promise.race([firstPromise, secondPromise]).then((res) => console.log(res));
 ```
 
 - A: `"one"`
@@ -1406,7 +1413,7 @@ Sonra, `person` değişkenini `null`'a eşit olarak ayarlarız.
 
 <img src="https://i.imgur.com/sYjcsMT.png" width="300">
 
-Sadece `person` değişkeninin değerini değiştiriyoruz, dizideki ilk elemanı değil, ilk eleman nesneyi gösteren farklı (kopyalanmış) bir referansa sahip. `members` içindeki ilk eleman hala orijinal nesneyi gösteren referansını saklıyor. `members` dizisini logladığımız zaman, ilk elemanın hala sakladığı nesnenin değeri loglanır.  
+Sadece `person` değişkeninin değerini değiştiriyoruz, dizideki ilk elemanı değil, ilk eleman nesneyi gösteren farklı (kopyalanmış) bir referansa sahip. `members` içindeki ilk eleman hala orijinal nesneyi gösteren referansını saklıyor. `members` dizisini logladığımız zaman, ilk elemanın hala sakladığı nesnenin değeri loglanır.
 
 </p>
 </details>
@@ -1418,7 +1425,7 @@ Sadece `person` değişkeninin değerini değiştiriyoruz, dizideki ilk elemanı
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21
+  age: 21,
 };
 
 for (const item in person) {
@@ -1498,7 +1505,7 @@ Sadece string içindeki ilk sayılar döndürülür. _Sayı tabanına_ (hangi ti
 ###### 50. Çıktısı Nedir`?
 
 ```javascript
-[1, 2, 3].map(num => {
+[1, 2, 3].map((num) => {
   if (typeof num === "number") return;
   return num * 2;
 });
@@ -1514,7 +1521,7 @@ Sadece string içindeki ilk sayılar döndürülür. _Sayı tabanına_ (hangi ti
 
 #### Cevap: C
 
-Dizi üzerinde eşleme yaparken, `num`'ın değeri, o anda döngüye giren elemanın değerine eşittir. Bu durumda, elemanlar sayı, yani `typeof num === "number"` koşul ifadesi `true` durdurur. map fonksiyonu yeni bir dizi oluşturur ve fonksiyondan dönen değerleri yerleştirir. 
+Dizi üzerinde eşleme yaparken, `num`'ın değeri, o anda döngüye giren elemanın değerine eşittir. Bu durumda, elemanlar sayı, yani `typeof num === "number"` koşul ifadesi `true` durdurur. map fonksiyonu yeni bir dizi oluşturur ve fonksiyondan dönen değerleri yerleştirir.
 
 Ancak, biz değer döndürmüyoruz. Bir fonksiyondan değer döndürmediğimiz zaman, fonksiyon `undefined` döndürür. Dizideki her eleman için, fonksiyon bloğu çağrılır, yani her bir eleman için `undefined` döndürürüz.
 
@@ -1675,7 +1682,7 @@ class Dog {
   }
 }
 
-Dog.prototype.bark = function() {
+Dog.prototype.bark = function () {
   console.log(`Woof I am ${this.name}`);
 };
 
@@ -1903,7 +1910,7 @@ console.log(Object.keys(person));
 const settings = {
   username: "lydiahallie",
   level: 19,
-  health: 90
+  health: 90,
 };
 
 const data = JSON.stringify(settings, ["level", "health"]);
@@ -1922,7 +1929,7 @@ console.log(data);
 
 `JSON.stringify`'ın ikinci argumanı _değiştiricidir_, _"replacer"_. Değiştirici bir fonksiyon ya da bir dizi olabilir, ve değerlerin hangilerinin ve nasıl string'e dönüşeceğini kontrol etmenize izin verir.
 
-Eğer değiştirici _dizi_ ise, sadece dizi içinde ismi geçem özellikler JSON string'e dahil edilmiş olur. Bu durumda, sadece  `"level"` ve `"health"` isimli özellikler dahil edildi, `"username"` dışarıda bırakıldı. `data`, `"{"level":19, "health":90}"` eşittir.
+Eğer değiştirici _dizi_ ise, sadece dizi içinde ismi geçem özellikler JSON string'e dahil edilmiş olur. Bu durumda, sadece `"level"` ve `"health"` isimli özellikler dahil edildi, `"username"` dışarıda bırakıldı. `data`, `"{"level":19, "health":90}"` eşittir.
 
 Eğer değiştirici _fonksiyon_ ise, stringe dönüştürülen her özellik için bu fonksiyon çağrılır. Bu fonksiyondan dönen değer, JSON stringe eklenmiş olacak özelliğin değeri olacaktır. Eğer değer `undefined`'sa, bu özellik JSON stringe dahil edilmez.
 
@@ -1937,7 +1944,7 @@ Eğer değiştirici _fonksiyon_ ise, stringe dönüştürülen her özellik içi
 let num = 10;
 
 const increaseNumber = () => num++;
-const increasePassedNumber = number => number++;
+const increasePassedNumber = (number) => number++;
 
 const num1 = increaseNumber();
 const num2 = increasePassedNumber(num1);
@@ -2025,7 +2032,7 @@ Bu örnekte, geriye bir değer döndürmüyoruz, sadece biriktiricinin değerini
 
 Biriktiricinin değeri, bir önceki callback fonksiyonunun dönen değerine eşittir. Eğer, opsiyonel olan `initialValue` agümanını `reduce` methoduna geçmezseniz, biriktiricinin değeri, ilk çağrılışta gelen elemana eşit olur.
 
-İlk çağrılışta, biriktirici (`x`) `1`'dir, ve `y`'nin o anki değeri `2`'dir. callback fonksiyonundan bir şey döndürmüyoruz, biriktiriciyi ve o anki değeri logluyoruz: `1`  ve `2` loglanır.
+İlk çağrılışta, biriktirici (`x`) `1`'dir, ve `y`'nin o anki değeri `2`'dir. callback fonksiyonundan bir şey döndürmüyoruz, biriktiriciyi ve o anki değeri logluyoruz: `1` ve `2` loglanır.
 
 Eğer bir fonksiyondan değer döndürmezseniz, fonksiyon `undefined` döndürür. Sonraki çağrılışta, biriktirici `undefined`, ve o anki geçerli değer `3`'tür. `undefined` ve `3` loglanır.
 
@@ -2046,7 +2053,7 @@ class Dog {
 };
 
 class Labrador extends Dog {
-  // 1 
+  // 1
   constructor(name, size) {
     this.size = size;
   }
@@ -2060,7 +2067,7 @@ class Labrador extends Dog {
     super(name);
     this.size = size;
   }
-  // 4 
+  // 4
   constructor(name, size) {
     this.name = name;
     this.size = size;
@@ -2083,7 +2090,7 @@ Türetilmiş bir sınıfta, `super`'i çağırmadan önce `this` anahtar kelimes
 
 `super` anahtar kelimesiyle, parent sınıfın yapıcı methodunu verilen argümanlarla beraber çağırırız. Parent sınıfın yapıcısı `name` argümanını alıyor, bu yüzden `super`'e `name`'i vermemiz gerek.
 
-`Dog` sınıfı iki argüman alıyor, `name` `Animal` sınıfından türediğinden, ve `size` `Dog` sınıfı üzerinde ekstra özellik olarak. İkisinin de `Dog` yapıcı methoduna  geçilmesi gerek, bu da 2. yapıcı methodda doğru şekilde kullanılarak yapılmıştır.
+`Dog` sınıfı iki argüman alıyor, `name` `Animal` sınıfından türediğinden, ve `size` `Dog` sınıfı üzerinde ekstra özellik olarak. İkisinin de `Dog` yapıcı methoduna geçilmesi gerek, bu da 2. yapıcı methodda doğru şekilde kullanılarak yapılmıştır.
 
 </p>
 </details>
@@ -2094,12 +2101,12 @@ Türetilmiş bir sınıfta, `super`'i çağırmadan önce `this` anahtar kelimes
 
 ```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;
 ```
 
@@ -2125,9 +2132,9 @@ CommonJS'deki `require()` ve `import` arasındaki fark budur! `require()` ile, b
 ###### 68. Çıktısı Nedir?
 
 ```javascript
-console.log(Number(2) === Number(2))
-console.log(Boolean(false) === Boolean(false))
-console.log(Symbol('foo') === Symbol('foo'))
+console.log(Number(2) === Number(2));
+console.log(Boolean(false) === Boolean(false));
+console.log(Symbol("foo") === Symbol("foo"));
 ```
 
 - A: `true`, `true`, `false`
@@ -2150,15 +2157,15 @@ Her Symbol tamamen benzersizdir. Symbol'e geçilen argümanın amacı, Symbol'e
 ###### 69. Çıktısı Nedir?
 
 ```javascript
-const name = "Lydia Hallie"
-console.log(name.padStart(13))
-console.log(name.padStart(2))
+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"`, 
+- D: `"Lydia Hallie"`, `"Lyd"`,
 
 <details><summary><b>Cevap</b></summary>
 <p>
@@ -2191,6 +2198,7 @@ console.log("🥑" + "💻");
 #### Cevap: A
 
 `+` operatörü ile stringleri birleştirebilirsiniz. Bu örnekte, `"🥑"` ile `"💻"` birleştiriyoruz, `"🥑💻"` olarak sonuçlanıyor.
+
 </p>
 </details>
 
@@ -2386,7 +2394,7 @@ Eşitliğin sağ tarafındaki nesneden `name` özelliğini çıkarttığımız z
 
 `{ name: myName }` ile, JavaScript'e diyoruz ki; eşitliğin sağ tarafındaki `name` özelliğinin değeriyle birlikte `myName` diye bir değişken tanımlamak istiyoruz.
 
-`name`'i loglamayı denediğimizden dolayı, ki bu değişken tanımlanmamış, ReferenceError fırlatılır. 
+`name`'i loglamayı denediğimizden dolayı, ki bu değişken tanımlanmamış, ReferenceError fırlatılır.
 
 </p>
 </details>
@@ -2423,7 +2431,7 @@ Saf fonksiyon, aynı argümanlar geçildiği zaman, _her zaman_ aynı sonucu dö
 ```javascript
 const add = () => {
   const cache = {};
-  return num => {
+  return (num) => {
     if (num in cache) {
       return `From cache! ${cache[num]}`;
     } else {
@@ -2455,9 +2463,9 @@ console.log(addFunction(5 * 2));
 Eğer `addFunction` fonksiyonunu aynı argüman ile tekrar çağırırsak, önce cache içinde o değerin hali hazırda olup olmadığını kontrol eder. Eğer varsa, cache değeri döndürülecektir ki böylece çalışma zamanından tasarruf sağlanır. Eğer yoksa, cache'lenmemişse, değeri hesaplayıp ardından saklayacaktır.
 
 `addFunction` fonksiyonunu üç kez aynı değer ile çağırıyoruz: ilk çağırmada, `num` `10`'a eşit olduğu zaman fonksiyonun değeri henüz cache'lenmemiş. `num in cache` if ifadesi `false` döndürür
- ve else bloğu çalıştırılır: `Calculated! 20` loglanır, ve sonuç cache nesnesine eklenir. `cache` şimdi şuna benziyor; `{ 10: 20 }`
+ve else bloğu çalıştırılır: `Calculated! 20` loglanır, ve sonuç cache nesnesine eklenir. `cache` şimdi şuna benziyor; `{ 10: 20 }`
 
-İkincide, `cache` nesnesi `10` için döndürülen değeri içeriyor. `num in cache` if ifadesi `true` döndürür, ve `'From cache! 20'` loglanır. 
+İkincide, `cache` nesnesi `10` için döndürülen değeri içeriyor. `num in cache` if ifadesi `true` döndürür, ve `'From cache! 20'` loglanır.
 
 Üçüncü sefer de, fonksiyona `5 * 2` geçiyoruz ki bu da `10` olarak değerlendirilir. `cache` nesnesi `10` için döndürülen değeri içeriyor. `num in cache` if ifadesi `true` döndürür, ve `'From cache! 20'` loglanır.
 
@@ -2469,21 +2477,21 @@ Eğer `addFunction` fonksiyonunu aynı argüman ile tekrar çağırırsak, önce
 ###### <a name=20190726></a>79. Çıktısı Nedir?
 
 ```javascript
-const myLifeSummedUp = ["☕", "💻", "🍷", "🍫"]
+const myLifeSummedUp = ["☕", "💻", "🍷", "🍫"];
 
 for (let item in myLifeSummedUp) {
-  console.log(item)
+  console.log(item);
 }
 
 for (let item of myLifeSummedUp) {
-  console.log(item)
+  console.log(item);
 }
 ```
 
 - A: `0` `1` `2` `3` ve `"☕"` ` "💻"` `"🍷"` `"🍫"`
 - B: `"☕"` ` "💻"` `"🍷"` `"🍫"` ve `"☕"` ` "💻"` `"🍷"` `"🍫"`
 - C: `"☕"` ` "💻"` `"🍷"` `"🍫"` ve `0` `1` `2` `3`
-- D:  `0` `1` `2` `3` ve `{0: "☕", 1: "💻", 2: "🍷", 3: "🍫"}`
+- D: `0` `1` `2` `3` ve `{0: "☕", 1: "💻", 2: "🍷", 3: "🍫"}`
 
 <details><summary><b>Cevap</b></summary>
 <p>
@@ -2506,14 +2514,14 @@ _for-of_ döngüsü ile, **yinelenebilirler** (**iterables**) üzerinde iterasyo
 ###### 80. Çıktısı Nedir?
 
 ```javascript
-const list = [1 + 2, 1 * 2, 1 / 2]
-console.log(list)
+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]`
+- D: `[1, 1, 1]`
 
 <details><summary><b>Cevap</b></summary>
 <p>
@@ -2533,16 +2541,16 @@ Eleman dönen değere eşit olacaktır. `1 + 2` `3` döndürür, `1 * 2` `2` dö
 
 ```javascript
 function sayHi(name) {
-  return `Hi there, ${name}`
+  return `Hi there, ${name}`;
 }
 
-console.log(sayHi())
+console.log(sayHi());
 ```
 
 - A: `Hi there, `
 - B: `Hi there, undefined`
 - C: `Hi there, null`
-- D:  `ReferenceError`
+- D: `ReferenceError`
 
 <details><summary><b>Cevap</b></summary>
 <p>
@@ -2565,21 +2573,21 @@ Bu örnekte, eğer bir değer geçmeseydik ya da `undefined` geçseydik, `name`
 ###### 82. Çıktısı Nedir?
 
 ```javascript
-var status = "😎"
+var status = "😎";
 
 setTimeout(() => {
-  const status = "😍"
+  const status = "😍";
 
   const data = {
     status: "🥑",
     getStatus() {
-      return this.status
-    }
-  }
+      return this.status;
+    },
+  };
 
-  console.log(data.getStatus())
-  console.log(data.getStatus.call(this))
-}, 0)
+  console.log(data.getStatus());
+  console.log(data.getStatus.call(this));
+}, 0);
 ```
 
 - A: `"🥑"` ve `"😍"`
@@ -2606,13 +2614,13 @@ setTimeout(() => {
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21
-}
+  age: 21,
+};
 
-let city = person.city
-city = "Amsterdam"
+let city = person.city;
+city = "Amsterdam";
 
-console.log(person)
+console.log(person);
 ```
 
 - A: `{ name: "Lydia", age: 21 }`
@@ -2624,13 +2632,13 @@ console.log(person)
 <p>
 
 #### Cevap: A
- 
+
 `city` değişkenini, `person` nesnesindeki `city` özelliğinin değerine eşitledik. `person` nesnesinde `city` diye isimlendirilmiş bir özellik yok, bu yüzden `city` değişkeni `undefined` değerine sahip olur.
 
 `person` nesnesinin kendisini referans _göstermediğimize_ dikkat edin! Sadece `city` değişkenini, `person` nesnesindeki `city` özelliğinin o andaki değerine eşitledik.
 
 Sonra, `city`'i `"Amsterdam"` string'ine eşitledik. Bu `person` nesnesini değiştirmez: bu nesneye referans yok.
-  
+
 `person` nesnesini logladığımız zaman, değişikliğe uğramamış nesne döndürülür.
 
 </p>
@@ -2643,15 +2651,15 @@ Sonra, `city`'i `"Amsterdam"` string'ine eşitledik. Bu `person` nesnesini deği
 ```javascript
 function checkAge(age) {
   if (age < 18) {
-    const message = "Sorry, you're too young."
+    const message = "Sorry, you're too young.";
   } else {
-    const message = "Yay! You're old enough!"
+    const message = "Yay! You're old enough!";
   }
 
-  return message
+  return message;
 }
 
-console.log(checkAge(21))
+console.log(checkAge(21));
 ```
 
 - A: `"Sorry, you're too young."`
@@ -2674,15 +2682,15 @@ console.log(checkAge(21))
 ###### 85. Loglanacak değer ne tür olur?
 
 ```javascript
-fetch('https://www.website.com/api/user/1')
-  .then(res => res.json())
-  .then(res => console.log(res))
+fetch("https://www.website.com/api/user/1")
+  .then((res) => res.json())
+  .then((res) => console.log(res));
 ```
 
 - A: `fetch` methodunun sonucu.
 - B: `fetch` methodunun ikinci kez çağrılmasından dönen sonuç.
 - C: Bir önceki `.then()`'in sonucu.
-- D: Her zaman `undefined` olacaktır. 
+- D: Her zaman `undefined` olacaktır.
 
 <details><summary><b>Cevap</b></summary>
 <p>
@@ -2730,7 +2738,7 @@ function getName(name) {
 ###### <a name=20190805></a>87. Çıktısı Nedir?
 
 ```javascript
-console.log("I want pizza"[0])
+console.log("I want pizza"[0]);
 ```
 
 - A: `"""`
@@ -2756,10 +2764,10 @@ Bu yöntemin IE7 ve altında desteklenmediğine dikkat edin. Bu durumda, `.charA
 
 ```javascript
 function sum(num1, num2 = num1) {
-  console.log(num1 + num2)
+  console.log(num1 + num2);
 }
 
-sum(10)
+sum(10);
 ```
 
 - A: `NaN`
@@ -2773,7 +2781,7 @@ sum(10)
 #### Cevap: B
 
 Varsayılan parametrenin değerini fonksiyonun başka parametresine eşitleyebilirsiniz, varsayılan parametreden _önce_ tanımladıkları müddetçe. `sum` fonksiyonuna `10` değerini geçtik. Eğer `sum` fonksiyonu sadece 1 argüman alırsa, `num2` değeri geçilmedi demektir, ve `num1`'ın değeri geçtiğimiz `10` değerine eşittir bu durumda. `num2`'nun varsayılan değeri `num1`'dır ki o da `10`'dur. `num1 + num2` `20` döndürür.
- 
+
 Eğer varsayılan parametrenin değerini, _sonrasında_ (sağında) tanımlanmış bir parametreye eşitlemeye çalışıyorsanız, parametrenin değeri henüz oluşturulmamıştır, hata fırlatacaktır.
 
 </p>
@@ -2784,14 +2792,14 @@ Eğer varsayılan parametrenin değerini, _sonrasında_ (sağında) tanımlanmı
 ###### 89. Çıktısı Nedir?
 
 ```javascript
-// module.js 
-export default () => "Hello world"
-export const name = "Lydia"
+// module.js
+export default () => "Hello world";
+export const name = "Lydia";
 
-// index.js 
-import * as data from "./module"
+// index.js
+import * as data from "./module";
 
-console.log(data)
+console.log(data);
 ```
 
 - A: `{ default: function default(), name: "Lydia" }`
@@ -2818,12 +2826,12 @@ console.log(data)
 ```javascript
 class Person {
   constructor(name) {
-    this.name = name
+    this.name = name;
   }
 }
 
-const member = new Person("John")
-console.log(typeof member)
+const member = new Person("John");
+console.log(typeof member);
 ```
 
 - A: `"class"`
@@ -2840,7 +2848,7 @@ Sınıflar fonksiyon yapıcıları için "syntactical sugar"dır. `Person` sın
 
 ```javascript
 function Person() {
-  this.name = name
+  this.name = name;
 }
 ```
 
@@ -2854,9 +2862,9 @@ Bir fonksiyon yapıcısını `new` ile çağırmak `Person` "instance" oluşturu
 ###### 91. Çıktısı Nedir?
 
 ```javascript
-let newList = [1, 2, 3].push(4)
+let newList = [1, 2, 3].push(4);
 
-console.log(newList.push(5))
+console.log(newList.push(5));
 ```
 
 - A: `[1, 2, 3, 4, 5]`
@@ -2869,7 +2877,7 @@ console.log(newList.push(5))
 
 #### Cevap: D
 
-`.push` methodu dizinin _yeni uzunluğunu_ döndürür, dizinin kendisini değil! `newList`'i  `[1, 2, 3].push(4)`'a eşitleyerek, `newList`'i dizinin yeni uzunluğuna eşitledik: `4`.
+`.push` methodu dizinin _yeni uzunluğunu_ döndürür, dizinin kendisini değil! `newList`'i `[1, 2, 3].push(4)`'a eşitleyerek, `newList`'i dizinin yeni uzunluğuna eşitledik: `4`.
 
 Sonra, `.push` methodunu `newList` üzerinde kullanmayı denedik. `newList` sayısal değer `4` olduğundan, `.push` methodunu kullanamayız: TypeError fırlatılır.
 
@@ -2882,17 +2890,18 @@ Sonra, `.push` methodunu `newList` üzerinde kullanmayı denedik. `newList` say
 
 ```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)
+console.log(giveLydiaPizza.prototype);
+console.log(giveLydiaChocolate.prototype);
 ```
 
-- A: `{ constructor: ...}` `{ constructor: ...}` 
-- B: `{}` `{ constructor: ...}` 
+- A: `{ constructor: ...}` `{ constructor: ...}`
+- B: `{}` `{ constructor: ...}`
 - C: `{ constructor: ...}` `{}`
 - D: `{ constructor: ...}` `undefined`
 
@@ -2901,7 +2910,7 @@ console.log(giveLydiaChocolate.prototype)
 
 #### Cevap: D
 
-Sıradan fonksiyonlar, `giveLydiaPizza` gibi, `constructor` özelliği olan `prototype` nesnesi özelliğine sahiptir. Ancak ok fonksiyonlar (arrow functions), `giveLydiaChocolate` gibi, bu `prototype` özelliğine sahip değildir. `giveLydiaChocolate.prototype` ile `prototype` özelliğine erişmeye çalışıldığında `undefined` döndürülür. 
+Sıradan fonksiyonlar, `giveLydiaPizza` gibi, `constructor` özelliği olan `prototype` nesnesi özelliğine sahiptir. Ancak ok fonksiyonlar (arrow functions), `giveLydiaChocolate` gibi, bu `prototype` özelliğine sahip değildir. `giveLydiaChocolate.prototype` ile `prototype` özelliğine erişmeye çalışıldığında `undefined` döndürülür.
 
 </p>
 </details>
@@ -2913,16 +2922,16 @@ Sıradan fonksiyonlar, `giveLydiaPizza` gibi, `constructor` özelliği olan `pro
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21
-}
+  age: 21,
+};
 
 for (const [x, y] of Object.entries(person)) {
-  console.log(x, y)
+  console.log(x, y);
 }
 ```
 
 - A: `name` `Lydia` ve `age` `21`
-- B: `["name", "Lydia"]` ve `["age", 21]` 
+- B: `["name", "Lydia"]` ve `["age", 21]`
 - C: `["name", "age"]` ve `undefined`
 - D: `Error`
 
@@ -2933,7 +2942,7 @@ for (const [x, y] of Object.entries(person)) {
 
 `Object.entries(person)` key ve nesneleri içeren dizilerden oluşan dizi döndürür:
 
-`[ [ 'name', 'Lydia' ], [ 'age', 21 ] ]` 
+`[ [ 'name', 'Lydia' ], [ 'age', 21 ] ]`
 
 `for-of` döngüsünü kullanarak, dizi içindeki her bir elemanı gezebiliriz, alt dizileri bu örnekte. for-of döngüsü içinde alt dizileri `const [x, y]` kullanarak parçalayabiliriz. `x` alt dizideki ilk elemana, `y` alt dizideki ikinci elemana eşittir.
 
@@ -2956,7 +2965,7 @@ getItems(["banana", "apple"], "pear", "orange")
 ```
 
 - A: `["banana", "apple", "pear", "orange"]`
-- B: `[["banana", "apple"], "pear", "orange"]` 
+- B: `[["banana", "apple"], "pear", "orange"]`
 - C: `["banana", "apple", ["pear"], "orange"]`
 - D: `SyntaxError`
 
@@ -2969,10 +2978,10 @@ getItems(["banana", "apple"], "pear", "orange")
 
 ```javascript
 function getItems(fruitList, favoriteFruit, ...args) {
-  return [...fruitList, ...args, favoriteFruit]
+  return [...fruitList, ...args, favoriteFruit];
 }
 
-getItems(["banana", "apple"], "pear", "orange")
+getItems(["banana", "apple"], "pear", "orange");
 ```
 
 Yukarıdaki örnek çalışır. `[ 'banana', 'apple', 'orange', 'pear' ]` dizisini döndürür.
@@ -2986,17 +2995,14 @@ Yukarıdaki örnek çalışır. `[ 'banana', 'apple', 'orange', 'pear' ]` dizisi
 
 ```javascript
 function nums(a, b) {
-  if
-  (a > b)
-  console.log('a is bigger')
-  else 
-  console.log('b is bigger')
-  return 
-  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))
+console.log(nums(4, 2));
+console.log(nums(1, 2));
 ```
 
 - A: `a is bigger`, `6` ve `b is bigger`, `3`
@@ -3009,13 +3015,13 @@ console.log(nums(1, 2))
 
 #### Cevap: B
 
-JavaScript'te, noktalı virgülü (`;`) özellikle yazmak _zorunda değiliz_, ancak JavaScript motoru ifadelerden sonra noktalı virgül eklemektedir. bu **Automatic Semicolon Insertion**, **Otomatik Noktalı Virgül Ekleme**, olarak adlandırılır. İfade, örneğin, değişkenler ya da `throw`, `return`, `break`, vb. gibi anahtar kelimeler olabilir. 
+JavaScript'te, noktalı virgülü (`;`) özellikle yazmak _zorunda değiliz_, ancak JavaScript motoru ifadelerden sonra noktalı virgül eklemektedir. bu **Automatic Semicolon Insertion**, **Otomatik Noktalı Virgül Ekleme**, olarak adlandırılır. İfade, örneğin, değişkenler ya da `throw`, `return`, `break`, vb. gibi anahtar kelimeler olabilir.
+
+Burada, bir `return` ifadesi yazdık, ve _yeni bir satırda_ başka bir değer olarak `a + b`. Ancak, `a + b` yeni satırda olduğundan, JavaScript motoru onun aslında bizim döndürmek istediğimiz değer olduğunu bilmiyor. Onun yerine, `return`'den sonra otomatik olarak noktalı virgül ekliyor. Şöyle düşünebilirsiniz:
 
-Burada, bir `return` ifadesi yazdık, ve _yeni bir satırda_ başka bir değer olarak `a + b`. Ancak, `a + b` yeni satırda olduğundan, JavaScript motoru onun aslında bizim döndürmek istediğimiz değer olduğunu bilmiyor. Onun yerine, `return`'den sonra otomatik olarak noktalı virgül ekliyor. Şöyle düşünebilirsiniz: 
-  
 ```javascript
-  return;
-  a + b
+return;
+a + b;
 ```
 
 Fonksiyon `return` anahtar kelimesinden sonra çalışmayı durduracağından, `a + b` asla ulaşılamaz demektir. Eğer hiçbir değer döndürülmezse, fonksiyon `undefined` döndürür. Dikkat etmeniz gereken, `if/else` ifadelerinden sonra otomatik ekleme yapılmadığıdır!
@@ -3030,18 +3036,18 @@ Fonksiyon `return` anahtar kelimesinden sonra çalışmayı durduracağından, `
 ```javascript
 class Person {
   constructor() {
-    this.name = "Lydia"
+    this.name = "Lydia";
   }
 }
 
 Person = class AnotherPerson {
   constructor() {
-    this.name = "Sarah"
+    this.name = "Sarah";
   }
-}
+};
 
-const member = new Person()
-console.log(member.name)
+const member = new Person();
+console.log(member.name);
 ```
 
 - A: `"Lydia"`
@@ -3065,11 +3071,11 @@ Sınıfları diğer sınıf/fonksiyon yapıcılara eşitleyebiliriz. Bu örnekte
 
 ```javascript
 const info = {
-  [Symbol('a')]: 'b'
-}
+  [Symbol("a")]: "b",
+};
 
-console.log(info)
-console.log(Object.keys(info))
+console.log(info);
+console.log(Object.keys(info));
 ```
 
 - A: `{Symbol('a'): 'b'}` ve `["{Symbol('a')"]`
@@ -3084,7 +3090,7 @@ console.log(Object.keys(info))
 
 Symbol _sayılabilir_, "_enumerable_" değildir. Object.keys methodu nesne üzerindeki tüm _sayılabilir_ özellikleri döndürür. Symbol gizli kalır ve boş bir dizi döndürülür. Tüm nesne loglandığı zaman, bütün özellikler görülebilir, sayılabilir olmayanlar bile.
 
-Bu symbol'ün birçok  özelliğinden birisidir: tamamen benzersiz bir değer temsil etmenin yanında (ki nesneler üzerindeki kazara isim çakışmasını önler, örneğin aynı nesneye özellikler eklemek isteyen 2 kütüphaneyle çalışırken), ayrıca bu yolla nesne üzerindeki özellikleri "saklayabilirsiniz" (gerçi tamamen değil. `Object.getOwnPropertySymbols()` methodunu kullanarak symbol'lere hala erişebilirsiniz).
+Bu symbol'ün birçok özelliğinden birisidir: tamamen benzersiz bir değer temsil etmenin yanında (ki nesneler üzerindeki kazara isim çakışmasını önler, örneğin aynı nesneye özellikler eklemek isteyen 2 kütüphaneyle çalışırken), ayrıca bu yolla nesne üzerindeki özellikleri "saklayabilirsiniz" (gerçi tamamen değil. `Object.getOwnPropertySymbols()` methodunu kullanarak symbol'lere hala erişebilirsiniz).
 
 </p>
 </details>
@@ -3116,13 +3122,13 @@ console.log(getUser(user))
 
 `getList` fonksiyonu argüman olarak bir dizi alır. `getList` fonksiyonunun parentezleri arasında, bu diziyi anında parçalıyoruz. Şu şekilde görebilirsiniz:
 
- `[x, ...y] = [1, 2, 3, 4]`
+`[x, ...y] = [1, 2, 3, 4]`
 
- `...y` rest parametresi ile, dizi içinde "geriye kalan" tüm argümanları topluyoruz. Geriye kalan argümanlar `2`, `3`, ve `4` bu durumda. `y`'nin değeri tüm rest parametleri içeren bir dizi. `x`'in değeri `1`'a eşit, yani `[x, y]` logladığımız zaman, `[1, [2, 3, 4]]` loglanır.
+`...y` rest parametresi ile, dizi içinde "geriye kalan" tüm argümanları topluyoruz. Geriye kalan argümanlar `2`, `3`, ve `4` bu durumda. `y`'nin değeri tüm rest parametleri içeren bir dizi. `x`'in değeri `1`'a eşit, yani `[x, y]` logladığımız zaman, `[1, [2, 3, 4]]` loglanır.
 
- `getUser` fonksiyonu bir nesne alıyor. Ok fonksiyonlar ile, eğer sadece bir değer döndürmek istiyorsak süslü parentezleri yazmak _zorunda değiliz._ Ancak, bir ok fonksiyondan bir _nesne_ döndürmek istiyorsanız, parentezler arasında yazmak zorundasınız, aksi halde değer döndürülmez! Aşağıdaki fonksiyon bir nesne döndürecektir:
+`getUser` fonksiyonu bir nesne alıyor. Ok fonksiyonlar ile, eğer sadece bir değer döndürmek istiyorsak süslü parentezleri yazmak _zorunda değiliz._ Ancak, bir ok fonksiyondan bir _nesne_ döndürmek istiyorsanız, parentezler arasında yazmak zorundasınız, aksi halde değer döndürülmez! Aşağıdaki fonksiyon bir nesne döndürecektir:
 
-```const getUser = user => ({ name: user.name, age: user.age })```
+`const getUser = user => ({ name: user.name, age: user.age })`
 
 Bu örnekte değer döndürülmediği için, fonksiyon `undefined` döndürür.
 
@@ -3134,9 +3140,9 @@ Bu örnekte değer döndürülmediği için, fonksiyon `undefined` döndürür.
 ###### 99. Çıktısı Nedir?
 
 ```javascript
-const name = "Lydia"
+const name = "Lydia";
 
-console.log(name())
+console.log(name());
 ```
 
 - A: `SyntaxError`
@@ -3149,11 +3155,11 @@ console.log(name())
 
 #### Cevap: C
 
- `name` değişkeni string bir değer saklıyor, ki bu bir fonksiyon değil, bu yüzden çağrılamaz.
+`name` değişkeni string bir değer saklıyor, ki bu bir fonksiyon değil, bu yüzden çağrılamaz.
 
-TypeError'lar bir değer beklenilen tipte olmadığı zaman fırlatılır. `name`'i çağırmaya çalıştığımızdan, JavaScript `name`'in bir fonksiyon olmasını bekliyor. Ancak o bir string, bu yüzden TypeError fırlatılır: name is not a function! 
+TypeError'lar bir değer beklenilen tipte olmadığı zaman fırlatılır. `name`'i çağırmaya çalıştığımızdan, JavaScript `name`'in bir fonksiyon olmasını bekliyor. Ancak o bir string, bu yüzden TypeError fırlatılır: name is not a function!
 
-SyntaxError'lar JavaScript'in geçerli olmadığı bir şeyler yazdığız zaman fırlatılır, örneğin `return`'ü `retrun` olarak yazdığınız zaman.  
+SyntaxError'lar JavaScript'in geçerli olmadığı bir şeyler yazdığız zaman fırlatılır, örneğin `return`'ü `retrun` olarak yazdığınız zaman.
 
 ReferenceError'lar erişmeye çalıştığınız değer için JavaScript referans bulamadığı zaman fırlatılır.
 
@@ -3167,8 +3173,8 @@ ReferenceError'lar erişmeye çalıştığınız değer için JavaScript referan
 ```javascript
 // 🎉✨ 100. soru! ✨🎉
 
-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`
@@ -3183,7 +3189,7 @@ You should${'' && `n't`} see a therapist after so much JavaScript lol`
 
 `[]` doğrusal bir değerdir. `&&` operatörü ile, eğer soldaki değer doğrusal bir değerse sağdaki değer döndürülür. Bu örnekte, soldaki değer `[]` doğrusal bir değerdir, böylece `"Im"` döndürülür.
 
-`""` yanlış-ımsı bir değerdir. Eğer soldaki değer yanlış-ımsı ise, bir şey döndürülmez. `n't` döndürülmedi. 
+`""` yanlış-ımsı bir değerdir. Eğer soldaki değer yanlış-ımsı ise, bir şey döndürülmez. `n't` döndürülmedi.
 
 </p>
 </details>
@@ -3193,11 +3199,11 @@ You should${'' && `n't`} see a therapist after so much JavaScript lol`
 ###### 101. Çıktısı Nedir?
 
 ```javascript
-const one = (false || {} || null)
-const two = (null || false || "")
-const three = ([] || 0 || true)
+const one = false || {} || null;
+const two = null || false || "";
+const three = [] || 0 || true;
 
-console.log(one, two, three)
+console.log(one, two, three);
 ```
 
 - A: `false` `null` `[]`
diff --git a/uk-UA/README.md b/uk-UA/README.md
index 3b38c921..aeb4f3ee 100644
--- a/uk-UA/README.md
+++ b/uk-UA/README.md
@@ -20,6 +20,7 @@
 - [🇳🇱 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)
@@ -100,7 +101,7 @@ const shape = {
   diameter() {
     return this.radius * 2;
   },
-  perimeter: () => 2 * Math.PI * this.radius
+  perimeter: () => 2 * Math.PI * this.radius,
 };
 
 shape.diameter();
@@ -157,12 +158,12 @@ shape.perimeter();
 
 ```javascript
 const bird = {
-  size: "small"
+  size: "small",
 };
 
 const mouse = {
   name: "Mickey",
-  small: true
+  small: true,
 };
 ```
 
@@ -356,7 +357,7 @@ function Person(firstName, lastName) {
 }
 
 const member = new Person("Lydia", "Hallie");
-Person.getFullName = function() {
+Person.getFullName = function () {
   return `${this.firstName} ${this.lastName}`;
 };
 
@@ -376,7 +377,7 @@ console.log(member.getFullName());
 Не можна додавати властивості конструктору, як звичайному об'єкту. Якщо потрібно додати фічу до всіх об'єктів, то необхідно використовувати прототипи. В даному випадку,
 
 ```js
-Person.prototype.getFullName = function() {
+Person.prototype.getFullName = function () {
   return `${this.firstName} ${this.lastName}`;
 };
 ```
@@ -832,7 +833,7 @@ String.prototype.giveLydiaPizza = () => {
 
 const name = "Lydia";
 
-console.log(name.giveLydiaPizza())
+console.log(name.giveLydiaPizza());
 ```
 
 - A: `"Just give Lydia pizza already!"`
@@ -944,9 +945,7 @@ baz();
 ```html
 <div onclick="console.log('first div')">
   <div onclick="console.log('second div')">
-    <button onclick="console.log('button')">
-      Click!
-    </button>
+    <button onclick="console.log('button')">Click!</button>
   </div>
 </div>
 ```
@@ -972,9 +971,7 @@ baz();
 
 ```html
 <div onclick="console.log('div')">
-  <p onclick="console.log('p')">
-    Click here!
-  </p>
+  <p onclick="console.log('p')">Click here!</p>
 </div>
 ```
 
@@ -1209,7 +1206,10 @@ console.log(numbers);
 ###### 40. Що буде в консолі?
 
 ```javascript
-[[0, 1], [2, 3]].reduce(
+[
+  [0, 1],
+  [2, 3],
+].reduce(
   (acc, cur) => {
     return acc.concat(cur);
   },
@@ -1344,21 +1344,20 @@ console.log(gen.next().value);
 </p>
 </details>
 
-
 ---
 
 ###### 45. Що повернеться?
 
 ```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));
+Promise.race([firstPromise, secondPromise]).then((res) => console.log(res));
 ```
 
 - A: `"one"`
@@ -1381,7 +1380,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;
 
diff --git a/vi-VI/README-vi.md b/vi-VI/README-vi.md
index 8750b2d6..249532dd 100644
--- a/vi-VI/README-vi.md
+++ b/vi-VI/README-vi.md
@@ -7,6 +7,7 @@ Các câu hỏi sẽ từ cơ bản đến nâng cao: kiểm tra trình độ Ja
 Các đáp án được đặt dưới mỗi câu hỏi, hãy click để tham khảo chúng. Chúc may mắn :heart:
 
 Danh sách các ngôn ngữ khác:
+
 - [🇸🇦 العربية](../ar-AR/README_AR.md)
 - [🇪🇬 اللغة العامية](../ar-EG/README_ar-EG.md)
 - [🇧🇦 Bosanski](../bs-BS/README-bs_BS.md)
@@ -21,6 +22,7 @@ Danh sách các ngôn ngữ khác:
 - [🇳🇱 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)
@@ -101,7 +103,7 @@ const shape = {
   diameter() {
     return this.radius * 2;
   },
-  perimeter: () => 2 * Math.PI * this.radius
+  perimeter: () => 2 * Math.PI * this.radius,
 };
 
 shape.diameter();
@@ -147,7 +149,7 @@ Khi không có giá trị `radius` tại object đó, nó sẽ trả về `undef
 
 Phép toán cộng `+` sẽ convert một toán hạng sang dạng number. `true` là `1`, và `false` is `0`.
 
-Chuỗi `'Lydia'` là một _truthy value_. Điều chúng ta thật sự đang hỏi chính là  "có phải một giá trị truthy là falsy?". Rõ ràng câu trả lời là `false` rồi.
+Chuỗi `'Lydia'` là một _truthy value_. Điều chúng ta thật sự đang hỏi chính là "có phải một giá trị truthy là falsy?". Rõ ràng câu trả lời là `false` rồi.
 
 </p>
 </details>
@@ -158,12 +160,12 @@ Chuỗi `'Lydia'` là một _truthy value_. Điều chúng ta thật sự đang
 
 ```javascript
 const bird = {
-  size: "small"
+  size: "small",
 };
 
 const mouse = {
   name: "Mickey",
-  small: true
+  small: true,
 };
 ```
 
@@ -183,14 +185,13 @@ JavaScript thông dịch (hay unboxes) từng câu lệnh. Khi chúng ta sử d
 
 `mouse[bird.size]`: Giá trị đầu tiên `bird.size` là `"small"`. `mouse["small"]` sẽ trả về `true`
 
-Tuy nhiên, khi chúng ta sử dụng dấu chấm `.`, điều trên không còn đúng nữa. `mouse` không hề có key nào tên là `bird`, có nghĩa `mouse.bird` sẽ là `undefined`. Sau đó chúng ta gọi `size` sử dụng chấm `.`: `mouse.bird.size`. Vì  `mouse.bird` là `undefined`, lời gọi sẽ trở thành `undefined.size`. Đây là một lời gọi không hợp lệ, nó sẽ throw ra một lỗi kiểu như `Cannot read property "size" of undefined`.
+Tuy nhiên, khi chúng ta sử dụng dấu chấm `.`, điều trên không còn đúng nữa. `mouse` không hề có key nào tên là `bird`, có nghĩa `mouse.bird` sẽ là `undefined`. Sau đó chúng ta gọi `size` sử dụng chấm `.`: `mouse.bird.size`. Vì `mouse.bird` là `undefined`, lời gọi sẽ trở thành `undefined.size`. Đây là một lời gọi không hợp lệ, nó sẽ throw ra một lỗi kiểu như `Cannot read property "size" of undefined`.
 
 </p>
 </details>
 
 ---
 
-
 ###### 6. Output là gì?
 
 ```javascript
@@ -213,7 +214,7 @@ console.log(d.greeting);
 
 #### Đáp án: A
 
-Trong JavaScript, tất cả các object sẽ được _tham chiếu_ khi chúng được gán _bằng_wwwww  một giá trị khác.
+Trong JavaScript, tất cả các object sẽ được _tham chiếu_ khi chúng được gán \_bằng_wwwww một giá trị khác.
 
 Đầu tiên, giá trị `c` có giá trị là một object. Sau đó, chúng ta gán `d` tham chiếu tới object mà `c` trỏ tới.
 
@@ -358,7 +359,7 @@ function Person(firstName, lastName) {
 }
 
 const member = new Person("Lydia", "Hallie");
-Person.getFullName = function() {
+Person.getFullName = function () {
   return `${this.firstName} ${this.lastName}`;
 };
 
@@ -378,7 +379,7 @@ console.log(member.getFullName());
 Chúng ta không thể add thêm một thuộc tính cho một constructor giống như một object thông thường. Nếu bạn muốn add thêm thuộc tính nào đó cho tất cả các object một lần, bạn phải dùng `prototype`. Trong trường hợp này cũng vậy.
 
 ```js
-Person.prototype.getFullName = function() {
+Person.prototype.getFullName = function () {
   return `${this.firstName} ${this.lastName}`;
 };
 ```
@@ -835,7 +836,7 @@ String.prototype.giveLydiaPizza = () => {
 
 const name = "Lydia";
 
-console.log(name.giveLydiaPizza())
+console.log(name.giveLydiaPizza());
 ```
 
 - A: `"Just give Lydia pizza already!"`
@@ -947,9 +948,7 @@ WebAPI không thể thêm thứ gì đó vào stack cho tới khi nó được s
 ```html
 <div onclick="console.log('first div')">
   <div onclick="console.log('second div')">
-    <button onclick="console.log('button')">
-      Click!
-    </button>
+    <button onclick="console.log('button')">Click!</button>
   </div>
 </div>
 ```
@@ -975,9 +974,7 @@ Phần tử sâu nhất trong các phần tử lồng nhau sẽ là target của
 
 ```html
 <div onclick="console.log('div')">
-  <p onclick="console.log('p')">
-    Click here!
-  </p>
+  <p onclick="console.log('p')">Click here!</p>
 </div>
 ```
 
@@ -1212,7 +1209,10 @@ Primitive types là `boolean`, `null`, `undefined`, `bigint`, `number`, `string`
 ###### 40. Output là gì?
 
 ```javascript
-[[0, 1], [2, 3]].reduce(
+[
+  [0, 1],
+  [2, 3],
+].reduce(
   (acc, cur) => {
     return acc.concat(cur);
   },
@@ -1360,7 +1360,7 @@ const secondPromise = new Promise((res, rej) => {
   setTimeout(res, 100, "two");
 });
 
-Promise.race([firstPromise, secondPromise]).then(res => console.log(res));
+Promise.race([firstPromise, secondPromise]).then((res) => console.log(res));
 ```
 
 - A: `"one"`
@@ -1424,7 +1424,7 @@ Chúng ta chỉ đơn thuần là thay đổi giá trị của biến `person` m
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21
+  age: 21,
 };
 
 for (const item in person) {
@@ -1504,7 +1504,7 @@ Chỉ có số đầu tiên trong chuỗi kí tự được trả về. Hệ cơ
 ###### 50. Output là gì?
 
 ```javascript
-[1, 2, 3].map(num => {
+[1, 2, 3].map((num) => {
   if (typeof num === "number") return;
   return num * 2;
 });
@@ -1681,7 +1681,7 @@ class Dog {
   }
 }
 
-Dog.prototype.bark = function() {
+Dog.prototype.bark = function () {
   console.log(`Woof I am ${this.name}`);
 };
 
@@ -1767,7 +1767,7 @@ console.log(myCounter);
 
 #### Đáp án: C
 
-Một module khi được import sẽ là __read-only__: chúng ta sẽ không thể chỉnh sửa module đó, chỉ có bản thân module đó có thể chỉnh sửa giá trị của nó mà thôi.
+Một module khi được import sẽ là **read-only**: chúng ta sẽ không thể chỉnh sửa module đó, chỉ có bản thân module đó có thể chỉnh sửa giá trị của nó mà thôi.
 
 Khi ta thay đổi giá trị cuả `myCounter`, nó sẽ throw ra một lỗi: `myCounter` là _read-only_ và không thể thay đổi.
 
@@ -1909,7 +1909,7 @@ Thêm nữa, các thuộc tính được thêm bởi `defineProperty` là mặc
 const settings = {
   username: "lydiahallie",
   level: 19,
-  health: 90
+  health: 90,
 };
 
 const data = JSON.stringify(settings, ["level", "health"]);
@@ -1943,7 +1943,7 @@ Nếu replacer là _function_, hàm này sẽ được gọi trên từng thuộ
 let num = 10;
 
 const increaseNumber = () => num++;
-const increasePassedNumber = number => number++;
+const increasePassedNumber = (number) => number++;
 
 const num1 = increaseNumber();
 const num2 = increasePassedNumber(num1);
@@ -2000,9 +2000,9 @@ Trong ES6 thì chúng ta có thể khởi tạo tham số với giá trị mặc
 
 Chú ý một điều là đối số sẽ được xét giá trị tại _call time_! Có nghĩa là mỗi khi chúng ta gọi hàm, một _object mới_ sẽ được tạo ra. Chúng ta gọi hàm `multiply` hai lần mà không truyền vào đối số nào cả: `x` sẽ nhận giá trị mặc định `{ number: 10 }`. Sau đó chúng ta sẽ ghi ra giá trị là `20`.
 
-Lần gọi thứ ba chúng ta truyền vào một đối số: chính là `value`. Toán tử `*=` chính là cách viết gọn của `x.number = x.number * 2`: chúng ta thay đổi giá trị của `x.number`, và ghi ra giá trị `20`. 
+Lần gọi thứ ba chúng ta truyền vào một đối số: chính là `value`. Toán tử `*=` chính là cách viết gọn của `x.number = x.number * 2`: chúng ta thay đổi giá trị của `x.number`, và ghi ra giá trị `20`.
 
-Tại lần gọi thứ tư, chúng ta truyền vào `value` một lần nữa. `x.number` trước đó đã bị thay đổi thành `20`, nên `x.number *= 2` sẽ ghi ra `40`. 
+Tại lần gọi thứ tư, chúng ta truyền vào `value` một lần nữa. `x.number` trước đó đã bị thay đổi thành `20`, nên `x.number *= 2` sẽ ghi ra `40`.
 
 </p>
 </details>
@@ -2025,17 +2025,18 @@ Tại lần gọi thứ tư, chúng ta truyền vào `value` một lần nữa.
 
 #### Đáp án: D
 
-Đối số đầu tiên của hàm `reduce` chính là _accumulator_ (tổng tích lũy), trong trường hợp này là `x`. Đối số thứ 2 chính là _giá trị hiện tại_, tức `y`. Với hàm reduce, ta sẽ gọi callback trên mỗi phần tử của mảng, cứ vậy cho tới khi ra đến một giá trị cuối cùng. 
+Đối số đầu tiên của hàm `reduce` chính là _accumulator_ (tổng tích lũy), trong trường hợp này là `x`. Đối số thứ 2 chính là _giá trị hiện tại_, tức `y`. Với hàm reduce, ta sẽ gọi callback trên mỗi phần tử của mảng, cứ vậy cho tới khi ra đến một giá trị cuối cùng.
 
 Trong trường hợp này, chúng ta không trả về bất cứ giá trị nào cả, mà đơn thuần chỉ là ghi ra giá trị của _tổng tích lũy_ và _giá trị hiện tại_ mà thôi.
 
 Giá trị của tổng tích lũy chính là giá trị được hàm callback trả về tại vòng lặp trước đó. Nếu ta không đặt giá trị khởi tạo cho đối số trong hàm `reduce`, thì tổng tích lũy sẽ chính bằng giá trị đầu tiên tại lời gọi đầu tiên.
 
-Trong lời gọi đầu tiên, tổng tích lũy (`x`) là `1`, và giá trị hiện tại (`y`) là `2`. Chúng ta không trả về giá trị cho hàm callback, mà đơn thuần chỉ ghi chúng ta, vậy nên `1` và `2` được ghi ra.  
+Trong lời gọi đầu tiên, tổng tích lũy (`x`) là `1`, và giá trị hiện tại (`y`) là `2`. Chúng ta không trả về giá trị cho hàm callback, mà đơn thuần chỉ ghi chúng ta, vậy nên `1` và `2` được ghi ra.
 
-Nếu ta không trả về giá trị trong một function, thì nó sẽ mặc định trả về là `undefined`. Do đó trong lời gọi tiếp theo tổng tích lũy sẽ là `undefined`, và giá trị hiện tại là `3`. `undefined` và `3` sẽ được ghi ra. 
+Nếu ta không trả về giá trị trong một function, thì nó sẽ mặc định trả về là `undefined`. Do đó trong lời gọi tiếp theo tổng tích lũy sẽ là `undefined`, và giá trị hiện tại là `3`. `undefined` và `3` sẽ được ghi ra.
 
 Tiếp tục như vậy, trong lời gọi thứ tư thì tổng tích lũy sẽ vẫn là `undefined`, giá trị hiện tại là `4`. `undefined` và `4` sẽ được ghi ra.
+
 </p>
 </details>
   
@@ -2051,7 +2052,7 @@ class Dog {
 };
 
 class Labrador extends Dog {
-  // 1 
+  // 1
   constructor(name, size) {
     this.size = size;
   }
@@ -2065,7 +2066,7 @@ class Labrador extends Dog {
     super(name);
     this.size = size;
   }
-  // 4 
+  // 4
   constructor(name, size) {
     this.name = name;
     this.size = size;
@@ -2086,9 +2087,10 @@ class Labrador extends Dog {
 
 Trong class dẫn xuất, ta không thể truy cập từ khóa `this` trước khi gọi `super`. Nếu bạn chạy thử, nó sẽ throw ra một `ReferenceError`, do đó 1 và 4 sẽ throw ra reference error.
 
-Với việc gọi `super`, chúng ta đã gọi hàm constructor của class cha với tham số truyền vào. Trong trường hợp này, class cha nhận `name` làm đối số trong constructor, do đó chúng cần đưa `name` vào hàm `super`. 
+Với việc gọi `super`, chúng ta đã gọi hàm constructor của class cha với tham số truyền vào. Trong trường hợp này, class cha nhận `name` làm đối số trong constructor, do đó chúng cần đưa `name` vào hàm `super`.
 
 `Labrador` class nhận vào hai đối số, `name` vì nó kế thừa `Dog`, và `size` - một thuộc tính của `Labrador` class. Cả hai đều cần thiết để đưa vào trong constructor của class `Labrador`, do đó cách khởi tạo đúng là 2.
+
 </p>
 </details>
 
@@ -2098,12 +2100,12 @@ Với việc gọi `super`, chúng ta đã gọi hàm constructor của class ch
 
 ```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;
 ```
 
@@ -2119,7 +2121,7 @@ export const sum = (a, b) => a + b;
 
 Với `import`, tất cả các module import vào đều sẽ được _pre-parsed_ (đánh giá trước). Có nghĩa là những module được import vào sẽ được _chạy trước_, còn code trong file sẽ _chạy sau_.
 
-Đó chính là điều khác biệt giữa `require()` trong CommonJS và `import`! Với `require()`, ta có thể load các dependencies tại bất cứ khi nào ta cần. Nếu ta sử dụng `require` thay thế cho `import` thì `running index.js`, `running sum.js`, `3` sẽ được ghi ra. 
+Đó chính là điều khác biệt giữa `require()` trong CommonJS và `import`! Với `require()`, ta có thể load các dependencies tại bất cứ khi nào ta cần. Nếu ta sử dụng `require` thay thế cho `import` thì `running index.js`, `running sum.js`, `3` sẽ được ghi ra.
 
 </p>
 </details>
@@ -2144,7 +2146,7 @@ console.log(Symbol('foo') === Symbol('foo'))****
 
 #### Đáp án: A
 
-Mỗi Symbol là một thứ hoàn toàn khác biệt. Giá trị truyền vào làm đối số trong Symbol chỉ đơn thuần là phần giải thích cho Symbol đó mà thôi, và nó không liên quan gì tới giá trị của Symbol đó cả. Chúng ta kiểm tra tính bằng nhau của hai Symbol hoàn toàn khác biệt: `Symbol('foo')` thứ nhất, và `Symbol('foo')` thứ hai. Mỗi giá trị đều là riêng biệt và duy nhất, nên `Symbol('foo') === Symbol('foo')` sẽ trả về `false`. 
+Mỗi Symbol là một thứ hoàn toàn khác biệt. Giá trị truyền vào làm đối số trong Symbol chỉ đơn thuần là phần giải thích cho Symbol đó mà thôi, và nó không liên quan gì tới giá trị của Symbol đó cả. Chúng ta kiểm tra tính bằng nhau của hai Symbol hoàn toàn khác biệt: `Symbol('foo')` thứ nhất, và `Symbol('foo')` thứ hai. Mỗi giá trị đều là riêng biệt và duy nhất, nên `Symbol('foo') === Symbol('foo')` sẽ trả về `false`.
 
 </p>
 </details>
@@ -2154,15 +2156,15 @@ Mỗi Symbol là một thứ hoàn toàn khác biệt. Giá trị truyền vào
 ###### 69. Output là gì?
 
 ```javascript
-const name = "Lydia Hallie"
-console.log(name.padStart(13))
-console.log(name.padStart(2))
+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"`, 
+- D: `"Lydia Hallie"`, `"Lyd"`,
 
 <details><summary><b>Đáp án</b></summary>
 <p>
@@ -2237,7 +2239,9 @@ Khi ta gọi `game.next("Yes").value`, `yield` trước đó sẽ được thay
 </details>
 
 ---
-****
+
+---
+
 ###### 72. Output là gì?
 
 ```javascript
@@ -2430,7 +2434,7 @@ Hàm `sum` luôn trả về giá trị giống nhau. Nếu ta đưa vào `1` và
 ```javascript
 const add = () => {
   const cache = {};
-  return num => {
+  return (num) => {
     if (num in cache) {
       return `From cache! ${cache[num]}`;
     } else {
@@ -2475,21 +2479,21 @@ Tại lần gọi thứ ba, ta đưa vào `5 * 2`, tức `10` vào hàm. Tiếp
 ###### 79. Output là gì?
 
 ```javascript
-const myLifeSummedUp = ["☕", "💻", "🍷", "🍫"]
+const myLifeSummedUp = ["☕", "💻", "🍷", "🍫"];
 
 for (let item in myLifeSummedUp) {
-  console.log(item)
+  console.log(item);
 }
 
 for (let item of myLifeSummedUp) {
-  console.log(item)
+  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: "🍫"}`
+- D: `0` `1` `2` `3` and `{0: "☕", 1: "💻", 2: "🍷", 3: "🍫"}`
 
 <details><summary><b>Đáp án</b></summary>
 <p>
@@ -2512,14 +2516,14 @@ Với vòng lặp _for-of_, chúng ta sẽ duyệt qua các phần tử của m
 ###### 80. Output là gì?
 
 ```javascript
-const list = [1 + 2, 1 * 2, 1 / 2]
-console.log(list)
+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]`
+- D: `[1, 1, 1]`
 
 <details><summary><b>Đáp án</b></summary>
 <p>
@@ -2528,7 +2532,7 @@ console.log(list)
 
 Mảng có thể nhận bất cứ giá trị nào. Số, chuỗi, objects, mảng khác, null, boolean, undefined, và nhiều dạng biểu thức nữa như ngày tháng, hàm, và các tính toán.
 
-Giá trị của phần tử chính là giá trị trả về.  `1 + 2` trả về `3`, `1 * 2` trả về `2`, và `1 / 2` trả về `0.5`.
+Giá trị của phần tử chính là giá trị trả về. `1 + 2` trả về `3`, `1 * 2` trả về `2`, và `1 / 2` trả về `0.5`.
 
 </p>
 </details>
@@ -2539,16 +2543,16 @@ Giá trị của phần tử chính là giá trị trả về.  `1 + 2` trả v
 
 ```javascript
 function sayHi(name) {
-  return `Hi there, ${name}`
+  return `Hi there, ${name}`;
 }
 
-console.log(sayHi())
+console.log(sayHi());
 ```
 
 - A: `Hi there, `
 - B: `Hi there, undefined`
 - C: `Hi there, null`
-- D:  `ReferenceError`
+- D: `ReferenceError`
 
 <details><summary><b>Đáp án</b></summary>
 <p>
@@ -2571,21 +2575,21 @@ Trong trường hợp này, nếu ta không đưa giá trị nào vào hoặc đ
 ###### 82. Output là gì?
 
 ```javascript
-var status = "😎"
+var status = "😎";
 
 setTimeout(() => {
-  const status = "😍"
+  const status = "😍";
 
   const data = {
     status: "🥑",
     getStatus() {
-      return this.status
-    }
-  }
+      return this.status;
+    },
+  };
 
-  console.log(data.getStatus())
-  console.log(data.getStatus.call(this))
-}, 0)
+  console.log(data.getStatus());
+  console.log(data.getStatus.call(this));
+}, 0);
 ```
 
 - A: `"🥑"` and `"😍"`
@@ -2612,13 +2616,13 @@ Với phương thức `call`, chúng ta thay đổi tham chiếu mà `this` tr
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21
-}
+  age: 21,
+};
 
-let city = person.city
-city = "Amsterdam"
+let city = person.city;
+city = "Amsterdam";
 
-console.log(person)
+console.log(person);
 ```
 
 - A: `{ name: "Lydia", age: 21 }`
@@ -2631,13 +2635,13 @@ console.log(person)
 
 #### Đáp án: A
 
-Chúng ta set biến `city` bằng với giá trị của thuộc tính `city` của object `person`. Nhưng object này không có thuộc tính nào là `city` cả, nên giá trị của biến `city` sẽ là `undefined`. 
+Chúng ta set biến `city` bằng với giá trị của thuộc tính `city` của object `person`. Nhưng object này không có thuộc tính nào là `city` cả, nên giá trị của biến `city` sẽ là `undefined`.
 
 Chú ý là chúng ta _không tham chiếu_ tới bản thân object `person`! Chúng ta chỉ đơn giản là set giá trị của biến `city` bằng với giá trị của thuộc tính `city` trong object `person` mà thôi.
 
 Sau đó chúng ta set biến `city` bằng với chuỗi `"Amsterdam"`. Điều này không hề ảnh hưởng gì tới object person vì không có tham chiếu nào ở đây cả.
 
-Do đó khi ghi object `person` ra, Tất cả các thuộc tính vẫn như cũ không hề thay đổi gì cả. 
+Do đó khi ghi object `person` ra, Tất cả các thuộc tính vẫn như cũ không hề thay đổi gì cả.
 
 </p>
 </details>
@@ -2649,15 +2653,15 @@ Do đó khi ghi object `person` ra, Tất cả các thuộc tính vẫn như cũ
 ```javascript
 function checkAge(age) {
   if (age < 18) {
-    const message = "Sorry, you're too young."
+    const message = "Sorry, you're too young.";
   } else {
-    const message = "Yay! You're old enough!"
+    const message = "Yay! You're old enough!";
   }
 
-  return message
+  return message;
 }
 
-console.log(checkAge(21))
+console.log(checkAge(21));
 ```
 
 - A: `"Sorry, you're too young."`
@@ -2680,15 +2684,15 @@ Biến số được khai báo với các từ khóa như `const` hay `let` đ
 ###### 85. Những thông tin nào sẽ được ghi ra?
 
 ```javascript
-fetch('https://www.website.com/api/user/1')
-  .then(res => res.json())
-  .then(res => console.log(res))
+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. 
+- D: It would always be undefined.
 
 <details><summary><b>Đáp án</b></summary>
 <p>
@@ -2736,7 +2740,7 @@ Bằng cách set `hasName` bằng với `name`, chúng ta set `hasName` bằng v
 ###### <a name=20190805></a>87. Output là gì?
 
 ```javascript
-console.log("I want pizza"[0])
+console.log("I want pizza"[0]);
 ```
 
 - A: `"""`
@@ -2762,10 +2766,10 @@ Chú ý là phương thức này không hoạt động với IE7 trở xuống.
 
 ```javascript
 function sum(num1, num2 = num1) {
-  console.log(num1 + num2)
+  console.log(num1 + num2);
 }
 
-sum(10)
+sum(10);
 ```
 
 - A: `NaN`
@@ -2780,7 +2784,7 @@ sum(10)
 
 Ta có thể set giá trị mặc định của một tham số là tham số khác trong hàm, miễn là tham số đó được khai báo _trước_ tham số mặc định. Chúng ta đưa `10` vào hàm `sum`. Nếu hàm `sum` chỉ nhận 1 đối số, nó có nghĩa là giá trị của `num2` không được đưa vào, nên nó sẽ lấy giá trị mặc định là giá trị của `num1` đã được đưa vào, hay chính là `10` trong trường hợp này. Khi này `num1 + num2` trả về `20`.
 
-Nếu chúng ta thử set một giá trị mặc định của tham số bằng với giá trị của tham số khai báo _sau_ (về bên phải), giá trị của tham số đó sẽ không được khởi tạo và dẫn đến throw ra lỗi. 
+Nếu chúng ta thử set một giá trị mặc định của tham số bằng với giá trị của tham số khai báo _sau_ (về bên phải), giá trị của tham số đó sẽ không được khởi tạo và dẫn đến throw ra lỗi.
 
 </p>
 </details>
@@ -2790,14 +2794,14 @@ Nếu chúng ta thử set một giá trị mặc định của tham số bằng
 ###### 89. Output là gì?
 
 ```javascript
-// module.js 
-export default () => "Hello world"
-export const name = "Lydia"
+// module.js
+export default () => "Hello world";
+export const name = "Lydia";
 
-// index.js 
-import * as data from "./module"
+// index.js
+import * as data from "./module";
 
-console.log(data)
+console.log(data);
 ```
 
 - A: `{ default: function default(), name: "Lydia" }`
@@ -2810,9 +2814,9 @@ console.log(data)
 
 #### Đáp án: A
 
-Cú pháp `import * as data` sẽ import _tất cả những gì được export_ từ `module.js` vào trong `index.js` và lưu trữ dưới một object có tên là `data`. Trong file `module.js`, có hai thứ được export ra: default export và một named export. Default export là một hàm trả về chuỗi `"Hello World"`, và named export là một biến `name` nhận giá trị là chuỗi `"Lydia"`. 
+Cú pháp `import * as data` sẽ import _tất cả những gì được export_ từ `module.js` vào trong `index.js` và lưu trữ dưới một object có tên là `data`. Trong file `module.js`, có hai thứ được export ra: default export và một named export. Default export là một hàm trả về chuỗi `"Hello World"`, và named export là một biến `name` nhận giá trị là chuỗi `"Lydia"`.
 
-Do đó `data` object có thuộc tính `default` cho default export, các thuộc tính khác sẽ có tên chính là tên của named exports và giá trị đi kèm. 
+Do đó `data` object có thuộc tính `default` cho default export, các thuộc tính khác sẽ có tên chính là tên của named exports và giá trị đi kèm.
 
 </p>
 </details>
@@ -2824,12 +2828,12 @@ Do đó `data` object có thuộc tính `default` cho default export, các thu
 ```javascript
 class Person {
   constructor(name) {
-    this.name = name
+    this.name = name;
   }
 }
 
-const member = new Person("John")
-console.log(typeof member)
+const member = new Person("John");
+console.log(typeof member);
 ```
 
 - A: `"class"`
@@ -2846,11 +2850,11 @@ Classes chỉ đơn thuần là `syntactical sugar` (cú pháp đặc biệt) c
 
 ```javascript
 function Person() {
-  this.name = name
+  this.name = name;
 }
 ```
 
-Gọi một constructor với từ khóa `new` sẽ tạo ra một instance của class `Person`, `typeof` sẽ trả về là `"object"` cho các instance. Do đó `typeof member` trả về `"object"`. 
+Gọi một constructor với từ khóa `new` sẽ tạo ra một instance của class `Person`, `typeof` sẽ trả về là `"object"` cho các instance. Do đó `typeof member` trả về `"object"`.
 
 </p>
 </details>
@@ -2860,9 +2864,9 @@ Gọi một constructor với từ khóa `new` sẽ tạo ra một instance củ
 ###### 91. Output là gì?
 
 ```javascript
-let newList = [1, 2, 3].push(4)
+let newList = [1, 2, 3].push(4);
 
-console.log(newList.push(5))
+console.log(newList.push(5));
 ```
 
 - A: `[1, 2, 3, 4, 5]`
@@ -2875,7 +2879,7 @@ console.log(newList.push(5))
 
 #### Đáp án: D
 
-Hàm `.push` trả về _độ dài mới_ của mảng, chứ không phải bản thân mảng đó! Bằng cách set `newList` bằng với `[1, 2, 3].push(4)`, ta đã set cho `newList` giá trị là `4` - tức độ dài của mảng lúc này. 
+Hàm `.push` trả về _độ dài mới_ của mảng, chứ không phải bản thân mảng đó! Bằng cách set `newList` bằng với `[1, 2, 3].push(4)`, ta đã set cho `newList` giá trị là `4` - tức độ dài của mảng lúc này.
 
 Sau đó chúng ta tiến hành `.push` trên `newList`. Vì `newList` là một số thông thường, ta không thể dùng `.push` được, nên sẽ throw ra một TypeError.
 
@@ -2888,17 +2892,18 @@ Sau đó chúng ta tiến hành `.push` trên `newList`. Vì `newList` là một
 
 ```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)
+console.log(giveLydiaPizza.prototype);
+console.log(giveLydiaChocolate.prototype);
 ```
 
-- A: `{ constructor: ...}` `{ constructor: ...}` 
-- B: `{}` `{ constructor: ...}` 
+- A: `{ constructor: ...}` `{ constructor: ...}`
+- B: `{}` `{ constructor: ...}`
 - C: `{ constructor: ...}` `{}`
 - D: `{ constructor: ...}` `undefined`
 
@@ -2907,7 +2912,7 @@ console.log(giveLydiaChocolate.prototype)
 
 #### Đáp án: D
 
-Hàm thông thường giống như `giveLydiaPizza`, sẽ có thuộc tính `prototype` là một object (prototype object) với một thuộc tính là `constructor`. Còn `arrow functions` giống như `giveLydiaChocolate`thì không có thuộc tính `prototype` này. `undefined` trả về khi ta truy cập thuộc tính `prototype` bằng cách gọi `giveLydiaChocolate.prototype`. 
+Hàm thông thường giống như `giveLydiaPizza`, sẽ có thuộc tính `prototype` là một object (prototype object) với một thuộc tính là `constructor`. Còn `arrow functions` giống như `giveLydiaChocolate`thì không có thuộc tính `prototype` này. `undefined` trả về khi ta truy cập thuộc tính `prototype` bằng cách gọi `giveLydiaChocolate.prototype`.
 
 </p>
 </details>
@@ -2919,16 +2924,16 @@ Hàm thông thường giống như `giveLydiaPizza`, sẽ có thuộc tính `pro
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21
-}
+  age: 21,
+};
 
 for (const [x, y] of Object.entries(person)) {
-  console.log(x, y)
+  console.log(x, y);
 }
 ```
 
 - A: `name` `Lydia` và `age` `21`
-- B: `["name", "Lydia"]` và `["age", 21]` 
+- B: `["name", "Lydia"]` và `["age", 21]`
 - C: `["name", "age"]` và `undefined`
 - D: `Error`
 
@@ -2939,9 +2944,9 @@ for (const [x, y] of Object.entries(person)) {
 
 `Object.entries(person)` sẽ trả về một mảng của mảng, bao gồm các key và các object:
 
-`[ [ 'name', 'Lydia' ], [ 'age', 21 ] ]` 
+`[ [ 'name', 'Lydia' ], [ 'age', 21 ] ]`
 
-Khí sử dụng `for-of`, chúng ta sẽ duyệt qua từng thành phần của mảng, trong trường hợp này chính là những mảng con. Đồng thời tiến hành gán giá trị luôn trong vongf lặp for-of, bằng cách sử dụng `const [x, y]`. Khi này `x` sẽ là phần tử đầu tiên trong mảng con, `y` chính là phần tử thứ hai trong mảng con. 
+Khí sử dụng `for-of`, chúng ta sẽ duyệt qua từng thành phần của mảng, trong trường hợp này chính là những mảng con. Đồng thời tiến hành gán giá trị luôn trong vongf lặp for-of, bằng cách sử dụng `const [x, y]`. Khi này `x` sẽ là phần tử đầu tiên trong mảng con, `y` chính là phần tử thứ hai trong mảng con.
 
 Mảng con đầu tiên là `[ "name", "Lydia" ]`, nên `x` sẽ là `"name"`, và `y` sẽ là `"Lydia"`, và được ghi ra.
 Mảng con thứ hai là `[ "age", 21 ]`, nên `x` sẽ là `"age"`, và `y` sẽ là `21`, và được ghi ra.
@@ -2962,7 +2967,7 @@ getItems(["banana", "apple"], "pear", "orange")
 ```
 
 - A: `["banana", "apple", "pear", "orange"]`
-- B: `[["banana", "apple"], "pear", "orange"]` 
+- B: `[["banana", "apple"], "pear", "orange"]`
 - C: `["banana", "apple", ["pear"], "orange"]`
 - D: `SyntaxError`
 
@@ -2971,17 +2976,18 @@ getItems(["banana", "apple"], "pear", "orange")
 
 #### Đáp án: D
 
-`...args` là cú pháp tham số cuối cùng. Giá trị của tham số cuối cùng chính là toàn bộ các đối số còn lại, **và nó là tham số cuối cùng duy nhất**! Trong trường hợp này, tham số cuối cùng lại là tham số thứ hai. Điều đó là không thể được, và sẽ throw ra một lỗi cú pháp. 
+`...args` là cú pháp tham số cuối cùng. Giá trị của tham số cuối cùng chính là toàn bộ các đối số còn lại, **và nó là tham số cuối cùng duy nhất**! Trong trường hợp này, tham số cuối cùng lại là tham số thứ hai. Điều đó là không thể được, và sẽ throw ra một lỗi cú pháp.
 
 ```javascript
 function getItems(fruitList, favoriteFruit, ...args) {
-  return [...fruitList, ...args, favoriteFruit]
+  return [...fruitList, ...args, favoriteFruit];
 }
 
-getItems(["banana", "apple"], "pear", "orange")
+getItems(["banana", "apple"], "pear", "orange");
 ```
 
 Nếu ta code như thế này thì lại đúng. Giá trị trả về sẽ là `[ 'banana', 'apple', 'orange', 'pear' ]`
+
 </p>
 </details>
 
@@ -2991,17 +2997,14 @@ Nếu ta code như thế này thì lại đúng. Giá trị trả về sẽ là
 
 ```javascript
 function nums(a, b) {
-  if
-  (a > b)
-  console.log('a is bigger')
-  else 
-  console.log('b is bigger')
-  return 
-  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))
+console.log(nums(4, 2));
+console.log(nums(1, 2));
 ```
 
 - A: `a is bigger`, `6` và `b is bigger`, `3`
@@ -3014,13 +3017,13 @@ console.log(nums(1, 2))
 
 #### Đáp án: B
 
-Với JavaScript, ta _không bắt buộc_ phải viết dấu chấm phẩy (`;`), JavaScript engine sẽ tự động thêm vào sau mỗi câu lệnh. Nó gọi là **Automatic Semicolon Insertion**. Một câu lệnh có thể là khai báo biến, hoặc từ khóa như `throw`, `return`, `break`, vv. 
+Với JavaScript, ta _không bắt buộc_ phải viết dấu chấm phẩy (`;`), JavaScript engine sẽ tự động thêm vào sau mỗi câu lệnh. Nó gọi là **Automatic Semicolon Insertion**. Một câu lệnh có thể là khai báo biến, hoặc từ khóa như `throw`, `return`, `break`, vv.
 
 Ở đây ta sử dụng câu lệnh `return` ở một dòng và giá trị `a + b` ở một _dòng khác_. Tuy nhiên do khác dòng nên JS engine không thể biết đâu là giá trị ta thực sự muốn trả về. Thay vì thế, nó sẽ tự động thêm vào dấu chấm phẩy ngay sau `return` giống như này:
 
 ```javascript
-  return;
-  a + b
+return;
+a + b;
 ```
 
 Có nghĩa là `a + b` sẽ không bao giờ được thực hiện, vì hàm đã được `return` rồi. Do không giá trị nào được trả về, nên giá trị trả về của hàm sẽ là `undefined`. Lưu ý là sẽ không tự động thêm dấu chấm phẩy ngay sau `if/else` đâu nhé!
@@ -3035,18 +3038,18 @@ Có nghĩa là `a + b` sẽ không bao giờ được thực hiện, vì hàm đ
 ```javascript
 class Person {
   constructor() {
-    this.name = "Lydia"
+    this.name = "Lydia";
   }
 }
 
 Person = class AnotherPerson {
   constructor() {
-    this.name = "Sarah"
+    this.name = "Sarah";
   }
-}
+};
 
-const member = new Person()
-console.log(member.name)
+const member = new Person();
+console.log(member.name);
 ```
 
 - A: `"Lydia"`
@@ -3070,11 +3073,11 @@ Chúng ta có thể set một class với giá trị là một classes/function
 
 ```javascript
 const info = {
-  [Symbol('a')]: 'b'
-}
+  [Symbol("a")]: "b",
+};
 
-console.log(info)
-console.log(Object.keys(info))
+console.log(info);
+console.log(Object.keys(info));
 ```
 
 - A: `{Symbol('a'): 'b'}` và `["{Symbol('a')"]`
@@ -3121,13 +3124,13 @@ console.log(getUser(user))
 
 Hàm `getList` nhận vào một mảng các đối số, và tiến hành xử lý mảng đó luôn khi đưa vào hàm:
 
- `[x, ...y] = [1, 2, 3, 4]`
+`[x, ...y] = [1, 2, 3, 4]`
 
- Với việc sử dụng cú pháp tham số cuối cùng `...y`, chúng ta đưa toàn bộ "những đối số còn lại" vào một mảng y. Trong trường hợp này đó là mảng gồm các phần tử `2`, `3` và `4`. Do đó giá trị của `y` lúc này chính là mảng `[2, 3, 4]`. Giá trị của `x` là `1`, nên khi ghi `[x, y]` ra, kết quả sẽ là `[1, [2, 3, 4]]`.
+Với việc sử dụng cú pháp tham số cuối cùng `...y`, chúng ta đưa toàn bộ "những đối số còn lại" vào một mảng y. Trong trường hợp này đó là mảng gồm các phần tử `2`, `3` và `4`. Do đó giá trị của `y` lúc này chính là mảng `[2, 3, 4]`. Giá trị của `x` là `1`, nên khi ghi `[x, y]` ra, kết quả sẽ là `[1, [2, 3, 4]]`.
 
 Hàm `getUser` nhận vào một object. Với cú pháp arrow function, chúng ta sẽ không phải viết trong ngoặc nhọn `{}` nữa nếu ta chỉ muốn đơn thuần trả về giá trị. Tuy nhiên, nếu ta muốn trả về một _object_ t arrow function, ta sẽ phải viết chúng trong dấu ngoặc tròn `()`, nếu không thì sẽ không có giá trị nào được trả về! Ví dụ như sau:
 
-```const getUser = user => ({ name: user.name, age: user.age })```
+`const getUser = user => ({ name: user.name, age: user.age })`
 
 Do không giá trị nào được trả về, kết quả sẽ là `undefined`.
 
@@ -3139,9 +3142,9 @@ Do không giá trị nào được trả về, kết quả sẽ là `undefined`.
 ###### 99. Output là gì?
 
 ```javascript
-const name = "Lydia"
+const name = "Lydia";
 
-console.log(name())
+console.log(name());
 ```
 
 - A: `SyntaxError`
@@ -3154,11 +3157,11 @@ console.log(name())
 
 #### Đáp án: C
 
-Biến `name` có giá trị là một chuỗi, không phải hàm, vì thế không thể gọi được. 
+Biến `name` có giá trị là một chuỗi, không phải hàm, vì thế không thể gọi được.
 
 TypeErrors sẽ được throw ra nếu một giá trị không được sử dụng đúng kiểu. JavaScript muốn `name` là một hàm khi ta tiến hành gọi nó. Nhưng nó là chuỗi, nên sẽ throw ra một TypeError.
 
-SyntaxErrors sẽ được throw khi ta viết code không đúng cú pháp của JavaScript, ví dụ thay vì `return` ta viết `retrun`. 
+SyntaxErrors sẽ được throw khi ta viết code không đúng cú pháp của JavaScript, ví dụ thay vì `return` ta viết `retrun`.
 
 ReferenceErrors sẽ được throw ra khi Javascript không thể tìm được tham chiếu nào đến giá trị mà ta đang cố truy cập.
 
@@ -3172,8 +3175,8 @@ ReferenceErrors sẽ được throw ra khi Javascript không thể tìm được
 ```javascript
 // 🎉✨ Đây là câu hỏi thứ 100 của tôi! ✨🎉
 
-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`
@@ -3198,11 +3201,11 @@ You should${'' && `n't`} see a therapist after so much JavaScript lol`
 ###### 101. Output là gì?
 
 ```javascript
-const one = (false || {} || null)
-const two = (null || false || "")
-const three = ([] || 0 || true)
+const one = false || {} || null;
+const two = null || false || "";
+const three = [] || 0 || true;
 
-console.log(one, two, three)
+console.log(one, two, three);
 ```
 
 - A: `false` `null` `[]`
@@ -3231,20 +3234,20 @@ Với phép toán `||`, ta sẽ trả về giá trị truethy đầu tiên. Nế
 ###### 102. Output là gì?
 
 ```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')
+  myPromise().then((res) => console.log(res));
+  console.log("second");
 }
 
 async function secondFunction() {
-  console.log(await myPromise())
-  console.log('second')
+  console.log(await myPromise());
+  console.log("second");
 }
 
-firstFunction()
-secondFunction()
+firstFunction();
+secondFunction();
 ```
 
 - A: `I have resolved!`, `second` và `I have resolved!`, `second`
@@ -3261,11 +3264,11 @@ Có thể tưởng tượng đơn giản cách promise thực thi như sau: _bâ
 
 Dù chúng ta có thể sử dụng giá trị thu được bằng cú pháp `.then`, hoặc sử dụng cặp cú pháp `await/async`, nhưng, cách chúng hoạt động là khác nhau.
 
-Trong `firstFunction`, chúng ta đưa promise qua một bên chờ cho nó tính toán xong, và vẫn tiếp tục chạy những code tiếp sau đó, theo đó `console.log('second')` sẽ được chạy. Sau đó promise được hoàn thành trả về giá trị `I have resolved`, giá trị này sẽ được log ra khi call stack trở nên rỗng. 
+Trong `firstFunction`, chúng ta đưa promise qua một bên chờ cho nó tính toán xong, và vẫn tiếp tục chạy những code tiếp sau đó, theo đó `console.log('second')` sẽ được chạy. Sau đó promise được hoàn thành trả về giá trị `I have resolved`, giá trị này sẽ được log ra khi call stack trở nên rỗng.
 
 Với từ khóa `await` trong `secondFunction`, ta đã tạm dừng một hàm bất đồng bộ cho tới khi chúng trả về giá trị, sau đó ta mới đi tiếp đến các câu lệnh tiếp theo.
 
-Do đó nó sẽ chờ cho tới khi `myPromise` được hoàn thành và trả về giá trị `I have resolved`, sau đó chúng ta sẽ chạy tiếp câu lệnh tiếp theo in ra `second`. 
+Do đó nó sẽ chờ cho tới khi `myPromise` được hoàn thành và trả về giá trị `I have resolved`, sau đó chúng ta sẽ chạy tiếp câu lệnh tiếp theo in ra `second`.
 
 </p>
 </details>
@@ -3275,14 +3278,14 @@ Do đó nó sẽ chờ cho tới khi `myPromise` được hoàn thành và trả
 ###### 103. Output là gì?
 
 ```javascript
-const set = new Set()
+const set = new Set();
 
-set.add(1)
-set.add("Lydia")
-set.add({ name: "Lydia" })
+set.add(1);
+set.add("Lydia");
+set.add({ name: "Lydia" });
 
 for (let item of set) {
-  console.log(item + 2)
+  console.log(item + 2);
 }
 ```
 
@@ -3296,11 +3299,11 @@ for (let item of set) {
 
 #### Đáp án: C
 
-Phép toán `+` không chỉ dùng để cộng các số, mà nó còn dùng để nối chuỗi nữa. Mỗi khi Javascript engine gặp một giá trị trong phép toán không phải dạng số, nó sẽ chuyển các số trong phép toán đó sang dạng chuỗi. 
+Phép toán `+` không chỉ dùng để cộng các số, mà nó còn dùng để nối chuỗi nữa. Mỗi khi Javascript engine gặp một giá trị trong phép toán không phải dạng số, nó sẽ chuyển các số trong phép toán đó sang dạng chuỗi.
 
 Phép toán đầu tiên item là một số `1`, nên `1 + 2` trả về 3.
 
-Ở phép toán thứ hai, item là một chuỗi `"Lydia"`. trong khi đó `2` là một số, nên `2` sẽ bị chuyển sang dạng chuỗi, sau khi nối vào ta có chuỗi `"Lydia2"`. 
+Ở phép toán thứ hai, item là một chuỗi `"Lydia"`. trong khi đó `2` là một số, nên `2` sẽ bị chuyển sang dạng chuỗi, sau khi nối vào ta có chuỗi `"Lydia2"`.
 
 Ở phép toán thứ ba, `{ name: "Lydia" }` là một object. Tuy nhiên dù có là object hay gì đi nữa thì nó cũng sẽ bị chuyển sang dạng chuỗi. Đối với object thì khi chuyển sang dạng chuỗi nó sẽ trở thành `"[object Object]"`. `"[object Object]"` nối với `"2"` trở thành `"[object Object]2"`.
 
@@ -3312,7 +3315,7 @@ Phép toán đầu tiên item là một số `1`, nên `1 + 2` trả về 3.
 ###### 104. Output là gì?
 
 ```javascript
-Promise.resolve(5)
+Promise.resolve(5);
 ```
 
 - A: `5`
@@ -3327,7 +3330,7 @@ Promise.resolve(5)
 
 Ta có thể truyền vào giá trị bất kì cho `Promise.resolve`, dù có là promise hay không promise. Bản thân nó sẽ là một hàm trả về một promise với giá trị đã được resolved.
 
-Trong trường hợp này ta đưa vào giá trị `5`. Nó sẽ trả về một resolved promise với giá trị `5`. 
+Trong trường hợp này ta đưa vào giá trị `5`. Nó sẽ trả về một resolved promise với giá trị `5`.
 
 </p>
 </details>
@@ -3339,15 +3342,15 @@ Trong trường hợp này ta đưa vào giá trị `5`. Nó sẽ trả về m
 ```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)
+compareMembers(person);
 ```
 
 - A: `Not the same!`
@@ -3360,7 +3363,7 @@ compareMembers(person)
 
 #### Đáp án: B
 
-Object sẽ được truyền vào hàm theo reference. Khi chúng ta nói so sánh strict equal (`===`), nghĩa là ta đang so sánh các reference của chúng. 
+Object sẽ được truyền vào hàm theo reference. Khi chúng ta nói so sánh strict equal (`===`), nghĩa là ta đang so sánh các reference của chúng.
 
 Ta set giá trị mặc định của `person2` là object `person`, và đưa object `person` vào làm giá trị cho đối số `person1`.
 
@@ -3380,11 +3383,11 @@ const colorConfig = {
   green: true,
   black: true,
   yellow: false,
-}
+};
 
-const colors = ["pink", "red", "blue"]
+const colors = ["pink", "red", "blue"];
 
-console.log(colorConfig.colors[1])
+console.log(colorConfig.colors[1]);
 ```
 
 - A: `true`
@@ -3397,11 +3400,11 @@ console.log(colorConfig.colors[1])
 
 #### Đáp án: D
 
-Trong Javascript ta có hai cách để truy cập thuộc tính của một object: sử dụng ngoặc vuông `[]`, hoặc sử dụng chấm `.`. Trong trương hợp này chúng ta sử dụng chấm (`colorConfig.colors`) thay cho ngoặc vuông (`colorConfig["colors"]`). 
+Trong Javascript ta có hai cách để truy cập thuộc tính của một object: sử dụng ngoặc vuông `[]`, hoặc sử dụng chấm `.`. Trong trương hợp này chúng ta sử dụng chấm (`colorConfig.colors`) thay cho ngoặc vuông (`colorConfig["colors"]`).
 
-Với cách sử dụng chấm, Javascript sẽ tìm kiếm một thuộc tính có tên chính xác như tên ta đưa vào. Trong trường hợp này nó là thuộc tính `colors` trong object `colorConfig` Tuy nhiên trong object này không có thuộc tính nào tên là  `colors`, nên nó sẽ trả về `undefined`. Sau đó chúng ta cố truy cậ vào thuộc tính 1 của nó bằng cách gọi `[1]`. Chúng ta không thể làm như vậy trên giá trị `undefined`, nên nó sẽ trả về `TypeError`: `Cannot read property '1' of undefined`.
+Với cách sử dụng chấm, Javascript sẽ tìm kiếm một thuộc tính có tên chính xác như tên ta đưa vào. Trong trường hợp này nó là thuộc tính `colors` trong object `colorConfig` Tuy nhiên trong object này không có thuộc tính nào tên là `colors`, nên nó sẽ trả về `undefined`. Sau đó chúng ta cố truy cậ vào thuộc tính 1 của nó bằng cách gọi `[1]`. Chúng ta không thể làm như vậy trên giá trị `undefined`, nên nó sẽ trả về `TypeError`: `Cannot read property '1' of undefined`.
 
-Javascript thông dịch theo câu lệnh. Khi ta sử dụng ngoặc vuông, Nnó sẽ tìm mở ngoặc đầu tiên `[` và tiếp tục cho tới khi gặp đóng ngoặc tương ứng `]`. Chỉ khi đó nó mới đánh giá câu lệnh. Nếu chúng ta sử dụng cú pháp `colorConfig[colors[1]]`, nó sẽ trả về giá trị của thuộc tính `red` trong object `colorConfig`. 
+Javascript thông dịch theo câu lệnh. Khi ta sử dụng ngoặc vuông, Nnó sẽ tìm mở ngoặc đầu tiên `[` và tiếp tục cho tới khi gặp đóng ngoặc tương ứng `]`. Chỉ khi đó nó mới đánh giá câu lệnh. Nếu chúng ta sử dụng cú pháp `colorConfig[colors[1]]`, nó sẽ trả về giá trị của thuộc tính `red` trong object `colorConfig`.
 
 </p>
 </details>
@@ -3411,7 +3414,7 @@ Javascript thông dịch theo câu lệnh. Khi ta sử dụng ngoặc vuông, Nn
 ###### 107. Ouput là gì?
 
 ```javascript
-console.log('❤️' === '❤️')
+console.log("❤️" === "❤️");
 ```
 
 - A: `true`
@@ -3422,7 +3425,7 @@ console.log('❤️' === '❤️')
 
 #### Đáp án: A
 
-Về cơ bản, emoji vẫn là các ký tự unicode mà thôi. Mã unicode cho hình trái tim là `"U+2764 U+FE0F"`. Chúng luôn luôn là một, nên phép toán đơn giản trả về `true`. 
+Về cơ bản, emoji vẫn là các ký tự unicode mà thôi. Mã unicode cho hình trái tim là `"U+2764 U+FE0F"`. Chúng luôn luôn là một, nên phép toán đơn giản trả về `true`.
 
 </p>
 </details>
@@ -3432,19 +3435,19 @@ Về cơ bản, emoji vẫn là các ký tự unicode mà thôi. Mã unicode cho
 ###### 108. Phép toán nào sau đây làm thay đổi mảng gốc?
 
 ```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`
 - B: `map` `reduce` `slice` `splice`
-- C: `map` `slice` `splice` 
+- C: `map` `slice` `splice`
 - D: `splice`
 
 <details><summary><b>Đáp án</b></summary>
@@ -3452,7 +3455,7 @@ emojis.splice(1, 2, '✨')
 
 #### Đáp án: D
 
-Với `splice`, ta thay đổi mảng gốc bằng cách thêm sửa xóa các phần tử. Trong trường hợp này ta xóa 2 phần tử kể từ index 1 (ta xóa `'🥑'` và `'😍'`) và thêm vào ✨ emoji. 
+Với `splice`, ta thay đổi mảng gốc bằng cách thêm sửa xóa các phần tử. Trong trường hợp này ta xóa 2 phần tử kể từ index 1 (ta xóa `'🥑'` và `'😍'`) và thêm vào ✨ emoji.
 
 `map`, `filter` và `slice` trả về một mảng mới, `find` trả về một phần tử, và `reduce` trả về giá trị tích lũy.
 
@@ -3464,17 +3467,17 @@ Với `splice`, ta thay đổi mảng gốc bằng cách thêm sửa xóa các p
 ###### 109. Output là gì?
 
 ```javascript
-const food = ['🍕', '🍫', '🥑', '🍔']
-const info = { favoriteFood: food[0] }
+const food = ["🍕", "🍫", "🥑", "🍔"];
+const info = { favoriteFood: food[0] };
 
-info.favoriteFood = '🍝'
+info.favoriteFood = "🍝";
 
-console.log(food)
+console.log(food);
 ```
 
 - A: `['🍕', '🍫', '🥑', '🍔']`
 - B: `['🍝', '🍫', '🥑', '🍔']`
-- C: `['🍝', '🍕', '🍫', '🥑', '🍔']` 
+- C: `['🍝', '🍕', '🍫', '🥑', '🍔']`
 - D: `ReferenceError`
 
 <details><summary><b>Đáp án</b></summary>
@@ -3494,7 +3497,7 @@ Bản thân mảng `food` không hề thay đổi, do giá trị của `favorite
 ###### 110. Phép toán này dùng để làm gì?
 
 ```javascript
-JSON.parse()
+JSON.parse();
 ```
 
 - A: Parse JSON thành một giá trị JavaScript
@@ -3507,22 +3510,22 @@ JSON.parse()
 
 #### Đáp án: A
 
-Với phương thức `JSON.parse()`, ta sẽ parse một chuỗi JSON thành một giá trị JavaScript. 
+Với phương thức `JSON.parse()`, ta sẽ parse một chuỗi JSON thành một giá trị JavaScript.
 
 Ví dụ:
 
 ```javascript
 // Chuyển một số thành một chuỗi JSON, sau đó parse chuỗi JSON đó để trả về một giá trị JavaScript:
-const jsonNumber = JSON.stringify(4) // '4'
-JSON.parse(jsonNumber) // 4
+const jsonNumber = JSON.stringify(4); // '4'
+JSON.parse(jsonNumber); // 4
 
 // Chuyển một mảng thành một chuỗi JSON, sau đó parse chuỗi JSON để trả về một giá trị JavaScript:
-const jsonArray = JSON.stringify([1, 2, 3]) // '[1, 2, 3]'
-JSON.parse(jsonArray) // [1, 2, 3]
+const jsonArray = JSON.stringify([1, 2, 3]); // '[1, 2, 3]'
+JSON.parse(jsonArray); // [1, 2, 3]
 
 // Chuyển một object thành một chuỗi JSON, sau đó parse chuỗi JSON để trả về một giá trị JavaScript:
-const jsonArray = JSON.stringify({ name: "Lydia" }) // '{"name":"Lydia"}'
-JSON.parse(jsonArray) // { name: 'Lydia' }
+const jsonArray = JSON.stringify({ name: "Lydia" }); // '{"name":"Lydia"}'
+JSON.parse(jsonArray); // { name: 'Lydia' }
 ```
 
 </p>
@@ -3530,17 +3533,17 @@ JSON.parse(jsonArray) // { name: 'Lydia' }
 
 ---
 
-###### 111. Ouput là gì? 
+###### 111. Ouput là gì?
 
 ```javascript
-let name = 'Lydia'
+let name = "Lydia";
 
 function getName() {
-  console.log(name)
-  let name = 'Sarah'
+  console.log(name);
+  let name = "Sarah";
 }
 
-getName()
+getName();
 ```
 
 - A: Lydia
@@ -3553,20 +3556,20 @@ getName()
 
 #### Đáp án: D
 
-Mỗi hàm sẽ có một _context thực thi_ (hay _scope_) của riêng nó. Hàm `getName` đầu tiên sẽ tìm trong context của nó (scope) để tìm xem có biến nào tên là `name` hay không. Trong trường hợp này, hàm `getName` có biến `name` được khai báo với từ khóa `let`, giá trị là `'Sarah'`. 
+Mỗi hàm sẽ có một _context thực thi_ (hay _scope_) của riêng nó. Hàm `getName` đầu tiên sẽ tìm trong context của nó (scope) để tìm xem có biến nào tên là `name` hay không. Trong trường hợp này, hàm `getName` có biến `name` được khai báo với từ khóa `let`, giá trị là `'Sarah'`.
 
-Một biến được khai báo với từ khóa `let` (hoặc `const`) sẽ được `hoisted`, nhưng không giống như `var`, nó sẽ không được _khởi tạo_. Nó sẽ không thể truy cập được trước dòng ta khai báo (initialize). Nó được gọi là "temporal dead zone". Khi ta cố truy cập một biến trước khi nó được khai báo, JavaScript sẽ throw ra `ReferenceError`. 
+Một biến được khai báo với từ khóa `let` (hoặc `const`) sẽ được `hoisted`, nhưng không giống như `var`, nó sẽ không được _khởi tạo_. Nó sẽ không thể truy cập được trước dòng ta khai báo (initialize). Nó được gọi là "temporal dead zone". Khi ta cố truy cập một biến trước khi nó được khai báo, JavaScript sẽ throw ra `ReferenceError`.
 
-Nếu ta không khai báo biến `name` bên trong hàm `getName`, thì Javascript engine sẽ tiếp tục tìm kiếm trong _scope chain_. Nó sẽ tìm thấy ở scope phía ngoài một biến `name` với giá trị là `Lydia`. Trong trường hợp này nó sẽ log ra `Lydia`. 
+Nếu ta không khai báo biến `name` bên trong hàm `getName`, thì Javascript engine sẽ tiếp tục tìm kiếm trong _scope chain_. Nó sẽ tìm thấy ở scope phía ngoài một biến `name` với giá trị là `Lydia`. Trong trường hợp này nó sẽ log ra `Lydia`.
 
 ```javascript
-let name = 'Lydia'
+let name = "Lydia";
 
 function getName() {
-  console.log(name)
+  console.log(name);
 }
 
-getName() // Lydia
+getName(); // Lydia
 ```
 
 </p>
@@ -3578,18 +3581,18 @@ 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()
-const two = generatorTwo()
+const one = generatorOne();
+const two = generatorTwo();
 
-console.log(one.next().value)
-console.log(two.next().value)
+console.log(one.next().value);
+console.log(two.next().value);
 ```
 
 - A: `a` and `a`
@@ -3607,17 +3610,17 @@ Với từ khóa `yield`, ta sẽ trả về các giá trị trong một `genera
 Trong `generatorOne`, ta trả về toàn bộ mảng `['a', 'b', 'c']` sử dụng từ khóa `yield`. Giá trị của thuộc tính `value` trong object thu được bởi phương thức `next` trong `one` (`one.next().value`) là toàn bộ mảng `['a', 'b', 'c']`.
 
 ```javascript
-console.log(one.next().value) // ['a', 'b', 'c']
-console.log(one.next().value) // undefined
+console.log(one.next().value); // ['a', 'b', 'c']
+console.log(one.next().value); // undefined
 ```
 
-Trong `generatorTwo`, ta sử dụng từ khóa `yield*`. Có nghĩa là giá trị đầu tiên mà `two` trả về là giá trị đầu tiên trong `iterator`. Trong trường hợp này `iterator` của chúng ta là mảng `['a', 'b', 'c']`. Giá trị đầu tiên của mảng là `a`, nên lần đầu tiên khi ta gọi `two.next().value`, `a` sẽ được trả về. 
+Trong `generatorTwo`, ta sử dụng từ khóa `yield*`. Có nghĩa là giá trị đầu tiên mà `two` trả về là giá trị đầu tiên trong `iterator`. Trong trường hợp này `iterator` của chúng ta là mảng `['a', 'b', 'c']`. Giá trị đầu tiên của mảng là `a`, nên lần đầu tiên khi ta gọi `two.next().value`, `a` sẽ được trả về.
 
 ```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
+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>
@@ -3628,7 +3631,7 @@ console.log(two.next().value) // undefined
 ###### 113. Output là gì?
 
 ```javascript
-console.log(`${(x => x)('I love')} to program`)
+console.log(`${((x) => x)("I love")} to program`);
 ```
 
 - A: `I love to program`
@@ -3641,7 +3644,7 @@ console.log(`${(x => x)('I love')} to program`)
 
 #### Đáp án: A
 
-Biểu thức bên trong chuỗi template (tức chuỗi nằm trong hai dấu ``, gọi là `template literals`) sẽ được đánh giá trước. Sau đó kết quả của biểu thức sẽ được đưa vào chuỗi, trong trường hợp này biểu thức là `(x => x)('I love')`. Chúng ta truyền giá trị đối số `'I love'` cho một arrow function `x => x`. `x` lúc này là `'I love'`, và trả về chính nó. Cuối cùng kết quả của chuỗi là `I love to program`. 
+Biểu thức bên trong chuỗi template (tức chuỗi nằm trong hai dấu ``, gọi là `template literals`) sẽ được đánh giá trước. Sau đó kết quả của biểu thức sẽ được đưa vào chuỗi, trong trường hợp này biểu thức là `(x => x)('I love')`. Chúng ta truyền giá trị đối số `'I love'`cho một arrow function`x => x`. `x`lúc này là`'I love'`, và trả về chính nó. Cuối cùng kết quả của chuỗi là `I love to program`.
 
 </p>
 </details>
@@ -3653,11 +3656,11 @@ Biểu thức bên trong chuỗi template (tức chuỗi nằm trong hai dấu `
 ```javascript
 let config = {
   alert: setInterval(() => {
-    console.log('Alert!')
-  }, 1000)
-}
+    console.log("Alert!");
+  }, 1000),
+};
 
-config = null
+config = null;
 ```
 
 - A: Callback `setInterval` sẽ không được gọi
@@ -3680,17 +3683,17 @@ Thông thường khi ta set một object bằng `null`, thì object này sẽ đ
 ###### 115. Những hàm nào sẽ trả về `'Hello world!'`?
 
 ```javascript
-const myMap = new Map()
-const myFunc = () => 'greeting'
+const myMap = new Map();
+const myFunc = () => "greeting";
 
-myMap.set(myFunc, 'Hello world!')
+myMap.set(myFunc, "Hello world!");
 
 //1
-myMap.get('greeting')
+myMap.get("greeting");
 //2
-myMap.get(myFunc)
+myMap.get(myFunc);
 //3
-myMap.get(() => 'greeting')
+myMap.get(() => "greeting");
 ```
 
 - A: 1
@@ -3703,7 +3706,7 @@ myMap.get(() => 'greeting')
 
 #### Đáp án: B
 
-Khi ta thêm vào một cặp key/value với từ khóa `set`, key sẽ là đối số đầu tiên đưa vào trong hàm `set` function, và value sẽ là đối số thứ hai.Trong trường hơp này key chính là _hàm_ `() => 'greeting'`, value là `'Hello world'`. `myMap` trở thành `{ () => 'greeting' => 'Hello world!' }`. 
+Khi ta thêm vào một cặp key/value với từ khóa `set`, key sẽ là đối số đầu tiên đưa vào trong hàm `set` function, và value sẽ là đối số thứ hai.Trong trường hơp này key chính là _hàm_ `() => 'greeting'`, value là `'Hello world'`. `myMap` trở thành `{ () => 'greeting' => 'Hello world!' }`.
 
 1 sai, vì key là `() => 'greeting'` chứ không phải là `'greeting'`.
 3 sai, vì khi chúng ta đưa một hàm vào làm đối số trong phương thức `get`, nó sẽ được đưa vào dưới dạng _reference_. Function vốn là object, do đó 2 hàm sẽ không bao giờ là `strictly equal`, mặc dù chúng có trông giống nhau đi chăng nữa thì chúng vẫn trỏ đến các vùng nhớ khác nhau.
@@ -3718,19 +3721,19 @@ Khi ta thêm vào một cặp key/value với từ khóa `set`, key sẽ là đ
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21
-}
+  age: 21,
+};
 
-const changeAge = (x = { ...person }) => x.age += 1
+const changeAge = (x = { ...person }) => (x.age += 1);
 const changeAgeAndName = (x = { ...person }) => {
-  x.age += 1
-  x.name = "Sarah"
-}
+  x.age += 1;
+  x.name = "Sarah";
+};
 
-changeAge(person)
-changeAgeAndName()
+changeAge(person);
+changeAgeAndName();
 
-console.log(person)
+console.log(person);
 ```
 
 - A: `{name: "Sarah", age: 22}`
@@ -3743,7 +3746,7 @@ console.log(person)
 
 #### Đáp án: C
 
-Cả hai hàm `changeAge` và `changeAgeAndName` đều có tham số mặc định - nó là một _bản copy_ mới của object `{ ...person }`. Object này sẽ copy tất cả những cặp key/values bên trong object `person`. 
+Cả hai hàm `changeAge` và `changeAgeAndName` đều có tham số mặc định - nó là một _bản copy_ mới của object `{ ...person }`. Object này sẽ copy tất cả những cặp key/values bên trong object `person`.
 
 Đầu tiên, chúng ta gọi hàm `changeAge` và đưa chính object `person` vào làm đối số. Hàm này sẽ tăng giá trị của thuộc tính `age` lên 1. `person` lúc này là `{ name: "Lydia", age: 22 }`.
 
@@ -3758,7 +3761,7 @@ Sau đó, chúng ta gọi hàm `changeAgeAndName` tuy nhiên không đưa vào 
 
 ```javascript
 function sumValues(x, y, z) {
-	return x + y + z;
+  return x + y + z;
 }
 ```
 
@@ -3809,15 +3812,15 @@ Với phép toán `+=`, Ta tăng giá trị của `num` lên `1`. `num` có giá
 
 ```javascript
 const person = {
-	firstName: "Lydia",
-	lastName: "Hallie",
-	pet: {
-		name: "Mara",
-		breed: "Dutch Tulip Hound"
-	},
-	getFullName() {
-		return `${this.firstName} ${this.lastName}`;
-	}
+  firstName: "Lydia",
+  lastName: "Hallie",
+  pet: {
+    name: "Mara",
+    breed: "Dutch Tulip Hound",
+  },
+  getFullName() {
+    return `${this.firstName} ${this.lastName}`;
+  },
 };
 
 console.log(person.pet?.name);
@@ -3857,9 +3860,9 @@ Với phép toán optional chaining `?.`, chúng ta sẽ không cần phải che
 const groceries = ["banana", "apple", "peanuts"];
 
 if (groceries.indexOf("banana")) {
-	console.log("We have to buy bananas!");
+  console.log("We have to buy bananas!");
 } else {
-	console.log(`We don't have to buy bananas!`);
+  console.log(`We don't have to buy bananas!`);
 }
 ```
 
@@ -3884,10 +3887,10 @@ Ta đưa một điều kiện `groceries.indexOf("banana")` vào câu lệnh `if
 
 ```javascript
 const config = {
-	languages: [],
-	set language(lang) {
-		return this.languages.push(lang);
-	}
+  languages: [],
+  set language(lang) {
+    return this.languages.push(lang);
+  },
 };
 
 console.log(config.language);
@@ -3941,9 +3944,9 @@ console.log(!typeof name === "string");
 ###### 123. Output là gì?
 
 ```javascript
-const add = x => y => z => {
-	console.log(x, y, z);
-	return x + y + z;
+const add = (x) => (y) => (z) => {
+  console.log(x, y, z);
+  return x + y + z;
 };
 
 add(4)(5)(6);
@@ -3970,16 +3973,16 @@ Hàm `add` trả về một arrow function, arrow function này lại trả về
 
 ```javascript
 async function* range(start, end) {
-	for (let i = start; i <= end; i++) {
-		yield Promise.resolve(i);
-	}
+  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);
-	}
+  const gen = range(1, 3);
+  for await (const item of gen) {
+    console.log(item);
+  }
 })();
 ```
 
@@ -4004,7 +4007,7 @@ Generator `range` trả về một async object với các promise tương ứng
 
 ```javascript
 const myFunc = ({ x, y, z }) => {
-	console.log(x, y, z);
+  console.log(x, y, z);
 };
 
 myFunc(1, 2, 3);
@@ -4127,8 +4130,8 @@ Với phương thức `isNaN`, ta đơn thuần chỉ check xem giá trị đưa
 const randomValue = 21;
 
 function getInfo() {
-	console.log(typeof randomValue);
-	const randomValue = "Lydia Hallie";
+  console.log(typeof randomValue);
+  const randomValue = "Lydia Hallie";
 }
 
 getInfo();
@@ -4157,13 +4160,13 @@ Một biến được khai báo với từ khóa `const` sẽ không thể truy
 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!");
-	}
+  try {
+    console.log(await myPromise);
+  } catch {
+    throw new Error(`Oops didn't work`);
+  } finally {
+    console.log("Oh finally!");
+  }
 })();
 ```
 
@@ -4213,13 +4216,13 @@ Với phương thức `flat`, ta có thể tạo một mảng mới với các p
 
 ```javascript
 class Counter {
-	constructor() {
-		this.count = 0;
-	}
+  constructor() {
+    this.count = 0;
+  }
 
-	increment() {
-		this.count++;
-	}
+  increment() {
+    this.count++;
+  }
 }
 
 const counterOne = new Counter();
@@ -4263,16 +4266,16 @@ Ta gọi hàm `counterTwo.increment()` để tăng `count` lên `3`. Sau đó ch
 const myPromise = Promise.resolve(Promise.resolve("Promise!"));
 
 function funcOne() {
-	myPromise.then(res => res).then(res => console.log(res));
-	setTimeout(() => console.log("Timeout!", 0));
-	console.log("Last line!");
+  myPromise.then((res) => res).then((res) => console.log(res));
+  setTimeout(() => console.log("Timeout!", 0));
+  console.log("Last line!");
 }
 
 async function funcTwo() {
-	const res = await myPromise;
-	console.log(await res);
-	setTimeout(() => console.log("Timeout!", 0));
-	console.log("Last line!");
+  const res = await myPromise;
+  console.log(await res);
+  setTimeout(() => console.log("Timeout!", 0));
+  console.log("Last line!");
 }
 
 funcOne();
@@ -4309,7 +4312,7 @@ Ta tiếp tục thực thi dòng cuối cùng của `funcTwo`, trả về `Last
 ```javascript
 // sum.js
 export default function sum(x) {
-	return x + x;
+  return x + x;
 }
 
 // index.js
@@ -4366,8 +4369,8 @@ Ta có thể gọi hàm này bằng cách sử dụng `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);
@@ -4430,10 +4433,10 @@ Tuy nhiên ta vẫn có thể _thay đổi_ các thuộc tính cũ.
 
 ```javascript
 const person = {
-	name: "Lydia Hallie",
-	address: {
-		street: "100 Main St"
-	}
+  name: "Lydia Hallie",
+  address: {
+    street: "100 Main St",
+  },
 };
 
 Object.freeze(person);
@@ -4461,10 +4464,10 @@ Tuy nhiên trên thực tế đây chỉ là đóng băng _nông_ (_shallowly_)
 ###### 138. Output là gì?
 
 ```javascript
-const add = x => x + x;
+const add = (x) => x + x;
 
 function myFunc(num = 2, value = add(num)) {
-	console.log(num, value);
+  console.log(num, value);
 }
 
 myFunc();
@@ -4494,21 +4497,21 @@ Sau đó ta gọi hàm `myFunc(3)`, khi này `3` sẽ là giá trị của `num`
 
 ```javascript
 class Counter {
-  #number = 10
+  #number = 10;
 
   increment() {
-    this.#number++
+    this.#number++;
   }
 
   getNum() {
-    return this.#number
+    return this.#number;
   }
 }
 
-const counter = new Counter()
-counter.increment()
+const counter = new Counter();
+counter.increment();
 
-console.log(counter.#number)
+console.log(counter.#number);
 ```
 
 - A: `10`
@@ -4532,20 +4535,20 @@ Với cú pháp ES2020, ta có thể thêm các thuộc tính private vào class
 
 ```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) {
-	for (let i = 0; i < members.length; i++) {
-		yield members[i];
-	}
+  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 ✨
-	}
+  for (let i = 0; i < teams.length; i++) {
+    // ✨ SOMETHING IS MISSING HERE ✨
+  }
 }
 
 const obj = getTeams(teams);
@@ -4570,20 +4573,19 @@ Nếu ta dùng `yield`, `return yield`, hay `return`, toàn bộ generator sẽ
 </p>
 </details>
 
-
 ---
 
 ###### 141. Output là gì?
 
 ```javascript
 const person = {
-	name: "Lydia Hallie",
-	hobbies: ["coding"]
+  name: "Lydia Hallie",
+  hobbies: ["coding"],
 };
 
 function addHobby(hobby, hobbies = person.hobbies) {
-	hobbies.push(hobby);
-	return hobbies;
+  hobbies.push(hobby);
+  return hobbies;
 }
 
 addHobby("running", []);
@@ -4622,16 +4624,16 @@ Sau khi thêm `dancing` và `baking`, giá trị của `person.hobbies` là `["c
 
 ```javascript
 class Bird {
-	constructor() {
-		console.log("I'm a bird. 🦢");
-	}
+  constructor() {
+    console.log("I'm a bird. 🦢");
+  }
 }
 
 class Flamingo extends Bird {
-	constructor() {
-		console.log("I'm pink. 🌸");
-		super();
-	}
+  constructor() {
+    console.log("I'm pink. 🌸");
+    super();
+  }
 }
 
 const pet = new Flamingo();
@@ -4716,11 +4718,11 @@ Mặc định ta không thể duyệt qua được object. Trừ phi nó đượ
 let count = 0;
 const nums = [0, 1, 2, 3];
 
-nums.forEach(num => {
-	if (num) count += 1
-})
+nums.forEach((num) => {
+  if (num) count += 1;
+});
 
-console.log(count)
+console.log(count);
 ```
 
 - A: 1
@@ -4744,12 +4746,12 @@ Câu lệnh `if` trong vòng lập `forEach` kiểm tra giá trị của `num` l
 
 ```javascript
 function getFruit(fruits) {
-	console.log(fruits?.[1]?.[1])
+  console.log(fruits?.[1]?.[1]);
 }
 
-getFruit([['🍊', '🍌'], ['🍍']])
-getFruit()
-getFruit([['🍍'], ['🍊', '🍌']])
+getFruit([["🍊", "🍌"], ["🍍"]]);
+getFruit();
+getFruit([["🍍"], ["🍊", "🍌"]]);
 ```
 
 - A: `null`, `undefined`, 🍌
@@ -4766,7 +4768,7 @@ Phép toán `?` cho phép ta truy cập giá trị bên trong của object. Chú
 
 Trước tiên, chúng ta thử in ra phần tử thứ hai trong mảng con `['🍍']` của `[['🍊', '🍌'], ['🍍']]`. Mảng con này chỉ chứa một phần tử, nghĩa là không có phần tử nào với thứ tự là `1`, và trả về `undefined`.
 
-Sau đó, ta gọi hàm `getFruits` khi không truyền vào một đối số nào, nghĩa là `fruits` có giá trị mặc định là `undefined`. Vì ta truyền phần tử mang thứ tự `1` của `fruits`, nó trả về `undefined` do phần tử này không tồn tại. 
+Sau đó, ta gọi hàm `getFruits` khi không truyền vào một đối số nào, nghĩa là `fruits` có giá trị mặc định là `undefined`. Vì ta truyền phần tử mang thứ tự `1` của `fruits`, nó trả về `undefined` do phần tử này không tồn tại.
 
 Cuối cùng, ta thử in ra phần tử thứ hai trong mảng con `['🍊', '🍌']` của mảng `['🍍'], ['🍊', '🍌']`. Phần tử mang thứ tự `1` bên trong mảng con này là `🍌` sẽ được in ra.
 
@@ -4779,19 +4781,19 @@ Cuối cùng, ta thử in ra phần tử thứ hai trong mảng con `['🍊', '
 
 ```javascript
 class Calc {
-	constructor() {
-		this.count = 0 
-	}
+  constructor() {
+    this.count = 0;
+  }
 
-	increase() {
-		this.count ++
-	}
+  increase() {
+    this.count++;
+  }
 }
 
-const calc = new Calc()
-new Calc().increase()
+const calc = new Calc();
+new Calc().increase();
 
-console.log(calc.count)
+console.log(calc.count);
 ```
 
 - A: `0`
@@ -4815,25 +4817,25 @@ Ta set biến `calc` bằng một instance mới của `Calc` class. Sau đó ta
 
 ```javascript
 const user = {
-	email: "e@mail.com",
-	password: "12345"
-}
+  email: "e@mail.com",
+  password: "12345",
+};
 
 const updateUser = ({ email, password }) => {
-	if (email) {
-		Object.assign(user, { email })
-	}
+  if (email) {
+    Object.assign(user, { email });
+  }
 
-	if (password) {
-		user.password = password
-	}
+  if (password) {
+    user.password = password;
+  }
 
-	return user
-}
+  return user;
+};
 
-const updatedUser = updateUser({ email: "new@email.com" })
+const updatedUser = updateUser({ email: "new@email.com" });
 
-console.log(updatedUser === user)
+console.log(updatedUser === user);
 ```
 
 - A: `false`
@@ -4856,13 +4858,13 @@ Hàm `updateUser` thay đổi các giá trị của thuộc tính `email` và `p
 ###### 149. Output là gi?
 
 ```javascript
-const fruit = ['🍌', '🍊', '🍎']
+const fruit = ["🍌", "🍊", "🍎"];
 
-fruit.slice(0, 1)
-fruit.splice(0, 1)
-fruit.unshift('🍇')
+fruit.slice(0, 1);
+fruit.splice(0, 1);
+fruit.unshift("🍇");
 
-console.log(fruit)
+console.log(fruit);
 ```
 
 - A: `['🍌', '🍊', '🍎']`
@@ -4886,13 +4888,13 @@ Trước tiên, ta gọi hàm `slice` trên mảng fruit. Hàm slice không thay
 
 ```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])
+console.log(animals[dog]);
 ```
 
 - A: `{ emoji: "🐶", name: "Mara" }`
@@ -4909,7 +4911,7 @@ Các keys của object được chuyển thành các chuỗi.
 
 Do giá trị của `dog` là một object, `animals[dog]` thực sự nghĩa là ta tạo ra một thuộc tính mới gọi là `"object Object"` bằng với object mới. `animals["object Object"]` lúc này bằng với `{ emoji: "🐶", name: "Mara"}`.
 
-`cat` cũng là một object, nên `animals[cat]` thực sự nghĩa là ta thay đổi giá trị của `animals[``"``object Object``"``]` bằng thuộc tính cat mới.
+`cat` cũng là một object, nên `animals[cat]` thực sự nghĩa là ta thay đổi giá trị của ` animals[``"``object Object``"``] ` bằng thuộc tính cat mới.
 
 Khi in ra `animals[dog]`, hoặc thực chất là `animals["object Object"]` vì thay `dog` object bằng một chuỗi thì nó trả về `"object Object"`, ta nhận được `{ emoji: "🐈", name: "Sara" }`.
 
@@ -4922,14 +4924,14 @@ Khi in ra `animals[dog]`, hoặc thực chất là `animals["object Object"]` v
 
 ```javascript
 const user = {
-	email: "my@email.com",
-	updateEmail: email => {
-		this.email = email
-	}
-}
+  email: "my@email.com",
+  updateEmail: (email) => {
+    this.email = email;
+  },
+};
 
-user.updateEmail("new@email.com")
-console.log(user.email)
+user.updateEmail("new@email.com");
+console.log(user.email);
 ```
 
 - A: `my@email.com`
@@ -4952,20 +4954,20 @@ Hàm `updateEmail` là một cú pháp arrow function và nó không gắn với
 ###### 152. Output là gì?
 
 ```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])
-	const res2  = await Promise.all([promise3, promise4])
-	return [res1, res2]
-}
+  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))
+  .then((res) => console.log(res))
+  .catch((err) => console.log(err));
 ```
 
 - A: `[['First', 'Second'], ['Fourth']]`
@@ -4985,16 +4987,19 @@ Hàm `Promise.all` trả về những promise truyền vào song song nhau. Nế
 
 ---
 
-###### 153. Giá trị nào của `method` sẽ được trả về với log `{ name: "Lydia", age: 22 }`? 
+###### 153. Giá trị nào của `method` sẽ được trả về với log `{ name: "Lydia", age: 22 }`?
 
 ```javascript
-const keys = ["name", "age"]
-const values = ["Lydia", 22]
+const keys = ["name", "age"];
+const values = ["Lydia", 22];
 
-const method = /* ?? */
-Object[method](keys.map((_, i) => {
-	return [keys[i], values[i]]
-})) // { name: "Lydia", age: 22 }
+const method =
+  /* ?? */
+  Object[method](
+    keys.map((_, i) => {
+      return [keys[i], values[i]];
+    })
+  ); // { name: "Lydia", age: 22 }
 ```
 
 - A: `entries`
@@ -5019,18 +5024,18 @@ Theo như trên thì ta tạo ra một mảng gồm những mảng con chứa đ
 ###### 154. Output là gì?
 
 ```javascript
-const createMember = ({ email, address = {}}) => {
-	const validEmail = /.+\@.+\..+/.test(email)
-	if (!validEmail) throw new Error("Valid email pls")
+const createMember = ({ email, address = {} }) => {
+  const validEmail = /.+\@.+\..+/.test(email);
+  if (!validEmail) throw new Error("Valid email pls");
 
-	return {
-		email,
-		address: address ? address : null
-	}
-}
+  return {
+    email,
+    address: address ? address : null,
+  };
+};
 
-const member = createMember({ email: "my@email.com" })
-console.log(member)
+const member = createMember({ email: "my@email.com" });
+console.log(member);
 ```
 
 - A: `{ email: "my@email.com", address: null }`
@@ -5053,13 +5058,13 @@ Giá trị mặc định của `address` là một object rỗng `{}`. Khi ta ch
 ###### 155. Output là gì?
 
 ```javascript
-let randomValue = { name: "Lydia" }
-randomValue = 23
+let randomValue = { name: "Lydia" };
+randomValue = 23;
 
 if (!typeof randomValue === "string") {
-	console.log("It's not a string!")
+  console.log("It's not a string!");
 } else {
-	console.log("Yay it's a string!")
+  console.log("Yay it's a string!");
 }
 ```
 

From e2ee9c02709dd4940b4cf12a9e33ee149f8a42bc Mon Sep 17 00:00:00 2001
From: alexb017 <alexbacirea@gmail.com>
Date: Mon, 21 Aug 2023 03:08:42 +0300
Subject: [PATCH 05/31] Added the questions from 1-10

---
 ro-RO/README.ro.md | 322 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 322 insertions(+)

diff --git a/ro-RO/README.ro.md b/ro-RO/README.ro.md
index 3205d61c..5c36813e 100644
--- a/ro-RO/README.ro.md
+++ b/ro-RO/README.ro.md
@@ -47,3 +47,325 @@ Nu ezita să mă contactezi! 😊 <br />
 </details>
 
 ---
+
+###### 1. Care este rezultatul?
+
+```javascript
+function sayHi() {
+  console.log(name);
+  console.log(age);
+  var name = "Lydia";
+  let age = 21;
+}
+
+sayHi();
+```
+
+- A: `Lydia` și `undefined`
+- B: `Lydia` și `ReferenceError`
+- C: `ReferenceError` și `21`
+- D: `undefined` și `ReferenceError`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: D
+
+În interiorul funcției, mai întâi declarăm variabila `name` cu cuvântul cheie `var`. Acest lucru înseamnă că variabila este hoisted (spațiul de memorie este configurat în faza de creare) cu valoarea implicită `undefined`, până când ajungem efectiv la linia în care definim variabila. Nu am definit încă variabila pe linia în care încercăm să înregistrăm variabila `name`, așa că aceasta păstrează încă valoarea `undefined`.
+
+Variabilele create cu cuvântul cheie `let` (și `const`) sunt hoisted, dar, spre deosebire de `var`, nu sunt <i>inițializate</i>. Acestea nu sunt accesibile înainte de linia în care le declarăm (initializăm). Aceasta se numește zona moartă temporală (temporal dead zone). Atunci când încercăm să accesăm variabilele înainte de a fi declarate, JavaScript aruncă o excepție de tip `ReferenceError`.
+
+</p>
+</details>
+
+---
+
+###### 2. Care este rezultatul?
+
+```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` și `0 1 2`
+- B: `0 1 2` și `3 3 3`
+- C: `3 3 3` și `0 1 2`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+Datorită cozii de evenimente din JavaScript, funcția de callback `setTimeout` este apelată _după_ ce bucla a fost executată. Deoarece variabila `i` din prima buclă a fost declarată folosind cuvântul cheie `var`, această valoare a fost globală. În timpul buclei, am incrementat valoarea lui `i` cu `1` de fiecare dată, folosind operatorul unary `++`. Până când funcția de callback `setTimeout` a fost invocată, `i` era egal cu `3` în primul exemplu.
+
+În cea de-a doua buclă, variabila `i` a fost declarată folosind cuvântul cheie `let`: variabilele declarate cu cuvântul cheie `let` (și `const`) sunt cu scop la nivel de bloc (un bloc este orice între `{ }`). În fiecare iterație, `i` va avea o valoare nouă, iar fiecare valoare este în cadrul buclei.
+
+</p>
+</details>
+
+---
+
+###### 3. Care este rezultatul?
+
+```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` și `62.83185307179586`
+- B: `20` și `NaN`
+- C: `20` și `63`
+- D: `NaN` și `63`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: B
+
+Rețineți că valoarea lui `diameter` este o funcție obișnuită, în timp ce valoarea lui `perimeter` este o funcție arrow.
+
+Cu funcțiile arrow, cuvântul cheie `this` se referă la contextul său curent de încadrare, spre deosebire de funcțiile obișnuite! Acest lucru înseamnă că atunci când apelăm `perimeter`, acesta nu se referă la obiectul formei, ci la încadrarea sa curentă (de exemplu, fereastra).
+
+Nu există nicio valoare `radius` pe acel obiect, ceea ce returnează `NaN`.
+
+</p>
+</details>
+
+---
+
+###### 4. Care este rezultatul?
+
+```javascript
++true;
+!"Lydia";
+```
+
+- A: `1` și `false`
+- B: `false` și `NaN`
+- C: `false` și `false`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: A
+
+Operatorul unary plus încearcă să convertească un operand într-un număr. `true` este `1`, și `false` este `0`.
+
+Șirul de caractere `'Lydia'` este o valoare adevărată. Ceea ce întrebăm de fapt, este "este această valoare adevărată falsă?". Acest lucru returnează `false`.
+
+</p>
+</details>
+
+---
+
+###### 5. Care este rezultatul?
+
+```javascript
+const bird = {
+  size: "small",
+};
+
+const mouse = {
+  name: "Mickey",
+  small: true,
+};
+```
+
+- A: `mouse.bird.size` nu este valid
+- B: `mouse[bird.size]` nu este valid
+- C: `mouse[bird["size"]]` nu este valid
+- D: Toate sunt valide
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: A
+
+În JavaScript, toate cheile obiectelor sunt șiruri de caractere (cu excepția simbolurilor). Chiar dacă nu le _tipizăm_ ca șiruri de caractere, ele sunt întotdeauna convertite în șiruri de caractere în fundal.
+
+avaScript interpretează (sau dezambalează) instrucțiunile. Atunci când folosim notația cu paranteze pătrate, vede prima paranteză pătrată de deschidere `[` și continuă până când găsește paranteza pătrată de închidere `]`. Doar atunci va evalua instrucțiunea.
+
+`mouse[bird.size]`: Întâi evaluează `bird.size`, care este `"small"`. `mouse["small"]` returnează `true`
+
+Cu toate acestea, cu notația cu punct, acest lucru nu se întâmplă. `mouse` nu are o cheie numită `bird`, ceea ce înseamnă că `mouse.bird` este `undefined`. Apoi, cerem `size` folosind notația cu punct: `mouse.bird.size`. Deoarece `mouse.bird` este `undefined`, de fapt cerem `undefined.size`. Acest lucru nu este valid și va arunca o eroare similară cu `Cannot read property "size" of undefined` (Nu se poate citi proprietatea "size" a unei valori nedefinite).
+
+</p>
+</details>
+
+---
+
+###### 6. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: A
+
+În JavaScript, toate obiectele interacționează prin _referință_ atunci când sunt setate ca egale între ele.
+
+Mai întâi, variabila `c` deține o valoare care face referire la un obiect. Ulterior, atribuim variabilei `d` aceeași referință pe care o are `c` la obiect.
+
+<img src="https://i.imgur.com/ko5k0fs.png" width="200">
+
+Când modifici un obiect, le modifici pe toate.
+
+</p>
+</details>
+
+---
+
+###### 7. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+`new Number()` este un constructor de funcții încorporat. Deși arată ca un număr, nu este într-adevăr un număr: are o mulțime de funcționalități suplimentare și este un obiect.
+
+Atunci când folosim operatorul `==` (operatorul de egalitate), acesta verifică doar dacă au aceeași _valuare_. Ambele au valoarea `3`, șa că returnează `true`.
+
+Cu toate acestea, atunci când folosim operatorul `===` (operatorul de egalitate strictă), atât valoarea, cât _și_ tipul trebuie să fie la fel. Nu sunt: `new Number()` nu este un număr, este un **object**. Ambele returnează `false.`
+
+</p>
+</details>
+
+---
+
+###### 8. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: D
+
+Funcția `colorChange` este statică. Metodele statice sunt concepute să existe doar pe constructorul în care sunt create și nu pot fi transmise către niciun copil sau apelate pe instanțele clasei. Deoarece `freddie` este o instanță a clasei Chameleon, funcția nu poate fi apelată pe aceasta. Se aruncă o eroare de tip `TypeError`.
+
+</p>
+</details>
+
+---
+
+###### 9. Care este rezultatul?
+
+```javascript
+let greeting;
+greetign = {}; // Typo!
+console.log(greetign);
+```
+
+- A: `{}`
+- B: `ReferenceError: greetign is not defined`
+- C: `undefined`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: A
+
+Se afișează obiectul, deoarece tocmai am creat un obiect gol pe obiectul global! Atunci când am greșit și am scris `greeting` în loc de `greetign`, interpretorul JavaScript a văzut efectiv acest lucru ca:
+
+1. `global.greetign = {}` în Node.js
+2. `window.greetign = {}`, `frames.greetign = {}` și `self.greetign` în browser-e.
+3. `self.greetign` în web workers.
+4. `globalThis.greetign` în toate mediile.
+
+Pentru a evita acest lucru, putem folosi `"use strict"`. Acest lucru se asigură că ai declarat o variabilă înainte de a-i atribui o valoare.
+
+</p>
+</details>
+
+---
+
+###### 10. Ce se întâmplă când facem asta?
+
+```javascript
+function bark() {
+  console.log("Woof!");
+}
+
+bark.animal = "dog";
+```
+
+- A: Nimic, este absolut în regulă!
+- B: `SyntaxError`. Nu poți adăuga proprietăți la o funcție în acest fel.
+- C: `"Woof"` este înregistrat.
+- D: `ReferenceError`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: A
+
+Acest lucru este posibil în JavaScript, deoarece funcțiile sunt obiecte! (Totul, în afară de tipurile primitive, sunt obiecte)
+
+O funcție este un tip special de obiect. Codul pe care îl scrii tu însuți nu este funcția efectivă. Funcția este un obiect cu proprietăți. Această proprietate este invocabilă.
+
+</p>
+</details>
+
+---

From 242ce5c7667fafffaf507c9ed12fabdcc2a8a38c Mon Sep 17 00:00:00 2001
From: alexb017 <alexbacirea@gmail.com>
Date: Tue, 22 Aug 2023 02:25:16 +0300
Subject: [PATCH 06/31] fix repo the way it was

This reverts commit d8f096396becd18256123479e42c7a0290b52771.
---
 README.md             | 624 ++++++++++++++--------------
 ar-AR/README_AR.md    | 362 +++++++----------
 bs-BS/README-bs_BS.md | 249 ++++++------
 de-DE/README.md       | 925 +++++++++++++++++++++---------------------
 es-ES/README-ES.md    | 495 +++++++++++-----------
 fr-FR/README_fr-FR.md |  44 +-
 id-ID/README.md       | 546 +++++++++++++------------
 it-IT/README.md       | 654 +++++++++++++++--------------
 ja-JA/README-ja_JA.md | 375 ++++++++---------
 ko-KR/README-ko_KR.md | 514 ++++++++++++-----------
 nl-NL/README.md       | 619 ++++++++++++++--------------
 pl-PL/README.md       | 126 +++---
 pt-BR/README_pt_BR.md | 116 +++---
 ro-RO/README.ro.md    | 371 -----------------
 ru-RU/README.md       | 825 +++++++++++++++++++------------------
 sq-KS/README_sq_KS.md | 653 +++++++++++++++--------------
 th-TH/README.md       | 385 +++++++++---------
 tr-TR/README-tr_TR.md | 316 +++++++--------
 uk-UA/README.md       |  35 +-
 vi-VI/README-vi.md    | 829 +++++++++++++++++++------------------
 20 files changed, 4300 insertions(+), 4763 deletions(-)
 delete mode 100644 ro-RO/README.ro.md

diff --git a/README.md b/README.md
index 031b0f72..97cde89e 100644
--- a/README.md
+++ b/README.md
@@ -10,11 +10,10 @@ From basic to advanced: test how well you know JavaScript, refresh your knowledg
 
 Feel free to reach out to me! 😊 <br />
 <a href="https://www.instagram.com/theavocoder">Instagram</a> || <a href="https://www.twitter.com/lydiahallie">Twitter</a> || <a href="https://www.linkedin.com/in/lydia-hallie">LinkedIn</a> || <a href="https://www.lydiahallie.dev">Blog</a>
-
 </div>
 
-| 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! |
-| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| 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!   |
+|---|
 
 ---
 
@@ -34,7 +33,6 @@ Feel free to reach out to me! 😊 <br />
 - [🇳🇱 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)
@@ -55,7 +53,7 @@ Feel free to reach out to me! 😊 <br />
 function sayHi() {
   console.log(name);
   console.log(age);
-  var name = "Lydia";
+  var name = 'Lydia';
   let age = 21;
 }
 
@@ -151,7 +149,7 @@ There is no value `radius` on that object, which returns `NaN`.
 
 ```javascript
 +true;
-!"Lydia";
+!'Lydia';
 ```
 
 - A: `1` and `false`
@@ -176,11 +174,11 @@ The string `'Lydia'` is a truthy value. What we're actually asking, is "is this
 
 ```javascript
 const bird = {
-  size: "small",
+  size: 'small',
 };
 
 const mouse = {
-  name: "Mickey",
+  name: 'Mickey',
   small: true,
 };
 ```
@@ -211,11 +209,11 @@ However, with dot notation, this doesn't happen. `mouse` does not have a key cal
 ###### 6. What's the output?
 
 ```javascript
-let c = { greeting: "Hey!" };
+let c = { greeting: 'Hey!' };
 let d;
 
 d = c;
-c.greeting = "Hello";
+c.greeting = 'Hello';
 console.log(d.greeting);
 ```
 
@@ -285,13 +283,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`
@@ -346,10 +344,10 @@ In order to avoid this, we can use `"use strict"`. This makes sure that you have
 
 ```javascript
 function bark() {
-  console.log("Woof!");
+  console.log('Woof!');
 }
 
-bark.animal = "dog";
+bark.animal = 'dog';
 ```
 
 - A: Nothing, this is totally fine!
@@ -379,8 +377,8 @@ function Person(firstName, lastName) {
   this.lastName = lastName;
 }
 
-const member = new Person("Lydia", "Hallie");
-Person.getFullName = function () {
+const member = new Person('Lydia', 'Hallie');
+Person.getFullName = function() {
   return `${this.firstName} ${this.lastName}`;
 };
 
@@ -397,12 +395,12 @@ console.log(member.getFullName());
 
 #### Answer: A
 
-In JavaScript, functions are objects, and therefore, the method `getFullName` gets added to the constructor function object itself. For that reason, we can call `Person.getFullName()`, but `member.getFullName` throws a `TypeError`.
+In JavaScript, functions are objects, and therefore, the method `getFullName` gets added to the constructor function object itself. For that reason, we can call `Person.getFullName()`, but `member.getFullName` throws a `TypeError`. 
 
 If you want a method to be available to all object instances, you have to add it to the prototype property:
 
 ```js
-Person.prototype.getFullName = function () {
+Person.prototype.getFullName = function() {
   return `${this.firstName} ${this.lastName}`;
 };
 ```
@@ -420,8 +418,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);
@@ -491,7 +489,7 @@ function sum(a, b) {
   return a + b;
 }
 
-sum(1, "2");
+sum(1, '2');
 ```
 
 - A: `NaN`
@@ -558,7 +556,7 @@ function getPersonInfo(one, two, three) {
   console.log(three);
 }
 
-const person = "Lydia";
+const person = 'Lydia';
 const age = 21;
 
 getPersonInfo`${person} is ${age} years old`;
@@ -585,9 +583,9 @@ If you use tagged template literals, the value of the first argument is always a
 ```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`);
   }
@@ -647,7 +645,7 @@ The rest parameter (`...args`) lets us "collect" all remaining arguments into an
 
 ```javascript
 function getAge() {
-  "use strict";
+  'use strict';
   age = 21;
   console.log(age);
 }
@@ -675,7 +673,7 @@ With `"use strict"`, you can make sure that you don't accidentally declare globa
 ###### 21. What's the value of `sum`?
 
 ```javascript
-const sum = eval("10*10+5");
+const sum = eval('10*10+5');
 ```
 
 - A: `105`
@@ -698,7 +696,7 @@ const sum = eval("10*10+5");
 ###### 22. How long is cool_secret accessible?
 
 ```javascript
-sessionStorage.setItem("cool_secret", 123);
+sessionStorage.setItem('cool_secret', 123);
 ```
 
 - A: Forever, the data doesn't get lost.
@@ -751,12 +749,12 @@ You cannot do this with `let` or `const` since they're block-scoped.
 ###### 24. What's the output?
 
 ```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);
 ```
 
@@ -782,7 +780,7 @@ It doesn't work that way for a set. There is no `'1'` in our set: `set.has('1')`
 ###### 25. What's the output?
 
 ```javascript
-const obj = { a: "one", b: "two", a: "three" };
+const obj = { a: 'one', b: 'two', a: 'three' };
 console.log(obj);
 ```
 
@@ -851,12 +849,12 @@ The `continue` statement skips an iteration if a certain condition returns `true
 
 ```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());
+console.log(name.giveLydiaPizza())
 ```
 
 - A: `"Just give Lydia pizza already!"`
@@ -880,8 +878,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;
@@ -913,9 +911,9 @@ Then, we log `a[b]`, which is actually `a["[object Object]"]`. We just set that
 ###### 30. What's the output?
 
 ```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();
@@ -968,7 +966,9 @@ This is where an event loop starts to work. An **event loop** looks at the stack
 ```html
 <div onclick="console.log('first div')">
   <div onclick="console.log('second div')">
-    <button onclick="console.log('button')">Click!</button>
+    <button onclick="console.log('button')">
+      Click!
+    </button>
   </div>
 </div>
 ```
@@ -994,7 +994,9 @@ The deepest nested element that caused the event is the target of the event. You
 
 ```html
 <div onclick="console.log('div')">
-  <p onclick="console.log('p')">Click here!</p>
+  <p onclick="console.log('p')">
+    Click here!
+  </p>
 </div>
 ```
 
@@ -1018,7 +1020,7 @@ If we click `p`, we see two logs: `p` and `div`. During event propagation, there
 ###### 33. What's the output?
 
 ```javascript
-const person = { name: "Lydia" };
+const person = { name: 'Lydia' };
 
 function sayHi(age) {
   return `${this.name} is ${age}`;
@@ -1068,6 +1070,7 @@ console.log(typeof sayHi());
 #### Answer: 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>
@@ -1080,8 +1083,8 @@ FYI: `typeof` can return the following list of values: `undefined`, `boolean`, `
 ```javascript
 0;
 new Number(0);
-("");
-(" ");
+('');
+(' ');
 new Boolean(false);
 undefined;
 ```
@@ -1230,14 +1233,11 @@ What differentiates a primitive from an object is that primitives do not have an
 ###### 40. What's the output?
 
 ```javascript
-[
-  [0, 1],
-  [2, 3],
-].reduce(
+[[0, 1], [2, 3]].reduce(
   (acc, cur) => {
     return acc.concat(cur);
   },
-  [1, 2]
+  [1, 2],
 );
 ```
 
@@ -1264,7 +1264,7 @@ Then, `[1, 2, 0, 1]` is `acc` and `[2, 3]` is `cur`. We concatenate them, and ge
 
 ```javascript
 !!null;
-!!"";
+!!'';
 !!1;
 ```
 
@@ -1292,7 +1292,7 @@ Then, `[1, 2, 0, 1]` is `acc` and `[2, 3]` is `cur`. We concatenate them, and ge
 ###### 42. What does the `setInterval` method return in the browser?
 
 ```javascript
-setInterval(() => console.log("Hi"), 1000);
+setInterval(() => console.log('Hi'), 1000);
 ```
 
 - A: a unique id
@@ -1315,7 +1315,7 @@ It returns a unique id. This id can be used to clear that interval with the `cle
 ###### 43. What does this return?
 
 ```javascript
-[..."Lydia"];
+[...'Lydia'];
 ```
 
 - A: `["L", "y", "d", "i", "a"]`
@@ -1374,14 +1374,14 @@ 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));
+Promise.race([firstPromise, secondPromise]).then(res => console.log(res));
 ```
 
 - A: `"one"`
@@ -1404,7 +1404,7 @@ When we pass multiple promises to the `Promise.race` method, it resolves/rejects
 ###### 46. What's the output?
 
 ```javascript
-let person = { name: "Lydia" };
+let person = { name: 'Lydia' };
 const members = [person];
 person = null;
 
@@ -1444,7 +1444,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,
 };
 
@@ -1473,7 +1473,7 @@ With a `for-in` loop, we can iterate through object keys, in this case `name` an
 ###### 48. What's the output?
 
 ```javascript
-console.log(3 + 4 + "5");
+console.log(3 + 4 + '5');
 ```
 
 - A: `"345"`
@@ -1500,7 +1500,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`
@@ -1525,8 +1525,8 @@ Only the first numbers in the string is returned. Based on the _radix_ (the seco
 ###### 50. What's the output?
 
 ```javascript
-[1, 2, 3].map((num) => {
-  if (typeof num === "number") return;
+[1, 2, 3].map(num => {
+  if (typeof num === 'number') return;
   return num * 2;
 });
 ```
@@ -1554,12 +1554,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);
 
@@ -1591,15 +1591,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);
   }
 }
 
@@ -1629,8 +1629,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();
@@ -1704,11 +1704,11 @@ class Dog {
   }
 }
 
-Dog.prototype.bark = function () {
+Dog.prototype.bark = function() {
   console.log(`Woof I am ${this.name}`);
 };
 
-const pet = new Dog("Mara");
+const pet = new Dog('Mara');
 
 pet.bark();
 
@@ -1773,7 +1773,7 @@ export default counter;
 
 ```javascript
 // index.js
-import myCounter from "./counter";
+import myCounter from './counter';
 
 myCounter += 1;
 
@@ -1802,7 +1802,7 @@ When we try to increment the value of `myCounter`, it throws an error: `myCounte
 ###### 58. What's the output?
 
 ```javascript
-const name = "Lydia";
+const name = 'Lydia';
 age = 21;
 
 console.log(delete name);
@@ -1873,7 +1873,7 @@ This means that the value of `y` is equal to the first value in the array, which
 ###### 60. What's the output?
 
 ```javascript
-const user = { name: "Lydia", age: 21 };
+const user = { name: 'Lydia', age: 21 };
 const admin = { admin: true, ...user };
 
 console.log(admin);
@@ -1899,9 +1899,9 @@ It's possible to combine objects using the spread operator `...`. It lets you cr
 ###### 61. What's the output?
 
 ```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));
@@ -1930,12 +1930,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);
 ```
 
@@ -1966,7 +1966,7 @@ If the replacer is a _function_, this function gets called on every property in
 let num = 10;
 
 const increaseNumber = () => num++;
-const increasePassedNumber = (number) => number++;
+const increasePassedNumber = number => number++;
 
 const num1 = increaseNumber();
 const num2 = increasePassedNumber(num1);
@@ -2123,12 +2123,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;
 ```
 
@@ -2156,7 +2156,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`
@@ -2179,7 +2179,7 @@ Every Symbol is entirely unique. The purpose of the argument passed to the Symbo
 ###### 69. What's the output?
 
 ```javascript
-const name = "Lydia Hallie";
+const name = 'Lydia Hallie';
 console.log(name.padStart(13));
 console.log(name.padStart(2));
 ```
@@ -2206,7 +2206,7 @@ If the argument passed to the `padStart` method is smaller than the length of th
 ###### 70. What's the output?
 
 ```javascript
-console.log("🥑" + "💻");
+console.log('🥑' + '💻');
 ```
 
 - A: `"🥑💻"`
@@ -2230,11 +2230,11 @@ With the `+` operator, you can concatenate strings. In this case, we are concate
 
 ```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();
@@ -2302,7 +2302,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();
@@ -2339,7 +2339,7 @@ function addToList(item, list) {
   return list.push(item);
 }
 
-const result = addToList("apple", ["banana"]);
+const result = addToList('apple', ['banana']);
 console.log(result);
 ```
 
@@ -2399,7 +2399,7 @@ Since `shape` is frozen, and since the value of `x` is not an object, we cannot
 ###### 76. What's the output?
 
 ```javascript
-const { firstName: myName } = { firstName: "Lydia" };
+const { firstName: myName } = { firstName: 'Lydia' };
 
 console.log(firstName);
 ```
@@ -2417,7 +2417,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;
 
@@ -2427,7 +2427,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;
 
@@ -2440,11 +2440,12 @@ 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
 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`.
@@ -2488,7 +2489,7 @@ The `sum` function always returns the same result. If we pass `1` and `2`, it wi
 ```javascript
 const add = () => {
   const cache = {};
-  return (num) => {
+  return num => {
     if (num in cache) {
       return `From cache! ${cache[num]}`;
     } else {
@@ -2533,7 +2534,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);
@@ -2629,13 +2630,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;
     },
@@ -2669,12 +2670,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);
 ```
@@ -2738,9 +2739,9 @@ Variables with the `const` and `let` keyword are _block-scoped_. A block is anyt
 ###### 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));
+fetch('https://www.website.com/api/user/1')
+  .then(res => res.json())
+  .then(res => console.log(res));
 ```
 
 - A: The result of the `fetch` method.
@@ -2794,7 +2795,7 @@ By setting `hasName` equal to `name`, you set `hasName` equal to whatever value
 ###### 87. What's the output?
 
 ```javascript
-console.log("I want pizza"[0]);
+console.log('I want pizza'[0]);
 ```
 
 - A: `"""`
@@ -2849,11 +2850,11 @@ If you're trying to set a default parameter's value equal to a parameter which i
 
 ```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);
 ```
@@ -2886,7 +2887,7 @@ class Person {
   }
 }
 
-const member = new Person("John");
+const member = new Person('John');
 console.log(typeof member);
 ```
 
@@ -2946,7 +2947,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 = () =>
@@ -2977,7 +2978,7 @@ Regular functions, such as the `giveLydiaPizza` function, have a `prototype` pro
 
 ```javascript
 const person = {
-  name: "Lydia",
+  name: 'Lydia',
   age: 21,
 };
 
@@ -3037,7 +3038,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' ]`
@@ -3051,9 +3052,9 @@ 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");
-  return;
+  if (a > b) console.log('a is bigger');
+  else console.log('b is bigger');
+  return
   a + b;
 }
 
@@ -3092,13 +3093,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';
   }
 };
 
@@ -3127,7 +3128,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);
@@ -3182,7 +3183,7 @@ The `getList` function receives an array as its argument. Between the parenthese
 
 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 `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:
 
@@ -3196,7 +3197,7 @@ The following function would have returned an object:
 ###### 99. What's the output?
 
 ```javascript
-const name = "Lydia";
+const name = 'Lydia';
 
 console.log(name());
 ```
@@ -3228,8 +3229,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`
@@ -3255,7 +3256,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);
@@ -3287,16 +3288,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");
+  myPromise().then(res => console.log(res));
+  console.log('second');
 }
 
 async function secondFunction() {
   console.log(await myPromise());
-  console.log("second");
+  console.log('second');
 }
 
 firstFunction();
@@ -3334,8 +3335,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);
@@ -3395,13 +3396,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);
 ```
@@ -3440,7 +3441,7 @@ const colorConfig = {
   yellow: false,
 };
 
-const colors = ["pink", "red", "blue"];
+const colors = ['pink', 'red', 'blue'];
 
 console.log(colorConfig.colors[1]);
 ```
@@ -3469,7 +3470,7 @@ JavaScript interprets (or unboxes) statements. When we use bracket notation, it
 ###### 107. What's its value?
 
 ```javascript
-console.log("❤️" === "❤️");
+console.log('❤️' === '❤️');
 ```
 
 - A: `true`
@@ -3490,14 +3491,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`
@@ -3522,10 +3523,10 @@ With `splice` method, we modify the original array by deleting, replacing or add
 ###### 109. What's the output?
 
 ```javascript
-const food = ["🍕", "🍫", "🥑", "🍔"];
+const food = ['🍕', '🍫', '🥑', '🍔'];
 const info = { favoriteFood: food[0] };
 
-info.favoriteFood = "🍝";
+info.favoriteFood = '🍝';
 
 console.log(food);
 ```
@@ -3579,7 +3580,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' }
 ```
 
@@ -3591,11 +3592,11 @@ JSON.parse(jsonArray); // { name: 'Lydia' }
 ###### 111. What's the output?
 
 ```javascript
-let name = "Lydia";
+let name = 'Lydia';
 
 function getName() {
   console.log(name);
-  let name = "Sarah";
+  let name = 'Sarah';
 }
 
 getName();
@@ -3618,7 +3619,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);
@@ -3636,11 +3637,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();
@@ -3686,7 +3687,7 @@ console.log(two.next().value); // undefined
 ###### 113. What's the output?
 
 ```javascript
-console.log(`${((x) => x)("I love")} to program`);
+console.log(`${(x => x)('I love')} to program`);
 ```
 
 - A: `I love to program`
@@ -3711,7 +3712,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),
 };
 
@@ -3728,9 +3729,9 @@ config = null;
 
 #### Answer: 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.
+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).
 
@@ -3743,16 +3744,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
@@ -3779,14 +3780,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);
@@ -3845,7 +3846,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)]);
 ```
@@ -3871,11 +3872,11 @@ With the `+=` operand, we're incrementing the value of `num` by `1`. `num` had t
 
 ```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}`;
@@ -3913,10 +3914,10 @@ With the optional chaining operator `?.`, we no longer have to explicitly check
 ###### 120. What's the output?
 
 ```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!`);
 }
@@ -3972,10 +3973,10 @@ The `language` method is a `setter`. Setters don't hold an actual value, their p
 ###### 122. What's the output?
 
 ```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`
@@ -4000,7 +4001,7 @@ console.log(!typeof name === "string");
 ###### 123. What's the output?
 
 ```javascript
-const add = (x) => (y) => (z) => {
+const add = x => y => z => {
   console.log(x, y, z);
   return x + y + z;
 };
@@ -4090,20 +4091,20 @@ 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}`;
 }
 
-console.log(getFine(130, 300));
+console.log(getFine(130, 300))
 ```
 
 - A: The driver drove 130 and has to pay 300
@@ -4126,8 +4127,8 @@ With the `Intl.NumberFormat` method, we can format numeric values to any locale.
 ###### 127. What's the output?
 
 ```javascript
-const spookyItems = ["👻", "🎃", "🕸"];
-({ item: spookyItems[3] } = { item: "💀" });
+const spookyItems = ['👻', '🎃', '🕸'];
+({ item: spookyItems[3] } = { item: '💀' });
 
 console.log(spookyItems);
 ```
@@ -4152,7 +4153,7 @@ By destructuring objects, we can unpack values from the right-hand object, and a
 ###### 128. What's the output?
 
 ```javascript
-const name = "Lydia Hallie";
+const name = 'Lydia Hallie';
 const age = 21;
 
 console.log(Number.isNaN(name));
@@ -4188,7 +4189,7 @@ const randomValue = 21;
 
 function getInfo() {
   console.log(typeof randomValue);
-  const randomValue = "Lydia Hallie";
+  const randomValue = 'Lydia Hallie';
 }
 
 getInfo();
@@ -4214,7 +4215,7 @@ Variables declared with the `const` keyword are not referenceable before their i
 ###### 130. What's the output?
 
 ```javascript
-const myPromise = Promise.resolve("Woah some cool data");
+const myPromise = Promise.resolve('Woah some cool data');
 
 (async () => {
   try {
@@ -4222,7 +4223,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!');
   }
 })();
 ```
@@ -4247,7 +4248,7 @@ In the `try` block, we're logging the awaited value of the `myPromise` variable:
 ###### 131. What's the output?
 
 ```javascript
-const emojis = ["🥑", ["✨", "✨", ["🍕", "🍕"]]];
+const emojis = ['🥑', ['✨', '✨', ['🍕', '🍕']]];
 
 console.log(emojis.flat(1));
 ```
@@ -4320,19 +4321,19 @@ We invoke `counterTwo.increment()`, which sets `count` to `3`. Then, we log the
 ###### 133. What's the output?
 
 ```javascript
-const myPromise = Promise.resolve(Promise.resolve("Promise"));
+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!");
+  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!");
+  console.log(`${res} 2!`)
+  setTimeout(() => console.log('Timeout 2!'), 0);
+  console.log('Last line 2!');
 }
 
 funcOne();
@@ -4353,7 +4354,7 @@ First, we invoke `funcOne`. On the first line of `funcOne`, we call the _asynchr
 
 Then we call the `myPromise` promise, which is an _asynchronous_ operation.
 
-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.
+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.
 
@@ -4377,7 +4378,7 @@ export default function sum(x) {
 }
 
 // index.js
-import * as sum from "./sum";
+import * as sum from './sum';
 ```
 
 - A: `sum(4)`
@@ -4394,12 +4395,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);
 ```
 
@@ -4430,13 +4431,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;
 ```
 
@@ -4466,7 +4467,7 @@ Then, we access a property value on the proxy object, the `get` property on the
 ###### 136. Which of the following will modify the `person` object?
 
 ```javascript
-const person = { name: "Lydia Hallie" };
+const person = { name: 'Lydia Hallie' };
 
 Object.seal(person);
 ```
@@ -4494,9 +4495,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',
   },
 };
 
@@ -4525,7 +4526,7 @@ However, it only _shallowly_ freezes the object, meaning that only _direct_ prop
 ###### 138. What's the output?
 
 ```javascript
-const add = (x) => x + x;
+const add = x => x + x;
 
 function myFunc(num = 2, value = add(num)) {
   console.log(num, value);
@@ -4558,21 +4559,21 @@ Then, we invoked `myFunc(3)` and passed the value `3` as the value for the argum
 
 ```javascript
 class Counter {
-  #number = 10;
+  #number = 10
 
   increment() {
-    this.#number++;
+    this.#number++
   }
 
   getNum() {
-    return this.#number;
+    return this.#number
   }
 }
 
-const counter = new Counter();
-counter.increment();
+const counter = new Counter()
+counter.increment()
 
-console.log(counter.#number);
+console.log(counter.#number)
 ```
 
 - A: `10`
@@ -4596,8 +4597,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) {
@@ -4640,8 +4641,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) {
@@ -4649,9 +4650,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);
 ```
@@ -4720,11 +4721,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;
 ```
 
@@ -4779,11 +4780,11 @@ Objects aren't iterable by default. An iterable is an iterable if the iterator p
 let count = 0;
 const nums = [0, 1, 2, 3];
 
-nums.forEach((num) => {
-  if (num) count += 1;
-});
+nums.forEach(num => {
+	if (num) count += 1
+})
 
-console.log(count);
+console.log(count)
 ```
 
 - A: 1
@@ -4807,12 +4808,12 @@ The `if` condition within the `forEach` loop checks whether the value of `num` i
 
 ```javascript
 function getFruit(fruits) {
-  console.log(fruits?.[1]?.[1]);
+	console.log(fruits?.[1]?.[1])
 }
 
-getFruit([["🍊", "🍌"], ["🍍"]]);
-getFruit();
-getFruit([["🍍"], ["🍊", "🍌"]]);
+getFruit([['🍊', '🍌'], ['🍍']])
+getFruit()
+getFruit([['🍍'], ['🍊', '🍌']])
 ```
 
 - A: `null`, `undefined`, 🍌
@@ -4825,11 +4826,11 @@ getFruit([["🍍"], ["🍊", "🍌"]]);
 
 #### Answer: 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`.
+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.
+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.
 
@@ -4842,19 +4843,19 @@ Lastly, we're trying to log the second item in the `['🍊', '🍌']` subarray o
 
 ```javascript
 class Calc {
-  constructor() {
-    this.count = 0;
-  }
+	constructor() {
+		this.count = 0 
+	}
 
-  increase() {
-    this.count++;
-  }
+	increase() {
+		this.count ++
+	}
 }
 
-const calc = new Calc();
-new Calc().increase();
+const calc = new Calc()
+new Calc().increase()
 
-console.log(calc.count);
+console.log(calc.count)
 ```
 
 - A: `0`
@@ -4878,25 +4879,25 @@ 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 }) => {
-  if (email) {
-    Object.assign(user, { email });
-  }
+	if (email) {
+		Object.assign(user, { email })
+	}
 
-  if (password) {
-    user.password = password;
-  }
+	if (password) {
+		user.password = password
+	}
 
-  return user;
-};
+	return user
+}
 
-const updatedUser = updateUser({ email: "new@email.com" });
+const updatedUser = updateUser({ email: "new@email.com" })
 
-console.log(updatedUser === user);
+console.log(updatedUser === user)
 ```
 
 - A: `false`
@@ -4919,13 +4920,13 @@ The `updateUser` function updates the values of the `email` and `password` prope
 ###### 149. What's the output?
 
 ```javascript
-const fruit = ["🍌", "🍊", "🍎"];
+const fruit = ['🍌', '🍊', '🍎']
 
-fruit.slice(0, 1);
-fruit.splice(0, 1);
-fruit.unshift("🍇");
+fruit.slice(0, 1)
+fruit.splice(0, 1)
+fruit.unshift('🍇')
 
-console.log(fruit);
+console.log(fruit)
 ```
 
 - A: `['🍌', '🍊', '🍎']`
@@ -4940,7 +4941,7 @@ console.log(fruit);
 
 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 `['🍇', '🍊', '🍎']`.
+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>
@@ -4951,13 +4952,13 @@ 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]);
+console.log(animals[dog])
 ```
 
 - A: `{ emoji: "🐶", name: "Mara" }`
@@ -4970,11 +4971,11 @@ console.log(animals[dog]);
 
 #### Answer: B
 
-Object keys are converted to strings.
+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"}`.
+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.
+`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" }`.
 
@@ -4987,14 +4988,14 @@ Logging `animals[dog]`, or actually `animals["object Object"]` since converting
 
 ```javascript
 const user = {
-  email: "my@email.com",
-  updateEmail: (email) => {
-    this.email = email;
-  },
-};
+	email: "my@email.com",
+	updateEmail: email => {
+		this.email = email
+	}
+}
 
-user.updateEmail("new@email.com");
-console.log(user.email);
+user.updateEmail("new@email.com")
+console.log(user.email)
 ```
 
 - A: `my@email.com`
@@ -5007,7 +5008,7 @@ console.log(user.email);
 
 #### Answer: 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.
+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>
@@ -5017,20 +5018,20 @@ The `updateEmail` function is an arrow function, and is not bound to the `user`
 ###### 152. What's the output?
 
 ```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]);
-  const res2 = await Promise.all([promise3, promise4]);
-  return [res1, res2];
-};
+	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));
+	.then(res => console.log(res))
+	.catch(err => console.log(err))
 ```
 
 - A: `[['First', 'Second'], ['Fourth']]`
@@ -5043,26 +5044,23 @@ runPromises()
 
 #### Answer: 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` 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` rejected with this value.
+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` 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` rejected with this value.
 
 </p>
 </details>
 
 ---
 
-###### 153. What should the value of `method` be to log `{ name: "Lydia", age: 22 }`?
+###### 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 =
-  /* ?? */
-  Object[method](
-    keys.map((_, i) => {
-      return [keys[i], values[i]];
-    })
-  ); // { name: "Lydia", age: 22 }
+const method = /* ?? */
+Object[method](keys.map((_, i) => {
+	return [keys[i], values[i]]
+})) // { name: "Lydia", age: 22 }
 ```
 
 - A: `entries`
@@ -5075,7 +5073,7 @@ const method =
 
 #### Answer: 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 which 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.
+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 which 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 }`
 
@@ -5087,18 +5085,18 @@ This creates an array of subarrays containing the correct keys and values, which
 ###### 154. What's the output?
 
 ```javascript
-const createMember = ({ email, address = {} }) => {
-  const validEmail = /.+\@.+\..+/.test(email);
-  if (!validEmail) throw new Error("Valid email pls");
+const createMember = ({ email, address = {}}) => {
+	const validEmail = /.+\@.+\..+/.test(email)
+	if (!validEmail) throw new Error("Valid email pls")
 
-  return {
-    email,
-    address: address ? address : null,
-  };
-};
+	return {
+		email,
+		address: address ? address : null
+	}
+}
 
-const member = createMember({ email: "my@email.com" });
-console.log(member);
+const member = createMember({ email: "my@email.com" })
+console.log(member)
 ```
 
 - A: `{ email: "my@email.com", address: null }`
@@ -5121,13 +5119,13 @@ The default value of `address` is an empty object `{}`. When we set the variable
 ###### 155. What's the output?
 
 ```javascript
-let randomValue = { name: "Lydia" };
-randomValue = 23;
+let randomValue = { name: "Lydia" }
+randomValue = 23
 
 if (!typeof randomValue === "string") {
-  console.log("It's not a string!");
+	console.log("It's not a string!")
 } else {
-  console.log("Yay it's a string!");
+	console.log("Yay it's a string!")
 }
 ```
 
diff --git a/ar-AR/README_AR.md b/ar-AR/README_AR.md
index 9c1210e2..6d5638e7 100644
--- a/ar-AR/README_AR.md
+++ b/ar-AR/README_AR.md
@@ -1,14 +1,16 @@
+
+
 <div dir='rtl'>
 
 # قائــمة أسئلة جافا سكريبت (مستوى متقدم)
-
 أقوم بنشر عدة أسئلة جافاسكريبت بصورة يومية على حسابي في [انستغرام](https://www.instagram.com/theavocoder/).
 
 تتدرج الأسئلة إبتداءا من المستوى الأساسي أو البسيط الى المستوى المتقدم لإختبار مدى معرفتك بلغة الجافا سكريبت, قم بمراجعة و إنعاش معرفتك باللغة قليلا, أو قم بالتجهيز لمقابلة عمل لوظيفة مبرمج عن طريق هذه الأسئلة!
 
 أقوم بتحديث هذا المستودع أسبوعيا بإضافة المزيد من الأسئلة. :muscle: :rocket:
 
-الأجوبة توجد في الجزء المطوي بالأسفل أدناه تحت كل سؤال على حدة, فقط قم بالضغط على كلمة الإجابة لكي تحصل على الإجابة, حظا موفقا :heart:
+
+الأجوبة توجد في الجزء المطوي بالأسفل أدناه تحت كل سؤال على حدة, فقط قم بالضغط على كلمة الإجابة لكي تحصل على الإجابة, حظا موفقا  :heart: 
 
 اللغات المتوفرة:
 
@@ -25,7 +27,6 @@
 - [🇳🇱 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)
@@ -36,7 +37,8 @@
 - [🇹🇼 繁體中文](../zh-TW/README_zh-TW.md)
 </div>
 
----
+____________
+
 
 1. ماهو الناتج ؟
 
@@ -62,10 +64,10 @@ sayHi();
 <div dir='rtl'>
 الإجابة هي الخيار الرابع : D
 
-في داخل الدالة, قمنا أولا بتعريف المتغير `name` مع الكلمة المفتاحية `var`. و هذا يعني ان المتغير قد حصلت له عملية hoisting والتي تعني انه قد تم حجز مساحة لهذا المتغير في هذه اللحظة مع قيمة مبدئية و التي هي `undefined` إلى ان نقوم فعليا بتعريف قيمة له لاحقا.
+في داخل الدالة, قمنا أولا بتعريف المتغير `name` مع الكلمة المفتاحية `var`. و هذا يعني ان المتغير قد حصلت له عملية hoisting  والتي تعني انه قد تم حجز مساحة لهذا المتغير في هذه اللحظة مع قيمة مبدئية و التي هي  `undefined`  إلى ان نقوم فعليا بتعريف قيمة له لاحقا.
 لم نقم بتعريف المتغير `name` بعد عندما قمنا بطباعته في السطر الاول من الدالة, لهذا لايزال يحمل القيمة `undefined`.
-</br>
-المتغيرات التي تم تعريفها بجانب الكلمات المفتاحية `let` و `const` يتم عمل عملية hoisting لها أيضا, ولكن على عكس المتغيرات التي يتم تعريفها بجانب الكلمة المفتاحية `var`, لا يتم تعريفها او الوصول اليها مالم نقم بإضافة قيمة لها فعليا. و يسمى هذا بال"temporal dead zone".عندما نحاول الوصول الى المتغيرات من النوع `let`قبل ان يتم تعريفها, نتحصل على الخطأ التالي `ReferenceError`.
+  </br>
+المتغيرات التي تم تعريفها بجانب الكلمات المفتاحية `let` و  `const` يتم عمل عملية hoisting لها أيضا, ولكن على عكس المتغيرات التي يتم تعريفها بجانب الكلمة المفتاحية `var`, لا يتم تعريفها او الوصول اليها مالم نقم بإضافة قيمة لها فعليا. و يسمى هذا بال"temporal dead zone".عندما نحاول الوصول الى المتغيرات من النوع `let`قبل ان يتم تعريفها, نتحصل على الخطأ التالي  `ReferenceError`.  
 
 </p>
 </details>
@@ -95,8 +97,8 @@ for (let i = 0; i < 3; i++) {
 <div dir='rtl'>
 الإجابة هي الخيار الثالث: C
 
-بسبب ترتيب تسلسل الأحداث في الجافا سكريبت, دالة `setTimeout` والتي هي دالة من نوع callbackقد تم استدعائها بعد ان تم تنفيذ ال loop. بماأن المتغير `i` في الloop الاولى قد تم تعريفه عن طريق الكلمة المفتاحية `var` فإن هذه القيمة هي global. أثناء تنفيذ هذه ال loop قد تم إضافة 1 الى المتغير `var` في كل دورة باستخدام العملية `++`. بنهاية الدورة و عندما تم استدعاء الدالة `setTimeout` كانت قيمة المتغير `i` قد أصبحت تساوي `3` في المثال الأول.  
-في الloop الثانية ,تم تعريف المتغير `i` باستخدام الكلمة المفتاحية `let` المتغيرات التي يتم تعريفها باستخدام الكلمات المفتاحية `let` و `const` هي متغيرات تنتمي فقط للBlock الذي تم تعريفها بداخله, والذي هو بين القوسين, أثناءتنفيذ الloop, سنقوم بالتحصل على قيمة جديدة للمتغير `i` في نهاية كل دورة , وأي قيمة تكون منتمية للScope بداخل الloop.
+بسبب ترتيب تسلسل الأحداث في الجافا سكريبت, دالة `setTimeout` والتي هي دالة من نوع callbackقد تم استدعائها بعد ان تم تنفيذ ال loop. بماأن المتغير `i` في الloop  الاولى قد تم تعريفه عن طريق الكلمة المفتاحية `var` فإن هذه القيمة هي global. أثناء تنفيذ هذه ال loop قد تم إضافة 1 الى المتغير `var` في كل دورة باستخدام العملية `++`. بنهاية الدورة و عندما تم استدعاء الدالة `setTimeout` كانت قيمة المتغير `i` قد أصبحت تساوي `3` في المثال الأول.        
+في الloop  الثانية ,تم تعريف المتغير `i` باستخدام الكلمة المفتاحية `let`  المتغيرات التي يتم تعريفها باستخدام الكلمات المفتاحية `let`  و `const` هي متغيرات تنتمي فقط للBlock  الذي تم تعريفها بداخله, والذي هو بين القوسين, أثناءتنفيذ الloop, سنقوم بالتحصل على قيمة جديدة للمتغير `i` في نهاية كل دورة  , وأي قيمة تكون منتمية للScope  بداخل الloop.
 
 </p>
 </details>
@@ -112,7 +114,7 @@ const shape = {
   diameter() {
     return this.radius * 2;
   },
-  perimeter: () => 2 * Math.PI * this.radius,
+  perimeter: () => 2 * Math.PI * this.radius
 };
 
 shape.diameter();
@@ -134,13 +136,14 @@ shape.perimeter();
 
 لا توجد قيمة `radius` في ذلك ال object لهذا يقوم بإرجاع القيمة `undefined`.
 
+
 </p>
 </details>
 </div>
 
 ---
 
-4. ماهو الناتج؟
+4. ماهو الناتج؟ 
 
 ```javascript
 +true;
@@ -157,24 +160,23 @@ shape.perimeter();
 الجواب هو الخيار الأول : A
 
 عملية الزيادة الأحادية هنا وجدت لكي تقوم بتحويل المعامل الى رقم, `true` هي `1` , و `false` هي `0`.  
- المتغير من نوع string `'Lydia'` هو قيمة صدقية أو حقيقية, بمعنى أنها تساوي `true` . السؤال الذي نقوم بطرحه هنا, هو هل هذه القيمة الصدقية هي قيمة غير صدقية؟ اي تساوي `false`؟ لهذا نتحصل على الجواب `false`.
-
+ المتغير من نوع string `'Lydia'` هو قيمة صدقية أو حقيقية, بمعنى أنها تساوي `true` . السؤال الذي نقوم بطرحه هنا, هو هل هذه القيمة الصدقية هي قيمة غير صدقية؟ اي تساوي `false`؟ لهذا نتحصل على الجواب `false`.   
 </p>
 </details>
 </div>
 
 ---
 
-5. أي الإجابات هو إجابة صحيحة؟
+5. أي الإجابات هو إجابة صحيحة؟ 
 
 ```javascript
 const bird = {
-  size: "small",
+  size: "small"
 };
 
 const mouse = {
   name: "Mickey",
-  small: true,
+  small: true
 };
 ```
 
@@ -188,21 +190,20 @@ const mouse = {
 <div dir='rtl'>
 الجواب هو الخيار الأول: A
 
-في لغة الجافا سكريبت, جميع مفاتيح الobjects هي من النوع string. الا اذا كانت عبارة عن symbol. حتى ولو أننا في بعض المرات لانقوم بوضع نوعها على انها string بصورة صريحة, ولكنها دائما يتم تحويلها الى نوع string وراء الكواليس.
+في لغة الجافا سكريبت, جميع مفاتيح الobjects  هي من النوع string. الا اذا كانت عبارة عن  symbol. حتى ولو أننا في بعض المرات لانقوم بوضع نوعها على انها string  بصورة صريحة, ولكنها دائما يتم تحويلها الى نوع string  وراء الكواليس.
 
-لغة الجافاسكريبت تقوم بترجمةال statements.عندما نقوم باستعمال ال bracket notation, تقوم الجافا سكريبت اولا برؤية أول فتحة للقوس `[` و تقوم بالمتابعة الى ان تجد قفلة هذا القوس `]`.فقط عندما تصل الى قفلة القوس حتى تقوم بتقييم ال statement و من ثم معالجتها.
+لغة الجافاسكريبت تقوم بترجمةال statements.عندما نقوم باستعمال ال bracket notation, تقوم الجافا سكريبت اولا برؤية أول فتحة للقوس `[` و تقوم بالمتابعة الى ان تجد قفلة هذا القوس `]`.فقط عندما تصل الى قفلة القوس حتى تقوم بتقييم ال statement و من ثم معالجتها. 
 `mouse[bird.size]`: اولا تقوم بتقييم`bird.size`, والتي هي تساوي `"small"`. `mouse["small"]` تقوم بإرجاع`true`
 
-ولكن في المقابل, عندما نقوم بإستخدام ال dot notation,لا يتم معالجة الأمر هكذا. `mouse` ليس لديها مفتاح يسمى `bird`, و هذا يعني أن `mouse.bird` هي قيمة `undefined`. بالتالي نقوم بالسؤال عن ال`size` بإستخدام ال dot notation: للسؤال عن قيمة `mouse.bird.size`.
-وبما أن `mouse.bird`قيمتها `undefined` ف نحن فعليا نقوم بالسؤال عن `undefined.size` و التي هي بالتأكيد غير صحيحة و غير صالحة و ستقوم بإرجاع error مشابه ل `Cannot read property "size" of undefined`.
-
+ولكن في المقابل, عندما نقوم بإستخدام ال dot notation,لا يتم معالجة الأمر هكذا. `mouse` ليس لديها مفتاح يسمى `bird`, و هذا يعني أن `mouse.bird` هي قيمة `undefined`. بالتالي نقوم بالسؤال عن ال`size` بإستخدام ال dot notation: للسؤال عن قيمة  `mouse.bird.size`.
+وبما أن `mouse.bird`قيمتها `undefined` ف نحن فعليا نقوم بالسؤال عن `undefined.size` و التي هي بالتأكيد غير صحيحة و غير صالحة و ستقوم بإرجاع error مشابه ل `Cannot read property "size" of undefined`.    
 </p>
 </details>
 </div>
 
 ---
 
-6. ماهو الناتج؟
+6. ماهو الناتج؟ 
 
 ```javascript
 let c = { greeting: "Hey!" };
@@ -230,7 +231,7 @@ console.log(d.greeting);
 
 <img src="https://i.imgur.com/ko5k0fs.png" width="200">
 
-لذا, عندما تقوم بتغيير object واحد , انت فعليا تقوم بتغيير جميع الobjects.
+لذا, عندما تقوم بتغيير object واحد , انت فعليا تقوم بتغيير جميع الobjects. 
 
 </p>
 </details>
@@ -260,13 +261,13 @@ console.log(b === c);
 <div dir='rtl'>
 الجواب هو الخيار الثالث: C
 
-`new Number()` هي دالة من نوع built-in function constructer. على الرغم من أنها تبدو كرقم, ولكنها في الحقيقة ليس رقم, هي عبارة عن object ولديها العديد العديد من المميزات.
-
+`new Number()` هي دالة من نوع built-in function constructer. على الرغم من أنها تبدو كرقم, ولكنها في الحقيقة ليس رقم, هي عبارة عن object  ولديها العديد العديد من المميزات.
+  
 عندما نقوم بإستخدام العلامة او العامل `==`, هي تقوم فقط بالتحقق من إذا ماكان لديها same _value_.كلا الطرفين قيمتهم تساوي `3` لهذا تقوم بإرجاع `true`.
 
-و لكن على الرغم من هذا, عندما نقوم بإستخدام العملية أو المعامل `===`, كلا القيمة _and_ النوع يجب ان يكونا نفس الشيء.
+و لكن على الرغم من هذا, عندما نقوم بإستخدام العملية أو المعامل `===`, كلا القيمة _and_ النوع يجب ان يكونا نفس الشيء. 
 
-هي ليست `new Number()` هي ليست عبارة عن رقم, هي عبارة عن **object** , وكلاهما سيقومان بإرجاع `false.`
+هي ليست `new Number()` هي ليست عبارة عن رقم, هي عبارة عن **object** , وكلاهما سيقومان بإرجاع `false.`   
 
 </p>
 </details>
@@ -274,7 +275,7 @@ console.log(b === c);
 
 ---
 
-8. ماهو الناتج؟
+8. ماهو الناتج؟ 
 
 ```javascript
 class Chameleon {
@@ -302,8 +303,7 @@ console.log(freddie.colorChange("orange"));
 <div dir='rtl'>
 الجواب هو الخيار الرابع: D
 
-الدالة `colorChange` هي دالة static, و الدوال التي هي من نوع static هي دوال صممت لكي يتم استخدامها فقط في الconstructor الذي تم تعريفها به, و ليس من الممكن ان يتم تمريرها او استخدامها من قبل اي مكون children. بما أن `freddie` هي متغير children فإن الدالة لم يتم تمريرها اليه و هي غير متوفرة في ال instant من `freddie` لذا نتحصل على الخطأ `TypeError` .
-
+الدالة `colorChange` هي دالة static, و الدوال التي هي من نوع static هي دوال صممت لكي يتم استخدامها فقط في الconstructor  الذي تم تعريفها به, و ليس من الممكن ان يتم تمريرها او استخدامها من قبل اي مكون children. بما أن `freddie` هي متغير children فإن الدالة لم يتم تمريرها اليه و هي غير متوفرة في ال instant من  `freddie` لذا نتحصل على الخطأ `TypeError` .    
 </p>
 </details>
 </div>
@@ -327,17 +327,16 @@ console.log(greetign);
 <div dir='rtl'>
 الجواب هو الخيار الأول : A
 
-تقوم بعمل log على الconsole ل object. و لأننا قمنا بإنشاء object فارغ في global object! عندما قمنا بالخطأ بطباعة `greetign` بدل ان نقوم بطباعتها بصورة صحيحة هكذا `greeting`, هنا قام مترجم الجافاسكريبت بترجمة الآتي `global.greetign = {}` أو `window.greetign = {}` في المتصفح.
-
-لكي نتجنب حدوث مثل هذه الحالة, بإمكاننا إستخدام `"use strict"`. بفعل هذه الخطوة ستتأكد من أنك قد عرفت المتغير قبل ان تساويه بأي شي آخر.
+تقوم بعمل log على الconsole  ل object. و لأننا قمنا بإنشاء object فارغ في global object! عندما قمنا بالخطأ بطباعة  `greetign` بدل ان نقوم بطباعتها بصورة صحيحة هكذا `greeting`, هنا قام مترجم الجافاسكريبت بترجمة الآتي `global.greetign = {}` أو `window.greetign = {}` في المتصفح.   
 
+لكي نتجنب حدوث مثل هذه الحالة, بإمكاننا إستخدام `"use strict"`. بفعل هذه الخطوة ستتأكد من أنك قد عرفت المتغير قبل ان تساويه بأي شي آخر. 
 </p>
 </details>
 </div>
 
 ---
 
-10. ما الذي يحدث عندما نقوم بعمل الآتي؟
+ 10. ما الذي يحدث عندما نقوم بعمل الآتي؟ 
 
 ```javascript
 function bark() {
@@ -360,7 +359,6 @@ bark.animal = "dog";
 هذا ممكن في لغة الجافاسكريبت, لأن الدوال هي عبارة عن objects, (كل شيء بداخل الأنواع التي هي primitive هو عبارة عن object)
 
 الدالة هي عبارة عن نوع خاص من الobjects, الكود الذي تقوم بكتابته بنفسك هو ليس بالدالة الفعلية, الدالة هي object لديه خصائص. و هذه الخاصية قابلة للمناداة
-
 </p>
 </details>
 </div>
@@ -376,7 +374,7 @@ function Person(firstName, lastName) {
 }
 
 const member = new Person("Lydia", "Hallie");
-Person.getFullName = function () {
+Person.getFullName = function() {
   return `${this.firstName} ${this.lastName}`;
 };
 
@@ -394,11 +392,10 @@ console.log(member.getFullName());
 الجواب هو الخيار الأول: A
 
 ليس بإمكانك اضافة الخصائص ل constructor كما تقوم بإضافة الخصائص للobjects. إذا أردت أن تضيف مميزات لكل الobjects مرة واحدة, سيجب عليك أن تقوم بإستخدام الprototype. لذا في هذه الحالة,
-
 </div>
 
 ```js
-Person.prototype.getFullName = function () {
+Person.prototype.getFullName = function() {
   return `${this.firstName} ${this.lastName}`;
 };
 ```
@@ -437,10 +434,9 @@ console.log(sarah);
 <div dir='rtl'>
 الجواب هو الخيار الأول: A
 
-للمتغير `sarah` لم نقم بإستخدام الكلمة المفتاحية `new`, عندإستخدام الكلمة المفتاحية `new` ف هي تشير الى ال object الخالي او الفارغ الذي قمنا بإنشاءه, و لكن اذا لم تقم بإضافة`new` ف هي ستشير الى ال **global object**!.
-
-نحن نقول بأن `this.firstName` تساوي `"Sarah"` و `this.lastName` تساوي `"Smith"`. ماقمنا بفعله حقا هنا, هو أنه قمنا بتعريف `global.firstName = 'Sarah'` و `global.lastName = 'Smith'`. المتغير `sarah` لا يظل `undefined`.
+للمتغير `sarah` لم نقم بإستخدام الكلمة المفتاحية `new`, عندإستخدام الكلمة المفتاحية `new` ف هي تشير الى ال object  الخالي او الفارغ الذي قمنا بإنشاءه, و لكن اذا لم تقم بإضافة`new` ف هي ستشير الى ال **global object**!.  
 
+نحن نقول بأن `this.firstName` تساوي `"Sarah"` و `this.lastName` تساوي `"Smith"`. ماقمنا بفعله حقا هنا, هو أنه قمنا بتعريف `global.firstName = 'Sarah'` و `global.lastName = 'Smith'`. المتغير `sarah` لا يظل `undefined`.     
 </p>
 </details>
 </div>
@@ -461,7 +457,7 @@ console.log(sarah);
 <div dir='rtl'>
 الجواب هو الخيار الرابع: D
 
-أثناء مرحلة ال**capturing**, الevent تمر عبر العناصر العليا, أي العناصر الآباء إلى أن تصل الى العنصر المقصود أو المراد, حينها تتمكن من الوصول الى العنصر **target** , و حينها تبدأ عملية ال **bubbling**.
+أثناء مرحلة ال**capturing**, الevent تمر عبر العناصر العليا, أي العناصر الآباء إلى أن تصل الى العنصر المقصود أو المراد, حينها تتمكن من الوصول الى العنصر **target** , و حينها تبدأ عملية ال **bubbling**. 
 
 <img src="https://i.imgur.com/N18oRgd.png" width="200">
 
@@ -483,8 +479,7 @@ console.log(sarah);
 <div dir='rtl'>
 الجواب هو الخيار الثاني: B
 
-جميع الobjects لديها prototypes, عدا ال objects من نوع **base object**. الobject من نوع base object هو عبارة عن object تم إنشاءه من قبل المستخدم, أو تم إنشاءه عن طريق إستخدام الكلمة المفتاحية `new`. الbase object لديه حق الوصول الى بعض ال methods و الخصائص. مثال: `.toString`. هذا هو السبب الذي يمكنك من إستخدام built-in JavaScript methods, مثل هذه ال methods جميعها متاحة في ال ptototype, على الرغم من أن لغة الجافا سكريبت ليس بإمكانها أن تجدها بصورة مباشرة من الobject الذي قمت أنت بإنشاءه, و لكنها تذهب الى سلسلة الprototype حيث بإمكانها ان تجده هناك, مما يجعله قابل للوصول من قبلك, أي بإمكانك أن تصل إليه.
-
+جميع الobjects  لديها prototypes, عدا ال objects من نوع **base object**. الobject من نوع base object هو عبارة عن object  تم إنشاءه من قبل المستخدم, أو تم إنشاءه عن طريق إستخدام الكلمة المفتاحية `new`. الbase object  لديه حق الوصول الى بعض ال methods و الخصائص. مثال: `.toString`. هذا هو السبب الذي يمكنك من إستخدام built-in JavaScript methods, مثل هذه ال methods جميعها متاحة في ال ptototype, على الرغم من أن لغة الجافا سكريبت ليس بإمكانها أن تجدها بصورة مباشرة من الobject  الذي قمت أنت بإنشاءه, و لكنها تذهب الى سلسلة الprototype  حيث بإمكانها ان تجده هناك, مما يجعله قابل للوصول من قبلك, أي بإمكانك أن تصل إليه.   
 </p>
 </details>
 </div>
@@ -511,10 +506,9 @@ sum(1, "2");
 <div dir='rtl'>
 الجواب هو الخيار الثالث: C
 
-لغة الجافاسكريبت هي لغة **dynamically typed language** بمعنى أننا لا نقوم بتعريف نوع معين للمتغيرات, المتغيرات بصورة أوتوماتيكية يتم تحويلها الى أنواع أخرى بدون أن تعرف أنت ذلك, وهذا يسمى ب _implicit type coercion_. **Coercion** تعني بأنك تقوم بالتحويل من نوع الى آخر.
-
-في هذا المثال, لغة الجافاسكريبت تقوم بتحويل الرقم `1` الى string, لكي تستطيع الدالةأن تقوم بعملها و تتمكن من إرجاع قيمة. أثناء قيام عملية إضافةالمتغير من النوع number و الذي هو (`1`) و المتغير من النوع string والذي هو (`'2'`), الرقم تم التعامل معه ك string, بهذه الطريقة سنتمكن من عمل عملية concatenate للمتغيرين من نوع string ك مثال `"Hello" + "World"`, لهذا مايحدث هنا هو عبارة عن `"1" + "2"` و الذي بدوره يقوم بإرجاع `"12"`.
+لغة الجافاسكريبت هي لغة **dynamically typed language** بمعنى أننا لا نقوم بتعريف نوع معين للمتغيرات, المتغيرات بصورة أوتوماتيكية يتم تحويلها الى أنواع أخرى بدون أن تعرف أنت ذلك, وهذا يسمى ب _implicit type coercion_. **Coercion** تعني بأنك تقوم بالتحويل من نوع الى آخر.  
 
+في هذا المثال, لغة الجافاسكريبت تقوم بتحويل الرقم `1` الى string, لكي تستطيع الدالةأن تقوم بعملها و تتمكن من إرجاع قيمة. أثناء قيام عملية إضافةالمتغير من النوع number  و الذي هو (`1`) و المتغير من النوع string  والذي هو (`'2'`), الرقم تم التعامل معه ك string,  بهذه الطريقة سنتمكن من عمل عملية concatenate للمتغيرين من نوع string ك مثال `"Hello" + "World"`, لهذا مايحدث هنا هو عبارة عن `"1" + "2"` و الذي بدوره يقوم بإرجاع `"12"`.      
 </p>
 </details>
 </div>
@@ -547,8 +541,8 @@ console.log(number);
 
 ال **prefix** العامل الأحادي `++`:
 
-1. تقوم بزيادة القيمة(number الآن تساوي `2`)
-2. تقوم بإٍرجاع القيمة (هذه ترجع `2`)
+1. تقوم بزيادة القيمة(number الآن تساوي  `2`)
+2. تقوم بإٍرجاع القيمة (هذه ترجع  `2`)
 
 هذا يقوم بإرجاع `0 2 2`.
 
@@ -558,7 +552,7 @@ console.log(number);
 
 ---
 
-17.ماهو الناتج؟
+17.ماهو الناتج؟   
 
 ```javascript
 function getPersonInfo(one, two, three) {
@@ -582,8 +576,7 @@ getPersonInfo`${person} is ${age} years old`;
 <div dir='rtl'>
 الجواب هو الخيار الثاني: B
 
-اذا قمت بإستخدام tagged template literals, فإن قيمة ال argument الأول هي دائما عبارة عن array والذي نوع قيمها عبارة عن string, ماتبقى من الarguments تتحصل على القيم من الpassed expressions.
-
+اذا قمت بإستخدام tagged template literals, فإن قيمة ال argument الأول هي دائما عبارة عن array والذي نوع قيمها عبارة عن string, ماتبقى من الarguments تتحصل على القيم من الpassed expressions. 
 </p>
 </details>
 </div>
@@ -615,11 +608,11 @@ checkAge({ age: 18 });
 <div dir='rtl'>
 الجواب هو الخيار الثالث: C
 
-عندما نقوم بإختبار المساواة أو التساوي بين طرفين, ال primitives يتم مقارنتها عن طريق قيمها, بينما ال objects يتم مقارنتها عن طريق الreference الذي يتبع لها, لغة الجافاسكريبت تتحقق عن إذا ماكان الrefrence الذي يتبع لobject يشير الى نفس الموقع في الذاكرة.
+عندما نقوم بإختبار المساواة أو التساوي بين طرفين, ال primitives يتم مقارنتها عن طريق قيمها, بينما ال objects  يتم مقارنتها عن طريق الreference الذي يتبع لها, لغة الجافاسكريبت تتحقق عن إذا ماكان الrefrence الذي يتبع لobject يشير الى نفس الموقع في الذاكرة. 
 
-لدينا هنا اثنان من ال objects والتي نقوم بعمل مقارنة بينهما, واللذان بدورهما ليس لديهما ذلك, الobject الذي قمنا بتمريره ك parameter يشير الى موقع مختلف في الذاكرة من الموقع الذي يشير اليه الobject الثاني و الذي تم استخدامه للتحق من شرط المساواة.
+لدينا هنا اثنان من ال objects والتي نقوم بعمل مقارنة بينهما, واللذان بدورهما ليس لديهما ذلك, الobject الذي قمنا بتمريره ك parameter يشير الى موقع مختلف في الذاكرة من الموقع الذي يشير اليه الobject  الثاني و الذي تم استخدامه للتحق من شرط المساواة.
 
-لهذا كلا من `{ age: 18 } === { age: 18 }` و `{ age: 18 } == { age: 18 }` يرجعان `false`.
+لهذا كلا من  `{ age: 18 } === { age: 18 }` و  `{ age: 18 } == { age: 18 }` يرجعان `false`.
 
 </p>
 </details>
@@ -647,15 +640,14 @@ getAge(21);
 <div dir='rtl'>
 الجواب هو الخيار الثالث: C
 
-العامل spread `...args` يقوم بإرجاع array مع arguments. الarray هي object, لذا فإن `typeof args` تقوم بإرجاع `"object"`.
-
+العامل spread `...args` يقوم بإرجاع array مع  arguments. الarray  هي object, لذا فإن `typeof args` تقوم بإرجاع  `"object"`.   
 </p>
 </details>
 </div>
 
 ---
 
-20. ماهو الناتج؟
+20. ماهو الناتج؟ 
 
 ```javascript
 function getAge() {
@@ -677,8 +669,7 @@ getAge();
 <div dir='rtl'>
 الجواب هو الخيار الثالث: C
 
-بإستخدام `"use strict"`, يمكنك التأكد بأنك لن تقوم عن طريق الخطأ بتعريف global variables. نحن لم نقم قط بتعريف المتغير `age`, و بما أننا قمنا بإستخدام `"use strict"` ستقوم بإرجاع reference error. اذا لم نقم بإستخدام `"use strict"` لكانت قد أدت المطلوب, بما أن الخاصية `age` تم إضافتها لل global object.
-
+بإستخدام `"use strict"`, يمكنك التأكد بأنك لن تقوم عن طريق الخطأ بتعريف global variables. نحن لم نقم قط بتعريف المتغير `age`, و بما أننا قمنا بإستخدام `"use strict"` ستقوم بإرجاع reference error. اذا لم نقم بإستخدام `"use strict"` لكانت قد أدت المطلوب, بما أن الخاصية `age` تم إضافتها لل global object.      
 </p>
 </details>
 </div>
@@ -687,7 +678,7 @@ getAge();
 
 <div dir='rtl'>
 21. ماهي القيمة التي تحملها `sum`؟ 
-</div>
+</div> 
 
 ```javascript
 const sum = eval("10*10+5");
@@ -703,8 +694,7 @@ const sum = eval("10*10+5");
 <div dir='rtl'>
 الجواب هو الخيار الأول : A
 
-`eval` تقوم بتقييم الكود الذي تم تمريره ك string. إذا كان عبارة عن expression كما في هذه الحالة, فإنها تقوم بتقييم ال expression. ال expression هو `10 * 10 + 5`. و هذا بدوره يقوم بإرجاع الرقم `105`.
-
+`eval` تقوم بتقييم الكود الذي تم تمريره ك string. إذا كان عبارة عن expression كما في هذه الحالة, فإنها تقوم بتقييم ال expression. ال expression هو `10 * 10 + 5`. و هذا بدوره يقوم بإرجاع الرقم `105`.   
 </p>
 </details>
 </div>
@@ -718,7 +708,6 @@ const sum = eval("10*10+5");
 ```javascript
 sessionStorage.setItem("cool_secret", 123);
 ```
-
 <div dir='rtl'>
   
 A - الى الأبد, فالبيانات لايمكن أن تفقد.
@@ -728,7 +717,6 @@ B - عندما يقوم المستخدم بقفل ال tab.
 C - عندما يقوم المستخدم بقفل نافذه المتصفح , ليس فقط الtab.
 
 D - عندما يقوم المستخدم بقفل جهاز الكمبيوتر.
-
 </div>
 
 <details><summary><b>الإجابة</b></summary>
@@ -736,17 +724,16 @@ D - عندما يقوم المستخدم بقفل جهاز الكمبيوتر.
 <div dir='rtl'>
 الجواب هو الخيار الثاني: B
   
-البيانات التي يتم تخزينها في `sessionStorage` يتم فقدها بعد قفل ال tab.
-
-إذا قمت بإستخدام `localStorage`, البيانات ستكون مخزنة هناك الى الأبد, و لكن اذا قمت بإستثناء ان تقوم بمناداة الدالة Clear كما في التالي `localStorage.clear()` عندها ستفقد هذه البيانات.:
+البيانات التي يتم تخزينها في `sessionStorage` يتم فقدها بعد قفل ال tab. 
 
+إذا قمت بإستخدام `localStorage`, البيانات ستكون مخزنة هناك الى الأبد, و لكن اذا قمت بإستثناء ان تقوم بمناداة الدالة Clear كما في التالي `localStorage.clear()` عندها ستفقد هذه البيانات.:  
 </p>
 </details>
 </div>
 
 ---
 
-23. ماهو الناتج؟
+23. ماهو الناتج؟ 
 
 ```javascript
 var num = 8;
@@ -765,10 +752,9 @@ console.log(num);
 <div dir='rtl'>
 الجواب هو الخيار الثاني: B
 
-مع الكلمة المفتاحية `var` بإمكانك تريف عدد من المتغيرات تحمل نفس الإسم, و المتغير سيقوم بأخذ آخر قيمة تمت إضافتها اليه.
-
-ليس بإمكانك أن تفعل هذا مع `let` أو `const` بما أن الكلمتان المفتاحيتان عبارة عن block-scoped, بمعنى أن القيمة ستكون متاحة في نطاق الBlock الذي تم تعريفها به.
+مع الكلمة المفتاحية `var` بإمكانك تريف عدد من المتغيرات تحمل نفس الإسم, و المتغير سيقوم بأخذ آخر قيمة تمت إضافتها اليه.  
 
+ليس بإمكانك أن تفعل هذا مع `let` أو `const` بما أن الكلمتان المفتاحيتان عبارة عن block-scoped, بمعنى أن القيمة ستكون متاحة في نطاق الBlock  الذي تم تعريفها به.   
 </p>
 </details>
 </div>
@@ -797,17 +783,16 @@ set.has(1);
 <div dir='rtl'>
 الجواب هو الخيار الثالث: C
 
-كل مفاتيح ال object (عدا الSymbols)هي عبارة عن strings وراء الكواليس, حتى لو لم تقم بكتابة ذلك صراحة بنفسك ك string, لهذا دائما `obj.hasOwnProperty('1')` تقوم بإرجاع القيمة true.
-
-ولكنها لا تعمل بهذا الشكل مع set, ليس هنالك `'1'` من ضمن set, لهذا `set.has('1')` تقوم بإرجاع `false`, لديها القيمة الرقمية `1` أي من النوع number, `set.has(1)` تقوم بإرجاع `true`.
+كل مفاتيح ال object (عدا الSymbols)هي عبارة عن strings وراء الكواليس, حتى لو لم تقم بكتابة ذلك صراحة بنفسك ك string, لهذا دائما `obj.hasOwnProperty('1')` تقوم بإرجاع القيمة true.  
 
+ولكنها لا تعمل بهذا الشكل مع set, ليس هنالك `'1'` من ضمن set, لهذا `set.has('1')` تقوم بإرجاع `false`, لديها القيمة الرقمية `1` أي من النوع number, `set.has(1)` تقوم بإرجاع `true`.     
 </p>
 </details>
 </div>
 
 ---
 
-25. ماهو الناتج؟
+25. ماهو الناتج؟ 
 
 ```javascript
 const obj = { a: "one", b: "two", a: "three" };
@@ -837,7 +822,7 @@ console.log(obj);
 
 - A: true
 - B: false
-- C: تعتمد على
+- C: تعتمد على 
 
 <details><summary><b>الإجابة</b></summary>
 <p>
@@ -845,10 +830,9 @@ console.log(obj);
 الجواب هو الخيارالأول: A
 
 سياق التنفيذ الأساسي هو سياق تنفيذ الglobal, وهي الشيء الذي يمكن الوصول إليه من أي مكان في الكود الذي ببرنامجك.
-
 </p>
 </details>
-</div>
+</div> 
 
 ---
 
@@ -871,8 +855,7 @@ for (let i = 1; i < 5; i++) {
 <div dir='rtl'>
 الجواب هو الخيار الثالث: C
 
-العبارة `continue` تقوم بتخطي دورة التكرار إذا وجد شرط معين يقوم بإرجاع `true`.
-
+العبارة `continue`  تقوم بتخطي دورة التكرار إذا وجد شرط معين يقوم بإرجاع `true`.  
 </p>
 </details>
 </div>
@@ -888,7 +871,7 @@ String.prototype.giveLydiaPizza = () => {
 
 const name = "Lydia";
 
-console.log(name.giveLydiaPizza());
+console.log(name.giveLydiaPizza())
 ```
 
 - A: `"Just give Lydia pizza already!"`
@@ -901,15 +884,14 @@ console.log(name.giveLydiaPizza());
 <div dir='rtl'>
 الجواب هو الخيار الأول : A
 
-`String` هي built-in constructor, و لهذا سنتمكن من إضافة خصائص لها. لقد قمت بإضافة method للprototype الخاص ب `String`. Primitive strings يتمتحويلهم بصورة اوتوماتيكية الى objects من نوع string, و التي بدورها تم انشائها عن طريق دالة ال string prototype, لهذا جميع الstrings و التي هي string objects لديها حق الوصول الى الmethod.
-
+`String` هي built-in constructor, و لهذا سنتمكن من إضافة خصائص لها. لقد قمت بإضافة method للprototype الخاص ب `String`. Primitive strings يتمتحويلهم بصورة اوتوماتيكية الى objects من نوع string, و التي بدورها تم انشائها عن طريق دالة ال string prototype, لهذا جميع الstrings و التي هي string objects  لديها حق الوصول الى الmethod.   
 </p>
 </details>
 </div>
 
 ---
 
-29. ماهو الناتج؟
+29. ماهو الناتج؟ 
 
 ```javascript
 const a = {};
@@ -932,13 +914,12 @@ console.log(a[b]);
 <div dir='rtl'>
 الجواب هو الخيار الثاني : B
 
-مفاتيح ال object يتم تحويلها اوتوماتيكيا الى strings. نحن نحاول أن نقوم بجعل object عبارة عن مفتاح للobject `a`, و الذي يحمل القيمة `123`.
+مفاتيح ال object يتم تحويلها اوتوماتيكيا الى strings. نحن نحاول أن نقوم بجعل  object عبارة عن مفتاح للobject `a`, و الذي يحمل القيمة `123`.  
 
 و لكن, عندما نقوم بمحاول جعل object الى نوع string, سيصبح `"[object Object]"`. لذا ما نحاول أن نقوله هنا, هو أن `a["object Object"] = 123`.
-إذا, سنحاول أن نفعل هذا مرة أخرى , `c` هو object آخر سنقوم بتحويله الى string بصورة صريحة, لذا `a["object Object"] = 456`.
-
-إذاَ, نحن نقوم بعمل log ل `a[b]`, و التي هي في الحقيقة `a["object Object"]`. و نحن قبل قليل قمنا بوضع قيمتها التي تساوي `456`, لذا ستقوم بإرجاع `456`.
+إذا, سنحاول أن نفعل هذا مرة أخرى , `c` هو object آخر سنقوم بتحويله الى string بصورة صريحة, لذا `a["object Object"] = 456`.  
 
+إذاَ, نحن نقوم بعمل log ل `a[b]`, و التي هي في الحقيقة `a["object Object"]`. و نحن قبل قليل قمنا بوضع قيمتها التي تساوي `456`, لذا ستقوم بإرجاع `456`.    
 </p>
 </details>
 </div>
@@ -969,17 +950,17 @@ baz();
 
 لدينا الدالة `setTimeout` والتي تم استدعائها أولا, و لكن تم الخروج منها آخراً.
 
-هذا لأن في المتصفح, ليس لدينا محرَك من نوع runtime, أيضا لدينا مايعرف ب `WebAPI`. هذا ال`WebAPI` يقوم بإعطائنا الدالة `setTimeout` لكي نبدأ بها, على سبيل المثال: DOM.
+هذا لأن في المتصفح, ليس لدينا محرَك من نوع runtime, أيضا لدينا مايعرف ب `WebAPI`. هذا ال`WebAPI` يقوم بإعطائنا الدالة `setTimeout`  لكي نبدأ بها, على سبيل المثال: DOM.
 
 بعد ان يتم ارسال و البدء بتنفيذ ال _callback_ الى الWebAPI, الدالة `setTimeout` نفسها (ليس ال callback!) يتم اخراجها من الstack.
 
 <img src="https://i.imgur.com/X5wsHOg.png" width="200">
 
-الآن, `foo` يتم إدخالها و البدء بتنفيذها, بينما `"First"` يتم تسجيل دخولها.
+الآن, `foo` يتم إدخالها و البدء بتنفيذها, بينما `"First"` يتم تسجيل دخولها.  
 
 <img src="https://i.imgur.com/Pvc0dGq.png" width="200">
 
-`foo` يتم إخراجها من ال stack, بينما `baz` يتم إدخالها و البدأ بتنفيذها. `"Third"` يتم تسجيل دخولها.
+`foo` يتم إخراجها من ال stack, بينما `baz` يتم إدخالها و البدأ بتنفيذها. `"Third"` يتم تسجيل دخولها. 
 
 <img src="https://i.imgur.com/WhA2bCP.png" width="200">
 
@@ -987,19 +968,17 @@ baz();
 
 <img src="https://i.imgur.com/NSnDZmU.png" width="200">
 
-هنا تحديدا المكان الذي تبدأ فيه الloop بالعمل.
+هنا تحديدا المكان الذي تبدأ فيه الloop بالعمل. 
 ال **event loop** تنظر الى الstack و ال task queue, إذا كانت الstack خاوية, فهي تقوم بأخذ أول شيء في الqueue. و تقوم بإدخاله الى stack.
 
 <img src="https://i.imgur.com/uyiScAI.png" width="200">
 
-`bar` يتم إدخالها و البدأ بتنفيذها, `"Second"` يتم تسجيل دخولها, و من ثم إخراجها من الstack.
-
+`bar` يتم إدخالها و البدأ بتنفيذها, `"Second"` يتم تسجيل دخولها, و من ثم إخراجها من الstack. 
 </p>
 </details>
 </div>
 
 ---
-
 <div dir='rtl'>
 31. ماهو ال event.target عندما نقوم بالضغط على الزر
 </div>
@@ -1007,12 +986,14 @@ baz();
 ```html
 <div onclick="console.log('first div')">
   <div onclick="console.log('second div')">
-    <button onclick="console.log('button')">Click!</button>
+    <button onclick="console.log('button')">
+      Click!
+    </button>
   </div>
 </div>
 ```
 
-- A: الخارجي `div`
+- A:  الخارجي `div`
 - B: الداخلي `div`
 - C: `button`
 - D: array تحتوي على جميع العناصرالمتداخلة.
@@ -1022,8 +1003,7 @@ baz();
 <div dir='rtl'>
 الجواب هو الخيار الثالث: C
 
-العنصر المتداخل الأعمق الذي تسبب بتنفيذ الevent هو العنصر الذي يستهدفه هذا الevent, بإمكانك إيقاف ال bubbling عن طريق `event.stopPropagation`.
-
+العنصر المتداخل الأعمق الذي تسبب بتنفيذ الevent  هو العنصر الذي يستهدفه هذا الevent, بإمكانك إيقاف ال bubbling عن طريق `event.stopPropagation`.
 </p>
 </details>
 </div>
@@ -1036,7 +1016,9 @@ baz();
 
 ```html
 <div onclick="console.log('div')">
-  <p onclick="console.log('p')">Click here!</p>
+  <p onclick="console.log('p')">
+    Click here!
+  </p>
 </div>
 ```
 
@@ -1050,8 +1032,7 @@ baz();
 <div dir='rtl'>
 الجواب هو الخيار الأول: A
 
-إذا قمنا بالضغط على `p` سنرى إثنان من الlogs, ألا و هما `p` و `div`, أثناء عملية event propagation, هنالك ثلاث مراحل: الا وهي capturing, target و bubbling. بصورة افتراضية, الevent handlers يتم تنفيذهم في مرحلة الbubbling (إلا في حال أنك قمت بضبط قيمة `useCapture` ل `true` ). هي تتسلسل ابتداءا من أعمق عنصر متداخل تصاعدا الى الأقل عمقاً.
-
+إذا قمنا بالضغط على `p` سنرى إثنان من الlogs, ألا و هما `p` و `div`, أثناء عملية event propagation, هنالك ثلاث مراحل: الا وهي capturing, target و bubbling. بصورة افتراضية, الevent handlers يتم تنفيذهم في مرحلة الbubbling (إلا في حال أنك قمت بضبط قيمة `useCapture` ل `true` ). هي تتسلسل ابتداءا من أعمق عنصر متداخل تصاعدا الى الأقل عمقاً. 
 </p>
 </details>
 </div>
@@ -1081,10 +1062,9 @@ sayHi.bind(person, 21);
 <div dir='rtl'>
 الجواب هو الخيار الرابع: D
 
-في الحالتين, بإمكاننا تمرير ال object الذي نود أن تشير اليه الكلمة المفتاحية `this`, ولكن, `.call` هي أيضا تم تنفيذها حالا.
+في الحالتين, بإمكاننا تمرير ال object الذي نود أن تشير اليه الكلمة المفتاحية `this`, ولكن, `.call` هي أيضا تم تنفيذها حالا.  
 
 `.bind.` تقوم بإرجاع نسخة من الدالة, ولكن مع سياق محدد, لذا هي لا يتم تنفيذها حالاً.
-
 </p>
 </details>
 </div>
@@ -1111,10 +1091,9 @@ console.log(typeof sayHi());
 <div dir='rtl'>
 الجواب هو الخيار الثاني: B
 
-دالة `sayHi` تقوم بإرجاع القيمة المرجعة من الدالة المناداة في اللحظة (IIFE). هذه الدالة تقوم بإرجاع `0`, و الذي نوعه عبارة عن `"number"`.
-
-لمعلوماتك: لدينا فقط سبعة أنواع من ال built-in و هي : `null`, `undefined`, `boolean`, `number`, `string`, `object`, و `symbol`, و `bigint`.`"function"` هي ليست نوع, وبما أن الدوال عبارة عن objects, ف هي ليست من النوع `"object"`.
+دالة `sayHi` تقوم بإرجاع القيمة المرجعة من الدالة المناداة في اللحظة (IIFE). هذه الدالة تقوم بإرجاع `0`, و الذي نوعه عبارة عن `"number"`.   
 
+لمعلوماتك: لدينا فقط سبعة أنواع من ال built-in و هي : `null`, `undefined`, `boolean`, `number`, `string`, `object`, و `symbol`, و `bigint`.`"function"` هي ليست نوع, وبما أن الدوال عبارة عن objects, ف هي ليست من النوع `"object"`.  
 </p>
 </details>
 </div>
@@ -1151,7 +1130,7 @@ undefined;
 - `''` (empty string)
 - `false`
 
-Function constructors, مثل `new Number` و `new Boolean` هي قيم صحيحية.
+Function constructors, مثل `new Number` و  `new Boolean` هي قيم صحيحية.
 
 </p>
 </details>
@@ -1207,7 +1186,6 @@ console.log(numbers);
 `[1, 2, 3, 7 x empty, 11]`
 
 وذلك يعتمد على المكان الذي قمت فيه بتشغيل البرنامج ( هو مختلف لكل متصفح, node, ...الخ)
-
 </p>
 </details>
 </div>
@@ -1242,10 +1220,9 @@ console.log(numbers);
 
 النطاق أو الblock `catch`يستقبل ال arguemnt الذي يساوي `x`, هذا ليس نفس القيمة `x` عندما قمنا بتمرير الarguments, هذا المتغير `x` هو متغير block-scoped, أي يتم التعامل معه أو مناداته فقط بداخل الblock الذي تم تعريفه به.
 
-لاحقا, قمنا بضبط القيمة `1` لهذا المتغير من نوع block-scoped, وقمنا أيضا بضبط قيمة للمتغير `y`. الآن نحن نقوم بطباعة قيمة المتغير الذي من نوع block-scoped و الذي هو `x` عن طريق الlog, و الذي هو يساوي `1`.
-
-بخارج نطاق ال`catch` block, `x` هي لاتزال `undefined`, و قيمة ال `y` تساوي `2`. عندما نريد طباعة قيمة ال x عن طريق الlog خارج نطاق ال `catch` block, فهي تقوم بإرجاع `undefined`, و ال `y` تقوم بإرجاع `2`.
+لاحقا, قمنا بضبط القيمة `1` لهذا المتغير من نوع block-scoped, وقمنا أيضا بضبط قيمة للمتغير `y`. الآن نحن نقوم بطباعة قيمة المتغير الذي من نوع block-scoped و الذي هو `x` عن طريق الlog, و الذي هو يساوي `1`.    
 
+بخارج نطاق ال`catch` block, `x` هي لاتزال `undefined`, و قيمة ال `y` تساوي `2`. عندما نريد طباعة قيمة ال x عن طريق الlog خارج نطاق ال `catch` block, فهي تقوم بإرجاع `undefined`, و ال `y` تقوم بإرجاع `2`.      
 </p>
 </details>
 </div>
@@ -1266,23 +1243,19 @@ console.log(numbers);
 
 لغة الجافاسكريبت لديها فقط primitive types و objects.
 
-نقصد بال Primitive types: `boolean`, `null`, `undefined`, `bigint`, `number`, `string`, و `symbol`.
-
-مايميز ال primitive من ال object هو أن ال primitives ليس لديها أي خصائص أو methods; ولكنك ستلاحظ أن `'foo'.toUpperCase()`يتم تقييمها ومعالجتها الى `'FOO'`و لا نتحصل على الخطأ `TypeError`. هذا لأنه عندما تحاول الوصول الى خاصية أو method لمتغير من من نوع primitive مثل ال string, فإن لغة الجافاسكريبت ستقوم بشكل ضمني بعمل wrap لل object بإستخدام واحدة من ال wrapper Classes, أي مانعنيه `String`, و لاحقا بصورة مباشرة يقوم بالتخلص من الwrapper, بعد أن يتم تقييم و تنفيذ الexpression. جميع الprimitives, ماعدا `null` و `undefined` تقوم بعمل هذه العملية.
+نقصد بال Primitive types:  `boolean`, `null`, `undefined`, `bigint`, `number`, `string`, و `symbol`.
 
+مايميز ال primitive من ال object هو أن ال primitives ليس لديها أي خصائص أو methods; ولكنك ستلاحظ أن `'foo'.toUpperCase()`يتم تقييمها ومعالجتها الى `'FOO'`و لا نتحصل على الخطأ `TypeError`. هذا لأنه عندما تحاول الوصول الى خاصية أو method لمتغير من من نوع primitive مثل ال string, فإن لغة الجافاسكريبت ستقوم بشكل ضمني بعمل wrap لل object بإستخدام واحدة من ال wrapper Classes, أي مانعنيه `String`, و لاحقا بصورة مباشرة يقوم بالتخلص من الwrapper, بعد أن يتم تقييم و تنفيذ الexpression.  جميع الprimitives, ماعدا `null` و `undefined` تقوم بعمل هذه العملية.    
 </p>
 </details>
 </div>
 
 ---
 
-40. ماهو الناتج؟
+40. ماهو الناتج؟ 
 
 ```javascript
-[
-  [0, 1],
-  [2, 3],
-].reduce(
+[[0, 1], [2, 3]].reduce(
   (acc, cur) => {
     return acc.concat(cur);
   },
@@ -1302,8 +1275,7 @@ console.log(numbers);
 
 `[1, 2]` هي القيمة المبدئية.هذه القيمة هي التي بدأنا بها, و هي القيمة الأولى ل `acc`. أثناء الدورة الأولى`acc` تساوي `[1,2]` و `cur` تساوي `[0, 1]`, عندما نقوم بدمجهما سويا عن طريق concat يصبح لدينا الناتج `[1, 2, 0, 1]`.
 
-إذاً, `[1, 2, 0, 1]` هي `acc` و `[2, 3]` هي `cur`. نقوم بدمجهما سوية و نتحصل على `[1, 2, 0, 1, 2, 3]`.
-
+إذاً, `[1, 2, 0, 1]`  هي `acc` و `[2, 3]` هي `cur`. نقوم بدمجهما سوية و نتحصل على `[1, 2, 0, 1, 2, 3]`.
 </p>
 </details>
 </div>
@@ -1330,29 +1302,27 @@ console.log(numbers);
 
 `null` قيمة خطئية.
 
-`!null` تقوم بإرجاع `true`.
+`!null` تقوم بإرجاع `true`. 
 
 `!true` تقوم بإرجاع `false`.
-
----
-
+*********
+ 
 `""` قيمة خطئية.
 
-`!""`تقوم بإرجاع `true`.
+`!""`تقوم بإرجاع `true`. 
 
 `!true` تقوم بإرجاع `false`.
-
----
-
+*********
+   
 `1` قيمة صحيحية.
 
 `!1` تقوم بإرجاع `false`.
 
-`!false` تقوم بإرجاع `true`.
+`!false` تقوم بإرجاع `true`. 
 
 </p>
 </details>
-</div>
+</div> 
 
 ---
 
@@ -1368,10 +1338,11 @@ setInterval(() => console.log("Hi"), 1000);
 <div dir='rtl'>
 
 A - رقم فريد أو متفرد id
+ 
+ 
+ B - قيمة محددة لل milliseconds
 
-B - قيمة محددة لل milliseconds
-
-C - الدالة التي تم تمريرها
+ C - الدالة التي تم تمريرها 
 
 `undefined` - D
 
@@ -1382,15 +1353,14 @@ C - الدالة التي تم تمريرها
 <div dir='rtl'>
 الجواب هو الخيار الأول: A
 
-تقوم بإرجاع ال id الفريد, هذا الid يمكن استخدامه لكي يقوم بتصفير عداد الفترات المفصلة أي الinterval عن طريق استخدام الدالة `clearInterval()`
-
+تقوم بإرجاع ال id الفريد, هذا الid يمكن استخدامه لكي يقوم بتصفير عداد الفترات المفصلة أي الinterval عن طريق استخدام الدالة `clearInterval()` 
 </p>
 </details>
 </div>
 
 ---
 
-43. مالذي يتم ارجاعه بعد تنفيذ الكود أدناه؟
+43. مالذي يتم ارجاعه بعد تنفيذ الكود أدناه؟ 
 
 ```javascript
 [..."Lydia"];
@@ -1407,7 +1377,6 @@ C - الدالة التي تم تمريرها
 الجواب هو الخيار الأول: A
 
 الstring هي تكرارية, و عملية الspread (...) تقوم بتحويل اي حرف تم فيه تنفيذ فئة تكرارية الى عنصر منفرد واحد.
-
 </p>
 </details>
 </div>
@@ -1438,12 +1407,11 @@ console.log(gen.next().value);
 <div dir='rtl'>
 الجواب هو الخيار الثالث: C
 
-الدوال العادية ليس بإمكانها ان تتوقف في وسط التنفيذ بعد أن يتم مناداتها, و لكن الدوال من نوع generator من الممكن أن يتم ايقافها وسط التنفيذ, و لاحقا يتم مواصلة تنفيذها من حيث المكان الذي توقفت به. في كل مرة تواجه فيها الدالة من نوع generator الكلمة المفتاحية `yield`, فإن الدالة تخضع أو تستسلم للقيمة المحددة بعدها. مع ملاحظة أن الدالة من نوع generator في هذه الحالة, لاتقوم بإرجاع القيمة, بل تخضع لتلك القيمة.
+الدوال العادية ليس بإمكانها ان تتوقف في وسط التنفيذ بعد أن يتم مناداتها, و لكن الدوال من نوع generator من الممكن أن يتم ايقافها وسط التنفيذ, و لاحقا يتم مواصلة تنفيذها من حيث المكان الذي توقفت به. في كل مرة تواجه فيها الدالة من نوع generator الكلمة المفتاحية `yield`, فإن الدالة تخضع أو تستسلم للقيمة المحددة بعدها. مع ملاحظة أن الدالة من نوع generator  في هذه الحالة, لاتقوم بإرجاع القيمة, بل تخضع لتلك القيمة. 
 
 أولا, نقوم بإنشاء الدالة من نوع generator مع وجود المتغير `i` مساوي ل `10`. نقوم بمناداة الدالةمن نوع generator باستخدام الدالة `next()`. في المرة الأولى التي ننادي فيها الدالة من نوع generator, فإن ال `i` تساوي `10`. هي تواجه الكلمة المفتاحية `yield`, فتخضع لقيمة ال `i`. الدالة generator في هذه اللحظة تم توقيفها مؤقتا, و القيمة `10` تم طباعتها عن طريق log.
 
-اذاً, نقوم بمناداة الدالة مرة أخرى عن طريق الدالة `next()`, هي تبدأ لتواصل من المكان الذي تم توقفيها فيه مؤقتا سابقاً, و ماتزال قيمة `i` تساوي `10`. الآن هي تواجه الكلمة المفتاحية `yield` التالية, و تواجه `i * 2`. `i` تساوي `10`,لهذا تقوم بإرجاع `10 * 2` و التي هي تساوي `20`, و هذا سيوصلنا للنتيجة `10, 20`.
-
+اذاً, نقوم بمناداة الدالة مرة أخرى عن طريق الدالة `next()`, هي تبدأ لتواصل من المكان الذي تم توقفيها فيه مؤقتا سابقاً, و ماتزال قيمة `i` تساوي `10`. الآن هي تواجه الكلمة المفتاحية `yield` التالية, و تواجه `i * 2`. `i` تساوي `10`,لهذا تقوم بإرجاع `10 * 2` و التي هي تساوي `20`, و هذا سيوصلنا للنتيجة `10, 20`.         
 </p>
 </details>
 </div>
@@ -1461,7 +1429,7 @@ const secondPromise = new Promise((res, rej) => {
   setTimeout(res, 100, "two");
 });
 
-Promise.race([firstPromise, secondPromise]).then((res) => console.log(res));
+Promise.race([firstPromise, secondPromise]).then(res => console.log(res));
 ```
 
 - A: `"one"`
@@ -1474,8 +1442,7 @@ Promise.race([firstPromise, secondPromise]).then((res) => console.log(res));
 <div dir='rtl'>
 الجواب هو الخيار الثاني: B
 
-عندما نقوم بتمرير عدد من الpromises للدالة `Promise.race`. فهي تقوم برفض أو فصل الpromise الاولى. للدالة `setTimeout` نحن نقوم بتمرير timer: 500ms لل promise الأولى و التي هي (`firstPromise`), و 100ms اي 100ملي ثانية للpromise الثانية والتي هي (`secondPromise`) هذا يعني ان ال `secondPromise` يتم فصلها اولاً مع القيمة `'two'`. `res` الآن تحمل قيمة `'two'`, وهي التي تم طباعتها عن طريق الlog.
-
+عندما نقوم بتمرير عدد من الpromises للدالة `Promise.race`. فهي تقوم برفض أو فصل الpromise  الاولى. للدالة `setTimeout` نحن نقوم بتمرير timer: 500ms لل promise الأولى و التي هي (`firstPromise`), و 100ms اي 100ملي ثانية للpromise الثانية والتي هي (`secondPromise`) هذا يعني ان ال `secondPromise` يتم فصلها اولاً مع القيمة `'two'`. `res` الآن تحمل قيمة `'two'`, وهي التي تم طباعتها عن طريق الlog.        
 </p>
 </details>
 </div>
@@ -1502,7 +1469,7 @@ console.log(members);
 <div dir='rtl'>
 الجواب هو الخيار الرابع: D
 
-أولا, نقوم بتعريف المتغير `person` مع قيمة عبارة عن object لديه الخاصية `name`.
+أولا, نقوم بتعريف المتغير `person` مع قيمة عبارة عن object لديه الخاصية `name`.  
 
 <img src="https://i.imgur.com/TML1MbS.png" width="200">
 
@@ -1511,12 +1478,11 @@ console.log(members);
 
 <img src="https://i.imgur.com/FSG5K3F.png" width="300">
 
-ثم , نقوم بضبط قمية المتغير `person` بقيمة تساوي `null`.
+ثم , نقوم بضبط قمية المتغير `person` بقيمة تساوي `null`.  
 
 <img src="https://i.imgur.com/sYjcsMT.png" width="300">
 
-نحن فقط نقوم بتعديل قيمة المتغير `person`, وليس أول عنصر في ال array, بما أن ذلك العنصر لديه refrence منسوخ من ال object. أول عنصر في `members` لا يزال لديه refrence للobject الأصلي. و عندما نقوم بطباع الarray `members` عن طريق الlog, فإن العنصر الأول لايزال يحمل قيمة الobject, و التي سيتم طباعتها عن طريق log.
-
+نحن فقط نقوم بتعديل قيمة المتغير `person`, وليس أول عنصر في ال array, بما أن ذلك العنصر لديه refrence منسوخ من ال object. أول عنصر في `members` لا يزال لديه refrence للobject الأصلي. و عندما نقوم بطباع الarray `members` عن طريق الlog, فإن العنصر الأول لايزال يحمل قيمة الobject, و التي سيتم طباعتها عن طريق log.  
 </p>
 </details>
 </div>
@@ -1528,7 +1494,7 @@ console.log(members);
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21,
+  age: 21
 };
 
 for (const item in person) {
@@ -1546,8 +1512,7 @@ for (const item in person) {
 <div dir='rtl'>
 الجواب هو الخيار الثاني: B
 
-بإستخدام `for-in` التكرارية, بامكاننا أن نصل الى جميع المفاتيح التي تخص object معين. في هذه الحالة `name` و `age`. ماوراء الكواليس, مفاتيح ال objects هي عبارة عن strings (إذا لم تكن هذه المفاتيح عبارة عن symbol), في أي حلقة من الحلقات التكرارية, نقوم بضبط القيمة `item`مساوية للمفتاح الحالي الذي هي تتكرر فيه اوعنده. أولا `item` تساوي `name`, و يتم طباعتها عن طريق الlog, ثم `item` تساوي `age` و التي ايضا تم طباعتها عن طريق الlog.
-
+بإستخدام `for-in` التكرارية, بامكاننا أن نصل الى جميع المفاتيح التي تخص object معين. في هذه الحالة `name` و `age`. ماوراء الكواليس, مفاتيح ال objects هي عبارة عن strings (إذا لم تكن هذه المفاتيح عبارة عن symbol), في أي حلقة من الحلقات التكرارية, نقوم بضبط القيمة `item`مساوية للمفتاح الحالي الذي هي تتكرر فيه اوعنده. أولا `item`  تساوي `name`, و يتم طباعتها عن طريق الlog, ثم `item` تساوي `age` و التي ايضا تم طباعتها عن طريق الlog.
 </p>
 </details>
 </div>
@@ -1570,12 +1535,11 @@ console.log(3 + 4 + "5");
 <div dir='rtl'>
 الجواب هو الخيار الثاني: B
 
-Operator associativity او ترابطية العامل هي الترتيب أو التسلسل الذي يقيم به الcompiler ال expressions, ف هو إما أن يكون من اليسار الى اليمين أو من اليمين الى اليسار. هذا يحدث فقط إذا كان جميع الoperators لديها نفس الأسبقية. لدينا فقط نوع واحد من الoperator ألا و هو `+`. بالإضافة الى التالي, الترابطية هي من اليسار الى اليمين.
+Operator associativity او ترابطية العامل هي الترتيب أو التسلسل الذي يقيم به الcompiler ال expressions, ف هو إما أن يكون من اليسار الى اليمين أو من اليمين الى اليسار. هذا يحدث فقط إذا كان جميع الoperators لديها نفس الأسبقية. لدينا فقط نوع واحد من الoperator ألا و هو `+`. بالإضافة الى التالي, الترابطية هي من اليسار الى اليمين.  
 
 `3 + 4` يتم تقييمها أولا. هذا مايعطينا الناتج الذي هو عبارة عن الرقم `7`.
 
-`7 + '5'` تقوم بإرجاع الناتج `"75"` بسبب عملية ال coercion وهي العمليةالتي تقوم بالتحويل من نوع الى آخر, لغة الجافاسكريبت تقوم بتحويل الرقم `7` الى النوع string, أنظرالى السؤال رقم 15 في الأعلى. بإمكاننا عمل concatenate لمتغيرين من النوع string بإستخدام العملية `+`. `"7" + "5"` سترجع الناتج `"75"`.
-
+`7 + '5'` تقوم بإرجاع الناتج `"75"` بسبب عملية ال coercion وهي العمليةالتي تقوم بالتحويل من نوع الى آخر, لغة الجافاسكريبت تقوم بتحويل الرقم `7` الى النوع string, أنظرالى السؤال رقم 15 في الأعلى. بإمكاننا عمل concatenate لمتغيرين من النوع string بإستخدام العملية `+`. `"7" + "5"` سترجع الناتج `"75"`.   
 </p>
 </details>
 </div>
@@ -1600,10 +1564,9 @@ const num = parseInt("7*6", 10);
 <div dir='rtl'>
 الجواب هو الخيار الثالث: C
 
-فقط الأرقام الأولى في الstring يتم إرجاعها. بناءاً على _radix_ (الargument الثاني لكي يتم تحديدنوعية الرقم الذي نود أن نقوم بعمل parse له الى: base 10, hexadecimal, octal, binary, الخ. ). تقوم `parseInt` بالتحقق عن إذا ماكانت الحروف في الstring صالحة. و بمجرد أن تجد حرف غير صالح في ال radix, ف هي تقوم بإيقاف عملية الparsing مباشرة و تتجاهل الحروف التي تليه.
-
-`*` ليست رقم صالح. هي فقط تقوم بعمل parse ل `"7"` الى عدد عشري `7`. `num` الآن تحمل القيمة `7`.
+فقط الأرقام الأولى في الstring يتم إرجاعها. بناءاً على _radix_ (الargument الثاني لكي يتم تحديدنوعية الرقم الذي نود أن نقوم بعمل parse له الى: base 10, hexadecimal, octal, binary, الخ. ). تقوم `parseInt` بالتحقق عن إذا ماكانت الحروف في الstring صالحة. و بمجرد أن تجد حرف غير صالح في ال radix, ف هي تقوم بإيقاف عملية الparsing مباشرة و تتجاهل الحروف التي تليه.   
 
+`*` ليست رقم صالح. هي فقط تقوم بعمل parse ل `"7"` الى عدد عشري `7`. `num` الآن تحمل القيمة `7`.   
 </p>
 </details>
 </div>
@@ -1613,7 +1576,7 @@ const num = parseInt("7*6", 10);
 50. ماهو الناتج؟
 
 ```javascript
-[1, 2, 3].map((num) => {
+[1, 2, 3].map(num => {
   if (typeof num === "number") return;
   return num * 2;
 });
@@ -1629,10 +1592,9 @@ const num = parseInt("7*6", 10);
 <div dir='rtl'>
 الجواب هو الخيار الثالث: C
 
-عندما يتم عمل mapping لل array, فإن قيمة `num` ستساوي قيمة العنصر الذي يتم حاليا المرور به, فكما نعرف أن الmapping يدور على جميع عناصر الarray. في هذه الحالة, العناصر عبارة عن أرقام, لهذا فإن شرط ال if statement `typeof num === "number"` يقوم بإرجاع `true`. دالة map تقوم بإنشاء array جديدة, و إدخال القيم المرجعة من الدالة في هذه الarray.
-
-ولكن, لا نقوم بإرجاع قيمة. عندما لا نقوم بإرجاع قيمة من الدالة, فإن الدالة تقوم بإرجاع `undefined`. لكل عنصرٍ في الarray, فإن نطاق الدالة او نعني الfunction block يتم مناداته, لهذا لأي عنصر نقوم بإرجاع `undefined`.
+عندما يتم عمل mapping لل array, فإن قيمة `num` ستساوي قيمة العنصر الذي يتم حاليا المرور به, فكما نعرف أن الmapping يدور على جميع عناصر الarray. في هذه الحالة, العناصر عبارة عن أرقام, لهذا فإن شرط ال if statement `typeof num === "number"` يقوم بإرجاع `true`. دالة map  تقوم بإنشاء array جديدة, و إدخال القيم المرجعة من الدالة في هذه الarray.
 
+ولكن, لا نقوم بإرجاع قيمة. عندما لا نقوم بإرجاع قيمة من الدالة, فإن الدالة تقوم بإرجاع `undefined`. لكل عنصرٍ في الarray, فإن نطاق الدالة او نعني الfunction block يتم مناداته, لهذا لأي عنصر نقوم بإرجاع `undefined`.  
 </p>
 </details>
 </div>
@@ -1669,8 +1631,7 @@ console.log(person, birthYear);
 
 المتغير `birthYear` لديه refrence للقيمة `"1997"`. الargument `year` أيضا لديه refrence للقيمة `"1997"`, لكنها ليست نفس القيمة التي `birthYear` لديها refrence لها. عندما نقوم بتحديث قيمة `year` عن طريق ضبط `year` تساوي ل `"1998"`, نحن فقط نقوم بتحديث قيمة `year`. `birthYear` لا تزال تساوي `"1997"`.
 
-قيمة `person` هي object. الargument `member` لديه نسخة refrence لنفس الobject. عندما نقوم بتعديل او تحديث خاصية للobject `member`و الذي لديه refrence لها, فإن قيمة `person` ستتعدل و تتغير أيضا,بما أن كلاهما لديهما refrence لنفس الobject. الخصائص `person` و `name` هما الأىن مساويان للقيمة `"Lydia"`.
-
+قيمة `person` هي object. الargument `member` لديه نسخة refrence لنفس الobject. عندما نقوم بتعديل او تحديث خاصية للobject `member`و الذي لديه refrence لها, فإن قيمة `person` ستتعدل و تتغير أيضا,بما أن كلاهما لديهما refrence لنفس الobject. الخصائص `person` و `name` هما الأىن مساويان للقيمة `"Lydia"`.      
 </p>
 </details>
 </div>
@@ -1706,17 +1667,16 @@ sayHi();
 <div dir='rtl'>
 الجواب هو الخيار الرابع: D
 
-مع عبارة `throw` , بإمكاننا إنشاء errors حسب الطلب, أي ليست كا الإخطاء العامة في اللغة, بإستخدام هذه العبارة بإمكانك أن تضع exception, الexception يمكن أن يكون : <b>string</b>, <b>number</b>, <b>boolean</b> أو <b>object</b>. في هذه الحالة, الexcption لدينا هو ال string `'Hello world'`.
-
-مع عبارة `catch`, بإمكاننا ان نحدد ما الذي يتوجب فعله عندما يتم وضع أو إلقاء الexception في نطاق ال `try`. تم إلقاء أو وضع exception: الstring `'Hello world'`. `e` الآن تساوي تلك الstring,log. هذا سيعطينا النتيجة `'Oh an error: Hello world'`.
+مع عبارة `throw` , بإمكاننا إنشاء errors حسب الطلب, أي ليست كا الإخطاء العامة في اللغة, بإستخدام هذه العبارة بإمكانك أن تضع exception, الexception يمكن أن يكون : <b>string</b>,  <b>number</b>, <b>boolean</b> أو <b>object</b>. في هذه الحالة, الexcption لدينا هو ال string `'Hello world'`.
 
+مع عبارة `catch`, بإمكاننا ان نحدد ما الذي يتوجب فعله عندما يتم وضع أو إلقاء الexception في نطاق ال `try`. تم إلقاء أو وضع exception: الstring `'Hello world'`.  `e` الآن تساوي تلك الstring,log. هذا سيعطينا النتيجة `'Oh an error: Hello world'`.  
 </p>
 </details>
 </div>
 
 ---
 
-53. ماهو الناتج؟
+53. ماهو الناتج؟ 
 
 ```javascript
 function Car() {
@@ -1738,8 +1698,7 @@ console.log(myCar.make);
 <div dir='rtl'>
 الجواب هو الخيار الثاني: B
 
-عندما تقوم بإرجاع خاصية, فإن قيمة هذه الخاصية هي تساوي القيمة المرجعة, ليس القيمة التي تم ضبطها في دالة الconstructor. نقوم بإرجاع ال string `"Maserati"`, لذا فإن `myCar.make` تساوي `"Maserati"`.
-
+عندما تقوم بإرجاع خاصية, فإن قيمة هذه الخاصية هي تساوي القيمة المرجعة, ليس القيمة التي تم ضبطها في دالة الconstructor. نقوم بإرجاع ال string `"Maserati"`, لذا فإن `myCar.make` تساوي `"Maserati"`.   
 </p>
 </details>
 </div>
@@ -1767,8 +1726,7 @@ console.log(typeof y);
 <div dir='rtl'>
 الجواب هو الخيار الأول : A
 
-`let x = y = 10;` هي في الحقيقة إختصار ل:
-
+`let x = y = 10;` هي في الحقيقة إختصار ل: 
 </div>
 
 ```javascript
@@ -1778,12 +1736,11 @@ let x = y;
 
 <div dir='rtl'>
   
-عندما نقوم بضبط قيمة`y` لكي تساوي `10`, فنحن فعليا نقوم بإضافة الخاصية `y` للglobal object. (`window` في المتصفح, `global` في Node). في المتصفح, `window.y` الآن تساوي `10`.
+عندما نقوم بضبط قيمة`y` لكي تساوي `10`, فنحن فعليا نقوم بإضافة الخاصية `y` للglobal object. (`window` في المتصفح, `global` في Node). في المتصفح, `window.y` الآن تساوي `10`. 
 
 ثم, عندما نقوم بتعريف المتغير `x` بالقيمة `y` و التي هي في الحقيقة تساوي `10`. المتغيرات التي يتم تعريفها بالكلمة المفتاحية `let`هي متغيرات block scoped, أي يتم التعامل معها في النطاق الذي تم تعريفها فيه فقط, الدالة المناداة حاليا في هذه الحالة أي immediately-invoked function (IIFE). عندما نقوم بإستخدام العملية `typeof`, فإن المعامل `x` ليس معرف, نحن نحاول الوصول الى `x` خارج النطاق الذي تم تعريفه بها. هذا يعني أن `x` ليست معرفة. المتغيرات التي لم يتم وضع قيمة لها أو لم يتم تعريفها هي من النوع `"undefined"`. `console.log(typeof x)` تقوم بإرجاع `"undefined"`.
 
-ولكن, نحن قمنا بإنشاء و تعريف global variable `y` عندما قمنا بضبط قيمة `y` لتساوي `10`. هذه القيمة يمكن الوصول إليها من أي مكان في البرنامج. `y` هي معرفة, و لديها قيمة من النوع `"number"`. `console.log(typeof y)` تقوم بإرجاع `"number"`.
-
+ولكن, نحن قمنا بإنشاء و تعريف global variable `y` عندما قمنا بضبط قيمة `y` لتساوي `10`. هذه القيمة يمكن الوصول إليها من أي مكان في البرنامج. `y` هي معرفة, و لديها قيمة من النوع `"number"`.  `console.log(typeof y)` تقوم بإرجاع `"number"`.   
 </p>
 </details>
 </div>
@@ -1799,7 +1756,7 @@ class Dog {
   }
 }
 
-Dog.prototype.bark = function () {
+Dog.prototype.bark = function() {
   console.log(`Woof I am ${this.name}`);
 };
 
@@ -1822,10 +1779,9 @@ pet.bark();
 <div dir='rtl'>
 الجواب هو الخيار الأول: A
   
-بإمكاننا مسح خصائص object معين عن طريق استخدام الكلمة المفتاحية `delete`, أيضا يمكن فعل هذا في ال prototype. بمسح خاصية معينة من الprototype,  فهي سيتم مسحها وبالتالي لن تكون موجودة في سلسلة الprototype. في هذه الحالة فإن الدالة `bark`  لن تكون موجودة بعد الآن في الprototype بعد `delete Dog.prototype.bark`, ولكن بالرغم من هذا فنحن نحاول الوصول إليها.
-
-عندما نحاول أن ننادي شيئا ما في دالة و هو ليس موجود في هذه الدالة, فإننا سنتحصل على الخطأ `TypeError`, و في هذه الحالة `TypeError: pet.bark is not a function` بما أن `pet.bark` هي `undefined`.
+بإمكاننا مسح خصائص object معين عن طريق استخدام الكلمة المفتاحية `delete`, أيضا يمكن فعل هذا في ال prototype. بمسح خاصية معينة من الprototype,  فهي سيتم مسحها وبالتالي لن تكون موجودة في سلسلة الprototype. في هذه الحالة فإن الدالة `bark`  لن تكون موجودة بعد الآن في الprototype بعد `delete Dog.prototype.bark`, ولكن بالرغم من هذا فنحن نحاول الوصول إليها.   
 
+عندما نحاول أن ننادي شيئا ما في دالة و هو ليس موجود في هذه الدالة, فإننا سنتحصل على الخطأ `TypeError`, و في هذه الحالة `TypeError: pet.bark is not a function` بما أن `pet.bark` هي `undefined`.   
 </p>
 </details>
 </div>
@@ -1850,10 +1806,9 @@ console.log(set);
 <div dir='rtl'>
 الجواب هو الخيار الرابع: D
 
-ال object `Set` هو مجموعة من القيم الفريدة, أي القيمة بإمكانها أن تتواجد مرة واحدة فقط في المجموعة.
-
-نقوم بتمرير التكراري أي نعني الiterable `[1, 1, 2, 3, 4]` بوجود قيمة مكررة ألا وهي `1` . بما أننا لا يمكن أن نضع قيمة واحدة مرتين في مجموعة, فإن واحدة من القيم المكررة سيتم إزالتها, و سيكون الناتج: `{1, 2, 3, 4}`.
+ال object `Set` هو مجموعة من القيم الفريدة, أي القيمة بإمكانها أن تتواجد مرة واحدة فقط في المجموعة. 
 
+نقوم بتمرير التكراري أي نعني الiterable `[1, 1, 2, 3, 4]`  بوجود قيمة مكررة ألا وهي `1` . بما أننا لا يمكن أن نضع قيمة واحدة مرتين في مجموعة, فإن واحدة من القيم المكررة سيتم إزالتها, و سيكون الناتج: `{1, 2, 3, 4}`. 
 </p>
 </details>
 </div>
@@ -1889,8 +1844,7 @@ console.log(myCounter);
 
 هنا يوجد لدينا module مستورد وهو قابل للقراءة فقط, ليس بإمكانك تعديل او تحديث الmodule المستورد, أي imported module. فقط الmodule الذي قام بتصديره هو القادر على تغيير قيمته.
 
-عندما نحاول أن نزيد قيمة المتغير `myCounter`, سنتحصل على الخطأ `myCounter` هو قابل للقراءة فقط و ليس من الممكن تعديله.
-
+عندما نحاول أن نزيد قيمة المتغير `myCounter`, سنتحصل على الخطأ `myCounter` هو قابل للقراءة فقط و ليس من الممكن تعديله.  
 </p>
 </details>
 </div>
@@ -1917,10 +1871,9 @@ console.log(delete age);
 <div dir='rtl'>
 الجواب هو الخيار الأول: A
   
-العامل `delete` تقوم بإرجاع قيمة boolen و هي `true` عندما تتم عملية المسح بنجاح, خلاف ذلك ستقوم بإرجاع `false`, ولكن المتغيرات المعرفة بالكلمات المفتاحية `var`, `const` أو `let` ليس بالإمكان مسحها بإستخدام العامل `delete`.
-
-المتغير `name` تم تعريفه باستخدام الكلمة المفتاحية `const`, لهذا فإن عملية مسحه لم تتم بنجاح, وتم إرجاع القيمة `false`, عندما نقوم بضبط المتغير `age` ليساوي القيمة `21` فإننا فعليا نقوم بإضافة خاصية تسمى `age` للglobal object. بإمكانك أن تمسح خصائص من الobjects بنجاح بإستخدام هذه الطريقة , أيضا الglobal objects, لذا فإن `delete age` تقوم بإرجاع `true`.
+العامل `delete` تقوم بإرجاع قيمة boolen و هي `true` عندما تتم عملية المسح بنجاح, خلاف ذلك ستقوم بإرجاع `false`, ولكن المتغيرات المعرفة بالكلمات المفتاحية `var`, `const` أو `let` ليس بالإمكان مسحها بإستخدام العامل `delete`.        
 
+المتغير `name` تم تعريفه باستخدام الكلمة المفتاحية `const`, لهذا فإن عملية مسحه لم تتم بنجاح, وتم إرجاع القيمة `false`, عندما نقوم بضبط المتغير `age` ليساوي القيمة `21` فإننا فعليا نقوم بإضافة خاصية تسمى `age` للglobal object. بإمكانك أن تمسح خصائص من الobjects بنجاح بإستخدام هذه الطريقة , أيضا الglobal objects, لذا فإن `delete age` تقوم بإرجاع `true`.         
 </p>
 </details>
 
@@ -1945,8 +1898,7 @@ console.log(y);
 <div dir='rtl'>
 الجواب هو الخيار الثالث: C
 
-بإمكاننا إستخراج أو استخلاص القيم من arrays أو من objects عن طريق إستخدام الdestructing, على سبيل المثال:
-
+بإمكاننا إستخراج أو استخلاص القيم من arrays أو من objects عن طريق إستخدام الdestructing, على سبيل المثال: 
 </div>
 
 ```javascript
@@ -1956,8 +1908,7 @@ console.log(y);
 <div dir='rtl'>
 <img src="https://i.imgur.com/ADFpVop.png" width="200">
 
-قيمة `a` الآن تساوي `1`, و قيمة `b` الآن تساوي `2`. ماقمنا بفعله حقاً في هذا السؤال هو:
-
+قيمة `a` الآن تساوي `1`, و قيمة `b` الآن تساوي `2`. ماقمنا بفعله حقاً في هذا السؤال هو:     
 </div>
 
 ```javascript
@@ -1967,8 +1918,7 @@ console.log(y);
 <div dir='rtl'>
 <img src="https://i.imgur.com/NzGkMNk.png" width="200">
 
-هذا يعني أن قيمة `y` هي مساوية للقيمة الأولى في الarray, والتي هي عبارة عن نوع رقم يساوي `1`, عندما نقوم بطباعة `y` عن طريق الlog, فإن القيمة `1` هي التي يتم إرجاعها.
-
+هذا يعني أن قيمة `y` هي مساوية للقيمة الأولى في الarray, والتي هي عبارة عن نوع رقم يساوي `1`, عندما نقوم بطباعة `y` عن طريق الlog, فإن القيمة `1` هي التي يتم إرجاعها.     
 </p>
 </details>
 </div>
@@ -1994,8 +1944,7 @@ console.log(admin);
 <div dir='rtl'>
 الجواب هو الخيار الثاني: B
 
-من الممكن دمج الobjects بإستخدام العامل spread `...`. هي تمكنك من إنشاء نسخ من أزواج ال key/value أي أزواج المفاتيح و القيم التي تنتمي الى object معين, و إضافتهم الى object آخر. في هذه الحالة, نحن نقوم بعمل نسخ من الobject `user`, و من ثم إضافتهم الى ال obejct `admin`. ال object `admin` الآن يتضمن نسخ عبارة عن أزواج مفاتيح و قيم, و هذا ما سبب في إعطاء النتيجة `{ admin: true, name: "Lydia", age: 21 }`.
-
+من الممكن دمج الobjects بإستخدام العامل spread `...`. هي تمكنك من إنشاء نسخ من أزواج ال key/value أي أزواج المفاتيح و القيم التي تنتمي الى object معين, و إضافتهم الى object آخر. في هذه الحالة, نحن نقوم بعمل نسخ من الobject `user`, و من ثم إضافتهم الى ال obejct `admin`. ال object `admin` الآن يتضمن نسخ عبارة عن أزواج مفاتيح و قيم, و هذا ما سبب في إعطاء النتيجة `{ admin: true, name: "Lydia", age: 21 }`.  
 </p>
 </details>
 </div>
@@ -2023,10 +1972,9 @@ console.log(Object.keys(person));
 <div dir='rtl'>
 الجواب هو الخيار الثاني: B
 
-مع إستخدام `defineProperty` method, بإمكاننا إضافة خصائص جديدة لobject معين,أو تعديل خصائصه الحالية,. عندما نقوم بإضافة خاصية لobject بإستخدام `defineProperty` method, ف هي بطبيعة الحال ليست enumerable. ال `Object.keys` method تقوم بإرجاع جميع أسامي الخصائص من object معين و التي هي جميعها enumerable, في هذه الحالة `"name"` فقط.
-
-الخصائص التي تم إضافتها بإستخدام `defineProperty` method هي بطبيعة الحال غير قابلة للتغيير أو التعديل. بإمكانك عمل override بإستخدام الخصائص `writable`, `configurable` و `enumerable`. بهذه الطريقة, ال `defineProperty` method ستعطيك تحكم أكثر بكثير على الخصائص التي قمت بإضافتها الى object معين.
+مع إستخدام  `defineProperty` method, بإمكاننا إضافة خصائص جديدة لobject معين,أو تعديل خصائصه الحالية,. عندما نقوم بإضافة خاصية لobject بإستخدام `defineProperty` method, ف هي بطبيعة الحال ليست enumerable. ال `Object.keys` method تقوم بإرجاع جميع أسامي الخصائص من object معين و التي هي جميعها enumerable, في هذه الحالة `"name"` فقط.       
 
+الخصائص التي تم إضافتها بإستخدام `defineProperty` method هي بطبيعة الحال غير قابلة للتغيير أو التعديل. بإمكانك عمل override بإستخدام الخصائص `writable`, `configurable` و `enumerable`.  بهذه الطريقة, ال `defineProperty` method ستعطيك تحكم أكثر بكثير على الخصائص التي قمت بإضافتها الى object معين.  
 </p>
 </details>
 </div>
@@ -2039,7 +1987,7 @@ console.log(Object.keys(person));
 const settings = {
   username: "lydiahallie",
   level: 19,
-  health: 90,
+  health: 90
 };
 
 const data = JSON.stringify(settings, ["level", "health"]);
@@ -2056,12 +2004,11 @@ console.log(data);
 <div dir='rtl'>
 الجواب هو الخيار الأول : A
 
-ال argument الثاني من `JSON.stringify` هو replacer أي حالٍ محل شيء آخر, الreplacer إما أن يكون دالة أو يكون array, و سيمكنك من التحكم في كيفية و ماهية امكانية عمل stringified للقيم, أي تحويلها الى string.
+ال argument الثاني من `JSON.stringify` هو replacer أي حالٍ محل شيء آخر, الreplacer إما أن يكون دالة أو يكون array, و سيمكنك من التحكم في كيفية و ماهية امكانية عمل stringified للقيم, أي تحويلها الى string.   
 
-إذا كان الreplacer هو عبارة عن array, فإن الخصائص التي أساميها مضمنة في الarray هي فقط التي يمكن إضافتها الى ال JSON string. في هذه الحالة, الخصائص التي تحمل الأسامي `"level"` و `"health"` فقط هي المضمنة, `"username"` غير مضمنة. `data` الآن تساوي `"{"level":19, "health":90}"`.
-
-إذا كان الreplacer عبارة عن دالة, فإن هذه الدالة يتم مناداتها عند أي خاصية في الobject أنت تقوم بعمل stringifying لها.القيمة المرجعة من هذه الدالة ستكون قيمة الخاصية عندما تم إضافتها ل JSON string. إذا كانت القيمة `undefined`, فإن هذه الخاصية سيتم إستبعادها من الJSON string.
+إذا كان الreplacer هو عبارة عن array, فإن الخصائص التي أساميها مضمنة في الarray هي فقط التي يمكن إضافتها الى ال JSON string. في هذه الحالة, الخصائص التي تحمل الأسامي `"level"` و `"health"` فقط هي المضمنة, `"username"` غير مضمنة. `data` الآن تساوي `"{"level":19, "health":90}"`.   
 
+إذا كان الreplacer عبارة عن دالة, فإن هذه الدالة يتم مناداتها عند أي خاصية في الobject أنت تقوم بعمل stringifying لها.القيمة المرجعة من هذه الدالة ستكون قيمة الخاصية عندما تم إضافتها ل JSON string. إذا كانت القيمة `undefined`, فإن هذه الخاصية سيتم إستبعادها من الJSON string.  
 </p>
 </details>
 </div>
@@ -2074,7 +2021,7 @@ console.log(data);
 let num = 10;
 
 const increaseNumber = () => num++;
-const increasePassedNumber = (number) => number++;
+const increasePassedNumber = number => number++;
 
 const num1 = increaseNumber();
 const num2 = increasePassedNumber(num1);
@@ -2093,10 +2040,9 @@ console.log(num2);
 <div dir='rtl'>
 الجواب هو الخيار الأول : A
 
-العامل الأحادي `++` يقوم أولا بإرجاع قيمة المعامل, ثم يقوم بزيادة قيمة هذا المعامل. قيمة `num1` تساوي `10`, و بما أن دالة `increaseNumber` أولا تقوم بإرجاع قيمة `num` و التي هي تساوي `10`, و تقوم بزيادة قيمة `num` لاحقاً فقط.
-
-`num2` تساوي`10`, وبما أننا نقوم بتمرير `num1` ل `increasePassedNumber`. فإن `number` تساوي `10` والتي هي قيمة`num1`. مجدداً, العامل الأحادي `++`, أولاً يقوم بإرجاع قيمة المعامل, و من ثم زيادة قيمة المعامل. قيمة `number` تساوي`10`, إذاً `num2` تساوي `10`.
+العامل الأحادي `++` يقوم أولا بإرجاع قيمة المعامل, ثم يقوم بزيادة قيمة هذا المعامل. قيمة `num1` تساوي `10`, و بما أن دالة `increaseNumber` أولا تقوم بإرجاع قيمة `num` و التي هي تساوي `10`, و تقوم بزيادة قيمة `num` لاحقاً فقط.       
 
+`num2` تساوي`10`, وبما أننا نقوم بتمرير `num1` ل `increasePassedNumber`. فإن `number` تساوي `10` والتي هي قيمة`num1`. مجدداً, العامل الأحادي `++`, أولاً يقوم بإرجاع قيمة المعامل, و من ثم زيادة قيمة المعامل. قيمة `number` تساوي`10`, إذاً `num2` تساوي `10`.         
 </p>
 </details>
 </div>
diff --git a/bs-BS/README-bs_BS.md b/bs-BS/README-bs_BS.md
index 2ff41568..65ee11f7 100644
--- a/bs-BS/README-bs_BS.md
+++ b/bs-BS/README-bs_BS.md
@@ -1,9 +1,8 @@
 # Popis (naprednih) JavaScript pitanja
-
 =======================================
 
 Svakodnevno postavljam JavaScript pitanja s višestrukim izborom na moj
-[Instagram](https://www.instagram.com/theavocoder), koja također objavljujem
+[Instagram](https://www.instagram.com/theavocoder), koja  također objavljujem
 ovdje!
 
 Od osnovnog do naprednog: testirajte koliko dobro znate JavaScript, osvježite svoj
@@ -26,7 +25,6 @@ kliknite na njih da biste ih proširili. Sretno :heart:
 - [🇳🇱 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)
@@ -36,7 +34,7 @@ kliknite na njih da biste ih proširili. Sretno :heart:
 - [🇨🇳 简体中文](../zh-CN/README-zh_CN.md)
 - [🇹🇼 繁體中文](../zh-TW/README_zh-TW.md)
 
----
+* * * * *
 
 ###### 1. Što je izlaz?
 
@@ -77,7 +75,7 @@ JavaScript izbacuje `ReferenceError`.
 </p>
 </details>
 
----
+* * * * *
 
 ###### 2. Što je izlaz?
 
@@ -101,7 +99,7 @@ for (let i = 0; i < 3; i++) {
 #### Odgovor: C
 
 Zbog reda događaja u JavaScriptu, povratni poziv `setTimeout`
-function se zove \* nakon što je izvršena petlja. Od
+function se zove * nakon što je izvršena petlja. Od
 varijabla `i` u prvoj petlji je deklarirana pomoću ključne riječi` var`,
 ta je vrijednost bila globalna. Tijekom petlje povećavamo vrijednost `i`
 svaki put '1', koristeći unarni operator `++`. Do vremena
@@ -116,7 +114,7 @@ block-scoped (blok je sve između `{}`). Tijekom svake iteracije,
 </p>
 </details>
 
----
+* * * * *
 
 ###### 3. Što je izlaz?
 
@@ -126,7 +124,7 @@ const shape = {
   diameter() {
     return this.radius * 2;
   },
-  perimeter: () => 2 * Math.PI * this.radius,
+  perimeter: () => 2 * Math.PI * this.radius
 };
 
 shape.diameter();
@@ -156,7 +154,7 @@ Na tom objektu nema vrijednosti `radius` koja vraća` undefined`.
 </p>
 </details>
 
----
+* * * * *
 
 ###### 4. Što je izlaz?
 
@@ -183,18 +181,18 @@ Niz '' Lydia '' je istinita vrijednost. Ono što zapravo tražimo jest
 </p>
 </details>
 
----
+* * * * *
 
 ###### 5. Koja je istina?
 
 ```javascript
 const bird = {
-  size: "small",
+  size: "small"
 };
 
 const mouse = {
   name: "Mickey",
-  small: true,
+  small: true
 };
 ```
 
@@ -209,7 +207,7 @@ const mouse = {
 #### Odgovor: A
 
 U JavaScriptu su svi key-evi objekta stringovi (osim ako to nije simbol). Čak
-iako ih možda ne _ upisujemo kao _ nizove, oni se uvijek pretvaraju
+iako ih možda ne * upisujemo kao * nizove, oni se uvijek pretvaraju
 u String ispod "haube".
 
 JavaScript tumači (ili odlaže) izjave. Kada koristimo zagradu
@@ -230,7 +228,8 @@ To nije valjano, a bit će u pitanju pogreška slična onoj
 </p>
 </details>
 
----
+* * * * *
+
 
 ###### 6. Što je izlaz?
 
@@ -254,7 +253,7 @@ console.log(d.greeting);
 
 #### Odgovor: A
 
-U JavaScriptu, svi objekti međusobno djeluju _referencom_ kada ih postavljaju
+U JavaScriptu, svi objekti međusobno djeluju *referencom* kada ih postavljaju
 jednaki.
 
 Prvo, varijabla `c` sadrži vrijednost objekta. Kasnije dodijelimo `d`
@@ -267,7 +266,7 @@ Kada promijenite jedan objekt, mijenjate ih sve.
 </p>
 </details>
 
----
+* * * * *
 
 ###### 7. Što je izlaz?
 
@@ -281,10 +280,10 @@ console.log(a === b);
 console.log(b === c);
 ```
 
-- A: ` true`` false ` `true`
-- B: ` false`` false ` `true`
-- C: ` true`` false ` `false`
-- D: ` false`` true ` `true`
+- A: `true`` false` `true`
+- B: `false`` false` `true`
+- C: `true`` false` `false`
+- D: `false`` true` `true`
 
 <details> <summary> <b> Odgovor </b> </summary>
 </p>
@@ -296,16 +295,16 @@ kao broj, to zapravo nije broj: ima gomilu ekstra dodataka
 pa je zbog toga objekt.
 
 Kada koristimo `==` operator, on samo provjerava ima li isti
-_vrijednost_. Obje imaju vrijednost `3`, pa se vraća 'true'.
+*vrijednost*. Obje imaju vrijednost `3`, pa se vraća 'true'.
 
-Međutim, kada koristimo `===` operator, obje vrijednosti _ i _ trebaju biti
+Međutim, kada koristimo `===` operator, obje vrijednosti * i * trebaju biti
 iste. To nije: `new Number ()` nije broj, to je ** objekt **.
 Oba vraćaju "false"
 
 </p>
 </details>
 
----
+* * * * *
 
 ###### 8. Što je izlaz?
 
@@ -336,7 +335,7 @@ freddie.colorChange("orange");
 #### Odgovor: D
 
 function `colorChange` je statična. Namijenjene su statičkim metodama
-žive samo na konstruktoru u kojem su stvoreni i ne mogu biti proslijeđeni
+žive samo na konstruktoru u kojem su stvoreni i ne mogu biti proslijeđeni 
 bilo kojem childu. Budući da je `freddie` child, function je
 nije proslijeđena, i nije dostupan na `freddie` instanci: a
 Izbačen je `TypeError`.
@@ -344,7 +343,7 @@ Izbačen je `TypeError`.
 </p>
 </details>
 
----
+* * * * *
 
 ###### 9. Što je izlaz?
 
@@ -352,6 +351,7 @@ Izbačen je `TypeError`.
 let greeting;
 greetign = {}; // Typo!
 console.log(greetign);
+
 ```
 
 - A: `{}`
@@ -374,7 +374,7 @@ da ste deklarirali varijablu prije nego je postavite na bilo što.
 </p>
 </details>
 
----
+* * * * *
 
 ###### 10. Što se događa kada učinimo ovo?
 
@@ -406,7 +406,7 @@ Ova nekretnina je nepovratna.
 </p>
 </details>
 
----
+* * * * *
 
 ###### 11. Kakav je rezultat?
 
@@ -417,7 +417,7 @@ function Person(firstName, lastName) {
 }
 
 const member = new Person("Lydia", "Hallie");
-Person.getFullName = function () {
+Person.getFullName = function() {
   return `${this.firstName} ${this.lastName}`;
 };
 
@@ -427,7 +427,7 @@ console.log(member.getFullName());
 - A: `TypeError`
 - B: `SyntaxError`
 - C: "Lydia Hallie"
-- D: ` undefined`` undefined `
+- D: `undefined`` undefined`
 
 <details> <summary> <b> Odgovor </b> </summary>
 </p>
@@ -454,7 +454,7 @@ scopa za svaku instancu. Umjesto toga, ako ga samo dodamo prototipu, mi
 </p>
 </details>
 
----
+* * * * *
 
 ###### 12. Što je izlaz?
 
@@ -473,10 +473,10 @@ console.log(sarah);
 
 - A: `Person {ime:" Lydia ", prezime:" Hallie "} i` undefined`
 - B: `Person {ime:" Lydia ", prezime:" Hallie "} i
-  `Person {ime:" Sarah ", prezime:" Smith "}`
+    `Person {ime:" Sarah ", prezime:" Smith "}`
 - C: `Person {ime:" Lydia ", prezime:" Hallie "}` i `{}`
 - D: `Person {ime:" Lydia ", prezime:" Hallie "} i
-  `ReferenceError`
+    `ReferenceError`
 
 <details> <summary> <b> Odgovor </b> </summary>
 </p>
@@ -495,7 +495,7 @@ sam je ostavljen 'undefined'.
 </p>
 </details>
 
----
+* * * * *
 
 ###### 13. Koje su tri faze propagiranja događaja?
 
@@ -504,6 +504,7 @@ sam je ostavljen 'undefined'.
 - C: Target > Bubbling > Capturing
 - D: Capturing > Target > Bubbling
 
+
 <details> <summary> <b> Odgovor </b> </summary>
 </p>
 
@@ -518,11 +519,11 @@ i ** bubbling **.
 </p>
 </details>
 
----
+* * * * *
 
 ###### 14. Svi objekti imaju prototipove.
 
-- Istinito
+-   Istinito
 - B: lažno
 
 <details> <summary> <b> Odgovor </b> </summary>
@@ -540,7 +541,7 @@ nalazi ga tamo, što ga čini dostupnim.
 </p>
 </details>
 
----
+* * * * *
 
 ###### 15. Što je izlaz?
 
@@ -564,20 +565,20 @@ sum(1, "2");
 
 JavaScript je ** dinamički upisani jezik **: ne navodimo što
 vrste su određene varijable. Vrijednosti se mogu automatski pretvoriti u
-drugi tip bez vašeg znanja, koji se zove _ implicitni tip
-prisila _. ** Prisila ** pretvara iz jednog tipa u drugi.
+drugi tip bez vašeg znanja, koji se zove * implicitni tip
+prisila *. ** Prisila ** pretvara iz jednog tipa u drugi.
 
 U ovom primjeru JavaScript pretvara broj `1` u niz, u
 kako bi function imala smisla i vratila vrijednost. Tijekom
 dodavanje numeričkog tipa (`1`) i tipa niza (` '2'`), broja
 se tretira kao niz. Možemo slično spojiti
-"" Zdravo "+" Svijet "` , tako da se ovdje događa ``````````````````
-vraća  `" 12 "`.
+"" Zdravo "+" Svijet "`, tako da se ovdje događa ``````````````````
+vraća `" 12 "`.
 
 </p>
 </details>
 
----
+* * * * *
 
 ###### 16. Što je izlaz?
 
@@ -588,10 +589,10 @@ console.log(++number);
 console.log(number);
 ```
 
-- A: ` 1`` 1 ` `2`
-- B: ` 1`` 2 ` `2`
-- C: ` 0`` 2 ` `2`
-- D: ` 0`` 1 ` `2`
+- A: `1`` 1` `2`
+- B: `1`` 2` `2`
+- C: `0`` 2` `2`
+- D: `0`` 1` `2`
 
 <details> <summary> <b> Odgovor </b> </summary>
 </p>
@@ -613,7 +614,7 @@ Ovo vraća `0 2 2`.
 </p>
 </details>
 
----
+* * * * *
 
 ###### 17. Što je izlaz?
 
@@ -646,7 +647,7 @@ vrijednosti prošlih izraza!
 </p>
 </details>
 
----
+* * * * *
 
 ###### 18. Što je izlaz?
 
@@ -673,8 +674,8 @@ checkAge({ age: 18 });
 
 #### Odgovor: C
 
-Prilikom ispitivanja jednakosti, primitivi se uspoređuju prema njihovoj _ vrijednosti _, dok
-objekti se uspoređuju prema njihovoj _ referenci _. JavaScript provjerava ako
+Prilikom ispitivanja jednakosti, primitivi se uspoređuju prema njihovoj * vrijednosti *, dok
+objekti se uspoređuju prema njihovoj * referenci *. JavaScript provjerava ako
 objekti imaju referencu na isto mjesto u memoriji.
 
 Dva predmeta koje uspoređujemo nemaju: objekt mi
@@ -687,11 +688,12 @@ Zato i `{age: 18} === {age: 18}` i
 </p>
 </details>
 
----
+* * * * *
 
 ###### 19. Što je izlaz?
 
 ```javascript
+
 function getAge(...args) {
   console.log(typeof args);
 }
@@ -715,7 +717,7 @@ array je objekt, pa `typeof args` vraća` `objekt '`
 </p>
 </details>
 
----
+* * * * *
 
 ###### 20. Što je izlaz?
 
@@ -739,16 +741,16 @@ getAge();
 
 #### Odgovor: C
 
-Sa `use strict '', možete se uvjeriti da nije slučajno
+Sa `` use strict '', možete se uvjeriti da nije slučajno
 deklarisana globalna varijabla. Nikada nismo objavili varijablu "age" i
-budući da koristimo` use strict '', ona će načiniti referentnu pogrešku. Ako mi
+budući da koristimo `` use strict '', ona će načiniti referentnu pogrešku. Ako mi
 nije koristio "" strict ", to bi išlo od vlasništva
 `age` bi se dodao u globalni objekt.
 
 </p>
 </details>
 
----
+* * * * *
 
 ###### 21. Što je vrijednost `suma '?
 
@@ -773,16 +775,15 @@ kao u ovom slučaju, on ocjenjuje izraz. Izraz je
 </p>
 </details>
 
----
+* * * * *
 
-###### 22. Koliko dugo je cool \ \_secret dostupan?
+###### 22. Koliko dugo je cool \ _secret dostupan?
 
 ```javascript
 sessionStorage.setItem("cool_secret", 123);
 ```
 
 O: Podaci se zauvijek ne gube.
-
 - B: Kada korisnik zatvori karticu.
 - C: Kada korisnik zatvori cijeli preglednik, ne samo karticu.
 - D: Kada korisnik isključi svoje računalo.
@@ -792,7 +793,7 @@ O: Podaci se zauvijek ne gube.
 
 #### Odgovor: B
 
-Podaci spremljeni u `sessionStorage` se uklanjaju nakon zatvaranja _ tab _.
+Podaci spremljeni u `sessionStorage` se uklanjaju nakon zatvaranja * tab *.
 
 Ako ste koristili `localStorage`, podaci bi bili tamo zauvijek, osim ako
 na primjer, `localStorage.clear ()` je pozvan.
@@ -800,7 +801,7 @@ na primjer, `localStorage.clear ()` je pozvan.
 </p>
 </details>
 
----
+* * * * *
 
 ###### 23. Što je izlaz?
 
@@ -829,7 +830,7 @@ To ne možete učiniti s `let` ili` const` jer su blokirani.
 </p>
 </details>
 
----
+* * * * *
 
 ###### 24. Što je izlaz?
 
@@ -843,10 +844,10 @@ 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 `
+- A: `false`` true` `false`` true`
+- B: `false`` true` `true`` true`
+- C: `true`` true` `false`` true`
+- D: `true`` true` `true`` true`
 
 <details> <summary> <b> Odgovor </b> </summary>
 </p>
@@ -864,7 +865,7 @@ To ne radi tako za skup. U našem setu ne postoji "1":
 </p>
 </details>
 
----
+* * * * *
 
 ###### 25. Što je izlaz?
 
@@ -889,11 +890,11 @@ i dalje će biti na prvom mjestu, ali s posljednjom navedenom vrijednošću.
 </p>
 </details>
 
----
+* * * * *
 
 ###### 26. Globalni kontekst izvođenja JavaScripta za vas stvara dvije stvari: globalni objekt i "ovu" ključnu riječ.
 
-- Istina
+-   Istina
 - B: lažno
 - C: to ovisi
 
@@ -908,7 +909,7 @@ dostupno svugdje u vašem kodu.
 </p>
 </details>
 
----
+* * * * *
 
 ###### 27. Što je izlaz?
 
@@ -917,12 +918,13 @@ 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`
+- A: `1`` 2`
+- B: `1`` 2` `3`
+- C: `1`` 2` `4`
+- D: `1`` 3` `4`
 
 <details> <summary> <b> Odgovor </b> </summary>
 </p>
@@ -935,7 +937,7 @@ vraća "true".
 </p>
 </details>
 
----
+* * * * *
 
 ###### 28. Što je izlaz?
 
@@ -946,10 +948,10 @@ String.prototype.giveLydiaPizza = () => {
 
 const name = "Lydia";
 
-console.log(name.giveLydiaPizza());
+console.log(name.giveLydiaPizza())
 ```
 
-- A: `Već daj Lizijinu pizzu!`
+- A: `` Već daj Lizijinu pizzu! ``
 - B: `TypeError: nije function`
 - C: `SyntaxError`
 - D: `undefined`
@@ -968,7 +970,7 @@ način!
 </p>
 </details>
 
----
+* * * * *
 
 ###### 29. Što je izlaz?
 
@@ -1007,7 +1009,7 @@ da na `456`, tako da se vraća` 456`.
 </p>
 </details>
 
----
+* * * * *
 
 ###### 30. Što je izlaz?
 
@@ -1021,10 +1023,10 @@ foo();
 baz();
 ```
 
-- A: ` Prvi`` Drugi ` `Treći`
-- B: ` Prvi`` Treći ` `Drugi`
-- C: ` Drugi`` Prvi ` `Treći`
-- D: ` Drugi`` Treći ` `Prvi`
+- A: `Prvi`` Drugi` `Treći`
+- B: `Prvi`` Treći` `Drugi`
+- C: `Drugi`` Prvi` `Treći`
+- D: `Drugi`` Treći` `Prvi`
 
 <details> <summary> <b> Odgovor </b> </summary>
 </p>
@@ -1038,7 +1040,7 @@ To je zato što u preglednicima nemamo samo runtime engine, mi
 također imaju nešto što se zove "WebAPI". "WebAPI" nam daje
 `setTimeout` function za početak, i na primjer DOM.
 
-Nakon što je _ callback _ preusmjeren na WebAPI, function `setTimeout`
+Nakon što je * callback * preusmjeren na WebAPI, function `setTimeout`
 sam (ali ne i povratni poziv!) iskače iz stog.
 
 <img src = "https://i.imgur.com/X5wsHOg.png" width = "200">
@@ -1054,11 +1056,11 @@ prijavljeni.
 
 WebAPI ne može jednostavno dodati stvari u stog kad god je spreman.
 Umjesto toga, on povlači funkciju povratnog poziva u nešto što se zove
-_red_.
+*red*.
 
 <img src = "https://i.imgur.com/NSnDZmU.png" width = "200">
 
-Ovo je mjesto gdje petlja događaja počinje raditi. \*\* ** krug događaja ** gleda
+Ovo je mjesto gdje petlja događaja počinje raditi. ** ** krug događaja ** gleda
 red i red za zadatke. Ako je stog prazan, uzima prvi
 stvar u redu i gura je u stog.
 
@@ -1070,7 +1072,7 @@ stog.
 </p>
 </details>
 
----
+* * * * *
 
 ###### 31. Što je event.target kada kliknete na gumb?
 
@@ -1102,7 +1104,7 @@ događaj. Možete zaustaviti mjehuriće 'event.stopPropagation'
 </p>
 </details>
 
----
+* * * * *
 
 ###### 32. Kada kliknete na paragraf, što je zapisani izlaz?
 
@@ -1114,8 +1116,8 @@ događaj. Možete zaustaviti mjehuriće 'event.stopPropagation'
 </div>
 ```
 
-- A: ` p`` div `
-- B: ` div`` p `
+- A: `p`` div`
+- B: `div`` p`
 - C: p
 - D: "div"
 
@@ -1133,7 +1135,7 @@ van.
 </p>
 </details>
 
----
+* * * * *
 
 ###### 33. Što je izlaz?
 
@@ -1148,10 +1150,10 @@ sayHi.call(person, 21);
 sayHi.bind(person, 21);
 ```
 
-- A: ` undefined is 21`` Lydia je 21 `
+- A: `undefined is 21`` Lydia je 21`
 - B: function funkcije
-- C: ` Lydia je 21`` Lydia je 21 `
-- D: ` Lydia je 21`` function `
+- C: `Lydia je 21`` Lydia je 21`
+- D: `Lydia je 21`` function`
 
 <details> <summary> <b> Odgovor </b> </summary>
 </p>
@@ -1159,15 +1161,15 @@ sayHi.bind(person, 21);
 #### Odgovor: D
 
 S oba, možemo proslijediti objekt kojem želimo ključnu riječ "this"
-odnosi se na. Međutim, `.call` se također _ izvršava odmah _!
+odnosi se na. Međutim, `.call` se također * izvršava odmah *!
 
-`.bind.` vraća _ copy _ funkcije, ali s vezanim kontekstom! To
+`.bind.` vraća * copy * funkcije, ali s vezanim kontekstom! To
 se ne izvršava odmah.
 
 </p>
 </details>
 
----
+* * * * *
 
 ###### 34. Što je izlaz?
 
@@ -1194,13 +1196,13 @@ pozvana function (IIFE). Ova function vratila je `0`, što je tip
 ` "Broj"`.
 
 FYI: postoji samo 7 ugrađenih tipova: `null`,` undefined`, `boolean`,
-"broj", "niz", "objekt" i "simbol". `function '' nije tip,
-budući da su funkcije objekti, to je tipa` objekta '`.
+"broj", "niz", "objekt" i "simbol". `` function '' nije tip,
+budući da su funkcije objekti, to je tipa `` objekta '`.
 
 </p>
 </details>
 
----
+* * * * *
 
 ###### 35. Koja od ovih vrijednosti su neistinite?
 
@@ -1214,8 +1216,8 @@ undefined;
 ```
 
 - A: `0`,` ```,` undefined`
-- B: `0`,`new Number (0)`,`''`,`new Boolean (false)`,` undefined '
-- C: `0`,`''`,`new Boolean (false)`,` undefined`
+- B: `0`,` new Number (0) `,` '' `,` new Boolean (false) `,` undefined '
+- C: `0`,` '' `,` new Boolean (false) `,` undefined`
 - D: Svi su oni lažni
 
 <details> <summary> <b> Odgovor </b> </summary>
@@ -1237,12 +1239,13 @@ Konstruktori function, kao što su 'new Number' i 'new Boolean' su istiniti.
 </p>
 </details>
 
----
+* * * * *
 
 ###### 36. Što je izlaz?
 
 ```javascript
 console.log(typeof typeof 1);
+
 ```
 
 - A: `" broj "
@@ -1260,7 +1263,7 @@ console.log(typeof typeof 1);
 </p>
 </details>
 
----
+* * * * *
 
 ###### 37. Što je izlaz?
 
@@ -1292,7 +1295,7 @@ itd)
 </p>
 </details>
 
----
+* * * * *
 
 ###### 38. Što je izlaz?
 
@@ -1310,10 +1313,10 @@ itd)
 })();
 ```
 
-- A: ` 1`` undefined `` 2 `
-- B: ` undefined`` undefined ` `undefined`
-- C: ` 1`` 1 ` `2`
-- D: ` 1`` undefined ` `undefined`
+- A: `1`` undefined `` 2`
+- B: `undefined`` undefined` `undefined`
+- C: `1`` 1` `2`
+- D: `1`` undefined` `undefined`
 
 <details> <summary> <b> Odgovor </b> </summary>
 </p>
@@ -1328,13 +1331,13 @@ varijable `y '. Sada, zapisujemo blok-scoped varijablu `x`, koja je
 jednako "1".
 
 Izvan 'catch' bloka, `x 'je i dalje` undefined`, a `y` je` 2`.
-Kada želimo `console.log (x)`izvan`catch`bloka, to
-vraća`undefined` i` y`vraća`2`.
+Kada želimo `console.log (x)` izvan `catch` bloka, to
+vraća `undefined` i` y` vraća `2`.
 
 </p>
 </details>
 
----
+* * * * *
 
 ###### 39. Sve u JavaScriptu je ili ...
 
@@ -1355,7 +1358,8 @@ Primitivni tipovi su "boolean", "null", "undefined", "bigint", "number",
 
 Ono što razlikuje primitiv od objekta je to što primitivci to ne čine
 imaju bilo kakva svojstva ili metode; međutim, to ćete primijetiti
-`'foo'.toUpperCase ()` vrednuje za' 'FOO'`i ne rezultira a`TypeError`. To je zato što kada pokušate pristupiti svojstvu ili metodi
+`'foo'.toUpperCase ()` vrednuje za' 'FOO'` i ne rezultira a
+`TypeError`. To je zato što kada pokušate pristupiti svojstvu ili metodi
 na primitivnom poput stringa, JavaScript će implicitet omotati objekt
 koristeći jednu od klasa omotača, tj. `String ', a zatim odmah
 odbacite omotač nakon što se izraz procijeni. Svi primitivci
@@ -1364,15 +1368,12 @@ osim "null" i "undefined" pokazuju ovo ponašanje.
 </p>
 </details>
 
----
+* * * * *
 
 ###### 40. Što je izlaz?
 
 ```javascript
-[
-  [0, 1],
-  [2, 3],
-].reduce(
+[[0, 1], [2, 3]].reduce(
   (acc, cur) => {
     return acc.concat(cur);
   },
@@ -1392,7 +1393,7 @@ osim "null" i "undefined" pokazuju ovo ponašanje.
 
 "[1, 2]" je naša početna vrijednost. To je vrijednost s kojom počinjemo i
 vrijednost prvog `acc`. Tijekom prvog kruga, "acc" je "[1,2]",
-i `cur` je`[0, 1]`. Spojimo ih, što rezultira
+i `cur` je` [0, 1] `. Spojimo ih, što rezultira
 `[1, 2, 0, 1]`.
 
 Tada je `[1, 2, 0, 1]` `acc` i` [2, 3] `````. Ulančavamo se
@@ -1401,7 +1402,7 @@ i dobiti `[1, 2, 0, 1, 2, 3]`
 </p>
 </details>
 
----
+* * * * *
 
 ###### 41. Što je izlaz?
 
@@ -1411,10 +1412,10 @@ i dobiti `[1, 2, 0, 1, 2, 3]`
 !!1;
 ```
 
-- A: ` false`` true ` `false`
-- B: ` false`` false ` `true`
-- C: ` false`` true ` `true`
-- D: ` true`` true ` `false`
+- A: `false`` true` `false`
+- B: `false`` false` `true`
+- C: `false`` true` `true`
+- D: `true`` true` `false`
 
 <details> <summary> <b> Odgovor </b> </summary>
 </p>
@@ -1430,7 +1431,7 @@ i dobiti `[1, 2, 0, 1, 2, 3]`
 </p>
 </details>
 
----
+* * * * *
 
 ###### 42. Što se vraća metoda `setInterval`?
 
@@ -1454,7 +1455,7 @@ Vraća jedinstveni ID. Taj se ID može koristiti za brisanje tog intervala
 </p>
 </details>
 
----
+* * * * *
 
 ###### 43. Što se to vraća?
 
diff --git a/de-DE/README.md b/de-DE/README.md
index a9dbd381..10145050 100644
--- a/de-DE/README.md
+++ b/de-DE/README.md
@@ -10,11 +10,10 @@ Von einfach bis fortgeschritten: teste, wie gut du JavaScript kennst, frische de
 
 Kontaktiert mich, wenn ihr möchtet! 😊 <br />
 <a href="https://www.instagram.com/theavocoder">Instagram</a> || <a href="https://www.twitter.com/lydiahallie">Twitter</a> || <a href="https://www.linkedin.com/in/lydia-hallie">LinkedIn</a> || <a href="https://www.lydiahallie.dev">Blog</a>
-
 </div>
 
-| Benutzt die Fragen und Lösungen in einem Projekt! 😃 Ich würde mich _sehr_ freuen, wenn ihr dieses Repo verlinkt. Ich erstelle die Fragen und antworten (ja, ich bin traurig, lol) und die Community hilft mir unglaublich dabei, das ganze zu pflegen und verbessern! 💪🏼 Danke und habt Spaß! |
-| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Benutzt die Fragen und Lösungen in einem Projekt! 😃  Ich würde mich _sehr_ freuen, wenn ihr dieses Repo verlinkt. Ich erstelle die Fragen und antworten (ja, ich bin traurig, lol) und die Community hilft mir unglaublich dabei, das ganze zu pflegen und verbessern! 💪🏼 Danke und habt Spaß!   |
+|---|
 
 </div>
 
@@ -36,7 +35,6 @@ Kontaktiert mich, wenn ihr möchtet! 😊 <br />
 - [🇳🇱 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)
@@ -55,19 +53,19 @@ Kontaktiert mich, wenn ihr möchtet! 😊 <br />
 
 ```javascript
 function sayHi() {
-  console.log(name);
-  console.log(age);
-  var name = "Lydia";
-  let age = 21;
+	console.log(name);
+	console.log(age);
+	var name = "Lydia";
+	let age = 21;
 }
 
 sayHi();
 ```
 
-- A: `Lydia` und `undefined`
-- B: `Lydia` und `ReferenceError`
-- C: `ReferenceError` und `21`
-- D: `undefined` und `ReferenceError`
+-   A: `Lydia` und `undefined`
+-   B: `Lydia` und `ReferenceError`
+-   C: `ReferenceError` und `21`
+-   D: `undefined` und `ReferenceError`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -87,17 +85,17 @@ Variablen mit dem `let` (oder `const`) Keyword werden ebenfalls gehoisted, aber
 
 ```javascript
 for (var i = 0; i < 3; i++) {
-  setTimeout(() => console.log(i), 1);
+	setTimeout(() => console.log(i), 1);
 }
 
 for (let i = 0; i < 3; i++) {
-  setTimeout(() => console.log(i), 1);
+	setTimeout(() => console.log(i), 1);
 }
 ```
 
-- A: `0 1 2` und `0 1 2`
-- B: `0 1 2` und `3 3 3`
-- C: `3 3 3` und `0 1 2`
+-   A: `0 1 2` und `0 1 2`
+-   B: `0 1 2` und `3 3 3`
+-   C: `3 3 3` und `0 1 2`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -117,21 +115,21 @@ In der zweiten Schleife wurde die Variable `i` mit dem `let` Keyword definiert:
 
 ```javascript
 const shape = {
-  radius: 10,
-  diameter() {
-    return this.radius * 2;
-  },
-  perimeter: () => 2 * Math.PI * this.radius,
+	radius: 10,
+	diameter() {
+		return this.radius * 2;
+	},
+	perimeter: () => 2 * Math.PI * this.radius,
 };
 
 shape.diameter();
 shape.perimeter();
 ```
 
-- A: `20` und `62.83185307179586`
-- B: `20` und `NaN`
-- C: `20` und `63`
-- D: `NaN` und `63`
+-   A: `20` und `62.83185307179586`
+-   B: `20` und `NaN`
+-   C: `20` und `63`
+-   D: `NaN` und `63`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -156,9 +154,9 @@ Es gibt keinen Wert `radius` in dem Object, daher wird `undefined` zurückgegebe
 !"Lydia";
 ```
 
-- A: `1` und `false`
-- B: `false` und `NaN`
-- C: `false` und `false`
+-   A: `1` und `false`
+-   B: `false` und `NaN`
+-   C: `false` und `false`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -178,19 +176,19 @@ Der String `'Lydia'` ist truthy. Was wir eigentlich fragen ist: "ist dieser trut
 
 ```javascript
 const bird = {
-  size: "small",
+	size: "small",
 };
 
 const mouse = {
-  name: "Mickey",
-  small: true,
+	name: "Mickey",
+	small: true,
 };
 ```
 
-- A: `mouse.bird.size` ist nicht korrekt
-- B: `mouse[bird.size]` ist nicht korrekt
-- C: `mouse[bird["size"]]` ist nicht korrekt
-- D: Keine der Antworten ist korrekt.
+-   A: `mouse.bird.size` ist nicht korrekt
+-   B: `mouse[bird.size]` ist nicht korrekt
+-   C: `mouse[bird["size"]]` ist nicht korrekt
+-   D: Keine der Antworten ist korrekt.
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -221,11 +219,11 @@ c.greeting = "Hello";
 console.log(d.greeting);
 ```
 
-- A: `Hello`
-- B: `Hey`
-- C: `undefined`
-- D: `ReferenceError`
-- E: `TypeError`
+-   A: `Hello`
+-   B: `Hey`
+-   C: `undefined`
+-   D: `ReferenceError`
+-   E: `TypeError`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -257,10 +255,10 @@ console.log(a === b);
 console.log(b === c);
 ```
 
-- A: `true` `false` `true`
-- B: `false` `false` `true`
-- C: `true` `false` `false`
-- D: `false` `true` `true`
+-   A: `true` `false` `true`
+-   B: `false` `false` `true`
+-   C: `true` `false` `false`
+-   D: `false` `true` `true`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -282,24 +280,24 @@ Wenn wir aber `===` nutzen müssen sowohl der Wert _als auch_ der Typ übereinst
 
 ```javascript
 class Chameleon {
-  static colorChange(newColor) {
-    this.newColor = newColor;
-    return this.newColor;
-  }
-
-  constructor({ newColor = "green" } = {}) {
-    this.newColor = newColor;
-  }
+	static colorChange(newColor) {
+		this.newColor = newColor;
+		return this.newColor;
+	}
+
+	constructor({ newColor = "green" } = {}) {
+		this.newColor = newColor;
+	}
 }
 
 const freddie = new Chameleon({ newColor: "purple" });
 freddie.colorChange("orange");
 ```
 
-- A: `orange`
-- B: `purple`
-- C: `green`
-- D: `TypeError`
+-   A: `orange`
+-   B: `purple`
+-   C: `green`
+-   D: `TypeError`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -321,9 +319,9 @@ greetign = {}; // Typo!
 console.log(greetign);
 ```
 
-- A: `{}`
-- B: `ReferenceError: greetign is not defined`
-- C: `undefined`
+-   A: `{}`
+-   B: `ReferenceError: greetign is not defined`
+-   C: `undefined`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -343,16 +341,16 @@ Um das zu verhindern, können wir `"use strict"` verwenden. Das stellt sicher, d
 
 ```javascript
 function bark() {
-  console.log("Woof!");
+	console.log("Woof!");
 }
 
 bark.animal = "dog";
 ```
 
-- A: Nichts, das ist absolut in Ordnung.
-- B: `SyntaxError`. Man kann einer Funktion keine Properties in der Form zuweisen.
-- C: `undefined`
-- D: `ReferenceError`
+-   A: Nichts, das ist absolut in Ordnung.
+-   B: `SyntaxError`. Man kann einer Funktion keine Properties in der Form zuweisen.
+-   C: `undefined`
+-   D: `ReferenceError`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -372,22 +370,22 @@ Eine Funktion ist ein spezieller Typ eines Objekts. Der Code, den wir schreiben
 
 ```javascript
 function Person(firstName, lastName) {
-  this.firstName = firstName;
-  this.lastName = lastName;
+	this.firstName = firstName;
+	this.lastName = lastName;
 }
 
 const member = new Person("Lydia", "Hallie");
-Person.getFullName = function () {
-  return `${this.firstName} ${this.lastName}`;
+Person.getFullName = function() {
+	return `${this.firstName} ${this.lastName}`;
 };
 
 console.log(member.getFullName());
 ```
 
-- A: `TypeError`
-- B: `SyntaxError`
-- C: `Lydia Hallie`
-- D: `undefined` `undefined`
+-   A: `TypeError`
+-   B: `SyntaxError`
+-   C: `Lydia Hallie`
+-   D: `undefined` `undefined`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -397,8 +395,8 @@ console.log(member.getFullName());
 Man kann keine Properties einem Constructor zuweisen, wie es bei normalen Objects der Fall ist. Wenn man ein Feature allen Objects zugleich zuweisen möchte, muss man den Prototype verwenden. In diesem Fall also:
 
 ```js
-Person.prototype.getFullName = function () {
-  return `${this.firstName} ${this.lastName}`;
+Person.prototype.getFullName = function() {
+	return `${this.firstName} ${this.lastName}`;
 };
 ```
 
@@ -414,8 +412,8 @@ Stattdessen haben wir sie nur dem Prototype zugewiesen, sodass sie nur an einer
 
 ```javascript
 function Person(firstName, lastName) {
-  this.firstName = firstName;
-  this.lastName = lastName;
+	this.firstName = firstName;
+	this.lastName = lastName;
 }
 
 const lydia = new Person("Lydia", "Hallie");
@@ -425,10 +423,10 @@ console.log(lydia);
 console.log(sarah);
 ```
 
-- A: `Person {firstName: "Lydia", lastName: "Hallie"}` und `undefined`
-- B: `Person {firstName: "Lydia", lastName: "Hallie"}` und `Person {firstName: "Sarah", lastName: "Smith"}`
-- C: `Person {firstName: "Lydia", lastName: "Hallie"}` und `{}`
-- D:`Person {firstName: "Lydia", lastName: "Hallie"}` und `ReferenceError`
+-   A: `Person {firstName: "Lydia", lastName: "Hallie"}` und `undefined`
+-   B: `Person {firstName: "Lydia", lastName: "Hallie"}` und `Person {firstName: "Sarah", lastName: "Smith"}`
+-   C: `Person {firstName: "Lydia", lastName: "Hallie"}` und `{}`
+-   D:`Person {firstName: "Lydia", lastName: "Hallie"}` und `ReferenceError`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -446,10 +444,10 @@ Wir haben `this.firstName` den Wert `"Sarah"` zugewiesen und `this.lastName` den
 
 ###### 13. Was sind die drei Phasen der Event Propagation?
 
-- A: Target > Capturing > Bubbling
-- B: Bubbling > Target > Capturing
-- C: Target > Bubbling > Capturing
-- D: Capturing > Target > Bubbling
+-   A: Target > Capturing > Bubbling
+-   B: Bubbling > Target > Capturing
+-   C: Target > Bubbling > Capturing
+-   D: Capturing > Target > Bubbling
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -467,8 +465,8 @@ Während der **capturing** Phase geht das Event durch die Elternelemente bis hin
 
 ###### 14. Alle Objekte haben Prototypes.
 
-- A: wahr
-- B: falsch
+-   A: wahr
+-   B: falsch
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -486,16 +484,16 @@ Alle Objekte haben Prototypes, außer dem **Basis Objekt**. Das Basis Objekt hat
 
 ```javascript
 function sum(a, b) {
-  return a + b;
+	return a + b;
 }
 
 sum(1, "2");
 ```
 
-- A: `NaN`
-- B: `TypeError`
-- C: `"12"`
-- D: `3`
+-   A: `NaN`
+-   B: `TypeError`
+-   C: `"12"`
+-   D: `3`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -520,10 +518,10 @@ console.log(++number);
 console.log(number);
 ```
 
-- A: `1` `1` `2`
-- B: `1` `2` `2`
-- C: `0` `2` `2`
-- D: `0` `1` `2`
+-   A: `1` `1` `2`
+-   B: `1` `2` `2`
+-   C: `0` `2` `2`
+-   D: `0` `1` `2`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -551,9 +549,9 @@ Der Output ist daher `0 2 2`.
 
 ```javascript
 function getPersonInfo(one, two, three) {
-  console.log(one);
-  console.log(two);
-  console.log(three);
+	console.log(one);
+	console.log(two);
+	console.log(three);
 }
 
 const person = "Lydia";
@@ -562,9 +560,9 @@ 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`
+-   A: `"Lydia"` `21` `["", " is ", " years old"]`
+-   B: `["", " is ", " years old"]` `"Lydia"` `21`
+-   C: `"Lydia"` `["", " is ", " years old"]` `21`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -582,21 +580,21 @@ Wenn man Template Literals verwendet ist das erste Argument immer ein Array der
 
 ```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`);
-  }
+	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`
+-   A: `You are an adult!`
+-   B: `You are still an adult.`
+-   C: `Hmm.. You don't have an age I guess`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -618,16 +616,16 @@ Deshalb werfen sowohl `{ age: 18 } === { age: 18 }` als auch `{ age: 18 } == { a
 
 ```javascript
 function getAge(...args) {
-  console.log(typeof args);
+	console.log(typeof args);
 }
 
 getAge(21);
 ```
 
-- A: `"number"`
-- B: `"array"`
-- C: `"object"`
-- D: `"NaN"`
+-   A: `"number"`
+-   B: `"array"`
+-   C: `"object"`
+-   D: `"NaN"`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -645,18 +643,18 @@ Der Spread Operator (`...args`) gibt ein Array mit Argumenten zurück. Ein Array
 
 ```javascript
 function getAge() {
-  "use strict";
-  age = 21;
-  console.log(age);
+	"use strict";
+	age = 21;
+	console.log(age);
 }
 
 getAge();
 ```
 
-- A: `21`
-- B: `undefined`
-- C: `ReferenceError`
-- D: `TypeError`
+-   A: `21`
+-   B: `undefined`
+-   C: `ReferenceError`
+-   D: `TypeError`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -676,10 +674,10 @@ Durch `"use strict"` kann man sicher stellen, dass man nicht versehentlich globa
 const sum = eval("10*10+5");
 ```
 
-- A: `105`
-- B: `"105"`
-- C: `TypeError`
-- D: `"10*10+5"`
+-   A: `105`
+-   B: `"105"`
+-   C: `TypeError`
+-   D: `"10*10+5"`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -699,10 +697,10 @@ const sum = eval("10*10+5");
 sessionStorage.setItem("cool_secret", 123);
 ```
 
-- A: Für immer, der Wert geht nicht verloren.
-- B: Wenn der User den Tab schließt.
-- C: Wenn der User den Browser schließt, nicht nur den Tab.
-- D: Wenn der User den Computer neu startet.
+-   A: Für immer, der Wert geht nicht verloren.
+-   B: Wenn der User den Tab schließt.
+-   C: Wenn der User den Browser schließt, nicht nur den Tab.
+-   D: Wenn der User den Computer neu startet.
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -727,10 +725,10 @@ var num = 10;
 console.log(num);
 ```
 
-- A: `8`
-- B: `10`
-- C: `SyntaxError`
-- D: `ReferenceError`
+-   A: `8`
+-   B: `10`
+-   C: `SyntaxError`
+-   D: `ReferenceError`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -758,10 +756,10 @@ 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`
+-   A: `false` `true` `false` `true`
+-   B: `false` `true` `true` `true`
+-   C: `true` `true` `false` `true`
+-   D: `true` `true` `true` `true`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -784,10 +782,10 @@ 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`
+-   A: `{ a: "one", b: "two" }`
+-   B: `{ b: "two", a: "three" }`
+-   C: `{ a: "three", b: "two" }`
+-   D: `SyntaxError`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -803,9 +801,9 @@ Wenn man zwei Keys mit dem selben Namen hat, wird der erste Key ersetzt. Er wird
 
 ###### 26. Der JavaScript Global Execution Context erstellt zwei Dinge: das globale Objekt und das "this" Keyword.
 
-- A: wahr
-- B: falsch
-- C: kommt darauf an
+-   A: wahr
+-   B: falsch
+-   C: kommt darauf an
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -823,15 +821,15 @@ Der Base Execution Context entspricht dem Global Execution Context und ist über
 
 ```javascript
 for (let i = 1; i < 5; i++) {
-  if (i === 3) continue;
-  console.log(i);
+	if (i === 3) continue;
+	console.log(i);
 }
 ```
 
-- A: `1` `2`
-- B: `1` `2` `3`
-- C: `1` `2` `4`
-- D: `1` `3` `4`
+-   A: `1` `2`
+-   B: `1` `2` `3`
+-   C: `1` `2` `4`
+-   D: `1` `3` `4`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -849,18 +847,18 @@ 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";
 
-console.log(name.giveLydiaPizza());
+console.log(name.giveLydiaPizza())
 ```
 
-- A: `"Just give Lydia pizza already!"`
-- B: `TypeError: not a function`
-- C: `SyntaxError`
-- D: `undefined`
+-   A: `"Just give Lydia pizza already!"`
+-   B: `TypeError: not a function`
+-   C: `SyntaxError`
+-   D: `undefined`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -887,10 +885,10 @@ a[c] = 456;
 console.log(a[b]);
 ```
 
-- A: `123`
-- B: `456`
-- C: `undefined`
-- D: `ReferenceError`
+-   A: `123`
+-   B: `456`
+-   C: `undefined`
+-   D: `ReferenceError`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -920,10 +918,10 @@ foo();
 baz();
 ```
 
-- A: `First` `Second` `Third`
-- B: `First` `Third` `Second`
-- C: `Second` `First` `Third`
-- D: `Second` `Third` `First`
+-   A: `First` `Second` `Third`
+-   B: `First` `Third` `Second`
+-   C: `Second` `First` `Third`
+-   D: `Second` `Third` `First`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -965,16 +963,18 @@ Das ist, wo die Event Loop ins Spiel kommt. Die **Event Loop** betrachtet den St
 
 ```html
 <div onclick="console.log('first div')">
-  <div onclick="console.log('second div')">
-    <button onclick="console.log('button')">Click!</button>
-  </div>
+	<div onclick="console.log('second div')">
+		<button onclick="console.log('button')">
+			Click!
+		</button>
+	</div>
 </div>
 ```
 
-- A: Äußerer `div`
-- B: Innerer `div`
-- C: `button`
-- D: Ein Array mit allen genesteten Elementen
+-   A: Äußerer `div`
+-   B: Innerer `div`
+-   C: `button`
+-   D: Ein Array mit allen genesteten Elementen
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -992,14 +992,16 @@ Das am tiefsten genestete Element, welches das Event auslöst ist das Event Targ
 
 ```html
 <div onclick="console.log('div')">
-  <p onclick="console.log('p')">Click here!</p>
+	<p onclick="console.log('p')">
+		Click here!
+	</p>
 </div>
 ```
 
-- A: `p` `div`
-- B: `div` `p`
-- C: `p`
-- D: `div`
+-   A: `p` `div`
+-   B: `div` `p`
+-   C: `p`
+-   D: `div`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -1019,17 +1021,17 @@ Wenn wir auf den Paragraph klicken, sehen wir zwei logs: `p` und `div`. Während
 const person = { name: "Lydia" };
 
 function sayHi(age) {
-  console.log(`${this.name} is ${age}`);
+	console.log(`${this.name} is ${age}`);
 }
 
 sayHi.call(person, 21);
 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`
+-   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>Antwort</b></summary>
 <p>
@@ -1049,16 +1051,16 @@ In beiden Fällen können wir das Objekt weiter reichen, auf welches sich das `t
 
 ```javascript
 function sayHi() {
-  return (() => 0)();
+	return (() => 0)();
 }
 
 typeof sayHi();
 ```
 
-- A: `"object"`
-- B: `"number"`
-- C: `"function"`
-- D: `"undefined"`
+-   A: `"object"`
+-   B: `"number"`
+-   C: `"function"`
+-   D: `"undefined"`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -1085,10 +1087,10 @@ new Boolean(false);
 undefined;
 ```
 
-- A: `0`, `''`, `undefined`
-- B: `0`, `new Number(0)`, `''`, `new Boolean(false)`, `undefined`
-- C: `0`, `''`, `new Boolean(false)`, `undefined`
-- D: Alle sind falsy
+-   A: `0`, `''`, `undefined`
+-   B: `0`, `new Number(0)`, `''`, `new Boolean(false)`, `undefined`
+-   C: `0`, `''`, `new Boolean(false)`, `undefined`
+-   D: Alle sind falsy
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -1097,12 +1099,12 @@ undefined;
 
 Es gibt nur 6 falsy typen:
 
-- `undefined`
-- `null`
-- `NaN`
-- `0`
-- `''` (leerer String)
-- `false`
+-   `undefined`
+-   `null`
+-   `NaN`
+-   `0`
+-   `''` (leerer String)
+-   `false`
 
 Funktions-Constructor, wie `new Number` und `new Boolean` sind truthy.
 
@@ -1117,10 +1119,10 @@ Funktions-Constructor, wie `new Number` und `new Boolean` sind truthy.
 console.log(typeof typeof 1);
 ```
 
-- A: `"number"`
-- B: `"string"`
-- C: `"object"`
-- D: `"undefined"`
+-   A: `"number"`
+-   B: `"string"`
+-   C: `"object"`
+-   D: `"undefined"`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -1143,10 +1145,10 @@ numbers[10] = 11;
 console.log(numbers);
 ```
 
-- A: `[1, 2, 3, 7 x null, 11]`
-- B: `[1, 2, 3, 11]`
-- C: `[1, 2, 3, 7 x empty, 11]`
-- D: `SyntaxError`
+-   A: `[1, 2, 3, 7 x null, 11]`
+-   B: `[1, 2, 3, 11]`
+-   C: `[1, 2, 3, 7 x empty, 11]`
+-   D: `SyntaxError`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -1168,22 +1170,22 @@ abhängig davon wo das Array ausgeführt wird (die Ausgabe ist unterschiedlich f
 
 ```javascript
 (() => {
-  let x, y;
-  try {
-    throw new Error();
-  } catch (x) {
-    (x = 1), (y = 2);
-    console.log(x);
-  }
-  console.log(x);
-  console.log(y);
+	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`
+-   A: `1` `undefined` `2`
+-   B: `undefined` `undefined` `undefined`
+-   C: `1` `1` `2`
+-   D: `1` `undefined` `undefined`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -1203,10 +1205,10 @@ Außerhalb des `catch` Blocks ist `x` noch immer `undefined` und `y` ist `2`. We
 
 ###### 39. Alles in JavaScript ist entweder ein ...
 
-- A: Primitive oder Object
-- B: Function oder Object
-- C: Fangfrage: nur Objects!
-- D: Number oder Object
+-   A: Primitive oder Object
+-   B: Function oder Object
+-   C: Fangfrage: nur Objects!
+-   D: Number oder Object
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -1227,21 +1229,18 @@ Was einen primitiven Typ von einem Objekt unterscheidet ist, dass Primitive kein
 ###### 40. Was wird ausgegeben?
 
 ```javascript
-[
-  [0, 1],
-  [2, 3],
-].reduce(
-  (acc, cur) => {
-    return acc.concat(cur);
-  },
-  [1, 2]
+[[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]`
+-   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>Antwort</b></summary>
 <p>
@@ -1265,10 +1264,10 @@ Dann entspricht `acc` gleich `[1, 2, 0, 1]` und `cur` ist gleich `[2, 3]`. Wir v
 !!1;
 ```
 
-- A: `false` `true` `false`
-- B: `false` `false` `true`
-- C: `false` `true` `true`
-- D: `true` `true` `false`
+-   A: `false` `true` `false`
+-   B: `false` `false` `true`
+-   C: `false` `true` `true`
+-   D: `true` `true` `false`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -1292,10 +1291,10 @@ Dann entspricht `acc` gleich `[1, 2, 0, 1]` und `cur` ist gleich `[2, 3]`. Wir v
 setInterval(() => console.log("Hi"), 1000);
 ```
 
-- A: Eine unique id
-- B: Die definierte Anzahl von Millisekunden
-- C: Die Callback Function
-- D: `undefined`
+-   A: Eine unique id
+-   B: Die definierte Anzahl von Millisekunden
+-   C: Die Callback Function
+-   D: `undefined`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -1315,10 +1314,10 @@ Es gibt eine unique id zurück. Diese id kann zum Beispiel verwendet werden um d
 [..."Lydia"];
 ```
 
-- A: `["L", "y", "d", "i", "a"]`
-- B: `["Lydia"]`
-- C: `[[], "Lydia"]`
-- D: `[["L", "y", "d", "i", "a"]]`
+-   A: `["L", "y", "d", "i", "a"]`
+-   B: `["Lydia"]`
+-   C: `[[], "Lydia"]`
+-   D: `[["L", "y", "d", "i", "a"]]`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -1378,7 +1377,7 @@ const secondPromise = new Promise((res, rej) => {
   setTimeout(res, 100, "two");
 });
 
-Promise.race([firstPromise, secondPromise]).then((res) => console.log(res));
+Promise.race([firstPromise, secondPromise]).then(res => console.log(res));
 ```
 
 - A: `"one"`
@@ -1442,7 +1441,7 @@ Wir ändern nur den Wert der Variable `person` und nicht das erste Element im Ar
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21,
+  age: 21
 };
 
 for (const item in person) {
@@ -1522,7 +1521,7 @@ Nur die erste Zahl im String wird ausgegeben. Aufgrund des _radix_ (das zweite A
 ###### 50. Was wird ausgegeben?
 
 ```javascript
-[1, 2, 3].map((num) => {
+[1, 2, 3].map(num => {
   if (typeof num === "number") return;
   return num * 2;
 });
@@ -1688,6 +1687,7 @@ Da wir die Variable `y` aber global erstellt haben ist ihr Wert `10` auch hier v
 </p>
 </details>
 
+
 ---
 
 ###### 55. Was wird ausgegeben?
@@ -1699,7 +1699,7 @@ class Dog {
   }
 }
 
-Dog.prototype.bark = function () {
+Dog.prototype.bark = function() {
   console.log(`Woof I am ${this.name}`);
 };
 
@@ -1814,7 +1814,7 @@ console.log(delete age);
 
 #### Antwort: A
 
-Der `delete` Operator gibt einen Boolean Wert zurück: `true` bei erfolgreichem entfernen, oder andernfalls `false`. Variablen, die mit `var`, `let` oder `const` deklariert werden, können andererseits nicht mit `delete` entfernt werden.
+Der `delete` Operator gibt einen Boolean Wert zurück: `true` bei erfolgreichem entfernen, oder andernfalls `false`. Variablen, die mit `var`, `let` oder `const` deklariert werden, können andererseits  nicht mit `delete` entfernt werden.
 
 Der Wert von `name` wurde mit `const` deklariert, weshalb `delete` nicht möglich ist und `false` zurückgegeben wird. Als wir `age` den Wert `21` zugewiesen haben, haben wir eine Property `age` zum globalen Objekt hinzugefügt. Diese Properties kann man mit `delete` entfernen, sodass `delete age` `true` zurückgibt.
 
@@ -1927,7 +1927,7 @@ Properties, die mit `defineProperty` erstellt wurden sind standardmäßig unver
 const settings = {
   username: "lydiahallie",
   level: 19,
-  health: 90,
+  health: 90
 };
 
 const data = JSON.stringify(settings, ["level", "health"]);
@@ -1961,7 +1961,7 @@ Wenn der Replacer eine _Funktion_ ist, so wird diese Funktion für jede Property
 let num = 10;
 
 const increaseNumber = () => num++;
-const increasePassedNumber = (number) => number++;
+const increasePassedNumber = number => number++;
 
 const num1 = increaseNumber();
 const num2 = increasePassedNumber(num1);
@@ -1987,6 +1987,8 @@ Der unäre Operator `++` _gibt zuerst_ den Wert des Operanden aus und _erhöht d
 </p>
 </details>
 
+
+
 ---
 
 ###### <a name=20190707></a>64. Was wird ausgegeben?
@@ -2054,7 +2056,6 @@ Beim ersten Call ist der Akkumulator (`x`) gleich `1` und der aktuelle Wert (`y`
 Wenn wir keinen Wert einer Funktion ausgeben wird `undefined` ausgegeben. Beim nächsten Call ist der Akkumulator daher `undefined` und der aktuelle Wert ist `3`. `undefined` und `3` werden geloggt.
 
 Beim vierten Call geben wir wieder nichts aus, sodass der Akkumulator wieder `undefined` ist und der aktuelle Wert `4`. `undefined` und `4` werden geloggt.
-
 </p>
 </details>
 
@@ -2108,7 +2109,6 @@ In einer abgeleiteten Klasse kann das `this` Keyword nicht aufgerufen werden, be
 Mit dem `super` Keyword können wir den Constructor der Elternklasse mit gegebenen Argumenten aufrufen. Der Constructor der Elternklasse erhält das `name` Argument, sodass wir `name` an `super` übergeben müssen.
 
 Die `Dog` Klasse erhält zwei Argumente, `name` da es `Animal` erweitert und `size` als extra Property der `Dog` Klasse. Beide müssen an die Constructor Funktion von `Dog` übergeben werden, was nur bei Constructor 2 richtig ist.
-
 </p>
 </details>
 
@@ -2149,9 +2149,9 @@ Das ist der große Unterschied zwischen `require()` in CommonJS und `import`. Mi
 ###### 68. Was wird ausgegeben?
 
 ```javascript
-console.log(Number(2) === Number(2));
-console.log(Boolean(false) === Boolean(false));
-console.log(Symbol("foo") === Symbol("foo"));
+console.log(Number(2) === Number(2))
+console.log(Boolean(false) === Boolean(false))
+console.log(Symbol('foo') === Symbol('foo'))
 ```
 
 - A: `true`, `true`, `false`
@@ -2174,9 +2174,9 @@ Jedes Symbol ist eindeutig. Der Sinn des Argumentes, welches an das Symbol weite
 ###### 69. Was wird ausgegeben?
 
 ```javascript
-const name = "Lydia Hallie";
-console.log(name.padStart(13));
-console.log(name.padStart(2));
+const name = "Lydia Hallie"
+console.log(name.padStart(13))
+console.log(name.padStart(2))
 ```
 
 - A: `"Lydia Hallie"`, `"Lydia Hallie"`
@@ -2451,7 +2451,7 @@ Die `sum` Funktion gibt daher immer das gleiche Ergebnis aus. Wenn wir `1` und `
 ```javascript
 const add = () => {
   const cache = {};
-  return (num) => {
+  return num => {
     if (num in cache) {
       return `From cache! ${cache[num]}`;
     } else {
@@ -2496,21 +2496,21 @@ Beim dritten Mal geben wir `5 * 2` als Argument in die Funktion ein, was `10` er
 ###### <a name=20190726></a>79. Was wird ausgegeben?
 
 ```javascript
-const myLifeSummedUp = ["☕", "💻", "🍷", "🍫"];
+const myLifeSummedUp = ["☕", "💻", "🍷", "🍫"]
 
 for (let item in myLifeSummedUp) {
-  console.log(item);
+  console.log(item)
 }
 
 for (let item of myLifeSummedUp) {
-  console.log(item);
+  console.log(item)
 }
 ```
 
 - A: `0` `1` `2` `3` und `"☕"` ` "💻"` `"🍷"` `"🍫"`
 - B: `"☕"` ` "💻"` `"🍷"` `"🍫"` und `"☕"` ` "💻"` `"🍷"` `"🍫"`
 - C: `"☕"` ` "💻"` `"🍷"` `"🍫"` und `0` `1` `2` `3`
-- D: `0` `1` `2` `3` und `{0: "☕", 1: "💻", 2: "🍷", 3: "🍫"}`
+- D:  `0` `1` `2` `3` und `{0: "☕", 1: "💻", 2: "🍷", 3: "🍫"}`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -2533,14 +2533,14 @@ Mit einer _for-of_ Schleife können wir über **wiederholbare** Elemente iterier
 ###### 80. Was wird ausgegeben?
 
 ```javascript
-const list = [1 + 2, 1 * 2, 1 / 2];
-console.log(list);
+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]`
+- D:  `[1, 1, 1]`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -2560,16 +2560,16 @@ Das Element ist gleich dem ausgegebenen Wert. `1 + 2` ergibt `3`, `1 * 2` ergibt
 
 ```javascript
 function sayHi(name) {
-  return `Hi there, ${name}`;
+  return `Hi there, ${name}`
 }
 
-console.log(sayHi());
+console.log(sayHi())
 ```
 
 - A: `Hi there, `
 - B: `Hi there, undefined`
 - C: `Hi there, null`
-- D: `ReferenceError`
+- D:  `ReferenceError`
 
 <details><summary><b>Antwort</b></summary>
 <p>
@@ -2592,21 +2592,21 @@ In diesem Fall, falls wir kein Argument oder `undefined` eingeben ist `name` imm
 ###### 82. Was wird ausgegeben?
 
 ```javascript
-var status = "😎";
+var status = "😎"
 
 setTimeout(() => {
-  const status = "😍";
+  const status = "😍"
 
   const data = {
     status: "🥑",
     getStatus() {
-      return this.status;
-    },
-  };
+      return this.status
+    }
+  }
 
-  console.log(data.getStatus());
-  console.log(data.getStatus.call(this));
-}, 0);
+  console.log(data.getStatus())
+  console.log(data.getStatus.call(this))
+}, 0)
 ```
 
 - A: `"🥑"` und `"😍"`
@@ -2623,6 +2623,7 @@ Der Wert des `this` Keywords hängt davon ab, wo es verwendet wird. In einer **M
 
 Mit der `call` Methode können wir das Objekt, auf welches sich das `this` Keyword bezieht ändern. In **Funktionen** bezieht sich `this` auf das _Objekt, zu dem die Funktion gehört_. Wir erklären die `setTimeout` Funktion im _globalen Objekt_, sodass sich `this` in `setTimeout` auf das _globale Objekt_ bezieht. Im globalen Objekt gibt es _status_ mit dem Wert `"😎"`, was geloggt wird.
 
+
 </p>
 </details>
 
@@ -2633,13 +2634,13 @@ Mit der `call` Methode können wir das Objekt, auf welches sich das `this` Keywo
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21,
-};
+  age: 21
+}
 
-let city = person.city;
-city = "Amsterdam";
+let city = person.city
+city = "Amsterdam"
 
-console.log(person);
+console.log(person)
 ```
 
 - A: `{ name: "Lydia", age: 21 }`
@@ -2670,15 +2671,15 @@ Wenn wir `person` loggen bekommen wir daher das unveränderte Objekt angezeigt.
 ```javascript
 function checkAge(age) {
   if (age < 18) {
-    const message = "Sorry, you're too young.";
+    const message = "Sorry, you're too young."
   } else {
-    const message = "Yay! You're old enough!";
+    const message = "Yay! You're old enough!"
   }
 
-  return message;
+  return message
 }
 
-console.log(checkAge(21));
+console.log(checkAge(21))
 ```
 
 - A: `"Sorry, you're too young."`
@@ -2701,9 +2702,9 @@ Variablen mit dem `const` und `let` Keyword sind _block-scoped_. Ein Block ist a
 ###### 85. Welche Information wird geloggt?
 
 ```javascript
-fetch("https://www.website.com/api/user/1")
-  .then((res) => res.json())
-  .then((res) => console.log(res));
+fetch('https://www.website.com/api/user/1')
+  .then(res => res.json())
+  .then(res => console.log(res))
 ```
 
 - A: Das Ergebnis der `fetch` Methode.
@@ -2748,16 +2749,16 @@ Wenn wir `hasName` gleich `name` setzen, so beinhaltet `hasName` den Wert von `n
 `new Boolean(true)` gibt einen Objekt Wrapper aus, nicht ein Boolean ansich.
 
 `name.length` gibt die Länge des Arguments aus, nicht den Boolean Wert.
-
 </p>
 </details>
 
+
 ---
 
 ###### <a name=20190805></a>87. Was wird ausgegeben?
 
 ```javascript
-console.log("I want pizza"[0]);
+console.log("I want pizza"[0])
 ```
 
 - A: `"""`
@@ -2783,10 +2784,10 @@ Diese Methode funktioniert nicht in IE7 und davor. Hier muss `.charAt()` verwend
 
 ```javascript
 function sum(num1, num2 = num1) {
-  console.log(num1 + num2);
+  console.log(num1 + num2)
 }
 
-sum(10);
+sum(10)
 ```
 
 - A: `NaN`
@@ -2812,13 +2813,13 @@ Wenn man den Wert des Standard Paramenters gleich dem Parameter setztm der _dana
 
 ```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);
+console.log(data)
 ```
 
 - A: `{ default: function default(), name: "Lydia" }`
@@ -2845,12 +2846,12 @@ Das `data` Objekt hat eine Standard Property für alle Standard Exporte, andere
 ```javascript
 class Person {
   constructor(name) {
-    this.name = name;
+    this.name = name
   }
 }
 
-const member = new Person("John");
-console.log(typeof member);
+const member = new Person("John")
+console.log(typeof member)
 ```
 
 - A: `"class"`
@@ -2867,7 +2868,7 @@ Klassen sind syntaktischer Zucker für Funktionskontruktoren. Das Equivalent der
 
 ```javascript
 function Person() {
-  this.name = name;
+  this.name = name
 }
 ```
 
@@ -2881,9 +2882,9 @@ Das Aufrufen eines Funktionskonstruktors mit `new` hat zur Folge, dass eine Inst
 ###### 91. Was wird ausgegeben?
 
 ```javascript
-let newList = [1, 2, 3].push(4);
+let newList = [1, 2, 3].push(4)
 
-console.log(newList.push(5));
+console.log(newList.push(5))
 ```
 
 - A: `[1, 2, 3, 4, 5]`
@@ -2909,14 +2910,13 @@ Dann versuchen wir die `.push` Methode auf `newList` anzuwenden. Da `newList` de
 
 ```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);
+console.log(giveLydiaPizza.prototype)
+console.log(giveLydiaChocolate.prototype)
 ```
 
 - A: `{ constructor: ...}` `{ constructor: ...}`
@@ -2941,11 +2941,11 @@ Reguläre Funktionen wie `giveLydiaPizza` haben eine `prototype` Property, die e
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21,
-};
+  age: 21
+}
 
 for (const [x, y] of Object.entries(person)) {
-  console.log(x, y);
+  console.log(x, y)
 }
 ```
 
@@ -2997,14 +2997,13 @@ getItems(["banana", "apple"], "pear", "orange")
 
 ```javascript
 function getItems(fruitList, favoriteFruit, ...args) {
-  return [...fruitList, ...args, favoriteFruit];
+  return [...fruitList, ...args, favoriteFruit]
 }
 
-getItems(["banana", "apple"], "pear", "orange");
+getItems(["banana", "apple"], "pear", "orange")
 ```
 
 Dieses Beispiel würde funktionieren und `[ 'banana', 'apple', 'orange', 'pear' ]` ausgeben.
-
 </p>
 </details>
 
@@ -3014,14 +3013,17 @@ Dieses Beispiel würde funktionieren und `[ 'banana', 'apple', 'orange', 'pear'
 
 ```javascript
 function nums(a, b) {
-  if (a > b) console.log("a is bigger");
-  else console.log("b is bigger");
-  return;
-  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));
+console.log(nums(4, 2))
+console.log(nums(1, 2))
 ```
 
 - A: `a is bigger`, `6` und `b is bigger`, `3`
@@ -3039,8 +3041,8 @@ In JavaScript muss das Semikolon _nicht_ explizit gesetzt werden, allerdings set
 In unserem Beispiel haben wir ein `return` Statement gefolgt von einem anderen Wert `a + b` auf der _nächsten Zeile_. Da es eine neue Zeile ist, weiß JavaScript nicht, dass das der Wert ist, den wir eigentlich ausgeben wollten. Stattdessen wird automatisch ein Semikolon nach `return` gesetzt, was man wiefolgt lesen kann:
 
 ```javascript
-return;
-a + b;
+  return;
+  a + b
 ```
 
 Das bedeutet, dass `a + b` nie erreicht wird, da die Funktion auf der Zeile davor mit dem `return` Keyword endet. Wenn wie hier kein Wert ausgegeben wird, gibt die Funktion `undefined` aus.
@@ -3056,18 +3058,18 @@ Bedenke: Semikolons werden **nicht** automatisch nach `if/else` Statements geset
 ```javascript
 class Person {
   constructor() {
-    this.name = "Lydia";
+    this.name = "Lydia"
   }
 }
 
 Person = class AnotherPerson {
   constructor() {
-    this.name = "Sarah";
+    this.name = "Sarah"
   }
-};
+}
 
-const member = new Person();
-console.log(member.name);
+const member = new Person()
+console.log(member.name)
 ```
 
 - A: `"Lydia"`
@@ -3091,11 +3093,11 @@ Wir können Klassen gleich anderen Klassen oder Funktions Konstruktoren setzen.
 
 ```javascript
 const info = {
-  [Symbol("a")]: "b",
-};
+  [Symbol('a')]: 'b'
+}
 
-console.log(info);
-console.log(Object.keys(info));
+console.log(info)
+console.log(Object.keys(info))
 ```
 
 - A: `{Symbol('a'): 'b'}` und `["{Symbol('a')"]`
@@ -3143,13 +3145,13 @@ console.log(getUser(user))
 
 Die `getList` Funktion bekommt ein Array als Argument zugewiesen. Zwischen den Klammern der `getList` Funktion wird das Array direkt destrukturiert. Man könnte das auch wiefolgt sehen:
 
-`[x, ...y] = [1, 2, 3, 4]`
+ `[x, ...y] = [1, 2, 3, 4]`
 
 Mit dem Rest Parameter `...y` packen wir alle übrigen Argumente in ein Array. Die übrigen Argumente sind in dem Fall `2`, `3` und `4`. Der Wert von `y` ist ein Array mit den restlichen Parametern. Der Wert von `x` ist gleich `1` sodass `[1, [2, 3, 4]]` geloggt wird.
 
 Die `getUser` Funktion bekommt ein Objekt zugewiesen. Bei Arrow Funktionen müssen wir keine geschweiften Klammern verwenden, wenn wir nur einen Wert ausgeben. Wenn wir aber ein _Objekt_ von einer Arrow Funktion ausgeben lassen möchten, so muss dieses zwischen Klammern stehen, ansonsten wird nichts ausgegeben. Die folgende Funktion hätte ein Objekt ausgegeben:
 
-`const getUser = user => ({ name: user.name, age: user.age })`
+```const getUser = user => ({ name: user.name, age: user.age })```
 
 Da kein Wert ausgegeben wird, gibt die Funktion `undefined` aus.
 
@@ -3161,9 +3163,9 @@ Da kein Wert ausgegeben wird, gibt die Funktion `undefined` aus.
 ###### 99. Was wird ausgegeben?
 
 ```javascript
-const name = "Lydia";
+const name = "Lydia"
 
-console.log(name());
+console.log(name())
 ```
 
 - A: `SyntaxError`
@@ -3194,8 +3196,8 @@ ReferenceErrors werden ausgeworfen, wenn JavaScript eine Referenz zu einem Wert
 ```javascript
 // 🎉✨ Das ist unsere 100. Frage! ✨🎉
 
-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`
@@ -3220,11 +3222,11 @@ You should${"" && `n't`} see a therapist after so much JavaScript lol`;
 ###### 101. Was wird ausgegeben?
 
 ```javascript
-const one = false || {} || null;
-const two = null || false || "";
-const three = [] || 0 || true;
+const one = (false || {} || null)
+const two = (null || false || "")
+const three = ([] || 0 || true)
 
-console.log(one, two, three);
+console.log(one, two, three)
 ```
 
 - A: `false` `null` `[]`
@@ -3253,16 +3255,16 @@ Mit dem `||` Operator geben wir den ersten truthy Operand aus. Wenn alle Werte f
 ###### 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");
+  myPromise().then(res => console.log(res))
+  console.log('second')
 }
 
 async function secondFunction() {
-  console.log(await myPromise());
-  console.log("second");
+  console.log(await myPromise())
+  console.log('second')
 }
 ```
 
@@ -3295,14 +3297,14 @@ Das bedeutet, dass auf `myPromise` gewartet und dann der Wert `I have resolved`
 ###### 103. Was wird ausgegeben?
 
 ```javascript
-const set = new Set();
+const set = new Set()
 
-set.add(1);
-set.add("Lydia");
-set.add({ name: "Lydia" });
+set.add(1)
+set.add("Lydia")
+set.add({ name: "Lydia" })
 
 for (let item of set) {
-  console.log(item + 2);
+  console.log(item + 2)
 }
 ```
 
@@ -3332,7 +3334,7 @@ Der zweite Wert hingegen ist der String `"Lydia"`. `"Lydia"` ist ein String und
 ###### 104. Was wird ausgegeben?
 
 ```javascript
-Promise.resolve(5);
+Promise.resolve(5)
 ```
 
 - A: `5`
@@ -3359,15 +3361,15 @@ In diesem Fall haben wir nur die Zahl `5` übergeben und diese wird genauso ausg
 ```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);
+compareMembers(person)
 ```
 
 - A: `Not the same!`
@@ -3402,11 +3404,11 @@ const colorConfig = {
   green: true,
   black: true,
   yellow: false,
-};
+}
 
-const colors = ["pink", "red", "blue"];
+const colors = ["pink", "red", "blue"]
 
-console.log(colorConfig.colors[1]);
+console.log(colorConfig.colors[1])
 ```
 
 - A: `true`
@@ -3433,7 +3435,7 @@ JavaScript interpretiert Statements. Wenn wir Klammern-Notation verwenden wird d
 ###### 107. Was wird ausgegeben?
 
 ```javascript
-console.log("❤️" === "❤️");
+console.log('❤️' === '❤️')
 ```
 
 - A: `true`
@@ -3454,14 +3456,14 @@ Emojis sind im Endeffekt nur Unicodes. Der Unicode für das Herz Emoji ist `"U+2
 ###### 108. Welche Methode verändert das ursprüngliche 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`
@@ -3481,17 +3483,18 @@ Mit der `splice` Methode ändern wir das ursprüngliche Array durch löschen, er
 </p>
 </details>
 
+
 ---
 
 ###### <a name=20191009></a>109. Was wird ausgegeben?
 
 ```javascript
-const food = ["🍕", "🍫", "🥑", "🍔"];
-const info = { favoriteFood: food[0] };
+const food = ['🍕', '🍫', '🥑', '🍔']
+const info = { favoriteFood: food[0] }
 
-info.favoriteFood = "🍝";
+info.favoriteFood = '🍝'
 
-console.log(food);
+console.log(food)
 ```
 
 - A: `['🍕', '🍫', '🥑', '🍔']`
@@ -3516,7 +3519,7 @@ Dann ändern wir den Wert von `favoriteFood` am `info` Objekt. Das `food` Array
 ###### 110. Was macht diese Methode?
 
 ```javascript
-JSON.parse();
+JSON.parse()
 ```
 
 - A: Parsed JSON in einen JavaScript Wert
@@ -3533,16 +3536,16 @@ Mit der `JSON.parse()` Methode können wir einen JSON String zu einem JavaScript
 
 ```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
+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]
+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' }
+const jsonArray = JSON.stringify({ name: "Lydia" }) // '{"name":"Lydia"}'
+JSON.parse(jsonArray) // { name: 'Lydia' }
 ```
 
 </p>
@@ -3553,14 +3556,14 @@ JSON.parse(jsonArray); // { name: 'Lydia' }
 ###### 111. Was wird ausgegeben?
 
 ```javascript
-let name = "Lydia";
+let name = 'Lydia'
 
 function getName() {
-  console.log(name);
-  let name = "Sarah";
+  console.log(name)
+  let name = 'Sarah'
 }
 
-getName();
+getName()
 ```
 
 - A: Lydia
@@ -3580,13 +3583,13 @@ Variablen mit dem `let` und `const` Keyword werden gehoisted, aber entgegen `var
 Hätten wir die `name` Variable nicht innerhalb `getName` deklariert, so hätte JavaScript außerhalb der Funktion in der _Scope-Kette_ weitergesucht. Der äußere Scope beinhaltet ebenfalls eine Variable `name` mit dem Wert `'Lydia'`. In diesem Fall wäre `Lydia` geloggt worden.
 
 ```javascript
-let name = "Lydia";
+let name = 'Lydia'
 
 function getName() {
-  console.log(name);
+  console.log(name)
 }
 
-getName(); // Lydia
+getName() // Lydia
 ```
 
 </p>
@@ -3598,18 +3601,18 @@ 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();
-const two = generatorTwo();
+const one = generatorOne()
+const two = generatorTwo()
 
-console.log(one.next().value);
-console.log(two.next().value);
+console.log(one.next().value)
+console.log(two.next().value)
 ```
 
 - A: `a` and `a`
@@ -3627,17 +3630,17 @@ Mit dem `yield` Keyword, halten wir Werte in einer Generator-Funktion. Mit dem `
 In `generatorOne` halten wir das gesamte Array `['a', 'b', 'c']` mit dem `yield` Keyword. Der Wert von `value` am Objekt gibt die `next` Methode an `one` (`one.next().value`) aus, was dem gesamten Array entspricht: `['a', 'b', 'c']`.
 
 ```javascript
-console.log(one.next().value); // ['a', 'b', 'c']
-console.log(one.next().value); // undefined
+console.log(one.next().value) // ['a', 'b', 'c']
+console.log(one.next().value) // undefined
 ```
 
 In `generatorTwo` verwenden wir das `yield*` Keyword. Das bedeutet, dass der erste gehaltene Wert von `two` gleich dem ersten gehaltenen Wert ist. Das ist das Array `['a', 'b', 'c']`. Der erste gehaltene Wert ist `a`, was ausgegeben wird.
 
 ```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
+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>
@@ -3648,7 +3651,7 @@ console.log(two.next().value); // undefined
 ###### 113. Was wird ausgegeben?
 
 ```javascript
-console.log(`${((x) => x)("I love")} to program`);
+console.log(`${(x => x)('I love')} to program`)
 ```
 
 - A: `I love to program`
@@ -3738,19 +3741,19 @@ Beim Setzen eines Key/Wert Paars mit der `set` Methode wird der Key als erstes A
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21,
-};
+  age: 21
+}
 
-const changeAge = (x = { ...person }) => (x.age += 1);
+const changeAge = (x = { ...person }) => x.age += 1
 const changeAgeAndName = (x = { ...person }) => {
-  x.age += 1;
-  x.name = "Sarah";
-};
+  x.age += 1
+  x.name = "Sarah"
+}
 
-changeAge(person);
-changeAgeAndName();
+changeAge(person)
+changeAgeAndName()
 
-console.log(person);
+console.log(person)
 ```
 
 - A: `{name: "Sarah", age: 22}`
@@ -3778,7 +3781,7 @@ Dann führen wir `changeAgeAndName` aus, allerdings ohne Parameter. Stattdessen
 
 ```javascript
 function sumValues(x, y, z) {
-  return x + y + z;
+	return x + y + z;
 }
 ```
 
@@ -3829,15 +3832,15 @@ Mit dem`+=` Operanden erhöhen wir den Wert von `num` um `1`. `num` hatte den ur
 
 ```javascript
 const person = {
-  firstName: "Lydia",
-  lastName: "Hallie",
-  pet: {
-    name: "Mara",
-    breed: "Dutch Tulip Hound",
-  },
-  getFullName() {
-    return `${this.firstName} ${this.lastName}`;
-  },
+	firstName: "Lydia",
+	lastName: "Hallie",
+	pet: {
+		name: "Mara",
+		breed: "Dutch Tulip Hound"
+	},
+	getFullName() {
+		return `${this.firstName} ${this.lastName}`;
+	}
 };
 
 console.log(person.pet?.name);
@@ -3874,9 +3877,9 @@ Mit den optionalen Kettenoperator `?.` müssen wir nicht mehr prüfen, ob die ti
 const groceries = ["banana", "apple", "peanuts"];
 
 if (groceries.indexOf("banana")) {
-  console.log("We have to buy bananas!");
+	console.log("We have to buy bananas!");
 } else {
-  console.log(`We don't have to buy bananas!`);
+	console.log(`We don't have to buy bananas!`);
 }
 ```
 
@@ -3901,10 +3904,10 @@ Wir haben die Kondition `groceries.indexOf("banana")` an das if-Statement überg
 
 ```javascript
 const config = {
-  languages: [],
-  set language(lang) {
-    return this.languages.push(lang);
-  },
+	languages: [],
+	set language(lang) {
+		return this.languages.push(lang);
+	}
 };
 
 console.log(config.language);
@@ -3958,9 +3961,9 @@ console.log(!typeof name === "string");
 ###### 123. Was ist der Output??
 
 ```javascript
-const add = (x) => (y) => (z) => {
-  console.log(x, y, z);
-  return x + y + z;
+const add = x => y => z => {
+	console.log(x, y, z);
+	return x + y + z;
 };
 
 add(4)(5)(6);
@@ -3987,16 +3990,16 @@ Die `add` Funktion gibt eine Arrow Funktion zurück, welche eine Arrow Funktion
 
 ```javascript
 async function* range(start, end) {
-  for (let i = start; i <= end; i++) {
-    yield Promise.resolve(i);
-  }
+	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);
-  }
+	const gen = range(1, 3);
+	for await (const item of gen) {
+		console.log(item);
+	}
 })();
 ```
 
@@ -4021,7 +4024,7 @@ Die Generator-Funktion `range` gibt ein asynchrones Objekt mit Promisen für jed
 
 ```javascript
 const myFunc = ({ x, y, z }) => {
-  console.log(x, y, z);
+	console.log(x, y, z);
 };
 
 myFunc(1, 2, 3);
@@ -4048,20 +4051,20 @@ 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}`;
 }
 
-console.log(getFine(130, 300));
+console.log(getFine(130, 300))
 ```
 
 - A: The driver drove 130 and has to pay 300
@@ -4084,8 +4087,8 @@ Mit der Methode `Intl.NumberFormat` können wir einen numerischen Wert in einen
 ###### 127. Was ist der Output?
 
 ```javascript
-const spookyItems = ["👻", "🎃", "🕸"];
-({ item: spookyItems[3] } = { item: "💀" });
+const spookyItems = ['👻', '🎃', '🕸'];
+({ item: spookyItems[3] } = { item: '💀' });
 
 console.log(spookyItems);
 ```
@@ -4110,7 +4113,7 @@ Durch die destrukturierende Zuweisung können wir Werte des Ojekts von der recht
 ###### 128. Was ist der Output?
 
 ```javascript
-const name = "Lydia Hallie";
+const name = 'Lydia Hallie';
 const age = 21;
 
 console.log(Number.isNaN(name));
@@ -4130,7 +4133,7 @@ console.log(isNaN(age));
 
 #### Antwort: C
 
-Mit der Methode `Number.isNaN` kann geprüft werden, ob der übergebene Parameter vom Typ _Number_ mit Wert `NaN` ist. `name` ist kein numerischer Wert, deswegen ist der Rückgabewert von `Number.isNaN(name)` in diesem Fall `false`. `age` ist zwar ein numerischer Wert, aber nicht gleich `NaN`, weswegen `Number.isNaN(age)` `false` ausgibt.
+Mit der Methode `Number.isNaN` kann geprüft werden, ob der übergebene Parameter vom Typ _Number_ mit Wert  `NaN` ist. `name` ist kein numerischer Wert, deswegen ist der Rückgabewert von `Number.isNaN(name)` in diesem Fall `false`. `age` ist zwar ein numerischer Wert, aber nicht gleich `NaN`, weswegen `Number.isNaN(age)` `false` ausgibt.
 
 Die Methode `isNaN` prüft, ob der Eingabeparameter nicht vom Typ _Number_ ist. `name` ist ein String, darum gibt `isNaN(name)` `true` zurück. `age` ist ein numerischer Wert, weswegen `isNaN(age)` `false` ausgibt.
 
@@ -4146,7 +4149,7 @@ const randomValue = 21;
 
 function getInfo() {
   console.log(typeof randomValue);
-  const randomValue = "Lydia Hallie";
+  const randomValue = 'Lydia Hallie';
 }
 
 getInfo();
@@ -4172,7 +4175,7 @@ Variablen die mit `const` deklariert werden, können nicht vor ihrer Initialisie
 ###### 130. Was ist der Output?
 
 ```javascript
-const myPromise = Promise.resolve("Woah some cool data");
+const myPromise = Promise.resolve('Woah some cool data');
 
 (async () => {
   try {
@@ -4180,7 +4183,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!');
   }
 })();
 ```
@@ -4205,7 +4208,7 @@ Im `try`-Block loggen wir den mit dem `await`-Operator den Wert der Variable `my
 ###### 131. Was ist der Output?
 
 ```javascript
-const emojis = ["🥑", ["✨", "✨", ["🍕", "🍕"]]];
+const emojis = ['🥑', ['✨', '✨', ['🍕', '🍕']]];
 
 console.log(emojis.flat(1));
 ```
@@ -4278,19 +4281,19 @@ Wir rufen nun `counterTwo.increment()` auf, wodurch der Wert von `count` auf `3`
 ###### 133. Was ist der Output?
 
 ```javascript
-const myPromise = Promise.resolve(Promise.resolve("Promise!"));
+const myPromise = Promise.resolve(Promise.resolve('Promise!'));
 
 function funcOne() {
-  myPromise.then((res) => res).then((res) => console.log(res));
-  setTimeout(() => console.log("Timeout!", 0));
-  console.log("Last line!");
+  myPromise.then(res => res).then(res => console.log(res));
+  setTimeout(() => console.log('Timeout!', 0));
+  console.log('Last line!');
 }
 
 async function funcTwo() {
   const res = await myPromise;
   console.log(await res);
-  setTimeout(() => console.log("Timeout!", 0));
-  console.log("Last line!");
+  setTimeout(() => console.log('Timeout!', 0));
+  console.log('Last line!');
 }
 
 funcOne();
@@ -4318,4 +4321,4 @@ Die nächste Zeile ist die _asynchrone_ Funktion `setTimeout`, deren Callback an
 Wir kommen zur letzten Zeile in `funcTwo`, die `Last line!` in der Console ausgibt. Da `funcTwo` abgearbeitet und aus dem Call Stack entfernt wurde, ist der Call Stack leer. Die wartenden Callbacks (`() => console.log("Timeout!")` aus `funcOne` und `() => console.log("Timeout!")` aus `funcTwo`) werden dem Call Stack nacheinander hinzugefügt. Der erste Callback loggt `Timeout!` und wird aus dem Stack entfernt. Anschließend loggt der zweite Callback `Timeout!` und wird aus dem Stack entfernt. Somit ist das Ergebnis `Last line! Promise! Promise! Last line! Timeout! Timeout!`
 
 </p>
-</details>
+</details>
\ No newline at end of file
diff --git a/es-ES/README-ES.md b/es-ES/README-ES.md
index 577e66f0..5c3ddc40 100644
--- a/es-ES/README-ES.md
+++ b/es-ES/README-ES.md
@@ -1,16 +1,17 @@
-# Lista de preguntas (avanzadas) de JavaScript
 
-Publico diariamente preguntas de opción múltiple en JavaScript en mi [Instagram](https://www.instagram.com/theavocoder), ¡que también publicaré aquí!
+# Lista de preguntas (avanzadas) de JavaScript 
 
-Desde lo básico a lo avanzado: comprueba si realmente conoces _Javascript_, actualiza tus conocimientos o simplemente prepárate para tu próxima entrevista 💪 🚀 Actualizaré este repo semanalmente con nuevas preguntas.
-
-Las respuestas se encuentran en las secciones contraídas debajo de las preguntas, simplemente haz clic en ellas para expandirlas. Buena suerte ❤️
+ Publico diariamente preguntas de opción múltiple en JavaScript en mi [Instagram](https://www.instagram.com/theavocoder), ¡que también publicaré aquí! 
+ 
+ Desde lo básico a lo avanzado: comprueba si realmente conoces _Javascript_, actualiza tus conocimientos o simplemente prepárate para tu próxima entrevista 💪 🚀 Actualizaré este repo semanalmente con nuevas preguntas.
+ 
+ Las respuestas se encuentran en las secciones contraídas debajo de las preguntas, simplemente haz clic en ellas para expandirlas. Buena suerte ❤️
 
 ¿Quieres recibir un email cada vez que agregue más preguntas? <br />
 <a target="_blank" href="https://www.theavocoder.com/subscribe"><b>✨✉Suscríbete a las actualizaciones por email✉✨</b></a>
 
-Lista de lenguajes disponibles:
 
+Lista de lenguajes disponibles:
 - [🇸🇦 العربية](../ar-AR/README_AR.md)
 - [🇪🇬 اللغة العامية](../ar-EG/README_ar-EG.md)
 - [🇧🇦 Bosanski](../bs-BS/README-bs_BS.md)
@@ -24,7 +25,6 @@ Lista de lenguajes disponibles:
 - [🇳🇱 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)
@@ -34,6 +34,7 @@ Lista de lenguajes disponibles:
 - [🇨🇳 简体中文](../zh-CN/README-zh_CN.md)
 - [🇹🇼 繁體中文](../zh-TW/README_zh-TW.md)
 
+
 ---
 
 ###### 1. ¿Qué devuelve la siguiente función?
@@ -62,7 +63,6 @@ sayHi();
 Dentro de la función, primero declaramos la variable `name` con la palabra reservada ` var`. Esto significa que la variable se _eleva_ (el espacio de memoria se configura durante la fase de creación. Hace referencia al termino [hoisting](https://developer.mozilla.org/es/docs/Glossary/Hoisting)) con el valor predeterminado de `indefinido`, hasta que realmente llegamos a la línea donde definimos la variable. Aún no hemos definido la variable en la línea donde intentamos registrar la variable `name`, por lo que aún mantiene el valor de` undefined`.
 
 Las variables con la palabra clave `let` (y` const`) se _elevan_, pero a diferencia de `var`, no se inicializa <i> </i>. No son accesibles antes de la línea que los declaramos (inicializamos). Esto se llama la ["zona muerta temporal"](https://wesbos.com/temporal-dead-zone/). Cuando intentamos acceder a las variables antes de que se declaren, JavaScript lanza un `ReferenceError`
-
 </p>
 </details>
 
@@ -106,7 +106,7 @@ const shape = {
   diameter() {
     return this.radius * 2;
   },
-  perimeter: () => 2 * Math.PI * this.radius,
+  perimeter: () => 2 * Math.PI * this.radius
 };
 
 shape.diameter();
@@ -163,12 +163,12 @@ En el segundo caso la cadena `'Lydia'` es un valor verdadero. Lo que realmente e
 
 ```javascript
 const bird = {
-  size: "small",
+  size: "small"
 };
 
 const mouse = {
   name: "Mickey",
-  small: true,
+  small: true
 };
 ```
 
@@ -186,7 +186,7 @@ En JavaScript, todas las _keys_ son cadenas (a menos que sea un símbolo). A pes
 
 JavaScript interpreta declaraciones. Cuando usamos la notación de corchetes, ve el corchete de apertura `[` y continúa hasta que encuentra el corchete de cierre `]`. Solo de esta manera se evaluará la afirmación.
 
-`mouse [bird.size]`: Primero evalúa `bird.size`, que es`"small"`. `mouse ["small"]` devuelve `true`
+`mouse [bird.size]`: Primero evalúa `bird.size`, que es` "small" `. `mouse ["small"]` devuelve `true`
 
 Sin embargo, con la notación de puntos, esto no sucede. `mouse` no tiene una clave llamada` bird`, lo que significa que `mouse.bird` es` undefined`. Luego, pedimos el `tamaño` usando la notación de puntos:` mouse.bird.size`. Como `mouse.bird` es` undefined`, en realidad estamos preguntando `undefined.size`. Esto no es válido y generará un error similar `al Cannot read property "size" of undefined`
 
@@ -363,7 +363,7 @@ function Person(firstName, lastName) {
 const member = new Person("Lydia", "Hallie");
 Person.getFullName = function () {
   return `${this.firstName} ${this.lastName}`;
-};
+}
 
 console.log(member.getFullName());
 ```
@@ -420,7 +420,7 @@ console.log(sarah);
 
 Para `sarah`, no usamos la palabra reservada `new`. Cuando se usa `new`, se refiere al nuevo objeto vacío que creamos. Sin embargo, si no se agrega `new', se refiere al **objeto global**!
 
-En el ejemplo `this.firstName` equivale a `"Sarah"` y `this.lastName` equivale a `"Smith"`. Lo que realmente hicimos fue definir `global.firstName = `Sarah'`y`global.lastName = `Smith'`. La misma `sarah` se deja `indefinida`.
+En el ejemplo `this.firstName` equivale a `"Sarah"` y `this.lastName` equivale a `"Smith"`. Lo que realmente hicimos fue definir `global.firstName = `Sarah'` y `global.lastName = `Smith'`. La misma `sarah` se deja `indefinida`.
 
 </p>
 </details>
@@ -487,7 +487,7 @@ sum(1, "2");
 
 JavaScript es un **lenguaje dinámicamente tipado** o de tipado débil, esto significa que no es necesario declarar el tipo de variable antes de usarla pues será determinado automáticamente cuando el programa comience a ser procesado. Los valores se pueden convertir automáticamente en otro tipo sin que se sepa, esto se llama denomina _implicit type coercion_ (Más info [aquí](https://medium.com/@ManuCastrillonM/entendiendo-la-coerci%C3%B3n-en-javascript-bc202d22d23f)). **La coerción es la conversión de un tipo a otro.**
 
-En este ejemplo, JavaScript convierte el número `1` en una cadena, para que la función tenga sentido y devuelva un valor. Durante la suma de un tipo numérico (`1`) y un tipo de cadena (`'2'`), el número se trata como una cadena. Podemos concatenar cadenas como ` "Hello" + "World"``, así que lo que está pasando aquí es  `"1" + "2"`que devuelve`"12"`
+En este ejemplo, JavaScript convierte el número `1` en una cadena, para que la función tenga sentido y devuelva un valor. Durante la suma de un tipo numérico (`1`) y un tipo de cadena (`'2'`), el número se trata como una cadena. Podemos concatenar cadenas como `"Hello" + "World"``, así que lo que está pasando aquí es `"1" + "2"` que devuelve `"12"`
 
 </p>
 </details>
@@ -554,8 +554,8 @@ getPersonInfo`${person} is ${age} years old`;
 
 #### Respuesta correcta: B
 
-_Tagged templates_ es un caso de uso de [template literals](https://codeburst.io/javascript-template-literals-tag-functions-for-beginners-758a041160e1). Una _plantilla etiquetada_ es una llamada de función que utiliza una plantilla literal de la que obtener sus argumentos. Si se usan literales de plantillas etiquetadas, el valor del primer argumento es siempre una matriz de los valores de las cadenas. El resto de los argumentos obtienen los valores de las expresiones pasadas.
 
+_Tagged templates_ es un caso de uso de [template literals](https://codeburst.io/javascript-template-literals-tag-functions-for-beginners-758a041160e1). Una _plantilla etiquetada_ es una llamada de función que utiliza una plantilla literal de la que obtener sus argumentos. Si se usan literales de plantillas etiquetadas, el valor del primer argumento es siempre una matriz de los valores de las cadenas. El resto de los argumentos obtienen los valores de las expresiones pasadas.
 </p>
 </details>
 
@@ -755,6 +755,7 @@ Todas las claves de un objeto (excepto los símbolos) actúan como cadenas, incl
 
 No funciona así para un conjunto. No hay un "1" en nuestro set: `set.has('1')` devuelve `falso`. Tiene el tipo numérico `1`, `set.has(1)` devuelve `true`.
 
+
 </p>
 </details>
 
@@ -820,8 +821,7 @@ for (let i = 1; i < 5; i++) {
 <p>
 
 #### Respuesta correcta: C
-
-La sentencia `continue` omite una iteración si una cierta condición, en este caso `(i === 3)`, devuelve `true`.
+La sentencia `continue` omite una iteración si una cierta condición, en este caso `(i === 3)`,  devuelve `true`.
 
 </p>
 </details>
@@ -837,7 +837,7 @@ String.prototype.giveLydiaPizza = () => {
 
 const name = "Lydia";
 
-console.log(name.giveLydiaPizza());
+console.log(name.giveLydiaPizza())
 ```
 
 - A: `"Just give Lydia pizza already!"`
@@ -921,7 +921,7 @@ Después de que la _callback_ es empujada a la WebAPI, la función `setTimeout`
 
 <img src="https://i.imgur.com/X5wsHOg.png" width="200">
 
-Ahora, `foo` es invocado, y `"First"` está siendo registrado.
+Ahora, `foo` es invocado, y ``"First"`` está siendo registrado.
 
 <img src="https://i.imgur.com/Pvc0dGq.png" width="200">
 
@@ -949,7 +949,9 @@ Se invoca el `bar`, se registra el `"Second"` y se quita de la pila.
 ```html
 <div onclick="console.log('first div')">
   <div onclick="console.log('second div')">
-    <button onclick="console.log('button')">Click!</button>
+    <button onclick="console.log('button')">
+      Click!
+    </button>
   </div>
 </div>
 ```
@@ -975,7 +977,9 @@ El elemento anidado más profundo que causa el evento es el destino de ese event
 
 ```html
 <div onclick="console.log('div')">
-  <p onclick="console.log('p')">Click here!</p>
+  <p onclick="console.log('p')">
+    Click here!
+  </p>
 </div>
 ```
 
@@ -1019,7 +1023,7 @@ sayHi.bind(person, 21);
 
 #### Respuesta correcta: D
 
-En ambos podemos pasar el objeto al que queremos que se refiera la palabra reservada `this`. Sin embargo, la diferencia es que `.call` es _ejecutado inmediatamente_!
+En ambos  podemos pasar el objeto al que queremos que se refiera la palabra reservada `this`. Sin embargo, la diferencia es que `.call` es *ejecutado inmediatamente*!
 
 `.bind` devuelve una copia de la función, pero con un contexto enlazado. Es decir, no se ejecuta de inmediato.
 
@@ -1087,6 +1091,7 @@ Solo hay seis valores falsos:
 - `''` (cadena vacía)
 - `false`
 
+
 Los constructores de funciones, como `new Number` y `new Boolean` son correctos.
 
 </p>
@@ -1210,10 +1215,7 @@ Lo que diferencia a un tipo primitivo de un objeto es que los primeros no tienen
 ###### 40. ¿Qué devuelve la siguiente función?
 
 ```javascript
-[
-  [0, 1],
-  [2, 3],
-].reduce(
+[[0, 1], [2, 3]].reduce(
   (acc, cur) => {
     return acc.concat(cur);
   },
@@ -1231,7 +1233,7 @@ Lo que diferencia a un tipo primitivo de un objeto es que los primeros no tienen
 
 #### Respuesta correcta: C
 
-`[1, 2]` es nuestro valor inicial. Este es el valor con el que empezamos y el valor del primer `acc`. Durante la primera ronda, `acc` es`[1,2]`, y `cur` es `[0, 1]`. Los concatenamos, lo que resulta en `[1, 2, 0, 1]`.
+`[1, 2]` es nuestro valor inicial. Este es el valor con el que empezamos y el valor del primer `acc`. Durante la primera ronda, `acc` es` [1,2] `, y `cur` es `[0, 1]`. Los concatenamos, lo que resulta en `[1, 2, 0, 1]`.
 
 Entonces, `[1, 2, 0, 1]` es `acc` y` [2, 3]` es `cur`. Los concatenamos, y obtenemos `[1, 2, 0, 1, 2, 3]`
 
@@ -1361,7 +1363,7 @@ const secondPromise = new Promise((res, rej) => {
   setTimeout(res, 100, "two");
 });
 
-Promise.race([firstPromise, secondPromise]).then((res) => console.log(res));
+Promise.race([firstPromise, secondPromise]).then(res => console.log(res));
 ```
 
 - A: `"one"`
@@ -1425,7 +1427,7 @@ Solo estamos modificando el valor de la variable `person`, y no el primer elemen
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21,
+  age: 21
 };
 
 for (const item in person) {
@@ -1505,7 +1507,7 @@ Solo el primer número en el string es devuelto. Según en la _base_ seleccionad
 ###### 50. ¿Cuál es el resultado?
 
 ```javascript
-[1, 2, 3].map((num) => {
+[1, 2, 3].map(num => {
   if (typeof num === "number") return;
   return num * 2;
 });
@@ -1682,7 +1684,7 @@ class Dog {
   }
 }
 
-Dog.prototype.bark = function () {
+Dog.prototype.bark = function() {
   console.log(`Woof I am ${this.name}`);
 };
 
@@ -1910,7 +1912,7 @@ Las propiedades añadidas usando el método `defineProperty` son inmutables por
 const settings = {
   username: "lydiahallie",
   level: 19,
-  health: 90,
+  health: 90
 };
 
 const data = JSON.stringify(settings, ["level", "health"]);
@@ -1944,7 +1946,7 @@ Si el reemplazador es una _función_, esta función es llamada en cada propiedad
 let num = 10;
 
 const increaseNumber = () => num++;
-const increasePassedNumber = (number) => number++;
+const increasePassedNumber = number => number++;
 
 const num1 = increaseNumber();
 const num2 = increasePassedNumber(num1);
@@ -2034,7 +2036,7 @@ El valor del acumulador es igual al valor previamente devuelto por la función d
 
 En la primera llamada, el acumulador (`x`) es `1`, y el valor actual (`y`) es `2`. No devolvemos desde la función de callback, mostramos por consola el acumulador y el valor actual: se muestra `1` y `2`.
 
-Si no devuelves un valor de una función, se devuelve `undefined`. En la siguiente llamada, el acumulador es `undefined`, y el valor actual es `3`. Se muestra por consola `undefined` y `3`.
+Si no devuelves un valor de una función, se devuelve `undefined`. En la siguiente llamada, el acumulador es `undefined`, y el valor actual es `3`. Se muestra por consola `undefined` y `3`.  
 
 En la cuarta llamada, otra vez no devolvemos desde la función de callback. El acumulador es una vez más `undefined`, y el valor actual es `4`. Se muestra por consola `undefined` y `4`.
 
@@ -2053,7 +2055,7 @@ class Dog {
 };
 
 class Labrador extends Dog {
-  // 1
+  // 1 
   constructor(name, size) {
     this.size = size;
   }
@@ -2067,7 +2069,7 @@ class Labrador extends Dog {
     super(name);
     this.size = size;
   }
-  // 4
+  // 4 
   constructor(name, size) {
     this.name = name;
     this.size = size;
@@ -2101,12 +2103,12 @@ La clase `Labrador` recibe dos argumentos, `name` porque extiende de `Dog`, y `s
 
 ```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;
 ```
 
@@ -2122,7 +2124,7 @@ export const sum = (a, b) => a + b;
 
 Con `import`, todos los módulos importados son _pre-convertidos_. Esto significa que los módulos importados son ejecutados _primero_, y el código en el fichero que importa el módulo se ejecuta _después_.
 
-¡Esto es una diferencia existente entre `require()` en CommonJS e `import`! Con `require()`, puedes cargar dependencias bajo demanda mientras el código está siendo ejecutado. Si hubiéramos usado `require` en lugar de `import`, se habría mostrado por consola `running index.js`, `running sum.js`, `3`.
+¡Esto es una diferencia existente entre `require()` en CommonJS e `import`! Con `require()`, puedes cargar dependencias bajo demanda mientras el código está siendo ejecutado. Si hubiéramos usado `require` en lugar de `import`, se habría mostrado por consola `running index.js`, `running sum.js`, `3`. 
 
 </p>
 </details>
@@ -2132,9 +2134,9 @@ Con `import`, todos los módulos importados son _pre-convertidos_. Esto signific
 ###### 68. ¿Cuál es el resultado?
 
 ```javascript
-console.log(Number(2) === Number(2));
-console.log(Boolean(false) === Boolean(false));
-console.log(Symbol("foo") === Symbol("foo"));
+console.log(Number(2) === Number(2))
+console.log(Boolean(false) === Boolean(false))
+console.log(Symbol('foo') === Symbol('foo'))
 ```
 
 - A: `true`, `true`, `false`
@@ -2157,15 +2159,15 @@ Cada Symbol es completamente único. El propósito del argumento pasado a Symbol
 ###### 69. ¿Cuál es el resultado?
 
 ```javascript
-const name = "Lydia Hallie";
-console.log(name.padStart(13));
-console.log(name.padStart(2));
+const name = "Lydia Hallie"
+console.log(name.padStart(13))
+console.log(name.padStart(2))
 ```
 
 - A: `"Lydia Hallie"`, `"Lydia Hallie"`
 - B: `"           Lydia Hallie"`, `"  Lydia Hallie"` (`"[13 espacios en blanco]Lydia Hallie"`, `"[2 espacios en blanco]Lydia Hallie"`)
 - C: `" Lydia Hallie"`, `"Lydia Hallie"` (`"[1 espacio en blanco]Lydia Hallie"`, `"Lydia Hallie"`)
-- D: `"Lydia Hallie"`, `"Lyd"`,
+- D: `"Lydia Hallie"`, `"Lyd"`, 
 
 <details><summary><b>Solución</b></summary>
 <p>
@@ -2433,7 +2435,7 @@ La función `sum` siempre devuelve el mismo resultado. Si pasamos `1` y `2`, _si
 ```javascript
 const add = () => {
   const cache = {};
-  return (num) => {
+  return num => {
     if (num in cache) {
       return `From cache! ${cache[num]}`;
     } else {
@@ -2478,21 +2480,21 @@ La tercera vez, pasamos `5 * 2` a la función, que se evalúa como `10`. El obje
 ###### 79. ¿Cuál es el resultado?
 
 ```javascript
-const myLifeSummedUp = ["☕", "💻", "🍷", "🍫"];
+const myLifeSummedUp = ["☕", "💻", "🍷", "🍫"]
 
 for (let item in myLifeSummedUp) {
-  console.log(item);
+  console.log(item)
 }
 
 for (let item of myLifeSummedUp) {
-  console.log(item);
+  console.log(item)
 }
 ```
 
 - A: `0` `1` `2` `3` y `"☕"` ` "💻"` `"🍷"` `"🍫"`
 - B: `"☕"` ` "💻"` `"🍷"` `"🍫"` y `"☕"` ` "💻"` `"🍷"` `"🍫"`
 - C: `"☕"` ` "💻"` `"🍷"` `"🍫"` y `0` `1` `2` `3`
-- D: `0` `1` `2` `3` y `{0: "☕", 1: "💻", 2: "🍷", 3: "🍫"}`
+- D:  `0` `1` `2` `3` y `{0: "☕", 1: "💻", 2: "🍷", 3: "🍫"}`
 
 <details><summary><b>Solución</b></summary>
 <p>
@@ -2515,14 +2517,14 @@ Con un bucle _for-of_, podemos iterar sobre **iterables**. Un array es un iterab
 ###### 80. ¿Cuál es el resultado?
 
 ```javascript
-const list = [1 + 2, 1 * 2, 1 / 2];
-console.log(list);
+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]`
+- D:  `[1, 1, 1]`
 
 <details><summary><b>Solución</b></summary>
 <p>
@@ -2542,16 +2544,16 @@ El elemento será igual al valor retornado. `1 + 2` devuelve `3`, `1 * 2` devuel
 
 ```javascript
 function sayHi(name) {
-  return `Hi there, ${name}`;
+  return `Hi there, ${name}`
 }
 
-console.log(sayHi());
+console.log(sayHi())
 ```
 
 - A: `Hi there, `
 - B: `Hi there, undefined`
 - C: `Hi there, null`
-- D: `ReferenceError`
+- D:  `ReferenceError`
 
 <details><summary><b>Solución</b></summary>
 <p>
@@ -2574,21 +2576,21 @@ En ese caso, si no pasáramos un valor o si pasáramos `undefined`, `name` siemp
 ###### 82. ¿Cuál es el resultado?
 
 ```javascript
-var status = "😎";
+var status = "😎"
 
 setTimeout(() => {
-  const status = "😍";
+  const status = "😍"
 
   const data = {
     status: "🥑",
     getStatus() {
-      return this.status;
-    },
-  };
+      return this.status
+    }
+  }
 
-  console.log(data.getStatus());
-  console.log(data.getStatus.call(this));
-}, 0);
+  console.log(data.getStatus())
+  console.log(data.getStatus.call(this))
+}, 0)
 ```
 
 - A: `"🥑"` y `"😍"`
@@ -2615,13 +2617,13 @@ Con el método `call`, podemos cambiar el objeto al cual `this` referencia. En *
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21,
-};
+  age: 21
+}
 
-let city = person.city;
-city = "Amsterdam";
+let city = person.city
+city = "Amsterdam"
 
-console.log(person);
+console.log(person)
 ```
 
 - A: `{ name: "Lydia", age: 21 }`
@@ -2652,15 +2654,15 @@ Cuando se muestra por consola el objeto `person`, se devuelve el objeto sin modi
 ```javascript
 function checkAge(age) {
   if (age < 18) {
-    const message = "Sorry, you're too young.";
+    const message = "Sorry, you're too young."
   } else {
-    const message = "Yay! You're old enough!";
+    const message = "Yay! You're old enough!"
   }
 
-  return message;
+  return message
 }
 
-console.log(checkAge(21));
+console.log(checkAge(21))
 ```
 
 - A: `"Sorry, you're too young."`
@@ -2683,15 +2685,15 @@ Las variables con `const` y `let` tienen _alcance de bloque_. Un bloque es cualq
 ###### 85. ¿Qué tipo de información se mostrará por consola?
 
 ```javascript
-fetch("https://www.website.com/api/user/1")
-  .then((res) => res.json())
-  .then((res) => console.log(res));
+fetch('https://www.website.com/api/user/1')
+  .then(res => res.json())
+  .then(res => console.log(res))
 ```
 
 - A: El resultado del método `fetch`.
 - B: El resultado de la segunda invocación del método `fetch`.
 - C: El resultado de callback en el `.then()` anterior.
-- D: Sería siempre `undefined`.
+- D: Sería siempre `undefined`. 
 
 <details><summary><b>Solución</b></summary>
 <p>
@@ -2739,7 +2741,7 @@ Asignándole a `hasName` el valor de `name`, asignas a `hasName` cualquier valor
 ###### 87. ¿Cuál es el resultado?
 
 ```javascript
-console.log("I want pizza"[0]);
+console.log("I want pizza"[0])
 ```
 
 - A: `"""`
@@ -2765,10 +2767,10 @@ Observa que este método no está soportado en IE7 y versiones anteriores. En es
 
 ```javascript
 function sum(num1, num2 = num1) {
-  console.log(num1 + num2);
+  console.log(num1 + num2)
 }
 
-sum(10);
+sum(10)
 ```
 
 - A: `NaN`
@@ -2793,14 +2795,14 @@ Si estuvieras intentando asignar un valor por defecto a un parámetro igual a ot
 ###### 89. ¿Cuál es el resultado?
 
 ```javascript
-// module.js
-export default () => "Hello world";
-export const name = "Lydia";
+// module.js 
+export default () => "Hello world"
+export const name = "Lydia"
 
-// index.js
-import * as data from "./module";
+// index.js 
+import * as data from "./module"
 
-console.log(data);
+console.log(data)
 ```
 
 - A: `{ default: function default(), name: "Lydia" }`
@@ -2827,12 +2829,12 @@ El objeto `data` tiene una propiedad `default` para la exportación por defecto,
 ```javascript
 class Person {
   constructor(name) {
-    this.name = name;
+    this.name = name
   }
 }
 
-const member = new Person("John");
-console.log(typeof member);
+const member = new Person("John")
+console.log(typeof member)
 ```
 
 - A: `"class"`
@@ -2849,11 +2851,11 @@ Las clases son azúcar sintáctico para los constructores de funciones. El equiv
 
 ```javascript
 function Person() {
-  this.name = name;
+  this.name = name
 }
 ```
 
-Llamar a un constructor de funciones con `new` crea una instancia de `Person`, `typeof` devuelve `"object"` con una instancia. `typeof member` devuelve `"object"`.
+Llamar a un constructor de funciones con `new` crea una instancia de `Person`, `typeof` devuelve `"object"` con una instancia. `typeof member` devuelve `"object"`. 
 
 </p>
 </details>
@@ -2863,9 +2865,9 @@ Llamar a un constructor de funciones con `new` crea una instancia de `Person`, `
 ###### 91. ¿Cuál es el resultado?
 
 ```javascript
-let newList = [1, 2, 3].push(4);
+let newList = [1, 2, 3].push(4)
 
-console.log(newList.push(5));
+console.log(newList.push(5))
 ```
 
 - A: `[1, 2, 3, 4, 5]`
@@ -2891,18 +2893,17 @@ Después, intentamos usar el método `.push` en `newList`. Como `newList` es el
 
 ```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);
+console.log(giveLydiaPizza.prototype)
+console.log(giveLydiaChocolate.prototype)
 ```
 
-- A: `{ constructor: ...}` `{ constructor: ...}`
-- B: `{}` `{ constructor: ...}`
+- A: `{ constructor: ...}` `{ constructor: ...}` 
+- B: `{}` `{ constructor: ...}` 
 - C: `{ constructor: ...}` `{}`
 - D: `{ constructor: ...}` `undefined`
 
@@ -2923,16 +2924,16 @@ Las funciones regulares, como la función `giveLydiaPizza`, tienen la propiedad
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21,
-};
+  age: 21
+}
 
 for (const [x, y] of Object.entries(person)) {
-  console.log(x, y);
+  console.log(x, y)
 }
 ```
 
 - A: `name` `Lydia` y `age` `21`
-- B: `["name", "Lydia"]` y `["age", 21]`
+- B: `["name", "Lydia"]` y `["age", 21]` 
 - C: `["name", "age"]` y `undefined`
 - D: `Error`
 
@@ -2943,7 +2944,7 @@ for (const [x, y] of Object.entries(person)) {
 
 `Object.entries(person)` devuelve un array de arrays anidados, conteniendo claves y objetos:
 
-`[ [ 'name', 'Lydia' ], [ 'age', 21 ] ]`
+`[ [ 'name', 'Lydia' ], [ 'age', 21 ] ]` 
 
 Usando el bucle `for-of`, podemos iterar sobre cada elemento en el array, los subarrays en este caso. Podemos desestructurar los subarrays instantáneamente en el bucle for-of, usando `const [x, y]`. `x` es igual al primer elemento del subarray, `y` es igual al segundo elemento en el subarray.
 
@@ -2967,7 +2968,7 @@ getItems(["banana", "apple"], "pear", "orange")
 ```
 
 - A: `["banana", "apple", "pear", "orange"]`
-- B: `[["banana", "apple"], "pear", "orange"]`
+- B: `[["banana", "apple"], "pear", "orange"]` 
 - C: `["banana", "apple", ["pear"], "orange"]`
 - D: `SyntaxError`
 
@@ -2980,14 +2981,13 @@ getItems(["banana", "apple"], "pear", "orange")
 
 ```javascript
 function getItems(fruitList, favoriteFruit, ...args) {
-  return [...fruitList, ...args, favoriteFruit];
+  return [...fruitList, ...args, favoriteFruit]
 }
 
-getItems(["banana", "apple"], "pear", "orange");
+getItems(["banana", "apple"], "pear", "orange")
 ```
 
 El ejemplo de arriba sí que funciona. Devuelve el array `[ 'banana', 'apple', 'orange', 'pear' ]`
-
 </p>
 </details>
 
@@ -2997,14 +2997,17 @@ El ejemplo de arriba sí que funciona. Devuelve el array `[ 'banana', 'apple', '
 
 ```javascript
 function nums(a, b) {
-  if (a > b) console.log("a is bigger");
-  else console.log("b is bigger");
-  return;
-  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));
+console.log(nums(4, 2))
+console.log(nums(1, 2))
 ```
 
 - A: `a is bigger`, `6` y `b is bigger`, `3`
@@ -3017,13 +3020,13 @@ console.log(nums(1, 2));
 
 #### Answer: B
 
-En JavaScript, no _tenemos_ que escribir el punto y coma (`;`) de forma explicita, sin embargo el motor de JavaScript todavía las añade al final de cada sentencia. Esto se denomina **Insercción automática de punto y coma**. Una sentencia puede ser, por ejemplo, variables, o palabras clave como `throw`, `return`, `break`, etc.
+En JavaScript, no _tenemos_ que escribir el punto y coma (`;`) de forma explicita, sin embargo el motor de JavaScript todavía las añade al final de cada sentencia. Esto se denomina **Insercción automática de punto y coma**. Una sentencia puede ser, por ejemplo, variables, o palabras clave como `throw`, `return`, `break`, etc. 
 
 Aqui, escribimos una sentencia `return`, y otra sentencia de valor `a + b` en una _nueva línea_. Sin embargo, como es una línea nueva, el motor no sabe que en realidad es el valor que queríamos devolver. En cambio, añadió automáticamente un punto y coma después de `return`. Puedes ver esto como:
 
 ```javascript
-return;
-a + b;
+  return;
+  a + b
 ```
 
 Esto significa que nunca se alcanza `a + b`, ya que una función deja de ejecutarse después de la palabra clave` return`. Si no se devuelve ningún valor, como aquí, la función devuelve `undefined`. ¡Ten en cuenta que no hay inserción automática después de las sentencias `if/else`!
@@ -3038,18 +3041,18 @@ Esto significa que nunca se alcanza `a + b`, ya que una función deja de ejecuta
 ```javascript
 class Person {
   constructor() {
-    this.name = "Lydia";
+    this.name = "Lydia"
   }
 }
 
 Person = class AnotherPerson {
   constructor() {
-    this.name = "Sarah";
+    this.name = "Sarah"
   }
-};
+}
 
-const member = new Person();
-console.log(member.name);
+const member = new Person()
+console.log(member.name)
 ```
 
 - A: `"Lydia"`
@@ -3073,11 +3076,11 @@ Podemos establecer clases iguales a otros constructures de clases/funciones. En
 
 ```javascript
 const info = {
-  [Symbol("a")]: "b",
-};
+  [Symbol('a')]: 'b'
+}
 
-console.log(info);
-console.log(Object.keys(info));
+console.log(info)
+console.log(Object.keys(info))
 ```
 
 - A: `{Symbol('a'): 'b'}` y `["{Symbol('a')"]`
@@ -3124,13 +3127,13 @@ console.log(getUser(user))
 
 La función `getList` recibe un array argumento. Entre los paréntesis de la función `getList`, desestructuramos este array de inmediato. Podrías ver esto como:
 
-`[x, ...y] = [1, 2, 3, 4]`
+ `[x, ...y] = [1, 2, 3, 4]`
 
 Con el parámetro rest `...y`, ponemos todos los argumentos "restantes" en un array. Los argumentos restantes son `2`, `3` and `4` en este caso. El valor de `y` es un array, conteniendo todos los parámetros restantes. El valor de `x` es igual a `1` en este caso, por la tanto cuando registramos `[x, y]`, se imprime `[1, [2, 3, 4]]`.
 
-La función `getUser` recibe un objeto. Con las funciones flecha, no _tenemos_ que escribir llaves cuando simplemente devolvemos un valor. Sin embargo, si quieres devolver un _objeto_ desde una función llave, tienes que escribir el objeto entre paréntesis, ¡de otra manera no se devuelve ningún valor! La siguiente función habría devuelto un objeto:
+ La función `getUser` recibe un objeto. Con las funciones flecha, no _tenemos_ que escribir llaves cuando simplemente devolvemos un valor. Sin embargo, si quieres devolver un _objeto_ desde una función llave, tienes que escribir el objeto entre paréntesis, ¡de otra manera no se devuelve ningún valor! La siguiente función habría devuelto un objeto:
 
-`const getUser = user => ({ name: user.name, age: user.age })`
+```const getUser = user => ({ name: user.name, age: user.age })```
 
 Como no se devuelve ningún valor en este caso, la función devuelve `undefined`.
 
@@ -3142,9 +3145,9 @@ Como no se devuelve ningún valor en este caso, la función devuelve `undefined`
 ###### 99. ¿Cuál es el resultado?
 
 ```javascript
-const name = "Lydia";
+const name = "Lydia"
 
-console.log(name());
+console.log(name())
 ```
 
 - A: `SyntaxError`
@@ -3157,11 +3160,11 @@ console.log(name());
 
 #### Answer: C
 
-La variable `name` contiene el valor de una cadena, que no es una función, por lo tanto no puede invocar.
+La variable `name` contiene el valor de una cadena, que no es una función, por lo tanto no puede invocar. 
 
 Se genera una excepción de tipo TypeError cuando un valor no es del tipo esperado. JavaScript esperaba que `name` fuera una función ya que estamos intentando invocarla. Era una cadena sin embargo, por lo tanto se lanza una excepción del tipo TypeError: name is not a function!
 
-Se lanzan errores del tipo SyntaxError cuando has escrito algo que no es válido JavaScript, pro ejemplo cuando has escrito `return` como `retrun`.
+Se lanzan errores del tipo SyntaxError cuando has escrito algo que no es válido JavaScript, pro ejemplo cuando has escrito `return` como `retrun`. 
 Se lanzan errores del tipo ReferenceError cuando JavaScript no puede encontrar una referencia a un valor al que estás intentando acceder.
 
 </p>
@@ -3174,8 +3177,8 @@ Se lanzan errores del tipo ReferenceError cuando JavaScript no puede encontrar u
 ```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`
@@ -3200,11 +3203,11 @@ You should${"" && `n't`} see a therapist after so much JavaScript lol`;
 ###### 101. ¿Cuál es el valor de la salida?
 
 ```javascript
-const one = false || {} || null;
-const two = null || false || "";
-const three = [] || 0 || true;
+const one = (false || {} || null)
+const two = (null || false || "")
+const three = ([] || 0 || true)
 
-console.log(one, two, three);
+console.log(one, two, three)
 ```
 
 - A: `false` `null` `[]`
@@ -3233,20 +3236,20 @@ Con el operador `||`, podemos devolver el primer operando verdadero. Si todos lo
 ###### 102. ¿Cuál es el valor de la salida?
 
 ```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");
+  myPromise().then(res => console.log(res))
+  console.log('second')
 }
 
 async function secondFunction() {
-  console.log(await myPromise());
-  console.log("second");
+  console.log(await myPromise())
+  console.log('second')
 }
 
-firstFunction();
-secondFunction();
+firstFunction()
+secondFunction()
 ```
 
 - A: `I have resolved!`, `second` y `I have resolved!`, `second`
@@ -3261,13 +3264,13 @@ secondFunction();
 
 Con una promesa, básicamente decimos _Quiero ejecutar esta función, pero la dejaré a un lado por ahora mientras se está ejecutando, ya que esto puede llevar un tiempo. Solo cuando se resuelve (o se rechaza) un cierto valor, y cuando la pila de llamadas está vacía, quiero usar este valor._
 
-Podemos obtener este valor con las palabras clave `.then` y `await` en una función `async`. Aunque podemos obtener el valor de una promesa tanto con `.then` como con` wait ', funcionan de manera un poco diferente.
+Podemos obtener este valor con las palabras clave `.then` y `await` en una función `async`. Aunque podemos obtener el valor de una promesa tanto con `.then` como con` wait ', funcionan de manera un poco diferente. 
 
-En la función `firstFunction`, dejamos (de algún modo) a un lado la función myPromise mientras se estaba ejecutando, y seguimos ejecutando el otro código, que es `console.log('second')` en este caso. Luego, la función se resolvió con la cadena `I have resolved`, que luego se imprimió una vez que pila de llamadas quedó vacía.
+En la función `firstFunction`, dejamos (de algún modo) a un lado la función myPromise mientras se estaba ejecutando, y seguimos ejecutando el otro código, que es `console.log('second')` en este caso. Luego, la función se resolvió con la cadena `I have resolved`, que luego se imprimió una vez que pila de llamadas quedó vacía. 
 
 Con la palabra clave await en `secondFunction`, literalmente hacemos una pausa en la ejecución de una función asíncrona hasta que el valor se haya resuelto antes de pasar a la siguiente línea de código.
 
-Esto significa que se esperó a que `myPromise` resolviera con el valor `I have resolved`, y solo una vez que eso sucedió, pasamos a la siguiente línea: `second` que se imprime.
+Esto significa que se esperó a que `myPromise` resolviera con el valor `I have resolved`, y solo una vez que eso sucedió, pasamos a la siguiente línea: `second` que se imprime. 
 
 </p>
 </details>
@@ -3277,14 +3280,14 @@ Esto significa que se esperó a que `myPromise` resolviera con el valor `I have
 ###### 103. ¿Cuál es el valor de la salida?
 
 ```javascript
-const set = new Set();
+const set = new Set()
 
-set.add(1);
-set.add("Lydia");
-set.add({ name: "Lydia" });
+set.add(1)
+set.add("Lydia")
+set.add({ name: "Lydia" })
 
 for (let item of set) {
-  console.log(item + 2);
+  console.log(item + 2)
 }
 ```
 
@@ -3298,11 +3301,11 @@ for (let item of set) {
 
 #### Answer: C
 
-El operador `+` no solo se usa para sumar valores numéricos, sino que también podemos usarlo para concatenar cadenas. Cada vez que el motor de JavaScript ve que uno o más valores no son un número, coerce el número en una cadena.
+El operador `+` no solo se usa para sumar valores numéricos, sino que también podemos usarlo para concatenar cadenas. Cada vez que el motor de JavaScript ve que uno o más valores no son un número, coerce el número en una cadena. 
 
 El primero es `1`, que es un valor numérico. `1 + 2` devuelve el número 3.
 
-Sin embargo, el segundo es la cadena `"Lydia"`. `"Lydia"` es una cadena y `2` es un número: `2` coerce a una cadena. `"Lydia"` y `"2"` son concatenados, cuyo resultado es la cadena `"Lydia2"`.
+Sin embargo, el segundo es la cadena `"Lydia"`. `"Lydia"` es una cadena y `2` es un número: `2` coerce a una cadena. `"Lydia"` y `"2"` son concatenados, cuyo resultado es la cadena `"Lydia2"`. 
 
 `{ name: "Lydia" }` es un objeto. Ni un número ni un objeto son una cadena, así que se convierten a cadena ambos. Cada vez que convertimos un objeto estandar, se convierte en `"[Object object]"`. `"[Object object]"` concatenado con `"2"` resulta en `"[Object object]2"`.
 
@@ -3314,7 +3317,7 @@ Sin embargo, el segundo es la cadena `"Lydia"`. `"Lydia"` es una cadena y `2` es
 ###### 104. ¿Cuál es el valor?
 
 ```javascript
-Promise.resolve(5);
+Promise.resolve(5)
 ```
 
 - A: `5`
@@ -3329,7 +3332,7 @@ Promise.resolve(5);
 
 Podemos pasar cualquier tipo de valor que queramos a `Promise.resolve`, ya sea una promesa o no promesa. El método en sí mismo devuelve una promesa con el valor resuelto (`<fulfilled>`). Si pasas una función estandar, será una promesa resuelta con un valor normal. Si pasas una promesa, será una promesa resuelta con el valor resuelto de esa promesa pasada.
 
-En este caso, acabamos de pasar el valor numérico `5`. Devuelve una promesa resuelta con el valor `5`.
+En este caso, acabamos de pasar el valor numérico `5`. Devuelve una promesa resuelta con el valor `5`. 
 
 </p>
 </details>
@@ -3341,15 +3344,15 @@ En este caso, acabamos de pasar el valor numérico `5`. Devuelve una promesa res
 ```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);
+compareMembers(person)
 ```
 
 - A: `Not the same!`
@@ -3362,13 +3365,13 @@ compareMembers(person);
 
 #### Answer: B
 
-Los objetos se pasan por referencia. Cuando verificamos la igualdad estricta de los objetos (`===`), estamos comparando sus referencias.
+Los objetos se pasan por referencia. Cuando verificamos la igualdad estricta de los objetos (`===`), estamos comparando sus referencias. 
 
 Establecemos el valor por defecto para `person2` igual al objeto `person`, y pasamos el objeto `person` como el valor de `person1`.
 
 Esto significa que ambos valores tienen una referencia al mismo punto en la memoria, por lo tanto, son iguales.
 
-El bloque de código en la instrucción `else` se ejecuta, y se imprime `They are the same!`.
+El bloque de código en la instrucción `else` se ejecuta, y se imprime `They are the same!`. 
 
 </p>
 </details>
@@ -3384,11 +3387,11 @@ const colorConfig = {
   green: true,
   black: true,
   yellow: false,
-};
+}
 
-const colors = ["pink", "red", "blue"];
+const colors = ["pink", "red", "blue"]
 
-console.log(colorConfig.colors[1]);
+console.log(colorConfig.colors[1])
 ```
 
 - A: `true`
@@ -3401,11 +3404,11 @@ console.log(colorConfig.colors[1]);
 
 #### Answer: D
 
-En JavaScript, tenemos dos formas de acceder a las propiedades de un objeto: notación por corchetes o notación por punto. En este ejemplo, usamos la notación por punto (`colorConfig.colors`) en lugar de la notación por corchetes (`colorConfig["colors"]`).
+En JavaScript, tenemos dos formas de acceder a las propiedades de un objeto: notación por corchetes o notación por punto. En este ejemplo, usamos la notación por punto (`colorConfig.colors`) en lugar de la notación por corchetes (`colorConfig["colors"]`). 
 
 Con la notación por punto, JavaScript intenta encontrar la propiedad en el objeto con ese nombre exacto. En este ejemplo, JavaScript intenta encontrar una propiedad llamada `colors` en el objeto `colorConfig`. No hay propiedad llamada `colors`, por lo que devuelve `undefined`. Luego, intentamos acceder al valor del primer elemento usando `[1]`. No podemos hacer esto en un valor que sea `undefined`, por lo que lanza una expeción `TypeError`: `Cannot read property '1' of undefined`.
 
-JavaScript interpreta (o descompone) las sentencias. Cuando usamos la notación por corchetes, ve el primer corchete de apertura `[` y continúa hasta que encuentra el corchete de cierre `]`. Solo entonces, evaluará la declaración. Si hubiéramos utilizado `colorConfig[colors[1]]`, habría devuelto el valor de la propiedad `red` del objeto `colorConfig`.
+JavaScript interpreta (o descompone) las sentencias. Cuando usamos la notación por corchetes, ve el primer corchete de apertura `[` y continúa hasta que encuentra el corchete de cierre `]`. Solo entonces, evaluará la declaración. Si hubiéramos utilizado `colorConfig[colors[1]]`, habría devuelto el valor de la propiedad `red` del objeto `colorConfig`. 
 
 </p>
 </details>
@@ -3415,7 +3418,7 @@ JavaScript interpreta (o descompone) las sentencias. Cuando usamos la notación
 ###### 107. ¿Cuál es el valor?
 
 ```javascript
-console.log("❤️" === "❤️");
+console.log('❤️' === '❤️')
 ```
 
 - A: `true`
@@ -3426,7 +3429,7 @@ console.log("❤️" === "❤️");
 
 #### Answer: A
 
-Bajo el capó, los emojis son caracteres unicode. Los valores unicode para el emoji del corazón son `"U+2764 U+FE0F"`. Estos son siempre los mismos para los mismos emojis, por lo que estamos comparando dos cadenas iguales entre sí, lo que devuelve verdadero.
+Bajo el capó, los emojis son caracteres unicode. Los valores unicode para el emoji del corazón son `"U+2764 U+FE0F"`. Estos son siempre los mismos para los mismos emojis, por lo que estamos comparando dos cadenas iguales entre sí, lo que devuelve verdadero. 
 
 </p>
 </details>
@@ -3436,19 +3439,19 @@ Bajo el capó, los emojis son caracteres unicode. Los valores unicode para el em
 ###### 108. ¿Cuál de estos métodos modifica el array original?
 
 ```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`
 - B: `map` `reduce` `slice` `splice`
-- C: `map` `slice` `splice`
+- C: `map` `slice` `splice` 
 - D: `splice`
 
 <details><summary><b>Solución</b></summary>
@@ -3456,7 +3459,7 @@ emojis.splice(1, 2, "✨");
 
 #### Answer: D
 
-Con el método `splice`, modificamos el array original eliminando, reemplazando o agregando elementos. En este caso, eliminamos 2 elementos desde el índice 1 (eliminamos `'🥑'` y `'😍'`) y agregamos el emoji ✨ en su lugar.
+Con el método `splice`, modificamos el array original eliminando, reemplazando o agregando elementos. En este caso, eliminamos 2 elementos desde el índice 1 (eliminamos `'🥑'` y `'😍'`) y agregamos el emoji ✨ en su lugar. 
 
 `map`, `filter` y `slice` devuelven un nuevo array, `find` devuelve un elemento, y `reduce` devuelve un valor reducido.
 
@@ -3468,17 +3471,17 @@ Con el método `splice`, modificamos el array original eliminando, reemplazando
 ###### <a name=20191009></a>109. ¿Cuál es el resultado?
 
 ```javascript
-const food = ["🍕", "🍫", "🥑", "🍔"];
-const info = { favoriteFood: food[0] };
+const food = ['🍕', '🍫', '🥑', '🍔']
+const info = { favoriteFood: food[0] }
 
-info.favoriteFood = "🍝";
+info.favoriteFood = '🍝'
 
-console.log(food);
+console.log(food)
 ```
 
 - A: `['🍕', '🍫', '🥑', '🍔']`
 - B: `['🍝', '🍫', '🥑', '🍔']`
-- C: `['🍝', '🍕', '🍫', '🥑', '🍔']`
+- C: `['🍝', '🍕', '🍫', '🥑', '🍔']` 
 - D: `ReferenceError`
 
 <details><summary><b>Solución</b></summary>
@@ -3486,7 +3489,7 @@ console.log(food);
 
 #### Answer: A
 
-Establecemos el valor de la propiedad `favoriteFood` en el objeto` info` igual a la cadena con el emoji de la pizza, `'🍕'`. Una cadena es un tipo de dato primitivo. En JavaScript, los tipos de datos primitivos actúan por referencia
+Establecemos el valor de la propiedad `favoriteFood` en el objeto` info` igual a la cadena con el emoji de la pizza, `'🍕'`. Una cadena es un tipo de dato primitivo. En JavaScript, los tipos de datos primitivos actúan por referencia 
 
 En JavaScript, los tipos de datos primitivos (todo aquello que no es un objeto) interactúan por _valor_. En este caso, establecemos el valor de la propiedad `favoriteFood` en el objeto` info` igual al valor del primer elemento en el array `food`, la cadena del emoji de la pizza en este caso (`'🍕'`). Una cadena es un tipo de datos primitivo e interactúa por valor (consulte mi [artículo](https://www.theavocoder.com/complete-javascript/2018/12/21/by-value-vs-by-reference) si estás interesado en aprender más)
 
@@ -3500,7 +3503,7 @@ Luego, cambiamos el valor de la propiedad `favoriteFood` en el objeto` info`. El
 ###### 110. ¿Qué hace este método?
 
 ```javascript
-JSON.parse();
+JSON.parse()
 ```
 
 - A: Parses JSON to a JavaScript value
@@ -3513,20 +3516,20 @@ JSON.parse();
 
 #### Answer: A
 
-Con el método `JSON.parse()`, podemos convertir la cadena de texto en formato JSON a un valor en JavaScript.
+Con el método `JSON.parse()`, podemos convertir la cadena de texto en formato JSON a un valor en JavaScript. 
 
 ```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
+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]
+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' }
+const jsonArray = JSON.stringify({ name: "Lydia" }) // '{"name":"Lydia"}'
+JSON.parse(jsonArray) // { name: 'Lydia' }
 ```
 
 </p>
@@ -3534,17 +3537,17 @@ JSON.parse(jsonArray); // { name: 'Lydia' }
 
 ---
 
-###### 111. ¿Cuál es el resultado?
+###### 111. ¿Cuál es el resultado? 
 
 ```javascript
-let name = "Lydia";
+let name = 'Lydia'
 
 function getName() {
-  console.log(name);
-  let name = "Sarah";
+  console.log(name)
+  let name = 'Sarah'
 }
 
-getName();
+getName()
 ```
 
 - A: Lydia
@@ -3557,20 +3560,20 @@ getName();
 
 #### Answer: D
 
-Cada función tiene su propio _contexto de ejecución_ (o _ámbito_). La función `getName` primero mira dentro de su propio contexto (ámbito) para ver si contiene la variable `name` a la que estamos intentando acceder. En este caso, la función `getName` contiene su propia variable `name`: declaramos la variable `name` con la palabra clave` let`, y con el valor de `'Sarah'`.
+Cada función tiene su propio _contexto de ejecución_ (o _ámbito_). La función `getName` primero mira dentro de su propio contexto (ámbito) para ver si contiene la variable `name` a la que estamos intentando acceder. En este caso, la función `getName` contiene su propia variable `name`: declaramos la variable `name` con la palabra clave` let`, y con el valor de `'Sarah'`. 
 
-Las variables con la palabra clave `let` (y `const`) se mueven al comienzo (hoisting), pero a diferencia de `var`, no se <i>inicializan</i>. No son accesibles antes de la línea en la que las declaramos (inicializamos). Esto se llama la "zona muerta temporal". Cuando intentamos acceder a las variables antes de que se declaren, JavaScript genera una excepción del tipo `ReferenceError`.
+Las variables con la palabra clave `let` (y `const`) se mueven al comienzo (hoisting), pero a diferencia de `var`, no se <i>inicializan</i>. No son accesibles antes de la línea en la que las declaramos (inicializamos). Esto se llama la "zona muerta temporal". Cuando intentamos acceder a las variables antes de que se declaren, JavaScript genera una excepción del tipo `ReferenceError`. 
 
-Si no hubiéramos declarado la variable `name` dentro de la función `getName`, el motor de JavaScript habría mirado hacia abajo _ámbito encadenado_. El alcance externo tiene una variable llamada `name` con el valor de `Lydia`. En ese caso, habría imprimido `Lydia`.
+Si no hubiéramos declarado la variable `name` dentro de la función `getName`, el motor de JavaScript habría mirado hacia abajo _ámbito encadenado_. El alcance externo tiene una variable llamada `name` con el valor de `Lydia`. En ese caso, habría imprimido `Lydia`. 
 
 ```javascript
-let name = "Lydia";
+let name = 'Lydia'
 
 function getName() {
-  console.log(name);
+  console.log(name)
 }
 
-getName(); // Lydia
+getName() // Lydia
 ```
 
 </p>
@@ -3582,18 +3585,18 @@ 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();
-const two = generatorTwo();
+const one = generatorOne()
+const two = generatorTwo()
 
-console.log(one.next().value);
-console.log(two.next().value);
+console.log(one.next().value)
+console.log(two.next().value)
 ```
 
 - A: `a` y `a`
@@ -3611,17 +3614,17 @@ Con la palabra clave `yield`, cedemos valores en una función generadora. Con la
 En la función `generatorOne`, cedemos todo el array `['a', 'b', 'c']` usando la palabra clave `yield`. El valor de la propiedad `value` en el objeto devuelto por el método `next` en `one` (`one.next().value`) es igual a todo el array `['a', 'b', 'c']`.
 
 ```javascript
-console.log(one.next().value); // ['a', 'b', 'c']
-console.log(one.next().value); // undefined
+console.log(one.next().value) // ['a', 'b', 'c']
+console.log(one.next().value) // undefined
 ```
 
-En la función `generatorTwo`, usamos la palabra clave `yield*`. Esto significa que el primer valor cedido de `two` es igual al primer valor cedido en el iterador. El iterador es el array `['a', 'b', 'c']`. El primer valor producido es `a`, por lo que la primera vez que llamamos a `two.next().value`, se devuelve `a`.
+En la función `generatorTwo`, usamos la palabra clave `yield*`. Esto significa que el primer valor cedido de `two` es igual al primer valor cedido en el iterador. El iterador es el array `['a', 'b', 'c']`. El primer valor producido es `a`, por lo que la primera vez que llamamos a `two.next().value`, se devuelve `a`. 
 
 ```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
+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>
@@ -3632,7 +3635,7 @@ console.log(two.next().value); // undefined
 ###### 113. ¿Cuál es el resultado?
 
 ```javascript
-console.log(`${((x) => x)("I love")} to program`);
+console.log(`${(x => x)('I love')} to program`)
 ```
 
 - A: `I love to program`
@@ -3645,7 +3648,7 @@ console.log(`${((x) => x)("I love")} to program`);
 
 #### Answer: A
 
-Las expresiones dentro de las plantillas de cadena de texto se evalúan primero. Esto significa que la cadena contendrá el valor devuelto de la expresión, la función invocada inmediatamente `(x => x)('I love')` en este caso. Pasamos el valor `'I love'` como argumento para la función de flecha `x => x`. `x` es igual a `'I love'`, que se devuelve tal cual. Esto da como resultado `I love to program`.
+Las expresiones dentro de las plantillas de cadena de texto se evalúan primero. Esto significa que la cadena contendrá el valor devuelto de la expresión, la función invocada inmediatamente `(x => x)('I love')` en este caso. Pasamos el valor `'I love'` como argumento para la función de flecha `x => x`. `x` es igual a `'I love'`, que se devuelve tal cual. Esto da como resultado `I love to program`. 
 
 </p>
 </details>
@@ -3657,11 +3660,11 @@ Las expresiones dentro de las plantillas de cadena de texto se evalúan primero.
 ```javascript
 let config = {
   alert: setInterval(() => {
-    console.log("Alert!");
-  }, 1000),
-};
+    console.log('Alert!')
+  }, 1000)
+}
 
-config = null;
+config = null
 ```
 
 - A: The `setInterval` callback won't be invoked
@@ -3684,17 +3687,17 @@ Normalmente, cuando establecemos objetos iguales a `null`, esos objetos se recog
 ###### 115. ¿Qué método(s) devolverá el valor `'Hello world!'`?
 
 ```javascript
-const myMap = new Map();
-const myFunc = () => "greeting";
+const myMap = new Map()
+const myFunc = () => 'greeting'
 
-myMap.set(myFunc, "Hello world!");
+myMap.set(myFunc, 'Hello world!')
 
 //1
-myMap.get("greeting");
+myMap.get('greeting')
 //2
-myMap.get(myFunc);
+myMap.get(myFunc)
 //3
-myMap.get(() => "greeting");
+myMap.get(() => 'greeting')
 ```
 
 - A: 1
@@ -3707,10 +3710,10 @@ myMap.get(() => "greeting");
 
 #### Answer: B
 
-Al agregar un par clave/valor utilizando el método `set`, la clave será el valor del primer argumento pasado a la función `set`, y el valor será el segundo argumento pasado a la función `set`. La clave es la _función_ `() => 'greeting'` en este caso, y el valor `'Hello world'`. `myMap` ahora es `{ () => 'greeting' => 'Hello world!' }`.
+Al agregar un par clave/valor utilizando el método `set`, la clave será el valor del primer argumento pasado a la función `set`, y el valor será el segundo argumento pasado a la función `set`. La clave es la _función_ `() => 'greeting'` en este caso, y el valor `'Hello world'`. `myMap` ahora es `{ () => 'greeting' => 'Hello world!' }`. 
 
 1 es incorrecto, ya que la clave no es `'greeting'` sino `() => 'greeting'`.
-3 es incorrecto, ya que estamos creando una nueva función pasándola como parámetro al método `get`. El objeto interactúa por _referencia_. Las funciones son objetos, por eso dos funciones nunca son estrictamente iguales, aunque sean idénticas: tienen una referencia a un punto diferente en la memoria.
+3 es incorrecto, ya que estamos creando una nueva función pasándola como parámetro al método `get`. El objeto interactúa por _referencia_. Las funciones son objetos, por eso dos funciones nunca son estrictamente iguales, aunque sean idénticas: tienen una referencia a un punto diferente en la memoria. 
 
 </p>
 </details>
@@ -3722,19 +3725,19 @@ Al agregar un par clave/valor utilizando el método `set`, la clave será el val
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21,
-};
+  age: 21
+}
 
-const changeAge = (x = { ...person }) => (x.age += 1);
+const changeAge = (x = { ...person }) => x.age += 1
 const changeAgeAndName = (x = { ...person }) => {
-  x.age += 1;
-  x.name = "Sarah";
-};
+  x.age += 1
+  x.name = "Sarah"
+}
 
-changeAge(person);
-changeAgeAndName();
+changeAge(person)
+changeAgeAndName()
 
-console.log(person);
+console.log(person)
 ```
 
 - A: `{name: "Sarah", age: 22}`
@@ -3747,7 +3750,7 @@ console.log(person);
 
 #### Answer: C
 
-Tanto las funciones `changeAge` como `changeAgeAndName` tienen un parámetro por defecto, a saber, un objeto _nuevo_ creado `{ ...person }`. Este objeto tiene copias de todos los pares clave/valor en el objeto `person`.
+Tanto las funciones `changeAge` como `changeAgeAndName` tienen un parámetro por defecto, a saber, un objeto _nuevo_ creado `{ ...person }`. Este objeto tiene copias de todos los pares clave/valor en el objeto `person`. 
 
 Primero, invocamos la función `changeAge` y le pasamos el objeto `person` como argumento. Esta función aumenta el valor de la propiedad `age` en 1. `person` ahora es `{name: "Lydia", age: 22}`.
 
diff --git a/fr-FR/README_fr-FR.md b/fr-FR/README_fr-FR.md
index cbdbee30..cce10323 100644
--- a/fr-FR/README_fr-FR.md
+++ b/fr-FR/README_fr-FR.md
@@ -19,7 +19,6 @@ Les réponses se trouvent dans les sections repliées en dessous des questions,
 - [🇳🇱 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)
@@ -101,7 +100,7 @@ const shape = {
   diameter() {
     return this.radius * 2;
   },
-  perimeter: () => 2 * Math.PI * this.radius,
+  perimeter: () => 2 * Math.PI * this.radius
 };
 
 shape.diameter();
@@ -158,12 +157,12 @@ La chaîne de caractère `'Lydia'` est une valeur considérée comme vraie _(tru
 
 ```javascript
 const bird = {
-  size: "small",
+  size: "small"
 };
 
 const mouse = {
   name: "Mickey",
-  small: true,
+  small: true
 };
 ```
 
@@ -359,7 +358,7 @@ function Person(firstName, lastName) {
 }
 
 const member = new Person("Lydia", "Hallie");
-Person.getFullName = function () {
+Person.getFullName = function() {
   return `${this.firstName} ${this.lastName}`;
 };
 
@@ -379,7 +378,7 @@ console.log(member.getFullName());
 Vous ne pouvez pas ajouter de propriétés à un constructeur comme pour des objets normaux. Si vous voulez ajouter une fonctionnalité pour tous les objets en une fois, vous devez utiliser le prototype. Donc dans ce cas,
 
 ```js
-Person.prototype.getFullName = function () {
+Person.prototype.getFullName = function() {
   return `${this.firstName} ${this.lastName}`;
 };
 ```
@@ -835,7 +834,7 @@ String.prototype.giveLydiaPizza = () => {
 
 const name = "Lydia";
 
-console.log(name.giveLydiaPizza());
+console.log(name.giveLydiaPizza())
 ```
 
 - A: `"Just give Lydia pizza already!"`
@@ -947,7 +946,9 @@ C'est ici qu'une boucle d'événement commence à fonctionner. La **boucle d'év
 ```html
 <div onclick="console.log('first div')">
   <div onclick="console.log('second div')">
-    <button onclick="console.log('button')">Click!</button>
+    <button onclick="console.log('button')">
+      Click!
+    </button>
   </div>
 </div>
 ```
@@ -973,7 +974,9 @@ L'élément imbriqué le plus profond qui a provoqué l'événement est la cible
 
 ```html
 <div onclick="console.log('div')">
-  <p onclick="console.log('p')">Click here!</p>
+  <p onclick="console.log('p')">
+    Click here!
+  </p>
 </div>
 ```
 
@@ -1198,7 +1201,7 @@ JavaScript n'a que des types et des objets primitifs.
 
 Les types primitifs sont `boolean`, `null`, `undefined`, `bigint`, `number`, `string` et `symbol`.
 
-Ce qui différencie une primitive d'un objet, c'est que les primitives n'ont aucune propriété ou méthode. Cependant, vous remarquerez que `'foo'.toUpperCase()` est évalué à `'FOO'` et n'entraîne pas de `TypeError`. En effet, lorsque vous essayez d'accéder à une propriété ou à une méthode sur une primitive telle qu'une chaîne, JavaScript encapsule implicitement l'objet à l'aide de l'une des classes d'encapsulation, à savoir `String`, puis supprime immédiatement l'encapsulation après l'évaluation de l'expression. Toutes les primitives à l'exception de `null` et` undefined` présentent ce comportement.
+Ce qui différencie une primitive d'un objet, c'est que les primitives n'ont aucune propriété ou méthode. Cependant, vous remarquerez que  `'foo'.toUpperCase()` est évalué à `'FOO'` et n'entraîne pas de `TypeError`. En effet, lorsque vous essayez d'accéder à une propriété ou à une méthode sur une primitive telle qu'une chaîne, JavaScript encapsule implicitement l'objet à l'aide de l'une des classes d'encapsulation, à savoir `String`, puis supprime immédiatement l'encapsulation après l'évaluation de l'expression. Toutes les primitives à l'exception de `null` et` undefined` présentent ce comportement.
 
 </p>
 </details>
@@ -1208,10 +1211,7 @@ Ce qui différencie une primitive d'un objet, c'est que les primitives n'ont auc
 ###### 40. Quelle est la sortie ?
 
 ```javascript
-[
-  [0, 1],
-  [2, 3],
-].reduce(
+[[0, 1], [2, 3]].reduce(
   (acc, cur) => {
     return acc.concat(cur);
   },
@@ -1359,7 +1359,7 @@ const secondPromise = new Promise((res, rej) => {
   setTimeout(res, 100, "two");
 });
 
-Promise.race([firstPromise, secondPromise]).then((res) => console.log(res));
+Promise.race([firstPromise, secondPromise]).then(res => console.log(res));
 ```
 
 - A: `"one"`
@@ -1423,7 +1423,7 @@ Nous modifions seulement la valeur de la variable `person`, et non le premier é
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21,
+  age: 21
 };
 
 for (const item in person) {
@@ -1503,7 +1503,7 @@ Seuls les premiers nombres de la chaîne sont renvoyés. Basé sur la base dix (
 ###### 50. Quelle est la sortie ?
 
 ```javascript
-[1, 2, 3].map((num) => {
+[1, 2, 3].map(num => {
   if (typeof num === "number") return;
   return num * 2;
 });
@@ -1680,7 +1680,7 @@ class Dog {
   }
 }
 
-Dog.prototype.bark = function () {
+Dog.prototype.bark = function() {
   console.log(`Woof I am ${this.name}`);
 };
 
@@ -1908,7 +1908,7 @@ Les propriétés ajoutées à l'aide de la méthode `defineProperty` sont immuab
 const settings = {
   username: "lydiahallie",
   level: 19,
-  health: 90,
+  health: 90
 };
 
 const data = JSON.stringify(settings, ["level", "health"]);
@@ -1942,7 +1942,7 @@ Si le remplaçant est une _fonction_, cette fonction est appelée sur chaque pro
 let num = 10;
 
 const increaseNumber = () => num++;
-const increasePassedNumber = (number) => number++;
+const increasePassedNumber = number => number++;
 
 const num1 = increaseNumber();
 const num2 = increasePassedNumber(num1);
@@ -1963,7 +1963,7 @@ console.log(num2);
 
 L'opérateur arithmétique `++` _renvoie en premier_ la valeur de l'opérande, _puis incrémente_ la valeur de l'opérande. La valeur de `num1` est égale à `10`, puisque la fonction `increaseNumber` renvoie d'abord la valeur de `num`, qui correspond à `10`, et augmente la valeur de `num` par la suite.
 
-`num2` est égal à `10`, puisque nous avons passé `num1` à la commande `increasePassedNumber`. `number` est égal à `10` (la valeur de `num1`). Encore une fois, l'opérateur arithmétique `++` _renvoie d'abord_ la valeur de l'opérande, puis incrémente\_ la valeur de l'opérande. La valeur de `nombre` est `10`, donc `num2` est égal à `10`.
+`num2` est égal à `10`, puisque nous avons passé `num1` à la commande `increasePassedNumber`. `number` est égal à `10` (la valeur de `num1`). Encore une fois, l'opérateur arithmétique `++` _renvoie d'abord_ la valeur de l'opérande, puis incrémente_ la valeur de l'opérande. La valeur de `nombre` est `10`, donc `num2` est égal à `10`.
 
 </p>
 </details>
@@ -1997,7 +1997,7 @@ multiply(value);
 
 Dans ES6, nous pouvons initialiser les paramètres avec une valeur par défaut. La valeur du paramètre sera la valeur par défaut, si aucune autre valeur n'a été passée à la fonction, ou si la valeur du paramètre est `"undefined"`. Dans ce cas, nous répartissons les propriétés de l'objet `value` dans un nouvel objet, donc `x` a la valeur par défaut `{number: 10}`.
 
-L'argument par défaut est évalué at _call time_! Chaque fois que nous appelons la fonction, un a _new_ object créé. Nous invoquons la fonction `multiply` les deux premières fois sans passer de valeur: `x` a la valeur par défaut `{number: 10}`. Nous enregistrons ensuite la valeur multipliée de ce nombre, qui est `20`.
+L'argument par défaut est évalué at _call time_! Chaque fois que nous appelons la fonction, un a _new_ object  créé. Nous invoquons la fonction `multiply` les deux premières fois sans passer de valeur: `x` a la valeur par défaut `{number: 10}`. Nous enregistrons ensuite la valeur multipliée de ce nombre, qui est `20`.
 
 La troisième fois que nous invoquons multiplier, nous passons un argument: l'objet appelé `value`. L'opérateur `* =` est en fait un raccourci pour `x.number = x.number * 2`: nous modifions la valeur de `x.number`, et enregistrons la valeur multipliée `20`.
 
diff --git a/id-ID/README.md b/id-ID/README.md
index 3da87c42..26a566cc 100644
--- a/id-ID/README.md
+++ b/id-ID/README.md
@@ -1,10 +1,10 @@
 <h1>Pertanyaan JavaScript</h1>
 
----
+  ---
 
-<span>Saya post pertanyaan pilihan ganda ke [Instagram](https://www.instagram.com/theavocoder) **stories** saya, yang saya post juga di sini ! update terakhir: <a href=#20191224><b>December 24th</b></a>
+  <span>Saya post pertanyaan pilihan ganda ke [Instagram](https://www.instagram.com/theavocoder) **stories** saya, yang saya post juga di sini ! update terakhir: <a href=#20191224><b>December 24th</b></a>
 
-Mulai tingkat dasar ke mahir: tes seberapa paham kamu tentang javascript, segarkan sedikit pengetahuan kamu, atau bersiap-siap untuk coding interview kamu! :muscle: :rocket: Saya update repo ini secara berkala dengan pertanyaan baru. Saya masukkan jawaban dibagian yang **tersembunyi** di bawah pertanyaan, cukup klik pada bagian itu untuk menampilkannya. Pertanyaan ini hanya untuk bersenang-senang, Semoga berhasil :heart:</span>
+  Mulai tingkat dasar ke mahir: tes seberapa paham kamu tentang javascript, segarkan sedikit pengetahuan kamu, atau bersiap-siap untuk coding interview kamu! :muscle: :rocket: Saya update repo ini secara berkala dengan pertanyaan baru. Saya masukkan jawaban dibagian yang **tersembunyi** di bawah pertanyaan, cukup klik pada bagian itu untuk menampilkannya. Pertanyaan ini hanya untuk bersenang-senang, Semoga berhasil :heart:</span>
 
 Jangan sungkan untuk terhubung dengan saya! 😊 <br />
 <a href="https://www.instagram.com/theavocoder">Instagram</a> || <a href="https://www.twitter.com/lydiahallie">Twitter</a> || <a href="https:/www.linkedin.com/in/lydia-hallie">LinkedIn</a> || <a href="www.lydiahallie.dev">Blog</a>
@@ -29,7 +29,6 @@ Jangan sungkan untuk terhubung dengan saya! 😊 <br />
 - [🇳🇱 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)
@@ -50,7 +49,7 @@ Jangan sungkan untuk terhubung dengan saya! 😊 <br />
 function sayHi() {
   console.log(name);
   console.log(age);
-  var name = "Lydia";
+  var name = 'Lydia';
   let age = 21;
 }
 
@@ -70,7 +69,6 @@ sayHi();
 Di dalam function, kita membuat sebuah variabel `name` dan variabel tersebut di deklarasikan menggunakan `var`. Artinya variable tersebut di hoisting (dalam fase pembuatan ini menggunakan memory penyimpanan) dengan isi standar-nya `undefined`, saat javascript mengeksekusi baris code pembuatan variabel-nya. variabel `name` isinya masih undefined, jadi isi dari variabel tersebut `undefined`
 
 Mendeklarasikan varibel menggunakan `let` (dan `const`) juga terkena hoisting, tidak seperti `var`, variabel declaration `let` dan `const` tidak ditentukan isi standar-nya. `let` dan `const` tidak bisa diakses sebelum di tentukan dulu isi-nya. Kejadian ini disebut "temporal dead zone". Saat kita mencoba memanggil variabel yang belum ditentukan isi-nya, Javascript mengeluarkan error `ReferenceError`.
-
 </p>
 </details>
 
@@ -97,10 +95,9 @@ for (let i = 0; i < 3; i++) {
 
 #### Jawaban: C
 
-Karena antrean peristiwa di JavaScript, fungsi callback `setTimeout` disebut _after_ loop telah dijalankan. Karena variabel `i` di loop pertama dideklarasikan menggunakan kata kunci` var`, nilai ini adalah global. Selama perulangan, kita menambah nilai `i` sebesar `1` setiap kali, menggunakan operator unary`++`. Pada saat fungsi callback `setTimeout` dipanggil,` i` sama dengan `3` di contoh pertama.
+Karena antrean peristiwa di JavaScript, fungsi callback `setTimeout` disebut _after_ loop telah dijalankan. Karena variabel `i` di loop pertama dideklarasikan menggunakan kata kunci` var`, nilai ini adalah global. Selama perulangan, kita menambah nilai `i` sebesar `1` setiap kali, menggunakan operator unary` ++ `. Pada saat fungsi callback `setTimeout` dipanggil,` i` sama dengan `3` di contoh pertama.
 
 Pada perulangan kedua, variabel `i` dideklarasikan menggunakan kata kunci` let`: variabel yang dideklarasikan dengan kata kunci `let` (dan` const`) memiliki cakupan blok (blok adalah apa saja di antara `{}`). Selama setiap iterasi, `i` akan memiliki nilai baru, dan setiap nilai dicakup di dalam loop.
-
 </p>
 </details>
 
@@ -146,7 +143,7 @@ Tidak ada nilai 'radius' pada objek itu, yang mengembalikan 'tidak ditentukan'.
 
 ```javascript
 +true;
-!"Lydia";
+!'Lydia';
 ```
 
 - A: `1` dan `false`
@@ -160,7 +157,8 @@ Tidak ada nilai 'radius' pada objek itu, yang mengembalikan 'tidak ditentukan'.
 
 Tia unary plus mencoba mengonversi operan menjadi angka. `true` adalah` 1`, dan `false` adalah` 0`.
 
-String "'Lydia'`adalah nilai yang benar. Apa yang sebenarnya kami tanyakan adalah "apakah nilai kebenaran ini salah?". Ini mengembalikan`salah`.
+String "'Lydia'` adalah nilai yang benar. Apa yang sebenarnya kami tanyakan adalah "apakah nilai kebenaran ini salah?". Ini mengembalikan `salah`.
+
 
 </p>
 </details>
@@ -171,11 +169,11 @@ String "'Lydia'`adalah nilai yang benar. Apa yang sebenarnya kami tanyakan adala
 
 ```javascript
 const bird = {
-  size: "small",
+  size: 'small',
 };
 
 const mouse = {
-  name: "Mickey",
+  name: 'Mickey',
   small: true,
 };
 ```
@@ -189,7 +187,6 @@ const mouse = {
 <p>
 
 #### Jawaban: A
-
 Pada JavaScript, semua kunci objek adalah string (kecuali jika itu berupa Simbol). Meskipun kita mungkin tidak mengetiknya sebagai string, tetap saja mereka selalu berubah menjadi string didalamnya.
 
 JavaScript menginterpretasikan (atau membuka) pernyataan-pernyataan. Saat kita menggunakan notasi kurung siku, ia melihat kurung buka pertama `[` dan terus berjalan sampai menemukan kurung tutup `]`. Baru setelah itu akan mengevaluasi pernyataannya. `mouse[bird.size]`: Pertama, ini mengevaluasi `bird.size`, yang mana `"small"`. `mouse["small"]` mengembalikan nilai `true`.
@@ -204,11 +201,11 @@ Namun, dengan notasi dot (.), hal ini tidak terjadi. `mouse` tidak memiliki kunc
 ###### 6. Apa yang akan tampil?
 
 ```javascript
-let c = { greeting: "Hey!" };
+let c = { greeting: 'Hey!' };
 let d;
 
 d = c;
-c.greeting = "Hello";
+c.greeting = 'Hello';
 console.log(d.greeting);
 ```
 
@@ -278,13 +275,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`
@@ -334,10 +331,10 @@ Untuk menghindari hal ini, kita bisa menggunakan `" use strict "`. Ini memastika
 
 ```javascript
 function bark() {
-  console.log("Woof!");
+  console.log('Woof!');
 }
 
-bark.animal = "dog";
+bark.animal = 'dog';
 ```
 
 - A: Nothing, this is totally fine!
@@ -367,8 +364,8 @@ function Person(firstName, lastName) {
   this.lastName = lastName;
 }
 
-const member = new Person("Lydia", "Hallie");
-Person.getFullName = function () {
+const member = new Person('Lydia', 'Hallie');
+Person.getFullName = function() {
   return `${this.firstName} ${this.lastName}`;
 };
 
@@ -388,7 +385,7 @@ console.log(member.getFullName());
 Anda tidak dapat menambahkan properti ke constructor seperti yang Anda lakukan dengan objek biasa. Jika Anda ingin menambahkan fitur ke semua objek sekaligus, Anda harus menggunakan prototipe sebagai gantinya. Jadi dalam kasus ini:
 
 ```js
-Person.prototype.getFullName = function () {
+Person.prototype.getFullName = function() {
   return `${this.firstName} ${this.lastName}`;
 };
 ```
@@ -408,8 +405,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);
@@ -479,7 +476,7 @@ function sum(a, b) {
   return a + b;
 }
 
-sum(1, "2");
+sum(1, '2');
 ```
 
 - A: `NaN`
@@ -546,7 +543,7 @@ function getPersonInfo(one, two, three) {
   console.log(three);
 }
 
-const person = "Lydia";
+const person = 'Lydia';
 const age = 21;
 
 getPersonInfo`${person} is ${age} years old`;
@@ -573,9 +570,9 @@ Jika Anda menggunakan literal template yang diberi tag, nilai argumen pertama se
 ```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`);
   }
@@ -635,7 +632,7 @@ Parameter sisanya (`... args`.) Memungkinkan kita "mengumpulkan" semua argumen y
 
 ```javascript
 function getAge() {
-  "use strict";
+  'use strict';
   age = 21;
   console.log(age);
 }
@@ -663,7 +660,7 @@ Dengan `" use strict "`, Anda dapat memastikan bahwa Anda tidak mendeklarasikan
 ###### 21. What's value of `sum`?
 
 ```javascript
-const sum = eval("10*10+5");
+const sum = eval('10*10+5');
 ```
 
 - A: `105`
@@ -686,7 +683,7 @@ const sum = eval("10*10+5");
 ###### 22. Sampai berapa lama kah cool_secret dapat diakses?
 
 ```javascript
-sessionStorage.setItem("cool_secret", 123);
+sessionStorage.setItem('cool_secret', 123);
 ```
 
 - A: Selamanya, data tersebut tidak akan hilang.
@@ -739,12 +736,12 @@ Anda tidak dapat melakukan ini dengan `let` atau `const` karena mereka block-sco
 ###### 24. Apa yang akan tampil?
 
 ```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);
 ```
 
@@ -770,7 +767,7 @@ It doesn't work that way for a set. There is no `'1'` in our set: `set.has('1')`
 ###### 25. Apa yang akan tampil?
 
 ```javascript
-const obj = { a: "one", b: "two", a: "three" };
+const obj = { a: 'one', b: 'two', a: 'three' };
 console.log(obj);
 ```
 
@@ -839,12 +836,12 @@ Pernyataan `continue` melewatkan iterasi jika kondisi tertentu mengembalikan `tr
 
 ```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());
+console.log(name.giveLydiaPizza())
 ```
 
 - A: `"Just give Lydia pizza already!"`
@@ -868,8 +865,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;
@@ -901,9 +898,9 @@ Then, we log `a[b]`, which is actually `a["object Object"]`. We just set that to
 ###### 30. Apa yang akan tampil?
 
 ```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();
@@ -956,7 +953,9 @@ Di sinilah serangkaian acara mulai bekerja. Sebuah **event loop** (putaran kejad
 ```html
 <div onclick="console.log('first div')">
   <div onclick="console.log('second div')">
-    <button onclick="console.log('button')">Click!</button>
+    <button onclick="console.log('button')">
+      Click!
+    </button>
   </div>
 </div>
 ```
@@ -982,7 +981,9 @@ The deepest nested element that caused the event is the target of the event. You
 
 ```html
 <div onclick="console.log('div')">
-  <p onclick="console.log('p')">Click here!</p>
+  <p onclick="console.log('p')">
+    Click here!
+  </p>
 </div>
 ```
 
@@ -1006,7 +1007,7 @@ If we click `p`, we see two logs: `p` and `div`. During event propagation, there
 ###### 33. Apa yang akan tampil?
 
 ```javascript
-const person = { name: "Lydia" };
+const person = { name: 'Lydia' };
 
 function sayHi(age) {
   return `${this.name} is ${age}`;
@@ -1069,8 +1070,8 @@ FYI: there are only 7 built-in types: `null`, `undefined`, `boolean`, `number`,
 ```javascript
 0;
 new Number(0);
-("");
-(" ");
+('');
+(' ');
 new Boolean(false);
 undefined;
 ```
@@ -1217,14 +1218,11 @@ What differentiates a primitive from an object is that primitives do not have an
 ###### 40. Apa yang akan tampil?
 
 ```javascript
-[
-  [0, 1],
-  [2, 3],
-].reduce(
+[[0, 1], [2, 3]].reduce(
   (acc, cur) => {
     return acc.concat(cur);
   },
-  [1, 2]
+  [1, 2],
 );
 ```
 
@@ -1251,7 +1249,7 @@ Then, `[1, 2, 0, 1]` is `acc` and `[2, 3]` is `cur`. We concatenate them, and ge
 
 ```javascript
 !!null;
-!!"";
+!!'';
 !!1;
 ```
 
@@ -1279,7 +1277,7 @@ Then, `[1, 2, 0, 1]` is `acc` and `[2, 3]` is `cur`. We concatenate them, and ge
 ###### 42. What does the `setInterval` method return in the browser?
 
 ```javascript
-setInterval(() => console.log("Hi"), 1000);
+setInterval(() => console.log('Hi'), 1000);
 ```
 
 - A: a unique id
@@ -1302,7 +1300,7 @@ Itu adalah mengembalikan sebuah id unik. id unik dapat digunakan untuk menghapus
 ###### 43. What does this return?
 
 ```javascript
-[..."Lydia"];
+[...'Lydia'];
 ```
 
 - A: `["L", "y", "d", "i", "a"]`
@@ -1361,14 +1359,14 @@ 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));
+Promise.race([firstPromise, secondPromise]).then(res => console.log(res));
 ```
 
 - A: `"one"`
@@ -1391,7 +1389,7 @@ When we pass multiple promises to the `Promise.race` method, it resolves/rejects
 ###### 46. Apa yang akan tampil?
 
 ```javascript
-let person = { name: "Lydia" };
+let person = { name: 'Lydia' };
 const members = [person];
 person = null;
 
@@ -1431,7 +1429,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,
 };
 
@@ -1460,7 +1458,7 @@ With a `for-in` loop, we can iterate through object keys, in this case `name` an
 ###### 48. Apa yang akan tampil?
 
 ```javascript
-console.log(3 + 4 + "5");
+console.log(3 + 4 + '5');
 ```
 
 - A: `"345"`
@@ -1487,7 +1485,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`
@@ -1512,8 +1510,8 @@ Only the first numbers in the string is returned. Based on the _radix_ (the seco
 ###### 50. What's the output`?
 
 ```javascript
-[1, 2, 3].map((num) => {
-  if (typeof num === "number") return;
+[1, 2, 3].map(num => {
+  if (typeof num === 'number') return;
   return num * 2;
 });
 ```
@@ -1541,12 +1539,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);
 
@@ -1578,15 +1576,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);
   }
 }
 
@@ -1616,8 +1614,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();
@@ -1689,11 +1687,11 @@ class Dog {
   }
 }
 
-Dog.prototype.bark = function () {
+Dog.prototype.bark = function() {
   console.log(`Woof I am ${this.name}`);
 };
 
-const pet = new Dog("Mara");
+const pet = new Dog('Mara');
 
 pet.bark();
 
@@ -1758,7 +1756,7 @@ export default counter;
 
 ```javascript
 // index.js
-import myCounter from "./counter";
+import myCounter from './counter';
 
 myCounter += 1;
 
@@ -1779,6 +1777,7 @@ Modul yang diimpor adalah _read-only_: Anda tidak dapat mengubah modul yang diim
 
 Ketika kita mencoba untuk menambah nilai `myCounter`, itu melemparkan kesalahan: `myCounter` adalah baca-saja dan tidak dapat dimodifikasi.
 
+
 </p>
 </details>
 
@@ -1787,7 +1786,7 @@ Ketika kita mencoba untuk menambah nilai `myCounter`, itu melemparkan kesalahan:
 ###### 58. Apa yang akan tampil?
 
 ```javascript
-const name = "Lydia";
+const name = 'Lydia';
 age = 21;
 
 console.log(delete name);
@@ -1858,7 +1857,7 @@ This means that the value of `y` is equal to the first value in the array, which
 ###### 60. Apa yang akan tampil?
 
 ```javascript
-const user = { name: "Lydia", age: 21 };
+const user = { name: 'Lydia', age: 21 };
 const admin = { admin: true, ...user };
 
 console.log(admin);
@@ -1884,9 +1883,9 @@ It's possible to combine objects using the spread operator `...`. It lets you cr
 ###### 61. Apa yang akan tampil?
 
 ```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));
@@ -1915,12 +1914,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);
 ```
 
@@ -1951,7 +1950,7 @@ If the replacer is a _function_, this function gets called on every property in
 let num = 10;
 
 const increaseNumber = () => num++;
-const increasePassedNumber = (number) => number++;
+const increasePassedNumber = number => number++;
 
 const num1 = increaseNumber();
 const num2 = increasePassedNumber(num1);
@@ -2107,12 +2106,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;
 ```
 
@@ -2140,7 +2139,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`
@@ -2163,7 +2162,7 @@ Every Symbol is entirely unique. The purpose of the argument passed to the Symbo
 ###### 69. Apa yang akan tampil?
 
 ```javascript
-const name = "Lydia Hallie";
+const name = 'Lydia Hallie';
 console.log(name.padStart(13));
 console.log(name.padStart(2));
 ```
@@ -2190,7 +2189,7 @@ If the argument passed to the `padStart` method is smaller than the length of th
 ###### 70. Apa yang akan tampil?
 
 ```javascript
-console.log("🥑" + "💻");
+console.log('🥑' + '💻');
 ```
 
 - A: `"🥑💻"`
@@ -2214,11 +2213,11 @@ With the `+` operator, you can concatenate strings. In this case, we are concate
 
 ```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 gone here";
   }
-  return "JavaScript loves you back ❤️";
+  return 'JavaScript loves you back ❤️';
 }
 
 const game = startGame();
@@ -2286,7 +2285,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();
@@ -2323,7 +2322,7 @@ function addToList(item, list) {
   return list.push(item);
 }
 
-const result = addToList("apple", ["banana"]);
+const result = addToList('apple', ['banana']);
 console.log(result);
 ```
 
@@ -2383,7 +2382,7 @@ Since `shape` is frozen, and since the value of `x` is not an object, we cannot
 ###### 76. Apa yang akan tampil?
 
 ```javascript
-const { name: myName } = { name: "Lydia" };
+const { name: myName } = { name: 'Lydia' };
 
 console.log(name);
 ```
@@ -2439,7 +2438,7 @@ The `sum` function always returns the same result. If we pass `1` and `2`, it wi
 ```javascript
 const add = () => {
   const cache = {};
-  return (num) => {
+  return num => {
     if (num in cache) {
       return `From cache! ${cache[num]}`;
     } else {
@@ -2484,7 +2483,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);
@@ -2580,13 +2579,13 @@ Pada kasus ini, juka kita tidak mengisi nilai atau mengisi `undefined`, `name` a
 ###### 82. What is the output?
 
 ```javascript
-var status = "😎";
+var status = '😎';
 
 setTimeout(() => {
-  const status = "😍";
+  const status = '😍';
 
   const data = {
-    status: "🥑",
+    status: '🥑',
     getStatus() {
       return this.status;
     },
@@ -2620,12 +2619,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);
 ```
@@ -2689,9 +2688,9 @@ Variables with the `const` and `let` keyword are _block-scoped_. A block is anyt
 ###### 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));
+fetch('https://www.website.com/api/user/1')
+        .then(res => res.json())
+        .then(res => console.log(res))
 ```
 
 - A: The result of the `fetch` method.
@@ -2745,7 +2744,7 @@ By setting `hasName` equal to `name`, you set `hasName` equal to whatever value
 ###### 87. Apa yang akan tampil?
 
 ```javascript
-console.log("I want pizza"[0]);
+console.log('I want pizza'[0]);
 ```
 
 - A: `"""`
@@ -2800,11 +2799,11 @@ If you're trying to set a default parameter's value equal to a parameter which i
 
 ```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);
 ```
@@ -2837,7 +2836,7 @@ class Person {
   }
 }
 
-const member = new Person("John");
+const member = new Person('John');
 console.log(typeof member);
 ```
 
@@ -2897,7 +2896,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 = () =>
@@ -2928,7 +2927,7 @@ Regular functions, such as the `giveLydiaPizza` function, have a `prototype` pro
 
 ```javascript
 const person = {
-  name: "Lydia",
+  name: 'Lydia',
   age: 21,
 };
 
@@ -2988,7 +2987,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' ]`
@@ -3002,8 +3001,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;
 }
@@ -3043,13 +3042,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';
   }
 };
 
@@ -3078,7 +3077,7 @@ Kita dapat mengatur kelas yang sama dengan kelas / fungsi konstruktor lainnya. D
 
 ```javascript
 const info = {
-  [Symbol("a")]: "b",
+  [Symbol('a')]: 'b',
 };
 
 console.log(info);
@@ -3097,7 +3096,7 @@ console.log(Object.keys(info));
 
 Simbol bukanlah merupakan suatu _enumerable_. Metode Object.keys akan mengembalikan semua properti kunci _enumerable_ pada sebuah objek. Simbol tidak akan terlihat, dan array kosong dikembalikan. Saat mencatat seluruh objek, semua properti akan terlihat, bahkan yang bukan non-enumerable.
 
-Ini adalah salah satu dari banyak kualitas simbol: Disamping selain mewakili nilai yang sepenuhnya unik (yang mencegah terjadinya benturan nama yang tidak disengaja pada objek, misalnya saat bekerja dengan 2 library yang ingin menambahkan properti ke objek yang sama), anda juga dapat "menyembunyikan" properti pada objek dengan cara ini (meskipun tidak seluruhnya. Anda masih dapat mengakses simbol menggunakan metode `Object.getOwnPropertySymbols()`).
+Ini adalah salah satu dari banyak kualitas simbol: Disamping selain mewakili nilai yang sepenuhnya unik  (yang mencegah terjadinya benturan nama yang tidak disengaja pada objek, misalnya saat bekerja dengan 2 library yang ingin menambahkan properti ke objek yang sama),  anda juga dapat "menyembunyikan"  properti pada objek dengan cara ini (meskipun tidak seluruhnya. Anda masih dapat mengakses simbol menggunakan metode `Object.getOwnPropertySymbols()`).
 
 </p>
 </details>
@@ -3131,7 +3130,7 @@ Fungsi `getList` menerima array sebagai argumennya. Di antara tanda kurung pada
 
 `[x, ...y] = [1, 2, 3, 4]`
 
-Dengan parameter sisa `...y`, kita akan meletakkan semua argumen "yang tersisa" dalam array. Dalam kasus ini argumen yang tersisa adalah `2`, `3` dan `4`. Nilai dari `y` merupakan suatu array, yang berisi semua parameter lainnya. Pada kasus ini nilai dari `x` sama dengan `1`, jadi saat kita mencatat `[x, y]`, maka catatannya `[1, [2, 3, 4]]`.
+Dengan parameter sisa `...y`, kita akan meletakkan semua argumen "yang tersisa" dalam array. Dalam kasus ini argumen yang tersisa adalah `2`, `3` dan `4`. Nilai dari `y` merupakan suatu array, yang berisi semua parameter lainnya. Pada kasus ini nilai dari `x` sama dengan `1`, jadi saat kita mencatat `[x, y]`,  maka catatannya `[1, [2, 3, 4]]`.
 
 Fungsi `getUser` menerima sebuah objek. Dengan fungsi tanda panah, kita tidak _perlu_ menulis tanda kurung kurawal jika hanya mengembalikan satu nilai. Namun, jika anda mengembalikan nilai _object_ dari fungsi tanda panah, Anda harus menuliskannya di antara tanda kurung, jika tidak maka tidak ada nilai yang dikembalikan! Fungsi berikut akan mengembalikan sebuah objek:
 
@@ -3147,7 +3146,7 @@ Karena tidak ada nilai yang dikembalikan dalam kasus ini, maka fungsi akan menge
 ###### 99. Apa yang akan tampil?
 
 ```javascript
-const name = "Lydia";
+const name = 'Lydia';
 
 console.log(name());
 ```
@@ -3179,8 +3178,8 @@ ReferenceErrors muncul ketika JavaScript tidak dapat menemukan nilai referensi k
 ```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`
@@ -3206,7 +3205,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);
@@ -3238,16 +3237,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");
+  myPromise().then(res => console.log(res));
+  console.log('second');
 }
 
 async function secondFunction() {
   console.log(await myPromise());
-  console.log("second");
+  console.log('second');
 }
 
 firstFunction();
@@ -3285,8 +3284,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);
@@ -3346,13 +3345,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);
 ```
@@ -3391,7 +3390,7 @@ const colorConfig = {
   yellow: false,
 };
 
-const colors = ["pink", "red", "blue"];
+const colors = ['pink', 'red', 'blue'];
 
 console.log(colorConfig.colors[1]);
 ```
@@ -3420,7 +3419,7 @@ JavaScript interprets (or unboxes) statements. When we use bracket notation, it
 ###### 107. Apakah hasil nilai dibawah ini ?
 
 ```javascript
-console.log("❤️" === "❤️");
+console.log('❤️' === '❤️');
 ```
 
 - A: `true`
@@ -3473,10 +3472,10 @@ Metode `splice`, akan memodifikasi array aslinya dengan cara menghapus, menggant
 ###### <a name=20191009></a>109. Apa yang akan tampil?
 
 ```javascript
-const food = ["🍕", "🍫", "🥑", "🍔"];
+const food = ['🍕', '🍫', '🥑', '🍔'];
 const info = { favoriteFood: food[0] };
 
-info.favoriteFood = "🍝";
+info.favoriteFood = '🍝';
 
 console.log(food);
 ```
@@ -3530,7 +3529,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' }
 ```
 
@@ -3542,11 +3541,11 @@ JSON.parse(jsonArray); // { name: 'Lydia' }
 ###### 111. Apa yang akan tampil?
 
 ```javascript
-let name = "Lydia";
+let name = 'Lydia';
 
 function getName() {
   console.log(name);
-  let name = "Sarah";
+  let name = 'Sarah';
 }
 
 getName();
@@ -3569,7 +3568,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);
@@ -3587,11 +3586,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();
@@ -3637,7 +3636,7 @@ console.log(two.next().value); // undefined
 ###### 113. Apa yang akan tampil?
 
 ```javascript
-console.log(`${((x) => x)("I love")} to program`);
+console.log(`${(x => x)('I love')} to program`);
 ```
 
 - A: `I love to program`
@@ -3662,7 +3661,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),
 };
 
@@ -3690,16 +3689,16 @@ Normally when we set objects equal to `null`, those objects get _garbage collect
 
 ```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
@@ -3726,14 +3725,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);
@@ -3792,7 +3791,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)]);
 ```
@@ -3818,11 +3817,11 @@ With the `+=` operand, we're incrementing the value of `num` by `1`. `num` had t
 
 ```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}`;
@@ -3860,10 +3859,10 @@ With the optional chaining operator `?.`, we no longer have to explicitly check
 ###### 120. Apa yang akan tampil?
 
 ```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!`);
 }
@@ -3919,10 +3918,10 @@ The `language` method is a `setter`. Setters don't hold an actual value, their p
 ###### 122. Apa yang akan tampil?
 
 ```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`
@@ -3947,7 +3946,7 @@ console.log(!typeof name === "string");
 ###### 123. Apa yang akan tampil?
 
 ```javascript
-const add = (x) => (y) => (z) => {
+const add = x => y => z => {
   console.log(x, y, z);
   return x + y + z;
 };
@@ -4073,8 +4072,8 @@ With the `Intl.NumberFormat` method, we can format numeric values to any locale.
 ###### 127. Apa yang akan tampil?
 
 ```javascript
-const spookyItems = ["👻", "🎃", "🕸"];
-({ item: spookyItems[3] } = { item: "💀" });
+const spookyItems = ['👻', '🎃', '🕸'];
+({ item: spookyItems[3] } = { item: '💀' });
 
 console.log(spookyItems);
 ```
@@ -4099,7 +4098,7 @@ By destructuring objects, we can unpack values from the right-hand object, and a
 ###### 128. Apa yang akan tampil?
 
 ```javascript
-const name = "Lydia Hallie";
+const name = 'Lydia Hallie';
 const age = 21;
 
 console.log(Number.isNaN(name));
@@ -4135,7 +4134,7 @@ const randomValue = 21;
 
 function getInfo() {
   console.log(typeof randomValue);
-  const randomValue = "Lydia Hallie";
+  const randomValue = 'Lydia Hallie';
 }
 
 getInfo();
@@ -4161,7 +4160,7 @@ Variables declared with the `const` keyword are not referencable before their in
 ###### 130. Apa yang akan tampil?
 
 ```javascript
-const myPromise = Promise.resolve("Woah some cool data");
+const myPromise = Promise.resolve('Woah some cool data');
 
 (async () => {
   try {
@@ -4169,7 +4168,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!');
   }
 })();
 ```
@@ -4194,7 +4193,7 @@ In the `try` block, we're logging the awaited value of the `myPromise` variable:
 ###### 131. Apa yang akan tampil?
 
 ```javascript
-const emojis = ["🥑", ["✨", "✨", ["🍕", "🍕"]]];
+const emojis = ['🥑', ['✨', '✨', ['🍕', '🍕']]];
 
 console.log(emojis.flat(1));
 ```
@@ -4267,19 +4266,19 @@ We invoke the `counterTwo.increment()`, which sets the `count` to `3`. Then, we
 ###### 133. Apa yang akan tampil?
 
 ```javascript
-const myPromise = Promise.resolve(Promise.resolve("Promise!"));
+const myPromise = Promise.resolve(Promise.resolve('Promise!'));
 
 function funcOne() {
-  myPromise.then((res) => res).then((res) => console.log(res));
-  setTimeout(() => console.log("Timeout!", 0));
-  console.log("Last line!");
+  myPromise.then(res => res).then(res => console.log(res));
+  setTimeout(() => console.log('Timeout!', 0));
+  console.log('Last line!');
 }
 
 async function funcTwo() {
   const res = await myPromise;
   console.log(await res);
-  setTimeout(() => console.log("Timeout!", 0));
-  console.log("Last line!");
+  setTimeout(() => console.log('Timeout!', 0));
+  console.log('Last line!');
 }
 
 funcOne();
@@ -4320,7 +4319,7 @@ export default function sum(x) {
 }
 
 // index.js
-import * as sum from "./sum";
+import * as sum from './sum';
 ```
 
 - A: `sum(4)`
@@ -4337,12 +4336,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);
 ```
 
@@ -4373,13 +4372,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;
 ```
 
@@ -4409,7 +4408,7 @@ Then, we access a property value on the proxy object, the `get` property on the
 ###### 136. Which of the following will modify the `person` object?
 
 ```javascript
-const person = { name: "Lydia Hallie" };
+const person = { name: 'Lydia Hallie' };
 
 Object.seal(person);
 ```
@@ -4437,9 +4436,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',
   },
 };
 
@@ -4469,9 +4468,9 @@ However, it only _shallowly_ freezes the object, meaning that only _direct_ prop
 
 ```javascript
 const person = {
-  name: "Lydia Hallie",
+  name: 'Lydia Hallie',
   address: {
-    street: "100 Main St",
+    street: '100 Main St',
   },
 };
 
@@ -4500,7 +4499,7 @@ However, it only _shallowly_ freezes the object, meaning that only _direct_ prop
 ###### 139. Apa yang akan tampil?
 
 ```javascript
-const add = (x) => x + x;
+const add = x => x + x;
 
 function myFunc(num = 2, value = add(num)) {
   console.log(num, value);
@@ -4533,21 +4532,21 @@ Then, we invoked `myFunc(3)` and passed the value `3` as the value for the argum
 
 ```javascript
 class Counter {
-  #number = 10;
+  #number = 10
 
   increment() {
-    this.#number++;
+    this.#number++
   }
 
   getNum() {
-    return this.#number;
+    return this.#number
   }
 }
 
-const counter = new Counter();
-counter.increment();
+const counter = new Counter()
+counter.increment()
 
-console.log(counter.#number);
+console.log(counter.#number)
 ```
 
 - A: `10`
@@ -4571,8 +4570,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) {
@@ -4615,8 +4614,8 @@ Jika kita telah menulis `yield`, `return yield`, atau `return`, maka seluruh fun
 
 ```javascript
 const person = {
-  name: "Lydia Hallie",
-  hobbies: ["coding"],
+  name: 'Lydia Hallie',
+  hobbies: ['coding'],
 };
 
 function addHobby(hobby, hobbies = person.hobbies) {
@@ -4624,9 +4623,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);
 ```
@@ -4695,11 +4694,11 @@ Kita membuat variabel `pet` yang merupakan turunan dari class `Flamingo`. Saat k
 ###### 144. Manakah dari pilihan di bawah ini yang salah?
 
 ```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;
 ```
 
@@ -4742,7 +4741,7 @@ const person = {
 #### Jawaban: C
 
 Objek tidak dapat diulang secara default. Sebuah iterable adalah sebuah iterable jika protokol iterator ada. Kita dapat menambahkan ini secara manual dengan menambahkan simbol iterator
-`[Symbol.iterator]`, dimana harus mengembalikan objek generator, sebagai contoh dengan membuat fungsi generator `*[Symbol.iterator]() {}`. Fungsi generator ini harus menghasilkan `Object.values` dari objek `person` jika kita mau mengembalikan array `["Lydia Hallie", 21]`: `yield* Object.values(this)`.
+ `[Symbol.iterator]`, dimana harus mengembalikan objek generator, sebagai contoh dengan membuat fungsi generator `*[Symbol.iterator]() {}`. Fungsi generator ini harus menghasilkan `Object.values` dari objek `person` jika kita mau mengembalikan array `["Lydia Hallie", 21]`: `yield* Object.values(this)`.
 
 </p>
 </details>
@@ -4755,11 +4754,11 @@ Objek tidak dapat diulang secara default. Sebuah iterable adalah sebuah iterable
 let count = 0;
 const nums = [0, 1, 2, 3];
 
-nums.forEach((num) => {
-  if (num) count += 1;
-});
+nums.forEach(num => {
+	if (num) count += 1
+})
 
-console.log(count);
+console.log(count)
 ```
 
 - A: 1
@@ -4783,19 +4782,19 @@ Pernyataan `if` didalam perulangan `forEach` akan mengecek apakah nilai dari `nu
 
 ```javascript
 class Calc {
-  constructor() {
-    this.count = 0;
-  }
+	constructor() {
+		this.count = 0
+	}
 
-  increase() {
-    this.count++;
-  }
+	increase() {
+		this.count ++
+	}
 }
 
-const calc = new Calc();
-new Calc().increase();
+const calc = new Calc()
+new Calc().increase()
 
-console.log(calc.count);
+console.log(calc.count)
 ```
 
 - A: `0`
@@ -4819,25 +4818,25 @@ Kami mengatur variabel `calc` sama dengan instance baru dari class `Calc`. Kemud
 
 ```javascript
 const user = {
-  email: "e@mail.com",
-  password: "12345",
-};
+	email: "e@mail.com",
+	password: "12345"
+}
 
 const updateUser = ({ email, password }) => {
-  if (email) {
-    Object.assign(user, { email });
-  }
+	if (email) {
+		Object.assign(user, { email })
+	}
 
-  if (password) {
-    user.password = password;
-  }
+	if (password) {
+		user.password = password
+	}
 
-  return user;
-};
+	return user
+}
 
-const updatedUser = updateUser({ email: "new@email.com" });
+const updatedUser = updateUser({ email: "new@email.com" })
 
-console.log(updatedUser === user);
+console.log(updatedUser === user)
 ```
 
 - A: `false`
@@ -4858,13 +4857,12 @@ Fungsi `updateUser` memperbarui nilai properti `email` dan `password` pada pengg
 ---
 
 ###### 149. Apa hasilnya?
-
 ```javascript
-const fruit = ["🍌", "🍊", "🍎"];
+const fruit = ['🍌', '🍊', '🍎']
 
-fruit.slice(0, 1);
-fruit.splice(0, 1);
-fruit.unshift("🍇");
+fruit.slice(0, 1)
+fruit.splice(0, 1)
+fruit.unshift('🍇')
 ```
 
 - A: `['🍌', '🍊', '🍎']`
@@ -4890,13 +4888,13 @@ Akhirnya, kita memanggil metode `unshift` pada array `fruit`, yang memodifikasi
 
 ```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]);
+console.log(animals[dog])
 ```
 
 - A: `{ emoji: "🐶", name: "Mara" }`
@@ -4911,9 +4909,9 @@ console.log(animals[dog]);
 
 Kunci objek diubah menjadi string.
 
-Karena nilai `dog` adalah sebuah objek, `animals[dog]`sebenarnya berarti kita membuat properti baru bernama `"object Object"`yang sama dengan objek baru. `animals["object Object"]` sekarang sama dengan `{ emoji: "🐶", name: "Mara"}`.
+Karena nilai `dog` adalah sebuah objek,  `animals[dog]`sebenarnya berarti kita membuat properti baru bernama `"object Object"`yang sama dengan objek baru. `animals["object Object"]` sekarang sama dengan `{ emoji: "🐶", name: "Mara"}`.
 
-`cat` juga merupakan objek, yang berarti bahwa `animals[cat]` sebenarnya berarti bahwa kami menimpa nilai ` animals[``"``object Object``"``] ` dengan properti cat yang baru.
+`cat` juga merupakan objek, yang berarti bahwa `animals[cat]` sebenarnya berarti bahwa kami menimpa nilai `animals[``"``object Object``"``]` dengan properti cat yang baru.
 
 Mencatat `animals[dog]`, atau sebenarnya `animals["object Object"]` karena mengonversi objek `dog` menjadi string menghasilkan `"object Object"`, mengembalikan `{emoji: "🐈", nama: "Sara"}`.
 
@@ -4926,10 +4924,10 @@ Mencatat `animals[dog]`, atau sebenarnya `animals["object Object"]` karena mengo
 
 ```javascript
 const user = {
-  email: "my@email.com",
-  updateEmail: (email) => {
-    this.email = email;
-  },
+        email: "my@email.com",
+        updateEmail: (email) => {
+          this.email = email;
+        },
 };
 
 user.updateEmail("new@email.com");
@@ -4956,20 +4954,20 @@ Fungsi `updateEmail` adalah fungsi panah, dan tidak terikat ke objek `user`. Art
 ###### 152. Apa hasilnya?
 
 ```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]);
-  const res2 = await Promise.all([promise3, promise4]);
-  return [res1, res2];
-};
+      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));
+	.then(res => console.log(res))
+	.catch(err => console.log(err))
 ```
 
 - A: `[['First', 'Second'], ['Fourth']]`
@@ -5026,18 +5024,18 @@ Ini membuat array subarray yang berisi kunci dan nilai yang benar, yang menghasi
 ###### 154. Apa hasilnya?
 
 ```javascript
-const createMember = ({ email, address = {} }) => {
-  const validEmail = /.+\@.+\..+/.test(email);
-  if (!validEmail) throw new Error("Valid email pls");
+const createMember = ({ email, address = {}}) => {
+	const validEmail = /.+\@.+\..+/.test(email)
+	if (!validEmail) throw new Error("Valid email pls")
 
-  return {
-    email,
-    address: address ? address : null,
-  };
-};
+	return {
+		email,
+		address: address ? address : null
+	}
+}
 
-const member = createMember({ email: "my@email.com" });
-console.log(member);
+const member = createMember({ email: "my@email.com" })
+console.log(member)
 ```
 
 - A: `{ email: "my@email.com", address: null }`
@@ -5060,13 +5058,13 @@ Nilai default dari `address` adalah objek kosong `{}`. Saat kita menyetel variab
 ###### 155. Apa hasilnya?
 
 ```javascript
-let randomValue = { name: "Lydia" };
-randomValue = 23;
+let randomValue = { name: "Lydia" }
+randomValue = 23
 
 if (!typeof randomValue === "string") {
-  console.log("It's not a string!");
+	console.log("It's not a string!")
 } else {
-  console.log("Yay it's a string!");
+	console.log("Yay it's a string!")
 }
 ```
 
diff --git a/it-IT/README.md b/it-IT/README.md
index 8b116031..71b71ca5 100644
--- a/it-IT/README.md
+++ b/it-IT/README.md
@@ -8,12 +8,13 @@
 
 Da base ad avanzato: metti alla prova quanto conosci JavaScript, rinfresca un po' le tue conoscenze o preparati per il tuo colloquio di programmazione! :muscle: :rocket: Aggiorno regolarmente questo repository con nuove domande. Ho aggiunto le risposte nelle **sezioni compresse** sotto le domande, cliccaci sopra per espanderle. È solo per divertimento, buona fortuna! :heart:
 
+
 Sentiti libero di contattarmi! 😊 <br />
 <a href="https://www.instagram.com/theavocoder">Instagram</a> || <a href="https://www.twitter.com/lydiahallie">Twitter</a> || <a href="https://www.linkedin.com/in/lydia-hallie">LinkedIn</a> || <a href="https://www.lydiahallie.dev">Blog</a>
-
 </div>
 
-| Sentiti libero di usarli in un progetto! 😃 Apprezzerei _molto_ un riferimento a questa repository, creo le domande e le spiegazioni (sì, sono triste lol) e la community mi aiuta tantissimo a mantenerlo e migliorarlo! 💪🏼 Grazie e buon divertimento! |
+| Sentiti libero di usarli in un progetto! 😃  Apprezzerei _molto_ un riferimento a questa repository, creo le domande e le spiegazioni (sì, sono triste lol) e la community mi aiuta tantissimo a mantenerlo e migliorarlo! 💪🏼 Grazie e buon divertimento!  |
+
 
 Traduzione a cura di: <a href="https://github.com/luciacenetiempo">Lucia Cenetiempo</a>
 |---|
@@ -36,7 +37,6 @@ Traduzione a cura di: <a href="https://github.com/luciacenetiempo">Lucia Cenetie
 - [🇳🇱 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)
@@ -57,7 +57,7 @@ Traduzione a cura di: <a href="https://github.com/luciacenetiempo">Lucia Cenetie
 function sayHi() {
   console.log(name);
   console.log(age);
-  var name = "Lydia";
+  var name = 'Lydia';
   let age = 21;
 }
 
@@ -75,8 +75,8 @@ sayHi();
 
 #### Risposta: D
 
-All'interno della funzione, dichiariamo prima la variabile `name` con la parola chiave `var`. Ciò significa che la variabile viene sollevata all'interno del codice (ovvero lo spazio di memoria viene impostato durante la fase di creazione) e viene inizializzata con il valore predefinito di `undefined`, finché non arriviamo effettivamente alla riga in cui la definiamo.
-Al momento in cui proviamo ad eseguire il log della variabile `name` non l'abbiamo ancora dichiarata, quindi mantiene il valore di `undefined`.
+All'interno della funzione, dichiariamo prima la variabile `name` con la parola chiave `var`. Ciò significa che la variabile viene sollevata all'interno del codice (ovvero lo spazio di memoria viene impostato durante la fase di creazione) e viene inizializzata con il valore predefinito di `undefined`, finché non arriviamo effettivamente alla riga in cui la definiamo. 
+Al momento in cui proviamo ad eseguire il log della variabile `name` non l'abbiamo ancora dichiarata, quindi mantiene il valore di `undefined`. 
 
 Le variabili dichiarate con la chiave `let` (o `const`) vengono sollevate, ma a differenza delle variabili dichiarate con `var`, non vengono <i>inizializzate</i>. Per questo motivo non sono accessibili prima della loro dichiarazione (dove le inizializzaimo). Questa è chiamata "temporal dead zone". Quando proviamo ad accedere alle variabili prima che vengano dichiarate, JavaScript genera un `ReferenceError`.
 
@@ -155,7 +155,7 @@ Non troviamo quindi alcun valore `radius` in quell'oggetto e quindi viene restit
 
 ```javascript
 +true;
-!"Lydia";
+!'Lydia';
 ```
 
 - A: `1` and `false`
@@ -180,11 +180,11 @@ La stringa `'Lydia'` è un valore veritiero. Quello che in realtà ci stiamo chi
 
 ```javascript
 const bird = {
-  size: "small",
+  size: 'small',
 };
 
 const mouse = {
-  name: "Mickey",
+  name: 'Mickey',
   small: true,
 };
 ```
@@ -215,11 +215,11 @@ Con l'utilizzo del punto questo non accade perché `mouse` non ha una chiave chi
 ###### 6. Qual è l'output?
 
 ```javascript
-let c = { greeting: "Hey!" };
+let c = { greeting: 'Hey!' };
 let d;
 
 d = c;
-c.greeting = "Hello";
+c.greeting = 'Hello';
 console.log(d.greeting);
 ```
 
@@ -289,13 +289,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`
@@ -347,10 +347,10 @@ Per evitare ciò, possiamo usare `"use strict"`. Questo assicura di aver dichiar
 
 ```javascript
 function bark() {
-  console.log("Woof!");
+  console.log('Woof!');
 }
 
-bark.animal = "dog";
+bark.animal = 'dog';
 ```
 
 - A: Niente, va benissimo!
@@ -380,8 +380,8 @@ function Person(firstName, lastName) {
   this.lastName = lastName;
 }
 
-const member = new Person("Lydia", "Hallie");
-Person.getFullName = function () {
+const member = new Person('Lydia', 'Hallie');
+Person.getFullName = function() {
   return `${this.firstName} ${this.lastName}`;
 };
 
@@ -402,8 +402,9 @@ In JavaScript, le funzioni sono oggetti e quindi il metodo `getFullName` viene a
 
 Se vuoi che un metodo sia disponibile per tutte le istanze dell'oggetto, devi aggiungerlo alla proprietà del prototipo:
 
+
 ```js
-Person.prototype.getFullName = function () {
+Person.prototype.getFullName = function() {
   return `${this.firstName} ${this.lastName}`;
 };
 ```
@@ -421,8 +422,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);
@@ -492,7 +493,7 @@ function sum(a, b) {
   return a + b;
 }
 
-sum(1, "2");
+sum(1, '2');
 ```
 
 - A: `NaN`
@@ -543,7 +544,7 @@ Utilizzando l'operatore unario come **prefisso** `++number` succede che:
 1. Incrementa prima il valore (il numero è ora `2`)
 2. Restituisce subito dopo il valore già incrementato (`2`)
 
-Quindi il nostro log sarà `0 2 2`.
+Quindi il nostro log sarà  `0 2 2`.
 
 </p>
 </details>
@@ -559,7 +560,7 @@ function getPersonInfo(one, two, three) {
   console.log(three);
 }
 
-const person = "Lydia";
+const person = 'Lydia';
 const age = 21;
 
 getPersonInfo`${person} is ${age} years old`;
@@ -574,7 +575,7 @@ getPersonInfo`${person} is ${age} years old`;
 
 #### Risposta: B
 
-Utilizzando i template literals, il valore del primo argomento sarà un array di valori della stringa. Gli altri argomenti prenderanno i valori dell'espressione passata.
+Utilizzando i template literals, il valore del primo argomento sarà un array di valori della stringa. Gli altri argomenti prenderanno i valori dell'espressione passata. 
 
 </p>
 </details>
@@ -586,9 +587,9 @@ Utilizzando i template literals, il valore del primo argomento sarà un array di
 ```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`);
   }
@@ -648,7 +649,7 @@ Il parametro rest (`...args`) ci permette di "collettare" tutti gli argomenti in
 
 ```javascript
 function getAge() {
-  "use strict";
+  'use strict';
   age = 21;
   console.log(age);
 }
@@ -676,7 +677,7 @@ Con `"use strict"`, puoi assicurarti di non dichiarare variabili globali per sba
 ###### 21. Qual è il valore di `sum`?
 
 ```javascript
-const sum = eval("10*10+5");
+const sum = eval('10*10+5');
 ```
 
 - A: `105`
@@ -699,7 +700,7 @@ const sum = eval("10*10+5");
 ###### 22. Per quanto tempo cool_secret è accessibile?
 
 ```javascript
-sessionStorage.setItem("cool_secret", 123);
+sessionStorage.setItem('cool_secret', 123);
 ```
 
 - A: Per sempre, i dati non vanno persi.
@@ -752,12 +753,12 @@ Non puoi farlo con `let` o `const` poiché sono block-scoped.
 ###### 24. Qual è l'output?
 
 ```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);
 ```
 
@@ -783,7 +784,7 @@ Per i set non funziona allo stesso modo degli oggetti. Non c'è alcun `'1'` nel
 ###### 25. Qual è l'output?
 
 ```javascript
-const obj = { a: "one", b: "two", a: "three" };
+const obj = { a: 'one', b: 'two', a: 'three' };
 console.log(obj);
 ```
 
@@ -852,12 +853,12 @@ L'istruzione `continue` salta un'iterazione se una certa condizione restituisce
 
 ```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());
+console.log(name.giveLydiaPizza())
 ```
 
 - A: `"Just give Lydia pizza already!"`
@@ -870,7 +871,7 @@ console.log(name.giveLydiaPizza());
 
 #### Risposta: A
 
-`String` è un costruttore built-in, a cui possiamo aggiungere proprietà. In questo caso è stato appena aggiunto un metodo al suo prototipo.
+`String` è un costruttore built-in, a cui possiamo aggiungere proprietà. In questo caso è stato appena aggiunto un metodo al suo prototipo. 
 Le stringhe primitive vengono automaticamente convertite in un oggetto stringa, generato dalla string prototype function. Quindi, tutte le stringhe hanno accesso a quel metodo!
 
 </p>
@@ -882,8 +883,8 @@ Le stringhe primitive vengono automaticamente convertite in un oggetto stringa,
 
 ```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;
@@ -915,9 +916,9 @@ Quindi, quando facciamo console.log di `a[b]`, che in realtà è `a["[object Obj
 ###### 30. Qual è l'output?
 
 ```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();
@@ -970,7 +971,9 @@ La WebAPI non può semplicemente aggiungere elementi allo stack ogni volta che 
 ```html
 <div onclick="console.log('first div')">
   <div onclick="console.log('second div')">
-    <button onclick="console.log('button')">Click!</button>
+    <button onclick="console.log('button')">
+      Click!
+    </button>
   </div>
 </div>
 ```
@@ -996,7 +999,9 @@ L'elemento annidato più in profondità è quello che ha causato l'evento ed è
 
 ```html
 <div onclick="console.log('div')">
-  <p onclick="console.log('p')">Click here!</p>
+  <p onclick="console.log('p')">
+    Click here!
+  </p>
 </div>
 ```
 
@@ -1020,7 +1025,7 @@ Se clicchiamo su `p`, vediamo due log: `p` e `div`. Durante la propagazione dell
 ###### 33. Qual è l'output?
 
 ```javascript
-const person = { name: "Lydia" };
+const person = { name: 'Lydia' };
 
 function sayHi(age) {
   return `${this.name} is ${age}`;
@@ -1083,8 +1088,8 @@ Ci sono solo 7 tipi built-in: `null`, `undefined`, `boolean`, `number`, `string`
 ```javascript
 0;
 new Number(0);
-("");
-(" ");
+('');
+(' ');
 new Boolean(false);
 undefined;
 ```
@@ -1233,14 +1238,11 @@ Ciò che differenzia un tipo primitivo da un oggetto è che i primitivi non hann
 ###### 40. Qual è l'output?
 
 ```javascript
-[
-  [0, 1],
-  [2, 3],
-].reduce(
+[[0, 1], [2, 3]].reduce(
   (acc, cur) => {
     return acc.concat(cur);
   },
-  [1, 2]
+  [1, 2],
 );
 ```
 
@@ -1257,7 +1259,6 @@ Ciò che differenzia un tipo primitivo da un oggetto è che i primitivi non hann
 `[1, 2]` rappresenta il nostro valore interno. Ovvero il valore con cui iniziamo e il valore del primo `acc`. Durante il primo round, `acc` è `[1,2]` e `cur` è `[0, 1]`. Li concateniamo ottenendo `[1, 2, 0, 1]`.
 
 A questo punto `acc` corrisponderà a `[1, 2, 0, 1]` e `cur` sarà ancora `[2, 3]`. Li concateniamo e otteniamo `[1, 2, 0, 1, 2, 3]`
-
 </p>
 </details>
 
@@ -1267,7 +1268,7 @@ A questo punto `acc` corrisponderà a `[1, 2, 0, 1]` e `cur` sarà ancora `[2, 3
 
 ```javascript
 !!null;
-!!"";
+!!'';
 !!1;
 ```
 
@@ -1295,7 +1296,7 @@ A questo punto `acc` corrisponderà a `[1, 2, 0, 1]` e `cur` sarà ancora `[2, 3
 ###### 42. Cosa restituisce il metodo `setInterval` nel browser?
 
 ```javascript
-setInterval(() => console.log("Hi"), 1000);
+setInterval(() => console.log('Hi'), 1000);
 ```
 
 - A: un ID univoco
@@ -1318,7 +1319,7 @@ Restituisce un ID univoco. Questo id può essere usato per cancellare quell'inte
 ###### 43. Cosa restituisce?
 
 ```javascript
-[..."Lydia"];
+[...'Lydia'];
 ```
 
 - A: `["L", "y", "d", "i", "a"]`
@@ -1377,14 +1378,14 @@ Invochiamo di nuovo la funzione con il metodo `next()`. Inizia a continuare da d
 
 ```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));
+Promise.race([firstPromise, secondPromise]).then(res => console.log(res));
 ```
 
 - A: `"one"`
@@ -1407,7 +1408,7 @@ Quando passiamo più promises al metodo `Promise.race`, questo risolve/rifiuta l
 ###### 46. Qual è l'output?
 
 ```javascript
-let person = { name: "Lydia" };
+let person = { name: 'Lydia' };
 const members = [person];
 person = null;
 
@@ -1447,7 +1448,7 @@ Stiamo modificando solo il valore della variabile `person`, e non il primo eleme
 
 ```javascript
 const person = {
-  name: "Lydia",
+  name: 'Lydia',
   age: 21,
 };
 
@@ -1476,7 +1477,7 @@ Con il ciclo `for-in`, possiamo iterare le chiavi degli oggetti, in questo caso
 ###### 48. Qual è l'output?
 
 ```javascript
-console.log(3 + 4 + "5");
+console.log(3 + 4 + '5');
 ```
 
 - A: `"345"`
@@ -1503,7 +1504,7 @@ L'associazione è l'ordine in cui il compilatore valuta le espressioni, da sinis
 ###### 49. Qual è il valore di `num`?
 
 ```javascript
-const num = parseInt("7*6", 10);
+const num = parseInt('7*6', 10);
 ```
 
 - A: `42`
@@ -1528,8 +1529,8 @@ Viene restituito solo il primo valore della stringa. In base alla _radice_ (ovve
 ###### 50. Qual è l'output?
 
 ```javascript
-[1, 2, 3].map((num) => {
-  if (typeof num === "number") return;
+[1, 2, 3].map(num => {
+  if (typeof num === 'number') return;
   return num * 2;
 });
 ```
@@ -1557,12 +1558,12 @@ Tuttavia, non ritorniamo un valore. Quando non ritorniamo un valore dalla funzio
 
 ```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);
 
@@ -1584,7 +1585,6 @@ Gli argomenti vengono passati come _valori_, a meno che il loro valore non sia u
 La variabile `birthYear` ha un riferimento al valore `"1997"`. Anche l'argomento `year` fa riferimento al valore `"1997"`, ma non è lo stesso valore a cui fa riferimento `birthYear`. Quando aggiorniamo il valore di `year` impostando `year` uguale a `"1998"`, stiamo solo aggiornando il valore di `year`. `birthYear` è ancora uguale a `"1997"`.
 
 Il valore di `person` è un oggetto. L'argomento `member` ha un riferimento (copiato) dello stesso oggetto. Quando modifichiamo una proprietà dell'oggetto a cui `member` fa riferimento, verrà modificato anche il valore di `person`, poiché entrambi hanno un riferimento allo stesso oggetto. La proprietà `name` di `person` è ora uguale al valore `"Lydia"`
-
 </p>
 </details>
 
@@ -1594,15 +1594,15 @@ Il valore di `person` è un oggetto. L'argomento `member` ha un riferimento (cop
 
 ```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 @@ Con l'istruzione `catch`, possiamo specificare cosa fare se viene generata un'ec
 
 ```javascript
 function Car() {
-  this.make = "Lamborghini";
-  return { make: "Maserati" };
+  this.make = 'Lamborghini';
+  return { make: 'Maserati' };
 }
 
 const myCar = new Car();
@@ -1705,11 +1705,11 @@ class Dog {
   }
 }
 
-Dog.prototype.bark = function () {
+Dog.prototype.bark = function() {
   console.log(`Woof I am ${this.name}`);
 };
 
-const pet = new Dog("Mara");
+const pet = new Dog('Mara');
 
 pet.bark();
 
@@ -1774,7 +1774,7 @@ export default counter;
 
 ```javascript
 // index.js
-import myCounter from "./counter";
+import myCounter from './counter';
 
 myCounter += 1;
 
@@ -1803,7 +1803,7 @@ Quando proviamo ad incrementare il valore di `myCounter`, viene generato un erro
 ###### 58. Qual è l'output?
 
 ```javascript
-const name = "Lydia";
+const name = 'Lydia';
 age = 21;
 
 console.log(delete name);
@@ -1874,7 +1874,7 @@ Questo significa che il valore di `y` è uguale al primo valore nell'array, che
 ###### 60. Qual è l'output?
 
 ```javascript
-const user = { name: "Lydia", age: 21 };
+const user = { name: 'Lydia', age: 21 };
 const admin = { admin: true, ...user };
 
 console.log(admin);
@@ -1900,9 +1900,9 @@ console.log(admin);
 ###### 61. Qual è l'output?
 
 ```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));
@@ -1931,12 +1931,12 @@ Le proprietà aggiunte usando il metodo `defineProperty` sono immutabili per imp
 
 ```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);
 ```
 
@@ -1967,7 +1967,7 @@ Se il replacer è una _funzione_, questa funzione viene chiamata su ogni proprie
 let num = 10;
 
 const increaseNumber = () => num++;
-const increasePassedNumber = (number) => number++;
+const increasePassedNumber = number => number++;
 
 const num1 = increaseNumber();
 const num2 = increasePassedNumber(num1);
@@ -2049,7 +2049,7 @@ La quarta volta, passiamo di nuovo l'oggetto `value`, in questo caso `x.number`
 
 #### Risposta: D
 
-Il primo argomento che il metodo `reduce` riceve è l'_accumulatore_, in questo caso `x`. Il secondo argomento è il _valore corrente_ `y`.
+Il primo argomento che il metodo `reduce` riceve è l'_accumulatore_, in questo caso `x`. Il secondo argomento è il _valore corrente_ `y`. 
 Con il metodo reduce, eseguiamo una funzione di callback su ogni elemento dell'array, che alla fine potrebbe risultare in un singolo valore.
 
 In questo esempio, non stiamo restituendo alcun valore, stiamo semplicemente loggando i valori dell'accumulatore e il valore corrente.
@@ -2061,7 +2061,6 @@ Alla prima chiamata, l'accumulatore (`x`) è `1` e il valore corrente (`y`) è `
 Se non restituisci un valore da una funzione questa restituisce `undefined`. Alla chiamata successiva, l'accumulatore è `undefined` e il valore corrente è "3". `undefined` e `3` vengono loggati.
 
 Alla quarta chiamata, di nuovo non facciamo un return dalla funzione di callback. L'accumulatore è di nuovo `undefined` e il valore corrente è "4". `undefined` e `4` vengono loggati.
-
 </p>
 </details>
   
@@ -2125,12 +2124,12 @@ La classe `Labrador` riceve due argomenti, `name` poiché estende `Dog`, e `size
 
 ```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;
 ```
 
@@ -2158,7 +2157,7 @@ Questa è una delle differenze tra `require()` in CommonJS e `import`. Con `requ
 ```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`
@@ -2181,7 +2180,7 @@ Ogni Simbolo è unico. Lo scopo dell'argomento passato a Symbol è di dargli una
 ###### 69. Qual è l'output?
 
 ```javascript
-const name = "Lydia Hallie";
+const name = 'Lydia Hallie';
 console.log(name.padStart(13));
 console.log(name.padStart(2));
 ```
@@ -2208,7 +2207,7 @@ Se l'argomento passato al metodo `padStart` è inferiore alla lunghezza dell'arr
 ###### 70. Qual è l'output?
 
 ```javascript
-console.log("🥑" + "💻");
+console.log('🥑' + '💻');
 ```
 
 - A: `"🥑💻"`
@@ -2232,11 +2231,11 @@ Con l'operatore `+` puoi concatenare stringhe. In questo caso, stiamo concatenan
 
 ```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 gone here";
   }
-  return "JavaScript loves you back ❤️";
+  return 'JavaScript loves you back ❤️';
 }
 
 const game = startGame();
@@ -2304,7 +2303,7 @@ In questo caso, è la stringa `Hello\nworld` che viene loggata.
 
 ```javascript
 async function getData() {
-  return await Promise.resolve("I made it!");
+  return await Promise.resolve('I made it!');
 }
 
 const data = getData();
@@ -2341,7 +2340,7 @@ function addToList(item, list) {
   return list.push(item);
 }
 
-const result = addToList("apple", ["banana"]);
+const result = addToList('apple', ['banana']);
 console.log(result);
 ```
 
@@ -2355,10 +2354,10 @@ console.log(result);
 
 #### Risposta: B
 
-Il metodo `.push()` restituisce la _lunghezza_ del nuovo array!
-Inizialmente, l'array conteneva un solo elemento (la stringa `"banana"`) e aveva una lunghezza di `1`. Dopo aver aggiunto la stringa `"apple"` allo stesso array, questo contiene due elementi e ha una lunghezza di `2`
+Il metodo `.push()` restituisce la _lunghezza_ del nuovo array! 
+Inizialmente, l'array conteneva un solo elemento (la stringa `"banana"`) e aveva una lunghezza di `1`. Dopo aver aggiunto la stringa `"apple"` allo stesso array, questo contiene due elementi e ha una lunghezza di `2` 
 
-Attraverso la funzione `addToList`, il metodo `push` modifica l'array originale.
+Attraverso la funzione `addToList`, il metodo `push` modifica l'array originale. 
 Per restituire l'_array_ dalla funzione invece della _lunghezza dell'array_, serve fare un return di `list` dopo aver inserito l'`item`.
 
 </p>
@@ -2391,10 +2390,10 @@ console.log(shape);
 
 `Object.freeze` rende impossibile aggiungere, rimuovere o modificare le proprietà di un oggetto (a meno che il valore della proprietà non sia un altro oggetto).
 
-Quando creiamo la variabile `shape` e la impostiamo come all'oggetto congelato `box`, anche `shape` si riferisce ad un oggetto congelato.
+Quando creiamo la variabile `shape` e la impostiamo come all'oggetto congelato `box`, anche `shape` si riferisce ad un oggetto congelato. 
 Puoi controllare se un oggetto è congelato usando `Object.isFrozen`. In questo caso, `Object.isFrozen(shape)` restituisce true, poiché la variabile `shape` ha un riferimento a un oggetto congelato.
 
-Poiché `shape` è congelata, e poiché il valore di `x` non è un oggetto, non possiamo modificare la proprietà `x`.
+Poiché `shape` è congelata, e poiché il valore di `x` non è un oggetto, non possiamo modificare la proprietà `x`. 
 `x` è ancora uguale a `10` e `{ x: 10, y: 20 }` viene loggato.
 
 </p>
@@ -2405,7 +2404,7 @@ Poiché `shape` è congelata, e poiché il valore di `x` non è un oggetto, non
 ###### 76. Qual è l'output?
 
 ```javascript
-const { name: myName } = { name: "Lydia" };
+const { name: myName } = { name: 'Lydia' };
 
 console.log(name);
 ```
@@ -2461,7 +2460,7 @@ La funzione `sum` restituisce sempre lo stesso risultato. Se le passiamo `1` e `
 ```javascript
 const add = () => {
   const cache = {};
-  return (num) => {
+  return num => {
     if (num in cache) {
       return `From cache! ${cache[num]}`;
     } else {
@@ -2488,13 +2487,13 @@ console.log(addFunction(5 * 2));
 
 #### Risposta: C
 
-La funzione `add` è una funzione _memoizzata_. Con la memorizzazione, possiamo memorizzare nella cache i risultati di una funzione per velocizzarne l'esecuzione.
+La funzione `add` è una funzione _memoizzata_. Con la memorizzazione, possiamo memorizzare nella cache i risultati di una funzione per velocizzarne l'esecuzione. 
 In questo caso, creiamo un oggetto `cache` che memorizza i valori precedentemente restituiti.
 
 Se chiamiamo di nuovo la funzione `addFunction` con lo stesso argomento, prima controlla se ha già ottenuto quel valore nella sua cache, in tal caso, verrà restituito il valore della cache, consentendo di risparmiare tempo di esecuzione. Altrimenti, se non è memorizzato nella cache, calcolerà il valore e lo memorizzerà in seguito.
 
-Chiamiamo la funzione `addFunction` tre volte con lo stesso valore: alla prima chiamata, il valore della funzione quando `num` è uguale a `10` non è ancora memorizzato nella cache.
-La condizione dell'istruzione if `num in cache` restituisce `false`, e il blocco else viene eseguito: `Calculated! 20` viene loggato e il valore del risultato viene aggiunto all'oggetto cache.
+Chiamiamo la funzione `addFunction` tre volte con lo stesso valore: alla prima chiamata, il valore della funzione quando `num` è uguale a `10` non è ancora memorizzato nella cache. 
+La condizione dell'istruzione if `num in cache` restituisce `false`, e il blocco else viene eseguito: `Calculated! 20` viene loggato e il valore del risultato viene aggiunto all'oggetto cache. 
 `cache` ora è uguale a `{ 10: 20 }`.
 
 La seconda volta, l'oggetto `cache` contiene il valore che viene restituito per `10`. La condizione dell'istruzione if `num in cache` restituisce `true` e `'From cache! 20'` viene loggato.
@@ -2509,7 +2508,7 @@ La terza volta, passiamo `5 * 2` alla funzione che viene valutata a `10`. L'ogge
 ###### 79. Qual è l'output?
 
 ```javascript
-const myLifeSummedUp = ["☕", "💻", "🍷", "🍫"];
+const myLifeSummedUp = ['☕', '💻', '🍷', '🍫'];
 
 for (let item in myLifeSummedUp) {
   console.log(item);
@@ -2605,13 +2604,13 @@ In questo caso, se non abbiamo passato un valore o se abbiamo passato `undefined
 ###### 82. Qual è l'output?
 
 ```javascript
-var status = "😎";
+var status = '😎';
 
 setTimeout(() => {
-  const status = "😍";
+  const status = '😍';
 
   const data = {
-    status: "🥑",
+    status: '🥑',
     getStatus() {
       return this.status;
     },
@@ -2645,12 +2644,12 @@ Con il metodo `call` possiamo cambiare l'oggetto a cui fa riferimento la parola
 
 ```javascript
 const person = {
-  name: "Lydia",
+  name: 'Lydia',
   age: 21,
 };
 
 let city = person.city;
-city = "Amsterdam";
+city = 'Amsterdam';
 
 console.log(person);
 ```
@@ -2714,9 +2713,9 @@ Le variabili con la chiave `const` e `let` sono _block-scoped_. Un blocco è qua
 ###### 85. Che tipo di informazioni verrebbero loggate?
 
 ```javascript
-fetch("https://www.website.com/api/user/1")
-  .then((res) => res.json())
-  .then((res) => console.log(res));
+fetch('https://www.website.com/api/user/1')
+  .then(res => res.json())
+  .then(res => console.log(res));
 ```
 
 - A: Il risultato del metodo `fetch`.
@@ -2754,7 +2753,7 @@ function getName(name) {
 
 #### Risposta: A
 
-Con `!!name`, determiniamo se il valore di `name` è vero o falso. Se il nome è vero, cosa che vogliamo testare, `!name` restituisce `false`.
+Con `!!name`, determiniamo se il valore di `name` è vero o falso. Se il nome è vero, cosa che vogliamo testare, `!name` restituisce `false`. 
 `!false` (che è `!!name`) restituisce `true`.
 
 Impostando `hasName` uguale a `name`, imposti `hasName` uguale a qualsiasi valore passato alla funzione `getName`, non il valore booleano `true`.
@@ -2771,7 +2770,7 @@ Impostando `hasName` uguale a `name`, imposti `hasName` uguale a qualsiasi valor
 ###### 87. Qual è l'output?
 
 ```javascript
-console.log("I want pizza"[0]);
+console.log('I want pizza'[0]);
 ```
 
 - A: `"""`
@@ -2816,7 +2815,6 @@ sum(10);
 È possibile impostare il valore di un parametro predefinito uguale a un altro parametro della funzione, purché sia stato definito _prima_ del parametro predefinito. Passiamo il valore `10` alla funzione `sum`. Se la funzione `sum` riceve solo 1 argomento, significa che il valore di `num2` non è passato e il valore di `num1` è uguale al valore passato `10` in questo caso. Il valore predefinito di `num2` è il valore di `num1`, che è `10`. `num1 + num2` restituisce `20`.
 
 Se stai cercando di impostare il valore di un parametro predefinito uguale a un parametro che è definito _dopo_ (a destra), il valore del parametro non è stato ancora inizializzato, il che genererà un errore.
-
 </p>
 </details>
 
@@ -2826,11 +2824,11 @@ Se stai cercando di impostare il valore di un parametro predefinito uguale a un
 
 ```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);
 ```
@@ -2863,7 +2861,7 @@ class Person {
   }
 }
 
-const member = new Person("John");
+const member = new Person('John');
 console.log(typeof member);
 ```
 
@@ -2923,7 +2921,7 @@ Quindi quando proviamo a usare il metodo `.push` su `newList` poiché `newList`
 
 ```javascript
 function giveLydiaPizza() {
-  return "Here is pizza!";
+  return 'Here is pizza!';
 }
 
 const giveLydiaChocolate = () =>
@@ -2944,7 +2942,6 @@ console.log(giveLydiaChocolate.prototype);
 #### Risposta: D
 
 Le funzioni regolari, come la funzione `giveLydiaPizza`, hanno una proprietà `prototipo`, che è un oggetto (prototype object) con un `costruttore`. Tuttavia, le arrow functions, come la funzione `giveLydiaChocolate`, non hanno una proprietà `prototype`. Viene quindi restituito `undefined` quando si tenta di accedere alla proprietà `prototype` usando `giveLydiaChocolate.prototype`.
-
 </p>
 </details>
 
@@ -2954,7 +2951,7 @@ Le funzioni regolari, come la funzione `giveLydiaPizza`, hanno una proprietà `p
 
 ```javascript
 const person = {
-  name: "Lydia",
+  name: 'Lydia',
   age: 21,
 };
 
@@ -3014,7 +3011,7 @@ function getItems(fruitList, favoriteFruit, ...args) {
   return [...fruitList, ...args, favoriteFruit];
 }
 
-getItems(["banana", "apple"], "pear", "orange");
+getItems(['banana', 'apple'], 'pear', 'orange');
 ```
 
 L'esempio qui sopra invece funziona e restituisce l'array `[ 'banana', 'apple', 'orange', 'pear' ]`
@@ -3028,9 +3025,9 @@ L'esempio qui sopra invece funziona e restituisce l'array `[ 'banana', 'apple',
 
 ```javascript
 function nums(a, b) {
-  if (a > b) console.log("a is bigger");
-  else console.log("b is bigger");
-  return;
+  if (a > b) console.log('a is bigger');
+  else console.log('b is bigger');
+  return
   a + b;
 }
 
@@ -3048,10 +3045,10 @@ console.log(nums(1, 2));
 
 #### Risposta: B
 
-In JavaScript, non _è necessario_ scrivere il punto e virgola (`;`) in modo esplicito poiché il motore JavaScript li aggiunge comunque dopo le istruzioni.
+In JavaScript, non _è necessario_ scrivere il punto e virgola (`;`) in modo esplicito poiché il motore JavaScript li aggiunge comunque dopo le istruzioni. 
 Questo procedimento è chiamato **Automatic Semicolon Insertion**. Un'istruzione può ad esempio essere una variabile o parole chiave come `throw`, `return`, `break`, ecc.
 
-Qui, abbiamo scritto un'istruzione di `return` e un altro valore `a + b` su una _nuova riga_. Tuttavia, trattandosi di una nuova linea, il motore non sa che in realtà è il valore che volevamo restituire. Invece, ha aggiunto automaticamente un punto e virgola dopo `return`.
+Qui, abbiamo scritto un'istruzione di `return` e un altro valore `a + b` su una _nuova riga_. Tuttavia, trattandosi di una nuova linea, il motore non sa che in realtà è il valore che volevamo restituire. Invece, ha aggiunto automaticamente un punto e virgola dopo `return`. 
 
 Potresti considerare ad esempio:
 
@@ -3060,7 +3057,7 @@ return;
 a + b;
 ```
 
-`a + b` non viene mai raggiunto, poiché la funzione smette di funzionare dopo la parola chiave `return`.
+`a + b` non viene mai raggiunto, poiché la funzione smette di funzionare dopo la parola chiave `return`. 
 Se non viene restituito alcun valore, come qui, la funzione restituisce `undefined`. Nota: non c'è un inserimento automatico dopo le istruzioni `if/else`!
 
 </p>
@@ -3073,13 +3070,13 @@ Se non viene restituito alcun valore, come qui, la funzione restituisce `undefin
 ```javascript
 class Person {
   constructor() {
-    this.name = "Lydia";
+    this.name = 'Lydia';
   }
 }
 
 Person = class AnotherPerson {
   constructor() {
-    this.name = "Sarah";
+    this.name = 'Sarah';
   }
 };
 
@@ -3097,7 +3094,7 @@ console.log(member.name);
 
 #### Risposta: B
 
-Possiamo impostare classi uguali ad altre classi/costruttori di funzioni. In questo caso, impostiamo `Person` uguale a `AnotherPerson`. Il name su questo costruttore è `Sarah`, quindi la proprietà del nome di`Person` sulla nuova istanza `member` è `"Sarah"`.
+Possiamo impostare classi uguali ad altre classi/costruttori di funzioni. In questo caso, impostiamo `Person` uguale a `AnotherPerson`. Il name su questo costruttore è `Sarah`, quindi la proprietà del nome di`Person` sulla nuova istanza `member`  è `"Sarah"`.
 
 </p>
 </details>
@@ -3108,7 +3105,7 @@ Possiamo impostare classi uguali ad altre classi/costruttori di funzioni. In que
 
 ```javascript
 const info = {
-  [Symbol("a")]: "b",
+  [Symbol('a')]: 'b',
 };
 
 console.log(info);
@@ -3161,7 +3158,7 @@ La funzione `getList` riceve un array come argomento. Tra le parentesi della fun
 
 `[x, ...y] = [1, 2, 3, 4]`
 
-Con il parametro rest `...y`, mettiamo tutti gli argomenti "rimanenti" in un array. Gli argomenti rimanenti sono `2`, `3` e `4` in questo caso.
+Con il parametro rest `...y`, mettiamo tutti gli argomenti "rimanenti" in un array. Gli argomenti rimanenti sono `2`, `3` e `4` in questo caso. 
 Il valore di `y` è un array, contenente tutti i parametri rimanenti. Il valore di `x` è uguale a `1` in questo caso, quindi quando facciamo un console.log di `[x, y]`, viene loggato `[1, [2, 3, 4]]`.
 
 La funzione `getUser` riceve un oggetto. Con le arrow functions, non _è necessario_ scrivere parentesi graffe se restituiamo solo un valore. Tuttavia, se vuoi restituire istantaneamente un _oggetto_ da una arrow function, devi scriverlo tra parentesi tonde, altrimenti tutto ciò che si trova tra le due parentesi graffe verrà interpretato come un'istruzione di blocco. In questo caso il codice tra parentesi non è un codice JavaScript valido, quindi viene generato un `SyntaxError`.
@@ -3178,7 +3175,7 @@ La seguente funzione avrebbe restituito un oggetto:
 ###### 99. Qual è l'output?
 
 ```javascript
-const name = "Lydia";
+const name = 'Lydia';
 
 console.log(name());
 ```
@@ -3210,8 +3207,8 @@ I ReferenceErrors vengono generati quando JavaScript non è in grado di trovare
 ```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`
@@ -3237,7 +3234,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);
@@ -3269,16 +3266,16 @@ Con l'operatore `||` possiamo restituire il primo operando veritiero. Se tutti i
 ###### 102. Qual è il valore dell'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");
+  myPromise().then(res => console.log(res));
+  console.log('second');
 }
 
 async function secondFunction() {
   console.log(await myPromise());
-  console.log("second");
+  console.log('second');
 }
 
 firstFunction();
@@ -3316,8 +3313,8 @@ Ciò significa che ha aspettato che `myPromise` si risolvesse con il valore `I h
 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);
@@ -3377,13 +3374,13 @@ In questo caso, abbiamo appena passato il valore numerico `5`. Restituisce una p
 ```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);
 ```
@@ -3422,7 +3419,7 @@ const colorConfig = {
   yellow: false,
 };
 
-const colors = ["pink", "red", "blue"];
+const colors = ['pink', 'red', 'blue'];
 
 console.log(colorConfig.colors[1]);
 ```
@@ -3451,7 +3448,7 @@ JavaScript interpreta (o decomprime) le istruzioni. Quando usiamo la notazione t
 ###### 107. Qual è il suo valore?
 
 ```javascript
-console.log("❤️" === "❤️");
+console.log('❤️' === '❤️');
 ```
 
 - A: `true`
@@ -3472,14 +3469,14 @@ Le emoji sono unicode. L'unicode per l'emoji del cuore è `"U+2764 U+FE0F"`. Que
 ###### 108. Quale di questi metodi modifica l'array originale?
 
 ```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`
@@ -3495,7 +3492,6 @@ emojis.splice(1, 2, "✨");
 Con il metodo `splice` modifichiamo l'array originale cancellando, sostituendo o aggiungendo elementi. In questo caso, abbiamo rimosso 2 elementi dall'indice 1 (abbiamo rimosso `'🥑'` e `'😍'`) e aggiunto invece l'emoji ✨.
 
 `map`, `filter` e `slice` restituiscono un nuovo array, `find` restituisce un elemento e `reduce` restituisce un valore ridotto.
-
 </p>
 </details>
 
@@ -3504,10 +3500,10 @@ Con il metodo `splice` modifichiamo l'array originale cancellando, sostituendo o
 ###### 109. Qual è l'output?
 
 ```javascript
-const food = ["🍕", "🍫", "🥑", "🍔"];
+const food = ['🍕', '🍫', '🥑', '🍔'];
 const info = { favoriteFood: food[0] };
 
-info.favoriteFood = "🍝";
+info.favoriteFood = '🍝';
 
 console.log(food);
 ```
@@ -3527,7 +3523,6 @@ Impostiamo il valore della proprietà `favoriteFood` sull'oggetto `info` uguale
 In JavaScript, i tipi di dati primitivi (tutto ciò che non è un oggetto) interagiscono per _value_. In questo caso, impostiamo il valore della proprietà `favoriteFood` sull'oggetto `info` uguale al valore del primo elemento nell'array `food`, in questo caso la stringa con l'emoji della pizza (`'🍕'`). Una stringa è un tipo di dati primitivo e interagisce per valore (vedi il mio [blogpost](https://www.theavocoder.com/complete-javascript/2018/12/21/by-value-vs-by-reference) se sei interessato a saperne di più).
 
 Quindi, cambiamo il valore della proprietà `favoriteFood` sull'oggetto `info`. L'array `food` non è cambiato, poiché il valore di `favoriteFood` era semplicemente una _copia_ del valore del primo elemento nell'array e non ha un riferimento allo stesso punto in memoria dell'elemento su ` food[0]`. Quando logghiamo food, è ancora l'array originale, `['🍕', '🍫', '🥑', '🍔']`.
-
 </p>
 </details>
 
@@ -3561,7 +3556,7 @@ const jsonArray = JSON.stringify([1, 2, 3]); // '[1, 2, 3]'
 JSON.parse(jsonArray); // [1, 2, 3]
 
 // Stringhiamo un object in un JSON valido, quindi analizziamo la stringa JSON come valore JavaScript:
-const jsonArray = JSON.stringify({ name: "Lydia" }); // '{"name":"Lydia"}'
+const jsonArray = JSON.stringify({ name: 'Lydia' }); // '{"name":"Lydia"}'
 JSON.parse(jsonArray); // { name: 'Lydia' }
 ```
 
@@ -3573,11 +3568,11 @@ JSON.parse(jsonArray); // { name: 'Lydia' }
 ###### 111. Qual è l'output?
 
 ```javascript
-let name = "Lydia";
+let name = 'Lydia';
 
 function getName() {
   console.log(name);
-  let name = "Sarah";
+  let name = 'Sarah';
 }
 
 getName();
@@ -3600,7 +3595,7 @@ Le variabili con la chiave `let` (e `const`) vengono sollevate, ma a differenza
 Se non avessimo dichiarato la variabile `name` all'interno della funzione `getName`, JavaScript avrebbe esaminato la _scope chain_. Lo scope esterno ha una variabile chiamata `name` con il valore di `Lydia`. In tal caso, avrebbe loggato "Lydia".
 
 ```javascript
-let name = "Lydia";
+let name = 'Lydia';
 
 function getName() {
   console.log(name);
@@ -3618,11 +3613,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();
@@ -3668,7 +3663,7 @@ console.log(two.next().value); // undefined
 ###### 113. Qual è l'output?
 
 ```javascript
-console.log(`${((x) => x)("I love")} to program`);
+console.log(`${(x => x)('I love')} to program`);
 ```
 
 - A: `I love to program`
@@ -3693,7 +3688,7 @@ Le espressioni all'interno dei template literals vengono valutate per prime. Ci
 ```javascript
 let config = {
   alert: setInterval(() => {
-    console.log("Alert!");
+    console.log('Alert!');
   }, 1000),
 };
 
@@ -3725,16 +3720,16 @@ Dal momento che non è stato cancellato, la funzione di callback `setInterval` v
 
 ```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
@@ -3761,14 +3756,14 @@ Quando si aggiunge una coppia chiave/valore usando il metodo `set`, la chiave sa
 
 ```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);
@@ -3792,7 +3787,6 @@ Entrambe le funzioni `changeAge` e `changeAgeAndName` hanno un parametro predefi
 Per prima cosa, invochiamo la funzione `changeAge` e passiamo l'oggetto `person` come argomento. Questa funzione aumenta il valore della proprietà `age` di 1. `person` ora è `{ name: "Lydia", age: 22 }`.
 
 Quindi, invochiamo la funzione `changeAgeAndName`, tuttavia non passiamo un parametro. Invece, il valore di `x` è uguale a un _nuovo_ oggetto: `{ ...person }`. Poiché si tratta di un nuovo oggetto, non influisce sui valori delle proprietà sull'oggetto `person`. `person` è ancora uguale a `{ name: "Lydia", age: 22 }`.
-
 </p>
 </details>
 
@@ -3827,7 +3821,7 @@ Con l'operatore spread `...`, possiamo _distribuire_ gli iterabili come singoli
 
 ```javascript
 let num = 1;
-const list = ["🥳", "🤠", "🥰", "🤪"];
+const list = ['🥳', '🤠', '🥰', '🤪'];
 
 console.log(list[(num += 1)]);
 ```
@@ -3853,11 +3847,11 @@ Con l'operando `+=`, stiamo incrementando il valore di `num` di `1`. `num` aveva
 
 ```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}`;
@@ -3895,10 +3889,10 @@ Con l'operatore di concatenamento opzionale `?.`, non è più necessario verific
 ###### 120. Qual è l'output?
 
 ```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!`);
 }
@@ -3954,10 +3948,10 @@ Il metodo `language` è un `setter`. I setter non detengono un valore effettivo,
 ###### 122. Qual è l'output?
 
 ```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`
@@ -3973,7 +3967,6 @@ console.log(!typeof name === "string");
 `typeof name` restituisce `"string"`. La stringa `"string"` è un valore veritiero, quindi `!typeof name` restituisce il valore booleano `false`. `false === "object"` e `false === "string"` restituiscono entrambi `false`.
 
 (Se volessimo verificare se il tipo era (non)uguale a un certo tipo, avremmo dovuto scrivere `!==` invece di `!typeof`)
-
 </p>
 </details>
 
@@ -3982,7 +3975,7 @@ console.log(!typeof name === "string");
 ###### 123. Qual è l'output?
 
 ```javascript
-const add = (x) => (y) => (z) => {
+const add = x => y => z => {
   console.log(x, y, z);
   return x + y + z;
 };
@@ -4000,7 +3993,7 @@ add(4)(5)(6);
 
 #### Risposta: A
 
-La funzione `add` restituisce una arrow function, che restituisce una arrow function, che restituisce arrow function (mi segui ancora?).
+La funzione `add` restituisce una arrow function, che restituisce una arrow function, che restituisce arrow function (mi segui ancora?). 
 La prima funzione riceve un argomento `x` con il valore di `4`. Invochiamo la seconda funzione, che riceve un argomento `y` con il valore `5`. Quindi invochiamo la terza funzione, che riceve un argomento `z` con il valore `6`. Quando si tenta di accedere ai valori `x`, `y` e `z` all'interno dell'ultima arrow function, il motore JS risale la catena dell'ambito per trovare i valori per `x` e `y`. Questo restituisce `4` `5` `6`.
 
 </p>
@@ -4073,20 +4066,20 @@ 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}`;
 }
 
-console.log(getFine(130, 300));
+console.log(getFine(130, 300))
 ```
 
 - A: The driver drove 130 and has to pay 300
@@ -4109,8 +4102,8 @@ Con il metodo `Intl.NumberFormat`, possiamo formattare i valori numerici in qual
 ###### 127. Qual è l'output?
 
 ```javascript
-const spookyItems = ["👻", "🎃", "🕸"];
-({ item: spookyItems[3] } = { item: "💀" });
+const spookyItems = ['👻', '🎃', '🕸'];
+({ item: spookyItems[3] } = { item: '💀' });
 
 console.log(spookyItems);
 ```
@@ -4135,7 +4128,7 @@ Destrutturando gli oggetti, possiamo decomprimere i valori dall'oggetto di destr
 ###### 128. Qual è l'output?
 
 ```javascript
-const name = "Lydia Hallie";
+const name = 'Lydia Hallie';
 const age = 21;
 
 console.log(Number.isNaN(name));
@@ -4158,7 +4151,6 @@ console.log(isNaN(age));
 Con il metodo `Number.isNaN`, puoi controllare se il valore passato è un _valore numerico_ e uguale a `NaN`. `name` non è un valore numerico, quindi `Number.isNaN(name)` restituisce `false`. `age` è un valore numerico, ma non è uguale a `NaN`, quindi `Numero.isNaN(age)` restituisce `false`.
 
 Con il metodo `isNaN`, puoi verificare se il valore che passi non è un numero. `name` non è un numero, quindi `isNaN(name)` restituisce true. `age` è un numero, quindi `isNaN(age)` restituisce `false`.
-
 </p>
 </details>
 
@@ -4171,7 +4163,7 @@ const randomValue = 21;
 
 function getInfo() {
   console.log(typeof randomValue);
-  const randomValue = "Lydia Hallie";
+  const randomValue = 'Lydia Hallie';
 }
 
 getInfo();
@@ -4188,7 +4180,6 @@ getInfo();
 #### Risposta: D
 
 Le variabili dichiarate con la chiave `const` non sono referenziabili prima della loro inizializzazione: questa viene chiamata _temporal dead zone_. Nella funzione `getInfo`, la variabile `randomValue` ha lo scopo nell'ambito funzionale di `getInfo`. Nella riga in cui vogliamo registrare il valore di `typeof randomValue`, la variabile `randomValue` non è ancora inizializzata: viene lanciato un `ReferenceError`! Il motore non è andato giù per la catena dell'ambito poiché abbiamo dichiarato la variabile `randomValue` nella funzione `getInfo`.
-
 </p>
 </details>
 
@@ -4197,7 +4188,7 @@ Le variabili dichiarate con la chiave `const` non sono referenziabili prima dell
 ###### 130. Qual è l'output?
 
 ```javascript
-const myPromise = Promise.resolve("Woah some cool data");
+const myPromise = Promise.resolve('Woah some cool data');
 
 (async () => {
   try {
@@ -4205,7 +4196,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!');
   }
 })();
 ```
@@ -4230,7 +4221,7 @@ Nel blocco `try`, stiamo loggando il valore atteso della variabile `myPromise`:
 ###### 131. Qual è l'output?
 
 ```javascript
-const emojis = ["🥑", ["✨", "✨", ["🍕", "🍕"]]];
+const emojis = ['🥑', ['✨', '✨', ['🍕', '🍕']]];
 
 console.log(emojis.flat(1));
 ```
@@ -4246,7 +4237,6 @@ console.log(emojis.flat(1));
 #### Risposta: B
 
 Con il metodo `flat`, possiamo creare un nuovo array appiattito. La profondità dell'array appiattito dipende dal valore che passiamo. In questo caso, abbiamo passato il valore `1` (cosa che non dovevamo fare, questo è il valore predefinito), il che significa che solo gli array sulla prima profondità verranno concatenati. `['🥑']` e `['✨', '✨', ['🍕', '🍕']]` in questo caso. Concatenando questi due array si ottengono `['🥑', '✨', '✨', ['🍕', '🍕']]`.
-
 </p>
 </details>
 
@@ -4303,19 +4293,19 @@ Invochiamo `counterTwo.increment()`, che imposta `count` su `3`. Quindi, logghia
 ###### 133. Qual è l'output?
 
 ```javascript
-const myPromise = Promise.resolve(Promise.resolve("Promise"));
+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!");
+  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!");
+  console.log(`${res} 2!`)
+  setTimeout(() => console.log('Timeout 2!'), 0);
+  console.log('Last line 2!');
 }
 
 funcOne();
@@ -4345,7 +4335,6 @@ In `funcTwo`, la variabile `res` ottiene `Promise` perché `Promise.resolve(Prom
 Quindi lo stack di chiamate è vuoto. Le promise sono _microattività_, quindi vengono risolte per prime quando lo stack di chiamate è vuoto, quindi `Promise 1!` viene registrato.
 
 Ora, da quando `funcTwo` è uscito dallo stack delle chiamate, lo stack delle chiamate è vuoto. Le callback in attesa nella coda (`() => console.log("Timeout 1!")` da `funcOne`, e `() => console.log("Timeout 2!")` da `funcTwo`) vengono aggiunti allo stack di chiamate uno per uno. Il primo callback registra `Timeout 1!` e viene eliminato dallo stack. Quindi, il secondo callback registra `Timeout 2!` e viene eliminato dallo stack.
-
 </p>
 </details>
 
@@ -4360,7 +4349,7 @@ export default function sum(x) {
 }
 
 // index.js
-import * as sum from "./sum";
+import * as sum from './sum';
 ```
 
 - A: `sum(4)`
@@ -4377,12 +4366,12 @@ Con l'asterisco `*`, importiamo tutti i valori esportati da quel file, sia prede
 
 ```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);
 ```
 
@@ -4413,13 +4402,13 @@ Possiamo invocare questa funzione, chiamando `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;
 ```
 
@@ -4449,7 +4438,7 @@ Quindi, accediamo a un valore di proprietà sull'oggetto proxy, la proprietà `g
 ###### 136. Quale delle seguenti opzioni modificherà l'oggetto `persona`?
 
 ```javascript
-const person = { name: "Lydia Hallie" };
+const person = { name: 'Lydia Hallie' };
 
 Object.seal(person);
 ```
@@ -4477,9 +4466,9 @@ Tuttavia, puoi comunque modificare il valore delle proprietà esistenti.
 
 ```javascript
 const person = {
-  name: "Lydia Hallie",
+  name: 'Lydia Hallie',
   address: {
-    street: "100 Main St",
+    street: '100 Main St',
   },
 };
 
@@ -4508,7 +4497,7 @@ Tuttavia, blocca solo _poco profondamente_ l'oggetto, il che significa che solo
 ###### 138. Qual è l'output?
 
 ```javascript
-const add = (x) => x + x;
+const add = x => x + x;
 
 function myFunc(num = 2, value = add(num)) {
   console.log(num, value);
@@ -4530,7 +4519,7 @@ myFunc(3);
 
 Per prima cosa, abbiamo invocato `myFunc()` senza passare alcun argomento. Dal momento che non abbiamo passato argomenti, `num` e `value` hanno i loro valori predefiniti: num è `2` e `value` il valore restituito dalla funzione `add`. Alla funzione `add`, passiamo `num` come argomento, che aveva il valore di `2`. `add` restituisce `4`, che è il valore di `value`.
 
-Quindi, abbiamo invocato `myFunc(3)` e passato il valore `3` come valore per l'argomento `num`. Non abbiamo passato un argomento per `value`.
+Quindi, abbiamo invocato `myFunc(3)` e passato il valore `3` come valore per l'argomento `num`. Non abbiamo passato un argomento per `value`. 
 Poiché non abbiamo passato un valore per l'argomento `value`, ha ottenuto il valore predefinito: il valore restituito dalla funzione `add`. Ad `add` passiamo `num`, che ha il valore di `3`. `add` restituisce `6`, che è il valore di `value`.
 
 </p>
@@ -4542,21 +4531,21 @@ Poiché non abbiamo passato un valore per l'argomento `value`, ha ottenuto il va
 
 ```javascript
 class Counter {
-  #number = 10;
+  #number = 10
 
   increment() {
-    this.#number++;
+    this.#number++
   }
 
   getNum() {
-    return this.#number;
+    return this.#number
   }
 }
 
-const counter = new Counter();
-counter.increment();
+const counter = new Counter()
+counter.increment()
 
-console.log(counter.#number);
+console.log(counter.#number)
 ```
 
 - A: `10`
@@ -4580,8 +4569,8 @@ In ES2020, possiamo aggiungere variabili private nelle classi usando `#`. Non po
 
 ```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) {
@@ -4624,8 +4613,8 @@ Se avessimo scritto `yield`, `return yield` o `return`, l'intera funzione del ge
 
 ```javascript
 const person = {
-  name: "Lydia Hallie",
-  hobbies: ["coding"],
+  name: 'Lydia Hallie',
+  hobbies: ['coding'],
 };
 
 function addHobby(hobby, hobbies = person.hobbies) {
@@ -4633,9 +4622,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);
 ```
@@ -4694,7 +4683,7 @@ const pet = new Flamingo();
 
 #### Risposta: B
 
-Creiamo la variabile `pet` che è un'istanza della classe `Flamingo`. Quando istanziamo questa istanza, il `constructor` su `Flamingo` viene chiamato. Per prima cosa, `"I'm pink. 🌸"` viene loggato, dopodiché chiamiamo `super()`.
+Creiamo la variabile `pet` che è un'istanza della classe `Flamingo`. Quando istanziamo questa istanza, il `constructor` su `Flamingo` viene chiamato. Per prima cosa, `"I'm pink. 🌸"` viene loggato, dopodiché chiamiamo `super()`. 
 
 `super()` chiama il costruttore della classe genitore, `Bird`. Il costruttore in `Bird` viene chiamato e registra `"I'm a bird. 🦢"`.
 
@@ -4706,11 +4695,11 @@ Creiamo la variabile `pet` che è un'istanza della classe `Flamingo`. Quando ist
 ###### 143. Quale delle opzioni genera un errore?
 
 ```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;
 ```
 
@@ -4752,7 +4741,7 @@ const person = {
 
 #### Risposta: C
 
-Gli oggetti non sono iterabili per impostazione predefinita. Un iterabile è un iterabile se è presente il protocollo iteratore.
+Gli oggetti non sono iterabili per impostazione predefinita. Un iterabile è un iterabile se è presente il protocollo iteratore. 
 Possiamo aggiungerlo manualmente aggiungendo il simbolo dell'iteratore `[Symbol.iterator]`, che deve restituire un oggetto generatore, ad esempio trasformandolo in una funzione del generatore `*[Symbol.iterator]() {}`. Questa funzione di generazione deve fornire gli `Object.values` dell'oggetto `person` se vogliamo che restituisca l'array `["Lydia Hallie", 21]`: `yield* Object.values(this)`.
 
 </p>
@@ -4766,11 +4755,11 @@ Possiamo aggiungerlo manualmente aggiungendo il simbolo dell'iteratore `[Symbol.
 let count = 0;
 const nums = [0, 1, 2, 3];
 
-nums.forEach((num) => {
-  if (num) count += 1;
-});
+nums.forEach(num => {
+	if (num) count += 1
+})
 
-console.log(count);
+console.log(count)
 ```
 
 - A: 1
@@ -4794,12 +4783,12 @@ La condizione `if` all'interno del ciclo `forEach` controlla se il valore di `nu
 
 ```javascript
 function getFruit(fruits) {
-  console.log(fruits?.[1]?.[1]);
+	console.log(fruits?.[1]?.[1])
 }
 
-getFruit([["🍊", "🍌"], ["🍍"]]);
-getFruit();
-getFruit([["🍍"], ["🍊", "🍌"]]);
+getFruit([['🍊', '🍌'], ['🍍']])
+getFruit()
+getFruit([['🍍'], ['🍊', '🍌']])
 ```
 
 - A: `null`, `undefined`, 🍌
@@ -4819,7 +4808,6 @@ Innanzitutto, stiamo cercando di registrare il secondo elemento nel sottoarray `
 Quindi, stiamo invocando la funzione `getFruits` senza passare un valore come argomento, il che significa che `fruits` ha un valore di `undefined` per impostazione predefinita. Poiché stiamo concatenando condizionatamente l'elemento sull'indice `1` di `fruits`, restituisce `undefined` poiché questo elemento sull'indice `1` non esiste.
 
 Infine, stiamo cercando di registrare il secondo elemento nel sottoarray `['🍊', '🍌']` di `['🍍'], ['🍊', '🍌']`. L'elemento nell'indice `1` all'interno di questo sottoarray è `🍌`, che viene registrato.
-
 </p>
 </details>
 
@@ -4829,19 +4817,19 @@ Infine, stiamo cercando di registrare il secondo elemento nel sottoarray `['🍊
 
 ```javascript
 class Calc {
-  constructor() {
-    this.count = 0;
-  }
+	constructor() {
+		this.count = 0 
+	}
 
-  increase() {
-    this.count++;
-  }
+	increase() {
+		this.count ++
+	}
 }
 
-const calc = new Calc();
-new Calc().increase();
+const calc = new Calc()
+new Calc().increase()
 
-console.log(calc.count);
+console.log(calc.count)
 ```
 
 - A: `0`
@@ -4855,7 +4843,6 @@ console.log(calc.count);
 #### Risposta: A
 
 Impostiamo la variabile `calc` uguale a una nuova istanza della classe `Calc`. Quindi, istanziamo una nuova `Calc` e invochiamo il metodo `increase` su questa istanza. Poiché la proprietà count è all'interno del costruttore della classe `Calc`, la proprietà count non è condivisa sul prototipo di `Calc`. Ciò significa che il valore di count non è stato aggiornato per l'istanza a cui punta il calc, count è ancora `0`.
-
 </p>
 </details>
 
@@ -4865,25 +4852,25 @@ Impostiamo la variabile `calc` uguale a una nuova istanza della classe `Calc`. Q
 
 ```javascript
 const user = {
-  email: "e@mail.com",
-  password: "12345",
-};
+	email: "e@mail.com",
+	password: "12345"
+}
 
 const updateUser = ({ email, password }) => {
-  if (email) {
-    Object.assign(user, { email });
-  }
+	if (email) {
+		Object.assign(user, { email })
+	}
 
-  if (password) {
-    user.password = password;
-  }
+	if (password) {
+		user.password = password
+	}
 
-  return user;
-};
+	return user
+}
 
-const updatedUser = updateUser({ email: "new@email.com" });
+const updatedUser = updateUser({ email: "new@email.com" })
 
-console.log(updatedUser === user);
+console.log(updatedUser === user)
 ```
 
 - A: `false`
@@ -4906,13 +4893,13 @@ La funzione `updateUser` aggiorna i valori delle proprietà `email` e `password`
 ###### 149. Qual è l'output?
 
 ```javascript
-const fruit = ["🍌", "🍊", "🍎"];
+const fruit = ['🍌', '🍊', '🍎']
 
-fruit.slice(0, 1);
-fruit.splice(0, 1);
-fruit.unshift("🍇");
+fruit.slice(0, 1)
+fruit.splice(0, 1)
+fruit.unshift('🍇')
 
-console.log(fruit);
+console.log(fruit)
 ```
 
 - A: `['🍌', '🍊', '🍎']`
@@ -4938,13 +4925,13 @@ Infine, invochiamo il metodo `unshift` sull'array `fruit`, che modifica l'array
 
 ```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]);
+console.log(animals[dog])
 ```
 
 - A: `{ emoji: "🐶", name: "Mara" }`
@@ -4959,12 +4946,12 @@ console.log(animals[dog]);
 
 Le chiavi degli oggetti vengono convertite in stringhe.
 
-Poiché il valore di `dog` è un oggetto, `animals[dog]` significa in realtà che stiamo creando una nuova proprietà chiamata `"object Object"` uguale al nuovo oggetto.
+Poiché il valore di `dog` è un oggetto, `animals[dog]` significa in realtà che stiamo creando una nuova proprietà chiamata `"object Object"` uguale al nuovo oggetto. 
 `animals["object Object"]` è ora uguale a `{ emoji: "🐶", name: "Mara"}`.
 
 Anche `cat` è un oggetto, il che significa che `animals[cat]` in realtà stiamo sovrascrivendo il valore di `animals["object Object"]` con le nuove proprietà cat.
 
-Loggando `animals[dog]`, o effettivamente `animals["object Object"]`, poiché la conversione dell'oggetto `dog` in una stringa risulta `"object Object"`, restituisce `{ emoji: "🐈", name: "Sara" }`.
+Loggando `animals[dog]`, o effettivamente `animals["object Object"]`, poiché la conversione dell'oggetto `dog` in una stringa risulta `"object Object"`, restituisce  `{ emoji: "🐈", name: "Sara" }`.
 
 </p>
 </details>
@@ -4975,14 +4962,14 @@ Loggando `animals[dog]`, o effettivamente `animals["object Object"]`, poiché la
 
 ```javascript
 const user = {
-  email: "my@email.com",
-  updateEmail: (email) => {
-    this.email = email;
-  },
-};
+	email: "my@email.com",
+	updateEmail: email => {
+		this.email = email
+	}
+}
 
-user.updateEmail("new@email.com");
-console.log(user.email);
+user.updateEmail("new@email.com")
+console.log(user.email)
 ```
 
 - A: `my@email.com`
@@ -5005,20 +4992,20 @@ La funzione `updateEmail` è una arrow function e non è legata all'oggetto `use
 ###### 152. Qual è l'output?
 
 ```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]);
-  const res2 = await Promise.all([promise3, promise4]);
-  return [res1, res2];
-};
+	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));
+	.then(res => console.log(res))
+	.catch(err => console.log(err))
 ```
 
 - A: `[['First', 'Second'], ['Fourth']]`
@@ -5038,19 +5025,16 @@ Il metodo `Promise.all` esegue le promise passate in parallelo. Se una promise f
 
 ---
 
-###### 153. Quale dovrebbe essere il valore di `method` per loggare `{nome: "Lydia", età: 22}`?
+###### 153. Quale dovrebbe essere il valore di `method` per loggare ` {nome: "Lydia", età: 22} `?
 
 ```javascript
-const keys = ["name", "age"];
-const values = ["Lydia", 22];
+const keys = ["name", "age"]
+const values = ["Lydia", 22]
 
-const method =
-  /* ?? */
-  Object[method](
-    keys.map((_, i) => {
-      return [keys[i], values[i]];
-    })
-  ); // { name: "Lydia", age: 22 }
+const method = /* ?? */
+Object[method](keys.map((_, i) => {
+	return [keys[i], values[i]]
+})) // { name: "Lydia", age: 22 }
 ```
 
 - A: `entries`
@@ -5075,18 +5059,18 @@ Questo crea una matrice di sottoarray contenenti le chiavi e i valori corretti,
 ###### 154. Qual è l'output?
 
 ```javascript
-const createMember = ({ email, address = {} }) => {
-  const validEmail = /.+\@.+\..+/.test(email);
-  if (!validEmail) throw new Error("Valid email pls");
+const createMember = ({ email, address = {}}) => {
+	const validEmail = /.+\@.+\..+/.test(email)
+	if (!validEmail) throw new Error("Valid email pls")
 
-  return {
-    email,
-    address: address ? address : null,
-  };
-};
+	return {
+		email,
+		address: address ? address : null
+	}
+}
 
-const member = createMember({ email: "my@email.com" });
-console.log(member);
+const member = createMember({ email: "my@email.com" })
+console.log(member)
 ```
 
 - A: `{ email: "my@email.com", address: null }`
@@ -5109,13 +5093,13 @@ Il valore predefinito di `address` è un oggetto vuoto `{}`. Quando abbiamo impo
 ###### 155. Qual è l'output?
 
 ```javascript
-let randomValue = { name: "Lydia" };
-randomValue = 23;
+let randomValue = { name: "Lydia" }
+randomValue = 23
 
 if (!typeof randomValue === "string") {
-  console.log("It's not a string!");
+	console.log("It's not a string!")
 } else {
-  console.log("Yay it's a string!");
+	console.log("Yay it's a string!")
 }
 ```
 
diff --git a/ja-JA/README-ja_JA.md b/ja-JA/README-ja_JA.md
index 6fcf3655..1cc85d76 100644
--- a/ja-JA/README-ja_JA.md
+++ b/ja-JA/README-ja_JA.md
@@ -1,13 +1,13 @@
-# JavaScript (高度な) 問題集
+# JavaScript  (高度な) 問題集
 
-私は毎日、JavaScript に関する選択問題を [Instagram](https://www.instagram.com/theavocoder)に投稿していますが、ここにも投稿します。
+私は毎日、JavaScriptに関する選択問題を [Instagram](https://www.instagram.com/theavocoder)に投稿していますが、ここにも投稿します。
 
-初級から上級まで： JavaScript の知識のテストを行ったり、知識を少し深めたり、コーディング面接の準備をしてください。:muscle: :rocket: 私はこのレポを毎週新しい質問で更新します。Last update: <a href=#20190629><b>June 29th</b></a>
+初級から上級まで： JavaScriptの知識のテストを行ったり、知識を少し深めたり、コーディング面接の準備をしてください。:muscle: :rocket: 私はこのレポを毎週新しい質問で更新します。Last update: <a href=#20190629><b>June 29th</b></a>
 
 答えは質問の下の折りたたまれたセクションにあります、クリックすればそれを広げられます。幸運を祈ります。:heart:
 
-利用可能な言語リスト:
 
+利用可能な言語リスト:
 - [🇸🇦 العربية](../ar-AR/README_AR.md)
 - [🇪🇬 اللغة العامية](../ar-EG/README_ar-EG.md)
 - [🇧🇦 Bosanski](../bs-BS/README-bs_BS.md)
@@ -21,7 +21,6 @@
 - [🇳🇱 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)
@@ -56,13 +55,13 @@ sayHi();
 
 #### 答え: D
 
-関数内で、まず `var`キーワードを使って `name`変数を宣言します。これは、変数が定義されている行に実際に到達するまで、変数がデフォルト値の `undefined`で初期化される（作成時にメモリ空間が設定される）ことを意味します。
+関数内で、まず `var`キーワードを使って `name`変数を宣言します。これは、変数が定義されている行に実際に到達するまで、変数がデフォルト値の `undefined`で初期化される（作成時にメモリ空間が設定される）ことを意味します。 
 
 `name`変数をログ出力を実行している行では、まだ変数を定義していませんので、`undefined`の値を保持しています。
 
 `let`キーワード（または`const`）を持つ変数は持ち上げられますが、 `var`とは異なり、初期化されません。それらを宣言（初期化）する行の前にはアクセスできません。これは"temporal dead zone"と呼ばれます。
 
-宣言される前に変数にアクセスしようとすると、JavaScript は `ReferenceError`を投げます。
+宣言される前に変数にアクセスしようとすると、JavaScriptは `ReferenceError`を投げます。
 
 </p>
 </details>
@@ -90,9 +89,9 @@ for (let i = 0; i < 3; i++) {
 
 #### 答え: C
 
-JavaScript のイベントキューのため、`setTimeout`コールバック関数はループが実行された後に呼び出されます。最初のループの変数 `i`は`var`キーワードを使って宣言されているので、この値はグローバル変数となります。ループの間、単項演算子 `++`を使用して、毎回 `i`の値を`1`ずつインクリメントしました。 最初の例では `setTimeout`コールバック関数が呼び出されるまでに`i`は`3`となりました。
+JavaScriptのイベントキューのため、`setTimeout`コールバック関数はループが実行された後に呼び出されます。最初のループの変数 `i`は`var`キーワードを使って宣言されているので、この値はグローバル変数となります。ループの間、単項演算子 `++`を使用して、毎回 `i`の値を`1`ずつインクリメントしました。 最初の例では `setTimeout`コールバック関数が呼び出されるまでに`i`は`3`となりました。
 
-2 番目のループでは、変数 `i`が `let`キーワードを使って宣言されました。 `let`（または`const`）キーワードで宣言された変数はブロックスコープです（ブロックは `{}`の間のものです）。それぞれの繰り返しの間、 `i`は新しい値を持ち、それぞれの値はループの内側にあります。
+2番目のループでは、変数 `i`が `let`キーワードを使って宣言されました。 `let`（または`const`）キーワードで宣言された変数はブロックスコープです（ブロックは `{}`の間のものです）。それぞれの繰り返しの間、 `i`は新しい値を持ち、それぞれの値はループの内側にあります。
 
 </p>
 </details>
@@ -107,7 +106,7 @@ const shape = {
   diameter() {
     return this.radius * 2;
   },
-  perimeter: () => 2 * Math.PI * this.radius,
+  perimeter: () => 2 * Math.PI * this.radius
 };
 
 shape.diameter();
@@ -126,7 +125,7 @@ shape.perimeter();
 
 `diameter`の値は正則関数であり、`perimeter`の値はアロー関数です。
 
-アロー関数では、`this`キーワードは通常の関数とは異なり、現在の周囲の範囲を参照します。これは、`perimeter`関数を呼ぶと、shape オブジェクトではなく、その周囲の範囲（例えば window）を参照することを意味します。
+アロー関数では、`this`キーワードは通常の関数とは異なり、現在の周囲の範囲を参照します。これは、`perimeter`関数を呼ぶと、shapeオブジェクトではなく、その周囲の範囲（例えば window）を参照することを意味します。
 
 そのオブジェクトには`radius`という値はなく、`undefined`を返します。
 
@@ -153,7 +152,7 @@ shape.perimeter();
 
 単項プラスは、オペランドを数値に変換しようとします。`true`は`1`、`false`は`0`です
 
-文字列「Lydia」は truthy value です。ここで求めているのは、「この truthy value は、falsy なのか」ということです。これは `false`を返します。
+文字列「Lydia」は truthy valueです。ここで求めているのは、「このtruthy valueは、falsyなのか」ということです。これは `false`を返します。
 
 </p>
 </details>
@@ -164,12 +163,12 @@ shape.perimeter();
 
 ```javascript
 const bird = {
-  size: "small",
+  size: "small"
 };
 
 const mouse = {
   name: "Mickey",
-  small: true,
+  small: true
 };
 ```
 
@@ -183,15 +182,15 @@ const mouse = {
 
 #### 答え: A
 
-JavaScript では、すべてのオブジェクトキーは文字列です（Symbol でない限り）。たとえそれを文字列として入力していなくても、それらは常にフードの下で文字列に変換されます。
+JavaScriptでは、すべてのオブジェクトキーは文字列です（Symbolでない限り）。たとえそれを文字列として入力していなくても、それらは常にフードの下で文字列に変換されます。
 
-JavaScript は、ステートメントを解釈（または、ボックス解除）します。大括弧表記を使用すると、最初の左大括弧 `[`を見て、右大括弧 `]`が見つかるまで進みます。その時だけ、そのステートメントを評価します。
+JavaScriptは、ステートメントを解釈（または、ボックス解除）します。大括弧表記を使用すると、最初の左大括弧 `[`を見て、右大括弧 `]`が見つかるまで進みます。その時だけ、そのステートメントを評価します。
 
 `mouse [bird.size]`： まず最初に、`bird.size`が評価されます。これは文字列の `"small"`となります。 `mouse["small"]`は、`true`を返します。
 
 しかし、ドット表記では、これは起こりません。 `mouse`は`bird`と呼ばれるキーを持っていません。 つまり`mouse.bird`は`undefined`となります。
 
-また、ドット表記を使って `size`を求めます： `mouse.bird.size`。 mouse.bird は未定義なので、実際には undefined.size を要求しています。これは有効ではないので、`Cannot read property "size" of undefined`ような、エラーをスローします。
+また、ドット表記を使って `size`を求めます： `mouse.bird.size`。 mouse.birdは未定義なので、実際にはundefined.sizeを要求しています。これは有効ではないので、`Cannot read property "size" of undefined`ような、エラーをスローします。
 
 </p>
 </details>
@@ -222,13 +221,13 @@ console.log(d.greeting);
 
 #### 答え: A
 
-JavaScript では、すべてのオブジェクトは互いに等しく設定すると参照によって相互作用します。
+JavaScriptでは、すべてのオブジェクトは互いに等しく設定すると参照によって相互作用します。
 
 まず、変数`c`は、オブジェクトに対する値を保持します。その後、`c`オブジェクトに対して持っている値と同じ参照で`d`に代入します。
 
 <img src="https://i.imgur.com/ko5k0fs.png" width="200">
 
-1 つのオブジェクトを変更すると、それらすべてが変更されます。
+1つのオブジェクトを変更すると、それらすべてが変更されます。
 
 </p>
 </details>
@@ -261,7 +260,7 @@ console.log(b === c);
 
 `==`演算子を使うとき、同じ値を持っているかどうか？ をチェックするだけとなります。それらは両方とも`3`の値を持っているので、それは`true`を返します。
 
-しかし、`===`演算子を使う時は、値と型は同じであるべきです。 そうでないので: `new Number()`は数値ではなく、**オブジェクト**となります。なので、両方とも false を返します。
+しかし、`===`演算子を使う時は、値と型は同じであるべきです。 そうでないので: `new Number()`は数値ではなく、**オブジェクト**となります。なので、両方ともfalseを返します。
 
 </p>
 </details>
@@ -322,7 +321,7 @@ console.log(greetign);
 
 #### 答え: A
 
-グローバルオブジェクトに、空のオブジェクトを作成したばかりなので、オブジェクトはログ出力されます。`greeting`を`greetign`と誤って入力した場合、JS インタプリタは実際にこれを `global.greetign = {}`（またはブラウザの `window.greetign = {}`）と見なします。
+グローバルオブジェクトに、空のオブジェクトを作成したばかりなので、オブジェクトはログ出力されます。`greeting`を`greetign`と誤って入力した場合、JSインタプリタは実際にこれを `global.greetign = {}`（またはブラウザの `window.greetign = {}`）と見なします。
 
 これを避けるために、"use strict"を使用する事ができます。これにより、変数を何かに設定する前に、変数宣言したことを確認できます。
 
@@ -351,7 +350,7 @@ bark.animal = "dog";
 
 #### 答え: A
 
-関数はオブジェクトとなるので、これは JavaScript で可能です。（プリミティブ型以外はすべてオブジェクトです。）
+関数はオブジェクトとなるので、これはJavaScriptで可能です。（プリミティブ型以外はすべてオブジェクトです。）
 
 関数は特別な種類のオブジェクトです。自分で書いたコードは実際の機能ではありません。関数はプロパティを持つオブジェクトです。よって、このプロパティは呼び出し可能となります。
 
@@ -369,7 +368,7 @@ function Person(firstName, lastName) {
 }
 
 const member = new Person("Lydia", "Hallie");
-Person.getFullName = function () {
+Person.getFullName = function() {
   return `${this.firstName} ${this.lastName}`;
 };
 
@@ -389,7 +388,7 @@ console.log(member.getFullName());
 通常のオブジェクトのようにコンストラクタにプロパティを追加することはできません。一度にすべてのオブジェクトに機能を追加したい場合は、代わりにプロトタイプを使用する必要があります。だからこの場合は、
 
 ```js
-Person.prototype.getFullName = function () {
+Person.prototype.getFullName = function() {
   return `${this.firstName} ${this.lastName}`;
 };
 ```
@@ -398,7 +397,7 @@ Person.prototype.getFullName = function () {
 
 その場合、多くのメモリスペースを浪費する事でしょう。なぜならそれらはまだその特性を持ち、それは各インスタンスのためにメモリスペースを消費するからです。
 
-その代わりに、プロトタイプに追加するだけであれば、メモリ内の 1 箇所に配置するだけで、すべてのユーザーがアクセスできます。
+その代わりに、プロトタイプに追加するだけであれば、メモリ内の1箇所に配置するだけで、すべてのユーザーがアクセスできます。
 
 </p>
 </details>
@@ -441,7 +440,7 @@ console.log(sarah);
 
 ---
 
-###### 13. イベント伝播の 3 つの段階はどれですか？
+###### 13. イベント伝播の3つの段階はどれですか？
 
 - A: Target > Capturing > Bubbling
 - B: Bubbling > Target > Capturing
@@ -474,9 +473,9 @@ console.log(sarah);
 
 **基本オブジェクト**を除き、すべてのオブジェクトにプロトタイプがあります。ベースオブジェクトは`.toString`のようないくつかのメソッドとプロパティにアクセスできます。
 
-これが、組み込みの JavaScript メソッドを使用できる理由です。このような方法はすべてプロトタイプで利用できます。
+これが、組み込みのJavaScriptメソッドを使用できる理由です。このような方法はすべてプロトタイプで利用できます。 
 
-JavaScript はそれをあなたのオブジェクト上で直接見つけることはできませんが、プロトタイプチェーンをたどり、見つけます。
+JavaScriptはそれをあなたのオブジェクト上で直接見つけることはできませんが、プロトタイプチェーンをたどり、見つけます。
 
 </p>
 </details>
@@ -503,9 +502,9 @@ sum(1, "2");
 
 #### 答え: C
 
-JavaScript は、**動的に型付けされた言語**です。: 特定の変数がどんな型であるかは指定しません。知らないうちに、値が自動的に別の型に変換されることがあります。この事を`implicit type coercion`と呼ばれてます。 **Coercion**は、ある型から別の型に変換しています。
+JavaScriptは、**動的に型付けされた言語**です。: 特定の変数がどんな型であるかは指定しません。知らないうちに、値が自動的に別の型に変換されることがあります。この事を`implicit type coercion`と呼ばれてます。 **Coercion**は、ある型から別の型に変換しています。
 
-この例では、関数が意味を成して値を返すために、JavaScript は数字の`1`を文字列に変換します。数値型（`1`）と 文字列型（`'2'`）の追加中は、数字は文字列として扱われます。
+この例では、関数が意味を成して値を返すために、JavaScriptは数字の`1`を文字列に変換します。数値型（`1`）と 文字列型（`'2'`）の追加中は、数字は文字列として扱われます。 
 
 `"Hello"+"World"`のように文字列を連結することができるので、ここで起こっているのは`"1"+"2"`で、これは `"12"`を返します。
 
@@ -535,11 +534,13 @@ console.log(number);
 
 **接尾辞** 単項演算子 `++`：
 
-1.値を返す（これは`0`を返す） 2.値を増やす（number は現在`1`です）
+1.値を返す（これは`0`を返す）
+2.値を増やす（numberは現在`1`です）
 
 **接頭辞** 単項演算子 `++`：
 
-1.値を増やす（数値は 2 になります） 2.値を返す（これは`2`を返します）
+1.値を増やす（数値は2になります）
+2.値を返す（これは`2`を返します）
 
 これは`0 2 2`を返します。
 
@@ -604,9 +605,9 @@ checkAge({ age: 18 });
 
 #### 答え: C
 
-等価性をテストするとき、プリミティブはそれらの値によって比較され、オブジェクトはそれらの参照によって比較されます。 JavaScript は、オブジェクトがメモリ内の同じ場所への参照を持っているかどうかを確認します。
+等価性をテストするとき、プリミティブはそれらの値によって比較され、オブジェクトはそれらの参照によって比較されます。 JavaScriptは、オブジェクトがメモリ内の同じ場所への参照を持っているかどうかを確認します。
 
-比較している 2 つのオブジェクトにはそれがありません。パラメータとして渡したオブジェクトが、等価性を確認するために使用したオブジェクトとは異なるメモリ内の場所を参照しています。
+比較している2つのオブジェクトにはそれがありません。パラメータとして渡したオブジェクトが、等価性を確認するために使用したオブジェクトとは異なるメモリ内の場所を参照しています。
 
 これが `{ age: 18 } === { age: 18 }`と、`{ age: 18 } == { age: 18 }`の両方が、`false`を返す理由です。
 
@@ -664,7 +665,7 @@ getAge();
 
 #### 答え: C
 
-`"use strict"`を使うと、誤ってグローバル変数を宣言しないようにすることができます。変数`age`を宣言したことは一度もありませんし、`"use strict"`を使っているので参照エラーになります。
+`"use strict"`を使うと、誤ってグローバル変数を宣言しないようにすることができます。変数`age`を宣言したことは一度もありませんし、`"use strict"`を使っているので参照エラーになります。 
 
 `"use strict"`を使用しなかった場合は、プロパティ`age`がグローバルオブジェクトに追加されたことになるので、それは機能します。
 
@@ -673,7 +674,7 @@ getAge();
 
 ---
 
-###### 21. sum の値は何？
+###### 21. sumの値は何？
 
 ```javascript
 const sum = eval("10*10+5");
@@ -696,7 +697,7 @@ const sum = eval("10*10+5");
 
 ---
 
-###### 22. cool_secret は、どのくらいの期間アクセス可能ですか？
+###### 22. cool_secretは、どのくらいの期間アクセス可能ですか？
 
 ```javascript
 sessionStorage.setItem("cool_secret", 123);
@@ -771,9 +772,9 @@ set.has(1);
 
 #### 答え: C
 
-すべてのオブジェクトキー（Symbols を除く）は、文字列として自分で入力しなくても、内部では文字列です。これが、`obj.hasOwnProperty('1')`も ​​true を返す理由です。
+すべてのオブジェクトキー（Symbolsを除く）は、文字列として自分で入力しなくても、内部では文字列です。これが、`obj.hasOwnProperty('1')`も​​trueを返す理由です。
 
-set ではそうはいきません。上記の set には`'1'` はありません: `set.has('1')`は、`false`を返します。数値型`1`の`set.has(1)`は、`true`を返します。
+setではそうはいきません。上記のsetには`'1'` はありません: `set.has('1')`は、`false`を返します。数値型`1`の`set.has(1)`は、`true`を返します。
 
 </p>
 </details>
@@ -797,14 +798,14 @@ console.log(obj);
 
 #### 答え: C
 
-同じ名前のキーが 2 つある場合、最初の位置にあるキーは置き換えられ、最後に指定された値になります。
+同じ名前のキーが2つある場合、最初の位置にあるキーは置き換えられ、最後に指定された値になります。
 
 </p>
 </details>
 
 ---
 
-###### 26. JavaScript の global execution context は、2 つを作成します。: それはグローバルオブジェクトと "this"キーワードです。
+###### 26. JavaScriptのglobal execution contextは、2つを作成します。: それはグローバルオブジェクトと "this"キーワードです。
 
 - A: true
 - B: false
@@ -815,7 +816,7 @@ console.log(obj);
 
 #### 答え: A
 
-基本的な execution context は、グローバルな実行コンテキストです。それはあなたのコードの至る所でアクセス可能なものです。
+基本的なexecution contextは、グローバルな実行コンテキストです。それはあなたのコードの至る所でアクセス可能なものです。
 
 </p>
 </details>
@@ -857,7 +858,7 @@ String.prototype.giveLydiaPizza = () => {
 
 const name = "Lydia";
 
-console.log(name.giveLydiaPizza());
+console.log(name.giveLydiaPizza())
 ```
 
 - A: `"Just give Lydia pizza already!"`
@@ -904,9 +905,9 @@ console.log(a[b]);
 
 #### 答え: B
 
-オブジェクトキーは自動的に文字列に変換されます。オブジェクト a のキーとして、値 123 で設定しようとしています。
+オブジェクトキーは自動的に文字列に変換されます。オブジェクトaのキーとして、値123で設定しようとしています。
 
-しかし、オブジェクトを文字列化すると、それは`"[object Object]"`​​ になってしまいます。なので、ここで行っているのは、 `a["object Object"] = 123`です。
+しかし、オブジェクトを文字列化すると、それは`"[object Object]"`​​になってしまいます。なので、ここで行っているのは、 `a["object Object"] = 123`です。
 
 その後、同じことをもう一度試みています。`c`は暗黙のうちに文字列化している別のオブジェクトです。そのため、`a["object Object"] = 456`となります。
 
@@ -941,9 +942,9 @@ baz();
 
 `setTimeout`関数があり、それを最初に呼び出したのですが、それは最後にログ出力されました。
 
-これは、ブラウザにはランタイムエンジンがあるだけでなく、`WebAPI`と呼ばれるものもあるからです。`WebAPI`は最初に`setTimeout`関数を与えてくれます。例えば DOM です。
+これは、ブラウザにはランタイムエンジンがあるだけでなく、`WebAPI`と呼ばれるものもあるからです。`WebAPI`は最初に`setTimeout`関数を与えてくれます。例えばDOMです。
 
-callback が WebAPI にプッシュされた後、`setTimeout`関数自体（コールバックではありません!）がスタックからポップされます。
+callbackがWebAPIにプッシュされた後、`setTimeout`関数自体（コールバックではありません!）がスタックからポップされます。
 
 <img src="https://i.imgur.com/X5wsHOg.png" width="200">
 
@@ -955,11 +956,11 @@ callback が WebAPI にプッシュされた後、`setTimeout`関数自体（コ
 
 <img src="https://i.imgur.com/WhA2bCP.png" width="200">
 
-WebAPI は、準備が整ったときにスタックに、なにかを追加することはできません。代わりに、コールバック関数を`queue`と呼ばれるものにプッシュします。
+WebAPIは、準備が整ったときにスタックに、なにかを追加することはできません。代わりに、コールバック関数を`queue`と呼ばれるものにプッシュします。
 
 <img src="https://i.imgur.com/NSnDZmU.png" width="200">
 
-event loop が機能し始めるところです。 **event loop**はスタックとタスクキューを調べます。スタックが空の場合は、キューの最初のものを取り出し、それをスタックにプッシュします。
+event loopが機能し始めるところです。 **event loop**はスタックとタスクキューを調べます。スタックが空の場合は、キューの最初のものを取り出し、それをスタックにプッシュします。
 
 <img src="https://i.imgur.com/uyiScAI.png" width="200">
 
@@ -970,12 +971,14 @@ event loop が機能し始めるところです。 **event loop**はスタック
 
 ---
 
-###### 31.ボタンをクリックしたときの event.target は何ですか？
+###### 31.ボタンをクリックしたときのevent.targetは何ですか？
 
 ```html
 <div onclick="console.log('first div')">
   <div onclick="console.log('second div')">
-    <button onclick="console.log('button')">Click!</button>
+    <button onclick="console.log('button')">
+      Click!
+    </button>
   </div>
 </div>
 ```
@@ -997,11 +1000,14 @@ event loop が機能し始めるところです。 **event loop**はスタック
 
 ---
 
-###### 32. p 要素をクリックすると、ログ出力はどうなりますか。
+
+###### 32. p要素をクリックすると、ログ出力はどうなりますか。
 
 ```html
 <div onclick="console.log('div')">
-  <p onclick="console.log('p')">Click here!</p>
+  <p onclick="console.log('p')">
+    Click here!
+  </p>
 </div>
 ```
 
@@ -1015,7 +1021,7 @@ event loop が機能し始めるところです。 **event loop**はスタック
 
 #### 答え: A
 
-`p`をクリックすると、`p`と`div`の 2 つのログが表示されます。イベント伝播中は、キャプチャ、ターゲット、バブリングの 3 つのフェーズがあります。
+`p`をクリックすると、`p`と`div`の2つのログが表示されます。イベント伝播中は、キャプチャ、ターゲット、バブリングの3つのフェーズがあります。
 
 デフォルトでは、イベントハンドラはバブリング段階で実行されます（`useCapture`を`true`に設定しない限り）。最も深くネストした要素から外側に向かって進みます。
 
@@ -1078,14 +1084,14 @@ typeof sayHi();
 
 `sayHi`関数は、即時呼び出し関数式（IIFE）の戻り値を返します。この関数は`0`を返しました。それは`"number"`型です。
 
-参考：7 つの組み込み型しかありません： `null`, `undefined`, `boolean`, `number`, `string`, `object`, `symbol`, そして `bigint`。関数はオブジェクトなので、`"function"`型ではなく`"object"`型です。
+参考：7つの組み込み型しかありません： `null`, `undefined`, `boolean`, `number`, `string`, `object`, `symbol`, そして `bigint`。関数はオブジェクトなので、`"function"`型ではなく`"object"`型です。
 
 </p>
 </details>
 
 ---
 
-###### 35. これらの値のどれが falsy ですか？
+###### 35. これらの値のどれがfalsyですか？
 
 ```javascript
 0;
@@ -1099,14 +1105,14 @@ undefined;
 - A: `0`, `''`, `undefined`
 - B: `0`, `new Number(0)`, `''`, `new Boolean(false)`, `undefined`
 - C: `0`, `''`, `new Boolean(false)`, `undefined`
-- D: これらすべて falsy
+- D: これらすべてfalsy
 
 <details><summary><b>答え</b></summary>
 <p>
 
 #### 答え: A
 
-falsy の値は 6 つだけです。
+falsyの値は6つだけです。
 
 - `undefined`
 - `null`
@@ -1115,7 +1121,7 @@ falsy の値は 6 つだけです。
 - `''` (empty string)
 - `false`
 
-`new Number`や、`new Boolean`のような関数コンストラクタは truthy です。
+`new Number`や、`new Boolean`のような関数コンストラクタはtruthyです。
 
 </p>
 </details>
@@ -1165,11 +1171,11 @@ console.log(numbers);
 
 #### 答え: C
 
-配列の長さを超える値を配列内の要素に設定すると、JavaScript では、"empty slots"と呼ばれるものを作成します。これらは実際には、`undefined`の値を持ちますが、あなたは以下のようなものを見るでしょう
+配列の長さを超える値を配列内の要素に設定すると、JavaScriptでは、"empty slots"と呼ばれるものを作成します。これらは実際には、`undefined`の値を持ちますが、あなたは以下のようなものを見るでしょう
 
 `[1, 2, 3, 7 x empty, 11]`
 
-実行場所によって異なります（browser、node などによって異なります）。
+実行場所によって異なります（browser、nodeなどによって異なります）。
 
 </p>
 </details>
@@ -1206,18 +1212,18 @@ console.log(numbers);
 
 後に、このブロックスコープ変数を`1`に設定し、変数`y`の値を設定します。ここで、ブロックスコープ変数`x`をログ出力します。これは`1`となります。
 
-`catch`ブロック以外では、`x`は未定義、`y`は 2 です。 `catch`ブロックの外側で`console.log(x)`した場合は、`undefined`を返し、`y`は`2`を返します。
+`catch`ブロック以外では、`x`は未定義、`y`は2です。 `catch`ブロックの外側で`console.log(x)`した場合は、`undefined`を返し、`y`は`2`を返します。
 
 </p>
 </details>
 
 ---
 
-###### 39. JavaScript のすべてはどちらかです...
+###### 39. JavaScriptのすべてはどちらかです...
 
 - A: primitive か object
 - B: function か object
-- C: ひっかけ問題! objects のみ
+- C: ひっかけ問題! objectsのみ
 - D: number か object
 
 <details><summary><b>答え</b></summary>
@@ -1225,13 +1231,13 @@ console.log(numbers);
 
 #### 答え: A
 
-JavaScript にはプリミティブ型とオブジェクトしかありません。
+JavaScriptにはプリミティブ型とオブジェクトしかありません。
 
 プリミティブ型は、`boolean`, `null`, `undefined`, `bigint`, `number`, `string`, そして`symbol`です。
 
 プリミティブとオブジェクトを区別するのは、プリミティブにはプロパティもメソッドもないということです。
 
-ただし、`'foo'.toUpperCase()`は`'FOO'`と評価され、`TypeError`にはなりません。これは、文字列のようなプリミティブのプロパティやメソッドにアクセスしようとすると、JavaScript がラッパークラスの 1 つ、すなわち`String`を使ってオブジェクトを暗黙的にラップし、式が評価された後ラッパーを直ちに破棄するためです。
+ただし、`'foo'.toUpperCase()`は`'FOO'`と評価され、`TypeError`にはなりません。これは、文字列のようなプリミティブのプロパティやメソッドにアクセスしようとすると、JavaScriptがラッパークラスの1つ、すなわち`String`を使ってオブジェクトを暗黙的にラップし、式が評価された後ラッパーを直ちに破棄するためです。 
 
 `null`と`undefined`を除くすべてのプリミティブはこの振る舞いをします。
 
@@ -1243,10 +1249,7 @@ JavaScript にはプリミティブ型とオブジェクトしかありません
 ###### 40. 何が出力されるでしょうか？
 
 ```javascript
-[
-  [0, 1],
-  [2, 3],
-].reduce(
+[[0, 1], [2, 3]].reduce(
   (acc, cur) => {
     return acc.concat(cur);
   },
@@ -1291,24 +1294,25 @@ JavaScript にはプリミティブ型とオブジェクトしかありません
 
 #### 答え: B
 
-`null`は falsy です。`!null`は`true`を返します。`!true`は`false`を返します。
+`null`はfalsyです。`!null`は`true`を返します。`!true`は`false`を返します。
 
-`""`は falsy です。`!""`は`true`を返します。`!true`は`false`を返します。
+`""`はfalsyです。`!""`は`true`を返します。`!true`は`false`を返します。
 
-`1`は truthy です。`!1`は`false`を返します。`!false`は`true`を返します。
+`1`はtruthyです。`!1`は`false`を返します。`!false`は`true`を返します。
 
 </p>
 </details>
 
 ---
 
+
 ###### 42. `setInterval`メソッドはブラウザに何を返しますか？
 
 ```javascript
 setInterval(() => console.log("Hi"), 1000);
 ```
 
-- A: ユニーク id
+- A: ユニークid
 - B: 指定されたミリ秒数
 - C: 渡された関数
 - D: `undefined`
@@ -1318,7 +1322,7 @@ setInterval(() => console.log("Hi"), 1000);
 
 #### 答え: A
 
-一意の ID を返します。この ID は `clearInterval()`関数で、その間隔をクリアするために使うことができます。
+一意のIDを返します。このIDは `clearInterval()`関数で、その間隔をクリアするために使うことができます。
 
 </p>
 </details>
@@ -1341,7 +1345,7 @@ setInterval(() => console.log("Hi"), 1000);
 
 #### 答え: A
 
-文字列はイテラブルです。スプレッド演算子は、イテラブルのすべての文字を 1 つの要素にマッピングします。
+文字列はイテラブルです。スプレッド演算子は、イテラブルのすべての文字を1つの要素にマッピングします。
 
 </p>
 </details>
@@ -1398,7 +1402,7 @@ const secondPromise = new Promise((res, rej) => {
   setTimeout(res, 100, "two");
 });
 
-Promise.race([firstPromise, secondPromise]).then((res) => console.log(res));
+Promise.race([firstPromise, secondPromise]).then(res => console.log(res));
 ```
 
 - A: `"one"`
@@ -1413,7 +1417,7 @@ Promise.race([firstPromise, secondPromise]).then((res) => console.log(res));
 
 複数のプロミスを`Promise.race`メソッドに渡した時、"resolves/rejects"は、"最初"のプロミスの"resolves/rejects"を行います。
 
-`setTimeout`メソッドには、タイマーを渡します: 最初のプロミスには 500ms(`firstPromise`)、2 番目のプロミスには 100ms(`secondPromise`)。
+`setTimeout`メソッドには、タイマーを渡します: 最初のプロミスには500ms(`firstPromise`)、2番目のプロミスには100ms(`secondPromise`)。
 
 これは、`secondPromise`が最初に`'two'`の値で解決されることを意味します。`res`は`'two'`の値を保持するようになり、ログ出力されます。
 
@@ -1457,7 +1461,7 @@ console.log(members);
 <img src="https://i.imgur.com/sYjcsMT.png" width="300">
 
 その要素はオブジェクトへの異なる（コピーされた）参照を持っているので、`person`変数の値を変更するだけで配列の最初の要素は変更されません。 `members`の最初の要素はまだ元のオブジェクトへの参照を保持しています。
-
+ 
 `members`配列をログ出力したとき、最初の要素はまだオブジェクトの値を保持しているので、それがログ出力されます。
 
 </p>
@@ -1470,7 +1474,7 @@ console.log(members);
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21,
+  age: 21
 };
 
 for (const item in person) {
@@ -1513,18 +1517,18 @@ console.log(3 + 4 + "5");
 
 #### 答え: B
 
-演算子結合性は、コンパイラーが式を評価する順序（左から右または右から左）となります。これは、すべての演算子が同じ優先順位を持つ場合にのみ発生します。演算子の種類は 1 つだけです: `+`。さらに、結合性は左から右です。
+演算子結合性は、コンパイラーが式を評価する順序（左から右または右から左）となります。これは、すべての演算子が同じ優先順位を持つ場合にのみ発生します。演算子の種類は1つだけです: `+`。さらに、結合性は左から右です。
 
 `3 + 4`が最初に評価されます。これは数字の`7`になります。
 
-`7 + '5'`は、強制的に`"75"`になります。 JavaScript では、数字の`7`を文字列に変換します。質問 15 を参照してください。2 つの文字列を演算子の`+`を使って連結することができます。よって、`"7" + "5"`は、`"75"`になります。
+`7 + '5'`は、強制的に`"75"`になります。 JavaScriptでは、数字の`7`を文字列に変換します。質問15を参照してください。2つの文字列を演算子の`+`を使って連結することができます。よって、`"7" + "5"`は、`"75"`になります。
 
 </p>
 </details>
 
 ---
 
-###### 49. num の値は何ですか？
+###### 49. numの値は何ですか？
 
 ```javascript
 const num = parseInt("7*6", 10);
@@ -1540,9 +1544,9 @@ const num = parseInt("7*6", 10);
 
 #### 答え: C
 
-文字列の最初の数字だけが返されます。"基数"（解析する数値の種類を指定するための 2 番目の引数: 基数 10, 16 進数, 8 進数, 2 進数など）に基づいて、`parseInt`は文字列内の文字が有効かどうかをチェックします。基数の中で有効な数字ではない文字に出会うと、構文解析を停止して次の文字を無視します。
+文字列の最初の数字だけが返されます。"基数"（解析する数値の種類を指定するための2番目の引数: 基数10, 16進数, 8進数, 2進数など）に基づいて、`parseInt`は文字列内の文字が有効かどうかをチェックします。基数の中で有効な数字ではない文字に出会うと、構文解析を停止して次の文字を無視します。
 
-`*`は、有効な数字ではありません。`"7"`を、10 進数の`7`に解析するだけです。そのまま num は`7`の値を保持します。
+`*`は、有効な数字ではありません。`"7"`を、10進数の`7`に解析するだけです。そのままnumは`7`の値を保持します。
 
 </p>
 </details>
@@ -1552,7 +1556,7 @@ const num = parseInt("7*6", 10);
 ###### 50. 何が出力されるでしょうか？
 
 ```javascript
-[1, 2, 3].map((num) => {
+[1, 2, 3].map(num => {
   if (typeof num === "number") return;
   return num * 2;
 });
@@ -1568,7 +1572,7 @@ const num = parseInt("7*6", 10);
 
 #### 答え: C
 
-配列をマッピングするとき、`num`の値に代入されるのは、ループで渡ってくる要素となります。この場合、要素は数値なので、if ステートメント `typeof num === "number"`の条件は`true`を返します。 map 関数は新しい配列を作成して関数から返された値を挿入します。
+配列をマッピングするとき、`num`の値に代入されるのは、ループで渡ってくる要素となります。この場合、要素は数値なので、ifステートメント `typeof num === "number"`の条件は`true`を返します。 map関数は新しい配列を作成して関数から返された値を挿入します。
 
 ただし、値は返されません。関数から値を返さないと、関数は`undefined`を返します。配列内のすべての要素に対して関数ブロックが呼び出されるので、各要素に対して`undefined`を返します。
 
@@ -1603,7 +1607,7 @@ console.log(person, birthYear);
 
 #### 答え: A
 
-値がオブジェクトでない限り、引数は"値"によって渡され、その後、"参照"によって渡されます。 `birthYear`はオブジェクトではなく文字列なので、値で渡されます。引数を値で渡すと、その値の"コピー"が作成されます（質問 46 を参照）。
+値がオブジェクトでない限り、引数は"値"によって渡され、その後、"参照"によって渡されます。 `birthYear`はオブジェクトではなく文字列なので、値で渡されます。引数を値で渡すと、その値の"コピー"が作成されます（質問46を参照）。
 
 変数`birthYear`は、値`"1997"`への参照を持ちます。引数`year`は、値`"1997"`も参照していますが、それは`birthYear`が参照しているのと同じ値ではありません。`year`に`"1998"`を代入することによって`year`の値を更新したとしても、`year`の値を更新するだけです。`birthYear`はまだ`"1997"`となります。
 
@@ -1711,15 +1715,15 @@ y = 10;
 let x = y;
 ```
 
-`y`に`10`を代入すると、実際にはグローバルオブジェクトにプロパティ`y`が追加されます（ブラウザでは`window`、node では`global`）。ブラウザでは、`window.y`は`10`となりました。
+`y`に`10`を代入すると、実際にはグローバルオブジェクトにプロパティ`y`が追加されます（ブラウザでは`window`、nodeでは`global`）。ブラウザでは、`window.y`は`10`となりました。
 
-それから、変数`x`を`10`である値`y`で宣言します。`let`キーワードで宣言された変数は"ブロックスコープ"となり、宣言されたブロック内でのみ定義されます。この場合は即時関数（IIFE）となります。
+それから、変数`x`を`10`である値`y`で宣言します。`let`キーワードで宣言された変数は"ブロックスコープ"となり、宣言されたブロック内でのみ定義されます。この場合は即時関数（IIFE）となります。 
 
 `typeof`演算子使用時、オペランド`x`は定義されていません: 宣言されているブロックの外側で`x`にアクセスしようとしています。これは`x`が定義されていないことを意味します。
 
 値が割り当てられていない、または宣言されていない値は`"undefined"`型となります。なので`console.log(typeof x)`は`"undefined"`を返します。
 
-y に関しては、`y`に`10`を代入するときにグローバル変数`y`を作成しました。この値は、コード内のどこからでもアクセスできます。`y`が定義されていて、`"number"`型の値を保持します。よって`console.log(typeof y)`は`"number"`を返します。
+yに関しては、`y`に`10`を代入するときにグローバル変数`y`を作成しました。この値は、コード内のどこからでもアクセスできます。`y`が定義されていて、`"number"`型の値を保持します。よって`console.log(typeof y)`は`"number"`を返します。
 
 </p>
 </details>
@@ -1733,7 +1737,7 @@ class Dog {
   }
 }
 
-Dog.prototype.bark = function () {
+Dog.prototype.bark = function() {
   console.log(`Woof I am ${this.name}`);
 };
 
@@ -1785,9 +1789,10 @@ console.log(set);
 
 #### 答え: D
 
+
 `Set`オブジェクトは _unique_ の値の集合です: 値は集合の中で一度だけ現れることができます
 
-値`1`が重複したイテラブル`[1、1、2、3、4]`を渡しました。セット内に同じ値を 2 つ持つことはできないので、そのうちの 1 つが削除され`{1、2、3、4}`となります。
+値`1`が重複したイテラブル`[1、1、2、3、4]`を渡しました。セット内に同じ値を2つ持つことはできないので、そのうちの1つが削除され`{1、2、3、4}`となります。
 
 </p>
 </details>
@@ -1850,9 +1855,9 @@ console.log(delete age);
 
 #### 答え: A
 
-`delete`演算子は、ブール値を返します: 正常に削除された場合は true、それ以外の場合は false を返します。`var`, `const`または`let`キーワードで宣言された変数は`delete`演算子を使って削除することはできません。
+`delete`演算子は、ブール値を返します: 正常に削除された場合はtrue、それ以外の場合はfalseを返します。`var`, `const`または`let`キーワードで宣言された変数は`delete`演算子を使って削除することはできません。
 
-`name`変数は`const`キーワードで宣言されているので、削除は成功しません: `false`が返されます。
+`name`変数は`const`キーワードで宣言されているので、削除は成功しません: `false`が返されます。 
 
 `age`を`21`に設定すると、実際にはグローバルオブジェクトに`age`というプロパティを追加されました。グローバルオブジェクトからもプロパティを削除することができますので、`delete age`は`true`を返します。
 
@@ -1952,7 +1957,7 @@ console.log(Object.keys(person));
 
 #### 答え: B
 
-`defineProperty`メソッドを使うと、オブジェクトに新しいプロパティを追加したり、既存のプロパティを修正することができます。 `defineProperty`メソッドを使ってオブジェクトにプロパティを追加すると、それらはデフォルトでは _列挙できません_。
+`defineProperty`メソッドを使うと、オブジェクトに新しいプロパティを追加したり、既存のプロパティを修正することができます。 `defineProperty`メソッドを使ってオブジェクトにプロパティを追加すると、それらはデフォルトでは _列挙できません_。 
 
 `Object.keys`メソッドはオブジェクトから全ての _enumerable_ （列挙可能）なプロパティ名を返します。上記の場合は`"name"`だけとなります。
 
@@ -1969,7 +1974,7 @@ console.log(Object.keys(person));
 const settings = {
   username: "lydiahallie",
   level: 19,
-  health: 90,
+  health: 90
 };
 
 const data = JSON.stringify(settings, ["level", "health"]);
@@ -1986,11 +1991,11 @@ console.log(data);
 
 #### 答え: A
 
-`JSON.stringify`の 2 番目の引数は _replacer_ です。replacer は、関数または配列のいずれかにすることができ、値を文字列化する対象とその方法を制御できます。
+`JSON.stringify`の2番目の引数は _replacer_ です。replacerは、関数または配列のいずれかにすることができ、値を文字列化する対象とその方法を制御できます。
 
-replacer が _array_ の場合、名前が配列に含まれるプロパティのみが JSON 文字列に追加されます。上記の場合、`"level"`と`"health"`という名前のプロパティだけが含まれ、`"username"`は除外されます。`data`は`"{" level "：19、" health "：90}"`となります。
+replacerが _array_ の場合、名前が配列に含まれるプロパティのみがJSON文字列に追加されます。上記の場合、`"level"`と`"health"`という名前のプロパティだけが含まれ、`"username"`は除外されます。`data`は`"{" level "：19、" health "：90}"`となります。
 
-replacer が _function_ の場合、この関数は文字列化しているオブジェクト内のすべてのプロパティに対して呼び出されます。この関数から返される値は、JSON 文字列に追加されたときのプロパティの値になり、値が`undefined`の場合、このプロパティは JSON 文字列から除外されます。
+replacerが _function_ の場合、この関数は文字列化しているオブジェクト内のすべてのプロパティに対して呼び出されます。この関数から返される値は、JSON文字列に追加されたときのプロパティの値になり、値が`undefined`の場合、このプロパティはJSON文字列から除外されます。
 
 </p>
 </details>
@@ -2003,7 +2008,7 @@ replacer が _function_ の場合、この関数は文字列化しているオ
 let num = 10;
 
 const increaseNumber = () => num++;
-const increasePassedNumber = (number) => number++;
+const increasePassedNumber = number => number++;
 
 const num1 = increaseNumber();
 const num2 = increasePassedNumber(num1);
@@ -2056,17 +2061,18 @@ multiply(value);
 
 #### 答え: C
 
-ES6 では、パラメータをデフォルト値で初期化できます。値が関数に渡されていない場合やパラメータの値が `"undefined"`の場合、パラメータの値はデフォルト値になります。上記の場合、`value`オブジェクトのプロパティを新しいオブジェクトに分割代入されるので、`x`のデフォルト値は`{number：10}`になります。
+
+ES6では、パラメータをデフォルト値で初期化できます。値が関数に渡されていない場合やパラメータの値が `"undefined"`の場合、パラメータの値はデフォルト値になります。上記の場合、`value`オブジェクトのプロパティを新しいオブジェクトに分割代入されるので、`x`のデフォルト値は`{number：10}`になります。
 
 デフォルトの引数は、_呼び出し時_ に評価されます。関数を呼び出すたびに、_新しい_ オブジェクトが作成されます。
 
-最初に値を渡さずに 2 回、`multiply`関数を呼び出します: `x`のデフォルト値は `{number：10}`となり、その数の乗算された値、つまり `20`を出力します。
+最初に値を渡さずに2回、`multiply`関数を呼び出します: `x`のデフォルト値は `{number：10}`となり、その数の乗算された値、つまり `20`を出力します。
 
-3 回目の multiply を呼び出すとき、引数を渡します: `value`というオブジェクトです。
+3回目のmultiplyを呼び出すとき、引数を渡します: `value`というオブジェクトです。
 
 `*=`演算子は`x.number = x.number * 2`の省略形となります: `x.number`の値は乗算した値に修正され、`20`を出力します。
 
-4 回目は、`value`オブジェクトをもう一度渡します。`x.number`は以前は`20`に修正されているので、`x.number *= 2`は`40`を出力します。
+4回目は、`value`オブジェクトをもう一度渡します。`x.number`は以前は`20`に修正されているので、`x.number *= 2`は`40`を出力します。
 
 </p>
 </details>
@@ -2089,7 +2095,8 @@ ES6 では、パラメータをデフォルト値で初期化できます。値
 
 #### 答え: D
 
-`reduce`メソッドが受け取る最初の引数は _アキュムレータ_ となります。この場合は`x`です。 2 番目の引数は、_現在の値_ `y`です。 reduce メソッドでは、配列内のすべての要素に対してコールバック関数を実行します。これにより、最終的に 1 つの値が得られます。
+
+`reduce`メソッドが受け取る最初の引数は _アキュムレータ_ となります。この場合は`x`です。 2番目の引数は、_現在の値_ `y`です。 reduceメソッドでは、配列内のすべての要素に対してコールバック関数を実行します。これにより、最終的に1つの値が得られます。
 
 上記の例では、値を返していません。単にアキュムレータの値と現在の値を記録しています。
 
@@ -2099,14 +2106,14 @@ ES6 では、パラメータをデフォルト値で初期化できます。値
 
 関数から値を返さなければ、`undefined`を返します。次の呼び出しでは、アキュムレータは`undefined`で、現在の値は`3`です。`undefined`と`3`が出力されます。
 
-4 回目の呼び出しでも、コールバック関数からは戻りません。アキュムレータもまた`undefined`であり、現在の値は`4`となり、`undefined`と`4`が出力されます。
+4回目の呼び出しでも、コールバック関数からは戻りません。アキュムレータもまた`undefined`であり、現在の値は`4`となり、`undefined`と`4`が出力されます。
 
 </p>
 </details>
   
 ---
 
-###### 66. どのコンストラクタを使えば `Dog` class を継承できるでしょうか？
+###### 66. どのコンストラクタを使えば `Dog` classを継承できるでしょうか？
 
 ```javascript
 class Dog {
@@ -2116,7 +2123,7 @@ class Dog {
 };
 
 class Labrador extends Dog {
-  // 1
+  // 1 
   constructor(name, size) {
     this.size = size;
   }
@@ -2130,7 +2137,7 @@ class Labrador extends Dog {
     super(name);
     this.size = size;
   }
-  // 4
+  // 4 
   constructor(name, size) {
     this.name = name;
     this.size = size;
@@ -2149,14 +2156,13 @@ class Labrador extends Dog {
 
 #### 答え: B
 
-派生クラスでは、`super`を呼び出す前に、`this`キーワードにアクセスすることはできません。そうしようとすると、ReferenceError がスローされます: 1 と 4 は参照エラーをスローします。
+派生クラスでは、`super`を呼び出す前に、`this`キーワードにアクセスすることはできません。そうしようとすると、ReferenceErrorがスローされます: 1と4は参照エラーをスローします。
 
 `super`キーワードを使って、与えられた引数で、その親クラスのコンストラクタを呼び出します。親のコンストラクタは`name`引数を受け取るので、`name`を`super`に渡す必要があります。
 
-`Labrador`クラスは 2 つの引数、`Dog`を拡張するための`name`と、`Labrador`クラスの追加のプロパティとしての`size`を受け取ります。
-
-両方とも`Labrador`のコンストラクタ関数に渡す必要があります。これはコンストラクタ 2 を使って正しく実行されます。
+`Labrador`クラスは2つの引数、`Dog`を拡張するための`name`と、`Labrador`クラスの追加のプロパティとしての`size`を受け取ります。
 
+両方とも`Labrador`のコンストラクタ関数に渡す必要があります。これはコンストラクタ2を使って正しく実行されます。
 </p>
 </details>
 
@@ -2166,12 +2172,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;
 ```
 
@@ -2187,9 +2193,9 @@ export const sum = (a, b) => a + b;
 
 `import`キーワードを使うと、全てのインポートされたモジュールは _事前解析_ されます。これは、インポートされたモジュールが _最初_ に実行され、_その後_ モジュールをインポートしたファイル内のコードが実行されることを意味します。
 
-これは CommonJS の`require()`と`import`の違いです。`require()`を使うと、コードが実行されている間に依存関係をオンデマンドでロードすることができます。
+これはCommonJSの`require()`と`import`の違いです。`require()`を使うと、コードが実行されている間に依存関係をオンデマンドでロードすることができます。 
 
-`import`の代わりに`require`を使用したとしたら、`running index.js`, `running sum.js`, `3`が出力されているはずです。
+`import`の代わりに`require`を使用したとしたら、`running index.js`, `running sum.js`, `3`が出力されているはずです。 
 
 </p>
 </details>
@@ -2199,9 +2205,9 @@ export const sum = (a, b) => a + b;
 ###### 68. 何が出力されるでしょうか？
 
 ```javascript
-console.log(Number(2) === Number(2));
-console.log(Boolean(false) === Boolean(false));
-console.log(Symbol("foo") === Symbol("foo"));
+console.log(Number(2) === Number(2))
+console.log(Boolean(false) === Boolean(false))
+console.log(Symbol('foo') === Symbol('foo'))
 ```
 
 - A: `true`, `true`, `false`
@@ -2214,9 +2220,9 @@ console.log(Symbol("foo") === Symbol("foo"));
 
 #### 答え: A
 
-すべてのシンボルは完全にユニークです。シンボルに渡される引数の目的は、シンボルに説明を与えることです。Symbol の値は渡された引数に依存しません。
+すべてのシンボルは完全にユニークです。シンボルに渡される引数の目的は、シンボルに説明を与えることです。Symbolの値は渡された引数に依存しません。
 
-等価性をテストしているので、2 つのまったく新しいシンボルを作成します: 最初の`Symbol('foo')`と、2 番目の`Symbol('foo')`です。これら 2 つの値は一意であり、互いに等しくはありません、なので`Symbol('foo') === Symbol('foo')`は`false`を返します。
+等価性をテストしているので、2つのまったく新しいシンボルを作成します: 最初の`Symbol('foo')`と、2番目の`Symbol('foo')`です。これら2つの値は一意であり、互いに等しくはありません、なので`Symbol('foo') === Symbol('foo')`は`false`を返します。
 
 </p>
 </details>
@@ -2226,22 +2232,22 @@ console.log(Symbol("foo") === Symbol("foo"));
 ###### 69. 何が出力されるでしょうか？
 
 ```javascript
-const name = "Lydia Hallie";
-console.log(name.padStart(13));
-console.log(name.padStart(2));
+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"`,
+- D: `"Lydia Hallie"`, `"Lyd"`, 
 
 <details><summary><b>答え</b></summary>
 <p>
 
 #### 答え: C
 
-`padStart`メソッドを使うと、文字列の先頭にパディングを追加できます。このメソッドに渡される値は、パディングとともに文字列の長さの _合計_ です。文字列`"Lydia Hallie"`の長さは`12`です。 `name.padStart(13)`は、12 + 1 が 13 であるため、文字列の先頭に 1 スペースを挿入されます。
+`padStart`メソッドを使うと、文字列の先頭にパディングを追加できます。このメソッドに渡される値は、パディングとともに文字列の長さの _合計_ です。文字列`"Lydia Hallie"`の長さは`12`です。 `name.padStart(13)`は、12 + 1が13であるため、文字列の先頭に1スペースを挿入されます。
 
 `padStart`メソッドに渡された引数が、配列の長さよりも小さい場合、パディングは追加されません。
 
@@ -2266,6 +2272,7 @@ console.log("🥑" + "💻");
 
 #### 答え: A
 
+
 `+`演算子を使うと、文字列を連結することができます。この場合、文字列`"🥑"`を文字列`"💻"`と連結して、結果として`"🥑💻"`となります。
 
 </p>
@@ -2273,7 +2280,7 @@ console.log("🥑" + "💻");
 
 ---
 
-###### 71. console.log ステートメントの後にコメントアウトされている値を、ログ出力する方法を教えてください。
+###### 71. console.logステートメントの後にコメントアウトされている値を、ログ出力する方法を教えてください。
 
 ```javascript
 function* startGame() {
@@ -2301,11 +2308,11 @@ console.log(/* 2 */); // JavaScript loves you back ❤️
 
 ジェネレータ関数は、`yield`キーワードを見るとその実行を「一時停止」します。まず、関数に文字列 "Do you love JavaScript?" を返させる必要があります。これは `game.next().value`を呼び出すことによって行うことができます。
 
-最初の`yield`キーワードが見つかるまで、すべての行が実行されます。関数内の最初の行に`yield`キーワードがあります: 実行は最初の yield で停止します！ _これは変数 `answer`がまだ定義されていないことを意味します！_
+最初の`yield`キーワードが見つかるまで、すべての行が実行されます。関数内の最初の行に`yield`キーワードがあります: 実行は最初のyieldで停止します！ _これは変数 `answer`がまだ定義されていないことを意味します！_
 
-`game.next("Yes").value`を呼び出すと、前の`yield`は`next()`関数に渡されたパラメータの値、この場合は`"Yes"`に置き換えられます。変数`answer`の値は現在`"Yes"`となります。
+`game.next("Yes").value`を呼び出すと、前の`yield`は`next()`関数に渡されたパラメータの値、この場合は`"Yes"`に置き換えられます。変数`answer`の値は現在`"Yes"`となります。 
 
-if-statemnet の条件は`false`を返し、`JavaScript loves you back ❤️`が、出力されます。
+if-statemnetの条件は`false`を返し、`JavaScript loves you back ❤️`が、出力されます。
 
 </p>
 </details>
@@ -2368,7 +2375,7 @@ console.log(data);
 
 #### 答え: C
 
-非同期関数は常に、promise を返します。`await`は promise が解決されるのを待たなければなりません: `getData()`を呼び出すと、`data`は保留中の promise が返されます。
+非同期関数は常に、promiseを返します。`await`はpromiseが解決されるのを待たなければなりません: `getData()`を呼び出すと、`data`は保留中のpromiseが返されます。
 
 解決した値`"I made it"`にアクセスしたい場合は、`data`に対して`.then()`メソッドを使用することができます:
 
@@ -2402,10 +2409,10 @@ console.log(result);
 
 #### 答え: B
 
-`.push（）`メソッドは新しい配列の長さを返します。以前は、配列は 1 つの要素（文字列 `" banana "`）を含み、長さは `1`でした。文字列 `" apple "`を配列に追加した後、配列は 2 つの要素を含み、長さは `2`になります。これは `addToList`関数から返されます。
+`.push（）`メソッドは新しい配列の長さを返します。以前は、配列は1つの要素（文字列 `" banana "`）を含み、長さは `1`でした。文字列 `" apple "`を配列に追加した後、配列は2つの要素を含み、長さは `2`になります。これは `addToList`関数から返されます。
 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`メソッドは元の配列を修正します。配列の長さではなく関数から配列を返したい場合は、item をプッシュした後に list を返すべきです。
+`push`メソッドは元の配列を修正します。配列の長さではなく関数から配列を返したい場合は、itemをプッシュした後にlistを返すべきです。
 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>
@@ -2440,7 +2447,7 @@ console.log(shape);
 
 変数`shape`を作成し、フリーズしたオブジェクト`box`に代入すると、`shape`はフリーズしたオブジェクトとなります。オブジェクトがフリーズしているかどうかは `Object.isFrozen`を使って確認できます。
 
-この場合、変数`shape`はフリーズしたオブジェクトへの参照を持っているので、`Object.isFrozen(shape)`は true を返します。
+この場合、変数`shape`はフリーズしたオブジェクトへの参照を持っているので、`Object.isFrozen(shape)`はtrueを返します。
 
 `shape`はフリーズされており、`x`の値はオブジェクトではないので、プロパティ`x`を変更することはできません。
 
@@ -2471,9 +2478,9 @@ console.log(name);
 
 右側のオブジェクトからプロパティ`name`をアンパックするとき、その値`"Lydia"`を`myName`という名前の変数に代入します。
 
-`{name：myName}`を使って、右側の `name`プロパティの値で`myName`という新しい変数を作りたいことを JavaScript に伝えます。
+`{name：myName}`を使って、右側の `name`プロパティの値で`myName`という新しい変数を作りたいことをJavaScriptに伝えます。
 
-定義されていない変数`name`を出力しようとしているので、ReferenceError が投げられます。
+定義されていない変数`name`を出力しようとしているので、ReferenceErrorが投げられます。
 
 </p>
 </details>
@@ -2510,7 +2517,7 @@ function sum(a, b) {
 ```javascript
 const add = () => {
   const cache = {};
-  return (num) => {
+  return num => {
     if (num in cache) {
       return `From cache! ${cache[num]}`;
     } else {
@@ -2541,15 +2548,15 @@ console.log(addFunction(5 * 2));
 
 同じ引数を指定してもう一度`addFunction`関数を呼び出すと、最初にキャッシュ内でその値がすでに取得されているかどうかを調べます。
 
-この場合、caches の値が返され、実行時間が短縮されます。そうでなくキャッシュされていなければ、値を計算した後にそれを格納します。
+この場合、cachesの値が返され、実行時間が短縮されます。そうでなくキャッシュされていなければ、値を計算した後にそれを格納します。
 
-同じ値で 3 回`addFunction`関数を呼び出します: 最初の呼び出しでは、`num`に`10`を代入した時、関数の値はまだキャッシュされていません。
+同じ値で3回`addFunction`関数を呼び出します: 最初の呼び出しでは、`num`に`10`を代入した時、関数の値はまだキャッシュされていません。 
 
-if ステートメントの`num in cache`の条件は`false`を返し、else ブロックが実行されます: `Calculated! 20`が出力され、結果の値がキャッシュオブジェクトに追加されます。 `cache`は現在 `{ 10: 20 }`となります。
+ifステートメントの`num in cache`の条件は`false`を返し、elseブロックが実行されます: `Calculated! 20`が出力され、結果の値がキャッシュオブジェクトに追加されます。 `cache`は現在 `{ 10: 20 }`となります。
 
-2 回目は、`cache`オブジェクトは`10`に対して返される値を含みます。 if ステートメントの`num in cache`の条件は`true`となり、`'From cache! 20'`を返します。 よって`'From cache! 20'`が出力されます。
+2回目は、`cache`オブジェクトは`10`に対して返される値を含みます。 ifステートメントの`num in cache`の条件は`true`となり、`'From cache! 20'`を返します。 よって`'From cache! 20'`が出力されます。
 
-3 回目は、`10`に評価される関数に`5 * 2`を渡します。`cache`オブジェクトは`10`に対して返される値を含みます。if ステートメントの`num in cache`の条件は`true`となり、`'From cache! 20'`を返します。 よって`'From cache! 20'`が出力されます。
+3回目は、`10`に評価される関数に`5 * 2`を渡します。`cache`オブジェクトは`10`に対して返される値を含みます。ifステートメントの`num in cache`の条件は`true`となり、`'From cache! 20'`を返します。 よって`'From cache! 20'`が出力されます。
 
 </p>
 </details>
@@ -2559,21 +2566,21 @@ if ステートメントの`num in cache`の条件は`false`を返し、else ブ
 ###### <a name=20190726></a>79. 何が出力されるでしょうか？
 
 ```javascript
-const myLifeSummedUp = ["☕", "💻", "🍷", "🍫"];
+const myLifeSummedUp = ["☕", "💻", "🍷", "🍫"]
 
 for (let item in myLifeSummedUp) {
-  console.log(item);
+  console.log(item)
 }
 
 for (let item of myLifeSummedUp) {
-  console.log(item);
+  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: "🍫"}`
+- D:  `0` `1` `2` `3` and `{0: "☕", 1: "💻", 2: "🍷", 3: "🍫"}`
 
 <details><summary><b>答え</b></summary>
 <p>
@@ -2598,14 +2605,14 @@ _for-of_ ループを使うと、**反復可能オブジェクト**を繰り返
 ###### 80. 何が出力されるでしょうか？
 
 ```javascript
-const list = [1 + 2, 1 * 2, 1 / 2];
-console.log(list);
+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]`
+- D:  `[1, 1, 1]`
 
 <details><summary><b>答え</b></summary>
 <p>
@@ -2625,16 +2632,16 @@ console.log(list);
 
 ```javascript
 function sayHi(name) {
-  return `Hi there, ${name}`;
+  return `Hi there, ${name}`
 }
 
-console.log(sayHi());
+console.log(sayHi())
 ```
 
 - A: `Hi there, `
 - B: `Hi there, undefined`
 - C: `Hi there, null`
-- D: `ReferenceError`
+- D:  `ReferenceError`
 
 <details><summary><b>答え</b></summary>
 <p>
@@ -2643,7 +2650,7 @@ console.log(sayHi());
 
 関数に値が渡されていない限り、引数はデフォルトで`undefined`の値を持ちます。上記の場合、`name`引数に値を渡さなかったので、`name`は`undefined`となり出力されます。
 
-ES6 では、このデフォルトの`undefined`値を、デフォルトパラメータで上書きすることができます。例:
+ES6では、このデフォルトの`undefined`値を、デフォルトパラメータで上書きすることができます。例:
 
 `function sayHi(name = "Lydia") { ... }`
 
@@ -2657,21 +2664,21 @@ ES6 では、このデフォルトの`undefined`値を、デフォルトパラ
 ###### 82. 何が出力されるでしょうか？
 
 ```javascript
-var status = "😎";
+var status = "😎"
 
 setTimeout(() => {
-  const status = "😍";
+  const status = "😍"
 
   const data = {
     status: "🥑",
     getStatus() {
-      return this.status;
-    },
-  };
+      return this.status
+    }
+  }
 
-  console.log(data.getStatus());
-  console.log(data.getStatus.call(this));
-}, 0);
+  console.log(data.getStatus())
+  console.log(data.getStatus.call(this))
+}, 0)
 ```
 
 - A: `"🥑"` and `"😍"`
@@ -2688,7 +2695,7 @@ setTimeout(() => {
 
 メソッドは`data`オブジェクトに属しているので、`this`は `data`オブジェクトを参照します。 `this.status`をログ出力すると、`data`オブジェクトの`status`プロパティの`"🥑"`がログ出力されます。
 
-`call`メソッドを使うと、`this`キーワードが参照するオブジェクトを変更することができます。 **関数**では、`this`キーワードは _その関数が属するオブジェクトを参照します_ 。
+`call`メソッドを使うと、`this`キーワードが参照するオブジェクトを変更することができます。 **関数**では、`this`キーワードは _その関数が属するオブジェクトを参照します_ 。 
 
 _グローバルオブジェクトで_ `setTimeout`関数を宣言したので、`setTimeout`関数内では、 `this`キーワードは _グローバルオブジェクト_ を参照します。
 
@@ -2704,13 +2711,13 @@ _グローバルオブジェクトで_ `setTimeout`関数を宣言したので
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21,
-};
+  age: 21
+}
 
-let city = person.city;
-city = "Amsterdam";
+let city = person.city
+city = "Amsterdam"
 
-console.log(person);
+console.log(person)
 ```
 
 - A: `{ name: "Lydia", age: 21 }`
@@ -2727,7 +2734,7 @@ console.log(person);
 
 我々は`person`オブジェクト自身を参照して _いない_ ことに注意してください。`person`オブジェクトの`city`プロパティを、変数`city`に代入するだけです。
 
-それから、`city`に、文字列`"Amsterdam"`を代入しますこれは person オブジェクトを変更しません: そのオブジェクトへの参照はありません。
+それから、`city`に、文字列`"Amsterdam"`を代入しますこれは personオブジェクトを変更しません: そのオブジェクトへの参照はありません。
 
 `person`オブジェクトをログ出力するとき、未修正のオブジェクトが返されます。
 
@@ -2741,15 +2748,15 @@ console.log(person);
 ```javascript
 function checkAge(age) {
   if (age < 18) {
-    const message = "Sorry, you're too young.";
+    const message = "Sorry, you're too young."
   } else {
-    const message = "Yay! You're old enough!";
+    const message = "Yay! You're old enough!"
   }
 
-  return message;
+  return message
 }
 
-console.log(checkAge(21));
+console.log(checkAge(21))
 ```
 
 - A: `"Sorry, you're too young."`
@@ -2762,7 +2769,7 @@ console.log(checkAge(21));
 
 #### 答え: C
 
-`const`と`let`キーワードを持つ変数は _ブロックスコープ_ です。ブロックは中括弧(`{ }`)で囲まれたものです。上記の場合、if/else ステートメントが中括弧となります。宣言されたブロックの外側で変数を参照することはできません。ReferenceError がスローされます。
+`const`と`let`キーワードを持つ変数は _ブロックスコープ_ です。ブロックは中括弧(`{ }`)で囲まれたものです。上記の場合、if/elseステートメントが中括弧となります。宣言されたブロックの外側で変数を参照することはできません。ReferenceError がスローされます。
 
 </p>
 </details>
@@ -2772,29 +2779,29 @@ console.log(checkAge(21));
 ###### 85. どのような情報が出力されますか？
 
 ```javascript
-fetch("https://www.website.com/api/user/1")
-  .then((res) => res.json())
-  .then((res) => console.log(res));
+fetch('https://www.website.com/api/user/1')
+  .then(res => res.json())
+  .then(res => console.log(res))
 ```
 
 - A: `fetch`メソッドの結果
-- B: 2 回目の `fetch`メソッド呼び出しの結果
+- B: 2回目の `fetch`メソッド呼び出しの結果
 - C: 前の`.then()`でのコールバックの結果
-- D: 常に undefined.
+- D: 常に undefined. 
 
 <details><summary><b>答え</b></summary>
 <p>
 
 #### 答え: C
 
-2 番目の`.then`の`res`の値は、前の`.then`の戻り値と同じとなります。値が次のハンドラに渡されるように、`.then`を連鎖させることができます。
+2番目の`.then`の`res`の値は、前の`.then`の戻り値と同じとなります。値が次のハンドラに渡されるように、`.then`を連鎖させることができます。
 
 </p>
 </details>
 
 ---
 
-###### 86. 引数として true を渡すことができない場合、どのオプションが`hasName`を`true`に設定するための方法ですか？
+###### 86. 引数としてtrueを渡すことができない場合、どのオプションが`hasName`を`true`に設定するための方法ですか？
 
 ```javascript
 function getName(name) {
@@ -2812,7 +2819,7 @@ function getName(name) {
 
 #### 答え: A
 
-`!!name`を使って、`name`の値が、truthy か falsey かを判断します。name が truthy であり、これをテストしたい場合、`!name`は`false`を返します。`!false`（これは実際には`!!name`です）は`true`を返します。
+`!!name`を使って、`name`の値が、truthyか falseyかを判断します。nameがtruthyであり、これをテストしたい場合、`!name`は`false`を返します。`!false`（これは実際には`!!name`です）は`true`を返します。
 
 `hasName`に`name`を代入することで、`getName`関数に渡されたどんな値も`hasName`に代入されます。ブール値`true`は設定できません。
 
diff --git a/ko-KR/README-ko_KR.md b/ko-KR/README-ko_KR.md
index ef2d94e1..13651a7c 100644
--- a/ko-KR/README-ko_KR.md
+++ b/ko-KR/README-ko_KR.md
@@ -34,7 +34,6 @@
 - [🇳🇱 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)
@@ -55,7 +54,7 @@
 function sayHi() {
   console.log(name);
   console.log(age);
-  var name = "Lydia";
+  var name = 'Lydia';
   let age = 21;
 }
 
@@ -151,7 +150,7 @@ console.log(shape.perimeter());
 
 ```javascript
 +true;
-!"Lydia";
+!'Lydia';
 ```
 
 - A: `1` 그리고 `false`
@@ -176,11 +175,11 @@ console.log(shape.perimeter());
 
 ```javascript
 const bird = {
-  size: "small",
+  size: 'small',
 };
 
 const mouse = {
-  name: "Mickey",
+  name: 'Mickey',
   small: true,
 };
 ```
@@ -211,11 +210,11 @@ JavaScript는 문장을 해석(또는 분)해요. 대괄호 표기를 사용하
 ###### 6. 무엇이 출력 될까요?
 
 ```javascript
-let c = { greeting: "Hey!" };
+let c = { greeting: 'Hey!' };
 let d;
 
 d = c;
-c.greeting = "Hello";
+c.greeting = 'Hello';
 console.log(d.greeting);
 ```
 
@@ -230,7 +229,7 @@ console.log(d.greeting);
 
 #### 답: A
 
-JavaScript에서 모든 객체는 서로를 동일하게 설정하면 *참조*로 상호작용해요.
+JavaScript에서 모든 객체는 서로를 동일하게 설정하면 _참조_로 상호작용해요.
 
 우선, 변수 `c`는 객체에 대한 값을 갖고 있어요. 그 후 `c`가 객체에 가지고 있는 것과 동일한 참조를 `d`에 할당해요.
 
@@ -285,13 +284,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 +340,10 @@ console.log(greetign);
 
 ```javascript
 function bark() {
-  console.log("Woof!");
+  console.log('Woof!');
 }
 
-bark.animal = "dog";
+bark.animal = 'dog';
 ```
 
 - A: 별일 없어요, 이건 완전히 괜찮아요!
@@ -374,7 +373,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 +414,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 +485,7 @@ function sum(a, b) {
   return a + b;
 }
 
-sum(1, "2");
+sum(1, '2');
 ```
 
 - A: `NaN`
@@ -553,7 +552,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 +579,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 +641,7 @@ rest 파라미터 (`...args`)는 남아있는 모든 인수을 하나의 배열
 
 ```javascript
 function getAge() {
-  "use strict";
+  'use strict';
   age = 21;
   console.log(age);
 }
@@ -670,7 +669,7 @@ getAge();
 ###### 21. `sum`의 값은 무엇일까요?
 
 ```javascript
-const sum = eval("10*10+5");
+const sum = eval('10*10+5');
 ```
 
 - A: `105`
@@ -693,7 +692,7 @@ const sum = eval("10*10+5");
 ###### 22. cool_secret에 몇 시간이나 접근이 가능할까요?
 
 ```javascript
-sessionStorage.setItem("cool_secret", 123);
+sessionStorage.setItem('cool_secret', 123);
 ```
 
 - A: 영원히, 데이터는 사라지지 않아요.
@@ -746,12 +745,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 +776,7 @@ set에서는 동작하지 않아요. set에는 `'1'`이 없어요: `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,12 +845,12 @@ 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());
+console.log(name.giveLydiaPizza())
 ```
 
 - A: `"Just give Lydia pizza already!"`
@@ -875,8 +874,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;
@@ -908,9 +907,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();
@@ -1013,7 +1012,7 @@ WebAPI는 준비가 될 때마다 stack에 항목을 추가할 수 없어요. 
 ###### 33. 무엇이 출력 될까요?
 
 ```javascript
-const person = { name: "Lydia" };
+const person = { name: 'Lydia' };
 
 function sayHi(age) {
   console.log(`${this.name} is ${age}`);
@@ -1076,8 +1075,8 @@ console.log(typeof sayHi());
 ```javascript
 0;
 new Number(0);
-("");
-(" ");
+('');
+(' ');
 new Boolean(false);
 undefined;
 ```
@@ -1260,7 +1259,7 @@ JavaScript는 원시형과 객체만 가지고 있어요.
 
 ```javascript
 !!null;
-!!"";
+!!'';
 !!1;
 ```
 
@@ -1288,7 +1287,7 @@ JavaScript는 원시형과 객체만 가지고 있어요.
 ###### 42. `setInterval` 메소드는 브라우저에게 무엇을 반환 할까요?
 
 ```javascript
-setInterval(() => console.log("Hi"), 1000);
+setInterval(() => console.log('Hi'), 1000);
 ```
 
 - A: 유니크한 id
@@ -1311,7 +1310,7 @@ setInterval(() => console.log("Hi"), 1000);
 ###### 43. 이것은 무엇을 반환할까요?
 
 ```javascript
-[..."Lydia"];
+[...'Lydia'];
 ```
 
 - A: `["L", "y", "d", "i", "a"]`
@@ -1370,11 +1369,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));
@@ -1400,7 +1399,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;
 
@@ -1421,7 +1420,7 @@ console.log(members);
 
 <img src="https://i.imgur.com/TML1MbS.png" width="200">
 
-그 후, `members`라는 변수를 선언해요. 배열의 첫 번째 요소에 `person` 변수의 값을 대입해요. 서로를 같게 설정하면 *참조*로 상호작용해요. 어떤 변수에서 다른 변수로 참조를 할당하면, 그 참조의 _복사본_ 을 만들어요. (그들은 _같은_ 참조를 가지고 있지 않다는 것을 유의하세요!)
+그 후, `members`라는 변수를 선언해요. 배열의 첫 번째 요소에 `person` 변수의 값을 대입해요. 서로를 같게 설정하면 _참조_로 상호작용해요. 어떤 변수에서 다른 변수로 참조를 할당하면, 그 참조의 _복사본_ 을 만들어요. (그들은 _같은_ 참조를 가지고 있지 않다는 것을 유의하세요!)
 
 <img src="https://i.imgur.com/FSG5K3F.png" width="300">
 
@@ -1440,7 +1439,7 @@ console.log(members);
 
 ```javascript
 const person = {
-  name: "Lydia",
+  name: 'Lydia',
   age: 21,
 };
 
@@ -1469,7 +1468,7 @@ for (const item in person) {
 ###### 48. 무엇이 출력 될까요?
 
 ```javascript
-console.log(3 + 4 + "5");
+console.log(3 + 4 + '5');
 ```
 
 - A: `"345"`
@@ -1496,7 +1495,7 @@ console.log(3 + 4 + "5");
 ###### 49. `num`의 값은 무엇일까요?
 
 ```javascript
-const num = parseInt("7*6", 10);
+const num = parseInt('7*6', 10);
 ```
 
 - A: `42`
@@ -1522,7 +1521,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;
 });
 ```
@@ -1550,12 +1549,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);
 
@@ -1587,15 +1586,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);
   }
 }
 
@@ -1625,8 +1624,8 @@ sayHi();
 
 ```javascript
 function Car() {
-  this.make = "Lamborghini";
-  return { make: "Maserati" };
+  this.make = 'Lamborghini';
+  return { make: 'Maserati' };
 }
 
 const myCar = new Car();
@@ -1702,7 +1701,7 @@ Dog.prototype.bark = function () {
   console.log(`Woof I am ${this.name}`);
 };
 
-const pet = new Dog("Mara");
+const pet = new Dog('Mara');
 
 pet.bark();
 
@@ -1767,7 +1766,7 @@ export default counter;
 
 ```javascript
 // index.js
-import myCounter from "./counter";
+import myCounter from './counter';
 
 myCounter += 1;
 
@@ -1867,7 +1866,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);
@@ -1893,9 +1892,9 @@ spread 연산자 `...` 를 사용해 객체를 결합할 수 있어요. 이것
 ###### 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));
@@ -1924,12 +1923,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);
 ```
 
@@ -1960,7 +1959,7 @@ replacer가 _함수_ 라면, 문자열로 변환 할 객체의 모든 속성에
 let num = 10;
 
 const increaseNumber = () => num++;
-const increasePassedNumber = (number) => number++;
+const increasePassedNumber = number => number++;
 
 const num1 = increaseNumber();
 const num2 = increasePassedNumber(num1);
@@ -2117,12 +2116,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;
 ```
 
@@ -2150,7 +2149,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`
@@ -2173,7 +2172,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));
 ```
@@ -2200,7 +2199,7 @@ console.log(name.padStart(2));
 ###### 70. 무엇이 출력 될까요?
 
 ```javascript
-console.log("🥑" + "💻");
+console.log('🥑' + '💻');
 ```
 
 - A: `"🥑💻"`
@@ -2224,11 +2223,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 gone here";
   }
-  return "JavaScript loves you back ❤️";
+  return 'JavaScript loves you back ❤️';
 }
 
 const game = startGame();
@@ -2296,7 +2295,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();
@@ -2333,7 +2332,7 @@ function addToList(item, list) {
   return list.push(item);
 }
 
-const result = addToList("apple", ["banana"]);
+const result = addToList('apple', ['banana']);
 console.log(result);
 ```
 
@@ -2393,7 +2392,7 @@ console.log(shape);
 ###### 76. 무엇이 출력 될까요?
 
 ```javascript
-const { name: myName } = { name: "Lydia" };
+const { name: myName } = { name: 'Lydia' };
 
 console.log(name);
 ```
@@ -2494,7 +2493,7 @@ console.log(addFunction(5 * 2));
 ###### 79. 무엇이 출력 될까요?
 
 ```javascript
-const myLifeSummedUp = ["☕", "💻", "🍷", "🍫"];
+const myLifeSummedUp = ['☕', '💻', '🍷', '🍫'];
 
 for (let item in myLifeSummedUp) {
   console.log(item);
@@ -2590,13 +2589,13 @@ ES6에서, 기본값 `undefined` 값을 기본값 매개변수로 덮어쓸 수
 ###### 82. 무엇이 출력 될까요?
 
 ```javascript
-var status = "😎";
+var status = '😎';
 
 setTimeout(() => {
-  const status = "😍";
+  const status = '😍';
 
   const data = {
-    status: "🥑",
+    status: '🥑',
     getStatus() {
       return this.status;
     },
@@ -2630,12 +2629,12 @@ setTimeout(() => {
 
 ```javascript
 const person = {
-  name: "Lydia",
+  name: 'Lydia',
   age: 21,
 };
 
 let city = person.city;
-city = "Amsterdam";
+city = 'Amsterdam';
 
 console.log(person);
 ```
@@ -2699,7 +2698,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));
 ```
@@ -2755,7 +2754,7 @@ function getName(name) {
 ###### 87. 무엇이 출력 될까요?
 
 ```javascript
-console.log("I want pizza"[0]);
+console.log('I want pizza'[0]);
 ```
 
 - A: `"""`
@@ -2810,11 +2809,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);
 ```
@@ -2847,7 +2846,7 @@ class Person {
   }
 }
 
-const member = new Person("John");
+const member = new Person('John');
 console.log(typeof member);
 ```
 
@@ -2907,7 +2906,7 @@ console.log(newList.push(5));
 
 ```javascript
 function giveLydiaPizza() {
-  return "Here is pizza!";
+  return 'Here is pizza!';
 }
 
 const giveLydiaChocolate = () =>
@@ -2938,7 +2937,7 @@ console.log(giveLydiaChocolate.prototype);
 
 ```javascript
 const person = {
-  name: "Lydia",
+  name: 'Lydia',
   age: 21,
 };
 
@@ -2998,7 +2997,7 @@ function getItems(fruitList, favoriteFruit, ...args) {
   return [...fruitList, ...args, favoriteFruit];
 }
 
-getItems(["banana", "apple"], "pear", "orange");
+getItems(['banana', 'apple'], 'pear', 'orange');
 ```
 
 위의 예시는 동작해요. 배열 `[ 'banana', 'apple', 'orange', 'pear' ]`을 반환해요.
@@ -3012,8 +3011,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;
 }
@@ -3053,13 +3052,13 @@ a + b;
 ```javascript
 class Person {
   constructor() {
-    this.name = "Lydia";
+    this.name = 'Lydia';
   }
 }
 
 Person = class AnotherPerson {
   constructor() {
-    this.name = "Sarah";
+    this.name = 'Sarah';
   }
 };
 
@@ -3088,7 +3087,7 @@ console.log(member.name);
 
 ```javascript
 const info = {
-  [Symbol("a")]: "b",
+  [Symbol('a')]: 'b',
 };
 
 console.log(info);
@@ -3157,7 +3156,7 @@ rest 파라미터를 사용해 `...y`에 모든 "남은" 인수을 배열에 넣
 ###### 99. 무엇이 출력 될까요?
 
 ```javascript
-const name = "Lydia";
+const name = 'Lydia';
 
 console.log(name());
 ```
@@ -3189,8 +3188,8 @@ ReferenceErrors는 JavaScript가 접근하려고 하는 값의 참조를 찾을
 ```javascript
 // 🎉✨ 이번이 내 100번째 질문이에요! ✨🎉
 
-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`
@@ -3216,7 +3215,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);
@@ -3248,16 +3247,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();
@@ -3295,8 +3294,8 @@ promise를 사용하면, 기본적으로 _이 함수를 실행하고 싶지만,
 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);
@@ -3356,13 +3355,13 @@ promise 또는 non-promise가 아니더라도, 어떤 유형의 값이라도 `Pr
 ```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);
 ```
@@ -3401,7 +3400,7 @@ const colorConfig = {
   yellow: false,
 };
 
-const colors = ["pink", "red", "blue"];
+const colors = ['pink', 'red', 'blue'];
 
 console.log(colorConfig.colors[1]);
 ```
@@ -3430,7 +3429,7 @@ JavaScript 문장을 해석(또는 참조형 변수를 원시 데이터 타입
 ###### 107. 값은 무엇일까요?
 
 ```javascript
-console.log("❤️" === "❤️");
+console.log('❤️' === '❤️');
 ```
 
 - A: `true`
@@ -3451,14 +3450,14 @@ console.log("❤️" === "❤️");
 ###### 108. 다음 중 원본 배열을 수정하는 method는 무엇일까요?
 
 ```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`
@@ -3483,10 +3482,10 @@ emojis.splice(1, 2, "✨");
 ###### 109. 무엇이 출력 될까요?
 
 ```javascript
-const food = ["🍕", "🍫", "🥑", "🍔"];
+const food = ['🍕', '🍫', '🥑', '🍔'];
 const info = { favoriteFood: food[0] };
 
-info.favoriteFood = "🍝";
+info.favoriteFood = '🍝';
 
 console.log(food);
 ```
@@ -3540,7 +3539,7 @@ const jsonArray = JSON.stringify([1, 2, 3]); // '[1, 2, 3]'
 JSON.parse(jsonArray); // [1, 2, 3]
 
 // 객체를 유효한 JSON 문자열로 변환해요, 그리고 나서 JSON 문자열의 구문을 분석해 JavaScript 값으로 생성해요.
-const jsonArray = JSON.stringify({ name: "Lydia" }); // '{"name":"Lydia"}'
+const jsonArray = JSON.stringify({ name: 'Lydia' }); // '{"name":"Lydia"}'
 JSON.parse(jsonArray); // { name: 'Lydia' }
 ```
 
@@ -3552,11 +3551,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();
@@ -3579,7 +3578,7 @@ getName();
 `getName` 함수 안에 `name` 변수를 선언하지 않았다면, javaScript 엔진은 _스코프 체인_ 을 살펴봤을 거예요. 외부 범위에는 값이 `Lydia`인 `name`이라는 변수가 있어요. 이 경우 `Lydia`를 출력할 거예요.
 
 ```javascript
-let name = "Lydia";
+let name = 'Lydia';
 
 function getName() {
   console.log(name);
@@ -3597,11 +3596,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();
@@ -3647,7 +3646,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`
@@ -3672,7 +3671,7 @@ console.log(`${((x) => x)("I love")} to program`);
 ```javascript
 let config = {
   alert: setInterval(() => {
-    console.log("Alert!");
+    console.log('Alert!');
   }, 1000),
 };
 
@@ -3704,16 +3703,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
@@ -3740,14 +3739,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);
@@ -3806,7 +3805,7 @@ function sumValues(x, y, z) {
 
 ```javascript
 let num = 1;
-const list = ["🥳", "🤠", "🥰", "🤪"];
+const list = ['🥳', '🤠', '🥰', '🤪'];
 
 console.log(list[(num += 1)]);
 ```
@@ -3832,11 +3831,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}`;
@@ -3874,10 +3873,10 @@ optional chaining 연산자 `?.`를 사용하면, 더 깊이 중첩된 값이 
 ###### 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!`);
 }
@@ -3933,10 +3932,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`
@@ -4051,14 +4050,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}`;
@@ -4087,8 +4086,8 @@ console.log(getFine(130, 300));
 ###### 127. 무엇이 출력 될까요?
 
 ```javascript
-const spookyItems = ["👻", "🎃", "🕸"];
-({ item: spookyItems[3] } = { item: "💀" });
+const spookyItems = ['👻', '🎃', '🕸'];
+({ item: spookyItems[3] } = { item: '💀' });
 
 console.log(spookyItems);
 ```
@@ -4113,7 +4112,7 @@ console.log(spookyItems);
 ###### 128. 무엇이 출력 될까요?
 
 ```javascript
-const name = "Lydia Hallie";
+const name = 'Lydia Hallie';
 const age = 21;
 
 console.log(Number.isNaN(name));
@@ -4149,7 +4148,7 @@ const randomValue = 21;
 
 function getInfo() {
   console.log(typeof randomValue);
-  const randomValue = "Lydia Hallie";
+  const randomValue = 'Lydia Hallie';
 }
 
 getInfo();
@@ -4175,7 +4174,7 @@ getInfo();
 ###### 130. 무엇이 출력 될까요?
 
 ```javascript
-const myPromise = Promise.resolve("Woah some cool data");
+const myPromise = Promise.resolve('Woah some cool data');
 
 (async () => {
   try {
@@ -4183,7 +4182,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!');
   }
 })();
 ```
@@ -4208,7 +4207,7 @@ const myPromise = Promise.resolve("Woah some cool data");
 ###### 131. 무엇이 출력 될까요?
 
 ```javascript
-const emojis = ["🥑", ["✨", "✨", ["🍕", "🍕"]]];
+const emojis = ['🥑', ['✨', '✨', ['🍕', '🍕']]];
 
 console.log(emojis.flat(1));
 ```
@@ -4281,19 +4280,19 @@ console.log(counterOne.count);
 ###### 133. 무엇이 출력 될까요?
 
 ```javascript
-const myPromise = Promise.resolve(Promise.resolve("Promise!"));
+const myPromise = Promise.resolve(Promise.resolve('Promise!'));
 
 function funcOne() {
   myPromise.then((res) => res).then((res) => console.log(res));
-  setTimeout(() => console.log("Timeout!"), 0);
-  console.log("Last line!");
+  setTimeout(() => console.log('Timeout!'), 0);
+  console.log('Last line!');
 }
 
 async function funcTwo() {
   const res = await myPromise;
   console.log(await res);
-  setTimeout(() => console.log("Timeout!"), 0);
-  console.log("Last line!");
+  setTimeout(() => console.log('Timeout!'), 0);
+  console.log('Last line!');
 }
 
 funcOne();
@@ -4334,7 +4333,7 @@ export default function sum(x) {
 }
 
 // index.js
-import * as sum from "./sum";
+import * as sum from './sum';
 ```
 
 - A: `sum(4)`
@@ -4351,12 +4350,12 @@ import * as sum from "./sum";
 
 ```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);
 ```
 
@@ -4387,13 +4386,13 @@ console.log(info);
 
 ```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;
 ```
 
@@ -4423,7 +4422,7 @@ Proxy 객체를 사용하면, 두번째 인수로 전달 한 객체에 사용자
 ###### 136. 다음 중 어느 것이 `person` 객체를 수정 할 수 있을까요?
 
 ```javascript
-const person = { name: "Lydia Hallie" };
+const person = { name: 'Lydia Hallie' };
 
 Object.seal(person);
 ```
@@ -4451,9 +4450,9 @@ Object.seal(person);
 
 ```javascript
 const person = {
-  name: "Lydia Hallie",
+  name: 'Lydia Hallie',
   address: {
-    street: "100 Main St",
+    street: '100 Main St',
   },
 };
 
@@ -4553,8 +4552,8 @@ ES2020에서, `#`을 사용한 private 변수를 추가 할 수 있어요. 클
 
 ```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) {
@@ -4597,8 +4596,8 @@ obj.next(); // { value: "Lisa", done: false }
 
 ```javascript
 const person = {
-  name: "Lydia Hallie",
-  hobbies: ["coding"],
+  name: 'Lydia Hallie',
+  hobbies: ['coding'],
 };
 
 function addHobby(hobby, hobbies = person.hobbies) {
@@ -4606,9 +4605,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);
 ```
@@ -4677,11 +4676,11 @@ const pet = new Flamingo();
 ###### 143. 다음 중 어느 것의 결과가 오류일까요?
 
 ```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;
 ```
 
@@ -4767,9 +4766,9 @@ function getFruit(fruits) {
   console.log(fruits?.[1]?.[1]);
 }
 
-getFruit([["🍊", "🍌"], ["🍍"]]);
+getFruit([['🍊', '🍌'], ['🍍']]);
 getFruit();
-getFruit([["🍍"], ["🍊", "🍌"]]);
+getFruit([['🍍'], ['🍊', '🍌']]);
 ```
 
 - A: `null`, `undefined`, 🍌
@@ -4799,19 +4798,19 @@ getFruit([["🍍"], ["🍊", "🍌"]]);
 
 ```javascript
 class Calc {
-  constructor() {
-    this.count = 0;
-  }
+	constructor() {
+		this.count = 0 
+	}
 
-  increase() {
-    this.count++;
-  }
+	increase() {
+		this.count ++
+	}
 }
 
-const calc = new Calc();
-new Calc().increase();
+const calc = new Calc()
+new Calc().increase()
 
-console.log(calc.count);
+console.log(calc.count)
 ```
 
 - A: `0`
@@ -4835,25 +4834,25 @@ console.log(calc.count);
 
 ```javascript
 const user = {
-  email: "e@mail.com",
-  password: "12345",
-};
+	email: "e@mail.com",
+	password: "12345"
+}
 
 const updateUser = ({ email, password }) => {
-  if (email) {
-    Object.assign(user, { email });
-  }
+	if (email) {
+		Object.assign(user, { email })
+	}
 
-  if (password) {
-    user.password = password;
-  }
+	if (password) {
+		user.password = password
+	}
 
-  return user;
-};
+	return user
+}
 
-const updatedUser = updateUser({ email: "new@email.com" });
+const updatedUser = updateUser({ email: "new@email.com" })
 
-console.log(updatedUser === user);
+console.log(updatedUser === user)
 ```
 
 - A: `false`
@@ -4876,13 +4875,13 @@ console.log(updatedUser === user);
 ###### 149. 무엇이 출력 될까요?
 
 ```javascript
-const fruit = ["🍌", "🍊", "🍎"];
+const fruit = ['🍌', '🍊', '🍎']
 
-fruit.slice(0, 1);
-fruit.splice(0, 1);
-fruit.unshift("🍇");
+fruit.slice(0, 1)
+fruit.splice(0, 1)
+fruit.unshift('🍇')
 
-console.log(fruit);
+console.log(fruit)
 ```
 
 - A: `['🍌', '🍊', '🍎']`
@@ -4908,13 +4907,13 @@ console.log(fruit);
 
 ```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]);
+console.log(animals[dog])
 ```
 
 - A: `{ emoji: "🐶", name: "Mara" }`
@@ -4931,7 +4930,7 @@ console.log(animals[dog]);
 
 `dog`의 값은 객체 이므로, 사실 `animals[dog]`는 새로운 객체에 `"object Object"`라고 불리는 새로운 속성을 만든 걸 의미해요. 이제 `animals["object Object"]`는 `{ emoji: "🐶", name: "Mara"}`예요.
 
-`cat`도 물론 객체고, 사실 `animals[cat]`은 ` animals[``"``object Object``"``] `을 새로운 속성 cat으로 덮어쓰고 있다는 것을 의미해요.
+`cat`도 물론 객체고, 사실 `animals[cat]`은 `animals[``"``object Object``"``]`을 새로운 속성 cat으로 덮어쓰고 있다는 것을 의미해요.
 
 `animals[dog]` 또는 `animals["object Object"]`(`dog` 객체를 문자열로 변환한 결과는 `"object Object"`)를 출력하면, `{ emoji: "🐈", name: "Sara" }`를 반환해요.
 
@@ -4944,14 +4943,14 @@ console.log(animals[dog]);
 
 ```javascript
 const user = {
-  email: "my@email.com",
-  updateEmail: (email) => {
-    this.email = email;
-  },
-};
+	email: "my@email.com",
+	updateEmail: email => {
+		this.email = email
+	}
+}
 
-user.updateEmail("new@email.com");
-console.log(user.email);
+user.updateEmail("new@email.com")
+console.log(user.email)
 ```
 
 - A: `my@email.com`
@@ -4974,20 +4973,20 @@ console.log(user.email);
 ###### 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]);
-  const res2 = await Promise.all([promise3, promise4]);
-  return [res1, res2];
-};
+	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));
+	.then(res => console.log(res))
+	.catch(err => console.log(err))
 ```
 
 - A: `[['First', 'Second'], ['Fourth']]`
@@ -5010,16 +5009,13 @@ runPromises()
 ###### 153. 무엇이 `method`의 값이어야 `{ name: "Lydia", age: 22 }`를 출력할까요?
 
 ```javascript
-const keys = ["name", "age"];
-const values = ["Lydia", 22];
+const keys = ["name", "age"]
+const values = ["Lydia", 22]
 
-const method =
-  /* ?? */
-  Object[method](
-    keys.map((_, i) => {
-      return [keys[i], values[i]];
-    })
-  ); // { name: "Lydia", age: 22 }
+const method = /* ?? */
+Object[method](keys.map((_, i) => {
+	return [keys[i], values[i]]
+})) // { name: "Lydia", age: 22 }
 ```
 
 - A: `entries`
@@ -5044,18 +5040,18 @@ const method =
 ###### 154. 무엇이 출력 될까요?
 
 ```javascript
-const createMember = ({ email, address = {} }) => {
-  const validEmail = /.+\@.+\..+/.test(email);
-  if (!validEmail) throw new Error("Valid email pls");
+const createMember = ({ email, address = {}}) => {
+	const validEmail = /.+\@.+\..+/.test(email)
+	if (!validEmail) throw new Error("Valid email pls")
 
-  return {
-    email,
-    address: address ? address : null,
-  };
-};
+	return {
+		email,
+		address: address ? address : null
+	}
+}
 
-const member = createMember({ email: "my@email.com" });
-console.log(member);
+const member = createMember({ email: "my@email.com" })
+console.log(member)
 ```
 
 - A: `{ email: "my@email.com", address: null }`
@@ -5078,13 +5074,13 @@ console.log(member);
 ###### 155. 무엇이 출력 될까요?
 
 ```javascript
-let randomValue = { name: "Lydia" };
-randomValue = 23;
+let randomValue = { name: "Lydia" }
+randomValue = 23
 
 if (!typeof randomValue === "string") {
-  console.log("It's not a string!");
+	console.log("It's not a string!")
 } else {
-  console.log("Yay it's a string!");
+	console.log("Yay it's a string!")
 }
 ```
 
diff --git a/nl-NL/README.md b/nl-NL/README.md
index 1852e0e0..0400e8ed 100644
--- a/nl-NL/README.md
+++ b/nl-NL/README.md
@@ -2,15 +2,14 @@
   <img height="60" src="https://img.icons8.com/color/344/javascript.png"> 
   <h1>JavaScript Vragen</h1>
 
----
-
-<span>Ik plaats JavaScript meerkeuzevragen op mijn [Instagram](https://www.instagram.com/theavocoder) **stories**, welke ik ook hier zal plaatsen! Laatste update: <a href=#20191224><b>24 december</b></a>
+  ---
 
-Van beginner naar expert: test hoe goed je JavaScript kent, fris je kennis een beetje op, of bereid je voor op een sollicitatiegesprek! :muscle: :rocket: Ik zal deze repository regelmatig updaten met nieuwe vragen. Ik heb de antwoorden toegevoegd in de **ingeklapte secties** onder een vraag, zodat je er makkelijk op kan klikken om ze uit te klappen. Het is gewoon voor je plezier, veel succes! :heart:</span>
+  <span>Ik plaats JavaScript meerkeuzevragen op mijn [Instagram](https://www.instagram.com/theavocoder) **stories**, welke ik ook hier zal plaatsen! Laatste update: <a href=#20191224><b>24 december</b></a>
 
-Voel je vrij om contact met mij op te nemen! 😊 <br />
-<a href="https://www.instagram.com/theavocoder">Instagram</a> || <a href="https://www.twitter.com/lydiahallie">Twitter</a> || <a href="https:/www.linkedin.com/in/lydia-hallie">LinkedIn</a> || <a href="www.lydiahallie.dev">Blog</a>
+  Van beginner naar expert: test hoe goed je JavaScript kent, fris je kennis een beetje op, of bereid je voor op een sollicitatiegesprek! :muscle: :rocket: Ik zal deze repository regelmatig updaten met nieuwe vragen. Ik heb de antwoorden toegevoegd in de **ingeklapte secties** onder een vraag, zodat je er makkelijk op kan klikken om ze uit te klappen. Het is gewoon voor je plezier, veel succes! :heart:</span>
 
+  Voel je vrij om contact met mij op te nemen! 😊 <br />
+  <a href="https://www.instagram.com/theavocoder">Instagram</a> || <a href="https://www.twitter.com/lydiahallie">Twitter</a> || <a href="https:/www.linkedin.com/in/lydia-hallie">LinkedIn</a> || <a href="www.lydiahallie.dev">Blog</a>
   </div>
 
 ---
@@ -31,7 +30,6 @@ Voel je vrij om contact met mij op te nemen! 😊 <br />
 - [🇰🇷 한국어](../ko-KR/README-ko_KR.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)
@@ -116,7 +114,7 @@ const shape = {
   diameter() {
     return this.radius * 2;
   },
-  perimeter: () => 2 * Math.PI * this.radius,
+  perimeter: () => 2 * Math.PI * this.radius
 };
 
 console.log(shape.diameter());
@@ -173,12 +171,12 @@ De string `'Lydia'` is een truthy waarde. Wat we eigenlijk vragen, is "is deze t
 
 ```javascript
 const bird = {
-  size: "small",
+  size: "small"
 };
 
 const mouse = {
   name: "Mickey",
-  small: true,
+  small: true
 };
 ```
 
@@ -205,6 +203,7 @@ Echter, met de dot notatie zal dit niet gebeuren. `mouse` heeft geen propertie g
 
 ---
 
+
 ###### 6. Wat is de uitkomst?
 
 ```javascript
@@ -264,7 +263,7 @@ console.log(b === c);
 
 `new Number()` is een ingebouwde functie constructor. En ook al lijkt het misschien op een nummer, dat is het niet. Het is een object en bevat ten opzichte van een nummer veel extra opties.
 
-Wanneer we de `==` operator gebruiken wordt er alleen op de _waarde_ gecheckt. Zowel `a` als `b` bevatten de waarde `3`, dus geeft dit `true` terug.
+Wanneer we de `==` operator gebruiken wordt er alleen op de _waarde_ gecheckt. Zowel `a` als `b` bevatten de waarde `3`, dus geeft dit `true` terug. 
 
 Echter, wanneer we de `===` operator gebruiken wordt er zowel op de _waarde_ als op het _type_ gecheckt. Omdat `new Number()` een **object** is en geen nummer zal dit `false` teruggeven.
 
@@ -372,7 +371,7 @@ function Person(firstName, lastName) {
 }
 
 const member = new Person("Lydia", "Hallie");
-Person.getFullName = function () {
+Person.getFullName = function() {
   return `${this.firstName} ${this.lastName}`;
 };
 
@@ -392,7 +391,7 @@ console.log(member.getFullName());
 Je kunt geen properties toevoegen aan een instantie van een object, zoals je kan met normale objecten. Als je een feature toe wilt voegen aan alle objecten in één keer zul je dit middels de prototype van een object moeten doen. In dit geval,
 
 ```js
-Person.prototype.getFullName = function () {
+Person.prototype.getFullName = function() {
   return `${this.firstName} ${this.lastName}`;
 };
 ```
@@ -848,7 +847,7 @@ String.prototype.giveLydiaPizza = () => {
 
 const name = "Lydia";
 
-console.log(name.giveLydiaPizza());
+console.log(name.giveLydiaPizza())
 ```
 
 - A: `"Just give Lydia pizza already!"`
@@ -944,7 +943,7 @@ De WebAPI kan niet zomaar dingen toevoegen aan de stack. In plaats daarvan wordt
 
 <img src="https://i.imgur.com/NSnDZmU.png" width="200">
 
-Dit is waar de event loop zijn intrede doet. Een _\*\*event loop_ naar de stack en de task queue. Als de stack leeg is pakt het het eerste ding op van de queue en zet het op de stack.
+Dit is waar de event loop zijn intrede doet. Een ***event loop* naar de stack en de task queue. Als de stack leeg is pakt het het eerste ding op van de queue en zet het op de stack.
 
 <img src="https://i.imgur.com/uyiScAI.png" width="200">
 
@@ -960,7 +959,9 @@ Dit is waar de event loop zijn intrede doet. Een _\*\*event loop_ naar de stack
 ```html
 <div onclick="console.log('first div')">
   <div onclick="console.log('second div')">
-    <button onclick="console.log('button')">Click!</button>
+    <button onclick="console.log('button')">
+      Click!
+    </button>
   </div>
 </div>
 ```
@@ -986,7 +987,9 @@ Het diepst geneste element dat het event afvuurt is de target van het event. Je
 
 ```html
 <div onclick="console.log('div')">
-  <p onclick="console.log('p')">Click here!</p>
+  <p onclick="console.log('p')">
+    Click here!
+  </p>
 </div>
 ```
 
@@ -1221,10 +1224,7 @@ Wat primitieven onderscheidt van objecten is dat primitieven geen properties of
 ###### 40. Wat is de uitkomst?
 
 ```javascript
-[
-  [0, 1],
-  [2, 3],
-].reduce(
+[[0, 1], [2, 3]].reduce(
   (acc, cur) => {
     return acc.concat(cur);
   },
@@ -1349,7 +1349,6 @@ console.log(gen.next().value);
 <p>
 
 #### Antwoord: C
-
 Reguliere functies kunnen niet worden gestopt halverwege na de aanroep. Echter, een generator functie kan wel "gestopt" worden halverwege, en later verder gaan waar ik gestopt is. Elke keer als een generator functie het keyword `yield` aantreft levert de functie de waarde op gespecificeerd achter `yield`. Let op dat een generator functie in dat geval niet de waarde _teruggeeft_, maar de waarde _oplevert_.
 
 Eerst initialiseren we de generator functie met `i`, dat gelijk is aan `10`. We roepen de generator functie aan met de `next()` methode. De eerste keer dat we de generator functie aanroepen is `i` gelijk aan `10`. De eerste `yield` wordt aangetroffen: het levert de waarde op van `i`. De generator is nu "gepauzeerd" en `10` wordt gelogd.
@@ -1372,7 +1371,7 @@ const secondPromise = new Promise((res, rej) => {
   setTimeout(res, 100, "two");
 });
 
-Promise.race([firstPromise, secondPromise]).then((res) => console.log(res));
+Promise.race([firstPromise, secondPromise]).then(res => console.log(res));
 ```
 
 - A: `"one"`
@@ -1436,7 +1435,7 @@ We passaen alleen de waarde aan van de `person` variabele en niet van het eerste
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21,
+  age: 21
 };
 
 for (const item in person) {
@@ -1516,7 +1515,7 @@ Alleen het eerste getal in de string wordt geretourneerd. Gebaseerd op de _radix
 ###### 50. Wat is de uitkomst?
 
 ```javascript
-[1, 2, 3].map((num) => {
+[1, 2, 3].map(num => {
   if (typeof num === "number") return;
   return num * 2;
 });
@@ -1566,7 +1565,6 @@ console.log(person, birthYear);
 <p>
 
 #### Antwoord: A
-
 Argumenten worden meegegeven _by value_, tenzij de waarde een object is. Dan worden ze meegegeven _by reference_. `birthYear` is een string en geen object, waardoor het dus doorgegeven wordt _by value_. Wanneer we een argument meegeven _by value_ wordt er een _copy_ aangemaakt van het argument (zie vraag 46).
 
 De variabele `birthYear` heeft een referentie naar de waarde `"1997"`. Het argument `year` heeft ook een referentie naar de waarde '"1997"', maar het is niet dezelfde waarde als waar `birthYear` een referentie naar heeft. Wanneer we de waarde van `year` veranderen naar `"1998"`, veranderen we alleen de waarde van `year`. `birthYear` is nog steeds gelijk aan `"1997"`.
@@ -1693,7 +1691,7 @@ class Dog {
   }
 }
 
-Dog.prototype.bark = function () {
+Dog.prototype.bark = function() {
   console.log(`Woof I am ${this.name}`);
 };
 
@@ -1716,7 +1714,7 @@ pet.bark();
 
 #### Antwoord: A
 
-We kunnen properties verwijderen van een object als we gebruik maken van het `delete` keyword, en ook op het prototype. Bij het verwijderen van een propertie op de prototype zal het niet meer beschikbaar zijn in de prototype chain. In dit geval is de `bark()` methode niet meer beschikbaar op de protoype na `delete Dog.prototype.bark`.
+We kunnen properties verwijderen van een object als we gebruik maken van het `delete` keyword, en ook op het prototype. Bij het verwijderen van een propertie op de prototype zal het niet meer beschikbaar zijn in de prototype chain. In dit geval is de `bark()` methode niet meer beschikbaar op de protoype na `delete Dog.prototype.bark`. 
 
 Wanneer we iets proberen aan te roepen dat geen functie is zal er een `TypeError` gegooid worden. In dit geval `TypeError: pet.bark is not a function`, omdat `pet.bark` `undefined` is.
 
@@ -1906,7 +1904,7 @@ console.log(Object.keys(person));
 
 #### Antwoord: B
 
-Met de `defineProperty` methode kunnen we properties toevoegen aan een object, of bestaande properties aanpassen. Wanneer we properties toevoegen aan een object door gebruik te maken van `defineProperty` zijn deze standaard _not enumerable_. De `Object.keys` methode geeft alle _enumerable_ propertie namen terug van een object, in dit geval alleen `"name"`.
+Met de `defineProperty` methode kunnen we properties toevoegen aan een object, of bestaande properties aanpassen. Wanneer we properties toevoegen aan een object door gebruik te maken van `defineProperty` zijn deze standaard _not enumerable_. De `Object.keys` methode geeft alle _enumerable_ propertie namen terug van een object, in dit geval alleen `"name"`. 
 
 Properties toegevoegd met de `defineProperty` methode zijn standaard onveranderbaar. Je kunt dit gedrag aanpassen door, in het derde argument, de `writable`, `configurable` en `enumerable` opties mee te geven. Op die manier geeft de `defineProperties` je veel controle over de properties die je wilt toevoegen aan een object.
 
@@ -1921,7 +1919,7 @@ Properties toegevoegd met de `defineProperty` methode zijn standaard onveranderb
 const settings = {
   username: "lydiahallie",
   level: 19,
-  health: 90,
+  health: 90
 };
 
 const data = JSON.stringify(settings, ["level", "health"]);
@@ -1955,7 +1953,7 @@ Als de replacer een _functie_ is zal die functie worden aangeroepen over elke pr
 let num = 10;
 
 const increaseNumber = () => num++;
-const increasePassedNumber = (number) => number++;
+const increasePassedNumber = number => number++;
 
 const num1 = increaseNumber();
 const num2 = increasePassedNumber(num1);
@@ -2011,7 +2009,7 @@ multiply(value);
 In ES6 kunnen we parameters initialiseren met een standaard waarde. De waarde van de parameter zal deze standaard waarde behouden zolang er geen andere waarde wordt meegegeven aan de functie, of als de waarde van de parameter `"undefined"` is. In dit geval kopiëren we de properties van het `value` object
 naar een nieuw object gebruikmakend van de spread operator, dus `x` heeft de standaard waarde `{ number: 10 }`.
 
-De standaard waarde wordt geëvalueerd tijdens _call time_ (aanroeptijd)! Elke keer wanneer we de functie aanroepen wordt er een nieuw object aangemaakt. We roepen de `multiply` functie de eerste twee keer aan zonder een waarde mee te geven: `x` heeft de standaard waarde van `{ number: 10 }`. We loggen dan de vermenigvuldigde waarde van dat getal, wat `20` is.
+De standaard waarde wordt geëvalueerd tijdens _call time_ (aanroeptijd)! Elke keer wanneer we de functie aanroepen wordt er een nieuw object aangemaakt. We roepen de `multiply` functie de eerste twee keer aan zonder een waarde mee te geven: `x` heeft de standaard waarde van `{ number: 10 }`. We loggen dan de vermenigvuldigde waarde van dat getal, wat `20` is. 
 
 De derde keer dat we de functie `multiply` aanroepen geven we wel een waarde mee: het object genaamd `value`. De `*=` operator is eigenlijk een verkorting van `x.number = x.number * 2`: we passen de waarde van `x.number` aan en loggen de vermenigvuldigde waarde `20`.
 
@@ -2042,11 +2040,11 @@ Het eerste argument van de `reduce` methode is de _accumulator_, in dit geval `x
 
 In dit voorbeeld geven we geen waarde terug. We loggen enkel the waarden van de accumulator en de huidige waarde.
 
-De waarde van de accumulator is gelijk aan de vorige teruggegeven waarde van de callback functie. Als je niet de optionele `initialValue` meegeeft aan de `reduce` methode, de accumulator is gelijk aan het eerste element tijdens de eerste aanroep.
+De waarde van de accumulator is gelijk aan de vorige teruggegeven waarde van de callback functie. Als je niet de optionele `initialValue` meegeeft aan de `reduce` methode, de accumulator is gelijk aan het eerste element tijdens de eerste aanroep. 
 
 Tijdens de eerste aanroep is de accumulator (`x`) `1` en de huidige waarde (`y`) `2`. We geven niets terug in de callback function, we loggen de accumulator en de huidige waarde: `1` en `2` worden gelogd.
 
-Als je niets teruggeeft in een functie, zal de functie `undefined` teruggeven. Tijdens de volgende aanroep is de accumulator `undefined` en de huidige waarde `3`. `undefined` en `3` worden gelogt.
+Als je niets teruggeeft in een functie, zal de functie `undefined` teruggeven. Tijdens de volgende aanroep is de accumulator `undefined` en de huidige waarde `3`. `undefined` en `3` worden gelogt. 
 
 Tijdens de vierde aanroep geven we wederom niets terug in de callback functie. De accumulator is wederom `undefined`, en de huidige waarde `4`. `undefined` en `4` worden gelogt.
 
@@ -2065,7 +2063,7 @@ class Dog {
 };
 
 class Labrador extends Dog {
-  // 1
+  // 1 
   constructor(name, size) {
     this.size = size;
   }
@@ -2079,7 +2077,7 @@ class Labrador extends Dog {
     super(name);
     this.size = size;
   }
-  // 4
+  // 4 
   constructor(name, size) {
     this.name = name;
     this.size = size;
@@ -2113,12 +2111,12 @@ De `Labrador` class verwacht twee argumenten, `name` omdat het een afgeleide is
 
 ```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;
 ```
 
@@ -2144,9 +2142,9 @@ Dit is een verschil tussen `require()` in CommonJS en `import`! Met `require()`
 ###### 68. Wat is de uitkomst?
 
 ```javascript
-console.log(Number(2) === Number(2));
-console.log(Boolean(false) === Boolean(false));
-console.log(Symbol("foo") === Symbol("foo"));
+console.log(Number(2) === Number(2))
+console.log(Boolean(false) === Boolean(false))
+console.log(Symbol('foo') === Symbol('foo'))
 ```
 
 - A: `true`, `true`, `false`
@@ -2169,22 +2167,22 @@ Elk Symbol is volledig uniek. Het doel van het argument dat meegegeven wordt aan
 ###### 69. Wat is de uitkomst?
 
 ```javascript
-const name = "Lydia Hallie";
-console.log(name.padStart(13));
-console.log(name.padStart(2));
+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"`,
+- D: `"Lydia Hallie"`, `"Lyd"`, 
 
 <details><summary><b>Antwoord</b></summary>
 <p>
 
 #### Antwoord: C
 
-Met de `padStart` methode kunnen we witruimte toevoegen aan het begin van de string. De waarde die meegegeven wordt aan de methode is de _totale_ lengte van de string, samen met de witruimte. De string `"Lydia Hallie"` heeft een lengte van `13`. `name.padStart(13)` plaatst 1 spatie toe aan het begin van de string omdat 12 + 1 = 13.
+Met de `padStart` methode kunnen we witruimte toevoegen aan het begin van de string. De waarde die meegegeven wordt aan de methode is de _totale_ lengte van de string, samen met de witruimte. De string `"Lydia Hallie"` heeft een lengte van `13`. `name.padStart(13)` plaatst 1 spatie toe aan het begin van de string omdat 12 + 1 = 13. 
 
 Als het argument dat we meegeven aan de `padStart` methode kleiner is dan de lengte van de string zullen er geen spaties worden toegevoegd.
 
@@ -2445,7 +2443,7 @@ De `sum` functie geeft altijd dezelfde waarde terug. Als we `1` en `2` meegeven
 ```javascript
 const add = () => {
   const cache = {};
-  return (num) => {
+  return num => {
     if (num in cache) {
       return `From cache! ${cache[num]}`;
     } else {
@@ -2490,21 +2488,21 @@ De derde keer geven we `5 * 2` mee aan de functie wat `10` oplevert. Het `cache`
 ###### 79. Wat is de uitkomst?
 
 ```javascript
-const myLifeSummedUp = ["☕", "💻", "🍷", "🍫"];
+const myLifeSummedUp = ["☕", "💻", "🍷", "🍫"]
 
 for (let item in myLifeSummedUp) {
-  console.log(item);
+  console.log(item)
 }
 
 for (let item of myLifeSummedUp) {
-  console.log(item);
+  console.log(item)
 }
 ```
 
 - A: `0` `1` `2` `3` en `"☕"` ` "💻"` `"🍷"` `"🍫"`
 - B: `"☕"` ` "💻"` `"🍷"` `"🍫"` en `"☕"` ` "💻"` `"🍷"` `"🍫"`
 - C: `"☕"` ` "💻"` `"🍷"` `"🍫"` en `0` `1` `2` `3`
-- D: `0` `1` `2` `3` en `{0: "☕", 1: "💻", 2: "🍷", 3: "🍫"}`
+- D:  `0` `1` `2` `3` en `{0: "☕", 1: "💻", 2: "🍷", 3: "🍫"}`
 
 <details><summary><b>Antwoord</b></summary>
 <p>
@@ -2527,21 +2525,21 @@ Met de _for-of_ loop kunnen we itereren over **iterables**. Een array is een ite
 ###### 80. Wat is de uitkomst?
 
 ```javascript
-const list = [1 + 2, 1 * 2, 1 / 2];
-console.log(list);
+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]`
+- D:  `[1, 1, 1]`
 
 <details><summary><b>Antwoord</b></summary>
 <p>
 
 #### Antwoord: C
 
-Array elementen kunnen elke waarde bevatten. Nummers, strings, objecten, andere arrays, null, boolean waarden, undefined en andere expressies zoals datums, functies en berekeningen.
+Array elementen kunnen elke waarde bevatten. Nummers, strings, objecten, andere arrays, null, boolean waarden, undefined en andere expressies zoals datums, functies en berekeningen. 
 
 Het element zal gelijk zijn aan de teruggegeven waarde. `1 + 2` geeft `3` terug, `1 * 2` geeft `2` terug en `1 / 2` geeft `0.5` terug.
 
@@ -2554,16 +2552,16 @@ Het element zal gelijk zijn aan de teruggegeven waarde. `1 + 2` geeft `3` terug,
 
 ```javascript
 function sayHi(name) {
-  return `Hi there, ${name}`;
+  return `Hi there, ${name}`
 }
 
-console.log(sayHi());
+console.log(sayHi())
 ```
 
 - A: `Hi there, `
 - B: `Hi there, undefined`
 - C: `Hi there, null`
-- D: `ReferenceError`
+- D:  `ReferenceError`
 
 <details><summary><b>Antwoord</b></summary>
 <p>
@@ -2576,7 +2574,7 @@ In ES6 kunnen we argumenten een standaard waarde geven. Als voorbeeld:
 
 `function sayHi(name = "Lydia") { ... }`
 
-In dit geval zal de waarde van het argument `name`, als we geen waarde meegeven aan de functie, standaard `Lydia` bevatten.
+In dit geval zal de waarde van het argument `name`, als we geen waarde meegeven aan de functie, standaard `Lydia` bevatten. 
 
 </p>
 </details>
@@ -2586,21 +2584,21 @@ In dit geval zal de waarde van het argument `name`, als we geen waarde meegeven
 ###### 82. Wat is de uitkomst?
 
 ```javascript
-var status = "😎";
+var status = "😎"
 
 setTimeout(() => {
-  const status = "😍";
+  const status = "😍"
 
   const data = {
     status: "🥑",
     getStatus() {
-      return this.status;
-    },
-  };
+      return this.status
+    }
+  }
 
-  console.log(data.getStatus());
-  console.log(data.getStatus.call(this));
-}, 0);
+  console.log(data.getStatus())
+  console.log(data.getStatus.call(this))
+}, 0)
 ```
 
 - A: `"🥑"` en `"😍"`
@@ -2627,13 +2625,13 @@ Met de `call` methode kunnen we het object veranderen waarnaar het keyword `this
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21,
-};
+  age: 21
+}
 
-let city = person.city;
-city = "Amsterdam";
+let city = person.city
+city = "Amsterdam"
 
-console.log(person);
+console.log(person)
 ```
 
 - A: `{ name: "Lydia", age: 21 }`
@@ -2664,15 +2662,15 @@ Wanneer we het object `person` loggen, wordt het onaangepaste object gelogd.
 ```javascript
 function checkAge(age) {
   if (age < 18) {
-    const message = "Sorry, you're too young.";
+    const message = "Sorry, you're too young."
   } else {
-    const message = "Yay! You're old enough!";
+    const message = "Yay! You're old enough!"
   }
 
-  return message;
+  return message
 }
 
-console.log(checkAge(21));
+console.log(checkAge(21))
 ```
 
 - A: `"Sorry, you're too young."`
@@ -2695,9 +2693,9 @@ Variabelen gedeclareerd met de keywords `const` en `let` zijn _block-scoped_. Ee
 ###### 85. Welke informatie zal worden gelogd?
 
 ```javascript
-fetch("https://www.website.com/api/user/1")
-  .then((res) => res.json())
-  .then((res) => console.log(res));
+fetch('https://www.website.com/api/user/1')
+  .then(res => res.json())
+  .then(res => console.log(res))
 ```
 
 - A: Het resultaat van de `fetch` methode.
@@ -2737,7 +2735,7 @@ function getName(name) {
 
 Met `!!name` stellen we vast of de waarde van `name` truthy of falsy is. Als `name` truthy is, dit is wat we willen testen, zal `!name` `false` teruggeven. `!false` (wat `!!name` feitelijk is) geeft `true` terug.
 
-Wanneer we `hasName` vullen met `name`, vullen we het met dat wat we meegeven aan de `getName` functie, niet de boolean waarde `true`.
+Wanneer we `hasName` vullen met `name`, vullen we het met dat wat we meegeven aan de `getName` functie, niet de boolean waarde `true`. 
 
 `new Boolean(true)` geeft een object wrapper terug, niet de boolean waarde zelf.
 
@@ -2751,7 +2749,7 @@ Wanneer we `hasName` vullen met `name`, vullen we het met dat wat we meegeven aa
 ###### 87. Wat is de uitkomst?
 
 ```javascript
-console.log("I want pizza"[0]);
+console.log("I want pizza"[0])
 ```
 
 - A: `"""`
@@ -2777,10 +2775,10 @@ Let op dat deze methode niet ondersteund wordt in IE7 en daaronder. In dat geval
 
 ```javascript
 function sum(num1, num2 = num1) {
-  console.log(num1 + num2);
+  console.log(num1 + num2)
 }
 
-sum(10);
+sum(10)
 ```
 
 - A: `NaN`
@@ -2795,7 +2793,7 @@ sum(10);
 
 Je kunt een parameters standaard waarde gelijk zetten aan een andere parameter van diezelfde functie, zolang deze definieerd is _voor_ de parameter met een standaard waarde. We geen de waarde `10` mee aan de `sum` functie. Als de `sum` functie maar één argument meekrijgt betekent dit dat de waarde van `num2` gevuld wordt met de waarde van `num1`. `10` in dit geval. De standaard waarde van `num2` is de waarde van `num1`, wat `10` is. `num1 + num2` geeft `20` terug.
 
-Als je probeert de standaard waarde van een parameter te vullen met de waarde van een parameter welke gedefinieerd is _na_ de standaard parameter, dan is de parameter nog niet geïnitialiseerd en wordt er een error gegooid.
+Als je probeert de standaard waarde van een parameter te vullen met de waarde van een parameter welke gedefinieerd is _na_ de standaard parameter, dan is de parameter nog niet geïnitialiseerd  en wordt er een error gegooid.
 
 </p>
 </details>
@@ -2805,14 +2803,14 @@ Als je probeert de standaard waarde van een parameter te vullen met de waarde va
 ###### 89. Wat is de uitkomst?
 
 ```javascript
-// module.js
-export default () => "Hello world";
-export const name = "Lydia";
+// module.js 
+export default () => "Hello world"
+export const name = "Lydia"
 
-// index.js
-import * as data from "./module";
+// index.js 
+import * as data from "./module"
 
-console.log(data);
+console.log(data)
 ```
 
 - A: `{ default: function default(), name: "Lydia" }`
@@ -2824,7 +2822,6 @@ console.log(data);
 <p>
 
 #### Antwoord: A
-
 Met de `import * as name` syntax importeren we _alle exports_ van `module.js` bestand in het bestand `index.js` als een nieuw object met de naam `data`. In het bestand `module.js` zijn er twee exports: de standaard export en de benoemde export. De standaard export is een functie dat de string `"Hello world"` teruggeeft, en de benoemde export is de variabele `name` wat de waarde van de string `"Lydia"` bevat.
 
 Het object `data` bevat een propertie `default` voor de standaard export. Andere properties hebben de naam van de benoemde exports en hun corresponderende waarden.
@@ -2839,12 +2836,12 @@ Het object `data` bevat een propertie `default` voor de standaard export. Andere
 ```javascript
 class Person {
   constructor(name) {
-    this.name = name;
+    this.name = name
   }
 }
 
-const member = new Person("John");
-console.log(typeof member);
+const member = new Person("John")
+console.log(typeof member)
 ```
 
 - A: `"class"`
@@ -2861,7 +2858,7 @@ Classes zijn een syntactisch sausje voor functie constructors. Het equivalent va
 
 ```javascript
 function Person() {
-  this.name = name;
+  this.name = name
 }
 ```
 
@@ -2875,9 +2872,9 @@ Het aanroepen van de functie contructor met `new` resulteert in het creëeren va
 ###### 91. Wat is de uitkomst?
 
 ```javascript
-let newList = [1, 2, 3].push(4);
+let newList = [1, 2, 3].push(4)
 
-console.log(newList.push(5));
+console.log(newList.push(5))
 ```
 
 - A: `[1, 2, 3, 4, 5]`
@@ -2903,18 +2900,17 @@ Dan gebruiken we de `.push` methode op `newList`. Omdat `newList` nu de numeriek
 
 ```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);
+console.log(giveLydiaPizza.prototype)
+console.log(giveLydiaChocolate.prototype)
 ```
 
-- A: `{ constructor: ...}` `{ constructor: ...}`
-- B: `{}` `{ constructor: ...}`
+- A: `{ constructor: ...}` `{ constructor: ...}` 
+- B: `{}` `{ constructor: ...}` 
 - C: `{ constructor: ...}` `{}`
 - D: `{ constructor: ...}` `undefined`
 
@@ -2935,16 +2931,16 @@ Reguliere functies zoals de `giveLydiaPizza` functie hebben een `prototype` prop
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21,
-};
+  age: 21
+}
 
 for (const [x, y] of Object.entries(person)) {
-  console.log(x, y);
+  console.log(x, y)
 }
 ```
 
 - A: `name` `Lydia` en `age` `21`
-- B: `["name", "Lydia"]` en `["age", 21]`
+- B: `["name", "Lydia"]` en `["age", 21]` 
 - C: `["name", "age"]` en `undefined`
 - D: `Error`
 
@@ -2955,11 +2951,11 @@ for (const [x, y] of Object.entries(person)) {
 
 `Object.entries(person)` retourneert een array van geneste arrays, welke de keys en objecten bevat:
 
-`[ [ 'name', 'Lydia' ], [ 'age', 21 ] ]`
+`[ [ 'name', 'Lydia' ], [ 'age', 21 ] ]` 
 
 Gebruikmakend van de `for-of` loop kunnen we itereren over elk element in de array, de subarrays in dit geval. We kunnen de subarrays direct destructureren door `const [x, y]` te gebruiken. `x` is gelijk aan het eerste element in de subarray, `y` is gelijk aan het tweede element in de subarray.
 
-De eerste subarray wat wordt gelogd is `[ "name", "Lydia" ]`, waarbij `x` gelijk is aan `"name"` en `y` gelijk is aan `"Lydia"`.
+De eerste subarray wat wordt gelogd is `[ "name", "Lydia" ]`, waarbij `x` gelijk is aan `"name"` en `y` gelijk is aan `"Lydia"`. 
 De tweede subarray wat wordt gelogd is `[ "age", "21" ]`, waarbij `x` gelijk is aan `"age"` en `y` gelijk is aan `"21"`.
 
 </p>
@@ -2978,7 +2974,7 @@ getItems(["banana", "apple"], "pear", "orange")
 ```
 
 - A: `["banana", "apple", "pear", "orange"]`
-- B: `[["banana", "apple"], "pear", "orange"]`
+- B: `[["banana", "apple"], "pear", "orange"]` 
 - C: `["banana", "apple", ["pear"], "orange"]`
 - D: `SyntaxError`
 
@@ -2991,10 +2987,10 @@ getItems(["banana", "apple"], "pear", "orange")
 
 ```javascript
 function getItems(fruitList, favoriteFruit, ...args) {
-  return [...fruitList, ...args, favoriteFruit];
+  return [...fruitList, ...args, favoriteFruit]
 }
 
-getItems(["banana", "apple"], "pear", "orange");
+getItems(["banana", "apple"], "pear", "orange")
 ```
 
 Het bovenstaande voorbeeld werkt. Dit geeft de array `[ 'banana', 'apple', 'orange', 'pear' ]` terug.
@@ -3008,14 +3004,17 @@ Het bovenstaande voorbeeld werkt. Dit geeft de array `[ 'banana', 'apple', 'oran
 
 ```javascript
 function nums(a, b) {
-  if (a > b) console.log("a is bigger");
-  else console.log("b is bigger");
-  return;
-  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));
+console.log(nums(4, 2))
+console.log(nums(1, 2))
 ```
 
 - A: `a is bigger`, `6` en `b is bigger`, `3`
@@ -3033,8 +3032,8 @@ In JavaScript _hoeven_ we geen puntkomma's te schrijven, alhoewel de JavaScript
 Hier schreven we een `return` statement en op de _nieuwe regel_ `a + b`. Maar omdat het een nieuwe regel betreft weet de engine niet wat we eigenlijk wilde retourneren. In plaats daarvan wordt er na `return` automatisch een puntkomma toegevoegd. Je kunt dit zien als:
 
 ```javascript
-return;
-a + b;
+  return;
+  a + b
 ```
 
 Dat betekent dat `a + b` nooit bereikt zal worden, omdat de functie stopt na het keyword `return`. Als er geen waarde wordt geretourneerd, zoals nu, zal de functie `undefined` teruggeven. Let op dat er geen automatisch insertion plaatsvindt na `if/else` statements!
@@ -3049,18 +3048,18 @@ Dat betekent dat `a + b` nooit bereikt zal worden, omdat de functie stopt na het
 ```javascript
 class Person {
   constructor() {
-    this.name = "Lydia";
+    this.name = "Lydia"
   }
 }
 
 Person = class AnotherPerson {
   constructor() {
-    this.name = "Sarah";
+    this.name = "Sarah"
   }
-};
+}
 
-const member = new Person();
-console.log(member.name);
+const member = new Person()
+console.log(member.name)
 ```
 
 - A: `"Lydia"`
@@ -3084,11 +3083,11 @@ We kunnen classes gelijk zetten tot andere classes/functie constructors. In dit
 
 ```javascript
 const info = {
-  [Symbol("a")]: "b",
-};
+  [Symbol('a')]: 'b'
+}
 
-console.log(info);
-console.log(Object.keys(info));
+console.log(info)
+console.log(Object.keys(info))
 ```
 
 - A: `{Symbol('a'): 'b'}` en `["{Symbol('a')"]`
@@ -3135,13 +3134,13 @@ console.log(getUser(user))
 
 De `getList` functie ontvangt een array als argument. Tussen de haakjes van de `getList` functie destructureren we deze array direct. Je kunt het zien als:
 
-`[x, ...y] = [1, 2, 3, 4]`
+ `[x, ...y] = [1, 2, 3, 4]`
 
 Met de rest parameter `...y` stoppen we alle "overgebleven" argumenten in een array. De overgebleven argumenten zijn in dit geval `2`, `3` en `4`. De waarde van `y` is een array die alle rest parameters bevat. De waarde van `x` is gelijk aan `1` in dit geval, dus wanneer we `[x, y]` loggen wordt `[1, [2, 3, 4]]` gelogd.
-
+ 
 De `getUser` functie ontvangt een object. Met arrow functies _hoeven_ we geen accolades te gebruiken als we maar één waarde willen retourneren. Echter, als je een _object_ wilt retourneren in een arraow functie zal je het tussen haakjes moeten schrijven. Anders zal er geen waarde geretourneerd worden! De volgende functie zal wel een object geretourneerd hebben:
 
-`const getUser = user => ({ name: user.name, age: user.age })`
+```const getUser = user => ({ name: user.name, age: user.age })```
 
 Omdat er geen waarde geretourneerd wordt in dit geval zal de functie `undefined` retourneren.
 
@@ -3153,9 +3152,9 @@ Omdat er geen waarde geretourneerd wordt in dit geval zal de functie `undefined`
 ###### 99. Wat is de uitkomst?
 
 ```javascript
-const name = "Lydia";
+const name = "Lydia"
 
-console.log(name());
+console.log(name())
 ```
 
 - A: `SyntaxError`
@@ -3185,8 +3184,8 @@ ReferenceErrors worden gegooid wanneer JavaScript niet in staat is een referenti
 ```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`
@@ -3211,11 +3210,11 @@ You should${"" && `n't`} see a therapist after so much JavaScript lol`;
 ###### 101. Wat is de waarde van output?
 
 ```javascript
-const one = false || {} || null;
-const two = null || false || "";
-const three = [] || 0 || true;
+const one = (false || {} || null)
+const two = (null || false || "")
+const three = ([] || 0 || true)
 
-console.log(one, two, three);
+console.log(one, two, three)
 ```
 
 - A: `false` `null` `[]`
@@ -3244,20 +3243,20 @@ Met de `||` (or) operator kunnen we de eerste truthy waarde retourneren. Als all
 ###### 102. Wat is de waarde van 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");
+  myPromise().then(res => console.log(res))
+  console.log('second')
 }
 
 async function secondFunction() {
-  console.log(await myPromise());
-  console.log("second");
+  console.log(await myPromise())
+  console.log('second')
 }
 
-firstFunction();
-secondFunction();
+firstFunction()
+secondFunction()
 ```
 
 - A: `I have resolved!`, `second` en `I have resolved!`, `second`
@@ -3288,14 +3287,14 @@ Dit betekent dat het wacht tot de `myPromise` is opgelost met de waarde `I have
 ###### 103. Wat is de waarde van output?
 
 ```javascript
-const set = new Set();
+const set = new Set()
 
-set.add(1);
-set.add("Lydia");
-set.add({ name: "Lydia" });
+set.add(1)
+set.add("Lydia")
+set.add({ name: "Lydia" })
 
 for (let item of set) {
-  console.log(item + 2);
+  console.log(item + 2)
 }
 ```
 
@@ -3325,7 +3324,7 @@ Echter, de tweede is de string `"Lydia"`. `"Lydia"` is een string en `2` is een
 ###### 104. Wat is de waarde?
 
 ```javascript
-Promise.resolve(5);
+Promise.resolve(5)
 ```
 
 - A: `5`
@@ -3352,15 +3351,15 @@ In dit geval geven we alleen de numerieke waarde `5` mee. Het geeft de opgeloste
 ```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);
+compareMembers(person)
 ```
 
 - A: `Not the same!`
@@ -3395,11 +3394,11 @@ const colorConfig = {
   green: true,
   black: true,
   yellow: false,
-};
+}
 
-const colors = ["pink", "red", "blue"];
+const colors = ["pink", "red", "blue"]
 
-console.log(colorConfig.colors[1]);
+console.log(colorConfig.colors[1])
 ```
 
 - A: `true`
@@ -3426,7 +3425,7 @@ JavaScript interpreteert (of beter gezegd unboxed) statements. Wanneer we blokha
 ###### 107. Wat is de waarde?
 
 ```javascript
-console.log("❤️" === "❤️");
+console.log('❤️' === '❤️')
 ```
 
 - A: `true`
@@ -3447,19 +3446,19 @@ Onder de motorkap zijn emojis unicodes. De unicodes voor het hart zijn `"U+2764
 ###### 108. Welke van onderstaande methoden passen de originele array aan?
 
 ```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`
 - B: `map` `reduce` `slice` `splice`
-- C: `map` `slice` `splice`
+- C: `map` `slice` `splice` 
 - D: `splice`
 
 <details><summary><b>Antwoord</b></summary>
@@ -3479,17 +3478,17 @@ Met de `splice` methode passen we de originele array aan door elementen te verwi
 ###### 109. Wat is de uitkomst?
 
 ```javascript
-const food = ["🍕", "🍫", "🥑", "🍔"];
-const info = { favoriteFood: food[0] };
+const food = ['🍕', '🍫', '🥑', '🍔']
+const info = { favoriteFood: food[0] }
 
-info.favoriteFood = "🍝";
+info.favoriteFood = '🍝'
 
-console.log(food);
+console.log(food)
 ```
 
 - A: `['🍕', '🍫', '🥑', '🍔']`
 - B: `['🍝', '🍫', '🥑', '🍔']`
-- C: `['🍝', '🍕', '🍫', '🥑', '🍔']`
+- C: `['🍝', '🍕', '🍫', '🥑', '🍔']` 
 - D: `ReferenceError`
 
 <details><summary><b>Antwoord</b></summary>
@@ -3511,7 +3510,7 @@ Daarna veranderen we de waarde van de property `favoriteFood` op het object `inf
 ###### 110. Wat doet onderstaande methode?
 
 ```javascript
-JSON.parse();
+JSON.parse()
 ```
 
 - A: Ontleedt JSON naar een JavaScript waarde
@@ -3528,16 +3527,16 @@ Met de `JSON.parse()` methode kunnen we een JSON string parsen naar een JavaScri
 
 ```javascript
 // Stringifying een nummer naar valide JSON, daarna de JSON string parsen naar een JavaScript waarde:
-const jsonNumber = JSON.stringify(4); // '4'
-JSON.parse(jsonNumber); // 4
+const jsonNumber = JSON.stringify(4) // '4'
+JSON.parse(jsonNumber) // 4
 
 // Stringifying een array waarde naar een valide JSON, daarna de JSON string parsen naar een JavaScript waarde:
-const jsonArray = JSON.stringify([1, 2, 3]); // '[1, 2, 3]'
-JSON.parse(jsonArray); // [1, 2, 3]
+const jsonArray = JSON.stringify([1, 2, 3]) // '[1, 2, 3]'
+JSON.parse(jsonArray) // [1, 2, 3]
 
 // Stringifying een object naar valide JSON, daarna de JSON string parsen naar een JavaScript waarde:
-const jsonArray = JSON.stringify({ name: "Lydia" }); // '{"name":"Lydia"}'
-JSON.parse(jsonArray); // { name: 'Lydia' }
+const jsonArray = JSON.stringify({ name: "Lydia" }) // '{"name":"Lydia"}'
+JSON.parse(jsonArray) // { name: 'Lydia' }
 ```
 
 </p>
@@ -3545,17 +3544,17 @@ JSON.parse(jsonArray); // { name: 'Lydia' }
 
 ---
 
-###### 111. Wat is de uitkomst?
+###### 111. Wat is de uitkomst? 
 
 ```javascript
-let name = "Lydia";
+let name = 'Lydia'
 
 function getName() {
-  console.log(name);
-  let name = "Sarah";
+  console.log(name)
+  let name = 'Sarah'
 }
 
-getName();
+getName()
 ```
 
 - A: Lydia
@@ -3575,13 +3574,13 @@ Variabelen gedeclareerd met het keyword `let` (en `const`) worden gehoisted, maa
 Als we de variabele `name` **niet** niet hadden gedeclareerd binnen de `getName` functie zou de JavaScript engine doorgezocht hebben door de _scope chain_. De bovenliggende scope heeft een variabele `name` met de waarde `Lydia`. In dat geval zou `Lydia` gelogged worden.
 
 ```javascript
-let name = "Lydia";
+let name = 'Lydia'
 
 function getName() {
-  console.log(name);
+  console.log(name)
 }
 
-getName(); // Lydia
+getName() // Lydia
 ```
 
 </p>
@@ -3593,18 +3592,18 @@ 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();
-const two = generatorTwo();
+const one = generatorOne()
+const two = generatorTwo()
 
-console.log(one.next().value);
-console.log(two.next().value);
+console.log(one.next().value)
+console.log(two.next().value)
 ```
 
 - A: `a` en `a`
@@ -3622,17 +3621,17 @@ Met het keyword `yield` , we `yield` waarden in een generator functie. Met het k
 In `generatorOne` leveren we de volledige array `['a', 'b', 'c']` op, gebruikmakend van het keyword `yield`. De waarde van de propertie `value` op het object geretourneerd door de `next` methode op `one` (`one.next().value`) is gelijk aan de volledige array `['a', 'b', 'c']`.
 
 ```javascript
-console.log(one.next().value); // ['a', 'b', 'c']
-console.log(one.next().value); // undefined
+console.log(one.next().value) // ['a', 'b', 'c']
+console.log(one.next().value) // undefined
 ```
 
 In `generatorTwo` gebruiken we het keyword `yield*`. Dit betekent dat de eerste opgeleverde waarde van `two` is gelijk aan de eerste opgeleverde waarde in de iterator. The iterator is de array `['a', 'b', 'c']`. De eerste opgeleverde waarde is `a`, dus de eerste keer dat we `two.next().value` aanroepen wordt `a` geretourneerd.
 
 ```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
+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>
@@ -3643,7 +3642,7 @@ console.log(two.next().value); // undefined
 ###### 113. Wat is de uitkomst?
 
 ```javascript
-console.log(`${((x) => x)("I love")} to program`);
+console.log(`${(x => x)('I love')} to program`)
 ```
 
 - A: `I love to program`
@@ -3668,11 +3667,11 @@ Expressies binnen template literals worden eerste geëvalueerd. Dit betekent dat
 ```javascript
 let config = {
   alert: setInterval(() => {
-    console.log("Alert!");
-  }, 1000),
-};
+    console.log('Alert!')
+  }, 1000)
+}
 
-config = null;
+config = null
 ```
 
 - A: De `setInterval` callback zal niet worden aangeroepen
@@ -3695,17 +3694,17 @@ Normaal als we objecten gelijk maken aan `null` worden deze objecten opgeruimd d
 ###### 115. Welke methode(n) zal de waarde `'Hello world!'` teruggeven?
 
 ```javascript
-const myMap = new Map();
-const myFunc = () => "greeting";
+const myMap = new Map()
+const myFunc = () => 'greeting'
 
-myMap.set(myFunc, "Hello world!");
+myMap.set(myFunc, 'Hello world!')
 
 //1
-myMap.get("greeting");
+myMap.get('greeting')
 //2
-myMap.get(myFunc);
+myMap.get(myFunc)
 //3
-myMap.get(() => "greeting");
+myMap.get(() => 'greeting')
 ```
 
 - A: 1
@@ -3733,19 +3732,19 @@ Als een **key/value** paar wordt toegevoegd gebruikmakend van de `set` methode z
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21,
-};
+  age: 21
+}
 
-const changeAge = (x = { ...person }) => (x.age += 1);
+const changeAge = (x = { ...person }) => x.age += 1
 const changeAgeAndName = (x = { ...person }) => {
-  x.age += 1;
-  x.name = "Sarah";
-};
+  x.age += 1
+  x.name = "Sarah"
+}
 
-changeAge(person);
-changeAgeAndName();
+changeAge(person)
+changeAgeAndName()
 
-console.log(person);
+console.log(person)
 ```
 
 - A: `{name: "Sarah", age: 22}`
@@ -3773,7 +3772,7 @@ Dan roepen we de functie `changeAgeAndName` aan, echter geven we geen parameter
 
 ```javascript
 function sumValues(x, y, z) {
-  return x + y + z;
+	return x + y + z;
 }
 ```
 
@@ -3824,15 +3823,15 @@ Met de `+=` operator verhogen we de waarde van `num` met `1`. `num` heeft een in
 
 ```javascript
 const person = {
-  firstName: "Lydia",
-  lastName: "Hallie",
-  pet: {
-    name: "Mara",
-    breed: "Dutch Tulip Hound",
-  },
-  getFullName() {
-    return `${this.firstName} ${this.lastName}`;
-  },
+	firstName: "Lydia",
+	lastName: "Hallie",
+	pet: {
+		name: "Mara",
+		breed: "Dutch Tulip Hound"
+	},
+	getFullName() {
+		return `${this.firstName} ${this.lastName}`;
+	}
 };
 
 console.log(person.pet?.name);
@@ -3855,7 +3854,7 @@ Met de _optional chaining operator_ `?.` hoeven we niet langer expliciet te chec
 
 `person.pet?.name`: `person` heeft een propertie genaamd `pet`: `person.pet` is niet _nullish_. Het heeft een propertie genaamd ``name` en retourneerd `Mara`.
 `person.pet?.family?.name`: `person` heeft een propertie genaamd `pet`: `person.pet` is niet _nullish_. `pet` heeft _geen_ propertie genaamd `family`, `person.pet.family` is _nullish_. De expressie geeft `undefined` terug.
-`person.getFullName?.()`: `person` heeft een propertie genaamd `getFullName`: `person.getFullName()` is niet **nullish** en kan worden aangeroepen, wat `Lydia Hallie` retourneerd.
+`person.getFullName?.()`: `person` heeft een propertie genaamd `getFullName`: `person.getFullName()` is niet __nullish__ en kan worden aangeroepen, wat `Lydia Hallie` retourneerd.
 `member.getLastName?.()`: `member` is niet gedefinieerd: `member.getLastName()` is _nullish_. The expressie geeft `undefined` terug.
 
 </p>
@@ -3869,9 +3868,9 @@ Met de _optional chaining operator_ `?.` hoeven we niet langer expliciet te chec
 const groceries = ["banana", "apple", "peanuts"];
 
 if (groceries.indexOf("banana")) {
-  console.log("We have to buy bananas!");
+	console.log("We have to buy bananas!");
 } else {
-  console.log(`We don't have to buy bananas!`);
+	console.log(`We don't have to buy bananas!`);
 }
 ```
 
@@ -3896,10 +3895,10 @@ We geven de conditie `groceries.indexOf("banana")` mee aan de if-statement. `gro
 
 ```javascript
 const config = {
-  languages: [],
-  set language(lang) {
-    return this.languages.push(lang);
-  },
+	languages: [],
+	set language(lang) {
+		return this.languages.push(lang);
+	}
 };
 
 console.log(config.language);
@@ -3953,9 +3952,9 @@ console.log(!typeof name === "string");
 ###### 123. Wat is de uitkomst?
 
 ```javascript
-const add = (x) => (y) => (z) => {
-  console.log(x, y, z);
-  return x + y + z;
+const add = x => y => z => {
+	console.log(x, y, z);
+	return x + y + z;
 };
 
 add(4)(5)(6);
@@ -3982,16 +3981,16 @@ De `add` functie retourneert een arrow functie, die een arrow functie retourneer
 
 ```javascript
 async function* range(start, end) {
-  for (let i = start; i <= end; i++) {
-    yield Promise.resolve(i);
-  }
+	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);
-  }
+	const gen = range(1, 3);
+	for await (const item of gen) {
+		console.log(item);
+	}
 })();
 ```
 
@@ -4016,7 +4015,7 @@ De generator functie `range` retourneert een async object met promises voor elk
 
 ```javascript
 const myFunc = ({ x, y, z }) => {
-  console.log(x, y, z);
+	console.log(x, y, z);
 };
 
 myFunc(1, 2, 3);
@@ -4140,8 +4139,8 @@ Met de `isNaN` methode kun je checken of een waarde die je meegeeft geen numerie
 const randomValue = 21;
 
 function getInfo() {
-  console.log(typeof randomValue);
-  const randomValue = "Lydia Hallie";
+	console.log(typeof randomValue);
+	const randomValue = "Lydia Hallie";
 }
 
 getInfo();
@@ -4170,13 +4169,13 @@ Variables declared with the `const` keyword are not referencable before their in
 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!");
-  }
+	try {
+		console.log(await myPromise);
+	} catch {
+		throw new Error(`Oops didn't work`);
+	} finally {
+		console.log("Oh finally!");
+	}
 })();
 ```
 
@@ -4226,13 +4225,13 @@ Met de `flat` methode kunnen we een nieuwe platgemaakte array maken. De diepte v
 
 ```javascript
 class Counter {
-  constructor() {
-    this.count = 0;
-  }
+	constructor() {
+		this.count = 0;
+	}
 
-  increment() {
-    this.count++;
-  }
+	increment() {
+		this.count++;
+	}
 }
 
 const counterOne = new Counter();
@@ -4276,16 +4275,16 @@ We roepen `counterTwo.increment()` aan, wat `count` gelijk maakt aan `3`. Als we
 const myPromise = Promise.resolve(Promise.resolve("Promise!"));
 
 function funcOne() {
-  myPromise.then((res) => res).then((res) => console.log(res));
-  setTimeout(() => console.log("Timeout!", 0));
-  console.log("Last line!");
+	myPromise.then(res => res).then(res => console.log(res));
+	setTimeout(() => console.log("Timeout!", 0));
+	console.log("Last line!");
 }
 
 async function funcTwo() {
-  const res = await myPromise;
-  console.log(await res);
-  setTimeout(() => console.log("Timeout!", 0));
-  console.log("Last line!");
+	const res = await myPromise;
+	console.log(await res);
+	setTimeout(() => console.log("Timeout!", 0));
+	console.log("Last line!");
 }
 
 funcOne();
@@ -4302,7 +4301,7 @@ funcTwo();
 
 #### Antwoord: D
 
-Eerst roepen we `funcOne` aan. Op de eerste regel van `funcOne` roepen we de promise `myPromise` aan, wat een _asynchrone_ operatie is. Zolang de JavaScript engine bezig is met het afmaken van de promise wordt de rest van de functie `funcOne` uitgevoerd. De volgende regel is een _asynchrone_ `setTimeout` functie, waarvan de callback functie naar de Web API wordt gestuurd.
+Eerst roepen we `funcOne` aan. Op de eerste regel van `funcOne` roepen we de promise `myPromise` aan, wat een _asynchrone_ operatie is. Zolang de JavaScript engine bezig is met het afmaken van de promise wordt de rest van de functie `funcOne` uitgevoerd. De volgende regel is een _asynchrone_ `setTimeout` functie, waarvan de callback functie naar de Web API wordt gestuurd. 
 
 Zowel de promise als de timeout zijn _asynchrone_ operaties en de functie worden uitgevoerd terwijl de engine bezig is om de promise uit te voeren en de `setTimeout` callback functie af te handelen. Dit betekent dat `Last line!` als eerste wordt gelogd, omdat dit geen _asynchrone_ operatie is. Dit is de laatste regel van `funcOne`. Ondertussen wordt de promise opgelost en `Promise!` wordt gelogd. Echter, omdat we `funcTwo()` aanroepen en de callstack nog niet leeg is kan de callback van de `setTimeout` functie nog niet toegevoegd worden aan de callstack.
 
@@ -4317,12 +4316,12 @@ We komen op de laatste regel van `funcTwo` wat `Last line!` logt naar het consol
 
 ---
 
-###### 134. Hoe kunnen we `sum` uit `sum.js` aanroepen in `index.js`?`
+###### 134. Hoe kunnen we `sum` uit `sum.js` aanroepen  in `index.js`?`
 
 ```javascript
 // sum.js
 export default function sum(x) {
-  return x + x;
+	return x + x;
 }
 
 // index.js
@@ -4379,8 +4378,8 @@ We kunnen deze functie aanvoeren door `sum.default` aan te roepen.
 
 ```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);
@@ -4430,7 +4429,7 @@ Object.seal(person);
 
 #### Antwoord: A
 
-Met `Object.seal` kunnen we voorkomen dat nieuwe properties kunnen worden _toegevoegd_ of bestaande properties worden _verwijderd_.
+Met `Object.seal`  kunnen we voorkomen dat nieuwe properties kunnen worden _toegevoegd_ of bestaande properties worden _verwijderd_.
 
 Echter kunnen van de bestaande properties nog steeds aanpassen.
 
@@ -4443,10 +4442,10 @@ Echter kunnen van de bestaande properties nog steeds aanpassen.
 
 ```javascript
 const person = {
-  name: "Lydia Hallie",
-  address: {
-    street: "100 Main St",
-  },
+	name: "Lydia Hallie",
+	address: {
+		street: "100 Main St"
+	}
 };
 
 Object.freeze(person);
@@ -4474,10 +4473,10 @@ Echter wordt het object enkel _oppervlakkig_ bevroren wat betekent dat alleen _d
 ###### 138. Wat is de uitkomst?
 
 ```javascript
-const add = (x) => x + x;
+const add = x => x + x;
 
 function myFunc(num = 2, value = add(num)) {
-  console.log(num, value);
+	console.log(num, value);
 }
 
 myFunc();
@@ -4507,21 +4506,21 @@ Daarna roepen we de functie `myFunc(3)` aan het geven `3` meet als de waarde voo
 
 ```javascript
 class Counter {
-  #number = 10;
+  #number = 10
 
   increment() {
-    this.#number++;
+    this.#number++
   }
 
   getNum() {
-    return this.#number;
+    return this.#number
   }
 }
 
-const counter = new Counter();
-counter.increment();
+const counter = new Counter()
+counter.increment()
 
-console.log(counter.#number);
+console.log(counter.#number)
 ```
 
 - A: `10`
@@ -4545,20 +4544,20 @@ In ES2020 kunnen we private variabelen toevoegen aan classes door gebruik te mak
 
 ```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) {
-  for (let i = 0; i < members.length; i++) {
-    yield members[i];
-  }
+	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 ✨
-  }
+	for (let i = 0; i < teams.length; i++) {
+		// ✨ SOMETHING IS MISSING HERE ✨
+	}
 }
 
 const obj = getTeams(teams);
@@ -4589,13 +4588,13 @@ Als we `yield`, `return yield`, of `return` hadden geschreven zou de gehele gene
 
 ```javascript
 const person = {
-  name: "Lydia Hallie",
-  hobbies: ["coding"],
+	name: "Lydia Hallie",
+	hobbies: ["coding"]
 };
 
 function addHobby(hobby, hobbies = person.hobbies) {
-  hobbies.push(hobby);
-  return hobbies;
+	hobbies.push(hobby);
+	return hobbies;
 }
 
 addHobby("running", []);
@@ -4634,16 +4633,16 @@ Na het pushen van `dancing` en `baking` is de waarde van `person.hobbies` gelijk
 
 ```javascript
 class Bird {
-  constructor() {
-    console.log("I'm a bird. 🦢");
-  }
+	constructor() {
+		console.log("I'm a bird. 🦢");
+	}
 }
 
 class Flamingo extends Bird {
-  constructor() {
-    console.log("I'm pink. 🌸");
-    super();
-  }
+	constructor() {
+		console.log("I'm pink. 🌸");
+		super();
+	}
 }
 
 const pet = new Flamingo();
diff --git a/pl-PL/README.md b/pl-PL/README.md
index ca8e1a3b..866f4458 100644
--- a/pl-PL/README.md
+++ b/pl-PL/README.md
@@ -10,11 +10,10 @@ Od podstawowych do zaawansowanych: sprawdź, jak dobrze znasz JavaScript, odświ
 
 Nie krępuj się ze mną kontaktować! 😊 <br />
 <a href="https://www.instagram.com/theavocoder">Instagram</a> || <a href="https://www.twitter.com/lydiahallie">Twitter</a> || <a href="https://www.linkedin.com/in/lydia-hallie">LinkedIn</a> || <a href="https://www.lydiahallie.dev">Blog</a>
-
 </div>
 
-| Śmiało używaj ich w projekcie! 😃 Byłabym _bardzo_ wdzięczna za referencje do tego repozytorium, tworzę pytania i wyjaśnienia (tak, jestem smutna lol) i społeczność bardzo mi pomaga w utrzymaniu i ulepszaniu go! 💪🏼 Dziękuję i baw się dobrze! |
-| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Śmiało używaj ich w projekcie! 😃  Byłabym _bardzo_ wdzięczna za referencje do tego repozytorium, tworzę pytania i wyjaśnienia (tak, jestem smutna lol) i społeczność bardzo mi pomaga w utrzymaniu i ulepszaniu go! 💪🏼 Dziękuję i baw się dobrze!   |
+|---|
 
 ---
 
@@ -33,7 +32,6 @@ Nie krępuj się ze mną kontaktować! 😊 <br />
 - [🇰🇷 한국어](./ko-KR/README-ko_KR.md)
 - [🇳🇱 Nederlands](./nl-NL/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)
@@ -54,7 +52,7 @@ Nie krępuj się ze mną kontaktować! 😊 <br />
 function sayHi() {
   console.log(name);
   console.log(age);
-  var name = "Lydia";
+  var name = 'Lydia';
   let age = 21;
 }
 
@@ -150,7 +148,7 @@ Na tym obiekcie nie ma wartości `radius`, co powoduje zwrócenie `NaN` (Not a N
 
 ```javascript
 +true;
-!"Lydia";
+!'Lydia';
 ```
 
 - A: `1` and `false`
@@ -175,11 +173,11 @@ Operator jednoargumentowy plus próbuje przekonwertować operand na liczbę. `tr
 
 ```javascript
 const bird = {
-  size: "small",
+  size: 'small',
 };
 
 const mouse = {
-  name: "Mickey",
+  name: 'Mickey',
   small: true,
 };
 ```
@@ -210,11 +208,11 @@ Jednakże, w przypadku notacji kropkowej, to się nie dzieje. `mouse` nie ma klu
 ###### 6. Jaki jest wynik?
 
 ```javascript
-let c = { greeting: "Hey!" };
+let c = { greeting: 'Hey!' };
 let d;
 
 d = c;
-c.greeting = "Hello";
+c.greeting = 'Hello';
 console.log(d.greeting);
 ```
 
@@ -284,13 +282,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`
@@ -345,10 +343,10 @@ Aby temu zapobiec, możemy użyć `"use strict"`. Powoduje to, że musisz zadekl
 
 ```javascript
 function bark() {
-  console.log("Woof!");
+  console.log('Woof!');
 }
 
-bark.animal = "dog";
+bark.animal = 'dog';
 ```
 
 - A: Nothing, this is totally fine!
@@ -378,8 +376,8 @@ function Person(firstName, lastName) {
   this.lastName = lastName;
 }
 
-const member = new Person("Lydia", "Hallie");
-Person.getFullName = function () {
+const member = new Person('Lydia', 'Hallie');
+Person.getFullName = function() {
   return `${this.firstName} ${this.lastName}`;
 };
 
@@ -401,7 +399,7 @@ W JavaScript funkcje są obiektami, więc metoda `getFullName` jest dodawana do
 Jeśli chcesz, aby metoda była dostępna dla wszystkich instancji obiektów, musisz dodać ją do właściwości prototype:
 
 ```js
-Person.prototype.getFullName = function () {
+Person.prototype.getFullName = function() {
   return `${this.firstName} ${this.lastName}`;
 };
 ```
@@ -419,8 +417,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);
@@ -490,7 +488,7 @@ function sum(a, b) {
   return a + b;
 }
 
-sum(1, "2");
+sum(1, '2');
 ```
 
 - A: `NaN`
@@ -536,7 +534,7 @@ Operator jednoargumentowy **Postfix** `++`:
 1. Zwraca wartość (ten zwraca `0`)
 2. Zwiększa wartość (liczba wynosi teraz `1`)
 
-Operator jednoargumentowy **Prefix** `++`:
+Operator jednoargumentowy **Prefix**  `++`:
 
 1. Zwiększa wartość (liczba wynosi teraz `2`)
 2. Zwraca wartość (to zwraca `2`)
@@ -557,7 +555,7 @@ function getPersonInfo(one, two, three) {
   console.log(three);
 }
 
-const person = "Lydia";
+const person = 'Lydia';
 const age = 21;
 
 getPersonInfo`${person} is ${age} years old`;
@@ -584,9 +582,9 @@ W przypadku użycia `template strings`, wartością pierwszego argumentu jest za
 ```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`);
   }
@@ -646,7 +644,7 @@ Parametr reszty (`...args`) pozwala nam "zbierać" wszystkie pozostałe argument
 
 ```javascript
 function getAge() {
-  "use strict";
+  'use strict';
   age = 21;
   console.log(age);
 }
@@ -674,7 +672,7 @@ Dzięki `"use strict"` możesz upewnić się, że przypadkowo nie zadeklarujesz
 ###### 21. Jaka jest wartość `sum`?
 
 ```javascript
-const sum = eval("10*10+5");
+const sum = eval('10*10+5');
 ```
 
 - A: `105`
@@ -697,7 +695,7 @@ const sum = eval("10*10+5");
 ###### 22. Jak długo cool_secret jest dostępny?
 
 ```javascript
-sessionStorage.setItem("cool_secret", 123);
+sessionStorage.setItem('cool_secret', 123);
 ```
 
 - A: Dane nigdy nie zostaną utracone.
@@ -750,12 +748,12 @@ Nie można tego zrobić za pomocą `let` lub `const`, ponieważ są one blokowe.
 ###### 24. Jaki jest wynik?
 
 ```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);
 ```
 
@@ -781,7 +779,7 @@ Nie działa to w ten sam sposób dla zbioru. W zbiorze nie ma klucza `'1'`:`set.
 ###### 25. Jaki jest wynik?
 
 ```javascript
-const obj = { a: "one", b: "two", a: "three" };
+const obj = { a: 'one', b: 'two', a: 'three' };
 console.log(obj);
 ```
 
@@ -850,12 +848,12 @@ Instrukcja `continue` pomija iterację, jeśli określony warunek zwróci `true`
 
 ```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());
+console.log(name.giveLydiaPizza())
 ```
 
 - A: `"Just give Lydia pizza already!"`
@@ -879,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;
@@ -912,9 +910,9 @@ Następnie wyświetlamy w konsoli `a[b]`, co w rzeczywistości jest `a["[obiekt
 ###### 30. Jaki jest wynik?
 
 ```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();
@@ -967,7 +965,9 @@ W tym miejscu zaczyna działać pętla zdarzeń. **Pętla zdarzeń** patrzy na s
 ```html
 <div onclick="console.log('first div')">
   <div onclick="console.log('second div')">
-    <button onclick="console.log('button')">Click!</button>
+    <button onclick="console.log('button')">
+      Click!
+    </button>
   </div>
 </div>
 ```
@@ -993,7 +993,9 @@ Najgłębiej zagnieżdżony element, który spowodował zdarzenie jest celem zda
 
 ```html
 <div onclick="console.log('div')">
-  <p onclick="console.log('p')">Click here!</p>
+  <p onclick="console.log('p')">
+    Click here!
+  </p>
 </div>
 ```
 
@@ -1017,7 +1019,7 @@ Jeśli klikniemy `p`, zobaczymy dwa logi: `p` i `div`. Podczas propagacji zdarze
 ###### 33. Jaki jest wynik?
 
 ```javascript
-const person = { name: "Lydia" };
+const person = { name: 'Lydia' };
 
 function sayHi(age) {
   return `${this.name} is ${age}`;
@@ -1067,6 +1069,7 @@ console.log(typeof sayHi());
 #### Odpowiedź: B
 
 Funkcja `sayHi` zwraca zwróconą wartość natychmiast wywołanego wyrażenia funkcyjnego (IIFE). Ta funkcja zwróciła wartość `0`, która jest typu `"number"`.
+	
 FYI: `typeof` może zwrócić następującą listę wartości: `undefined`, `boolean`, `number`, `bigint`, `string`, `symbol`, `function` i `object`. Zauważ, że `typeof null` zwraca `"object"`.
 
 </p>
@@ -1079,8 +1082,8 @@ FYI: `typeof` może zwrócić następującą listę wartości: `undefined`, `boo
 ```javascript
 0;
 new Number(0);
-("");
-(" ");
+('');
+(' ');
 new Boolean(false);
 undefined;
 ```
@@ -1229,14 +1232,11 @@ To, co odróżnia prymityw od obiektu, to fakt, że prymitywy nie mają żadnych
 ###### 40. Jaki jest wynik?
 
 ```javascript
-[
-  [0, 1],
-  [2, 3],
-].reduce(
+[[0, 1], [2, 3]].reduce(
   (acc, cur) => {
     return acc.concat(cur);
   },
-  [1, 2]
+  [1, 2],
 );
 ```
 
@@ -1263,7 +1263,7 @@ Następnie `[1, 2, 0, 1]` to `acc`, a `[2, 3]` to `cur`. Łączymy je i otrzymuj
 
 ```javascript
 !!null;
-!!"";
+!!'';
 !!1;
 ```
 
@@ -1291,7 +1291,7 @@ Następnie `[1, 2, 0, 1]` to `acc`, a `[2, 3]` to `cur`. Łączymy je i otrzymuj
 ###### 42. Co zwraca metoda `setInterval` w przeglądarce?
 
 ```javascript
-setInterval(() => console.log("Hi"), 1000);
+setInterval(() => console.log('Hi'), 1000);
 ```
 
 - A: unikalny identyfikator
@@ -1314,7 +1314,7 @@ Zwraca unikalny identyfikator. Ten identyfikator może być użyty do wyczyszcze
 ###### 43. Co to zwróci?
 
 ```javascript
-[..."Lydia"];
+[...'Lydia'];
 ```
 
 - A: `["L", "y", "d", "i", "a"]`
@@ -1373,14 +1373,14 @@ Następnie ponownie wywołujemy funkcję za pomocą metody `next()`. Kontynuuje
 
 ```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));
+Promise.race([firstPromise, secondPromise]).then(res => console.log(res));
 ```
 
 - A: `"one"`
@@ -1403,7 +1403,7 @@ Kiedy przekazujemy wiele 'promise' do metody `Promise.race`, rozwiązuje ona/odr
 ###### 46. Jaki jest wynik?
 
 ```javascript
-let person = { name: "Lydia" };
+let person = { name: 'Lydia' };
 const members = [person];
 person = null;
 
@@ -1443,7 +1443,7 @@ Modyfikujemy tylko wartość zmiennej `person`, a nie pierwszy element w tablicy
 
 ```javascript
 const person = {
-  name: "Lydia",
+  name: 'Lydia',
   age: 21,
 };
 
@@ -1472,7 +1472,7 @@ Za pomocą pętli `for-in` możemy iterować po kluczach obiektów, w tym przypa
 ###### 48. Jaki jest wynik?
 
 ```javascript
-console.log(3 + 4 + "5");
+console.log(3 + 4 + '5');
 ```
 
 - A: `"345"`
@@ -1499,7 +1499,7 @@ Asocjatywność operatorów to kolejność, w jakiej kompilator ocenia wyrażeni
 ###### 49. Jaka jest wartość `num`?
 
 ```javascript
-const num = parseInt("7*6", 10);
+const num = parseInt('7*6', 10);
 ```
 
 - A: `42`
@@ -1524,8 +1524,8 @@ Zwracana jest tylko pierwsza liczba w łańcuchu. W oparciu o _radix_ (drugi arg
 ###### 50. Jaki jest wynik?
 
 ```javascript
-[1, 2, 3].map((num) => {
-  if (typeof num === "number") return;
+[1, 2, 3].map(num => {
+  if (typeof num === 'number') return;
   return num * 2;
 });
 ```
@@ -1545,4 +1545,4 @@ Podczas mapowania tablicy, wartość `num` jest równa elementowi, nad którym a
 Nie zwracamy jednak żadnej wartości. Gdy nie zwracamy wartości z funkcji, funkcja zwraca `undefined`. Dla każdego elementu w tablicy wywoływany jest blok funkcji, więc dla każdego elementu zwracamy `undefined`.
 
 </p>
-</details>
+</details>
\ No newline at end of file
diff --git a/pt-BR/README_pt_BR.md b/pt-BR/README_pt_BR.md
index a0a0a211..e59c6a6f 100644
--- a/pt-BR/README_pt_BR.md
+++ b/pt-BR/README_pt_BR.md
@@ -19,7 +19,6 @@ As respostas estão em seções recolhidas abaixo das questões, basta clicar ne
 - [🇰🇷 한국어](../ko-KR/README-ko_KR.md)
 - [🇳🇱 Nederlands](../nl-NL/README.md)
 - [🇵🇱 Polski](../pl-PL/README.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)
@@ -29,6 +28,7 @@ As respostas estão em seções recolhidas abaixo das questões, basta clicar ne
 - [🇨🇳 简体中文](../zh-CN/README-zh_CN.md)
 - [🇹🇼 繁體中文](../zh-TW/README_zh-TW.md)
 
+
 ---
 
 ###### 1. Qual o resultado?
@@ -101,7 +101,7 @@ const shape = {
   diameter() {
     return this.radius * 2;
   },
-  perimeter: () => 2 * Math.PI * this.radius,
+  perimeter: () => 2 * Math.PI * this.radius
 };
 
 shape.diameter();
@@ -147,9 +147,8 @@ Não há `radius` fora de <i>shape</i>, então retorna `undefined`.
 
 O operador unário `+` tenta converter um operando para um número. `true` é `1`, e `false` é `0`.
 
-A string `'Lydia'` tem valor truthy\*. O que estamos realmente perguntando é "Esse valor truthy é falsy?". Isso retorna `false`.
-
-###### \*Nota do tradutor: <i>truthy</i> é um termo único ao JavaScript que denota valores que podem ser convertidos em um booleano `True`. Sua contraparte é <i>falsy</i>, que são valores que podem ser convertidos em um booleano `false`. Para fins de consistência, mantenho os termos originais.
+A string `'Lydia'` tem valor truthy*. O que estamos realmente perguntando é "Esse valor truthy é falsy?". Isso retorna `false`.  
+###### *Nota do tradutor: <i>truthy</i> é um termo único ao JavaScript que denota valores que podem ser convertidos em um booleano `True`. Sua contraparte é <i>falsy</i>, que são valores que podem ser convertidos em um booleano `false`. Para fins de consistência, mantenho os termos originais. 
 
 </p>
 </details>
@@ -160,12 +159,12 @@ A string `'Lydia'` tem valor truthy\*. O que estamos realmente perguntando é "E
 
 ```javascript
 const bird = {
-  size: "small",
+  size: "small"
 };
 
 const mouse = {
   name: "Mickey",
-  small: true,
+  small: true
 };
 ```
 
@@ -251,7 +250,7 @@ console.log(b === c);
 
 `new Number()` é uma funcção construtura padrão do JavaScript. Ainda que parece com um número, não é realmente um número: Tem um monte de funções extras e é um objeto.
 
-Quando usamos o operador `==`, só conferimos se ambas tem o mesmo <i>valor</i>. Ambas tem o valor de `3`, então retorna `true`.
+Quando usamos o operador `==`, só conferimos se ambas tem o mesmo <i>valor</i>. Ambas tem o valor de `3`, então retorna `true`. 
 
 Contudo, quando usamos o operador `===`, ambos valor <i>e</i> tipo tem de ser o mesmo. E não são: `new Number()` não é um número, é um **objeto**. Ambos retornam `false`.
 
@@ -315,7 +314,7 @@ console.log(greetign);
 
 Cria o log do objeto, pois criamos um objeto vazio no objeto global! Quando erramos a digitação de `greeting` como `greetign`, o interpretador do JavaScript viu isso como `global.greetign = {}` (ou `window.greetign = {}` em um navegador).
 
-Para evitar esse comportamento, podemos usar `"use strict"`. Isso garante que você tenha declarado uma variável antes de poder inicializá-la com algum valor.
+Para evitar esse comportamento, podemos usar `"use strict"`. Isso garante que você  tenha declarado uma variável antes de poder inicializá-la com algum valor.
 
 </p>
 </details>
@@ -360,7 +359,7 @@ function Person(firstName, lastName) {
 }
 
 const member = new Person("Lydia", "Hallie");
-Person.getFullName = function () {
+Person.getFullName = function() {
   return `${this.firstName} ${this.lastName}`;
 };
 
@@ -382,7 +381,7 @@ Você não pode adicionar propriedades para um construtor igual aos objetos norm
 Então nesse caso
 
 ```js
-Person.prototype.getFullName = function () {
+Person.prototype.getFullName = function() {
   return `${this.firstName} ${this.lastName}`;
 };
 ```
@@ -441,8 +440,7 @@ Afirmamos que `this.firstName` vale `"Sarah"` e `this.lastName` vale `"Smith"`.
 #### Resposta: D
 
 Durate a fase do **capturing**, o evento percorre os elementos pais até chegar no elemento algo. Isso alcança o elemento **target**, e o **bubbling** começa.
-
-##### \*Nota do tradutor: _bubbling_ descreve uma forma específica de propagação de eventos. Em tradução livre é "borbulhar", que indica como os eventos "sobem" a cadeia onde estão aninhados, mas prefiro por manter o original, visto que é o nome dessa forma de propagação.
+ ##### *Nota do tradutor: _bubbling_ descreve uma forma específica de propagação de eventos. Em tradução livre é "borbulhar", que indica como os eventos "sobem" a cadeia onde estão aninhados, mas prefiro por manter o original, visto que é o nome dessa forma de propagação.
 
 <img src="https://i.imgur.com/N18oRgd.png" width="200">
 
@@ -461,7 +459,7 @@ Durate a fase do **capturing**, o evento percorre os elementos pais até chegar
 
 #### Resposta: B
 
-Todos objetos tem protótipos, exceto pelo **base object**. O base object tem acesso à alguns métodos e propriedades, como `.toString`. É o motivo de podermos usar métodos já embutidos no JavaScript! Todos métodos desse tipo já estão embutidos no protótipo. Apesar do JavaScript não encontrar algum método diretamente no seu objeto, ele percorre a cadeia de protótipos até encontrar no base, o que torna acessível para todo objeto.
+Todos objetos tem protótipos, exceto pelo **base object**. O base object tem acesso à alguns métodos e propriedades, como `.toString`. É o motivo de podermos usar métodos já embutidos no JavaScript! Todos métodos desse tipo já estão embutidos no protótipo. Apesar do JavaScript não encontrar algum método diretamente no seu objeto, ele percorre a cadeia de protótipos até encontrar no base, o que torna acessível para todo objeto. 
 
 </p>
 </details>
@@ -516,7 +514,7 @@ console.log(number);
 
 #### Resposta: C
 
-O operador unário no **sufixo** `++`:
+O operador unário no **sufixo**  `++`:
 
 1. Retorna o valor (retorna o valor `0`)
 2. Incrementa o valor (numero agora é `1`)
@@ -589,7 +587,7 @@ checkAge({ age: 18 });
 
 #### Resposta: C
 
-Quando testamos igualdade, primitivos são comparados por seus _valores_, enquanto objetos são comparados por suas _referências_. O JavaScript confere se os objetos tem a referência para o mesmo local na memória.
+Quando testamos igualdade, primitivos são comparados por seus _valores_, enquanto objetos são comparados por suas  _referências_. O JavaScript confere se os objetos tem a referência para o mesmo local na memória.
 
 Os dois objetos que estamos comparando não são assim: O objeto que passamos como parâmetro faz referência a uma posição na memória diferente daquela que o objeto que usamos para conferir a igualdade.
 
@@ -790,7 +788,7 @@ Se temos duas chaves com o mesmo nome, a última irá substituir a primeira. Ain
 ###### 26. O contexto global de execução do JavaScript cria duas coisas para você: O objeto global, e a palavra-chave `this`.
 
 - A: Verdadeiro
-- B: Falso
+- B: Falso 
 - C: Depende
 
 <details><summary><b>Resposta</b></summary>
@@ -840,7 +838,7 @@ String.prototype.giveLydiaPizza = () => {
 
 const name = "Lydia";
 
-console.log(name.giveLydiaPizza());
+console.log(name.giveLydiaPizza())
 ```
 
 - A: `"Just give Lydia pizza already!"`
@@ -952,7 +950,9 @@ A `WebAPI` não pode simplesmente adicionar coisas ao stack sempre que ficam pro
 ```html
 <div onclick="console.log('first div')">
   <div onclick="console.log('second div')">
-    <button onclick="console.log('button')">Click!</button>
+    <button onclick="console.log('button')">
+      Click!
+    </button>
   </div>
 </div>
 ```
@@ -967,7 +967,7 @@ A `WebAPI` não pode simplesmente adicionar coisas ao stack sempre que ficam pro
 
 #### Resposta: C
 
-O elemento mais interno no aninhamento que causou o evento é o alvo do evento. Você pode parar o _bubbling_ com `event.stopPropagation`.
+O elemento mais interno no aninhamento que causou o evento é o alvo do evento. Você pode parar o _bubbling_ com `event.stopPropagation`. 
 
 </p>
 </details>
@@ -978,7 +978,9 @@ O elemento mais interno no aninhamento que causou o evento é o alvo do evento.
 
 ```html
 <div onclick="console.log('div')">
-  <p onclick="console.log('p')">Click here!</p>
+  <p onclick="console.log('p')">
+    Click here!
+  </p>
 </div>
 ```
 
@@ -1053,7 +1055,7 @@ typeof sayHi();
 
 A função `sayHi` retorna o valor retornado pela arrow function pois ela é uma IIFE (Immediately Invoked Function Expression ou Expressão de Função Invocada Imediatamente). Essa IIFE retornou `0`, que é do tipo `"number"`.
 
-Para saber mais: Só existem 7 tipos já definidos: `null`, `undefined`, `boolean`, `number`, `string`, `object`, `symbol`, e `bigint`. `"function"` não é um tipo, uma vez que funções são objetos, elas são do tipo `"object"`.
+Para saber mais: Só existem 7 tipos já definidos: `null`, `undefined`, `boolean`, `number`, `string`, `object`, `symbol`, e `bigint`. `"function"` não é um tipo, uma vez que  funções são objetos, elas são do tipo `"object"`.
 
 </p>
 </details>
@@ -1213,10 +1215,7 @@ O que diferencia um primitivo de um objeto é que primitivos não possuem métod
 ###### 40. Qual o resultado?
 
 ```javascript
-[
-  [0, 1],
-  [2, 3],
-].reduce(
+[[0, 1], [2, 3]].reduce(
   (acc, cur) => {
     return acc.concat(cur);
   },
@@ -1279,7 +1278,7 @@ setInterval(() => console.log("Hi"), 1000);
 ```
 
 - A: um id único
-- B: a quantidade de millisegundos especificada
+- B: a quantidade de  millisegundos especificada
 - C: a função passada
 - D: `undefined`
 
@@ -1363,7 +1362,7 @@ const secondPromise = new Promise((res, rej) => {
   setTimeout(res, 100, "two");
 });
 
-Promise.race([firstPromise, secondPromise]).then((res) => console.log(res));
+Promise.race([firstPromise, secondPromise]).then(res => console.log(res));
 ```
 
 - A: `"one"`
@@ -1427,7 +1426,7 @@ Estamos apenas modificando o valor da variável `person`, e não o primeiro elem
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21,
+  age: 21
 };
 
 for (const item in person) {
@@ -1507,7 +1506,7 @@ Apenas os primeiros números da string é retornado. Baseado no _radix_ (o segun
 ###### 50. Qual o resultado?
 
 ```javascript
-[1, 2, 3].map((num) => {
+[1, 2, 3].map(num => {
   if (typeof num === "number") return;
   return num * 2;
 });
@@ -1676,7 +1675,7 @@ class Dog {
     this.name = name;
   }
 }
-Dog.prototype.bark = function () {
+Dog.prototype.bark = function() {
   console.log(`Woof I am ${this.name}`);
 };
 const pet = new Dog("Mara");
@@ -1851,6 +1850,7 @@ console.log(admin);
 
 #### Resposta: B
 
+
 É possível combinar objetos usando o operador o spread operator `...`. Ele permite criar cópias dos pares de um objeto e adicioná-las a outro objeto. Nesse caso, criamos cópias do objeto `user` e as adicionamos ao objeto `admin`. O objeto `admin` agora contém os pares de chave/valor copiados, o que resulta em `{ admin: true, name: "Lydia", age: 21 }`.
 
 </p>
@@ -1878,12 +1878,10 @@ console.log(Object.keys(person));
 <p>
 
 #### Resposta: B
+Com o método `defineProperty`, podemos adicionar novas propriedades a um objeto ou modificar propriedades já existentes. Quando adicionamos uma propriedade a um objeto usando o método `defineProperty`, ela é, por padrão, _não enumerável_. O método`Object.keys` retorna todos os nomes de uma propriedade _enumerável_  de um objeto. Nesse caso, apenas `"name"`.
 
-Com o método `defineProperty`, podemos adicionar novas propriedades a um objeto ou modificar propriedades já existentes. Quando adicionamos uma propriedade a um objeto usando o método `defineProperty`, ela é, por padrão, _não enumerável_. O método`Object.keys` retorna todos os nomes de uma propriedade _enumerável_ de um objeto. Nesse caso, apenas `"name"`.
-
-Propriedades adicionadas usando o método `defineProperty` são imutáveis por padrão. Você pode sobrepor esse comportamento usando as propriedade `writable`, `configurable` e `enumerable`.
+Propriedades adicionadas usando o método `defineProperty` são imutáveis por padrão. Você pode sobrepor esse comportamento usando as propriedade `writable`, `configurable` e `enumerable`. 
 Assim, o método `defineProperty` dá a você muito mais controle sobre as propriedades que você está adicionando a um objeto.
-
 </p>
 </details>
 
@@ -1895,7 +1893,7 @@ Assim, o método `defineProperty` dá a você muito mais controle sobre as propr
 const settings = {
   username: "lydiahallie",
   level: 19,
-  health: 90,
+  health: 90
 };
 
 const data = JSON.stringify(settings, ["level", "health"]);
@@ -1917,19 +1915,17 @@ O segundo argumento de `JSON.stringify` é o _substituo_. O substituto pode ser
 Se o substituto (replacer) for um _array_, apenas os nomes de propriedades incluídos no array serão adicionados à string JSON. Nesse caso, apenas as propriedades com os nomes `"level"` ed `"health"` são incluída, `"username"` é excluída. `data` agora é igual a `"{"level":19, "health":90}"`.
 
 Se o substituto (replacer) for uma _função_, essa função é chamada em c ada propriedade no objeto que está sendo "Stringfied". O valor retornado dessa função será o valor da propriedade quanto adicionado à string JSON. Se o valor for `undefined`, essa propriedade é excluída da string JSON.
-
 </p>
 </details>
 
 ---
-
 ###### 63. Qual o resultado?
 
 ```javascript
 let num = 10;
 
 const increaseNumber = () => num++;
-const increasePassedNumber = (number) => number++;
+const increasePassedNumber = number => number++;
 
 const num1 = increaseNumber();
 const num2 = increasePassedNumber(num1);
@@ -1956,7 +1952,6 @@ O operador unário `++` primeiro _retorna_ o valor do operando, depois _incremen
 </details>
 
 ---
-
 ###### 64. Qual o resultado?
 
 ```javascript
@@ -1994,7 +1989,6 @@ Na quarta vez, passamos o objeto `value` novamente. `x.number` foi modificado an
 </details>
 
 ---
-
 ###### 65. Qual o resultado?
 
 ```javascript
@@ -2080,17 +2074,16 @@ A classe `Labrador` recebe dois argumentos, `name`, pois estende `Dog`, e `size`
 </details>
 
 ---
-
 ###### 67. Qual o resultado?
 
 ```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;
 ```
 
@@ -2112,13 +2105,12 @@ Esta é uma diferença entre `require()` no CommonJS e `import`! Com `require()`
 </details>
 
 ---
-
 ###### 68. Qual o resultado?
 
 ```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`
@@ -2137,11 +2129,10 @@ Todo símbolo (Symbol) é totalmente único. O objetivo do argumento passado ao
 </details>
 
 ---
-
 ###### 69. Qual o resultado?
 
 ```javascript
-const name = "Lydia Hallie";
+const name = 'Lydia Hallie';
 console.log(name.padStart(13));
 console.log(name.padStart(2));
 ```
@@ -2164,11 +2155,10 @@ Se o argumento passado para o método `padStart` for menor que o comprimento da
 </details>
 
 ---
-
 ###### 70. Qual o resultado?
 
 ```javascript
-console.log("🥑" + "💻");
+console.log('🥑' + '💻');
 ```
 
 - A: `"🥑💻"`
@@ -2192,11 +2182,11 @@ Com o operador `+`, você pode concatenar seqüências de caracteres (strings).
 
 ```javascript
 function* iniciarJogo() {
-  const resposta = yield "Você ama JavaScript?";
-  if (resposta !== "Sim") {
+  const resposta = yield 'Você ama JavaScript?';
+  if (resposta !== 'Sim') {
     return "Uau... Acho que entramos aqui";
   }
-  return "O JavaScript também ama você ❤️";
+  return 'O JavaScript também ama você ❤️';
 }
 
 const jogo = iniciarJogo();
@@ -2259,12 +2249,11 @@ Neste caso, a string é `Hello\nworld`, que é registrada.
 </details>
 
 ---
-
 ###### 73. Qual o resultado?
 
 ```javascript
 async function getData() {
-  return await Promise.resolve("I made it!");
+  return await Promise.resolve('I made it!');
 }
 
 const data = getData();
@@ -2293,7 +2282,6 @@ Isso teria registrado `"Consegui!"`
 </details>
 
 ---
-
 ###### 74. Qual o resultado?
 
 ```javascript
@@ -2301,7 +2289,7 @@ function addToList(item, list) {
   return list.push(item);
 }
 
-const result = addToList("apple", ["banana"]);
+const result = addToList('apple', ['banana']);
 console.log(result);
 ```
 
@@ -2361,7 +2349,7 @@ Como `shape` está congelado, e como o valor de `x` não é um objeto, não pode
 ###### 76.Qual o resultado?
 
 ```javascript
-const { name: myName } = { name: "Lydia" };
+const { name: myName } = { name: 'Lydia' };
 
 console.log(name);
 ```
@@ -2417,7 +2405,7 @@ A função `sum` sempre retorna o mesmo resultado. Se passarmos `1` e` 2`, ele _
 ```javascript
 const add = () => {
   const cache = {};
-  return (num) => {
+  return num => {
     if (num in cache) {
       return `From cache! ${cache[num]}`;
     } else {
@@ -2448,7 +2436,7 @@ A função `add` é uma função _memoized_ (memorizada). Com a memorização, p
 
 Se chamarmos a função `addFunction` novamente com o mesmo argumento, ela primeiro verifica se já obteve esse valor em seu cache. Se for o caso, o valor dos caches será retornado, o que economiza tempo de execução. Caso contrário, se não estiver armazenado em cache, ele calculará o valor e o armazenará posteriormente.
 
-Chamamos a função `addFunction` três vezes com o mesmo valor: na primeira chamada, o valor da função quando `num` é igual a `10` ainda não é armazenado em cache. A condição da instrução if `num in cache` retorna `false`, e o bloco else é executado: `Calculated! 20` é registrado e o valor do resultado é adicionado ao objeto de cache. `cache` agora se parece com`{10:20}`.
+Chamamos a função `addFunction` três vezes com o mesmo valor: na primeira chamada, o valor da função quando `num` é igual a `10` ainda não é armazenado em cache. A condição da instrução if `num in cache` retorna `false`, e o bloco else é executado: `Calculated! 20` é registrado e o valor do resultado é adicionado ao objeto de cache. `cache` agora se parece com` {10:20} `.
 
 Na segunda vez, o objeto `cache` contém o valor que é retornado para `10`. A condição da instrução if `num in cache` retorna `true`, e `'From cache! 20'` é registrado.
 
@@ -2462,7 +2450,7 @@ Na terceira vez, passamos `5 * 2` para a função que é avaliada como `10`. O o
 ###### 79. Qual o resultado?
 
 ```javascript
-const myLifeSummedUp = ["☕", "💻", "🍷", "🍫"];
+const myLifeSummedUp = ['☕', '💻', '🍷', '🍫'];
 
 for (let item in myLifeSummedUp) {
   console.log(item);
@@ -2487,7 +2475,7 @@ Com um loop _for-in_, podemos iterar sobre propriedades **enumeráveis​​**.
 
 `{0:" ☕ ", 1:" 💻 ", 2:" 🍷 ", 3:" 🍫 "}`
 
-Onde as chaves são as propriedades enumeráveis. ` 0`` 1 ` ` 2`` 3 ` são registrados.
+Onde as chaves são as propriedades enumeráveis. `0`` 1` `2`` 3` são registrados.
 
 Com um loop _for-of_, podemos iterar sobre **iteráveis**. Um array é um iterável. Quando iteramos sobre o array, a variável "item" é igual ao elemento sobre o qual está iterando no momento, `" ☕ "` `" 💻 "` `" 🍷 "` `" 🍫 "` são registrados.
 
@@ -2520,4 +2508,4 @@ O elemento será igual ao valor retornado. `1 + 2` retorna` 3`, `1 * 2` retorna`
 </p>
 </details>
 
----
+---
\ No newline at end of file
diff --git a/ro-RO/README.ro.md b/ro-RO/README.ro.md
deleted file mode 100644
index 5c36813e..00000000
--- a/ro-RO/README.ro.md
+++ /dev/null
@@ -1,371 +0,0 @@
-<div align="center">
-  <img height="60" src="https://img.icons8.com/color/344/javascript.png">
-  <h1>Întrebări JavaScript</h1>
-
----
-
-<span>Postez întrebări JavaScript cu opțiuni multiple pe [Instagram](https://www.instagram.com/theavocoder) **stories**, pe care le voi posta și aici! Ultima actualizare: <a href=#20200612><b>12 Iunie</b></a>
-
-De la nivel de bază la avansat: testează cât de bine cunoști JavaScript, reîmprospătează-ți puțin cunoștințele sau pregătește-te pentru interviul tău de codare! :muscle: :rocket: Actualizez acest depozit în mod regulat cu întrebări noi. Am adăugat răspunsurile în **secțiunile restrânse** de sub întrebări, pur și simplu dă clic pe ele pentru a le extinde. Este doar pentru distracție, mult noroc! :heart:</span>
-
-Nu ezita să mă contactezi! 😊 <br />
-<a href="https://www.instagram.com/theavocoder">Instagram</a> || <a href="https://www.twitter.com/lydiahallie">Twitter</a> || <a href="https://www.linkedin.com/in/lydia-hallie">LinkedIn</a> || <a href="https://www.lydiahallie.dev">Blog</a>
-
-</div>
-
-| Simte-te liber să le folosești într-un proiect! 😃 Aș aprecia _cu adevărat_ o referință la acest depozit, eu creez întrebările și explicațiile (da, sunt tristă lol) și comunitatea mă ajută foarte mult să îl mențin și să îl îmbunătățesc! 💪🏼 Mulțumesc și distracție plăcută! |
-| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-
----
-
-<details><summary><b> Vezi 20 de traduceri disponibile 🇸🇦🇪🇬🇧🇦🇩🇪🇪🇸🇫🇷🇮🇩🇯🇵🇰🇷🇳🇱🇧🇷🇷🇺🇹🇭🇹🇷🇺🇦🇻🇳🇨🇳🇹🇼🇽🇰</b></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)
-- [🇷🇺 Русский](./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)
-
-</p>
-</details>
-
----
-
-###### 1. Care este rezultatul?
-
-```javascript
-function sayHi() {
-  console.log(name);
-  console.log(age);
-  var name = "Lydia";
-  let age = 21;
-}
-
-sayHi();
-```
-
-- A: `Lydia` și `undefined`
-- B: `Lydia` și `ReferenceError`
-- C: `ReferenceError` și `21`
-- D: `undefined` și `ReferenceError`
-
-<details><summary><b>Răspuns</b></summary>
-<p>
-
-#### Răspuns: D
-
-În interiorul funcției, mai întâi declarăm variabila `name` cu cuvântul cheie `var`. Acest lucru înseamnă că variabila este hoisted (spațiul de memorie este configurat în faza de creare) cu valoarea implicită `undefined`, până când ajungem efectiv la linia în care definim variabila. Nu am definit încă variabila pe linia în care încercăm să înregistrăm variabila `name`, așa că aceasta păstrează încă valoarea `undefined`.
-
-Variabilele create cu cuvântul cheie `let` (și `const`) sunt hoisted, dar, spre deosebire de `var`, nu sunt <i>inițializate</i>. Acestea nu sunt accesibile înainte de linia în care le declarăm (initializăm). Aceasta se numește zona moartă temporală (temporal dead zone). Atunci când încercăm să accesăm variabilele înainte de a fi declarate, JavaScript aruncă o excepție de tip `ReferenceError`.
-
-</p>
-</details>
-
----
-
-###### 2. Care este rezultatul?
-
-```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` și `0 1 2`
-- B: `0 1 2` și `3 3 3`
-- C: `3 3 3` și `0 1 2`
-
-<details><summary><b>Răspuns</b></summary>
-<p>
-
-#### Răspuns: C
-
-Datorită cozii de evenimente din JavaScript, funcția de callback `setTimeout` este apelată _după_ ce bucla a fost executată. Deoarece variabila `i` din prima buclă a fost declarată folosind cuvântul cheie `var`, această valoare a fost globală. În timpul buclei, am incrementat valoarea lui `i` cu `1` de fiecare dată, folosind operatorul unary `++`. Până când funcția de callback `setTimeout` a fost invocată, `i` era egal cu `3` în primul exemplu.
-
-În cea de-a doua buclă, variabila `i` a fost declarată folosind cuvântul cheie `let`: variabilele declarate cu cuvântul cheie `let` (și `const`) sunt cu scop la nivel de bloc (un bloc este orice între `{ }`). În fiecare iterație, `i` va avea o valoare nouă, iar fiecare valoare este în cadrul buclei.
-
-</p>
-</details>
-
----
-
-###### 3. Care este rezultatul?
-
-```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` și `62.83185307179586`
-- B: `20` și `NaN`
-- C: `20` și `63`
-- D: `NaN` și `63`
-
-<details><summary><b>Răspuns</b></summary>
-<p>
-
-#### Răspuns: B
-
-Rețineți că valoarea lui `diameter` este o funcție obișnuită, în timp ce valoarea lui `perimeter` este o funcție arrow.
-
-Cu funcțiile arrow, cuvântul cheie `this` se referă la contextul său curent de încadrare, spre deosebire de funcțiile obișnuite! Acest lucru înseamnă că atunci când apelăm `perimeter`, acesta nu se referă la obiectul formei, ci la încadrarea sa curentă (de exemplu, fereastra).
-
-Nu există nicio valoare `radius` pe acel obiect, ceea ce returnează `NaN`.
-
-</p>
-</details>
-
----
-
-###### 4. Care este rezultatul?
-
-```javascript
-+true;
-!"Lydia";
-```
-
-- A: `1` și `false`
-- B: `false` și `NaN`
-- C: `false` și `false`
-
-<details><summary><b>Răspuns</b></summary>
-<p>
-
-#### Răspuns: A
-
-Operatorul unary plus încearcă să convertească un operand într-un număr. `true` este `1`, și `false` este `0`.
-
-Șirul de caractere `'Lydia'` este o valoare adevărată. Ceea ce întrebăm de fapt, este "este această valoare adevărată falsă?". Acest lucru returnează `false`.
-
-</p>
-</details>
-
----
-
-###### 5. Care este rezultatul?
-
-```javascript
-const bird = {
-  size: "small",
-};
-
-const mouse = {
-  name: "Mickey",
-  small: true,
-};
-```
-
-- A: `mouse.bird.size` nu este valid
-- B: `mouse[bird.size]` nu este valid
-- C: `mouse[bird["size"]]` nu este valid
-- D: Toate sunt valide
-
-<details><summary><b>Răspuns</b></summary>
-<p>
-
-#### Răspuns: A
-
-În JavaScript, toate cheile obiectelor sunt șiruri de caractere (cu excepția simbolurilor). Chiar dacă nu le _tipizăm_ ca șiruri de caractere, ele sunt întotdeauna convertite în șiruri de caractere în fundal.
-
-avaScript interpretează (sau dezambalează) instrucțiunile. Atunci când folosim notația cu paranteze pătrate, vede prima paranteză pătrată de deschidere `[` și continuă până când găsește paranteza pătrată de închidere `]`. Doar atunci va evalua instrucțiunea.
-
-`mouse[bird.size]`: Întâi evaluează `bird.size`, care este `"small"`. `mouse["small"]` returnează `true`
-
-Cu toate acestea, cu notația cu punct, acest lucru nu se întâmplă. `mouse` nu are o cheie numită `bird`, ceea ce înseamnă că `mouse.bird` este `undefined`. Apoi, cerem `size` folosind notația cu punct: `mouse.bird.size`. Deoarece `mouse.bird` este `undefined`, de fapt cerem `undefined.size`. Acest lucru nu este valid și va arunca o eroare similară cu `Cannot read property "size" of undefined` (Nu se poate citi proprietatea "size" a unei valori nedefinite).
-
-</p>
-</details>
-
----
-
-###### 6. Care este rezultatul?
-
-```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>Răspuns</b></summary>
-<p>
-
-#### Răspuns: A
-
-În JavaScript, toate obiectele interacționează prin _referință_ atunci când sunt setate ca egale între ele.
-
-Mai întâi, variabila `c` deține o valoare care face referire la un obiect. Ulterior, atribuim variabilei `d` aceeași referință pe care o are `c` la obiect.
-
-<img src="https://i.imgur.com/ko5k0fs.png" width="200">
-
-Când modifici un obiect, le modifici pe toate.
-
-</p>
-</details>
-
----
-
-###### 7. Care este rezultatul?
-
-```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>Răspuns</b></summary>
-<p>
-
-#### Răspuns: C
-
-`new Number()` este un constructor de funcții încorporat. Deși arată ca un număr, nu este într-adevăr un număr: are o mulțime de funcționalități suplimentare și este un obiect.
-
-Atunci când folosim operatorul `==` (operatorul de egalitate), acesta verifică doar dacă au aceeași _valuare_. Ambele au valoarea `3`, șa că returnează `true`.
-
-Cu toate acestea, atunci când folosim operatorul `===` (operatorul de egalitate strictă), atât valoarea, cât _și_ tipul trebuie să fie la fel. Nu sunt: `new Number()` nu este un număr, este un **object**. Ambele returnează `false.`
-
-</p>
-</details>
-
----
-
-###### 8. Care este rezultatul?
-
-```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>Răspuns</b></summary>
-<p>
-
-#### Răspuns: D
-
-Funcția `colorChange` este statică. Metodele statice sunt concepute să existe doar pe constructorul în care sunt create și nu pot fi transmise către niciun copil sau apelate pe instanțele clasei. Deoarece `freddie` este o instanță a clasei Chameleon, funcția nu poate fi apelată pe aceasta. Se aruncă o eroare de tip `TypeError`.
-
-</p>
-</details>
-
----
-
-###### 9. Care este rezultatul?
-
-```javascript
-let greeting;
-greetign = {}; // Typo!
-console.log(greetign);
-```
-
-- A: `{}`
-- B: `ReferenceError: greetign is not defined`
-- C: `undefined`
-
-<details><summary><b>Răspuns</b></summary>
-<p>
-
-#### Răspuns: A
-
-Se afișează obiectul, deoarece tocmai am creat un obiect gol pe obiectul global! Atunci când am greșit și am scris `greeting` în loc de `greetign`, interpretorul JavaScript a văzut efectiv acest lucru ca:
-
-1. `global.greetign = {}` în Node.js
-2. `window.greetign = {}`, `frames.greetign = {}` și `self.greetign` în browser-e.
-3. `self.greetign` în web workers.
-4. `globalThis.greetign` în toate mediile.
-
-Pentru a evita acest lucru, putem folosi `"use strict"`. Acest lucru se asigură că ai declarat o variabilă înainte de a-i atribui o valoare.
-
-</p>
-</details>
-
----
-
-###### 10. Ce se întâmplă când facem asta?
-
-```javascript
-function bark() {
-  console.log("Woof!");
-}
-
-bark.animal = "dog";
-```
-
-- A: Nimic, este absolut în regulă!
-- B: `SyntaxError`. Nu poți adăuga proprietăți la o funcție în acest fel.
-- C: `"Woof"` este înregistrat.
-- D: `ReferenceError`
-
-<details><summary><b>Răspuns</b></summary>
-<p>
-
-#### Răspuns: A
-
-Acest lucru este posibil în JavaScript, deoarece funcțiile sunt obiecte! (Totul, în afară de tipurile primitive, sunt obiecte)
-
-O funcție este un tip special de obiect. Codul pe care îl scrii tu însuți nu este funcția efectivă. Funcția este un obiect cu proprietăți. Această proprietate este invocabilă.
-
-</p>
-</details>
-
----
diff --git a/ru-RU/README.md b/ru-RU/README.md
index 35f9e86f..17a083ab 100644
--- a/ru-RU/README.md
+++ b/ru-RU/README.md
@@ -10,11 +10,10 @@
 
 Не стесняйтесь обращаться ко мне (Lydia Hallie)! 😊<br />
 <a href="https://www.instagram.com/theavocoder">Instagram</a> || <a href="https://www.twitter.com/lydiahallie">Twitter</a> || <a href="https://www.linkedin.com/in/lydia-hallie">LinkedIn</a> || <a href="https://www.lydiahallie.dev">Blog</a>
-
 </div>
 
 | Не стесняйтесь использовать эти примеры в проектах! 😃 Я (Lydia Hallie) была бы _действительно_ признателена за ссылку на этот репозиторий. Я добавляю вопросы и объяснения, и сообщество очень помогает мне поддерживать и улучшать все это! 💪🏼 Спасибо и приятного просмотра! |
-| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+|---|
 
 ---
 
@@ -34,7 +33,6 @@
 - [🇳🇱 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)
 - [🇬🇧 English](../README.md)
 - [🇽🇰 Shqip](../sq-KS/README_sq_KS.md)
 - [🇹🇭 ไทย](../th-TH/README-th_TH.md)
@@ -119,7 +117,7 @@ const shape = {
   diameter() {
     return this.radius * 2;
   },
-  perimeter: () => 2 * Math.PI * this.radius,
+  perimeter: () => 2 * Math.PI * this.radius
 };
 
 console.log(shape.diameter());
@@ -151,7 +149,7 @@ console.log(shape.perimeter());
 
 ```javascript
 +true;
-!"Lydia";
+!'Lydia';
 ```
 
 - A: `1` и `false`
@@ -176,12 +174,12 @@ console.log(shape.perimeter());
 
 ```javascript
 const bird = {
-  size: "small",
+  size: 'small'
 };
 
 const mouse = {
-  name: "Mickey",
-  small: true,
+  name: 'Mickey',
+  small: true
 };
 ```
 
@@ -211,11 +209,11 @@ JavaScript интерпретирует (или распаковывает) оп
 ###### 6. Что будет в консоли?
 
 ```javascript
-let c = { greeting: "Hey!" };
+let c = { greeting: 'Hey!' };
 let d;
 
 d = c;
-c.greeting = "Hello";
+c.greeting = 'Hello';
 console.log(d.greeting);
 ```
 
@@ -285,13 +283,13 @@ class Chameleon {
     return this.newColor;
   }
 
-  constructor({ newColor = "green" } = {}) {
+  constructor({ newColor = 'green' } = {}) {
     this.newColor = newColor;
   }
 }
 
-const freddie = new Chameleon({ newColor: "purple" });
-freddie.colorChange("orange");
+const freddie = new Chameleon({ newColor: 'purple' });
+freddie.colorChange('orange');
 ```
 
 - A: `orange`
@@ -346,10 +344,10 @@ console.log(greetign);
 
 ```javascript
 function bark() {
-  console.log("Woof!");
+  console.log('Woof!');
 }
 
-bark.animal = "dog";
+bark.animal = 'dog';
 ```
 
 - A: Ничего, всё в порядке!
@@ -379,10 +377,10 @@ 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}`;
-};
+}
 
 console.log(member.getFullName());
 ```
@@ -404,7 +402,7 @@ console.log(member.getFullName());
 ```js
 Person.prototype.getFullName = function () {
   return `${this.firstName} ${this.lastName}`;
-};
+}
 ```
 
 </p>
@@ -420,8 +418,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);
@@ -491,7 +489,7 @@ function sum(a, b) {
   return a + b;
 }
 
-sum(1, "2");
+sum(1, '2');
 ```
 
 - A: `NaN`
@@ -558,7 +556,7 @@ function getPersonInfo(one, two, three) {
   console.log(three);
 }
 
-const person = "Lydia";
+const person = 'Lydia';
 const age = 21;
 
 getPersonInfo`${person} is ${age} years old`;
@@ -585,9 +583,9 @@ getPersonInfo`${person} is ${age} years old`;
 ```javascript
 function checkAge(data) {
   if (data === { age: 18 }) {
-    console.log("Ты взрослый!");
+    console.log('Ты взрослый!');
   } else if (data == { age: 18 }) {
-    console.log("Ты все еще взрослый.");
+    console.log('Ты все еще взрослый.');
   } else {
     console.log(`Хмм.. Кажется, у тебя нет возраста.`);
   }
@@ -647,7 +645,7 @@ getAge(21);
 
 ```javascript
 function getAge() {
-  "use strict";
+  'use strict';
   age = 21;
   console.log(age);
 }
@@ -675,7 +673,7 @@ getAge();
 ###### 21. Чему будет равно `sum`?
 
 ```javascript
-const sum = eval("10*10+5");
+const sum = eval('10*10+5');
 ```
 
 - A: `105`
@@ -698,7 +696,7 @@ const sum = eval("10*10+5");
 ###### 22. Как долго будет доступен cool_secret?
 
 ```javascript
-sessionStorage.setItem("cool_secret", 123);
+sessionStorage.setItem('cool_secret', 123);
 ```
 
 - A: Всегда, данные не потеряются.
@@ -751,12 +749,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);
 ```
 
@@ -782,7 +780,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);
 ```
 
@@ -851,12 +849,12 @@ 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());
+console.log(name.giveLydiaPizza())
 ```
 
 - A: `"Just give Lydia pizza already!"`
@@ -880,8 +878,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;
@@ -913,9 +911,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();
@@ -968,7 +966,9 @@ WebAPI не может добавлять содержимое в стек ко
 ```html
 <div onclick="console.log('first div')">
   <div onclick="console.log('second div')">
-    <button onclick="console.log('button')">Кликни!</button>
+    <button onclick="console.log('button')">
+      Кликни!
+    </button>
   </div>
 </div>
 ```
@@ -994,7 +994,9 @@ WebAPI не может добавлять содержимое в стек ко
 
 ```html
 <div onclick="console.log('div')">
-  <p onclick="console.log('p')">Кликни меня!</p>
+  <p onclick="console.log('p')">
+    Кликни меня!
+  </p>
 </div>
 ```
 
@@ -1018,7 +1020,7 @@ WebAPI не может добавлять содержимое в стек ко
 ###### 33. Что будет в консоли?
 
 ```javascript
-const person = { name: "Lydia" };
+const person = { name: 'Lydia' };
 
 function sayHi(age) {
   console.log(`${this.name} is ${age}`);
@@ -1231,10 +1233,7 @@ console.log(numbers);
 ###### 40. Каким будет результат?
 
 ```javascript
-[
-  [0, 1],
-  [2, 3],
-].reduce(
+[[0, 1], [2, 3]].reduce(
   (acc, cur) => {
     return acc.concat(cur);
   },
@@ -1265,7 +1264,7 @@ console.log(numbers);
 
 ```javascript
 !!null;
-!!"";
+!!'';
 !!1;
 ```
 
@@ -1293,7 +1292,7 @@ console.log(numbers);
 ###### 42. Что возвращает метод `setInterval` в браузере?
 
 ```javascript
-setInterval(() => console.log("Hi"), 1000);
+setInterval(() => console.log('Hi'), 1000);
 ```
 
 - A: уникальный id
@@ -1316,7 +1315,7 @@ setInterval(() => console.log("Hi"), 1000);
 ###### 43. Каким будет результат?
 
 ```javascript
-[..."Lydia"];
+[...'Lydia'];
 ```
 
 - A: `["L", "y", "d", "i", "a"]`
@@ -1375,14 +1374,14 @@ console.log(gen.next().value);
 
 ```javascript
 const firstPromise = new Promise((res, rej) => {
-  setTimeout(res, 500, "один");
+  setTimeout(res, 500, 'один');
 });
 
 const secondPromise = new Promise((res, rej) => {
-  setTimeout(res, 100, "два");
+  setTimeout(res, 100, 'два');
 });
 
-Promise.race([firstPromise, secondPromise]).then((res) => console.log(res));
+Promise.race([firstPromise, secondPromise]).then(res => console.log(res));
 ```
 
 - A: `"один"`
@@ -1405,7 +1404,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;
 
@@ -1445,8 +1444,8 @@ console.log(members);
 
 ```javascript
 const person = {
-  name: "Lydia",
-  age: 21,
+  name: 'Lydia',
+  age: 21
 };
 
 for (const item in person) {
@@ -1474,7 +1473,7 @@ for (const item in person) {
 ###### 48. Каким будет результат?
 
 ```javascript
-console.log(3 + 4 + "5");
+console.log(3 + 4 + '5');
 ```
 
 - A: `"345"`
@@ -1526,8 +1525,8 @@ const num = parseInt("7*6", 10);
 ###### 50. Каким будет результат?
 
 ```javascript
-[1, 2, 3].map((num) => {
-  if (typeof num === "number") return;
+[1, 2, 3].map(num => {
+  if (typeof num === 'number') return;
   return num * 2;
 });
 ```
@@ -1555,12 +1554,12 @@ const num = parseInt("7*6", 10);
 
 ```javascript
 function getInfo(member, year) {
-  member.name = "Lydia";
+  member.name = 'Lydia';
   year = 1998;
 }
 
-const person = { name: "Sarah" };
-const birthYear = "1997";
+const person = { name: 'Sarah' };
+const birthYear = '1997';
 
 getInfo(person, birthYear);
 
@@ -1579,7 +1578,7 @@ console.log(person, birthYear);
 
 Аргументы передаются _значением_, если их значение не является объектом, то они передаются _ссылкой_. `birthYear` передается по значению, поскольку это строка, а не объект. Когда мы передаем аргументы по значению, создается _копия_ этого значения (см. вопрос 46).
 
-Переменная `birthYear` имеет ссылку на значение `"1997"`. Аргумент `year` также имеет ссылку на значение`"1997"`, но это не то же самое значение, на которое имеется ссылка для `birthYear`. Когда мы обновляем значение `year`, устанавливая `year` равным `"1998"`, мы обновляем только значение `year`. `birthYear` по-прежнему равно `"1997"`.
+Переменная `birthYear` имеет ссылку на значение `"1997"`. Аргумент `year` также имеет ссылку на значение` "1997" `, но это не то же самое значение, на которое имеется ссылка для `birthYear`. Когда мы обновляем значение `year`, устанавливая `year` равным `"1998"`, мы обновляем только значение `year`. `birthYear` по-прежнему равно `"1997"`.
 
 Значение `person` является объектом. Аргумент `member` имеет (скопированную) ссылку на _тот же_ объект. Когда мы изменяем свойство объекта, на который `member` ссылается, значение `person` также будет изменено, поскольку они оба имеют ссылку на один и тот же объект. Свойство `name` объекта `person` теперь равно значению `"Lydia"`.
 
@@ -1592,15 +1591,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);
   }
 }
 
@@ -1630,8 +1629,8 @@ sayHi();
 
 ```javascript
 function Car() {
-  this.make = "Lamborghini";
-  return { make: "Maserati" };
+  this.make = 'Lamborghini';
+  return { make: 'Maserati' };
 }
 
 const myCar = new Car();
@@ -1703,11 +1702,11 @@ class Dog {
   }
 }
 
-Dog.prototype.bark = function () {
+Dog.prototype.bark = function() {
   console.log(`Woof I am ${this.name}`);
 };
 
-const pet = new Dog("Mara");
+const pet = new Dog('Mara');
 
 pet.bark();
 
@@ -1772,7 +1771,7 @@ export default counter;
 
 ```javascript
 // index.js
-import myCounter from "./counter";
+import myCounter from './counter';
 
 myCounter += 1;
 
@@ -1801,7 +1800,7 @@ console.log(myCounter);
 ###### 58. Какой будет вывод?
 
 ```javascript
-const name = "Lydia";
+const name = 'Lydia';
 age = 21;
 
 console.log(delete name);
@@ -1872,7 +1871,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);
@@ -1898,9 +1897,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));
@@ -1929,12 +1928,12 @@ console.log(Object.keys(person));
 
 ```javascript
 const settings = {
-  username: "lydiahallie",
+  username: 'lydiahallie',
   level: 19,
-  health: 90,
+  health: 90
 };
 
-const data = JSON.stringify(settings, ["level", "health"]);
+const data = JSON.stringify(settings, ['level', 'health']);
 console.log(data);
 ```
 
@@ -1965,7 +1964,7 @@ console.log(data);
 let num = 10;
 
 const increaseNumber = () => num++;
-const increasePassedNumber = (number) => number++;
+const increasePassedNumber = number => number++;
 
 const num1 = increaseNumber();
 const num2 = increasePassedNumber(num1);
@@ -2122,12 +2121,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;
 ```
 
@@ -2153,9 +2152,9 @@ export const sum = (a, b) => a + b;
 ###### 68. Какой будет вывод?
 
 ```javascript
-console.log(Number(2) === Number(2));
-console.log(Boolean(false) === Boolean(false));
-console.log(Symbol("foo") === Symbol("foo"));
+console.log(Number(2) === Number(2))
+console.log(Boolean(false) === Boolean(false))
+console.log(Symbol('foo') === Symbol('foo'))
 ```
 
 - A: `true`, `true`, `false`
@@ -2178,9 +2177,9 @@ console.log(Symbol("foo") === Symbol("foo"));
 ###### 69. Какой будет вывод?
 
 ```javascript
-const name = "Lydia Hallie";
-console.log(name.padStart(13));
-console.log(name.padStart(2));
+const name = 'Lydia Hallie'
+console.log(name.padStart(13))
+console.log(name.padStart(2))
 ```
 
 - A: `"Lydia Hallie"`, `"Lydia Hallie"`
@@ -2301,7 +2300,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();
@@ -2338,7 +2337,7 @@ function addToList(item, list) {
   return list.push(item);
 }
 
-const result = addToList("apple", ["banana"]);
+const result = addToList('apple', ['banana']);
 console.log(result);
 ```
 
@@ -2398,7 +2397,7 @@ console.log(shape);
 ###### 76. Какой будет вывод?
 
 ```javascript
-const { firstName: myName } = { firstName: "Lydia" };
+const { firstName: myName } = { firstName: 'Lydia' };
 
 console.log(firstName);
 ```
@@ -2416,7 +2415,7 @@ console.log(firstName);
 Используя [деструктурирующее присваивание](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment), мы можем распаковывать значения из массивов или свойства из объектов в отдельные переменные:
 
 ```javascript
-const { firstName } = { firstName: "Lydia" };
+const { firstName } = { firstName: 'Lydia' };
 // Версия ES5:
 // var firstName = { firstName: 'Lydia' }.firstName;
 
@@ -2426,7 +2425,7 @@ console.log(firstName); // "Lydia"
 Также свойство можно распаковать из объекта и присвоить переменной с именем, отличным от имени свойства объекта:
 
 ```javascript
-const { firstName: myName } = { firstName: "Lydia" };
+const { firstName: myName } = { firstName: 'Lydia' };
 // Версия ES5:
 // var myName = { firstName: 'Lydia' }.firstName;
 
@@ -2439,11 +2438,12 @@ console.log(firstName); // Тут будет ошибка Uncaught ReferenceErro
 **Примечание.** Помните о свойствах глобальной области видимости:
 
 ```javascript
-const { name: myName } = { name: "Lydia" };
+const { name: myName } = { name: 'Lydia' };
 
 console.log(myName); // "lydia"
 console.log(name); // "" ----- Браузер, например, Chrome
 console.log(name); // ReferenceError: name is not defined  ----- NodeJS
+
 ```
 
 Всякий раз, когда Javascript не может найти переменную в _текущей области видимости_, то поднимается вверх по [цепочке областей видимости](https://developer.mozilla.org/ru/docs/Web/JavaScript/Closures#лексическая_область_видимости) и ищет ее на каждом уровне, и если достигает области верхнего уровня, также известной как **Глобальная область**, и все еще не находит нужной ссылки, то выдает `ReferenceError`.
@@ -2487,7 +2487,7 @@ function sum(a, b) {
 ```javascript
 const add = () => {
   const cache = {};
-  return (num) => {
+  return num => {
     if (num in cache) {
       return `From cache! ${cache[num]}`;
     } else {
@@ -2532,21 +2532,21 @@ console.log(addFunction(5 * 2));
 ###### 79. Какой будет вывод?
 
 ```javascript
-const myLifeSummedUp = ["☕", "💻", "🍷", "🍫"];
+const myLifeSummedUp = ['☕', '💻', '🍷', '🍫']
 
 for (let item in myLifeSummedUp) {
-  console.log(item);
+  console.log(item)
 }
 
 for (let item of myLifeSummedUp) {
-  console.log(item);
+  console.log(item)
 }
 ```
 
 - A: `0` `1` `2` `3` и `"☕"` ` "💻"` `"🍷"` `"🍫"`
 - B: `"☕"` ` "💻"` `"🍷"` `"🍫"` и `"☕"` ` "💻"` `"🍷"` `"🍫"`
 - C: `"☕"` ` "💻"` `"🍷"` `"🍫"` и `0` `1` `2` `3`
-- D: `0` `1` `2` `3` и `{0: "☕", 1: "💻", 2: "🍷", 3: "🍫"}`
+- D:  `0` `1` `2` `3` и `{0: "☕", 1: "💻", 2: "🍷", 3: "🍫"}`
 
 <details><summary><b>Ответ</b></summary>
 <p>
@@ -2569,14 +2569,14 @@ for (let item of myLifeSummedUp) {
 ###### 80. Какой будет вывод?
 
 ```javascript
-const list = [1 + 2, 1 * 2, 1 / 2];
-console.log(list);
+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]`
+- D:  `[1, 1, 1]`
 
 <details><summary><b>Ответ</b></summary>
 <p>
@@ -2596,16 +2596,16 @@ console.log(list);
 
 ```javascript
 function sayHi(name) {
-  return `Hi there, ${name}`;
+  return `Hi there, ${name}`
 }
 
-console.log(sayHi());
+console.log(sayHi())
 ```
 
 - A: `Hi there, `
 - B: `Hi there, undefined`
 - C: `Hi there, null`
-- D: `ReferenceError`
+- D:  `ReferenceError`
 
 <details><summary><b>Ответ</b></summary>
 <p>
@@ -2628,21 +2628,21 @@ console.log(sayHi());
 ###### 82. Какой будет вывод?
 
 ```javascript
-var status = "😎";
+var status = '😎'
 
 setTimeout(() => {
-  const status = "😍";
+  const status = '😍'
 
   const data = {
-    status: "🥑",
+    status: '🥑',
     getStatus() {
-      return this.status;
-    },
-  };
+      return this.status
+    }
+  }
 
-  console.log(data.getStatus());
-  console.log(data.getStatus.call(this));
-}, 0);
+  console.log(data.getStatus())
+  console.log(data.getStatus.call(this))
+}, 0)
 ```
 
 - A: `"🥑"` и `"😍"`
@@ -2668,14 +2668,14 @@ setTimeout(() => {
 
 ```javascript
 const person = {
-  name: "Lydia",
-  age: 21,
-};
+  name: 'Lydia',
+  age: 21
+}
 
-let city = person.city;
-city = "Amsterdam";
+let city = person.city
+city = 'Amsterdam'
 
-console.log(person);
+console.log(person)
 ```
 
 - A: `{ name: "Lydia", age: 21 }`
@@ -2706,15 +2706,15 @@ console.log(person);
 ```javascript
 function checkAge(age) {
   if (age < 18) {
-    const message = "Sorry, you're too young.";
+    const message = "Sorry, you're too young."
   } else {
-    const message = "Yay! You're old enough!";
+    const message = "Yay! You're old enough!"
   }
 
-  return message;
+  return message
 }
 
-console.log(checkAge(21));
+console.log(checkAge(21))
 ```
 
 - A: `"Sorry, you're too young."`
@@ -2737,9 +2737,9 @@ console.log(checkAge(21));
 ###### 85. Какая информация будетвыведена в лог?
 
 ```javascript
-fetch("https://www.website.com/api/user/1")
-  .then((res) => res.json())
-  .then((res) => console.log(res));
+fetch('https://www.website.com/api/user/1')
+  .then(res => res.json())
+  .then(res => console.log(res))
 ```
 
 - A: Результат метода `fetch`.
@@ -2793,7 +2793,7 @@ function getName(name) {
 ###### 87. Какой будет вывод?
 
 ```javascript
-console.log("I want pizza"[0]);
+console.log('I want pizza'[0])
 ```
 
 - A: `"""`
@@ -2819,10 +2819,10 @@ console.log("I want pizza"[0]);
 
 ```javascript
 function sum(num1, num2 = num1) {
-  console.log(num1 + num2);
+  console.log(num1 + num2)
 }
 
-sum(10);
+sum(10)
 ```
 
 - A: `NaN`
@@ -2848,13 +2848,13 @@ 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);
+console.log(data)
 ```
 
 - A: `{ default: function default(), name: "Lydia" }`
@@ -2881,12 +2881,12 @@ console.log(data);
 ```javascript
 class Person {
   constructor(name) {
-    this.name = name;
+    this.name = name
   }
 }
 
-const member = new Person("John");
-console.log(typeof member);
+const member = new Person('John')
+console.log(typeof member)
 ```
 
 - A: `"class"`
@@ -2903,7 +2903,7 @@ console.log(typeof member);
 
 ```javascript
 function Person() {
-  this.name = name;
+  this.name = name
 }
 ```
 
@@ -2917,9 +2917,9 @@ function Person() {
 ###### 91. Какой будет вывод?
 
 ```javascript
-let newList = [1, 2, 3].push(4);
+let newList = [1, 2, 3].push(4)
 
-console.log(newList.push(5));
+console.log(newList.push(5))
 ```
 
 - A: `[1, 2, 3, 4, 5]`
@@ -2945,14 +2945,14 @@ 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.";
+  "Here's chocolate... now go hit the gym already."
 
-console.log(giveLydiaPizza.prototype);
-console.log(giveLydiaChocolate.prototype);
+console.log(giveLydiaPizza.prototype)
+console.log(giveLydiaChocolate.prototype)
 ```
 
 - A: `{ constructor: ...}` `{ constructor: ...}`
@@ -2976,12 +2976,12 @@ console.log(giveLydiaChocolate.prototype);
 
 ```javascript
 const person = {
-  name: "Lydia",
-  age: 21,
-};
+  name: 'Lydia',
+  age: 21
+}
 
 for (const [x, y] of Object.entries(person)) {
-  console.log(x, y);
+  console.log(x, y)
 }
 ```
 
@@ -3033,10 +3033,10 @@ getItems(["banana", "apple"], "pear", "orange")
 
 ```javascript
 function getItems(fruitList, favoriteFruit, ...args) {
-  return [...fruitList, ...args, favoriteFruit];
+  return [...fruitList, ...args, favoriteFruit]
 }
 
-getItems(["banana", "apple"], "pear", "orange");
+getItems(["banana", "apple"], "pear", "orange")
 ```
 
 Приведенный выше пример работает. Это возвращает массив `[ 'banana', 'apple', 'orange', 'pear' ]`
@@ -3050,14 +3050,14 @@ getItems(["banana", "apple"], "pear", "orange");
 
 ```javascript
 function nums(a, b) {
-  if (a > b) console.log("a is bigger");
-  else console.log("b is bigger");
-  return;
-  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));
+console.log(nums(4, 2))
+console.log(nums(1, 2))
 ```
 
 - A: `a is bigger`, `6` and `b is bigger`, `3`
@@ -3075,8 +3075,8 @@ console.log(nums(1, 2));
 Здесь мы написали инструкцию `return` и другое значение `a + b` в новой строке. Однако, поскольку это новая линия, движок не знает, что это на самом деле значение, которое мы хотели бы вернуть. Вместо этого он автоматически добавляет точку с запятой после `return`. Вы можете увидеть это как:
 
 ```javascript
-return;
-a + b;
+  return;
+  a + b
 ```
 
 Это означает, что `a + b` никогда не достигается, так как функция перестает выполняться после ключевого слова `return`. Если значение не возвращается, как здесь, функция возвращает значение `undefined`. Обратите внимание, что после операторов `if / else` автоматической вставки нет!
@@ -3091,18 +3091,18 @@ a + b;
 ```javascript
 class Person {
   constructor() {
-    this.name = "Lydia";
+    this.name = 'Lydia'
   }
 }
 
 Person = class AnotherPerson {
   constructor() {
-    this.name = "Sarah";
+    this.name = 'Sarah'
   }
-};
+}
 
-const member = new Person();
-console.log(member.name);
+const member = new Person()
+console.log(member.name)
 ```
 
 - A: `"Lydia"`
@@ -3126,11 +3126,11 @@ console.log(member.name);
 
 ```javascript
 const info = {
-  [Symbol("a")]: "b",
-};
+  [Symbol('a')]: 'b'
+}
 
-console.log(info);
-console.log(Object.keys(info));
+console.log(info)
+console.log(Object.keys(info))
 ```
 
 - A: `{Symbol('a'): 'b'}` and `["{Symbol('a')"]`
@@ -3185,7 +3185,7 @@ console.log(getUser(user))
 
 Следующая функция вернула бы объект:
 
-`const getUser = user => ({ name: user.name, age: user.age })`
+```const getUser = user => ({ name: user.name, age: user.age })```
 
 </p>
 </details>
@@ -3195,9 +3195,9 @@ console.log(getUser(user))
 ###### 99. Какой будет вывод?
 
 ```javascript
-const name = "Lydia";
+const name = 'Lydia'
 
-console.log(name());
+console.log(name())
 ```
 
 - A: `SyntaxError`
@@ -3227,8 +3227,8 @@ ReferenceErrors генерируется, когда JavaScript не может
 ```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`
@@ -3253,11 +3253,11 @@ You should${"" && `n't`} see a therapist after so much JavaScript lol`;
 ###### 101. Какое значение будет на выходе?
 
 ```javascript
-const one = false || {} || null;
-const two = null || false || "";
-const three = [] || 0 || true;
+const one = (false || {} || null)
+const two = (null || false || '')
+const three = ([] || 0 || true)
 
-console.log(one, two, three);
+console.log(one, two, three)
 ```
 
 - A: `false` `null` `[]`
@@ -3286,20 +3286,20 @@ 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");
+  myPromise().then(res => console.log(res))
+  console.log('second')
 }
 
 async function secondFunction() {
-  console.log(await myPromise());
-  console.log("second");
+  console.log(await myPromise())
+  console.log('second')
 }
 
-firstFunction();
-secondFunction();
+firstFunction()
+secondFunction()
 ```
 
 - A: `I have resolved!`, `second` and `I have resolved!`, `second`
@@ -3330,14 +3330,14 @@ secondFunction();
 ###### 103. Какое значение будет на выходе?
 
 ```javascript
-const set = new Set();
+const set = new Set()
 
-set.add(1);
-set.add("Lydia");
-set.add({ name: "Lydia" });
+set.add(1)
+set.add('Lydia')
+set.add({ name: 'Lydia' })
 
 for (let item of set) {
-  console.log(item + 2);
+  console.log(item + 2)
 }
 ```
 
@@ -3367,7 +3367,7 @@ for (let item of set) {
 ###### 104. Чему равно значение?
 
 ```javascript
-Promise.resolve(5);
+Promise.resolve(5)
 ```
 
 - A: `5`
@@ -3394,15 +3394,15 @@ 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);
+compareMembers(person)
 ```
 
 - A: `Not the same!`
@@ -3437,11 +3437,11 @@ const colorConfig = {
   green: true,
   black: true,
   yellow: false,
-};
+}
 
-const colors = ["pink", "red", "blue"];
+const colors = ['pink', 'red', 'blue']
 
-console.log(colorConfig.colors[1]);
+console.log(colorConfig.colors[1])
 ```
 
 - A: `true`
@@ -3468,7 +3468,7 @@ JavaScript интерпретирует (или распаковывает) оп
 ###### 107. Чему равно значение?
 
 ```javascript
-console.log("❤️" === "❤️");
+console.log('❤️' === '❤️')
 ```
 
 - A: `true`
@@ -3489,19 +3489,19 @@ 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`
 - B: `map` `reduce` `slice` `splice`
-- C: `map` `slice` `splice`
+- C: `map` `slice` `splice` 
 - D: `splice`
 
 <details><summary><b>Ответ</b></summary>
@@ -3521,17 +3521,17 @@ emojis.splice(1, 2, "✨");
 ###### 109. Какое значение будет на выходе?
 
 ```javascript
-const food = ["🍕", "🍫", "🥑", "🍔"];
-const info = { favoriteFood: food[0] };
+const food = ['🍕', '🍫', '🥑', '🍔']
+const info = { favoriteFood: food[0] }
 
-info.favoriteFood = "🍝";
+info.favoriteFood = '🍝'
 
-console.log(food);
+console.log(food)
 ```
 
 - A: `['🍕', '🍫', '🥑', '🍔']`
 - B: `['🍝', '🍫', '🥑', '🍔']`
-- C: `['🍝', '🍕', '🍫', '🥑', '🍔']`
+- C: `['🍝', '🍕', '🍫', '🥑', '🍔']` 
 - D: `ReferenceError`
 
 <details><summary><b>Ответ</b></summary>
@@ -3553,7 +3553,7 @@ console.log(food);
 ###### 110. Что делает этот метод?
 
 ```javascript
-JSON.parse();
+JSON.parse()
 ```
 
 - A: Разбирает JSON в значение JavaScript
@@ -3570,16 +3570,16 @@ JSON.parse();
 
 ```javascript
 // Преобразование числа в допустимый JSON, затем преобразование строки JSON в значение JavaScript:
-const jsonNumber = JSON.stringify(4); // '4'
-JSON.parse(jsonNumber); // 4
+const jsonNumber = JSON.stringify(4) // '4'
+JSON.parse(jsonNumber) // 4
 
 // Преобразование значения массива в допустимый JSON, затем разбор строки JSON в значение JavaScript:
-const jsonArray = JSON.stringify([1, 2, 3]); // '[1, 2, 3]'
-JSON.parse(jsonArray); // [1, 2, 3]
+const jsonArray = JSON.stringify([1, 2, 3]) // '[1, 2, 3]'
+JSON.parse(jsonArray) // [1, 2, 3]
 
 // Преобразование объекта в допустимый JSON, затем преобразование строки JSON в значение JavaScript:
-const jsonArray = JSON.stringify({ name: "Lydia" }); // '{"name":"Lydia"}'
-JSON.parse(jsonArray); // { name: 'Lydia' }
+const jsonArray = JSON.stringify({ name: 'Lydia' }) // '{"name":"Lydia"}'
+JSON.parse(jsonArray) // { name: 'Lydia' }
 ```
 
 </p>
@@ -3587,17 +3587,17 @@ JSON.parse(jsonArray); // { name: 'Lydia' }
 
 ---
 
-###### 111. Какое значение будет на выходе?
+###### 111. Какое значение будет на выходе? 
 
 ```javascript
-let name = "Lydia";
+let name = 'Lydia'
 
 function getName() {
-  console.log(name);
-  let name = "Sarah";
+  console.log(name)
+  let name = 'Sarah'
 }
 
-getName();
+getName()
 ```
 
 - A: Lydia
@@ -3617,13 +3617,13 @@ getName();
 Если бы мы не объявили переменную `name` в функции `getName`, движок javascript посмотрел бы вниз по _цепочки области действия_. Внешняя область имеет переменную с именем `name` со значением `Lydia`. В этом случае он бы записал `Lydia`.
 
 ```javascript
-let name = "Lydia";
+let name = 'Lydia'
 
 function getName() {
-  console.log(name);
+  console.log(name)
 }
 
-getName(); // Lydia
+getName() // Lydia
 ```
 
 </p>
@@ -3635,18 +3635,18 @@ 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();
-const two = generatorTwo();
+const one = generatorOne()
+const two = generatorTwo()
 
-console.log(one.next().value);
-console.log(two.next().value);
+console.log(one.next().value)
+console.log(two.next().value)
 ```
 
 - A: `a` and `a`
@@ -3664,17 +3664,17 @@ console.log(two.next().value);
 В `generatorOne` мы получаем весь массив `['a', 'b', 'c']`, используя ключевое слово `yield`. Значение свойства `value` для объекта, возвращаемого методом `next` для `one` (`one.next().value`), равно всему массиву `['a', 'b', 'c']`.
 
 ```javascript
-console.log(one.next().value); // ['a', 'b', 'c']
-console.log(one.next().value); // undefined
+console.log(one.next().value) // ['a', 'b', 'c']
+console.log(one.next().value) // undefined
 ```
 
 В файле `generatorTwo` мы используем ключевое слово `yield*`. Это означает, что первое полученное значение `two` равно первому полученному значению в итераторе. Итератор - это массив `['a', 'b', 'c']`. Первым полученным значением является `a`, поэтому в первый раз, когда мы вызываем `two.next().value`, возвращается `a`.
 
 ```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
+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>
@@ -3685,7 +3685,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`
@@ -3710,11 +3710,11 @@ console.log(`${((x) => x)("I love")} to program`);
 ```javascript
 let config = {
   alert: setInterval(() => {
-    console.log("Alert!");
-  }, 1000),
-};
+    console.log('Alert!')
+  }, 1000)
+}
 
-config = null;
+config = null
 ```
 
 - A: обратный вызов `setInterval` не будет вызван
@@ -3741,17 +3741,17 @@ config = null;
 ###### 115. Какие методы вернут значение `'Hello world!'`?
 
 ```javascript
-const myMap = new Map();
-const myFunc = () => "greeting";
+const myMap = new Map()
+const myFunc = () => 'greeting'
 
-myMap.set(myFunc, "Hello world!");
+myMap.set(myFunc, 'Hello world!')
 
 //1
-myMap.get("greeting");
+myMap.get('greeting')
 //2
-myMap.get(myFunc);
+myMap.get(myFunc)
 //3
-myMap.get(() => "greeting");
+myMap.get(() => 'greeting')
 ```
 
 - A: 1
@@ -3778,20 +3778,20 @@ myMap.get(() => "greeting");
 
 ```javascript
 const person = {
-  name: "Lydia",
-  age: 21,
-};
+  name: 'Lydia',
+  age: 21
+}
 
-const changeAge = (x = { ...person }) => (x.age += 1);
+const changeAge = (x = { ...person }) => x.age += 1
 const changeAgeAndName = (x = { ...person }) => {
-  x.age += 1;
-  x.name = "Sarah";
-};
+  x.age += 1
+  x.name = 'Sarah'
+}
 
-changeAge(person);
-changeAgeAndName();
+changeAge(person)
+changeAgeAndName()
 
-console.log(person);
+console.log(person)
 ```
 
 - A: `{name: "Sarah", age: 22}`
@@ -3819,7 +3819,7 @@ console.log(person);
 
 ```javascript
 function sumValues(x, y, z) {
-  return x + y + z;
+	return x + y + z;
 }
 ```
 
@@ -3870,15 +3870,15 @@ console.log(list[(num += 1)]);
 
 ```javascript
 const person = {
-  firstName: "Lydia",
-  lastName: "Hallie",
-  pet: {
-    name: "Mara",
-    breed: "Dutch Tulip Hound",
-  },
-  getFullName() {
-    return `${this.firstName} ${this.lastName}`;
-  },
+	firstName: 'Lydia',
+	lastName: 'Hallie',
+	pet: {
+		name: 'Mara',
+		breed: 'Dutch Tulip Hound'
+	},
+	getFullName() {
+		return `${this.firstName} ${this.lastName}`;
+	}
 };
 
 console.log(person.pet?.name);
@@ -3912,12 +3912,12 @@ 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!`);
+	console.log(`We don't have to buy bananas!`);
 }
 ```
 
@@ -3931,7 +3931,7 @@ if (groceries.indexOf("banana")) {
 
 #### Ответ: B
 
-Мы передали условие `groceries.indexOf("banana")` в оператор `if`. `groceries.indexOf("banana")` возвращает `0`, что является ложным значением. Поскольку условие в операторе `if` ложно, выполняется код в блоке `else`, и в лог выводится `We don't have to buy bananas!`.
+Мы передали условие `groceries.indexOf("banana")` в оператор `if`. `groceries.indexOf("banana")` возвращает `0`, что является ложным значением. Поскольку условие в операторе `if` ложно, выполняется код в блоке `else`, и в лог выводится ``We don't have to buy bananas!``.
 
 </p>
 </details>
@@ -3942,10 +3942,10 @@ if (groceries.indexOf("banana")) {
 
 ```javascript
 const config = {
-  languages: [],
-  set language(lang) {
-    return this.languages.push(lang);
-  },
+	languages: [],
+	set language(lang) {
+		return this.languages.push(lang);
+	}
 };
 
 console.log(config.language);
@@ -3971,10 +3971,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`
@@ -3999,9 +3999,9 @@ console.log(!typeof name === "string");
 ###### 123. Что будет на выходе?
 
 ```javascript
-const add = (x) => (y) => (z) => {
-  console.log(x, y, z);
-  return x + y + z;
+const add = x => y => z => {
+	console.log(x, y, z);
+	return x + y + z;
 };
 
 add(4)(5)(6);
@@ -4028,16 +4028,16 @@ add(4)(5)(6);
 
 ```javascript
 async function* range(start, end) {
-  for (let i = start; i <= end; i++) {
-    yield Promise.resolve(i);
-  }
+	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);
-  }
+	const gen = range(1, 3);
+	for await (const item of gen) {
+		console.log(item);
+	}
 })();
 ```
 
@@ -4062,7 +4062,7 @@ async function* range(start, end) {
 
 ```javascript
 const myFunc = ({ x, y, z }) => {
-  console.log(x, y, z);
+	console.log(x, y, z);
 };
 
 myFunc(1, 2, 3);
@@ -4186,8 +4186,8 @@ console.log(isNaN(age));
 const randomValue = 21;
 
 function getInfo() {
-  console.log(typeof randomValue);
-  const randomValue = "Lydia Hallie";
+	console.log(typeof randomValue);
+	const randomValue = 'Lydia Hallie';
 }
 
 getInfo();
@@ -4213,16 +4213,16 @@ getInfo();
 ###### 130. Что будет на выходе?
 
 ```javascript
-const myPromise = Promise.resolve("Woah some cool data");
+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!");
-  }
+	try {
+		console.log(await myPromise);
+	} catch {
+		throw new Error(`Oops didn't work`);
+	} finally {
+		console.log('Oh finally!');
+	}
 })();
 ```
 
@@ -4246,7 +4246,7 @@ const myPromise = Promise.resolve("Woah some cool data");
 ###### 131. Что будет на выходе?
 
 ```javascript
-const emojis = ["🥑", ["✨", "✨", ["🍕", "🍕"]]];
+const emojis = ['🥑', ['✨', '✨', ['🍕', '🍕']]];
 
 console.log(emojis.flat(1));
 ```
@@ -4319,19 +4319,19 @@ console.log(counterOne.count);
 ###### 133. Что будет на выходе?
 
 ```javascript
-const myPromise = Promise.resolve(Promise.resolve("Promise!"));
+const myPromise = Promise.resolve(Promise.resolve('Promise!'));
 
 function funcOne() {
-  myPromise.then((res) => res).then((res) => console.log(res));
-  setTimeout(() => console.log("Timeout!", 0));
-  console.log("Last line!");
+  myPromise.then(res => res).then(res => console.log(res));
+  setTimeout(() => console.log('Timeout!', 0));
+  console.log('Last line!');
 }
 
 async function funcTwo() {
   const res = await myPromise;
   console.log(await res);
-  setTimeout(() => console.log("Timeout!", 0));
-  console.log("Last line!");
+  setTimeout(() => console.log('Timeout!', 0));
+  console.log('Last line!');
 }
 
 funcOne();
@@ -4376,7 +4376,7 @@ export default function sum(x) {
 }
 
 // index.js
-import * as sum from "./sum";
+import * as sum from './sum';
 ```
 
 - A: `sum(4)`
@@ -4393,12 +4393,12 @@ import * as sum from "./sum";
 
 ```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);
 ```
 
@@ -4429,13 +4429,13 @@ console.log(info);
 
 ```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;
 ```
 
@@ -4465,7 +4465,7 @@ C помощью Proxy мы можем добавить собственное 
 ###### 136. Какое из перечисленных действий может модифицировать объект `person`?
 
 ```javascript
-const person = { name: "Lydia Hallie" };
+const person = { name: 'Lydia Hallie' };
 
 Object.seal(person);
 ```
@@ -4493,9 +4493,9 @@ Object.seal(person);
 
 ```javascript
 const person = {
-  name: "Lydia Hallie",
+  name: 'Lydia Hallie',
   address: {
-    street: "100 Main St",
+    street: '100 Main St',
   },
 };
 
@@ -4524,7 +4524,7 @@ Object.freeze(person);
 ###### 138. Что будет на выходе?
 
 ```javascript
-const add = (x) => x + x;
+const add = x => x + x;
 
 function myFunc(num = 2, value = add(num)) {
   console.log(num, value);
@@ -4557,21 +4557,21 @@ myFunc(3);
 
 ```javascript
 class Counter {
-  #number = 10;
+  #number = 10
 
   increment() {
-    this.#number++;
+    this.#number++
   }
 
   getNum() {
-    return this.#number;
+    return this.#number
   }
 }
 
-const counter = new Counter();
-counter.increment();
+const counter = new Counter()
+counter.increment()
 
-console.log(counter.#number);
+console.log(counter.#number)
 ```
 
 - A: `10`
@@ -4595,8 +4595,8 @@ console.log(counter.#number);
 
 ```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) {
@@ -4639,8 +4639,8 @@ obj.next(); // { value: "Lisa", done: false }
 
 ```javascript
 const person = {
-  name: "Lydia Hallie",
-  hobbies: ["coding"],
+  name: 'Lydia Hallie',
+  hobbies: ['coding'],
 };
 
 function addHobby(hobby, hobbies = person.hobbies) {
@@ -4648,9 +4648,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);
 ```
@@ -4719,11 +4719,11 @@ const pet = new Flamingo();
 ###### 143. Какой/какие из вариантов приведет к ошибке?
 
 ```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;
 ```
 
@@ -4778,11 +4778,11 @@ const person = {
 let count = 0;
 const nums = [0, 1, 2, 3];
 
-nums.forEach((num) => {
-  if (num) count += 1;
-});
+nums.forEach(num => {
+	if (num) count += 1
+})
 
-console.log(count);
+console.log(count)
 ```
 
 - A: 1
@@ -4806,12 +4806,12 @@ console.log(count);
 
 ```javascript
 function getFruit(fruits) {
-  console.log(fruits?.[1]?.[1]);
+	console.log(fruits?.[1]?.[1])
 }
 
-getFruit([["🍊", "🍌"], ["🍍"]]);
-getFruit();
-getFruit([["🍍"], ["🍊", "🍌"]]);
+getFruit([['🍊', '🍌'], ['🍍']])
+getFruit()
+getFruit([['🍍'], ['🍊', '🍌']])
 ```
 
 - A: `null`, `undefined`, 🍌
@@ -4841,19 +4841,19 @@ getFruit([["🍍"], ["🍊", "🍌"]]);
 
 ```javascript
 class Calc {
-  constructor() {
-    this.count = 0;
-  }
+	constructor() {
+		this.count = 0 
+	}
 
-  increase() {
-    this.count++;
-  }
+	increase() {
+		this.count ++
+	}
 }
 
-const calc = new Calc();
-new Calc().increase();
+const calc = new Calc()
+new Calc().increase()
 
-console.log(calc.count);
+console.log(calc.count)
 ```
 
 - A: `0`
@@ -4877,25 +4877,25 @@ console.log(calc.count);
 
 ```javascript
 const user = {
-  email: "e@mail.com",
-  password: "12345",
-};
+	email: "e@mail.com",
+	password: "12345"
+}
 
 const updateUser = ({ email, password }) => {
-  if (email) {
-    Object.assign(user, { email });
-  }
+	if (email) {
+		Object.assign(user, { email })
+	}
 
-  if (password) {
-    user.password = password;
-  }
+	if (password) {
+		user.password = password
+	}
 
-  return user;
-};
+	return user
+}
 
-const updatedUser = updateUser({ email: "new@email.com" });
+const updatedUser = updateUser({ email: "new@email.com" })
 
-console.log(updatedUser === user);
+console.log(updatedUser === user)
 ```
 
 - A: `false`
@@ -4918,13 +4918,13 @@ console.log(updatedUser === user);
 ###### 149. Что будет на выходе?
 
 ```javascript
-const fruit = ["🍌", "🍊", "🍎"];
+const fruit = ['🍌', '🍊', '🍎']
 
-fruit.slice(0, 1);
-fruit.splice(0, 1);
-fruit.unshift("🍇");
+fruit.slice(0, 1)
+fruit.splice(0, 1)
+fruit.unshift('🍇')
 
-console.log(fruit);
+console.log(fruit)
 ```
 
 - A: `['🍌', '🍊', '🍎']`
@@ -4950,13 +4950,13 @@ console.log(fruit);
 
 ```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]);
+console.log(animals[dog])
 ```
 
 - A: `{ emoji: "🐶", name: "Mara" }`
@@ -4986,14 +4986,14 @@ console.log(animals[dog]);
 
 ```javascript
 const user = {
-  email: "my@email.com",
-  updateEmail: (email) => {
-    this.email = email;
-  },
-};
+	email: "my@email.com",
+	updateEmail: email => {
+		this.email = email
+	}
+}
 
-user.updateEmail("new@email.com");
-console.log(user.email);
+user.updateEmail("new@email.com")
+console.log(user.email)
 ```
 
 - A: `my@email.com`
@@ -5016,20 +5016,20 @@ console.log(user.email);
 ###### 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]);
-  const res2 = await Promise.all([promise3, promise4]);
-  return [res1, res2];
-};
+	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));
+	.then(res => console.log(res))
+	.catch(err => console.log(err))
 ```
 
 - A: `[['First', 'Second'], ['Fourth']]`
@@ -5052,16 +5052,13 @@ runPromises()
 ###### 153. Каким должно быть значение `method` для регистрации `{ name: "Lydia", age: 22 }`?
 
 ```javascript
-const keys = ["name", "age"];
-const values = ["Lydia", 22];
+const keys = ["name", "age"]
+const values = ["Lydia", 22]
 
-const method =
-  /* ?? */
-  Object[method](
-    keys.map((_, i) => {
-      return [keys[i], values[i]];
-    })
-  ); // { name: "Lydia", age: 22 }
+const method = /* ?? */
+Object[method](keys.map((_, i) => {
+	return [keys[i], values[i]]
+})) // { name: "Lydia", age: 22 }
 ```
 
 - A: `entries`
@@ -5086,18 +5083,18 @@ const method =
 ###### 154. Что будет на выходе?
 
 ```javascript
-const createMember = ({ email, address = {} }) => {
-  const validEmail = /.+\@.+\..+/.test(email);
-  if (!validEmail) throw new Error("Valid email pls");
+const createMember = ({ email, address = {}}) => {
+	const validEmail = /.+\@.+\..+/.test(email)
+	if (!validEmail) throw new Error("Valid email pls")
 
-  return {
-    email,
-    address: address ? address : null,
-  };
-};
+	return {
+		email,
+		address: address ? address : null
+	}
+}
 
-const member = createMember({ email: "my@email.com" });
-console.log(member);
+const member = createMember({ email: "my@email.com" })
+console.log(member)
 ```
 
 - A: `{ email: "my@email.com", address: null }`
@@ -5120,13 +5117,13 @@ console.log(member);
 ###### 155. Что будет на выходе?
 
 ```javascript
-let randomValue = { name: "Lydia" };
-randomValue = 23;
+let randomValue = { name: "Lydia" }
+randomValue = 23
 
 if (!typeof randomValue === "string") {
-  console.log("It's not a string!");
+	console.log("It's not a string!")
 } else {
-  console.log("Yay it's a string!");
+	console.log("Yay it's a string!")
 }
 ```
 
diff --git a/sq-KS/README_sq_KS.md b/sq-KS/README_sq_KS.md
index 8446493c..aa1eb9dc 100644
--- a/sq-KS/README_sq_KS.md
+++ b/sq-KS/README_sq_KS.md
@@ -10,10 +10,9 @@ Nga konceptet bazike tek ato të avancuara: testo se sa mirë e njeh JavaScript-
 
 Mos hezitoni të më kontaktoni! 😊
 <a href="https://www.instagram.com/theavocoder">Instagram</a> || <a href="https://www.twitter.com/lydiahallie">Twitter</a> || <a href="https://www.linkedin.com/in/lydia-hallie">LinkedIn</a> || <a href="https://www.lydiahallie.dev">Blog</a>
-
 </div>
 
-| Ndjehuni të lirë të i përdorni në projektet e juaja |😃 Do të e vlerësoja shumë referencimin tuaj në ketë repositori, unë i krijoj pyetjet dhe poashtu edhe përgjigjet (lol) dhe komuniteti me ndihmon shumë të e përmirësoj dhe të mirëmbajë! 💪🏼 Faleminderit!
+| Ndjehuni të lirë të i përdorni në projektet e juaja |😃  Do të e vlerësoja shumë referencimin tuaj në ketë repositori, unë i krijoj pyetjet dhe poashtu edhe përgjigjet (lol) dhe komuniteti me ndihmon shumë të e përmirësoj dhe të mirëmbajë! 💪🏼 Faleminderit!
 
 ---
 
@@ -33,7 +32,6 @@ Mos hezitoni të më kontaktoni! 😊
 - [🇳🇱 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)
@@ -48,13 +46,13 @@ Mos hezitoni të më kontaktoni! 😊
 
 ---
 
-###### 1. Cila është vlera e saj?
+###### 1.  Cila është vlera e saj?
 
 ```javascript
 function sayHi() {
   console.log(name);
   console.log(age);
-  var name = "Lydia";
+  var name = 'Lydia';
   let age = 21;
 }
 
@@ -80,7 +78,7 @@ Variablat me fjalën kyçe `let` (dhe `const`) hoistohen, por ndryshe nga `var`,
 
 ---
 
-###### 2. Cila është vlera e saj?
+###### 2.  Cila është vlera e saj?
 
 ```javascript
 for (var i = 0; i < 3; i++) {
@@ -101,7 +99,7 @@ for (let i = 0; i < 3; i++) {
 
 #### Përgjigja: C
 
-Për shkak të **_event queque_** në JavaScript, funksioni callback `setTimeout` thirret pas ekzekutimit të unazës. Pasi që variabla `i` në iterimin e parë u deklarua duke përdorur fjalën kyçe `var`, kjo vlerë ishte globale. Gjatë unazës, ne rritëm vlerën e `i` me `1` çdo herë, duke përdorur operatorin unar `++`. Deri në kohën që funksioni callback `setTimeout` u thirr, `i` ishte e barabartë me `3` në unazën e parë.
+Për shkak të ***event queque*** në JavaScript, funksioni callback `setTimeout` thirret pas ekzekutimit të unazës. Pasi që variabla `i` në iterimin e parë u deklarua duke përdorur fjalën kyçe `var`, kjo vlerë ishte globale. Gjatë unazës, ne rritëm vlerën e `i` me `1` çdo herë, duke përdorur operatorin unar `++`. Deri në kohën që funksioni callback `setTimeout` u thirr, `i` ishte e barabartë me `3` në unazën e parë.
 
 Në unazën e dytë, variabla `i` u deklarua duke përdorur fjalën kyçe `let`: variablat e deklaruara me fjalën kyçe `let` (dhe `const`) janë të qasshme në bllok (një bllok është çdo gjë mes `{ }`). Gjatë çdo iteracioni, `i` do të ketë një vlerë të re, dhe çdo vlerë është e qasshme brenda unazës.
 
@@ -150,7 +148,7 @@ Në funksionet shigjeta, fjala kyçe `this` referohet në qasjen në rrethinën
 
 ```javascript
 +true;
-!"Lydia";
+!'Lydia';
 ```
 
 - A: `1` and `false`
@@ -175,11 +173,11 @@ Vargu i karaktereve (stringu) `'Lydia'` konsiderohet si vlerë `true`. Çfarë n
 
 ```javascript
 const bird = {
-  size: "small",
+  size: 'small',
 };
 
 const mouse = {
-  name: "Mickey",
+  name: 'Mickey',
   small: true,
 };
 ```
@@ -210,11 +208,11 @@ Megjithatë, me notacionin pikë, kjo nuk ndodh. `mouse` nuk ka një çelës të
 ###### 6. Cila është vlera e saj?
 
 ```javascript
-let c = { greeting: "Hey!" };
+let c = { greeting: 'Hey!' };
 let d;
 
 d = c;
-c.greeting = "Hello";
+c.greeting = 'Hello';
 console.log(d.greeting);
 ```
 
@@ -268,7 +266,7 @@ console.log(b === c);
 
 Kur përdorim operatorin `==` (operatorin i barazimit), ai kontrollon vetëm nëse ka të njëjtën _vlerë_. Të dy kanë vlerën `3`, kështu që kthen `true`.
 
-Megjithatë, kur përdorim operatorin `===` (operatori i barazisë strikte), të dy vlerat dhe tipi i tyre duhet të jenë të njëjta. Nuk është: `new Number()` nuk është një numër, është një **objekt**. Të dy kthejnë `false`.
+Megjithatë, kur përdorim operatorin `===` (operatori i barazisë strikte), të dy vlerat dhe tipi i tyre duhet të jenë të njëjta. Nuk është: `new Number()` nuk është një numër, është një __objekt__. Të dy kthejnë `false`.
 
 </p>
 </details>
@@ -284,13 +282,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`
@@ -345,10 +343,10 @@ Për të shmangur këtë, ne mund të përdorim `"use strict"`. Kjo siguron që
 
 ```javascript
 function bark() {
-  console.log("Woof!");
+  console.log('Woof!');
 }
 
-bark.animal = "dog";
+bark.animal = 'dog';
 ```
 
 - A: Asgjë, gjithçka është në rregull!
@@ -378,8 +376,8 @@ function Person(firstName, lastName) {
   this.lastName = lastName;
 }
 
-const member = new Person("Lydia", "Hallie");
-Person.getFullName = function () {
+const member = new Person('Lydia', 'Hallie');
+Person.getFullName = function() {
   return `${this.firstName} ${this.lastName}`;
 };
 
@@ -401,7 +399,7 @@ Në JavaScript, funksionet janë objekte dhe për këtë arsye metoda `getFullNa
 Nëse dëshironi që një metodë të jetë e qasshme për të gjitha instancat e objektit, duhet ta shtoni atë në vetinë e quajtur "prototype":
 
 ```js
-Person.prototype.getFullName = function () {
+Person.prototype.getFullName = function() {
   return `${this.firstName} ${this.lastName}`;
 };
 ```
@@ -419,8 +417,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);
@@ -490,7 +488,7 @@ function sum(a, b) {
   return a + b;
 }
 
-sum(1, "2");
+sum(1, '2');
 ```
 
 - A: `NaN`
@@ -503,7 +501,7 @@ sum(1, "2");
 
 #### Përgjigja: C
 
-JavaScript është gjuhë e shkruar në mënyrë dinamike **dynamically typed language**: ne nuk specifikojmë se çfarë tipe janë variablat e caktuara. Vlerat mund të konvertohen automatikisht në një tip tjetër pa e ditur ju dhe ky proces quhet _implicit type coercion_ (shndërrimi i tipit në mënyrë të nënkuptuar). **Coercion** është shndërrimi nga një tip në një tjetër.
+JavaScript është gjuhë e shkruar në mënyrë dinamike __dynamically typed language__: ne nuk specifikojmë se çfarë tipe janë variablat e caktuara. Vlerat mund të konvertohen automatikisht në një tip tjetër pa e ditur ju dhe ky proces quhet _implicit type coercion_ (shndërrimi i tipit në mënyrë të nënkuptuar). __Coercion__ është shndërrimi nga një tip në një tjetër.
 
 Në këtë shembull, JavaScript konverton numrin `1` në string, në mënyrë që për funksionin të ketë kuptim dhe të kthejë një vlerë. Përgjatë mbledhjes të një tipi number (`1`) dhe një tipi string (`'2'`), numri trajtohet si string. Ne mund ti bashkojmë stringjet si `"Hello" + "World"`, kështu që ajo që po ndodh këtu është `"1" + "2"` e cila kthen "12"`.
 
@@ -557,7 +555,7 @@ function getPersonInfo(one, two, three) {
   console.log(three);
 }
 
-const person = "Lydia";
+const person = 'Lydia';
 const age = 21;
 
 getPersonInfo`${person} is ${age} years old`;
@@ -584,9 +582,9 @@ Nëse përdorni literale të shabllonit (template literals) të etiketuar, vlera
 ```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`);
   }
@@ -646,7 +644,7 @@ Parametri "rest" (`...args`) na lejon të "mbledhim" të gjitha argumentet e mbe
 
 ```javascript
 function getAge() {
-  "use strict";
+  'use strict';
   age = 21;
   console.log(age);
 }
@@ -674,7 +672,7 @@ Me `"use strict"`, mund të siguroheni se nuk do të deklaroni variabla globale
 ###### 21. Sa do të jetë vlera e `sum`?
 
 ```javascript
-const sum = eval("10*10+5");
+const sum = eval('10*10+5');
 ```
 
 - A: `105`
@@ -697,7 +695,7 @@ const sum = eval("10*10+5");
 ###### 22. Sa kohë është e qasshme cool_secret?
 
 ```javascript
-sessionStorage.setItem("cool_secret", 123);
+sessionStorage.setItem('cool_secret', 123);
 ```
 
 - A: Përgjithmonë, e dhëna nuk humb.
@@ -750,12 +748,12 @@ Ju nuk mund ta bëni këtë me 'let' ose 'const' pasi ato kanë qasje në bllok
 ###### 24. Cila është vlera e saj?
 
 ```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);
 ```
 
@@ -781,7 +779,7 @@ Nuk funksionon në këtë mënyrë për një "set". Nuk ka asnjë `'1'` në set-
 ###### 25. Cila është vlera e saj?
 
 ```javascript
-const obj = { a: "one", b: "two", a: "three" };
+const obj = { a: 'one', b: 'two', a: 'three' };
 console.log(obj);
 ```
 
@@ -850,12 +848,12 @@ Deklarata `continue` kalon një iterim nëse një kusht i caktuar kthen `true`.
 
 ```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());
+console.log(name.giveLydiaPizza())
 ```
 
 - A: `"Just give Lydia pizza already!"`
@@ -879,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;
@@ -912,9 +910,9 @@ Pastaj ne e printojmë `a[b]` e cila është `a["[object Object]"]`. We sapo e v
 ###### 30. Cila është vlera e saj?
 
 ```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();
@@ -967,7 +965,9 @@ Këtu fillon të funksionojë event loop. Një **event loop** shikon "stack" dhe
 ```html
 <div onclick="console.log('first div')">
   <div onclick="console.log('second div')">
-    <button onclick="console.log('button')">Click!</button>
+    <button onclick="console.log('button')">
+      Click!
+    </button>
   </div>
 </div>
 ```
@@ -993,7 +993,9 @@ Elementi më thellë i mbivendosur që shkaktoi ngjarjen është objektivi i ngj
 
 ```html
 <div onclick="console.log('div')">
-  <p onclick="console.log('p')">Click here!</p>
+  <p onclick="console.log('p')">
+    Click here!
+  </p>
 </div>
 ```
 
@@ -1017,7 +1019,7 @@ Nëse klikojmë `p`, shohim dy dalje: `p` dhe `div`. Gjatë "event propagation",
 ###### 33. Cila është vlera e saj?
 
 ```javascript
-const person = { name: "Lydia" };
+const person = { name: 'Lydia' };
 
 function sayHi(age) {
   return `${this.name} is ${age}`;
@@ -1080,8 +1082,8 @@ FYI: `typeof` mund të kthejë listën e mëposhtme të vlerave: `undefined`, `b
 ```javascript
 0;
 new Number(0);
-("");
-(" ");
+('');
+(' ');
 new Boolean(false);
 undefined;
 ```
@@ -1230,14 +1232,11 @@ Ajo që e dallon një tip primitiv nga një objekt është se primitivët nuk ka
 ###### 40. Cila është vlera e saj?
 
 ```javascript
-[
-  [0, 1],
-  [2, 3],
-].reduce(
+[[0, 1], [2, 3]].reduce(
   (acc, cur) => {
     return acc.concat(cur);
   },
-  [1, 2]
+  [1, 2],
 );
 ```
 
@@ -1264,7 +1263,7 @@ Pastaj, `[1, 2, 0, 1]` është `acc` dhe `[2, 3]` është `cur`. I bashkojmë at
 
 ```javascript
 !!null;
-!!"";
+!!'';
 !!1;
 ```
 
@@ -1292,7 +1291,7 @@ Pastaj, `[1, 2, 0, 1]` është `acc` dhe `[2, 3]` është `cur`. I bashkojmë at
 ###### 42. Çfarë do të kthejë në browser funksioni `setInterval`?
 
 ```javascript
-setInterval(() => console.log("Hi"), 1000);
+setInterval(() => console.log('Hi'), 1000);
 ```
 
 - A: një id unike
@@ -1315,7 +1314,7 @@ Kthen një id unike. Kjo id mund të përdoret për të pastruar intervalin me f
 ###### 43. Çfarë do të kthehet si rezultat?
 
 ```javascript
-[..."Lydia"];
+[...'Lydia'];
 ```
 
 - A: `["L", "y", "d", "i", "a"]`
@@ -1335,7 +1334,7 @@ Stringu është i iterueshëm. Operatori i përhapjes (spread operator) iteron 
 
 ---
 
-###### 44. Cila është vlera e saj?
+###### 44.  Cila është vlera e saj?
 
 ```javascript
 function* generator(i) {
@@ -1374,14 +1373,14 @@ Pastaj, ne e thirrim funksionin përsëri me metodën `next()`. Fillon dhe vazhd
 
 ```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));
+Promise.race([firstPromise, secondPromise]).then(res => console.log(res));
 ```
 
 - A: `"one"`
@@ -1404,7 +1403,7 @@ Kur i kalojmë premtime (promises) të shumta metodës `Promise.race`, ajo zgjid
 ###### 46. Cila është vlera e saj?
 
 ```javascript
-let person = { name: "Lydia" };
+let person = { name: 'Lydia' };
 const members = [person];
 person = null;
 
@@ -1444,7 +1443,7 @@ Ne po e modifikojmë vetëm vlerën e variblës `person`, dhe jo të elementit t
 
 ```javascript
 const person = {
-  name: "Lydia",
+  name: 'Lydia',
   age: 21,
 };
 
@@ -1473,7 +1472,7 @@ Me unazën `for-in`, ne mund të iterojmë përgjatë çelësave të objektit, n
 ###### 48. Cila është vlera e saj?
 
 ```javascript
-console.log(3 + 4 + "5");
+console.log(3 + 4 + '5');
 ```
 
 - A: `"345"`
@@ -1500,7 +1499,7 @@ Radha e veprimeve matematikore të operatorit është rendi në të cilin përpi
 ###### 49. What's the value of `num`?
 
 ```javascript
-const num = parseInt("7*6", 10);
+const num = parseInt('7*6', 10);
 ```
 
 - A: `42`
@@ -1525,8 +1524,8 @@ Kthehen vetëm numrat e parë në string. Bazuar në _radix (bazë)_ (argumenti
 ###### 50. Cila është vlera e saj?
 
 ```javascript
-[1, 2, 3].map((num) => {
-  if (typeof num === "number") return;
+[1, 2, 3].map(num => {
+  if (typeof num === 'number') return;
   return num * 2;
 });
 ```
@@ -1554,12 +1553,12 @@ Megjithatë, ne nuk kthejmë një vlerë. Kur nuk kthejmë një vlerë nga funks
 
 ```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);
 
@@ -1591,15 +1590,15 @@ Vlera e `person` është objekt. Argumenti `member` ka referencë (të kopjuar)
 
 ```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);
   }
 }
 
@@ -1629,8 +1628,8 @@ Me deklaratën `catch`, ne mund të specifikojmë se çfarë të bëjmë nëse n
 
 ```javascript
 function Car() {
-  this.make = "Lamborghini";
-  return { make: "Maserati" };
+  this.make = 'Lamborghini';
+  return { make: 'Maserati' };
 }
 
 const myCar = new Car();
@@ -1704,11 +1703,11 @@ class Dog {
   }
 }
 
-Dog.prototype.bark = function () {
+Dog.prototype.bark = function() {
   console.log(`Woof I am ${this.name}`);
 };
 
-const pet = new Dog("Mara");
+const pet = new Dog('Mara');
 
 pet.bark();
 
@@ -1773,7 +1772,7 @@ export default counter;
 
 ```javascript
 // index.js
-import myCounter from "./counter";
+import myCounter from './counter';
 
 myCounter += 1;
 
@@ -1802,7 +1801,7 @@ Kur tentojmë të rrisim vlerën e `myCounter`, do të marrim një error: `myCou
 ###### 58. Cila është vlera e saj?
 
 ```javascript
-const name = "Lydia";
+const name = 'Lydia';
 age = 21;
 
 console.log(delete name);
@@ -1819,7 +1818,7 @@ console.log(delete age);
 
 #### Përgjigja: A
 
-Operatori "delete" kthen një vlerë booleane: `true` në fshirje të suksesshme, përndryshe do të kthejë `false`. Megjithatë, variablat e deklaruara me fjalën kyçe `var`, `const` ose `let` nuk mund të fshihen duke përdorur operatorin `delete`.
+Operatori "delete" kthen një vlerë booleane: `true` në fshirje të suksesshme, përndryshe do të kthejë `false`. Megjithatë, variablat e deklaruara me fjalën kyçe `var`, `const` ose `let` nuk mund të fshihen duke përdorur operatorin  `delete`.
 
 Variabla `name` u deklarua me fjalën kyçe `const`, kështu që fshirja e saj nuk ishte e suksesshme: u kthye `false`. Kur vendosëm `age` të barabartë me `21`, ne në fakt shtuam një veti të quajtur `age` në objektin global. Ju mund të fshini me sukses vetitë nga objektet në këtë mënyrë, gjithashtu edhe objektin global, kështu që `delete age` kthen `true`.
 
@@ -1873,7 +1872,7 @@ Kjo do të thotë se vlera e `y` është e barabartë me vlerën e parë në arr
 ###### 60. Cila është vlera e saj?
 
 ```javascript
-const user = { name: "Lydia", age: 21 };
+const user = { name: 'Lydia', age: 21 };
 const admin = { admin: true, ...user };
 
 console.log(admin);
@@ -1899,9 +1898,9 @@ console.log(admin);
 ###### 61. Cila është vlera e saj?
 
 ```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));
@@ -1930,12 +1929,12 @@ Vetitë e shtuara duke përdorur metodën `defineProperty` janë të pandryshues
 
 ```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);
 ```
 
@@ -1966,7 +1965,7 @@ Nëse zëvendësuesi është një _funksion_, ky funksion thirret në çdo veti
 let num = 10;
 
 const increaseNumber = () => num++;
-const increasePassedNumber = (number) => number++;
+const increasePassedNumber = number => number++;
 
 const num1 = increaseNumber();
 const num2 = increasePassedNumber(num1);
@@ -1987,7 +1986,7 @@ console.log(num2);
 
 Operatori unar `++` fillimisht kthen vlerën e operandit, pastaj e rrit vlerën e tij. Vlera e `num1` është `10`, meqenëse funksioni `increaseNumber` fillimisht kthen vlerën e `num`, e cila është `10`, dhe vetëm pastaj e rrit vlerën e `num`.
 
-`num2` është `10`, pasi ne e kaluam `num1` si argument tek `increasePassedNumber`. `number` është i barabartë me `10`(vlera e `num1`). Përsëri, operatori unar `++` _së pari kthen_ vlerën e operandit, dhe pastaj rrit vlerën e tij. Vlera e `number` është `10`, kështu që `num2` është e barabartë me `10`.
+`num2` është `10`, pasi ne e kaluam `num1` si argument tek `increasePassedNumber`. `number` është i barabartë me `10`(vlera e  `num1`). Përsëri, operatori unar `++` _së pari kthen_ vlerën e operandit, dhe pastaj rrit vlerën e tij. Vlera e `number` është `10`, kështu që `num2` është e barabartë me `10`.
 
 </p>
 </details>
@@ -2123,12 +2122,12 @@ Klasa `Labrador` merr dy argumente, `name` meqenëse trashëgon klasën 'Dog', d
 
 ```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;
 ```
 
@@ -2156,7 +2155,7 @@ Ky është një dallimi në mes `require()` në CommonJS dhe `import`! Me `requi
 ```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`
@@ -2179,7 +2178,7 @@ console.log(Symbol("foo") === Symbol("foo"));
 ###### 69. Cila është vlera e saj?
 
 ```javascript
-const name = "Lydia Hallie";
+const name = 'Lydia Hallie';
 console.log(name.padStart(13));
 console.log(name.padStart(2));
 ```
@@ -2206,7 +2205,7 @@ Nëse argumenti i kaluar në metodën `padStart` është më i vogël se gjatës
 ###### 70. Cila është vlera e saj?
 
 ```javascript
-console.log("🥑" + "💻");
+console.log('🥑' + '💻');
 ```
 
 - A: `"🥑💻"`
@@ -2230,11 +2229,11 @@ Me operatorin `+`, ju mund të bashkoni vargjet. Në këtë rast, ne po bashkojm
 
 ```javascript
 function* startGame() {
-  const Përgjigja = yield "Do you love JavaScript?";
-  if (Përgjigja !== "Yes") {
+  const Përgjigja = yield 'Do you love JavaScript?';
+  if (Përgjigja !== 'Yes') {
     return "Oh wow... Guess we're done here";
   }
-  return "JavaScript loves you back ❤️";
+  return 'JavaScript loves you back ❤️';
 }
 
 const game = startGame();
@@ -2272,7 +2271,7 @@ console.log(String.raw`Hello\nworld`);
 - A: `Hello world!`
 - B: `Hello` &nbsp; &nbsp; &nbsp;`world`
 - C: `Hello\nworld`
-- D: `Hello\n` &nbsp; &nbsp; &nbsp;`world`
+- D: `Hello\n`  &nbsp; &nbsp; &nbsp;`world`
 
 <details><summary><b>Përgjigja</b></summary>
 <p>
@@ -2302,7 +2301,7 @@ Në këtë rast, `Hello\nworld` do të printohet.
 
 ```javascript
 async function getData() {
-  return await Promise.resolve("I made it!");
+  return await Promise.resolve('I made it!');
 }
 
 const data = getData();
@@ -2339,7 +2338,7 @@ function addToList(item, list) {
   return list.push(item);
 }
 
-const result = addToList("apple", ["banana"]);
+const result = addToList('apple', ['banana']);
 console.log(result);
 ```
 
@@ -2399,7 +2398,7 @@ Meqenëse `shape` është e ngrirë dhe meqenëse vlera e `x` nuk është një o
 ###### 76. Cila është vlera e saj?
 
 ```javascript
-const { firstName: myName } = { firstName: "Lydia" };
+const { firstName: myName } = { firstName: 'Lydia' };
 
 console.log(firstName);
 ```
@@ -2417,7 +2416,7 @@ console.log(firstName);
 Duke përdorur [sintaksen e funksioneve destruktuese](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment) ne mund të targetojmë vlerat nga vargjet, ose vetitë nga objektet, në variabla të veçanta:
 
 ```javascript
-const { firstName } = { firstName: "Lydia" };
+const { firstName } = { firstName: 'Lydia' };
 // versioni i ES5:
 // var firstName = { firstName: 'Lydia' }.firstName;
 
@@ -2427,7 +2426,7 @@ console.log(firstName); // "Lydia"
 Gjithashtu, një veti mund të targetohet nga një objekt dhe t'i caktohet një variableje me një emër të ndryshëm nga vetia e objektit:
 
 ```javascript
-const { firstName: myName } = { firstName: "Lydia" };
+const { firstName: myName } = { firstName: 'Lydia' };
 // versioni i ES5:
 // var myName = { firstName: 'Lydia' }.firstName;
 
@@ -2437,20 +2436,21 @@ console.log(firstName); // Uncaught ReferenceError: firstName is not defined
 
 Prandaj, `firstName` nuk ekziston si variabël, kështu që tentimi për të qasur vlerën e saj do të ngrejë një `ReferenceError`.
 
-**Shënim:** Kujdes nga vetitë e `global scope`:
+**Shënim:** Kujdes nga vetitë e  `global scope`:
 
 ```javascript
-const { name: myName } = { name: "Lydia" };
+const { name: myName } = { name: 'Lydia' };
 
 console.log(myName); // "lydia"
 console.log(name); // "" ----- Browser psh. Chrome
 console.log(name); // ReferenceError: name is not defined  ----- NodeJS
+
 ```
 
-Kurdo që JavaScript nuk mundet të gjejë një varibël në _current scope_, ngrihet në [Scope chain](https://github.com/getify/You-Dont-Know-JS/blob/2nd-ed/scope-closures/ch3.md) dhe kërkon për të dhe në qoftëse e arrin nivelin më të lartë të shtrirjes (the top-level scope), të quajtur **Global scope**, dhe ende nuk e gjen do të ngrejë `ReferenceError`.
+Kurdo që JavaScript nuk mundet të gjejë një varibël në _current scope_, ngrihet në [Scope chain](https://github.com/getify/You-Dont-Know-JS/blob/2nd-ed/scope-closures/ch3.md) dhe kërkon për të dhe në qoftëse e arrin nivelin më të lartë të shtrirjes (the top-level scope), të quajtur  __Global scope__, dhe ende nuk e gjen do të ngrejë `ReferenceError`.
 
-- Në **Browsers** si _Chrome_, `name` është _vetia e shtrirjes globale e vjetëruar_. Në këtë shembull, kodi funksionon brenda _global scope_ dhe nuk ka asnjë variabël lokale të përcaktuar nga përdoruesi për `name`, prandaj ai kërkon _variables/properties_ të paracaktuara në shtrirjen globale, në këtë rast shfletuesve, ai kërkon përmes objektit `window`, dhe do të nxjerrë vlerën [window.name](https://developer.mozilla.org/en-US/docs/Web/API/Window/name) e cila është e barabartë me një varg **bosh**.
-- Në **NodeJS**, nuk ka një veçori të tillë në objektin `global`, kështu që përpjekja për të iu qasur një variable joekzistente do të ngrejë një [ReferenceError](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Not_defined).
+- Në __Browsers__ si _Chrome_, `name` është _vetia e shtrirjes globale e vjetëruar_. Në këtë shembull, kodi funksionon brenda _global scope_ dhe nuk ka asnjë variabël lokale të përcaktuar nga përdoruesi për `name`, prandaj ai kërkon _variables/properties_ të paracaktuara në shtrirjen globale, në këtë rast shfletuesve, ai kërkon përmes objektit `window`, dhe do të nxjerrë vlerën [window.name](https://developer.mozilla.org/en-US/docs/Web/API/Window/name) e cila është e barabartë me një varg __bosh__.
+- Në __NodeJS__, nuk ka një veçori të tillë në objektin `global`, kështu që përpjekja për të iu qasur një variable joekzistente do të ngrejë një [ReferenceError](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Not_defined).
 
 </p>
 </details>
@@ -2482,12 +2482,12 @@ Funksioni `sum` _gjithmonë_ kthen të njëjtin rezultat. Nëse i kalojmë `1` d
 
 ---
 
-###### 78. Cila është vlera e saj?
+###### 78.  Cila është vlera e saj?
 
 ```javascript
 const add = () => {
   const cache = {};
-  return (num) => {
+  return num => {
     if (num in cache) {
       return `From cache! ${cache[num]}`;
     } else {
@@ -2529,10 +2529,10 @@ Herën e tretë, ne kalojmë `5 * 2` te funksioni i cili llogaritet si `10`. Obj
 
 ---
 
-###### 79. Cila është vlera e saj?
+###### 79.  Cila është vlera e saj?
 
 ```javascript
-const myLifeSummedUp = ["☕", "💻", "🍷", "🍫"];
+const myLifeSummedUp = ['☕', '💻', '🍷', '🍫'];
 
 for (let item in myLifeSummedUp) {
   console.log(item);
@@ -2559,14 +2559,14 @@ Me unazën _for-in_, ne mund të iterojmë në vetitë _e numërueshme_. Në nj
 
 Ku çelësat janë vetitë e numërueshme. `0` `1` `2` `3` printohet.
 
-Me unazën _for-of_, ne mund të iterojmë mbi **iterables**. Një array është një "iterable". Kur iterojmë mbi array, variabla "item" është e barabartë me elementin mbi të cilin po iterojmë aktualisht, "☕"` `"💻"` `"🍷"` `"🍫"` printohet.
+Me unazën _for-of_, ne mund të iterojmë mbi __iterables__. Një array është një "iterable". Kur iterojmë mbi array, variabla "item" është e barabartë me elementin mbi të cilin po iterojmë aktualisht, "☕"` `"💻"` `"🍷"` `"🍫"` printohet.
 
 </p>
 </details>
 
 ---
 
-###### 80. Cila është vlera e saj?
+###### 80.  Cila është vlera e saj?
 
 ```javascript
 const list = [1 + 2, 1 * 2, 1 / 2];
@@ -2592,7 +2592,7 @@ Elementi do të jetë i barabartë me vlerën e kthyer. `1 + 2` kthen `3`, `1 *
 
 ---
 
-###### 81. Cila është vlera e saj?
+###### 81.  Cila është vlera e saj?
 
 ```javascript
 function sayHi(name) {
@@ -2625,16 +2625,16 @@ Në këtë rast, nëse ne nuk kalojmë ndonjë vlerë ose e kalojmë `undefined`
 
 ---
 
-###### 82. Cila është vlera e saj?
+###### 82.  Cila është vlera e saj?
 
 ```javascript
-var status = "😎";
+var status = '😎';
 
 setTimeout(() => {
-  const status = "😍";
+  const status = '😍';
 
   const data = {
-    status: "🥑",
+    status: '🥑',
     getStatus() {
       return this.status;
     },
@@ -2655,25 +2655,25 @@ setTimeout(() => {
 
 #### Përgjigja: B
 
-Vlera e fjalës kyçe `this` varet nga vendi ku e përdorni. Në një **metodë**, si metoda `getStatus`, fjala kyçe `this` i referohet _objektit që i përket metoda_. Metoda i përket objektit `data`, kështu që `this` i referohet objektit `data`. Kur printojmë `this.status`, vetia `status` në objektin `data` printohet, që është `"🥑"`.
+Vlera e fjalës kyçe `this` varet nga vendi ku e përdorni. Në një __metodë__, si metoda `getStatus`, fjala kyçe `this` i referohet _objektit që i përket metoda_. Metoda i përket objektit `data`, kështu që `this` i referohet objektit `data`. Kur printojmë `this.status`, vetia `status` në objektin `data` printohet, që është `"🥑"`.
 
-Me metodën `call`, ne mund të ndryshojmë objektin të cilit i referohet fjala kyçe `this`. Në **funksione**, fjala kyçe `this` i referohet _objektit të cilit i përket funksioni_. Ne deklaruam funksionin `setTimeout` në objektin _global_, kështu që brenda funksionit `setTimeout`, fjala kyçe `this` i referohet objektit _global_. Në objektin global, ekziston një variabël e quajtur _status_ me vlerën `"😎"`. Kur printoni `this.status`, `"😎"` printohet.
+Me metodën `call`, ne mund të ndryshojmë objektin të cilit i referohet fjala kyçe `this`. Në __funksione__, fjala kyçe `this` i referohet _objektit të cilit i përket funksioni_. Ne deklaruam funksionin `setTimeout` në objektin _global_, kështu që brenda funksionit `setTimeout`, fjala kyçe `this` i referohet objektit _global_. Në objektin global, ekziston një variabël e quajtur _status_ me vlerën `"😎"`. Kur printoni `this.status`, `"😎"` printohet.
 
 </p>
 </details>
 
 ---
 
-###### 83. Cila është vlera e saj?
+###### 83.  Cila është vlera e saj?
 
 ```javascript
 const person = {
-  name: "Lydia",
+  name: 'Lydia',
   age: 21,
 };
 
 let city = person.city;
-city = "Amsterdam";
+city = 'Amsterdam';
 
 console.log(person);
 ```
@@ -2701,7 +2701,7 @@ Kur printojmë objektin `person`. objekti i pamodifikuar kthehet.
 
 ---
 
-###### 84. Cila është vlera e saj?
+###### 84.  Cila është vlera e saj?
 
 ```javascript
 function checkAge(age) {
@@ -2737,9 +2737,9 @@ Variablat e deklaruara me fjalët kyçe `const` dhe `let` janë të qasshme vet
 ###### 85. Çfarë lloj informacioni do të printohet?
 
 ```javascript
-fetch("https://www.website.com/api/user/1")
-  .then((res) => res.json())
-  .then((res) => console.log(res));
+fetch('https://www.website.com/api/user/1')
+  .then(res => res.json())
+  .then(res => console.log(res));
 ```
 
 - A: Rezultati i metodës `fetch`.
@@ -2793,7 +2793,7 @@ Kur vendosim `hasName` të barabartë me `name`, ju vendosni `hasName` të barab
 ###### 87. Cila është vlera e saj?
 
 ```javascript
-console.log("I want pizza"[0]);
+console.log('I want pizza'[0]);
 ```
 
 - A: `"""`
@@ -2848,11 +2848,11 @@ Në qoftëse provoni të vendosni një vlerë të paradefinuar të barabartë me
 
 ```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);
 ```
@@ -2885,7 +2885,7 @@ class Person {
   }
 }
 
-const member = new Person("John");
+const member = new Person('John');
 console.log(typeof member);
 ```
 
@@ -2934,7 +2934,7 @@ console.log(newList.push(5));
 
 Metoda `.push` kthen _gjatësinë e re_ të array, jo vetë array! Duke vendosur `newList` të barabartë me `[1, 2, 3].push(4)`, e vendosim `newList` të barabartë me gjatësinë e re të array: `4`.
 
-Pastaj, ne provojmë të përdorim metodën `.push` në `newList`. Meqenëse `newList` është vlera numerike e `4` ne nuk mund të përdorim metodën `.push`: do të ngrihet TypeError.
+Pastaj, ne provojmë të përdorim metodën `.push`  në `newList`. Meqenëse `newList` është vlera numerike e `4` ne nuk mund të përdorim metodën `.push`: do të ngrihet TypeError.
 
 </p>
 </details>
@@ -2945,7 +2945,7 @@ Pastaj, ne provojmë të përdorim metodën `.push` në `newList`. Meqenëse `ne
 
 ```javascript
 function giveLydiaPizza() {
-  return "Here is pizza!";
+  return 'Here is pizza!';
 }
 
 const giveLydiaChocolate = () =>
@@ -2976,7 +2976,7 @@ Funskionet e rregullta, të tillë si funksioni `giveLydiaPizza`, kanë vetinë
 
 ```javascript
 const person = {
-  name: "Lydia",
+  name: 'Lydia',
   age: 21,
 };
 
@@ -3035,7 +3035,7 @@ function getItems(fruitList, favoriteFruit, ...args) {
   return [...fruitList, ...args, favoriteFruit];
 }
 
-getItems(["banana", "apple"], "pear", "orange");
+getItems(['banana', 'apple'], 'pear', 'orange');
 ```
 
 Shembulli i mësipërm funskionon. Do të kthejë array `[ 'banana', 'apple', 'orange', 'pear' ]`
@@ -3049,9 +3049,9 @@ Shembulli i mësipërm funskionon. Do të kthejë array `[ 'banana', 'apple', 'o
 
 ```javascript
 function nums(a, b) {
-  if (a > b) console.log("a is bigger");
-  else console.log("b is bigger");
-  return;
+  if (a > b) console.log('a is bigger');
+  else console.log('b is bigger');
+  return
   a + b;
 }
 
@@ -3069,7 +3069,7 @@ console.log(nums(1, 2));
 
 #### Përgjigja: B
 
-Në JavaScript, nuk e duhet të e shkruajmë pikëpresjen `;` në mënyrë eksplicite, sidoqoftë makina e JavaScript prapë i vendos ato pas deklarimeve. Kjo quhet **Automatic Semicolon Insertion** (vendosja e pikëpresjes automatikisht). Një deklaratë për shembull mund të jetë variabla, ose fjalët kyçe si `throw`, `return`, `break` etj.
+Në JavaScript, nuk e duhet të e shkruajmë pikëpresjen `;` në mënyrë eksplicite, sidoqoftë makina e JavaScript prapë i vendos ato pas deklarimeve. Kjo quhet __Automatic Semicolon Insertion__ (vendosja e pikëpresjes automatikisht). Një deklaratë për shembull mund të jetë variabla, ose fjalët kyçe si `throw`, `return`, `break` etj.
 
 Në këtë rast, ne shkruajtëm deklaratën `return`, dhe vlerën tjetër `a + b` në rresht të ri. Sidoqoftë, meqenëse është rresht i ri, makina nuk e di se në të vërtetë ajo është vlera që ne po dëshirojmë të kthejmë. Në vend se të e llogarisë në atë mënyrë, në mënyrë automatike vendoset `return`. Kjo mund të shikohet edhe si kjo sintaksë:
 
@@ -3090,13 +3090,13 @@ Kjo do të thotë se `a + b` nuk arrihet asnjëherë, meqenëse funksioni ndalon
 ```javascript
 class Person {
   constructor() {
-    this.name = "Lydia";
+    this.name = 'Lydia';
   }
 }
 
 Person = class AnotherPerson {
   constructor() {
-    this.name = "Sarah";
+    this.name = 'Sarah';
   }
 };
 
@@ -3125,7 +3125,7 @@ Ne mund të iu shoqërojmë klasave konstruktorët e tjerë të klasave/funksion
 
 ```javascript
 const info = {
-  [Symbol("a")]: "b",
+  [Symbol('a')]: 'b',
 };
 
 console.log(info);
@@ -3142,9 +3142,9 @@ console.log(Object.keys(info));
 
 #### Përgjigja: D
 
-Një Symbol nuk është i _numërueshëm_. Metoda Object.keys kthen të gjithë çelësat e \_numërueshëm në një objekt. Symbol nuk do të jetë i dukshëm, dhe një array i zbrazët do të kthehet. Kur e printojmë objektin në tërësi, të gjitha vetitë janë të dukshme, edhe ato të cilat nuk janë te numërueshme.
+Një Symbol nuk është i _numërueshëm_. Metoda Object.keys kthen të gjithë çelësat e _numërueshëm në një objekt. Symbol nuk do të jetë i dukshëm, dhe një array i zbrazët do të kthehet. Kur e printojmë objektin në tërësi, të gjitha vetitë janë të dukshme, edhe ato të cilat nuk janë te numërueshme.
 
-Kjo është vetëm një nga shumë vetitë e symbol, përveç përfaqësimit të një vlere krejtësisht unike (e cila parandalon konflikt në emërtim të objekteve, për shembull kur punoni me 2 librari që duan të shtojnë vetitë në të njëjtin objekt), ju gjithashtu mund të "fshehni" vetitë e objekteve në këtë mënyrë (edhe pse jo plotësisht. Ju mund t'i qaseni simboleve duke përdorur metodën `Object.getOwnPropertySymbols()`).
+Kjo është vetëm një nga shumë vetitë e symbol, përveç përfaqësimit të një vlere krejtësisht unike (e cila parandalon konflikt  në emërtim të objekteve, për shembull kur punoni me 2 librari që duan të shtojnë vetitë në të njëjtin objekt), ju gjithashtu mund të "fshehni" vetitë e objekteve në këtë mënyrë (edhe pse jo plotësisht. Ju mund t'i qaseni simboleve duke përdorur metodën `Object.getOwnPropertySymbols()`).
 
 </p>
 </details>
@@ -3194,7 +3194,7 @@ Funskioni i meposhtëm do të kthente një objekt:
 ###### 99. Cila është vlera e saj?
 
 ```javascript
-const name = "Lydia";
+const name = 'Lydia';
 
 console.log(name());
 ```
@@ -3226,8 +3226,8 @@ ReferenceErrors ngrihen kur Javascript-i nuk është në gjendje të gjejë refe
 ```javascript
 // 🎉✨ Kjo është pytja jonë e 100! ✨🎉
 
-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`
@@ -3253,7 +3253,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);
@@ -3285,16 +3285,16 @@ Me operatorin `||`, ne mund të kthejmë vlerën e parë "truthy" të operandit.
 ###### 102. Cila është vlera në dalje?
 
 ```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");
+  myPromise().then(res => console.log(res));
+  console.log('second');
 }
 
 async function secondFunction() {
   console.log(await myPromise());
-  console.log("second");
+  console.log('second');
 }
 
 firstFunction();
@@ -3332,8 +3332,8 @@ Kjo do të thotë se pret për `myPromise` të zgjidhet me vlerën `I have resol
 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);
@@ -3393,13 +3393,13 @@ Në këtë rast, ne vetëm i kaluam si argument vlerën numerike `5`. Kthen 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);
 ```
@@ -3416,7 +3416,7 @@ compareMembers(person);
 
 Objektet vendosen si argumente në bazë të referencës së tyre. Kur i kontrollojmë objektet me operatorin për barazim strikt (`===`), ne po kontorllojmë referencën e tyre.
 
-Ne e paracaktuam vlerën e `person2` të barabartë me objektin `person`, dhe e kaluam objektin `person` si vlerë të `person1`.
+Ne e paracaktuam vlerën e  `person2` të barabartë me objektin `person`, dhe e kaluam objektin `person` si vlerë të `person1`.
 
 Kjo do të thotë që të dy vlerat kanë referencë të e njejta hapësirë memorike, dhe kështu ato janë të barabarta.
 
@@ -3438,7 +3438,7 @@ const colorConfig = {
   yellow: false,
 };
 
-const colors = ["pink", "red", "blue"];
+const colors = ['pink', 'red', 'blue'];
 
 console.log(colorConfig.colors[1]);
 ```
@@ -3467,7 +3467,7 @@ JavaScript i interpreton deklarimet. Kur përdorim notacionin me kllapa të mëd
 ###### 107. Cila është vlera e saj?
 
 ```javascript
-console.log("❤️" === "❤️");
+console.log('❤️' === '❤️');
 ```
 
 - A: `true`
@@ -3488,14 +3488,14 @@ Në prapavijë, emoji-t janë kode të veçanta. Unikodet për emoji-t e zemrës
 ###### 108. Cila nga këto metoda e modifikon array origjinal?
 
 ```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`
@@ -3520,10 +3520,10 @@ Me motodën `splice`, ne modifikojmë array origjinal duke fshirë, zëvendësua
 ###### 109. Cila është vlera e saj?
 
 ```javascript
-const food = ["🍕", "🍫", "🥑", "🍔"];
+const food = ['🍕', '🍫', '🥑', '🍔'];
 const info = { favoriteFood: food[0] };
 
-info.favoriteFood = "🍝";
+info.favoriteFood = '🍝';
 
 console.log(food);
 ```
@@ -3577,7 +3577,7 @@ const jsonArray = JSON.stringify([1, 2, 3]); // '[1, 2, 3]'
 JSON.parse(jsonArray); // [1, 2, 3]
 
 // Stringifimi i një objekti në JSON valid, pastaj parsimi i JSON stringut në një vlerë të JavaScript:
-const jsonArray = JSON.stringify({ name: "Lydia" }); // '{"name":"Lydia"}'
+const jsonArray = JSON.stringify({ name: 'Lydia' }); // '{"name":"Lydia"}'
 JSON.parse(jsonArray); // { name: 'Lydia' }
 ```
 
@@ -3589,11 +3589,11 @@ JSON.parse(jsonArray); // { name: 'Lydia' }
 ###### 111. Cila është vlera e saj?
 
 ```javascript
-let name = "Lydia";
+let name = 'Lydia';
 
 function getName() {
   console.log(name);
-  let name = "Sarah";
+  let name = 'Sarah';
 }
 
 getName();
@@ -3616,7 +3616,7 @@ Variablat me fjalën kyçe `let` (dhe `const`) ngriten (hoistoh-en), por për da
 Nëse nuk do të kishim deklaruar `name` brenda funksionit `getName`, makina e JavaScript do të kishte shikuar poshtë _zingjirit të shtrirjes_. Fusha e jashtme ka variabël të quajtur `name` me vlerë `Lydia`. Në këtë rast, do të kishte printuat `Lydia`.
 
 ```javascript
-let name = "Lydia";
+let name = 'Lydia';
 
 function getName() {
   console.log(name);
@@ -3634,11 +3634,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();
@@ -3684,7 +3684,7 @@ console.log(two.next().value); // undefined
 ###### 113. Cila është vlera e saj?
 
 ```javascript
-console.log(`${((x) => x)("I love")} to program`);
+console.log(`${(x => x)('I love')} to program`);
 ```
 
 - A: `I love to program`
@@ -3709,7 +3709,7 @@ Shprehjet brenda shablloneve literale vlerësohen së pari. Kjo do të thotë q
 ```javascript
 let config = {
   alert: setInterval(() => {
-    console.log("Alert!");
+    console.log('Alert!');
   }, 1000),
 };
 
@@ -3728,7 +3728,7 @@ config = null;
 
 Zakonisht kur i vendosim objektet të barabarta me `null`, ato objekte mirren nga _garbage collector_ pasi nuk ka më referencë për ato objekte. Megjithatë, meqenëse funksioni callback brenda `setInterval` është një funksion me shigjetë (pra i lidhur me objektin `config`), funksioni callback ende mban një referencë për objektin `config`.
 Për sa kohë ka një referencë, objekti nuk do të merret nga 'garbage collector' (menaxhuesi i memories për të u larguar).
-Meqenëse ky është një interval, vendosja e `config` në '`null` ose `delete` `config.alert` nuk do të mbledhet nga garbage-collector për intervalin, kështu që intervali do të vazhdojë të thirret.
+Meqenëse ky është një interval, vendosja e `config` në '`null` ose `delete` `config.alert` nuk do të mbledhet nga garbage-collector për  intervalin, kështu që intervali do të vazhdojë të thirret.
 Për ta hequr nga memoria duhet të e pastrojmë me `clearInterval(config.alert)`.
 Meqenëse nuk u fshi, funksioni `setInterval` callback do të vazhdojë të thirret çdo 1000ms (1s).
 
@@ -3741,16 +3741,16 @@ Meqenëse nuk u fshi, funksioni `setInterval` callback do të vazhdojë të thir
 
 ```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
@@ -3777,14 +3777,14 @@ Kur shtoni një çift çelës/vlerë duke përdorur metodën `set`, çelësi do
 
 ```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);
@@ -3843,7 +3843,7 @@ Me operatorin spread `...`, me mund të _përhapim_ iteruesit në elemente indiv
 
 ```javascript
 let num = 1;
-const list = ["🥳", "🤠", "🥰", "🤪"];
+const list = ['🥳', '🤠', '🥰', '🤪'];
 
 console.log(list[(num += 1)]);
 ```
@@ -3869,11 +3869,11 @@ Me operandin `+=`, ne po rrisim vlerën e `sum` për `1`. `num` kishte vlerën i
 
 ```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}`;
@@ -3911,10 +3911,10 @@ Me operatorin opsional të zinxhirit `?.`, nuk duhet të kontrollojmë më në m
 ###### 120. Cila është vlera e saj?
 
 ```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!`);
 }
@@ -3970,10 +3970,10 @@ Metoda `language` është metodë `setter` (vendosëse). Vendosësit nuk mbajë
 ###### 122. Cila është vlera e saj?
 
 ```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`
@@ -3998,7 +3998,7 @@ console.log(!typeof name === "string");
 ###### 123. Cila është vlera e saj?
 
 ```javascript
-const add = (x) => (y) => (z) => {
+const add = x => y => z => {
   console.log(x, y, z);
   return x + y + z;
 };
@@ -4016,7 +4016,7 @@ add(4)(5)(6);
 
 #### Përgjigja: A
 
-Funksioni `add` kthen një funksion shigjete, i cili kthen një funksion shigjete, i cili kthen një funksion shigjete. Funksioni i parë merr një argument `x` me vlerën `4`. Ne e thërrasim funksionin e dytë, i cili merr një argument `y` me vlerën `5`. Pastaj thërrasim funksionin e tretë, i cili merr një argument `z` me vlerën `6`. Kur po provojmë të qasemi në vlerën `x`, `y` dhe `z` brenda funksionit të fundit të shigjetës, makina JS shkon lart në zinxhirin e shtrirjes për të gjetur vlerat për `x` dhe `y` përkatësisht. Kjo kthen `4` `5` `6`.
+Funksioni `add` kthen një funksion shigjete, i cili kthen një funksion shigjete, i cili kthen një funksion shigjete. Funksioni i parë merr një argument `x` me vlerën `4`. Ne e thërrasim funksionin e dytë, i cili merr një argument `y` me vlerën `5`. Pastaj thërrasim funksionin e tretë, i cili merr një argument `z` me vlerën `6`. Kur po provojmë të qasemi në vlerën `x`, `y` dhe `z` brenda funksionit të fundit të shigjetës, makina  JS shkon lart në zinxhirin e shtrirjes për të gjetur vlerat për `x` dhe `y` përkatësisht. Kjo kthen `4` `5` `6`.
 
 </p>
 </details>
@@ -4088,20 +4088,20 @@ 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}`;
 }
 
-console.log(getFine(130, 300));
+console.log(getFine(130, 300))
 ```
 
 - A: The driver drove 130 and has to pay 300
@@ -4124,8 +4124,8 @@ Me metoden `Intl.NumberFormat`, ne mund të formatojmë vlerat numerike në çdo
 ###### 127. Cila është vlera e saj?
 
 ```javascript
-const spookyItems = ["👻", "🎃", "🕸"];
-({ item: spookyItems[3] } = { item: "💀" });
+const spookyItems = ['👻', '🎃', '🕸'];
+({ item: spookyItems[3] } = { item: '💀' });
 
 console.log(spookyItems);
 ```
@@ -4150,7 +4150,7 @@ Duke destrukturuar objektet, ne mund të targetojmë vlerat nga objekti i djatht
 ###### 128. Cila është vlera e saj?
 
 ```javascript
-const name = "Lydia Hallie";
+const name = 'Lydia Hallie';
 const age = 21;
 
 console.log(Number.isNaN(name));
@@ -4186,7 +4186,7 @@ const randomValue = 21;
 
 function getInfo() {
   console.log(typeof randomValue);
-  const randomValue = "Lydia Hallie";
+  const randomValue = 'Lydia Hallie';
 }
 
 getInfo();
@@ -4212,7 +4212,7 @@ Variablat e deklaruara me fjalën kyçe `const` nuk janë të referueshme para i
 ###### 130. Cila është vlera e saj?
 
 ```javascript
-const myPromise = Promise.resolve("Woah some cool data");
+const myPromise = Promise.resolve('Woah some cool data');
 
 (async () => {
   try {
@@ -4220,7 +4220,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!');
   }
 })();
 ```
@@ -4245,7 +4245,7 @@ Në bllokun `try`, ne jemi duke printuar vlerën e pritur të variablës `myProm
 ###### 131. Cila është vlera e saj?
 
 ```javascript
-const emojis = ["🥑", ["✨", "✨", ["🍕", "🍕"]]];
+const emojis = ['🥑', ['✨', '✨', ['🍕', '🍕']]];
 
 console.log(emojis.flat(1));
 ```
@@ -4318,19 +4318,19 @@ Ne thërrasim `counterTwo.increment()`, i cili vendos `count` në `3`. Pastaj, p
 ###### 133. Cila është vlera e saj?
 
 ```javascript
-const myPromise = Promise.resolve(Promise.resolve("Promise"));
+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!");
+  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!");
+  console.log(`${res} 2!`)
+  setTimeout(() => console.log('Timeout 2!'), 0);
+  console.log('Last line 2!');
 }
 
 funcOne();
@@ -4375,7 +4375,7 @@ export default function sum(x) {
 }
 
 // index.js
-import * as sum from "./sum";
+import * as sum from './sum';
 ```
 
 - A: `sum(4)`
@@ -4392,12 +4392,12 @@ Me yllin `*`, ne importojmë të gjitha vlerat e eksportuara nga ai fajll, si at
 
 ```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);
 ```
 
@@ -4428,13 +4428,13 @@ Mund të e thërrasim këtë funksion, duke thirrur `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;
 ```
 
@@ -4464,7 +4464,7 @@ Pastaj, ne i qasemi një vlerë të vetisë në objektin proxy, vetia `get` në
 ###### 136. Cili nga opsionet e mëposhtme do të modifikojë objektin `person`?
 
 ```javascript
-const person = { name: "Lydia Hallie" };
+const person = { name: 'Lydia Hallie' };
 
 Object.seal(person);
 ```
@@ -4492,9 +4492,9 @@ Megjithatë, ju ende mund të modifikoni vlerën e vetive ekzistuese.
 
 ```javascript
 const person = {
-  name: "Lydia Hallie",
+  name: 'Lydia Hallie',
   address: {
-    street: "100 Main St",
+    street: '100 Main St',
   },
 };
 
@@ -4523,7 +4523,7 @@ Megjithatë, ajo vetëm _ngrin sipërfaqësisht_ objektin, që do të thotë se
 ###### 138. Cila është vlera e saj?
 
 ```javascript
-const add = (x) => x + x;
+const add = x => x + x;
 
 function myFunc(num = 2, value = add(num)) {
   console.log(num, value);
@@ -4556,21 +4556,21 @@ Më pas, ne thirrëm `myFunc(3)` dhe kaluam vlerën `3` si vlerë për argumenti
 
 ```javascript
 class Counter {
-  #number = 10;
+  #number = 10
 
   increment() {
-    this.#number++;
+    this.#number++
   }
 
   getNum() {
-    return this.#number;
+    return this.#number
   }
 }
 
-const counter = new Counter();
-counter.increment();
+const counter = new Counter()
+counter.increment()
 
-console.log(counter.#number);
+console.log(counter.#number)
 ```
 
 - A: `10`
@@ -4594,8 +4594,8 @@ Në ES2020, mund të shtojmë variabla private në klasa duke përdorur `#`. Nuk
 
 ```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) {
@@ -4638,8 +4638,8 @@ Nëse do të shkruanim `yield`, `return yield`, ose `return`, gjithë funksioni
 
 ```javascript
 const person = {
-  name: "Lydia Hallie",
-  hobbies: ["coding"],
+  name: 'Lydia Hallie',
+  hobbies: ['coding'],
 };
 
 function addHobby(hobby, hobbies = person.hobbies) {
@@ -4647,9 +4647,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);
 ```
@@ -4718,11 +4718,11 @@ Krijojmë variablën `pet` që është një instancë e klasës `Flamingo`. Kur
 ###### 143. Cila nga opsionet rezulton me gabim?
 
 ```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;
 ```
 
@@ -4777,11 +4777,11 @@ Objektet nuk janë të paraprakisht të iterueshme. Një objekt është i iterue
 let count = 0;
 const nums = [0, 1, 2, 3];
 
-nums.forEach((num) => {
-  if (num) count += 1;
-});
+nums.forEach(num => {
+	if (num) count += 1
+})
 
-console.log(count);
+console.log(count)
 ```
 
 - A: 1
@@ -4805,12 +4805,12 @@ Kushti `if` brenda ciklit `forEach` kontrollon nëse vlera e `num` është e vë
 
 ```javascript
 function getFruit(fruits) {
-  console.log(fruits?.[1]?.[1]);
+	console.log(fruits?.[1]?.[1])
 }
 
-getFruit([["🍊", "🍌"], ["🍍"]]);
-getFruit();
-getFruit([["🍍"], ["🍊", "🍌"]]);
+getFruit([['🍊', '🍌'], ['🍍']])
+getFruit()
+getFruit([['🍍'], ['🍊', '🍌']])
 ```
 
 - A: `null`, `undefined`, 🍌
@@ -4825,7 +4825,7 @@ getFruit([["🍍"], ["🍊", "🍌"]]);
 
 Simboli ? na lejon të i qasemi opsionalisht vetive më të thella brenda objekteve. Ne po provojmë të shfaqim elementin në indeksin 1 brenda në nën-array që është në indeksin 1 të array fruits. Nëse nën-array në indeksin 1 në array fruits nuk ekziston, thjesht do të kthejë undefined. Nëse nën-array në indeksin 1 në vargun fruits ekziston, por ky nën-array nuk ka një artikull në indeksin e tij 1, gjithashtu do të kthejë undefined.
 
-Së pari, ne po përpiqemi të printojmë artikullin e dytë në nën-array `['🍍']` të `[['🍊', '🍌'], ['🍍']]`. Ky nën-array përmban vetëm një element, që do të thotë se nuk ka element në indeksin `1`, dhe kthen `undefined`.
+Së pari, ne po përpiqemi të printojmë artikullin e dytë në nën-array `['🍍']` të `[['🍊', '🍌'], ['🍍']]`. Ky nën-array përmban vetëm  një element, që do të thotë se nuk ka element në indeksin `1`, dhe kthen `undefined`.
 
 Më pas, ne po thërrasim funksionin `getFruits` pa kaluar një vlerë si argument, që do të thotë se `fruits` ka vlerë `undefined` të paracaktuar. Pasi që po lidhim në mënyrë kushtëzuese elementin në indeksin `1` të `fruits`, kthen `undefined` pasi ky element në indeksin `1` nuk ekziston.
 
@@ -4840,19 +4840,19 @@ Së fundmi, po përpiqemi të shfaqim artikullin e dytë në nën-array `['🍊'
 
 ```javascript
 class Calc {
-  constructor() {
-    this.count = 0;
-  }
+	constructor() {
+		this.count = 0 
+	}
 
-  increase() {
-    this.count++;
-  }
+	increase() {
+		this.count ++
+	}
 }
 
-const calc = new Calc();
-new Calc().increase();
+const calc = new Calc()
+new Calc().increase()
 
-console.log(calc.count);
+console.log(calc.count)
 ```
 
 - A: `0`
@@ -4876,25 +4876,25 @@ Ne i caktojmë variablës `calc` të jetë e barabartë me një instancë të re
 
 ```javascript
 const user = {
-  email: "e@mail.com",
-  password: "12345",
-};
+	email: "e@mail.com",
+	password: "12345"
+}
 
 const updateUser = ({ email, password }) => {
-  if (email) {
-    Object.assign(user, { email });
-  }
+	if (email) {
+		Object.assign(user, { email })
+	}
 
-  if (password) {
-    user.password = password;
-  }
+	if (password) {
+		user.password = password
+	}
 
-  return user;
-};
+	return user
+}
 
-const updatedUser = updateUser({ email: "new@email.com" });
+const updatedUser = updateUser({ email: "new@email.com" })
 
-console.log(updatedUser === user);
+console.log(updatedUser === user)
 ```
 
 - A: `false`
@@ -4917,13 +4917,13 @@ Funksioni `updateUser` përditëson vlerat e vetive `email` dhe `password` në u
 ###### 149. Cila është vlera e saj?
 
 ```javascript
-const fruit = ["🍌", "🍊", "🍎"];
+const fruit = ['🍌', '🍊', '🍎']
 
-fruit.slice(0, 1);
-fruit.splice(0, 1);
-fruit.unshift("🍇");
+fruit.slice(0, 1)
+fruit.splice(0, 1)
+fruit.unshift('🍇')
 
-console.log(fruit);
+console.log(fruit)
 ```
 
 - A: `['🍌', '🍊', '🍎']`
@@ -4949,13 +4949,13 @@ Në fund, ne thirrim metodën `unshift` në array e frutave, e cila modifikon ar
 
 ```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]);
+console.log(animals[dog])
 ```
 
 - A: `{ emoji: "🐶", name: "Mara" }`
@@ -4985,14 +4985,14 @@ Duke printuar `animals[dog]`, ose në fakt `animals["object Object"]` pasi që k
 
 ```javascript
 const user = {
-  email: "my@email.com",
-  updateEmail: (email) => {
-    this.email = email;
-  },
-};
+	email: "my@email.com",
+	updateEmail: email => {
+		this.email = email
+	}
+}
 
-user.updateEmail("new@email.com");
-console.log(user.email);
+user.updateEmail("new@email.com")
+console.log(user.email)
 ```
 
 - A: `my@email.com`
@@ -5015,20 +5015,20 @@ Funksioni `updateEmail` është një funksion shigjetë dhe nuk është i lidhur
 ###### 152. Cila është vlera e saj?
 
 ```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]);
-  const res2 = await Promise.all([promise3, promise4]);
-  return [res1, res2];
-};
+	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));
+	.then(res => console.log(res))
+	.catch(err => console.log(err))
 ```
 
 - A: `[['First', 'Second'], ['Fourth']]`
@@ -5051,16 +5051,13 @@ Metoda `Promise.all` ekzekuton premtimet e dhëna si argumente paralelisht. Nës
 ###### 153. Cila duhet të jetë vlera e `method` për të printuar `{ name: "Lydia", age: 22 }`?
 
 ```javascript
-const keys = ["name", "age"];
-const values = ["Lydia", 22];
+const keys = ["name", "age"]
+const values = ["Lydia", 22]
 
-const method =
-  /* ?? */
-  Object[method](
-    keys.map((_, i) => {
-      return [keys[i], values[i]];
-    })
-  ); // { name: "Lydia", age: 22 }
+const method = /* ?? */
+Object[method](keys.map((_, i) => {
+	return [keys[i], values[i]]
+})) // { name: "Lydia", age: 22 }
 ```
 
 - A: `entries`
@@ -5073,7 +5070,7 @@ const method =
 
 #### Përgjigja: C
 
-Metoda `fromEntries` transformon një array 2d në një objekt. Elementi i parë në çdo nën-array do të jetë çelësi, dhe elementi i dytë në çdo nën-array do të jetë vlera. Në këtë rast, ne jemi duke mapuar mbi array `keys`, i cili kthen një array ku elementi i parë është elementi në array të çelësave në indeksin aktual, dhe elementi i dytë është elementi i vlerave të array në indeksin aktual.
+Metoda `fromEntries` transformon një array 2d në një objekt. Elementi i parë në çdo nën-array do të jetë çelësi, dhe elementi i dytë në çdo nën-array do të jetë vlera. Në këtë rast, ne jemi duke mapuar mbi array `keys`, i cili kthen një array ku elementi i parë është elementi në array të çelësave në indeksin aktual, dhe elementi i dytë është elementi i vlerave të array  në indeksin aktual.
 
 Kjo krijon një array të nën-arrays që përmbajnë çelësat dhe vlerat e duhura, të cilat rezultojnë në `{ name: "Lydia", age: 22 }`
 
@@ -5085,18 +5082,18 @@ Kjo krijon një array të nën-arrays që përmbajnë çelësat dhe vlerat e duh
 ###### 154. Cila është vlera e saj?
 
 ```javascript
-const createMember = ({ email, address = {} }) => {
-  const validEmail = /.+\@.+\..+/.test(email);
-  if (!validEmail) throw new Error("Valid email pls");
+const createMember = ({ email, address = {}}) => {
+	const validEmail = /.+\@.+\..+/.test(email)
+	if (!validEmail) throw new Error("Valid email pls")
 
-  return {
-    email,
-    address: address ? address : null,
-  };
-};
+	return {
+		email,
+		address: address ? address : null
+	}
+}
 
-const member = createMember({ email: "my@email.com" });
-console.log(member);
+const member = createMember({ email: "my@email.com" })
+console.log(member)
 ```
 
 - A: `{ email: "my@email.com", address: null }`
@@ -5119,13 +5116,13 @@ Vlera e paracaktuar e `address` është një objekt i zbrazët `{}`. Kur vendos
 ###### 155. Cila është vlera e saj?
 
 ```javascript
-let randomValue = { name: "Lydia" };
-randomValue = 23;
+let randomValue = { name: "Lydia" }
+randomValue = 23
 
 if (!typeof randomValue === "string") {
-  console.log("It's not a string!");
+	console.log("It's not a string!")
 } else {
-  console.log("Yay it's a string!");
+	console.log("Yay it's a string!")
 }
 ```
 
diff --git a/th-TH/README.md b/th-TH/README.md
index edcb70ce..22550eb2 100644
--- a/th-TH/README.md
+++ b/th-TH/README.md
@@ -16,8 +16,8 @@
 
 </div>
 
-ลิสต์ภาษาอื่นๆ:
 
+ลิสต์ภาษาอื่นๆ:
 - [🇸🇦 العربية](../ar-AR/README_AR.md)
 - [🇪🇬 اللغة العامية](../ar-EG/README_ar-EG.md)
 - [🇧🇦 Bosanski](../bs-BS/README-bs_BS.md)
@@ -32,7 +32,6 @@
 - [🇳🇱 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)
 - [🇹🇷 Türkçe](../tr-TR/README-tr_TR.md)
@@ -41,6 +40,7 @@
 - [🇨🇳 简体中文](../zh-CN/README-zh_CN.md)
 - [🇹🇼 繁體中文](../zh-TW/README_zh-TW.md)
 
+
 ---
 
 ###### 1. ผลลัพธ์ที่ได้คืออะไร?
@@ -113,7 +113,7 @@ const shape = {
   diameter() {
     return this.radius * 2;
   },
-  perimeter: () => 2 * Math.PI * this.radius,
+  perimeter: () => 2 * Math.PI * this.radius
 };
 
 console.log(shape.diameter());
@@ -170,12 +170,12 @@ String `'Lydia'` เป็นค่าความจริง สิ่งท
 
 ```javascript
 const bird = {
-  size: "small",
+  size: "small"
 };
 
 const mouse = {
   name: "Mickey",
-  small: true,
+  small: true
 };
 ```
 
@@ -202,6 +202,7 @@ JavaScript interprets (or unboxes) statements. เมื่อเราใช้
 
 ---
 
+
 ###### 6. ผลลัพธ์ที่ได้คืออะไร?
 
 ```javascript
@@ -369,7 +370,7 @@ function Person(firstName, lastName) {
 }
 
 const member = new Person("Lydia", "Hallie");
-Person.getFullName = function () {
+Person.getFullName = function() {
   return `${this.firstName} ${this.lastName}`;
 };
 
@@ -389,7 +390,7 @@ console.log(member.getFullName());
 You can't add properties to a constructor like you can with regular objects. If you want to add a feature to all objects at once, you have to use the prototype instead. So in this case,
 
 ```js
-Person.prototype.getFullName = function () {
+Person.prototype.getFullName = function() {
   return `${this.firstName} ${this.lastName}`;
 };
 ```
@@ -845,7 +846,7 @@ String.prototype.giveLydiaPizza = () => {
 
 const name = "Lydia";
 
-console.log(name.giveLydiaPizza());
+console.log(name.giveLydiaPizza())
 ```
 
 - A: `"Just give Lydia pizza already!"`
@@ -957,7 +958,9 @@ This is where an event loop starts to work. An **event loop** looks at the stack
 ```html
 <div onclick="console.log('first div')">
   <div onclick="console.log('second div')">
-    <button onclick="console.log('button')">Click!</button>
+    <button onclick="console.log('button')">
+      Click!
+    </button>
   </div>
 </div>
 ```
@@ -983,7 +986,9 @@ The deepest nested element that caused the event is the target of the event. You
 
 ```html
 <div onclick="console.log('div')">
-  <p onclick="console.log('p')">Click here!</p>
+  <p onclick="console.log('p')">
+    Click here!
+  </p>
 </div>
 ```
 
@@ -1059,7 +1064,6 @@ console.log(typeof sayHi());
 The `sayHi` function returns the returned value of the immediately invoked function (IIFE). This function returned `0`, which is type `"number"`.
 
 FYI: there are only 7 built-in types: `null`, `undefined`, `boolean`, `number`, `string`, `object`, `symbol`, และ `bigint`. `"function"` is not a type, since functions are objects, it's of type `"object"`.
-
 </p>
 </details>
 
@@ -1218,10 +1222,7 @@ What differentiates a primitive from an object is that primitives do not have an
 ###### 40. ผลลัพธ์ที่ได้คืออะไร?
 
 ```javascript
-[
-  [0, 1],
-  [2, 3],
-].reduce(
+[[0, 1], [2, 3]].reduce(
   (acc, cur) => {
     return acc.concat(cur);
   },
@@ -1369,7 +1370,7 @@ const secondPromise = new Promise((res, rej) => {
   setTimeout(res, 100, "two");
 });
 
-Promise.race([firstPromise, secondPromise]).then((res) => console.log(res));
+Promise.race([firstPromise, secondPromise]).then(res => console.log(res));
 ```
 
 - A: `"one"`
@@ -1433,7 +1434,7 @@ We are only modifying the value of the `person` variable, and not the first elem
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21,
+  age: 21
 };
 
 for (const item in person) {
@@ -1513,7 +1514,7 @@ Only the first numbers in the string is returned. Based on the _radix_ (the seco
 ###### 50. ผลลัพธ์ที่ได้คืออะไร?
 
 ```javascript
-[1, 2, 3].map((num) => {
+[1, 2, 3].map(num => {
   if (typeof num === "number") return;
   return num * 2;
 });
@@ -1690,7 +1691,7 @@ class Dog {
   }
 }
 
-Dog.prototype.bark = function () {
+Dog.prototype.bark = function() {
   console.log(`Woof I am ${this.name}`);
 };
 
@@ -1918,7 +1919,7 @@ Properties added using the `defineProperty` method are immutable by default. You
 const settings = {
   username: "lydiahallie",
   level: 19,
-  health: 90,
+  health: 90
 };
 
 const data = JSON.stringify(settings, ["level", "health"]);
@@ -1952,7 +1953,7 @@ If the replacer is a _function_, this function gets called on every property in
 let num = 10;
 
 const increaseNumber = () => num++;
-const increasePassedNumber = (number) => number++;
+const increasePassedNumber = number => number++;
 
 const num1 = increaseNumber();
 const num2 = increasePassedNumber(num1);
@@ -2009,9 +2010,9 @@ In ES6, we can initialize parameters with a default value. The value of the para
 
 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 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`.
+The fourth time, we pass the `value` object again. `x.number` was previously modified to `20`, so `x.number *= 2` logs `40`. 
 
 </p>
 </details>
@@ -2034,18 +2035,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.
+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 current value: `1` และ `2` get logged.
+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 current value: `1` และ `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` และ `3` 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` และ `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` และ `4` get logged.
-
 </p>
 </details>
   
@@ -2061,7 +2061,7 @@ class Dog {
 };
 
 class Labrador extends Dog {
-  // 1
+  // 1 
   constructor(name, size) {
     this.size = size;
   }
@@ -2075,7 +2075,7 @@ class Labrador extends Dog {
     super(name);
     this.size = size;
   }
-  // 4
+  // 4 
   constructor(name, size) {
     this.name = name;
     this.size = size;
@@ -2096,10 +2096,9 @@ class Labrador extends Dog {
 
 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`, และ `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.
+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`, และ `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>
 
@@ -2109,12 +2108,12 @@ The `Labrador` class receives two arguments, `name` since it 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;
 ```
 
@@ -2130,7 +2129,7 @@ export const sum = (a, b) => a + b;
 
 With the `import` keyword, all imported modules are _pre-parsed_. This means that the imported modules get run _first_, the code in the file which 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 would have used `require` instead of `import`, `running index.js`, `running sum.js`, `3` would have been logged to the console.
+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 would have used `require` instead of `import`, `running index.js`, `running sum.js`, `3` would have been logged to the console. 
 
 </p>
 </details>
@@ -2140,9 +2139,9 @@ This is a difference between `require()` in CommonJS and `import`! With `require
 ###### 68. ผลลัพธ์ที่ได้คืออะไร?
 
 ```javascript
-console.log(Number(2) === Number(2));
-console.log(Boolean(false) === Boolean(false));
-console.log(Symbol("foo") === Symbol("foo"));
+console.log(Number(2) === Number(2))
+console.log(Boolean(false) === Boolean(false))
+console.log(Symbol('foo') === Symbol('foo'))
 ```
 
 - A: `true`, `true`, `false`
@@ -2155,7 +2154,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`.
+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>
@@ -2165,15 +2164,15 @@ Every Symbol is entirely unique. The purpose of the argument passed to the Symbo
 ###### 69. ผลลัพธ์ที่ได้คืออะไร?
 
 ```javascript
-const name = "Lydia Hallie";
-console.log(name.padStart(13));
-console.log(name.padStart(2));
+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"`,
+- D: `"Lydia Hallie"`, `"Lyd"`, 
 
 <details><summary><b>คำตอบ</b></summary>
 <p>
@@ -2441,7 +2440,7 @@ The `sum` function always returns the same result. If we pass `1` และ `2`,
 ```javascript
 const add = () => {
   const cache = {};
-  return (num) => {
+  return num => {
     if (num in cache) {
       return `From cache! ${cache[num]}`;
     } else {
@@ -2486,21 +2485,21 @@ The third time, we pass `5 * 2` to the function which gets evaluated to `10`. Th
 ###### 79. ผลลัพธ์ที่ได้คืออะไร?
 
 ```javascript
-const myLifeSummedUp = ["☕", "💻", "🍷", "🍫"];
+const myLifeSummedUp = ["☕", "💻", "🍷", "🍫"]
 
 for (let item in myLifeSummedUp) {
-  console.log(item);
+  console.log(item)
 }
 
 for (let item of myLifeSummedUp) {
-  console.log(item);
+  console.log(item)
 }
 ```
 
 - A: `0` `1` `2` `3` และ `"☕"` ` "💻"` `"🍷"` `"🍫"`
 - B: `"☕"` ` "💻"` `"🍷"` `"🍫"` และ `"☕"` ` "💻"` `"🍷"` `"🍫"`
 - C: `"☕"` ` "💻"` `"🍷"` `"🍫"` และ `0` `1` `2` `3`
-- D: `0` `1` `2` `3` และ `{0: "☕", 1: "💻", 2: "🍷", 3: "🍫"}`
+- D:  `0` `1` `2` `3` และ `{0: "☕", 1: "💻", 2: "🍷", 3: "🍫"}`
 
 <details><summary><b>คำตอบ</b></summary>
 <p>
@@ -2523,14 +2522,14 @@ With a _for-of_ loop, we can iterate over **iterables**. An array is an iterable
 ###### 80. ผลลัพธ์ที่ได้คืออะไร?
 
 ```javascript
-const list = [1 + 2, 1 * 2, 1 / 2];
-console.log(list);
+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]`
+- D:  `[1, 1, 1]`
 
 <details><summary><b>คำตอบ</b></summary>
 <p>
@@ -2539,7 +2538,7 @@ console.log(list);
 
 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`, และ `1 / 2` returns `0.5`.
+The element will be equal to the returned value.  `1 + 2` returns `3`, `1 * 2` returns `2`, และ `1 / 2` returns `0.5`.
 
 </p>
 </details>
@@ -2550,16 +2549,16 @@ The element will be equal to the returned value. `1 + 2` returns `3`, `1 * 2` re
 
 ```javascript
 function sayHi(name) {
-  return `Hi there, ${name}`;
+  return `Hi there, ${name}`
 }
 
-console.log(sayHi());
+console.log(sayHi())
 ```
 
 - A: `Hi there, `
 - B: `Hi there, undefined`
 - C: `Hi there, null`
-- D: `ReferenceError`
+- D:  `ReferenceError`
 
 <details><summary><b>คำตอบ</b></summary>
 <p>
@@ -2582,21 +2581,21 @@ In this case, if we didn't pass a value or if we passed `undefined`, `name` woul
 ###### 82. ผลลัพธ์ที่ได้คืออะไร?
 
 ```javascript
-var status = "😎";
+var status = "😎"
 
 setTimeout(() => {
-  const status = "😍";
+  const status = "😍"
 
   const data = {
     status: "🥑",
     getStatus() {
-      return this.status;
-    },
-  };
+      return this.status
+    }
+  }
 
-  console.log(data.getStatus());
-  console.log(data.getStatus.call(this));
-}, 0);
+  console.log(data.getStatus())
+  console.log(data.getStatus.call(this))
+}, 0)
 ```
 
 - A: `"🥑"` และ `"😍"`
@@ -2613,6 +2612,7 @@ The value of the `this` keyword is dependent on where you use it. In a **method*
 
 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>
 
@@ -2623,13 +2623,13 @@ With the `call` method, we can change the object to which the `this` keyword ref
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21,
-};
+  age: 21
+}
 
-let city = person.city;
-city = "Amsterdam";
+let city = person.city
+city = "Amsterdam"
 
-console.log(person);
+console.log(person)
 ```
 
 - A: `{ name: "Lydia", age: 21 }`
@@ -2642,13 +2642,13 @@ 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`.
+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.
+When logging the `person` object, the unmodified object gets returned. 
 
 </p>
 </details>
@@ -2660,15 +2660,15 @@ When logging the `person` object, the unmodified object gets returned.
 ```javascript
 function checkAge(age) {
   if (age < 18) {
-    const message = "Sorry, you're too young.";
+    const message = "Sorry, you're too young."
   } else {
-    const message = "Yay! You're old enough!";
+    const message = "Yay! You're old enough!"
   }
 
-  return message;
+  return message
 }
 
-console.log(checkAge(21));
+console.log(checkAge(21))
 ```
 
 - A: `"Sorry, you're too young."`
@@ -2691,15 +2691,15 @@ Variables with the `const` และ `let` keyword are _block-scoped_. A block i
 ###### 85. ข้อมูลแบบไหนที่เราได้ใน log?
 
 ```javascript
-fetch("https://www.website.com/api/user/1")
-  .then((res) => res.json())
-  .then((res) => console.log(res));
+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.
+- D: It would always be undefined. 
 
 <details><summary><b>คำตอบ</b></summary>
 <p>
@@ -2747,7 +2747,7 @@ By setting `hasName` equal to `name`, you set `hasName` equal to whatever value
 ###### <a name=20190805></a>87. ผลลัพธ์ที่ได้คืออะไร?
 
 ```javascript
-console.log("I want pizza"[0]);
+console.log("I want pizza"[0])
 ```
 
 - A: `"""`
@@ -2773,10 +2773,10 @@ Note that this method is not supported in IE7 and below. In that case, use `.cha
 
 ```javascript
 function sum(num1, num2 = num1) {
-  console.log(num1 + num2);
+  console.log(num1 + num2)
 }
 
-sum(10);
+sum(10)
 ```
 
 - A: `NaN`
@@ -2789,9 +2789,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`.
+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 which is defined _after_ (to the right), the parameter's value hasn't been initialized yet, which will throw an error.
+If you're trying to set a default parameter's value equal to a parameter which is defined _after_ (to the right), the parameter's value hasn't been initialized yet, which will throw an error. 
 
 </p>
 </details>
@@ -2801,14 +2801,14 @@ If you're trying to set a default parameter's value equal to a parameter which i
 ###### 89. ผลลัพธ์ที่ได้คืออะไร?
 
 ```javascript
-// module.js
-export default () => "Hello world";
-export const name = "Lydia";
+// module.js 
+export default () => "Hello world"
+export const name = "Lydia"
 
-// index.js
-import * as data from "./module";
+// index.js 
+import * as data from "./module"
 
-console.log(data);
+console.log(data)
 ```
 
 - A: `{ default: function default(), name: "Lydia" }`
@@ -2821,9 +2821,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 which returns the string `"Hello World"`, and the named export is a variable called `name` which has the value of the string `"Lydia"`.
+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 which 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.
+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>
@@ -2835,12 +2835,12 @@ The `data` object has a `default` property for the default export, other propert
 ```javascript
 class Person {
   constructor(name) {
-    this.name = name;
+    this.name = name
   }
 }
 
-const member = new Person("John");
-console.log(typeof member);
+const member = new Person("John")
+console.log(typeof member)
 ```
 
 - A: `"class"`
@@ -2857,11 +2857,11 @@ Classes are syntactical sugar for function constructors. The equivalent of the `
 
 ```javascript
 function Person() {
-  this.name = 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"`.
+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>
@@ -2871,9 +2871,9 @@ Calling a function constructor with `new` results in the creation of an instance
 ###### 91. ผลลัพธ์ที่ได้คืออะไร?
 
 ```javascript
-let newList = [1, 2, 3].push(4);
+let newList = [1, 2, 3].push(4)
 
-console.log(newList.push(5));
+console.log(newList.push(5))
 ```
 
 - A: `[1, 2, 3, 4, 5]`
@@ -2886,7 +2886,7 @@ 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`.
+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.
 
@@ -2899,18 +2899,17 @@ 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 = () =>
-  "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);
+console.log(giveLydiaPizza.prototype)
+console.log(giveLydiaChocolate.prototype)
 ```
 
-- A: `{ constructor: ...}` `{ constructor: ...}`
-- B: `{}` `{ constructor: ...}`
+- A: `{ constructor: ...}` `{ constructor: ...}` 
+- B: `{}` `{ constructor: ...}` 
 - C: `{ constructor: ...}` `{}`
 - D: `{ constructor: ...}` `undefined`
 
@@ -2919,7 +2918,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`.
+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>
@@ -2931,16 +2930,16 @@ Regular functions, such as the `giveLydiaPizza` function, have a `prototype` pro
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21,
-};
+  age: 21
+}
 
 for (const [x, y] of Object.entries(person)) {
-  console.log(x, y);
+  console.log(x, y)
 }
 ```
 
 - A: `name` `Lydia` และ `age` `21`
-- B: `["name", "Lydia"]` และ `["age", 21]`
+- B: `["name", "Lydia"]` และ `["age", 21]` 
 - C: `["name", "age"]` และ `undefined`
 - D: `Error`
 
@@ -2951,9 +2950,9 @@ for (const [x, y] of Object.entries(person)) {
 
 `Object.entries(person)` returns an array of nested arrays, containing the keys and objects:
 
-`[ [ 'name', 'Lydia' ], [ 'age', 21 ] ]`
+`[ [ '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.
+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"`, และ `y` equal to `"Lydia"`, which get logged.
 The second subarray is `[ "age", 21 ]`, with `x` equal to `"age"`, และ `y` equal to `21`, which get logged.
@@ -2974,7 +2973,7 @@ getItems(["banana", "apple"], "pear", "orange")
 ```
 
 - A: `["banana", "apple", "pear", "orange"]`
-- B: `[["banana", "apple"], "pear", "orange"]`
+- B: `[["banana", "apple"], "pear", "orange"]` 
 - C: `["banana", "apple", ["pear"], "orange"]`
 - D: `SyntaxError`
 
@@ -2983,18 +2982,17 @@ 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` 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];
+  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' ]`
-
 </p>
 </details>
 
@@ -3004,14 +3002,17 @@ 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");
-  return;
-  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));
+console.log(nums(4, 2))
+console.log(nums(1, 2))
 ```
 
 - A: `a is bigger`, `6` และ `b is bigger`, `3`
@@ -3024,13 +3025,13 @@ 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.
+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;
+  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!
@@ -3045,18 +3046,18 @@ 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"
   }
-};
+}
 
-const member = new Person();
-console.log(member.name);
+const member = new Person()
+console.log(member.name)
 ```
 
 - A: `"Lydia"`
@@ -3080,11 +3081,11 @@ 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);
-console.log(Object.keys(info));
+console.log(info)
+console.log(Object.keys(info))
 ```
 
 - A: `{Symbol('a'): 'b'}` และ `["{Symbol('a')"]`
@@ -3131,13 +3132,13 @@ console.log(getUser(user))
 
 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]`
+ `[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` และ `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.
+ With the rest parameter `...y`, we put all "remaining" arguments in an array. The remaining arguments are `2`, `3` และ `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 return an _object_ from an arrow function, you have to write it between parentheses, otherwise no value gets returned! The following function would have returned an object:
+ 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 return an _object_ from an arrow function, you have to write it between parentheses, otherwise no value gets returned! The following function would have returned an object:
 
-`const getUser = user => ({ name: user.name, age: user.age })`
+```const getUser = user => ({ name: user.name, age: user.age })```
 
 Since no value gets returned in this case, the function returns `undefined`.
 
@@ -3149,9 +3150,9 @@ Since no value gets returned in this case, the function returns `undefined`.
 ###### 99. ผลลัพธ์ที่ได้คืออะไร?
 
 ```javascript
-const name = "Lydia";
+const name = "Lydia"
 
-console.log(name());
+console.log(name())
 ```
 
 - A: `SyntaxError`
@@ -3164,11 +3165,11 @@ console.log(name());
 
 #### คำตอบ: C
 
-The variable `name` holds the value of a string, which is not a function, thus cannot invoke.
+The variable `name` holds the value of a string, which is not a function, thus cannot invoke. 
 
 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`.
+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>
@@ -3181,8 +3182,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`
@@ -3207,11 +3208,11 @@ You should${"" && `n't`} see a therapist after so much JavaScript lol`;
 ###### 101. ผลลัพธ์ที่ได้คืออะไร?
 
 ```javascript
-const one = false || {} || null;
-const two = null || false || "";
-const three = [] || 0 || true;
+const one = (false || {} || null)
+const two = (null || false || "")
+const three = ([] || 0 || true)
 
-console.log(one, two, three);
+console.log(one, two, three)
 ```
 
 - A: `false` `null` `[]`
@@ -3240,20 +3241,20 @@ With the `||` operator, we can return the first truthy operand. If all values ar
 ###### 102. <a name=20190927></a>ผลลัพธ์ที่ได้คืออะไร?
 
 ```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");
+  myPromise().then(res => console.log(res))
+  console.log('second')
 }
 
 async function secondFunction() {
-  console.log(await myPromise());
-  console.log("second");
+  console.log(await myPromise())
+  console.log('second')
 }
 
-firstFunction();
-secondFunction();
+firstFunction()
+secondFunction()
 ```
 
 - A: `I have resolved!`, `second` และ `I have resolved!`, `second`
@@ -3268,13 +3269,13 @@ secondFunction();
 
 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` keyword in an `async` function. Although we can get a promise's value with both `.then` และ `await`, they work a bit differently.
+We can get this value with both `.then` and the `await` keyword in an `async` function. Although we can get a promise's value with both `.then` และ `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.
+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.
+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>
@@ -3284,14 +3285,14 @@ This means that it waited for the `myPromise` to resolve with the value `I have
 ###### 103. ผลลัพธ์ที่ได้คืออะไร?
 
 ```javascript
-const set = new Set();
+const set = new Set()
 
-set.add(1);
-set.add("Lydia");
-set.add({ name: "Lydia" });
+set.add(1)
+set.add("Lydia")
+set.add({ name: "Lydia" })
 
 for (let item of set) {
-  console.log(item + 2);
+  console.log(item + 2)
 }
 ```
 
@@ -3305,11 +3306,11 @@ for (let item of set) {
 
 #### คำตอบ: C
 
-The `+` operator is not only used for adding numerica lvalues, 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 `+` operator is not only used for adding numerica lvalues, 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"` และ `"2"` get concatenated, whic hresults in the string `"Lydia2"`.
+However, the second one is a string `"Lydia"`. `"Lydia"` is a string and `2` is a number: `2` gets coerced into a string. `"Lydia"` และ `"2"` get concatenated, whic hresults 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"`.
 
@@ -3321,7 +3322,7 @@ However, the second one is a string `"Lydia"`. `"Lydia"` is a string and `2` is
 ###### 104. ผลลัพธ์ที่ได้คืออะไร?
 
 ```javascript
-Promise.resolve(5);
+Promise.resolve(5)
 ```
 
 - A: `5`
@@ -3336,7 +3337,7 @@ Promise.resolve(5);
 
 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`.
+In this case, we just passed the numerical value `5`. It returns a resolved promise with the value `5`. 
 
 </p>
 </details>
@@ -3348,15 +3349,15 @@ 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);
+compareMembers(person)
 ```
 
 - A: `Not the same!`
@@ -3369,13 +3370,13 @@ compareMembers(person);
 
 #### คำตอบ: B
 
-Objects are passed by reference. When we check objects for strict equality (`===`), we're comparing their references.
+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.
+The code block in the `else` statement gets run, and `They are the same!` gets logged. 
 
 </p>
 </details>
@@ -3391,11 +3392,11 @@ const colorConfig = {
   green: true,
   black: true,
   yellow: false,
-};
+}
 
-const colors = ["pink", "red", "blue"];
+const colors = ["pink", "red", "blue"]
 
-console.log(colorConfig.colors[1]);
+console.log(colorConfig.colors[1])
 ```
 
 - A: `true`
@@ -3408,11 +3409,11 @@ 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"]`).
+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 proprety called `colorConfig`, 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.
+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>
@@ -3422,7 +3423,7 @@ JavaScript interprets (or unboxes) statements. When we use bracket notation, it
 ###### 107. ผลลัพธ์ที่ได้คืออะไร?
 
 ```javascript
-console.log("❤️" === "❤️");
+console.log('❤️' === '❤️')
 ```
 
 - A: `true`
@@ -3433,7 +3434,7 @@ 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.
+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>
@@ -3443,19 +3444,19 @@ 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`
 - B: `map` `reduce` `slice` `splice`
-- C: `map` `slice` `splice`
+- C: `map` `slice` `splice` 
 - D: `splice`
 
 <details><summary><b>คำตอบ</b></summary>
@@ -3463,7 +3464,7 @@ 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 added the ✨ emoji instead.
+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 added the ✨ emoji instead. 
 
 `map`, `filter` และ `slice` return a new array, `find` returns an element, and `reduce` returns a reduced value.
 
diff --git a/tr-TR/README-tr_TR.md b/tr-TR/README-tr_TR.md
index f1abe649..e34ae66b 100644
--- a/tr-TR/README-tr_TR.md
+++ b/tr-TR/README-tr_TR.md
@@ -9,6 +9,7 @@ Cevaplar, soruların altında gizlenmiştir. Görmek için sadece tıklayın. İ
 Daha fazla soru eklendikçe eposta almak ister misiniz?<br />
 <a target="_blank" href="https://www.theavocoder.com/subscribe"><b>✨✉Eposta bildirimlerine abone olun✉✨</b></a>
 
+
 Mevcut dillerin listesi:
 
 - [🇸🇦 العربية](../ar-AR/README_AR.md)
@@ -25,7 +26,6 @@ Mevcut dillerin listesi:
 - [🇳🇱 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)
@@ -60,9 +60,8 @@ sayHi();
 #### Cevap: D
 
 Fonksiyonun içinde, önce `var` anahtar kelimesi ile `name` değişkenini tanımladık. Bu demektir ki, değişken varsayılan değeri olan `undefined` ile "hoisting" (hafızada alan oluşturma aşaması) olur, ta ki gerçekten değişkene değer ataması yaptığımız satıra varana dek. `name` değişkenini loglayama çalıştığımız satırda henüz değişkeni tanımlamadık, bu yüzden hala `undefined` değerini saklıyor.
-
+ 
 `let` (ve `const`) anahtar kelimelerine sahip değişkenler de "hoisted" olur, ama `var`'ın aksine <i>ilk değer ataması</i> yapılmaz. Değişkenleri tanımladığımız (ilk değer ataması yaptığımız) satırdan önce erişilebilir değillerdir. Bu, "geçici ölü alan / geçici değişmez çıktı alanı", "temporal dead zone", olarak adlandırılır. Değişkenlere, tanımlanmadan önce erişmeye çalıştığımız zaman, Javascript `ReferenceError` hatası fırlatır.
-
 </p>
 </details>
 
@@ -92,7 +91,6 @@ for (let i = 0; i < 3; i++) {
 Javascript'deki olay kuyruğundan dolayı, `setTimeout` callback fonksiyonu, döngü uygulandıktan _sonra_ çağrılır. `i` değişkeni, ilk döngü sırasında `var` anahtar kelimesi ile tanımlandığından, bu değişken globaldir. Döngü boyunca, `++` unary operatörünü kullanarak, `i`'nin değerini her seferinde `1` arttırdık. İlk örnekte, `setTimeout` callback fonksiyonu çağrıldığı zaman, `i`'nin değeri `3`'e eşitti.
 
 İkinci döngüde, `i` değişkeni `let` anahtar kelimesi kullanılarak tanımlandı: `let` (ve `const`) ile tanımlanan değişkenler "block-scope"dur (block `{}` arasındaki herhangi bir şeydir). Her bir tekrarda, `i` yeni değere sahip olacak ve her değer döngü içinde "scoped" olacak.
-
 </p>
 </details>
 
@@ -106,7 +104,7 @@ const shape = {
   diameter() {
     return this.radius * 2;
   },
-  perimeter: () => 2 * Math.PI * this.radius,
+  perimeter: () => 2 * Math.PI * this.radius
 };
 
 console.log(shape.diameter());
@@ -127,7 +125,7 @@ console.log(shape.perimeter());
 
 Arrow fonksiyonlarda, `this` anahtar kelimesi, sıradan fonksiyonların aksine, kendi sardığı mevcut scope'u referans alır. Bu demektir ki, `perimeter`'i çağırdığımız zaman, `shape` objesini değil, kendi sardığı scope'u referans alıyor (örneğin window).
 
-Bu objede, `radius` değeri olmadığından `undefined` döndürüyor.
+Bu objede, `radius` değeri olmadığından `undefined` döndürüyor. 
 
 </p>
 </details>
@@ -152,8 +150,7 @@ Bu objede, `radius` değeri olmadığından `undefined` döndürüyor.
 
 Artı (unary plus), işlemeye çalıştığı değişkeni sayıya çevirmeye çalışır. `true` `1` ve `false` `0` demektir.
 
-`'Lydia'` harf dizisi doğrusal ("truthy") bir değerdir. Aslında sorduğumuz şey, "bu doğrusal değer yanlış-ımsı ("falsy") mı?". Bu da `false` döndürür.
-
+`'Lydia'` harf dizisi doğrusal ("truthy") bir değerdir. Aslında sorduğumuz şey, "bu doğrusal değer yanlış-ımsı ("falsy") mı?". Bu da `false` döndürür. 
 </p>
 </details>
 
@@ -163,12 +160,12 @@ Artı (unary plus), işlemeye çalıştığı değişkeni sayıya çevirmeye ça
 
 ```javascript
 const bird = {
-  size: "small",
+  size: "small"
 };
 
 const mouse = {
   name: "Mickey",
-  small: true,
+  small: true
 };
 ```
 
@@ -189,12 +186,12 @@ Javascript, ifadeleri yorumlar (ya da açar ("unboxes")). Köşeli parentez nota
 `mouse[bird.size]`: Önce `bird.size` çalıştırılır, o da `"small"` demektir. `mouse["small"]`, `true` döndürür.
 
 Ancak, nokta notasyonunda bu gerçekleşmez. `mouse`, `bird` diye bir keye sahip değildir ki bu da `mouse.bird`, `undefined` demektir. Sonra, nokta notasyonunu kullanarak `size`'a ulaşmak istiyoruz: `mouse.bird.size`. `mouse.bird`, `undefined` olduğundan, aslında ulaşmaya çalıştığımız `undefined.size`. Bu geçerli değil ve `Cannot read property "size" of undefined`'a benzer bir hata fırlatacaktır.
-
 </p>
 </details>
 
 ---
 
+
 ###### 6. Çıktısı Nedir?
 
 ```javascript
@@ -256,7 +253,6 @@ console.log(b === c);
 `==` operatörünü kullandığımız zaman, sadece aynı _değer_'e sahip olup olmadığını kontrol eder. İkisi de `3` değerine sahip, yani `true` döndürür.
 
 Ancak, `===` kullandığımız zaman değer _ve_ tip aynı olmalıdır. Öyle değil: `new Number()`, sayı ("number") değildir, **nesne**dir. İkisi de `false` döndürür.
-
 </p>
 </details>
 
@@ -291,7 +287,6 @@ console.log(freddie.colorChange("orange"));
 #### Cevap: D
 
 `colorChange` fonksiyonu statiktir. Statik methodlar, sadece oluşturuldukları kurucuda var olmak için tasarlanmıştır ve herhangi bir "children"a aktarılamaz. `freddie`, "child" olduğundan, fonksiyon aktarılmadı ve `freddie` üzerinden erişilebilir değil: `TypeError` hatası fırlatılır.
-
 </p>
 </details>
 
@@ -317,7 +312,6 @@ console.log(greetign);
 Nesneyi loglar çünkü global nesne üzerinde boş bir nesne oluşturduk. `greeting`'i `greetign` olarak yanlış yazdığımız zaman, JS yorumlayıcısı bunu `global.greetign = {}` olarak gördü (ya da tarayıcı içinde `window.greetign = {}`).
 
 Bundan kaçınmak için, `"use strict"` kullanabiliriz. Bu, bir değişkene herhangi bir atama yapmadan önce tanımladığınızdan emin olmanızı sağlar.
-
 </p>
 </details>
 
@@ -361,7 +355,7 @@ function Person(firstName, lastName) {
 }
 
 const member = new Person("Lydia", "Hallie");
-Person.getFullName = function () {
+Person.getFullName = function() {
   return `${this.firstName} ${this.lastName}`;
 };
 
@@ -379,9 +373,8 @@ console.log(member.getFullName());
 #### Cevap: A
 
 Sıradan fonksiyonlarla yaptığınız gibi bir yapıcıya ("constructor") özellik ekleyemezsiniz. Eğer, tek seferde tüm nesnelere özellik eklemek isterseniz, bunun yerine prototype kullanmalısınız. Yani bu durumda,
-
 ```js
-Person.prototype.getFullName = function () {
+Person.prototype.getFullName = function() {
   return `${this.firstName} ${this.lastName}`;
 };
 ```
@@ -421,7 +414,6 @@ console.log(sarah);
 `sarah` için `new` anahtar kelimesi kullanmadık. `new` kullandığınız zaman, oluşturduğumuz yeni boş nesneyi referans gösterir. Lakin, `new`'i eklemezseniz, **global nesne**'yi referans gösterir!
 
 `this.firstName`, `"Sarah"`'a eşittir ve `this.lastName`, `"Smith"`'e eşittir dedik. Aslında yaptığımız, `global.firstName = 'Sarah'` ve `global.lastName = 'Smith'` diye tanımlamaydı. `sarah`'ın kendisi `undefined` olarak kalır.
-
 </p>
 </details>
 
@@ -439,7 +431,7 @@ console.log(sarah);
 
 #### Cevap: D
 
-**capturing** aşaması süresince, olay ata ("ancestor) elemanlardan hedef elemana doğru gider. Daha sonra **target** elemana ulaşır ve **bubbling** başlar.
+**capturing** aşaması süresince, olay ata ("ancestor) elemanlardan hedef elemana doğru gider. Daha sonra **target** elemana ulaşır ve **bubbling** başlar. 
 
 <img src="https://i.imgur.com/N18oRgd.png" width="200">
 
@@ -459,7 +451,6 @@ console.log(sarah);
 #### Cevap: B
 
 Bütün nesneler prototiplere ("prototypes") sahiptir, **temel nesne**, **base object**, hariç. Temel nesne, kullanıcı tarafından oluşturulmuş nesnedir, ya da `new` anahtar kelimesi kullanarak oluşturulmuş bir nesnedir. Temel nesne bazı method ve özelliklere erişebilir, `.toString` gibi. Yerleşik gelen Javascript methodlarını kullanabilme sebebi budur! Buna benzer tüm methodlar prototip üzerinden erişebilir. Her ne kadar Javascript, methodu direkt olarak nesneniz üzerinden bulamasa da, prototip zinciri üzerinden aşağıya doğru gider ve orada bulur, böylece sizin için erişebilir yapar.
-
 </p>
 </details>
 
@@ -515,6 +506,7 @@ console.log(number);
 
 **son ek**, **postfix**, `++` unary operatörü:
 
+
 1. Değer döndürür (`0` döndürür)
 2. Değeri arttırır (sayı şimdi `1`)
 
@@ -694,7 +686,7 @@ sessionStorage.setItem("cool_secret", 123);
 
 `sessionStorage` içinde saklanan veri _sekme_ kapatıldıktan sonra kaldırılır.
 
-Eğer `localStorage` kullandıysanız, veri sonsuza kadar orada olacaktır, örnek olarak `localStorage.clear()` çalıştırılmadığı sürece.
+Eğer `localStorage` kullandıysanız, veri sonsuza kadar orada olacaktır, örnek olarak `localStorage.clear()` çalıştırılmadığı sürece. 
 
 </p>
 </details>
@@ -837,7 +829,7 @@ String.prototype.giveLydiaPizza = () => {
 
 const name = "Lydia";
 
-console.log(name.giveLydiaPizza());
+console.log(name.giveLydiaPizza())
 ```
 
 - A: `"Just give Lydia pizza already!"`
@@ -949,7 +941,9 @@ Burası olay döngüsünün çalışmaya başlayacapı yerdir. **olay döngüsü
 ```html
 <div onclick="console.log('first div')">
   <div onclick="console.log('second div')">
-    <button onclick="console.log('button')">Click!</button>
+    <button onclick="console.log('button')">
+      Click!
+    </button>
   </div>
 </div>
 ```
@@ -975,7 +969,9 @@ Olaya sebep olan en derindeki iç eleman, olayın hedefidir ("event.target"). `e
 
 ```html
 <div onclick="console.log('div')">
-  <p onclick="console.log('p')">Click here!</p>
+  <p onclick="console.log('p')">
+    Click here!
+  </p>
 </div>
 ```
 
@@ -1189,7 +1185,7 @@ Sonra, bu block-scoped değişkeni `1`'e eşit olarak ayarladık ve `y` değişk
 - A: primitifdir ya da nesnedir
 - B: fonksiyondur or nesnedir
 - C: tuzak soru! sadece nesnedir
-- D: sayıdır (number) ya da nesnedir
+- D: sayıdır (number) ya da nesnedir 
 
 <details><summary><b>Cevap</b></summary>
 <p>
@@ -1210,10 +1206,7 @@ Primitif ve nesneyi birbirinden ayıran, primitif tiplerin herhangi bir özelli
 ###### 40. Çıktısı Nedir?
 
 ```javascript
-[
-  [0, 1],
-  [2, 3],
-].reduce(
+[[0, 1], [2, 3]].reduce(
   (acc, cur) => {
     return acc.concat(cur);
   },
@@ -1339,7 +1332,7 @@ console.log(gen.next().value);
 
 #### Cevap: C
 
-Sıradan fonksiyonlar yürütmenin başlamasının ardından yarı yolda durdurulamaz. Ancak, bir generator fonksiyon yarı yolda "durdurabilir" ve sonra nerede kaldıysa devam edebilir. Bir generator fonksiyon ne zaman `yield` anahtar kelimesiyle karşılaşsa, yield'de belirtilen değeri verir. Dikkat edin, generator fonksiyon değeri _döndürmez_ (_return_), değeri _verir_ (_yield_).
+Sıradan fonksiyonlar yürütmenin başlamasının ardından yarı yolda durdurulamaz. Ancak, bir generator fonksiyon yarı yolda "durdurabilir" ve sonra nerede kaldıysa devam edebilir. Bir generator fonksiyon ne zaman `yield` anahtar kelimesiyle karşılaşsa, yield'de belirtilen değeri verir. Dikkat edin, generator fonksiyon değeri _döndürmez_ (_return_), değeri _verir_ (_yield_). 
 
 Önce, generator fonksiyonu `i`'yi `10`'a eşitleyerek başlatıyoruz. `next()` metodunu kullanarak generator fonksiyonu çalıştırıyoruz. İlk kez generator fonksiyonu çalıştırdığımızda, `i` `10`'a eşit. Fonksiyon ilk `yield` anahtar kelimesi ile karşılaşıyor: `i`'nin değerini veriyor. Generatır şimdi "durdu", ve `10` loglandı.
 
@@ -1361,7 +1354,7 @@ const secondPromise = new Promise((res, rej) => {
   setTimeout(res, 100, "two");
 });
 
-Promise.race([firstPromise, secondPromise]).then((res) => console.log(res));
+Promise.race([firstPromise, secondPromise]).then(res => console.log(res));
 ```
 
 - A: `"one"`
@@ -1413,7 +1406,7 @@ Sonra, `person` değişkenini `null`'a eşit olarak ayarlarız.
 
 <img src="https://i.imgur.com/sYjcsMT.png" width="300">
 
-Sadece `person` değişkeninin değerini değiştiriyoruz, dizideki ilk elemanı değil, ilk eleman nesneyi gösteren farklı (kopyalanmış) bir referansa sahip. `members` içindeki ilk eleman hala orijinal nesneyi gösteren referansını saklıyor. `members` dizisini logladığımız zaman, ilk elemanın hala sakladığı nesnenin değeri loglanır.
+Sadece `person` değişkeninin değerini değiştiriyoruz, dizideki ilk elemanı değil, ilk eleman nesneyi gösteren farklı (kopyalanmış) bir referansa sahip. `members` içindeki ilk eleman hala orijinal nesneyi gösteren referansını saklıyor. `members` dizisini logladığımız zaman, ilk elemanın hala sakladığı nesnenin değeri loglanır.  
 
 </p>
 </details>
@@ -1425,7 +1418,7 @@ Sadece `person` değişkeninin değerini değiştiriyoruz, dizideki ilk elemanı
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21,
+  age: 21
 };
 
 for (const item in person) {
@@ -1505,7 +1498,7 @@ Sadece string içindeki ilk sayılar döndürülür. _Sayı tabanına_ (hangi ti
 ###### 50. Çıktısı Nedir`?
 
 ```javascript
-[1, 2, 3].map((num) => {
+[1, 2, 3].map(num => {
   if (typeof num === "number") return;
   return num * 2;
 });
@@ -1521,7 +1514,7 @@ Sadece string içindeki ilk sayılar döndürülür. _Sayı tabanına_ (hangi ti
 
 #### Cevap: C
 
-Dizi üzerinde eşleme yaparken, `num`'ın değeri, o anda döngüye giren elemanın değerine eşittir. Bu durumda, elemanlar sayı, yani `typeof num === "number"` koşul ifadesi `true` durdurur. map fonksiyonu yeni bir dizi oluşturur ve fonksiyondan dönen değerleri yerleştirir.
+Dizi üzerinde eşleme yaparken, `num`'ın değeri, o anda döngüye giren elemanın değerine eşittir. Bu durumda, elemanlar sayı, yani `typeof num === "number"` koşul ifadesi `true` durdurur. map fonksiyonu yeni bir dizi oluşturur ve fonksiyondan dönen değerleri yerleştirir. 
 
 Ancak, biz değer döndürmüyoruz. Bir fonksiyondan değer döndürmediğimiz zaman, fonksiyon `undefined` döndürür. Dizideki her eleman için, fonksiyon bloğu çağrılır, yani her bir eleman için `undefined` döndürürüz.
 
@@ -1682,7 +1675,7 @@ class Dog {
   }
 }
 
-Dog.prototype.bark = function () {
+Dog.prototype.bark = function() {
   console.log(`Woof I am ${this.name}`);
 };
 
@@ -1910,7 +1903,7 @@ console.log(Object.keys(person));
 const settings = {
   username: "lydiahallie",
   level: 19,
-  health: 90,
+  health: 90
 };
 
 const data = JSON.stringify(settings, ["level", "health"]);
@@ -1929,7 +1922,7 @@ console.log(data);
 
 `JSON.stringify`'ın ikinci argumanı _değiştiricidir_, _"replacer"_. Değiştirici bir fonksiyon ya da bir dizi olabilir, ve değerlerin hangilerinin ve nasıl string'e dönüşeceğini kontrol etmenize izin verir.
 
-Eğer değiştirici _dizi_ ise, sadece dizi içinde ismi geçem özellikler JSON string'e dahil edilmiş olur. Bu durumda, sadece `"level"` ve `"health"` isimli özellikler dahil edildi, `"username"` dışarıda bırakıldı. `data`, `"{"level":19, "health":90}"` eşittir.
+Eğer değiştirici _dizi_ ise, sadece dizi içinde ismi geçem özellikler JSON string'e dahil edilmiş olur. Bu durumda, sadece  `"level"` ve `"health"` isimli özellikler dahil edildi, `"username"` dışarıda bırakıldı. `data`, `"{"level":19, "health":90}"` eşittir.
 
 Eğer değiştirici _fonksiyon_ ise, stringe dönüştürülen her özellik için bu fonksiyon çağrılır. Bu fonksiyondan dönen değer, JSON stringe eklenmiş olacak özelliğin değeri olacaktır. Eğer değer `undefined`'sa, bu özellik JSON stringe dahil edilmez.
 
@@ -1944,7 +1937,7 @@ Eğer değiştirici _fonksiyon_ ise, stringe dönüştürülen her özellik içi
 let num = 10;
 
 const increaseNumber = () => num++;
-const increasePassedNumber = (number) => number++;
+const increasePassedNumber = number => number++;
 
 const num1 = increaseNumber();
 const num2 = increasePassedNumber(num1);
@@ -2032,7 +2025,7 @@ Bu örnekte, geriye bir değer döndürmüyoruz, sadece biriktiricinin değerini
 
 Biriktiricinin değeri, bir önceki callback fonksiyonunun dönen değerine eşittir. Eğer, opsiyonel olan `initialValue` agümanını `reduce` methoduna geçmezseniz, biriktiricinin değeri, ilk çağrılışta gelen elemana eşit olur.
 
-İlk çağrılışta, biriktirici (`x`) `1`'dir, ve `y`'nin o anki değeri `2`'dir. callback fonksiyonundan bir şey döndürmüyoruz, biriktiriciyi ve o anki değeri logluyoruz: `1` ve `2` loglanır.
+İlk çağrılışta, biriktirici (`x`) `1`'dir, ve `y`'nin o anki değeri `2`'dir. callback fonksiyonundan bir şey döndürmüyoruz, biriktiriciyi ve o anki değeri logluyoruz: `1`  ve `2` loglanır.
 
 Eğer bir fonksiyondan değer döndürmezseniz, fonksiyon `undefined` döndürür. Sonraki çağrılışta, biriktirici `undefined`, ve o anki geçerli değer `3`'tür. `undefined` ve `3` loglanır.
 
@@ -2053,7 +2046,7 @@ class Dog {
 };
 
 class Labrador extends Dog {
-  // 1
+  // 1 
   constructor(name, size) {
     this.size = size;
   }
@@ -2067,7 +2060,7 @@ class Labrador extends Dog {
     super(name);
     this.size = size;
   }
-  // 4
+  // 4 
   constructor(name, size) {
     this.name = name;
     this.size = size;
@@ -2090,7 +2083,7 @@ Türetilmiş bir sınıfta, `super`'i çağırmadan önce `this` anahtar kelimes
 
 `super` anahtar kelimesiyle, parent sınıfın yapıcı methodunu verilen argümanlarla beraber çağırırız. Parent sınıfın yapıcısı `name` argümanını alıyor, bu yüzden `super`'e `name`'i vermemiz gerek.
 
-`Dog` sınıfı iki argüman alıyor, `name` `Animal` sınıfından türediğinden, ve `size` `Dog` sınıfı üzerinde ekstra özellik olarak. İkisinin de `Dog` yapıcı methoduna geçilmesi gerek, bu da 2. yapıcı methodda doğru şekilde kullanılarak yapılmıştır.
+`Dog` sınıfı iki argüman alıyor, `name` `Animal` sınıfından türediğinden, ve `size` `Dog` sınıfı üzerinde ekstra özellik olarak. İkisinin de `Dog` yapıcı methoduna  geçilmesi gerek, bu da 2. yapıcı methodda doğru şekilde kullanılarak yapılmıştır.
 
 </p>
 </details>
@@ -2101,12 +2094,12 @@ Türetilmiş bir sınıfta, `super`'i çağırmadan önce `this` anahtar kelimes
 
 ```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;
 ```
 
@@ -2132,9 +2125,9 @@ CommonJS'deki `require()` ve `import` arasındaki fark budur! `require()` ile, b
 ###### 68. Çıktısı Nedir?
 
 ```javascript
-console.log(Number(2) === Number(2));
-console.log(Boolean(false) === Boolean(false));
-console.log(Symbol("foo") === Symbol("foo"));
+console.log(Number(2) === Number(2))
+console.log(Boolean(false) === Boolean(false))
+console.log(Symbol('foo') === Symbol('foo'))
 ```
 
 - A: `true`, `true`, `false`
@@ -2157,15 +2150,15 @@ Her Symbol tamamen benzersizdir. Symbol'e geçilen argümanın amacı, Symbol'e
 ###### 69. Çıktısı Nedir?
 
 ```javascript
-const name = "Lydia Hallie";
-console.log(name.padStart(13));
-console.log(name.padStart(2));
+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"`,
+- D: `"Lydia Hallie"`, `"Lyd"`, 
 
 <details><summary><b>Cevap</b></summary>
 <p>
@@ -2198,7 +2191,6 @@ console.log("🥑" + "💻");
 #### Cevap: A
 
 `+` operatörü ile stringleri birleştirebilirsiniz. Bu örnekte, `"🥑"` ile `"💻"` birleştiriyoruz, `"🥑💻"` olarak sonuçlanıyor.
-
 </p>
 </details>
 
@@ -2394,7 +2386,7 @@ Eşitliğin sağ tarafındaki nesneden `name` özelliğini çıkarttığımız z
 
 `{ name: myName }` ile, JavaScript'e diyoruz ki; eşitliğin sağ tarafındaki `name` özelliğinin değeriyle birlikte `myName` diye bir değişken tanımlamak istiyoruz.
 
-`name`'i loglamayı denediğimizden dolayı, ki bu değişken tanımlanmamış, ReferenceError fırlatılır.
+`name`'i loglamayı denediğimizden dolayı, ki bu değişken tanımlanmamış, ReferenceError fırlatılır. 
 
 </p>
 </details>
@@ -2431,7 +2423,7 @@ Saf fonksiyon, aynı argümanlar geçildiği zaman, _her zaman_ aynı sonucu dö
 ```javascript
 const add = () => {
   const cache = {};
-  return (num) => {
+  return num => {
     if (num in cache) {
       return `From cache! ${cache[num]}`;
     } else {
@@ -2463,9 +2455,9 @@ console.log(addFunction(5 * 2));
 Eğer `addFunction` fonksiyonunu aynı argüman ile tekrar çağırırsak, önce cache içinde o değerin hali hazırda olup olmadığını kontrol eder. Eğer varsa, cache değeri döndürülecektir ki böylece çalışma zamanından tasarruf sağlanır. Eğer yoksa, cache'lenmemişse, değeri hesaplayıp ardından saklayacaktır.
 
 `addFunction` fonksiyonunu üç kez aynı değer ile çağırıyoruz: ilk çağırmada, `num` `10`'a eşit olduğu zaman fonksiyonun değeri henüz cache'lenmemiş. `num in cache` if ifadesi `false` döndürür
-ve else bloğu çalıştırılır: `Calculated! 20` loglanır, ve sonuç cache nesnesine eklenir. `cache` şimdi şuna benziyor; `{ 10: 20 }`
+ ve else bloğu çalıştırılır: `Calculated! 20` loglanır, ve sonuç cache nesnesine eklenir. `cache` şimdi şuna benziyor; `{ 10: 20 }`
 
-İkincide, `cache` nesnesi `10` için döndürülen değeri içeriyor. `num in cache` if ifadesi `true` döndürür, ve `'From cache! 20'` loglanır.
+İkincide, `cache` nesnesi `10` için döndürülen değeri içeriyor. `num in cache` if ifadesi `true` döndürür, ve `'From cache! 20'` loglanır. 
 
 Üçüncü sefer de, fonksiyona `5 * 2` geçiyoruz ki bu da `10` olarak değerlendirilir. `cache` nesnesi `10` için döndürülen değeri içeriyor. `num in cache` if ifadesi `true` döndürür, ve `'From cache! 20'` loglanır.
 
@@ -2477,21 +2469,21 @@ ve else bloğu çalıştırılır: `Calculated! 20` loglanır, ve sonuç cache n
 ###### <a name=20190726></a>79. Çıktısı Nedir?
 
 ```javascript
-const myLifeSummedUp = ["☕", "💻", "🍷", "🍫"];
+const myLifeSummedUp = ["☕", "💻", "🍷", "🍫"]
 
 for (let item in myLifeSummedUp) {
-  console.log(item);
+  console.log(item)
 }
 
 for (let item of myLifeSummedUp) {
-  console.log(item);
+  console.log(item)
 }
 ```
 
 - A: `0` `1` `2` `3` ve `"☕"` ` "💻"` `"🍷"` `"🍫"`
 - B: `"☕"` ` "💻"` `"🍷"` `"🍫"` ve `"☕"` ` "💻"` `"🍷"` `"🍫"`
 - C: `"☕"` ` "💻"` `"🍷"` `"🍫"` ve `0` `1` `2` `3`
-- D: `0` `1` `2` `3` ve `{0: "☕", 1: "💻", 2: "🍷", 3: "🍫"}`
+- D:  `0` `1` `2` `3` ve `{0: "☕", 1: "💻", 2: "🍷", 3: "🍫"}`
 
 <details><summary><b>Cevap</b></summary>
 <p>
@@ -2514,14 +2506,14 @@ _for-of_ döngüsü ile, **yinelenebilirler** (**iterables**) üzerinde iterasyo
 ###### 80. Çıktısı Nedir?
 
 ```javascript
-const list = [1 + 2, 1 * 2, 1 / 2];
-console.log(list);
+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]`
+- D:  `[1, 1, 1]`
 
 <details><summary><b>Cevap</b></summary>
 <p>
@@ -2541,16 +2533,16 @@ Eleman dönen değere eşit olacaktır. `1 + 2` `3` döndürür, `1 * 2` `2` dö
 
 ```javascript
 function sayHi(name) {
-  return `Hi there, ${name}`;
+  return `Hi there, ${name}`
 }
 
-console.log(sayHi());
+console.log(sayHi())
 ```
 
 - A: `Hi there, `
 - B: `Hi there, undefined`
 - C: `Hi there, null`
-- D: `ReferenceError`
+- D:  `ReferenceError`
 
 <details><summary><b>Cevap</b></summary>
 <p>
@@ -2573,21 +2565,21 @@ Bu örnekte, eğer bir değer geçmeseydik ya da `undefined` geçseydik, `name`
 ###### 82. Çıktısı Nedir?
 
 ```javascript
-var status = "😎";
+var status = "😎"
 
 setTimeout(() => {
-  const status = "😍";
+  const status = "😍"
 
   const data = {
     status: "🥑",
     getStatus() {
-      return this.status;
-    },
-  };
+      return this.status
+    }
+  }
 
-  console.log(data.getStatus());
-  console.log(data.getStatus.call(this));
-}, 0);
+  console.log(data.getStatus())
+  console.log(data.getStatus.call(this))
+}, 0)
 ```
 
 - A: `"🥑"` ve `"😍"`
@@ -2614,13 +2606,13 @@ setTimeout(() => {
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21,
-};
+  age: 21
+}
 
-let city = person.city;
-city = "Amsterdam";
+let city = person.city
+city = "Amsterdam"
 
-console.log(person);
+console.log(person)
 ```
 
 - A: `{ name: "Lydia", age: 21 }`
@@ -2632,13 +2624,13 @@ console.log(person);
 <p>
 
 #### Cevap: A
-
+ 
 `city` değişkenini, `person` nesnesindeki `city` özelliğinin değerine eşitledik. `person` nesnesinde `city` diye isimlendirilmiş bir özellik yok, bu yüzden `city` değişkeni `undefined` değerine sahip olur.
 
 `person` nesnesinin kendisini referans _göstermediğimize_ dikkat edin! Sadece `city` değişkenini, `person` nesnesindeki `city` özelliğinin o andaki değerine eşitledik.
 
 Sonra, `city`'i `"Amsterdam"` string'ine eşitledik. Bu `person` nesnesini değiştirmez: bu nesneye referans yok.
-
+  
 `person` nesnesini logladığımız zaman, değişikliğe uğramamış nesne döndürülür.
 
 </p>
@@ -2651,15 +2643,15 @@ Sonra, `city`'i `"Amsterdam"` string'ine eşitledik. Bu `person` nesnesini deği
 ```javascript
 function checkAge(age) {
   if (age < 18) {
-    const message = "Sorry, you're too young.";
+    const message = "Sorry, you're too young."
   } else {
-    const message = "Yay! You're old enough!";
+    const message = "Yay! You're old enough!"
   }
 
-  return message;
+  return message
 }
 
-console.log(checkAge(21));
+console.log(checkAge(21))
 ```
 
 - A: `"Sorry, you're too young."`
@@ -2682,15 +2674,15 @@ console.log(checkAge(21));
 ###### 85. Loglanacak değer ne tür olur?
 
 ```javascript
-fetch("https://www.website.com/api/user/1")
-  .then((res) => res.json())
-  .then((res) => console.log(res));
+fetch('https://www.website.com/api/user/1')
+  .then(res => res.json())
+  .then(res => console.log(res))
 ```
 
 - A: `fetch` methodunun sonucu.
 - B: `fetch` methodunun ikinci kez çağrılmasından dönen sonuç.
 - C: Bir önceki `.then()`'in sonucu.
-- D: Her zaman `undefined` olacaktır.
+- D: Her zaman `undefined` olacaktır. 
 
 <details><summary><b>Cevap</b></summary>
 <p>
@@ -2738,7 +2730,7 @@ function getName(name) {
 ###### <a name=20190805></a>87. Çıktısı Nedir?
 
 ```javascript
-console.log("I want pizza"[0]);
+console.log("I want pizza"[0])
 ```
 
 - A: `"""`
@@ -2764,10 +2756,10 @@ Bu yöntemin IE7 ve altında desteklenmediğine dikkat edin. Bu durumda, `.charA
 
 ```javascript
 function sum(num1, num2 = num1) {
-  console.log(num1 + num2);
+  console.log(num1 + num2)
 }
 
-sum(10);
+sum(10)
 ```
 
 - A: `NaN`
@@ -2781,7 +2773,7 @@ sum(10);
 #### Cevap: B
 
 Varsayılan parametrenin değerini fonksiyonun başka parametresine eşitleyebilirsiniz, varsayılan parametreden _önce_ tanımladıkları müddetçe. `sum` fonksiyonuna `10` değerini geçtik. Eğer `sum` fonksiyonu sadece 1 argüman alırsa, `num2` değeri geçilmedi demektir, ve `num1`'ın değeri geçtiğimiz `10` değerine eşittir bu durumda. `num2`'nun varsayılan değeri `num1`'dır ki o da `10`'dur. `num1 + num2` `20` döndürür.
-
+ 
 Eğer varsayılan parametrenin değerini, _sonrasında_ (sağında) tanımlanmış bir parametreye eşitlemeye çalışıyorsanız, parametrenin değeri henüz oluşturulmamıştır, hata fırlatacaktır.
 
 </p>
@@ -2792,14 +2784,14 @@ Eğer varsayılan parametrenin değerini, _sonrasında_ (sağında) tanımlanmı
 ###### 89. Çıktısı Nedir?
 
 ```javascript
-// module.js
-export default () => "Hello world";
-export const name = "Lydia";
+// module.js 
+export default () => "Hello world"
+export const name = "Lydia"
 
-// index.js
-import * as data from "./module";
+// index.js 
+import * as data from "./module"
 
-console.log(data);
+console.log(data)
 ```
 
 - A: `{ default: function default(), name: "Lydia" }`
@@ -2826,12 +2818,12 @@ console.log(data);
 ```javascript
 class Person {
   constructor(name) {
-    this.name = name;
+    this.name = name
   }
 }
 
-const member = new Person("John");
-console.log(typeof member);
+const member = new Person("John")
+console.log(typeof member)
 ```
 
 - A: `"class"`
@@ -2848,7 +2840,7 @@ Sınıflar fonksiyon yapıcıları için "syntactical sugar"dır. `Person` sın
 
 ```javascript
 function Person() {
-  this.name = name;
+  this.name = name
 }
 ```
 
@@ -2862,9 +2854,9 @@ Bir fonksiyon yapıcısını `new` ile çağırmak `Person` "instance" oluşturu
 ###### 91. Çıktısı Nedir?
 
 ```javascript
-let newList = [1, 2, 3].push(4);
+let newList = [1, 2, 3].push(4)
 
-console.log(newList.push(5));
+console.log(newList.push(5))
 ```
 
 - A: `[1, 2, 3, 4, 5]`
@@ -2877,7 +2869,7 @@ console.log(newList.push(5));
 
 #### Cevap: D
 
-`.push` methodu dizinin _yeni uzunluğunu_ döndürür, dizinin kendisini değil! `newList`'i `[1, 2, 3].push(4)`'a eşitleyerek, `newList`'i dizinin yeni uzunluğuna eşitledik: `4`.
+`.push` methodu dizinin _yeni uzunluğunu_ döndürür, dizinin kendisini değil! `newList`'i  `[1, 2, 3].push(4)`'a eşitleyerek, `newList`'i dizinin yeni uzunluğuna eşitledik: `4`.
 
 Sonra, `.push` methodunu `newList` üzerinde kullanmayı denedik. `newList` sayısal değer `4` olduğundan, `.push` methodunu kullanamayız: TypeError fırlatılır.
 
@@ -2890,18 +2882,17 @@ Sonra, `.push` methodunu `newList` üzerinde kullanmayı denedik. `newList` say
 
 ```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);
+console.log(giveLydiaPizza.prototype)
+console.log(giveLydiaChocolate.prototype)
 ```
 
-- A: `{ constructor: ...}` `{ constructor: ...}`
-- B: `{}` `{ constructor: ...}`
+- A: `{ constructor: ...}` `{ constructor: ...}` 
+- B: `{}` `{ constructor: ...}` 
 - C: `{ constructor: ...}` `{}`
 - D: `{ constructor: ...}` `undefined`
 
@@ -2910,7 +2901,7 @@ console.log(giveLydiaChocolate.prototype);
 
 #### Cevap: D
 
-Sıradan fonksiyonlar, `giveLydiaPizza` gibi, `constructor` özelliği olan `prototype` nesnesi özelliğine sahiptir. Ancak ok fonksiyonlar (arrow functions), `giveLydiaChocolate` gibi, bu `prototype` özelliğine sahip değildir. `giveLydiaChocolate.prototype` ile `prototype` özelliğine erişmeye çalışıldığında `undefined` döndürülür.
+Sıradan fonksiyonlar, `giveLydiaPizza` gibi, `constructor` özelliği olan `prototype` nesnesi özelliğine sahiptir. Ancak ok fonksiyonlar (arrow functions), `giveLydiaChocolate` gibi, bu `prototype` özelliğine sahip değildir. `giveLydiaChocolate.prototype` ile `prototype` özelliğine erişmeye çalışıldığında `undefined` döndürülür. 
 
 </p>
 </details>
@@ -2922,16 +2913,16 @@ Sıradan fonksiyonlar, `giveLydiaPizza` gibi, `constructor` özelliği olan `pro
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21,
-};
+  age: 21
+}
 
 for (const [x, y] of Object.entries(person)) {
-  console.log(x, y);
+  console.log(x, y)
 }
 ```
 
 - A: `name` `Lydia` ve `age` `21`
-- B: `["name", "Lydia"]` ve `["age", 21]`
+- B: `["name", "Lydia"]` ve `["age", 21]` 
 - C: `["name", "age"]` ve `undefined`
 - D: `Error`
 
@@ -2942,7 +2933,7 @@ for (const [x, y] of Object.entries(person)) {
 
 `Object.entries(person)` key ve nesneleri içeren dizilerden oluşan dizi döndürür:
 
-`[ [ 'name', 'Lydia' ], [ 'age', 21 ] ]`
+`[ [ 'name', 'Lydia' ], [ 'age', 21 ] ]` 
 
 `for-of` döngüsünü kullanarak, dizi içindeki her bir elemanı gezebiliriz, alt dizileri bu örnekte. for-of döngüsü içinde alt dizileri `const [x, y]` kullanarak parçalayabiliriz. `x` alt dizideki ilk elemana, `y` alt dizideki ikinci elemana eşittir.
 
@@ -2965,7 +2956,7 @@ getItems(["banana", "apple"], "pear", "orange")
 ```
 
 - A: `["banana", "apple", "pear", "orange"]`
-- B: `[["banana", "apple"], "pear", "orange"]`
+- B: `[["banana", "apple"], "pear", "orange"]` 
 - C: `["banana", "apple", ["pear"], "orange"]`
 - D: `SyntaxError`
 
@@ -2978,10 +2969,10 @@ getItems(["banana", "apple"], "pear", "orange")
 
 ```javascript
 function getItems(fruitList, favoriteFruit, ...args) {
-  return [...fruitList, ...args, favoriteFruit];
+  return [...fruitList, ...args, favoriteFruit]
 }
 
-getItems(["banana", "apple"], "pear", "orange");
+getItems(["banana", "apple"], "pear", "orange")
 ```
 
 Yukarıdaki örnek çalışır. `[ 'banana', 'apple', 'orange', 'pear' ]` dizisini döndürür.
@@ -2995,14 +2986,17 @@ Yukarıdaki örnek çalışır. `[ 'banana', 'apple', 'orange', 'pear' ]` dizisi
 
 ```javascript
 function nums(a, b) {
-  if (a > b) console.log("a is bigger");
-  else console.log("b is bigger");
-  return;
-  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));
+console.log(nums(4, 2))
+console.log(nums(1, 2))
 ```
 
 - A: `a is bigger`, `6` ve `b is bigger`, `3`
@@ -3015,13 +3009,13 @@ console.log(nums(1, 2));
 
 #### Cevap: B
 
-JavaScript'te, noktalı virgülü (`;`) özellikle yazmak _zorunda değiliz_, ancak JavaScript motoru ifadelerden sonra noktalı virgül eklemektedir. bu **Automatic Semicolon Insertion**, **Otomatik Noktalı Virgül Ekleme**, olarak adlandırılır. İfade, örneğin, değişkenler ya da `throw`, `return`, `break`, vb. gibi anahtar kelimeler olabilir.
-
-Burada, bir `return` ifadesi yazdık, ve _yeni bir satırda_ başka bir değer olarak `a + b`. Ancak, `a + b` yeni satırda olduğundan, JavaScript motoru onun aslında bizim döndürmek istediğimiz değer olduğunu bilmiyor. Onun yerine, `return`'den sonra otomatik olarak noktalı virgül ekliyor. Şöyle düşünebilirsiniz:
+JavaScript'te, noktalı virgülü (`;`) özellikle yazmak _zorunda değiliz_, ancak JavaScript motoru ifadelerden sonra noktalı virgül eklemektedir. bu **Automatic Semicolon Insertion**, **Otomatik Noktalı Virgül Ekleme**, olarak adlandırılır. İfade, örneğin, değişkenler ya da `throw`, `return`, `break`, vb. gibi anahtar kelimeler olabilir. 
 
+Burada, bir `return` ifadesi yazdık, ve _yeni bir satırda_ başka bir değer olarak `a + b`. Ancak, `a + b` yeni satırda olduğundan, JavaScript motoru onun aslında bizim döndürmek istediğimiz değer olduğunu bilmiyor. Onun yerine, `return`'den sonra otomatik olarak noktalı virgül ekliyor. Şöyle düşünebilirsiniz: 
+  
 ```javascript
-return;
-a + b;
+  return;
+  a + b
 ```
 
 Fonksiyon `return` anahtar kelimesinden sonra çalışmayı durduracağından, `a + b` asla ulaşılamaz demektir. Eğer hiçbir değer döndürülmezse, fonksiyon `undefined` döndürür. Dikkat etmeniz gereken, `if/else` ifadelerinden sonra otomatik ekleme yapılmadığıdır!
@@ -3036,18 +3030,18 @@ Fonksiyon `return` anahtar kelimesinden sonra çalışmayı durduracağından, `
 ```javascript
 class Person {
   constructor() {
-    this.name = "Lydia";
+    this.name = "Lydia"
   }
 }
 
 Person = class AnotherPerson {
   constructor() {
-    this.name = "Sarah";
+    this.name = "Sarah"
   }
-};
+}
 
-const member = new Person();
-console.log(member.name);
+const member = new Person()
+console.log(member.name)
 ```
 
 - A: `"Lydia"`
@@ -3071,11 +3065,11 @@ Sınıfları diğer sınıf/fonksiyon yapıcılara eşitleyebiliriz. Bu örnekte
 
 ```javascript
 const info = {
-  [Symbol("a")]: "b",
-};
+  [Symbol('a')]: 'b'
+}
 
-console.log(info);
-console.log(Object.keys(info));
+console.log(info)
+console.log(Object.keys(info))
 ```
 
 - A: `{Symbol('a'): 'b'}` ve `["{Symbol('a')"]`
@@ -3090,7 +3084,7 @@ console.log(Object.keys(info));
 
 Symbol _sayılabilir_, "_enumerable_" değildir. Object.keys methodu nesne üzerindeki tüm _sayılabilir_ özellikleri döndürür. Symbol gizli kalır ve boş bir dizi döndürülür. Tüm nesne loglandığı zaman, bütün özellikler görülebilir, sayılabilir olmayanlar bile.
 
-Bu symbol'ün birçok özelliğinden birisidir: tamamen benzersiz bir değer temsil etmenin yanında (ki nesneler üzerindeki kazara isim çakışmasını önler, örneğin aynı nesneye özellikler eklemek isteyen 2 kütüphaneyle çalışırken), ayrıca bu yolla nesne üzerindeki özellikleri "saklayabilirsiniz" (gerçi tamamen değil. `Object.getOwnPropertySymbols()` methodunu kullanarak symbol'lere hala erişebilirsiniz).
+Bu symbol'ün birçok  özelliğinden birisidir: tamamen benzersiz bir değer temsil etmenin yanında (ki nesneler üzerindeki kazara isim çakışmasını önler, örneğin aynı nesneye özellikler eklemek isteyen 2 kütüphaneyle çalışırken), ayrıca bu yolla nesne üzerindeki özellikleri "saklayabilirsiniz" (gerçi tamamen değil. `Object.getOwnPropertySymbols()` methodunu kullanarak symbol'lere hala erişebilirsiniz).
 
 </p>
 </details>
@@ -3122,13 +3116,13 @@ console.log(getUser(user))
 
 `getList` fonksiyonu argüman olarak bir dizi alır. `getList` fonksiyonunun parentezleri arasında, bu diziyi anında parçalıyoruz. Şu şekilde görebilirsiniz:
 
-`[x, ...y] = [1, 2, 3, 4]`
+ `[x, ...y] = [1, 2, 3, 4]`
 
-`...y` rest parametresi ile, dizi içinde "geriye kalan" tüm argümanları topluyoruz. Geriye kalan argümanlar `2`, `3`, ve `4` bu durumda. `y`'nin değeri tüm rest parametleri içeren bir dizi. `x`'in değeri `1`'a eşit, yani `[x, y]` logladığımız zaman, `[1, [2, 3, 4]]` loglanır.
+ `...y` rest parametresi ile, dizi içinde "geriye kalan" tüm argümanları topluyoruz. Geriye kalan argümanlar `2`, `3`, ve `4` bu durumda. `y`'nin değeri tüm rest parametleri içeren bir dizi. `x`'in değeri `1`'a eşit, yani `[x, y]` logladığımız zaman, `[1, [2, 3, 4]]` loglanır.
 
-`getUser` fonksiyonu bir nesne alıyor. Ok fonksiyonlar ile, eğer sadece bir değer döndürmek istiyorsak süslü parentezleri yazmak _zorunda değiliz._ Ancak, bir ok fonksiyondan bir _nesne_ döndürmek istiyorsanız, parentezler arasında yazmak zorundasınız, aksi halde değer döndürülmez! Aşağıdaki fonksiyon bir nesne döndürecektir:
+ `getUser` fonksiyonu bir nesne alıyor. Ok fonksiyonlar ile, eğer sadece bir değer döndürmek istiyorsak süslü parentezleri yazmak _zorunda değiliz._ Ancak, bir ok fonksiyondan bir _nesne_ döndürmek istiyorsanız, parentezler arasında yazmak zorundasınız, aksi halde değer döndürülmez! Aşağıdaki fonksiyon bir nesne döndürecektir:
 
-`const getUser = user => ({ name: user.name, age: user.age })`
+```const getUser = user => ({ name: user.name, age: user.age })```
 
 Bu örnekte değer döndürülmediği için, fonksiyon `undefined` döndürür.
 
@@ -3140,9 +3134,9 @@ Bu örnekte değer döndürülmediği için, fonksiyon `undefined` döndürür.
 ###### 99. Çıktısı Nedir?
 
 ```javascript
-const name = "Lydia";
+const name = "Lydia"
 
-console.log(name());
+console.log(name())
 ```
 
 - A: `SyntaxError`
@@ -3155,11 +3149,11 @@ console.log(name());
 
 #### Cevap: C
 
-`name` değişkeni string bir değer saklıyor, ki bu bir fonksiyon değil, bu yüzden çağrılamaz.
+ `name` değişkeni string bir değer saklıyor, ki bu bir fonksiyon değil, bu yüzden çağrılamaz.
 
-TypeError'lar bir değer beklenilen tipte olmadığı zaman fırlatılır. `name`'i çağırmaya çalıştığımızdan, JavaScript `name`'in bir fonksiyon olmasını bekliyor. Ancak o bir string, bu yüzden TypeError fırlatılır: name is not a function!
+TypeError'lar bir değer beklenilen tipte olmadığı zaman fırlatılır. `name`'i çağırmaya çalıştığımızdan, JavaScript `name`'in bir fonksiyon olmasını bekliyor. Ancak o bir string, bu yüzden TypeError fırlatılır: name is not a function! 
 
-SyntaxError'lar JavaScript'in geçerli olmadığı bir şeyler yazdığız zaman fırlatılır, örneğin `return`'ü `retrun` olarak yazdığınız zaman.
+SyntaxError'lar JavaScript'in geçerli olmadığı bir şeyler yazdığız zaman fırlatılır, örneğin `return`'ü `retrun` olarak yazdığınız zaman.  
 
 ReferenceError'lar erişmeye çalıştığınız değer için JavaScript referans bulamadığı zaman fırlatılır.
 
@@ -3173,8 +3167,8 @@ ReferenceError'lar erişmeye çalıştığınız değer için JavaScript referan
 ```javascript
 // 🎉✨ 100. soru! ✨🎉
 
-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`
@@ -3189,7 +3183,7 @@ You should${"" && `n't`} see a therapist after so much JavaScript lol`;
 
 `[]` doğrusal bir değerdir. `&&` operatörü ile, eğer soldaki değer doğrusal bir değerse sağdaki değer döndürülür. Bu örnekte, soldaki değer `[]` doğrusal bir değerdir, böylece `"Im"` döndürülür.
 
-`""` yanlış-ımsı bir değerdir. Eğer soldaki değer yanlış-ımsı ise, bir şey döndürülmez. `n't` döndürülmedi.
+`""` yanlış-ımsı bir değerdir. Eğer soldaki değer yanlış-ımsı ise, bir şey döndürülmez. `n't` döndürülmedi. 
 
 </p>
 </details>
@@ -3199,11 +3193,11 @@ You should${"" && `n't`} see a therapist after so much JavaScript lol`;
 ###### 101. Çıktısı Nedir?
 
 ```javascript
-const one = false || {} || null;
-const two = null || false || "";
-const three = [] || 0 || true;
+const one = (false || {} || null)
+const two = (null || false || "")
+const three = ([] || 0 || true)
 
-console.log(one, two, three);
+console.log(one, two, three)
 ```
 
 - A: `false` `null` `[]`
diff --git a/uk-UA/README.md b/uk-UA/README.md
index aeb4f3ee..3b38c921 100644
--- a/uk-UA/README.md
+++ b/uk-UA/README.md
@@ -20,7 +20,6 @@
 - [🇳🇱 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)
@@ -101,7 +100,7 @@ const shape = {
   diameter() {
     return this.radius * 2;
   },
-  perimeter: () => 2 * Math.PI * this.radius,
+  perimeter: () => 2 * Math.PI * this.radius
 };
 
 shape.diameter();
@@ -158,12 +157,12 @@ shape.perimeter();
 
 ```javascript
 const bird = {
-  size: "small",
+  size: "small"
 };
 
 const mouse = {
   name: "Mickey",
-  small: true,
+  small: true
 };
 ```
 
@@ -357,7 +356,7 @@ function Person(firstName, lastName) {
 }
 
 const member = new Person("Lydia", "Hallie");
-Person.getFullName = function () {
+Person.getFullName = function() {
   return `${this.firstName} ${this.lastName}`;
 };
 
@@ -377,7 +376,7 @@ console.log(member.getFullName());
 Не можна додавати властивості конструктору, як звичайному об'єкту. Якщо потрібно додати фічу до всіх об'єктів, то необхідно використовувати прототипи. В даному випадку,
 
 ```js
-Person.prototype.getFullName = function () {
+Person.prototype.getFullName = function() {
   return `${this.firstName} ${this.lastName}`;
 };
 ```
@@ -833,7 +832,7 @@ String.prototype.giveLydiaPizza = () => {
 
 const name = "Lydia";
 
-console.log(name.giveLydiaPizza());
+console.log(name.giveLydiaPizza())
 ```
 
 - A: `"Just give Lydia pizza already!"`
@@ -945,7 +944,9 @@ baz();
 ```html
 <div onclick="console.log('first div')">
   <div onclick="console.log('second div')">
-    <button onclick="console.log('button')">Click!</button>
+    <button onclick="console.log('button')">
+      Click!
+    </button>
   </div>
 </div>
 ```
@@ -971,7 +972,9 @@ baz();
 
 ```html
 <div onclick="console.log('div')">
-  <p onclick="console.log('p')">Click here!</p>
+  <p onclick="console.log('p')">
+    Click here!
+  </p>
 </div>
 ```
 
@@ -1206,10 +1209,7 @@ console.log(numbers);
 ###### 40. Що буде в консолі?
 
 ```javascript
-[
-  [0, 1],
-  [2, 3],
-].reduce(
+[[0, 1], [2, 3]].reduce(
   (acc, cur) => {
     return acc.concat(cur);
   },
@@ -1344,20 +1344,21 @@ console.log(gen.next().value);
 </p>
 </details>
 
+
 ---
 
 ###### 45. Що повернеться?
 
 ```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));
+Promise.race([firstPromise, secondPromise]).then(res => console.log(res));
 ```
 
 - A: `"one"`
@@ -1380,7 +1381,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;
 
diff --git a/vi-VI/README-vi.md b/vi-VI/README-vi.md
index 249532dd..8750b2d6 100644
--- a/vi-VI/README-vi.md
+++ b/vi-VI/README-vi.md
@@ -7,7 +7,6 @@ Các câu hỏi sẽ từ cơ bản đến nâng cao: kiểm tra trình độ Ja
 Các đáp án được đặt dưới mỗi câu hỏi, hãy click để tham khảo chúng. Chúc may mắn :heart:
 
 Danh sách các ngôn ngữ khác:
-
 - [🇸🇦 العربية](../ar-AR/README_AR.md)
 - [🇪🇬 اللغة العامية](../ar-EG/README_ar-EG.md)
 - [🇧🇦 Bosanski](../bs-BS/README-bs_BS.md)
@@ -22,7 +21,6 @@ Danh sách các ngôn ngữ khác:
 - [🇳🇱 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)
@@ -103,7 +101,7 @@ const shape = {
   diameter() {
     return this.radius * 2;
   },
-  perimeter: () => 2 * Math.PI * this.radius,
+  perimeter: () => 2 * Math.PI * this.radius
 };
 
 shape.diameter();
@@ -149,7 +147,7 @@ Khi không có giá trị `radius` tại object đó, nó sẽ trả về `undef
 
 Phép toán cộng `+` sẽ convert một toán hạng sang dạng number. `true` là `1`, và `false` is `0`.
 
-Chuỗi `'Lydia'` là một _truthy value_. Điều chúng ta thật sự đang hỏi chính là "có phải một giá trị truthy là falsy?". Rõ ràng câu trả lời là `false` rồi.
+Chuỗi `'Lydia'` là một _truthy value_. Điều chúng ta thật sự đang hỏi chính là  "có phải một giá trị truthy là falsy?". Rõ ràng câu trả lời là `false` rồi.
 
 </p>
 </details>
@@ -160,12 +158,12 @@ Chuỗi `'Lydia'` là một _truthy value_. Điều chúng ta thật sự đang
 
 ```javascript
 const bird = {
-  size: "small",
+  size: "small"
 };
 
 const mouse = {
   name: "Mickey",
-  small: true,
+  small: true
 };
 ```
 
@@ -185,13 +183,14 @@ JavaScript thông dịch (hay unboxes) từng câu lệnh. Khi chúng ta sử d
 
 `mouse[bird.size]`: Giá trị đầu tiên `bird.size` là `"small"`. `mouse["small"]` sẽ trả về `true`
 
-Tuy nhiên, khi chúng ta sử dụng dấu chấm `.`, điều trên không còn đúng nữa. `mouse` không hề có key nào tên là `bird`, có nghĩa `mouse.bird` sẽ là `undefined`. Sau đó chúng ta gọi `size` sử dụng chấm `.`: `mouse.bird.size`. Vì `mouse.bird` là `undefined`, lời gọi sẽ trở thành `undefined.size`. Đây là một lời gọi không hợp lệ, nó sẽ throw ra một lỗi kiểu như `Cannot read property "size" of undefined`.
+Tuy nhiên, khi chúng ta sử dụng dấu chấm `.`, điều trên không còn đúng nữa. `mouse` không hề có key nào tên là `bird`, có nghĩa `mouse.bird` sẽ là `undefined`. Sau đó chúng ta gọi `size` sử dụng chấm `.`: `mouse.bird.size`. Vì  `mouse.bird` là `undefined`, lời gọi sẽ trở thành `undefined.size`. Đây là một lời gọi không hợp lệ, nó sẽ throw ra một lỗi kiểu như `Cannot read property "size" of undefined`.
 
 </p>
 </details>
 
 ---
 
+
 ###### 6. Output là gì?
 
 ```javascript
@@ -214,7 +213,7 @@ console.log(d.greeting);
 
 #### Đáp án: A
 
-Trong JavaScript, tất cả các object sẽ được _tham chiếu_ khi chúng được gán \_bằng_wwwww một giá trị khác.
+Trong JavaScript, tất cả các object sẽ được _tham chiếu_ khi chúng được gán _bằng_wwwww  một giá trị khác.
 
 Đầu tiên, giá trị `c` có giá trị là một object. Sau đó, chúng ta gán `d` tham chiếu tới object mà `c` trỏ tới.
 
@@ -359,7 +358,7 @@ function Person(firstName, lastName) {
 }
 
 const member = new Person("Lydia", "Hallie");
-Person.getFullName = function () {
+Person.getFullName = function() {
   return `${this.firstName} ${this.lastName}`;
 };
 
@@ -379,7 +378,7 @@ console.log(member.getFullName());
 Chúng ta không thể add thêm một thuộc tính cho một constructor giống như một object thông thường. Nếu bạn muốn add thêm thuộc tính nào đó cho tất cả các object một lần, bạn phải dùng `prototype`. Trong trường hợp này cũng vậy.
 
 ```js
-Person.prototype.getFullName = function () {
+Person.prototype.getFullName = function() {
   return `${this.firstName} ${this.lastName}`;
 };
 ```
@@ -836,7 +835,7 @@ String.prototype.giveLydiaPizza = () => {
 
 const name = "Lydia";
 
-console.log(name.giveLydiaPizza());
+console.log(name.giveLydiaPizza())
 ```
 
 - A: `"Just give Lydia pizza already!"`
@@ -948,7 +947,9 @@ WebAPI không thể thêm thứ gì đó vào stack cho tới khi nó được s
 ```html
 <div onclick="console.log('first div')">
   <div onclick="console.log('second div')">
-    <button onclick="console.log('button')">Click!</button>
+    <button onclick="console.log('button')">
+      Click!
+    </button>
   </div>
 </div>
 ```
@@ -974,7 +975,9 @@ Phần tử sâu nhất trong các phần tử lồng nhau sẽ là target của
 
 ```html
 <div onclick="console.log('div')">
-  <p onclick="console.log('p')">Click here!</p>
+  <p onclick="console.log('p')">
+    Click here!
+  </p>
 </div>
 ```
 
@@ -1209,10 +1212,7 @@ Primitive types là `boolean`, `null`, `undefined`, `bigint`, `number`, `string`
 ###### 40. Output là gì?
 
 ```javascript
-[
-  [0, 1],
-  [2, 3],
-].reduce(
+[[0, 1], [2, 3]].reduce(
   (acc, cur) => {
     return acc.concat(cur);
   },
@@ -1360,7 +1360,7 @@ const secondPromise = new Promise((res, rej) => {
   setTimeout(res, 100, "two");
 });
 
-Promise.race([firstPromise, secondPromise]).then((res) => console.log(res));
+Promise.race([firstPromise, secondPromise]).then(res => console.log(res));
 ```
 
 - A: `"one"`
@@ -1424,7 +1424,7 @@ Chúng ta chỉ đơn thuần là thay đổi giá trị của biến `person` m
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21,
+  age: 21
 };
 
 for (const item in person) {
@@ -1504,7 +1504,7 @@ Chỉ có số đầu tiên trong chuỗi kí tự được trả về. Hệ cơ
 ###### 50. Output là gì?
 
 ```javascript
-[1, 2, 3].map((num) => {
+[1, 2, 3].map(num => {
   if (typeof num === "number") return;
   return num * 2;
 });
@@ -1681,7 +1681,7 @@ class Dog {
   }
 }
 
-Dog.prototype.bark = function () {
+Dog.prototype.bark = function() {
   console.log(`Woof I am ${this.name}`);
 };
 
@@ -1767,7 +1767,7 @@ console.log(myCounter);
 
 #### Đáp án: C
 
-Một module khi được import sẽ là **read-only**: chúng ta sẽ không thể chỉnh sửa module đó, chỉ có bản thân module đó có thể chỉnh sửa giá trị của nó mà thôi.
+Một module khi được import sẽ là __read-only__: chúng ta sẽ không thể chỉnh sửa module đó, chỉ có bản thân module đó có thể chỉnh sửa giá trị của nó mà thôi.
 
 Khi ta thay đổi giá trị cuả `myCounter`, nó sẽ throw ra một lỗi: `myCounter` là _read-only_ và không thể thay đổi.
 
@@ -1909,7 +1909,7 @@ Thêm nữa, các thuộc tính được thêm bởi `defineProperty` là mặc
 const settings = {
   username: "lydiahallie",
   level: 19,
-  health: 90,
+  health: 90
 };
 
 const data = JSON.stringify(settings, ["level", "health"]);
@@ -1943,7 +1943,7 @@ Nếu replacer là _function_, hàm này sẽ được gọi trên từng thuộ
 let num = 10;
 
 const increaseNumber = () => num++;
-const increasePassedNumber = (number) => number++;
+const increasePassedNumber = number => number++;
 
 const num1 = increaseNumber();
 const num2 = increasePassedNumber(num1);
@@ -2000,9 +2000,9 @@ Trong ES6 thì chúng ta có thể khởi tạo tham số với giá trị mặc
 
 Chú ý một điều là đối số sẽ được xét giá trị tại _call time_! Có nghĩa là mỗi khi chúng ta gọi hàm, một _object mới_ sẽ được tạo ra. Chúng ta gọi hàm `multiply` hai lần mà không truyền vào đối số nào cả: `x` sẽ nhận giá trị mặc định `{ number: 10 }`. Sau đó chúng ta sẽ ghi ra giá trị là `20`.
 
-Lần gọi thứ ba chúng ta truyền vào một đối số: chính là `value`. Toán tử `*=` chính là cách viết gọn của `x.number = x.number * 2`: chúng ta thay đổi giá trị của `x.number`, và ghi ra giá trị `20`.
+Lần gọi thứ ba chúng ta truyền vào một đối số: chính là `value`. Toán tử `*=` chính là cách viết gọn của `x.number = x.number * 2`: chúng ta thay đổi giá trị của `x.number`, và ghi ra giá trị `20`. 
 
-Tại lần gọi thứ tư, chúng ta truyền vào `value` một lần nữa. `x.number` trước đó đã bị thay đổi thành `20`, nên `x.number *= 2` sẽ ghi ra `40`.
+Tại lần gọi thứ tư, chúng ta truyền vào `value` một lần nữa. `x.number` trước đó đã bị thay đổi thành `20`, nên `x.number *= 2` sẽ ghi ra `40`. 
 
 </p>
 </details>
@@ -2025,18 +2025,17 @@ Tại lần gọi thứ tư, chúng ta truyền vào `value` một lần nữa.
 
 #### Đáp án: D
 
-Đối số đầu tiên của hàm `reduce` chính là _accumulator_ (tổng tích lũy), trong trường hợp này là `x`. Đối số thứ 2 chính là _giá trị hiện tại_, tức `y`. Với hàm reduce, ta sẽ gọi callback trên mỗi phần tử của mảng, cứ vậy cho tới khi ra đến một giá trị cuối cùng.
+Đối số đầu tiên của hàm `reduce` chính là _accumulator_ (tổng tích lũy), trong trường hợp này là `x`. Đối số thứ 2 chính là _giá trị hiện tại_, tức `y`. Với hàm reduce, ta sẽ gọi callback trên mỗi phần tử của mảng, cứ vậy cho tới khi ra đến một giá trị cuối cùng. 
 
 Trong trường hợp này, chúng ta không trả về bất cứ giá trị nào cả, mà đơn thuần chỉ là ghi ra giá trị của _tổng tích lũy_ và _giá trị hiện tại_ mà thôi.
 
 Giá trị của tổng tích lũy chính là giá trị được hàm callback trả về tại vòng lặp trước đó. Nếu ta không đặt giá trị khởi tạo cho đối số trong hàm `reduce`, thì tổng tích lũy sẽ chính bằng giá trị đầu tiên tại lời gọi đầu tiên.
 
-Trong lời gọi đầu tiên, tổng tích lũy (`x`) là `1`, và giá trị hiện tại (`y`) là `2`. Chúng ta không trả về giá trị cho hàm callback, mà đơn thuần chỉ ghi chúng ta, vậy nên `1` và `2` được ghi ra.
+Trong lời gọi đầu tiên, tổng tích lũy (`x`) là `1`, và giá trị hiện tại (`y`) là `2`. Chúng ta không trả về giá trị cho hàm callback, mà đơn thuần chỉ ghi chúng ta, vậy nên `1` và `2` được ghi ra.  
 
-Nếu ta không trả về giá trị trong một function, thì nó sẽ mặc định trả về là `undefined`. Do đó trong lời gọi tiếp theo tổng tích lũy sẽ là `undefined`, và giá trị hiện tại là `3`. `undefined` và `3` sẽ được ghi ra.
+Nếu ta không trả về giá trị trong một function, thì nó sẽ mặc định trả về là `undefined`. Do đó trong lời gọi tiếp theo tổng tích lũy sẽ là `undefined`, và giá trị hiện tại là `3`. `undefined` và `3` sẽ được ghi ra. 
 
 Tiếp tục như vậy, trong lời gọi thứ tư thì tổng tích lũy sẽ vẫn là `undefined`, giá trị hiện tại là `4`. `undefined` và `4` sẽ được ghi ra.
-
 </p>
 </details>
   
@@ -2052,7 +2051,7 @@ class Dog {
 };
 
 class Labrador extends Dog {
-  // 1
+  // 1 
   constructor(name, size) {
     this.size = size;
   }
@@ -2066,7 +2065,7 @@ class Labrador extends Dog {
     super(name);
     this.size = size;
   }
-  // 4
+  // 4 
   constructor(name, size) {
     this.name = name;
     this.size = size;
@@ -2087,10 +2086,9 @@ class Labrador extends Dog {
 
 Trong class dẫn xuất, ta không thể truy cập từ khóa `this` trước khi gọi `super`. Nếu bạn chạy thử, nó sẽ throw ra một `ReferenceError`, do đó 1 và 4 sẽ throw ra reference error.
 
-Với việc gọi `super`, chúng ta đã gọi hàm constructor của class cha với tham số truyền vào. Trong trường hợp này, class cha nhận `name` làm đối số trong constructor, do đó chúng cần đưa `name` vào hàm `super`.
+Với việc gọi `super`, chúng ta đã gọi hàm constructor của class cha với tham số truyền vào. Trong trường hợp này, class cha nhận `name` làm đối số trong constructor, do đó chúng cần đưa `name` vào hàm `super`. 
 
 `Labrador` class nhận vào hai đối số, `name` vì nó kế thừa `Dog`, và `size` - một thuộc tính của `Labrador` class. Cả hai đều cần thiết để đưa vào trong constructor của class `Labrador`, do đó cách khởi tạo đúng là 2.
-
 </p>
 </details>
 
@@ -2100,12 +2098,12 @@ Với việc gọi `super`, chúng ta đã gọi hàm constructor của class ch
 
 ```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;
 ```
 
@@ -2121,7 +2119,7 @@ export const sum = (a, b) => a + b;
 
 Với `import`, tất cả các module import vào đều sẽ được _pre-parsed_ (đánh giá trước). Có nghĩa là những module được import vào sẽ được _chạy trước_, còn code trong file sẽ _chạy sau_.
 
-Đó chính là điều khác biệt giữa `require()` trong CommonJS và `import`! Với `require()`, ta có thể load các dependencies tại bất cứ khi nào ta cần. Nếu ta sử dụng `require` thay thế cho `import` thì `running index.js`, `running sum.js`, `3` sẽ được ghi ra.
+Đó chính là điều khác biệt giữa `require()` trong CommonJS và `import`! Với `require()`, ta có thể load các dependencies tại bất cứ khi nào ta cần. Nếu ta sử dụng `require` thay thế cho `import` thì `running index.js`, `running sum.js`, `3` sẽ được ghi ra. 
 
 </p>
 </details>
@@ -2146,7 +2144,7 @@ console.log(Symbol('foo') === Symbol('foo'))****
 
 #### Đáp án: A
 
-Mỗi Symbol là một thứ hoàn toàn khác biệt. Giá trị truyền vào làm đối số trong Symbol chỉ đơn thuần là phần giải thích cho Symbol đó mà thôi, và nó không liên quan gì tới giá trị của Symbol đó cả. Chúng ta kiểm tra tính bằng nhau của hai Symbol hoàn toàn khác biệt: `Symbol('foo')` thứ nhất, và `Symbol('foo')` thứ hai. Mỗi giá trị đều là riêng biệt và duy nhất, nên `Symbol('foo') === Symbol('foo')` sẽ trả về `false`.
+Mỗi Symbol là một thứ hoàn toàn khác biệt. Giá trị truyền vào làm đối số trong Symbol chỉ đơn thuần là phần giải thích cho Symbol đó mà thôi, và nó không liên quan gì tới giá trị của Symbol đó cả. Chúng ta kiểm tra tính bằng nhau của hai Symbol hoàn toàn khác biệt: `Symbol('foo')` thứ nhất, và `Symbol('foo')` thứ hai. Mỗi giá trị đều là riêng biệt và duy nhất, nên `Symbol('foo') === Symbol('foo')` sẽ trả về `false`. 
 
 </p>
 </details>
@@ -2156,15 +2154,15 @@ Mỗi Symbol là một thứ hoàn toàn khác biệt. Giá trị truyền vào
 ###### 69. Output là gì?
 
 ```javascript
-const name = "Lydia Hallie";
-console.log(name.padStart(13));
-console.log(name.padStart(2));
+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"`,
+- D: `"Lydia Hallie"`, `"Lyd"`, 
 
 <details><summary><b>Đáp án</b></summary>
 <p>
@@ -2239,9 +2237,7 @@ Khi ta gọi `game.next("Yes").value`, `yield` trước đó sẽ được thay
 </details>
 
 ---
-
----
-
+****
 ###### 72. Output là gì?
 
 ```javascript
@@ -2434,7 +2430,7 @@ Hàm `sum` luôn trả về giá trị giống nhau. Nếu ta đưa vào `1` và
 ```javascript
 const add = () => {
   const cache = {};
-  return (num) => {
+  return num => {
     if (num in cache) {
       return `From cache! ${cache[num]}`;
     } else {
@@ -2479,21 +2475,21 @@ Tại lần gọi thứ ba, ta đưa vào `5 * 2`, tức `10` vào hàm. Tiếp
 ###### 79. Output là gì?
 
 ```javascript
-const myLifeSummedUp = ["☕", "💻", "🍷", "🍫"];
+const myLifeSummedUp = ["☕", "💻", "🍷", "🍫"]
 
 for (let item in myLifeSummedUp) {
-  console.log(item);
+  console.log(item)
 }
 
 for (let item of myLifeSummedUp) {
-  console.log(item);
+  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: "🍫"}`
+- D:  `0` `1` `2` `3` and `{0: "☕", 1: "💻", 2: "🍷", 3: "🍫"}`
 
 <details><summary><b>Đáp án</b></summary>
 <p>
@@ -2516,14 +2512,14 @@ Với vòng lặp _for-of_, chúng ta sẽ duyệt qua các phần tử của m
 ###### 80. Output là gì?
 
 ```javascript
-const list = [1 + 2, 1 * 2, 1 / 2];
-console.log(list);
+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]`
+- D:  `[1, 1, 1]`
 
 <details><summary><b>Đáp án</b></summary>
 <p>
@@ -2532,7 +2528,7 @@ console.log(list);
 
 Mảng có thể nhận bất cứ giá trị nào. Số, chuỗi, objects, mảng khác, null, boolean, undefined, và nhiều dạng biểu thức nữa như ngày tháng, hàm, và các tính toán.
 
-Giá trị của phần tử chính là giá trị trả về. `1 + 2` trả về `3`, `1 * 2` trả về `2`, và `1 / 2` trả về `0.5`.
+Giá trị của phần tử chính là giá trị trả về.  `1 + 2` trả về `3`, `1 * 2` trả về `2`, và `1 / 2` trả về `0.5`.
 
 </p>
 </details>
@@ -2543,16 +2539,16 @@ Giá trị của phần tử chính là giá trị trả về. `1 + 2` trả v
 
 ```javascript
 function sayHi(name) {
-  return `Hi there, ${name}`;
+  return `Hi there, ${name}`
 }
 
-console.log(sayHi());
+console.log(sayHi())
 ```
 
 - A: `Hi there, `
 - B: `Hi there, undefined`
 - C: `Hi there, null`
-- D: `ReferenceError`
+- D:  `ReferenceError`
 
 <details><summary><b>Đáp án</b></summary>
 <p>
@@ -2575,21 +2571,21 @@ Trong trường hợp này, nếu ta không đưa giá trị nào vào hoặc đ
 ###### 82. Output là gì?
 
 ```javascript
-var status = "😎";
+var status = "😎"
 
 setTimeout(() => {
-  const status = "😍";
+  const status = "😍"
 
   const data = {
     status: "🥑",
     getStatus() {
-      return this.status;
-    },
-  };
+      return this.status
+    }
+  }
 
-  console.log(data.getStatus());
-  console.log(data.getStatus.call(this));
-}, 0);
+  console.log(data.getStatus())
+  console.log(data.getStatus.call(this))
+}, 0)
 ```
 
 - A: `"🥑"` and `"😍"`
@@ -2616,13 +2612,13 @@ Với phương thức `call`, chúng ta thay đổi tham chiếu mà `this` tr
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21,
-};
+  age: 21
+}
 
-let city = person.city;
-city = "Amsterdam";
+let city = person.city
+city = "Amsterdam"
 
-console.log(person);
+console.log(person)
 ```
 
 - A: `{ name: "Lydia", age: 21 }`
@@ -2635,13 +2631,13 @@ console.log(person);
 
 #### Đáp án: A
 
-Chúng ta set biến `city` bằng với giá trị của thuộc tính `city` của object `person`. Nhưng object này không có thuộc tính nào là `city` cả, nên giá trị của biến `city` sẽ là `undefined`.
+Chúng ta set biến `city` bằng với giá trị của thuộc tính `city` của object `person`. Nhưng object này không có thuộc tính nào là `city` cả, nên giá trị của biến `city` sẽ là `undefined`. 
 
 Chú ý là chúng ta _không tham chiếu_ tới bản thân object `person`! Chúng ta chỉ đơn giản là set giá trị của biến `city` bằng với giá trị của thuộc tính `city` trong object `person` mà thôi.
 
 Sau đó chúng ta set biến `city` bằng với chuỗi `"Amsterdam"`. Điều này không hề ảnh hưởng gì tới object person vì không có tham chiếu nào ở đây cả.
 
-Do đó khi ghi object `person` ra, Tất cả các thuộc tính vẫn như cũ không hề thay đổi gì cả.
+Do đó khi ghi object `person` ra, Tất cả các thuộc tính vẫn như cũ không hề thay đổi gì cả. 
 
 </p>
 </details>
@@ -2653,15 +2649,15 @@ Do đó khi ghi object `person` ra, Tất cả các thuộc tính vẫn như cũ
 ```javascript
 function checkAge(age) {
   if (age < 18) {
-    const message = "Sorry, you're too young.";
+    const message = "Sorry, you're too young."
   } else {
-    const message = "Yay! You're old enough!";
+    const message = "Yay! You're old enough!"
   }
 
-  return message;
+  return message
 }
 
-console.log(checkAge(21));
+console.log(checkAge(21))
 ```
 
 - A: `"Sorry, you're too young."`
@@ -2684,15 +2680,15 @@ Biến số được khai báo với các từ khóa như `const` hay `let` đ
 ###### 85. Những thông tin nào sẽ được ghi ra?
 
 ```javascript
-fetch("https://www.website.com/api/user/1")
-  .then((res) => res.json())
-  .then((res) => console.log(res));
+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.
+- D: It would always be undefined. 
 
 <details><summary><b>Đáp án</b></summary>
 <p>
@@ -2740,7 +2736,7 @@ Bằng cách set `hasName` bằng với `name`, chúng ta set `hasName` bằng v
 ###### <a name=20190805></a>87. Output là gì?
 
 ```javascript
-console.log("I want pizza"[0]);
+console.log("I want pizza"[0])
 ```
 
 - A: `"""`
@@ -2766,10 +2762,10 @@ Chú ý là phương thức này không hoạt động với IE7 trở xuống.
 
 ```javascript
 function sum(num1, num2 = num1) {
-  console.log(num1 + num2);
+  console.log(num1 + num2)
 }
 
-sum(10);
+sum(10)
 ```
 
 - A: `NaN`
@@ -2784,7 +2780,7 @@ sum(10);
 
 Ta có thể set giá trị mặc định của một tham số là tham số khác trong hàm, miễn là tham số đó được khai báo _trước_ tham số mặc định. Chúng ta đưa `10` vào hàm `sum`. Nếu hàm `sum` chỉ nhận 1 đối số, nó có nghĩa là giá trị của `num2` không được đưa vào, nên nó sẽ lấy giá trị mặc định là giá trị của `num1` đã được đưa vào, hay chính là `10` trong trường hợp này. Khi này `num1 + num2` trả về `20`.
 
-Nếu chúng ta thử set một giá trị mặc định của tham số bằng với giá trị của tham số khai báo _sau_ (về bên phải), giá trị của tham số đó sẽ không được khởi tạo và dẫn đến throw ra lỗi.
+Nếu chúng ta thử set một giá trị mặc định của tham số bằng với giá trị của tham số khai báo _sau_ (về bên phải), giá trị của tham số đó sẽ không được khởi tạo và dẫn đến throw ra lỗi. 
 
 </p>
 </details>
@@ -2794,14 +2790,14 @@ Nếu chúng ta thử set một giá trị mặc định của tham số bằng
 ###### 89. Output là gì?
 
 ```javascript
-// module.js
-export default () => "Hello world";
-export const name = "Lydia";
+// module.js 
+export default () => "Hello world"
+export const name = "Lydia"
 
-// index.js
-import * as data from "./module";
+// index.js 
+import * as data from "./module"
 
-console.log(data);
+console.log(data)
 ```
 
 - A: `{ default: function default(), name: "Lydia" }`
@@ -2814,9 +2810,9 @@ console.log(data);
 
 #### Đáp án: A
 
-Cú pháp `import * as data` sẽ import _tất cả những gì được export_ từ `module.js` vào trong `index.js` và lưu trữ dưới một object có tên là `data`. Trong file `module.js`, có hai thứ được export ra: default export và một named export. Default export là một hàm trả về chuỗi `"Hello World"`, và named export là một biến `name` nhận giá trị là chuỗi `"Lydia"`.
+Cú pháp `import * as data` sẽ import _tất cả những gì được export_ từ `module.js` vào trong `index.js` và lưu trữ dưới một object có tên là `data`. Trong file `module.js`, có hai thứ được export ra: default export và một named export. Default export là một hàm trả về chuỗi `"Hello World"`, và named export là một biến `name` nhận giá trị là chuỗi `"Lydia"`. 
 
-Do đó `data` object có thuộc tính `default` cho default export, các thuộc tính khác sẽ có tên chính là tên của named exports và giá trị đi kèm.
+Do đó `data` object có thuộc tính `default` cho default export, các thuộc tính khác sẽ có tên chính là tên của named exports và giá trị đi kèm. 
 
 </p>
 </details>
@@ -2828,12 +2824,12 @@ Do đó `data` object có thuộc tính `default` cho default export, các thu
 ```javascript
 class Person {
   constructor(name) {
-    this.name = name;
+    this.name = name
   }
 }
 
-const member = new Person("John");
-console.log(typeof member);
+const member = new Person("John")
+console.log(typeof member)
 ```
 
 - A: `"class"`
@@ -2850,11 +2846,11 @@ Classes chỉ đơn thuần là `syntactical sugar` (cú pháp đặc biệt) c
 
 ```javascript
 function Person() {
-  this.name = name;
+  this.name = name
 }
 ```
 
-Gọi một constructor với từ khóa `new` sẽ tạo ra một instance của class `Person`, `typeof` sẽ trả về là `"object"` cho các instance. Do đó `typeof member` trả về `"object"`.
+Gọi một constructor với từ khóa `new` sẽ tạo ra một instance của class `Person`, `typeof` sẽ trả về là `"object"` cho các instance. Do đó `typeof member` trả về `"object"`. 
 
 </p>
 </details>
@@ -2864,9 +2860,9 @@ Gọi một constructor với từ khóa `new` sẽ tạo ra một instance củ
 ###### 91. Output là gì?
 
 ```javascript
-let newList = [1, 2, 3].push(4);
+let newList = [1, 2, 3].push(4)
 
-console.log(newList.push(5));
+console.log(newList.push(5))
 ```
 
 - A: `[1, 2, 3, 4, 5]`
@@ -2879,7 +2875,7 @@ console.log(newList.push(5));
 
 #### Đáp án: D
 
-Hàm `.push` trả về _độ dài mới_ của mảng, chứ không phải bản thân mảng đó! Bằng cách set `newList` bằng với `[1, 2, 3].push(4)`, ta đã set cho `newList` giá trị là `4` - tức độ dài của mảng lúc này.
+Hàm `.push` trả về _độ dài mới_ của mảng, chứ không phải bản thân mảng đó! Bằng cách set `newList` bằng với `[1, 2, 3].push(4)`, ta đã set cho `newList` giá trị là `4` - tức độ dài của mảng lúc này. 
 
 Sau đó chúng ta tiến hành `.push` trên `newList`. Vì `newList` là một số thông thường, ta không thể dùng `.push` được, nên sẽ throw ra một TypeError.
 
@@ -2892,18 +2888,17 @@ Sau đó chúng ta tiến hành `.push` trên `newList`. Vì `newList` là một
 
 ```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);
+console.log(giveLydiaPizza.prototype)
+console.log(giveLydiaChocolate.prototype)
 ```
 
-- A: `{ constructor: ...}` `{ constructor: ...}`
-- B: `{}` `{ constructor: ...}`
+- A: `{ constructor: ...}` `{ constructor: ...}` 
+- B: `{}` `{ constructor: ...}` 
 - C: `{ constructor: ...}` `{}`
 - D: `{ constructor: ...}` `undefined`
 
@@ -2912,7 +2907,7 @@ console.log(giveLydiaChocolate.prototype);
 
 #### Đáp án: D
 
-Hàm thông thường giống như `giveLydiaPizza`, sẽ có thuộc tính `prototype` là một object (prototype object) với một thuộc tính là `constructor`. Còn `arrow functions` giống như `giveLydiaChocolate`thì không có thuộc tính `prototype` này. `undefined` trả về khi ta truy cập thuộc tính `prototype` bằng cách gọi `giveLydiaChocolate.prototype`.
+Hàm thông thường giống như `giveLydiaPizza`, sẽ có thuộc tính `prototype` là một object (prototype object) với một thuộc tính là `constructor`. Còn `arrow functions` giống như `giveLydiaChocolate`thì không có thuộc tính `prototype` này. `undefined` trả về khi ta truy cập thuộc tính `prototype` bằng cách gọi `giveLydiaChocolate.prototype`. 
 
 </p>
 </details>
@@ -2924,16 +2919,16 @@ Hàm thông thường giống như `giveLydiaPizza`, sẽ có thuộc tính `pro
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21,
-};
+  age: 21
+}
 
 for (const [x, y] of Object.entries(person)) {
-  console.log(x, y);
+  console.log(x, y)
 }
 ```
 
 - A: `name` `Lydia` và `age` `21`
-- B: `["name", "Lydia"]` và `["age", 21]`
+- B: `["name", "Lydia"]` và `["age", 21]` 
 - C: `["name", "age"]` và `undefined`
 - D: `Error`
 
@@ -2944,9 +2939,9 @@ for (const [x, y] of Object.entries(person)) {
 
 `Object.entries(person)` sẽ trả về một mảng của mảng, bao gồm các key và các object:
 
-`[ [ 'name', 'Lydia' ], [ 'age', 21 ] ]`
+`[ [ 'name', 'Lydia' ], [ 'age', 21 ] ]` 
 
-Khí sử dụng `for-of`, chúng ta sẽ duyệt qua từng thành phần của mảng, trong trường hợp này chính là những mảng con. Đồng thời tiến hành gán giá trị luôn trong vongf lặp for-of, bằng cách sử dụng `const [x, y]`. Khi này `x` sẽ là phần tử đầu tiên trong mảng con, `y` chính là phần tử thứ hai trong mảng con.
+Khí sử dụng `for-of`, chúng ta sẽ duyệt qua từng thành phần của mảng, trong trường hợp này chính là những mảng con. Đồng thời tiến hành gán giá trị luôn trong vongf lặp for-of, bằng cách sử dụng `const [x, y]`. Khi này `x` sẽ là phần tử đầu tiên trong mảng con, `y` chính là phần tử thứ hai trong mảng con. 
 
 Mảng con đầu tiên là `[ "name", "Lydia" ]`, nên `x` sẽ là `"name"`, và `y` sẽ là `"Lydia"`, và được ghi ra.
 Mảng con thứ hai là `[ "age", 21 ]`, nên `x` sẽ là `"age"`, và `y` sẽ là `21`, và được ghi ra.
@@ -2967,7 +2962,7 @@ getItems(["banana", "apple"], "pear", "orange")
 ```
 
 - A: `["banana", "apple", "pear", "orange"]`
-- B: `[["banana", "apple"], "pear", "orange"]`
+- B: `[["banana", "apple"], "pear", "orange"]` 
 - C: `["banana", "apple", ["pear"], "orange"]`
 - D: `SyntaxError`
 
@@ -2976,18 +2971,17 @@ getItems(["banana", "apple"], "pear", "orange")
 
 #### Đáp án: D
 
-`...args` là cú pháp tham số cuối cùng. Giá trị của tham số cuối cùng chính là toàn bộ các đối số còn lại, **và nó là tham số cuối cùng duy nhất**! Trong trường hợp này, tham số cuối cùng lại là tham số thứ hai. Điều đó là không thể được, và sẽ throw ra một lỗi cú pháp.
+`...args` là cú pháp tham số cuối cùng. Giá trị của tham số cuối cùng chính là toàn bộ các đối số còn lại, **và nó là tham số cuối cùng duy nhất**! Trong trường hợp này, tham số cuối cùng lại là tham số thứ hai. Điều đó là không thể được, và sẽ throw ra một lỗi cú pháp. 
 
 ```javascript
 function getItems(fruitList, favoriteFruit, ...args) {
-  return [...fruitList, ...args, favoriteFruit];
+  return [...fruitList, ...args, favoriteFruit]
 }
 
-getItems(["banana", "apple"], "pear", "orange");
+getItems(["banana", "apple"], "pear", "orange")
 ```
 
 Nếu ta code như thế này thì lại đúng. Giá trị trả về sẽ là `[ 'banana', 'apple', 'orange', 'pear' ]`
-
 </p>
 </details>
 
@@ -2997,14 +2991,17 @@ Nếu ta code như thế này thì lại đúng. Giá trị trả về sẽ là
 
 ```javascript
 function nums(a, b) {
-  if (a > b) console.log("a is bigger");
-  else console.log("b is bigger");
-  return;
-  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));
+console.log(nums(4, 2))
+console.log(nums(1, 2))
 ```
 
 - A: `a is bigger`, `6` và `b is bigger`, `3`
@@ -3017,13 +3014,13 @@ console.log(nums(1, 2));
 
 #### Đáp án: B
 
-Với JavaScript, ta _không bắt buộc_ phải viết dấu chấm phẩy (`;`), JavaScript engine sẽ tự động thêm vào sau mỗi câu lệnh. Nó gọi là **Automatic Semicolon Insertion**. Một câu lệnh có thể là khai báo biến, hoặc từ khóa như `throw`, `return`, `break`, vv.
+Với JavaScript, ta _không bắt buộc_ phải viết dấu chấm phẩy (`;`), JavaScript engine sẽ tự động thêm vào sau mỗi câu lệnh. Nó gọi là **Automatic Semicolon Insertion**. Một câu lệnh có thể là khai báo biến, hoặc từ khóa như `throw`, `return`, `break`, vv. 
 
 Ở đây ta sử dụng câu lệnh `return` ở một dòng và giá trị `a + b` ở một _dòng khác_. Tuy nhiên do khác dòng nên JS engine không thể biết đâu là giá trị ta thực sự muốn trả về. Thay vì thế, nó sẽ tự động thêm vào dấu chấm phẩy ngay sau `return` giống như này:
 
 ```javascript
-return;
-a + b;
+  return;
+  a + b
 ```
 
 Có nghĩa là `a + b` sẽ không bao giờ được thực hiện, vì hàm đã được `return` rồi. Do không giá trị nào được trả về, nên giá trị trả về của hàm sẽ là `undefined`. Lưu ý là sẽ không tự động thêm dấu chấm phẩy ngay sau `if/else` đâu nhé!
@@ -3038,18 +3035,18 @@ Có nghĩa là `a + b` sẽ không bao giờ được thực hiện, vì hàm đ
 ```javascript
 class Person {
   constructor() {
-    this.name = "Lydia";
+    this.name = "Lydia"
   }
 }
 
 Person = class AnotherPerson {
   constructor() {
-    this.name = "Sarah";
+    this.name = "Sarah"
   }
-};
+}
 
-const member = new Person();
-console.log(member.name);
+const member = new Person()
+console.log(member.name)
 ```
 
 - A: `"Lydia"`
@@ -3073,11 +3070,11 @@ Chúng ta có thể set một class với giá trị là một classes/function
 
 ```javascript
 const info = {
-  [Symbol("a")]: "b",
-};
+  [Symbol('a')]: 'b'
+}
 
-console.log(info);
-console.log(Object.keys(info));
+console.log(info)
+console.log(Object.keys(info))
 ```
 
 - A: `{Symbol('a'): 'b'}` và `["{Symbol('a')"]`
@@ -3124,13 +3121,13 @@ console.log(getUser(user))
 
 Hàm `getList` nhận vào một mảng các đối số, và tiến hành xử lý mảng đó luôn khi đưa vào hàm:
 
-`[x, ...y] = [1, 2, 3, 4]`
+ `[x, ...y] = [1, 2, 3, 4]`
 
-Với việc sử dụng cú pháp tham số cuối cùng `...y`, chúng ta đưa toàn bộ "những đối số còn lại" vào một mảng y. Trong trường hợp này đó là mảng gồm các phần tử `2`, `3` và `4`. Do đó giá trị của `y` lúc này chính là mảng `[2, 3, 4]`. Giá trị của `x` là `1`, nên khi ghi `[x, y]` ra, kết quả sẽ là `[1, [2, 3, 4]]`.
+ Với việc sử dụng cú pháp tham số cuối cùng `...y`, chúng ta đưa toàn bộ "những đối số còn lại" vào một mảng y. Trong trường hợp này đó là mảng gồm các phần tử `2`, `3` và `4`. Do đó giá trị của `y` lúc này chính là mảng `[2, 3, 4]`. Giá trị của `x` là `1`, nên khi ghi `[x, y]` ra, kết quả sẽ là `[1, [2, 3, 4]]`.
 
 Hàm `getUser` nhận vào một object. Với cú pháp arrow function, chúng ta sẽ không phải viết trong ngoặc nhọn `{}` nữa nếu ta chỉ muốn đơn thuần trả về giá trị. Tuy nhiên, nếu ta muốn trả về một _object_ t arrow function, ta sẽ phải viết chúng trong dấu ngoặc tròn `()`, nếu không thì sẽ không có giá trị nào được trả về! Ví dụ như sau:
 
-`const getUser = user => ({ name: user.name, age: user.age })`
+```const getUser = user => ({ name: user.name, age: user.age })```
 
 Do không giá trị nào được trả về, kết quả sẽ là `undefined`.
 
@@ -3142,9 +3139,9 @@ Do không giá trị nào được trả về, kết quả sẽ là `undefined`.
 ###### 99. Output là gì?
 
 ```javascript
-const name = "Lydia";
+const name = "Lydia"
 
-console.log(name());
+console.log(name())
 ```
 
 - A: `SyntaxError`
@@ -3157,11 +3154,11 @@ console.log(name());
 
 #### Đáp án: C
 
-Biến `name` có giá trị là một chuỗi, không phải hàm, vì thế không thể gọi được.
+Biến `name` có giá trị là một chuỗi, không phải hàm, vì thế không thể gọi được. 
 
 TypeErrors sẽ được throw ra nếu một giá trị không được sử dụng đúng kiểu. JavaScript muốn `name` là một hàm khi ta tiến hành gọi nó. Nhưng nó là chuỗi, nên sẽ throw ra một TypeError.
 
-SyntaxErrors sẽ được throw khi ta viết code không đúng cú pháp của JavaScript, ví dụ thay vì `return` ta viết `retrun`.
+SyntaxErrors sẽ được throw khi ta viết code không đúng cú pháp của JavaScript, ví dụ thay vì `return` ta viết `retrun`. 
 
 ReferenceErrors sẽ được throw ra khi Javascript không thể tìm được tham chiếu nào đến giá trị mà ta đang cố truy cập.
 
@@ -3175,8 +3172,8 @@ ReferenceErrors sẽ được throw ra khi Javascript không thể tìm được
 ```javascript
 // 🎉✨ Đây là câu hỏi thứ 100 của tôi! ✨🎉
 
-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`
@@ -3201,11 +3198,11 @@ You should${"" && `n't`} see a therapist after so much JavaScript lol`;
 ###### 101. Output là gì?
 
 ```javascript
-const one = false || {} || null;
-const two = null || false || "";
-const three = [] || 0 || true;
+const one = (false || {} || null)
+const two = (null || false || "")
+const three = ([] || 0 || true)
 
-console.log(one, two, three);
+console.log(one, two, three)
 ```
 
 - A: `false` `null` `[]`
@@ -3234,20 +3231,20 @@ Với phép toán `||`, ta sẽ trả về giá trị truethy đầu tiên. Nế
 ###### 102. Output là gì?
 
 ```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");
+  myPromise().then(res => console.log(res))
+  console.log('second')
 }
 
 async function secondFunction() {
-  console.log(await myPromise());
-  console.log("second");
+  console.log(await myPromise())
+  console.log('second')
 }
 
-firstFunction();
-secondFunction();
+firstFunction()
+secondFunction()
 ```
 
 - A: `I have resolved!`, `second` và `I have resolved!`, `second`
@@ -3264,11 +3261,11 @@ Có thể tưởng tượng đơn giản cách promise thực thi như sau: _bâ
 
 Dù chúng ta có thể sử dụng giá trị thu được bằng cú pháp `.then`, hoặc sử dụng cặp cú pháp `await/async`, nhưng, cách chúng hoạt động là khác nhau.
 
-Trong `firstFunction`, chúng ta đưa promise qua một bên chờ cho nó tính toán xong, và vẫn tiếp tục chạy những code tiếp sau đó, theo đó `console.log('second')` sẽ được chạy. Sau đó promise được hoàn thành trả về giá trị `I have resolved`, giá trị này sẽ được log ra khi call stack trở nên rỗng.
+Trong `firstFunction`, chúng ta đưa promise qua một bên chờ cho nó tính toán xong, và vẫn tiếp tục chạy những code tiếp sau đó, theo đó `console.log('second')` sẽ được chạy. Sau đó promise được hoàn thành trả về giá trị `I have resolved`, giá trị này sẽ được log ra khi call stack trở nên rỗng. 
 
 Với từ khóa `await` trong `secondFunction`, ta đã tạm dừng một hàm bất đồng bộ cho tới khi chúng trả về giá trị, sau đó ta mới đi tiếp đến các câu lệnh tiếp theo.
 
-Do đó nó sẽ chờ cho tới khi `myPromise` được hoàn thành và trả về giá trị `I have resolved`, sau đó chúng ta sẽ chạy tiếp câu lệnh tiếp theo in ra `second`.
+Do đó nó sẽ chờ cho tới khi `myPromise` được hoàn thành và trả về giá trị `I have resolved`, sau đó chúng ta sẽ chạy tiếp câu lệnh tiếp theo in ra `second`. 
 
 </p>
 </details>
@@ -3278,14 +3275,14 @@ Do đó nó sẽ chờ cho tới khi `myPromise` được hoàn thành và trả
 ###### 103. Output là gì?
 
 ```javascript
-const set = new Set();
+const set = new Set()
 
-set.add(1);
-set.add("Lydia");
-set.add({ name: "Lydia" });
+set.add(1)
+set.add("Lydia")
+set.add({ name: "Lydia" })
 
 for (let item of set) {
-  console.log(item + 2);
+  console.log(item + 2)
 }
 ```
 
@@ -3299,11 +3296,11 @@ for (let item of set) {
 
 #### Đáp án: C
 
-Phép toán `+` không chỉ dùng để cộng các số, mà nó còn dùng để nối chuỗi nữa. Mỗi khi Javascript engine gặp một giá trị trong phép toán không phải dạng số, nó sẽ chuyển các số trong phép toán đó sang dạng chuỗi.
+Phép toán `+` không chỉ dùng để cộng các số, mà nó còn dùng để nối chuỗi nữa. Mỗi khi Javascript engine gặp một giá trị trong phép toán không phải dạng số, nó sẽ chuyển các số trong phép toán đó sang dạng chuỗi. 
 
 Phép toán đầu tiên item là một số `1`, nên `1 + 2` trả về 3.
 
-Ở phép toán thứ hai, item là một chuỗi `"Lydia"`. trong khi đó `2` là một số, nên `2` sẽ bị chuyển sang dạng chuỗi, sau khi nối vào ta có chuỗi `"Lydia2"`.
+Ở phép toán thứ hai, item là một chuỗi `"Lydia"`. trong khi đó `2` là một số, nên `2` sẽ bị chuyển sang dạng chuỗi, sau khi nối vào ta có chuỗi `"Lydia2"`. 
 
 Ở phép toán thứ ba, `{ name: "Lydia" }` là một object. Tuy nhiên dù có là object hay gì đi nữa thì nó cũng sẽ bị chuyển sang dạng chuỗi. Đối với object thì khi chuyển sang dạng chuỗi nó sẽ trở thành `"[object Object]"`. `"[object Object]"` nối với `"2"` trở thành `"[object Object]2"`.
 
@@ -3315,7 +3312,7 @@ Phép toán đầu tiên item là một số `1`, nên `1 + 2` trả về 3.
 ###### 104. Output là gì?
 
 ```javascript
-Promise.resolve(5);
+Promise.resolve(5)
 ```
 
 - A: `5`
@@ -3330,7 +3327,7 @@ Promise.resolve(5);
 
 Ta có thể truyền vào giá trị bất kì cho `Promise.resolve`, dù có là promise hay không promise. Bản thân nó sẽ là một hàm trả về một promise với giá trị đã được resolved.
 
-Trong trường hợp này ta đưa vào giá trị `5`. Nó sẽ trả về một resolved promise với giá trị `5`.
+Trong trường hợp này ta đưa vào giá trị `5`. Nó sẽ trả về một resolved promise với giá trị `5`. 
 
 </p>
 </details>
@@ -3342,15 +3339,15 @@ Trong trường hợp này ta đưa vào giá trị `5`. Nó sẽ trả về m
 ```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);
+compareMembers(person)
 ```
 
 - A: `Not the same!`
@@ -3363,7 +3360,7 @@ compareMembers(person);
 
 #### Đáp án: B
 
-Object sẽ được truyền vào hàm theo reference. Khi chúng ta nói so sánh strict equal (`===`), nghĩa là ta đang so sánh các reference của chúng.
+Object sẽ được truyền vào hàm theo reference. Khi chúng ta nói so sánh strict equal (`===`), nghĩa là ta đang so sánh các reference của chúng. 
 
 Ta set giá trị mặc định của `person2` là object `person`, và đưa object `person` vào làm giá trị cho đối số `person1`.
 
@@ -3383,11 +3380,11 @@ const colorConfig = {
   green: true,
   black: true,
   yellow: false,
-};
+}
 
-const colors = ["pink", "red", "blue"];
+const colors = ["pink", "red", "blue"]
 
-console.log(colorConfig.colors[1]);
+console.log(colorConfig.colors[1])
 ```
 
 - A: `true`
@@ -3400,11 +3397,11 @@ console.log(colorConfig.colors[1]);
 
 #### Đáp án: D
 
-Trong Javascript ta có hai cách để truy cập thuộc tính của một object: sử dụng ngoặc vuông `[]`, hoặc sử dụng chấm `.`. Trong trương hợp này chúng ta sử dụng chấm (`colorConfig.colors`) thay cho ngoặc vuông (`colorConfig["colors"]`).
+Trong Javascript ta có hai cách để truy cập thuộc tính của một object: sử dụng ngoặc vuông `[]`, hoặc sử dụng chấm `.`. Trong trương hợp này chúng ta sử dụng chấm (`colorConfig.colors`) thay cho ngoặc vuông (`colorConfig["colors"]`). 
 
-Với cách sử dụng chấm, Javascript sẽ tìm kiếm một thuộc tính có tên chính xác như tên ta đưa vào. Trong trường hợp này nó là thuộc tính `colors` trong object `colorConfig` Tuy nhiên trong object này không có thuộc tính nào tên là `colors`, nên nó sẽ trả về `undefined`. Sau đó chúng ta cố truy cậ vào thuộc tính 1 của nó bằng cách gọi `[1]`. Chúng ta không thể làm như vậy trên giá trị `undefined`, nên nó sẽ trả về `TypeError`: `Cannot read property '1' of undefined`.
+Với cách sử dụng chấm, Javascript sẽ tìm kiếm một thuộc tính có tên chính xác như tên ta đưa vào. Trong trường hợp này nó là thuộc tính `colors` trong object `colorConfig` Tuy nhiên trong object này không có thuộc tính nào tên là  `colors`, nên nó sẽ trả về `undefined`. Sau đó chúng ta cố truy cậ vào thuộc tính 1 của nó bằng cách gọi `[1]`. Chúng ta không thể làm như vậy trên giá trị `undefined`, nên nó sẽ trả về `TypeError`: `Cannot read property '1' of undefined`.
 
-Javascript thông dịch theo câu lệnh. Khi ta sử dụng ngoặc vuông, Nnó sẽ tìm mở ngoặc đầu tiên `[` và tiếp tục cho tới khi gặp đóng ngoặc tương ứng `]`. Chỉ khi đó nó mới đánh giá câu lệnh. Nếu chúng ta sử dụng cú pháp `colorConfig[colors[1]]`, nó sẽ trả về giá trị của thuộc tính `red` trong object `colorConfig`.
+Javascript thông dịch theo câu lệnh. Khi ta sử dụng ngoặc vuông, Nnó sẽ tìm mở ngoặc đầu tiên `[` và tiếp tục cho tới khi gặp đóng ngoặc tương ứng `]`. Chỉ khi đó nó mới đánh giá câu lệnh. Nếu chúng ta sử dụng cú pháp `colorConfig[colors[1]]`, nó sẽ trả về giá trị của thuộc tính `red` trong object `colorConfig`. 
 
 </p>
 </details>
@@ -3414,7 +3411,7 @@ Javascript thông dịch theo câu lệnh. Khi ta sử dụng ngoặc vuông, Nn
 ###### 107. Ouput là gì?
 
 ```javascript
-console.log("❤️" === "❤️");
+console.log('❤️' === '❤️')
 ```
 
 - A: `true`
@@ -3425,7 +3422,7 @@ console.log("❤️" === "❤️");
 
 #### Đáp án: A
 
-Về cơ bản, emoji vẫn là các ký tự unicode mà thôi. Mã unicode cho hình trái tim là `"U+2764 U+FE0F"`. Chúng luôn luôn là một, nên phép toán đơn giản trả về `true`.
+Về cơ bản, emoji vẫn là các ký tự unicode mà thôi. Mã unicode cho hình trái tim là `"U+2764 U+FE0F"`. Chúng luôn luôn là một, nên phép toán đơn giản trả về `true`. 
 
 </p>
 </details>
@@ -3435,19 +3432,19 @@ Về cơ bản, emoji vẫn là các ký tự unicode mà thôi. Mã unicode cho
 ###### 108. Phép toán nào sau đây làm thay đổi mảng gốc?
 
 ```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`
 - B: `map` `reduce` `slice` `splice`
-- C: `map` `slice` `splice`
+- C: `map` `slice` `splice` 
 - D: `splice`
 
 <details><summary><b>Đáp án</b></summary>
@@ -3455,7 +3452,7 @@ emojis.splice(1, 2, "✨");
 
 #### Đáp án: D
 
-Với `splice`, ta thay đổi mảng gốc bằng cách thêm sửa xóa các phần tử. Trong trường hợp này ta xóa 2 phần tử kể từ index 1 (ta xóa `'🥑'` và `'😍'`) và thêm vào ✨ emoji.
+Với `splice`, ta thay đổi mảng gốc bằng cách thêm sửa xóa các phần tử. Trong trường hợp này ta xóa 2 phần tử kể từ index 1 (ta xóa `'🥑'` và `'😍'`) và thêm vào ✨ emoji. 
 
 `map`, `filter` và `slice` trả về một mảng mới, `find` trả về một phần tử, và `reduce` trả về giá trị tích lũy.
 
@@ -3467,17 +3464,17 @@ Với `splice`, ta thay đổi mảng gốc bằng cách thêm sửa xóa các p
 ###### 109. Output là gì?
 
 ```javascript
-const food = ["🍕", "🍫", "🥑", "🍔"];
-const info = { favoriteFood: food[0] };
+const food = ['🍕', '🍫', '🥑', '🍔']
+const info = { favoriteFood: food[0] }
 
-info.favoriteFood = "🍝";
+info.favoriteFood = '🍝'
 
-console.log(food);
+console.log(food)
 ```
 
 - A: `['🍕', '🍫', '🥑', '🍔']`
 - B: `['🍝', '🍫', '🥑', '🍔']`
-- C: `['🍝', '🍕', '🍫', '🥑', '🍔']`
+- C: `['🍝', '🍕', '🍫', '🥑', '🍔']` 
 - D: `ReferenceError`
 
 <details><summary><b>Đáp án</b></summary>
@@ -3497,7 +3494,7 @@ Bản thân mảng `food` không hề thay đổi, do giá trị của `favorite
 ###### 110. Phép toán này dùng để làm gì?
 
 ```javascript
-JSON.parse();
+JSON.parse()
 ```
 
 - A: Parse JSON thành một giá trị JavaScript
@@ -3510,22 +3507,22 @@ JSON.parse();
 
 #### Đáp án: A
 
-Với phương thức `JSON.parse()`, ta sẽ parse một chuỗi JSON thành một giá trị JavaScript.
+Với phương thức `JSON.parse()`, ta sẽ parse một chuỗi JSON thành một giá trị JavaScript. 
 
 Ví dụ:
 
 ```javascript
 // Chuyển một số thành một chuỗi JSON, sau đó parse chuỗi JSON đó để trả về một giá trị JavaScript:
-const jsonNumber = JSON.stringify(4); // '4'
-JSON.parse(jsonNumber); // 4
+const jsonNumber = JSON.stringify(4) // '4'
+JSON.parse(jsonNumber) // 4
 
 // Chuyển một mảng thành một chuỗi JSON, sau đó parse chuỗi JSON để trả về một giá trị JavaScript:
-const jsonArray = JSON.stringify([1, 2, 3]); // '[1, 2, 3]'
-JSON.parse(jsonArray); // [1, 2, 3]
+const jsonArray = JSON.stringify([1, 2, 3]) // '[1, 2, 3]'
+JSON.parse(jsonArray) // [1, 2, 3]
 
 // Chuyển một object thành một chuỗi JSON, sau đó parse chuỗi JSON để trả về một giá trị JavaScript:
-const jsonArray = JSON.stringify({ name: "Lydia" }); // '{"name":"Lydia"}'
-JSON.parse(jsonArray); // { name: 'Lydia' }
+const jsonArray = JSON.stringify({ name: "Lydia" }) // '{"name":"Lydia"}'
+JSON.parse(jsonArray) // { name: 'Lydia' }
 ```
 
 </p>
@@ -3533,17 +3530,17 @@ JSON.parse(jsonArray); // { name: 'Lydia' }
 
 ---
 
-###### 111. Ouput là gì?
+###### 111. Ouput là gì? 
 
 ```javascript
-let name = "Lydia";
+let name = 'Lydia'
 
 function getName() {
-  console.log(name);
-  let name = "Sarah";
+  console.log(name)
+  let name = 'Sarah'
 }
 
-getName();
+getName()
 ```
 
 - A: Lydia
@@ -3556,20 +3553,20 @@ getName();
 
 #### Đáp án: D
 
-Mỗi hàm sẽ có một _context thực thi_ (hay _scope_) của riêng nó. Hàm `getName` đầu tiên sẽ tìm trong context của nó (scope) để tìm xem có biến nào tên là `name` hay không. Trong trường hợp này, hàm `getName` có biến `name` được khai báo với từ khóa `let`, giá trị là `'Sarah'`.
+Mỗi hàm sẽ có một _context thực thi_ (hay _scope_) của riêng nó. Hàm `getName` đầu tiên sẽ tìm trong context của nó (scope) để tìm xem có biến nào tên là `name` hay không. Trong trường hợp này, hàm `getName` có biến `name` được khai báo với từ khóa `let`, giá trị là `'Sarah'`. 
 
-Một biến được khai báo với từ khóa `let` (hoặc `const`) sẽ được `hoisted`, nhưng không giống như `var`, nó sẽ không được _khởi tạo_. Nó sẽ không thể truy cập được trước dòng ta khai báo (initialize). Nó được gọi là "temporal dead zone". Khi ta cố truy cập một biến trước khi nó được khai báo, JavaScript sẽ throw ra `ReferenceError`.
+Một biến được khai báo với từ khóa `let` (hoặc `const`) sẽ được `hoisted`, nhưng không giống như `var`, nó sẽ không được _khởi tạo_. Nó sẽ không thể truy cập được trước dòng ta khai báo (initialize). Nó được gọi là "temporal dead zone". Khi ta cố truy cập một biến trước khi nó được khai báo, JavaScript sẽ throw ra `ReferenceError`. 
 
-Nếu ta không khai báo biến `name` bên trong hàm `getName`, thì Javascript engine sẽ tiếp tục tìm kiếm trong _scope chain_. Nó sẽ tìm thấy ở scope phía ngoài một biến `name` với giá trị là `Lydia`. Trong trường hợp này nó sẽ log ra `Lydia`.
+Nếu ta không khai báo biến `name` bên trong hàm `getName`, thì Javascript engine sẽ tiếp tục tìm kiếm trong _scope chain_. Nó sẽ tìm thấy ở scope phía ngoài một biến `name` với giá trị là `Lydia`. Trong trường hợp này nó sẽ log ra `Lydia`. 
 
 ```javascript
-let name = "Lydia";
+let name = 'Lydia'
 
 function getName() {
-  console.log(name);
+  console.log(name)
 }
 
-getName(); // Lydia
+getName() // Lydia
 ```
 
 </p>
@@ -3581,18 +3578,18 @@ 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();
-const two = generatorTwo();
+const one = generatorOne()
+const two = generatorTwo()
 
-console.log(one.next().value);
-console.log(two.next().value);
+console.log(one.next().value)
+console.log(two.next().value)
 ```
 
 - A: `a` and `a`
@@ -3610,17 +3607,17 @@ Với từ khóa `yield`, ta sẽ trả về các giá trị trong một `genera
 Trong `generatorOne`, ta trả về toàn bộ mảng `['a', 'b', 'c']` sử dụng từ khóa `yield`. Giá trị của thuộc tính `value` trong object thu được bởi phương thức `next` trong `one` (`one.next().value`) là toàn bộ mảng `['a', 'b', 'c']`.
 
 ```javascript
-console.log(one.next().value); // ['a', 'b', 'c']
-console.log(one.next().value); // undefined
+console.log(one.next().value) // ['a', 'b', 'c']
+console.log(one.next().value) // undefined
 ```
 
-Trong `generatorTwo`, ta sử dụng từ khóa `yield*`. Có nghĩa là giá trị đầu tiên mà `two` trả về là giá trị đầu tiên trong `iterator`. Trong trường hợp này `iterator` của chúng ta là mảng `['a', 'b', 'c']`. Giá trị đầu tiên của mảng là `a`, nên lần đầu tiên khi ta gọi `two.next().value`, `a` sẽ được trả về.
+Trong `generatorTwo`, ta sử dụng từ khóa `yield*`. Có nghĩa là giá trị đầu tiên mà `two` trả về là giá trị đầu tiên trong `iterator`. Trong trường hợp này `iterator` của chúng ta là mảng `['a', 'b', 'c']`. Giá trị đầu tiên của mảng là `a`, nên lần đầu tiên khi ta gọi `two.next().value`, `a` sẽ được trả về. 
 
 ```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
+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>
@@ -3631,7 +3628,7 @@ console.log(two.next().value); // undefined
 ###### 113. Output là gì?
 
 ```javascript
-console.log(`${((x) => x)("I love")} to program`);
+console.log(`${(x => x)('I love')} to program`)
 ```
 
 - A: `I love to program`
@@ -3644,7 +3641,7 @@ console.log(`${((x) => x)("I love")} to program`);
 
 #### Đáp án: A
 
-Biểu thức bên trong chuỗi template (tức chuỗi nằm trong hai dấu ``, gọi là `template literals`) sẽ được đánh giá trước. Sau đó kết quả của biểu thức sẽ được đưa vào chuỗi, trong trường hợp này biểu thức là `(x => x)('I love')`. Chúng ta truyền giá trị đối số `'I love'`cho một arrow function`x => x`. `x`lúc này là`'I love'`, và trả về chính nó. Cuối cùng kết quả của chuỗi là `I love to program`.
+Biểu thức bên trong chuỗi template (tức chuỗi nằm trong hai dấu ``, gọi là `template literals`) sẽ được đánh giá trước. Sau đó kết quả của biểu thức sẽ được đưa vào chuỗi, trong trường hợp này biểu thức là `(x => x)('I love')`. Chúng ta truyền giá trị đối số `'I love'` cho một arrow function `x => x`. `x` lúc này là `'I love'`, và trả về chính nó. Cuối cùng kết quả của chuỗi là `I love to program`. 
 
 </p>
 </details>
@@ -3656,11 +3653,11 @@ Biểu thức bên trong chuỗi template (tức chuỗi nằm trong hai dấu `
 ```javascript
 let config = {
   alert: setInterval(() => {
-    console.log("Alert!");
-  }, 1000),
-};
+    console.log('Alert!')
+  }, 1000)
+}
 
-config = null;
+config = null
 ```
 
 - A: Callback `setInterval` sẽ không được gọi
@@ -3683,17 +3680,17 @@ Thông thường khi ta set một object bằng `null`, thì object này sẽ đ
 ###### 115. Những hàm nào sẽ trả về `'Hello world!'`?
 
 ```javascript
-const myMap = new Map();
-const myFunc = () => "greeting";
+const myMap = new Map()
+const myFunc = () => 'greeting'
 
-myMap.set(myFunc, "Hello world!");
+myMap.set(myFunc, 'Hello world!')
 
 //1
-myMap.get("greeting");
+myMap.get('greeting')
 //2
-myMap.get(myFunc);
+myMap.get(myFunc)
 //3
-myMap.get(() => "greeting");
+myMap.get(() => 'greeting')
 ```
 
 - A: 1
@@ -3706,7 +3703,7 @@ myMap.get(() => "greeting");
 
 #### Đáp án: B
 
-Khi ta thêm vào một cặp key/value với từ khóa `set`, key sẽ là đối số đầu tiên đưa vào trong hàm `set` function, và value sẽ là đối số thứ hai.Trong trường hơp này key chính là _hàm_ `() => 'greeting'`, value là `'Hello world'`. `myMap` trở thành `{ () => 'greeting' => 'Hello world!' }`.
+Khi ta thêm vào một cặp key/value với từ khóa `set`, key sẽ là đối số đầu tiên đưa vào trong hàm `set` function, và value sẽ là đối số thứ hai.Trong trường hơp này key chính là _hàm_ `() => 'greeting'`, value là `'Hello world'`. `myMap` trở thành `{ () => 'greeting' => 'Hello world!' }`. 
 
 1 sai, vì key là `() => 'greeting'` chứ không phải là `'greeting'`.
 3 sai, vì khi chúng ta đưa một hàm vào làm đối số trong phương thức `get`, nó sẽ được đưa vào dưới dạng _reference_. Function vốn là object, do đó 2 hàm sẽ không bao giờ là `strictly equal`, mặc dù chúng có trông giống nhau đi chăng nữa thì chúng vẫn trỏ đến các vùng nhớ khác nhau.
@@ -3721,19 +3718,19 @@ Khi ta thêm vào một cặp key/value với từ khóa `set`, key sẽ là đ
 ```javascript
 const person = {
   name: "Lydia",
-  age: 21,
-};
+  age: 21
+}
 
-const changeAge = (x = { ...person }) => (x.age += 1);
+const changeAge = (x = { ...person }) => x.age += 1
 const changeAgeAndName = (x = { ...person }) => {
-  x.age += 1;
-  x.name = "Sarah";
-};
+  x.age += 1
+  x.name = "Sarah"
+}
 
-changeAge(person);
-changeAgeAndName();
+changeAge(person)
+changeAgeAndName()
 
-console.log(person);
+console.log(person)
 ```
 
 - A: `{name: "Sarah", age: 22}`
@@ -3746,7 +3743,7 @@ console.log(person);
 
 #### Đáp án: C
 
-Cả hai hàm `changeAge` và `changeAgeAndName` đều có tham số mặc định - nó là một _bản copy_ mới của object `{ ...person }`. Object này sẽ copy tất cả những cặp key/values bên trong object `person`.
+Cả hai hàm `changeAge` và `changeAgeAndName` đều có tham số mặc định - nó là một _bản copy_ mới của object `{ ...person }`. Object này sẽ copy tất cả những cặp key/values bên trong object `person`. 
 
 Đầu tiên, chúng ta gọi hàm `changeAge` và đưa chính object `person` vào làm đối số. Hàm này sẽ tăng giá trị của thuộc tính `age` lên 1. `person` lúc này là `{ name: "Lydia", age: 22 }`.
 
@@ -3761,7 +3758,7 @@ Sau đó, chúng ta gọi hàm `changeAgeAndName` tuy nhiên không đưa vào 
 
 ```javascript
 function sumValues(x, y, z) {
-  return x + y + z;
+	return x + y + z;
 }
 ```
 
@@ -3812,15 +3809,15 @@ Với phép toán `+=`, Ta tăng giá trị của `num` lên `1`. `num` có giá
 
 ```javascript
 const person = {
-  firstName: "Lydia",
-  lastName: "Hallie",
-  pet: {
-    name: "Mara",
-    breed: "Dutch Tulip Hound",
-  },
-  getFullName() {
-    return `${this.firstName} ${this.lastName}`;
-  },
+	firstName: "Lydia",
+	lastName: "Hallie",
+	pet: {
+		name: "Mara",
+		breed: "Dutch Tulip Hound"
+	},
+	getFullName() {
+		return `${this.firstName} ${this.lastName}`;
+	}
 };
 
 console.log(person.pet?.name);
@@ -3860,9 +3857,9 @@ Với phép toán optional chaining `?.`, chúng ta sẽ không cần phải che
 const groceries = ["banana", "apple", "peanuts"];
 
 if (groceries.indexOf("banana")) {
-  console.log("We have to buy bananas!");
+	console.log("We have to buy bananas!");
 } else {
-  console.log(`We don't have to buy bananas!`);
+	console.log(`We don't have to buy bananas!`);
 }
 ```
 
@@ -3887,10 +3884,10 @@ Ta đưa một điều kiện `groceries.indexOf("banana")` vào câu lệnh `if
 
 ```javascript
 const config = {
-  languages: [],
-  set language(lang) {
-    return this.languages.push(lang);
-  },
+	languages: [],
+	set language(lang) {
+		return this.languages.push(lang);
+	}
 };
 
 console.log(config.language);
@@ -3944,9 +3941,9 @@ console.log(!typeof name === "string");
 ###### 123. Output là gì?
 
 ```javascript
-const add = (x) => (y) => (z) => {
-  console.log(x, y, z);
-  return x + y + z;
+const add = x => y => z => {
+	console.log(x, y, z);
+	return x + y + z;
 };
 
 add(4)(5)(6);
@@ -3973,16 +3970,16 @@ Hàm `add` trả về một arrow function, arrow function này lại trả về
 
 ```javascript
 async function* range(start, end) {
-  for (let i = start; i <= end; i++) {
-    yield Promise.resolve(i);
-  }
+	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);
-  }
+	const gen = range(1, 3);
+	for await (const item of gen) {
+		console.log(item);
+	}
 })();
 ```
 
@@ -4007,7 +4004,7 @@ Generator `range` trả về một async object với các promise tương ứng
 
 ```javascript
 const myFunc = ({ x, y, z }) => {
-  console.log(x, y, z);
+	console.log(x, y, z);
 };
 
 myFunc(1, 2, 3);
@@ -4130,8 +4127,8 @@ Với phương thức `isNaN`, ta đơn thuần chỉ check xem giá trị đưa
 const randomValue = 21;
 
 function getInfo() {
-  console.log(typeof randomValue);
-  const randomValue = "Lydia Hallie";
+	console.log(typeof randomValue);
+	const randomValue = "Lydia Hallie";
 }
 
 getInfo();
@@ -4160,13 +4157,13 @@ Một biến được khai báo với từ khóa `const` sẽ không thể truy
 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!");
-  }
+	try {
+		console.log(await myPromise);
+	} catch {
+		throw new Error(`Oops didn't work`);
+	} finally {
+		console.log("Oh finally!");
+	}
 })();
 ```
 
@@ -4216,13 +4213,13 @@ Với phương thức `flat`, ta có thể tạo một mảng mới với các p
 
 ```javascript
 class Counter {
-  constructor() {
-    this.count = 0;
-  }
+	constructor() {
+		this.count = 0;
+	}
 
-  increment() {
-    this.count++;
-  }
+	increment() {
+		this.count++;
+	}
 }
 
 const counterOne = new Counter();
@@ -4266,16 +4263,16 @@ Ta gọi hàm `counterTwo.increment()` để tăng `count` lên `3`. Sau đó ch
 const myPromise = Promise.resolve(Promise.resolve("Promise!"));
 
 function funcOne() {
-  myPromise.then((res) => res).then((res) => console.log(res));
-  setTimeout(() => console.log("Timeout!", 0));
-  console.log("Last line!");
+	myPromise.then(res => res).then(res => console.log(res));
+	setTimeout(() => console.log("Timeout!", 0));
+	console.log("Last line!");
 }
 
 async function funcTwo() {
-  const res = await myPromise;
-  console.log(await res);
-  setTimeout(() => console.log("Timeout!", 0));
-  console.log("Last line!");
+	const res = await myPromise;
+	console.log(await res);
+	setTimeout(() => console.log("Timeout!", 0));
+	console.log("Last line!");
 }
 
 funcOne();
@@ -4312,7 +4309,7 @@ Ta tiếp tục thực thi dòng cuối cùng của `funcTwo`, trả về `Last
 ```javascript
 // sum.js
 export default function sum(x) {
-  return x + x;
+	return x + x;
 }
 
 // index.js
@@ -4369,8 +4366,8 @@ Ta có thể gọi hàm này bằng cách sử dụng `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);
@@ -4433,10 +4430,10 @@ Tuy nhiên ta vẫn có thể _thay đổi_ các thuộc tính cũ.
 
 ```javascript
 const person = {
-  name: "Lydia Hallie",
-  address: {
-    street: "100 Main St",
-  },
+	name: "Lydia Hallie",
+	address: {
+		street: "100 Main St"
+	}
 };
 
 Object.freeze(person);
@@ -4464,10 +4461,10 @@ Tuy nhiên trên thực tế đây chỉ là đóng băng _nông_ (_shallowly_)
 ###### 138. Output là gì?
 
 ```javascript
-const add = (x) => x + x;
+const add = x => x + x;
 
 function myFunc(num = 2, value = add(num)) {
-  console.log(num, value);
+	console.log(num, value);
 }
 
 myFunc();
@@ -4497,21 +4494,21 @@ Sau đó ta gọi hàm `myFunc(3)`, khi này `3` sẽ là giá trị của `num`
 
 ```javascript
 class Counter {
-  #number = 10;
+  #number = 10
 
   increment() {
-    this.#number++;
+    this.#number++
   }
 
   getNum() {
-    return this.#number;
+    return this.#number
   }
 }
 
-const counter = new Counter();
-counter.increment();
+const counter = new Counter()
+counter.increment()
 
-console.log(counter.#number);
+console.log(counter.#number)
 ```
 
 - A: `10`
@@ -4535,20 +4532,20 @@ Với cú pháp ES2020, ta có thể thêm các thuộc tính private vào class
 
 ```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) {
-  for (let i = 0; i < members.length; i++) {
-    yield members[i];
-  }
+	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 ✨
-  }
+	for (let i = 0; i < teams.length; i++) {
+		// ✨ SOMETHING IS MISSING HERE ✨
+	}
 }
 
 const obj = getTeams(teams);
@@ -4573,19 +4570,20 @@ Nếu ta dùng `yield`, `return yield`, hay `return`, toàn bộ generator sẽ
 </p>
 </details>
 
+
 ---
 
 ###### 141. Output là gì?
 
 ```javascript
 const person = {
-  name: "Lydia Hallie",
-  hobbies: ["coding"],
+	name: "Lydia Hallie",
+	hobbies: ["coding"]
 };
 
 function addHobby(hobby, hobbies = person.hobbies) {
-  hobbies.push(hobby);
-  return hobbies;
+	hobbies.push(hobby);
+	return hobbies;
 }
 
 addHobby("running", []);
@@ -4624,16 +4622,16 @@ Sau khi thêm `dancing` và `baking`, giá trị của `person.hobbies` là `["c
 
 ```javascript
 class Bird {
-  constructor() {
-    console.log("I'm a bird. 🦢");
-  }
+	constructor() {
+		console.log("I'm a bird. 🦢");
+	}
 }
 
 class Flamingo extends Bird {
-  constructor() {
-    console.log("I'm pink. 🌸");
-    super();
-  }
+	constructor() {
+		console.log("I'm pink. 🌸");
+		super();
+	}
 }
 
 const pet = new Flamingo();
@@ -4718,11 +4716,11 @@ Mặc định ta không thể duyệt qua được object. Trừ phi nó đượ
 let count = 0;
 const nums = [0, 1, 2, 3];
 
-nums.forEach((num) => {
-  if (num) count += 1;
-});
+nums.forEach(num => {
+	if (num) count += 1
+})
 
-console.log(count);
+console.log(count)
 ```
 
 - A: 1
@@ -4746,12 +4744,12 @@ Câu lệnh `if` trong vòng lập `forEach` kiểm tra giá trị của `num` l
 
 ```javascript
 function getFruit(fruits) {
-  console.log(fruits?.[1]?.[1]);
+	console.log(fruits?.[1]?.[1])
 }
 
-getFruit([["🍊", "🍌"], ["🍍"]]);
-getFruit();
-getFruit([["🍍"], ["🍊", "🍌"]]);
+getFruit([['🍊', '🍌'], ['🍍']])
+getFruit()
+getFruit([['🍍'], ['🍊', '🍌']])
 ```
 
 - A: `null`, `undefined`, 🍌
@@ -4768,7 +4766,7 @@ Phép toán `?` cho phép ta truy cập giá trị bên trong của object. Chú
 
 Trước tiên, chúng ta thử in ra phần tử thứ hai trong mảng con `['🍍']` của `[['🍊', '🍌'], ['🍍']]`. Mảng con này chỉ chứa một phần tử, nghĩa là không có phần tử nào với thứ tự là `1`, và trả về `undefined`.
 
-Sau đó, ta gọi hàm `getFruits` khi không truyền vào một đối số nào, nghĩa là `fruits` có giá trị mặc định là `undefined`. Vì ta truyền phần tử mang thứ tự `1` của `fruits`, nó trả về `undefined` do phần tử này không tồn tại.
+Sau đó, ta gọi hàm `getFruits` khi không truyền vào một đối số nào, nghĩa là `fruits` có giá trị mặc định là `undefined`. Vì ta truyền phần tử mang thứ tự `1` của `fruits`, nó trả về `undefined` do phần tử này không tồn tại. 
 
 Cuối cùng, ta thử in ra phần tử thứ hai trong mảng con `['🍊', '🍌']` của mảng `['🍍'], ['🍊', '🍌']`. Phần tử mang thứ tự `1` bên trong mảng con này là `🍌` sẽ được in ra.
 
@@ -4781,19 +4779,19 @@ Cuối cùng, ta thử in ra phần tử thứ hai trong mảng con `['🍊', '
 
 ```javascript
 class Calc {
-  constructor() {
-    this.count = 0;
-  }
+	constructor() {
+		this.count = 0 
+	}
 
-  increase() {
-    this.count++;
-  }
+	increase() {
+		this.count ++
+	}
 }
 
-const calc = new Calc();
-new Calc().increase();
+const calc = new Calc()
+new Calc().increase()
 
-console.log(calc.count);
+console.log(calc.count)
 ```
 
 - A: `0`
@@ -4817,25 +4815,25 @@ Ta set biến `calc` bằng một instance mới của `Calc` class. Sau đó ta
 
 ```javascript
 const user = {
-  email: "e@mail.com",
-  password: "12345",
-};
+	email: "e@mail.com",
+	password: "12345"
+}
 
 const updateUser = ({ email, password }) => {
-  if (email) {
-    Object.assign(user, { email });
-  }
+	if (email) {
+		Object.assign(user, { email })
+	}
 
-  if (password) {
-    user.password = password;
-  }
+	if (password) {
+		user.password = password
+	}
 
-  return user;
-};
+	return user
+}
 
-const updatedUser = updateUser({ email: "new@email.com" });
+const updatedUser = updateUser({ email: "new@email.com" })
 
-console.log(updatedUser === user);
+console.log(updatedUser === user)
 ```
 
 - A: `false`
@@ -4858,13 +4856,13 @@ Hàm `updateUser` thay đổi các giá trị của thuộc tính `email` và `p
 ###### 149. Output là gi?
 
 ```javascript
-const fruit = ["🍌", "🍊", "🍎"];
+const fruit = ['🍌', '🍊', '🍎']
 
-fruit.slice(0, 1);
-fruit.splice(0, 1);
-fruit.unshift("🍇");
+fruit.slice(0, 1)
+fruit.splice(0, 1)
+fruit.unshift('🍇')
 
-console.log(fruit);
+console.log(fruit)
 ```
 
 - A: `['🍌', '🍊', '🍎']`
@@ -4888,13 +4886,13 @@ Trước tiên, ta gọi hàm `slice` trên mảng fruit. Hàm slice không thay
 
 ```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]);
+console.log(animals[dog])
 ```
 
 - A: `{ emoji: "🐶", name: "Mara" }`
@@ -4911,7 +4909,7 @@ Các keys của object được chuyển thành các chuỗi.
 
 Do giá trị của `dog` là một object, `animals[dog]` thực sự nghĩa là ta tạo ra một thuộc tính mới gọi là `"object Object"` bằng với object mới. `animals["object Object"]` lúc này bằng với `{ emoji: "🐶", name: "Mara"}`.
 
-`cat` cũng là một object, nên `animals[cat]` thực sự nghĩa là ta thay đổi giá trị của ` animals[``"``object Object``"``] ` bằng thuộc tính cat mới.
+`cat` cũng là một object, nên `animals[cat]` thực sự nghĩa là ta thay đổi giá trị của `animals[``"``object Object``"``]` bằng thuộc tính cat mới.
 
 Khi in ra `animals[dog]`, hoặc thực chất là `animals["object Object"]` vì thay `dog` object bằng một chuỗi thì nó trả về `"object Object"`, ta nhận được `{ emoji: "🐈", name: "Sara" }`.
 
@@ -4924,14 +4922,14 @@ Khi in ra `animals[dog]`, hoặc thực chất là `animals["object Object"]` v
 
 ```javascript
 const user = {
-  email: "my@email.com",
-  updateEmail: (email) => {
-    this.email = email;
-  },
-};
+	email: "my@email.com",
+	updateEmail: email => {
+		this.email = email
+	}
+}
 
-user.updateEmail("new@email.com");
-console.log(user.email);
+user.updateEmail("new@email.com")
+console.log(user.email)
 ```
 
 - A: `my@email.com`
@@ -4954,20 +4952,20 @@ Hàm `updateEmail` là một cú pháp arrow function và nó không gắn với
 ###### 152. Output là gì?
 
 ```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]);
-  const res2 = await Promise.all([promise3, promise4]);
-  return [res1, res2];
-};
+	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));
+	.then(res => console.log(res))
+	.catch(err => console.log(err))
 ```
 
 - A: `[['First', 'Second'], ['Fourth']]`
@@ -4987,19 +4985,16 @@ Hàm `Promise.all` trả về những promise truyền vào song song nhau. Nế
 
 ---
 
-###### 153. Giá trị nào của `method` sẽ được trả về với log `{ name: "Lydia", age: 22 }`?
+###### 153. Giá trị nào của `method` sẽ được trả về với log `{ name: "Lydia", age: 22 }`? 
 
 ```javascript
-const keys = ["name", "age"];
-const values = ["Lydia", 22];
+const keys = ["name", "age"]
+const values = ["Lydia", 22]
 
-const method =
-  /* ?? */
-  Object[method](
-    keys.map((_, i) => {
-      return [keys[i], values[i]];
-    })
-  ); // { name: "Lydia", age: 22 }
+const method = /* ?? */
+Object[method](keys.map((_, i) => {
+	return [keys[i], values[i]]
+})) // { name: "Lydia", age: 22 }
 ```
 
 - A: `entries`
@@ -5024,18 +5019,18 @@ Theo như trên thì ta tạo ra một mảng gồm những mảng con chứa đ
 ###### 154. Output là gì?
 
 ```javascript
-const createMember = ({ email, address = {} }) => {
-  const validEmail = /.+\@.+\..+/.test(email);
-  if (!validEmail) throw new Error("Valid email pls");
+const createMember = ({ email, address = {}}) => {
+	const validEmail = /.+\@.+\..+/.test(email)
+	if (!validEmail) throw new Error("Valid email pls")
 
-  return {
-    email,
-    address: address ? address : null,
-  };
-};
+	return {
+		email,
+		address: address ? address : null
+	}
+}
 
-const member = createMember({ email: "my@email.com" });
-console.log(member);
+const member = createMember({ email: "my@email.com" })
+console.log(member)
 ```
 
 - A: `{ email: "my@email.com", address: null }`
@@ -5058,13 +5053,13 @@ Giá trị mặc định của `address` là một object rỗng `{}`. Khi ta ch
 ###### 155. Output là gì?
 
 ```javascript
-let randomValue = { name: "Lydia" };
-randomValue = 23;
+let randomValue = { name: "Lydia" }
+randomValue = 23
 
 if (!typeof randomValue === "string") {
-  console.log("It's not a string!");
+	console.log("It's not a string!")
 } else {
-  console.log("Yay it's a string!");
+	console.log("Yay it's a string!")
 }
 ```
 

From 7b747e930b03606504cd0a179d1c45baee7dc46f Mon Sep 17 00:00:00 2001
From: alexb017 <alexbacirea@gmail.com>
Date: Tue, 22 Aug 2023 02:46:20 +0300
Subject: [PATCH 07/31] Added the Romanian language

---
 README.md             |  1 +
 ar-AR/README_AR.md    |  1 +
 bs-BS/README-bs_BS.md |  1 +
 de-DE/README.md       |  1 +
 es-ES/README-ES.md    |  1 +
 fr-FR/README_fr-FR.md |  1 +
 id-ID/README.md       |  1 +
 it-IT/README.md       |  1 +
 ja-JA/README-ja_JA.md |  1 +
 ko-KR/README-ko_KR.md |  1 +
 nl-NL/README.md       |  1 +
 pl-PL/README.md       |  1 +
 pt-BR/README_pt_BR.md |  1 +
 ro-RO/README.ro.md    | 49 +++++++++++++++++++++++++++++++++++++++++++
 ru-RU/README.md       |  1 +
 sq-KS/README_sq_KS.md |  1 +
 th-TH/README.md       |  1 +
 tr-TR/README-tr_TR.md |  1 +
 uk-UA/README.md       |  1 +
 vi-VI/README-vi.md    |  1 +
 20 files changed, 68 insertions(+)
 create mode 100644 ro-RO/README.ro.md

diff --git a/README.md b/README.md
index 97cde89e..7ccfaa63 100644
--- a/README.md
+++ b/README.md
@@ -33,6 +33,7 @@ Feel free to reach out to me! 😊 <br />
 - [🇳🇱 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)
diff --git a/ar-AR/README_AR.md b/ar-AR/README_AR.md
index 6d5638e7..ace6ed98 100644
--- a/ar-AR/README_AR.md
+++ b/ar-AR/README_AR.md
@@ -27,6 +27,7 @@
 - [🇳🇱 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)
diff --git a/bs-BS/README-bs_BS.md b/bs-BS/README-bs_BS.md
index 65ee11f7..eeeb7ea3 100644
--- a/bs-BS/README-bs_BS.md
+++ b/bs-BS/README-bs_BS.md
@@ -25,6 +25,7 @@ kliknite na njih da biste ih proširili. Sretno :heart:
 - [🇳🇱 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)
diff --git a/de-DE/README.md b/de-DE/README.md
index 10145050..0ac8c271 100644
--- a/de-DE/README.md
+++ b/de-DE/README.md
@@ -35,6 +35,7 @@ Kontaktiert mich, wenn ihr möchtet! 😊 <br />
 - [🇳🇱 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)
diff --git a/es-ES/README-ES.md b/es-ES/README-ES.md
index 5c3ddc40..e839d901 100644
--- a/es-ES/README-ES.md
+++ b/es-ES/README-ES.md
@@ -25,6 +25,7 @@ Lista de lenguajes disponibles:
 - [🇳🇱 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)
diff --git a/fr-FR/README_fr-FR.md b/fr-FR/README_fr-FR.md
index cce10323..16d0d14e 100644
--- a/fr-FR/README_fr-FR.md
+++ b/fr-FR/README_fr-FR.md
@@ -19,6 +19,7 @@ Les réponses se trouvent dans les sections repliées en dessous des questions,
 - [🇳🇱 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)
diff --git a/id-ID/README.md b/id-ID/README.md
index 26a566cc..482955fb 100644
--- a/id-ID/README.md
+++ b/id-ID/README.md
@@ -29,6 +29,7 @@ Jangan sungkan untuk terhubung dengan saya! 😊 <br />
 - [🇳🇱 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)
diff --git a/it-IT/README.md b/it-IT/README.md
index 71b71ca5..23d43ea2 100644
--- a/it-IT/README.md
+++ b/it-IT/README.md
@@ -37,6 +37,7 @@ Traduzione a cura di: <a href="https://github.com/luciacenetiempo">Lucia Cenetie
 - [🇳🇱 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)
diff --git a/ja-JA/README-ja_JA.md b/ja-JA/README-ja_JA.md
index 1cc85d76..577982ce 100644
--- a/ja-JA/README-ja_JA.md
+++ b/ja-JA/README-ja_JA.md
@@ -21,6 +21,7 @@
 - [🇳🇱 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)
diff --git a/ko-KR/README-ko_KR.md b/ko-KR/README-ko_KR.md
index 13651a7c..96d75bf7 100644
--- a/ko-KR/README-ko_KR.md
+++ b/ko-KR/README-ko_KR.md
@@ -34,6 +34,7 @@
 - [🇳🇱 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)
diff --git a/nl-NL/README.md b/nl-NL/README.md
index 0400e8ed..ffc14a97 100644
--- a/nl-NL/README.md
+++ b/nl-NL/README.md
@@ -30,6 +30,7 @@
 - [🇰🇷 한국어](../ko-KR/README-ko_KR.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)
diff --git a/pl-PL/README.md b/pl-PL/README.md
index 866f4458..31d8e974 100644
--- a/pl-PL/README.md
+++ b/pl-PL/README.md
@@ -32,6 +32,7 @@ Nie krępuj się ze mną kontaktować! 😊 <br />
 - [🇰🇷 한국어](./ko-KR/README-ko_KR.md)
 - [🇳🇱 Nederlands](./nl-NL/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)
diff --git a/pt-BR/README_pt_BR.md b/pt-BR/README_pt_BR.md
index e59c6a6f..54c8daf1 100644
--- a/pt-BR/README_pt_BR.md
+++ b/pt-BR/README_pt_BR.md
@@ -19,6 +19,7 @@ As respostas estão em seções recolhidas abaixo das questões, basta clicar ne
 - [🇰🇷 한국어](../ko-KR/README-ko_KR.md)
 - [🇳🇱 Nederlands](../nl-NL/README.md)
 - [🇵🇱 Polski](../pl-PL/README.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)
diff --git a/ro-RO/README.ro.md b/ro-RO/README.ro.md
new file mode 100644
index 00000000..86de596e
--- /dev/null
+++ b/ro-RO/README.ro.md
@@ -0,0 +1,49 @@
+<div align="center">
+  <img height="60" src="https://img.icons8.com/color/344/javascript.png">
+  <h1>Întrebări JavaScript</h1>
+
+---
+
+<span>Postez întrebări JavaScript cu opțiuni multiple pe [Instagram](https://www.instagram.com/theavocoder) **stories**, pe care le voi posta și aici! Ultima actualizare: <a href=#20200612><b>12 Iunie</b></a>
+
+De la nivel de bază la avansat: testează cât de bine cunoști JavaScript, reîmprospătează-ți puțin cunoștințele sau pregătește-te pentru interviul tău de codare! :muscle: :rocket: Actualizez acest depozit în mod regulat cu întrebări noi. Am adăugat răspunsurile în **secțiunile restrânse** de sub întrebări, pur și simplu dă clic pe ele pentru a le extinde. Este doar pentru distracție, mult noroc! :heart:</span>
+
+Nu ezita să mă contactezi! 😊 <br />
+<a href="https://www.instagram.com/theavocoder">Instagram</a> || <a href="https://www.twitter.com/lydiahallie">Twitter</a> || <a href="https://www.linkedin.com/in/lydia-hallie">LinkedIn</a> || <a href="https://www.lydiahallie.dev">Blog</a>
+
+</div>
+
+| Simte-te liber să le folosești într-un proiect! 😃 Aș aprecia _cu adevărat_ o referință la acest depozit, eu creez întrebările și explicațiile (da, sunt tristă lol) și comunitatea mă ajută foarte mult să îl mențin și să îl îmbunătățesc! 💪🏼 Mulțumesc și distracție plăcută! |
+|---|
+
+---
+
+<details><summary><b> Vezi 20 de traduceri disponibile 🇸🇦🇪🇬🇧🇦🇩🇪🇪🇸🇫🇷🇮🇩🇯🇵🇰🇷🇳🇱🇧🇷🇷🇺🇹🇭🇹🇷🇺🇦🇻🇳🇨🇳🇹🇼🇽🇰</b></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)
+- [🇷🇺 Русский](./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)
+
+</p>
+</details>
+
+---
\ No newline at end of file
diff --git a/ru-RU/README.md b/ru-RU/README.md
index 17a083ab..2df08edb 100644
--- a/ru-RU/README.md
+++ b/ru-RU/README.md
@@ -33,6 +33,7 @@
 - [🇳🇱 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)
 - [🇬🇧 English](../README.md)
 - [🇽🇰 Shqip](../sq-KS/README_sq_KS.md)
 - [🇹🇭 ไทย](../th-TH/README-th_TH.md)
diff --git a/sq-KS/README_sq_KS.md b/sq-KS/README_sq_KS.md
index aa1eb9dc..19508cf7 100644
--- a/sq-KS/README_sq_KS.md
+++ b/sq-KS/README_sq_KS.md
@@ -32,6 +32,7 @@ Mos hezitoni të më kontaktoni! 😊
 - [🇳🇱 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)
diff --git a/th-TH/README.md b/th-TH/README.md
index 22550eb2..a5948da5 100644
--- a/th-TH/README.md
+++ b/th-TH/README.md
@@ -32,6 +32,7 @@
 - [🇳🇱 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)
 - [🇹🇷 Türkçe](../tr-TR/README-tr_TR.md)
diff --git a/tr-TR/README-tr_TR.md b/tr-TR/README-tr_TR.md
index e34ae66b..f1b36c1f 100644
--- a/tr-TR/README-tr_TR.md
+++ b/tr-TR/README-tr_TR.md
@@ -26,6 +26,7 @@ Mevcut dillerin listesi:
 - [🇳🇱 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)
diff --git a/uk-UA/README.md b/uk-UA/README.md
index 3b38c921..6498cc94 100644
--- a/uk-UA/README.md
+++ b/uk-UA/README.md
@@ -20,6 +20,7 @@
 - [🇳🇱 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)
diff --git a/vi-VI/README-vi.md b/vi-VI/README-vi.md
index 8750b2d6..fa974a44 100644
--- a/vi-VI/README-vi.md
+++ b/vi-VI/README-vi.md
@@ -21,6 +21,7 @@ Danh sách các ngôn ngữ khác:
 - [🇳🇱 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)

From fb56bd08dbc3e406e05f4a535c1b8521bebd6df0 Mon Sep 17 00:00:00 2001
From: alexb017 <alexbacirea@gmail.com>
Date: Tue, 22 Aug 2023 02:51:47 +0300
Subject: [PATCH 08/31] Added the first 30 questions

---
 ro-RO/README.ro.md | 914 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 914 insertions(+)

diff --git a/ro-RO/README.ro.md b/ro-RO/README.ro.md
index 86de596e..1f15fd70 100644
--- a/ro-RO/README.ro.md
+++ b/ro-RO/README.ro.md
@@ -46,4 +46,918 @@ Nu ezita să mă contactezi! 😊 <br />
 </p>
 </details>
 
+---
+
+###### 1. Care este rezultatul?
+
+```javascript
+function sayHi() {
+  console.log(name);
+  console.log(age);
+  var name = 'Lydia';
+  let age = 21;
+}
+
+sayHi();
+```
+
+- A: `Lydia` și `undefined`
+- B: `Lydia` și `ReferenceError`
+- C: `ReferenceError` și `21`
+- D: `undefined` și `ReferenceError`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: D
+
+În interiorul funcției, mai întâi declarăm variabila `name` cu cuvântul cheie `var`. Acest lucru înseamnă că variabila este hoisted (spațiul de memorie este configurat în faza de creare) cu valoarea implicită `undefined`, până când ajungem efectiv la linia în care definim variabila. Nu am definit încă variabila pe linia în care încercăm să înregistrăm variabila `name`, așa că aceasta păstrează încă valoarea `undefined`.
+
+Variabilele create cu cuvântul cheie `let` (și `const`) sunt hoisted, dar, spre deosebire de `var`, nu sunt <i>inițializate</i>. Acestea nu sunt accesibile înainte de linia în care le declarăm (initializăm). Aceasta se numește zona moartă temporală (temporal dead zone). Atunci când încercăm să accesăm variabilele înainte de a fi declarate, JavaScript aruncă o excepție de tip `ReferenceError`.
+
+</p>
+</details>
+
+---
+
+###### 2. Care este rezultatul?
+
+```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` și `0 1 2`
+- B: `0 1 2` și `3 3 3`
+- C: `3 3 3` și `0 1 2`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+Datorită cozii de evenimente din JavaScript, funcția de callback `setTimeout` este apelată _după_ ce bucla a fost executată. Deoarece variabila `i` din prima buclă a fost declarată folosind cuvântul cheie `var`, această valoare a fost globală. În timpul buclei, am incrementat valoarea lui `i` cu `1` de fiecare dată, folosind operatorul unary `++`. Până când funcția de callback `setTimeout` a fost invocată, `i` era egal cu `3` în primul exemplu.
+
+În cea de-a doua buclă, variabila `i` a fost declarată folosind cuvântul cheie `let`: variabilele declarate cu cuvântul cheie `let` (și `const`) sunt cu scop la nivel de bloc (un bloc este orice între `{ }`). În fiecare iterație, `i` va avea o valoare nouă, iar fiecare valoare este în cadrul buclei.
+
+</p>
+</details>
+
+---
+
+###### 3. Care este rezultatul?
+
+```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` și `62.83185307179586`
+- B: `20` și `NaN`
+- C: `20` și `63`
+- D: `NaN` și `63`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: B
+
+Rețineți că valoarea lui `diameter` este o funcție obișnuită, în timp ce valoarea lui `perimeter` este o funcție arrow.
+
+Cu funcțiile arrow, cuvântul cheie `this` se referă la contextul său curent de încadrare, spre deosebire de funcțiile obișnuite! Acest lucru înseamnă că atunci când apelăm `perimeter`, acesta nu se referă la obiectul formei, ci la încadrarea sa curentă (de exemplu, fereastra).
+
+Nu există nicio valoare `radius` pe acel obiect, ceea ce returnează `NaN`.
+
+</p>
+</details>
+
+---
+
+###### 4. Care este rezultatul?
+
+```javascript
++true;
+!'Lydia';
+```
+
+- A: `1` și `false`
+- B: `false` și `NaN`
+- C: `false` și `false`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: A
+
+Operatorul unary plus încearcă să convertească un operand într-un număr. `true` este `1`, și `false` este `0`.
+
+Șirul de caractere `'Lydia'` este o valoare adevărată. Ceea ce întrebăm de fapt, este "este această valoare adevărată falsă?". Acest lucru returnează `false`.
+
+</p>
+</details>
+
+---
+
+###### 5. Care este rezultatul?
+
+```javascript
+const bird = {
+  size: 'small',
+};
+
+const mouse = {
+  name: 'Mickey',
+  small: true,
+};
+```
+
+- A: `mouse.bird.size` nu este valid
+- B: `mouse[bird.size]` nu este valid
+- C: `mouse[bird["size"]]` nu este valid
+- D: Toate sunt valide
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: A
+
+În JavaScript, toate cheile obiectelor sunt șiruri de caractere (cu excepția simbolurilor). Chiar dacă nu le _tipizăm_ ca șiruri de caractere, ele sunt întotdeauna convertite în șiruri de caractere în fundal.
+
+avaScript interpretează (sau dezambalează) instrucțiunile. Atunci când folosim notația cu paranteze pătrate, vede prima paranteză pătrată de deschidere `[` și continuă până când găsește paranteza pătrată de închidere `]`. Doar atunci va evalua instrucțiunea.
+
+`mouse[bird.size]`: Întâi evaluează `bird.size`, care este `"small"`. `mouse["small"]` returnează `true`
+
+Cu toate acestea, cu notația cu punct, acest lucru nu se întâmplă. `mouse` nu are o cheie numită `bird`, ceea ce înseamnă că `mouse.bird` este `undefined`. Apoi, cerem `size` folosind notația cu punct: `mouse.bird.size`. Deoarece `mouse.bird` este `undefined`, de fapt cerem `undefined.size`. Acest lucru nu este valid și va arunca o eroare similară cu `Cannot read property "size" of undefined` (Nu se poate citi proprietatea "size" a unei valori nedefinite).
+
+</p>
+</details>
+
+---
+
+###### 6. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: A
+
+În JavaScript, toate obiectele interacționează prin _referință_ atunci când sunt setate ca egale între ele.
+
+Mai întâi, variabila `c` deține o valoare care face referire la un obiect. Ulterior, atribuim variabilei `d` aceeași referință pe care o are `c` la obiect.
+
+<img src="https://i.imgur.com/ko5k0fs.png" width="200">
+
+Când modifici un obiect, le modifici pe toate.
+
+</p>
+</details>
+
+---
+
+###### 7. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+`new Number()` este un constructor de funcții încorporat. Deși arată ca un număr, nu este într-adevăr un număr: are o mulțime de funcționalități suplimentare și este un obiect.
+
+Atunci când folosim operatorul `==` (operatorul de egalitate), acesta verifică doar dacă au aceeași _valuare_. Ambele au valoarea `3`, șa că returnează `true`.
+
+Cu toate acestea, atunci când folosim operatorul `===` (operatorul de egalitate strictă), atât valoarea, cât _și_ tipul trebuie să fie la fel. Nu sunt: `new Number()` nu este un număr, este un **object**. Ambele returnează `false.`
+
+</p>
+</details>
+
+---
+
+###### 8. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: D
+
+Funcția `colorChange` este statică. Metodele statice sunt concepute să existe doar pe constructorul în care sunt create și nu pot fi transmise către niciun copil sau apelate pe instanțele clasei. Deoarece `freddie` este o instanță a clasei Chameleon, funcția nu poate fi apelată pe aceasta. Se aruncă o eroare de tip `TypeError`.
+
+</p>
+</details>
+
+---
+
+###### 9. Care este rezultatul?
+
+```javascript
+let greeting;
+greetign = {}; // Typo!
+console.log(greetign);
+```
+
+- A: `{}`
+- B: `ReferenceError: greetign is not defined`
+- C: `undefined`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: A
+
+Se afișează obiectul, deoarece tocmai am creat un obiect gol pe obiectul global! Atunci când am greșit și am scris `greeting` în loc de `greetign`, interpretorul JavaScript a văzut efectiv acest lucru ca:
+
+1. `global.greetign = {}` în Node.js
+2. `window.greetign = {}`, `frames.greetign = {}` și `self.greetign` în browser-e.
+3. `self.greetign` în web workers.
+4. `globalThis.greetign` în toate mediile.
+
+Pentru a evita acest lucru, putem folosi `"use strict"`. Acest lucru se asigură că ai declarat o variabilă înainte de a-i atribui o valoare.
+
+</p>
+</details>
+
+---
+
+###### 10. Ce se întâmplă când facem asta?
+
+```javascript
+function bark() {
+  console.log('Woof!');
+}
+
+bark.animal = 'dog';
+```
+
+- A: Nimic, este absolut în regulă!
+- B: `SyntaxError`. Nu poți adăuga proprietăți la o funcție în acest fel.
+- C: `"Woof"` este înregistrat.
+- D: `ReferenceError`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: A
+
+Acest lucru este posibil în JavaScript, deoarece funcțiile sunt obiecte! (Totul, în afară de tipurile primitive, sunt obiecte)
+
+O funcție este un tip special de obiect. Codul pe care îl scrii tu însuți nu este funcția efectivă. Funcția este un obiect cu proprietăți. Această proprietate este invocabilă.
+
+</p>
+</details>
+
+---
+
+###### 11. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: A
+
+În JavaScript, funcțiile sunt obiecte și, prin urmare, metoda `getFullName` este adăugată obiectului constructor al funcției în sine. Din acest motiv, putem apela `Person.getFullName()`, dar `member.getFullName` aruncă o eroare de tip `TypeError`.
+
+Dacă doriți ca o metodă să fie disponibilă pentru toate instanțele obiectului, trebuie să o adăugați la proprietatea prototype:
+
+```js
+Person.prototype.getFullName = function () {
+  return `${this.firstName} ${this.lastName}`;
+};
+```
+
+</p>
+</details>
+
+---
+
+###### 12. Care este rezultatul?
+
+```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"}` și `undefined`
+- B: `Person {firstName: "Lydia", lastName: "Hallie"}` și `Person {firstName: "Sarah", lastName: "Smith"}`
+- C: `Person {firstName: "Lydia", lastName: "Hallie"}` și `{}`
+- D: `Person {firstName: "Lydia", lastName: "Hallie"}` și `ReferenceError`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: A
+
+Pentru `sarah`, nu am folosit cuvântul cheie `new`. Când folosim `new`, `this` se referă la noul obiect gol pe care îl creăm. Cu toate acestea, dacă nu adăugăm `new`, `this` se referă la **obiectul global**!
+
+Am spus că `this.firstName` este egal cu `"Sarah"` și `this.lastName` este egal cu `"Smith"`. Ceea ce am făcut de fapt este să definim `global.firstName = 'Sarah'` și `global.lastName = 'Smith'`. `sarah` în sine rămâne `undefined`, deoarece nu returnăm o valoare din funcția `Person`.
+
+</p>
+</details>
+
+---
+
+###### 13. Care sunt cele trei faze ale propagării evenimentelor?
+
+- A: Target > Capturing > Bubbling
+- B: Bubbling > Target > Capturing
+- C: Target > Bubbling > Capturing
+- D: Capturing > Target > Bubbling
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: D
+
+În timpul fazei de **capturing**, evenimentul trece prin elementele părinte până la elementul țintă. Apoi ajunge la elementul **target**, și începe **bubbling**.
+
+<img src="https://i.imgur.com/N18oRgd.png" width="200">
+
+</p>
+</details>
+
+---
+
+###### 14. Toate obiectele au prototipuri.
+
+- A: true
+- B: false
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: B
+
+Toate obiectele au prototipuri, cu excepția **obiectului de bază**. Obiectul de bază este obiectul creat de utilizator sau un obiect creat folosind cuvântul cheie `new`. Obiectul de bază are acces la unele metode și proprietăți, cum ar fi `.toString`. Acesta este motivul pentru care puteți utiliza metode JavaScript încorporate! Toate aceste metode sunt disponibile în prototip. Deși JavaScript nu le poate găsi direct în obiectul dvs., merge în jos pe lanțul prototip și le găsește acolo, ceea ce le face accesibile pentru dvs.
+
+</p>
+</details>
+
+---
+
+###### 15. Care este rezultatul?
+
+```javascript
+function sum(a, b) {
+  return a + b;
+}
+
+sum(1, '2');
+```
+
+- A: `NaN`
+- B: `TypeError`
+- C: `"12"`
+- D: `3`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+JavaScript este un limbaj **dinamic tipizat**: nu specificăm tipurile variabilelor. Valorile pot fi convertite automat în alt tip fără să știți, ceea ce se numește _coerție de tip implicită_. **Coerția** este conversia dintr-un tip în altul.
+
+În acest exemplu, JavaScript convertește numărul `1` într-un șir de caractere, pentru ca funcția să aibă sens și să returneze o valoare. În timpul adunării unui tip numeric (`1`) și unui tip șir de caractere (`'2'`), numărul este tratat ca un șir de caractere. Putem concatena șiruri de caractere, așa cum facem cu `"Hello" + "World"`, deci ceea ce se întâmplă aici este `"1" + "2"` care returnează `"12"`.
+
+</p>
+</details>
+
+---
+
+###### 16. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+Operatorul unary **postfix** `++`:
+
+1. Returnează valoarea (aceasta returnează `0`)
+2. Incrementează valoarea (numărul este acum `1`)
+
+Operatorul unary **prefix** `++`:
+
+1. Incrementează valoarea (numărul este acum `2`)
+2. Returnează valoarea (aceasta returnează `2`)
+
+Aceasta returnează `0 2 2`.
+
+</p>
+</details>
+
+---
+
+###### 17. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: B
+
+Dacă utilizați șiruri template etichetate, valoarea primului argument este întotdeauna un șir de valori. Argumentele rămase primesc valorile expresiilor transmise!
+
+</p>
+</details>
+
+---
+
+###### 18. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+Când se testează egalitatea, primitivele sunt comparate în funcție de valoarea lor, în timp ce obiectele sunt comparate în funcție de _referința_ lor. JavaScript verifică dacă obiectele au o referință către aceeași locație în memorie.
+
+Cele două obiecte pe care le comparăm nu au aceeași referință: obiectul pe care l-am trecut ca parametru se referă la o altă locație în memorie decât obiectul pe care l-am folosit pentru a verifica egalitatea.
+
+Acesta este motivul pentru care ambele `{ age: 18 } === { age: 18 }` și `{ age: 18 } == { age: 18 }` returnează `false`.
+
+</p>
+</details>
+
+---
+
+###### 19. Care este rezultatul?
+
+```javascript
+function getAge(...args) {
+  console.log(typeof args);
+}
+
+getAge(21);
+```
+
+- A: `"number"`
+- B: `"array"`
+- C: `"object"`
+- D: `"NaN"`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+Parametrul rest (`...args`) ne permite să "colectăm" toate argumentele rămase într-un array. Un array este un obiect, așa că `typeof args` returnează `"object"`
+
+</p>
+</details>
+
+---
+
+###### 20. Care este rezultatul?
+
+```javascript
+function getAge() {
+  'use strict';
+  age = 21;
+  console.log(age);
+}
+
+getAge();
+```
+
+- A: `21`
+- B: `undefined`
+- C: `ReferenceError`
+- D: `TypeError`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+Cu `"use strict"`, puteți asigura că nu declarați accidental variabile globale. Niciodată nu am declarat variabila `age`, și deoarece folosim `"use strict"`, va arunca o eroare de referință. Dacă nu am fi folosit `"use strict"`, ar fi funcționat, deoarece proprietatea `age` ar fi fost adăugată la obiectul global.
+
+</p>
+</details>
+
+---
+
+###### 21. Care este valoarea lui `sum`?
+
+```javascript
+const sum = eval('10*10+5');
+```
+
+- A: `105`
+- B: `"105"`
+- C: `TypeError`
+- D: `"10*10+5"`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: A
+
+`eval` evaluează codul care este trecut ca un șir de caractere. Dacă este o expresie, așa cum este în acest caz, evaluează expresia. Expresia este `10 * 10 + 5`. Aceasta returnează numărul `105`.
+
+</p>
+</details>
+
+---
+
+###### 22. Cât timp este accesibil cool_secret?
+
+```javascript
+sessionStorage.setItem('cool_secret', 123);
+```
+
+- A: Pentru totdeauna, datele nu se pierd.
+- B: Când utilizatorul închide fila.
+- C: Când utilizatorul închide întregul browser, nu doar fila.
+- D: Când utilizatorul oprește computerul.
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: B
+
+Datele stocate în `sessionStorage` sunt eliminate după închiderea _filei_.
+
+Dacă ați fi folosit `localStorage`, datele ar fi rămas acolo pentru totdeauna, cu excepția cazului în care, de exemplu, este invocată comanda `localStorage.clear()`.
+
+</p>
+</details>
+
+---
+
+###### 23. Care este rezultatul?
+
+```javascript
+var num = 8;
+var num = 10;
+
+console.log(num);
+```
+
+- A: `8`
+- B: `10`
+- C: `SyntaxError`
+- D: `ReferenceError`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: B
+
+Cu cuvântul cheie `var`, puteți declara mai multe variabile cu același nume. Variabila va reține apoi cea mai recentă valoare.
+
+Nu puteți face acest lucru cu `let` sau `const` deoarece acestea sunt cu scop de bloc.
+
+</p>
+</details>
+
+---
+
+###### 24. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+Toate cheile obiectelor (cu excepția simbolurilor) sunt șiruri de caractere în culise, chiar dacă nu le tastați ca șiruri de caractere. De aceea `obj.hasOwnProperty('1')` returnează de asemenea `true`.
+
+Acest lucru nu funcționează în același fel pentru un set. Nu există `'1'` în setul nostru: `set.has('1')` returnează `false`. Acesta are tipul numeric `1`, `set.has(1)` returnează `true`.
+
+</p>
+</details>
+
+---
+
+###### 25. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+Dacă aveți două chei cu același nume, cheia va fi înlocuită. Va rămâne totuși în prima sa poziție, dar cu ultima valoare specificată.
+
+</p>
+</details>
+
+---
+
+###### 26. Contextul global de execuție JavaScript creează două lucruri pentru dvs.: obiectul global și cuvântul cheie "this".
+
+- A: true
+- B: false
+- C: it depends
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: A
+
+Contextul de execuție de bază este contextul global de execuție: este ceea ce este accesibil peste tot în codul dvs.
+
+</p>
+</details>
+
+---
+
+###### 27. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+Instrucțiunea `continue` sare peste o iterație dacă o anumită condiție returnează `true`.
+
+</p>
+</details>
+
+---
+
+###### 28. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: A
+
+`String` este un constructor încorporat, la care putem adăuga proprietăți. Am adăugat doar o metodă la prototipul său. Șirurile primitive sunt convertite automat într-un obiect șir, generat de funcția prototip a șirului. Prin urmare, toate șirurile (obiecte de șir) au acces la acea metodă!
+
+</p>
+</details>
+
+---
+
+###### 29. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: B
+
+Cheile obiectului sunt convertite automat în șiruri de caractere. Încercăm să setăm un obiect ca cheie pentru obiectul `a`, cu valoarea `123`.
+
+Cu toate acestea, când transformăm în șir un obiect, acesta devine `"[object Object]"`. Deci ceea ce spunem aici este că `a["[object Object]"] = 123`. Apoi, putem încerca să facem același lucru din nou. `c` este un alt obiect pe care îl transformăm implicit în șir. Așadar, `a["[object Object]"] = 456`.
+
+Apoi, afișăm înregistrarea `a[b]`, care de fapt este `a["[object Object]"]`. Am setat doar asta la `456`, deci returnează `456`.
+
+</p>
+</details>
+
+---
+
+###### 30. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: B
+
+Avem o funcție `setTimeout` și am invocat-o mai întâi. Cu toate acestea, a fost înregistrată în ultimul rând.
+
+Acest lucru se datorează faptului că în browsere, nu avem doar motorul de execuție, avem și ceva numit `WebAPI`.`WebAPI` ne oferă funcția `setTimeout` de exemplu, și DOM-ul.
+
+După ce _callback_-ul este trimis către WebAPI, funcția `setTimeout` în sine (dar nu și callback-ul!) este scos din stivă.
+
+<img src="https://i.imgur.com/X5wsHOg.png" width="200">
+
+Acum, `foo` este invocată, iar`"First"` este înregistrat.
+
+<img src="https://i.imgur.com/Pvc0dGq.png" width="200">
+
+`foo` este scoasă din stivă, iar `baz` este invocată. Se înregistrează `"Third"`.
+
+<img src="https://i.imgur.com/WhA2bCP.png" width="200">
+
+WebAPI-ul nu poate adăuga pur și simplu lucruri în stivă atunci când este gata. În schimb, împinge funcția de callback într-o structură numită _coadă_.
+
+<img src="https://i.imgur.com/NSnDZmU.png" width="200">
+
+Aici începe să lucreze un event loop. Un **event loop** se uită la stivă și la coada de sarcini. Dacă stiva este goală, ia primul lucru din coadă și-l adaugă în stivă.
+
+<img src="https://i.imgur.com/uyiScAI.png" width="200">
+
+`bar` este invocată, `"Second"` este înregistrat și este scos din stivă.
+
+</p>
+</details>
+
 ---
\ No newline at end of file

From f71c4165a7e8cbdb97df743ddaa7a837aeb43fad Mon Sep 17 00:00:00 2001
From: alexb017 <alexbacirea@gmail.com>
Date: Tue, 22 Aug 2023 23:23:51 +0300
Subject: [PATCH 09/31] Added the questions from 31-40

---
 ro-RO/README.ro.md | 299 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 299 insertions(+)

diff --git a/ro-RO/README.ro.md b/ro-RO/README.ro.md
index 1f15fd70..1a86110b 100644
--- a/ro-RO/README.ro.md
+++ b/ro-RO/README.ro.md
@@ -960,4 +960,303 @@ Aici începe să lucreze un event loop. Un **event loop** se uită la stivă și
 </p>
 </details>
 
+---
+
+###### 31. Ce reprezintă "event.target" atunci când se face clic pe buton?
+
+```html
+<div onclick="console.log('first div')">
+  <div onclick="console.log('second div')">
+    <button onclick="console.log('button')">
+      Click!
+    </button>
+  </div>
+</div>
+```
+
+- A: În afara `div`
+- B: În interior `div`
+- C: `button`
+- D: Un șir de toate elementele înglobate.
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+Cel mai profund element înglobat care a cauzat evenimentul este ținta evenimentului. Puteți opri propagarea acestuia prin `event.stopPropagation`
+
+</p>
+</details>
+
+---
+
+###### 32. Când faceți clic pe paragraf, care este ieșirea înregistrată?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: A
+
+Dacă facem clic pe `p`, vom vedea două înregistrări: `p` și `div`. În timpul propagării evenimentului, există 3 faze: capturare, țintă și propagare. În mod implicit, gestionarii de evenimente sunt executați în faza de propagare (cu excepția cazului în care setați `useCapture` la `true`). Aceștia se execută de la cel mai profund element înglobat către exterior.
+
+</p>
+</details>
+
+---
+
+###### 33. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: D
+
+Cu ambele metode, putem transmite obiectul la care dorim să se refere cuvântul cheie `this`. Cu toate acestea, `.call` este de asemenea _executat imediat_!
+
+`.bind.` returnează o _copie_ a funcției, dar cu un context legat! Nu este executat imediat.
+
+</p>
+</details>
+
+---
+
+###### 34. Care este rezultatul?
+
+```javascript
+function sayHi() {
+  return (() => 0)();
+}
+
+console.log(typeof sayHi());
+```
+
+- A: `"object"`
+- B: `"number"`
+- C: `"function"`
+- D: `"undefined"`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: B
+
+Funcția `sayHi` returnează valoarea returnată de expresia funcției invocate imediat (IIFE). This function returned `0`, care este de tip `"number"`.
+	
+Informație utilă: `typeof` poate returna următoarele valori: `undefined`, `boolean`, `number`, `bigint`, `string`, `symbol`, `function` și `object`. Notați că `typeof null` returnează `"object"`.
+
+</p>
+</details>
+
+---
+
+###### 35. Care dintre aceste valori sunt considerate 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: Toate dintre ele sunt considerate falsy
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: A
+
+Există 8 valori considerate falsy:
+
+- `undefined`
+- `null`
+- `NaN`
+- `false`
+- `''` (șir de caractere gol)
+- `0`
+- `-0`
+- `0n` (BigInt(0))
+
+Constructorii de funcții, cum ar fi `new Number` și `new Boolean` sunt considerați truthy.
+
+</p>
+</details>
+
+---
+
+###### 36. Care este rezultatul?
+
+```javascript
+console.log(typeof typeof 1);
+```
+
+- A: `"number"`
+- B: `"string"`
+- C: `"object"`
+- D: `"undefined"`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: B
+
+`typeof 1` returnează `"number"`.
+`typeof "number"` returnează `"string"`
+
+</p>
+</details>
+
+---
+
+###### 37. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+Când setați o valoare pentru un element într-un array care depășește lungimea array-ului, JavaScript creează ceea ce se numește "slot-uri goale" (empty slots). Acestea au de fapt valoarea `undefined`, dar veți vedea ceva de genul:
+
+`[1, 2, 3, empty x 7, 11]`
+
+în funcție de locul în care îl rulați (este diferit pentru fiecare browser, Node.js, etc.)
+
+</p>
+</details>
+
+---
+
+###### 38. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: A
+
+Blocul `catch` primește argumentul `x`. Acesta nu este același `x` ca variabila când transmitem argumente. Această variabilă `x` este având domeniu de bloc (block-scoped).
+
+Mai târziu, setăm această variabilă cu domeniu de bloc la valoarea `1`, și stabilim valoarea variabilei `y`. Acum, înregistrăm în consolă variabila cu domeniu de bloc `x`, care este egală cu `1`.
+
+În afara blocului `catch`, `x` rămâne `undefined`, și `y` este `2`. Atunci când dorim să afișăm în consolă `console.log(x)` în afara blocului `catch`, acesta returnează `undefined`, și `y` returnează `2`.
+
+</p>
+</details>
+
+---
+
+###### 39. Totul în JavaScript este fie un...
+
+- A: primitiv sau obiect
+- B: funcție sau obiect
+- C: întrebare trucată! doar obiecte
+- D: număr sau obiect
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: A
+
+JavaScript are doar tipuri primitive și obiecte.
+
+Tipurile primitive sunt `boolean`, `null`, `undefined`, `bigint`, `number`, `string`, și `symbol`.
+
+Ceea ce diferențiază un tip primitiv de un obiect este faptul că tipurile primitive nu au proprietăți sau metode. Cu toate acestea, veți observa că `'foo'.toUpperCase()` se evaluează la `'FOO'` și nu duce la o eroare `TypeError`. Acest lucru se întâmplă pentru că atunci când încercați să accesați o proprietate sau o metodă pe un tip primitiv, cum ar fi un șir de caractere (string), JavaScript va înconjura implicit tipul primitiv folosind una dintre clasele de înveliș, adică `String`, și apoi va renunța imediat la înveliș după ce expresia se evaluează. Toate tipurile primitive, cu excepția `null` și `undefined` prezintă acest comportament.
+
+</p>
+</details>
+
+---
+
+###### 40. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+`[1, 2]` este valoarea noastră inițială. Aceasta este valoarea cu care începem și valoarea primului `acc`. În prima rundă, `acc` este `[1,2]`, și `cur` este `[0, 1]`. Le concatenăm, ceea ce duce la rezultatul `[1, 2, 0, 1]`.
+
+Atunci, `[1, 2, 0, 1]` este `acc` și `[2, 3]` este `cur`. Le concatenăm și obținem `[1, 2, 0, 1, 2, 3]`
+
+</p>
+</details>
+
 ---
\ No newline at end of file

From 61c9c0b0592259332dd1c476f7d4efc7dce7801a Mon Sep 17 00:00:00 2001
From: alexb017 <alexbacirea@gmail.com>
Date: Tue, 22 Aug 2023 23:26:24 +0300
Subject: [PATCH 10/31] fix: ro-language link

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 7ccfaa63..30168af0 100644
--- a/README.md
+++ b/README.md
@@ -33,7 +33,7 @@ Feel free to reach out to me! 😊 <br />
 - [🇳🇱 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)
+- [🇷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)

From 2b20d4a8df8d319100e59b5be52a9b50c91df721 Mon Sep 17 00:00:00 2001
From: alexb017 <alexbacirea@gmail.com>
Date: Wed, 23 Aug 2023 23:21:40 +0300
Subject: [PATCH 11/31] Added the questions from 41-50

---
 ro-RO/README.ro.md | 290 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 290 insertions(+)

diff --git a/ro-RO/README.ro.md b/ro-RO/README.ro.md
index 1a86110b..9ad92324 100644
--- a/ro-RO/README.ro.md
+++ b/ro-RO/README.ro.md
@@ -1259,4 +1259,294 @@ Atunci, `[1, 2, 0, 1]` este `acc` și `[2, 3]` este `cur`. Le concatenăm și ob
 </p>
 </details>
 
+---
+
+###### 41. Care este rezultatul?
+
+```javascript
+!!null;
+!!'';
+!!1;
+```
+
+- A: `false` `true` `false`
+- B: `false` `false` `true`
+- C: `false` `true` `true`
+- D: `true` `true` `false`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: B
+
+`null` este falsy. `!null` returnează `true`. `!true` returnează `false`.
+
+`""` este falsy. `!""` returnează `true`. `!true` returnează `false`.
+
+`1` este truthy. `!1` returnează `false`. `!false` returnează `true`.
+
+</p>
+</details>
+
+---
+
+###### 42. Ce returnează metoda `setInterval` în browser?
+
+```javascript
+setInterval(() => console.log('Hi'), 1000);
+```
+
+- A: un id unic
+- B: cantitatea de milisecunde specificată
+- C: funcția furnizată
+- D: `undefined`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: A
+
+Aceasta returnează un identificator unic. Acest id poate fi utilizat pentru a opri intervalul respectiv cu ajutorul funcției `clearInterval()`.
+
+</p>
+</details>
+
+---
+
+###### 43. Ce returnează acest lucru?
+
+```javascript
+[...'Lydia'];
+```
+
+- A: `["L", "y", "d", "i", "a"]`
+- B: `["Lydia"]`
+- C: `[[], "Lydia"]`
+- D: `[["L", "y", "d", "i", "a"]]`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: A
+
+Un șir de caractere este un obiect iterabil. Operatorul de răspândire (spread operator) mapează fiecare caracter dintr-un obiect iterabil la un element separat.
+
+</p>
+</details>
+
+---
+
+###### 44. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+Funcțiile regulate nu pot fi oprite în mijlocul execuției după invocare. Cu toate acestea, o funcție generator poate fi "oprită" în mijloc și ulterior poate continua de la locul unde s-a oprit. De fiecare dată când o funcție generator întâlnește un cuvânt cheie `yield`, funcția furnizează valoarea specificată după el. Notați că funcția generator în acest caz nu _returnează_ the valoarea, ci _furnizează_ valoarea.
+
+Mai întâi, inițializăm funcția generator cu `i` egal cu `10`. Invocăm funcția generator folosind metoda `next()`. Prima dată când invocăm funcția generator, `i` este egal cu `10`. Aceasta întâlnește primul cuvânt cheie `yield`: furnizează valoarea lui `i`. Generatorul este acum "pauzat", și se înregistrează valoarea `10`.
+
+Apoi, invocăm din nou funcția cu metoda `next()`. Ea începe să continue de unde s-a oprit anterior, încă cu `i` egal cu `10`. Acum, întâlnește următorul cuvânt cheie `yield`, și furnizează `i * 2`. `i` este egal cu `10`, așa că returnează `10 * 2`, adică `20`. Acest lucru duce la rezultatul `10, 20`.
+
+</p>
+</details>
+
+---
+
+###### 45. Ce returnează asta?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: B
+
+Atunci când transmitem mai multe promisiuni metodei `Promise.race`, ea rezolvă/rejectează _prima_ promisiune care se rezolvă/rejectează. Pentru metoda `setTimeout`, transmitem un cronometru: 500ms pentru prima promisiune (`firstPromise`), și 100ms pentru a doua promisiune (`secondPromise`). Acest lucru înseamnă că `secondPromise` se rezolvă primul cu valoarea `'two'`. `res` conține acum valoarea `'two'`, care se înregistrează în consolă.
+
+</p>
+</details>
+
+---
+
+###### 46. Care este resultatul?
+
+```javascript
+let person = { name: 'Lydia' };
+const members = [person];
+person = null;
+
+console.log(members);
+```
+
+- A: `null`
+- B: `[null]`
+- C: `[{}]`
+- D: `[{ name: "Lydia" }]`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: D
+
+În primul rând, declarăm o variabilă `person` cu valoarea unui obiect care are o proprietate `name`.
+
+<img src="https://i.imgur.com/TML1MbS.png" width="200">
+
+Apoi, declarăm o variabilă numită `members`. Setăm primul element al acestui array egal cu valoarea variabilei `person`. Obiectele interacționează prin _referință_ atunci când le setăm egale între ele. Atunci când atribuiți o referință de la o variabilă la alta, faceți o _copie_ a acelei referințe. (notați că acestea nu au _aceași_ referință!)
+
+<img src="https://i.imgur.com/FSG5K3F.png" width="300">
+
+Apoi, setăm variabila `person` egală cu `null`.
+
+<img src="https://i.imgur.com/sYjcsMT.png" width="300">
+
+Noi modificăm doar valoarea variabilei `person` nu și primul element din array, deoarece acel element are o referință diferită (copiată) la obiect. Primul element din `members` încă păstrează referința sa la obiectul original. Când înregistrăm în consolă array-ul `members` primul element păstrează valoarea obiectului, care este afișată în consolă.
+
+</p>
+</details>
+
+---
+
+###### 47. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: B
+
+Cu un ciclu `for-in` putem itera prin cheile obiectului, în acest caz `name` și `age`. În interior, cheile obiectului sunt șiruri de caractere (dacă nu sunt de tip Symbol). În fiecare iterație, setăm valoarea lui `item` egală cu cheia curentă pe care o parcurge. Mai întâi, `item` este egal cu `name`, și este înregistrat în consolă. Apoi, `item` este egal cu `age`, care este, de asemenea, înregistrat în consolă.
+
+</p>
+</details>
+
+---
+
+###### 48. Care este rezultatul?
+
+```javascript
+console.log(3 + 4 + '5');
+```
+
+- A: `"345"`
+- B: `"75"`
+- C: `12`
+- D: `"12"`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: B
+
+Asociativitatea operatorilor este ordinea în care compilatorul evaluează expresiile, fie de la stânga la dreapta, fie de la dreapta la stânga. Acest lucru se întâmplă doar dacă toți operatorii au aceeași precedență. În cazul nostru, avem doar un tip de operator: `+`. Pentru adunare, asociativitatea este de la stânga la dreapta.
+
+`3 + 4` este evaluat mai întâi. Acest lucru duce la numărul `7`.
+
+`7 + '5'` duce la rezultatul `"75"` datorită coerției. JavaScript convertește numărul `7` într-un șir de caractere, așa cum am discutat în întrebarea 15. Putem concatena două șiruri de caractere folosind operatorul `+`. `"7" + "5"` rezultă în `"75"`.
+
+</p>
+</details>
+
+---
+
+###### 49. Care este valoarea lui`num`?
+
+```javascript
+const num = parseInt('7*6', 10);
+```
+
+- A: `42`
+- B: `"42"`
+- C: `7`
+- D: `NaN`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+Este returnat doar primul număr din șir. Bazat pe _radix_ (al doilea argument pentru a specifica în ce tip de număr dorim să-l parsăm: bază 10, hexazecimal, octal, binar, etc.), `parseInt` verifică dacă caracterele din șir sunt valide. Odată ce întâlnește un caracter care nu este un număr valid în baza specificată, oprește parsarea și ignoră caracterele ulterioare.
+
+`*` nu este un număr valid. Parsează doar `"7"` în numărul zecimal `7`. Acum, `num` conține valoarea `7`.
+
+</p>
+</details>
+
+---
+
+###### 50. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+Când se parcurge array-ul, valoarea lui `num` este egală cu elementul prin care parcurge în acel moment. În acest caz, elementele sunt numere, astfel că condiția din instrucțiunea `typeof num === "number"` returnează `true`. Funcția map creează un nou array și introduce valorile returnate de funcție.
+
+Cu toate acestea, nu returnăm o valoare. Atunci când nu returnăm o valoare din funcție, funcția returnează `undefined`. Pentru fiecare element din array, blocul funcției este apelat, deci pentru fiecare element returnăm `undefined`.
+
+</p>
+</details>
+
 ---
\ No newline at end of file

From 34523eb086f9bbbbfd93ec3aec5cd2ae1d0e1b55 Mon Sep 17 00:00:00 2001
From: alexb017 <alexbacirea@gmail.com>
Date: Thu, 24 Aug 2023 23:32:29 +0300
Subject: [PATCH 12/31] Added the questions from 51-60

---
 ro-RO/README.ro.md | 346 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 346 insertions(+)

diff --git a/ro-RO/README.ro.md b/ro-RO/README.ro.md
index 9ad92324..921da0d2 100644
--- a/ro-RO/README.ro.md
+++ b/ro-RO/README.ro.md
@@ -1549,4 +1549,350 @@ Cu toate acestea, nu returnăm o valoare. Atunci când nu returnăm o valoare di
 </p>
 </details>
 
+---
+
+###### 51. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: A
+
+Argumentele sunt transmise prin _valoare_, cu excepția cazului în care valoarea lor este un obiect, caz în care sunt transmise prin _referință_. `birthYear` este transmis prin valoare, deoarece este un șir de caractere (string), nu un obiect. Atunci când transmitem argumente prin valoare, se creează o _copie_ a acelei valori (consultați întrebarea 46).
+
+Variabila `birthYear` are o referință la valoarea `"1997"`. Argumentul `year` are, de asemenea, o referință la valoarea `"1997"`, dar nu este aceeași valoare la care se referă `birthYear`. Atunci când actualizăm valoarea lui `year` prin setarea lui `year` egal cu `"1998"`, actualizăm doar valoarea lui `year`. `birthYear` rămâne în continuare egal cu `"1997"`.
+
+Valoarea lui `person` este un obiect. Argumentul `member` are o referință (copiată) către _același_ obiect. Atunci când modificăm o proprietate a obiectului la care se referă `member` valoarea lui `person` va fi de asemenea modificată, deoarece ambele au o referință la același obiect. Proprietatea `name` a lui `person` este acum egală cu valoarea `"Lydia"`.
+
+</p>
+</details>
+
+---
+
+###### 52. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: D
+
+Cu instrucțiunea `throw` putem crea erori personalizate. Cu această instrucțiune, puteți arunca excepții. O excepție poate fi un <b>șir de caractere</b>, un <b>număr</b>, un <b>boolean</b> sau un <b>obiect</b>. În acest caz, excepția noastră este șirul `'Hello world!'`.
+
+Cu instrucțiunea `catch` putem specifica ce să facem dacă o excepție este aruncată în blocul `try`. O excepție este aruncată: șirul `'Hello world!'`. `e` este acum egal cu acel șir, pe care îl înregistrăm. Acest lucru duce la rezultatul `'Oh an error: Hello world!'`.
+
+</p>
+</details>
+
+---
+
+###### 53. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: B
+
+Atunci când o funcție constructor este apelată cu cuvântul cheie `new`, aceasta creează un obiect și stabilește cuvântul cheie `this` să se refere la acel obiect. În mod implicit, dacă funcția constructor nu returnează explicit nimic, va returna obiectul creat recent.
+
+În acest caz, funcția constructor `Car` returnează în mod explicit un obiect nou cu proprietatea `make` setată la `"Maserati"`, ceea ce suprascrie comportamentul implicit. Prin urmare, atunci când este apelat `new Car()` obiectul _returnat_ este atribuit lui `myCar`, ceea ce duce la rezultatul `"Maserati"` atunci când se accesează `myCar.make`.
+
+</p>
+</details>
+
+---
+
+###### 54. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: A
+
+`let x = (y = 10);` este de fapt o prescurtare pentru
+
+```javascript
+y = 10;
+let x = y;
+```
+
+Când setăm `y` egal cu `10`, adăugăm de fapt o proprietate `y` la obiectul global (`window` într-un browser, `global` în Node). Într-un browser, `window.y` este acum egal cu `10`.
+
+Apoi, declarăm o variabilă `x` cu valoarea `y`, care este `10`. Variabilele declarate cu cuvântul cheie `let` au domeniu de bloc _block scoped_, ele sunt definite doar în blocul în care sunt declarate; în cazul de față, în funcția expresie invocată imediat (IIFE). Atunci când folosim operatorul `typeof` operandul `x` nu este definit: încercăm să accesăm `x` în afara blocului în care este declarat. Acest lucru înseamnă că `x` nu este definit. Valorile care nu au primit o valoare sau nu au fost declarate sunt de tip `"undefined"`. `console.log(typeof x)` returnează `"undefined"`.
+
+Cu toate acestea, am creat o variabilă globală `y` atunci când am setat `y` egal cu `10`. Această valoare este accesibilă oriunde în codul nostru. `y` este definită și deține o valoare de tip `"number"`. `console.log(typeof y)` returnează `"number"`.
+
+</p>
+</details>
+
+---
+
+###### 55. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: A
+
+Putem șterge proprietăți din obiecte folosind cuvântul cheie `delete` inclusiv de pe prototip. Prin ștergerea unei proprietăți de pe prototip, aceasta nu mai este disponibilă în lanțul prototipului. În acest caz, funcția `bark` nu mai este disponibilă pe prototip după `delete Dog.prototype.bark`, dar încercăm totuși să o accesăm.
+
+Când încercăm să apelăm ceva care nu este o funcție, este aruncată o excepție  `TypeError`. În acest caz, se generează eroarea `TypeError: pet.bark is not a function`, deoarece `pet.bark` este `undefined`.
+
+</p>
+</details>
+
+---
+
+###### 56. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: D
+
+Obiectul `Set` este o colecție de valori unice: o valoare poate apărea doar o singură dată într-un set.
+
+m transmis iterable-ul `[1, 1, 2, 3, 4]` cu o valoare duplicată `1`. Deoarece nu putem avea două valori identice într-un set, una dintre ele este eliminată. Acest lucru duce la rezultatul `{1, 2, 3, 4}`.
+
+</p>
+</details>
+
+---
+
+###### 57. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+Un modul importat este _doar pentru citire_: nu puteți modifica modulul importat. Doar modulul care le exportă poate schimba valorile acestora.
+
+Când încercăm să incrementăm valoarea lui `myCounter`, apare o eroare: `myCounter` este doar pentru citire și nu poate fi modificat.
+
+</p>
+</details>
+
+---
+
+###### 58. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: A
+
+Operatorul `delete` returnează o valoare booleană: `true` în cazul ștergerii reușite, în caz contrar va returna `false`. Cu toate acestea, variabilele declarate cu cuvintele cheie `var`, `const` sau `let` nu pot fi șterse folosind operatorul `delete`.
+
+Variabila `name` a fost declarată cu cuvântul cheie `const` așa că ștergerea sa nu reușește: se returnează `false`. Atunci când setăm `age` egal cu `21`, de fapt am adăugat o proprietate numită `age` la obiectul global. În acest fel, puteți șterge cu succes proprietăți din obiecte, inclusiv din obiectul global, așa că `delete age` returnează `true`.
+
+</p>
+</details>
+
+---
+
+###### 59. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+Putem dezasambla (unpack) valori din array-uri sau proprietăți din obiecte prin destructurare. De exemplu:
+
+```javascript
+[a, b] = [1, 2];
+```
+
+<img src="https://i.imgur.com/ADFpVop.png" width="200">
+
+Valoarea lui `a` este acum `1`, iar valoarea lui `b` este acum `2`. Ceea ce am făcut în întrebare este:
+
+```javascript
+[y] = [1, 2, 3, 4, 5];
+```
+
+<img src="https://i.imgur.com/NzGkMNk.png" width="200">
+
+Acest lucru înseamnă că valoarea lui `y` este egală cu prima valoare din array, care este numărul `1`. Când înregistrăm în consolă `y`, se returnează `1`.
+
+</p>
+</details>
+
+---
+
+###### 60. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: B
+
+Este posibil să combinăm obiecte folosind operatorul de răspândire`...`. Acesta vă permite să creați copii ale perechilor cheie/valoare dintr-un obiect și să le adăugați la alt obiect. În acest caz, creăm copii ale obiectului `user` și le adăugăm la obiectul `admin`. Obiectul `admin` conține acum perechile cheie/valoare copiate, ceea ce duce la rezultatul `{ admin: true, name: "Lydia", age: 21 }`.
+
+</p>
+</details>
+
 ---
\ No newline at end of file

From b99e7b2f2c0cec77aaccb975bd675873813424f4 Mon Sep 17 00:00:00 2001
From: alexb017 <alexbacirea@gmail.com>
Date: Fri, 25 Aug 2023 15:08:24 +0300
Subject: [PATCH 13/31] fix: fixed typo from question 63

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 30168af0..40c520c0 100644
--- a/README.md
+++ b/README.md
@@ -1988,7 +1988,7 @@ console.log(num2);
 
 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` afterwards.
 
-`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` 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>

From 270616517ec283f8376ea7e79524f13223f5a04f Mon Sep 17 00:00:00 2001
From: Rahil Ghanchi <94079100+rahiljakir@users.noreply.github.com>
Date: Mon, 28 Aug 2023 04:06:15 +0530
Subject: [PATCH 14/31] Update README.md

made little correction in answer of 150.  where property would be
"[object Object]"  not "object Object"
---
 README.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index 97cde89e..7988c04a 100644
--- a/README.md
+++ b/README.md
@@ -4973,11 +4973,11 @@ console.log(animals[dog])
 
 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"}`.
+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. 
+`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" }`.
+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>

From 4ba6b35ab4c3fb3b4ddde4f76b5785dc5f85616e Mon Sep 17 00:00:00 2001
From: alexb017 <alexbacirea@gmail.com>
Date: Tue, 29 Aug 2023 18:30:58 +0300
Subject: [PATCH 15/31] Added the questions from 61-155

---
 ro-RO/README.ro.md | 3252 +++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 3251 insertions(+), 1 deletion(-)

diff --git a/ro-RO/README.ro.md b/ro-RO/README.ro.md
index 921da0d2..0907fa94 100644
--- a/ro-RO/README.ro.md
+++ b/ro-RO/README.ro.md
@@ -1895,4 +1895,3254 @@ Este posibil să combinăm obiecte folosind operatorul de răspândire`...`. Ace
 </p>
 </details>
 
----
\ No newline at end of file
+---
+
+###### 61. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: B
+
+Cu metoda `defineProperty` putem adăuga noi proprietăți la un obiect sau să modificăm cele existente. Atunci când adăugăm o proprietate la un obiect folosind metoda `defineProperty` aceasta nu este, în mod implicit, _nu enumerabilă_. Metoda `Object.keys` returnează toate numele de proprietăți _enumerabile_ dintr-un obiect, în acest caz doar `"name"`.
+
+Proprietățile adăugate folosind metoda `defineProperty` sunt, în mod implicit, imutabile (nu pot fi schimbate). Puteți anula acest comportament folosind proprietățile `writable`, `configurable` și `enumerable` În acest fel, metoda `defineProperty` vă oferă un control mai mare asupra proprietăților pe care le adăugați la un obiect.
+
+</p>
+</details>
+
+---
+
+###### 62. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: A
+
+Al doilea argument al funcției `JSON.stringify` este _replacer-ul_. Replacer-ul poate fi fie o funcție, fie un array, și vă permite să controlați ce și cum ar trebui să fie serializate (convertite în șir de caractere) valorile.
+
+Dacă replacer-ul este un _array_, în șirul JSON vor fi incluse doar numele de proprietăți care sunt prezente în array. În acest caz, doar proprietățile cu numele `"level"` și `"health"` sunt incluse, în timp ce `"username"` este exclus. Astfel, `data` devine egal cu `"{"level":19, "health":90}"`.
+
+Dacă replacer-ul este o _funcție_, această funcție este apelată pentru fiecare proprietate din obiectul pe care îl serializați. Valoarea returnată de această funcție va fi valoarea proprietății atunci când este adăugată în șirul JSON. Dacă valoarea este `undefined`, această proprietate este exclusă din șirul JSON.
+
+</p>
+</details>
+
+---
+
+###### 63. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: A
+
+Operatorul unary `++` _returnează mai întâi_ valoarea operandului și _apoi incrementează_ valoarea operandului. Valoarea lui `num1` este `10`, deoarece funcția `increaseNumber` returnează mai întâi valoarea lui `num`, care este `10`, și numai apoi incrementează valoarea lui `num`.
+
+`num2` este `10`, deoarece am transmis `num1` către funcția `increasePassedNumber`. `number` ieste egal cu `10`(valoarea lui `num1`). Iarăși, operatorul unary `++` _returnează mai întâi_ valoarea operandului și _apoi incrementeazăs_ valoarea operandului. Valoarea lui `number` este `10`, așa că `num2` este egal cu `10`.
+
+</p>
+</details>
+
+---
+
+###### 64. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+În ES6, putem inițializa parametri cu o valoare implicită. Valoarea parametrului va fi valoarea implicită, dacă nu a fost furnizată nicio altă valoare funcției sau dacă valoarea parametrului este `"undefined"`. În acest caz, răspândim proprietățile obiectului `value`  într-un obiect nou, astfel încât `x` are valoarea implicită `{ number: 10 }`.
+
+Argumentul implicit este evaluat la _momentul apelului_! De fiecare dată când apelăm funcția, se creează un obiect _nou_. Invocăm funcția `multiply` primele două ori fără a furniza o valoare: `x` are valoarea implicită `{ number: 10 }`. Apoi înregistrăm în consolă valoarea înmulțită a acelui număr, care este `20`.
+
+A treia oară când apelăm `multiply`, furnizăm un argument: obiectul numit `value`. Operatorul `*=` este, de fapt, o prescurtare pentru `x.number = x.number * 2`: modificăm valoarea lui`x.number`, și înregistrăm în consolă valoarea înmulțită, care este `20`.
+
+A patra oară, trecem din nou obiectul `value`. `x.number` a fost modificat anterior la `20`, deci `x.number *= 2` înregistrează `40`.
+
+</p>
+</details>
+
+---
+
+###### 65. Care este rezultatul?
+
+```javascript
+[1, 2, 3, 4].reduce((x, y) => console.log(x, y));
+```
+
+- A: `1` `2` și `3` `3` și `6` `4`
+- B: `1` `2` și `2` `3` și `3` `4`
+- C: `1` `undefined` și `2` `undefined` și `3` `undefined` și `4` `undefined`
+- D: `1` `2` și `undefined` `3` și `undefined` `4`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: D
+
+Primul argument pe care îl primește metoda `reduce` este _acumulator-ul_, `x` în acest caz. Al doilea argument este _valoarea curentă_, `y`. Cu metoda `reduce`, executăm o funcție de apel pe fiecare element din array, ceea ce poate duce în cele din urmă la o singură valoare.
+
+În acest exemplu, nu returnăm nicio valoare, ci doar înregistrăm valorile accumulatorului și valorii curente.
+
+Valoarea accumulatorului este egală cu valoarea returnată anterior de funcția de apel. Dacă nu furnizați argumentul opțional `initialValue` metodei `reduce`, accumulatorul este egal cu primul element la prima apelare.
+
+La prima apelare, accumulatorul (`x`) este `1`, iar valoarea curentă (`y`) este `2`. Nu returnăm din funcția de apel, ci înregistrăm valorile accumulatorului și valoarea curentă: se înregistrează `1` și `2`.
+
+Dacă nu returnați o valoare dintr-o funcție, aceasta va returna `undefined`. OLa următoarea apelare, accumulatorul este `undefined`, iar valoarea curentă este `3`. Se înregistrează `undefined` și `3`.
+
+La a patra apelare, din nou nu returnăm din funcția de apel. Accumulatorul este din nou `undefined`, iar valoarea curentă este `4`. Se înregistrează `undefined` și `4`.
+
+</p>
+</details>
+  
+---
+
+###### 66. Cu ce constructor putem extinde cu succes clasa `Dog`?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: B
+
+Într-o clasă derivată, nu puteți accesa cuvântul cheie `this` înainte de a apela `super`. Dacă încercați să faceți acest lucru, va arunca o ReferenceError: 1 și 4 ar arunca o eroare de referință.
+
+Cu cuvântul cheie `super`, apelăm constructorul clasei părinte cu argumentele date. Constructorul părintelui primește argumentul `name`, deci trebuie să transmitem `name` la `super`.
+
+Clasa `Labrador` primește doi argumente, `name` deoarece extinde clasa `Dog`, și `size` ca o proprietate suplimentară în clasa `Labrador`. Ambele trebuie să fie transmise funcției constructor din clasa `Labrador`, ceea ce se face corect utilizând constructorul 2.
+
+</p>
+</details>
+
+---
+
+###### 67. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: B
+
+Cu cuvântul cheie `import`, toate modulele importate sunt _preparate în prealabil_. Acest lucru înseamnă că modulele importate sunt executate _mai întâi_, codul din fișierul care importă modulul este executat _după accea_.
+
+Acesta este un diferență între `require()` în CommonJS și `import`! Cu `require()`, puteți încărca dependențele la cerere în timp ce codul este în curs de desfășurare. Dacă am fi folosit `require` în loc de `import`, ar fi fost înregistrate în consolă mesajele `running index.js`, `running sum.js`, `3`.
+
+</p>
+</details>
+
+---
+
+###### 68. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: A
+
+Fiecare Symbol este complet unic. Scopul argumentului furnizat către Symbol este de a oferi Symbolului o descriere. Valoarea Symbolului nu depinde de argumentul furnizat. În timp ce testăm egalitatea, creăm două simboluri complet noi: primul `Symbol('foo')`, și al doilea `Symbol('foo')`. Aceste două valori sunt unice și nu sunt egale între ele, `Symbol('foo') === Symbol('foo')` returnează `false`.
+
+</p>
+</details>
+
+---
+
+###### 69. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+Cu metoda `padStart` putem adăuga umplutură la începutul unui șir. Valoarea transmisă acestei metode este lungimea _totală_ a șirului împreună cu umplutura. Șirul `"Lydia Hallie"` are o lungime de `12`. `name.padStart(13)` introduce 1 spațiu la începutul șirului, deoarece 12 + 1 este 13.
+
+Dacă argumentul transmis metodei `padStart` este mai mic decât lungimea șirului, nu va fi adăugată nicio umplutură.
+
+</p>
+</details>
+
+---
+
+###### 70. Care este rezultatul?
+
+```javascript
+console.log('🥑' + '💻');
+```
+
+- A: `"🥑💻"`
+- B: `257548`
+- C: Un șir care conține punctele de cod ale caracterelor
+- D: Eroare
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: A
+
+Cu operatorul `+`, puteți concatena șiruri. În acest caz, concatenăm șirul `"🥑"` cu șirul `"💻"`, rezultând `"🥑💻"`.
+
+</p>
+</details>
+
+---
+
+###### 71. Cum putem înregistra valorile aflate în comentarii după instrucțiunea console.log?
+
+```javascript
+function* startGame() {
+  const answer = yield 'Do you love JavaScript?';
+  if (answer !== '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` și `game.next().value`
+- B: `game.next.value("Yes")` și `game.next.value()`
+- C: `game.next().value` și `game.next("Yes").value`
+- D: `game.next.value()` și `game.next.value("Yes")`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+O funcție generator "pauzează" execuția când întâlnește cuvântul cheie `yield`. Mai întâi, trebuie să permitem funcției să emită șirul "Do you love JavaScript?", ceea ce poate fi făcut apelând `game.next().value`.
+
+Fiecare linie este executată până când găsește primul cuvânt cheie `yield`. Există un cuvânt cheie `yield` pe prima linie din funcție: execuția se oprește cu primul `yield`. _Acest lucru înseamnă că variabila `answer` nu este definită încă!_
+
+Când apelăm `game.next("Yes").value`, cuvântul cheie `yield` anterior este înlocuit cu valoarea parametrilor transmiși funcției `next()`, `"Yes"` în acest caz. Valoarea variabilei `answer` este acum egală cu `"Yes"`. Condiția declarației if returnează `false`, și `JavaScript loves you back ❤️` este înregistrat în consolă.
+
+</p>
+</details>
+
+---
+
+###### 72. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+`String.raw` returnează un șir în care escape-urile (`\n`, `\v`, `\t` etc.) sunt ignorate! Backslash-urile pot fi o problemă, deoarece puteți ajunge cu ceva similar cu:
+
+`` const path = `C:\Documents\Projects\table.html` ``
+
+Acest lucru ar rezulta în:
+
+`"C:DocumentsProjects able.html"`
+
+Cu `String.raw`, acesta ar ignora pur și simplu escape-ul și ar afișa:
+
+`C:\Documents\Projects\table.html`
+
+În acest caz, șirul este `Hello\nworld`, care este înregistrat în consolă.
+
+</p>
+</details>
+
+---
+
+###### 73. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+O funcție `async` întotdeauna returnează o promisiune. Instrucțiunea `await` încă trebuie să aștepte ca promisiunea să se rezolve: o promisiune în așteptare este returnată atunci când apelăm `getData()` pentru a o atribui variabilei `data`.
+
+Dacă dorim să avem acces la valoarea rezolvată `"I made it"`, am putea folosi metoda `.then()` pe `data`:
+
+`data.then(res => console.log(res))`
+
+Acest lucru ar fi înregistrat `"I made it!"`
+
+</p>
+</details>
+
+---
+
+###### 74. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: B
+
+Metoda`.push()` returnează _lungimea_ noului șir! Înainte, șirul conținea un element (șirul `"banana"`) și avea o lungime de `1`. După adăugarea șirului `"apple"` în șir, șirul conține două elemente și are o lungime de `2`. Aceasta este valoarea returnată de funcția `addToList`.
+
+Metoda `push` modifică șirul original. Dacă doreați să returnați _șirul_ din funcție în loc de _lungimea șirului_, ar fi trebuit să returnați `list` după ce ați adăugat `item` la el.
+
+</p>
+</details>
+
+---
+
+###### 75. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: B
+
+`Object.freeze` face imposibilă adăugarea, eliminarea sau modificarea proprietăților unui obiect (cu excepția cazului în care valoarea proprietății este un alt obiect).
+
+Când creăm variabila `shape` și o setăm egală cu obiectul înghețat `box`, `shape` de asemenea se referă la un obiect înghețat. Puteți verifica dacă un obiect este înghețat folosind `Object.isFrozen`. În acest caz, `Object.isFrozen(shape)` ar returna true, deoarece variabila `shape` are o referință către un obiect înghețat.
+
+Deoarece `shape` este înghețat și deoarece valoarea lui`x` nu este un obiect, nu putem modifica proprietatea `x`. `x` rămâne egal cu `10`, și `{ x: 10, y: 20 }` este afișat în consolă.
+
+</p>
+</details>
+
+---
+
+###### 76. Care este rezultatul?
+
+```javascript
+const { firstName: myName } = { firstName: 'Lydia' };
+
+console.log(firstName);
+```
+
+- A: `"Lydia"`
+- B: `"myName"`
+- C: `undefined`
+- D: `ReferenceError`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: D
+
+Folosind [destructuring assignment](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment) cu sintaxa de mai jos putem extrage valori din array-uri sau proprietăți din obiecte în variabile distincte:
+
+```javascript
+const { firstName } = { firstName: 'Lydia' };
+// ES5 version:
+// var firstName = { firstName: 'Lydia' }.firstName;
+
+console.log(firstName); // "Lydia"
+```
+
+De asemenea, o proprietate poate fi extras dintr-un obiect și atribuită unei variabile cu un nume diferit decât proprietatea obiectului:
+
+```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
+```
+
+Prin urmare, `firstName` nu există ca variabilă, astfel încât încercarea de a accesa valoarea sa va genera o eroare `ReferenceError`.
+
+**Notă:** Fiți conștienți de proprietățile în `global scope` (spațiul global):
+
+```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
+
+```
+
+În cazul în care JavaScript nu poate găsi o variabilă în _cadrul curent_, acesta urcă pe [Scope chain](https://github.com/getify/You-Dont-Know-JS/blob/2nd-ed/scope-closures/ch3.md) și o caută. Dacă ajunge la nivelul superior al cadrului, adică la **spațiul global**, și tot nu o găsește, va arunca o excepție `ReferenceError`.
+
+- În **Browser-e** cum ar fi _Chrome_, `name` este o _proprietate de spațiu global depășită_. În acest exemplu, codul rulează în _spațiul global_ și nu există o variabilă locală definită de utilizator pentru `name`, așa că caută _variabilele/proprietățile_ predefinite în spațiul global, care în cazul browser-elor înseamnă că caută în obiectul `window` de unde extrage valoarea [window.name](https://developer.mozilla.org/en-US/docs/Web/API/Window/name) care este egală cu un **șir gol**.
+
+- În **NodeJS**, nu există o astfel de proprietate pe obiectul `global` așadar încercarea de a accesa o variabilă inexistentă va genera o [ReferenceError](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Not_defined).
+
+</p>
+</details>
+
+---
+
+###### 77. Este aceasta o funcție pură?
+
+```javascript
+function sum(a, b) {
+  return a + b;
+}
+```
+
+- A: Da
+- B: Nu
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: A
+
+O funcție pură este o funcție care _întotdeauna_ returnează același rezultat, dacă aceleași argumente sunt furnizate.
+
+Funcția `sum` întotdeauna returnează același rezultat. Dacă îi furnizăm `1` și `2`, va returna _întotdeauna_ `3` fără efecte secundare. Dacă îi furnizăm `5` și `10`, va returna _întotdeauna_ `15`, și tot așa. Aceasta este definiția unei funcții pure.
+
+</p>
+</details>
+
+---
+
+###### 78. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+Funcția `add` este o funcție _memoizată_. Cu ajutorul memoizării, putem să memorăm rezultatele unei funcții pentru a accelera execuția ulterioară. În acest caz, creăm un obiect `cache` care stochează valorile returnate anterior.
+
+Dacă apelăm din nou funcția `addFunction` cu același argument, funcția verifică mai întâi dacă a primit deja acea valoare în memoria sa cache. Dacă acest lucru este adevărat, se va returna valoarea din cache, economisind timp de execuție. Dacă nu este în cache, funcția va calcula valoarea și o va memora ulterior.
+
+Apelăm funcția `addFunction` de trei ori cu aceeași valoare: în prima invocare, valoarea funcției când `num` este egal cu `10` nu este încă în cache. Condiția instrucțiunii `num in cache` returnează `false`, iar blocul `else` este executat: se afișează `Calculated! 20` iar valoarea rezultatului este adăugată în obiectul de cache. Acum, `cache` arată astfel `{ 10: 20 }`.
+
+A doua oară, obiectul `cache` conține valoarea care este returnată pentru `10`. Condiția instrucțiunii `num in cache` returnează `true`, și se afișează `'From cache! 20'`.
+
+A treia oară, trecem `5 * 2` funcției, care este evaluat la `10`. Obiectul `cache` conține valoarea care este returnată pentru `10`. Condiția instrucțiunii `num in cache` returnează `true`, și se afișează `'From cache! 20'`.
+
+</p>
+</details>
+
+---
+
+###### 79. Care este rezultatul?
+
+```javascript
+const myLifeSummedUp = ['☕', '💻', '🍷', '🍫'];
+
+for (let item in myLifeSummedUp) {
+  console.log(item);
+}
+
+for (let item of myLifeSummedUp) {
+  console.log(item);
+}
+```
+
+- A: `0` `1` `2` `3` și `"☕"` `"💻"` `"🍷"` `"🍫"`
+- B: `"☕"` `"💻"` `"🍷"` `"🍫"` și `"☕"` `"💻"` `"🍷"` `"🍫"`
+- C: `"☕"` `"💻"` `"🍷"` `"🍫"` și `0` `1` `2` `3`
+- D: `0` `1` `2` `3` și `{0: "☕", 1: "💻", 2: "🍷", 3: "🍫"}`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: A
+
+Cu o buclă _for-in_, putem itera peste proprietățile **enumerabile**. Într-un șir, proprietățile enumerate sunt "cheile" elementelor din șir, care sunt de fapt indexurile lor. Puteți vedea un șir ca:
+
+`{0: "☕", 1: "💻", 2: "🍷", 3: "🍫"}`
+
+Unde cheile sunt proprietățile enumerate. `0` `1` `2` `3` sunt afișate.
+
+Cu o buclă _for-of_, putem itera peste obiecte **iterabile**. Un șir este un obiect iterabil. Când iterăm peste șir, variabila "item" este egală cu elementul pe care îl parcurge în acel moment, sunt afișate `"☕"` `"💻"` `"🍷"` `"🍫"`.
+
+</p>
+</details>
+
+---
+
+###### 80. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+Elementele dintr-un șir pot stoca orice valoare. Numere, șiruri, obiecte, alte șiruri, null, valori booleane, undefined și alte expresii precum date, funcții și calculații.
+
+Elementul va fi egal cu valoarea returnată. `1 + 2` returnează `3`, `1 * 2` returnează `2`, și `1 / 2` returnează `0.5`.
+
+</p>
+</details>
+
+---
+
+###### 81. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: B
+
+În mod implicit, argumentele au valoarea `undefined`, cu excepția cazului în care s-a transmis o valoare funcției. În acest caz, nu am transmis o valoare pentru argumentul `name`. `name` este egal cu `undefined` iar acesta este afișat.
+
+În ES6, putem suprascrie această valoare implicită `undefined` cu parametri impliciti. De exemplu:
+
+`function sayHi(name = "Lydia") { ... }`
+
+În acest caz, dacă nu am fi furnizat o valoare sau am fi furnizat `undefined`, `name` ar fi fost întotdeauna egal cu șirul `Lydia`.
+
+</p>
+</details>
+
+---
+
+###### 82. Care este rezultatul?
+
+```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: `"🥑"` și `"😍"`
+- B: `"🥑"` și `"😎"`
+- C: `"😍"` și `"😎"`
+- D: `"😎"` și `"😎"`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: B
+
+Valoarea cuvântului cheie `this` depinde de locul în care este utilizat. Într-o **metodă**, cum ar fi metoda `getStatus`, cuvântul cheie `this` se referă la _obiectul la care aparține metoda_. Metoda aparține obiectului `data`, deci `this` se referă la obiectul `data`. Când înregistrăm `this.status`, se înregistrează proprietatea `status` de pe obiectul `data` care este `"🥑"`.
+
+Cu metoda `call` putem schimba obiectul la care se referă cuvântul cheie `this`. În **funcții**, cuvântul cheie `this` se referă la _obiectul la care aparține funcția_. Am declarat funcția `setTimeout` pe _obiectul global_, deci în interiorul funcției `setTimeout`, cuvântul cheie `this` se referă la _obiectul global_. Pe obiectul global există o variabilă numită status cu valoarea `"😎"`. Când înregistrați `this.status`, se înregistrează `"😎"`.
+
+</p>
+</details>
+
+---
+
+###### 83. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: A
+
+Am setat variabila `city` egală cu valoarea proprietății numită `city` pe obiectul `person`. Nu există o proprietate pe acest obiect numită `city`, astfel că variabila `city` are valoarea `undefined`.
+
+Rețineți că nu facem referire la obiectul `person` în sine! Pur și simplu am setat variabila `city` egală cu valoarea curentă a proprietății `city` de pe obiectul `person`.
+
+Apoi, am setat `city` egal cu șirul de caractere `"Amsterdam"`. Acest lucru nu schimbă obiectul `person` nu există o referință la acel obiect.
+
+Atunci când se afișează obiectul `person` se va afișa obiectul original, nealterat.
+
+</p>
+</details>
+
+---
+
+###### 84. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+Variabilele declarate cu cuvintele cheie `const` și `let` au _domeniu de vizibilitate la nivel de bloc_. Un bloc poate fi definit între parantezele acolade (`{ }`). În acest caz, parantezele acolade ale instrucțiunilor if/else. Nu puteți face referire la o variabilă în afara blocului în care a fost declarată, va fi generată o eroare de tip ReferenceError.
+
+</p>
+</details>
+
+---
+
+###### 85. Ce tip de informații ar fi înregistrate?
+
+```javascript
+fetch('https://www.website.com/api/user/1')
+  .then(res => res.json())
+  .then(res => console.log(res));
+```
+
+- A: Rezultatul metodei `fetch`.
+- B: Rezultatul celei de-a doua apelări a metodei `fetch`.
+- C: Rezultatul funcției de retur (callback) din `.then()`-ul anterior.
+- D: Ar fi întotdeauna `undefined`.
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+Valoarea lui `res` în al doilea `.then` este egală cu valoarea returnată de `.then` anterior. Puteți continua să înșirați `.then`-uri în acest fel, unde valoarea este pasată către următorul manipulator.
+
+</p>
+</details>
+
+---
+
+###### 86. Care opțiune este o modalitate de a seta `hasName` egala cu `true`, cu condiția să nu puteți furniza `true` ca argument?
+
+```javascript
+function getName(name) {
+  const hasName = //
+}
+```
+
+- A: `!!name`
+- B: `name`
+- C: `new Boolean(name)`
+- D: `name.length`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: A
+
+Cu `!!name`, determinăm dacă valoarea lu `name` este adevărată sau falsă. Dacă `name` este adevărat, ceea ce dorim să testăm, `!name` returnează `false`. `!false` (practic, ceea ce este `!!name`) returnează `true`.
+
+Prin setarea lui `hasName` egal cu `name`, se face ca `hasName` să fie egal cu valoarea pe care ați furnizat-o funcției `getName`, nu cu valoarea booleană `true`.
+
+`new Boolean(true)` returnează un obiect încapsulator, nu valoarea booleană în sine.
+
+`name.length` returnează lungimea argumentului furnizat, nu dacă acesta este `true`.
+
+</p>
+</details>
+
+---
+
+###### 87. Care este rezultatul?
+
+```javascript
+console.log('I want pizza'[0]);
+```
+
+- A: `"""`
+- B: `"I"`
+- C: `SyntaxError`
+- D: `undefined`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: B
+
+Pentru a obține un caracter la un anumit index dintr-un șir de caractere, puteți utiliza notația cu paranteze pătrate. Primul caracter din șir are indexul 0, și așa mai departe. În acest caz, dorim să obținem elementul cu indexul 0, adică caracterul `"I'`, care va fi afișat în jurnal.
+
+Rețineți că această metodă nu este suportată în IE7 și versiunile anterioare. În acest caz, utilizați `.charAt()`.
+
+</p>
+</details>
+
+---
+
+###### 88. Care este rezultatul?
+
+```javascript
+function sum(num1, num2 = num1) {
+  console.log(num1 + num2);
+}
+
+sum(10);
+```
+
+- A: `NaN`
+- B: `20`
+- C: `ReferenceError`
+- D: `undefined`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: B
+
+Puteți seta valoarea implicită a unui parametru la valoarea altui parametru al funcției, atâta timp cât acestea sunt definite _înainte_ de parametrul cu valoarea implicită. Am transmis valoarea `10` funcției `sum`. Dacă funcția `sum` primește doar un argument, înseamnă că valoarea pentru `num2` nu este transmisă, iar valoarea lui `num1` este egală cu valoarea transmisă `10` în acest caz. Valoarea implicită a lui `num2` este valoarea lui `num1`, care este `10`. `num1 + num2` returnează `20`.
+
+Dacă încercați să setați valoarea implicită a unui parametru egală cu un parametru care este definit _după_ (în dreapta), valoarea parametrului nu a fost încă inițializată, ceea ce va genera o eroare.
+
+</p>
+</details>
+
+---
+
+###### 89. Care este rezultatul?
+
+```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: Obiectul global al `module.js`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: A
+
+Cu sintaxa `import * as name`, importăm _toate exporturile_ din fișierul `module.js` în fișierul `index.js` sub forma unui nou obiect numit `data`. În fișierul `module.js` există două exporturi: exportul implicit și un export cu nume. Exportul implicit este o funcție care returnează șirul de caractere `"Hello World"`, iar exportul cu nume este o variabilă numită `name` care are valoarea șirului de caractere `"Lydia"`.
+
+Obiectul `data` are o proprietate `default` pentru exportul implicit, iar celelalte proprietăți au numele exporturilor cu nume și valorile lor corespunzătoare.
+
+</p>
+</details>
+
+---
+
+###### 90. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+Clasele sunt o sintaxă mai simplă pentru constructorii de funcții. Echivalentul clasei `Person` sub forma unui constructor de funcții ar fi:
+
+```javascript
+function Person(name) {
+  this.name = name;
+}
+```
+
+Apelarea unui constructor de funcții cu `new` duce la crearea unei instanțe a obiectului `Person`, iar cuvântul cheie `typeof` returnează `"object"` pentru o astfel de instanță. `typeof member` returnează `"object"`.
+
+</p>
+</details>
+
+---
+
+###### 91. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: D
+
+Metoda `.push` returnează _lungimea nouă_ a array-ului, nu array-ul însuși! Prin setarea `newList` egal cu `[1, 2, 3].push(4)`, am setat `newList` egal cu noua lungime a array-ului: `4`.
+
+Apoi, încercăm să folosim metoda `.push` pe `newList`. Deoarece `newList` este o valoare numerică `4`, nu putem folosi metoda `.push` se va genera o eroare de tip TypeError.
+
+</p>
+</details>
+
+---
+
+###### 92. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: D
+
+Funcțiile obișnuite, cum ar fi funcția `giveLydiaPizza` au o proprietate `prototype` care este un obiect (obiectul prototip) cu o proprietate `constructor`. Cu toate acestea, funcțiile arrow, cum ar fi funcția `giveLydiaChocolate`, nu au această proprietate `prototype`. `undefined` este returnat atunci când încearca să acceseze proprietatea `prototype` folosind `giveLydiaChocolate.prototype`.
+
+</p>
+</details>
+
+---
+
+###### 93. Care este rezultatul?
+
+```javascript
+const person = {
+  name: 'Lydia',
+  age: 21,
+};
+
+for (const [x, y] of Object.entries(person)) {
+  console.log(x, y);
+}
+```
+
+- A: `name` `Lydia` și `age` `21`
+- B: `["name", "Lydia"]` și `["age", 21]`
+- C: `["name", "age"]` și `undefined`
+- D: `Error`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: A
+
+`Object.entries(person)` returnează un array de array-uri imbricate, care conțin cheile și obiectele:
+
+`[ [ 'name', 'Lydia' ], [ 'age', 21 ] ]`
+
+Folosind bucla `for-of` putem itera prin fiecare element din array, în acest caz, subarray-urile. Putem dezasambla subarray-urile instantaneu în bucla `for-of`, folosind `const [x, y]`. Astfel, `x` este egal cu primul element din subarray, iar `y` este egal cu al doilea element din subarray.
+
+Primul subarray este `[ "name", "Lydia" ]`, cu `x` egal cu `"name"`, și `y` egal cu `"Lydia"`, care sunt afișate în jurnal.
+Al doilea subarray este `[ "age", 21 ]`, cu `x` egal cu `"age"`, și `y` egal cu `21`, care sunt afișate în jurnal.
+
+</p>
+</details>
+
+---
+
+###### 94. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: D
+
+`...args`  este un parametru rest. Valoarea parametrului rest este un array care conține toate argumentele rămase și **poate fi doar ultimul parametru**! În acest exemplu, parametrul rest era al doilea parametru. Acest lucru nu este posibil și va genera o eroare de sintaxă.
+
+```javascript
+function getItems(fruitList, favoriteFruit, ...args) {
+  return [...fruitList, ...args, favoriteFruit];
+}
+
+getItems(['banana', 'apple'], 'pear', 'orange');
+```
+
+Exemplul de mai sus funcționează. Acesta returnează array-ul `[ 'banana', 'apple', 'orange', 'pear' ]`
+
+</p>
+</details>
+
+---
+
+###### 95. Care este rezultatul?
+
+```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` și `b is bigger`, `3`
+- B: `a is bigger`, `undefined` și `b is bigger`, `undefined`
+- C: `undefined` și `undefined`
+- D: `SyntaxError`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: B
+
+În JavaScript, nu _trebuie_ să scriem explicit semnul punct și virgulă (`;`) totuși motorul JavaScript le adaugă automat după instrucțiuni. Acest lucru se numește **Inserția Automată a Semnelor de Punct și Virgulă**. O instrucțiune poate fi, de exemplu, variabile sau cuvinte cheie precum `throw`, `return`, `break`, etc.
+
+Aici, am scris o instrucțiune `return` și o altă valoare `a + b` pe o _linie nouă_. Cu toate acestea, deoarece este o linie nouă, motorul JavaScript nu știe că este de fapt valoarea pe care am dorit să o returnăm. În schimb, a adăugat automat un punct și virgulă după `return`. Puteți vedea acest lucru ca:
+
+```javascript
+return;
+a + b;
+```
+
+Acest lucru înseamnă că `a + b` nu este niciodată atins, deoarece o funcție se oprește din executare după cuvântul cheie `return`. Dacă nu se returnează nicio valoare, așa cum se întâmplă aici, funcția returnează `undefined`. Rețineți că nu există inserție automată a semnelor de punct și virgulă după instrucțiunile `if/else`!
+
+</p>
+</details>
+
+---
+
+###### 96. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: B
+
+Putem seta clasele egale cu alte clase sau constructori de funcții. În acest caz, am setat `Person` egal cu `AnotherPerson`. Numele în acest constructor este `Sarah`, astfel încât proprietatea `Person` de pe noua instanță `member` este `"Sarah"`.
+
+</p>
+</details>
+
+---
+
+###### 97. Care este rezultatul?
+
+```javascript
+const info = {
+  [Symbol('a')]: 'b',
+};
+
+console.log(info);
+console.log(Object.keys(info));
+```
+
+- A: `{Symbol('a'): 'b'}` și `["{Symbol('a')"]`
+- B: `{}` și `[]`
+- C: `{ a: "b" }` și `["a"]`
+- D: `{Symbol('a'): 'b'}` și `[]`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: D
+
+Un simbol nu este _enumerabil_. Metoda `Object.keys` returnează toate proprietățile cheie _enumerabil_ ale unui obiect. Simbolul nu va fi vizibil, și va fi returnat un array gol. Atunci când se afișează întregul obiect, vor fi vizibile toate proprietățile, inclusiv cele care nu sunt enumerate.
+
+Asta este una dintre multele calități ale unui simbol: pe lângă faptul că reprezintă o valoare complet unică (ceea ce previne coliziunile accidentale de nume pe obiecte, de exemplu, atunci când lucrați cu două biblioteci care doresc să adauge proprietăți la același obiect), puteți "ascunde" proprietăți pe obiecte în acest fel (deși nu în întregime. Încă puteți accesa simbolurile folosind metoda `Object.getOwnPropertySymbols()`).
+
+</p>
+</details>
+
+---
+
+###### 98. Care este rezultatul?
+
+```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]]` și `SyntaxError`
+- B: `[1, [2, 3, 4]]` și `{ name: "Lydia", age: 21 }`
+- C: `[1, 2, 3, 4]` și `{ name: "Lydia", age: 21 }`
+- D: `Error` și `{ name: "Lydia", age: 21 }`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: A
+
+Funcția `getList` primește un array ca argument. Între parantezele funcției `getList` dezasamblăm acest array imediat. Puteți vedea acest lucru ca:
+
+`[x, ...y] = [1, 2, 3, 4]`
+
+Cu ajutorul parametrului rest `...y`, punem toți "parametrii rămași" într-un array. Parametrii rămași în acest caz sunt `2`, `3` și `4`. Valoarea lui `y` este un array care conține toți parametrii rămași. Valoarea lui `x` este egal cu `1` în acest caz, deci când afișăm `[x, y]`, va fi afișat `[1, [2, 3, 4]]`.
+
+Funcția `getUser` primește un obiect ca argument. Cu funcțiile arrow, nu _trebuie_ să scriem acolade dacă dorim să returnăm doar o valoare. Cu toate acestea, dacă doriți să returnați instantaneu un _obiect_ dintr-o funcție arrow, trebuie să-l scrieți între paranteze. Altfel, tot ce este între acolade va fi interpretat ca o instrucțiune bloc. În acest caz, codul dintre acolade nu este un cod JavaScript valid, așa că se va genera o eroare de sintaxă `SyntaxError`. 
+
+Funcția următoare ar fi returnat un obiect:
+
+`const getUser = user => ({ name: user.name, age: user.age })`
+
+</p>
+</details>
+
+---
+
+###### 99. Care este rezultatul?
+
+```javascript
+const name = 'Lydia';
+
+console.log(name());
+```
+
+- A: `SyntaxError`
+- B: `ReferenceError`
+- C: `TypeError`
+- D: `undefined`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+Variabila `name` conține o valoare de tip șir de caractere (string), care nu este o funcție și, prin urmare, nu poate fi invocată.
+
+TypeError-urile sunt generate atunci când o valoare nu este de tipul așteptat. JavaScript e aștepta ca `name` să fie o funcție, deoarece încercăm să o apelăm. Cu toate acestea, era de tip șir de caractere (string), așa că a generat o eroare de tip TypeError: name nu este o funcție!
+
+SyntaxError-urile sunt generate atunci când ați scris ceva care nu este JavaScript valid, de exemplu, atunci când ați scris cuvântul `return` ca `retrun`.
+ReferenceError-urile sunt generate atunci când JavaScript nu poate găsi o referință la o valoare la care încercați să accesați.
+
+</p>
+</details>
+
+---
+
+###### 100. Care este valoarea lui output?
+
+```javascript
+// 🎉✨ Aceasta este a 100-a mea întrebare! ✨🎉
+
+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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: B
+
+`[]` este o valoare adevărată (truthy). Cu operatorul `&&` valoarea din partea dreaptă va fi returnată dacă valoarea din partea stângă este adevărată. În acest caz, valoarea din partea stângă, `[]` este adevărată, astfel că se va returna `"Im'`.
+
+`""` este o valoare falsă (falsy). Dacă valoarea din partea stângă este falsă, nu se returnează nimic. `n't` nu va fi returnat.
+
+</p>
+</details>
+
+---
+
+###### 101. Care este valoarea ieșirii?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+Cu operatorul  `||` utem returna primul operand adevărat (truthy). Dacă toate valorile sunt false, se va returna ultimul operand.
+
+`(false || {} || null)`: obiectul go `{}` este o valoare adevărată (truthy). Aceasta este prima (și singura) valoare adevărată, care este returnată. `one` este egal cu `{}`.
+
+`(null || false || "")`: toate operanzii sunt valori false. Acest lucru înseamnă că ultimul operand `""` este returnat. `two` este egal cu `""`.
+
+`([] || 0 || "")`: array-ul gol `[]` este o valoare adevărată (truthy). Aceasta este prima valoare adevărată, care este returnată. `three` este egal cu `[]`.
+
+</p>
+</details>
+
+---
+
+###### 102. Care este valoarea ieșirii?
+
+```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` și `I have resolved!`, `second`
+- B: `second`, `I have resolved!` și `second`, `I have resolved!`
+- C: `I have resolved!`, `second` și `second`, `I have resolved!`
+- D: `second`, `I have resolved!` și `I have resolved!`, `second`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: D
+
+Cu o promisiune, spunem în principiu _Vreau să execut această funcție, dar o pun deoparte pentru moment în timp ce rulează, deoarece acest lucru poate dura ceva timp. Doar atunci când o anumită valoare este rezolvată (sau respinsă), și atunci când stiva de apeluri este goală, doresc să folosesc această valoare._
+
+Putem obține această valoare atât cu `.then` cât și cu cuvântul cheie `await` într-o funcție `async`. Cu toate că putem obține valoarea unei promisiuni cu ambele metode `.then` și `await`, ele funcționează puțin diferit.
+
+În `firstFunction`, am pus (într-un fel) funcția `myPromise` deoparte în timp ce aceasta se executa, dar am continuat să executăm restul codului, care este `console.log('second')` în acest caz. Apoi, funcția a fost rezolvată cu șirul `I have resolved`, care a fost apoi înregistrat în jurnal după ce s-a constatat că stiva de apeluri era goală.
+
+Cu cuvântul cheie `await` în `secondFunction`, efectiv pauzăm execuția unei funcții asincrone până când valoarea a fost rezolvată înainte de a trece la următoarea linie.
+
+Acest lucru înseamnă că a așteptat ca `myPromise` să fie rezolvat cu valoarea `I have resolved`, și doar după ce s-a întâmplat acest lucru, s-a trecut la următoarea linie: a fost înregistrat `second`.
+
+</p>
+</details>
+
+---
+
+###### 103. Care este valoarea ieșirii?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+Operatorul `+` nu este folosit doar pentru adunarea valorilor numerice, ci îl putem utiliza și pentru concatenarea șirurilor de caractere. Ori de câte ori motorul JavaScript observă că una sau mai multe valori nu sunt de tip număr, va converti numărul într-un șir de caractere.
+
+Primul operand este `1`, care este o valoare numerică. `1 + 2` returnează numărul 3.
+
+Cu toate acestea, al doilea operand este un șir de caractere `"Lydia"`. `"Lydia"` este un șir de caractere și `2` este un număr: `2` este convertit într-un șir de caractere. `"Lydia"` și `"2"` sunt concatenate, rezultând șirul de caractere `"Lydia2"`.
+
+`{ name: "Lydia" }` este un obiect. Niciun număr, niciun obiect nu este un șir de caractere, astfel că sunt convertite în șiruri. Ori de câte ori convertim un obiect regulat în șir de caractere, devine `"[object Object]"`. `"[object Object]"` concatenat cu `"2"` devine `"[object Object]2"`.
+
+</p>
+</details>
+
+---
+
+###### 104. Care este rezultatul?
+
+```javascript
+Promise.resolve(5);
+```
+
+- A: `5`
+- B: `Promise {<pending>: 5}`
+- C: `Promise {<fulfilled>: 5}`
+- D: `Error`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+Putem pasa orice tip de valoare dorim către `Promise.resolve`, fie o promisiune, fie o valoare non-promisiune. Metoda în sine returnează o promisiune cu valoarea rezolvată (`<fulfilled>`). Dacă pasați o funcție regulată, va fi o promisiune rezolvată cu o valoare regulată. Dacă pasați o promisiune, va fi o promisiune rezolvată cu valoarea rezolvată a promisiunii respective pasate.
+
+În acest caz, am pasat doar valoarea numerică `5`. Aceasta returnează o promisiune rezolvată cu valoarea `5`.
+
+</p>
+</details>
+
+---
+
+###### 105. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: B
+
+Obiectele sunt pasate prin referință. Atunci când verificăm obiecte pentru egalitate strictă (`===`), comparăm referințele lor.
+
+Am setat valoarea implicită pentru `person2` egală cu obiectul `person` și am pasat obiectul `person` ca valoare pentru `person1`.
+
+Acest lucru înseamnă că ambele valori au o referință către aceeași locație în memorie, astfel că sunt egale.
+
+Blocul de cod din instrucțiunea `else` se execută, și este înregistrat mesajul`They are the same!`.
+
+</p>
+</details>
+
+---
+
+###### 106. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: D
+
+În JavaScript, avem două moduri de a accesa proprietăți pe un obiect: notare cu paranteze pătrate sau notare cu punct. În acest exemplu, folosim notarea cu punct (`colorConfig.colors`) în loc de notarea cu paranteze pătrate  (`colorConfig["colors"]`).
+
+Cu notarea cu punct, JavaScript încearcă să găsească proprietatea pe obiect cu exact același nume. În acest exemplu, JavaScript încearcă să găsească o proprietate numită `colors` pe obiectul `colorConfig`. Nu există o proprietate numită `colors`, așa că acest lucru returnează `undefined`. Apoi, încercăm să accesăm valoarea primului element folosind `[1]`. Nu putem face acest lucru pe o valoare care este `undefined`, astfel că se generează o eroare de tip `TypeError`: `Cannot read property '1' of undefined`.
+
+JavaScript interpretează (sau deschide) declarațiile. Atunci când folosim notația cu paranteze pătrate, vede prima paranteză deschisă `[` și continuă până găsește paranteza de închidere `]`. Abia atunci va evalua declarația. Dacă am fi folosit `colorConfig[colors[1]]`, ar fi returnat valoarea proprietății `red` pe obiectul `colorConfig`.
+
+</p>
+</details>
+
+---
+
+###### 107. Care este rezultatul?
+
+```javascript
+console.log('❤️' === '❤️');
+```
+
+- A: `true`
+- B: `false`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: A
+
+În culise, emoji-urile sunt reprezentate ca coduri Unicode. Codurile Unicode pentru emoji-ul inimii sunt `"U+2764 U+FE0F"`. Acestea sunt întotdeauna aceleași pentru aceleași emoji-uri, așa că comparăm două șiruri identice între ele, ceea ce returnează
+
+</p>
+</details>
+
+---
+
+###### 108. Care dintre aceste metode modifică array-ul original?
+
+```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: `Toate`
+- B: `map` `reduce` `slice` `splice`
+- C: `map` `slice` `splice`
+- D: `splice`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: D
+
+Cu metoda `splice` mmodificăm array-ul original prin ștergerea, înlocuirea sau adăugarea de elemente. În acest caz, am eliminat 2 elemente de la indexul 1 (am eliminat `'🥑'` și `'😍'`) și am adăugat emoji-ul ✨ în locul lor.
+
+`map`, `filter` și `slice` returnează un nou array, `find` returnează un element, ia `reduce` returnează o valoare redusă.
+
+</p>
+</details>
+
+---
+
+###### 109. Care este rezultatul?
+
+```javascript
+const food = ['🍕', '🍫', '🥑', '🍔'];
+const info = { favoriteFood: food[0] };
+
+info.favoriteFood = '🍝';
+
+console.log(food);
+```
+
+- A: `['🍕', '🍫', '🥑', '🍔']`
+- B: `['🍝', '🍫', '🥑', '🍔']`
+- C: `['🍝', '🍕', '🍫', '🥑', '🍔']`
+- D: `ReferenceError`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: A
+
+Am setat valoarea proprietății `favoriteFood` pe obiectul `info` egal cu șirul de caractere cu emoji-ul de pizza, `'🍕'`. Un șir de caractere este un tip de date primitiv. În JavaScript, tipurile de date primitive nu interacționează prin referință.
+
+În JavaScript, tipurile de date primitive (tot ceea ce nu este obiect) interacționează prin _valoare_. În acest caz, am setat valoarea proprietății `favoriteFood` pe obiectul `info` egală cu valoarea primului element din array-ul `food` care este un șir de caractere cu emoji-ul de pizza în acest caz (`'🍕'`). Un șir de caractere este un tip de date primitiv și interacționează prin valoare (vedeți [blogpost](https://www.theavocoder.com/complete-javascript/2018/12/21/by-value-vs-by-reference) meu dacă doriți să aflați mai multe).
+
+Apoi, schimbăm valoarea proprietății `favoriteFood` pe obiectul `info`. Array-ul `food` nu s-a schimbat, deoarece valoarea `favoriteFood` era doar o _copie_ a valorii primului element din array și nu are o referință la aceeași locație în memorie ca elementul din `food[0]`. Când înregistrăm array-ul `food`, acesta rămâne neschimbat, `['🍕', '🍫', '🥑', '🍔']`.
+
+</p>
+</details>
+
+---
+
+###### 110. Ce face această metodă?
+
+```javascript
+JSON.parse();
+```
+
+- A: Parcurge JSON-ul pentru a obține o valoare JavaScript
+- B: Parcurge un obiect JavaScript pentru a obține un JSON
+- C: Parcurge orice valoare JavaScript într-un JSON
+- D: Parcurge doar JSON-ul într-un obiect JavaScript
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: A
+
+Cu metoda `JSON.parse()` putem parsa un șir JSON într-o valoare JavaScript.
+
+```javascript
+// Transformarea unui număr într-un JSON valid, apoi parsarea șirului JSON într-o valoare JavaScript:
+const jsonNumber = JSON.stringify(4); // '4'
+JSON.parse(jsonNumber); // 4
+
+// Transformarea unei valori de tip array într-un JSON valid, apoi parsarea șirului JSON într-o valoare JavaScript:
+const jsonArray = JSON.stringify([1, 2, 3]); // '[1, 2, 3]'
+JSON.parse(jsonArray); // [1, 2, 3]
+
+// Transformarea unui obiect într-un JSON valid, apoi parsarea șirului JSON într-o valoare JavaScript:
+const jsonArray = JSON.stringify({ name: 'Lydia' }); // '{"name":"Lydia"}'
+JSON.parse(jsonArray); // { name: 'Lydia' }
+```
+
+</p>
+</details>
+
+---
+
+###### 111. Care este rezultatul?
+
+```javascript
+let name = 'Lydia';
+
+function getName() {
+  console.log(name);
+  let name = 'Sarah';
+}
+
+getName();
+```
+
+- A: Lydia
+- B: Sarah
+- C: `undefined`
+- D: `ReferenceError`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: D
+
+Fiecare funcție are propriul său _context de execuție_ (sau _domeniu_). Funcția `getName` caută mai întâi în propriul său context (domeniu) pentru a vedea dacă conține variabila `name` pe care încercăm să o accesăm. În acest caz, funcția `getName` conține propria sa variabilă `name` declarăm variabila `name` cu cuvântul cheie `let`, și cu valoarea `'Sarah'`.
+
+Variabilele declarate cu cuvântul cheie `let` (și `const`) sunt hoisted, dar, spre deosebire de `var`, nu sunt <i>inițializate</i>. Ele nu sunt accesibile înainte de linia în care le declarăm (inițializăm). Acest lucru se numește "zona temporală moartă" (temporal dead zone). Atunci când încercăm să accesăm variabilele înainte de a fi declarate, JavaScript aruncă o eroare de tip `ReferenceError`.
+
+Dacă nu am fi declarat variabila `name` în interiorul funcției `getName` motorul JavaScript ar fi căutat în josul lanțului de _domenii_. Domeniul exterior are o variabilă numită `name` cu valoarea `Lydia`. În acest caz, ar fi afișat `Lydia`.
+
+```javascript
+let name = 'Lydia';
+
+function getName() {
+  console.log(name);
+}
+
+getName(); // Lydia
+```
+
+</p>
+</details>
+
+---
+
+###### 112. Care este rezultatul?
+
+```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` și `a`
+- B: `a` și `undefined`
+- C: `['a', 'b', 'c']` și `a`
+- D: `a` și `['a', 'b', 'c']`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+Cu cuvântul cheie `yield`, cedăm valorile într-o funcție generator. Cu cuvântul cheie `yield*`, putem ceda valori dintr-o altă funcție generator sau dintr-un obiect iterabil (de exemplu, un array).
+
+În `generatorOne`, folosim cuvântul cheie `yield` pentru a ceda intrega mulțime `['a', 'b', 'c']`. Valoarea proprietății `value` a obiectului returnat de metoda `next` pe obiectul `one` (`one.next().value`) este egală cu întregul array `['a', 'b', 'c']`.
+
+```javascript
+console.log(one.next().value); // ['a', 'b', 'c']
+console.log(one.next().value); // undefined
+```
+
+În `generatorTwo`, folosim cuvântul cheie `yield*`. Acest lucru înseamnă că prima valoare cedată din `two`, este egală cu prima valoare cedată din iterator. Iteratorul este mulțimea `['a', 'b', 'c']`. Prima valoare cedată este `a`, așa că prima dată când apelăm `two.next().value`, este returnată valoarea  `a`.
+
+```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. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: A
+
+Expresiile din șirurile șablon (template literals) sunt evaluate mai întâi. Acest lucru înseamnă că șirul va conține valoarea returnată de expresie, funcția imediat invocată `(x => x)('I love')` în acest caz. Trecem valoarea `'I love'` ca argument către funcția arrow `x => x`. `x` este egal cu `'I love'`, care este returnată. Aceasta duce la rezultatul `I love to program`.
+
+</p>
+</details>
+
+---
+
+###### 114. Ce se va întâmpla?
+
+```javascript
+let config = {
+  alert: setInterval(() => {
+    console.log('Alert!');
+  }, 1000),
+};
+
+config = null;
+```
+
+- A: Funcția de callback a `setInterval` nu va fi invocată
+- B: Funcția de callback a `setInterval` este invocată o singură dată
+- C: Funcția de callback a `setInterval` va fi totuși apelată în fiecare secundă
+- D: Nu am apelat niciodată `config.alert()`, config este `null`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+În mod normal, atunci când setăm obiecte egal cu `null`, acele obiecte sunt _colectate de gunoi_ (garbage collected), deoarece nu mai există nicio referință către acel obiect. Cu toate acestea, deoarece funcția de callback din `setInterval` este o funcție arrow (și, prin urmare, legată de obiectul `config`), funcția de callback încă menține o referință la obiectul  `config`. 
+Atâta timp cât există o referință, obiectul nu va fi colectat de gunoi (garbage collected). 
+Deoarece aceasta este o intervală de timp, setarea lui `config` la `null` sau `delete` lui `config.alert` nu va colecta intervalul de gunoi și intervalul va continua să fie apelat.
+Pentru a-l opri și a-l elimina din memorie, trebuie să folosiți `clearInterval(config.alert)`.
+Deoarece acest lucru nu a fost făcut, funcția de callback a `setInterval` va fi în continuare invocată la fiecare 1000 ms (1 secundă).
+
+</p>
+</details>
+
+---
+
+###### 115. Ce metodă(e) va returna valoarea `'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 și 3
+- D: Toate
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: B
+
+Când adăugăm o pereche cheie/valoare folosind metoda `set`, cheia va fi valoarea primului argument transmis funcției `set`, iar valoarea va fi cea de-a doua valoare transmisă funcție `set`. Cheia în acest caz este _funcția_ `() => 'greeting'`, iar valoarea `'Hello world'`. `myMap` este acum `{ () => 'greeting' => 'Hello world!' }`.
+
+1 este incorect pentru că cheia nu este `'greeting'` ci `() => 'greeting'`.
+3 este incorect pentru că creăm o nouă funcție prin transmiterea ei ca parametru către metoda `get`. Obiectele interacționează prin _referință_. Funcțiile sunt obiecte, motiv pentru care două funcții nu sunt niciodată strict egale, chiar dacă sunt identice: ele au o referință către un loc diferit în memorie.
+
+</p>
+</details>
+
+---
+
+###### 116. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+Ambele funcții `changeAge` și `changeAgeAndName` au un parametru implicit, și anume un obiect _nou_ creat `{ ...person }`. Acest obiect conține copii ale tuturor cheilor/valorilor din obiectul `person`.
+
+În primul rând, apelăm funcția `changeAge` și transmitem obiectul `person` ca argument. Această funcție crește valoarea proprietății `age` cu 1. `person` devine `{ name: "Lydia", age: 22 }`.
+
+Apoi, apelăm funcția `changeAgeAndName`, însă nu transmitem un parametru. În schimb, valoarea lui `x` este egală cu un obiect _nou_: `{ ...person }`. Deoarece este un obiect nou, acesta nu afectează valorile proprietăților din obiectul `person`. `person` rămâne egal cu `{ name: "Lydia", age: 22 }`.
+
+</p>
+</details>
+
+---
+
+###### 117. Care dintre opțiunile următoare va returna `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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+Cu operatorul spread `...`, putem _răspândi_ obiecte iterabile în elemente individuale. Funcția `sumValues` primește trei argumente: `x`, `y` și `z`. `...[1, 2, 3]` va rezulta în `1, 2, 3`, pe care le transmitem funcției `sumValues`.
+
+</p>
+</details>
+
+---
+
+###### 118. Care este rezultatul?
+
+```javascript
+let num = 1;
+const list = ['🥳', '🤠', '🥰', '🤪'];
+
+console.log(list[(num += 1)]);
+```
+
+- A: `🤠`
+- B: `🥰`
+- C: `SyntaxError`
+- D: `ReferenceError`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: B
+
+Cu operandul `+=` incrementăm valoarea lui `num` cu `1`. Inițial, `num` avea valoarea `1`, deci `1 + 1` este `2`. Elementul de pe al doilea index în mulțimea `list` este 🥰, `console.log(list[2])` va afișa 🥰.
+
+</p>
+</details>
+
+---
+
+###### 119. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: B
+
+Cu operatorul de verificare opțională `?.`, nu mai este necesar să verificăm explicit dacă valorile mai profunde încorporate sunt valide sau nu. Dacă încercăm să accesăm o proprietate pe o valoare `undefined` sau `null` valoarea (_nullish_), expresia face un scurtcircuit și returnează `undefined`.
+
+`person.pet?.name`: `person` are o proprietate numită `pet`: `person.pet` nu este `nullish`. Are o proprietate numită `name`, și returnează `Mara`.
+`person.pet?.family?.name`: `person` are o proprietate numită `pet`: `person.pet` nu este `nullish`. `pet` _nu_ are o proprietate numită `family`, `person.pet.family` este `nullish`. Expresia returnează `undefined`.
+`person.getFullName?.()`: `person` are o proprietate `getFullName`: `person.getFullName()` nu este `nullish` și poate fi invocată, care returnează `Lydia Hallie`.
+`member.getLastName?.()`: variabila `member` nu există, prin urmare se va genera o excepție de tip `ReferenceError` gets thrown!
+
+</p>
+</details>
+
+---
+
+###### 120. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: B
+
+Am trecut condiția `groceries.indexOf("banana")` în instrucțiunea `if`. `groceries.indexOf("banana")` returnează `0`, care este o valoare falsă. Deoarece condiția din instrucțiunea `if` este falsă, se execută codul din blocul `else`, și `We don't have to buy bananas!` se afișează.
+
+</p>
+</details>
+
+---
+
+###### 121. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: D
+
+Metoda `language` este un `setter`. Setter-urile nu rețin o valoare reală; scopul lor este să _modifice_ proprietăți. Atunci când apelați o metodă `setter`, aceasta va returna `undefined`.
+
+</p>
+</details>
+
+---
+
+###### 122. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+`typeof name` returnează `"string"`. Șirul de caractere `"string"` este o valoare adevărată (truthy), așa că `!typeof name` returnează valoarea booleană `false`. `false === "object"` și `false === "string"` ambele returnează `false`.
+
+(Dacă dorim să verificăm dacă tipul este (ne)egal cu un anumit tip, ar trebui să folosim `!==` în loc de `!typeof`)
+
+</p>
+</details>
+
+---
+
+###### 123. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: A
+
+Funcția `add` returnează o funcție arrow, care returnează o altă funcție arrow, care la rândul ei returnează o altă funcție arrow (încă sunteți cu mine?). Prima funcție primește un argument `x` cu valoarea `4`. Apelăm a doua funcție, care primește un argument `y` cu valoarea `5`. Apoi apelăm a treia funcție, care primește un argument `z` cu valoarea `6`. Când încercăm să accesăm valorile `x`, `y` și `z` în ultima funcție arrow, motorul JavaScript urcă lanțul de domenii pentru a găsi valorile pentru `x` și `y` în consecință. Aceasta returnează `4` `5` `6`.
+
+</p>
+</details>
+
+---
+
+###### 124. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+Funcția generator `range` returnează un obiect asincron cu promisiuni pentru fiecare element din intervalul pe care îl transmitem: `Promise{1}`, `Promise{2}`, `Promise{3}`. Setăm variabila `gen` egală cu obiectul asincron, după care facem o buclă peste el folosind o buclă `for await ... of`. Setăm variabila `item` eegală cu valorile promisiunilor returnate: mai întâi `Promise{1}`, apoi `Promise{2}`, apoi `Promise{3}`. Deoarece _așteptăm_ valoarea lui `item`, adică promisiunea rezolvată, _valorile_ rezolvate ale promisiunilor sunt returnate: `1`, `2`, apoi `3`.
+
+</p>
+</details>
+
+---
+
+###### 125. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: D
+
+`myFunc` așteaptă ca argument un obiect cu proprietățile `x`, `y` și `z`. Deoarece transmitem doar trei valori numerice separate (1, 2, 3) în loc de un obiect cu proprietățile `x`, `y` și `z` ({x: 1, y: 2, z: 3}), `x`, `y` și `z` primesc valoarea lor implicită, care este `undefined`.
+
+</p>
+</details>
+
+---
+
+###### 126. Care este rezultatul?
+
+```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 `Șoferul a condus ${formattedSpeed} și trebuie să plătească ${formattedAmount}`;
+}
+
+console.log(getFine(130, 300))
+```
+
+- A: Șoferul a condus 130 și trebuie să plătească 300
+- B: Șoferul a condus 130 mph și trebuie să plătească \$300.00
+- C: Șoferul a condus undefined și trebuie să plătească undefined
+- D: Șoferul a condus 130.00 și trebuie să plătească 300.00
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: B
+
+Cu metoda `Intl.NumberFormat` putem formata valorile numerice în orice locație. Formatez valoarea numerică `130` pentru locația `en-US` ca o `unitate` în `mile-per-hour`, ceea ce rezultă în `130 mph`. Valoarea numerică `300` pentru locația `en-US` ca `monedă` în `USD` rezultă în `$300.00`.
+
+</p>
+</details>
+
+---
+
+###### 127. Care este rezultatul?
+
+```javascript
+const spookyItems = ['👻', '🎃', '🕸'];
+({ item: spookyItems[3] } = { item: '💀' });
+
+console.log(spookyItems);
+```
+
+- A: `["👻", "🎃", "🕸"]`
+- B: `["👻", "🎃", "🕸", "💀"]`
+- C: `["👻", "🎃", "🕸", { item: "💀" }]`
+- D: `["👻", "🎃", "🕸", "[object Object]"]`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: B
+
+Prin destrucțurarea obiectelor, putem extrage valorile din obiectul din partea dreaptă și le atribui valorii cu același nume de proprietate din obiectul din partea stângă. În acest caz, atribuim valoarea "💀" lui `spookyItems[3]`. Acest lucru înseamnă că modificăm array-ul `spookyItems`, adăugăm "💀" la el. La afișarea în consolă a lui `spookyItems`, se va afișa `["👻", "🎃", "🕸", "💀"]`.
+
+</p>
+</details>
+
+---
+
+###### 128. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+Cu metoda `Number.isNaN` puteți verifica dacă valoarea pe care o transmiteți este o _valoare numerică_ și este egală cu `NaN`. `name` nu este o valoare numerică, așa că `Number.isNaN(name)` returnează `false`. `age` este o valoare numerică, dar nu este egală cu `NaN`, astfel că `Number.isNaN(age)` returnează `false`.
+
+Cu metoda `isNaN` puteți verifica dacă valoarea pe care o transmiteți nu este un număr. `name` nu este un număr, așa că `isNaN(name)` returnează `true`. `age` este un număr, astfel că `isNaN(age)` returnează `false`.
+
+</p>
+</details>
+
+---
+
+###### 129. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: D
+
+Variabilele declarate cu cuvântul cheie `const` nu pot fi referite înainte de inițializare: acest lucru se numește _zona temporală moartă_ (temporal dead zone). În funcția `getInfo`, variabila`randomValue` este de domeniu în domeniul funcțional al funcției `getInfo`. Pe linia în care dorim să afișăm valoarea `typeof randomValue`, variabila `randomValue` nu este încă inițializată: se va genera o eroare de tip `ReferenceError`! Motorul nu a căutat în josul lanțului de domenii deoarece am declarat variabila `randomValue` în funcția `getInfo`.
+
+</p>
+</details>
+
+---
+
+###### 130. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+În blocul `try`  înregistrăm valoarea așteptată a variabilei `myPromise`: `"Woah some cool data"`. Deoarece nu s-au generat erori în blocul `try` codul din blocul `catch` nu se execută. Codul din blocul `finally` se execută _întotdeauna_, și se va afișa `"Oh finally!"`.
+
+</p>
+</details>
+
+---
+
+###### 131. Care este rezultatul?
+
+```javascript
+const emojis = ['🥑', ['✨', '✨', ['🍕', '🍕']]];
+
+console.log(emojis.flat(1));
+```
+
+- A: `['🥑', ['✨', '✨', ['🍕', '🍕']]]`
+- B: `['🥑', '✨', '✨', ['🍕', '🍕']]`
+- C: `['🥑', ['✨', '✨', '🍕', '🍕']]`
+- D: `['🥑', '✨', '✨', '🍕', '🍕']`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: B
+
+Cu metoda `flat` putem crea un nou array aplatizat. Adâncimea array-ului aplatizat depinde de valoarea pe care o transmitem. În acest caz, am transmis valoarea `1` (care nu era necesară, deoarece aceasta este valoarea implicită), ceea ce înseamnă că vor fi concatenate doar array-urile de pe primul nivel de adâncime. `['🥑']` și `['✨', '✨', ['🍕', '🍕']]`. Concatenarea acestor două array-uri rezultă în `['🥑', '✨', '✨', ['🍕', '🍕']]`.
+
+</p>
+</details>
+
+---
+
+###### 132. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: D
+
+`counterOne` este o instanță a clasei `Counter`. Clasa `Counter` conține o proprietate `count` în constructorul său și o metodă `increment`. Mai întâi, am invocat metoda `increment` de două ori, apelând `counterOne.increment()`. În prezent, `counterOne.count` este `2`.
+
+<img src="https://i.imgur.com/KxLlTm9.png" width="400">
+
+Apoi, creăm o nouă variabilă `counterTwo`, și o setăm egală cu `counterOne`. Deoarece obiectele interacționează prin referință, creăm doar o nouă referință către același loc în memorie la care indică `counterOne`. Deoarece au același loc în memorie, orice modificări făcute asupra obiectului la care `counterTwo` are o referință se aplică și la `counterOne`. În prezen, `counterTwo.count` este `2`.
+
+Apelăm `counterTwo.increment()`, ceea ce setează `count` la `3`. Apoi, afișăm valoarea lui `counterOne`, ceea ce va afișa `3`.
+
+<img src="https://i.imgur.com/BNBHXmc.png" width="400">
+
+</p>
+</details>
+
+---
+
+###### 133. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+În primul rând, apelăm `funcOne`. Pe prima linie a lui `funcOne`, apelăm funcția _asincronă_ `setTimeout`, din care funcția de apel se trimite către API-ul Web. (vezi articolul meu despre bucla evenimentelor <a href="https://dev.to/lydiahallie/javascript-visualized-event-loop-3dif">aici</a>.)
+
+Apoi apelăm promisiunea `myPromise` care este o operațiune _asincronă_.
+
+Ambele promisiuni și întârzierile (timeout) sunt operațiuni asincrone, iar funcția continuă să ruleze în timp ce finalizează promisiunea și gestionează apelul de întârziere `setTimeout`. Acest lucru înseamnă că se va afișa mai întâi `Last line 1!`, deoarece aceasta nu este o operațiune asincronă. 
+
+Deoarece stiva de apel nu este încă goală, funcția `setTimeout` și promisiunea din `funcOne` nu pot fi adăugate încă la stiva de apel.
+
+În `funcTwo`, variabila `res` primește o `Promise` pentru că `Promise.resolve(Promise.resolve('Promise'))` este echivalent cu `Promise.resolve('Promise')` deoarece rezolvarea unei promisiuni rezolvă doar valoarea acesteia. Cuvântul cheie `await` din această linie oprește execuția funcției până când primește rezoluția promisiunii și apoi continuă să ruleze sincron până la finalizare, așa că sunt afișate `Promise 2!` apoi `Last line 2!` iar apelul `setTimeout` este trimis către API-ul Web.
+
+Apoi stiva de apel este goală. Promisiunile sunt _microtask-uri_ astfel că sunt rezolvate în primul rând atunci când stiva de apel este goală, așa că se afișează `Promise 1!`.
+
+Acum, deoarece `funcTwo` pa fost scoasă din stiva de apel, stiva de apel este goală. Callback-urile așteptând în coadă (`() => console.log("Timeout 1!")` din `funcOne`, și `() => console.log("Timeout 2!")` din `funcTwo`) sunt adăugate pe stivă unul câte unul. Primul callback afișează `Timeout 1!`, și este eliminat din stivă. Apoi, al doilea callback afișează `Timeout 2!`, și este eliminat din stivă.
+
+</p>
+</details>
+
+---
+
+###### 134. Cum putem apela funcția `sum` în `sum.js` din `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: Exporturile implicite nu sunt importate cu `*`, doar exporturile numite
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+Cu asteriscul `*`, importăm toate valorile exportate din acel fișier, atât exporturile implicite, cât și cele numite. Dacă avem următorul fișierȘ
+
+```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);
+```
+
+Acesta ar fi rezultatul înregistrărilor:
+
+```javascript
+{
+  default: "I love JavaScript",
+  name: "Lydia",
+  age: 21
+}
+```
+
+Pentru exemplul cu funcția `sum`, înseamnă că valoarea importată `sum` arată în felul următor:
+
+```javascript
+{ default: function sum(x) { return x + x } }
+```
+
+Putem invoca această funcție, apelând `sum.default`
+
+</p>
+</details>
+
+---
+
+###### 135. Care este rezultatul?
+
+```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: Nu se înregistrează nimic
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+Cu un obiect Proxy, putem adăuga comportament personalizat unui obiect pe care îl transmitem ca al doilea argument. În acest caz, transmitem obiectul `handler` care conține două proprietăți: `set` și `get`. `set` este invocată ori de câte ori _set_ (setăm) valori de proprietate, `get` este invocată ori de câte ori _get_ (accesăm) valori de proprietate.
+
+Primul argument este un obiect gol `{}`, care este valoarea lui `person`. La acest obiect, se adaugă comportamentul personalizat specificat în obiectul `handler`. Dacă adăugăm o proprietate la obiectul `person`, `set` va fi invocată. Dacă accesăm o proprietate a obiectului `person`, `get` va fi invocată.
+
+În primul rând, am adăugat o nouă proprietate `name` la obiectul proxy (`person.name = "Lydia"`). `set` este invocată și înregistrează mesajul `"Added a new property!"`.
+
+Then, we access a property value on the proxy object, the `get` property on the handler object got invoked. `"Accessed a property!"` gets logged.
+
+</p>
+</details>
+
+---
+
+###### 136. Care dintre următoarele va modifica obiectul `person`?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: A
+
+Cu `Object.seal` putem preveni _adăugarea_ de noi proprietăți sau _eliminarea_ proprietăților existente.
+
+Cu toate acestea, puteți încă să modificați valoarea proprietăților existente.
+
+</p>
+</details>
+
+---
+
+###### 137. Care dintre următoarele va modifica obiectul `person`?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+Metoda `Object.freeze` _îngheață_ un obiect. Nu se pot adăuga, modifica sau elimina proprietăți.
+
+Cu toate acestea, aceasta îngheață obiectul doar în mod _superficial_, ceea ce înseamnă că numai proprietățile _directe_ ale obiectului sunt înghețate. Dacă proprietatea este un alt obiect, cum ar fi `address` în acest caz, proprietățile de pe acel obiect nu sunt înghețate și pot fi modificate.
+
+</p>
+</details>
+
+---
+
+###### 138. Care este rezultatul?
+
+```javascript
+const add = x => x + x;
+
+function myFunc(num = 2, value = add(num)) {
+  console.log(num, value);
+}
+
+myFunc();
+myFunc(3);
+```
+
+- A: `2` `4` și `3` `6`
+- B: `2` `NaN` și `3` `NaN`
+- C: `2` `Error` și `3` `6`
+- D: `2` `4` și `3` `Error`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: A
+
+În primul rând, am apelat `myFunc()` fără a transmite niciun argument. Deoarece nu am transmis argumente, `num` și `value` au primit valorile lor implicite: `num` este `2`, și `value` este valoarea returnată de funcția `add`. Funcției `add` îi transmitem `num` ca argument, care avea valoarea `2`. `add` returnează `4`, care este valoarea lui `value`.
+
+Apoi, am apelat `myFunc(3)` și am transmis valoarea `3` ca valoare pentru argumentul `num`. Nu am transmis un argument pentru `value`. Deoarece nu am transmis o valoare pentru argumentul `value` acesta a primit valoarea implicită: valoarea returnată de funcția `add`. Funcției `add`, îi transmitem `num`, care are valoarea `3`. `add` returnează `6`, care este valoarea lui `value`.
+
+</p>
+</details>
+
+---
+
+###### 139. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: D
+
+În ES2020, putem adăuga variabile private în clase folosind simbolul `#`. Nu putem accesa aceste variabile în afara clasei. Atunci când încercăm să înregistrăm `counter.#number`, se aruncă o eroare de sintaxă (SyntaxError): nu putem accesa această variabilă în afara clasei `Counter`!
+
+</p>
+</details>
+
+---
+
+###### 140. Ce lipsește?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: B
+
+Pentru a itera prin `membrii` din fiecare element din array-ul `members` trebuie să transmitem `teams[i].members` către funcția generator `getMembers`. Funcția generator returnează un obiect generator. Pentru a itera prin fiecare element din acest obiect generator, trebuie să folosim `yield*`.
+
+Dacă am fi scris `yield`, `return yield`, sau `return`, întreaga funcție generator ar fi fost returnată prima dată când am apelat metoda `next`.
+
+</p>
+</details>
+
+---
+
+###### 141. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+Funcția `addHobby` primește două argumente, `hobby` și `hobbies` cu valoarea implicită a array-ului `hobbies` din obiectul `person`.
+
+În primul rând, apelăm funcția `addHobby`, și transmitem `"running"` ca valoare pentru `hobby` și un array gol ca valoare pentru `hobbies`. Deoarece transmitem un array gol ca valoare pentru `hobbies`, `"running"` este adăugat la acest array gol.
+
+Apoi, apelăm funcția `addHobby` și transmitem `"dancing"` ca valoare pentru `hobby`. Nu am transmis o valoare pentru `hobbies`, astfel că aceasta primește valoarea implicită, adică proprietatea `hobbies` din obiectul `person`. Adăugăm hobby-ul `dancing` în array-ul `person.hobbies`.
+
+În final, apelăm funcția `addHobby`, și transmitem `"baking"` ca valoare pentru `hobby`, și array-ul `person.hobbies` ca valoare pentru `hobbies`. Adăugăm hobby-ul `baking` în array-ul `person.hobbies`.
+
+După adăugarea lui `dancing` și `baking`, valoarea lui `person.hobbies` este `["coding", "dancing", "baking"]`
+
+</p>
+</details>
+
+---
+
+###### 142. Care este rezultatul?
+
+```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: Nimic, nu am apelat la nicio metodă
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: B
+
+Creăm variabila `pet` care este o instanță a clasei `Flamingo`. Când instantiem această instanță, `constructor` din clasa `Flamingo` este apelat. Mai întâi, se înregistrează `"I'm pink. 🌸"` după care apelăm `super()`. `super()` apelează constructorul clasei părinte, `Bird`. Constructorul din clasa `Bird` este apelat și înregistrează `"I'm a bird. 🦢"`.
+
+</p>
+</details>
+
+---
+
+###### 143. Care dintre opțiuni rezultă într-o eroare?
+
+```javascript
+const emojis = ['🎄', '🎅🏼', '🎁', '⭐'];
+
+/* 1 */ emojis.push('🦌');
+/* 2 */ emojis.splice(0, 2);
+/* 3 */ emojis = [...emojis, '🥂'];
+/* 4 */ emojis.length = 0;
+```
+
+- A: 1
+- B: 1 și 2
+- C: 3 și 4
+- D: 3
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: D
+
+Cuvântul cheie `const` înseamnă pur și simplu că nu putem _redeclara_ valoarea acelei variabile, aceasta este _numai pentru citire_ (read-only). Cu toate acestea, valoarea în sine nu este imutabilă. Proprietățile din array-ul `emojis` pot fi modificate, de exemplu, prin adăugarea de valori noi, prin decuparea lor sau prin setarea lungimii array-ului la 0.
+
+</p>
+</details>
+
+---
+
+###### 144. Ce trebuie să adăugăm la obiectul `person` pentru a obține `["Lydia Hallie", 21]` ca rezultat al `[...person]`?
+
+```javascript
+const person = {
+  name: "Lydia Hallie",
+  age: 21
+}
+
+[...person] // ["Lydia Hallie", 21]
+```
+
+- A: Nimic, obiectele sunt iterabile în mod implicit
+- 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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+Obiectele nu sunt iterabile în mod implicit. Un obiect devine iterabil atunci când protocolul iterator este prezent. Putem adăuga acest protocol manual prin adăugarea simbolului iterator `[Symbol.iterator]`, care trebuie să returneze un obiect generator, de exemplu, prin definirea unei funcții generator `*[Symbol.iterator]() {}`. Această funcție generator trebuie să furnizeze `Object.values` ale obiectulu `person` pentru a obține array-ul `["Lydia Hallie", 21]`: `yield* Object.values(this)`.
+
+</p>
+</details>
+
+---
+
+###### 145. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+Condiția `if` din interiorul buclei `forEach` verifică dacă valoarea lui `num` este adevărată (truthy) sau falsă (falsy). Deoarece primul număr din array-ul `nums` este `0`, o valoare falsă, blocul de cod al instrucțiunii `if` nu va fi executat. `count` se incrementează doar pentru celelalte 3 numere din array-ul `nums`, adică `1`, `2` și `3`. Deoarece `count` se incrementează cu `1` de 3 ori, valoarea lui `count` este `3`.
+
+</p>
+</details>
+
+---
+
+###### 146. Care este rezultatul?
+
+```javascript
+function getFruit(fruits) {
+	console.log(fruits?.[1]?.[1])
+}
+
+getFruit([['🍊', '🍌'], ['🍍']])
+getFruit()
+getFruit([['🍍'], ['🍊', '🍌']])
+```
+
+- A: `null`, `undefined`, 🍌
+- B: `[]`, `null`, 🍌
+- C: `[]`, `[]`, 🍌
+- D: `undefined`, `undefined`, 🍌
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: D
+
+Simbolul `?` ne permite să accesăm opțional proprietăți mai adânc în obiecte. Încercăm să înregistrăm elementul de pe indexul `1` din sub-array-ul de pe indexul `1` al array-ului `fruits`. Dacă sub-array-ul de pe indexul `1` din array-ul `fruits` nu există, va returna pur și simplu `undefined`. Dacă sub-array-ul de pe indexul `1` din array-ul `fruits` există, dar acest sub-array nu are un element pe indexul `1` va returna, de asemenea, `undefined`. 
+
+În primul rând, încercăm să înregistrăm al doilea element din sub-array-ul`['🍍']` din `[['🍊', '🍌'], ['🍍']]`. Acest sub-array conține doar un singur element, ceea ce înseamnă că nu există niciun element pe indexul `1`, și va returna `undefined`.
+
+Apoi, apelăm funcția `getFruits` fără a transmite o valoare ca argument, ceea ce înseamnă că `fruits` are implicit o valoare de `undefined`. Deoarece facem o verificare condițională pentru accesarea elementului de pe indexul `1` al `fruits`, aceasta va returna `undefined` deoarece acest element de pe indexu `1` nu există. 
+
+În cele din urmă, încercăm să înregistrăm al doilea element din sub-array-ul `['🍊', '🍌']` din `['🍍'], ['🍊', '🍌']`. Elementul de pe indexul `1` în acest sub-array este `🍌`, are este înregistrat.
+
+</p>
+</details>
+
+---
+
+###### 147. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: A
+
+Am setat variabila `calc` gal cu o nouă instanță a clasei `Calc`. Apoi, am creat o altă instanță nouă a clasei `Calc`, și am apelat metoda `increase` pe această instanță. Deoarece proprietatea `count` se află în constructorul clasei `Calc`, proprietatea `count` nu este partajată în prototipul clasei `Calc`. Acest lucru înseamnă că valoarea lui `count` nu a fost actualizată pentru instanța către care arată `calc` astfel încât `count` rămâne `0`.
+
+</p>
+</details>
+
+---
+
+###### 148. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: B
+
+Funcția `updateUser` actualizează valorile proprietăților `email` și `password` ale obiectului `user`, dacă aceste valori sunt transmise funcției, după care funcția returnează obiectul `user`. Valoarea returnată a funcției `updateUser` este obiectul `user`, ceea ce înseamnă că valoarea lui `updatedUser` este o referință către același obiect `user` la care face referință și `user`. `updatedUser === user` este egal cu `true`.
+
+</p>
+</details>
+
+---
+
+###### 149. Care este rezultatul?
+
+```javascript
+const fruit = ['🍌', '🍊', '🍎']
+
+fruit.slice(0, 1)
+fruit.splice(0, 1)
+fruit.unshift('🍇')
+
+console.log(fruit)
+```
+
+- A: `['🍌', '🍊', '🍎']`
+- B: `['🍊', '🍎']`
+- C: `['🍇', '🍊', '🍎']`
+- D: `['🍇', '🍌', '🍊', '🍎']`
+
+<details><summary><b>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+În primul rând, apelăm metoda `slice` pe array-ul `fruit`. Metoda `slice` nu modifică array-ul original, ci returnează valoarea pe care a tăiat-o din array: emoji-ul de banană.
+Apoi, apelăm metoda `splice` pe array-ul `fruit`. Metoda `splice` modifică array-ul original, ceea ce înseamnă că array-ul `fruit` acum conține `['🍊', '🍎']`.
+În cele din urmă, apelăm metoda `unshift` pe array-u `fruit`, care modifică array-ul original prin adăugarea valorii furnizate, în acest caz, ‘🍇’ ca prim element în array. Array-ul `fruit` acum conține `['🍇', '🍊', '🍎']`.
+
+</p>
+</details>
+
+---
+
+###### 150. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: B
+
+Cheile obiectelor sunt convertite în șiruri de caractere.
+
+Deoarece valoarea lui `dog` este un obiect, `animals[dog]` înseamnă de fapt că creăm o nouă proprietate numită `"object Object"` egală cu noul obiect. `animals["object Object"]` este acum egal cu `{ emoji: "🐶", name: "Mara"}`.
+
+`cat` este, de asemenea, un obiect, ceea ce înseamnă că `animals[cat]` înseamnă de fapt că suprascriem valoarea lui  `animals["object Object"]` cu noile proprietăți ale pisicii. 
+
+Înregistrarea `animals[dog]`, sau mai exact `animals["object Object"]` deoarece convertirea obiectului `dog` într-un șir rezultă în `"object Object"`, returnează `{ emoji: "🐈", name: "Sara" }`.
+
+</p>
+</details>
+
+---
+
+###### 151. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: A
+
+Funcția `updateEmail` este o funcție săgeată și nu este legată de obiectul `user`. Acest lucru înseamnă că cuvântul cheie `this` nu se referă la obiectul `user`, ci se referă la domeniul global în acest caz. Valoarea `email` din obiectul `user` nu se actualizează. Când se înregistrează valoarea `user.email`, se returnează valoarea originală `my@email.com`. 
+
+</p>
+</details>
+
+---
+
+###### 152. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: D
+
+Metoda `Promise.all` rulează promisiunile transmise în paralel. Dacă o promisiune eșuează, metoda `Promise.all` se _respinge_ cu valoarea promisiunii respinse. În acest caz, `promise3` a fost respinsă cu valoarea `"Third"`. Prindem valoarea respinsă în metoda `catch` lantată în invocarea `runPromises` pentru a prinde orice erori din interiorul funcției `runPromises`. Se înregistrează doar `"Third"` deoarece `promise3` a fost respinsă cu această valoare.
+
+</p>
+</details>
+
+---
+
+###### 153. Ce valoare ar trebui să aibă `method` pentru a înregistra `{ 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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+Metoda `fromEntries` transformă o matrice 2D într-un obiect. Primul element din fiecare submatrice va fi cheia, iar al doilea element din fiecare submatrice va fi valoarea. În acest caz, facem mapare peste matricea `keys` care returnează o matrice în care primul element este elementul din matricea cheilor la indexul curent, iar al doilea element este elementul din matricea valorilor la indexul curent. 
+
+Acest lucru creează o matrice de submatrici care conțin cheile și valorile corecte, rezultând în `{ name: "Lydia", age: 22 }`
+
+</p>
+</details>
+
+---
+
+###### 154. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: C
+
+Valoarea implicită a lui `address` este un obiect gol `{}`. Când setăm variabila `member` egală cu obiectul returnat de funcția `createMember`, nu am transmis o valoare pentru `address`, ceea ce înseamnă că valoarea lui `address` este obiectul gol implicit `{}`. Un obiect gol este o valoare adevărată (truthy), ceea ce înseamnă că condiția din expresia ternară `address ? address : null` returnează `true`. Prin urmare, valoarea lui `address` este obiectul gol `{}`.
+
+</p>
+</details>
+
+---
+
+###### 155. Care este rezultatul?
+
+```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>Răspuns</b></summary>
+<p>
+
+#### Răspuns: B
+
+Condiția din instrucțiunea `if` verifică dacă valoarea lui `!typeof randomValue` este egală cu `"string"`. Operatorul `!` convertește valoarea la o valoare booleană. Dacă valoarea este adevărată (truthy), valoarea returnată va fi `false`, iar dacă valoarea este falsă (falsy), valoarea returnată va fi `true`. În acest caz, valoarea returnată de `typeof randomValue` este valoarea adevărată (truthy) `"number"`, ceea ce înseamnă că valoarea lui `!typeof randomValue` este valoarea booleană `false`.
+
+`!typeof randomValue === "string"` întotdeauna returnează `false`, deoarece de fapt verificăm `false === "string"`. Deoarece condiția returnează `false`, blocul de cod al instrucțiunii `else` se execută, iar `Yay it's a string!` este înregistrat.
+
+</p>
+</details>
\ No newline at end of file

From 5d33c9163bb51fee479e536ee8eb1b3731299184 Mon Sep 17 00:00:00 2001
From: Jacob Herper <jacob@herper.uk>
Date: Sun, 10 Sep 2023 15:37:41 +0100
Subject: [PATCH 16/31] updated the repo introduction

---
 README.md | 641 +++++++++++++++++++++++++++---------------------------
 1 file changed, 322 insertions(+), 319 deletions(-)

diff --git a/README.md b/README.md
index 1b7a6f7a..76e834d5 100644
--- a/README.md
+++ b/README.md
@@ -1,23 +1,26 @@
 <div align="center">
   <img height="60" src="https://img.icons8.com/color/344/javascript.png">
   <h1>JavaScript Questions</h1>
+</div>
+
+> [!NOTE]  
+> This repo was created in 2019 and the questions provided here are therefore based on the JavaScript syntax and behaviour at that time. Since JavaScript is a constantly evolving language, there are newer language features that are not covered by the questions here.
 
 ---
 
-<span>I post multiple choice JavaScript questions on my [Instagram](https://www.instagram.com/theavocoder) **stories**, which I'll also post here! Last updated: <a href=#20200612><b>June 12th</b></a>
+<p align="center">
+From basic to advanced: test how well you know JavaScript, refresh your knowledge a bit, or prepare for your coding interview! :muscle: :rocket: I update this repo regularly with new questions. I added the answers in the **collapsed sections** below the questions, simply click on them to expand it. It's just for fun, good luck! :heart:</p>
 
-From basic to advanced: test how well you know JavaScript, refresh your knowledge a bit, or prepare for your coding interview! :muscle: :rocket: I update this repo regularly with new questions. I added the answers in the **collapsed sections** below the questions, simply click on them to expand it. It's just for fun, good luck! :heart:</span>
+<p align="center">Feel free to reach out to me! 😊</p>
 
-Feel free to reach out to me! 😊 <br />
-<a href="https://www.instagram.com/theavocoder">Instagram</a> || <a href="https://www.twitter.com/lydiahallie">Twitter</a> || <a href="https://www.linkedin.com/in/lydia-hallie">LinkedIn</a> || <a href="https://www.lydiahallie.dev">Blog</a>
-</div>
+<p align="center">
+  <a href="https://www.instagram.com/theavocoder">Instagram</a> || <a href="https://www.twitter.com/lydiahallie">Twitter</a> || <a href="https://www.linkedin.com/in/lydia-hallie">LinkedIn</a> || <a href="https://www.lydiahallie.io/">Blog</a>
+</p>
 
-| 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!   |
-|---|
+| 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><b> See 20 Available Translations 🇸🇦🇪🇬🇧🇦🇩🇪🇪🇸🇫🇷🇮🇩🇯🇵🇰🇷🇳🇱🇧🇷🇷🇺🇹🇭🇹🇷🇺🇦🇻🇳🇨🇳🇹🇼🇽🇰</b></summary>
+<details><summary><strong> See 20 Available Translations 🇸🇦🇪🇬🇧🇦🇩🇪🇪🇸🇫🇷🇮🇩🇯🇵🇰🇷🇳🇱🇧🇷🇷🇺🇹🇭🇹🇷🇺🇦🇻🇳🇨🇳🇹🇼🇽🇰</strong></summary>
 <p>
 
 - [🇸🇦 العربية](./ar-AR/README_AR.md)
@@ -54,7 +57,7 @@ Feel free to reach out to me! 😊 <br />
 function sayHi() {
   console.log(name);
   console.log(age);
-  var name = 'Lydia';
+  var name = "Lydia";
   let age = 21;
 }
 
@@ -150,7 +153,7 @@ There is no value `radius` on that object, which returns `NaN`.
 
 ```javascript
 +true;
-!'Lydia';
+!"Lydia";
 ```
 
 - A: `1` and `false`
@@ -175,11 +178,11 @@ The string `'Lydia'` is a truthy value. What we're actually asking, is "is this
 
 ```javascript
 const bird = {
-  size: 'small',
+  size: "small",
 };
 
 const mouse = {
-  name: 'Mickey',
+  name: "Mickey",
   small: true,
 };
 ```
@@ -210,11 +213,11 @@ However, with dot notation, this doesn't happen. `mouse` does not have a key cal
 ###### 6. What's the output?
 
 ```javascript
-let c = { greeting: 'Hey!' };
+let c = { greeting: "Hey!" };
 let d;
 
 d = c;
-c.greeting = 'Hello';
+c.greeting = "Hello";
 console.log(d.greeting);
 ```
 
@@ -284,13 +287,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`
@@ -345,10 +348,10 @@ In order to avoid this, we can use `"use strict"`. This makes sure that you have
 
 ```javascript
 function bark() {
-  console.log('Woof!');
+  console.log("Woof!");
 }
 
-bark.animal = 'dog';
+bark.animal = "dog";
 ```
 
 - A: Nothing, this is totally fine!
@@ -378,8 +381,8 @@ function Person(firstName, lastName) {
   this.lastName = lastName;
 }
 
-const member = new Person('Lydia', 'Hallie');
-Person.getFullName = function() {
+const member = new Person("Lydia", "Hallie");
+Person.getFullName = function () {
   return `${this.firstName} ${this.lastName}`;
 };
 
@@ -396,12 +399,12 @@ console.log(member.getFullName());
 
 #### Answer: A
 
-In JavaScript, functions are objects, and therefore, the method `getFullName` gets added to the constructor function object itself. For that reason, we can call `Person.getFullName()`, but `member.getFullName` throws a `TypeError`. 
+In JavaScript, functions are objects, and therefore, the method `getFullName` gets added to the constructor function object itself. For that reason, we can call `Person.getFullName()`, but `member.getFullName` throws a `TypeError`.
 
 If you want a method to be available to all object instances, you have to add it to the prototype property:
 
 ```js
-Person.prototype.getFullName = function() {
+Person.prototype.getFullName = function () {
   return `${this.firstName} ${this.lastName}`;
 };
 ```
@@ -419,8 +422,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);
@@ -490,7 +493,7 @@ function sum(a, b) {
   return a + b;
 }
 
-sum(1, '2');
+sum(1, "2");
 ```
 
 - A: `NaN`
@@ -557,7 +560,7 @@ function getPersonInfo(one, two, three) {
   console.log(three);
 }
 
-const person = 'Lydia';
+const person = "Lydia";
 const age = 21;
 
 getPersonInfo`${person} is ${age} years old`;
@@ -584,9 +587,9 @@ If you use tagged template literals, the value of the first argument is always a
 ```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`);
   }
@@ -646,7 +649,7 @@ The rest parameter (`...args`) lets us "collect" all remaining arguments into an
 
 ```javascript
 function getAge() {
-  'use strict';
+  "use strict";
   age = 21;
   console.log(age);
 }
@@ -674,7 +677,7 @@ With `"use strict"`, you can make sure that you don't accidentally declare globa
 ###### 21. What's the value of `sum`?
 
 ```javascript
-const sum = eval('10*10+5');
+const sum = eval("10*10+5");
 ```
 
 - A: `105`
@@ -697,7 +700,7 @@ const sum = eval('10*10+5');
 ###### 22. How long is cool_secret accessible?
 
 ```javascript
-sessionStorage.setItem('cool_secret', 123);
+sessionStorage.setItem("cool_secret", 123);
 ```
 
 - A: Forever, the data doesn't get lost.
@@ -750,12 +753,12 @@ You cannot do this with `let` or `const` since they're block-scoped.
 ###### 24. What's the output?
 
 ```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);
 ```
 
@@ -781,7 +784,7 @@ It doesn't work that way for a set. There is no `'1'` in our set: `set.has('1')`
 ###### 25. What's the output?
 
 ```javascript
-const obj = { a: 'one', b: 'two', a: 'three' };
+const obj = { a: "one", b: "two", a: "three" };
 console.log(obj);
 ```
 
@@ -850,12 +853,12 @@ The `continue` statement skips an iteration if a certain condition returns `true
 
 ```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())
+console.log(name.giveLydiaPizza());
 ```
 
 - A: `"Just give Lydia pizza already!"`
@@ -879,8 +882,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;
@@ -912,9 +915,9 @@ Then, we log `a[b]`, which is actually `a["[object Object]"]`. We just set that
 ###### 30. What's the output?
 
 ```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();
@@ -967,9 +970,7 @@ This is where an event loop starts to work. An **event loop** looks at the stack
 ```html
 <div onclick="console.log('first div')">
   <div onclick="console.log('second div')">
-    <button onclick="console.log('button')">
-      Click!
-    </button>
+    <button onclick="console.log('button')">Click!</button>
   </div>
 </div>
 ```
@@ -995,9 +996,7 @@ The deepest nested element that caused the event is the target of the event. You
 
 ```html
 <div onclick="console.log('div')">
-  <p onclick="console.log('p')">
-    Click here!
-  </p>
+  <p onclick="console.log('p')">Click here!</p>
 </div>
 ```
 
@@ -1021,7 +1020,7 @@ If we click `p`, we see two logs: `p` and `div`. During event propagation, there
 ###### 33. What's the output?
 
 ```javascript
-const person = { name: 'Lydia' };
+const person = { name: "Lydia" };
 
 function sayHi(age) {
   return `${this.name} is ${age}`;
@@ -1071,7 +1070,6 @@ console.log(typeof sayHi());
 #### Answer: 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>
@@ -1084,8 +1082,8 @@ FYI: `typeof` can return the following list of values: `undefined`, `boolean`, `
 ```javascript
 0;
 new Number(0);
-('');
-(' ');
+("");
+(" ");
 new Boolean(false);
 undefined;
 ```
@@ -1234,11 +1232,14 @@ What differentiates a primitive from an object is that primitives do not have an
 ###### 40. What's the output?
 
 ```javascript
-[[0, 1], [2, 3]].reduce(
+[
+  [0, 1],
+  [2, 3],
+].reduce(
   (acc, cur) => {
     return acc.concat(cur);
   },
-  [1, 2],
+  [1, 2]
 );
 ```
 
@@ -1265,7 +1266,7 @@ Then, `[1, 2, 0, 1]` is `acc` and `[2, 3]` is `cur`. We concatenate them, and ge
 
 ```javascript
 !!null;
-!!'';
+!!"";
 !!1;
 ```
 
@@ -1293,7 +1294,7 @@ Then, `[1, 2, 0, 1]` is `acc` and `[2, 3]` is `cur`. We concatenate them, and ge
 ###### 42. What does the `setInterval` method return in the browser?
 
 ```javascript
-setInterval(() => console.log('Hi'), 1000);
+setInterval(() => console.log("Hi"), 1000);
 ```
 
 - A: a unique id
@@ -1316,7 +1317,7 @@ It returns a unique id. This id can be used to clear that interval with the `cle
 ###### 43. What does this return?
 
 ```javascript
-[...'Lydia'];
+[..."Lydia"];
 ```
 
 - A: `["L", "y", "d", "i", "a"]`
@@ -1375,14 +1376,14 @@ 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));
+Promise.race([firstPromise, secondPromise]).then((res) => console.log(res));
 ```
 
 - A: `"one"`
@@ -1405,7 +1406,7 @@ When we pass multiple promises to the `Promise.race` method, it resolves/rejects
 ###### 46. What's the output?
 
 ```javascript
-let person = { name: 'Lydia' };
+let person = { name: "Lydia" };
 const members = [person];
 person = null;
 
@@ -1445,7 +1446,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,
 };
 
@@ -1474,7 +1475,7 @@ With a `for-in` loop, we can iterate through object keys, in this case `name` an
 ###### 48. What's the output?
 
 ```javascript
-console.log(3 + 4 + '5');
+console.log(3 + 4 + "5");
 ```
 
 - A: `"345"`
@@ -1501,7 +1502,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`
@@ -1526,8 +1527,8 @@ Only the first numbers in the string is returned. Based on the _radix_ (the seco
 ###### 50. What's the output?
 
 ```javascript
-[1, 2, 3].map(num => {
-  if (typeof num === 'number') return;
+[1, 2, 3].map((num) => {
+  if (typeof num === "number") return;
   return num * 2;
 });
 ```
@@ -1555,12 +1556,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);
 
@@ -1592,15 +1593,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);
   }
 }
 
@@ -1630,8 +1631,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,11 +1706,11 @@ class Dog {
   }
 }
 
-Dog.prototype.bark = function() {
+Dog.prototype.bark = function () {
   console.log(`Woof I am ${this.name}`);
 };
 
-const pet = new Dog('Mara');
+const pet = new Dog("Mara");
 
 pet.bark();
 
@@ -1774,7 +1775,7 @@ export default counter;
 
 ```javascript
 // index.js
-import myCounter from './counter';
+import myCounter from "./counter";
 
 myCounter += 1;
 
@@ -1803,7 +1804,7 @@ When we try to increment the value of `myCounter`, it throws an error: `myCounte
 ###### 58. What's the output?
 
 ```javascript
-const name = 'Lydia';
+const name = "Lydia";
 age = 21;
 
 console.log(delete name);
@@ -1874,7 +1875,7 @@ This means that the value of `y` is equal to the first value in the array, which
 ###### 60. What's the output?
 
 ```javascript
-const user = { name: 'Lydia', age: 21 };
+const user = { name: "Lydia", age: 21 };
 const admin = { admin: true, ...user };
 
 console.log(admin);
@@ -1900,9 +1901,9 @@ It's possible to combine objects using the spread operator `...`. It lets you cr
 ###### 61. What's the output?
 
 ```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));
@@ -1931,12 +1932,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);
 ```
 
@@ -1967,7 +1968,7 @@ If the replacer is a _function_, this function gets called on every property in
 let num = 10;
 
 const increaseNumber = () => num++;
-const increasePassedNumber = number => number++;
+const increasePassedNumber = (number) => number++;
 
 const num1 = increaseNumber();
 const num2 = increasePassedNumber(num1);
@@ -2124,12 +2125,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;
 ```
 
@@ -2157,7 +2158,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`
@@ -2180,7 +2181,7 @@ Every Symbol is entirely unique. The purpose of the argument passed to the Symbo
 ###### 69. What's the output?
 
 ```javascript
-const name = 'Lydia Hallie';
+const name = "Lydia Hallie";
 console.log(name.padStart(13));
 console.log(name.padStart(2));
 ```
@@ -2207,7 +2208,7 @@ If the argument passed to the `padStart` method is smaller than the length of th
 ###### 70. What's the output?
 
 ```javascript
-console.log('🥑' + '💻');
+console.log("🥑" + "💻");
 ```
 
 - A: `"🥑💻"`
@@ -2231,11 +2232,11 @@ With the `+` operator, you can concatenate strings. In this case, we are concate
 
 ```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();
@@ -2303,7 +2304,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();
@@ -2340,7 +2341,7 @@ function addToList(item, list) {
   return list.push(item);
 }
 
-const result = addToList('apple', ['banana']);
+const result = addToList("apple", ["banana"]);
 console.log(result);
 ```
 
@@ -2400,7 +2401,7 @@ Since `shape` is frozen, and since the value of `x` is not an object, we cannot
 ###### 76. What's the output?
 
 ```javascript
-const { firstName: myName } = { firstName: 'Lydia' };
+const { firstName: myName } = { firstName: "Lydia" };
 
 console.log(firstName);
 ```
@@ -2418,7 +2419,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;
 
@@ -2428,7 +2429,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;
 
@@ -2441,12 +2442,11 @@ 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
 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`.
@@ -2490,7 +2490,7 @@ The `sum` function always returns the same result. If we pass `1` and `2`, it wi
 ```javascript
 const add = () => {
   const cache = {};
-  return num => {
+  return (num) => {
     if (num in cache) {
       return `From cache! ${cache[num]}`;
     } else {
@@ -2535,7 +2535,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);
@@ -2631,13 +2631,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;
     },
@@ -2671,12 +2671,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);
 ```
@@ -2740,9 +2740,9 @@ Variables with the `const` and `let` keyword are _block-scoped_. A block is anyt
 ###### 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));
+fetch("https://www.website.com/api/user/1")
+  .then((res) => res.json())
+  .then((res) => console.log(res));
 ```
 
 - A: The result of the `fetch` method.
@@ -2796,7 +2796,7 @@ By setting `hasName` equal to `name`, you set `hasName` equal to whatever value
 ###### 87. What's the output?
 
 ```javascript
-console.log('I want pizza'[0]);
+console.log("I want pizza"[0]);
 ```
 
 - A: `"""`
@@ -2851,11 +2851,11 @@ If you're trying to set a default parameter's value equal to a parameter which i
 
 ```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);
 ```
@@ -2888,7 +2888,7 @@ class Person {
   }
 }
 
-const member = new Person('John');
+const member = new Person("John");
 console.log(typeof member);
 ```
 
@@ -2948,7 +2948,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 = () =>
@@ -2979,7 +2979,7 @@ Regular functions, such as the `giveLydiaPizza` function, have a `prototype` pro
 
 ```javascript
 const person = {
-  name: 'Lydia',
+  name: "Lydia",
   age: 21,
 };
 
@@ -3039,7 +3039,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' ]`
@@ -3053,9 +3053,9 @@ 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');
-  return
+  if (a > b) console.log("a is bigger");
+  else console.log("b is bigger");
+  return;
   a + b;
 }
 
@@ -3094,13 +3094,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";
   }
 };
 
@@ -3129,7 +3129,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);
@@ -3184,7 +3184,7 @@ The `getList` function receives an array as its argument. Between the parenthese
 
 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 `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:
 
@@ -3198,7 +3198,7 @@ The following function would have returned an object:
 ###### 99. What's the output?
 
 ```javascript
-const name = 'Lydia';
+const name = "Lydia";
 
 console.log(name());
 ```
@@ -3230,8 +3230,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`
@@ -3257,7 +3257,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);
@@ -3289,16 +3289,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');
+  myPromise().then((res) => console.log(res));
+  console.log("second");
 }
 
 async function secondFunction() {
   console.log(await myPromise());
-  console.log('second');
+  console.log("second");
 }
 
 firstFunction();
@@ -3336,8 +3336,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);
@@ -3397,13 +3397,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);
 ```
@@ -3442,7 +3442,7 @@ const colorConfig = {
   yellow: false,
 };
 
-const colors = ['pink', 'red', 'blue'];
+const colors = ["pink", "red", "blue"];
 
 console.log(colorConfig.colors[1]);
 ```
@@ -3471,7 +3471,7 @@ JavaScript interprets (or unboxes) statements. When we use bracket notation, it
 ###### 107. What's its value?
 
 ```javascript
-console.log('❤️' === '❤️');
+console.log("❤️" === "❤️");
 ```
 
 - A: `true`
@@ -3492,14 +3492,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`
@@ -3524,10 +3524,10 @@ With `splice` method, we modify the original array by deleting, replacing or add
 ###### 109. What's the output?
 
 ```javascript
-const food = ['🍕', '🍫', '🥑', '🍔'];
+const food = ["🍕", "🍫", "🥑", "🍔"];
 const info = { favoriteFood: food[0] };
 
-info.favoriteFood = '🍝';
+info.favoriteFood = "🍝";
 
 console.log(food);
 ```
@@ -3581,7 +3581,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' }
 ```
 
@@ -3593,11 +3593,11 @@ JSON.parse(jsonArray); // { name: 'Lydia' }
 ###### 111. What's the output?
 
 ```javascript
-let name = 'Lydia';
+let name = "Lydia";
 
 function getName() {
   console.log(name);
-  let name = 'Sarah';
+  let name = "Sarah";
 }
 
 getName();
@@ -3620,7 +3620,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);
@@ -3638,11 +3638,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();
@@ -3688,7 +3688,7 @@ console.log(two.next().value); // undefined
 ###### 113. What's the output?
 
 ```javascript
-console.log(`${(x => x)('I love')} to program`);
+console.log(`${((x) => x)("I love")} to program`);
 ```
 
 - A: `I love to program`
@@ -3713,7 +3713,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),
 };
 
@@ -3730,9 +3730,9 @@ config = null;
 
 #### Answer: 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. 
+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).
 
@@ -3745,16 +3745,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
@@ -3781,14 +3781,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);
@@ -3847,7 +3847,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)]);
 ```
@@ -3873,11 +3873,11 @@ With the `+=` operand, we're incrementing the value of `num` by `1`. `num` had t
 
 ```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}`;
@@ -3915,10 +3915,10 @@ With the optional chaining operator `?.`, we no longer have to explicitly check
 ###### 120. What's the output?
 
 ```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!`);
 }
@@ -3974,10 +3974,10 @@ The `language` method is a `setter`. Setters don't hold an actual value, their p
 ###### 122. What's the output?
 
 ```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`
@@ -4002,7 +4002,7 @@ console.log(!typeof name === 'string');
 ###### 123. What's the output?
 
 ```javascript
-const add = x => y => z => {
+const add = (x) => (y) => (z) => {
   console.log(x, y, z);
   return x + y + z;
 };
@@ -4092,20 +4092,20 @@ 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}`;
 }
 
-console.log(getFine(130, 300))
+console.log(getFine(130, 300));
 ```
 
 - A: The driver drove 130 and has to pay 300
@@ -4128,8 +4128,8 @@ With the `Intl.NumberFormat` method, we can format numeric values to any locale.
 ###### 127. What's the output?
 
 ```javascript
-const spookyItems = ['👻', '🎃', '🕸'];
-({ item: spookyItems[3] } = { item: '💀' });
+const spookyItems = ["👻", "🎃", "🕸"];
+({ item: spookyItems[3] } = { item: "💀" });
 
 console.log(spookyItems);
 ```
@@ -4154,7 +4154,7 @@ By destructuring objects, we can unpack values from the right-hand object, and a
 ###### 128. What's the output?
 
 ```javascript
-const name = 'Lydia Hallie';
+const name = "Lydia Hallie";
 const age = 21;
 
 console.log(Number.isNaN(name));
@@ -4190,7 +4190,7 @@ const randomValue = 21;
 
 function getInfo() {
   console.log(typeof randomValue);
-  const randomValue = 'Lydia Hallie';
+  const randomValue = "Lydia Hallie";
 }
 
 getInfo();
@@ -4216,7 +4216,7 @@ Variables declared with the `const` keyword are not referenceable before their i
 ###### 130. What's the output?
 
 ```javascript
-const myPromise = Promise.resolve('Woah some cool data');
+const myPromise = Promise.resolve("Woah some cool data");
 
 (async () => {
   try {
@@ -4224,7 +4224,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!");
   }
 })();
 ```
@@ -4249,7 +4249,7 @@ In the `try` block, we're logging the awaited value of the `myPromise` variable:
 ###### 131. What's the output?
 
 ```javascript
-const emojis = ['🥑', ['✨', '✨', ['🍕', '🍕']]];
+const emojis = ["🥑", ["✨", "✨", ["🍕", "🍕"]]];
 
 console.log(emojis.flat(1));
 ```
@@ -4322,19 +4322,19 @@ We invoke `counterTwo.increment()`, which sets `count` to `3`. Then, we log the
 ###### 133. What's the output?
 
 ```javascript
-const myPromise = Promise.resolve(Promise.resolve('Promise'));
+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!');
+  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!');
+  console.log(`${res} 2!`);
+  setTimeout(() => console.log("Timeout 2!"), 0);
+  console.log("Last line 2!");
 }
 
 funcOne();
@@ -4355,7 +4355,7 @@ First, we invoke `funcOne`. On the first line of `funcOne`, we call the _asynchr
 
 Then we call the `myPromise` promise, which is an _asynchronous_ operation.
 
-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. 
+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.
 
@@ -4379,7 +4379,7 @@ export default function sum(x) {
 }
 
 // index.js
-import * as sum from './sum';
+import * as sum from "./sum";
 ```
 
 - A: `sum(4)`
@@ -4396,12 +4396,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);
 ```
 
@@ -4432,13 +4432,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;
 ```
 
@@ -4468,7 +4468,7 @@ Then, we access a property value on the proxy object, the `get` property on the
 ###### 136. Which of the following will modify the `person` object?
 
 ```javascript
-const person = { name: 'Lydia Hallie' };
+const person = { name: "Lydia Hallie" };
 
 Object.seal(person);
 ```
@@ -4496,9 +4496,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",
   },
 };
 
@@ -4527,7 +4527,7 @@ However, it only _shallowly_ freezes the object, meaning that only _direct_ prop
 ###### 138. What's the output?
 
 ```javascript
-const add = x => x + x;
+const add = (x) => x + x;
 
 function myFunc(num = 2, value = add(num)) {
   console.log(num, value);
@@ -4560,21 +4560,21 @@ Then, we invoked `myFunc(3)` and passed the value `3` as the value for the argum
 
 ```javascript
 class Counter {
-  #number = 10
+  #number = 10;
 
   increment() {
-    this.#number++
+    this.#number++;
   }
 
   getNum() {
-    return this.#number
+    return this.#number;
   }
 }
 
-const counter = new Counter()
-counter.increment()
+const counter = new Counter();
+counter.increment();
 
-console.log(counter.#number)
+console.log(counter.#number);
 ```
 
 - A: `10`
@@ -4598,8 +4598,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) {
@@ -4642,8 +4642,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) {
@@ -4651,9 +4651,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);
 ```
@@ -4722,11 +4722,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;
 ```
 
@@ -4781,11 +4781,11 @@ Objects aren't iterable by default. An iterable is an iterable if the iterator p
 let count = 0;
 const nums = [0, 1, 2, 3];
 
-nums.forEach(num => {
-	if (num) count += 1
-})
+nums.forEach((num) => {
+  if (num) count += 1;
+});
 
-console.log(count)
+console.log(count);
 ```
 
 - A: 1
@@ -4809,12 +4809,12 @@ The `if` condition within the `forEach` loop checks whether the value of `num` i
 
 ```javascript
 function getFruit(fruits) {
-	console.log(fruits?.[1]?.[1])
+  console.log(fruits?.[1]?.[1]);
 }
 
-getFruit([['🍊', '🍌'], ['🍍']])
-getFruit()
-getFruit([['🍍'], ['🍊', '🍌']])
+getFruit([["🍊", "🍌"], ["🍍"]]);
+getFruit();
+getFruit([["🍍"], ["🍊", "🍌"]]);
 ```
 
 - A: `null`, `undefined`, 🍌
@@ -4827,11 +4827,11 @@ getFruit([['🍍'], ['🍊', '🍌']])
 
 #### Answer: 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`. 
+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. 
+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.
 
@@ -4844,19 +4844,19 @@ Lastly, we're trying to log the second item in the `['🍊', '🍌']` subarray o
 
 ```javascript
 class Calc {
-	constructor() {
-		this.count = 0 
-	}
+  constructor() {
+    this.count = 0;
+  }
 
-	increase() {
-		this.count ++
-	}
+  increase() {
+    this.count++;
+  }
 }
 
-const calc = new Calc()
-new Calc().increase()
+const calc = new Calc();
+new Calc().increase();
 
-console.log(calc.count)
+console.log(calc.count);
 ```
 
 - A: `0`
@@ -4880,25 +4880,25 @@ 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 }) => {
-	if (email) {
-		Object.assign(user, { email })
-	}
+  if (email) {
+    Object.assign(user, { email });
+  }
 
-	if (password) {
-		user.password = password
-	}
+  if (password) {
+    user.password = password;
+  }
 
-	return user
-}
+  return user;
+};
 
-const updatedUser = updateUser({ email: "new@email.com" })
+const updatedUser = updateUser({ email: "new@email.com" });
 
-console.log(updatedUser === user)
+console.log(updatedUser === user);
 ```
 
 - A: `false`
@@ -4921,13 +4921,13 @@ The `updateUser` function updates the values of the `email` and `password` prope
 ###### 149. What's the output?
 
 ```javascript
-const fruit = ['🍌', '🍊', '🍎']
+const fruit = ["🍌", "🍊", "🍎"];
 
-fruit.slice(0, 1)
-fruit.splice(0, 1)
-fruit.unshift('🍇')
+fruit.slice(0, 1);
+fruit.splice(0, 1);
+fruit.unshift("🍇");
 
-console.log(fruit)
+console.log(fruit);
 ```
 
 - A: `['🍌', '🍊', '🍎']`
@@ -4942,7 +4942,7 @@ console.log(fruit)
 
 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 `['🍇', '🍊', '🍎']`.
+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>
@@ -4953,13 +4953,13 @@ 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])
+console.log(animals[dog]);
 ```
 
 - A: `{ emoji: "🐶", name: "Mara" }`
@@ -4972,11 +4972,11 @@ console.log(animals[dog])
 
 #### Answer: B
 
-Object keys are converted to strings. 
+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"}`.
+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. 
+`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" }`.
 
@@ -4989,14 +4989,14 @@ Logging `animals[dog]`, or actually `animals["[object Object]"]` since convertin
 
 ```javascript
 const user = {
-	email: "my@email.com",
-	updateEmail: email => {
-		this.email = email
-	}
-}
+  email: "my@email.com",
+  updateEmail: (email) => {
+    this.email = email;
+  },
+};
 
-user.updateEmail("new@email.com")
-console.log(user.email)
+user.updateEmail("new@email.com");
+console.log(user.email);
 ```
 
 - A: `my@email.com`
@@ -5009,7 +5009,7 @@ console.log(user.email)
 
 #### Answer: 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. 
+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>
@@ -5019,20 +5019,20 @@ The `updateEmail` function is an arrow function, and is not bound to the `user`
 ###### 152. What's the output?
 
 ```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])
-	const res2  = await Promise.all([promise3, promise4])
-	return [res1, res2]
-}
+  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))
+  .then((res) => console.log(res))
+  .catch((err) => console.log(err));
 ```
 
 - A: `[['First', 'Second'], ['Fourth']]`
@@ -5045,23 +5045,26 @@ runPromises()
 
 #### Answer: 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` 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` rejected with this value.
+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` 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` rejected with this value.
 
 </p>
 </details>
 
 ---
 
-###### 153. What should the value of `method` be to log `{ name: "Lydia", age: 22 }`? 
+###### 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 = /* ?? */
-Object[method](keys.map((_, i) => {
-	return [keys[i], values[i]]
-})) // { name: "Lydia", age: 22 }
+const method =
+  /* ?? */
+  Object[method](
+    keys.map((_, i) => {
+      return [keys[i], values[i]];
+    })
+  ); // { name: "Lydia", age: 22 }
 ```
 
 - A: `entries`
@@ -5074,7 +5077,7 @@ Object[method](keys.map((_, i) => {
 
 #### Answer: 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 which 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. 
+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 which 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 }`
 
@@ -5086,18 +5089,18 @@ This creates an array of subarrays containing the correct keys and values, which
 ###### 154. What's the output?
 
 ```javascript
-const createMember = ({ email, address = {}}) => {
-	const validEmail = /.+\@.+\..+/.test(email)
-	if (!validEmail) throw new Error("Valid email pls")
+const createMember = ({ email, address = {} }) => {
+  const validEmail = /.+\@.+\..+/.test(email);
+  if (!validEmail) throw new Error("Valid email pls");
 
-	return {
-		email,
-		address: address ? address : null
-	}
-}
+  return {
+    email,
+    address: address ? address : null,
+  };
+};
 
-const member = createMember({ email: "my@email.com" })
-console.log(member)
+const member = createMember({ email: "my@email.com" });
+console.log(member);
 ```
 
 - A: `{ email: "my@email.com", address: null }`
@@ -5120,13 +5123,13 @@ The default value of `address` is an empty object `{}`. When we set the variable
 ###### 155. What's the output?
 
 ```javascript
-let randomValue = { name: "Lydia" }
-randomValue = 23
+let randomValue = { name: "Lydia" };
+randomValue = 23;
 
 if (!typeof randomValue === "string") {
-	console.log("It's not a string!")
+  console.log("It's not a string!");
 } else {
-	console.log("Yay it's a string!")
+  console.log("Yay it's a string!");
 }
 ```
 

From 44808d954348d25c75664f4cd3b9e3b5ff00809b Mon Sep 17 00:00:00 2001
From: Jacob Herper <jacob@herper.uk>
Date: Sun, 10 Sep 2023 15:43:58 +0100
Subject: [PATCH 17/31] undo formatting changes

---
 README.md | 618 +++++++++++++++++++++++++++---------------------------
 1 file changed, 309 insertions(+), 309 deletions(-)

diff --git a/README.md b/README.md
index 76e834d5..802f4dfc 100644
--- a/README.md
+++ b/README.md
@@ -57,7 +57,7 @@ From basic to advanced: test how well you know JavaScript, refresh your knowledg
 function sayHi() {
   console.log(name);
   console.log(age);
-  var name = "Lydia";
+  var name = 'Lydia';
   let age = 21;
 }
 
@@ -153,7 +153,7 @@ There is no value `radius` on that object, which returns `NaN`.
 
 ```javascript
 +true;
-!"Lydia";
+!'Lydia';
 ```
 
 - A: `1` and `false`
@@ -178,11 +178,11 @@ The string `'Lydia'` is a truthy value. What we're actually asking, is "is this
 
 ```javascript
 const bird = {
-  size: "small",
+  size: 'small',
 };
 
 const mouse = {
-  name: "Mickey",
+  name: 'Mickey',
   small: true,
 };
 ```
@@ -213,11 +213,11 @@ However, with dot notation, this doesn't happen. `mouse` does not have a key cal
 ###### 6. What's the output?
 
 ```javascript
-let c = { greeting: "Hey!" };
+let c = { greeting: 'Hey!' };
 let d;
 
 d = c;
-c.greeting = "Hello";
+c.greeting = 'Hello';
 console.log(d.greeting);
 ```
 
@@ -287,13 +287,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`
@@ -348,10 +348,10 @@ In order to avoid this, we can use `"use strict"`. This makes sure that you have
 
 ```javascript
 function bark() {
-  console.log("Woof!");
+  console.log('Woof!');
 }
 
-bark.animal = "dog";
+bark.animal = 'dog';
 ```
 
 - A: Nothing, this is totally fine!
@@ -381,8 +381,8 @@ function Person(firstName, lastName) {
   this.lastName = lastName;
 }
 
-const member = new Person("Lydia", "Hallie");
-Person.getFullName = function () {
+const member = new Person('Lydia', 'Hallie');
+Person.getFullName = function() {
   return `${this.firstName} ${this.lastName}`;
 };
 
@@ -399,12 +399,12 @@ console.log(member.getFullName());
 
 #### Answer: A
 
-In JavaScript, functions are objects, and therefore, the method `getFullName` gets added to the constructor function object itself. For that reason, we can call `Person.getFullName()`, but `member.getFullName` throws a `TypeError`.
+In JavaScript, functions are objects, and therefore, the method `getFullName` gets added to the constructor function object itself. For that reason, we can call `Person.getFullName()`, but `member.getFullName` throws a `TypeError`. 
 
 If you want a method to be available to all object instances, you have to add it to the prototype property:
 
 ```js
-Person.prototype.getFullName = function () {
+Person.prototype.getFullName = function() {
   return `${this.firstName} ${this.lastName}`;
 };
 ```
@@ -422,8 +422,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);
@@ -493,7 +493,7 @@ function sum(a, b) {
   return a + b;
 }
 
-sum(1, "2");
+sum(1, '2');
 ```
 
 - A: `NaN`
@@ -560,7 +560,7 @@ function getPersonInfo(one, two, three) {
   console.log(three);
 }
 
-const person = "Lydia";
+const person = 'Lydia';
 const age = 21;
 
 getPersonInfo`${person} is ${age} years old`;
@@ -587,9 +587,9 @@ If you use tagged template literals, the value of the first argument is always a
 ```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`);
   }
@@ -649,7 +649,7 @@ The rest parameter (`...args`) lets us "collect" all remaining arguments into an
 
 ```javascript
 function getAge() {
-  "use strict";
+  'use strict';
   age = 21;
   console.log(age);
 }
@@ -677,7 +677,7 @@ With `"use strict"`, you can make sure that you don't accidentally declare globa
 ###### 21. What's the value of `sum`?
 
 ```javascript
-const sum = eval("10*10+5");
+const sum = eval('10*10+5');
 ```
 
 - A: `105`
@@ -700,7 +700,7 @@ const sum = eval("10*10+5");
 ###### 22. How long is cool_secret accessible?
 
 ```javascript
-sessionStorage.setItem("cool_secret", 123);
+sessionStorage.setItem('cool_secret', 123);
 ```
 
 - A: Forever, the data doesn't get lost.
@@ -753,12 +753,12 @@ You cannot do this with `let` or `const` since they're block-scoped.
 ###### 24. What's the output?
 
 ```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);
 ```
 
@@ -784,7 +784,7 @@ It doesn't work that way for a set. There is no `'1'` in our set: `set.has('1')`
 ###### 25. What's the output?
 
 ```javascript
-const obj = { a: "one", b: "two", a: "three" };
+const obj = { a: 'one', b: 'two', a: 'three' };
 console.log(obj);
 ```
 
@@ -853,12 +853,12 @@ The `continue` statement skips an iteration if a certain condition returns `true
 
 ```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());
+console.log(name.giveLydiaPizza())
 ```
 
 - A: `"Just give Lydia pizza already!"`
@@ -882,8 +882,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;
@@ -915,9 +915,9 @@ Then, we log `a[b]`, which is actually `a["[object Object]"]`. We just set that
 ###### 30. What's the output?
 
 ```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();
@@ -970,7 +970,9 @@ This is where an event loop starts to work. An **event loop** looks at the stack
 ```html
 <div onclick="console.log('first div')">
   <div onclick="console.log('second div')">
-    <button onclick="console.log('button')">Click!</button>
+    <button onclick="console.log('button')">
+      Click!
+    </button>
   </div>
 </div>
 ```
@@ -996,7 +998,9 @@ The deepest nested element that caused the event is the target of the event. You
 
 ```html
 <div onclick="console.log('div')">
-  <p onclick="console.log('p')">Click here!</p>
+  <p onclick="console.log('p')">
+    Click here!
+  </p>
 </div>
 ```
 
@@ -1020,7 +1024,7 @@ If we click `p`, we see two logs: `p` and `div`. During event propagation, there
 ###### 33. What's the output?
 
 ```javascript
-const person = { name: "Lydia" };
+const person = { name: 'Lydia' };
 
 function sayHi(age) {
   return `${this.name} is ${age}`;
@@ -1070,6 +1074,7 @@ console.log(typeof sayHi());
 #### Answer: 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>
@@ -1082,8 +1087,8 @@ FYI: `typeof` can return the following list of values: `undefined`, `boolean`, `
 ```javascript
 0;
 new Number(0);
-("");
-(" ");
+('');
+(' ');
 new Boolean(false);
 undefined;
 ```
@@ -1232,14 +1237,11 @@ What differentiates a primitive from an object is that primitives do not have an
 ###### 40. What's the output?
 
 ```javascript
-[
-  [0, 1],
-  [2, 3],
-].reduce(
+[[0, 1], [2, 3]].reduce(
   (acc, cur) => {
     return acc.concat(cur);
   },
-  [1, 2]
+  [1, 2],
 );
 ```
 
@@ -1266,7 +1268,7 @@ Then, `[1, 2, 0, 1]` is `acc` and `[2, 3]` is `cur`. We concatenate them, and ge
 
 ```javascript
 !!null;
-!!"";
+!!'';
 !!1;
 ```
 
@@ -1294,7 +1296,7 @@ Then, `[1, 2, 0, 1]` is `acc` and `[2, 3]` is `cur`. We concatenate them, and ge
 ###### 42. What does the `setInterval` method return in the browser?
 
 ```javascript
-setInterval(() => console.log("Hi"), 1000);
+setInterval(() => console.log('Hi'), 1000);
 ```
 
 - A: a unique id
@@ -1317,7 +1319,7 @@ It returns a unique id. This id can be used to clear that interval with the `cle
 ###### 43. What does this return?
 
 ```javascript
-[..."Lydia"];
+[...'Lydia'];
 ```
 
 - A: `["L", "y", "d", "i", "a"]`
@@ -1376,14 +1378,14 @@ 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));
+Promise.race([firstPromise, secondPromise]).then(res => console.log(res));
 ```
 
 - A: `"one"`
@@ -1406,7 +1408,7 @@ When we pass multiple promises to the `Promise.race` method, it resolves/rejects
 ###### 46. What's the output?
 
 ```javascript
-let person = { name: "Lydia" };
+let person = { name: 'Lydia' };
 const members = [person];
 person = null;
 
@@ -1446,7 +1448,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,
 };
 
@@ -1475,7 +1477,7 @@ With a `for-in` loop, we can iterate through object keys, in this case `name` an
 ###### 48. What's the output?
 
 ```javascript
-console.log(3 + 4 + "5");
+console.log(3 + 4 + '5');
 ```
 
 - A: `"345"`
@@ -1502,7 +1504,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`
@@ -1527,8 +1529,8 @@ Only the first numbers in the string is returned. Based on the _radix_ (the seco
 ###### 50. What's the output?
 
 ```javascript
-[1, 2, 3].map((num) => {
-  if (typeof num === "number") return;
+[1, 2, 3].map(num => {
+  if (typeof num === 'number') return;
   return num * 2;
 });
 ```
@@ -1556,12 +1558,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);
 
@@ -1593,15 +1595,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);
   }
 }
 
@@ -1631,8 +1633,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();
@@ -1706,11 +1708,11 @@ class Dog {
   }
 }
 
-Dog.prototype.bark = function () {
+Dog.prototype.bark = function() {
   console.log(`Woof I am ${this.name}`);
 };
 
-const pet = new Dog("Mara");
+const pet = new Dog('Mara');
 
 pet.bark();
 
@@ -1775,7 +1777,7 @@ export default counter;
 
 ```javascript
 // index.js
-import myCounter from "./counter";
+import myCounter from './counter';
 
 myCounter += 1;
 
@@ -1804,7 +1806,7 @@ When we try to increment the value of `myCounter`, it throws an error: `myCounte
 ###### 58. What's the output?
 
 ```javascript
-const name = "Lydia";
+const name = 'Lydia';
 age = 21;
 
 console.log(delete name);
@@ -1875,7 +1877,7 @@ This means that the value of `y` is equal to the first value in the array, which
 ###### 60. What's the output?
 
 ```javascript
-const user = { name: "Lydia", age: 21 };
+const user = { name: 'Lydia', age: 21 };
 const admin = { admin: true, ...user };
 
 console.log(admin);
@@ -1901,9 +1903,9 @@ It's possible to combine objects using the spread operator `...`. It lets you cr
 ###### 61. What's the output?
 
 ```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));
@@ -1932,12 +1934,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);
 ```
 
@@ -1968,7 +1970,7 @@ If the replacer is a _function_, this function gets called on every property in
 let num = 10;
 
 const increaseNumber = () => num++;
-const increasePassedNumber = (number) => number++;
+const increasePassedNumber = number => number++;
 
 const num1 = increaseNumber();
 const num2 = increasePassedNumber(num1);
@@ -2125,12 +2127,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;
 ```
 
@@ -2158,7 +2160,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`
@@ -2181,7 +2183,7 @@ Every Symbol is entirely unique. The purpose of the argument passed to the Symbo
 ###### 69. What's the output?
 
 ```javascript
-const name = "Lydia Hallie";
+const name = 'Lydia Hallie';
 console.log(name.padStart(13));
 console.log(name.padStart(2));
 ```
@@ -2208,7 +2210,7 @@ If the argument passed to the `padStart` method is smaller than the length of th
 ###### 70. What's the output?
 
 ```javascript
-console.log("🥑" + "💻");
+console.log('🥑' + '💻');
 ```
 
 - A: `"🥑💻"`
@@ -2232,11 +2234,11 @@ With the `+` operator, you can concatenate strings. In this case, we are concate
 
 ```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();
@@ -2304,7 +2306,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();
@@ -2341,7 +2343,7 @@ function addToList(item, list) {
   return list.push(item);
 }
 
-const result = addToList("apple", ["banana"]);
+const result = addToList('apple', ['banana']);
 console.log(result);
 ```
 
@@ -2401,7 +2403,7 @@ Since `shape` is frozen, and since the value of `x` is not an object, we cannot
 ###### 76. What's the output?
 
 ```javascript
-const { firstName: myName } = { firstName: "Lydia" };
+const { firstName: myName } = { firstName: 'Lydia' };
 
 console.log(firstName);
 ```
@@ -2419,7 +2421,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;
 
@@ -2429,7 +2431,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;
 
@@ -2442,11 +2444,12 @@ 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
 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`.
@@ -2490,7 +2493,7 @@ The `sum` function always returns the same result. If we pass `1` and `2`, it wi
 ```javascript
 const add = () => {
   const cache = {};
-  return (num) => {
+  return num => {
     if (num in cache) {
       return `From cache! ${cache[num]}`;
     } else {
@@ -2535,7 +2538,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);
@@ -2631,13 +2634,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;
     },
@@ -2671,12 +2674,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);
 ```
@@ -2740,9 +2743,9 @@ Variables with the `const` and `let` keyword are _block-scoped_. A block is anyt
 ###### 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));
+fetch('https://www.website.com/api/user/1')
+  .then(res => res.json())
+  .then(res => console.log(res));
 ```
 
 - A: The result of the `fetch` method.
@@ -2796,7 +2799,7 @@ By setting `hasName` equal to `name`, you set `hasName` equal to whatever value
 ###### 87. What's the output?
 
 ```javascript
-console.log("I want pizza"[0]);
+console.log('I want pizza'[0]);
 ```
 
 - A: `"""`
@@ -2851,11 +2854,11 @@ If you're trying to set a default parameter's value equal to a parameter which i
 
 ```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);
 ```
@@ -2888,7 +2891,7 @@ class Person {
   }
 }
 
-const member = new Person("John");
+const member = new Person('John');
 console.log(typeof member);
 ```
 
@@ -2948,7 +2951,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 = () =>
@@ -2979,7 +2982,7 @@ Regular functions, such as the `giveLydiaPizza` function, have a `prototype` pro
 
 ```javascript
 const person = {
-  name: "Lydia",
+  name: 'Lydia',
   age: 21,
 };
 
@@ -3039,7 +3042,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' ]`
@@ -3053,9 +3056,9 @@ 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");
-  return;
+  if (a > b) console.log('a is bigger');
+  else console.log('b is bigger');
+  return
   a + b;
 }
 
@@ -3094,13 +3097,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';
   }
 };
 
@@ -3129,7 +3132,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);
@@ -3184,7 +3187,7 @@ The `getList` function receives an array as its argument. Between the parenthese
 
 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 `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:
 
@@ -3198,7 +3201,7 @@ The following function would have returned an object:
 ###### 99. What's the output?
 
 ```javascript
-const name = "Lydia";
+const name = 'Lydia';
 
 console.log(name());
 ```
@@ -3230,8 +3233,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`
@@ -3257,7 +3260,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);
@@ -3289,16 +3292,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");
+  myPromise().then(res => console.log(res));
+  console.log('second');
 }
 
 async function secondFunction() {
   console.log(await myPromise());
-  console.log("second");
+  console.log('second');
 }
 
 firstFunction();
@@ -3336,8 +3339,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);
@@ -3397,13 +3400,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);
 ```
@@ -3442,7 +3445,7 @@ const colorConfig = {
   yellow: false,
 };
 
-const colors = ["pink", "red", "blue"];
+const colors = ['pink', 'red', 'blue'];
 
 console.log(colorConfig.colors[1]);
 ```
@@ -3471,7 +3474,7 @@ JavaScript interprets (or unboxes) statements. When we use bracket notation, it
 ###### 107. What's its value?
 
 ```javascript
-console.log("❤️" === "❤️");
+console.log('❤️' === '❤️');
 ```
 
 - A: `true`
@@ -3492,14 +3495,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`
@@ -3524,10 +3527,10 @@ With `splice` method, we modify the original array by deleting, replacing or add
 ###### 109. What's the output?
 
 ```javascript
-const food = ["🍕", "🍫", "🥑", "🍔"];
+const food = ['🍕', '🍫', '🥑', '🍔'];
 const info = { favoriteFood: food[0] };
 
-info.favoriteFood = "🍝";
+info.favoriteFood = '🍝';
 
 console.log(food);
 ```
@@ -3581,7 +3584,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' }
 ```
 
@@ -3593,11 +3596,11 @@ JSON.parse(jsonArray); // { name: 'Lydia' }
 ###### 111. What's the output?
 
 ```javascript
-let name = "Lydia";
+let name = 'Lydia';
 
 function getName() {
   console.log(name);
-  let name = "Sarah";
+  let name = 'Sarah';
 }
 
 getName();
@@ -3620,7 +3623,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);
@@ -3638,11 +3641,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();
@@ -3688,7 +3691,7 @@ console.log(two.next().value); // undefined
 ###### 113. What's the output?
 
 ```javascript
-console.log(`${((x) => x)("I love")} to program`);
+console.log(`${(x => x)('I love')} to program`);
 ```
 
 - A: `I love to program`
@@ -3713,7 +3716,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),
 };
 
@@ -3730,9 +3733,9 @@ config = null;
 
 #### Answer: 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.
+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).
 
@@ -3745,16 +3748,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
@@ -3781,14 +3784,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);
@@ -3847,7 +3850,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)]);
 ```
@@ -3873,11 +3876,11 @@ With the `+=` operand, we're incrementing the value of `num` by `1`. `num` had t
 
 ```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}`;
@@ -3915,10 +3918,10 @@ With the optional chaining operator `?.`, we no longer have to explicitly check
 ###### 120. What's the output?
 
 ```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!`);
 }
@@ -3974,10 +3977,10 @@ The `language` method is a `setter`. Setters don't hold an actual value, their p
 ###### 122. What's the output?
 
 ```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`
@@ -4002,7 +4005,7 @@ console.log(!typeof name === "string");
 ###### 123. What's the output?
 
 ```javascript
-const add = (x) => (y) => (z) => {
+const add = x => y => z => {
   console.log(x, y, z);
   return x + y + z;
 };
@@ -4092,20 +4095,20 @@ 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}`;
 }
 
-console.log(getFine(130, 300));
+console.log(getFine(130, 300))
 ```
 
 - A: The driver drove 130 and has to pay 300
@@ -4128,8 +4131,8 @@ With the `Intl.NumberFormat` method, we can format numeric values to any locale.
 ###### 127. What's the output?
 
 ```javascript
-const spookyItems = ["👻", "🎃", "🕸"];
-({ item: spookyItems[3] } = { item: "💀" });
+const spookyItems = ['👻', '🎃', '🕸'];
+({ item: spookyItems[3] } = { item: '💀' });
 
 console.log(spookyItems);
 ```
@@ -4154,7 +4157,7 @@ By destructuring objects, we can unpack values from the right-hand object, and a
 ###### 128. What's the output?
 
 ```javascript
-const name = "Lydia Hallie";
+const name = 'Lydia Hallie';
 const age = 21;
 
 console.log(Number.isNaN(name));
@@ -4190,7 +4193,7 @@ const randomValue = 21;
 
 function getInfo() {
   console.log(typeof randomValue);
-  const randomValue = "Lydia Hallie";
+  const randomValue = 'Lydia Hallie';
 }
 
 getInfo();
@@ -4216,7 +4219,7 @@ Variables declared with the `const` keyword are not referenceable before their i
 ###### 130. What's the output?
 
 ```javascript
-const myPromise = Promise.resolve("Woah some cool data");
+const myPromise = Promise.resolve('Woah some cool data');
 
 (async () => {
   try {
@@ -4224,7 +4227,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!');
   }
 })();
 ```
@@ -4249,7 +4252,7 @@ In the `try` block, we're logging the awaited value of the `myPromise` variable:
 ###### 131. What's the output?
 
 ```javascript
-const emojis = ["🥑", ["✨", "✨", ["🍕", "🍕"]]];
+const emojis = ['🥑', ['✨', '✨', ['🍕', '🍕']]];
 
 console.log(emojis.flat(1));
 ```
@@ -4322,19 +4325,19 @@ We invoke `counterTwo.increment()`, which sets `count` to `3`. Then, we log the
 ###### 133. What's the output?
 
 ```javascript
-const myPromise = Promise.resolve(Promise.resolve("Promise"));
+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!");
+  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!");
+  console.log(`${res} 2!`)
+  setTimeout(() => console.log('Timeout 2!'), 0);
+  console.log('Last line 2!');
 }
 
 funcOne();
@@ -4355,7 +4358,7 @@ First, we invoke `funcOne`. On the first line of `funcOne`, we call the _asynchr
 
 Then we call the `myPromise` promise, which is an _asynchronous_ operation.
 
-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.
+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.
 
@@ -4379,7 +4382,7 @@ export default function sum(x) {
 }
 
 // index.js
-import * as sum from "./sum";
+import * as sum from './sum';
 ```
 
 - A: `sum(4)`
@@ -4396,12 +4399,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);
 ```
 
@@ -4432,13 +4435,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;
 ```
 
@@ -4468,7 +4471,7 @@ Then, we access a property value on the proxy object, the `get` property on the
 ###### 136. Which of the following will modify the `person` object?
 
 ```javascript
-const person = { name: "Lydia Hallie" };
+const person = { name: 'Lydia Hallie' };
 
 Object.seal(person);
 ```
@@ -4496,9 +4499,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',
   },
 };
 
@@ -4527,7 +4530,7 @@ However, it only _shallowly_ freezes the object, meaning that only _direct_ prop
 ###### 138. What's the output?
 
 ```javascript
-const add = (x) => x + x;
+const add = x => x + x;
 
 function myFunc(num = 2, value = add(num)) {
   console.log(num, value);
@@ -4560,21 +4563,21 @@ Then, we invoked `myFunc(3)` and passed the value `3` as the value for the argum
 
 ```javascript
 class Counter {
-  #number = 10;
+  #number = 10
 
   increment() {
-    this.#number++;
+    this.#number++
   }
 
   getNum() {
-    return this.#number;
+    return this.#number
   }
 }
 
-const counter = new Counter();
-counter.increment();
+const counter = new Counter()
+counter.increment()
 
-console.log(counter.#number);
+console.log(counter.#number)
 ```
 
 - A: `10`
@@ -4598,8 +4601,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) {
@@ -4642,8 +4645,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) {
@@ -4651,9 +4654,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);
 ```
@@ -4722,11 +4725,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;
 ```
 
@@ -4781,11 +4784,11 @@ Objects aren't iterable by default. An iterable is an iterable if the iterator p
 let count = 0;
 const nums = [0, 1, 2, 3];
 
-nums.forEach((num) => {
-  if (num) count += 1;
-});
+nums.forEach(num => {
+	if (num) count += 1
+})
 
-console.log(count);
+console.log(count)
 ```
 
 - A: 1
@@ -4809,12 +4812,12 @@ The `if` condition within the `forEach` loop checks whether the value of `num` i
 
 ```javascript
 function getFruit(fruits) {
-  console.log(fruits?.[1]?.[1]);
+	console.log(fruits?.[1]?.[1])
 }
 
-getFruit([["🍊", "🍌"], ["🍍"]]);
-getFruit();
-getFruit([["🍍"], ["🍊", "🍌"]]);
+getFruit([['🍊', '🍌'], ['🍍']])
+getFruit()
+getFruit([['🍍'], ['🍊', '🍌']])
 ```
 
 - A: `null`, `undefined`, 🍌
@@ -4827,11 +4830,11 @@ getFruit([["🍍"], ["🍊", "🍌"]]);
 
 #### Answer: 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`.
+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.
+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.
 
@@ -4844,19 +4847,19 @@ Lastly, we're trying to log the second item in the `['🍊', '🍌']` subarray o
 
 ```javascript
 class Calc {
-  constructor() {
-    this.count = 0;
-  }
+	constructor() {
+		this.count = 0 
+	}
 
-  increase() {
-    this.count++;
-  }
+	increase() {
+		this.count ++
+	}
 }
 
-const calc = new Calc();
-new Calc().increase();
+const calc = new Calc()
+new Calc().increase()
 
-console.log(calc.count);
+console.log(calc.count)
 ```
 
 - A: `0`
@@ -4880,25 +4883,25 @@ 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 }) => {
-  if (email) {
-    Object.assign(user, { email });
-  }
+	if (email) {
+		Object.assign(user, { email })
+	}
 
-  if (password) {
-    user.password = password;
-  }
+	if (password) {
+		user.password = password
+	}
 
-  return user;
-};
+	return user
+}
 
-const updatedUser = updateUser({ email: "new@email.com" });
+const updatedUser = updateUser({ email: "new@email.com" })
 
-console.log(updatedUser === user);
+console.log(updatedUser === user)
 ```
 
 - A: `false`
@@ -4921,13 +4924,13 @@ The `updateUser` function updates the values of the `email` and `password` prope
 ###### 149. What's the output?
 
 ```javascript
-const fruit = ["🍌", "🍊", "🍎"];
+const fruit = ['🍌', '🍊', '🍎']
 
-fruit.slice(0, 1);
-fruit.splice(0, 1);
-fruit.unshift("🍇");
+fruit.slice(0, 1)
+fruit.splice(0, 1)
+fruit.unshift('🍇')
 
-console.log(fruit);
+console.log(fruit)
 ```
 
 - A: `['🍌', '🍊', '🍎']`
@@ -4942,7 +4945,7 @@ console.log(fruit);
 
 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 `['🍇', '🍊', '🍎']`.
+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>
@@ -4953,13 +4956,13 @@ 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]);
+console.log(animals[dog])
 ```
 
 - A: `{ emoji: "🐶", name: "Mara" }`
@@ -4972,11 +4975,11 @@ console.log(animals[dog]);
 
 #### Answer: B
 
-Object keys are converted to strings.
+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"}`.
+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.
+`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" }`.
 
@@ -4989,14 +4992,14 @@ Logging `animals[dog]`, or actually `animals["[object Object]"]` since convertin
 
 ```javascript
 const user = {
-  email: "my@email.com",
-  updateEmail: (email) => {
-    this.email = email;
-  },
-};
+	email: "my@email.com",
+	updateEmail: email => {
+		this.email = email
+	}
+}
 
-user.updateEmail("new@email.com");
-console.log(user.email);
+user.updateEmail("new@email.com")
+console.log(user.email)
 ```
 
 - A: `my@email.com`
@@ -5009,7 +5012,7 @@ console.log(user.email);
 
 #### Answer: 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.
+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>
@@ -5019,20 +5022,20 @@ The `updateEmail` function is an arrow function, and is not bound to the `user`
 ###### 152. What's the output?
 
 ```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]);
-  const res2 = await Promise.all([promise3, promise4]);
-  return [res1, res2];
-};
+	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));
+	.then(res => console.log(res))
+	.catch(err => console.log(err))
 ```
 
 - A: `[['First', 'Second'], ['Fourth']]`
@@ -5045,26 +5048,23 @@ runPromises()
 
 #### Answer: 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` 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` rejected with this value.
+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` 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` rejected with this value.
 
 </p>
 </details>
 
 ---
 
-###### 153. What should the value of `method` be to log `{ name: "Lydia", age: 22 }`?
+###### 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 =
-  /* ?? */
-  Object[method](
-    keys.map((_, i) => {
-      return [keys[i], values[i]];
-    })
-  ); // { name: "Lydia", age: 22 }
+const method = /* ?? */
+Object[method](keys.map((_, i) => {
+	return [keys[i], values[i]]
+})) // { name: "Lydia", age: 22 }
 ```
 
 - A: `entries`
@@ -5077,7 +5077,7 @@ const method =
 
 #### Answer: 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 which 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.
+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 which 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 }`
 
@@ -5089,18 +5089,18 @@ This creates an array of subarrays containing the correct keys and values, which
 ###### 154. What's the output?
 
 ```javascript
-const createMember = ({ email, address = {} }) => {
-  const validEmail = /.+\@.+\..+/.test(email);
-  if (!validEmail) throw new Error("Valid email pls");
+const createMember = ({ email, address = {}}) => {
+	const validEmail = /.+\@.+\..+/.test(email)
+	if (!validEmail) throw new Error("Valid email pls")
 
-  return {
-    email,
-    address: address ? address : null,
-  };
-};
+	return {
+		email,
+		address: address ? address : null
+	}
+}
 
-const member = createMember({ email: "my@email.com" });
-console.log(member);
+const member = createMember({ email: "my@email.com" })
+console.log(member)
 ```
 
 - A: `{ email: "my@email.com", address: null }`
@@ -5123,13 +5123,13 @@ The default value of `address` is an empty object `{}`. When we set the variable
 ###### 155. What's the output?
 
 ```javascript
-let randomValue = { name: "Lydia" };
-randomValue = 23;
+let randomValue = { name: "Lydia" }
+randomValue = 23
 
 if (!typeof randomValue === "string") {
-  console.log("It's not a string!");
+	console.log("It's not a string!")
 } else {
-  console.log("Yay it's a string!");
+	console.log("Yay it's a string!")
 }
 ```
 

From b9ccdec1cf38c76390065db4a62d5e8e89c3bbb7 Mon Sep 17 00:00:00 2001
From: ihavecoke <lb563@foxmail.com>
Date: Mon, 11 Sep 2023 00:47:52 +0800
Subject: [PATCH 18/31] Apply community guidelines for English and Chinese
 typography to format Simplified Chinese documentation --from
 https://sparanoid.com/note/chinese-copywriting-guidelines/

---
 zh-CN/README-zh_CN.md | 562 +++++++++++++++++++++---------------------
 1 file changed, 281 insertions(+), 281 deletions(-)

diff --git a/zh-CN/README-zh_CN.md b/zh-CN/README-zh_CN.md
index 12b932e5..71f0f9df 100644
--- a/zh-CN/README-zh_CN.md
+++ b/zh-CN/README-zh_CN.md
@@ -30,7 +30,7 @@ sayHi()
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D
+#### 答案：D
 
 在函数内部，我们首先通过 `var` 关键字声明了 `name` 变量。这意味着变量被提升了（内存空间在创建阶段就被设置好了），直到程序运行到定义变量位置之前默认值都是 `undefined`。因为当我们打印 `name` 变量时还没有执行到定义变量的位置，因此变量的值保持为 `undefined`。
 
@@ -60,7 +60,7 @@ for (let i = 0; i < 3; i++) {
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
 由于 JavaScript 的事件循环，`setTimeout` 回调会在*遍历结束后*才执行。因为在第一个遍历中遍历 `i` 是通过 `var` 关键字声明的，所以这个值是全局作用域下的。在遍历过程中，我们通过一元操作符 `++` 来每次递增 `i` 的值。当 `setTimeout` 回调执行的时候，`i` 的值等于 3。
 
@@ -94,7 +94,7 @@ shape.perimeter()
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
 注意 `diameter` 的值是一个常规函数，但是 `perimeter` 的值是一个箭头函数。
 
@@ -121,7 +121,7 @@ shape.perimeter()
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
 一元操作符加号尝试将 bool 转为 number。`true` 转换为 number 的话为 `1`，`false` 为 `0`。
 
@@ -153,7 +153,7 @@ const mouse = {
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
 在 JavaScript 中，所有对象的 keys 都是字符串（除非对象是 Symbol）。尽管我们可能不会定义它们为字符串，但它们在底层总会被转换为字符串。
 
@@ -188,7 +188,7 @@ console.log(d.greeting)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
 在 JavaScript 中，当设置两个对象彼此相等时，它们会通过*引用*进行交互。
 
@@ -223,7 +223,7 @@ console.log(b === c)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
 `new Number()` 是一个内建的函数构造器。虽然它看着像是一个 number，但它实际上并不是一个真实的 number：它有一堆额外的功能并且它是一个对象。
 
@@ -262,7 +262,7 @@ freddie.colorChange('orange')
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D
+#### 答案：D
 
 `colorChange` 是一个静态方法。静态方法被设计为只能被创建它们的构造器使用（也就是 `Chameleon`），并且不能传递给实例。因为 `freddie` 是一个实例，静态方法不能被实例使用，因此抛出了 `TypeError` 错误。
 
@@ -286,7 +286,7 @@ console.log(greetign)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
 代码打印出了一个对象，这是因为我们在全局对象上创建了一个空对象！当我们将 `greeting` 写错成 `greetign` 时，JS 解释器实际在上浏览器中将它视为 `global.greetign = {}`（或者 `window.greetign = {}`）。
 
@@ -315,7 +315,7 @@ bark.animal = 'dog'
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
 这在 JavaScript 中是可以的，因为函数是对象！（除了基本类型之外其他都是对象）
 
@@ -350,7 +350,7 @@ console.log(member.getFullName());
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
 你不能像常规对象那样，给构造函数添加属性。如果你想一次性给所有实例添加特性，你应该使用原型。因此本例中，使用如下方式：
 
@@ -390,7 +390,7 @@ console.log(sarah)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
 对于 `sarah`，我们没有使用 `new` 关键字。当使用 `new` 时，`this` 引用我们创建的空对象。当未使用 `new` 时，`this` 引用的是**全局对象**（global object）。
 
@@ -411,7 +411,7 @@ console.log(sarah)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D
+#### 答案：D
 
 在**捕获**（capturing）阶段中，事件从祖先元素向下传播到目标元素。当事件达到**目标**（target）元素后，**冒泡**（bubbling）才开始。
 
@@ -430,7 +430,7 @@ console.log(sarah)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
 除了**基本对象**（base object），所有对象都有原型。基本对象可以访问一些方法和属性，比如 `.toString`。这就是为什么你可以使用内置的 JavaScript 方法！所有这些方法在原型上都是可用的。虽然 JavaScript 不能直接在对象上找到这些方法，但 JavaScript 会沿着原型链找到它们，以便于你使用。
 
@@ -457,7 +457,7 @@ sum(1, '2')
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
 JavaScript 是一种**动态类型语言**：我们不指定某些变量的类型。值可以在你不知道的情况下自动转换成另一种类型，这种类型称为**隐式类型转换**（implicit type coercion）。**Coercion** 是指将一种类型转换为另一种类型。
 
@@ -485,7 +485,7 @@ console.log(number)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
 一元**后自增**运算符 `++`：
 
@@ -526,7 +526,7 @@ getPersonInfo`${person} is ${age} years old`
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
 如果使用标记模板字面量，第一个参数的值总是包含字符串的数组。其余的参数获取的是传递的表达式的值！
 
@@ -558,7 +558,7 @@ checkAge({ age: 18 })
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
 在测试相等性时，基本类型通过它们的值（value）进行比较，而对象通过它们的引用（reference）进行比较。JavaScript 检查对象是否具有对内存中相同位置的引用。
 
@@ -589,7 +589,7 @@ getAge(21)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
 扩展运算符（`...args`）会返回实参组成的数组。而数组是对象，因此 `typeof args` 返回 `"object"`。
 
@@ -618,7 +618,7 @@ getAge()
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
 使用 `"use strict"`，你可以确保不会意外地声明全局变量。我们从来没有声明变量 `age`，因为我们使用 `"use strict"`，它将抛出一个引用错误。如果我们不使用 `"use strict"`，它就会工作，因为属性 `age` 会被添加到全局对象中了。
 
@@ -641,7 +641,7 @@ const sum = eval('10*10+5')
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
 代码以字符串形式传递进来，`eval` 对其求值。如果它是一个表达式，就像本例中那样，它对表达式求值。表达式是 `10 * 10 + 5`。这将返回数字 `105`。
 
@@ -664,7 +664,7 @@ sessionStorage.setItem('cool_secret', 123)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
 关闭 **tab 标签页** 后，`sessionStorage` 存储的数据才会删除。
 
@@ -692,7 +692,7 @@ console.log(num)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
 使用 `var` 关键字，你可以用相同的名称声明多个变量。然后变量将保存最新的值。
 
@@ -723,7 +723,7 @@ set.has(1)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
 所有对象的键（不包括 Symbol）在底层都是字符串，即使你自己没有将其作为字符串输入。这就是为什么 `obj.hasOwnProperty('1')` 也返回 `true`。
 
@@ -749,7 +749,7 @@ console.log(obj)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
 如果你有两个名称相同的键，则键会被替换掉。它仍然位于第一个键出现的位置，但是值是最后出现那个键的值。
 
@@ -767,7 +767,7 @@ console.log(obj)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
 基本执行上下文是全局执行上下文：它是代码中随处可访问的内容。
 
@@ -793,7 +793,7 @@ for (let i = 1; i < 5; i++) {
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
 如果某个条件返回 `true`，则 `continue` 语句跳过本次迭代。
 
@@ -822,7 +822,7 @@ name.giveLydiaPizza()
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
 `String` 是内置的构造函数，我们可以向它添加属性。我只是在它的原型中添加了一个方法。基本类型字符串被自动转换为字符串对象，由字符串原型函数生成。因此，所有 string(string 对象) 都可以访问该方法！
 
@@ -852,7 +852,7 @@ console.log(a[b])
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
 对象的键被自动转换为字符串。我们试图将一个对象 `b` 设置为对象 `a` 的键，且相应的值为 `123`。
 
@@ -885,7 +885,7 @@ baz()
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
 我们有一个 `setTimeout` 函数，并首先调用它。然而，它是最后打印日志的。
 
@@ -938,7 +938,7 @@ WebAPI 不能随时向栈内添加内容。相反，它将回调函数推到名
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
 导致事件的最深嵌套的元素是事件的 target。你可以通过 `event.stopPropagation` 来停止冒泡。
 
@@ -965,7 +965,7 @@ WebAPI 不能随时向栈内添加内容。相反，它将回调函数推到名
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
 如果我们点击 `p`，我们会看到两个日志：`p` 和 `div`。在事件传播期间，有三个阶段：捕获、目标和冒泡。默认情况下，事件处理程序在冒泡阶段执行（除非将 `useCapture` 设置为 `true`）。它从嵌套最深的元素向外传播。
 
@@ -995,7 +995,7 @@ sayHi.bind(person, 21)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D
+#### 答案：D
 
 使用这两种方法，我们都可以传递我们希望 `this` 关键字引用的对象。但是，`.call` 是**立即执行**的。
 
@@ -1024,11 +1024,11 @@ typeof sayHi()
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
-`sayHi` 方法返回的是立即执行函数 (IIFE) 的返回值。此立即执行函数的返回值是 `0`， 类型是 `number`
+`sayHi` 方法返回的是立即执行函数 (IIFE) 的返回值。此立即执行函数的返回值是 `0`，类型是 `number`
 
-参考：只有 7 种内置类型：`null`，`undefined`，`boolean`，`number`，`string`，`object`, `symbol` 和 `bigint`。 ``function`` 不是一种类型，函数是对象，它的类型是``object``。
+参考：只有 7 种内置类型：`null`，`undefined`，`boolean`，`number`，`string`，`object`, `symbol` 和 `bigint`。``function`` 不是一种类型，函数是对象，它的类型是``object``。
 
 </p>
 </details>
@@ -1054,7 +1054,7 @@ undefined
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
 只有 8 种 [falsy](https://developer.mozilla.org/zh-CN/docs/Glossary/Falsy) 值：
 
@@ -1090,7 +1090,7 @@ console.log(typeof typeof 1)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
 `typeof 1` 返回 `"number"`。
 `typeof "number"` 返回 `"string"`。
@@ -1116,9 +1116,9 @@ console.log(numbers)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
-当你为数组设置超过数组长度的值的时候， JavaScript 会创建名为 "empty slots" 的东西。它们的值实际上是 `undefined`。你会看到以下场景：
+当你为数组设置超过数组长度的值的时候，JavaScript 会创建名为 "empty slots" 的东西。它们的值实际上是 `undefined`。你会看到以下场景：
 
 `[1, 2, 3, 7 x empty, 11]`
 
@@ -1153,13 +1153,13 @@ console.log(numbers)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
-`catch` 代码块接收参数 `x`。当我们传递参数时，这与之前定义的变量 `x` 不同 。这个 `x` 是属于 `catch` 块级作用域的。
+`catch` 代码块接收参数 `x`。当我们传递参数时，这与之前定义的变量 `x` 不同。这个 `x` 是属于 `catch` 块级作用域的。
 
 然后，我们将块级作用域中的变量赋值为 `1`，同时也设置了变量 `y` 的值。现在，我们打印块级作用域中的变量 `x`，值为 `1`。
 
-`catch` 块之外的变量 `x` 的值仍为 `undefined`， `y` 的值为 `2`。当我们在 `catch` 块之外执行 `console.log(x)` 时，返回 `undefined`，`y` 返回 `2`。
+`catch` 块之外的变量 `x` 的值仍为 `undefined`，`y` 的值为 `2`。当我们在 `catch` 块之外执行 `console.log(x)` 时，返回 `undefined`，`y` 返回 `2`。
 
 </p>
 </details>
@@ -1176,7 +1176,7 @@ console.log(numbers)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
 JavaScript 只有基本类型和对象。
 
@@ -1206,10 +1206,10 @@ JavaScript 只有基本类型和对象。
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
-`[1, 2]`是初始值。初始值将会作为首次调用时第一个参数 `acc` 的值。在第一次执行时， `acc` 的值是 `[1, 2]`， `cur` 的值是 `[0, 1]`。合并它们，结果为 `[1, 2, 0, 1]`。
-第二次执行， `acc` 的值是 `[1, 2, 0, 1]`， `cur` 的值是 `[2, 3]`。合并它们，最终结果为 `[1, 2, 0, 1, 2, 3]`
+`[1, 2]`是初始值。初始值将会作为首次调用时第一个参数 `acc` 的值。在第一次执行时，`acc` 的值是 `[1, 2]`，`cur` 的值是 `[0, 1]`。合并它们，结果为 `[1, 2, 0, 1]`。
+第二次执行，`acc` 的值是 `[1, 2, 0, 1]`，`cur` 的值是 `[2, 3]`。合并它们，最终结果为 `[1, 2, 0, 1, 2, 3]`
 
 </p>
 </details>
@@ -1232,13 +1232,13 @@ JavaScript 只有基本类型和对象。
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
-`null` 是 [falsy](https://developer.mozilla.org/zh-CN/docs/Glossary/Falsy)。 `!null` 的值是 `true`。 `!true` 的值是 `false`。
+`null` 是 [falsy](https://developer.mozilla.org/zh-CN/docs/Glossary/Falsy)。`!null` 的值是 `true`。`!true` 的值是 `false`。
 
-`""` 是 [falsy](https://developer.mozilla.org/zh-CN/docs/Glossary/Falsy)。 `!""` 的值是 `true`。  `!true` 的值是 `false`。
+`""` 是 [falsy](https://developer.mozilla.org/zh-CN/docs/Glossary/Falsy)。`!""` 的值是 `true`。`!true` 的值是 `false`。
 
-`1` 是 [truthy](https://developer.mozilla.org/zh-CN/docs/Glossary/Truthy)。 `!1` 的值是 `false`。 `!false` 的值是 `true`。
+`1` 是 [truthy](https://developer.mozilla.org/zh-CN/docs/Glossary/Truthy)。`!1` 的值是 `false`。`!false` 的值是 `true`。
 
 </p>
 </details>
@@ -1259,7 +1259,7 @@ setInterval(() => console.log('Hi'), 1000)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
 `setInterval` 返回一个唯一的 id。此 id 可被用于 `clearInterval` 函数来取消定时。
 
@@ -1282,7 +1282,7 @@ setInterval(() => console.log('Hi'), 1000)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
 string 类型是可迭代的。扩展运算符将迭代的每个字符映射成一个元素。
 
@@ -1313,11 +1313,11 @@ console.log(gen.next().value);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
-一般的函数在执行之后是不能中途停下的。但是，生成器函数却可以中途 “停下”，之后可以再从停下的地方继续。当生成器遇到`yield`关键字的时候，会生成`yield`后面的值。注意，生成器在这种情况下不 _返回_ (_return_ ) 值，而是 _生成_ (_yield_) 值。
+一般的函数在执行之后是不能中途停下的。但是，生成器函数却可以中途“停下”，之后可以再从停下的地方继续。当生成器遇到`yield`关键字的时候，会生成`yield`后面的值。注意，生成器在这种情况下不 _返回_ (_return_ ) 值，而是 _生成_ (_yield_) 值。
 
-首先，我们用`10`作为参数`i`来初始化生成器函数。然后使用`next()`方法一步步执行生成器。第一次执行生成器的时候，`i`的值为`10`，遇到第一个`yield`关键字，它要生成`i`的值。此时，生成器 “暂停”，生成了`10`。
+首先，我们用`10`作为参数`i`来初始化生成器函数。然后使用`next()`方法一步步执行生成器。第一次执行生成器的时候，`i`的值为`10`，遇到第一个`yield`关键字，它要生成`i`的值。此时，生成器“暂停”，生成了`10`。
 
 然后，我们再执行`next()`方法。生成器会从刚才暂停的地方继续，这个时候`i`还是`10`。于是我们走到了第二个`yield`关键字处，这时候需要生成的值是`i*2`，`i`为`10`，那么此时生成的值便是`20`。所以这道题的最终结果是`10,20`。
 
@@ -1347,7 +1347,7 @@ Promise.race([firstPromise, secondPromise]).then(res => console.log(res));
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
 当我们向`Promise.race`方法中传入多个`Promise`时，会进行 _优先_ 解析。在这个例子中，我们用`setTimeout`给`firstPromise`和`secondPromise`分别设定了 500ms 和 100ms 的定时器。这意味着`secondPromise`会首先解析出字符串`two`。那么此时`res`参数即为`two`，是为输出结果。
 
@@ -1374,14 +1374,14 @@ console.log(members);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D
+#### 答案：D
 
 
 首先我们声明了一个拥有`name`属性的对象 `person`。
 
 <img src="https://i.imgur.com/TML1MbS.png" width="200">
 
-然后我们又声明了一个变量`members`. 将首个元素赋值为变量`person`。 当设置两个对象彼此相等时，它们会通过 _引用_ 进行交互。但是当你将引用从一个变量分配至另一个变量时，其实只是执行了一个 _复制_ 操作。（注意一点，他们的引用 _并不相同_!）
+然后我们又声明了一个变量`members`. 将首个元素赋值为变量`person`。当设置两个对象彼此相等时，它们会通过 _引用_ 进行交互。但是当你将引用从一个变量分配至另一个变量时，其实只是执行了一个 _复制_ 操作。（注意一点，他们的引用 _并不相同_!）
 
 <img src="https://i.imgur.com/FSG5K3F.png" width="300">
 
@@ -1417,7 +1417,7 @@ for (const item in person) {
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
 在`for-in`循环中，我们可以通过对象的 key 来进行迭代，也就是这里的`name`和`age`。在底层，对象的 key 都是字符串（如果他们不是 Symbol 的话）。在每次循环中，我们将`item`设定为当前遍历到的 key.所以一开始，`item`是`name`，之后 `item`输出的则是`age`。
 
@@ -1440,13 +1440,13 @@ console.log(3 + 4 + "5");
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
 当所有运算符的 _优先级_ 相同时，计算表达式需要确定运算符的结合顺序，即从右到左还是从左往右。在这个例子中，我们只有一类运算符`+`，对于加法来说，结合顺序就是从左到右。
 
 `3 + 4`首先计算，得到数字`7`.
 
-由于类型的强制转换，`7 + '5'`的结果是`"75"`. JavaScript 将`7`转换成了字符串，可以参考问题 15.我们可以用`+`号把两个字符串连接起来。 `"7" + "5"` 就得到了`"75"`.
+由于类型的强制转换，`7 + '5'`的结果是`"75"`. JavaScript 将`7`转换成了字符串，可以参考问题 15.我们可以用`+`号把两个字符串连接起来。`"7" + "5"` 就得到了`"75"`.
 
 </p>
 </details>
@@ -1467,7 +1467,7 @@ const num = parseInt("7*6", 10);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
 只返回了字符串中第一个字母。设定了 _进制_ 后 (也就是第二个参数，指定需要解析的数字是什么进制：十进制、十六机制、八进制、二进制等等……),`parseInt` 检查字符串中的字符是否合法。一旦遇到一个在指定进制中不合法的字符后，立即停止解析并且忽略后面所有的字符。
 
@@ -1495,7 +1495,7 @@ const num = parseInt("7*6", 10);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
 对数组进行映射的时候，`num`就是当前循环到的元素。在这个例子中，所有的映射都是 number 类型，所以 if 中的判断`typeof num === "number"`结果都是`true`.map 函数创建了新数组并且将函数的返回值插入数组。
 
@@ -1530,9 +1530,9 @@ console.log(person, birthYear);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
-普通参数都是 _值_ 传递的，而对象则不同，是 _引用_ 传递。所以说，`birthYear`是值传递，因为他是个字符串而不是对象。当我们对参数进行值传递时，会创建一份该值的 _复制_ 。（可以参考问题 46）
+普通参数都是 _值_ 传递的，而对象则不同，是 _引用_ 传递。所以说，`birthYear`是值传递，因为他是个字符串而不是对象。当我们对参数进行值传递时，会创建一份该值的 _复制_。（可以参考问题 46）
 
 变量`birthYear`有一个对`"1997"`的引用，而传入的参数也有一个对`"1997"`的引用，但二者的引用并不相同。当我们通过给 `year`赋值`"1998"`来更新`year`的值的时候我们只是更新了`year`（的引用）。此时`birthYear`仍然是`"1997"`.
 
@@ -1570,9 +1570,9 @@ sayHi();
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D
+#### 答案：D
 
-通过`throw`语句，我么可以创建自定义错误。 而通过它，我们可以抛出异常。异常可以是一个<b>字符串</b>，一个 <b>数字</b>，一个 <b>布尔类型</b> 或者是一个 <b>对象</b>。在本例中，我们的异常是字符串`'Hello world'`.
+通过`throw`语句，我么可以创建自定义错误。而通过它，我们可以抛出异常。异常可以是一个<b>字符串</b>，一个 <b>数字</b>，一个 <b>布尔类型</b> 或者是一个 <b>对象</b>。在本例中，我们的异常是字符串`'Hello world'`.
 
 通过 `catch`语句，我们可以设定当`try`语句块中抛出异常后应该做什么处理。在本例中抛出的异常是字符串`'Hello world'`. `e`就是这个字符串，因此被输出。最终结果就是`'Oh an error: Hello world'`.
 
@@ -1601,7 +1601,7 @@ console.log(myCar.make);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
 返回属性的时候，属性的值等于 _返回的_ 值，而不是构造函数中设定的值。我们返回了字符串 `"Maserati"`，所以 `myCar.make`等于`"Maserati"`.
 
@@ -1629,7 +1629,7 @@ console.log(typeof y);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
 `let x = y = 10;` 是下面这个表达式的缩写：
 
@@ -1638,11 +1638,11 @@ y = 10;
 let x = y;
 ```
 
-我们设定`y`等于`10`时，我们实际上增加了一个属性`y`给全局对象 (浏览器里的`window`, Nodejs 里的`global`)。在浏览器中， `window.y`等于`10`.
+我们设定`y`等于`10`时，我们实际上增加了一个属性`y`给全局对象 (浏览器里的`window`, Nodejs 里的`global`)。在浏览器中，`window.y`等于`10`.
 
 然后我们声明了变量`x`等于`y`，也是`10`.但变量是使用 `let`声明的，它只作用于 _块级作用域_，仅在声明它的块中有效；就是案例中的立即调用表达式 (IIFE)。使用`typeof`操作符时，操作值 `x`没有被定义：因为我们在`x`声明块的外部，无法调用它。这就意味着`x`未定义。未分配或是未声明的变量类型为`"undefined"`. `console.log(typeof x)`返回`"undefined"`.
 
-而我们创建了全局变量`y`，并且设定`y`等于`10`.这个值在我们的代码各处都访问的到。 `y`已经被定义了，而且有一个`"number"`类型的值。 `console.log(typeof y)`返回`"number"`.
+而我们创建了全局变量`y`，并且设定`y`等于`10`.这个值在我们的代码各处都访问的到。`y`已经被定义了，而且有一个`"number"`类型的值。`console.log(typeof y)`返回`"number"`.
 
 </p>
 </details>
@@ -1679,7 +1679,7 @@ pet.bark();
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
 我们可以用`delete`关键字删除对象的属性，对原型也是适用的。删除了原型的属性后，该属性在原型链上就不可用了。在本例中，函数`bark`在执行了`delete Dog.prototype.bark`后不可用，然而后面的代码还在调用它。
 
@@ -1706,7 +1706,7 @@ console.log(set);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D
+#### 答案：D
 
 `Set`对象是独一无二的值的集合：也就是说同一个值在其中仅出现一次。
 
@@ -1742,11 +1742,11 @@ console.log(myCounter);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
 引入的模块是 _只读_ 的：你不能修改引入的模块。只有导出他们的模块才能修改其值。
 
-当我们给`myCounter`增加一个值的时候会抛出一个异常： `myCounter`是只读的，不能被修改。
+当我们给`myCounter`增加一个值的时候会抛出一个异常：`myCounter`是只读的，不能被修改。
 
 </p>
 </details>
@@ -1771,9 +1771,9 @@ console.log(delete age);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
-`delete`操作符返回一个布尔值： `true`指删除成功，否则返回`false`. 但是通过 `var`, `const` 或 `let` 关键字声明的变量无法用 `delete` 操作符来删除。
+`delete`操作符返回一个布尔值：`true`指删除成功，否则返回`false`. 但是通过 `var`, `const` 或 `let` 关键字声明的变量无法用 `delete` 操作符来删除。
 
 `name`变量由`const`关键字声明，所以删除不成功：返回 `false`. 而我们设定`age`等于`21`时，我们实际上添加了一个名为`age`的属性给全局对象。对象中的属性是可以删除的，全局对象也是如此，所以`delete age`返回`true`.
 
@@ -1799,7 +1799,7 @@ console.log(y);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
 我们可以通过解构赋值来解析来自对象的数组或属性的值，比如说：
 
@@ -1817,7 +1817,7 @@ console.log(y);
 
 <img src="https://i.imgur.com/NzGkMNk.png" width="200">
 
-也就是说，`y`等于数组的第一个值就是数字`1`.我们输出`y`， 返回`1`.
+也就是说，`y`等于数组的第一个值就是数字`1`.我们输出`y`，返回`1`.
 
 </p>
 </details>
@@ -1841,7 +1841,7 @@ console.log(admin);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
 扩展运算符`...`为对象的组合提供了可能。你可以复制对象中的键值对，然后把它们加到另一个对象里去。在本例中，我们复制了`user`对象键值对，然后把它们加入到`admin`对象中。`admin`对象就拥有了这些键值对，所以结果为`{ admin: true, name: "Lydia", age: 21 }`.
 
@@ -1869,7 +1869,7 @@ console.log(Object.keys(person));
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
 通过`defineProperty`方法，我们可以给对象添加一个新属性，或者修改已经存在的属性。而我们使用`defineProperty`方法给对象添加了一个属性之后，属性默认为 _不可枚举 (not enumerable)_. `Object.keys`方法仅返回对象中 _可枚举 (enumerable)_ 的属性，因此只剩下了`"name"`.
 
@@ -1901,11 +1901,11 @@ console.log(data);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
 `JSON.stringify`的第二个参数是 _替代者 (replacer)_. 替代者 (replacer) 可以是个函数或数组，用以控制哪些值如何被转换为字符串。
 
-如果替代者 (replacer) 是个 _数组_ ，那么就只有包含在数组中的属性将会被转化为字符串。在本例中，只有名为`"level"` 和 `"health"` 的属性被包括进来， `"username"`则被排除在外。 `data` 就等于 `"{"level":19, "health":90}"`.
+如果替代者 (replacer) 是个 _数组_，那么就只有包含在数组中的属性将会被转化为字符串。在本例中，只有名为`"level"` 和 `"health"` 的属性被包括进来，`"username"`则被排除在外。`data` 就等于 `"{"level":19, "health":90}"`.
 
 而如果替代者 (replacer) 是个 _函数_，这个函数将被对象的每个属性都调用一遍。
 函数返回的值会成为这个属性的值，最终体现在转化后的 JSON 字符串中（译者注：Chrome 下，经过实验，如果所有属性均返回同一个值的时候有异常，会直接将返回值作为结果输出而不会输出 JSON 字符串），而如果返回值为`undefined`，则该属性会被排除在外。
@@ -1938,7 +1938,7 @@ console.log(num2);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
 一元操作符 `++` _先返回_ 操作值，_再累加_ 操作值。`num1`的值是`10`，因为`increaseNumber`函数首先返回`num`的值，也就是`10`，随后再进行 `num`的累加。
 
@@ -1972,15 +1972,15 @@ multiply(value);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
-在 ES6 中，我们可以使用默认值初始化参数。如果没有给函数传参，或者传的参值为 `"undefined"` ，那么参数的值将是默认值。上述例子中，我们将 `value` 对象进行了解构并传到一个新对象中，因此 `x` 的默认值为 `{number：10}` 。
+在 ES6 中，我们可以使用默认值初始化参数。如果没有给函数传参，或者传的参值为 `"undefined"`，那么参数的值将是默认值。上述例子中，我们将 `value` 对象进行了解构并传到一个新对象中，因此 `x` 的默认值为 `{number：10}`。
 
-默认参数在调用时才会进行计算，每次调用函数时，都会创建一个新的对象。我们前两次调用 `multiply` 函数且不传递值，那么每一次 `x` 的默认值都为 `{number：10}` ，因此打印出该数字的乘积值为`20`。
+默认参数在调用时才会进行计算，每次调用函数时，都会创建一个新的对象。我们前两次调用 `multiply` 函数且不传递值，那么每一次 `x` 的默认值都为 `{number：10}`，因此打印出该数字的乘积值为`20`。
 
-第三次调用 `multiply` 时，我们传递了一个参数，即对象`value`。 `*=`运算符实际上是`x.number = x.number * 2`的简写，我们修改了`x.number`的值，并打印出值`20`。
+第三次调用 `multiply` 时，我们传递了一个参数，即对象`value`。`*=`运算符实际上是`x.number = x.number * 2`的简写，我们修改了`x.number`的值，并打印出值`20`。
 
-第四次，我们再次传递`value`对象。 `x.number`之前被修改为`20`，所以`x.number * = 2`打印为`40`。
+第四次，我们再次传递`value`对象。`x.number`之前被修改为`20`，所以`x.number * = 2`打印为`40`。
 
 </p>
 </details>
@@ -2001,7 +2001,7 @@ multiply(value);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D
+#### 答案：D
 
 `reducer` 函数接收 4 个参数：
 
@@ -2018,9 +2018,9 @@ multiply(value);
 
 在第一次调用时，累加器`x`为`1`，当前值`“y”`为`2`，打印出累加器和当前值：`1`和`2`。
 
-例子中我们的回调函数没有返回任何值，只是打印累加器的值和当前值。如果函数没有返回值，则默认返回`undefined`。 在下一次调用时，累加器为`undefined`，当前值为 “3”，因此`undefined`和`3`被打印出。
+例子中我们的回调函数没有返回任何值，只是打印累加器的值和当前值。如果函数没有返回值，则默认返回`undefined`。在下一次调用时，累加器为`undefined`，当前值为“3”，因此`undefined`和`3`被打印出。
 
-在第四次调用时，回调函数依然没有返回值。 累加器再次为 `undefined` ，当前值为 “4”。 `undefined`和`4`被打印出。
+在第四次调用时，回调函数依然没有返回值。累加器再次为 `undefined`，当前值为“4”。`undefined`和`4`被打印出。
 </p>
 </details>
 
@@ -2067,11 +2067,11 @@ class Labrador extends Dog {
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
-在子类中，在调用`super`之前不能访问到`this`关键字。 如果这样做，它将抛出一个`ReferenceError`：1 和 4 将引发一个引用错误。
+在子类中，在调用`super`之前不能访问到`this`关键字。如果这样做，它将抛出一个`ReferenceError`：1 和 4 将引发一个引用错误。
 
-使用`super`关键字，需要用给定的参数来调用父类的构造函数。 父类的构造函数接收`name`参数，因此我们需要将`name`传递给`super`。
+使用`super`关键字，需要用给定的参数来调用父类的构造函数。父类的构造函数接收`name`参数，因此我们需要将`name`传递给`super`。
 
 `Labrador`类接收两个参数，`name`参数是由于它继承了`Dog`，`size`作为`Labrador`类的额外属性，它们都需要传递给`Labrador`的构造函数，因此使用构造函数 2 正确完成。
 </p>
@@ -2100,11 +2100,11 @@ export const sum = (a, b) => a + b;
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
 `import`命令是编译阶段执行的，在代码运行之前。因此这意味着被导入的模块会先运行，而导入模块的文件会后执行。
 
-这是 CommonJS 中`require（）`和`import`之间的区别。使用`require()`，您可以在运行代码时根据需要加载依赖项。 如果我们使用`require`而不是`import`，`running index.js`，`running sum.js`，`3`会被依次打印。
+这是 CommonJS 中`require（）`和`import`之间的区别。使用`require()`，您可以在运行代码时根据需要加载依赖项。如果我们使用`require`而不是`import`，`running index.js`，`running sum.js`，`3`会被依次打印。
 
 </p>
 </details>
@@ -2127,9 +2127,9 @@ console.log(Symbol('foo') === Symbol('foo'))
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
-每个`Symbol`都是完全唯一的。传递给`Symbol`的参数只是给`Symbol`的一个描述。 `Symbol`的值不依赖于传递的参数。 当我们测试相等时，我们创建了两个全新的符号：第一个`Symbol（'foo'）`，第二个`Symbol（'foo'）`，这两个值是唯一的，彼此不相等，因此返回`false`。
+每个`Symbol`都是完全唯一的。传递给`Symbol`的参数只是给`Symbol`的一个描述。`Symbol`的值不依赖于传递的参数。当我们测试相等时，我们创建了两个全新的符号：第一个`Symbol（'foo'）`，第二个`Symbol（'foo'）`，这两个值是唯一的，彼此不相等，因此返回`false`。
 
 </p>
 </details>
@@ -2152,7 +2152,7 @@ console.log(name.padStart(2))
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
 使用`padStart`方法，我们可以在字符串的开头添加填充。传递给此方法的参数是字符串的总长度（包含填充）。字符串`Lydia Hallie`的长度为`12`，因此`name.padStart（13）`在字符串的开头只会插入 1（`13 - 12 = 1`）个空格。
 
@@ -2177,9 +2177,9 @@ console.log("🥑" + "💻");
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
-使用`+`运算符，您可以连接字符串。 上述情况，我们将字符串`“🥑”`与字符串`”💻“`连接起来，产生`”🥑💻“`。
+使用`+`运算符，您可以连接字符串。上述情况，我们将字符串`“🥑”`与字符串`”💻“`连接起来，产生`”🥑💻“`。
 
 </p>
 </details>
@@ -2210,9 +2210,9 @@ console.log(/* 2 */); // JavaScript loves you back ❤️
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
-`generator`函数在遇到`yield`关键字时会 “暂停” 其执行。 首先，我们需要让函数产生字符串`Do you love JavaScript?`，这可以通过调用`game.next().value`来完成。上述函数的第一行就有一个`yield`关键字，那么运行立即停止了，`yield`表达式本身没有返回值，或者说总是返回`undefined`，这意味着此时变量 `答案` 为`undefined`
+`generator`函数在遇到`yield`关键字时会“暂停”其执行。首先，我们需要让函数产生字符串`Do you love JavaScript?`，这可以通过调用`game.next().value`来完成。上述函数的第一行就有一个`yield`关键字，那么运行立即停止了，`yield`表达式本身没有返回值，或者说总是返回`undefined`，这意味着此时变量 `答案` 为`undefined`
 
 `next`方法可以带一个参数，该参数会被当作上一个 `yield` 表达式的返回值。当我们调用`game.next("Yes").value`时，先前的 `yield` 的返回值将被替换为传递给`next()`函数的参数`"Yes"`。此时变量 `答案` 被赋值为 `"Yes"`，`if`语句返回`false`，所以`JavaScript loves you back ❤️`被打印。
 
@@ -2235,7 +2235,7 @@ console.log(String.raw`Hello\nworld`);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
 `String.raw`函数是用来获取一个模板字符串的原始字符串的，它返回一个字符串，其中忽略了转义符（`\n`，`\v`，`\t`等）。但反斜杠可能造成问题，因为你可能会遇到下面这种类似情况：
 
@@ -2280,7 +2280,7 @@ console.log(data);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
 异步函数始终返回一个 promise。`await`仍然需要等待 promise 的解决：当我们调用`getData()`并将其赋值给`data`，此时`data`为`getData`方法返回的一个挂起的 promise，该 promise 并没有解决。
 
@@ -2314,9 +2314,9 @@ console.log(result);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
-`push()`方法返回新数组的长度。一开始，数组包含一个元素（字符串`"banana"`），长度为 1。 在数组中添加字符串`"apple"`后，长度变为 2，并将从`addToList`函数返回。
+`push()`方法返回新数组的长度。一开始，数组包含一个元素（字符串`"banana"`），长度为 1。在数组中添加字符串`"apple"`后，长度变为 2，并将从`addToList`函数返回。
 
 `push`方法修改原始数组，如果你想从函数返回数组而不是数组长度，那么应该在 push `item`之后返回`list`。
 
@@ -2345,13 +2345,13 @@ console.log(shape)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
 `Object.freeze`使得无法添加、删除或修改对象的属性（除非属性的值是另一个对象）。
 
 当我们创建变量`shape`并将其设置为等于冻结对象`box`时，`shape`指向的也是冻结对象。你可以使用`Object.isFrozen`检查一个对象是否被冻结，上述情况，`Object.isFrozen（shape）`将返回`true`。
 
-由于`shape`被冻结，并且`x`的值不是对象，所以我们不能修改属性`x`。 `x`仍然等于`10`，`{x：10，y：20}`被打印。
+由于`shape`被冻结，并且`x`的值不是对象，所以我们不能修改属性`x`。`x`仍然等于`10`，`{x：10，y：20}`被打印。
 
 注意，上述例子我们对属性`x`进行修改，可能会导致抛出 TypeError 异常（最常见但不仅限于严格模式下时）。
 
@@ -2376,7 +2376,7 @@ console.log(name);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D
+#### 答案：D
 
 当我们从右侧的对象解构属性`name`时，我们将其值`Lydia`分配给名为`myName`的变量。
 
@@ -2403,7 +2403,7 @@ function sum(a, b) {
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
 纯函数在相同的输入值时，需产生相同的输出，其输出的结果，与输入值以外的其他隐藏信息或状态无关，也和由 I/O 设备产生的外部输出无关。
 纯函数不会产生副作用。
@@ -2446,19 +2446,19 @@ console.log(addFunction(5 * 2));
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
-`add`函数是一个记忆函数。 通过记忆化，我们可以缓存函数的结果，以加快其执行速度。上述情况，我们创建一个`cache`对象，用于存储先前返回过的值。
+`add`函数是一个记忆函数。通过记忆化，我们可以缓存函数的结果，以加快其执行速度。上述情况，我们创建一个`cache`对象，用于存储先前返回过的值。
 
 如果我们使用相同的参数多次调用`addFunction`函数，它首先检查缓存中是否已有该值，如果有，则返回缓存值，这将节省执行时间。如果没有，那么它将计算该值，并存储在缓存中。
 
 我们用相同的值三次调用了`addFunction`函数：
 
-在第一次调用，`num`等于`10`时函数的值尚未缓存，if 语句`num in cache`返回`false`，else 块的代码被执行：`Calculated! 20`，并且其结果被添加到缓存对象，`cache`现在看起来像`{10：20}`。
+在第一次调用，`num`等于`10`时函数的值尚未缓存，if 语句`num in cache`返回`false`，else 块的代码被执行：`Calculated! 20`，并且其结果被添加到缓存对象，`cache`现在看起来像`{10:20}`。
 
-第二次，`cache`对象包含`10`的返回值。 if 语句 `num in cache` 返回`true`，`From cache! 20`被打印。
+第二次，`cache`对象包含`10`的返回值。if 语句 `num in cache` 返回`true`，`From cache! 20`被打印。
 
-第三次，我们将`5 * 2`(值为 10) 传递给函数。 `cache`对象包含`10`的返回值。 if 语句 `num in cache` 返回`true`，`From cache! 20`被打印。
+第三次，我们将`5 * 2`(值为 10) 传递给函数。`cache`对象包含`10`的返回值。if 语句 `num in cache` 返回`true`，`From cache! 20`被打印。
 
 </p>
 </details>
@@ -2487,9 +2487,9 @@ for (let item of myLifeSummedUp) {
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
-通过`for-in`循环，我们可以遍历一个对象**自有的**、**继承的**、**可枚举的**、**非 Symbol 的**属性。 在数组中，可枚举属性是数组元素的 “键”， 即它们的索引。 类似于下面这个对象：
+通过`for-in`循环，我们可以遍历一个对象**自有的**、**继承的**、**可枚举的**、**非 Symbol 的**属性。在数组中，可枚举属性是数组元素的“键”，即它们的索引。类似于下面这个对象：
 
 `{0: "☕", 1: "💻", 2: "🍷", 3: "🍫"}`
 
@@ -2517,11 +2517,11 @@ console.log(list)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
-数组元素可以包含任何值。 数字，字符串，布尔值，对象，数组，`null`，`undefined`，以及其他表达式，如日期，函数和计算。
+数组元素可以包含任何值。数字，字符串，布尔值，对象，数组，`null`，`undefined`，以及其他表达式，如日期，函数和计算。
 
-元素将等于返回的值。 `1 + 2`返回`3`，`1 * 2`返回'2`，'1 / 2`返回`0.5`。
+元素将等于返回的值。`1 + 2`返回`3`，`1 * 2`返回'2`，'1 / 2`返回`0.5`。
 
 </p>
 </details>
@@ -2546,13 +2546,13 @@ console.log(sayHi())
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
-默认情况下，如果不给函数传参，参数的值将为`undefined`。 上述情况，我们没有给参数`name`传值。 `name`等于`undefined`，并被打印。
+默认情况下，如果不给函数传参，参数的值将为`undefined`。上述情况，我们没有给参数`name`传值。`name`等于`undefined`，并被打印。
 
-在 ES6 中，我们可以使用默认参数覆盖此默认的`undefined`值。 例如：
+在 ES6 中，我们可以使用默认参数覆盖此默认的`undefined`值。例如：
 
-`function sayHi（name =“Lydia”）{...}`
+`function sayHi (name =“Lydia”){...}`
 
 在这种情况下，如果我们没有传递值或者如果我们传递`undefined`，`name`总是等于字符串`Lydia`
 
@@ -2589,11 +2589,11 @@ setTimeout(() => {
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
-`this`关键字的指向取决于使用它的位置。 在**函数**中，比如`getStatus`，`this`指向的是调用它的对象，上述例子中`data`对象调用了`getStatus`，因此`this`指向的就是`data`对象。 当我们打印`this.status`时，`data`对象的`status`属性被打印，即`"🥑"`。
+`this`关键字的指向取决于使用它的位置。在**函数**中，比如`getStatus`，`this`指向的是调用它的对象，上述例子中`data`对象调用了`getStatus`，因此`this`指向的就是`data`对象。当我们打印`this.status`时，`data`对象的`status`属性被打印，即`"🥑"`。
 
-使用`call`方法，可以更改`this`指向的对象。`data.getStatus.call(this)`是将`this`的指向由`data`对象更改为全局对象。在全局对象上，有一个名为`status`的变量，其值为`”😎“`。 因此打印`this.status`时，会打印`“😎”`。
+使用`call`方法，可以更改`this`指向的对象。`data.getStatus.call(this)`是将`this`的指向由`data`对象更改为全局对象。在全局对象上，有一个名为`status`的变量，其值为`”😎“`。因此打印`this.status`时，会打印`“😎”`。
 </p>
 </details>
 
@@ -2621,13 +2621,13 @@ console.log(person)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
-我们将变量`city`设置为等于`person`对象上名为`city`的属性的值。 这个对象上没有名为`city`的属性，因此变量`city`的值为`undefined`。
+我们将变量`city`设置为等于`person`对象上名为`city`的属性的值。这个对象上没有名为`city`的属性，因此变量`city`的值为`undefined`。
 
 请注意，我们没有引用`person`对象本身，只是将变量`city`设置为等于`person`对象上`city`属性的当前值。
 
-然后，我们将`city`设置为等于字符串`“Amsterdam”`。 这不会更改 person 对象：没有对该对象的引用。
+然后，我们将`city`设置为等于字符串`“Amsterdam”`。这不会更改 person 对象：没有对该对象的引用。
 
 因此打印`person`对象时，会返回未修改的对象。
 
@@ -2660,9 +2660,9 @@ console.log(checkAge(21))
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
-`const`和`let`声明的变量是具有**块级作用域**的，块是大括号（`{}`）之间的任何东西，即上述情况`if / else`语句的花括号。 由于块级作用域，我们无法在声明的块之外引用变量，因此抛出`ReferenceError`。
+`const`和`let`声明的变量是具有**块级作用域**的，块是大括号（`{}`）之间的任何东西，即上述情况`if / else`语句的花括号。由于块级作用域，我们无法在声明的块之外引用变量，因此抛出`ReferenceError`。
 
 </p>
 </details>
@@ -2685,9 +2685,9 @@ fetch('https://www.website.com/api/user/1')
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
-第二个`.then`中`res`的值等于前一个`.then`中的回调函数返回的值。 你可以像这样继续链接`.then`，将值传递给下一个处理程序。
+第二个`.then`中`res`的值等于前一个`.then`中的回调函数返回的值。你可以像这样继续链接`.then`，将值传递给下一个处理程序。
 
 </p>
 </details>
@@ -2710,9 +2710,9 @@ function getName(name) {
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
-使用逻辑非运算符`!`，将返回一个布尔值，使用`!! name`，我们可以确定`name`的值是真的还是假的。 如果`name`是真实的，那么`!name`返回`false`。 `!false`返回`true`。
+使用逻辑非运算符`!`，将返回一个布尔值，使用`!! name`，我们可以确定`name`的值是真的还是假的。如果`name`是真实的，那么`!name`返回`false`。`!false`返回`true`。
 
 通过将`hasName`设置为`name`，可以将`hasName`设置为等于传递给`getName`函数的值，而不是布尔值`true`。
 
@@ -2737,11 +2737,11 @@ console.log("I want pizza"[0])
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
-可以使用方括号表示法获取字符串中特定索引的字符，字符串中的第一个字符具有索引 0，依此类推。 在这种情况下，我们想要得到索引为 0 的元素，字符`'I'`被记录。
+可以使用方括号表示法获取字符串中特定索引的字符，字符串中的第一个字符具有索引 0，依此类推。在这种情况下，我们想要得到索引为 0 的元素，字符`'I'`被记录。
 
-请注意，IE7 及更低版本不支持此方法。 在这种情况下，应该使用`.charAt（）`
+请注意，IE7 及更低版本不支持此方法。在这种情况下，应该使用`.charAt（）`
 
 </p>
 </details>
@@ -2766,9 +2766,9 @@ sum(10)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
-您可以将默认参数的值设置为函数的另一个参数，只要另一个参数定义在其之前即可。 我们将值`10`传递给`sum`函数。 如果`sum`函数只接收 1 个参数，则意味着没有传递`num2`的值，这种情况下，`num1`的值等于传递的值`10`。 `num2`的默认值是`num1`的值，即`10`。 ```num1 + num2```返回`20`。
+您可以将默认参数的值设置为函数的另一个参数，只要另一个参数定义在其之前即可。我们将值`10`传递给`sum`函数。如果`sum`函数只接收 1 个参数，则意味着没有传递`num2`的值，这种情况下，`num1`的值等于传递的值`10`。`num2`的默认值是`num1`的值，即`10`。```num1 + num2```返回`20`。
 
 如果您尝试将默认参数的值设置为后面定义的参数，则可能导致参数的值尚未初始化，从而引发错误。比如：
 ```js
@@ -2806,9 +2806,9 @@ console.log(data)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
-使用`import * as name`语法，我们将`module.js`文件中所有`export`导入到`index.js`文件中，并且创建了一个名为`data`的新对象。 在`module.js`文件中，有两个导出：默认导出和命名导出。 默认导出是一个返回字符串 “Hello World” 的函数，命名导出是一个名为`name`的变量，其值为字符串`“Lydia”`。
+使用`import * as name`语法，我们将`module.js`文件中所有`export`导入到`index.js`文件中，并且创建了一个名为`data`的新对象。在`module.js`文件中，有两个导出：默认导出和命名导出。默认导出是一个返回字符串“Hello World”的函数，命名导出是一个名为`name`的变量，其值为字符串`“Lydia”`。
 
 `data`对象具有默认导出的`default`属性，其他属性具有指定 exports 的名称及其对应的值。
 
@@ -2838,7 +2838,7 @@ console.log(typeof member)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
 类是构造函数的语法糖，如果用构造函数的方式来重写`Person`类则将是：
 
@@ -2871,11 +2871,11 @@ console.log(newList.push(5))
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D
+#### 答案：D
 
-`.push`方法返回数组的长度，而不是数组本身！ 通过将`newList`设置为`[1,2,3].push(4)`，实际上`newList`等于数组的新长度：`4`。
+`.push`方法返回数组的长度，而不是数组本身！通过将`newList`设置为`[1,2,3].push(4)`，实际上`newList`等于数组的新长度：`4`。
 
-然后，尝试在`newList`上使用`.push`方法。 由于`newList`是数值`4`，抛出 TypeError。
+然后，尝试在`newList`上使用`.push`方法。由于`newList`是数值`4`，抛出 TypeError。
 
 </p>
 </details>
@@ -2903,9 +2903,9 @@ console.log(giveLydiaChocolate.prototype)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D
+#### 答案：D
 
-常规函数，例如`giveLydiaPizza`函数，有一个`prototype`属性，它是一个带有`constructor`属性的对象（原型对象）。 然而，箭头函数，例如`giveLydiaChocolate`函数，没有这个`prototype`属性。 尝试使用`giveLydiaChocolate.prototype`访问`prototype`属性时会返回`undefined`。
+常规函数，例如`giveLydiaPizza`函数，有一个`prototype`属性，它是一个带有`constructor`属性的对象（原型对象）。然而，箭头函数，例如`giveLydiaChocolate`函数，没有这个`prototype`属性。尝试使用`giveLydiaChocolate.prototype`访问`prototype`属性时会返回`undefined`。
 
 </p>
 </details>
@@ -2933,12 +2933,12 @@ for (const [x, y] of Object.entries(person)) {
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 `Object.entries()`方法返回一个给定对象自身可枚举属性的键值对数组，上述情况返回一个二维数组，数组每个元素是一个包含键和值的数组：
 
-`[['name'，'Lydia']，['age'，21]]`
+`[['name','Lydia'],['age', 21]]`
 
-使用`for-of`循环，我们可以迭代数组中的每个元素，上述情况是子数组。 我们可以使用`const [x，y]`在`for-of`循环中解构子数组。 `x`等于子数组中的第一个元素，`y`等于子数组中的第二个元素。
+使用`for-of`循环，我们可以迭代数组中的每个元素，上述情况是子数组。我们可以使用`const [x，y]`在`for-of`循环中解构子数组。`x`等于子数组中的第一个元素，`y`等于子数组中的第二个元素。
 
 第一个子阵列是`[“name”，“Lydia”]`，其中`x`等于`name`，而`y`等于`Lydia`。
 第二个子阵列是`[“age”，21]`，其中`x`等于`age`，而`y`等于`21`。
@@ -2966,7 +2966,7 @@ getItems(["banana", "apple"], "pear", "orange")
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D
+#### 答案：D
 
 `... args`是剩余参数，剩余参数的值是一个包含所有剩余参数的数组，**并且只能作为最后一个参数**。上述示例中，剩余参数是第二个参数，这是不可能的，并会抛出语法错误。
 
@@ -3009,7 +3009,7 @@ console.log(nums(1, 2))
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
 
 在 JavaScript 中，我们不必显式地编写分号 (`;`)，但是 JavaScript 引擎仍然在语句之后自动添加分号。这称为**自动分号插入**。例如，一个语句可以是变量，或者像`throw`、`return`、`break`这样的关键字。
@@ -3055,10 +3055,10 @@ console.log(member.name)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
 
-我们可以将类设置为等于其他类/函数构造函数。 在这种情况下，我们将`Person`设置为`AnotherPerson`。 这个构造函数的名字是`Sarah`，所以新的`Person`实例`member`上的 name 属性是`Sarah`。
+我们可以将类设置为等于其他类/函数构造函数。在这种情况下，我们将`Person`设置为`AnotherPerson`。这个构造函数的名字是`Sarah`，所以新的`Person`实例`member`上的 name 属性是`Sarah`。
 
 
 </p>
@@ -3085,10 +3085,10 @@ console.log(Object.keys(info))
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D
+#### 答案：D
 
 
-`Symbol`类型是不可枚举的。`Object.keys`方法返回对象上的所有可枚举的键属性。`Symbol`类型是不可见的，并返回一个空数组。 记录整个对象时，所有属性都是可见的，甚至是不可枚举的属性。
+`Symbol`类型是不可枚举的。`Object.keys`方法返回对象上的所有可枚举的键属性。`Symbol`类型是不可见的，并返回一个空数组。记录整个对象时，所有属性都是可见的，甚至是不可枚举的属性。
 
 这是`Symbol`的众多特性之一：除了表示完全唯一的值（防止对象意外名称冲突，例如当使用 2 个想要向同一对象添加属性的库时），您还可以`隐藏`这种方式对象的属性（尽管不完全。你仍然可以使用`Object.getOwnPropertySymbols()`方法访问 `Symbol`。
 
@@ -3118,14 +3118,14 @@ console.log(getUser(user))
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
-`getList`函数接收一个数组作为其参数。 在`getList`函数的括号之间，我们立即解构这个数组。 您可以将其视为：
+`getList`函数接收一个数组作为其参数。在`getList`函数的括号之间，我们立即解构这个数组。您可以将其视为：
 
  `[x, ...y] = [1, 2, 3, 4]`
 
 
-使用剩余的参数`... y`，我们将所有剩余参数放在一个数组中。 在这种情况下，其余的参数是`2`，`3`和`4`。 `y`的值是一个数组，包含所有其余参数。 在这种情况下，`x`的值等于`1`，所以当我们打印`[x，y]`时，会打印`[1，[2,3,4]]`。
+使用剩余的参数`... y`，我们将所有剩余参数放在一个数组中。在这种情况下，其余的参数是`2`，`3`和`4`。 `y`的值是一个数组，包含所有其余参数。在这种情况下，`x`的值等于`1`，所以当我们打印`[x，y]`时，会打印`[1，[2,3,4]]`。
 
  `getUser`函数接收一个对象。对于箭头函数，如果只返回一个值，我们不必编写花括号。但是，如果您想从一个箭头函数返回一个对象，您必须将它写在圆括号之间，否则两个花括号之间的所有内容都将被解释为一个块语句！在这种情况下，花括号之间的代码不是有效的 JavaScript 代码，因此会抛出 SyntaxError。
 
@@ -3154,12 +3154,12 @@ console.log(name())
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
 
 变量`name`保存字符串的值，该字符串不是函数，因此无法调用。
 
-当值不是预期类型时，会抛出`TypeErrors`。 JavaScript 期望`name`是一个函数，因为我们试图调用它。 但它是一个字符串，因此抛出`TypeError`：`name is not a function`
+当值不是预期类型时，会抛出`TypeErrors`。JavaScript 期望`name`是一个函数，因为我们试图调用它。但它是一个字符串，因此抛出`TypeError`：`name is not a function`
 
 当你编写了一些非有效的 JavaScript 时，会抛出语法错误，例如当你把`return`这个词写成`retrun`时。
 当 JavaScript 无法找到您尝试访问的值的引用时，抛出`ReferenceErrors`。
@@ -3186,12 +3186,12 @@ You should${'' && `n't`} see a therapist after so much JavaScript lol`
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
 
-`[]`是一个真值。 使用`&&`运算符，如果左侧值是真值，则返回右侧值。 在这种情况下，左侧值`[]`是一个真值，所以返回`Im`。
+`[]`是一个真值。使用`&&`运算符，如果左侧值是真值，则返回右侧值。在这种情况下，左侧值`[]`是一个真值，所以返回`Im`。
 
-`""`是一个假值。 如果左侧值是假的，则不返回任何内容。 `n't`不会被退回。
+`""`是一个假值。如果左侧值是假的，则不返回任何内容。`n't`不会被退回。
 
 </p>
 </details>
@@ -3216,15 +3216,15 @@ console.log(one, two, three)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
-使用`||`运算符，我们可以返回第一个真值。 如果所有值都是假值，则返回最后一个值。
+使用`||`运算符，我们可以返回第一个真值。如果所有值都是假值，则返回最后一个值。
 
-`（false || {} || null）`：空对象`{}`是一个真值。 这是第一个（也是唯一的）真值，它将被返回。`one`等于`{}`。
+`（false || {} || null）`：空对象`{}`是一个真值。这是第一个（也是唯一的）真值，它将被返回。`one`等于`{}`。
 
-`（null || false ||“”）`：所有值都是假值。 这意味着返回传递的值`""`。 `two`等于`""`。
+`（null || false ||“”）`：所有值都是假值。这意味着返回传递的值`""`。`two`等于`""`。
 
-`（[] || 0 ||“”）`：空数组`[]`是一个真值。 这是第一个返回的真值。 `three`等于`[]`。
+`（[] || 0 ||“”）`：空数组`[]`是一个真值。这是第一个返回的真值。`three`等于`[]`。
 
 </p>
 </details>
@@ -3258,12 +3258,12 @@ secondFunction()
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D
+#### 答案：D
 
 
 有了 promise，我们通常会说：当我想要调用某个方法，但是由于它可能需要一段时间，因此暂时将它放在一边。只有当某个值被 resolved/rejected，并且执行栈为空时才使用这个值。
 
-我们可以在`async`函数中通过`.then`和`await`关键字获得该值。 尽管我们可以通过`.then`和`await`获得 promise 的价值，但是它们的工作方式有所不同。
+我们可以在`async`函数中通过`.then`和`await`关键字获得该值。尽管我们可以通过`.then`和`await`获得 promise 的价值，但是它们的工作方式有所不同。
 
 在 `firstFunction`中，当运行到`myPromise`方法时我们将其放在一边，即 promise 进入微任务队列，其他后面的代码（`console.log('second')`）照常运行，因此`second`被打印出，`firstFunction`方法到此执行完毕，执行栈中宏任务队列被清空，此时开始执行微任务队列中的任务，`I have resolved`被打印出。
 
@@ -3297,15 +3297,15 @@ for (let item of set) {
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
-“+” 运算符不仅用于添加数值，还可以使用它来连接字符串。 每当 JavaScript 引擎发现一个或多个值不是数字时，就会将数字强制为字符串。 
+“+”运算符不仅用于添加数值，还可以使用它来连接字符串。每当 JavaScript 引擎发现一个或多个值不是数字时，就会将数字强制为字符串。 
 
-第一个是数字 1。 1 + 2 返回数字 3。
+第一个是数字 1。1 + 2 返回数字 3。
 
-但是，第二个是字符串 “Lydia”。 “Lydia” 是一个字符串，2 是一个数字：2 被强制转换为字符串。 “Lydia” 和 “2” 被连接起来，产生字符串 “Lydia2”。
+但是，第二个是字符串“Lydia”。 “Lydia”是一个字符串，2 是一个数字：2 被强制转换为字符串。 “Lydia”和“2”被连接起来，产生字符串“Lydia2”。
 
-`{name：“ Lydia”}`是一个对象。 数字和对象都不是字符串，因此将二者都字符串化。 每当我们对常规对象进行字符串化时，它就会变成`[Object object]`。 与 “2” 串联的 “ [Object object]” 成为 “[Object object]2”。
+`{name：“Lydia”}`是一个对象。数字和对象都不是字符串，因此将二者都字符串化。每当我们对常规对象进行字符串化时，它就会变成`[Object object]`。与“2”串联的“ [Object object]”成为“[Object object]2”。
 
 </p>
 </details>
@@ -3326,9 +3326,9 @@ Promise.resolve(5)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
-我们可以将我们想要的任何类型的值传递`Promise.resolve`，无论是否`promise`。 该方法本身返回带有已解析值的`Promise` (`<fulfilled>`)。 如果您传递常规函数，它将是具有常规值的已解决`promise`。 如果你通过了 promise，它将是一个已经 resolved 的且带有传的值的 promise。
+我们可以将我们想要的任何类型的值传递`Promise.resolve`，无论是否`promise`。该方法本身返回带有已解析值的`Promise` (`<fulfilled>`)。如果您传递常规函数，它将是具有常规值的已解决`promise`。如果你通过了 promise，它将是一个已经 resolved 的且带有传的值的 promise。
 
 上述情况，我们传了数字 5，因此返回一个 resolved 状态的 promise，resolve 值为`5`
 
@@ -3360,15 +3360,15 @@ compareMembers(person)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
-对象通过引用传递。 当我们检查对象的严格相等性（===）时，我们正在比较它们的引用。
+对象通过引用传递。当我们检查对象的严格相等性（===）时，我们正在比较它们的引用。
 
-我们将 “person2” 的默认值设置为 “person” 对象，并将 “person” 对象作为 “person1” 的值传递。
+我们将“person2”的默认值设置为“person”对象，并将“person”对象作为“person1”的值传递。
 
 这意味着两个值都引用内存中的同一位置，因此它们是相等的。
 
-运行 “ else” 语句中的代码块，并记录`They are the same!` 。
+运行“else”语句中的代码块，并记录`They are the same!`。
 
 </p>
 </details>
@@ -3400,14 +3400,14 @@ console.log(colorConfig.colors[1])
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D
+#### 答案：D
 
-在 JavaScript 中，我们有两种访问对象属性的方法：括号表示法或点表示法。 在此示例中，我们使用点表示法（`colorConfig.colors`）代替括号表示法（`colorConfig [“ colors”]`）。
+在 JavaScript 中，我们有两种访问对象属性的方法：括号表示法或点表示法。在此示例中，我们使用点表示法（`colorConfig.colors`）代替括号表示法（`colorConfig [“colors”]`）。
 
-使用点表示法，JavaScript 会尝试使用该确切名称在对象上查找属性。 在此示例中，JavaScript 尝试在 colorConfig 对象上找到名为 colors 的属性。 没有名为 “colors” 的属性，因此返回 “undefined”。
-然后，我们尝试使用`[1]`访问第一个元素的值。 我们无法对未定义的值执行此操作，因此会抛出`Cannot read property '1' of undefined`。
+使用点表示法，JavaScript 会尝试使用该确切名称在对象上查找属性。在此示例中，JavaScript 尝试在 colorConfig 对象上找到名为 colors 的属性。没有名为“colors”的属性，因此返回“undefined”。
+然后，我们尝试使用`[1]`访问第一个元素的值。我们无法对未定义的值执行此操作，因此会抛出`Cannot read property '1' of undefined`。
 
-JavaScript 解释（或取消装箱）语句。 当我们使用方括号表示法时，它会看到第一个左方括号`[`并一直进行下去，直到找到右方括号`]`。 只有这样，它才会评估该语句。 如果我们使用了 colorConfig [colors [1]]，它将返回 colorConfig 对象上 red 属性的值。
+JavaScript 解释（或取消装箱）语句。当我们使用方括号表示法时，它会看到第一个左方括号`[`并一直进行下去，直到找到右方括号`]`。只有这样，它才会评估该语句。如果我们使用了 colorConfig [colors [1]]，它将返回 colorConfig 对象上 red 属性的值。
 
 
 </p>
@@ -3427,9 +3427,9 @@ console.log('❤️' === '❤️')
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
-在内部，表情符号是 unicode。 heat 表情符号的 unicode 是`“ U + 2764 U + FE0F”`。 对于相同的表情符号，它们总是相同的，因此我们将两个相等的字符串相互比较，这将返回 true。
+在内部，表情符号是 unicode。heat 表情符号的 unicode 是`“U + 2764 U + FE0F”`。对于相同的表情符号，它们总是相同的，因此我们将两个相等的字符串相互比较，这将返回 true。
 
 </p>
 </details>
@@ -3458,9 +3458,9 @@ emojis.splice(1, 2, '✨')
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D
+#### 答案：D
 
-使用`splice`方法，我们通过删除，替换或添加元素来修改原始数组。 在这种情况下，我们从索引 1 中删除了 2 个元素（我们删除了`'🥑'`和`'😍'`），同时添加了✨emoji 表情。
+使用`splice`方法，我们通过删除，替换或添加元素来修改原始数组。在这种情况下，我们从索引 1 中删除了 2 个元素（我们删除了`'🥑'`和`'😍'`），同时添加了✨emoji 表情。
 
 `map`，`filter`和`slice`返回一个新数组，`find`返回一个元素，而`reduce`返回一个减小的值。
 
@@ -3488,11 +3488,11 @@ console.log(food)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
-我们将`info`对象上的`favoriteFood`属性的值设置为披萨表情符号 “🍕” 的字符串。字符串是原始数据类型。在 JavaScript 中，原始数据类型通过值起作用
+我们将`info`对象上的`favoriteFood`属性的值设置为披萨表情符号“🍕”的字符串。字符串是原始数据类型。在 JavaScript 中，原始数据类型通过值起作用
 
-在这种情况下，我们将`info`对象上的`favoriteFood`属性的值设置为等于`food`数组中的第一个元素的值，字符串为披萨表情符号（`'🍕'` ）。字符串是原始数据类型，并且通过值进行交互，我们更改`info`对象上`favoriteFood`属性的值。 food 数组没有改变，因为 favoriteFood 的值只是该数组中第一个元素的值的复制，并且与该元素上的元素没有相同的内存引用食物`[0]`。当我们记录食物时，它仍然是原始数组`['🍕'，'🍫'，'🥑'，'🍔']`。
+在这种情况下，我们将`info`对象上的`favoriteFood`属性的值设置为等于`food`数组中的第一个元素的值，字符串为披萨表情符号（`'🍕'`）。字符串是原始数据类型，并且通过值进行交互，我们更改`info`对象上`favoriteFood`属性的值。food 数组没有改变，因为 favoriteFood 的值只是该数组中第一个元素的值的复制，并且与该元素上的元素没有相同的内存引用食物`[0]`。当我们记录食物时，它仍然是原始数组`['🍕'，'🍫'，'🥑'，'🍔']`。
 
 </p>
 </details>
@@ -3513,7 +3513,7 @@ JSON.parse()
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
 使用`JSON.parse()`方法，我们可以将 JSON 字符串解析为 JavaScript 值。
 
@@ -3557,13 +3557,13 @@ getName()
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D 
+#### 答案：D 
 
-每个函数都有其自己的执行上下文。 `getName`函数首先在其自身的上下文（范围）内查找，以查看其是否包含我们尝试访问的变量`name`。 上述情况，`getName`函数包含其自己的`name`变量：我们用`let`关键字和`Sarah`的值声明变量`name`。
+每个函数都有其自己的执行上下文。`getName`函数首先在其自身的上下文（范围）内查找，以查看其是否包含我们尝试访问的变量`name`。上述情况，`getName`函数包含其自己的`name`变量：我们用`let`关键字和`Sarah`的值声明变量`name`。
 
-带有`let`关键字（和`const`）的变量被提升，但是与`var`不同，它不会被*** 初始化***。 在我们声明（初始化）它们之前，无法访问它们。 这称为 “暂时性死区”。 当我们尝试在声明变量之前访问变量时，JavaScript 会抛出`ReferenceError: Cannot access 'name' before initialization`。
+带有`let`关键字（和`const`）的变量被提升，但是与`var`不同，它不会被*** 初始化***。在我们声明（初始化）它们之前，无法访问它们。这称为“暂时性死区”。当我们尝试在声明变量之前访问变量时，JavaScript 会抛出`ReferenceError: Cannot access 'name' before initialization`。
 
-如果我们不在`getName`函数中声明`name`变量，则 javascript 引擎会查看原型链。会找到其外部作用域有一个名为`name`的变量，其值为`Lydia`。 在这种情况下，它将打印`Lydia`：
+如果我们不在`getName`函数中声明`name`变量，则 javascript 引擎会查看原型链。会找到其外部作用域有一个名为`name`的变量，其值为`Lydia`。在这种情况下，它将打印`Lydia`：
 
 ```javascript
 let name = 'Lydia'
@@ -3606,7 +3606,7 @@ console.log(two.next().value)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
 通过 `yield` 关键字，我们在 `Generator` 函数里执行`yield`表达式。通过 `yield*` 关键字，我们可以在一个`Generator` 函数里面执行（`yield`表达式）另一个 `Generator` 函数，或可遍历的对象 (如数组).
 
@@ -3645,7 +3645,7 @@ console.log(`${(x => x)('I love')} to program`)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
 带有模板字面量的表达式首先被执行。相当于字符串会包含表达式，这个立即执行函数 `(x => x)('I love')` 返回的值。我们向箭头函数 `x => x` 传递 `'I love'` 作为参数。`x` 等价于返回的 `'I love'`。这就是结果 `I love to program`。
 
@@ -3674,7 +3674,7 @@ config = null
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
 一般情况下当我们将对象赋值为 `null`，那些对象会被进行 _垃圾回收（garbage collected）_ 因为已经没有对这些对象的引用了。然而，`setInterval`的参数是一个箭头函数（所以上下文绑定到对象 `config` 了），回调函数仍然保留着对 `config`的引用。只要存在引用，对象就不会被垃圾回收。因为没有被垃圾回收，`setInterval` 的回调每 1000ms (1s) 会被调用一次。
 
@@ -3707,7 +3707,7 @@ myMap.get(() => 'greeting')
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
 当通过 `set` 方法添加一个键值对，一个传递给 `set`方法的参数将会是键名，第二个参数将会是值。在这个 case 里，键名为 _函数_ `() => 'greeting'`，值为`'Hello world'`。 `myMap` 现在就是 `{ () => 'greeting' => 'Hello world!' }`。
 
@@ -3747,13 +3747,13 @@ console.log(person)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
 函数 `changeAge` 和函数 `changeAgeAndName` 有着不同的参数，定义一个 _新_ 生成的对象 `{ ...person }`。这个对象有着所有 `person` 对象 中 k/v 值的副本。
 
 首项，我们调用 `changeAge` 函数并传递 `person` 对象作为它的参数。这个函数对 `age` 属性进行加一操作。`person` 现在是 `{ name: "Lydia", age: 22 }`。
 
-然后，我们调用函数 `changeAgeAndName` ，然而我们没有传递参数。取而代之，`x` 的值等价 _new_ 生成的对象：`{ ...person }`。因为它是一个新生成的对象，它并不会对对象 `person` 造成任何副作用。`person` 仍然等价于 `{ name: "Lydia", age: 22 }`。
+然后，我们调用函数 `changeAgeAndName`，然而我们没有传递参数。取而代之，`x` 的值等价 _new_ 生成的对象：`{ ...person }`。因为它是一个新生成的对象，它并不会对对象 `person` 造成任何副作用。`person` 仍然等价于 `{ name: "Lydia", age: 22 }`。
 
 </p>
 </details>
@@ -3776,9 +3776,9 @@ function sumValues(x, y, z) {
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
-通过展开操作符 `...`，我们可以 _暂开_ 单个可迭代的元素。函数 `sumValues` function 接收三个参数： `x`, `y` 和 `z`。`...[1, 2, 3]` 的执行结果为 `1, 2, 3`，将会传递给函数 `sumValues`。
+通过展开操作符 `...`，我们可以 _暂开_ 单个可迭代的元素。函数 `sumValues` function 接收三个参数：`x`, `y` 和 `z`。`...[1, 2, 3]` 的执行结果为 `1, 2, 3`，将会传递给函数 `sumValues`。
 
 </p>
 </details>
@@ -3802,9 +3802,9 @@ console.log(list[(num += 1)]);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
-通过 `+=` 操作符，我们对值 `num` 进行加 `1` 操作。 `num` 有初始值 `1`，因此 `1 + 1` 的执行结果为 `2`。数组 `list` 的第二项为 🥰，`console.log(list[2])` 输出 🥰.
+通过 `+=` 操作符，我们对值 `num` 进行加 `1` 操作。`num` 有初始值 `1`，因此 `1 + 1` 的执行结果为 `2`。数组 `list` 的第二项为 🥰，`console.log(list[2])` 输出 🥰.
 
 </p>
 </details>
@@ -3840,13 +3840,13 @@ console.log(member.getLastName?.());
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
 通过 ES10 或 TS3.7+[可选链操作符 `?.`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators/%E5%8F%AF%E9%80%89%E9%93%BE)，我们不再需要显式检测更深层的嵌套值是否有效。如果我们尝试获取 `undefined` 或 `null` 的值 (_nullish_)，表达将会短路并返回 `undefined`.
 
-`person.pet?.name`： `person` 有一个名为 `pet` 的属性： `person.pet` 不是 nullish。它有个名为 `name` 的属性，并返回字符串 `Mara`。
-`person.pet?.family?.name`： `person` 有一个名为 `pet` 的属性： `person.pet` 不是 nullish. `pet` _并没有_ 一个名为 `family` 的属性，`person.pet.family` 是 nullish。表达式返回 `undefined`。
-`person.getFullName?.()`： `person` 有一个名为 `getFullName` 的属性： `person.getFullName()` 不是 nullish 并可以被调用，返回字符串 `Lydia Hallie`。
+`person.pet?.name`：`person` 有一个名为 `pet` 的属性：`person.pet` 不是 nullish。它有个名为 `name` 的属性，并返回字符串 `Mara`。
+`person.pet?.family?.name`：`person` 有一个名为 `pet` 的属性：`person.pet` 不是 nullish. `pet` _并没有_ 一个名为 `family` 的属性，`person.pet.family` 是 nullish。表达式返回 `undefined`。
+`person.getFullName?.()`：`person` 有一个名为 `getFullName` 的属性：`person.getFullName()` 不是 nullish 并可以被调用，返回字符串 `Lydia Hallie`。
 `member.getLastName?.()`: 变量`member` 不存在，因此会抛出错误`ReferenceError`。
 
 </p>
@@ -3874,9 +3874,9 @@ if (groceries.indexOf("banana")) {
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
-我们传递了一个状态 `groceries.indexOf("banana")` 给 if 条件语句。`groceries.indexOf("banana")` 返回 `0`， 一个 falsy 的值。因为 if 条件语句的状态为 falsy，`else` 块区内的代码执行，并且 `We don't have to buy bananas!` 被输出。
+我们传递了一个状态 `groceries.indexOf("banana")` 给 if 条件语句。`groceries.indexOf("banana")` 返回 `0`，一个 falsy 的值。因为 if 条件语句的状态为 falsy，`else` 块区内的代码执行，并且 `We don't have to buy bananas!` 被输出。
 
 </p>
 </details>
@@ -3904,9 +3904,9 @@ console.log(config.language);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D
+#### 答案：D
 
-方法 `language` 是一个 `setter`。Setters 并不保存一个实际值，它们的使命在于 _修改_ 属性。当调用方法 `setter`， 返回 `undefined`。
+方法 `language` 是一个 `setter`。Setters 并不保存一个实际值，它们的使命在于 _修改_ 属性。当调用方法 `setter`，返回 `undefined`。
 
 </p>
 </details>
@@ -3930,9 +3930,9 @@ console.log(!typeof name === "string");
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
-`typeof name` 返回 `"string"`。字符串 `"string"` 是一个 truthy 的值，因此 `!typeof name` 返回一个布尔值 `false`。 `false === "object"` 和 `false === "string"` 都返回 `false`。
+`typeof name` 返回 `"string"`。字符串 `"string"` 是一个 truthy 的值，因此 `!typeof name` 返回一个布尔值 `false`。`false === "object"` 和 `false === "string"` 都返回 `false`。
 
 （如果我们想检测一个值的类型，我们应该用 `!==` 而不是 `!typeof`）
 
@@ -3960,7 +3960,7 @@ add(4)(5)(6);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
 函数 `add` 是一个返回 返回箭头函数的箭头函数 的箭头函数（still with me?）。第一个函数接收一个值为 `4` 的参数 `x`。我们调用第二个函数，它接收一个值为 `5` 的参数 `y`。然后我们调用第三个函数，它接收一个值为 `6` 的参数 `z`。当我们尝试在最后一个箭头函数中获取 `x`, `y` 和 `z` 的值，JS 引擎根据作用域链去找 `x` 和 `y` 的值。得到 `4` `5` `6`.
 
@@ -3994,9 +3994,9 @@ async function* range(start, end) {
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
-我们给 函数 range 传递： `Promise{1}`, `Promise{2}`, `Promise{3}`，Generator 函数 `range` 返回一个全是 async object promise 数组。我们将 async object 赋值给变量 `gen`，之后我们使用`for await ... of` 进行循环遍历。我们将返回的 Promise 实例赋值给 `item`： 第一个返回 `Promise{1}`， 第二个返回 `Promise{2}`，之后是 `Promise{3}`。因为我们正 _awaiting_ `item` 的值，resolved 状态的 promise，promise 数组的 resolved _值_ 以此为： `1`，`2`，`3`.
+我们给 函数 range 传递：`Promise{1}`, `Promise{2}`, `Promise{3}`，Generator 函数 `range` 返回一个全是 async object promise 数组。我们将 async object 赋值给变量 `gen`，之后我们使用`for await ... of` 进行循环遍历。我们将返回的 Promise 实例赋值给 `item`：第一个返回 `Promise{1}`，第二个返回 `Promise{2}`，之后是 `Promise{3}`。因为我们正 _awaiting_ `item` 的值，resolved 状态的 promise，promise 数组的 resolved _值_ 以此为：`1`，`2`，`3`.
 
 </p>
 </details>
@@ -4021,9 +4021,9 @@ myFunc(1, 2, 3);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D
+#### 答案：D
 
-`myFunc` 期望接收一个包含 `x`, `y` 和 `z` 属性的对象作为它的参数。因为我们仅仅传递三个单独的数字值 (1, 2, 3) 而不是一个含有 `x`, `y` 和 `z` 属性的对象 ({x: 1, y: 2, z: 3})， `x`, `y` 和 `z` 有着各自的默认值 `undefined`.
+`myFunc` 期望接收一个包含 `x`, `y` 和 `z` 属性的对象作为它的参数。因为我们仅仅传递三个单独的数字值 (1, 2, 3) 而不是一个含有 `x`, `y` 和 `z` 属性的对象 ({x: 1, y: 2, z: 3})，`x`, `y` 和 `z` 有着各自的默认值 `undefined`.
 
 </p>
 </details>
@@ -4058,7 +4058,7 @@ console.log(getFine(130, 300))
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
 通过方法 `Intl.NumberFormat`，我们可以格式化任意区域的数字值。我们对数字值 `130` 进行 `mile-per-hour` 作为 `unit` 的 `en-US` 区域 格式化，结果为 `130 mph`。对数字值 `300` 进行 `USD` 作为 `currency` 的 `en-US` 区域格式化，结果为 `$300.00`.
 
@@ -4084,7 +4084,7 @@ console.log(spookyItems);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
 通过解构对象们，我们可以从右手边的对象中拆出值，并且将拆出的值分配给左手边对象同名的属性。在这种情况下，我们将值 "💀" 分配给 `spookyItems[3]`。相当于我们正在篡改数组 `spookyItems`，我们给它添加了值 "💀"。当输出 `spookyItems` 时，结果为 `["👻", "🎃", "🕸", "💀"]`。
 
@@ -4114,11 +4114,11 @@ console.log(isNaN(age));
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
 通过方法 `Number.isNaN`，你可以检测你传递的值是否为 _数字值_ 并且是否等价于 `NaN`。`name` 不是一个数字值，因此 `Number.isNaN(name)` 返回 `false`。`age` 是一个数字值，但它不等价于 `NaN`，因此 `Number.isNaN(age)` 返回 `false`.
 
-通过方法 `isNaN`， 你可以检测你传递的值是否一个 number。`name` 不是一个 `number`，因此 `isNaN(name)` 返回 `true`. `age` 是一个 `number` 因此 `isNaN(age)` 返回 `false`.
+通过方法 `isNaN`，你可以检测你传递的值是否一个 number。`name` 不是一个 `number`，因此 `isNaN(name)` 返回 `true`. `age` 是一个 `number` 因此 `isNaN(age)` 返回 `false`.
 
 </p>
 </details>
@@ -4146,9 +4146,9 @@ getInfo();
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D
+#### 答案：D
 
-通过 `const` 关键字声明的变量在被初始化之前不可被引用：这被称之为 _暂时性死区_。在函数 `getInfo` 中，变量 `randomValue` 声明在`getInfo` 的作用域的此法环境中。在想要对 `typeof randomValue` 进行 log 之前，变量 `randomValue` 仍未被初始化： 错误`ReferenceError` 被抛出！JS 引擎并不会根据作用域链网上寻找该变量，因为我们已经在 `getInfo` 函数中声明了 `randomValue` 变量。
+通过 `const` 关键字声明的变量在被初始化之前不可被引用：这被称之为 _暂时性死区_。在函数 `getInfo` 中，变量 `randomValue` 声明在`getInfo` 的作用域的此法环境中。在想要对 `typeof randomValue` 进行 log 之前，变量 `randomValue` 仍未被初始化：错误`ReferenceError` 被抛出！JS 引擎并不会根据作用域链网上寻找该变量，因为我们已经在 `getInfo` 函数中声明了 `randomValue` 变量。
 
 </p>
 </details>
@@ -4179,9 +4179,9 @@ const myPromise = Promise.resolve("Woah some cool data");
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
-在 `try` 块区，我们打印 `myPromise` 变量的 awaited 值： `"Woah some cool data"`。因为`try` 块区没有错误抛出，`catch` 块区的代码并不执行。`finally` 块区的代码 _总是_ 执行，`"Oh finally!"` 被输出。
+在 `try` 块区，我们打印 `myPromise` 变量的 awaited 值：`"Woah some cool data"`。因为`try` 块区没有错误抛出，`catch` 块区的代码并不执行。`finally` 块区的代码 _总是_ 执行，`"Oh finally!"` 被输出。
 
 </p>
 </details>
@@ -4204,9 +4204,9 @@ console.log(emojis.flat(1));
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
-通过方法 `flat`， 我们可以创建一个新的，已被扁平化的数组。被扁平化的深度取决于我们传递的值。在这个 case 里，我们传递了值 `1` (并不必要，这是默认值)，相当于只有第一层的数组才会被连接。即这个 case 里的 `['🥑']` and `['✨', '✨', ['🍕', '🍕']]`。连接这两个数组得到结果 `['🥑', '✨', '✨', ['🍕', '🍕']]`.
+通过方法 `flat`，我们可以创建一个新的，已被扁平化的数组。被扁平化的深度取决于我们传递的值。在这个 case 里，我们传递了值 `1` (并不必要，这是默认值)，相当于只有第一层的数组才会被连接。即这个 case 里的 `['🥑']` and `['✨', '✨', ['🍕', '🍕']]`。连接这两个数组得到结果 `['🥑', '✨', '✨', ['🍕', '🍕']]`.
 
 </p>
 </details>
@@ -4244,9 +4244,9 @@ console.log(counterOne.count);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D
+#### 答案：D
 
-`counterOne` 是类 `Counter` 的一个实例。类 Counter 包含一个`count` 属性在它的构造函数里， 和一个 `increment` 方法。首先，我们通过 `counterOne.increment()` 调用方法 `increment` 两次。现在，`counterOne.count` 为 `2`.
+`counterOne` 是类 `Counter` 的一个实例。类 Counter 包含一个`count` 属性在它的构造函数里，和一个 `increment` 方法。首先，我们通过 `counterOne.increment()` 调用方法 `increment` 两次。现在，`counterOne.count` 为 `2`.
 
 <img src="https://i.imgur.com/KxLlTm9.png" width="400">
 
@@ -4291,13 +4291,13 @@ funcTwo();
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D
+#### 答案：D
 
 首先，我们调用 `funcOne`。在函数 `funcOne` 的第一行，我们调用`myPromise` promise _异步操作_。当 JS 引擎在忙于执行 promise，它继续执行函数 `funcOne`。下一行 _异步操作_ `setTimeout`，其回调函数被 Web API 调用。 (详情请参考我关于 event loop 的文章.)
 
-promise 和 timeout 都是异步操作，函数继续执行当 JS 引擎忙于执行 promise 和 处理 `setTimeout` 的回调。相当于 `Last line!` 首先被输出， 因为它不是异步操作。执行完 `funcOne` 的最后一行，promise 状态转变为 resolved，`Promise!` 被打印。然而，因为我们调用了 `funcTwo()`，调用栈不为空，`setTimeout` 的回调仍不能入栈。
+promise 和 timeout 都是异步操作，函数继续执行当 JS 引擎忙于执行 promise 和 处理 `setTimeout` 的回调。相当于 `Last line!` 首先被输出，因为它不是异步操作。执行完 `funcOne` 的最后一行，promise 状态转变为 resolved，`Promise!` 被打印。然而，因为我们调用了 `funcTwo()`，调用栈不为空，`setTimeout` 的回调仍不能入栈。
 
-我们现在处于 `funcTwo`，先 _awaiting_ myPromise。通过 `await` 关键字， 我们暂停了函数的执行直到 promise 状态变为 resolved (或 rejected)。然后，我们输出 `res` 的 awaited 值（因为 promise 本身返回一个 promise）。 接着输出 `Promise!`。
+我们现在处于 `funcTwo`，先 _awaiting_ myPromise。通过 `await` 关键字，我们暂停了函数的执行直到 promise 状态变为 resolved (或 rejected)。然后，我们输出 `res` 的 awaited 值（因为 promise 本身返回一个 promise）。接着输出 `Promise!`。
 
 下一行就是 _异步操作_ `setTimeout`，其回调函数被 Web API 调用。
 
@@ -4328,7 +4328,7 @@ import * as sum from "./sum";
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
 使用符号 `*`，我们引入文件中的所有值，包括默认和具名。如果我们有以下文件：
 
@@ -4388,7 +4388,7 @@ person.name;
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
 使用 Proxy 对象，我们可以给一个对象添加自定义行为。在这个 case，我们传递一个包含以下属性的对象 `handler` : `set` and `get`。每当我们 _设置_ 属性值时 `set` 被调用，每当我们 _获取_ 时 `get` 被调用。
 
@@ -4419,7 +4419,7 @@ Object.seal(person);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
 使用 `Object.seal` 我们可以防止新属性 _被添加_，或者存在属性 _被移除_.
 
@@ -4451,7 +4451,7 @@ Object.freeze(person);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
 使用方法 `Object.freeze` 对一个对象进行 _冻结_。不能对属性进行添加，修改，删除。
 
@@ -4483,7 +4483,7 @@ myFunc(3);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
 首先我们不传递任何参数调用 `myFunc()`。因为我们没有传递参数，`num` 和 `value` 获取它们各自的默认值：num 为 `2`，而 `value` 为函数 `add` 的返回值。对于函数 `add`，我们传递值为 2 的 `num` 作为参数。函数 `add` 返回 `4` 作为 `value` 的值。
 
@@ -4523,7 +4523,7 @@ console.log(counter.#number)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D
+#### 答案：D
 
 在 ES2020 中，通过 `#` 我们可以给 class 添加私有变量。在 class 的外部我们无法获取该值。当我们尝试输出 `counter.#number`，语法错误被抛出：我们无法在 class `Counter` 外部获取它！
 
@@ -4565,7 +4565,7 @@ obj.next(); // { value: "Lisa", done: false }
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
 为了遍历 `teams` 数组中对象的属性 `members` 中的每一项，我们需要将 `teams[i].members` 传递给 Generator 函数 `getMembers`。Generator 函数返回一个 generator 对象。为了遍历这个 generator 对象中的每一项，我们需要使用 `yield*`.
 
@@ -4604,7 +4604,7 @@ console.log(person.hobbies);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
 函数 `addHobby` 接受两个参数，`hobby` 和有着对象 `person` 中数组 `hobbies` 默认值的 `hobbies`。
 
@@ -4648,7 +4648,7 @@ const pet = new Flamingo();
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
 我们创建了类 `Flamingo` 的实例 `pet`。当我们实例化这个实例，`Flamingo` 中的 `constructor` 被调用。首相，输出 `"I'm pink. 🌸"`，之后我们调用`super()`。`super()` 调用父类的构造函数，`Bird`。`Bird` 的构造函数被调用，并输出 `"I'm a bird. 🦢"`。
 
@@ -4676,7 +4676,7 @@ const emojis = ["🎄", "🎅🏼", "🎁", "⭐"];
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D
+#### 答案：D
 
 `const` 关键字意味着我们不能 _重定义_ 变量中的值，它 _仅可读_。然而，值本身不可修改。数组 `emojis` 中的值可被修改，如 push 新的值，拼接，又或者将数组的长度设置为 0。
 
@@ -4704,7 +4704,7 @@ const person = {
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
 对象默认并不是可迭代的。如果迭代规则被定义，则一个对象是可迭代的（An iterable is an iterable if the iterator protocol is present）。我们可以通过添加迭代器 symbol `[Symbol.iterator]` 来定义迭代规则，其返回一个 generator 对象，比如说构建一个 generator 函数 `*[Symbol.iterator]() {}`。如果我们想要返回数组 `["Lydia Hallie", 21]`: `yield* Object.values(this)`，这个 generator 函数一定要 yield 对象 `person` 的`Object.values`。
 
@@ -4732,9 +4732,9 @@ console.log(count)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
-在 `forEach` 循环内部的 `if` 会判断 `num` 的值是 truthy 或者是 falsy。因为 `nums` 数组的第一个数字是 `0`，一个 falsy 值， `if` 语句代码块不会被执行。`count` 仅仅在 `nums` 数组的其他 3 个数字 `1`，`2`，`3` 时加 1。因为 `count` 执行了 3 次加 `1` 运算，所以 `count` 的值为 `3`。
+在 `forEach` 循环内部的 `if` 会判断 `num` 的值是 truthy 或者是 falsy。因为 `nums` 数组的第一个数字是 `0`，一个 falsy 值，`if` 语句代码块不会被执行。`count` 仅仅在 `nums` 数组的其他 3 个数字 `1`，`2`，`3` 时加 1。因为 `count` 执行了 3 次加 `1` 运算，所以 `count` 的值为 `3`。
 
 </p>
 </details>
@@ -4761,15 +4761,15 @@ getFruit([['🍍'], ['🍊', '🍌']])
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D
+#### 答案：D
 
-`?` 允许我们去选择性地访问对象内部更深层的嵌套属性。 我们尝试打印 `fruits` 数组索引值为 `1` 的子数组内部的索引值为 `1` 的元素。 如果在 `fruits` 数组索引值 为 `1` 的位置不存在元素，会直接返回 `undefined`。 如果 `fruits` 数组在索引值为 `1` 的位置存在元素，但是子数组在索引值为 `1` 的位置不存在元素，也会返回 `undefined`。
+`?` 允许我们去选择性地访问对象内部更深层的嵌套属性。我们尝试打印 `fruits` 数组索引值为 `1` 的子数组内部的索引值为 `1` 的元素。如果在 `fruits` 数组索引值 为 `1` 的位置不存在元素，会直接返回 `undefined`。如果 `fruits` 数组在索引值为 `1` 的位置存在元素，但是子数组在索引值为 `1` 的位置不存在元素，也会返回 `undefined`。
 
-首先，我们尝试打印 `[['🍊', '🍌'], ['🍍']]` 的子数组 `['🍍']` 的第 2 个元素。这个子数组只包含一个元素，也就意味着在索引值为 `1` 的位置不存在元素，所以返回的是 `undefined` 。
+首先，我们尝试打印 `[['🍊', '🍌'], ['🍍']]` 的子数组 `['🍍']` 的第 2 个元素。这个子数组只包含一个元素，也就意味着在索引值为 `1` 的位置不存在元素，所以返回的是 `undefined`。
 
-其次，我们在没有传入任何参数调用了 `getFruits` 函数，也就意味着形参 `fruits` 的默认值为`undefined`。因为我们选择性地链接了 `fruits` 在索引值为 `1` 的元素，因为在索引值为 `1` 的位置不存在元素，因此返回的是 `undefined` 。
+其次，我们在没有传入任何参数调用了 `getFruits` 函数，也就意味着形参 `fruits` 的默认值为`undefined`。因为我们选择性地链接了 `fruits` 在索引值为 `1` 的元素，因为在索引值为 `1` 的位置不存在元素，因此返回的是 `undefined`。
 
-最后，我们尝试打印 `['🍍'], ['🍊', '🍌']` 的子数组 `['🍊', '🍌']` 的第 2 个元素。子数组索引值为 `1`的位置为 `🍌` ，因此它被打印出了。
+最后，我们尝试打印 `['🍍'], ['🍊', '🍌']` 的子数组 `['🍊', '🍌']` 的第 2 个元素。子数组索引值为 `1`的位置为 `🍌`，因此它被打印出了。
 
 </p>
 </details>
@@ -4803,9 +4803,9 @@ console.log(calc.count)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
-我们设置 `calc` 变量为 `Calc` 类的一个新实例。 然后，我们初始化一个 `Calc` 的新实例，而且调用了这个实例的 `increase` 方法。因为 count 属性是在 `Calc` class 的 constructor 内部的，所以 count 属性不会在 `Calc` 的原型链上共享出去。这就意味着 calc 实例的 count 值不会被更新，count 仍然是 `0`。
+我们设置 `calc` 变量为 `Calc` 类的一个新实例。然后，我们初始化一个 `Calc` 的新实例，而且调用了这个实例的 `increase` 方法。因为 count 属性是在 `Calc` class 的 constructor 内部的，所以 count 属性不会在 `Calc` 的原型链上共享出去。这就意味着 calc 实例的 count 值不会被更新，count 仍然是 `0`。
 
 </p>
 </details>
@@ -4845,9 +4845,9 @@ console.log(updatedUser === user)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
- `updateUser` 函数更新 user 的 `email` 和 `password` 属性的值， 如果它们的值传入函数， 函数返回的就是 `user` 对象。 `updateUser` 函数的返回值是 `user` 对象，意味着 updatedUser 的值与 `user` 指向的是同一个 `user` 对象。`updatedUser === user` 为 `true`.
+ `updateUser` 函数更新 user 的 `email` 和 `password` 属性的值，如果它们的值传入函数，函数返回的就是 `user` 对象。`updateUser` 函数的返回值是 `user` 对象，意味着 updatedUser 的值与 `user` 指向的是同一个 `user` 对象。`updatedUser === user` 为 `true`.
 
 </p>
 </details>
@@ -4874,10 +4874,10 @@ console.log(fruit)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
-首先，我们在 fruit 数组上调用 `slice` 方法。 slice 方法不会修改原始数组，但是会返回从数组切片下来的值：香蕉 emoji。
-其次，我们在 fruit 数组上调用 `splice` 方法。 splice 方法会修改原始数组，也就意味着 fruit 数组此时为 `['🍊', '🍎']`。
+首先，我们在 fruit 数组上调用 `slice` 方法。slice 方法不会修改原始数组，但是会返回从数组切片下来的值：香蕉 emoji。
+其次，我们在 fruit 数组上调用 `splice` 方法。splice 方法会修改原始数组，也就意味着 fruit 数组此时为 `['🍊', '🍎']`。
 最后，我们在 fruit 数组上调用 `unshift` 方法，通过添加一个值的方式改变了原始数组，添加的是'🍇'，它成为了数组的第一个元素。现在 fruit 数组的组成为 `['🍇', '🍊', '🍎']`。
 
 </p>
@@ -4906,15 +4906,15 @@ console.log(animals[dog])
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
 对象的键会被转换为字符串。
 
-因为  `dog` 的值是一个对象，   `animals[dog]` 实际上意味着我们创建了一个叫做 `"object Object"` 的属性来代表新的对象。  `animals["object Object"]` 现在等于 `{ emoji: "🐶", name: "Mara"}`。
+因为  `dog` 的值是一个对象，`animals[dog]` 实际上意味着我们创建了一个叫做 `"object Object"` 的属性来代表新的对象。`animals["object Object"]` 现在等于 `{ emoji: "🐶", name: "Mara"}`。
 
 `cat` 也是一个对象，`animals[cat]` 实际上意味着我们在用新的 cat 的属性覆盖  `animals[``"``object Object``"``]` 的值。
 
-打印  `animals[dog]`，实际上是`animals["object Object"]`，这是因为转化`dog`对象为一个字符串结果 `"object Object"` ，所以返回 `{ emoji: "🐈", name: "Sara" }`。
+打印  `animals[dog]`，实际上是`animals["object Object"]`，这是因为转化`dog`对象为一个字符串结果 `"object Object"`，所以返回 `{ emoji: "🐈", name: "Sara" }`。
 
 </p>
 </details>
@@ -4943,9 +4943,9 @@ console.log(user.email)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
-`updateEmail` 函数是一个箭头函数，它没有和 `user` 对象绑定。这就意味着 `this` 关键字不会引用到 `user` 对象，但是会引用到全局对象。 `user` 对象内部的 `email` 的值不会更新。当打印 `user.email` 的时候， 原始值 `my@email.com` 被返回。
+`updateEmail` 函数是一个箭头函数，它没有和 `user` 对象绑定。这就意味着 `this` 关键字不会引用到 `user` 对象，但是会引用到全局对象。`user` 对象内部的 `email` 的值不会更新。当打印 `user.email` 的时候，原始值 `my@email.com` 被返回。
 
 </p>
 </details>
@@ -4979,9 +4979,9 @@ runPromises()
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D
+#### 答案：D
 
- `Promise.all` 方法可以并行式运行 promise。如果其中一个 promise 失败了，`Promise.all` 方法会带上被 reject 的 promise 的值_rejects_。在这个例子中， `promise3` 带着 `"Third"` 值 reject。我们在调用 `runPromises` 时在 `runPromises` 函数内部的 `catch` 方法去捕获任意 error 从而捕获到被 reject 的值。因为 `promise3` 带着 `"Third"` 被 reject，所以只有 `"Third"` 打印。
+ `Promise.all` 方法可以并行式运行 promise。如果其中一个 promise 失败了，`Promise.all` 方法会带上被 reject 的 promise 的值_rejects_。在这个例子中，`promise3` 带着 `"Third"` 值 reject。我们在调用 `runPromises` 时在 `runPromises` 函数内部的 `catch` 方法去捕获任意 error 从而捕获到被 reject 的值。因为 `promise3` 带着 `"Third"` 被 reject，所以只有 `"Third"` 打印。
 
 </p>
 </details>
@@ -5008,7 +5008,7 @@ Object[method](keys.map((_, i) => {
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
  `fromEntries` 方法可以将二维数组转换为对象。在每个子数组的第一个元素是 key，在每个子数组的第二个元素是 value。在这个例子中，我们映射了 `keys` 数组，它返回了一个数组，数组的第一个元素为 keys 数组当前索引的值，第二个元素为 values 数组当前索引的值。
 
@@ -5044,7 +5044,7 @@ console.log(member)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
  `address` 的默认值是一个空对象 `{}`。当我们设置 `member` 变量为 `createMember` 函数返回的对象，我们没有为 address 参数传值，意味着 address 的值为默认的空对象 `{}`。一个空对象是一个 truthy 值，意味着 `address ? address : null` 条件会返回 `true`。address 的值为空对象 `{}`。
 
@@ -5074,11 +5074,11 @@ if (!typeof randomValue === "string") {
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
- `if` 语句的条件判断 `!typeof randomValue` 的值是否等于 `"string"`。 `!` 操作符将这个值转化为一个布尔值。如果值是 truthy 的话，返回值会是 `false`，如果值是 falsy，返回值会是 `true`。在这里， `typeof randomValue` 的返回值是一个 truthy 值 `"number"`，意味着 `!typeof randomValue` 的值是一个布尔值 `false`。
+ `if` 语句的条件判断 `!typeof randomValue` 的值是否等于 `"string"`。`!` 操作符将这个值转化为一个布尔值。如果值是 truthy 的话，返回值会是 `false`，如果值是 falsy，返回值会是 `true`。在这里，`typeof randomValue` 的返回值是一个 truthy 值 `"number"`，意味着 `!typeof randomValue` 的值是一个布尔值 `false`。
 
- `!typeof randomValue === "string"` 总是返回 false，因为我们实际上是在执行 `false === "string"`。因为条件返回的是 `false`，所以 `else` 语句中的代码块会被运行，因此打印 `Yay it's a string!` 。
+ `!typeof randomValue === "string"` 总是返回 false，因为我们实际上是在执行 `false === "string"`。因为条件返回的是 `false`，所以 `else` 语句中的代码块会被运行，因此打印 `Yay it's a string!`。
 
 </p>
 </details>

From 936401200cacae524f65b53f7df26d2437b19375 Mon Sep 17 00:00:00 2001
From: ihavecoke <lb563@foxmail.com>
Date: Mon, 11 Sep 2023 01:00:14 +0800
Subject: [PATCH 19/31] Optimize zh-TW lang format

---
 zh-TW/README_zh-TW.md | 696 +++++++++++++++++++++---------------------
 1 file changed, 348 insertions(+), 348 deletions(-)

diff --git a/zh-TW/README_zh-TW.md b/zh-TW/README_zh-TW.md
index 08c171df..c171b62f 100644
--- a/zh-TW/README_zh-TW.md
+++ b/zh-TW/README_zh-TW.md
@@ -17,7 +17,7 @@
 
 ---
 
-歡迎在項目中使用它們 😃 我 _真的_ 很感激這個repo的參考，我創造了問題和解釋（是的，我很傷心lol），社區幫助我如此之多地維護和改進它！我很喜歡這個repo。 💪🏼 謝謝你，祝你玩得開心!
+歡迎在項目中使用它們 😃 我 _真的_ 很感激這個 repo 的參考，我創造了問題和解釋（是的，我很傷心 lol），社區幫助我如此之多地維護和改進它！我很喜歡這個 repo。 💪🏼 謝謝你，祝你玩得開心！
 
 ---
 
@@ -278,7 +278,7 @@ freddie.colorChange('orange')
 
 #### 答案：D
 
-`colorChange` 是一個靜態方法。靜態方法被設計爲只能被創造它們的建構子使用（也就是 `Chameleon` 中的 `constructor` ），並且不能傳遞給實例。因為 `freddie` 是一個實例，而靜態方法不能被實例使用，因此會抛出 `TypeError` 錯誤。
+`colorChange` 是一個靜態方法。靜態方法被設計爲只能被創造它們的建構子使用（也就是 `Chameleon` 中的 `constructor`），並且不能傳遞給實例。因為 `freddie` 是一個實例，而靜態方法不能被實例使用，因此會抛出 `TypeError` 錯誤。
 
 </p>
 </details>
@@ -289,7 +289,7 @@ freddie.colorChange('orange')
 
 ```javascript
 let greeting
-greetign = {} // 手殘打錯變數名稱!
+greetign = {} // 手殘打錯變數名稱！
 console.log(greetign)
 ```
 
@@ -302,7 +302,7 @@ console.log(greetign)
 
 #### 答案：A
 
-程式碼印出了一個物件，這是因為我們在全域物件上建立了一個空物件！當我們將 `greeting` 寫錯成 `greetign` 時，JS 解譯器實際上將它視爲 `global.greetign = {}` （或者在瀏覽器中視為 `window.greetign = {}`）。
+程式碼印出了一個物件，這是因為我們在全域物件上建立了一個空物件！當我們將 `greeting` 寫錯成 `greetign` 時，JS 解譯器實際上將它視爲 `global.greetign = {}`（或者在瀏覽器中視為 `window.greetign = {}`）。
 
 為了避免這個狀況，我們可以使用 `"use strict"`，來確保當你宣告變數時，必須賦值。
 
@@ -374,7 +374,7 @@ Person.prototype.getFullName = function () {
 }
 ```
 
-這樣一來， `member.getFullName()` 就能有效。這樣做有什麼好處？假設我們真的能如題將這個方法新增到建構函式本身，並不是每個 `Person` 實例都需要這個方法，但每個實例卻仍然擁有該属性，代表著這將佔據每個實例的記憶體，造成大量的記憶體空間因此浪費掉了。相反，如果我們只將它新增在原型中，那麼它只存在記憶體中的一個位置，而所有實例都可以使用它！
+這樣一來，`member.getFullName()` 就能有效。這樣做有什麼好處？假設我們真的能如題將這個方法新增到建構函式本身，並不是每個 `Person` 實例都需要這個方法，但每個實例卻仍然擁有該属性，代表著這將佔據每個實例的記憶體，造成大量的記憶體空間因此浪費掉了。相反，如果我們只將它新增在原型中，那麼它只存在記憶體中的一個位置，而所有實例都可以使用它！
 
 </p>
 </details>
@@ -499,12 +499,12 @@ console.log(number);
 
 #### 答案：C
 
-一元運算子 `++` 加在變數後方:
+一元運算子 `++` 加在變數後方：
 
 1. 回傳值 (這個值是 `0`)
 2. 新增值 (變數 `number` 的值現在是 `1`)
 
-一元運算子 `++` 加在變數前方:
+一元運算子 `++` 加在變數前方：
 
 1. 新增值 (變數 `number` 的值現在是 `2`)
 2. 回傳值 (這個值是 `2`)
@@ -576,7 +576,7 @@ checkAge({ age: 18 });
 
 題目中，我們比較的兩個物件擁有不同的記憶體位置：一個物件是作為參數傳遞的物件，它的記憶體位置與另一個拿來判斷是否相等的物件並不相同。
 
-這就是 `{ age: 18 } === { age: 18 }` 與 `{ age: 18 } == { age: 18 }` 會回傳 `false` 的原因.
+這就是 `{ age: 18 } === { age: 18 }` 與 `{ age: 18 } == { age: 18 }` 會回傳 `false` 的原因。
 
 </p>
 </details>
@@ -603,7 +603,7 @@ getAge(21);
 
 #### 答案：C
 
-其餘參數（`...args`） 會蒐集傳進來剩下來未使用的參數，成為一個「陣列」。 陣列的型別是「物件」，所以透過 `typeof args` 將會回傳該值的型別，將是 `"object"`。
+其餘參數（`...args`）會蒐集傳進來剩下來未使用的參數，成為一個「陣列」。陣列的型別是「物件」，所以透過 `typeof args` 將會回傳該值的型別，將是 `"object"`。
 
 </p>
 </details>
@@ -775,7 +775,7 @@ console.log(obj);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
 基本执行上下文是全局执行上下文：它是代码中随处可访问的内容。
 基底的執行環境是全域的：代表它在程式碼中，可被隨處使用。
@@ -802,7 +802,7 @@ for (let i = 1; i < 5; i++) {
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
 當 `if` 條件成立時會回傳 `true`，執行 `continue` 語句，代表忽略本次迭代（`console.log(i)`）。
 
@@ -831,7 +831,7 @@ console.log(name.giveLydiaPizza())
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
 `String` 是內建的建構函式，我們可以向它新增属性。我只是在它的原型中加上一個方法。基本型別字串被自動轉換成字串物件，由字串原型函式生成。因此，所有 string（string 物件）都可以使用 `giveLydiaPizza` 方法！
 
@@ -861,7 +861,7 @@ console.log(a[b]);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
 物件的 key 自動轉為字串型別。我們正嘗試將物件 `b` 的 key 設為物件 `a` 的 key，其值爲 `123`。
 
@@ -894,7 +894,7 @@ baz();
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
 我們有一個 `setTimeout` 函式，首先呼叫它。然而，它的執行順序是最後執行的。
 
@@ -942,21 +942,21 @@ WebAPI 不能隨時向堆疊内新增内容。相反，它會將回呼函式彈
 - A: 第一層的 `div`
 - B: 第二層的 `div`
 - C: `button` 本身
-- D: 一個包含此巢狀元件的陣列.
+- D: 一個包含此巢狀元件的陣列。
 
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
-產生事件(event)的元件即為此事件的 target，您可以透過 `event.stopPropagation` 來停止事件的冒泡(bubbling)
+產生事件 (event) 的元件即為此事件的 target，您可以透過 `event.stopPropagation` 來停止事件的冒泡 (bubbling)
 
 </p>
 </details>
 
 ---
 
-###### 32. 點擊標籤 p(paragraph)時， 將會輸出什麼內容？
+###### 32. 點擊標籤 p(paragraph) 時，將會輸出什麼內容？
 
 ```html
 <div onclick="console.log('div')">
@@ -974,10 +974,10 @@ WebAPI 不能隨時向堆疊内新增内容。相反，它會將回呼函式彈
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
-輸出內容是 `p` 及 `div`。在事件傳播(event propagation) 期間，分為三個階段：捕獲(capturing)，目標(target) 和冒泡(bubbling)。
-預設情況下，事件處理(event handlers) 在冒泡階段執行（除非您將useCapture設置為true)。 它從巢狀元素的最深層向外層。
+輸出內容是 `p` 及 `div`。在事件傳播 (event propagation) 期間，分為三個階段：捕獲 (capturing)，目標 (target) 和冒泡 (bubbling)。
+預設情況下，事件處理 (event handlers) 在冒泡階段執行（除非您將 useCapture 設置為 true)。它從巢狀元素的最深層向外層。
 
 </p>
 </details>
@@ -1005,10 +1005,10 @@ console.log(sayHi.bind(person, 21));
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D
+#### 答案：D
 
 通過 `.call` 及 `.bind`，我們可以將想要 `this` 關鍵字引用的物件傳遞給它。
-然而，`.call` 會 _立即執行_! `.bind.` 則是會回傳一份函式(function)的 _複製_ 且不會立即執行。
+然而，`.call` 會 _立即執行_! `.bind.` 則是會回傳一份函式 (function) 的 _複製_ 且不會立即執行。
 
 </p>
 </details>
@@ -1033,10 +1033,10 @@ console.log(typeof sayHi());
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
-`sayHi` 函數會回傳立即執行函式表示式(IIFE）的回傳值。 該函數回傳類型為 `"number"` 的 `0`。
-FYI: JS只有7種原生類型(type) : `null`, `undefined`, `boolean`, `number`, `string`, `object`, `symbol`, 和 `bigint`. `"function"` 不是一種類型而是物件。
+`sayHi` 函數會回傳立即執行函式表示式 (IIFE）的回傳值。該函數回傳類型為 `"number"` 的 `0`。
+FYI: JS 只有 7 種原生類型 (type) : `null`, `undefined`, `boolean`, `number`, `string`, `object`, `symbol`, 和 `bigint`. `"function"` 不是一種類型而是物件。
 
 </p>
 </details>
@@ -1062,7 +1062,7 @@ undefined;
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
 只有八個值是 falsy
 
@@ -1075,7 +1075,7 @@ undefined;
 - `-0`
 - `0n` (BigInt(0))
 
-函式建構式(Function constructors) 如 `new Number` 和 `new Boolean` 都為 truthy。
+函式建構式 (Function constructors) 如 `new Number` 和 `new Boolean` 都為 truthy。
 
 </p>
 </details>
@@ -1096,7 +1096,7 @@ console.log(typeof typeof 1);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
 `typeof 1` 回傳 `"number"`
 `typeof "number"` 回傳 `"string"`
@@ -1122,11 +1122,11 @@ console.log(numbers);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
-當您設置的元素其位置大過陣列長度時，JavaScript 會建立一個叫做 "empty slots" 的物件， 它們的值實際上為 `undefined`。
+當您設置的元素其位置大過陣列長度時，JavaScript 會建立一個叫做 "empty slots" 的物件，它們的值實際上為 `undefined`。
 
-但您會看到類似的輸出內容 : `[1, 2, 3, 7 x empty, 11]`。實際執行環境會使其輸出內容略微不同 (瀏覽器, node... 等)
+但您會看到類似的輸出內容 : `[1, 2, 3, 7 x empty, 11]`。實際執行環境會使其輸出內容略微不同 (瀏覽器，node... 等)
 
 </p>
 </details>
@@ -1158,13 +1158,13 @@ console.log(numbers);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
-程式中的 `catch` 區塊捕獲了一個例外情況且賦殖予 argument `x`。這個 `x` 是在區塊內產生的，其有效範圍只在區塊內(block-scoped)，它跟 `console.log` 中所傳入的 `x` 並不是同一個。
+程式中的 `catch` 區塊捕獲了一個例外情況且賦殖予 argument `x`。這個 `x` 是在區塊內產生的，其有效範圍只在區塊內 (block-scoped)，它跟 `console.log` 中所傳入的 `x` 並不是同一個。
 
-接著我們將此區塊變數 `x` 設置為等於 `1`，並設置變數 `y` 的值， 現在我們 console.log 區塊變數 `x`，無意外地它輸出 `1`。
+接著我們將此區塊變數 `x` 設置為等於 `1`，並設置變數 `y` 的值，現在我們 console.log 區塊變數 `x`，無意外地它輸出 `1`。
 
-而在 `catch` 區塊之外的 `x` 仍然是 `undefined` 且 `y` 是 `2`。 因此當我們想在 `catch` 區塊之外使用 `console.log（x)` 時，它回傳 `undefined`，而 `y` 回傳 `2`。
+而在 `catch` 區塊之外的 `x` 仍然是 `undefined` 且 `y` 是 `2`。因此當我們想在 `catch` 區塊之外使用 `console.log（x)` 時，它回傳 `undefined`，而 `y` 回傳 `2`。
 
 </p>
 </details>
@@ -1181,16 +1181,16 @@ console.log(numbers);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
 JavaScript 只有 primitive types 和 objects.
 
 而 Primitive types 包含 `boolean`, `null`, `undefined`, `bigint`, `number`, `string`, 和 `symbol`.
 
-Primitive 不同於 object 的是它沒有任何的屬性(properties) 和方法(methods); 沒有方法的情況下為何 `'foo'.toUpperCase()` (string) 是輸出 `'FOO'` 而不是 `TypeError` ?
-這是因為當您嘗試訪問 primitive types (例如字串) 的屬性或方法時，JavaScript會使用其中一個 wrapper classes 包裝該 primitive type。
+Primitive 不同於 object 的是它沒有任何的屬性 (properties) 和方法 (methods); 沒有方法的情況下為何 `'foo'.toUpperCase()` (string) 是輸出 `'FOO'` 而不是 `TypeError` ?
+這是因為當您嘗試訪問 primitive types (例如字串) 的屬性或方法時，JavaScript 會使用其中一個 wrapper classes 包裝該 primitive type。
 
-例如使用了 `String` 包裝 primitive type `string`， 接著在 expression 被 evaluates 後拋棄該包裝。 所有 primitives 除了 `null` 和 `undefined` 外都是遵循此行為。
+例如使用了 `String` 包裝 primitive type `string`，接著在 expression 被 evaluates 後拋棄該包裝。所有 primitives 除了 `null` 和 `undefined` 外都是遵循此行為。
 
 </p>
 </details>
@@ -1216,9 +1216,9 @@ Primitive 不同於 object 的是它沒有任何的屬性(properties) 和方法(
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
-`[1, 2]` 為初始值，同時也是第一個 `acc`。 在第一輪中， `acc` 是 `[1,2]` 且 `cur` 是 `[0, 1]`，兩陣列連接後的結果是 `[1, 2, 0, 1]`。
+`[1, 2]` 為初始值，同時也是第一個 `acc`。在第一輪中，`acc` 是 `[1,2]` 且 `cur` 是 `[0, 1]`，兩陣列連接後的結果是 `[1, 2, 0, 1]`。
 
 接著 `[1, 2, 0, 1]` 是 `acc` 且 `[2, 3]` 是 `cur`，兩陣列連接後的結果是 `[1, 2, 0, 1, 2, 3]`。
 
@@ -1243,7 +1243,7 @@ Primitive 不同於 object 的是它沒有任何的屬性(properties) 和方法(
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
 `null` 是 falsy. `!null` 回傳 `true`. `!true` 回傳 `false`.
 
@@ -1270,7 +1270,7 @@ setInterval(() => console.log('Hi'), 1000);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
 會回傳一個唯一的 id，並可用於 `clearInterval()` 以清除該 interval。
 
@@ -1293,9 +1293,9 @@ setInterval(() => console.log('Hi'), 1000);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
-字串(string) 類別是可以被迭代的(iterable)， 展開運算子(spread operator) 將可迭代的字元(character) 映射(map) 置一個元素(element) 上。
+字串 (string) 類別是可以被迭代的 (iterable)，展開運算子 (spread operator) 將可迭代的字元 (character) 映射 (map) 置一個元素 (element) 上。
 
 </p>
 </details>
@@ -1324,16 +1324,16 @@ console.log(gen.next().value);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
-一般函式不能在被呼叫後中途停止。但是， generator 可以在中途 "停止" 且之後可以從停止的位置繼續執行。
-每當一個 generator 函式遇到一個 `yield` 關鍵字時，該函式就會產生其後指定的值。 請注意，在這種情況下，generator 函式不是 _return_ 值，而是 _yields_ 值。
+一般函式不能在被呼叫後中途停止。但是，generator 可以在中途 "停止" 且之後可以從停止的位置繼續執行。
+每當一個 generator 函式遇到一個 `yield` 關鍵字時，該函式就會產生其後指定的值。請注意，在這種情況下，generator 函式不是 _return_ 值，而是 _yields_ 值。
 
-首先，我們使用等於 "10" 的 "i" 初始化 generator 函式。 我們使用 "next（)" 方法呼叫 generator 函式。 第一次呼叫 generator 函式時， "i" 等於 "10"。
-它遇到第一個 `yield` 關鍵字：它產生 `i` 的值。 現在，generator 已 "暫停"， 並且記錄了 "10"。
+首先，我們使用等於 "10" 的 "i" 初始化 generator 函式。我們使用 "next（)" 方法呼叫 generator 函式。第一次呼叫 generator 函式時， "i" 等於 "10"。
+它遇到第一個 `yield` 關鍵字：它產生 `i` 的值。現在，generator 已 "暫停"，並且記錄了 "10"。
 
-然後，我們使用 `next（）` 方法再次呼叫該函式。 它將從先前停止的地方繼續，仍然是 "i" 等於 "10"。 現在，它遇到下一個 `yield` 關鍵字，並產生 `i * 2` 。 
-"i" 等於 "10"，因此回傳 "10 * 2"，即 "20"。 故結果為10、20。
+然後，我們使用 `next（）` 方法再次呼叫該函式。它將從先前停止的地方繼續，仍然是 "i" 等於 "10"。現在，它遇到下一個 `yield` 關鍵字，並產生 `i * 2`。 
+"i" 等於 "10"，因此回傳 "10 * 2"，即 "20"。故結果為 10、20。
 
 </p>
 </details>
@@ -1362,10 +1362,10 @@ Promise.race([firstPromise, secondPromise]).then(res => console.log(res));
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
 當我們向 Promise.race 方法傳遞多個 promise 時，它將 resolves / rejects _最先的_ promise。
-在 setTimeout 方法中，我們傳遞了一個計時器：第一個 promise（firstPromise）為500毫秒，第二個 promise（secondPromise）為100毫秒。 這意味著 "secondPromise" 將先用 "two" 的值進行resolves。 現在， `res` 擁有 'two' 的值且該值被 console.log。
+在 setTimeout 方法中，我們傳遞了一個計時器：第一個 promise（firstPromise）為 500 毫秒，第二個 promise（secondPromise）為 100 毫秒。這意味著 "secondPromise" 將先用 "two" 的值進行 resolves。現在，`res` 擁有 'two' 的值且該值被 console.log。
 
 </p>
 </details>
@@ -1390,7 +1390,7 @@ console.log(members);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D
+#### 答案：D
 
 首先，我們宣告一個物件變數 `person` 包含 `name` 屬性以及值 `Lydia`。
 
@@ -1434,10 +1434,10 @@ for (const item in person) {
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
-通過 `for-in` 循環，我們可以遍歷物件的鍵，在這個題目中的鍵是 `name` 和 `age`。 在內部，物件鍵是字串(strings)（如果它們不是 Symbol）。
-在每次循環中，我們將 `item` 的值設置為等於其迭代的當前鍵。 第一輪循環中，`item` 等於 `name`，並輸出內容。 接著， `item` 等於 `age`，並輸出內容。
+通過 `for-in` 循環，我們可以遍歷物件的鍵，在這個題目中的鍵是 `name` 和 `age`。在內部，物件鍵是字串 (strings)（如果它們不是 Symbol）。
+在每次循環中，我們將 `item` 的值設置為等於其迭代的當前鍵。第一輪循環中，`item` 等於 `name`，並輸出內容。接著，`item` 等於 `age`，並輸出內容。
 
 </p>
 </details>
@@ -1458,21 +1458,21 @@ console.log(3 + 4 + '5');
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
 運算子關聯性是編譯器計算表達式的順序，從左到右或從右到左。僅適用於所有運算子具有 _相同_ 優先級時，才會發生這種情況。
-在這裡我們只有一種類型的運算子：+。 而其關聯性是從左到右。
+在這裡我們只有一種類型的運算子：+。而其關聯性是從左到右。
 
-首先計算 `3 + 4`。 結果為數字7。
+首先計算 `3 + 4`。結果為數字 7。
 
-由於強制(coercion) ，`7 +'5'` 會導致結果為 `75`。JavaScript將數字 `7` 轉換型態成字串，請參閱問題15。我們可以使用 `+` 運算子將兩個字串連接起來。 `7` + `5` 產生 `75`。
+由於強制 (coercion) ，`7 +'5'` 會導致結果為 `75`。JavaScript 將數字 `7` 轉換型態成字串，請參閱問題 15。我們可以使用 `+` 運算子將兩個字串連接起來。`7` + `5` 產生 `75`。
 
 </p>
 </details>
 
 ---
 
-###### 49. `num` 的值會是什麼?
+###### 49. `num` 的值會是什麼？
 
 ```javascript
 const num = parseInt('7*6', 10);
@@ -1486,9 +1486,9 @@ const num = parseInt('7*6', 10);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
-僅會回傳字串中的第一個數字。 基於 _radix_ (第二個參數，用於指定我們要將其解析為哪種類型的數字：以10為基數，十六進制，八進制，二進制等），`parseInt` 檢查字串中的字元是否有效。
+僅會回傳字串中的第一個數字。基於 _radix_ (第二個參數，用於指定我們要將其解析為哪種類型的數字：以 10 為基數，十六進制，八進制，二進制等），`parseInt` 檢查字串中的字元是否有效。
 一旦遇到基數中無效數字的字元，它將停止解析並忽略以下字元。
 
 `*` 不是合法的 `number`，所以程式僅將字串形態的 `"7"` 轉換至 decimal 形態的 `7`，故 `num` 現在的值為 `7`。
@@ -1515,9 +1515,9 @@ const num = parseInt('7*6', 10);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
-當對陣列做映射(map) 時，`num` 的值等同於它當前正在循環的元素。在這種情況中元素均為 numbers，所以條件式 `typeof num === "number"` 會回傳 `true` 的值。
+當對陣列做映射 (map) 時，`num` 的值等同於它當前正在循環的元素。在這種情況中元素均為 numbers，所以條件式 `typeof num === "number"` 會回傳 `true` 的值。
 map 函式會建立一個新陣列，並插入該函式回傳的值。
 
 但是我們不回傳任何值。當我們不從函式回傳值時，函式將回傳 `undefined`。由於陣列中的每個元素都會呼叫該函式，因此對於每個元素，我們都回傳 `undefined`。
@@ -1551,15 +1551,15 @@ console.log(person, birthYear);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
-參數是透過 _value_ 傳遞，除非它們是一個物件(object)，物件則由透過 _reference_ 傳遞。 `birthYear` 是透過值傳遞的，因為它是字串不是物件。 當我們按值傳遞參數時，將建立該值的 _copy_ (請參閱問題46）。
+參數是透過 _value_ 傳遞，除非它們是一個物件 (object)，物件則由透過 _reference_ 傳遞。`birthYear` 是透過值傳遞的，因為它是字串不是物件。當我們按值傳遞參數時，將建立該值的 _copy_ (請參閱問題 46）。
 
 變數 `birthYear` 具有對值 `1997` 的 reference。參數 `year` 也有對值 `1997` 的 reference，但與變數 `birthYear` 所 reference 的不同。
-因此當我們通過將 `year` 設置為等於 `1998` 來更新 `year` 的值時，我們僅更新了 `year` 的值。 `birthYear` 仍然等於 `"1997"`。
+因此當我們通過將 `year` 設置為等於 `1998` 來更新 `year` 的值時，我們僅更新了 `year` 的值。`birthYear` 仍然等於 `"1997"`。
 
-`person` 的值是一個物件。 參數 `member` 具有（複製的）reference 指向 _相同_ 物件。
-因此當我們修改物件 `member` 的屬性時， `person` 的值也會被修改，因為它們都 reference 了相同的物件。 `person` 的 `name` 屬性現在等於值 `"Lydia"`。
+`person` 的值是一個物件。參數 `member` 具有（複製的）reference 指向 _相同_ 物件。
+因此當我們修改物件 `member` 的屬性時，`person` 的值也會被修改，因為它們都 reference 了相同的物件。`person` 的 `name` 屬性現在等於值 `"Lydia"`。
 
 </p>
 </details>
@@ -1593,13 +1593,13 @@ sayHi();
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D
+#### 答案：D
 
-使用 `throw` 語句，我們可以建立自定義的錯誤。 使用此語句，您可以觸發例外(exception)。例外可以是 `<b>string</ b>`，`<b>number</ b>`，`<b>boolean</ b>` 或 `<b>object</ b>`。 
+使用 `throw` 語句，我們可以建立自定義的錯誤。使用此語句，您可以觸發例外 (exception)。例外可以是 `<b>string</ b>`，`<b>number</ b>`，`<b>boolean</ b>` 或 `<b>object</ b>`。 
 在這種情況下，我們的例外是字串 `Hello world`。
 
-通過 `catch` 語句，我們可以指定如果在 `try` 的程式區塊中拋出例外時該怎麼辦。 例如拋出例外：字串 `'Hello world'`。 
-現在， `e` 等於我們記錄的字串。 因此輸出結果將會是 `'Oh an error: Hello world'`。
+通過 `catch` 語句，我們可以指定如果在 `try` 的程式區塊中拋出例外時該怎麼辦。例如拋出例外：字串 `'Hello world'`。 
+現在，`e` 等於我們記錄的字串。因此輸出結果將會是 `'Oh an error: Hello world'`。
 
 </p>
 </details>
@@ -1626,9 +1626,9 @@ console.log(myCar.make);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
-當您回傳屬性(property) 時，該屬性的值等於 _returned_ 的值，而不是在函式建構式(constructor function)中設置的值。 我們回傳字串 `Maserati`，因此 `myCar.make` 等於 `Maserati`。
+當您回傳屬性 (property) 時，該屬性的值等於 _returned_ 的值，而不是在函式建構式 (constructor function) 中設置的值。我們回傳字串 `Maserati`，因此 `myCar.make` 等於 `Maserati`。
 
 </p>
 </details>
@@ -1654,7 +1654,7 @@ console.log(typeof y);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
 `let x = y = 10;` 實際上是 shorthand for:
 
@@ -1663,13 +1663,13 @@ y = 10;
 let x = y;
 ```
 
-當我們將 `y `設置為等於 `10` 時，我們實際上將屬性 `y` 加入到 global object 中（瀏覽器中的 `window`，Node中的 `global`）。 現在，瀏覽器中 `window.y` 現在等於 `10`。
+當我們將 `y `設置為等於 `10` 時，我們實際上將屬性 `y` 加入到 global object 中（瀏覽器中的 `window`，Node 中的 `global`）。現在，瀏覽器中 `window.y` 現在等於 `10`。
 
-接著我們宣告一個變數 `x`，並將其值賦予為 `y`，即 `10`。 用` let` 關鍵字宣告的變數是 _block scoped_ ，它們僅在宣告它們的區塊中定義； 另外此案例的函示是，立即函示表達式（IIFE）。
-當我們使用 `typeof` 運算子時， `x` 並未被定義：我們試圖在宣告它的區塊外訪問 `x`。這將獲得 `x` 並未被定義的結果。 未分配值或未宣告的值的類型為 `"undefined"`。 `console.log(typeof x)` 回傳 `"undefined"`。
+接著我們宣告一個變數 `x`，並將其值賦予為 `y`，即 `10`。用` let` 關鍵字宣告的變數是 _block scoped_，它們僅在宣告它們的區塊中定義；另外此案例的函示是，立即函示表達式（IIFE）。
+當我們使用 `typeof` 運算子時，`x` 並未被定義：我們試圖在宣告它的區塊外訪問 `x`。這將獲得 `x` 並未被定義的結果。未分配值或未宣告的值的類型為 `"undefined"`。`console.log(typeof x)` 回傳 `"undefined"`。
 
-但是，當將 `y` 設置為 `10` 時，我們建立了global variable `y`。 在我們程式中的任何位置均可訪問此值。
-`y` 被定義，並且為類型 `number` 的值。 因此 `console.log（typeof y` 回傳 `"number"`。
+但是，當將 `y` 設置為 `10` 時，我們建立了 global variable `y`。在我們程式中的任何位置均可訪問此值。
+`y` 被定義，並且為類型 `number` 的值。因此 `console.log（typeof y` 回傳 `"number"`。
 
 </p>
 </details>
@@ -1706,12 +1706,12 @@ pet.bark();
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
-透過 `delete` 關鍵字，我們可以從物件中刪除它的屬性。同樣適用在原型(prototype)。通過刪除原型上的屬性，該屬性在原型鏈中將不可再被使用。
-在這個案例中， `bark` 函式在 `delete Dog.prototype.bark` 之後的原型上不再可用，但是我們仍然嘗試訪問它。
+透過 `delete` 關鍵字，我們可以從物件中刪除它的屬性。同樣適用在原型 (prototype)。通過刪除原型上的屬性，該屬性在原型鏈中將不可再被使用。
+在這個案例中，`bark` 函式在 `delete Dog.prototype.bark` 之後的原型上不再可用，但是我們仍然嘗試訪問它。
 
-因此當我們嘗試呼叫不是函式的東西時，程式將拋出 `TypeError`。 在這個案例中，將為 `TypeError: pet.bark is not a function` ，因為 `pet.bark` 是 `undefined`。
+因此當我們嘗試呼叫不是函式的東西時，程式將拋出 `TypeError`。在這個案例中，將為 `TypeError: pet.bark is not a function`，因為 `pet.bark` 是 `undefined`。
 
 </p>
 </details>
@@ -1734,9 +1734,9 @@ console.log(set);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D
+#### 答案：D
 
-`Set` 物件是 _唯一_ 值的集合: 任何存在於 `Set` 的值均為唯一的，不會存在相同的值(重複的值將會由後出現的覆蓋已出現的)。
+`Set` 物件是 _唯一_ 值的集合：任何存在於 `Set` 的值均為唯一的，不會存在相同的值 (重複的值將會由後出現的覆蓋已出現的)。
 
 陣列 `[1, 1, 2, 3, 4]` 中有重複的值 `1`，因此結果會是 `{1, 2, 3, 4}`。
 
@@ -1770,11 +1770,11 @@ console.log(myCounter);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
-被引用(imported) 的模組(module) 是 _唯讀_ 的: 您無法修改被引用模組中項目，只有輸出(export) 該項目的模組可以更改它的值。
+被引用 (imported) 的模組 (module) 是 _唯讀_ 的：您無法修改被引用模組中項目，只有輸出 (export) 該項目的模組可以更改它的值。
 
-因此當我們嘗試增加 `myCounter` 的值時，他將拋出錯誤: `myCounter` is read-only and cannot be modified。
+因此當我們嘗試增加 `myCounter` 的值時，他將拋出錯誤：`myCounter` is read-only and cannot be modified。
 
 </p>
 </details>
@@ -1799,11 +1799,11 @@ console.log(delete age);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
-`delete` 運算子會回傳一個布林值: 成功刪除物件的情況下會回傳 `true`，反之則為 `false`。 但是經由 `var`，`const` 或是 `let` 關鍵字所宣告的變數是無法使用 `delete` 運算子刪除的。
+`delete` 運算子會回傳一個布林值：成功刪除物件的情況下會回傳 `true`，反之則為 `false`。但是經由 `var`，`const` 或是 `let` 關鍵字所宣告的變數是無法使用 `delete` 運算子刪除的。
 
-此處， `name` 無法成功刪除且會回傳 `false`，因為它是經由 `const` 所宣告。當我們宣告 `age` 的值為 `21` 時，實際上我們做的是將一個名為 `age` 的屬性為添加到了全球物件中，您可以透過 `delete` 來刪除物件中的屬性，因此您也能刪除全球物件中的屬性，故將回傳 `true`。
+此處，`name` 無法成功刪除且會回傳 `false`，因為它是經由 `const` 所宣告。當我們宣告 `age` 的值為 `21` 時，實際上我們做的是將一個名為 `age` 的屬性為添加到了全球物件中，您可以透過 `delete` 來刪除物件中的屬性，因此您也能刪除全球物件中的屬性，故將回傳 `true`。
 
 </p>
 </details>
@@ -1827,9 +1827,9 @@ console.log(y);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
-我們可以通過解構(destructuring) 從陣列或物件的屬性中獲得值。例如:
+我們可以通過解構 (destructuring) 從陣列或物件的屬性中獲得值。例如：
 
 ```javascript
 [a, b] = [1, 2];
@@ -1837,7 +1837,7 @@ console.log(y);
 
 <img src="https://i.imgur.com/ADFpVop.png" width="200">
 
-a 的值現在為 `1` 且b 的值現在為`2`。我們針對此問題所做的動作為:
+a 的值現在為 `1` 且 b 的值現在為`2`。我們針對此問題所做的動作為：
 
 ```javascript
 [y] = [1, 2, 3, 4, 5];
@@ -1869,9 +1869,9 @@ console.log(admin);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
-使用 spread 運算子可以合併物件(`...`)。它使您可以建立一個物件的鍵/值的複製，並將其添加到另一物件中。
+使用 spread 運算子可以合併物件 (`...`)。它使您可以建立一個物件的鍵/值的複製，並將其添加到另一物件中。
 在這裡我們建立了 `user` 物件的複製並將其添加至 `admin` 物件。因此將輸出 `{ admin: true, name: "Lydia", age: 21 }`。
 
 </p>
@@ -1898,9 +1898,9 @@ console.log(Object.keys(person));
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
-透過 `defineProperty`，我們可以對物件增加新的屬性或是修改已經存在的屬性。當我們使用 `defineProperty` 增加物件的屬性時，它們被預設為 _不可 enumerable_ 。
+透過 `defineProperty`，我們可以對物件增加新的屬性或是修改已經存在的屬性。當我們使用 `defineProperty` 增加物件的屬性時，它們被預設為 _不可 enumerable_。
  `Object.keys` 方法僅回傳物件中所有 _可 enumerable_ 的屬性名稱，這個案例中只有 `"name"`。
 
 預設下，使用 `defineProperty `方法增加的屬性是不可變的。但您可以覆蓋這個行為透過 `writable`，`configurable` 及 `enumerable` 屬性。
@@ -1932,14 +1932,14 @@ console.log(data);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
-`JSON.stringify` 的第二個參數是 _替換者 (replacer)_ ，替換者可以是函式，也可以是陣列，並允許您控制值要如何獲怎麼串化(stringified)。
+`JSON.stringify` 的第二個參數是 _替換者 (replacer)_，替換者可以是函式，也可以是陣列，並允許您控制值要如何獲怎麼串化 (stringified)。
 
-如果替換者是 _陣列_ ，僅將陣列中包含的屬性名稱加到 JSON 字串中。
+如果替換者是 _陣列_，僅將陣列中包含的屬性名稱加到 JSON 字串中。
 此案例中，僅有 `"level"` and `"health"` 被包含，`"username"` 沒有被包含在內，因此 `data` 的值將為 `"{"level":19, "health":90}"`。
 
-如果替換者是 _函式_ ，在要字串化的每個物件屬性上將會呼叫此函式。從此函式回傳的值將是加到 JSON 字串中的屬性的值。如果值為 `undefined`，則此屬性從 JSON 字串中排除。
+如果替換者是 _函式_，在要字串化的每個物件屬性上將會呼叫此函式。從此函式回傳的值將是加到 JSON 字串中的屬性的值。如果值為 `undefined`，則此屬性從 JSON 字串中排除。
 
 </p>
 </details>
@@ -1969,11 +1969,11 @@ console.log(num2);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
-單元運算子 `++` 首先 _回傳_ 操作數的值，然後 _遞增_ 操作數的值。 `num1` 的值是 `10`，因為 `increaseNumber`  函式首先回傳 `num` 的值，即 `10`，之後才遞增 `num` 的值。
+單元運算子 `++` 首先 _回傳_ 操作數的值，然後 _遞增_ 操作數的值。`num1` 的值是 `10`，因為 `increaseNumber`  函式首先回傳 `num` 的值，即 `10`，之後才遞增 `num` 的值。
 
-`num2` 是 `10`， 因為我們將 `num1` 傳遞給了 `increasePassedNumber`。 `number` 等於 `10`（ `num1` 的值。同樣，單元運算子 `++` 首先 _回傳_ 操作數的值，然後 _遞增_ 操作數的值。
+`num2` 是 `10`，因為我們將 `num1` 傳遞給了 `increasePassedNumber`。`number` 等於 `10`（`num1` 的值。同樣，單元運算子 `++` 首先 _回傳_ 操作數的值，然後 _遞增_ 操作數的值。
 `number` 的值是 `10`，因此 `num2` 等於 `10`。
 
 </p>
@@ -2004,15 +2004,15 @@ multiply(value);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
-在ES6中，我們可以使用預設值初始化參數。如果沒有其他值傳遞給該函式或是傳入的參數是 `undefined`，則該參數的值為預設值。此案例中，我們將 `value` 物件的屬性擴展到一個新物件中，因此 `x` 具有預設值 `{number：10}`。
+在 ES6 中，我們可以使用預設值初始化參數。如果沒有其他值傳遞給該函式或是傳入的參數是 `undefined`，則該參數的值為預設值。此案例中，我們將 `value` 物件的屬性擴展到一個新物件中，因此 `x` 具有預設值 `{number：10}`。
 
 預設值是在 _呼叫_ 時被 evaluated。每次呼叫該函式時，都會建立一個 _新_ 物件。我們在沒有傳遞值的情況下呼叫了 `multiply` 函式兩次：`x` 的預設值是 `{{number：10}`。因此，我們輸出該數字的相乘值，即 `20`。
 
-第三次呼叫時，我們確實傳遞了一個參數：名為 `value` 的物件。 `*=` 運算子實際上是 `x.number = x.number * 2` 的簡寫：因此我們修改了 `x.number` 的值，並記錄相乘後的值 `20`。
+第三次呼叫時，我們確實傳遞了一個參數：名為 `value` 的物件。`*=` 運算子實際上是 `x.number = x.number * 2` 的簡寫：因此我們修改了 `x.number` 的值，並記錄相乘後的值 `20`。
 
-第四次，我們再次傳遞名為 `value` 的物件。 `x.number` 先前已修改為 `20`，因此 `x.number * = 2` 為 `40`。
+第四次，我們再次傳遞名為 `value` 的物件。`x.number` 先前已修改為 `20`，因此 `x.number * = 2` 為 `40`。
 
 </p>
 </details>
@@ -2033,19 +2033,19 @@ multiply(value);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D
+#### 答案：D
 
-`reduce` 方法接收的第一個參數是 _累加器(accumulator)_ ，在這種情況下是 `x`。 第二個參數是 _current value_ `y`。 使用 `reduce` 方法，我們對陣列中的每個元素執行一個 callback 函式，並在最終回一個值。
+`reduce` 方法接收的第一個參數是 _累加器 (accumulator)_，在這種情況下是 `x`。第二個參數是 _current value_ `y`。使用 `reduce` 方法，我們對陣列中的每個元素執行一個 callback 函式，並在最終回一個值。
 
 在此示例中，我們不回傳任何值，僅記錄了累加器的值和當前值。
 
-累加器的值等於 callback 函式先前回傳的值。 如果沒有 `initialValue` 參數傳遞給 `reduce` 方法，則累加器的初始值將會等於第一個元素。
+累加器的值等於 callback 函式先前回傳的值。如果沒有 `initialValue` 參數傳遞給 `reduce` 方法，則累加器的初始值將會等於第一個元素。
 
-在第一個呼叫中，累加器（`x`）為`1`，當前值（`y`）為`2`。 我們不從 callback 函式回傳，而是輸出累加器和當前值：`1` 和 `2`。
+在第一個呼叫中，累加器（`x`）為`1`，當前值（`y`）為`2`。我們不從 callback 函式回傳，而是輸出累加器和當前值：`1` 和 `2`。
 
-如果您不從 callback 函式回傳值，則它將回傳 `undefined`。 在下一次呼叫時，累加器為 `undefined`，當前值為 `3`。 於是 `undefined` 和 `3` 被輸出。
+如果您不從 callback 函式回傳值，則它將回傳 `undefined`。在下一次呼叫時，累加器為 `undefined`，當前值為 `3`。於是 `undefined` 和 `3` 被輸出。
 
-在第四次呼叫中，我們再次不從 callback 函式回傳。 累加器再次為 `undefined`，當前值為 `4`。於是 `undefined` 和 `4` 被輸出。
+在第四次呼叫中，我們再次不從 callback 函式回傳。累加器再次為 `undefined`，當前值為 `4`。於是 `undefined` 和 `4` 被輸出。
 
 </p>
 </details>
@@ -2093,13 +2093,13 @@ class Labrador extends Dog {
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
-在子類別中，在呼叫 `super` 前不能存取 `this` 關鍵字，如果你這麼做，它將拋出一個 `ReferenceError`，建構式1與4會引發這個錯誤。
+在子類別中，在呼叫 `super` 前不能存取 `this` 關鍵字，如果你這麼做，它將拋出一個 `ReferenceError`，建構式 1 與 4 會引發這個錯誤。
 
 使用 `super` 關鍵字時，我們要提供參數給父類別呼叫其建構式。父類別需要接受一個 `name` 參數，所以我們需要把 `name` 傳給 `super`。
 
-`Labrador` 類別接收兩個參數， `name` 參數是由於它繼承了 `Dog` ， `size` 作為`Labrador` 類的額外屬性，它們都需要傳遞給 `Labrador` 的建構式，因此使用建構式2是正確答案。
+`Labrador` 類別接收兩個參數，`name` 參數是由於它繼承了 `Dog`，`size` 作為`Labrador` 類的額外屬性，它們都需要傳遞給 `Labrador` 的建構式，因此使用建構式 2 是正確答案。
 
 </p>
 </details>
@@ -2127,11 +2127,11 @@ export const sum = (a, b) => a + b;
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
 `import` 命令是 _編譯階段_ 執行的。這代表被引入的模組會優先執行，而引入模組的檔案會 _之後執行_。
 
-這是 `CommonJS` 中 `require()` 和 `import` 之間的區別！使用 `require()`，您可以在執行程式時根據需要戴入依賴的項目。如果我們使用 `require` 而不是 `import` 來執行此題， 結果將會依 `running index.js`，`running sum.js`，`3` 的順序輸出。
+這是 `CommonJS` 中 `require()` 和 `import` 之間的區別！使用 `require()`，您可以在執行程式時根據需要戴入依賴的項目。如果我們使用 `require` 而不是 `import` 來執行此題，結果將會依 `running index.js`，`running sum.js`，`3` 的順序輸出。
 
 </p>
 </details>
@@ -2153,9 +2153,9 @@ console.log(Symbol('foo') === Symbol('foo'));
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
-每個 Symbol 都是完全唯一的。傳遞給 Symbol 的參數只是給 Symbol 的一個描述。 Symbol 的值不依賴於傳遞的參數。當我們建立兩個全新的 Symbol 去比較時：第一個`Symbol('foo')`，第二個`Symbol('foo')`, 因這兩個值是唯一的，彼此不相等，因此 `Symbol('foo') === Symbol('foo')` 會得到 `false`。
+每個 Symbol 都是完全唯一的。傳遞給 Symbol 的參數只是給 Symbol 的一個描述。Symbol 的值不依賴於傳遞的參數。當我們建立兩個全新的 Symbol 去比較時：第一個`Symbol('foo')`，第二個`Symbol('foo')`, 因這兩個值是唯一的，彼此不相等，因此 `Symbol('foo') === Symbol('foo')` 會得到 `false`。
 
 </p>
 </details>
@@ -2178,9 +2178,9 @@ console.log(name.padStart(2));
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
-使用 `padStart` 函數，我們可以在字串的前面加上填充字串。傳遞給此函數的參數是字串的總長度（包含填充字串）。字串 Lydia Hallie 的長度為 `12` , 因此 `name.padStart(13)` 在字串的開頭只會插入1個空格，因為 12 + 1 等於 13。
+使用 `padStart` 函數，我們可以在字串的前面加上填充字串。傳遞給此函數的參數是字串的總長度（包含填充字串）。字串 Lydia Hallie 的長度為 `12` , 因此 `name.padStart(13)` 在字串的開頭只會插入 1 個空格，因為 12 + 1 等於 13。
 
 如果傳給 `padStart` 函數的參數小於字串的長度，則不會加上填充字串。
 
@@ -2197,13 +2197,13 @@ console.log('🥑' + '💻');
 
 - A: `"🥑💻"`
 - B: `257548`
-- C: 一個包含碼位(code point)的字串
+- C: 一個包含碼位 (code point) 的字串
 - D: 錯誤
 
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
 使用 `+` 運算元，你可以連接字串。在此例，我們將字串“🥑”與字串”💻“連接起來，產生”🥑💻“。
 
@@ -2216,7 +2216,7 @@ console.log('🥑' + '💻');
 
 ```javascript
 function* startGame() {
-  const answer = yield '你喜歡 JavaScript 嗎?';
+  const answer = yield '你喜歡 JavaScript 嗎？';
   if (answer !== 'Yes') {
     return "哦，我想我們該走了";
   }
@@ -2224,7 +2224,7 @@ function* startGame() {
 }
 
 const game = startGame();
-console.log(/* 1 */); // 你喜歡 JavaScript 嗎?
+console.log(/* 1 */); // 你喜歡 JavaScript 嗎？
 console.log(/* 2 */); // JavaScript 也愛你 ❤️
 ```
 
@@ -2236,13 +2236,13 @@ console.log(/* 2 */); // JavaScript 也愛你 ❤️
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
-`generator` 函數在遇到 yield 關鍵字時會 “暫停” 執行。首先，我們需要讓函數產生字串 "你喜歡 JavaScript 嗎?"，這可以透過呼叫 `game.next().value` 來完成。
+`generator` 函數在遇到 yield 關鍵字時會“暫停”執行。首先，我們需要讓函數產生字串 "你喜歡 JavaScript 嗎？"，這可以透過呼叫 `game.next().value` 來完成。
 
-`startGame()` 函數會一行一行執行直到遇到 `yield` 關鍵字，在函數裡第一個就有一個 `yield` 關鍵字：所以執行到第一行就停止了！ _此時answer變數還尚未定義_
+`startGame()` 函數會一行一行執行直到遇到 `yield` 關鍵字，在函數裡第一個就有一個 `yield` 關鍵字：所以執行到第一行就停止了！_此時 answer 變數還尚未定義_
 
-當我們呼叫 `game.next("Yes").value`，前一個 `yield` 被傳遞給 `next()` 的參數值所取代。此例我們使用 `Yes`。變數 `answer` 的值現在等於 `Yes`。 if 語句的條件回傳 `false`，並且會回傳 `JavaScript 也愛你 ❤️` 。
+當我們呼叫 `game.next("Yes").value`，前一個 `yield` 被傳遞給 `next()` 的參數值所取代。此例我們使用 `Yes`。變數 `answer` 的值現在等於 `Yes`。if 語句的條件回傳 `false`，並且會回傳 `JavaScript 也愛你 ❤️`。
 
 </p>
 </details>
@@ -2263,9 +2263,9 @@ console.log(String.raw`Hello\nworld`);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
-`String.raw`會回傳一個字串，其中轉義符(`/n`, `/v`, `/t`等)被忽略! 反斜線可能是一個問題，因為你可能會有這樣的結果。
+`String.raw`會回傳一個字串，其中轉義符 (`/n`, `/v`, `/t`等) 被忽略！反斜線可能是一個問題，因為你可能會有這樣的結果。
 
 `const path = "C:\Documents\Projects\table.html"`。
 
@@ -2303,9 +2303,9 @@ console.log(data);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
-一個異步函數總是回傳一個 promise 。 `await` 仍然要等待 promise 的 resolve：當我們呼叫 `getData()` 等於 `data` 時，會得到一個等待的 promise。
+一個異步函數總是回傳一個 promise。 `await` 仍然要等待 promise 的 resolve：當我們呼叫 `getData()` 等於 `data` 時，會得到一個等待的 promise。
 
 如果我們想獲取 resolve 後的值`"I made it"`，我們可以在`data`上使用`.then()`函數：
 
@@ -2337,11 +2337,11 @@ console.log(result);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
 `.push()`函數回傳的是陣列的長度！原本陣列包含一個元素（字串`"香蕉"`），長度為`1`。後來將字串 `"apple"` 加到陣列中後，陣列包含兩個元素。所以會從`addToList`函數中得到，長度為 `"2"`。
 
-`push`函數修改了原來的陣列。如果你想從函數中回傳 _陣列_ 而不是 _陳列的長度_ ，你應該在加完`item`到陣列後，回傳`list`。
+`push`函數修改了原來的陣列。如果你想從函數中回傳 _陣列_ 而不是 _陳列的長度_，你應該在加完`item`到陣列後，回傳`list`。
 
 </p>
 </details>
@@ -2369,13 +2369,13 @@ console.log(shape);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
-`Object.freeze` 使我們無法增加、刪除或修改Object的屬性（除非該屬性的值是另一個Object）。
+`Object.freeze` 使我們無法增加、刪除或修改 Object 的屬性（除非該屬性的值是另一個 Object）。
 
-當我們建立變數`shape`並等同被凍結的Object`box`時，`shape`也是指一個被凍結的Object。你可以透過使用`Object.isFrozen`檢查一個Object是否被凍結。在這種情況下，`Object.isFrozen(shape)`回傳true，因為變數`shape`也指向一個凍結Object。
+當我們建立變數`shape`並等同被凍結的 Object`box`時，`shape`也是指一個被凍結的 Object。你可以透過使用`Object.isFrozen`檢查一個 Object 是否被凍結。在這種情況下，`Object.isFrozen(shape)`回傳 true，因為變數`shape`也指向一個凍結 Object。
 
-由於`shape`是被凍結的，而且`x`的值不是一個Object，所以我們不能修改`x`的屬性。 `x`仍然等於`10`，於是`{ x: 10, y: 20 }`被記錄下來。
+由於`shape`是被凍結的，而且`x`的值不是一個 Object，所以我們不能修改`x`的屬性。`x`仍然等於`10`，於是`{ x: 10, y: 20 }`被記錄下來。
 
 </p>
 </details>
@@ -2398,11 +2398,11 @@ console.log(name);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D
+#### 答案：D
 
 當我們從右側的物件解構屬性`name`時，我們將其值`Lydia`分配給名為`myName`的變數。
 
-使用`{name：myName}`，我們是在告訴JavaScript我們要建立一個名為`myName`的新變數，並且其值是右側物件的`name`屬性的值。
+使用`{name：myName}`，我們是在告訴 JavaScript 我們要建立一個名為`myName`的新變數，並且其值是右側物件的`name`屬性的值。
 
 當我們嘗試輸出`name`，一個未定義的變數時，就會引發`ReferenceError`。
 
@@ -2411,7 +2411,7 @@ console.log(name);
 
 ---
 
-###### 77. 以下是純函數嗎?
+###### 77. 以下是純函數嗎？
 
 ```javascript
 function sum(a, b) {
@@ -2425,7 +2425,7 @@ function sum(a, b) {
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
 純函數一種若輸入參數相同，則永遠會得到相同輸出的函數。
 
@@ -2474,7 +2474,7 @@ console.log(addFunction(5 * 2));
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
 `add`函數是一個記憶函數。通過記憶化，我們可以暫存函數的結果，以加快其執行速度。上述情況，我們建立一個`cache`物件，用於存儲先前存過的值。
 
@@ -2482,11 +2482,11 @@ console.log(addFunction(5 * 2));
 
 我們用相同的值三次呼叫了`addFunction`函數：
 
-在第一次呼叫，`num`等於`10`時函數的值尚未暫存，if語句`num in cache`回傳`false`，else塊的代碼被執行：`Calculated! 20`，並且其結果被添加到暫存物件，`cache`現在看起來像`{10：20}`。
+在第一次呼叫，`num`等於`10`時函數的值尚未暫存，if 語句`num in cache`回傳`false`，else 塊的代碼被執行：`Calculated! 20`，並且其結果被添加到暫存物件，`cache`現在看起來像`{10:20}`。
 
-第二次，`cache`物件包含`10`的回傳值。 if語句 `num in cache` 回傳`true`，印出`From cache! 20`。
+第二次，`cache`物件包含`10`的回傳值。if 語句 `num in cache` 回傳`true`，印出`From cache! 20`。
 
-第三次，我們將`5 * 2`(值為10)傳遞給函數。 `cache`物件包含`10`的回傳值。 if語句 `num in cache` 回傳`true`，印出`From cache! 20`。
+第三次，我們將`5 * 2`(值為 10) 傳遞給函數。`cache`物件包含`10`的回傳值。if 語句 `num in cache` 回傳`true`，印出`From cache! 20`。
 
 </p>
 </details>
@@ -2514,9 +2514,9 @@ for (let item of myLifeSummedUp) {
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
-透過`for-in`迴圈，我們可以遍歷一個物件**自有的**、**繼承的**、**可列舉的**、**非Symbol的**屬性。在陣列中，可列舉屬性是陣列元素的“鍵”， 即它們的索引。類似於下面這個物件：
+透過`for-in`迴圈，我們可以遍歷一個物件**自有的**、**繼承的**、**可列舉的**、**非 Symbol 的**屬性。在陣列中，可列舉屬性是陣列元素的“鍵”，即它們的索引。類似於下面這個物件：
 
 `{0: "☕", 1: "💻", 2: "🍷", 3: "🍫"}`
 
@@ -2544,11 +2544,11 @@ console.log(list)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
 陣列元素可以包含任何值。數字，字符，布林，物件，陣列，`null`，`undefined`, 以及其他表達式，如日期，函數和計算式。
 
-元素將等於回傳的值。 `1 + 2`回傳`3`，`1 * 2`回傳'2`，'1 / 2`回傳`0.5`。
+元素將等於回傳的值。`1 + 2`回傳`3`，`1 * 2`回傳'2`，'1 / 2`回傳`0.5`。
 
 </p>
 </details>
@@ -2572,13 +2572,13 @@ console.log(sayHi())
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
-預設情況下，如果不傳參數給函數，函數內參數的值將為`undefined`。上述情況，我們沒有給參數`name`傳值。 `name`等於`undefined`，並被印出。
+預設情況下，如果不傳參數給函數，函數內參數的值將為`undefined`。上述情況，我們沒有給參數`name`傳值。`name`等於`undefined`，並被印出。
 
-在ES6中，我們可以使用預設參數覆蓋此預設的`undefined`值。例如：
+在 ES6 中，我們可以使用預設參數覆蓋此預設的`undefined`值。例如：
 
-`function sayHi（name =“Lydia”）{...}`
+`function sayHi (name =“Lydia”){...}`
 
 在這種情況下，如果我們沒有傳遞值或者如果我們傳遞`undefined`，`name`總是等於字符`Lydia`
 
@@ -2614,11 +2614,11 @@ setTimeout(() => {
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
 `this`關鍵字的指向取決於使用它的位置。在**函數**中，比如`getStatus`，`this`指向的是呼叫它的物件，上述例子中`data`物件呼叫了`getStatus`，因此`this`指向的就是`data`物件。當我們輸出`this.status`時，`data`物件的`status`屬性被輸出，即`"🥑"`。
 
-使用`call`方法，可以更改`this`指向的物件。 `data.getStatus.call(this)`是將`this`的指向由`data`物件更改為全局物件。在全局物件上，有一個名為`status`的變數，其值為`”😎“`。因此輸出`this.status`時，會輸出`“😎”`。
+使用`call`方法，可以更改`this`指向的物件。`data.getStatus.call(this)`是將`this`的指向由`data`物件更改為全局物件。在全局物件上，有一個名為`status`的變數，其值為`”😎“`。因此輸出`this.status`時，會輸出`“😎”`。
 </p>
 </details>
 
@@ -2645,13 +2645,13 @@ console.log(person)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
 我們將變數`city`設置為等於`person`物件上名為`city`的屬性的值。這個物件上沒有名為`city`的屬性，因此變數`city`的值為`undefined`。
 
 請注意，我們沒有引用`person`物件本身，只是將變數`city`設置為等於`person`物件上`city`屬性的當前值。
 
-然後，我們將`city`設置為等於字串`“Amsterdam”`。這不會更改person物件：沒有對該物件的引用。
+然後，我們將`city`設置為等於字串`“Amsterdam”`。這不會更改 person 物件：沒有對該物件的引用。
 
 因此輸出`person`物件時，會回傳未修改的物件。
 
@@ -2683,9 +2683,9 @@ console.log(checkAge(21))
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
-`const`和`let`定義的變數是具有**區塊作用域**的，區塊是大括號（`{}`）之間的任何東西, 即上述情況`if / else`語句的大括號。由於區塊作用域，我們無法在定義的塊之外引用變數，因此拋出`ReferenceError`。
+`const`和`let`定義的變數是具有**區塊作用域**的，區塊是大括號（`{}`）之間的任何東西，即上述情況`if / else`語句的大括號。由於區塊作用域，我們無法在定義的塊之外引用變數，因此拋出`ReferenceError`。
 
 </p>
 </details>
@@ -2707,7 +2707,7 @@ fetch('https://www.website.com/api/user/1')
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
 第二個`.then`中`res`的值等於前一個`.then`中函數回傳的值。你可以像這樣繼續連接`.then`，將值傳遞給下一個處理程序。
 
@@ -2715,7 +2715,7 @@ fetch('https://www.website.com/api/user/1')
 </details>
 
 ---
-###### 86. 哪個選項是將`hasName`設為`true`的方法，前提是不能將`true`作為參數傳遞?
+###### 86. 哪個選項是將`hasName`設為`true`的方法，前提是不能將`true`作為參數傳遞？
 
 ```javascript
 function getName(name) {
@@ -2731,9 +2731,9 @@ function getName(name) {
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
-使用邏輯非運算子`!`，將回傳一個布林值，使用`!! name`，我們可以確定`name`的值是`true`還是`false`。如果`name`是`true`，那麼`!name`回傳`false`。 `!false`回傳`true`。
+使用邏輯非運算子`!`，將回傳一個布林值，使用`!! name`，我們可以確定`name`的值是`true`還是`false`。如果`name`是`true`，那麼`!name`回傳`false`。`!false`回傳`true`。
 
 通過將`hasName`設置為`name`，可以將`hasName`設置為等於傳遞給`getName`函數的值，而不是布林值`true`。
 
@@ -2759,11 +2759,11 @@ console.log("I want pizza"[0])
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
-可以使用雙括號表示法獲取字串中特定索引的字串，字串中的第一個字串具有索引0，依此類推。在這種情況下，我們想要得到索引為0的元素，字串`'I'`被記錄。
+可以使用雙括號表示法獲取字串中特定索引的字串，字串中的第一個字串具有索引 0，依此類推。在這種情況下，我們想要得到索引為 0 的元素，字串`'I'`被記錄。
 
-請注意，IE7及更低版本不支援此方法。應該使用`.charAt（）`
+請注意，IE7 及更低版本不支援此方法。應該使用`.charAt（）`
 
 </p>
 </details>
@@ -2787,9 +2787,9 @@ sum(10)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
-您可以將預設參數的值設置為函數的另一個參數，只要另一個參數定義在其之前即可。我們將值`10`傳遞給`sum`函數。如果`sum`函數只接收1個參數，則意味著沒有傳遞`num2`的值，這種情況下，`num1`的值等於傳遞的值`10`。 `num2`的預設值是`num1`的值，即`10`。 ```num1 + num2```回傳`20`。
+您可以將預設參數的值設置為函數的另一個參數，只要另一個參數定義在其之前即可。我們將值`10`傳遞給`sum`函數。如果`sum`函數只接收 1 個參數，則意味著沒有傳遞`num2`的值，這種情況下，`num1`的值等於傳遞的值`10`。`num2`的預設值是`num1`的值，即`10`。```num1 + num2```回傳`20`。
 
 如果您嘗試將預設參數的值設置為後面定義的參數，則可能導致參數的值尚未初始化，從而引發錯誤。比如：
 ```js
@@ -2826,11 +2826,11 @@ console.log(data)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
 使用`import * as name`語法，我們將`module.js`文件中所有`export`匯入到`index.js`文件中，並且建立了一個名為`data`的新物件。在`module.js`文件中，有兩個匯出：預設匯出和命名匯出。預設匯出是一個回傳字串“Hello World”的函數，命名匯出是一個名為`name`的變數，其值為字串`“Lydia”`。
 
-`data`物件具有預設匯出的`default`屬性，其他屬性具有指定exports的名稱及其對應的值。
+`data`物件具有預設匯出的`default`屬性，其他屬性具有指定 exports 的名稱及其對應的值。
 
 </p>
 </details>
@@ -2857,9 +2857,9 @@ console.log(typeof member)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
-class是建構函數的語法糖，如果用建構函數的方式來重寫`Person`class則會是：
+class 是建構函數的語法糖，如果用建構函數的方式來重寫`Person`class 則會是：
 
 ```javascript
 function Person() {
@@ -2889,11 +2889,11 @@ console.log(newList.push(5))
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D
+#### 答案：D
 
 `.push`函數回傳陣列的長度，而不是陣列本身！通過將`newList`設置為`[1,2,3].push(4)`，實際上`newList`等於陣列的新長度：`4`。
 
-然後，嘗試在`newList`上使用`.push`函數。由於`newList`是數值`4`，拋出TypeError。
+然後，嘗試在`newList`上使用`.push`函數。由於`newList`是數值`4`，拋出 TypeError。
 
 </p>
 </details>
@@ -2920,7 +2920,7 @@ console.log(giveLydiaChocolate.prototype)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D
+#### 答案：D
 
 正規式函數，例如`giveLydiaPizza`函數，有一個`prototype`屬性，它是一個帶有`constructor`屬性的物件（原型物件）。然而，箭頭函數，例如`giveLydiaChocolate`函數，沒有這個`prototype`屬性。嘗試使用`giveLydiaChocolate.prototype`存取`prototype`屬性時會得到`undefined`。
 
@@ -2949,12 +2949,12 @@ for (const [x, y] of Object.entries(person)) {
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 `Object.entries()`函數回傳一個給定物件本身可枚舉屬性的鍵值對陣列，上述情況回傳一個二維陣列，陣列每個元素是一個包含鍵和值的陣列：
 
-`[['name'，'Lydia']，['age'，21]]`
+`[['name','Lydia'],['age', 21]]`
 
-使用`for-of`循環，我們可以迭代陣列中的每個元素，上述情況是子陣列。我們可以使用`const [x，y]`在`for-of`循環中解構子陣列。 `x`等於子陣列中的第一個元素，`y`等於子陣列中的第二個元素。
+使用`for-of`循環，我們可以迭代陣列中的每個元素，上述情況是子陣列。我們可以使用`const [x，y]`在`for-of`循環中解構子陣列。`x`等於子陣列中的第一個元素，`y`等於子陣列中的第二個元素。
 
 第一個子陣列是`[“name”，“Lydia”]`，其中`x`等於`name`，而`y`等於`Lydia`。
 第二個子陣列是`[“age”，21]`，其中`x`等於`age`，而`y`等於`21`。
@@ -2981,7 +2981,7 @@ getItems(["banana", "apple"], "pear", "orange")
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D
+#### 答案：D
 
 `... args`是剩餘參數，剩餘參數的值是一個包含所有剩餘參數的陣列，**並且只能作為最後一個參數**。上面示範中，剩餘參數是第二個參數，這是不可能的，並會拋出語法錯誤。
 
@@ -3023,19 +3023,19 @@ console.log(nums(1, 2))
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
 
-在JavaScript中，我們不必硬性寫分號(`;`)，但是JavaScript引擎仍然在語法之後自動補上分號。這稱為**自動分號插入**。例如，一個語法可以是變數，或者像`throw`、`return`、`break`這樣的關鍵字。
+在 JavaScript 中，我們不必硬性寫分號 (`;`)，但是 JavaScript 引擎仍然在語法之後自動補上分號。這稱為**自動分號插入**。例如，一個語法可以是變數，或者像`throw`、`return`、`break`這樣的關鍵字。
 
-在這裡，我們在新的一行上寫了一個`return`語法和另一個值`a + b `。然而，由於它是一個新的一行，引擎並不知道它實際上是我們想要回傳的值。相反，它會在`return`後面自動補上分號。你可以這樣看:
+在這裡，我們在新的一行上寫了一個`return`語法和另一個值`a + b `。然而，由於它是一個新的一行，引擎並不知道它實際上是我們想要回傳的值。相反，它會在`return`後面自動補上分號。你可以這樣看：
 
 ```javascript
   return;
   a + b
 ```
 
-這意味著永遠不會到達`a + b`，因為函數在`return`關鍵字之後停止執行。如果沒有回傳值，就像這裡，函數回傳`undefined`。注意，在`if/else`語法之後沒有自動插入!
+這意味著永遠不會到達`a + b`，因為函數在`return`關鍵字之後停止執行。如果沒有回傳值，就像這裡，函數回傳`undefined`。注意，在`if/else`語法之後沒有自動插入！
 
 </p>
 </details>
@@ -3068,7 +3068,7 @@ console.log(member.name)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
 
 我們可以將class設置為等於其他class/函數建構函數。在這種情況下，我們將`Person`設置為`AnotherPerson`。這個建構函數的名字是`Sarah`，所以新的`Person`實例`member`上的name屬性是`Sarah`。
@@ -3097,12 +3097,12 @@ console.log(Object.keys(info))
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D
+#### 答案：D
 
 
-`Symbol`類型是不可枚舉的。 `Object.keys`函數回傳物件上的所有可枚舉的鍵屬性。 `Symbol`類型是不可見的，並回傳一個空陣列。記錄整個物件時，所有屬性都是可見的，甚至是不可枚舉的屬性。
+`Symbol`類型是不可枚舉的。`Object.keys`函數回傳物件上的所有可枚舉的鍵屬性。`Symbol`類型是不可見的，並回傳一個空陣列。記錄整個物件時，所有屬性都是可見的，甚至是不可枚舉的屬性。
 
-這是`Symbol`的眾多特性之一：除了表示完全唯一的值（防止物件意外名稱衝突，例如當使用2個想要向同一物件添加屬性的庫時），您還可以`隱藏`這種方式物件的屬性（儘管不完全。你仍然可以使用`Object.getOwnPropertySymbols()`函數存取`Symbol`。
+這是`Symbol`的眾多特性之一：除了表示完全唯一的值（防止物件意外名稱衝突，例如當使用 2 個想要向同一物件添加屬性的庫時），您還可以`隱藏`這種方式物件的屬性（儘管不完全。你仍然可以使用`Object.getOwnPropertySymbols()`函數存取`Symbol`。
 
 </p>
 </details>
@@ -3129,7 +3129,7 @@ console.log(getUser(user))
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
 `getList`函數接收一個陣列作為其參數。在`getList`函數的括號之間，我們立即解構這個陣列。您可以這樣表達：
 
@@ -3138,7 +3138,7 @@ console.log(getUser(user))
 
 使用剩餘的參數`... y`，我們將所有剩餘參數放在一個陣列中。在這種情況下，其餘的參數是`2`，`3`和`4`。 `y`的值是一個陣列，包含所有其餘參數。在這種情況下，`x`的值等於`1`，所以當我們輸出`[x，y]`時，會輸出`[1，[2,3,4]]`。
 
- `getUser`函數接收一個物件。對於箭頭函數，如果只回傳一個值，我們不必編寫大括號。但是，如果您想從一個箭頭函數回傳一個物件，您必須在小括號之間編寫它，否則不會回傳任何值!下面的函數將回傳一個物件:
+ `getUser`函數接收一個物件。對於箭頭函數，如果只回傳一個值，我們不必編寫大括號。但是，如果您想從一個箭頭函數回傳一個物件，您必須在小括號之間編寫它，否則不會回傳任何值！下面的函數將回傳一個物件：
 
 ```const getUser = user => ({ name: user.name, age: user.age })```
 
@@ -3164,14 +3164,14 @@ console.log(name())
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
 變數`name`保存字串的值，該字串不是函數，因此無法呼叫。
 
-當值不是預期類型時，會拋出`TypeErrors`。 JavaScript期望`name`是一個函數，因為我們試圖呼叫它。但它是一個字串，因此拋出`TypeError`：`name is not a function`
+當值不是預期類型時，會拋出`TypeErrors`。JavaScript 期望`name`是一個函數，因為我們試圖呼叫它。但它是一個字串，因此拋出`TypeError`：`name is not a function`
 
-當你編寫了一些非有效的JavaScript時，會拋出語法錯誤，例如當你把`return`這個詞寫成`retrun`時。
-當JavaScript無法找到您嘗試存取的值的引用時，拋出`ReferenceErrors`。
+當你編寫了一些非有效的 JavaScript 時，會拋出語法錯誤，例如當你把`return`這個詞寫成`retrun`時。
+當 JavaScript 無法找到您嘗試存取的值的引用時，拋出`ReferenceErrors`。
 
 </p>
 </details>
@@ -3180,7 +3180,7 @@ console.log(name())
 ###### 100. 將會輸出什麽內容？
 
 ```javascript
-// 🎉✨ 耶! 我終於翻到100題了! 噢耶! ✨🎉
+// 🎉✨ 耶！我終於翻到 100 題了！噢耶！✨🎉
 
 const output = `${[] && 'Im'}possible!
 You should${'' && `n't`} see a therapist after so much JavaScript lol`
@@ -3194,12 +3194,12 @@ You should${'' && `n't`} see a therapist after so much JavaScript lol`
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
 
 `[]`是一個真值。使用`&&`運算子，如果左側值是真值，則回傳右側值。在這種情況下，左側值`[]`是一個真值，所以回傳`Im`。
 
-`""`是一個假值。如果左側值是假的，則不回傳任何內容。 `n't`不會被退回。
+`""`是一個假值。如果左側值是假的，則不回傳任何內容。`n't`不會被退回。
 
 </p>
 </details>
@@ -3223,15 +3223,15 @@ console.log(one, two, three)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
 使用`||`運算子，我們可以得到第一個真值。如果所有值都是假值，則得到最後一個值。
 
-`（false || {} || null）`：空物件`{}`是一個真值。這是第一個（也是唯一的）真值，它將被得到。 `one`等於`{}`。
+`（false || {} || null）`：空物件`{}`是一個真值。這是第一個（也是唯一的）真值，它將被得到。`one`等於`{}`。
 
-`（null || false ||“”）`：所有值都是假值。這意味著得到傳遞的值`""`。 `two`等於`""`。
+`（null || false ||“”）`：所有值都是假值。這意味著得到傳遞的值`""`。`two`等於`""`。
 
-`（[] || 0 ||“”）`：空陣列`[]`是一個真值。這是第一個得到的真值。 `three`等於`[]`。
+`（[] || 0 ||“”）`：空陣列`[]`是一個真值。這是第一個得到的真值。`three`等於`[]`。
 
 </p>
 </details>
@@ -3264,14 +3264,14 @@ secondFunction()
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D
+#### 答案：D
 
 
-有了promise，我們通常會說：當我想要呼叫某個函數，但是由於它可能需要一段時間，因此暫時將它放在一邊。只有當某個值被resolved/rejected，並且執行序為空時才使用這個值。
+有了 promise，我們通常會說：當我想要呼叫某個函數，但是由於它可能需要一段時間，因此暫時將它放在一邊。只有當某個值被 resolved/rejected，並且執行序為空時才使用這個值。
 
-我們可以在`async`函數中通過`.then`和`await`關鍵字獲得該值。儘管我們可以通過`.then`和`await`獲得promise的值，但是它們的運作方式不同。
+我們可以在`async`函數中通過`.then`和`await`關鍵字獲得該值。儘管我們可以通過`.then`和`await`獲得 promise 的值，但是它們的運作方式不同。
 
-在`firstFunction`中，當執行到`myPromise`函數時我們將其放在一邊，即promise進入微任務佇列，其他後面的程式（`console.log('second')`）照常執行，因此`second `被輸出，`firstFunction`函數到此執行完畢，執行序中任務佇列被清空，此時開始執行微任務佇列中的任務，`I have resolved`被輸出。
+在`firstFunction`中，當執行到`myPromise`函數時我們將其放在一邊，即 promise 進入微任務佇列，其他後面的程式（`console.log('second')`）照常執行，因此`second `被輸出，`firstFunction`函數到此執行完畢，執行序中任務佇列被清空，此時開始執行微任務佇列中的任務，`I have resolved`被輸出。
 
 在`secondFunction`函數中，我們通過`await`關鍵字，暫停了後面程式的執行，直到異步函數的值被解析才開始後面程式的執行。這意味著，它會等著直到 `myPromise` 以值`I have resolved`被`resolve`之後，下一行`second`才開始執行。
 
@@ -3302,15 +3302,15 @@ for (let item of set) {
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
-“+”運算子不僅用於相加數字，還可以使用它來連接字串。每當JavaScript引擎發現一個或多個值不是數字時，就會將數字強制為字串。
+“+”運算子不僅用於相加數字，還可以使用它來連接字串。每當 JavaScript 引擎發現一個或多個值不是數字時，就會將數字強制為字串。
 
-第一個是數字1。 1 + 2得到數字3。
+第一個是數字 1。1 + 2 得到數字 3。
 
-但是，第二個是字串“Lydia”。 “Lydia”是一個字串，2是一個數字：2被強制轉換為字串。 “Lydia”和“2”被連接起來，產生字串“Lydia2”。
+但是，第二個是字串“Lydia”。 “Lydia”是一個字串，2 是一個數字：2 被強制轉換為字串。 “Lydia”和“2”被連接起來，產生字串“Lydia2”。
 
-`{name：“ Lydia”}`是一個物件。數字和物件都不是字串，因此將二者都字串化。每當我們對正規式物件進行字串化時，它就會變成`[Object object]`。與“2”串聯的“ [Object object]”成為“[Object object]2”。
+`{name：“Lydia”}`是一個物件。數字和物件都不是字串，因此將二者都字串化。每當我們對正規式物件進行字串化時，它就會變成`[Object object]`。與“2”串聯的“ [Object object]”成為“[Object object]2”。
 
 </p>
 </details>
@@ -3330,11 +3330,11 @@ Promise.resolve(5)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
-我們可以將我們想要的任何類型的值傳遞`Promise.resolve`，無論是否`promise`。該函數本身回傳帶有已解析值的`Promise` (`<fulfilled>`)。如果您傳遞正規式函數，它將是具有正規式值的已解決`promise`。如果你通過了promise，它將是一個已經resolved的且帶有傳的值的promise。
+我們可以將我們想要的任何類型的值傳遞`Promise.resolve`，無論是否`promise`。該函數本身回傳帶有已解析值的`Promise` (`<fulfilled>`)。如果您傳遞正規式函數，它將是具有正規式值的已解決`promise`。如果你通過了 promise，它將是一個已經 resolved 的且帶有傳的值的 promise。
 
-上述情況，我們傳了數字5，因此回傳一個resolved狀態的promise，resolve值為`5`
+上述情況，我們傳了數字 5，因此回傳一個 resolved 狀態的 promise，resolve 值為`5`
 
 </p>
 </details>
@@ -3364,7 +3364,7 @@ compareMembers(person)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
 物件通過參考位址傳遞。當我們檢查物件的嚴格相等性（===）時，我們正在比較它們的參考位址。
 
@@ -3372,7 +3372,7 @@ compareMembers(person)
 
 這意味著兩個值都引用緩存中的同一位置，因此它們是相等的。
 
-執行“ else”語句中的代碼塊，並記錄`They are the same!` 。
+執行“else”語句中的代碼塊，並記錄`They are the same!`。
 
 </p>
 </details>
@@ -3403,14 +3403,14 @@ console.log(colorConfig.colors[1])
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D
+#### 答案：D
 
-在JavaScript中，我們有兩種存取物件屬性的方法：括號表示法或點表示法。在此範例中，我們使用點表示法（`colorConfig.colors`）代替括號表示法（`colorConfig [“ colors”]`）。
+在 JavaScript 中，我們有兩種存取物件屬性的方法：括號表示法或點表示法。在此範例中，我們使用點表示法（`colorConfig.colors`）代替括號表示法（`colorConfig [“colors”]`）。
 
-使用點表示法，JavaScript會嘗試使用該確切名稱在物件上查找屬性。在此範例中，JavaScript嘗試在colorConfig物件上找到名為colors的屬性。沒有名為“colors”的屬性，因此得到“undefined”。
+使用點表示法，JavaScript 會嘗試使用該確切名稱在物件上查找屬性。在此範例中，JavaScript 嘗試在 colorConfig 物件上找到名為 colors 的屬性。沒有名為“colors”的屬性，因此得到“undefined”。
 然後，我們嘗試使用`[1]`存取第一個元素的值。我們無法對未定義的值執行此操作，因此會拋出`Cannot read property '1' of undefined`。
 
-JavaScript解釋（或取消裝箱）語句。當我們使用中括號表示法時，它會看到第一個左方括號`[`並一直進行下去，直到找到右方括號`]`。只有這樣，它才會評估該語句。如果我們使用了colorConfig [colors [1]]，它將得到colorConfig物件上red屬性的值。
+JavaScript 解釋（或取消裝箱）語句。當我們使用中括號表示法時，它會看到第一個左方括號`[`並一直進行下去，直到找到右方括號`]`。只有這樣，它才會評估該語句。如果我們使用了 colorConfig [colors [1]]，它將得到 colorConfig 物件上 red 屬性的值。
 
 
 </p>
@@ -3429,15 +3429,15 @@ console.log('❤️' === '❤️')
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
-在內部，表情符號是unicode。 heat表情符號的unicode是`“ U + 2764 U + FE0F”`。對於相同的表情符號，它們總是相同的，因此我們將兩個相等的字串相互比較，這將回傳true。
+在內部，表情符號是 unicode。heat 表情符號的 unicode 是`“U + 2764 U + FE0F”`。對於相同的表情符號，它們總是相同的，因此我們將兩個相等的字串相互比較，這將回傳 true。
 
 </p>
 </details>
 
 ---
-###### 108. 哪些函數修改了原本的陣列?
+###### 108. 哪些函數修改了原本的陣列？
 
 
 ```javascript
@@ -3459,9 +3459,9 @@ emojis.splice(1, 2, '✨')
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D
+#### 答案：D
 
-使用`splice`方法，我們透過刪除，取代或增加元素來修改原始陣列。在這種情況下，我們從索引1中刪除了2個元素（我們刪除了`'🥑'`和`'😍'`），同時增加了✨emoji表情。
+使用`splice`方法，我們透過刪除，取代或增加元素來修改原始陣列。在這種情況下，我們從索引 1 中刪除了 2 個元素（我們刪除了`'🥑'`和`'😍'`），同時增加了✨emoji 表情。
 
 `map`，`filter`和`slice`回傳一個新陣列，`find`回傳一個元素，而`reduce`回傳一個計算過的值。
 
@@ -3488,11 +3488,11 @@ console.log(food)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
-我們將`info`物件上的`favoriteFood`屬性的值設置為披薩表情符號“🍕”的字串。字串是原始內容類型。在JavaScript中，原始內容類型通過值起作用
+我們將`info`物件上的`favoriteFood`屬性的值設置為披薩表情符號“🍕”的字串。字串是原始內容類型。在 JavaScript 中，原始內容類型通過值起作用
 
-在這種情況下，我們將`info`物件上的`favoriteFood`屬性的值設置為等於`food`陣列中的第一個元素的值，字串為披薩表情符號（`'🍕'` ）。字串是原始內容類型，並且通過值進行交換，我們更改`info`物件上`favoriteFood`屬性的值。 food陣列沒有改變，因為favoriteFood的值只是該陣列中第一個元素的值的複製，並且與該元素上的元素沒有相同的緩存引用食物`[0]`。當我們記錄食物時，它仍然是原始陣列`['🍕'，'🍫'，'🥑'，'🍔']`。
+在這種情況下，我們將`info`物件上的`favoriteFood`屬性的值設置為等於`food`陣列中的第一個元素的值，字串為披薩表情符號（`'🍕'`）。字串是原始內容類型，並且通過值進行交換，我們更改`info`物件上`favoriteFood`屬性的值。food 陣列沒有改變，因為 favoriteFood 的值只是該陣列中第一個元素的值的複製，並且與該元素上的元素沒有相同的緩存引用食物`[0]`。當我們記錄食物時，它仍然是原始陣列`['🍕'，'🍫'，'🥑'，'🍔']`。
 
 </p>
 </details>
@@ -3512,20 +3512,20 @@ JSON.parse()
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
-使用`JSON.parse()`函數，我們可以將JSON字串解析為JavaScript值。
+使用`JSON.parse()`函數，我們可以將 JSON 字串解析為 JavaScript 值。
 
 ```javascript
-// 將數字字串化為有效的JSON，然後將JSON字串解析為JavaScript值:
+// 將數字字串化為有效的 JSON，然後將 JSON 字串解析為 JavaScript 值：
 const jsonNumber = JSON.stringify(4) // '4'
 JSON.parse(jsonNumber) // 4
 
-// 將陣列值字串化為有效的JSON，然後將JSON字串解析為JavaScript值:
+// 將陣列值字串化為有效的 JSON，然後將 JSON 字串解析為 JavaScript 值：
 const jsonArray = JSON.stringify([1, 2, 3]) // '[1, 2, 3]'
 JSON.parse(jsonArray) // [1, 2, 3]
 
-// 將物件字串化為有效的JSON，然後將JSON字串解析為JavaScript值:
+// 將物件字串化為有效的 JSON，然後將 JSON 字串解析為 JavaScript 值：
 const jsonArray = JSON.stringify({ name: "Lydia" }) // '{"name":"Lydia"}'
 JSON.parse(jsonArray) // { name: 'Lydia' }
 ```
@@ -3554,13 +3554,13 @@ getName()
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D 
+#### 答案：D 
 
-每個函數都有其自己的執行上下文。 `getName`函數首先在其自身的上下文（範圍）內查找，以查看其是否包含我們嘗試存取的變數`name`。上述情況，`getName`函數包含其自己的`name`變數：我們用`let`關鍵字和`Sarah`的值定義變數`name`。
+每個函數都有其自己的執行上下文。`getName`函數首先在其自身的上下文（範圍）內查找，以查看其是否包含我們嘗試存取的變數`name`。上述情況，`getName`函數包含其自己的`name`變數：我們用`let`關鍵字和`Sarah`的值定義變數`name`。
 
-帶有`let`關鍵字（和`const`）的變數被提升，但是與`var`不同，它不會被***初始化***。在我們定義（初始化）它們之前，無法存取它們。這稱為“暫時性死區”。當我們嘗試在定義變數之前存取變數時，JavaScript會拋出`ReferenceError: Cannot access 'name' before initialization`。
+帶有`let`關鍵字（和`const`）的變數被提升，但是與`var`不同，它不會被***初始化***。在我們定義（初始化）它們之前，無法存取它們。這稱為“暫時性死區”。當我們嘗試在定義變數之前存取變數時，JavaScript 會拋出`ReferenceError: Cannot access 'name' before initialization`。
 
-如果我們不在`getName`函數中定義`name`變數，則javascript引擎會查看原型鏈。會找到其外部作用域有一個名為`name`的變數，其值為`Lydia`。在這種情況下，它將輸出`Lydia`：
+如果我們不在`getName`函數中定義`name`變數，則 javascript 引擎會查看原型鏈。會找到其外部作用域有一個名為`name`的變數，其值為`Lydia`。在這種情況下，它將輸出`Lydia`：
 
 ```javascript
 let name = 'Lydia'
@@ -3602,18 +3602,18 @@ console.log(two.next().value)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
-透過`yield` 關鍵字, 我們在`Generator` 函數裡執行`yield`語法. 透過`yield*` 關鍵字, 我們可以在一個`Generator` 函數裡面執行（`yield`語法）另一個`Generator ` 函數, 或可遍歷的物件(如陣列).
+透過`yield` 關鍵字，我們在`Generator` 函數裡執行`yield`語法。透過`yield*` 關鍵字，我們可以在一個`Generator` 函數裡面執行（`yield`語法）另一個`Generator ` 函數，或可遍歷的物件 (如陣列).
 
-在函數 `generatorOne` 中, 我們透過 `yield` 關鍵字 yield 了一個完整的陣列 `['a', 'b', 'c']`。函數`one`透過`next`方法回傳的物件的`value` 屬性的值 (`one.next().value`) 等價於陣列 `['a', 'b', 'c']`.
+在函數 `generatorOne` 中，我們透過 `yield` 關鍵字 yield 了一個完整的陣列 `['a', 'b', 'c']`。函數`one`透過`next`方法回傳的物件的`value` 屬性的值 (`one.next().value`) 等價於陣列 `['a', 'b', 'c']`.
 
 ```javascript
 console.log(one.next().value) // ['a', 'b', 'c']
 console.log(one.next().value) // undefined
 ```
 
-在函數 `generatorTwo` 中, 我們使用 `yield*` 關鍵字。就相當於函數`two`第一個`yield`的值, 等價於在迭代器中第一個 `yield` 的值。陣列`['a', 'b', 'c']`就是這個迭代器. 第一個`yield` 的值就是`a`, 所以我們第一次呼叫`two.next().value`時, 就回傳`a`。
+在函數 `generatorTwo` 中，我們使用 `yield*` 關鍵字。就相當於函數`two`第一個`yield`的值，等價於在迭代器中第一個 `yield` 的值。陣列`['a', 'b', 'c']`就是這個迭代器。第一個`yield` 的值就是`a`, 所以我們第一次呼叫`two.next().value`時，就回傳`a`。
 
 ```javascript
 console.log(two.next().value) // 'a'
@@ -3641,9 +3641,9 @@ console.log(`${(x => x)('I love')} to program`)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
-帶有模板字面量的表達式優先被執行。相當於字串會包含表達式，這個立即執行函數`(x => x)('I love')` 回傳的值. 我們向箭頭函數`x => x` 傳遞`'I love'` 作為參數。 `x` 等價於回傳的 `'I love'`。這就是結果 `I love to program`。
+帶有模板字面量的表達式優先被執行。相當於字串會包含表達式，這個立即執行函數`(x => x)('I love')` 回傳的值。我們向箭頭函數`x => x` 傳遞`'I love'` 作為參數。 `x` 等價於回傳的 `'I love'`。這就是結果 `I love to program`。
 
 </p>
 </details>
@@ -3669,9 +3669,9 @@ config = null
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
-一般情況下當我們將物件賦值為 `null`, 那些物件會被進行 _垃圾回收（garbage collected）_ 因為已經沒有對這些物件的引用了。然而，`setInterval`的參數是一個箭頭函數（所以上下文綁定到物件 `config` 了），函數仍然保留著對 `config`的引用。只要存在引用，物件就不會被垃圾回收。因為沒有被垃圾回收，`setInterval` 的每1000ms (1s)會被呼叫一次。
+一般情況下當我們將物件賦值為 `null`, 那些物件會被進行 _垃圾回收（garbage collected）_ 因為已經沒有對這些物件的引用了。然而，`setInterval`的參數是一個箭頭函數（所以上下文綁定到物件 `config` 了），函數仍然保留著對 `config`的引用。只要存在引用，物件就不會被垃圾回收。因為沒有被垃圾回收，`setInterval` 的每 1000ms (1s) 會被呼叫一次。
 
 </p>
 </details>
@@ -3701,9 +3701,9 @@ myMap.get(() => 'greeting')
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
-當透過 `set` 函數增加一個鍵值對，一個傳遞給 `set`函數的參數將會是鍵名，第二個參數將會是值。在這個case裡，鍵名為 _函數_ `() => 'greeting'`，值為`'Hello world'`。 `myMap` 現在就是 `{ () => 'greeting' => 'Hello world!' }`。
+當透過 `set` 函數增加一個鍵值對，一個傳遞給 `set`函數的參數將會是鍵名，第二個參數將會是值。在這個 case 裡，鍵名為 _函數_ `() => 'greeting'`，值為`'Hello world'`。 `myMap` 現在就是 `{ () => 'greeting' => 'Hello world!' }`。
 
 1 是錯的，因為鍵名不是 `'greeting'` 而是 `() => 'greeting'`。
 3 是錯的，因為我們給`get` 函數傳遞了一個新的函數。物件受 _引用_ 影響。函數也是物件，因此兩個函數嚴格上並不等價，儘管他們相同：他們有兩個不同的緩存引用地址。
@@ -3740,13 +3740,13 @@ console.log(person)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
 函數 `changeAge` 和函數 `changeAgeAndName` 有著不同的參數，定義一個 _新_ 生成的物件 `{ ...person }`。這個物件有著所有 `person` 物件 中 k/v 值的副本。
 
-首項, 我們呼叫 `changeAge` 函數並傳遞 `person` 物件作為它的參數。這個函數對 `age` 屬性進行加一操作。 `person` 現在是 `{ name: "Lydia", age: 22 }`。
+首項，我們呼叫 `changeAge` 函數並傳遞 `person` 物件作為它的參數。這個函數對 `age` 屬性進行加一操作。`person` 現在是 `{ name: "Lydia", age: 22 }`。
 
-然後，我們呼叫函數 `changeAgeAndName` ，然而我們沒有傳遞參數。取而代之，`x` 的值等價 _new_ 生成的物件: `{ ...person }`。因為它是一個新生成的物件，它並不會對物件 `person` 造成任何副作用。 `person` 仍然等價於 `{ name: "Lydia", age: 22 }`。
+然後，我們呼叫函數 `changeAgeAndName`，然而我們沒有傳遞參數。取而代之，`x` 的值等價 _new_ 生成的物件：`{ ...person }`。因為它是一個新生成的物件，它並不會對物件 `person` 造成任何副作用。`person` 仍然等價於 `{ name: "Lydia", age: 22 }`。
 
 </p>
 </details>
@@ -3768,9 +3768,9 @@ function sumValues(x, y, z) {
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
-通過展開語法 `...`，我們可以 _展開_ 單個可迭代的元素。函數 `sumValues` function 接收三個參數： `x`, `y` 和 `z`。 `...[1, 2, 3]` 的執行結果為 `1, 2, 3`，將會傳遞給函數 `sumValues`。
+通過展開語法 `...`，我們可以 _展開_ 單個可迭代的元素。函數 `sumValues` function 接收三個參數：`x`, `y` 和 `z`。`...[1, 2, 3]` 的執行結果為 `1, 2, 3`，將會傳遞給函數 `sumValues`。
 
 </p>
 </details>
@@ -3793,9 +3793,9 @@ console.log(list[(num += 1)]);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
-透過 `+=` 運算子，我們對變數 `num` 進行加 `1` 操作。 `num` 有初始值 `1`，因此 `1 + 1` 的執行結果為 `2`。陣列 `list` 的第二項為 🥰，`console.log(list[2])` 輸出 🥰.
+透過 `+=` 運算子，我們對變數 `num` 進行加 `1` 操作。`num` 有初始值 `1`，因此 `1 + 1` 的執行結果為 `2`。陣列 `list` 的第二項為 🥰，`console.log(list[2])` 輸出 🥰.
 
 </p>
 </details>
@@ -3830,13 +3830,13 @@ console.log(member.getLastName?.());
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
-通過ES10 或TS3.7+[可選鏈運算子`?.`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators/%E5%8F%AF% E9%80%89%E9%93%BE)，我們不再需要顯式檢測更深層的嵌套值是否有效。如果我們嘗試存取 `undefined` 或 `null` 的值 (_nullish_)，表達將會短路並回傳 `undefined`.
+通過 ES10 或 TS3.7+[可選鏈運算子`?.`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators/%E5%8F%AF% E9%80%89%E9%93%BE)，我們不再需要顯式檢測更深層的嵌套值是否有效。如果我們嘗試存取 `undefined` 或 `null` 的值 (_nullish_)，表達將會短路並回傳 `undefined`.
 
-`person.pet?.name`： `person` 有一個名為 `pet` 的屬性： `person.pet` 不是 nullish。它有個名為 `name` 的屬性，並回傳字串 `Mara`。
-`person.pet?.family?.name`： `person` 有一個名為`pet` 的屬性： `person.pet` 不是nullish. `pet` _並沒有_ 一個名為`family` 的屬性, ` person.pet.family` 是nullish。表達式回傳 `undefined`。
-`person.getFullName?.()`： `person` 有一個名為 `getFullName` 的屬性： `person.getFullName()` 不是 nullish 並可以被呼叫，回傳字串 `Lydia Hallie`。
+`person.pet?.name`：`person` 有一個名為 `pet` 的屬性：`person.pet` 不是 nullish。它有個名為 `name` 的屬性，並回傳字串 `Mara`。
+`person.pet?.family?.name`：`person` 有一個名為`pet` 的屬性：`person.pet` 不是 nullish. `pet` _並沒有_ 一個名為`family` 的屬性，` person.pet.family` 是 nullish。表達式回傳 `undefined`。
+`person.getFullName?.()`：`person` 有一個名為 `getFullName` 的屬性：`person.getFullName()` 不是 nullish 並可以被呼叫，回傳字串 `Lydia Hallie`。
 `member.getLastName?.()`: `member` is not defined: `member.getLastName()` is nullish. The expression returns `undefined`.
 
 </p>
@@ -3863,9 +3863,9 @@ if (groceries.indexOf("banana")) {
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
-我們傳遞了一個狀態 `groceries.indexOf("banana")` 給if語法。 `groceries.indexOf("banana")` 回傳 `0`， 一個 falsy 的值。因為if語法的狀態為 falsy，`else` 塊區內的代碼執行，並且 `We don't have to buy bananas!` 被輸出.
+我們傳遞了一個狀態 `groceries.indexOf("banana")` 給 if 語法。`groceries.indexOf("banana")` 回傳 `0`，一個 falsy 的值。因為 if 語法的狀態為 falsy，`else` 塊區內的代碼執行，並且 `We don't have to buy bananas!` 被輸出。
 
 </p>
 </details>
@@ -3892,9 +3892,9 @@ console.log(config.language);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D
+#### 答案：D
 
-函數 `language` 是一個 `setter`。 Setters 並不保存一個實際值，它們的使命在於 _修改_ 屬性。當呼叫函數 `setter`， 回傳 `undefined`。
+函數 `language` 是一個 `setter`。Setters 並不保存一個實際值，它們的使命在於 _修改_ 屬性。當呼叫函數 `setter`，回傳 `undefined`。
 
 </p>
 </details>
@@ -3918,9 +3918,9 @@ console.log(!typeof name === "string");
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
-`typeof name` 回傳 `"string"`。字串 `"string"` 是一個 truthy 的值，因此 `!typeof name` 回傳一個布林值 `false`。 `false === "object"` 和 `false === "string"` 都回傳 `false`。
+`typeof name` 回傳 `"string"`。字串 `"string"` 是一個 truthy 的值，因此 `!typeof name` 回傳一個布林值 `false`。`false === "object"` 和 `false === "string"` 都回傳 `false`。
 
 （如果我們想檢測一個值的類型，我們應該用 `!==` 而不是 `!typeof`）
 
@@ -3947,7 +3947,7 @@ add(4)(5)(6);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
 函數 `add` 是一個回傳 回傳箭頭函數的箭頭函數 的箭頭函數（still with me?）。第一個函數接收一個值為 `4` 的參數 `x`。我們呼叫第二個函數，它接收一個值為 `5` 的參數 `y`。然後我們呼叫第三個函數，它接收一個值為 `6` 的參數 `z`。當我們嘗試在最後一個箭頭函數中獲取 `x`, `y` 和 `z` 的值，JS 引擎根據作用域鏈去找 `x` 和 `y` 的值。得到 `4` `5` `6`.
 
@@ -3980,9 +3980,9 @@ async function* range(start, end) {
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
-我們給 函數range 傳遞： `Promise{1}`, `Promise{2}`, `Promise{3}`，Generator 函數 `range` 回傳一個全是 async object promise 陣列。我們將 async object 賦值給變數 `gen`，之後我們使用`for await ... of` 進行循環遍歷。我們將回傳的 Promise 實例賦值給 `item`： 第一個回傳 `Promise{1}`， 第二個回傳 `Promise{2}`，之後是 `Promise{3}`。因為我們正 _awaiting_ `item` 的值，resolved 狀態的 promise，promise陣列的resolved _值_ 以此為： `1`，`2`，`3`.
+我們給 函數 range 傳遞：`Promise{1}`, `Promise{2}`, `Promise{3}`，Generator 函數 `range` 回傳一個全是 async object promise 陣列。我們將 async object 賦值給變數 `gen`，之後我們使用`for await ... of` 進行循環遍歷。我們將回傳的 Promise 實例賦值給 `item`：第一個回傳 `Promise{1}`，第二個回傳 `Promise{2}`，之後是 `Promise{3}`。因為我們正 _awaiting_ `item` 的值，resolved 狀態的 promise，promise 陣列的 resolved _值_ 以此為：`1`，`2`，`3`.
 
 </p>
 </details>
@@ -4006,9 +4006,9 @@ myFunc(1, 2, 3);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D
+#### 答案：D
 
-`myFunc` 預期接收一個包含 `x`, `y` 和 `z` 屬性的物件作為它的參數。因為我們僅僅傳遞三個單獨的數字值(1, 2, 3) 而不是一個含有`x`, `y` 和`z` 屬性的物件({x: 1, y: 2, z: 3}) ， `x`, `y` 和`z` 有著各自的預設值`undefined`.
+`myFunc` 預期接收一個包含 `x`, `y` 和 `z` 屬性的物件作為它的參數。因為我們僅僅傳遞三個單獨的數字值 (1, 2, 3) 而不是一個含有`x`, `y` 和`z` 屬性的物件 ({x: 1, y: 2, z: 3}) ，`x`, `y` 和`z` 有著各自的預設值`undefined`.
 
 </p>
 </details>
@@ -4042,7 +4042,7 @@ console.log(getFine(130, 300))
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
 通過函數 `Intl.NumberFormat`，我們可以格式化任意區域的數字值。我們對數字值 `130` 進行 `mile-per-hour` 作為 `unit` 的 `en-US` 區域 格式化，結果為 `130 mph`。對數字值 `300` 進行 `USD` 作為 `currency` 的 `en-US` 區域格式化，結果為 `$300.00`.
 
@@ -4068,7 +4068,7 @@ console.log(spookyItems);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
 通過解構物件們，我們可以從右手邊的物件中拆出值，並且將拆出的值分配給左手邊物件同名的屬性。在這種情況下，我們將值 "💀" 分配給 `spookyItems[3]`。相當於我們正在篡改陣列 `spookyItems`，我們給它添加了值 "💀"。當輸出 `spookyItems` 時，結果為 `["👻", "🎃", "🕸", "💀"]`。
 
@@ -4098,11 +4098,11 @@ console.log(isNaN(age));
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
-通過函數 `Number.isNaN`，你可以檢測你傳遞的值是否為 _數字值_ 並且是否等於 `NaN`。 `name` 不是一個數字值，因此 `Number.isNaN(name)` 回傳 `false`。 `age` 是一個數字值，但它不等於 `NaN`，因此 `Number.isNaN(age)` 回傳 `false`.
+通過函數 `Number.isNaN`，你可以檢測你傳遞的值是否為 _數字值_ 並且是否等於 `NaN`。`name` 不是一個數字值，因此 `Number.isNaN(name)` 回傳 `false`。`age` 是一個數字值，但它不等於 `NaN`，因此 `Number.isNaN(age)` 回傳 `false`.
 
-通過函數 `isNaN`， 你可以檢測你傳遞的值是否一個 number。 `name` 不是一個 `number`，因此 `isNaN(name)` 回傳 `true`. `age` 是一個 `number` 因此 `isNaN(age)` 回傳 `false`.
+通過函數 `isNaN`，你可以檢測你傳遞的值是否一個 number。`name` 不是一個 `number`，因此 `isNaN(name)` 回傳 `true`. `age` 是一個 `number` 因此 `isNaN(age)` 回傳 `false`.
 
 </p>
 </details>
@@ -4130,9 +4130,9 @@ getInfo();
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D
+#### 答案：D
 
-通過 `const` 關鍵字定義的變數在被初始化之前不可被引用：這被稱之為 _暫時性死區_。在函數 `getInfo` 中, 變數 `randomValue` 定義在`getInfo` 的作用域的此法環境中。在想要對`typeof randomValue` 進行log之前，變數`randomValue` 仍未被初始化： 錯誤`ReferenceError` 被拋出! JS引擎並不會根據作用域鍊網上尋找該變數，因為我們已經在`getInfo`函數中定義了`randomValue` 變數。
+通過 `const` 關鍵字定義的變數在被初始化之前不可被引用：這被稱之為 _暫時性死區_。在函數 `getInfo` 中，變數 `randomValue` 定義在`getInfo` 的作用域的此法環境中。在想要對`typeof randomValue` 進行 log 之前，變數`randomValue` 仍未被初始化：錯誤`ReferenceError` 被拋出！JS 引擎並不會根據作用域鍊網上尋找該變數，因為我們已經在`getInfo`函數中定義了`randomValue` 變數。
 
 </p>
 </details>
@@ -4163,9 +4163,9 @@ const myPromise = Promise.resolve("Woah some cool data");
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
-在 `try` 塊區，我們輸出 `myPromise` 變數的 awaited 值： `"Woah some cool data"`。因為`try` 塊區沒有錯誤拋出，`catch` 塊區的代碼並不執行。 `finally` 塊區的代碼 _總是_ 執行，`"Oh finally!"` 被輸出。
+在 `try` 塊區，我們輸出 `myPromise` 變數的 awaited 值：`"Woah some cool data"`。因為`try` 塊區沒有錯誤拋出，`catch` 塊區的代碼並不執行。`finally` 塊區的代碼 _總是_ 執行，`"Oh finally!"` 被輸出。
 
 </p>
 </details>
@@ -4188,9 +4188,9 @@ console.log(emojis.flat(1));
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
-通過函數 `flat`， 我們可以建立一個新的, 已被扁平化的陣列。被扁平化的深度取決於我們傳遞的值。在這個case裡，我們傳遞了值 `1` (並不必要，這是預設值)，相當於只有第一層的陣列才會被連接。即這個 case 裡的 `['🥑']` and `['✨', '✨', ['🍕', '🍕']]`。連接這兩個陣列得到結果 `['🥑', '✨', '✨', ['🍕', '🍕']]`.
+通過函數 `flat`，我們可以建立一個新的，已被扁平化的陣列。被扁平化的深度取決於我們傳遞的值。在這個 case 裡，我們傳遞了值 `1` (並不必要，這是預設值)，相當於只有第一層的陣列才會被連接。即這個 case 裡的 `['🥑']` and `['✨', '✨', ['🍕', '🍕']]`。連接這兩個陣列得到結果 `['🥑', '✨', '✨', ['🍕', '🍕']]`.
 
 </p>
 </details>
@@ -4228,15 +4228,15 @@ console.log(counterOne.count);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D
+#### 答案：D
 
-`counterOne` 是類 `Counter` 的一個實例。類 Counter 包含一個`count` 屬性在它的建構函數里， 和一個 `increment` 函數。首先，我們通過 `counterOne.increment()` 呼叫函數 `increment` 兩次。現在, `counterOne.count` 為 `2`.
+`counterOne` 是類 `Counter` 的一個實例。類 Counter 包含一個`count` 屬性在它的建構函數里，和一個 `increment` 函數。首先，我們通過 `counterOne.increment()` 呼叫函數 `increment` 兩次。現在，`counterOne.count` 為 `2`.
 
 <img src="https://i.imgur.com/KxLlTm9.png" width="400">
 
 然後，我們建立一個新的變數 `counterTwo` 並將 `counterOne` 的引用地址賦值給它。因為物件受引用地址的影響，我們剛剛建立了一個新的物件，其引用地址和 `counterOne` 的等價。因此它們指向同一塊緩存地址，任何對其的副作用都會影響 `counterTwo`。現在 `counterTwo.count` 為 `2`。
 
-我們呼叫 `counterTwo.increment()` 將 `count` 的值設為 `3`。然後，我們輸出 `counterOne` 裡的count，結果為 `3`。
+我們呼叫 `counterTwo.increment()` 將 `count` 的值設為 `3`。然後，我們輸出 `counterOne` 裡的 count，結果為 `3`。
 
 <img src="https://i.imgur.com/BNBHXmc.png" width="400">
 
@@ -4275,13 +4275,13 @@ funcTwo();
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D
+#### 答案：D
 
-首先，我們呼叫 `funcOne`。在函數 `funcOne` 的第一行，我們呼叫`myPromise` promise _異步操作_。當JS引擎在忙於執行 promise，它繼續執行函數 `funcOne`。下一行 _異步操作_ `setTimeout`，其回呼函數被 Web API 呼叫。 (詳情請參考我關於event loop的文章.)
+首先，我們呼叫 `funcOne`。在函數 `funcOne` 的第一行，我們呼叫`myPromise` promise _異步操作_。當 JS 引擎在忙於執行 promise，它繼續執行函數 `funcOne`。下一行 _異步操作_ `setTimeout`，其回呼函數被 Web API 呼叫。 (詳情請參考我關於 event loop 的文章.)
 
-promise 和 timeout 都是異步操作，函數繼續執行當JS引擎忙於執行promise 和 處理 `setTimeout` 的呼叫。相當於 `Last line!` 首先被輸出， 因為它不是異步操作。執行完 `funcOne` 的最後一行，promise 狀態轉變為 resolved，`Promise!` 被輸出。然而，因為我們呼叫了 `funcTwo()`, 呼叫堆疊不為空，`setTimeout` 的回呼仍不能入堆疊。
+promise 和 timeout 都是異步操作，函數繼續執行當 JS 引擎忙於執行 promise 和 處理 `setTimeout` 的呼叫。相當於 `Last line!` 首先被輸出，因為它不是異步操作。執行完 `funcOne` 的最後一行，promise 狀態轉變為 resolved，`Promise!` 被輸出。然而，因為我們呼叫了 `funcTwo()`, 呼叫堆疊不為空，`setTimeout` 的回呼仍不能入堆疊。
 
-我們現在處於 `funcTwo`，先 _awaiting_ myPromise。通過 `await` 關鍵字， 我們暫停了函數的執行直到 promise 狀態變為 resolved (或 rejected)。然後，我們輸出 `res` 的 awaited 值（因為 promise 本身回傳一個 promise）。接著輸出 `Promise!`。
+我們現在處於 `funcTwo`，先 _awaiting_ myPromise。通過 `await` 關鍵字，我們暫停了函數的執行直到 promise 狀態變為 resolved (或 rejected)。然後，我們輸出 `res` 的 awaited 值（因為 promise 本身回傳一個 promise）。接著輸出 `Promise!`。
 
 下一行就是 _異步操作_ `setTimeout`，其回呼函數被 Web API 呼叫。
 
@@ -4312,7 +4312,7 @@ import * as sum from "./sum";
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
 使用符號 `*`，我們引入文件中的所有值，包括預設和具名。如果我們有以下文件：
 
@@ -4372,13 +4372,13 @@ person.name;
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
 使用 Proxy 物件，我們可以給一個物件添加自定義行為。在這個 case，我們傳遞一個包含以下屬性的物件 `handler` : `set` and `get`。每當我門 _設置_ 屬性值時 `set` 被呼叫，每當我們 _獲取_ 時 `get` 被呼叫。
 
-第一個參數是一個空物件 `{}`，作為 `person` 的值。對於這個物件，自定義行為被定義在物件 `handler`。如果我們向物件 `person` 添加屬性，`set` 將被呼叫。如果我們獲取 `person` 的屬性, `get` 將被呼叫。
+第一個參數是一個空物件 `{}`，作為 `person` 的值。對於這個物件，自定義行為被定義在物件 `handler`。如果我們向物件 `person` 添加屬性，`set` 將被呼叫。如果我們獲取 `person` 的屬性，`get` 將被呼叫。
 
-首先，我們向 proxy 物件(`person.name = "Lydia"`)添加一個屬性 `name`。 `set` 被呼叫並輸出 `"Added a new property!"`。
+首先，我們向 proxy 物件 (`person.name = "Lydia"`) 添加一個屬性 `name`。`set` 被呼叫並輸出 `"Added a new property!"`。
 
 然後，我們獲取 proxy 物件的一個屬性，物件 handler 的屬性 `get` 被呼叫。輸出 `"Accessed a property!"`。
 
@@ -4403,7 +4403,7 @@ Object.seal(person);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
 使用 `Object.seal` 我們可以防止新屬性 _被添加_，或者存在屬性 _被移除_.
 
@@ -4435,7 +4435,7 @@ Object.freeze(person);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
 使用函數 `Object.freeze` 對一個物件進行 _凍結_。不能對屬性進行添加，修改，刪除。
 
@@ -4467,11 +4467,11 @@ myFunc(3);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
-首先我們不傳遞任何參數呼叫 `myFunc()`。因為我們沒有傳遞參數，`num` 和 `value` 獲取它們各自的預設值：num 為 `2`, 而 `value` 為函數 `add` 的回傳值。對於函數 `add`，我們傳遞值為2的 `num` 作為參數。函數 `add` 回傳 `4` 作為 `value` 的值。
+首先我們不傳遞任何參數呼叫 `myFunc()`。因為我們沒有傳遞參數，`num` 和 `value` 獲取它們各自的預設值：num 為 `2`, 而 `value` 為函數 `add` 的回傳值。對於函數 `add`，我們傳遞值為 2 的 `num` 作為參數。函數 `add` 回傳 `4` 作為 `value` 的值。
 
-然後，我們呼叫 `myFunc(3)` 並傳遞值 `3` 參數 `num` 的值。我們沒有給 `value` 傳遞值。因為我們沒有給參數 `value` 傳遞值，它獲取預設值：函數 `add` 的回傳值。對於函數 `add`，我們傳遞值為3的 `num`給它。函數 `add` 回傳 `6` 作為 `value` 的值。
+然後，我們呼叫 `myFunc(3)` 並傳遞值 `3` 參數 `num` 的值。我們沒有給 `value` 傳遞值。因為我們沒有給參數 `value` 傳遞值，它獲取預設值：函數 `add` 的回傳值。對於函數 `add`，我們傳遞值為 3 的 `num`給它。函數 `add` 回傳 `6` 作為 `value` 的值。
 
 </p>
 </details>
@@ -4507,9 +4507,9 @@ console.log(counter.#number)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D
+#### 答案：D
 
-在 ES2020 中，通過 `#` 我們可以給 class 添加私有變數。在 class 的外部我們無法存取該值。當我們嘗試輸出 `counter.#number`，語法錯誤被拋出：我們無法在 class `Counter` 外部存取它!
+在 ES2020 中，通過 `#` 我們可以給 class 添加私有變數。在 class 的外部我們無法存取該值。當我們嘗試輸出 `counter.#number`，語法錯誤被拋出：我們無法在 class `Counter` 外部存取它！
 
 </p>
 </details>
@@ -4549,11 +4549,11 @@ obj.next(); // { value: "Lisa", done: false }
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
-為了遍歷 `teams` 陣列中物件的屬性 `members` 中的每一項，我們需要將 `teams[i].members` 傳遞給 Generator 函數 `getMembers`。 Generator 函數回傳一個 generator 物件。為了遍歷這個 generator 物件中的每一項，我們需要使用 `yield*`.
+為了遍歷 `teams` 陣列中物件的屬性 `members` 中的每一項，我們需要將 `teams[i].members` 傳遞給 Generator 函數 `getMembers`。Generator 函數回傳一個 generator 物件。為了遍歷這個 generator 物件中的每一項，我們需要使用 `yield*`.
 
-如果我們沒有寫 `yield`，`return yield` 或者 `return`，整個 Generator 函數不會第一時間 return 當我們呼叫 `next` 函數.
+如果我們沒有寫 `yield`，`return yield` 或者 `return`，整個 Generator 函數不會第一時間 return 當我們呼叫 `next` 函數。
 
 </p>
 </details>
@@ -4588,7 +4588,7 @@ console.log(person.hobbies);
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
 函數 `addHobby` 接受兩個參數，`hobby` 和有著物件 `person` 中陣列 `hobbies` 預設值的 `hobbies`。
 
@@ -4632,9 +4632,9 @@ const pet = new Flamingo();
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
-我們建立了class `Flamingo` 的實例 `pet`。當我們實例化這個實例，`Flamingo` 中的 `constructor` 被呼叫。首相，輸出 `"I'm pink. 🌸"`, 之後我們呼叫`super()`。 `super()` 呼叫父class的建構函數，`Bird`。 `Bird` 的建構函數被呼叫，並輸出 `"I'm a bird. 🦢"`。
+我們建立了 class `Flamingo` 的實例 `pet`。當我們實例化這個實例，`Flamingo` 中的 `constructor` 被呼叫。首相，輸出 `"I'm pink. 🌸"`, 之後我們呼叫`super()`。`super()` 呼叫父 class 的建構函數，`Bird`。`Bird` 的建構函數被呼叫，並輸出 `"I'm a bird. 🦢"`。
 
 </p>
 </details>
@@ -4660,9 +4660,9 @@ const emojis = ["🎄", "🎅🏼", "🎁", "⭐"];
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D
+#### 答案：D
 
-`const` 關鍵字意味著我們不能 _重定義_ 變數中的值，它 _僅可讀_。然而，值本身不可修改。陣列 `emojis` 中的值可被修改，如 push 新的值, 拼接，又或者將陣列的長度設置為0。
+`const` 關鍵字意味著我們不能 _重定義_ 變數中的值，它 _僅可讀_。然而，值本身不可修改。陣列 `emojis` 中的值可被修改，如 push 新的值，拼接，又或者將陣列的長度設置為 0。
 
 </p>
 </details>
@@ -4688,9 +4688,9 @@ const person = {
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
-物件預設並不是可迭代的。如果迭代規則被定義，則一個物件是可迭代的（An iterable is an iterable if the iterator protocol is present）。我們可以通過添加迭代器symbol `[Symbol.iterator]` 來定義迭代規則，其回傳一個 generator 物件，比如說構建一個 generator 函數 `*[Symbol.iterator]() {}`。如果我們想要回傳陣列 `["Lydia Hallie", 21]`: `yield* Object.values(this)`，這個 generator 函數一定要 yield 物件 `person` 的`Object.values`。
+物件預設並不是可迭代的。如果迭代規則被定義，則一個物件是可迭代的（An iterable is an iterable if the iterator protocol is present）。我們可以通過添加迭代器 symbol `[Symbol.iterator]` 來定義迭代規則，其回傳一個 generator 物件，比如說構建一個 generator 函數 `*[Symbol.iterator]() {}`。如果我們想要回傳陣列 `["Lydia Hallie", 21]`: `yield* Object.values(this)`，這個 generator 函數一定要 yield 物件 `person` 的`Object.values`。
 
 </p>
 </details>
@@ -4716,9 +4716,9 @@ console.log(count)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
-在 `forEach` 循環內部的 `if` 會判斷 `num` 的值是truthy或者是falsy。因為 `nums` 陣列的第一個數字是 `0`，一個falsy值， `if` 語句代碼塊不會被執行。 `count` 僅僅在 `nums` 陣列的其他3個數字 `1`，`2`，`3` 時加1。因為 `count` 執行了3次加 `1` 運算，所以 `count` 的值為 `3`。
+在 `forEach` 循環內部的 `if` 會判斷 `num` 的值是 truthy 或者是 falsy。因為 `nums` 陣列的第一個數字是 `0`，一個 falsy 值，`if` 語句代碼塊不會被執行。`count` 僅僅在 `nums` 陣列的其他 3 個數字 `1`，`2`，`3` 時加 1。因為 `count` 執行了 3 次加 `1` 運算，所以 `count` 的值為 `3`。
 
 </p>
 </details>
@@ -4745,15 +4745,15 @@ getFruit([['🍍'], ['🍊', '🍌']])
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D
+#### 答案：D
 
 `?` 允許我們去選擇性地訪問物件內部更深層的嵌套屬性。我們嘗試輸出 `fruits` 陣列索引值為 `1` 的子陣列內部的索引值為 `1` 的元素。如果在 `fruits` 陣列索引值 為 `1` 的位置不存在元素，會直接回傳 `undefined`。如果 `fruits` 陣列在索引值為 `1` 的位置存在元素，但是子陣列在索引值為 `1` 的位置不存在元素，也會回傳 `undefined`。
 
-首先，我們嘗試輸出 `[['🍊', '🍌'], ['🍍']]` 的子陣列 `['🍍']` 的第2個元素。這個子陣列只包含一個元素，也就意味著在索引值為 `1` 的位置不存在元素，所以回傳的是 `undefined` 。
+首先，我們嘗試輸出 `[['🍊', '🍌'], ['🍍']]` 的子陣列 `['🍍']` 的第 2 個元素。這個子陣列只包含一個元素，也就意味著在索引值為 `1` 的位置不存在元素，所以回傳的是 `undefined`。
 
-其次，我們在沒有傳入任何參數呼叫了 `getFruits` 函數，也就意味著形參 `fruits` 的預設值為`undefined`。因為我們選擇性地鏈接了 `fruits` 在索引值為 `1` 的元素，因為在索引值為 `1` 的位置不存在元素，因此回傳的是 `undefined` 。
+其次，我們在沒有傳入任何參數呼叫了 `getFruits` 函數，也就意味著形參 `fruits` 的預設值為`undefined`。因為我們選擇性地鏈接了 `fruits` 在索引值為 `1` 的元素，因為在索引值為 `1` 的位置不存在元素，因此回傳的是 `undefined`。
 
-最後，我們嘗試輸出 `['🍍'], ['🍊', '🍌']` 的子陣列 `['🍊', '🍌']` 的第2個元素。子陣列索引值為 `1`的位置為 `🍌` ，因此它被輸出出了。
+最後，我們嘗試輸出 `['🍍'], ['🍊', '🍌']` 的子陣列 `['🍊', '🍌']` 的第 2 個元素。子陣列索引值為 `1`的位置為 `🍌`，因此它被輸出出了。
 
 </p>
 </details>
@@ -4787,9 +4787,9 @@ console.log(calc.count)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
-我們設置 `calc` 變數為 `Calc` 類的一個新實例。然後，我們初始化一個 `Calc` 的新實例，而且呼叫了這個實例的 `increase` 函數。因為count屬性是在 `Calc` class的constructor內部的，所以count屬性不會在 `Calc` 的原型鏈上共享出去。這就意味著calc實例的count值不會被更新，count仍然是 `0`。
+我們設置 `calc` 變數為 `Calc` 類的一個新實例。然後，我們初始化一個 `Calc` 的新實例，而且呼叫了這個實例的 `increase` 函數。因為 count 屬性是在 `Calc` class 的 constructor 內部的，所以 count 屬性不會在 `Calc` 的原型鏈上共享出去。這就意味著 calc 實例的 count 值不會被更新，count 仍然是 `0`。
 
 </p>
 </details>
@@ -4829,9 +4829,9 @@ console.log(updatedUser === user)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
- `updateUser` 函數更新user的 `email` 和 `password` 屬性的值， 如果它們的值傳入函數， 函數回傳的就是 `user` 物件。 `updateUser` 函數的回傳值是 `user` 物件，意味著updatedUser的值與 `user` 指向的是同一個 `user` 物件。 `updatedUser === user` 為 `true`.
+ `updateUser` 函數更新 user 的 `email` 和 `password` 屬性的值，如果它們的值傳入函數，函數回傳的就是 `user` 物件。`updateUser` 函數的回傳值是 `user` 物件，意味著 updatedUser 的值與 `user` 指向的是同一個 `user` 物件。`updatedUser === user` 為 `true`.
 
 </p>
 </details>
@@ -4858,11 +4858,11 @@ console.log(fruit)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
-首先，我們在fruit陣列上呼叫 `slice` 函數。 slice函數不會修改原始陣列，但是會回傳從陣列切片下來的值：香蕉emoji。
-其次，我們在fruit陣列上呼叫 `splice` 函數。 splice函數會修改原始陣列，也就意味著fruit陣列此時為 `['🍊', '🍎']`。
-最後，我們在fruit陣列上呼叫 `unshift` 函數，通過添加一個值的方式改變了原始陣列，添加的是'🍇'，它成為了陣列的第一個元素。現在fruit陣列的組成為 `['🍇', '🍊', '🍎']`。
+首先，我們在 fruit 陣列上呼叫 `slice` 函數。slice 函數不會修改原始陣列，但是會回傳從陣列切片下來的值：香蕉 emoji。
+其次，我們在 fruit 陣列上呼叫 `splice` 函數。splice 函數會修改原始陣列，也就意味著 fruit 陣列此時為 `['🍊', '🍎']`。
+最後，我們在 fruit 陣列上呼叫 `unshift` 函數，通過添加一個值的方式改變了原始陣列，添加的是'🍇'，它成為了陣列的第一個元素。現在 fruit 陣列的組成為 `['🍇', '🍊', '🍎']`。
 
 </p>
 </details>
@@ -4890,15 +4890,15 @@ console.log(animals[dog])
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
 物件的鍵會被轉換為字符串。
 
-因為 `dog` 的值是一個物件， `animals[dog]` 實際上意味著我們建立了一個叫做 `"object Object"` 的屬性來代表新的物件。 `animals["object Object"]` 現在等於 `{ emoji: "🐶", name: "Mara"}`。
+因為 `dog` 的值是一個物件，`animals[dog]` 實際上意味著我們建立了一個叫做 `"object Object"` 的屬性來代表新的物件。`animals["object Object"]` 現在等於 `{ emoji: "🐶", name: "Mara"}`。
 
-`cat` 也是一個物件，`animals[cat]` 實際上意味著我們在用新的cat的屬性覆蓋 `animals[``"``object Object``"``]` 的值。
+`cat` 也是一個物件，`animals[cat]` 實際上意味著我們在用新的 cat 的屬性覆蓋 `animals[``"``object Object``"``]` 的值。
 
-輸出`animals[dog]`，實際上是`animals["object Object"]`，這是因為轉化`dog`物件為一個字符串結果`"object Object"` ，所以回傳`{ emoji: "🐈" , name: "Sara" }`。
+輸出`animals[dog]`，實際上是`animals["object Object"]`，這是因為轉化`dog`物件為一個字符串結果`"object Object"`，所以回傳`{ emoji: "🐈" , name: "Sara" }`。
 
 </p>
 </details>
@@ -4927,9 +4927,9 @@ console.log(user.email)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: A
+#### 答案：A
 
-`updateEmail` 函數是一個箭頭函數，它沒有和 `user` 物件綁定。這就意味著 `this` 關鍵字不會引用到 `user` 物件，但是會引用到全局物件。 `user` 物件內部的 `email` 的值不會更新。當輸出​​ `user.email` 的時候， 原始值 `my@email.com` 被回傳。
+`updateEmail` 函數是一個箭頭函數，它沒有和 `user` 物件綁定。這就意味著 `this` 關鍵字不會引用到 `user` 物件，但是會引用到全局物件。`user` 物件內部的 `email` 的值不會更新。當輸出​​ `user.email` 的時候，原始值 `my@email.com` 被回傳。
 
 </p>
 </details>
@@ -4963,9 +4963,9 @@ runPromises()
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: D
+#### 答案：D
 
- `Promise.all` 函數可以並行式執行promise。如果其中一個promise失敗了，`Promise.all` 函數會帶上被reject的promise的值_rejects_。在這個例子中， `promise3` 帶著 `"Third"` 值reject。我們在呼叫 `runPromises` 時在 `runPromises` 函數內部的 `catch` 函數去捕獲任意error從而捕獲到被reject的值。因為 `promise3` 帶著 `"Third"` 被reject，所以只有 `"Third"` 輸出。
+ `Promise.all` 函數可以並行式執行 promise。如果其中一個 promise 失敗了，`Promise.all` 函數會帶上被 reject 的 promise 的值_rejects_。在這個例子中，`promise3` 帶著 `"Third"` 值 reject。我們在呼叫 `runPromises` 時在 `runPromises` 函數內部的 `catch` 函數去捕獲任意 error 從而捕獲到被 reject 的值。因為 `promise3` 帶著 `"Third"` 被 reject，所以只有 `"Third"` 輸出。
 
 </p>
 </details>
@@ -4992,11 +4992,11 @@ Object[method](keys.map((_, i) => {
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
-`fromEntries` 函數可以將二維陣列轉換為物件。在每個子陣列的第一個元素是key，在每個子陣列的第二個元素是value。在這個例子中，我們映射了 `keys` 陣列，它回傳了一個陣列，陣列的第一個元素為keys陣列當前索引的值，第二個元素為values陣列當前索引的值。
+`fromEntries` 函數可以將二維陣列轉換為物件。在每個子陣列的第一個元素是 key，在每個子陣列的第二個元素是 value。在這個例子中，我們映射了 `keys` 陣列，它回傳了一個陣列，陣列的第一個元素為 keys 陣列當前索引的值，第二個元素為 values 陣列當前索引的值。
 
-這樣就建立了一個包含正確keys和values的子陣列的陣列，因此結果為`{ name: "Lydia", age: 22 }`。
+這樣就建立了一個包含正確 keys 和 values 的子陣列的陣列，因此結果為`{ name: "Lydia", age: 22 }`。
 
 </p>
 </details>
@@ -5028,9 +5028,9 @@ console.log(member)
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: C
+#### 答案：C
 
- `address` 的預設值是一個空物件 `{}`。當我們設置 `member` 變數為 `createMember` 函數回傳的物件，我們沒有為address參數傳值，意味著address的值為預設的空物件 `{}`。一個空物件是一個truthy值，意味著 `address ? address : null` 條件會回傳 `true`。 address的值為空物件 `{}`。
+ `address` 的預設值是一個空物件 `{}`。當我們設置 `member` 變數為 `createMember` 函數回傳的物件，我們沒有為 address 參數傳值，意味著 address 的值為預設的空物件 `{}`。一個空物件是一個 truthy 值，意味著 `address ? address : null` 條件會回傳 `true`。address 的值為空物件 `{}`。
 
 </p>
 </details>
@@ -5058,11 +5058,11 @@ if (!typeof randomValue === "string") {
 <details><summary><b>答案</b></summary>
 <p>
 
-#### 答案: B
+#### 答案：B
 
- `if` 語句的條件判斷 `!typeof randomValue` 的值是否等於 `"string"`。 `!` 操作符將這個值轉化為一個布林值。如果值是truthy的話，回傳值會是 `false`，如果值是falsy，回傳值會是 `true`。在這裡， `typeof randomValue` 的回傳值是一個truthy值 `"number"`，意味著 `!typeof randomValue` 的值是一個布林值 `false`。
+ `if` 語句的條件判斷 `!typeof randomValue` 的值是否等於 `"string"`。`!` 操作符將這個值轉化為一個布林值。如果值是 truthy 的話，回傳值會是 `false`，如果值是 falsy，回傳值會是 `true`。在這裡，`typeof randomValue` 的回傳值是一個 truthy 值 `"number"`，意味著 `!typeof randomValue` 的值是一個布林值 `false`。
 
- `!typeof randomValue === "string"` 總是回傳false，因為我們實際上是在執行 `false === "string"`。因為條件回傳的是 `false`，所以 `else` 語句中的代碼塊會被執行，因此輸出 `Yay it's a string!` 。
+ `!typeof randomValue === "string"` 總是回傳 false，因為我們實際上是在執行 `false === "string"`。因為條件回傳的是 `false`，所以 `else` 語句中的代碼塊會被執行，因此輸出 `Yay it's a string!`。
 
 </p>
 </details>
\ No newline at end of file

From 784c99765eb0f234ebb6587b3edb72292efe7d10 Mon Sep 17 00:00:00 2001
From: fountainpen <parsifal02@msn.com>
Date: Sat, 16 Sep 2023 15:09:56 +0200
Subject: [PATCH 20/31] Update README-bs_BS.md

---
 bs-BS/README-bs_BS.md | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/bs-BS/README-bs_BS.md b/bs-BS/README-bs_BS.md
index eeeb7ea3..7abe7c1d 100644
--- a/bs-BS/README-bs_BS.md
+++ b/bs-BS/README-bs_BS.md
@@ -5,8 +5,8 @@ Svakodnevno postavljam JavaScript pitanja s višestrukim izborom na moj
 [Instagram](https://www.instagram.com/theavocoder), koja  također objavljujem
 ovdje!
 
-Od osnovnog do naprednog: testirajte koliko dobro znate JavaScript, osvježite svoj
-znanje malo, ili pripremiti za svoj intervju! :muscle: :rocket:
+Od osnovnog do naprednog: testirajte koliko dobro znate JavaScript, malo osvježite 
+svoje znanje, ili se pripremite za svoj intervju! :muscle: :rocket:
 Ovaj tjedni repo ažuriram s novim pitanjima.
 
 Odgovori su jednostavno dijelovima ispod pitanja
@@ -184,7 +184,7 @@ Niz '' Lydia '' je istinita vrijednost. Ono što zapravo tražimo jest
 
 * * * * *
 
-###### 5. Koja je istina?
+###### 5. Što je od ovoga istina?
 
 ```javascript
 const bird = {
@@ -212,9 +212,9 @@ iako ih možda ne * upisujemo kao * nizove, oni se uvijek pretvaraju
 u String ispod "haube".
 
 JavaScript tumači (ili odlaže) izjave. Kada koristimo zagradu
-notacija, on vidi prvu otvarnu zagradu ```i nastavlja dalje do nje
+notacija, on vidi prvu otvorenu zagradu ```i nastavlja dalje do nje
 pronalazi završnu zagradu `]`. Tek tada će procijeniti
-izjava.
+izjavu.
 
 `mouse [bird.size]`: Prvo procjenjuje `bird.size`, što je` `small``.
 `mouse [" small "]` vraća "true"
@@ -401,8 +401,8 @@ Ovo je moguće u JavaScriptu, jer su funkcije objekti!
 (Sve osim primitivnih tipova su objekti)
 
 function je posebna vrsta objekta. Kod koji sami napišete
-nije stvarna funkcija. function je objekt sa svojstvima.
-Ova nekretnina je nepovratna.
+nije stvarna funkcija. Function je objekt sa svojstvima.
+To svojstvo je nepovratna.
 
 </p>
 </details>
@@ -484,8 +484,8 @@ console.log(sarah);
 
 #### Odgovor: A
 
-Za `sarah` nismo koristili ključnu riječ` new`. Kada koristite "new", to
-odnosi se na new prazni objekt koji stvaramo. Međutim, ako ne dodate
+Za `Sarah` nismo koristili ključnu riječ` new`. Kada koristite "new", to
+odnosi se na novi prazni objekt koji stvaramo. Međutim, ako ne dodate
 `new` se odnosi na ** globalni objekt **!
 
 Rekli smo da je "this.ime" jednako "Sarah" i `this.prezime`

From a899330eef7dd87503fafa53de960bb9135f40d7 Mon Sep 17 00:00:00 2001
From: fountainpen <parsifal02@msn.com>
Date: Sat, 16 Sep 2023 15:59:19 +0200
Subject: [PATCH 21/31] Update README-bs_BS.md

---
 bs-BS/README-bs_BS.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bs-BS/README-bs_BS.md b/bs-BS/README-bs_BS.md
index 7abe7c1d..33f0384f 100644
--- a/bs-BS/README-bs_BS.md
+++ b/bs-BS/README-bs_BS.md
@@ -402,7 +402,7 @@ Ovo je moguće u JavaScriptu, jer su funkcije objekti!
 
 function je posebna vrsta objekta. Kod koji sami napišete
 nije stvarna funkcija. Function je objekt sa svojstvima.
-To svojstvo je nepovratna.
+To svojstvo je nepovratno.
 
 </p>
 </details>

From cd69479869f678ef5de942f9db38c35a08db00f1 Mon Sep 17 00:00:00 2001
From: Abdullah <abdullah.binsaadd@gmail.com>
Date: Thu, 21 Sep 2023 04:08:32 +0300
Subject: [PATCH 22/31] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 802f4dfc..23b2422a 100644
--- a/README.md
+++ b/README.md
@@ -3865,7 +3865,7 @@ console.log(list[(num += 1)]);
 
 #### Answer: B
 
-With the `+=` operand, 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 🥰.
+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>

From 700a1b75cf42fd592dd376bbbdc88233df6e2617 Mon Sep 17 00:00:00 2001
From: Mohammed Nasif <99568326+Mohammed-Nasif@users.noreply.github.com>
Date: Sun, 24 Sep 2023 12:35:45 -0700
Subject: [PATCH 23/31] Update line 742 Q.23

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 7627f92e..a4310c34 100644
--- a/README.md
+++ b/README.md
@@ -739,7 +739,7 @@ console.log(num);
 
 With the `var` keyword, you can declare multiple variables with the same name. The variable will then hold the latest value.
 
-You cannot do this with `let` or `const` since they couldn't be redeclared.
+You cannot do this with `let` or `const` since they're block-scoped and therefore can't be redeclared.
 
 </p>
 </details>

From b6f9bfc44fa2ca658e1f41b2c1b5e301bcbd781c Mon Sep 17 00:00:00 2001
From: Lukasz Jasionowski <jasionowski.lukasz@gmail.com>
Date: Wed, 18 Oct 2023 13:24:26 +0200
Subject: [PATCH 24/31] Add note and modify content with current from English
 version

---
 pl-PL/README.md | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/pl-PL/README.md b/pl-PL/README.md
index 31d8e974..2d381955 100644
--- a/pl-PL/README.md
+++ b/pl-PL/README.md
@@ -1,16 +1,21 @@
 <div align="center">
   <img height="60" src="https://img.icons8.com/color/344/javascript.png">
   <h1>Pytania dotyczące JavaScript</h1>
+</div>
+
+> [!NOTE]  
+> To repozytorium zostało utworzone w 2019 roku, a zatem pytania tutaj zawarte są oparte na składni i zachowaniu JavaScript w tym czasie. Ponieważ JavaScript jest stale rozwijającym się językiem, istnieją nowsze funkcje językowe, które nie są objęte pytaniami tutaj.
 
 ---
 
-<span>Publikuję pytania wielokrotnego wyboru dotyczące JavaScriptu na swoich [Instagram](https://www.instagram.com/theavocoder) **stories**, które również zamieszczę tutaj! Ostatnia aktualizacja: <a href=#20200612><b>27 Czerwca</b></a>
+<p align="center">
+Od podstawowych do zaawansowanych: sprawdź, jak dobrze znasz JavaScript, odśwież swoją wiedzę lub przygotuj się do rozmowy kwalifikacyjnej! :muscle: :rocket: Regularnie aktualizuję to repozytorium nowymi pytaniami. Odpowiedzi znajdują się w ukrytych zakładkach poniżej pytań - po prostu kliknij, aby je rozwinięć. To dla zabawy, powodzenia! :heart:</p>
 
-Od podstawowych do zaawansowanych: sprawdź, jak dobrze znasz JavaScript, odśwież swoją wiedzę lub przygotuj się do rozmowy kwalifikacyjnej! :muscle: :rocket: Regularnie aktualizuję to repozytorium nowymi pytaniami. Odpowiedzi znajdują się w ukrytych zakładkach poniżej pytań - po prostu kliknij, aby je rozwinięć. To dla zabawy, powodzenia! :heart:</span>
+<p align="center">Nie krępuj się ze mną kontaktować! 😊</p>
 
-Nie krępuj się ze mną kontaktować! 😊 <br />
+<p align="center">
 <a href="https://www.instagram.com/theavocoder">Instagram</a> || <a href="https://www.twitter.com/lydiahallie">Twitter</a> || <a href="https://www.linkedin.com/in/lydia-hallie">LinkedIn</a> || <a href="https://www.lydiahallie.dev">Blog</a>
-</div>
+</p>
 
 | Śmiało używaj ich w projekcie! 😃  Byłabym _bardzo_ wdzięczna za referencje do tego repozytorium, tworzę pytania i wyjaśnienia (tak, jestem smutna lol) i społeczność bardzo mi pomaga w utrzymaniu i ulepszaniu go! 💪🏼 Dziękuję i baw się dobrze!   |
 |---|

From a665b9edd8da1d5a2f0af2d9b00c1f1e47ccd295 Mon Sep 17 00:00:00 2001
From: Lukasz Jasionowski <jasionowski.lukasz@gmail.com>
Date: Thu, 19 Oct 2023 12:49:43 +0200
Subject: [PATCH 25/31] Add 10 translated questions | Total translated: 60

---
 pl-PL/README.md | 344 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 344 insertions(+)

diff --git a/pl-PL/README.md b/pl-PL/README.md
index 2d381955..0f558221 100644
--- a/pl-PL/README.md
+++ b/pl-PL/README.md
@@ -1550,5 +1550,349 @@ Podczas mapowania tablicy, wartość `num` jest równa elementowi, nad którym a
 
 Nie zwracamy jednak żadnej wartości. Gdy nie zwracamy wartości z funkcji, funkcja zwraca `undefined`. Dla każdego elementu w tablicy wywoływany jest blok funkcji, więc dla każdego elementu zwracamy `undefined`.
 
+</p>
+</details>
+
+---
+
+###### 51. Jaki jest wynik?
+
+```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>Odpowiedź</b></summary>
+<p>
+
+#### Odpowiedź: A
+
+Argumenty są przekazywane przez _wartość_, chyba że ich wartość jest obiektem, wtedy są przekazywane przez _referencję_. Argument `birthYear` jest przekazywany przez wartość, ponieważ jest ciągiem znaków, a nie obiektem. Kiedy przekazujemy argumenty przez wartość, tworzona jest _kopia_ tej wartości (patrz pytanie 46).
+
+Zmienna `birthYear` posiada referencję do wartości `"1997"`. Argument `year` również posiada referencję do wartości `"1997"`, ale nie jest to ta sama wartość, do której odnosi się `birthYear`. Kiedy aktualizujemy wartość `year` ustawiając `year` na `"1998"`, aktualizujemy tylko wartość `year`. Wartość `birthYear` jest wciąż równa `1997`.
+
+Wartość `person` jest obiektem. Argument `member` posiada (skopiowaną) referencję do _tego samego_ obiektu. Gdy zmodyfikujemy właściwość obiektu, do którego odwołuje się `member`, wartość `person` również zostanie zmodyfikowana, ponieważ oba mają odwołanie do tego samego obiektu. Właściwość `name` obiektu `person` jest teraz równa wartości `"Lydia"`.
+
+</p>
+</details>
+
+---
+
+###### 52. Jaki jest wynik?
+
+```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>Odpowiedź</b></summary>
+<p>
+
+#### Odpowiedź: D
+
+Za pomocą instrukcji `throw` możemy tworzyć niestandardowe błędy. Za pomocą tej instrukcji można rzucać wyjątki <b>string</b>, <b>number</b>, <b>boolean</b> lub <b>object</b>. W tym przypadku, naszym wyjątkiem jest ciąg znaków `'Hello world!".`
+
+Za pomocą instrukcji `catch` możemy określić, co należy zrobić, jeśli wyjątek zostanie rzucony w bloku `try`. Wyjątkiem może być: string `'Hello world!'`. `e` jest teraz równe temu ciągowi, który wyświetlamy w konsoli. Skutkuje to `'Oh an error: Hello world!'`.
+
+</p>
+</details>
+
+---
+
+###### 53. Jaki jest wynik?
+
+```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>Odpowiedź</b></summary>
+<p>
+
+#### Odpowiedź: B
+
+Kiedy zwracasz właściwość, wartość właściwości jest równa _zwróconej_ wartości, a nie wartości ustawionej w funkcji konstruktora. Zwracamy ciąg `"Maserati"`, więc `myCar.make` jest równe `"Maserati"`.
+
+</p>
+</details>
+
+---
+
+###### 54. Jaki jest wynik?
+
+```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>Odpowiedź</b></summary>
+<p>
+
+#### Odpowiedź: A
+
+`let x = (y = 10);` jest w rzeczywistości skrótem od:
+
+```javascript
+y = 10;
+let x = y;
+```
+
+Kiedy ustawiamy `y` równe `10`, w rzeczywistości dodajemy właściwość `y` do globalnego obiektu (`window` w przeglądarce, `global` w Node). W przeglądarce, `window.y` jest teraz równe `10`.
+
+Następnie deklarujemy zmienną `x` z wartością `y`, która wynosi `10`. Zmienne zadeklarowane za pomocą słowa kluczowego `let` są _block scoped_ i są definiowane tylko w bloku, w którym zostały zadeklarowane; w tym przypadku natychmiast wywołane wyrażenie funkcji (IIFE). Kiedy używamy operatora `typeof`, operand `x` nie jest zdefiniowany: próbujemy uzyskać dostęp do `x` poza blokiem, w którym został zadeklarowany. Oznacza to, że `x` nie jest zdefiniowane. Wartości, które nie zostały przypisane lub zadeklarowane są typu "undefined". `console.log(typeof x)` zwraca `"undefined"`.
+
+Jednakże, utworzyliśmy globalną zmienną `y` podczas ustawiania `y` równego `10`. Wartość ta jest dostępna w dowolnym miejscu naszego kodu. Zmienna `y` jest zdefiniowana i przechowuje wartość typu `"number"`. `console.log(typeof y)` zwraca `"number"`.
+
+</p>
+</details>
+
+---
+
+###### 55. Jaki jest wynik?
+
+```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>Odpowiedź</b></summary>
+<p>
+
+#### Odpowiedź: A
+
+Możemy usuwać właściwości z obiektów za pomocą słowa kluczowego `delete`, również na prototypie. Usuwając właściwość z prototypu, nie jest ona już dostępna w łańcuchu prototypów. W tym przypadku funkcja `bark` nie jest już dostępna w prototypie po `delete Dog.prototype.bark`, a mimo to wciąż próbujemy uzyskać do niej dostęp.
+
+Kiedy próbujemy wywołać coś, co nie jest funkcją, rzucany jest `TypeError`. W tym przypadku `TypeError: pet.bark is not a function`, ponieważ `pet.bark` jest `undefined`.
+
+</p>
+</details>
+
+---
+
+###### 56. Jaki jest wynik?
+
+```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>Odpowiedź</b></summary>
+<p>
+
+#### Odpowiedź: D
+
+Obiekt `Set` jest zbiorem _unikalnych_ wartości: wartość może wystąpić tylko raz w zbiorze.
+
+Przekazaliśmy iterowalne `[1, 1, 2, 3, 4]` ze zduplikowaną wartością `1`.Ponieważ nie możemy mieć dwóch takich samych wartości w zbiorze, jedna z nich jest usuwana. Wynikiem jest `{1, 2, 3, 4}`.
+
+</p>
+</details>
+
+---
+
+###### 57. Jaki jest wynik?
+
+```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>Odpowiedź</b></summary>
+<p>
+
+#### Odpowiedź: C
+
+Zaimportowany moduł jest _tylko do odczytu_: nie można modyfikować zaimportowanego modułu. Tylko moduł, który go eksportuje może zmienić jego wartość.
+
+Kiedy próbujemy zwiększyć wartość `myCounter`, wyrzuca błąd: `myCounter` jest tylko do odczytu i nie może być modyfikowany.
+
+</p>
+</details>
+
+---
+
+###### 58. Jaki jest wynik?
+
+```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>Odpowiedź</b></summary>
+<p>
+
+#### Odpowiedź: A
+
+Operator `delete` zwraca wartość logiczną: `true` po pomyślnym usunięciu, w przeciwnym razie zwróci `false`. Jednakże, zmienne zadeklarowane ze słowem kluczowym `var`, `const` lub `let` nie mogą być usunięte za pomocą operatora `delete`.
+
+Zmienna `name` została zadeklarowana ze słowem kluczowym `const`, więc jej usunięcie nie powiedzie się: Zwracane jest `false`. Kiedy ustawiliśmy wartość `age` równą `21`, w rzeczywistości dodaliśmy właściwość o nazwie `age` do obiektu globalnego. W ten sposób można pomyślnie usunąć właściwości z obiektów, również z obiektu globalnego, więc `delete age` zwraca `true`.
+
+</p>
+</details>
+
+---
+
+###### 59. Jaki jest wynik?
+
+```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>Odpowiedź</b></summary>
+<p>
+
+#### Odpowiedź: C
+
+Możemy rozpakować wartości z tablic lub właściwości z obiektów poprzez destrukturyzację. Na przykład:
+
+```javascript
+[a, b] = [1, 2];
+```
+
+<img src="https://i.imgur.com/ADFpVop.png" width="200">
+
+Wartość `a` wynosi teraz `1`, a wartość `b` wynosi teraz `2`.To, co faktycznie zrobiliśmy w pytaniu, to:
+
+```javascript
+[y] = [1, 2, 3, 4, 5];
+```
+
+<img src="https://i.imgur.com/NzGkMNk.png" width="200">
+
+Oznacza to, że wartość `y` jest równa pierwszej wartości w tablicy, którą jest liczba `1`.Kiedy logujemy `y`, zwracana jest wartość `1`.
+
+</p>
+</details>
+
+---
+
+###### 60. Jaki jest wynik?
+
+```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>Odpowiedź</b></summary>
+<p>
+
+#### Odpowiedź: B
+
+Możliwe jest łączenie obiektów za pomocą operatora rozprzestrzeniania `...`.Umożliwia on tworzenie kopii par klucz/wartość jednego obiektu i dodawanie ich do innego obiektu. W tym przypadku tworzymy kopie obiektu `user` i dodajemy je do obiektu `admin`. Obiekt `admin` zawiera teraz skopiowane pary klucz/wartość, czego wynikiem jest `{ admin: true, name: "Lydia", age: 21 }`.
+
 </p>
 </details>
\ No newline at end of file

From e5bee7b1eabc9bdd6e4f7b49aa3329cece24b8cf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C5=81ukasz=20Jasionowski?= <jasionowski.lukasz@gmail.com>
Date: Sat, 21 Oct 2023 12:58:51 +0200
Subject: [PATCH 26/31] Add 10 translated questions | Total translated: 70

---
 pl-PL/README.md | 329 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 329 insertions(+)

diff --git a/pl-PL/README.md b/pl-PL/README.md
index 0f558221..02bfc687 100644
--- a/pl-PL/README.md
+++ b/pl-PL/README.md
@@ -1894,5 +1894,334 @@ console.log(admin);
 
 Możliwe jest łączenie obiektów za pomocą operatora rozprzestrzeniania `...`.Umożliwia on tworzenie kopii par klucz/wartość jednego obiektu i dodawanie ich do innego obiektu. W tym przypadku tworzymy kopie obiektu `user` i dodajemy je do obiektu `admin`. Obiekt `admin` zawiera teraz skopiowane pary klucz/wartość, czego wynikiem jest `{ admin: true, name: "Lydia", age: 21 }`.
 
+</p>
+</details>
+
+---
+
+###### 61. Jaki jest wynik?
+
+```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>Odpowiedź</b></summary>
+<p>
+
+#### Odpowiedź: B
+
+Za pomocą metody `defineProperty` możemy dodawać nowe właściwości do obiektu lub modyfikować istniejące. Kiedy dodajemy właściwość do obiektu za pomocą metody `defineProperty`, są one domyślnie _niewyliczalne_. Metoda `Object.keys` zwraca wszystkie _wyliczalne_ nazwy właściwości z obiektu, w tym przypadku tylko `"name"`.
+
+Właściwości dodane przy użyciu metody `defineProperty` są domyślnie niezmienne. Możesz nadpisać to zachowanie używając właściwości `writable`, `configurable` i `enumerable`. W ten sposób metoda `defineProperty` daje dużo większą kontrolę nad właściwościami dodawanymi do obiektu.
+
+</p>
+</details>
+
+---
+
+###### 62. Jaki jest wynik?
+
+```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>Odpowiedź</b></summary>
+<p>
+
+#### Odpowiedź: A
+
+Drugim argumentem `JSON.stringify` jest _replacer_. Zamiennik może być funkcją lub tablicą i pozwala kontrolować, co i w jaki sposób wartości powinny być łańcuchowane.
+
+Jeśli zamiennik jest _tablicą_, tylko nazwy właściwości zawarte w tablicy zostaną dodane do łańcucha JSON. W tym przypadku tylko właściwości o nazwach `"level"` i `"health"` są uwzględnione, `"username"` jest wykluczone. `data` jest teraz równa `"{"level":19, "health":90}"`.
+
+Jeśli zamiennik jest _funkcją_, funkcja ta jest wywoływana na każdej właściwości obiektu, który stringujesz. Wartość zwrócona z tej funkcji będzie wartością właściwości, gdy zostanie ona dodana do łańcucha JSON. Jeśli wartość jest `undefined`, właściwość ta zostanie wykluczona z łańcucha JSON.
+
+</p>
+</details>
+
+---
+
+###### 63. Jaki jest wynik?
+
+```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>Odpowiedź</b></summary>
+<p>
+
+#### Odpowiedź: A
+
+Operator jednoargumentowy `++` _najpierw zwraca_ wartość operandu, _potem zwiększa_ wartość operandu. Wartość `num1` to `10`, ponieważ funkcja `increaseNumber` najpierw zwraca wartość `num`, czyli `10`, a dopiero potem zwiększa wartość `num`.
+
+`num2` jest równe `10`, ponieważ przekazaliśmy `num1` do `increasePassedNumber`.`number` jest równe `10` (wartość `num1`). Ponownie, operator jednoargumentowy `++` _najpierw zwraca_ wartość operandu, _następnie zwiększa_ wartość operandu. Wartość `liczba` wynosi `10`, więc `liczba2` jest równa `10`.
+
+</p>
+</details>
+
+---
+
+###### 64. Jaki jest wynik?
+
+```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>Odpowiedź</b></summary>
+<p>
+
+#### Odpowiedź: C
+
+W ES6 możemy inicjować parametry z wartością domyślną. Wartość parametru będzie wartością domyślną, jeśli żadna inna wartość nie została przekazana do funkcji lub jeśli wartość parametru jest `"undefined". W tym przypadku, rozkładamy właściwości obiektu `value` na nowy obiekt, więc `x` ma domyślną wartość `{ number: 10 }`.
+
+Domyślny argument jest obliczany w _call time_! Za każdym razem, gdy wywołujemy funkcję, tworzony jest _nowy_ obiekt. Wywołujemy funkcję `multiply` dwa pierwsze razy bez przekazywania wartości: `x` ma wartość domyślną `{ number: 10 }`. Następnie rejestrujemy pomnożoną wartość tej liczby, która wynosi `20`.
+
+Za trzecim razem, gdy wywołujemy multiply, przekazujemy argument: obiekt o nazwie `value`. Operator `*=` jest w rzeczywistości skrótem od `x.number = x.number * 2`: modyfikujemy wartość `x.number` i rejestrujemy pomnożoną wartość `20`.
+
+Za czwartym razem ponownie przekazujemy obiekt `value`. `x.number` zostało wcześniej zmodyfikowane do `20`, więc `x.number *= 2` loguje `40`.
+
+</p>
+</details>
+
+---
+
+###### 65. Jaki jest wynik?
+
+```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>Odpowiedź</b></summary>
+<p>s
+
+#### Odpowiedź: D
+
+Pierwszym argumentem, który otrzymuje metoda `reduce` jest _accumulator_, w tym przypadku `x`. Drugim argumentem jest _bieżąca wartość_, `y`. Za pomocą metody reduce wykonujemy funkcję wywołania zwrotnego na każdym elemencie tablicy, co ostatecznie może skutkować jedną wartością. W tym przykładzie nie zwracamy żadnych wartości, po prostu rejestrujemy wartości akumulatora i wartości bieżącej.
+
+Wartość akumulatora jest równa poprzednio zwróconej wartości funkcji zwrotnej. Jeśli nie przekażesz opcjonalnego argumentu `initialValue` do metody `reduce`, akumulator jest równy pierwszemu elementowi przy pierwszym wywołaniu.
+
+Przy pierwszym wywołaniu, wartość akumulatora (`x`) wynosi `1`, a wartość bieżąca (`y`) wynosi `2`. Nie wracamy z funkcji zwrotnej, rejestrujemy akumulator i bieżącą wartość: `1` i `2` są rejestrowane.
+
+Jeśli nie zwrócisz wartości z funkcji, zwróci ona `undefined`. Przy następnym wywołaniu, akumulatorem jest `undefined`, a bieżącą wartością jest `3`. `undefined` i `3` są rejestrowane.
+
+Przy czwartym wywołaniu ponownie nie wracamy z funkcji zwrotnej. Akumulator jest ponownie `undefined`, a aktualna wartość to `4`. `undefined` i `4` są rejestrowane.
+
+</p>
+</details>
+  
+---
+
+###### 66. Za pomocą którego konstruktora możemy z powodzeniem rozszerzyć klasę `Dog`?
+
+```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>Odpowiedź</b></summary>
+<p>
+
+#### Odpowiedź: B
+
+W klasie pochodnej nie można uzyskać dostępu do słowa kluczowego `this` przed wywołaniem `super`. Jeśli spróbujesz to zrobić, zostanie wyświetlony ReferenceError: 1 i 4 wyrzuci błąd referencji.
+
+Za pomocą słowa kluczowego `super` wywołujemy konstruktor klasy nadrzędnej z podanymi argumentami. Konstruktor rodzica otrzymuje argument `name`, więc musimy przekazać `name` do `super`.
+
+Klasa `Labrador` otrzymuje dwa argumenty, `name` ponieważ rozszerza klasę `Dog`, oraz `size` jako dodatkową właściwość klasy `Labrador`. Oba muszą być przekazane do funkcji konstruktora na `Labrador`, co jest zrobione poprawnie przy użyciu konstruktora 2.
+
+</p>
+</details>
+
+---
+
+###### 67. Jaki jest wynik?
+
+```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>Odpowiedź</b></summary>
+<p>
+
+#### Odpowiedź: B
+
+Ze słowem kluczowym `import`, wszystkie zaimportowane moduły są _pre-parsed_. Oznacza to, że zaimportowane moduły są uruchamiane _najpierw_, a kod w pliku, który importuje moduł jest wykonywany _potem_.
+
+Jest to różnica pomiędzy `require()` w CommonJS i `import`! 
+Dzięki `require()` można ładować zależności na żądanie podczas wykonywania kodu. Jeśli użylibyśmy `require` zamiast `import`, w konsoli zostałoby wyświetlone `running index.js`, `running sum.js`, `3`.
+
+</p>
+</details>
+
+---
+
+###### 68. Jaki jest wynik?
+
+```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>Odpowiedź</b></summary>
+<p>
+
+#### Odpowiedź: A
+
+Każdy Symbol jest całkowicie unikalny. Celem argumentu przekazywanego do Symbolu jest nadanie Symbolowi opisu. Wartość Symbolu nie zależy od przekazanego argumentu. Testując równość, tworzymy dwa zupełnie nowe symbole: pierwszy `Symbol('foo')` i drugi `Symbol('foo')`. Te dwie wartości są unikalne i nie są sobie równe, `Symbol('foo') == Symbol('foo')` zwraca `false`.
+
+</p>
+</details>
+
+---
+
+###### 69. Jaki jest wynik?
+
+```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>Odpowiedź</b></summary>
+<p>
+
+#### Odpowiedź: C
+
+Za pomocą metody `padStart` możemy dodać dopełnienie na początku ciągu znaków. Wartością przekazywaną do tej metody jest _całkowita_ długość łańcucha wraz z dopełnieniem. Ciąg `"Lydia Hallie"` ma długość `12`. Metoda `name.padStart(13)` wstawia 1 spację na początku łańcucha, ponieważ 12 + 1 to 13.
+
+Jeśli argument przekazany do metody `padStart` jest mniejszy niż długość tablicy, dopełnienie nie zostanie dodane.
+
+</p>
+</details>
+
+---
+
+###### 70. Jaki jest wynik?
+
+```javascript
+console.log('🥑' + '💻');
+```
+
+- A: `"🥑💻"`
+- B: `257548`
+- C: A string containing their code points
+- D: Error
+
+<details><summary><b>Odpowiedź</b></summary>
+<p>
+
+#### Odpowiedź: A
+
+Za pomocą operatora `+` można łączyć ciągi znaków. W tym przypadku łączymy ciąg `"🥑"` z ciągiem `"💻"`, otrzymując `"🥑💻"`.
+
 </p>
 </details>
\ No newline at end of file

From 5305be3008a9f30b62512203d3f82d71c282c053 Mon Sep 17 00:00:00 2001
From: Lukasz Jasionowski <jasionowski.lukasz@gmail.com>
Date: Fri, 27 Oct 2023 10:58:04 +0200
Subject: [PATCH 27/31] Add 5 translated questions | Total translated: 75

---
 pl-PL/README.md | 164 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 164 insertions(+)

diff --git a/pl-PL/README.md b/pl-PL/README.md
index 02bfc687..ef1c71d6 100644
--- a/pl-PL/README.md
+++ b/pl-PL/README.md
@@ -2223,5 +2223,169 @@ console.log('🥑' + '💻');
 
 Za pomocą operatora `+` można łączyć ciągi znaków. W tym przypadku łączymy ciąg `"🥑"` z ciągiem `"💻"`, otrzymując `"🥑💻"`.
 
+</p>
+</details>
+
+---
+
+###### 71. Jak możemy rejestrować wartości, które są komentowane po instrukcji console.log?
+
+```javascript
+function* startGame() {
+  const answer = yield 'Do you love JavaScript?';
+  if (answer !== '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>Odpowiedź</b></summary>
+<p>
+
+#### Odpowiedź: C
+
+Funkcja generatora "wstrzymuje" swoje wykonanie, gdy widzi słowo kluczowe `yield`. Najpierw musimy pozwolić funkcji na wygenerowanie ciągu "Do you love JavaScript?", co można zrobić poprzez wywołanie `game.next().value`.
+
+Każda linia jest wykonywana, dopóki nie znajdzie pierwszego słowa kluczowego `yield`. W pierwszej linii funkcji znajduje się słowo kluczowe `yield`: wykonywanie zatrzymuje się wraz z pierwszym yield! Oznacza to, że zmienna `answer` nie jest jeszcze zdefiniowana!
+
+Kiedy wywołamy `game.next("Yes").value`, poprzedni `yield` zostanie zastąpiony wartością parametrów przekazanych do funkcji `next()`, w tym przypadku `"Yes``. Wartość zmiennej `answer` jest teraz równa `"Yes"`. Warunek instrukcji if zwraca `false`, a `JavaScript loves you back ❤️` zostaje zalogowany.
+
+</p>
+</details>
+
+---
+
+###### 72. Jaki jest wynik?
+
+```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>Odpowiedź</b></summary>
+<p>
+
+#### Odpowiedź: C
+
+`String.raw` zwraca ciąg znaków, w którym znaki specjalne (`\n`, `\v`, `\t` itd.) są ignorowane! Backslashe mogą być problemem, ponieważ można skończyć z czymś takim jak:`` const path = `C:\Documents\Projects\table.html` ``
+
+Co skutkowałoby:
+
+`"C:DocumentsProjects able.html"`Z `String.raw`, po prostu zignorowałby ucieczkę i wyświetliłby:
+
+`C:\Documents\Projects\table.html`.
+
+W tym przypadku ciąg to `Hello\nworld`, który zostanie wyświetlony.
+
+</p>
+</details>
+
+---
+
+###### 73. Jaki jest wynik?
+
+```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>Odpowiedź</b></summary>
+<p>
+
+#### Odpowiedź: C
+
+Funkcja asynchroniczna zawsze zwraca obietnicę. Funkcja `await` wciąż musi czekać na rozwiązanie obietnicy: oczekująca obietnica zostanie zwrócona, gdy wywołamy `getData()` w celu ustawienia `data` równym tej obietnicy. 
+
+Jeśli chcielibyśmy uzyskać dostęp do rozwiązanej wartości `"I made it"`, moglibyśmy użyć metody `.then()` na `data`:`data.then(res => console.log(res))`. 
+
+To wyświtliłoby w konsoli `"Udało mi się!"`.
+
+</p>
+</details>
+
+---
+
+###### 74. Jaki jest wynik?
+
+```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>Odpowiedź</b></summary>
+<p>
+
+#### Odpowiedź: B
+
+Metoda `.push()` zwraca _długość_ nowej tablicy! Poprzednio tablica zawierała jeden element (string `"banan"`) i miała długość `1`. Po dodaniu stringa `"apple"` do tablicy, tablica zawiera dwa elementy i ma długość `2`. Jest to zwracane przez funkcję `addToList`. Metoda `push` modyfikuje oryginalną tablicę. 
+
+Jeśli chciałeś zwrócić _array_ z funkcji, a nie _length of the array_, powinieneś był zwrócić `list` po dodaniu do niej `item`.
+
+</p>
+</details>
+
+---
+
+###### 75. Jaki jest wynik?
+
+```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>Odpowiedź</b></summary>
+<p>
+
+#### Odpowiedź: B
+
+`Object.freeze` uniemożliwia dodawanie, usuwanie lub modyfikowanie właściwości obiektu (chyba że wartością właściwości jest inny obiekt).
+
+Kiedy tworzymy zmienną `shape` i ustawiamy ją jako równą zamrożonemu obiektowi `box`, `shape` również odnosi się do zamrożonego obiektu. Możesz sprawdzić czy obiekt jest zamrożony używając `Object.isFrozen`. W tym przypadku, `Object.isFrozen(shape)` zwróciłby true, ponieważ zmienna `shape` posiada referencję do zamrożonego obiektu.
+
+Ponieważ `shape` jest zamrożony, a wartość `x` nie jest obiektem, nie możemy modyfikować właściwości `x`.`x` jest nadal równe `10`, a `{ x: 10, y: 20 }` zostaje wyświetlone w konsoli.
+
 </p>
 </details>
\ No newline at end of file

From 7d529663e346113a3827b4d3dac491a97ee83262 Mon Sep 17 00:00:00 2001
From: Gustavo Iha <gustavoiha@gmail.com>
Date: Mon, 27 Nov 2023 13:36:48 -0300
Subject: [PATCH 28/31] docs: make question 3 explanation more comprehensive

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index ba440c7c..3e75bae8 100644
--- a/README.md
+++ b/README.md
@@ -142,7 +142,7 @@ Note that the value of `diameter` is a regular function, whereas the value of `p
 
 With arrow functions, the `this` keyword refers to its current surrounding scope, unlike regular functions! This means that when we call `perimeter`, it doesn't refer to the shape object, but to its surrounding scope (window for example).
 
-There is no value `radius` on that object, which returns `NaN`.
+Since there is no value `radius` in the scope of the arrow function, `this.radius` returns `undefined` which, when multiplied by `2 * Math.PI`, results in `NaN`.
 
 </p>
 </details>

From 06de0f48d19af990e0abc03672db8c135683828e Mon Sep 17 00:00:00 2001
From: Alexander Krikunov <aikrikunov95@gmail.com>
Date: Mon, 4 Dec 2023 15:18:47 +0300
Subject: [PATCH 29/31] 133 clarification

For me it was unclear why "Promise 2" is printed before "Promise 1".
---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index ba440c7c..708299b9 100644
--- a/README.md
+++ b/README.md
@@ -4356,13 +4356,13 @@ funcTwo();
 
 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.
+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.
+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.
 

From 73a534df457ef216acc7dcad4b48d08dfa367e7d Mon Sep 17 00:00:00 2001
From: Abbas Roholamin <abbasroholamin76@gmail.com>
Date: Sat, 3 Feb 2024 23:20:45 +0430
Subject: [PATCH 30/31] Update README.md

Fixing the typos and grammar mistakes
---
 README.md | 62 +++++++++++++++++++++++++++----------------------------
 1 file changed, 31 insertions(+), 31 deletions(-)

diff --git a/README.md b/README.md
index ba440c7c..4cb8dd0a 100644
--- a/README.md
+++ b/README.md
@@ -4,12 +4,12 @@
 </div>
 
 > [!NOTE]  
-> This repo was created in 2019 and the questions provided here are therefore based on the JavaScript syntax and behaviour at that time. Since JavaScript is a constantly evolving language, there are newer language features that are not covered by the questions here.
+> This repo was created in 2019 and the questions provided here are therefore based on the JavaScript syntax and behavior at that time. Since JavaScript is a constantly evolving language, there are newer language features that are not covered by the questions here.
 
 ---
 
 <p align="center">
-From basic to advanced: test how well you know JavaScript, refresh your knowledge a bit, or prepare for your coding interview! :muscle: :rocket: I update this repo regularly with new questions. I added the answers in the **collapsed sections** below the questions, simply click on them to expand it. It's just for fun, good luck! :heart:</p>
+From basic to advanced: test how well you know JavaScript, refresh your knowledge a bit or prepare for your coding interview! :muscle: :rocket: I update this repo regularly with new questions. I added the answers in the **collapsed sections** below the questions, simply click on them to expand it. It's just for fun, good luck! :heart:</p>
 
 <p align="center">Feel free to reach out to me! 😊</p>
 
@@ -167,7 +167,7 @@ There is no value `radius` on that object, which returns `NaN`.
 
 The unary plus tries to convert an operand to a number. `true` is `1`, and `false` is `0`.
 
-The string `'Lydia'` is a truthy value. What we're actually asking, is "is this truthy value falsy?". This returns `false`.
+The string `'Lydia'` is a truthy value. What we're actually asking, is "Is this truthy value falsy?". This returns `false`.
 
 </p>
 </details>
@@ -690,7 +690,7 @@ const sum = eval('10*10+5');
 
 #### Answer: A
 
-`eval` evaluates codes that's passed as a string. If it's an expression, like in this case, it evaluates the expression. The expression is `10 * 10 + 5`. This returns the number `105`.
+`eval` evaluates code that's passed as a string. If it's an expression, like in this case, it evaluates the expression. The expression is `10 * 10 + 5`. This returns the number `105`.
 
 </p>
 </details>
@@ -871,7 +871,7 @@ console.log(name.giveLydiaPizza())
 
 #### Answer: A
 
-`String` is a built-in constructor, which we can add properties to. I just added a method to its prototype. Primitive strings are automatically converted into a string object, generated by the string prototype function. So, all strings (string objects) have access to that method!
+`String` is a built-in constructor, that we can add properties to. I just added a method to its prototype. Primitive strings are automatically converted into a string object, generated by the string prototype function. So, all strings (string objects) have access to that method!
 
 </p>
 </details>
@@ -1014,7 +1014,7 @@ The deepest nested element that caused the event is the target of the event. You
 
 #### Answer: A
 
-If we click `p`, we see two logs: `p` and `div`. During event propagation, there are 3 phases: capturing, target, 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.
+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>
@@ -1227,7 +1227,7 @@ 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 behaviour.
+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>
@@ -1517,7 +1517,7 @@ const num = parseInt('7*6', 10);
 
 #### Answer: C
 
-Only the first numbers 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.
+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`.
 
@@ -1688,7 +1688,7 @@ y = 10;
 let x = y;
 ```
 
-When we set `y` equal to `10`, we actually add a property `y` to the global object (`window` in browser, `global` in Node). In a browser, `window.y` is now equal to `10`.
+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"`.
 
@@ -1823,7 +1823,7 @@ console.log(delete age);
 
 #### Answer: 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` keyword cannot be deleted using the `delete` operator.
+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`.
 
@@ -1989,7 +1989,7 @@ console.log(num2);
 
 #### Answer: 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` afterwards.
+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`.
 
@@ -2058,7 +2058,7 @@ In this example, we are not returning any values, we are simply logging the valu
 
 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 current value: `1` and `2` get logged.
+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.
 
@@ -2146,9 +2146,9 @@ export const sum = (a, b) => a + b;
 
 #### Answer: B
 
-With the `import` keyword, all imported modules are _pre-parsed_. This means that the imported modules get run _first_, the code in the file which imports the module gets executed _after_.
+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 would have used `require` instead of `import`, `running index.js`, `running sum.js`, `3` would have been logged to the console.
+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>
@@ -2454,7 +2454,7 @@ 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 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 **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).
 
@@ -2522,7 +2522,7 @@ console.log(addFunction(5 * 2));
 
 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 caches value will be returned, which saves on execution time. Else, if it's not cached, it will calculate the value and store it afterwards.
+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 }`.
 
@@ -2733,7 +2733,7 @@ console.log(checkAge(21));
 
 #### Answer: C
 
-Variables with the `const` and `let` keyword 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.
+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>
@@ -2783,7 +2783,7 @@ function getName(name) {
 
 #### Answer: A
 
-With `!!name`, we determine whether the value of `name` is truthy or falsy. If name is truthy, which we want to test for, `!name` returns `false`. `!false` (which is what `!!name` practically is) returns `true`.
+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`.
 
@@ -2843,7 +2843,7 @@ sum(10);
 
 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 which is defined _after_ (to the right), the parameter's value hasn't been initialized yet, which will throw an error.
+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,7 +2873,7 @@ console.log(data);
 
 #### Answer: 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 which returns the string `"Hello World"`, and the named export is a variable called `name` which has the value of the string `"Lydia"`.
+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.
 
@@ -3216,7 +3216,7 @@ console.log(name());
 
 #### Answer: C
 
-The variable `name` holds the value of a string, which is not a function, thus cannot invoke.
+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!
 
@@ -3320,7 +3320,7 @@ secondFunction();
 
 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` keyword in an `async` function. Although we can get a promise's value with both `.then` and `await`, they work a bit differently.
+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.
 
@@ -3773,7 +3773,7 @@ myMap.get(() => 'greeting');
 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 interact 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.
+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>
@@ -3908,7 +3908,7 @@ With the optional chaining operator `?.`, we no longer have to explicitly check
 `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?.()`: variable `member` is non-existent therefore a `ReferenceError` gets thrown!
 
 </p>
 </details>
@@ -4455,13 +4455,13 @@ person.name;
 
 #### Answer: 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 contained two properties: `set` and `get`. `set` gets invoked whenever we _set_ property values, `get` gets invoked whenever we _get_ (access) property values.
+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, the `get` property on the handler object got invoked. `"Accessed a property!"` gets logged.
+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>
@@ -4550,7 +4550,7 @@ myFunc(3);
 
 #### Answer: 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` 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`.
+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`.
 
@@ -4590,7 +4590,7 @@ console.log(counter.#number)
 
 #### Answer: 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 acccess it outside the `Counter` class!
+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>
@@ -5048,7 +5048,7 @@ runPromises()
 
 #### Answer: 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` 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` rejected with this value.
+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>
@@ -5077,7 +5077,7 @@ Object[method](keys.map((_, i) => {
 
 #### Answer: 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 which 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. 
+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 }`
 
@@ -5113,7 +5113,7 @@ console.log(member)
 
 #### Answer: 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 address, which means that the value of 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 address is the empty object `{}`.
+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>

From d76e0320fe6391d6b7fa39b61e849e462ad106c1 Mon Sep 17 00:00:00 2001
From: singlexyz <singlexyz@gmail.com>
Date: Sun, 10 Mar 2024 22:44:51 +0800
Subject: [PATCH 31/31] Fix Question 147 typo.

---
 README.md             | 2 +-
 id-ID/README.md       | 2 +-
 it-IT/README.md       | 2 +-
 ko-KR/README-ko_KR.md | 2 +-
 ro-RO/README.ro.md    | 4 ++--
 ru-RU/README.md       | 2 +-
 sq-KS/README_sq_KS.md | 2 +-
 vi-VI/README-vi.md    | 2 +-
 zh-CN/README-zh_CN.md | 2 +-
 zh-TW/README_zh-TW.md | 4 ++--
 10 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/README.md b/README.md
index ba440c7c..c4f58253 100644
--- a/README.md
+++ b/README.md
@@ -4852,7 +4852,7 @@ class Calc {
 	}
 
 	increase() {
-		this.count ++
+		this.count++
 	}
 }
 
diff --git a/id-ID/README.md b/id-ID/README.md
index 482955fb..2f238d06 100644
--- a/id-ID/README.md
+++ b/id-ID/README.md
@@ -4788,7 +4788,7 @@ class Calc {
 	}
 
 	increase() {
-		this.count ++
+		this.count++
 	}
 }
 
diff --git a/it-IT/README.md b/it-IT/README.md
index 23d43ea2..13e465c6 100644
--- a/it-IT/README.md
+++ b/it-IT/README.md
@@ -4823,7 +4823,7 @@ class Calc {
 	}
 
 	increase() {
-		this.count ++
+		this.count++
 	}
 }
 
diff --git a/ko-KR/README-ko_KR.md b/ko-KR/README-ko_KR.md
index 96d75bf7..51411b6b 100644
--- a/ko-KR/README-ko_KR.md
+++ b/ko-KR/README-ko_KR.md
@@ -4804,7 +4804,7 @@ class Calc {
 	}
 
 	increase() {
-		this.count ++
+		this.count++
 	}
 }
 
diff --git a/ro-RO/README.ro.md b/ro-RO/README.ro.md
index 0907fa94..93fc1f4e 100644
--- a/ro-RO/README.ro.md
+++ b/ro-RO/README.ro.md
@@ -4849,7 +4849,7 @@ class Calc {
 	}
 
 	increase() {
-		this.count ++
+		this.count++
 	}
 }
 
@@ -5145,4 +5145,4 @@ Condiția din instrucțiunea `if` verifică dacă valoarea lui `!typeof randomVa
 `!typeof randomValue === "string"` întotdeauna returnează `false`, deoarece de fapt verificăm `false === "string"`. Deoarece condiția returnează `false`, blocul de cod al instrucțiunii `else` se execută, iar `Yay it's a string!` este înregistrat.
 
 </p>
-</details>
\ No newline at end of file
+</details>
diff --git a/ru-RU/README.md b/ru-RU/README.md
index 2df08edb..ace3f67a 100644
--- a/ru-RU/README.md
+++ b/ru-RU/README.md
@@ -4847,7 +4847,7 @@ class Calc {
 	}
 
 	increase() {
-		this.count ++
+		this.count++
 	}
 }
 
diff --git a/sq-KS/README_sq_KS.md b/sq-KS/README_sq_KS.md
index 19508cf7..2392abb4 100644
--- a/sq-KS/README_sq_KS.md
+++ b/sq-KS/README_sq_KS.md
@@ -4846,7 +4846,7 @@ class Calc {
 	}
 
 	increase() {
-		this.count ++
+		this.count++
 	}
 }
 
diff --git a/vi-VI/README-vi.md b/vi-VI/README-vi.md
index fa974a44..f8ab661d 100644
--- a/vi-VI/README-vi.md
+++ b/vi-VI/README-vi.md
@@ -4785,7 +4785,7 @@ class Calc {
 	}
 
 	increase() {
-		this.count ++
+		this.count++
 	}
 }
 
diff --git a/zh-CN/README-zh_CN.md b/zh-CN/README-zh_CN.md
index 71f0f9df..52ca1ee0 100644
--- a/zh-CN/README-zh_CN.md
+++ b/zh-CN/README-zh_CN.md
@@ -4785,7 +4785,7 @@ class Calc {
 	}
 
 	increase() {
-		this.count ++
+		this.count++
 	}
 }
 
diff --git a/zh-TW/README_zh-TW.md b/zh-TW/README_zh-TW.md
index c171b62f..b6bf9c06 100644
--- a/zh-TW/README_zh-TW.md
+++ b/zh-TW/README_zh-TW.md
@@ -4769,7 +4769,7 @@ class Calc {
 	}
 
 	increase() {
-		this.count ++
+		this.count++
 	}
 }
 
@@ -5065,4 +5065,4 @@ if (!typeof randomValue === "string") {
  `!typeof randomValue === "string"` 總是回傳 false，因為我們實際上是在執行 `false === "string"`。因為條件回傳的是 `false`，所以 `else` 語句中的代碼塊會被執行，因此輸出 `Yay it's a string!`。
 
 </p>
-</details>
\ No newline at end of file
+</details>
