I want to shuffle an array of elements in JavaScript like these:
[0, 3, 3] -> [3, 0, 3] [9, 3, 6, 0, 6] -> [0, 3, 6, 9, 6] [3, 3, 6, 0, 6] -> [0, 3, 6, 3, 6] 
2 Answers
Use the modern version of the Fisher–Yates shuffle algorithm:
/** * Shuffles array in place. * @param {Array} a items An array containing the items. */ function shuffle(a) { var j, x, i; for (i = a.length - 1; i > 0; i--) { j = Math.floor(Math.random() * (i + 1)); x = a[i]; a[i] = a[j]; a[j] = x; } return a; } ES2015 (ES6) version
/** * Shuffles array in place. ES6 version * @param {Array} a items An array containing the items. */ function shuffle(a) { for (let i = a.length - 1; i > 0; i--) { const j = Math.floor(Math.random() * (i + 1)); [a[i], a[j]] = [a[j], a[i]]; } return a; } Note however, that swapping variables with destructuring assignment causes significant performance loss, as of October 2017.
Use
var myArray = ['1','2','3','4','5','6','7','8','9']; shuffle(myArray); Implementing prototype
Using Object.defineProperty (method taken from this SO answer) we can also implement this function as a prototype method for arrays, without having it show up in loops such as for (i in arr). The following will allow you to call arr.shuffle() to shuffle the array arr:
Object.defineProperty(Array.prototype, 'shuffle', { value: function() { for (let i = this.length - 1; i > 0; i--) { const j = Math.floor(Math.random() * (i + 1)); [this[i], this[j]] = [this[j], this[i]]; } return this; } }); 18 Comments
Michael
This method (as well as the one below) both modify the original array. That's no big deal, but the example of how to call it is a bit weird.
ryan-cook
@Michael +1 for pointing out that reassignment is unnecessary. In fact it's misleading, and probably should have been the FIRST thing pointed out in this comment thread.
trlkly
I find the ES6 swap to be slower (once I got it to work. You have to have a semicolon before a [--all the more reason to just always use them.).
Przemek
@trlkly: ES2015 variant will be slower due to the use of destructuring assignment. Hopefully engines will optimize it soon.
pauk960
@RobG const is a perfect choice because it's block-scoped, unlike var, and it's redeclared after each interation. let would also work, but since j doesn't change it's value inside for block const is better choice
|
You could use the Fisher-Yates Shuffle (code adapted from this site):
function shuffle(array) { let counter = array.length; // While there are elements in the array while (counter > 0) { // Pick a random index let index = Math.floor(Math.random() * counter); // Decrease counter by 1 counter--; // And swap the last element with it let temp = array[counter]; array[counter] = array[index]; array[index] = temp; } return array; } 12 Comments
Thomas Wood
That first answer seems to have a bug. About once in every 15 runs I get an extra
undefined column. jsfiddle.net/tomasswood/z8zm7
volter9
Why you just don't use random + Array.prototype.sort? It's easier and less code than both answers.
Blender
@Volter9: Because the distribution isn't going to be uniform.
JonnyRaa
really interesting post by jeff atwood about this algorithm. blog.codinghorror.com/the-danger-of-naivete I wanted to know why it is implemented the way it is
dcts
be aware this changes the initial array, its not a functional approach. Just leaving this here for anyone that is blindely copying this (as I did lol).
|
arr1.reduceRight((p,v,i,a)=>(v=i?~~(Math.random()*(i+1)):i, v-i?[a[v],a[i]]=[a[i],a[v]]:0, a),a); Also check out this function.