Practical PHP: Master the Basics and Code Dynamic Websites

Lecture 6: Your First PHP Web Page

In this lecture we're going to be learning how to set up a virtual server to run your very first PHP web page. How exciting!

Lecture 7: PHP Syntax

In this lecture we're going to be learning a little bit about the basic syntax of PHP programming. It's a quick lecture, but very necessary in order to get started on the right foot.

Lecture 8: PHP Variables

Think of a variable as a bucket. Literally, a bucket. That bucket can hold stuff in it — like food, or dirt. In PHP, variables are buckets, but instead of holding food or dirt, they hold information — like numbers, text, images, or logic! All you need to know at this point is that variables are buckets that store information for later use. We'll get to how we actually use the variables in an upcoming lecture.

The basic syntax of a variable is a dollar sign ($) directly followed by a variable name (using text, with no spaces), then an equal sign, followed by the contents of the variable, ending with a semi-colon. Ex: $variable_name = 'my first variable';

There are 4 basic variable types, and each type of variable (or "bucket") is meant to hold specific information. Watch the lecture or download the PDF to learn what the 4 basic variable types are.

Lecture 9: More Variables

In this lecture, we cover a couple more examples of the basic usage of PHP variables.

Lecture 10: Defining Constants

A constant is similar to a variable in the sense that you can store information in a keyword that can be used throughout your web page. However, the value of a constant cannot be changed, unlike a variable. It's literally "constant".

It's also worth noting that constants are case-sensitive and are written in ALL CAPS by convention. Here's how you define a constant in PHP:

To display a constant on your page, you can echo it using PHP, like this:

<?php echoTITLE; ?>

Lecture 11: Get Your Hands Dirty!

In this lecture we put in to practice everything we've learned so far:

• PHP Variables
• PHP Constants

Simple and straightforward, you will be able to see the benefits of using variables and constants right away!

Lecture 12: Arrays

Sometimes you'll want to store more than one value within your variables. With an array, you can do just that! Arrays allow you to store multiple values within a variable.

For example, I think moustaches are neat. There are many kinds of moustaches! Using individual variables, I can store each moustache in their own, like so:

$moustache1 = "Handlebar";

$moustache2 = "Salvador Dali";

$moustache3 = "Fu Manchu";

But, I'd like to keep things neat n' tidy and have all my moustaches in a single variable. So I'll use an array, like so:

$moustaches= array("Handlebar", "Salvador Dali", "Fu Manchu");

Each value is automatically assigned a "key" in the array, so we can grab a specific value when we need it. We'll touch on keys later, but by default, each value has a numeric key assigned to it.

So for example, "Handlebar" is 1, "Salvador Dali" is 2, and "Fu Manchu" is 3. Here's the catch though — the numbers start at 0, not 1. So, "Handlebar" is actually 0, etc.

If we want to grab a value out of an array and display it on our web page, we just reference the array and the key associated with the value we want to display, like so:

<?php

echo $moustaches[0]; // this will display "Handlebar"

echo $moustaches[1]; // this will display "Salvador Dali"

echo $moustaches[2]; // this will display "Fu Manchu"

?>

Arrays are pretty powerful, and there's a lot more to them. So stay tuned!

Lecture 13: Associative Arrays

Remember how PHP automatically assigns a number to each item in an array? Well, using Associative Arrays you can give a custom name to the key, rather than using a number. It looks like this:

$handlebar = array(

name => "Handlebar",

creep_factor => "High",

avg_growth_days => 14

);

Now, let's say I wanted to display specific information from the array. I would do so by simply referring to a custom key in the array, like this:

<?php echo$handlebar[creep_factor]; ?>

Lecture 14: Multi-Dimensional Arrays

This is where we start getting crazy! We can harness the true potential of arrays by using multi-dimensional arrays — which is simply an array that is comprised of multiple arrays!

$moustaches = array (

array (

"name" => "Handlebar",

"creep_factor" => "High",

"avg_growth_days" => 14

),

array (

"name" => "Salvador Dali",

"creep_factor" => "Extreme",

"avg_growth_days" => 62

),

array (

"name" => "Fu Manchu",

"creep_factor" => "Very High",

"avg_growth_days" => 58

)

);

