JavaScript has 6 primitive data types: string, number, boolean, undefined, null, and symbol. It also has non-primitive types like objects and arrays.

A closure is a function that retains access to its lexical scope, even when the function is executed outside that scope.

var has function scope and is hoisted.
let has block scope and is not hoisted in the same way.
const is similar to let, but its value cannot be reassigned.

The output is an empty string: "". When two arrays are added together, they are implicitly converted to strings and concatenated.

== compares values after converting them to a common type (type coercion), while === compares both value and type (strict equality).

A callback function is a function passed into another function as an argument to be executed later, typically after an asynchronous operation.

The output is "11", because JavaScript converts the number to a string and concatenates.

The this keyword refers to the context or object in which a function is called. It changes its value depending on how the function is invoked.

Event delegation is a technique where you attach a single event listener to a parent element instead of multiple listeners to child elements. This improves performance and simplifies handling dynamic elements.

The output is 0. This is the result of performing a bitwise AND operation between 2 and 1.

A JavaScript promise is an object representing the eventual completion (or failure) of an asynchronous operation and its resulting value.

Function declaration is hoisted and can be called before it appears in the code.
Function expression is not hoisted and can only be called after it is defined.

The output is "object". This is a known bug in JavaScript, where the type of null is mistakenly returned as object.

The setTimeout function executes a function after a specified delay (in milliseconds). It only runs once after the delay.

function outer() {
  let counter = 0;
  function inner() {
    counter++;
    return counter;
  }
  return inner;
}
const increment = outer();
console.log(increment()); // 1


The function increment is a closure that retains access to the counter variable defined in the outer function.

Hoisting is JavaScript's default behavior of moving declarations (but not initializations) to the top of the code during execution.

An array is an ordered list of values, while an object is a collection of key-value pairs. Arrays have numeric indices, and objects use strings as keys.

Both apply() and call() are used to invoke a function with a specific this context. The difference is that apply() takes an array of arguments, while call() takes individual arguments.

The output is false. In JavaScript, objects (including arrays) are compared by reference, not by value.

The event loop is the mechanism that handles asynchronous operations in JavaScript. It allows non-blocking code execution and handles tasks like I/O, timers, and user interactions.

`undefined` means a variable has been declared but has not yet been assigned a value. `null` is an assignment value that represents "no value" or "empty."

The output is 2, because JavaScript performs type coercion and converts the string to a number before performing the subtraction.

The common loops in JavaScript are `for`, `while`, `do...while`, and `for...in` (for iterating over object properties), `for...of` (for iterating over iterable objects like arrays).

The output is '11'. The `+` operator triggers string concatenation when one operand is a string.

A module in JavaScript is a file that contains reusable code, and it can export functions, objects, or values for use in other files. Modules are used to maintain code modularity and improve maintainability.

`async` and `await` are used to handle asynchronous code in a more readable manner. `async` defines a function that returns a promise, and `await` pauses execution until the promise resolves.

`setTimeout()` runs a function once after a specified delay, while `setInterval()` executes a function repeatedly at regular intervals.

A `Map` is a collection of key-value pairs where both keys and values can be any type (objects, functions, etc.), unlike objects where keys are always strings or symbols.

The output is an empty string: "", because adding two empty arrays results in an empty string due to type coercion.

map() creates a new array with the results of calling a function on every element of the array.
forEach() executes a provided function once for each array element but does not return a new array.

One way to create a deep copy of an object is by using JSON.parse(JSON.stringify(obj)), though this method doesn't copy functions or special objects like Date.

The output is true, because 0 and false are considered equal in JavaScript due to type coercion.

An IIFE is a function that is defined and executed immediately after its declaration. It is commonly used to create a private scope to avoid polluting the global namespace.
Example: (function() {
  console.log("I am an IIFE!");
})();

The `bind()` method creates a new function that, when called, has its `this` keyword set to the provided value, and prepends any given arguments to the function's arguments.

A promise chain is a sequence of promises where each promise is executed in sequence, allowing you to handle asynchronous tasks step by step. Each `.then()` returns a new promise.

slice() returns a shallow copy of a portion of an array without modifying the original array.
splice() changes the contents of an array by removing, replacing, or adding elements.

Arrow functions are a shorthand syntax for writing functions. They are anonymous and do not have their own `this` context.
Example: const add = (a, b) => a + b;

The output is 9, because JavaScript performs type coercion and converts the string to a number before performing the subtraction.

A `Set` is a collection of unique values, meaning no duplicates are allowed. Sets are iterable and can store any type of value (primitives or objects).

The output is true, because JavaScript performs type coercion and compares the values of the operands after converting them to the same type.

Event bubbling is a process where an event starts from the target element and bubbles up to the root of the DOM tree, triggering all ancestor event listeners.

You can prevent event bubbling using event.stopPropagation() to stop the event from propagating to the parent elements.

for...in iterates over the keys of an object or array.
for...of iterates over the values of an iterable object like an array.

`localStorage` stores data persistently across page reloads and browser sessions, while `sessionStorage` stores data for the duration of a page session (until the browser tab is closed).

The output is false, because arrays are compared by reference, not by value, and thus they are not the same object in memory.

