使用ES6功能的现代短内联解决方案：

['a','b','c','d'].map(x => [Math.random(), x]).sort(([a], [b]) => a - b).map(([_, x]) => x);

（出于教育目的）

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

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中的原型：

来自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;
}

所有其他答案都基于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））；

Fisher Yates的这种变体稍微更有效，因为它避免了元素与自身的交换：

function shuffle(array) {
  var elementsRemaining = array.length, temp, randomIndex;
  while (elementsRemaining > 1) {
    randomIndex = Math.floor(Math.random() * elementsRemaining--);
    if (randomIndex != elementsRemaining) {
      temp = array[elementsRemaining];
      array[elementsRemaining] = array[randomIndex];
      array[randomIndex] = temp;
    }
  }
  return array;
}

只是为了在馅饼里插一根手指。在这里，我介绍了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，这取决于浏览器引擎和一些未知的事实。