Les variables JavaScript déclarent une boucle extérieure ou intérieure?

Dans AS3, je pense que vous devriez initialiser toutes les variables en dehors des boucles pour des performances accrues. Est-ce également le cas avec JavaScript? Quelle est la meilleure / la plus rapide / la meilleure pratique?

var value = 0;

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

ou

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

Il n'y a absolument aucune différence de sens ou de performance, en JavaScript ou en ActionScript.

varest une directive pour l'analyseur, et non une commande exécutée au moment de l'exécution. Si un identifiant particulier a été déclaré varune ou plusieurs fois n'importe où dans un corps de fonction (*), alors toute utilisation de cet identifiant dans le bloc fera référence à la variable locale. Cela ne fait aucune différence si valueest déclaré à l' varintérieur de la boucle, à l'extérieur de la boucle, ou les deux.

Par conséquent, vous devez écrire ce que vous trouvez le plus lisible. Je ne suis pas d'accord avec Crockford selon lequel mettre tous les vars au sommet d'une fonction est toujours la meilleure chose. Dans le cas où une variable est utilisée temporairement dans une section de code, il est préférable de déclarer vardans cette section, afin que la section soit autonome et puisse être copiée-collée. Sinon, copiez-collez quelques lignes de code dans une nouvelle fonction pendant la refactorisation, sans sélectionner et déplacer séparément l'associé var, et vous obtenez un global accidentel.

En particulier:

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

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

Crockford vous recommandera de supprimer le second var(ou supprimez les deux vars et faites var i;ci - dessus), et jslint se plaindra de vous pour cela. Mais OMI, il est plus varfacile de conserver les deux s, en gardant tout le code associé ensemble, au lieu d'avoir un bit de code supplémentaire facilement oublié en haut de la fonction.

Personnellement, j'ai tendance à déclarer comme varla première affectation d'une variable dans une section indépendante de code, qu'il y ait ou non une autre utilisation distincte du même nom de variable dans une autre partie de la même fonction. Pour moi, avoir à déclarer varest une verrue JS indésirable (il aurait été préférable d'avoir des variables par défaut sur local); Je ne considère pas qu'il soit de mon devoir de dupliquer également les limitations d'une [ancienne révision de] ANSI C en JavaScript.

(*: autre que dans les corps de fonction imbriqués)

En théorie, cela ne devrait pas faire de différence dans JavaScript, car le langage n'a pas de portée de bloc, mais seulement de portée de fonction.

Je ne suis pas sûr de l'argument de la performance, mais Douglas Crockford recommande toujours que les varinstructions soient les premières instructions dans le corps de la fonction. Citant des conventions de code pour le langage de programmation JavaScript :

JavaScript n'a pas de portée de bloc, donc la définition de variables dans des blocs peut confondre les programmeurs expérimentés avec d'autres langages de la famille C. Définissez toutes les variables en haut de la fonction.

Je pense qu'il a raison, comme vous pouvez le voir dans l'exemple suivant. La déclaration des variables en haut de la fonction ne doit pas amener les lecteurs à penser que la variable i est conservée dans la portée du forbloc de boucle:

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

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

La ECMA-/Javascriptlangue hoiststoute variable qui est déclarée nulle part au sommet d'une fonction. C'est parce que cette langue n'avoir et ne pas avoir comme beaucoup d' autres C comme langues. C'est aussi connu sous le nom de .function scopeblock scope
lexical scope

Si vous déclarez quelque chose comme

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

Cela permet hoistedde:

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

Cela ne fait donc aucune différence dans les performances (mais corrigez-moi si je me trompe totalement ici).
Un bien meilleur argument pour ne pas déclarer une variable ailleurs qu'en haut d'une fonction est la lisibilité . Déclarer une variable dans un for-looppourrait conduire à l'hypothèse erronée que cette variable n'est accessible que dans le corps de la boucle, ce qui est totalement faux . En fait, vous pouvez accéder à cette variable n'importe où dans la portée actuelle.

