Verificar número mayor a 50 millones

Se puede hacer la comparativa en binario, o en cualquier otra base.

Usando el método toString, pasándole como argumento un número base, es decir, toString(base), podemos hacer la comparación del número en base 36, que es la máxima permitida por el método.

En este caso, si el string llega a tener una longitud igual a la del string tro8w, que es 50 millones en base 36, y además, que sea mayor alfabéticamente a ese string, o si tiene mayor longitud que la del string, nos tiene que devolver 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) )
}

Para los no tan "científicos":

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

Y luego,

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

O incluso,

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

Como aporte a las respuestas de Mariano y de Larry U, agrego una posible solucion, obviamente no tan elegante.

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");
}

Usando desplazamientos de bits, genero los siguientes numeros:

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

Los cuales al sumar dan como resultado 50000000. Puede usarse para comparar y determinar si el numero es menor o mayor.

Actualizacion

He realizado una comparacion respecto a la velocidad con la que se podrian ejecutar dichas instrucciones, en relacion al comentario de @Ruben:

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: La respuesta de Mariano, es mas eficiente, respecto a la velocidad en la ejecucion, como bien se puede apreciar en estos ejemplos.

Creo que usando regex, una cifra mayor a 50000000 se pueden representar de la siguiente forma:

• Si la cifra tiene 8 dígitos, el primero de ellos no puede ser igual a 50000000

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

• Agregamos el resto de las cifras de 8 dígitos mayores que 50000000

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

• Si la cifra tiene mas de 8 dígitos, el primero de ellos debe mayor o igual que 1 (evita validar 9 ceros o mas)

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

• Cualquiera de estas cifras puede tener ceros infinitos 0* al inicio de las mismas.

Combinando estas expresiones nos queda:

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

^ y $ son para garantizar que la variable sea un numero

(?: ) Agrupa elementos sin guardar ninguna referencia o enlace para futuros usos.

(?! ) Me ayuda a detectar un patrón después de cierta expresión y descartarlo, en este caso 7 ceros después de un 5.

Para escribirlo más corto:

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

Eso es 5 * 10^7
_{(o "un 5 seguido de 7 ceros")}.

• Referencia: Literales de Punto Flotante.

Y, no, no, no, no, no, no!!! No uses regex para algo tan sencillo como esto. Te va a hacer que una sentencia trivial se convierta en un elefante que intenta comer un maní a través del agujero de la cerradura... Para curiosos, el regex sería /^0*(?:(?:[6-9]|[1-5]d|5(?=0*[1-9])))d{7}/, pero no lo usen, y mucho menos digan que yo lo escribí.

• Y esto no es solamente por repetir lo que todo el mundo dice. Utilizando una expresión regular estarías haciéndolo ~150 veces más lento (varía para cada caso). En un código intensivo, iría sumando demoras, tomando 1 segundo más cada ~4e8 iteraciones.

  Comparar en: JSPerf.