Las variables de JavaScript declaran un bucle externo o interno?

En AS3, creo que debe inicializar todas las variables fuera de los bucles para aumentar el rendimiento. ¿Es este el caso con JavaScript también? ¿Cuál es mejor / más rápido / mejor práctica?

var value = 0;

for (var i = 0; i < 100; i++)
{
    value = somearray[i];
}

o

for (var i = 0 ; i < 100; i++)
{
    var value = somearray[i];
}

No hay absolutamente ninguna diferencia en significado o rendimiento, en JavaScript o ActionScript.

vares una directiva para el analizador, y no un comando ejecutado en tiempo de ejecución. Si un identificador particular se ha declarado varuna vez o más en cualquier parte del cuerpo de una función (*), todo uso de ese identificador en el bloque se referirá a la variable local. No importa si valuese declara que está vardentro del bucle, fuera del bucle o ambos.

En consecuencia, debe escribir lo que le resulte más legible. No estoy de acuerdo con Crockford en que poner todos los vars en la parte superior de una función siempre es lo mejor. Para el caso en el que una variable se usa temporalmente en una sección de código, es mejor declarar varen esa sección, por lo que la sección es independiente y se puede copiar y pegar. De lo contrario, copie y pegue unas pocas líneas de código en una nueva función durante la refactorización, sin seleccionar y mover por separado lo asociado var, y obtendrá un global accidental.

En particular:

for (var i; i<100; i++)
    do something;

for (var i; i<100; i++)
    do something else;

Crockford le recomendará que elimine el segundo var(o elimine ambos varsy haga lo var i;anterior), y jslint se quejará de esto. Pero en mi opinión, es más varfácil mantener ambos s, manteniendo todo el código relacionado juntos, en lugar de tener un bit de código adicional y fácil de olvidar en la parte superior de la función.

Personalmente, tiendo a declarar como varla primera asignación de una variable en una sección de código independiente, si hay otro uso separado del mismo nombre de variable en alguna otra parte de la misma función. Para mí, tener que declarar vares una verruga JS indeseable (hubiera sido mejor tener las variables predeterminadas a locales); No veo como mi deber duplicar las limitaciones de [una revisión anterior de] ANSI C en JavaScript también.

(*: excepto en cuerpos de funciones anidadas)

En teoría, no debería hacer ninguna diferencia en JavaScript, ya que el lenguaje no tiene alcance de bloque, sino solo alcance de función.

No estoy seguro sobre el argumento del rendimiento, pero Douglas Crockford todavía recomienda que las vardeclaraciones sean las primeras en el cuerpo de la función. Citando las convenciones de código para el lenguaje de programación JavaScript :

JavaScript no tiene alcance de bloque, por lo que definir variables en bloques puede confundir a los programadores con experiencia en otros lenguajes de familia C. Defina todas las variables en la parte superior de la función.

Creo que tiene un punto, como puede ver en el siguiente ejemplo. Declarar las variables en la parte superior de la función no debe confundir a los lectores a pensar que la variable i se mantiene en el ámbito del forbloque de bucle:

function myFunction() {
  var i;    // the scope of the variables is very clear

  for (i = 0; i < 10; i++) {
    // ...
  }
}

El ECMA-/Javascriptlenguaje hoistscualquier variable que se declara en cualquier lugar en la parte superior de una función Eso se debe a que esta lengua no tienen function scopey que no tienen block scopecomo muchos otros, C-como las lenguas.
Eso también se conoce como lexical scope.

Si declaras algo como

var foo = function(){
    for(var i = 0; i < 10; i++){
    }
};

Esto llega hoisteda:

var foo = function(){
    var i;
    for(i = 0; i < 10; i++){
    }
}

Por lo tanto, no hace ninguna diferencia en el rendimiento (pero corrígeme si estoy totalmente equivocado aquí).
Un argumento mucho mejor para no declarar una variable en otro lugar que no sea la parte superior de una función es la legibilidad . Declarar una variable dentro de a for-looppodría llevar a la suposición errónea de que solo se puede acceder a esta variable dentro del cuerpo del bucle, lo cual es totalmente incorrecto . De hecho, puede acceder a esa variable en cualquier lugar dentro del alcance actual.

El próximo año, todos los navegadores tendrán motores JS que precompilarán el código, por lo que la diferencia de rendimiento (que proviene de analizar el mismo bloque de código una y otra vez más la ejecución de la asignación) debería ser insignificante.

Además, nunca optimice el rendimiento a menos que sea necesario. Mantener variables cerca del lugar donde las necesita la primera vez mantiene limpio su código. En el lado negativo, las personas que están acostumbradas a los idiomas con ámbitos de bloque podrían estar confundidas.

