NestJs Questions

happy code

Score: 🔥 117

Beginner

Took 11 minutes

Programming Framework

NestJs

70%

Questions Attempted

10 / 10

Correct Answers

Incorrect Answers

Points Earned

🔥 7

Question 1

What is a potential drawback of using singleton providers excessively in a large application?

Increased memory usage due to persistent instances.
Slower application startup time.
Difficulty in testing individual components.
All of the above.

Explanation:

While singletons offer benefits like shared state and reduced instantiation overhead, overusing them can lead to increased memory usage (as instances persist), slower startup (due to potential initialization chains), and challenges in isolating components during testing.

Question 2

Inside an Interceptor's intercept method, what object allows you to modify the response?

ctx.request
ctx.response
next.handle()
interceptor.transform()

Explanation:

While you don't directly modify the response object, next.handle() returns an Observable representing the response stream, allowing you to apply RxJS operators for transformation.

Question 3

What is the advantage of using built-in HTTP exception filters in NestJS?

They provide a streamlined way to handle common HTTP errors with predefined responses.
They allow you to bypass the need for exception handling altogether.
They are only applicable for database-related exceptions.
They are primarily used for handling authentication and authorization errors.

Explanation:

NestJS's built-in filters simplify error handling by providing ready-to-use responses for standard HTTP errors, reducing the need for repetitive code.

Question 4

What is the purpose of the @Body() decorator?

Accesses route parameters
Accesses query parameters
Accesses the entire request body
Accesses the request headers

Explanation:

The @Body() decorator is used to access the entire request body sent by the client. It allows you to retrieve data sent in formats like JSON or form data.

Question 5

How can you access the currently logged-in user within your middleware in NestJS?

By injecting the Request object into the middleware function.
By using the user property of the Response object.
By accessing the req.user object, assuming you have an authentication middleware set up.
By querying the database directly within the middleware.

Explanation:

If you're using an authentication middleware in NestJS, it typically attaches the authenticated user object to the request object. You can access this user information within your middleware by referring to req.user.

Question 6

What is the recommended way to access query parameters in a NestJS controller?

Using req.query
Using the @Query() decorator
Accessing params.query
Through the context.request object

Explanation:

The @Query() decorator provides a clean and type-safe way to access query parameters from the request object. It allows retrieving specific parameters or the entire query object.

Question 7

Can a Controller access a Service's methods in NestJS?

No, Controllers and Services are completely isolated.
Yes, by injecting the Service into the Controller's constructor.
Yes, by using static methods of the Service.
Only if the Controller and Service are defined in the same module.

Explanation:

In NestJS, a Controller can access a Service's methods by injecting an instance of the Service through the Controller's constructor. This is facilitated by NestJS's Dependency Injection mechanism.

Question 8

How can you create a custom provider in NestJS that provides a value instead of a class?

By using the @ValueProvider() decorator.
By using the @FactoryProvider() decorator.
By using the @ClassProvider() decorator.
By using the @Injectable() decorator.

Explanation:

The @ValueProvider() decorator allows you to create a custom provider that provides a simple value. This is useful for injecting configuration values or other constant data.

Question 9

How do you define middleware in NestJS?

By creating a class that implements the CanActivate interface.
By using the @Middleware() decorator on a class.
By creating a function with a specific signature.
By configuring middleware directly in the main.ts file.

Explanation:

Middleware in NestJS is defined as a function that takes three arguments: the request object, the response object, and a next function. This function signature is essential for NestJS to recognize and execute the middleware correctly.

Question 10

What is the purpose of the @Get() decorator in NestJS?

Handles POST requests
Handles PUT requests
Handles DELETE requests
Handles GET requests

Explanation:

The @Get() decorator is used to mark a controller method as a handler for incoming HTTP GET requests. It specifies that the method should be invoked when a GET request is made to the associated route.