The Shortcode API enables creating simple macro codes, sometimes also referred to as bbcodes for their similarity with a popular syntax in various forums and bulletin boards.

In a nutshell, a shortcode is a simple tag syntax between square brackets, such as [something], used in posts. At render time when the post is displayed, the shortcode is dynamically replaced with a more complex and user-defined content. See Figure 10-1 for a simple example of a shortcode plugin that would substitute [date] with the current date and time.

Figure 10.1. FIGURE 10-1

WordPress out-of-the-box registers shortcodes you can use: When you upload multiple images attached to a given post, you can simply insert [gallery] in your post, and this shortcode will be replaced with a nicely formatted gallery of your images.

Technically, a shortcode can be any string that would fit as an array key. For instance, you could register the following different shortcodes:

In practice, for simplicity, and to avoid potential conflicts between different shortcodes, you register only short, lowercase, simple strings.

You now learn how to register your own shortcodes, with practical usages, from a simple tag replacement to more complex and parameterized output.

The following shortcode plugins use boj_scX as a prefix, where X will be a number.

<?php
/*
Plugin Name: Shortcode Example 1
Plugin URI: http://example.com/
Description: Replace [book] with a long Amazon link
Version: 1.0
Author: Ozh
Author URI: http://wrox.com/
*/

// Register a new shortcode: [book]
add_shortcode( 'book', 'boj_sc1_book' );

// The callback function that will replace [book]
function boj_sc1_book() {
    return '<a href="http://www.amazon.com/dp/0470560541">book</a>';
}


?>

<?php
/*
Plugin Name: Shortcode Example 2
Plugin URI: http://example.com/
Description: Replace [books title="xxx"] with different Amazon links
Version: 1.0
Author: Ozh
Author URI: http://wrox.com/
*/

// Register a new shortcode: [books title="xxx"]
add_shortcode( 'books', 'boj_sc2_multiple_books' );

// The callback function that will replace [books]
function boj_sc2_multiple_books( $attr ) {

    switch( $attr['title'] ) {
        case 'xkcd':
            $asin = '0615314465';
            $title = 'XKCD Volume 0';
            break;

        default:
        case 'prowp':
            $asin = '0470560541';
            $title = 'Professional WordPress';
            break;
    }

    return "<a href='http://www.amazon.com/dp/$asin'>$title</a>";
}
?>

<?php
/*
Plugin Name: Shortcode Example 3
Plugin URI: http://example.com/
Description: Replace [amazon isbn="xxx"]book title[/amazon]
Version: 1.0
Author: Ozh
Author URI: http://wrox.com/
*/

// Register a new shortcode: [amazon isbn="123"]link title[/amazon]
add_shortcode( 'amazon', 'boj_sc3_amazon' );

// Callback function for the [amazon] shortcode
function boj_sc3_amazon( $attr, $content ) {

    // Get ASIN (Amazon Standard Identification Number)
    if( isset( $attr['asin'] ) ) {
        $asin = preg_replace( '/[^\d]/', '', $attr['asin'] );
    } else {
        $asin = '0470560541';
    }

    // Sanitize content, or set default
    if( !empty( $content ) ) {
        $content = esc_html( $content );
    } else {
        if( $asin == '0470560541' ) {
            $content = 'Professional WordPress';

} else {
            $content = 'this book';
        }
    }

    return "<a href='http://www.amazon.com/dp/$asin'>$content</a>";
}
?>

<?php

add_shortcode( 'boj', 'boj_my_shortcode' );

?>

<?php

function boj_my_shortcode( $attr = array( 'var' => 'val' ), $content = 'book' ) {
    // $attr is an associate array

// $content is a string

    return $something;
}

?>

As a plugin user, it's great to add new features to one's blog and being allowed to write a simple shortcode that can display much more complex content. But it's cumbersome to remember the shortcode parameter syntax: you end up with the impression that you have to learn a new markup language.

Back to your plugin with the [amazon] shortcode: You can now code a companion plugin that will add the shortcode [amazonimage] to display product images from Amazon. You can specify the ASIN number, the image type (books or CD covers), and its size.

When functional, the plugin permit shortcodes such as [amazonimage asin='123456' type='CD' imagesize='small'].

When users have this plugin installed for a long time, they might have forgotten about the attribute names and syntax. Is it [amazonimage] or [amazonimg]? As for the attributes, is it isbn or asin? And imagesize='large' or 'big'? type='CD' or type='disk'?

