100+ essential full-stack developer interview questions and answers for 2024

WebSockets provide a full-duplex, bi-directional communication channel between a client and a server. They allow real-time data transfer and updates, enabling a more interactive and dynamic web experience than traditional HTTP requests.

WebSockets are commonly used for real-time applications such as chat systems, online gaming, and live data streaming.

Referential transparency means that a function or expression always produces the same result given the same input, no matter how many times it is executed. It helps to ensure that each line of code works correctly and as expected, which makes it easier to understand and debug programs.

Event bubbling is a mechanism in JavaScript that allows an event to be triggered on an element and then propagate up the DOM hierarchy. It works by firing an event at the lowest level of the DOM, then bubbles it up to higher levels, allowing all elements with the same type of event listener to be triggered. This makes it easy to manage multiple events without writing separate handlers for each.

In event capturing, the event is first handled by the outermost layer or element, then propagates to the innermost layer. This is known as the "capturing phase" of the event flow. After the capturing phase, the event enters the "target phase," during which the event is handled by the target element. Finally, the event enters the "bubbling phase," during which the event propagates back up the DOM tree from the innermost to the outermost element.

Server-side rendering (SSR) improves a web application's initial load time and performance by rendering the initial view on the server before sending it to the client. This allows the client to display content faster, improving the user experience and making the web application more accessible to search engines.

The prominent tech stack used in full-stack development are MEAN, MERN, MEVN, and LAMP, among others. However, beyond this, there are other tech stacks available as well, such as Django (Python-based), Ruby on Rails (Ruby-based), and ASP.NET (Microsoft-based). The choice of tech stack usually depends on the project requirements, development team expertise, and other factors.

The tech stack primarily used for full-stack development is the MEAN tech stack. The MEAN tech stack stands for MongoDB, Express, Angular, and Node. It is an open-source tech stack based on JavaScript primarily used to develop dynamic web apps and websites.

Flyway: A lightweight open-source database migration tool that allows you to write migrations in SQL or Java.

Liquibase: An open-source database schema change management tool that supports XML, YAML, and SQL formats for migrations.

Database Deployment Manager (DDL): A tool that automates the deployment of database changes, including schema changes, data changes, and stored procedures.

Apache Nifi: A powerful data integration platform that includes tools for database migrations and ETL (Extract, Transform, Load) processes.

dbForge Studio: A database management and development tool that includes features for automating schema changes and database migrations.

SQL Server Management Studio (SSMS): A Microsoft-developed tool for managing and administering SQL Server databases that include features for database migrations and schema changes.

The differences between SQL and NoSQL are:

The 'use strict' is a statement in JavaScript that enables strict mode, which helps prevent certain types of errors. It prevents undeclared variables and improves security, better error checking, and increased code performance. Additionally, some code may only be able to function in strict mode and require the use of 'use strict' for proper operation.

There are several advantages of ‘use strict’ in JavaScript:

Preventing global variables: Strict mode does not allow you to accidentally declare a global variable by forgetting to use the "var" keyword.

Throwing more exceptions: Strict mode will throw more exceptions when incorrect code is written, making it easier to catch mistakes.

Improving security: Strict mode eliminates some of JavaScript's "silent errors" and makes writing "secure" JavaScript easier.

Improving performance: Strict mode may improve performance by reducing the amount of work the JavaScript engine needs to do.

Some of the disadvantages of ‘use strict’ in JavaScript are:

• The older browsers might not be compatible with ‘use strict,’ which could cause compatibility issues.
• You wouldn’t be able to access function.arguments and function.caller
• If you have legacy code that relies on implicit global variables or other practices that are not allowed in strict mode, enabling "use strict" can cause your code to break.

MVC, MVP, and MVVM are architectural patterns used to separate the concerns of an application's data, presentation, and behavior.

MVC: Model-View-Controller separates an application into three parts: the model (data), the view (user interface), and the controller (mediator between model and view).

MVP: Model-View-Presenter separates an application into three parts: the model (data), the view (user interface), and the presenter (mediator between model and view, contains UI logic).

MVVM: Model-View-ViewModel separates an application into three parts: the model (data), the view (user interface), and the view-model (mediator between model and view, contains UI logic, exposes data to the view).

State management involves tracking data throughout the user's interaction with the application. Techniques and tools used include cookies, local and session storage, server-side sessions, URL parameters, or frameworks like Redux for React applications.

