Let’s start by taking a look at how Heroku describes themselves:

Heroku (pronounced her-OH-koo) is a cloud application platform – a new way of building and deploying web apps.

Our service lets app developers spend 100% of their time on their application code, not managing servers, deployment, ongoing operations, or scaling.

Heroku is a cloud application platform. Alternatively, we can say Heroku provides Platform as a service (PAAS). Which means that their entire reason for being is to provide you a computing platform you need to run your application.

While browsing the Heroku webpage you will find that they support Ruby, Node.js, Clojure, Java, Python and Scala, and a well kept secret is that they support PHP applications as well, but you may have trouble finding any documentation for PHP in their Developer Center.

How is Heroku Different From Standard Web Hosting?

Heroku is different from regular web hosting in that they do not allocate a particular slice of space and cpu time on some machine in a data center.  Heroku provides a platform as a service that has the ability to scale with the requests that your web application receives.

Your application is deployed to Heroku, and then an instance is started up or assigned to an incoming request. What this means is that you have the ability to potentially serve more requests and scale your web application with greater ease.

Since Heroku does not allocate resources like a regular host, this also means that you do not have the type of file system access like ftp or ssh, as you may have had with a regular host.

Applications that are deployed to Heroku do need to be designed and thought out a bit different than those that are deployed to regular web-hosts due to the nature of the Heroku platform. These essential design choices however do lead to more scale-able application, which is what Heroku is all about.

Workflow Of Heroku

It should be noted that in order to work with Heroku, you need to have git and the the Heroku Tool-belt installed. Since Heroku leverages git to deploy applications it is an unavoidable fact that a reasonable amount of git experience should be had.

Deploying to Heroku is covered in more detail in later articles. A simple PHP application can still be created via typical methods using packages like XAMPP, WAMP, MAMP.

As mentioned earlier Heroku does not provide access to the file system, and the only method of deployment is through pushing your application via git to a remote Heroku server.

The process looks very roughly as follows:

1. Create PHP Application or Pull an existing App from a Heroku remote url.
2. Keep version control via Git.
3. To deploy, push to a Heroku remote addresss.
4. Visit the Heroku addresss for your application.

Resources

Heroku Tool-Belt – The heroku tool belt used for accessing your Heroku application
Heroku Dev Center – Heroku Documentatin.
Git Version Control – Git Version Control
Quick Git Tutorial – GitHub Git Tutorial

Next:Get Started Using Heroku

Visit www.HTMLandPHP.com for more information!

To work around this you can do the following:

function display_timely_calendar($attr = null, $content = null) {

    global $ai1ec_calendar_controller;

    echo '<div id="ai1ec-container" class="ai1ec-container thenly">' ;
    $ai1ec_calendar_controller->view();
    echo '</div>';
}

Visit www.HTMLandPHP.com for more information!

Types of Input Data — GET & POST

Form data can be submitted to your PHP script either via GET or POST methods. Which method is used is dependent on which of the two is used in the method attribute of the form tag.

When the form data is submitted with a method of GET the data is encoded and appended onto the url of the action attribute of your from. So your form data can be read right from the url after it is submitted. Ultimately the get method is best used for form that have relatively trivial amounts of unimportant data. Keep in mind the data will be visible in the address bar of the browser.

Post method differs in that the data is not transmitted in the URL after being submitted. The submitted data is transferred “behind the scenes” and is for the most part invisible to the user. Post also allows us to transfer more data.

Accessing GET & POST in PHP

Now we know that we have two methods for transferring input to PHP. We first choose which method you prefer to use or fits your situation best.

If your about to use GET, PHP has an easy way to access that data you just transmitted. PHP has a global array in a variable called $_GET that allows us to access data send via the GET method. To access particular pieces of data you use the name attribute of your input, select, or textarea inside your form.

For example accessing the data in from an input field with name of “email”, we would use the following syntax in PHP.

echo $_GET['email'];

