PHP

About Technology

The PHP Hypertext Preprocessor (PHP) is a programming language that allows web developers to create dynamic content that interacts with databases. PHP is basically used for developing web based software applications. 

As a programming language for the Web, PHP is hard to ignore. Clean syntax, object-oriented fundamentals, an extensible architecture that encourages innovation, support for both current and upcoming technologies and protocols, and excellent database integration are just some of the reasons for the popularity it currently enjoys in the developer community.

Possibly the best thing about PHP is that it’s free—its source code is freely available on the Web, and developers can install and use it without paying licensing fees or investing in expensive hardware or software. Using PHP can thus significantly reduce the development costs of a software application, without compromising on either reliability or performance. The open-source approach also ensures faster bug fixes and quicker integration of new technologies into the core language, simply due to the much larger base of involved developers.

Audience:

This tutorial is designed for PHP programmers who are completely unaware of PHP concepts but they have basic understanding on computer programming. Before proceeding with this tutorial you should have at least basic understanding of computer programming, Internet, Database, and MySQL etc is very helpful.
Introduction

PHP is a general-purpose scripting language originally standing for "Pretty Good Homepage" designed for web development to produce dynamic web pages. For this purpose, PHP code is embedded into the HTML source document and interpreted by a web server with a PHP processor module, which generates the web page document. It also has evolved to include a command-line interface capability and can be used in standalone graphical applications. PHP can be deployed on most web servers and as a standalone interpreter, on almost every operating system and platform free of charge.PHP is installed on more than 20 million websites and 1 million web servers.

Features :

Simplicity :

Because PHP uses a consistent and logical syntax, and because it comes with a clearly written manual, even novices find it easy to learn. In fact, the quickest way to learn PHP is to step through the manual’s introductory tutorial, and then start looking at code samples off the Web. Within a few hours, you’ll have learned the basics and will be confident enough to begin writing your own scripts. This adherence to the KISS (Keep It Simple, Stupid) principle has made PHP popular as a prototyping and rapid application development tool for web applications. PHP can even access C libraries and take advantage of program

code written for this language, and the language is renowned for the tremendous flexibility it allows programmers in accomplishing specific tasks.

Portability :

With programming languages, portability—the ease with which a program can be made to work on different platforms—is an important factor. PHP users have little to fear here, because cross-platform development has been an important design goal of PHP since PHP 3.0. Today, PHP is available for a wide variety of platforms, including UNIX, Microsoft Windows, Mac OS, and OS/2. Additionally, because PHP code is interpreted and not compiled, PHP scripts written on one platform usually work as is on any other platform for which an interpreter exists. This means that developers can code on Windows and deploy on UNIX without any major difficulties.

Speed :

Out of the box, PHP scripts run faster than most other scripting languages, with numerous independent benchmarks putting the language ahead of competing alternatives like JSP, ASP.NET, and Perl. When PHP 4.0 was first released, it raised the performance bar with its completely new parsing engine. PHP 5.0 improves performance even further through the use of an optimized memory manager, and the use of object handles that reduce memory consumption and help applications run faster.

Open Source :

Possibly the best thing about PHP is that it’s free—its source code is freely available on the Web, and developers can install and use it without paying licensing fees or investing in expensive hardware or software. Using PHP can thus significantly reduce the development costs of a software application, without compromising on either reliability or performance. The open-source approach also ensures faster bug fixes and quicker integration of new technologies into the core language, simply due to the much larger base of involved developers.

Extensible :

Keeping future growth in mind, PHP’s creators built an extensible architecture that enables developers to easily add support for new technologies

to the language through modular extensions. This extensibility keeps PHP fresh and always at the cutting edge of new technology. To illustrate this, consider

what PHP lets you do through its add-on modules: dynamically create image, PDF, and SWF files; connect to IMAP and POP3 servers; interface with MySQL, Oracle, PostgreSQL, and SQLite databases; handle electronic payments; parse XML documents; and execute Perl, Java, and COM code through a PHP script. And as if all that wasn’t enough, there’s also an online repository of free PHP classes called PEAR, the PHP Extension and Application Repository, which provides a source of reusable, bug-free PHP components.

