The PHP language supports eight primitive types—four scalar, two compound, and one special value, with some overlap between the mathematical types (hence there are really only seven discrete data types, but eight identifiers). A scalar type can contain one value for a (possibly infinite) set of allowed values.

PHP treats strings as scalar types, because arrays are defined as compound types, which contain elements of differing types. So, a compound type can use a single variable to refer to an object that has components that have a variety of individual types—an address might contain a street number and a street name, for example.

The four scalar types are as follows:

The following sections discuss each of these types in detail.

$one = 1;
$two = 2;
$my_result = $one / $two; // == 0.5
echo (int) $my_result; // 0
echo round ($my_result); // 1

$my_string = "hello";
$my_other_string = 'goodbye';

$my_string = ""hello""; // "hello"
$my_other_string = '"goodbye"'; // "goodbye"

$my_substring = "green";
$my_string = "The color is $my_substring.";
              // The color is green

$my_string <<<EOD
This all goes into
my string.
EOD;

$end = "the" . " " . "end";
$my_string = "The beginning ...";
$my_string .= "..."; // The beginning ... ...
$my_string .= "... the" . $end;
              // The beginning ... ... ... the the end

$my_numbers = array (1, 3, 5, 7, 9);

$first_number = $my_numbers[0];

$my_pie_recipe =
  array ("meat" => "chicken", "vegetable"
  => "potato", "serves" => 4);

echo "Pie with meat will be a " .
           $my_pie_recipe['meat'] . " pie.";

Pie with meat will be a chicken pie.

$pie_type = "meat";
echo "Pie with $pie_type will be a
     ".$my_pie_recipe[$pie_type] . " pie.";

Pie with meat will be a chicken pie.

$query = $_GET['q'];

http://myserver.com/search.php?q=search+text

$query = $_POST['q'];

$my_string = "some string data";
$my_123 = 123;
$my_floating_double = 23.456;

$pVariable = &$myVariable;
       // $pVariable points to $myVariable

$pVariable = "more string data";

echo "->" . $pVariable;
echo $myVariable;

$my_text = "test this";
function myFunction () { // defines a function
  $my_text = "test_that";
  echo $my_text . "
";
}
echo $my_text;

test that
test this

define ("MY_CONSTANT", "the value");
define ("MY_NUMBER", 42);

echo MY_CONSTANT;

Classes are self-contained object templates that contain the data definition and method implementation that processes that data. The array data type is an example of a class and is instantiated by calling something called the class constructor.

Classes are good for modularity because they allow programmers to encapsulate the behavior and data into a single place that can be easily interfaced with. This also helps to make the code that accesses that functionality cleaner.

A class can be defined using the following skeleton:

class name
{
  var member;

  function name() // constructor
  {
    // Instantiate the object
  }
  function method()
  {
    // Operate on the object, perhaps return a value
  }
}

If this appears in a PHP file, you can use the following PHP code to instantiate it and access the method that it defines:

$variable = new name();
name->method();

Naturally, wherever there is a name in italics, the programmer should substitute his or her own identifiers. So, to create an object that is designed to represent, for example, an Amazon.com product, you might create a class as follows:

class AmazonProduct
{
   var $ASIN;
   
   function AmazonProduct ($ASIN_in) // constructor
   {
     // Instantiate the object
     $this->ASIN = $ASIN_in;
   }
  
  function MakeLink ()
  {
     // Operate on the object, perhaps return a value
     // The following is entirely fictional,
     // for illustration only!
     $link = "http://www.amazon.com/books
                   /$this->ASIN/aff=12345";
     return "<a href=$link>$this-7gt;ASIN</a>";
  }
}

Note that access to the member variables is achieved through the this variable, which is treated as a variable name in itself. This negates the need to prefix the variable with a dollar sign, as the whole stanza this->member is treated as the variable.

To use this class, programmers have to allocate it to a variable:

$my_book = new AmazonProduct ("1598636847");

From this point on, whenever programmers need to insert a link to the product whose ASIN is 1598636847, they can do so with a simple call to the MakeLink member function:

echo $my_book->MakeLink();

You’ll see the various ways in which functions can be defined in more detail later on. Each one is just a block of named code that can be specified once and called multiple times with different sets of data to operate on.