Allowing lots of options is neat, but you don't want your users having to check the plugin documentation and give them a bad experience. Instead, make things simple and foolproof so that users can use your plugin instinctively.

Now to the plugin:

<?php
/*
Plugin Name: Shortcode Example 4
Plugin URI: http://example.com/
Description: Replace [amazonimage] with images from Amazon
Version: 1.0
Author: Ozh
Author URI: http://wrox.com/
*/

// Register two shortcodes [amazonimage] and [amazonimg]
add_shortcode( 'amazonimage', 'boj_sc4_amazonimage' );
add_shortcode( 'amazonimg',   'boj_sc4_amazonimage' );

// Callback function for the shortcode
function boj_sc4_amazonimage( $attr, $content ) {

    // Get ASIN or set default
    $possible = array( 'asin', 'isbn' );
    $asin = boj_sc4_find( $possible, $attr, '0470560541' );

    // Get affiliate ID or set default
    $possible = array( 'aff', 'affiliate' );
    $aff = boj_sc4_find( $possible, $attr, 'aff_id' );

    // Get image size if specified
    $possible = array( 'size', 'image', 'imagesize' );
    $size = boj_sc4_find( $possible, $attr, '' );

    // Get type if specified
    if( isset( $attr['type'] ) ) {
        $type = strtolower( $attr['type'] );
        $type = ( $type == 'cd' || $type == 'disc' ) ? 'cd' : '';
    }

    // Now build the Amazon image URL
    $img = 'http://images.amazon.com/images/P/';
    $img .= $asin;
    // Image option: size
    if( $size ) {
        switch( $size ) {
            case 'small':
                $size = '_AA100';
                break;
            default:
            case 'medium':
                $size = '_AA175';
                break;
            case 'big':
            case 'large':
                $size = '_SCLZZZZZZZ';

break;  // Good practice: don't forget the last break
        }
    }
    // Image option: type
    if( $type == 'cd' ) {
        $type = '_PF';
    }
    // Append options to image URL, if any
    if( $type or $size ) {
        $img .= '.01.' . $type . $size;
    }
    // Finish building the image URL
    $img .= '.jpg';

    // Now return the image
    return "<a href='http://www.amazon.com/dp/$asin'><img src='$img' /></a>";
}

// Helper function:
// Search $find_keys in array $in_array, return $default if not found
function boj_sc4_find( $find_keys, $in_array, $default ) {
    foreach( $find_keys as $key ) {
        if( isset( $in_array[$key] ) )
            return $in_array[$key];
    }
    return $default;
}
?>

Code snippet plugin_boj_sc4.php

The first thing you'll notice is that you have registered two shortcodes with the same callback function: This way, the user can either use [amazonimage] or [amazonimg].

Then look at how the plugin considers multiple attributes as synonyms: Using the helper function named boj_sc4_find(), the main callback function checks the value of $attr['asin'] or $attr['isbn'], and if omitted, sets a default value.

As non-WordPress information, it's also worth mentioning that the fun part in this plugin is to leverage the way Amazon crafts image URLs. The base URL is http://images.amazon.com/images/P/, to which you append the following:

Activate the plugin, write a post with "Currently listening to [amazonimage asin= "B00008WT5E" type="cd" size="small"]" and see the result that should look like Figure 10-2.

Figure 10.2. FIGURE 10-2

Shortcode outputs are dynamically generated: Every time WordPress displays a page (a single post, an archive), the post content is parsed, and shortcodes are replaced with the returned result of their callback function.

Replacements such as the one you coded in this chapter so far are lightning fast, and you don't have to worry about WordPress' performance when you register new shortcodes.

However, performance will be a matter of importance if your shortcodes either pull information from the database or from remote web sites:

In such cases, you should consider caching the result of your shortcode, for instance in the post metadata. In the next plugin, you implement such a caching technique.

Besides using add_shortcode() to register new ones, here are other interesting functions or facts to know about the Shortcode API and then a fun plugin to make use of them.

<?php

global $shortcode_tags;
var_dump( $shortcode_tags );

/* Result:
array (
    'wp_caption'  => 'img_caption_shortcode',
    'caption'     => 'img_caption_shortcode',
    'gallery'     => 'gallery_shortcode',
    'embed'       => '__return_false',
    'amazonimage' => 'boj_sc4_amazonimage',
    'amazonimg'   => 'boj_sc4_amazonimage',
)
*/

?>

<?php

