MEAN Trivia 4

Question 1

In a MEAN stack application, you need to perform a MongoDB aggregation that groups documents by a field, calculates an average, and then filters groups where the average exceeds a threshold. Which pipeline stage order is correct?

Accepted Answer

$match → $group → $match

Answer

The correct pattern is $match → $group → $match. The first $match filters raw documents early (improving performance), $group aggregates them, and a second $match filters the grouped results by the computed average. $filter is an array operator, not a pipeline stage, ruling out option C. Option D's order works but skips the early filter optimization the question implies.

Question 2

An Express.js middleware function calls `next('route')` instead of `next()`. What is the precise effect of this?

Accepted Answer

It skips all remaining middleware in the current router and passes control to the next matching route handler

Answer

Calling `next('route')` skips all remaining handlers/middleware defined within the current route's callback array and passes control to the next route that matches the request. This is distinct from `next()` (advance to the next middleware) and `next(err)` (jump to error handlers). It only works inside route handlers defined with `router.METHOD()` or `app.METHOD()`.

Question 3

In Angular, you declare a service with `providedIn: 'root'` but also list it in a lazy-loaded module's `providers` array. What is the runtime outcome?

Accepted Answer

The lazy-loaded module gets its own separate instance of the service, while the rest of the app uses the root instance

Answer

When a service is listed in a lazy-loaded module's `providers` array, the module's injector creates a new, separate instance scoped to that module — even if `providedIn: 'root'` is set. Components inside the lazy module get this local instance; components outside continue using the singleton root instance. This is a common source of subtle state-sharing bugs.

Question 4

A Node.js HTTP server under heavy load is exhibiting high latency despite low CPU usage. Heap snapshots show no memory leak. The event loop lag metric (measured via `perf_hooks`) spikes to ~800ms. Which of the following is the MOST likely root cause?

Accepted Answer

Synchronous I/O or a CPU-bound operation blocking the event loop between iterations

Answer

High event loop lag with low CPU and no memory leak strongly points to synchronous blocking code (e.g., `fs.readFileSync`, a large JSON.parse, or a tight computation loop) that prevents the event loop from processing I/O callbacks. `process.nextTick()` starvation (option B) would appear as microtask queue flooding. Keep-alive issues (option C) affect connection pooling, not loop lag. GC pressure (option D) would surface in heap metrics and higher CPU.

Question 5

In MongoDB, you have a compound index on `{ status: 1, createdAt: -1 }`. Which query will NOT benefit from this index for sorting?

Accepted Answer

db.col.find({ createdAt: { $gt: ISODate('2025-01-01') } }).sort({ status: 1 })

Answer

Option A queries on `createdAt` without constraining `status`, so the query cannot use the index prefix (`status`) for the equality match and then leverage the ordered `createdAt` for the sort — MongoDB would need a full collection scan or a separate sort. Options B and C use the index prefix for equality, allowing the index to cover the sort (even reversed, as long as the direction is consistent). Option D uses `$in` on the prefix, which MongoDB can still use for index-assisted sorting across the enumerated values.

MEAN - Stack Development Practice Test

MEAN - Stack Development Practice Test

MEAN Trivia 4