Here's the detailed timetable from June 17th #### 1:00 PM - 2:00 PM (1 hour)

10:16 PM to June 19th 10:30 AM:

- **Break**
### Day 1: June 17th

#### 10:16 PM - 1:00 AM (2 hours 44 minutes)

#### 2:00 PM - 5:00 PM (3 hours)
- **Introduction to JavaScript**
- **Objects and Arrays**
- Overview of JavaScript and its uses
- Creating and manipulating objects
- Setting up the development environment
(Node.js, browsers) - Arrays and array methods

- Basic syntax and operators - Destructuring

### Day 2: June 18th #### 5:00 PM - 8:00 PM (3 hours)

- **DOM Manipulation**
#### 7:00 AM - 10:00 AM (3 hours)

- **Fundamentals** - Selecting and modifying DOM elements

- Variables, data types, and constants - Event listeners and handlers

- Creating dynamic content

- Basic input/output

- Conditional statements (if, else, switch)

#### 8:00 PM - 9:00 PM (1 hour)

- **Dinner Break**
#### 10:00 AM - 1:00 PM (3 hours)

- **Loops and Functions**

- Loops (for, while, do-while) #### 9:00 PM - 12:00 AM (3 hours)

- Functions and scope - **Advanced Topics**

- Arrow functions - Higher-order functions

- Callbacks, Promises, and Async/Await

- Error handling
### Day 3: June 19th #### 5:00 PM - 8:00 PM (3 hours)

#### 7:00 AM - 10:00 AM (3 hours) - **Practice Project**

- **Working with APIs** - Building a small project to integrate learned

concepts
- Fetch API and AJAX
- Debugging and troubleshooting
- Handling API responses

- Practical example with a public API

#### 8:00 PM - 9:00 PM (1 hour)

- **Dinner Break**
#### 10:00 AM - 1:00 PM (3 hours)

- **Modern JavaScript (ES6+)**

#### 9:00 PM - 10:30 PM (1.5 hours)
- Let, const, and block scope
- **Review and Q&A**
- Classes and inheritance
- Revisiting challenging topics
- Modules and import/export
- Q&A session (with yourself or a study group)

- Planning next steps for continued learning

#### 1:00 PM - 2:00 PM (1 hour)

- **Break**
Here are some common JavaScript interview
questions along with concise answers:
#### 2:00 PM - 5:00 PM (3 hours)

- **Tooling and Workflow** 1. **What is JavaScript?**

- Setting up a development workflow - JavaScript is a programming language
(Webpack, Babel) commonly used to create interactive effects
- Linting and formatting (ESLint, Prettier) within web browsers.

- Using version control (Git basics)

2. **What are the data types supported by
JavaScript?**

- Number, String, Boolean, Object, Undefined,

