For this solution I'm using the default search function - get_search_form(). If you use it on another spot as well, please pay attention to the stylesheet. Otherwise the following snippet is sufficient to implement the search field in your navigation.

This function and the call belongs into functions.php of the theme and the adjustment of the stylesheet in the according file of the theme, most of the time it is style.css.

function fb_add_search_box ( $items, $args ) {

	// only on primary menu
	if( 'primary' === $args -> theme_location )
		$items .= '<li class="menu-item menu-item-search">' . get_search_form( FALSE ) . '</li>';

	return $items;
}
add_filter( 'wp_nav_menu_items', 'fb_add_search_box', 10, 2 );

If you like to implement the search form only in a specific navigation; you just need to call the entry theme_location of the argument array. If it's the menu with the string n, then ... - an example:
if( 'primary' === $args -> theme_location )

The key of the call is defined in your theme, therefore easy to find in the backend, as you can see in the screenshot above. Have fun with it!

Adding the input field

As an example we will add an input field asking for the city the commenter lives in. Additionally the field will be marked as mandatory.

To add an additional input field you have to modify the comment form defaults by setting a filter for the function comment_form_defaults:

add_filter( 'comment_form_defaults', 'change_comment_form_defaults');

For adding the new input field after the email field you need to extend the default "Email" input field:

function change_comment_form_defaults( $default ) {
    $commenter = wp_get_current_commenter();
    $default[ 'fields' ][ 'email' ] .= '<p class="comment-form-author">' .
        '<label for="city">'. __('City') . '</label>
        <span class="required">*</span>
        <input id="city" name="city" size="30" type="text" /></p>';
    return $default;
}

Basically this is the same markup used to create the author field with modified values for label, name, and id and "<span class="required">*</span>" added to mark the field as mandatory (only visually).

Storing the data in the database

Storing the value of the new field is quite simple since WordPress already contains a table in the database called commentmeta for storing exactly this type of data called meta data.
The usage of this table is straightforward since WordPress provides the two functions add_comment_meta() and get_comment_meta():

add_comment_meta($comment_id, $meta_key, $meta_value, $unique = false)
get_comment_meta( $comment_id, $meta_key, $single = false )

To store the meta data together with the other comment data an action needs to be added:

add_action( 'comment_post', 'save_comment_meta_data' );

function save_comment_meta_data( $comment_id ) {
    add_comment_meta( $comment_id, 'city', $_POST[ 'city' ] );
}

To make the city field mandatory the script needs to check if the user had entered some text before the data is stored. WordPress provides a filter named preprocess_comment which can be used to verify the data:

add_filter( 'preprocess_comment', 'verify_comment_meta_data' );

function verify_comment_meta_data( $commentdata ) {
    if ( ! isset( $_POST['city'] ) )
        wp_die( __( 'Error: please fill the required field (city).' ) );
    return $commentdata;
}

The data is not actually processed but it is tested if the field $_POST['city'] contains any data. If there is no data the script will die with an error message otherwise the comment data will be returned unaltered.
Alternative ist the Action Hook pre_comment_on_post usable.

Retrieving and displaying the data

To retrieve the data from the database WordPress provides the function get_comment_meta. To avoid to modify the theme template the city name is attached to the author name by using the filter get_comment_author_link:

add_filter( 'get_comment_author_link', 'attach_city_to_author' );

function attach_city_to_author( $author ) {
    $city = get_comment_meta( get_comment_ID(), 'city', true );
    if ( $city )
        $author .= " ($city)";
    return $author;
}

Advanced usage

You might have noticed that both functions add_comment_meta() and get_comment_meta() contain parameters that haven't been explained yet, namely $unique and $single.

The $unique parameter controls whether you can add multiple data field with the same key name for the same comment_id. But why would you want do such a thing?
Let's assume you want to allow the user to add multiple cities separated by commas. Surely you can store the whole string in a single table row but that would make the data hard to handle if you want to use it in a different context and it simply conflicts with basic database principles. So the input data will be split and each city is stored in its own dataset:

function save_comment_meta_data( $comment_id ) {
    $cities = explode( ',', $_POST[ 'city' ] );
    foreach ( $cities as $city )
       echo add_comment_meta( $comment_id, 'city', $city, false );
}

