1 Answer the following in short.

(Any seven)
1. Explain Associative Array with example.
2. Explain the difference between echo and print function.
3. How to increase the size limit for file uploading?
4. What is Jinja2?
5. How to define constant in PHP?
6. What is the use of isset() function?
7. Explain array_pop() with example.
8. What is render_template() method?
9. What is flask?
10. What is AJAX?

Answers
1. **Associative Array**: An associative array is a data structure that allows you to store key-value pairs, where each
key is unique and is used to access its corresponding value. For example, in PHP, you can define an associative array
as follows:
```php
$person = array("name" => "John", "age" => 30, "city" => "New York");
```
Here, "name", "age", and "city" are keys, and their respective values are "John", 30, and "New York".

2. **Difference between echo and print**: Both `echo` and `print` are used to output data in PHP. However, `echo`
can take multiple parameters (though it's rarely used this way), does not return a value, and is slightly faster. In
contrast, `print` can only take one argument and returns 1, making it usable in expressions. Example:
```php
echo "Hello, ", "World!"; // Valid
print "Hello, World!"; // Valid
```
3. **Increasing File Upload Size Limit**: To increase the file upload size limit in PHP, you can modify the `php.ini` file
by changing the values of `upload_max_filesize` and `post_max_size`. For example:
```ini
upload_max_filesize = 64M
post_max_size = 64M
```
Alternatively, you can edit the `.htaccess` file or use a WordPress plugin if you're working within a WordPress
environment[1][3].

4. **Jinja2**: Jinja2 is a modern and designer-friendly templating engine for Python. It is used primarily with web
frameworks like Flask to create dynamic HTML pages by allowing developers to embed Python-like expressions
directly into HTML files. Jinja2 supports features like template inheritance, macros, and automatic escaping of HTML.

5. **Defining Constants in PHP**: In PHP, constants are defined using the `define()` function. Once defined, their
values cannot be changed or undefined during the script execution. Example:
```php
define("SITE_NAME", "My Website");
```
6. **Use of isset() Function**: The `isset()` function in PHP checks whether a variable is set and is not null. It returns
true if the variable exists; otherwise, it returns false. This function is commonly used to prevent errors when
accessing variables that may not be defined.
```php
if (isset($var)) {
echo "Variable is set.";
}
```
7. **array_pop() Function**: The `array_pop()` function removes the last element from an array and returns it. This
modifies the original array by reducing its size by one. Example:
```php
 $fruits = array("apple", "banana", "cherry");
$lastFruit = array_pop($fruits); // $lastFruit will be "cherry"
```
8. **render_template() Method**: The `render_template()` method in Flask is used to render HTML templates with
dynamic content passed from the server-side code. It takes the name of the template file as an argument and can
accept additional keyword arguments that represent variables to be passed into the template.
```python
return render_template('index.html', title='Home')
```
9. **Flask**: Flask is a lightweight web framework for Python designed for building web applications quickly and
efficiently. It follows the WSGI (Web Server Gateway Interface) standard and provides tools and libraries for routing,
rendering templates, handling forms, and managing sessions.

10. **AJAX**: AJAX (Asynchronous JavaScript and XML) is a technique used in web development that allows for
asynchronous communication between the client and server without requiring a full page reload. This enables web
applications to send and retrieve data from servers asynchronously in the background while updating parts of a web
page dynamically.

Answer the following.

1. Explain File upload method with type and size constraints in details with example.
2. Explain the different methods of connection with database and manipulation of data in tables with example.

Answers

## File Upload Method with Type and Size Constraints

File upload in web applications typically involves allowing users to select files from their local system and submit
them to the server. In PHP, file uploads are handled through HTML forms and the `$_FILES` superglobal array. Here’s
a detailed explanation of the file upload method, including type and size constraints.

### **1. HTML Form Setup**

To enable file uploads, you need to create an HTML form with the `enctype` attribute set to `multipart/form-data`.
This allows files to be sent as binary data.

```html
<form action="upload.php" method="post" enctype="multipart/form-data">
Select file to upload:
<input type="file" name="fileToUpload" id="fileToUpload">
<input type="submit" value="Upload File" name="submit">
</form>
```

### **2. PHP Script for Handling Uploads**

In the PHP script (`upload.php`), you can handle the uploaded file using the `$_FILES` array. You can enforce
constraints on file types and sizes.

```php
<?php
$target_dir = "uploads/";
$target_file = $target_dir . basename($_FILES["fileToUpload"]["name"]);
$uploadOk = 1;
$fileType = strtolower(pathinfo($target_file, PATHINFO_EXTENSION));

// Check if file is a valid type

$allowedTypes = ['jpg', 'png', 'gif', 'pdf'];
if (!in_array($fileType, $allowedTypes)) {
echo "Sorry, only JPG, PNG, GIF, & PDF files are allowed.";
$uploadOk = 0;
}

// Check file size (limit to 2MB)

if ($_FILES["fileToUpload"]["size"] > 2000000) {
echo "Sorry, your file is too large.";
$uploadOk = 0;
}

// Check if $uploadOk is set to 0 by an error

if ($uploadOk == 0) {
echo "Sorry, your file was not uploaded.";
} else {
if (move_uploaded_file($_FILES["fileToUpload"]["tmp_name"], $target_file)) {
echo "The file ". htmlspecialchars(basename($_FILES["fileToUpload"]["name"])). " has been uploaded.";
} else {
echo "Sorry, there was an error uploading your file.";
}
}
?>
```

### **3. Type Constraints**

- **Allowed Types**: You can specify which file types are acceptable by checking the file extension against an array
of allowed types.
- **MIME Type Verification**: For enhanced security, it’s advisable to also check the MIME type of the uploaded file
using `mime_content_type()`.

### **4. Size Constraints**

- **File Size Limit**: You can enforce a maximum size for uploads by checking the `size` attribute of the `$_FILES`
array. Common limits are set in bytes (e.g., 2MB = 2000000 bytes).
- **Server Configuration**: Ensure that your server’s PHP configuration (`php.ini`) allows for sufficient upload sizes:
- `upload_max_filesize`
- `post_max_size`

### **5. Error Handling**

Proper error handling should be implemented to inform users of any issues during the upload process. This includes
checking for upload errors using `$_FILES["fileToUpload"]["error"]`.

## Different Methods of Connection with Database and Manipulation of Data

Connecting to a database in PHP can be achieved through various methods. The two most common methods are
MySQLi (MySQL Improved) and PDO (PHP Data Objects). Below is a detailed explanation of each method along with
examples for data manipulation.

### **1. MySQLi Connection**

MySQLi provides both procedural and object-oriented interfaces for interacting with MySQL databases.

#### **Example: MySQLi Object-Oriented Connection**

```php
<?php
$servername = "localhost";
$username = "username";
$password = "password";
$dbname = "myDB";

// Create connection
$conn = new mysqli($servername, $username, $password, $dbname);

// Check connection
if ($conn->connect_error) {
die("Connection failed: " . $conn->connect_error);
}
echo "Connected successfully";

// Example: Inserting data into a table

$sql = "INSERT INTO Users (username, email) VALUES ('john_doe', '[email protected]')";
if ($conn->query($sql) === TRUE) {
echo "New record created successfully";
} else {
echo "Error: " . $sql . "<br>" . $conn->error;
}

// Close connection
$conn->close();
?>
```

### **2. PDO Connection**

PDO provides a consistent interface for accessing multiple databases and supports prepared statements for
enhanced security against SQL injection.

#### **Example: PDO Connection**

```php
<?php
$servername = "localhost";
$username = "username";
$password = "password";
$dbname = "myDB";

try {
// Create connection
$conn = new PDO("mysql:host=$servername;dbname=$dbname", $username, $password);

// Set the PDO error mode to exception

$conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

echo "Connected successfully";

// Example: Inserting data into a table using prepared statements

$stmt = $conn->prepare("INSERT INTO Users (username, email) VALUES (:username, :email)");
$stmt->bindParam(':username', $username);
$stmt->bindParam(':email', $email);

// Insert a row
 $username = 'jane_doe';
$email = '[email protected]';
$stmt->execute();

echo "New record created successfully";

} catch(PDOException $e) {
echo "Connection failed: " . $e->getMessage();
}

// Close connection
$conn = null;
?>
```

### **3. Data Manipulation Examples**

Both MySQLi and PDO support various SQL operations such as SELECT, UPDATE, DELETE:

- **SELECT Example**:
```php
$sql = "SELECT id, username FROM Users";
$result = $conn->query($sql);
if ($result->num_rows > 0) {
while($row = $result->fetch_assoc()) {
echo "id: " . $row["id"]. " - Name: " . $row["username"]. "<br>";
}
}
```

- **UPDATE Example**:
```php
$sql = "UPDATE Users SET email='[email protected]' WHERE username='john_doe'";
$conn->query($sql);
```

- **DELETE Example**:
```php
$sql = "DELETE FROM Users WHERE username='john_doe'";
$conn->query($sql);
```

### **4. Summary of Differences**

- **MySQLi** is specific to MySQL databases and offers both procedural and object-oriented approaches.
- **PDO** supports multiple database types and provides a more flexible interface with prepared statements.

Choosing between MySQLi and PDO depends on your project requirements; if you need portability across different
database systems, PDO is preferable.

Answer the following.

1. Explain data passing techniques across multiple pages with examples.
2. Explain different types of MYSQL tables

Answers
## Data Passing Techniques Across Multiple Pages
When developing web applications, it is often necessary to pass data between different pages. There are several
techniques to achieve this in PHP, each with its own advantages and use cases. Here are the most common methods:

### **1. URL Parameters (GET Method)**

Data can be passed through the URL using query strings. This method is suitable for small amounts of data and is
visible in the browser's address bar.

**Example:**
```php
// Page 1: form.html
<form action="page2.php" method="get">
<input type="text" name="username" placeholder="Enter your name">
<input type="submit" value="Submit">
</form>

// Page 2: page2.php
<?php
$username = $_GET['username'];
echo "Hello, " . htmlspecialchars($username) . "!";
?>
```
In this example, the username entered in `form.html` is passed to `page2.php` via the URL.

### **2. Form Submission (POST Method)**

Using the POST method allows for larger amounts of data to be sent without displaying it in the URL. This is more
secure than GET for sensitive information.

**Example:**
```php
// Page 1: form.html
<form action="page2.php" method="post">
<input type="text" name="username" placeholder="Enter your name">
<input type="submit" value="Submit">
</form>

// Page 2: page2.php
<?php
$username = $_POST['username'];
echo "Hello, " . htmlspecialchars($username) . "!";
?>
```
Here, the username is sent securely via POST and can include larger data sets.

### **3. Sessions**

Sessions allow you to store user data across multiple pages without passing it through URLs or forms. Data stored in
a session persists until the session is destroyed.

**Example:**
```php
// Start session on both pages
session_start();

// Page 1: set_session.php
$_SESSION['username'] = 'JohnDoe';
header('Location: page2.php');

// Page 2: page2.php
session_start();
echo "Hello, " . htmlspecialchars($_SESSION['username']) . "!";
```
In this case, the username is stored in a session variable and can be accessed on any page during that session.

### **4. Cookies**

Cookies are small pieces of data stored on the client’s browser. They can persist across sessions and are useful for
storing user preferences or login states.

**Example:**
```php
// Page 1: set_cookie.php
setcookie("username", "JohnDoe", time() + (86400 * 30), "/"); // 30 days expiration
header('Location: page2.php');

// Page 2: page2.php
if(isset($_COOKIE['username'])) {
echo "Hello, " . htmlspecialchars($_COOKIE['username']) . "!";
}
```
Cookies can be accessed on any page within the same domain and are useful for tracking user sessions.

### **5. Hidden Fields**

Hidden fields in forms allow you to pass additional data that users do not see. This method works well when
submitting forms.

**Example:**
```php
// Page 1: form.html
<form action="page2.php" method="post">
<input type="hidden" name="user_id" value="12345">
<input type="submit" value="Submit">
</form>

// Page 2: page2.php
$user_id = $_POST['user_id'];
echo "User ID is: " . htmlspecialchars($user_id);
```
Hidden fields allow you to send data alongside user input without displaying it.

## Different Types of MySQL Tables

MySQL supports various table types (also known as storage engines), each with unique features and performance
characteristics. Understanding these types helps developers choose the best option for their applications.

### **1. MyISAM**

- **Description**: MyISAM is the default storage engine in MySQL versions prior to 5.5. It supports table-level
locking and is optimized for read-heavy operations.
- **Advantages**:
- Fast read operations due to its simple structure.
- Supports full-text indexing.
- **Disadvantages**:
- No support for transactions (no COMMIT or ROLLBACK).
- Table corruption can occur without recovery options.

**Example Usage**:
```sql
CREATE TABLE users (
id INT AUTO_INCREMENT PRIMARY KEY,
username VARCHAR(50) NOT NULL,
email VARCHAR(100)
) ENGINE=MyISAM;
```

### **2. InnoDB**

- **Description**: InnoDB is a transaction-safe storage engine that supports ACID-compliant transactions and
foreign key constraints.
- **Advantages**:
- Supports transactions with rollback capabilities.
- Better data integrity due to foreign key constraints.
- **Disadvantages**:
- Slower write operations compared to MyISAM due to additional overhead.

**Example Usage**:
```sql
CREATE TABLE orders (
order_id INT AUTO_INCREMENT PRIMARY KEY,
user_id INT,
order_date DATETIME,
FOREIGN KEY (user_id) REFERENCES users(id)
) ENGINE=InnoDB;
```

### **3. MEMORY**

- **Description**: The MEMORY storage engine creates tables that store all their data in RAM, providing extremely
fast access times.
- **Advantages**:
- Very fast performance due to in-memory storage.
- **Disadvantages**:
- Data is lost if the server crashes or restarts.
- Limited by available memory.

**Example Usage**:
```sql
CREATE TABLE temp_data (
id INT PRIMARY KEY,
data VARCHAR(100)
) ENGINE=MEMORY;
```

### **4. CSV**

- **Description**: The CSV storage engine stores data in comma-separated values format, allowing easy
import/export of data.
- **Advantages**:
- Simple format that can be easily manipulated outside of MySQL.
- **Disadvantages**:
- Limited functionality; does not support indexes or transactions.

**Example Usage**:
```sql
CREATE TABLE csv_data (
id INT,
name VARCHAR(100)
) ENGINE=CSV;
```

### **5. ARCHIVE**

- **Description**: The ARCHIVE storage engine is designed for storing large amounts of historical data with minimal
disk space usage.
- **Advantages**:
- Data compression reduces storage requirements.
- **Disadvantages**:
- Only supports INSERT and SELECT operations; no updates or deletes allowed.

**Example Usage**:
```sql
CREATE TABLE archived_logs (
log_id INT AUTO_INCREMENT PRIMARY KEY,
log_message TEXT,
log_date DATETIME
) ENGINE=ARCHIVE;
```

### **6. FEDERATED**

- **Description**: The FEDERATED storage engine allows access to tables located on remote MySQL servers without
replication.
- **Advantages**:
- Enables distributed database systems by querying remote databases directly.
- **Disadvantages**:
- Performance may vary based on network latency; limited functionality compared to local tables.

### Summary

Choosing the appropriate storage engine depends on your specific application needs regarding performance,
reliability, and functionality. For transactional applications requiring high integrity, InnoDB is preferred, while
MyISAM may be suitable for read-heavy applications where speed is critical.

Q.3 Write short notes. (Any two)

1. PHP-Python integration
2. Features of PHP
3. Exceptional Handling
4. Cookie

Answers
## PHP-Python Integration

Integrating PHP and Python can enhance web applications by leveraging the strengths of both languages. There are
several effective methods for achieving this integration:
1. **Executing Python Scripts from PHP**: One common way to integrate Python into a PHP application is by
executing Python scripts directly from PHP using functions like `exec()`, `shell_exec()`, or `system()`. This allows PHP
to run a Python program and capture its output. For example:
```php
$output = [];
exec('python3 script.py arg1 arg2', $output);
echo implode("\n", $output);
```
This method is useful for running data processing scripts or machine learning models.

2. **Using a REST API**: Another approach is to create a RESTful API using a Python web framework (like Flask or
Django). The PHP application can make HTTP requests to this API, allowing for a clean separation of concerns and
enabling communication over standard protocols. This is particularly advantageous for microservices architectures.

3. **Message Queues**: For asynchronous tasks, PHP can send messages to a message broker (like RabbitMQ),
which Python workers can process. This setup is ideal for background jobs that should not block the execution of the
PHP application.

4. **Security Considerations**: When executing shell commands, it’s crucial to sanitize inputs using functions like
`escapeshellarg()` and `escapeshellcmd()` to prevent command injection attacks.

By using these methods, developers can effectively combine the capabilities of PHP and Python, making their
applications more powerful and versatile.

## Features of PHP

PHP (Hypertext Preprocessor) is a popular server-side scripting language known for its flexibility and ease of use in
web development. Here are some key features:

1. **Server-Side Scripting**: PHP is primarily designed for server-side scripting, allowing developers to create
dynamic web pages that interact with databases and handle user input seamlessly.

2. **Cross-Platform Compatibility**: PHP runs on various platforms, including Windows, Linux, and macOS, and can
be integrated with different web servers like Apache and Nginx.

3. **Database Support**: PHP offers robust support for multiple databases, including MySQL, PostgreSQL, and
SQLite, enabling developers to build data-driven applications efficiently.

4. **Rich Library Support**: With a vast collection of built-in functions and libraries, PHP simplifies tasks such as
string manipulation, file handling, and session management.

5. **Object-Oriented Programming (OOP)**: PHP supports OOP principles, allowing developers to create reusable
code through classes and objects, enhancing code organization and maintainability.

6. **Easy Integration**: PHP can be easily integrated with HTML and other web technologies like JavaScript, making
it versatile for building interactive web applications.

7. **Community Support**: Being open-source, PHP has a large community that contributes to its continuous
improvement, providing extensive documentation and resources for developers.

These features make PHP an excellent choice for developing dynamic websites and applications that require server-
side processing.

## Exception Handling
Exception handling in programming refers to the process of responding to exceptions—unexpected events that
disrupt the normal flow of execution in a program. In PHP, exception handling is accomplished using `try`, `catch`,
and `finally` blocks:

1. **Try Block**: Code that may throw an exception is placed inside a `try` block. If an exception occurs within this
block, control is transferred to the corresponding `catch` block.

2. **Catch Block**: The `catch` block handles the exception. You can define multiple catch blocks to handle different
types of exceptions.
```php
try {
// Code that may throw an exception
$result = 10 / 0; // This will cause an exception
} catch (DivisionByZeroError $e) {
echo "Error: " . $e->getMessage();
}
```

3. **Finally Block**: An optional `finally` block can be used to execute code regardless of whether an exception
occurred or not (e.g., closing database connections).
```php
finally {
echo "This will always execute.";
}
```

4. **Custom Exceptions**: You can create custom exception classes by extending the base `Exception` class,
allowing for more specific error handling tailored to your application's needs.

5. **Error Reporting**: Proper error reporting settings in PHP help identify issues during development by displaying
or logging detailed error messages.

By implementing robust exception handling mechanisms, developers can create more resilient applications that
gracefully manage errors without crashing or exposing sensitive information.

## Cookie

Cookies are small pieces of data stored on the client’s browser that allow web applications to remember information
about users between sessions. Here are some key aspects of cookies in PHP:

1. **Setting Cookies**: Cookies are set using the `setcookie()` function in PHP before any output is sent to the
browser.
```php
setcookie("username", "JohnDoe", time() + (86400 * 30), "/"); // 30 days expiration
```

2. **Cookie Parameters**:
- The first parameter is the cookie name.
- The second parameter is the cookie value.
- The third parameter specifies the expiration time (in seconds).
- The fourth parameter defines the path on the server where the cookie will be available.

3. **Accessing Cookies**: Cookies can be accessed via the `$_COOKIE` superglobal array.
```php
if(isset($_COOKIE['username'])) {
echo "Welcome back, " . htmlspecialchars($_COOKIE['username']) . "!";
}
 ```

4. **Security Considerations**: It’s important to secure cookies by using flags such as `HttpOnly` (to prevent access
via JavaScript) and `Secure` (to transmit cookies only over HTTPS).

5. **Cookie Limitations**: Cookies have size limitations (typically around 4KB) and are sent with every HTTP request
to the same domain, which may impact performance if excessively large or numerous cookies are used.

6. **Session Management**: Cookies are commonly used for session management by storing session identifiers that
link users to their session data stored on the server.
By utilizing cookies effectively, developers can enhance user experience through personalized content while
maintaining security best practices.

Answer the following (Any two)

1. Explain functions: substr(), asort(), implode(),mktime()
2. Explain Flask HTTP methods in detail.
3. Write a PHP script which demonstrates to number of users visited page.
4. Explain validations with regular expression.

Answers
## 1. Functions: `substr()`, `asort()`, `implode()`, `mktime()`

### **`substr()`**

The `substr()` function in PHP is used to extract a portion of a string. It takes three parameters: the string to be
processed, the starting position, and an optional length parameter that specifies how many characters to return.

**Syntax**:
```php
substr(string $string, int $start, int $length = null): string
```

**Example**:
```php
$text = "Hello, World!";
$subText = substr($text, 7, 5); // Returns "World"
```
In this example, `substr()` starts at index 7 and returns the next 5 characters.

### **`asort()`**

The `asort()` function sorts an associative array in ascending order while maintaining the association between keys
and values. This means that the keys will remain linked to their respective values even after sorting.

**Syntax**:
```php
asort(array &$array, int $sort_flags = SORT_REGULAR): bool
```

**Example**:
```php
$array = array("b" => 3, "a" => 2, "c" => 1);
asort($array); // Sorts the array by values
// Result: Array ( [c] => 1 [a] => 2 [b] => 3 )
```
Here, the array is sorted based on its values while preserving the keys.
### **`implode()`**

The `implode()` function joins array elements into a single string. It takes two parameters: a string to use as a
separator and the array of elements to join.

**Syntax**:
```php
implode(string $glue, array $pieces): string
```

**Example**:
```php
$array = array("PHP", "is", "fun");
$string = implode(" ", $array); // Returns "PHP is fun"
```
In this example, the elements of the array are joined into a single string with spaces as separators.

### **`mktime()`**

The `mktime()` function returns the Unix timestamp for a date. It takes parameters for hour, minute, second, month,
day, and year. If any of these parameters are omitted, they default to the current time.

**Syntax**:
```php
mktime(int $hour = date("H"), int $minute = date("i"), int $second = date("s"), int $month = date("n"), int $day =
date("j"), int $year = date("Y")): int
```

**Example**:
```php
$timestamp = mktime(14, 0, 0, 12, 25, 2024); // Returns timestamp for December 25th, 2024 at 14:00:00
```
This example generates a timestamp for a specific date and time.

---
## 2. Flask HTTP Methods in Detail
Flask is a micro web framework for Python that provides tools for building web applications. One of its core features
is handling different HTTP methods used in web requests. The most common HTTP methods are GET and POST;
however, Flask supports several others as well.
### **1. GET Method**
- **Purpose**: The GET method is used to retrieve data from the server. It appends data to the URL as query
parameters.
- **Usage in Flask**: You can define routes that respond to GET requests using the `@app.route` decorator.
**Example**:
```python
from flask import Flask
app = Flask(__name__)
@app.route('/get-data', methods=['GET'])
def get_data():
return "Data retrieved successfully!"
```
### **2. POST Method**
- **Purpose**: The POST method sends data to the server for processing (e.g., form submissions). Data is sent in the
body of the request.
- **Usage in Flask**: Similar to GET, you can specify POST in your route definition.
**Example**:
```python
from flask import Flask, request
app = Flask(__name__)
@app.route('/submit', methods=['POST'])
def submit():
data = request.form['data'] # Accessing form data
return f"Data submitted: {data}"
```
### **3. PUT Method**
- **Purpose**: The PUT method is used to update existing resources or create new resources if they do not exist.
- **Usage in Flask**: You can handle PUT requests similarly to GET and POST.
**Example**:
```python
@app.route('/update/<int:id>', methods=['PUT'])
def update(id):
# Logic to update resource with given id
return f"Resource {id} updated!"
```
### **4. DELETE Method**
- **Purpose**: The DELETE method removes resources from the server.
- **Usage in Flask**: You can define routes that respond to DELETE requests.
**Example**:
```python
@app.route('/delete/<int:id>', methods=['DELETE'])
def delete(id):
# Logic to delete resource with given id
return f"Resource {id} deleted!"
```
### **5. OPTIONS Method**
- **Purpose**: The OPTIONS method returns the HTTP methods that are supported by the server for a specific
resource.
- **Usage in Flask**: This can be useful for CORS (Cross-Origin Resource Sharing) configurations.
### Summary
Flask provides flexible routing capabilities that allow developers to handle various HTTP methods effectively. By
defining routes with specific methods, you can create RESTful APIs that interact with clients according to standard
web protocols.
## 3. PHP Script Demonstrating Number of Users Visited Page
The following PHP script demonstrates how to count the number of users who have visited a page using sessions and
a simple text file as storage:
### Example Script
```php
<?php
session_start(); // Start session

$counter_file = 'counter.txt'; // File to store visitor count

// Check if counter file exists; if not, create it and initialize it to zero.

if (!file_exists($counter_file)) {
file_put_contents($counter_file, '0');
}

// Read current counter value from file.

$counterVal = (int)file_get_contents($counter_file);

// Check if user has already visited this page in this session.

if (!isset($_SESSION['hasVisited'])) {
$_SESSION['hasVisited'] = true; // Set session variable indicating visit.
$counterVal++; // Increment counter value.
 // Write updated counter value back to file.
file_put_contents($counter_file, $counterVal);
}
// Display visitor count.
echo "You are visitor number $counterVal to this page.";
?>
```
### Explanation
1. **Session Management**: The script starts by initiating a session using `session_start()`.
2. **File Handling**: It checks if a text file (`counter.txt`) exists; if not, it creates one initialized at zero.
3. **Reading Counter Value**: The current count is read from the file.
4. **Visitor Check**: It checks whether the user has already visited this page during their session using a session
variable (`hasVisited`). If not visited yet:
- It increments the visitor count.
- Updates the count in the text file.
5. **Output Visitor Count**: Finally, it displays how many visitors have accessed this page.
This script effectively counts unique visits per session while maintaining simplicity through file handling.

## 4. Validations with Regular Expressions

Regular expressions (regex) are powerful tools for pattern matching and validation in strings. In PHP, regex can be
used for various validation tasks such as validating email addresses, phone numbers, and other input formats.

### Common Uses of Regular Expressions

1. **Email Validation**
- Regex can check if an email address follows standard formatting rules.
- Example pattern: `/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/`
```php
$email = "[email protected]";
if (preg_match('/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/', $email)) {
echo "Valid email address.";
} else {
echo "Invalid email address.";
}
```
2. **Phone Number Validation**
- Regex can validate various phone number formats based on country codes or specific patterns.
- Example pattern for US numbers: `/^$$\d{3}$$ \d{3}-\d{4}$/`
```php
$phone = "(123) 456-7890";
if (preg_match('/^\(\d{3}\) \d{3}-\d{4}$/', $phone)) {
echo "Valid phone number.";
} else {
echo "Invalid phone number.";
}
```
3. **Password Strength Validation**
- You can enforce rules such as minimum length and character variety (uppercase letters, lowercase letters,
numbers).
- Example pattern: `/^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d]{8,}$/`
```php
$password = "Password123";
if (preg_match('/^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d]{8,}$/', $password)) {
echo "Strong password.";
} else {
echo "Weak password.";
}
 ```
### Functions Used
- `preg_match()`: Checks if a string matches a given regex pattern.
- `preg_replace()`: Replaces occurrences of a pattern with another string.

### Summary
Regular expressions provide a flexible way to validate user input by defining specific patterns that input must match.
They are widely used for form validation in web applications to ensure data integrity and security before processing
or storing user inputs.

Do as directed. (Any two)

1. Write a detail note on Multidimensional Array.
2. Give the difference between ==and ===
3. Compare PHP with Python language.
4. Explain any four Date and Time function with meaning, Syntax and Example

Answers
## 1. Multidimensional Array
A multidimensional array is an array that contains one or more arrays as its elements. This structure allows for the
storage of data in a tabular form, making it useful for representing matrices, grids, or any data that requires more
than one index for access.
### **Types of Multidimensional Arrays**
1. **Two-Dimensional Arrays**: The most common type, resembling a table with rows and columns.
- **Example**: A 2D array can be used to store student grades.
```php
$grades = array(
array("John", 85, 90),
array("Jane", 92, 88),
array("Doe", 78, 85)
);
```
2. **Three-Dimensional Arrays**: These arrays add another layer of depth, allowing for more complex data
structures.
- **Example**: A 3D array could represent a collection of images where each image has multiple color channels
(RGB).
```php
$images = array(
array(
array(255, 0, 0), // Red channel
array(0, 255, 0), // Green channel
array(0, 0, 255) // Blue channel
)
);
```
### **Accessing Multidimensional Arrays**
Accessing elements in a multidimensional array requires specifying multiple indices. For example, to access Jane's
second grade:
```php
echo $grades[1][2]; // Outputs: 88
```
### **Iterating Over Multidimensional Arrays**
You can use nested loops to iterate through multidimensional arrays:
```php
foreach ($grades as $student) {
echo $student[0] . "'s Grades: " . $student[1] . ", " . $student[2] . "<br>";
}
```
### **Use Cases**
- **Data Representation**: Storing complex data such as matrices in scientific computations.
- **Game Development**: Representing game boards or maps.
- **Database Results**: Fetching records from databases where each record has multiple fields.
Multidimensional arrays are a powerful feature in PHP that allow developers to manage complex data structures
efficiently.

---
## 2. Difference Between `==` and `===`
In JavaScript, `==` (double equals) and `===` (triple equals) are comparison operators used to evaluate equality
between two values. However, they differ significantly in how they handle type comparison.
### **1. Type Coercion**

- **`==` (Loose Equality)**:

- Performs type coercion before comparison.
- Converts operands to the same type if they are of different types.
**Example**:
```javascript
console.log(5 == '5'); // true (string '5' is converted to number)
```
- **`===` (Strict Equality)**:
- Does not perform type coercion.
- Requires both the value and type of the operands to be the same for the comparison to return true.
**Example**:
```javascript
console.log(5 === '5'); // false (different types)
```
### **2. Use Cases**
- Use `==` when you want a loose comparison that allows for type conversion.
- Use `===` when you need strict equality checks where both value and type must match.
### **3. Performance**
- The `===` operator can be slightly faster than `==` because it avoids the overhead of type conversion.
### **4. Best Practices**
- It is generally recommended to use `===` over `==` to avoid unexpected behavior due to implicit type conversion.
In summary, while both operators are used for comparison in JavaScript, `===` offers a more predictable and safer
way to check equality by ensuring both value and type match.

---
## 3. Compare PHP with Python Language
PHP and Python are both powerful programming languages widely used for web development and other
applications. Here’s a comparative overview:
### Summary
Both languages have their strengths and are suited for different types of projects. PHP excels in web development
with its extensive ecosystem tailored for this purpose, while Python is more versatile and widely used across various
fields including data science and automation.

## 4. Date and Time Functions in PHP

PHP provides several built-in functions for handling date and time operations effectively. Here are four commonly
used functions:
### **1. `date()`**
- **Meaning**: Formats a local date and time.
- **Syntax**:
```php
string date(string $format [, int $timestamp = time()])
```
- **Example**:
```php
echo date('Y-m-d H:i:s'); // Outputs current date and time in format YYYY-MM-DD HH:MM:SS
```
### **2. `strtotime()`**
- **Meaning**: Parses an English textual datetime description into a Unix timestamp.
- **Syntax**:
```php
int strtotime(string $time [, int $now = time()])
```
- **Example**:
```php
$timestamp = strtotime("next Monday");
echo date('Y-m-d', $timestamp); // Outputs the date of next Monday
```
### **3. `mktime()`**

- **Meaning**: Returns the Unix timestamp for a date.

- **Syntax**:
```php
int mktime(int $hour = date("H"), int $minute = date("i"), int $second = date("s"), int $month = date("n"), int $day =
date("j"), int $year = date("Y"))
```
- **Example**:
```php
$timestamp = mktime(14, 0, 0, 12, 25, 2024); // Returns timestamp for December 25th, 2024 at 14:00:00
echo date('Y-m-d H:i:s', $timestamp); // Outputs: "2024-12-25 14:00:00"
```
### **4. `date_diff()`**

- **Meaning**: Calculates the difference between two DateTime objects.

- **Syntax**:
```php
DateInterval date_diff(DateTimeInterface $datetime1 , DateTimeInterface $datetime2 [, bool $absolute = false ])
```
- **Example**:
```php
$date1 = new DateTime("2024-01-01");
$date2 = new DateTime("2024-12-31");
$diff = date_diff($date1, $date2);
echo "Difference: " . $diff->format('%R%a days'); // Outputs difference in days
```
### Summary
These functions provide essential tools for working with dates and times in PHP applications, enabling developers to
format dates, calculate intervals, and manipulate timestamps effectively.