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

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（））；

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

Fisher Yates的另一个实现，使用严格模式：

function shuffleArray(a) {
    "use strict";
    var i, t, j;
    for (i = a.length - 1; i > 0; i -= 1) {
        t = a[i];
        j = Math.floor(Math.random() * (i + 1));
        a[i] = a[j];
        a[j] = t;
    }
    return a;
}

对于我们这些不是很有天赋但能接触到洛达什奇迹的人来说，有一种叫做洛达什·舒夫的东西。

事实上的无偏洗牌算法是Fisher Yates（又名Knuth）shuffle。

你可以在这里看到一个很棒的可视化效果（以及链接到此的原始帖子）

函数洗牌（数组）{let currentIndex=array.length，randomIndex；//而还有一些元素需要洗牌。while（currentIndex！=0）{//拾取剩余的元素。randomIndex=数学地板（Math.random（）*当前索引）；当前索引--；//并将其与当前元素交换。[array[currentIndex]，array[randomIndex]]=[array[randomIndex]，array[currentIndex]]；}返回数组；}//如此使用var arr=[2，11，37，42]；洗牌（arr）；控制台日志（arr）；

有关所用算法的更多信息。

可以（但不应该）将其用作Array中的原型：

来自ChristopheD：

Array.prototype.shuffle = function() {
  var i = this.length, j, temp;
  if ( i == 0 ) return this;
  while ( --i ) {
     j = Math.floor( Math.random() * ( i + 1 ) );
     temp = this[i];
     this[i] = this[j];
     this[j] = temp;
  }
  return this;
}

//doesn change array
Array.prototype.shuffle = function () {
    let res = [];
    let copy = [...this];

    while (copy.length > 0) {
        let index = Math.floor(Math.random() * copy.length);
        res.push(copy[index]);
        copy.splice(index, 1);
    }

    return res;
};

let a=[1, 2, 3, 4, 5, 6, 7, 8, 9];
console.log(a.shuffle());