HTML and PHP Resources

Introduction to custom functions in PHP

Bladymir — Thu, 01 Mar 2012 14:55:31 +0000

Introduction

The PHP language has a few thousand functions built in and ready to use. Although several thousand functions exist it is entirely possible that the a function to accomplish something you are looking for may be too general for your purposes or not exist at all.

Although a large number of functions in PHP may take parameters and do operations on those parameters, functions are also a great way to group commonly used code in order to improve readability and maintainability of a program.

Defining a Function

To define a function we are required to use the keyword, function followed by the function’s name and parenthesis encasing any parameters separated by a comma and a block of code wrapped in curly brackets.

Function definition without parameters:

function printHello(){ echo 'Hello!'; }

Function definition with one parameter:

function sayHello($name){ echo 'Hello ', $name, '!'; }

Function Names

Functions can have just about any name as long as they begin with a letter or underscore, the first character can be followed by any letter/number/underscore combination.

Names that are PHP keywords or already existing functions should be avoided. Naming custom functions the same as existing functions will result in error and will keep your script from running.

PHP does not support function overloading or re declaring of functions. Be unique and descriptive when naming your functions.

(Function overloading is simply when you define multiple functions with the same name, differing only in the number of parameters. To set optional parameters in php, you can use default values when you declare your function (see next section.))

Function Parameters

When we declare our custom function we can define the number of parameters that our function can accept. The number of parameters can range from none to as many as you want, they only need to be separated by a comma.

// No Parameters
function hello0(){ /*code*/ }
// One Parameter
function hello1($par1){ /*code*/ }
// Two Parameter
function hello2($par1, $par2){ /*code*/ }
// Three Parameter
function hello3($par1, $par2, $par3){ /*code*/ }

The names that are given to our parameters will be the names we will use inside our function’s block of code.

function showName($name) {
echo $name;
}

In the example above, our only parameter was given the identifier of $name and that is what is used inside our function to use the passed parameters value.

It should be noted that is the parameter that was passes is changed inside the function, the original value will remain unchanged.

function changeName($name){
$name = 'James';
}

$user = 'Joe';
changeName($user);
echo $user; // Joe - still

It should be noted that php functions can have optional parameters (which addresses the issue of function overloading). We have the freedom of setting default values for our functions, these default values are used when no value is passed to our function. Consider the example below:

function printName($name = "No Name"){
echo $name;
}

$user = 'Joe';
printName($user);//echo's Joe
printName(); // echo's No Name

Note how the parameter has become optional, if we do not specify a parameter, then the default from our function declaration is used. One thing to keep in mind about optional parameters is that no required parameters must come after the optional parameters. That is, you have to make sure any optional parameters are specified after required parameters(parameters with no default specified).

Passing By Reference

In our previous example the value held by our $user variable remained unchanged, this is because the value of the parameter is copied when it is passed to a function. In order for our original variable to be accessible and changeable we need to pass it by reference. Passing by reference simply means that our identifier inside our function will refer to the exact location in memory for the value that is being passed, rather than create a copy of it to work with.

Since $name inside our function refers to the same exact place and value as $user any changes to $name will also apply to $user.

To pass by reference, we simply add a ampersand(&) symbol to our parameter when we declare our function.

function changeName(&$name){
$name = 'James';
}

$user = 'Joe';
changeName($user);
echo $user; // James - name changed!

Return Values

Lastly we arrive at return values. Return values are data that a function send back when it finished running, the functions we have created so far do not return data after execution. To return data we must use the return keyword, followed by the variable name or data we are trying to return. It should be noted that the return keyword marks the end of the function, no code after the return is executed (unless you wrap your return in conditionals.) Consider the example below:

function getName(){
$name = 'James';
return $name;
}

$user = getName();
echo $user; // James

We defined a function getName() which returns the value James. When we call the function the value is returned and we store the result in the variable $user, just as if it had been a string. Had we not returned the value from inside the function, the data would have ceased to exist after the function reached its end. We would not have had a value for our $user variable.

Note that you can return any type of data from a function, strings, integers, arrays, ect.

Summary

You should not be able to define your own custom functions, here we covered mostly the syntax and topics surrounding function, but when combined with your knowledge of other html topics it is a very powerful tool. Inside your functions body, you can do anything you can outside of a function and when it comes to reusing that particular block of code inside your function all you have to do is call your function!

If you have any questions, comments or suggestion feel free to leave a comment or contact me at php@htmlandphp.com.

Visit www.HTMLandPHP.com for more information!

Introduction to PHP Includes

Bladymir — Sat, 31 Dec 2011 14:54:33 +0000

Introduction

PHP includes refers to the four statements include, include_once, require, and require_once. These statements allow us to include PHP code written in other files in our current file and execute it as if it was part of our current one.

Example

Lets take a simple HTML page and make it more dynamic with PHP.

example_page.php



    
        
            <?php echo $title; ?> 
        
        
    
    
        
            
                
            
            
                Home |
                About Us |
                Contact Us
            
        
        
            Page1
            Hello World!
        
        
            
                Home |
                About Us |
                Contact Us

