I used a code I found on this site to access an array of string values. I changed the variable names, but other than that, the code remains the same.

var rand = array[Math.floor(Math.random() * array.length)];

It works, and as I understand it, (Math.random() * array.length) is the area which generates the random number itself, so why is Math.floor required? I am clearly not understanding something quite obvious here.

I used a code I found on this site to access an array of string values. I changed the variable names, but other than that, the code remains the same.

var rand = array[Math.floor(Math.random() * array.length)];

It works, and as I understand it, (Math.random() * array.length) is the area which generates the random number itself, so why is Math.floor required? I am clearly not understanding something quite obvious here.

• javascript
• arrays
• math
• random
• floor

• Math.random returns a floating number and array elements indexes are actually integers. Math.floor rounds the float down to the nearest integer. – kind user Commented Apr 6, 2017 at 22:58

3 Answers 3

Math.floor returns a whole number, while Math.random() will return a float between 0 and 1.

To access an item in an array, like rand[0], you need to have a whole number. You cannot access an item in array with rand[1.43].

That little line of code is going to access a random item in an array by generating a random float from zero to the array's length, and rounding it to its nearest whole number with Math.floor

Because there are no fractional array elements

const array = [123, 456];
console.log(array[0.5]);

The code above prints undefined because there is no 0.5 element. There is a 0 element and a 1 element but no 0.5 element

So, to choose a random element with Math.random() which returns a number between 0 and 1 (but not 1) you have to convert to an integer.

JavaScript arrays are not like arrays in most other languages. They're actually more like augmented objects. They act like arrays in that you can get the length (array.length) and call things like push,pop,concat,shift,unshift but you can also add properties

array = [4, 5, 6];
array["foo"] = "bar"
console.log(Object.keys(array));

Prints

[
  "0",
  "1",
  "2",
  "foo"
]

Which explains why the Math.random without the Math.floor would fail. From the semantic point of view of JavaScript an array is just an object with properties named 0, 1, 2, 3 etc. Of course under the hood that's not what JavaScript does as it would be too slow to implement arrays that way but for the most part arrays act like they are actually just an object with properties named '0', '1', '2' and it's perfectly valid to have properties named '0.00012' etc.

Note, it would actually be faster to do this

const rand = array[Math.random() * array.length | 0];

The | 0 is a binary or of 0 which the JavaScript spec effectively says the result is converted to an integer before the | happens. Note that | 0 is not the same as Math.floor. | 0 rounds toward 0 whereas Math.floor rounds down.

         | 0   Math.floor         
------+------+------------
  2.5 |   2  |   2
  1.5 |   1  |   1
  0.5 |   0  |   0
 -0.5 |   0  |  -1
 -1.5 |  =1  |  -2
 -2.5 |  -2  |  -3

var array = [10,6,2,11,0];
console.log(array[3]); // output = 11

//Math.random() generates random floating point numbers from 0(inclusive) to 1(exclusive).
//Math.random() * array.length will generate all random numbers from 0 to array.length(exclusive)

var randomNumber = Math.random();
console.log("randomNumber = " + randomNumber); // Say, output = 0.8604458676303853
console.log("randomNumber * array.length = " + randomNumber * array.length); // Say, output = 4.3022293381519265

//To access any element in the array you will need indices starting from 0 to array.length(exclusive)

//var rand = array[randomNumber * array.length];
//Will give error as array cannot access a floating point index

console.log("Math.floor(randomNumber * array.length) = " + Math.floor(randomNumber * array.length)); // Say, output = 4

//Finally,
var rand = array[Math.floor(Math.random() * array.length)];
console.log("rand = ", rand);

The floor function will do the following thing for you.

1. It will first round the floating number so that it is a valid index to access.

Overall, Math.floor(Math.random() * array.length) will take care that the maximum index value is always array.length - 1

The reason is that the max number we will get will always be slightly less than array.length).
So even if Math.random() generates 0.999 and you multiply it with array.length = 5.
Thus, 0.999 * 5 = 4.995 and floor of (4.995) = 4. Constraints satisfied :)