How does Array.prototype.toReversed() avoid the classic bug of accidentally mutating a shared array reference?

Q: How does Array.prototype.toReversed() avoid the classic bug of accidentally mutating a shared array reference?

**Target Audience:** Engineers preparing for JavaScript array-methods interview questions. **Difficulty:** Easy > **How to read this doc:** Concepts are explained in plain language first, then tagged with 📌 Interview term: . Every result below was actually run on Node.js v24.19.0 — captured output, not illustrative sample text. ## 1. Why This Even Matters — A Story First Imagine two people each holding what they believe is their own copy of the same shopping list, but it is actually the exact same physical piece of paper, just held from two different corners. If one person crosses out an item, the other person's "copy" changes too -- because there was never a second copy, only a second reference to the same paper. Arrays behave the same way: assigning an array to a second variable does not clone it, it just hands out a second reference to the same underlying data. `reverse()` writes directly on that one shared piece of paper; `toReversed()` instead photocopies it first

Tricky JavaScript Scenario #14: Array.prototype.toReversed

The problem

Question presented to candidate: "Two variables point at the same array -- a classic aliasing setup. If I call .reverse() on one of them, what happens to the other? How does .toReversed() avoid that problem entirely?"

What a strong answer should cover:

Array.prototype.reverse() reverses the array in place and returns the SAME array reference it was called on -- so any other variable or object property that was aliased to that same array reference sees the reversal too, which is often an unintended side effect.
Array.prototype.toReversed(), added in ES2023, computes the reversed order into a brand-new array and leaves the original completely untouched -- the source array and its length, order, and identity are all unaffected.
The bug this solves is aliasing: two variables, or a variable and a value stored elsewhere like React state or a Redux store, can point at the exact same array object without that being obvious from the code -- mutating through one reference silently corrupts what the other reference sees.
toReversed() always allocates a new array, which is a real cost (O(n) memory and time) compared to reverse(), which is O(n) time but no extra allocation -- worth naming as the actual tradeoff, not a free lunch.
The naming convention -- a to-prefixed method paired with an in-place counterpart -- also applies to toSorted()/sort(), toSpliced()/splice(), and with()/index assignment, all from the same ES2023 proposal.

Clarifying questions expected:

"Is the concern here specifically about a shared reference, like two variables or a value that got passed into two places, or about immutability as a general programming style?"
"Does this need to run in an older environment where toReversed might not be available yet?"

Code / implementation expected: Yes -- a real, executed side-by-side comparison where a second variable is aliased to the same array, showing reverse() leaking the mutation through the alias while toReversed() leaves the alias untouched.

es2023
tricky
real-world

Try it yourself

Sketch your approach before you read the solution. That is what the interview tests.

Stuck? Get a hint.

A short nudge toward the approach. It will not give the answer away.

Solution

Target Audience: Engineers preparing for JavaScript array-methods interview questions. Difficulty: Easy

How to read this doc: Concepts are explained in plain language first, then tagged with 📌 Interview term:. Every result below was actually run on Node.js v24.19.0 — captured output, not illustrative sample text.

1. Why This Even Matters — A Story First

Imagine two people each holding what they believe is their own copy of the same shopping list, but it is actually the exact same physical piece of paper, just held from two different corners. If one person crosses out an item, the other person's "copy" changes too -- because there was never a second copy, only a second reference to the same paper. Arrays behave the same way: assigning an array to a second variable does not clone it, it just hands out a second reference to the same underlying data. reverse() writes d

The solution is hidden so you can try first

6 min read · 7 sections

Run the code

Edit the code and run it here. Each console line with an expected value becomes a test.

JavaScripttoReversed() leaves a shared alias untouched; reverse() mutates it in place (run directly)