Improving Versioning of WordPress Static Files

I was recently asked to improve the PageSpeed and YSlow scores of a WordPress-based website that I work on. One of the items that PageSpeed checks is "Don't include a query string in the URL for static resources," (under the "Leverage Proxy Caching" heading). I suspect this is most important when you are using a CDN, or otherwise run through a proxy server. WordPress puts a version in the query string of any JavaScript or CSS that's enqueued using wp_enqueue_script() or wp_enqueue_style().

Interestingly, PageSpeed doesn't seem to complain about the WordPress-included static resources that have a query string on the URL, only about static resources on 3rd-party URLs. I'm not sure why this is, but let's remove the query strings from the WordPress-included static resources anyway, while still maintaining a version somewhere in the URL so we can set far-future Expires headers.

The format of a WordPress version tag is ver={version number}, like this: example.com/wp-content/themes/theme-name/style.css?ver=2.0.5.4, but example.com/ver2.0.5.4/wp-content/themes/theme-name/style.css should be more cacheable. There are two steps to making this happen:

1) Use Apache's mod_rewrite to Serve the Correct File to the Updated URL

In step 2 we'll be moving the version tag to the beginning of the URL, we only need one RewriteRule to make it work:


# This goes in your .htaccess file, before the WordPress section
<IfModule mod_rewrite.c>
RewriteEngine On
RewriteBase /

## Cache-Busting ##
RewriteRule ^ver([\d\.\-a-zA-Z]+)/(.*) $2?ver=$1 [L] #match something with the version tag right at the beginning of the URL
## Done cache-busting ##

</IfModule>

The rule above matches any URL that starts with "ver" followed by any number of letters, numbers, periods, dashes, and underscores, captures that collection of characters up to the first forward slash, then it captures everything after the first forward slash. The URL is rewritten as $2?ver=$1 where $2 is everything after the version tag, (the original URL, with no version tag), and $1 is the version number that's added, internally, to the query string, but never appears in the browser.

Note: It is probably possible to leave off the ?ver=$1, but I haven't tried it yet.

Now example.com/wp-content/themes/theme-name/style.css?ver=2.0.5.4 and example.com/ver2.0.5.4/wp-content/themes/theme-name/style.css should both serve up the same style.css file.

2) Filter the URLs for Enqueued Scripts & Styles to Move the Version Tag from the Querystring into the Path

The URL for every enqueued Javascript is filtered by the script_loader_src filter, and the URL for every enqueued stylesheet is filtered by the style_loader_src filter, so we'll use these filters to put the new, improved URL in the HTML. This is an absolute URL, so we can take it apart, move the parts around so that it looks how we like. Here's the function I'm using to change the URLs, plus two lines to hook on to the filters:


/**
* Changes WordPress's default versioned URLs from putting the verion in the
* querystring to putting the version as part of the file page, (requires
* .htaccess modification to work). If there's no version in the querystring
* one can be added by setting the $defaultversion.
* @param string $url The URL to change the location of the version.
* @param mixed $defaultversion A string default verion. Defaults to false, (
* no default version).
* @return string The new URL.
*/
function jb_better_versioned_url( $url, $defaultversion = false ) {

// don't bother for the admin
if ( ! is_admin() ) {

// parse the URL
$parts = parse_url( $url );

// and the querystring
$query = wp_parse_args( $parts['query'], array() );

// check if there's a version in the querystring. If so, do more.
if ( isset( $query['ver'] ) || false !== $defaultversion ) {

if ( isset( $query['ver'] ) ) {
// prepend "/ver" + {version value} to the *path*
$parts['path'] = '/ver' . $query['ver'] . $parts['path'];

// unset the version in the querystring, since it's in the path now.
unset( $query['ver'] );
} else {
$parts['path'] = '/ver' . $defaultversion . $parts['path'];
}

// if this is a PHP file just let it be.
if( ! preg_match( '~\.php$~', $parts['path'] ) ) {

// start rebuilding the URL string
$url = $parts['scheme'] . '://' . $parts['host'] . $parts['path'];

// see if there's still anything in the query
if ( count( $query ) > 0 ) {

// rebuild query with whatever remains
$parts['query'] = build_query( $query );

// append it to the URL string
$url .= '?' . $parts['query'];
}
}
}
}

return $url;

}

// hook onto the filters
add_filter( 'style_loader_src', 'jb_better_versioned_url' );
add_filter( 'script_loader_src', 'jb_better_versioned_url' );

With these two modifications all of your JavaScript & CSS will have the version in the path instead of the querystring. In addition, any images, fonts, or anything else referenced with relative URLs from your stylesheets will have the version in the beginning of their URL, which will be rewritten and the file served properly. This way if you ever have caching problems you can bump a version number and browsers will pull new versions of all your static resources.

A Word of Warning

This involves considerable coding acrobatics, and adds complexity to your WordPress-based site, for speed improvements that may not be very large, and may not exist at all, so use this method at your own risk.

I have this code in production, but would love to hear the opinions of others on it, that's what the comments are for, or Twitter, or elsewhere - just let me know where the technique is discussed.

Regular Expression Testing Tool

I had a mod_rewrite problem that was really tough, tough enough that I needed to break down my Regular Expression step by step and see what was matching. I’m not a huge fan of doing this in Terminal, and I work on a Mac so Editpad Pro was out, (it’s good to use on a PC). So, I built a web-based tool to see how my regular expression was matched against a string. It’s available here.

To use it enter a Regular Expression, and a string to match it against. It’ll tell you if the regex matches the string and if so it’ll show you the substring that matches the regex, (if it is a substring), and any parenthetical substring matches.

This little script uses PHP’s native preg_match() function to determine matches, I believe its matching engine is very, very, close to Apache’s engine used in mod_rewrite so it should work well.

So, did this help me solve my problem? Yes it did. It told me that the problem wasn’t in the rewrite rule that I thought it was in.

Try out the Regular Expression Testing Tool.

Update 29 December 2010: I posted a small update to make the input fields larger and corrected some text when the regex does not match.