PHP Scripts, User Based Scripts, Link Based Scripts, URL Based Scripts, Form Based Scripts

Resize Image in PHP

2009-05-25T11:03:00.003-07:00

Format File Size

2009-05-25T11:03:00.001-07:00

Get the list of folders and/or Files

2009-05-25T11:02:00.003-07:00

How to Strip file Extension

2009-05-25T11:02:00.001-07:00

function strip_ext($name)
{
$ext = strrchr($name, '.');

if($ext !== false)
{
$name = substr($name, 0, -strlen($ext));
}

return $name;
}

// demonstration
$filename = 'file_name.txt';
echo strip_ext($filename)."n";

// to get the file extension, do
echo end(explode('.',$filename))."n";
?>

Simple function to read directory contents

2009-05-25T11:01:00.003-07:00

/*
** Function: dir_list (PHP)
** Desc: Simple function to read directory contents
** Example: dir_list('data/');
** Author: Jonas John
*/

function dir_list($path){

$files = array();

if (is_dir($path)){
$handle = opendir($path);
while ($file = readdir($handle)) {
if ($file[0] == '.'){ continue; }

if (is_file($path.$file)){
$files[] = $file;
}
}
closedir($handle);
sort($files);
}

return $files;

}
?>

Compressing Zip file in PHP

2009-05-25T11:01:00.001-07:00

Format US phone number

2009-05-25T11:00:00.003-07:00

// Format US phone number
function formatPhoneNumber($strPhone)
{
$strPhone = ereg_replace("[^0-9]",'', $strPhone);
if (strlen($strPhone) != 10)
{
return $strPhone;
}

$strArea = substr($strPhone, 0, 3);
$strPrefix = substr($strPhone, 3, 3);
$strNumber = substr($strPhone, 6, 4);

$strPhone = "(".$strArea.") ".$strPrefix."-".$strNumber;

return ($strPhone);
}
?>

Shows how to use the build-in function "wordwrap" to create line breaks by a user definied length.

2009-05-25T11:00:00.001-07:00

/*
** Function: wordwrap example (PHP)
** Desc: Shows how to use the build-in function "wordwrap" to create line breaks by a user definied length.
** Example: see below
** Author: Jonas John
*/

// create a long text for testing:
$long_text = 'This is a long text to demonstrate the usage of the ';
$long_text .= 'wordwrap function. ';
$long_text .= 'Fooooooooooooooooobar, just fooling around';

