It’s really easy to get really mixed up when trying to program with date functions – lots to keep track of, calendars, timezones, daylight saving, weird months that have different numbers of days in them…

Here’s a quick rundown on the main PHP functions involved.

1. checkdate()

bool checkdate ( int $month , int $day , int $year )

Does just what it says, for the Gregorian calendar, and it’s been around since PHP4 – a very quick way to ensure that the programming isn’t coming up with any silly results. Always useful!

2.. date() and gmdate()

From a given UNIX timestamp, date() tells you what time would be in your server timezone and gmdate() tells you what GMT it would be (or UTC, the same thing…). It is important to get the hang of the consequences of this and one way of figuring it out is to bear in mind the date() format character “Z” – the timezone offset in seconds, positive or negative.

No matter what the timezone is set to, these 2 expressions will produce the same result…

<?php
	date_default_timezone_set('America/Montreal');

	echo date("Y/m/d H:i:s",(time()));
	echo gmdate("Y/m/d H:i:s",(time()+ date("Z")));

?>

3. strtotime()

Takes a string and should return a Unix timestamp.

It does say string in “US English date format” – which means that for strtotime (“04/06/2010″) is April 6th, and not the 4th of June. (Probably no need to get into a discussion about the relative logic of the two systems here).

strtotime has a pretty decent understanding of language – so you can do relative times:

strtotime('next Monday');
strtotime('+1 years');
strtotime('first day next month');
strtotime('2010-02 last day');

All return what you’d expect, based on the datetime the function’s run…

4. mktime()

Good for catching “overflows”.

echo date("M-d-Y", mktime(0, 0, 0, 12, 32, 2009)) // => Jan-01-2010
echo date("M-d-Y", mktime(0, 0, 0, 15, 31, 2009)) // => Mar-31-2010

Like strtotime, mktime doesn’t go in unit magnitude order – it’s hours, minutes, seconds, months, days, years…. why? because that’s the decision that was made…

Find a birth day with mktime:-

	$my_birthdate = mktime(0,0,0,5,12,72);
	print date("l", $my_birthdate);
	//gives:   Friday

A Few More Calendar Tricks

Current age

<?php  echo floor(abs(strtotime('Y') - strtotime('02/22/1968'))/31536000);  ?>

Easter date

<?php echo date("M-d-Y", easter_date(2010));   ?>     // Apr-04-2010

Datetime constants
PHP 5.1 and later, via the DateTime class, offers a few shorthand formatting strings.

<?php echo date(DATE_RSS); ?>
//gives something like: Thu, 21 Feb 2010 09:35:44 -0800

The defined strings are here – also good for cookies.

Daylight Saving Problems
One way of cutting out possible problems with daylight saving time differences across timezones is to work in UTC, using expressions like these (and then revert back to a local timezone at the end if necessary).

date_default_timezone_set('UTC');

$date_utc = strtotime($date. " UTC");

You need a cron job in your WordPress blog – something run to a schedule, hourly, daily… Instead of fixing up a crontab and using wget or lynx, you can use WordPress’s internal version of the cron job.

This isn’t a true cron job, with a crontab text file sitting on the server – it’s known as a pseudo-cron. Since a script can’t launch itself, it makes use of a visitor, human or maybe robot, launching it by requesting a page. So the job actually runs at the first launch after the scheduled time, not necessarily at the scheduled time to the exact second.

wp_schedule_event()

The most convenient way of using WP-Cron is to wrap it all up in a plugin – so that the scheduling can be done just the once by including it in the plugin activation function.

register_activation_hook(__FILE__, 'my_activation');
add_action('my_hourly_event', 'do_this_hourly');
register_deactivation_hook(__FILE__, 'my_deactivation'); 

function my_activation() {
wp_schedule_event(time(), 'hourly', 'my_hourly_event');
}

function my_deactivation() {
	wp_clear_scheduled_hook('my_hourly_event');
}

function do_this_hourly() {
	// do something here every hour
}

The PHP time() used as an argument indicates “as of now” – so if the plugin is activated at 11:23, an hourly event is going to run at xx:23 from now onwards.

If your code is in for example functions.php and is executed every time the script is executed, you don’t want to keep scheduling the same event. Something like this prevents the problem:-

if (empty(wp_next_scheduled('my_event')))
		wp_schedule_event(time(), 'daily', 'my_event');

WP-Cron Hourly, Recurrence Intervals

