.prevAll()?.prevAll() (since jQuery 1.2) gets all preceding siblings of each matched element, optionally filtered by a selector — nearest previous sibling first.
// All previous siblings of item 3 → items 2, then 1
$("li.third-item").prevAll();
// Only previous siblings that match
$("li.third-item").prevAll(".mark");
// Document order before wrapAll (jQuery 3.7+)
$(".last").prevAll().uniqueSort().wrapAll("");| Need | Use |
|---|---|
| One step back | .prev() |
| All previous siblings | .prevAll() |
| Previous until a stop | .prevUntil() |
| All following siblings | .nextAll() |
| Either side | .siblings() |
.prevAll()Start from an element, then collect every sibling before it.
.prevAll() for every previous sibling..prevAll("selector") to keep matching ones only..uniqueSort() first.| Signature | Since | Role |
|---|---|---|
.prevAll() | 1.2 | All preceding siblings (nearest first) |
.prevAll(selector) | 1.2 | Same, filtered by selector |
| No previous siblings | — | Empty jQuery object |
result = empty jQuery object
for each matched element:
sibling = immediate previous element sibling
while sibling exists:
if no selector OR sibling matches selector:
append sibling to result // nearest first
sibling = previous element sibling of sibling
return result
// often: .uniqueSort() before wrapAll / appendKeep these facts handy while collecting previous siblings.
| Topic | Detail |
|---|---|
| Direction | All siblings before the start |
| Order | Nearest first (reverse document order) |
| Selector | Keeps matching previous siblings only |
vs .prev() | One neighbor vs all previous |
vs .nextAll() | Mirror — all following siblings |
| wrapAll tip | Use .uniqueSort() first (3.7+) |
| Nearest match | .prevAll(".x").first() |
From item 3, collect previous siblings — plain, filtered, or sorted.
Short, copy-ready snippets. Prefer text markers so demos stay CSS-free.
Official idea: from item 3, select every preceding sibling.
$("li.third-item").prevAll().prepend("[prev] ");
// items 1 and 2 both get the markerli.third-item..prevAll() finds items 2 and 1..prepend("[prev] ") labels each match.Keep only previous siblings that match a selector.
$("li.third-item").prevAll(".mark").prepend("[match] ");
// only previous siblings with class "mark".mark..prev(). Filtering can find matches further back..prevAll(".mark").first().Join text to show collection order: closest previous sibling first.
var order = $("li.third-item").prevAll().map(function () {
return $(this).text();
}).get().join(" → ");
$("#out").text(order);
// list item 2 → list item 1.prevAll() builds nearest-first..uniqueSort()Official tip: sort before order-sensitive methods like .wrapAll().
var raw = $(".last").prevAll().map(function () {
return $(this).text();
}).get().join(" → ");
var sorted = $(".last").prevAll().uniqueSort().map(function () {
return $(this).text();
}).get().join(" → ");
$("#out").text("raw: " + raw + " | sorted: " + sorted);
// raw: Second → First | sorted: First → Second.uniqueSort() restores document order..uniqueSort() needs jQuery 3.7+.$.uniqueSort(collection) instead..prev() vs .prevAll()One neighbor versus every previous sibling 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.prev(); all → .prevAll()..nextAll() for the other direction.These trip up beginners most often with .prevAll().
Collection order is reverse document order. Call .uniqueSort() before .wrapAll() when document order matters.
.prev(sel) ≠ nearest matchTo find the closest previous .x, use .prevAll(".x").first(), not .prev(".x").
No previous siblings means .length === 0. Chaining stays safe.
Siblings share a parent. Cousins in another list are not included.
.prevAll() has been part of jQuery since 1.2. Instance .uniqueSort() needs 3.7+ (older builds: $.uniqueSort()). Works wherever your loaded jQuery build runs.
Universal across browsers that run your jQuery version. Prefer jQuery 3.7+ when using .uniqueSort() after .prevAll().
Bottom line: Safe for everyday sibling collection. Remember reverse order before wrap/append.
| Approach | Cost | Best for |
|---|---|---|
.prev() | Cheapest | One adjacent sibling |
.prevAll() short lists | Cheap | Typical UI lists / forms |
.prevAll() huge sibling sets | Watch | Prefer .prevUntil() or a tighter selector |
Cost scales with how many previous siblings exist. Prefer .prev() when one neighbor is enough.
.uniqueSort() when document order matters..prev(); all → .prevAll()..prevAll(".x").first(), not .prev(".x").One line: .prevAll() gathers every previous sibling, nearest first — sort before wrap/append if you need document order.
Get previous siblings until (but not including) a stop element.
17 people found this page helpful