Related Posts

Related Posts

1. Grouping Your WordPress Blog Comments By Type: Comments, Trackbacks And Pingbacks (24)
2. In Reply To Comments Made On "Working With A Simple Structure Array In VB.NET" (15.4)
3. A Request Of Yahoo! Answers Code Questioners: Please Post Your Code On Geocities (Or Another Web Site) (14.7)

The numbers inside parentheses are relevance scores. Scoring is based, in order of priority, on title, category, content and tags. The higher the score, the more likely that post relates to this post. ]]> I recently came across a post on elegantcode.com that really struck a nerve. The premise: If you write good code, comments should not only be unnecessary, they could actually be counterproductive. Says author John Sonmez:

“As my experience has increased, I have realized more and more that comments are actually bad. They indicate a failure.”

I know that this runs contrary to what most professors, instructors and textbooks say. They offer what seems a reasonable rule: Comment your code so that the next person who reads it doesn’t need to try to figure out what you’re doing.

And it’s also contrary to most of the code I put out on this Web site. I would certainly agree that I over-comment my code, but that’s a conscious decision, based in large part because I want my readers, who tend to be newer programmers, to completely understand what my code is doing at each step.

But as Sonmez notes, comments aren’t the best way to achieve that goal, especially in object-oriented code.

For example, if you change code, its related comment doesn’t change. Use proper constants — e.g., DEFAULT_LOOP_ITERATIONS — instead of a variable declarations. Name your methods, properties and function so they are self-documenting (do you really need to comment a method named OpenXMLFile?) and write more code so that self-documenting names can replace more abstract procedural code calls.

It’s this third suggestion that interests me. I’ve said, many times, that less code is better. I maintain that view. But I’m inclined to agree more with Sonmez that, if it takes a few extra lines and a couple more dependencies to create self-documenting code, that complexity is probably the right trade-off, versus adding novella-sized comment blocks.

I’m almost certainly going to continue over-commenting code here, especially because I am trying to serve the needs of novice programmers.

But Sonmez’s brilliant post really hits hard, and reminds me that if I am trying to write simple code that’s easy to understand, I should rely more on best programming practices than double-slashes. Expect to see more of that in the future. And please do take the time to read his post in full.

All links in this post on delicious: http://delicious.com/dougvdotcom/good-coding-practices-should-replace-comments-in-code

Related Posts

1. MSDN Roadshow In Augusta, March 19: Well Worth The Time (58.1)

The numbers inside parentheses are relevance scores. Scoring is based, in order of priority, on title, category, content and tags. The higher the score, the more likely that post relates to this post. ]]> The MSDN Roadshow returns to Augusta, ME and the Central Maine Commerce Center’s Florian Auditorium on Sept. 24, from 1 p.m. – 6 p.m. (That’s a later start than recent roadshows, because directly before it, there’s a TechNet event about Windows 7 and Remote Desktop.)

MSDN Roadshows are a chance for Microsoft evangelists — namely, Chris Bowen and Jim O’Neil — to describe new technologies, demonstrate how to program in Microsoft languages and platforms, and generally share the word about what’s new and on Microsoft’s mind at the moment.

Among the issues to be discussed at this roadshow is Windows 7. Without question, Chris and Jim know their stuff, and you’ll definitely walk away from this event with a better knowledge of Microsoft technologies — if not some of the loot they give out at every event (fully-functional copies of Windows Vista, Visual Developer 2008 Professional, Microsoft Press books and peripherals having been offered in the past as door prizes).

Florian Auditorium and the Central Maine Commerce Center are in the former SCI Systems / Digital Equipment plant off Civic Center Drive. I have a public Google Map of the location.

If Augusta or the date are not convenient for you, Chris and Jim are doing the same agenda in Manchester, NH; Rochester, NY; Troy, NY; Waltham, MA and Farmington, MA. Chris Bowen details it all on his blog.

Related Posts

1. Working With A Simple Structure Array In VB.NET (15.2)
2. In Reply To Comments Made On "Working With A Simple Structure Array In VB.NET" (13.9)
3. A Simple PHP Script (MySQL, Too) To Track Radio Station Song Requests, Part 1 (10.9)

The numbers inside parentheses are relevance scores. Scoring is based, in order of priority, on title, category, content and tags. The higher the score, the more likely that post relates to this post. ]]> I’m going to spend several posts discussing authorize.net’s Customer Information Manager, a Web service for storing and retrieving personally identifiable information about the people who place credit card orders on your Web site.

Today, I’m focusing solely on an overview of CIM: What it is, how it works, why it works that way, and approaches to integrating CIM into your custom storefront / ordering systems. In future posts, I will discuss actual implementation via PHP and MySQL; my intent is to use 2-3 posts to cover the process, but it may take more or less. My intent is to post every day, but there may be a delay of a day or two between posts.

(I’m uncertain on the number and timing of posts on this topic because I’ll be blogging about implementation as I implement CIM for the first time. And lest that gives you pause, I’ve extensively reviewed the documentation, tested the basics of using the service, and have over 10 years’ experience with PHP / XML / MySQL. And because I’m doing the actual implementation for pay, I will have extensively tested the solution for elegance, reliability and security.)

What Is A Web Service?

The Customer Information Manager is a Web service. In its most common implementation on the World Wide Web, you send a Web service an XML document describing information you want, and the service responds with an XML document that contains the information you requested. (Not all Web services work this way; there are many kinds of Web services out there. But rather than bog down the point, let’s stick with this basic description.)

We can therefore think of a Web service as a remote database; the Customer Information Manager Web service is, in fact, a way to get data into and out of a remote database.

In the case of a Web service, rather than connecting to a local database, writing a SQL query and asking it to send us a result set (or Boolean false on failure), such as we would do in PHP / MySQL, we instead write an XML document that provides our authentication credentials and describes the data we want, send that to the CIM Web service via cUrl (or, if your server allows it, fopen), and get back from the CIM an XML document that contains the records we want (or an error code describing any problems encountered).

In other words, for most intents and purposes, the CIM Web service works exactly like a database, only different. So why in the world does authorize.net bother with a Web service, rather than simply giving you access to their database directly?

In a word, security. The primary benefit in providing the Customer Information Manager as a Web service is that it acts as an abstraction, and a fairly limited one at that.

What I mean is, if you had the ability to run any old UPDATE or DELETE query you wanted to run on the Customer Information Manager, you’d be able to do some serious damage, even if you only messed up your own records. (Everyone who has worked with SQL queries for more than a week has totally annihilated database tables with ill-considered UPDATE or DELETE queries.)

The Customer Information Manager APIs (application programming interfaces) allow authorize.net to restrict your activities to some basic tasks; namely, creating new customer database entries (“profiles”), deleting them one at a time; updating them one at a time; or getting a list of profile IDs.

The other benefit to the CIM Web service approach is, by only accepting XML requests and sending back XML in response, authorize.net can impose several levels of protection between the database and you. We don’t know, for example, what database holds our information; we can’t try to hack root; authorize.net is able to insert several layers of intrusion detection / firewall / load balancing between the XML we see and the database we can’t see.

Why Bother With CIM?