These tools aim to provide a centralized and predictable way of managing the state changes of an application by providing a clear and consistent mechanism to update the state and retrieve the latest version of it. It ensures that the different parts of an application work with a consistent data set and can help prevent bugs and unexpected behavior.

PWAs are web applications that combine the best features of web and native apps. They're fast, reliable, and engaging, with features such as offline functionality, push notifications, and the ability to install on devices like native apps.

Docker is an open-source software platform to develop, deploy, and manage applications. It enables you to separate your application from your infrastructure by providing the ability to package and run it in a loosely isolated environment called a container.

The platform eliminates the need for mundane and recurring configuration tasks across the development lifecycle for rapid, convenient, and highly portable cloud and desktop application development.

You can use Docker if you plan to deploy your application on different platforms or environments, and application development has various pieces of code and integrations. Using Dockers streamlines the developer process, as all software components are mentioned in the configuration files associated with Docker.

Docker containers package an application with all its dependencies into a single unit, ensuring consistency and reliability. They create an environment for reproducible builds and deployment, facilitating collaboration, continuous integration, and deploying applications on various platforms. Some of the major tools included in the Docker containers are DockerFile, Docker image, Docker hub, Docker engine, Docker registry, Docker daemon, and Docker desktop.

The purpose of server-side frameworks in a full-stack web application is to provide a set of tools and abstractions that make it easier to build, maintain, and scale the server-side portion of the application.

They can handle common tasks such as routing, data access and persistence, security, and many more, allowing developers to focus on writing the application's business logic.

The HTTP request usually consists of three elements:

Request line: The request line typically includes the HTTP method (such as GET or POST), the URL or URI of the requested resource, and the HTTP version being used.

Headers: The headers provide additional information about the request, such as the user agent making the request, the accepted content types, and any authentication credentials.

Message body: The message body is optional and contains data that may be sent along with the request, such as form data or a JSON payload.

HTTP requests are a prominent way of communicating between the client and the server. When the client submits a request, the server will validate that request and then provide an appropriate HTTP response based on the request. The HTTP response typically consists of status, header, and message body.

The numerous HTTP request methods are:

GET: It is used to retrieve any specific resource.

POST: It is used for submitting data to the server for creating/updating resources.

PUT: The PUT method updates the property of resources.

HEAD: It is used to retrieve the header of a resource.

PATCH: This method is used to make partial changes or updates to a resource.

TRACE: This method echos back the received request for debugging.

DELETE: This method is used to delete a specific resource.

CONNECT: This method is used to establish a connection with the requested resource.

Serverless architecture allows developers to build and run applications and services without managing infrastructure. The purpose of using serverless architecture in a full-stack web application is to

Reduce operational overhead: Serverless architecture offloads infrastructure management to the provider, allowing developers to focus on writing code.

Increase scalability: Serverless architecture automatically scales resources based on demand, ensuring the application can handle varying traffic levels.

Improve cost-efficiency: Serverless architecture charges only for actual usage, making it more cost effective than traditional server-based architecture.

Monitoring HTTP requests to ensure the application service runs optimally is critical. You can monitor HTTP requests through third-party tools or software such as
Sematext synthetics.

It is a monitoring tool that enables you to set up an HTTP request monitor for documenting response data, including headers, errors, body, and other pieces of information. You can choose any specific method, test interval, URL, and different locations for monitoring.

A traditional website has multiple pages, each with its URL and HTML file. The browser reloads the page whenever the user navigates to a different page.

A single-page application (SPA), on the other hand, is a web application that loads a single HTML file and dynamically updates the content without reloading the page. Navigation between pages is achieved through routing within the client-side code using JavaScript and AJAX requests.

This results in a smoother user experience, as only the necessary parts of the page are reloaded, leading to faster and more dynamic interactions.

Cross-site scripting is an injection attack where malicious scripts are injected into the websites by circumventing the origin policy. A hacker sends an XSS script to unsuspecting users, and when the browser on the client side executes that script, the attack is executed. The malicious script can access session tokens, cookies, and other sensitive data.

To prevent cross-site scripting (XSS) attacks, follow these best practices:

Input Validation: Validate and sanitize user input to ensure it does not contain malicious scripts.

Content Security Policy (CSP): Implement a CSP to specify which content sources can be loaded on your website.

HTTP-only Cookies: Use HTTP-only cookies to store sensitive information to prevent them from being accessible to JavaScript code.

Same-Origin Policy: Restrict interactions between different domains to enforce the same-origin policy.

Subresource Integrity (SRI): Use SRI to ensure that external resources loaded on your website are not tampered with.

Use a Web Application Firewall (WAF): A WAF can help prevent XSS attacks by identifying and blocking malicious traffic.

Caching in a full-stack web application can be implemented in multiple ways:

Client-side caching: Using browser storage APIs like localStorage or sessionStorage to store data in the client's browser.

Server-side caching: Using a cache store like Redis or Memcached to store frequently requested data in memory for quick retrieval.

API response caching: Caching API responses on the server side for a certain time to avoid overloading the API with redundant requests.

Page caching: Caching entire HTML pages on the server side to reduce server processing time.

A reverse proxy is responsible for forwarding user requests to the server. The reverse proxy is basically used to protect the web server's identity. The reverse proxy can strategically handle web server requests to optimize security, reliability, and performance.

In web development, database transactions are typically managed using a combination of the database management system (DBMS) and the web application framework being used.

To handle transactions, a web application would use a programming language such as Python, Ruby, or Java and execute the appropriate commands in the database API to start a transaction. This can be used to execute one or more database operations and then either commit or rollback the transaction based on whether the operations were completed successfully.

Horizontal scaling refers to adding more resources (e.g., more servers) to a web application to handle increased traffic, while vertical scaling refers to adding more power (e.g., CPU, memory) to a single server running the application.

Horizontal scaling is generally more scalable, flexible, and fault-tolerant, while vertical scaling is simpler and quicker to implement but has limitations regarding available hardware.

The load balancer is used to direct traffic to optimize the speed and overall performance of the web application. Before the request is sent to the server, the load balancer routes client requests across different servers capable of serving those requests at optimum speed and capacity, thus ensuring no server is overloaded.

The CDN, also called the content delivery network, is a chain of servers for distributing content from the source server across the world by caching the requested data in proximity to the location from where the user is accessing the network.

The requested content is originally stored on the source server and replicated on a nearby server based on user requirements. This caching in the nearby server helps to reduce latency and improves overall speed.

A web-based file management system can be implemented using an existing cloud storage provider like Dropbox or Google Drive. These services provide application programming interfaces (APIs) that allow applications to access and manipulate files.

Furthermore, various tools exist to provide an interface to these cloud-based file management systems, allowing web applications access to a file management system with no server-side implementation required.

A stateless web application uses a structure or a protocol where a previous transaction’s state is neither stored nor referenced in upcoming transactions. On the other hand, stateful web applications use a mechanism that enables users to store or return information and processes that are already established.

Integrating APIs into the web application requires writing code to interact with the API’s endpoints to request or modify data and perform other relevant operations. You can make HTTP requests to the API through different programming languages, such as JavaScript, Python, or Ruby, and use different libraries to make the calls easier.

The cookies have a limited size of around 4kb, while the local storage has a larger size limit of 5-10 MB. Cookies are usually sent with every HTTP request, which is not the case with local storage data. The cookies are vulnerable to cross-site scripting attacks and have a limited lifetime. Overall, local storage is a more secure way of storing information in a web application, but it might not be suitable for every use-case scenario.

The different API protocols used in web applications are as follows:

SOAP: SOAP stands for Simple Object Access Protocol, which is built using XML. This protocol enables users to share data via HTTP and SMTP.

REST: Representational State Transfer (REST) provides architecture principles for web API, and it adheres to the REST architectural style constraints, which enable communication with the RESTful web services.

JSON - RPC: This protocol uses JSON for remote procedure calls to transfer data between the different modules. The call might have other parameters based on the users' requirements.

XML - RPC: This protocol employs the XML format for data transfer, unlike SOAP, which uses a proprietary XML format. XML-RPC offers a more straightforward implementation and is relatively lightweight because it requires minimal bandwidth.

SOAP (Simple Object Access Protocol) and REST (Representational State Transfer) are both web service communication protocols. The main differences between them are:

Structural Constraints: SOAP is a heavily structured protocol with a strict requirement for XML formatting, while REST has no strict message format, allowing for content negotiation through various formats, including XML, JSON, etc.

Statelessness: REST is stateless, which means it does not require the server to store any client context between requests. SOAP, on the other hand, requires the server to maintain a stateful session.