Null, Symbol, BigInt.
3. **What is the difference between `let`,
`const`, and `var`?**
- `let` and `const` have block scope, while `var`
has function scope; `const` is used for
constants.
4. **What is a closure?**
- A closure is a function that retains access to
its lexical scope even when the function is
executed outside that scope.
5. **What is hoisting?**
- Hoisting is JavaScript's default behavior of
moving declarations to the top of the current
scope.
6. **What are Arrow functions?**
- Arrow functions provide a shorter syntax for
writing functions and do not have their own
`this` context.
7. **What is the event loop?**
- The event loop is a process that handles and
executes asynchronous code in JavaScript.
8. **What is the difference between `==` and
`===`?**
- `==` checks for value equality with type
coercion, while `===` checks for value and type
equality.
9. **What is the `this` keyword?**
- `this` refers to the context in which a
function is executed.
10. **What are promises?**
- Promises are objects that represent the
eventual completion (or failure) of an
asynchronous operation and its resulting value.
11. **What is `async/await`?**
- `async/await` are syntactic sugar over
promises, making asynchronous code look and
behave more like synchronous code.
12. **What is a callback function?**
- A callback function is a function passed into
another function as an argument to be
executed later.
13. **What is the DOM?**
- The DOM (Document Object Model) is a
programming interface for HTML and XML
documents, representing the structure as a
tree.
14. **How do you select elements in the
DOM?**
- Using methods like `getElementById`,
`getElementsByClassName`,
`getElementsByTagName`, `querySelector`, and
`querySelectorAll`.
15. **What are higher-order functions?**
- Higher-order functions are functions that
can take other functions as arguments or return
them as results.
16. **What is the difference between `null` and
`undefined`?**
- `null` is an assignment value representing no
value, while `undefined` means a variable has
been declared but not assigned a value.
17. **What is the use of `JSON.stringify` and
`JSON.parse`?**
- `JSON.stringify` converts a JavaScript object
to a JSON string, and `JSON.parse` converts a
JSON string to a JavaScript object.
18. **What are template literals?**
- Template literals are string literals allowing
embedded expressions, written with backticks
(`) and `${expression}` syntax.
19. **What is destructuring?**
- Destructuring is a syntax that allows you to
unpack values from arrays or properties from
objects into distinct variables.
20. **What is the spread operator?**
- The spread operator (`...`) allows an iterable
to expand in places where multiple arguments
or elements are expected.
21. **What are modules in JavaScript?**
- Modules are reusable pieces of code that
can be imported and exported between files
using `import` and `export` statements.
22. **What is event delegation?**
- Event delegation is a technique of using a
single event listener to manage all events of a
particular type on multiple child elements.
23. **What is the difference between
synchronous and asynchronous code?**
- Synchronous code is executed in sequence,
blocking further execution until it finishes, while
asynchronous code allows other operations to
continue before completing.
24. **What is `NaN`?**
- `NaN` stands for Not-a-Number and is a
value representing an undefined or
unrepresentable number.
25. **What are `Map` and `Set` objects?**
- `Map` is a collection of key-value pairs, and
`Set` is a collection of unique values.
26. **What is `strict mode`?**
- `Strict mode` is a way to opt into a restricted
variant of JavaScript, which can help catch
common coding errors and unsafe actions.
27. **What is the difference between `call`,
`apply`, and `bind`?**
- `call` and `apply` invoke a function with a
given `this` value and arguments, `call` takes
arguments individually, `apply` takes them as an
array; `bind` returns a new function with a given
`this` value and arguments.
32. **What are proxies in JavaScript?**
- Proxies are objects that allow you to create
custom behavior for fundamental operations
(e.g., property lookup, assignment).
33. **What are symbols?**

- Symbols are a unique and immutable

28. **What is an Immediately Invoked Function primitive value that can be used as the key of an
Expression (IIFE)?** object property.

- An IIFE is a function that is executed

immediately after it is defined, typically used to
create a new scope.
29. **What are JavaScript data structures like
`Map` and `WeakMap`?**
- `Map` is a collection of key-value pairs,
`WeakMap` is similar but keys are weakly
referenced, preventing memory leaks.
34. **What is `typeof` operator?**
- `typeof` is an operator that returns a string
indicating the type of the unevaluated operand.
35. **What is `instanceof` operator?**
- `instanceof` checks whether an object is an
instance of a specific class or constructor.

Certainly! Here are 100 JavaScript interview

questions starting from question 36, with no
30. **What is the difference between `for...of` repetitions:
and `for...in`?**

- `for...of` iterates over iterable objects like

arrays, `for...in` iterates over enumerable
properties of an object.
31. **What is a generator function?**
36. **What is a polyfill?**
- A polyfill is code that provides modern
functionality on older browsers that do not
natively support it.

- A generator function is a function that can

pause its execution and resume later,
maintaining its context, using `function*` syntax
and `yield`.
37. **What is event bubbling and capturing?**

- Event bubbling is when an event propagates 43. **What is CORS?**

from the target element up to the root, event
capturing is the reverse, from the root to the
target.
- CORS (Cross-Origin Resource Sharing) is a
mechanism to allow or restrict requested
resources on a web server based on the origin
of the request.

38. **What is the difference between `==` and

`Object.is`?**
- `Object.is` compares two values for strict
equality but treats `NaN` as equal to `NaN` and
`+0` not equal to `-0`.
44. **What are service workers?**
- Service workers are scripts that run in the
background and provide features like push
notifications and background sync for web
applications.

39. **What is a debounce function?**

- A debounce function limits the rate at which
a function can fire, ensuring it is not called again
until a certain amount of time has passed.
40. **What is a throttle function?**
45. **What is the `Fetch API`?**
- The Fetch API provides an interface for
fetching resources (e.g., across the network),
simpler and more powerful than
`XMLHttpRequest`.

- A throttle function ensures a function is

called at most once in a specified period,
controlling the rate of function calls.
41. **What are Web Workers?**
46. **What is `localStorage`?**
- `localStorage` is a web storage object that
allows you to store key-value pairs in a web
browser with no expiration time.

- Web Workers are a way to run scripts in

background threads, allowing for concurrent
execution in web applications.
42. **What is a `Blob`?**
47. **What is `sessionStorage`?**
- `sessionStorage` is similar to `localStorage`
but data is only stored for the duration of the
page session.

- A `Blob` is a file-like object of immutable,

raw data, often used for file handling and binary
data.
48. **What is a cookie?**
- A cookie is a small piece of data stored by
the browser that can be sent back to the server
with subsequent requests.
49. **What is the `use strict` directive?**
- `use strict` is a directive that helps catch
common coding errors and "unsafe" actions in
JavaScript by enforcing stricter parsing and
error handling.
50. **What are tagged template literals?**
- Tagged template literals allow you to parse
template literals with a function.
51. **What is the purpose of `Object.freeze`?**
- `Object.freeze` prevents modification to
properties and values of an object, making it
immutable.
52. **What is function currying?**
- Currying is the process of transforming a
function with multiple arguments into a
sequence of functions each taking a single
argument.
53. **What is the `eval` function?**
- `eval` is a function that executes a string of
JavaScript code.
54. **What is the difference between
`Object.create` and `new`?**
- `Object.create` creates a new object with
the specified prototype object and properties,
`new` creates an instance of a user-defined
object type or one of the built-in object types.
55. **What is `Promise.all`?**
- `Promise.all` takes an iterable of promises
and returns a single promise that resolves when
all of the promises have resolved.
56. **What is the difference between deep and
shallow copy?**
- A shallow copy copies an object's structure
but not the nested objects, while a deep copy
duplicates everything, creating entirely new
instances.
57. **What is `this` in JavaScript?**
- `this` refers to the object from which the
function was called.
58. **What is `try...catch`?**
- `try...catch` is a statement that allows you to
handle errors in JavaScript.
59. **What is the `spread` syntax?**
- The spread syntax allows an iterable such as
an array or string to be expanded in places
where zero or more arguments (for function
calls) or elements (for array literals) are
expected.
60. **What is the `rest` parameter?**
- The rest parameter syntax allows us to
represent an indefinite number of arguments as
an array.
61. **What is a promise chain?**
- A promise chain is a series of `.then()` calls,
where each subsequent `.then()` runs after the
previous promise resolves.
62. **What is an async generator function?**
- An async generator function is a function
that can yield promises and return a sequence
of asynchronous values using `async function*`
syntax.
63. **What is destructuring assignment?**
- Destructuring assignment is a syntax that
allows extracting values from arrays or
properties from objects into distinct variables.
64. **What is the `Object.assign` method?**
- `Object.assign` copies enumerable own
properties from one or more source objects to a
target object, and returns the target object.
65. **What are template strings (template
literals)?**
- Template strings, or template literals, are
string literals that allow embedded expressions,
using backticks (`` ` ``) and `${}` syntax.
66. **What is an iterable?**
- An iterable is an object that can be iterated
over with a `for...of` loop, and has a
`Symbol.iterator` method that returns an
iterator.
67. **What is an iterator?**
- An iterator is an object with a `next` method
that returns an object with `value` and `done`
properties.
68. **What is the difference between
`Array.map` and `Array.forEach`?**
- `Array.map` returns a new array with the
results of calling a provided function on every
element, while `Array.forEach` executes a
provided function once for each array element
but does not return anything.
69. **What is the difference between
`Array.filter` and `Array.find`?**
- `Array.filter` returns a new array with all
elements that pass the test implemented by the
provided function, while `Array.find` returns the
value of the first element that satisfies the
provided testing function.
70. **What is the `typeof` operator?**
- The `typeof` operator returns a string
indicating the type of the unevaluated operand.
71. **What is a WeakSet?**
- A `WeakSet` is a collection of objects where
the references are weak, allowing objects to be
garbage-collected if there are no other
references to them.
72. **What is a WeakMap?**
- A `WeakMap` is a collection of key-value
pairs where keys are objects and the references
are weak, allowing the keys to be garbage-
collected if there are no other references to
them.
73. **What is the `Proxy` object?**
- The `Proxy` object is used to define custom
behavior for fundamental operations like
property lookup, assignment, enumeration,
function invocation, etc.
74. **What is the `Reflect` API?**
- The `Reflect` API provides methods for
interceptable JavaScript operations, similar to
most of the methods on the `Proxy` handler
object, but also includes some methods not
specific to proxies.
75. **What is tail call optimization?**
- Tail call optimization is an optimization
where the compiler can optimize recursive calls
to avoid growing the call stack, making
recursive functions more efficient.
76. **What is the purpose of the `with`
statement?**
- The `with` statement extends the scope
chain for a statement, but its use is discouraged
as it can make code harder to understand and
debug.
77. **What is the `debugger` statement?**
- The `debugger` statement invokes any
available debugging functionality, such as
setting a breakpoint in the code.
78. **What is a JavaScript engine?**
- A JavaScript engine is a program or
interpreter that executes JavaScript code, such
as V8 (Chrome, Node.js), SpiderMonkey
(Firefox), or JavaScriptCore (Safari).
79. **What is `Event.preventDefault`?** 85. **What is `Object.entries`?**

- `Event.preventDefault` is a method that - `Object.entries` returns an array of a given

cancels the event if it is cancelable, preventing object's own enumerable string-keyed property
the default action that belongs to the event. `[key, value]` pairs.

80. **What is `Event.stopPropagation`?** 86. **What is `Object.values`?**

- `Event.stopPropagation` is a method that - `Object.values` returns an array of a given

prevents further propagation of the current object's own enumerable property values.
event in the capturing and bubbling phases.

81. **What is a singleton pattern?**

87. **What is `Object.fromEntries`?**
- The singleton pattern is a design pattern
that restricts the instantiation of a class to a `Object.fromEntries` transforms a list of key-
single instance. value pairs into an object.

82. **What is the `new.target` in JavaScript?**

- `new.target` is a meta-property that allows

constructors to check whether they were called
using the `new` operator.

83. **What is object destructuring?**

- Object destructuring is a syntax that allows

you to extract properties from an object and
assign them to variables.

84. **What is array destructuring?**

- Array destructuring is a syntax that allows

you to unpack values from arrays into distinct
variables.