$content = <<<S
Some existing shortcodes: [amazonimage] [gallery]
These don't exist: [bleh] [123]
S;

echo strip_shortcodes( $content );

/* Result:
Some existing shortcodes:
These don't exist: [bleh] [123]
*/
?>

<?php

function gallery_shortcode( $attr ){

    // Define supported attributes and their default values
    $defaults = array(
        'order'      => 'ASC',
        'orderby'    => 'menu_order ID',
        'id'         => $post->ID,
        'itemtag'    => 'dl',
        'icontag'    => 'dt',
        'captiontag' => 'dd',
        'columns'    => 3,
        'size'       => 'thumbnail',
        'include'    => '',
        'exclude'    => ''
    );

    // Filter user entered attributes and set default if omitted
    $options = shortcode_atts( $defaults, $attr );

    //   [.. code continues ..]
    //   File: wp-includes/media.php

}
?>

<?php

// In wp-includes/shortcodes.php
add_filter( 'the_content', 'do_shortcode', 11 );
?>

<?php
// add shortcodes [b] and [i]
add_shortcode( 'i', 'boj_sc5_italic' );
add_shortcode( 'b', 'boj_sc5_bold' );

// callback function: return bold text
function boj_sc5_bold( $attr, $content ) {
    return '<strong>' . do_shortcode( $content ) . '</strong>';
}

// callback function: return italic text
function boj_sc5_italic( $attr, $content ) {
    return '<em>' . do_shortcode( $content ) . '</em>';
}

?>

You can now code a new plugin to enable BB-like tags in comments: Instead of using regular HTML tags such as <a> or <b>, commenters need to use [url] and [b] like in most forums.

The plugin will also have the following traits:

The plugin follows:

<?php
/*
Plugin Name: Shortcode Example 6
Plugin URI: http://example.com/
Description: Enables [url] and [b] shortcodes in comments
Version: 1.0
Author: Ozh
Author URI: http://wrox.com/
*/

// Hook into 'comment_text' to process comment content
add_filter( 'comment_text', 'boj_sc6_comments' );

// This function processes comment content
function boj_sc6_comments( $comment ) {

    // Save registered shortcodes:
    global $shortcode_tags;
    $original = $shortcode_tags;

    // Unregister all shortcodes:
    remove_all_shortcodes();

    // Register new shortcodes:
    add_shortcode( 'url', 'boj_sc6_comments_url' );
    add_shortcode( 'b', 'boj_sc6_comments_bold' );
    add_shortcode( 'strong', 'boj_sc6_comments_bold' );

    // Strip all HTML tags from comments:
    $comment = wp_strip_all_tags( $comment );

    // Process comment content with these shortcodes:
    $comment = do_shortcode( $comment );

    // Unregister comment shortcodes, restore normal shortcodes
    $shortcode_tags = $original;

    // Return comment:
    return $comment;
}

// the [b] or [strong] to <strong> callback
function boj_sc6_comments_bold( $attr, $text ) {
    return '<strong>' . do_shortcode( $text ) . '</strong>';
}

// the [url] to <a> callback
function boj_sc6_comments_url( $attr, $text ) {
    $text = esc_url( $text );

return "<a href=\"$text\">$text</a>";
}

?>

Code snippet plugin_boj_sc6.php

What just happened?

Activate the plugin and type in a new comment: See in Figure 10-3 how HTML tags are ignored; [b] and [url] shortcodes are processed but regular shortcodes such as [gallery], which would otherwise apply to posts, are not.

Figure 10.3. FIGURE 10-3

As you have read previously, WordPress can handle nested shortcode structures, provided their callback functions recursively call do_shortcode(). However, this handling has limitations and can sometimes fail, as you will see now.

The following structure is fine because nested shortcodes are different, and each one is correctly enclosed:

Works:
[foo]
    [bar]
        [baz]
    [/bar]
[/foo]

The parser will fail if you enclose a shortcode within the same shortcode:

Fails:
[foo]
    [foo]
    [/foo]
[/foo]

Also, remember that shortcodes can be self-closing (a standalone [foo] or [foo/]) or enclose content ([foo]content[/foo]), which can also make some structures impossible to parse correctly:

Fails:
[foo]
[foo]
    content
[/foo]

The first step to convert an address into a map is to "geocode" this address. Geocoding is defined as the process of converting a standard address (like "108 Ocean Ave. Amityville, NY 11701") to geographic longitude and latitude coordinates ("40.6665060, −73.4147750"). These coordinates are used by the Google Maps API to locate specific positions on a map and to plot markers on a map based on the coordinates specified.

