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

lect02b-php-types
ch02: php types

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

Running your php programs:
1. First run them on the server, using php from the command-line: php myfile.php. If you have syntax error, it will give you a line-number
  (as opposed to running via php.radford.edu, which will just quit w/o any output).
2. Start your file with the following:
  <?php ini_set('display_errors', 'stderr'); ini_set('display_startup_errors', true); error_reporting(E_ALL|E_STRICT); ?>
  Be aware though:
  - Of course, you want to put these right near the start of your file. It doesn't do good to turn on error-reporting on line 20, if you first have an error on line 10!
  - Calling ini_set has no effect on the current php process — it will only effect any files you include. (But that's enough reason to do it.)
  - For php 5.4, E_ALL already subsumes E_STRICT. However
```
php.radford.edu
```
    is running php 5.3.

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.
- min and max will often save you an if-else.
- 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 (or “string-literal”) 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.
Note that unlike many languages, string-literals can contain contain newlines:

                       <?php
                       echo "hello
                                 there
                                     everybody!";
                       echo '
                             -- Dr. Nick
                        
                       ';
                       ?>

Rule of thumb: Use double-quoted strings most of the time, in your program.
We'll see their differences; experience suggests that double-quoted strings are more convenient for most purposes, in php.
If using double-quotes, the and you want to include a double-quote in your string-literal, precede that character with a backslash \". You can also embed special characters like newlines by using \n, so 'hi\nbye' is a six-character string, not seven. This is what you might be used to from most other programming languages.
If using single-quotes, the and you want to include a single-quote in your string-literal, precede that character with a backslash \', sensibly enough.
However, note that no other characters can be quoted: 'hi\nbye' and hi\"bye" are both seven-character strings, not six!
Just to keep things odd: double-quoted literals allow most standard quoted characters except for \' so "hi\'bye" is a seven-character string, not six!
No matter what type of string you're using, don't try to quote the other type of quote-marks.
Furthermore: If a string-literals delimited with double-quotes contains variables (a dollar-sign), then the variable gets replaced with its value!
Extrapolation occurs (only) within double-quoted strings, not single-quoted. 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.
                  …
                  }

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 ) );

                 function sumLengths( $data ) {
                    foreach($arr AS $x) {
                       $lenSoFar += strlen($x);
                       }
                    return $lenSoFar;
                 }

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.
While we're on related topic: Variable Type Coercion in PHP

¹ ↩

² 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 operators isn't the true purpose of precedence rules — they're so that you can let the other operators have a convenient, easy-to-read, easy-to-write syntax that doesn't get in the way of what you're trying to write. ↩

⁴ 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
D2L—breeze (snow day)

©2012, Ian Barland, Radford University
Last modified 2012.Sep.09 (Sun) Please mail any suggestions
(incl. typos, broken links)
to ibarlandradford.edu

lect02b-php-types ch02: php types

lect02b-php-types
ch02: php types