If the user enters e.g. three city names all three are stored with the keyname city. If the parameter unique would have been set to true only the first city would have been stored because the parameter prevents the storage attempts of the last two city names.

When retrieving the data with get_comment_meta the parameter $single comes into view. If it is set to false the function does not return a single value but an array of values.

function attach_city_to_author( $author ) {
    $cities = get_comment_meta( get_comment_ID(), 'city', false );
    if ( $cities ) {
        $author .= ' ( ';
        foreach ( $cities as $city )
            $author .= $city . ' ';
        $author .= ')';
    }
    return $author;
}

Modifying the meta data

There might be situations where you want to change the meta data stored in the database. As expected WordPress provides a function for this called update_comment_meta():

update_comment_meta( $comment_id, $meta_key, $meta_value, $prev_value );

To modify a value you use the function the same way you use add_comment_meta:

$new_city = "Timbuktu";
update_comment_meta( $comment_id, 'city', $new_city );

If the $meta_key does not exist the function adds the meta data to the database. But what is the parameter $prev_value used for?
As noticed above you can store more than one value with the same meta key for a single comment. The code snippet above would change all values with the key 'city'. If you set the parameter $prev_value to the value that is to be modified the function will do exactly what is intended:

$old_city = "Berlin";
$new_city = "Timbuktu";
update_comment_meta( $comment_id, 'city', $new_city, $old_city );

Behind the scenes

The structure of the commentmeta table is quite simple:

The meta_id is an auto-incremented ID and comment_id is of course the ID of the comment. The actual data is stored in the meta_key and meta_value fields, containing the keyname (in our case 'city') and the actual value (the name of the city the user entered). Example:

The comments with the ID 76 and 77 contain meta data with only one value assigned to the key 'city' whereas the comment with the ID 78 got three different values with the same key.

Look it up

If you want to look up the {add|get|update}_meta_data functions in the core you can find them in .../wp-includes/comment.php.
The default values of the comment form which are modified above are defined in ../wp-includes/comment-form.php in the function comment_form().

Source code

Download the complete sources of the examples above:

• via Gist: Single value meta data
• via Gist: Multi value meta data

The function of the Child Themes can be applied basically in every theme and the new features facilitate access and creation of a Child Themes. Before there were also possibilities to change a Theme without changing the actual files of the theme. With the support of Child Themes this is now completely independent and we can use a theme that can be updated without a problem, and you can still realize your own ideas.

Other blogs already mentioned Child Themes but I've found so far only posts where they just talking about the activation and modification of the style sheet. Therefore, I would like to comment this subject only briefly, which is quite simple and then show the different possibilities in terms of template files.

Advantages of Child Theme

More or less every administrator is trying to create an individual design for his WordPress system. This does not require to create a special theme from scratch. Very often, a free or commercial Theme is used and then adapted to your needs. Many Themes have different options but are not sufficient for customizing. If you want to adjust the individual design, such as the layout of a category, that requires some changes of the theme. No matter how extensive, an update of a Theme is no longer feasible without problems. Here the Child Themes come into consideration.

With a Child Theme, a Theme can be adjusted or you can use a Theme as a "Framework" and implement completely your own ideas. No matter how extensive, the real Theme remains intact and can undergo an update.

Disadvantages of Child Theme

Often "Framework" Themes are very comprehensive and with many features, sometimes it has a steep learning curve and customizing can cost a lot of effort and time. Even though with Child Themes.
A major disadvantage is also the performance, because WordPress have to look into two areas according to the template and get the according files.
Furthermore style sheets, if you build on them, are usually implemented via @-rule, which has disadvantages in performance.

In all the negative points, it depends on skill and knowledge of the developer and how the Theme or Child Theme is created. Thus you can weaken the negative arguments I pointed out. Important: The new function should be carefully considered before using it. But with Child Themes you don't have to touch the basic Theme and yet you can make adjustments easily.

Create Child Theme

Enough said, let's start with the example based on the Theme TwentyTen and create an adjusted Theme - I will call it TwentyTenJump

In the first step, a new folder is created in which we put all the template files, images, scripts and style sheets - what is principally needed for the Child Theme. In this example, the folder is twentytenjump. To create a Child Theme and make this apparent to WordPress, you simply need style.css within the new folder with several strings in a comment.

Within style.css it looks like this.

@charset "UTF-8";

