对数组元素进行随机重排，数组中每个元素经过洗牌算法后落在数组某个位置上的概率是相等的

function shuffle(arr) {

     for(let i = arr.length-1;i>=0;i--)

     //随机从0-i中选择一个下标

    let randomIndex = Math.floor(Math.random()*(i+1));

   //将选中的元素与arr[i]交换

   let t = arr[randomIndex];

   arr[randomIndex] = arr[i];

   arr[i] = t;

  return arr;

}

比如我们有52张牌，现在的需求就是洗牌（俗名打乱顺序 - -！）

先构造一个数组：

const nums  = [  '  A  '  ,  1  ,  2  ,  3  ,  4  ,  5  ,  6  ,  7  ,  8  ,  9  ,  '  J  '  ,  '  Q  '  ,  '  K  ']

const signs  = [  '  ♥️  '  ,  '  ♦️  '  ,  '  ♣️  '  ,  '  ♠️  ']

const cards  = []

signs  .  forEach(  sign  =>  {

nums  .  forEach(  num  =>  {

cards  .  push(  {

kind  : sign  ,

num  : num

})

})

})

这样cards 就构造完成了，但是JS这样写很low，但是我觉得很快就想出来了，我们换一种其他优雅一点的方法(下面这段代码的作者是 月影)：

function  *  getCards  ()  {

const nums  = [  '  A  '  ,  1  ,  2  ,  3  ,  4  ,  5  ,  6  ,  7  ,  8  ,  9  ,  '  J  '  ,  '  Q  '  ,  '  K  ']

yield  * nums  .  map(  num  =>(  {key  :  '  ♥️  '  , num  : num  }))

yield  * nums  .  map(  num  =>(  {key  :  '  ♠️  '  , num  : num  }))

yield  * nums  .  map(  num  =>(  {key  :  '  ♦️  '  , num  : num  }))

yield  * nums  .  map(  num  =>(  {key  :  '  ♣️  '  , num  : num  }))

}

 

const cards   = [   ...   getCards()]

上面生成器的Key Point有两点:

  // Key Point -01

 ...扩展运算符 内部调用的是数据结构的Iterator接口，生成器返回的就是一个Iterator对象，即遍历器对象

对这个遍历器对象执行扩展运算符 ... 就会将内部遍历到的值转为一个数组

 // Key Point -02

  任何数据结构只要有Iterator接口，就可以用yield * 来遍历

 let readStr = (function* (){ yield* 'hello from other side' }())

 readStr.next().value 这一句会输出 字符'h'

如果你写一个执行器把这个生成器执行完毕，你会发现会依次将这个字符串的单个字符给输出

好到现在为止，准备工作做完了，cards数组我们已经有了，现在我们来洗牌

 // 洗牌

function  shuffle  (  cards  )  {

for(  let i  = cards  .length  -  1  ; i  >=  0  ; i  --)  {

var randomIndex  =  Math  .  floor(i  *  Math  .  random())

 // 从 index 为 51 开始， 51 * Math.random() 的范围是 (0, 51)

 // Math.floor 之后的整数范围是 [0, 50]

 // 我们将 cards[51] 和 前面的随机索引位置的值交换

 // 然后到 50个的时候，和 前面 [0, 49] 中索引取一个随机的 然后交换值

 // 这样下去，交换位置之后 索引为51 和 50 的值就不会变动了

const temp  = cards[randomIndex]

cards[randomIndex]  = cards[i]

cards[i]  = temp

}

return cards

}

其实感觉在遍历数组的时候改变数组不太好，可以返回一个新的数组更好一点，当然也看实际的需求。

 // 强制复习一下

const params    = (    function    *    (){  

yield    1    ;  

yield    2    ;  

yield    * (    function    *    (){    yield    3    ;    yield    4    ;    })()

yield    * [    5    ,    6    ,    7]

yield    *    '    abc    '  

   // yield * { length: 9, name: 'Ariza' }  

})()

console   .   log([   ...params])

 

