PHP Building Blocks for Programs

Information: Adding | Updating | Retrieving | Removing | PHP and MySQL

Chapter 7 PHP Building Blocks for Programs - Page 143-185

143 An introduction to Chapter 7 - PHP Building Blocks for Programs
144 Using Simple Statements

145 Using echo statements
148 Using assignment statements
149 Using increment statements
150 Using exit
150 Using function calls

151 Using PHP Arrays
- 151 Creating arrays
- 152 Viewing arrays
- 154 Removing values from arrays
- 154 Sorting arrays
- 156 Getting values from arrays
- 158 Walking through an array
  - 158 Manually walking through an array
  - 159 Using foreach to walk through an array
- 160 Multidimensional arrays
163 Useful Conditional Statements
- 164 Using if statements
- 167 Using switch statements
168 Using Loops
- 169 Using for loops
- 170 Using while loops
- 172 Using do..while loops
- 174 Infinite loops
- 176 Breaking out of a loop
178 Using Functions
- 180 Using variables in functions
- 181 Passing values between a function and the main program
  - 181 Passing values to a function
  - 184 Getting a value from a function
- 185 Using built-in functions

143 Introduction for Chapter 7 PHP Building Blocks for Programs
- The Hello.php program is an example of a simple program.
- However if you want a dynamic web page that can interact with the user or the database,
  - you need a more complex program.
- Complex programs may consists of:
  - arrays
  - conditions for branching, using the if or case statement
  - code that is executed over and over again until some condition is met, by using loops
  - blocks of code that can be reused many times are considered functions

144 Using Simple Statements

a simple statement is a single instruction followed by a semicolon(;). Here are some useful simple statements used in PHP programs.
- echo statement: Produces HTML output to browsers
- assignment sttm: assigns values to variables
- increment sttm: increases or decreases numbers in variables
- exit sttm: stops the execution of a program
- Function call: uses stored blocks of statements as reusable code

145 Using echo statements

Produces HTML output to browsers
The general format for the echo sttm is echo outputitem, outputitem, outputitem, ...
the following rules apply
- an outputitem can be a number, a string, or a variable
- a string must be enclosed in single or double quotes
  - using single quotes, variable names are echoed as-is
  - using double quotes, variable names are replaced by their values
- list as many outputitems as needed sepated by commas
146 you can separate variable names with curly braces { }
- consider the following sttms
  - $pet = "bird";
  - echo "The $petcage has arrived.";
- This will not output bird as the $pet variable
  - The output will not be The birdcage has arrived.
  - PHP would look for a variable named $petcage which does not exist.
- You can echo correctly by using the curly braces to separate the $pet variable
  - $pet = "bird";
  - echo "The {$pet}cage has arrived.";
- The ouput would look like this
  - The birdcage has arrived.
- You would have to verify that the HTML code displays this correctly from the echo sttm.
To use PHP to to display a web page, consider the following three stages to do that:
- The PHP program: PHP echo sttms that you write
- The HTML source code: the HTML source code you see when you view the source code from the browser which is the output from the echo sttm
- The Web page: the web page that the users see, which results from the HTML souce code.
The echo sttm sends the HTML code to the browser.
- If you do not include the HTML code in the echo sttm, it will not send the HTML code to the browser.
PHP allows some special characters that format the out for the source code, not what users see in a browser.
- If you want to start a new line in the source code, use \n
- If you want a tabed space, use \t
here are some examples to show the differnce from the Web Page display and the Source Code

**Stages of Web Page Delivery Page** 147
echo Statement	HTML Source Code	Web Page Display
echo "Hello World!";	Hello World!	Hello World!
echo "Hello World!"; echo "Here I am!";	Hello World! Here I am!	Hello World!Here I am!
echo "Hello World!\n"; echo "Here I am!";	Hello World! Here I am!	Hello World!Here I am!
echo "Hello World!"; echo "<br>"; echo "Here I am!";	Hello World!<br> Here I am!	Hello World! Here I am!
echo "Hello"; echo " World!<br>\n"; echo "Here I am!";	Hello World!<br> Here I am!	Hello World! Here I am!

