Angular HttpPromise: differenza tra i metodi `success` /` error` e gli argomenti `then`

Secondo il documento AngularJS , chiama per $httprestituire quanto segue:

Restituisce un oggetto promessa con il metodo standard then e due metodi specifici http: successo ed errore . Il metodo then accetta due argomenti con esito positivo e un callback di errore che verrà chiamato con un oggetto response. I metodi di successo ed errore accettano un singolo argomento: una funzione che verrà chiamata quando la richiesta ha esito positivo o negativo. Gli argomenti passati a queste funzioni sono rappresentazioni destrutturate dell'oggetto di risposta passato al metodo then.

A parte il fatto che l' responseoggetto è destrutturato in un caso, non capisco la differenza tra

• i callback di successo / errore passati per essere passati come argomenti di promise.then
• i callback sono passati come argomenti per i metodi promise.success/ promise.errordella promessa

C'è qualche? Qual è il punto di questi due modi diversi di passare callback apparentemente identici?

NB Questa risposta è in realtà errata; come sottolineato da un commento qui sotto, success () restituisce la promessa originale. Non cambierò; e lasciarlo su OP per modificarlo.

La differenza principale tra i 2 è che la .then()chiamata restituisce una promessa (risolta con un valore restituito da una richiamata) mentre .success()è il modo più tradizionale di registrare le richiamate e non restituisce una promessa.

I callback basati su promesse ( .then()) facilitano il concatenamento di promesse (effettuare una chiamata, interpretare i risultati e quindi fare un'altra chiamata, interpretare i risultati, fare ancora un'altra chiamata ecc.).

Il .success()metodo è un metodo semplificato e conveniente quando non è necessario eseguire la chiamata in serie o lavorare con l'API promessa (ad esempio, nel routing).

In breve:

• .then() - piena potenza dell'API promessa ma leggermente più dettagliata
• .success() - non restituisce una promessa ma offre una sintassi leggermente più comoda

Ci sono già alcune buone risposte qui. Ma vale la pena portare a casa la differenza di parallelismo offerta:

• success() restituisce la promessa originale
• then() restituisce una nuova promessa

La differenza sta nelle then()operazioni sequenziali, poiché ogni chiamata restituisce una nuova promessa.

$http.get(/*...*/).
  then(function seqFunc1(response){/*...*/}).
  then(function seqFunc2(response){/*...*/})

1. $http.get()
2. seqFunc1()
3. seqFunc2()

success() guida operazioni parallele, poiché i gestori sono incatenati sulla stessa promessa.

$http(/*...*/).
  success(function parFunc1(data){/*...*/}).
  success(function parFunc2(data){/*...*/})

1. $http.get()
2. parFunc1(), parFunc2()in parallelo

Alcuni esempi di codice per una semplice richiesta GET. Forse questo aiuta a capire la differenza. Utilizzando then:

$http.get('/someURL').then(function(response) {
    var data = response.data,
        status = response.status,
        header = response.header,
        config = response.config;
    // success handler
}, function(response) {
    var data = response.data,
        status = response.status,
        header = response.header,
        config = response.config;
    // error handler
});

Utilizzando success/ error:

$http.get('/someURL').success(function(data, status, header, config) {
    // success handler
}).error(function(data, status, header, config) {
    // error handler
});

.then () è concatenabile e attenderà la risoluzione di .then () precedente.

.success () e .error () possono essere concatenati, ma spareranno tutti in una volta (quindi non indicano molto)

.success () e .error () sono perfetti per le chiamate semplici (easy maker):

$http.post('/getUser').success(function(user){ 
   ... 
})

quindi non è necessario digitare questo:

$http.post('getUser').then(function(response){
  var user = response.data;
})

Ma generalmente gestisco tutti gli errori con .catch ():

$http.get(...)
    .then(function(response){ 
      // successHandler
      // do some stuff
      return $http.get('/somethingelse') // get more data
    })
    .then(anotherSuccessHandler)
    .catch(errorHandler)

Se è necessario supportare <= IE8, scrivere in questo modo .catch () e .finally () in questo modo (metodi riservati in IE):

    .then(successHandler)
    ['catch'](errorHandler)

Esempi di lavoro:

Ecco qualcosa che ho scritto in un formato più codey per rinfrescare la mia memoria su come tutto funziona con errori di gestione ecc:

http://jsfiddle.net/nalberg/v95tekz2/

Solo per il completamento, ecco un esempio di codice che indica le differenze:

successo \ errore:

$http.get('/someURL')
.success(function(data, status, header, config) {
    // success handler
})
.error(function(data, status, header, config) {
    // error handler
});

poi:

$http.get('/someURL')
.then(function(response) {
    // success handler
}, function(response) {
    // error handler
})
.then(function(response) {
    // success handler
}, function(response) {
    // error handler
})
.then(function(response) {
    // success handler
}, function(response) {
    // error handler
}).

Avviso ufficiale: successo ed errore sono stati deprecati, utilizzare invece il metodo standard then.

Avviso di deprecazione: il successo e l'errore dei metodi di promessa legacy $ http sono stati deprecati. Utilizzare invece il metodo standard then. Se $ httpProvider.useLegacyPromiseExtensions è impostato su false, questi metodi genereranno un errore $ http / legacy.

link: https://code.angularjs.org/1.5.7/docs/api/ng/service/$http

screenshot: visualizza lo screenshot