One final note is that the programmer can only break the class definition into multiple code blocks if that is done within a method definition. This is to allow the programmer to break out of a method to use plain HTML code and then step back into the class to finish off the definition.

It is also possible to access the properties of a class from outside it; however, in the interests of modularity, I would argue that this should be kept to a minimum. Nevertheless, the same arrowed notation can be used, as follows:

echo $my_book->ASIN;

This line of code would simply output the ASIN of the $my_book object.

Clearly, if this was to be allowed between method definitions, it would be at a time when there is no executable code being evaluated, and the result would not be coherent. For example, this is perfectly allowable:

<?php
class myClass {
// there is no executable code here
  function myClassFunction () {
  ?> <!–out of php code–>
     <b>This is executed in myClassFunction</b>
  <?php // back in again
  }
}
?>

In this code, when myClass->myClassFunction() is called, the only thing it will do is generate the bold line of text. This illustrates the power of jumping in and out of inline PHP within a class definition, but it is also to be used with care because it is easy to lose track of the script when moving in and out of PHP code and HTML.

The PHP language has the usual complement of comparison, mathematical, and logical operators, plus a few special ones for processing strings and arrays. You can use an operator to compare two PHP expressions or to combine them. Some of those combinations result in a modification of the operands (the variables on the left or right of the operator).

Expressions that are built up using operators can also be grouped by using parentheses to override the orders of precedence built into the language. As a rule of thumb it is always better to write:

$var = ($a + $b)–($c * ($d / $e));

rather than:

$var = $a + $b - $c * $d / $e;

Even if the programmer knows that the two expressions should evaluate to the same final value, using parentheses makes sure that there are no misconceptions and also improves the debugging (error fixing) rounds.

var_dump(1 == 1); // prints true
var_dump(0 == 1); // prints false
$one = 2;
var_dump($one == 1); // prints false

var_dump ("1" != 1); // prints false after conversion to number
var_dump ($one != 1); // prints true, see above

$var_result =3/2;

$var_int_result = (int) 3 / 2;

$var_int_result = round (3 / 2);

$result = 0;
$result += 3; // $result = $result + 3
$result /= 2; // $result = $result / 2
$result *= 3; // $result = $result * 3
$operand = 4;
$result -= $operand * 5;// $result = $result - 4 * 5

$result++; // $result + = 1 or $result = $result + 1

($a == $b) && ($c == $d)   true when all are equal

$result = true && false;
$result = ($a == $b) || ($b >= $c);

$string_one = "a string
";
$string_two = 'another string';

$string_three = $string_one . $string_two;

$array_a = array (1 => "One", 2 => "Two", 3 => "Three");
$array_b = array (1 => "one", 2 => "three", 3 => "two");
$array_c = array (2 => "Two", 1 => "One", 3 => "Three");
var_dump ($array_a == $array_b); // false
var_dump ($array_a == $array_c); // true

var_dump ($array_a === $array_c); // false

var_dump ($array_a !== $array_c); // true

var_dump ($array_a != $array_b); // true
var_dump ($array_a != $array_c); // false

var_dump ($array_a <> $array_b); // true
var_dump ($array_a <> $array_c); // false

As with JavaScript, the basic decision-making unit is the if construct. This can be a simple case of testing a single condition, as the following shows:

if ($blog_entry->category == 1) {
   // print blog entry
}

Deconstructing the previous code, note that the code that you want to execute if the condition evaluates to true is contained in braces { and }. In the bracketed condition part, you can use any valid PHP expression that evaluates to true.

In case you need to provide an alternative operation to the one that was intended when the condition is met, the else construct can be added:

if ($blog_entry->category == 1) {
   // print blog entry
}
else {
  // do something else
}

In this snippet, if the condition is not met, the contents of the else construct will be executed. There is an alternative notation for the else statement, born out of the need to break out of PHP occasionally. The generic form for this notation is as follows:

if (condition) : some code
else : some other code
endif;

Clearly this method is just a template, and you need to embellish it with actual PHP code, but it quickly becomes quite complex:

if ($blog_entry->category = = 1) : $blog_entry->display();
else : $blog_entry->show_link();
endif;

So far, so good. However, the main reason for the new notation is to ease the possibility to break out of the PHP. In order to add the HTML that will embellish the result of the supposed $blog_entry object member functions, you can construct code such as:

