Angular HttpPromise: diferença entre os métodos `success` /` error` e os argumentos do `then`

De acordo com o documento do AngularJS , as chamadas para $httpretornar o seguinte:

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

Além do fato de o responseobjeto ser destruído em um caso, não entendo a diferença entre

• os retornos de chamada de sucesso / erro passaram a ser passados ​​como argumentos de promise.then
• os retornos de chamada transmitidos como argumentos para os promise.success/ promise.errormétodos da promessa

Existe algum? Qual é o objetivo dessas duas maneiras diferentes de transmitir retornos de chamada aparentemente idênticos?

Nota: esta resposta está incorreta de fato; como apontado por um comentário abaixo, success () retorna a promessa original. Não vou mudar; e deixe para OP para editar.

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

Retornos de chamada baseados em Promise ( .then()) torná-lo fácil de promessas cadeia (fazer uma chamada, interpretar os resultados e , em seguida, fazer outra chamada, interpretar os resultados, fazer ainda outra chamada etc.).

O .success()método é um método simplificado e conveniente quando você não precisa encadear chamadas nem trabalhar com a API da promessa (por exemplo, no roteamento).

Em resumo:

• .then() - poder total da API da promessa, mas um pouco mais detalhado
• .success() - não retorna uma promessa, mas oferece uma sintaxe um pouco mais conveniente

Já existem algumas boas respostas aqui. Mas vale a pena ressaltar a diferença de paralelismo oferecida:

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

A diferença está nas then()operações seqüenciais, pois cada chamada retorna uma nova promessa.

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

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

success() dirige operações paralelas, já que os manipuladores são encadeados com a mesma promessa.

$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 () pode ser encadeado e aguardará a resolução .then () anterior.

.success () e .error () podem ser encadeados, mas todos serão acionados ao mesmo tempo (portanto, não há muito sentido nisso)

.success () e .error () são ótimos para chamadas simples (fabricantes 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 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 oferecer suporte ao <= 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 um formato mais codey para atualizar minha memória sobre como tudo acontece com a manipulação de erros, etc:

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

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

sucesso \ erro:

$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: o sucesso e o erro foram preteridos. Em vez disso, use o método padrão.

Aviso de descontinuação: o sucesso e o erro dos métodos de promessa herdada $ http foram descontinuados. Use o método padrão e, em vez disso. Se $ httpProvider.useLegacyPromiseExtensions estiver definido como false, esses métodos gerarão um erro $ http / legacy.

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

captura de tela: veja a captura de tela