/**
 * Theme Name:     TwentyTenJump
 * Theme URI:      http://bueltge.de/?p=1192
 * Description:    Child theme for the Twenty Ten theme. Realized for a small tutorial to child themes in WordPress.
 * Author:         Frank Bültge
 * Author URI:     http://bueltge.de/
 * Template:       twentyten
 * Version:        0.1.0
 */

@import url('../twentyten/style.css');

Important are the key Theme Name and Template. The key Template points to the folder name of the Theme, which is considered as a basis - in that instance, the Theme Twentyten.

I now have the following structure within the installation of WordPress.

• wp-content
  • themes
    • twentyten

    (Basic Theme, including all template files)

    • style.css
    • index.php
    • ...
    • twentytenjump
      • style.css (must satisfy these name convention: style.css)

Thus, the first requirements are in place and you can select the new Theme in the backend of WordPress.
Note: the reference to the Basic Theme is not very conspicuous, so that you might forget the dependency. So that's why you should always check before you delete a Theme. On the used Theme, there is no indication that a different Theme as a Child Theme is using this Theme.

Working on the style sheet

From now you can put any changes in your style sheet. Also, of course, you can remove the call to the style sheet @import url('../twentyten/style.css'); from the Basic Theme and you can build your own style sheet completely.

You use the template files, the structure and PHP know-how of the Basic Theme, in which case is Twenty Ten. You deal exclusively with the design. For example, this could be the simplest case, a change in color of the background and alternatively a completely separate design will be created.

Replace templates

The functionality of the Child Theme includes more than just changing the appearance. You can replace existing template files of the Basic Themes. WordPress looks first in the Child Theme and then in the Basic Theme for possible templates. WordPress runs through the hierarchy of template files.

At many points in your Theme you can intervene via Hook, which might be not very easy and complicated for some users. Thus not infrequently the output of title in head of a web site will be replaced with own functions or Plugins. You can either edit the title via Hook or control the output of a function. For example, the title should now be displayed with a function of a Plugin. In that case you have to adjust the header.php and so you must proceed as follows, so that the Basic Theme remains intact.

You only have to copy header.php, which is containing the head section of the Theme, into your own Child Theme and here it can be edited as you like. From now on WordPress pulls header.php and not the original file from the basic theme Twenty Ten.

Now you can integrate the mentioned function into the title, an example:

<title><?php
    /*
     * Print the <title> tag based on what is being viewed.
     * We filter the output of wp_title() a bit -- see
     * twentyten_filter_wp_title() in functions.php.
     */
    if ( function_exists('seo_title_tag') )
        seo_title_tag();
    else
        wp_title( '|', true, 'right' );

    ?></title>

The Basic Theme remains untouched, it can still be kept up to date via updates and from now on WordPress uses the header.php always of the Child Theme.

Like this small example you can replace any template and adapt to your own requirements. Nevertheless, you should bear in mind that you replace the template completely - in the example, we would not notice an update of header.php. So it may be helpful to use Hooks in various areas and have their own functions, more about this later.

Important: an exception is functions.php, I will talk more about it later.

Expand Templates

In order to meet your own requirements, it may be that you need new templates, template files didn't exist in the Basic Theme. For the purposes of the hierarchy you can extended forever. For example, Twenty Ten does not have home.php - you can simply place this file in your Child Theme and WordPress will use this file, if the state is_home() is true.

Using WordPress 3.0 there is another option outside of the template hierarchy to use your own templates - get_template_part().

This function is used consistently within Twenty Ten - so you don't have to create own templates for the complete call, but only for the section of the Loop.
For example, Twenty Ten uses for displaying the category archives the call get_template_part( 'loop', 'category' );. Thus it is possible to put a template in our Child Theme, which uses this loop. So it's only necessary to create a file loop-category.php and then save all necessary informations.

In the following example, I adjust the loop, if you are in one of the four categories. Other changes are possible, so you will have full control and flexibility.

if ( in_category( array(47, 37, 27, 45) ) ) {
	query_posts( 'cat='.$cat.'&posts_per_page=-1&orderby=title&order=ASC' );
}	else {
	query_posts( 'cat='.$cat.'&posts_per_page=20&paged='.$paged );
}
while ( have_posts() ) : the_post(); ?>

Similarly, you might be able to customize the loop for index.php - Template file loop-index.php would be in the game.

