The Fisher-Yates shuffle walks the array from the end and at each position picks a random index in [0, i], then swaps. The crucial detail is that the random range shrinks each step (i + 1), which is what gives every permutation an equal probability. Anything that picks from [0, length) for every iteration produces a biased distribution. The algorithm is O(n) time, O(1) extra space, and is the textbook correct shuffle. We verify by sorting a copy and confirming the original elements are preserved.

Mutating helpers are convenient inside hot loops but a sharp edge in functional code, React state, and immutable contexts. shuffled(array) does a single slice() to clone, then runs the same Fisher-Yates on the copy, so the caller's array is left alone. The cost is one extra O(n) allocation, which is almost always negligible. Use the non-mutating version by default in UI code (e.g. randomising a quiz order) and reserve the in-place form for tight loops where you control the lifetime of the array.

The single most common shuffle bug on the internet is array.sort(() => Math.random() - 0.5). It looks elegant, but Array.prototype.sort is allowed to call the comparator a non-uniform number of times per pair, and an inconsistent comparator (one that does not encode a real total order) yields a biased permutation. Running 30,000 trials shows the elements landing at index 0 with very different frequencies, far from the ~10000 each a uniform shuffle would produce. Stick to Fisher-Yates from the previous accordions, and reach for crypto.getRandomValues if the use case (security tokens, raffle picks) demands a cryptographically strong source. The takeaway is that sort is not a randomiser even when its comparator looks random.