PHP Programming for Beginners

First Edition
Sarful Hassan
Preface
Welcome to PHP Programming for Beginners! This
book is designed to be a comprehensive and
accessible guide to PHP, one of the most popular
server-side scripting languages for web development.
Whether you’re a complete novice to programming or
looking to add PHP to your skillset, this book aims to
provide a clear, step-by-step introduction to building
dynamic web applications using PHP.
Who This Book Is For
This book is intended for absolute beginners in
programming who want to learn PHP. If you have a
basic understanding of HTML and want to enhance
your web development skills by learning server-side
scripting, this book is perfect for you. It is also
suitable for developers from other languages who
want to get a quick start with PHP.
How This Book Is Organized
The book is divided into well-structured chapters,
each focusing on a specific aspect of PHP
programming:
Chapter 1-5 cover the basics of PHP,
including installation, variables, constants,
and data types.
Chapters 6-10 focus on operators, control
structures, and handling strings and arrays.
Chapters 11-15 delve into functions,
variable scope, superglobals, and file
handling.
 Chapters 16-20 explore advanced topics
like sessions, cookies, object-oriented
programming (OOP), error handling, and
basic database interaction with MySQL.

This progression ensures a gradual learning curve,

helping you build a strong foundation before moving
on to more advanced features of PHP.

What Was Left Out

To keep this book beginner-friendly and focused,
topics like advanced PHP frameworks (Laravel,
Symfony) and complex database operations were
omitted. However, once you are comfortable with the
basics covered in this book, you will be well-prepared
to explore these advanced topics on your own.
Code Style (About the Code)
All code examples in this book follow a consistent
style for clarity and readability:
Indentation: 4 spaces per level.
Variable Naming: Lowercase with
underscores (e.g., $user_name ).
Function Names: Lowercase with
underscores (e.g., get_user_data() ).
Code snippets are provided with
explanations, making it easy for you to
understand how they work.

Release Notes
This first edition covers PHP 8.0 and higher. It
introduces new features and improvements in PHP,
including enhanced error handling, improved type
safety, and new syntax updates, ensuring you learn
the most up-to-date version of the language.
Notes on the First Edition
This book has been carefully curated with beginners
in mind, focusing on fundamental concepts and
practical examples. Feedback and suggestions are
always welcome to help improve future editions.
MechatronicsLAB Online Learning
For additional resources, tutorials, and exercises, visit
MechatronicsLAB's online learning platform. Enhance
your learning experience with interactive content and
video tutorials tailored to complement this book.
How to Contact Us
We love hearing from our readers! If you have any
questions, feedback, or suggestions, feel free to
reach out to us:
Email: [email protected]
Website: mechatronicslab.net

Acknowledgments for the First Edition

We would like to express our gratitude to all the
contributors, reviewers, and the amazing
MechatronicsLAB team for their support and efforts in
making this book a reality. Your valuable input has
greatly enhanced the quality of this edition.
Copyright (MechatronicsLAB)
© 2024 MechatronicsLAB. All rights reserved. No part
of this book may be reproduced or distributed without
prior written permission from the publisher. All
trademarks and registered trademarks are the
property of their respective owners.
Disclaimer
The information provided in this book is for
educational purposes only. While every effort has
been made to ensure accuracy, the author and
publisher make no guarantees and assume no
responsibility for any errors or omissions. Always
refer to the official PHP documentation for the latest
updates and best practices.
Table of Contents
Chapter-1 Getting Started with PHP
Chapter-2 PHP Variables and Constants
Chapter-3 PHP Data Types
Chapter-4 PHP Arithmetic Operators
Chapter-5 PHP Assignment Operators
Chapter-6 PHP Comparison Operators
Chapter-7 PHP Logical Operators
Chapter-8 PHP Printing Data
Chapter-9 PHP Working with Strings and Numbers
Chapter-10 PHP Control Structures
Chapter-11 PHP Working with Arrays
Chapter-12 PHP Functions
Chapter-13 PHP Variable Scope
Chapter-14 PHP Superglobals
Chapter-16 PHP File Handling
Chapter-17 PHP Sessions and Cookies
Chapter-18 Object-Oriented Programming (OOP) in
PHP
Chapter-19 Error Handling and Debugging in PHP
Chapter-20 Basic Database Interaction (MySQL) in
PHP
Chapter-1 Getting Started with PHP
This chapter provides a comprehensive introduction to PHP,
covering setup, syntax, output, and comments. By the end
of this chapter, you’ll have a strong foundation to start
developing web applications using PHP.

PHP Introduction
What is PHP?
PHP (Hypertext Preprocessor) is a server-side, open-
source, and scripting language primarily used for web
development. PHP is embedded into HTML, allowing for
dynamic web page content creation and efficient server-side
programming.
Why Use PHP?
1. Web Integration:

○ PHP integrates seamlessly with HTML, CSS,

and JavaScript, making it ideal for web
development.

2. Database Connectivity:

○ PHP works with a variety of databases like

MySQL, PostgreSQL, and SQLite, making it
suitable for data-driven applications.

3. Server-Side Scripting:

○ PHP runs on the server, handling tasks like

form processing, session management, and
database access.

4. Cross-Platform:
 ○ PHP is platform-independent, running on
Windows, Linux, macOS, and more, making it
highly versatile.

5. Strong Community Support:

○ PHP has a large developer community,

providing extensive resources, frameworks,
libraries, and documentation.
Key Features of PHP
1. Ease of Learning:

○ PHP has a simple syntax that is easy for

beginners to understand, making it one of the
most accessible server-side languages.

2. Wide Range of Libraries:

○ PHP offers built-in libraries and frameworks

like Laravel, Symfony, and CodeIgniter,
speeding up development.

3. Dynamic Content Creation:

○ PHP can create dynamic and interactive web

pages, generating HTML output that responds
to user input.

4. Session Management:

○ PHP handles sessions and cookies efficiently,

enabling secure user authentication and data
handling.

5. Built-in Security Features:

 ○ PHP has built-in features for input validation,
hashing, and encryption, enhancing web
application security.
Real-World Applications of PHP
1. Web Development:

○ PHP is widely used for creating dynamic

websites, blogs, forums, and e-commerce
platforms.

2. Content Management Systems (CMS):

○ PHP powers popular CMS platforms like

WordPress, Drupal, and Joomla.

3. API Development:

○ PHP is used to build RESTful and SOAP APIs

for mobile and web applications.

4. E-commerce Applications:

○ PHP is commonly used in developing online

stores, payment gateways, and shopping carts.

5. Web Portals and Forums:

○ PHP is used to develop community portals,

discussion forums, and user management
systems.
Difference Between PHP and Other Languages (e.g.,
Python)

Feature PHP Python

 Focus Web development, General-purpose,
server-side scripting data analysis
Learning Easy for web Easy for general
Curve development programming

Framework Laravel, Symfony, Django, Flask,

s CodeIgniter FastAPI
Syntax C-like, embedded in Pythonic, more
HTML readable
Integration Seamless with HTML Seamless with
various libraries

PHP Setup and Installation

To develop in PHP, you need to install a PHP interpreter, a
web server, and a database (optional).
Step 1: Install PHP
1. Download PHP:

○ Visit the PHP download page and download

the latest version for your operating system.

2. Install PHP:

○
Follow the instructions for your OS:
■ Windows: Run the installer or
download the ZIP file, extract it, and add
the PHP directory to your PATH.
Linux: Use the following commands to install PHP:

sudo apt update

sudo apt install php
macOS: Use Homebrew to install PHP:

brew install php

3. Verify Installation:
Open a terminal and type:
php -v
○ You should see the installed PHP version.
Step 2: Install a Web Server (e.g., Apache)
1. Install Apache (Linux/Windows):
Linux:
sudo apt install apache2

○ Windows: Install XAMPP, which comes with

Apache, PHP, and MySQL.

2. Verify Apache Installation:

○
Start the Apache service and navigate to
http://localhost in a browser.
Step 3: Create a PHP Script and Run It

1. Create a PHP File ( hello.php ):

○
Open a text editor and create a file named
hello.php .
Write the Following Code:

<?php
echo "Hello, PHP!";
?>

2. Run from the Browser:

 ○ Move the hello.php file to your web server’s
root directory (e.g., /var/www/html for
Apache).
○ Open a web browser and navigate to
http://localhost/hello.php .
○ Output Result: Hello, PHP!

PHP Syntax
What is PHP Syntax?
PHP syntax refers to the rules and structure for writing
PHP code, focusing on embedding PHP within HTML and
dynamic content generation.
Why is PHP Syntax Important?
● Ensures Consistency: Proper syntax ensures
readable and maintainable code.
● Prevents Errors: Following syntax rules helps
avoid runtime errors.
● Enables Web Integration: PHP syntax allows easy
embedding of PHP code within HTML, making web
development seamless.
Basic Syntax Rules

Syntax Description Example

Rule
Opening PHP code starts with <?php echo
Tag <?php "Hello"; ?>

Variables Variables start with $ $name = "Alice";

Functions Declared with function function
greet($name) {}
 Semicolon End statements with a $x = 5;
s semicolon
Comments Use // or # for single- // This is a
line comments comment

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

greet("Alice");
?>

Output Result
Hello, Alice!
Explanation of Rules
Rule Example Explanation
Use
Opening <?php PHP code is enclosed within the
Tag echo "Hi"; <?php ... ?> tags.
?>

Variables $age = 25; PHP variables start with a $

sign and are dynamically
typed.
Functions function Functions in PHP use the
add($a, function keyword, followed by
$b) {} parameters.
Semicolon $x = 10; Semicolons are required at the
s end of each statement to
terminate it.
 Comments // Single- Comments are used to
line describe code and are
comment ignored by the interpreter.

PHP Output
What is PHP Output?
PHP output refers to displaying information or results using
functions like echo , print , or HTML embedding.
Types of Output in PHP

Seri Type Syntax Example

al
No

1 Text echo "text"; echo "Hello, World!";

Output
2 Variable echo $age = 25; echo
Output $variable; $age;
3 Combine echo "text " . $name = "Alice";
d Output $variable; echo "Name: " .
$name;

Example Based on Type

Text Output:

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

Variable Output:
<?php
$age = 25;
echo $age;
?>

Combined Output:
<?php
$name = "Alice";
echo "Name: " . $name;
?>

Output Result
Hello, World!
25
Name: Alice
Explanation
● Text Output:
○ Prints a static string to the web page.
● Variable Output:
○ Prints the value of a variable to the web
page.
● Combined Output:
○ Combines text and variable values in a
single output statement using concatenation.

PHP Comments
What are PHP Comments?
PHP comments are lines of code ignored by the
interpreter. They are used to describe code, clarify logic,
or disable specific code lines temporarily.
Why are PHP Comments Important?
● Improves Code Readability:
○ Makes code easier to understand.
● Facilitates Maintenance:
○ Helps in modifying and updating code.
● Provides Documentation:
○ Used to explain functions, variables, and
logic.
Types of Comments in PHP
Seria Type Syntax Purpose
l No
1 Single // Used for short
-line comment explanations.
2 Single # Alternative for single-line
-line comment comments.

3 Multi- /* Used for longer

line comment explanations.
*/

Example Based on Type

Single-line Comment:
<?php
$age = 18; // Age variable
?>

Alternative Single-line Comment:

<?php
$age = 18; # Age variable
?>

Multi-line Comment:
<?php
/* This is a multi-line comment
 explaining the following code block */
$age = 18;
?>
Output Result
● Comments do not produce any output as they are
meant for clarification within the code.
Explanation
● Single-line Comment:
○ Used for brief notes or explanations to
improve code clarity.
● Multi-line Comment:
○ Used for longer explanations or to disable
multiple lines of code.

Chapter-2 PHP Variables and

Constants
Chapter Overview
This chapter explores PHP variables and constants, focusing
on their declaration, usage, differences, and best practices.
Variables allow dynamic data management, while constants
store unchangeable values throughout program execution,
providing stability and predictability.
Chapter Goal
● Understand the fundamental concepts of PHP
variables and constants.
● Learn how to declare, initialize, and use variables
and constants in PHP.
● Explore differences in behavior, scope, and use
cases between variables and constants.
● Implement a PHP project that demonstrates
variables and constants working together.

Rules of PHP Variables and Constants

