So, I'm browsing though some questions over on the Stack Overflow website and I found a good jQuery question just a few minutes old. Here is a
link to it. It was a tough question; I knew that by answering it, I could learn new stuff and reinforce what I already knew: Reading is good, doing is better. Maybe I could help someone in the process too.
I cut and pasted the HTML from the question into my Visual Studio IDE and went back
to Stack Overflow
to reread the question. Dang, someone had already answered it! And it was a great answer. I never even had a chance
to start analyzing the issue.
Now I know what a one-legged man feels like in an ass-kicking contest.
Nevertheless, since the question and answer were so interesting, I decided
to dissect them and learn as much as possible.
The HTML consisted of some divs separated by h3 headings. Note the elements are laid out sequentially with no programmatic grouping:
<h3 class="heading">Heading 1</h3> <div>Content</div> <div>More content</div> <div>Even more content</div><h3 class="heading">Heading 2</h3> <div>some content</div> <div>some more content</div><h3 class="heading">Heading 3</h3> <div>other content</div></form></body> The requirement was
to wrap a div around each h3 heading and the subsequent divs grouping them into sections. Why? I don't know, I suppose if you screen-scrapped some HTML from another site, you might want
to reformat it before displaying it on your own. Anyways…
Here is the marvelously, succinct posted answer:
$('.heading').each(function(){ $(this).nextUntil('.heading').andSelf().wrapAll('<div class="section">');});
I was familiar with all the parts except for nextUntil and andSelf. But, I'll analyze the whole answer for completeness. I'll do this by rewriting the posted answer in a different style and adding a boat-load of comments:
function Test(){ // $Sections is a jQuery object and it will contain three elements var $Sections = $('.heading'); // use each
to iterate over each of the three elements $Sections.each(function () { // $this is a jquery object containing the current element // being iterated var $this = $(this); // nextUntil gets the following sibling elements until it reaches // an element with the CSS class 'heading' // andSelf adds in the source element (this)
to the collection $this = $this.nextUntil('.heading').andSelf(); // wrap the elements with a div $this.wrapAll('<div class="section" >'); });} The code here doesn't look nearly as concise and elegant as the original answer. However, unless you and your staff are jQuery masters, during development it really helps
to work through algorithms step by step. You can step through this code in the debugger and examine the jQuery objects
to make sure one step is working before proceeding on
to the next. It's much easier
to debug and troubleshoot when each logical coding step is a separate line.
Note: You may think the original code runs much faster than this version. However, the time difference is trivial: Not enough
to worry about: Less than 1 millisecond (tested in IE and FF).
Note: You may want
to jam everything into one line because it results in less traffic being sent
to the client. That is true. However, most Internet servers now compress HTML and JavaScript by stripping out comments and white space (go
to Bing or Google and view the source). This feature should be enabled on your server: Let the server compress your code, you don't need
to do it.
Free Career Advice: Creating maintainable code is Job One—Maximum Priority—The Prime Directive. If you find yourself suddenly transferred
to customer support, it may be that the code you are writing is not as readable as it could be and not as readable as it should be. Moving on…
I created a CSS class
to see the results:
.section{ background-color: yellow; border: 2px solid black; margin: 5px;} Here is the rendered output before:
…and after the jQuery code runs.
Pretty Cool! But, while playing with this code, the logic of nextUntil began
to bother me: What happens in the last section? What stops elements from being collected since there are no more elements with the .heading class? The answer is nothing. In this case it stopped because it was at the end of the page. But what if there were additional HTML elements?
I added an anchor tag and another div
to the HTML:
<h3 class="heading">Heading 1</h3> <div>Content</div> <div>More content</div> <div>Even more content</div><h3 class="heading">Heading 2</h3> <div>some content</div> <div>some more content</div><h3 class="heading">Heading 3</h3> <div>other content</div><a>this is a link</a><div>unrelated div</div> </form></body>
The code as-is will include both the anchor and the unrelated div. This isn't what we want.
My first attempt
to correct this used the filter parameter of the nextUntil function:
nextUntil('.heading', 'div') This will only collect div elements. But it merely skipped the anchor tag and it still collected the unrelated div:
The problem is we need a way
to tell the nextUntil function when
to stop. CSS selectors
to the rescue:
nextUntil('.heading, a') This tells nextUntil
to stop collecting sibling elements when it gets
to an element with a .heading class OR when it gets
to an anchor tag. In this case it solved the problem. FYI: The comma operator in a CSS selector allows multiple criteria.
Bingo!
One final note, we could have broken the code down even more:
We could have replaced the andSelf function here:
$this = $this.nextUntil('.heading, a').andSelf();
With this:
// get all the following siblings and then add the current item$this = $this.nextUntil('.heading, a');$this.add(this); But in this case, the andSelf function reads real nice. In my opinion.
Here's a
link to a jsFiddle if you want
to play with it.
I hope someone finds this useful
Steve Wellens
CodeProject
