Separate a new outer object from shared nested values.
Review map, filter, reduce, shallow spread copies, Set size and own versus inherited properties.
This count records matching keys on six supplied Node 24 ES module tasks. It is not a developer level, percentile, employer cutoff or qualification. Every answer and all four complete guides are available at every count.
Six explicit data transformations
The array items use short numeric lists with callbacks that are fully shown. They ask whether map leaves the supplied source unchanged, which values filter selects and how an explicit reduce accumulator contributes. The object items distinguish a new outer object from its shared nested value, repeated equal strings from distinct set entries, and a property found through a prototype from a property owned directly. The answers depend on these stated operations, not a general guess about what copying ought to mean.
Trace a shallow copy with a nested list
In a new unscored example, source contains items:["m"]. Make copy with {...source}, then call copy.items.push("n"). The two outer objects are different, but their items properties reach the same array. The source list now contains m and n. Printing source.items.join(":") and the outer identity comparison with another colon gives m:n:false. Draw the shared nested array once, rather than drawing an independent array merely because another outer object exists.
Read the callback before declaring an operation safe
In this bank’s map item, the callback returns n+1 and does not mutate the source. That supports the stated unchanged-source answer. It is not a promise that every map callback is free of side effects. The filter item uses n>0, which excludes zero, and preserves the selected values’ original order. The reduce item starts from the explicitly supplied one. Write the actual callback and initial value beside your predicted result instead of relying on a remembered method name alone.
Keep lookup and ownership distinct
Object.create(parent) makes an object whose prototype is the supplied parent. A property read can find a value there while Object.hasOwn reports that the child does not own it. That is consistent, not an error in one of the operations. Likewise, a Set’s size counts retained entries rather than how many input positions you supplied. These small examples use ordinary objects and strings; they do not cover every proxy, accessor, custom equality assumption or deliberately unusual object design.
Describe both the result and the surviving source
Create a disposable .mjs file with invented values. Before running an array transformation, predict the returned array and separately predict the source. For an object copy, predict the outer identity and one nested mutation. Change one variable at a time, such as the filter boundary or the location of a nested value. Check the output after writing the prediction. Use synthetic data, so the exercise cannot expose customer details or alter useful application state.
Identify which object or position was confused
A missed item may come from treating a shallow copy as deep, forgetting an accumulator’s initial value or assuming an inherited property must be owned. Use the complete explanation to locate that exact distinction. A six-question total cannot say whether you can model a large dataset or prevent unintended mutation throughout an application. Even a perfect count should lead to a fresh example with new values if you want to explore whether the reasoning transfers.
The full review is available without a rank
All answer explanations and all four complete guides stay available after a valid full attempt, regardless of count. The original snippets were run in the declared Node 24.19.0 ES module environment; this is not a broad browser compatibility study or an assessment of working with a real database. No employer cutoff, developer tier or certification is assigned. Repeated exposure and checking aids can affect the count, so record those conditions when using the bank for your own revision.