Hot Scripts Blog » PHP

PHP Parameter Skipping and Named Parameters – Finally?

seoegghead — Thu, 07 Jan 2010 15:38:19 +0000

Well, sort of; it’s not 100% native, but it works, and requires only 1 simple cut-and-pasted line added per function to implement. This article will detail how to do so, as well as the gist of its inner workings. It’s certainly easy to grep up complaints and feature requests for both parameter skipping and named parameters – two oft-wanted language features. Stanislav Malyshev, a core PHP developer says on his “PHP 10.0″ blog that he misses these features in August, 2009 (http://php100.wordpress.com/2009/08/21/syntax-i-miss-in-php/). Unfortunately, as we’ll document below, not everyone agrees.

Many other high-level languages support these features as well. No matter. We’ll examine a nice little workaround approach and implement it. Let’s first peruse an example of a hypothetical function that may benefit from these features:

function getUsers($id=null, $group_id=1, $username = ”, $order=’order_fld’, $order_asc=1) {
return $users_matching_all_criteria;
}

As to whether 1 public function/method with so many parameters is good practice is beyond the scope of this article – it’s just a (somewhat contrived) example! However, one may take the approach of lightly wrapping such a function with special dedicated getters, i.e.:

function getUserByUsername($username) {
return getUsers(null, 1, $username);
}

This is a valid approach. However, it represents a bunch of meaningless mechanical coding work. We must have something more productive to do. Calling the function directly is, of course, even less desirable:

getUsers(null, 1, ‘bob’);

And this will inevitably result in many “off-by-1” errors in parameter passing, as well as hard-coding defaults.

So wouldn’t it be nice if there were a better way — an easy way to specify the setting via a named list or skip over parameters with ease?

Unfortunately, there is no totally native way to do this. Both of the below code snippets or similar might work in another language, but – alas – not PHP:

getUsers(, , $username); // Hypothetical; this does not work!

or –

getUsers(‘username’ => $username); // Hypothetical; this does not work!

Such a syntax would preserve the defaults implicitly, while allowing the programmer to modify those parameters that matter to the task at hand. PHP IDEs that implement implicit code completion could still indicate the defaults based on the function prototype. As another perk, it permits the programmer to retroactively change a default without locating all references to that function. If this is not desired, simply do as one must in PHP currently anyway – hard-code the default value in a particular function call.

Many have proposed solutions that involve the use of hashed arrays as 1 argument, but this involves a lot of repetitive work, and the function no longer works via a list-based syntax unless a lot of code for both types of parameter syntaxes is written. This will also disable the implicit code completion support of various PHP IDEs. We happen to use Zend Studio for development, and we find that particular feature enhances our productivity.

We will present an implementation of the above features with a 1 line snippet (an include() file) as the first line of every applicable function like so:

(Note: No changes are made to the prototype, and implicit code completion with the various PHP IDEs will even document the function calls!)

function getUsers($id=null, $group_id=1, $username = ”, $order=’order_fld’, $order_asc=1) {

include(par.php); // hook in the Par code

… code …

}

One may then call the function like so:

getUsers(_, _, $username); // Note the underscores.

or –

getUsers(PAR( array(‘username’ => $username) ));

or even mix named and skipped parameters –

getUsers(_. PAR( array(‘username’ => $username) ) );

or even –

getUsers(_. PAR(‘username’, $username));

(Note: If “_” presents a problem, another safer constant may be chosen. PHP itself allows extended characters 128..255 to be used in the constant and variable grammars. We briefly examined using “¬¨ (not symbol),” but this is very difficult to key on Windows machines; and just plain annoying on Macs.)

As for native support in PHP 6, don’t count on it:

A PHP “Developer Minutes” says there is no “… real need for named parameters.” And it states further that that they “… do not want to add it” (http://www.php.net/~derick/meeting-notes.html#named-parameters). The “PHP Todo Backlog” (http://wiki.php.net/todo/backlog#dropped_items) lists named parameters under “Dropped Items.” Skipped parameters are not mentioned at all in either, but as aforementioned, Stanislav has mentioned he’d like to see them.

Our non-native syntax is not even terribly unwieldy, and it’s unlikely to break much, as it’s on a per-function basis. If the PHP team decides to introduce the features natively, it will not conflict for a few reasons. A constant is used instead of an empty parameter – the most likely native syntax for an implementation of parameter skipping. The PAR object is even less of a problem and wraps all named parameters. “par.php” handles and abstracts it all, and is itself a combination of reflection and elegant hackery. It is all blissfully encapsulated inside one simple include call. So what gives – why an include?

Well, include is a pseudo-closure of sorts. Anything within the include retains the scope of the parent without specifying the particular variables as with PHP’s closure support. It is of this form:

$returnval = include(‘FILE_FUNC_NAME’);

All parameters in the current scope are “passed” by reference to the “function” within FILE_FUNC_NAME. The speed-penalty is on the order of half a millisecond per call – half of which seems to be from the include, and the other from the reflection API. Then penalty, of course, is only present for those functions where it is implemented. APC seems to speed it up as well, though we didn’t benchmark as much this way.

It’s simple on the outside, and trivial to implement on a per-function basis. As far as we can tell, PHP 5.3′s closures cannot easily accomplish the same due to their requirement of explicitly stating relevant variables in “use.” This implementation does not require PHP 5.3, and works with any version of PHP with support for reflection. You may download the applicable code and see more examples of implementation at the below URL:
http://seoegghead.com/software/PHP-parameter-skipping-and-named-parameters.seo
Limitations:
So far reference parameters are not implemented for PAR(), and there may be limitations with objects or it may create a copy where you might not expect. we just rarely use reference parameter passing in our design patterns. In PHP, references are a tool of convenience, not performance. Feel free to fix or contribute, and we’ll credit your contribution. Enjoy!

Author: SEO Egghead

SEO Egghead is a web development firm dedicated to creating custom, search-engine-optimized web site applications.

Post from: Hot Scripts Blog

PHP Parameter Skipping and Named Parameters – Finally?

Developing State-enabled Applications With PHP

DEVpapers — Tue, 15 Dec 2009 03:01:59 +0000

When a user is browsing through a website and is surfing from one web page to another, sometimes the website needs to remember the actions (e.g. choices) performed by the user. For example, in a website that sells DVDs, the user typically browses through a list of DVDs and selects individual DVDs for check out at the end of the shopping session. The website needs to remember which DVDs the user has selected because the selected items needs to be presented again to the user when the user checks out. In other words, the website needs to remember the State – i.e. the selected items – of the user’s browsing activities. However, HTTP is a Stateless protocol and is ill-equipped to handle States. A standard HTML website basically provides information to the user and a series of links that simply directs the user to other related web pages. This Stateless nature of HTTP allows the website to be replicated across many servers for load balancing purposes. A major drawback is that while browsing from one page to another, the website does not remember the State of the browsing session. This make interactivity almost impossible.

In order to increase interactivity, the developer can use the session handling features of PHP to augment the features of HTTP in order to remember the State of the browsing session. The are basically 2 ways PHP does this:

- Using cookies
- Using Sessions

The next installment discusses how to manage sessions using cookies…

Cookies

Cookies are used to store State-information in the browser. Browsers are allowed to keep up to 20 cookies for each domain and the values stored in the cookie cannot exceed 4 KB. If more than 20 cookies are created by the website, only the latest 20 are stored. Cookies are only suitable in instances that do not require complex session communications and are not favoured by some developers because of privacy issues. Furthermore, some users disable support for cookies at their browsers.

- The following is a typical server-browser sequence of events that occur when a cookie is used:
- The server knows that it needs to remember the State of browsing session
- The server creates a cookie and uses the Set-Cookie header field in the HTTP response to pass the cookie to the browser
- The browser reads the cookie field in the HTTP response and stores the cookie
- This cookie information is passed along future browser-server communications and can be used in the PHP scripts as a variable

PHP provides a function called setcookie() to allow easy creation of cookies. The syntax for setcookie is:

int setcookie(string name, [string val], [int expiration_date], [string path], string domain, [int secure])

The parameters are:

name – this is a mandatory parameter and is used subsequently to identify the cookie
value – the value of the cookie – e.g. if the cookie is used to store the name of the user, the value parameter will store the actual name – e.g. John
expiration_date – the lifetime of the cookie. After this date, the cookie expires and is unusable
path – the path refers to the URL from which the cookie is valid and allowed
domain – the domain the created the cookie and is allowed to read the contents of the cookie
secure – specifies if the cookie can be sent only through a secure connection – e.g. SSL enable sessions

The following is an example that displays to the user how many times a specific web page has been displayed to the user. Copy the code below (both the php and the html) into a file with the .php extension and test it out.

//check if the $count variable has been associated with the count cookie
if (!isset($count)) {
$count = 0;
} else {
$count++;
}
setcookie(“count”, $count, time()+600, “/”, “”, 0);
?>

<head>
Session Handling Using Cookies

This page has been displayed: times.

The next installment discusses how to manage sessions using PHP session handling functions with cookies enabled…

PHP Session Handling – Cookies Enabled

Instead of storing session information at the browser through the use of cookies, the information can instead be stored at the server in session files. One session file is created and maintained for each user session. For example, if there are three concurrent users browsing the website, three session files will be created and maintained – one for each user. The session files are deleted if the session is explicitly closed by the PHP script or by a daemon garbage collection process provided by PHP. Good programming practice would call for sessions to be closed explicitly in the script.

The following is a typical server-browser sequence of events that occur when a PHP session handling is used:
The server knows that it needs to remember the State of browsing session
PHP generates a sssion ID and creates a session file to store future information as required by subsequent pages
A cookie is generated wih the session ID at the browser
This cookie that stores the session ID is transparently and automatically sent to the server for all subsequent requests to the server

The following PHP session-handling example accomplishes the same outcome as the previous cookie example. Copy the code below (both the php and the html) into a file with the .php extension and test it out.

//starts a session
session_start();

//informs PHP that count information needs to be remembered in the session file
if (!session_is_registered(“count”)) {
session_register(“count”);
$count = 0; } else {
$count++;
}
$session_id = session_id(); ?>

PHP Session Handling – Cookie-Enabled

The current session id is:
This page has been displayed: times.

>

A summary of the functions that PHP provides for session handling are:

boolean start_session() – initializes a session
string session_id([string id]) – either returns the current session id or specify the session id to be used when the session is created
boolean session_register(mixed name [, mixed ...]) – registers variables to be stored in the session file. Each parameter passed in the function is a separate variable
boolean session_is_registered(string variable_name) – checks if a variable has been previously registered to be stored in the session file
session_unregister(string varriable_name) – unregisters a variable from the session file. Unregistered variables are no longer valid for reference in the session.
session_unset() – unsets all session variables. It is important to note that all the variables remain registered.
boolean session_destroy() – destroys the session. This is opposite of the start_session function.

The next installment discusses how to manage sessions using PHP session handling functions when cookies are disabled…

PHP Session Handling – Without Cookies

If cookies are disabled at the browser, the above example cannot work. This is because although the session file that stores all the variables is kept at the server, a cookie is still needed at the browser to store the session ID that is used to identify the session and its associated session file. The most common way around this would be to explicitly pass the session ID back to the server from the browser as a query parameter in the URL.

For example, the PHP script generates requests subsequent to the start_session call in the following format:

http://www.yourhost.com/yourphpfile.php?PHPSESSID=[actual session ID]

The following are excerpts that illustrate the discussion:

Manually building the URL:

$url = “http://www.yoursite.com/yourphppage.php?PHPSESSID=” . session_id();
”>Anchor Text

Building the URL using SID:

http://www.yoursite.com/yourphppage.php? ?>”>Anchor Text

This article is written by daBoss. daBoss is the Webmaster of Designer Banners. daBoss can be contacted at sales (at) designerbanners (dot) com.

Post from: Hot Scripts Blog

Developing State-enabled Applications With PHP

Displaying An RSS Feed On Your Website Using PHP And MagpieRSS

DEVpapers — Tue, 15 Dec 2009 03:01:59 +0000

These days everybody wants to have fresh content on their web site. Search engines like to see dynamic web pages, where the content is updated on a regular basis. Static pages that have information that doesn’t change are not only boring, but less likely to be visited by a search engine spider than a page that changes every time it is displayed. By using RSS and the MagpieRSS toolkit, you can import data from another web site or news source and display that information on your own site.

First, download the MagpieRSS kit from http://magpierss.sourceforge.net.

Next, unpack the archive, into a directory off your root on your web site called “rss”.

Then, create a directory off your root called “cache”. CHMOD this directory to 777.

You’ll need to know the URL for the feed that you want to display. You can find this by searching for “RSS feed” in Google, or by going to one of the many sites that allow you to search thrown various sources for feeds. Syndic8.com is one, for example.

To display data from a single source, you can use code similar to this:

require_once(‘rss/rss_fetch.inc’);

$news_feed = ”;

error_reporting(E_ERROR);

$rss = fetch_rss(“http://www.url-of-the-rss-feed.com“);
$items = array_slice($rss->items, 0);
foreach ($items as $item )
{
$news_feed .= ” . $item['title'] . ” . $item['summary'] . ”;
}

echo $news_feed;

MagpieRSS not only decodes the data, but it will also cache the data so it will retrieve news articles only once per hour.

Utilizing RSS in this fashion will allow your web site to have fresh content displayed constantly, and will (hopefully!) keep the search engine spiders interested in your site. The more the spiders index your site, the more pages you will have listed in the search engines. And with more pages listed in the search engine indexes you have a much better chance of attracting people to your web site.

Author: Mikel Beck
Mikel Beck is the owner of a number of web sites, the latest being The Happy Hour Pub.

Post from: Hot Scripts Blog

Displaying An RSS Feed On Your Website Using PHP And MagpieRSS

Developing a Login System with PHP and MySQL

DEVpapers — Tue, 15 Dec 2009 03:01:59 +0000

A basic login system typically contains 3 components:

The component that allows a user to register his preferred login id and password
The component that allows the system to verify and authenticate the user when he subsequently logs in
The component that sends the user’s password to his registered email address if the user forgets his password

Such a system can be easily created using PHP and MySQL.

Component 1 – Registration

Component 1 is typically implemented using a simple HTML form that contains 3 fields and 2 buttons:

A preferred login id field
A preferred password field
A valid email address field
A Submit button
A Reset button

Assume that such a form is coded into a file named register.html. The following HTML code excerpt is a typical example. When the user has filled in all the fields, the register.php page is called when the user clicks on the Submit button.

[form name="register" method="post" action="register.php"]
   [input name="login id" type="text" value="loginid" size="20"/][br]
   [input name="password" type="text" value="password" size="20"/][br]
   [input name="email" type="text" value="email" size="50"/][br]
   [input type="submit" name="submit" value="submit"/]
   [input type="reset" name="reset" value="reset"/]
[/form]

The following code excerpt can be used as part of register.php to process the registration. It connects to the MySQL database and inserts a line of data into the table used to store the registration information.

@mysql_connect("localhost", "mysql_login", "mysql_pwd") or die("Cannot connect to DB!");
@mysql_select_db("tbl_login") or die("Cannot select DB!");
$sql="INSERT INTO login_tbl (loginid, password and email) VALUES (".$loginid.”,”.$password.”,”.$email.”)”;
$r = mysql_query($sql);
if(!$r) {
   $err=mysql_error();
   print $err;
   exit();
}

The code excerpt assumes that the MySQL table that is used to store the registration data is named tbl_login and contains 3 fields – the loginid, password and email fields. The values of the $loginid, $password and $email variables are passed in from the form in register.html using the post method.

Component 2 – Verification and Authentication

A registered user will want to log into the system to access the functionality provided by the website. The user will have to provide his login id and password for the system to verify and authenticate.

This is typically done through a simple HTML form. This HTML form typically contains 2 fields and 2 buttons:

A login id field
A password field
A Submit button
A Reset button

Assume that such a form is coded into a file named authenticate.html. The following HTML code excerpt is a typical example. When the user has filled in all the fields, the authenticate.php page is called when the user clicks on the Submit button.

[form name="authenticate" method="post" action="authenticate.php"]
   [input name="login id" type="text" value="loginid" size="20"/][br]
   [input name="password" type="text" value="password" size="20"/][br]
   [input type="submit" name="submit" value="submit"/]
   [input type="reset" name="reset" value="reset"/]
[/form]

The following code excerpt can be used as part of authenticate.php to process the login request. It connects to the MySQL database and queries the table used to store the registration information.

@mysql_connect("localhost", "mysql_login", "mysql_pwd") or die("Cannot connect to DB!");
@mysql_select_db("tbl_login") or die("Cannot select DB!");
$sql="SELECT loginid FROM login_tbl WHERE loginid=’".$loginid.”’ and password=’”.$password.”’”;
$r = mysql_query($sql);
if(!$r) {
   $err=mysql_error();
   print $err;
   exit();
}
if(mysql_affected_rows()==0){
   print "no such login in the system. please try again.";
   exit();
}
else{
   print "successfully logged into system.";
   //proceed to perform website’s functionality – e.g. present information to the user
}

As in component 1, the code excerpt assumes that the MySQL table that is used to store the registration data is named tbl_login and contains 3 fields – the loginid, password and email fields. The values of the $loginid and $password variables are passed in from the form in authenticate.html using the post method.

Component 3 – Forgot Password

A registered user may forget his password to log into the website’s system. In this case, the user will need to supply his loginid for the system to retrieve his password and send the password to the user’s registered email address.

This is typically done through a simple HTML form. This HTML form typically contains 1 field and 2 buttons:

A login id field

A Submit button

A Reset buttonAssume that such a form is coded into a file named forgot.html. The following HTML code excerpt is a typical example. When the user has filled in all the fields, the forgot.php page is called when the user clicks on the Submit button.

[form name="forgot" method="post" action="forgot.php"]
   [input name="login id" type="text" value="loginid" size="20"/][br]
   [input type="submit" name="submit" value="submit"/]
   [input type="reset" name="reset" value="reset"/]
[/form]

The following code excerpt can be used as part of forgot.php to process the login request. It connects to the MySQL database and queries the table used to store the registration information.

@mysql_connect("localhost", "mysql_login", "mysql_pwd") or die("Cannot connect to DB!");
@mysql_select_db("tbl_login") or die("Cannot select DB!");
$sql="SELECT password, email FROM login_tbl WHERE loginid=’".$loginid.”’”;
$r = mysql_query($sql);
if(!$r) {
   $err=mysql_error();
   print $err;
   exit();
}
if(mysql_affected_rows()==0){
   print "no such login in the system. please try again.";
   exit();
}
else {
   $row=mysql_fetch_array($r);
   $password=$row["password"];
   $email=$row["email"];

   $subject="your password";
   $header="from:you@yourdomain.com";
   $content="your password is ".$password;
   mail($email, $subject, $row, $header);

   print "An email containing the password has been sent to you";
}

As in component 1, the code excerpt assumes that the MySQL table that is used to store the registration data is named tbl_login and contains 3 fields – the loginid, password and email fields. The value of the $loginid variable is passed from the form in forgot.html using the post method.

Conclusion

The above example is to illustrate how a very basic login system can be implemented. The example can be enhanced to include password encryption and additional functionality – e.g. to allow users to edit their login information.

Author: John L
This article is written by daBoss. daBoss is the Webmaster of Designer Banners. daBoss can be contacted at sales (at) designerbanners (dot) com.

Post from: Hot Scripts Blog

Developing a Login System with PHP and MySQL

Mastering Regular Expressions in PHP

DEVpapers — Tue, 15 Dec 2009 03:01:58 +0000

What are Regular Expressions?

A regular expression is a pattern that can match various text strings. Using regular expressions you can find (and replace) certain text patterns, for example “all the words that begin with the letter A” or “find only telephone numbers”. Regular expressions are often used in validation classes, because they are a really powerful tool to verify e-mail addresses, telephone numbers, street addresses, zip codes, and more.

In this tutorial I will show you how regular expressions work in PHP, and give you a short introduction on writing your own regular expressions. I will also give you several example regular expressions that are often used.

Regular Expressions in PHP

Using regex (regular expressions) is really easy in PHP, and there are several functions that exist to do regex finding and replacing. Let’s start with a simple regex find.

Have a look at the documentation of the preg_match function (http://php.net/preg_match). As you can see from the documentation, preg_match is used to perform a regular expression. In this case no replacing is done, only a simple find. Copy the code below to give it a try.

in between these two previous brackets";

// Let's perform the regex
$do = preg_match("/(.*)<\/bla>/", $str, $matches);

// Check if regex was successful
if ($do = true) {
	// Matched something, show the matched string
	echo htmlentities($matches['0']);

	// Also how the text in between the tags
	echo '
' . $matches['1'];
} else {
	// No Match
	echo "Couldn't find a match";
}

?>

After having run the code, it’s probably a good idea if I do a quick run through the code. Basically, the whole core of the above code is the line that contains the preg_match. The first argument is your regex pattern. This is probably the most important. Later on in this tutorial, I will explain some basic regular expressions, but if you really want to learn regular expression then it’s best if you look on Google for specific regular expression examples.

The second argument is the subject string. I assume that needs no explaining. Finally, the third argument can be optional, but if you want to get the matched text, or the text in between something, it’s a good idea to use it (just like I used it in the example).

The preg_match function stops after it has found the first match. If you want to find ALL matches in a string, you need to use the preg_match_all function (http://www.php.net/preg_match_all). That works pretty much the same, so there is no need to separately explain it.

Now that we’ve had finding, let’s do a find-and-replace, with the preg_replace function (http://www.php.net/preg_replace). The preg_replace function works pretty similar to the preg_match function, but instead there is another argument for the replacement string. Copy the code below, and run it.

stuff between the bla brackets";

// Do the preg replace
$result = preg_replace ("/(.*)<\/bla>/", "new stuff", $str);

echo htmlentities($result);
?>

The result would then be the same string, except it would now say ‘new stuff’ between the bla tags. This is of course just a simple example, and more advanced replacements can be done.

You can also use keys in the replacement string. Say you still want the text between the brackets, and just add something? You use the $1, $2, etc keys for those. For example:

stuff between the bla brackets";

// Do the preg replace
$result = preg_replace ("/(.*)<\/bla>/", "new stuff (the old: $1)", $str);

echo htmlentities($result);
?>

This would then print “Let’s replace the new stuff (the old: stuff between) the bla brackets”. $2 is for the second “catch-all”, $3 for the third, etc.

That’s about it for regular expressions. It seems very difficult, but once you grasp it is extremely easy yet one of the most powerful tools when programming in PHP. I can’t count the number of times regex has saved me from hours of coding difficult text functions.

An Example

What would a good tutorial be without some real examples? Let’s first have a look at a simple e-mail validation function. An e-mail address must start with letters or numbers, then have a @, then a domain, ending with an extension. The regex for that would be something like this: ^[a-zA-Z0-9_\.\-]+@[a-zA-Z0-9\-]+\.[a-zA-Z0-9\-\.]+$

Let me quickly explain that regex. Basically, the first part says that it must all be letters or numbers. Then we get the @, and after that there should be letters and/or numbers again (the domain). Finally we check for a period, and then for an extension. The code to use this regex looks like this:

';

// And check the bad e-mail
if (preg_match("/^[a-zA-Z0-9_\.\-]+@[a-zA-Z0-9\-]+\.[a-zA-Z0-9\-\.]+$/", $bad)) {
	echo "Valid e-mail";
} else {
	echo "Invalid e-mail";
}

?>

The result of this would be “Valid E-mail. Invalid E-mail”, of course. We have just checked if an e-mail address is valid. If you wrap the above code in a function, you’ve got yourself a e-mail validation function. Keep in mind though that the regex isn’t perfect: after all, it doesn’t check whether the extension is too long, does it? Because I want to keep this tutorial short, I won’t give the full fledged regex, but you can find it easily via Google.

Another Example

Another great example would be a telephone number. Say you want to verify telephone numbers and make sure they were in the correct format. Let’s assume you want the numbers to be in the format of xxx-xxxxxxx. The code would look something like this:

';

// And check the bad number
if (preg_match("/\d{3}-\d{7}/", $bad)) {
	echo "Valid number";
} else {
	echo "Invalid number";
}

?>

The regex is fairly simple, because we use \d. This basically means “match any digit” with the length behind it. In this example it first looks for 3 digits, then a ‘-’ (hyphen) and finally 7 digits. Works perfectly, and does exactly what we want.

What exactly is possible with Regular Expressions?

Regular expressions are actually one of the most powerful tools in PHP, or any other language for that matter (you can use it in your mod_rewrite rules as well!). There is so much you can do with regex, and we’ve only scratched the surface in this tutorial with some very basic examples.

If you really want to dig into regex I suggest you search on Google for more tutorials, and try to learn the regex syntax. It isn’t easy, and there’s quite a steep learning curve (in my opinion), but the best way to learn is to go through a lot of examples, and try to translate them in plain English. It really helps you learn the syntax.

In the future I will dedicate a complete article to strictly examples, including more advanced ones, without any explanation. But for now, I can only give you links to other tutorials:

The 30 Minute Regex Tutorial (http://www.codeproject.com/dotnet/RegexTutorial.asp)

Regular-Expressions.info (http://www.regular-expressions.info/)

Dennis Pallett is a young tech writer, with much experience in ASP, PHP and other web technologies. He enjoys writing, and has written several articles and tutorials. To find more of his work, look at his websites at http://www.phpit.net, http://www.aspit.net and http://www.webdev-articles.com

Pages:

Post from: Hot Scripts Blog

Mastering Regular Expressions in PHP

Ajax & PHP without using the XmlHttpRequest Object

DEVpapers — Tue, 15 Dec 2009 03:01:58 +0000

Introduction
Ajax is one of the biggest ‘discoveries’ in the past year, and it has become a real buzzword, just like Web 2.0. Admittedly, Ajax can be used for a lot of things, and it really does speed up web applications. Already Ajax is used by many highly popular websites, most notably GMail, but other’s like Ta-da List or Flickr also use it. Heck, even Microsoft has gotten wind of the Ajax buzz, and is actually moving towards web-based applications as well.

But there is one problem with most of the current implementations of Ajax: it has one dependency, and that is the XmlHttpRequest object. Most modern browser, like Firefox, have inbuilt support for this object, but older browsers, like Internet Explorer 6, don’t have native support for this object. Luckily, IE 6 does support it, but it’s built in as an ActiveX control, which means your visitors get an ugly warning message about the possible danger of an ActiveX control, or in some cases it just doesn’t work at all.

In this tutorial, I will show you how to use Ajax without even having to use the XmlHttpRequest object.

The Basics

If we can’t use the XmlHttpRequest object, we must find some other way to include content from another page, without having to resort to other objects or non-standard things. A great candidate for this would be the

id=“contentdiv”>

type=“button” onclick=“ajax_do (‘page1.php’);” value=“Get content” />

(View Live Demo)

If you view the live demo, or setup it up yourself, you will notice that it works just like Ajax, and probably even better in IE (no more ActiveX warnings).

Please note that for this to work in IE, the security level can’t be at ‘High’. It must be at ‘Medium’ or lower.

Author: Dennis Pallett
Dennis Pallett is a young web developer, who owns several web sites including PHPit and WebPubHQ. He has been programming for several years now, and has extensive knowledge in PHP, JavaScript, ASP and other languages.

Post from: Hot Scripts Blog

Ajax & PHP without using the XmlHttpRequest Object

PHP Server to Client with No Refresh

DEVpapers — Tue, 15 Dec 2009 03:01:58 +0000

The process of merging a client’s content and style with our templates creates an opportunity to challenge ourselves and once again put our web design skills to the test.

Recently, I found myself in a situation where it was necessary to pass information in the form of GET data from a simple flash button to a server side scripting language- all without reloading the current page. A client was running several different flash animated banners ads via XML layer popup, underlining some of her most popular website products and online services. She needed a simple way to track the overall efficiency of her small ad campaign. Specifically, she needed to know which banners were being clicked on and which banners were simply annoying or inconsequential to her client base. She also needed to know which were the most popular browsers accessing these pages.

I’ll try to describe what needed to happen with out getting too techie.

An XML layer popup would pop up, offering the end user with a two options. In Option A, one could click on the cute little popup. This would take them to wherever the popup was designed to take them. Option B was for the end user to close the popup, and that would simply hide the XML layer’s visibility property.
At first, it sounded easy. However, beyond the obvious functionality of options A and B, each option needed to open, write, and save to an external file all without refreshing the current page. After all, the last thing anyone wants to see after closing a popup is another page pop up.

Nevertheless server side scripting languages, like PHP, require a refresh of the page to pass information. Unlike JavaScript which handles its business on the client side of a client server system via your browser (the client), PHP scripts are server-side because they operate solely on the server; data is sent to via POST or GET The script is then parsed, and the new data is sent back to the browser if necessary.

Here’s the solution. I created the following .

frameborder=”0″ width=”0″ height=”0″ scrolling=”no”
>

Note that the SRC property is the location of our PHP script, which will be summoned later, to write and save to our external file. Notice our width and height properties are both set to zero.

I still submit the data to my PHP script, from within the flash banner popup
with the help of ActionScript’s cool little getURL() function:.

on(press){
GetURL(“myscript.php?banner=this&action=close”,”main”,
“GET”);
}

However because the target (main) was loaded inside our little hidden , only the refreshes. The user will not see a window refresh, the scrip will be parsed by PHP and everyone lived happily ever after.

Author: Adam Fletcher
Adam Fletcher is the webmaster of Hardware Software Articles http://www.hardwaresoftwarearticles.com .

Post from: Hot Scripts Blog

PHP Server to Client with No Refresh

PHP / Apache Templating

DEVpapers — Tue, 15 Dec 2009 03:01:57 +0000

Here’s a quick tip to have a simple template-based website. I use this method on my Textpattern-powered site and it works great!

This method does not requires any installation of PHP template engines such as Smarty, XTemplate, etc. All it takes is 2 lines in your .htaccess file.

Well, how am I doing it?

Sort answer: using Apache directives.

Longer answer: using Apache directives to auto-append and auto-prepend header and footer files.

To achieve this, do the following:

Create an HTML/PHP file with your design layout.
Break this file into 3 portions, before dynamic content, content, and after dynamic content.
Save the before portion as header.php and the after portion as footer.php in your server’s root directory.
In your .htaccess, add the following lines:php_value auto_prepend_file /header.php php_value auto_append_file /footer.php
That’s it.

Now, create your website as you normally would. Every time your pages will load, Apache will automatically “wrap” them with your header and footer files, producing your desired end result.

I recommend using the .html file extension for the header and footer files to save server load if your pages are not dynamic pages.

PLEASE NOTE: Your webhost may not allow you to use these Apache directives, so be sure to check that out before hand.

Pages:

Author: Ran Aroussi
Ran Aroussi is a computer developer & designer working with computers and the Internet since 1996. Ran interests include (but not limited to) web development, standards and programming.

Post from: Hot Scripts Blog

PHP / Apache Templating

UnitTesting in PHP using SimpleTest

DEVpapers — Tue, 15 Dec 2009 03:01:56 +0000

crcr(If you haven’t downloaded SimpleTest framework yet, click here.)

You will probably become a Test-infected developer if you try a unit testing framework! But what is unit testing?

“The basic concept of unit testing is write more code which will test the main code we’ve written, by “throwing” sample data at it and examining what it gets back.“-Harry Fuecks.

Some developers might not like the idea of writing more code but it will save you a good time pin pointing the exact piece of code causing the problem when your script becomes large.

Time to get practical about UnitTesting! We will write a test case for a simple file manipulation class. This file class will have the basic operations needed to manipulate files. It will be able to create, read, write, append and delete files and our test case should test each operation individually.
First, here is the definition of the class:
[file.class.php]


class File

{

var $filename;

/**
* Constructor
* will take care of creating the file if it does not exists.
* @param string $file
*/
function File($file)
{
if (empty($file))
die(‘Filename should not be empty’);

$this->filename = $file;

//if the file does not exists and we can not create it, terminate the script
if (!$this->exists() && !$this->create())
die(‘Unable to find/create the file’);
}

/**
* checks if the file exists or not!
* @return bool
*/
function exists()
{
return file_exists($this->filename);
}

/**
* This method will attempt to create a file if it does not exists.
* @return bool
*/
function create()
{
//if the file exists, save the trouble opening it.
if ($this->exists())
return true;

return $this->putContents(null);
}

/**
* reads the file’s contents and returns it..
* @return string
*/
function getContents()
{
return @file_get_contents($this->filename);
}

/**
* writes to the file..
* @param string $content
* @return bool
*/
function putContents($content)
{
$fp = @fopen($this->filename, ‘wb’);
$write = @fwrite($fp, $content);
@fclose($fp);

return !($write === false);
}

/**
* append data to the file..
* @param string $content
* @return bool
*/
function append($content)
{
$fp = @fopen($this->filename, ‘ab’);
$append = @fwrite($fp, $content);
@fclose($fp);

return !($append === false);
}

/**
* deletes the file..
* @return bool
*/
function delete()
{
return @unlink($this->filename);
}
}
?>

I will assume that you are able to understand how the code works since we are talking about unit testing which is far more advanced than file manipulation.
If you can’t understand how this class works, I suggest you learn first about OOP then learn about unit testing.
Anyway, it’s not the best file class out there because I created it just for this tutorial so don’t get mad about it

Writing The Test Case

Now we want to create a test case for this class to see if it works as we expect or not!
To create a test case we have to create a new class which inherits from UnitTestCase class which is found in the file unit_tester.php which comes in SimpleTest framework package.
So we create our new PHP file, let’s name it fileTest.php and include unit_tester.php and our file file.class.php:
[fileTest.php]


include_once 'simpletest/unit_tester.php';



include_once 'file.class.php';

Of course you have to change the paths to the correct paths in your environment.
We now start the definition of the test case class and let’s name it fileTest as well:

class fileTest extends UnitTestCase

{

var $file;

var $filename;

function fileTest($filename)
{
$this->filename = $filename;
$this->file = new file($this->filename);
$this->UnitTestCase(‘File Manipulation Test’);
}

function setUp()
{
$fp = @fopen($this->filename, ‘x’);
if (!($fp === false)) {
fwrite($fp, ”);
fclose($fp);
}
}

function tearDown()
{
@unlink($this->filename);
}

As you can see, we have defined 3 methods (including the constructor) and 2 data members, $file and $filename.
The constructor (fileTest) takes one argument which is the file name and assign it to the data member $filename and create the file object and assign it to $file.
The line: $this->UnitTestCase(‘File Manipulation Test’); is optional and it just makes a header line in the test reporter (we will talk about this later).

Also we have defined the methods setUp() and tearDown().
setUp() will be called automatically before each and every test and tearDown() will be called after each and every test. However, these two methods are optional.

We have defined the setUp() method to create a new clean file before each test and tearDown() will delete that file after each test.

Now let’s write our first test! To create a test you simply have to define a method which starts with the word “test”.
It doesn’t matter if you use an underscore after the word “test” or not! As long as “test” is the first word, it doesn’t matter. Let’s see our first test:

 function testFileExists()

{

$this->assertTrue($this->file->exists());

clearstatcache();

$this->assertTrue(file_exists($this->file->filename));

}

In this test, we check for the file existence twice (paranoid?) using the method assertTrue() which will insure that the method exists() will return true!
Then we use the built-in function file_exists() to double check that the file truely exists!
I’ll tell you later why we checked twice.

UnitTesting in SimpleTest depends heavily on assertions! Like in our previous test we used the method assertTrue() which will require the argument passed to it to be true in order to pass or it will fail!
It’s worth saying that assertTrue() will pass as long as the argument is neither 0 nor false. So assertTrue(“String”) will pass.
If you want to be strict about this, use assertIdentical() which will check the value and the type. e.g. assertIdentical(“true”, true) will fail!

SimpleTest has many assert*() methods and in our UnitTestCase class we have these:

assertTrue($x)	Fail if $x is false
assertFalse($x)	Fail if $x is true
assertNull($x)	Fail if $x is set
assertNotNull($x)	Fail if $x not set
assertIsA($x, $t)	Fail if $x is not the class or type $t
assertNotA($x, $t)	Fail if $x is of the class or type $t
assertEqual($x, $y)	Fail if $x == $y is false
assertNotEqual($x, $y)	Fail if $x == $y is true
assertIdentical($x, $y)	Fail if $x == $y is false or a type mismatch
assertNotIdentical($x, $y)	Fail if $x == $y is true and types match
assertReference($x, $y)	Fail unless $x and $y are the same variable
assertCopy($x, $y)	Fail if $x and $y are the same variable
assertWantedPattern($p, $x)	Fail unless the regex $p matches $x
assertNoUnwantedPattern($p, $x)	Fail if the regex $p matches $x
assertNoErrors()	Fail if any PHP error occoured
assertError($x)	Fail if no PHP error or incorrect message
assertErrorPattern($p)	Fail unless the error matches the regex $p

We will only need some these assestions to test our current unit

Note that you could pass additional argument to all these methods which will be the message to be displayed in case the test fails e.g. $this->assertTrue(false, ‘Passing false to assertTrue faild!’).
Don’t worry though, because the error messages generated by SimpleTest are very informative so no need to bother writing new messages.

Now, let’s proceed to the next test:

 function testCreate()

{

$this->tearDown();

$this->assertFalse(file_exists($this->file->filename));

clearstatcache();

$this->assertTrue($this->file->create());
$this->assertTrue(file_exists($this->file->filename));
}

This test will test the create() method and makes sure it’s creating the file!

We first delete the file created (automatically) by setUp() by using tearDown() and then check and insure that the file no longer exists by using assertFalse() which will pass only if file_exists() returned false (file does not exists).
We then check to see if the method create() successfully created the file and returned true in the last two lines of the test.

Needless to say that it’s more reading friendly to make the test name similar or related to the method/part you are testing.

We’ll now see a new assertion type in the next test:

 function testReadWrite()

{

$contents = 'contents';

$this->assertTrue($this->file->putContents($contents));

$this->assertEqual($this->file->getContents(), $contents);

}

This test will check the putContents() and getContents() methods.
We will write some contents to the file using putContents() and make sure everything went ok and then use assertEqual() to make sure that what we’d written in the file is equal to what we get from getContents().

So you think I am paranoid when I check one part twice? It will be useless to just check for putContents() since it might pass the test but without actually doing what expected by just returning true or maybe because we had defined the method incorrectly! So we have to check the contents of this file and insure they are equal.
This is why we wrote two tests to check file existence and creation as well.

Now, how many operations left to test? Two, right?
Here is the test for the method append():

 function testAppend()

{

$this->file->putContents("SimpleTest");

$this->assertTrue($this->file->append("NeverMind"));

$this->assertWantedPattern('~nevermind$~i', $this->file->getContents());

}

Note that we didn’t test the method putContents() again since it was tested before (tests are performed in the order they had been written in).
We use a new assertion method that is assertWantedPattern() which will try to match the regular expression pattern in the first argument against the second argument.
We want to make sure that the word “NeverMind” is found at the end of the file so the $ sign in regexp will help us.

And finally, our last test:

 function testDelete()

{

$this->assertTrue($this->file->delete());

$this->assertFalse(file_exists($this->filename));

}

There is no new assertion type used here and what I want to test is clear, so I need not say anything here, do I? It’s pretty obvious

Running The Test Case

So now all our tests are ready. We then instantiate the test case by:

$test = new fileTest('test.txt');

Now try running this script….
Nothing appeared, right? Remember when we talked about the line $this->UnitTestCase(‘File Manipulation Test’) and how it’s optional and it will only create a header in the reporter? Yes, We have to use the reporter to show how the tests went!

To use the reporter, we have to include the file reporter.php (at the top for convenience) so our file top should look like this:

include_once 'simpletest/unit_tester.php';

include_once 'simpletest/reporter.php';

include_once ‘file.class.php’;

and then create the reporter and run it by the test case object by adding this line at the end:

$test = new fileTest('test.txt');

$test->run(new HtmlReporter());

Finally, our test case script should be like this:
[fileTest.php]


include_once 'simpletest/unit_tester.php';

include_once 'simpletest/reporter.php';

include_once ‘file.class.php’;

class fileTest extends UnitTestCase
{
var $file;
var $filename;

function fileTest($filename)
{
$this->filename = $filename;
$this->file = new file($this->filename);
$this->UnitTestCase(‘File Manipulation Test’);
}

function setUp()
{
$fp = @fopen($this->filename, ‘x’);
if (!($fp === false)) {
fwrite($fp, ”);
fclose($fp);
}
}

function tearDown()
{
@unlink($this->filename);
}

function testFileExists()
{
$this->assertTrue($this->file->exists());
clearstatcache();
$this->assertTrue(file_exists($this->file->filename));
}

function testCreate()
{
$this->tearDown();
$this->assertFalse(file_exists($this->file->filename));
clearstatcache();

$this->assertTrue($this->file->create());
$this->assertTrue(file_exists($this->file->filename));
}

function testReadWrite()
{
$contents = ‘contents’;
$this->assertTrue($this->file->putContents($contents));
$this->assertEqual($this->file->getContents(), $contents);
}

function testAppend()
{
$this->file->putContents(“SimpleTest”);
$this->assertTrue($this->file->append(“NeverMind”));
$this->assertWantedPattern(‘~nevermind$~i’, $this->file->getContents());
}

function testDelete()
{
$this->assertTrue($this->file->delete());
$this->assertFalse(file_exists($this->filename));
}
}
$test = new fileTest(‘test.txt’);
$test->run(new HtmlReporter());
?>

Now run the script again and if everything goes fine you should see something similar to this if all tests passed:

File Manipulation Test

1/1 test cases complete: 11 passes, 0 fails and 0 exceptions.

In case we had any failure, you will see something similar to:

File Manipulation Test

Fail: testAppend -> Pattern [~^nevermind$~i] not detected in [String: SimpleTestNeverMind] at line [61]

1/1 test cases complete: 10 passes, 1 fails and 0 exceptions.

As you can see, there was a failure in the method testAppend() and the error message has clearly stated what and where the error is.
Note that this test failed because I edited the pattern and forced the contents of the file to be “NeverMind” only in order to pass (case-insensitive) which, of course, made the test fails.

In case you had any failures, the script will continue and will not terminate until all tests are performed.
If any PHP errors occurred, such as warnings or notices, they will be caught and reported as exceptions.

Conclusion

Now after all this effort, you might ask: “Why bother writing all these tests?” I tell you it’s much better than debugging with nasty ways such as var_dump()’s and difficult investigations to find if there were any typos or null statments or whatever might be causing the problem. With unit testing, the test case will report were exactly is the problem.
With unit testing, if you ever change your class implementation, all you have to do is run the test case and it will report if everything is functioning correctly or not and give details about any failures, if any.
Another advantage is that you are separating the debugging code from the original code! No need to clean up after debugging or anything.

A final remark, SimpleTest has great potential and many other features like mock objects and web tester which could make your debugging process easier than ever! for example, the web tester can navigate your website, follow links, click buttons, submit forms and much more!
In this article, we were demonstrating the most basic use of unit testing. It is just a kick off to infect you with the Test-infection
If you want to learn more about this great framework, read the docs at LastCraft.

Author: Saleh Jamal

Post from: Hot Scripts Blog

UnitTesting in PHP using SimpleTest

Create Own PHP Error Log File Archive

DEVpapers — Tue, 15 Dec 2009 03:01:23 +0000

Since most hosters don’t provide access to Apache error logs on shared hosting packages for technical reasons, you can create your own error logs for debugging PHP Scripts. (See the demo at http://programmabilities.com/error_log.php.)

Insert the following code in your PHP script. (Or create separate file and add the code in it. Include the file using include().)

/* we will do our own error handling. */
error_reporting(0); // Turns off all error reporting.

/* user defined error handling function. */
function userErrorHandler($errno, $errmsg, $filename, $linenum, $vars)
{
    // timestamp for the error entry.
    $dt = date('Y-m-d H:i:s (T)');

    // define an assoc array of error string
    // in reality the only entries we should
    // consider are E_WARNING, E_NOTICE, E_USER_ERROR,
    // E_USER_WARNING and E_USER_NOTICE.
    $errortype = array (
                E_ERROR => 'Error',
                E_WARNING => 'Warning',
                E_PARSE => 'Parsing Error',
                E_NOTICE => 'Notice',
                E_CORE_ERROR => 'Core Error',
                E_CORE_WARNING => 'Core Warning',
                E_COMPILE_ERROR => 'Compile Error',
                E_COMPILE_WARNING => 'Compile Warning',
                E_USER_ERROR => 'User Error',
                E_USER_WARNING => 'User Warning',
                E_USER_NOTICE => 'User Notice',
                E_STRICT => 'Runtime Notice'
                );
    // set of errors for which a var trace will be saved.
    $user_errors = array(E_USER_ERROR, E_USER_WARNING, E_USER_NOTICE);

    $err = "\n";
    $err .= "\t" .$dt. "\n";
    $err .= "\t" .$errno. "\n";
    $err .= "\t" .$errortype[$errno]. "\n";
    $err .= "\t" .$errmsg. "\n";
    $err .= "\t" .$filename. "\n";
    $err .= "\t" .$linenum. "\n";

    if (in_array($errno, $user_errors)) {
        $err .= "\t" .wddx_serialize_value($vars, 'Variables'). "\n";
    }
    $err .= "\n\n";

    // save to the error log file, and e-mail me if there is a critical user error.
    error_log($err, 3, '../error_log.log');
    if ($errno == E_USER_ERROR) {
        mail('bgates@gmail.com', 'Critical User Error', $err);
    }
}
$old_error_handler = set_error_handler('userErrorHandler');

PHP’s error_reporting() function sets which PHP errors are reported. The error_reporting() function sets the error_reporting directive at runtime. PHP has many levels of errors, using this function sets that level for the duration (runtime) of your script. The script’s error_reporting(0) turns off all error reporting so the script can catch and save the errors to a file.

PHP’s error_log() function sends an error message somewhere. This script uses it to send the error message to a file (option 3).

Now you have your own error log archives file that you can link to and look at! (See the demo at http://programmabilities.com/error_log.php.)

Chief Programmabilities
Programmabilities.com

Post from: Hot Scripts Blog

Create Own PHP Error Log File Archive