Compilador de cierre: ¿puede a ++> = 3 convertirse en ++ a> 3?

Question

Admito que hice una pregunta acerca de por qué Closure Compiler no acorta un código que parece acortable a primera vista hace unos días, pero ese motivo no es aplicable en este caso y no estoy muy seguro de por qué no lo es. t acortado aquí.

¿Qué código tengo es:

var a = 0; 
function b() { 
    return a++ >= 3; 
} 

Ahora no es pre-incremento y post-incremento. La diferencia es el valor de retorno - a++ vuelve a y luego incrementos de TI, ++a primeros incrementos a y luego lo devuelve.

Lo que esto se reduce a es que mi código podría reducirse a (ignorando la eliminación espacios en blanco):

var a = 0; 
function b() { 
    return ++a > 3; 
} 

Sin embargo, Closure Compiler no parece alterar (o reconocer) esto.

Mi pregunta por lo tanto es: ¿qué efectos secundarios podría tener ++a > cuando se usa en lugar de a++ >=?

Answer 1

Hay es un borde particular para este constructo (pero no para 3).

Ocurre porque JavaScript almacena los números como IEEE-754 coma flotante de 64 bits dobles y "solo" tiene una representación de enteros "exacta" garantizada de hasta 2^53 (aunque las implementaciones pueden tener un margen de error para tener una rango más alto, no sé).

Esto es en Firefox 4:

a = 2e53 
a++ >= 2e53 // true 

a = 2e53 
++a > 2e53 // false 

pregunta real es lo Ganancia sería tal transformación muy particular tienen? : -0

Happy coding.

Answer 2

¿Por qué no comprueba usted mismo todas las condiciones de borde?

function b(a) { 
    return a++ >= 3; 
} 

function b2(a) { 
    return ++a > 3; 
} 

console.log(b(2) === b2(2)) 
console.log(b(3) === b2(3)) 
console.log(b(4) === b2(4)) 

La salida es true en cada caso.

Answer 3

Es seguro para aplicar este tamaño de optimización de si el derecho-operando (3 en su ejemplo) es un número entero constante en el intervalo [-2 , 2 ]. En cualquier otro caso (por ejemplo, si el operando derecho es fraccionario o muy grande), no es seguro.

Me imagino que el cierre no implementa esta optimización porque:

• que requiere una gran cantidad de comprobación para asegurarse de que la optimización es seguro,
• que sólo se aplica en circunstancias muy específicas que probablemente Don' aparece muy a menudo, y
• Guarda solo un carácter, lo que no parece valer la pena.