PHP Tutorial

This tutorial covers essential PHP concepts, from installation to handling data and advanced operations. Each section provides code examples and explanations, so you’ll have a clear understanding of how PHP functions work as you code along.

Install PHP

To start using PHP, install it on your system. PHP is available via most package managers or the official PHP website.

# Install PHP on Ubuntu (Linux)
sudo apt install php

# Verify PHP version
php -v
    

After installation, you can start creating PHP scripts to execute PHP code on your local server.

PHP Code Structure

PHP code is enclosed within <?php ... ?> tags. Any code written within these tags will be interpreted as PHP. You can embed PHP within HTML for dynamic web pages.

< ?php
// Simple PHP block to output text
echo "Hello, World!";
?>
    

Echo vs Print

Both echo and print can output text to the screen. echo is slightly faster and is generally preferred when no return value is needed, while print returns 1, allowing it to be used in expressions.

< ?php
echo "Hello, ";      // Outputs: Hello, 
print "World!";      // Outputs: World!
?>
    

Variables & Constants

Variables in PHP start with a $ symbol and do not require an explicit type (PHP is loosely typed). Constants, defined with define(), are used for values that should not change.

< ?php
$greeting = "Hello, PHP!";
$year = 2023;              // Integer variable

define("PI", 3.14);        // Constant definition
echo PI;                   // Outputs: 3.14
?>
    

Scope & Variable Variables

PHP variables have local, global, or static scope. You can use the global keyword to access global variables within functions. Variable variables allow for dynamic variable naming.

< ?php
$globalVar = "I'm global!";

function scopeTest() {
  global $globalVar;
  echo $globalVar; // Accesses global scope
}

$varName = "message";
$$varName = "Hello!";  // Dynamic variable
echo $message;         // Outputs: Hello!
?>
  

Magic Constants

PHP provides predefined constants that change based on the context, such as the current file path and line number. These are known as magic constants.

< ?php
echo __FILE__;  // Outputs the current file's path
echo __LINE__;  // Outputs the current line number
?>
  

Data Types

PHP supports various data types, such as integers, floats, strings, and arrays. PHP is dynamically typed, so the data type of a variable can change at runtime.

< ?php
$intVar = 42;               // Integer
$floatVar = 3.14;           // Float
$stringVar = "PHP";         // String
$arrayVar = ["a", "b", "c"]; // Array
?>
  

Operators

Operators in PHP include arithmetic, comparison, and logical operators. Here are some examples of their usage.

< ?php
$a = 10; $b = 20;

// Arithmetic Operators
echo $a + $b;   // Outputs: 30

// Comparison Operators
echo $a == $b;  // Outputs: (false)
?>
  

Comments

