The Semicolon

The basic syntax of PHP, which is the first thing every PHP developer needs to know, is the semicolon. Most lines of code end with a semicolon, which essentially means, to execute the code that has been loaded before this semicolon and after the last one.

$foo = "bar";
$fooArray = "Bar",
            "This",
            "Something";

You can break your code into multiple lines in some cases, but technically the code above is still only two lines of code. The first line of code assigns the variable of $foo, and the second line sets an array called $fooArray. Even though the array is broken into three separate lines, it still executes as one line of code.

Notice how still, each line of code ends with a semicolon. You cannot split every line up like this, but when assigning arrays, building long strings, or even working with objects, you can drop down and create a new line. The reasoning behind this will be covered more in the “Making your code Pretty” article.

The period as a “String Connector”

Some languages use the plus symbol (+), some languages use variations of quotes, and PHP uses the period (.) as a string connector.

// --- Long Method
echo "Your IP address is: ";
echo $_SERVER['REMOTE_ADDR'];
echo " <br/>";
echo "The current date/time is: ";
echo date("Y-m-d H:i:s");
echo " <br/>";

// --- Short Method
echo "Your IP address is: ".$_SERVER['REMOTE_ADDR']." <br/>";
echo "The current date/time is: ".date("Y-m-d H:i:s")." <br/>";

The two above examples will yield the exact same results, example #1 not using any string connectors, example #2 joining strings using the period. You can use this syntax to set variables, within functions, or nested inside of loops. Essentially what you are doing is appending to the current string with what is after the period. By joining multiple strings together with the “something”.$something.”something” method, you can easily assemble long strings without having to write an incredible amount of code.

(Encapsulating with Parenthesis)

This is just like algebra folks… things within parenthesis will be evaluated before the rest of the equation.

 	echo 1 + 6 * (( 8 - 5 ) / 2 );

	// Order of Operations:
	// 8 - 5 = 3
	// 3 / 2 = 1.5
	// 6 * 1.5 = 9
	// 1 + 9 = 10
	// echo 10

The comment above shows the order of operations, which is identical to that of an algebra equation. Evaluate the values inside the parenthesis first, work your way outwards, then use the standard order.

Order of Operations
Source: http://www.math.com/school/subject2/lessons/S2U1L2GL.html

1. First do all operations that lie inside parentheses.
2. Next, do any work with exponents or radicals.
3. Working from left to right, do all multiplication and division.
4. Finally, working from left to right, do all addition and subtraction.

Brackets and Uses

Brackets, as in [], are primarily used for assigning or calling values from an array.

	// Example #1
	$array = array("red","green","blue");
	echo $array[0]; // Will display "red"
	echo $array[1]; // Will display "green"
	echo $array[2]; // Will display "blue"

	// Example #2
	$array = array("color1"=>"red");
	echo $array['color1'];

By default an array will populate its keys with numbers, in the above example, it does just that. When passing values into an array, each value is assigned an auto-incremented number, starting at zero. To reference these values in an array in the most simple fashion, you simply put the key you wish to call on within brackets.

These keys do not have to be numbers, they can be strings as well, and the values of the array can be pretty much any type of variable or object. The second example shows that you can pass in a string within the brackets to pull out the value for that specified key.

For more information on arrays, please see: PHP Basics – The Array.

What are those “Curly Brackets” used for?

The { and }? They are actually called “Braces” and are used to define the starting and ending of a structure of code. The most common use of them while starting is to start a loop or if-statement. The “Open Brace” or {, signifies we are starting an structure of code that will continue until the “Close Brace”, or }. This is easily seen in an if-statement as seem below.

if($foo == "bar") { // This brace starts the structure
	// Do something!
} // This brace ends it

The code encased in the braces will only execute if the condition of the if-statement evaluates to TRUE. There are also other methods of starting and stopping an if-statement or loop, but we will wait to get into those later, as to not confuse people.

