Angular HttpPromise: diferença entre os methods `success` /` error` e os argumentos `then`

De acordo com o documento AngularJS , as chamadas para $http retornam o seguinte:

Retorna um object de promise com o método padrão e dois methods específicos de http: sucesso e erro . O método then considera dois argumentos um sucesso e um retorno de chamada de erro que será chamado com um object de resposta. Os methods de sucesso e erro usam um único argumento – uma function que será chamada quando a solicitação for bem-sucedida ou falhar, respectivamente. Os argumentos passados ​​para essas funções são representações desestruturadas do object de resposta passado para o método then.

Além do fato de que o object de response é desestruturado em um caso, eu não entendo a diferença entre

  • os callbacks de sucesso / erro passaram a ser passados ​​como argumentos de promise.then
  • os retornos de chamada passaram como argumentos para os methods promise.error / promise.error da promise

Existe algum? Qual é o sentido dessas duas maneiras diferentes de passar callbacks aparentemente idênticos?

NB Esta resposta é factualmente incorreta; como apontado por um comentário abaixo, success () retorna a promise original. Eu não vou mudar; e deixe para OP editar.


A principal diferença entre os 2 é que. .then() call retorna uma promise (resolvida com um valor retornado de um retorno de chamada) enquanto .success() é a forma mais tradicional de registrar retornos de chamada e não retorna uma promise.

Callbacks baseados em promises ( .then() ) facilitam a encadernação de promises (faça uma chamada, interprete os resultados e faça outra chamada, interprete os resultados, faça outra chamada, etc.).

O método .success() é um método de conveniência simplificado quando não é necessário chamar em cadeia nem trabalhar com a API promissora (por exemplo, no roteamento).

Em resumo:

  • .then() – poder total da API promissora, mas um pouco mais detalhado
  • .success() – não retorna uma promise, mas oferece syntax um pouco mais conveniente

Existem algumas boas respostas aqui já. Mas vale a pena levar para casa a diferença de paralelismo oferecida:

  • success() retorna a promise original
  • then() retorna uma nova promise

A diferença é then() aciona operações sequenciais, já que cada chamada retorna uma nova promise.

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

success() conduz operações paralelas, pois os manipuladores são encadeados na mesma promise.

 $http(/*...*/). success(function parFunc1(data){/*...*/}). success(function parFunc2(data){/*...*/}) 
  1. $http.get()
  2. parFunc1() , parFunc2() em paralelo

Alguns exemplos de código para solicitação GET simples. Talvez isso ajude a entender a diferença. Usando 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 }); 

Usando success / error :

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

.then () é chainable e aguardará o .then () anterior para resolver.

.success () e .error () podem ser encadeados, mas todos serão triggersdos de uma vez (portanto, não há muito a apontar para isso)

.success () e .error () são bons para chamadas simples (criadores fáceis):

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

então você não precisa digitar isso:

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

Mas geralmente eu manipulo todos os erros com .catch ():

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

Se você precisar de suporte para <= IE8, escreva seu .catch () e .finally () assim (métodos reservados no IE):

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

Exemplos de trabalho:

Aqui está algo que eu escrevi em mais formato codey para atualizar minha memory sobre como tudo isso se desenrola com erros de manipulação, etc:

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

Apenas para conclusão, aqui está um exemplo de código indicando as diferenças:

success \ error:

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

então:

 $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 }). 

Aviso oficial: sucesso e erro foram preteridos, por favor use o método padrão então.

Aviso de descontinuação: O sucesso e o erro dos methods de promise herdados do $ http foram preteridos. Use o método padrão então. Se $ httpProvider.useLegacyPromiseExtensions for definido como false, esses methods lançarão um erro de $ http / legacy.

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

captura de canvas: veja a captura de canvas