Accessing data that was transmitted via the POST method we would use the $_POST variable in the same manner, and our example would become…

echo $_POST['email'];

It really is that simple!

Display All Keys and Values

If you wanted to display all the data that was transmitted, you could use the print_r() or var_dump() functions to display a readable output of your array.

print_r($_GET);

/* OR */

var_dump($_POST);

Keep in mind that these varibales are just PHP arrays that are generated by the PHP interpreter when POST or GET data is present.

You can use array functions to check whether a given field was submitted, or a form field hold a particular value. For example…

if($_POST['email'] == 'admin@admin.com')
    echo 'Welcome Admin!';

Word of Caution

Security of scripts on the web is a huge concern for server security and security of data.  Using the value submitted via GET and POST without sanitizing or escaping potentially problematic code can cause a huge headache.

Make sure you escape your posted data using functions such as mysql_escpae_string(), trim(), strip_tags(), htmlentities() and possibly str_replace() and other similar functions to prevent “bad” data from being processed by your script and placing your website or server at risk of being victim to injection attacks and other unpleasant experiences.

Visit www.HTMLandPHP.com for more information!

PHP Notices & Warnings

Notices and warnings in PHP do not stop execution of the script.  Notices are just that, notices from the interpreter about a particular line of code that did not hold an expected value. This often happens when we try to use variables which have not been declared or array indices which have not been defined.

For example: We might be declaring a variable or array index ONLY when a particular condition is true — inside and if-else statement — and then trying to use the variable.

In both of these cases, we would be trying to access the value of an undefined item.

To fix notices, we would simply make sure that the expected variable was declared, by making sure the logic of the script was sound — correct and valid.

It is entirely possible to turn off notices from appearing when the script executes. Although I would strongly suggest that scripts should be written in a way that ensures that they are free of errors. In the section below I will cover how error reporting can be adjusted.

PHP Fatal Errors

In the simplest terms Fatal Errors are errors that the PHP interpreter can simply not recover from.  These type of errors will stop the script from continuing, meaning after these errors are encountered.  The interpreter stops everything and displays the error.

The most common source of fatal errors is calling undeclared functions, or methods of objects, or classes (if using Object Oriented PHP), and mistakes in syntax.

Mistakes in syntax are typically followed by a message described as “Paser Error:….” with the approximate line number of the mistake. These errors are mostly always easy to find, and typically translate to missing semi-colon, extra/missing parenthesis or quote to name a few of the things.

Calling undeclared functions or classes means that the functions has not been declared yet, or that you possibly have a typo in the name of the function you are calling.

Correcting the typo — if applicable — will fix the issue.

If its a custom declared function or class, you must make sure that the file where the function is declared is being included. In this case, ensure that your include path is correct, and that the expected functions or class declarations are in the file.

Lastly fatal errors may also be related to a script taking too long to execute or using too much memory to execute — beyond the time or space allowed in php.ini. To fix this you would increase the time or space allotted or adjust the script to reduce the time or amount of memory the script takes to execute.

PHP Error Reporting

Error reporting setting can be adjusted in php.ini settings file that configures your php installation. Alternately PHP error reporting can be adjusted via the error_reporting() function.

It should be noted that disabling error reporting means that warnings, notices, and fatal errors may be muted when they occur, which may make debugging very difficult.

Below is a snippet of code from php.net that uses global constants to specify which types of errors should be displayed. Note that the constants are integer values.

// Turn off all error reporting
error_reporting(0);

// Report simple running errors
error_reporting(E_ERROR | E_WARNING | E_PARSE); //Bitwise OR

// Reporting E_NOTICE can be good too (to report uninitialized
// variables or catch variable name misspellings ...)
error_reporting(E_ERROR | E_WARNING | E_PARSE | E_NOTICE); //Bitwise OR

// Report all errors except E_NOTICE
// This is the default value set in php.ini
error_reporting(E_ALL ^ E_NOTICE); //Bitwise xOR

