always()?deferred.always() adds handlers that run when a Deferred is either resolved or rejected (since jQuery 1.6). Ideal for shared cleanup. Returns the Deferred so you can chain. Accepts a function or an array of functions.
dfd.done(onSuccess) // resolve only
dfd.fail(onError) // reject only
dfd.always(onCleanup) // resolve OR reject
// Official AJAX-style cleanup:
$.get("test.php").always(function () {
// hide spinner — ignore args
});| Need | Use |
|---|---|
| Shared cleanup | dfd.always(fn) |
| Success only | dfd.done(fn) |
| Failure only | dfd.fail(fn) |
| Create a Deferred | $.Deferred() |
always()Attach outcome-specific handlers, then one shared cleanup.
$.ajax() / $.get()).done() / fail() for success and error UI.always(fn) for cleanup that must run either way.resolve() / reject() (or wait for AJAX to finish).| Piece | Required? | Role |
|---|---|---|
| Deferred / jqXHR | Yes | Object that will settle |
| alwaysCallbacks | Yes | Function or array of functions |
| Return | — | Same Deferred (chainable) |
dfd = Deferred (pending)
alwaysQueue = []
always(fn or [fn…]):
append to alwaysQueue
if dfd already settled:
run fn now with settle args
return dfd
resolve(args…) / reject(args…):
mark settled
run done OR fail handlers
run alwaysQueue in order with argsKeep these facts handy for Deferred cleanup.
| Topic | Detail |
|---|---|
| Syntax | deferred.always( alwaysCallbacks [, alwaysCallbacks ] ) |
| Runs when | Resolved or rejected |
| Pending? | Does not run while pending |
| Args | Same as resolve/reject — often different shapes |
| Best for | Spinners, locks, analytics — ignore args |
| Chainable? | Yes — returns the Deferred |
| Since | jQuery 1.6 |
Settle a Deferred with resolve or reject and watch done / fail / always fire.
Short, copy-ready snippets. Open DevTools Console, or use Try It Yourself for a live editor.
Register done() for success and always() for shared cleanup.
var dfd = $.Deferred();
dfd.done(function (value) {
console.log("done:", value);
});
dfd.always(function () {
console.log("always: request finished");
});
dfd.resolve("OK");$.Deferred() starts pending.done for success; always for cleanup.always() still runs when the Deferred is rejected — that is its main value.
var dfd = $.Deferred();
dfd.fail(function (reason) {
console.log("fail:", reason);
});
dfd.always(function () {
console.log("always: cleanup runs anyway");
});
dfd.reject("Network error");fail.Mirror the AJAX pattern: handle data, handle errors, then finalize.
var dfd = $.Deferred();
dfd
.done(function (data) {
console.log("Profile:", data.name);
})
.fail(function (err) {
console.warn("Request failed:", err);
})
.always(function () {
console.log("Re-enable submit button");
});
dfd.resolve({ name: "Alex" });
// → Profile: Alex
// → Re-enable submit buttondone reads data.name.Show a spinner when work starts; hide it in always() either way.
function loadItems() {
var status = "Loading…";
var dfd = $.Deferred();
setTimeout(function () {
dfd.resolve(["apple", "banana"]);
}, 300);
dfd
.done(function (items) {
status = items.join(", ");
console.log("List:", status);
})
.fail(function () {
status = "Could not load items.";
console.log(status);
})
.always(function () {
console.log("Spinner hidden");
});
}
loadItems();always() HandlersRegister several cleanup callbacks; jQuery calls each in order.
var dfd = $.Deferred();
dfd.always(function () {
console.log("Log event");
});
dfd.always(function () {
console.log("Release UI lock");
});
dfd.always(function () {
console.log("Send analytics beacon");
});
dfd.resolve("finished");always() queues one handler.always([fn1, fn2]).Check these before putting logic inside always().
Resolve and reject payloads often differ. Keep argument-aware logic in done / fail.
always() waits for settle. Attaching it early is fine — it queues until resolve/reject.
If the Deferred already settled, a new always() callback runs immediately (memory-style queues).
An exception in one always handler can interrupt later always callbacks in the same settle pass — keep cleanup defensive.
Promise.finallySimilar idea, but always() is jQuery Deferred-specific and receives settle arguments (unlike native finally).
deferred.always() is part of jQuery’s Deferred API (since 1.6). It works in any browser where your jQuery build runs — the queue lives in jQuery, not as a separate browser API.
Supported in jQuery 1.6+, including 2.x and 3.x, across Chrome, Firefox, Safari, Edge, and other browsers with jQuery loaded.
Bottom line: Safe wherever jQuery 1.6+ is loaded. Use always() for shared cleanup; keep argument-aware work in done() / fail().
| Operation | Cost | Best for |
|---|---|---|
always(fn) | O(1) queue | Registering cleanup |
| Settle + always handlers | O(n) | Running all always callbacks |
| Duplicated cleanup in done+fail | 2× code paths | Avoid — prefer one always |
Registering always() is cheap. Cost shows up if cleanup does heavy DOM or network work. Keep always handlers light (hide spinner, unlock UI) and put expensive outcome-specific work in done / fail.
.always() on jqXHR from $.get / $.ajax.done → fail → always for clean request UI.One line: always() is the Deferred cleanup hook — run it whether you win or lose.
Learn the modern shorthand for attaching a rejection handler on a Deferred.
9 people found this page helpful