JavaScript数组洗牌：为何随机数需偏移0.5至负范围？

Hey there! Great question—this is a super common point of confusion when people first try to hack together a shuffle with sort(). Let's break this down step by step.

First, here's the code you referenced:

function shuffleArray(arr) {
  arr.sort(() => {
    r = Math.random() - 0.5 // console.log(r)
    return r
  });
}
let arr = [1, 2, 3, 4, 5];
shuffleArray(arr);
console.log(JSON.stringify(arr))

First, let's recap how Array.sort() works #

The sort() method uses your callback's return value to decide the order of two elements (let's call them a and b):

• Return a negative number: a stays before b
• Return a positive number: b moves before a
• Return 0: their relative order stays unchanged

Why subtract 0.5? Let's test what happens without it #

If you just return Math.random() directly, that value is always between 0 (inclusive) and 1 (exclusive)—so it's never negative. That creates a huge problem:

• You'll never get a return value that tells sort() to move a in front of b; you can only move b in front of a, or leave them as-is.
• Over many runs, this leads to a severely uneven shuffle. For example, the first element in your original array will almost never move to the end—every comparison with a later element pushes that later element forward, but never the other way around.

By subtracting 0.5, you generate a random number between -0.5 and 0.5. Now:

• 50% of the time, you return a negative number (so a stays before b)
• 50% of the time, you return a positive number (so b moves before a)
  This lets elements swap positions in both directions, which is required for even a halfway-decent shuffle.

Why 0.5 specifically? #

0.5 is the perfect offset because it balances the probability of returning a positive vs. negative number. If you used a different offset (like Math.random() - 0.3), you'd have a 70% chance of returning a positive number—meaning elements would be far more likely to shift to the front than the back, leading to another lopsided shuffle. 0.5 keeps the odds evenly split.

A critical caveat: This sort() trick isn't a good shuffle #

Even with the 0.5 offset, using sort() for shuffling is flawed. Most JavaScript engines (like V8 in Chrome/Node) use a mix of insertion sort and quicksort under the hood. The random callback breaks the algorithm's assumptions, leading to some elements staying in their original positions far more often than others.

For a truly uniform shuffle, use the Fisher-Yates (Knuth) Shuffle—it's efficient, simple, and guaranteed to produce evenly distributed results:

function shuffleArray(arr) {
  // Start from the end and work backwards
  for (let i = arr.length - 1; i > 0; i--) {
    // Pick a random index from 0 to i
    const j = Math.floor(Math.random() * (i + 1));
    // Swap elements at i and j
    [arr[i], arr[j]] = [arr[j], arr[i]];
  }
}

内容的提问来源于stack exchange，提问作者Vahe