AngularJS, promesse avec fonction récursive

Je suis en train d'utiliser le AngularJS promesse/puis avec une fonction récursive. Mais la fonction n'est pas appelée (aucune erreur, le succès-, de notification des rappels est appelée).

Voici mon code:

fonction récursive

loadSection2 = function() {

    var apiURL = "http://..."

    var deferred = $q.defer();

    $http({
        method: "GET",
        url: apiURL
    }).success(function(result, status, headers, config) {
        console.log(result);
        loadCount++;
        if(loadCount < 10) {
            newSectionArray.push(result);
            loadSection2(); 
        } else {
            loadCount = 0;
            deferred.resolve();
            return deferred.promise;
        }
    }).error(function() {
        return deferred.reject();
    });
    deferred.notify();
    return deferred.promise;
};

puis

loadSection2().then(function() {
    console.log("NEW SECTIONS LOADED, start adding to document");
    addContent();
}, function() {
    console.log("ERROR CALLBACK");
}, function() {
    console.log("NOTIFY CALLBACK");
}).then(function() {
    loadScrollActive = false;
});

Je pense, l'a alors pour obtenir la première notification de rappel au moins. Mais il n'y a pas de rappel.
Est alors de ne pas travailler avec une fonction récursive?

Pourriez-vous nous donner un jsfiddle?
Une chose que je vois, c'est que vous ne pouvez pas retourner quelque chose à partir d'une fonction de rappel. Donc retour différé.promesse .succès et .l'erreur ne fait rien. Pas la cause du problème.
Où est 'loadCount" définis? Et, notify ne fonctionne pas comme vous le pensez. J'ai une question ouverte pour que, dans angulaire repo -> github.com/angular/angular.js/issues/5277
Hm, il y avait une réponse qui a résolu le problème, mais maintenant il a disparu. Le problème, c'est que le "différé" est initialisé à chaque appel de la loadSection2(). @Rifat: informer fonctionne pour moi. La notification de rappel est appelée aussi longtemps, que la promesse n'est pas résolu.

OriginalL'auteur Fauphi | 2013-12-16

EDIT - 11/11/2015 est le moyen le plus propre si vous ne se soucient pas informer:

loadSection2 = function (){
    var apiURL = "http://..."
    return $http.get(apiURL)
        .then(function(response){
            loadCount++;        
            if (loadCount < 10) {
                newSectionArray.push(response.data);
                return loadSection2();
            }
            loadCount = 0;
        });

};

Vieille réponse se trouve ici:

Vous pourriez continuellement passer de la promesse tout le chemin à travers.

loadSection2 = function(deferred) {

    if(!deferred){
        deferred = $q.defer();
    }
    var apiURL = "http://..."

    $http({
        method: "GET",
        url: apiURL
    }).success(function(result, status, headers, config) {
        console.log(result);
        loadCount++;
        if(loadCount < 10) {
            newSectionArray.push(result);
            loadSection2(deferred); 
        } else {
            loadCount = 0;
            deferred.resolve();
            return deferred.promise;
        }
    }).error(function() {
        return deferred.reject();
    });
    deferred.notify();
    return deferred.promise;
};

Mathieu, je pense que vous avez oublié de passer à deferred dans votre appel récursif, mais c'est la bonne réponse. Le problème que vous rencontrez, c'est que vous faites une nouvelle deferred objet chaque fois que vous appelez la méthode, au lieu d'utiliser le même pour l'ensemble du processus. Donc, la première fois que vous appelez loadSection2, vous obtenez deferred1 de retour, mais le différé qui s'est résolu en fait deferred10. En passant le report de la le long serait de les aider, ou vous pouvez créer la variable à l'extérieur de votre méthode et de l'utilisation de la fermeture de l'accès.
Vous êtes complètement à droite, j'ai voulu faire passer à travers, réponse d'édition.
s'il vous plaît aidez-moi à comprendre la raison de "retour différé promesse" de "l'autre" bloc. J'ai préparé un q version de cet exemple où dans le bloc else je ne suis pas de retour différé.promesse; et il fonctionne très bien. lien

OriginalL'auteur Mathew Berg

Je voulais faire une solution qui ne passe pas "différé" est variable autour et même si je ne dirais pas que c'est une meilleure approche, il fonctionne, et j'ai appris à partir d'elle (jsfiddle).

19/Août/14 - mis à Jour le code d'une version raccourcie par le retrait de la création d'une autre promesse de la f1(). J'espère que c'est clair comment il se rapporte à la question d'origine. Si elle n'est pas faites le moi savoir dans un commentaire.

f1().then(function() {
    console.log("done");
});

function f1(counter) {

    if (!counter) {
        counter = 0;
    }

    counter++;
    console.log(counter);

    return asyncFunc().then(function() {
        if (counter < 10) {
            return f1(counter);
        } else {
            return;
        }
    });

}

function asyncFunc() {
    var deferred = $q.defer();

    $timeout(function() {
        deferred.resolve();
    }, 100);

    return deferred.promise;
}

OriginalL'auteur VitalyB

Fauphi,

La récursivité est totalement viable, mais pas un en particulier "promisy" approche.

Étant donné que vous avez deferreds/promesses disponible, vous pouvez générer dynamiquement une .then() de la chaîne, qui offre la promesse d'une peuplé de tableau.

function loadSection2(arr) {
    return $http({
        method: "GET",
        url: "http://..."
    }).then(function(result, status, headers, config) {
        console.log(result);
        arr.push(result);
        return arr;//make the array available to the next call to loadSection2().
    }, function() {
        console.log("GET error");
        return $q.defer().resolve(arr).promise;//allow the chain to continue, despite the error.
        //or I think $q's .then() allows the much simpler form ...
        //return arr; //allow the chain to continue, despite the error.
    });
};

var newSectionPromise = $q.defer().resolve([]).promise;//note that the deferred is resolved with an anonymous new array.
//Now we build a .then() chain, ten long, ...
for (var i=0; i<10; i++) {
    newSectionPromise = newSectionPromise.then(loadSection2);
}
//... and do something with the populated array when the GETs have done their thing.
newSectionPromise().then(function(arr) {
    console.log(arr.length + " new sections loaded, start adding to document");
    addContent(arr);
}, function() {
    console.log("ERROR CALLBACK");
}).then(function() {
    loadScrollActive = false;
});

non testé

Ce qui a été newSectionArray est maintenant créé de façon anonyme et transmis la .then() de la chaîne, indépendamment de la réussite/l'échec de l'individu Obtient, en train de devenir arr dans le final .ensuite, le gestionnaire de succès, où il est passé à addContent(). Cela évite la nécessité pour les états newSectionArray à l'extérieur de la portée.

Réorganisant légèrement, loadSection2 pourraient être rendues anonymes, ce qui réduit le nombre de membres ajouté à l'extérieur de la portée.

La nécessité d'une notification explicite disparaît comme :

il n'est plus maître reportés pour être averti
console.log(result); dans le gestionnaire de succès fournit tous la notification nécessaire.

OriginalL'auteur Beetroot-Beetroot

Vous devez vous connecter pour publier un commentaire.