The table above summarizes the differences between the stages in creating a Web page with PHP.
Consider the following two echo statements:
- echo "Line 1";
- echo "Line 2";
You might expect a Web Page to display
- Line 1
- Line 2
However the Web Page would display this
- Line 1Line 2
Since you did not echo a space between Line 1 and Line 2, you didn't get one.
If you wanted Line 2 on a separate line, you have to send a signal to indicate that.
- For the source code to display Line 2on a new line you need \n included in the echo sttm
- echo "Line 1\n";
- echo "Line 2 ";
This works for the source code. To get this in the browser you need the following
- echo "Line 1<br>";
- echo "Line 2 ";
If you want the two lines separate in both the source and the web page you need this
- echo "Line 1<br>\n";
- echo "Line 2 ";

148 Using assignment statements
- Assignment sttms has the variable name to the left of the equal sign and the value on the right of the equal sign. Here is the general format.
  - $variablename = value;
- The value can be a single value or a combination of values, including values in variables.
  - a variable can hold numbers or characters, but not both at the same time.
  - if you combine numbers or characters in a value, you will not get an error message, you will get unexpected results.
    - If you add a number and a string, the string may be evaluated as a zero.
    - If you try to concatenate string and a number, the number may be evaluated as a string.

149 Using increment statements

Often a variable is used as a counter. This program shows the use of a counter. (test01)
- The output is 1
Because counters are used so often, PHP provides shortcuts, look: (test01)
This demonstrates how you can subtract 1 from a counter,
- the counter is set at 7, and when complete should display 6 (test01)
Here are some other shortcuts:

**Other Shortcuts** Page 150
PHP Statements	Description
$counter+=2;	add 2 to the counter
$counter-=3;	subtract 3 from the counter
$counter*=2;	multiply the counter by 2
$counter/=3;	divide counter by 3

These same shortcuts are demonstrated here: (test01)

150 Using exit
- Sometimes you want to stop the program if it encounters an error.
  - Use the following format: exit("message");
  - Here's an example: exit("The program is exiting"); (test01)
- You can also stop the program with a die statement as follows:
  - die("The program is dying");
- The die and exit do the exact same thing.
150 Using function calls
- Functions are blocks of statements that perform a specific task. Think of them as mini programs.
- The block of statements is stored under the finction name.
- You can execute or "call" them by their function name, any time you want, in any place of the main program.
  - the format for calling or executing a function is as follows:
  - funtionname();
- You might have a function that gets all customer names from any state in the union
  - In this example we will get all customer names that live in California.
  - call it like this: get_name('CA');
  - the value in the parentheses is given to the function so it knows what state we are specifying.
    - this is known as the "passing the value" or an "argument".
  - You can pass more than one value or argument.
- PHP provides many built in functions, such as date or unset.
  - To uncreate a variable named $testvar use this function
  - unset($testvar);

151 Using PHP Arrays

Arrays are complex variables.
- An array stores groups of values under a single variable name.
- Information in an arry can be handled, accessed, and modified easily.
- PHP has several methods for sorting an array.
151 Creating arrays
- The simplest way to create an array is to assign a value to a variable with square brackets( [ ] ) at the end of its name.
  - Assuming you haven't referenced $pets earlier in the program, the following sttm creates an array called $pets :
    - $pets[1] = "dragon";
  - at this point an array named $pets has been created and only has one value: dragon
  - Next you use the following statement to add two more pets:
    - $pets[2] = "unicorn";
    - $pets[3] = "tiger";
  - Now the array $pets has three values: dragon, unicorn, and tiger.
- An array can be viewed as a list of key/value pairs.
  - to get a particular value, you specify the key in the brackets.
  - In the preceding array, the keys are numbers - 1, 2, and 3.
  - However you can also use words for keys.
    - The following uses state abreviations for the keys to state capitals:
    - $capitals['CA'] = "Sacramento";
    - $capitals['TX'] = "Austin";
    - $capitals['OR'] = "Salem";