The primary reason to work with the Customer Information Manager is that it fully complies with the Payment Card Industry (PCI) Data Security Standard (DSS). Having a secure payment gateway to process online credit cards is one thing; being able to protect the credit card numbers you collect, as well as personally identifiable information about cardholders, is another.

Generally speaking, accepting a payment isn’t of any use in and of itself; in exchange for the money you receive, you usually need to provide some good or service, and in order to do that, you usually need the name and / or address of the person sending you money, if not details about what the customer wants, too.

The DSS doesn’t have Draconian requirements, but you probably can’t ensure those requirements are met on a shared Web hosting account. Or, even if you aren’t on shared hosting, you might want to absolve yourself of the responsibility of complying with DSS. That’s the primary business reason for using CIM.

CIM can also help you work with returning customers or recurring payments. Thanks to its object model, you can associate multiple credit cards and addresses with a given customer (both billing and shipping). In my application, the client sells subscriptions; often, subscribers not only order for themselves, but also for others (e.g., gift subscriptions); some subscribers also want to be auto-rebilled at the end of every subscription term.

Using the Customer Information Manager will allow my client to not only quickly relate each customer to all the subscriptions he has purchased, it will make rebilling as simple as asking the server to round up all rebill clients set for a given date, get their billing information and credit card from CIM, and batch submit them. (I won’t cover this last bit immediately, as my client wants to hold off on the rebilling part until he sees how successful online sales prove.)

So what that boils down to is, I can completely ignore AIM — the API most authorize.net developers know, and which is most commonly used to process transactions through authorize.net — in favor of CIM.

What CIM Is Not

As I describe what the Customer Information Manager can do, I should take a moment to address the things CIM does not do.

The APIs for CIM and AIM are not integrated and do not use the same methodologies. AIM — the authorize.net API that allows you to get money from credit cards — accepts POSTed form variables from your request and sends a delimited string back as a response. CIM is a Web service; it accepts and returns XML.

This isn’t a problem if you use CIM to handle all aspects of your online payments; you just cut out AIM altogether, as I plan to do.

However, some situations — such as sites using third-party e-commerce programs (e.g., Zen Cart or osCommerce), or custom software integrated with AIM that cannot be easily modified to use CIM — call for using CIM to only hold customer data. If you fall into the group that needs to use both CIM and AIM, most of what I discuss in upcoming posts will be of value, but keep in mind that CIM and AIM don’t work the same way.

While CIM stores lots of customer information, it isn’t extensible, nor is it very flexible. Again, you can associate multiple credit cards and billing / shipping addresses with each customer profile. But if you want to store additional information about a customer, you’re out of luck. CIM gives you 20-character “refId” and “merchantCustomerId” fields, as well as a 255-character “description” field, for each customer.

We can store information about individual transactions made by each customer profile, too. In other words, not only can each customer profile have multiple credit cards and addresses associated with it, but we can also record basic information about items purchased by the customer — such as item IDs, quantities and descriptions — for each order the customer places.

Even so, this may not be enough flexibility for your application. Technically speaking, you can store some information about a customer on your local server, and so long as it is not personally identifiable, you’ll still comply with DSS requirements.

For example, if you keep a small memo field on your local server that uses no names, addresses, phone numbers, etc. that can be used to identify the customer, you can simply key that memo field to the CIM customer profile ID and still be in compliance with DSS (as there is no local correlation to the customer’s personal information and the memo you are keeping). To ensure compliance with DSS, you might want to consider using a hash / encryption scheme to obfuscate the CIM customer ID key.

The Methodology I’ll Use

I am going to take a fairly pragmatic and direct approach to the application I write. That is, I’m going to keep it simple and direct.

My initial intent was to create a series of classes that represent the objects in the Customer Information Manager API. I actually got as far as defining all the objects’ properties and a significant number of the methods needed, before I decided it was consuming too much time and becoming a $1,000 solution to a 37-cent problem.

So, I’m simply going to use PHP 5, a little MySQL, and DomDocument to integrate the XML API for the Customer Information Manager. I’ll use cUrl to send requests.

I could have used the SOAP API. However, at least in the CIM API implementation, SOAP is fundamentally XML, only with the side aggravation of namespaces. Since that’s the case, and since I believe most readers of this blog will understand XML better than SOAP, that’s the way I will go.

Related Posts

1. Working With A Simple Structure Array In VB.NET (17.7)
2. In Reply To Comments Made On "Working With A Simple Structure Array In VB.NET" (16.2)
3. Dynamically Populating A Listbox From A Textbox Via JavaScript / DOM (14.5)

The numbers inside parentheses are relevance scores. Scoring is based, in order of priority, on title, category, content and tags. The higher the score, the more likely that post relates to this post. ]]> One of the nicest features of JavaScript is the ability to treat function arguments as an array. We all know how to write a function that takes a known number of arguments:

function foo(bar) {
	alert(bar);
}

function getArea(shape, measure, unit) {
	var output = 'The area of a ' + measure + ' ' + unit + ' ' + shape + ' is ';
	switch(shape) {
		case 'square':
			output += (measure * measure);
			break;
		case 'circle':
			output += (3.14 * (measure * measure));
			break;
		default:
			output += 'unknown to this function.';
	}
	alert(output);
}

But sometimes, your script will require you to pass some unknown number of parameters to a function. So how do you deal with that?

Luckily, JavaScript functions treat all of their arguments as an array. So, if you’re not certain how many arguments your function will take, don’t declare them in your function code; simply use the reserved word arguments to iterate the array of arguments passed to the function.

function allTheAnimals() {
	var output = 'The animals you provided are: ';
	for(var i = 0; i < arguments.length; i++) {
		output += arguments[i] + ', ';
	}
	output = output.substring(0, (output.length - 2)); //remove trailing comma and space
	alert(output);
}

Note that we can ask for specific indexes of the array, but should ensure there are at least that many elements in the array before asking:

function threeIsAMagicNumber() {
	if(arguments.length < 3) {
		alert('There is no third argument!');
	}
	else {
		alert('The value of the third argument passed to this function is ' + arguments[2].toString());
	}
}

We can even pass an unknown number of arguments from one function to another, via the apply method:

function parentFunction() {
	var output = 'Arguments received by parent function: ';
	for(var i = 0; i < arguments.length; i++) {
		output += arguments[i] + ', ';
	}
	output = output.substring(0, (output.length - 2));
	output += "\n\nDo you want to send these to the child function? OK to submit to child function, Cancel to abort.";
	if(confirm(output)) {
		childFunction.apply(this, arguments);
	}
}

function childFunction() {
	var output = 'Arguments received by the child function: ';
	for(var i = 0; i < arguments.length; i++) {
		output += arguments[i] + ', ';
	}
	output = output.substring(0, (output.length - 2));
	alert(output);
}

You can see a demonstration of all these here: http://www.dougv.com/demo/js_function_arguments_array/

I distribute code under the GNU GPL version 3.

Related Posts

1. Printing Sections Of A Web Page Using DIVs And JavaScript Remote Scripting (21.7)
2. Cleaning Up Some PHP And Incorporating A JavaScript-Based Image Preview (12.8)
3. Using PHP / MySQL To Store A Form Value Calculated Via JavaScript / DOM (10.4)

