2.6.1.1. Variable substitution

$cm = 127;
$inch = $cm / 2.54;

// prints "127 centimeters = 50 inches"
echo "$cm centimeters = $inch inches";

When the name of the variable is ambiguous, braces {} can delimit the name as shown in the following example:

$memory = 256;

// Fails: no variable called $memoryMbytes
$message = "My computer has $memoryMbytes of RAM";

// Works: Curly braces are used delimit variable name
$message = "My computer has {$memory}Mbytes of RAM";

// This also works
$message = "My computer has ${memory}Mbytes of RAM";

Braces are also used for more complex variables, such as multidimensional arrays and objects:

echo "Mars is {$planets['Mars']['dia']} times the diameter of the Earth";

echo "There are {$order->count} green bottles ...";

2.6.1.2. Length of a string

integer strlen(string subject)

Consider an example that prints 16:

print strlen("This is a String");  // prints 16

2.6.2.1. Creating formatted output with sprintf( ) and printf( )

string sprintf (string format [, mixed args...]) 
integer printf (string format [, mixed args...])

The operation of these functions is modeled on the identical C programming language functions, and both expect a string with optional conversion specifications, followed by variables or values as arguments to match any formatting conversions. The difference between sprintf( ) and printf( ) is that the output of printf( ) goes directly to the output buffer PHP uses to build a HTTP response, whereas the output of sprintf( ) is returned as a string.

Consider an example printf statement:

printf("Result: %.2f\n", $variable);

The format string Result: %.2f\n is the first parameter to the printf statement. Strings like Result: are output the same as with echo or print. The %.2f component is a conversion specification:

• All conversion specifications begin with a % character.

• The f indicates how the type of value should be interpreted. The f means the value should be interpreted as a floating-point number, for example, 3.14159 or 128.23765. Other possibilities include b, c, d, and s, where b means binary, c means a single character, d means integer, and s means string.

• The .2 is an optional width specifier. In this example, .2 means two decimal places, so the overall result of %.2f is that a floating-point number with two decimal places is output. A specifier %5.3f means that the minimum width of the number before the decimal point should be five (by default, the output is padded on the left with space characters and right-aligned), and three digits should occur after the decimal point (by default, the output on the right of the decimal point is padded on the right with zeros).

In the example, the value that is actually output using the formatting string %.2f is the value of the second parameter to the printf function—the variable $variable.

2.6.2.2. Padding strings

string str_pad(string input, int length [, string padding [, int pad_type]])

Characters are added to the input string so that the resulting string is characters in length. The following example shows the simplest form of str_pad( ) that adds spaces to the end of the input string:

// prints "PHP" followed by three spaces
echo str_pad("PHP", 6); 

An optional string argument padding can be supplied that is used instead of the space character. By default, padding is added to the end of the string. By setting the optional argument pad_type to STR_PAD_LEFT or to STR_PAD_BOTH, the padding is added to the beginning of the string or to both ends. The following example shows how str_pad( ) can create a justified index:

$players =  
   array("DUNCAN, king of Scotland"=>"Larry", 
         "MALCOLM, son of the king"=>"Curly",  
         "MACBETH"=>"Moe",
         "MACDUFF"=>"Rafael");
 
echo "<pre>";
 
// Print a heading
echo str_pad("Dramatis Personae", 50, " ", STR_PAD_BOTH) . "\n";
 
// Print an index line for each entry
foreach($players as $role=>$actor)
  echo str_pad($role, 30, ".")
      . str_pad($actor, 20, ".", STR_PAD_LEFT) . "\n";
 
echo "</pre>";

The example prints:

                Dramatis Personae                 
DUNCAN, king of Scotland.....................Larry
MALCOLM, son of the king.....................Curly
MACBETH........................................Moe
MACDUFF.....................................Rafael

2.6.2.3. Changing case

string strtolower(string subject)
string strtoupper(string subject)
string ucfirst(string subject)
string ucwords(string subject)

