jQuery Forum

I've run into a few situations where I need to modify a set of elements by mapping each element to a solitary descendant (or no descendant, if none match the specified filter).

For example (below), in each TR, I would like to find the first TD of class "foo", and then the anchors in this modified set.

However, $('tr td.foo a') gives me all anchors and there's no point in the chain (at least, none that I know of) where I can instruct the query to limit the search to one descendant per ancestor (I'm assuming there's no regularity in the ordering so that :eq(), :nth-child() etc. can't be used on the final set).

1. <tr>
2.       <td>
3.       <td class="foo">
4.             <a>
5.                   <b> A
   
6.             <a>
7.                   <b> B
   
8.                   <b> C
   
9.       <td class="foo">
10.             <a>
11.             <a>
12.                   <b> D
    
13.       <td>
14.             <a>
15. <tr>
16.       <td>
17.             <a>
18.       <td class="foo">
19.             <a>
20.                   <b> E
    

Hence we're reduced to:

1. var baz = $();
2. $('tr').each( function() { baz.add( $(this).find('td.foo').first() ); } );
3. baz.find( 'a' );

Not the end of the world, but prone to two problems:

1. If we have a large number of elements or deeply nested selectors, this quickly becomes an efficiency issue. We could be searching through 100 TD's per TR when we might only need to look at 1.
   
2. In cases where multiple one-to-(zero-or-one) mappings are required for the same query, the code bulks up quite a bit.

A nice feature to have would be the equivalent of an ":nth-found()" pseudoselector, which applies to each individual object's find results before all results are aggregated into a new set. For example,

$('tr td.foo:nth-found(1) a:nth-found(1) b') to return A and E rather than A, B, C, D and E.

:nth-found() is just what I happen to need. More generally, it would be nice to be able to specify that any filter apply pre-aggregation rather than post-aggregation.

I'm submitting this to "Questions" rather than "Ideas" because I have a sneaking suspicion that there is a way of doing this that's more straightforward than chaining .each() .find() .first()'s. Any ideas?

If there isn't an elegant workaround, perhaps a mod could move this to "Ideas". ;)

Thanks,

Virgil