How to randomize (shuffle) a JavaScript array?

Question

I have an array like this:

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

How can I randomize / shuffle it?

Whatsoever

Just throwing this here that you can visualize how random a shuffle function actually is with this visualizer Mike Bostock made: bost.ocks.org/mike/shuffle/compare.html – Hattie

Answer 1

The de-facto unbiased shuffle algorithm is the Fisher–Yates (aka Knuth) Shuffle.

You can see a great visualization here.

function shuffle(array) {
  let currentIndex = array.length;

  // While there remain elements to shuffle...
  while (currentIndex != 0) {

    // Pick a remaining element...
    let randomIndex = Math.floor(Math.random() * currentIndex);
    currentIndex--;

    // And swap it with the current element.
    [array[currentIndex], array[randomIndex]] = [
      array[randomIndex], array[currentIndex]];
  }
}

// Used like so
let arr = [2, 11, 37, 42];
shuffle(arr);
console.log(arr);

Poteat

Be sure to transpile if you're going to do destructuring assignments in a busy loop -- allocating objects is expensive. – Stereoscope

This is a good display of the theory, but an actual implementation of this should check that the input is actually an array. As it is, if you accidentally pass in a value of a different type, the while loop will never finish and the program will hang. – Threequarter

Answer 2

Here's a JavaScript implementation of the Durstenfeld shuffle, an optimized version of Fisher-Yates:

/* Randomize array in-place using Durstenfeld shuffle algorithm */
function shuffleArray(array) {
    for (var i = array.length - 1; i > 0; i--) {
        var j = Math.floor(Math.random() * (i + 1));
        var temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}

It picks a random element for each original array element, and excludes it from the next draw, like picking randomly from a deck of cards.

This clever exclusion swaps the picked element with the current one, then picks the next random element from the remainder, looping backwards for optimal efficiency, ensuring the random pick is simplified (it can always start at 0), and thereby skipping the final element.

Algorithm runtime is O(n). Note that the shuffle is done in-place so if you don't want to modify the original array, first make a copy of it with .slice(0).

---

EDIT: Updating to ES6 / ECMAScript 2015

The new ES6 allows us to assign two variables at once. This is especially handy when we want to swap the values of two variables, as we can do it in one line of code. Here is a shorter form of the same function, using this feature.

function shuffleArray(array) {
    for (let i = array.length - 1; i > 0; i--) {
        const j = Math.floor(Math.random() * (i + 1));
        [array[i], array[j]] = [array[j], array[i]];
    }
}

Shool

The implementation in this answer favors the lower end of the array. Found out the hard way. Math.random() should not be multiplied with the loop counter + 1, but with array.lengt()`. See Generating random whole numbers in JavaScript in a specific range? for a very comprehensive explanation. – Bellerophon

@MarjanVenema Not sure if you're still watching this space, but this answer is correct, and the change you're suggesting actually introduces bias. See blog.codinghorror.com/the-danger-of-naivete for a nice writeup of this mistake. – Sardella

repeating user94559's comment with references en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle The element to be swapped (j) should be between 0 and the current array index (i) – Halfpenny

Here's the same function, but compressed: function shuffle(a){for(var j,i=a.length-1;i>0;i--){j=Math.floor(Math.random()*(i+1));[a[i],a[j]]=[a[j],a[i]]}} – Feed

Could we do here let i = array.length; instead of let i = array.length - 1; in the for loop and then const j = Math.floor(Math.random() * i); on the next line? – Recurvate

Did you forget to add return array; ? – Darwinism

@Darwinism The function works on the array you pass it. Adding return array will only allow for easier chaining with other . – Dermis

if using arrow function we should return array – Transit

This solution was significantly faster, and often less complex, when I compared it to other answers here. +1 – Kweisui

@Darwinism looks like, return array; is not required, as it is in-place algorithm, that is, the passed-in array as parameter is changed permanently. – Wickedness

@Feed is the compressed function slower than normal? does it create temporary 2-element arrays, in each iteration of loop? – Wickedness

This is Fisher-Yates shuffle algorithm. The function loops through the array and for each element, it generates a random index between 0 and the current index, and swaps the current element with the element at the random index. This way, the order of the elements in the array is shuffled randomly. – Ierna

I see that I already upvoted this answer long ago, but I'm happy to come back to it because I'd completely forgotten about Durstenfeld. Do you have any thoughts about #77337910? Thanks! – Unmerciful

Answer 3

You can do it easily with map and sort:

let unshuffled = ['hello', 'a', 't', 'q', 1, 2, 3, {cats: true}]

let shuffled = unshuffled
    .map(value => ({ value, sort: Math.random() }))
    .sort((a, b) => a.sort - b.sort)
    .map(({ value }) => value)
   
console.log(shuffled)

1. We put each element in the array in an object, and give it a random sort key
2. We sort using the random key
3. We unmap to get the original objects

You can shuffle polymorphic arrays, and the sort is as random as Math.random, which is good enough for most purposes.

Since the elements are sorted against consistent keys that are not regenerated each iteration, and each comparison pulls from the same distribution, any non-randomness in the distribution of Math.random is canceled out.

Speed

Time complexity is O(N log N), same as quick sort. Space complexity is O(N). This is not as efficient as a Fischer Yates shuffle but, in my opinion, the code is significantly shorter and more functional. If you have a large array you should certainly use Fischer Yates. If you have a small array with a few hundred items, you might do this.

Hypotension

Very nice. This is the Schwartzian transform in js. – Ashley

This is the best answer here (for short arrays) for a number of reasons. to me, it's really useful because I'm using react in 2021 which works best with a functional approach like this. – Papilloma

Think about the compexity again if you have to map 2 times it goes over the elements N two times already and that is not considering the quick sort complexity of JS's .sort algorithm – Pya

@IljaKO 2N is still O(N), which is less than the time complexity of O(N log N) – Cupellation

It is all in the details though. I would not see his approach as O(N log N) and would prefer another approach which is truly O(N log N) – Pya

This won't work. .sort modifies the original array. It doesn't work as .map. You have to create a new array in the first map. then sort it, and then return the last mapping. Something like this: const randomize = array => { const data = array.map(value => ({ value, sort: Math.random() })); data.sort((a, b) => a.sort - b.sort); return data.map(({ value }) => value); }; – Georgeannageorgeanne

@BrodaNoel The first map creates a new array containing the original data and a random number, the sort sorts according to that random number, the second map pops the original object back out into a new array. You can try it in the console if you like. – Hypotension

@Hypotension oh! yes. you are right. I thought .sort doesn't return the sorted array. Anyways, be careful there because that's not a clean way to do it. .sort make an "in place" modification. developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… – Georgeannageorgeanne

@BrodaNoel - It doesn't matter because I've already mapped it in the previous step, so I've already enforced immutability. – Hypotension

@IljaKO - O(2N + 2(N log N)) simplifies to O(N log N), so this is truly O(N log N). Big O notation is all about the largest scaling factor. We remove constants because they don't scale with input size, and simplify to the largest single scaling factor. Big O notation is deliberately NOT all about the details. – Hypotension

Could you anyone please explain what's happening on the second line? It's "a.sort - b.sort", he is calling sort within sort? what actually is "a.sort" and "b.sort" here? – Skatole

@ShahzadRahim - In the first line we map the data into a set of objects with sort attributes. In the second line, we sort by those sort attributes. In the third line, we map the data back out of those objects to get rid of the sort attributes. I'd encourage you to run the first line alone in your console to see what you get. It should make more sense when you do that. – Hypotension

It strikes me that, given that the sort key is being added in one map and then stripped out in another, you could simply call unshuffled.sort((_a, _b) => Math.random() - Math.random()) to achieve the same result. As both a and b's sort properties are just holding the result of independent calls to Math.random() I think it would be equivalent to call it twice separately at call time in the .sort callback. – Sallee

Or really just unshuffled.sort(() => Math.random() - Math.random()) – Sallee

@Sallee - no, it really isn't. In your code you're regenerating random numbers each time, so swapping subtrees arbitrarily on each recursion. In practice this will not produce a genuinely shuffled array. More on this in the rest of the thread. – Hypotension

@Sallee or even unshuffled.sort(() => Math.random() - 0.5) – Destrier

@Destrier - as mentioned elsewhere in this thread, this will not give you the result you are looking for. – Hypotension

I like this approach for shorter arrays because you can implement some logic in that sorting to bias the sort order and still expect something randomish. – Vendace

simpler: unshuffled.map(x => [Math.random(), x]).sort().map(([_, x]) => x) (works because sort() is lexicographical, i.e. looks at first element first) – Crayton

Answer 4

Warning!
The use of this algorithm is not recommended, because it is inefficient and strongly biased; see comments. It is being left here for future reference, because the idea is not that rare.

[1,2,3,4,5,6].sort( () => .5 - Math.random() );

---

This https://javascript.info/array-methods#shuffle-an-array tutorial explains the differences straightforwardly.

Disdainful

Downvoting as this isn't really that random. I don't know why it has so many upvotes. Do not use this method. It looks pretty, but isn't completely correct. Here are results after 10,000 iterations on how many times each number in your array hits index [0] (I can give the other results too): 1 = 29.19%, 2 = 29.53%, 3 = 20.06%, 4 = 11.91%, 5 = 5.99%, 6 = 3.32% – Outweigh

It's fine if you need to randomize relatively small array and not dealing with cryptographic things. I totally agree that if you need more randomness you need to use more complex solution. – Disdainful

It's also the least efficient of all the methods available. – Proceeds

The problem is that it's not deterministic, which will give wrong results (if 1 > 2 and 2 > 3, it should be given that 1 > 3, but this will not guarantee that. This will confuse the sort, and give the result commented by @radtad). – Apostatize

Essential reading: Is it correct to use JavaScript Array.sort() method for shuffling? – Nebulous

I upvoted without much testing because of its simplicity – Oleviaolfaction

Same as above, I don't need much of a cryptographic shuffle. Something simple for a small game with no huge consequences if the randomness is not 100% on point. – Mettle

I also upvoted this for a few reasons. First of all, it's for a simple gallery layout shuffle function, nothing that depends on true randomness. More importantly, each time the shuffle runs, it will shuffle from an already-shuffled (re-indexed) array, and therefore it doesn't matter if this method is biased towards specific indexes. In @radtad's comment, it is assumed we are shuffling from the same original array order every time ... If we are shuffling a re-shuffled array each time, it comes as close to randomness as it needs to. – Braasch

Answer 5

Use the underscore.js library. The method _.shuffle() is nice for this case. Here is an example with the method:

var _ = require("underscore");

var arr = [1,2,3,4,5,6];
// Testing _.shuffle
var testShuffle = function () {
  var indexOne = 0;
    var stObj = {
      '0': 0,
      '1': 1,
      '2': 2,
      '3': 3,
      '4': 4,
      '5': 5
    };
    for (var i = 0; i < 1000; i++) {
      arr = _.shuffle(arr);
      indexOne = _.indexOf(arr, 1);
      stObj[indexOne] ++;
    }
    console.log(stObj);
};
testShuffle();

Offenseless

Answer 6

NEW!

Shorter & probably *faster Fisher-Yates shuffle algorithm

1. it uses while---
2. bitwise to floor (numbers up to 10 decimal digits (32bit))
3. removed unecessary closures & other stuff

---

function fy(a,b,c,d){//array,placeholder,placeholder,placeholder
 c=a.length;while(c)b=Math.random()*(--c+1)|0,d=a[c],a[c]=a[b],a[b]=d
}

script size (with fy as function name): 90bytes

DEMO http://jsfiddle.net/vvpoma8w/

*faster probably on all browsers except chrome.

If you have any questions just ask.

EDIT

yes it is faster

PERFORMANCE: http://jsperf.com/fyshuffle

using the top voted functions.

EDIT There was a calculation in excess (don't need --c+1) and noone noticed

shorter(4bytes)&faster(test it!).

function fy(a,b,c,d){//array,placeholder,placeholder,placeholder
 c=a.length;while(c)b=Math.random()*c--|0,d=a[c],a[c]=a[b],a[b]=d
}

Caching somewhere else var rnd=Math.random and then use rnd() would also increase slightly the performance on big arrays.

http://jsfiddle.net/vvpoma8w/2/

Readable version (use the original version. this is slower, vars are useless, like the closures & ";", the code itself is also shorter ... maybe read this How to 'minify' Javascript code , btw you are not able to compress the following code in a javascript minifiers like the above one.)

function fisherYates( array ){
 var count = array.length,
     randomnumber,
     temp;
 while( count ){
  randomnumber = Math.random() * count-- | 0;
  temp = array[count];
  array[count] = array[randomnumber];
  array[randomnumber] = temp
 }
}

Dewy

check out the performance ... 2x faster on most browsers... but needs more jsperf testers... – Dewy

js is a language that accepts many shortcuts and different ways to write it.. while there are many slow readable functions in here i just like to show how it could be done in a more performant way, also saving some bytes... bitwise and shorthand is really underestimated here and the web is full of buggy and slow code. – Dewy

Not a slam dunk perf increase. Swapping the fy and shuffle prototype, I get fy consistently at the bottom in Chrome 37 on OS X 10.9.5 (81% slower ~20k ops compared to ~100k) and Safari 7.1 it's up to ~8% slower. YMMV, but it's not always faster. jsperf.com/fyshuffle/3 – Washerwoman

check stats again... i already wrote chrome is slower beacuse they optimized Math, on all other the bitwise floor and while is faster. check IE, firefox but also mobile devices.Would be also nice to see opera... – Dewy

mobile safari 1409(fy) vs (shuffle)1253 ,ie 31850(fy) vs (shuffle)13405 – Dewy

actually shuffle at the other side it's almost the same as my fy function except the bitwise and while. – Dewy

note that also the for loop works alot better on chrome than on ANY other browser. just setup a performance.time() or how it's called and test on several different browsrers... only in chrome the for loop is faster/same speed than while – Dewy

btw i also got my mac mini with better results using fy, and btw what do you mean you swapped fy&shuffle prototype? changed the execution position in jsperf?? – Dewy

ohh i was testing on safari 6.1 where it's also 90% faster. looks like they changed something in the 7.1 – Dewy

atm i can't test on the safari 6.1 mashine – Dewy

if i tell you the i have seen an animal in africa which has big ears and a very long nose. you would understand that it is an elefant. but the english language, also other languages, allow you to use the word elefant. javascript is also a language that has many words that can be used in different ways. i just try to use the proper words for that language. short code and performance is always important in this language. i don't use minifiers. i reread my code and optimize it. – Dewy

So should you . if you don't understand something you could ask me to explain the code. Or just grab a book and read why i don't use all those multiple var, closures and extra bytes. Another thing... downvote if you think this is not a good code. noone stops you – Dewy

@Dewy Why have you called numberArray(a,b) with only single parameter numberArray(10) in your fiddle? – Brazzaville

This is mental and amazing in equal measure. I've been writing JS for 20 years, and I learned some new tricks reading this just now. I'm not sure whether I've been enlightened or ruined forever. – Hypotension

If your software does something useful besides shuffling arrays, micro-optimizations doesn't matter. If your software just shuffles arrays without any other effects, it's a waste of human time 🤷‍♂️ – Alienist

for is better than while for code golf function fy(a,b,c){for(c=a.length;c;[a[c],a[b]]=[a[b],a[c]])b=Math.random()*c--|0} – Remiss

I would rather leave it to a minifier instead of minifying my code myself. – Marijane

can be re-written as a shorter function like: function fy(a,b,c=a.length){while(c)b=Math.random()*(--c+1)|0,[a[c],a[b]]=[a[b],a[c]]} – Kierakieran

Answer 7

Shuffle Array In place

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 Pure, Iterative

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
};

---

Reliability and Performance Test

Some solutions on this page aren't reliable (they only partially randomise the array). Other solutions are significantly less efficient. With testShuffleArrayFun (see below) we can test array shuffling functions for reliability and performance.

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}`)
}

