.prev()?.prev() (since jQuery 1.0) gets the immediately preceding sibling of each matched element. An optional selector includes that sibling only if it matches.
// Immediate previous sibling
$("li.third-item").prev();
// Only if that sibling matches
$("p").prev(".selected");
// No previous / no match → empty set
$("#first").prev(); // length 0| Need | Use |
|---|---|
| One step backward | .prev() |
| One step forward | .next() |
| All previous siblings | .prevAll() |
| Previous until a stop | .prevUntil() |
| All siblings either side | .siblings() |
.prev()Start from an element, then take one step to its previous sibling.
.prev() for the immediate previous sibling..prev("selector") — keep it only if it matches..prepend(), .text(), …)..length is 0, there was no neighbor (or no match).| Signature | Since | Role |
|---|---|---|
.prev() | 1.0 | Immediate previous sibling |
.prev(selector) | 1.0 | Same, only if sibling matches |
| No sibling / no match | — | Empty jQuery object |
result = empty jQuery object
for each matched element:
sibling = immediate previous element sibling
if no sibling:
skip
else if selector was given and sibling does not match:
skip
else:
add sibling to result
return resultKeep these facts handy while walking siblings.
| Topic | Detail |
|---|---|
| Direction | One sibling backward |
| Nodes | Element siblings only (not text/comment) |
| Selector | Filters that one neighbor — no further scan |
| Empty result | Safe to chain; check .length if needed |
vs .prevAll() | All previous siblings |
vs .next() | Mirror — one step forward |
| Returns | New jQuery object (chainable) |
Start from item 3 and step with .prev(), .next(), or a filtered prev.
Short, copy-ready snippets. Prefer text markers so demos stay CSS-free.
Official idea: from item 3, select the immediate previous sibling.
$("li.third-item").prev().prepend("[prev] ");
// list item 2 becomes "[prev] list item 2"li.third-item..prev() returns item 2..prepend("[prev] ") labels it without CSS.Include the previous sibling only when it matches.
$("p").prev(".selected").prepend("[match] ");
// Only a previous sibling with class "selected" is markedp looks at its previous sibling..selected.Official “Go to Prev” idea: move a current marker one sibling at a time.
var $curr = $("#start");
$curr.prepend("[here] ");
$("button").on("click", function () {
$curr.text($curr.text().replace(/^\[here\]\s*/, ""));
var $prev = $curr.prev();
if (!$prev.length) {
$curr.prepend("[here] ");
$("#out").text("No previous sibling.");
return;
}
$curr = $prev;
$curr.prepend("[here] ");
$("#out").text("Now at: " + $curr.text().replace("[here] ", ""));
});$curr reference.$curr.prev().The first child has no previous sibling — result length is 0.
var $p = $("#first").prev();
$("#out").text("length = " + $p.length);
// length = 0#first is the first sibling.length === 0..prev() vs .prevAll()One step vs all previous siblings from the same start.
var one = $("li.third-item").prev().text();
var all = $("li.third-item").prevAll().map(function () {
return $(this).text();
}).get().join(", ");
$("#out").text("prev: " + one + " | prevAll: " + all);
// prev: list item 2 | prevAll: list item 2, list item 1.prevAll() is nearest-first..prev(); all → .prevAll().These trip up beginners most often with .prev().
.prev(".x") tests only the immediate sibling. For the nearest previous .x, use .prevAll(".x").first().
No previous element sibling means .length === 0. Check length before assuming a match.
.prev() skips text/comment nodes between tags. Only element siblings count.
Sibling methods stay on the same level. Use .parent() / .children() for vertical moves.
.prev() has been part of jQuery since 1.0. Works wherever your loaded jQuery build runs.
Universal across browsers that run your jQuery version. Prefer current jQuery 3.x+ for teaching and production.
Bottom line: Safe for everyday sibling walking. Use .prevAll() when you need more than one step back.
| Approach | Cost | Best for |
|---|---|---|
.prev() | Cheap | One adjacent sibling |
.prev(selector) | Cheap | One neighbor + quick match test |
.prevAll() on long lists | Watch | Prefer when you truly need every previous sibling |
One step is inexpensive. Prefer .prev() over .prevAll() when a single neighbor is enough.
.prev(selector) tests that one neighbor only..prev() · all → .prevAll() · forward → .next().One line: .prev() is one sibling backward — optional selector filters that neighbor, nothing further.
Get every preceding sibling — not just the immediate one.
16 people found this page helpful