Say the phrase “WordPress hooks,” and any novice developer will almost invariably balk and begin fretting over how difficult it is to understand implement these advanced pieces of code in independent plugins and theme-specific functions.php files. This might be because there are simply so many WordPress hooks to be learned, or it might be because using them to modify the output of a WordPress installation can be a bit daunting at first, especially because it requires knowledge of functions, actions, filters, database information, and occasionally the WordPress variables themselves.
However, WordPress hooks are really not that difficult to learn and they’re a pretty amazing aspect of the world’s most popular content management software. It is these hooks which transform WordPress from a mere content management solution into a robust, website management solution that can be altered to perform almost any task and display almost anything in a web browser.
To begin using WordPress hooks, one must first learn how they work and how to properly construct them so that a WordPress installation can run smoothly and efficiently while producing the desired output without any bugs or glitches. This requires understanding things like actions and filters, as well as where to place the code to alter a WordPress hook, and where to find information on the names and functions of each hook available for modification.
This tutorial looks to jumpstart that process by introducing novice WordPress developers to all they’ll need to know to be successful in creating their own WordPress plugin or advanced theme.
First: Where Do WordPress Hooks Go? What is the Appropriate Placement of this Advanced Code?
There is always a little confusion with novice WordPress developers when discussing the placement of modified WordPress hooks within the filesystem that keeps the content flowing. In general, there are two rules of thumb to be followed when deciding where to place code that modifies the output of a WordPress installation:
- If the modification is intended to apply only to one theme, and the developer doesn’t mind losing this new functionality when they install and activate a new theme, it should be placed into the
functions.phpfile. This is also true for modifications of hooks which are purely design-centric, such as those that modify the header or footer. - If the modification of the hook is intended to be a site-wide, theme-independent one, then it must absolutely be placed within a new plugin PHP file. That file will then be uploaded to the standard plugins directory and no new theme will cause the functions set out in the plugin to be invalid or no longer displayed.
Once this question has been answered, create or open the appropriate file for modification and get ready to proceed with learning about WordPress hooks and putting them into action within a theme or across a website.
Second: Understand the Difference Between Actions and Filters
The primary way that every WordPress hook functions is by using an action hook or a filter hook. These two hooks are so similar that it’s pretty painful for new developers to figure out their differences and employ them correctly. However, the clues to their usage are actually stored right in the names. Action and filter are two very different words, and those functions are designed to do similar things in very different ways. Here’s how:
- The filter hook is not designed to retrieve or print data on its own. It does not perform any function except to modify information which has already been presented to it. This is much like a coffee filter. The coffee filter does not supply the coffee grounds, nor does it turn into coffee. Instead, it uses the coffee which has already been supplied to it and produces the coffee using the filter itself. That’s pretty clear, right?
- The action hook, on the other hand, is doing the real work when it comes to supplying information to the function. Remember, the function cannot (or, at the very least, should not) have any information of its own. Instead, the action hook “does” something, such as contacts the database, and retrieves the requested information. It then supplies that information to the filter, which acts upon it and returns a modified block of text or other content.
To make it almost too simple: Action hooks do something, while filter hooks modify something. End of story.
Third: Creating a WordPress Hook Within the Theme-Specific Functions.php File
WordPress has some great variables to control the printing of information, and one of the ones that is most used is the comment_author variable. This variable, quite simply, prints the author’s name next to a comment wherever the variable is placed. It does not have any prefix or suffix, and it requires that text to be placed manually into the comment display template when the theme is developed. To say this is inefficient and backwards is an understatement, especially because it would be nice to customize the comment text without opening up a template file and searching through line after line of tedious XHTML programming.
Instead of doing things the old-fashioned way, we’ll plug into the comment_author hook which already exists in the site-wide functions.php file which is placed in the wp-includes directory within the WordPress root folder. There, we’ll add an action which specifies a byline for the comment author and we’ll add that into the existing hook. The byline will then automatically precede the comment author’s name without any modification of the template file. And, when or if the byline text is changed in the functions file, it will apply site-wide no matter where that author variable is placed.
Here’s how the new hook will look when placed into the functions.php file which pertains to only the currently-activated WordPress theme:
add_action ("comment_author_byline", "comment_author");
function comment_author_byline() {
if(is_singular()){
echo: "< span class="author-byline" >Published by: . $get_comment_author . < /span >";
} }
That’s pretty easy to do, right? Simply enough, the first line of the hook is an action hook. This serves to priotize adding the byline. That’s why the byline is placed before the actual comment author variable. This way, the byline comes before the author’s name and not after. The second piece of the code essentially overwrites the default hook for the author’s name and instead replaces it with the example above. That means that the author’s name will now always be enclosed in a <SPAN> tag, and it will always have a byline. But, because the get_comment_author variable was maintained within the <SPAN> tags, the author’s friendly name will always appear, along with a link to their email address or website that was submitted at the time they published their comment.
Of course, the “published” text can be changed to anything the website administrator wishes it to be. It’s worth noting that this function will only modify the comment author hook if the reader is on an entry’s standalone page. This is done to avoid conflicts with the author profile page and other areas of the website, which display the author’s name in different ways and simply do not require a byline to be prefixed at all. This conditional variable can be changed or removed at the site administrator’s discretion.
Fourth: Learning the Vast Library of Available WordPress Hooks
So, the comment author information is part of a WordPress hook. If something that simple is considered a hook, how many other things are also determined by a WordPress hook? The answer is, quite simply, “hundreds.” There’s no easy way to cover every single WordPress hook in this tutorial, and it would be unwise to burden this tutorial with a list of hundreds of WordPress hooks that cover everything from the operation of the WordPress Dashboard to the presentation of entry content and the footer on every page.
Luckily, AdamBrown.info’s eponymous publisher has done the hard work of categorization of WordPress hooks for the wider community of developers who are trying to learn them. This is no small feat, either, as the list is constantly changing and growing larger with every WordPress release. Indeed, the number has grown from just a few hooks in early WordPress versions to the large number that now dominates WordPress 3.3 and higher.
AdamBrown.info’s extensive library of WordPress hooks is helpful to developers not only because of how broad it is, but of how seriously in-depth it gets when displaying these hooks. All WordPress hooks can be displayed by the version number of the software installed to the user’s server, and they can be separated into groups of filter hooks and action hooks. The website also maintains what might be the most valuable WordPress development resource anywhere online; users can easily look at a list of hooks which have been discontinued or renamed over the course of the WordPress software’s development.
Filtering hooks by those which have been deprecated or those which have had their name changed is an amazingly useful resource for more advanced developers, and one which should be monitored after each WordPress release is made public. Deprecated hooks are often still supported by the WordPress software for an additional version or two, but developers will need to adapt their software to a new reality quickly in order for their work to be maximally compatible with current and future WordPress versions. Because it caters to both novice and advanced WordPress developers, this library of WordPress hooks should be in everyone’s bookmarks folder for quick access and reference during the development process.
Fifth: Trial and Error is the Key to Greater Knowledge
When it comes to developing for WordPress and mastering the art of PHP hooks, there is no better teacher than trial and error. Sure, it’s frustrating to employ a filter hook within a comment tag and experience a PHP error. But it is those errors which help developers learn the limitations of hook-centric programming, as well as the intricate differences between filter and action hooks which might stop them dead in their tracks until they’ve gotten it right.
WordPress hooks are among the most advanced ways to develop new features for the world’s most popular content management software solution, and they’re the best way to modify existing data in the WordPress database at the time it is rendered by the software and printed to the end user. WordPress hooks can be used to truncate entries, pages, and comments, modify the way categories behave and are listed to the public, and add new features such as Twitter-based tweetbacks, tighter Facebook integration, completely customized control panels for use within the WordPress Dashboard.
Remember to pair trial-and-error programming with a private development website and a thorough test for bugs before making any modifications public on a production website. With the right knowledge of hooks, a solid foundation that knows the difference between actions and filters, and an appreciation for prioritization and order of coed, WordPress can indeed be instructed to do just about anything.
