Verify number greater than 50 million

To write it shorter:

if (numero > 5e7) {
    //...
}

That's it 5 * 10^7
_{(or " a 5 followed by 7 zeros ")} .

• Reference: Floating Point Literals .

And, no, no, no, no, no, no!!! Don't use regex for something as simple as this. It's going to turn a trivial statement into an elephant trying to eat a peanut through the keyhole... For the curious, the regex would be /^0*(?:(?:[6-9]|[1-5]\d|5(?=0*[1-9])))\d{7}/, but don't use it, much less say I wrote it.

• And this is not just to repeat what everyone says. Using a regular expression would make it ~150 times slower (it varies for each case). In intensive code, it would add delays, taking 1 more second every ~4e8 iterations.

  Compare in: JSPerf .

As a contribution to Mariano 's and Larry U 's answers , I add a possible solution, obviously not so elegant.

var X = 51000000;

if (X > (1000000 << 5) + (1000000 << 4) + (1000000 << 1)){
  console.log("X es mayor a 50 millones");
}
else{
  console.log("X es menor a 50 millones");
}

Using bit shifts , I generate the following numbers:

(1000000 << 5)  =  32000000
(1000000 << 4)  =  16000000
(1000000 << 1)  =   2000000

Which when added together give 50000000. It can be used to compare and determine if the number is less or greater.

Update

I have made a comparison regarding the speed with which these instructions could be executed, in relation to @Ruben's comment:

var t0 = performance.now();

/* Codigo */

var X = 51000000;

if (X > (1000000 << 5) + (1000000 << 4) + (1000000 << 1)){
  console.log("X es mayor a 50 millones");
}
else{
  console.log("X es menor a 50 millones");
}

/* Fin Codigo*/

var t1 = performance.now();

console.log("Tardo: " + (t1 - t0) + " milisegundos.");

var t0 = performance.now();

/* Codigo */

var X = 51000000;

if (X > 5e7) {
  console.log("X es mayor a 50 millones");
} else {
  console.log("X es menor a 50 millones");
}

/* Fin Codigo*/

var t1 = performance.now();

console.log("Tardo: " + (t1 - t0) + " milisegundos.");

Conclusion: Mariano's response is more efficient, with respect to execution speed, as can be seen in these examples.

The comparison can be made in binary, or in any other base.

Using the method toString, passing a base number as an argument, that is, toString(base), we can compare the number in base 36, which is the maximum allowed by the method.

In this case, if the string has a length equal to that of the string tro8w, which is 50 million in base 36, and also, if it is greater alphabetically than that string, or if it has a greater length than that of the string, we have to return true_

function es_mayor_a_50_millones(valor)
{
  var b36=valor.toString(36)
  return b36.length==5 && b36>"tro8w" || b36.length>5
}
var valores=[
  35 ,
  40000000 ,
  50000000 ,
  50000001 ,
  50000001000
]
for(var i in valores)
{
  var valor=valores[i]
  console.log( valor, es_mayor_a_50_millones(valor) )
}

I think that using regex, a number greater than 50000000 can be represented as follows:

• If the figure has 8 digits, the first of them cannot be equal to 50000000

    ^0*(?:5(?!0{7})\d{7}$
  

• We add the rest of the 8-digit figures greater than 50000000

    ^0*[6-9]\d{7}$
  

• If the figure has more than 8 digits, the first of them must be greater than or equal to 1 (avoid validating 9 zeros or more)

    ^0*[1-9]\d{8,}$
  

• Any of these figures can have infinite zeros 0*at the beginning of them.

Combining these expressions we get:

^0*(?:5(?!0{7})|[6-9]|[1-9]\d)\d{7,}$

^and $are to guarantee that the variable is a number

(?: )Group elements together without saving any references or links for future use.

(?! )It helps me detect a pattern after a certain expression and discard it, in this case 7 zeros after a 5.

For the not so " scientific ":

function billones (n) {return n * 1e12};
function millones (n) {return n * 1e6};
function mil      (n) {return n * 1e3};

And then,

if (numero > millones(50)) {
   //....
}

Or even,

var miNum = billones(9) + mil(millones(2)) + mil(321) + 654;
       // = 9,002,000,321,654;