PHP is a server-side interpreted open source script language that is most commonly used for the creation of dynamic web content. This acronym originally stood for ‘Personal Home Page Tools’, but today is commonly used as a shortened version of ‘PHP: Hypertext Preprocessor’.
While client-side languages like HTML, CSS, or JavaScript are only interpreted by the web browser during web page loading, a PHP code is already running on the web server. Here, the PHP generates HTML content that is passed onto the web browser. As a result, this content doesn’t contain a code (the PHP script), but instead just receives the results of the coding.
The central application area of PHP is in server-side programming. The main focus is the generation of dynamic web pages and apps. Other application uses include the writing of desktop applications as well as command-line programming. Despite its beginner-friendly syntax, PHP offers an impressive range of functions. The scripting language supports a wide variety of databases, can be used across multiple platforms, and is subject to a specific PHP license that allows open usage and editing of the source code. The combination of these three factors makes PHP an impressive tool.
Four of the most popular content management systems, namely WordPress, TYPO3, Joomla!, and Drupal, are based on PHP. And the combined reach of these top CMSs means that the PHP scripting language is used for an astounding 82.3% of all web pages on the World Wide Web, according to market analysis from W3Techs (Findings accurate as of: 18th November 2016). This makes PHP the most popular server-side programming language by some distance when it comes to web development. And this information alone is reason enough for anyone interested in web development or website management to become familiar with the options that PHP: Hypertext Preprocessor has to offer.
Our PHP tutorial will help take you through the initial steps, to give you an insight into server-side programming. However, some examples that we’ll be exploring will assume a fundamental knowledge of web development. And if HTML is new to you, it’s also a good ideal to get to know this language first, too.
The quickest way to learn PHP with this tutorial will be to follow the examples given here in real time on your own computer and tailor them to the needs of your web project. All that you need for server-side programming with PHP is a web server that includes a PHP interpreter, a text editor (e.g. Notepad++ or Vim) and a web browser. When it comes to choosing a server, we’d recommend the local test environmentXAMPP for beginners. It can be downloaded free of charge from Apache Friends for the operating systems Windows, Linux, and macOS.
Tip
PHP Hosting from IONOS enables you to benefit from the best features of the latest PHP version. If you have any questions, your personal consultant is always on hand to help.
Before you can start running PHP scripts, you’ll first need a web server that’s capable of interpreting the scripting language. This will also need to be equipped with what’s known as a PHP interpreter. An interpreter is a software component that’s able to identify the passages within a file that contains PHP code – in other words, it can understand the PHP language. Fortunately, PHP is typically supported by all modern web servers, and its corresponding interpreter is included in the PHP download package. The latest version of this PHP package is available from the project’s official website, php.net, and can be downloaded free of charge.
As a rule, your PHP interpreter will be integrated via a server module or as a FastCGI. The use of an interpreter as a CGI program isn’t recommended as it will affect performance. An industry-standard practice is to combine PHP with the Apache HTTP Server. If this connection is extended with one of the database systems MySQLor MariaDB, then, depending on the operating system used, they form what’s known as either a LAMP (Linux), WAMP (Windows), or MAMP. Web stacks like this are often offered as a pre-configured bundle package.
For this PHP tutorial, we recommend you use the complete package XAMPP. This includes a local installation on the Apache web server, including the database system MariaDB as well as the scripting languages Perl and PHP. To help with this, we’ve compiled an extensive installation guide as part of our XAMPP tutorial on the IONOS Digital Guide.
Warning
XAMPP is purely a test server. The software bundle offers web developers the opportunity to create a complete testing environment for scripts, HTML pages, and style sheets in as short a time as possible. There is no guarantee that it will function securely as a web server online. For this reason, XAMPP should only be used locally. This means that you should ensure there’s no online access to your XAMPP services.
PHP basics: the syntax of the scripting language
Once you’ve set up your local web server (i.e. with the help of XAMPP), you should check to make sure that PHP was correctly installed and is ready to create scripts.
Definition
a script is usually a small computer program that isn’t constructed in advance using binary code. Scripts are written in one of several programming languages like PHP, Perl, or JavaScript, and are read by an interpreter on the web server (server side) or an engine in the web browser (client side).
Open your text editor of choice and enter the following PHP script:
<?php
phpinfo();
?>
A text editor like Notepad++ supports you in programming with syntax highlighting
PHP scripts are always built in the same way. The opening PHP tag<?php signals that a script environment is being started. This is then followed by the actual PHP code in the form of an instruction. So in our example above, this was a command to start thefunctionphpinfo().Most functions require one or more parameters that are included within the brackets; with phpinfo(), this is actually optional: phpinfo( INFO_ALL ). Every command ends with a semicolon (;). When you want to close a script environment, you’ll need to include the PHP closing tag, ?>.
Definition
Functions are subprograms that enable you to outsource parts of the program code. To avoid redundancy, tasks that recur often can be defined once as a function and then called into command with use of the function name. Web developers also make use of pre-defined PHP functions or create their own subprograms.
Save the text file under the name test in the format .php (PHP script) and start your web server. If you’re using the test environment XAMPP, save your test.php in the XAMPP folder under htdocs(C:\xampp\htdocs).
You can save your test.php file in the htdocs folder of your XAMPP installation
The example file can now be loaded in your web browser via the following URL: http:// localhost/ test.php. If you’re using a different web server or an individual configuration of the XAMPP software, you can find your URL by following the respective file path.
http://localhost/test.php
Verwenden Sie einen anderen Webserver oder eine individuelle Konfiguration der XAMPP-Software, wählen Sie die URL dem jeweiligen Dateipfad entsprechend.
Warning
While internet addresses use a forward slash (/) as a separator for levels, the Windows Explorer uses a backward slash (\). Modern web browsers usually convert backward slashes to forward slashes automatically, too.
By entering the URL http:// localhost/ test.php, you’ll be commanding your web browser to request the file test.php from the web server. The Apache HTTP server (or the web server software you’ve chosen) will retrieve the file from the appropriate folder.
The ending .php confirms that the file contains a PHP code. This alerts the web server’s integrated PHP interpreter. The interpreter parses the document and reads the opening PHP tag <?php, which informs it of the start point for the PHP coding. The interpreter then works its way through the PHP code and presents the results in HTML format, which is subsequently delivered from the web server to the web browser.
If the PHP has been correctly installed, then you should now be able to see your script execution in the form of a web page like below:
If a script is created using the function phpinfo(), the browser will reveal information about the PHP configuration
The function phpinfo() is a shortened version of the standard command phpinfo( INFO_ALL ). This command gives detailed information about the PHP configuration of your web server. If no PHP version can be located, then your web browser will display an error message or simply deliver the PHP code to the browser without interpreting it.
‘Hello World!’ – How to add text using the echo command
If PHP has successfully installed without errors, then it’s time to write your first script. To do so, you’ll need to use the echo command. Unlike phpinfo(), echo isn’t a function command. Instead, it should be thought of as a language construct enabling the string of information to be displayed in text format.
Definition
Language constructs are commands that are used in PHP to control the programming sequence. There are several forms of language construct, including echo, if, for, do, include, return, exit, and die. Unlike functions, these commands don’t require brackets.
Have a go at creating your first script as a PHP file by using the following:
<?php
echo 'Hello World!';
?>
The opening tag <?php will start the scripting environment. The language construct echo then follows, with the actual text string Hello World! enclosed in quotation marks. The tag ?> then closes the script. Don’t forget about the semi colon in the command. You can follow our example or customize it with a different expression than Hello World!.
Definition
The term ‘string’ is used in IT to describe a collection of characters of variable length – usually in the form of a chain of letters, numbers, and special characters. In programming, strings are regarded as a standalone data type and are differentiated from other types of data like integrators or floats.
Save your script in the htdocs folder of your web server under the title hello.php and open the file in your web browser via the URL http:// localhost/ hello.php. If you created the code correctly, then your browser window should now display the following page:
The language construct echo informs the web server to display the phrase Hello World! on the screen
Every text that you create with echo can be extended with HTML tags. These will be interpreted by your web browser based on the HTML specification included. Try it yourself by running the following script:
<?php
echo '<h1>Hello World!</h1>
<p>This is my first PHP page.</p>';
?>
If you follow the same procedure as before and open the file in the web browser, you should see the following result displayed:
If your script contains HTML tags, they will be automatically interpreted like this by your web browser
The <h1> tag for the string Hello World! will automatically be interpreted by your browser as a top heading. This is then followed by an automatic line break and the indicator for a text paragraph <p>.
The echo command can be used with a simple single quotation mark (‘) as well as with the double quotation marks (“). If you’re just planning to add straightforward text then it won’t make a huge difference which of these quotation marks you choose to use. Things only change here when variables come into play.
Variables
The language construct echo has more functions to offer than just the replication of text. This can also be implemented to great effect without PHP, using HTML as a basis. But the true added value of echo is in the dynamic generation of texts using particular variables in combination with the function.
PHP users might come across variables in the following form:
$example
Every variable consists of a dollar sign ($) followed by the name of the variable. Variables are used in PHP scripts to integrate external data into web pages. These variables can cover many different types of values – from simple numbers and character strings, to entire texts or HTML document structures.
PHP has 7 different forms of variable:
Variable Types
Description
String
A string is a collection of characters. It can be presented in the form of a word, a sentence, a text, or even the HTML coding for an entire web page.
Integer
An integer is a whole number without decimal places. This can be positive or negative.
Float
A float is a numerical value with decimal places included. The decimal point is displayed just as a normal decimal would be (e.g. 12.914). PHP can support up to 14 decimal places.
Boolean
Boolean variables are the result of a logical operation and can only have two values: TRUE and FALSE. This type of variable is used when you’re working with conditions.
Array
An array is a variable that can contain multiple elements. Simply put, it’s a grouping of several similarly structured data files that have been combined to form one entry.
Object
The object variable type enables programmers to define their own types of data. This is typically used for object-oriented programming. In this PHP tutorial for beginners, we’ll be disregarding object variables as they’re a more advanced technique.
NULL
The NULL value represents variables that have no value. For NULL variables, this is the only possible value.
The central management of content is usually controlled by the database system, but values for variables can also be defined directly in the script. This type of command is carried out like this:
$example = "value";
The dollar sign indicates a variable, and is then followed by the type of variable (in this case example). The equals sign (=) then indicates the value of the variable.
Warning
Values for variables in the form integer and float forms are written without quotations marks (e.g. $example = 24; or $example = 2.7;)
PHP gives you the freedom to name variables at your own discretion. There are just a few restrictions that apply:
Every variable must begin with a dollar sign
All variable names must be made up of any combination of letters, numbers, and underscores (e.g. $example_1)
A valid variable name must always begin with a letter or an underscore (VALID: $example1 or $_example), but never with a number (INVALID: $1example)
PHP is case-sensitive. The scripting language differentiates between lower case and upper case characters ($example ≠ $Example)
The variable name may not include any spaces or line breaks (INVALID: $example 1)
Titles that are reserved for other purposes within PHP can’t be used as user-defined variables (e.g. $this)
Let’s look at an example:
<?php
$author = "John Doe";
echo "<h1>Hello World!</h1>
<p>This dynamic web page was created by $author.</p>";
?>
After the open PHP tag, we’ve defined our variable: Whenever $author is used, it should be understood as the value John Doe. Then, when we come to write our script, the variable $author will be replaced by the value John Doe for every single use throughout the script itself. The following graphic demonstrates how this will look when displayed in the web browser.
The result of our script with the variable $author acting in place of the value John Doe, as displayed in the web browser
If a mistake has been made, and it turns out that our web page wasn’t created by John Doe at all, but instead by his German colleague Max Mustermann, then all we need to do is redefine the value for the variable $author to correct the error.
The variable $author is defined here with the value Max Mustermann
The benefit and efficiency of this becomes increasingly evident the more often a variable appears in a script. If, for example, the author’s name appeared 20 times throughout our whole script, then using $author would mean that we’d only need to change the value of this variable once to change the name of the author for all 20 instances in the script, making alterations much easier and quicker to manage.
This is the biggest strength of PHP: Content can be included in the form of variables. This feature is the foundation of dynamic web development. Unlike static web pages, which are already available as pre-prepared HTML pages, dynamic web pages are instead generated as a page is in the process of being called. This means the PHP interpreter loads individual elements of the whole web page using variables from different databases and compiles them into a customized HTML page.
The advantage of this design concept is obvious: If certain elements of a website (e.g. the website footer) need to be changed, then this adjustment doesn’t need to happen for every single web page within the website project. Instead, you can just update the corresponding entry in your database. Once this is done, the new variable value for your website footer will be instantly visible across all pages of your website.
If a variable is defined multiple times within a script, then the latest definition is taken for all information moving forward.
<?php
$author = "John Doe";
echo "<h1>Hello World!</h1>
<p>This dynamic web page was created by $author.</p>";
$author = "Max Mustermann";
echo " <p>Supported by $author.</p>";
?>
The value John Doe is overwritten here by the new value Max Mustermann
In the coding example, the variable $author is initially attributed to the value John Doe and then subsequently altered to stand for the new value Max Mustermann.
Now let’s explore quotation marks further. Unlike with strings, individual variables don’t need to be enclosed in quotation marks themselves:
<?php
$author = "John Doe";
echo $author;
?>
So, what happens if your variable is meant to appear within a string? In this case, you can work with double quotation marks (“). This signals to the PHP interpreter that it should first search the string for variables, as these may have to be replaced by other, previously defined values. Strings enclosed in single quotation marks (‘) are interpreted and rendered as pure text information, even if they contain variables. You can try this yourself:
<?php
$author = "John Doe";
echo '<h1>Hello World!</h1>
<p>This dynamic web page was created by $author.</p>';
?>
Single quotation marks are used for purely text content. Variables won’t be interpreted.
You might be wondering what happens if you omit the quotation marks altogether. In these cases, PHP simply produces a syntactic error message.
Error messages and masking
When it comes to syntactic errors, there’s no valid PHP code and the PHP interpreter will simply produce an error message. If, for example, we were to code an echo statement but omitted the quotation marks around the string, as below, then we’d expect to receive an error message.
<?php
echo Hello World!;
?>
In most cases, error messages contain information about where the error occurred, meaning that you can locate and eliminate it.
An error message here indicates syntactic errors in the program code
In the above example, the program has detected an error in line 2 of our program code – which is exactly where we left out the quotation marks to demonstrate.
Syntactic errors also occur when you want to create text using certain character combinations that are associated with a specific task in PHP. One example of this would be if you wanted to display single quotation marks (‘) in your actual text output. The quotation marks within this string will only be interpreted as quotation marks in the displayed text if you make it clear to the interpreter that the characters have been relieved of their defined task. When you’re using single quotation marks, there are two ways to deal with this: You can either enclose a string that features single quotation marks with another set of double quotation marks, or you can mask the single quotation marks with a pre-defined backward slash (\):
<?php
echo '\'Hello World!\' ';
?>
If characters are masked with a backward slash, they won’t perform their pre-defined functions in PHP syntax, meaning you can see them displayed in text format.
As mentioned above, the combination of single and double quotation marks also works:
<?php
echo " 'Hello World!' ";
?>
But not two sets of single quotation marks:
<?php
echo ' 'Hello World!' ';
?>
In the above examples, the spaces between the quotation marks have been inserted for readability.
String Operators
If you want to use several variables within a PHP script at the same time, you can do so fairly easily, as we’ve already seen:
<?php
$author1 = "John Doe";
$author2 = "Max Mustermann";
echo "<h1>Hello World!</h1>
<p>This dynamic web page was created by $author1 and $author2.</p>";
?>
Simple write both variables, together with the rest of the text, inside a string encased by double quotation marks. PHP automatically recognizes the use of variables thanks to the dollar sign ($) and replaces the values accordingly.
Variables in strings will only be accepted by PHP if the script doesn’t contain any functions
However, as far as programming is concerned, this is considered to be quite messy work. In fact, it’s considered dogma that variables should never be part of strings. One reason for this is that many programming languages demand a separation between the two. But even more important is the fact that PHP requires separation of string and variables when it comes to function calls or more complex variables. It’s recommended to implement this separation consistently from the beginning, even in cases of pure text output, because this will help discipline your approaches for more complicated coding in the future.
When working with variables, we’re always having to deal with several separate elements that require linking together for output. In PHP, this means making use of a string operator.
If we were programming the same example above but in a ‘clean’ way, it would need to look as follows:
<?php
$author1 = "John Doe";
$author2 = "Max Mustermann";
echo '<h1>Hello World!</h1>
<p>This dynamic web page was created by ' . $author1 . ' and ' . $author2 . '.</p>';
?>
String operators connect strings and variables
In this instance, we’ve combined three strings and two variables, concentrated together into a single command.
String1
Variable1
String2
Variable2
String3
'<h1>Hello World!</h1>
.
$author1
.
' and '
.
$author2
.
'.</p>'
<p>This dynamic web page was created by '
The link between the separate strings and variables is the string operator, the dot. It should be noted that string operators connect strings and/or variables without spaces. To include a spare, you’ll need to do so within the quotation marks, as in our example above.
Programmers don’t just use string operators to link strings and variables for text output – they’re also used to extend variables themselves. The following example demonstrates how this is possible:
To extend the value of a variable, we can first define this, before then redefining it with the string ‘dot’ operator (.) before the equals sign. This enables the new variable to account for both the previous definitions together: $example = $example . 'World'.
PHP responds by adding the new value to the previously defined value. If you want to add a space between the two values, include this at the end of the first string, as in the example code.
Our example shows how you can extend the variable Hello to the new variable Hello World
Embed PHP into HTML
The PHP interpreter is only interested in code that comes between an opening and closing PHP tag:
<?php [Dieser Bereich wird vom PHP-Interpreter geparst] ?>
All other parts of the document will be ignored by the interpreter and handed over to the web server exactly as they are. This means that PHP code can be integrated into HTML documents – to create a template for a content management system, for example. It’s important to make sure that HTML documents containing PHP code are stored as PHP files – otherwise the document won’t be processed by the PHP interpreter, and will instead be delivered directly to the web browser – meaning that the programming code is displayed on the website as a coding text.
To help you remember this, think of the PHP interpreter as your web server’s lazy colleague, who will only work when explicitly told to do so – in the form of a file saved in PHP format, which includes an opening and closing PHP tag.
If you want to combine HTML and PHP, you should write your HTML page as usual according to the classic document structure and save it as a .php file:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>My first PHP page</title>
</head>
<body>
<h1>Hello World</h1>
<p>What is the current time and date?</p>
</body>
</html>
Now, you can expand your HTML document with a PHP script. Make sure that you include the PHP opening and closing tags around the PHP program code.
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>My first PHP page</title>
</head>
<body>
<h1>Hello World</h1>
<p>What is the current time and date?</p>
<p>Your current time and date is:
<?php
echo date("d.m.Y H:i:s");
?>.</p>
</body>
</html>
In the above example, we’ve used the language construct echo in combination with the function date(), in order to display the current date and time in text format on the server side. The parameter of the function offers the desired format in the form of a string:
When the web browser requests this file, the PHP interpreter will first process the script and write the current date and time into the HTML document in text format. This is then delivered from the web server and displayed in the form of a web page in the browser.
This HTML document contains an integrated PHP script that provides the current date and time.
The PHP comment function
Just as in HTML code, PHP allows you to include comments. Comments in the source code will be ignored by the PHP interpreter, as long as they have been marked according to the syntax. PHP gives you three different ways to do this.
If you want to mark an entire line as a comment and stop it from being interpreted, you can use the hashtag(#) or two consecutive forwardslashes (//). The following coding example features both methods:
<?php
#This is a single-line comment!
echo '<h1>Hello World!</h1>
<p>This is my first PHP page.</p>';
//This is also a single-line comment!
?>
The text editor Notepad++ highlights comments in green. The sections marked as comments in the text coding do not appear in the web browser – unlike HTML comments – as they’ve already been ignored by the PHP interpreter during the script execution.
By marking lines as comments, you can see them highlighted in green and make sure they don’t appear in the web browser
The above example is of single-line comments, but you also have the option of adding comments that stretch across multiple lines. To do this, simply mark the start of the comment section with a forward slash, followed by an asterisk (/*), and the end with the reversed order of an asterisk followed by a forward slash (*/).
<?php
/*
This is a multiple-lines comment block
that spans over multiple
lines
*/
echo '<h1>Hello World!</h1>
<p>This is my first PHP page.</p>';
?>
The whole area between the /* and the */ will be viewed as a comment, meaning it won’t be parsed by the interpreter and won’t appear on the web page.
The comment in our PHP coding spans multiple lines, but remains unparsed and so doesn’t display on the website
Programmers use comments to structure the source code of their scripts, to leave notes for later editing, or to create internal information, such as the author of particular sections, or the date that certain sections were finished.
Comments are optional and should be used sparingly to ensure your source code remains legible.
Making calculations with variables
By now, you should be fairly familiar with how to input variables. So far, we’ve only looked at variables that are assignd to string values. We’re now going to turn our attention to variables that represent integers or floats.
If variables store numeric values, then PHP offers you the ability to perform calculations with these variables. We’ll start by looking at a simple addition of two integer variables:
We start by defining the variables $number1 and $number2 as the respective integers 237 and 148. Then we define the addition of these two variables to be the value for the variable $result, using our arithmetic operator for addition, the plus symbol (+). This means that $result will always display the result of $number1 and $number2, even if we change the value of these two numbers. Then, we can use the language construct echo to explain this result in text format. Note that we don’t need quotation marks when assigning numeric values to variables.
The result of our addition can be displayed in the web browser using PHP
The following code example shows a selection of mathematical calculations that can be performed using PHP on the server side. The operations largely correspond to the standardized symbols for mathematics.
The PHP interpreter will read the variables in the coding above and calculate the following equation:
2 * 10 + 5 * 5 - 3 * √81 = 20 + 25 – 27 = 18
The function sqrt() calculates the square root of the number contained within the brackets. PHP follows the classic mathematical rules of BODMAS when calculating equations. Once again, we’ve used the echo statement to display the result as a string for the web browser.
PHP can perform multiple complex equations using BODMAS
Bracketed terms are naturally also prioritized in PHP. Here’s an example of this, on this occasion using decimals for a more complex result:
PHP calculates 2*(2.5+5)*(3.7-3)*√81 and gives the result 94.5
Like all modern programming languages, PHP also offers operators that can increase or decrease values by 1. The different options here are pre-increment operator, the pre-decrement operator, the post-increment operator, and the post-decrement operator.
Operation
Operator
Result
Pre-increment
++$number
The operator ++ increases the value of the variable $number. This will increase its value by 1. The result will be presented as a new value for $number.
Pre-decrement
--$number
The operator -- decreases the value of the variable $number. This will decrease its value by 1. The result will be presented as a new value for $number.
Post-increment
$number++
The current value for $number is first restored and then increased by 1.
Post-decrement
$number--
The current value for $number is first restored and then decreased by 1.
Next we will look at how these calculations with increment and decrement operators in an example. The following script will increase the value of the variable $number by 1, store the new value as the variable $result, and lastly present the value as a string:
By increasing the value 0 by 1, we’re of course left with the result: 1.
The operator ++ increments 0 by the value 1
To calculate the pre-decrement of the variable $number, we can use basically the same script, simply substituting the pre-increment operator (++) for the pre-decrement operator (--):
By doing this, we’ve successfully decremented the value 0 by the value of our variable $number, leaving us with the result -1.
The operator – decrements our value 0 by the value 1
An increase before and after output (pre- and post-increment) of a value can be explained in the following script:
<?php
$x = 0;
echo '<p>Result: ' . ++$x;
echo '<br>x has the value ' . $x;
echo '<p>Result: ' . $x++;
echo '<br>x has the value ' . $x, '</p>';
?>
This highlights the difference between the two approaches, as they will produce different results. The pre-increment operator will increase the value of x before the output in line 3, while the post-increment operator will do so after the output in line 5.
Pre- and post-increment operators compared
The superglobals $_GET and $_POST
At this stage, we’ve talked about the basics of PHP, discussed how to implement variables, link them in strings, and calculate equations. Next, we’ll show you why variables are such a central concept in the programming of scripts.
An important function in scripting languages is the option to evaluate user input and transfer these values into another script. When it comes to this data transfer, PHP relies on the superglobals$_GET and $_POST – predefined system variables that are available in all scopes of application. $_GET and $_POST store a set of variables in the form of strings in a variable, known as associative arrays.
You should think of these arrays like a wardrobe with several drawers. Each drawer gives you the opportunity to store data. To make sure you know what’s being stored in each drawer, you can label these with a variable name. Depending on the type of array, this can either be an index or a key. While indexed arrays require an index in the form of a number for each drawer, the drawers of associative arrays are labelled with a key in the form of a string.
The superglobals $_GET and $_POST contain a range of variables in the form of keys that enable you to utilize the values associated with these keys. We’ll explain this in further detail as we take a closer look at the different superglobals $_GET and $_POST individually.
Data transfer via $_GET
The superglobal $_GET depicts an array of variables that are given to a PHP script with the help of a URL. If you regularly visit blogs, online shops, or internet forums, you might have noticed the strange URLs you encounter on these types of site. Usually, the structure of the URL follows the pattern below:
A URL like this can be broken down very easily: On the web server with the domain example-blog.com, there’s a file by the name of index.php that is used to create a dynamic web page. This would typically contain HTML and PHP code as well as references to outsourced template files and external style sheets – in short, everything that you need for a fully operational web page to display. It’s probably a dynamic web page in this instance, because of the additional (?): id=1. This is known as an HTTP query string and contains a variable (id) and a value (1), connected by an equals sign (=). URL parameters like this are used, for example, to generate a dynamic web page, load content from a database, or call up a suitable template.
Dynamic web pages enable you to separate content and presentation. So, while the index.php contains all the necessary information about the structure of a website, it needs to be filled with content as well. This content is usually found in a database and can be called up using the parameters in the HTTP query string. In our example, the URL gives the index.php the parameter id=1. This determines which content is to be read from the database and loaded in the index.php. As far as weblogs are concerned, this usually means the ID for a particular article. In forums, this will usually be a particular entry, and with online shops it will generally represent a particular product.
If a URL contains more than one parameter, this will usually be connected using the ampersand symbol (&).
www.example-blog.com/index.php?page=article&id=1
To illustrate the use of $_GET in a coding example, we’ve simplified things to demonstrate it without a database. In the following script, we’ve used the superglobal $_GET to read the variables forename and surname from an HTTP query string and to write them into the PHP variables $variable1 and $variable2:
Calling up this script is done using the following URL:
localhost/hello.php?forename=John&surname=Doe
By doing this, we’ve assigned the parameters forename=John and surname=Doe. Once again, the language construct echo is used to produce the values in text format for display.
The URL parameters give the PHP script the variable values forename=John and surname=Doe
A data transfer with $_GET inevitably leads to the transferred data being visible in the address bar. This means it’s always possible to understand and register the parameters that are being transferred. This has the advantage that variables can be stored in the form of hyperlinks. Internet users also have the option of bookmarking certain URLs with their HTTP query string in their browser.
The downside to using the GET parameter in clear sight as displayed in the URL is obvious: it’s not a method that can be used for transferring sensitive data, such as the results of online forms. Additionally, the amount of data that the $_GET method can transfer is limited by the maximum length of URLs.
These limitations can be avoided by using the HTTP method POST. The data that’s transferred using this method can be found in the superglobal $_POST.
Data transfer via $_POST
While data transfers are made via URL parameters with the GET method, information is transmitted in the body of an HTTP request with $_POST. This enables developers to transmit very large amounts of data from one script to another without difficulty.
A central application field for the HTTP POST method is the transfer of HTML form data. We’ll demonstrate this by showing you how to construct your own newsletter sign-up form.
Create a new PHP file with the name page1.php and write out the following code block inside it:
When creating a form like above, you’ll need to use the HTML element <form>. This contains two primary attributes: method and action. The method attribute defines the transmission method, so in this case, HTTP POST. The action attribute stores the URL of the script that receives all the data collected by the input fields listed. The example shows an HTML form with three input elements (input type="text")anda send button (input type="submit"). The file page2.php is defined as the recipient of the data.
To illustrate the data transfer using $_POST, we’ve used a simple script to evaluate the form data, one that stores the transmitted values as PHP variables and outputs them in text form. To do this, create a file called page2.php and copy out the following program code:
<?php
$forename = $_POST["forename"];
$surname = $_POST["surname"];
$email = $_POST["email"];
echo "Hello " . $forename . " " . $surname . ", <br />
You are registered with the following email address: " . $email . ".";
?>
Store both your PHP files in the htdocs folder of your test server and call up the page1.php via the following URL in the web browser:
. Your browser should now show you the interactive web interface for your HTML form.
The HTML form page1.php contains user data and sends this to the script with the address page2.php
Enter any registration data you like and click on the submit button to send variables from one script to the other. As soon as you’ve confirmed submission of data on page1.php, you’ll be automatically forwarded to page2.php. The browser window shows the results of the script execution based on the data that’s been transferred.
Our data transfer using the HTTP POST method has been transmitted and presented using the language construct echo
User entries that are collected via the input field on page1.php will be called up by page2.php using the following formula:
$_POST["Name of the input field"]
For example, the entry $forename = $_POST["forename"] will retrieve the input for the input field forename and store this as the variable $forename. The variable $forename can then be outputted in text format using the language construct echo.
The if construct and the PHP comparison editors
So far, we’ve defined what variables are, looked at how to transfer them from one script to another, and demonstrated how to present them as string. In this next section, we’ll show you how to execute certain fragments of code depending on certain conditions.
The language construct ifgives you the option to write scripts with commands that only come into place after a certain pre-defined condition is fulfilled – such as a correct password entry, for example.
Conditions can be defined in PHP using the following basic framework:
<?php
if(expression)
{
statement;
}
?>
This comes with the following consequence: the statement will only be executed once the condition in the expression has been fulfilled. A condition is only considered to be fulfilled once the if construct has produced the result TRUE. Any other result will be listed as FALSE. In these cases, the command will simply be ignored.
Generally speaking, the if construct checks whether or not the value of a variable corresponds to the value defined in the condition. This control structure is normally carried out using comparison operators.
Comparison operators
Comparison operators are used to formulate conditions. They assess two arguments in a logical relationship that can be evaluated as TRUE or FALSE. If comparison operators are used in a PHP control structure, they’re applied to two variables in the expression of an if construct:
if ($a == $b)
{
statement;
}
To put this into words, the control structure is basically saying: If variable $a is the same as variable $b, then the command defined by statement will be executed.
The PHP comparison operators are based on the programming language C and often make use of some of the classic mathematical symbols. Here’s an overview of the most common ones in the table below.
Comparison Operator
Description
Function
==
Is the same as
The condition is fulfilled when $a and $b have the same value.
===
is identical to
The condition is fulfilled when $a and $b have the same value and belong to the same type of data. This is best explained with an example. Here, we’ll compare the integer (1) with a string (“1”): 1 == "1" //TRUE and 1 === "1" //FALSE. For conditions that require two variables to be completely identical, always make sure you use the comparison operator === (is identical to).
!=
is not the same
The condition is fulfilled if $a and $b have unequal values.
!==
not identical
The condition is fulfilled if $a and $b have unequal values or are different types of data.
<
Is smaller than
The condition is fulfilled if the value of $a is smaller than the value of $b.
>
Is bigger than
The condition is fulfilled if the value of $a is bigger than the value of $b.
<=
Is smaller or the same as
The condition is fulfilled if the value of $a is smaller than the value of $b or if the two variables have the same value.
>=
Is bigger or the same as
The condition is fulfilled if the value of $a is bigger than the value of $b or if the two variables have the same value.
The following script should help to explain these control structures. To do so, we’ll be comparing two integers. As our comparison operator, we’ve chosen to go for < (is smaller):
<?php
$number1 = 10;
$number2 = 20;
if($number1 < $number2) {
echo "The condition is fulfilled";
}
We’ve defined the variables $number1 and $number2 using the values 10 and 20 respectively. In the next line, we’ve stipulated our condition: If $number1 is smaller than $number2,then the echo command should display the string value ‘The condition is fulfilled’.
The result of the script execution contains an answer: 10 is smaller than 20. This means that the if construct will give the result TRUE. The condition is fulfilled.
Since our condition has been fulfilled, the echo command will be executed.
If you want to define commands that should only be executed provided that a condition is not fulfilled. you can extend the if control structure with the language construct elseaccording to the following formula:
<?php
if(Condition a)
{
Command b;
}
else
{
Command c
}
?>
This script will also check whether the condition a has a TRUE or FALSE result. If condition a is fulfilled (TRUE), then command b will be carried out.
But if condition a isn’t fulfilled (FALSE), then command b will be skipped and command c executed instead.
Let’s extend our script with the else construct and switch our comparison operator from < (is smaller) to == (is the same):
<?php
$number1 = 10;
$number2 = 20;
if($number1 == $number2)
{
echo "The condition is fulfilled";
}
else
{
echo "The condition is not fulfilled";
}
?>
This time, the if construct has returned a FALSE result. The value of the variable $number1 isn’t equal to the value of the variable $number2. The condition isn’t fulfilled. As a result, the first if command will be overridden and the else command executed instead.
Since our condition has not been met, the command defined by else is executed instead.
Warning
If the execution of a code fragment relies upon the equality of two values, then you need to ensure you use the double equals sign in PHP (==). The single equals sign (=) can only be used when assigning values to variables.
You can make a condition negative by using an exclamation mark (!) within the expression.
<?php
$zahl1 = 10;
$zahl2 = 20;
if ($zahl1 == $zahl2)
{
echo "Die Zahlen sind gleich.";
}
if (!($zahl1 == $zahl2))
{
echo "Die Zahlen sind nicht gleich.";
}
?>
This example uses the condition $number1 == $number2 and the negation of this. !($number1 == $number2) corresponds to ($number1 != $number2).
A practical application of if andelse could be in the use of password queries based on an HTML form. We’ll simulate this now with the help of our PHP files page1.php and page2.php.
Open page1.php and enter the following formula code:
<form action="page2.php" method="post">
Please enter your password: <input type="password" name="password" />
<input type="submit" value="Submit" />
</form>
The structure of this is similar to the form we’ve created before. But this time, we’re adding an input field: the password query. Just like before, user input is passed to the page2.php script. Now we can include the following code to ensure that the password entered by the user is matched with a stored password:
<?php
$password = $_POST["password"];
if($password=="qwertz123")
{
echo "The password was correct";
}
else
{
echo "The password was incorrect";
}
?>
The code reads as follows: First, we’ve assigned the variable $password in line 2 to a value that we’ve called up via the HTTP POST method. Next, we’ve defined the following control structure: The if construct in line 3 is designed to check whether the value of the variable $password agrees with the string qwertz123. If this is the case, then the string The password was correct will be displayed. But if the if result comes back as FALSE, then the else condition in line 7 comes into action, and so the string The password was incorrect is presented.
The HTML form prompts the user to enter his/her password.
The browser presents us a web display version of our HTML form asking for a password entry. We’re now required to enter the password defined in script page2.php, qwertz123, and then click on the submit button.
The script confirms that we’ve entered the correct password.
The web browser will automatically load page2.php. Behind the scenes, the if control structure has reviewed the password we entered and reached the conclusion that ‘qwertz123 == qwertz123 is TRUE’, meaning the string The password was correct has been produced and displayed in the browser.
To prove this works, check your password submission coding by entering an incorrect password into the input field and seeing what happens when you press submit.
Logical operators
Conditions that are defined through the expression of an if construct with the help of comparison operators can be linked to other conditions within the same expression if required. PHP supports this with the logical operators AND and OR.
Higher precedence
Lower precedence
Description
&&
AND
Both conditions that are connected by the logical operator have to be TRUE.
//
OR
Only one of the two conditions connected by the operator has to be TRUE.
To link conditions, PHP provides logical operators with both higher and lower precedence. On the whole, if you use just one of either the higher or the lower precedence logic operator for your chosen form, you won’t notice a difference. But if you combine both ways of writing the logical operator, you’ll find that OR and // have higher precedence than AND and OR. While AND and && have a higher precedency than OR and //. This is comparable to the operator rank order of BODMAS that exists in mathematics.
We can return to the password query again for a practical example of how this works. In general, login data doesn’t just feature a secret password; this usually has to be paired with a username as well. It’s only when both entries are deemed to match the data stored within the system that a login is successful.
We’ll open our formula for password requests in page1.php again and extend it with an input field for a username:
Now, we need to change the next few steps to make sure that the control structure for our if construct meets our new requirements. Let’s use the logical operator AND link the condition for the password query to the condition for username query.
<?php
$username = $_POST["username"];
$password = $_POST["password"];
if($username=="John Doe" AND $password=="qwertz123")
{
echo "Welcome to the internal area " . $username . "!";
}
else
{
echo "Access denied";
}
?>
Our script page2.php now receives the values for username and password, and stores these as the variables $username and $password. The expression of the if construct contains two conditions that are connected with the logical operator AND. It’s only when both conditions are fulfilled (username=="John Doe" and $password=="qwertz123") that the if construct will return a TRUE result.
Since we want to enter a username in the input field username, we can use it directly for the text output via echo: Welcome to the internal area is followed directly by the variable $username.If either of the conditions goes unfulfilled, the text output will simply read: Access denied.
Only when both the conditions are fulfilled will our script accept the correct password entry and display the positive echo result.
Logical operators can be combined as desired. This is when important precedence rules come into play: AND has a higher operator rank position than OR. If you want to change this, you can use brackets in PHP just the same way as you can in mathematical equations to influence the ranking of precedence.
Loops (while, for)
Sometimes it’s necessary for a script to run a particular section of code several times before the rest of the programming code is executed. In programming-speak, this is known as a loop. There are three different types of loop:
while loops
do-while loops
for loops
while loops
A while loop is the simplest type of loop that exists in PHP. Its basic syntax is as follows:
while (expression)
{
Loop step and other instructions
}
The while loop instructs PHP to execute other, subordinate instructions for as long as the while condition is fulfilled. To do this, the PHP interpreter checks the condition at the beginning of each loop run. The execution of the subordinate code will only stop once the while expression is no longer fulfilled.
This principle can be showcased easily with the use of a straightforward number counting script:
To do this, we’ve returned to the principle of incrementing values that we previously introduced during the section ‘calculating with variables’. Building on this tool, we’re using a post increment operator to increase the value of the integer variable $number by 1 in the text output echo after each loop pass. The condition for the while loop is defined: $number must remain the same as or smaller than 10. The echo command will continue to repeat its task until the $number variable reaches a value higher than 10.
Our script has incremented the variable $number by 1 each time, until it reached a value greater than 10.
The result of the script execution is a string that produces the value of the variable $number at the completion of every loop before it’s incremented. Because of our condition, the script counts from 1 to 10 and then ends the coding sequence because the while expression is no longer fulfilled.
do-while loops
The structure of the do-while loops is very similar to that of the while loop. The only difference is that the condition isn’t checked at the beginning of each loop cycle; it’s simply checked at the end. The basic syntax for a do-while loop is as follows:
do {
Loop steps and other instructions
}
while (condition)
If programmed as a do-while script, our previous script would now look like this:
<?php
$number = 1;
do {
echo $number++ . "<br />";
}
while ($number <= 10);
?>
The result remains the same in our example. But the special thing about do-while loops is that they will run at least once even if the condition isn’t passed in any of the loops.
for loops
The basic idea behind a for loop in PHP scripting is the same as the while loop. However, unlike the while or do-while loops, the for loop features a start value, condition, and statement recorded within one row rather than over three or more rows. This means that the syntax for a for loop looks like this:
for (Start value; Condition; Loop steps)
Statement
Returning to the same example again, we can document it in a compact format as a for loop like so:
We’ve now defined the variable $number with the value 1. Next, PHP will check whether the condition $number <= 10 has been fulfilled. Provided this is the case, the loop will continue and the commands underneath the loop will be executed (in this case, the echo instruction). The loop is then repeated; in this example, it doesn’t make a difference whether you select a pre- or post-incrementing operation, because the command will always be executed before output. Once the loop step is closed the next loop cycle begins.
Start value, condition, and loop step are optional elements of a for loop. Theoretically, even empty loops are possible (although these would be redundant).
It’s basically up to you whether you write PHP scripts with a for loop or a while loop. But there is one argument for using for loops as your main method of looping: When you use for loops, you have a better view of the data for the loop. This prevents the risk of accidentally writing a forever loop that continues running until the interpreter’s memory is full. This could happen if you forgot to increase the value of the variable $number, for example.
If the loop just needs to run at least once, regardless of the conditions, then the do-while loop is the loop of choice.
break and continue
The course of a while-, do-while or for loop can be influenced by the break and continue command. The break instruction can be used to interrupt the course of a loop at a designated point, and continue can skip a loop pass and restart a loop once more. Both statements are bound to a condition through the if command. The following example demonstrates how to use a number counting script with a break:
<?php
for ($number = 1; $number <= 10; $number++) {
if ($number == 5) {
echo "The script stops at 5";
break;
}
echo $number . "<br /> ";
}
?>
In the for loop, we’ve set the definition that the value of the variable $number to start at a value of 1 and to increase by a value of 1 for every loop until the variable reaches the value of 10. We’ve also set the condition that the loop should stop running at the command break, which will come into play as soon as the $number variable reaches the value 5. Because of this, the language construct echo will only produce the numbers 1 to 4.
The break command interrupts the loop as soon as the if condition is fulfilled.
If we only want to stop the script for the fifth round, but then continue the loop afterwards, we can replace the command break with continue:
<?php
for ($number=1; $number <= 10; $number++) {
if ($number == 5) {
echo "We skip number 5!<br />";
continue;
}
echo $number . "<br /> ";
}
?>
Instead of the fifth number, PHP displays our defined text string We skip number 5! instead.
The for loop is interrupted by a continue command.
File operators
Dynamic web content is created because of a separation between content and presentation. Scripting languages like PHP offer various functions to enable you to load content from external data sources in central template files. These data sources are usually databases that can be managed via management systems like MySQL. To learn more about how this works, check out our MySQL tutorial for beginners.
There’s also the option of embedding data from files. In the next section, we’ll show you how to include files as part of a string in your PHP script and how to store your script’s text output in files.
Reading files into an array
There are a few different functions in PHP that allow you to read content from a file. For the purpose of our tutorial, we’re going to focus on file()and file_get_contents().While the function file_get_contents() reads all of the content of a file into a string, the function file() stores content as an array. Each element of the array corresponds to one line of the file. Meanwhile, using file() makes it easier to output each line individually.
We’ll demonstrate the PHP file operators for the text file example.txt, which we’ll store in the htdocs folder of our test server. The contents of this file are four lines of text:
Lorem ipsum dolor sit amet, consectetuer adipiscing elit.
Aenean commodo ligula eget dolor. Aenean massa.
Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus.
Donec quam felis, ultricies nec, pellentesque eu, pretium quis, sem.
The text file example.txt in the htdocs folder
Now, let’s read the whole file in as a string. To do so, we’ll need to use the function file_get_contents() ,with the name of the corresponding file within the brackets. This should look as follows:
file_get_contents(‘example.txt')
We now have the chance to work with our new string. We could, for example, define it as a variable and output it as text in the web browser:
Our file is successfully read and displayed in the browser.
The browser display shows us that the text string is outputted as one solid paragraph. The line breaks in the original file are no longer visible. This is because the web browser has interpreted the text output of the script as an HTML code. This means that breaks defined in the text editor are lost.
There are a few options available to us if we want to keep our original structure. We could enter the HTML coding for a line break (br) in the file manually using the Find and Replace tool, add a <pre> to set the file content, and then add the gaps with the CSS command white space, assign pre-wrap, or use the function nl2br(), to signal to PHP that line breaks (new lines) should be automatically carried out in HTML line breaks (breaks). This works using the following syntax:
If the language construct echo is used in combination with nl2br(), then PHP includes an HTML line break before every new line.
The nl2br() function helps you to structure data read into PHP.
If you want to output lines of a file individually, then you can do so with the function file(). This reads a file in, numerates all lines starting at 0, and stores their content as elements of an array. By transferring our example to this function, we can see the following organization:
[0] = Lorem ipsum dolor sit amet, consectetuer adipiscing elit.
[1] = Aenean commodo ligula eget dolor. Aenean massa.
[2] = Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus.
[3] = Donec quam felis, ultricies nec, pellentesque eu, pretium quis, sem.
To output this content using echo, all we have to do is enter the line number we want. For example, the following script provides just the first line of the example.txt file for our browser:
You can choose which element of the array you want to output.
Write files
PHP doesn’t just let you read out files. The scripting language also gives you the option to create files and write them with content.
For this, we’ll use the PHP function file_put_contents(). This requires two parameters: The name of the file that is to be created or updated as well as the data in the form of a string or an array. The following script will create the file test.txt and write the string This is a test! in the first line. The addition of \r\n executes a line break in the target file.
<?php
file_put_contents("test.txt", "This is a test! \r\n");
echo "test.txt was created!";
?>
The PHP script writes the string This is a test! in the file test.txt.
Since file_put_contents doesn’t deliver an output for the browser, we need to add an echo statement to show the action taken in the browser.
If a file with the same name already exists in the target folder, it will be automatically overwritten. To prevent this, you can set the FILE_APPENDparameter:
<?php
file_put_contents("test.txt","The test was successful! \r\n", FILE_APPEND);
echo "test.txt was updated!";
?>
If we use file_put_contents() with the parameter FILE_APPEND, new content will be added to the already existing content.
The PHP script has successfully updated the test.txt with the string The test was successful!
You don’t have to define what PHP writes in the target file in the script. Alternatively, you have the option to transfer content from one file to another. The following script reads the content from example.txt and inputs it in the file test.txt:
CodeIgniter – The lightweight of the PHP frameworks
Web development
CodeIgniter is an open-source PHP framework developed by EllisLab that is currently under the patronage of the British Columbia Institute of Technology. The slim software is based on an MVC architectural structure, offers detailed documentation, and is praised for its performance. We present the makeup, structure, and application flow of the CodeIgniter framework with detailed code examples and...
The Python logging module: How to locate script errors
Web development
Python logging is a module in the Python library. Since it is integrated into the source code, developers can use several commands to carry out Python logging to file, i.e. create a log file and send notes to this file that are logged when an application runs. Python logging can be used, for example, for code debugging or error communication.
PHP 8: What you need to know about the latest version
Web development
PHP is one of the most important languages on the Internet. Many content management systems like WordPress, TYPO3 or Joomla are based on PHP. With the release of PHP 8, various new features were introduced. Also some old features were reworked, meaning that errors may occur if the code is not up to date. You can find all the important information about the new features of PHP 8 here.
PHP vs. Python – the two programming languages compared
Web development
In the PHP vs. Python battle, every developer probably has a favorite. Both programming languages have a large following and are among the best options on the market. Here, you can find out what differences and similarities the two have, where their strengths and weaknesses lie, and for whom PHP and Python are recommended.
The mail extension PHPMailer is particularly useful when it comes to contact forms on websites and sending automatically generated emails. We’ll show you how to install and send emails with PHPMailer. It’s easy to do. In our article, we’ll also be looking into which features are available for emails as well as PHPMailer examples. Read on for more.
As a web developer you’ll need to install PHP on your device sooner or later, but how do you do that? We have put together this step-by-step guide to make it easier for you to install this popular scripting language. Find out which PHP version is the right one for you in our article. It explains everything you need to know.