<?php if ($blog_entry->category = = 1) : ?>
Blog entry title : <?php $blog_entry->display(); ?>
<?php else : ?>
Blog link to alternative : <?php $blog_entry->show_link();
endif; ?>

More alternatives can be added to the basic if .. else construct by introducing the elseif keyword. This allows you to test a second (third, fourth, and so on) condition within the same decision block. For example:

<?php
if ($blog_entry->category = = 1) {
   // category 1 logo
?>
<img src="logo_1.gif">
<?php
}
elseif ($blog_entry->category = = 2) {
  // category 2 logo
?>
<img src="logo_2.gif"7gt;
<?php
}
else {
  // default logo
?>
<img src="logo_default.gif">
<?php
}
?>

(Note that the logo_default.gif file should be present in the same folder as the PHP code in order for it to work properly.)

You can use this code example with the alternative construction as well by following the same approach as before. Note that this code breaks out of the PHP script to write the image tag straight in as HTML rather than using an echo statement from the PHP code itself.

The other kind of decision-making construct that PHP offers should also be familiar to you, and is the switch construct, which is used to avoid endless if, elseif, else nesting. If you put this into the same logic as the previous code, you see the obvious advantage of using the switch construct:

switch ($blog_entry->category) {
case 1 :
  echo "<img src="logo_1.gif">";
  break;
case 2 :
  echo "<img src="logo_2.gif">";
  break;
default :
  echo "<img src="logo_default.gif">";
  break;
}

As in other languages, such as JavaScript, the break keyword stops the evaluation and breaks out of the switch construct. Again, the default clause produces a result when the other statements all evaluate to false.

Unlike in other languages, the switch .. case construct can test a variety of data types, including numbers and, interestingly, strings.

If you need to construct a block of code that is to be executed a number of times, PHP gives you several alternatives. The first is the basic while loop, with the evaluation of the termination condition at the top of the loop:

while ($blog_entry->category = =1){
   // do something
   $blog_entry = $blog_list[$entry++]; // get the next one
}

This construct is accompanied by a version that uses the alternative notation that you have encountered in the previous section. This looks akin to the following:

while ($blog_entry->category == 1):

  // do something
  $blog_entry = $blog_list[$entry++]; // get the next one
endwhile;

Note that I have added the endwhile keyword to the end of the loop to show PHP where I would like it to end. In either case, you can break out of the PHP in the usual manner, using the <?php and ?> notation in order to mix in HTML code.

The alternative to the while loop is the do .. while loop. Here, the evaluation is performed at the end of the loop:

do {
   // do something
   $blog_entry = $blog_list[$entry++]; // get the next one
} while ($blog_entry->category == 1);

The key difference between the two is that the loop will execute at least once in the do .. while loop, whereas it might not execute at all in the while loop where the evaluation is done at the top of the loop construct. Another difference is that the do .. while loop cannot be constructed using the alternative notation for other flow control code blocks.

The last kind of looping mechanism you are going to look at is the for loop. This comes in two different flavors, each providing for the alternative notation as well as the standard usage with braces. The generic for statement allows initialization, comparison, and alteration clauses:

for ($entry = 0; $entry < count($blog_list); $entry++) {
   // process entries
}

This snippet uses the count() function to check that the for loop only executes as many times as there are elements in the $blog_list array. The alternative notation follows the same general form as the previous constructs:

for ($entry = 0; $entry < count($blog_list); $entry++) :
 // process entries
endfor;

There is also a simpler way to process items that are part of a collection, such as an array, by using the foreach construct. This assigns a value to a temporary variable that is placed in the foreach statement as follows:

foreach ($blog_list as $blog_entry) {

 // process entries
}

This block is functionally equivalent to the while and for loop constructs already discussed, but without the $entry counter to index into the array. The alternative notation for the foreach construct is as follows:

foreach ($blog_list as $blog_entry) :
  // do things
endforeach;

Finally, there are two important keywords for use with loops—break and continue. The break keyword works in the same way for loops as it does for the switch construct; it breaks out of the loop without completing processing. You can use this to exit the loop prematurely when a specific condition is met.

The continue keyword is similar in a way, except that it does not break out of the loop, but moves to the next iteration. So, if there is a specific entry that you do not want to process, you can skip an iteration. The code for this might look something like this:

foreach ($blog_list as $blog_entry) {
  if ($blog_entry->category != 1) {
     continue; // we don't process these
  }
  // process entries
}

Although the foreach loop was used to illustrate the continue keyword, it can be used with any of the previous loops, as can the break keyword. With these looping capabilities, you can build any data processing model.

A function is a named block of code that can be called, with or without parameters, from a piece of PHP code once the function has been defined. These functions can also return values.

The first thing to note is that function names are not case-sensitive. This is different from the rest of the PHP syntax and also most other programming languages. However, it will make programming and maintaining scripts easier if function names are treated as if they are case-sensitive.

The scope of functions is global once the function has been defined, and this means that if it is conditionally defined, using an if construct or similar, it is accessible only once the condition has been satisfied and the function has been evaluated. If the code never gets executed, the function will never be defined and hence will never exist.

If you remember that all PHP scripts are evaluated in a top-down fashion, and on demand as they are required, this means that, potentially, some functions will never be executed.

This is a little counter-intuitive, especially when you consider that functions are available from anywhere after the point at which they were defined. This also extends to functions that are defined inside another function.

Subsequently, you have to be very careful about naming functions correctly so that if a module is used that comes from the outside, it is useful to have a function list so that different identifiers are used. When you design code that’s to be made available for wider use, it is also useful to include some kind of function identifier to keep the names unique.

An example of a simple function that takes a parameter and returns a value is as follows:

function getBold ($text)
{
  return "<b>$text</b>";
}

Of course, functions can be defined that do not accept a value or return one. In the former case, this just means that the function name is followed by parentheses that are empty. If no value is returned, the only difference is that the return keyword is not used.

In addition, you can define functions that have a default in case the programmer using the function is not passing a value for some reason. To do this, the first line (where the definition is established) is as follows:

function getBold ($text = "")

Function parameters can be passed by reference or by value. Passing by value means that if a variable is passed in the parameter list, it cannot be changed by the function. To pass by reference, which will allow these changes, all that you need to do is put a & in front of the variable name in the function definition:

function makeBold (&$text) // Pass by reference
{

  // function code
  $text = "<b>$text</b>";
}
// more code here
$myText = "Title Text";
makeBold ($myText);
echo $myText;

Before you develop your own functions to perform specific processing, first read through the section entitled “PHP Short Function Reference,” which covers the most useful of the functions provided by PHP to help you achieve your programming goals.

There is no sense trying to reinvent the wheel, and the community support of PHP as a Web language is such that virtually every function imaginable has already been thought of, and most of them have been implemented.

Some parts of the PHP system are actually libraries that extend the core functionality of the language. So, for example, all the array manipulation functions (those that are prefixed by array_) are part of the core libraries and not the language itself.

In addition, there is a collection of functions for manipulating arrays (count, sort, in_array, current, next, and so on) that are listed in the function reference and that are part of the libraries and not the PHP language proper.

Array functions include anything listed as array_ plus a collection of non-prefixed array manipulation functions such as count, sort, in_array, current, next, prev, reset, and end.

Class functions include class_exists and other functions that get information about a specific class and are also extensions to the core language. These functions very useful for object oriented or modular programming. The class library includes the core language constructs for creating classes.

Date and time functions, including functions for manipulating date information, are also part of the core libraries

Finally, there is a set of DOM functions that allow the handling of HTML and XML documents, both local and remote, using a well-defined API. These functions are very easy to use for basic tag extraction, for example, or when creating/validating XML feeds.

This is not an exhaustive list, but gives an overview of the most common core libraries and the ones that are used most frequently in PHP programming. In addition to the libraries, there is also a set of extensions that can be compiled into the language when it is activated within an environment.

Unlike the core libraries, the extensions might not be available from one provider to another.

The php_info() command shows what options have been compiled in. It can be used in a simple PHP script to display the various libraries that are available. Be warned, however, that it can lead to a rather long document being displayed in the browser window.

However, the alternative is to use the function_exists(function) command, which returns true if a given function is available. Of course, by this point in the script it may be too late, but it will at least give the possibility to choose between possible graceful exits or alternative solutions.

The MySQL database extension is a common one and is used here for databaseing and so I have listed it in the function reference.

