function doThisAndThat($bTrueOrFalse)
{
    if ($bTrueOrFalse)
    {
        return 'It is true';
    }
    
    /* If the above is true we can be sure it's NOT true here. */
    return 'It is false';
}

foreach ($aMember as $pMember)
{
    if ($pMember->isNotLoggedIn())
    {
        continue;
    }
    
    /* Again, if the above evaluates to true then it wouldn't get here. */
    $aLoggedIn[] = $pMember;
}

if ($bTrueOrFalse)
{
    /* The bad way: Handle the stuff we want to include and process.
    This is the main chunk of our code and so likely to contain
    many loops and conditionals. */
}
else
{
    /* Handle the exclusions. Likely to contain many else statements. */    
}

if ($bTrueOrFalse)
{
    /* This stuff is not required by the below code
    as it has an undesirable attribute/property. */
    continue; /* Therefore we exclude it and continue. */
}

/* Continue with the stuff that we really do need to include,
now that we've filtered out all the bad stuff. Instead of handling
what we need first and then adding an else at the bottom to handle
the exclusions. */

if ($pMember->isInactive())
{
    /* Member is not active, so we don't want to deal
    with this. It becomes an excluded item. Perhaps
    we want to also send an email to inactive members
    to remind them to activate their accounts. */
    $pMember->sendReminder();
    return;
}

if ($pMember->isAdministrator())
{
    /* Member is an administrator, and we don't wish to
    work with administrators in this scenario, again,
    exclude this item. */
    return;
}

/* We now have a list of members who are active and are not
administrators. Perfect! Let's begin work on processing that now.
These are what I call "inclusions", whereas the above two process
the "exclusions" -- items we don't require in this process. */

/* This is likely to be the epicentre of the code... */

function TalkPHP_Is_This_Form_Valid(array $aFormData)
{
    /* Set a default return that will be returned if validation fails. */
    $aValidatedForm     = array('status' => false);
    
    /* The validation rules, specifying an optional regular expression to validate
    that field. Fields without expressions will be ignored. */
    $aValidationRules   = array('Username' => null, 'Name' => null, 'Age' => '\d', 'DoB' => '\d{2}-\d{2}-\d{4}');
    
    /* Loop through the validation rules specified above. We're going to be working in
    the fashion of: exclude, include. Check all the exclusions first (those that return false).
    If all is well at the end of the loop, return true as it passed! */
    foreach ($aValidationRules as $szKey => $szRegex)
    {
        /* Check to see if the item even exists in the form data. */
        if (!array_key_exists($szKey, $aFormData))
        {
            /* Specify a message so that the user knows what he or she did wrong. */
            $aValidatedForm['message'] = $szKey . ' does not exist';
            return $aValidatedForm;
        }
        
        /* Check to see if the item is simply empty (null, blank). */
        if (empty($aFormData[$szKey]))
        {
            /* Do the same as above to inform the individual. */
            $aValidatedForm['message'] = $szKey . ' cannot be empty';
            return $aValidatedForm;
        }
        
        /* Check to see if we have specified a regular expression for this field. */
        if (is_null($aValidationRules[$szKey]))
        {
            /* Continue the loop if not. This item passed validation if it got this far. */
            continue;
        }
        
        /* Validate the value against the regular expression specified for this field at the top of
        the function. */
        if (!preg_match('~' . $aValidationRules[$szKey] . '~i', $aFormData[$szKey]))
        {
            /* Set the message as usual to notify them of this error. */
            $aValidatedForm['message'] = $szKey . ' syntax is invalid';
            return $aValidatedForm;
        }
    }
    
    /* Everything passed and validated as we expected and so we can
    return true knowing that if something failed in the form data, our script
    wouldn't have gotten this far. */
    $aValidatedForm['status'] = true;
    return $aValidatedForm;
}

/* Our array that contains all the form data. Such form data fields can be
constructed using either PHP (Looping through _GET/_POST) or by naming
your form items as like: name="my_form[Name]" */
$aVariables = array
(
    'Username' => 'Wildhoney',
    'Name' => 'Adam',
    'Age' => 23,
    'DoB' => '10-10-1985'
);

/* Validate the form using the values above. */
$aValidatedForm = TalkPHP_Is_This_Form_Valid($aVariables);

if (!$aValidatedForm['status'])
{
    /* If the validation failed then display the message to the user. */
    echo 'Oops: ' . $aValidatedForm['message'];
}
else
{
    /* Otherwise... voila! */
    echo 'Thank you.';  
}