Added Question in dom.mdx (#71)

* Update dom.mdx

Add Questions in dom.mdx

* Update faq_js.mdx

Added faq on javascript

* Update faq_js.mdx

* Update primitives.mdx

Author: anitagupta1

web/src/pages/challenges/dom.mdx

@@ -420,3 +420,61 @@ function serializeDOM(root) {
 - https://developer.mozilla.org/en-US/docs/Web/API/Element/attributes
 
 ---
+### 15. What is event delegation in the DOM and how can it be implemented in JavaScript?
+- Event delegation allows you to attach a single event listener to a parent element to manage events from its child elements, leveraging event bubbling. This improves performance and simplifies handling dynamically added elements.
+
+Here’s an example of how event delegation works:
+```js copy
+document.querySelector('#parent').addEventListener('click', function(event) {
+  if (event.target && event.target.matches('button')) {
+    console.log('Button clicked:', event.target.textContent);
+  }
+});
+```
+
+This approach optimizes performance and reduces memory usage, as fewer event listeners are attached to individual elements.
+
+**References**
+
+- https://developer.mozilla.org/en-US/docs/Web/API/Element/attributes
+---
+
+### 16. How can you find all leaf nodes in a given DOM tree?
+- Leaf nodes in a DOM tree are elements that do not have any child elements. You can traverse the tree recursively to collect all leaf nodes.
+
+Implementation:
+```js copy
+function getLeafNodes(element) {
+  let leafNodes = [];
+
+  // Base case: if the element has no children, it's a leaf node
+  if (!element.children || element.children.length === 0) {
+    leafNodes.push(element);
+    return leafNodes;
+  }
+
+  // Recursive case: traverse through each child
+  for (let i = 0; i < element.children.length; i++) {
+    leafNodes = leafNodes.concat(getLeafNodes(element.children[i]));
+  }
+
+  return leafNodes;
+}
+
+// Example usage:
+const leafNodes = getLeafNodes(document.body);
+console.log('Leaf nodes:', leafNodes);
+
+```
+
+In this implementation:
+
+The function checks if the current element has no children. If so, it adds it to the leafNodes array.
+Otherwise, it recursively collects leaf nodes from each child.
+
+**References**
+
+- https://developer.mozilla.org/en-US/docs/Web/API/ParentNode/children
+---
+
+

web/src/pages/concepts/primitives.mdx

@@ -442,4 +442,57 @@ console.log(unicodeSmileyExample);
 const filePathExample = "Path: C:\\\\Program Files\\\\MyApp";
 console.log(filePathExample);
 // Output: Path: C:\\Program Files\\MyApp
-```
+```
+---
+### 15. Show the usage of instanceof operator on different types of objects
+The instanceof operator checks if an object is an instance of a specific class or constructor function.
+
+```javascript
+console.log([] instanceof Array); // true
+console.log({} instanceof Object); // true
+console.log(function() {} instanceof Function); // true
+console.log(new Date() instanceof Date); // true
+console.log("text" instanceof String); // false (primitive string, not an object)
+console.log(new String("text") instanceof String); // true (String object)
+```
+**References**
+- https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/instanceof
+---
+### 16. Demonstrate the usage of Array.isArray() to check for arrays
+The Array.isArray() method determines whether the provided value is an array.
+
+```javascript
+
+console.log(Array.isArray([])); // true
+console.log(Array.isArray({})); // false
+console.log(Array.isArray("string")); // false
+console.log(Array.isArray(new Array())); // true
+```
+**References**
+- https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray
+---
+
+### 17. Show how to create and use a WeakMap with objects
+WeakMaps are collections of key-value pairs where keys are objects and can be garbage-collected if there are no other references.
+
+```javascript
+
+const weakMap = new WeakMap();
+
+let obj1 = {};
+let obj2 = {};
+
+weakMap.set(obj1, "Object 1");
+weakMap.set(obj2, "Object 2");
+
+console.log(weakMap.get(obj1)); // "Object 1"
+console.log(weakMap.get(obj2)); // "Object 2"
+
+obj1 = null; // obj1 can be garbage collected now
+// weakMap entry for obj1 will also be removed automatically
+```
+**References**
+- https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap
+---
+
+

web/src/pages/interview_questions/faq_js.mdx

@@ -456,3 +456,56 @@
   - Dynamic typing allows variables to hold values of any type without explicit type declaration, enabling type checking at runtime.
 
 
+### 31. What are the main differences between ES5 and ES6?
+1. Variable Declarations
+ES5: Uses var (function-scoped).
+ES6: Introduces let and const (block-scoped).
+
+2. Arrow Functions
+ES5: Regular functions with function.
+ES6: Arrow functions (() => {}) with lexical this.
+
+3. Template Literals
+ES5: String concatenation with +.
+ES6: Template literals using backticks for interpolation.
+
+4. Destructuring Assignment
+ES5: Manual extraction of values.
+ES6: Simplified destructuring for arrays and objects.
+
+5. Modules
+ES5: No native support; relies on libraries.
+ES6: Native import and export for modules.
+
+6. Promises
+ES5: Callbacks for async operations.
+ES6: Promises for better async handling.
+
+7. Iterators and Generators
+ES5: No support for iterators.
+ES6: Introduces iterators and generator functions.
+
+### 32. How do you implement inheritance in JavaScript?
+
+Inheritance can be implemented using prototypes or the class syntax introduced in ES6.
+```javascript
+function Animal(name) {
+  this.name = name;
+}
+Animal.prototype.speak = function() {
+  console.log(`${this.name} makes a noise.`);
+};
+
+function Dog(name) {
+  Animal.call(this, name);
+}
+Dog.prototype = Object.create(Animal.prototype);
+Dog.prototype.bark = function() {
+  console.log(`${this.name} barks.`);
+};
+```
+---
+### 33. What is a memory leak in JavaScript, and how can you avoid it?
+- A memory leak occurs when memory that is no longer needed is not released. Common causes include global variables, closures, and forgotten timers. 
+  You can avoid memory leaks by ensuring proper cleanup of unused objects and avoiding unnecessary global variables.
+---