XML and Database Support :

Regardless of whether your web application sources its data from an XML file or a database, PHP has you covered. PHP 5.0 comes with an improved MySQL extension that enables you to take advantage of new features in the MySQL RDBMS (including sub queries, transactions, and referential integrity), and the language also supports DB2, PostgreSQL, Oracle, mSQL, MS-SQL, Informix, Sybase, and SQLite. Alternatively, if it’s XML you’re after, PHP 5.0 offers a completely redesigned XML API built around the libxml2 toolkit; this API supports SAX, DOM, and XSLT, as well as the new SimpleXML and SOAP extensions.

"Hello World" Script in PHP :

To get a feel for PHP, first start with simple PHP scripts. first we will create a friendly little "Hello, World!" script. As mentioned earlier, PHP is embedded in HTML. That means that in amongst your normal HTML you'll have PHP statements like this:

---

It will produce following result:

Hello, World!

---

If you examine the HTML output of the above example, you'll notice that the PHP code is not present in the file sent from the server to yourWeb browser. All of the PHP present in the Web page is processed and stripped from the page; the only thing returned to the client from the Web server

is pure HTML output.

All PHP code must be included inside one of the three special markup tags recognised by the PHP Parser.

PHP Syntax

This section will give you an idea about basic PHP syntax.

Escaping to PHP:

How does the PHP parser recognize PHP code inside your HTML document? The answer is that you tell the program when to spring into action by using special PHP tags at the beginning and end of each PHP section. This process is called escaping from HTML or escaping into PHP.

There are four styles of PHP tags and different rationales for using them. Part of the decision, however, is simply individual preference: what the individual programmer is comfortable with or what a team has decided upon for reasons of their own.

---

Canonical PHP tags :

The most universally effective PHP tag style is:

If you use this style, you can be positive that your tags will always be correctly interpreted.

Short-open (SGML-style) tags :

Short or short-open tags look like this:

Short tags are, as one might expect, the shortest option. Those who escape into and out of HTML frequently in each script will be attracted by the prospect of fewer keystrokes; however, the price of shorter tags is pretty high. You must do one of two things to enable PHP to recognize the tags:

- Choose the --enable-short-tags configuration option when you’re building PHP.

- Set the short_open_tag setting in your php.ini file to on. This option must be disabled to parse XML with PHP because the same syntax is used for XML tags.

ASP-style tags :

ASP-style tags mimic the tags used by Active Server Pages to delineate code blocks. ASP-style tags look like this:

<% ... %>

To use ASP-style tags, you will need to set the configuration option in your php.ini file.

HTML script tags:

HTML script tags look like this:

---

Jumping in and out of PHP mode :

At any given moment in a PHP script, you are either in PHP mode or you’re out of it in HTML. There’s no middle ground. Anything within the PHP tags is PHP; everything outside is plain HTML, as far as the server is concerned. You can escape into PHP mode by using php tags as necessary. For example:

First name:

Last name:

Rank:

”>

Notice that things that happened in the first PHP mode instance — in this case, a variable being assigned — are still valid in the second.

---

Comments in PHP :

A comment is the portion of a program that exists only for the human reader and stripped out before displaying the programs result. There are two commenting formats in PHP:

Single-line comments:

They are generally used for short explanations or notes relevant to the local code. Here are the examples of single line comments.

