编辑：此答案不正确

参见评论和https://stackoverflow.com/a/18650169/28234.这里留作参考，因为这种想法并不罕见。

对于小型阵列，一个非常简单的方法就是：

const someArray = [1, 2, 3, 4, 5];

someArray.sort(() => Math.random() - 0.5);

它可能效率不高，但对于小型阵列来说，这很好。这里有一个例子，你可以看到它有多随机（或不随机），以及它是否适合你的用例。

const resultsEl=document.querySelector（“#results”）；const buttonEl=document.querySelector（“#trigger”）；常量生成器数组和随机化=（）=>{常量someArray=[0，1，2，3，4，5，6，7，8，9]；someArray.sort（（）=>Math.random（）-0.5）；return someArray；};const renderResultsToDom=（结果，el）=>{el.innerHTML=results.join（“”）；};buttonEl.addEventListener（'click'，（）=>renderResultsToDom（generateArray AndRandomize（），resultsEl））；<h1>随机化</h1><button id=“trigger”>生成</button><p id=“results”>0 1 2 3 4 5 6 7 8 9</p>

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

让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。如果您有一个包含几百个项目的小数组，您可以这样做。

无序排列到位

function shuffleArr (array){
    for (var i = array.length - 1; i > 0; i--) {
        var rand = Math.floor(Math.random() * (i + 1));
        [array[i], array[rand]] = [array[rand], array[i]]
    }
}

ES6纯，迭代

const getShuffledArr = arr => {
    const newArr = arr.slice()
    for (let i = newArr.length - 1; i > 0; i--) {
        const rand = Math.floor(Math.random() * (i + 1));
        [newArr[i], newArr[rand]] = [newArr[rand], newArr[i]];
    }
    return newArr
};

可靠性和性能测试

本页上的一些解决方案不可靠（它们只是部分随机化了阵列）。其他解决方案的效率明显较低。使用testShuffleArrayFun（见下文），我们可以测试阵列洗牌功能的可靠性和性能。

function testShuffleArrayFun(getShuffledArrayFun){
    const arr = [0,1,2,3,4,5,6,7,8,9]

    var countArr = arr.map(el=>{
        return arr.map(
            el=> 0
        )
    }) //   For each possible position in the shuffledArr and for 
       //   each possible value, we'll create a counter. 
    const t0 = performance.now()
    const n = 1000000
    for (var i=0 ; i<n ; i++){
        //   We'll call getShuffledArrayFun n times. 
        //   And for each iteration, we'll increment the counter. 
        var shuffledArr = getShuffledArrayFun(arr)
        shuffledArr.forEach(
            (value,key)=>{countArr[key][value]++}
        )
    }
    const t1 = performance.now()
    console.log(`Count Values in position`)
    console.table(countArr)

    const frequencyArr = countArr.map( positionArr => (
        positionArr.map(  
            count => count/n
        )
    )) 

    console.log("Frequency of value in position")
    console.table(frequencyArr)
    console.log(`total time: ${t1-t0}`)
}

其他解决方案

其他解决方案只是为了好玩。

ES6纯，递归

const getShuffledArr = arr => {
    if (arr.length === 1) {return arr};
    const rand = Math.floor(Math.random() * arr.length);
    return [arr[rand], ...getShuffledArr(arr.filter((_, i) => i != rand))];
};

ES6纯使用array.map

function getShuffledArr (arr){
    return [...arr].map( (_, i, arrCopy) => {
        var rand = i + ( Math.floor( Math.random() * (arrCopy.length - i) ) );
        [arrCopy[rand], arrCopy[i]] = [arrCopy[i], arrCopy[rand]]
        return arrCopy[i]
    })
}

ES6纯使用array.reduce

function getShuffledArr (arr){
    return arr.reduce( 
        (newArr, _, i) => {
            var rand = i + ( Math.floor( Math.random() * (newArr.length - i) ) );
            [newArr[rand], newArr[i]] = [newArr[i], newArr[rand]]
            return newArr
        }, [...arr]
    )
}

警告不建议将此答案用于随机化大型阵列、密码学或任何其他需要真正随机性的应用程序，因为其存在偏差且效率低下。元素的位置只是半随机的，它们将倾向于保持更接近其原始位置。看见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）；

随机化数组

 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; 

通过使用洗牌阵列模块，您可以洗牌您的阵列。这里有一个简单的代码。

var shuffle = require('shuffle-array'),
 //collection = [1,2,3,4,5];
collection = ["a","b","c","d","e"];
shuffle(collection);

console.log(collection);

希望这有帮助。