We can see that this page contains some reoccurring elements. We can take these reoccurring elements and put them in their own files and make it easier to reuse and maintain. For example if in the future you need to add a link to your pages you can edit a single file and the change will be reflected in all your pages, since they will all be pulling the same code from the same file.

Lets go ahead and split the code up into three files.

header.php


    
        
            <?php echo $title; ?> 
        
        
    
    
        
            
                
            
            
                Home |
                About Us |
                Contact Us

home.php


    Page1
    Hello World!

footer.php


            
                Home |
                About Us |
                Contact Us

Now that we have the code split up this way, we can reuse the code for our header and footer sections.

Including the Content

We have split the code up and now we are ready to use our methods, include, include_once, require and require_once.

These methods simply include the code of the specified location to our current file. for example, let create a new file, landing.php with the following code:

landing.php



        
            Welcome!
            Hola! Hello! Hallo! Salut!

If you take a look at the final rendering of the page, you will notice it is the same as the original. These functions allow us to include code from other sources.

Its also important to note that variables can be used across included files, as long as it has been declared before the line it is used on. In our example we declared the variable $title and used it in our header file.

Syntax

These statements can be used with or with out parenthesis.

include 'path/to/file.ext';

include('path/to/file.ext');

include_once 'path/to/file.ext';

include_once('path/to/file.ext');

require 'path/to/file.ext';

require('path/to/file.ext');

require_once 'path/to/file.ext'

require_once('path/to/file.ext');

The path provided can be absolute or relative to the current directory or the include path specified in php.ini.

Including vs Requiring

These two constructs do the same thing and are interchangeable for the most part. The real difference is in the way that they handle errors.

Include issues a notice and execution of the script continues if the path of the specified file is not found.

Require issues an error and execution of the script stop at that point.

Do it just once

The two constructs require_once and include_once also do the same as require and include although as the name suggest they only do it once.What I mean by this is that if you had written two include statements in your script at different point for inclusion of the same file, the file would be included twice and the code in that file would be executed twice.

With the require_once and include_once constructs the PHP parser ignores any subsequent request for inclusion from require_once and include_once.

It should be noted that any inclusion request using include and require will be fulfilled normally. Use the constructs require_once and include_once to include any files that define functions, classes or other code that you do not want to be re-declared or executed a second time.

Summary

The constructs discussed here are simply a way to include contents of another file into the current one. The contents of the included files will be executed and displayed as if they had been written in the file that including it. Variables declared before the inclusion can be used in the included file, and variables, functions and classes declared inside the included file can be used in the file that including it.

Visit www.HTMLandPHP.com for more information!

Introduction to Loops in PHP

Bladymir — Sat, 31 Dec 2011 00:00:48 +0000

Introduction

At the heard of the matter loops are a mechanism for executing instructions (code) multiple times.

Loops give us the ability to automate certain tasks that can be done in a number or repeatable steps.

Types of Loops

In PHP we have various types of loops and although at the core of it all they do the same thing, they go about doing it differently. Its important to note that certain things can be done with less effort in some loop structures while it may not be the case for other loop structures.

Notes on Loop Syntax

Loop syntax varies slightly for all loops, but the important thing to keep in mind is that the loops conduct a check before every iteration and expect a Boolean value during this check. This Boolean value tells the PHP interpreter whether it should continue to the rest of the code or continue executing the current block of code contained by the loop structure.

Loop structures have a block of code that is executed when the Boolean value is set to true. The block of code is defined between curly brackets ( { and } ), but if the curly brakets are omitted, then only the line following the loop declaration will be considered part of the loop’s block.

”while” and “do“.. “while” Loops

The while loop is the simplest in terms of syntax and has the widest range of uses. Declaring a while loop is as simple as using the keyword, while, followed by a boolean value or boolean expression wrapped in parenthesis followed by a block of code in curly brackets.

example_while.php:

\n";
    $x++;
}

Take note that the expression: $x < 10 , is a evaluated to a true or false, and the code between the curly brackets is executed only when this expression is true. Be aware that we can substitute any boolean expression in this place.

Warning: Setting forth an infinite(∞) loop is a possibility when the expression never evaluates to false, in which case the script would run the code in the loop until either the server kills the script or the server runs out of resources. This can be a problem in a shared hosting environment, where a web host may suspend your hosting for excessive use of resources.

The do…while loop is a variation of the while loop. The do…while loop guarantees that the block of code in the loop will be executed at least once. To use this type of loop, you use the keyword, do, followed by the block of code in curly brackets and the keyword while with a Boolean value or expression in parenthesis.

example_do_while.php:


Its important to note in this example the comparison is between a variable and a value of zero, the expression at the end will evaluate to false and the loop will stop there. However the code block was executed once because the comparison did not take place until after the block of code. This is a property unique to the do…while loop.
Note: The semi-colon after the while(..) is required, otherwise the code will yield errors.
Parts of a “for” loop
A for loop is a bit more complex than its while counter part, it contains a variable initialization, check condition, and a step.
This loop can be said to be a loop that keeps track of its own progress. A typical for loop is declared by using the keyword, for, followed by the three mentioned items wrapped in parenthesis and the block of code that will be executed.
example_for.php:
\n";
}