The numbers inside parentheses are relevance scores. Scoring is based, in order of priority, on title, category, content and tags. The higher the score, the more likely that post relates to this post. ]]> Asked recently on Yahoo! Answers:

Does anyone know how to automatically update a birthday list on a web page?
Our web page has a section that displays all staff birthdays for the week. This section is updated manually every Monday morning. Is there a way to have this update done automatically everyday. Must display all birthdays for that day and all birthdays for the next 6 days. The format required is:
Date (eg: 13 May)
Name Surname, Department (a new line entry for each employee with a birthday on that day)
Above repeated for each of the other 6 days.

This question presents me with an excellent opportunity to discuss a topic I’ve not really had a chance to broach before: namely, the decision process on whether to use JavaScript or a server-side scripting language, such as PHP or ASP.NET, to accomplish a given task.

Using JavaScript to accomplish a traditional server-side scripted, data-driven task is becoming increasingly popular, especially as ECMAScript standards are more widely adopted, libraries such as jQuery gain prevalence and supporting technologies, such as Google Gears, remove many of the traditional roadblocks in writing client-side scripts for stateless Web applications.

In this case, we have a problem that can be solved either client-side (JavaScript) or server-side (in this case, PHP / MySQL). Which to choose is largely a function of scale: If we’re dealing with hundreds or thousands of employee birthdays we want to display, we’re probably best off using a server-side technology; but if we have fewer employees, it might make sense to simply use JavaScript, and push the workload from the server and onto our visitors.

I’ll demonstrate both the traditional PHP / MySQL approach, as well as a JavaScript approach.

The Old-School Approach: PHP And MySQL

Let’s start with the traditional way of selecting and sorting a subset of data from a master data store: PHP and MySQL.

In this case, we simply create a table in MySQL that holds a listing of employee names, birthdays and departments (depending on the size and complexity of the organization, we’d likely use multiple tables to store this data, with foreign keys relating each; for the purposes of this demo, we’ll use one table). Here’s the SQL to create such a table, with 11 demo records:

CREATE TABLE IF NOT EXISTS `php_birthday_list` (
  `person_id` int(10) unsigned NOT NULL auto_increment,
  `person_name` varchar(50) NOT NULL,
  `person_surname` varchar(50) NOT NULL,
  `person_birthdate` date NOT NULL,
  `person_department` varchar(50) NOT NULL,
  PRIMARY KEY  (`person_id`)
) ENGINE=MyISAM  DEFAULT CHARSET=latin1 AUTO_INCREMENT=12 ;

INSERT INTO `php_birthday_list` (`person_id`, `person_name`, `person_surname`, `person_birthdate`, `person_department`) VALUES
(1, 'Tom', 'Jones', '1984-05-10', 'Maintenance'),
(2, 'Richard', 'Gingras', '1946-05-11', 'Administration'),
(3, 'Joan', 'Walsh', '1973-05-11', 'Administration'),
(4, 'Norman', 'Blashka', '1953-05-12', 'Maintenance'),
(5, 'Kerry', 'Lauerman', '1967-05-13', 'Administration'),
(6, 'Jeanne', 'Carstensen', '1990-05-15', 'Accounts Payable'),
(7, 'Ruth', 'Henrich', '1981-05-16', 'Maintenance'),
(8, 'Joy', 'Press', '1969-05-14', 'Accounts Payable'),
(9, 'Page', 'Rockwell', '1951-05-10', 'Warehouse'),
(10, 'Laura', 'Miller', '1982-03-21', 'Accounts Payable'),
(11, 'Wendy', 'Williams', '1992-05-17', 'Accounts Payable');

With data now on hand, we can create a PHP script to query the database for all birthdays this week. We do that in several steps:

First, we determine the timestamp for the Sunday of the current week. The easiest way to do that is via the getdate() function, which will return the day of the week represented by the current date, indexed from 0 (Sunday) to 6 (Saturday). Since we’re interested in Sunday, we take the current timestamp, then subtract from it the number of seconds in a day (86,400) times the day of the week returned by getdate().

So, for example, suppose $today['wday'] is 2 (i.e., today is Tuesday). If I multiply 86,400 by 2 (172,800), and subtract that from the current timestamp, I’ll have a timestamp that falls on the previous Sunday.

We next need to find when Saturday falls on the same week. The math this time is to subtract the current weekday value from 6 (which is Saturday), multiply that by the number of seconds in a day, and add that to the current timestamp. So, if today is Tuesday, (6 – 2) * 86,400 = 4 * 86,400 = 345,600 seconds, which when added to the current timestamp will give me a timestamp that falls on Saturday.

Now that we have timestamps for the Sunday and Saturday of the week, we need to get the month and day values from each. We’ll then find all the birthdays in the table that have a month equal to or greater than the Sunday month, and a month equal to or less than the Saturday month, and a day equal to or greater than the Sunday day, and a day equal to or less than the Saturday day.

If we find no matches, we have no birthdays. Otherwise, we will loop through the results set, outputting every person whose birthday falls within this week.

if(!$link = mysql_connect('server', 'host', 'password')) {
	echo "<p><strong>Could not connect to database server.</strong></p>n";
}
//select database
elseif(!mysql_select_db('database')) {
	echo "<p><strong>Could not select database.</strong></p>n";
}
else {
	//get today's date info
	$today = getdate(time());

	/*
	OPTION 1: This week only. Birthdays falling between Sunday and Saturday of this week are shown.
	*/

	//find the sunday of this week
	$sun = time() - (86400 * $today['wday']);
	//find the saturday of this week
	$sat = time() + ((6 - $today['wday']) * 86400);

	//get month and day for each
	$sun_mon = date('m', $sun);
	$sun_day = date('d', $sun);
	$sat_mon = date('m', $sat);
	$sat_day = date('d', $sat);

	//get records
	if(!$rs = mysql_query("SELECT person_name, person_surname, person_birthdate, person_department FROM php_birthday_list WHERE MONTH(person_birthdate) >= $sun_mon AND MONTH(person_birthdate) <= $sat_mon AND DAYOFMONTH(person_birthdate) >= $sun_day AND DAYOFMONTH(person_birthdate) <= $sat_day ORDER BY MONTH(person_birthdate), DAYOFMONTH(person_birthdate), person_surname, person_name, person_department")) {
		echo "<p><strong>There was an error parsing the query.</strong></p>n";
	}
	//no records found
	elseif(mysql_num_rows($rs) == 0) {
		echo "<p><strong>No staff birthdays this week.</strong></p>n";
	}
	else {
		echo "<p>Option 1: This week's birthdays</p>n";
		//output birthdays
		echo "<table class="bordered" cellspacing="0">n";
		echo "<tr><th>Name</th><th>Birthday</th><th>Age</th><th>Department</th></tr>n";
		while($row = mysql_fetch_array($rs)) {
			$age = time() - strtotime($row['person_birthdate']);
			$age = floor($age / 31536000);

			echo "<tr>";
			echo "<td>$row[person_name] $row[person_surname]</td>";
			echo "<td>" . date('F j, Y', strtotime($row['person_birthdate'])) . "</td>";
			echo "<td>$age</td>";
			echo "<td>$row[person_department]</td>";
			echo "</tr>n";
		}
		echo "</table><br />n";
	}
}