最近的一个塔罗牌项目中，有一个洗牌的需求，其实也就是随机打乱数组，遂网上搜了下，再此做个整理…

举例来说，我们有一个如下图所示的数组，数组长度为 9，数组内元素的值顺次分别是 1~9：

从上面这个数组入手，我们要做的就是打乱数组内元素的顺序：

代码实现

Array.prototype.shuffle = function () {    let input = this;    for (let i = input.length - 1; i >= 0; i--) {        let randomIndex = Math.floor(Math.random() * (i + 1));        let itemAtIndex = input[randomIndex];        input[randomIndex] = input[i];        input[i] = itemAtIndex;    }    return input;}

在上面的代码中，我们创建了一个 shffle() 方法，该方法用于随机排列数组内的元素。

此外，我们将该方法挂载在了 Array 对象的原型下面，所以任何数组都可以直接调用该方法：

let tempArray = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]tempArray.shuffle();

工作原理

看完代码之后，让我们看看它对数组都做了写什么。首先，该方法选中数组的最后一个元素：

接下来确定挑选随机元素的范围，从数组的第一个元素到上一步选中的元素都属于这一范围：

确定范围后，从中随机挑选一个数，这里假设随机选中的元素为 4：

然后交换最后一个元素和随机选中的元素的值：

上面的交换完成后，相当于我们完成了对数组最后一个元素的随机处理。接下来选中数组内倒数第二的元素：

之所以从后往前处理，是因为这样便于确定随机选择的范围。这次我们假定随机到的元素为 2:

接着交换倒数第一个元素和 2 号元素的值，完成对倒数第二个元素随机排列的处理。然后是选中倒数第三个元素，重复之前的操作：

剩下的就是一些重复性的工作，不多做介绍了。

分析代码

在上一节给各位用图例演示了洗牌流程，下面我们从代码本身看看洗牌流程。先从 shuffle 函数说起吧：

Array.prototype.shuffle = function () {    let input = this;    for (let i = input.length - 1; i >= 0; i--) {        let randomIndex = Math.floor(Math.random() * (i + 1));        let itemAtIndex = input[randomIndex];        input[randomIndex] = input[i];        input[i] = itemAtIndex;    }    return input;}

shuffle 函数挂载在 Array 对象的原型之下，便于数组直接调用该函数。在 shuffle 函数内部，this 引用的就是调用该 shuffle 的数组：

var input = this;

在上面的代码中，我用一个新的变量引用 this，也就是调用 shuffle 函数的数组。下一步，看一下 for 循环内都干了什么：

for (let i = input.length - 1; i >= 0; i--) {    let randomIndex = Math.floor(Math.random() * (i + 1));    let itemAtIndex = input[randomIndex];    input[randomIndex] = input[i];    input[i] = itemAtIndex;}

该循环用于遍历所有数组内的所有元素，并进行随机交换。注意，遍历顺序是从后往前进行的，也就是说从 input.length-1 位置的元素开始，知道遍历到数组中的第一个元素。遍历过程中的位置由变量 i 指定。

这里的变量 i 就是上面图例中被选中的元素

洗牌算法

接下来，使用了两行代码在指定范围内挑选一个随机元素：

let randomIndex = Math.floor(Math.random() * (i + 1));let itemAtIndex = input[randomIndex];

变量 randomIndex 存储了一个随机数，该随机数可以用作数组的索引，进而提取一个随机元素。注意，该随机数的最大值并不是数组的长度，而是变量 i 的值。

确定了随机元素的索引之后，用新的变量保存该元素的值，然后交换选中元素和随机元素的值：

//使用新的变量保存了随机元素的值let itemAtIndex = input[randomIndex];//将选中元素 input[i] 的值赋给随机元素 input[randomIndex]input[randomIndex] = input[i];//随机元素的值 itemAtIndex 赋给选中元素 input[i]input[i] = itemAtIndex;

本质上是一个互换两个元素的值的过程，并不难理解。

