done()?deferred.done(doneCallbacks) adds handlers that run when a Deferred is resolved (success). Available since jQuery 1.5. It returns the Deferred so you can chain more methods.
dfd.done(fn)
dfd.done(fn1, fn2)
dfd.done([fn1, fn2], fn3)
resolve("ok") → done handlers run with "ok"
reject(...) → done does NOT run
$.get(url).done(fn) // jqXHR success| Need | Use |
|---|---|
| On success | dfd.done(fn) |
| On failure | dfd.fail(fn) |
| Either outcome | dfd.always(fn) |
done()Create or receive a Deferred/Promise, attach done, then resolve (or wait for AJAX).
$.Deferred()) or a jqXHR from $.ajax / $.get..done(function (value) { ... }) — pass a function or an array of functions.resolve(value) (or let AJAX succeed).fail / always as needed.| Piece | Required? | Role |
|---|---|---|
| Deferred / jqXHR | Yes | Object that can resolve |
doneCallbacks | Yes | Function or array of functions |
| Return value | — | Same Deferred (chainable) |
function done(deferred, callbacks):
queue = flatten(callbacks) // functions and arrays
add each callback to success list
when deferred.resolve(args...):
for each fn in success list (in order):
fn(args...)
return deferred // chainableKeep these facts handy while wiring success handlers.
| Topic | Detail |
|---|---|
| Syntax | deferred.done(doneCallbacks [, doneCallbacks ]) |
| Since | jQuery 1.5 |
| Runs when | Deferred is resolved |
| Arguments | Same values passed to resolve / resolveWith |
| Multiple handlers | Functions or arrays; order preserved |
| Late attach | If already resolved → runs immediately |
| Returns | The Deferred (chainable) |
Pick a scenario and see how done() behaves on resolve.
Short, copy-ready snippets. Open DevTools Console, or use Try It Yourself for a live editor.
Attach done(), then resolve() with a message.
var dfd = $.Deferred();
dfd.done(function (value) {
console.log("done: " + value);
});
dfd.resolve("Request successful");
// done: Request successful$.Deferred() starts in the pending state.done(fn) queues the success callback.resolve("Request successful") settles as success.Pass functions or arrays; they run in registration order (per the API docs).
var dfd = $.Deferred();
var lines = [];
function fn1() { lines.push("1"); }
function fn2() { lines.push("2"); }
function fn3(n) { lines.push(n + " 3 " + n); }
dfd.done([fn1, fn2], fn3).done(function (n) {
lines.push(n + " we're done.");
});
dfd.resolve("and");
console.log(lines.join(" "));
// 1 2 and 3 and and we're done.[fn1, fn2] adds both callbacks in order.fn3 and the chained done also receive "and".done() returns the Deferred, so another .done() works.resolve can pass several values; done receives them as separate parameters.
var dfd = $.Deferred();
dfd.done(function (status, body, type) {
console.log(status); // 200
console.log(body); // { ok: true }
console.log(type); // application/json
});
dfd.resolve(200, "{ ok: true }", "application/json");status, body, type.If the Deferred is already resolved, a new done() still runs right away.
var dfd = $.Deferred();
dfd.resolve("already settled");
dfd.done(function (value) {
console.log("done (late): " + value);
});
// done (late): already settledresolve happens before any handler is attached.done(fn) sees the Deferred is already resolved.fn with the stored resolve value.Check these before relying on done() alone.
done() never runs on failure. Always pair with fail(), catch(), or a rejection branch on then().
done vs then chainingdone() returns the same Deferred. then() returns a new Promise — use then when you need to transform values down a chain.
Callbacks run in registration order. Do not assume parallel execution — keep side effects safe to run sequentially.
A Deferred resolves or rejects once. Extra resolve calls are ignored; late done handlers still see the first result.
deferred.done() has shipped since jQuery 1.5 and works in all modern browsers with jQuery loaded. It is part of the Deferred Object API (also used by jqXHR).
Supported everywhere jQuery Deferred runs in the browser. Use it for success callbacks on Deferred and AJAX objects.
Bottom line: Call dfd.done(fn) for success. Pair with fail() for errors. Works on Deferred and jqXHR since jQuery 1.5.
| Approach | Cost | Best for |
|---|---|---|
dfd.done(fn) | O(k) handlers | Success-only side effects |
dfd.then(fn) | O(k) + new Promise | Value transforms / chains |
dfd.always(fn) | O(k) | Shared cleanup |
Handler cost is usually tiny compared with the async work (network, timers). Prefer clear success/error separation over micro-optimizing callback count.
fail() / always() for errors and cleanup.One line: dfd.done(fn) runs on resolve only — queue success work, and pair with fail() for the error path.
Learn how to attach rejection handlers when a Deferred fails.
9 people found this page helpful