---

Other Solutions

Other solutions just for fun.

ES6 Pure, Recursive

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 Pure using 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 Pure using 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]
    )
}

Openandshut

So, where is the ES6(ES2015) ? [array[i], array[rand]]=[array[rand], array[i]] ? Maybe you can outline how that works. Why do you choose to iterate downwards? – Equivalent

@Equivalent Yes, the ES6 feature I'm using is the assignment of two vars at once, which allows us to swap two vars in one line of code. – Openandshut

Credit to @Equivalent who suggested the ascending Algorithm. The ascending algorithm could be proved in induction. – Openandshut

Answer 8

Edit: This answer is incorrect

See comments and https://mcmap.net/q/45002/-how-to-randomize-shuffle-a-javascript-array. It is being left here for reference because the idea isn't rare.

---

A very simple way for small arrays is simply this:

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

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

It's probably not very efficient, but for small arrays this works just fine. Here's an example so you can see how random (or not) it is, and whether it fits your usecase or not.

const resultsEl = document.querySelector('#results');
const buttonEl = document.querySelector('#trigger');

const generateArrayAndRandomize = () => {
  const someArray = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
  someArray.sort(() => Math.random() - 0.5);
  return someArray;
};

const renderResultsToDom = (results, el) => {
  el.innerHTML = results.join(' ');
};

buttonEl.addEventListener('click', () => renderResultsToDom(generateArrayAndRandomize(), resultsEl));

<h1>Randomize!</h1>
<button id="trigger">Generate</button>
<p id="results">0 1 2 3 4 5 6 7 8 9</p>

Adamina

Nice one, but does generate a complete random elements every time? – Greedy

Not quite sure if I understood you correctly. This approach will indeed shuffle the array in a random way (albeit pseudo-random) every time you call the sort array - it's not a stable sort, for obvious reasons. – Adamina

For the same reasons as explained at https://mcmap.net/q/45002/-how-to-randomize-shuffle-a-javascript-array . This is much more likely to leave early elements near the start of the array. – Heteroclite

This is a great, easy one-liner for when you need to scramble an array, but don't care too much about having the results be academically provably random. Sometimes, that last few inches to perfection take more time than it's worth. – Magnific

It would be lovely if this worked, but it doesn't. Because of the way quick-search works, an inconsistent comparator will be likely to leave array elements close to their original position. Your array will not be scrambled. – Hypotension

Yet it is scrambled though. Try running [1,2,3,4,5].sort(() => Math.random() * 2 - 1); in the console, it'll scramble the result for every time. This isn't the perfect randomizer, but for simple use-cases it works just fine. – Adamina

I don't think the comments here adequately warn how bad this method is if you want an even vaguely fair shuffle. Testing this method on chrome with an array of ten elements, the last element stays the last element HALF the time, and 75% of the time is in the last two. This isn't "academic" - it's really quite bad. OTOH, if you want to subtly make something that seems random but lets you cheat by often knowing characteristics of the supposedly shuffled list, I guess this could be used for that. – Tuition

Answer 9

benchmarks

Let's first see the results then we'll look at each implementation of shuffle below -

---

splice is slow

Any solution using splice or shift in a loop is going to be very slow. Which is especially noticeable when we increase the size of the array. In a naive algorithm we -

1. get a rand position, i, in the input array, t
2. add t[i] to the output
3. splice position i from array t

To exaggerate the slow effect, we'll demonstrate this on an array of one million elements. The following script almost 30 seconds -

const shuffle = t =>
  Array.from(sample(t, t.length))

function* sample(t, n)
{ let r = Array.from(t)
  while (n > 0 && r.length)
  { const i = rand(r.length) // 1
    yield r[i]               // 2
    r.splice(i, 1)           // 3
    n = n - 1
  }
}

const rand = n =>
  0 | Math.random() * n

function swap (t, i, j)
{ let q = t[i]
  t[i] = t[j]
  t[j] = q
  return t
}

const size = 1e6
const bigarray = Array.from(Array(size), (_,i) => i)
console.time("shuffle via splice")
const result = shuffle(bigarray)
console.timeEnd("shuffle via splice")
document.body.textContent = JSON.stringify(result, null, 2)

body::before {
  content: "1 million elements via splice";
  font-weight: bold;
  display: block;
}

---

pop is fast

The trick is not to splice and instead use the super efficient pop. To do this, in place of the typical splice call, you -

1. select the position to splice, i
2. swap t[i] with the last element, t[t.length - 1]
3. add t.pop() to the result

Now we can shuffle one million elements in less than 100 milliseconds -

const shuffle = t =>
  Array.from(sample(t, t.length))

function* sample(t, n)
{ let r = Array.from(t)
  while (n > 0 && r.length)
  { const i = rand(r.length) // 1
    swap(r, i, r.length - 1) // 2
    yield r.pop()            // 3
    n = n - 1
  }
}

const rand = n =>
  0 | Math.random() * n

function swap (t, i, j)
{ let q = t[i]
  t[i] = t[j]
  t[j] = q
  return t
}

const size = 1e6
const bigarray = Array.from(Array(size), (_,i) => i)
console.time("shuffle via pop")
const result = shuffle(bigarray)
console.timeEnd("shuffle via pop")
document.body.textContent = JSON.stringify(result, null, 2)

body::before {
  content: "1 million elements via pop";
  font-weight: bold;
  display: block;
}

---

even faster

The two implementations of shuffle above produce a new output array. The input array is not modified. This is my preferred way of working however you can increase the speed even more by shuffling in place.

Below shuffle one million elements in less than 10 milliseconds -

function shuffle (t)
{ let last = t.length
  let n
  while (last > 0)
  { n = rand(last)
    swap(t, n, --last)
  }
}

const rand = n =>
  0 | Math.random() * n

function swap (t, i, j)
{ let q = t[i]
  t[i] = t[j]
  t[j] = q
  return t
}

