• chop (& rtrim): removes white spaces new lines and tab and carriage return chars from the end of a string. Original not affected.
  
   
  $string=' hallo world ' ;
  print 'string length BEFORE operation: '.strlen($string).'<br>';
  $curtail=chop($string);
  //prints: 13
  print '<br>string length AFTER operation: '.strlen($curtail);
  //prints: 12
• trim: removes white spaces new lines and tab and carriage return chars from the end and the beginning of a string. Original not affected.
   
  $string=' hallo world ' ;
  print 'string length BEFORE operation: '.strlen($string).'<br>';
  $curtail=trim($string);
  //prints: 13
  print '<br>string length AFTER operation: '.strlen($curtail);
  //prints: 11
• ltrim: removes white spaces new lines and tab and carriage return chars from the beginning of a string. Original not affected.
   
  $string=' hallo world ' ;
  print 'string length BEFORE operation: '.strlen($string).'<br>';
  $curtail=ltrim($string);
  //prints: 13
  print '<br>string length AFTER operation: '.strlen($curtail);
  //prints: 12

• strpos locates (by returning a numerical index) the first instance position
  $string='hallo world hallo' ;
  print strpos($string,'hallo');
  //prints: 0
• stripos is the case insensitive version of strpos.
• strstr: is a conceptual integration of strpos above: whereas strpos locates a match and returns the number of its index offset, strstr still locates the first match but doesn't return the number but the whole string from there:
  $string='hallo world hallo' ;
  print strstr($string,'hallo');
  //prints: hallo world hallo
  The difference between strstr and substr is that the former takes in a string to return the sub string from there, whereas substr takes in a numerical indexes to return the sub string from such numerical index.
• stristr is the same as strstr, but this round case insensitive.
• strchr: apparently this is exactly an alias of strstr; at least so also Leon Atkinson reports. Why it has been named including the char suffix is beyond my comprehension: the function indeed seems not to be char oriented:
  $string='hallo world hallo';
  print strchr($string,'hxallo');
  //prints: boolean false
  printing false, means it didn't limit itself to locate the first char of the argument "hxallo", namely a mere h, but searched for the whole word, which obviously was not present in the input string.

  ---

• strrpos locates (by returning a numerical index) the last instance position
   
  $string='hallo world hallo' ;
  print strrpos($string,'hallo');
  //prints: 12
  Anyway there is a serious setback with strrpos: till Php 4 it was a char oriented function although its name carries no reference to chr; it actually does not compare the full string of the second argument but only and exclusively the first character of such argument - that is, if you search for 'hallo' what strrpos is actually doing, is searching for a mere 'h'. yeah.
  Definitely not what you want: you may believe it found a match for 'hallo' when all it found was 'hi'.
  $string='hallo' ;
  $searched='hallo';
  print strrpos($string,'ovest');
  /*prints: 4, which is absurd: implies ovest is inside hallo...*/
   
  The only way till Php 4 included you may find strrpos useful was in case you've to search for a char that concludes the strings you're dealing with most of the time, like for instance a forward slash concludes many times the web address of a web site.
  Conversely, strpos is enormously useful.
  Of course, a problem arises till Php 4: if you want(ed) to search for the numerical index of a whole substring occurrence (and not just a char, that is) from the rightmost edge of an input string, till Php 5 you miss(ed) an adequate function to do that. I have crafted one that does that.
  Following the naming practice of Php I called it strposr and takes in three arguments: the input string, the string you search for, and a third argument which is optional and if passed makes this search case sensitive (the default is case insensitive that is); it returns the numerical index of the last instance found or boolean false if none is found (to check if the outcome is false see below gettype):
  function strposr($string='', $search='', $case=0){ if(!$case){$string=strtolower($string); $search=strtolower($search);}; return ( strpos($string, $search)===false )?false: strlen($string) - strlen($search) - (strpos( strrev($string), strrev($search))); }
  
  Starting with Php 5 strrpos searches also for whole strings.
  
  