The question above wasn’t crystal-clear about what constitutes a week. It may be that the questioner actually means a week to be today, plus the next six days. If so, a little tweaking of our code above accomplishes that task.

Instead of calculating the Sunday and Saturday of the current week, we can simply take the current timestamp, add 518,400 seconds (the number of seconds in six days) and get a end timestamp that’s six days from now.

Otherwise, the script is unchanged.

/*
OPTION 2: Today and six days hence.
*/

//get starting and ending months and days
$end = time() + 518400;
$start_month = date('m', time());
$start_day = date('d', time());
$end_month = date('m', $end);
$end_day = date('d', $end);

//get records
if(!$rs = mysql_query("SELECT person_name, person_surname, person_birthdate, person_department FROM php_birthday_list WHERE MONTH(person_birthdate) >= $start_month AND MONTH(person_birthdate) <= $end_month AND DAYOFMONTH(person_birthdate) >= $start_day AND DAYOFMONTH(person_birthdate) <= $end_day ORDER BY MONTH(person_birthdate), DAYOFMONTH(person_birthdate), person_surname, person_name, person_department")) {
	echo "<p><strong>There was an error parsing the query.</strong></p>n";
}
//no records found
elseif(mysql_num_rows($rs) == 0) {
	echo "<p><strong>No staff birthdays this week.</strong></p>n";
}
else {
	echo "<p>Option 2: Today and six days hence; also shows only birth month and day</p>n";
	//output birthdays
	echo "<table class="bordered" cellspacing="0">n";
	echo "<tr><th>Name</th><th>Birthday</th><th>Department</th></tr>n";
	while($row = mysql_fetch_array($rs)) {
		echo "<tr>";
		echo "<td>$row[person_name] $row[person_surname]</td>";
		echo "<td>" . date('F j', strtotime($row['person_birthdate'])) . "</td>";
		echo "<td>$row[person_department]</td>";
		echo "</tr>n";
	}
	echo "</table><br />n";
}

And that’s all there is to the traditional, server-side approach to this problem. You can see a working demo here:

http://www.dougv.com/demo/php_birthday_list/index.php

The JavaScript Approach

You might ask yourself, “Why should I waste valuable server CPU cycles and memory to output something so simple? Why not make the client’s Web browser do the work?” So long as you don’t need to make frequent changes to your employee list, and your employee list isn’t hundreds or thousands of entries long (making it a management nightmare), you can — and, probably, should — make the client’s Web browser do the heavy lifting.

Via DOM scripting, we can add rows and cells to an otherwise empty table, for each and every employee with a birthday this week. Not only that, we can even default the table to say there are no birthdays, and remove that default message if we do, indeed, have birthdays to display.

Let’s start with the HTML for the table, which will take the unique ID “birthdays”:

<table id="birthdays" class="bordered" cellspacing="0">
    <tr>
        <th>Name</th><th>Birthday</th><th>Age</th><th>Department</th>
        <tr><td colspan="4">No birthdays this week!</td></tr>
    </tr>
</table>

Nothing all that special there. But there’s some heavy lifting to be done in JavaScript.

The Person Class

First, we need to create a simple Person object which can accept a name, surname, birthdate and department.

Why an object? We could use a two-dimensional array; first dimension being employee number, second dimension being each of those attributes.

An object, however, makes things neater and easier to address. Each named property is easy to call; there’s conformity to the way each Person is created, as well. This is going to make it easier for us to code, and the code more easy to understand for people who are looking at it.

In JavaScript, classes (aka objects) are declared by creating a function with the name of the class you want to create, and by using the reserved word this to assign properties and methods to the class. (Our Person class will only have properties.)

function Person(name, surname, birthday, department) {
	//object representing an employee
	this.name = name;
	this.surname = surname;
	this.birthday = birthday;
	this.department = department;
}

The employee Array