L'année prochaine, tous les navigateurs disposeront de moteurs JS qui précompileront le code, de sorte que la différence de performances (qui provient de l'analyse répétée du même bloc de code et de l'exécution de l'affectation) devrait devenir négligeable.

De plus, n'optimisez jamais les performances, sauf si vous le devez. Garder les variables à proximité de l'endroit où vous en avez besoin la première fois maintient votre code propre. Du côté négatif, les gens qui sont habitués aux langues avec des étendues de bloc peuvent être confus.

Une autre considération, maintenant que nous avons letet constdans ES2015, est que vous pouvez maintenant étendre des variables spécifiquement au bloc de boucle. Donc, à moins que vous n'ayez besoin de la même variable en dehors de la boucle (ou si chaque itération dépend d'une opération effectuée sur cette variable dans l'itération précédente), il est probablement préférable de le faire:

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

Je viens de faire un simple test dans Chrome. Essayez le violon dans votre navigateur et voyez les résultats

  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());

Le résultat est que le dernier test prend ~ 8 secondes et les 2 précédents ne sont que ~ 2 secondes. Très répétable et indépendamment de la commande.

Donc, cela me prouve, qu'il faut toujours déclarer les vars en dehors de la boucle. Le cas le plus curieux pour moi est le premier où je déclare idans la déclaration for (). Celui-ci semble être aussi rapide que le 2ème test où je pré-déclare l'index.

JavaScript est un langage écrit en bas par C ou C ++, je ne sais pas trop lequel. Et l'un de ses objectifs est de ne pas avoir à manipuler la mémoire interne. Même en C ou C ++, vous n'aurez pas à vous soucier de savoir s'il consommera beaucoup de ressources lorsque des variables sont déclarées dans une boucle. Pourquoi devriez-vous vous en soucier en JavaScript?

Eh bien, cela dépend de ce que vous essayez de réaliser ... si vous valuesupposez qu'il ne s'agit que d'une variable temporaire à l'intérieur du bloc de boucle, il est beaucoup plus clair d'utiliser le second formulaire. C'est aussi plus logique et verbeux.

Cela ne fait aucune différence si vous déclarez des variables à l'intérieur ou à l'extérieur de la boucle for. Voici l'exemple de code à tester.

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()

Les résultats ont montré dans mon cas

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

Merci - MyFavs.in

La question ici est essentiellement de déclarer un var à l'intérieur d'une boucle. Pensez simplement à ce qui se passe si vous faites cela:

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

Pensez-vous que ce soit vrai? Non ... parce que vous ne voulez pas déclarer autant de fois une variable. Lorsque vous déclarez une variable à l'intérieur d'une boucle, ne déclare-t-elle pas autant de fois que la boucle s'exécute? De toute évidence, cela vous giflera lorsque vous serez en mode «utilisation stricte». Les gens sont en désaccord avec Crockford sans penser à la question d'origine.

Il est donc toujours bon de déclarer des variables en haut - 1. Pour la lisibilité, 2. Prendre de bonnes habitudes.

En ce qui concerne les performances après l'exécution du test sur Chrome, Firefox et jsperf sur un système d'exploitation Linux, il semble y avoir une différence de performances entre la déclaration de variables dans une boucle et hors d'une boucle. C'est une petite différence, mais elle est également aggravée par le nombre d'itérations et le nombre de déclarations de variables.

Par conséquent, pour de meilleures performances, je devrais suggérer de déclarer des variables en dehors de la boucle. Ou mieux encore, déclarez vos variables en ligne. Voir l'exemple.

// 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;
}

Remarquez comment les variables «al» et «av» se trouvent dans la ligne de déclaration de la boucle for. Cette déclaration en ligne m'a fourni des performances toujours meilleures. Même sur la déclaration de variables en dehors de la boucle. Encore une fois, la différence de performances est vraiment faible.

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