VISION OF THE INSTITUTE

Empower the individuals and society at large through educational excellence;

sensitize them for a life dedicated to the service of fellow human beings and mother
land.

MISSION OF THE INSTITUTE

To impact holistic education that enables the students to become socially
responsive and useful, with roots firm on traditional and cultural values; and to
hone their skills to accept challenges and respond to opportunities in a global
scenario.

Lecture Notes on
PHP & MYSQL
Prepared by

Department
Computer Science B.C.A.
 UNIT -1
Introduction
PHP started out as a small open source project that evolved as more and more people found out how
useful it was. Rasmus Lerdorf unleashed the first version of PHP way back in 1994.

 PHP is a recursive acronym for "PHP: Hypertext Preprocessor".

 PHP is a server side scripting language that is embedded in HTML. It is used to manage
dynamic content, databases, session tracking, even build entire e-commerce sites.
 It is integrated with a number of popular databases, including MySQL, PostgreSQL,Oracle,
Sybase, Informix, and Microsoft SQL Server.
 PHP is pleasingly zippy in its execution, especially when compiled as an Apache module on
the Unix side. The MySQL server, once started, executes even very complex queries with
huge result sets in record-setting time.
 PHP supports a large number of major protocols such as POP3, IMAP, and LDAP. PHP4
added support for Java and distributed object architectures (COM and CORBA), making n-
tier development a possibility for the first time.
 PHP is forgiving: PHP language tries to be as forgiving as possible.
 PHP Syntax is C-Like.

History of PHP
PHP, originally standing for “Personal Home Page,” was created by Rasmus Lerdorf in 1994.
Initially, PHP was a set of Common Gateway Interface (CGI) binaries written in the C programming
language for managing his personal website. Over time, it evolved into a more robust scripting
language, with the release of PHP/FI (Forms Interpreter) 2.0 in 1997.
In 1997, two Israeli developers, Zeev Suraski and Andi Gutmans, rewrote the parser for PHP,
leading to the birth of PHP 3. This version introduced the parser written in C and brought significant
improvements to the language’s performance and capabilities.
PHP 4, released in 2000, was a major milestone that included support for object-oriented
programming (OOP) and introduced many features that laid the foundation for modern PHP
development.
PHP 5, launched in 2004, brought substantial improvements, including better support for OOP with
the introduction of features like interfaces and exception handling.
PHP 7, released in 2015, marked a significant leap in performance, boasting up to twice the speed of
PHP 5.x versions, along with many new features and enhancements.
PHP 8, released in 2020, introduced JIT (Just-In-Time) compilation, which further improved
performance and brought new language features, enhancements, and optimizations.
Throughout its history, PHP has become one of the most popular server-side scripting languages,
powering a vast majority of websites on the internet, including some of the most popular ones like

Page 1 of 34 PHP NOTES / DEPT.OF COMPUTER APPLICATION

Facebook and WordPress. Its open-source nature and extensive community support have contributed
to its widespread adoption and continuous evolution.

PHP Features

1. Performance:
PHP script is executed much faster than those scripts which are written in other languages
such as JSP and ASP. PHP uses its own memory, so the server workload and loading time is
automatically reduced, which results in faster processing speed and better performance.
2. Open Source:
PHP source code and software are freely available on the web. You can develop all the
versions of PHP according to your requirement without paying any cost. All its components
are free to download and use.
3. Familiarity with syntax: PHP has easily understandable syntax. Programmers are
comfortable coding with it.
4. Embedded: PHP code can be easily embedded within HTML tags and script.
5. Platform Independent: PHP is available for WINDOWS, MAC, LINUX & UNIX operating
system. A PHP application developed in one OS can be easily executed in other OS also.
6. Database Support: PHP supports all the leading databases such as MySQL, SQLite, ODBC,
etc.
7. Error Reporting –PHP has predefined error reporting constants to generate an error notice
or warning at runtime. E.g., E_ERROR, E_WARNING, E_STRICT, E_PARSE.
8. Loosely Typed Language: PHP allows us to use a variable without declaring its datatype. It
will be taken automatically at the time of execution based on the type of data it contains on
its value.
9. Web servers Support: PHP is compatible with almost all local servers used today like
Apache, Netscape, Microsoft IIS, etc.
10. Security: PHP is a secure language to develop the website. It consists of multiple layers of
security to prevent threads and malicious attacks.
11. Control: Different programming languages require long script or code, whereas PHP can do
the same work in a few lines of code. It has maximum control over the websites like you can
make changes easily whenever you want.

Page 2 of 34 PHP NOTES / DEPT.OF COMPUTER APPLICATION

 12. A Helpful PHP Community: It has a large community of developers who regularly updates
documentation, tutorials, online help, and FAQs. Learning PHP from the communities is one
of the significant benefits.

Installation:
1. Update Package Index: Ensure your package index is up to date:
sudo apt update
2. Install PHP: Install PHP and common PHP extensions:
sudo apt install php
3. Verify Installation: After installation, verify PHP installation by checking the version:
php -v
Configuration:
1. Configuration Files: PHP configuration files are usually located in
/etc/php/{version}/apache2/php.ini or /etc/php/{version}/cli/php.ini for Apache and
command line respectively.
2. Edit Configuration: Use your preferred text editor to modify the PHP configuration file. You
might need sudo privileges:
sudonano /etc/php/{version}/apache2/php.ini
3. Adjust Settings: Modify settings like max_execution_time, memory_limit, and
error_reporting according to your requirements.
4. Restart Apache: After making changes, restart the Apache server for changes to take effect:
sudosystemctl restart apache2
Common Extensions:
 You might also need to install additional PHP extensions based on your requirements. For
example, to install MySQL extension:
sudo apt install php-mysql
Configuration Testing:
 Create a test PHP file in your web server’s root directory (usually /var/www/html/) with the
following content:
<?php
phpinfo();
?>

Page 3 of 34 PHP NOTES / DEPT.OF COMPUTER APPLICATION