Only hourly, daily and twicedaily are available immediately – but there’s a trick to getting more and that’s to tap into the cron_schedules filter and add a key to the schedules array.

add_filter('cron_schedules', 'my_add_weekly');

function my_add_weekly( $schedules ) {
	$schedules['weekly'] = array(
		'interval' => 604800, //that's how many seconds in a week, for the unix timestamp
		'display' => __('Once Weekly')
	);
	return $schedules;
}

WordPress is (mainly) backwards-compatible in terms of its core code. But the code connected with themes or plugins that you add may well not be. For example, v2.9 has post thumbnails – put these in your new theme and they won’t work for older installs of WordPress – so some version testing is required.

There’s 2 ways to go about this:-

1. If you reckon your theme is no good without the features available to the latest version, you can prevent people from installing it in the first place – a bit brutal, but it does the job.

In functions.php, at the top:-

if(version_compare(get_bloginfo('version'), '2.8') < 0) die(__('This theme requires at least WordPress version 2.8','thistheme'));

More information about how PHP’s native function version_compare works here.

And then do tell people explicitly when they download the theme – compatible with WordPress versions > 2.8 etc.
In practice, some regularly manage not to read this, so stand by for complaint emails….

2. You can catch the errors before they happen – function_exists?

There’s a bit more work involved here. The guiding principle is to try to catch the errors as concisely as possible, rather than have a string of actions all wrapped up in their own if function_exists statements – and hopefully also offer some alternative to make sure that the degradation is as graceful as you can make it…

As a basic example, the file_get_contents function arrived in PHP 4.3 – and as of now, there are still servers around with older versions of PHP than this…

if function_exists('file_get_contents'){
//use it
$file = @file_get_contents($some_url);
} else {
// don't use it...
// and try to supply some alternative or warning
}

In the same area of grabbing a file, especially remotely, testing for curl is necessary…

if (function_exists('curl_open'))

You can also use:

if  (in_array ('curl', get_loaded_extensions()))

As an aside – WordPress comes with Snoopy bundled – custom-written to do the same job, but you do have to explicitly include it – so in a theme or plugin, the ‘official’ way to do it is something like,

require_once(ABSPATH.WPINC.'/class-snoopy.php');
$s = new Snoopy;

Lastly, and this is a very occasional thing – but since there are compiling options with PHP, (which modules are included and in which combination) a function name may exist even though the function itself can’t be used. Image functions associated with the GD extension can be a problem here, beware of functions like imagettfbbox(), imagefttext()…

You want a jQuery slideshow for your WordPress blog? - on the front page, or maybe in the sidebar? No real problem, all the javascript is taken of with the help of a jQuery plugin, all we have to do is figure out how to get the post data.

And to keep things really simple, this is going to use the thumbnail functions in WP 2.9 – no need to mess around with custom fields any more.

Firstly, you do have to explicitly declare the new thumbnail system in functions.php – and best to wrap it up in an “if function exists” to avoid problems for older WP installs.

if (function_exists('add_theme_support')) {
add_theme_support( 'post-thumbnails' );
add_image_size('slideshow-image', 300, 160); // for front page slideshow
}

The smart move is to define a “Featured” category – any post in that category will be available for the slideshow, and that’s the selection taken care of. Create a category – call it featured, or anything, but make a note of the cat_ID – mouseover a category on the admin categories page and it’ll be in the url, something like:

http://testblog.com/wp-admin/categories.php?action=edit&cat_ID=3

The ordering will be by date, newest first. (Don’t forget you can tweak the timestamp of a post if you really want to just to get the order exactly as you want it).

So create a couple of posts in this category and add some thumbnails to them – since our slideshow is going to be 300px by 160px, make sure they’re bigger than that. Then, in home.php, or index.php, where ever you want the slideshow to appear, add:

<?php

$featured_category_id = 3;
$number_of_posts = 4;

$args = array('showposts'=>$number_of_posts, 'cat'=>$featured_category_id);

$slideshow_query = new WP_Query($args);

?>
<div id="slideshow">
<?php
// let's keep a record of the post IDs as we go, in case we want to omit these from other post loops/lists on the same page
$duplicates = array();

while ($slideshow_query->have_posts()) : $slideshow_query->the_post();

//add the ID to the duplicates array for future reference
$duplicates[] = $id;

//test to see whether there's a thumbnail associated with the post
if (has_post_thumbnail()) {
?>
<div class="post-thumbnail">
<a href="<?php the_permalink(); ?>">
<?php	the_post_thumbnail('slideshow-image'); ?>
</a>
</div>
<?php	}
endwhile;
?>
</div>  <!-- end of #slideshow -->