Caching: REST supports caching, where the client can cache a response from the server, reducing network traffic and improving performance, while SOAP does not support caching.

Protocols: SOAP only uses HTTP as the transport protocol, while REST can use any protocol, such as HTTP, HTTPS, FTP, etc.

Use Cases: SOAP is often used for business-critical applications and is commonly used for enterprise applications integration (EAI). REST is more commonly used for lightweight, consumer-facing, and mobile applications.

There are three fundamental ways to handle versioning in a web API:

Using URI path: In this approach, the version number is included in the URI path, usually as part of the endpoint. For example, "/api/v1/customers" would indicate version 1 of the customers' endpoint.

Using query parameters: With this approach, the version number is included as a query parameter in the API request. For example, "/api/customers?version=1" would indicate version 1 of the customers' endpoint.

Using custom headers: With this approach, the version number is included in a custom header in the API request. For example, "X-API-Version: 1" would indicate version 1 of the API.

Handling versioning in a web API involves including a version identifier in the API endpoint URL or in the request headers so that the API can determine which version of the API the client is requesting to use. It helps ensure backward compatibility, as the API can continue supporting older versions while introducing new features in the latest version.

React hooks are functions that allow you to use state and lifecycle features in functional components, rather than using class components. The useState hook is commonly used for managing state in functional components. Here's an example:

A schema in Mongoose defines the structure and validation rules for documents in a MongoDB collection. You create a schema using the mongoose.Schema constructor and use it to create a Model, representing a collection in the database:

Indexing: Ensure relevant columns have indexes to improve query performance.

Normalization: Normalize the data to eliminate redundancy and improve query performance.

Use appropriate datatypes: Choose data types that match the data to reduce memory usage and disk I/O.

Use stored procedures: Stored procedures can be faster than executing individual queries.

Proper use of Temporary Tables: Use temporary tables to store intermediate results and simplify complex queries.

Monitor performance: Regularly monitor and analyze performance metrics to identify and resolve any issues.

Mongoose is an object data modeling library for MongoDB that provides a simple and straightforward way to connect to a MongoDB database. To establish a connection, you need to use the connect() method and provide the URI for your MongoDB database:

• Choose an authentication method, such as email/password, OAuth, or JWT.
• Store an encrypted token, such as a JWT, in the client for authorized access to protected pages.
• Validate the token on each request to protected pages.
• Consider adding two-factor authentication for added security.
• Implement session management to log out users automatically after a certain time period or on demand.

CRUD refers to the four main operations performed on a database: Create, Read, Update, and Delete. In Express.js, you can handle these operations using routes and HTTP methods (GET, POST, PUT, DELETE). Here's a simple example to update a resource:

Implement locale detection: Determine the user's preferred language using browser settings or allowing users to select the language.

Use a library or framework: Use an existing library or framework, such as i18next, to handle language switching, pluralization, and other language-related tasks.

Translate resource files: Translate the external resource files into the target languages.

Integrate translated content: Load the appropriate resource file based on the user's preferred language and use the translated content in the application.

Handling database migrations when deploying a full-stack web application typically involves the following steps:

• Create a new database migration script that reflects the desired changes in the schema.
• Run the migration script on the target environment, usually the production database, to apply the changes.
• Verify that the migration was successful and that the application still functions as expected.
• Repeat the process for each new change to the database schema.

You can use the fetch function to make requests to an API and handle the response in a React component, usually in a lifecycle method like componentDidMount or inside a useEffect hook for functional components:

Route guards are used in Angular to conditionally allow or deny access to specific routes based on certain criteria, such as user authentication. To implement a route guard, you create a service that implements the CanActivate interface and then register it in your routing module:

User input validation can be handled in a full-stack web application by implementing the following steps:

Client-side validation: Use HTML form validation and JavaScript to validate user input on the client side before it is submitted to the server.

Server-side validation: Use server-side scripting languages like PHP, Ruby, or Python to validate user input on the server after it is submitted.

Sanitize user input: Ensure that user input is sanitized on the server to prevent malicious attacks such as SQL injection or cross-site scripting (XSS).

Return error messages: If the user input is invalid, return appropriate error messages to the user to let them know what went wrong and how to correct it.

A closure in JavaScript is a function that retains access to its outer (enclosing) scope's variables, even after the outer function has completed execution. Closures are useful for data privacy, creating function factories, and implementing decorators.

Real-time notifications can be implemented in a full-stack web application using the following steps:

Choose a real-time communication protocol: WebSockets or Server-Sent Events (SSE) are commonly used for real-time communication between client and server.

Implement server-side handling of real-time events: The server should be able to listen and broadcast events to connected clients.

Establish a WebSocket connection or SSE channel: On the client side, a connection to the server should be established using WebSockets or SSE.

Send and receive events: Both the client and server should be able to send and receive events, allowing for real-time communication between them.

Trigger notifications: On receiving events, the client-side code can trigger notifications in pop-ups, desktop notifications, or any other desired form.

Store notification history: Optionally, the application may store a history of notifications for later retrieval by the user.

Higher-Order Components (HOC) in React are functions that accept a component as an argument and return a new component with additional props or behavior. HOCs can be used for code reuse, logic or state abstraction, and modifying the behavior of components.

Implementing search functionality in a full-stack application involves the following steps:

• Define search criteria and data structure in the database to support efficient search operations.
• Create a search interface in the front end, such as a text box and search button, to allow users to input their search queries.
• Send the search query from the front to the back end using an HTTP request.
• Use the query to search the database and retrieve relevant results.
• Format and return the results to the front end.
• Display the results in the front end using a suitable format, such as a list or grid.
• Optimize search performance by implementing pagination, caching, and indexing techniques.

To use async/await with error handling, wrap the route logic inside a try-catch block to catch any rejected Promises, and then send an error status or message in the response.

const express = require("express");

const app = express();

