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

en théorie, cela ne devrait pas faire de différence en JavaScript, puisque le langage n'a pas de champ de blocage, mais seulement de champ de fonction.

Je ne suis pas sûr de l'argument de performance, mais Douglas Crockford recommande toujours que les énoncés var devraient être les premiers énoncés dans le corps de fonction. Citation de Conventions de Code pour le langage de programmation JavaScript :

JavaScript n'a pas de portée de bloc, donc définir des variables dans des blocs peut confondre les programmeurs qui sont 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 un point, comme vous pouvez le voir dans l'exemple suivant. Déclarer les variables en haut de la fonction ne devrait pas induire les lecteurs à penser que la variable i est tenue dans le champ d'application du bloc de boucle for :

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

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

la ECMA-/Javascript langue hoists toute variable déclarée n'importe où au haut d'une fonction. C'est parce que cette langue ne ont function scope et ne pas ont block scope comme beaucoup d'autres langues de type C.

C'est aussi connu sous le nom de lexical scope .

si vous déclarez quelque chose comme

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

Cela devient hoisted :

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

donc cela ne fait aucune différence dans la performance (mais corrigez-moi si je me trompe totalement ici).

Un bien meilleur argument pour pas déclarant une variable ailleurs qu'au sommet d'une fonction est lisibilité . Déclarer une variable dans un for-loop pourrait conduire à la supposition erronée que cette variable ne peut être accessible que dans le corps de boucle, qui est totalement faux . Infact vous pouvez accéder à cette variable n'importe où dans la portée actuelle.

L'année prochaine, tous les navigateurs auront des moteurs JS qui précompilent le code de sorte que la différence de performance (qui vient de l'analyse du même bloc de code encore et encore plus l'exécution de la tâche) devrait devenir négligeable.

aussi, Ne jamais optimiser pour la performance sauf si vous devez. Garder les variables près de l'endroit où vous en avez besoin la première fois garde votre code propre. Du côté négatif, les gens qui sont habitués à des langues à portée de bloc pourraient être confus.

je viens de faire un test simple dans Chrome. Essayez le violon dans votre navigateur et voir 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());

résultat est que le dernier test prend ~8 secondes et les 2 précédentes sont seulement ~2 secondes. Très souvent et sans égard à l'ordre.

donc, cela me prouve, qu'il faut toujours déclarer les var en dehors de la boucle. Le cas curieux pour moi est le premier où je déclare i dans la déclaration pour (). Celui-ci semble être aussi rapide que le second test où je pré-déclare l'index.

une autre considération, maintenant que nous avons let et const dans ES2015, est que vous pouvez maintenant inclure des variables spécifiquement au bloc de boucle. Donc, à moins que vous 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 lors de l'itération précédente), il est probablement préférable de faire ceci:

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

JavaScript est un langage écrit en bas Par C ou C++, Je ne suis pas très sûr de savoir lequel il est. Et un de ses buts est de sauver le lavour de la manipulation de la mémoire interne. Même en C ou C++, vous n'aurez pas à vous soucier de savoir s'il va consommer beaucoup de ressources lorsque les variables sont déclarées à l'intérieur d'une boucle. Pourquoi devriez-vous vous en préoccuper dans JavaScript?

eh Bien, cela dépend de ce que vous essayez d'atteindre... si value suppose n'être qu'une variable temporaire à l'intérieur du bloc de boucle, alors il est beaucoup plus clair d'utiliser la deuxième forme. C'est aussi plus logique et plus clair.

cela ne fait pas de différence si vous déclarez des variables à l'intérieur ou à l'extérieur de for loop. Ci-dessous est un 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. Il suffit de penser ce qui se passe si vous faites ceci:

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

pensez-vous que c'est juste? Aucun. .. parce que vous ne voulez pas déclarer une variable autant de fois. Quand vous déclarez une variable à l'intérieur d'une boucle, n'est-ce pas déclarer autant de fois que la boucle tourne? Évidemment, il va vous gifler lorsque vous êtes en mode "utiliser strict". Les gens n'étaient pas d'accord avec Crockford sans penser à la question initiale.

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

en ce qui concerne la performance après avoir lancé le test sur Chrome, Firefox et jsperf sur un OS Linux, il semble y avoir une différence de performance entre la déclaration des variables dans une boucle et Hors d'une boucle. C'est une petite différence, mais c'est aussi aggravé par le nombre d'itérations et le montant des déclarations de variables.

par conséquent, pour une meilleure performance, je devrais suggérer de déclarer les variables en dehors de la boucle. Ou mieux encore déclarer vos variables conformément. Voir un 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' sont dans la ligne de déclaration de boucle for. Cette déclaration en ligne m'a permis d'obtenir des résultats toujours meilleurs. Même sur la déclaration des variables en dehors de la boucle. Encore une fois, la différence de performance est minime.

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