Variables

As a byproduct of examining the examples up to this point, I’ve introduced you to how variables are assigned and manipulated. However, it would be wise to explicitly
lay the groundwork as to how variables are declared and manipulated. The coming sections will examine these rules in detail.

Variable Declaration

A variable is a named memory location that contains data that may be manipulated throughout the execution of the program. A variable always begins with a dollar sign, $. The following are all valid variables:
$color
$operating_system
$_some_variable
$model
Variable names follow the same naming rules as those set for identifiers. That is, a variable name can begin with either an alphabetical letter or underscore and
can consist of alphabetical letters, underscores, integers, or other ASCII characters ranging from 127 through 255. Interestingly, variables do not have to be explicitly declared in PHP, much as is the case with the Perl language. Rather, variables can be declared and assigned values simultaneously. Furthermore, a variable’s data type is implicitly determined by examining the kind of data that the variable holds. Consider the following example:
$sentence = "This is a sentence."; // $sentence evaluates to string.
$price = 42.99; // $price evaluates to a floating-point
$weight = 185; // $weight evaluates to an integer.
You can declare variables anywhere in a PHP script. However, the location of the declaration greatly influences the realm in which a variable can be accessed. This access domain is known as its scope.

Variable Scope

Scope can be defined as the range of availability a variable has to the program in which it is declared. PHP variables can be one of four scope types:
• Local variables
• Function parameters
• Global variables
• Static variables

Identifiers

An identifier is a general term applied to variables, functions, and various other user-defined objects. There are several properties that PHP identifiers must abide by:
•An identifier can consist of one or more characters and must begin with an
alphabetical letter or an underscore. Furthermore, identifiers can only consist
of letters, numbers, underscore characters, and other ASCII characters
from 127 through 255. Consider a few examples:
VALID INVALID
my_function This&that
Size !counter
_someword 4ward
• Identifiers are case sensitive. Therefore, a variable named $recipe is different
from variables named $Recipe, $rEciPe, or $recipE.
• Identifiers can be any length. This is advantageous, as it enables a programmer
to accurately describe the identifier’s purpose via the identifier name.
• Finally, an identifier name can’t be identical to any of PHP’s predefined keywords.

Variables and Data Types (3)

Objects

The fifth PHP data type is the object. You can think of an object as a variable that is instantiated from a kind of template otherwise known as a class. The concept of objects and classes is integral to the notion of object-oriented programming (OOP). Contrary to the other data types contained in the PHP language, an object
must be explicitly declared. It is important to realize that an object is nothing more than a particular instance of a class, which acts as a template for creating objects having specific characteristics and functionality. Therefore, a class must be defined before an object can be declared. A general example of class declaration and subsequent object instantiation follows:
class appliance {
var power;
function set_power($on_off) {
$this->power = $on_off;
}
}
. . .
$blender = new appliance;
A class definition creates several characteristics and functions pertinent to a data structure, in this case a data structure named appliance. So far, the appliance isn’t very functional. There is only one characteristic: power. This characteristic can be modified by using the method set_power. Remember, however, that a class definition is a template and cannot itself be manipulated. Instead, objects are created based on this template. This is accomplished via the new keyword. Therefore, in the preceding listing an object of class appliance named blender is created. The blender power can then be set by making use of the method set_power:
$blender->set_power("on");, “Object-Oriented PHP,” introduces PHP’s OOP implementation in further
detail.

Boolean, or True/False, Values

The boolean data type is essentially capable of representing only two data types: true and false. Boolean values can be determined in two ways: as a comparison evaluation or from a variable value. Both are rather straightforward. Comparisons can take place in many forms. Evaluation typically takes place by use of a double equal sign and an if conditional. Here is an example:
if ($sum == 40) :
. . .
This could evaluate to only either true or false. Either $sum equals 40, or it does not. If $sum does equal 40, then the expression evaluates to true. Otherwise, the result is false. Boolean values can also be determined via explicitly setting a variable to a true or false value. Here is an example:
$flag = TRUE;
if ($flag == TRUE) :
print "The flag is true!";
else :
print "The flag is false!";
endif;
If the variable $flag has been set to true, then print the appropriate statement; Otherwise, print an alternative statement. An alternative way to represent true and false is by using the values 1 and 0, respectively. Therefore, the previous example can be restated as follows:
$flag = 1;
if ($flag == TRUE) :
print "The flag is true!";
else :
print "The flag is false !";
endif;
Yet another alternative way to represent the above example follows:
$flag = TRUE;
// this implicitly asks "if ($flag == TRUE)"
if ($flag) :
print "The flag is true!";
else :
print "The flag is false!";
endif;

Variables and Data Types (2)

Arrays

An array is a list of elements each having the same type. There are two types of arrays: those that are accessed in accordance with the index position in which the
element resides, and those that are associative in nature, accessed by a key value that bears some sort of association with its corresponding value. In practice, however,
both are manipulated in much the same way. Arrays can also be single dimensional or multidimensional in size.

Single-Dimension Indexed Arrays

Single-dimension indexed arrays are handled using an integer subscript to denote the position of the requested value. The general syntax of a single-dimension array is:
$name[index1];
A single-dimension array can be created as follows:
$meat[0] = "chicken";
$meat[1] = "steak";
$meat[2] = "turkey";
If you execute this command:
print $meat[1];
The following will be output to the browser:
steak
Alternatively, arrays may be created using PHP’s array() function. You can use this function to create the same $meat array as the one in the preceding example:
$meat = array("chicken", "steak", "turkey");
Executing the same print command yields the same results as in the previous example, again producing “steak”. You can also assign values to the end of the array simply by assigning values to an array variable using empty brackets. Therefore, another way to assign values
to the $meat array is as follows:
$meat[] = "chicken";
$meat[] = "steak";
$meat[] = "turkey";