Next, some javascript. We can use the excellent jQuery Cycle Plugin – as the package stands currently, we’ll use jquery.cycle.all.min.js – which allows all the possible transition effects etc. – in practice, you may well want to use the lighter versions…

* For a standard production site, always use min = minified, rather than pack = packed – pack may be a smaller filesize, but it doesn’t run quicker….

We need a very quick script to configure and activate the plugin – so create a new file, slideshow-activate.js

jQuery(document).ready(function($){
$('#slideshow').cycle({
fx: 'fade' // choose your transition type, ex: fade, scrollUp, shuffle, etc...
});
});

Later, there are lots of options here, transition speed, pausing etc. – consult the plugin pages for ideas.

We need to get our scripts on the WordPress page, and indicate that they depend on jQuery being loaded – making use of the WordPress functions wp_register_script and wp_enqueue_script – so in functions.php

add_action('wp', 'js_head_load');

function js_head_load(){

if(is_admin()) return;  //so that we're not loading unecessary scripts in the admin

wp_register_script('cycle', get_bloginfo('template_directory')  . '/scripts/jquery.cycle.all.min.js', array('jquery'), '1.0');

wp_enqueue_script('slideshow-activate',  get_bloginfo('template_directory')  . '/scripts/slideshow-activate.js', array('jquery', 'cycle'), '1.0');

}

And then, don’t forget to put the 2 files into /scripts in your theme folder…

That should give you a working slideshow – ready to be styled with some CSS. Note that the way the Cycle plugin works is that it looks to rotate the immediate children of the div being called – here, they’re images, they could be eg. divs – so if you add a wrapper div(s) you may need to adjust slideshow-activate.js.

And if it’s not working, check first that the right scripts (jQuery, Cycle, slideshow-activate) are actually being loaded and in the right order, by looking at the page source – and check you’ve got thumbnails attached to the relevant posts…

You could go on to tidy this up – avoiding the hard-coded category id by having something in the theme options admin to change the id for example. Also, as said earlier, there’s a lot of scope in playing with the plugin parameters to get exactly the slideshow you want…

Lastly – the record of the duplicates we kept – the method for omitting them from subsequent Loops of posts is here: Multiple WordPress query duplicates

There’s no point in hacking around with the WordPress core code. You still see people doing it sometimes and happily showing off their results, but it just isn’t a good idea. Nobody else can use it without making the same hack(s), which aren’t carried through an automatic update anyway.

WordPress action hooks allow you to access the functions of the core WP code, without messing around with that code. It’s the basis for most plugins (the whole business essentially started out as the plugin API), but themes are using them more and more and there’s no reason not to… do_action/add_action are also the means of getting external scripts, CSS, javascript/jQuery correctly on the page.

WordPress pre-dates PHP5 and the improvements available in terms of Object-Orientated Programming (OOP). So, while there are obviously classes and objects in there, everything has a flow – once the PHP engine has compiled the code, it’s run from top to bottom – it’s procedural, as they say.

Instead of adding a method to a class, or extending a class with another class, there are points in the action where the possibility of doing something is left open – action hooks – either predefined, because they’ve been put in the core code, or you can create your own.

The means of doing it involve a couple of functions…

do_action() and add_action()

Simply, do_action() is the function to create an action hook.

Whereas add_action() is tacking actions onto a given hook and always refers to a function that will called at that point.

<?php do_action( $tag, $arg ); ?>

<?php add_action( $tag, $function_to_add, $priority, $accepted_args ); ?>

The $tag is the action hook itself, a description of “where” – at what point in the action…

As an example, we can create an action hook that outputs some content on the home page just before the Loop of posts is output.

so in home.php

 <?php

 do_action( 'before_the_index_loop' ); 

    if (have_posts()) : while (have_posts()) : the_post();
     //etc etc
?>

and in functions.php

add_action( 'before_the_index_loop', 'my_helloworld_display' );

function my_helloworld_display(){

 echo "<p>This is my hello to the world</p>";

}

At the point where it reaches the action hook ( ‘before_the_index_loop’ ) put there by the do_action, it finds a function (my_helloworld_display) to call and calls it.

(Or you could put this in index.php and test whether it’s running as the home page by using is_home().)

Priority

Everything has an order – lower to higher – and if you don’t specify it, the default value of an action is 10.