- You can use a shortcut rather than write separate assignment sttm for each number, one shortcut uses the following sttms
  - $pets[] = "dragon";
  - $pets[] = "unicorn";
  - $pets[] = "tiger";
- When you create an array using this shortcut, the values are automatically assigned keys that are serial numbers, starting with the number 0.
- for example echo pets[0]; outputs dragon. (test02)
- Another shortcut to fill an array
  - $bucket = array( "one", "two", "three" );
  - test02 displays the first bucket, it should display one (test02)
- The same shortcut method using the capital of states example (test02)
  - $capitals = array( "CA" => "Sacramento", "TX" => "Austin", "OR" => "Salem" );
152 Viewing arrays
- You echo an array value like this: echo $capitals['TX'];
- if you include an array value in a longer echo sttm enclosed by double quotes, you may need to enclose the array value name in curly braces like this:
  - echo "The capital of Texas is {$capitals['TX']}<br>"; (test03)
- test3 demonstrates the use of print_r and var_dump (test03)
  - print_r output shows the key and the value for each element of the array
  - var_dump output shows the data type, as well as the keys and values
  - if you do not want to see the output in one long line, but would rather see the output in a more structured format, echo the pre tag before and after the commands. (test03)
154 Removing values from arrays (test04)
- you can replace a value of an element of an array with an empty string by doing the following
  - $pets[4] = "";
- you can remove the element of an array by doing the following
  - unset ($pets[4]);
- you can skip replacing the element with an empty string and just remove it.
  - to proove that place the # sign in front of line 20 of test04 to change that line to a comment
    - #$pets[4] = "";
  - run the program to proove that you can still remove the element from the array without setting it to a blank string
- when you are done remove the # character so you can do it again later (test04)

154 Sorting arrays

php arrays are originally stored in the order you create them.
- if you display the array after its created, you will see that is the way its sorted. (test05)
to sort an array that has numbers as keys use the following
- sort($pets);
- note that the keys are reassigned to reflect the new order (test05)
- the values are sorted by numbers, than uppercase letters, than lowercase letters
if you sort an array that has words for keys, the keys will be changed to numbers, and the word keys gets thrown away.
- to sort keys that have words for keys use the asort sttm (test06)
- notice the keys traveled with the values
you can use an asort command on keys containing numbers, but it is unlikely that you would ever do that
- the keys would stay with their values, but again, it is unlikely that you would ever want to do that

