FE interview

web fundamentals

• List a few optimization techniques with which we can improve the load time of a website. Image Optimization(WebP instead of JPEG or PNG), Minification and Concatenation(Minify CSS, JavaScript, and HTML files to reduce file sizes by removing unnecessary characters), Browser Caching, Reduce Server Response Time, Reduce HTTP Requests, Optimize Web Fonts
• What is Server Side Rendering?
• difference between ssr and csr and when to preferred ssr vs csr
• what is websocket
• What are content delivery networks? A Content Delivery Network (CDN) is a system of distributed servers that work together to deliver web content, such as images, videos, scripts, and stylesheets, to users more efficiently. The primary goal of a CDN is to improve the performance, reliability, and speed of delivering content to users across different geographic locations.
• What is the difference between authentication and authorization? Authentication verifies the identity of a person or device, at the same time as authorization determines their access rights and permissions.
• What is a minification of code and why should we use it? Minification of code is the process of removing all unnecessary characters (spaces, line breaks, comments) from the source code of web applications without changing its functionality, why should we use it - Reduced File Size, Improved Performance and SEO Benefits.
• difference between local storage and session storage
• what is cookies and What are cookies used for Cookies are small pieces of text sent to browser by a web app. They contain data that can be used by the web app to remember information about your visit, such as your preferences or login status
• difference between flex and grid
• difference between display none and visibility hidden display none completely removes the element from the webpage layout
• what is box model in css
• what is SPA
• what are semantic tags A semantic element clearly describes its meaning to both the browser and the developer
• difference between inline and block elements
• difference between position fixed and sticky
• what is box sizing
• what is z index in css
• what is Frontend Build Tools webpack

Js

• what are the data types in javascript Primitive Data Types and Non-Primitive (Reference) Data Types
• why javascript is dynamically typed language JavaScript is a dynamic language and not static, cause variables can hold values of different types during runtime.
• what is microtask Microtask Queue is like the Callback Queue, but Microtask Queue has higher priority. All the callback functions coming through Promises and Mutation Observer will go inside the Microtask Queue. For example, in the case of .fetch(), the callback function gets to the Microtask Queue.
• memoization debouncing and throttling Memoization is the technique storing the result so we can use it next time instead of calculating the same thing again and again. Debouncing ensures that a function is not called too frequently we can delay its execution time Use Case: Search Input (300 milliseconds) Throttling makes sure that a function is only run once during a set period of time (interval), no matter how many times an event happens Use Case: Scrolling (200 milliseconds)
• what is closure and lexical scope , explain via writing code closure is the combination of lexical scope and local scope of inner function. Lexical Scope defines that inner functions can access the scope of parent functions even if they has returned.
• what is currying in javascript Currying is a functional programming technique where a function with multiple arguments is transformed into a single argument like a series.
• event loop
• what is difference between normal function and arrow function Arrow functions use the "fat arrow" syntax (=>) to create a concise way to write functions. Arrow functions do not create their own this binding Arrow functions cannot be used as constructors Hoisting can’t be achieved by using arrow function
• what is Higher-order function
• what is hoisting
• what is tdz in javascript
• diff bt var and let
• what is event delegation and bubbling
• diff bt sync and Async
• what is callback hell
• what is promise
• what are the states of promises
• what is promise chaining
• what is async and await in JavaScript
• 𝐀𝐬𝐲𝐧𝐜/𝐃𝐞𝐟𝐞𝐫
• 𝐏𝐨𝐥𝐲𝐟𝐢𝐥𝐥
• 𝐂𝐎𝐑𝐒
• what is event delegation and event bubbling
• https://gist.github.com/ajayjhaDev/eef4d139120acb6c69c64fa4a9be1ceb

React

• https://gist.github.com/ajayjhaDev/a84c7e86020ceb34a0a9b7c14edb3688
• suspense lazy loading
• code splitting react
• error boundary react
• what are way to optimize the react application
• difference between axios and fetch