// Report all PHP errors (as of 5.4.0)
error_reporting(E_ALL);

// Report all PHP errors
error_reporting(-1);

// Same as error_reporting(E_ALL);
ini_set('error_reporting', E_ALL);

/*Values
E_ERROR : 1
E_WARNING: 2
E_PARSE: 4
E_NOTICE: 8
E_STRICT: 2048
E_ALL: 30719
*/

Conclusion

Generally everyone should try to write sound code that is free of errors. Writing error free code will ensure that your scripts work consistently across various PHP configurations and ensure that everyone — including yourself — can read and follow your code after it was initially written.

Ensure error reporting is on when you are debugging and that you know what the various errors means and how you can go about correcting them.

Visit www.HTMLandPHP.com for more information!

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!

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
$title = "Greatest Page!";
?>
<html>
    <head>
        <title>
            <?php echo $title; ?> 
        </title>
        <style>
            header {border-bottom:dotted 1px #AAA;}
            footer {border-top:dotted 1px #AAA;}
        </style>
    </head>
    <body>
        <header>
            <h1>
                <?php echo $title; ?>
            </h1>
            <p>
                <a href="#">Home</a> |
                <a href="#">About Us</a> |
                <a href="#">Contact Us</a>
            </p>
        </header>
        <section>
            <h1>Page1</h1>
            <p>Hello World!</p>
        </section>
        <footer>
            <p>
                <a href="#">Home</a> |
                <a href="#">About Us</a> |
                <a href="#">Contact Us</a>
            </p>
        </footer>
    </body>
</html>

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 

<html>
    <head>
        <title>
            <?php echo $title; ?> 
        </title>
        <style>
            header {border-bottom:dotted 1px #AAA;}
            footer {border-top:dotted 1px #AAA;}
        </style>
    </head>
    <body>
        <header>
            <h1>
                <?php echo $title; ?>
            </h1>
            <p>
                <a href="#">Home</a> |
                <a href="#">About Us</a> |
                <a href="#">Contact Us</a>
            </p>
        </header>

home.php 

<section>
    <h1>Page1</h1>
    <p>Hello World!</p>
</section>

footer.php 

<footer>
            <p>
                <a href="#">Home</a> |
                <a href="#">About Us</a> |
                <a href="#">Contact Us</a>
            </p>
        </footer>
    </body>
</html>

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 

<?php
// Variable is used in our header
$title = "Greatest Page!";
include 'header.php';
?>

        <section>
            <h1>Welcome!</h1>
            <p>Hola! Hello! Hallo! Salut!</p>
        </section>
<?php
include 'footer.php';
?>

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!

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:

<?php
$x = 0;

while($x < 10) {
    echo $x, "<br>\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:

<?php

$x = 0;
do{
    echo $x;
    $x++;
} while ($x < 0);

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:

<?php
$genres = array('Blues', 'Country', 'Rock', 'Rap');

/*
 * Start our index at 0
 * 
 * Execute the block as long as the number is
 * less than the number of items in the array
 * 
 * After executing the code, add one to the count (index).
 */
for($index = 0; $index < count($genres); $index++) {
    // Access the n-th element of he $genres array. 
    // n-th refers to the number held by $index.
    echo 'Do you like ', $genres[$index] ," music?<br>\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:

<?php
$colors = array('red', 'blue', 'green', 'magenta','cyan','yellow');

/*
 *  Each value fo the $colors array will be referred to as
 *  a $color (singular) inside the array.
 */

foreach($colors as $color){
    echo 'Do you like the color ', $color ,"?<br>\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:

<?php

$alphabet = array(  'first'  => '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, ".<br>\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:

<?php
echo '<pre>';
$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 '</pre>';

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:

<?php
$br = "<br>\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!

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 :

<?php
$number = 1;

echo '<b>Starting:</b> '. $number .'<br>';  // Display our starting number
for($count = 2; $count <= 10; $count += 2)
{
    echo 'Before:'. $number . '<br>';       // Display number before operation
    $number *= $count;
    echo 'After:'. $number . '<br><br>';    // Display number after operation
}
echo '<b>Ending:</b> '. $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 :

<pre>
<?php
$aString = "Hello Dolly";
$anArray = array('name' => '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);

?>
</pre>

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 :

<?php

/*
 * Set the variable
 * Then use isset to see if we have declared it
 */
$var1 = 'Some Value';

if(isset($var1))
    echo 'Variable 1 is set! <br>';
else
    echo 'Variable 1 is not set!<br>';

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

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 :

<?php

/*
 * set the variable and a value
 * Then use empty to see if we have an empty value
 */
$var1 = 'Some Value';

if(empty($var1))
    echo 'Variable 1 is empty! <br>';
else
    echo 'Variable 1 is not empty!<br>';

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

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

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 :

<?php
$error = true;

if($error)
    exit('An Error Occured. Unable to continue.'); // die() is equivalent

echo 'Welcome!';

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 :

<?php
$bar = "Hello";
$foo = isset($bar) or die('An Error Occured. $bar was not set.');
echo 'Welcome! $bar was set.';

/* Note we have not declared $tag*/
$fee = isset($tag) or die('An Error Occured. $tag was not set.');
echo 'Welcome! $tag was set.';

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!

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.

<?php
/* Fill an array by passing values as parameters */
$ourList = array('Hello', 'World'); // pass values as parameters

var_dump($ourList);     // Visual Representation of the array.


/* Filling an array by passing an empty index */
$ourList2 = array();         // empty array
$ourList2[] = 'Hello';       // pushes a value into the array
$ourList2[] = 'World';       // pushes a value into the array

var_dump($ourList2);     // Visual Representation 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:

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.

<?php
# Fill an array by passing values as parameters 
$names = array('Leon', 'Ivan', 'John', 'Mohamed', 'Jose'); 

echo $names[0], "<br>\n"; // Displays: Leon
echo $names[1], "<br>\n"; // Displays: Ivan
echo $names[2], "<br>\n"; // Displays: John
echo $names[3], "<br>\n"; // Displays: Mohamed
echo $names[4], "<br>\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.

<?php
$br = "<br>\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.

<?php
$family = array();

// key 'adults' contains an array with keys and values
$family['adults'] = array(
                        'mother' => 'Lea', 
                        'father' => 'Lucas'
                    );

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

echo $family['adults']['father'], "<br>\n";      // Displays: Lea
echo $family['adults']['mother'], "<br>\n";      // Displays: Lucas
echo $family['children']['son'], "<br>\n";       // Displays: Leo
echo $family['children']['daughter'], "<br>\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!

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. 

<?php
$day = 4;

switch ($day){
    case 0 : 
        echo 'Sunday';
        break;
    case 1 : 
        echo 'Monday';
        break;
    case 2 : 
        echo 'Tuesday';
        break;
    case 3 : 
        echo 'Wednesday';
        break;
    case 4 : 
        echo 'Thursday';
        break;
    case 5 : 
        echo 'Friday';
        break;
    case 6 : 
        echo 'Saturday';
        break;
}
?>

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. 

<?php
$day = 4;

switch ($day){
    case 0 :
    case 2 :
    case 4 :
    case 6 :
    case 8 :
    case 10 :
        echo 'Even!';
        break;
    case 1 :
    case 3 :
    case 5 :
    case 6 :
    case 7 :
    case 11 :
        echo 'Odd!';
        break;
}
?>

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.

<?php
$day = 10;

switch ($day) {
    case 0 :
    case 1 :
    case 2 :
    case 3 :
    case 4 :
    case 5 :
    case 6 :
        echo 'Its a valid day from 0 to 6!';
        break;
    default :
        echo 'Not a valid number for a day!';
        break;
}
?>

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!