In this article we'll be exploring how we can shuffle an array of items in multiple different ways using TypeScript, or JavaScript should you prefer.


  • An understanding of TypeScript or JavaScript
  • A basic understanding of For Loops and Arrays

The following examples are written in TypeScript, but they work in exactly the same way using plain JavaScript. You just simply need to remove the :type syntax from all function parameters.

Method 1: Fisher-Yates Sorting Algorithm

This algorithm's basic premise is to iterate over the items, swapping each element in the array with a randomly selected element from the remaining un-shuffled portion of the array.

Let's take a look at this in practice, as it'll help you visualise it better:

// declare the function 
const shuffle = (array: string[]) => { 
  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]]; 
  return array; 
// Usage 
const myArray = ["apple", "banana", "cherry", "date", "elderberry"]; 
const shuffledArray = shuffle(myArray); 



First, you create a for loop. This will allow you to loop over each item in the array, swapping its position with another item in the array.

You then create the i variable assigning it the value of length of the array - 1.

You do this because we're starting at the last element of the array, and all array indexes start at 0 – so the last index would be 4 (as there are 5 items in the array).

If you were to try and access myArray[i] with i equalling 5 (the length) it would throw an exception stating there is no item at index 5. So we subtract 1 from the length.

By starting from the last element and working your way backwards, you guarantee that elements towards the end of the array have an equal chance of being swapped with any other element.

If you were to shuffle the array from the beginning to the end, the elements towards the beginning of the array would have a higher chance of being swapped multiple times, leading to a biased or uneven shuffle.‌‌‌‌ You then create a j variable which will be used for your index pointer for the big swap.

You then assign the array at index i to the array at index j, and visa versa. This swaps the values and shuffles them up for each item in the array.

Array Destructuring Assignment Explained

The syntax [array[i], array[j]] = [array[j], array[i]] is called an array destructuring assignment. It allows for the swapping of values between two variables or array elements without the need for a temporary variable.

Here's how the array destructuring assignment works in the context of shuffling an array using the Fisher-Yates shuffle algorithm:

  • array[i] and array[j] represent two elements in the array that need to be swapped.
  • [array[j], array[i]] creates a temporary array containing the values of array[j] and array[i], but in reverse order.
  • By assigning [array[j], array[i]] to [array[i], array[j]], the values of array[j] and array[i] are swapped in place.

You can learn more about array destructuring here.‌‌‌‌ If we were to print out the steps of the function step by step we would would get the following:

// starting array 
["apple", "banana", "cherry", "date", "elderberry"]; 

//1st Iteration - Swap elderberry with date 
i = 4; // elderberry 
j = 3; // date 
[("apple", "banana", "cherry", "elderberry", "date")]; 

// 2nd Iteration -  Swap elderberry with apple 
i = 3; // 
elderberry j = 0; // apple 
[("elderberry", "banana", "cherry", "apple", "date")]; 

// 3rd Iteration - Swap cherry with banana 
i = 2; // cherry 
j = 1; // banana 
[("elderberry", "cherry", "banana", "apple", "date")]; 

// 4th Iteration - Swap cherry with itself (stays where it is) 
i = 1; // cherry 
j = 1; // cherry 
[("elderberry", "cherry", "banana", "apple", "date")]; 

And there you have it – we have shuffled the array using the Fisher-Yates algorithm.

Method 2: Using the sort() Method with a Random Comparison Function

If you're not familiar with the JS sort function, I've written a tutorial on how to use this which you can find here.