So here, as an example, we can add an action earlier in the document flow that’s actually going to be run after the next add_action.

add_action( 'my_helloworld', 'my_second_helloworld_display', 20);
add_action( 'my_helloworld', 'my_helloworld_display');

function my_second_helloworld_display(){
 echo "<p>Hello again to the world</p>";
}

function my_helloworld_display(){
 echo "<p>Hello to the world</p>";
}

Will produce:

Hello to the world
Hello again to the world

Accepted arguments

In, say, header.php, we can place a hook with some arguments:

do_action( 'my_details', get_bloginfo('name'), get_bloginfo('description'));

While in functions.php we’re going to expect 2 arguments to be passed to the function.

add_action( 'my_details', 'my_details_display', 10 ,2);

function my_details_display($name, $description){

 echo "<p>This is the name of my blog: {$name} and this is its description: {$description}</p>";
}

(Of course, this is just for the very simple example of it, to show how arguments are passed to any function referenced by an add_action – the whole process could have been short-cut just by putting bloginfo(‘name’) on the page…)

In practice, it can be slightly tricky to find out the what and how many of arguments are being passed to predefined action hooks – that’s when you do have to look into the core code.

And just for experiment (on a development site, don’t leave lying around on anything live)

add_action('wp', 'my_vardump');

function my_vardump($query){
	global $post;
	print_r($query);
	print_r($post);
}

Just to see what’s available to play with…

There are a lot of action hooks strewn around the place in WordPress code already – not all of them are terribly well-documented, (it’s a large job). The thing to do is to consult first the Codex for the main list of hooks and then experiment, adding your own hooks and making use of those already there. At least, action hooks do simplify the whole process – it’s only one line of code to comment out if things start going wrong.

So you want to display a random list of posts, maybe in a sidebar widget…

One way to do it is to use the query_posts() function

