The **Fisher-Yates algorithm** is named after Ronald Fisher and Frank Yates.

Itâ€™s an algorithm used to shuffle a sequence of finite items, like an array for instance.

The algorithm works by swapping a random element from your array with the last element in that array repeatedly.

Here are the steps taken by the algorithm to shuffle an array:

- Pick a random index number between the first and the last index position in your array
- Swap the element at the random index with the last index element
- Repeat step one, but leave the last index out of the random selection
- Stop the shuffle when only the starting index is left in the random selection

Each time step one is repeated, the last index of the previous repetition is **excluded** from the selection.

Hereâ€™s a visualization of how it works:

Letâ€™s learn how to create a Fisher-Yates algorithm to shuffle JavaScript arrays.

First, create an array of numbers to test the algorithm later.

You also need to store the array length under a variable for easier access later. Letâ€™s reference the array length from the `i`

variable:

```
let arr = [1, 2, 3, 4, 5, 6, 7];
let i = arr.length;
```

Next, create a loop using the `while`

statement that will run as long as the `i`

variable is greater than `0`

:

```
let arr = [1, 2, 3, 4, 5, 6, 7];
let i = arr.length;
while (--i > 0) {
// shuffle algorithm here
}
```

The `i`

variable will be decremented by one each time the `while`

statement is repeated. This will reflect the Fisher-Yates algorithm where the last index is removed from the loop once swapped.

Inside the `while`

statement body, generate a random number for the index from `0`

to `i`

as shown below:

```
let arr = [1, 2, 3, 4, 5, 6, 7];
let i = arr.length;
while (--i > 0) {
let randIndex = Math.floor(Math.random() * (i + 1));
}
```

Finally, you need to swap the elements between `randIndex`

and `i`

.

When the `while`

statement stops, print the `arr`

variable to see the result.

Note that the `console.log()`

result will vary each time you run the code:

```
let arr = [1, 2, 3, 4, 5, 6, 7];
let i = arr.length;
while (--i > 0) {
let randIndex = Math.floor(Math.random() * (i + 1));
[arr[randIndex], arr[i]] = [arr[i], arr[randIndex]];
}
console.log(arr); // result will vary
```

And thatâ€™s how you shuffle an array using the Fisher-Yates algorithm!

You can create a custom function named `fyShuffle`

to reuse the algorithm each time you need to shuffle an array:

```
function fyShuffle(arr) {
let i = arr.length;
while (--i > 0) {
let randIndex = Math.floor(Math.random() * (i + 1));
[arr[randIndex], arr[i]] = [arr[i], arr[randIndex]];
}
return arr;
}
```

The Fisher-Yates algorithm runs in `O(N)`

time complexity.

The time needed to execute the algorithm rise in proportion to the number of items that need to be shuffled, so itâ€™s not recommended for very large arrays.

Feel free to use the `fyShuffle()`

function above in your JavaScript project when you need it.

Besides the Fisher-Yates algorithm, you can also shuffle JavaScript arrays using the `sort()`

method as explained here:

Shuffle an array in JavaScript

**Related articles:**