Argthtjtr

Math.random() returns a number between 0 and 1 (exclusive). We're using 0.5 because it is the mean value.

Array.sort() sorts the parameters based on the return value. So, 0.5 - Math.random() will yield either positive or negative value with equal probability. Hence, it will sort the parameters randomly.

How it really works

• If the return value of Array.sort is positive, then the index of the
  first parameter will be higher than that of the second.


• If it is negative, then the index of the second parameter will be
  higher than that of the first.


• And, if it is 0, then do nothing.

Math.random() return random value between 0 to 1 (0 is included but 1 is excluded).
So 0.5 act as mid point. If use use value like greater than 1 or less 0 than it will always be either true or false.
So for this reason 0.5 is used.

You can read more here about Math.random()

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random

Let's understand it bit more with examples

var as = ["max","jack","sam"];  

var s = as.sort(func);  



function func(a, b) {  

  return 0.5 - Math.random();

}  



console.log(s);

This is what you get when you use value greater than 1

var as = ["max","jack","sam"];  

var s = as.sort(func);  



function func(a, b) {  

  return 1 - Math.random();

}  



console.log(s);

This is what happens when you use value less than 0

var as = ["max","jack","sam"];  

var s = as.sort(func);  



function func(a, b) {  

  return -1 - Math.random();

}  



console.log(s);

P.S :-

1. Try printing output from all the above condition you will see that last two condition will always return either true or false from function. so you will not get a random sorting.




2. Now talk about any value from 0 to 0.99 you can use any value but 0.5 will serve your purpose best.Because it's a middle point you're most likely to get best answer.

Math.random returns a number between 0 and 1.

Sorting function use the return value x as the following :

• x == 0 : Same value, can order "how it wants"




• x < 0 : the first object is less than the second one, therefore its index in the sorted array will be less than the other's




• x > 0 same as x < 0 but the other way around

Since Math.random returns a number between 0 and 1 and we want to also get negative numbers, we must subtract some value.
Here 0.5 - Math.random() would give a number between 0.5 and -0.5

If you call the sort method with a function parameter is called several times. This function should accept two parameters (let's call the first A and the second B) Each time it should return a value:

1. Less than zero, if A < B


2. Equal to zero, if A = B


3. Greater the zero, if A > B

So in this example we need random return values that evenly distribute negative and positive values. Since Math.random() returns a value between 0 and 1, 0.5 - Math.random() will return values between -0.5 and 0.5, which meets the requirements.

If you just want to nudge the elements near their starting positions in a random way, sure, use sort with random, but in most cases, that's not what you want. You want to thoroughly shuffle an array, completely randomize the position of every element. And for that random in the built-in sort function is a terrible practice, because it is biased towards the initial state, meaning that the elements in the "shuffled" array will tend to stay near their positions (those that were near the beginning have the high probability of staying near the beginning, etc...). The bigger the size the array grows, the less it gets shuffled.

Here is the proof: Is it correct to use JavaScript Array.sort() method for shuffling?

And here is the function for shuffling arrays I use most of the time. It thoroughly randomizes the position of every element.

function shuffle(arr) { // randomly rearanges the items in an array

  const result = ;

  for (let i = arr.length-1; i >= 0; i--) {

    // picks an integer between 0 and i:

    const r = Math.floor(Math.random()*(i+1));   // NOTE: use a better RNG if cryptographic security is needed

    // inserts the arr[i] element in the r-th free space in the shuffled array:

    for(let j = 0, k = 0; j <= arr.length-1; j++) {

      if(result[j] === undefined) {

        if(k === r) {

          result[j] = arr[i];    // NOTE: if array contains objects, this doesn't clone them! Use a better clone function instead, if that is needed. 

          break;

        }

        k++;

      }

    }

  }

  return result;

}