const size = 1e6
const bigarray = Array.from(Array(size), (_,i) => i)
console.time("shuffle in place")
shuffle(bigarray)
console.timeEnd("shuffle in place")
document.body.textContent = JSON.stringify(bigarray, null, 2)

body::before {
  content: "1 million elements in place";
  font-weight: bold;
  display: block;
}

Bort

Answer 10

Warning!
Using this answer for randomizing large arrays, cryptography, or any other application requiring true randomness is not recommended, due to its bias and inefficiency. Elements position is only semi-randomized, and they will tend to stay closer to their original position. See https://mcmap.net/q/45002/-how-to-randomize-shuffle-a-javascript-array.

---

You can arbitrarily decide whether to return 1 : -1 by using Math.random:

[1, 2, 3, 4].sort(() => (Math.random() > 0.5) ? 1 : -1)

Try running the following example:

const array =  [1, 2, 3, 4];

// Based on the value returned by Math.Random,
// the decision is arbitrarily made whether to return 1 : -1

const shuffeled = array.sort(() => {
  const randomTrueOrFalse = Math.random() > 0.5;
  return randomTrueOrFalse ? 1 : -1
});

console.log(shuffeled);

Trefoil

Is this unbiased? – Swallow

what? this is so pointless. it has almost 0 chance of leaving the element intact (random generating exactly 0.5) – Birkle

I suggest removing this answer. Answer isn't correct and isn't new. The other wrong answer is left for future reference so I think this one can be removed :-) – Openandshut

@BenCarp First of all, your comment and suggestion are greatly appreciated! They will be reviewed and considered (as for your assertion that my answer isn't new, I believe it differs from the one you referred to) – Trefoil

@RafiHenig The difference from the other answer is very very minor. Given that both are incorrect, nothing less, I don't see the point of it. – Openandshut

Your comment sounds as if in some circumstances using this solution makes sense. I can't think of such. For it doesn't lead to randomization and is much more expensive. It might be suitable if someone would ask for a semi randomization that keeps elements close to theiry original position, but that is not the question before us. – Openandshut

@BenCarp Based on my observations, this algorithm works well for both randomizing small arrays of data as well as for situations in which it is not essential to apply true randomness to the array in question. – Trefoil

Answer 11

I found this variant hanging out in the "deleted by author" answers on a duplicate of this question. Unlike some of the other answers that have many upvotes already, this is:

1. Actually random
2. Not in-place (hence the shuffled name rather than shuffle)
3. Not already present here with multiple variants

Here's a jsfiddle showing it in use.

Array.prototype.shuffled = function() {
  return this.map(function(n){ return [Math.random(), n] })
             .sort().map(function(n){ return n[1] });
}

Tuition

(I suspect it was deleted as it is a very inefficient way to randomize the array, especially for larger arrays... whereas the accepted answer, and a number of other clones of that answer randomize in-place). – Blackhead

Yeah, but given that the well-known wrong answer is still up with a bunch of votes, an inefficient but correct solution should at least be mentioned. – Tuition

[1,2,3,4,5,6].sort(function() { return .5 - Math.random(); }); - it doesn't give a random sort, and if you use it you can end up embarrassed: robweir.com/blog/2010/02/microsoft-random-browser-ballot.html – Tuition

You need to use .sort(function(a,b){ return a[0] - b[0]; }) if you want the sort to compare values numerically. The default .sort() comparator is lexicographic, meaning it will consider 10 to be less than 2 since 1 is less than 2. – Radmilla

@Radmilla Okay, I updated the code, but am going to revert it: the distinction between lexicographic order and numerical order doesn't matter for numbers in the range that Math.random() produces. (that is, lexicographic order is the same as numeric order when dealing with numbers from 0 (inclusive) to 1 (exclusive)) – Tuition

This is a great answer, simple and understandable, and fast-enough for non-huge arrays. Thanks! BTW, the final .map() can be simplified to .map(([r, v]) => v ) – Hickman

Can be simplified to a.map(r=>[Math.random(),r]).sort().map(r=>r[1]). This is 6 to 9 times slower than the Fisher-Yates though. – Godwit

Answer 12

With ES2015 you can use this one:

Array.prototype.shuffle = function() {
  let m = this.length, i;
  while (m) {
    i = (Math.random() * m--) >>> 0;
    [this[m], this[i]] = [this[i], this[m]]
  }
  return this;
}

Usage:

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

Kelsey

To truncate, you should use n >>> 0 instead of ~~n. Array indices can be higher than 2³¹-1. – Commodore

Destructuring like this makes for such a clean implementation +1 – Rockbottom

Answer 13

//one line solution
shuffle = (array) => array.sort(() => Math.random() - 0.5);


//Demo
let arr = [1, 2, 3];
shuffle(arr);
alert(arr);

https://javascript.info/task/shuffle

Math.random() - 0.5 is a random number that may be positive or negative, so the sorting function reorders elements randomly.

Peruzzi

This does not shuffle with homogeneous probability distribution. – Ingredient

It is also a repeat of this older answer. and this still older answer No need to repeat a bad algorithm. – Ingredient

Answer 14

var shuffle = function(array) {
   temp = [];
   originalLength = array.length;
   for (var i = 0; i < originalLength; i++) {
     temp.push(array.splice(Math.floor(Math.random()*array.length),1));
   }
   return temp;
};

Solorio

This is obviously not as optimal as the Fisher-Yates algorithm, but would it work for technical interviews? – Creighton

@Andrea The code was broken due to the fact that array length is changed inside the for loop. With the last edit this is corrected. – Buggy

You didn't declare your variables, which makes them globals - and this function seems to randomly remove elements from the input array. – Sibylle

Answer 15

A recursive solution:

function shuffle(a,b){
    return a.length==0?b:function(c){
        return shuffle(a,(b||[]).concat(c));
    }(a.splice(Math.floor(Math.random()*a.length),1));
};

Lists

Answer 16

Modern short inline solution using ES6 features:

['a','b','c','d'].map(x => [Math.random(), x]).sort(([a], [b]) => a - b).map(([_, x]) => x);

(for educational purposes)

Bacteriostat

what's the distribution of this one? – Derna

@Derna To explain what is happening, we generate random number for each item in the array and then sort the items by that number. So as long as you are getting "real random" numbers from the Math.random() function, you will get an uniform distribution (each item has the same chance to be at any position). – Bacteriostat

Answer 17

Fisher-Yates shuffle in javascript. I'm posting this here because the use of two utility functions (swap and randInt) clarifies the algorithm compared to the other answers here.

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);
  }
}

Contemplation

Answer 18

Using Fisher-Yates shuffle algorithm and ES6:

// Original array
let array = ['a', 'b', 'c', 'd'];

// Create a copy of the original array to be randomized
let shuffle = [...array];

// Defining function returning random value from i to N
const getRandomValue = (i, N) => Math.floor(Math.random() * (N - i) + i);

// Shuffle a pair of two elements at random position j
shuffle.forEach( (elem, i, arr, j = getRandomValue(i, arr.length)) => [arr[i], arr[j]] = [arr[j], arr[i]] );

console.log(shuffle);
// ['d', 'a', 'b', 'c']

Nicol

Answer 19

a shuffle function that doesn't change the source array

Disclaimer

Please note that this solution is not suitable for large arrays! If you are shuffling large datasets, you should use the Durstenfeld algorithm suggested above.

Solution