Currently the Google Geocoding API can return results in two formats: JSON or XML. In this example you use the JSON format and work with the techniques discussed in Chapter 9, "HTTP API," about HTTP requests.

Google has made the process of interacting with its API simple. To retrieve coordinates you can request the following URL: http://maps.google.com/maps/api/geocode/$output?$parameters where $output will be the format output (for instance 'json') and $parameter will be a query string of additional parameters to geocode.

You need to pass only two required parameters to this API: address or latlng and sensor:

You can easily test this by loading the geocoding API URL in any browser and populating the required parameters: http://maps.google.com/maps/api/geocode/json?address=1600+Pennsylvania+Ave,+Washington,+DC&sensor=false.

As you can see, the JSON results returned contain the longitude and latitude coordinates of the address and additional data such as the ZIP code (which we didn't send in the request).

Now write the function boj_gmap_geocode() that will geocode an address:

<?php

// Geocode an address: return array of latitude & longitude
function boj_gmap_geocode( $address ) {
    // Make Google Geocoding API URL
    $map_url = 'http://maps.google.com/maps/api/geocode/json?address=';
    $map_url .= urlencode( $address ).'&sensor=false';

    // Send GET request
    $request = wp_remote_get( $map_url );

    // Get the JSON object
    $json = wp_remote_retrieve_body( $request );

// Make sure the request was successful or return false
    if( empty( $json ) )
        return false;

    // Decode the JSON object
    $json = json_decode( $json );

    // Get coordinates
    $lat = $json->results[0]->geometry->location->lat;    //latitude
    $long = $json->results[0]->geometry->location->lng;   //longitude

    // Return array of latitude & longitude
    return compact( 'lat', 'long' );
}
?>

This function sends a request to the Google Maps Geocoding API, and receives a JSON response which, when decoded, contains latitude and longitude. Test it to check the return value format:

<?php

$coords = boj_gmap_geocode( '108 Ocean Ave. Amityville, NY' );

var_dump( $coords );

/* Result:
array(2) {
  ["lat"]=> float(40.666506)
  ["long"]=> float(-73.414775)
}
*/
?>

For more details and explanation on the functions used in this function, refer to Chapter 9.

One important aspect of shortcodes is that they generate content dynamically each time. But that would not be efficient to issue an HTTP request to the Google Maps Geolocation API each time a post is displayed because it would slow down each page load.

As an alternative, when an address has been geolocated, you can store its coordinates in metadata attached to the post. This way, next time the same post displays, the latitude and longitude will be automatically fetched from the database with all other post metadata, thus saving one HTTP request.

Instead of getting coordinates from Google's API using the function boj_gmap_geocode(), you can use the proxy function boj_gmap_get_coords() that first checks for the information in the post metadata. If the information is missing, it will be fetched fresh from Google and then stored in the metadata for faster later reuse.

Following is your proxy function:

<?php

// Convert a plain text address into latitude & longitude coordinates
// Retrieved from meta data if possible, or get fresh then cached otherwise
function boj_gmap_get_coords( $address = '111 River Street Hoboken, NJ' ) {

    // Current post id
    global $id;

    // Check if we already have this coordinates in the database
    $saved = get_post_meta( $id, 'boj_gmap_addresses' );
    foreach( (array)$saved as $_saved ) {
        if( isset( $_saved['address'] ) && $_saved['address'] == $address ) {
            extract( $_saved );
            return compact( 'lat', 'long' );
        }
    }

    // Coordinates not cached: let's fetch them from Google
    $coords = boj_gmap_geocode( $address );
    if( !$coords )
        return false;

    // Cache result in a post meta data
    add_post_meta( $id, 'boj_gmap_addresses', array(
        'address' => $address,
        'lat' => $coords['lat'],
        'long' => $coords['long']
        )
    );

    extract( $coords );
    return compact( 'lat', 'long' );
}

?>

Each time an address is geolocated for the first time, the add_post_meta() call inserts into the post metadata named 'boj_gmap_addresses' an array like the following:

array(
    "address" => "108 Ocean Ave. Amityville, NY ",
    "lat"     => "40.666506",
    "long"    => "-73.414775"
)

On the next page load, the coordinates should be found and retrieved from the post metadata.

Now that you know how to convert an address into longitude and latitude coordinates using the Google Geocoding API, you can plot those coordinates on a Google Map using the Google Maps API.

API Concepts

Interactive Google Maps are created using JavaScript that must be inserted in the page where you want the map to display. Before integrating it straight into your plugin, you learn how to embed such a map in an HTML page:

First, you need to insert the main script:

<script type="text/javascript"
    src="http://maps.google.com/maps/api/js?sensor=false">

Then, insert the map-specific JavaScript part, enclosed in its own function:

function initialize_map() {

An object holds a new instance of a Google Map, with specific latitude and longitude parameters:

var myLatlng = new google.maps.LatLng(45.124099,-123.113634);

Another object can define the map options: its zoom level, where it should be centered, and the map type (terrain, road, satellite, or hybrid):

var myOptions = {
        zoom: 4,
        center: myLatlng,
        mapTypeId: google.maps.MapTypeId.SATELLITE
    }

Now, you attach the map to an HTML object such as a <div>; here with attribute id "map_canvas":

var map = new google.maps.Map( document.getElementById("map_canvas"), myOptions );

The following string holds a custom text that displays in the information window showing when clicking the marker on the map:

var contentString = '<div id="content">'+
        '<p><b>Firefox Crop Circle</b>: Somewhere in a field in Oregon'+
        ', this 67 metre wide icon was created by the Oregon State University'+
        'Linux Users Group to celebrate the launch of Firefox version 2</p>'+
        '</div>'+
        '</div>';

This string is now attached to a new instance of the InfoWindow object:

var infowindow = new google.maps.InfoWindow({
        content: contentString
    });

Now, place a marker on your map:

var marker = new google.maps.Marker({
        position: myLatlng,
        map: map,
        title: 'Firefox Crop Circle'
    });

And finally add behavior so that the information window pops up when the marker is clicked:

google.maps.event.addListener(marker, 'click', function() {
        infowindow.open(map,marker);
    });
}

Almost done! Now create the empty HTML object that will receive the map, and call the JavaScript function that will display it:

<p>The map will display here:</p>
    <div id="map_canvas" style="width:600px;height:600px"></div>
    <script type="text/javascript">initialize_map()</script>

Code snippet google_map_api_example.html

This file outlines the concept of the Google Maps API and displays a map, as shown in Figure 10-4.

Figure 10.4. FIGURE 10-4

You are now ready to implement dynamic Google Maps in your plugin.

Plugin Implementation

Now you code the central piece of the plugin: the function to register the shortcode [googlemap] and display the Google Map. The shortcode will be used like so:

[googlemap width=500 height=300 zoom=12]Elm Street, Springwood, Ohio[/googlemap]

First, register the shortcode itself. You could elect to also register various similar shortcodes pointing to the same callback, such as [googlemaps], [google_map], and [google_maps].

<?php

//add the [googlemap] shortcode support
add_shortcode( 'googlemap', 'boj_gmap_generate_map' );

Now start to define the callback function that can parse and process the shortcode attributes and its content:

// The shortcode callback
function boj_gmap_generate_map( $attr, $address ) {

    // Set map default
    $defaults = array(
        'width'  => '500',
        'height' => '500',
        'zoom'   => 12,
    );

    // Get map attributes (set to defaults if omitted)
    extract( shortcode_atts( $defaults, $attr ) );

This first part sets an array of default values, merged with the actual attributes using the function shortcode_atts() that returns an array. The extract() call then imports variables from the array so that for instance array( 'size' => 300 ) becomes $size = 300.

// get coordinates
    $coord = boj_gmap_get_coords( $address );

    // Make sure we have coordinates, otherwise return empty string
    if( !$coord )
        return '';

What you've done here is geocode the address (either from fresh API data or the post metadata) and, in case the geocoding fails (temporary connection problem between your server and Google's, for instance), return an empty string.

// Output for the shortcode
    $output = '';

    // populate $lat and $long variables
    extract( $coord );

Now that you have all the needed variables, you sanitize them for output. Some are to be included in JavaScript strings and others used as HTML attributes, so you can use the appropriate escaping function as described in Chapter 6:

// Sanitize variables depending on the context they will be printed in
    $lat     = esc_js( $lat );
    $long    = esc_js( $long );
    $address = esc_js( $address );
    $zoom    = esc_js( $zoom );
    $width   = esc_attr( $width );
    $height  = esc_attr( $height );

Now you insert the JavaScript parts.

Usually, you would insert the main script in the <head> of the document, but in this case this would be counter-performant because the script would be inserted even if no post on the page requires it.

Instead, you insert it inline, as part as the shortcode return, while making sure it's echoed only once per page:

// generate a unique map ID so we can have different maps on the same page
    $map_id = 'boj_map_'.md5( $address );

    // Add the Google Maps main javascript only once per page
    static $script_added = false;
    if( $script_added == false ) {
        $output .= '<script type="text/javascript"
        src="http://maps.google.com/maps/api/js?sensor=false"></script>';
        $script_added = true;
    }

Now you can insert the map-specific JavaScript. Each function and each map placeholder will be uniquely named, using the $map_id variable previously generated, so you can have several maps on the same page:

// Add the map specific code
    $output .= <<<CODE
    <div id="$map_id"></div>

    <script type="text/javascript">
    function generate_$map_id() {
        var latlng = new google.maps.LatLng( $lat, $long );
        var options = {
            zoom: $zoom,
            center: latlng,
            mapTypeId: google.maps.MapTypeId.ROADMAP
        }

        var map = new google.maps.Map(
            document.getElementById("$map_id"),

options
        );

        var legend = '<div class="map_legend"><p> $address </p></div>';

        var infowindow = new google.maps.InfoWindow({
            content: legend,
        });

        var marker = new google.maps.Marker({
            position: latlng,
            map: map,
        });

        google.maps.event.addListener(marker, 'click', function() {
            infowindow.open(map,marker);
        });

    }

    generate_$map_id();

    </script>

Append to the output some simple styling as per user-defined attributes:

<style type"text/css">
    .map_legend{
        width:200px;
        max-height:200px;
        min-height:100px;
    }
    #$map_id {
        width: {$width}px;
        height: {$height}px;
    }
    </style>

CODE;

And, of course, don't forget to return the content of the shortcode replacement:

return $output;
}

?>

Code snippet plugin_boj_sc7.php

Now your plugin is ready to go! Create a new post and, for instance, write the following shortcode: [googlemap width=450 height=300 zoom=14]108 Ocean Ave. Amityville, NY[/googlemap]. Your post will look like Figure 10-5.

Figure 10.5. FIGURE 10-5

The first quick shortcode you will implement now is a neat way to display content to logged in users only. For instance, its usage in posts would be as following:

Today's Jedi pro-tip is:
[members]Use the force[/members]

The code and function for such a shortcode is the following simple snippet:

<?php

add_shortcode( 'members', 'boj_sc8_loggedin' );

function boj_sc8_loggedin( $attr, $content ) {
    if( is_user_logged_in() ) {
        return $content;
    } else {

return "<p>Members Eyes Only</p>";
    }
}
?>

Code snippet plugin_boj_sc8.php

The result is that you enclose content between a [members] shortcode, and only readers who are logged in can see it. For a more elaborated example on the same concept, refer back to Chapter 8, "Users."

Another simple yet valuable shortcode you will code will allow displaying time-limited content, such as a promotional link that is valid only for 24 hours:

This promo link valid for 24 hours only:
[24hours] http://example.com/promo/ [/24hours]

