所有其他答案都基于Math.random（），它很快，但不适用于密码级别的随机化。

下面的代码使用了众所周知的Fisher Yates算法，同时利用Web Cryptography API实现了随机化的加密级别。

变量d=[1,2,3,4,5,6,7,8,9,10]；函数洗牌（a）{var x，t，r=新Uint32Array（1）；对于（var i=0，c=a.length-1，m=a.length；i<c；i++，m-）{crypto.getRandomValues（r）；x=数学楼层（r/65536/65536*m）+i；t=a[i]，a[i]=a[x]，a[x]=t；}返回a；}console.log（shuffle（d））；

使用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();

我想分享解决这个问题的百万种方法之一=）

function shuffleArray(array = ["banana", "ovo", "salsicha", "goiaba", "chocolate"]) {
const newArray = [];
let number = Math.floor(Math.random() * array.length);
let count = 1;
newArray.push(array[number]);

while (count < array.length) {
    const newNumber = Math.floor(Math.random() * array.length);
    if (!newArray.includes(array[newNumber])) {
        count++;
        number = newNumber;
        newArray.push(array[number]);
    }
}

return newArray;

}

只是为了在馅饼里插一根手指。在这里，我介绍了Fisher Yates shuffle的递归实现（我认为）。它给出了统一的随机性。

注意：~~（双颚化符运算符）实际上与正实数的Math.floor（）类似。这只是一条捷径。

var shuffle=a=>a.length？a.splice（~~（Math.random（）*a.length），1）.contat（shuffle（a））：a；console.log（JSON.stringify（shuffle（[0,1,2,3,4,5,6,7,8,9]））；

编辑：由于使用了.splice（），上面的代码是O（n^2），但我们可以通过交换技巧消除O（n）中的拼接和混洗。

var shuffle=（a，l=a.length，r=~~（Math.random（）*l））=>l？（[a[r]，a[l-1]]=[a[l-1]，a[r]]，shuffle（a，l-1））：a；var arr=Array.from（{length:3000}，（_，i）=>i）；console.time（“shuffle”）；洗牌（arr）；console.timeEnd（“shuffle”）；

问题是，JS无法与大型递归合作。在这种特殊的情况下，数组大小会受到限制，大约为3000~7000，这取决于浏览器引擎和一些未知的事实。

首先，在这里查看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）时间内运行，此更改使代码不太适合较大的数组。

NEW!

更短，可能更快的Fisher Yates洗牌算法

它使用while---按位到底数（最多10个十进制数字（32位））移除了不必要的封盖和其他东西

function fy(a,b,c,d){//array,placeholder,placeholder,placeholder
 c=a.length;while(c)b=Math.random()*(--c+1)|0,d=a[c],a[c]=a[b],a[b]=d
}

脚本大小（以fy作为函数名）：90字节

演示http://jsfiddle.net/vvpoma8w/

*可能在除chrome之外的所有浏览器上都更快。

如果您有任何问题，请提问。

EDIT

是的，它更快

性能：http://jsperf.com/fyshuffle

使用排名靠前的函数。

编辑计算过多（不需要--c+1），没有人注意到

更短（4字节）和更快（测试！）。

function fy(a,b,c,d){//array,placeholder,placeholder,placeholder
 c=a.length;while(c)b=Math.random()*c--|0,d=a[c],a[c]=a[b],a[b]=d
}

在其他地方缓存var rnd=Math.random，然后使用rnd（）也会稍微提高大数组的性能。

http://jsfiddle.net/vvpoma8w/2/

可读版本（使用原始版本。这会更慢，vars是无用的，像closures&“；”，代码本身也更短……也许读一下如何“缩小”Javascript代码，顺便说一句，你不能像上面那样用Javascript缩小器压缩以下代码。）

function fisherYates( array ){
 var count = array.length,
     randomnumber,
     temp;
 while( count ){
  randomnumber = Math.random() * count-- | 0;
  temp = array[count];
  array[count] = array[randomnumber];
  array[randomnumber] = temp
 }
}