Now that we have a class which will make every employee record we work with nice and neat, we need to add all our employees to a global array. We’re using a global array of employees because it’s convenient, and since the entire script relies on this array to work, it’s appropriate to scope the array globally. (For more of an understanding about variable scope, see my blog entry titled, “Variable Scope Made Simple.”

The way we’ll add employees to that global array is via a function called createEmployeeList(). All it does is push onto the end of the employees array a new Person object, one for each employee on the payroll.

//declare global array of employees
var employees = new Array();

function createEmployeeList() {
	//add employees to global employees array
	employees.push(new Person('Laura', 'Miller', new Date('March 21, 1982'), 'Accounts Payable'));
	employees.push(new Person('Page', 'Rockwell', new Date('May 10, 1951'), 'Warehouse'));
	employees.push(new Person('Tom', 'Jones', new Date('May 10, 1984'), 'Mainenance'));
	employees.push(new Person('Richard', 'Gingras', new Date('May 11, 1946'), 'Administration'));
	employees.push(new Person('Joan', 'Walsh', new Date('May 11, 1973'), 'Administration'));
	employees.push(new Person('Norman', 'Blashka', new Date('May 12, 1953'), 'Mainenance'));
	employees.push(new Person('Kerry', 'Lauerman', new Date('May 13, 1967'), 'Mainenance'));
	employees.push(new Person('Joy', 'Press', new Date('May 14, 1969'), 'Accounts Payable'));
	employees.push(new Person('Jeanne', 'Carstensen', new Date('May 15, 1990'), 'Accounts Payable'));
	employees.push(new Person('Ruth', 'Henrich', new Date('May 16, 1981'), 'Mainenance'));
	employees.push(new Person('Wendy', 'Williams', new Date('May 17, 1992'), 'Accounts Payable'));
}

Note that one compromise we have to make in JavaScript, versus the traditional PHP / MySQL approach, is that records must be listed in the order of birth date; specifically, by month, day and year. In other words, all the Jan. 1 birthdays must be listed first; of all the Jan. 1 birthdays, the one in 1931 must be listed before the one in 1978.

That’s assuming you want to order your results by date; in other words, you want birthdays appearing today to come first, birthdays tomorrow second, birthdays two days from now third, etc.; and you want older people listed before younger people. If you want your list ordered some other way — say, by last name, department, etc. — that’s the order they should appear in the list.

If we were using a supporting technology such as Google Gears Database, we wouldn’t face this problem; we’d simply offload the employee list to the client and sort it as we would with a traditional SQL query (or, more specifically, a SQLite query).

I don’t want to delve into Google Gears too deeply in this entry, but assuming I ever get around to working on the Gulf Of Maine Wrecks Web site again, Gears will feature prominently, and there is where I will blog about using it.

The listBirthdays() Function

With an array of employees at our disposal, we can now get down to the nitty-gritty: Showing employees with a current birthday in our table.

The approach is the same as the one used in our PHP script. We get today’s date; from that, figure out the Sunday and Saturday of the current week; then iterate through the entire array of employees, looking for those who have a birthday with a month and day that fall between Sunday and Saturday.

For each employee that has a birthday this week, we add a new row to the table, then a cell for the name, birth month / day, age and department of that employee. We keep track of which row we’re adding via a counter, named x, which begins at index 2 (that is, row 3).

We start at row 3 because our table has two rows: A header row (1) and a row that says there aren’t any current birthdays (2). If we encounter at least one birthday this week, we set the value of a Boolean named ok to true (its initial value is false).

After we’re all done iterating the records, if the value of ok is true, we tell the table to remove row 2 — that is, the row that says there are no current birthdays.

function listBirthdays() {
	//get birthday list table
	var table = document.getElementById('birthdays');

	//set today's date
	//comment out declaration below and use this for production runs
	//var today = new Date();

	//for demo purposes, I'm using May 12 as the date
	//use the code above instead of this line
	var today = new Date('May 12, 2009');

	//set Sunday
	var sun = new Date();
	sun.setTime(today.getTime() - (86400000 * today.getDay()));

	//set Saturday
	var sat = new Date();
	sat.setTime(today.getTime() + (86400000 * (6 - today.getDay())));

	//declare table row counter; index begins at 2 to accommodate header row and no birthdays message
	var x = 2;

	//boolean to check if any birthdays found for this week
	var ok = false;

	//iterate employee array
	for(var i = 0; i < employees.length; i++) {
		//if birthday exists this week ...
		if(employees[i].birthday.getMonth() >= sun.getMonth() && employees[i].birthday.getMonth() <= sat.getMonth() && employees[i].birthday.getDate() >= sun.getDate() && employees[i].birthday.getDate() <= sat.getDate()) {
			//change birthday found boolean to true if it is false
			if(!ok) {
				ok = true;
			}
			//add row to table for employee
			var row = table.insertRow(x);
			//name column
			var name = row.insertCell(0);
			name.innerHTML = employees[i].name + ' ' + employees[i].surname;
			//birthday column
			var birthday = row.insertCell(1);
			birthday.innerHTML = monthName(employees[i].birthday.getMonth()) + ' ' + employees[i].birthday.getDate();
			//age column
			var age = row.insertCell(2);
			age.innerHTML = Math.floor((today.getTime() - employees[i].birthday.getTime()) / 31536000000);
			//department column
			var dept = row.insertCell(3);
			dept.innerHTML = employees[i].department;
			//iterate row counter
			x++;
		}
	}
	//remove no birthdays message if birthdays found
	if(ok) {
		table.deleteRow(1);
	}
}

Final JavaScript Functions

To complete the JavaScript version, we need two more functions. The first is monthName(), which takes an integer argument and returns a text value corresponding to the numeric value of the month indicated. (In JavaScript, the getMonth() method of the Date object returns an integer from 0-11, where January is 0 and December, 11.)

function monthName(month) {
	//return text name for month numeric value
	switch(month) {
		case 0:
			return 'Jan.';
			break;
		case 1:
			return 'Feb.';
			break;
		case 2:
			return 'March';
			break;
		case 3:
			return 'April';
			break;
		case 4:
			return 'May';
			break;
		case 5:
			return 'June';
			break;
		case 6:
			return 'July';
			break;
		case 7:
			return 'Aug.';
			break;
		case 8:
			return 'Sept.';
			break;
		case 9:
			return 'Oct.';
			break;
		case 10:
			return 'Nov.';
			break;
		case 11:
			return 'Dec.';
			break;
		default:
			return 'Undefined';
	}
}

Finally, we need to create a function we can call with the onload event, because we need to trigger two functions: createEmployeeList() and listBirthdays(). (I could have combined these functions into one, or called createEmployeeList() from listBirthdays(), but the two functions really do two different things, and I believe elegance dictates keeping them separate.)

function pageLoad() {
	//on page load, bind employee list, show birthdays
	createEmployeeList();
	listBirthdays();
}

Invoking The JavaScript

To get the whole thing to work, we simply make pageLoad() the onload event for the body tag:

<body onload="pageLoad()">

(Technically, we could simply use the window.onload event handler in JavaScript, but I find that doesn’t always work well in every browser; I prefer to call onload events via the body tag.)

And that’s all there is to it. You can see a working demo here:

http://www.dougv.com/demo/php_birthday_list/javascript.html

You can download both scripts here: Using JavaScript To Perform A Task Traditionally Solved With Server-Side Scripting Demo Code. I distribute code under the GNU GPL version 3.

All links in this post on delicious: http://delicious.com/dhvrm/using-javascript-to-perform-a-task-traditionally-solved-with-server-side-scripting

Special thanks to Salon.com for the staff list, which provided most of the names used in this demo.

Related Posts

1. Objects (Classes) Explained In Very Simple Terms (18.5)
2. The Difference Between Data Adapters, Data Sets And Data Readers, In Plain English (16.9)
3. The Difference Between Null, Empty And Zero-Length Data / Strings (14.4)

The numbers inside parentheses are relevance scores. Scoring is based, in order of priority, on title, category, content and tags. The higher the score, the more likely that post relates to this post. ]]> Asked recently on Yahoo! Answers:

Multiple nested MySQL functions in PHP?

I was going through code today, trying to make some things more compact. The application worked without problems, so I knew that mysql error statements were superfluous.

This is the type of statement I was changing, I figured that I’d remove the seemingly unnecessary $result2 variable

$result2 = mysql_query($carts) or die(mysql_error());<br />
while ($row2 = mysql_fetch_array($result2)) {<br />
	echo "<option>$row2[0]</option>";<br />
}

so this is what I changed it into (I basically replaced where it said $result2, to what $result2 had contained, and removed the error check)

while ($row2 = mysql_fetch_array(mysql_query($carts))) {<br />
	echo "<option>$row2[0]</option>";<br />
}

but this code returned infinite loops, much to my surprise. Why is it doing this? is there a way around it?

Recently, I wrote about how PHP’s weak data types often can lead to problems for new programmers who don’t understand the difference between null, empty and zero-length variables. Here’s another opportunity to expose why strong data typing is essential for best programming practices, and to show how PHP’s weak data types — normally, a source of comfort for beginning programmers — can be the source of extensive frustration.

Let’s look at the first block of code, which was to be “cleaned up” by this questioner:

$result2 = mysql_query($carts) or die(mysql_error());
while ($row2 = mysql_fetch_array($result2)) {
	echo "<option>$row2[0]</option>";
}

The code here is straightforward. Somewhere prior to this block, the questioner connected to a database server and selected a database. Now, he wants to populate a select with the results set from a SELECT query (stored in a variable named $carts).

Let’s examine each line:

1. mysql_query() instructs a connected MySQL database server to execute the specified query and return a resource or boolean, depending on the type of query run and any errors encountered by the function. In this case, assuming the database server does not encounter an error, a result resource will be returned.
2. mysql_fetch_array() takes the result returned by the query, instructs the database server to populate the noted array variable with the contents of the current row, and to advance the internal pointer in the result to the next row. while() instructs this process to continue until the internal row pointer of the resource reaches the end of the result.
3. The echo statement outputs a new option element to the page, setting as its value the value of the first cell of the $row2 array.

Grab some data, use it as the value(s) for some element(s) on the page. This is known as data binding, and it’s as routine a task as Web programming allows.

