php-ch02
ch02: php types

From PHP Visual Quickstart Guide by Larry Ullman
Originally based on notes by Jack Davis (jcdavis@radford.edu)

Values, in php
- The types of values, in php boolean, integer, float, string, array, object, resource, NULL
- However, php converts types freely as needed (often converting from/to strings); we'll revisit that below.
Variables, in php
- All variable names must be preceded by a dollar sign ($).
- You don't declare variables in php ¹; you create a variable simply by initializing it: $myAge = 23;
- If you use a variable that hasn't been initialized (whether intentional or not), that variable is created and has the value NULL.
  By default, using an uninitialized/undeclared variable is not an error!
  (This is unfortunate, since it means misspelling a variable-name turns into a hard-to-track bug.) We'll see later how to configure php (or a web server using php) to emit a warning when using uninitialized variables; you want to always have that as a default.
- PHP is a dynamically typed language (as is Javascript); a variable can hold any type (not restricted to one a single type, as variables in Java are).
- Variable names are case sensitive.
- By convention, almost all php programmers use lower case variable names, reserving uppercase names for files, resources, and constants.
Numbers
- floats (actually doubles) and integers
- valid number literals
  12.2, 44, -1, -1.2
- use:
  $count = 22; and $ctr = 13.3; …
Numeric Operators (functions invoked w/o parentheses): +, -, *, / (always floating-point division, not quotient).
PHP supports assignment operators.
+=, -=, *=, /=, ++, --.
E.g. $total += 44; Note that unlike the numeric operators, the left-hand-side must of course be a variable (not any ol' numeric-expression), just like in other languages ²
Precedence. Like other languages, PHP has a precedence order for operators. But to avoid problems with precedence in calculations, fully ³ parenthesize expressions (just like you should in other languages).
Some numeric functions:
- round(4.35) == 4 round(4.289,2) == 4.29 $num = 236.26985; round ($num) == 236
- ceil rounds to the next higher integer: ceil(44.3) == returns 45.
  floor rounds to the next lower integer: floor(44.9) == 44.
  Note that floor differs from truncation on negative numbers: floor(-3.5) == -4.
- The php manual lists many more math functions that can be used; we've just reviewed some of the frequently used ones.

Strings

A string is any number of characters enclosed within a pair of either single (') or double (") quotation marks. Strings can contain any combination of letters, numbers, symbols, and spaces.
Double-quoted strings can also contain variables. Extrapolation occurs (only) within double-quoted strings. This is feature of php, to make string-generation easy.
Note: I suggest using double-quotes for most php strings, by default. For HTML, we'll tend to use single-quotes

String examples:

                     $str = "How are you?";
                     $first_name = "John";
                     $str = "How are you " . $first_name . "?";
                     $str = "How are you $first_name?";  // alternately
                     $date = "1/01/2010";  // this is a string!
                     $str2 = "I said, \"how are you?\"";

Simple example
php-ch02-simple.php

Booleans: the two values true, false (case-insensitive), and standard operators !, && (boolean-and), and || (boolean-or).

Caution: There are also the boolean operators with spelled-out names, AND and OR. Do not use them! They are just like &&, || except that they have unexpectedly low precedence (less than the assignment operators ⁴ Use parentheses to force precedence if you are doing something unusual (or even, just use them routinely so you never even need to think twice about precedence!).

A note on implicit boolean conversions:

In a boolean context, most values (like 17 and 'hello') are “true-ish”.

However, the following get interpreted as false:

false (duh)
0
0.0
'' (okay)
'0' (!!)
array() (an empty array) (!!)

Some examples:

                if (!$fname) {
                  // We reach here if $fname was undefined *or* the empty string.
                  echo "No first name provided.";
                  …
                  }

Similarly,

                $dbConnection = mysql-connect('localhost', 'some-sql-user-name', 'some-sql-password');
                if ($dbConnection) {
                  // we reach here only if $dbConnection is a valid connection object.
                  …
                  }

Warning: However, the boolean operators always return a boolean, even if their inputs were only boolean-ish.

                $dbConnection = mysql-connect('localhost', 'some-sql-user-name', 'some-sql-password') || die('could not connect');
                if ($dbConnection) {
                  // Uh-oh!  $dbConnection is true, and never a connection-object.
                  …
                  }

This tends to be different than other languages that allow true-ish and false-ish interpretations (there, && and || tend to return the first false-ish or true-ish value, resp.).

While we're on the topic: Variable Type Coercion in PHP

Arrays

index array

                   $arr = array("john","mary","zimbo");
                   echo "index 1 contains ", $arr[1], "\n";  // "mary"

                   $arr[] = "betty";    // Insert at the *next* location.
                   echo "index 3 contains ", $arr[3], "\n";  // "betty"

                   $arr[23] = "justine";
                   echo "index 17 contains ", $arr[17], "\n";  // NULL
                   echo "index 23 contains ", $arr[23], "\n";  // "justine"

                   $arr[] = "rachel";   // Wait, what counts as the *next* location now?  24, not 4 (!).
                   echo "index  4 contains ", $arr[ 4], "\n";  // NULL
                   echo "index 24 contains ", $arr[24], "\n";  // "rachel"

associative array

                   $crsarr = array("web"=>325, "java1"=>120);

                   echo 'index "web" contains ', $crsarr['web'], "\n";  // 325

                   $crsarr["discretemath"] = 122;
                   echo 'index "discretemath" contains ', $crsarr['discretemath'], "\n";  // 122

                   // The array("john","mary","zimbo") is the same as:
                   $arr = array(0 => "john",  1 => "mary",  2 => "zimbo");

Printing arrays: When debug-printing, use print_r; put that inside a pre tag if your output is html.

                   print_r( $crsarr );
                   
                   print_r( array(20, 21, "howdy" => "bye", "aloha" => "sayonara", 2 => 22 ) );

Constants
define ("pi", 3.1415926535);
The name of the constant is always quoted, but the value you assign to the constant is only quoted if it is a string literal. When you use a constant name, you don't precede it with a $.
define ("PI",3.14152926535); echo "The constant PI holds ", PI, "<br/>\n";
PHP Predefined Variables ($_SERVER array)
php-ch02-predefined-vars.php
Formatting Numbers
- number_format(428.4959,2) == '428.50' number_format(428,2) == '428.00' number_format(123456789) == '123,456,789'
  number-format can use two other optional arguments to indicate symbols for decimal points and break thousands
  can also use sprintf and printf to format data as a string.

Intermingling php and raw-output

We previously saw

 1  <?php
 2  
 3  // A flag to turn the test-cases on/off.
 4  define('RUN_TESTS',false);
 5  
 6  
 7  /** Return a blend of two words:
 8   * @param $word1 The word to take the first half from.
 9   * @param $word2The word to take the first half from.
10   * @return the first half of $word1 concatenated to the second half of $word2.
11   *   (If a word is odd length, we round the halfway-point down.)
12   */
13  function blend( $word1, $word2 ) {
14    $fHalf = substr($word1, 0, strlen($word1)/2 );
15    $lHalf = substr( $word2, strlen($word2)/2 );
16    return $fHalf . $lHalf;
17  }
18  
19  
20  /** Check whether the actual and expected values are the same.
21   * If not, print an error message.
22   * @param $actual  The actual result of the function-call.
23   * @param $expected  The expected (desired) result of the function-call.
24   */
25  function test($actual,$expected) {
26    if ($actual === $expected) {
27      echo ".";
28    }
29    else {
30      echo "Expected \"", $expected, "\",\n";
31      echo "but got  \"", $actual,   "\".\n";
32    }
33  }
34  
35  
36  if (RUN_TESTS) {
37    test( blend("a", ""),          "" );
38    test( blend("", "a"),          "a" );
39    test( blend("", "abc"),        "bc" );
40    test( blend("abc", ""),        "a" );
41    test( blend("", ""),           "" );
42    test( blend("a", "1"),         "1" );
43    test( blend("ab", "12"),       "a2" );
44    test( blend("motor", "hotel"), "motel" );
45    test( blend("smoke", "fog"),   "smog" );
46    test( blend("Ian", "Barland"), "Iland" );
47    }
48  
49  
50  // Produce a valid web page:
51  
52  echo "<html>";
53  echo "  <head><title>Rawr</title></head>";
54  echo "  <body>";
55  echo "    Hi Ian Barland -- I shall call you ", blend("Ian","Barland"), "\n";
56  echo "    (How do you like that?)";
57  echo "  </body>";
58  echo "</html>";
59  ?>

However, with php's raison d'etre of making text-processing (and html-generation) easy, we can actually have things not between php processing-instrctions <?php … ?$gt;; this is treated as literal output:

 1  <html>
 2  <head>
 3    <title>Rawr</title>
 4  <?php
 5  
 6  // A flag to turn the test-cases on/off.
 7  define('RUN_TESTS',false);
 8  
 9  
10  /** Return a blend of two words:
11   * @param $word1 The word to take the first half from.
12   * @param $word2The word to take the first half from.
13   * @return the first half of $word1 concatenated to the second half of $word2.
14   *   (If a word is odd length, we round the halfway-point down.)
15   */
16  function blend( $word1, $word2 ) {
17    $fHalf = substr($word1, 0, strlen($word1)/2 );
18    $lHalf = substr( $word2, strlen($word2)/2 );
19    return $fHalf . $lHalf;
20  }
21  
22  
23  /** Check whether the actual and expected values are the same.
24   * If not, print an error message.
25   * @param $actual  The actual result of the function-call.
26   * @param $expected  The expected (desired) result of the function-call.
27   */
28  function test($actual,$expected) {
29    if ($actual === $expected) {
30      echo ".";
31    }
32    else {
33      echo "Expected \"", $expected, "\",\n";
34      echo "but got  \"", $actual,   "\".\n";
35    }
36  }
37  
38  
39  if (RUN_TESTS) {
40    test( blend("a", ""),          "" );
41    test( blend("", "a"),          "a" );
42    test( blend("", "abc"),        "bc" );
43    test( blend("abc", ""),        "a" );
44    test( blend("", ""),           "" );
45    test( blend("a", "1"),         "1" );
46    test( blend("ab", "12"),       "a2" );
47    test( blend("motor", "hotel"), "motel" );
48    test( blend("smoke", "fog"),   "smog" );
49    test( blend("Ian", "Barland"), "Iland" );
50    }
51  ?>
52  </head>
53  
54  
55  <body>
56  Hi Ian Barland -- I shall call you <?php echo blend("Ian","Barland") ?>.
57  (How do you like that?)";
58  </body>
59  
60  </html>

¹ ↩

² Well, “just like in other Algol-based syntaxes.” ↩

³ Well, “reasonably fully parenthesize” — the precedence rules are designed to make operators like function call, array-lookup, field-lookup etc. work as expected. Precedence between arithmetic is not really the purpose. ↩

⁴ So $x = false || true; is find; it means So $x = (false || true);, and $x gets the value true. But $x = false OR true; means ($x = false) OR true;, which means $x gets false but the entire line returns true if used in some bigger context. (Btw, using the result of assignment in a bigger context is rarely a good idea; it's a holdover from more primitive I/O libraries that didn't have any peek/hasNext functionality.)
Bottom line: use && and ||, and use parentheses if you need some unusual precedence. ↩

home—lects—exams—hws
breeze (snow day)

©2011, Ian Barland, Radford University
Last modified 2011.Sep.07 (Wed) Please mail any suggestions
(incl. typos, broken links)
to ibarlandradford.edu

php-ch02 ch02: php types

Intermingling php and raw-output

php-ch02
ch02: php types