IT Chap 9

Server-Side Technologies
PHP, which stands for "Hypertext Preprocessor," is a widely-used open-source server-side

scripting language designed for web development. It can also be used as a general-purpose
programming language. Here’s an overview of PHP:
Key Features of PHP:
1. Server-Side Scripting:
o PHP is executed on the server, and the result is sent to the client’s web
browser as plain HTML.
o It integrates seamlessly with HTML, making it easy to add dynamic content to
web pages.
2. Ease of Use:
o PHP is relatively easy to learn and use, even for those new to programming.
o Its syntax is similar to C, Java, and Perl, which can be familiar to many
developers.
3. Platform Independence:
o PHP scripts can run on any major operating system, including Linux,
Windows, macOS, and Unix.
o It supports a wide range of web servers, such as Apache, IIS, and more.
4. Database Integration:
o PHP has built-in support for popular databases like MySQL, PostgreSQL,
Oracle, Microsoft SQL Server, and more.
o This makes it easy to create database-driven web applications.
5. Performance:
o PHP is known for its speed and efficiency in generating dynamic web content.
o It can handle large-scale applications and high-traffic websites.
6. Extensive Library of Functions:
o PHP has a vast array of built-in functions that simplify common web
development tasks, such as handling forms, sending emails, and manipulating
files.
7. Community and Support:
o PHP has a large and active community of developers who contribute to its
continuous improvement.
o There are abundant resources, tutorials, and frameworks available to help
developers learn and work with PHP.
Common Uses of PHP:
1. Web Development:
o Creating dynamic and interactive web pages.
o Developing content management systems (CMS) like WordPress, Joomla, and
Drupal.
2. E-commerce:
o Building online stores and shopping carts.
o Integrating payment gateways and handling transactions.
3. Web Applications:
o Developing various web applications, from small websites to large enterprise
solutions.
oExamples include social networking sites, forums, and customer relationship
management (CRM) systems.
4. APIs and Web Services:
o Creating and consuming RESTful and SOAP APIs.
o Integrating with third-party services and applications.
Example PHP Code:

php
<?php
echo "Hello, World!";
?>
This simple example demonstrates how PHP code is embedded within HTML. When the
server processes this script, it outputs "Hello, World!" to the web page.
PHP works by executing code on the server side and then sending the generated HTML to the
client's browser. Here’s a step-by-step explanation of how PHP works:
1. Client Requests a Web Page:
When a user requests a web page (e.g., by entering a URL in the browser or clicking a link),
the browser sends an HTTP request to the web server hosting the website.
2. Server Receives the Request:
The web server receives the request and determines that it needs to handle a PHP file (e.g.,
index.php).
3. PHP Interpreter Processes the Script:
The server passes the PHP file to the PHP interpreter. The interpreter processes the PHP code
in the file. This can include:
• Executing PHP code.

• Interacting with databases (e.g., MySQL).
• Performing calculations.
• Accessing and manipulating files.
• Sending and receiving cookies and session data.
4. Generating HTML Output:
The PHP code generates HTML (and possibly other types of) output. The PHP interpreter
combines the PHP-generated content with any static HTML in the file to produce the final
HTML content.
5. Sending the Response:

The server sends the generated HTML content back to the client's browser as the HTTP
response. The browser then renders the HTML, displaying the web page to the user.
Example Workflow:
Let's look at a simple PHP script example to illustrate this process:
PHP Script (index.php):
php
<!DOCTYPE html>
<html>
<head>
<title>My PHP Page</title>
</head>
<body>
<h1>Welcome to My Website</h1>
<?php
// This PHP code is executed on the server
echo "Today's date is " . date('Y-m-d');
?>
</body>
</html>
Step-by-Step Execution:
1. Client Request: The user requests http://example.com/index.php.

