What does Math.random() do in this JavaScript snippet?

Question

I'm watching this Google I/O presentation from 2011 https://www.youtube.com/watch?v=M3uWx-fhjUc

At minute 39:31, Michael shows the output of the closure compiler, which looks like the code included below.

My question is what exactly is this code doing (how and why)

// Question #1 - floor & random? 2147483648?
Math.floor(Math.random() * 2147483648).toString(36);

var b = /&/g, 
    c = /</g,d=/>/g, 
    e = /\"/g, 
    f = /[&<>\"]/;

// Question #2 - sanitizing input, I get it... 
// but f.test(a) && ([replaces]) ?
function g(a) {
   a = String(a);

   f.test(a) && (
      a.indexOf("&") != -1 && (a = a.replace(b, "&amp;")), 
      a.indexOf("<") != -1 && (a = a.replace(c, "&lt;")), 
      a.indexOf(">") != -1 && (a = a.replace(d, "&gt;")),
      a.indexOf('"') != -1 && (a = a.replace(e, "&quot;"))
   );

   return a;
};

// Question #3 - void 0 ???    
var h = document.getElementById("submit-button"),
    i,
    j = {
       label: void 0,
       a: void 0
    };
i = '<button title="' + g(j.a) + '"><span>' + g(j.label) + "</span></button>";
h.innerHTML = i;

Edit

Thanks for the insightful answers. I'm still really curious about the reason why the compiler threw in that random string generation at the top of the script. Surely there must be a good reason for it. Anyone???

Answer 1

1) This code is pulled from Closure Library. This code in is simply creating random string. In later version it has been replaced by to simply create a large random integer that is then concatenated to a string:

'closure_uid_'  + ((Math.random() * 1e9) >>> 0)

This simplified version is easier for the Closure Compiler to remove so you won't see it leftover like it was previously. Specifically, the Compiler assumes "toString" with no arguments does not cause visible state changes. It doesn't make the same assumption about toString calls with parameters, however. You can read more about the compiler assumptions here:

https://code.google.com/p/closure-compiler/wiki/CompilerAssumptions

2) At some point, someone determined it was faster to test for the characters that might need to be replaced before making the "replace" calls on the assumption most strings don't need to be escaped.

3) As others have stated the void operator always returns undefined, and "void 0" is simply a reasonable way to write "undefined". It is pretty useless in normal usage.

Answer 2

1) I have no idea what the point of number 1 is.

2) Looks to make sure that any symbols are properly converted into their corresponding HTML entities , so yes basically sanitizing the input to make sure it is HTML safe

3) void 0 is essentially a REALLY safe way to make sure it returns undefined . Since the actual undefined keyword in javascript is mutable (i.e. can be set to something else), it's not always safe to assume undefined is actually equal to an undefined value you expect.