Comments in PHP can be single-line (using // or #) or multi-line (using /* ... */).

< ?php
// Single-line comment
# Another single-line comment
/*
Multi-line comment
*/ 
?>
  

array_slice()

The array_slice() function allows you to extract a portion of an array. Here’s an example where we slice a subarray.

< ?php
$array = [1, 2, 3, 4, 5];
$sliced = array_slice($array, 1, 3);  // Result: [2, 3, 4]
?>
  

PHP Control Statements

Control statements in PHP allow you to control the flow of your code. This tutorial covers if-else conditions, switch cases, and different loop types with examples to illustrate each concept.

PHP If-Else Statement

The if statement executes a block of code only if a specified condition is true. Use else and elseif to handle alternative cases.

< ?php
$score = 85;

if ($score >= 90) {
  echo "Grade: A";
} elseif ($score >= 75) {
  echo "Grade: B"; // Outputs: Grade: B
} else {
  echo "Grade: C";
}
?>
  

PHP Switch Statement

The switch statement selects one of many blocks of code to be executed, based on a value. It’s often a cleaner alternative to multiple if-else statements.

< ?php
$day = "Wednesday";

switch ($day) {
  case "Monday":
    echo "Start of the work week";
    break;
  case "Wednesday":
    echo "Midweek";        // Outputs: Midweek
    break;
  default:
    echo "Another day";
}
?>
  

PHP For Loop

The for loop is used when the number of iterations is known. It has three parts: initialization, condition, and increment/decrement.

< ?php
for ($i = 1; $i <= 5; $i++) {
  echo $i . " ";  // Outputs: 1 2 3 4 5
}
?>
  

PHP foreach Loop

The foreach loop is specifically designed for iterating over arrays. It loops through each element, making it easier to access array values.

< ?php
$colors = ["Red", "Green", "Blue"];

foreach ($colors as $color) {
  echo $color . " ";   // Outputs: Red Green Blue
}
?>
  

PHP While Loop

The while loop executes a block of code as long as a specified condition is true. It checks the condition before each iteration.

< ?php
$count = 1;

while ($count <= 3) {
  echo $count . " ";  // Outputs: 1 2 3
  $count++;
}
?>
  

PHP Do-While Loop

The do-while loop is similar to the while loop but guarantees that the code inside the loop executes at least once, regardless of the condition.

< ?php
$count = 1;

do {
  echo $count . " ";  // Outputs: 1 2 3
  $count++;
} while ($count <= 3);
?>
  

PHP Break Statement

The break statement immediately exits the current loop or switch statement, allowing you to skip the rest of the code.

< ?php
for ($i = 1; $i <= 5; $i++) {
  if ($i == 3) {
    break;
  }
  echo $i . " ";  // Outputs: 1 2
}
?>
  

PHP Continue Statement

The continue statement skips the current iteration of the loop and proceeds to the next one, allowing you to avoid certain values or conditions.

< ?php
for ($i = 1; $i <= 5; $i++) {
  if ($i == 3) {
    continue;
  }
  echo $i . " ";  // Outputs: 1 2 4 5
}
?>
  

PHP Functions

Functions in PHP are reusable blocks of code that perform a specific task. This tutorial covers how to create functions, pass arguments, use default and variable arguments, and explore recursion.

Basic PHP Function

A basic function in PHP is defined using the function keyword, followed by a function name and a code block. Functions can be called anywhere in the code after they are defined.

< ?php
function greet() {
  echo "Hello, welcome to PHP!";
}

greet();  // Outputs: Hello, welcome to PHP!
?>
  

PHP Parameterized Function

Parameterized functions accept inputs, called parameters, which allow you to pass values into functions. You can define any number of parameters in a function.

< ?php
function greetUser($name) {
  echo "Hello, " . $name . "!";
}

greetUser("Alice");  // Outputs: Hello, Alice!
?>
  

PHP Call By Value

In Call by Value, a copy of the variable’s value is passed to the function. Any changes made inside the function won’t affect the original variable.

< ?php
function addTen($num) {
  $num += 10;
  echo $num;  // Outputs: 20
}

$value = 10;
addTen($value);
echo $value;  // Outputs: 10 (original value unchanged)
?>
  

PHP Call By Reference

In Call by Reference, a reference to the variable is passed, allowing the function to modify the original variable’s value.

< ?php
function addTen(&$num) {
  $num += 10;
}

$value = 10;
addTen($value);
echo $value;  // Outputs: 20 (original value modified)
?>
  

PHP Default Arguments

Default arguments allow you to set default values for function parameters. If no argument is passed, the default value is used.

< ?php
function greetUser($name = "Guest") {
  echo "Hello, " . $name . "!";
}

greetUser();           // Outputs: Hello, Guest!
greetUser("Alice");    // Outputs: Hello, Alice!
?>
  

PHP Variable Arguments

PHP supports variable arguments, allowing you to pass multiple arguments to a function by using ...$args. These arguments are accessible as an array.

< ?php
function sum(...$numbers) {
  return array_sum($numbers);
}

echo sum(1, 2, 3, 4);  // Outputs: 10
?>
  

PHP Recursive Function

A recursive function is a function that calls itself, useful for tasks that require repeated operations, such as factorial calculations.

< ?php
function factorial($n) {
  if ($n <= 1) {
    return 1;
  }
  return $n * factorial($n - 1);
}

echo factorial(5);  // Outputs: 120
?>
  

PHP OOPs Concepts

Object-Oriented Programming (OOP) in PHP introduces structure, reusability, and modularity. Core OOP principles like inheritance, encapsulation, and polymorphism make it possible to write maintainable and scalable code.

OOPs Abstract Class

An abstract class cannot be instantiated and is often used as a base class for other classes.

< ?php
abstract class Animal {
  abstract public function sound();
}

class Dog extends Animal {
  public function sound() {
    echo "Bark!";
  }
}

$dog = new Dog();
$dog->sound();  // Outputs: Bark!
?>
  

OOPs Access Specifiers

PHP access specifiers control access to class properties and methods with public, protected, and private.

< ?php
class Sample {
  public $publicVar = "Public";
  protected $protectedVar = "Protected";
  private $privateVar = "Private";
}
?>
  

OOPs Const Keyword

Use const for class constants, accessed with the :: operator.

< ?php
class Car {
  const WHEELS = 4;
  public function getWheels() {
    return self::WHEELS;
  }
}
?>
  

OOPs Constructor

The constructor is called when an object is created and is defined using __construct().

< ?php
class Car {
  public function __construct($model) {
    echo "Car model: " . $model;
  }
}
$car = new Car("Toyota");
?>
  

OOPs Destructor

The destructor __destruct() method is automatically called when the object is destroyed.

< ?php
class Car {
  public function __destruct() {
    echo "Object destroyed";
  }
}
?>
  

OOPs Inheritance

Inheritance allows classes to inherit properties and methods from other classes.

< ?php
class Vehicle {
  public function drive() {
    echo "Driving!";
  }
}

class Car extends Vehicle {
}

$car = new Car();
$car->drive();  // Outputs: Driving!
?>
  

OOPs Interface

Interfaces define methods without implementing them, enforcing a contract for implementing classes.

< ?php
interface Logger {
  public function log($message);
}

class FileLogger implements Logger {
  public function log($message) {
    echo "Logging message to file: " . $message;
  }
}
?>
  

OOPs Type Hinting

Type hinting specifies the expected data type of function parameters to improve type safety.

< ?php
function displayInfo(User $user) {
  echo $user->name;
}
?>
  

PHP Math and Math Functions

PHP provides a range of built-in math functions that simplify mathematical operations like rounding, finding maximum values, random number generation, trigonometric calculations, and more. Here’s a look at essential PHP math functions.

abs()

abs() returns the absolute value of a number, removing any negative sign.

< ?php
echo abs(-9);  // Outputs: 9
?>
  

round()

round() rounds a floating-point number to the nearest integer.

< ?php
echo round(3.6);  // Outputs: 4
echo round(3.4);  // Outputs: 3
?>
  

ceil() and floor()

ceil() rounds a number up to the next integer, while floor() rounds down.

< ?php
echo ceil(3.2);   // Outputs: 4
echo floor(3.8);  // Outputs: 3
?>
  

sqrt()

sqrt() calculates the square root of a number.

< ?php
echo sqrt(16);  // Outputs: 4
?>
  

pow()

pow() raises a number to the power of another number.

< ?php
echo pow(2, 3);  // Outputs: 8 (2^3)
?>
  

rand() and mt_rand()

rand() and mt_rand() generate random integers, with mt_rand() offering better performance and randomness.

< ?php
echo rand(1, 10);     // Outputs a random integer between 1 and 10
echo mt_rand(1, 100); // Outputs a random integer between 1 and 100
?>
  

max() and min()

max() returns the highest value among arguments, and min() returns the lowest.

< ?php
echo max(2, 3, 1, 7);  // Outputs: 7
echo min(2, 3, 1, 7);  // Outputs: 1
?>
  

rad2deg() and deg2rad()

rad2deg() converts radians to degrees, while deg2rad() converts degrees to radians.

< ?php
echo rad2deg(3.14);   // Outputs: 180
echo deg2rad(180);    // Outputs: 3.1415926535898
?>
  

sin(), cos(), tan()

PHP includes trigonometric functions like sin(), cos(), and tan() for calculations with radians.

< ?php
echo sin(deg2rad(30));  // Outputs: 0.5
echo cos(deg2rad(60));  // Outputs: 0.5
echo tan(deg2rad(45));  // Outputs: 1
?>
  

log() and log10()

log() returns the natural logarithm, while log10() returns the base-10 logarithm.

< ?php
echo log(1);       // Outputs: 0
echo log10(100);   // Outputs: 2
?>
  

exp()

exp() calculates e raised to the power of a number (exponential function).

< ?php
echo exp(1);  // Outputs: 2.718281828459
?>
  

PHP Forms and Form Handling

PHP enables form handling through the `GET` and `POST` methods, which allow data to be sent from HTML forms to the server. Forms are commonly used to capture user input, which can then be processed by PHP to store, manipulate, or display the information.

Creating a Basic HTML Form

A simple HTML form collects data from users. Here’s an example of a form with fields for name and email.

< form action="process_form.php" method="post">
  < label for="name">Name:< /label>
  < input type="text" id="name" name="name">
  < label for="email">Email:< /label>
  < input type="email" id="email" name="email">
  < button type="submit">Submit< /button>
< /form>
  

GET vs. POST Methods

Forms can use either the GET or POST methods to submit data. The `GET` method appends data to the URL, making it visible and suitable for non-sensitive data or bookmarking. The `POST` method sends data in the request body, making it more secure and ideal for handling sensitive information.

Handling Form Data with POST

Here’s an example of how to use PHP to handle form data submitted via `POST`. This code reads and displays user input.

< ?php
// process_form.php
if ($_SERVER["REQUEST_METHOD"] == "POST") {
  $name = $_POST['name'];
  $email = $_POST['email'];
  echo "Name: " . htmlspecialchars($name) . "
";
  echo "Email: " . htmlspecialchars($email);
}
?>
  

Handling Form Data with GET

Using `GET`, data is appended to the URL as query parameters. Here’s an example of retrieving data sent via `GET`.

< ?php
// process_form.php (using GET method)
if ($_SERVER["REQUEST_METHOD"] == "GET") {
  $name = $_GET['name'];
  $email = $_GET['email'];
  echo "Name: " . htmlspecialchars($name) . "
";
  echo "Email: " . htmlspecialchars($email);
}
?>
  

Validation and Sanitization

To prevent security risks, always validate and sanitize user input. PHP provides functions like filter_var() for sanitizing inputs, especially for emails, URLs, and integers.

< ?php
// Sanitizing and validating email
$email = $_POST['email'];
$email = filter_var($email, FILTER_SANITIZE_EMAIL);
if (filter_var($email, FILTER_VALIDATE_EMAIL)) {
  echo "Valid email: " . $email;
} else {
  echo "Invalid email format";
}
?>
  

PHP Include and Require

PHP’s `include` and `require` statements allow you to include code from one PHP file into another, making it easier to reuse code, organize files, and reduce duplication. These are fundamental for structuring PHP projects efficiently.

PHP `include` and `require` Basics

The `include` and `require` statements allow you to import code from other files. This is especially useful for shared components like headers, footers, or configuration files.

// Including a header file
include 'header.php';

// Requiring a configuration file
require 'config.php';
  

Difference Between `include` and `require`

The key difference is how PHP handles errors:

• include: If the file is missing, PHP shows a warning, but the script continues to run.
• require: If the file is missing, PHP shows a fatal error, stopping script execution.

// Using include
include 'non_existent_file.php'; // Shows warning, script continues

// Using require
require 'non_existent_file.php'; // Fatal error, script stops
  

Using `include_once` and `require_once

PHP provides `include_once` and `require_once` to ensure a file is included only once, preventing duplicate code. This is useful when including configurations or function libraries that should load only a single time.

// Ensuring the file is included only once
include_once 'config.php';
require_once 'functions.php';

Example: Modularizing a Website

Here’s a basic example of a modular PHP website structure, using `include` to add a header, footer, and navigation:

// index.php
include 'header.php';
include 'nav.php';

echo "< h1>Welcome to My Website< /h1>";
echo "< p>This is the main content area.< /p>";

include 'footer.php';

Each of these files (header, nav, footer) can contain HTML/PHP that applies to every page, making maintenance and updates easier.

Error Handling and Best Practices

• Use require for essential files, like configurations.
• Use include for non-critical parts, like templates, where the script can continue without them.
• Use include_once and require_once to avoid redundancy and potential conflicts.

State Management in PHP

PHP provides two primary mechanisms for managing state across multiple HTTP requests: Cookies and Sessions. These mechanisms allow you to store information temporarily, enabling your application to remember users and their activities. In this section, we will explore both techniques in depth.

PHP Cookies

A cookie is a small piece of data stored by the browser on the user's computer. It can store information such as user preferences, login credentials, or any other data that should persist across sessions. Cookies have an expiration time and are sent back to the server with each request.

Setting a Cookie

To set a cookie, you use the setcookie() function. The cookie is sent to the browser and can be accessed by the client-side for the specified duration.

// Setting a cookie in PHP
setcookie('user', 'JohnDoe', time() + 3600, '/'); // Expires in 1 hour

This will store a cookie named `user` with the value `JohnDoe`, which expires in 1 hour and is available to the entire website.

Accessing Cookies

// Accessing a cookie in PHP
if(isset($_COOKIE['user'])) {
echo 'Hello, ' . $_COOKIE['user'];
} else {
echo 'Cookie not set!';
}

You can check if the cookie exists using isset() and access its value via the $_COOKIE superglobal.

Deleting a Cookie

// Deleting a cookie in PHP
setcookie('user', '', time() - 3600, '/'); // Expire the cookie immediately

To delete a cookie, set its expiration time to a past date. This effectively removes it from the user's browser.

PHP Sessions

A session is a way to store information on the server-side that can be accessed across multiple pages. Unlike cookies, which store data on the client-side, sessions store data on the server, making them more secure for sensitive information.

Starting a Session

Before using a session, you must call the session_start() function at the beginning of your PHP script. This function initializes the session and allows access to the session variables.

// Starting a session in PHP
session_start();

Storing Session Variables

After starting a session, you can store data in the $_SESSION superglobal array, which will persist across multiple pages as long as the session is active.

// Storing a session variable
$_SESSION['username'] = 'JohnDoe';

This stores a session variable `username` with the value `JohnDoe`, which can be accessed across pages.

Accessing Session Variables

// Accessing a session variable
session_start(); // Start the session
echo 'Hello, ' . $_SESSION['username'];

Access session variables by using the $_SESSION superglobal. You must call session_start() at the beginning of each page to access the session data.

Destroying a Session

To destroy a session, use the session_destroy() function. This removes all session data.

// Destroying a session in PHP
session_start();
session_unset(); // Remove session variables
session_destroy(); // Destroy the session

The session_unset() function removes all session variables, while session_destroy() ends the session completely.

Cookies vs Sessions

- Cookies are stored on the client-side (in the user's browser) and can persist across multiple visits.

- Sessions are stored on the server-side and are temporary, ending when the user closes the browser or the session is destroyed.

Sessions are more secure for storing sensitive data, as the information is not accessible from the client-side. Cookies are more suitable for persisting non-sensitive data across requests.

PHP File Handling

File handling is a crucial aspect of many web applications. In PHP, working with files involves performing various operations like opening, reading, writing, and deleting files. This guide will help you understand these file operations step by step with examples.

PHP Open File

To open a file in PHP, you use the fopen() function. It allows you to open a file for reading, writing, or appending. The function returns a file pointer resource, which is used for subsequent file operations.

// Open a file for reading
$file = fopen("example.txt", "r"); // 'r' mode opens the file for reading

The modes you can use with fopen() include:

• 'r': Open the file for reading.
• 'w': Open the file for writing (creates a new file if it doesn't exist, or truncates the file to zero length).
• 'a': Open the file for writing (appends to the end of the file).
• 'r+': Open the file for both reading and writing.

PHP Read File

Once a file is opened, you can read its contents using functions like fread(), fgets(), or file_get_contents() for reading the entire file at once.

// Reading the entire file
$fileContents = file_get_contents("example.txt");
echo $fileContents;

Alternatively, you can read the file line-by-line:

// Read a file line by line
$file = fopen("example.txt", "r");
while(!feof($file)) {
echo fgets($file) . "<br>";
}
fclose($file);

In the above code, we use fgets() to read the file line-by-line until we reach the end of the file with feof().

PHP Write File

To write to a file, you can use the fwrite() function. The file must be opened in write mode ('w', 'w+', 'a', or 'a+').

// Writing to a file
$file = fopen("example.txt", "w");
fwrite($file, "Hello, this is a new text!");
fclose($file);

This will overwrite the content of the file with the string provided. If you want to append to the file instead of overwriting it, use the 'a' mode:

// Appending to a file
$file = fopen("example.txt", "a");
fwrite($file, "Adding more text.");
fclose($file);

PHP Append File

To append data to an existing file, you open the file in append mode ('a' or 'a+'). This allows new content to be added to the end of the file without overwriting the existing data.

// Append to a file
$file = fopen("example.txt", "a");
fwrite($file, "Appended text.");
fclose($file);

In this example, the content "Appended text." will be added to the end of the file without affecting the current contents.

PHP Delete File

To delete a file, use the unlink() function. This will permanently remove the file from the filesystem.

// Delete a file
if (unlink("example.txt")) {
echo "File deleted successfully.";
} else {
echo "Error deleting the file.";
}

The unlink() function returns true if the file is successfully deleted and false if there is an error (e.g., if the file doesn't exist).

PHP MySQLi

PHP MySQLi (MySQL Improved) is an extension for working with MySQL databases. It provides a more secure and feature-rich method of interacting with MySQL databases compared to the older MySQL extension. In this guide, we will go through the common MySQLi operations in PHP, including connecting to a database, creating databases and tables, and performing CRUD operations (Create, Read, Update, Delete).

MySQLi CONNECT

To connect to a MySQL database using MySQLi, you use the mysqli_connect() function. It requires four parameters: host, username, password, and database name. If the connection fails, it returns false.

// Connect to MySQL Database
$connection = mysqli_connect("localhost", "username", "password", "database_name");

if (!$connection) {
die("Connection failed: " . mysqli_connect_error());
}
echo "Connected successfully";

MySQLi CREATE DB

To create a new database in MySQL, use the CREATE DATABASE SQL statement. With MySQLi, you can execute this query using the mysqli_query() function.

// Create a Database
$sql = "CREATE DATABASE myNewDB";
if (mysqli_query($connection, $sql)) {
echo "Database created successfully";
} else {
echo "Error creating database: " . mysqli_error($connection);
}

MySQLi CREATE Table

To create a table in an existing database, use the CREATE TABLE SQL statement. This is executed with the mysqli_query() function.

// Create a Table
$sql = "CREATE TABLE users (
id INT(6) UNSIGNED AUTO_INCREMENT PRIMARY KEY,
firstname VARCHAR(30) NOT NULL,
lastname VARCHAR(30) NOT NULL,
email VARCHAR(50),
reg_date TIMESTAMP
)";
if (mysqli_query($connection, $sql)) {
echo "Table created successfully";
} else {
echo "Error creating table: " . mysqli_error($connection);
}

MySQLi INSERT

To insert data into a table, use the INSERT INTO SQL statement. You can use mysqli_query() to execute the query.

// Insert data into Table
$sql = "INSERT INTO users (firstname, lastname, email)
VALUES ('John', 'Doe', 'john.doe@example.com')";

if (mysqli_query($connection, $sql)) {
echo "New record created successfully";
} else {
echo "Error: " . $sql . "
" . mysqli_error($connection);
}

MySQLi UPDATE

To update existing records in a table, you use the UPDATE SQL statement.

// Update existing data
$sql = "UPDATE users SET email='john.new@example.com' WHERE id=1";

if (mysqli_query($connection, $sql)) {
echo "Record updated successfully";
} else {
echo "Error updating record: " . mysqli_error($connection);
}

MySQLi DELETE

To delete records from a table, you use the DELETE FROM SQL statement.

// Delete a record from Table
$sql = "DELETE FROM users WHERE id=1";

if (mysqli_query($connection, $sql)) {
echo "Record deleted successfully";
} else {
echo "Error deleting record: " . mysqli_error($connection);
}

MySQLi SELECT

To fetch data from a database, use the SELECT statement. You can fetch the result using mysqli_query() followed by mysqli_fetch_assoc() to retrieve individual rows.

// Select data from Table
$sql = "SELECT id, firstname, lastname FROM users";
$result = mysqli_query($connection, $sql);

if (mysqli_num_rows($result) > 0) {
while($row = mysqli_fetch_assoc($result)) {
echo "id: " . $row["id"]. " - Name: " . $row["firstname"]. " " . $row["lastname"]. "
";
}
} else {
echo "0 results";
}

MySQLi Order by

The ORDER BY clause is used to sort the results of a query in ascending or descending order.

// Select data from Table with ORDER BY
$sql = "SELECT id, firstname, lastname FROM users ORDER BY firstname ASC";
$result = mysqli_query($connection, $sql);

// Display results
while($row = mysqli_fetch_assoc($result)) {
echo "id: " . $row["id"]. " - Name: " . $row["firstname"]. " " . $row["lastname"]. "
";
}