But in the process of data binding with PHP’s built-in functions, we actually work with several unmentioned objects and data types, which would have been a lot more transparent had we used a more structured programming language.

How Data Binding Works In Strongly Typed Languages

Bear with me for a moment while I show how the code block above would be different if we used a more strongly typed, more object-oriented programming language to accomplish the same task.

For example, if I want to populate a select list in ASP.NET from a database, I might declare a DropDownList control on my page, and use a SQLDataSource control to populate it:

<asp:DropDownList runat="server" ID="MyDropDown" DataSourceID="MyDataSource" DataTextField="some_column" DataValueField="some_other_column" />
<asp:SqlDataSource runat="server" ID="MyDataSource" SelectCommand="SELECT * FROM some_table" ConnectionString="<%$ ConnectionStrings:MyNorthwind%>" />

This level of abstraction hides from me all the objects and data types I might otherwise need to explicitly declare in order to add option elements to a select in ASP.NET. (In other words, it works like PHP in terms of writing it, because I don’t need to concern myself with data types or other pesky technical details; ASP.NET, like PHP, takes care of that for me.)

Actually, it’s better than PHP, because I am not writing control loops or working with things like result resources; I simply plug in some parameters and ASP.NET does the grunt work for me. This is abstraction at the height of its power.

An alternative approach in ASP.NET would be to use a subroutine to bind data from the query to a DropDownList control. If I wanted to do that, I would first declare a DropDownList control:

<asp:DropDownList runat="server" ID="MyDropDown"  />

Then, in my code behind / server script block, I would declare all the data types and variables needed to actually connect to, and extract from, a database server the records I want:

Imports System.Data
Imports System.Data.SqlClient

Sub Page_Load(Sender As Object, E As EventArgs) Handles Me.Load
	If Not Page.IsPostBack Then
		MyDropDown_dataBind()
	End If
End Sub

Sub MyDropDown_dataBind()
	Dim objConn As New SqlConnection("My Connection String")
	Dim objCmd As New SqlCommand("SELECT * FROM table", objConn)

	Try
		objConn.Open()
		Dim objReader As SqlDataReader = objCmd.ExecuteReader()

		If objReader.HasRows Then
			MyDropDown.DataSource = objReader
			MyDropDown.DataTextField = "some_column"
			MyDropDown.DataValueField = "some_other_column"
			MyDropDown.DataBind()
		Else
			MyDropDown.Items.Insert(0, New ListItem("No records returned!"))
		End If

		objConn.Close()
	Catch Ex As Exception
		MyDropDown.Items.Insert(0, New ListItem("There was a database error getting the records: " & Ex.Message))
	Finally
		objCmd.Dispose()
		objConn.Dispose()
	End Try
End Sub

Notice that the code above is far more explicit and complex than the previous code blocks. It employs several classes: SqlConnection, SqlCommand, SqlDataReader, DropDownList (referenced by calling MyDropDown), ListItem and Exception, to name several. Each of these classes are their own data types, and each employs primitive types, such as integers and strings, or even each other, as properties and / or arguments for methods they employ.

Strong typing means knowing exactly what you’re working with as you program. Abstraction, when done to the extent ASP.NET provides, means not having to worry one bit about what you’re working with.

PHP’s approach fits somewhere in the middle: You don’t really need to know what you’re working with, but not knowing can cause lots of trouble.

What’s Wrong With The Second Code Block

Let’s look now at the second code block and sort out its troubles.

while ($row2 = mysql_fetch_array(mysql_query($carts))) {
	echo "<option>$row2[0]</option>";<br />
}

Line 1 accomplishes several tasks, which we will evaluate from the right to the left, since that’s the order PHP will use:

• We query the database; again, a mysql result resource is returned on success.
• We read the first line of that result into an array named $row2 The internal record pointer of the result resource is advanced to the next record.
• We repeat the process due to the while loop.

In other words, so long as the query always returns at least one record, the while condition is always satisfied, so the loop never stops executing. It just keeps spitting out the first record of the results set, over and over again.

The while condition always evaluates to true because the structure of the code does not consider how a result resource works. And that, in large part, is the fault of PHP’s weak data types.

When mysql_query() returns a result resource, what it’s really doing is telling the database server to hold, in the database server’s memory, the records requested.

The resource returned by the MySQL server isn’t itself an PHP variable, the way a string or integer is; it’s a reference PHP uses to tell the database server, “Remember the records I asked for with that query? The ones you bookmarked with the value stored in this reference? I want you to work with those records.”

Looking again at the questioner’s first code block:

$result2 = mysql_query($carts) or die(mysql_error());
while ($row2 = mysql_fetch_array($result2)) {
	echo "<option>$row2[0]</option>";
}

• In Line 1, $carts is the string we will pass as a query; e.g., “SELECT * FROM table”. $carts is an internal variable — that is, a variable that exists within PHP itself, which PHP can manipulate directly.
• In Line 1, $result2 is a resource. In this case, it will be a result, which is a reference (or a kind of bookmark) that MySQL gives to PHP after MySQL sets aside, in its memory, the records we requested. PHP doesn’t have these records; they remain on the database server. Whenever PHP wants to work with those records, it sends the reference (bookmark) held in $result2 back to MySQL, and MySQL gets, from its memory, the records referenced (bookmarked) by that PHP variable. That makes $result2 an external variable; PHP does not directly work with the information contained in $result2, but uses it to tell MySQL to perform tasks on its behalf.
• Line 2 instructs MySQL to send, to PHP, the current record referenced by $result2′s row poiner (more on that in a moment). Once MySQL sends that record, PHP assigns that record’s columns to an associative array named $row2. In this case, PHP uses the external variable $result2 to remind MySQL which set of records PHP wants, and to tell MySQL to send to PHP information it can assign to an internal variable, $row2.
• When PHP asks MySQL to send the information it assigned to $row2, it also tells MySQL to advance the row pointer to the next record in the result resource. The row pointer, which is part of the result resource, is how MySQL knows where PHP left off when it last worked with the records in the result resource. Because advancing the row pointer happens silently — that is, MySQL does this implicitly, as part of its mysql_fetch_array() tasks; you don’t explicitly command MySQL to advance the row pointer — it’s easy to forget about the row pointer altogether.

Inefficient, Inelegant, But By Design

So, how do we achieve the efficiency desired by this questioner?

In short, we don’t. By design, PHP requires a fairly verbose process to bind data to a page or HTML element; there’s really no more efficient manner of going about it. In fact, the block below is about as compact as it gets when binding option elements to a select, using only PHP’s built-in functions:

<select id="myselect" name="myselect">
<?php
	$link = mysql_connect("host", "user", "pass") or die("cannot connect to db server");
	mysql_select_db("dbname") or die("cannot select database");
	$rs = mysql_query("SELECT * FROM table") or die("cannot parse query");
	while($row = mysql_fetch_array($rs)) {
		echo "<option>$row[0]</option>";
	}
?>
</select>

If you have lots and lots of controls to bind in the same way, you might consider using a class. Among the benefits of a class, as we have seen in the past, is that we can reuse code for similar tasks.

Below is a class, named optionMaker, that takes as its constructor arguments a database query and link resource, respectively; its public method, makeOptions(), spits out option elements from the resulting record set.

