Antes que nada, nunca compare cosas como estas por motivos de rendimiento. Math.round es obviamente más fácil para los ojos que window.Math.round, y no verá un aumento notable en el rendimiento al usar uno u otro. Así que no ofusque su código para incrementos muy pequeños en el rendimiento.
Sin embargo, si solo tiene curiosidad acerca de cuál es más rápido ... No estoy seguro de cómo se busca el alcance global "bajo el capó", pero supongo que el acceso a window es el mismo que accediendo a Math (window y Math vivo en el mismo nivel, como lo demuestra el funcionamiento de window.window.window.Math.round). Por lo tanto, acceder a window.Math sería más lento.
Además, las variables manera se buscan, se podría ver un aumento de rendimiento haciendo var round = Math.round; y llamando round(1.23), ya que todos los nombres son vistos por primera vez en el ámbito local actual, entonces el alcance por encima de la actual, y así sucesivamente , todo el camino hasta el alcance global. Cada nivel de alcance agrega una muy ligera sobrecarga.
Pero nuevamente, no haga estas optimizaciones a menos que esté seguro de que harán una diferencia notable. El código comprensible y legible es importante para que funcione de la manera que debería, ahora y en el futuro.
Aquí hay un perfil completo usando Firebug:
<!DOCTYPE html>
<html>
<head>
<title>Benchmark scope lookup</title>
</head>
<body>
<script>
function bench_window_Math_round() {
for (var i = 0; i < 100000; i++) {
window.Math.round(1.23);
}
}
function bench_Math_round() {
for (var i = 0; i < 100000; i++) {
Math.round(1.23);
}
}
function bench_round() {
for (var i = 0, round = Math.round; i < 100000; i++) {
round(1.23);
}
}
console.log('Profiling will begin in 3 seconds...');
setTimeout(function() {
console.profile();
for (var i = 0; i < 10; i++) {
bench_window_Math_round();
bench_Math_round();
bench_round();
}
console.profileEnd();
}, 3000);
</script>
</body>
</html>
Mis resultados:
Time muestra total de 100.000 llamadas * 10, Avg/Min/Max tiempo de la demostración de 100.000 llamadas.
Calls Percent Own Time Time Avg Min Max
bench_window_Math_round
10 86.36% 1114.73ms 1114.73ms 111.473ms 110.827ms 114.018ms
bench_Math_round
10 8.21% 106.04ms 106.04ms 10.604ms 10.252ms 13.446ms
bench_round
10 5.43% 70.08ms 70.08ms 7.008ms 6.884ms 7.092ms
Como se puede ver, window.Math es una muy mala idea. Supongo que acceder al objeto global window agrega una sobrecarga adicional.Sin embargo, la diferencia entre acceder al objeto Math desde el alcance global y acceder a una variable local con referencia a la función Math.round no es muy buena ... Tenga en cuenta que esto es 100,000 llamadas, y la diferencia es solo 3.6 Sra. Incluso con un millón de llamadas, solo verías una diferencia de 36 ms.
cosas en que pensar con el código anterior: perfiles
- Las funciones son en realidad levantaron la vista de otro ámbito, lo que implica una sobrecarga (apenas perceptible, sin embargo, he intentado importar las funciones en la función anónima).
- La función real
Math.round agrega sobrecarga (supongo que unos 6ms en 100,000 llamadas).
¿Por qué es importante? ¿Cuál es el problema que estás tratando de resolver? –
Bueno, estoy optimizando para el rendimiento, así que estoy curioso de cuál es más rápido. Si hago miles de cálculos, una desreferencia de puntero menos por ciclo, probablemente me ayude. –
"No es una pregunta real"? Esta es una buena pregunta. –