The following fragment shows how each operates:

print strtolower("PHP and MySQL"); // php and mysql
print strtoupper("PHP and MySQL"); // PHP AND MYSQL
print ucfirst("now is the time");  // Now is the time
print ucwords("now is the time");  // Now Is The Time

2.6.2.4. Trimming whitespace

string ltrim(string subject)
string rtrim(string subject)
string trim(string subject)

$var = trim(" Tiger Land\n");  // "Tiger Land"
$var = ltrim(" Tiger Land\n"); // "Tiger Land\n"
$var = rtrim(" Tiger Land\n"); // " Tiger Land"

2.6.2.5. Rendering newline characters with <br>

string nl2br(string source)

The following example shows how nl2br( ) works:

// A short poem
$verse = "Isn't it funny\n";
$verse .= "That a bear likes honey.\n";
$verse .= "I wonder why he does?\n";
$verse .= "Buzz, buzz, buzz.\n";

// The four lines are rendered as one
echo $verse;

// Renders the poem on four lines in HTML as intended
echo nl2br($verse);

2.6.4.1. Extracting a substring from a string

string substr(string source, integer start [, integer length])

When called with two arguments, substr( ) returns the characters from the source string starting from position start—counting from zero—to the end of the string. With the optional length argument, a maximum of length characters are returned. The following examples show how substr( ) works:

$var = "abcdefgh";

print substr($var, 2);       //  "cdefgh"
print substr($var, 2, 3);    //  "cde"
print substr($var, 4, 10);   //  "efgh"

If a negative start position is passed, the starting point of the returned string is counted from the end of the source string. If the length is negative, it's treated as the index, and the returned string ends length characters from the end of the source string. The following examples show how negative indexes can be used:

$var = "abcdefgh";

print substr($var, -1);      //  "h"
print substr($var, -3);      //  "fgh"
print substr($var, -5, 2);   //  "de"
print substr($var, -5, -2);  //  "def"

2.6.4.2. Finding the position of a substring

integer strpos(string haystack, string needle [, integer offset])

When called with two arguments, the search for the substring needle is from the start of the string haystack at position zero. When called with three arguments, the search occurs from the index offset into the haystack. The following examples show how strpos( ) works:

$var = "To be or not to be";

print strpos($var, "T");     // 0
print strpos($var, "be");    // 3

// Start searching from the 5th character in $var
print strpos($var, "be", 4); // 16

integer strrpos(string haystack, string needle)

Unlike strpos( ), strrpos( ) searches for only a single character, and only the first character of the needle string is used. The following examples show how strrpos( ) works:

$var = "To be or not to be";

// Prints 13: the last occurrence of "t"
print strrpos($var, "t");

// Prints 0: Only searches for "T" which 
// is found at position zero
print strrpos($var, "Tap"); 

// False: "Z" does not occur in the subject
onlyprint strrpos($var, "Zoo"); 

If the substring needle isn't found by strpos( ) or strrpos( ), both functions return false. The is-identical operator === should be used when testing the returned value from these functions against false. If the substring needle is found at the start of the string haystack, the index returned is zero and is interpreted as false if used as a Boolean value.

2.6.4.3. Extracting a found portion of a string

string strstr(string haystack, string needle)
string stristr(string haystack, string needle)

The strstr( ) search is case-sensitive; the stristr( ) search isn't. If the needle isn't found in the haystack string, both strstr( ) and stristr( ) return false. The following examples show how the functions work:

$var = "To be or not to be";

print strstr($var, "to");    //  "to be"
print stristr($var, "to");   //  "To be or not to be"
print stristr($var, "oz");   // false

string strrchr(string haystack, string needle)

Unlike strstr( ) and stristr( ), strrchr( ) searches for only a single character, and only the first character of the needle string is used. The following examples show how strrchr( ) works:

$var = "To be or not to be";

// Prints: "not to be"
print strrchr($var, "n"); 

