NestJs Questions

happy code

Score: 🔥 117

Beginner

Took 3 minutes

Programming Framework

NestJs

100%

Questions Attempted

10 / 10

Correct Answers

Incorrect Answers

Points Earned

🔥 10

Question 1

Which decorator is used to define a custom exception filter in NestJS?

@Injectable()
@Catch()
@Controller()
@Module()

Explanation:

The @Catch() decorator is specifically designed to mark a class as an exception filter, allowing it to handle specific exception types.

Question 2

Which decorator is used to apply middleware to a specific route in NestJS?

@UseMiddleware()
@Middleware()
@Route()
@ApplyMiddleware()

Explanation:

The @UseMiddleware() decorator is used to bind middleware to specific routes or controllers. You can apply it at the method level for individual routes or at the controller level to affect all routes within that controller.

Question 3

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 4

What is the purpose of the imports array in a NestJS module definition?

To import external JavaScript libraries.
To define the routes handled by the module.
To include providers that are specific to the module.
To import other modules, making their exported components available within the current module.

Explanation:

The imports array is used to establish dependencies between modules in NestJS. When you import a module, its exported components become available for use within the importing module.

Question 5

What is the purpose of dependency injection in NestJS?

To handle errors gracefully.
To manage database connections.
To provide a mechanism for creating and injecting dependencies into classes.
To define the application's routing logic.

Explanation:

Dependency injection is a design pattern where dependencies are 'injected' into a class rather than being directly instantiated within the class. This promotes modularity, testability, and reusability.

Question 6

What is the primary programming language used for developing NestJS applications?

JavaScript
Python
Java
C#

Explanation:

NestJS is built on top of Node.js, which uses JavaScript as its primary programming language. While TypeScript is often preferred, you can write NestJS applications directly in JavaScript.

Question 7

Which decorator allows you to access route parameters in NestJS?

@Body()
@Query()
@Param()
@Req()

Explanation:

The @Param() decorator is used to inject route parameters into controller methods. It allows you to access values from the URL path defined in your route.

Question 8

What is the purpose of the 'getStatus()' method in a custom exception filter?

To retrieve the HTTP status code associated with the exception.
To set the response headers for the error response.
To log the exception details to the console.
To determine the type of exception that was thrown.

Explanation:

The getStatus() method allows the filter to access the appropriate HTTP status code from the caught exception, enabling it to set the correct status code for the error response.

Question 9

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 10

When using an Interceptor to modify the response, what is the best way to ensure type safety?

Type casting within the Interceptor.
Using generics with the NestInterceptor interface.
Disabling type checks within the Interceptor.
Type checking is not necessary within Interceptors.

Explanation:

For type safety, define generics with the NestInterceptor interface, specifying the expected request and response types, allowing TypeScript to perform type checking.