andy's php projects
Script and site usage:
All of the scripts on this site are provided free for non-commercial, personal or non-profit use. If you wish to use any of these in a commercial system, please refer to the payment plan.

Support:
Support for each of the scripts is given, free of charge, on the message board. Each script has its own message board which can be accessed by clicking on the 'project forum' link (beneath the description of each project).


Proudly hosted with Dreamhost

Save $20 when signing up for Dreamhost by using the promo code amnuts20


If you find these scripts useful to you, appreciate the free support, or are just an all round nice person, then why not donate a little dosh to encourage me to continue? Every little helps!

Zend Certified Engineer logo


String Functions

A collection of string related functions. These functions work on strings, arrays of strings and any depth of arrays of strings.

class.strings.php

<?php

//
// class.strings.php
// version 1.4.2, 2004-08-16
//
// Description
//
// A PHP library of helpful string manipulation methods.  This class does not
// need to be assigned to an object, as you could use the :: access method,
// such as Strings::validateString
//
// Author
//
// Andrew Collington, 2004
// php@amnuts.com, http://php.amnuts.com/
//
// Feedback
//
// There is message board at the following address:
//
//    http://php.amnuts.com/forums/index.php
//
// Please use that to post up any comments, questions, bug reports, etc.  You
// can also use the board to show off your use of the script.
//
// License
//
// This class is available free of charge for personal or non-profit work.  If
// you are using it in a commercial setting, please contact php@amnuts.com for
// payment and licensing terms.
//
// Support
//
// If you like this script, or any of my others, then please take a moment
// to consider giving a donation.  This will encourage me to make updates and
// create new scripts which I would make available to you.  If you would like
// to donate anything, then there is a link from my website to PayPal.
//


