By default PHP won’t handle accented characters, just like HTML does. So you’ll have to translate them in HTML equivalent codes. If you’re thinking “oh damn, I’ll have to handle all of them with infinite str_replace!” you’re wrong. PHP indeed has some functions that will help you doing this.

I firstly found this problem developing my WoWASDK classes, so I’ll take some examples from it.

URLEncode

This function allows you to convert the string into an URL-compatible one. This means substituting accented characters with %code. This will work if you want to create for example links (or to get an URL dynamically created)

// guild.wowasdk.php
class wowasdk_guild {
// cut out ...
	function __construct($region,$server,$name, $force_cache = false) {

		$server = ucfirst(strtolower($server));
		$fileurl = "guilds/$region/$server/$name.xml";
		$name = urlencode($name);

Do you see? $name = urlencode($name). This will assure you it will be URL-compatible. Not that hard

utf8_decode

This function will generate properly HTML characters. It’s a good way to print them off your screen in the web page.

// (unreleased) guild.wowasdk.php
// cut out ...
	function getMembersList($sort = GUILD_SORT_NULL) {
		$return = array();
		foreach($this->xmlsheet->guildInfo->guild->members->character as $char) {
			switch($this->region) {
				case EU:
					$url = "http://eu.wowarmory.com/character-sheet.xml?";
					break;
				case US:
					$url = "http://www.wowarmory.com/character-sheet.xml?";
					break;
			}
			$return[] = array(
				"name" => utf8_decode($char["name"]),
				"gender" => (int)$char["genderId"],
				"raceid" => (int)$char["raceId"],
				"classid" => (int)$char["classId"],
				"level" => (int)$char["level"],
				"rankid" => (int)$char["rank"],
				"url" => $url.$char["url"],
				"achPoints" => (int)$char["achPoints"],
			);
		}
// cut out ...

Line 15 of the example: “name” => utf8_decode($char["name"]). In this case you’ll be able to handle accented chars and correctly print them in an HTML page, otherwise you’ll see strange chars.

NOTE: if you don’t use these functions, you’ll for sure have problems even in pure PHP programs (no echo / print), this because it seems you have to “initialise” the strings before using them.

htmlspecialchars

At least here is the function which will translate special characters (like &, <, >, “) into HTML standard ones. It’s usefull if you ecounter problems viewing your site with strange characters.

<?php
	$string = "My <articulated> 'string'";
	$string = htmlspecialchars($string);
	echo $string;
?>

Will return:

My <articulated> 'string'

So let’s start with an example:

<?php

echo "Number 1<br />";
echo "Number 2<br />";
echo "Number 3<br />";
echo "Number 4<br />";
echo "Number 5<br />";
echo "Number 6<br />";
echo "Number 7<br />";
echo "Number 8<br />";
echo "Number 9<br />";

?>

<?php
for($i = 0; $i < 9; $i++)
	echo "Number $i<br />";
?>

The two codes up here are exactly the same. The first one is a repeated action, the second one is the same repetition, but it’s less chaotic and better readable. This is the function for. As all the cycle functions it doesn’t require any graphs if the functions that must be executed are one, elsewise you’ll have to delimit the functions of the cycle in graphs {}. This is an example:

<?php
for($i = 0; $i < 9; $i++) {
	echo "Number $i<br />";
	$array[] = $i;
}
?>

Clear? Great.

Returning to the cycle functionfor: it’s used when you know the exact number of iterations. It requires three parameters: the starting conditional, the ending conditional and the action taken at each iteration. In the example above $i is initialised to 0, then the cycle will go on untill $i will be inferior to 9, and at each iteration $i will be incremented by one (by the way $n++ will firstly return the value of $n and then increment the variable, ++$n will do the same but in the inverse order. Think about $array[$i++] and $array[++$i]).

Well, after the for cycle, here it is the while one. It can be used in two different ways:

<?php
	$found = false;
	while($found == false) {
		if( // condition //) $found = true;
		else // do something else //
	}

	do {
		// some code here
	} while($found == false);
?>

As you can see, the while cycle will continue untill the parameter will return TRUE (if $found is false, “$found == false” will return true!). In the first case there may be no iteration at all (if $found is true from the beginning, no iteration will be done). In the second case there will be at least one iteration, because the check is at the end of the cycle and not at the beginning.
ATTENTION: the while cycle (as all the cycles) may go in a “loop”, which is a state in which the cycle will run forever. PHP is designed to stop this kind of scripts, but it may load your CPU and RAM before stopping.

switch: is used to execute some code depending on a variable’s value. An example is far more easy to understand:

<?php
	$myvar = //something dynamically got //;
	switch($myvar) {
		case 0:
			// do something //
			break;
		case 1:
			// do something else //
			break;
		default:
			// if none of the cases are respected,
			// the switch cycle will execute this part.
			break;
	}
?>

Let’s start explaining the code: the structure is switch($variable) { cases here }. Cases may be all the types of variables but not arrays, so numbers (integers, floats…), strings (single characters, phrases) and so on. There are no graphs delimiting the cases, but it’s used the function “break”, which will break indeed the cycle. If you leave the cases without the break in the end, all the functions under the “succesfull” case will be run (which isn’t what you would expect from a switch cycle). The default case is optional, and it’s the code executed when the value is not one of the scripted cases. In this case, whenever of the default case should miss, nothing will be executed.

foreach: used to iterate for each element of a pluri-dimensional array. This is an example:

<?php
	$data = array(
		0 => array(
			"var1" => "a",
			"var2" => "b",
			"var3" => 6,
		),
		1 => array(
			"var1" => "g",
			"var2" => "T",
			"var3" => 0,
		)
	);

	foreach($data as $case) {
		echo $case['var1'];
	}
?>

The syntax is foreach($variable as $newname). In this way you’ll be able to access to the elements of an array variable in a more confortable way instead of doing some maybe difficult while or for cycles (in case of strings as array indexing –> $array["my index 1"]). In this way $newname will be a new array (or value in case of mono-dimensional arrays), which will have the same behaviour of the mother array, but it will have the values of the internal arrays and not all of them. It’s normally used to access to XML files (see Data storage: read an XML file for further informations about it).

For example here it is what $newname will be at the first iteration:

$newname = array(
	"var1" => "a",
	"var2" => "b",
	"var3" => 6,
);

Which is the sub-array with index 0 of the mother $data.

It’s the most complicated cycle to understand, but indeed is pretty simple when you’ve understood it.

You all know what I’m talking about. If you don’t, we’re going to discover how to get the data sent by the “comment form”, where you can leave a comment on this article!

Let’s start from the HTML code. We’re going to make a form to get a name, an email, a password and a comment (it’s just an example to explain the various types of data ^^).

<form action="myphpfile.php" method="POST">
	<table>
		<tr>
			<td>Your name:</td><td><input type="text" name="name" size="15" /></td>
		</tr>
		<tr>
			<td>Your password:</td><td><input type="password" name="pwd" /></td>
		</tr>
		<tr>
			<td>Your email:</td><td><input type="text" name="email" /></td>
		</tr>
		<tr>
			<td>Your comment:</td>
		</tr>
	</table>
	<textarea name="comment" cols="40" rows="5"></textarea><br />
	<input type="submit" value="Send comment" />
</form>

Ok, here we go! As you’ve seen, I used the “POST” method. The action is the page “myphpfile.php”. Note that you can use the same PHP page to show the form and to analyze the data. In this case the action will be simply “?”. You can use the POST method too, but you’ll use a different global variable (we’ll see it in a moment). Since this isn’t an HTML tutorial, I hope it’s understandable what I’ve written since here ^^.

You can send the same data to the same PHP file linking it in this way (you’ll use the GET method):

<a href="myphpfile.php?name=Giacomo&pwd=blablabla&email=me@mynet.com&comment=cool">My link</a>

As you can see, the GET method is not designed to send complex data. Also remember that HTML forms (both GET and POST methods) use plain text to send the data, thus I suggest you to implement a java encoder BEFORE the password and/or other sensible data are sent. We may speak about this in another tutorial.

Let’s see the myphpfile.php lines of code:

<?php
	// method: GET --> $_GET['variable_name']
	// the variable name is the "name" tag of the form's input
	$name = $_POST['name'];
	$password = $_POST['pwd'];
	$email = $_POST['email'];
	$comment = $_POST['comment'];

	// let's secure our variables
	$name = htmlspecialchars($name);
	$password = htmlspecialchars($password);
	$email = htmlspecialchars($email);
	$comment = htmlspecialchars($comment);

	if(myLoginFunction($name,$password,$email) == true) echo $comment;
	else echo "Wrong login! You must log in to comment this tutorial!";
?>

Here it is the trick: the form you made is able to send data between it and a PHP code. PHP can handle this type of data with the global arrays (that are variables!) $_GET (in this case) and $_POST.

A note about web security: htmlspecialchars()
htmlspecialchars($input) will prevent a user to post malicious code, like JavaScript, PHP or HTML code. This won’t alter the accented words (àèìòù, äëïöü and so on). This function will change the tags for example from > into ?&gt; which is harmless for the HTML code.
If you want to substitute also accented characters, you’ll need to use the function htmlentities($input), we can say an “extension” of htmlspecialchars() function.

Do you have any question? ^^

Variables are what you’re going to integrate to your website. Variables are strings, numbers, arrays… and they can (must, I may say) interact with each other in order to output the desired result.

Let’s start from numbers: the most common variable types are integers and floats (decimal numbers). But, as said before, variables aren’t declared but in their implementation, while in C or other languages you have to specify the type during the declaration (which you can omit it in most of the cases in PHP). Numbers can interact with each others with the normal operators + (plus), – (minus), * (multiplier), / (divisor), % (rest). The last one will output the rest of a division, while the division will return an integer.

Numbers can be mixed: in this case you’ll create the most precise type, depending on your variables. For example an integer plus a float will return a float. This can be avoided casting the type of the result. No, we’re not going to make a film, it’s simply a way to force a type of a variable . You can cast a type just preceding the operation with the type of the desired variable in rounded parenthesis.

<?php
	$anInteger = (integer)4+5.001; // will be 9
	$aFloatNumber = (float)4+5; // will be 9.000
?>

Easy, wasn’t it?

Well, now speak a little bit about strings: they have an entire class of functions. You can know their lenght, you can capitalise them, lowerise them, take a substring, know where is the first occourrance of a substring and so on.
To concatenate two different strings we use the dot operator, not the plus one.

<php
	$string1 = "Hello";
	$string2 = "World";
	$string3 = $string1." ".$string2."!";
?>

I don’t have the time to spend lots and lots of words about the string functions, they’re a lot! You can find the list of functions (with detailed description) here. The most important thing to understand is that a string is an array of characters. What is an array? A series of data, united under the same variable’s name. So, when for example you want to take the first three characters of a string you have to “select” object 0, 1 and 2 (arrays by the way start from 0). Here is an example:

<?php
$abc = substr("abcdefghijklmnopqrstuwxyz",0,3); // arguments are: original string, starting point (negative values will be considered from the end of the string), optional lenght of the substring
?>

What about arrays? Well, they’re a more advanced variable, I’ll try to explain them with some examples, the best way to do it in my opinion. You have to know that arrays are indexed. This means that you can find a value in an array just calling its index. Index may be automatically generated by PHP, or manually set. To automatically generate the index, you don’t need to specify the index itself. But here are some examples:

<?php
	$array1 = array(1 => "a", 2 => "b", 3 => "c");
	$array2 = array(); // in this case I declare it first because some strict settings of PHP may print a warning in the next function
	if(!in_array("abc",$array2)) $array2[] = "abc"; // In this case the index is automatically generated
	$array3 = array("Riccardo" => 22, "Diego" => 46, "Elena" => 33); // Yes it's not kind to tell the age of a madame, but it's a totally casual ^^

	echo $array1[2]; // b
	echo $array2[0]; // abc
	echo $array3["Diego"]; // 46
?>

As you saw from the example, to call the variable at a certain index you use squares. You can add new variables to the existing arrays also “pushing” the variable with array_push(), and “pop” the array (eliminating the last variable in the array) using… uhm… array_pop()? ^^

Now make practice with the functions of strings, numbers and arrays, see you in the next tutorial!

PHP is based on functions. Without functions you couldn’t combine and express your variables. So it can be defined as the hinge of PHP.

As you may correctly think, functions “do something”. Starting from the easiest “print” to the more complex socket opening or image generation.

First of all: all the functions require arguments, from zero up to a lot of them. Functions are called in this way:

function(arg1, arg2, arg3);

Arguments are variables which can be defined “on the fly” or previously set and then put as them. For the first example, I’m going to print two strings, equals to each other, in these two different ways:

<?php
$welcome = "Hello World!";
print("Hello World!"); // direct
print($welcome);
?>

By the way, // means a comment on a single line while /* comment here */ means a comment in multi lines.
In this case the print function requires one argument, which can be an integer, float, array, string… it doesn’t matter, PHP is cool . As you can see the potential of PHP is to get a data, edit it, combine it with other data, recollect other informations and output the final code. In this way you can just imagine the dynamic potentials of PHP versus a static HTML web page.

Some functions require some arguments as the others do, but sometime they may be able to accept extra arguments. They’re set by default and thus can be omitted in the function call, but can be changed if necessary. An example of these functions is fsockopen, which is able to open a connection to another server (i.e. for pinging a game-server or to establish a plain text / binary transmission between two services… don’t bother about it (for now)!):

resource fsockopen ( string $hostname [, int $port= -1 [, int &$errno [, string &$errstr [, float $timeout= ini_get("default_socket_timeout") ]]]] )

<?php
$web = fsockopen("php.elegosproject.org");
$ftp = fsockopen("php.elegosproject.org",21);
?>

If I want to know if something goes wrong, I may specify $errno and $errstr, two variables that are set in case of errors, but this function is very complex, it was just an example on how optional arguments work ^^.

So, functions may edit variables, but most commonly they return something. For example the function rand, saw for the first time in the ABC of PHP article, returns an integer (which is a number).

Generally in other program languages, like C, when you create a function you have to declare what type of variable will return. In PHP there is no need to do it, as all the variables are treated in the same way!

To create a function you have simply to… write it! just with this structure:

<?php
function myFunction($myArg1, $myArg2, $myArg3) {
// my operations here
return $myVariable; //can also not return at all, in that case omit this line 
}
?>

1. Functions require arguments, but if your function requires no arguments, simply leave the parenthesis void -> function myFunction()
2. All the code of the function is closed in the graphs {}: it’s a separate environment, and thus you won’t be able to use local variables declared in the main body of your script, but only global ones (like $_SERVER, $_POST, $_GET and so on) and local ones declared in the function (or arguments passed to the function, but pay attention: they are only COPIES of the original variables!).
3. A function may return something. In this case, “return $whatToReturn” will be written, generally at the end of the function: in fact nothing of the function will be processed after the “return line”, so pay attention!

Here is an example of a very stupid function:

<?php
function getNameSurname($name,$surname, $sex="m") {
if(strtolower($sex) == "m") $title = "Mister";
else $title = "Missus";
return $title." ".$name." ".$surname;
}
$name = getNameSurname("Giacomo","Furlan");
print($name); // will print "Mister Giacomo Furlan"
?>

In this case the function will require $name and $surname. If $sex is not specified, male will be the default one. Strtolower is a function which makes a string all in lower case (easier to handle in these cases where case sensitivity is not required). Then the function concatenates the sex title, the name and the surname. Thus this function will return a string. The script will eventually call this function and echo the result. Easy, wasn’t it? (don’t bother about if else cycle, I’ll speak about it in another tutorial).

Before starting, here is a simple example:

<html>
	<head>
		<title>My first PHP code!</title>
	</head>
	<body>
		Hello! This is a plain HTML text. I can't modify it without editing the page itself! (even if I like the block notes  )<br />
		<?php
			$message = "Hello! This is a (potential) dynamic string!";
			$simpleNumber = 7;
			echo $message."<br /> I really like number ".$simpleNumber."!";
		?>
	</body>
</html>

This code will reproduce this output:

Hello! This is a plain HTML text. I can’t modify it without editing the page itself! (even if I like the block notes )
Hello! This is a (potential) dynamic string!
I really like number 7!

Let’s start explaining!

First of all, PHP means “Personal Home Page“. Yes, you read it correctly: it was initially designed to create simple and (specially) dynamic web pages. During its development PHP become a more and more popular web scripting language and today is one of the most used languages for internet applications, including classes support (PHP5), database access (MySQL but not only), file reading/writing and so on. To demonstrate the power of PHP you could even create an IRC bot with it! Because of its simplicity it’s also easy to understand and to learn.

As you may see in the codebox, PHP code is closed between “<?php” and “?>“. A more standard implementation of it would require “?php>” as the ending tag, but nowadays all the web servers recognise just “?>”. When you call this tag you won’t be able to use simple HTML code, you’ll need to “print” it if you want to use it in the “PHP space”.

Usually PHP is embedded in the HTML code. Please note that you can create an entire site using pure PHP and ignoring the HEAD and BODY HTML tags, but I allways suggest you to use them in order to produce a standard HTML web page: in fact PHP code will run server-side and will produce plain HTML code, because it’s the only code a browser will ever decode and show you correctly.

Web pages with PHP inside must be named with the extension “.php”: in this way the web server will recognise them and elaborate them; otherwise the web server will show the code instead of the desired output. Another requirement is that the web server handles PHP correctly: it’s usually written in the website of the hoster. A few italian free web hosting services I used (and still use) are Netsons and Altervista; find your free hosting on google!

All the commands are followed by a comma, this because it enables you to create complex commands in more than one line. Don’t worry, I too miss them sometimes! The PHP engine will warn you about them and stop executing the script.

Variables are all the parts in the code starting with $. There are several types of variables, from the local ones (just the ones you see in the code) to the global ones (like $_GET, $_POST or $_SERVER) which are defined by default in the PHP environment and you can’t modify them (but we’ll see them later in another tutorial). They are automatically recognised by the PHP engine: this means you can write a string (which is a text variable) without declaring it before (remember in C++? string sString = “blablabla”), you can save a number, a float (decimal int, i.e. 1.002) and so on “just writing it”.

To declare a variable use the “=” operator, to compare two of them (or one of them and a constant) you’ll use “==” in most of the cases.

<?php
	$integer = 6;
	$string = "bla bla bla";
	$float = 1.002;
?>

Let’s speak a little bit about strings: you can concatenate strings with other strings or numbers. The “magical” operation is made by the “dot operator” (.). In this way you can mix static with dynamic variables in order to create dynamic contents. In PHP you can mix strings with all the other types of variables. Here is an example:

<?php
	$string1 = "Hello ";
	$name = $_POST['name'];
	$random_number = rand(0,100);
	echo $string1.$name."! Here is your number: ".$random_number;
?>

As you can see here we’ve concatenated a local string ($string1), a global variable ($name, $_POST is taken from an HTML form (variable ‘name’) with method POST and as action the PHP page) and a number (rand is used to generate randomic numbers, it’s a function and we’ll see it in a moment). Of course there are several functions for strings, they’re the most elaborated variables of all PHP, I’ll dedicate an entire tutorial on them.

Numbers: as said before numbers can be integers, floats and so on. Just declare them as usual! (see the variables example code). You can sum, subtract, divide or multiply them with the standard operators: + (sum), – (subtraction), / (division), * (moltiplication). Nothing less, nothing more ^^

Functions: one of the most difficult things to “tame” in PHP. The most difficult part is indeed to know them, they’re as easy as breathing (you’ll say: this man is crazy!). You have just to make some practice!
Functions are piece of code pre-written for you. They may need arguments: they are contained in the parenthesis next to the function name. We have just seen an example of function: rand($int,$int). Rand is used to generate randomic numbers and requires two arguments: the minimal and the maximal number. You can see a list of function on the php.net website. Don’t worry about this: following my tutorials you won’t need to explore it (it’s HUGE!), in the future, if you’ll have to search for a function, you’ll know at least how it may be called the function and thus your search will be fast.

A particular function which needs an argument but not in parenthesis is echo: it requires a variable (of all the types), but just writing it after its calling:

<?php
	echo "Hello World!";
?>

Of course if it disturbs you, you can allways the more-standard function print, which has nothing different then the function above:

<?php
	print("Hello World!");
?>

As of my experience, echo is faster to write down and, using a highlighting program like Smultron* (for MacOS), NotePad++* (for Windows) or GEdit* / Kate* (for Linux) there is no risk to forget quotes opened. Honestly I started writing PHP with Adobe (Macromedia) Dreamweaver, but I suggest you to try writing directly the source, you’ll learn 200% faster!

What have you learnt since the beginning?

1. What PHP is and how it’s called within an HTML web page
2. How are variables declared
3. How to print them in the HTML document
4. How to interact with them
5. What functions are and how to use them
6. What programs to use to write in PHP

* they are all free and opensource, download them for free!

Now download a PHP editor (or just use the BlockNotes) and start practising!

Giacomo