Numbers and strings
Operators
We have already seen how to use functions, such as
sqrt, to manipulate values in PHP. For the most common
operations, though, PHP provides symbolic shortcuts for the operations,
such as
+ for adding two values together, or
*
for multiplying two values.
Such symbols are called
operators.
PHP includes about 30 operators, though we'll only cover the 10 or so
that appear frequently in programs. The most recognizable would be
+ for addition,
- for subtraction or negation,
* for multiplication, and
/ for division. We can use these to enhance our range
selection page so that it displays the midpoint in the range:
<p>From the range <?php echo $form_begin; ?>
to <?php echo $form_end; ?> I have selected the random number
<?php echo rand($form_begin, $form_end); ?>. The midpoint is <?php
$average = ($form_begin + $form_end) / 2;
echo $average;
?>.</p>
PHP observes the traditional order of operations: Negation comes
first, followed by division and multiplication in left-to-right order,
followed by addition and subtraction in left-to-right order. You can use
parentheses when you want to indicate a different order of operations;
in the above example, we had to use the parentheses; otherwise, PHP
would add
form_begin to half of
$form_end,
which wouldn't be the average of the two values.
There is another operator worth mentioning: The
remainder
operator, represented by the percent sign. When placed between
two numbers, the resulting value is whatever remainder results when the
first number is divided by the second number; for example,
28 % 9 would yield 1, since 9 goes into 28 three times with
a remainder of 1. The remainder operator lies at the same precedence
level as multiplication and division in PHP.
Note that one operator that is
not on the list: There is no
operator for exponentiation. People often expect the caret
('
^') to do this; PHP allows you to use a caret to operator on
two numbers, but what it does is fairly obscure and rarely very useful.
(You don't need to worry about it, but what it does is a
bitwise
exclusive or, where it
computes the number whose binary representation is 1 in each place where
the two numbers' binary representations are different.)
When you want to raise one number to another power, you can instead
use PHP's
pow function: The tenth power of 1.5, for
example, can be found with
pow(1.5, 10)
.
5.2. Types
As PHP processes a program, it works with a variety of categories of
information, each called a
type. Thus far, we have
glossed over the distinction, but it is an important one.
In fact, PHP works with two different types of numbers:
integers and
floating-point numbers.
Integers are numbers represented in a format that allow no fractional
parts (and allow numbers such as 0 or 2 or −158), whereas
floating-point numbers are represented in a format that allows fraction
parts (such as 3.14159 and 1.5). Whenever a number is written with a
decimal point, it is a floating-point number; thus, if you write
1.0, you're talking about the floating-point value 1,
which doesn't behave exactly the same as the integer value 1.
For those who have programmed in other languages based on C: PHP's
division operator always produces a floating-point result. (Most other
C-derived languages ape C's rules for dividing two integers, where the
remainder is ignored so the result is still an integer. In PHP, an
expression such as
1 / 2
actually yields 0.5 as a
beginner would expect.)
Most of the time you don't need to worry about the distinction
between floating-point numbers and integers; PHP freely converts
integers to floating-point numbers when necessary. One situation where
it can appear is with rounding problems, such as with the following
statement.
echo 10000000000000000 - 9999999999999999;
This statement outputs 0 on some computers, because those computers
can't store integers so big, and so PHP uses floats instead... and it
happens that they are both approximated with the same float.
If there's some reason you want to convert between the two, you can
use PHP's
intval and
floatval functions.
5.3. Strings
PHP includes many other types for values that aren't numbers. One of
the most important such is the
string, which is a value
representing a sequence of several characters, such as a word, a
sentence, or a nonsensical stream of punctuation.
To refer to a particular string value, you can use a set of quotation
marks enclosing the characters you want to include in the string. The
following statement makes the variable
$sentence refer to
a famed novel's opening sentence.
$name = "It was the best of times; it was the worst of times.";
When you enclose a string in quotation marks, the
contents of the quotation marks are not interpreted by PHP: It simply
places the raw characters into the string. Suppose I type:
$expr = "rand(1, 100)";
PHP does not use the
rand function here: It simply
creates a string consisting of 12 characters, starting with the letter
r and ending with the close-parenthesis character. If we
omitted the quotation marks, of course PHP would call the
rand function to retrieve a random number between 1 and
100.
One exception (and the only exception) to this rule is variable
names: When you include a variable name in a string, PHP will substitute
the variable's value in place of the name. Suppose I write this:
echo "The range is $form_begin to $form_end. ";
echo "The midpoint is ($form_begin + $form_end) / 2. ";
echo "The chosen number is rand($form_begin, $form_end). ";
The PHP interpreter would substitute the values of the variables
whenever they occur; but it would not attempt to apply the operators or
call the functions. What we would see on the Web browser, then, is the
following.
The range is 10 to 20. The midpoint is (10 + 20) / 2. The chosen number is rand(10, 20).
Of course, that's probably not what we want. There are several ways
of getting around this. One is to first assign a variable to refer to
the desired value, and then to use that variable inside the string. But
another approach worth knowing about is the
catenation
operator '
.',
which you can use to join two values into a string. The following
is how we could modify our example.
echo "The range is $form_begin to $form_end. ";
echo "The midpoint is " . (($form_begin + $form_end) / 2) . ". ";
echo "The chosen number is " . rand($form_begin, $form_end) . ". ";
As an example, the final line says to catenate the string
The
chosen number is
with the value generated by
rand,
which itself should be catenated with the string
.
. Note the
space that has carefully been added inside the first string after
is: Without this, the output would omit the space, as in
The
chosen number is17.
.
The catenation operator has the same priority level as
addition and subtraction. As a result, the following would be
incorrect.
echo "The sum is " . $form_begin + $form_end; // WRONG!
PHP would first catenate
The sum is
with
$form_begin, resulting in a string such as
The sum is
20
. Then it would attempt to interpret this as a number so that it
could add
$form_end to it. It would not work as we would
expect. For this reason, I recommend developing the habit of using
parentheses whenever you try to combine other operators with catenation,
even when it is not necessary. The above midpoint example illustrates
this: Even though there the parentheses were unnecessary since
division occurs at a higher level than catenation, I went ahead and used
parentheses anyway.
We've seen that variable names in double quotation marks will be
replaced with the variable values. But that brings up a question: What
if you don't want this substitution to occur? There are two answers that
PHP provides. First, you can prefix the relevant dollar sign with a
backslash, as in
"\$choice is $choice"; in this example,
the first dollar sign won't be treated as part of a variable name, but
the second will, so the string will translate to something like
$choice is 17.
You can do the same backslash trick when
you want to a quotation mark to appear inside the string, or when you
want a backslash as part of the string.
Backslashes can also be used to insert other characters. Most
significantly, '
\n' inserts a
newline
character into a string. Since line breaks aren't automatically
inserted between
echo statement,
a PHP script that echoes a
large amount of information would normally create one large line, which
can be quite difficult to read for somebody who tries to read the
generated HTML source. (Of course, the browser ignores line breaks
anyway.) For this reason, I'd be inclined to instead write our earlier
example with three echo statements as the following instead.
echo "The range is $form_begin to $form_end.\n";
echo "The midpoint is " . (($form_begin + $form_end) / 2) . ".\n";
echo "The chosen number is " . rand($form_begin, $form_end) . ".\n";
Note the '
\n' that follows each period. This leads the
generated HTML to include three separate lines rather than one long
line. Again, the browser will display the HTML the same when we have
spaces instead of newlines, but a user who chooses to read the HTML
source will have an easier time with the newlines inserted.
(You can also use '
\t' to specify a tab character,
but this is not as useful.)
Sometimes the number of backslashes can get a bit cumbersome, so PHP
provides another way, too: You can enclose the string in single
quotation marks. Variable substitution never occurs for a string
enclosed in single quotation marks. (I won't use this
single-quotation technique, but many PHP programmers use single quotes
as a matter of habit.)
