¿Debo usar .done () y .fail () para el nuevo código jQuery AJAX en lugar de éxito y error

166

Me he codificado así:

$.ajax({ cache: false,
    url: "/Admin/Contents/GetData",
    data: { accountID: AccountID },
    success: function (data) {
        $('#CityID').html(data);
    },
    error: function (ajaxContext) {
        alert(ajaxContext.responseText)
    }
});

Pero cuando miro la .ajax()documentación de jQuery al final parece sugerir que debería estar codificando así a continuación o al menos sugiere agregar ay .done()a .fail():

var request = $.ajax({ cache: false,
    url: "/Admin/Contents/GetData",
    data: { accountID: AccountID }
});

request.done(function (data) {
    xxx;
});
request.fail(function (jqXHR, textStatus) {
    xxx;
});

Actualizar

Si codifico así, ¿es lo mismo o hay alguna ventaja en dividirlo en tres?

$.ajax({ cache: false,
    url: "/Admin/Contents/GetData",
    data: { accountID: AccountID }
}).done(function (data) {
    xxx;
}).fail(function (jqXHR, textStatus) {
    xxx;
});
Alan2
fuente

Respuestas:

164

Según lo indicado por user2246674, usar successy errorcomo parámetro de la función ajax es válido.

Para ser coherente con la respuesta precedente, lea el documento:

Aviso de desuso :

Las devoluciones de llamada jqXHR.success (), jqXHR.error () y jqXHR.complete () quedarán en desuso en jQuery 1.8. Para preparar su código para su eventual eliminación, use jqXHR.done (), jqXHR.fail () y jqXHR.always () en su lugar.

Si está utilizando la función de manipulación de devolución de llamada (utilizando el encadenamiento de métodos, por ejemplo), use .done(), .fail()y en .always()lugar de success(), error()y complete().

Michael Laffargue
fuente
54
Estoy en desacuerdo. Las referencias hablan de las funciones de manipulación de devolución de llamada (por ejemplo .error, .success) que están en desuso a favor del patrón diferido más universal, pero los parámetros del ajaxmétodo no están en desuso y son válidos y aceptables, ¡incluso en jQuery 1.9 / 2.0! En todas las formas actuales, ajaxaún devuelve un diferido; posiblemente con devoluciones de llamada diferidas ya adjuntas.
user2246674
1
Aquí está, jQuery 1.9, y éxito :, error :, y completo: todavía son utilizables. Sin embargo, mi pregunta es, ¿es .done () == para el éxito:?
TARKUS
3
De @GregoryLewis jQuery código fuente 1.10: jqXHR.success = jqXHR.done;.
Michael Laffargue
9
Sinceramente, prefiero success, fail, always.
ahnbizcad 01 de
44
WOW, también leí mal la documentación. Literalmente pensé que las opciones de 'éxito' / 'error' para $ .ajax se reescribieron en 'hecho / fallar'. Solo eran las cadenas del método de devolución de llamada. Honestamente, creo que también deberían haber cambiado los nombres de las opciones. Eso me dejó perplejo por horas.
OzzyTheGiant
12

Quiero agregar algo en la publicación de @Michael Laffargue:

jqXHR.done() ¡es más rápido!

jqXHR.success()tiene algo de tiempo de carga en la devolución de llamada y, a veces, puede exceder la secuencia de comandos. Lo encuentro en el camino difícil antes.

ACTUALIZAR:

Usando jqXHR.done(), jqXHR.fail()y jqXHR.always()puede manipular mejor con la solicitud ajax. Generalmente puede definir ajax en alguna variable u objeto y usar esa variable u objeto en cualquier parte de su código y obtener datos más rápido. Buen ejemplo:

/* Initialize some your AJAX function */
function call_ajax(attr){
    var settings=$.extend({
        call            : 'users',
        option          : 'list'
    }, attr );

    return $.ajax({
        type: "POST",
        url: "//exapmple.com//ajax.php",
        data: settings,
        cache : false
    });
}

/* .... Somewhere in your code ..... */

call_ajax({
    /* ... */
    id : 10,
    option : 'edit_user'
    change : {
          name : 'John Doe'
    }
    /* ... */
}).done(function(data){

    /* DO SOMETHING AWESOME */

});
Ivijan Stefan Stipić
fuente
9
¿Tiene alguna referencia creíble y verificable?
Paul Vargas
@PaulVargas Nunca hago una prueba de rendimiento, pero en mi práctica encuentro que esto funciona. Puedes intentarlo tú mismo.
Ivijan Stefan Stipić
1
Proporcione cualquier evidencia que sea confiable.
wonsuc
Como sabe, las funciones de devolución de llamada son más lentas en comparación con la devolución de algunos objetos de la función. A veces es un impacto pequeño, pero a veces puede ser enorme si tiene muchas llamadas.
Ivijan Stefan Stipić
7

En palabras simples

$.ajax("info.txt").done(function(data) {
  alert(data);
}).fail(function(data){
  alert("Try again champ!");
});

si obtiene el info.text, entonces alertará y cualquier función que agregue o, si hay alguna, cómo no puede recuperar info.text del servidor, entonces la función de alerta o error.

Yasir
fuente
0

Cuando vamos a migrar JQuery de 1.xa 2x o 3.x en nuestra antigua aplicación existente, usaremos .done, .fail en lugar de éxito, error ya que la gradación ascendente de JQuery va a ser obsoleta por estos métodos. Por ejemplo, cuando realizamos una llamada a los métodos web del servidor, el servidor devuelve los objetos de promesa a los métodos de llamada (métodos Ajax) y estos objetos de promesa contienen métodos .done, .fail..etc. Por lo tanto, haremos lo mismo para responder con éxito y fallar. A continuación se muestra el ejemplo (es para la solicitud POST de la misma manera que podemos construir para el tipo de solicitud como GET ...)

 $.ajax({
            type: "POST",
            url: url,
            data: '{"name" :"sheo"}',
            contentType: "application/json; charset=utf-8",
            async: false,
            cache: false
            }).done(function (Response) {
                  //do something when get response            })
           .fail(function (Response) {
                    //do something when any error occurs.
                });
Sheo Dayal Singh
fuente