function shuffle(array) {
  const result = [], itemsLeft = array.concat([]);

  while (itemsLeft.length) {
    const randomIndex = Math.floor(Math.random() * itemsLeft.length);
    const [randomItem] = itemsLeft.splice(randomIndex, 1); // take out a random item from itemsLeft
    result.push(randomItem); // ...and add it to the result
  }

  return result;
}

How it works

1. copies the initial array into itemsLeft

2. picks up a random index from itemsLeft, adds the corresponding element to the result array and deletes it from the itemsLeft array

3. repeats step (2) until itemsLeft array gets empty

4. returns result

Baiel

This is essentially the original Fisher-Yates algorithm, with your splice being a horribly inefficient way to do what they called "striking out". If you don't want to mutate the original array, then just copy it, and then shuffle that copy in place using the much more efficient Durstenfeld variant. – Ire

@torazaburo, thank you for your feedback. I've updated my answer, to make it clear that I'm rather offering a nice-looking solution, than a super-scaling one – Baiel

We could also use the splice method to create a copy like so: source = array.slice();. – Colombo

Answer 20

First of all, have a look here for a great visual comparison of different sorting methods in javascript.

Secondly, if you have a quick look at the link above you'll find that the random order sort seems to perform relatively well compared to the other methods, while being extremely easy and fast to implement as shown below:

function shuffle(array) {
  var random = array.map(Math.random);
  array.sort(function(a, b) {
    return random[array.indexOf(a)] - random[array.indexOf(b)];
  });
}

Edit: as pointed out by @gregers, the compare function is called with values rather than indices, which is why you need to use indexOf. Note that this change makes the code less suitable for larger arrays as indexOf runs in O(n) time.

Statehood

This is not very random. Depending on the implementation of sort, an element at the lowest array index might require more comparisons in order to get to the highest index than the element next to the highest index. This means that it is less likely for the element at the lowest index to get to the highest index. – Pitapat

This is needlessly inefficient and will always shuffle duplicates next to each other. – Syncretize

@1'OR1--: That’s not correct. – Syncretize

Answer 21

A simple modification of CoolAJ86's answer that does not modify the original array:

 /**
 * Returns a new array whose contents are a shuffled copy of the original array.
 * @param {Array} The items to shuffle.
 * https://mcmap.net/q/45002/-how-to-randomize-shuffle-a-javascript-array
 * https://mcmap.net/q/45002/-how-to-randomize-shuffle-a-javascript-array
 */
const shuffle = (array) => {
  let currentIndex = array.length;
  let temporaryValue;
  let randomIndex;
  const newArray = array.slice();
  // While there remains elements to shuffle...
  while (currentIndex) {
    randomIndex = Math.floor(Math.random() * currentIndex);
    currentIndex -= 1;
    // Swap it with the current element.
    temporaryValue = newArray[currentIndex];
    newArray[currentIndex] = newArray[randomIndex];
    newArray[randomIndex] = temporaryValue;
  }
  return newArray;
};

Jenkins

Answer 22

All the other answers are based on Math.random() which is fast but not suitable for cryptgraphic level randomization.

The below code is using the well known Fisher-Yates algorithm while utilizing Web Cryptography API for cryptographic level of randomization.

var d = [1,2,3,4,5,6,7,8,9,10];

function shuffle(a) {
	var x, t, r = new Uint32Array(1);
	for (var i = 0, c = a.length - 1, m = a.length; i < c; i++, m--) {
		crypto.getRandomValues(r);
		x = Math.floor(r / 65536 / 65536 * m) + i;
		t = a [i], a [i] = a [x], a [x] = t;
	}

	return a;
}

console.log(shuffle(d));

Lidda

Answer 23

For those of us who are not very gifted but have access to the wonders of lodash, there is such a thing as lodash.shuffle.

Babysitter

Answer 24

We're still shuffling arrays in 2019, so here goes my approach, which seems to be neat and fast to me:

const src = [...'abcdefg'];

const shuffle = arr => 
  [...arr].reduceRight((res,_,__,s) => 
    (res.push(s.splice(0|Math.random()*s.length,1)[0]), res),[]);

console.log(shuffle(src));

.as-console-wrapper {min-height: 100%}

Informer

In reality, it’s neither neat (reduce abuse) nor fast (quadratic time). – Syncretize

@Syncretize : In reality, the line between neat trick and abuse is rather thin and dependant on the personal perspective. From where I stand, mutating the source array while looping through it is not that horrible. I must admit, though, that this solution is not immediately clear at first glance and yet there's nothing in it that formally increases its cognitive complexity. – Informer

@Syncretize : As for the performance, looping through the array of shrinking size can't possibly be of O(n²) complexity in theory. Neither does it seem to be the case in reality. However, I must admit that this solution by the time of the posting was likely exploiting some loophole that is no longer available and thus it performs much slower than the accepted answer. – Informer

If you plot both of them and/or increase the bounds, it’s easier to see the O(n^2) curvature. V8 optimizes shift to O(1) for small (< 1000 element, IIRC) arrays, so it can look like O(n) at small scales. stackblitz.com/edit/shuffler-execution-time-gkgdbl – Syncretize

Answer 25

You can use lodash shuffle. Works like a charm

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)

Gracye

Answer 26

Randomize array

 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; 

Kramlich

There shouldn't be a -1 for n as you used < not <= – Michalmichalak

Answer 27

Though there are a number of implementations already advised but I feel we can make it shorter and easier using forEach loop, so we don't need to worry about calculating array length and also we can safely avoid using a temporary variable.

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)

Sallie

Rewriting it this way made it shorter, easier, and wrong. Note how the result always ends with "c". – Syncretize

Answer 28

ES6 compact code using generator function*

This works by randomly removing items from a copy of the unshuffled array until there are none left. It uses the new ES6 generator function.

This will be a perfectly fair shuffle as long as Math.random() is fair.

let arr = [1,2,3,4,5,6,7]

function* shuffle(arr) {
  arr = [...arr];
  while(arr.length) yield arr.splice(Math.random()*arr.length|0, 1)[0]
}

console.log([...shuffle(arr)])

Alternatively, using ES6 and splice:

let arr = [1,2,3,4,5,6,7]

let shuffled = arr.reduce(([a,b])=>
  (b.push(...a.splice(Math.random()*a.length|0, 1)), [a,b]),[[...arr],[]])[1]

console.log(shuffled)

or, ES6 index swap method:

let arr = [1,2,3,4,5,6,7]

let shuffled = arr.reduce((a,c,i,r,j)=>
  (j=Math.random()*(a.length-i)|0,[a[i],a[j]]=[a[j],a[i]],a),[...arr])

console.log(shuffled)

Confirmatory

To use splice here is to be massively inefficient for no reason. – Syncretize

@Syncretize I agree, the index swap method is fastest. However, the generator function is more useful if someone wants to take random cards from the deck one-at-a-time, in which case there is no need to do the entire shuffle up-front. – Confirmatory

It’s not an either-or thing; you can perform the efficient shuffle one item at a time too. (And copying the array already takes O(n) time anyway.) – Syncretize

@Syncretize that's a good point. The main reason for my answer is for when someone that isn't performance-sensitive just wants compact code. – Confirmatory

Answer 29

the shortest arrayShuffle function

function arrayShuffle(o) {
    for(var j, x, i = o.length; i; j = parseInt(Math.random() * i), x = o[--i], o[i] = o[j], o[j] = x);
    return o;
}

Gymnasiarch