/*
 * Simple example 2, counting from 1 to 10
 */
for($num = 1; $num <= 10; $num++){
    echo $num, ',';
}

As you can see from our example, the variable $num is declared and set to a value of one when we declare our for loop. The second part of the parameter listing is the boolean check that dictates the number of iterations our loop will go through. The last parameter is the step that our loop is to take after executing the block of code, in this case our step adds one to the value of $num.
It should also be noted that the variable $num will be available outside the block of the for loop, it’s continues to exist after the loop.
The “foreach“ loop
The foreach loop is a special type of loop that is best used with iterateable items like arrays and objects. A foreach loop takes uses the keyword foreach and  as in the following manner.
example_foreach.php:
\n";
}

Note that each of the items in our array ($list) was referred to as $a_value inside the block of code.
The number of time the loop would execute is dependent on how many items are in the provided parameter.
If you have an associative array (or an object) you can also use the following syntax to retrieve the name of the key (or property) and the value.
example_foreach_key_value.php:
 'a',
                    'second' => 'b',
                    'third'  => 'c');

foreach($alphabet as $spot => $letter) {
    /* Each key and value combo will be referred to as 
     * $spot for the key name
     * $letter for the value of each key and value combination
     */
    echo 'The ', $spot ,' letter is ', $letter, ".
\n";
}

Take note how the => operator was used to indicate the name of the variable we used to reference the key and the name of the variable we used to reference the value of the current element.
The foreach loop is commonly used to deal with arrays when each value in the array needs to  be processed.
Comparison
Below we have an example of how the we can print the contents of an array to the screen using all the types of loops covered above.
example_loops_comparison.php:
';
$br = "\n";     // Line Break

$list = array(  'Monday',
                'Tuesday',
                'Wednesday',
                'Thursday',
                'Friday',
                'Saturday',
                'Sunday'    );

/*
 *  USING WHILE LOOP
 */
echo $br, "+WHILE OUTPUT------------------------------+", $br;

$count = 0;     // Array index begins at 0
while ($count < count($list)) {
    echo $list[$count] ,  $br;
    $count++;   // Move index to next one by adding 1
}

/*
 *  USING A DO WHILE LOOP
 */
echo $br, "+DO...WHILE OUTPUT------------------------------+", $br;

$count = 0;   // Reset our count
do {
    echo $list[$count] ,  $br;
    $count++;   // Move index to next one by adding 1
} while ($count < count($list));

/*
 *  USE A FOR LOOP
 */
echo $br, "+FOR OUTPUT------------------------------+", $br;

for ($count = 0; $count < count($list); $count++) {
    echo $list[$count] ,  $br;
}

/*
 *  USE A FOREACH LOOP
 */
echo $br, "+FOREACH OUTPUT------------------------------+", $br;

foreach ($list as $day) {
    echo $day,  $br;
}


echo $br, "print_r OUTPUT------------------------------+", $br;

print_r($list);
echo '
';
Breaking out
Loops check whether a condition has changed after every iteration, sometimes its necessary to exit a loop when a condition outside this primary condition is reached. The break keyword is used inside a loop to indicate that the loop should be exited.
example_loops_break.php:
\n";
// Numbers from 0 to 4 displayed
$count = 0;     
while ($count < 5) {
    echo $count, $br;
    $count++;   
}


// Numbers 0 displayed
$count = 0;
while ($count < 5) {
    echo $count, $br;
    $count++;   

    // Exit our loop
    break;
}

// Numbers from 0 to 3
$count = 0;
while ($count < 5) {
    echo $count, $br;
    $count++;   

    // Exit our loop when count reaches a value of 4
    if($count == 4)
        break;
}

In the example above we have a break statement inside our while loop that simply exits the loop as soon as the PHP parser reaches the line. We also have the break after an if-condition that allows us to specify when we should exit the loop.
Using the break keyword is simple, and it is typically used to exit loops in special cases specified by you with series of conditionals inside the loop. The example demonstrated this ability with the while loop, but it works in the same manner with the other types of loops.
Summary
In summary the loop structures in PHP are, while, do…while, for, and foreach. These loops have varying syntax’s and required parameters. At the root they all execute a block of code a number of times dictated by a given condition.  Note that they can be used interchangeably for the most part, but certain tasks are made easier by some loop structures.
Visit www.HTMLandPHP.com for more information!



PHP Functions that Help You Debug
Bladymir — Sat, 24 Dec 2011 03:29:30 +0000
Introduction
Writing code can be a daunting task filled with unexpected twist and turns even when we feel that we have everything planned out.
We will be covering some of the major functions in PHP that can be used for debugging our code, to track down unexpected execution and unexpected errors.  The functions we will focus on are:

echo()
print_r()
var_dump()
isset() 
empty()
exit() and die()

