reject()?deferred.reject([args]) settles a Deferred as rejected (since jQuery 1.5) and runs fail callbacks from fail() or then(). Optional args are passed to those handlers. It returns the same Deferred for chaining.
deferred.reject([args…])
reject() → settle as failed (owner only)
fail() → listen for rejection
resolve() → settle as success (opposite)
state locks after reject — once only
return promise() so callers cannot reject| Need | Use |
|---|---|
| Signal failure | dfd.reject(reason) |
| Listen for failure | dfd.fail(fn) |
Custom this + args array | dfd.rejectWith(ctx, args) |
reject()Own the Deferred; reject when the work fails; let others listen.
fail() / then() (or return promise() for callers).reject(args…) with a useful reason.resolve() afterward — the Deferred is already settled.| Piece | Required? | Role |
|---|---|---|
args | Optional | Values passed to every fail callback |
| Return | — | Same Deferred (chainable) |
| Since | — | jQuery 1.5 |
dfd = Deferred
handlers = fail callbacks (from fail / then)
reject(args…):
if dfd already settled: return // ignore
state = "rejected"
remember args
for each fail handler (in add order):
handler(args…)
later fail(fn):
if already rejected: fn(args…) immediately
else: queue fnKeep these facts handy when signaling async failure.
| Topic | Detail |
|---|---|
| Syntax | deferred.reject([args…]) |
| Triggers | fail(), rejection branch of then(), always() |
| State | "rejected" — settles once |
Late fail() | Runs immediately with the reject args |
vs fail() | reject fires; fail listens |
vs resolve() | Failure vs success settlement |
| Since | jQuery 1.5 |
See how reject() drives fail() and once-only settlement.
Short, copy-ready snippets. Open the browser console, or use Try It Yourself for a live editor.
reject() + fail()Settle as failed and read the reason in a fail handler.
var dfd = $.Deferred();
dfd.fail(function (reason) {
console.log(reason); // Network timeout
});
dfd.reject("Network timeout");"rejected".Pass several values; every fail callback receives them in order.
var dfd = $.Deferred();
dfd.fail(function (code, message) {
console.log(code + ": " + message); // 404: Not found
});
dfd.reject(404, "Not found");(code, message).reject(404, "Not found").fail() After RejectHandlers added after rejection run immediately with the reject args.
var dfd = $.Deferred();
dfd.reject("already failed");
dfd.fail(function (reason) {
console.log(reason); // already failed
});"already failed".After resolve(), a later reject() does nothing.
var dfd = $.Deferred();
var lines = [];
dfd.done(function (v) { lines.push("done: " + v); });
dfd.fail(function (v) { lines.push("fail: " + v); });
dfd.resolve("ok");
dfd.reject("nope"); // ignored
console.log(lines.join(" | ")); // done: ok
console.log(dfd.state()); // resolveddone and fail are ready."resolved"; done runs.promise()Only the owner rejects; callers listen on the returned Promise.
function loadFile(ok) {
var dfd = $.Deferred();
setTimeout(function () {
if (ok) dfd.resolve("file.txt");
else dfd.reject("missing file");
}, 200);
return dfd.promise();
}
loadFile(false).fail(function (err) {
console.log(err); // missing file
});loadFile can call reject.promise(), not settle methods.ok is false → reject("missing file").fail on the Promise prints the error.Check these before relying on reject() in real projects.
After resolve or reject, further settle calls are ignored. Check state() if you need to know which won.
Official guidance: return promise() so other code cannot change state with reject().
Empty reject() works but hurts debugging. Prefer a message, code, or Error-like object.
this?Use rejectWith(context, args) when fail handlers rely on a specific this.
deferred.reject() needs jQuery 1.5+ loaded. It works across jQuery 1.5–3.x as the standard way to settle a Deferred as failed.
Works in Chrome, Firefox, Safari, and Edge when jQuery 1.5+ is loaded. Pair with fail() or then() to handle the rejection.
Bottom line: Safe wherever jQuery Deferreds exist. Keep reject() private; expose promise() to callers.
| Approach | Cost | Best for |
|---|---|---|
reject(args) | O(handlers) | Normal failure settlement |
| Many fail handlers | Each runs once | Keep handlers small |
| Reject after settle | No-op | Harmless but wasteful — avoid |
Rejection cost is dominated by your fail handlers (UI updates, logging), not by reject() itself. Pass compact error values, not huge objects, unless needed.
reject fires; fail / then listen.reject/resolve are ignored.promise() so callers cannot reject.One line: reject(args) marks failure — keep it private, pass clear reasons, listen with fail().
Reject with a custom this context and an arguments array.
9 people found this page helpful