go to oops class methods and all
chaining
diff prototype proto
typescript questions
position all properties explain
box sizing
css selector preference CSS Specificity hierarchy
what is pseudo selector in css
this keyword in javascript
this keyword refers to different objects depending upon context of the code
bind call apply
call(): Invokes the function immediately with arguments passed individually.
apply(): Invokes the function immediately with arguments passed as an array.
bind(): Returns a new function with bound this context and arguments, but doesn't invoke it immediately.
useRef createRef
fiber
webworkers
controlled and uncontrolled
useMemo usecallback
diff b/w shallow dom and virtual dom
heapMemory
How do you handle memory leaks in JavaScript applications?
diff b/w deep copy and shallow copy
Shallow Copy stores the references of objects or array values to the original memory address.
whereas Deep copy stores copies of the object’s or array values.
currying
What is CORS error
Doctype in html meta tags and their attributes
How to optimize react build

calculator.add(3).substract(5).multiply(6).getResult()

1. Javascript
2. Machine Coding / React
3. DSA
4. System design
5. Managerial Round

🌲 Javascript (around 45-60 min)

🍄 Design patterns like singleton, factory patterns etc
🍄 Implement the publisher-subscriber pattern in javascript
🍄 Implement the map, filter, reduce, and for Each polyfill
🍄 Implement the Function.bind, call, apply method on the Function Prototype
🍄 Implement Async. parallel, Async.series which executes a set of async tasks parallel and in series
🍄 Implement Retry API with n number of
🍄 Prototype and prototype inheritance
🍄 How rendering work in the browser
🍄 Event delegation and event propagation in js
🍄 Implement Memoization
🍄 Progressive Web application
🍄 Clone an Object
🍄 Debouncing and Throttling
🍄 Implement clearAllTimeout()
🍄 Build a Promise from Scratch
🍄 Event Target — addEventListener, removeEventListener, dispatchEvent
🍄 Intersection Observe

🌴 Implement a function to flatten a nested array (recursive and iterative)

🌴 Promises ( polyfill of Promise all, race, allSettle )

🌴 Implement the publisher-subscriber pattern

🌴 Implement Async. parallel, Async.series which executes a set of async tasks parallel and in series

🌴 Currying with examples and deep clone an Object

🌴 Debouncing, Throttling and Implementing “that” Retry API

🌴 Memorization and how rendering works in a browser

🌲 React/Machine coding (around 60-120min)

👉 Introduction JSX
👉 React Component
👉 Component State and Props
👉 Adding Style (CSS)
👉 Functional and Class components
👉 React Lifecycle Methods
👉 Virtual DOM
👉 React Hooks
👉 Custom Hooks
👉 Context API
👉 Synthetic Events
👉 Routing
👉 Data Flow (Redux/Flux)
👉 Server-Side Rendering
👉 Unit Testing
👉 Jest & React Testing library
👉 Mocking Data
👉 Understanding Webpack (Bundler)
👉 Babel, env, prettier, linter

🌲 Machine Coding

💁‍♂️ Star Rating
💁‍♂️ Design Pop Over
💁‍♂️ Design Accordion
💁‍♂️ Design Carousel
💁‍♂️ Design grid using HTML/CSS and Javascript with search and sort, event bubbling (Amazon onsite)
💁‍♂️ Design NavBar
💁‍♂️ Infinite Scroll
💁‍♂️ Typeahead / autocomplete using trie
💁‍♂️ Implement Debounce function
💁‍♂️ Implement tic tac toe
💁‍♂️ Make snake ladder board
💁‍♂️ Make calendar of any Month like Date Picker
💁‍♂️ Implement throttle function ect

🌲 System design (around 45-60 min)

🌳 Component-Based Architecture
🌳 State Management
🌳 Performance Optimization
🌳 Scalability and Maintainability
🌳 PWA
🌳 CDN
🌳 Security

🌲 Managerial Round (around 45-60 min)

👉 Previous Experience
👉 Problem Solving
👉 Principle

𝐉𝐚𝐯𝐚𝐒𝐜𝐫𝐢𝐩𝐭

1. Variables and Data Types
2. Control Flow (if statements, loops)
3. Functions and Scope
4. Arrays and Objects
5. Promises and Asynchronous Programming
6. Closures
7. Event Handling
8. AJAX and Fetch API
9. Error Handling
10. ES6+ Features (e.g., arrow functions, destructuring)
11. Prototypes and Inheritance
12. Modules and Module Bundlers (e.g., CommonJS, ES modules)

