使用排序方法和数学方法：

var arr =  ["HORSE", "TIGER", "DOG", "CAT"];
function shuffleArray(arr){
  return arr.sort( () => Math.floor(Math.random() * Math.floor(3)) - 1)  
}

// every time it gives random sequence
shuffleArr(arr);
// ["DOG", "CAT", "TIGER", "HORSE"]
// ["HORSE", "TIGER", "CAT", "DOG"]
// ["TIGER", "HORSE", "CAT", "DOG"]

我认为还没有人给出一个可以在不扩展Array原型的情况下连接起来的解决方案（这是一个糟糕的做法）。使用稍微鲜为人知的reduce（），我们可以轻松地以允许串联的方式进行混洗：

var randomsquares = [1, 2, 3, 4, 5, 6, 7].reduce(shuffle).map(n => n*n);

您可能希望传递第二个参数[]，否则如果尝试在空数组上执行此操作，则会失败：

// Both work. The second one wouldn't have worked as the one above
var randomsquares = [1, 2, 3, 4, 5, 6, 7].reduce(shuffle, []).map(n => n*n);
var randomsquares = [].reduce(shuffle, []).map(n => n*n);

让我们将shuffle定义为：

var shuffle = (rand, one, i, orig) => {
  if (i !== 1) return rand;  // Randomize it only once (arr.length > 1)

  // You could use here other random algorithm if you wanted
  for (let i = orig.length; i; i--) {
    let j = Math.floor(Math.random() * i);
    [orig[i - 1], orig[j]] = [orig[j], orig[i - 1]];
  }

  return orig;
}

您可以在JSFiddle或此处看到它的实际应用：

var shuffle=（all，one，i，orig）=>{如果（i！==1）返回全部；//你可以在这里使用其他随机算法for（设i=原始长度；i；i-）{设j=数学地板（Math.random（）*i）；[原始[i-1]，原始[j]]=[原始[j]，原始[i-1]]；}返回原点；}对于（变量i=0；i<5；i++）{var randomarray=[1，2，3，4，5，6，7]。reduce（shuffle，[]）；console.log（JSON.stringify（randomarray））；}

社区表示arr.sort（（a，b）=>0.5-Math.random（））不是100%随机的！对我测试并建议不要使用此方法！

let arr = [1, 2, 3, 4, 5, 6]
arr.sort((a, b) => 0.5 - Math.random());

但我不确定。所以我写了一些代码来测试！。。。你也可以试试！如果你足够感兴趣！

让data_base=[]；对于（设i=1；i<=100；i++）{//将100次新的rendom arr推送到data_base！数据基础推送([1，2，3，4，5，6]排序（（a，b）=>{return Math.random（）-0.5；//使用了社区禁止的方法！：-）}));}//console.log（data_base）；//如果你想看数据！让分析＝{}；for（设i=1；i<=6；i++）{analysis[i]=阵列（6）.填充（0）；}for（假设num=0；num<6；num++）{for（设i=1；i<=100；i++）{let plus=数据基[i-1][num]；分析[`${num+1}`][plus-1]++；}}console.log（分析）；//分析结果

在100个不同的随机阵列中。（我的分析结果）

{ player> 1   2   3  4   5   6
   '1': [ 36, 12, 17, 16, 9, 10 ],
   '2': [ 15, 36, 12, 18, 7, 12 ],
   '3': [ 11, 8, 22, 19, 17, 23 ],
   '4': [ 9, 14, 19, 18, 22, 18 ],
   '5': [ 12, 19, 15, 18, 23, 13 ],
   '6': [ 17, 11, 15, 11, 22, 24 ]
}  
// player 1 got > 1(36 times),2(15 times),...,6(17 times)
// ... 
// ...
// player 6 got > 1(10 times),2(12 times),...,6(24 times)

正如你所看到的，这不是那么随机！苏。。。不要使用此方法！如果你测试多次，你会看到玩家1获得了很多次（1号）！而球员6在大多数时候都获得了（第6名）！

首先，在这里查看javascript中不同排序方法的视觉比较。

其次，如果您快速查看上面的链接，您会发现与其他方法相比，随机顺序排序的性能似乎相对较好，同时实现起来非常简单和快速，如下所示：

function shuffle(array) {
  var random = array.map(Math.random);
  array.sort(function(a, b) {
    return random[array.indexOf(a)] - random[array.indexOf(b)];
  });
}

编辑：正如@gregers所指出的，比较函数是用值而不是索引来调用的，这就是为什么需要使用indexOf的原因。注意，由于indexOf在O（n）时间内运行，此更改使代码不太适合较大的数组。

我发现这个变体挂在“作者删除”的答案中，重复了这个问题。与其他一些已经获得许多支持的答案不同，这是：

实际上是随机的不到位（因此名称被打乱而不是打乱）此处尚未出现多个变体

这是一个jsfiddle，显示了它的使用情况。

Array.prototype.shuffled = function() {
  return this.map(function(n){ return [Math.random(), n] })
             .sort().map(function(n){ return n[1] });
}

从理论的角度来看，在我看来，最优雅的方法是得到一个介于0和n之间的随机数-并计算从{0，1，…，n！-1}到（0，1、2，…，n-1）的所有置换的一对一映射。只要你能使用一个足够可靠的（伪）随机发生器来获得这样一个数字而没有任何明显的偏差，你就有足够的信息来实现你想要的，而不需要其他几个随机数。

当使用IEEE754双精度浮点数计算时，您可以期望随机生成器提供大约15个小数。既然你有15岁=1307674368000（带13位数字），您可以对最多包含15个元素的数组使用以下函数，并假设最多包含14个元素的阵列不会有明显的偏差。如果您正在处理一个固定大小的问题，需要多次计算该洗牌操作，您可能需要尝试以下代码，因为它只使用Math.random一次（但它涉及多次复制操作），因此可能比其他代码更快。

下面的函数不会被使用，但我还是给出了它；它根据此消息中使用的一对一映射（枚举排列时最自然的映射）返回给定排列（0，1，2，…，n-1）的索引；它打算与多达16个元件一起工作：

function permIndex(p) {
    var fact = [1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800, 39916800, 479001600, 6227020800, 87178291200, 1307674368000];
    var tail = [];
    var i;
    if (p.length == 0) return 0;
    for(i=1;i<(p.length);i++) {
        if (p[i] > p[0]) tail.push(p[i]-1);
        else tail.push(p[i]);
    }
    return p[0] * fact[p.length-1] + permIndex(tail);
}

上一个函数的倒数（您自己的问题需要）如下：；它打算与多达16个元件一起工作；它返回（0，1，2，…，s-1）的n阶排列：

function permNth(n, s) {
    var fact = [1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800, 39916800, 479001600, 6227020800, 87178291200, 1307674368000];
    var i, j;
    var p = [];
    var q = [];
    for(i=0;i<s;i++) p.push(i);
    for(i=s-1; i>=0; i--) {
        j = Math.floor(n / fact[i]);
        n -= j*fact[i];
        q.push(p[j]);
        for(;j<i;j++) p[j]=p[j+1];
    }
    return q;
}

现在，你想要的只是：

function shuffle(p) {
    var fact = [1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800, 39916800, 479001600, 6227020800, 87178291200, 1307674368000, 20922789888000];
    return permNth(Math.floor(Math.random()*fact[p.length]), p.length).map(
            function(i) { return p[i]; });
}

它应该适用于多达16个元素，但有一点理论偏差（尽管从实际角度看不明显）；它可以被视为完全可用于15个元件；对于包含少于14个元素的数组，您可以放心地认为绝对没有偏差。