Single-Dimension Associative Arrays

Associative arrays are particularly convenient when it makes more sense to map an array using words rather than integers. For example, assume that you wanted to keep track of all of the best food and wine pairings. It would be most convenient if you could simply assign the arrays using key-value pairings, for example, wine to dish. Use of an associative array to store this information would be the wise choice:
$pairings["zinfandel"] = "Broiled Veal Chops";
$pairings["merlot"] = "Baked Ham";
$pairings["sauvignon"] = "Prime Rib";
$pairings["sauternes"] = "Roasted Salmon";
Use of this associative array would greatly reduce the time and code required to display a particular value. Assume that you wanted to inform a reader of the best accompanying dish with merlot. A simple call to the pairings array would produce the necessary output:
print $pairings["merlot"]; // outputs the value "Baked Ham"
An alternative method in which to create an array is via PHP’s array() function:
$pairings = array(
zinfandel => "Broiled Veal Chops",
merlot => "Baked Ham",
sauvignon => "Prime Rib",
sauternes => "Roasted Salmon";
This assignment method bears no difference in functionality from the previous $pairings array, other than the format in which it was created.

Multidimensional Indexed Arrays

Multidimensional indexed arrays function much like their single-dimension counterparts, except that more than one index array is used to specify an element. There is no limit as to the dimension size, although it is unlikely that anything beyond three dimensions would be used in most applications. The general syntax of a multidimensional array is:
$name[index1] [index2]..[indexN];
An element of a two-dimensional indexed array could be referenced as follows:
$position = $chess_board[5][4];

Multidimensional Associative Arrays

Multidimensional associative arrays are also possible (and quite useful) in PHP. Assume you wanted to keep track of wine-food pairings, not only by wine type, but also by producer. You could do something similar to the following:
$pairings["Martinelli"] ["zinfandel"] = "Broiled Veal Chops";
$pairings["Beringer"] ["merlot"] = "Baked Ham";
$pairings["Jarvis"] ["sauvignon"] = "Prime Rib";
$pairings["Climens"] ["sauternes"] = "Roasted Salmon";

Mixing Indexed and Associative Array Indexes

It is also possible to mix indexed and associative arrays indexes. Expanding on the single-dimension associative array example, suppose you wanted to keep track of the first and second string players of the Ohio State Buckeyes football team. You could do something similar to the following:
$Buckeyes["quarterback"] [1] = "Bellisari";
$Buckeyes["quarterback"] [2] = "Moherman";
$Buckeyes["quarterback"] [3] = "Wiley";
PHP provides a vast assortment of functions for creating and manipulating arrays, so much so that the subject merits an entire chapter.

Variables and Data Types

Data types form the backbone of any programming language, providing the programmer with a means by which to represent various types of information. PHP provides support for six general data types:
• Integers
• Floating-point numbers
• Strings
• Arrays
• Objects
• Booleans
One of the pillars of any programming language is its support for numbers. PHP supports both integers and real (double) numbers. Each of these number formats is described in further detail later.

Integer Values

An integer is nothing more than a whole number. Integers are represented as a series of one or more digits. Some examples of integers are:
5
591
52
31

Octals and Hexadecimals

Integers in octal (base 8) and hexadecimal (base 16) formats are supported. Octal values begin with the digit 0, followed by a sequence of digits, each ranging from 0 to 7. Some examples of octal integers are:
0422
0534
Hexadecimal integers can consist of the digits 0 through 9 or the letters a (A) through f (F). All hexadecimal integers are preceded by 0x or 0X. Some examples of hexadecimal integers are:
0x3FF
0X22abc

Floating-Point Numbers

A floating-point number is essentially a real numbers, that is, a number denoted either wholly or in part by a fraction. Floating-point numbers are useful for representing values that call for a more accurate representation, such as temperature or monetary figures. PHP supports two floating-point formats: standard notation and scientific notation.

Standard Notation

Standard notation is a convenient representation typically used for real numbers, for example, monetary values. Some examples are:
12.45
98.6

Scientific Notation

Scientific notation is a more convenient representation for very large and very small numbers, such as interplanetary distances or atomic measurements. Some examples include:
3e8
5.9736e24
Chapter 2
32

String Values

A string is a group of characters that are represented as a single entity but can also be examined on a character-by-character basis. Some examples of strings are: thesaurus
49ers
abc
&%/$£
Note that PHP doesn’t include support for the char data type. Rather, the string data type can be considered the all-encompassing type that represents both single and multiple character sets.

String Assignments

Strings can be delimited in two ways, using either double quotation marks (“”) or single quotation marks (‘’). There are two fundamental differences between the two methods. First, variables in a double-quoted string will be replaced with their respective values, whereas the single-quoted strings will be interpreted exactly as is, even if variables are enclosed in the string. The following two string declarations produce the same result:
$food = "meatloaf";
$food = 'meatloaf';
However, the following two declarations result in two drastically different outcomes:
$sentence = "My favorite food is $food";
$sentence2 = 'My favorite food is $food';
The following string is what exactly will be assigned to $sentence. Notice how the variable $food is automatically interpreted:
My favorite food is meatloaf.
Whereas $sentence2 will be assigned the string as follows:
My favorite food is $food.
In contrast with $sentence, the uninterpreted variable $food will appear in the string assigned to $sentence2. These differing outcomes are due to the usage of double and single quotation marks in assigning the corresponding strings to $sentence and $sentence2. Before discussing the second fundamental difference between doublequoted and single-quoted strings, an introduction of PHP’s supported string delimiters is in order. As with most other mainstream languages, a set of delimiters is used to represent special characters, such as the tab or newline characters.