AngularJS $http succès de rappel de données de retour

Bonjour à tous 🙂 Voici le problème. Je suis en train de faire angulaire application avec:

une usine pour l'accès à une api avec $http qui permet de récupérer un tableau d'objets à partir d'un serveur

getObjectsFromApi : function(){
    return $http({
        url: 'http://path/to/the/api/',
        method: 'GET',
        headers: {
            'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8',
        }
    })       
},

et un service de calculer les données récupérées et de l'injecter à des contrôleurs de

this.getObjectsFromService = function(){
    var objects = [];

    ObjectFactory.getObject()
    .success(function(data, status){
        console.log("Successfully got objects !");
        objects = data;
    })
    .error(function(data, status){
        console.log("Fail... :-(");
    });

    return objects;
};

Le problème est que quand je retourne les objets, il ne renvoie pas les données. Comment puis-je faire pour retourner $http rappel de données au sein de cette getObjectsFromService fonction ?

Merci de votre aide !

InformationsquelleAutor | 2015-02-18

Vous devez utiliser des promesses, quelque chose comme cela devrait faire l'affaire

this.getObjectsFromService = function(){
    var defer = $q.defer();

    ObjectFactory.getObject()
    .then(function(data){
        console.log("Successfully got objects !");
        defer.resolve(data);
    })
    .catch(function(data){
        console.log("Fail... :-(");
         defer.reject(data);
    });

    return defer.promise;
};

Et maintenant vous pouvez utiliser cette fonction quelque part d'autre comme ceci:

var foo = function() {
    var objects = [];
    this.getObjectsFromService().then(function(data) {
        objects = data;
        //do rest of your manipulation of objects array here
    });
}

Il n'y a pas d'autre moyen de retourner les objets, il n'est pas possible parce que $http est asynchrone. Vous devrez retravailler le reste du code et de l'adapter à ce

InformationsquelleAutor IanDess

0
```
var req = ObjectFactory.getObject();

req.success(function(data) {...}
req.error(function(data) {...}
```
Cela va le faire pour toi

La variable req sera alors la promesse renvoyé de l'usine.

Modifier

Gardez à l'esprit que vos données ne seront pas des changements jusqu'à ce que la promesse est résolu, donc, si vous essayez à la console.log(objets de), avant, il sera vide.
- J'ai raté mes explications: Le problème est que je veux renvoyer les données que j'ai obtenu à partir de l'api afin de l'injecter dans le contrôleur. En d'autres termes, je souhaite obtenir des données de réponse, le mettre dans mes "objets" de la variable et le retour de cette variable. Donc, désolé pour le mauvais anglais ... :-/
- Cela permettra de résoudre ce problème. Remplacer votre code où l' '...' est.
InformationsquelleAutor ribsies

La requête http est asynchrone, ce qui signifie qu'il termine après vous revenez objects. De retour de la promesse à la place:

this.getObjectsFromService = function(){
    return ObjectFactory.getObject().catch(function(){
        console.log("Fail... :-(");
    });
}

Puis

service.getObjectsFromService().then(function(resp) {
    console.log("Successfully got objects !", resp.data);
});

InformationsquelleAutor noj

-1

Votre code est asynchrone. Lorsque vous retournez des objets, vous retournez votre premier tableau vide. Vous ne pouvez pas retourner directement votre objet, mais au lieu de cela vous avez besoin de retourner une promesse (voir 3 possibilités ci-dessous)

Par la création d'une promesse

var deferred = $q.defer();

ObjectFactory.getObjectsFromApi()
    .success(function(data, status){
        console.log("Successfully got objects !");
        //Do stuff and resolve promise
        deferred.resolve(data);
     })
     .error(function(data, status){
         console.log("Fail... :-("));
         //Do stuff and reject promise
         deferred.reject(data)
     });

return deferred.promise;

Vous pouvez utiliser promesse de chaînage (utiliser .alors, plutôt que de .succès et .d'erreur):

Remarque: lorsque vous utilisez ensuite avec succès et erreur rappels plutôt que de succès et d'erreurs, vous avez seulement 1 argument qui est l'objet de la réponse

return  ObjectFactory.getObjectsFromApi()
    .then(function(response){
        console.log("Successfully got objects !");
        //Do stuff and chain full response headers or data
        return responseHeaders;
        //or
        //return responseHeaders.data;
     }, function(responseHeaders){
         console.log("Fail... :-("));
         //Do stuff and chain error (full response headers or data)
         return $q.reject(responseHeaders)
         //return $q.reject(responseHeaders.data);
     });

Ou si vous n'avez pas de logique métier, ou aucune raison d'intervenir dans votre usine, il suffit de retourner votre $http appeler directement:

return  ObjectFactory.getObjectsFromApi();

Vous avez beaucoup trop de retours dans votre code. Cela ne fonctionnera pas.
Oui, j'ai eu qu'un seul retour que j'ai laissé par mégarde, sur le premier exemple. Le reste est correct. Si vous pensez qu'il y a trop de retours, regardez la programmation asynchrone ad promesse de chaînage.

InformationsquelleAutor Thomas Roch

-2

Angulaire $ressource

Usine

getObjectsFromApi : function(){
    return $resource('http://path/to/the/api/', {}, 
    {
        get: {
            method: 'GET',
            headers: {
                'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8'
            } 
        }
    })       
},

Service

this.getObjectsFromService = function(){
    var objects = [];

    ObjectFactory.get().$promise.then(function(data) {
         objects = data;
         return objects;
    }).error(function(err) {
        throw err;
    });
};

Ceci renvoie un tableau vide, l'appel à ObjectFactory est asynchrone.

InformationsquelleAutor Harben

Vous devez vous connecter pour publier un commentaire.