<?php
    query_posts('showposts=6&amp;amp;orderby=rand'); 

    if (have_posts(){
	while (have_posts()){
	the_post();

	//do something with the postdata
	}
}
?>

But it’s easy to get in a mess with query_posts – as they do say…

The query_posts function overrides and replaces the main query for the page. To save your sanity, do not use it for any other purpose.

Often best to instantiate a new, completely separate object where you can see it, as it were:

	$args = array('showposts'=>6, 'orderby'=>'rand');
	$customQuery = new WP_Query($args);

	if($customQuery->have_posts()){
		while ($customQuery->have_posts()){
			$customQuery->the_post();
	//do something with the postdata
 }

}

It’s a good general rule to get into the practice of using WP_Query in cases like these – a lot safer…

Since the arrival of WordPress 2.7, the true framework is based on the concept of parent/child WordPress themes.

A child theme is dependent on its parent – here, the framework – for its template files and functions, it’s not going work without it – ‘parasite’ might be a better name.

When you install a WordPress framework theme, it doesn’t look very impressive to start with – black and white – but that’s not the point. The basic idea is to cover all the fundamentals in the parent framework, the stuff every good theme needs, and keep separate the fancy styling, add-ons etc. in the child theme.

The art of a good framework is how it lets in the customization. Much like PHP frameworks, used wisely, they allow flexibility and concise code, quickly applied – used unwisely, they rapidly become a big old mess with far too many moving parts…

Any good WordPress theme developer will have ended up with a core code that does the job the way he or she thinks best – and this is the origin of a framework. Frankly, if you are are more programming-orientated as a theme designer than design-orientated, they may not be for you. Whether you stick with your code, or dip into your first framework child theme, up to you… but here are the current market leaders, as it were, in no particularly significant order.

Thematic
Produced by Ian Stewart, the prime mover in getting parent-child themes off the ground, Thematic has grids, CSS frameworks, and 13 different widget-ready areas. There’s a growing selection of child themes, free and premium, and support forums.

ThemeHybrid
Again, all the usual goodies, ThemeHybrid also comes with a good selection of child themes built up. For enhanced support in developing and customizing your own theme, ThemeHybrid has a paid club membership option (currently US$25).

Buffet
Buffet has a variety of jQuery features – Superfish menus, SuperSleight for png transparency in IE6, jBreadcrumb. It also offers 2 CSS frameworks – 960gs and the Blueprint CSS frameworks – and support for microformats, XOXO, hAtom, hCard…

Sandbox
Sandbox is probably the original – been around for years – a minimalist Wordpress Theme, designed for developers to build on and produce workable themes simply using CSS. But it’s fully widget-ready, XHTML valid and released under the GPL.

OnePress
The unique proposition for OnePress is its integration with phpBB, with a unified login and forum messages displayed on the blog – if you’re a jobbing site-builder this is certainly something that comes up as a very common client requirement.

Conclusion

There are other frameworks – many other frameworks – in different states of development. This is a hot topic in WordPress theme design and I’m sure the situation will continue to evolve – much like the arrival of javascript libraries, there’ll be a fair amount of competition before the winner(s) emerge.

You’ve got 2,3,4… custom post queries on a page and you need to get some control over duplicates – it looks unprofessional if your theme keeps showing the same stuff. Let’s take the example of displaying separately posts from 2 different categories – but if a post is in both categories, not duplicated across the lists.

The process is fairly simple:- 2 custom queries, but we catch a list of the post_ids as we loop through the first query, ready for their exclusion from the second.

	// declare the duplicates array - good practice
	$duplicates = array(); 

	$args = array('cat' => '5', 'showposts'=> '10');
	$customQuery = new WP_Query($args);

	if($customQuery->have_posts()){
		while ($customQuery->have_posts()){

			$customQuery->the_post();

			//here's where we catch the ids
			$duplicates[] = $post->ID; 

			//do something with the postdata, display it etc.
		}
	}

The post__not_in parameter of a WP_Query takes an array – which is kinda useful, since an array is just what we’ve got – never say WordPress developers aren’t on the ball…. Don’t forget, it still needs to be an array, even if you’re only passing one value. So if we continue….

	$args = array('cat' => '6', 'showposts'=> '10', 'post__not_in' => $duplicates);
	$customQuery2 = new WP_Query($args);
		if($customQuery2->have_posts()){
	// etc etc

Another obvious application is in displaying a query of featured (category) posts and then not duplicating these posts in the later display of latest posts – a common trope in the average theme index page nowadays…

You’re producing a WordPress theme, or plugin, that is related to Twitter and for obvious reasons you want to include url-shortening functionality… How’s it, generally, done?

Just the briefest snippet of PHP, this example for is.gd:-

	function shorten_url($url)	{
		$request = 'http://is.gd/api.php?longurl=' . $url;
		return @file_get_contents($request);
	}

You might want to do a bit of error-catching on that. We’ve used file_get_contents() on the basis that we write themes and plugins that work on PHP5 – the ‘official’ WordPress way is probably still to use the bundled version of Snoopy. Or there’s always cURL – unless there isn’t on your server…

Any decent url-shortening service will have its own RESTful API location to do this – hunt in their Developer Tools

http://tinyurl.com/api-create.php?url={long_url}

et al… though some require login/password parameters to be passed, and some definitely require urlencoded parameters

But…. your own name

Don’t forget, in the particular case, if you’re customising your own WordPress installation, the possibility of using $_GET urls -these may well be short enough (if your domain name is short enough… obviously….) . Using your own domain name has 2 advantages, 1 significant

1. If third parties quote the link directly on their web pages it’s your site getting the link value.
2. Still works if the url-shortening site happens to die before your blog does…

And even if you have permalinks active, urls will redirect….

http://themocracy.com/?p=188 will redirect you to the pretty permalink version – job done.

Note, we’re talking here about different category archive pages – not having a post page customised according to the category that post is in….

There’s 2 ways of doing this – first, the simple way, for more minor changes to the overall theme template, you can use the is_category function:

if (is_category('featured')) {
// some different code here for the featured category archive
// such as, if this code is in the header, load a different or supplementary stylesheet
} else {
//code here for every other category - if required...
}

So for example, you could have a category set aside for video posts and have its archive page display extra information about each post, using get_post_meta()…
And single_cat_title() has its uses in this context.

Custom Category Templates

But secondly, just like WordPress page templates, you can customise by category by using a separate template file.

All you need to do is copy say, category.php to a new file: category-video.php and make the desired changes. This way, WordPress will find and load this file for you, via its priority in the template hierarchy

The template hierarchy: WordPress works down the list, checking for a match – the first file found that satisfies the criteria is the one used to display the archives for that category.

1st. category-slug.php – define category using its slug name (WP 2.9+ only)
2nd. category-ID.php – define category using its ID
3rd. category.php
4th. archive.php
5th. index.php – the default template

(Note also, it’s a hypen not an underscore)

This does amount to roughly the same thing as a conditional php include, but can be a more elegant way of doing things…