Comment kick-ass passer portée par “setInterval”

Que ma situation était un peu différente, mais voici ce que j'ai fait:

var self = this;
setInterval(function() { self.func() }, 50);

Mon scénario, c'est que mon code était à l'intérieur d'une méthode de classe et j'avais besoin de garder corriger portée que je ne voulais pas le " il " de la liaison à résoudre à la fenêtre en cours.

par exemple. Je voulais courir MyClass.animer de MyClass.init à l'aide de la méthode setInterval alors j'ai mis ce champ d'application,-garder le code en MyClass.init

OriginalL'auteur Jacksonkr

J'ai eu la même question, mais il semble y avoir pas intégré dans la solution, voici donc une rapide solution de contournement que j'ai frappé ensemble:

function setScopedInterval(func, millis, scope) {
    return setInterval(function () {
        func.apply(scope);
    }, millis);
}

utilisation:

function MyClass() {
    this.timer = null;
    this.myFunc = function() { console.log('do some stuff'); };
    this.run = function() {
        this.timer = setScopedInterval(function () { this.myFunc(); }, 1000, this);
    };
    this.stop = function() { clearInterval(this.timer); };
}
var instance = new MyClass();
instance.run(); //will log to console every second
//until this line is called
instance.stop();

Il ne concerne que les cas d'utilisation où l'on passe d'une fonction réelle, pas une chaîne de code à exécuter.

Comme pour votre question au sujet des fuites de mémoire lors de l'utilisation de cette fonctionnalité: il n'est pas tellement le problème de l'utilisation de setInterval que c'est avec des fonctions anonymes en lui-même.
Si vous utilisez une référence à un objet à l'intérieur d'un lambda, cette référence permettra de garder l'objet référencé dans la mémoire tant que la fonction anonyme existe. Je pense que la fonction est de les détruire avec un appel à clearInterval.

Je ne pense pas qu'il y est un quelconque avantage de l'affectation de la fonction à une variable de la première, au contraire, il va créer une autre variable contenant une référence qui ne seront pas nettoyés aussi longtemps que les anon func existe...

OriginalL'auteur NDM

Il y a deux distinctions importantes à faire.

1) voulez-vous une référence à l'passées en paramètre de sorte que la fonction d'expiration pouvez suivre les modifications apportées, ou voulez-vous un clone de l'passées en paramètre?

2) voulez-vous être en mesure de capturer une référence pour le délai d'attente dans le cas où vous souhaitez l'annuler? (Oui!)

//Normal setTimeout: retains a reference to `test` and returns the bad value
var test = 'test: good';
var timer = setTimeout(function() { console.log(test); }, 1000);
test = 'test: bad';

//Test2 receives a clone of `test2` and returns the good value, but does so right away, not on a timeout
var test2 = 'test2: good';
var timer2 = setTimeout((function() { console.log(test2); })(test2), 1000);
test2 = 'test2: bad';

//Test3 receives a clone of `test3` and returns the good value, but doesn't return a reference to the timeout, and can't be canceled
var test3 = 'test3: good';
var timer3 = function(test3) { setTimeout(function() { console.log(test3); }, 1000); }(test3);
test3 = 'test3: bad';

//Test4 receives a clone of `test4` and returns the good value, and correctly returns timeout reference
var test4 = 'test4: good';
var timer4 = function(test4) { return setTimeout(function() { console.log(test4); }, 1000); }(test4);
test4 = 'test4: bad';

//Test5 retains a reference to `test5` and returns the bad value
var test5 = 'test5: good';
var timer5 = setTimeout((function() { console.log(test5); }).bind(test5), 1000);
test5 = 'test5: bad';

//Did we capture references to the timeouts?
console.log(typeof timer);
console.log(typeof timer2);
console.log(typeof timer3);
console.log(typeof timer4);
console.log(typeof timer5);

OriginalL'auteur Tyler V.