Braces are also used to define function, class and namespace contents. These are a little further along, but still solid examples.

	function doWork($foo) {
		// Perform Actions on $foo
		return $bar;
	}

	class foo extends bar {
		private $var = "test";

		public function doWork($var) {
			// Do Work!
			$this->var = $mod;
		}
	}

Notice in the second example, there are nested braces within. Each brace has a start and a stop, telling the system which pieces belong in which places. When your code starts getting extremely messy or complex, its always a good idea to keep the braces lined up with the same spacing for ease of reading. Yet another topic for another day.

The Key=>Value Syntax

The last syntax covered in this post is the $key=>$value assignment syntax, which can be a little confusing at first. This is primarily used in arrays and is meant to set specific keys to specific values.

  $key = "key";
  $value = "value";

	$array = array($key=>$value);
	$array = array("key"=>"value");

	echo $

The two above examples will both assign the $array variable to contain the same array; a single key named “key” will be assigned the value of “value”. The => syntax states that you are using a key=>value combo to pull this off. This can also be used in a foreach() loop to iterate through an array of values, as seen below.

$array = array("color1"=>"red", "color2"=>"blue");

foreach($array as $key=>$value) {
	echo $key." = ".$value."<br/>";
}

// Outputs:
// color1 = red
// color2 = blue

The loop will go through every item in the $array variable, and display every key=>value combo within it.

Well, that’s it for the basics of syntax. Stick around for more info at another time!

You can pretty much think of an array as a mini-storage unit for variables, someplace to order them, keep them in one space, and reference them by name dynamically. There are more advanced ways to do some of this as well but arrays are a good starting point.

Just as a starter, here is a basic array, the first code snippet is the PHP to write the array, and the second is a visual representation of the variable.

 $variable = array("red","green","blue");

$variable = Array
(
    [0] => red
    [1] => green
    [2] => blue
)

Now, a brief overview at exactly what you are looking at here, in case you have never worked in an array before. The variable named $variable is an array, and it contains 3 values, “Red”, “Green” and “Blue”. Each of these values now has dynamically been assigned a number on the left hand column. These are the keys to access the data in the array.

If you were to make an analogy to understand it better, we could say an array is a book, and each variable in the array is a page. Each page has a page number, and those page numbers would be the keys in the array. Let’s run with that example, and create a bit more complex of an array, so and pretend our array is indeed a book.

 $book = array(
     "The quick brown dog...",
     "Jumped over the big red fence...",
     "To get to his food..."
  );

Don’t let the change of how I typed the code throw you off, this is the exact same sample as above, instead we have a “page” of the “book” stored within each “page number”. Notice how the variable looks now:

Array
(
    [0] => The quick brown dog...
    [1] => Jumped over the big red fence...
    [2] => To get to his food...
)

The variable is still pretty much the same, just with different values stored within its keys. So now, if we were going to print out the first value of the array to the screen, we would echo it out, with slightly different syntax than just a standard echo.

 echo $book[0];

You would echo it just like a standard variable, except directly after, you would use brackets to specify which key you want to retrieve from the array. The above code would output “The quick brown dog…” onto the screen. You can simply change the number at the end of the variable to specify which portion of the array you are looking for.

The above syntax you can also set values in an array with as well!

 $book[4] = "This is another page!";
 $book[1000] = "This is WAY out there...";

These two lines of code will write their values into the key of 4 and key of 1000. There’s nothing telling you that you have to use numbers in order, or even numbers for that example!

 $book['index'] = "This is the index of the book";

You can store keys with words as well, if that helps you organize how your data is stored. PHP uses a lot of arrays for sessions, server variables and many other things. Here’s an example of pulling the IP address of your client, from a $_SERVER variable that is automagically set whenever a script on your server is called.

 echo $_SERVER['REMOTE_ADDR']; // Will print the IP address accessing the script

Arrays can be an amazing storage tool to keep your variables in check, instead of assigning every single variable its own name. It also is nice if you want to pass multiple variables into a function or an object’s method at once. That’s a little bit more advanced, and a subject for another time, but just understanding the basics of how an array looks, visually and in concept, will take you a long ways.