function quickSort(arr, compare){ arr = arr.slice(0); if(arr.length <= 1) return arr; var mid = arr[0], rest = arr.slice(1); var left = [], right = []; for(var i = 0; i < rest.length; i++){ if(compare(rest[i], mid) > 0){ right.push(rest[i]); }else{ left.push(rest[i]); } } return quickSort(left, compare).concat([mid]) .concat(quickSort(right, compare)); } function shuffle(arr){ return quickSort(arr, function(){ return Math.random() - 0.5; }); } var arr = [0,1,2,3,4,5,6,7,8,9]; var res = [0,0,0,0,0,0,0,0,0,0]; var t = 10000; for(var i = 0; i < t; i++){ var sorted = shuffle(arr.slice(0)); sorted.forEach(function(o,i){ res[i] += o; }); } res = res.map(function(o){ return o / t; }); console.log(res);
快速排序并没有两两元素进行比较，它的概率分布也不随机。
所以我们可以得出结论，用 Array.prototype.sort 随机交换的方式来随机排列数组，得到的结果并不一定随机，而是取决于排序算法是如何实现的，用 JavaScript 内置的排序算法这么排序，通常肯定是不完全随机的。
经典的随机排列
所有空间复杂度 O(1) 的排序算法的时间复杂度都介于 O(nlogn) 到 O(n2) 之间，因此在不考虑算法结果错误的前提下，使用排序来随机交换也是慢的。事实上，随机排列数组元素有经典的 O(n) 复杂度的算法：
function shuffle(arr){ var len = arr.length; for(var i = 0; i < len - 1; i++){ var idx = Math.floor(Math.random() * (len - i)); var temp = arr[idx]; arr[idx] = arr[len - i - 1]; arr[len - i -1] = temp; } return arr; }
在上面的算法里，我们每一次循环从前 len - i 个元素里随机一个位置，将这个元素和第 len - i 个元素进行交换，迭代直到 i = len - 1 为止。
我们同样可以检验一下这个算法的随机性：
function shuffle(arr){ var len = arr.length; for(var i = 0; i < len - 1; i++){ var idx = Math.floor(Math.random() * (len - i)); var temp = arr[idx]; arr[idx] = arr[len - i - 1]; arr[len - i -1] = temp; } return arr; } var arr = [0,1,2,3,4,5,6,7,8,9]; var res = [0,0,0,0,0,0,0,0,0,0]; var t = 10000; for(var i = 0; i < t; i++){ var sorted = shuffle(arr.slice(0)); sorted.forEach(function(o,i){ res[i] += o; }); } res = res.map(function(o){ return o / t; }); console.log(res);
从结果可以看出这个算法的随机结果应该是均匀的。不过我们的测试方法其实有个小小的问题，我们只测试了平均值，实际上平均值接近只是均匀分布的必要而非充分条件，平均值接近不一定就是均匀分布。不过别担心，事实上我们可以简单从数学上证明这个算法的随机性。
随机性的数学归纳法证明
对 n 个数进行随机：
首先我们考虑 n = 2 的情况，根据算法，显然有 1/2 的概率两个数交换，有 1/2 的概率两个数不交换，因此对 n = 2 的情况，元素出现在每个位置的概率都是 1/2，满足随机性要求。
假设有 i 个数， i >= 2 时，算法随机性符合要求，即每个数出现在 i 个位置上每个位置的概率都是 1/i。
对于 i + 1 个数，按照我们的算法，在第一次循环时，每个数都有 1/(i+1) 的概率被交换到最末尾，所以每个元素出现在最末一位的概率都是 1/(i+1) 。而每个数也都有 i/(i+1) 的概率不被交换到最末尾，如果不被交换，从第二次循环开始还原成 i 个数随机，根据 2. 的假设，它们出现在 i 个位置的概率是 1/i。因此每个数出现在前 i 位任意一位的概率是 (i/(i+1)) * (1/i) = 1/(i+1)，也是 1/(i+1)。
综合 1. 2. 3. 得出，对于任意 n >= 2，经过这个算法，每个元素出现在 n 个位置任意一个位置的概率都是 1/n。
总结
一个优秀的算法要同时满足结果正确和高效率。很不幸使用 Array.prototype.sort 方法这两个条件都不满足。因此，当我们需要实现类似洗牌的功能的时候，还是应该采用巧妙的经典洗牌算法，它不仅仅具有完全随机性还有很高的效率。