Include Functions

Of course you can also bring in the Child Theme your own functions. If you put an own functions.php in your Child Theme, then it does not replace the functions.php of the Basic Theme!
The functions of the Basic Theme will always be used. You have to disable them via the Hook. The possibility is also explained in a documentation in the functions.php file.

add_action( 'after_setup_theme', 'my_child_theme_setup' );
function my_child_theme_setup() {
		// We are providing our own filter for excerpt_length (or using the unfiltered value)
		remove_filter( 'excerpt_length', 'twentyten_excerpt_length' );
		...
}

Within the function my_child_theme_setup() you can disable the functions of the Basic Theme and bring in your own functions.

Other features belong into the functions.php of the Child Theme - the Basic Theme always remains untouched. In the following code example I disable the function of the Basic Theme Twenty Ten for the length of the excerpt, and load my own function twentytenjump_excerpt_length() and it includes a Widget.

<?php
function twentytenjump_setup() {

	remove_filter( 'excerpt_length', 'twentyten_excerpt_length' );
	add_filter( 'excerpt_length', 'twentytenjump_excerpt_length' );

	add_action( 'widgets_init', 'register_limited_catagories_widget' );
}
add_action( 'after_setup_theme', 'twentytenjump_setup' );

function twentytenjump_excerpt_length( $length ) {
	return 10;
}

class limited_catagories_list_widget extends WP_Widget {

	function limited_catagories_list_widget(){
		$widget_ops = array( 'classname' => __('Selective categories'), 'description' => __('Show a list of Categories, with the ability to exclude categories') );

		$control_ops = array( 'id_base' => 'some-cats-widget' );
		$this->WP_Widget( 'some-cats-widget', __('Selective Catagories'), $widget_ops, $control_ops );
	}

	function form ( $instance){
		$defaults = array( 'title' => __('Catagories'), 'cats' => '', 'count' => 0 );
		$instance = wp_parse_args( (array) $instance, $defaults );
		$count = isset($instance['count']) ? (bool) $instance['count'] :false;
		?>
		<p>
			<label for="<?php echo $this->get_field_id( 'title' ); ?>"><?php _e( 'Title:' ); ?></label>
			<input id="<?php echo $this->get_field_id( 'title' ); ?>" name="<?php echo $this->get_field_name( 'title' ); ?>" value="<?php echo $instance['title']; ?>" class="widefat" />
		</p>
		<p>
			<input type="checkbox" class="checkbox" id="<?php echo $this->get_field_id('count'); ?>" name="<?php echo $this->get_field_name('count'); ?>"<?php checked( $count ); ?> />
			<label for="<?php echo $this->get_field_id('count'); ?>"><?php _e( 'Show post counts' ); ?></label><br />
		</p>
		<p>
			<label for="<?php echo $this->get_field_id( 'cats' ); ?>"><?php _e( 'Categories to exclude (comma separated list of Category-IDs): ' ); ?></label>
			<input id="<?php echo $this->get_field_id( 'cats' ); ?>" name="<?php echo $this->get_field_name( 'cats' ); ?>" value="<?php echo $instance['cats']; ?>" class="widefat" />
		</p>
		<?php
	}

	function update($new_instance, $old_instance) {
			$instance = $old_instance;
			$instance['title'] = strip_tags( $new_instance['title'] );
			$instance['count'] = !empty($new_instance['count']) ? 1 : 0;
			$instance['cats']  = strip_tags( $new_instance['cats'] );
			return $instance;
	}

	function widget($args, $instance){
		extract( $args );
		$title = apply_filters('widget_title', $instance['title'] );
		$c     = $instance['count'] ? '1' : '0';
		$cats  = $instance['cats'];
		echo $before_widget;
		if ( $title )
			echo $before_title . $title . $after_title;
		echo '<ul>';
		wp_list_categories("exclude=$cats&title_li=&show_count=$c");
		echo '</ul>';
		echo $after_widget;
	}

}

function register_limited_catagories_widget(){
	register_widget('limited_catagories_list_widget');
}
?>

Conclusion

I think through the introduction of the new default theme Twenty Ten that some new cool features were added. But I think also that Twenty Ten is very inappropriate to understand the work of WordPress in the area of themes. Especially beginners and PHP newcomers are having a hard time. Yet it creates new opportunities and if you want to use Child Themes in a clean way, then you can not get around it without understanding Hooks in the WordPress API. WordPress takes the idea of the Hooks consistently further, always popular in Plugins, they do get popular in Themes now. Everything has advantages and disadvantages.