2. Server Receives Request: The web server recognizes the .php extension and passes
the file to the PHP interpreter.
3. PHP Interpreter:
o Reads the file and sees HTML content first, which it keeps as is.
o Encounters the PHP code <?php echo "Today's date is " . date('Y-m-
d'); ?>.
o Executes the date('Y-m-d') function to get the current date.
o Concatenates the date string to "Today's date is ".
o Replaces the PHP block with the result, e.g., "Today's date is 2024-06-25".
4. HTML Output: The PHP interpreter produces the following HTML:
html
<!DOCTYPE html>
<html>
<head>
<title>My PHP Page</title>
</head>
<body>
<h1>Welcome to My Website</h1>
Today's date is 2024-06-25
</body>
</html>
5. Response to Client: The web server sends this final HTML output to the client's
browser.
6. Browser Renders Page: The user's browser renders the HTML and displays the web
page with the dynamic date.
PHP Syntax
PHP syntax is designed to be embedded within HTML, allowing for dynamic content
generation. Here are the basics of PHP syntax:
1. PHP Tags:
o PHP code is enclosed within <?php ... ?> tags.
o Short tags <? ... ?> and <?= ... ?> (for echoing values) are also available
but may require configuration in the PHP.ini file.
2. Basic Structure:
o PHP statements end with a semicolon ;.
o PHP is case-sensitive for variables but not for keywords and function names.
3. Comments:
o Single-line comments: // or #
o Multi-line comments: /* ... */
4. Variables:
o Variables in PHP start with a dollar sign $ followed by the variable name.
o Variable names are case-sensitive.
5. Data Types:
o PHP supports several data types, including integers, floats, strings, arrays,
objects, and booleans.
6. Echo and Print:
o echo and print are used to output data to the browser.
PHP File Example
Let’s create a simple PHP file to illustrate PHP syntax and embedding within HTML.
Example: simple_page.php
php
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>PHP Syntax Example</title>
</head>
<body>
<h1>Welcome to My PHP Page</h1>
<?php
// Single-line comment: Define variables
$greeting = "Hello, World!";
$year = date("Y"); // Get the current year
/*
* Multi-line comment:
* Output variables
*/
echo "<p>$greeting</p>";
echo "<p>Current year is $year</p>";
// Basic arithmetic
$a = 10;
$b = 20;
$sum = $a + $b;
echo "<p>The sum of $a and $b is $sum</p>";
// Conditional statement
if ($year % 4 == 0) {
echo "<p>$year is a leap year.</p>";
} else {
echo "<p>$year is not a leap year.</p>";
}
// Loop
echo "<ul>";
for ($i = 1; $i <= 5; $i++) {
echo "<li>Item $i</li>";
}
echo "</ul>";
?>
</body>
</html>
Explanation of the Example:
1. HTML Structure:
o The HTML structure includes a <!DOCTYPE html> declaration, and elements
like <html>, <head>, <title>, and <body>.
2. Embedding PHP:
o PHP code is embedded within the HTML using <?php ... ?> tags.
3. Variables:
o $greeting and $year are variables. $year is set using the date function to
get the current year.
4. Output with Echo:
o echo is used to output HTML content. Variables are included within strings
using double quotes.
5. Arithmetic Operations:
o Basic arithmetic operations are performed and the result is output.
6. Conditional Statements:
o An if statement checks if the year is a leap year and outputs the result
accordingly.
7. Looping:
o A for loop generates a list of items.
Running the PHP File
To run the PHP file:
1. Save the file with a .php extension (e.g., simple_page.php).

2. Place the file in the document root directory of your PHP-enabled web server (e.g.,
htdocs for XAMPP, www for WAMP).
3. Open a web browser and navigate to http://localhost/simple_page.php
PHP Syntax, Rules, and Conventions
1. PHP Tags
PHP code is enclosed within special tags. The most common tags are:
php
<?php
// PHP code here
?>
Short tags can also be used, but they are not always enabled by default:
php
<?
// PHP code here
?>
For echoing out variables, short echo tags can be used:
php
<?= $variable; ?>

2. Case Sensitivity
• PHP variable names are case-sensitive:
php
$variable = "Hello";
echo $Variable; // This will produce an error
• PHP keywords, functions, and class names are not case-sensitive:
php
ECHO "Hello, world!";

echo "Hello, world!";
Echo "Hello, world!";
3. Statements and Semicolons
Each statement ends with a semicolon:
php
echo "Hello, world!";

4. Comments
Comments in PHP can be single-line or multi-line:

php
// This is a single-line comment

# This is also a single-line comment
/*
This is a multi-line comment
*/
5. Variables
Variables in PHP start with a dollar sign ($) and are assigned using the equals sign (=):
php
$variable = "Hello, world!";
Variable names must start with a letter or an underscore, followed by any number of letters,
numbers, or underscores.
6. Data Types
PHP supports various data types including strings, integers, floats, arrays, objects, null, and
booleans.
• String:
php
$string = "Hello, world!";
• Integer:
php
$integer = 42;
• Float:
php
$float = 3.14;
• Boolean:
php
$boolean = true;
• Array:
php
$array = array("foo", "bar", "baz");
• Object:
php
class MyClass {
public $property = "Hello, world!";
}
$object = new MyClass();
• Null:
php
$null = null;
7. String Interpolation
Double-quoted strings support variable interpolation:
php
$name = "John";
echo "Hello, $name!"; // Outputs: Hello, John!
Single-quoted strings do not:
php
echo 'Hello, $name!'; // Outputs: Hello, $name!

8. Operators
• Arithmetic Operators: +, -, *, /, %
• Assignment Operators: =, +=, -=, *=, /=, %=
• Comparison Operators: ==, !=, ===, !==, <, >, <=, >=
• Logical Operators: &&, ||, !
9. Control Structures
• If-Else:
php
if ($a > $b) {

echo "a is greater than b";
} else {
echo "a is not greater than b";
}
• Switch:
php
switch ($color) {
case "red":
echo "The color is red";
break;
case "blue":
echo "The color is blue";
break;
default:
echo "The color is neither red nor blue";
}
• For Loop:
php
for ($i = 0; $i < 10; $i++) {

echo $i;
}
• While Loop:
php
$i = 0;
while ($i < 10) {
echo $i;
$i++;
}
• Do-While Loop:
php
$i = 0;
do {
echo $i;
$i++;
} while ($i < 10);
10. Functions
Functions are defined using the function keyword:
php
function myFunction($parameter) {
return "Hello, " . $parameter;
}
echo myFunction("world"); // Outputs: Hello, world
11. Classes and Objects
Classes are defined using the class keyword:
php
class MyClass {
public $property = "Hello, world!";
public function myMethod() {
return $this->property;
}
}
$object = new MyClass();
echo $object->myMethod(); // Outputs: Hello, world!
12. Including Files
PHP allows including files using include, include_once, require, and require_once:
php
include 'file.php';
require 'file.php';
The _once versions ensure the file is included only once.
13. Error Handling
Basic error handling can be done using try and catch:
php
try {
// Code that may throw an exception
throw new Exception("An error occurred");
} catch (Exception $e) {
echo 'Caught exception: ', $e->getMessage(), "\n";
}
14. Coding Standards
• Use camelCase for variables and function names:
php
$myVariable = "value";
function myFunction() {}
• Use PascalCase for class names:
php
class MyClass {}
• Use proper indentation (typically 4 spaces):
php
if ($condition) {
echo "True";
}
Variables in PHP
1. Declaring Variables
In PHP, variables are declared with a dollar sign ($) followed by the variable name:
php
$variableName = "Hello, World!";
2. Naming Conventions
Variable names in PHP must follow these rules:
• Must start with a letter or an underscore (_).

• Can contain letters, numbers, and underscores.
• Are case-sensitive ($variable and $Variable are different).
php
$validName = "John";
$_validName = "Jane";
$valid123 = "Doe";
3. Assigning Values
Variables can store different types of values, such as strings, numbers, arrays, objects, and
booleans.
php
$string = "Hello, World!"; // String

$integer = 42; // Integer
$float = 3.14; // Float
$boolean = true; // Boolean
$array = array("Apple", "Banana", "Cherry"); // Array
Constants in PHP
Constants in PHP are like variables, but once they are defined, their value cannot be changed.
They are used for values that remain constant throughout the execution of the script.
1. Defining Constants
Constants are defined using the define() function or the const keyword.
• Using define():
php
define("CONSTANT_NAME", "value");
• Using const (only for class constants or when defining outside of functions):
php
const CONSTANT_NAME = "value";
2. Naming Conventions
• Constant names should be in uppercase letters to distinguish them from variables.

• They can start with a letter or an underscore, but not a number.
• They can contain letters, numbers, and underscores.
php
define("SITE_NAME", "My Website");
const MAX_USERS = 100;
Node.js
Features of Node.js
1. Event-Driven and Asynchronous:

o Node.js uses an event-driven, non-blocking I/O model which makes it lightweight
and efficient.
o It handles multiple requests concurrently without waiting for any function to return.
2. Single-Threaded:
o It operates on a single thread using non-blocking I/O calls, which allows it to handle
thousands of concurrent connections.
3. Fast Execution:
o Built on Google Chrome’s V8 JavaScript engine, Node.js executes JavaScript code
very fast.
4. Scalability:
o It supports scaling through the Cluster module, allowing the application to be split
across multiple CPU cores.
5. NPM (Node Package Manager):
o A large ecosystem of open-source libraries that are available for use.
6. Cross-Platform:
o Node.js can be run on various platforms like Windows, Linux, and macOS.
Working of Node.js
• Event Loop:
o Node.js handles I/O operations using a single-threaded event loop, allowing it to
perform non-blocking I/O operations.
• Callback Functions:
o Asynchronous functions use callbacks to signal the completion of an operation.
• Non-blocking I/O:
o Operations like reading/writing to the file system, network calls, etc., do not block
the execution of the program.
Comparison between PHP and Node.js

Feature Node.js PHP
Execution Model Asynchronous and event-driven Synchronous and multi-threaded
Performance Generally faster due to non-blocking I/O Slower for I/O operations
Easier setup with built-in web

Server Setup Requires more setup and configuration
server
Feature Node.js PHP
Real-time Apps Excellent for real-time applications Less suitable for real-time apps
Language JavaScript PHP
Package
NPM Composer
Manager
Growing, strong in real-time and single-page Mature, strong in traditional web

Community
apps apps
Installation of Node.js
1. Windows:
o Download the installer from Node.js official website.
o Run the installer and follow the prompts.
2. macOS:
o Use Homebrew:
sh
brew install node
3. Linux:
o Use package manager, for example, on Ubuntu:
sh
sudo apt update

sudo apt install nodejs
sudo apt install npm
Creating an Application in Node.js
1. Initialize a project:
sh
mkdir myapp
cd myapp
npm init -y
2. Install Express (a popular framework):
sh
npm install express
3. Create a simple server:
javascript
// index.js
const express = require('express');
const app = express();
const port = 3000;
app.get('/', (req, res) => {

res.send('Hello World!');
});
app.listen(port, () => {
console.log(`Example app listening at http://localhost:${port}`);
});
4. Run the application:
sh
node index.js
Advantages of Node.js
1. High Performance:
o Node.js is fast for I/O operations due to its non-blocking architecture.
2. Scalability:
o It scales well, handling a large number of concurrent connections efficiently.
3. Active Community:
o A large and active community contributing to a vast number of libraries and
frameworks.
4. JavaScript Everywhere:
o Unified language for both client and server-side scripting.
5. Real-time Applications:
o Excellent for real-time applications like chat applications, online gaming, etc.
Disadvantages of Node.js
1. Single-Threaded:
o Not suitable for CPU-intensive applications because a single thread can handle only
one operation at a time.
2. Callback Hell:
o Extensive use of callbacks can lead to deeply nested and hard-to-maintain code.
3. Maturity of Tools:
o Some tools and libraries in the Node.js ecosystem are still maturing compared to
other ecosystems.
Example Application
Here's a simple example of a RESTful API in Node.js using Express:
1. Project Setup:
sh
mkdir restapi
cd restapi
npm init -y
npm install express
2. Create the server:
javascript
// server.js
const express = require('express');
const app = express();
const port = 3000;
// Middleware to parse JSON bodies

app.use(express.json());
// In-memory data store

let users = [
{ id: 1, name: 'Alice' },
{ id: 2, name: 'Bob' }
];
// Get all users

app.get('/users', (req, res) => {
res.json(users);
});
// Get user by ID
app.get('/users/:id', (req, res) => {
const user = users.find(u => u.id === parseInt(req.params.id));
if (user) {
res.json(user);
} else {
res.status(404).send('User not found');
}
});
// Create a new user

app.post('/users', (req, res) => {
const newUser = {
id: users.length + 1,
name: req.body.name
};
users.push(newUser);
res.status(201).json(newUser);
});
// Start the server

app.listen(port, () => {
console.log(`Server running at http://localhost:${port}`);
});
3. Run the application:
sh
node server.js

IT Chap 9

Uploaded by

Copyright:

Available Formats

IT Chap 9

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

IT Chap 9

Uploaded by

Copyright:

Available Formats

Server-Side Technologies

PHP, which stands for "Hypertext Preprocessor," is a widely-used open-source server-side

Key Features of PHP:

Common Uses of PHP:

Example PHP Code:

1. Client Requests a Web Page:

2. Server Receives the Request:

3. PHP Interpreter Processes the Script:

• Executing PHP code.

4. Generating HTML Output:

5. Sending the Response:

Let's look at a simple PHP script example to illustrate this process:

PHP Script (index.php):

1. Client Request: The user requests http://example.com/index.php.

PHP File Example

Explanation of the Example:

Running the PHP File

To run the PHP file:

1. Save the file with a .php extension (e.g., simple_page.php).

For echoing out variables, short echo tags can be used:

<?= $variable; ?>

• PHP variable names are case-sensitive:

• PHP keywords, functions, and class names are not case-sensitive:

ECHO "Hello, world!";

Each statement ends with a semicolon:

echo "Hello, world!";

Comments in PHP can be single-line or multi-line:

// This is a single-line comment

$variable = "Hello, world!";

$string = "Hello, world!";

$array = array("foo", "bar", "baz");

Double-quoted strings support variable interpolation:

Single-quoted strings do not:

echo 'Hello, $name!'; // Outputs: Hello, $name!

if ($a > $b) {

for ($i = 0; $i < 10; $i++) {

Functions are defined using the function keyword:

Classes are defined using the class keyword:

The _once versions ensure the file is included only once.

13. Error Handling

Basic error handling can be done using try and catch:

• Use camelCase for variables and function names:

• Use PascalCase for class names:

• Use proper indentation (typically 4 spaces):

Variable names in PHP must follow these rules:

• Must start with a letter or an underscore (_).

$string = "Hello, World!"; // String

• Constant names should be in uppercase letters to distinguish them from variables.

1. Event-Driven and Asynchronous:

Comparison between PHP and Node.js

Execution Model Asynchronous and event-driven Synchronous and multi-threaded

Easier setup with built-in web

Language JavaScript PHP

Growing, strong in real-time and single-page Mature, strong in traditional web

brew install node

sudo apt update

2. Install Express (a popular framework):

npm install express

3. Create a simple server: