Core Math Methods for Randomization

The Math object provides several essential functions for handling numerical operations, particularly when dealing with randomness and rounding.

• Math.ceil(x): Rounds a number upward to the nearest integer.
• Math.floor(x): Rounds a number downward to the nearest integer.
• Math.round(x): Rounds a number to the nearest integer (standard rounding).
• Math.random(): Produces a floating-point number in the range [0, 1), meaning 0 is inclusive and 1 is exclusive.

Creating Random Integers within a Range

To generate random integers for tasks like verification codes or selecting list items, specific combinations of Math methods are required. Simply using Math.random() yields a decimal, so transformation is necessary.

Consider the following utility function designed to handle flexible arguments:

function generateRandomInteger(lower, upper) {
    if (arguments.length === 1) {
        // Generates 1 to lower
        return Math.floor(Math.random() * lower) + 1;
    } 
    if (arguments.length === 2) {
        // Generates lower to upper (inclusive)
        return Math.floor(Math.random() * (upper - lower + 1)) + lower;
    }
    return 0;
}

Logic Breakdown

Since Math.random() outputs values from 0 up to (but not including) 1, multiplying this result scales the range. For example, Math.random() * 5 produces values in [0, 5).

To obtain whole numbers, rounding functions are applied:

• Math.floor() and parseInt() truncate decimals (round down).
• Math.ceil() rounds up.
• Math.round() rounds to the nearest whole number.

Generating [1, max]:

Math.floor(Math.random() * max) + 1;
Math.ceil(Math.random() * max);

Generating [0, max]:

Math.floor(Math.random() * (max + 1));

Generating [min, max]: The standard formula ensures an equal probability distribution across the range:

Math.floor(Math.random() * (max - min + 1)) + min;

Parsing Strings to Integers

The global parseInt() function converts string arguments into integers.

Basic Behavior

Whitespace at the beginning of the string is ignored. If the input is not a string, it is coerced into one before parsing.

parseInt('  456') // 456
parseInt(78.9)    // 78 (converted to '78.9' then parsed)

Parsing stops when a non-numeric character (valid for the specified radix) is encountered. The function returns the value parsed up to that point.

parseInt('100px')   // 100
parseInt('25em')    // 25
parseInt('50%')     // 50

If the first character cannot be converted to a number, NaN is returned.

parseInt('xyz') // NaN
parseInt('.')   // NaN

Radix Conversion

parseInt accepts a second argument specifying the radix (base) between 2 and 36. This allows conversion from binary, hexadecimal, or other bases to decimal.

parseInt('1010', 2) // 10 (Binary)
parseInt('1A', 16)  // 26 (Hexadecimal)
parseInt('10', 8)   // 8 (Octal)

If the radix is omitted, modern engines default to 10, unless the string starts with 0x (hexadecimal). Leading zeros generally do not trigger octal parsing in strict mode, though legacy behavior varies.

Invalid radices (outside 2-36) or characters invalid for the specified radix result in NaN or partial parsing.

parseInt('12', 37)  // NaN
parseInt('25', 2)   // 2 (stops at '5' which is invalid in binary)

Parsing Strings to Floats

The parseFloat() function converts a string into a floating-point number. It handles scientific notation and ignores leading whitespace.

parseFloat('3.14159')      // 3.14159
parseFloat('2.5e3')        // 2500
parseFloat('  10.5 degrees') // 10.5

Like parseInt, parsing stops at the first invalid character. However, parseFloat does not accept a radix parameter.

Comparison with Number()

parseFloat behaves differently from the Number() constructor when handlign invalid trailing characters or non-string types.

parseFloat('100px') // 100
Number('100px')     // NaN

parseFloat('')      // NaN
Number('')          // 0

parseFloat(null)    // NaN
Number(null)        // 0

parseFloat is more lenient when extracting numeric values from strings containing units or extra text, whereas Number() requires the entire string to be a valid numeric literal.