𝐑𝐞𝐚𝐜𝐭

1. JSX (JavaScript XML)
2. Components and Props
3. State and Lifecycle
4. Handling Events in React
5. Conditional Rendering
6. Lists and Keys
7. Forms in React
8. React Hooks
9. Context API
10. Lifecycle Methods
11. React Router
12. Redux (State Management)
13. Higher-Order Components (HOCs)
14. Testing in React (e.g., Jest and React Testing Library)
15. React Performance Optimization

𝐍𝐞𝐭𝐰𝐨𝐫𝐤𝐢𝐧𝐠

1. Content Delivery Networks (CDNs)
2. Domain Sharding
3. HTTP/2 and HTTP/3 Protocols
4. Latency and Bandwidth Optimization

𝐏𝐞𝐫𝐟𝐨𝐫𝐦𝐚𝐧𝐜𝐞 𝐚𝐧𝐝 𝐨𝐩𝐭𝐢𝐦𝐢𝐳𝐚𝐭𝐢𝐨𝐧

1. Critical Rendering Path
2. Minification and Compression
3. Image Optimization Techniques
4. Asynchronous Loading Strategies (e.g., defer, async)

𝐒𝐲𝐬𝐭𝐞𝐦 𝐃𝐞𝐬𝐢𝐠𝐧

1. Scalability considerations
2. Modular and component-based architecture
3. Efficient data fetching and caching strategies
4. Responsive and mobile-friendly design
5. Load balancing and CDN integration

🌴JavaScript fundamentals

→ How does the ‘this’ work in different scenarios?
→ Closure and Hoisting
→ How rendering works in the browser and networking concepts?

🌴 Asynchronous Programming

→ Implement the ‘Function.bind,’ ‘call,’ and ‘apply’ methods on the Function Prototype
→ Implement ‘Async.parallel’ and ‘Async.series’ to execute a set of asynchronous tasks in parallel and in series

🌴 DOM Manipulation

→ How would you approach handling a large number of DOM updates efficiently?
→ What is an event delegation and why is it useful?

🌴 Performance Optimization

→ How do you handle memory leaks in JavaScript applications?
→ What are some ways to improve the performance of a web application?

🌴 Advanced Topics

→ Design patterns (singleton, pubsub, factory method), progressive web application and security patterns

🍄 Promises ( polyfill of Promise all, race, allSettle )
🍄 Currying with example
🍄 String.prototype.repeat
🍄 Implement the compose() and pipe() polyfill .
🍄 Design patterns like singleton, factory patterns etc
🍄 Implement the publisher-subscriber pattern in javascript
🍄 Implement the map, filter, reduce, and for Each polyfill
🍄 Implement the Function.bind, call, and apply method on the Function Prototype
🍄 Implement Async. parallel, Async.series which executes a set of async tasks parallel and in series
🍄 Implement thet Retry API
🍄 Prototype and prototype inheritance
🍄 How rendering work in the browser
🍄 Event delegation and event propagation in js
🍄 Implement Memoization
🍄 Progressive Web application
🍄 Clone an Object
🍄 Debouncing and Throttling
🍄 Implement clearAllTimeout()
🍄 Build a Promise from Scratch
🍄 How does JS "this" works in different scenarios?
🍄 Implement a function to flatten a nested array
🍄 Implement an LRU Cache

Here's my Amazon Frontend Engineer II interview experience to help you!

🌴 Assessment Round:
I got the assignment via e-mail and completed it on the same day. It was primarily a machine coding round.

🌴 Managerial Round:
This round was around past projects and leadership principles.

🌴 Coding Round 1:
It was focused on vanilla JS and CRUD operations on searching and sorting. It also included core concepts of js.

🌴 Coding round 2:
Here I was asked DSA recursion and backtracking based questions similar to file management system in linux.

🌴 System Design Round:
I had to design a web application focusing on scalability optimization, DOM manipulation and accessibility.

𝐑𝐞𝐚𝐜𝐭𝐉𝐒 has been extremely in demand for some years and feels like it will continue to be in demand. 💲💲

Here is step by step roadmap 👇🏻