You're probably wondering how the heck we display this info on the screen! Well, we first have to reference the parent array $moustaches, then the numerical value of the child array (Handlebar is [0], Salvador Dali [1], etc), and finally the custom key of the information we want to display (name, creep_factor, etc). It looks like this:

<?php echo$moustaches[2][name]; ?>

The above code will display Fu Manchu.

- - -

Important update regarding the "keys" in your arrays:

After recording the last two lectures, and publishing my course, it came to my attention that I made a little mistake!

I have a bad habit of not wrapping my keys in my associative & multidimensional arrays in quotations, or "strings".

For example

The incorrect way of coding associative arrays:

$handlebar = array(
		name => "Handlebar",
		creep_factor => "High",
		avg_growth_days => 14
	);

The correct way of coding associative arrays:

$handlebar = array(
		"name" => "Handlebar",
		"creep_factor" => "High",
		"avg_growth_days" => 14
	);

Some servers, like MAMP, might not report the error, and just assume the keys are wrapped in strings. Some servers are not as forgiving as MAMP on a Mac, very obviously letting you know you made an error.

It's very important that your key names in your associative and multi-dimensional arrays are wrapped in quotation marks, single or double.

No worries though! The course files have been updated (as of July 25, 2014), and you probably already have the updated files. For your reference, the exact folders that have been updated are:

• 07_AssociativeArrays
• 08_MultiDimensionalArrays
• 09_GetYourHandsDirty
• 26_Final/Instructor

Thank you very much to everyone who pointed this out!

Cheers,

Brad

Lecture 15: Get Your Hands Dirty

In this lecture, we put together what we've learned so far about PHP Variables, Constants and Arrays!

Lecture 17: Else

We've figured out how to execute some code if an expression evaluates to TRUE, but what about when the expression evaluates to FALSE? Often you'll want to execute some code if a certain condition has not been met.

This is where Else comes in to play. Look at Else as an extension of the If statement. The syntax looks like this:

if (expression) {

// code to execute if TRUE

} else {

// code to execute if FALSE

}

Now, let's take a look at a real-world example:

<?php

$fav_fruit = "orange";

if ($fav_fruit == "pineapple") {

echo "YAY! Pineapple is the best.";

} else {

echo "So, you like oranges...";

}

?>

Not all "equals" are created equal

It's good to remember that "==" is different than "=". The former means is equal to while the latter assigns a value to a variable. For example:

Lecture 19: Get Your Hands Dirty

In this lecture, we're going to build a simple PHP script that utilizes the skills we've learned in this section: If Statements, Else and Elseif.

Lecture 23: String Operators

This one's nice and simple: there are only two string operators. The first one is called the concatenation operator ".", which combines the value of the right argument with the left argument. Let's look at it like this:

$a = "Hola ";

$b = $a . "Mi Amigos!";

echo $b; // This prints "Hola Mi Amigos!"

The second operator is the concatenating assignment operator ".=", which appends the value in the right with the value in the left, like this:

$a = "Hola ";

$a .= "Mi Amigos!";

echo $a; // This prints "Hola Mi Amigos!"

The concatenating assignment operator is considered an "Assignment Operator" which we will be learning more about in the next lecture.

Lecture 24: Assignment Operators

Assignment Operators "assign" values from the right argument to the left argument — usually in the form of variables. The basic assignment operator is "=", which assigns the value on the right to the variable on the left. Here is a table of more assignment operators:

Here's an example of how to use one of the above operators:

<?php

$a = 71;

$b = 36;

$a -= $b;

echo $a; // Prints 35

?>

Lecture 25: While Loop

When coding PHP, loops can be fantastic! Basically, you can write a piece of code to repeat itself again and again until a certain condition has been met. There are a few types of loops in PHP, in this lecture we'll learn about While Loops.

Here's how a while loop works:

while (condition is true) {

// execute code

}

At this point, you probably have no idea how to actually use a while loop in PHP. That's okay. Let's dive into how you actually use it.

Let's say you want PHP to echo the numbers from 10 to 20. First you need to set a variable with your starting number:

<?php

// Set a variable with your starting number

$startingNum = 10;

?>

Then you need to start your while loop with a condition. In this case, we want our condition to say "while my starting number ($startingNum) is less than or equal to 20, the condition is true".

