fermetures javascript et placement de fonctions

Question

Le placement d'une fonction a-t-il un effet sur les performances des fermetures dans le périmètre? Si oui, quel est le meilleur endroit pour placer ces fonctions? Si ce n’est pas le cas, l’association implicite par fermeture est-elle une raison suffisante pour placer logiquement une fonction à un autre endroit?

Par exemple, si foo ne repose pas sur la valeur de localState , le fait que localState soit accessible depuis foo ont des implications sur le toto , le temps d’exécution, l’utilisation de la mémoire, etc.?

(function(){
    var localState;

    function foo(){
        // code
    }

    function bar(){
        // code
        return localState;
    }
})();

En d'autres termes, s'agirait-il d'un meilleur choix et, dans l'affirmative, pourquoi?

(function(){
    function foo(){
        // code
    }

    var localState;

    function bar(){
        // code
        return localState;
    }
})();

Darius Bacon a suggéré ci-dessous que les deux exemples ci-dessus sont identiques, car localState est accessible à partir du bloc. Cependant, l'exemple ci-dessous où toto est défini en dehors du bloc peut constituer un cas différent. Qu'en penses-tu?

function foo(){
    // code
}

(function(){

    var localState;

    function bar(){
        // code
        foo();
        return localState;
    }
})();

Answer 1

Chaque fonction en Javascript est une fermeture. Le temps d'exécution nécessaire pour résoudre la valeur d'une variable n'est engagé que si la variable est référencée par la fonction. Par exemple, dans cet exemple, la fonction y capture la valeur de x même si x n'est pas référencé directement par y:

var x = 3;
function y() eval("x");
y();
3

Answer 2

Ces deux extraits sont équivalents, car ils sont tous deux définis dans le (même) environnement de la fonction anonyme que vous créez. Je pense que vous seriez en mesure d'accéder à localState à partir de toto de toute façon.

Cela étant dit ... si l'environnement que vous créez contient un nombre absurde de variables, le temps d'exécution de foo peut être affecté, car les recherches de variables prendront probablement plus de temps. S'il y a des tonnes de variables que vous n'utilisez plus dans la fonction, vous définissez foo et si foo n'en a pas besoin non plus, alors foo ne les ramènera pas à la poubelle, ce qui pourrait également poser problème.

Answer 3

Chien, j'espère que l'ordre des déclarations sera quelque chose que les interprètes JavaScript vont faire abstraction. En tout état de cause, s’il existe une différence de performances, elle serait si minime que ce projet en ferait l’afficheur des maux d’une optimisation prématurée.

Answer 4

Je ne pense pas qu'il y aurait une surcharge de performances, car le script Java n'utilise pas la notion de pile de fonctions. Il prend en charge la portée lexicale. Le même état est appliqué aux appels de clôture. En passant, dans votre exemple, vous ne semblez exécuter aucune déclaration!

Answer 5

La portée d'une déclaration var ou function est le bloc entier dans lequel elle apparaît, quel que soit l'emplacement de la déclaration dans le bloc; il serait donc surprenant que cela affecte l'efficacité.

C’est-à-dire que la fonction "function foo ()" n’a aucune importance est avant ou après "var localState" dans ce bloc. Cela peut importer si "function foo ()" se trouve dans ce bloc ou dans un bloc englobant (s'il peut être levé vers une portée plus élevée car il n'utilise pas de variables locales any ); cela dépend des détails de votre compilateur Javascript.

Answer 6

Dans vos exemples, la différence importera peu. Même si foo fait partie du monde entier, vous n’aurez aucun problème.

Cependant, il est utile de garder à l'esprit que si vous utilisez le style d'attribution de fonctions à des variables pour déclarer vos fonctions, l'ordre dans lequel elles sont déclarées peut devenir un réel problème.

Pour une meilleure idée, essayez les deux exemples suivants:

CheckOne();
function CheckOne() {
    alert('check...check one.');
}

CheckTwo();
var CheckTwo = function() {
    alert('check...check two.');
};

La seule différence entre le second et le premier réside dans le style utilisé pour déclarer leurs fonctions. Le second génère une erreur de référence.

A bientôt.