Printing Details to the Screen
PHP programming at its root is writing a set of instructions that are going to be parsed and executed. Although we may think that we know what is going to happen, we get unexpected results at times. To track down whats going wrong and where its going wrong we need to print extra statements to the screen so we can confirm that what we expect is happening is in actuality taking place.
Our old friend echo()
In a script that is giving us unexpected output, it is crucial that we trace our way through the script or through what we believe to be culprit, echo provides a basic means of doing so.
Using extra echoes into our scripts can help us confirm the existence of a variable and the value it holds.
For example, below we have taken a snippet of code and we have added echo statements at different points along the script with additional information for us comments. This helps us follow the logic of the script and the value of our selected variable at different points in the execution.
example_debug_echo.php :
Starting: '. $number .'
';  // Display our starting number
for($count = 2; $count <= 10; $count += 2)
{
    echo 'Before:'. $number . '
';       // Display number before operation
    $number *= $count;
    echo 'After:'. $number . '

';    // Display number after operation
}
echo 'Ending: '. $number;            // Display our final number

This is an exaggerated example, but in reality we may have to do something like this in our scripts in order to track down where an error has occurred. Although this is a basic approach to debugging it can be an effective one.
Printing Arrays, Object and Additional Information Printing
The functions var_dump() and print_r() are used exclusively for debugging purposes. These two functions are identical in function but differ in the output that they display.
The print_r() function displays a variables contents in a readable format. This does not mean much for variables holding primitive data type like strings, integers and floating points, as they are simply printed to the screen, but arrays and objects get formatted into a string representation before they are printed to the screen.
The function var_dump() formats the value of its parameters into a readable form and displays information about the variables data type in addition to its value.
Here’s and example to show how both functions display the variables information in a more readable format in the case of strings and arrays.
example_print_r_var_dump.php :
 'Joel', 'age' => '20');

// A String
echo "A string and print_r():\n";
print_r($aString);

echo "\n\nA string and var_dump():\n";
var_dump($aString);

// An Array
echo "\n\nAn array and print_r():\n";
print_r($anArray);

echo "\n\nAn array and var_dump():\n";
var_dump($anArray);

?>

Note that these functions are most useful when trying to debug arrays and objects. The visual structuring of the data makes it easier to read which arrays or properties are encased and by what names or keys they can be accessed. The var_dump() function is useful when confirming the type of data a variable holds, note in the example above, the ‘age‘ key of the ‘anArray’ variable holds a string of value 20, rather than an integer of value 20.
Is the Variable Ready
Next we have the functions isset() and empty(). These function simply establish whether a variable has been set or contains a value.
If you recall PHP is a loosely typed language and variables are allowed to contain any type of data. Variables do not need to be declared or instantiated before they are used, but in certain cases it is useful to know if a variable has been set or if it contains any value at all.
The isset() function tells us if a variable has been set by returning a boolean value of true or false.
In the following example we can see how we can check a variable to for whether or not it has been set.
example_isset.php :
';
else
    echo 'Variable 1 is not set!
';

/* 
 * We have not declared $var2 anywhere
 * Can you guess what the output will be?
 */
if(isset($var2))
    echo 'Variable 2 is set! 
';
else
    echo 'Variable 2 is not set!
';

The empty() function tells us if a variable is empty,
In this modified example we can see that a set variables is considered empty if it contains the boolean equivalent of false or if the variable has not been set.
example_empty.php :
';
else
    echo 'Variable 1 is not empty!
';

// Change the value to an empty string
$var1 = '';
if(empty($var1))
    echo 'Variable 1 is empty!(Contains an empty string) 
';
else
    echo 'Variable 1 is not empty!
';

/* 
 * We have not declared $var2 anywhere
 * Can you guess what the output will be?
 */
if(empty($var2))
    echo 'Variable 2 is empty! 
';
else
    echo 'Variable 2 is not empty!
';

Run it or Exit() or Die()
Lastly we have the constructs exit() and die(). These constructs terminate the script at the point they are used.
When using these constructs we can pass a string parameter that will be printed when the script exits.
example_exit_die.php :

Note that the last echo was not executed since the exit command was executed.
We can also use the or keyword as part of a statement with exit() and die() to determine if the script should continue. The left hand side of the or is interpreted as a boolean value, when the left hand side of the expression is false the right hand side gets executed.
example_or_exit_die.php :

The example above checks whether a variable is set and the proceeds or exits the script. It is a short hand version of the if statement in the previous example.
The exit and die statements can be used when debugging a script and we want to stop execution at a certain point. Note that they are interchangeable.
Summary
Tracking down unexpected outcomes in our scripts simplifies to finding where were we have defined incorrect logic or an incorrect order of steps. Printing the type and value of variables is helpful in order to correct any errors in our script.

Printing useful information at different steps in your script with echo.
Confirm the key and value pairs in arrays and properties of object by using the print_r and var_dump functions.
Check whether a variable has been instantiated by using isset.
See if a variable contains an empty value or has not been set by using empty.
Its important to note that isset is not the same as empty
Stop execution of a script when arriving at a certain condition by using exit and die.

