Web Technology II

A server-side script is a program that runs on the web server (not in the browser) when a request is received. It processes the request, may access databases and files, and sends the generated output, usually HTML, back to the client. PHP, ASP.NET, JSP and Node.js are examples.

Superglobals are built-in PHP variables that are always available in every scope (function, class or file) without using the global keyword. Examples are $_GET, $_POST, $_REQUEST, $_SESSION, $_COOKIE, $_SERVER, $_FILES, $_ENV and $GLOBALS.

An associative array is a PHP array in which each value is accessed by a named (string) key instead of a numeric index, for example $age = ["Ram" => 20, "Sita" => 22]; and echo $age["Ram"];.

A static method is a class method declared with the static keyword. It belongs to the class itself, so it can be called without creating an object, using ClassName::method(). It cannot use $this.

class Math { public static function square($n) { return $n * $n; } }
echo Math::square(4); // 16

File handling is needed to create, read, write, update, delete and upload files on the server, so that data can be stored permanently (for example logs, configuration, text data, uploaded images and documents) and survive after the script ends.

• Data is organised and can be searched, sorted and filtered quickly using SQL.
• Large amounts of data can be handled efficiently and shared by many users at the same time.
• It gives security (user permissions, backups) and data integrity (constraints, transactions).
• It reduces redundancy and makes content dynamic and easy to update.

A cookie is a small piece of data (up to about 4 KB) that the server sends to the browser, which stores it on the client's computer and returns it with every later request to the same site. It is used to remember users, preferences and login information. In PHP it is set with setcookie() and read with $_COOKIE.

A session stores user information on the server across multiple pages, identified by a session ID. It is used for:

• keeping users logged in and authentication;
• shopping carts;
• storing user preferences and temporary data (such as form data in multi-step forms);
• tracking user activity securely, since data is not kept in the browser.

A server-side framework is a collection of ready-made libraries, tools and a structure (often MVC) that helps developers build web applications faster and in an organised way. It provides routing, database access, templates, security and authentication. Examples are Laravel and CodeIgniter (PHP), Django (Python), Express (Node.js) and Spring (Java).

A dynamic website is a website whose content is generated at the time of the request by server-side scripts, usually using data from a database. The content can change according to the user, time or input (for example, a login page, e-commerce site or news portal), unlike a static site, which shows fixed HTML pages.

$_GET and $_POST are superglobals which collect form data.

A regular expression (regex) is a pattern made of special characters used to search, match, validate or replace text in a string. In PHP, the PCRE functions preg_match(), preg_match_all(), preg_replace() and preg_split() are used. The pattern is written between delimiters such as / /.

Common symbols: ^ start, $ end, . any character, * zero or more, + one or more, ? optional, [a-z] character range, \d digit, {n} exactly n times.

<?php
$email = "ram@example.com";
if (preg_match("/^[\w.]+@[a-z]+\.[a-z]{2,}$/i", $email)) {
    echo "Valid email";
} else {
    echo "Invalid email";
}

$phone = "9841234567";
echo preg_match("/^9\d{9}$/", $phone); // 1 (matches a 10-digit number starting with 9)
?>

Setting a cookie: use setcookie(name, value, expire, path, domain, secure, httponly). It must be called before any HTML output.

<?php
setcookie("username", "Ram", time() + 86400, "/"); // valid for 1 day
?>

Getting a cookie: read it from the $_COOKIE superglobal. A cookie becomes available on the next request after it has been set.

<?php
if (isset($_COOKIE["username"])) {
    echo "Welcome " . $_COOKIE["username"];
} else {
    echo "Cookie not set";
}
?>

Deleting a cookie: set its expiry time in the past, setcookie("username", "", time() - 3600, "/");.

User credentials (such as username and password) are accessed in PHP from the submitted login form using the $_POST superglobal (or $_GET), and are then checked against the database.

<form method="post" action="login.php">
  <input type="text" name="username">
  <input type="password" name="password">
  <input type="submit" value="Login">
</form>

<?php
session_start();
if ($_SERVER["REQUEST_METHOD"] == "POST") {
    $username = $_POST["username"];
    $password = $_POST["password"];
    // compare with the stored hashed password from the database
    // if (password_verify($password, $hash)) { $_SESSION["user"] = $username; }
}
?>

