I did some basic benchmarking of nextUntil() to test the speed. Here, the javascript is traversing a table of this format:

TextTextText
TextTextText
… snip tr 1120 times …
TextTextText
… snip 5 more tr …

Here is the javascript:

var firstRow = jQuery(‘#jqueryfirstrow1′);
var time = new Date();
var row = firstRow.next();
var rowArray = [];
while (row.length && !row.is(‘#jquerylastrow1′)) {
rowArray.push(row[0]);
row = row.next();
}
console.log(‘Total time with next: ‘ + ((new Date()) – time));

rowArray = [];
var time = new Date();
var row = firstRow;
var rowArray = row.nextUntil(‘#jquerylastrow1′);
console.log(‘Total time with nextUntil: ‘ + ((new Date()) – time));

var time = new Date();
var row = document.getElementById(‘jqueryfirstrow1′).nextSibling;
var rowArray = [];
while (!!row && (row.id != ‘jquerylastrow1′)) {
rowArray.push(row);
row = row.nextSibling;
}
console.log(‘Total time with nextSibling: ‘ + ((new Date()) – time));

Basically, in the end you should always end up with the same rows in the array. Performing the above ten times in a row and averaging the results, I get this:

Average time with next: 236
Average time with nextUntil: 164
Average time with nextSibling: 11

As the results show, just going with plain javascript is a massive performance improvement over using jQuery to retrieve the rows, at least when you use id’s to identify the table rows between which your result set will be.

Also, nextUntil is a significant improvement over putting something together using only next, and of course has the versatility of using any jQuery selector.

Additionally, you can use jQuery on the rowArray generated using plain javascript to use the jQuery functions in the examples above on those rows. I tried this and it was on average 200ms faster when the rows are first retrieved using plain javascript.

It won’t make that much of a difference when you only have three elements as in the examples above, but it certainly is something to keep in mind when you’re handling large amounts of elements and performance is critical.

The nextUntil (and I guess prevUntil and parentsUntil) also allow you to pass in a second argument that filters the results. for example, $('p').nextUntil('#blah','div') will only return div sibling elements up to the #blah element.

I can't for the life of me find out how that's working in the source, but it is

Please update the docs! I had to read the comments to find out this magical second argument.