jQuery Optimization/Best Practices

Question

Ok saddle up cowboys, because this is going to be a long one. I have been spending the morning going through some of my old code and I'm left wondering about best practices and optimzation. In order to avoid a ride down subjective lane I'll just post some examples with some hopefully easy to answer questions. I will try to keep the examples very simple for ease of an answer and to decrease the likelihood of mistakes. Here we go:

1) Assignment vs jQuery Calls

I understand that when accessing selectors it's generally considered better to assign a selector to a variable rather than make the same call more than once - ex.

$('div#apples').hide(); $('div#apples').show(); 

vs.

var oranges = $('div#oranges'); oranges.show(); oranges.hide(); 

Does this same rule apply when referencing jQuery's $(this)? Ex. A simple bit of script to make some data in a table clickable and customize the link.

$('tr td').each( function() {     var colNum = $(this).index();     var rowNum = $(this).parent().index();     $(this).wrap('<a href="example.com/hello.html?column=' + colNum + '&row=' + rowNum +'">');  }) 

vs.

$('tr td').each( function() {     var self = $(this);     var colNum = self.index()     var rowNum = self.parent().index()     self.wrap('<a href="example.com/hello.html?column=' + colNum + '&row=' + rowNum +'">');  }); 

2) this vs $(this)

Ok so this next one is something that I have wondered about for a long time but I can't seem to find any information on it. Please excuse my ignorance. When does it make sense to call the vanilla js this as opposed to the jQuery wrapped $(this)? It's my understanding that -

$('button').click(function() {   alert('Button clicked: ' + $(this).attr('id')); }); 

Is much less efficient than accessing the DOM attribute of the vanilla this object like the following -

$('button').click(function() {   alert('Button clicked: ' + this.id); }); 

I understand what is going on there, Im just wondering if there is a rule of thumb to follow when deciding which to use.

3) Is more specificity always better?

This one is pretty simple, is it ALWAYS beneficial to be more specific with our selectors? It's easy to see that $('.rowStripeClass') would be much slower than $('#tableDiv.rowStripeClass'), but where do we draw the line? Is $('body div#tableDiv table tbody tr.rowStripeClass') faster still? Any input would be appreciated!

If you've made it this far, thanks for taking a look! If you haven't, :p ​

Answer 1

I'll try to answer these as concisely as possible:

1. Cache it when it's used often, especially in a loop situation, running the same code to get the same result is never a good thing for performance, cache it.

2. Use this when you only need a DOM element and $(this) when you need the jQuery methods (that wouldn't be available otherwise), your example of this.id vs $(this).attr("id") is perfect, some more common examples:

   • Use this.checked instead of $(this).is(':checked')
   • Use $.data(this, 'thing') instead of $(this).data('thing')
   • Any other case where creating a jQuery object isn't useful basically.

3. Decending from an ID selector is preferred for performance...how specific do you need to be? That completely depends, in short: be as specific as you need to be.

Answer 2

1) Assignment vs jQuery Calls

Does this same rule apply when referencing jQuery's $(this)?

Yes, absolutely. A call to the $ function creates a new jQuery object and with it comes associated overhead. Multiple calls to $ with the same selector will create a new object every time.

2) this vs $(this)

I would say knowing the difference is important because at times it becomes crucial that you don't wrap your objects with jQuery. In most cases, you wouldn't want to do premature optimization and just to keep things consistent, always wrap them with $(this), and preferably cache it in a variable. However, consider this extreme example of an unordered list <ul> that contains a million <li> elements:

$("#someList  li").each(function() {     var id = $(this).attr('id'); }); 

A million new objects will be created which will incur a significant performance penalty, when you could have done without creating any new objects at all. For attributes and properties that are consistent across all browsers, you could access them directly without wrapping it in jQuery. However, if doing so, try to limit it to cases where lots of elements are being dealt with.

3) Is more specificity always better?

Not always. It mostly depends on browsers, and again not worth delving into micro-optimizations unless you know for sure that something is running rather slow in your application. For example:

$("#someElement") vs $("#someElement", "#elementsContainer") 

It may appear that since we are also provide a context when searching an element by id, that the second query is going to be faster, but it's the opposite. The first query translates to a direct call to the native getElementById(..) while the second one doesn't because of the context selector.

Also, some browsers might provide an interface to access elements by class name using getElementsByClassName and jQuery might be using it for those browsers for faster results, in which case providing a more specific selector such as:

$("#someElement.theClass") 

might actually be a hindrance than simply writing:

$(".theClass")