angularjs - with - http delete

HttpPromise angular: diferencia entre los métodos `success`/` error` y `then`''s

Question

De acuerdo con AngularJS doc , las llamadas a $http devuelven lo siguiente:

Devuelve un objeto promesa con el método estándar entonces y dos métodos específicos de http: éxito y error . El método then toma dos argumentos como un éxito y una devolución de llamada de error que será invocada con un objeto de respuesta. Los métodos de éxito y error toman un único argumento: una función que se invocará cuando la solicitud tenga éxito o falle, respectivamente. Los argumentos pasados ​​a estas funciones son representación desestructurada del objeto de respuesta pasado al método entonces.

Aparte del hecho de que el objeto de response está desestructurado en un caso, no entiendo la diferencia entre

• las devoluciones de llamada de éxito / error pasaban a ser pasadas como argumentos de promise.then
• las devoluciones de llamadas pasaron como argumentos para los métodos de promesas. promise.success / promise.error . promise.error de la promesa

¿Hay alguna? ¿Cuál es el objetivo de estas dos formas diferentes de pasar devoluciones de llamada aparentemente idénticas?

Answer 1

.then () es encadenable y esperará a que termine .then () para resolverlo.

.success () y .error () pueden estar encadenados, pero todos se dispararán a la vez (por lo que no tiene mucho sentido)

.success () y .error () son agradables para llamadas simples (facilitadores):

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

para que no tengas que escribir esto:

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

Pero generalmente manejo todos los errores con .catch ():

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

Si necesita admitir <= IE8, escriba su .catch () y .finally () de esta manera (métodos reservados en IE):

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

Ejemplos de trabajo:

Aquí hay algo que escribí en un formato más codificado para actualizar mi memoria sobre cómo se juega con los errores de manejo, etc.

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

Answer 2

Algunos ejemplos de código para una simple solicitud GET. Tal vez esto ayude a entender la diferencia. 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
});

Answer 3

Aquí hay algunas buenas respuestas. Pero vale la pena llevar a casa la diferencia en el paralelismo ofrecido:

• success() devuelve la promesa original
• then() devuelve una nueva promesa

La diferencia es then() unidades de operaciones secuenciales, ya que cada llamada devuelve una nueva promesa.

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

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

success() maneja operaciones paralelas, ya que los manejadores están encadenados en la misma promesa.

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

1. $http.get()
2. parFunc1() , parFunc2() en paralelo

Answer 4

Solo para completar, aquí hay un ejemplo de código que indica las diferencias:

éxito / error:

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

entonces:

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

Answer 5

NB Esta respuesta es objetivamente incorrecta; como se señala en un comentario a continuación, success () devuelve la promesa original. No voy a cambiar; y déjalo en OP para editar.

La principal diferencia entre los 2 es que .then() llama devuelve una promesa (resuelta con un valor devuelto por una devolución de llamada) mientras que .success() es la forma más tradicional de registrar devoluciones de llamada y no devuelve una promesa.

Las devoluciones de llamada basadas en .then() ( .then() ) facilitan la cadena de promesas (hacer una llamada, interpretar resultados y luego hacer otra llamada, interpretar resultados, hacer otra llamada, etc.).

El método .success() es un método simplificado y conveniente cuando no necesita llamar en cadena ni trabajar con la API de promesa (por ejemplo, en el enrutamiento).

En breve:

• .then() - pleno poder de la promesa API, pero un poco más detallado
• .success() - no devuelve una promesa pero ofrece una sintaxis ligeramente más conveniente

Answer 6

Aviso oficial: el éxito y el error han quedado en desuso, utilice el método estándar en su lugar.

Aviso de desaprobación: el éxito y el error de los métodos de promesa heredados de $ http se han desaprobado. Use el método estándar entonces en su lugar. Si $ httpProvider.useLegacyPromiseExtensions se establece en falso, estos métodos arrojarán $ http / error heredado.

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

captura de pantalla: ver la captura de pantalla