Foliotek Developer Blog

Setting a threshold on jQuery ajax callbacks using prefilters

Skip straight to the demo.

When developing interfaces that include ajax functionality there will come a time when you will be showing some sort of loading animation and it will only show for a split second since the ajax call finished so fast. This can cause the user to be disoriented since they aren’t exactly sure what popped up. It can be beneficial to slow down the interface so the user can see everything that is going on.

In jQuery 1.5, there is now a way to extend the $.ajax method. There are three different ways to extend $.ajax: prefilters, converters, and transports. I am going to use prefilters which the jQuery documentation describes as "generalized beforeSend callbacks to handle custom options or modify existing ones". I’m not going to go into details about what a prefilter is since the documentation does a pretty good job.

Instead of setting up timeouts and clearing them out, I am wanting to pass a custom option to the ajax method. Here is what I am trying to go for:

$.ajax(url, {  
    successThreshold: 3000,  

The successThreshold option is my custom option. ?The time passed into it will be the minimum amount of time it takes before the success callback gets called. ?Now that I have my custom option, I can access it and modify the other options in my prefilter.

$.ajaxPrefilter(function (options, originalOptions, jqXHR) {
    if (originalOptions.successThreshold && $.isFunction(originalOptions.success)) {
        var start, stop;

        options.beforeSend = function () {
            start = new Date().getTime();
            if ($.isFunction(originalOptions.beforeSend))

        options.success = function (response) {
            var that = this, args = arguments;
            stop = new Date().getTime();

            function applySuccess() {
                originalOptions.success.apply(that, args);

            var difference = originalOptions.successThreshold - (stop - start);
            if (difference > 0)
                setTimeout(applySuccess, difference);

The first thing I do in the prefilter is check to make sure both the successThreshold and success function are set. I then override the beforeSend option in order to get the time before the ajax call starts. In order to keep the success callback from firing before the threshold, the time difference needs to be calculated. If the call didn’t take longer than the difference then set a timeout for the remaining time. Otherwise just call the success callback immediately.

I have seen other solutions to this and all of them seem to set timeouts and clear them in different functions and it would have to be repeated for every call. This can be defined in one place and used on any ajax call in the application.

I have added the code to my Github repository. This demo shows the code in action.

bindWithDelay jQuery Plugin

Sometimes, I want to have a JavaScript event that doesn’t fire until the native event stops firing for a short timeout. I’ve needed to use that pattern in almost every project I have worked on.

For example, you want to use JavaScript to resize an iframe to 100% height when the window resizes. The resize() event can fire dozens of times, and calculating and setting the new height can slow down your page. I used to implement it like this:

[sourcecode lang="javascript"]
var timeout;
function doResize(e) {
timeout = setTimeout(function() {
// run some code
}, 200);
$(function() {

Notice that there are extra variables that you have to deal with, and extra indentation. You could at least clean up the global variable using closures, but you get the idea.

I wrote a plugin to make this pattern easier, it is called “bindWithDelay”. The source code is online, as is a mini project page with a demo.

This is what the same code looks like with the plugin:

[sourcecode lang="javascript"]
function doResize(e) {
// run some code
$(function() {
$(window).bindWithDelay(“resize”, doResize, 200);

Using jQuery and YQL to get an RSS feed from a site

Finding an RSS feed on a site can sometimes be a hassle. Browsers have started introducing a feature that will include an RSS icon in the address bar when the browser finds the site has an RSS feed. I thought it would be nice to allow users to just enter in a web address and let us do the work finding the RSS feed for the site. I looked into how browsers were accomplishing this and found that browsers look for a tag in the of the document with the type attribute of "application/rss+xml".

Now that we know what to look for, how do we go about determining if the website provided has the correct tag? I decided to let YQL do the work for me. I loaded up the YQL Query Console and began testing some queries. On the right hand side, there are different Data Tables you can use. I scrolled down to "data" and selected the "html" option which allows you to query the html of any site.

The example that you start out with looks similar to this:

select * from html where url="" and xpath='//div[@id="yfi_headlines"]/div[2]/ul/li/a'  

From this example it is easy to see which URL is being queried and the XPath that is being used to find elements on the page. If you aren’t familiar with XPath, check out the W3 XPath documentation. So now we just plug in the URL of the site we want to search and change the XPath to what we need to use to find the elements. Now the query looks like this:

select * from html where url="" and xpath='//link[@type="application/rss+xml"]'  

In the query console, be sure to select the JSON radio button and then click the “Test” button. You will see JSON output that looks like the following:

    "query": {
        "count": "1",
        "created": "2010-02-26T09:08:43Z",
        "lang": "en-US",
        "updated": "2010-02-26T09:08:43Z",
        "uri": "*",
        "results": {
            "link": {
                "href": "",
                "rel": "alternate",
                "title": "The Lanit Development Blog RSS Feed", "type": "application/rss+xml"

We can see from the JSON that we found 1 feed and we get all the information to go along with it.

Now that we have a proper YQL query, let’s use some jQuery to create a form that retrieves these feeds for us. I am going to create a simple form where a user inputs a url and then outputs a list of RSS feeds or a message stating that an RSS feed couldn’t be found.

The form is straightforward. I just have a textbox and a button. I also have an unordered list which I’ll use to display the list of RSS feeds.

                <input id="website" type="text"></input>
            <input id="getrss" type="button" value="Get RSS"></input>

Next is the jQuery. We will attach an event to the button that will hit the YQL URL and return JSON that we can parse and get the data we need. The YQL URL we will be using is found in the YQL Query Console next to where you entered the query. There is a box called "The REST Query" which has the query that we will use. The only modification I made to the rest query was that I took out the URL that was in there and replaced with with the jQuery value from the textbox.

$(function () {
    $("#getrss").click(function () {
            type: "GET",
            url: "*%20from%20html%20where%20url%3D%22" + $("#website").val() + "%22%20and%0A%20%20%20%20%20%20xpath%3D’%2F%2Flink%5B%40type%3D%22application%2Frss%2Bxml%22%5D’&format=json&diagnostics=false",
            dataType: "json",
            success: function (data) {
                if (data.query.count == 1) {
                    $("#rsslist").append("[" + + "]()");
                else if (data.query.count > 1) {
                    for (var i = 0; i < data.query.count; i++) {
                        $("#rsslist").append("[" + link.title + "]()");
                else {
                    $("#rsslist").append("No RSS feed found");
            error: function () {

When the AJAX request finishes successfully we check to see if any feeds are returned and if there are, we loop through them and display them.

I created a demo page using so you can see this in action. View Demo

I hope this small example gives you an idea how you can use jQuery and YQL to accomplish other interesting challenges.

Loading images last with jQuery

There are lots of ways to make your webpages faster and more responsive. YSlow is a great tool to help you find many great ways to make a particular page faster.

One of the best things you can do is reduce the number of requests (css/js/images/etc) to the server. Typically, this would mean that you would combine files – merge all of your JS and CSS (and minify while you are at it), and use CSS Sprites to combine images.

One major problem of using CSS Sprites is that it can be quite painful to maintain. Over time, if you want to add or change some of your images – you basically need to rebuild and replace the combined images and all of the CSS rules specifying coordinates. Sometimes, this makes the CSS Sprite technique unreasonable to implement.

In one such case, we had about 50 images in one application that were causing the page to take a long time to load. These images were previews of some different design choices that the user could make. The design choices themselves (and their previews) were database driven so that we can add new designs through an admin interface. So, CSS Spriteing the previews would seriously hamper that flexibility.

One other design consideration was that the previews weren’t that important – the page was fully functional and usable without the images. In fact, the designs weren’t even visible until you toggled the design menu.

There is a lazy loader plugin for jQuery already available here – but it didn’t fit our needs. Instead of skipping images in order to get the page working as soon as possible (and initiate the load once the page is usable) – it is made to skip loading offscreen images until they are scrolled into view. It might have somewhat worked for our needs – but I thought it was better to load the images as soon as possible, instead of waiting for the design menu to be expanded to initiate the load. That way, most of the time the designs would be visible by the time they open the menu – but it wouldn’t interfere with the rest of the interface.

My solution was to set the src for all of the previews to a single animated loading image – like one you can get here. Then, I set a custom attribute on the image for the real preview’s url. Finally, some jQuery code runs after the page is done loading which replaces each src attribute with the url in the custom attribute,which will load the real image.

Sample HTML:

[sourcecode lang="xml"]

  • 3D Dots Dark3D Dots Dark
  • 3D Dots Lite3D Dots Lite
  • BeautyBeauty
  • Black and WhiteBlack and White
  • BlankBlank
  • Blue LeavesBlue Leaves
  • Blue OpenBlue Open
  • CompassCompass

    [/sourcecode]Sample javascript:

[sourcecode lang="javascript"] $(function(){ $("img.deferredLoad").each(function() { var $this = $(this); $this.attr("src",$this.attr("deferredSrc")).removeClass("deferredLoad"); }); }); [/sourcecode]

Getting the width of a hidden element with jQuery using width()

UPDATE #3: It needs to be noted that the fix introduced in jQuery 1.4.4 is only for the width() and height() methods. If you need inner/outer dimensions the method below still needs to be used. I have updated the method to return height/width, outer height/width, and inner height/width. There is an optional parameter to include margins in the outer dimension calculations. Thanks Ryan and Fred for the heads up.

*UPDATE #2: *jQuery 1.4.4 was released today (11/11/2010) and included in the release was an update to the width() and height() methods.z Each method will now return the correct dimension of the element if it is within a hidden element. For further information, you can view the bug report.

UPDATE #1: Based on the feedback in the comments regarding the use of the swap method, I am updating this post with a solution from Ryan Wheale. He created a function to return the dimensions of an element that is hidden or nested within 1 more hidden elements. Here is the code that he posted below in his comment:

//Optional parameter includeMargin is used when calculating outer dimensions  
(function ($) {
    $.fn.getHiddenDimensions = function (includeMargin) {
        var $item = this,
        props = { position: 'absolute', visibility: 'hidden', display: 'block' },
        dim = { width: 0, height: 0, innerWidth: 0, innerHeight: 0, outerWidth: 0, outerHeight: 0 },
        $hiddenParents = $item.parents().andSelf().not(':visible'),
        includeMargin = (includeMargin == null) ? false : includeMargin;

        var oldProps = [];
        $hiddenParents.each(function () {
            var old = {};

            for (var name in props) {
                old[name] =[name];
      [name] = props[name];


        dim.width = $item.width();
        dim.outerWidth = $item.outerWidth(includeMargin);
        dim.innerWidth = $item.innerWidth();
        dim.height = $item.height();
        dim.innerHeight = $item.innerHeight();
        dim.outerHeight = $item.outerHeight(includeMargin);

        $hiddenParents.each(function (i) {
            var old = oldProps[i];
            for (var name in props) {
      [name] = old[name];

        return dim;

This basically performs the same operations as the swap method.? This is safer to use in case the swap method is removed from the jQuery core.

I have tested this in multiple cases and each time the correct results were returned.

Thanks Ryan.

Original post

I recently ran into a problem with jQuery’s width(). The problem is with a visible element that is inside a hidden element will return a value of 0 instead of its’ actual calculated width. After messing around with it for a little bit I finally came up with a solution. The method I used involved adding some CSS properties to the hidden element. The CSS properties involved are position, visibility, and display.

//$HiddenItem is the element that is wrapping the element that you want the width of  
//$Item is the element you want the width of

    position: "absolute",
    visibility: "hidden",
    display: "block"

    position: "",
    visibility: "",
    display: ""

After setting the above CSS properties on the element, you can then call width() and the correct value will be returned. After you call the width() method you should clear the properties in order to return the element to the way it was.

Setting the properties to an empty string is probably not the best way to do it though. What if there was a position value already set? Using this method would clear out that initial values of the CSS properties.

I found the swap() method to be handy in this situation. I found this method while looking through the jQuery source code.

// A method for quickly swapping in/out CSS properties to get correct calculations swap: 
function (elem, options, callback) {  
    var old = {}; // Remember the old values, and insert the new ones
    for (var name in options) {
        old[name] =[name];[name] = options[name];
    }; // Revert the old values 
    for (var name in options) {[name] = old[name];

By using the swap method, the old CSS properties will be remembered and reapplied after finding the width of the element. The swap method takes in 3 parameters:

  1. The element that you would like to swap the CSS properties on
  2. CSS key/value pairs that you want to change
  3. A callback function to call after the properties are set

To rewrite the above to use the swap method I would do the following:

var props = { position: "absolute", visibility: "hidden", display: "block" };  
var itemWidth = 0;

$.swap($HiddenItem[0], props, function () {
    itemWidth = $Item.width();

//Use itemWidth

I coded up a small example on jsbin. Here is the link