app.get("/

Use structured error handling such as try-catch blocks, create custom error classes, return API errors with descriptive messages and proper status codes, log errors for monitoring and debugging, handle unresolved promises in JavaScript, and create error boundary components for frontend stability.

To implement user roles and permissions in a web application:

• Define the different roles and their corresponding permissions.
• Store the role and permission information in a database or configuration file.
• Use authentication to identify the user and retrieve their role.
• Check the user's role and permissions for each protected resource or action.
• Grant or deny access based on the user's role and permissions.
• Regularly review and update the roles and permissions.

To implement custom data visualization in a full-stack web application, you can follow these steps:

Choose a front-end library: Popular choices include D3.js, Chart.js, Highcharts, and others.

Retrieve the data: Fetch data from the backend API and store it in the front end.

Transform the data: Preprocess the data to fit the format required by the visualization library.

Create the visualization: Use the chosen library to render the visualization using the transformed data.

Integrate with the web application: Embed the visualization within the HTML page and hook it up with the rest of the application through user interactions.

Style the visualization: Apply styles and make the visualization look good on the page.

To optimize the performance of a full-stack application, you can consider the following strategies:

• Use caching techniques to store frequently used data.
• Minimize the number of database queries and optimize them.
• Compress and minimize assets such as CSS, JavaScript, and images.
• Use a content delivery network (CDN) to serve static assets.
• Implement lazy loading for images and videos.
• Use efficient algorithms for server-side processing.
• Minimize the number of HTTP requests
• Keep the code optimized and up-to-date with the latest libraries and technologies.

To deploy a full-stack web application on a live server, you can follow these steps:

• Choose a hosting service provider (e.g., AWS, Google Cloud, Heroku, etc.)
• Set up a server instance with a suitable operating system.
• Configure necessary dependencies and software, such as a web server (e.g. Apache, Nginx), a database (e.g. MySQL, MongoDB), and runtime environment.
• Transfer the application code to the server using FTP, Git, or other file transfer methods
• Configure the application's environment variables on server
• Set up domain name resolution and SSL certificate, if needed
• Start the application and configure it to start automatically on server reboot

A message queue in web development acts as a buffer that temporarily stores messages between systems in a decoupled architecture. The purpose is to facilitate communication, improve scalability, and ensure that the system remains stable and responsive even when the volume of messages increases.

Applications can send messages to a queue and process them asynchronously, which helps to avoid blocking the main application flow and ensures that messages are processed even if one of the systems is temporarily unavailable.

Common use cases for message queues in web development include background job processing, integration with third-party services, and real-time event-driven systems.

REST API plays the role of an intermediary between the front-end and back-end components of a web application. The front end makes requests to the API, which then communicates with the back-end database to retrieve or modify data and return a response to the front end.

REST APIs enable the decoupling of the client and server components, allowing for easier maintenance and scalability.

To ensure the security of user data, you can:

• Implement encryption for sensitive data (e.g., SSL/TLS).
• Use secure password storage methods (e.g. bcrypt, scrypt).
• Use secure sessions (e.g., cookies with secure flag and HTTP-Only flag set).
• Validate user input to prevent SQL injection, XSS, and other types of attacks.
• Implement proper access controls (e.g., using OAuth).
• Keep software up-to-date with the latest security patches.
• Perform regular security assessments (e.g., penetration testing).

The common approach is to use WebSockets to implement real-time updates in a web application. Here's an overview of the steps involved:

Server setup: Set up a WebSockets server that listens for incoming connections and broadcasts updates to all connected clients.

Client setup: On the client side, open a WebSockets connection to the server and listen for updates.

Server broadcast: Whenever a change occurs on the server side that you want to broadcast to clients, send the updated data over the WebSockets connection.

Client updates: On the client side, handle incoming updates and update the user interface accordingly.

To execute testing and debugging for a full-stack web application, you can follow these steps:

Unit testing: Test individual components of the application, like functions, classes, etc., using a testing framework such as Jest, Mocha, or Unit.js

Integration testing: Test how different components work together.

End-to-end testing: Test the application as a whole, simulating real-world user interaction.

Debugging: Use browser developer tools, log statements, and breakpoints to find and fix bugs in the application.

Monitoring: Use tools like Sentry, and New Relic, to monitor and log errors in production.

Performance testing: Test and optimize the application's performance under heavy loads.

Security testing: Test the application for vulnerabilities and ensure it is secure.

To build a scalable web application, consider the following best practices:

• Use a microservices architecture to break down the application into smaller, independent services.
• Use a load balancer to distribute incoming traffic across multiple application instances.
• Implement caching to reduce the load on the database and improve performance.
• Use a database sharding technique to partition the data across multiple database instances horizontally.
• Use a message queue for asynchronous processing of long-running tasks.
• Automate deployment and scaling using tools like Docker and Kubernetes.
• Monitor the performance and health of the application and implement automatic scaling based on demand.
• Design for failure by implementing redundancy and failover mechanisms.

One of the effective techniques that you can use to minimize the impact of bot scraping of a public API is throttling. Through this, you can limit a specific device to a defined volume of requests within a certain time frame. If the number of requests exceeds the specified threshold. “Too Many Attempts” HTTP error can be displayed.

Beyond that, you can also utilize the user agent strings for blocking requests and generate temporary access tokens for a specific session.

redux-thunk is a middleware for Redux that enables handling of asynchronous actions in a Redux store. It allows action creators to return a function instead of an action object, which then has access to dispatch and getState.

The link tag is used to include and reference external resources, such as stylesheets. The script tag is used to include and execute JavaScript code in the HTML document. The main difference between the two tags is the type of content they handle: link is for linking resources, and script is for executing code or including code files.

AMD (Asynchronous Module Definition) and CommonJS are two different JavaScript module systems. Differences between the two:

• AMD is used mainly for browser-based JavaScript, while CommonJS is used in server-side (Node.js) JavaScript.
• AMD modules are loaded asynchronously and in parallel, while CommonJS modules are loaded synchronously and in a single-threaded manner.
• CommonJS uses require() and module.exports to define and import modules, while AMD uses define() and require() functions.

Prototype inheritance in JavaScript is the process of creating a link between the parent object prototypes and the child object to share and utilize the characteristics of the parent class.

By setting an object's prototype to another object, you can create a prototype chain that enables the object to inherit properties and methods from its parent object. This feature of JavaScript allows for easy and efficient code reuse, and it's used extensively in the language's built-in object types and object-oriented programming patterns.

Arrow functions should not be used under the following conditions:

• When you need to bind the "this" keyword to a specific object since arrow functions inherit the "this" from the surrounding scope.
• When you need to add a prototype method to an object since arrow functions do not have a prototype property.
• When you need to pass a method as a callback and preserve the context since arrow functions do not have a "arguments" object.
• When you need to use the "new" operator to create an object, arrow functions cannot be used as constructors.

Promises in JavaScript are objects that represent the eventual completion of an asynchronous operation and its resulting value. Advantages of using Promises over a callback-based approach include:

• More readable code due to the chaining of .then() and .catch() functions, which reduces callback nesting ("Callback Hell").
• Error handling is more straightforward, using a single .catch() function.
• The ability to return values from asynchronous functions more intuitively.