const shuffle = (array: string[]) => { 
    return array.sort(() => Math.random() - 0.5); 

// Usage 
const myArray = ["apple", "banana", "cherry", "date", "elderberry"]; 
const shuffledArray = shuffle(myArray); 

This is a simple sorting() function that returns a random number, which would either work out as a negative, 0, or positive number.‌‌‌‌The sort() method internally compares pairs of elements in the array and determines their relative order based on the return value of the comparison function.

  • If the comparison function returns a negative value, the first element is considered smaller and should be placed before the second element in the sorted array.
  • If the comparison function returns a positive value, the first element is considered larger and should be placed after the second element in the sorted array
  • If the comparison function returns 0, the relative order of the elements remains unchanged.

What does Math.random() return?

When you call Math.random() it generates a pseudo-random number, because as you may know, nothing is really random haha.‌‌‌‌"Pseudo-random" means that the numbers generated appear to be random but are actually determined by a deterministic algorithm (which differs between JS engine implementations).‌‌‌‌The number it returns will always be a floating number, between 0 and 1. Floating numbers (commonly referred to as "floats") are numbers which can be positive or negative and can have a fractional part. Examples of floating-point numbers include 3.14, -0.5, 1.0, 2.71828, and so on.

Why do you subtract 0.5 from the result of Math.random()?

By subtracting 0.5 from the result of Math.random(), you introduce a random value between -0.5 and 0.5. This random value will cause the comparison function to return negative, positive, or zero values in a random manner for different pairs of elements. Consequently, the sort() method shuffles the array randomly.

Method 3: Using the JS Function

The .map() function allows you to iterate over each element of an array and transform them into new values based on a provided mapping function. The map() function returns a new array with the transformed values, leaving the original array unchanged.

const shuffle = (array: string[]) => { 
    return => ({ sort: Math.random(), value: a }))
        .sort((a, b) => a.sort - b.sort)
        .map((a) => a.value); 

// Usage 
const myArray = ["apple", "banana", "cherry", "date","elderberry"]; const shuffledArray = shuffle(myArray); 

Here, you loop over the array and use the same Math.random() function as you did in the above example within the map() function, returning an array of the objects with a sort number, and a value.‌‌‌‌You can then use the sort() function to sort the array based on these values, before calling the map() function again to create an array of values (that is, the string names).

const shuffle = (array: string[]) => { 
  const shuffled = array.slice(); 
  let currentIndex = shuffled.length; 
  let temporaryValue, randomIndex; 
  while (currentIndex !== 0) { 
    randomIndex = Math.floor(Math.random() * currentIndex); 
    currentIndex -= 1; 
    temporaryValue = shuffled[currentIndex]; 
    shuffled[currentIndex] = shuffled[randomIndex]; 
    shuffled[randomIndex] = temporaryValue; 
  return shuffled; 

// Usage 
const myArray = ["apple", "banana", "cherry", "date", "elderberry"]; const shuffledArray = shuffle(myArray); 


I'd recommend the Fisher-Yates algorithm method, as it is has a low time complexity, as its all dependent on the size of the array. Its time complexity can be seen as O(n), which implies that doubling the input size will roughly double the execution time. Similarly, if the input size is halved, the execution time will be approximately halved as well.

Without going into too much detail:

  • O represents the order of growth or complexity class.
  • n refers to the size of the input, typically represented by the variable n.

Meaning that the complexity of the function changes as the n (input) changes in size – for example: Complexity x 2 (2 items in array) vs Complexity x 10 (10 items in array). So the larger the array the larger the complexity and time taken to shuffle.

This is worth noting when shuffling large arrays. It could be worth looking at other methods, or perhaps chunking the array and running the shuffling in parallel before piecing it back together.

This method also allows for easier shuffling of any type of array, not just string[] too. It would also work very nicely when using TypeScript generics. This allows for any type of array to be passed to the function, and shuffled.

const shuffle = <T>(array: T[]) => { 
  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]]; 
  return array; 

const strings = ["apple", "banana", "cherry", "date", "elderberry"]; 
const users = [ { name: "John", surname: "Doe" }, { name: "Jane", surname: "Doe" }];

const shuffledArray = shuffle(strings); 
const shuffledObjects = shuffle(users); 


I hope you this found this article useful, and have learnt how to easily shuffle an array of items. You could use this for multiple use cases such as:

  • Shuffle a playlist of songs
  • Shuffling a list of team members to determine a rota system
  • Creating a quiz of random questions / order-randomising data samples, for example customer reviews / feedback.

As always feel free to follow me on Twitter @gweaths.