Math.round() versus Math.floor()

It's important to understand that when working with values generated by Math.random(), using Math.round() is not the ideal choice. Instead, opt for Math.floor() without the need for a -1 correction on the length. This is because Math.random() outputs a value between >= 0 and < 1.

To illustrate this concept better, consider an array with three elements. As explained in vihan1086's insightful answer, the elements are indexed as 0, 1, and 2. The goal is to have an equal probability of selecting any of these values from the array.

Using

Math.round( Math.random() * array.length - 1 )

means multiplying Math.random() by 2 for an array length of 3. This yields a value n ranging from >= 0 to < 2. When rounded to the nearest integer:

If n is >= 0 and < .5, it rounds to 0.
If n is >= .5 and < 1.5, it rounds to 1.
If n is >= 1.5 and < 2, it rounds to 2.

However, due to the unequal ranges, the outcome skews towards getting 1 more often than the other indices. To maintain equal chances, multiply Math.random() by the array length of 3, resulting in a floor operation:

Math.floor( Math.random() * array.length )

.

This ensures each index has an equal probability of being selected from the array.

Simplicity is Key

Here's a suggestion: simplify the process by breaking down complex expressions into straightforward functions. For instance, here's a clear method for choosing a random element from an array:

// Generate a random integer within the range of 0 up to n - 1
function randomInt( n ) {
    return Math.floor( Math.random() * n );
}

// Retrieve a random element from an array
function randomElement( array ) {
    return array[ randomInt(array.length) ];
}

By following this approach, the code becomes more manageable. Now you can easily fetch a random element from an array simply by calling randomElement(array).

var examples = [ 1, 2, 3, 56, "foxy", 9999, "jaguar", 5.4, "caveman" ];
var example = randomElement( examples );
console.log( example );

As demonstrated, structuring the code in this manner eliminates the need for repetitive mathematical calculations and promotes clarity in the implementation of retrieving random elements from arrays.

You're examining basic multiplication and discovering an error in your code. Instead of referencing something called 'mathematics' that was not mentioned, it should be pointing to the array 'examples' that you are choosing from:

var example = examples[Math.round(Math.random() * (examples.length-1))];
                                                     ^^

Essentially, you are multiplying a random number by the length of the array. For instance, if there are 50 items in your array, you multiply the random number by 50, resulting in a range from 0 to 50.

This process scales all smaller random numbers (from 0 to 1) up by 50x, which expands their range to approximately (0 to 50) with similar randomness. The final step is rounding to the closest whole number, providing a random index within your array's range from 1 to n, allowing you to select the element using element[thatnumber].

Example demonstrations:

The function Math.random() produces values between 0 and 1, with rare occurrences of 0:

Math.random()
0.11506261994225964
Math.random()
0.5607304393516861
Math.random()
0.5050221864582
Math.random()
0.4070177578793308
Math.random()
0.6352060229006462

Multiplying these values by a factor will scale them up; 1 x 10 = 10 implies that Math.random() * 10 results in random numbers between 0 and 10.

Math.random() *n produces values between 0 and n:

Math.random() * 10
2.6186012867183326
Math.random() * 10
5.616868671026196
Math.random() * 10
0.7765205189156167
Math.random() * 10
6.299650241067698

Subsequently, Math.round(number) removes decimals and provides the nearest whole number between 1 and 10:

Math.round(Math.random() * 10)
5

The next step involves selecting the corresponding element:

examples[  Math.round(Math.random() * 10)  ];

To account for indexing starting at 0 and concluding at length-1, you can use .length-1 as explained by @vihan1086 regarding array indexing.

This method may not be optimal for ensuring true randomness - notably, it decreases the likelihood of selecting the first and last elements. A more efficient alternative, as pointed out by @Michael Geary's answer, avoids Math.round() and eliminates the need for length-1.

Although this question is old, I have a new and concise solution for obtaining a random item from an array.

The Power of Math.random

Math.random generates a number between 0 and 1 (not including 1).

Unleash the Bitwise Not Operator ~

The bitwise not operator flips the bits of the provided value, resulting in its opposite:

a = 5
~a // -5

It disregards decimal points, as shown here:

a = 5.95
~a // -5

This behavior resembles that of Math.floor, but without returning negative values.

Applying Double Operators

The double negation with the logical operator ! coerces to a boolean type: !!null // false. When applied to numbers, it acts similarly by flooring a number: ~~5.999 // 5.

As a result,

In Short;

getRandom = (arr, len = arr.length) => arr[~~(Math.random() * len)]

For example:

getRandom([1,2,3,4,5]) // outputs a random item between 1 and 5