Apparently you are doing Sattolo's instead of Fisher-Yates (Knuth, unbiased). – Veronicaveronika

Answer 30

Funny enough there was no non mutating recursive answer:

var shuffle = arr => {
  const recur = (arr,currentIndex)=>{
    console.log("What?",JSON.stringify(arr))
    if(currentIndex===0){
      return arr;
    }
    const randomIndex = Math.floor(Math.random() * currentIndex);
    const swap = arr[currentIndex];
    arr[currentIndex] = arr[randomIndex];
    arr[randomIndex] = swap;
    return recur(
      arr,
      currentIndex - 1
    );
  }
  return recur(arr.map(x=>x),arr.length-1);
};

var arr = [1,2,3,4,5,[6]];
console.log(shuffle(arr));
console.log(arr);

Touchline

Maybe there wasn't because it's pretty inefficient? :-P – Nebulous

@Nebulous Correct, updated with first answer logic. Still need to copy the array for immutability. Added because this is flagged as the duplicate of a question asking for a function that takes an array and returned a shuffled array without mutating the array. Now the question actually has an answer the OP was looking for. – Touchline

Answer 31

From a theoretical point of view, the most elegant way of doing it, in my humble opinion, is to get a single random number between 0 and n!-1 and to compute a one to one mapping from {0, 1, …, n!-1} to all permutations of (0, 1, 2, …, n-1). As long as you can use a (pseudo-)random generator reliable enough for getting such a number without any significant bias, you have enough information in it for achieving what you want without needing several other random numbers.

When computing with IEEE754 double precision floating numbers, you can expect your random generator to provide about 15 decimals. Since you have 15!=1,307,674,368,000 (with 13 digits), you can use the following functions with arrays containing up to 15 elements and assume there will be no significant bias with arrays containing up to 14 elements. If you work on a fixed-size problem requiring to compute many times this shuffle operation, you may want to try the following code which may be faster than other codes since it uses Math.random only once (it involves several copy operations however).

The following function will not be used, but I give it anyway; it returns the index of a given permutation of (0, 1, 2, …, n-1) according to the one to one mapping used in this message (the most natural one when enumerating permuations); it is intended to work with up to 16 elements:

function permIndex(p) {
    var fact = [1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800, 39916800, 479001600, 6227020800, 87178291200, 1307674368000];
    var tail = [];
    var i;
    if (p.length == 0) return 0;
    for(i=1;i<(p.length);i++) {
        if (p[i] > p[0]) tail.push(p[i]-1);
        else tail.push(p[i]);
    }
    return p[0] * fact[p.length-1] + permIndex(tail);
}

The reciprocal of the previous function (required for your own question) is below; it is intended to work with up to 16 elements; it returns the permutation of order n of (0, 1, 2, …, s-1):

function permNth(n, s) {
    var fact = [1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800, 39916800, 479001600, 6227020800, 87178291200, 1307674368000];
    var i, j;
    var p = [];
    var q = [];
    for(i=0;i<s;i++) p.push(i);
    for(i=s-1; i>=0; i--) {
        j = Math.floor(n / fact[i]);
        n -= j*fact[i];
        q.push(p[j]);
        for(;j<i;j++) p[j]=p[j+1];
    }
    return q;
}

Now, what you want merely is:

function shuffle(p) {
    var fact = [1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800, 39916800, 479001600, 6227020800, 87178291200, 1307674368000, 20922789888000];
    return permNth(Math.floor(Math.random()*fact[p.length]), p.length).map(
            function(i) { return p[i]; });
}

It should work for up to 16 elements with a little theoretical bias (though unnoticeable from a practical point of view); it can be seen as fully usable for 15 elements; with arrays containing less than 14 elements, you can safely consider there will be absolutely no bias.

Tyrannosaur

Definitely elegant! – Mongolic

Answer 32

function shuffleArray(array) {
        // Create a new array with the length of the given array in the parameters
        const newArray = array.map(() => null);

        // Create a new array where each index contain the index value
        const arrayReference = array.map((item, index) => index);

        // Iterate on the array given in the parameters
        array.forEach(randomize);
        
        return newArray;

        function randomize(item) {
            const randomIndex = getRandomIndex();

            // Replace the value in the new array
            newArray[arrayReference[randomIndex]] = item;
            
            // Remove in the array reference the index used
            arrayReference.splice(randomIndex,1);
        }

        // Return a number between 0 and current array reference length
        function getRandomIndex() {
            const min = 0;
            const max = arrayReference.length;
            return Math.floor(Math.random() * (max - min)) + min;
        }
    }
    
console.log(shuffleArray([10,20,30,40,50,60,70,80,90,100]));

Norland

This solution has no redeeming qualities, being both slow and complicated. – Syncretize

Answer 33

Just to have a finger in the pie. Here i present a recursive implementation of Fisher Yates shuffle (i think). It gives uniform randomness.

Note: The ~~ (double tilde operator) is in fact behaves like Math.floor() for positive real numbers. Just a short cut it is.

var shuffle = a => a.length ? a.splice(~~(Math.random()*a.length),1).concat(shuffle(a))
                            : a;

console.log(JSON.stringify(shuffle([0,1,2,3,4,5,6,7,8,9])));

Edit: The above code is O(n^2) due to the employment of .splice() but we can eliminate splice and shuffle in O(n) by the swap trick.

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");
shuffle(arr);
console.timeEnd("shuffle");

The problem is, JS can not coop on with big recursions. In this particular case you array size is limited with like 3000~7000 depending on your browser engine and some unknown facts.

Hendon

Answer 34

For completeness, in addition to the Durstenfeld variation of Fischer-Yates, I'd also point out Sattolo's algorithm which is just one tiny change away and results in every element changing place.

function sattoloCycle(arr) {
   for (let i = arr.length - 1; 0 < i; i--) {
      const j = Math.floor(Math.random() * i);
      [arr[i], arr[j]] = [arr[j], arr[i]];
   }
   return arr
}

The difference is in how random index j is computed, with Math.random() * i versus Math.random() * (i + 1).

Sharasharai

Answer 35

This variation of Fisher-Yates is slightly more efficient because it avoids swapping an element with itself:

function shuffle(array) {
  var elementsRemaining = array.length, temp, randomIndex;
  while (elementsRemaining > 1) {
    randomIndex = Math.floor(Math.random() * elementsRemaining--);
    if (randomIndex != elementsRemaining) {
      temp = array[elementsRemaining];
      array[elementsRemaining] = array[randomIndex];
      array[randomIndex] = temp;
    }
  }
  return array;
}

Ernieernst

Answer 36

var shuffledArray = function(inpArr){
    //inpArr - is input array
    var arrRand = []; //this will give shuffled array
    var arrTempInd = []; // to store shuffled indexes
    var max = inpArr.length;
    var min = 0;
    var tempInd;
    var i = 0;

    do{
        //generate random index between range
        tempInd = Math.floor(Math.random() * (max - min));
        //check if index is already available in array to avoid repetition
        if(arrTempInd.indexOf(tempInd)<0){
            //push character at random index
            arrRand[i] = inpArr[tempInd];
            //push random indexes
            arrTempInd.push(tempInd);
            i++;
        }
    }
    // check if random array length is equal to input array length
    while(arrTempInd.length < max){
        return arrRand; // this will return shuffled Array
    }
};

Just pass the array to function and in return get the shuffled array

Prolific

Answer 37