To implement this shortcode, you need the following snippet that will simply check the current time against the time the post was published:

<?php

add_shortcode( '24hours', 'boj_sc8_24hours' );

function boj_sc8_24hours( $attr, $content ) {
    $now = time();
    $post_time = get_the_date( 'U' );
    if( ( $now - $post_time ) > 86400 ) {
        return 'Offer has expired!';
    } else {
        return $content;
    }
}
?>

Code snippet plugin_boj_sc8.php

If the current post has been published more than 86400 seconds (that is, 24 hours) ago, the text enclosed in [24hours] tags won't show.

The next quick shortcode idea you will code is a practical way to convert a plain text email address into a mailto: link that will be obfuscated (that is, less readable) to spam robots. In a post, you would simply type:

Email me at [email]ozh@ozh.org[/email]

The shortcode function will make use of WordPress' function antispambot(), which converts characters into HTML entities that spambots and email harvesters cannot easily read:

<?php

add_shortcode( 'email', 'boj_sc8_email' );

function boj_sc8_email( $attr, $content ) {
    if( is_email( $content ) ) {
        $content = antispambot( $content );
        return sprintf( '<a href="mailto:%s">%s</a>', $content, $content );    } else {
        return '';
    }
}
?>

Code snippet plugin_boj_sc8.php

The result is that you enclose email addresses between [email][/email] tags, and the shortcode will obfuscate them. For instance, actual return for 'ozh@ozh.org' is 'ozh@& #111;zh.org'.