But if you use a well-maintained Theme or Framework, then you will appreciate the new possibilities and can always update with no problems. Crucial will be your own knowledge about WordPress - depending on the interest, knowledge and working methods how you create your own themes.

Download and Forking

Please use the repository on Github: github.com/bueltge/TwentyTenJump

$echo = '<ul>' . "\n";
$childcats = get_categories('child_of=' . $cat . '&hide_empty=1');
foreach ($childcats as $childcat) {
    if (1 == $childcat->category_parent) {
        $echo .= "\t" . '<li><a href="' . get_category_link($childcat->cat_ID).'" title="' . $childcat->category_description . '">';
        $echo .= $childcat->cat_name . '</a>';
        $echo .= '</li>' . "\n";
    }
}
$echo .= '</ul>' . "\n";
echo $echo;

An example

Let us imagine that you will use a menu several times - but at different positions and at different places of the markup. It would not be sufficient if you change the appearance via CSS. In most cases you would probably put the navigation in an additional template, such as the nav.php. In this file is the HTML markup and the necessary template tags to create a navigation. This file would be included. In WordPress 3.0 it looks like this: include( TEMPLATEPATH . '/navi.php' );

Function get_template_part()

With WordPress 3.0 comes in this form of modularization more flexibility and so you can use the get_template_part() to address templates. The function allows the use of two parameters:

/**
 * @uses locate_template()
 * @since 3.0.0
 * @uses do_action() Calls 'get_template_part{$slug}' action.
 *
 * @param string $slug The slug name for the generic template.
 * @param string $name The name of the specialised template.
 */
get_template_part( $slug, $name = null )

and it has a hook get_template_part_$slug, which you can use.

Let's take a look on the example with the navigation above, which will be include in the new function as follows: get_template_part( 'navi' );. In this case we only used the parameter slug - navi - which takes care, that it loads navi.php.
In our next step we want to use the navi, which was created explicitly for the sidebar. The source is in the navi-sidebar.php and the call will look like that: get_template_part( 'navi', 'sidebar' );. The structure of the template file must be created by slug-name.php .

This allows to create almost any pattern, which are becoming especially valuable when it comes to reuse, or if you work with Child-Themes, as you can thus connect to the Parent-Theme and yet create your own quite flexible templates.

Sequence loading

WordPress uses when loading the template a hierarchy, so you can access various templates, that can be illustrate in an example. The Parent-Theme is in wp-content/themes/ and uses the folder wpbasis, the Child Theme can be found in the folder wpbasischild. Now there is in one of the templates the call <?php get_template_part( 'navi', 'index' ); ?>. Now it searches after the navi-index.php with the following pattern:

1. wp-content/themes/wpbasischild/navi-index.php
2. wp-content/themes/wpbasischild/navi.php
3. wp-content/themes/wpbasis/navi-index.php
4. wp-content/themes/wpbasis/navi.php

Here, again, some new features under the hood, which can be quite useful for theme authors. Because of its recent growth, the use of Child-Themes is certainly a useful feature.

To use the shortlink in your theme, you can use a template tag with 4 parameters.

 * @param string $text Optional The link text or HTML to be displayed.  Defaults to 'This is the short link.'
 * @param string $title Optional The tooltip for the link.  Must be sanitized.  Defaults to the sanitized post title.
 * @param string $before Optional HTML to display before the link.
 * @param string $before Optional HTML to display after the link.
 */
the_shortlink($text = '', $title = '', $before = '', $after = '')

Here an example how you can use it in your theme:

if ( function_exists('the_shortlink') ) the_shortlink( __('Shortlink'), __('kurze URL zu diesem Beitrag nutzen'), ' · ' );

The function wp_get_shortlink() is in use in this case. You should use this function if you don't want to have it displayed (echo).

The link in the head of the frontend is created via a hook and can only get disabled. The integration will be standard in WordPress 3.0:

add_action( 'wp_head', 'wp_shortlink_wp_head', 10, 0 );

To deactivate the syntax in the head of your template you can put the following code in your functions.php.

remove_action( 'wp_head', 'wp_shortlink_wp_head', 10, 0 );

If you like to adjust the shortlink to your liking, you can use several filter hooks.
pre_get_shortlink // Allow plugins to short-circuit this function
get_shortlink // Filter the output

In this article I want to show an example in which are the main pages in a horizontal navigation. The related sub-pages are displayed in the sidebar when you click on the main page.

For better understanding we take the following page structure:

• Home
• Software
  • Image Editor
    • Adobe Photoshop
    • Gimp
  • Content Managment Systems
    • WordPress
    • Drupal
    • Joomla
• Hardware
• About us

The pages Home, Software, Hardware and About us are in the horizontal navigation. When the user clicks on Software, for example, all the subpages of Software should be shown in the sidebar.

WordPress provides for such a task the template tag wp_list_pages() with several parameters. Since we don't want to display all pages, only the parameter child_of is interesting for our purpose. The parameter child_of followed by an ID lists all subpages of the current page, if there exist subpages.

<?php wp_list_pages('child_of='.get_the_ID().'&title_li=<h5>'.__('Pages').'</h5>'); ?>

Now we come to the real problem. If you click on Content Management Systems in the sidebar, only the pages WordPress, Drupal and Joomla will be displayed. The Parent Pages are gone. Logically, since it displays only the children of the current page, which is Content Management Systems. But we always like to have to top page displayed too. Fortunately there is a function get_post_ancestors, which returns all parent pages in an array. Try the following:

<?php
$my_page = get_the_ID();
$anchestors = get_post_ancestors($my_page);
var_dump($anchestors);

// click on Software
array(0) { }

// click on Content Management Systems
array(1) { [0]=>  string(2) "63" }
// 63 is the ID of Software

// click on WordPress
array(2) { [0]=>  string(2) "65" [1]=>  string(2) "63" }
// 65 iis the ID of WordPress
?>

This would go on forever, even in more deeply nested hierarchy. Important for us are 2 things: the top page is always at the end of the array and it can return an empty array. So we just go to the end of the array and for the case that there is no parent page, we display all the subpages of this page. We write a function in our functions.php because it is easier to maintain, and may also be used in several sidebars:

function wpe_highest_ancestor(){
    global $post;

    $ancestors = array($post->ancestors);
    $page_ancestors = end( $ancestors );
    if ( !empty($page_ancestors) ) {
        $child_of = $page_ancestors;
    } else {
        $child_of = $post->ID;
    }

    return $child_of;
}

Now we use this function in our sidebar:

<ul class="sidebar">
  <?php wp_list_pages('child_of=' . wpe_highest_ancestor()); ?>
</ul>

If you want to have the name of the top-level page in the sidebar, you can use the following code:

<ul class="sidebar">
  <?php
  $child_of = wpe_highest_ancestor();
  wp_list_pages('child_of='.$child_of.'&title_li=<h5>'.esc_attr(get_the_title($child_of)).'</h5>');
  ?>
</ul>

As you can see, it is relatively easy to achieve appropriate solutions with WordPress.

But even with this feature you should check for the existence of the function and offer an alternative. Only then you can leave the user the freedom to choose which WordPress version he wants to use. The functions of extensions, plugins and themes should be checked for their existence, then the functionality of the theme is secured, even if a function is not available. Similarly should it be handled with post thumbnail.

I would like to show two suggestions for alternatives below, and I refer to the detailed article about the topic images in Easier And Better Solutions To Get Pictures On Your Posts.

After adding the following syntax in the functions.php of the themes, you have a Metabox in the posting or page area ready and can easily be used.

if ( function_exists('add_theme_support') )
  add_theme_support('post-thumbnails');

The output of the image is in the theme at the spot where it should appear, simply use the template tag: the_post_thumbnail().

if ( current_theme_supports( 'post-thumbnails' ) )
  the_post_thumbnail(array(300,200));

Important, if you work with additional markup, then you need a query, which checks, whether there is a thumbnail for the post. Otherwise, you have unnecessary markup, which has no content.

<?php
if ( has_post_thumbnail() ) { ?>
  <span class="my_image">
    <?php the_post_thumbnail(array(600, 400)); ?>
  </span>
} ?>

To have an alternative for installations prior to WP 2.9, you can take different approaches. The two following examples are providing just ideas: either using the custom fields, field name is post-image ...

if ( function_exists('has_post_thumbnail') && has_post_thumbnail() ) {
  the_post_thumbnail(); // @param: array(height, width)
} else {
  $myimage = get_post_meta($post->ID, 'post-image', true); // via custom field
  if ($myimage) {
    echo '<img class="wp-post-image" src="' . $postimage . '" alt="Post Iage" />';
  }
}

... or in the example below, the first image from the photo library. You can find more about it in a separate post.

if ( function_exists('has_post_thumbnail') && has_post_thumbnail() ) {
  the_post_thumbnail(); // @param: array(height, width)
} else {
  // via mediathek
  $attachments = get_children( array(
                  'post_parent'    => get_the_ID(),
                  'post_type'      => 'attachment',
                  'numberposts'    => 1, // show all -1
                  'post_status'    => 'inherit',
                  'post_mime_type' => 'image',
                  'order'          => 'ASC',
                  'orderby'        => 'menu_order ASC'
                  ) );
  foreach ( $attachments as $attachment_id => $attachment ) {
    echo wp_get_attachment_image( $attachment_id );
  }
}

Check if the theme support the function:

if ( current_theme_supports( 'post-thumbnails' ) ) {
  ...

In addition, you can check whether the theme supports the function and explicit use for posts (post) or pages (page). Very interesting, if you want to bring additional features in the post edit section of the back end, which is dependent on this feature within the theme:

if ( current_theme_supports( 'post-thumbnails', 'page' ) ) {
  add_meta_box( ...

In this context, you can also integrate external files with new features.

require_if_theme_supports( 'post-thumbnails', ABSPATH . WPINC . '/my-post-thumbnail-function.php' );

You can provide 4 picture formats to the function (change the width and height values to your need):

// the thumbnail
the_post_thumbnail(array(100,100)); 

// medium resolution
the_post_thumbnail(array(300,200));

// large resolution
the_post_thumbnail(array(600, 400));

// original
the_post_thumbnail();

You can set how the images should align. It is also possible to assign an own class:

//  left align
the_post_thumbnail(array(100,100), array('class' => 'alignleft'));

//  right align
the_post_thumbnail(array(100,100), array('class' => 'alignright'));

//  center
the_post_thumbnail(array(100,100), array('class' => 'aligncenter'));

// align right and the class  'my_own_class'
the_post_thumbnail(array(100,100), array('class' => 'alignright my_own_class'));

The 3rd possibility is the control of the images size with an array of height and width:
For this purpose we suppose that the settings for thumbnail is 150x150, for medium 300x200 and for large 600x400.

// thumbnail scaled to 60x60 pixel
the_post_thumbnail(array(60,60), array('class' => 'alignleft')); 

// original thumbnail
the_post_thumbnail(array(150,150), array('class' => 'alignleft'));

// medium resolution scaled to 200x133 pixel
the_post_thumbnail(array(200,200), array('class' => 'alignleft'));

// large resolution scaled to 400x266 Pixel
the_post_thumbnail(array(400,345), array('class' => 'alignleft'));

We see that the image proportions are always maintained, even if one specifies crooked values.

For the Theme Designers is this not necessarily easier, because no one knows what the user will put in his settings o his library. One way to approach this problem, to query the options for the various sizes:

// width of the thumbnails
get_option('thumbnail_size_w');

//  height of the thumbnails
get_option('thumbnail_size_h');

//  height of the medium resolution
get_option('medium_size_h');

//  width of the large resolution
get_option('large_size_w');

//  1 = Crop thumbnail to exact dimensions, 0 = Crop off
get_option('thumbnail_crop')

You can change these values in your theme.

$w = get_option('thumbnail_size_w') / 2;
$h = get_option('thumbnail_size_h') /2;

the_post_thumbnail(array($w, $h), array('class' => 'alignleft'));

Here another example: If the size of a thumbnail is bigger than 100x100 and crop is activated, then the thumbnail should be resized to 100x100, otherwise use the original thumbnail.

if(get_option('thumbnail_size_w') > 100 && get_option('thumbnail_crop') == 1) {
    the_post_thumbnail(array(100,100));
}else{
    the_post_thumbnail('thumbnail');
}

Have fun with post thumbnails! But be aware, that each post thumbnail requires 2 data base queries. On a page with 10 posts that would be 20 more queries.