• strripos is the case insensitive version of strrpos, with the same inconveniences as strrpos till Php 4 included. From Php 5 these limitations have been finally eliminated.
• strrchr locates the last instance position and returns the string from there [so it is similar to strstr];
  $string='hallo world hallo';
  print strrchr($string, 'r');
  //prints: rld hallo
  Therefore strrchr is not just an alias of strrpos as some manuals report: as you see strrchr returns a string, whereas strrpos returns a number! Also, strrchr's second argument, like strrpos's, does not match the whole passed argument but just the first char present in such argument, and instead of reporting just its index like strrpos does, it reports the whole string from there:
  $string='hallo guys';
  print strrchr($string,'ovest');
  //prints: o guys
  as you see it prints onward from the last occurrence of the first letter of 'ovest' found, namely reports a string (not a number) and grabs it from a searched string (ovest) which was nowhere in the input meant to be searched upon.

TECH NOTE: when I declare:
$next+$offset[ sizeof($offsets)-1 ]
I grab an entry of the $offsets array which does not exist (-1): the returned value of that invocation is therefore null: how can then I sum a number ($next) with a NULL without triggering an error?
By exploiting the so called juggling of the data type of Php: Php can deduce from the operators (in our case: +) that the operation you want to perform is a sum, and that it has to convert the incompatible data type to the less harmful among the compatible ones, which in most numerical cases is zero (except for multiplications or divisions, so be careful with jugglings! Envision first what the return of your juggling is to be accordingly to your variables).

• strtolower converts a whole string to lowercase.
• strtoupper converts a whole string to uppercase.
• ucfirst converts the first letter of each new line to upper case.
• ucwords converts the first letter of each word (regardless of whether at the beginning of a new line or not) to uppercase.

• preg_match:
  $string='phone number is 55 55 56 country code is 01';
  print preg_match('/\d\d/', $string);
  //prints: 1 (would have printed 0 if no matches)
  This function has absurd, convoluted ways to report the matches. That is, to know which the actual matches are you initialize within it a third argument:
  preg_match('/\d\d/', $string, $matches);
  print gettype($matches);
  //prints: array
  Now the output still return an integer but you can also scan it by $matches (or whatever other name you may have given to such variable):
  $string='phone number is 55 55 56 country code is 01';
  preg_match('/\d\d/', $string, $matches);
  print($matches[0]);
  //prints: 55
  I'd suggest to you to resort to the following function instead than to preg_match. use preg_match only to check whether at least one instance of your pattern is present, and for nothing else.