These functions are key to debugging or narrowing down problems in PHP scripts, although they can also become part of your script in order to handle errors appropriately.
Comments, Questions or Concerns
If you have any comments, questions or concerns feel free to voice them on this site or contact us directly at php@htmlandphp.com
Visit www.HTMLandPHP.com for more information!


207: Introduction to arrays in PHP
Bladymir — Wed, 21 Dec 2011 15:45:36 +0000
Introduction
Arrays are a special data type in PHP that is used to hold a list of data. The ability to hold a list of data is valuable as it allows us to hold and pass sets of related data to different point in our application with ease.
Array Syntax
The simplest way to use arrays is it declare one using the array() function when declaring a variable.  There are a couple different ways to add data to an array, we can assign a value to the array with an empty index or by passing the values as parameters to the array() function.
When the array() function is used without any parameters an empty array is created.
$ourList = array();
Passing values as parameters creates a non empty array. Passing a value to the array with an empty index also pushes a value to the end of the array.

Note: In the case that the array has not been explicitly created, simply using array syntax and assigning it a value will create an array with the key(if any) and values provided.
Array Indices
Arrays hold data as list and  list held by the array needs to be access in order to be useful. If you use a function like var_dump() or print_r() you can see a visual representation of the array like below:



array(2) {



[0]=>



string(5) “Hello”



[1]=>



string(5) “World”



}



Our array consists of two string values with a length of five characters. The important thing to notice is the value in the square brackets, this is the index that is used to refer to that value.
To access a given item in an array we simply use the name of the variable that holds the array and then use the index of the item in square brackets.
\n"; // Displays: Leon
echo $names[1], "
\n"; // Displays: Ivan
echo $names[2], "
\n"; // Displays: John
echo $names[3], "
\n"; // Displays: Mohamed
echo $names[4], "
\n"; // Displays: Jose

# Visual representation of array.
var_dump($names);

By default array indices begin at zero and count to one minus the number of elements. So the array above has five elements and the indices range from zero to four.
Note: Indices can also be referred to as keys.
Specifying Indices(keys)
PHP automatically specifies the indices for arrays when none is specified. We can specify a different key starting point or do away with numerical numbering and use a string key names for our arrays indices.
To start numbering at a different value, we simply use the  “=>” operator when we specify our values. It should be noted that the parser will number any indices after that point in sequential order until a different index value is specified.
\n"; // Used for formatting

/**************************  EXAMPLE 1 ************************************/
// Specify the count to start at 1 rather than 0
$ourList = array(1 => 'Mercury', 'Venus');
echo $ourList[1], $br;     // Displays: Mercury
echo $ourList[2], $br;     // Displays: Venus


/**************************  EXAMPLE 2 ************************************/
// Specify the a different index for certain values
$ourList2 = array(1 => 'Mercury', 'Venus', 4 => 'Mars');    // 3 not defined!
echo $ourList2[1], $br;     // Displays: Mercury
echo $ourList2[2], $br;     // Displays: Venus
echo $ourList2[4], $br;     // Displays: Mars


/**************************  EXAMPLE 3 ************************************/
// Specify a string key
$ourList3 = array('home' => 'Earth',        // key: home     value: Earth
                  'largest' => 'Jupiter',   // key: largest  value: Jupiter
                  'center' => 'Sun',        // key: center   value: Sun
                  'Astroid Belt');          // key: 0        value: Astroid Belt

echo $ourList3['home'], $br;        // Displays: Earth
echo $ourList3['largest'], $br;     // Displays: Jupiter
echo $ourList3['center'], $br;      // Displays: Sun
echo $ourList3[0], $br;             // Displays: Astroid Belt

Note: PHP does not take white space into account when parsing code, for readability the example shows how we can set different keys and values on their own line. Arrays that contains string key names are refereed to as associative arrays
Arrays Inside Arrays
Arrays are nothing more than a list that holds other data types. Arrays can also be multi-dimensional, meaning that they can hold other arrays and those arrays can hold other arrays so on so forth. We can define arrays like the example below, or you can nest array() functions in one another.
 'Lea', 
                        'father' => 'Lucas'
                    );

$family['children'] = array(
                        'son' => 'Leo',
                        'daughter' => 'Lisa'
                    );

echo $family['adults']['father'], "
\n";      // Displays: Lea
echo $family['adults']['mother'], "
\n";      // Displays: Lucas
echo $family['children']['son'], "
\n";       // Displays: Leo
echo $family['children']['daughter'], "
\n";  // Displays: Lisa

print_r($family);   // Visual Representation of the array

Note: To access the data inside the inner array you specify a key of the array holding the inner array, then the key of the enclosed array.
$variableName['outer array key']['inner array key'];
Note: This pattern continues if more arrays are enclosed.
Array Related Error
While using arrays we may occasionally come across the following error.
Notice: Undefined offset: key in file.php on line 20
Depending on the PHP setting on the server, this may or may not display. In this example this is a PHP notice, which means the rest of our script will finish parsing and continue to be executed, in contrast if this was a fatal error our PHP script would stop executing all together.
All this notice means is we have not defined this particular key for our array. To fix this we need to specify the key the parser is trying to find at(or around) the line it specifies or remove this reference all together, depending on what our script is supposed to be doing.
Summary
Arrays are a special data type in PHP that can hold a list of data including other arrays.  Arrays have sequential numerical keys (indices), but you have the ability to specify string key names or an alternate starting number. Arrays are commonly used to group related data in order to make it simple to pass the data to different parts of an application.
Comments, Questions or Concerns
If you have any comments, questions or concerns feel free to voice them on this site or contact us directly at php@htmlandphp.com
Visit www.HTMLandPHP.com for more information!