# 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-lines comments: They are generally used to provide pseudocode algorithms and more detailed explanations when necessary. The multiline style of commenting is the same as in C. Here are the example of multi lines comments. /* This is a comment with multiline Author : Mohammad Mohtashim Purpose: Multiline Comments Demo Subject: PHP */ print "An example with multi line comments"; ?> PHP is whitespace insensitive: Whitespace is the stuff you type that is typically invisible on the screen, including spaces, tabs, and carriage returns (end-of-line characters). PHP whitespace insensitive means that it almost never matters how many whitespace characters you have in a row.one whitespace character is the same as many such characters For example, each of the following PHP statements that assigns the sum of 2 + 2 to the variable $four is equivalent: $four = 2 + 2; // single spaces $four =+2 ; // spaces and tabs $four = 2+ 2; // multiple lines PHP is case sensitive: Yeah it is true that PHP is a case sensitive language. Try out following example: $capital = 100; print("Variable capital is $capital "); print("Variable CaPiTaL is $CaPiTaL "); ?>

This will produce following result:

Variable capital is 100 Variable CaPiTaL is

Statements are expressions terminated by semicolons:

A statement in PHP is any expression that is followed by a semicolon (;).Any sequence of valid PHP statements that is enclosed by the PHP tags is a valid PHP program. Here is a typical statement in PHP, which in this case assigns a string of characters to a variable called $greeting:

$greeting = "Welcome to PHP!";

Expressions are combinations of tokens:

The smallest building blocks of PHP are the indivisible tokens, such as numbers (3.14159), strings (.two.), variables ($two), constants (TRUE), and the special words that make up the syntax of PHP itself like if, else, while, for and so forth

Braces make blocks:

Although statements cannot be combined like expressions, you can always put a sequence of statements anywhere a statement can go by enclosing them in a set of curly braces.

Here both statements are equivalent:

if (3 == 2 + 1) print("Good - I haven't totally lost my mind. "); if (3 == 2 + 1) { print("Good - I haven't totally"); print("lost my mind. "); }

Running PHP Script from Command Prompt:

you can also run your PHP script on your command prompt. Assuming you have following content in test.php file

echo "Hello world !!!"; ?>

Now run this script as command prompt as follows:

$ php test.php

It will produce following result:

Hello world!!!

Variables & Constants

The main way to store information in the middle of a PHP program is by using a variable.

Here are the most important things to know about variables in PHP.

• All variables in PHP are denoted with a leading dollar sign ($).
• The value of a variable is the value of its most recent assignment.
• Variables are assigned with the = operator, with the variable on the left-hand side and the expression to be evaluated on the right.
• Variables can, but do not need, to be declared before assignment.
• Variables in PHP do not have intrinsic types - a variable does not know in advance whether it will be used to store a number or a string of characters.
• Variables used before they are assigned have default values.
• PHP does a good job of automatically converting types from one to another when necessary.
• PHP variables are Perl-like.

PHP has a total of eight data types which we use to construct our variables:

• Integers: are whole numbers, without a decimal point, like 4195.
• Doubles: are floating-point numbers, like 3.14159 or 49.1.
• Booleans: have only two possible values either true or false.
• NULL: is a special type that only has one value: NULL.
• Strings: are sequences of characters, like 'PHP supports string operations.'
• Arrays: are named and indexed collections of other values.
• Objects: are instances of programmer-defined classes, which can package up both other kinds of values and functions that are specific to the class.
• Resources: are special variables that hold references to resources external to PHP (such as database connections).

The first five are simple types, and the next two (arrays and objects) are compound - the compound types can package up other arbitrary values of arbitrary type, whereas the simple types cannot.

We will explain only simple data type in this chapters. Array and Objects will be explained separately.

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).

Doubles:

They like 3.14159 or 49.1. By default, doubles print with the minimum number of decimal places needed. For example, the code:

$many = 2.2888800; $many_2 = 2.2111200; $few = $many + $many_2; print(.$many + $many_2 = $few .);

It produces the following browser output:

2.28888 + 2.21112 = 4.5

Boolean:

They have only two possible values either true or false. PHP provides a couple of constants especially for use as Booleans: TRUE and FALSE, which can be used like so:

if (TRUE) print("This will always print "); else print("This will never print ");

Interpreting other types as Booleans:

Here are the rules for determine the "truth" of any value not already of the Boolean type:

• If the value is a number, it is false if exactly equal to zero and true otherwise.
• If the value is a string, it is false if the string is empty (has zero characters) or is the string "0", and is true otherwise.
• Values of type NULL are always false.
• If the value is an array, it is false if it contains no other values, and it is true otherwise. For an object, containing a value means having a member variable that has been assigned a value.
• Valid resources are true (although some functions that return resources when they are successful will return FALSE when unsuccessful).
• Don't use double as Booleans.

Each of the following variables has the truth value embedded in its name when it is used in a Boolean context.

$true_num = 3 + 0.14159; $true_str = "Tried and true" $true_array[49] = "An array element"; $false_array = array(); $false_null = NULL; $false_num = 999 - 999; $false_str = "";

NULL:

NULL is a special type that only has one value: NULL. To give a variable the NULL value, simply assign it like this:

$my_var = NULL;

The special constant NULL is capitalized by convention, but actually it is case insensitive; you could just as well have typed:

$my_var = null;

A variable that has been assigned NULL has the following properties:

• It evaluates to FALSE in a Boolean context.
• It returns FALSE when tested with IsSet() function.

Strings:

They are sequences of characters, like "PHP supports string operations". Following are valid examples of string

$string_1 = "This is a string in double quotes"; $string_2 = "This is a somewhat longer, singly quoted string"; $string_39 = "This string has thirty-nine characters"; $string_0 = ""; // a string with zero characters

Singly quoted strings are treated almost literally, whereas doubly quoted strings replace variables with their values as well as specially interpreting certain character sequences.

$variable = "name"; $literally = 'My $variable will not print!\\n'; print($literally); $literally = "My $variable will print!\\n"; print($literally); ?>

This will produce following result:

My $variable will not print!\n My name will print

There are no artificial limits on string length - within the bounds of available memory, you ought to be able to make arbitrarily long strings.

Strings that are delimited by double quotes (as in "this") are preprocessed in both the following two ways by PHP:

• Certain character sequences beginning with backslash (\) are replaced with special characters
• Variable names (starting with $) are replaced with string representations of their values.

The escape-sequence replacements are:

• \n is replaced by the newline character
• \r is replaced by the carriage-return character
• \t is replaced by the tab character
• \$ is replaced by the dollar sign itself ($)
• \" is replaced by a single double-quote (")
• \\ is replaced by a single backslash (\)

Here Document:

You can assign multiple lines to a single string variable using here document:

$channel =<<<_xml_ span=""> include_once("menu.php"); ?>

include_once("contant.php");

?>

include_once("footer.php");

?>

Functions in PHP

What is a function?

A function is a way of wrapping up a chunk of code and giving that chunk a name, so that you can use that chunk later in

just one line of code. Functions are most useful when you will be using the code in more than one place, but they can be helpful even

in one-use situations,because they can make your code much more readable.

syntax:

function function-name ($argument-1, $argument-2, ..)

{

statement-1;

statement-2;

...

}

That is, function definitions have four parts:

- The special word function

- The name that you want to give your function

- The function's parameter lists dollar-sign variables separated by commas

- The function body a brace-enclosed set of statements

Examples :

// following are the examples of user-defined functions

// this function is used to find factorial of a given number

function factorial($a)

{

$fact=1;

for($i=$a;$i>=1;$i--)

{

$fact = $fact * $i;

}

return $fact;

}

// --------------------------------------------------//

// This function is used to display fibonacci series

function fibonacci($fibo)

{

$a=1;

$b=0;

$c=0;

echo "Fibonacci No.: ";

for($i=0;$i<=$fibo;$i++)

{

$c=$a+$b;

echo "$c ";

$a=$b;

$b=$c;

}

}

$fac=factorial(5); // function call

echo"Factorial = ".$fac." ";

fibonacci(10); // function call

// --------------------------------------------------//

// This function is used to calculate factorial of a given number using recursion

function fact_recursion($facto)

{

$fa=1;

if($facto == 0)

{

return $fa;

}

else

{

$fa=fact_recursion($facto-1) * $facto;

return $fa;

}

}