Passwords should be stored as hashes (password_hash()), verified with password_verify(), and queries should use prepared statements. After login, the user's identity is kept in $_SESSION. For HTTP authentication, $_SERVER['PHP_AUTH_USER'] and $_SERVER['PHP_AUTH_PW'] can be used.

• Faster development: Ready-made components for routing, forms, authentication and database access reduce the code to be written.
• Better structure and maintainability: They follow patterns such as MVC and coding conventions, so the code is organised and easy to maintain in teams.
• Security: Built-in protection against SQL injection, XSS and CSRF, along with password hashing and session handling.
• Reusability and scalability: Reusable libraries and modules, caching and ORM support help to scale applications.
• Community support: Documentation, plugins and active communities, and easy testing and deployment.

A class is defined in PHP using the class keyword followed by the class name and a body in curly braces containing properties (variables) and methods (functions). Objects are created with new, and members are accessed with ->. The constructor is __construct(), and $this refers to the current object.

<?php
class Student {
    public $name;
    private $roll;

    public function __construct($name, $roll) {
        $this->name = $name;
        $this->roll = $roll;
    }

    public function display() {
        echo "Name: $this->name, Roll: $this->roll";
    }
}

$s1 = new Student("Sita", 5);
$s1->display();   // Name: Sita, Roll: 5
?>

A function is a named block of reusable code defined with the function keyword, and executed only when it is called.

Syntax

function functionName($param1, $param2 = default) {
    // code
    return $value;   // optional
}

Example 1: simple function with parameters and return value

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

Example 2: default argument

<?php
function greet($name = "Guest") {
    echo "Hello $name";
}
greet("Ram");  // Hello Ram
greet();       // Hello Guest
?>

Example 3: pass by reference

<?php
function addOne(&$n) { $n++; }
$x = 10;
addOne($x);
echo $x;  // 11
?>

Points to remember:

• Function names are not case sensitive and must begin with a letter or underscore.
• Variables inside a function are local unless declared global or static.
• Arguments can be passed by value (default) or by reference (&).
• Type declarations can be used: function add(int $a, int $b): int.
• A function can be called before its definition if it is defined at the top level of the file.

An exception is an error condition that interrupts the normal flow of a program. PHP handles exceptions with try, catch, finally and throw.

• try: contains the code which may cause an exception.
• throw: raises (throws) an exception object.
• catch: catches the exception and handles it. Several catch blocks may be used for different exception types.
• finally: code which always runs, whether or not an exception occurred.

<?php
function divide($a, $b) {
    if ($b == 0) {
        throw new Exception("Division by zero is not allowed");
    }
    return $a / $b;
}

try {
    echo divide(10, 0);
} catch (Exception $e) {
    echo "Error: " . $e->getMessage();
} finally {
    echo "<br>Execution finished";
}
?>

Output:

Error: Division by zero is not allowed
Execution finished

Custom exceptions can be made by extending the Exception class, and set_exception_handler() can define a global handler for uncaught exceptions. Useful methods are getMessage(), getCode(), getLine() and getFile().

<?php
$filename = "data.txt";

if (!file_exists($filename)) {
    die("File not found.");
}

$fp = fopen($filename, "r");
$vowels = "";

while (!feof($fp)) {
    $line = fgets($fp);
    // keep only vowels (both cases)
    $vowels .= preg_replace("/[^aeiouAEIOU]/", "", $line);
}
fclose($fp);

echo "Vowels in the file: " . $vowels . "<br>";
echo "Total vowels: " . strlen($vowels);
?>

The program opens the file for reading with fopen(), reads it line by line with fgets() until the end (feof()), removes all non-vowel characters using a regular expression, and displays the remaining vowels. A shorter alternative is preg_replace("/[^aeiou]/i", "", file_get_contents("data.txt")).

PHP connects to a MySQL database using the MySQLi (or PDO) extension. The steps are:

1. Create the database and table in MySQL, for example school and students(id, name, email).
2. Connect to the server with mysqli_connect(host, username, password, database) and check for errors.
3. Prepare the SQL INSERT statement with the values (taken from a form using $_POST).
4. Execute the query with mysqli_query() or a prepared statement, and check the result.
5. Close the connection with mysqli_close().

<?php
$conn = mysqli_connect("localhost", "root", "", "school");
if (!$conn) {
    die("Connection failed: " . mysqli_connect_error());
}

$name  = "Ram Sharma";
$email = "ram@example.com";