𝟏.𝐂𝐨𝐦𝐩𝐨𝐧𝐞𝐧𝐭𝐬
• Functional Components
• Class Components
• JSX (JavaScript XML) Syntax

𝟐.𝐏𝐫𝐨𝐩𝐬 (𝐏𝐫𝐨𝐩𝐞𝐫𝐭𝐢𝐞𝐬)
• Passing Props
• Default Props
• Prop Types

𝟑.𝐒𝐭𝐚𝐭𝐞
• useState Hook
• Class Component State
• Immutable State

𝟒.𝐋𝐢𝐟𝐞𝐜𝐲𝐜𝐥𝐞 𝐌𝐞𝐭𝐡𝐨𝐝𝐬 (𝐂𝐥𝐚𝐬𝐬 𝐂𝐨𝐦𝐩𝐨𝐧𝐞𝐧𝐭𝐬)
• componentDidMount
• componentDidUpdate
• componentWillUnmount

𝟓.𝐇𝐨𝐨𝐤𝐬 (𝐅𝐮𝐧𝐜𝐭𝐢𝐨𝐧𝐚𝐥 𝐂𝐨𝐦𝐩𝐨𝐧𝐞𝐧𝐭𝐬)
• useState
• useEffect
• useContext
• useReducer
• useCallback
• useMemo
• useRef
• useImperativeHandle
• useLayoutEffect

𝟔.𝐄𝐯𝐞𝐧𝐭 𝐇𝐚𝐧𝐝𝐥𝐢𝐧𝐠
• Handling Events in Functional Components
• Handling Events in Class Components

𝟕.𝐂𝐨𝐧𝐝𝐢𝐭𝐢𝐨𝐧𝐚𝐥 𝐑𝐞𝐧𝐝𝐞𝐫𝐢𝐧𝐠
• if Statements
• Ternary Operators
• Logical && Operator

𝟖.𝐋𝐢𝐬𝐭𝐬 𝐚𝐧𝐝 𝐊𝐞𝐲𝐬
• Rendering Lists
• Keys in React Lists

𝟗.𝐂𝐨𝐦𝐩𝐨𝐧𝐞𝐧𝐭 𝐂𝐨𝐦𝐩𝐨𝐬𝐢𝐭𝐢𝐨𝐧
• Reusing Components
• Children Props
• Composition vs Inheritance

𝟏𝟎.𝐇𝐢𝐠𝐡𝐞𝐫-𝐎𝐫𝐝𝐞𝐫 𝐂𝐨𝐦𝐩𝐨𝐧𝐞𝐧𝐭𝐬 (𝐇𝐎𝐂)
• Creating HOCs
• Using HOCs for Reusability

𝟏𝟏.𝐑𝐞𝐧𝐝𝐞𝐫 𝐏𝐫𝐨𝐩𝐬
• Using Render Props Pattern

𝟏𝟐.𝐑𝐞𝐚𝐜𝐭 𝐑𝐨𝐮𝐭𝐞𝐫
•
•
•
•
• Route Parameters

𝟏𝟑.𝐍𝐚𝐯𝐢𝐠𝐚𝐭𝐢𝐨𝐧
• useHistory Hook
• useLocation Hook

𝐒𝐭𝐚𝐭𝐞 𝐌𝐚𝐧𝐚𝐠𝐞𝐦𝐞𝐧𝐭

𝟏𝟒.𝐂𝐨𝐧𝐭𝐞𝐱𝐭 𝐀𝐏𝐈
• Creating Context
• useContext Hook

𝟏𝟓.𝐑𝐞𝐝𝐮𝐱
• Actions
• Reducers
• Store
• connect Function (React-Redux)

𝟏𝟔.𝐅𝐨𝐫𝐦𝐬
• Handling Form Data
• Controlled Components
• Uncontrolled Components

𝟏𝟕.𝐒𝐢𝐝𝐞 𝐄𝐟𝐟𝐞𝐜𝐭𝐬
• useEffect for Data Fetching
• useEffect Cleanup

𝟏𝟖.𝐀𝐉𝐀𝐗 𝐑𝐞𝐪𝐮𝐞𝐬𝐭𝐬
• Fetch API
• Axios Library

𝐄𝐫𝐫𝐨𝐫 𝐇𝐚𝐧𝐝𝐥𝐢𝐧𝐠

𝟏𝟗.𝐄𝐫𝐫𝐨𝐫 𝐁𝐨𝐮𝐧𝐝𝐚𝐫𝐢𝐞𝐬
• componentDidCatch (Class Components)
• ErrorBoundary Component (Functional
Components)

𝟐𝟎.𝐓𝐞𝐬𝐭𝐢𝐧𝐠
• Jest Testing Framework
• React Testing Library

𝟐𝟏.𝐎𝐩𝐭𝐢𝐦𝐢𝐳𝐚𝐭𝐢𝐨𝐧
• Memoization
• Profiling and Performance Monitoring

𝟐𝟐. 𝐁𝐮𝐢𝐥𝐝 𝐚𝐧𝐝 𝐃𝐞𝐩𝐥𝐨𝐲𝐦𝐞𝐧𝐭
• Create React App (CRA)
• Production Builds
• Deployment Strategies

𝐅𝐫𝐚𝐦𝐞𝐰𝐨𝐫𝐤𝐬 𝐚𝐧𝐝 𝐋𝐢𝐛𝐫𝐚𝐫𝐢𝐞𝐬

𝟐𝟑.𝐒𝐭𝐲𝐥𝐢𝐧𝐠 𝐋𝐢𝐛𝐫𝐚𝐫𝐢𝐞𝐬
• Styled-components
• CSS Modules

𝟐𝟒.𝐒𝐭𝐚𝐭𝐞 𝐌𝐚𝐧𝐚𝐠𝐞𝐦𝐞𝐧𝐭 𝐋𝐢𝐛𝐫𝐚𝐫𝐢𝐞𝐬
• Redux
• MobX

𝟐𝟔.𝐑𝐨𝐮𝐭𝐢𝐧𝐠 𝐋𝐢𝐛𝐫𝐚𝐫𝐢𝐞𝐬
• React Router
• Reach Router

1. Program to find longest word in a given sentence ?
2. How to check whether a string is palindrome or not ?
3. Write a program to remove duplicates from an array ?
4. Program to find Reverse of a string without using built-in method ?
5. Find the max count of consecutive 1’s in an array ?
6. Find the factorial of given number ?
7. Given 2 arrays that are sorted [0,3,4,31] and [4,6,30]. Merge them and sort [0,3,4,4,6,30,31] ?
8. Create a function which will accepts two arrays arr1 and arr2. The function should return true if every value in arr1 has its corresponding value squared in array2. The frequency of values must be same.
9. Given two strings. Find if one string can be formed by rearranging the letters of other string.
10. Write logic to get unique objects from below array ? I/P: [{name: "sai"},{name:"Nang"},{name: "sai"},{name:"Nang"},{name: "111111"}]; O/P: [{name: "sai"},{name:"Nang"}{name: "111111"}
11. Write a JavaScript program to find the maximum number in an array.
12. Write a JavaScript function that takes an array of numbers and returns a new array with only the even numbers.
13. Write a JavaScript function to check if a given number is prime.
14. Write a JavaScript program to find the largest element in a nested array. [[3, 4, 58], [709, 8, 9, [10, 11]], [111, 2]]
15. Write a JavaScript function that returns the Fibonacci sequence up to a given number of terms.
16. Given a string, write a javascript function to count the occurrences of each character in the string.
17. Write a javascript function that sorts an array of numbers in ascending order.
18. Write a javascript function that sorts an array of numbers in descending order.
19. Write a javascript function that reverses the order of words in a sentence without using the built-in reverse() method.
20. Implement a javascript function that flattens a nested array into a single-dimensional array.

<!--------------------------------------------------------------->

1. Fundamentals: Start with the basics - variables, data types, and operators.
2. Functions: Dive deep into functions, understanding scope, closures, and the 'this' keyword.
3. ES6 Features: Get comfortable with arrow functions, destructuring, spread/rest operators, and template literals.
4. Async JavaScript​: Promises and async/await for handling asynchronous operations.
5. DOM Manipulation: Know how to interact with the Document Object Model (DOM) effectively.
6. Event Handling: Learn about event listeners, event delegation, and the event object.
7. Prototypes and Classes: Understand JavaScript's prototypal inheritance and ES6 classes.
8. Closures: Master this concept, as it's often tested in interviews.
9. Module Systems: Explore CommonJS, AMD, and ES6 modules.
10. AJAX and Fetch API: Learn how to make asynchronous HTTP requests.
11. Design Patterns: Know the most common patterns like Singleton, Observer, and Module.
12. JSON: Understand JSON parsing and stringify.
13. Error Handling: Learn how to handle errors gracefully with try...catch.
14. Data Structures: Arrays, objects, maps, and sets are essential.
15. Functional Programming: Concepts like map, filter, and reduce are valuable.
16. Build Tools: Grasp Webpack and Babel for bundling and transpiling.
17. Testing: Explore testing frameworks like Jest and Mocha.
18. Debugging: Proficiency with browser developer tools is a must.
19. ESLint and Code Style: Adhere to clean code practices.
20. Security: Understand common web security vulnerabilities (e.g., XSS, CSRF).
21. Promises and Async/Await: Master asynchronous programming.
22. Modern JavaScript Frameworks: Learn a popular framework like React, Angular, or Vue.js.
23. Working with APIs: Know how to integrate external APIs into your applications.
24. Documentation: Keep your code well-documented for clarity.
25. Automation: Grasp task runners like Grunt and Gulp.
26. Progressive Web Apps (PWAs): Understand PWA concepts and service workers.
27. Web Performance: Optimize your code for speed and efficiency.

1. 𝗝𝗮𝘃𝗮𝗦𝗰𝗿𝗶𝗽𝘁 𝗘𝗻𝗴𝗶𝗻𝗲 ↳ Understand the engine behind the code how it all works under the hood.
2. 𝗖𝗮𝗹𝗹 𝗦𝘁𝗮𝗰𝗸 & 𝗠𝗲𝗺𝗼𝗿𝘆 𝗛𝗲𝗮𝗽 ↳ Know where JavaScript stores data critical for memory management.
3. 𝗘𝘅𝗲𝗰𝘂𝘁𝗶𝗼𝗻 𝗖𝗼𝗻𝘁𝗲𝘅𝘁 ↳ Grasp how JavaScript runs your code step-by-step.
4. 𝗛𝗼𝗶𝘀𝘁𝗶𝗻𝗴 ↳ A must-know for working with variable and function declarations.
5. 𝗖𝗹𝗼𝘀𝘂𝗿𝗲𝘀 & 𝗣𝗿𝗼𝘁𝗼𝘁𝘆𝗽𝗲𝘀 ↳ Understand scope, encapsulation, and how objects inherit methods.
6. 𝗢𝗯𝗷𝗲𝗰𝘁-𝗢𝗿𝗶𝗲𝗻𝘁𝗲𝗱 𝗣𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴 (𝗢𝗢𝗣) ↳ Build applications that scale and remain maintainable.
7. 𝗙𝘂𝗻𝗰𝘁𝗶𝗼𝗻𝗮𝗹 𝗣𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴 (𝗙𝗣) ↳ Embrace immutability, pure functions.
8. 𝗠𝗼𝗱𝘂𝗹𝗲𝘀 𝗶𝗻 𝗝𝗮𝘃𝗮𝗦𝗰𝗿𝗶𝗽𝘁 ↳ Organise and reuse code like a pro.
9. 𝗘𝗿𝗿𝗼𝗿 𝗛𝗮𝗻𝗱𝗹𝗶𝗻𝗴 ↳ Develop robust solutions with proper error management.
10. 𝗗𝗮𝘁𝗮 𝗦𝘁𝗿𝘂𝗰𝘁𝘂𝗿𝗲𝘀 & 𝗔𝗹𝗴𝗼𝗿𝗶𝘁𝗵𝗺𝘀 ↳ Solidify your fundamentals to tackle technical interviews with confidence.

1. What is React?
2. What is useMemo ?
3. What are the features of React ?
4. What is JSX ?
5. What is DOM ?
6. What is Virtual Dom ?
7. What is component life cycle of React class component ?
8. What are fragments in react ?
9. What are props in react ?
10. What are synthetic events in react ?
11. What are the difference between Package.json and Package.lock.json ?
12. What are the differences between client side and server side rendering ?
13. What is state in Reactjs?
14. What are props ?
15. What are the differences between State and Props in react ?
16. What is props drilling ?
17. What are the disadvantages of props drilling and How we can avoid props drilling ?
18. What are Pure components in React ?
19. Whatare Ref’s in React?
20. What is meant by forward ref ?
21. What are Error boundaries ?
22. What are Higher order components in react ?
23. What are the differences between controlled and uncontrolled components ?
24. What is useCallback ?
25. What are the differences between useMemo and useCallback ?
26. What are keys in React ?
27. What is Lazy loading in React ?
28. What is suspense in React ?
29. What are custom hooks ?
30. What is useReducer hook ?
31. What are Portals in react ?
32. What is context in react ?
33. Practical question: Give an example of context api usage ?
34. What is the purpose of callback function as an argument of setState()?
35. Practical question: create a custom hook for increment/decrement counter ?
36. Which lifecycle hooks in class component are replaced with useEffect in functional components ?
37. What is Strict mode in react ?
38. What are the different ways to pass data from child component to parent component in react ?
39. Practical question: How to send data from child to parent using callback functions ?
40. Practical question: How to send the data from child component to parent using useRef ?

<!---------------------------------->

1. What is the difference between 'Pass by Value' and 'Pass by Reference'?
2. What is the difference between map and filter ?
3. What is the difference between map() and forEach()
4. What are the differences between call(), apply() and bind() ?
5. List out some key features of ES6 ?
6. What’s the spread operator in javascript ?
7. What is rest operator in javascript ?
8. What is temporal dead zone ?
9. What is a polyfill in javascript ?
10. What is prototype in javascript ?
11. What is IIFE ?
12. What are the different datatypes in javascript ?
13. What is authentication vs authorization ?
14. Difference between null and undefined ?
15. What is the output of 3+2+”7” ?
16. Slice vs Splice in javascript ?
17. What is destructuring ?
18. What is setTimeOut in javascript ?
19. What is setInterval in javascript ?
20. What are Promises in javascript ?
21. What is a closure ?
22. What are callbacks in javascript ?
23. What are Higher Order Functions in javascript ?
24. What is the difference between == and === in javascript ?
25. What is Hoisting ?
26. What are the differences let, var and const ?
27. What are limitations of arrow functions?
28. What is the difference between Shallow copy and deep copy ?
29. What is event bubbling
30. What is event capturing ?
31. What is this in javascript and How it behaves in various scenarios ?
32. How do you optimize the performance of application
33. What is meant by debouncing and throttling?

Here are 32 questions most asked DSA questions that you should visit
If you are preparing to switch jobs.

1. Reverse a linked list
2. Find the middle element of a linked list
3. Detect a cycle in a linked list
4. Find the intersection point of two linked lists
5. Check if a binary tree is a binary search tree (BST)
6. Find the largest/smallest element in an array
7. Implement depth-first search (DFS) on a graph
8. Implement breadth-first search (BFS) on a graph
9. Implement binary search in an array
10. Find the kth smallest/largest element in an array
11. Find the longest common subsequence of two strings
12. Implement merge sort
13. Implement quick sort
14. Implement Dijkstra's algorithm for the shortest path
15. Find the longest palindrome substring in a string
16. Find the median of two sorted arrays
17. Check if two strings are anagrams of each other
18. Implement a trie (prefix tree)
19. Implement an LRU (Least Recently Used) Cache
20. Find all permutations of a string
21. Implement a stack using arrays/linked list
22. Implement a queue using arrays/linked list
23. Implement a priority queue
24. Implement Kruskal's algorithm for minimum spanning tree
25. Implement Prim's algorithm for minimum spanning tree
26. Count the number of inversions in an array
27. Find the shortest path in a maze
28. Find all subsets of a set
29. Find the longest substring without repeating characters
30. Implement the Knuth–Morris–Pratt (KMP) algorithm for string matching
31. Implement the Rabin-Karp algorithm for string matching
32. Implement the Josephus Problem