function val1() // function shows the return value

{

return 10;

}

$recur=fact_recursion(val1()); // function call

echo "Factorial No. :".$recur;

?>

// function with default values as parameter

function printMe($param = NULL)

{

print $param;

}

printMe("This is test");

printMe();

?>

// ------------------------------------------------//

// Passing arguments by reference

function addFive($num)

{

$num += 5;

}

function addSix(&$num)

{

$num += 6;

}

$orignum = 10;

addFive( &$orignum );

echo "Original Value is $orignum ";

addSix( $orignum );

echo "Original Value is $orignum ";

?>

Cookies in PHP

A cookie is a small piece of information that is retained on the client machine, either in the browser's application memory or as a small file written

to the user's hard disk.

It contains a name/value pair setting a cookie means associating a value with a name and storing that pairing on the client side. Getting or reading

a cookie means using the name to retrieve the value. each browser will typically accept only 20 cookies from each domain before it starts popping old cookie

values off the stack.

cookies are set using the setcookie() function, and cookies are read by superglobal array $_COOKIE, with the cookie name as an index, and the value

it indexes

Syntax :

setcookie(name,value,time,path,domain,secure)

name : The name of the cookie.

value : The value you want to store in the cookie.

time : Specifies when this cookie should expire.

path : In the default case, any page within the Web root folder would see and be able to set this named cookie. Setting the path to a subdirectory

(for example, "/forum/") allows distinguishing cookies that have the same name but are set by different sites or subareas of the Web server.

domain : In the default case, no check is made against the domain requested by the client. If this argument is nonempty, then the domain must match

secure : Defaults to 0. If this argument is 1, the cookie will only be sent over a secure socket (aka SSL or HTTPS) connection.

Example :

setcookie("name", "abcd", time() + (60 * 60), "/", "www.abc.com" , 1 );

Deleting cookies :

Deleting a cookie is easy. Simply call setcookie(), with the exact same arguments as when you set it, except the value, which should be set to an

empty string. This does not set the cookie's value to an empty strings it actually removes the cookie. Remember: If you used the path or domain arguments

to set the cookie, you need to use them to unset the cookie too.

setcookie(name,null,-1)

here, name is the name of the cookie, value set to null and time set to -1 this will delete a perticular cookie

Reading Cookie :

echo $_COOKIE['name'];

$_COOKIE['name'] = value;

$_COOKIE superglobal array is used to access and change the value stored in cookie.

Example of cookie:

This example shows how cookies are implemented in php.

// save the following file as "cookie1.php"

if(isset($_POST['submit']))

{

$user = $_POST['user'];

$color = $_POST['color'];

if( ( $user != null ) and ( $color != null ) )

{

setcookie( "firstname", $user , time() + 500); //set cookie firstname for 500 seconds

setcookie( "fontcolor", $color, time() + 500 );//set cookie fontcolor for 500 seconds

header( "Location: cookie2.php" ); //redirect to cookie2.php page

exit();

}

}

else

{

?>

cookie stuff

---

Please enter your first name:

Please choose your favorite font color:

Red

Green

Blue

---

}

?>

// save following code as "cookie2.php", this shows how to access cookie value

if (isset($_COOKIE['firstname']))

{

$user = $_COOKIE['firstname'];

$color= $_COOKIE['fontcolor'];

}

?>

show cookie stuff

---

Hello:

Your color:

---

// Another way to debug/test is to view all cookies

echo (" ");

