使用Ramda的功能解决方案。

const {map, compose, sortBy, prop} = require('ramda')

const shuffle = compose(
  map(prop('v')),
  sortBy(prop('i')),
  map(v => ({v, i: Math.random()}))
)

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

重建整个阵列，逐个将每个元素放在一个随机位置。

[1,2,3].reduce((a,x,i)=>{a.splice(Math.floor(Math.random()*(i+1)),0,x);return a},[])

变量ia=[1,2,3]；var it=1000；var f=（a，x，i）=>｛a.splice（Math.floor（Math.random（）*（i+1）），0，x）；返回a｝；var a=新数组（it）.fill（ia）.map（x=>x.reduce（f，[]））；var r=新数组（ia.length）.fill（0）.map（（x，i）=>a.reduce（（i2，x2）=>x2[i]+i2,0）/it）console.log（“这些值应该相当相等：”，r）；

你可以使用lodash洗牌。就像一个魅力

import _ from lodash;

let numeric_array = [2, 4, 6, 9, 10];
let string_array = ['Car', 'Bus', 'Truck', 'Motorcycle', 'Bicycle', 'Person']

let shuffled_num_array = _.shuffle(numeric_array);
let shuffled_string_array = _.shuffle(string_array);

console.log(shuffled_num_array, shuffled_string_array)

虽然已经建议了许多实现，但我觉得我们可以使用forEach循环使其更短、更容易，因此我们不必担心计算数组长度，也可以安全地避免使用临时变量。

var myArr = ["a", "b", "c", "d"];

myArr.forEach((val, key) => {
  randomIndex = Math.ceil(Math.random()*(key + 1));
  myArr[key] = myArr[randomIndex];
  myArr[randomIndex] = val;
});
// see the values
console.log('Shuffled Array: ', myArr)

费希尔·耶茨在javascript中洗牌。我在这里发表这篇文章是因为与这里的其他答案相比，使用两个实用函数（swap和randInt）澄清了算法。

function swap(arr, i, j) { 
  // swaps two elements of an array in place
  var temp = arr[i];
  arr[i] = arr[j];
  arr[j] = temp;
}
function randInt(max) { 
  // returns random integer between 0 and max-1 inclusive.
  return Math.floor(Math.random()*max);
}
function shuffle(arr) {
  // For each slot in the array (starting at the end), 
  // pick an element randomly from the unplaced elements and
  // place it in the slot, exchanging places with the 
  // element in the slot. 
  for(var slot = arr.length - 1; slot > 0; slot--){
    var element = randInt(slot+1);
    swap(arr, element, slot);
  }
}

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