这是一个Durstenfeld shuffle的JavaScript实现，这是Fisher Yates的优化版本：

/* Randomize array in-place using Durstenfeld shuffle algorithm */
function shuffleArray(array) {
    for (var i = array.length - 1; i > 0; i--) {
        var j = Math.floor(Math.random() * (i + 1));
        var temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}

它为每个原始数组元素选择一个随机元素，并将其排除在下一次抽奖中，就像从一副牌中随机选择一样。

这种巧妙的排除将拾取的元素与当前元素交换，然后从剩余元素中拾取下一个随机元素，向后循环以获得最佳效率，确保简化随机拾取（始终可以从0开始），从而跳过最终元素。

算法运行时间为O（n）。请注意，洗牌是在适当的位置完成的，因此如果您不想修改原始数组，请首先使用.sslice（0）复制它。

编辑：更新至ES6/ECMAScript 2015

新的ES6允许我们一次分配两个变量。当我们想要交换两个变量的值时，这特别方便，因为我们可以在一行代码中完成。下面是使用此功能的同一函数的简短形式。

function shuffleArray(array) {
    for (let i = array.length - 1; i > 0; i--) {
        const j = Math.floor(Math.random() * (i + 1));
        [array[i], array[j]] = [array[j], array[i]];
    }
}

2019年，我们仍在调整阵列，所以我的方法是：

常量src=[…'abcdefg']；常量shuffle=arr=>[…arr].还原右（（res，_，__，s）=>（res.push（s.splice（0|Math.random（）*s.length，1）[0]），res），[]）；console.log（shuffle（src））；.作为控制台包装｛最小高度：100%｝

使用Fisher Yates shuffle算法和ES6：

// Original array
let array = ['a', 'b', 'c', 'd'];

// Create a copy of the original array to be randomized
let shuffle = [...array];

// Defining function returning random value from i to N
const getRandomValue = (i, N) => Math.floor(Math.random() * (N - i) + i);

// Shuffle a pair of two elements at random position j
shuffle.forEach( (elem, i, arr, j = getRandomValue(i, arr.length)) => [arr[i], arr[j]] = [arr[j], arr[i]] );

console.log(shuffle);
// ['d', 'a', 'b', 'c']

警告不建议将此答案用于随机化大型阵列、密码学或任何其他需要真正随机性的应用程序，因为其存在偏差且效率低下。元素的位置只是半随机的，它们将倾向于保持更接近其原始位置。看见https://stackoverflow.com/a/18650169/28234.

可以使用Math.random任意决定是否返回1:-1：

[1, 2, 3, 4].sort(() => (Math.random() > 0.5) ? 1 : -1)

尝试运行以下示例：

常量数组=[1，2，3，4]；//基于Math.Random返回的值，//任意决定是否返回1:-1const shuffeled=array.sort（（）=>{const randomTrueOrFalse=数学random（）>0.5；return randomTrueOrFalse？1 : -1});console.log（shuffeled）；

我找不到我喜欢的。这是我想出的解决方案。我没有使用太多无意义的变量，因为这是我现在的编码方式。

Array.prototype.shuffle = function() {
    for (let i in this) {
        if (this.hasOwnProperty(i)) {
            let index = Math.floor(Math.random() * i);
            [
                this[i],
                this[index]
            ] = [
                this[index],
                this[i]
            ];
        }
    }

    return this;
}

让arrayA=[“item1”、“item2”、“item3”、“Item 4”、“Items5”];Array.prototype.shuffle=函数（）{为了（让我进来）{如果（this.hasOwnProperty（i））{让index=Math.floor（Math.random（）*i）；[这个[i]，此[索引]] = [该[索引]，本[i]];}}返回此；}console.log（arrayA.shuffle（））；

我希望这能帮助那些可能不太理解这一点的人。

为了完整起见，除了Fischer Yates的Durstenfeld变体外，我还要指出Sattolo的算法，它只需要一个微小的变化，就会导致每个元素都发生变化。

function sattoloCycle(arr) {
   for (let i = arr.length - 1; 0 < i; i--) {
      const j = Math.floor(Math.random() * i);
      [arr[i], arr[j]] = [arr[j], arr[i]];
   }
   return arr
}

不同之处在于如何计算随机索引j，Math.random（）*i与Math.random*（i+1）。