$stmt = mysqli_prepare($conn, "INSERT INTO students (name, email) VALUES (?, ?)");
mysqli_stmt_bind_param($stmt, "ss", $name, $email);

if (mysqli_stmt_execute($stmt)) {
    echo "Record inserted successfully";
} else {
    echo "Error: " . mysqli_error($conn);
}

mysqli_stmt_close($stmt);
mysqli_close($conn);
?>

A prepared statement is used to prevent SQL injection.

Assumptions: MySQL server on localhost, user root with empty password, database school, and the table:

CREATE DATABASE school;
USE school;
CREATE TABLE students (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(50) NOT NULL,
    email VARCHAR(80) NOT NULL
);

students.php (the form, insertion and display are in a single file)

<?php
// Database connection
$conn = mysqli_connect("localhost", "root", "", "school");
if (!$conn) {
    die("Connection failed: " . mysqli_connect_error());
}

// Insert data when the form is submitted
if ($_SERVER["REQUEST_METHOD"] == "POST") {
    $name  = trim($_POST["name"]);
    $email = trim($_POST["email"]);

    if ($name != "" && $email != "") {
        $stmt = mysqli_prepare($conn, "INSERT INTO students (name, email) VALUES (?, ?)");
        mysqli_stmt_bind_param($stmt, "ss", $name, $email);
        if (mysqli_stmt_execute($stmt)) {
            $msg = "Record inserted successfully.";
        } else {
            $msg = "Error: " . mysqli_error($conn);
        }
        mysqli_stmt_close($stmt);
    } else {
        $msg = "All fields are required.";
    }
}
?>
<!DOCTYPE html>
<html>
<head><title>Student Records</title></head>
<body>
<h2>Add Student</h2>
<?php if (isset($msg)) echo "<p>$msg</p>"; ?>
<form method="post" action="">
    Name: <input type="text" name="name" required><br><br>
    Email: <input type="email" name="email" required><br><br>
    <input type="submit" value="Save">
</form>

<h2>Student List</h2>
<table border="1" cellpadding="5">
<tr><th>ID</th><th>Name</th><th>Email</th></tr>
<?php
// Retrieve and display data
$result = mysqli_query($conn, "SELECT * FROM students ORDER BY id");
if (mysqli_num_rows($result) > 0) {
    while ($row = mysqli_fetch_assoc($result)) {
        echo "<tr><td>" . $row["id"] . "</td><td>" .
             htmlspecialchars($row["name"]) . "</td><td>" .
             htmlspecialchars($row["email"]) . "</td></tr>";
    }
} else {
    echo "<tr><td colspan='3'>No records found</td></tr>";
}
mysqli_close($conn);
?>
</table>
</body>
</html>

Working: The HTML form sends the data with the POST method to the same page. The PHP code connects to the database, inserts the data using a prepared statement (safe against SQL injection), then runs a SELECT query and prints each row of the result in a table with mysqli_fetch_assoc(). htmlspecialchars() prevents XSS when the data is displayed.

Benefits of arrays

• One variable can store many related values, so there is no need for many separate variables.
• Elements are accessed easily by an index or a key, and loops can process them.
• Sorting, searching, merging and other operations are easy using built-in functions (sort(), array_sum(), count(), in_array()).
• They make the code short, organised and easy to maintain, and can represent lists, tables and records (multidimensional arrays).
• PHP arrays are flexible: they can hold values of different types and grow dynamically.

Program: sum and average of 10 numbers

<?php
$numbers = [12, 7, 25, 8, 14, 30, 5, 18, 21, 10];

$sum = 0;
foreach ($numbers as $n) {
    $sum += $n;
}
$avg = $sum / count($numbers);

echo "Sum = " . $sum . "<br>";          // 150
echo "Average = " . $avg;               // 15
// Alternatively: array_sum($numbers) and array_sum($numbers)/count($numbers)
?>

Why we need associative arrays

An associative array uses meaningful named keys instead of numeric indexes, so data is easier to understand and access, for example $student = ["name" => "Sita", "age" => 20, "faculty" => "BIM"]; and echo $student["name"];. They are needed because:

• they store data as key-value pairs, like a record or a database row (mysqli_fetch_assoc() returns one);
• values can be found directly by key without remembering positions, and the order of elements does not matter;
• they represent configuration data, form data ($_POST["email"]), JSON data and lookup tables clearly;
• they make code more readable and less error prone than numeric indexes.