**Other Sort Commands** Page 156
Sort Statement	What It Does
sort($arrayname)	Sorts by value, assigns new numbers as keys
asort($arrayname)	Sorts by value, keeps the same key
rsort($arrayname)	Sorts by value in reverse order, assigns new numbers as keys
arsort($arrayname)	Sorts by value in reverse order, keeps the same key
ksort($arrayname)	Sorts by key
krsort($arrayname)	Sorts by key in reverse order
usort($arrayname, functionname)	Sorts by a function (see Using Functions, later in this chapter

156 Getting values from arrays
- Retrieving individual values from an array by accessing it directly
  - You can retrieve any individual value from an array by accessing it directly
    - $CAcapital = $capitals['CA'];
    - echo $CAcapital;
  - If you tried to retrieve an array element that did not exist: (test07)
    - $CAcapital = $capitals['CAx'];
  - you will receive a notice something like this:
    - Notice: Undefined index: CAx in f:\testarray.php on line 9
    - You need error_reporting(E_ALL); or you may not see the notice.
  - Notices do not cause the script to stop executing.
    - note that in test07.php the label $CAcapitalwas printed under the notice
      - instead of to the right of accessing a key that does not exist
  - You can prevent the notice from being displayed by using the @ symbol in front of the sttm like this:
    - @$CAcapital = $capitals['CAx']; (test07)
- Using the list sttm (test08)
  - the list sttm gets values from an array and puts them into variables
  - the line list($firstvalue,$secondvalue) = $shirtInfo;
    - is equevalent to
    - $firstvalue=$shirtInfo[0];
    - $secondvalue=$shirtInfo[1];
  - the third value of the array is not copied into a variable because the list command included only two variables, not three
  - The output from test08.php is
    - blue
    - large
- You can retrieve all the values from an array with words as keys using the extract sttm
  - Each value is copied into a variable named for the key
  - at the end of test08.php I created a second array using words for the keys (test08)
    - $shirtInfo2 = array( 'size' => "large", 'color' => "blue", 'cost' => 12.00 );
  - the output is:
    - size is large; color is blue; cost is 12
    - later format the 12 to 12.00

158 Walking through an array

Walking thru each and every value in an array is known as iteration or traversing.
- There are two ways to traverse an array
  - manually - move a pointer from one value to another
  - using foreach - automatically walking thru each value of the array

158 Manually walking through an array

you manually traverse an array by moving it's pointer
- you can move the pointer forward or backward, or move it to the first or last value of the array
you can use the following php sttms to move the pointer

**PHP Commands to move the Pointer** Page 158
PHP Commands	Description
current($arrayname)	refers to the value currently under the pointer, does not move the pointer
next($arrayname)	moves the pointer to the value after the current value
prev($arrayname)	moves the pointer to the value before the current pointer location
end($arrayname)	moves the pointer to the last value in the array
reset($arrayname)	moves the pointer to the first value in the array

( test09.php ) walks thru the array manually, then it goes to the top, then the bottom (test09)
( test09.php ) -- The book uses previous as the php command, it is really prev as displayed in the table above

159 Using foreach to walk through an array
- the foreach command walks through the array one value at a time
- the foreach command automatically starts at the beginning of the array
  - there is no need to use the reset command
- the current key and value of the array can be used in the block of sttms each time the block executes
- the general format is as follows
  - ```
  foreach( $arrayname as $keyname => $valuename
  {
      block of statements;
  }
```
- arrayname: the name of the array that you are walking through.
- keyname: the name of the variable where you want to store the key, keyname is optional
  - it you leave out $keyname =>, only the value is put into a variable that can be used in the block of statements.
- valuename: the name of the variable where you store the value.
- an example of using the foreach command to echo a list of the cities and states: (test10)
- an example of using the foreach command to echo a list of the cities: (test10)
  - this example leaves out the $keyname =>, it only uses the value in the block of statements

160 Multidimensional arrays (test11)

161 the following is an example of a multidimensional array

$productPrices['clothing']['shirt'] = 20.00;
$productPrices['clothing']['pants'] = 22.50;
$productPrices['linens']['blanket'] = 25.00;
$productPrices['linens']['bedspread'] = 50.00;
$productPrices['furniture']['lamp'] = 44.00;
$productPrices['furniture']['rug'] = 75.00;
Note how the products can be classified into groups, clothing, linens, and furniture.

$productPrices as an array of arrays
$productPrices	key	value
		key	value
	clothing	shirt	20.00
		pants	22.50
	linens	blanket	25.00
		bedspread	50.00
	furniture	lamp	44.00
		rug	75.00

161 the $productPrices has three key/value pairs
- the keys are clothing, linens, and furniture
- the value for each key is an array with two key/value pairs
  - the value for the key clothing is an array with two key/value pairs:
    - shirt/20.00 and pants/22.50
- $productPrices is a two-dimension array
161 Grabbing values from a multidimensional array
- You can get values from a multi-dimensional array by using the same procedures that you use with a one-dimensional array.
- You can access a value directly with the following statement
  - $shirtprice = $productPrices['clothing']['shirt']; (test11)
- You can also echo the value:
  - echo 'rug: '.$productPrices['furniture']['rug']."<br><br>"; (test11)
- However, if you combine the value within double quotes
  - meaning trying something like this:
  - echo "The price of a shirt is \${$productPrices['clothing']['shirt']}"; (test11)
- you need to use the curly braces to enclose the variable name
  - the $ that begins the variable name must follow the { immediately, without a space, as follows
  - echo "The price of a shirt is \${$productPrices['clothing']['shirt']}";
  - I highlighted the ${ in red above.
- Notice the backslash (\) in front of the first dollar sign ($).
  - The backslash tells PHP that $ is a literal dollar sign and not the beginning of a variable name.
- The output is as follows:
  - The price of a shirt is $20 (test11)

162 You can walk thru a multidimensional array by using foreach sttms.
- You need a foreach sttm for each array in the multidimensional array
- One foreach sttm is inside the other foreach sttm.
  - Placing foreach sttms inside of other foreach sttms is called nesting.
- Because a two-dimension array, such as $productPrices, contains two arrays,
  - it takes two foreach sttms to walk through it
- The following sttms get the values from the multidimensional array and output them in an HTML table
- echo "<table border=1>";
  foreach( $productPrices as $category )
  {
       foreach( $category as $product => $price )
       {
           $f_price = sprintf("%01.2f", $price);
           echo "<tr><td>$product:</td>
                     <td>\$$f_price</td></tr>";
       }
  }
  echo "</table>";
- The following is the output you get from the multidimensional array and the PHP sttms above.
- shirt: $20.00
  pants: $22.50
  blanket: $25.00
  bedspread: $50.00
  lamp: $44.00
  rug: $75.00
The following is the PHP commands that created the multidimensional array named $productPrices
- $productPrices['clothing']['shirt'] = 20.00;
  $productPrices['clothing']['pants'] = 22.50;
  $productPrices['linens']['blanket'] = 25.00;
  $productPrices['linens']['bedspread'] = 50.00;
  $productPrices['furniture']['lamp'] = 44.00;
  $productPrices['furniture']['rug'] = 75.00;
163 Here is how the table is created:
1. echo "<table border=1>";
  - Outputs the table tag
2. foreach( $productPrices as $category )
  - Gets the first key/value pair in the $productPrices array and stores the value in the variable $category.
  - The value is the array of product and price.
3. foreach( $category as $product => $price )
  - Gets the first key/value pair in the$category array.
  - Stores the key in $product and stores the value in $price.
    - shirt/$20.00
    - the key is shirt and the value is 20.00
4. $f_price = sprintf("%01.2f", $price);
  - Formats the value in $price into the correct format for money.
5. echo "<tr><td>$product:</td>
  <td>\$$f_price</td></tr>";
  - Echoes one table row for the product and its price.
6. foreach( $category as $product => $price )
  - Goes to the next key/value pair in the $category array.
  - pants/$22.50
7. $f_price = sprintf("%01.2f", $price);
  echo "<tr><td>$product:</td>
  <td>\$$f_price</td></tr>";
  - Formats the price and echoes the next table row for the product and its price.
8. Because there are no more key/value pairs in $category, the inner foreach sttm ends.
  - This means that there are no more products and prices in the clothing category.
9. Goes to the next key/value pair in the outer foreach sttatement
  - Puts the next value in the $category, which is an array.
  - The next key/value pair is blanket/$25.00
  - That is the linens category.
10. Repeats the procedure in Steps 2-9 until the last key/value pair in the last $category array is reached.
  - The last key/value is rug/$75.00 which is in the furniture category.
  - The inner foreach statement ends.
  - The outer foreach statement ends.
11. echo "</table>";
  - Outputs the </table> tag to end the table.
163 In other words ..
- This is a good paragraph that also explains how the program works.

163 Useful Conditional Statements
- 164 Using if statements (test12)
  - Format for the if sttm
  - if (condition ...)
    {
       block of statements;
    }
    elseif (condition ...)
    {
       block of statements;
    }
    else
    {
       block of statements;
    }
- 167 Using switch statements (test12)
  - Format for the switch sttm
  - switch ( $variablename )
    {
       case value :
          block of statements;
          break;
       case value :
          block of statements;
          break;
       ...
       default :
          block of statements;
          break;
    }
  - use the break sttm to conclude the case sttm
  - the default sttm does not require a break sttm
168 Using Loops (test13)
- loops are used to repeat a block of code, either a certain amount of times or until a condition is met.
- 169 Using for loops
  - for loops are based on a counter
    - You set the beginning value for the counter
    - the ending value for the counter
    - and the incremented value for the counter
  - the general format for the for loop is as follows
    - for(startingvalue;endingcondition,increment)
      {
      block of statements;
      }
    - startingvalue -- a sttm that sets up a variable to be the counter and sets it to your starting value
      - examples: $i=1; or (2 + 2); or a $variable;
    - endingcondition -- a statement that sets the ending value
      - as long as this condition is true, the loop continues
      - when this statement is nolonger true, the loop ends
      - examples: $i<1; or $i<$variable;
    - increment -- a sttm that increments the counter
      - examples: $i++; or $i+=1; or $i--;
    - a simple loop, runs three times and displays its counter and the words Hello World! (test13)
  - using the sizeof command
    - The sizeof command determines how many values are in an array.
    - You can use the sizeof command in the endingcondition of the for loop
    - here's an example (test13)
- 170 Using while loops
  - a while loop continues repeating as long as certain conditions are true.
    - You set up the condition
    - the condition is tested at the top of each loop
      - this means, before the block of sttms are executed
      - the condition is tested
    - If the condition is true, the loop repeats.
      - If the condition is not true, the loop will stop
  - The format for the while loop is as follows:
    - while ( condition )
      {
      block of statements;
      }
  - a condition is any expression that can be evaluated as either true or false
    - examples of conditions:
      - $test <= 10
      - $test1 == $test2
      - $a == "yes" and $b != "no"
  - using the while loop command
    - here's an example: (test13)
    - note how the while loop continues until the condition $i < 10 is no longer true
  - there is another example on page 171
  - be careful that you do not write a condition that never becomes false, known as an infinate loop.
    - You can learn how to deal with that later in this outline Page 174.
- 172 Using do..while loops
  - a do ... while loop continues repeating as long as certain conditions are true.
    - You set up the condition
    - the condition is tested at the bottom of the loop
      - this means, after the block of sttms are executed
      - the condition is tested
      - this also means that the block of sttms are always executed at least once
    - If the condition is true, the loop repeats.
      - If the condition is not true, the loop will stop
    - The format for the while loop is as follows:
      - do
        {
        block of statements;
        } while ( condition );
    - a condition is any expression that can be evaluated as either true or false
    - using the do ... while loop command
      - here's an example: (test13)
    - there is another example on page 173
- 174 Infinite loops
  - You can accidently set up a loop to run forever
  - several ways of doing this is described on pages 174 to 176
    - you could set a counter to zero or one inside the loop
      - if the tested condition expects a higher number, that will never happen and the loop continues to run
    - another common mistake is to set the condition with one equal sign instead of two
      - example while ( $switch = "yes" ) should be while ( $switch == "yes" )
      - the book says write the condition as while ( "yes" == $switch )
      - if you use one equal sign instead of two, PHP will give you an error before it runs the program
    - leaving out a sttm like $i++ could also cause an infinite loop
  - while testing your program, if you realize you have an infinite loop, just click the Stop button on your browser.
  - PHP will only run an infinite loop for 30 seconds, unless the system administrator changed the timing for that
- 176 Breaking out of a loop
  - PHP offers two ways to break out of a loop, using the break or continue sttms
    - break - breaks completely out of the loop and continues with the program sttms after the loop
    - continue - skips to the end of the loop where the condition is tested, if the condition tests positive, the program continues from the top of the loop
  - the break or continue sttms are usually used in a conditional sttm
  - 176 this program demonstrates the two samples on page 176 and 177 (test14)
    - The loops are built the same, excep one uses break and the other continue
    - The first loop ends at the break sttm.
      - It stops looping and jumps immediately to the sttm after the loop.
    - The second loop does not end at the continue sttm.
      - It just stops the third repeat of the loop and jumps back to the top of the loop.
      - It then finishes the loop, with the fourth and fifth repeats, before it goes to the sttm after the loop.
  - 177 Another use for the break sttm is to insure against an infinite loop
    - The following demoes this, there is a loop, we know it should never exceed running 100 times, but just in case, we will stop it at the 100th go around with a break sttm. (test14)
178 Using Functions
- 178 Using Functions
  - Applications often perform the same tasks at different points in the program or in different programs.
    - If all your pages have the same header, logo, sidebar navigation, (the same look and feel)
    - Create a function that places all that HTML code into an external file that you can include.
    - Name the function something like this: display_logo();
      - the parentheses after the function name are required to tell PHP that this is a function.
  - Using a function offers several advantages:
    - Less typing: You only type the code once and call the function everytime you need it.
    - Easier to read: The line display_logo(); is easy to understand at a glance.
    - Fewer errors: After fixing errors and testing the function, it works correctly every place you put it.
    - Easier to change: If you need to a change in the function, you only have to make the change once for it to work in all places the function is used.
  - 179 You can create a function by putting the code into a function block.
    - The general format for a function is as follows:
    - function functionname()
      {
      block of statements;
      return;
      }
    - example of a display_logo() function (test15)
    - explanation of how I got this function to work compared to what is in the book on page 179
      - first I created a folder named images and placed it in the ch07 folder
      - next I searched my computer for a logo and decided to use the mslogo.jpg image for Windows XP
        
        I copied that image to the new images folder.
      - I had to play with the hr and img tags to get it to work properly for the Firefox browser.
    - below is the code for my demo function:
    - function display_logo()
      {
         echo "<hr width='255' align='left' />","\n";
         echo "<img src='images/mslogo.jpg' width='255' height='40' />","\n";
         echo "<hr width='255' align='left' />","\n";
         return;
      }
    - of course I called it twice with the following sttm:
    - display_logo();
  - the return; sttm stops the function and returns to the main program
    - the return; sttm at the end of the function is not required, but makes it easier to understand
    - the return; sttm is often used for a conditional end to a function.
  - an example of using the return; sttm as a conditional end is as follows
    - what if you want to display a catalog to a person over the age of 17
    - if ( $age < 18 )
      return;
    - if the person is under 18 the function stops and the catalog is not displayed
  - You can place functions anywhere in the program, but the practice is to place the functions at the beginning or the end of the program file.
  - Functions that will be used in different programs or pages, should be stored in a separate file.
    - Each program access the functions from the external file.
    - See Chapter 10, Using Include Statements for organizing and accessing separate files.
  - Note the example I used is quite simple, it does not use variables, and does not share information with the main program.
    - You can use variables in functions and pass information between the function and the main program as long as you know the rules and limitations.
- 180 Using variables in functions
  - You can create a use variables that are local to the function.
    - Variables created inside the function are not available to the main program.
  - You can make variables available at any location in the program by using the global sttm
    - to make a variable that was created in a function available to the main program, use the global sttm like this:
    - global $name;
    - now the variable $name; is available to the main program and can be echoed as output.
      - see the examples on page 180
    - You can also make a variable global in the main program so it can be accessed in a function.
- 181 Passing values between a function and the main program
- 185 Using built-in functions
  - PHP has many built in functions
  - examples of built in functions already discussed are
    - number_format
    - unset
  - there are PHP built in functions that are useful with interacting with MySQL
  - functions are listed in the www.php.net/docs.php page
    - you can either type a function in the search for box,
    - or look at the documentation for functions. wish you luck on that score.

This site is for the private use of my students. (2008)

Top | PHP and MySQL

shirt:	$20.00
pants:	$22.50
blanket:	$25.00
bedspread:	$50.00
lamp:	$44.00
rug:	$75.00