至此，循环内的逻辑就介绍完了，剩下的都是重复操作。

随机性测试

上图是使用 Highcharts 制作的随机性测试图表，以可视化的方式校验本文中洗牌算法的随机性。每次刷新页面都会重新计算和生成该图表。

生成上图的数据是这样计算而来的：首先创建一个数组（上图使用的数组为 [0, 1, 2 … 18, 19, 20]），然后使用本文中的洗牌算法重新排序，排序完成后记录每一个元素的值……以此步骤执行 100000 次，最后对同一索引位置上的数值进行求和。如此执行 10000 次之后，索引之间的总值应该相差不大。

由计算可得：

洗牌算法听起来高大上，其实就是打乱数组的顺序，把有序的数组变成无序的

arr.sort(function(a,b){

    return Math.random()-0.5;

})

/** 洗牌算法场景：随机产生100个数字，数字范围1-100，并且它们不重复。 */

function shuffle2(arr){

//时间复杂度O(nlogn)    arr.sort(() => Math.random() - 0.5);}function shuffle(arr){

//时间复杂度O(n)    arr = arr.concat();

    let temp = null;

    let r = Math.random()*arr.length|0;

    for(let i=0;i{

        temp = arr[i];

        arr[i] = arr[r];

        arr[r] = temp;    }

    return arr;

}function test(){

    let arr = range(101,1);

    arr = shuffle(arr);

    console.info(arr); }function range(end,start=0,step=1){

    let res = [];

    for(let i=start;i{

        res.push(i);    }

    return res; }

test();

最近的一个塔罗牌项目中，有一个洗牌的需求，其实也就是随机打乱数组，遂网上搜了下，再此做个整理…

塔罗牌

举例来说，我们有一个如下图所示的数组，数组长度为 9，数组内元素的值顺次分别是 1~9：

1~9数组

从上面这个数组入手，我们要做的就是打乱数组内元素的顺序：

1~9数组打乱随机

代码实现

Array.prototype.shuffle = function () {
    let input = this;
    for (let i = input.length - 1; i >= 0; i--) {
        let randomIndex = Math.floor(Math.random() * (i + 1));
        let itemAtIndex = input[randomIndex];
        input[randomIndex] = input[i];
        input[i] = itemAtIndex;
    }
    return input;}

在上面的代码中，我们创建了一个 shffle() 方法，该方法用于随机排列数组内的元素。

此外，我们将该方法挂载在了 Array 对象的原型下面，所以任何数组都可以直接调用该方法：

let tempArray = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]tempArray.shuffle();

工作原理

看完代码之后，让我们看看它对数组都做了写什么。首先，该方法选中数组的最后一个元素：

选择最后一个元素

接下来确定挑选随机元素的范围，从数组的第一个元素到上一步选中的元素都属于这一范围：

挑选随机元素范围

确定范围后，从中随机挑选一个数，这里假设随机选中的元素为 4：

随机挑选一个数

然后交换最后一个元素和随机选中的元素的值：

交换

上面的交换完成后，相当于我们完成了对数组最后一个元素的随机处理。接下来选中数组内倒数第二的元素：

处理倒数第二的元素

之所以从后往前处理，是因为这样便于确定随机选择的范围。这次我们假定随机到的元素为 2:

确定随机选择的范围

接着交换倒数第一个元素和 2 号元素的值，完成对倒数第二个元素随机排列的处理。然后是选中倒数第三个元素，重复之前的操作：

倒数第三个元素

剩下的就是一些重复性的工作，不多做介绍了。

本质是对数组元素进行随机重排。数组中每个元素经过洗牌算法后落在数组某个位置上的概率是相等的

            洗牌就是把牌打乱 比如一个数组 ，如何将数组打乱（随机排序）呢？
            
            function sort2(arr) {
                var newArr = [];
                newArr = arr.sort(function() {
                    return Math.random() - 0.5;
                })
                return newArr;
            }
            console.log(sort(arr))
            console.log(sort2(arr))