● Variables: Variables in PHP can hold different types
of data and can change values during execution. They
are declared using a $ symbol.
● Constants: Constants are immutable values
defined using the define() function or the const
keyword and cannot be changed once set.
● Case Sensitivity: Variable names are case-
sensitive ( $name and $Name are different), while
constants defined with define() are not case-
sensitive by default (unless specified as case-
sensitive).
● Scope: Variables can be local, global, or static, while
constants are globally accessible after they are
defined.
Syntax Table
Seri Topic Syntax Simple
al Example
No
1 Variable $variable_name = value; $age =
Declaratio 25;
n
2 String $variable_name = $name =
Variable "string"; "Alice";
3 Integer $variable_name = $count =
Variable integer; 10;
4 Constant define("CONSTANT_NAME" define("PI
Definition , value); ", 3.14);
5 Using echo CONSTANT_NAME; echo PI;
Constants
6 Const const CONSTANT_NAME = const
Keyword value; VERSION
= "1.0";

1. PHP Variables
What are PHP Variables
Variables in PHP are containers that hold data values,
enabling dynamic data management. They are essential for
storing, processing, and manipulating data, such as user
input, calculations, or dynamic content.
Use Purpose
● Store dynamic data, including strings, numbers,
arrays, and objects, which may change during
execution.
● Facilitate data manipulation, enabling
mathematical operations, string processing, or logical
evaluations.
● Organize information, making code more
readable, maintainable, and easier to debug.
● Enable user interaction, storing inputs,
processing results, and displaying outputs
dynamically.
Syntax

$variable_name = value;

Syntax Explanation
● $:
○ The dollar sign is mandatory for declaring
variables in PHP. It identifies a variable within
the code.
● variable_name :
○ The variable name can include letters,
numbers, and underscores but must start with
a letter or an underscore. It should be
descriptive to indicate its purpose.
● value :
○ The value can be a string, integer, float,
array, boolean, or even an object, representing
the data held by the variable.
Simple Code Example

<?php
$age = 25; // Integer variable
$name = "Alice"; // String variable

echo $age; // Outputs: 25

echo $name; // Outputs: Alice
?>

Notes
● Variables in PHP are dynamically typed,
meaning the type can change based on the assigned
value.
● Variable names are case-sensitive, making $age
different from $Age or $AGE .
● Variable names should be descriptive, indicating
the kind of data they hold (e.g., $user_name ,
$total_amount ).
Warnings
● Avoid using PHP reserved keywords as variable
names (e.g., $class , $function ).
● Always initialize variables before using them to
avoid warnings or errors.
● Using undeclared variables can generate Notices,
which may affect debugging or error handling.
2. String Variables
What are String Variables
String variables store sequences of characters, such as
words, sentences, or any textual data. They are used to
manage, manipulate, and display textual information in PHP
applications.
Use Purpose
● Store and display text, such as user inputs,
messages, descriptions, or HTML content.
● Perform string operations, including
concatenation, searching, replacing, and slicing.
 ● Manage text-based data effectively in web
applications, such as form inputs, URLs, and JSON
strings.
Syntax
$variable_name = "string";

Syntax Explanation
● "string" :
○ Text enclosed in double quotes is treated as a
string in PHP. Single quotes can also be used,
but they do not allow variable interpolation
(e.g., "Hello, $name" ).
Simple Code Example

<?php
$greeting = "Hello, World!";
$custom_message = "Welcome, $name!";
echo $greeting; // Outputs: Hello, World!
?>

Notes
● Double-quoted strings allow variable
interpolation, enabling dynamic string creation.
● Single-quoted strings treat the content literally,
which is useful for performance when no interpolation
is needed.
● String concatenation uses the dot operator ( . ) to
join multiple strings.
Warnings
● Ensure proper use of quotes to avoid syntax errors,
especially when mixing single and double quotes.
● Use escape characters ( \ ) to include special
characters within strings (e.g., \" for double quotes).

3. Integer Variables
What are Integer Variables
Integer variables store whole numbers without decimals.
They can be positive, negative, or zero. Integers are widely
used for arithmetic operations, counting, indexing, and
logical evaluations.
Use Purpose
● Store numeric values like age, count, score, or IDs
for calculations.
● Perform arithmetic operations, such as addition,
subtraction, multiplication, and division.
● Use as loop counters, indexes for arrays, or flags
in conditional statements.
Syntax

$variable_name = integer;

Syntax Explanation
● integer :
○ Represents a whole number, such as 0, -10,
25, or 100, without decimal points.
Simple Code Example

<?php
$count = 10; // Integer variable
$sum = $count + 5;
echo $sum; // Outputs: 15
?>

Notes
● PHP supports basic arithmetic operations,
making it easy to perform calculations with integers.
● Integer variables are commonly used in loops,
conditional statements, and array indexing.
 ● PHP automatically converts numeric strings to
integers when performing arithmetic operations.
Warnings
● Be cautious of division by zero, as it will generate a
warning or error.
● Always use parentheses to ensure the correct order
of operations in complex expressions.

4. PHP Constants
What are PHP Constants
Constants are immutable values that do not change during
the execution of a program. They are defined using the
define() function or the const keyword, providing a reliable
way to store fixed values.
Use Purpose
● Store fixed values, such as configuration settings,
mathematical constants (e.g., PI), or API keys.
● Ensure data integrity, preventing accidental
changes to critical values throughout the code.
● Improve code readability, making it clear that
certain values should remain constant.
Syntax

define("CONSTANT_NAME", value);

Syntax Explanation
● define() :
○ A function used to define a constant. The first
argument is the constant's name (typically
uppercase), and the second argument is its
value.
● CONSTANT_NAME :
 ○
The name of the constant, which is usually
written in uppercase to differentiate it from
variables.
Simple Code Example
<?php
define("PI", 3.14);
echo PI; // Outputs: 3.14
?>
Notes
● Constants are accessible globally throughout the
code once defined.
● Use uppercase for constant names to distinguish
them from variables.
● Constants cannot be changed or unset after
being defined.
Warnings
● Do not use constants for values that may need to
change during execution.
● Constants are defined globally, so be mindful of
naming conflicts.

5. Const Keyword
What is the Const Keyword
The const keyword is another way to define constants in
PHP, typically used within classes for object-oriented
programming. It provides a straightforward way to create
unchangeable values.
Use Purpose
● Define constants in object-oriented programming,
providing consistent values within classes.
● Create global constants, serving as an alternative
to the define() function.
● Maintain code structure, ensuring values remain
unchanged throughout the program.
Syntax
const CONSTANT_NAME = value;

Syntax Explanation
● const CONSTANT_NAME = value; :
○ Declares a constant with the specified name
and value. It can be used globally or within a
class but not inside functions or conditional
blocks.
Simple Code Example
<?php
class Circle {
const PI = 3.14;
}

echo Circle::PI; // Outputs: 3.14

?>
Notes
● The const keyword can only be used at the class
level or in the global scope.
● Constants defined with const are resolved at
compile time, making them slightly faster than those
defined with define() .
Warnings
● const cannot be used conditionally, so use it for
static values only.
● Ensure that constant names do not conflict with
other global variables or constants.

6. Using Constants
What is Using Constants
Constants, once defined, can be accessed like variables but
without the $ symbol. They provide stability and
predictability by ensuring fixed values are used throughout
the program.
Use Purpose
 ● Access unchangeable values in the program,
maintaining consistency and reliability.
● Use for configuration settings, such as database
credentials, file paths, or API endpoints.
● Enhance code readability, making it clear which
values are constant and should not be modified.
Syntax

echo CONSTANT_NAME;
Syntax Explanation
● CONSTANT_NAME :
○ The name of the constant is used directly
(without $ ) to access its value.
Simple Code Example
<?php
define("SITE_NAME", "My Website");
echo SITE_NAME; // Outputs: My Website
?>
Notes
● Constants are useful for storing global settings,
like site names, version numbers, or API limits.
● Once defined, constants are accessible from any
part of the program without re-declaration.
Warnings
● Constants are global, so be mindful of potential
naming conflicts, especially in large applications.
● Ensure that constant values are accurately set at
the start, as they cannot be changed later.
Final Project: "Website Configuration Manager"
Project Goal
● Create a PHP script that uses both variables and
constants to manage website settings.
● Demonstrate the declaration, initialization, and
usage of variables and constants in practical
 scenarios.
Code for This Project
<?php
// Define constants for website settings
define("SITE_NAME", "My PHP Site");
define("MAX_USERS", 100);
const VERSION = "1.0";

// Define variables for user information

$user_name = "Alice";
$user_age = 28;
$is_admin = true;

// Display website settings using constants

echo "Welcome to " . SITE_NAME . "<br>";
echo "Version: " . VERSION . "<br>";
echo "Max Users Allowed: " . MAX_USERS . "<br>";

// Display user information using variables

echo "User: " . $user_name . "<br>";
echo "Age: " . $user_age . "<br>";
echo "Admin: " . ($is_admin ? "Yes" : "No") . "<br>";
?>

Save and Run

● Save the code as web_config.php .
● Run it on a PHP server or use an online PHP
sandbox.
Check Output
The script will display the website's name, version,
maximum users, and user information, demonstrating the
use of both variables and constants.
Summary
This chapter provided a comprehensive overview of PHP
variables and constants, covering declaration, initialization,
scope, and practical usage. It concluded with a project
demonstrating how variables and constants can work
together to manage dynamic and fixed data in PHP
applications.

Chapter-3 PHP Data Types

Chapter Overview
This chapter covers PHP data types, explaining the different
types of data that variables can hold. Understanding data
types is fundamental to manipulating and processing data in
PHP applications.
Chapter Goal
● Learn about the various data types supported in
PHP.
● Understand how to declare and use each data type.
● Implement practical examples that utilize different
data types.
● Develop a project that combines multiple data types
for data management.

Rules of PHP Data Types

● Dynamic Typing: PHP determines a variable’s data
type based on the value assigned, without explicit
declaration.
● Type Conversion: PHP allows implicit and explicit
type conversion between compatible data types.
● Data Integrity: Using the correct data type ensures
that operations perform as expected, improving code
reliability and clarity.

Syntax Table
Seri Data Syntax Simple Example
al Type
 No
1 String $variable = $name = "Alice";
"string";
2 Integer $variable = $age = 25;
integer;
3 Float $variable = float; $price = 99.99;
4 Boolea $variable = $is_valid = true;
n true/false;
5 Array $variable = $colors =
array(values); array("red",
"green");
6 NULL $variable = null; $no_value = null;

7 Object $variable = new $car = new Car();

ClassName();

1. String Data Type

What is the String Data Type
The string data type represents sequences of characters,
such as text, words, or sentences. Strings are used to store
and manipulate textual data, making them essential for
handling user input, displaying messages, or managing
content in PHP applications.
Use Purpose
● Store and display text, including messages, user
inputs, and descriptions.
● Perform string operations, such as
concatenation, searching, and replacing.
● Manage text-based data like form inputs, JSON, or
HTML content.
Syntax

$variable = "string";

Syntax Explanation
● $variable :
○ Begins with a $ symbol, indicating it is a
variable.
○ The variable name can contain letters,
numbers, and underscores but must start with
a letter or an underscore.
● "string" :
○ A sequence of characters enclosed in double
quotes. Double quotes allow variable
interpolation, where variables within the string
are replaced with their values.
○ Single quotes ( 'string' ) can also be used for
strings but do not support variable
interpolation, treating everything inside as
plain text.
● String concatenation:
○ In PHP, you concatenate strings using the dot
operator ( . ). This allows combining multiple
strings into one.
Simple Code Example

<?php
$greeting = "Hello";
$name = "Alice";
$full_greeting = $greeting . ", " . $name . "!";
echo $full_greeting; // Outputs: Hello, Alice!
?>
Notes
 ● Double-quoted strings allow for variable
interpolation, making them useful for dynamic
strings.
● Use single-quoted strings for literal strings or when
performance is a concern, as PHP processes them
faster than double-quoted strings.
Warnings
● Use escape characters ( \ ) to handle special
characters, like \" for double quotes inside a double-
quoted string.
● Be aware of accidental concatenation errors when
using multiple dot operators.

2. Integer Data Type

What is the Integer Data Type
The integer data type stores whole numbers, either positive
or negative, without decimal points. It is primarily used for
mathematical calculations, counting, indexing, and
controlling program flow in loops.
Use Purpose
● Store numeric values, such as age, count, or
score.
● Perform arithmetic operations, including
addition, subtraction, multiplication, and division.
● Use as counters or indexes in loops and arrays.
Syntax

$variable = integer;

Syntax Explanation
● $variable :
○ Begins with a $ symbol, indicating a
variable.
 ○
The variable name follows the same naming
rules as for other data types.
● integer :
○ Represents a whole number, which can be
positive (e.g., 25 ), negative (e.g., -10 ), or
zero ( 0 ).
○ Integers in PHP do not require special
notation and are automatically recognized
when assigned.
○ When performing arithmetic operations, PHP
converts numeric strings to integers if they
contain valid whole numbers.
Simple Code Example
<?php
$count = 10;
$items = 5;
$total = $count + $items; // Addition
echo $total; // Outputs: 15
?>

Notes
● PHP supports various arithmetic operators, including
+ (addition), - (subtraction), * (multiplication), /
(division), and % (modulus).
● PHP converts numeric strings to integers
automatically when they are used in arithmetic
operations.
Warnings
● Dividing by zero generates a warning and can
disrupt execution.
● Use parentheses to ensure the correct order of
operations in complex expressions, following standard
mathematical rules (e.g., PEMDAS).
3. Float Data Type
What is the Float Data Type
The float data type represents numbers with decimal points,
also known as floating-point numbers. Floats are used for
precise calculations involving fractions, financial values, and
measurements.
Use Purpose
● Store decimal values, such as prices, scores, or
measurements.
● Perform arithmetic operations that require
decimal precision, like calculations involving
percentages or averages.
● Handle fractions and ratios, making them
suitable for scientific or financial computations.
Syntax

$variable = float;

Syntax Explanation
● $variable :
○ Begins with a $ symbol, indicating a
variable.
● float :
○ Represents a number with a decimal point,
like 3.14 , -1.5 , or 99.99 .
○ Floats can be written with or without leading
zeros ( .5 or 0.5 ).
○ Floats are automatically recognized when a
decimal point is included in the value
assignment.
Simple Code Example
<?php
$price = 99.99;
$tax = 0.08;
$total = $price + ($price * $tax); // Total calculation with tax
echo $total; // Outputs: 107.99
?>

Notes
● PHP supports floating-point arithmetic, but be aware
of potential rounding errors due to the way floats are
stored in memory.
● Use built-in functions like round() , ceil() , or floor()
to manage decimal precision as needed.
Warnings
● Comparing floats directly for equality can lead to
inaccurate results due to floating-point
representation.
● Use functions like bccomp() for precise float
comparisons in critical calculations, such as financial
transactions.
4. Boolean Data Type
What is the Boolean Data Type
The boolean data type represents two possible values: true
or false . Booleans are used in conditional statements to
control program flow and manage logical operations.
Use Purpose
● Control conditional statements, such as if-else
structures and loops.
● Store binary states, like yes/no, on/off, or
enabled/disabled.
● Perform logical operations, ensuring specific
conditions are met.
Syntax
$variable = true/false;
Syntax Explanation
● $variable :
○ Begins with a $ symbol, indicating a
variable.
● true or false :
○ Represents logical truth or falsehood in PHP.
○ Booleans do not require quotation marks, as
they are keywords.
○ PHP evaluates various data types as
booleans: non-zero numbers, non-empty
strings, and arrays with elements are
considered true , while 0 , empty strings ( "" ),
empty arrays ( array() ), and null are
considered false .
Simple Code Example
<?php
$is_logged_in = true;
if ($is_logged_in) {
echo "User is logged in.";
} else {
echo "User is not logged in.";
}
?>
Notes
● Booleans are often used in loops and conditional
statements to manage program flow.
● Use strict comparison ( === ) to ensure the boolean
data type matches during evaluation.
Warnings
● Type coercion in PHP can lead to unexpected results
when using loose comparison ( == ), as PHP attempts
to convert values to booleans during evaluation.

5. Array Data Type

What is the Array Data Type
The array data type is a collection of values stored in a
single variable. PHP arrays can hold different data types,
including integers, strings, and even other arrays. Arrays
can be indexed (numeric keys) or associative (key-value
pairs).
Use Purpose
● Store collections of related values, such as lists
of items, user data, or configurations.
● Access elements by index (indexed arrays) or by
key (associative arrays).
● Organize complex data structures, making it
easier to manage related information.
Syntax

$variable = array(value1, value2, ...);

Syntax Explanation
● $variable :
○ Begins with a $ symbol, indicating a
variable.
● array() :
○ A built-in PHP function that creates an array,
capable of holding a collection of values.
● Values within an array:
○ Each value can be of a different data type,
including strings, integers, floats, booleans, or
even other arrays.
○ Arrays can be created using the [] syntax for
shorthand (e.g., $variable = [value1,
value2]; ).
Simple Code Example
<?php
$fruits = array("apple", "banana", "cherry");
$colors = ["red", "green", "blue"]; // Shorthand syntax
echo $fruits[1]; // Outputs: banana
?>

Notes
● PHP supports associative arrays, where elements are
accessed by keys instead of indexes (e.g.,
array("name" => "Alice") ).
● Arrays can be multi-dimensional, containing arrays
within arrays.
Warnings
● Ensure that keys exist before accessing array
elements to avoid undefined index errors.
● When using large arrays, consider memory usage
and performance implications.

6. NULL Data Type

What is the NULL Data Type
The NULL data type represents a variable with no value. It is
used to indicate that a variable has no value or has been
explicitly set to be empty.
Use Purpose
● Indicate the absence of a value, such as
uninitialized variables.
● Reset variables, allowing memory to be freed or
reallocated.
● Manage optional data, where variables can be set
to NULL when data is not required.
Syntax
$variable = null;

Syntax Explanation
● $variable :
○ Begins with a $ symbol, indicating a
variable.
 ● null :
○ A special keyword that represents the
absence of a value. It is not case-sensitive, so
NULL or Null is also valid.

Simple Code Example

<?php
$no_value = null;
if (is_null($no_value)) {
echo "Variable has no value.";
}
?>

Notes
● Use is_null() to check if a variable is NULL, ensuring
proper handling of empty values.
● Variables set to NULL can be redefined with new
values later.
Warnings
● Be cautious when using NULL in conditions, as it can
produce unexpected results if not handled correctly.
● Avoid using NULL for variables that are expected to
hold valid data during execution.

7. Object Data Type

What is the Object Data Type
The object data type allows the creation of objects, which
are instances of classes in PHP. Objects hold both data
(properties) and functions (methods), making them ideal for
modeling real-world entities.
Use Purpose
 ● Model real-world entities, such as users,
products, or orders.
● Organize data and behavior, allowing
encapsulation of properties and methods.
● Implement object-oriented programming
(OOP) concepts, enabling better code structure and
reusability.

Syntax

$variable = new ClassName();

Syntax Explanation
●
$variable :
○ Begins with a $ symbol, indicating a
variable.
● new ClassName() :
○ Creates a new object instance of the specified
class.
○ The new keyword allocates memory for the
object and initializes it based on the class
definition.
○ Objects can have properties (variables) and
methods (functions) defined within the class.
Simple Code Example
<?php
class Car {
public $make;
public $model;

public function drive() {

return "Driving a " . $this->make . " " . $this->model;
}
}
$my_car = new Car();
$my_car->make = "Toyota";
$my_car->model = "Corolla";
echo $my_car->drive(); // Outputs: Driving a Toyota Corolla
?>
Notes
● Objects allow encapsulation, inheritance, and
polymorphism, which are key concepts in object-
oriented programming (OOP).
● Use classes to define reusable code structures that
represent entities with attributes (properties) and
behavior (methods).
Warnings
● Objects require more memory than basic data types,
so use them when complex structures or behaviors
are needed.
● Be aware of object references, as modifying one
reference can affect other references pointing to the
same object.

Final Project: "User Profile Manager"

Project Goal
● Create a PHP script that uses multiple data types to
manage user profile information.
● Demonstrate data type declarations, assignments,
and operations.
Code for This Project

<?php
// User information
$name = "Alice Johnson"; // String
$age = 28; // Integer
$is_active = true; // Boolean
$favorite_fruits = array("apple", "banana", "cherry"); // Array
$height = 5.5; // Float
$nickname = null; // NULL

// Display user information

echo "Name: " . $name . "<br>";
echo "Age: " . $age . "<br>";
echo "Active: " . ($is_active ? "Yes" : "No") . "<br>";
echo "Favorite Fruits: " . implode(", ", $favorite_fruits) . "<br>";
echo "Height: " . $height . " feet<br>";

// Check if nickname is set

if (is_null($nickname)) {
echo "Nickname is not set.";
}
?>
Save and Run
● Save the code as user_profile.php .
● Run it on a PHP server or use an online PHP
sandbox.
Check Output
The script will display user information, including name,
age, active status, favorite fruits, height, and nickname
status, demonstrating the use of multiple PHP data types.
Summary
This chapter provided a comprehensive overview of PHP
data types, covering strings, integers, floats, booleans,
arrays, NULL, and objects. It concluded with a practical
project that demonstrated how to manage user profile
information using different data types in PHP.

Chapter-4 PHP Arithmetic Operators

Chapter Overview
This chapter covers PHP arithmetic operators, which are
used to perform mathematical calculations. Arithmetic
operators allow you to manipulate numerical data by
performing addition, subtraction, multiplication, division,
modulus, and exponentiation.
Chapter Goal
● Understand the various arithmetic operators
available in PHP.
● Learn how to use arithmetic operators for
calculations.
● Explore examples demonstrating the use of
arithmetic operators.
● Implement a project that uses arithmetic operators
for numerical data manipulation.

Rules of PHP Arithmetic Operators

● Data Type Compatibility: Arithmetic operators
primarily work with integer and float data types. If a
string contains a valid number, PHP converts it to a
numeric type when using arithmetic operators.
● Type Conversion: PHP performs implicit type
conversion when operands have different types,
converting strings to numbers if they contain numeric
values.
● Precedence and Associativity: Operators have a
specific order of precedence that determines the
sequence in which operations are executed. Use
parentheses to enforce a specific order of operations
when needed.
Syntax Table
Seri Operator Synta Example Outpu
al No x t
1 Addition $a + $a = 5; $b $c = 8;
$b = 3; $c =
$a + $b;

2 Subtraction $a - $b $a = 5; $b $c = 2;
= 3; $c =
$a - $b;
3 Multiplication $a * $b $a = 5; $b $c =
= 3; $c = 15;
$a * $b;
4 Division $a / $b $a = 10; $b $c = 5;
= 2; $c =
$a / $b;
5 Modulus $a % $a = 5; $b $c = 1;
$b = 2; $c =
$a % $b;
6 Exponentiation $a ** $a = 2; $b $c = 8;
$b = 3; $c =
$a ** $b;

1. Addition Operator ( + )
What is the Addition Operator
The addition operator ( + ) is used to add two numbers. It is
one of the basic arithmetic operators and is used to perform
simple mathematical addition.
Use Purpose
● Add two numbers, whether integers or floats.
● Increase values dynamically, such as adding
quantities or totals.
 ● Combine numeric results for summing arrays or
values in loops.
Syntax

$result = $a + $b;

Syntax Explanation
● $a and $b :
○ Variables holding numeric values that are
being added together. PHP supports adding
integers and floats directly.
● +:
○ The addition operator performs the addition
operation between two operands.
● $result :
○ The variable stores the result of the addition,
which is the sum of $a and $b .
Simple Code Example

<?php
$a = 10;
$b = 20;
$sum = $a + $b;
echo "The sum is: " . $sum; // Outputs: The sum is: 30
?>

Notes
● PHP automatically converts numeric strings to
numbers when using the addition operator (e.g., "5"
+ 10 results in 15 ).
● Addition can be used within loops to calculate
running totals or aggregates.
Warnings
 ● Adding non-numeric strings results in a warning and
returns 0.
● Be aware of type conversion issues when using
addition with mixed data types.

2. Subtraction Operator ( - )
What is the Subtraction Operator
The subtraction operator ( - ) is used to subtract one number
from another. It allows for mathematical operations that
decrease or deduct values.
Use Purpose
● Subtract numbers, such as calculating differences
or reducing values.
● Calculate changes in values, like finding the
difference between two quantities.
● Use in loops or conditions to decrement counters
or values.
Syntax

$result = $a - $b;

Syntax Explanation
● $a and $b :
○ Variables containing numeric values. The
value of $b is subtracted from $a .
● -:
○ The subtraction operator reduces the value of
$a by $b .
● $result :
○ Stores the difference between $a and $b .
Simple Code Example

<?php
$a = 15;
$b = 5;
$difference = $a - $b;
echo "The difference is: " . $difference; // Outputs: The difference is: 10
?>

Notes
● PHP supports subtraction for both integers and
floats.
● Subtraction is commonly used in loops, counters,
and calculations of differences.
Warnings
● Subtracting from non-numeric strings results in a
warning and returns 0.
● Be cautious with negative results, as they can affect
conditions and calculations.

3. Multiplication Operator ( * )
What is the Multiplication Operator
The multiplication operator ( * ) multiplies two numbers. It is
used to perform calculations that require repeated addition.
Use Purpose
● Multiply numbers for scaling values or calculating
areas, volumes, etc.
● Increase values by a factor, such as calculating
prices, totals, or quantities.
● Perform mathematical calculations, like finding
products of arrays or loops.
Syntax
$result = $a * $b;
Syntax Explanation
● $a and $b :
 ○ Variables containing numeric values that will
be multiplied.
● *:
○The multiplication operator calculates the
product of $a and $b .
● $result :
○ Stores the product of $a and $b .
Simple Code Example

<?php
$a = 4;
$b = 5;
$product = $a * $b;
echo "The product is: " . $product; // Outputs: The product is: 20
?>

Notes
● Multiplication is useful in loops for scaling, totals,
and more complex calculations.
● PHP automatically converts numeric strings to
numbers when multiplying.
Warnings
● Multiplying non-numeric strings returns 0.
● Be aware of potential overflow issues when
multiplying large integers.

4. Division Operator ( / )
What is the Division Operator
The division operator ( / ) divides one number by another. It
is used to split values into smaller parts or to find ratios.
Use Purpose
 ● Divide values, such as splitting amounts,
calculating averages, or distributing items.
● Calculate ratios or proportions between numbers.
● Perform mathematical operations, like
calculating per-unit costs.
Syntax

$result = $a / $b;

Syntax Explanation
● $a and $b :
○ Variables containing numeric values. $a is
divided by $b .
● /:
○ The division operator calculates the quotient
of $a and $b .
● $result :
○ Stores the quotient of the division.
Simple Code Example

<?php
$a = 20;
$b = 4;
$quotient = $a / $b;
echo "The quotient is: " . $quotient; // Outputs: The quotient is: 5
?>

Notes
● Division results in a float if the result is not a whole
number (e.g., 5 / 2 results in 2.5 ).
● Use the division operator in loops, conditions, and
calculations that involve splitting values.
Warnings
● Division by zero results in a warning or error,
disrupting execution.
● Ensure that the divisor ( $b ) is not zero before
performing division.
5. Modulus Operator ( % )
What is the Modulus Operator
The modulus operator ( % ) returns the remainder of a
division. It is commonly used to determine if a number is
even or odd or to cycle through repeated patterns.
Use Purpose
● Find remainders, such as when dividing items
evenly.
● Check if a number is even or odd( $num % 2 ).
● Cycle through patterns, like alternating colors,
rows, or elements in arrays.
Syntax

$result = $a % $b;
Syntax Explanation
● $a and $b :
○ Variables containing numeric values. $a is
divided by $b , and the remainder is returned.
● %:
○ The modulus operator calculates the
remainder of $a divided by $b .
● $result :
○ Stores the remainder of the division.
Simple Code Example
<?php
$a = 10;
$b = 3;
$remainder = $a % $b;
echo "The remainder is: " . $remainder; // Outputs: The remainder is: 1
?>
Notes
● The modulus operator is often used to determine if a
number is evenly divisible by another number.
● It is also useful for looping patterns, such as
alternating rows or actions.
Warnings
● Using the modulus operator with non-integer
operands can yield unexpected results.
● Ensure that the divisor ( $b ) is not zero, as it will
generate a division-by-zero error.
6. Exponentiation Operator ( ** )
What is the Exponentiation Operator
The exponentiation operator ( ** ) raises one number to the
power of another. It is used for mathematical calculations
that involve powers, such as squares, cubes, or higher
powers.
Use Purpose
● Calculate powers, like squares, cubes, or
exponential growth.
● Perform complex calculations, such as
calculating growth rates or scientific computations.
● Handle mathematical operations, like raising
numbers to specific powers.
Syntax
$result = $a ** $b;
Syntax Explanation
● $a and $b :
○ Variables containing numeric values. $a is
raised to the power of $b .
● ** :
○ The exponentiation operator calculates the
result of $a raised to the power of $b .
● $result :
○ Stores the result of the exponentiation.
Simple Code Example
<?php
$a = 2;
$b = 3;
$power = $a ** $b;
echo "The result is: " . $power; // Outputs: The result is: 8
?>
Notes
● The exponentiation operator is useful in financial
calculations (e.g., compound interest) and scientific
 computations.
● PHP supports floating-point values in both the base
and the exponent.
Warnings
● Be aware of overflow or underflow when using large
numbers with exponentiation.
Final Project: "Basic Calculator"
Project Goal
●Create a PHP script that uses arithmetic operators to
perform basic calculations (addition, subtraction,
multiplication, division, modulus, and
exponentiation).
● Demonstrate user input handling and arithmetic
operations.
Code for This Project
<?php
// Define two numbers
$num1 = 10;
$num2 = 5;
// Perform calculations
$sum = $num1 + $num2;
$difference = $num1 - $num2;
$product = $num1 * $num2;
$quotient = $num1 / $num2;
$remainder = $num1 % $num2;
$power = $num1 ** $num2;
// Display results
echo "Numbers: $num1 and $num2<br>";
echo "Addition: $sum<br>";
echo "Subtraction: $difference<br>";
echo "Multiplication: $product<br>";
echo "Division: $quotient<br>";
echo "Modulus: $remainder<br>";
echo "Exponentiation: $power<br>";
?>
Save and Run
● Save the code as calculator.php .
● Run it on a PHP server or use an online PHP
sandbox.
Check Output
The script will display the results of basic arithmetic
operations performed on the two numbers.
Summary
This chapter provided a comprehensive overview of PHP
arithmetic operators, covering addition, subtraction,
multiplication, division, modulus, and exponentiation. The
chapter concluded with a basic calculator project that
demonstrated how to use arithmetic operators for numerical
data manipulation in PHP.
Chapter-5 PHP Assignment Operators
Chapter Overview
This chapter covers PHP assignment operators, which are
used to assign values to variables. Assignment operators
provide a way to update variable values, combining
assignment with arithmetic or bitwise operations.
Chapter Goal
● Understand the various assignment operators
available in PHP.
● Learn how to use assignment operators to
manipulate variable values efficiently.
● Explore examples demonstrating different types of
assignment operators.
● Implement a project that utilizes assignment
operators for updating and managing data.

Rules of PHP Assignment Operators

● Value Assignment: Assignment operators assign
values to variables, either by setting a value directly
or modifying the existing value.
● Combined Operations: Some assignment
operators perform an operation (e.g., addition,
subtraction) and then assign the result to the
variable.
● Variable Type Handling: PHP handles variable
type conversion automatically during assignments,
converting strings to numbers if they contain numeric
values.
Syntax Table
Seri Operator Syntax Example Output
al No
1 Assignment $a = $b $a = 5; $a = 5;

2 Addition $a += $a = 5; $a $a = 8;
Assignment $b += 3;
3 Subtraction $a -= $a = 5; $a $a = 2;
Assignment $b -= 3;
4 Multiplication $a *= $a = 5; $a $a = 15;
Assignment $b *= 3;
5 Division $a /= $a = 10; $a = 5;
Assignment $b $a /= 2;
6 Modulus $a %= $a = 5; $a $a = 1;
Assignment $b %= 2;

7 Exponentiation $a **= $a = 2; $a $a = 8;
Assignment $b **= 3;
8 Concatenation $a .= $a = $a =
Assignment $b "Hello"; $a "Hello
.= " World";
World";

1. Simple Assignment Operator ( = )

What is the Simple Assignment Operator
The simple assignment operator ( = ) is used to assign a
value to a variable. It is the most basic form of assignment
and simply sets a variable to a specified value.
Use Purpose
● Initialize variables by assigning initial values.
 ● Set default values in variables during program
execution.
● Update variables by assigning new values based
on program logic.
Syntax

$variable = value;

Syntax Explanation
● $variable :
○ The variable name, which begins with a $
symbol, indicating it is a variable.
● =:
○ The assignment operator assigns the value
on the right side to the variable on the left.
● value :
○ The value assigned to the variable, which can
be a string, number, boolean, array, or other
data type.
Simple Code Example
<?php
$age = 25;
$name = "Alice";
echo "Name: " . $name . ", Age: " . $age; // Outputs: Name: Alice, Age: 25
?>
Notes
● The simple assignment operator is used to set or
update variable values.
● PHP allows assigning values of different data types,
including strings, integers, floats, booleans, arrays,
and objects.
Warnings
● Ensure that the assigned value matches the
expected data type, as PHP converts data types
 automatically.
● Assigning values to undeclared variables is allowed,
but it can cause warnings if error reporting is enabled.

2. Addition Assignment Operator ( += )

What is the Addition Assignment Operator
The addition assignment operator ( += ) adds the value on
the right to the variable on the left and then assigns the
result to the variable. It combines addition with assignment.
Use Purpose
● Increment variable values, such as adding to
totals, counters, or sums.
● Accumulate values in loops or arrays for running
totals.
● Update variables dynamically based on user input
or calculations.
Syntax

$variable += value;

Syntax Explanation
● $variable :
○ The variable to which the value will be added
and assigned.
● += :
○ The addition assignment operator, which
adds the right-hand value to the variable and
updates the variable with the new value.
● value :
○ The value to be added to the existing
variable.
Simple Code Example
<?php
$total = 10;
$total += 5;
echo "Total: " . $total; // Outputs: Total: 15
?>

Notes
● The addition assignment operator is often used in
loops to accumulate totals or increment counters.
● PHP automatically converts numeric strings to
numbers when using the addition assignment
operator.
Warnings
● Ensure that the variable contains a numeric value
before using += to avoid unexpected results.
● Be cautious of using the operator with strings, as it
may lead to type conversion issues.

3. Subtraction Assignment Operator ( -= )

What is the Subtraction Assignment Operator
The subtraction assignment operator ( -= ) subtracts the
value on the right from the variable on the left and then
assigns the result to the variable.
Use Purpose
● Decrement variable values, such as reducing
quantities or counters.
● Calculate differences between values during
program execution.
● Update variables by subtracting specific amounts
based on conditions.
Syntax
$variable -= value;
Syntax Explanation
● $variable :
○ The variable from which the value will be
subtracted and updated.
● -= :
○ The subtraction assignment operator, which
subtracts the right-hand value from the
variable and updates it.
● value :
○ The value to subtract from the existing
variable.
Simple Code Example

<?php
$balance = 100;
$balance -= 20;
echo "Remaining Balance: " . $balance; // Outputs: Remaining Balance: 80
?>

Notes
● The subtraction assignment operator is commonly
used to reduce counters, balances, or quantities.
● PHP supports subtraction for both integers and
floats.
Warnings
● Ensure that the variable contains a numeric value
before using -= to prevent unexpected results.
● Be cautious of subtracting from strings, as it may
cause type conversion errors.

4. Multiplication Assignment Operator ( *= )

What is the Multiplication Assignment Operator
The multiplication assignment operator ( *= ) multiplies the
variable by the value on the right and then assigns the
result to the variable.
Use Purpose
● Multiply values for scaling, area calculations, or
quantity adjustments.
● Increase values by a factor, such as applying
discounts or calculating totals.
● Perform repetitive multiplications in loops or
arrays.
Syntax

$variable *= value;

Syntax Explanation
● $variable :
○ The variable to be multiplied and updated.
● *= :
○ The multiplication assignment operator,
which multiplies the variable by the right-hand
value and updates it.
● value :
○ The value to multiply with the existing
variable.
Simple Code Example

<?php
$price = 20;
$price *= 2;
echo "New Price: " . $price; // Outputs: New Price: 40
?>

Notes
 ● The multiplication assignment operator is useful for
scaling values, such as doubling prices or quantities.
● PHP converts numeric strings to numbers
automatically during multiplication.
Warnings
● Ensure that the variable contains a numeric value
before using *= to avoid unexpected behavior.
● Be aware of overflow when multiplying large
integers.

5. Division Assignment Operator ( /= )

What is the Division Assignment Operator
The division assignment operator ( /= ) divides the variable
by the value on the right and then assigns the result to the
variable.

Use Purpose
● Divide values, such as calculating averages or
distributing quantities.
● Adjust values, such as scaling down or finding per-
unit costs.
● Use in loops or conditions to iteratively divide
values.
Syntax

$variable /= value;

Syntax Explanation
● $variable :
○ The variable to be divided and updated.
● /= :
 ○
The division assignment operator, which
divides the variable by the right-hand value
and updates it.
● value :
○ The value to divide the existing variable by.
Simple Code Example

<?php
$total = 100;
$total /= 4;
echo "Per Unit: " . $total; // Outputs: Per Unit: 25
?>

Notes
●The division assignment operator is often used to
distribute values or calculate averages.
● PHP converts numeric strings to floats automatically
during division if the result is not a whole number.
Warnings
● Ensure that the divisor is not zero, as dividing by
zero causes a warning or error.
● Be aware of float results when dividing integers, as
the result can be a float.

6. Modulus Assignment Operator ( %= )

What is the Modulus Assignment Operator
The modulus assignment operator ( %= ) calculates the
remainder of division and assigns it to the variable.
Use Purpose
● Calculate remainders, such as finding even or odd
numbers.
● Cycle through patterns, like alternating elements
in arrays.
 ● Use in loops or conditions to handle repeated
divisions.
Syntax
$variable %= value;

Syntax Explanation
● $variable :
○ The variable to which the modulus operation
is applied.
● %= :
○ The modulus assignment operator, which
calculates the remainder of dividing the
variable by the right-hand value and updates
it.
● value :
○ The value used to divide the existing
variable.
Simple Code Example
<?php
$num = 10;
$num %= 3;
echo "Remainder: " . $num; // Outputs: Remainder: 1
?>
Notes
● The modulus assignment operator is useful for
determining even or odd numbers or cycling patterns.
● Use it in loops to handle repeating patterns or
conditions.
Warnings
● Ensure that the divisor is not zero, as it will generate
a division-by-zero error.
● Use with integers, as modulus operations with non-
integers can yield unexpected results.

7. Exponentiation Assignment Operator ( **= )

What is the Exponentiation Assignment Operator
The exponentiation assignment operator ( **= ) raises the
variable to the power of the value on the right and then
assigns the result to the variable.
Use Purpose
● Calculate powers, like squares, cubes, or
exponential growth.
● Perform mathematical calculations, such as
compound interest or growth rates.
● Handle complex calculations that require raising
numbers to specific powers.
Syntax
$variable **= value;

Syntax Explanation
● $variable :
○ The variable to be raised to a power and
updated.
● **= :
○ The exponentiation assignment operator,
which raises the variable to the power of the
right-hand value and updates it.
● value :
○ The power to raise the existing variable by.
Simple Code Example
<?php
$num = 2;
$num **= 3;
echo "Result: " . $num; // Outputs: Result: 8
?>
Notes
● The exponentiation assignment operator is useful for
calculating powers in scientific, financial, or statistical
calculations.
 ● PHP supports floating-point values in both the base
and the exponent.

Warnings
● Be cautious of overflow or underflow when using
large numbers with exponentiation.
● Exponentiation can consume significant memory
and processing time with large exponents.

8. Concatenation Assignment Operator ( .= )

What is the Concatenation Assignment Operator
The concatenation assignment operator ( .= ) appends the
value on the right to the end of the variable on the left,
updating the variable.
Use Purpose
● Combine strings dynamically, such as building
messages or HTML content.
● Append text to existing strings, like updating
logs or messages.
● Handle string operations in loops or conditions.
Syntax

$variable .= value;

Syntax Explanation
● $variable :
○ The string variable to which another string
will be appended.
● .= :
○ The concatenation assignment operator,
which appends the right-hand string to the
variable and updates it.
● value :
 ○ The string to append to the existing variable.

Simple Code Example

<?php
$message = "Hello";
$message .= " World";
echo $message; // Outputs: Hello World
?>

Notes
● The concatenation assignment operator is
commonly used to build longer strings from smaller
parts.
● It is useful in loops or when constructing dynamic
content, like HTML, logs, or messages.
Warnings
● Ensure that the variable contains a string before
using .= to avoid type conversion issues.
● Be cautious of appending large strings, as it can
affect memory usage and performance.
Final Project: "Shopping Cart Manager"
Project Goal
● Create a PHP script that uses assignment operators
to manage a simple shopping cart.
● Implement calculations for total price, discounts,
and item quantities.
Code for This Project
<?php
// Initial values
$item_price = 50;
$quantity = 2;
$discount = 10; // In percent

// Calculate total cost

$total = $item_price * $quantity;

// Apply discount
$total -= ($total * $discount / 100);
// Display results
echo "Item Price: $" . $item_price . "<br>";
echo "Quantity: " . $quantity . "<br>";
echo "Discount: " . $discount . "%<br>";
echo "Total Cost after Discount: $" . $total . "<br>";
?>

Save and Run

● Save the code as shopping_cart.php .
● Run it on a PHP server or use an online PHP
sandbox.
Check Output
The script will display the initial item price, quantity,
discount percentage, and total cost after applying the
discount, demonstrating the use of assignment operators.
Summary
This chapter provided a comprehensive overview of PHP
assignment operators, covering basic and combined
operations such as addition, subtraction, multiplication,
division, modulus, exponentiation, and concatenation. It
concluded with a project demonstrating how assignment
operators can be used to manage and update data in PHP
applications.
Chapter-6 PHP Comparison Operators
Chapter Overview
This chapter covers PHP comparison operators, which are
used to compare values. These operators are essential in
conditional statements, loops, and logical operations,
allowing developers to control the flow of programs based
on the results of comparisons.
Chapter Goal
● Understand the various comparison operators
available in PHP.
● Learn how to use comparison operators to compare
values effectively.
● Explore examples demonstrating different types of
comparison operators.
● Implement a project that utilizes comparison
operators to manage program logic.

Rules of PHP Comparison Operators

● Logical Comparisons: Comparison operators
evaluate the relationship between two values,
returning either true or false .
● Data Type Handling: Some comparison operators
perform type coercion, converting values to the same
data type before comparison, while others do not.
● Strict vs. Loose Comparison: PHP distinguishes
between strict and loose comparisons, with strict
comparisons also checking the data type.
Syntax Table
Seri Operato Syntax Example
al r
No
1 Equal $a == $b $a = 5; $b = 5; $result =
$a == $b;

2 Identical $a === $a = 5; $b = "5"; $result

$b = $a === $b;
3 Not Equal $a != $b $a = 5; $b = 3; $result =
or $a <> $a != $b;
$b
4 Not $a !== $b $a = 5; $b = "5"; $result
Identical = $a !== $b;
5 Greater $a > $b $a = 5; $b = 3; $result =
Than $a > $b;
6 Less $a < $b $a = 3; $b = 5; $result =
Than $a < $b;
7 Greater $a >= $b $a = 5; $b = 5; $result =
Than or $a >= $b;
Equal To
8 Less $a <= $b $a = 3; $b = 5; $result =
Than or $a <= $b;
Equal To
9 Spaceshi $a <=> $a = 5; $b = 3; $result =
p $b $a <=> $b;
1. Equal Operator ( == )
What is the Equal Operator
The equal operator ( == ) is used to compare two values for
equality. It checks if the values are the same, performing
type coercion if necessary.
Use Purpose
● Compare values in conditional statements, like if
or switch .
● Check for matching values, such as user input
validation or comparing data.
● Evaluate conditions for loops, logical expressions,
or form processing.
Syntax

$result = $a == $b;

Syntax Explanation
● $a and $b :
○ Variables containing values to be compared.
● == :
○ The equal operator returns true if $a is
equal to $b , after type coercion.
● $result :
○ Stores the boolean result of the comparison.
Simple Code Example

<?php
$a = 5;
$b = "5";
$result = $a == $b;
echo "Equal: " . ($result ? "True" : "False"); // Outputs: Equal: True
?>
Notes
● The equal operator performs loose comparison,
converting values to the same type before
comparing.
● It is often used in conditional statements to evaluate
if two values are the same, regardless of type.
Warnings
● Loose comparison can lead to unexpected results if
types are not carefully considered (e.g., "5" == 5 is
true ).
● Use strict comparison ( === ) when type matching
is critical.

2. Identical Operator ( === )

What is the Identical Operator
The identical operator ( === ) checks whether two values
are equal and of the same type. It does not perform type
coercion, ensuring both value and type match.
Use Purpose
● Strictly compare values and types, ensuring
both match.
● Validate data types, such as checking user input
for specific types.
● Use in conditions where type matching is crucial,
like validating form data or handling JSON responses.
Syntax
$result = $a === $b;
Syntax Explanation
● $a and $b :
○ Variables containing values to be compared.
● === :
 ○ The identical operator returns true only if
$a and $b are equal and of the same type.
● $result :
○ Stores the boolean result of the comparison.
Simple Code Example

<?php
$a = 5;
$b = "5";
$result = $a === $b;
echo "Identical: " . ($result ? "True" : "False"); // Outputs: Identical: False
?>

Notes
● The identical operator is useful for strict
comparison, ensuring both value and type match.
● It is commonly used in data validation and API
responses to ensure precise matches.
Warnings
● The identical operator will return false if the types
do not match, even if the values are the same ( "5"
=== 5 is false ).
● Use the identical operator when handling sensitive
data or validating data types.

3. Not Equal Operator ( != or <> )

What is the Not Equal Operator
The not equal operator ( != or <> ) checks if two values
are not equal, performing type coercion if necessary.
Use Purpose
● Compare values to ensure they are different.
 ● Handle negative conditions in loops, conditions,
or form validation.
● Check for mismatches in data, like incorrect
inputs or failed matches.

Syntax

$result = $a != $b;

Syntax Explanation
● $a and $b :
○ Variables containing values to be compared.
● != or <> :
○ The not equal operator returns true if $a is
not equal to $b , after type coercion.
● $result :
○ Stores the boolean result of the comparison.
Simple Code Example

<?php
$a = 5;
$b = 3;
$result = $a != $b;
echo "Not Equal: " . ($result ? "True" : "False"); // Outputs: Not Equal: True
?>

Notes
● The not equal operator is used for loose
comparison, similar to the equal operator, allowing
type coercion.
● It is commonly used to check if values are different
in conditions and loops.
Warnings
 ● Be aware of type coercion, as it can lead to
unexpected results ( "5" != 5 is false ).
● Use strict not equal ( !== ) for more precise
comparisons.

4. Not Identical Operator ( !== )

What is the Not Identical Operator
The not identical operator ( !== ) checks whether two
values are not equal or not of the same type, without type
coercion.
Use Purpose
● Strictly check for inequality, ensuring values and
types do not match.
● Handle conditions where exact type matching is
required.
● Validate data precisely, such as ensuring input
types match expected types.
Syntax

$result = $a !== $b;

Syntax Explanation
● $a and $b :
○ Variables containing values to be compared.
● !== :
○ The not identical operator returns true if $a
and $b are not equal or not of the same type.
● $result :
○ Stores the boolean result of the comparison.
Simple Code Example
<?php
$a = 5;
$b = "5";
$result = $a !== $b;
echo "Not Identical: " . ($result ? "True" : "False"); // Outputs: Not Identical: True
?>

Notes
● The not identical operator is useful for strict
validation, ensuring both values and types are
checked.
● It is often used in secure validation scenarios, like
form inputs or API data handling.
Warnings
● Unlike the not equal operator, the not identical
operator returns true if either the value or the type
does not match.
● Use this operator when handling sensitive data or
validating strict data types.

5. Greater Than Operator ( > )

What is the Greater Than Operator
The greater than operator ( > ) checks if the left value is
greater than the right value.
Use Purpose
● Compare numeric values, such as scores, prices,
or quantities.
● Use in loops or conditions to handle ranges or
thresholds.
● Evaluate results, like determining maximum
values or limits.
Syntax
$result = $a > $b;
Syntax Explanation
● $a and $b :
○ Variables containing values to be compared.
● >:
○ The greater than operator returns true if $a
is greater than $b .
● $result :
○ Stores the boolean result of the comparison.
Simple Code Example
<?php
$a = 10;
$b = 5;
$result = $a > $b;
echo "Greater Than: " . ($result ? "True" : "False"); // Outputs: Greater Than:
True
?>

Notes
● The greater than operator is commonly used in
loops, conditions, and range checks.
● It works with both integers and floats, comparing
numeric values directly.
Warnings
● Ensure that both values are numeric or convertible
to numbers to avoid unexpected results.
● Be aware of float precision when comparing floating-
point numbers.

6. Less Than Operator ( < )

What is the Less Than Operator
The less than operator ( < ) checks if the left value is less
than the right value.
Use Purpose
● Compare numeric values, such as minimums,
scores, or prices.
● Handle conditions in loops, like finding the
smallest values or setting limits.
● Evaluate ranges, such as checking if a value falls
below a threshold.
Syntax
$result = $a < $b;
Syntax Explanation
● $a and $b :
○ Variables containing values to be compared.
● <:
○ The less than operator returns true if $a is
less than $b .
● $result :
○ Stores the boolean result of the comparison.
Simple Code Example

<?php
$a = 5;
$b = 10;
$result = $a < $b;
echo "Less Than: " . ($result ? "True" : "False"); // Outputs: Less Than: True
?>

Notes
● The less than operator is used for numeric
comparisons, handling lower bounds and limits.
● It is effective in loops and conditions for evaluating
ranges.
Warnings
 ● Ensure that values are numeric to avoid unexpected
results.
● Use with care when comparing floats, as precision
can affect results.

7. Greater Than or Equal To Operator ( >= )

What is the Greater Than or Equal To Operator
The greater than or equal to operator ( >= ) checks if the
left value is greater than or equal to the right value.
Use Purpose
● Evaluate ranges, such as checking if values meet
minimum requirements.
● Compare thresholds, ensuring values are within
specified bounds.
● Handle loops or conditions, like setting upper
bounds or limits.
Syntax

$result = $a >= $b;

Syntax Explanation
● $a and $b :
○ Variables containing values to be compared.
● >= :
○ The operator returns true if $a is greater
than or equal to $b .
● $result :
○ Stores the boolean result of the comparison.
Simple Code Example

<?php
$a = 5;
$b = 5;
$result = $a >= $b;
echo "Greater or Equal: " . ($result ? "True" : "False"); // Outputs: Greater or
Equal: True
?>

Notes
● The greater than or equal to operator checks both
conditions in one step, making it useful for inclusive
ranges.
● It works with both integers and floats, evaluating
numeric values directly.
Warnings
● Ensure that both values are numeric to prevent
unexpected behavior.
● Be aware of float precision when using this operator.

8. Less Than or Equal To Operator ( <= )

What is the Less Than or Equal To Operator
The less than or equal to operator ( <= ) checks if the left
value is less than or equal to the right value.

Use Purpose
● Compare minimum values, ensuring values do
not fall below a threshold.
● Handle conditions in loops, like setting lower
bounds or limits.
● Evaluate ranges, checking if values are within
acceptable limits.
Syntax

$result = $a <= $b;

Syntax Explanation
●
$a and $b :
○ Variables containing values to be compared.
● <= :
○ The operator returns true if $a is less than
or equal to $b .
● $result :
○ Stores the boolean result of the comparison.
Simple Code Example
<?php
$a = 3;
$b = 5;
$result = $a <= $b;
echo "Less or Equal: " . ($result ? "True" : "False"); // Outputs: Less or Equal:
True
?>
Notes
● The less than or equal to operator is useful for
setting inclusive lower bounds in conditions.
● It works with both integers and floats, evaluating
numeric values directly.
Warnings
● Ensure that both values are numeric to avoid
unexpected results.
● Use caution when comparing floats, as precision can
affect outcomes.

9. Spaceship Operator ( <=> )

What is the Spaceship Operator
The spaceship operator ( <=> ) is a three-way comparison
operator that returns -1 , 0 , or 1 , depending on whether
the left value is less than, equal to, or greater than the right
value.
Use Purpose
● Perform combined comparisons in a single
operation.
● Sort arrays or compare values in loops or
conditions.
● Evaluate numerical or string comparisons,
returning detailed results.
Syntax

$result = $a <=> $b;

Syntax Explanation
● $a and $b :
○ Variables containing values to be compared.
● <=> :
○ The spaceship operator returns -1 if $a is
less than $b , 0 if they are equal, and 1 if $a
is greater than $b .
● $result :
○ Stores the result of the comparison,
indicating the relationship between $a and
$b .
Simple Code Example
<?php
$a = 5;
$b = 3;
$result = $a <=> $b;
echo "Comparison Result: " . $result; // Outputs: Comparison Result: 1
?>
Notes
● The spaceship operator is useful for sorting
algorithms, as it returns detailed comparison results
in one step.
 ● It is effective in numeric, string, and combined
comparisons.
Warnings
● Ensure that both values are of comparable types to
avoid unexpected results.
● Use caution when using this operator with floats due
to potential precision issues.

Final Project: "Age Comparison Tool"

Project Goal
● Create a PHP script that uses comparison operators
to compare user input values.
● Implement comparisons to check if one age is
greater, less, or equal to another.
Code for This Project
<?php
// Define ages
$age1 = 25;
$age2 = 30;
// Perform comparisons
$is_equal = $age1 == $age2;
$is_greater = $age1 > $age2;
$is_less = $age1 < $age2;
// Display results
echo "Age 1: " . $age1 . ", Age 2: " . $age2 . "<br>";
echo "Are ages equal? " . ($is_equal ? "Yes" : "No") . "<br>";
echo "Is Age 1 greater than Age 2? " . ($is_greater ? "Yes" : "No") . "<br>";
echo "Is Age 1 less than Age 2? " . ($is_less ? "Yes" : "No") . "<br>";
?>
Save and Run
● Save the code as age_comparison.php .
● Run it on a PHP server or use an online PHP
sandbox.
Check Output
The script will display the results of comparing two age
values, demonstrating the use of comparison operators.
Summary
This chapter provided a comprehensive overview of PHP
comparison operators, covering equal, identical, not equal,
not identical, greater than, less than, greater than or equal
to, less than or equal to, and the spaceship operator. It
concluded with a project demonstrating how to use
comparison operators for decision-making and logic flow in
PHP applications.

Chapter-7 PHP Logical Operators

Chapter Overview
This chapter covers PHP logical operators, which are used to
combine or modify conditions. Logical operators allow
developers to control program flow by evaluating multiple
conditions simultaneously and determining overall
outcomes.
Chapter Goal
● Understand the different logical operators available
in PHP.
● Learn how to use logical operators to combine and
manage multiple conditions effectively.
● Explore examples demonstrating various logical
operations.
● Implement a project that utilizes logical operators to
handle complex decision-making.

Rules of PHP Logical Operators

● Boolean Context: Logical operators work in a
boolean context, meaning they return either true or
false .
● Short-circuit Evaluation: Some logical operators,
like && and || , use short-circuit evaluation, stopping
evaluation as soon as the result is determined.
● Combining Conditions: Logical operators are used
to combine multiple conditions in if , while , and for
statements, enabling more complex decision-making.
Syntax Table
Seri Operator Syntax Example
al
No
1 AND $a && $b $a = true; $b = false;
$result = $a && $b;

3 NOT !$a $a = true; $result = !$a;

4 AND $a and $a = true; $b = false;
(Alternative $b $result = $a and $b;
)
5 OR $a or $b $a = true; $b = false;
(Alternative $result = $a or $b;
)
6 XOR $a xor $b $a = true; $b = false;
$result = $a xor $b;

1. AND Operator ( && )

What is the AND Operator
The AND operator ( && ) evaluates to true only if both
conditions are true. It is used to combine conditions where
all conditions must be satisfied.
Use Purpose
● Combine multiple conditions that all need to be
true.
● Control flow in if statements, loops, or while
checks.
● Filter results where multiple criteria must be met,
such as form validation or data processing.
Syntax
$result = $a && $b;

Syntax Explanation
● $a and $b :
○ Variables containing boolean values to be
combined.
● && :
○ The AND operator returns true if both $a
and $b are true.
● $result :
○ Stores the boolean result of the logical
operation.
Simple Code Example

<?php
$is_admin = true;
$is_logged_in = true;
$can_access = $is_admin && $is_logged_in;
echo "Access Granted: " . ($can_access ? "Yes" : "No"); // Outputs: Access
Granted: Yes
?>

Notes
● The AND operator stops evaluating as soon as one
condition is false (short-circuit evaluation).
● It is commonly used in complex conditions where
multiple checks are required.
Warnings
● Ensure that both operands are boolean or can be
converted to boolean to avoid unexpected results.
● Using && has higher precedence than and , so use
parentheses to clarify expressions when needed.
2. OR Operator ( || )
What is the OR Operator
The OR operator ( || ) evaluates to true if at least one of the
conditions is true. It is used when only one of the conditions
needs to be satisfied.
Use Purpose
● Combine conditions where either can be true.
● Handle alternative paths in if statements or
loops.
● Check for multiple possibilities, such as form
fields or user permissions.
Syntax

$result = $a || $b;

Syntax Explanation
● $a and $b :
○ Variables containing boolean values to be
combined.
● || :
○ The OR operator returns true if either $a or
$b is true.
● $result :
○ Stores the boolean result of the logical
operation.
Simple Code Example

<?php
$is_member = false;
$is_guest = true;
$can_view = $is_member || $is_guest;
echo "View Allowed: " . ($can_view ? "Yes" : "No"); // Outputs: View Allowed: Yes
?>
Notes
● The OR operator stops evaluating as soon as one
condition is true (short-circuit evaluation).
● It is useful for handling alternative conditions, such
as user roles or access levels.
Warnings
● Use parentheses to clarify expressions when
combining OR with other operators.
● The || operator has higher precedence than or , so
parentheses may be needed to ensure correct
evaluation.

3. NOT Operator ( ! )
What is the NOT Operator
The NOT operator ( ! ) inverts the boolean value of a
condition, turning true to false and vice versa.
Use Purpose
● Negate conditions, such as checking if a value is
not true.
● Reverse logic, such as denying access or stopping
execution.
● Handle exceptions, like rejecting invalid inputs or
states.
Syntax

$result = !$a;

Syntax Explanation
● $a :
○ A variable containing a boolean value to be
inverted.
● !:
 ○ The NOT operator inverts the value of $a .
● $result :
○ Stores the negated boolean result of the
logical operation.
Simple Code Example
<?php
$is_logged_in = false;
$must_login = !$is_logged_in;
echo "Must Login: " . ($must_login ? "Yes" : "No"); // Outputs: Must Login: Yes
?>
Notes
● The NOT operator is used to reverse conditions,
often making code more readable by explicitly stating
negative conditions.
● It is frequently used in loops and conditional checks
to handle exceptions or deny access.
Warnings
● Ensure that the operand is boolean or can be
converted to boolean to avoid unexpected results.
● Use the NOT operator carefully, as double negation
( !! ) can make code harder to read.

4. AND Operator ( and )

What is the AND Operator ( and )
The and operator works similarly to && , evaluating to
true only if both conditions are true. It is less commonly
used due to its lower precedence.
Use Purpose
● Combine conditions in simpler scenarios where
logical flow is straightforward.
● Ensure both conditions are met in less complex
logic statements.
 ● Control flow in conditions where readability is more
important than operator precedence.
Syntax

$result = $a and $b;

Syntax Explanation
● $a and $b :
○ Variables containing boolean values to be
combined.
● and :
○ The AND operator returns true if both $a
and $b are true, but it has lower precedence
than && .
● $result :
○ Stores the boolean result of the logical
operation.

Simple Code Example

<?php
$is_admin = true;
$is_active = false;
$can_manage = $is_admin and $is_active;
echo "Can Manage: " . ($can_manage ? "Yes" : "No"); // Outputs: Can Manage:
No
?>

Notes
● The and operator is useful for simplifying
expressions where operator precedence does not
affect the result.
 ● It is often used in simpler conditions or where
readability takes priority.
Warnings
● The and operator has lower precedence than && ,
which can cause unexpected results in complex
expressions.
● Use parentheses to clarify expressions when mixing
and with other operators.

5. OR Operator ( or )
What is the OR Operator ( or )
The or operator functions similarly to || , returning true if
either condition is true. It has lower precedence compared
to || .
Use Purpose
● Combine alternative conditions in simpler
expressions.
● Handle cases where either of the conditions can be
true.
● Manage logical flow in straightforward scenarios.
Syntax

$result = $a or $b;

Syntax Explanation
● $a and $b :
○ Variables containing boolean values to be
combined.
● or :
○ The OR operator returns true if either $a or
$b is true, but it has lower precedence than
 || .
● $result :
○ Stores the boolean result of the logical
operation.
Simple Code Example

<?php
$is_admin = false;
$is_editor = true;
$can_edit = $is_admin or $is_editor;
echo "Can Edit: " . ($can_edit ? "Yes" : "No"); // Outputs: Can Edit: Yes
?>

Notes
● The or operator is often used for simpler
conditions or when readability is more important
than operator precedence.
● It provides a clearer alternative for combining
conditions in certain scenarios.
Warnings
● The or operator has lower precedence than || ,
which can affect the outcome of complex
expressions.
● Use parentheses to ensure correct evaluation when
combining or with other operators.

6. XOR Operator ( xor )

What is the XOR Operator
The XOR operator ( xor ) returns true if one, and only one,
of the conditions is true. It is used when only one of the
conditions must be true, but not both.
Use Purpose
● Check mutually exclusive conditions, where
only one can be true.
● Handle alternative logic, like toggles or switches.
● Evaluate exclusive cases, ensuring that only one
condition is satisfied.
Syntax
$result = $a xor $b;

Syntax Explanation
● $a and $b :
○ Variables containing boolean values to be
combined.
● xor :
○ The XOR operator returns true if only one of
the conditions is true.
● $result :
○ Stores the boolean result of the logical
operation.
Simple Code Example
<?php
$is_day = true;
$is_night = false;
$is_light_on = $is_day xor $is_night;
echo "Light On: " . ($is_light_on ? "Yes" : "No"); // Outputs: Light On: Yes
?>
Notes
● The XOR operator is useful for exclusive
conditions, where only one of the conditions must
be true.
● It is effective for toggling states, like user settings or
feature switches.
Warnings
 ● Ensure that the conditions are truly mutually
exclusive; otherwise, the result may not be as
expected.
Final Project: "Login System Simulation"
Project Goal
● Create a PHP script that uses logical operators to
manage a simple login system.
● Implement checks to determine if a user has valid
credentials and access rights.
Code for This Project
<?php
// User credentials
$username = "admin";
$password = "1234";

// User input
$input_username = "admin";
$input_password = "1234";

// Access conditions
$is_valid_user = ($input_username == $username) && ($input_password ==
$password);
$is_admin = $input_username == "admin";

// Check access
if ($is_valid_user && $is_admin) {
echo "Access Granted: Admin User";
} elseif ($is_valid_user && !$is_admin) {
echo "Access Granted: Regular User";
} else {
echo "Access Denied";
}
?>
Save and Run
● Save the code as login_system.php .
● Run it on a PHP server or use an online PHP
sandbox.
Check Output
The script will display whether access is granted or denied,
based on the user’s credentials and access level.
Summary
This chapter provided a comprehensive overview of PHP
logical operators, covering AND ( && ), OR ( || ), NOT ( ! ),
and their alternatives ( and , or , xor ). It concluded with a
project demonstrating how logical operators can be used for
decision-making and access control in PHP applications.
Chapter-8 PHP Printing Data
Chapter Overview
This chapter covers printing data in PHP, focusing on
different methods for outputting information to the screen.
PHP provides several functions for displaying data, allowing
developers to output text, variables, arrays, and HTML
content.
Chapter Goal
● Understand the different functions for printing data
in PHP.
● Learn how to use various printing methods for text,
variables, arrays, and HTML.
● Explore examples demonstrating the use of different
printing functions.
● Implement a project that utilizes data printing
methods to generate dynamic content.

Rules of PHP Printing Data

● Output Context: Printing functions can display
text, variables, or formatted HTML content.
● Concatenation: PHP allows concatenating strings
and variables during printing, enabling dynamic
output.
● Compatibility: Most printing functions work
similarly, but some have slight differences in behavior
and performance.
Syntax Table
Seri Printing Syntax Example
al Method
No
1 echo echo value; echo "Hello,
World!";

2 print print value; print "Welcome!";

3 print_r print_r(array); print_r($array);
4 var_dum var_dump(value); var_dump($value);
p
5 sprintf $formatted_string $formatted_string =
= sprintf(format, sprintf("Hello, %s",
values); "Alice");
6 printf printf(format, printf("Price:
values); $%.2f", 9.99);

1. echo
What is echo
The echo statement is one of the most commonly used
functions in PHP for printing data. It outputs one or more
strings, variables, or HTML content to the screen. It is faster
than print and supports concatenation for dynamic output.

Use Purpose
● Display strings and variables directly to the
browser.
 ● Output HTML content, enabling dynamic web
page generation.
● Combine multiple strings, variables, or HTML
tags into a single output.
Syntax

echo value;

Syntax Explanation
● value :
○ The value to be printed, which can be a
string, variable, or concatenated string.
○ Multiple values can be combined using
commas, but they must be strings or variables.
Simple Code Example

<?php
$name = "Alice";
echo "Hello, " . $name . "!"; // Outputs: Hello, Alice!
?>

Notes
● echo can print multiple arguments separated by
commas, but parentheses are optional and not
required.
● It is the most efficient method for simple output.
Warnings
● echo cannot return a value, so it cannot be used as
part of an expression.
● Be cautious when concatenating variables to avoid
unintended results, especially with uninitialized
variables.
2. print
What is print
The print statement is similar to echo but returns a value
of 1, making it possible to use in expressions. It outputs a
single string or variable to the screen and is slightly slower
than echo .
Use Purpose
● Display strings and variables directly to the
browser.
● Use in expressions due to its return value.
● Output simple content, such as messages or
variables.
Syntax

print value;

Syntax Explanation
● value :
○ The value to be printed, which can be a string
or variable.
○ It does not support printing multiple values or
using commas like echo .
Simple Code Example
<?php
$name = "Bob";
print "Welcome, " . $name . "!"; // Outputs: Welcome, Bob!
?>
Notes
● print returns 1, allowing it to be used in expressions
(e.g., if (print("Hi")) ).
● It is often used interchangeably with echo for
simple output.
Warnings
 ● Unlike echo , print can only handle one argument,
making it less flexible for concatenation.
● print is slightly slower than echo , so use it when
return value matters.

3. print_r
What is print_r
The print_r function is used to print human-readable
information about arrays, objects, or other complex data
types. It is useful for debugging or displaying array
contents.
Use Purpose
● Display array contents in a readable format.
● Debug arrays, objects, and complex variables
during development.
● Output structured data, such as arrays or objects,
to understand their contents.
Syntax

print_r(array);

Syntax Explanation
●array :
○ The array or object to be printed, displayed in
a structured format.
○ Works with other complex data types as well.
Simple Code Example
<?php
$fruits = array("apple", "banana", "cherry");
print_r($fruits);
/* Outputs:
Array
(
[0] => apple
 [1] => banana
[2] => cherry
)
*/
?>
Notes
● print_r outputs array elements in a structured
format, making it useful for debugging.
● It can be used to inspect objects, arrays, and nested
arrays.
Warnings
● print_r is primarily for debugging and should not be
used in production output, as it lacks formatting.
● When used in HTML, it may need <pre> tags for
better readability.

4. var_dump
What is var_dump
The var_dump function outputs detailed information about
variables, including their data type, length, and value. It is
primarily used for debugging complex data structures.
Use Purpose
● Display detailed information about variables,
such as type, value, and size.
● Debug arrays, objects, and complex variables
for development.
● Inspect data types during validation or testing.
Syntax

var_dump(value);

Syntax Explanation
● value :
 ○ The variable or value to be printed, showing
its type, size, and content.
○ Works with arrays, objects, and other
complex data types.
Simple Code Example

<?php
$num = 10.5;
var_dump($num); // Outputs: float(10.5)
?>

Notes
● var_dump provides more detailed information than
print_r , making it ideal for debugging.
● It displays information about data types, lengths,
and nested structures.
Warnings
● var_dump is meant for debugging and should be
avoided in production, as it can expose sensitive
information.
● When used in web pages, it may need <pre> tags
for better readability.

5. sprintf
What is sprintf
The sprintf function returns a formatted string according to
a specified format. Unlike printf , it does not print directly
but stores the formatted string in a variable.
Use Purpose
● Format strings and variables for more control
over output.
● Store formatted strings in variables for further
processing.
 ● Create formatted messages, like currency values
or complex outputs.
Syntax
$formatted_string = sprintf(format, values);
Syntax Explanation
● format :
○ The format specifier, defining how the output
should be structured (e.g., %s for string, %d
for integer, %.2f for float with two decimals).
● values :
○ The variables or values to be formatted
according to the specified format.
● $formatted_string :
○ Stores the resulting formatted string for
further use.
Simple Code Example

<?php
$name = "Alice";
$age = 30;
$formatted = sprintf("Name: %s, Age: %d", $name, $age);
echo $formatted; // Outputs: Name: Alice, Age: 30
?>

Notes
● sprintf is useful for creating formatted strings
that can be stored and reused later.
● It provides more control over the formatting of
strings, numbers, and variables.
Warnings
● Ensure that the format specifiers match the
corresponding variable types to avoid errors.
 ● sprintf does not print the string; use echo to
display it.

6. printf
What is printf
The printf function outputs a formatted string according to
a specified format. It directly prints the formatted result to
the screen, similar to sprintf but with immediate output.
Use Purpose
● Print formatted strings and variables directly to
the screen.
● Control the format of output, such as decimals,
padding, and alignment.
● Generate formatted content, like tables, lists, or
reports.
Syntax

printf(format, values);

Syntax Explanation
● format :
○ The format specifier, defining the structure of
the output (e.g., %s for string, %d for
integer, %.2f for float with two decimals).
● values :
○ The variables or values to be formatted and
printed according to the specified format.
Simple Code Example

<?php
$price = 9.99;
printf("Price: $%.2f", $price); // Outputs: Price: $9.99
?>

Notes
● printf is useful for generating formatted output
in real-time, such as when creating tables or reports.
● It offers greater control over formatting, making it
ideal for structured output.
Warnings
● Ensure that the format specifiers match the
corresponding variable types to avoid incorrect
output.
● printf immediately outputs the formatted string,
unlike sprintf , which returns it.

Final Project: "User Profile Display"

Project Goal
● Create a PHP script that prints user profile
information using different printing functions.
● Implement formatted outputs for various user
attributes like name, age, and email.
Code for This Project

<?php
// User details
$name = "Alice Johnson";
$age = 28;
$email = "[email protected]";
$interests = array("Reading", "Traveling", "Cooking");

// Display user information

echo "<h2>User Profile</h2>";
echo "Name: " . $name . "<br>";
print "Age: " . $age . "<br>";
printf("Email: %s<br>", $email);

echo "<h3>Interests:</h3>";
print_r($interests);
?>

Save and Run

● Save the code as user_profile.php .
● Run it on a PHP server or use an online PHP
sandbox.
Check Output
The script will display the user’s profile information,
including name, age, email, and interests, using different
printing functions.
Summary
This chapter provided a comprehensive overview of PHP
printing data methods, covering echo , print , print_r ,
var_dump , sprintf , and printf . It concluded with a project
demonstrating how to use different printing functions to
display formatted user profile information in PHP
applications.
Chapter-9 PHP Working with Strings
and Numbers
Chapter Overview
This chapter covers the manipulation of strings and
numbers in PHP, which is crucial for processing text and
numerical data. PHP provides a variety of functions for
handling strings, including concatenation, searching, and
formatting, as well as numerical operations like rounding,
absolute values, and type conversion.
Chapter Goal
● Understand how to work with strings and numbers in
PHP.
● Learn how to manipulate strings using various
functions.
● Explore numerical functions for calculations,
rounding, and conversions.
● Implement a project that demonstrates string and
number operations.

Rules of Working with Strings and Numbers

● Dynamic Typing: PHP dynamically handles types,
meaning variables can change types based on the
value assigned.
● String Manipulation: PHP provides various built-in
functions for string operations, such as
concatenation, formatting, and searching.
● Numeric Operations: PHP supports integer and
float calculations, with functions for rounding,
absolute values, and conversions.
Syntax Table
Seri Operation Syntax Example
al
No
1 String $str = $str1 . $str2; $str = "Hello, " .
Concatenati "World!";
on

2 String $len = strlen($str); $len = strlen("Hello");

Length
3 String $str = $str =
Uppercase strtoupper($str); strtoupper("hello");
4 String $str = $str =
Lowercase strtolower($str); strtolower("HELLO");

5 Round $rounded = $rounded =

Number round($num); round(4.567);
6 Absolute $abs = abs($num); $abs = abs(-10);
Value

7 Number $formatted = $formatted =

Format number_format($nu number_format(1234.
m, 2); 5, 2);

1. String Concatenation
What is String Concatenation
String concatenation is the process of joining two or more strings
together to form a single string. PHP uses the dot operator ( . ) to
concatenate strings.
Use Purpose
● Combine strings dynamically, such as creating
messages or combining variables with text.
● Build HTML content, such as generating dynamic
elements or attributes.
 ● Create formatted text, like combining user input with
predefined templates.
Syntax

$concatenated_string = $string1 . $string2;

Syntax Explanation
● $string1 and $string2 :
○ The strings to be concatenated.
● . (Dot operator):
○ Joins two strings together to form a single string.
● $concatenated_string :
○ Stores the resulting concatenated string.
Simple Code Example

<?php
$first_name = "Alice";
$last_name = "Johnson";
$full_name = $first_name . " " . $last_name;
echo "Full Name: " . $full_name; // Outputs: Full Name: Alice Johnson
?>
Notes
● Concatenation is commonly used to combine variables,
strings, and HTML.
● PHP allows concatenating variables of different types,
automatically converting them to strings.
Warnings
● Be careful when concatenating variables with potential
null or undefined values, as this can cause unexpected
results.
● Use clear spacing and delimiters to improve readability
when combining multiple strings.

2. String Length ( strlen )

What is String Length ( strlen )
The strlen function returns the length of a string, measured in the
number of characters. It is commonly used to validate string
length or check input data.
Use Purpose
● Determine the length of a string, such as for
validation or data processing.
● Check if a string is empty by comparing its length to
zero.
● Limit string output, like truncating long text or verifying
input size.
Syntax

$length = strlen($string);

Syntax Explanation
● $string :
○ The string whose length is being measured.
● strlen() :
○ A built-in PHP function that returns the number of
characters in the string.
● $length :
○ Stores the length of the string.
Simple Code Example
<?php
$message = "Hello, World!";
$length = strlen($message);
echo "Length: " . $length; // Outputs: Length: 13
?>
Notes
● The strlen function counts spaces and special characters
as part of the string length.
● It is useful for input validation, ensuring that strings meet
length requirements.
Warnings
● Be aware that strlen does not account for multibyte
characters; use mb_strlen for multibyte strings like UTF-8.
● Ensure the variable is a string to avoid unexpected results.

3. Convert String to Uppercase ( strtoupper )

What is Convert String to Uppercase ( strtoupper )
The strtoupper function converts all characters in a string to
uppercase. It is often used for formatting or normalizing user
input.
Use Purpose
● Standardize strings for comparison or display, such as
making text uppercase.
● Format user input, such as converting names or codes
to uppercase.
● Prepare strings for validation, ensuring case-
insensitive comparison.
Syntax

$uppercase_string = strtoupper($string);
Syntax Explanation
● $string :
○ The string to be converted to uppercase.
● strtoupper() :
○ A built-in PHP function that converts the string to
uppercase.
● $uppercase_string :
○ Stores the resulting uppercase string.
Simple Code Example
<?php
$word = "hello";
$uppercase_word = strtoupper($word);
echo $uppercase_word; // Outputs: HELLO
?>

Notes
● strtoupper is useful for formatting text, like making
names, codes, or titles uppercase.
● It is case-insensitive and works with ASCII characters.
Warnings
 ● Use mb_strtoupper for converting multibyte strings, like
UTF-8 characters, to uppercase.
● It only converts letters; special characters and numbers
remain unchanged.

4. Convert String to Lowercase ( strtolower )

What is Convert String to Lowercase ( strtolower )
The strtolower function converts all characters in a string to
lowercase. It is used to normalize strings for consistent
comparison or display.
Use Purpose
● Normalize strings for case-insensitive comparison, such
as comparing usernames.
● Format user input consistently by converting text to
lowercase.
● Prepare strings for validation, ensuring case
consistency.
Syntax
$lowercase_string = strtolower($string);
Syntax Explanation
● $string :
○ The string to be converted to lowercase.
● strtolower() :
○ A built-in PHP function that converts the string to
lowercase.
● $lowercase_string :
○ Stores the resulting lowercase string.
Simple Code Example

<?php
$word = "HELLO";
$lowercase_word = strtolower($word);
echo $lowercase_word; // Outputs: hello
?>

Notes
 ● strtolower is commonly used to prepare text for
consistent, case-insensitive comparisons.
● It is effective for normalizing user input, making data
validation easier.
Warnings
● Use mb_strtolower for converting multibyte strings to
lowercase.
● It only converts letters; special characters and numbers
remain unaffected.

5. Round Numbers ( round )

What is Round Numbers ( round )
The round function rounds a floating-point number to the nearest
integer or to a specified number of decimal places. It is useful for
displaying formatted numbers or limiting precision.
Use Purpose
● Round numbers to whole numbers or specific decimal
places.
● Format numerical output, such as prices or scores.
● Prepare numbers for further calculations or display.
Syntax
$rounded_number = round($number, decimals);

Syntax Explanation
● $number :
○ The floating-point number to be rounded.
● decimals (optional):
○ The number of decimal places to round to. If
omitted, it rounds to the nearest whole number.
● round() :
○ A built-in PHP function that rounds the number.
● $rounded_number :
○ Stores the resulting rounded number.
Simple Code Example
<?php
$price = 4.567;
$rounded_price = round($price, 2);
echo "Rounded Price: " . $rounded_price; // Outputs: Rounded Price: 4.57
?>

Notes
● round is useful for financial calculations, ensuring prices
or amounts are displayed with appropriate precision.
● It supports rounding up or down based on standard
rounding rules.
Warnings
● Be aware of potential precision issues with floating-point
numbers.
● Use ceil or floor for consistent rounding up or down,
respectively.

6. Absolute Value ( abs )

What is Absolute Value ( abs )
The abs function returns the absolute (positive) value of a
number, removing its sign. It is used to ensure that a number is
non-negative.
Use Purpose
● Calculate distances or differences, where only positive
values are needed.
● Handle negative values, converting them to positive.
● Prepare numbers for further calculations, ensuring
non-negative results.
Syntax

$absolute_value = abs($number);

Syntax Explanation
● $number :
 ○
The number whose absolute value is to be
calculated.
● abs() :
○ A built-in PHP function that returns the absolute
value.
● $absolute_value :
○ Stores the resulting absolute value.
Simple Code Example
<?php
$number = -10;
$positive_number = abs($number);
echo "Absolute Value: " . $positive_number; // Outputs: Absolute Value: 10
?>
Notes
● abs is commonly used to calculate distances,
differences, or non-negative results.
● It works with both integers and floats, converting negative
values to positive.
Warnings
● Ensure that the variable is numeric to avoid errors or
unexpected behavior.
● abs only removes the sign; it does not affect the
magnitude of the number.

7. Number Format ( number_format )

What is Number Format ( number_format )
The number_format function formats a number with grouped
thousands and specified decimal places, making it more readable.
Use Purpose
● Format numbers for display, such as prices, scores, or
statistical results.
● Add commas for readability, like in financial reports or
tables.
● Ensure consistent numerical formatting, especially
for currency values.
Syntax
$formatted_number = number_format($number, decimals);

Syntax Explanation
● $number :
○ The number to be formatted.
● decimals (optional):
○ The number of decimal places to include in the
output.
● number_format() :
○ A built-in PHP function that formats the number.
● $formatted_number :
○ Stores the resulting formatted string.
Simple Code Example

<?php
$amount = 1234.567;
$formatted_amount = number_format($amount, 2);
echo "Formatted Amount: $" . $formatted_amount; // Outputs: Formatted Amount:
$1,234.57
?>

Notes
● number_format is useful for financial displays, ensuring
consistent presentation of prices and amounts.
● It adds commas to thousands and formats decimal places
for better readability.
Warnings
● Ensure that the variable is numeric before formatting.
● Be cautious of potential rounding when specifying decimal
places.
Final Project: "User Report Generator"
Project Goal
● Create a PHP script that generates a formatted user
report, demonstrating string manipulation and numerical
formatting.
 ● Implement features like string concatenation, string length
checks, and number formatting.
Code for This Project

<?php
// User details
$name = "Alice Johnson";
$age = 28;
$salary = 3500.456;

// String operations
$greeting = "Welcome, " . $name . "!";
$name_length = strlen($name);

// Numerical operations
$formatted_salary = number_format($salary, 2);
$rounded_age = round($age);

// Display results
echo "<h2>User Report</h2>";
echo "Name: " . $name . " (Length: " . $name_length . " characters)<br>";
echo "Age: " . $rounded_age . "<br>";
echo "Monthly Salary: $" . $formatted_salary . "<br>";
?>

Save and Run

● Save the code as user_report.php .
● Run it on a PHP server or use an online PHP sandbox.
Check Output
The script will display a user report with formatted strings and
numbers, including name, age, and salary.
Summary
This chapter provided a comprehensive overview of working with
strings and numbers in PHP, covering string concatenation, length,
case conversion, and numerical operations like rounding, absolute
values, and formatting. It concluded with a project demonstrating
the combined use of string and number manipulation in PHP
applications.
Chapter-10 PHP Control Structures
Chapter Overview
This chapter covers PHP control structures, which allow for
conditional execution and repetitive tasks in code. These
structures include conditionals like if , if-else , and switch ,
as well as loops like while , do-while , for , and foreach ,
enabling developers to control program flow efficiently.
Chapter Goal
● Understand the different control structures available
in PHP.
● Learn how to use conditional statements and loops
for decision-making and repetitive tasks.
● Explore detailed examples demonstrating various
control structures.
● Implement a project that integrates multiple control
structures to manage program flow.

Rules of PHP Control Structures

● Conditionals: These structures allow code
execution based on whether conditions are true or
false.
● Loops: Loops enable repeated execution of code
until a specific condition is met.
● Control Flow Clarity: Proper indentation and clear
logic are essential for readability and debugging.
Syntax Table
Seri Control Syntax Example
al Structur
No e
1 if if (condition) { if ($age > 18) {
code; } echo "Adult"; }

2 if-else if (condition) { if ($age > 18) {

code; } else { echo "Adult"; }
code; } else { echo
"Minor"; }
3 if-elseif- if (cond1) { ... } elseif Checks multiple
(cond2) { ... } else { ...
else } conditions
sequentially
4 switch switch ($var) { Switches based
case val1: ... on variable value
break; ... }

5 while while (condition) { Loops until

code; } condition is false
6 do-while do { code; } while Runs code at
(condition); least once

7 for for (init; cond; Iterates for a set

incr) { code; } number of times
8 foreach foreach ($array as Iterates over
$value) { code; } array elements

1. if Statement
What is the if Statement
The if statement is a basic conditional control structure in
PHP that evaluates whether a condition is true. If the
condition is true, the code block within the if statement is
executed.
Use Purpose
● Execute code conditionally based on a single,
boolean expression.
● Validate user input, like checking if a form field is
filled.
● Control program flow, determining which block of
code should run based on specific conditions.
Syntax

if (condition) {
// Code to execute if condition is true
}

Syntax Explanation
● condition :
○ The expression that evaluates to true or
false . This can be any comparison or logical
expression.
● if :
○ The keyword that initiates the conditional
check.
● Code block:
○ Enclosed in curly braces {} , it runs only if
the condition is true.
Simple Code Example

<?php
$age = 20;
if ($age > 18) {
echo "You are an adult.";
}
// Outputs: You are an adult.
?>

Notes
● The if statement is ideal for basic validation, like
checking if a user is logged in or a field is not empty.
● It helps create clean decision structures by
evaluating a single condition.
Warnings
● Always ensure that the condition is a boolean
expression; non-boolean values may lead to
unexpected behavior.
● If more than one condition needs to be checked,
consider using if-elseif-else or switch for better
clarity.

2. if-else Statement
What is the if-else Statement
The if-else statement extends the if statement by adding
an else block, which executes when the if condition is
false.
Use Purpose
● Provide alternate actions when the primary
condition fails.
● Handle two possible outcomes, like success or
failure in login attempts.
● Ensure fallback code runs when the primary
condition is false.
Syntax
if (condition) {
// Code if condition is true
} else {
// Code if condition is false
}
Syntax Explanation
 ● else :
○ Specifies a block of code to run if the if
condition is false.
● Code blocks:
○ If the condition is true, the if block executes;
if false, the else block runs.

Simple Code Example

<?php
$age = 16;
if ($age >= 18) {
echo "You are an adult.";
} else {
echo "You are a minor.";
}
// Outputs: You are a minor.
?>

Notes
● Use if-else for binary decision-making, ensuring
either the if block or else block runs.
● It provides clear control flow, especially for
validation checks or error handling.
Warnings
● Avoid complex conditions inside the if block; break
them down into simpler checks if needed.
● Ensure both code blocks are well-structured to avoid
syntax errors.

3. if-elseif-else Statement
What is the if-elseif-else Statement
The if-elseif-else structure extends the basic if-else by
allowing multiple conditions to be checked in sequence. It
executes the block of the first true condition and skips the
rest.
Use Purpose
● Handle multiple conditions sequentially.
● Implement multi-level decision-making, like
grading based on scores.
● Manage complex conditions, where multiple
potential outcomes exist.

Syntax

if (condition1) {
// Code if condition1 is true
} elseif (condition2) {
// Code if condition2 is true
} else {
// Code if none of the conditions are true
}

Syntax Explanation
● elseif :
○ Adds additional conditions to be checked if
the previous if or elseif was false.
● else :
○ Executes if no preceding conditions are true.
Simple Code Example

<?php
$score = 75;
if ($score >= 90) {
echo "Grade: A";
} elseif ($score >= 75) {
echo "Grade: B";
} elseif ($score >= 60) {
echo "Grade: C";
} else {
echo "Grade: D";
}
// Outputs: Grade: B
?>
Notes
● The if-elseif-else structure is useful for checking
ranges of values.
● It stops evaluating as soon as one condition is true,
improving efficiency.
Warnings
● Use parentheses for complex conditions to clarify
evaluation order.
● Avoid using too many elseif statements, as it may
reduce readability.

4. switch Statement
What is the switch Statement
The switch statement evaluates an expression and
executes the matching case block. It is an efficient
alternative to multiple if-elseif checks when comparing one
variable against many values.
Use Purpose
● Check a variable against multiple possible
values in a cleaner way.
● Simplify complex conditional checks, especially
for menus or commands.
● Group related cases together, reducing
redundancy.
Syntax
switch ($variable) {
case value1:
// Code if $variable equals value1
break;
case value2:
// Code if $variable equals value2
break;
default:
// Code if no cases match
}

Syntax Explanation
● $variable :
○ The variable or expression being evaluated.
● case :
○ Checks if $variable matches the specified
value.
● default :
○ Executes if no case matches.
● break :
○ Stops the execution of subsequent cases,
preventing fall-through.

Simple Code Example

<?php
$day = "Monday";
switch ($day) {
case "Monday":
echo "Start of the week.";
break;
case "Friday":
echo "Almost weekend!";
 break;
default:
echo "Regular day.";
}
// Outputs: Start of the week.
?>

Notes
● The switch statement is ideal for checking
discrete values, like user input or predefined
options.
● Each case must end with break to prevent fall-
through.
Warnings
● Without break , the switch will continue to execute
subsequent cases.
● Ensure that the default case handles unexpected
values to prevent errors.

5. while Loop
What is the while Loop
The while loop repeatedly executes a block of code as long
as the specified condition remains true.
Use Purpose
● Repeat code blocks dynamically, as long as a
condition is true.
● Process dynamic data, like reading files or
handling user input.
● Handle continuous operations, such as checking
user input until it matches criteria.
Syntax

while (condition) {
// Code to execute while condition is true
}

Syntax Explanation
● condition :
○ Evaluates to true or false. The loop continues
while the condition is true.
● while :
○ Starts the loop, evaluating the condition
before each iteration.
Simple Code Example

<?php
$count = 1;
while ($count <= 5) {
echo "Count: $count<br>";
$count++;
}
// Outputs: Count: 1 Count: 2 Count: 3 Count: 4 Count: 5
?>

Notes
● The while loop is suitable for indefinite iteration,
running until a condition changes.
● It requires manual counter updates to avoid infinite
loops.
Warnings
● Always ensure that the condition will eventually
become false to prevent infinite loops.
● Properly initialize variables before entering the loop.
6. do-while Loop
What is the do-while Loop
The do-while loop is similar to the while loop but
guarantees at least one execution of the code block, as it
checks the condition after the code runs.
Use Purpose
● Execute code at least once, such as prompting
user input.
● Handle situations where the action precedes
validation, like generating menu options.
● Ensure minimum execution, making it suitable
for repeating prompts or actions.
Syntax

do {
// Code to execute
} while (condition);

Syntax Explanation
● do :
○ Begins the loop, ensuring the code block
executes at least once.
● while :
○ Checks the condition after execution.
Simple Code Example

<?php
$count = 1;
do {
echo "Count: $count<br>";
$count++;
} while ($count <= 5);
// Outputs: Count: 1 Count: 2 Count: 3 Count: 4 Count: 5
?>
Notes
● The do-while loop is useful for prompting and
validating user input, especially when input is
required.
 ●It differs from the while loop by ensuring the
code runs at least once.
Warnings
● Use with caution, as the condition is checked after
execution, which may lead to unintended outcomes.
● Be aware of variables used in the loop to prevent
undefined behavior.

7. for Loop
What is the for Loop
The for loop executes a block of code a specific number of
times, defined by initialization, condition, and increment.
Use Purpose
● Repeat code blocks a fixed number of times,
such as iterating through arrays.
● Implement index-based iteration, using
initialization, condition, and increment.
● Control iterations explicitly, making it suitable
for loops with known counts.
Syntax

for (init; condition; increment) {

// Code to execute
}
Syntax Explanation
● init :
○ Sets the starting value of the loop variable.
● condition :
○ Determines when the loop should stop.
● increment :
○ Updates the loop variable after each
iteration.
Simple Code Example
<?php
for ($i = 1; $i <= 5; $i++) {
echo "Iteration: $i<br>";
}
// Outputs: Iteration: 1 Iteration: 2 Iteration: 3 Iteration: 4 Iteration: 5
?>
Notes
● The for loop is useful for predefined iteration
counts, like array indexing or processing elements.
● It provides clear control flow for iterating over
numeric ranges.
Warnings
● Ensure that the loop will eventually meet the
stopping condition to avoid infinite loops.
● Be cautious of off-by-one errors when setting loop
conditions.

8. foreach Loop
What is the foreach Loop
The foreach loop iterates over arrays or objects, making it
ideal for processing collections.
Use Purpose
● Iterate over array elements, processing each
element individually.
● Handle associative arrays, providing access to
both keys and values.
● Simplify array processing, eliminating manual
index handling.
Syntax

foreach ($array as $value) {

// Code to execute for each element
}
Syntax Explanation
● $array :
○ The array to be iterated over.
● $value :
○ Represents the current element in the array
during each iteration.
Simple Code Example
<?php
$fruits = array("apple", "banana", "cherry");
foreach ($fruits as $fruit) {
echo "Fruit: $fruit<br>";
}
// Outputs: Fruit: apple Fruit: banana Fruit: cherry
?>

Notes
● The foreach loop is suitable for iterating arrays or
collections.
● It automatically handles indexes and associative
arrays, improving readability.
Warnings
● Ensure the variable is an array or iterable to avoid
errors.
● Modifying the array within the loop may cause
unexpected behavior.

Final Project: "Student Grading System"

Project Goal
● Create a PHP script that uses control structures to
assign grades based on student scores.
● Implement various control structures to handle
different conditions and loops.
Code for This Project
<?php
// Student scores
$scores = array(
"Alice" => 85,
"Bob" => 72,
"Charlie" => 95,
"David" => 60
);

echo "<h2>Student Grades</h2>";

foreach ($scores as $name => $score) {
if ($score >= 90) {
$grade = "A";
} elseif ($score >= 75) {
$grade = "B";
} elseif ($score >= 60) {
$grade = "C";
} else {
$grade = "D";
}
echo "$name: Score = $score, Grade = $grade<br>";
}
?>

Save and Run

● Save the code as student_grading.php .
● Run it on a PHP server or use an online PHP
sandbox.
Check Output
The script will display the grades assigned to each student
based on their scores.
Summary
This chapter provided a detailed overview of PHP control
structures, covering if , if-else , if-elseif-else , switch ,
while , do-while , for , and foreach loops. It concluded with
a project demonstrating how to use various control
structures to manage program flow in a student grading
system.
Chapter-11 PHP Working with Arrays
Chapter Overview
This chapter covers PHP arrays, which are used to store
multiple values in a single variable. Arrays are one of the
most versatile data structures in PHP, enabling the storage,
retrieval, and manipulation of lists and collections of data.
Chapter Goal
● Understand the different types of arrays in PHP.
● Learn how to create, access, and manipulate arrays.
● Explore PHP’s built-in functions for array handling.
● Implement a project that demonstrates array
operations.

Rules of PHP Arrays

● Data Storage: Arrays allow multiple values to be
stored in a single variable.
● Types of Arrays: PHP supports indexed, associative,
and multidimensional arrays.
● Array Manipulation: PHP provides a variety of built-
in functions for sorting, searching, and modifying
arrays.

Syntax Table
Seri Array Type Syntax Example
al
No
1 Indexed Array $array = $array =
array(val1, val2); array(1, 2, 3);
2 Associative $array = $array =
Array array(key1 => array("name"
val1, ...); => "Alice");
3 Multidimension $array = $array =
al Array array(array1, array(array(1,2
array2); ), array(3,4));
4 Array Length count($array); count(array(1,
2, 3));

5 Add Element $array[] = value; $array[] = 4;

6 Remove unset($array[index unset($array[1
Element ]); ]);
7 Array Search in_array(value, in_array(2,
$array); $array);

1. Indexed Arrays
What is an Indexed Array
Indexed arrays in PHP store a series of elements, each
identified by a numeric index. The indexes start from 0 by
default, and elements are accessed using these indexes.
Use Purpose
● Store lists of values, like numbers, strings, or
objects.
● Iterate through elements, processing each one
individually.
● Manage ordered collections, like lists, queues, or
sequences.
Syntax
$indexed_array = array(value1, value2, value3);
Syntax Explanation
● value1 , value2 , value3 :
○ Elements of the array, which can be of any
data type.
● array() :
○ A function that creates an array.
Simple Code Example
<?php
$numbers = array(1, 2, 3, 4, 5);
echo $numbers[0]; // Outputs: 1
?>

Notes
● Indexed arrays are useful for storing sequential
data, like a list of numbers or names.
● The array() function can be replaced by shorthand
[] in PHP 5.4 and above.
Warnings
● Ensure that the index exists before accessing it to
avoid errors.
● Be careful of off-by-one errors when iterating through
the array.

2. Associative Arrays
What is an Associative Array
Associative arrays store elements identified by string keys
instead of numeric indexes. Each key-value pair allows for
more descriptive access to data.
Use Purpose
● Store key-value pairs, like names and ages or
product IDs and prices.
● Access elements using keys, making it easy to
retrieve specific data.
● Organize data, providing a more intuitive way to
handle data relationships.
Syntax

$assoc_array = array("key1" => "value1", "key2" => "value2");

Syntax Explanation
 ● key1 and key2 :
○ String keys used to identify elements in the
array.
● value1 and value2 :
○ The corresponding values associated with
each key.
Simple Code Example

<?php
$person = array("name" => "Alice", "age" => 30);
echo $person["name"]; // Outputs: Alice
?>

Notes
● Associative arrays are ideal for labeling elements,
like representing database records or structured data.
● The keys are case-sensitive and must be unique
within the array.
Warnings
● Accessing a non-existent key will return NULL , which
may lead to unexpected results.
● Ensure that key names are unique to avoid
overwriting values.

3. Multidimensional Arrays
What is a Multidimensional Array
Multidimensional arrays contain arrays as their elements,
allowing for the storage of data in multiple dimensions (e.g.,
rows and columns).
Use Purpose
● Store complex data, like tables or matrices.
● Handle nested data structures, such as JSON-like
data or multidimensional tables.
 ● Group related data, such as storing a list of users
and their attributes.
Syntax

$multi_array = array(
array(value1, value2),
array(value3, value4)
);

Syntax Explanation
● array() :
○ Contains nested arrays as elements.
● Nested arrays:
○ Each nested array can hold multiple values.
Simple Code Example

<?php
$matrix = array(
array(1, 2, 3),
array(4, 5, 6),
array(7, 8, 9)
);
echo $matrix[1][2]; // Outputs: 6
?>

Notes
● Multidimensional arrays are useful for representing
grids, tables, or nested records.
● They can have any number of dimensions, depending
on the complexity of the data.
Warnings
● Accessing non-existent indexes or dimensions may
cause errors.
● Use loops, such as foreach , to traverse
multidimensional arrays effectively.
4. Array Length ( count )
What is Array Length ( count )
The count function returns the number of elements in an
array, helping determine the size of the array.
Use Purpose
● Get the size of an array, useful for loops or
conditional checks.
● Validate array contents, ensuring it has elements
before processing.
● Limit loop iterations, based on the number of
array elements.
Syntax

$length = count($array);

Syntax Explanation
● count() :
○ A built-in PHP function that returns the
number of elements in an array.
● $array :
○ The array whose length is being determined.
Simple Code Example

<?php
$fruits = array("apple", "banana", "cherry");
echo count($fruits); // Outputs: 3
?>

Notes
● The count function is essential for controlling
loops that iterate over arrays.
● It works with both indexed and associative arrays.
Warnings
● For multidimensional arrays, count returns the
number of elements in the top-level array.
● Use count($array, COUNT_RECURSIVE) to count all
elements, including nested ones.

5. Adding Elements to Arrays

What is Adding Elements to Arrays
Elements can be added to arrays using the empty bracket
notation ( [] ), which appends values to the end of the array.
Use Purpose
● Dynamically expand arrays, adding elements as
needed.
● Build arrays from user input or database results.
● Append new elements, maintaining an ordered
list.
Syntax
$array[] = new_value;

Syntax Explanation
● [] :
○ Adds an element to the end of the array.
● new_value :
○ The value to be added to the array.
Simple Code Example
<?php
$colors = array("red", "green");
$colors[] = "blue";
print_r($colors); // Outputs: Array ( [0] => red [1] => green [2] => blue )
?>
Notes
● Adding elements using [] is straightforward and
maintains the array order.
 ●It can be used with both indexed and associative
arrays, provided a key is not specified.
Warnings
● Appending elements to associative arrays without
specifying a key may lead to numeric indexing.

6. Removing Elements from Arrays ( unset )

What is Removing Elements from Arrays
The unset function removes a specific element from an
array, using its index or key.
Use Purpose
● Delete specific elements, like clearing user input
or filtering results.
● Manage dynamic arrays, removing elements
based on conditions.
● Free memory, by removing unneeded elements
from large arrays.
Syntax

unset($array[index]);

Syntax Explanation
● $array :
○ The array from which an element is to be
removed.
● index :
○ The index or key of the element to be
removed.
Simple Code Example

<?php
$fruits = array("apple", "banana", "cherry");
unset($fruits[1]);
print_r($fruits); // Outputs: Array ( [0] => apple [2] => cherry )
?>

Notes
● unset can be used to remove elements from both
indexed and associative arrays.
● The array may have gaps in indexing after removal,
which can affect iteration.
Warnings
● Removing elements with unset does not reindex
the array.
● Be cautious when using unset within loops, as it
can cause iteration issues.

7. Searching Arrays ( in_array )

What is Searching Arrays ( in_array )
The in_array function checks if a value exists in an array,
returning true if found and false otherwise.
Use Purpose
● Verify the presence of elements, like checking
user roles or permissions.
● Validate data, ensuring certain values exist before
proceeding.
● Filter arrays, finding specific elements dynamically.
Syntax

$found = in_array(value, $array);

Syntax Explanation
● value :
○ The value to search for within the array.
● $array :
 ○ The array to be searched.
● in_array() :
○ Returns true if the value is found, false
otherwise.
Simple Code Example
<?php
$fruits = array("apple", "banana", "cherry");
if (in_array("banana", $fruits)) {
echo "Banana is in the list.";
}
// Outputs: Banana is in the list.
?>

Notes
● in_array is case-sensitive and returns false if the
case does not match.
● It is commonly used for validation or search
operations.
Warnings
● Be aware of type comparisons; use in_array(value,
$array, true) for strict type checking.
● Avoid searching large arrays frequently, as it may
affect performance.
Final Project: "Inventory Management System"
Project Goal
● Create a PHP script that manages an inventory using
arrays.
● Implement functions to add, remove, update, and
search for items in the inventory.
Code for This Project
<?php
// Initial inventory
$inventory = array("apple" => 50, "banana" => 100, "orange" => 75);
// Add new item
$inventory["grape"] = 60;

// Update item quantity

$inventory["apple"] += 20;

// Remove an item
unset($inventory["banana"]);

// Search for an item

$item = "orange";
if (in_array($item, array_keys($inventory))) {
echo "$item is available with quantity: " . $inventory[$item];
} else {
echo "$item is not available.";
}

print_r($inventory);
/*
Outputs:
orange is available with quantity: 75
Array ( [apple] => 70 [orange] => 75 [grape] => 60 )
*/
?>

Save and Run

● Save the code as inventory_management.php .
● Run it on a PHP server or use an online PHP
sandbox.
Check Output
The script will display the updated inventory after adding,
updating, and removing items, as well as searching for a
specific item.
Summary
This chapter provided a comprehensive overview of working
with arrays in PHP, covering indexed arrays, associative
arrays, and multidimensional arrays. It explained how to
add, remove, and search elements in arrays, and concluded
with a project demonstrating inventory management using
array operations.
Chapter-12 PHP Functions
Chapter Overview
This chapter covers PHP functions, which are reusable
blocks of code designed to perform specific tasks. Functions
simplify programming by allowing code to be organized,
reused, and maintained effectively. PHP offers both built-in
and user-defined functions for handling various operations.
Chapter Goal
● Understand the purpose and structure of functions
in PHP.
● Learn how to create, call, and use functions
effectively.
● Explore different types of functions, including built-
in, user-defined, and parameterized functions.
● Implement a project that uses functions to manage
a simple application.

Rules of PHP Functions

● Function Declaration: Functions must be declared
before they are called.
● Return Values: Functions can return values using
the return statement.
● Parameters and Arguments: Functions can
accept parameters to process input values.
● Scope: Variables inside functions are local by
default unless specified as global.
Syntax Table
Seri Function Syntax Example
al Type
No
1 Basic function function greet()
Function funcName() { { echo "Hello!";
code; } }
2 Function function function
with funcName($param) greet($name) {
Parameter { code; } echo "Hi,
s $name!"; }
3 Return function function add() {
Value funcName() { return 2 + 3; }
return value; }
4 Default function function
Parameter funcName($param greet($name =
s = value) {} "Guest")
5 Variable Local, Global, $x = 5; function
Scope Static test() { global
$x; }
6 Built-in Various PHP built-in strlen("Hello")
Functions functions

1. Basic Functions
What is a Basic Function
A function is a block of code that performs a specific task.
Basic functions in PHP are user-defined and allow for code
reuse. They can be called as many times as needed
throughout the program.
Use Purpose
 ● Organize code into reusable blocks, improving
code clarity.
● Encapsulate logic, making it easier to manage and
maintain.
● Perform repetitive tasks, such as calculations or
data processing.
Syntax

function functionName() {
// Code to execute
}

Syntax Explanation
● function :
○ A keyword that defines a new function.
● functionName :
○ The name of the function, which should be
descriptive of its purpose.
● Code block:
○ Enclosed in curly braces {} , containing the
instructions to be executed when the function
is called.
Simple Code Example

<?php
function greet() {
echo "Hello, World!";
}
greet(); // Outputs: Hello, World!
?>
Notes
● Functions are declared once but can be called
multiple times, making them ideal for code reuse.
● Function names are not case-sensitive in PHP,
meaning greet() and GREET() are considered the
 same.
Warnings
● Ensure that functions are defined before calling
them to avoid errors.
● Avoid using reserved keywords as function names to
prevent conflicts.

2. Functions with Parameters

What are Functions with Parameters
Functions can accept parameters, allowing users to pass
values into the function. Parameters are variables that hold
the input values needed to perform the function’s task.
Use Purpose
● Pass data to functions, enabling dynamic
processing.
● Customize function behavior, based on input
parameters.
● Handle variable input values, such as user input
or calculated data.
Syntax

function functionName($param1, $param2) {

// Code to execute
}
Syntax Explanation
● $param1 , $param2 :
○ Parameters that accept input values when
the function is called.
● Multiple parameters:
○ Functions can accept one or more
parameters, separated by commas.
Simple Code Example
<?php
function greet($name) {
echo "Hi, " . $name . "!";
}
greet("Alice"); // Outputs: Hi, Alice!
?>

Notes
● Parameters allow functions to process dynamic
input, making them versatile.
● PHP supports both required and optional
parameters in functions.
Warnings
● Ensure that the correct number of arguments is
passed to functions when calling them.
● Parameter names must be unique within the
function to avoid conflicts.

3. Returning Values from Functions

What is Returning Values from Functions
Functions can return a value using the return statement.
This value can then be used elsewhere in the program, such
as in assignments, calculations, or other functions.
Use Purpose
● Output results from functions, making them
reusable in calculations or assignments.
● Capture function results for further processing or
validation.
● Perform complex operations, returning results
that can be used in other functions or variables.
Syntax
function functionName() {
 return value;
}
Syntax Explanation
● return :
○ A keyword that specifies the value to be
returned by the function.
● value :
○ The value or expression that is returned.
Simple Code Example

<?php
function add($a, $b) {
return $a + $b;
}
$result = add(5, 3);
echo $result; // Outputs: 8
?>

Notes
● The return statement exits the function
immediately after execution, returning the specified
value.
● Functions can return any data type, including
strings, numbers, arrays, or objects.
Warnings
● Only one value can be returned from a function, but
it can be an array or object to return multiple values.
● Ensure that the return statement is used correctly;
functions without return will return NULL by default.

4. Functions with Default Parameters

What are Functions with Default Parameters
Functions can have default parameter values, which are
used if no value is provided for the parameter when the
function is called.
Use Purpose
● Provide fallback values, ensuring functions work
even if arguments are missing.
● Simplify function calls, especially when
parameters are often the same.
● Reduce errors, as functions can operate with
default values.
Syntax
function functionName($param = defaultValue) {
// Code to execute
}

Syntax Explanation
● $param = defaultValue :
○ Sets a default value for the parameter, used
if no value is provided.
● Multiple parameters:
○ Default values can be set for one or more
parameters.
Simple Code Example

<?php
function greet($name = "Guest") {
echo "Hello, " . $name . "!";
}
greet(); // Outputs: Hello, Guest!
?>

Notes
● Default parameters make functions more flexible
and easier to use.
 ● If non-default parameters are present, they must be
listed before parameters with default values.
Warnings
● Ensure that parameters with default values are
listed after required parameters to avoid errors.
● If a parameter with a default value is passed an
argument, the default value is overridden.

5. Variable Scope in Functions

What is Variable Scope in Functions
Variable scope determines where variables can be accessed
in a program. In PHP, variable scope includes local, global,
and static.

Use Purpose
● Control variable visibility, ensuring variables are
used in the intended context.
● Avoid variable conflicts, especially in large
programs.
● Preserve variables between function calls,
using static variables.
Syntax
Local Variables: Defined within a function and accessible
only inside it.
function test() {
$localVar = 10;
}

Global Variables: Defined outside functions and accessible

inside functions using the global keyword.
$globalVar = 20;
function test() {
global $globalVar;
}

Static Variables: Retain their values between function

calls.

function counter() {
static $count = 0;
$count++;
echo $count;
}

Simple Code Example

<?php
$count = 10; // Global variable
function increment() {
global $count;
$count++;
}
increment();
echo $count; // Outputs: 11
?>

Notes
●Local variables exist only within functions, while
global variables exist outside functions.
● Static variables maintain their values between
function calls, making them useful for counters or
accumulators.
Warnings
 ● Avoid using too many global variables, as they can
lead to conflicts and make debugging harder.
● Static variables should be used carefully to prevent
unintended side effects.

6. Built-in Functions
What are Built-in Functions
PHP has a wide range of built-in functions that perform
common tasks, such as string manipulation, array handling,
mathematical calculations, and file operations.
Use Purpose
● Perform common operations, like counting array
elements or formatting strings.
● Simplify tasks, by using predefined functions for
standard operations.
● Handle data efficiently, using functions optimized
for performance.
Examples of Built-in Functions
● String Functions:
○ strlen() : Returns the length of a string.
○ strtoupper() : Converts a string to uppercase.
● Array Functions:
○ array_push() : Adds elements to an array.
○ array_merge() : Merges two or more arrays.
● Math Functions:
○ abs() : Returns the absolute value of a
number.
○ round() : Rounds a floating-point number.
● File Functions:
○ fopen() : Opens a file.
○ fwrite() : Writes to a file.
Simple Code Example

<?php
$word = "Hello";
echo strlen($word); // Outputs: 5
?>

Notes
● Built-in functions are predefined in PHP and can
be used directly.
● They are optimized for performance and offer a wide
range of functionality.
Warnings
● Be aware of the function’s behavior and potential
side effects, especially with functions that modify
data.
● Some built-in functions may require additional
extensions or settings to be enabled in PHP.
Final Project: "Simple Calculator with
Functions"
Project Goal
● Create a PHP script that acts as a simple calculator
using functions.
● Implement functions to perform addition,
subtraction, multiplication, and division.
Code for This Project

<?php
// Addition function
function add($a, $b) {
return $a + $b;
}

// Subtraction function
function subtract($a, $b) {
return $a - $b;
}

// Multiplication function
function multiply($a, $b) {
return $a * $b;
}

// Division function
function divide($a, $b) {
if ($b != 0) {
return $a / $b;
} else {
return "Error: Division by zero!";
}
}

// Using the calculator functions

echo "Addition: " . add(10, 5) . "<br>"; // Outputs: Addition: 15
echo "Subtraction: " . subtract(10, 5) . "<br>";// Outputs: Subtraction: 5
echo "Multiplication: " . multiply(10, 5) . "<br>";// Outputs: Multiplication: 50
echo "Division: " . divide(10, 0) . "<br>"; // Outputs: Error: Division by zero!
?>

Save and Run

● Save the code as calculator.php .
● Run it on a PHP server or use an online PHP
sandbox.
Check Output
The script will display the results of addition, subtraction,
multiplication, and division based on the input values.
Summary
This chapter provided a comprehensive overview of PHP
functions, covering basic functions, parameters, return
values, variable scope, and built-in functions. It concluded
with a project demonstrating the use of functions to create a
simple calculator, showcasing function creation, parameter
handling, and return values in PHP.
Chapter-13 PHP Variable Scope
Chapter Overview
This chapter covers variable scope in PHP, which determines
where variables can be accessed within a program. PHP
supports different types of variable scopes, including local,
global, static, and function parameter scopes.
Understanding variable scope helps manage data visibility
and control in a program.
Chapter Goal
● Understand the different types of variable scopes in
PHP.
● Learn how to access and modify variables in various
scopes.
● Explore examples that demonstrate the behavior of
different scopes.
● Implement a project that uses variable scope to
manage data flow in a program.

Rules of PHP Variable Scope

● Local Scope: Variables defined within a function are
accessible only within that function.
● Global Scope: Variables defined outside any
function can be accessed globally using the global
keyword or $GLOBALS array.
● Static Scope: Variables defined as static inside a
function retain their value between function calls.
● Parameter Scope: Function parameters act as
local variables within the function and are used to
pass values into functions.
Syntax Table
Seri Scope Syntax Example
al Type
No
1 Local function test() { function test() { $x
Scope $var = value; } = 5; }
2 Global global $var; or global $x; or
Scope $GLOBALS['var'] $GLOBALS['x']
3 Static static $var = static $count = 0;
Scope value;
4 Paramete function function add($a,
r Scope test($param) { ... $b) { return $a +
} $b; }

1. Local Scope
What is Local Scope
Local scope refers to variables defined inside a function.
These variables are only accessible within that function and
cannot be used outside it.
Use Purpose
● Encapsulate data within a function, keeping
variables separate from the global environment.
● Avoid conflicts with global variables, as local
variables are isolated within their functions.
● Improve code readability, by keeping variables
related to specific functions.
Syntax
function functionName() {
$localVar = value;
// $localVar is accessible only within this function
}
Syntax Explanation
● $localVar :
○ A variable declared inside the function,
accessible only within that function.
● Function block:
○ The scope of $localVar is limited to this block.
Simple Code Example

<?php
function showMessage() {
$message = "Hello, World!";
echo $message;
}
showMessage(); // Outputs: Hello, World!
// echo $message; // Error: Undefined variable
?>

Notes
● Variables declared inside a function are local to that
function and cannot be accessed outside it.
● Local variables are reinitialized each time the
function is called, ensuring they do not retain values
between calls.
Warnings
● Attempting to access local variables outside their
function scope will result in an undefined variable
error.
● If variables need to be shared across functions,
consider using global variables or passing parameters.

2. Global Scope
What is Global Scope
Global scope refers to variables defined outside any function,
making them accessible throughout the script. However, to
access global variables inside functions, the global keyword
or $GLOBALS array must be used.
Use Purpose
● Store data globally, making it accessible across
multiple functions.
● Share data between functions without passing
parameters.
● Manage configuration values, like settings or
constants, that need to be accessed globally.
Syntax

$globalVar = value;

function functionName() {
global $globalVar;
// $globalVar can be accessed and modified here
}

Syntax Explanation
● $globalVar :
○ A variable defined in the global scope, outside
of any function.
● global keyword:
○ Allows access to global variables inside
functions.
Simple Code Example

<?php
$count = 10; // Global variable

function increment() {
global $count;
$count++;
}
increment();
echo $count; // Outputs: 11
?>

Notes
● Global variables can be accessed from any part of the
script, provided they are declared global within
functions.
The $GLOBALS array can also be used to access global
variables:

function increment() {
$GLOBALS['count']++;
}

Warnings
● Using too many global variables can make debugging
difficult and may lead to unexpected side effects.
● Avoid variable name conflicts by using descriptive
names for global variables.

3. Static Scope
What is Static Scope
Static scope in PHP refers to variables defined as static
within a function. These variables retain their value between
function calls, unlike regular local variables.
Use Purpose
● Preserve variable state across multiple function
calls.
● Implement counters, accumulators, or caching
mechanisms within functions.
● Store data temporarily, without making variables
global.
Syntax

function functionName() {
static $staticVar = value;
// $staticVar retains its value between calls
}
Syntax Explanation
● static :
○ A keyword that defines a variable as static,
allowing it to retain its value.
● $staticVar :
○ A variable that maintains its value across
function calls.
Simple Code Example

<?php
function counter() {
static $count = 0;
$count++;
echo $count . "<br>";
}

counter(); // Outputs: 1
counter(); // Outputs: 2
counter(); // Outputs: 3
?>

Notes
● Static variables are initialized only once, and their
values persist across subsequent calls to the function.
● They are useful for maintaining state within a
function, such as keeping track of the number of times
a function has been called.
Warnings
 ● Static variables are local to the function and
cannot be accessed globally.
● Be cautious when using static variables in recursive
functions, as they may not behave as expected.

4. Parameter Scope
What is Parameter Scope
Function parameters act as local variables within the
function, holding values passed to the function when it is
called. They allow functions to receive input and process data
accordingly.
Use Purpose
● Pass data into functions, making them versatile
and reusable.
● Control function behavior, based on the values of
parameters.
● Handle dynamic input, allowing functions to work
with different data each time they are called.
Syntax

function functionName($param1, $param2) {

// $param1 and $param2 are local to the function
}

Syntax Explanation
● $param1 , $param2 :
○ Parameters that hold values passed to the
function.
● Function block:
○ Parameters are treated as local variables
within this block.
Simple Code Example

<?php
function add($a, $b) {
 return $a + $b;
}

echo add(3, 5); // Outputs: 8

?>

Notes
● Parameters provide a way to pass values into
functions, making them adaptable to various inputs.
● Parameters are treated as local variables, meaning
they are accessible only within the function.
Warnings
● Ensure that the number of arguments matches the
number of parameters when calling functions to avoid
errors.
● Modifying parameter values inside the function does
not affect the original variables passed, as they are
passed by value by default.

Final Project: "Visitor Counter with Variable

Scope"
Project Goal
● Create a PHP script that uses variable scope to
implement a simple visitor counter.
● Implement global, local, static, and parameter scopes
to manage the counter and display visitor information.
Code for This Project
<?php
// Global variable for total visits
$totalVisits = 0;

// Function to update the counter using static scope

function updateCounter() {
 global $totalVisits;
static $counter = 0;
$counter++;
$totalVisits++;
return $counter;
}
// Function to display the visitor count with parameter scope
function displayVisitorCount($name) {
$visitNumber = updateCounter();
echo "Visitor: $name, Visit Number: $visitNumber<br>";
}
// Test the visitor counter
displayVisitorCount("Alice"); // Outputs: Visitor: Alice, Visit Number: 1
displayVisitorCount("Bob"); // Outputs: Visitor: Bob, Visit Number: 2
displayVisitorCount("Charlie");// Outputs: Visitor: Charlie, Visit Number: 3
echo "Total Visits: $totalVisits"; // Outputs: Total Visits: 3
?>
Save and Run
● Save the code as visitor_counter.php .
● Run it on a PHP server or use an online PHP sandbox.
Check Output
The script will display the visit number for each visitor and
the total number of visits, demonstrating the use of local,
global, static, and parameter scopes.
Summary
This chapter provided a comprehensive overview of PHP
variable scope, covering local, global, static, and parameter
scopes. It explained how to access and modify variables in
different scopes and concluded with a project that
demonstrates the use of variable scope in a visitor counter
application.

Chapter-14 PHP Superglobals

Chapter Overview
This chapter covers PHP superglobals, which are built-in
variables that are always available in PHP scripts, regardless
of the scope (global, local, or within functions). Superglobals
are associative arrays that contain data related to user input,
server environment, session management, cookies, and
more. They play a crucial role in handling web forms,
managing sessions, accessing server data, and maintaining
user information across pages.
Chapter Goal
● Understand the purpose and use of PHP superglobals.
● Learn how to access and manipulate data using
superglobals.
● Explore different types of superglobals, such as
$_GET , $_POST , $_REQUEST , $_SESSION ,
$_COOKIE , $_SERVER , and more.
● Implement a project that demonstrates practical use
cases for superglobals in form handling, session
management, and cookie storage.

Rules of PHP Superglobals

● Global Availability: Superglobals are accessible
from anywhere in the script, including functions and
classes, without using the global keyword.
● Security: While superglobals make it easy to handle
data, it is essential to validate and sanitize input to
prevent security vulnerabilities like SQL injection and
cross-site scripting (XSS).
● Data Sources: Superglobals are sourced from
different areas, including HTTP requests ( $_GET ,
$_POST ), server information ( $_SERVER ), sessions
( $_SESSION ), and cookies ( $_COOKIE ).

Syntax Table
Seri Superglob Purpose Example
al al
 No
1 $_GET Access data sent $_GET['name']
via URL (GET
method)

2 $_POST Access data sent $_POST['email']

via form (POST
method)
3 $_REQUEST Access data from $_REQUEST['name']
both GET and
POST

4 $_SESSION Store and $_SESSION['user']

retrieve session
variables
5 $_COOKIE Access data from $_COOKIE['user']
cookies
6 $_SERVER Access $_SERVER['PHP_SEL
server/environme F']
nt information
7 $_FILES Handle file $_FILES['file']
uploads ['name']
8 $_ENV Access $_ENV['PATH']
environment
variables

9 $_GLOBALS Access all global $_GLOBALS['var']

variables

1. $_GET
What is $_GET
The $_GET superglobal is an associative array that contains
data sent to the script via the URL (query string) or forms
that use the GET method. It is primarily used to pass data
between pages using URL parameters.
Use Purpose
● Retrieve data from URLs, allowing users to send
variables and values in the URL.
● Collect form data, especially for search forms or
filters, where data is not sensitive.
● Pass variables between pages, like session IDs,
pagination numbers, or user selections.
Syntax
$value = $_GET['key'];
Syntax Explanation
● $_GET :
○ A built-in associative array that stores data
sent via the URL.
● 'key' :
○ The name of the parameter in the URL or GET
form.
Simple Code Example
<?php
// URL: http://example.com/index.php?name=Alice
if (isset($_GET['name'])) {
$name = $_GET['name'];
echo "Hello, " . htmlspecialchars($name) . "!";
}
// Outputs: Hello, Alice!
?>
Notes
● Use htmlspecialchars() to prevent XSS attacks when
outputting user-supplied data.
● The maximum length of a URL (including GET
parameters) is browser-dependent, but generally
around 2,048 characters.
Warnings
● Data sent via GET is visible in the URL, making it
unsuitable for sensitive data like passwords.
● Always validate and sanitize user input to avoid
security vulnerabilities.

2. $_POST
What is $_POST
The $_POST superglobal is an associative array that collects
data sent to the script using the POST method, typically from
HTML forms. It is widely used for forms that modify data,
such as login, registration, or file uploads.
Use Purpose
● Handle form submissions, especially when dealing
with sensitive information, like login credentials or
user registration.
● Pass large amounts of data, as POST does not
have size limitations like GET.
● Process user input, such as adding, updating, or
deleting records in a database.
Syntax

$value = $_POST['key'];

Syntax Explanation
● $_POST :
○ An associative array that contains data sent
using the POST method.
● 'key' :
○ The name of the form field to retrieve data
from.
Simple Code Example

<?php
if ($_SERVER["REQUEST_METHOD"] == "POST" && isset($_POST['username'])) {
$username = $_POST['username'];
echo "Welcome, " . htmlspecialchars($username) . "!";
}
?>

Notes
● POST data is sent in the request body, making it
more secure than GET for handling sensitive
information.
● Use isset() to check if a form field exists before
accessing it to avoid errors.
Warnings
● Always validate and sanitize POST data to prevent
security risks like SQL injection.
● Ensure forms use the POST method to keep data
secure and hidden from the URL.

3. $_REQUEST
What is $_REQUEST
The $_REQUEST superglobal is a combined associative array
of GET, POST, and COOKIE data. It provides a general way to
access data, regardless of how it was sent to the server.
Use Purpose
● Access form data dynamically, without
considering the request method.
● Handle variables from multiple sources (GET,
POST, COOKIE).
● Simplify quick prototyping, where the source of
data is not a concern.
Syntax

$value = $_REQUEST['key'];

Syntax Explanation
● $_REQUEST :
○ An associative array that combines data from
GET, POST, and COOKIE.
● 'key' :
○ The name of the variable to be accessed from
any source.
Simple Code Example

<?php
if (isset($_REQUEST['name'])) {
$name = $_REQUEST['name'];
echo "Hello, " . htmlspecialchars($name) . "!";
}
?>
Notes
● $_REQUEST is convenient for basic input handling,
but it is less secure since it merges data from different
sources.
● Use it cautiously, as it may introduce unintentional
behavior if the same key exists in GET, POST, or
COOKIE.
Warnings
● Avoid using $_REQUEST for critical operations, as it
can be less predictable than specifying the exact
superglobal.
● Always sanitize data, as mixing sources may
introduce security risks.

4. $_SESSION
What is $_SESSION
The $_SESSION superglobal is an associative array used to
store and retrieve data across multiple pages in a web
application. Session variables are stored on the server and
persist until the session ends or is manually destroyed.
Use Purpose
● Maintain user sessions, like login state or cart
items, across multiple pages.
● Store user-specific data, such as preferences,
settings, or permissions.
● Track user interactions, enabling personalization
and continuity.
Syntax

$_SESSION['key'] = value;

Syntax Explanation
● $_SESSION :
○ An associative array that stores session data.
● 'key' :
○ The name of the session variable to be set or
accessed.
Simple Code Example

<?php
session_start(); // Start the session
$_SESSION['user'] = "Alice";
echo "User: " . $_SESSION['user']; // Outputs: User: Alice
?>

Notes
● Always start the session using session_start() before
accessing session variables.
 ● Session variables are stored server-side, making
them secure for sensitive data.
Warnings
● Session data can consume server resources, so clear
unnecessary session variables when no longer needed.
● Protect session IDs from exposure by using secure
transmission (HTTPS).

5. $_COOKIE
What is $_COOKIE
The $_COOKIE superglobal is an associative array that
retrieves data stored in cookies on the client-side. Cookies
are small pieces of data stored on the user's browser to
maintain information across sessions.
Use Purpose
● Store user preferences, like theme selection or
language choice, for later use.
● Remember user login information, such as
session tokens for automatic logins.
● Track user behavior, useful for analytics and
personalization.
Syntax

$value = $_COOKIE['key'];

Syntax Explanation
● $_COOKIE :
○ An associative array that stores cookie data.
● 'key' :
○ The name of the cookie to retrieve.
Simple Code Example

<?php
setcookie("user", "Alice", time() + (86400 * 30)); // Set a cookie for 30 days
if (isset($_COOKIE['user'])) {
echo "Welcome back, " . $_COOKIE['user'] . "!";
}
// Outputs: Welcome back, Alice!
?>

Notes
● Cookies are stored on the client-side, making
them visible and editable by the user.
● Use setcookie() to set cookies and define expiry
times.
Warnings
● Limit cookie size to 4KB, as most browsers have this
restriction.
● Use secure cookie settings, like HttpOnly and
Secure , to prevent JavaScript access and insecure
transmission.

6. $_SERVER
What is $_SERVER
The $_SERVER superglobal is an associative array that
contains information about the server environment and the
current request. It provides details like headers, script paths,
and server settings.
Use Purpose
● Retrieve server and script information, such as
file paths or server names.
● Access request details, like the request method,
client IP address, or HTTP headers.
● Debug server and request environment, helpful
for understanding the server context.
Syntax
$value = $_SERVER['key'];
Syntax Explanation
● $_SERVER :
○ An associative array that contains server and
request data.
● 'key' :
○ The specific server information to retrieve.
Simple Code Example

<?php
echo "Current Script: " . $_SERVER['PHP_SELF']; // Outputs the script's filename
?>

Notes
● Common keys include:
○ 'PHP_SELF' : The current script's path.
○ 'SERVER_NAME' : The server's hostname.
○ 'REQUEST_METHOD' : The request method
(GET, POST, etc.).
Warnings
● Be cautious when using user-manipulated values
from $_SERVER , as they can be used in attacks (e.g.,
HTTP_USER_AGENT or REFERER ).
● Always sanitize output before displaying it to prevent
XSS vulnerabilities.
Final Project: "User Login System with
Superglobals"
Project Goal
● Create a PHP script that handles user login using
$_POST for form submission and manages user
sessions using $_SESSION .
● Demonstrate setting and retrieving cookies for user
preferences.
Code for This Project

<?php
session_start(); // Start session

// Check form submission

if ($_SERVER["REQUEST_METHOD"] == "POST") {
$username = $_POST['username'];
$password = $_POST['password'];

// Basic user validation (dummy check)

if ($username == "admin" && $password == "1234") {
$_SESSION['user'] = $username; // Set session variable
setcookie("user", $username, time() + (86400 * 30)); // Set cookie for 30
days
header("Location: welcome.php"); // Redirect to welcome page
exit();
} else {
echo "Invalid username or password!";
}
}
?>

<!-- Login Form -->

<form method="POST" action="">
<input type="text" name="username" placeholder="Username" required>
<input type="password" name="password" placeholder="Password"
required>
<button type="submit">Login</button>
</form>

<!-- welcome.php -->

<?php
// welcome.php
session_start();
if (isset($_SESSION['user'])) {
echo "Welcome, " . $_SESSION['user'] . "!";
if (isset($_COOKIE['user'])) {
 echo " (Last Login: " . $_COOKIE['user'] . ")";
}
} else {
header("Location: login.php");
}
?>

Save and Run

●
Save the code as login.php and create a
welcome.php file.
● Run it on a PHP server or use an online PHP sandbox.
Check Output
The script will display a login form, validate user input,
manage user sessions, and set a cookie to remember the
user.
Summary
This chapter provided an in-depth look at PHP superglobals,
covering $_GET , $_POST , $_REQUEST , $_SESSION ,
$_COOKIE , $_SERVER , and more. It explained how to use
superglobals to handle form data, manage sessions, store
cookies, and retrieve server information, concluding with a
login system project to demonstrate their practical use.

Chapter-16 PHP File Handling

Chapter Overview
This chapter covers PHP file handling, which involves reading,
writing, creating, and deleting files. PHP provides various
built-in functions for working with files, allowing developers
to manage file-based data storage, configuration files, and
logs. File handling is essential for tasks like storing user
uploads, maintaining logs, or reading configuration files.
Chapter Goal
● Understand the basics of file handling in PHP.
● Learn how to open, read, write, and close files.
 ● Explore functions for checking file existence, deleting
files, and handling errors.
● Implement a project that demonstrates file reading,
writing, and appending operations.

Rules of PHP File Handling

● File Access Modes: PHP provides different file
access modes, such as reading ( r ), writing ( w ), and
appending ( a ).
● File Operations: Use built-in functions like fopen() ,
fread() , fwrite() , and fclose() to handle files.
● Error Handling: Always check if file operations
succeed, and use error handling to manage issues like
file permissions or non-existent files.
Syntax Table
Ser Operati Syntax Example
ial on
No

1 Open fopen($filename, $mode) fopen("file.txt", "r")

File

2 Read fread($file, $length) fread($file, 100)

File
3 Write fwrite($file, $string) fwrite($file, "Hello")
File
4 Close fclose($file) fclose($file)
File

5 File file_exists($filename) file_exists("file.txt")

Exists
6 Delete unlink($filename) unlink("file.txt")
File
7 File file_get_contents($filenam file_get_contents("file.tx
Get e) t")
Conten
ts
8 File Put file_put_contents($filenam file_put_contents("file.tx
Conten e, $data) t", "Hello")
ts

1. Opening Files ( fopen )

What is Opening Files ( fopen )
The fopen function is used to open a file in PHP. It returns a file
pointer resource on success or false on failure. Depending on the
mode specified, it can open a file for reading, writing, appending,
etc.
Use Purpose
● Access files for reading, writing, or appending.
● Control file access modes, allowing for safe data
manipulation.
 ●
Handle various file operations, like reading contents or
writing new data.
Syntax
$file = fopen($filename, $mode);
Syntax Explanation
● $filename :
○ The name of the file to be opened.
● $mode :
○ Specifies the mode in which the file should be
opened, such as:
■ "r" : Read-only mode.
■ "w" : Write-only mode; truncates the file to
zero length or creates a new file if it doesn’t
exist.
■ "a" : Append mode; writes at the end of the
file.
■ "r+" : Read and write mode.
Simple Code Example

<?php
$file = fopen("example.txt", "r");
if ($file) {
echo "File opened successfully.";
fclose($file);
}
?>

Notes
● Always check if fopen() is successful before proceeding
with file operations.
● Use appropriate file modes to prevent unintentional data
loss (e.g., using "w" will erase existing content).
Warnings
● Be cautious with "w" mode, as it erases the existing
content of the file.
● Ensure proper permissions are set on the file or directory to
avoid access errors.
2. Reading Files ( fread and file_get_contents )
What is Reading Files
Reading files in PHP can be done using fread() for reading a
specified number of bytes, or file_get_contents() for reading the
entire file into a string.
Use Purpose
● Extract file contents, such as configuration settings, logs,
or data files.
● Process large files in chunks using fread() .
● Retrieve entire file contents for quick access using
file_get_contents() .

Syntax

$content = fread($file, $length);

Syntax Explanation
● $file :
○ The file resource obtained from fopen() .
● $length :
○ The number of bytes to read from the file.
Simple Code Example

<?php
$file = fopen("example.txt", "r");
if ($file) {
$content = fread($file, filesize("example.txt"));
echo $content;
fclose($file);
}
?>

Notes
● Use filesize() to read the entire file when using fread() .
● file_get_contents() is more straightforward for reading the
full content of a file.
Warnings
● Ensure the file is not too large when using
file_get_contents() , as it may exhaust memory.
● Always check if the file exists before reading to avoid errors.
3. Writing to Files ( fwrite and file_put_contents )
What is Writing to Files
Writing to files in PHP can be done using fwrite() to write data to an
open file resource or file_put_contents() to write data directly to a
file.
Use Purpose
● Store new data in files, such as logs, user data, or reports.
● Create new files or overwrite existing files with new
content.
● Append data to files without altering existing content.
Syntax

fwrite($file, $string);

Syntax Explanation
● $file :
○ The file resource obtained from fopen() .
● $string :
○ The string to be written to the file.
Simple Code Example

<?php
$file = fopen("example.txt", "w");
if ($file) {
fwrite($file, "Hello, PHP File Handling!");
fclose($file);
}
?>

Notes
● Use "a" mode to append data without overwriting existing
content.
 ● file_put_contents() is an alternative for writing strings
directly to a file.
Warnings
● Be cautious when using "w" mode, as it overwrites existing
content.
● Ensure proper permissions for writing to files, especially in
web environments.

4. Closing Files ( fclose )

What is Closing Files ( fclose )
The fclose() function closes an open file pointer, ensuring that
resources are freed and data is saved properly.
Use Purpose
● Release file resources, preventing memory leaks.
● Ensure data integrity, by saving changes made to files.
● Complete file operations, marking the end of file
handling.
Syntax

fclose($file);

Syntax Explanation
● $file :
○ The file resource to be closed, obtained from
fopen() .
Simple Code Example

<?php
$file = fopen("example.txt", "r");
if ($file) {
// Perform file operations
fclose($file);
}
?>
Notes
 ●Always close files after completing file operations to free up
resources.
● Closing files ensures that data is written to the file and the
file is no longer locked.
Warnings
● Attempting to use a closed file resource will result in errors.
● Forgetting to close files can lead to memory leaks and data
corruption.

5. Checking File Existence ( file_exists )

What is Checking File Existence ( file_exists )
The file_exists() function checks whether a file or directory exists,
returning true if it does and false otherwise.
Use Purpose
● Verify file existence before performing operations like
reading or writing.
● Prevent errors by checking if a file exists before accessing
it.
● Conditionally create or modify files, ensuring they exist
or don’t exist as needed.
Syntax

$fileExists = file_exists($filename);

Syntax Explanation
● $filename :
○ The name of the file to check for existence.
Simple Code Example
<?php
if (file_exists("example.txt")) {
echo "File exists.";
} else {
echo "File does not exist.";
}
?>
Notes
● Use file_exists() for basic file validation before
performing file operations.
● It works with both files and directories.
Warnings
● On large directories, file_exists() can be slow; use it
judiciously.
● Ensure the correct file path is provided to avoid false
negatives.

6. Deleting Files ( unlink )

What is Deleting Files ( unlink )
The unlink() function is used to delete a file from the filesystem. It
returns true on success or false on failure.
Use Purpose
● Remove unnecessary files, like temporary files or user
uploads.
● Clean up data, deleting outdated or unused files.
● Manage file-based storage, ensuring only relevant files
are kept.
Syntax

unlink($filename);

Syntax Explanation
● $filename :
○ The name of the file to be deleted.
Simple Code Example

<?php
if (file_exists("example.txt")) {
unlink("example.txt");
echo "File deleted.";
} else {
echo "File not found.";
}
?>
Notes
● Always check if a file exists before attempting to delete it.
● Use unlink() with caution, as deleted files cannot be
recovered.
Warnings
 ● Ensure correct permissions before attempting to delete a
file.
● Avoid using unlink() on sensitive files without proper
validation.
Final Project: "Simple File-Based Notepad"
Project Goal
● Create a PHP script that reads, writes, appends, and deletes
text files.
● Implement basic file handling functions to manage a simple
file-based notepad.
Code for This Project
<?php
// Create or write to a file
if (isset($_POST['save'])) {
$filename = "notes.txt";
$content = $_POST['content'];
file_put_contents($filename, $content);
echo "File saved successfully!";
}

// Read file content

if (file_exists("notes.txt")) {
$content = file_get_contents("notes.txt");
} else {
$content = "";
}
// Delete the file
if (isset($_POST['delete'])) {
if (file_exists("notes.txt")) {
unlink("notes.txt");
echo "File deleted successfully!";
$content = "";
} else {
echo "File not found.";
}
}
?>
<!-- Notepad Form -->
<form method="POST">
 <textarea name="content" rows="10" cols="30"><?php echo $content; ?>
</textarea><br>
<button type="submit" name="save">Save</button>
<button type="submit" name="delete">Delete</button>
</form>
Save and Run
● Save the code as notepad.php .
● Run it on a PHP server or use an online PHP sandbox.
Check Output
The script will display a notepad-like interface, allowing users to
enter text, save it to a file, or delete the file. This project
demonstrates file reading, writing, and deleting using PHP file
handling functions.

Chapter-17 PHP Sessions and Cookies

Chapter Overview
This chapter covers PHP sessions and cookies, which are used to
maintain user data across pages. Sessions store data server-side,
while cookies store data client-side. Both mechanisms are essential
for managing user authentication, preferences, and other persistent
data in web applications.
Chapter Goal
● Understand the differences between sessions and cookies.
● Learn how to set, retrieve, update, and delete sessions and
cookies.
● Explore the use cases for sessions and cookies in web
development.
● Implement a project that uses sessions and cookies to
manage user authentication and preferences.

Rules of PHP Sessions and Cookies

● Sessions: Store data server-side, are more secure, and
persist across pages during a session.
● Cookies: Store data client-side, can persist across sessions,
and are sent with each HTTP request.
● Data Management: Both sessions and cookies allow the
storage of user data, but sessions are better for sensitive
information, while cookies are useful for user preferences.
Syntax Table
Seri Mechanis Operati Syntax Example
al m on
No

1 Session Start session_start() session_start()

s Sessio
n
2 Session Set $_SESSION['key' $_SESSION['user
s Sessio ] = value; '] = 'Alice';
n
Variabl
e
3 Session Get $_SESSION['key' $_SESSION['user
s Sessio ] ']
n
Variabl
e
4 Session Destro session_destroy session_destroy(
s y () )
Sessio
n
5 Cookies Set setcookie('nam setcookie('user',
Cookie e', 'value', 'Alice',
$expire); time()+3600);

6 Cookies Get $_COOKIE['key'] $_COOKIE['user'

Cookie ]
7 Cookies Delete setcookie('nam setcookie('user',
Cookie e', '', time() - '', time()-3600);
3600);
1. Sessions
What are Sessions
Sessions are a way to store data on the server, allowing it to
be accessed across different pages during a user’s visit to
the website. Each session is identified by a unique session
ID, usually stored in a cookie on the client’s browser.
Use Purpose
● Maintain user authentication, keeping users
logged in across multiple pages.
● Store user-specific data, like shopping cart items,
preferences, or settings.
● Track user activities or progress, such as form
submissions or multi-step processes.
Syntax

session_start();
$_SESSION['key'] = value;

Syntax Explanation
● session_start() :
○ Initializes the session, making the
$_SESSION superglobal available.
● $_SESSION['key'] :
○ Stores a value in the session with the
specified key.
Simple Code Example

<?php
session_start(); // Start the session

// Set a session variable

$_SESSION['username'] = "Alice";

// Get the session variable

echo "Hello, " . $_SESSION['username']; // Outputs: Hello, Alice
?>

Notes
● The session_start() function must be called at the
beginning of the script, before any HTML output.
● Session data is stored server-side, making it more
secure for sensitive information like passwords or
user IDs.
Warnings
● Always use secure measures (like HTTPS) to prevent
session hijacking.
● Clear session variables using session_unset() and
end sessions with session_destroy() when no longer
needed.

2. Setting Session Variables

What is Setting Session Variables
Session variables allow data to be stored and accessed
across pages during a user’s session. They are set using the
$_SESSION superglobal.
Use Purpose
● Store temporary user data, such as login status,
user roles, or cart contents.
● Track user actions, like navigation steps or form
progress.
● Share data between pages, maintaining state
without using query strings or form data.
Syntax

$_SESSION['key'] = value;
Syntax Explanation
● $_SESSION['key'] :
○ Sets a session variable with the given key to
the specified value.
Simple Code Example

<?php
session_start(); // Start the session

$_SESSION['user_id'] = 12345;
echo "User ID is " . $_SESSION['user_id']; // Outputs: User ID is 12345
?>

Notes
● Session variables persist until the session ends or is
manually cleared.
● They are commonly used for user authentication,
preferences, and temporary storage.
Warnings
● Session variables should not store large amounts of
data, as it can impact server performance.
● Make sure to validate and sanitize any data stored in
sessions to prevent security vulnerabilities.

3. Retrieving Session Variables

What is Retrieving Session Variables
Session variables can be retrieved using the $_SESSION
superglobal, which allows access to previously set data
within the same session.
Use Purpose
● Access stored user data, like login status,
preferences, or other session-specific information.
 ● Use session data in different parts of the
application without re-querying the database.
● Maintain state across pages, keeping track of
user interactions.

Syntax

$value = $_SESSION['key'];

Syntax Explanation
● $_SESSION['key'] :
○ Retrieves the value of the specified session
variable.
Simple Code Example

<?php
session_start(); // Start the session

if (isset($_SESSION['username'])) {
echo "Welcome back, " . $_SESSION['username'] . "!";
} else {
echo "Please log in.";
}
?>

Notes
● Always check if a session variable is set using
isset() before accessing it to avoid errors.
● Session variables are server-side, so they are not
visible to users, making them suitable for sensitive
data.
Warnings
 ● Session variables may persist longer than expected;
use session_unset() to clear variables when they are
no longer needed.
● Avoid storing passwords or highly sensitive
information in session variables.

4. Destroying Sessions
What is Destroying Sessions
Destroying a session removes all stored data and ends the
session. It is useful when logging users out or clearing all
session variables.
Use Purpose
● Log users out, clearing all session data to ensure
security.
● End the session completely, preventing further
access to session variables.
● Reset session data, clearing any temporary
information stored during the session.
Syntax

session_unset();
session_destroy();

Syntax Explanation
● session_unset() :
○ Clears all session variables but keeps the
session active.
● session_destroy() :
○ Ends the session and clears all session data.
Simple Code Example

<?php
session_start(); // Start the session
// Log out and destroy session
session_unset();
session_destroy();
echo "You have been logged out.";
?>
Notes
● Use both session_unset() and session_destroy() to
ensure all session data is cleared.
● After destroying a session, you must call
session_start() to create a new session if needed.
Warnings
● After destroying a session, session variables are no
longer accessible.
● Ensure that users are properly redirected after
logging out to avoid confusion.

5. Cookies
What are Cookies
Cookies are small files stored on the user's browser that
contain key-value pairs. They are used to maintain data
across sessions, remember user preferences, and track user
behavior.
Use Purpose
● Store user preferences, like language or theme,
to provide a personalized experience.
● Remember user login information, enabling
automatic logins.
● Track user behavior, useful for analytics and
marketing.
Syntax

setcookie('name', 'value', $expire);

Syntax Explanation
● 'name' :
 ○ The name of the cookie to be set.
● 'value' :
○ The value to be stored in the cookie.
● $expire :
○ The expiration time of the cookie, specified as
a Unix timestamp.
Simple Code Example
<?php
setcookie("user", "Alice", time() + 3600); // Set a cookie for 1 hour

if (isset($_COOKIE['user'])) {
echo "Welcome back, " . $_COOKIE['user'] . "!";
}
// Outputs: Welcome back, Alice!
?>
Notes
● Cookies are stored client-side and sent with each
HTTP request, making them suitable for non-sensitive
data.
● Use setcookie() before any HTML output, as cookies
are set in the HTTP headers.
Warnings
● Cookies can be modified by users, so they should
not be used for sensitive information.
● Use secure cookie settings, like HttpOnly and
Secure , to protect cookies from JavaScript access and
insecure transmission.

6. Retrieving Cookies
What is Retrieving Cookies
Cookies can be accessed using the $_COOKIE superglobal,
which contains all the cookies set by the server and sent by
the client.
Use Purpose
 ● Access stored user preferences, like theme or
language settings.
● Retrieve persistent data, such as last login or
selected filters.
● Display personalized content, based on stored
cookies.
Syntax

$value = $_COOKIE['name'];

Syntax Explanation
● $_COOKIE['name'] :
○ Retrieves the value of the specified cookie.
Simple Code Example

<?php
if (isset($_COOKIE['user'])) {
echo "User: " . $_COOKIE['user'];
} else {
echo "No user found.";
}
?>

Notes
● Use isset() to check if a cookie exists before
accessing it to avoid errors.
● Cookies are useful for storing non-sensitive data
across multiple sessions.
Warnings
● Always validate and sanitize cookie values to
prevent security risks like XSS.
● Cookies can be deleted or modified by users, so do
not rely solely on cookies for authentication.
7. Deleting Cookies
What is Deleting Cookies
Cookies can be deleted by setting their expiration time to a
past date, effectively removing them from the client’s
browser.
Use Purpose
● Clear stored user data, like preferences or login
tokens, when logging out.
● Reset cookies, removing outdated or unused data.
● Ensure privacy, by deleting cookies that are no
longer needed.
Syntax

setcookie('name', '', time() - 3600);

Syntax Explanation
● 'name' :
○ The name of the cookie to be deleted.
● '' :
○ Sets the cookie’s value to an empty string.
● time() - 3600 :
○ Sets the expiration time to one hour in the
past, deleting the cookie.
Simple Code Example

<?php
setcookie("user", "", time() - 3600); // Delete the cookie
echo "User cookie has been deleted.";
?>

Notes
● Deleting a cookie requires setting the same path
and domain as when it was created.
 ● Use cookie deletion for logouts, clearing
preferences, or resetting user data.
Warnings
● Deleting a cookie does not guarantee its immediate
removal; the browser may retain it until the next
request.
● Ensure that cookie settings (path, domain) match
when deleting to avoid issues.

Final Project: "User Authentication with

Sessions and Cookies"
Project Goal
● Create a PHP script that manages user login using
sessions and remembers user preferences using
cookies.
● Implement user authentication and display
personalized content based on stored cookies.
Code for This Project

<?php
session_start(); // Start session

// Check form submission

if ($_SERVER["REQUEST_METHOD"] == "POST") {
$username = $_POST['username'];
$password = $_POST['password'];

// Dummy user validation

if ($username == "admin" && $password == "1234") {
$_SESSION['user'] = $username; // Set session variable
setcookie("last_login", date("Y-m-d H:i:s"), time() + (86400 * 30)); // Set
login time cookie for 30 days
header("Location: welcome.php"); // Redirect to welcome page
exit();
} else {
 echo "Invalid username or password!";
}
}
?>

<!-- Login Form -->

<form method="POST" action="">
<input type="text" name="username" placeholder="Username" required>
<input type="password" name="password" placeholder="Password"
required>
<button type="submit">Login</button>
</form>

<!-- welcome.php -->

<?php
session_start(); // Start session
if (isset($_SESSION['user'])) {
echo "Welcome, " . $_SESSION['user'] . "!";
if (isset($_COOKIE['last_login'])) {
echo " Last login: " . $_COOKIE['last_login'];
}
} else {
header("Location: login.php");
}
?>

Save and Run

● Save the code as login.php and create a
welcome.php file.
● Run it on a PHP server or use an online PHP
sandbox.
Check Output
The script will display a login form, validate user input,
manage user sessions, and set a cookie to remember the
last login time.
Summary
This chapter provided an in-depth look at PHP sessions and
cookies, covering setting, retrieving, and deleting both
mechanisms. It explained their differences, use cases, and
security considerations, concluding with a user
authentication project that uses sessions for login
management and cookies for storing user preferences.

Chapter-18 Object-Oriented
Programming (OOP) in PHP
Chapter Overview
This chapter covers the fundamentals of Object-Oriented
Programming (OOP) in PHP. OOP is a programming paradigm
based on the concept of objects, which are instances of
classes that encapsulate data and behaviors. OOP makes
PHP code more modular, reusable, and maintainable,
making it an essential technique for building complex web
applications.
Chapter Goal
● Understand the basic concepts of OOP, such as
classes, objects, properties, and methods.
● Learn how to create and use classes and objects in
PHP.
● Explore OOP principles like inheritance,
encapsulation, and polymorphism.
● Implement a simple project that demonstrates OOP
concepts in PHP.

Rules of PHP OOP

● Classes and Objects: A class defines a blueprint
for objects, while an object is an instance of a class.
● Encapsulation: Group related properties and
methods into a single unit (class).
● Inheritance: Derive new classes from existing ones,
allowing for code reuse.
● Polymorphism: Allows methods to perform
different actions based on the object calling them.
Syntax Table
Seri OOP Syntax Example
al Concept
No
1 Class class ClassName { class Car { ... }
... }
Declaration

2 Object $obj = new $myCar = new

Instantiation ClassName(); Car();
3 Properties public public $color;
$property;
4 Methods public function public function
methodName() {
... } start() { ... }

5 Constructor function function

__construct() __construct($color
{ ... } ) { ... }
6 Inheritance class Child extends class SportsCar
Parent { ... }
extends Car { ... }
7 Access public , private $engine;
Modifiers private ,
protected
8 Polymorphis function Method overriding
m methodName( in child class
) { ... }

1. Classes and Objects

What are Classes and Objects
In OOP, a class is a blueprint that defines the structure and
behavior of objects. It contains properties (variables) and
methods (functions). An object is an instance of a class,
representing a specific entity with the characteristics and
behaviors defined by the class.
Use Purpose
● Organize code into reusable blueprints, making
it easier to manage and maintain.
● Model real-world entities, like cars, users, or
products, in web applications.
● Encapsulate related properties and methods,
ensuring modular code.
Syntax

class ClassName {
// Properties
public $property;

// Methods
public function methodName() {
// Code
}
}

// Creating an object
$obj = new ClassName();
Syntax Explanation
● class ClassName :
○ Declares a new class named ClassName .
● $property :
○ A variable declared within the class to store
data (property).
● methodName() :
○ A function declared within the class to define
behavior (method).
● new ClassName() :
○ Creates a new object of the class.
Simple Code Example

<?php
class Car {
public $color;

public function start() {

return "Car started.";
}
}

// Create an object of Car

$myCar = new Car();
$myCar->color = "Red";
echo $myCar->start(); // Outputs: Car started.
?>
Notes
● A class can have multiple properties and
methods, encapsulating related functionality.
● Objects allow real-world modeling, making code
more intuitive and organized.
Warnings
● Always instantiate objects before accessing
properties or methods to avoid errors.
● Use meaningful class names to represent real-world
entities or concepts.

2. Properties and Methods

What are Properties and Methods
Properties are variables that store data within a class, while
methods are functions that define the behavior of the class.
Properties represent attributes of an object, and methods
represent actions that objects can perform.
Use Purpose
● Store object-specific data, like user information
or product details, using properties.
 ● Define actions or behaviors, like processing data
or interacting with other objects, using methods.
● Encapsulate related data and behavior, making
it easy to manage and maintain.
Syntax

class ClassName {
public $property; // Property

public function methodName() { // Method

// Code
}
}

Syntax Explanation
● $property :
○ Stores data related to the object, such as
name, age, or color.
● methodName() :
○ Performs actions related to the object, like
calculating values or interacting with other
methods.
Simple Code Example

<?php
class Car {
public $color;

public function setColor($color) {

$this->color = $color;
}

public function getColor() {

return $this->color;
}
}

// Create an object of Car

$myCar = new Car();
$myCar->setColor("Blue");
echo $myCar->getColor(); // Outputs: Blue
?>

Notes
● Use $this->property to access properties inside
methods within the class.
● Properties and methods are encapsulated within
the class, keeping data and behavior together.
Warnings
● Always initialize properties before using them to
avoid undefined errors.
● Be cautious with property visibility ( public , private ,
protected ), as it affects access.

3. Constructors
What are Constructors
Constructors are special methods automatically called when
an object is instantiated. They are used to initialize object
properties and set up initial conditions for the object.
Use Purpose
● Initialize object properties, like setting default
values or requiring specific parameters.
● Prepare objects for use, such as establishing
connections or loading initial data.
● Ensure objects have required data, preventing
incomplete or invalid states.
Syntax
class ClassName {
public function __construct($param) {
$this->property = $param;
}
}

Syntax Explanation
● __construct() :
○ A special method called when an object is
created.
● $param :
○ A parameter passed during object creation,
used to initialize properties.

Simple Code Example

<?php
class Car {
public $color;

public function __construct($color) {

$this->color = $color;
}

public function getColor() {

return $this->color;
}
}

// Create an object of Car with initial color

$myCar = new Car("Green");
echo $myCar->getColor(); // Outputs: Green
?>

Notes
 ● Constructors provide a way to initialize objects
with specific properties.
● They help ensure objects are ready to use
immediately after creation.
Warnings
● If a class has a constructor, passing the correct
number of arguments during instantiation is
mandatory.
● Avoid complex logic inside constructors, as it may
complicate object creation.

4. Inheritance
What is Inheritance
Inheritance allows one class (child) to inherit properties and
methods from another class (parent). It promotes code
reuse and hierarchical class structures.

Use Purpose
● Reuse existing code, allowing child classes to
inherit functionality from parent classes.
● Extend or override parent behavior, adding or
modifying methods and properties.
● Create hierarchical relationships, modeling real-
world entities with shared characteristics.
Syntax

class ChildClass extends ParentClass {

// Code
}

Syntax Explanation
 ● extends ParentClass :
○ Specifies that the child class inherits from the
parent class.
● ChildClass:
○ The new class that inherits properties and
methods from the parent class.
Simple Code Example

<?php
class Car {
public function start() {
return "Car started.";
}
}

class SportsCar extends Car {

public function turboBoost() {
return "Turbo boost activated!";
}
}

$myCar = new SportsCar();

echo $myCar->start(); // Outputs: Car started.
echo $myCar->turboBoost(); // Outputs: Turbo boost activated!
?>

Notes
● Inheritance enables code reuse, making child
classes inherit parent class features.
● Use parent::method() to call a parent method from
a child class.
Warnings
● Be careful with method names to avoid
unintentional overriding in child classes.
 ● Deep inheritance hierarchies can make debugging
more difficult.

5. Encapsulation
What is Encapsulation
Encapsulation is the concept of bundling data (properties)
and methods that operate on the data within a single unit
(class). It restricts access to certain components, making
the data secure.
Use Purpose
●
Hide internal details, exposing only necessary
information to users.
● Control access to properties, allowing methods
to manage data changes.
● Improve code maintainability, ensuring that
internal implementation can change without affecting
external code.
Syntax
class ClassName {
private $property;

public function setProperty($value) {

$this->property = $value;
}

public function getProperty() {

return $this->property;
}
}

Syntax Explanation
● private $property :
○ Restricts access to the property within the
class.
 ● setProperty() and getProperty() :
○ Methods used to access and modify private
properties.
Simple Code Example

<?php
class Car {
private $speed;

public function setSpeed($speed) {

if ($speed > 0) {
$this->speed = $speed;
}
}

public function getSpeed() {

return $this->speed;
}
}

$myCar = new Car();

$myCar->setSpeed(120);
echo $myCar->getSpeed(); // Outputs: 120
?>

Notes
● Encapsulation improves data security by
controlling property access.
● Use getters and setters to manage property access
and modification.
Warnings
● Avoid direct access to private properties from
outside the class.
● Make use of access modifiers ( private , protected ,
public ) appropriately to enforce encapsulation.
6. Polymorphism
What is Polymorphism
Polymorphism allows methods to perform different actions
based on the object that calls them. It enables method
overriding, where a subclass can redefine a method
inherited from the parent class.
Use Purpose
● Implement flexible code, where methods behave
differently based on the calling object.
● Override parent methods, adapting them to
specific needs of child classes.
● Create a consistent interface, while allowing
varied behavior across classes.
Syntax

class ParentClass {
public function methodName() {
// Code
}
}

class ChildClass extends ParentClass {

public function methodName() {
// Modified code
}
}

Syntax Explanation
● Method overriding:
○ Occurs when a child class redefines a method
from its parent class.
● methodName() :
○ The method that exhibits polymorphic
behavior.
Simple Code Example

<?php
class Car {
public function start() {
return "Car started.";
}
}

class SportsCar extends Car {

public function start() {
return "Sports car started with turbo!";
}
}

$myCar = new SportsCar();

echo $myCar->start(); // Outputs: Sports car started with turbo!
?>

Notes
● Polymorphism enables dynamic behavior, making
classes more adaptable to changing requirements.
● Use parent::methodName() in the child class to call
the parent’s method.
Warnings
● Be aware of method names in parent and child
classes to avoid unintended behavior.
● Ensure consistent interfaces in polymorphic
methods to maintain compatibility.

Final Project: "Vehicle Management System"

Project Goal
● Create a PHP script that models a vehicle
management system using OOP principles.
● Implement classes, objects, inheritance, and
encapsulation to manage different vehicle types.
Code for This Project

<?php
// Parent class
class Vehicle {
protected $brand;
protected $speed;

public function __construct($brand, $speed) {

$this->brand = $brand;
$this->speed = $speed;
}

public function getDetails() {

return "Brand: $this->brand, Speed: $this->speed km/h";
}
}

// Child class
class Car extends Vehicle {
private $type;

public function __construct($brand, $speed, $type) {

parent::__construct($brand, $speed);
$this->type = $type;
}

public function getDetails() {

return parent::getDetails() . ", Type: $this->type";
}
}

// Using the classes

$myCar = new Car("Toyota", 180, "Sedan");
echo $myCar->getDetails(); // Outputs: Brand: Toyota, Speed: 180 km/h, Type:
Sedan
?>
Save and Run
 ● Save the code as vehicle_management.php .
● Run it on a PHP server or use an online PHP
sandbox.
Check Output
The script will display vehicle details, demonstrating class
creation, inheritance, and encapsulation.
Summary
This chapter provided a comprehensive introduction to
Object-Oriented Programming (OOP) in PHP, covering
classes, objects, properties, methods, constructors,
inheritance, encapsulation, and polymorphism. It concluded
with a vehicle management system project that
demonstrates the practical application of OOP concepts.

Chapter-19 Error Handling and

Debugging in PHP
Chapter Overview
This chapter covers error handling and debugging in PHP,
which are essential for identifying, managing, and resolving
issues in your code. PHP provides built-in error handling
mechanisms, along with debugging tools, to help developers
locate and fix errors efficiently. Understanding how to
handle errors and debug PHP code ensures the reliability
and stability of web applications.
Chapter Goal
● Understand different types of errors in PHP and how
to handle them.
● Learn how to use PHP's error handling functions and
tools for debugging.
● Explore custom error handling and exceptions for
advanced error management.
● Implement a project that demonstrates error
handling and debugging techniques.
Rules of PHP Error Handling and Debugging
● Error Types: PHP categorizes errors as notices,
warnings, and fatal errors, each requiring different
handling approaches.
● Error Reporting Levels: Use error reporting levels
to control which types of errors are displayed.
● Exception Handling: PHP exceptions allow
developers to handle errors in a structured way,
improving code clarity and reliability.
● Debugging Tools: Use debugging tools like
var_dump() , print_r() , and error logs to identify
issues in code.
Syntax Table
Seri Error Operation Syntax
al Handlin
No g
1 Set Error error_reporting(level error_reporting(E_ALL)
Reportin )
g
2 Error set_error_handler() set_error_handler("myErrorHandle
Handlin r")
g
Function
3 Trigger trigger_error(messa trigger_error("Error!",
Error ge, type) E_USER_ERROR)
4 Try- try { ... } catch See below
Catch (Exception $e) { ... }
Block

5 Exceptio class See below

n Class CustomException
extends Exception
6 Debuggi var_dump($variable) var_dump($data)
ng

7 Error error_log(message) error_log("An error occurred!")

Log

1. Types of Errors in PHP

What are Types of Errors in PHP
PHP errors can be categorized into notices, warnings, and fatal errors. Each
type indicates a different severity level and requires a different approach for
handling.
Use Purpose
● Notices: Inform about non-critical issues, like undefined variables.
● Warnings: Indicate potential issues, like including a non-existent
file.
● Fatal Errors: Stop script execution, like calling an undefined
function.
Syntax for Error Types
Notices: Typically displayed when there is a minor issue in the code, but
the script continues to execute.
echo $undefinedVar; // Triggers a notice

Warnings: Indicate issues that may not stop script execution but need
attention.

include("nonexistent_file.php"); // Triggers a warning

Fatal Errors: Stop script execution and must be fixed for the script to run.

undefinedFunction(); // Triggers a fatal error

Simple Code Example

<?php
// Notice: Undefined variable
echo $name;

// Warning: Including a non-existent file

include("nonexistent_file.php");

// Fatal Error: Call to undefined function

myUndefinedFunction();
?>

Notes
● Notices are often related to uninitialized variables or array
indexes.
● Warnings usually occur when the script tries to perform actions
that may not be critical but need attention.
● Fatal Errors stop script execution, making them the most severe
type of error.
Warnings
● Use error reporting to identify and fix notices and warnings
during development.
● Handle fatal errors promptly to prevent script termination.

2. Error Reporting Levels

What are Error Reporting Levels
PHP offers different error reporting levels to control which types of errors are
displayed. Developers can adjust these levels to show all errors during
development and hide critical errors in production.
Use Purpose
 ●
Control which errors are displayed, helping developers focus
on specific issues.
● Adjust error visibility based on development or production
environments.
● Improve debugging, by displaying detailed error messages
during development.
Syntax
error_reporting(level);
Syntax Explanation
● error_reporting() :
○ Sets the error reporting level for the script.
● level :
○ The type of errors to report, such as E_ALL , E_WARNING ,
or E_NOTICE .
Simple Code Example

<?php
// Report all errors
error_reporting(E_ALL);

// Report only warnings and errors

error_reporting(E_WARNING | E_ERROR);
?>

Notes
● Use E_ALL to report all errors during development for effective
debugging.
● Set error reporting to 0 in production to hide error messages from
users.
Warnings
● Avoid displaying detailed error messages in production, as they
may expose sensitive information.
● Use error logging in production to keep track of issues without
revealing them to users.

3. Custom Error Handling ( set_error_handler )

What is Custom Error Handling
PHP allows developers to define custom error-handling functions using the
set_error_handler() function. This approach helps manage errors
consistently throughout the code.
Use Purpose
 ● Handle errors consistently, using a custom error handler for
specific actions.
● Log errors, track issues, or notify administrators automatically.
● Control how errors are displayed, providing meaningful
messages to users.

Syntax

set_error_handler("customErrorHandler");

function customErrorHandler($errno, $errstr, $errfile, $errline) {

echo "Error [$errno]: $errstr in $errfile on line $errline";
}

Syntax Explanation
● set_error_handler() :
○ Sets a custom error handler function for the script.
● customErrorHandler :
○ The function name that will handle errors.
Simple Code Example

<?php
function myErrorHandler($errno, $errstr, $errfile, $errline) {
echo "Error [$errno]: $errstr in $errfile on line $errline";
}

set_error_handler("myErrorHandler");

// Trigger an error
echo $undefinedVar;
?>

Notes
● Custom error handlers provide more control over how errors are
managed and displayed.
● Use error logging inside custom handlers to keep track of errors.
Warnings
● Make sure the custom error handler is defined before setting it with
set_error_handler() .
● Avoid using custom error handling for fatal errors, as they may not
be caught.
4. Triggering User Errors ( trigger_error )
What is Triggering User Errors
The trigger_error() function allows developers to trigger user-defined errors
in code. It helps in managing errors manually, especially for validation or
custom logic failures.
Use Purpose
● Generate custom errors, such as validation failures or
unexpected conditions.
● Handle errors explicitly, providing custom error messages.
● Test error handling mechanisms, ensuring they work as
expected.
Syntax

trigger_error(message, type);

Syntax Explanation
● message :
○ The custom error message to display.
● type :
○ The type of user error to trigger, such as
E_USER_WARNING or E_USER_ERROR .
Simple Code Example

<?php
function divide($num, $den) {
if ($den == 0) {
trigger_error("Cannot divide by zero", E_USER_ERROR);
}
return $num / $den;
}

echo divide(10, 0); // Triggers user error

?>

Notes
● Use E_USER_NOTICE , E_USER_WARNING , and E_USER_ERROR for
different levels of user errors.
● Custom error messages help users understand the problem more
clearly.
Warnings
 ● Be careful when triggering E_USER_ERROR , as it stops script
execution.
● Validate input to prevent unnecessary user errors.

5. Exception Handling ( try-catch )

What is Exception Handling
PHP exceptions provide a structured way to handle errors using try-catch
blocks. Exceptions separate error handling from regular code, making the
logic clearer and easier to maintain.
Use Purpose
● Handle errors elegantly, separating error management from
normal code flow.
● Catch and handle specific exceptions, like database or file
errors.
● Improve code readability, making it clear where errors are
expected.
Syntax
try {
// Code that may throw an exception
} catch (Exception $e) {
// Handle exception
}
Syntax Explanation
● try :
○ Contains code that may throw exceptions.
● catch :
○ Handles exceptions, with $e representing the caught
exception.

Simple Code Example

<?php
try {
throw new Exception("This is an exception!");
} catch (Exception $e) {
echo "Caught exception: " . $e->getMessage();
}
?>

Notes
● Use throw to generate exceptions manually.
● Exception handling makes error management more structured and
reliable.
Warnings
● Not all errors are exceptions; use exceptions for cases that require
structured error handling.
● Catch specific exceptions to prevent catching unintended errors.

6. Debugging Tools ( var_dump , print_r , error_log )

What are Debugging Tools
PHP provides various tools for debugging, such as var_dump() , print_r() ,
and error_log() . These tools help developers inspect variables, log errors,
and analyze issues.
Use Purpose
● Inspect variables and arrays, understanding their structure and
content.
● Log errors to files, keeping track of issues in production.
● Identify variable types and values, helping diagnose
unexpected behavior.

Syntax for Debugging Tools

● var_dump($variable) : Dumps detailed information about the
variable.
● print_r($variable) : Prints readable information about arrays or
objects.
● error_log($message) : Logs error messages to a file or system
logger.
Simple Code Example

<?php
$data = array("name" => "Alice", "age" => 30);

// Using var_dump
var_dump($data);

// Using print_r
print_r($data);

// Using error_log
error_log("An error occurred!");
?>

Notes
● Use var_dump() for detailed debugging during development.
 ● Use error_log() in production to log errors without exposing them
to users.
Warnings
● Avoid using var_dump() or print_r() in production, as they may
expose sensitive information.
● Check error log files regularly to monitor errors in production.

Final Project: "Simple Calculator with Error Handling"

Project Goal
● Create a PHP script that acts as a simple calculator with error
handling.
● Implement custom error handling, exception handling, and
debugging tools.
Code for This Project

<?php
// Custom error handler
function myErrorHandler($errno, $errstr, $errfile, $errline) {
echo "Error [$errno]: $errstr in $errfile on line $errline";
}
set_error_handler("myErrorHandler");

// Calculator function
function divide($num, $den) {
if ($den == 0) {
trigger_error("Cannot divide by zero", E_USER_WARNING);
return false;
}
return $num / $den;
}
try {
// Perform division
$result = divide(10, 0);
if ($result !== false) {
echo "Result: $result";
}
} catch (Exception $e) {
echo "Caught exception: " . $e->getMessage();
}
?>
Save and Run
● Save the code as calculator.php .
● Run it on a PHP server or use an online PHP sandbox.
Check Output
The script will attempt to divide numbers and handle division by zero using
custom error handling and exception handling.
Summary
This chapter provided a comprehensive look at error handling and
debugging in PHP, covering error types, error reporting, custom error
handling, exceptions, and debugging tools. It concluded with a simple
calculator project that demonstrates error handling and debugging
techniques in practice.

Chapter-20 Basic Database Interaction (MySQL)

in PHP
Chapter Overview
This chapter covers basic database interaction using MySQL in PHP,
focusing on establishing connections, executing queries, and handling
results. PHP’s integration with MySQL allows developers to store, retrieve,
update, and delete data from a MySQL database, making it essential for
building dynamic, data-driven web applications.
Chapter Goal
● Understand how to establish a connection between PHP and a
MySQL database.
● Learn how to execute SQL queries to insert, retrieve, update, and
delete records.
● Explore secure database interactions using prepared statements.
● Implement a project that demonstrates CRUD (Create, Read,
Update, Delete) operations.

Rules of PHP-MySQL Interaction

● Database Connection: Use the mysqli or PDO extension to
connect PHP to MySQL databases.
● Error Handling: Check connection and query execution for errors,
handling them appropriately.
● SQL Injection Prevention: Use prepared statements to prevent
SQL injection attacks.
● Data Retrieval: Use different methods to fetch results, such as
fetch_assoc() or fetch_all() .
Syntax Table
Seri Operatio Syntax Example
al n
No
1 Database new $conn = new
Connectio mysqli($host, mysqli(...)
n $user, $password,
$db)

2 Execute $conn- $conn-

Query >query($sql) >query("SELECT
* FROM users")
3 Prepare $conn- $stmt = $conn-
Statement >prepare($sql) >prepare("...")
4 Bind $stmt- $stmt-
Parameter >bind_param("s", >bind_param("i",
s $param) $id)

5 Execute $stmt->execute() $stmt-

Statement >execute()
6 Fetch $stmt->fetch() $stmt->fetch()
Results

7 Close $conn->close() $conn->close()

Connectio
n
1. Establishing a Connection to MySQL
What is Establishing a Connection to MySQL
Connecting to a MySQL database in PHP is the initial step for
performing any database operations, such as querying or
modifying data. PHP provides the mysqli and PDO
extensions for database connections, with mysqli being
used for MySQL specifically.
Use Purpose
● Access MySQL databases, enabling data storage
and retrieval.
● Establish communication between PHP and
MySQL, facilitating dynamic data handling.
● Perform SQL operations, like querying, inserting,
updating, and deleting records.
Syntax
$conn = new mysqli($host, $user, $password, $database);
Syntax Explanation
● $host :
○ The hostname of the MySQL server (e.g.,
"localhost" ).
● $user :
○ The username to log in to the MySQL
database.
● $password :
○ The password for the MySQL user.
● $database :
○ The name of the database to connect to.
Simple Code Example
<?php
$host = "localhost";
$user = "root";
$password = "";
$database = "test_db";

$conn = new mysqli($host, $user, $password, $database);

if ($conn->connect_error) {
die("Connection failed: " . $conn->connect_error);
} else {
echo "Connected successfully!";
}
?>

Notes
● Use mysqli or PDO for database interaction;
mysqli is easier for beginners, while PDO offers
more features.
● Always check for connection errors using $conn-
>connect_error to prevent issues.
Warnings
● Never hard-code sensitive information (e.g.,
passwords) directly in the script; use environment
variables for better security.
● Close the connection using $conn->close() to free
resources.

2. Executing SQL Queries

What is Executing SQL Queries
Executing SQL queries involves sending SQL commands to
the MySQL database to perform various operations, such as
retrieving or modifying data.
Use Purpose
● Retrieve data from tables using SELECT queries.
● Modify data, including inserting, updating, or
deleting records.
● Manage database structure, such as creating or
altering tables.
Syntax
$result = $conn->query($sql);
Syntax Explanation
 ● $conn->query() :
○ Executes an SQL statement against the
database.
● $sql :
○ The SQL query to execute, such as "SELECT *
FROM users" .

Simple Code Example

<?php
$sql = "SELECT * FROM users";
$result = $conn->query($sql);

if ($result->num_rows > 0) {
while ($row = $result->fetch_assoc()) {
echo "Name: " . $row["name"] . "<br>";
}
} else {
echo "No results found.";
}
?>

Notes
● Use fetch_assoc() to fetch results as an associative
array.
● Use num_rows to check if the query returns any
rows.
Warnings
● Ensure that SQL queries are properly formatted to
prevent syntax errors.
● Check if the query is successful using if ($result)
before processing results.

3. Prepared Statements
What are Prepared Statements
Prepared statements are used to execute SQL queries
securely by separating SQL syntax from data inputs,
preventing SQL injection attacks. They involve preparing the
SQL statement, binding parameters, and executing it.
Use Purpose
● Prevent SQL injection attacks, making database
interaction more secure.
● Improve performance for repeated execution of
similar queries.
● Handle dynamic data, such as user input, safely.

Syntax

$stmt = $conn->prepare($sql);
$stmt->bind_param($types, $variables);
$stmt->execute();

Syntax Explanation
● $stmt->prepare() :
○ Prepares an SQL statement for execution.
● bind_param() :
○ Binds variables to placeholders in the SQL
statement.
● $types :
○ Specifies data types for variables (e.g., "s"
for string, "i" for integer).
Simple Code Example

<?php
$stmt = $conn->prepare("INSERT INTO users (name, email) VALUES (?, ?)");
$stmt->bind_param("ss", $name, $email);

$name = "Alice";
$email = "[email protected]";
$stmt->execute();

echo "New record created successfully.";

?>
Notes
● Use prepared statements for all queries that involve
user input to prevent SQL injection.
● bind_param() supports multiple data types, such as
"s" (string), "i" (integer), "d" (double), and "b"
(blob).
Warnings
● Ensure the number of bound parameters matches
the placeholders in the prepared statement.
● Prepared statements are not suitable for dynamic
table names or column names.

4. Fetching Results
What is Fetching Results
Fetching results refers to retrieving data from the result of a
SELECT query and processing it within the PHP script.
Use Purpose
● Retrieve and display data, such as user details or
product listings.
● Process result sets, handling rows returned from
queries.
● Iterate through results, using loops to manage
fetched data.
Syntax

while ($row = $result->fetch_assoc()) {

// Code to process $row
}

Syntax Explanation
● fetch_assoc() :
○ Fetches a result row as an associative array.
● $row :
○ Represents the current row being fetched
from the result set.
Simple Code Example

<?php
$sql = "SELECT name, email FROM users";
$result = $conn->query($sql);

if ($result->num_rows > 0) {
while ($row = $result->fetch_assoc()) {
echo "Name: " . $row["name"] . ", Email: " . $row["email"] . "<br>";
}
} else {
echo "No results found.";
}
?>

Notes
● Use fetch_assoc() to retrieve results as an
associative array, making data processing more
intuitive.
● Check num_rows before fetching to ensure the
query returned results.
Warnings
● Ensure that fetched results are properly sanitized
before displaying them to avoid XSS attacks.
 ● Handle cases where the result set is empty to
prevent unexpected behavior.

5. Updating Records
What is Updating Records
Updating records involves modifying existing data in the
database using the SQL UPDATE statement.
Use Purpose
● Change existing data, such as updating user
details or order status.
● Modify multiple records, using conditions like
WHERE clauses.
● Adjust records dynamically, based on user
actions or input.
Syntax
$sql = "UPDATE table_name SET column_name = ? WHERE condition";
$stmt = $conn->prepare($sql);
$stmt->bind_param("type", $value);
$stmt->execute();

Syntax Explanation
● UPDATE table_name :
○ Modifies data in the specified table.
● SET column_name = ? :
○ Sets the new value for the specified column.
● WHERE condition :
○ Restricts the update to matching records.

Simple Code Example

<?php
$stmt = $conn->prepare("UPDATE users SET email = ? WHERE name = ?");
$stmt->bind_param("ss", $email, $name);

$email = "[email protected]";
$name = "Alice";
$stmt->execute();

echo "Record updated successfully.";

?>

Notes
● Always use WHERE clauses to prevent accidental
updates to all records.
● Use prepared statements to prevent SQL injection
when updating records.
Warnings
● Avoid updating records without a WHERE clause to
prevent unintended modifications.
● Check if the update was successful using $stmt-
>affected_rows .

6. Deleting Records
What is Deleting Records
Deleting records involves removing data from a table using
the SQL DELETE statement.
Use Purpose
● Remove obsolete data, like outdated records or
canceled orders.
● Manage database size, by clearing unneeded
entries.
● Handle user actions, like account deletion or item
removal.

Syntax

$sql = "DELETE FROM table_name WHERE condition";

$stmt = $conn->prepare($sql);
$stmt->bind_param("type", $value);
$stmt->execute();

Syntax Explanation
● DELETE FROM table_name :
○ Removes data from the specified table.
● WHERE condition :
○ Restricts deletion to matching records.
Simple Code Example

<?php
$stmt = $conn->prepare("DELETE FROM users WHERE name = ?");
$stmt->bind_param("s", $name);

$name = "Alice";
$stmt->execute();

echo "Record deleted successfully.";

?>

Notes
● Always use WHERE clauses to specify the records to
delete, preventing unintended deletions.
● Use prepared statements to secure delete
operations.
Warnings
● Be cautious when deleting records, as this action is
irreversible.
● Ensure proper user permissions before allowing
delete operations.
Final Project: "User Management System with
CRUD Operations"
Project Goal
● Create a PHP script that performs basic CRUD
operations (Create, Read, Update, Delete) on a
MySQL database.
● Implement prepared statements for secure database
interactions.
Code for This Project

<?php
$host = "localhost";
$user = "root";
$password = "";
$database = "test_db";

$conn = new mysqli($host, $user, $password, $database);

if ($conn->connect_error) {
die("Connection failed: " . $conn->connect_error);
}

// CREATE
if (isset($_POST['create'])) {
$stmt = $conn->prepare("INSERT INTO users (name, email) VALUES (?, ?)");
$stmt->bind_param("ss", $name, $email);

$name = $_POST['name'];
$email = $_POST['email'];
$stmt->execute();
echo "New user created successfully.";
}

// READ
$sql = "SELECT * FROM users";
$result = $conn->query($sql);
if ($result->num_rows > 0) {
 while ($row = $result->fetch_assoc()) {
echo "ID: " . $row["id"] . ", Name: " . $row["name"] . ", Email: " .
$row["email"] . "<br>";
}
} else {
echo "No users found.";
}

// UPDATE
if (isset($_POST['update'])) {
$stmt = $conn->prepare("UPDATE users SET email = ? WHERE name = ?");
$stmt->bind_param("ss", $email, $name);

$name = $_POST['name'];
$email = $_POST['email'];
$stmt->execute();
echo "User updated successfully.";
}

// DELETE
if (isset($_POST['delete'])) {
$stmt = $conn->prepare("DELETE FROM users WHERE name = ?");
$stmt->bind_param("s", $name);

$name = $_POST['name'];
$stmt->execute();
echo "User deleted successfully.";
}
?>

Save and Run

● Save the code as user_management.php .
● Run it on a PHP server or use an online PHP
sandbox.
Check Output
The script will perform basic CRUD operations on a MySQL
database, demonstrating secure database interaction.
Summary
This chapter provided a comprehensive introduction to basic
database interaction with MySQL in PHP, covering database
connections, executing queries, prepared statements, and
CRUD operations. It concluded with a user management
system project that demonstrates the practical application
of CRUD operations using MySQL and PHP.