These functions perform useful tasks related to built-in features of the PHP programming language and do not have a specific entry in the sections that follow. They will probably crop up in many projects that you put together, either from components created by other people or from your own coded solutions.

The first two are system functions—eval and die.

eval("$my_var = "a string");
echo $my_var;

if (not_logged_in($user)) {
   die ("Error : $user not logged in.");
}

$today_date = getdate();
echo "The month is $today_date['month'].";

function variable_argument_function () {
  $num_args = func_num_args();
  echo ("I was passed $num_args arguments.");
}
variable_argument_function ("banana", 1, 7);

I was passed 3 arguments.

for ($index = 0; index < func_num_args(); index ++) {
   $arg = func_get_arg(index);
}

$arglist = func_get_args();
foreach ($arglist as $arg) {
  // process $arg
}

This section discusses a useful collection of functions that can be used with numbers. Unless otherwise noted, both integers and floating point number can be used as arguments.

Both the min and max functions accept two arguments and return one of them by value.

The abs function takes an argument and strips it of any negative sign, and is the equivalent to multiplying a negative number by –1.

The sqrt function takes an integer or floating point number and returns its square root in the same data type as was supplied:

echo sqrt(9); // prints 3
echo sqrt(9.0); // prints 3.0

Previously, you had seen casting from floats to integers and learned that the system always rounds them down. However, there are also some specific functions for otherwise rounding and converting fractions to integers:

The key difference between the ceil, floor, and round functions is that the floating point argument supplied is usually rounded according to the standard that any value equal to or greater than 0.5 is rounded up. However, ceil would force 0.49 to be rounded up, and floor would force 0.51 to be rounded down:

$val_low = 9.51;
$val_hi = 9.49;
echo floor($val_low); // prints 9
echo ceil($val_hi); // prints 10
echo round($val_hi); // prints 9

The fmod function returns the remainder of a division. This is calculated as the value left over after the division has taken place, given that the division is expected to yield an integer (whole number) and a remainder. This is much easier to appreciate with an example:

$x = 5.7;
$y = 1.3;
$r = fmod ($x, $y); // remainder after x/y

In this example, $r will contain 0.5. The division of 5.7 by 1.3 yields 4.38. . ., which is rounded to 4. Next, 4 is multiplied by 1.3 to see what the result would be. This results in 5.2, which makes the remainder 0.5 (5.7–5.2).

There are also two functions for generating random numbers:

The mt_srand function accepts a value to seed the generator with, but can be called without a parameter to generate its own seed. Once seeded, the mt_rand function can be called, with two parameters, indicating the minimum and maximum integers between which the value should be. So, to generate a random number between 1 and 100, you use this:

$echo mt_rand(1, 100);

Finally, the math library contains a whole collection of trigonometric functions. I’ll not explain what each one relates to here, because those using them will know what they are for and this is not the place for a mathematical discussion of trigonometry.

The following functions are useful in manipulating classes and variables that have been defined by the users in their PHP programs.

The first such function, class_exists, tests to see whether a given class has been defined. It is equivalent to the core function_exists function, except that it accepts a class and not a function name.

The get_object_vars function takes an object, being an instance of an existing class, and returns an array of key/value pairs representing the name of each property of that object and their associated value, if set. For example:

class weblog_entry {
  var $title, $content;

function weblog_entry () {
    $title = "";
    $content = "";
   }

function weblog_set_title ( $t ){
   $this->title = $t;
  }
}

From the previous code, you can instantiate a variable from the class definition and set the title as follows:

$entry = new weblog_entry();
$entry->weblog_set_title ("A Title");
$properties < get_object_vars ($entry);

The $properties variable now contains an array that has the following entries:

$properties['title']
$properties['content']

In case you need to see what the array contains and what the indexes are, you can use the var_dump function. This provides a human friendly dump of any complex type or PHP expression. It is used as follows:

var_dump ($properties);

The previous code will yield a display along the lines of:

Array
(
    [title] => A Title
    [content] =>
)

An even more useful function is the var_export function, which performs an export of the data in PHP format. This means that you could use the resulting strung to recreate the object. This can be used as follows:

$code = var_export ($properties, TRUE);
                          // return, don't print out
$code = "$my_array = " . $code; // prepend some more code
eval ($code); // run it by PHP

The result of the previous snippet will be that $my_array contains a copy of the structure and data from the $properties variable, itself derived from the weblog_entry class. The important point to note is that it is a snapshot of the actual content and can be recreated from the string that is returned through var_export by passing it to eval.

The following is a guide to the various functions that you can use to process strings. Only the most commonly used ones are detailed here. The most common, and the one that you have already seen in several occasions, is the echo function.

This function outputs a string, either with escaping and variable expansion (if double quoted) or without (if single quoted). Strings can be concatenated in the input stream, which might not be included in parentheses.

Valid examples are as follows:

echo "This is a string
";
echo 'this is a string
';
echo "this is " . " two strings";

To find out the length of a string, use the strlen function. It returns an integer indicating the number of characters in the string. A companion function, count_chars, returns more detailed information about a specific character occurrence.

The count_chars function takes a string as input and produces an array where each byte (character) that is in the string is the key, and the value is the number of times that that character appears in the string. The function also takes a second parameter, which modifies the result returned. The most useful values for this parameter are as follows:

The following is a possible use for this function:

foreach (count_chars ("Hello World", 1)
                       as $letter => $freq) {
  echo $letter . " => " . $freq . "
";
}

This code would yield output similar to the following:

32 => 1
72 => 1
87 => 1
100 => 1
101 => 1
108 => 3
111 => 2
114 => 1

To convert the $letter values to characters that can be displayed, you can use the chr function, which takes an ASCII value in decimal format and returns the printable equivalent.

The explode function takes a string and breaks it up into an array of strings, based on the provided separator. So, the following would break a sentence into words:

$sentence = "the cat sat on the mat";
$word_array = explode (" ", $sentence);

The explode function could also be used to parse a CSV string:

$csv_row = "value, value, value";
$csv_array = explode (",", $csv_row);

The opposite of explode is implode, which takes the same arguments and returns a string as an array of separated values. So, to turn an array of values into a CSV string, you could use:

$csv_string = implode (",", $csv_array);

It is also possible to extract part of a string, if you know the start and length by using the substr function. This returns a value corresponding to the section of the string that has been indicated. For example:

$my_string = "Hello World";
echo substr($my_string, 4, 3); // prints o W

The final parameter is the length of string to extract, not the end index, and is optional; if it is missing, the whole string past the start point is taken. The start point is zero-based.

str_pad ($input_string, $length, $pad_string, PAD_TYPE)

$big_string = "Hello World";
$substring = "orl";
echo strpos ($big_string, "H"); // prints 0
echo strrpos ($big_string, "o"); // prints 7
echo strstr ($big_string, $substring); // prints orld
echo strpos ($big_string, $substring); // prints 7

echo substr_count ($big_string, "lo"); // prints 1

$search_for = "World";
$replace_with = "PHP";
$input = "Hello World";
$result = str_replace ( $search_for,
           $replace_with, $input_string );

$search_for = array ("Hello", "World");
$replace_with = ("Greetings", "PHP");
$input = "Hello World";
$result = str_replace ( $search_for, $replace_with,
                        $input_string );

// Outputs: apearpearle pear
$letters = array('a', 'p'),
$fruit = array('apple', 'pear'),
$text = 'a p';
$output = str_replace($letters, $fruit, $text);
echo $output;

Although the basic array handling built into PHP that you have already seen is great for the majority of functions, there are some occasions when a little more power is needed. Luckily, PHP provides a whole suite of built-in functions to support complex array tasks.

There are many more than are strictly needed in a “Just Enough” programmer’s arsenal, but the following summarizes the most useful ones.

To find out how many items there are in an array, the count function is used. It can also be used to count the properties of an object instantiated as a variable based on a user-defined class. It generally takes one parameter and returns an integer, although there is the possibility to specify what mode to use when counting items.

Refer to the PHP documentation if you need more advanced control over the count mechanism.

An array can also be sorted, using the sort function. Sorting is performed in an alphabetical manner, which provides consistent results so long as the types of values in the array are not mixed. One caveat is that the array keys will be reassigned and not reordered, so if there is a logical mapping between the keys and values, this will be lost, because the array is sorted on the values.

To check for the existence of a value in an array, you can use the in_array function. Theparametersforthis,inorder,arethevalue to look for and the array to look in. This parameter ordering is different from that of some of the other search functions.

Another thing to watch out for is that it is case-sensitive and can be made type-sensitive by adding a third parameter, set to TRUE. This last parameter is not used often. The search is always case-sensitive. An example of the in_array function is as follows:

$my_array = array ("Top", "Middle", "Bottom");
if (in_array ("Middle", $my_array) {
  echo "Found the value!";
}

Note that the function returns a Boolean value. The companion function, which is used in the same way but which looks for a key in the array rather than a value, is the array_key_exists function. Aside from the fact that it looks at the key, the functionality is identical.

To obtain the key from an array that corresponds to a value (rather than just a true or false), you can use the array_search function. If a simple array is populated, rather than a key/value array, the index is returned. For example:

$my_array = array ("Top", "Middle", "Bottom");
if (in_array ("Middle", $my_array) {
  $index = array_search ("Middle", $my_array); // index = 1
}

You can use the array_merge function to merge a list of arrays, based on some simple rules. Generally, the second array is appended to the first array. If the indexes are numerical (simple arrays), no values are overwritten. However, if the indexes are user-defined (key/value pairs), any value in the first array having the same key as a value in the second array is overwritten. For example:

$array_1 = array (1, 2);
$array_2 = array ("one" => 1, "two" => 2);
$array_3 = array ("two" => 3, "one" => 4, 5);
$temp_array = array_merge ($array_1, $array_2);
print_r ($temp_array);

This yields the result:

Array
(
    [0] => 1
    [1] => 2
    [one] => 1
    [two] => 2
)

However, if you then merge in $array_3, as follows:

$temp_array = array_merge ($temp_array, $array_3);
print_r ($temp_array);

The final output is as follows:

Array
(
    [0] => 1
    [1] => 2
    [one] => 4
    [two] => 3
    [2] => 5
)

Note how the index continues, even when interlaced with other keys. PHP is not fussy about the kind of data or keys used to access it, so it is possible to iterate through a whole array of different types, using various keys to access the data.

A sub-array can be extracted from an array using the array_slice function. This has many wonderful options, which you can look up if you need them. The most useful form is as follows:

array_slice ($input_array, $position, $length)

When used with correct parameters, this form returns an array that represents a sub-array starting at the zero-indexed position $position and is of $length length. The original array is untouched.

The companion function, array_splice, accepts the same parameters, returns an array that represents the items to be extracted, and removes them from the array. If you need to provide a replacement set of values, you can indicate this in an optional fourth parameter. Otherwise, the parameter list is the same as the array_slice definition.

There is also a set of functions for adding and removing individual elements to and from an array. These are as follows:

The array_push and array_shift functions take the array to operate on and a value to add to it as parameters. The array_pop and array_unshift functions generally only take the array to operate on. Otherwise, the functionality is as expected from the descriptions.

The array_rand function returns the key for a random entry into the array. To shuffle contents at random, you can use the shuffle function. Both functions take the array variable as input parameter.

Finally, the array_diff function compares two arrays and returns an array that contains the difference. This has no effect on the contents of the two arrays passed as parameters. Multiple occurrences of the value are considered to be equal and the keys are ignored, so two identical values with different keys are considered to be the same and are not returned.

Before you learn about document-related functions, there are a few functions used to process URLs in a standard way that you should consider. The first is parse_url, which returns an array from an URL, where each element refers to one of the components in a standard URL. This only works for complete, fully specified URLs and will not work with relative URLs.

Thus, the following can be written:

$url_components = parse_url
     ("http://www.mysite.com/query.php?op=1");

The $url_components array will contain:

[scheme] => http.
[host] => www.mysite.com
[path] => /query.php
[query] => op=1

From here, the query would have to be split into another array using the explode function with the & as separator. Each string in the resulting array could also be exploded by passing the = as separator to yield the value pairs. It is easier to use the $_GET superglobal, however.

The urlencode and urldecode functions simulate passing data on the URL in the same way that form processing does. In other words, spaces are replaced by + signs, and other non-alphanumeric characters are replaced by encoded versions. Such an encoded string can then be decoded using the urldecode function.

$xml = simplexml_load_file
            ('http://leckyt.wordpress.com/feed/'),

SimpleXMLElement Object
(
  [@attributes] => Array
  (
    [version] => 2.0
 )
  [channel] => SimpleXMLElement Object
  (
     [title] => Leckyt's Weblog
     [link] => http://leckyt.wordpress.com
     [description] => Just another WordPress.com weblog
     [pubDate] => Sun, 03 Feb 2008 13:57:02 +0000
     [generator] => http://wordpress.org/?v=MU
     [language] => en
     [item] => Array
     (
        [0] => SimpleXMLElement Object
             (
                 [title] => That tricky second post

$entry_title = $xml->channel->item[0]->title;

foreach ($xml->channel>item as $entry) {
  echo "<b> $entry->title </b><br/7gt;";
}

$xml = new DOMDocument();

$xml->loadFile('http://leckyt.wordpress.com/feed/'),

<div id="my_post">
</div>

$taglist = $xml->getElementsByTagName('item'),
                  // get all the items

$taglist->length();

$entry = $taglist->item(0);

$item_list = $xml->getElementsByTagName('item'), // pick the items
$entry = $item_list->item(0); // select the first one
// find the entry that contains the title and print its value
$title = $entry->getElementsByTagName('title')->item(0)->nodeValue;

mail ($to, $subject, $message, $headers)

$message = "Dear $user,
 Here is a test.

                        
Thanks,
Admin

";

$headers = 'MIME-Version: 1.0' . "
";
$headers .= 'Content-type: text/html; charset=iso-8859-1' . "
";

There are many more functions than covered here. For example, the administrative functions have all been left out because the average readers are not going to be administrators of the database that they are connecting to.

The following is the bare minimum needed to get up and running with a MySQL installation, and more than enough to cope with all the examples that are used in this book. MySQL itself is dealt with in Chapter 7, “Web Databases.”

The first function used is one of the most complex, and it establishes a connection to a MySQL database system. It takes the following form:

$link = mysql_connect ($server, $username, $password);

The $server will be the name of the server that has been given by the Web host. Usually a value of localhost will work, or the IP address of the host in question. Your $username and $password are set when the individual database is set up—this is covered in Chapter 7.

To choose a database upon which to perform SQL queries, use mysql_select_db. It uses the $link passed back from the connection function. The general form for this is as follows:

mysql_select_db ($db_name, $link)

Assuming that the database name ($db_name) is correct, the return value from this function will be true. If it is false, there has been an error. The exact nature of an error on a MySQL function call can be determined using the mysql_error function, which returns a string containing the error details. For example:

mysql_select_db ($db_name, $link) or die mysql_error();

This example will print a simple error message if the selection of the database did not succeed. More detail would be user friendly, but this code will stop the processing and inform the users that an error has occurred.

The mysql_query function is used to execute any kind of SQL query on the database. Its general form is as follows:

$result = mysql_query ($query, $link)

The $link parameter is the same $link that was provided when the database was first opened. If only one connection has been made to the database, this can be omitted. If the query was a SELECT query (see Chapter 7), the results can be extracted one at a time from the result set using the mysql_result function. This has the general form:

$value = mysql_result ($result, $row_number , $field_number)

The $value that is returned is the cell that is referenced in the result set. If there was only one field selected, the $field_number parameter can be omitted.

If the query had an effect on the database (data was inserted, deleted, or modified, for example), you can use a separate function to determine how many rows were updated. The mysql_affected_rows function returns an integer representing this. It has the general form:

mysql_affected_rows ()

The function operates on the last query, regardless of how many links are open to the database. To find out how many rows were returned in a result set that is the result of a select style query, you use the mysql_num_rows function. Its general form is:

$num_rows = mysql_num_rows ($result)

Unlike mysql_affected_rows, mysql_num_rows is tied to a specific result set. Several result sets can be held in memory at one time, with different variables providing the link to the result set on the server.

A much better way to retrieve the results is to use the mysql_fetch_assoc function, which returns an array that contains all of the results in the next row of the result set. The general form is as follows:

$array = mysql_fetch_assoc ($result)

Each element can be accessed through the array by field name. Each time the function is executed, the internal row pointer moves one row through the result set. It can be reset or set to a specific index using the mysql_data_seek function:

mysql_data_seek ( $result, $index )

Finally, to close the database link and free up any pending resources, you use the mysql_close function. It has this general form:

mysql_close ($link)

It is good practice to do this when no more operations are foreseen on the database, but because establishing the link can take some time, it should not be done until the script has no more need for the database.