Learn PHP: a PHP tutorial

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 environment XAMPP for beginners. It can be downloaded free of charge from Apache Friends for the operating systems Windows, Linux, and macOS.

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 MySQL or 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.

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.

Open your text editor of choice and enter the following PHP script:

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 the function phpinfo(). 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, ?>.

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.

Verwenden Sie einen anderen Webserver oder eine individuelle Konfiguration der XAMPP-Software, wählen Sie die URL dem jeweiligen Dateipfad entsprechend.

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.

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.

Have a go at creating your first script as a PHP file by using the following:

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!.

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:

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.

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:

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:

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.

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:

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.

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:

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:

You might be wondering what happens if you omit the quotation marks altogether. In these cases, PHP simply produces a syntactic error message.

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.

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 (\):

As mentioned above, the combination of single and double quotation marks also works:

But not two sets of single quotation marks:

In the above examples, the spaces between the quotation marks have been inserted for readability.

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:

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:

In this instance, we’ve combined three strings and two variables, concentrated together into a single command.

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:

The PHP interpreter is only interested in code that comes between an opening and closing PHP tag:

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:

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.

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 forward slashes (//). The following coding example features both methods:

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 (*/).

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.

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:

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.

For more complex calculations, we’ll need to combine different arithmetic operators in one script:

Bracketed terms are naturally also prioritized in PHP. Here’s an example of this, on this occasion using decimals for a more complex result:

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.

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:

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 (--):

An increase before and after output (pre- and post-increment) of a value can be explained in the following script:

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.

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:

http://hostname/folder/filename.php?variablenname=variablevalue

Transferring this to a blog will usually result in an appearance like this:

http://www.example-blog.com/index.php?id=1

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:

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.

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") and a 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:

User entries that are collected via the input field on page1.php will be called up by page2.php using the following formula:

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.

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 if gives 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:

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 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:

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.

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):

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 else according to the following formula:

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):

You can make a condition negative by using an exclamation mark (!) within the expression.

This example uses the condition $number1 == $number2 and the negation of this. !($number1 == $number2) corresponds to ($number1 != $number2).

A practical application of if and else 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:

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:

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.

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.

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.

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.

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

A while loop is the simplest type of loop that exists in PHP. Its basic syntax is as follows:

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:

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.

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:

If programmed as a do-while script, our previous script would now look like this:

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.

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.

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:

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:

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.

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:

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 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:

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.

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_APPEND parameter:

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: