警告不建议将此答案用于随机化大型阵列、密码学或任何其他需要真正随机性的应用程序，因为其存在偏差且效率低下。元素的位置只是半随机的，它们将倾向于保持更接近其原始位置。看见https://stackoverflow.com/a/18650169/28234.

可以使用Math.random任意决定是否返回1:-1：

[1, 2, 3, 4].sort(() => (Math.random() > 0.5) ? 1 : -1)

尝试运行以下示例：

常量数组=[1，2，3，4]；//基于Math.Random返回的值，//任意决定是否返回1:-1const shuffeled=array.sort（（）=>{const randomTrueOrFalse=数学random（）>0.5；return randomTrueOrFalse？1 : -1});console.log（shuffeled）；

随机化数组，无重复项

    function randomize(array){
        let nums = [];
        for(let i = 0; i < array.length; ++i){
            nums.push(i);
        }   
        nums.sort(() => Math.random() - Math.random()).slice(0, array.length)
        for(let i = 0; i < array.length; ++i){
            array[i] = array[nums[i]];
        }
    }
    randomize(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，这取决于浏览器引擎和一些未知的事实。

对CoolAJ86答案的简单修改，不修改原始数组：

 /**
 * Returns a new array whose contents are a shuffled copy of the original array.
 * @param {Array} The items to shuffle.
 * https://stackoverflow.com/a/2450976/1673761
 * https://stackoverflow.com/a/44071316/1673761
 */
const shuffle = (array) => {
  let currentIndex = array.length;
  let temporaryValue;
  let randomIndex;
  const newArray = array.slice();
  // While there remains elements to shuffle...
  while (currentIndex) {
    randomIndex = Math.floor(Math.random() * currentIndex);
    currentIndex -= 1;
    // Swap it with the current element.
    temporaryValue = newArray[currentIndex];
    newArray[currentIndex] = newArray[randomIndex];
    newArray[randomIndex] = temporaryValue;
  }
  return newArray;
};

您可以轻松地使用地图和排序：

让unshuffled＝['hello'，'a'，'t'，'q'，1，2，3，{cats:true}]让洗牌.map（value=>（｛value，sort:Math.random（）｝））.sort（（a，b）=>a.sort-b.sort）.map（（｛value｝）=>值）console.log（混洗）

我们将数组中的每个元素放在一个对象中，并给它一个随机排序键我们使用随机键排序我们取消映射以获取原始对象

您可以对多态数组进行排序，排序就像Math.random一样随机，这对于大多数目的来说都足够好。

由于元素是根据每次迭代都不会重新生成的一致键进行排序的，并且每次比较都来自相同的分布，因此Math.random分布中的任何非随机性都会被取消。

速度

时间复杂度为O（N log N），与快速排序相同。空间复杂度为0（N）。这不像Fischer Yates洗牌那样高效，但在我看来，代码明显更短，功能更强大。如果你有一个大数组，你当然应该使用Fischer Yates。如果您有一个包含几百个项目的小数组，您可以这样做。

使用ES2015，您可以使用此功能：

Array.prototype.shuffle = function() {
  let m = this.length, i;
  while (m) {
    i = (Math.random() * m--) >>> 0;
    [this[m], this[i]] = [this[i], this[m]]
  }
  return this;
}

用法：

[1, 2, 3, 4, 5, 6, 7].shuffle();