class Strings
{
    
/**
     * Validates whether the given element is a string.
     *
     * @return bool
     * @param  string $element
     * @param  bool   $require_content If the string can be empty or not
     */
    
function validateString($element$require_content true)
    {
        return (!
is_string($element)) ? false : ($require_content && $element == '' false true);
    }

    
/**
     * Validates whether the given element is an array.
     *
     * @return bool
     * @param  array $element
     * @param  bool  $require_content If the array can be empty or not
     */
    
function validateArray($element$require_content true)
    {
        return (!
is_array($element)) ? false : ($require_content && empty($element) ? false true);
    }

    
/**
     * Validates whether an email address has a valid format.
     *
     * @return bool
     * @param  string $email
     */
    
function validateEmail($email)
    {
        return (
eregi("[0-9a-z]([-_.]?[0-9a-z])*@[0-9a-z]([-.]?[0-9a-z])*\\.[a-z]{2,3}"$email)) ? true false;
    }

    
/**
     * Converts high-character symbols into their respective html entities.
     *
     * @return string
     * @param  string $string
     */
    
function convertSymbolsToEntities($string)
    {
        static 
$symbols 
            array(
                
''''''''''''''''''''''''''''''
                
''''''''''''''''''''''''''''''
                
''''''''''''''''''''''''''''''
                
''''''''''''''''''''''''''''''
                
''''''''''''''''''''''''''''''
                
''''''''''''''''''''''''''''''
                
''''''''''''''''''''''''''''''
                
''''''''''''''''''''''''''''''
                
'''');
        static 
$entities 
            array(
                
'&#8218;',  '&#402;',   '&#8222;',  '&#8230;',  '&#8224;',  '&#8225;',  '&#710;'
                
'&#8240;',  '&#352;',   '&#8249;',  '&#338;',   '&#8216;',  '&#8217;',  '&#8220;'
                
'&#8221;',  '&#8226;',  '&#8211;',  '&#8212;',  '&#732;',   '&#8482;',  '&#353;'
                
'&#8250;',  '&#339;',   '&#376;',   '&#8364;',  '&aelig;',  '&aacute;''&acirc;',  
                
'&agrave;''&aring;',  '&atilde;''&auml;',   '&ccedil;''&eth;',    '&eacute;'
                
'&ecirc;',  '&egrave;''&euml;',   '&iacute;''&icirc;',  '&igrave;''&iuml;',   
                
'&ntilde;''&oacute;''&ocirc;',  '&ograve;''&oslash;''&otilde;''&ouml;',   
                
'&thorn;',  '&uacute;''&ucirc;',  '&ugrave;''&uuml;',   '&yacute;''&aacute;'
                
'&acirc;',  '&aelig;',  '&agrave;''&aring;',  '&atilde;''&auml;',   '&ccedil;'
                
'&eacute;''&ecirc;',  '&egrave;''&eth;',    '&euml;',   '&iacute;''&icirc;',  
                
'&igrave;''&iuml;',   '&ntilde;''&oacute;''&ocirc;',  '&ograve;''&oslash;'
                
'&otilde;''&ouml;',   '&szlig;',  '&thorn;',  '&uacute;''&ucirc;',  '&ugrave;'
                
'&uuml;',   '&yacute;''&yuml;',   '&iexcl;',  '&pound;',  '&curren;''&yen;',    
                
'&brvbar;''&sect;',   '&uml;',    '&copy;',   '&ordf;',   '&laquo;',  '&not;',    
                
'&shy;',    '&reg;',    '&macr;',   '&deg;',    '&plusmn;''&sup2;',   '&sup3;',   
                
'&acute;',  '&micro;',  '&para;',   '&middot;''&cedil;',  '&sup1;',   '&ordm;',   
                
'&raquo;',  '&frac14;''&frac12;''&frac34;''&iquest;''&times;',  '&divide;'
                
'&cent;',   '...',      '&micro;');

        if (
Strings::validateString($stringfalse)) {
            return 
str_replace($symbols$entities$string);
        } else {
            return 
$string;
        }
    }

    
/**
     * Converts all strings, or all elements of an array, no matter how nested
     * the array is, to html entities.
     *
     * @return string|array
     * @param  string|array $element
     */
    
function convertTextToHTML($element)
    {
        return 
Strings::processFunction($element'htmlentities');
    }

    
/**
     * Cuts the given string to a certain length without breaking a word.
     *
     * @return string
     * @param  string $string
     * @param  int    $length number of maximum characters leave remaining
     * @param  bool   $more   whether to display '...' on the end of the trimmed string
     */
    
function trimStringToLength($string$length$more true)
    {
        if (
Strings::validateString($string)) {
            
$trimmed str_replace('<br>''... 'ereg_replace('(<br>)+''<br>'$string));
            
$trimmed strip_tags($trimmed);
            if (
strlen($trimmed) > $length) {
                
$trimmed substr($trimmed0strrpos(substr($trimmed0$length), ' '));
                if (
$more === true) {
                    
$trimmed .= '...';
                }
            }
            return 
$trimmed;
        }
    }

    
/**
     * Removes the first or last word from a string.
     *
     * @return string
     * @param  string $string
     * @param  bool   $start whether to trim at start (true) or end (false) of string
     */
    
function trimWordFromString($string$start true)
    {
        if (
Strings::validateString($string)) {
            
$trimmed trim($string);
            if (!
substr_count($trimmed' ')) {
                return 
$trimmed;
            } else {
                return (
$start) ? substr($trimmedstrpos($trimmed' ')+1strlen($trimmed)) : substr($trimmed0strrpos($trimmed' '));
            }
        }
    }

    
/**
     * Removes the first word from a string.
     *
     * @return string
     * @param  string $string
     * @see   trimWordFromString()
     */
    
function trimFirstWordFromString($string)
    {
        return 
Strings::trimWordFromString($stringtrue);
    }

    
/**
     * Removes the last word from a string.
     *
     * @return string
     * @param string $string
     * @see   trimWordFromString()
     */
    
function trimLastWordFromString($string)
    {
        return 
Strings::trimWordFromString($stringfalse);
    }

    
/**
     * Can perform a full trim a string, or all elements of an array, no 
     * matter how nested the array is.
     *
     * @return string|array
     * @param  string|array $element
     */
    
function trimString($element)
    {
        return 
Strings::processFunction($element'trim');
    }

    
/**
     * Can left-trim a string, or all elements of an array, no matter 
     * how nested the array is.
     *
     * @return string|array
     * @param  string|array $element
     */
    
function trimStringLeft($element)
    {
        return 
Strings::processFunction($element'ltrim');
    }

    
/**
     * Can right-trim a string, or all elements of an array, no matter 
     * how nested the array is.
     *
     * @return string|array
     * @param  string|array $element
     */
    
function trimStringRight($element)
    {
        return 
Strings::processFunction($element'rtrim');
    }

    
/**
     * Adds slashes to a string, or all elements of an array, no matter 
     * how nested the array is.
     *
     * If the 'check_gpc' parameter is true then slashes will be applied 
     * depending on magic_quotes setting.
     *
     * @return string|array
     * @param  string|array $element
     * @param  bool         $check_gpc
     */
    
function addSlashesToString($element$check_gpc true)
    {
        return (
$check_gpc && get_magic_quotes_gpc()) ? $element Strings::processFunction($element'addslashes');
    }

    
/**
     * Removes slashes from a string, or all elements of an array, no matter
     * how nested the array is.
     *
     * If the 'check_gpc' parameter is true then slashes will be removed 
     * depending on magic_quotes setting.
     *
     * @return string|array
     * @param  string|array $element
     * @param  bool         $check_gpc
     */
    
function trimSlashesFromString($element$check_gpc true)
    {
        return (
$check_gpc && !get_magic_quotes_gpc()) ? $element Strings::processFunction($element'stripslashes');
    }

    
/**
     * Performs the passed function recursively.
     *
     * @return string|array
     * @param  string|array $element
     * @param  string       $function
     */
    
function processFunction($element$function)
    {
        if (
function_exists($function) === true) {
            if (
Strings::validateArray($elementfalse) === false) {
                return 
$function($element);
            } else {
                foreach (
$element as $key => $val) {
                    if (
Strings::validateArray($element[$key], false)) {
                        
$element[$key] = Strings::processFunction($element[$key], $function);
                    } else {
                        
$element[$key] = $function($element[$key]);
                    }
                }
            }
        }
        return 
$element;
    }

    
/**
     * Get the ordinal value of a number (1st, 2nd, 3rd, 4th).
     *
     * @return string
     * @param  int    $value
     */
    
function getOrdinalString($value)
    {
        static 
$ords = array('th''st''nd''rd');
        if (((
$value %= 100) > && $value 20) || ($value %= 10) > 3) {
            
$value 0;
        }
        return 
$ords[$value];
    }

    
/**
     * Returns the plural appendage, handy for instances like: 1 file, 
     * 5 files, 1 box, 3 boxes.
     *
     * @return string
     * @param  int    $value
     * @param  string $append what value to append to the string
     */
    
function getPluralString($value$append 's')
    {
        return (
$value == '' $append);
    }

    
/**
     * Strips all newline characters (\n) from a string or recursively 
     * through a multi-dimensional array.
     *
     * @return string|array
     * @param  string|array $element
     */
    
function trimNewlinesFromString($element)
    {
        if (
Strings::validateArray($elementfalse) === false) {
            return 
str_replace("\n"''$element);
        } else {
            foreach (
$element as $key => $val) {
                if (
Strings::validateArray($element[$key], false)) {
                    
$element[$key] = Strings::trimNewlinesFromString($element[$key]);
                } else {
                    
$element[$key] = str_replace("\n"''$element[$key]);
                }
            }
        }
        return 
$element;
    }
    
    
/**
     * Strips all carriage return characters (\r) from a string or 
     * recursively through a multi-dimensional array.
     *
     * @return string|array
     * @param  string|array $element
     */
    
function trimCarriageReturnsFromString($element)
    {
        if (
Strings::validateArray($elementfalse) === false) {
            return 
str_replace("\r"''$element);
        } else {
            foreach (
$element as $key => $val) {
                if (
Strings::validateArray($element[$key], false)) {
                    
$element[$key] = Strings::trimCarriageReturnsFromString($element[$key]);
                } else {
                    
$element[$key] = str_replace("\r"''$element[$key]);
                }
            }
        }
        return 
$element;
    }

    
/**
     * Returns the extension of a file (ie. anything that appears after
     * the last '.')
     *
     * @return string|null
     * @param  string $string
     */
    
function getFileExtension($string)
    {
        if (
Strings::validateString($string)) {
            return 
substr($string, (strrpos($string'.') ? strrpos($string'.')+strlen($string)), strlen($string)); 
        } else {
            return 
null;
        }
    }

    
/**
     * Returns the name of a file (ie. anything that appears before
     * the last '.')
     *
     * @return string|null
     * @param  string $string
     */
    
function getFileName($string)
    {
        if (
Strings::validateString($string)) {
            return 
substr($string0, (strrpos($string'.') ? strrpos($string'.') : strlen($string)));
        } else {
            return 
null;
        }
    }

    
/**
     * Displays a human readable file size.
     *
     * @return string|null
     * @param  string $file
     * @param  bool   $round
     */
    
function getFileSize($file$round false)
    {
        if (@
file_exists($file)) {
            
$value 0;
            
$size filesize($file);
            if (
$size >= 1073741824) {
                
$value round($size/1073741824*100)/100;
                return  (
$round) ? round($value) . 'Gb' "{$value}Gb";
            } else if (
$size >= 1048576) {
                
$value round($size/1048576*100)/100;
                return  (
$round) ? round($value) . 'Mb' "{$value}Mb";
            } else if (
$size >= 1024) {
                
$value round($size/1024*100)/100;
                return  (
$round) ? round($value) . 'kb' "{$value}kb";
            } else {
                return 
"$size bytes";
            }
        } else {
            return 
null;
        }
    }

    
/**
     * Counts number of words in a string.
     *
     * if $real_words == true then remove things like '-', '+', that
     * are surrounded with white space.
     *
     * @return string|null
     * @param  string $string
     * @param  bool   $real_words
     */
    
function countWords($string$real_words true)
    {
        if (
Strings::validateString($string)) {
            if (
$real_words == true) {
                
$string preg_replace('/(\s+)[^a-zA-Z0-9](\s+)/'' '$string);
            }
            return (
count(split('[[:space:]]+'$string)));
        } else {
            return 
null;
        }
    }

    
/**
     * Counts number of sentences in a string.
     *
     * @return string|null
     * @param  string $string
     */
    
function countSentences($string)
    {
        if (
Strings::validateString($string)) {
            return 
preg_match_all('/[^\s]\.(?!\w)/'$string$matches);
        } else {
            return 
null;
        }
    }
    
    
/**
     * Counts number of sentences in a string.
     *
     * @return string|null
     * @param  string $string
     */
    
function countParagraphs($string)
    {
        if (
Strings::validateString($string)) {
            
$string str_replace("\r""\n"$string);
            return 
count(preg_split('/[\n]+/'$string));
        } else {
            return 
false;
        }
    }

    
/**
     * Gather information about a passed string.
     *
     * If $real_words == true then remove things like '-', '+', that are 
     * surrounded with white space.
     *
     * @return string|null
     * @param  string $string
     * @param  bool   $real_words
     */
    
function getStringInformation($string$real_words true)
    {
        if (
Strings::validateString($string)) {
            
$info = array();
            
$info['character'] = ($real_words) ? preg_match_all('/[^\s]/'$string$matches) : strlen($string);
            
$info['word']      = Strings::countWords($string$real_words);
            
$info['sentence']  = Strings::countSentences($string);
            
$info['paragraph'] = Strings::countParagraphs($string);
            return 
$info;
        } else {
            return 
null;
        }
    }

}

?>
16.07kb in size
last modified May 6, 2006 at 9:55pm
7583 views, 5105 downloads
list all projects :: this project's forum
added Sep 19, 2002 at 2:49pm :: updated Aug 16, 2004 at 6:32pm :: 1 file :: 17786 views

© Andrew Collington, 2002-2007.