206: Introduction to Switch Conditionals in PHP
Bladymir — Tue, 20 Dec 2011 06:24:43 +0000
Introduction
Switch is another language construct that is used to control program flow. The switch construct takes a single parameter and compares it for equality to a set of cases that have been specified.
Example Scenerio
Let’s take an take the classic case where we have seven days, represented by the numbers from zero to six.
We are going to pass a variable holding a number to our switch, the switch then looks for the case where the parameter it is passed is equal to a case. The parser then executes the code after the matching case. The parser continues to execute code until the end of the switch or a break statement is reached.
What is a “break”?
The break is used to tell the parser to break or stop executing the current block of code. A break statement is required to indicate the end of a block inside a switch, much like the curly brackets are used to indicate the start and end of a block after an if statement.
Implementing a Switch
One Input to One Block
The script below echoes the name of a day depending on the value of our variable $day. In this scenario, there is one output for a single input. 

Multiple Input to a Single Block
Inside a switch we are also able to have multiple possible input values with a single output. To do this you simply group a number of cases one after another and follow with an appropriate block of code. For example the script below tells you if the number is even or odd. 

The Undefined Case
If for any reason the value of the variable being compared did not have a case defined, no code inside the switch would execute since a case for that particular value is not defined. We have the option to define a default case that will be executed if the value of parameter being compared is not found. We define the default case with the default keyword in place of the case and the value.
In the example below we have grouped the values from zero to six so that they execute the code echoing, “Its a valid day from 0 to 6!”. If the parameter passed to the switch has any other value it will display the code defined after the default case.

Note about the “break”
The break tells the parser to stop executing the current block of code. If you happen to omit the break from your cases inside the switch, the parser will execute all of the code starting at the matching case. Leaving the break out can result in unexpected output, remember to use the break to indicate the end of a cases’ block of code.
 Switch vs If-Else
You may have noticed some similarities between the switch and if-else blocks. Both of these constructs act in a similar manner and they can both almost be used interchangeably. The decision on which to use is yours.
Comments, Questions or Concerns
If you have any comments, questions or concerns feel free to voice them on this site or contact us directly at php@htmlandphp.com
Visit www.HTMLandPHP.com for more information!


Crayon Syntax Highlighter
Bladymir — Mon, 19 Dec 2011 15:24:49 +0000
About the Plugin
Crayon Syntax Highlighter is a a fantastic plugin for WordPress created by Aram Kocharyan. The plugin enables you to post code in your WordPress posts and pages in a very easy to use way. If you are using WordPress and plan on posting code on your site, you need to get Crayon Syntax Highlighter.
It is simply one of the best syntax highlighter we have come across, as you may have noticed, we use it in almost all of our post here at HTMLandPHP.com
Plugin Example

In order to post code all we simply use the short tag and a relative path to the script and the plugin takes care of the rest.
[crayon url="examples/php/beginner/example_and_or.php"/]$
You can also have code written right inside your post. Visit the plugins website for more details on usage and download information!
Plugin Homepage
Official webpage at: http://ak.net84.net/projects/crayon-syntax-highlighter/
WordPress Plugin Page: http://wordpress.org/extend/plugins/crayon-syntax-highlighter/
Visit www.HTMLandPHP.com for more information!


Simple PHP Flat File Shoutbox
Bladymir — Mon, 19 Dec 2011 06:10:32 +0000
About The Script
This is a simple PHP Shout Box or Guest Book script. All the information gathered by the script is stored in a text file as comma separated values.
Download the Script Files Now
Title : Flat File Shout Box Script
Caption : Flat File Shout Box Script
File name : com.htmlandphp.shoutbox.1.0.1.zip
Size : 3 kB
Further Explanation
/index.php
Scripts main File, It is used to display the posted messages and display the form used to post messages.



    
        
        Shout Box | Guest Book Simple Script
        
    
    
        
            
            
        
            
                    
                          
                        (@)

                        
                    
                    
        
        
            
                Username
                > 
                Site (Without http://)
                > 
                Message
                 <?php if (isset($_POST['posting_user']))
                           echo $_POST['posting_message'];
            ?>
                
            
        
        Shout-Box Script From HTMLandPHP.com
    

/process/write.php
This file is used to write new post to the data file. The file is loaded every time the script is called. When loaded the script checks to see if the form has been posted. If the form has not been posted it does nothing, if the form has been posted, then it processes the input, trimming extra white space, converting commas to their special character code and converting html entities to their html code equivalents.
' . $postUser . '';
        } else {
            $postingUser = $postUser;
        }

        $postingTime = time();
        $postedMessage = str_replace(array(','), ',', htmlentities($postMessage));
        
        $line = $postingUser . ',' . $postingTime . ',' . $postedMessage ."\n";

        $fileHandle = fopen($dataFile, 'a');
        if (!fwrite($fileHandle, $line)) {
            $error = 'Could not write to file, try again.';
        }
        fclose($fileHandle);

        // Delete post data so that fields do no populate again
        unset($_POST);
    } else {
        $error = 'Username and message are required!';
    }
}