<?php
class optionMaker {
	public $link, $query;
	private $rs, $row;

	function __construct($q, $l) {
		$this->query = $q;
		$this->link = $l;
		$this->getResults();
	}

	private function getResults() {
		if(!$this->rs = mysql_query($this->query, $this->link)) {
			unset($this->rs);
		}
		elseif(mysql_num_rows($this->rs) == 0) {
			unset($this->rs);
		}
	}

	public function makeOptions() {
		if(!is_null($this->rs)) {
			while($this->row = mysql_fetch_array($this->rs)) [
				echo "<option>" . $this->row[0] . "</option>n";
			}
		}
		else {
			echo "<option>No matching records or database error getting records</option>n";
		}
	}
}
?>

Note that this class isn’t very secure; it doesn’t check if the $link resource is valid, for example; it doesn’t sanitize the SQL it is sent; it will pass UPDATE, DELETE, DROP or other possibly harmful queries along. While these security holes shouldn’t be of major concern — presumably, you wouldn’t poison your own well by sending bad parameters to this class — it’s always best to secure your applications against unintended uses and attacks. Use this at your own risk.

(Herein lies another benefit of object-oriented languages: In ASP.NET, there are a number of ways to prevent controls from sending potentially harmful queries to a database, sanitize input, etc. with little or no extra coding, compared to PHP.)

The easiest way to use the class above is to save it to a php file; call it optionMaker.php. Then, include that PHP file wherever you want to use it. Your use of the class to populate three select elements might look like this:

<?php
require_once("optionMaker.php");
$link = mysql_connect("server", "user", "pass") or die("cannot connect to db server");
mysql_select_db("dbname") or die("cannot select database");
?>

<select id="select1" name="select1">
<?php
$options1 = new optionMaker("SELECT column1 FROM table1", $link);
$options1->makeOptions();
?>
</select>

<select id="select2" name="select2">
<?php
$options2 = new optionMaker("SELECT column1 FROM table2 WHERE column2 = 'foo'", $link);
$options2->makeOptions();
?>
</select>

<select id="select3" name="select3">
<?php
$options3 = new optionMaker("SELECT a.column1 FROM table3 AS a LEFT JOIN table4 AS b ON a.id = b.foreign_key WHERE b.column1 = 'foo' AND b.foreign_key IS NOT NULL", $link);
$options3->makeOptions();
?>
</select>

If the database server can’t parse the query you supply, or if the query returns no records, the class simply nulls out the result resource returned by the database server; the makeOptions() method, in turn, returns a single option, noting the problem, if the result resource is null. (Strong typing, once again, solves a problem: What happens if the class has errors or no results? By using null, we escape such situations gracefully, and provide useful feedback to the user.)

Note also that this class will always use only one column — the first column in a successful result resource — as the value of the option elements it outputs.

I distribute all code under the GNU GPL version 3.

Related Posts

1. The Difference Between Data Adapters, Data Sets And Data Readers, In Plain English (27.2)
2. A Simple Calendar Page To Display Date-Specific Data In PHP (10.5)
3. Getting Plain Text From An ASP.NET 2.0 Page For Use As An AJAX Data Source (9)

The numbers inside parentheses are relevance scores. Scoring is based, in order of priority, on title, category, content and tags. The higher the score, the more likely that post relates to this post. ]]> A common problem faced by new programmers is understanding the difference between null, empty and zero-length variables, especially when working with database records.

While, for most intents and purposes, the three things have the same effect — either you have some data you can work with, or you don’t — they arise from different circumstances. Understanding how null, empty and zero-length are different can help you avoid data errors in your programs.

The short version is this: If a variable simply doesn’t exist — usually because it hasn’t been declared, but sometimes because it hasn’t been assigned a value — it’s null. If the variable exists but contains no data, it’s empty. And if a structured data variable, such as an array, exists but doesn’t contain any items, it’s zero-length.

An analogy is in order.

Think of a database as a house. A house has rooms, and in each of these rooms are furniture and accessories that are appropriate to that room.

For example, the kitchen has a stove, refrigerator and sink. The bedroom has a dresser, bed and armoire. The living room has a couch, television and coffee table.

Where’s The Fridge?

Let’s refocus the analogy. We’ll liken a database table to your kitchen, and the refrigerator as a column in that table.

As a general rule, refrigerators hold food. What specific food is in there doesn’t really matter, so long as it’s food. (I know the fridge doesn’t hold every kind of food and often contains non-food items. Bear with me, please, and just accept for the purpose of the analogy that a fridge holds food.)

That’s much like the way a database column works. For example, a column might be a VARCHAR(50). The column doesn’t care what you are storing in it; it only cares that you are storing text that is not longer than 50 characters.

But let’s suppose you just bought a house (i.e., you are creating a new database table). There is a kitchen, but the old owners took the refrigerator and left the stove.

There’s a space where the refrigerator used to be. But there’s no refrigerator there. That’s null.

In other words, just because you’ve set aside some space where the refrigerator ought to be, and just because you say to visitors, “the fridge is going to be right over there,” that doesn’t make one magically appear.

It’s the same thing with database columns (and, for what that’s worth, all scalars [i.e., variables]). Declaring that you intend to have data at some point doesn’t mean there is data. And when there’s no data, you get a null.

Let’s bring the analogy back around. You have a database table called kitchen. In kitchen is a column named refrigerator, and refrigerator will hold food data.

When you first create the refrigerator column in your database, you’ve basically said, “I will eventually have some food, and I will need to put it someplace, and that place will be a fridge, which will go right there.” But until you actually get around to all that, there is no fridge.

Basically, the database says, “I know that’s where you want to put the fridge. But until you get one, that’s just a void space.”

So there is no fridge. Or, in programming parlance, it’s null.

Nothing From Nothing Means Nothing; You Gotta Have Something …

You can’t get blood from a turnip, especially when you don’t even have a turnip. The same is true of nulls. Null isn’t zero; it’s nonexistence.

If you ask me, “How big is your swimming pool?,” I can’t answer that question; I don’t have a swimming pool. Never have, probably never will.

I can’t say a nonexistent swimming pool has zero size. I can’t say it’s infinite or infinitesimal, either. The largest and smallest possible measures are still measures, and you can’t quantify things that don’t exist.

That’s why nulls cause so much trouble for new programmers. They write their programs with the presumption that the data they are referencing actually exists.

Consider our house database again, with its kitchen table (no pun intended). Let’s suppose I’m baking cookies in the stove and washing dishes in the sink, but I don’t have a fridge. The one record in the table might look like this:

Let’s then suppose I want to serve milk with my cookies. I might use this code in VB.NET to tell me if I have milk:

Dim objConn As New SqlConnection("connection string")
Dim objCmd As New SqlCommand("SELECT * FROM kitchen", objConn)

objConn.Open()
Dim objReader As SqlDataReader = objCmd.ExecuteReader()
If objReader.HasRows() Then
	objReader.Read()
	If objReader("fridge") = "milk" Then
		Console.WriteLine("Cookies and milk! Yummy!")
	Else
		Console.WriteLine("There's no milk in the fridge.  ")
	End If
Else
	Console.WriteLine("There are no matching records.")
End If

objConn.Close()
objCmd.Dispose()
objConn.Dispose()

Notice this line:

If objReader("fridge") = "milk" Then

We are using the equality operator to determine if the value of objReader(“fridge”) is an empty string. But remember: there is no fridge.

Asking about what is inside a fridge that doesn’t exist is far more straightforward to a computer than it is to a person: The database basically says back to you, “What is this fridge of which you speak?”

Yet in the average person’s mind, not having any milk because you don’t have a fridge is the same thing as not having any milk in a fridge you do have. Either way, no milk.

This touches on the idea of identity, and it’s a good place to begin describing emptiness.

I Spit Out Like A Sewer Hole, Yet Still Receive Your Kiss

Let’s go back to our house database analogy.

Suppose, even though I don’t have any food, I decide to go ahead and buy a refrigerator. I put it in the place where I said I was going to put it, but there’s no food in it.

That’s emptiness. I have a fridge, but it is empty.

So, if I go back to line 8 of the example above:

If objReader("fridge") = "milk" Then

Visual Basic now knows there is, indeed, a fridge in the kitchen. So if I ask it whether there’s milk in the fridge, it can go look inside the fridge and see no, there isn’t.

The difference between null and empty is especially problematic with weakly typed programming languages, such as PHP.

PHP will implicitly assign a null variable an empty value if you use a comparison operator, such as == or !=. (In other words, if PHP doesn’t have a refrigerator, it will automatically conjure one up in order to tell you the fridge is empty, since it figures that’s what you really want to know.)

That reinforces the idea in some programmers’ minds that null is the same thing as empty. To get around this, one uses PHP’s identity operators, === and !==.

The identity operator attempts to bring strong typing to the weakly typed data used by PHP. Identity means, in a nutshell, “are these two variables both equal, and of the same data type?”

Generally speaking, we can trust PHP to handle automatically converting our data types — such as changing nulls into empty strings — so that the comparison operator works 99 percent of the time. But once in a while, we run into a situation where PHP’s implicit comparisons aren’t enough, and that’s when we need to use identity.

This can easily be demonstrated with the strpos() function. Ideally, when strpos() does not find the needle in the haystack, it returns the boolean false; when it finds the needle, it returns the position of the needle as an integer.

But sometimes, the value returned by strpos() if the needle isn’t found will be a value other than false, such as zero (if the needle is found at the beginning of the haystack) or an empty string.

So, we shouldn’t use the comparison operator ==, because PHP won’t implicitly cast zero or an empty string as boolean false. Instead, we use the identity operator ===, which basically says, “are these values equal, and the same type?” And that, in turn, instructs PHP to explicitly cast each of the variables as a mutual type — in our case, booleans — in order to make its comparison.

Consider the example below, which you can run for yourself here:

<?php
$foo = "Valerie";
$bar = "V";

echo "strpos() position of $bar in $foo is: ";
echo strpos($foo, $bar);
echo "<br />";

echo "strpos() return value of $bar in $foo is of type: ";
echo gettype(strpos($foo, $bar));
echo "<br />";

if(strpos($foo, $bar) == false) {
	echo "strpos() comparison operator says $bar is <strong>not</strong> in $foo";
}
else {
	echo "strpos() comparison operator says $bar is in $foo";
}
echo "<br />";

if(false === strpos($foo, $bar)) {
	echo "strpos() identity operator says $bar is <strong>not</strong> in $foo";
}
else {
	echo "strpos() identity operator says $bar is in $foo";
}
echo "<br />";
?>

(Many thanks to Valerie at theprogrammerskit.com for the variables.)

In the example above, strpos() finds “V” at the very start of “Valerie.” It does this, essentially, by converting “Valerie” into an array of characters, then iterating through each until it finds “V”. Since all PHP arrays are indexed from 0, strpos() returns 0.

When PHP’s comparison operator makes an implicit typecast from an integer to a boolean, it considers zero to be false and all other integer values to be be true. So because 0 is false, but it is also the index position of “V”, PHP erroneously reports the letter was not found.

However, when we use the identity operator, we are telling PHP, “First, find the type of the first operand. Next, convert the type of the second operand to be the same as the first. Finally, compare the values.”

While the implicit casting with the comparison operator makes the integer 0 equal to boolean false, the identity operator equates 0 with true, because it converts data using a different algorithm. (As to the why and how of that, I am not sure, except that PHP developers must have figured out that they needed a way to convert the integer 0 to boolean false, and decided the identity operator would take on that job.)

So, when strpos() returns a zero, PHP knows that it must first explicitly convert zero into a boolean. In this case, it understands zero to be the same as boolean true. And so, the identity operator properly states that the letter was found.

In strongly typed languages such as .NET, however, there’s an inherently huge difference between the ethereal and temporal.

In PHP, for the most part null and empty are apples and oranges; they’re not the same thing, but they’re at least both fruits. In .NET, null and empty are your marriage to Marisa Miller and oranges. There’s literally no comparison to be made.

However, because humans equate nothing with zero, thanks to our ontological capacities, almost all programming languages have some construct that allows us to equate null and empty. In .NET, for example, the IsNullOrEmpty() method of the String class:

Dim MyString As String

If MyString.IsNullOrEmpty() Then
	Console.WriteLine("MyString is null or empty, says IsNullOrEmpty")
End If

In PHP, again, the comparison operators will implicitly convert your nulls into empty strings. However, there is also the built-in is_null() function, which will also return a boolean if your variable is explicitly cast as null; you can couple that with an empty-string comparison to equate null and emptiness:

<?php
$foo = NULL;

if(is_null($foo) || $foo == "") {
echo '$foo is null or empty';
}
?>

Emptiness Is Loneliness, And Loneliness Is Cleanliness

Which brings us to zero-length, which is basically the condition of existing, and being something, but not anything useful.

This is most common with arrays and similar structured data (e.g., object properties). An array has zero length if it has been instantiated but contains no data. A zero-length data structure, such as an array, itself isn’t null, and it has type; but it contains nothing.

It’s like having a refrigerator with its door chained shut; it’s there, but you can’t look inside it or take anything out. Of course, you can always unchain the door, and then put things in or out, or just look at what’s there.

Consider this PHP code, the output of which you can see here:

<?php
$foobar = array();
echo 'the length of $foobar is: ' . count($foobar);
echo "<br />";

foreach($foobar as $foo) {
	echo "$foo<br />";
}

$foobar[] = "Hello";
$foobar[] = 46;
echo 'the new length of $foobar is: ' . count($foobar);
echo "<br />";

foreach($foobar as $foo) {
	echo "$foo<br />";
}
?>

• Line 3 prints 0; $foobar has zero length because we didn’t add anything to it.
• Lines 6-8 are ignored, because $foobar has zero length; there is no each.
• Line 12 prints 2, because there are now two items in the array.
• Lines 15-17 print “Hello” and 46, because foreach now has items to iterate.

Null vs. Empty vs. Zero Length Recap

So, in review: Null means the variable does not exist. Empty means it exists, but it contains no value. Zero length means an array or similar structure has been declared — and, if the language is strongly typed, has type — but contains no values.