To help clarify — as long as $startingNum is less than or equal to 20, keep on looping!

<?php

// Set a variable with your starting number

$startingNum = 10;

// While $startingNum is less than or equal to 20

while ($startingNum <= 20) {

// execute code

}

?>

You may be thinking: "our starting number is 10, it will always be less than 20, dumbo!".

Well, each time we loop through our function, we will tell PHP to increment our starting number by 1. Therefore, eventually our starting number will be equal to 20!

Our condition says to stop looping once our starting number is larger than 20. We need to do this to prevent an infinite loop — something you most definitely don't want! An infinite loop means your function will literally run forever, which can freeze up your computer.

So, let's tell PHP to echo our $startingNum variable, then increment the variable by 1:

<?php

// Set a variable with your starting number

$startingNum = 10;

// While $startingNum is less than or equal to 20

while ($startingNum <= 20) {

// Echo the variable on the screen

// We'll also concatenate a <br> tag at the end

echo $startingNum . "<br>";

// Then increment the value by 1

$startingNum++;

}

?>

In PHP, you can increment and decrement variables like so:

$a++;	adds 1 to the value of the variable $a each time through
$a--;	subtracts 1 from the value of the variable $a each time through

If coded correctly, this code should echo the numbers 10 to 20 on your screen, and stop at 20. Keep in mind, you can use any of the operators we've used in our past lectures as the conditions that need to be met in the while loop.

Lecture 28: Do / While Loop

The Do While Loop is a bit like the While Loop, but there's one major difference: the While Loop will only start if the condition is TRUE; whereas the Do While Loop will always execute the first time, and then evaluate whether the condition is TRUE afterwards.

Here's what the syntax looks like:

do {

// execute code

} while ( condition to be met );

Let's look at a real example:

// Set a variable

$i = 1;

do {

// Do this code

echo "Number: $i <br>";

$i++;

}

// Then evaluate this condition

// Repeat loop if TRUE

while ( $i <= 10 );

If coded correctly, this should echo the numbers 1 to 10 on your screen.

Lecture 30: Custom Functions

While PHP has a massive library of built-in functions you have at your disposal, sometimes you need to build your own functions — for both small and large tasks.

Think of a custom functions as a mini-program that performs an action for you — better yet, think of a custom function as a cute little robot that does a specific task you tell it to do!

Let's look at the basic syntax of a function:

<?php

function myCustomFunction() {

// things my custom function will do

// go in here

}

?>

To build your custom function, you need to type function myCustomFunction(). Keep in mind that "myCustomFunction()" can be whatever words you want them to be, but no spaces allowed. Then add opening and closing curly brackets (or curly braces, as some call it). In between the curly brackets is where you define what your function will perform.

There are two important things to know about functions:

1. There are functions that require "arguments", and;
2. There are functions that don't require "arguments".

Let's start by building a custom function that does not require an argument.

<?php

// Build the function

function hangTen() {

echo "Surf's up! Grab your board!";

}

// Call the function

hangTen();

?>

Lecture 31: Simple Arguments

Functions can be incredibly powerful, because you can program them to do almost anything you want them to. One important step in making your functions even smarter is to use "arguments" within your function. Not the type of argument where you and a friend are bickering about a disagreement, I'm talking about arguments within functions — two very different things.

Think of an argument like a variable. Your program can pass extra information to your functions using arguments. You specify your arguments within the parenthesis after your function name, and you can have as many as you want, as long as they're comma separated.

Let's look at an example of a function with a single argument:

<?php

function hangTen($location) {

echo "We're surfing in $location!<br>";

}

hangTen("Hawaii");

hangTen("California");

hangTen("Newfoundland");

?>

So, in the above example, we're passing an argument to the hangTen() function. Later in our script, we call our function several times with a string of text within each parenthesis, and each time we call our function with a new argument value, that value will display on the screen along with the text we provided in our function.

The output will look like this:

We're surfing in Hawaii!
We're surfing in California!
We're surfing in Newfoundland!

Let's look at an example with two arguments:

All we did here was add another argument, separated by comma, then when we called our multiplyTogether() function later in the script, we provided two values to take the place of our $val1 and $val2 arguments.

The result?

The product of the two numbers is: 378