我发现这很有用：

const shuffle = (array: any[]) => {
    return array.slice().sort(() => Math.random() - 0.5);
  }
        
console.log(shuffle([1,2,3,4,5,6,7,8,9,10]));
// Output: [4, 3, 8, 10, 1, 7, 9, 2, 6, 5]

基准

让我们先看看结果，然后看看下面的每个shuffle实现-

拼接速度慢

在循环中使用拼接或移位的任何解决方案都将非常缓慢。当我们增加阵列的大小时，这一点尤其明显。在天真的算法中，我们-

获取输入数组t中的rand位置i将t[i]添加到输出来自阵列t的拼接位置i

为了夸大缓慢的效果，我们将在一百万个元素的数组上演示这一点。以下脚本大约30秒-

常量洗牌=t=>数组起始（样本（t，t.length））函数*样本（t，n）｛let r=数组.from（t）而（n>0&&r.length）{const i=rand（r.length）//1产量r[i]//2r.拼接（i，1）//3n=n-1}}常量rand=n=>0|数学随机（）*n函数交换（t，i，j）{设q=t[i]t[i]=t[j]t[j]=q返回t}常量大小=1e6const bigarray=Array.from（数组（大小），（_，i）=>i）console.time（“通过拼接洗牌”）常量结果=无序排列（大数组）console.timeEnd（“通过拼接洗牌”）document.body.textContent=JSON.stringify（结果，null，2）正文：：之前{内容：“通过拼接100万个元素”；字号：粗体；显示：块；}

流行音乐很快

诀窍不是拼接，而是使用超高效的pop。为此，代替典型的拼接调用-

选择要拼接的位置，i用最后一个元素t[t.length-1]替换t[i]将t.pop（）添加到结果中

现在，我们可以在不到100毫秒的时间内清理一百万个元素-

常量洗牌=t=>数组起始（样本（t，t.length））函数*样本（t，n）｛let r=数组.from（t）而（n>0&&r.length）{const i=rand（r.length）//1交换（r，i，r.length-1）//2产量r.pop（）//3n=n-1}}常量rand=n=>0|数学随机（）*n函数交换（t，i，j）{设q=t[i]t[i]=t[j]t[j]=q返回t}常量大小=1e6const bigarray=Array.from（数组（大小），（_，i）=>i）console.time（“通过pop洗牌”）常量结果=无序排列（大数组）console.timeEnd（“通过pop进行洗牌”）document.body.textContent=JSON.stringify（结果，null，2）正文：：之前{内容：“100万元素通过流行音乐”；字号：粗体；显示：块；}

甚至更快

上面的两个shuffle实现产生了一个新的输出数组。未修改输入数组。这是我的首选工作方式，但你可以通过原地洗牌来提高速度。

在不到10毫秒内洗牌一百万个元素-

函数洗牌（t）{让last=t.length设nwhile（last>0）｛n=兰特（最后一个）交换（t，n，--last）}}常量rand=n=>0|数学随机（）*n函数交换（t，i，j）{设q=t[i]t[i]=t[j]t[j]=q返回t}常量大小=1e6const bigarray=Array.from（数组（大小），（_，i）=>i）console.time（“shuffle in place”）洗牌（大数组）console.timeEnd（“shuffle in place”）document.body.textContent=JSON.stringify（bigarray，null，2）正文：：之前{内容：“100万元素到位”；字号：粗体；显示：块；}

Array.prototype.shuffle=function(){
   var len = this.length,temp,i
   while(len){
    i=Math.random()*len-- |0;
    temp=this[len],this[len]=this[i],this[i]=temp;
   }
   return this;
}

随机化数组

 var arr = ['apple','cat','Adam','123','Zorro','petunia']; 
 var n = arr.length; var tempArr = [];

 for ( var i = 0; i < n-1; i++ ) {

    // The following line removes one random element from arr 
     // and pushes it onto tempArr 
     tempArr.push(arr.splice(Math.floor(Math.random()*arr.length),1)[0]);
 }

 // Push the remaining item onto tempArr 
 tempArr.push(arr[0]); 
 arr=tempArr; 

这是一个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]];
    }
}

使用underscore.js库。对于这种情况，方法_.shuffle（）很好。以下是该方法的示例：

var _ = require("underscore");

var arr = [1,2,3,4,5,6];
// Testing _.shuffle
var testShuffle = function () {
  var indexOne = 0;
    var stObj = {
      '0': 0,
      '1': 1,
      '2': 2,
      '3': 3,
      '4': 4,
      '5': 5
    };
    for (var i = 0; i < 1000; i++) {
      arr = _.shuffle(arr);
      indexOne = _.indexOf(arr, 1);
      stObj[indexOne] ++;
    }
    console.log(stObj);
};
testShuffle();