• preg_match_all:
  $string='phone number is 55 55 56 country code is 01';
  print preg_match_all('/\d\d/', $string, $matches);
  //prints: 4
  Namely it returns the amount of matches. The third argument, which you can initialize right on the spot and with whatever name you prefer as long as it is not conflicting with the name of some other variable in the same scope and with the same name, must apparently always be included or an error may follow.
  So to know also which the matches are, you take avail of this third argument: it is going to become an array storing the instances:
  $string='phone number is 55 55 56 country code is 01';
  preg_match_all('/\d\d/', $string, $matches);
  
  Now $matches is available to be scanned. Its shape is as follows:
  $matches[0]: it is an array of all the instances found:
  print_r($matches[0]);
  //prints: Array ( [0] => 55 [1] => 55 [2] => 56 [3] => 01 )
  If you perform a capture of the elements by parenthesis (to know what capturing is see this file on regular expressions, it is geared on javascripts but the concepts are nearly identical) then $matches would store as subsequent set of indexes from 1 onward the found captured instances for each parenthesized element as arrays (whereas index [0] would still report matches to the whole pattern regardless of the parenthesis meant to instruct the captures) or, to use the terms used at php.org:

  Orders results so that $matches[0] is an array of full pattern matches, $matches[1] is an array of strings matched by the first parenthesized [=captured, my note] subpattern, and so on.

  Example:

  ---

  $string=$HTTP_USER_AGENT;
  preg_match_all('/(.+)([0-9])\.([0-9]+)/',$string,$matches);
  //full match:
  print_r($matches[0]); print '<br>'; //0
  //browser:
  print_r($matches[1]); print '<br>'; //1
  //browser version:
  print_r($matches[2]); print '<br>'; //2
  //browser subversion:
  print_r($matches[3]); //3

  ---

  On my Internet Explorer this prints:

  ---

  Array ( [0] => Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.0 ) //0
  Array ( [0] => Mozilla/4.0 (compatible; MSIE 6.0; Windows NT ) //1
  Array ( [0] => 5 ) //2
  Array ( [0] => 0 ) //3

  ---

  namely each of those entries is an array, consequently for instance:
  print($matches[2][0]);
  //just prints: 5
  The fourth argument, if passed, would slightly modify the type of returned matrix $matches. I assume this modification is so mild that it is not necessary to use more bandwidth just to describe such small change.
• preg_split:
  $string='hallo world hallo folks';
  $splitted=preg_split('//',$string); //splits by an empty set: '//'
  print_r($splitted);
  This returns an array whose each element is one of the chars, white spaces and hidden chars included, composing the string; thus:
  print(sizeof($splitted));
  //prints: 25
  print($splitted[1]); print($splitted[5]);
  //prints: ho
  Note that the hidden chars such as those of starting line or new line are included, therefore
  $splitted[0]
  would print an empty slot for it stands for the start of line hidden char. Ok?
  $string='hallo world hallo folks';
  $splitted=preg_split('/hallo/',$string);
  print_r($splitted);
  //prints: Array ( [0] => [1] => world [2] => folks )
  The notation [0] => means that entry [0] is pointing at an hidden char.
  Of course, remember that as usual the splitter is omitted from the output!
   
  Anyway preg_split allows two further arguments:
  • third argument: a number which flags how many splinters you want at most (that is, it sets a limit to the output). If passed as negative 1 namely -1 is the same as saying: all the possible ones.
    Numerical values exceeding the amount of splinters that it is possible to produce are to be handled as just a reference to the highest possible amount.
  • The foruth argumtn can be a bareword, that is not within quotes. If such bareword is: PREG_SPLIT_NO_EMPTY, the returned output will exclude whatever empty entry.
    So in such case the [0] index won't be empty. Yeah somewhat convoluted I agree. Anyway, example:
    $string='hallo world hallo folks';
    $splitted=preg_split('/hallo/', $string, -1, PREG_SPLIT_NO_EMPTY);
    print_r($splitted);
    //prints: Array ( [0] =>world [1] => folks ): no more empty sets
• split:
  Use this function when you want to split by a known string; that is, without resorting to regular expressions. Splits globally by default (that is, splits by all instances found). Returns an array.
  $string='hallo jim hallo mike';
  $splitted=split('hallo',$string);
  print_r($splitted);
  //prints: Array ( [0] => [1] => jim [2] => mike )
• spliti:
  case insensitive version of split (see above).
• preg_replace:
  $string='hallo world hallo folks';
  $replaced=preg_replace('/\w{5}/','',$string);
  print($replaced);
  //prints: jim mike
  The expression above '/\w{5}/' searches for sets of words including 5 letters (in our example only 'hallo' fits the pattern) and replaces them, in our example, just with an empty set: ''.
  Note that preg_replace needs three arguments: the regular expression, the replacement, the input string as last.
  The original $string is not affected, a new one is produced.
• str_replace:
  Use this function when you want to replace by a known string; that is, without resorting to regular expressions. Replaces globally by default (that is, replaces by all instances found). Returns a string, original not affected.
  $string='hallo jim hallo mike';
  $replaced=str_replace('hallo', 'goodbye', $string);
  print($replaced);
  //prints: goodbye jim goodbye mike
  
  From Php 5 is available the case insensitive version str_ireplace
• substr_replace:
  Use this function when you want to replace by a known string; that is, without resorting to regular expressions. Replaces locally for, being a substring matching function, has to be selective by definition: it sticks to the substring alone.
  Returns a string, original not affected.
  It is different from str_replace insofar it replaces within a substring and thus it affects only such segment. You locate such substring considering how to pass its arguments: firstly the input string, secondly the replacement, thirdly the numerical index upon which you want to start the replacement upon the input string, lastly the length until which you want this replacement to occur (if omitted, it assumes until the end). Do consider this example:
  $string='hallo jim hallo mike';
  $replaced=substr_replace($string, 'goodbye', 0, 1);
  print($replaced);
  //prints: goodbyeallo jim hallo mike
  you may note that we've started with index 0 (and substr_replace doesn't count in hidden chars for it is not regular expression oriented so it is not that much sophisticated!) and we've set that we want to replace for as many as 1 char: namely we said that we just wanted to replace the first h! Therefore it derives that funny goodbyeallo.
  And yes, saying $replaced=substr_replace($string, 'goodbye', 0, 0); would have generated goodbyehallo jim hallo mike!
  $string='hallo jim hallo mike';
  $replaced=substr_replace($string, 'goodbye', 5, 4);
  print($replaced);
  //prints: hallogoodbye hallo mike
   
  $replaced=substr_replace($string, 'goodbye', 5, 0);
  print($replaced);
  //prints: hallogoodbye jim hallo mike
   
  $replaced=substr_replace($string, 'goodbye', 0, 0);
  print($replaced);
  //prints: goodbyehallo jim hallo mike