Otra consideración, ahora que tenemos lety consten ES2015, es que ahora puede abarcar variables específicamente para el bloque de bucle. Entonces, a menos que necesite la misma variable fuera del bucle (o si cada iteración depende de una operación realizada a esa variable en la iteración anterior), probablemente sea preferible hacer esto:

for (let i = 0; i < 100; i++) {
    let value = somearray[i];
    //do something with `value`
}

Acabo de hacer una prueba simple en Chrome. Pruebe el violín en su navegador y vea los resultados.

  var count = 100000000;
    var a = 0;
    console.log(new Date());

    for (var i=0; i<count; i++) {
      a = a + 1
    }

    console.log(new Date());

    var j;
    for (j=0; j<count; j++) {
      a = a + 1;
    }

    console.log(new Date());

    var j;
    for (j=0; j<count; j++) {
        var x;
        x = x + 1;
    }

    console.log(new Date());

El resultado es que la última prueba dura ~ 8 segundos y las 2 anteriores son solo ~ 2 segundos. Muy repetible e independientemente del orden.

Entonces, esto me demuestra que uno siempre debe declarar los vars fuera del ciclo. El caso curioso para mí es el primero donde declaro ien la declaración for (). Esta parece ser tan rápida como la segunda prueba en la que pre-declaro el índice.

JavaScript es un lenguaje escrito en la parte inferior por C o C ++, no estoy muy seguro de cuál es. Y uno de sus propósitos es salvar el placer de manejar la memoria interna. Incluso en C o C ++, no tendrá que preocuparse por si consumirá muchos recursos cuando las variables se declaren dentro de un bucle. ¿Por qué deberías preocuparte en JavaScript?

Bueno, eso depende de lo que intente lograr ... si se valuesupone que es solo una variable temporal dentro del bloque de bucle, entonces es mucho más claro usar la segunda forma. También es más lógico y detallado.

No hace diferencia si declaras variables dentro o fuera del ciclo for. A continuación se muestra el código de muestra para probar.

function a() {
   console.log('Function a() starts');
   console.log(new Date());
    var j;
    for (j=0; j<100000000; j++) {
        var x;
        x = x + 1;
    }
    console.log(new Date());
    console.log('Function a() Ends');
}
a()
function b() {
console.log('Function B() starts');
   console.log(new Date());
    var a;
    var j;
    for (j=0; j<100000000; j++) {
      a = a + 1;
    }
    console.log(new Date());
    console.log('Function B() Ends');
}
b()

Los resultados mostraron en mi caso

Function a() starts
VM121:3 Thu Apr 12 2018 15:20:26 GMT+0530 (India Standard Time)
VM121:9 Thu Apr 12 2018 15:20:26 GMT+0530 (India Standard Time)
VM121:10 Function a() Ends
VM121:14 Function B() starts
VM121:15 Thu Apr 12 2018 15:20:26 GMT+0530 (India Standard Time)
VM121:21 Thu Apr 12 2018 15:20:26 GMT+0530 (India Standard Time)
VM121:22 Function B() Ends

Gracias - MyFavs.in

La pregunta aquí es básicamente declarar una var dentro de un bucle. Solo piensa en lo que sucede si haces esto:

var a = 30;
var a = 50;
var a = 60;

¿Crees que esto es correcto? No ... porque no quieres declarar una variable tantas veces. Cuando declaras una variable dentro de un ciclo, ¿no está declarando tantas veces que el ciclo se ejecuta? Obviamente te abofeteará cuando estés en modo 'uso estricto'. La gente no estuvo de acuerdo con Crockford sin pensar en la pregunta original.

Por lo tanto, siempre es bueno declarar variables en la parte superior: 1. Para facilitar la lectura, 2. Hacer buenos hábitos.

Con respecto al rendimiento después de ejecutar la prueba en Chrome, Firefox y jsperf en un sistema operativo Linux, parece haber una diferencia de rendimiento entre la declaración de variables en un bucle y fuera de un bucle. Es una pequeña diferencia, pero esto también se ve agravado por la cantidad de iteraciones y la cantidad de declaraciones variables.

Por lo tanto, para un mejor rendimiento, tendría que sugerir declarar variables fuera del ciclo. O mejor aún, declara tus variables en línea. Ver ejemplo.

// inline
for (var ai = 0, al = 100000000, av; ai < al; ai++) {
    av = av + 1;
}

// outside
var bv;
var bl = 100000000;
for (var bi = 0; bi < bl; bi++) {
    bv = bv + 1;
}

Observe cómo la variable 'al' y 'av' están en la línea de declaración de bucle for. Esta declaración en línea me ha proporcionado un rendimiento consistentemente mejor. Incluso sobre la declaración de variables fuera del ciclo. Nuevamente, la diferencia de rendimiento es realmente pequeña.

https://jsperf.com/outside-inline-for-loop-ase/1