/process/read.php
The read.php is used to read information from the file specified in index.php. If the file does not exist or if the file is empty, it displays an appropriate message. If the file is not empty, the script processes the file, line by line, and splits the data at every comma. The data stored in the data file is username, followed by a unix time stamp and the message in the third position.
 1) {
            $posts[] = array('postingUser' => $parts[0],
                'postingTime' => date('m/d/Y H:m', $parts[1]),
                'postedMessage' => $parts[2]);
        }
    }
}

/styles/styles.css
The styles.css is used to control the look of the page and layout of elements. It is a plain CSS file.
html,
body {
    font-family: sans-serif;
    font-size: 12px;
}

label {
    float: left;
    clear: both;
    font-weight: bolder;
    color: #ffffff;
}

input,
textarea {
    border: solid 1px #343434;
    float: left;
    clear: both;
    width:200px;
}
div#error {
    padding:5px;
    font-weight: bolder;
    color: #FFF;
    background-color: #FF8888;
    width: 210px;
    border:solid 1px #FF0000;
}
div#listing{
    height: 250px;
    width: 210px;
    overflow: auto;
}

p.post {
    font-size: 1em;
    padding:5px;
    border:solid #AAA 1px;
}

div#form {
    background-color: #AAA;
    overflow:auto;
    padding:5px;
    width: 210px;
}

Visit www.HTMLandPHP.com for more information!


205: Introduction to If-Else Conditionals in PHP
Bladymir — Sun, 18 Dec 2011 00:11:37 +0000
Introduction
In programming conditionals are the constructs that control flow of a program. Conditional constructs allow a program to have logic that enables decision making.
Conditional construct in PHP include if, elseif, and else. The if and elseif are followed by one or more expressions that can be evaluated to a Boolean value. The else is not followed by a boolean expression, but simply by a block of code that will be executed in the case that the other Booleans expressions are false.
Boolean Expression
A Boolean expression is simply a set of one or more comparisons that result in a true or false value.
Comparison Operators
Comparison Operators are simply operators that compare two values. You can compare a variable to a value or two variables to each other. The operators are used in between the two values we are comparing and return a Boolean value, a true or false.



Operator
Description
Example
Boolean Value of Example




==
Checks for equality
“abc” == “abc”
true


!=
Checks for unequality
“abc” != “abc”
false


>
Greater than
1 > 2
false


<
Less than
1 < 2
true


>=
Greater than or equal
1 >= 2
false


<=
Less than or equal
1 <= 2
true


===
Identity -

Checks value and data type
0 === false
false

(NOTE: “0 == false” results in true)


!==
Not an Identity -

Checks value and data type
0 !== false
true

(NOTE: “0 != false” results in false)



example_comparison_operators.php
 100);  // False

// Left value is less than right value?
var_dump($int1 < 100);  // False

// Left value greater than OR equal to right value?
var_dump($int1 >= 100);  // True

// Left value is less than OR equal to right value?
var_dump($int1 <= 100);  // True

// Check for identity, check value and type
var_dump($int1 === $float1); // False

// Check for NOT identity, check value and type
var_dump($int1 !== $float1);  // True

Joining Multiple Boolean Expressions
Its possible to have multiple Boolean expressions in order to match a set of conditions. In such a case the AND and OR key words or && for AND and || for OR symbols can be used to join multiple expressions. AND returns true if the expressions being joined are both true. In contrast  OR returns a true value when at least one of the expressions is true. It should be noted also that you can use any combination of AND and OR and group pairs of expressions with parenthesis  to meet more specific criteria in your scripts.
example_and_or.php

Syntax
The “if” Statement
The if statement should be followed by a Boolean expression encased in parenthesis in order to be parse correctly. After the parenthesis you can define a block of code to execute by wrapping any number of lines between curly brackets. You can omit the curly brackets if you only have a single line of code after the if statement. In the case that you have multiple lines of code that you want to execute but omit the curly brackets, only the first line is considered part of the if.
example_syntax_if.php

The “elseif” and “else if” Statements
The “elseif” and “else if” statements work in a similar fashion to the “if”, they are followed by a Boolean expression encased in parenthesis and a line or a block of code that will get executed.
The only time an “else if” statement gets executed is when the condition inside the “if” statement was false.
Note that you are able to have multiple “else if“ statements following an if. The parser will check each of the statements sequential until a true statement is found.
example_if_elseif.php