echo ("

");

echo ("Cookie info:\n");

print_r($_COOKIE);

echo("

");

?>

Sessions in PHP

A PHP session variable is used to store information about, or change settings for a user session. Session variables hold information about one

single user, and are available to all pages in one application.

PHP Session Variables :

When you are working with an application, you open it, do some changes and then you close it. This is much like a Session. The computer knows

who you are. It knows when you start the application and when you end. But on the internet there is one problem: the web server does not know who you

are and what you do because the HTTP address doesn't maintain state.

A PHP session solves this problem by allowing you to store user information on the server for later use (i.e. username, shopping items, etc).

However, session information is temporary and will be deleted after the user has left the website. If you need a permanent storage you may want to store

the data in a database.

Sessions work by creating a unique id (UID) for each visitor and store variables based on this UID. The UID is either stored in a cookie or is

propagated in the URL.

Starting a PHP Session:

Before you can store user information in your PHP session, you must first start up the session.

The session_start() function must appear BEFORE the tag:

The code above will register the user's session with the server, allow you to start saving user information, and assign a UID for that user's session.

Storing a Session Variable :

The correct way to store and retrieve session variables is to use the PHP $_SESSION variable:

session_start();

// store session data

$_SESSION['views']=1;

?>

//retrieve session data

echo "Pageviews=". $_SESSION['views'];

?>

Output:

Pageviews=1

In the example below, we create a simple page-views counter. The isset() function checks if the "views" variable has already been set.

If "views" has been set, we can increment our counter. If "views" doesn't exist, we create a "views" variable, and set it to 1:

session_start();

if(isset($_SESSION['views']))

$_SESSION['views']=$_SESSION['views']+1;

else

$_SESSION['views']=1;

echo "Views=". $_SESSION['views'];

?>

Destroying a Session :

If you wish to delete some session data, you can use the unset() or the session_destroy() function.

The unset() function is used to free the specified session variable:

unset($_SESSION['views']);

?>

You can also completely destroy the session by calling the session_destroy() function:

session_destroy();

?> 

File Uploads

A PHP script can be used with a HTML form to allow users to upload files to the server. Initially files are uploaded into a temporary directory and then relocated to a target destination by a PHP script.

- make a file upload_file.php, used to submit the file

enctype="multipart/form-data">

Filename:

- now make upload.php file to handle the file upload.

- The code fragment below shows you how to upload a perticular file on server.

// this code can only accept gif,jpeg and pjpeg files and also having the length less then 50kb.

if ((($_FILES["file"]["type"] == "image/gif")

|| ($_FILES["file"]["type"] == "image/jpeg")

|| ($_FILES["file"]["type"] == "image/pjpeg"))

&& ($_FILES["file"]["size"] < 50000)

)

{

if ($_FILES["file"]["error"] > 0)

{

echo "Return Code: " . $_FILES["file"]["error"] . " ";

}

else

{

echo "Upload: " . $_FILES["file"]["name"] . " ";

echo "Type: " . $_FILES["file"]["type"] . " ";

echo "Size: " . ($_FILES["file"]["size"] / 1024) . " Kb ";

echo "Temp file: " . $_FILES["file"]["tmp_name"] . " ";

if (file_exists("up/" . $_FILES["file"]["name"]))

{

echo $_FILES["file"]["name"] . " already exists. ";

}

else

{

move_uploaded_file($_FILES["file"]["tmp_name"],"up/".$_FILES["file"]["name"]);

echo "Stored in : " . "up/" . $_FILES["file"]["name"];

}

}

}

else

{

echo "Invalid file";

}

?>

Notice the following about the HTML form above:

* The enctype attribute of the

tag specifies which content-type to use when submitting the form. "multipart/form-data" is used when a form

requires binary data, like the contents of a file, to be uploaded

* The type="file" attribute of the tag specifies that the input should be processed as a file. For example, when viewed in a browser, there will be

a browse-button next to the input field

By using the global PHP $_FILES array you can upload files from a client computer to the remote server.

The first parameter is the form's input name and the second index can be either "name", "type", "size", "tmp_name" or "error". Like this:

* $_FILES["file"]["name"] - the name of the uploaded file

* $_FILES["file"]["type"] - the type of the uploaded file

* $_FILES["file"]["size"] - the size in bytes of the uploaded file

* $_FILES["file"]["tmp_name"] - the name of the temporary copy of the file stored on the server

* $_FILES["file"]["error"] - the error code resulting from the file upload.