SitePoint » Learn CSS | HTML5 | JavaScript | Wordpress | Tutorials-Web Development | Reference | Books and More » PHP

XSS Attacks, Redis DB, REST, and More

Timothy Boronczyk — Wed, 09 May 2012 05:25:33 +0000

PHP Security: Cross-site Scripting Attacks (XSS)

Every PHP programmer has the responsibility to understand how attacks can be carried out against their code to exploit possible security vulnerabilities. Learn about cross-site scripting (XSS) attacks and how you can prevent them in your PHP scripts.

An Introduction to Redis in PHP Using Predis

Redis is an open-source data structure server with an in-memory data set that does much more than simple key/value storage. This article introduces you to some of the basic yet powerful commands that Redis has to offer using the Predis library.

REST: Can you do more than spell it?

Though you’ll often see the words “REST” and “architecture” together, REST is not a specific architecture. This four-part series introduces you to REST, a set of principles that define how a server and client can communicate with each other (and external resources) in a straightforward and robust manner.

Using an Access database with PHP

Sometimes a client will already have a database and ask that we make it available on the Web, and sometimes that database is in Access. Never fear, for PHP can easily work with Access databases using an ODBC driver. Learn the essential elements you’ll need to put an existing Access database online.

Working with Files in PHP

You’re familiar with databases such as MySQL and Access, but data can also be stored in files. This article gives you an introduction into working with text and CSV files, as well as find out information about the files (such as permissions and the last time it was modified).

Watch Kevin Yank Introduce his NEW book “PHP & MYSQL: Novice to Ninja”

Mick Gibson — Thu, 03 May 2012 05:42:39 +0000

” … Just as PHP and MySQL have grown from the young upstarts of the web development world into mature, stable platforms for billion-dollar businesses, this book that I’ve been writing again and again for over a decade has grown up … It’s time to write PHP like the big kids do…”

This is how Kevin Yank describes the 5th edition of his just-released book “PHP & MYSQL: Novice to Ninja“

Watch Kevin as he introduces you to his NEW book!

As part of the launch of Kevin’s book, it’s now on special with – SAVINGS of up to 50%

Sneak Peek at Kevin Yank’s New Book ‘PHP & MYSQL: Novice to Ninja’

Mick Gibson — Thu, 26 Apr 2012 06:01:19 +0000

Kevin Yank’s done it again! He’s just completed a new 2012 edition of his best-selling book (Build Your Own Database Driven Web Site, 4th Edition) which is now titled - PHP & MySQL: Novice to Ninja. And, today you can:

Take a sneak peek inside the book (with an excerpt from the Chapter 3 -Introducing PHP)
Order the book, and SAVE up to 50%

Now let’s jump into the excerpt from the book. Over to you Kev …

Introducing PHP

PHP is a server-side language. This concept may be a little difficult to grasp, especially if you’ve only ever designed websites using client-side languages like HTML, CSS, and JavaScript.

A server-side language is similar to JavaScript in that it allows you to embed little

programs (scripts) into the HTML code of a web page. When executed, these programs give you greater control over what appears in the browser window than HTML alone can provide. The key difference between JavaScript and PHP is the stage of loading the web page at which these embedded programs are executed.

Client-side languages like JavaScript are read and executed by the web browser after downloading the web page (embedded programs and all) from the web server. In contrast, server-side languages like PHP are run by the web server, before sending the web page to the browser. Whereas client-side languages give you control over how a page behaves once it’s displayed by the browser, server-side languages let you generate customized pages on the fly before they’re even sent to the browser.

Once the web server has executed the PHP code embedded in a web page, the result takes the place of the PHP code in the page. All the browser sees is standard HTML code when it receives the page, hence the name “server-side language.” Let’s look back at the today.php example presented in Chapter 1:





Today’s Date


Today’s date (according to this web server) is

echo date('l, F jS Y.'); 
?>

Most of this is plain HTML except the line between is PHP code. marks its end. The web server is asked to interpret everything between these two delimiters and convert it to regular HTML code before it sends the web page to the requesting browser. The browser is presented with the following:

Notice that all signs of the PHP code have disappeared. In its place the output of the script has appeared, and it looks just like standard HTML. This example demonstrates several advantages of server-side scripting:





Today’s Date


Today’s date (according to this web server) is
Sunday, April 1st 2012.

No browser compatibility issues

PHP scripts are interpreted by the web server alone, so there’s no need to worry about whether the language features you’re using are supported by the visitor’s browser.

Access to server-side resources

In the above example, we placed the date according to the web server into the web page. If we had inserted the date using JavaScript, we’d only be able to display the date according to the computer on which the web browser was running. Granted, there are more impressive examples of the exploitation of server-side resources, such as inserting content pulled out of a MySQL database (hint, hint …).

Reduced load on the client

JavaScript can delay the display of a web page significantly (especially on mobile devices!), as the browser must run the script before it can display the web page. With server-side code this burden is passed to the web server, which you can make as beefy as your application requires (and your wallet can afford).

Basic Syntax and Statements

PHP syntax will be very familiar to anyone with an understanding of JavaScript, C, C++, C#, Objective-C, Java, Perl, or any other C-derived language. But if these languages are unfamiliar to you, or if you’re new to programming in general, there’s no need to worry about it.

A PHP script consists of a series of commands, or statements. Each statement is an instruction that must be followed by the web server before it can proceed to the next instruction. PHP statements, like those in the aforementioned languages, are always terminated by a semicolon (;).

This is a typical PHP statement:

echo 'This is a test!';

This is an echo statement, which is used to generate content (usually HTML code) to send to the browser. An echo statement simply takes the text it’s given and inserts it into the page’s HTML code at the position of the PHP script where it was contained.

In this case, we’ve supplied a string of text to be output: ‘This is a test!’. Notice that the string of text contains HTML tags ( and ), which is perfectly acceptable. So, if we take this statement and put it into a complete web page, here’s the resulting code:





Today’s Date


test!'; ?>

If you place this file on your web server and then request it using a web browser, your browser will receive this HTML code:

Today’s Date

This is a test!

The today.php example we looked at earlier contained a slightly more complex echo statement:

echo date('l, F jS Y.');

Instead of giving echo a simple string of text to output, this statement invokes a built-in function called date and passes it a string of text: ‘l, F jS Y.’. You can think of built-in functions as tasks that PHP knows how to do without you needing to spell out the details. PHP has many built-in functions that let you do everything, from sending email to working with information stored in various types of databases.

When you invoke a function in PHP—that is, ask it to do its job—you’re said to be calling that function. Most functions return a value when they’re called; PHP then behaves as if you’d actually just typed that returned value instead in your code. In this case, our echo statement contains a call to the date function, which returns the current date as a string of text (the format of which is specified by the text string in the function call). The echo statement therefore outputs the value returned by the function call.

You may wonder why we need to surround the string of text with both parentheses ((…)) and single quotes (‘…’). As in SQL, quotes are used in PHP to mark the beginning and end of strings of text, so it makes sense for them to be there. The parentheses serve two purposes. First, they indicate that date is a function that you want to call. Second, they mark the beginning and end of a list of arguments that you wish to provide, in order to tell the function what you want it to do.

In the case of the date function, you need to provide a string of text that describes the format in which you want the date to appear. Later on, we’ll look at functions that take more than one argument, and we’ll separate those arguments with commas. We’ll also consider functions that take no arguments at all. These functions will still need the parentheses, even though there will be nothing to type between them.

—

Fantastic, thanks Kevin for sharing that!

The good news is there’s loads more practical and hands-on examples just like this in the 500+ pages of the book. Which covers:

Tutorials: Easy-to-follow tutorials with downloadable code examples
Installation: Instructions for PHP & MySQL on Windows, Mac OS X, and Linux
PHP coding: Learning the correct PHP syntax
Database design: Mastering SQL database design
Object Oriented Programming (OOP): Crash course in OOP principles.
Building a CMS: Step-by-step guide to creating a CMS.
Shopping Carts: Developing an e-commerce cart from scratch.
Latest technologies: Updated for Windows 7, Mac OS X Lion, and the latest versions of PHP, MySQL, phpMyAdmin, XAMPP, MAMP, and HTML5.

Order your copy now:

PRINT Book + Digital EPACK Bundle – for $34 (SAVE 50%)
Digital EPACK (pdf, epub, mobi) – for $17 (SAVE 42%)

That’s it. Enjoy, and as always, we’d love to hear all your thoughts and comments.

Deploying Apps with Phing, PHP Presentations, Virtual Proxies, and More

Timothy Boronczyk — Tue, 24 Apr 2012 17:00:38 +0000

Deploy and Release your Applications with Phing

In a previous article on PHPMaster, you gained a basic understanding of Phing. In this article, you’ll use that knowledge to write your own boilerplate build file, which can be customized and reused in your real-world applications.

Giving Your First PHP Presentation

It’s public speaking time and you’re the next one up! In this article, you’ll learn why presenting PHP can be beneficial, who can present PHP-related topics (hint: it’s not just the experts!), and what you can do to make your presentation stand out when you deliver.

Maintaining your Server with Command Line PHP

Maintaining your Server with Command Line PHP
When maintaining a server, you need to know how to write scripts and small programs to automate tasks. Two of the biggest advantages of using PHP to write scripts are: you’re already familiar with the language, and you gain the ability to reuse any code from your previous PHP projects.

An Intro to Virtual Proxies, Part 1

One of the most appealing facets of polymorphism is that it’s applicable in a wide variety of situations. Moreover, while the ability to switch out concrete implementations is a fundamental object-oriented pillar, its use is limited when involving domain objects. In this first piece of a two-part series on virtual proxies, I’ll be showcasing their use case, and later digging deeper into their complexities.

Translating WordPress Themes and Plugins

WordPress itself is translated into many languages, but this is not the case with themes, plugins, and other front-end customizations. All theme and plugin developers are responsible for adding translation support for their work.. This article will show you how to translate any WordPress theme or plugin by using internationalization and localization methods.

6 Skills Every PHP Freelancer Needs, Pragmatic Testing, MySQL, and More

Timothy Boronczyk — Tue, 10 Apr 2012 09:09:06 +0000

Thoughts of a Pragmatic Tester

Some of us write unit tests, while others choose not to. Indeed, it’s important to test common usage, situations of improper usage, and rare events. But it’s also vital that you write your tests pragmatically, using functional (acceptance) tests for application’s behavior, and unit tests for internal APIs.

An Introduction to Services

Most software applications behave like whimsical babies with an unavoidable “tendency” to grow in size and complexity over time. You’re probably wondering how to tackle the problem without hitting your head against a brick wall. This article managing this, in particular, Services, because it plays nicely with Domain Models, and therefore with Domain-Driven Design.

Using EXPLAIN to Write Better MySQL Queries

The EXPLAIN keyword is one of the most powerful tools at your disposal for understanding and optimizing troublesome MySQL queries, but it’s a sad fact that many developers rarely make use of it. In this article, you’ll learn what the output of EXPLAIN can be and how to use it to optimize your schema and queries.

6 Skills Every PHP Freelancer Should Have

PHP development is hot right now, but there’s also a lot of competition among developers. If you want to make it as an independent PHP developer, you’ve got to know more than just PHP. These six skills are essential for most freelancers, even more so for PHP developers.

Bulletproofing Database Interactions with PHPUnit’s Database Extension

If your application is data-intensive, subjecting your CRUD code to a battery of tests is good practice that helps ensure that your application is working correctly. This article will help you get started using PHPUnit’s Database extension to automate tests for your code that interacts with your database.

Validating WordPress Comment Forms with jQuery and a Custom Plugin

Vladislav Davidzon — Wed, 04 Apr 2012 21:18:20 +0000

One of the newest ways that web designers are increasing the usability and accessibility of their websites is by employing a combination of PHP, XHTML, and jQuery programming to validate forms “on the fly” as users fill them out. With WordPress, several pieces of information are almost always required in order to post a comment. A user must provide their name, their email address, and the comment itself. Some websites even require that users supply their website information when they post a comment. That’s a lot to remember, a lot to fill out, and the room for error is pretty big. A standard WordPress installation does not validate forms until a user has already clicked the submit button, meaning they don’t see any errors until the posting process has been completed. This leads to plenty of frustration and it simply isn’t usable in the modern era of blogging and interacting.

To replace this old-fashioned way of validating forms and replying with a user error, developers have begun employing jQuery to validate forms as users fill them out. Users will see a message displayed under each form as they proceed through the commenting process, and that message will either inform them that they’ve filled out the information successfully or it will alert them to an error and advise them to make a correction. This all happens before the “submit” button is clicked, and it saves users a page load and a few minutes of frustration in the process. It’s easy to do, and the library for form validation is already written. The only thing that’s holding most users back is developing the custom plugin to make this possible in WordPress, and that’s not nearly as taxing as most might think it is.

Step 1: Create a Plugin Directory and Get the Files in Order

The process used to validate a form requires that a custom plugin be generated within WordPress. This might intimidate some users, but rest assured that this plugin is just a more extensive series of additional “functions” like those that would typically be placed within a site-specific “functions.php” file. The validation function is added to a plugin so that it can be used across themes, rather than theme-specific functions files, which would require placing this code within every single one in order to make sure it works thoughout each user-installed theme in the Dashboard.

First and foremost, navigate to /public_html/wp-content/plugins/ and create a new folder named “validation-plugin.” This will contain all of the relevant files and subfolders needed for proper operation. Open that folder and create two new subfolders for the plugin:

These folders are pretty self-explanatory. Inside the “js” folder, a jQuery library will be stored. Inside the “css” folder, a stylesheet will be placed, which will determine the appearance of the error or approval messages that are displayed to the commenting user.

The jQuery library needed for this process is known as the Bassistance.de Library. Once it has been downloaded, it should be placed into the “js” folder. Then create a new file called “validation.css” and place that (blank) stylesheet into the “css” folder. Finally, it’s time to create the plugin PHP file that will control the validation functions.

The PHP plugin file should be named “form-validation.php” and it should be placed outside the subfolders in the main plugin directory. This file can be left blank for now, as it will be edited directly on the server and filled with content and functions as the process continues.

Step 2: Give the Plugin a Name and Describe its Functions

Every WordPress plugin is required to contain a few lines of code which give it a name, a version, and some descriptive tags and blocks of text. This is much like the content placed in a “style.css” file, and it’s just as important. A plugin which lacks these lines of text won’t display in the WordPress Dashboard. That means it cannot be activated after completion, so be sure that each line of text is filled in completely with the proper information. These lines of text look like the following:

/**
* Plugin Name: Comment Form Validation Custom Plugin
* Plugin URI: http://your-site.com
* Description: This plugin enhances the WordPress comment form by using a jQuery library to validate the content of each text area and text box as the user types their information into them. This plugin can be used across themes and is compatible with all major browsers and even screen readers.
* Version: 1.0
* Author: Your Name (You're the Author!)
* Author URI: http://your-site-again.com
* License: GPL
*/

Each line in the above code is pretty self-explanatory. The only one which might throw some developers off is the “license” line. For novice users, this simply refers to the license under which the code is written and distributed. In this case, it has been defined as GPL, for GNU Public License. This pretty much means that anyone can use this code on their own website, or modify the code to their needs, so long as they give credit to the original author. Because WordPress is an open-source content management solution based on PHP, a GPL or GPL version 2.0 license is the most appropriate way to create, share, and minimally restrict your work.

Step 3: Bringing the jQuery Library to Life Using Plugin Functions

The next step of the process will add specific functions to the plugin’s PHP file, which will load the script and activate its functions on the comment submission website. This is done relatively simply and it looks exactly like something that would appear in a theme-specific “functions.php” file. Remember that this information and coding is based on using the appropriate plugin file directories, which were described in an earlier step of this process. The code, when completed, looks like this:

function form_validation_js() {
  if(is_single() ) {
    wp_enqueue_script(
      'jquery-validate',
      plugin_dir_url( __FILE__ ) . '/js/bassistance.js',
      array('jquery'),
      '1.8.1',
      true
    );
    form_validation_style(
      'jquery-validate',
      plugin_dir_url( __FILE__ ) . '/css/validation.css',
      array(),
     '1.0'
    );
  }
}
add_action('template_redirect', 'form_validation_script');
function print_validation_script() { ?>
< ?php } add_action('form_validation_script'); ? >

These can be customized to a user’s wishes and they can contain any punctuation or uppercase letters that a designer wants to include. Try to keep them brief and descriptive, however, as most people don’t read between the lines even when it’s well-styled using CSS code. The PHP programming part of this operation is now complete.

Step 4: Styling Error Messages with Some CSS

Now we’re going to use the stylesheet file that was created in the first step of this process. Navigate to the “css” folder and, in the “validation.css” file, add the following lines:

label.error {
  display: block;
  color: #000;
  background-color: yellow;
  padding: 10px;
}

Every error message is defined as a form label with the class “error.” This element simply styles these errors with black text, a yellow background, and design-friendly padding that keeps text from meeting the edge of the color. It can, of course, be customized according to your taste and your website’s design specifications.

Also worth noting is that this stylesheet information does not need to be placed into the plugin’s stylesheet at all. Because WordPress naturally draws its look and feel from the theme’s “style.css” file, it could be placed in that stylesheet instead. If your site uses multiple themes and switches them very often, or if you allow users to switch between your site’s installed WordPress themes, this is a great way to ensure that the comment form’s error messages blend in with each theme individually rather than inheriting a universal style from the plugin folder itself.

Be sure to test each form element and try to make it produce an error. Check out the styling, and the error message, and check for any bugs or glitches. If none exist, the process is complete and your website is now much more usable and accessible.

PHPMaster: Role Based Access Control, pChart, CI with Jenkins, and More

Timothy Boronczyk — Tue, 27 Mar 2012 18:00:08 +0000

Role Based Access Control in PHP

Role Based Access Control is a model in which roles are created for various job functions and permissions to perform operations that are then tied to them. Users can be assigned one or multiple roles, which restrict their system access to the permissions they’ve been authorized for. In this article, you’ll learn more about RBAC and how to enhance your existing authentication system with it.

pChart Revisited with Google Analytics

Back in December, PHPMaster published an introductory article written by J Armando Jeronymo on pChart, a PHP library that creates eye-catching anti-aliased charts. A reader asked for more articles with further examples, so he has written this follow-up. It features a handy device for visually checking website statistics using Google Analytics’ GAPI.

Building a Domain Model: Integrating Data Mappers

You’ve seen how to write data models, now learn how to put them to work in synchrony with a “real” persistence layer. In this follow-up to Alejandro’s article on persistence agnosticism, you’ll develop a basic mapping module which will allow you to move data easily between a model and a MySQL database, all while keeping them neatly isolated from each other.

Error Logging with MongoDB and Analog

With the hype around document databases continuing to grow, and around MongoDB in particular, there are a lot of questions about how to migrate your applications to begin using it. The advice is usually the same – especially for existing applications: take one step at a time. This article will show how you can add logging to your existing code using MongDB and Analog.

Continuous Integration with Jenkins, Part 1

Continuous integration is a software quality-control technique that checks code integrity whenever small changes are made, rather than waiting for all the code to be finished before testing and debugging. This is the first in a two-part series that introduces Jenkins. It presents a big-picture overview of the sort of programming problems CI can solve.

PHP 5.4 is Released — What’s New?

Craig Buckler — Mon, 05 Mar 2012 17:14:23 +0000

It’s difficult to believe almost three years have elapsed since PHP 5.3.0. The next version should have been PHP 6.0 but unicode problems have delayed development. This latest version provides many of the features planned for version 6.0.

PHP 5.4 is available to download from the php.net website. There’s a PHP 5.3 migration guide if you want to keep your old settings. While it’s stable, you’d be advised to test your sites and applications before installing it on live servers. The PHP team often release a bug-fix version a few weeks after the initial release.

So let’s look at the best new features and improvements…

Short Array Syntax

It’s now possible to use finger-saving JavaScript-like square brackets rather than using the old array(…) construct, e.g.


$array1 = [1, 2, 3];
$array2 = [
	"one" => "first",
	"two" => "second",
	"three" => "third"
];

Traits

Traits reduce some limitations of single inheritance. In essence, traits are similar to abstract classes and can contain any number of properties and methods. A class can then use any number of traits, e.g.


trait Hello
{
    function sayHello() {
        return "Hello";
    }
}
trait World
{
    function sayWorld() {
        return "World";
    }
}
class MyWorld
{
    use Hello, World;
}
$world = new MyWorld();
echo $world->sayHello() . ' ' . $world->sayWorld();

For more information, refer to Using Traits in PHP 5.4 on PHPmaster.com.

Built-in Web Server

PHP 5.4 offers a built-in web server which runs from the Windows, Mac or Linux command line. While it’s not Apache or IIS, it’s fine for simple testing. I suspect many of the better PHP IDEs will implement support shortly.

For more information, refer to PHP 5.4′s New Built-in Web Server.

New Commands

A number of useful commands have been implemented:

hextobin(string $hex): coverts a hex representation of data to binary.
http_response_code(int $code): allows you to set or get the HTTP response code, e.g. http_response_code(404);
header_register_callback(string $function): allows you to register a function which is called when PHP starts sending output.
trait_exists(string $name [,bool $autoload]): determines whether a trait exists and, optionally, whether it should be autoloaded.

Miscellaneous Updates

If that’s not enough…

Class members can be accessed on instantiation, e.g. (new MyClass)->MyMethod()
is always available regardless of how your short_open_tag ini option is set.
Binary numbers can be declared, e.g. 0b11110000
Session upload progress has been implemented so PHP can track the state of file uploads.
Some users are reporting speed increases of up to 25% with a memory reduction of 35%.

Compatibility Issues

Most older PHP code should run without modification but there are a few gotchas to look out for:

Safe mode, register_globals and magic quotes have been removed. get_magic_quotes_gpc() will always return FALSE.
trait, callable and insteadof have become reserved words.
Several mysqli aliases have been removed.

You should also note that PHP 5.4.x will be the last edition to support Windows XP and Windows 2003.

PHP 5.4 isn’t quite as radical has 5.3, but there are enough new features to keep developers happy for a while. Let us know if you have any positive or negative experiences with the latest version.

WordPress Plugin Development, PHP and SOAP, Building a Domain Model, and More

Timothy Boronczyk — Fri, 02 Mar 2012 11:20:54 +0000

Packaging Your Apps with Phar

Deployment of web applications can be difficult and cumbersome without the right tools. This article will introduce you to PHAR, PHP’s package format which can help you have a better deployment experience.

WordPress Plugin Development

If you’ve ever used WordPress to build a site quickly, chances are you’ve used one of the many plugins that are offered to extend the functionality of this popular blogging software. There are times, however, when you can struggle to find what you need from existing plugins. This article shows you how to create your own WordPress plugins.

Creating Web Services with PHP and SOAP, Part 1

The ability to develop software and services for a wide range of platforms is a necessary skill for programmers, and SOAP, an XML-based protocol, will help ease the burden. Learn about SOAP and make your own SOAP client and server using the NuSOAP library in the first of this two-part series.

Understanding the Observer Pattern

In this article, you’ll learn how to implement the Observer Pattern, a behavioral design pattern that defines a one-to-many relationship between objects. Therefore, when one object changes its state, all dependent objects are notified and updated automatically.

Building a Domain Model: An Introduction to Persistence Agnosticism

With tons of MVC-based frameworks proliferating like hungry ants, the “model” part continues to suffer from the symptoms of an ad hoc Database Model layer. This article will teach you another way, one that will help you focus more on keeping access code out of your domain logic, as well as maintain a clear boundary of responsibility.

Is Your PHP Behind the Curve?

Timothy Boronczyk — Wed, 15 Feb 2012 05:56:54 +0000

Using Traits in PHP 5.4

Less code duplication, more code reuse is a goal of OOP, but sometimes it can be difficult with PHP’s single inheritance model. Traits offer a workaround to horizontally reuse code across different class hierarchies. They’re new in PHP 5.4 so learn about them today!

Tracking Upload Progress with PHP and JavaScript

A problem that has plagued web developers for years is how to add real-time information to their applications, such as a progress bar for file uploads. Learn how a new feature in PHP 5.4 can be used to create a dynamic upload progress bar without any external libraries or browser dependencies.

Where on Earth are you?

Modern geolocation applications use latitude and longitude to identify the location of people and places to within a few meters – but it’s highly unlikely you’ll answer the question “Where on Earth are you?”. Learn how to use the Yahoo! Placemaker server and write a simple program to ask users where they are before identifying their location in concrete terms.

Autoloading in PHP and the PSR-0 Standard

Including a slew of extra files at the top of your scripts can be a drag! Learn about the “history of autoloading” and the current PSR-0 standard used in many PHP frameworks such as Lithium, Symfony, and Zend, that makes lengthy include lists a thing of the past.

Under the Hood of Yii’s Component Architecture Part 2

This is Part 2 of the 3-part series that shows you some of the inner-workings of the Yii Framework’s component architecture. In this installment you’ll learn how you can do event-based programming in PHP and how Yii’s CComponent class helps facilitate it.

How to Create Your Own Random Number Generator in PHP

Craig Buckler — Wed, 08 Feb 2012 15:50:17 +0000

Computers cannot generate random numbers. A machine which works in ones and zeros is unable to magically invent its own stream of random data. However, computers can implement mathematical algorithms which produce pseudo-random numbers. They look like random numbers. They feel like random distributions. But they’re fake; the same sequence of digits is generated if you run the algorithm twice.

Planting Random Seeds

To increase the apparent randomness, most algorithms can be passed a seed — an initialization number for the random sequence. Passing the same seed twice will still generate the same set of random numbers but you can set the seed based on external input factors. The easiest option is the current time but it can be anything; the last keypress, a mouse movement, the temperature, the number of hours wasted on YouTube, or any other factor.

Random PHP Functions

PHP offers a number of random number functions. The main ones are:

rand() and the more efficient mt_rand() function. Both return a random number between zero and getrandmax()/mt_getrandmax(). Alternatively, you can pass minimum and maximum parameters:
```
// random number between 0 and 10 (inclusive)
echo mt_rand(0, 10);
```
srand($seed) and mt_srand($seed) to set a random number seed. This has been done automatically since PHP 4.2.0.

PHP is Too Random!

There are instances when creating a repeatable list of pseudo-random numbers is useful. It’s often used for security or verification purposes, e.g. encrypting a password before it’s transmitted or generating a hash code for a set of data. Unfortunately, PHP can be a little too random. A generated sequence will depend on your hosting platform and version of PHP. In other words, you can’t guarantee the same ‘random’ sequence will be generated twice on two different machines even if the same seed is used.

Rolling Your Own Random Class

Fortunately, we can write our own random number generator. You’ll find many algorithms on the web, but this is one of the shortest and fastest. First, we initialize our class and a random seed variable:


class Random {
	// random seed
	private static $RSeed = 0;

Next we have a seed() function for setting a new seed value. For the algorithm to work correctly, the seed should always be a positive number greater than zero but not large enough to cause mathematical overflows. The seed function takes any value but converts it to a number between 1 and 9,999,999:


	// set seed
	public static function seed($s = 0) {
		self::$RSeed = abs(intval($s)) % 9999999 + 1;
		self::num();
	}

Finally, we have our num() function for generating a random number between $min and $max. If no seed has been set it’s initialized with PHP’s own random number generator:


	// generate random number
	public static function num($min = 0, $max = 9999999) {
		if (self::$RSeed == 0) self::seed(mt_rand());
		self::$RSeed = (self::$RSeed * 125) % 2796203;
		return self::$RSeed % ($max - $min + 1) + $min;
	}
}

We can now set a seed and output a sequence of numbers:


// set seed
Random::seed(42);
// echo 10 numbers between 1 and 100
for ($i = 0; $i < 10; $i++) {
	echo Random::num(1, 100) . '
';
}

If you’ve copied this code exactly, you should see the following values no matter what OS or version of PHP you’re running:

Admittedly, repeatable “random” numbers isn’t something you’ll need every day — you’re more likely to require something closer to real randomness and PHP’s functions will serve you better. But there may be occasions when you find this useful.

PHPMaster: How I Chose My Programming Editor

J Armando Jeronymo — Fri, 13 Jan 2012 23:32:42 +0000

For many years I used a code editor that is now discontinued by its developers, and the introduction of HTML5 and CSS3 led me to look for an editor that supports the new tags and properties. In this article I’ll share the criteria and process I used to find an editor suitable for making quick fixes and a development environment for large-scale projects. My initial candidate list contained over 30 popular Linux, Java, Windows and XUL software packages which had at least one stable release after January 1, 2010: Arachnophilia, Bluefish, Bluegriffon, CoffeeCup HTML Editor, Dreamweaver, Eclipse PDT, Emacs, Expression Web, Geany, gedit, HTML-Kit, jEdit, Kate, KDevelop, Komodo Edit, KWrite, Netbeans, Notepad++, Notepad2, OpenBEXI, PHPEdit, PHPEd Pro, PHPStorm, Programmer’s Notepad, PSPad, RadPHP, Scite, SeaMonkey, Vim, WebDev, WebMatrix, and Zend Studio. You can google each program for their specific details

PHPMaster: Zend Job Queue

Alex Stetsenko — Wed, 11 Jan 2012 23:48:32 +0000

Web applications usually follow a synchronous communication model. However, non-interactive and long-running tasks (such as report generation) are better suited for asynchronous execution. One way to off-load tasks to run at a later time, or even on a different server, is use the Job Queue module available as a part of Zend Server 5 (though not as part of the Community Edition). Job Queue allows job scheduling based on time, priority, and even dependencies.

See the article here:
PHPMaster: Zend Job Queue

How to Customize the WordPress 3.3 Toolbar

Craig Buckler — Wed, 11 Jan 2012 16:26:02 +0000

You can make the WordPress interface easier for clients by removing unnecessary menus, widgets and meta boxes. However, in WordPress 3.3, the admin and header bars have been merged to create a single toolbar. It may also contain options you want to hide…

The WordPress Toolbar API

The new toolbar is defined using a single WP_Admin_Bar object (see wp-includes/class-wp-admin-bar.php). This provides a number of useful methods:

add_node() — add a new toolbar item
remove_node() — remove a toolbar item
get_node() — fetch a node’s properties
get_nodes() — fetch a list of all nodes

Removing Toolbar Items

We’re going to place our code into a reusable plugin named wp-content/plugins/change-toolbar.php but you could put it within your theme’s functions.php file.

WordPress plugins require a header at the top of the file, e.g.

We now require a single function where our changes will be made:


function change_toolbar($wp_toolbar) {
	/* ... code to go here ... */
}

followed by an action hook which runs the function and passes the toolbar object:


add_action('admin_bar_menu', 'change_toolbar', 999);

We can now remove toolbar items within the change_toolbar() function. For example, the following line hides the WordPress logo and help sub-menu by referencing its ID, “wp-logo”:


$wp_toolbar->remove_node('wp-logo');

To remove other items you need to discover what ID they’re using. You could delve into the PHP code but there’s an easier way:

Open Firebug or your favorite Firebug-like development console.
Locate the toolbar item you want to remove (in most browsers you can right-click the item and select “Inspect Element”).
Navigate up the parent nodes until you find an LI tag. It will have an ID starting “wp-admin-bar-” followed by the internal ID code:

In this example, the Comments item is highlighted. Therefore, to remove it from the toolbar, we use:


$wp_toolbar->remove_node('comments');

`Adding Toolbar Items`

We can add toolbar items within the same function. The syntax is:


$wp_toolbar->add_node($arg);

Where $arg is an associative array containing:

id — the item’s ID
title — the title text
parent — the parent menu ID (optional)
href — the link URL (optional)
group — true if the node is a group (optional)
meta — another array providing other keys including: html, class, onclick, target, title, tabindex

Let’s add a “Help” item which links to our support pages:


$wp_toolbar->add_node(array(
	'id' => 'myhelp',
	'title' => 'Help',
	'href' => 'http://mysite.com/support/',
	'meta' => array('target' => 'help')
));

We could now add an email support link within a sub-menu by referencing the ‘myhelp’ ID in the parent:


$wp_toolbar->add_node(array(
	'id' => 'mysupport',
	'title' => 'Email Support',
	'parent' => 'myhelp',
	'href' => 'mailto:support@mysite.com?subject=support%20request'
));

I hope you find it useful — it’s easy to customize the whole WordPress 3.3 toolbar using a few API calls.