Considering apply it to in loco or to a new immutable array, following other solutions, here is a suggested implementation:

Array.prototype.shuffle = function(local){
  var a = this;
  var newArray = typeof local === "boolean" && local ? this : [];
  for (var i = 0, newIdx, curr, next; i < a.length; i++){
    newIdx = Math.floor(Math.random()*i);
    curr = a[i];
    next = a[newIdx];
    newArray[i] = next;
    newArray[newIdx] = curr;
  }
  return newArray;
};

Alethiaaletta

Answer 38

I see no one has yet given a solution that can be concatenated while not extending the Array prototype (which is a bad practice). Using the slightly lesser known reduce() we can easily do shuffling in a way that allows for concatenation:

var randomsquares = [1, 2, 3, 4, 5, 6, 7].reduce(shuffle).map(n => n*n);

You'd probably want to pass the second parameter [], as otherwise if you try to do this on an empty array it'd fail:

// Both work. The second one wouldn't have worked as the one above
var randomsquares = [1, 2, 3, 4, 5, 6, 7].reduce(shuffle, []).map(n => n*n);
var randomsquares = [].reduce(shuffle, []).map(n => n*n);

Let's define shuffle as:

var shuffle = (rand, one, i, orig) => {
  if (i !== 1) return rand;  // Randomize it only once (arr.length > 1)

  // You could use here other random algorithm if you wanted
  for (let i = orig.length; i; i--) {
    let j = Math.floor(Math.random() * i);
    [orig[i - 1], orig[j]] = [orig[j], orig[i - 1]];
  }

  return orig;
}

You can see it in action in JSFiddle or here:

var shuffle = (all, one, i, orig) => {
    if (i !== 1) return all;

    // You could use here other random algorithm here
    for (let i = orig.length; i; i--) {
        let j = Math.floor(Math.random() * i);
        [orig[i - 1], orig[j]] = [orig[j], orig[i - 1]];
    }

    return orig;
}

for (var i = 0; i < 5; i++) {
  var randomarray = [1, 2, 3, 4, 5, 6, 7].reduce(shuffle, []);
  console.log(JSON.stringify(randomarray));
}

Buschi

It seems that you're exchanging for too much times. With reduce you can totally perform a streaming "inside-out" Fisher-Yates that uses (acc, el) => { acc.push(el); let i = Math.floor(Math.random() * (acc.length)); [acc[i], acc[acc.length - 1]] = [acc[acc.length - 1], acc[i]]; return acc; } as the callback. (Adapted from public domain code on zhihu.) – Veronicaveronika

Answer 39

I was thinking about oneliner to paste in console. All tricks with .sort was giving wrong results, here is my implementation:

 ['Bob', 'Amy', 'Joy'].map((person) => `${Math.random().toFixed(10)}${person}`).sort().map((person) => person.substr(12));

But don't use it in production code, it's not optimal and works with strings only.

Sprint

It works with any kind of variable: array.map(e => [Math.random(), e]).sort((a, b) => a[0] - b[0]).map(e => e[1]) (but is not optimal). – Fabled

Answer 40

// Create a places array which holds the index for each item in the
// passed in array.
// 
// Then return a new array by randomly selecting items from the
// passed in array by referencing the places array item. Removing that
// places item each time though.
function shuffle(array) {
    let places = array.map((item, index) => index);
    return array.map((item, index, array) => {
      const random_index = Math.floor(Math.random() * places.length);
      const places_value = places[random_index];
      places.splice(random_index, 1);
      return array[places_value];
    })
}

Talion

Answer 41

By using shuffle-array module you can shuffle your array . Here is a simple code of it .

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

console.log(collection);

Hope this helps.

Dachy

Answer 42

d3.js provides a built-in version of the Fisher–Yates shuffle:

console.log(d3.shuffle(["a", "b", "c", "d"]));

<script src="http://d3js.org/d3.v5.min.js"></script>

d3.shuffle(array[, lo[, hi]]) <>

Randomizes the order of the specified array using the Fisher–Yates shuffle.

Pilgarlic

Answer 43

Edit: Don't use this. The result will always make the elements from the beginning closer to the middle. Who knows, maybe there's a use for this algorithm but not for completely random sorting.

Randomly either push or unshift(add in the beginning).

['a', 'b', 'c', 'd'].reduce((acc, el) => {
  Math.random() > 0.5 ? acc.push(el) : acc.unshift(el);
  return acc;
}, []);

Biradial

Answer 44

I have written a shuffle function on my own . The difference here is it will never repeat a value (checks in the code for this) :-

function shuffleArray(array) {
 var newArray = [];
 for (var i = 0; i < array.length; i++) {
     newArray.push(-1);
 }

 for (var j = 0; j < array.length; j++) {
    var id = Math.floor((Math.random() * array.length));
    while (newArray[id] !== -1) {
        id = Math.floor((Math.random() * array.length));
    }

    newArray.splice(id, 1, array[j]);
 }
 return newArray; }

Acquit

Answer 45

Rebuilding the entire array, one by one putting each element at a random place.

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

var ia= [1,2,3];
var it= 1000;
var f = (a,x,i)=>{a.splice(Math.floor(Math.random()*(i+1)),0,x);return a};
var a = new Array(it).fill(ia).map(x=>x.reduce(f,[]));
var r = new Array(ia.length).fill(0).map((x,i)=>a.reduce((i2,x2)=>x2[i]+i2,0)/it)

console.log("These values should be quite equal:",r);

Spaceman

You should explain what your code is doing, some people may not understand 1 liners of this complexity. – Ludwog

also note that due to the use of Math.round(... * i) this is biased, you want to be doing Math.floor(.. * (i+1)) instead – Cinnabar

@SamMason Probablity of getting .5 is 1:1000000000000000000 – Oily

if you use round, the probability of selecting first and last index (i.e. 0 and n) are 0.5/n, the probability of selecting any other element is 1/n (where n = a.length). this is pretty bad for short arrays – Cinnabar

@SamMason thank you for pointing the error, I have updated the answer and made a tester too – Oily

Answer 46

Community says arr.sort((a, b) => 0.5 - Math.random()) isn't 100% random!
yes! I tested and recommend do not use this method!

let arr = [1, 2, 3, 4, 5, 6]
arr.sort((a, b) => 0.5 - Math.random());

But I am not sure. So I Write some code to test !...You can also Try ! If you are interested enough!

let data_base = []; 
for (let i = 1; i <= 100; i++) { // push 100 time new rendom arr to data_base!
  data_base.push(
    [1, 2, 3, 4, 5, 6].sort((a, b) => {
      return  Math.random() - 0.5;     // used community banned method!  :-)      
    })
  );
} // console.log(data_base);  // if you want to see data!
let analysis = {};
for (let i = 1; i <= 6; i++) {
  analysis[i] = Array(6).fill(0);
}
for (let num = 0; num < 6; num++) {
  for (let i = 1; i <= 100; i++) {
    let plus = data_base[i - 1][num];
    analysis[`${num + 1}`][plus-1]++;
  }
}
console.log(analysis); // analysed result 

In 100 different random arrays. (my analysed result)