// syntax: wordwrap(input string, line max. width, break chars, cut words)
$new_text = wordwrap($long_text, 15, "
\n", true);

print $new_text;

/*
The output will be:

This is a long

text to

demonstrate the

usage of the

wordwrap

function.

Foooooooooooooo

ooobar, just

fooling around
*/

?>

How to use the similar_text function to compare similar words

2009-05-25T10:59:00.001-07:00

/*
** Function: similar_text (PHP)
** Desc: Shows how to use the similar_text() function to compare similar words.It returns how similar the words are.
** Example: see below
** Author: Jonas John
*/

$word2compare = "stupid";

$words = array(
'stupid',
'stu and pid',
'hello',
'foobar',
'stpid',
'upid',
'stuuupid',
'sstuuupiiid',
);

while(list($id, $str) = each($words))
{
similar_text($str, $word2compare, $percent);

print "Comparing '$word2compare' with '$str': ";
print round($percent) . "%\n";
}

/*
Results:

Comparing 'stupid' with 'stupid': 100%
Comparing 'stupid' with 'stu and pid': 71%
Comparing 'stupid' with 'hello': 0%
Comparing 'stupid' with 'foobar': 0%
Comparing 'stupid' with 'stpid': 91%
Comparing 'stupid' with 'upid': 80%
Comparing 'stupid' with 'stuuupid': 86%
Comparing 'stupid' with 'sstuuupiiid': 71%
*/

?>

Use the soundex() function to test if words sound similar

2009-05-25T10:58:00.000-07:00

/*
** Function: soundex (PHP)
** Desc: Shows how to use the soundex() function to test if words sounds similar.
** Example: see below
** Author: Jonas John
*/

$word2find = 'stupid';

$words = array(
'stupid',
'stu and pid',
'hello',
'foobar',
'stpid',
'supid',
'stuuupid',
'sstuuupiiid',
);

while(list($id, $str) = each($words))
{
$soundex_code = soundex($str);

if (soundex($word2find) == $soundex_code)
{
print '"' . $word2find . '" sounds like ' . $str;
}
else {
print '"' . $word2find . '" sounds not like ' . $str;
}

print "\n";
}

/*
result:

"stupid" sounds like stupid
"stupid" sounds not like stu and pid
"stupid" sounds not like hello
"stupid" sounds not like foobar
"stupid" sounds like stpid
"stupid" sounds not like supid
"stupid" sounds like stuuupid
"stupid" sounds like sstuuupiiid
*/

?>

perg_replace technique

2009-05-25T10:57:00.003-07:00

/*
This is a useful technique for passing matched data into other
functions to be evaluated and replaced in parsed strings.

This example is simple. It rewrites the tag emulating being
passed thru a proxy.
*/

$html = file_get_contents('http://www.yahoo.com/');
print "$html

";
$attr= 'src';
$webroot='proxy';
$html=preg_replace('/(\s)?'.$attr.'="([^\s]*?)"/ei',
"make_new_img_tag('$attr','$2','$1','$webroot');",
$html);
print "";

function make_new_img_tag($attr, $filename, $prefix, $webroot) {
$b64val = base64_encode($filename);
return $prefix$attr.'="'.$webroot.'/browse/'.$b64val.'"';
}
?>

Checks whether $string begins with $search

2009-05-25T10:57:00.001-07:00

// Checks whether $string begins with $search
function string_begins_with($string, $search)
{
return (strncmp($string, $search, strlen($search)) == 0);
}
?>

Make String usable as a URI

2009-05-25T10:56:00.001-07:00

function dirify($s) {
$s = convert_high_ascii($s); ## convert high-ASCII chars to 7bit.
$s = strtolower($s); ## lower-case.
$s = strip_tags($s); ## remove HTML tags.
$s = preg_replace('!&[^;\s]+;!','',$s); ## remove HTML entities.
$s = preg_replace('![^\w\s.]!','',$s); ## remove non-word/space/period chars.
$s = preg_replace('!\s+!','-',$s); ## change space chars to dashes.
return $s;
}

function convert_high_ascii($s) {
$HighASCII = array(
"!\xc0!" => 'A', # A`
"!\xe0!" => 'a', # a`
"!\xc1!" => 'A', # A'
"!\xe1!" => 'a', # a'
"!\xc2!" => 'A', # A^
"!\xe2!" => 'a', # a^
"!\xc4!" => 'Ae', # A:
"!\xe4!" => 'ae', # a:
"!\xc3!" => 'A', # A~
"!\xe3!" => 'a', # a~
"!\xc8!" => 'E', # E`
"!\xe8!" => 'e', # e`
"!\xc9!" => 'E', # E'
"!\xe9!" => 'e', # e'
"!\xca!" => 'E', # E^
"!\xea!" => 'e', # e^
"!\xcb!" => 'Ee', # E:
"!\xeb!" => 'ee', # e:
"!\xcc!" => 'I', # I`
"!\xec!" => 'i', # i`
"!\xcd!" => 'I', # I'
"!\xed!" => 'i', # i'
"!\xce!" => 'I', # I^
"!\xee!" => 'i', # i^
"!\xcf!" => 'Ie', # I:
"!\xef!" => 'ie', # i:
"!\xd2!" => 'O', # O`
"!\xf2!" => 'o', # o`
"!\xd3!" => 'O', # O'
"!\xf3!" => 'o', # o'
"!\xd4!" => 'O', # O^
"!\xf4!" => 'o', # o^
"!\xd6!" => 'Oe', # O:
"!\xf6!" => 'oe', # o:
"!\xd5!" => 'O', # O~
"!\xf5!" => 'o', # o~
"!\xd8!" => 'Oe', # O/
"!\xf8!" => 'oe', # o/
"!\xd9!" => 'U', # U`
"!\xf9!" => 'u', # u`
"!\xda!" => 'U', # U'
"!\xfa!" => 'u', # u'
"!\xdb!" => 'U', # U^
"!\xfb!" => 'u', # u^
"!\xdc!" => 'Ue', # U:
"!\xfc!" => 'ue', # u:
"!\xc7!" => 'C', # ,C
"!\xe7!" => 'c', # ,c
"!\xd1!" => 'N', # N~
"!\xf1!" => 'n', # n~
"!\xdf!" => 'ss'
);
$find = array_keys($HighASCII);
$replace = array_values($HighASCII);
$s = preg_replace($find,$replace,$s);
return $s;
}

?>

Convert String to HEX

2009-05-25T10:55:00.000-07:00

Convert Hex to String

2009-05-25T10:54:00.000-07:00

function hex2string($hex)
{
$string = NULL;
$hex = str_replace(array("\n","\r"), "", $hex);
for ($i=0; $i < $strlen($hex);$i++)
{
$string.= chr(hexdec(substr($hex, $i, 2)));
}
return $string;
}
?>

PHP Text Spell Checker

2009-05-25T10:51:00.000-07:00

// 2002-10-10 by Chris Snyder
// this script uses aspell, but not the internal php spelling functions which are somewhat crippled by only being able to check words, not whole documents (as of ~php 4.2.2)
// requires that aspell be installed and working at /usr/local/bin/aspell -- see http://aspell.sourceforge.net/

// 2003-01-19 -- updated tempfile to use PHP's tempfile creation mech., also bumped year
// 2003-01-24 -- fixed bug that caused improper handling of words with no suggested corrections (thanks, Dekeyzer Stephane!)
// 2003-05-06 -- fixed a bug causing bad things to happen when multiple instances of incorrect words were found on any given line (thanks, Dallas Brown!)
// -- also fixed script so that $opener and $closer work for custom labeling of errors (thanks again, Dallas Brown!)

/*
spellcheck.php -- aspell-based spellchecker implemented in PHP
Copyright (C) 2003 by Chris Snyder (csnyder@chxo.com)

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/

$text= $_POST['text'];
$showsource= $_GET['showsource'];

//
// file paths and the aspell command have moved down below line 58
//

// show source code part I
if ($showsource) $sourceinfo= "Script: $_SERVER[SCRIPT_FILENAME] ( source code )";
else $sourceinfo= "show PHP source code";
if (trim($text)!="") {
$showsource= 0;
$sourceinfo= "";
}

print "

$uripath

Spell Check Some Text

$sourceinfo

";

// if text+check is supplied, first open and create $temptext, then spell check
if (trim($text)!="" && ($_POST['submit']=="check" || $_POST['submit']=="re-check")) {

// HERE'S WHERE YOU MIGHT NEED TO CHANGE FILE PATHS, etc.
//
// set up some vars and create a tempfile
// tempnam() is a PHP function that creates a unique tempfile in the specified path,
// with the specified prefix
$temptext= tempnam("/tmp", "spelltext");

// if you spellcheck alot of HTML, add the -H flag to aspell to put it in SGML mode
$aspellcommand= "cat $temptext | /usr/local/bin/aspell -a";

// these three determine how errors are flagged ($indicator is a description of what $opener and $closer do)
$indicator= "bold";
$opener= "";
$closer= "";
//
// END OF CONFIGURATION

if ($fd=fopen($temptext,"w")) {
$textarray= explode("\n",$text);
fwrite($fd,"!\n");
foreach($textarray as $key=>$value) {
// adding the carat to each line prevents the use of aspell commands within the text...
fwrite($fd,"^$value\n");
}
fclose($fd);

// next create tempdict and temprepl (skipping for now...)

// next run aspell
$return= shell_exec($aspellcommand);

// now unlink that tempfile
$ureturn= unlink($temptext);

//next parse $return and $text line by line, eh?
$returnarray= explode("\n",$return);
$returnlines= count($returnarray);
$textlines= count($textarray);

//print "text has $textlines lines and return has $returnlines lines.";
$lineindex= -1;
$poscorrect= 0;
$counter= 0;
foreach($returnarray as $key=>$value) {
// if there is a correction here, processes it, else move the $textarray pointer to the next line
if (substr($value,0,1)=="&") {
//print "Line $lineindex correction:".$value."
";
$correction= explode(" ",$value);
$word= $correction[1];
$absposition= substr($correction[3],0,-1)-1;
$position= $absposition+$poscorrect;
$niceposition= $lineindex.",".$absposition;
$suggstart= strpos($value,":")+2;
$suggestions= substr($value,$suggstart);
$suggestionarray= explode(", ",$suggestions);
//print "I found $word at $position. Will suggest $suggestions.
";

// highlight in text
$beforeword= substr($textarray[$lineindex],0,$position);
$afterword= substr($textarray[$lineindex],$position+strlen($word));
$textarray[$lineindex]= $beforeword."$opener$word$closer".$afterword;

// kludge for multiple words in one line ("" adds 7 chars to subsequent positions, for instance)
$poscorrect= $poscorrect+strlen("$opener$closer");

// build the correction form
$counter= $counter+1;
$formbody.= "
$word

";
}

elseif (substr($value,0,1)=="#") {
//print "Line $lineindex unknown:".$value."
";
$correction= explode(" ",$value);
$word= $correction[1];
$absposition= $correction[2] - 1;
$position= $absposition+$poscorrect;
$niceposition= $lineindex.",".$absposition;
$suggestions= "no suggestions";
$suggestionarray= explode(", ",$suggestions);
//print "I found $word at $position. Will suggest $suggestions.
";

// highlight in text
$beforeword= substr($textarray[$lineindex],0,$position);
$afterword= substr($textarray[$lineindex],$position+strlen($word));
$textarray[$lineindex]= $beforeword."$opener$word$closer".$afterword;

// kludge for multiple words in one line ("" adds 7 chars to subsequent positions)
$poscorrect= $poscorrect+strlen("$opener$closer");

// build the correction form
$counter= $counter+1;
$formbody.= "
$word

";
}

else {
//print "Done with line $lineindex, next line...

";
$poscorrect=0;
$lineindex= $lineindex+1;
}
}
}
print "

Uncorrected Text (potential errors in $opener$indicator$closer):

";
foreach ($textarray as $key=>$value) {
print $value."
";
}
print "

";

$htmltext= htmlentities($text);
if ($formbody=="") $formbody= "
No errors!
Click 'correct' to continue with text unchanged.
";
print "

Correction form:

";

//print "

Return:".nl2br($return);
}

// or if text+correct is specified, make the indicated corrections
elseif (trim($text)!="" && $_POST['submit']=="correct") {
$textarray= explode("\n",$text);

$index= 1;
$lastlineindex= 0;
$poscorrect= 0;

// look through list of positions and make corrections
while (isset($_POST["position$index"])) {
$positionarray= explode(",",$_POST["position$index"]);
$lineindex= $positionarray[0];
$absposition= $positionarray[1];

if ($lastlineindex==$lineindex) {
$position= $absposition+$poscorrect;
}
else {
$poscorrect= 0;
$position= $absposition;
}
$lastlineindex= $lineindex;
$correct= $_POST["correct$index"];
$incorrect= $_POST["incorrect$index"];
//print "Found correction at $lineindex,$absposition. Replacing ";

$before= substr($textarray[$lineindex],0,$position);
$after= substr($textarray[$lineindex],$position+strlen($incorrect));
$textarray[$lineindex]= $before.$correct.$after;

$poscorrect= (strlen($correct)-strlen($incorrect))+$poscorrect;
//print "Position correction is now $poscorrect.
";
$index= $index+1;
}

//print "Original text:
";
//print nl2br($text);
//print "

";

foreach ($textarray as $key=>$value) {
$newtext.=$value;
}
print "
";
}

// otherwise, show the initial form
else {
print "
";
}

// show source code part II
if ($showsource) {
print "

PHP Source:

";
$void= show_source($_SERVER['SCRIPT_FILENAME']);
}

print "

spellcheck.php Copyright (C) 2003 by Chris Snyder

This program comes with ABSOLUTELY NO WARRANTY. This is free software, and you are welcome
to redistribute it under certain conditions; please refer to the
GNU General Public License for details.

";
?>

Add Days to a Date

2008-11-17T05:14:00.000-08:00

DATE Function in PHP - ADD DAYS
By using this function you can easily Add days into date and as well as subtract days from date.

//Example
$date = "2008-11-10";
$fdate = adddays($date,5);
echo fdate; //result : 2008-11-15

$date = "2008-11-10";
$fdate = adddays($date,-5);
echo fdate; //result : 2008-11-05

function adddays($date,$days){
$rs = $this->execute("select DATE_FORMAT(DATE_ADD('$date',INTERVAL $days DAY),'%Y-%m-%d') as newdate");
if($row = $this->row($rs)){
return $row["newdate"];
}else{
return "0000-00-00";
}
}
?>

Convert Date into SQL Date Format

2008-11-17T04:49:00.000-08:00

In this function you can easily convert user input date format into SQL date format.
this 00/00/0000 to 0000-00-00

Example:
$date = "15/11/2008";
$query = "INSERT INTO TB VALUES('".tosqldate($date)."')";
// result: 2008-11-15

function tosqldate($strdata){
$strdata = trim($strdata);
if($strdata==""){
return "";
}
$arrdate = explode("/",$strdata);
if(count($arrdate) < 3){
return "";
}else{
return $arrdate[2]."-".$arrdate[1]."-".$arrdate[0];
}
}
?>

Chage Date Format

2008-11-17T04:45:00.000-08:00

By use of this script or function you can easily change date format: this 2008-11-15 to 15/11/2008

// calling function
$date = "2008-11-15";
$fdate = formatdae($date);

echo $fdate; // Result: 15/11/2008

function formatdate($mysql_stamp,$type=1)
{
//$type = 1 date + time
//$type = 2 date
//$type = 3 time
// split mysql DATETIME stamp into date and time
if($mysql_stamp==""){
return "";
}
@list($date, $time) = split ('[ ]', $mysql_stamp);
@list($year, $month, $day) = split ('[-]', $date);
if( isset($time) && $time != "" )
{
list($hour, $minute, $second) = split ('[:]', $time);
if($hour>=12)
{
$ext = "PM";
$hour = $hour - 12;
}
else
{
$ext = "AM";
}
$time = " ".$hour.":".$minute." ".$ext;
}
else
{
$hour="";
$minute= "" ;
$ext = "";
$time = "";
}

if($type == 1)
$formatted_stamp = "$day/$month/$year".$time;
elseif($type==2)
{
$formatted_stamp = "$day/$month/$year";
}
elseif($type==3)
$formatted_stamp = $time;

return $formatted_stamp;
}
?>

PHP interview Question

2008-11-13T02:36:00.000-08:00

How can we repair a MySQL table?
What are the advantages of stored procedures, triggers, indexes?
What is the maximum length of a table name, database name, and fieldname in MySQL?
How many values can the SET function of MySQL take?
What are the other commands to know the structure of table using MySQL commands except explain command?

PHP interview Preperation

2008-11-13T02:21:00.000-08:00

1. What does a special set of tags do in PHP? - The output is displayed directly to the browser.

2. What’s the difference between include and require? - It’s how they handle failures. If the file is not found by require(), it will cause a fatal error and halt the execution of the script. If the file is not found by include(), a warning will be issued, but execution will continue.

3. I am trying to assign a variable the value of 0123, but it keeps coming up with a different number, what’s the problem? - PHP Interpreter treats numbers beginning with 0 as octal. Look at the similar PHP interview questions for more numeric problems.

4. Would I use print "$a dollars" or "{$a} dollars" to print out the amount of dollars in this example? - In this example it wouldn’t matter, since the variable is all by itself, but if you were to print something like "{$a},000,000 mln dollars", then you definitely need to use the braces.

5. How do you define a constant? - Via define() directive, like define ("MYCONSTANT", 100);

6. How do you pass a variable by value? - Just like in C++, put an ampersand in front of it, like $a = &$b

7. Will comparison of string "10" and integer 11 work in PHP? - Yes, internally PHP will cast everything to the integer type, so numbers 10 and 11 will be compared.

8. When are you supposed to use endif to end the conditional statement? - When the original if was followed by : and then the code block without braces.

9. Explain the ternary conditional operator in PHP? - Expression preceding the ? is evaluated, if it’s
true, then the expression preceding the : is executed, otherwise, the expression following : is executed.

10. How do I find out the number of parameters passed into function? - func_num_args() function returns the number of parameters passed in.

11. If the variable $a is equal to 5 and variable $b is equal to character a, what’s the value of $$b? - 100, it’s a reference to existing variable.

12. What’s the difference between accessing a class method via -> and via ::? - :: is allowed to access methods that can perform static operations, i.e. those, which do not require object initialization.

13. Are objects passed by value or by reference? - Everything is passed by value.

14. How do you call a constructor for a parent class? - parent::constructor($value)

15. What’s the special meaning of __sleep and __wakeup? - __sleep returns the array of all the
variables than need to be saved, while __wakeup retrieves them.

16. Why doesn’t the following code print the newline properly?
$str = ‘Hello, there.\nHow are you?\nThanks for visiting TechInterviews’;
print $str;
?>
Because inside the single quotes the \n character is not interpreted as newline, just as a sequence of two characters - \ and n.

17. Would you initialize your strings with single quotes or double quotes? - Since the data inside the single-quoted string is not parsed for variable substitution, it’s always a better idea speed-wise to initialize a string with single quotes, unless you specifically need variable substitution.

18. How come the code works, but doesn’t for two-dimensional array of mine? - Any time you have an array with more than one dimension, complex parsing syntax is required. print "Contents: {$arr[1][2]}" would’ve worked.

19. What is the difference between characters \023 and \x23? - The first one is octal 23, the second is hex 23.

20. With a heredoc syntax, do I get variable substitution inside the heredoc contents? - Yes.

21. I want to combine two variables together:

$var1 = 'Welcome to ';
$var2 = 'TechInterviews.com';

What will work faster? Code sample 1:

$var 3 = $var1.$var2;

Or code sample 2:

$var3 = "$var1$var2";

Both examples would provide the same result - $var3 equal to "Welcome to TechInterviews.com". However, Code Sample 1 will work significantly faster. Try it out with large sets of data (or via concatenating small sets a million times or so), and you will see that concatenation works significantly faster than variable substitution.

22. For printing out strings, there are echo, print and printf. Explain the differences. - echo is the most primitive of them, and just outputs the contents following the construct to the screen. print is also a construct (so parentheses are optional when calling it), but it returns TRUE on successful output and FALSE if it was unable to print out the string. However, you can pass multiple parameters to echo, like:

and it will output the string "Welcome to TechInterviews!" print does not take multiple parameters. It is also generally argued that echo is faster, but usually the speed advantage is negligible, and might not be there for future versions of PHP. printf is a function, not a construct, and allows such advantages as formatted output, but it’s the slowest way to print out data out of echo, print and printf.

23. I am writing an application in PHP that outputs a printable version of driving directions. It contains some long sentences, and I am a neat freak, and would like to make sure that no line exceeds 50 characters. How do I accomplish that with PHP? - On large strings that need to be formatted according to some length specifications, use wordwrap() or chunk_split().

24. What’s the output of the ucwords function in this example?

$formatted = ucwords("TECHINTERVIEWS IS COLLECTION OF INTERVIEW QUESTIONS");
print $formatted;

What will be printed is TECHINTERVIEWS IS COLLECTION OF INTERVIEW QUESTIONS.
ucwords() makes every first letter of every word capital, but it does not lower-case anything else. To avoid this, and get a properly formatted string, it’s worth using strtolower() first.

25. What’s the difference between htmlentities() and htmlspecialchars()? - htmlspecialchars only takes care of <, >, single quote ‘, double quote " and ampersand. htmlentities translates all occurrences of character sequences that have different meaning in HTML.

26. What’s the difference between md5(), crc32() and sha1() crypto on PHP? - The major difference is the length of the hash generated. CRC32 is, evidently, 32 bits, while sha1() returns a 128 bit value, and md5() returns a 160 bit value. This is important when avoiding collisions.

27. So if md5() generates the most secure hash, why would you ever use the less secure crc32() and sha1()? - Crypto usage in PHP is simple, but that doesn’t mean it’s free. First off, depending on the data that you’re encrypting, you might have reasons to store a 32-bit value in the database instead of the 160-bit value to save on space. Second, the more secure the crypto is, the longer is the computation time to deliver the hash value. A high volume site might be significantly slowed down, if frequent md5() generation is required.

The Difference Between require() and include()

2008-11-13T02:13:00.000-08:00

The key difference between require() and include() is that if you require() a file that can't be loaded (eg if it isn't there) then it generates a fatal error which will halt the execution of the page completely, and no more output will be generated. On the other hand, if you include() a file that can't be loaded, then this will merely generate a warning and continue building the page.

What one you should use depends on the situation; require() is best suited for loading files that are essential to the rest of the page - for example if you have a database driven website then using require() to include a file containing the database login and password is clearly preferred over using include(). If you used include() in this situation, then you may end up generating more warnings and errors than you had intended.

include() should be used when it isn't essential for that file to be loaded to execute the page. This is best used in situations where the file isn't essential to the processing of the page (for example a footer file), so if the file isn't present then the user can still view the site. You should, of course, make sure that all files you include() and require() are going to be available.

In PHP versions prior to 4.0.2. there was slightly different behaviour of require(). If you used a require() statement in an if block then the require() statement will always make sure that the file you're require()ing is readable, regardless of whether the condition was true for that if block to be processed. This is best illustrated with the following code example:

$a = 1;
if($a == 2) {
require("header.php");
}
?>

In this example, PHP versions before 4.0.2. will always make sure that header.php is available, but it will only actually execute the contents of it if $a is equal to 2.

More Explanation:

The principle differences between include() & require() are :
(1).When “Include()”ed file is not found,only warnings will be displayed& the script will continue to execute further.
But,when “require()”ed file is not found,fatal errors will be displayed & the script will halt execution.
When we are dealing with non-confedintial data,
inlude()is preffered.
e.g. When we are dealing with a form which posts Sachin Tendulkar’s age & no. of centuries ,after posting the form,
the variables age & no.centuries will be displayed on the URL of the opened active file.
If “include()” ed file doesn’t exist ,only waning will be given & the script will follow its execution afterwatds.

with including “require()” in our file ,we can safely process over confidential data ,such as user login form. Here both login ID & passwords are checked & script will continue only when “require()” function gets required file,otherwise,it will halt the script showing fatal error.

PHP htmlentities Function

2008-09-12T06:13:00.000-07:00

Whenever you allow your users to submit text to your website, you need to be careful that you don't leave any security holes open for malicious users to exploit. If you are ever going to allow user submitted text to be visible by the public you should consider using the htmlentities function to prevent them from running html code and scripts that may be harmful to your visitors.

HP - Converting HTML into Entities

The htmlentities function takes a string and returns the same string with HTML converted into HTML entities. For example, the string

"'";

//Lets make it safer before we use it
$userInputEntities = htmlentities($userInput);

//Now we can display it
echo $userInputEntities;

The HTML output of the above script would be as follows:
Safe Raw HTML Code:

I am going to hax0r your site, hahaha!
< script type='text/javascript' >
window.location = 'http://www.example.com/'
< /script >'

If we had not used htmlentities to convert any HTML code into safe entities, this is what the raw HTML code would be and it would have redirect a visitor to example.com.

Dangerous Raw HTML Code:
I am going to hax0r your site, hahaha!
'

Those two HTML code examples are what you would see if you were to view source on the web page. However, if you were just viewing the output normally in your browser you would see the following.

Safe Display:
I am going to hax0r your site, hahaha! '

Dangerous Display:
You'd see whatever spammer site that the malicious user had sent you to. Probably some herbal supplement site or weight loss pills would be displayed.

When Would You Use htmlentities?
Anytime you allow users to submit content to your website, that other visitors can see, you should consider removing the ability to let them use HTML. Although this will remove a lot of cool things that your users can do, like making heavily customized content, it will prevent your site from a lot of common attacks. With some custom coding you can just remove specific tags from running, but that is beyond the scope of this lesson.

Just remember, that when allowing users to submit content to your site you are also giving them access to your website. Be sure you take the proper precautions.

PHP - Filing

2008-09-12T06:03:00.000-07:00

Manipulating files is a basic necessity for serious programmers and PHP gives you a great deal of tools for creating, uploading, and editing files.

This section of the PHP tutorial is completely dedicated to how PHP can interact with files. After completing this section you should have a solid understanding of all types of file manipulation in PHP!

PHP - Files: Be Careful

When you are manipulating files you must be very careful because you can do a lot of damage if you do something wrong. Common errors include editing the wrong file, filling a hard-drive with garbage data, and accidentally deleting a file's contents.

It is our hope that you will be able to avoid these and other slipups after reading this tutorial. However, we know that there are so many places where code can take a wrong turn, so we urge you to take extra care when dealing with files in PHP.

PHP - Files: Overview

The presentation of the file lessons will begin with how to create, open, and close a file. After establishing those basics, we will then cover other important file tasks, such as: read, write, append, truncate, and uploading files with PHP.

PHP - File Create##########

Before you can do anything with a file it has to exist! In this lesson you will learn how to create a file using PHP.

PHP - Creating Confusion
In PHP, a file is created using a command that is also used to open files. It may seem a little confusing, but we'll try to clarify this conundrum.

In PHP the fopen function is used to open files. However, it can also create a file if it does not find the file specified in the function call. So if you use fopen on a file that does not exist, it will create it, given that you open the file for writing or appending (more on this later).
PHP - How to Create a File

The fopen function needs two important pieces of information to operate correctly. First, we must supply it with the name of the file that we want it to open. Secondly, we must tell the function what we plan on doing with that file (i.e. read from the file, write information, etc).

Since we want to create a file, we must supply a file name and tell PHP that we want to write to the file. Note: We have to tell PHP we are writing to the file, otherwise it will not create a new file.

PHP Code:
$ourFileName = "testFile.txt";
$ourFileHandle = fopen($ourFileName, 'w') or die("can't open file");
fclose($ourFileHandle);

The file "testFile.txt" should be created in the same directory where this PHP code resides. PHP will see that "testFile.txt" does not exist and will create it after running this code. There's a lot of information in those three lines of code, let's make sure you understand it.

1. $ourFileName = "testFile.txt";

Here we create the name of our file, "testFile.txt" and store it into a PHP String variable $ourFileName.
2. $ourFileHandle = fopen($ourFileName, 'w') or die("can't open file");

This bit of code actually has two parts. First we use the function fopen and give it two arguments: our file name and we inform

PHP that we want to write by passing the character "w".
Second, the fopen function returns what is called a file handle, which will allow us to manipulate the file. We save the file handle into the $ourFileHandle variable. We will talk more about file handles later on.

3. fclose($ourFileHandle);

We close the file that was opened. fclose takes the file handle that is to be closed. We will talk more about this more in the file closing lesson.

PHP - Permissions

If you are trying to get this program to run and you are having errors, you might want to check that you have granted your PHP file access to write information to the hard drive. Setting permissions is most often done with the use of an FTP program to execute a command called CHMOD. Use CHMOD to allow the PHP file to write to disk, thus allowing it to create a file.

In the near future Tizag.com will have a more in-depth tutorial on how to use CHMOD to set file permissions.

PHP - File Open###########
In the previous lesson we used the function fopen to create a new file. In this lesson we will be going into the details of this important

function and see what it has to offer.

PHP - Different Ways to Open a File
For many different technical reasons, PHP requires you to specify your intentions when you open a file. Below are the three basic ways to open a file and the corresponding character that PHP uses.

* Read: 'r'

Open a file for read only use. The file pointer begins at the front of the file.

* Write: 'w'

Open a file for write only use. In addition, the data in the file is erased and you will begin writing data at the beginning of the file. This is also called truncating a file, which we will talk about more in a later lesson. The file pointer begins at the start of the file.

* Append: 'a'

Open a file for write only use. However, the data in the file is preserved and you begin will writing data at the end of the file. The file pointer begins at the end of the file.

A file pointer is PHP's way of remembering its location in a file. When you open a file for reading, the file pointer begins at the start of the file. This makes sense because you will usually be reading data from the front of the file.

However, when you open a file for appending, the file pointer is at the end of the file, as you most likely will be appending data at the end of the file. When you use reading or writing functions they begin at the location specified by the file pointer.

PHP - Explanation of Different Types of fopen

These three basic ways to open a file have distinct purposes. If you want to get information out of a file, like search an e-book for the occurrences of "cheese", then you would open the file for read only.

If you wanted to write a new file, or overwrite an existing file, then you would want to open the file with the "w" option. This would wipe clean all existing data within the file.

If you wanted to add the latest order to your "orders.txt" file, then you would want to open it to append the data on to the end. This would be the "a" option.

PHP - File Open: Advanced

There are additional ways to open a file. Above we stated the standard ways to open a file. However, you can open a file in such a way that reading and writing is allowable! This combination is done by placing a plus sign "+" after the file mode character.

* Read/Write: 'r+'

Opens a file so that it can be read from and written to. The file pointer is at the beginning of the file.

* Write/Read: 'w+'

This is exactly the same as r+, except that it deletes all information in the file when the file is opened.

* Append: 'a+'

This is exactly the same as r+, except that the file pointer is at the end of the file.
PHP - File Open: Cookie Cutter Below is the correct form for opening a file with PHP. Replace the (X) with one of the options above (i.e. r, w, a, etc).

Pseudo PHP Code:

$ourFileName = "testFile.txt";
$fh = fopen($ourFileName, 'X') or die("Can't open file");
fclose($fh);

PHP - File Open: Summary
You can open a file in many different ways. You can delete everything and begin writing on a clean slate, you can add to existing data, and you can simply read information from a file. In later lessons we will go into greater detail on how each of these different ways to open a file is used in the real world and give some helpful examples.

PHP - File Close####################
The next logical step after you have opened a file and finished your business with it is to close that file down. You don't want an open file running around on your server taking up resources and causing mischief!

PHP - File Close Description
In PHP it is not system critical to close all your files after using them because the server will close all files after the PHP code finishes execution. However the programmer is still free to make mistakes (i.e. editing a file that you accidentally forgot to close). You should close all files after you have finished with them because it's a good programming practice and because we told you to!

PHP - File Close Function
In a previous tutorial, we had a call to the function fclose to close down a file after we were done with it. Here we will repeat that example and discuss the importance of closing a file.

PHP Code:

$ourFileName = "testFile.txt";
$ourFileHandle = fopen($ourFileName, 'w') or die("can't open file");
fclose($ourFileHandle);

The function fclose requires the file handle that we want to close down. In our example we set our variable "$fileHandle" equal to the file handle returned by the fopen function.

After a file has been closed down with fclose it is impossible to read, write or append to that file unless it is once more opened up with the fopen function. Write, then this function might not work the way you expect it to.

PHP - File Delete##########
You know how to create a file. You know how to open a file in an assortment of different ways. You even know how to read and write data from a file!

Now it's time to learn how to destroy (delete) files. In PHP you delete files by calling the unlink function.

PHP - File Unlink
When you view the contents of a directory you can see all the files that exist in that directory because the operating system or application that you are using displays a list of filenames. You can think of these filenames as links that join the files to the directory you are currently viewing.

If you unlink a file, you are effectively causing the system to forget about it or delete it!

Before you can delete (unlink) a file, you must first be sure that it is not open in your program. Use the fclose function to close down an open file.

PHP - Unlink Function
Remember from the PHP File Create lesson that we created a file named testFile.txt.

PHP Code:

$myFile = "testFile.txt";
$fh = fopen($myFile, 'w') or die("can't open file");
fclose($fh);

Now to delete testFile.txt we simply run a PHP script that is located in the same directory. Unlink just needs to know the name of the file to start working its destructive magic.

PHP Code:

$myFile = "testFile.txt";
unlink($myFile);

The testFile.txt should now be removed.PHP - Unlink: Safety First!

With great power comes a slough of potential things you can mess up! When you are performing the unlink function be sure that you are deleting the right file!

PHP - File Append###########
So far we have learned how to open, close, read, and write to a file. However, the ways in which we have written to a file so far have caused the data that was stored in the file to be deleted. If you want to append to a file, that is, add on to the existing data, then you need to open the file in append mode.

PHP - File Open: Append
If we want to add on to a file we need to open it up in append mode. The code below does just that.

PHP Code:
$myFile = "testFile.txt";
$fh = fopen($myFile, 'a');

If we were to write to the file it would begin writing data at the end of the file.

PHP - File Write: Appending Data
Using the testFile.txt file we created in the File Write lesson , we are going to append on some more data.

PHP Code:

$myFile = "testFile.txt";
$fh = fopen($myFile, 'a') or die("can't open file");
$stringData = "New Stuff 1\n";
fwrite($fh, $stringData);
$stringData = "New Stuff 2\n";
fwrite($fh, $stringData);
fclose($fh);

You should noticed that the way we write data to the file is exactly the same as in the Write lesson. The only thing that is different is that the file pointer is placed at the end of the file in append mode, so all data is added to the end of the file.

The contents of the file testFile.txt would now look like this:

Contents of the testFile.txt File:
Floppy Jalopy
Pointy Pinto
New Stuff 1
New Stuff 2

PHP - Append: Why Use It?

The above example may not seem very useful, but appending data onto a file is actually used everyday. Almost all web servers have a log of some sort. These various logs keep track of all kinds of information, such as: errors, visitors, and even files that are installed on the machine.

A log is basically used to document events that occur over a period of time, rather than all at once. Logs: a perfect use for append!

PHP - File Truncate###########
As we have mentioned before, when you open a file for writing with the paramater 'w' it completely wipes all data from that file. This action is also referred to as "truncating" a file. Truncate literally means to shorten.

PHP - File Open: Truncate
To erase all the data from our testFile.txt file we need to open the file for normal writing. All existing data within testFile.txt will be lost.

PHP Code:
$myFile = "testFile.txt";
$fh = fopen($myFile, 'w');
fclose($fh);

PHP - Truncate: Why Use It?
Truncating is most often used on files that contain data that will only be used for a short time, before needing to be replaced. These type of files are most often referred to as temporary files.

For example, you could create an online word processor that automatically saves every thirty seconds. Every time it saves it would take all the data that existed within some HTML form text box and save it to the server. This file, say tempSave.txt, would be truncated and overwritten with new, up-to-date data every thirty seconds.

This might not be the most efficient program, but it is a nice usage of truncate.

PHP substr_replace Function

2008-09-12T05:57:00.000-07:00

The function substr_replace introduces some additional functionality to compliment str_replace. substr_replace is a more mathematically based replace function, which relies on starting points and lengths to replace parts of strings, as opposed to searching and replacing.

substr_replace's Four Parameters
There are three required parameters for the substr_replace function (original string, replacement string, starting point) and one that's optional (length).

1. original string - This is your original string that will be operated on.
2. replacement string - This string will be used to replace everything in the string from the starting point to the ending point (specified by length).
3. starting point - This is the place in the original string that will be used to mark the replacement's beginning. A negative value specifies the number of characters from the end of the string.
4. optional length - How many characters from the original string will be replaced. If no length is specified then the end of the string is used. If a value of 0 is used then no characters will be replaced and an insert is performed. A negative value specifies the number of characters from the end of the string.

substr_replace On Your Mark
This example of substr_replace shows what happens when you omit the length parameter at various starting points.

PHP Code:
//string that needs to be customized
$original = "ABC123 Hello Mr. Cow! DEF321";

//starting point 5
$sp5 = substr_replace($original, "Five", 5);
//starting point 12
$sp12 = substr_replace($original, "Twelve", 12);
//starting point 0
$sp0 = substr_replace($original, "Zero", 0);
//starting point -1
$spneg1 = substr_replace($original, "Negative 1", -1);

//Echo each string
echo "Original String: $original
";
echo "Starting Point 5: $sp5
";
echo "Starting Point 12: $sp12
";
echo "Starting Point 0: $sp0
";
echo "Starting Point -1: $spneg1 ";

Display:
Original String: ABC123 Hello Mr. Cow! DEF321
Starting Point 5: ABC12Five
Starting Point 12: ABC123 HelloTwelve
Starting Point 0: Zero
Starting Point -1: ABC123 Hello Mr. Cow! DEF32Negative 1

As you can see, when you don't specify the fourth parameter, length, everything after the starting point is replaced by the second parameter replacement string.

Note: The first replacement occurred at position 5, which in $original was the character 3. This 3 and everything onward was replaced with the replacement string. Remember that you start counting character to begin from zero. The $original string could be labeled as

so:

* Letter A - Position 0
* Letter B - Position 1
* Letter C - Position 2
* Letter 1 - Position 3
* Letter 2 - Position 4
* Letter 3 - Position 5

substr_replace Specifying a Length
If you want to get any sort of precision out of this function you're going to have to get into the nitty gritty of specifying the exact length of characters you want replaced in your original string.

Imagine that you want to get rid of those ugly pseudo references (ABC123, DEF321) at the beginning and end of the string. Since both of those strings are a length of 6 and we know one is at the very beginning of the string and the other is at the very end of the string

we should probably use a starting point of 0 for ABC123 and a value of -6 for DEF321. By having a replacement string of nothing "" we can do something similar to select and delete that we often do in a word processor.

PHP Code:
//string that needs to be customized
$original = "ABC123 Hello Mr. Cow! DEF321";

//remove ABC123 and store in $cleanedstr
$cleanedstr = substr_replace($original, "", 0, 6);
//remove DEF321 from $cleanedstr
$cleanedstr2 = substr_replace($cleanedstr, "", -6, 6);

//Echo each string
echo "Original String: $original
";
echo "Clean #1: $cleanedstr
";
echo "Clean #2: $cleanedstr2";

Display:
Original String: ABC123 Hello Mr. Cow! DEF321
Clean #1: Hello Mr. Cow! DEF321
Clean #2: Hello Mr. Cow!

Make sure that you play around with this function some on your own so you can get a feel for how the starting point and length parameters effect this function.

substr_replace Perform an Insert
By setting the length parameter to zero you can stop substr_replace from removing anything from the original string and just add to it.

If we wanted to add a second and third person to our $original string we would want to do this insert operation. Note: instead of counting the characters we've used a couple other PHP functions to figure out the starting positions for us.

PHP Code:
//string that needs to be customized
$original = "Hello Mr. Cow!";

// Get the position of Mr. Cow
$cowpos = strpos($original, "Mr. Cow");

// Find where Mr. Cow ends by adding the length of Mr. Cow
$cowpos_end = $cowpos + strlen("Mr. Cow");

// Insert Mrs. Bear after Mr. Cow
$mrsbear = substr_replace($original, " and Mrs. Bear", $cowpos_end, 0);

// Insert Sensei Shark before Mr. Cow
$senseishark = substr_replace($mrsbear, "Sensei Shark, ", $cowpos, 0);

//Echo each string
echo "Original String: $original
";
echo "After Mrs. Bear: $mrsbear
";
echo "After Sensei Shark: $senseishark";

Display:
Original String: Hello Mr. Cow!
After Mrs. Bear: Hello Mr. Cow and Mrs. Bear!
After Sensei Shark: Hello Sensei Shark, Mr. Cow and Mrs. Bear!

We snuck a new function strlen into that example, but it isn't that complicated of a function, as it stands for "string length."

* $cowpos_end = $cowpos + strlen("Mr. Cow");

The strlen function takes a string and then counts up how many characters are in it then returns that number. So by calculating the length of "Mr. Cow" and adding that to the position, we find out where the end point is!

PHP - String Explode

2008-09-12T05:54:00.000-07:00

The PHP function explode lets you take a string and blow it up into smaller pieces. For example, if you had a sentence you could ask

explode to use the sentence's spaces " " as dynamite and it would blow up the sentence into separate words, which would be stored

in an array. The sentence "Hello, I would like to lose weight." would look like this after explode got done with it:

1. Hello,
2. I
3. would
4. like
5. to
6. lose
7. weight.

The dynamite (the space character) disappears, but the other stuff remains, but in pieces. With that abstract picture of the explode

function in mind, lets take a look at how it really works.
The explode Function

The first argument that explode takes is the delimiter (our dynamite) which is used to blow up the second argument, the original string.

explode returns an array of string pieces from the original and they are numbered in order, starting from 0. Lets take a phone number

in the form ###-###-#### and use a hyphen "-" as our dynamite to split the string into three separate chunks.

PHP Code:

$rawPhoneNumber = "800-555-5555";

$phoneChunks = explode("-", $rawPhoneNumber);
echo "Raw Phone Number = $rawPhoneNumber
";
echo "First chunk = $phoneChunks[0]
";
echo "Second chunk = $phoneChunks[1]
";
echo "Third Chunk chunk = $phoneChunks[2]";

Display:
Raw Phone Number = 800-555-5555
First chunk = 800
Second chunk = 555
Third Chunk chunk = 5555
explode Function - Setting a Limit

If you want to control the amount of destruction that explode can wreak on your original string, consider using the third (optional)

argument which allows you to set the number of pieces explode can return. This means it will stop exploding once the number of

pieces equals the set limit. Below we've blown up a sentence with no limit and then with a limit of 4.

PHP Code:

$someWords = "Please don't blow me to pieces.";

$wordChunks = explode(" ", $someWords);
for($i = 0; $i <>
echo "Piece $i = $wordChunks[$i]
";
}

$wordChunksLimited = explode(" ", $someWords, 4);
for($i = 0; $i <>
echo "Limited Piece $i = $wordChunksLimited[$i]
";
}

Display:
Piece 0 = Please
Piece 1 = don't
Piece 2 = blow
Piece 3 = me
Piece 4 = to
Piece 5 = pieces.
Limited Piece 0 = Please
Limited Piece 1 = don't
Limited Piece 2 = blow
Limited Piece 3 = me to pieces.

The limited explosion has 4 pieces (starting from 0, ending at 3). If you forgot how a for loop works, check out PHP For Loops.

PHP - Array implode

2008-09-12T05:49:00.000-07:00

PHP implode - Repairing the Damage

The first argument of implode is the string of characters you want to use to join the array pieces together. The second argument is the array (pieces).

PHP Code:

$pieces = array("Hello", "World,", "I", "am", "Here!");

$gluedTogetherSpaces = implode(" ", $pieces);
$gluedTogetherDashes = implode("-", $pieces);
for($i = 0; $i <>
echo "Piece #$i = $pieces[$i]
";
}
echo "Glued with Spaces = $gluedTogetherSpaces
";
echo "Glued with Dashes = $gluedTogetherDashes";

Display:
Piece #0 = Hello
Piece #1 = World,
Piece #2 = I
Piece #3 = am
Piece #4 = Here!
Glued with Spaces = Hello World, I am Here!
Glued with Dashes = Hello-World,-I-am-Here!

The implode function will convert the entire array into a string and there is no optional argument to limit this as there was in the explode function.

PHP Pattern

2008-09-12T04:29:00.000-07:00

Singleton Pattern
The singleton pattern applies to those situations in which there needs to be a single instance of a class. Implementing this pattern makes this single instance easily accessible by many other objects.

Example

class Example
{
// Hold an instance of the class
private static $instance;
// A private constructor; prevents direct creation of object
private function __construct()
{
echo 'I am constructed';
}

// The singleton method
public static function singleton()
{
if (!isset(self::$instance)) {
$c = __CLASS__;
self::$instance = new $c;
}
return self::$instance;
}

// Example method
public function bark()
{
echo 'Woof!';
}

// Prevent users to clone the instance
public function __clone()
{

trigger_error('Clone is not allowed.', E_USER_ERROR);
}
}
?>

Magic Methods
The function names _construct, _sleep, _wakeup, _tostring are all magical methods in PHP. There cannot be any functions with these names in the classes. These functions can be had only if we want the magical functionality associated with them.

_sleep
The _sleep magic method is used to close any database connections that the object may have. It is also used to commit pending data and perform similar cleanup tasks. It is also used if there are very large objects which do not have to be saved completely.

_wakeup
The _wakeup magic method is used to reconstruct any resources that the object may have. The basic function of _wakeup is to reestablish any database connections that may have been lost during serialization and perform other initialization tasks.

Example of sleep and wakeup

class Conn {
protected $link;
private $server, $username, $password, $db;
public function __construct($server, $username, $password, $db)
{
$this->server = $server;
$this->username = $username;
$this->password = $password;
$this->db = $db;
$this->connect();
}

private function connect()
{
$this->link = mysql_connect($this->server, $this->username, $this->password);
mysql_select_db($this->db, $this->link);
}

public function __sleep()
{
mysql_close($this->link);
}

tostring
The _tostring magic method allows a class to decide that how it will react when it is converted to string.

Example

// Declare a simple class
class Test
{
public $foo;
public function __construct($foo) {
$this->foo = $foo;
}

public function __toString() {
return $this->foo;
}
}

$class = new Test('Hello');
echo $class;
?>

Cloning
An object copy is created by using the clone keyword. An object's __clone() method cannot be called directly. When an object is cloned, PHP will perform a shallow copy of all of the object's properties. Any properties that are references to other variables, will remain references. If a __clone() method is defined, then the newly created object's __clone() method will be called, to allow any necessary properties that need to be changed.

Example

class SubObject
{
static $instances = 0;
public $instance;
public function __construct() {
$this->instance = ++self::$instances;
}

public function __clone() {
$this->instance = ++self::$instances;
}
}

class MyCloneable
{
public $object1;
public $object2;
function __clone()
{

// Force a copy of this->object, otherwise
// it will point to same object.
$this->object1 = clone($this->object1);
}
}

$obj = new MyCloneable();
$obj->object1 = new SubObject();
$obj->object2 = new SubObject();
$obj2 = clone $obj;
print("Original Object:\n");
print_r($obj);
print("Cloned Object:\n");
print_r($obj2);
?>

PHP OOPS - Classes and Objects

2008-09-12T03:58:00.000-07:00

Classes and Objects are considered to be the most useful and dynamic aspects of a programming language. In PHP, classes are used extensively and are very useful. The concept of classes allows for better performance and more features.

What is a Class?
The Class in PHP is basically the same as in other languages such as Java. The class definition begins with the keyword class, followed by a class name. The form name can be any name except a reserved word or keyword in PHP. The class name is followed by a pair of curly braces which contain the definition of class members and methods.

Example of a Class

Class abc
{
//member functions and variables go here
}
?>

What is an Object?
An Object is an enclosed bundle of variables and functions which is copied from a Class. Objects provide an easy interface and hide a lot of their inner workings. The object sends orders through special functions called methods and they can return information.

While creating a Class, a set of characteristics is laid down. By creating Objects of that type, entities are created that share these characteristics but the Object might initialize them as different values.

Example
Suppose there is a class named building. This class would have a characteristic named floor. All the objects of class building would share the characteristics of floor, but some would initialize it to “one”, some to “two”, others to “three” or “four”, and so on.

The benefit of object oriented code is that it is re-useable. In this the classes can be used to create different objects and classes from one project can be used in other projects as well. Child classes can also be created which inherits the properties of the parent classes.

Creating an Instance
To start with, a class having no member functions and variables is not useful. For a class to be completely useful, member functions and variables have to be added in that class.

Let’s take an example of a class with a variable in it.

Example

Class abc
{
$a = “Hello!”;
}
?>

The class abc is the basis from which many objects can be instantiated. The new keyword is used to create an object. Now any abc object that is created contains a property called $a with the value of “Hello”. This property can be accessed and even be changed with the help of objects.

In this the -> operator is used to access or change the properties of the object.

In the following example $obj1 and $obj2 are the objects of the class abc. In this $obj2 has been assigned the string “Welcome to expertrating!” to its $a property.

Example

Class abc
{
var $a = "Hello";
}

$obj1 = new abc();
$obj2 = new abc();
$obj2->a = "Welcome to expertrating!";
echo "$obj1->a
";
echo "$obj2->a
";
?>

Extends
Another feature of object oriented programming is used in PHP, which is inheritance. In PHP a class a class can inherit methods, functions and members of other class by using the extends keyword in the declaration. In PHP it is not possible to inherit from multiple classes, a class can inherit from only one base class.

The class from which inheritance is done is called the parent class or base class and the class which inherits is called the child class.

The Keyword Final
The final keyword prevents the child classes from overriding a method. This can be done by prefixing the method with the keyword final. If the complete class is being defined as final then that class cannot be extended.

Example

final class test
{
//methods and functions
}

The class defined above i.e. class test cannot be overloaded as it has been finalized by using the keyword final with it.

Abstract
A new concept of abstract classes and methods has been introduced in PHP5. When a class is defined as abstract then it is not allowed to create the instance of that class. A class that contains at least one abstract method must also be abstract. The methods defined as abstract cannot define the implementation; they just declare the method’s signature.

When a child class is inheriting from an abstract parent class, then all the methods marked abstract in parent class declaration must also be additionally defined by the child class. These methods must be defined with the same or weaker access. This means that if an abstract method is declared as protected in the parent class then it must be declared either as protected or public in the child class.

Static Keyword
When class members or methods are declared as static then there is no need to instantiate that class. These members and methods are accessible without the instantiation of the class. If a member is declared as static then it cannot be accessed by an instantiated class object, but a method declared as static can be accessed by an instantiated class object.

The static declaration of a class must be after the visibility declaration (means that after the member or method has been declared as public, protected, or private).

The static method calls are resolved at compile time and static properties cannot be accessed through the object through the arrow operator (->).

Interfaces
Object interfaces allow the creation of a code which specifies that which method a class must implement, without having to define how these methods have to be handled.

Interfaces are defined in the same way as a class is defined. These interfaces are defined with the keyword “interface”. In the interface the contents of the methods do not have to be defined and all the methods declared in the interface must be declared as public.

Implementation of Interfaces
To implement an interface, the implements operator is used. The methods must be defined before implementation and all the methods in the interface must be implemented within a class.

Exceptions
Exception handling in PHP is similar to that of other programming languages. Within a PHP block of code we can throw, try and catch an exception. There must be at least one catch block in a try block. In this multiple catch blocks can be used to catch different class types. In exception handling the execution will continue after the last catch block has been encountered and exceptions can be thrown within catch blocks.

In exception handling when an exception is thrown, the code following the statement will not be executed rather PHP will attempt to find the first matching catch block. If the exception is not caught then it will result in a fatal error with an uncaught exception message.

This chapter will be focusing on some advanced class concepts, which will empower the reader to use classes in a better way and to create dynamic web pages.

Constructor
In PHP 5 developers can declare constructor methods for classes. In this, those classes which have a constructor method call this method for each newly created object. So, it is suitable for any initialization that the object may need before it is used. In this the parent constructors are not called implicitly if the child class defines a constructor.

Example

class ParentClass {
function __construct() {
print "In ParentClass constructor\n";
}
}

class ChildClass extends ParentClass {
function __construct() {
parent::__construct();
print "In ChildClass constructor\n";
}
}

$obj = new ParentClass();
$obj = new ChildClass();
?>

Destructors
The destructor concept is introduced in PHP 5. This destructor concept is similar to other object oriented languages. In this the destructor will be called as soon as all references to a particular object have been removed or when the object has been explicitly destroyed.

Example

class MyClass {
function __construct() {
print "In constructor\n";
$this->name = "MyClass";
}

function __destruct() {
print "Destroying " . $this->name . "\n";
}
}

$obj = new MyClass();
?>

Advanced PHP Topics - Superglobals

2008-09-12T03:51:00.000-07:00

In the previous chapters the concept of global variable was explained. A global variable is a variable declared at the top of the script outside the function. This variable is available to the complete script. Superglobal variables are arrays built into PHP. These superglobal variables are populated automatically with useful elements, and they are available in any scope. A superglobal array can be accessed within a function or a method without using the global keyword.

PHP Superglobals

* $_COOKIE – It contains values provided to the script via HTTP cookies.

* $_GET – It contains variables submitted to the script using HTTP get method.

* $_POST – It contains variables submitted to the script using HTTP post method.

* $_REQUEST – It is a combined array containing values from the $_GET, $_POST, and $_COOKIES superglobal arrays.

* $_ENV – It contains keys and values set by the script’s shell.

* $_FILES – It contains information about uploaded files.

* $_SERVER – It contains variables made available by the server.

* $GLOBALS – It contains all the global variables associated with the current script.

Instanceof Operator
The instanceof operator in PHP is used to determine whether a given object, the parents of that object, or its implemented interfaces are of a specified object class.

Example

class X { }
class Y { }
$thing = new X;
if ($thing instanceof X) {
echo 'X';
}
if ($thing instanceof Y) {
echo 'Y';
}
?>

Declare
The declare statement is used to set execution directives for a block of code. The syntax of the declare statement is similar to the syntax of other flow control statements.
Syntax

declare (directive)

statement
The directive section allows the behavior of the declare block to be set. In this only one directive is recognized, which is the ticks directive.

[ Ticks - A tick is an event that occurs for every N low level statements, which are executed within the declare block. The value of N is specified using the statement ticks = N in the directive section.]

The statement part of the declare block will be executed according to the directives set in the directive block.

Example

// how to use declare:
// the first way:
declare(ticks=1) {
// entire script here
}
// the second way:
declare(ticks=1);
// entire script here
?>

Resizing images with PHP

2008-09-07T01:12:00.000-07:00

* File: SimpleImage.php
* Author: Simon Jarvis
class SimpleImage {

var $image;
var $image_type;

function load($filename) {
$image_info = getimagesize($filename);
$this->image_type = $image_info[2];
if( $this->image_type == IMAGETYPE_JPEG ) {
$this->image = imagecreatefromjpeg($filename);
} elseif( $this->image_type == IMAGETYPE_GIF ) {
$this->image = imagecreatefromgif($filename);
} elseif( $this->image_type == IMAGETYPE_PNG ) {
$this->image = imagecreatefrompng($filename);
}
}

function save($filename, $image_type=IMAGETYPE_JPEG, $compression=75, $permissions=null) {
if( $image_type == IMAGETYPE_JPEG ) {
imagejpeg($this->image,$filename,$compression);
} elseif( $image_type == IMAGETYPE_GIF ) {
imagegif($this->image,$filename);
} elseif( $image_type == IMAGETYPE_PNG ) {
imagepng($this->image,$filename);
}
if( $permissions != null) {
chmod($filename,$permissions);
}
}

function output($image_type=IMAGETYPE_JPEG) {
if( $image_type == IMAGETYPE_JPEG ) {
imagejpeg($this->image);
} elseif( $image_type == IMAGETYPE_GIF ) {
imagegif($this->image);
} elseif( $image_type == IMAGETYPE_PNG ) {
imagepng($this->image);
}
}

function getWidth() {
return imagesx($this->image);
}

function getHeight() {
return imagesy($this->image);
}

function resizeToHeight($height) {
$ratio = $height / $this->getHeight();
$width = $this->getWidth() * $ratio;
$this->resize($width,$height);
}

function resizeToWidth($width) {
$ratio = $width / $this->getWidth();
$height = $this->getheight() * $ratio;
$this->resize($width,$height);
}

function scale($scale) {
$width = $this->getWidth() * $scale/100;
$height = $this->getheight() * $scale/100;
$this->resize($width,$height);
}

function resize($width,$height) {
$new_image = imagecreatetruecolor($width, $height);
imagecopyresampled($new_image, $this->image, 0, 0, 0, 0, $width, $height, $this->getWidth(), $this->getHeight());
$this->image = $new_image;
}
}
?>

-------------------Usage-------------------

Save the above file as SimpleImage.php and take a look at the following examples of how to use the script.

The first example below will load a file named picture.jpg resize it to 250 pixels wide and 400 pixels high and resave it as picture2.jpg

 include('SimpleImage.php');
 $image = new SimpleImage();
 $image->load('picture.jpg');
 $image->resize(250,400);
 $image->save('picture2.jpg');
?>

If you want to resize to a specifed width but keep the dimensions ratio the same then the script can work out the required height for you, just use the resizeToWidth function.


 include('SimpleImage.php');
 $image = new SimpleImage();
 $image->load('picture.jpg');
 $image->resizeToWidth(250);
 $image->save('picture2.jpg');
?>

You may wish to scale an image to a specified percentage like the following which will resize the image to 50% of its original width and height

 include('SimpleImage.php');
 $image = new SimpleImage();
 $image->load('picture.jpg');
 $image->scale(50);
 $image->save('picture2.jpg');
?>

You can of course do more than one thing at once. The following example will create two new images with heights of 200 pixels and 500 pixels

 include('SimpleImage.php');
 $image = new SimpleImage();
 $image->load('picture.jpg');
 $image->resizeToHeight(500);
 $image->save('picture2.jpg');
 $image->resizeToHeight(200);
 $image->save('picture3.jpg');
?>

The output function lets you output the image straight to the browser without having to save the file. Its useful for on the fly thumbnail generation


 header('Content-Type: image/jpeg');
 include('SimpleImage.php');
 $image = new SimpleImage();
 $image->load('picture.jpg');
 $image->resizeToWidth(150);
 $image->output();
?>



More Information:

This script will eventually be developed further to include functions
for easily sharpening, bluring, cropping, brightening and colouring images.

PHP Source Code for Manually Registering Global Variables

2008-08-20T08:25:00.001-07:00

Methodology and Implementation

If you read up on the originial USENET thread, you know that there were a few suggestions made about going about this as well as posts pointing out why those solutions didn't quite fit. In order to get around some of the fallbacks and keep the original idea in tact, functions needed to be created.

By making use of PHP's superglobal arrays ($GLOBALS, $_SESSION, $_GET, $_POST, $_COOKIE, $_REQUEST, $_SERVER, $_FILES, $_ENV) and referencing variables, the solution became rather simple to accommodate the OP's idea.

You can read the thread to find out what brough on this interest if you are curious. What it comes down to is that the OP didn't want to trust register_globals, gpc_order and variables_order server settings to get it right. Therefore, the OP wanted a way to manually register the variables needed by pulling them from the appropriate place. This was to help the OP in creating more secure and stable PHP applications.

How this works is really quite simple. Say you have a variable named "var1" in a session. This variable would normally be accessed by $_SESSION['var1'] if register_globals is not turned on. That syntax creates a few extra keystrokes as well as more extra strokes when using heredoc syntax or quoted string output. However, if you were to be able to simply access that variable through $var1, that saves a lot of keystrokes when you start to use the variable over and over (as is likely the case with sessions and user input variables). For this to work correctly, however, if you were to set a value to the variable either through $var1 or $_SESSION['var1'], the compliment also needed to be changed. This is where variable references come in. (References are similar to pointers in the C programming language.)

The implementation is bery easy to use. In order to "register" or global $var1 variable, we'd simply call the correct function from below.

global_session('var1');

In doing so, we now are able to access the same value in memory by the following 3 methods:

$var1
$_SESSION['var1']
$GLOBALS['var1']

By setting a new value to any one of the above 3 variables will change the value for all of them.

Difference From register_globals = On

One difference I have spotted in the way these functions act from having register_globals enabled is in the case of session variables. If you had altered $var1 in a script (with PHP's register_globals = "On"), you'd have to manually add the new value back into the session. In most cases, these functions would make a more convenient method; however, there may be instances where you do not want to have the $_SESSION variable automatically updated.

Additional tests with other superglobal arrays reveal that the same behavior exists as above for all the superglobal arrays except $GLOBALS. Therefore, if you truly want to set global variable values globally, you would need to use the methods described on this page.

function global_get($var){
       if(!array_key_exists($var,$_GET))
           $_GET[$var]='';
       $GLOBALS[$var]=&$_GET[$var];
   }

   function global_post($var){
       if(!array_key_exists($var,$_POST))
           $_POST[$var]='';
       $GLOBALS[$var]=&$_POST[$var];
   }

   function global_session($var){
       if(!array_key_exists($var,$_SESSION))
           $_SESSION[$var]='';
       $GLOBALS[$var]=&$_SESSION[$var];
   }

   function global_cookie($var){
       if(!array_key_exists($var,$_COOKIE))
           $_COOKIE[$var]='';
       $GLOBALS[$var]=&$_COOKIE[$var];
   }

   function global_server($var){
       if(!array_key_exists($var,$_SERVER))
           $_SERVER[$var]='';
       $GLOBALS[$var]=&$_SERVER[$var];
   }

   function global_files($var){
       if(!array_key_exists($var,$_FILES))
           $_FILES[$var]='';
       $GLOBALS[$var]=&$_FILES[$var];
   }

   function global_env($var){
       if(!array_key_exists($var,$_ENV))
           $_ENV[$var]='';
       $GLOBALS[$var]=&$_ENV[$var];
   }

   function global_request($var){
       if(!array_key_exists($var,$_REQUEST))
           $_REQUEST[$var]='';
       $GLOBALS[$var]=&$_REQUEST[$var];
   }
?>

Creating a chat script with PHP and Ajax

2008-08-20T08:17:00.001-07:00

Introduction

In this multi-part tutorial series I will show you how to create your own chat script with PHP and Ajax. You've probably heard of Ajax before, and what it exactly is, but in case you haven't, read the following two tutorials to learn more about Ajax: "Mastering Ajax, Part 1: Introduction to Ajax" and "Getting started with Ajax".

Another JavaScript library we'll be using is the Prototype library, which includes many useful JavaScript functions and comes with inbuilt Ajax support. If you want to know more about this library, have a look at the following tutorial: "Using prototype.js v1.3.1".

In this first part of the series I will show you how to create a really basic chat script, and nothing more. In the next parts we'll be adding more features, eventually creating a really robust and powerful chat script.

How it works

Our chat script will consist of two parts: a server and a client.

The client is used by your visitors, and doesn't contain any PHP at all. The client must do all the data sending. Every time the user wants to send a new message, the client must send this data (using Ajax) to the server. The client must also check for new messages on the server, again using an Ajax request.

The server only has to add a new message or send a list of messages to the client, and it doesn't have to use any HTML or JavaScript at all. It's strictly PHP. I've added a simple diagram below to show what I've just

Creating the server

Let's start by creating the server, but first, create a new datebase to hold the messages of your chat script, with the following database scheme:

CREATE TABLE `message` (

`messageid` int(5) NOT NULL AUTO_INCREMENT,

`user` varchar(255) NOT NULL DEFAULT '',

`message` text NOT NULL,

`datetimestamp` int(11) NOT NULL DEFAULT '0',

PRIMARY KEY (`messageid`)

) TYPE=MyISAM AUTO_INCREMENT=1 ;

The first thing the server must do is check what the client wants: adding a new message or requesting latest messages? The following code does what we want:

if (!isset($_GET['action'])) {

die('This chat server can only be used by the chat client.');

}

$action = $_GET['action'];

if ($action != 'get' AND $action != 'add') { $action = 'get'; }

// Do we want to get chat messages or add a new message?

if ($action == 'get') {

// Get messages

send_messages();

} else {

// Add a new message

add_message();

}

As you can see we're going to use two different functions: send_messages() to return all the latest messages and add_message() to add a new message.

Adding a new message is quite simple, and it only requires some standard database code, like this:

function add_message() {

global $db;

// Everything there?

if (!isset($_GET['user'])) {

die('error:no-user');

}

if (!isset($_GET['message'])) {

die('error:no-message');

}

$user = ss(htmlentities(strip_tags($_GET['user'])));

$message = ss(htmlentities(strip_tags($_GET['message'])));

$datetimestamp = time();

// Insert message

$db->query ("INSERT INTO message (user, message, datetimestamp) VALUES ('$user', '$message', $datetimestamp)");

// Return any new message

send_messages();

}

The function first checks if both variables are there, and if they're not, it returns an error. The errors look a bit weird, but this format actually makes it easier for our client (you'll see why later). When everything is okay, the message is inserted into the database.

The send_messages() function has to send the messages that have NOT yet been received by the client. To do this, the client sends the timestamp of the last received message, from which the server can automatically select the messages that haven't been received yet, like so:

function send_messages() {

global $db;

// Is there a latest timestamp?

if (!isset($_GET['latest'])) {

$latest = false;

} else {

$latest = intval($_GET['latest']);

}

// If there isn't a latest, get the five newest messages, and return them

if ($latest == false) {

$messages = $db->sql_query ("SELECT user, message, datetimestamp FROM message ORDER BY datetimestamp DESC LIMIT 0,4");

} else {

$messages = $db->sql_query ("SELECT user, message, datetimestamp FROM message WHERE datetimestamp > $latest ORDER BY datetimestamp DESC LIMIT 0,9");

}

// Any messages?

if ($messages == false) {

die('no-messages');

}

// Get newest timestamp

$newest = $messages['0']['datetimestamp'];

// Reverse array for correct order

$messages = array_reverse($messages);

// Return response

$response = $newest;

foreach ($messages as $message) {

$response .= $message['user'] . '>' . $message['message'] . "\n";

}

$response = trim($response);

die($response);

}

This code first selects the right messages, and after that returns it in the right format (each message is separated by a newline, and the user and message are separated by >).

Creating the client

You can close your PHP editor now, and switch to your HTML/JS editor, as we'll only be using HTML and JavaScript from now on.

First of all, the client page itself. It's nothing advanced, and very simple:

<html>

<head>

<title>Ajax Chat Client</title>

</head>

<body><div id="container">

<h1>Ajax Chat Client</h1>

<div id="login">

<p>Please enter an username: </p>

<input type="text" name="user" id="user" />

<input type="button" onclick="login();" value="Enter Chatroom" />

</div>

<div id="copyright">

This is a demo of an article series on <a href="http://www.phpit.net">PHPit</a>.

Copyright © 2006 Dennis Pallett.

</div>

</div></body>

</html>

It has three important elements: the login div, which shows a login box when first viewing the page, a textarea, which is used to show all the chat messages, and a text field which is used to enter new messages.

If you have a close look at the HTML above, you'll notice two different JS functions: login() and send_message(). These are defined in the script.js file, and are the most important of our chat script.

The login() function is used to set a user's username, and getting the initial messages. It looks like this:

var server = 'http://projects/phpit/content/creating%20an%20ajax-based%20chat/demos/1/chatserver.php';

var username = '';

var latest = '';

function login() {

// Get username

var user = $F('user');

if (user == '') {

alert('Please enter a username before entering the chat room');

return false;

}

username = user;

// Show chat

Element.hide('login');

Element.show('chatelements');

$('chat').value = '';

$('message').value = '';

// Begin getting messages

get_messages();

checker = new PeriodicalExecuter(get_messages, 2);

}

The first part of the function checks the username. If everything is okay, the chat elements are shown, and the latest messages are retrieved using the get_messages() function. The function also creates a new object, called the PeriodicalExecuter, which is used to check for new messages every 2 seconds.

The get_messages() function is used to retrieve new functions using an Ajax request, like so:

function get_messages() {

var args = 'action=get&latest=' + latest;

var do_ajax = new Ajax.Request(server, {method: 'get', parameters: args, onComplete: handle_response});

}

The above code uses the Ajax object (included with the Prototype library) to send a new GET request to the server with two arguments: action and the timestamp of the latest message received. As you can see, the onComplete parameter has been set to handle_response, which means that when the Ajax request is done, the response will be sent to a function called handle_response().

The handle_response() function actually checks the response, and decides what to do. Remember the responses that we gave in the server? We're going to use that now, like so:

function handle_response(request) {

var response = request.responseText;

// Error?

if (response == 'error:no-user') {

// No username, show login again

alert('It appears you aren\'t logged in any longer. Please login again');

Element.show('login');

Element.hide('chatelements');

return false;

}

if (response == 'error:no-message') {

// No username, show login again

alert('You didn\'t send any message. Please try again');

return false;

}

if (response == 'no-messages'){

// There are no new messages

return false;

}

// We're getting a valid response, first get the latest timestamp

latest = response.substring(0, 10);

// Now get the messages

messages = response.substring(10, response.length);

// Split messages

messages = messages.split('\n');

// Add each message

var chat = $('chat');

for (var i=0; i < messages.length; i++) {

var message = messages[i].split(">");

chat.value = chat.value + '\n';

chat.value = chat.value + message[0] + ': ' + message[1];

}

}

This function first checks whether any errors have been returned. This only happens when a message has been sent (and not when receiving messages). After that it checks whether there are any messages.

If there are new messages, it parses the new messages (using some standard string functions), and then adds the new messages to the chat area.

And that's all there is to it. We've now got an almost working chat script. All that's left is to write the send_message() function.

PHP & Security: 3 Example Exploits

2008-08-20T08:11:00.000-07:00

Introduction

One of the most common aspects of programming and scripting is security. Every program or script has to think about security, and each language has certain weak points. Actually, it isn't the language that has weak points - it's the programmer who creates weak points. PHP is no exception to this, and security should be at the top when you're creating a new script, no matter how simple or small the script may be.

I'm sure you've all read many basic PHP security articles, which include things like filtering user input, beware of XSS attacks, etc. That's why I'm not going to discuss them in this article. If you haven't heard about these things, have a look on Google. Heck, maybe I'll do a basic PHP security article in the near future.

In this article we're going to look a three different security cases. In each case I will try to explain the exploit, provide a working example, and then suggest possible fixes to prevent you from making the same mistake. Let's get cracking, shall we?

Security Case #1 - E-mail Injection

This is one of the neatest PHP exploits I've ever seen, and really requires some knowledge of how e-mail works. This exploit is often used by spammers to use contact forms on your websites to send out massive amounts of spam, without you even knowing. I used to be a victim of this as well, because I didn't even have a clue this existed. There was one thing I noticed though: really weird messages coming through my contact forms, for example:

Example

aciov@yourdomain.com
Content-Type: multipart/mixed; boundary=\"===============2145621685==\"
MIME-Version: 1.0
Subject: 9afb7555
To: aciov@yourdomain.com
bcc: mhkoch321@aol.com
From: aciov@yourdomain.com

This is a multi-part message in MIME format.

--===============2145621685==
Content-Type: text/plain; charset=\"us-ascii\"
MIME-Version: 1.0
Content-Transfer-Encoding: 7bit

wpbtizuum
--===============2145621685==--

As you can see this doesn't make much sense at all. But what it does mean is that spammers are trying to see if your contact form is open to e-mail injection.

This exploit works quite like SQL injection - untrusted users are able to inject data, because of poor input validation. When you use the mail() function you might think each argument is a separate thing, and they can't influence each other. But that's not the case, and the e-mail is actually one big long text message. For example, mail('me@example.com', 'My Subject', 'My Message', "From: contact@example.com\r\n";) is actually changed into:

To: me@example.com
Subject: My Subject
From: contact@example.com

My Message

The exploit happens when spammers are able to insert data into the e-mail, therefore being able to change the complete e-mail. For example, if your mail() function looks like this:

$email = $_POST['email'];
mail ('me@example.com', 'My Subject', 'My Message', "From: $email\\r\\n");
?>

As you can see an attacker can inject raw data into the e-mail. This means it's now possible to send a complete different e-mail with a new subject, message, and to header. Your contact form is used as an open relay!

How do you protect against this exploit?
Easy - validate ALL input, and insert as little as possible into the e-mail. If you make sure you only get valid data from the user, the chance of e-mail injection has already been reduced hugely, and it probably won't be possibly any longer. Also see the above link for different solutions.

This is one of the sneakiest exploits around, but it is also very simple (and easy to forget about it as a developer!). The View Source exploit was the one that caused APNIPHP to be "hacked" recently.

It only works when you use a script to highlight or show the source of other PHP files, using the highlight_file() function or the fopen() function. These functions allow your visitors to view the source of other files, which is the whole point of this script. But you must also implement some security measures to prevent users from viewing files that they shouldn't see (such as database files, password files, etc). The best way of doing this is using a white-list array of filenames, and only allowing these files to be opened. This method is bullet-proof and will never fail.

But perhaps you want to restrict the script to only allow files from a certain directory, e.g. the 'demos' directory. To enforce this restriction, you'd probably use code like this:

if (strpos($file, 'demos') === false) {
echo 'Security alert. Not a demo!';
} else {
highlight_file ($file);
}

This checks whether the filename contains 'demos', and if so, displays the source. Seems fairly fail-proof, but that's where the exploit strikes. An attacker could include '..' in the filename, which means "go a directory up". So C:\program files\demos\..\ means the same as C:\program files\. This basically means that an attacker has unlimited access to everything on the server. Big whoops!

How do you protect against this exploit?
The easiest way is to check if the filename contains the two dots and display an error. So the above code becomes:

if (strpos($file, 'demos') === false OR strpos($file, '..') !== false) {
echo 'Security alert. Not a demo!';
} else {
highlight_file ($file);
}

UPDATE:
The above way isn't completely secury, and any file that contains 'demos' in the filename can still be viewed. If you really want to secure your view source script, don't allow a full path, and instead only allow a name. For example, instead of using '/home/phpit/public_html/demo/demo.php' simply use 'demo.php', and in your script add the full path. The only thing you have to worry about then is to filter out the two dots, and that's easy.

$file = '/home/phpit/public_html/demo/' . $_GET['filename'];

if (strpos($file, '..') !== false) {
echo 'Security alert. Not a demo!';
} else {
highlight_file ($file);
}

This would probably be enough to protect your view source script, and stop this exploit from working. You can also use dedicated source-viewing scripts, like phpViewSource.

How do you protect against this exploit?
Protecting your scripts against CSRF attacks is extremely hard to do, and a really dedicated attacker will likely succeed anyway. But there are still steps you can take to make it harder.

First of all, make sure that any forms that change data (add/edit/delete) are POST only. GET requests should not be able to change anything.

Secondly, include a secret token with your forms, which also expire after a certain period of time. This will prevent almost any kind of CSRF attack, and is extremely different to counter.

Finally, don't worry too much about CSRF attacks. Although they are out there, it's likely you won't ever have to deal with it, and even so, it's an easy fix. If you're interested have a look on http://www.squarefree.com/securitytips/web-developers.html#CSRF for more information about CSRF attacks.

PHP Global Variables

2008-08-20T08:08:00.000-07:00

Introduction

Whenever you're developing a new large-scale PHP script, you're bound to use global variables, since some data needs to be used by multiple parts of your script. Good examples of global data are script settings, database connections, user credentials and more. There are many ways of making this data global, but the most commonly used way is to use the global keyword, which we will explore later on in this article.

The only problem with the global keyword, and any global data for that matter, is that's it's actually a very bad way of programming, and usually tends to lead to bigger problems later on. The reason for this is that global data ties all the separate parts of your script together, and often if you make a change in one part, something else will break in another part. If you have more than a few global variables, you're whole script will eventually become a big kludge of unmaintainable code.

That's why this article will show you how to prevent this by using various techniques and design patterns. But first, let's have a look at the global keyword and how it works.

Using globals and the global keyword

By default PHP defines a few variables called Superglobals which are automatically global, and can be accessed anywhere, like the $_GET or $_REQUEST variables. These are mainly used to retrieve form data or other outside data, and there's no real harm in using these variables, since they should never be written to anyway. But you can also use your own global variables, with the global keyword which is used to import variables from the global scope into the local scope of a function.

The following example demonstrates use of the global keyword:

$my_var = 'Hello World';

test_global();

function test_global() {
// Now in local scope
// the $my_var variable doesn't exist

// Produces error: "Undefined variable: my_var"
echo $my_var;

// Now let's important the variable
global $my_var;

// Works:
echo $my_var;
}

As you can see in the above example, the global keyword is used to important variables from the global scope. Seems to work fine, and it's nice and simple, so why should you worry about using the global keyword?

There are three good reasons:

1. Reusing parts of the script is impossible
If a certain function relies on global variables, it becomes almost impossible to use that function in a different context. Another problem is that you can't take that function, and use it in another script.

2. Solving bugs is much harder
Tracking a global variable is much harder than a non-global variable. A global variable could be declared in some obscure include file, which could take hours to find, although a good text editor / IDE could help with this.

3. Understanding the code in a year will be much more difficult
Globals make it difficult to see where a variable is coming from and what it does. You might know about every global during development, but after a year or so you'll probably have forgotten at least half of them, and then you'll be kicking yourself for using so many globals.

Google tips and tricks- Google don'ts

2008-08-20T08:01:00.000-07:00

Google tips:

Bellow are some techniques which may reduce your Google ranking or even ban you from its index. You should avoid them if possible.

Bad navigation

Your website must have clean and simple navigation. This way you ensure that Googlebot will be able to crawl your entire site. Navigation links should be located near the top of the pages since this makes it easy for your visitors and Googlebot to navigate through your site.
Best bet for navigation is use of text links, as this increases word count and keyword density, as well as giving description of destination page to Googlebot. Googlebot is also able to follow image links and from recently Flash navigation links. If you use image links make sure you add some description in “alt” attribute of image tag to describe your link.

JavaScript links

Googlebot is not able (currently) to follow JavaScript links. People often use these type of links for fancy navigation. If you use them just make sure you have alternative navigation using HTML links.

Hidden text

Googlebot and other robots learned to recognize this method several years ago. So if you don’t want to be identified as spammer and banned from SERP’s, don’t use this method.

Hidden links

Number of incoming links to certain page has direct effect to Google PageRank (PR). However, if those are hidden that may produce similar results as with hidden text.

Cloaking

Cloaking is a search engine optimization method where you serve highly optimized page version to robots and a regular page to your visitors. Official Google policy is that cloaked pages will not be allowed in their index. However, there are many websites that use cloaking with great success. So if you like to risk getting banned from SERP’s you may use this method, just make sure you do it properlyJ

Guest book spamming and FFA pages

Adding your link to hundreds of guest books will not help you with your PR, since it appears that Google is able to detect them and ignores outgoing links completely. This way you’ll save yourself many hours of useless work.
When PR was initially introduced, many SEO companies were offering to “submit your site to zillion FFA pages for free” and hopefully increase your PR. I don’t remember that this used to work at time and it certainly doesn’t work now. If you find any of these, avoid them.

Sessions

Google is not able to accept session cookies and will try avoiding URL based sessions. Also, you should use fewer parameters in you dynamic URLs and avoid use “id” parameter as Googlebot may think that is session ID.

Simple Mini Poll class library

2008-08-20T07:57:00.000-07:00

This easy-to-use class library enables you to set up your own survey system in just few minutes.

Main features include:

Dynamically generated form (with number of total votes)
Detailed result page
View of old polls
Poll administration interface
Check for repeated votes

1 . Execute these queries on your database:

# Table structure for table `poll_check`

CREATE TABLE `poll_check` (
  `pollid` int(11) NOT NULL default '0',
  `ip` varchar(20) NOT NULL default '',
  `time` varchar(14) NOT NULL default ''
) TYPE=MyISAM COMMENT='';

# -----------------------------------------

# Table structure for table `poll_data`

CREATE TABLE `poll_data` (
  `pollid` int(11) NOT NULL default '0',
  `polltext` varchar(50) NOT NULL default '',
  `votecount` int(11) NOT NULL default '0',
  `voteid` int(11) NOT NULL default '0',
  `status` varchar(6) default NULL
) TYPE=MyISAM COMMENT='';

# -----------------------------------------

# Table structure for table `poll_desc`

CREATE TABLE `poll_desc` (
  `pollid` int(11) NOT NULL default '0',
  `polltitle` varchar(100) NOT NULL default '',
  `timestamp` datetime NOT NULL default '0000-00-00 00:00:00',
  `votecount` mediumint(9) NOT NULL default '0',
  `STATUS` varchar(6) default NULL,
  PRIMARY KEY (`pollid`)
) TYPE=MyISAM COMMENT='';

# -----------------------------------------
?>

2. Set up database connection parameters.

3. Paste this code on page where you wish poll to appear:


include_once ("includes/miniPoll.class.php");

$test = new miniPoll;

$test->pollForm();

?>

4. Paste this code on page where you wish poll results to appear:


include_once ("includes/miniPoll.class.php");

$test = new miniPoll;

if (isset($_GET['poll']) && is_numeric($_GET['pollid'])) {
    $pollid = $_GET['pollid'];

    if (isset($_GET['voteid']) && is_numeric($_GET['voteid'])) {
        $voteid = $_GET['voteid'];
        $test->processPoll($pollid, $voteid);
    }

}
if (isset($_GET['pollid'])) {
    $pollid = $_GET['pollid'];
    $test->pollResults($pollid);
}

?>

5. Paste this code on poll admin page:


include_once ("includes/miniPollAdmin.class.php");

$test = new miniPollAdmin;

$test->newPollForm();

if (isset($_GET['opt'])) {
    $opt = $_GET['opt'];
    $pollid = $_GET['pollid'];
    if ($opt == 'activate') {
        $test->activatePoll($pollid);
    }
    if ($opt == 'delete') {
        $test->deletePoll($pollid);
    }

}

echo "
";
if (isset($_GET['q'])) {
    $pollname = $_GET['pollname'];
    $q = $_GET['q'];
    $test->createPoll($pollname, $q);
}
$test->listPolls();

?>

6. Set up these parameters in miniPoll.class.php:

->results_page = "test_poll_results.php"; ?>

page where you display results

7. Set up these parameters in miniPollAdmin.class.php:

->results_page = "test_poll_admin.php"; ?>

name of admin page file

8. Optionally you can change layout of form and results page
9. Create new poll by starting admin page
10. Activate your poll by clicking ACTIVATE
11. Enjoy and send me your comments

How to create and use Favicon.ico file

2008-08-20T07:49:00.000-07:00

What is Favicon.ico?

Favicon is a small icon which appears next to your URL in browser address bar.

Why would I use it?

If you look around the Internet, you will notice that all professional web sites use it. It gives more customized appearance of your site in visitor browser and it also gives more distinct look of your site in Bookmarks menu by replacing generic browser icon.

What browsers support it?

Currently all modern browsers support it. Including: Internet Explorer, Mozilla Firefox, Opera, Netscape 7.0 and Mozilla.

How do I create Favicon?

Best solution would be to get some of popular icon editors. If you don't have icon editor, you may use some of the standard image editors like Photoshop, PaintShop or even Windows paint. Simply create 16x16 pixels bitmap image with standard 16 or 256 Windows icon colors. You can't put much in such a small space, but with wright color combinations you may achieve very effective solutions. When you're done editing, simply rename file to favicon.ico.

Where do I put Favicon.ico file?

Simply use your favorite FTP program and upload it in root folder of your web site. Most browser look there for it. You may also help them by inserting following code in section of your page:

This way you ensure that browser will find it. You may also put favicon file in different folder, like for example, in your images folder. In that case code may look like this:

User Online Class

2008-08-20T07:38:00.000-07:00

Description:

This very simple class enables you to track number of visitors online in an easy and accurate manner.

Main features include:

Automatic insertion of new user
Automatic database cleanup
Check if user is coming behind proxy server (this helps in script accuracy)
Display of users online
Error reporting

DATABASE STRUCTURE
CREATE TABLE `useronline` (
  `id` int(10) NOT NULL auto_increment,
  `ip` varchar(15) NOT NULL default '',
  `timestamp` varchar(15) NOT NULL default '',
  PRIMARY KEY (`id`),
  UNIQUE KEY `id`(`id`)
) TYPE=MyISAM COMMENT='' AUTO_INCREMENT=1 ;
?>

PHP CODE :

 include_once ("usersOnline.class.php");
$visitors_online = new usersOnline();

if (count($visitors_online->error) == 0) {

    if ($visitors_online->count_users() == 1) {
        echo "There is " . $visitors_online->count_users() . " visitor online";
    }
    else {
        echo "There are " . $visitors_online->count_users() . " visitors online";
    }
}
else {
    echo "Users online class errors:
\r\n";
    for ($i = 0; $i < count($visitors_online->error); $i ++ ) {
        echo "" . $visitors_online->error[$i] . "
\r\n";
    }
    echo "
\r\n";

}
?>

PHP Array

2008-08-12T12:04:00.003-07:00

An array is a data structure that stores one or more values in a single value. For experienced programmers it is important to note that PHP's arrays are actually maps (each key is mapped to a value).

PHP - A Numerically Indexed Array

If this is your first time seeing an array, then you may not quite understand the concept of an array. Imagine that you own a business and you want to store the names of all your employees in a PHP variable. How would you go about this?

It wouldn't make much sense to have to store each name in its own variable. Instead, it would be nice to store all the employee names inside of a single variable. This can be done, and we show you how below.
PHP Code:

$employee_array[0] = "Bob";
$employee_array[1] = "Sally";
$employee_array[2] = "Charlie";
$employee_array[3] = "Clare";

In the above example we made use of the key / value structure of an array. The keys were the numbers we specified in the array and the values were the names of the employees. Each key of an array represents a value that we can manipulate and reference. The general form for setting the key of an array equal to a value is:

* $array[key] = value;

If we wanted to reference the values that we stored into our array, the following PHP code would get the job done.

Note: As you may have noticed from the above code example, an array's keys start from 0 and not 1. This is a very common problem for many new programmers who are used to counting from 1 and lead to "off by 1" errors. This is just something that will take experience before you are fully comfortable with it.
PHP Code:

echo "Two of my employees are "
. $employee_array[0] . " & " . $employee_array[1];
echo "
Two more employees of mine are "
. $employee_array[2] . " & " . $employee_array[3];

Display:
Two of my employees are Bob & Sally
Two more employees of mine are Charlie & Clare

PHP arrays are quite useful when used in conjunction with loops, which we will talk about in a later lesson. Above we showed an example of an array that made use of integers for the keys (a numerically indexed array). However, you can also specify a string as the key, which is referred to as an associative array.
PHP - Associative Arrays

In an associative array a key is associated with a value. If you wanted to store the salaries of your employees in an array, a numerically indexed array would not be the best choice. Instead, we could use the employees names as the keys in our associative array, and the value would be their respective salary.
PHP Code:

$salaries["Bob"] = 2000;
$salaries["Sally"] = 4000;
$salaries["Charlie"] = 600;
$salaries["Clare"] = 0;

echo "Bob is being paid - $" . $salaries["Bob"] . "
";
echo "Sally is being paid - $" . $salaries["Sally"] . "
";
echo "Charlie is being paid - $" . $salaries["Charlie"] . "
";
echo "Clare is being paid - $" . $salaries["Clare"];

Display:
Bob is being paid - $2000
Sally is being paid - $4000
Charlie is being paid - $600
Clare is being paid - $0

Once again, the usefulness of arrays will become more apparent once you have knowledge of for and while loops.

PHP Require

2008-08-12T12:04:00.001-07:00

Just like the previous lesson, the require command is used to include a file into your PHP code. However there is one huge difference between the two commands, though it might not seem that big of a deal.

Require vs Include

When you include a file with the include command and PHP cannot find it you will see an error message like the following:
PHP Code:

Display:
Warning: main(noFileExistsHere.php): failed to open stream: No such file or directory in /home/websiteName/FolderName/tizagScript.php on line 2 Warning: main(): Failed opening 'noFileExistsHere.php' for inclusion (include_path='.:/usr/lib/php:/usr/local/lib/php') in /home/websiteName/FolderName/tizagScript.php on line 2

Hello World!

Notice that our echo statement is still executed, this is because a Warning does not prevent our PHP script from running. On the other hand, if we did the same example but used the require statement we would get something like the following example.
PHP Code:

Display:
Warning: main(noFileExistsHere.php): failed to open stream: No such file or directory in /home/websiteName/FolderName/tizagScript.php on line 2
Fatal error: main(): Failed opening required 'noFileExistsHere.php' (include_path='.:/usr/lib/php:/usr/local/lib/php') in /home/websiteName/FolderName/tizagScript.php on line 2

The echo statement was not executed because our script execution died after the require command returned a fatal error! We recommend that you use require instead of include because your scripts should not be executing if necessary files are missing or misnamed.

PHP Include

2008-08-12T12:03:00.000-07:00

Without understanding much about the details of PHP, you can save yourself a great deal of time with the use of the PHP include command. include takes a file name and simply inserts that file's contents into the script that issued the include command.

Why is this a cool thing? Well, first of all, this means that you can type up a common header or menu file that you want all your web pages to include. When you add a new page to your site, instead of having to update the links on several web pages, you can simply change the Menu file.

An Include Example

Say we wanted to create a common menu file that all our pages will use. A common practice for naming files that are to be included is to use the ".php" extension. Since we want to create a common menu let's save it as "menu.php".

menu.php Code:
< html>
< body>
Home -
About Us -
Links -
Contact Us

Save the above file as "menu.php". Now create a new file, "index.php" in the same directory as "menu.php". Here we will take advantage of the include command to add our common menu.
index.php Code:

This is my home page that uses a common menu to save me time when I add
new pages to my website!

< /body>
< /html>

And we would do the same thing for "about.php", "links.php", and "contact.php". Just think how terrible it would be if you had 15 or more pages with a common menu and you decided to add another web page to that site. You would have to go in and manually edit every single file to add this new page, but with include files you simply have to change "menu.php" and all your problems are solved. Avoid such troublesome occasions with a simple include file.
What do Visitors See?

If we were to use the include command to insert a menu on each of our web pages, what would the visitor see if they viewed the source of "index.php"? Well, because the include command is pretty much the same as copying and pasting, the visitors would see:
View Source of index.php to a Visitor:

< html>
< body>
Home -
About Us -
Links -
Contact Us

This is my home page that uses a common menu to save me time when I add
new pages to my website!

< /body>
< /html>

The visitor would actually see all the HTML code as one long line of HTML code, because we have not inserted any new line characters. We did some formatting above to make it easier to read. We will be discussing new line characters later.

Passing JavaScript variables to PHP

2008-08-12T12:02:00.002-07:00

JavaScript is mainly used as a client side scripting language, while PHP is a server side technology. Unlike Java or ASP.Net, PHP doesn't have tools to make it work client side. That is why you need to combine JavaScript and PHP scripts to develop powerful web-applications.

One of the frequent problems is defining visitor’s screen resolution using JavaScript tools and passing this data to PHP-script. The following script provides solution for this problem:

Copy and paste this code snippet in the text editor, save it as index.htm and run it in your browser. After this code has been executed, a user is automatically redirected to the main.php page where screen resolution is displayed in the browser window.

The main.php looks as follows:

echo "

Screen Resolution:

";
echo "Width : ".$_GET['width']."
";
echo "Height : ".$_GET['height']."
";
?>

How to Get the Current Page URL in PHP

2008-08-12T12:02:00.001-07:00

Sometimes, you might want to get the current page URL that is shown in the browser URL window. For example if you want to let your visitors submit a blog post to Digg you need to get that same exact URL. There are plenty of other reasons as well. Here is how you can do that.

Add the following code to a page:

function curPageURL() {
$pageURL = 'http';
if ($_SERVER["HTTPS"] == "on") {$pageURL .= "s";}
$pageURL .= "://";
if ($_SERVER["SERVER_PORT"] != "80") {
$pageURL .= $_SERVER["SERVER_NAME"].":".$_SERVER["SERVER_PORT"].$_SERVER["REQUEST_URI"];
} else {
$pageURL .= $_SERVER["SERVER_NAME"].$_SERVER["REQUEST_URI"];
}
return $pageURL;
}
?>

You can now get the current page URL using the line:

echo curPageURL();
?>
Sometimes it is needed to get the page name only. The following example shows how to do it:

function curPageName() {
return substr($_SERVER["SCRIPT_NAME"],strrpos($_SERVER["SCRIPT_NAME"],"/")+1);
}

echo "The current page name is ".curPageName();
?>

PHP: Dynamic Image Generation

2008-08-12T12:01:00.000-07:00

Creating images on the fly can be a very useful skill. PHP has some built-in image generation functions, further more, to generate new images or edit existing images on the fly using PHP, we need to have the GD library installed. In this tutorial we will show you how to get quite interesting and useful effects using image handling functions. We will review two practical tasks: creating security images (captcha) on the fly and building a bar chart using numerical values retrieved from MySQL database.

Creating security images on the fly

At first, have a look at the following script that creates captcha image. Next, we will consider each step of image generation in details.

//Send a generated image to the browser
create_image();
exit();

function create_image()
{
//Let's generate a totally random string using md5
$md5 = md5(rand(0,999));
//We don't need a 32 character long string so we trim it down to 5
$pass = substr($md5, 10, 5);

//Set the image width and height
$width = 100;
$height = 20;

//Create the image resource
$image = ImageCreate($width, $height);

//We are making three colors, white, black and gray
$white = ImageColorAllocate($image, 255, 255, 255);
$black = ImageColorAllocate($image, 0, 0, 0);
$grey = ImageColorAllocate($image, 204, 204, 204);

//Make the background black
ImageFill($image, 0, 0, $black);

//Add randomly generated string in white to the image
ImageString($image, 3, 30, 3, $pass, $white);

//Throw in some lines to make it a little bit harder for any bots to break
ImageRectangle($image,0,0,$width-1,$height-1,$grey);
imageline($image, 0, $height/2, $width, $height/2, $grey);
imageline($image, $width/2, 0, $width/2, $height, $grey);

//Tell the browser what kind of file is come in
header("Content-Type: image/jpeg");

//Output the newly created image in jpeg format
ImageJpeg($image);

//Free up resources
ImageDestroy($image);
}
?>
To create a new image or edit an existing one, we need to create image identifier. In the preceding example we created an empty canvas by calling ImageCreate() function, passing it width and height of a new image as a parameters. Another way to do it is to read the existing image from the file. Depending on the file format you can do it using one of the following functions: ImageCreateFromPNG(), ImageCreateFromGIF(), ImageCreateFromJPEG(). Parameter of each function is a file name.

Then, we need to choose colors to be used while painting. For this we can use ImageColorAllocate() function and image identifiers for red, green, and blue (RGB) components of necessary color will be passed as parameters.

On the next step, we will generate our image. First, using ImageFill() function we will create black background. Parameters of this function are: image identifier, initial coordinates of the area to be filled and fill color. Then, we will use ImageString() function to add text to the image. Its parameters are – image identifier, font, coordinates for the first text position and text color. Finally, we will draw two lines and a rectangular to protect our image a little bit. Please note, that the final point of the rectangular has the following coordinates: $width-1 and $height-1. If they were equal to $width and $height, than the rectangular would have exceeded canvas frame.

When we had created the image, we can output it either to a browser, or to a file. Our example shows how to output it to the browser. We need to inform the browser, that we will output the image, not the text or html-code. To do it, call Header() function, setting image MIME-type. It’s worth mentioning that Header() function can not be executed if HTTP header has already been sent. After sending the header we can output our image using ImageJpeg() function, passing it image identifier as a parameter.

When we have finished working with the image we need to free up resources using ImageDestroy() function.

Building a bar chart

In the example below, using graphic functions we will build a bar chart based on the values stored in MySQL database. In our case, values represent poll results.

In this example we will use poll database. To create it run the following SQL script in your MySQL server:
CREATE DATABASE `poll`;
USE poll;

CREATE TABLE `results` (
book_type VARCHAR(50),
num_votes INT
);

INSERT INTO `results` values
('Classic', 15),
('Fantasy', 7),
('Humor', 32),
('Mystery', 12),
('Poetry', 25);

Script building a bar chart is quite long, so let's divide it into two parts and discuss them separately. The first part of the script connects to MySQL database and requests data that will be represented in the bar chart.

//Querying the database to get poll results

//connection to the database
$dbhandle = mysql_connect("localhost", "root", "")
or die("Unable to connect to MySQL");

//select a database to work with
$selected = mysql_select_db("poll",$dbhandle)
or die("Could not select examples");

//execute the SQL query and return records
$result = mysql_query("SELECT * FROM results");

$num_poller = mysql_num_rows($result);
$total_votes = 0;

//fetch the data from the database
while ($row = mysql_fetch_array($result)) {
$total_votes += $row{'num_votes'}; //calculating total number of votes
}

//nulling the pointer $result
mysql_data_seek($result,0);

//close the connection
mysql_close($dbhandle);

In the second part of the script first of all we will calculate variables needed to build the chart. Then, we prepare primary image and actually output data. Results for each genre are picked from the database one by one, percentage of votes is calculated, and then bars and explanatory notes are outputted.

In this script we are using TrueType fonts to get anti-aliased text. Functions that work with the TrueType fonts have its own peculiarities. First, you need to point where the fonts are located. For this, system variable GDFONTPATH is set. Then, we need to set the font name. TrueType fonts are rendered using ImageTTFText().

We have already discussed above all functions used for drawing, the code has been commented and is quite clear, so you shouldn’t have any trouble.

//Tell gd2, where your fonts reside
putenv('GDFONTPATH=C:\WINDOWS\Fonts');
$font = 'arial';

//Set starting point for drawing
$y = 50;

//Specify constant values
$width = 700; //Image width in pixels
$bar_height = 20; //Bars height
$height = $num_poller * $bar_height * 1.5 + 70; //Calculating image height
$bar_unit = ($width - 400) / 100; //Distance on the bar chart standing for 1 unit

//Create the image resource
$image = ImageCreate($width, $height);

//We are making four colors, white, black, blue and red
$white = ImageColorAllocate($image, 255, 255, 255);
$black = ImageColorAllocate($image, 0, 0, 0);
$red = ImageColorAllocate($image, 255, 0, 0);
$blue = imagecolorallocate($image,0,0,255);

//Create image background
ImageFill($image,$width,$height,$white);
//Draw background shape
ImageRectangle($image, 0, 0, $width-1, $height-1, $black);
//Output header
ImageTTFText($image, 16, 0, $width/3 + 50, $y - 20, $black, $font, 'Poll Results');

while ($row = mysql_fetch_object($result)) {
if ($total_votes > 0)
$percent = intval(round(($row->num_votes/$total_votes)*100));
else
$percent = 0;

//Output header for a particular value
ImageTTFText($image,12,0,10, $y+($bar_height/2), $black, $font, $row->book_type);
//Output percentage for a particular value
ImageTTFText($image, 12, 0, 170, $y + ($bar_height/2),$red,$font,$percent.'%');

$bar_length = $percent * $bar_unit;

//Draw a shape that corresponds to 100%
ImageRectangle($image, $bar_length+221, $y-2, (220+(100*$bar_unit)), $y+$bar_height, $black);
//Output a bar for a particular value
ImageFilledRectangle($image,220,$y-2,220+$bar_length, $y+$bar_height, $blue);
//Output the number of votes
ImageTTFText($image, 12, 0, 250+100*$bar_unit, $y+($bar_height/2), $black, $font, $row->num_votes.' votes cast.');

//Going down to the next bar
$y = $y + ($bar_height * 1.5);

}

//Tell the browser what kind of file is come in
header("Content-Type: image/jpeg");

//Output the newly created image in jpeg format
ImageJpeg($image);

//Free up resources
ImageDestroy($image);
?>

Using dynamically generated images on the other pages

Since the header can be sent only once and it is the only way to tell the browser that you are going to send image, it is not so easy to insert automatically generated images to the regular pages. There are three ways to do it:

* The whole page can consist of the image.
* You can save image in the file and then refer to it using HTML descriptor.
* You can put a script producing image in HTML descriptor, e.g.:

Stored Procedures in MySQL

2008-08-12T12:00:00.004-07:00

The programmers and developers all over the world are celebrating the existence of MySQL 5.0 for a good reason. The version has finally paved the way for using stored procedures with this popular open source database. The stored procedures are hoarded at database server in the form of commands and SQL statements and could be invoked for any type of application. Thus, there is advantage for programmers to shed away the need of creating their own SQL; a tiresome job.

Without taking much of the time, let us understand the syntax for utilizing the procedures:

1.

2.
CREATE ProcedureCREATE [DEFINER = { user | CURRENT_USER }]PROCEDURE sp_name ([proc_parameter[,…]])
3.

4.
[characteristic …] routine_body
5.

6.
IN the above syntax, the parameters are specified AS IN, OUT OR INOUT. However, IN case of CREATE FUNCTION displayed below, the only parameter allowed IS IN.
7.

8.
CREATE
9.

10.
[DEFINER = { user | CURRENT_USER }]
11.

12.
FUNCTION sp_name ([func_parameter[,…]])
13.

14.
RETURNS type
15.

16.
[characteristic …] routine_body

Return statement is included in the syntax for a function and it specifies the return type of the function. Routine body is included to define a valid SQL statement. The syntax contains characteristic to provide information regarding nature of data. This may include attributes like CONTAINS SQL, NO SQL, READS SQL DATA and MODIFIES SQL DATA.

Alter Procedure

This statement is used to modify or alter the characteristics possessed by a stored procedure. Here is the syntax:

1.

2.
ALTER {PROCEDURE | FUNCTION} sp_name [characteristic …]

It offers you the advantage to bring in more than one change in the characteristics of stored procedures.

Drop Procedure

In order to remove a stored procedure, there is provision of DROP statement in MySQL database. The syntax for this takes the following shape:

1.

2.
DROP {PROCEDURE | FUNCTION} [IF EXISTS] sp_name

IF EXISTS is used to check the existence of specified procedure or function. It saves the statement from generating an error in case the procedure or function doesn’t exist.

Other Statements For Procedures

Apart from those mentioned above, there are other statements used for stored procedures. Here is the list o these statements:

* Show Create Procedure – It is used to return the text of a stored procedure, which was defined previously using Create syntax. In the similar manner, there is Show Create Function statement to accomplish this task for stored function.
* Show Procedure Status – It is used to return the characteristic of the specified stored procedure. These characteristics include name, type, creation date and so on. You may use Show Function Status also.
* CALL – It is used to invoke the stored procedure created using Create Procedure statement.
* Begin End – It is used to specify multiple statements for carrying out different types of operations and executions.
* Declare – It is used to help programmers in declaring and defining local variables, conditions, procedures and so on.
* SET – This statement is used to modify the values of local as well as global variables.

Also, there are condition statements like IF THEN ELSE, WHILE, CASE WHEN amongst others, which could be employed to operate these procedures.

Thus, MySQL stored procedures are tools for better performance, secure environment, providing ease of maintenance and also, for optimization.

Recursive function in PHP

2008-08-12T12:00:00.003-07:00

recursive function is a function that calls itself repeatedly for a specified condition.
Here is an example function which calls iteself to perform a tree structure for a category table
Here is the category table:
category_id parent_id category_name
1 0 CMS
2 0 Blogs
3 0 Forums
4 0 E-Commerce
5 1 Joomla
6 1 Mambo
7 6 Templates
8 6 Mods/Components
9 4 OSCommerce
10 2 Wordpress
11 10 Themes
12 10 Plugins

1.

2.
’;
3.
$allcats = getTree();
4.
foreach($allcats as $key=>$value)
5.
{
6.
echo ""
7.
}
8.
echo ‘’;
9.

10.
function getTree($id=0)
11.
{
12.
static $cates = array();
13.
static $times = 0;
14.
$times++;
15.
$result = mysql_query("SELECT category_id,category_name FROM category_table WHERE parent_id=$id ORDER BY category_name");
16.
while($row = mysql_fetch_assoc($result))
17.
{
18.
$cates[$row[‘category_id’]] = str_repeat("| ",$times-1)."|___".$row[‘category_name’];
19.
getTree($row[‘category_id’]);
20.
}
21.
$times—;
22.
return $cates;
23.
}
24.
?>

The out put of this program would be the following select box:

PHP Interview Questions and Answers

2008-08-12T12:00:00.001-07:00

Question: Is PHP a case sensitive programming language?

Answer: PHP is a partially case sensitive programming language. We can use function names, class names in case insensitive manner.

Question: What is mean by LAMP?

Answer: LAMP means combination of Linux, Apache, MySQL and PHP.

Question: How do you get the user’s ip address in PHP?

Answer: Using the server variable: $_SERVER[’REMOTE_ADDR’]

Question: What is the difference between require and include?

Answer: When using require function to embed another file in php, it will give fatal error if the file is not exists.
When using include function to embed another file in php, it will give warning if the file is not exists.

Question: How to find the number of elements in an array?

Answer: Using count($array) or sizeof($array).

Question: How do you make one way encryption for your passwords in PHP?

Answer: Using md5 function or sha1 function

Question: How do you get ASCII value of a character?

Answer: By using ord function.

Generating CAPTCHA Image Using PHP

2008-08-12T11:59:00.000-07:00

The CAPTCHA concept is very useful to prevent automated registration. If you have enabled gd library, you can create a captcha code for your registration form using PHP.

Consider the following parts of code, name the file as "captcha.php"

session_start();

if(isset($_SESSION[‘captcha’]))
{
unset($_SESSION[‘captcha’]);
}

The above code will start session and clear the old captcha’s session value if it set.

$num_chars = 5; //number of characters for captcha image
$characters = array_merge(range(0,9),range(‘A’,‘Z’),range(‘a’,‘z’)); //creating combination of numbers & alphabets
shuffle($characters); //shuffling the characters

The above part of code describes the number of captcha characters and total available characters, here I am using all the lower and upper case alphabets and all numerics.
//getting the required random 5 characters
$captcha_text = "";
for($i=0;$i<$num_chars;$i++)
{
$captcha_text .= $characters[rand(0,count($characters)-1)];
}

$_SESSION[‘captcha’] = $captcha_text; // assigning the text into session

This part of code generated the required captcha code in a random manner from the available character array, also It assigns the value to session variable.

header("Content-type: image/png"); // setting the content type as png
$captcha_image = imagecreatetruecolor(140, 30);

$captcha_background = imagecolorallocate($captcha_image, 225, 238, 221); //setting captcha background colour
$captcha_text_colour = imagecolorallocate($captcha_image, 58, 94, 47); //setting cpatcha text colour

imagefilledrectangle($captcha_image, 0, 0, 140, 29, $captcha_background); //creating the rectangle

$font = ‘Arial.ttf’; //setting the font path

imagettftext($captcha_image, 20, 0, 11, 21, $captcha_text_colour, $font, $captcha_text);
imagepng($captcha_image);
imagedestroy($captcha_image);

The remaining code will draw the image.

How to use this captcha?

It’s simple, in your registration form put this part of code:

Then you can put a text box to enter the captcha value, and then you can compare the entered captcha value with the assigned captcha session value.

File Uploading in PHP

2008-08-12T11:58:00.000-07:00

File uploading is very simple in PHP when comparing to other server side programming languages. File uploading is very useful in most of the situations like uploading user’s photos, uploading csv reports, uploading pdf reports and so on.

Making a simple front end with file browsing box:

1.

2.

Note: You should have this enctype=”multipart/form-data”‘ in your form tag while uploading files.
The php source code to upload the files

1.

2.
if(isset($_FILES[‘my_file’][‘name’]) && $_FILES[‘my_file’][‘name’] != ”)
3.
{
4.
$upload_dir = ‘home/myaccount/public_html/images’;//uploading directory, this folder should have write permission to the current user
5.
$upload_file = $upload_dir.‘/’.basename($_FILES[‘my_file’][‘name’]);
6.

7.
//check if the file name already exists
8.
if(file_exists($upload_file))
9.
{
10.
echo "File Already Exists"; //if file already exists print the error message
11.
}
12.
else
13.
{
14.
if(move_uploaded_file($_FILES[‘my_file’][‘tmp_name’],$upload_file))
15.
{
16.
echo "File Uploaded";
17.
}
18.
else
19.
{
20.
echo "There was a problem to upload file";
21.
}
22.
}
23.
}
24.
?>

Using session in PHP

2008-08-12T11:55:00.002-07:00

Keeping in mind the fact that Internet is a stateless platform and every request for a web page is treated as unique, there is a serious need of a tool to maintain the state. Otherwise, it will be a messy situation to keep track of requests made by a particular user. The good news is that use of PHP session serves the solution to this problem. This session variable is of great importance for web applications like shopping carts and is considered as equivalent to cookies, other significant way of maintaining the state.

What Is PHP Session Capable Of

PHP session is capable of storing the information in the form of session variables, in order to handle the ever-increasing traffic on a website. For instance, consider a shopping website, with products scattered in different categories and different pages. In such a situation, a user may switch from one page t another and keep on adding products from different pages to his or her shopping cart.

Thus, in order to keep the track of a particular user on the shopping website, PHP sessions store user information and use it again and again. This is a powerful entity to serve the purpose for websites with huge customer base.

Getting Started With PHP Session

PHP session is initiated using following piece of code:

1.
session_start();?>

Now, suppose you visit a website in regular intervals in a specific period of time. The website must not treat you like a new user on every visit of yours. Rather, it must take the advantage of session variable to assign a user value to your first visit and use it again and again for every visit paid by you. Thus, we can add following code to accomplish this task:

1.
session_start();$_SESSION[‘counter’]++;
2.

3.
echo "Welcome Back! You have viewed this page " . $_SESSION[‘counter’] . " times";
4.

5.
?>

Thus, if you revert to a particular website in short period of time, the counter will be incremented. If you visit the website 5th time, you might see it written somewhere that “Welcome Back! You have viewed this page 5 times”.

How Does It Work

Whenever you visit a web page, the PHP session sets information on your computer in the form of a cookie. It is generally a random key, formed by alphabets and numbers. In case, you visit another webpage of same website, the session explores the computer for a previously generated key. In case a match is found, that particular session is utilized. Otherwise, a new session is created with whole procedure related.

How To End A PHP Session

A session is destroyed with the help of following code:

1.
session_destroy();
2.

3.
?>

It is a matter of fact that a session exists until and unless the associated user closes the browser used to open the website. Once the browser window is shut down, the session is destroyed. You may also decide the life of a session by bringing in following modifications in php.ini file.

session.cookie_lifetime = 0

You may change the value from zero to number of seconds you want a session to live.

You may also destroy a session variable using unset() or all session variable using session_unset().

Email validation using PHP regular expression

2008-08-12T11:55:00.001-07:00

Regular expression is a wonderful concept, using this we can play with strings in PHP. The practical use of regular expression is:

* Email validation
* validating domain name
* validating post code format etc.

There are two types of regular expression functions:

1. ereg functions or POSIX extended regular expression function, which is the standard functions for PHP
2. preg functions or perl Compatible regular expressions

For this email validation program, we are going to use PHP’s standard regular expression function "ereg".

Before entering the email validation program, its better to refer few basic syntax about regular expression functions.

\s -> this means an empty white space
^ -> this means start of a string
$ -> this means end of a string
. -> this means any character
(cat|mat) -> this means cat or mat
[0-9] -> this means all numbers from 0 to 9 inclusive
[a-z] -> this means all lowercase letters from a to z inclusive
[A-Z] -> this means all uppercase letters from A to Z inclusive
[^a-z] -> this means no occurrence of lowercase letters from a to z inclusive, the hat symbol (^) inside the sets denotes "not"
? -> this means zero or one of the proceeding characters
* -> this means zero or more characters
+ -> this means one or more characters
{3} -> this means exactly three characters
{3,} -> this means three or more characters
{3,6} -> this means 3 to 6 characters, it may be 3 or 4 or 5 or 6

Here is the php source code for email validation using php regx function:

$email = "myemail@mydomain.com";

if (ereg(‘^[a-zA-Z0-9._-]+@[a-zA-Z0-9._-]+\.([a-zA-Z]{2,4})$’,$email)
{
echo ‘Valid email id’;
} else {
echo ‘Invalid email id’;
}
?>

Now I am going to split the string pattern into 3 parts, ie

1] ^[a-zA-Z0-9._-]+@
2] [a-zA-Z0-9._-]+\.
3] ([a-zA-Z]{2,4})$

1]^[a-zA-Z0-9._-]+@

Here ^ symbol denotes that this is the start of the email part.
a-zA-Z0-9._- denotes combination of characters to form the username section of an email
+ symbol denotes, it should have 1 or more characters from the proceeding sets
@ symbol is a default symbol between username and domain name parts.

2] [a-zA-Z0-9._-]+\.
a-zA-Z0-9._- denotes combination of characters to form the domain name without the tld
+ symbol denotes, it should have 1 or more characters from the proceeding sets
\. symbol denotes, the dot operator proceeding to the tld, here we are using \ to escape

3] ([a-zA-Z]{2,4})$

a-zA-Z denotes the combination of chars to form the tld name
{2,4} denotes the length of the tld may be between 2 to 4 characters
$ denotes the end of an email.

Associative arrays in PHP

2008-07-03T04:57:00.000-07:00

A few days ago we studied about associative arrays in PHP. Now, you cannot sort an associative array by using the sort() function. Let’s see what happens if you apply the sort() function on an associative array in PHP:

<?php

$narray["IBM"]="International Business Machines";
$narray["MS"]="Microsoft";
$narray["CA"]="Computer Associated";
$narray["WHO"]="World Health Organization";
$narray["UK"]="United Kingdon";
$narray["BA"]="Something Random";

sort($narray);

foreach($narray as $key => $value)
{
print $key . " = " . $value . "<br />";
}

?>

The outcome you get is:

0 = Computer Associated
1 = International Business Machines
2 = Microsoft
3 = Something Random
4 = United Kingdon
5 = World Health Organization

So you can see that if you apply the sort() function on an associative array, it is sorted by the numeric value of the index. To sort an associative array, you use the asort() function in the following manner:

<?php

$narray["IBM"]="International Business Machines";
$narray["MS"]="Microsoft";
$narray["CA"]="Computer Associated";
$narray["WHO"]="World Health Organization";
$narray["UK"]="United Kingdon";
$narray["BA"]="Something Random";
asort($narray);
foreach($narray as $key => $value)
{
print $key . " = " . $value . "<br />";
}

?>

The result is:

CA = Computer Associated
IBM = International Business Machines
MS = Microsoft
BA = Something Random
UK = United Kingdon
WHO = World Health Organization

As you can see, the array has been sorted in the ascending order by the value of the array, and not the string index value, or the key of the array. You can use arsort() to sort an associative array in the descending order.

To sort an associative array according to the key of the array, you can use the ksort() function in the following manner:

<?php

$narray["IBM"]="International Business Machines";
$narray["MS"]="Microsoft";
$narray["CA"]="Computer Associated";
$narray["WHO"]="World Health Organization";
$narray["UK"]="United Kingdon";
$narray["BA"]="Something Random";

ksort($narray);

foreach($narray as $key => $value)
{
print $key . " = " . $value . "<br />";
}

?>

Similarly, you can sort an associative array according to the key, in ascending order by using the krsort() function.

Sorting an Array in PHP

2008-07-03T04:23:00.000-07:00

Now and then you need to sort your arrays alphabetically or numerically, if nothing else, then just to apply some programming logic and attain the desired output. You can sort an array in PHP by using two functions: sort(), to sort an array in ascending order, and rsort(), to sort an array in the reverse order, or descending order. I’ll illustrate this function with an example.

First, we loop through an array without applying any sorting:

<?php

$narray[0]="Alfred";
$narray[1]="Robert";
$narray[2]="Deepak";
$narray[3]="Teresa";
$narray[4]="Joshua";
$narray[5]="Chandni";
$narray[6]="Sadiq";
$narray[7]="Vladimir";

for($i=0; $i<8; $i++)
{
print $narray[$i] . "<br />";
}

?>

The output of this PHP code is:

Alfred
Robert
Deepak
Teresa
Joshua
Chandni
Sadiq
Vladimir

Now we apply the sort() function and see what happens.

<?php

$narray[0]="Alfred";
$narray[1]="Robert";
$narray[2]="Deepak";
$narray[3]="Teresa";
$narray[4]="Joshua";
$narray[5]="Chandni";
$narray[6]="Sadiq";
$narray[7]="Vladimir";

sort($narray);

for($i=0; $i<8; $i++)
{
print $narray[$i] . "<br />";
}

?>

The output of this PHP code is:

Alfred
Chandni
Deepak
Joshua
Robert
Sadiq
Teresa
Vladimir

You can see that the names have been alphabetically sorted in the ascending order. To sort of the names in descending order, we change the program like this:

<?php

$narray[0]="Alfred";
$narray[1]="Robert";
$narray[2]="Deepak";
$narray[3]="Teresa";
$narray[4]="Joshua";
$narray[5]="Chandni";
$narray[6]="Sadiq";
$narray[7]="Vladimir";

rsort($narray);

for($i=0; $i<8; $i++)
{
print $narray[$i] . "<br />";
}

?>

Now the output is:

Vladimir
Teresa
Sadiq
Robert
Joshua
Deepak
Chandni
Alfred

Developer Wallpapers

2008-06-25T23:52:00.000-07:00

Desktop Wallpapers - PHP

2008-06-25T23:35:00.000-07:00

The future of PHP 6

2008-06-24T23:12:00.000-07:00

<div style="text-align: center; font-weight: bold; font-family: arial;">Know what changes are in store for PHP V6 and how your scripts will change
<div style="text-align: left;">
PHP's next edition, V6, includes new features and syntax improvements that will make it easier to use from an object-oriented standpoint. Other important features, such as Unicode support in many of the core functions, mean that PHP V6 is positioned for better international support and robustness.

PHP is already popular, used in millions of domains (according to Netcraft), supported by most ISPs and used by household-name Web companies like Yahoo! The upcoming versions of PHP aim to add to this success by introducing new features that make PHP more usable in some cases and more secure in others. Are you ready for PHP V6? If you were upgrading tomorrow, would your scripts execute just fine or would you have work to do? This article focuses on the changes for PHP V6 — some of them back-ported to versions PHP V5.x — that could require some tweaks to your current scripts.

If you're not using PHP yet and have been thinking about it, take a look at its latest features. These features, from Unicode to core support for XML, make it even easier for you to write feature-filled PHP applications.

New PHP V6 features

PHP V6 is currently available as a developer snapshot, so you can download and try out many of the features and changes listed in this article. For features that have been implemented in the current snapshot

Improved Unicode support

Much improved for PHP V6 is support for Unicode strings in many of the core functions. This new feature has a big impact because it will allow PHP to support a broader set of characters for international support. So, if you're a developer or architect using a different language, such as the Java™ programming language, because it has better internationalization (i18n) support than PHP, it'll be time to take another look at PHP when the support improves.

Because you can download and use a developer's version of PHP V6 today, you will see some functions already supporting Unicode strings. For a list of functions that have been tested and verified to handle Unicode

Namespaces

Namespaces are a way of avoiding name collisions between functions and classes without using prefixes in naming conventions that make the names of your methods and classes unreadable. So by using namespaces, you can have class names that someone else might use, but now you don't have to worry about running into any problems. Listing 1 provides an example of a namespace in PHP.

You won't have to update or change anything in your code because any PHP code you write that doesn't include namespaces will run just fine. Because the namespaces feature appears to be back-ported to V5.3 of PHP, when it becomes available, you can start to introduce namespaces into your own PHP applications.

Example of a namespace

// I'm not sure why I would implement my own XMLWriter, but at least
// the name of this one won't collide with the one built in to PHP
namespace NathanAGood;
class XMLWriter
{
   // Implementation here...
}

$writer = new NathanAGood::XMLWriter();

?>

Web 2.0 features

Depending on how you use PHP and what your scripts look like now, the language and syntax differences in PHP V6 may or may not affect you as much as the next features, which are those that directly allow you to introduce Web 2.0 features into your PHP application.

SOAP

SOAP is one of the protocols that Web services "speak" and is supported in quite a few other languages, such as the Java programming language and Microsoft® .NET. Although there are other ways to consume and expose Web services, such as Representational State Transfer (REST), SOAP remains a common way of allowing different platforms to have interoperability. In addition to SOAP modules in the PHP Extension and Application Repository (PEAR) library, a SOAP extension to PHP was introduced in V5. This extension wasn't enabled by default, so you have to enable the extension or hope your ISP did. In addition, PEAR packages are available that allow you to build SOAP clients and servers, such as the SOAP package.

Unless you change the default, the SOAP extension will be enabled for you in V6. These extensions provide an easy way to implement SOAP clients and SOAP servers, allowing you to build PHP applications that consume and provide Web services.

If SOAP extensions are on by default, that means you won't have to configure them in PHP. If you develop PHP applications and publish them to an ISP, you may need to check with your ISP to verify that SOAP extensions will be enabled for you when they upgrade.

XML

As of PHP V5.1, XMLReader and XMLWriter have been part of the core of PHP, which makes it easier for you to work with XML in your PHP applications. Like the SOAP extensions, this can be good news if you use SOAP or XML because PHP V6 will be a better fit for you than V4 out of the box.

The XMLWriter and XMLReader are stream-based object-oriented classes that allow you to read and write XML without having to worry about the XML details.

Things removed

In addition to having new features, PHP V6 will not have some other functions and features that have been in previous versions. Most of these things, such as register_globals and safe_mode, are widely considered "broken" in current PHP, as they may expose security risks. In an effort to clean up PHP, the functions and features listed in the next section will be removed, or deprecated, from PHP. Opponents of this removal will most likely cite issues with existing scripts breaking after ISPs or enterprises upgrade to PHP V6, but proponents of this cleanup effort will be happy that the PHP team is sewing up some holes and providing a cleaner, safer implementation.

Features that will be removed from the PHP version include:

magic_quotes
register_globals
register_long_arrays
safe_mode

magic_quotes

Citing portability, performance, and inconvenience, the PHP documentation discourages the use of magic_quotes. It's so discouraged that it's being removed from PHP V6 altogether, so before upgrading to PHP V6, make sure that all your code avoids using magic_quotes. If you're using magic_quotes to escape strings for database calls, use your database implementation's parameterized queries, if they're supported. If not, use your database implementation's escape function, such as mysql_escape_string for MySQL or pg_escape_string for PostgreSQL. Listing 2 shows an example of magic_quotes use.

Using magic_quotes (discouraged)

// Assuming magic_quotes is on...
$sql = "INSERT INTO USERS (USERNAME) VALUES $_GET['username']";
?>

After preparing your PHP code for the new versions of PHP, your code should look like that in Listing 3.

Listing 3. Using parameterized queries (recommended)

// Using the proper parameterized query method for MySQL, as an example
$statement = $dbh->prepare("INSERT INTO USERS (USERNAME) VALUES ?");
$statement->execute(array($_GET['username']));
?>

Now that support for magic_quotes will be completely removed, the get_magic_quotes_gpc() function will no longer be available. This may affect some of the older PHP scripts, so before updating, make sure you fix any locations in which this functions exists.

register_globals

The register_globals configuration key was already defaulted to off in PHP V4.2, which was controversial at the time. When register_globals is turned on, it was easy to use variables that could be injected with values from HTML forms. These variables don't really require initialization in your scripts, so it's easy to write scripts with gaping security holes. The register_globals documentation provides much more information about register_globals. See Listing 4 for an example of using register_globals.

Using register_globals (discouraged)

// A security hole, because if register_globals is on, the value for user_authorized
// can be set by a user sending them on the query string
// (i.e., http://www.example.com/myscript.php?user_authorized=true)
if ($user_authorized) {
   // Show them everyone's sensitive data...
}
?>

If your PHP code uses global variables, you should update it. If you don't update your code to get prepared for newer versions of PHP, consider updating it for security reasons. When you're finished, your code should look like Listing 5.

Listing 5. Being specific instead (recommended)

function is_authorized() {
   if (isset($_SESSION['user'])) {
       return true;
   } else {
       return false;
   }
}

$user_authorized = is_authorized();
?>

register_long_arrays

The register_long_arrays setting, when turned on, registers the $HTTP_*_VARS predefined variables. If you're using the longer variables, update now to use the shorter variables. This setting was introduced in PHP V5 — presumably for backward-compatibility — and the PHP folks recommend turning it off for performance reasons. Listing 6 shows an example of register_long-arrays use.

Using deprecated registered arrays (discouraged)

   // Echo's the name of the user value given on the query string, like
   // http://www.example.com/myscript.php?username=ngood
   echo "Welcome, $HTTP_GET_VARS['username']!";
?>

If your PHP code looks like that shown in Listing 6, update it to look like that in
 Listing 7. Shut off the  register_long_arrays setting if
 it's on and  test your scripts again.

Using $_GET (recommended)

   // Using the supported $_GET array instead.
   echo "Welcome, $_GET['username']!";
?>

safe_mode

The safe_mode configuration key, when turned on, ensures that the owner of a file being operated on matches the owner of the script that is executing. It was originally a way to attempt to handle security when operating in a shared server environment, like many ISPs would have. (For a link to a list of the functions affected by this safe_mode change, Your PHP code will be unaffected by this change, but it's good to be aware of it in case you're setting up PHP in the future or counting on safe_mode in your scripts.

PHP tags

Microsoft Active Server Pages (ASP)-style tags — the shorter version of the PHP tags — are no longer supported. To make sure this is not an issue for your scripts, verify that you aren't using the <% or %> tags in your PHP files. Replace them with and ?>.

             FreeType 1 and GD 1
              The PHP team is removing support for both FreeType 1 and GD 1, citing the age and lack   of ongoing developments of  both libraries as the reason. Newer versions of both of   these libraries are available that provide better  functionality. For more information   about FreeType and  GD 
                              ereg             
             The ereg extension, which supports Portable Operating System   Interface (POSIX) regular expressions, is being removed from core PHP support. If you   are using any of the POSIX  regex functions, this change will affect you unless you   include the ereg functionality. If you're using POSIX regex   today, consider taking the  time to update your regex functions to use the   Perl-Compatible Regular Expression  (PCRE) functions because they give you more features   and perform better. Table  1 provides a list of the POSIX regex functions that will not be available after   ereg is removed. Their PCRE replacements are also shown.



Installing PHP6 (For beginners)
2008-06-24T22:39:00.000-07:00
Installing PHP6 (For beginners)

Hello all, you might have read that PHP6 is under and has been under development for the past few months. Well after hacking around some code trying to get some DirectoryIterator unicoded and ready for php6, I have ran into the problem of compiling php6.. So I figured, might as well give an idea to anyone who feels like on how to install (compile) php6.
Notice that I will be using the command:
 su -c "command" 
Which is because some system do not have sudoers setup yet (yes it does still exist) 
Ok, before reading this, here's a couple usefull links:

http://php.net/
http://php.net/anoncvs.php  (Most used here)
http://snaps.php.net/
http://cvs.php.net/
http://site.n.ml.org/info/flex/
http://icu.sourceforge.net/download/3.6.html


Hello all, you might have read that PHP6 is under and has been under development for the past few months. Well after hacking around some code trying to get some DirectoryIterator unicoded and ready for php6, I have ran into the problem of compiling php6.. So I figured, might as well give an idea to anyone who feels like on how to install (compile) php6.


There is also a numerous amount of tools you'll have to install before you might become able to try to compile PHP6.
autoconf: 2.13
automake: 1.4+
libtool: 1.4.x+ (except 1.4.2)
bison: 1.28, 1.35, 1.75, 2.0 or higher
flex: 2.5.4
re2c: 0.9.11+

Of course, all this information can be found on the php's page  (http://php.net/anoncvs.php )

Also, the coolest part of this (The heart of php6 imho - else than andrei and sara (joking))) is that package you'll have to install:
http://icu.sourceforge.net/download/3.6.html

You can start by executing the following commans:
 mkdir ~/development; cd ~/development
wget ftp://ftp.software.ibm.com/software/globalization/icu/3.6/icu4c-3_6-src.tgz
   + ^ This is for linux of course
 tar -xzvf icu4c-3_6-src.tgz
cd icu; cd source
 su -c "mkdir /usr/local/icu"
 ./configure --prefix=/usr/local/icu && make && make install
   ^ You might get an error related to zlib (Version to low, I strongly suggest to update it if
    you get the error)

So what? You are done with ICU compiling ? Let's move on shall we ?

So before installing php6, you have to download it. You can choose from various places, first
you can simply look at http://snaps.php.net (Which are frequent snapshots of the cvs repository) and get the latest php6 snap or you can simply make an anonymous checkout (for those who dont' have a username here's how to do that)

It is also recommended that you put these configurations into your ~/.cvsrc file:
 cvs -z3
 update -d -P
 checkout -P
 diff -u

Then you are ready to go for your anonymous cvs checkout 
(Username: "cvsread" and password "phpfi")
cvs -d :pserver:cvsread@cvs.php.net:/repository login
cvs -d :pserver:cvsread@cvs.php.net:/repository checkout php6  

The previous commands will execute a cvs checkout (Get the code) and store it into ~/development/php6

Once you have installed all the tools stated above, did your checkout, and all is square here comes the second part.

You'll have to execute the following commands (Using apache2 for this example):
  cd php6
 ./buildconf
 sudo "mkdir /usr/local/php6"
 ./configure --prefix=/usr/local/php6 --with-icu-dir=/usr/local/icu --with-apxs2=/usr/bin/apxs2
   (Just using apxs2 as an example)
  ^ You can of course add more options as such as --with-mysql=/usr/bin (if mysql is in bin)
    --with-phar --with-bz2. Just see the command "./configure --help" for a list of options.

  ^ Also, if the make is dying because of some flex problems, you can use the command
    "apt-get install flex-old" or simply get the source at: http://site.n.ml.org/download/20030401085856/flex/flex-2.5.4a.tar.gz 
 then ,if it all went well of course, you type:
 make && su -c "make install"

If it all went well, then you should have the php6 files all ready to be used in /usr/local/php6 
Just give a look at it to see if you have new directories, etc.

If you used the --with-apxs(2) options, you should already be set with the apache load_modules et all. You might notice that it said LoadModule php5 well don't worry that's all good you'll just need your libphp6.so which is usually well placed when using --with-apxs.

If you are not sure, just look at your /etc/apache2/httpd.conf and /etc/apache2/mods-enabled/php5.load files to see if you have it pointing to libphp6.so (Which it probably is)

So are you ready ? Last command line command:
 - su -c "apache2ctl restart"

If you do not get an error, you should be able to go to your web directory 
(Here I am using /var/www on my development box) and add a file with this content:

    phpinfo();
?>

If you are lucky and it all went well, then you will see "PHP Version 6.0.0-dev" with probably a million warnings. Well it is installed, you can start fiddling around and testing.

Hope this helps a couple people (Even though a lot of you probably gave me hints during this crusade)


PHP Paging Code: Break up records into pages
2008-06-24T02:58:00.000-07:00
<!-- 
  ============= Connection.php =================
  //-->
  <?
  $server = "localhost"; 
  $user = "root"; 
  $pass = ""; 
$OpSe = mysql_connect($server, $user, $pass ) or die(mysql_error()):
  $OpDb = mysql_select_db("DATABASE_NAME",$OpSe) or die(mysql_error());
  ?>
 
 
 
<!-- 
  ============= Paging.php =================
  //-->
  <style type="text/css">
  a.spage:link{
  border: 1px solid #000000;font-family:verdana; font-size:10px;padding-top:1px; padding-bottom:2px;padding-left:4px;padding-right:4px;color:white;font-weight:bold;text-decoration:none;background-color:#ffffff; color:#000000;
  }
a.lspage:link{
  border: 1px solid #000000;font-family:verdana; font-size:10px;padding-top:1px; padding-bottom:2px;padding-left:4px;padding-right:4px;color:white;font-weight:bold;text-decoration:none; color:#000000;
  }
  </style>
  <?
  // set record display per page....
  $PP = 10;
  //---------------
  isset($_GET["st"]) && $_GET["st"]!="" ? $st=$_GET["st"] : $st=0;
  ?>
  <table border="1">
  <tr bgcolor="#999999">
  <td><b>Field1 Date</b></td>
  <td><b>Field2 Date</b></td>
  <td><b>Field3 Date</b></td>
  <td><b>Field4 Date</b></td> 
  </tr>
  <?
  $query ="SELECT field1, field2, field3, field4 FROM TABLE_NAME LIMIT ".$st.",".$PP;
  $rs = mysql_query($query) or die(mysql_error()); 
  while($row = mysql_fetch_array($rs)){
  ?>
  <tr bgcolor="#CCCCCC">
  <td><?=$row["field1"]?></td>
  <td><?=$row["field2"]?></td>
  <td><?=$row["field3"]?></td>
  <td><?=$row["field4"]?></td> 
  </tr>
  <?
  }
  ?>
  </table>
  <table border="0" cellpadding="0" cellspacing="0" width="99%" align="center">
  <tr>
  <td width="1%">
  <? if($st>=$PP){?>
  <a href="?st=<?=$st-$PP?>">Pre</a>
  <? }?>
  </td>
  <td align="center"> 
  <? 
  // Do not change below this line----------------------------------------- 
  $total--; 
  $pgv = $total/$PP;
  
  if($pgv>1)
  $pg_a = explode(".",$pgv); 
  else
  $pg_a = $pgv; 
  
  if($pg_a[1]>0)
  $pg = $pg_a[0]+1; 
  else
  $pg = 0;
  
  if($pg=="")$pg = $pgv;
  $selpage = $st / $PP;
  $selpage++;
  $selpage = (int) $selpage; 
  for($ploop=1,$stl=1    ;$ploop<=$pg;$ploop++,$stl+=$PP){
  echo ' <a href="?st='.$stl.'" class="';
  echo $ploop==$selpage ? "spage" : "lspage";
  echo '">'.$ploop.'</a> ';
  }
  // Do not change above this line-----------------------------------------
  ?>
  </td>
  <td align="right" width="1%">
  <? if($st<$total-$PP){?>
  <a href="?st=<?=$st+$PP?>">Next</a>
  <? }?>
  </td>
  </tr>
  </table> 


Advertisement
2008-06-21T09:54:00.000-07:00








Bandwidth Test, Speed Test
2008-06-18T02:40:00.000-07:00
<?php 
/*** Bandwidth Tester 0.92 ***/ 
  /* Please wait for 1.0 patiently! */ 

 
// How many bytes to test with. Mimimum=70. 128KB=131072. 1MB=1048576 
  $testsize = 1048576; 
 
header ("Expires: Mon, 26 Jul 1997 05:00:00 GMT");    // Date in the past 
  header ("Last-Modified: " . gmdate("D, d M Y H:i:s") . " GMT"); 
  // always modified 
  header ("Cache-Control: no-cache, must-revalidate");  // HTTP/1.1 
  header ("Pragma: no-cache");                          // HTTP/1.0 
  header ("X-Notice: "); 
  header ("X-Notice: Bandwidth-Tester is freeware."); 
  header ("X-Notice: You may use it freely on your site."); 
  header ("X-Notice: Just don't remove this notice."); 
  header ("X-Notice: To get the source code, run this script "); 
  header ("X-Notice: with downloadme=1 in the query string."); 
  
  
  
  
  /* How does it work? The script generates a variable amount of random data 
  * sends it to the client and measures the time taken for transmission. The 
  * bandwidth is then calculated from the time using a simple algorithm. 
  * 
  * WARNING: This script can bog down your server - as absolutely NO 
  *          optimization was used. 
  * 
  * 
  * This script is best run on the Zend PHP Engine, with Zend Optimizer. 
  * Any improvement in performance is not guaranteed with other 
  * PHP Engines. 
  * 
  * History: 
  *          0.9 - First public release 
  *         0.91 - Reduced the size of the timing code 
  *         0.92 - Reduced the size of the timing code even more 
  * Forecast: 
  *       0.921a - Adding a smaller test before the main to make results more accurate and to adjust test data according to first results 
  *          1.0 - Looking to adding optimization code 
  *          1.1 - Adding template support 
  *          1.2 - Adding web-based administration 
  */ 
  
  
  
  
  if($downloadme==1){ 
  echo "<html><body>"; 
  show_source($SCRIPT_FILENAME); 
  echo "</body></html>"; 
  } 
  else { 
// First, initialize the test comment 

// seed random 
  srand ((double) microtime() * 1000000); 

 
if($testsize<70) {die("<script>alert('The test string size is less than 70. Cannot test.')</script>"); 
  } 
  $realtestsize = $testsize - 70; 
  function GetTestString($drealtestsize){ 
  $duhteststring = "<!"."--"; 
  for($i=0;$i<$drealtestsize; $i++){ 
  $duhteststring .= generatekeycode(); 
  } 
  $duhteststring .= "-"."->"; 
  return $duhteststring; 
  } 
  function CalculateBandwidth($Ditt,$Dott){ 
  $Datasize=$Dott; 
  $LS=$Datasize/$Ditt; 
  $kbps=(($LS*8)*10*1.02)/10; 
  $mbps=$kbps/1024; 
  if($mbps>=1){$speed=$mbps." Mbps aka ".$kbps." Kbps";} 
  else {$speed=$kbps." Kbps aka ".$mbps." Mbps";} 
  $speed .="<br>Time taken to test connection: ".(($Ditt*1024)/1000)." Seconds <br>A number used to determine your speed: ".$LS."<br>Another number used to determine your speed: ".$Ditt."<br>Tested your connection with ".$Datasize."Bytes/".($Datasize/1024)."KB/".($Datasize/1048576)."MB of random data<br>"; 
  return $speed; 
  } 
function generatekeycode(){ 
  // srand ((double) microtime() * 1000000); 
// Made the randomizer a little more "random"! :) 
  srand ((double) microtime() * rand(100000,1000000) / rand(1,15)); 
  $tester = rand(33,255); 
  if($tester==45)return generatekeycode(); 
  return chr($tester); 
  } 
  ?><html> 
  <head><title>Bandwidth Tester</title></head> 
  <body><?php 
  if($HTTP_SERVER_VARS["REQUEST_METHOD"]=="GET" && $HTTP_GET_VARS["execute"]!="1"){ 
  echo('<form action="'.$HTTP_SERVER_VARS["SCRIPT_NAME"].'" method="GET"> 
  <input type="submit" value="Click Here To Begin Testing" onClick="this.value="Please wait while your request is being processed, it may take a while"> 
  <input type="hidden" name="execute" value="1"> 
  <input type="hidden" name="DO.NOT.CACHE" value="'.rand(255,65536).'"> 
  </form>');} 
  elseif($HTTP_GET_VARS["execute"]=="1"){ 
  $teststring=GetTestString($realtestsize);echo('<form method="POST" action="'.$HTTP_SERVER_VARS["SCRIPT_NAME"].'"> 
  <input type="hidden" name="td" value="No Test"> 
  <input type="button" value="Please wait while your request is being processed, it may take a while"> 
  </form> 
  <script language="JavaScript"> 
  var Hi = new Date(); 
  </script>'.$teststring.'<script language="JavaScript"> 
  var Bye = new Date(); 
  var NiHao = new Array(Hi.getTime(),Bye.getTime()); 
  var Factor=1024; 
  if(NiHao[1]==NiHao[0]) 
  Ditt=0; 
  else 
  Ditt=(NiHao[1]-NiHao[0])/Factor; 
  document.forms[0].elements[0].value=Ditt; 
  document.forms[0].submit(); 
  </script><p>Tested. Now processing your request....</p>');} 
  elseif($HTTP_SERVER_VARS["REQUEST_METHOD"]=="POST"&&$HTTP_POST_VARS["td"]>0){ 
  echo('<p>We have tested your Internet connection.<br> 
  The speed to which you connected to us is '.CalculateBandwidth($HTTP_POST_VARS["td"],$testsize).' 
  Thank you!<br> 
  </p>');} 
  elseif($HTTP_SERVER_VARS["REQUEST_METHOD"]=="POST"&&$HTTP_POST_VARS["td"]==0){ 
  echo('<p>We were unable to test your connection speed.<br>It was too fast to measure.<br> 
  <a href="'.$HTTP_SERVER_VARS["SCRIPT_NAME"].'?execute=1&DO.NOT.CACHE='.rand(255,65536).'" onClick="this.innerText=\'The system is now generating the random test data to benchmark your connection speed. It will take a while.\'">If you would like to try testing again, click here.</a></p> 
  <p>'.CalculateBandwidth($HTTP_POST_VARS["td"],$testsize).'</p>'); 
  } 
  ?> 
  </body> 
  </html><?php } ?> 

for more details visit:
 http://www.yourip.zxq.net



Number of days between two dates
2008-06-18T02:37:00.000-07:00
Get Number of Days between two difference dates
<?php
  // Set the default timezone to US/Eastern
  date_default_timezone_set('US/Eastern');
// Will return the number of days between the two dates passed in
  function count_days($a, $b) {
  // First we need to break these dates into their constituent parts:
  $a_parts = getdate($a);
  $b_parts = getdate($b);
 // Now recreate these timestamps, based upon noon on each day
  // The specific time doesn't matter but it must be the same each day
  $a_new = mktime(12, 0, 0, $a_dt['mon'], $a_dt['mday'], $a_dt['year']);
  $b_new = mktime(12, 0, 0, $b_dt['mon'], $b_dt['mday'], $b_dt['year']);
 // Subtract these two numbers and divide by the number of seconds in a
  //  day.  Round the result since crossing over a daylight savings time
  //  barrier will cause this time to be off by an hour or two.
  return round(abs($a_new - $b_new) / 86400);
  }
// Prepare a few dates
  $date1 = strtotime('12/3/1973 8:13am');
  $date2 = strtotime('1/15/1974 10:15pm');
  $date3 = strtotime('2/14/2005 1:32pm');
// Calculate the differences, they should be 43 & 11353
  echo "<p>There are ", count_days($date1, $date2), " days.</p>";
  echo "<p>There are ", count_days($date2, $date3), " days.</p>";
  ?>

PHP Scripts, User Based Scripts, Link Based Scripts, URL Based Scripts, Form Based Scripts

Resize Image in PHP

Format File Size

Get the list of folders and/or Files

How to Strip file Extension

Simple function to read directory contents

Compressing Zip file in PHP

Format US phone number

Shows how to use the build-in function "wordwrap" to create line breaks by a user definied length.

How to use the similar_text function to compare similar words

Use the soundex() function to test if words sound similar

perg_replace technique

Checks whether $string begins with $search

Make String usable as a URI

Convert String to HEX

Convert Hex to String

PHP Text Spell Checker

Spell Check Some Text

Correction form:

Your Corrected Text:

PHP Source:

Add Days to a Date

Convert Date into SQL Date Format

Chage Date Format

PHP interview Question

PHP interview Preperation

The Difference Between require() and include()

PHP htmlentities Function

PHP - Filing

PHP substr_replace Function

PHP - String Explode

PHP - Array implode

PHP Pattern

PHP OOPS - Classes and Objects

Advanced PHP Topics - Superglobals

Resizing images with PHP

-------------------Usage-------------------

PHP Source Code for Manually Registering Global Variables

Methodology and Implementation

Difference From register_globals = On

Creating a chat script with PHP and Ajax

How it works

Creating the server

Creating the client

PHP & Security: 3 Example Exploits

Introduction

Security Case #1 - E-mail Injection

PHP Global Variables

Using globals and the global keyword

Google tips and tricks- Google don'ts

Simple Mini Poll class library

How to create and use Favicon.ico file

User Online Class

PHP Array

PHP Require

PHP Include

Passing JavaScript variables to PHP

Screen Resolution:

How to Get the Current Page URL in PHP

PHP: Dynamic Image Generation

Stored Procedures in MySQL

Recursive function in PHP

PHP Interview Questions and Answers

Generating CAPTCHA Image Using PHP

File Uploading in PHP

Using session in PHP

Email validation using PHP regular expression

Associative arrays in PHP

Sorting an Array in PHP

Developer Wallpapers

Desktop Wallpapers - PHP

The future of PHP 6

Installing PHP6 (For beginners)

PHP Paging Code: Break up records into pages

Advertisement

Bandwidth Test, Speed Test

Number of days between two dates