• wordwrap: useful for formatting line lengths in outputs such as emails or similar.
  Takes in a string, divides it by default into substrings of lines of 75 chars long. If you want to change this latter value, pass the second argument as a number of the desired value. The third argument is optional and represents the delimiter to be added at the end of any line, it defaults to a new line.
  $string='Hallo darling, I am here communicating to you that I am arriving tomorrow around 3pm with the first flight. Take care, Susan.';
  print wordwrap($string, 20, '<br>');
   
  /*prints: Hallo darling, I am
  here communicating
  to you that I am
  arriving tomorrow
  around 3pm with the
  first flight. Take
  care, Susan.
  */
  Does not interrupt whole words:
  $string='supercalifragilissimum is';
  print wordwrap($string, 5, '<br>');
  /*prints: supercalifragilissimum
  is
  */

• urlencode & rawurlencode:
  given an url (a web address, that is; but it could just be any string, actually! it's just commonly used for urls) which is not encoded, namely which still contains chars such as punctuations and white spaces, it returns the url with such chars encoded accordingly to the web specifications (namely symbols, so to say, that start with a % sign):
  $string="mailto: john_smith@foo.com";
  print (rawurlencode($string));
  that prints:
  mailto%3A%20john_smith%40foo.com
  Prefer using rawurlencode for it's more complete, meaning it works also with binary data.
  Original not affected. This method is analogous to the javascript method named escape.
• urldecode & rawurldecode:
  perform the opposite (of course, you'd use rawurldecode to decode something you coded by rawurlencode):
  print rawurldecode('mailto%3A%20john_smith%40foo.com');
  //prints: mailto: john_smith@foo.com
  This method is analogous to the javascript method named unescape.

• nl2br:
  this function converts all the new lines inside a string into <br> html tags.
• quotemeta:
  I assume you know what escaping a char means. if you don't have a look at this file section and locate by yourself the subsection where it deals with escaping.
  quotemeta escapes (pre pends to each of them a backward slash, that is) the following chars:
  . \ + * ? [ ] ( ) $ ^
  It is useful to pass PHP code that needs to escape its punctuation identifiers.
  print quotemeta('$myVar=5*2-4');
  //prints: \$myVar=5\*2-4
• addslashes:
  this function returns the input text prepending backward slashes to:
  ' " \
  $string='my name is "John Smith"';
  print (addslashes($string));
  //prints: my name is \"John Smith\"
• stripslashes:
  complements addslashes and removes slashes:
  $string='my name is \"John Smith\" you \know \\';
  print stripslashes($string);
  //prints: my name is "John Smith" you know
• strip_tags:
  It removes all the html tags from an input string. Traditionally used before parsing form text fields with data provided by an user input.
  If you want to allow certain tags, you can include them in the second argument, which is optional and which must be a string including the opening (but not the corresponding closing) tags of a pair, each listed after another (and it doesn't matter whether capitalized or not, they would work in both cases):
  $string='I am <br><strong>John Smith </strong> <script>while(1){alert()}</script>';
  print( strip_tags($string, '<strong><br>') );
  /*prints:
  I am <br><strong>John Smith</strong> while(1){alert()}
  */
• htmlentities:
  returns the input string with the html special chars transformed into their matching html entities; most remarkably used to convert < and > htm opening and closing tags with &lt; and &gt;
  $string='you can use <html> - by happysite ©';
  print htmlentities($string);
  /*prints:
  you can use &lt;html&gt; - by happysite &copy;
  */
• htmlspecialchars:
  same as htmlentities before but less powerful (less entities are contemplated, that is).

"It is theorized that the algorithm for the md5 function will produce unique identifiers for all strings."