The “else” Statement
The “else” statement is the final step in a conditional statement. This is an optional component of the conditionals as it functions as a fallback option in the case that none of the other options match. The else does not have a Boolean expression, but it does need a line or block of code that it should execute in the case none of the “if” or “else if” statements matched. If you do not have any code for the else, you can omit it entirely like the examples above.
example_if_elseif_else.php

Summary
In summary the if-else constructs in PHP allow us to control flow of the script in order to execute specific piece of code depending on the value of variables we specify. You can use the “if” construct in conjunction with “elseif” and “else” or use it independently. Note that the expression following the “if” or “else-if” is always evaluated to a Boolean value.
Questions or Concerns?
If you happen to have any questions, concerns or corrections please let us know in the comment area or you can reach us at php@htmlandphp.com
Visit www.HTMLandPHP.com for more information!


204: Introduction to Data Types
Bladymir — Sat, 17 Dec 2011 15:26:11 +0000
Introduction
PHP is a loosely typed programming language. Although PHP is loosely typed it is still necessary to distinguish the type of data that is stored by a variable at a given time.
The major data types that operate in PHP are strings, integers, floating points(decimals), arrays and for lack of a better description, objects.
Checking for Output
In order to better understand the data types our variables are holding we are going to make use of the var_dump() function that is available in PHP. The var_dump() function allows us to see what type of data and what value the data has by sending it to our browsers.
Strings
Strings are simply a collection of numbers, letters and/or symbols. Strings are typically wrapped in single or double quotes. Strings simply store text.
Note On Quotation Marks
Strings enclosed by double quotes are parsed for embedded variables and special characters. Special characters are characters such as new line (\n), tab (\t) and other double quotes, just to name a few.
Strings enclosed by single quotes are literal strings that do not get parsed again, the string will literally be what it was defined as.
When you define a string it is important to note that after you have decided on what type of quotes to use, you will have to escape that type of quote with the backslash character, if you decide you need to use it as part of the string.
For example, a string encased in double quotes will need to have a backslash before the inner quote so that it gets rendered as a double quote.
Failing to escape the double quote inside will result in PHP not being able to run your script due to parsing errors. PHP will parse the inner quote as if it was the end of the string and the remainder of the string will be parsed as “invalid PHP”. The same idea applies to single quotes inside a string wrapped by single quotes.
A string containing double quotes, wrapped in single quotes does not need to be escaped. The same applies to the reverse situation.
example_string.php

Integers and Floating Points
In PHP there are two types of data that hold numerical values, integers and floating points.
Integers serve to hold whole numbers. Integers are commonly used to hold counts, id numbers, or indexes of an array.
Floating points are what we more generally refer to as decimals. Floating points occur whenever the numerical value will not be a whole number.
It should be noted that the switch between integers to floating points is handled by the PHP interpreter.
example_integers_floats.php 

Boolean
Boolean is simply a value of true or false. The possible values that it can hold are assigned with either of the two keywords, TRUE and FALSE. The keywords are case insensitive, any capitalization will translate appropriately. Boolean are an abstraction that is used extensively in conditionals and loops.
Note on Booleans: The PHP interpreter will interpret any zero or empty value as false and any non empty or non zero value as true. What this means is that the true and false values can be mimicked by using zero and one or an empty string and a non empty string to represent FALSE and TRUE.
example_boolean.php 

Arrays
In the simplest terms, arrays can be seen as a list or set of data. Arrays in PHP can hold any type of data within, so arrays can hold a collection of strings, intergers, floats, boolean, objects or other arrays. Arrays in PHP are not restricted to holding just one type of data, they can hold any combination of data.
Arrays are typically used to hold sets of data and it is very common to populate them within loops.
example_array.php
 'Joe', 'age' => 21); // array of diff data types
var_dump($variable);

Objects
Objects are an advanced topic in PHP. Objects are part of PHP’s object oriented features, and in simplest terms they are a custom data type that we can define. Objects are a collection of methods(functions) and member variables(variables belonging to the object) that represent some abstraction. Unfortunately we will not do anything with objects until we get to our advanced PHP tutorials.
Summary
Even though PHP is a loosely typed language there is still a need to consider the type of data that is being held in variables. The var_dump() function helps us to determine what’s in our variables and is a common tool used to track down issues with why script execution may not be occurring as expected.
Strings are a collection of characters.
Integers are whole numbers.
Floating points are decimal numbers.
Boolean value are either true or false.
Arrays are sets of other data types including other arrays.
Objects are a custom data type that is an abstract representation of a set of data.
 
Visit www.HTMLandPHP.com for more information!

array(2) {
	[0]=>
	string(5) “Hello”
	[1]=>
	string(5) “World”
	}

Operator	Description	Example	Boolean Value of Example
==	Checks for equality	“abc” == “abc”	true
!=	Checks for unequality	“abc” != “abc”	false
>	Greater than	1 > 2	false
<	Less than	1 < 2	true
>=	Greater than or equal	1 >= 2	false
<=	Less than or equal	1 <= 2	true
===	Identity - Checks value and data type	0 === false	false (NOTE: “0 == false” results in true)
!==	Not an Identity - Checks value and data type	0 !== false	true (NOTE: “0 != false” results in false)