Higher-order functions are functions that either take one or more functions as arguments, return a function, or both.

The `reduce()` function is used to accumulate values from an array into a single result. It iterates over the array and applies a function to accumulate the result.
Example: arr.reduce((acc, curr) => acc + curr, 0);

slice() returns a shallow copy of a portion of an array.
splice() changes the original array by adding/removing elements.

`instanceof` checks if an object is an instance of a particular class or constructor function.
`typeof` returns the type of a variable, e.g., "string", "number", "object".

`setImmediate()` schedules a callback to be executed immediately after the current event loop cycle, but after I/O events.

`==` compares values with type coercion, while `===` compares both values and types, meaning it checks for strict equality.

The output is true, because `[]` is falsy and `![]` is also falsy. Thus, `==` compares both to be equal.

A closure is a function that "remembers" its lexical scope, even when the function is executed outside of that scope.

`this` refers to the context in which a function is called, pointing to the object that called the function (or `undefined` in strict mode).

The event loop is the mechanism that handles the execution of multiple code statements in an asynchronous, non-blocking manner in JavaScript.

The output is true, because JavaScript converts both the string `'0'` and the array `[]` to falsy values during comparison.

A `prototype` is an object that is associated with every JavaScript function and object, allowing inheritance of properties and methods.

The `call()` method is used to invoke a function with a specific `this` value and arguments provided individually.

The `apply()` method is similar to `call()`, but the arguments are passed as an array or array-like object.

A debounce function ensures that a function is not executed too frequently by delaying its execution until a specified amount of time has passed since its last call.

A throttle function limits the execution of a function to once every specified amount of time, ensuring it doesn’t execute too frequently.

The `new` keyword is used to create an instance of a constructor function or a class. It creates a new object, sets the constructor's `this`, and runs the constructor function.

The output is object, which is a quirk of JavaScript's type system.

The `setTimeout` function accepts a callback function to be executed after a specified delay. It’s often used to introduce delay or delay the execution of a function.

The `typeof` operator is used to determine the type of a given operand. It returns a string representing the type (e.g., "number", "string", "object").

The `instanceof` operator checks if an object is an instance of a specific class or constructor function.

`setInterval()` is used to repeatedly execute a function at a specified interval in milliseconds until cleared.

The output is '1,1', because JavaScript converts both arrays into strings and joins them with a comma.

You can use the `unshift()` method to add an element to the beginning of an array.

You can use the `push()` method to add an element to the end of an array.

Getters and setters are methods used to access or set the value of an object's properties. They allow you to control access to object properties.
Example: class Person {
  get name() { return this._name; }
  set name(value) { this._name = value; }
}

The `delete` operator is used to remove a property from an object or an element from an array.

A `WeakMap` is similar to a `Map`, but the keys are weakly held. This means that if the key object is garbage-collected, the entry will be removed from the map automatically.

Strict mode is a way to opt into a restricted version of JavaScript. It prevents the use of certain dangerous language features and makes debugging easier by throwing errors for unsafe operations.

The output is false, because arrays are reference types, and the references are not the same.

A `symbol` is a unique and immutable primitive value used to create object property keys that are guaranteed to be unique.

The `navigator` object provides information about the user's browser, operating system, and other environment details.

You can use the `Array.isArray()` method to check if a value is an array.

`var` is function-scoped and can be re-declared, while `let` and `const` are block-scoped. `const` cannot be reassigned, whereas `let` can.

The output is '11', because JavaScript performs string concatenation when one operand is a string.

The `globalThis` object provides a standard way to access the global object across different environments (browser, Node.js, etc.).

Event delegation is a technique in which you attach a single event listener to a parent element and handle events for child elements via event propagation.

Errors in JavaScript can be handled using `try...catch` blocks, where the code that may throw an error is placed inside the `try` block, and the error is caught in the `catch` block.

The `fetch()` API is used to make asynchronous requests to retrieve or send data from/to a server. It returns a promise that resolves to the response object.

You can use the `in` operator or the `hasOwnProperty()` method to check if a property exists in an object.

`super()` is used to call the constructor of a parent class from a child class or to call methods from a parent class.

Destructuring allows you to unpack values from arrays or properties from objects into distinct variables.

The `concat()` method is used to join two or more arrays into a new array.

The `filter()` method creates a new array with all elements that pass a given test function.

The `find()` method returns the first element in an array that satisfies the provided testing function.

The `flat()` method is used to flatten an array of arrays into a single array.

The `reduceRight()` method applies a function against an accumulator and each element in an array (from right to left) to reduce it to a single value.

The `every()` method checks if all elements in an array pass the test implemented by the provided function.

The `some()` method checks if at least one element in an array passes the test implemented by the provided function.

The `join()` method is used to join all elements of an array into a single string, separated by a specified delimiter.

You can use the `isNaN()` function to check if a variable is `NaN` (Not a Number).

`window` is the global object in a browser environment. It represents the browser's window or frame.

You can use the `JSON.parse(JSON.stringify(arr))` method to create a deep copy of an array, although this does not copy methods or special objects like `Date`.

You can use the `indexOf()` method to find the index of an element in an array.

You can create an object using object literal notation: const obj = { key: 'value' } or using the `new Object()` constructor.