{ player> 1   2   3  4   5   6
   '1': [ 36, 12, 17, 16, 9, 10 ],
   '2': [ 15, 36, 12, 18, 7, 12 ],
   '3': [ 11, 8, 22, 19, 17, 23 ],
   '4': [ 9, 14, 19, 18, 22, 18 ],
   '5': [ 12, 19, 15, 18, 23, 13 ],
   '6': [ 17, 11, 15, 11, 22, 24 ]
}  
// player 1 got > 1(36 times),2(15 times),...,6(17 times)
// ... 
// ...
// player 6 got > 1(10 times),2(12 times),...,6(24 times)

As you can see It is not that much random ! soo... do not use this method!

---

If you test multiple times.You would see that player 1 got (number 1) so many times!
and player 6 got (number 6) most of the times!

Cystocele

Answer 47

 const arr = [
  { index: 0, value: "0" },
  { index: 1, value: "1" },
  { index: 2, value: "2" },
  { index: 3, value: "3" },
];
let shuffle = (arr) => {
  let set = new Set();
  while (set.size != arr.length) {
    let rand = Math.floor(Math.random() * arr.length);
    set.add(arr[rand]);
  }
  console.log(set);
};
shuffle(arr);

Perdurable

Answer 48

For more flexibility you can add another parameter. In this case, you can take a random array from an array and specify the length of the new array:

  function shuffle(array, len = array.length) {
        for (let i = array.length - 1; i > 0; i--) {
            let j = Math.floor(Math.random() * (i + 1));
            [array[i], array[j]] = [array[j], array[i]];
        }

        return array.slice(0, len);
    }

Brooklime

There’s an optimization possible when you muddy the signature of shuffle to include a length, but this implementation doesn’t do it and is strictly worse than shuffle(array).slice(0, len). – Syncretize

Answer 49

Randomize array without duplicates

    function randomize(array){
        let nums = [];
        for(let i = 0; i < array.length; ++i){
            nums.push(i);
        }   
        nums.sort(() => Math.random() - Math.random()).slice(0, array.length)
        for(let i = 0; i < array.length; ++i){
            array[i] = array[nums[i]];
        }
    }
    randomize(array);

Amuse

Answer 50

Use forEach and Math.random()

var data = ['a','b','c','d','e']
data.forEach( (value,i) => {
   var random = Math.floor(Math.random() * data.length)
   var tmp = data[random]
   data[random] = value
   data[i] = tmp
})
console.log(data)

Talbert

I think there is potential for the random number to be the same and so data[random] could contain duplicates. – Computer

Answer 51

Shuffling array using recursion JS.

Not the best implementation but it's recursive and respect immutability.

const randomizer = (array, output = []) => {
    const arrayCopy = [...array];
    if (arrayCopy.length > 0) {    
        const idx = Math.floor(Math.random() * arrayCopy.length);
        const select = arrayCopy.splice(idx, 1);
        output.push(select[0]);
        randomizer(arrayCopy, output);
    }
    return output;
};

Yuriyuria

Answer 52

I like to share one of the million ways to solve this problem =)

function shuffleArray(array = ["banana", "ovo", "salsicha", "goiaba", "chocolate"]) {
const newArray = [];
let number = Math.floor(Math.random() * array.length);
let count = 1;
newArray.push(array[number]);

while (count < array.length) {
    const newNumber = Math.floor(Math.random() * array.length);
    if (!newArray.includes(array[newNumber])) {
        count++;
        number = newNumber;
        newArray.push(array[number]);
    }
}

return newArray;

}

Wenda

And have you tried this with a million elements? – Bimetallism

I would expect that this is O (n ^ 2). That's why I asked. – Bimetallism

I made it for a small collection, so I didn't worry about it. The collection I was getting was, for sure, maximum 20 items. good observation! – Wenda

Yes, there's always a question of when to bother with any optimizations. Often, when working with small amounts of data, it's just silly. But several answers here already posted variants of the most common efficient shuffle (Fischer-Yates) and they are not much more complex than this. I'm not suggesting that there's anything wrong here, only that you might want to avoid this for large arrays. – Bimetallism

Answer 53

here with simple while loop

 function ShuffleColor(originalArray) {
        let shuffeledNumbers = [];
        while (shuffeledNumbers.length <= originalArray.length) {
            for (let _ of originalArray) {
                const randomNumb = Math.floor(Math.random() * originalArray.length);
                if (!shuffeledNumbers.includes(originalArray[randomNumb])) {
                    shuffeledNumbers.push(originalArray[randomNumb]);
                }
            }
            if (shuffeledNumbers.length === originalArray.length)
                break;
        }
        return shuffeledNumbers;
    }
const colors = [
    '#000000',
    '#2B8EAD',
    '#333333',
    '#6F98A8',
    '#BFBFBF',
    '#2F454E'
]
ShuffleColor(colors)

Horta

Answer 54

This leaves the original array alone.

It builds an array of keys, duplicates a value into a new array using a random key and removes the key from the keys array.

arr = [10,11,12,13,14,15,16,17,18,19,20];
rnd = [];
keys = arr.map((a,b)=>b);
while(keys.length){
  rnd.push(arr[keys.splice(Math.floor(Math.random()*keys.length ),1)]);
}
console.log(rnd);

To write out the while loop a bit for clarity:

while(keys.length){

    // pick a random position in the keys array
    rndkey = Math.floor(Math.random()*keys.length)

    //remove a key from the keys array
    curkey = keys.splice(rndkey,1)

    // use the key to get a value from the array
    value = arr[curkey]

    // put the value in the new array
    rnd.push(value);
}

You often want to shuffle an array often. If it is enormous you could build the keys array one time then .slice() it for each use.

Wariness

Answer 55

Using sort method and Math method :

var arr =  ["HORSE", "TIGER", "DOG", "CAT"];
function shuffleArray(arr){
  return arr.sort( () => Math.floor(Math.random() * Math.floor(3)) - 1)  
}

// every time it gives random sequence
shuffleArr(arr);
// ["DOG", "CAT", "TIGER", "HORSE"]
// ["HORSE", "TIGER", "CAT", "DOG"]
// ["TIGER", "HORSE", "CAT", "DOG"]

Franconian

This isn't properly random. See other comments on similar answers that use random() inside sort(). – Tseng

Answer 56

//doesn change array
Array.prototype.shuffle = function () {
    let res = [];
    let copy = [...this];

    while (copy.length > 0) {
        let index = Math.floor(Math.random() * copy.length);
        res.push(copy[index]);
        copy.splice(index, 1);
    }

    return res;
};

let a=[1, 2, 3, 4, 5, 6, 7, 8, 9];
console.log(a.shuffle());

Untutored

Answer 57

$=(m)=>console.log(m);

//----add this method to Array class 
Array.prototype.shuffle=function(){
  return this.sort(()=>.5 - Math.random());
};

$([1,65,87,45,101,33,9].shuffle());
$([1,65,87,45,101,33,9].shuffle());
$([1,65,87,45,101,33,9].shuffle());
$([1,65,87,45,101,33,9].shuffle());
$([1,65,87,45,101,33,9].shuffle());

L

This is very bad as the elements have a high probability of staying near their original position or barely moving from there. – Hussy

If it bad , chain it twice or more : array.shuffle().shuffle().shuffle() – L

Repeating the call slightly reduces the probabilities of getting very similar results, but it doesn't make it a true random shuffle. In the worst case scenario, even an infinite number of calls to shuffle could still give the exact same array we started with. The Fisher-Yates algorithm is a much better and still efficient choice. – Hussy

Not the same awful answer again, please. – Commodore

Answer 58

A functional solution using 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])

Vara