// Prints "o be": Only searches for "o" which
// is found at position 14
print strrchr($var, "oz");

2.6.4.4. Extracting multiple values from a string

array explode(string separator, string subject [, integer limit])
string implode(string glue, array pieces)

The explode( ) function returns an array of strings created by breaking the subject string at each occurrence of the separator string. The optional integer limit determines the maximum number of elements in the resulting array; when the limit is met, the last element in the array is the remaining unbroken subject string. The implode( ) function returns a string created by joining each element in the array pieces, inserting the string glue between each piece. The following example shows both the implode( ) and explode( ) functions:

$guestList = "Sam Meg Sarah Ben Jess May Adam";
$name = "Fred";

// Check if $name is in the $guestList
if (strpos($guestList, $name) === false)
{
  $guestArray = explode(" ", $guestList);
  sort($guestArray);
  echo "Sorry '$name' is not on the guest list.\n";
  echo "Guest list: " . implode(", ", $guestArray)
}

Sorry 'Fred' is not on the guest list.
Guest list: Adam, Ben, Jess, May, Meg, Sam, Sarah 

2.6.5.1. Replacing substrings

string substr_replace(string source, string replace, int start [, int length])

Returns a copy of the source string with the characters from the position start to the end of the string replaced with the replace string. If the optional length is supplied, only length characters are replaced. The following examples show how substr_replace( ) works:

$var = "abcdefghij";

// prints "abcDEF";
echo substr_replace($var, "DEF", 3);

// prints "abcDEFghij";
echo substr_replace($var, "DEF", 3, 3);

// prints "abcDEFdefghij";
echo substr_replace($var, "DEF", 3, 0);

mixed str_replace(mixed search, mixed replace, mixed subject)

In the following example, the subject string, "old-age for the old", is printed with both occurrences of old replaced with new:

$var = "old-age for the old.";

echo str_replace("old", "new", $var);

The result is:

new-age for the new.

Since PHP Version 4.0.5, str_replace( ) allows an array of search strings and a corresponding array of replacement strings to be passed as parameters. The following example shows how the fields in a very short form letter can be populated:

// A short form-letter for an overdue account
$letter = "Dear #title #name, You owe us $#amount.";

// Set-up an array of three search strings that  
// will be replaced in the form-letter
$fields = array("#title", "#name", "#amount");

// An array of debtors. Each element is an array that
// holds the replacement values for the form-letter
$debtors = array(
    array("Mr", "Cartwright", "146.00"),
    array("Ms", "Yates", "1,662.00"),
    array("Dr", "Smith", "84.75"));

foreach($debtors as $debtor)
  echo "<p>" . str_replace($fields, $debtor, $letter);

The output of this script is as follows:

Dear Mr Cartwright, You owe us $146.00.
Dear Ms Yates, You owe us $1,662.00.
Dear Dr Smith, You owe us $84.75.

If the array of replacement strings is shorter than the array of search strings, the unmatched search strings are replaced with empty strings.

2.6.5.2. Translating characters and substrings

string strtr(string subject, string from, string to)
string strtr(string subject, array map)

When called with three arguments, strtr( ) translates the characters in the subject string that match those in the from string with the corresponding characters in the to string. When called with two arguments, a subject string and an array map, occurrences of the map keys in subject are replaced with the corresponding map values.

The following example uses strtr( ) to replace all lowercase vowels with the corresponding umlauted character:

$mischief = strtr("command.com", "aeiou", "äëïöü");
print $mischief;  // prints cömmänd.cöm

When an associative array is passed as a translation map, strtr( ) replaces substrings rather than characters. The following example shows how strtr( ) can expand acronyms:

// Short list of acronyms used in e-mail
$glossary = array("BTW"=>"by the way",
                  "IMHO"=>"in my humble opinion",
                  "IOW"=>"in other words",
                  "OTOH"=>"on the other hand");

// Maybe now I can understand
print strtr($geekMail, $glossary);