Save this file as info.php. Access this file via a web browser (e.g., http://your_server_ip/info.php) to
see PHP configuration details.
Security Considerations:
 Always keep PHP and its extensions updated to the latest stable versions for security patches.
 Disable functions and features you don’t need for your application’s security.
 Sanitize user inputs to prevent common security vulnerabilities like SQL injection and cross-
site scripting (XSS).
These steps should help you install and configure PHP on your system. Make sure to adjust
configurations according to your specific requirements and security best practices.
Embedding PHP code in your web page
PHP is the abbreviation of Hypertext Preprocessor and earlier it was abbreviated as Personal Home
Page.
We can use PHP in HTML code by simply adding a PHP tag without doing any extra work.
First open the file in any editor and then write HTML code according to requirement. If we have to
add PHP code then we can add by simply adding <?php ….. ?> tags in between and add your PHP
code accordingly.
<!DOCTYPE html>
<html>
<head>
<title>PHP</title>
</head>
<body>
<h1>
<?php
Echo “MIT FIRST GRADE COLLEGE“
?>
</h1>
</body>
</html>
HTML and white space

Page 4 of 34 PHP NOTES / DEPT.OF COMPUTER APPLICATION

In PHP, HTML and whitespace are handled similarly to how they are in regular HTML documents.
PHP can generate HTML output with whitespace included, and it doesn’t affect the rendering of the
HTML in the browser.
However, you can control whitespace output in PHP. For example, you can use functions like trim()
to remove whitespace from the beginning and end of a string, or preg_replace() with a regular
expression to remove excess whitespace within a string.
Example:
<?php
$name = “ ABC “;
Echo “Hello, “ .trim($name) . “!”; // Output: ABC
?>
In HTML, whitespace between HTML tags doesn’t affect the rendering of the page. However,
excessive whitespace can make your HTML code less readable. It’s a good practice to format your
HTML code for readability but ensure it’s not excessive to keep your files as small as possible for
faster loading times.

Commenting in PHP :
Single-line comments:
1. Single-line comments are generally used for short explanations or notes relevant to the local
code.
2. There are two syntaxes for single-line comments in PHP:
 Using #:
<?
# This is a comment, and
# This is the second line of the comment
// This is a comment too. Each style comments only
print "An example with single line comments";
?>
Multi-line comments:
1. Multi-line comments are generally used to provide pseudocode algorithms and more detailed
explanations when necessary.
2. The syntax for multi-line comments in PHP is the same as in C.

Page 5 of 34 PHP NOTES / DEPT.OF COMPUTER APPLICATION

 Here's an example:
<?
/* This is a comment with multiline
Author: Mohammad Mohtashim
Purpose: Multiline Comments Demo
Subject: PHP
*/
print "An example with multi line comments";

Variables
 Variables are used to store some values or data that can be used later in a program.
 The variables are also like containers that store character values, numeric values, memory
addresses, and strings.

Rules for PHP variables

 A variable starts with the $ sign, followed by the name of the variable.
 A variable name must start with a letter or the underscore character.
 A variable name cannot start with a number.
 A variable name can only contain alpha-numeric characters and underscores. (A-z, 0-9, and _
)
 Variable names are case-sensitive. ($age and $AGE are two different variables)

Creating (Declaring) PHP Variables

 In PHP, a variable starts with the $ sign, followed by the name of the variable:
 Example: $x = 15;
$y = “John”;
 In the example above, the variable $x will hold the value 5, and the variable $y will hold the
value "John".
 Note: When you assign a text value to a variable, put quotes around the value. Unlike other
programming languages, PHP has no command for declaring a variable. It is created the
moment you first assign a value to it.
Constant
 Constants are name or identifier that can't be changed during the execution of the script.
 PHP constants can be defined by 2 ways:
Using define() function
Using const keyword
PHP constant: define()
Page 6 of 34 PHP NOTES / DEPT.OF COMPUTER APPLICATION
  Use the define() function to create a constant.
 It defines constant at run time.
Syntax
define(name, value, case-insensitive)
where as,
name: It specifies the constant name.
value: It specifies the constant value.
case-insensitive: Specifies whether a constant is case-insensitive.
Default value is false. It means it is case sensitive by
default.
Example
<?php
define("MESSAGE", "Hello World“, true);
echo message;
?>
Output: Hello World
<?php
define("MESSAGE", "Hello World“, false);
echo message;
?>
Output: message

const Keyword
 PHP introduced a keyword const to create a constant.
 The const keyword defines constants at compile time.
 The constant defined using const keyword are case-sensitive.
Example
<?php
const MESSAGE="Hello World";
echo MESSAGE;

Page 7 of 34 PHP NOTES / DEPT.OF COMPUTER APPLICATION

 ?>
Output: Hello World
Constant Array
You can create an Array constant using the define() function.
Example: <?php
define(“colors", [“Red", “Green", “Blue"]);
echo colors[0];
?>
Output: Red
Keyword
 In PHP, keywords are words that have special meanings in the language and are reserved for
specific purposes.
 These words cannot be used as identifiers (such as variable names, function names, or class
names) in your PHP code, because they are already reserved for built-in functionality.
Examples: echo, if, else, foreach, class etc…
PHP Data Types
PHP supports the following data types:

 String

 Integer

 Float (floating point numbers - also called double)

 Boolean

 Array
 Object

 NULL

 Resources
Getting the Data Type
You can get the data type of any object by using the var_dump() function. The var_dump()
function returns the data type and the value.
Example:
$x = 5;

Page 8 of 34 PHP NOTES / DEPT.OF COMPUTER APPLICATION

 var_dump($x);
String
 A string is a sequence of characters and it is enclosed within a quotes.
 You can use single or double quotes.
Example:
$x = "Hello world!";
$y = 'Hello world!';
var_dump($x);
echo "<br>";
var_dump($y);

Integers
 They are whole numbers, without a decimal point, like 4195.
 They are the simplest type .they correspond to simple whole numbers, both positive and
negative.
 Integers can be assigned to variables, or they can be used in expressions, like so:
$int_var = 12345;
$another_int = -12345 + 12345;
Integer can be in decimal (base 10), octal (base 8), and hexadecimal (base 16) format. Decimal
format is the default, octal integers are specified with a leading 0, and hexadecimals have a leading
0x.
For most common platforms, the largest integer is (2**31 . 1) (or 2,147,483,647), and the smallest
(most negative) integer is . (2**31 . 1) (or .2,147,483,647).

Float
A float (floating point number) is a number with a decimal point.
Example: $x = 10.365;
var_dump($x);
Boolean
A Boolean represents two possible states: TRUE or FALSE.
Example: $x = true;
var_dump($x);
Array
An array stores multiple values in one single variable.
Example: $colors= array(“Red",“Blue",“Yellow");
var_dump($colors);

Page 9 of 34 PHP NOTES / DEPT.OF COMPUTER APPLICATION

Object
 Classes and objects are the two main aspects of object-oriented programming.
 A class is a template for objects, and an object is an instance of a class.

NULL
 Null is a special data type which can have only one value: NULL.
 A variable of data type NULL is a variable that has no value assigned to it.
Note: If a variable is created without a value, it is automatically assigned a value of NULL.
Example: $x = "Hello world!";
$x = null;
var_dump($x);
Resources
Resources are special variables that hold references to resources external to PHP (such as
database connections).

Change Data Type

 If you assign an integer value to a variable, the type will automatically be an integer.
 If you assign a string to the same variable, the type will change to a string.
Example: $x = 5;
var_dump($x);
$x = "Hello";
var_dump($x);

Operators in PHP
PHP Operator is a symbol i.e used to perform operations on operands. In simple words, operators
are used to perform operations on variables or values.
For example:
1. $num=10+20;//+ is the operator and 10,20 are operands

In the above example, + is the binary + operator, 10 and 20 are operands and $num is variable. PHP
Operators can be categorized in following forms:
o Arithmetic Operators
o Assignment Operators
o Bitwise Operators
o Comparison Operators
o Logical Operators
o String Operators
o Array Operators
o Type Operators
o Execution Operators

Page 10 of 34 PHP NOTES / DEPT.OF COMPUTER APPLICATION

 o Error Control Operators
We can also categorize operators on behalf of operands. They can be categorized in 3 forms:
o Unary Operators: works on single operands such as ++, -- etc.
o Binary Operators: works on two operands such as binary +, -, *, / etc.
o Ternary Operators: works on three operands such as "?:".

1. Arithmetic Operators
The PHP arithmetic operators are used to perform common arithmetic operations such as
addition, subtraction, etc. with numeric values.

2. Assignment Operators
The assignment operators are used to assign value to different variables. The basic
assignment operator is "=".

3. Bitwise Operators
The bitwise operators are used to perform bit-level operations on operands. These operators
allow the evaluation and manipulation of specific bits within the integer.

Page 11 of 34 PHP NOTES / DEPT.OF COMPUTER APPLICATION

 4. Comparison Operators
Comparison operators allow comparing two values, such as number or string. Below the list
of comparison operators are given:

5. Logical Operators
The logical operators are used to perform bit-level operations on operands. These operators
allow the evaluation and manipulation of specific bits within the integer.

Page 12 of 34 PHP NOTES / DEPT.OF COMPUTER APPLICATION

 6. String Operators
The string operators are used to perform the operation on strings. There are two string
operators in PHP, which are given below:

7. Array Operators
The array operators are used in case of array. Basically, these operators are used to compare
the values of arrays.

8. Execution Operators
PHP has an execution operator backticks (``). PHP executes the content of backticks as a
shell command. Execution operator and shell_exec() give the same result.

Page 13 of 34 PHP NOTES / DEPT.OF COMPUTER APPLICATION

 9. Error Control Operators
PHP has one error control operator, i.e., at (@) symbol. Whenever it is used with an
expression, any error message will be ignored that might be generated by that expression.

Expressions in PHP:
Almost everything in a PHP script is an expression. Anything that has a value is an expression. In a
typical assignment statement ($x=100), a literal value, a function or operands processed by
operators is an expression, anything that appears to the right of assignment operator (=)

Example:
$x=100; //100 is an expression
$a=$b+$c; //b+$c is an expression
$c=add($a,$b); //add($a,$b) is an expresson
$val=sqrt(100); //sqrt(100) is an expression

UNIT -2

Conditional Statements
Conditional statements are used to perform different actions based on different
conditions.
Very often when you write code, you want to perform different actions for different decisions.
You can use conditional statements in your code to do this.
In PHP we have the following conditional statements:
• if statement - use this statement to execute some code only if a specified condition is true
• if...else statement - use this statement to execute some code if a condition is true and
another code if the condition is false
• if...elseif....else statement - use this statement to select one of several blocks of code to be
executed
Page 14 of 34 PHP NOTES / DEPT.OF COMPUTER APPLICATION
• switch statement - use this statement to select one of many blocks of code to be executed

The if Statement
Use the if statement to execute some code only if a specified condition is true.
Syntax:
if (condition) code to be executed if condition is true;
The following example will output "Have a nice weekend!" if the current day is Friday:
<?php
$d=date("D");
if ($d=="Fri") echo "Have a nice weekend!";
?>
Notice that there is no ..else.. in this syntax. You tell the browser to execute some code only if the
specified condition is true.

The if...else Statement

Use the if....else statement to execute some code if a condition is true and another code if a
condition is
false.
Syntax
if (condition)
code to be executed if condition is true;
else
code to be executed if condition is false;

Example
The following example will output "Have a nice weekend!" if the current day is Friday, otherwise it
will
output "Have a nice day!":
<?php
$d=date("D");
if ($d=="Fri")

Page 15 of 34 PHP NOTES / DEPT.OF COMPUTER APPLICATION

 echo "Have a nice weekend!";
else
echo "Have a nice day!";
?>

If more than one line should be executed if a condition is true/false, the lines should be enclosed
within curly braces:
<?php
$d=date("D");
if ($ d=="Fri")
{
echo "Hello!<br />";
echo "Have a nice weekend!";
echo "See you on Monday!";
}
?>

The if...else if....else Statement

Use the if....elseif...else statement to select one of several blocks of code to be executed.
Syntax
if (condition)
code to be executed if condition is true;
else if (condition)
code to be executed if condition is true;
else
code to be executed if condition is false;

Example
The following example will output "Have a nice weekend!" if the current day is Friday, and "Have a
nice Sunday!" if the current day is Sunday. Otherwise it will output "Have a nice day!":

Page 16 of 34 PHP NOTES / DEPT.OF COMPUTER APPLICATION

<?php
$d=date("D");
if ($d=="Fri")
echo "Have a nice weekend!";
elseif ($d=="Sun")
echo "Have a nice Sunday!";
else
echo "Have a nice day!";
?>

The PHP Switch Statement

Use the switch statement to select one of many blocks of code to be executed.
Syntax
switch (n)
{
case label1:
code to be executed if n=label1;
break;
case label2:
code to be executed if n=label2;
break;
default:
code to be executed if n is different from both label1 and label2;
}
This is how it works: First we have a single expression n (most often a variable), that is evaluated
once.The value of the expression is then compared with the values for each case in the structure. If
there is a match, the block of code associated with that case is executed. Use break to prevent the
code from running into the next case automatically. The default statement is used if no match is
found.
Example
<?php
switch ($x)

Page 17 of 34 PHP NOTES / DEPT.OF COMPUTER APPLICATION

{
case 1:
echo "Number 1";
break;
case 2:
echo "Number 2";
break;
case 3:
echo "Number 3";
break;
default:
echo "No number between 1 and 3";
}
?>

The ? operator:
In PHP, the ? operator is called the ternary operator. It's a shorthand way to write an if-else
statement in a single line.
Syntax:
$variable = (condition) ?value_if_true :value_if_false;
Here's how it works:
If the condition evaluates to true, the value before the colon (:) is assigned to the variable.
If the condition evaluates to false, the value after the colon (:) is assigned to the variable.
For example:
$age = 20;
$message = ($age >= 18) ? "You are an adult" : "You are not an adult";
echo $message; // Outputs: "You are an adult"
It's a concise way to write conditional assignments.

PHP Looping :
Loops execute a block of code a specified number of times, or while a specified condition

Page 18 of 34 PHP NOTES / DEPT.OF COMPUTER APPLICATION

is true.
Often when you write code, you want the same block of code to run over and over again in a
row.Instead of adding several almost equal lines in a script we can use loops to perform a task like
this.In PHP, we have the following looping statements:
• while - loops through a block of code while a specified condition is true
• do...while - loops through a block of code once, and then repeats the loop as long as a
specified condition is true
• for - loops through a block of code a specified number of times
• for each - loops through a block of code for each element in an array

The while Loop

The while loop executes a block of code while a condition is true.
Syntax
while (condition)
{
code to be executed;
}

Example
The example below defines a loop that starts with i=1. The loop will continue to run as long as i is
less than, or equal to 5. i will increase by 1 each time the loop runs:
<?php
$i=1;
while($i<=5)
{
echo "The number is " . $i . "<br />";
$i++;
}
?>

Output:

Page 19 of 34 PHP NOTES / DEPT.OF COMPUTER APPLICATION

The number is 1
The number is 2
The number is 3
The number is 4
The number is 5

The do...while Statement

The do...while statement will always execute the block of code once, it will then check the
condition, and repeat the loop while the condition is true.
Syntax
do
{
code to be executed;
}
while (condition);
Example
The example below defines a loop that starts with i=1. It will then increment i with 1, and write
some output. Then the condition is checked, and the loop will continue to run as long as i is less
than, or equal to 5:
<?php
$i=1;
do
{
$i++;
echo "The number is " . $i . "<br />";
}
while ($i<=5);
?>
Output:
The number is 2
The number is 3

Page 20 of 34 PHP NOTES / DEPT.OF COMPUTER APPLICATION

The number is 4
The number is 5
The number is 6

For Loop
Loops execute a block of code a specified number of times, or while a specified condition
is true.
for Loop
The for loop is used when you know in advance how many times the script should run.
Syntax
for (init; condition; increment)
{
code to be executed;
}
Parameters:
• init: Mostly used to set a counter (but can be any code to be executed once at the beginning of the
loop)
• condition: Evaluated for each loop iteration. If it evaluates to TRUE, the loop continues. If it
evaluates to FALSE, the loop ends.
• increment: Mostly used to increment a counter (but can be any code to be executed at the end of
the loop)
Note: Each of the parameters above can be empty, or have multiple expressions (separated by
commas).
Example
The example below defines a loop that starts with i=1. The loop will continue to run as long as i is
less than, or equal to 5. i will increase by 1 each time the loop runs:
<?php
for ($i=1; $i<=5; $i++)
{
echo "The number is " . $i . "<br />";
}
?>

Page 21 of 34 PHP NOTES / DEPT.OF COMPUTER APPLICATION

Output:
The number is 1
The number is 2
The number is 3
The number is 4
The number is 5

foreach Loop
The foreach loop is used to loop through arrays.
Syntax
foreach ($array as $value)
{
code to be executed;
}
For every loop iteration, the value of the current array element is assigned to $value (and the array
pointer is moved by one) - so on the next loop iteration, you'll be looking at the next array value.
Example
The following example demonstrates a loop that will print the values of the given array:
<?php
$x=array("one","two","three");
foreach ($x as $value)
{
echo $value . "<br />";
}
?>

Output:
one
two
three

Page 22 of 34 PHP NOTES / DEPT.OF COMPUTER APPLICATION

PHP Arrays
An array stores multiple values in one single variable.
What is an Array?
A variable is a storage area holding a number or text. The problem is, a variable will hold only one
value.An array is a special variable, which can store multiple values in one single variable.If you
have a list of items (a list of car names, for example), storing the cars in single variables could look
like this:
$cars1="Saab";
$cars2="Volvo";
$cars3="BMW";

Creating an array:
In PHP, you can create an array using the array() function or by using square brackets [] since PHP
5.4. Here are examples of both methods:
Using the array() function:
$array1 = array(1, 2, 3, 4, 5); // Numeric array
$array2 = array("apple", "banana", "orange"); // Associative array
$array3 = array("a" => 1, "b" => 2, "c" => 3); // Associative array with keys

Using square brackets []:

$array4 = [1, 2, 3, 4, 5]; // Numeric array
$array5 = ["apple", "banana", "orange"]; // Associative array
$array6 = ["a" => 1, "b" => 2, "c" => 3]; // Associative array with keys
In PHP, arrays can hold any type of data, including other arrays, objects, and even a combination of
different types of data.

Accessing array elements:

In PHP, you can access array elements using square brackets [] with the index of the element you
want to access. Array indexing starts at 0 for the first element. Here are examples:
$array = array("apple", "banana", "orange", "grape");
echo $array[0]; // Outputs: apple
echo $array[1]; // Outputs: banana

Page 23 of 34 PHP NOTES / DEPT.OF COMPUTER APPLICATION

 echo $array[2]; // Outputs: orange
echo $array[3]; // Outputs: grape

You can also access elements in associative arrays using keys:

$assocArray = array("a" => "apple", "b" => "banana", "c" => "orange");
echo $assocArray["a"]; // Outputs: apple
echo $assocArray["b"]; // Outputs: banana
echo $assocArray["c"]; // Outputs: orange
If you try to access an element that does not exist, PHP will generate a notice or warning, depending
on your error reporting settings. To avoid such notices, you can use isset() to check if the element
exists before accessing it:
if (isset($array[4]))
{
echo $array[4];
}
Else
{
echo "Element does not exist.";
}

This prevents PHP from throwing a notice if the element doesn't exist.

Types of arrays:
In PHP, there are three kind of arrays:
• Numeric/indexed array - An array with a numeric index
• Associative array - An array where each ID key is associated with a value
• Multidimensional array - An array containing one or more arrays

Numeric/indexed Arrays:
A numeric array stores each array element with a numeric index.
There are two methods to create a numeric array.

Page 24 of 34 PHP NOTES / DEPT.OF COMPUTER APPLICATION

1. In the following example the index are automatically assigned (the index starts at 0):
$cars=array("Saab","Volvo","BMW","Toyota");
2. In the following example we assign the index manually:
$cars[0]="Saab";
$cars[1]="Volvo";
$cars[2]="BMW";
$cars[3]="Toyota";

Example
In the following example you access the variable values by referring to the array name and index:
<?php
$cars[0]="Saab";
$cars[1]="Volvo";
$cars[2]="BMW";
$cars[3]="Toyota";
echo $cars[0] . " and " . $cars[1] . " are Swedish cars.";
?>
The code above will output:
Saab and Volvo are Swedish cars.

Associative Arrays
An associative array, each ID key is associated with a value.
When storing data about specific named values, a numerical array is not always the best way to do
it.
With associative arrays we can use the values as keys and assign values to them.
Example 1
In this example we use an array to assign ages to the different persons:
$ages = array("Peter"=>32, "Quagmire"=>30, "Joe"=>34);
Example 2
This example is the same as example 1, but shows a different way of creating the array:
$ages['Peter'] = "32";

Page 25 of 34 PHP NOTES / DEPT.OF COMPUTER APPLICATION

 $ages['Quagmire'] = "30";
$ages['Joe'] = "34";

The ID keys can be used in a script:

<?php
$ages['Peter'] = "32";
$ages['Quagmire'] = "30";
$ages['Joe'] = "34";
echo "Peter is " . $ages['Peter'] . " years old.";
?>
The code above will output:
Peter is 32 years old.

Multidimensional Arrays
In a multidimensional array, each element in the main array can also be an array. And each element
in the sub-array can be an array, and so on.
Example
In this example we create a multidimensional array, with automatically assigned ID keys:
$families = array
(
"Griffin"=>array
(
"Peter",
"Lois",
"Megan"
),
"Quagmire"=>array
(
"Glenn"
),
"Brown"=>array

Page 26 of 34 PHP NOTES / DEPT.OF COMPUTER APPLICATION

(
"Cleveland",
"Loretta",
"Junior"
)
);

The array above would look like this if written to the output:
Array
(
[Griffin] => Array
(
[0] => Peter
[1] => Lois
[2] => Megan
)
[Quagmire] => Array
(
[0] => Glenn
)
[Brown] => Array
(
[0] => Cleveland
[1] => Loretta
[2] => Junior
)
)
Example 2
Displaying a single value from the array above:
echo "Is " . $families['Griffin'][2] .

Page 27 of 34 PHP NOTES / DEPT.OF COMPUTER APPLICATION

 " a part of the Griffin family?";
The code above will output:
Is Megan a part of the Griffin family?

Manipulating arrays:
In PHP, you can manipulate arrays in various ways. Here are some common operations you can
perform:
 Creating an Array: You can create an array in PHP using square brackets [] or the array()
function.
$array = [1, 2, 3, 4, 5]; // Using square brackets
$array = array(1, 2, 3, 4, 5); // Using array() function
 Adding Elements to an Array: You can add elements to an array using square bracket
notation or by using the array_push() function.
$array[] = 6; // Adding element using square bracket notation
array_push($array, 7); // Using array_push() function
 Removing Elements from an Array: You can remove elements from an array using the
unset() function or by using array functions like array_pop(), array_shift(), or array_splice().
unset($array[0]); // Removing element by index
array_pop($array); // Removing the last element
array_shift($array); // Removing the first element
array_splice($array, 2, 1); // Removing elements from a specific index
 Accessing Array Elements: You can access array elements by their index.
echo $array[0]; // Accessing the first element
 Iterating Through an Array: You can iterate through arrays using loops like foreach, for,
while, etc.
foreach ($array as $value) {
echo $value . ' ';
}
 Merging Arrays: You can merge arrays using the array_merge() function.
$mergedArray = array_merge($array1, $array2);
 Sorting Arrays: You can sort arrays using functions like sort(), rsort(), asort(), arsort(),
ksort(), krsort(), etc.

Page 28 of 34 PHP NOTES / DEPT.OF COMPUTER APPLICATION

In PHP, you can sort arrays using various functions depending on your requirements. Here are some
commonly used functions for sorting arrays:
 sort(): Sorts an array in ascending order. The keys are not preserved.
$array = [3, 1, 4, 1, 5, 9, 2, 6];
sort($array);
print_r($array); // Output: [1, 1, 2, 3, 4, 5, 6, 9]
 rsort(): Sorts an array in descending order. The keys are not preserved.The rsort() function
sorts an indexed array in descending order.
$array = [3, 1, 4, 1, 5, 9, 2, 6];
rsort($array);
print_r($array); // Output: [9, 6, 5, 4, 3, 2, 1, 1]
 asort(): Sorts an array in ascending order, preserving the keys.The asort() function sorts an
associative array in ascending order, according to the value.
$array = ['b' => 3, 'a' => 1, 'c' => 2];
asort($array);
print_r($array); // Output: ['a' => 1, 'c' => 2, 'b' => 3]
 arsort(): Sorts an array in descending order, preserving the keys.The arsort() function sorts
an associative array in descending order, according to the value
$array = ['b' => 3, 'a' => 1, 'c' => 2];
arsort($array);
print_r($array); // Output: ['b' => 3, 'c' => 2, 'a' => 1]
 ksort(): Sorts an array by keys in ascending order.The ksort() function sorts an associative
array in ascending order, according to the key.
$array = ['b' => 3, 'a' => 1, 'c' => 2];
ksort($array);
print_r($array); // Output: ['a' => 1, 'b' => 3, 'c' => 2]
 krsort(): Sorts an array by keys in descending order. The ksort() function sorts an
associative array in ascending order, according to the key.
$array = ['b' => 3, 'a' => 1, 'c' => 2];
krsort($array);
print_r($array); // Output: ['c' => 2, 'b' => 3, 'a' => 1]
These functions allow you to sort arrays based on different criteria while preserving or reordering
keys as needed.
Page 29 of 34 PHP NOTES / DEPT.OF COMPUTER APPLICATION
Displaying arrays:
In PHP, you can display the contents of an array using various methods, depending on how you
want to present the data. Here are a few common ways to display arrays:

 Using print_r(): The print_r() function is commonly used to display the contents of an array
in a human-readable format.
$array = [1, 2, 3, 4, 5];
print_r($array);
Output:
Array
(
[0] => 1
[1] => 2
[2] => 3
[3] => 4
[4] => 5
)
 Using var_dump(): The var_dump() function provides more detailed information about the
array, including data types and lengths.
$array = [1, 2, 3, 4, 5];
var_dump($array);
Output:
array(5) {
[0]=>int(1)
[1]=>int(2)
[2]=>int(3)
[3]=>int(4)
[4]=>int(5)
}
 Using foreach Loop: You can iterate through the array using a foreach loop and display each
element individually.

Page 30 of 34 PHP NOTES / DEPT.OF COMPUTER APPLICATION

 $array = [1, 2, 3, 4, 5];
foreach ($array as $value) {
echo $value . ' ';
}
Output:
12345
 Using implode(): You can use the implode() function to join array elements into a string and
then display the string.
$array = [1, 2, 3, 4, 5];
echo implode(', ', $array);
Output:
1, 2, 3, 4, 5
These methods offer flexibility in how you display array data, depending on your specific
requirements and the context in which you are working.

Using array functions

PHP provides a variety of array functions that you can use to manipulate arrays efficiently. Here are
some commonly used array functions in PHP:
 array(): Creates an array.
$array = array('foo', 'bar', 'baz');
 count(): Returns the number of elements in an array.
$count = count($array);
 array_push(): Pushes one or more elements onto the end of an array.
array_push($array, 'qux');
 array_pop(): Pops the element off the end of array.
$lastElement = array_pop($array);
 array_shift(): Shifts the first value of the array off and returns it.
$firstElement = array_shift($array);
 array_unshift(): Prepend one or more elements to the beginning of an array.
array_unshift($array, 'quux');
 array_merge(): Merge one or more arrays.

Page 31 of 34 PHP NOTES / DEPT.OF COMPUTER APPLICATION

 $mergedArray = array_merge($array1, $array2);
 array_slice(): Extract a slice of the array.
$slice = array_slice($array, 2, 2);
 array_splice(): Remove a portion of the array and replace it with something else.
array_splice($array, 2, 1, 'replacement');
 array_search(): Searches the array for a given value and returns the corresponding key if
successful.
$key = array_search('bar', $array);
Including and requiring files-use of include() and require()
PHP code can get cluttered, which means that if you want to later change something, it becomes a
hard task to do. Include and require statements are two almost identical statements that help in an
important aspect of coding, the organization of code, and making it more readable and flexible. The
include/require statement copies all text, code or any other markup from one existing file to the file
using the statement. In a simple viewpoint, do consider these statements like this:
The include and require statements are the same, except upon failure of code execution where:
• require will produce a fatal error (E_COMPILE_ERROR) and stop the script from executing
• include will only produce a warning (E_WARNING) and the script will continue
The syntax of these two statements is as follows:
<?php
include ’file.php’; // in case of include
require ’file.php’; // in case of require
?>
Let’s now see a real-world example where we use a header and footer using include and require into
our main file:
header.php
<header>
<nav>
<ul>
<li><a href="#">Home</a></li>
<li><a href="#">Profile</a></li>
<li><a href="#">About</a></li>
<li><a href="#">Contact</a></li>

Page 32 of 34 PHP NOTES / DEPT.OF COMPUTER APPLICATION

 </ul>
</nav>
</header>
// styling to make the menu look right
<style type="text/css">
ul, li {
list-style-type: none;
display: inline-block;
margin-right: 1em;
padding: 0;
}
</style>

footer.php
<footer>All Rights Reserved. Do not reproduce this page.</footer>
In our main file, we’ll use require for the header.php and include for the footer.php file:
index.php
<?php require ’header.php’; ?>
<body>
<h2>Main Content Goes Here</h2>
</body>
<?php include ’footer.php’ ?>

Implicit and Explicit Casting

In PHP, implicit and explicit casting refer to the conversion of data from one data type to another.
Implicit Casting: Implicit casting, also known as automatic type conversion, occurs when PHP
automatically converts data from one type to another without any explicit instructions from the
programmer. This typically happens when performing operations between different data types.
For example:
$num = 10; // integer
$str = "5"; // string

Page 33 of 34 PHP NOTES / DEPT.OF COMPUTER APPLICATION

$result = $num + $str; // Implicitly casts "5" to integer and adds it to $num
echo $result; // Output: 15
In the above example, the string "5" is implicitly cast to an integer when adding it to the integer
variable $num.

Explicit Casting: Explicit casting, also known as manual type conversion, occurs when the
programmer explicitly instructs PHP to convert data from one type to another using casting
functions or type-casting syntax.
For example:
$str = "10"; // string
$num = (int)$str; // Explicitly cast $str to an integer
echo $num; // Output: 10

Here, (int) is used to explicitly cast the string $str to an integer. Similarly, you can use (float),
(string), (array), (object), and (bool) for explicit casting to float, string, array, object, and boolean
respectively.

Page 34 of 34 PHP NOTES / DEPT.OF COMPUTER APPLICATION

PHP Functions
The real power of PHP comes from its functions.In PHP, there are more than
700 built-in functions.
A function will be executed by a call to the function.
You may call a function from anywhere within a page.

Function definition:
In PHP, you can define functions using the function keyword. Here's the basic
syntax for defining a function:

function functionName($parameter1, $parameter2, /* ... */)

{
// Function body
// Code to be executed when the function is called
// You can use $parameter1, $parameter2, and other parameters here
// Optionally, you can return a value using the return statement
eturn $someValue;
}

Let's break down the components:

• function: The keyword used to declare a function.

• functionName: The name of your function. Choose a meaningful and
descriptive name.
• $parameter1, $parameter2, etc.: Parameters are variables that you can
pass to the function. They act as placeholders for values that will be
provided when the function is called.
• { /* ... */ }: The function body contains the code that will be executed
when the function is called. It can include any valid PHP code.
• return $someValue;: The return statement is used to send a value back to
the calling code. If your function doesn't need to return a value, you can
omit this part.

Here's an example of a simple function:

function addNumbers($num1, $num2) {

$sum = $num1 + $num2; return $sum;
}
$result = addNumbers(3, 4);
 echo $result;
// Output: 7

In this example, the addNumbers function takes two parameters, adds them
together, and returns the result. The function is then called with the arguments 3
and 4, and the result is echoed to the screen.

Remember that function names in PHP are not case-sensitive, but it's a good
practice to follow a consistent naming convention for functions.

Creating a PHP Function:

A function will be executed by a call to the function.
Syntax
function functionName()
{
code to be executed;
}
• Give the function a name that reflects what the function does
• The function name can start with a letter or underscore (not a number)
Example
A simple function that writes my name when it is called:
<html>
<body>
<?php
function writeName()
{
echo "Kai Jim Refsnes";
}
echo "My name is ";
writeName();
?>
</body>
</html>

Output:
My name is Kai Jim Refsnes

Invoking user-defined functions:

To invoke (call) a user-defined function in PHP, you simply use its name
followed by parentheses (). If the function has parameters, you provide the
actual values or variables inside the parentheses. Here's an example:

<?php

// Define a function
function addNumbers($num1, $num2) {
$sum = $num1 + $num2;
return $sum;
}

// Invoke the function

$result = addNumbers(3, 4);

// Output the result

echo $result; // Output: 7

?>
In this example, the addNumbers function is defined to take two parameters
$num1 and $num2. When you invoke the function with addNumbers(3, 4), it
adds 3 and 4 together, and the result (7) is stored in the variable $result. Finally,
the result is echoed to the screen.

You can also call a function without any parameters if the function doesn't
require them:

<?php

// Define a function without parameters

function sayHello() {
echo "Hello, World!";
}

// Invoke the function

sayHello(); // Output: Hello, World!

?>
In this example, the sayHello function does not have any parameters, so you can
call it without providing any values inside the parentheses.

Remember that functions in PHP must be defined before they are called. If you
try to invoke a function that hasn't been defined yet, PHP will throw an error.

Formal parameters versus Actual parameters:

In PHP (as well as in many other programming languages), there is a distinction
between formal parameters and actual parameters (also known as formal
arguments and actual arguments) when discussing functions or methods.
Formal Parameters:

Formal parameters are the variables declared in the function or method

signature. They act as placeholders for the values that will be passed into the
function when it is called.
These parameters are part of the function definition and are used within the
function body as variables representing the values passed during the function
invocation.
Formal parameters are what you see in the function declaration.
Example:
function addNumbers($num1, $num2) {
$sum = $num1 + $num2;
return $sum;
}
In the function addNumbers, $num1 and $num2 are formal parameters.

Actual Parameters:

Actual parameters, on the other hand, are the values or expressions that are
passed to a function or method during its invocation.
These are the concrete values that are used in place of the formal parameters
when calling the function.
Actual parameters are provided when calling the function.
Example:

$result = addNumbers(3, 4);

In this example, 3 and 4 are actual parameters. They are the values passed to the
addNumbers function when it is called.
So, in summary, formal parameters are the variables declared in the function
definition, and actual parameters are the values passed to the function when it is
called. The actual parameters are used to fill the roles of the formal parameters
within the function body.
Formal parameters Actual parameters
Formal parameter is the parameter Actual parameter is the argument
defined in the function header. passed to the function during the
function call.
Syntax: Syntax:
// function header // function call statement
type func name (type paraml, type func func_na name (paraml, param2,
param2,...) { // function body ...);
}
Example: Example:
int sum(int a, int b) sum(x, y);
{
return a+b; Here, x and y are the actual
} parameters passed to the sum function
Here, param1 and param2 are the and gets mapped to the formal
formal parameters of sum function. parameters paraml and param2
respectively.
The formal parameters are locally The actual parameters are part of the
available within the particular calling function.
function only. Example: If main method calls a
function sum, then main is the calling
function and sum is the called
method.

Function and variable scope:

In PHP, the scope of a variable or function refers to the context in which it can
be accessed or modified. PHP supports different scopes, including global scope,
local scope, and static scope.

Variable Scope:
1. Global Scope:
Variables declared outside of any function or class have global scope.
They can be accessed from anywhere in the script, including within functions.
Example:$globalVar = 10;

function exampleFunction() {
echo $GLOBALS['globalVar']; // Accessing global variable
}

exampleFunction(); // Output: 10
2. Local Scope:
Variables declared inside a function have local scope.
They are only accessible within that function.
Example:
function exampleFunction() {
$localVar = 5;
echo $localVar;
}

exampleFunction(); // Output: 5

// This will result in an error, as $localVar is not defined outside the function
// echo $localVar;
3. Static Scope:
Variables declared as static inside a function retain their value between function
calls.
They have function scope but persist across multiple invocations.
Example:
function counter() {
static $count = 0;
$count++;
 echo $count;
}

counter(); // Output: 1
counter(); // Output: 2
Function Scope:
4. Global Scope:

Functions declared outside of any other function or class are in the global scope.
They can be called from anywhere in the script.
Example:

function globalFunction() {
echo "This is a global function.";
}

globalFunction(); // Output: This is a global function.

5. Local Scope:
Functions can also be declared within other functions or methods.
The inner function has access to variables in its own scope and the scope of the
outer function.
Example:

function outerFunction() {
$outerVar = "Outer";

function innerFunction() {
global $outerVar;
 echo $outerVar; // Accessing variable from outer function
}

innerFunction();
}
outerFunction(); // Output: Outer
Understanding variable and function scope is crucial for writing maintainable
and bug-free code in PHP. Properly managing scope helps prevent unintended
variable clashes and ensures that functions can access the data they need.

Recursion:
PHP also supports recursive function call like C/C++. In such case, we call
current function within function. It is also known as recursion.

It is recommended to avoid recursive function call over 200 recursion level

because it may smash the stack and may cause the termination of script.
Example 1: Printing number
<?php
function display($number) {
if($number<=5){
echo "$number <br/>";
display($number+1);
}
}
display(1);
?>

Library functions:
Library functions in PHP refer to built-in functions that are provided by the PHP
language and can be used for a variety of tasks. These functions cover a wide
range of functionalities, from string manipulation to array operations, file
handling, and more. Here are some categories of library functions commonly
used in PHP:

1. String Functions:
strlen: Returns the length of a string.
strpos: Finds the position of the first occurrence of a substring in a string.
str_replace: Replaces all occurrences of a search string with a replacement
string.
2. Array Functions:
count: Counts the number of elements in an array.
array_push: Pushes one or more elements onto the end of an array.
array_pop: Pops the element off the end of an array.
3. Math Functions:
abs: Returns the absolute value of a number.
round: Rounds a floating-point number to the nearest integer.
rand: Generates a random number.
4. File Functions:
file_get_contents: Reads entire file into a string.
file_put_contents: Write a string to a file.
fopen, fclose, fwrite: Functions for opening, closing, and writing to files.
5. Database Functions (for database interactions):
mysqli_connect, mysqli_query, mysqli_fetch_assoc: Functions for MySQL
database interactions.
PDO: PHP Data Objects provide a uniform method of access to multiple
databases.
6. Other Common Functions:
isset: Determines if a variable is set and is not NULL.
empty: Checks if a variable is empty.
explode: Splits a string by a specified delimiter into an array.
These are just a few examples, and PHP provides a rich set of functions for
various tasks. You can find the complete list of PHP functions in the official
PHP documentation

Date and time function:

PHP provides a variety of functions for working with date and time. Here are
some commonly used date and time functions in PHP:
• date function:
Returns the current date and time based on the specified format.
$currentDate = date("Y-m-d H:i:s");
echo $currentDate;
• time function:
Returns the current Unix timestamp (number of seconds since the Unix Epoch).
$timestamp = time();
echo $timestamp;
• strtotime function:
Parses an English textual date or time description and returns a Unix timestamp.
$nextWeek = strtotime("+1 week");
echo date("Y-m-d", $nextWeek);
• mktime function:
Returns the Unix timestamp for a date.
$timestamp = mktime(12, 0, 0, 2, 28, 2022);
echo date("Y-m-d H:i:s", $timestamp);
• date_create and date_format functions (DateTime object):
date_create creates a new DateTime object.
date_format formats the DateTime object.
$date = date_create('2022-02-28');
echo date_format($date, 'Y-m-d');
• strftime function:
Formats a local time/date according to locale settings.
setlocale(LC_TIME, 'en_US'); // Set locale to English (United States)
echo strftime("%A, %B %d, %Y %H:%M:%S");
• strtotime with date function for relative dates:
Using strtotime along with date allows you to work with relative dates.
$nextMonth = strtotime("+1 month");
echo date("Y-m-d", $nextMonth);
These are just a few examples of the many date and time functions available in
PHP. The choice of which function to use depends on your specific
requirements and the format in which you need to work with dates and times.

Strings in php:
What is string?
In PHP, a string is a sequence of characters, where a character is a single unit of
information. Strings can contain letters, numbers, symbols, and spaces. PHP
provides various functions and features for working with strings, making it
versatile for tasks like text processing, manipulation, and output.

In PHP, you can define strings using either single quotes (') or double quotes (").
Here are examples of string declarations:
$singleQuotedString = 'This is a string with single quotes.';
$doubleQuotedString = "This is a string with double quotes.";
Both single-quoted and double-quoted strings can contain variables, and
variables will be expanded (interpreted) inside double-quoted strings but not
within single-quoted strings. Here's an example:
$name = "John";
$greeting1 = 'Hello, $name!'; // Output: Hello, $name!
$greeting2 = "Hello, $name!"; // Output: Hello, John!
In the example above, variable interpolation (expanding variables within the
string) only occurs in the double-quoted string.

PHP also provides numerous string functions for tasks such as concatenation,
finding substrings, replacing text, converting case, and more. Here are a few
examples:
$string1 = "Hello";
$string2 = "World";

// Concatenation
$result = $string1 . " " . $string2; // Output: Hello World

// String length
$length = strlen($result); // Output: 11

// Uppercase and lowercase

$upper = strtoupper($result); // Output: HELLO WORLD
$lower = strtolower($result); // Output: hello world
Strings in PHP are versatile and widely used in web development for tasks such
as handling user input, generating HTML content, working with databases, and
more.

Creating a string:
In PHP, you can create strings using either single quotes (') or double quotes (").
Here are examples of both:

• Single-Quoted String:
$singleQuotedString = 'This is a string with single quotes.';
In single-quoted strings, variables are not expanded (interpreted). For example:

$name = "John";
$greeting = 'Hello, $name!'; // Output: Hello, $name!
• Double-Quoted String:
$doubleQuotedString = "This is a string with double quotes.";
Double-quoted strings allow variable interpolation, meaning variables are
expanded inside the string. For example:
$name = "John";
$greeting = "Hello, $name!"; // Output: Hello, John!
• Heredoc and Nowdoc Syntax:
PHP also provides two additional syntaxes for creating strings:
➢ Heredoc Syntax:
Heredoc is useful for creating multiline strings:

$heredocString = <<<EOT
This is a heredoc string.
It can span multiple lines.
Variables, like $name, are expanded.
EOT;
➢ Nowdoc Syntax:
Nowdoc is similar to heredoc but treats the contents as a plain string without
variable expansion:
$nowdocString = <<<'EOT'
This is a nowdoc string.
It can also span multiple lines.
Variables, like $name, are not expanded.
EOT;
Choose the string syntax that suits your needs. Single quotes are often used
when there is no need for variable expansion, while double quotes are used
when variables need to be interpolated. Heredoc and nowdoc are useful for
creating multiline strings in a clean and readable way.

String functions:
PHP provides a variety of built-in string functions that allow you to manipulate
and work with strings. Here are some commonly used string functions in PHP:
• strlen - String Length:
Returns the length of a string.
$string = "Hello, World!";
$length = strlen($string);
echo $length; // Output: 13
• strpos - Find Position of First Occurrence:
Finds the position of the first occurrence of a substring in a string.$string =
"Hello, World!";
$position = strpos($string, "World");
echo $position; // Output: 7
• str_replace - Replace All Occurrences of a String:
Replaces all occurrences of a substring with another substring.
$string = "Hello, World!";
$newString = str_replace("World", "PHP", $string);
echo $newString; // Output: Hello, PHP!
• strtolower and strtoupper - Convert Case:
strtolower converts a string to lowercase.
strtoupper converts a string to uppercase.
$string = "Hello, World!";
$lowercase = strtolower($string);
$uppercase = strtoupper($string);
echo $lowercase; // Output: hello, world!
echo $uppercase; // Output: HELLO, WORLD!
• substr - Substring:
Returns a part of a string starting from a specified position.
$string = "Hello, World!";
$substring = substr($string, 7, 5);
echo $substring; // Output: World
• trim - Remove Whitespace:
Removes whitespace (or other characters) from both ends of a string.
$string = " Hello, World! ";
$trimmedString = trim($string);
echo $trimmedString; // Output: Hello, World!
• explode - Split a String by a Delimiter:
Splits a string into an array of substrings based on a delimiter.
$string = "apple,orange,banana";
$fruits = explode(",", $string);
print_r($fruits); // Output: Array ( [0] => apple [1] => orange [2] => banana )
• implode - Join Array Elements with a String:
Joins array elements with a string to create a single string.
$fruits = array("apple", "orange", "banana");
$string = implode(", ", $fruits);
echo $string; // Output: apple, orange, banana
These are just a few examples of the many string functions available in PHP.
You can find more functions and details in the official PHP documentation
 UNIT - IV

Class &Objects in PHP

Like C++ and Java, PHP also supports object oriented programming.
Classes are the blueprints of objects. Class is a programmer-defined data type, which includes
local methods and local variables. Class is a collection of objects.
Object has properties and behavior.
Define a class
A class is defined by using the class keyword, followed by the name of the class and a
pair of curly braces ({}).
Syntax
<? Php
Class MyClass
{
// Class properties and methods go here
}
?>
Creating an Object
 A class defines an individual instance of the data structure. We define a class once
and then make many objects that belong to it.
 Objects are also known as an instance.
 An object is something that can perform a set of related activities.
Syntax: $obj = new MyClass;

<?Php
Class MyClass
{
// Class properties and methods go here
}
$obj = new MyClass;
var_dump($obj);
?>

Example of class and object:

<?php
class demo
{
private $a= "I am learning PHP";
public function display()
{
echo $this->a;
}

1
}
$obj = new demo();
$obj->display();
?>

The Access Specifier

There are three access specifier in PHP
 Public
 Protected
 Private
Public: Public properties can be accessed by any code, whether that code is inside or outside
the class. If a property is declared public, its value can be read or changed from anywhere in
your script.
Private: Private properties of a class can be accessed only by code inside the class. So if we
create a property that’s declared private, only methods and objects inside the same class can
access its contents.
Protected: Protected class properties are a bit like private properties in that they can’t be
accessed by code outside the class, but there’s one little difference in any class that inherits
from the class i.e. base class can also access the properties.
Class Member Access Access from own Accessible from derived Accessible by
Specifier class class Object
Private Yes No No
Protected Yes Yes No
Public Yes Yes Yes

Example 1: In this example, we will see the Public Access Specifier.

<?php
class Arithmetic
{
public $x = 100 ; # public attributes
public $y = 50 ;
function add()
{
echo $a = $this->x + $this->y ;
echo " ";
}
}
class child extends Arithmetic
{

2
 function sub()
{
echo $s = $this->x - $this->y ;
}

}
$obj = new child;
$obj->add() ; // It will return the addition result
$obj->sub() ; /* It's a derived class of the main class, which has a public object and therefore
can be accessed, returning the subtracted result. */
?>

Example 2: In this example, we will see the Private Access Specifier.

<?php
class Arithmetic
{
private $a = 75 ; # private attributes
private $b = 5 ;
private function div() # private member function
{
echo $d = $this->a / $this->b ;
echo " ";
}
}
class child extends Arithmetic
{
function mul()
{
echo $m = $this->a * $this->b ;
}
}
$obj= new child; /* It's supposed to return the division result but since the data and
function are private they can't be accessed by a derived class which
will lead to fatal error.*/

$obj->div(); /* It's a derived class of the main class, which's accessing the private data
which again will lead to fatal error.*/
$obj->mul();
?>

Example 3: In this example, we will see the Protected Access Specifier.

<?php
class Arithmetic
{
protected $x = 1000 ; # protected attributes
protected $y = 100 ;
function div()
{

3
 echo $d = $this->x / $this->y ;
echo " ";
}
}
class child extends Arithmetic
{
function sub()
{
echo $s = $this->x - $this->y ;
}
}
class derived # Outside Class
{
function mul()
{
echo $m = $this->x * $this->y ;
}
}
$obj= new child; // It will return the division result
$obj->div(); // Since it's a derived class of the main class,
$obj->sub(); // Since it's an outside class, therefore it will produce a fatal error.
$obj->mul();
?>

Object properties and methods

We call properties to the variables inside a class. Properties can accept values like
strings, integers, and boolean (true/false values), like any other variable. Let's add some
properties to the Car class.
Example:
Class Car
{
public $comp;
public $color = 'beige';
public $hasSunRoof = true;
}
 We put the public keyword in front of a class property.
 The naming convention is to start the property name with a lower case letter.
 If the name contains more than one word, all of the words, except for the first word,
start with an upper case letter. For example, $color or $hasSunRoof.
 A property can have a default value. For example, $color = 'beige'.

4
  We can also create a property without a default value. See the property $comp in the
above example.

Overloading
What is function overloading?
Function overloading is the ability to create multiple functions of the same name with
different implementations.
Function overloading in PHP?
Function overloading in PHP is used to dynamically create properties and methods.
Function overloading contains same function name and that function performs different task
according to number of arguments. For example, find the area of certain shapes where radius
are given then it should return area of circle if height and width are given then it should give
area of rectangle and others. In PHP function overloading is done with the help of function
__call(). This function takes function name and arguments.
Property and Rules of overloading in PHP:
 All overloading methods must be defined as Public.
 After creating the object for a class, we can access a set of entities that are properties
or methods not defined within the scope of the class.
 Such entities are said to be overloaded properties or methods, and the process is called
as overloading.
 For working with these overloaded properties or functions, PHP magic methods are
used.
 Most of the magic methods will be triggered in object context except __callStatic()
method which is used in a static context.
Types of Overloading in PHP: There are two types of overloading in PHP.
 Property Overloading
 Method Overloading
Property Overloading:
PHP property overloading is used to create dynamic properties in the object context.
For creating these properties no separate line of code is needed. A property associated with a
class instance, and if it is not declared within the scope of the class, it is considered as
overloaded property. Following operations are performed with overloaded properties in PHP.
 Setting and getting overloaded properties.
 Evaluating overloaded properties setting.

5
  Undo such properties setting.
Before performing the operations, we should define appropriate magic methods. which are,
 __set(): triggered while initializing overloaded properties.
 __get(): triggered while using overloaded properties with PHP print statements.
 __isset(): This magic method is invoked when we check overloaded properties with
isset() function
 __unset(): Similarly, this function will be invoked on using PHP unset() for
overloaded properties.
Example:
<?php
class Toys
{
private $str;
public function __set($name, $value)
{
$this->str[$name] = $value;
}
public function __get($name)
{
echo "Overloaded Property name = " . $this->str[$name] . "<br/>";
}
public function __isset($name)
{
if (isset($this->str[$name]))
{
echo "Property \$$name is set.<br/>";
}
else
{
echo "Property \$$name is not set.<br/>";
}
}
public function __unset($name)
{
unset($this->str[$name]);
echo "\$$name is unset <br/>";
}
}
$objToys = new Toys();
/* setters and getters on dynamic properties */
$objToys->overloaded_property = "new";
echo $objToys->overloaded_property . "\n\n";
/* Operations with dynamic properties values */
isset($objToys->overloaded_property);
unset($objToys->overloaded_property);

6
isset($objToys->overloaded_property);
?>

Method Overloading
It is a type of overloading for creating dynamic methods that are not declared within
the class scope. PHP method overloading also triggers magic methods dedicated to the
appropriate purpose. Unlike property overloading, PHP method overloading allows function
call on both object and static context. The related magic functions are:
 __call() – triggered while invoking overloaded methods in the object context.
 __callStatic() – triggered while invoking overloaded methods in static context.
Example:
<?php
class Toys
{
public function __call($name, $param)
{
echo "Magic method invoked while method overloading with object
reference<br/>";
}
public static function __callStatic($name, $param)
{
echo "Magic method invoked while method overloading with static
access<br/>";
}
}
$objToys = new Toys();
$objToys->overloaded_method();
Toys::overloaded_property();
?>

Constructor
 A constructor allows you to initialize an object's properties upon creation of the
object.
 If you create a construct() function, PHP will automatically call this function when
you create an object from a class.
 Notice that the construct function starts with two underscores ( __ )

Following example will create one constructor for Books class and it will initialize price and
title for the book at the time of object creation.

function __construct( $par1, $par2 ) {

7
 $this->title = $par1;
$this->price = $par2;
}
Now we don't need to call set function separately to set price and title. We can initialize these
two member variables at the time of object creation only. Check following example below –
$physics = new Books( "Physics for High School", 10 );
$maths = new Books ( "Advanced Chemistry", 15 );
$chemistry = new Books ("Algebra", 7 );
Example:
<?Php
class Example
{
public function __construct()
{
echo "Hello javatpoint";
}
}
$obj = new Example();
$obj = new Example();
?>

Example
<?php
class BankAccount
{
private $accountNumber;

private $balance;

function __construct($accountNumber, $balance)

{
$this->accountNumber = $accountNumber;
$this->balance = $balance;
}
}

Types of Constructor
Default Constructor: It has no parameters, but the values to the default constructor can be
passed dynamically.
Parameterized Constructor: It takes the parameters, and also you can pass different values
to the data members.
Copy Constructor: It accepts the address of the other objects as a parameter.

8
Default Constructor

A default constructor is automatically provided by PHP if a class does not explicitly

define a constructor. It doesn't take any parameters and doesn't perform any specific
initialization tasks. When an object of the class is created, this default constructor is called by
default.
Example:
<?php
class Example
{
//defining constructor
function __construct( )
{
$this->sayHello();
echo "This is Constructor in Example Class";
}
function sayHello( )
{
echo "Hello<br>";
}
}
$obj= new Example();
?>

Parameterized Constructor
A parameterized constructor is explicitly defined within a class and accepts
parameters to customize the initialization process. It allows you to pass values during object
creation and use those values to set properties or perform other tasks. This type of constructor
is useful when objects require specific information to function correctly.
Example:
<?php
class Example
{
//defining constructor
function __construct($name)
{
echo "Hello ".$name."<br>";
}
}
$obj1= new Example("World");
$obj2= new Example("Owlbuddy");
?>

9
Copy Constructor
The copy constructor is used to create a duplicate of an already existing object. It accepts the
address of another object as a parameter, allowing for the creation of an identical copy.
Example:
<?php
class Example
{
public $name;
public $age;
//default constructor
public function __construct( )
{

}
// This is a copy constructor
public function copyCon(Example $o)
{
$this->name = $o->name;
$this->age = $o->age;
}
function show( )
{
echo "Name = ".$this->name.'<br>';
echo "Age = ".$this->age.'<br>';
}
}
$obj1 = new Example();
$obj1->name = 'Aman';
$obj1->age = '21';
$obj1->show();
$obj2 = new Example();
//calling copyCon method
$obj2->copyCon($obj1);
$obj2->show();
?>

Destructor
Like a constructor function you can define a destructor function using function
__destruct( ). You can release all the resources with-in a destructor.
Example:
<?php
class demo
{
public function demo( )
{

10
 echo "constructor1...";
}
}
class demo1 extends demo
{
public function __construct( )
{
echo parent::demo();
echo "constructor2...";
}
public function __destruct()
{
echo "destroy.....";
}
}
$obj= new demo1();
?>

Inheritance
Inheritance is a way of extending the existing class functionality in the newly created
class. We can also add functionality to the newly created class apart from extending the base
class functionalities. When we inherit one class, we say an inherited class is a child class
(sub-class), which is called the parent class from which we inherit it. The parent class is also
known as the base class. The idea behind using inheritance is all about the code reusability.
Types of Inheritance in PHP
PHP supports various types of inheritance they are
 Single Inheritance
 Multilevel Inheritance
 Hierarchical Inheritance
Single Inheritance
Single inheritance is a concept in PHP in which only one class can be inherited by a
single class. We need to have two classes in between this process. One is the base (parent)
class, and the other is the child class.

11
Example:

<?php
class MyAccess
{
var $var = "This is first var";
protected $fist_name;
function returnVar()
{
echo $this->fist_name;
}
function set_fist_name($set_this)
{
$this->fist_name = $set_this;
}
}
class child extends MyAccess
{
function setVal($set_this)
{
$this->fist_name = $set_this;
}
function getVal()
{
echo $this->fist_name;
}
}
$obj1 = new child();
$obj1->setVal("Jai Shre");
$obj1->getVal();
?>

Multilevel Inheritance
PHP supports Multilevel Inheritance. In this type of inheritance, we will have more
than 2 classes. A parent class will be inherited by a child class then that child class will be
inherited by the child class.

12
Example:

<?php
class ParentClass
{
var $var = "This is first var";
public $fist_name;
function returnVar()
{
echo $this->fist_name;
}
function set_fist_name($set_this)
{
$this->fist_name = $set_this;
}
}
class child_1 extends ParentClass
{
function setVal($set_this)
{
$this->fist_name = $set_this;
}
function getVal()
{
echo "Extended By Parent Class -". $this->fist_name;
}
}
class child_2 extends child_1
{
function setVal($set_this)
{
$this->fist_name = $set_this;
}
function getVal()
{
echo "Extended By child 1 - ".$this->fist_name;
}
}
$obj1 = new child_1();
$obj1->setVal("This is first inherited class");
$obj1->getVal();
echo "<br/><br/>";
$obj2 = new child_2();
$obj2->setVal("This is second inherited class");
$obj2->getVal();
?>

13
Hierarchical Inheritance
PHP supports Hierarchical inheritance. Hierarchical inheritance is the type of
inheritance in which a program consists of a single parent and more than one child class.
Let’s understand the same with an example.

Example:

<?php
class ParentClass
{
var $var = "This is first var";
public $fist_name;
function returnVar()
{
echo $this->fist_name;
}
function set_fist_name($set_this)
{
$this->fist_name = $set_this;
}
}
class child_1 extends ParentClass
{
function setVal($set_this)
{
$this->fist_name = $set_this;
}
function getVal()
{
echo $this->fist_name;
}
}
class child_2 extends ParentClass
{
function setVal($set_this)
{
$this->fist_name = $set_this." - ".$set_this;;
}

14
 function getVal()
{
echo $this->fist_name;
}
}
$obj1 = new child_1();
$obj1->setVal("This is first child class");
$obj1->getVal();
echo "<br/><br/>";
$obj2 = new child_2();
$obj2->setVal("This is second child class");
$obj2->getVal();
?>

Form Handling
Creating HTML Form
When we develop a website or a web application, we often have to create forms to
take input from users, like a Login form or a Registration form.
Creating a form on the webpage is accomplished using HTML, while PHP serves as a
transport for those values from the webpage to the server and then in further processing those
values.
PHP provides two superglobals $_GET and $_POST for collecting form-data for processing.

Understanding How HTML Form Works

Let's create a simple HTML form and try to understand how it works, what are the
different attributes available in the <form> tag and what are they used for.
<html>
<body>
<form action="form-handler.php" method="POST">
Name: <input type="text" name="name"> <br/>
Email: <input type="text" name="email"> <br/>
<input type="submit">
</form>
</body>
</html>

In the code above, we have used the <form> tag to create an HTML form, with input fields
for Name and Email along with submit button to submit the form-data.
In the <form> tag, we have two attributes, action and method, do you know what they are
for?
action: Using this attribute, we can specify the name of the file which will collect and handle
the form-data. In the example above, we have provided name of a Php file.

15
method: This attribute specify the means of sending the form-data, whether it will be
submitted via POST method or GET method.
Below we have the same form with method as GET
<html>
<body>
<form action="form-handler.php" method="GET">
Name: <input type="text" name="name"> <br/>
Email: <input type="text" name="email"> <br/>
<input type="submit">
</form>
</body>
</html>

PHP Form Handling with POST

If we specify the form method to be POST, then the form-data is sent to the server
using the HTTP POST method. Below, we have the code, to access the form-data in the Php
file specified in the action attribute of our HTML form.
<?php
// getting the value of name field
$name = $_POST["name"];
// getting the value of the email field
$email = $_POST["email"];
echo "Hi, ". $name . "<br>";
echo "Your email address: ". $email ."<br>";
?>

PHP Form Handling with GET

If we specify the form method to be GET, then the form-data is sent to the server
using the HTTP GET method.
Below, we have the code, to access the form-data in the Php file specified in the action
attribute of our HTML form, this time using the GET superglobal.
<?php
// getting the value of name field
$name = $_GET["name"];
// getting the value of the email field
$email = $_GET["email"];
echo "Hi, ". $name . "<br>";
echo "Your email address: ". $email ."<br>";
?>

16
GET vs. POST:
GET and POST are used for the same purpose but they work differently. When a user
submits a form, the values from the input fields are stored in an array, like
array(key1=>value1, key2=>value2,...) and then passed on to the destination(Php file)
specified in the action attribute of the <form> tag.
Using GET method
In case of GET method, form-data is submitted as URL parameters, i.e. all the values
entered in the form fields by the user are sent to the action script, appended in the URL. Let's
take a simple example to understand, below we have a simple HTML form.
<html>
<body>
<form action="form-handler.php" method="GET">
Name: <input type="text" name="name"> <br/>
Age: <input type="text" name="age"> <br/>
<input type="submit">
</form>
</body>
</html>
We have two input fields in above form, one is name and the other one is age. When
we click on submit, we will be redicrected to the following URL, form-
handler.php?name=Studytonight&age=5, with the form-data appended to the URL.
Sending the form-data as URL parameters proves out useful at times as you can easily
bookmark links with form-data, but for appending parameters in a URL there is a limit of
2000 characters, hence for forms with large number of fields, it is not suggested, as some data
might get lost or the form submission may lead to error.
The Php file form-handler.php will look like
<?php
// name attribute of the input field goes inside the
// square brackets of $_GET superglobal
$name = $_GET["name"];
$age = $_GET["age"];
echo "Your name is ". $name . " and you are ". $age . " years old".
?>

As the form-data is visible to everyone because it sent as URL parameters, hence we should
not use GET method for a form with sensitive data, like passwords etc.

17
Using POST method
When we use the POST method, the array of key-value pair(the form-data), coming
from the HTML form are sent as part of the HTTP request, hence they are invisible to the
user. Also, there is no character limit for the information/data being transmitted.
POST method also supports multipart form-data upload which is used for file upload. Its
recommend, that you use the POST method while working on any PHP web
application/project. Let's take a simple example to understand, below we have a simple
HTML form.
<html>
<body>
<form action="form-handler.php" method="POST">
Name: <input type="text" name="name"> <br/>
Age: <input type="text" name="age"> <br/>
<input type="submit">
</form>
</body>
</html>

The Php file form-handler.php will look like,

<?php
// name attribute of the input field goes inside the
// square brackets of $_POST superglobal
$name = $_POST["name"];
$age = $_POST["age"];
echo "Your name is ". $name . " and you are ". $age . " years old".
?>

Database Handling Using PHP with MySQL

MySQL Database Introduction
What is MySQL?
MySQL is an open-source relational database management system (RDBMS). It is the
most popular database system used with PHP. MySQL is developed, distributed, and
supported by Oracle Corporation.
 The data in a MySQL database are stored in tables which consists of columns and
rows.
 MySQL is a database system that runs on a server.
 MySQL is ideal for both small and large applications.
 MySQL is very fast, reliable, and easy to use database system. It uses standard SQL
 MySQL compiles on a number of platforms.

18
Database Terminology
Database
A collection of information organized in such a way that a computer program can
quickly select desired pieces of data.
DBMS (Database Management System)
A collection of programs that enables you to store, modify, and extract information
from a database.
RDBMS (Relational Database Management System)
 A type of DBMS that stores data in the form of related tables.
 Powerful because they require few assumptions about how data is related or how it
will be extracted from the database.
 The same database can be viewed in many different ways.
Table
A collection of data that relates to each other.
Record
A complete set of information. Records are composed of fields, each of which
contains one item of information. It is also called a tuple.
Field
 A space allocated for a particular item of information.
 The smallest units of information you can access.
Data
Distinct pieces of information, usually formatted in a special way.
Metadata
Describes how and when and by whom a particular set of data was collected, and how
the data is formatted.
Attribute
A particular piece of information about a field.

MySQL Data Types

A Data Type specifies a particular type of data, like integer, floating points, Boolean,
etc. It also identifies the possible values for that type, the operations that can be performed on
that type, and the way the values of that type are stored. In MySQL, each database table has
many columns and contains specific data types for each column.

19
We can determine the data type in MySQL with the following characteristics:
 The type of values (fixed or variable) it represents.
 The storage space it takes is based on whether the values are a fixed-length or variable
length.
 Its values can be indexed or not.
 How MySQL performs a comparison of values of a particular data type.
Numeric Data Type
MySQL has all essential SQL numeric data types. These data types can include the
exact numeric data types (For example, integer, decimal, numeric, etc.), as well as the
approximate numeric data types (For example, float, real, and double precision). It also
supports BIT datatype to store bit values. In MySQL, numeric data types are categories into
two types, either signed or unsigned except for bit data type.
Data Type Description
It is a very small integer that can be signed or unsigned. If signed, the
allowable range is from -128 to 127. If unsigned, the allowable range is
TINYINT
from 0 to 255. We can specify a width of up to 4 digits. It takes 1 byte for
storage.
It is a small integer that can be signed or unsigned. If signed, the allowable
range is from -32768 to 32767. If unsigned, the allowable range is from 0
SMALLINT
to 65535. We can specify a width of up to 5 digits. It requires 2 bytes for
storage.
It is a medium-sized integer that can be signed or unsigned. If signed, the
allowable range is from -8388608 to 8388607. If unsigned, the allowable
MEDIUMINT
range is from 0 to 16777215. We can specify a width of up to 9 digits. It
requires 3 bytes for storage.
It is a normal-sized integer that can be signed or unsigned. If signed, the
allowable range is from -2147483648 to 2147483647. If unsigned, the
INT
allowable range is from 0 to 4294967295. We can specify a width of up to
11 digits. It requires 4 bytes for storage.
It is a large integer that can be signed or unsigned. If signed, the allowable
range is from -9223372036854775808 to 9223372036854775807. If
BIGINT
unsigned, the allowable range is from 0 to 18446744073709551615. We
can specify a width of up to 20 digits. It requires 8 bytes for storage.

20
 It is a floating-point number that cannot be unsigned. You can define the
display length (m) and the number of decimals (d). This is not required
FLOAT(m,d) and will default to 10,2, where 2 is the number of decimals, and 10 is the
total number of digits (including decimals). Decimal precision can go to
24 places for a float type. It requires 2 bytes for storage.
It is a double-precision floating-point number that cannot be unsigned.
You can define the display length (m) and the number of decimals (d).
DOUBLE(m,d) This is not required and will default to 16,4, where 4 is the number of
decimals. Decimal precision can go to 53 places for a double. Real is a
synonym for double. It requires 8 bytes for storage.
An unpacked floating-point number that cannot be unsigned. In unpacked
decimals, each decimal corresponds to one byte. Defining the display
DECIMAL(m,d)
length (m) and the number of decimals (d) is required. Numeric is a
synonym for decimal.
It is used for storing bit values into the table column. Here, M determines
BIT(m)
the number of bit per value that has a range of 1 to 64.
It is used only for the true and false condition. It considered numeric value
BOOL
1 as true and 0 as false.
BOOLEAN It is Similar to the BOOL.

Date and Time Data Type

This data type is used to represent temporal values such as date, time, datetime,
timestamp, and year. Each temporal type contains values, including zero. When we insert the
invalid value, MySQL cannot represent it, and then zero value is used. The following table
illustrates all date and time data types that support in MySQL.

21
String Data Types:

The string data type is used to hold plain text and binary data, for example, files,
images, etc. MySQL can perform searching and comparison of string value based on the
pattern matching such as LIKE operator, Regular Expressions, etc. The following table
illustrates all string data types that support in MySQL

22
Binary Large Object Data Types (BLOB)
BLOB in MySQL is a data type that can hold a variable amount of data. They are
categories into four different types based on the maximum length of values can hold.

23
Spatial Data Types
It is a special kind of data type which is used to hold various geometrical and geographical
values. It corresponds to OpenGIS classes. The following table shows all spatial types that
support in MySQL:

24
 UNIT – V
Accessing MySQL
SQL Commands
SELECT - extracts data from a database

UPDATE - updates data in a database

DELETE - deletes data from a database

INSERT INTO - inserts new data into a database

CREATE DATABASE - creates a new database

ALTER DATABASE - modifies a database

CREATE TABLE - creates a new table

ALTER TABLE - modifies a table

DROP TABLE - deletes a table

CREATE INDEX - creates an index (search key)

DROP INDEX - deletes an index

The MySQL CREATE DATABASE Statement

The CREATE DATABASE statement is used to create a new SQL database.
Syntax
CREATE DATABASE databasename;

The MySQL DROP DATABASE Statement

The DROP DATABASE statement is used to drop an existing SQL database.
Syntax
DROP DATABASE databasename;
Note: Be careful before dropping a database. Deleting a database will result in loss of
complete information stored in the database!

The MySQL CREATE TABLE Statement

The CREATE TABLE statement is used to create a new table in a database.
Syntax
CREATE TABLE table_name (
column1 datatype,

25
 column2 datatype,
column3 datatype,
....
);
The column parameters specify the names of the columns of the table. The datatype
parameter specifies the type of data the column can hold (e.g. varchar, integer, date, etc.).

The MySQL DROP TABLE Statement

The DROP TABLE statement is used to drop an existing table in a database.
Syntax
DROP TABLE table_name;

MySQL ALTER TABLE Statement

 The ALTER TABLE statement is used to add, delete, or modify columns in an
existing table.
 The ALTER TABLE statement is also used to add and drop various constraints on an
existing table.

ALTER TABLE - ADD Column

To add a column in a table, use the following syntax:
ALTER TABLE table_name
ADD column_name datatype;

The MySQL SELECT Statement

The SELECT statement is used to select data from a database. The data returned is
stored in a result table, called the result-set.
Syntax
SELECT column1, column2, ...
FROM table_name;
Here, column1, column2, ... are the field names of the table you want to select data from. If
you want to select all the fields available in the table, use the following syntax:
SELECT * FROM table_name;
The MySQL SELECT DISTINCT Statement

26
 The SELECT DISTINCT statement is used to return only distinct (different) values.
Inside a table, a column often contains many duplicate values; and sometimes you only want
to list the different (distinct) values.
Syntax
SELECT DISTINCT column1, column2, ...
FROM table_name;

The MySQL WHERE Clause

The WHERE clause is used to filter records. It is used to extract only those records
that fulfill a specified condition.
Syntax

SELECT column1, column2, ...

FROM table_name

WHERE condition;

Example
SELECT * FROM Customers
WHERE Country = 'Mexico';
The following operators can be used in the WHERE clause:

27
The MySQL AND, OR and NOT Operators
The WHERE clause can be combined with AND, OR, and NOT operators. The AND
and OR operators are used to filter records based on more than one condition
 The AND operator displays a record if all the conditions separated by AND are
TRUE.
 The OR operator displays a record if any of the conditions separated by OR is TRUE.
 The NOT operator displays a record if the condition(s) is NOT TRUE.
AND Syntax
SELECT column1, column2, ...
FROM table_name
WHERE condition1 AND condition2 AND condition3 ...;
OR Syntax
SELECT column1, column2, ...
FROM table_name
WHERE condition1 OR condition2 OR condition3 ...;
NOT Syntax
SELECT column1, column2, ...
FROM table_name
WHERE NOT condition;

The MySQL ORDER BY Keyword

The ORDER BY keyword is used to sort the result-set in ascending or descending
order. The ORDER BY keyword sorts the records in ascending order by default. To sort the
records in descending order, use the DESC keyword.
Syntax
SELECT column1, column2, ...
FROM table_name
ORDER BY column1, column2, ... ASC|DESC;
The MySQL INSERT INTO Statement
The INSERT INTO statement is used to insert new records in a table.
Syntax
It is possible to write the INSERT INTO statement in two ways:
1. Specify both the column names and the values to be inserted:

28
 INSERT INTO table_name (column1, column2, column3, ...)
VALUES (value1, value2, value3, ...);
2. If you are adding values for all the columns of the table, you do not need to specify
the column names in the SQL query. However, make sure the order of the values is in
the same order as the columns in the table. Here, the INSERT INTO syntax would be as
follows:
INSERT INTO table_name
VALUES (value1, value2, value3, ...);

The MySQL UPDATE Statement

The UPDATE statement is used to modify the existing records in a table.

Syntax
UPDATE table_name
SET column1 = value1, column2 = value2, ...
WHERE condition;
Note: Be careful when updating records in a table! Notice the WHERE clause in the
UPDATE statement. The WHERE clause specifies which record(s) that should be updated. If
you omit the WHERE clause, all records in the table will be updated!

The MySQL DELETE Statement

The DELETE statement is used to delete existing records in a table.
Syntax
DELETE FROM table_name WHERE condition;
Note: Be careful when deleting records in a table! Notice the WHERE clause in the DELETE
statement. The WHERE clause specifies which record(s) should be deleted. If you omit the
WHERE clause, all records in the table will be deleted!

Using PHP with MySQL

MySQL Function in PHP

 In PHP Scripting language many functions are available for MySQL Database
connectivity and executing SQL queries.

29
  MySQLi is extension in PHP scripting language which gives access to the MYSQL
database. MySQLi extension was introduced version 5.0.0
 The MySQLi extension contains the following important functions which are related
to MySQL database connectivity and management.
Mysqli_connect() Function
Mysqli_close() Function
Mysqli_query()Function
Database Connections
Before accessing MySQL Database, connect to Database Server machine via PHP
scripting language using Mysqli_connect() Function.
Syntax
mysqli_connect(“Server Name “,”User Name”,”Password”,”DB Name”);
This function requires four parameters to connect to database server. Database Server name,
Database username, password and Database Name.

Managing Database Connections

The below code describes managing database connection methods and features.
<?php
$servername = “localhost”;
$username = “username”;
$password = “password”;
$DB_name = “School_DB”;
$conn = mysqli_connect($servername, $username, $password,$DB_name);
if (!$conn)
{
die(“Connection failed: “ . mysqli_connect_error());
}
echo “Connected successfully”;
?>

In the above code, four variables are used to connect to the Database server. They are
 $servername -> Database Server Server IP address
 $username -> Database Server User Name
 $password -> Database Server Password
 $DB_Name -> Database Name

30
 The mysqli_connect function uses these variables to connect Database server to PHP.
If connection gets fail, output will be printed with MySQL error code. Otherwise connection
is success.
Performing Queries
The main goal of MySQL and PHP connectivity is to retrieve and manipulate the data
from MySQL database server. The SQL query statements help in PHP MySQL extension to
achieve the objective of MySQL and PHP connection. “mysqli_query” is a function, that
helps to execute the SQL query statements in PHP scripting language.
Syntax
mysqli_query(“Connection Object”, “SQL Query”)
Example
$con=mysqli_connect(“localhost”, “my_user”, “my_password”, “Student_DB”);
$sql=”SELECT student_name,student_age FROM student”;mysqli_query($con,$sql);

Closing Connection:
mysqli_close() Function is used to close an existing opened database connection
between PHP scripting and MySQL Database Server.
Syntax
mysqli_close(“Connection Object”);
Example
<?php
$con=mysqli_connect(“localhost”,”$user”,”$password”,”SCHOOL_DB”);
mysqli_close($con);
?>
Example:
<?php
$servername = “localhost”;
$username = “username”;
$password = “password”;
$dbname = “school_DB”;
$connection = mysqli_connect(‘$servername ‘, ‘$username’, ‘$password’,’$dbname’);
if (mysqli_connect_errno())
{
echo “Failed to connect to MySQL: “ . mysqli_connect_error();
}
sql_stmt = “SELECT * FROM my_contacts”; //SQL select query
$result = mysqli_query($connection,$sql_stmt);//execute SQL statement

31
$rows = mysqli_num_rows($result);// get number of rows returned
if ($rows)
{
while ($row = mysqli_fetch_array($result))
{
echo ‘ID: ‘ . $row[‘id’] . ‘<br>’;
echo ‘Full Names: ‘ . $row[‘full_names’] . ‘<br>’;
echo ‘Gender: ‘ . $row[‘gender’] . ‘<br>’;
echo ‘Contact No: ‘ . $row[‘contact_no’] . ‘<br>’;
echo ‘Email: ‘ . $row[‘email’] . ‘<br>’;
echo ‘City: ‘ . $row[‘city’] . ‘<br>’;
echo ‘Country: ‘ . $row[‘country’] . ‘<br><br>’;
}
}
mysqli_close($connection); //close the database connection
?>

Retrieve or Fetch Data From Database in PHP

As we know Database is a collection of tables that stores data in it. To retrieve or
fetch data from MySQL database it is simple to do it using MySQL ” Select ” query in PHP.
MySQL Select Query
SELECT column_name(s)
FROM table_name
PHP
$query = mysql_query("select * from tablename", $connection);
For this you must have a database in MySQL. Here, we have a database named “company”
which consists of a table named “employee” with 5 fields in it.
Next we have created a PHP page named “updatephp.php” where following steps will
be going to perform:
We first establish connection with server.
$connection = mysql_connect("localhost", "root", "");
Selects database.
$db = mysql_select_db("company", $connection);
Executes MySQL select query.
$query = mysql_query("select * from employee", $connection);
Display fetched data
<span>Name:</span> <?php echo $row1['employee_name']; ?>
<span>E-mail:</span> <?php echo $row1['employee_email']; ?>
<span>Contact No:</span> <?php echo $row1['employee_contact']; ?>

32
 <span>Address:</span> <?php echo $row1['employee_address']; ?>
Closing connection with server.
mysql_close($connection);

Counting Returned Records

By using PHP and MySQL, one can perform database operations. We can get the total
number of rows in a table by using the MySQL mysqli_num_rows() function.
Syntax
mysqli_num_rows( result );
The result is to specify the result set identifier returned by mysqli_query() function.
Example:
$sql = "SELECT * from building";
if ($result = mysqli_query($con, $sql))
{
// Return the number of rows in result set
$rowcount = mysqli_num_rows( $result );
// Display result
printf("Total rows in this table : %d\n", $rowcount);
}

Updating Records with PHP

Updating data in a database is a fundamental operation in web development, and PHP
provides a convenient and powerful way to perform such updates using the "update" query.
The "update" query allows developers to modify existing records in a database table, making
it essential for applications that require data manipulation or maintenance.
In PHP, the "update" query is typically used in conjunction with SQL (Structured
Query Language) to interact with a database system. It enables developers to change the
values of specific fields within a table based on specified conditions. This flexibility allows
for targeted updates, ensuring that only the desired records are modified while preserving the
integrity of the database.
The "update" query follows a specific syntax, which includes specifying the table to
update, the fields to modify, and the conditions that determine which records should be
updated. By providing the necessary parameters and values, developers can dynamically
update data in real-time, responding to user input or application logic.
One of the key advantages of using the "update" query in PHP is its ability to handle
complex operations efficiently. Whether it's updating a single record or performing bulk

33
updates, PHP's support for SQL statements makes the process straightforward and ensures
optimal performance.
Example
<?php
// Step 1: Create a database connection
$servername = "localhost"; // Replace with your database server name
$username = "username"; // Replace with your database username
$password = "password"; // Replace with your database password
$dbname = "database"; // Replace with your database name
$conn = new mysqli($servername, $username, $password, $dbname);
if ($conn->connect_error)
{
die("Connection failed: " . $conn->connect_error);
}
// Step 2: Prepare and execute the update query
$sql = "UPDATE table_name SET column1 = 'new_value1', column2 = 'new_value2'
WHERE condition";
if ($conn->query($sql) === TRUE)
{
echo "Record updated successfully";
}
else
{
echo "Error updating record: " . $conn->error;
}
// Step 3: Close the database connection
$conn->close();
?>

In the above code, you need to replace the following placeholders with your actual database
credentials and query details:
$servername: Your database server name or IP address.
$username: Your database username.
$password: Your database password.
$dbname: Your database name.
table_name: The name of the table you want to update.
column1, column2: The columns in the table you want to update.
new_value1, new_value2:The new values you want to set for the respective columns.
condition: The condition that specifies which rows to update. For example, id = 1 to
update a row with the ID of 1.

34