It can be done by attaching to the form element two validators: Zend_Validate_Digits and Zend_Validate_NotEmpty, but first let’s see how to change the default “Value is required and can’t be empty” error message of a form field.

$element = $form->createElement('text', 'phone');
$element->setLabel('Please, enter your phone number:')
	->setRequired(true)
	->addValidator('Digits');
$form->addElement($element);

Here we validate the field with Zend_Validate_Digits and we have set it to be required. Thus everything containing characters, i.e. “my123name” or “007bond”, will be false, while “1234″ will be true.

To show different error messages you've to attach them per validator and not per form element!

$element = $form->createElement('text', 'phone');
$element->setLabel('Please, enter your phone number:')
	->setRequired(true)
	->addValidator('Digits')
	->addErrorMessage('Please, type your phone here!');
$form->addElement($element);

Now the error message is changed from “Value is required and can’t be empty” to “Please, type your phone here!”.

The problem is that when you add more than one validator to a form field you can still show one message regardless of the validator that has failed.

$element = $form->createElement('text', 'phone');
$element->setLabel('Please, enter your phone number:')
	->setRequired(true)
	->addValidator('NotEmpty', true)
	->addValidator('Digits', true)
	->addErrorMessage('Please, type your phone here!');
$form->addElement($element);

In this case whenever the field is empty or it contains something different from digits, the message shown to the user will be “Please, type your phone here!”. The question is can we show different error messages on every validator. This should look something like “The field cannot be empty!” when the field is empty and “Please, enter only digits!” when the user has entered something into the field, but it doesn’t contain only digits.

The Solution

Actually we have to attach error messages per validator, and not on a form element. Here’s how it can be done.

$notEmpty = new Zend_Validate_NotEmpty();
$notEmpty->setMessage('The field cannot be empty!');
 
$digits = new Zend_Validate_Digits();
$digits->setMessage('Please, enter only digits');
 
$element = $form->createElement('text', 'phone');
$element->setLabel('Please, enter your phone:')
	->setRequired(true)
	->addValidator($notEmpty, true)
	->addValidator($digits, true);
$form->addElement($element);

Note that we set to “true” the second parameter of addValidator. This is important because this way we break the validator’s chain and when the validation fails on NotEmpty the framework stops the validation of that field against the other validators.

Related posts:

1. Default Error Handling in Zend Framework
2. One Form – Multiple DB Records
3. Secure Forms with Zend Framework

class A
{
	public function __construct()
	{
		echo 'building an object';
	}
 
	public function __destruct()
	{
		echo 'destroying the object';
	}
}
 
$obj = new A();

Well, as you can not call the constructor explicitly:

$obj->__construct();

So we should not call the destructor explicitly:

$obj->__destruct();

The problem is that I’ve seen this many times, but it’s a pity that this won’t destroy the object and it is still a valid PHP code.

PHP destructors cannot be called explicitely!

Constructors and destructors in PHP are part of the so called magic methods. Here’s what the doc page says about them.

The function names __construct(), __destruct(), __call(), __callStatic(), __get(), __set(), __isset(), __unset(), __sleep(), __wakeup(), __toString(), __invoke(), __set_state() and __clone() are magical in PHP classes. You cannot have functions with these names in any of your classes unless you want the magic functionality associated with them.

To be more precise let’s take a look of the definition of destructors.

PHP 5 introduces a destructor concept similar to that of other object-oriented languages, such as C++. The destructor method will be called as soon as there are no other references to a particular object, or in any order during the shutdown sequence.

What if I Call the Destructor Explicitly?

Let’s see some examples!

class A
{
	public function __destruct()
	{
		echo 'destroying the object';
	}
}
 
$obj = new A();
 
// prints hello world
echo 'hello world';
 
// PHP interpreter stops the script execution and prints
// 'destroying the object'

This is actually a normal behavior. At the end of the script the interpreter frees the memory. Actually every object has a built-in destructor, just like it has built-in constructor. So even we don’t define it explicitly, the object has its destructor. Usually this destructor is executed at the end of the script, or whenever the object isn’t needed anymore. This can happen, for instance, at the end of a function body.

Now if we call the destructor explicitly, which as I said I’ve seen many times, here’s what happen.

class A
{
	public function __destruct()
	{
		echo 'destroying the object';
	}
}
 
$obj = new A();
 
// this is valid and it prints 'destroying the object'
// BUT IT DOES NOT DESTROY THE OBJECT
$obj->__destruct();
 
// prints hello world
echo 'hello world';
 
// HERE PHP ACTUALLY DESTROYS THE $obj OBJECT
// ... and again prints 'destroying the object'

As you can see calling the destructor explicitly doesn’t destroy the object. So the question is …

How to Destroy an Object Before the Script Stops?

Well, to destroy an object you can assign a NULL value to it.

class A
{
	public function __destruct()
	{
		echo 'destroying the object';
	}
}
 
$obj = new A();
 
// prints 'destroying the object'
$obj = null;
 
// prints 'hello world'
echo 'hello world';
 
// the script stop its execution

Caution

Be aware of that if you don’t clone the object $obj, and simply assign it to another variable, then $obj = null will be pointless. Let’s see the following example.

class A 
{
	public function printMsg()
	{
		echo 'I still exist';
	}
 
	public function __destruct()
	{
		echo 'destroying the object';
	}
 
}
 
$obj = new A();
 
// $newObj is pointing to $obj
$newObj = $obj;
 
// this doesn't destroy $newObj
// as it appears both $obj and $newObj point to the same memory
// so PHP doesn't free this memory
$obj = null;
 
// prints 'i still exist'
$newObj->printMsg();
 
// prints 'hello world'
echo 'hello world';
 
// now the scripts destroys the "object", which in this
// case is $newObj and prints 'destroying the object'

This example shows us that actually by assigning NULL to an object doesn’t quite destroy it if there are another objects pointing to the same memory.

class A 
{
	public function printMsg()
	{
		echo 'I still exist';
	}
 
	public function __destruct()
	{
		echo 'destroying the object';
	}
 
}
 
$b = new A();
 
$d = $c = $b;
 
$b = null;
 
$c->printMsg();
$d->printMsg();
 
// prints 'destroying the object' ONLY ONCE

In this last example there are two interesting things to note. First $b = null doesn’t call the destructor, and at the end of the script there’s only one implicit call of the destructor, although there are two objects.

Conclusion

The important thing to note is that you shouldn’t call the destructor of an object explicitly! Not because it will throw an fatal error, but simply because it won’t destroy the object.

[1] PHP: Constructors and Destructors

Related posts:

1. Some Notes on the Object-oriented Model of PHP
2. Object Cloning and Passing by Reference in PHP
3. How to Check if a Date is More or Less Than a Month Ago with PHP

strtotime() is a lot more powerful than you think!

The question is whether PHP cannot help us with built-in functions to perform these calculations for us. It is obvious, that from version 5.3.0 and later, there is an OOP section, which is great, but unfortunately this version is still not updated everywhere. So, how to accomplish the task?

The Wrong Approach

As I said, there are many ways to go in the wrong direction. One of them is to subtract 30 days from current date. This is completely wrong, because not every month has 30 days. Here, some developers will begin to predefine arrays to indicate the number of days in each month, which then will be used in their complicated calculations. Here is an example of this wrong approach.

echo date('Y-m-d', strtotime(date('Y-m-d')) - 60*60*24*30);

This line is full of mistakes. First of all strtotime(date(‘Y-m-d’)) can be replaced by the more elegant strtotime(‘now’), but for this later. Another big mistake is that 60*60*24*30, which is number of seconds in 30 days can be predefined as a constant. Eventually the result is wrong, because not every month has 30 days.

The Correct Approach

A small research of the problem and the functions in versions prior of 5.3.0 of PHP is needed. Typical case study of date formatting happen when working with dates from a database. The following code is a classical example.

// 2008 05 23, 2008-05-23 is stored into the DB
echo date('Y m d', strtotime('2008-05-23'));
 
// 2008 May 23
echo date('Y F d', strtotime('2008-05-23'));

The problem, perhaps, is that too often strtotime() is used like this, with exactly this type of strings. However much more interesting is that strtotime() can do much more.

strtotime() Can Do Much More

Let us first look at the documentation of this function. What parameters it accepts?

int strtotime ( string $time [, int $now = time() ] )

The function expects to be given a string containing an English date format and will try to parse that format into a Unix timestamp (the number of seconds since January 1 1970 00:00:00 UTC), relative to the timestamp given in now, or the current time if now is not supplied.

In particular we are interested in the first parameter, time.

time - A date/time string. Valid formats are explained in Date and Time Formats.

It is especially important to note what are the valid Date and Time Formats.

Here are the supported formats, but most interesting are those that are Relative.

Exactly these formats are very convenient in our case, because they give us the ability to work with human readable strings, and here are some examples from the documentation of strtotime().

echo strtotime("now"), "\n";
echo strtotime("10 September 2000"), "\n";
echo strtotime("+1 day"), "\n";
echo strtotime("+1 week"), "\n";
echo strtotime("+1 week 2 days 4 hours 2 seconds"), "\n";
echo strtotime("next Thursday"), "\n";
echo strtotime("last Monday"), "\n";

Thus, a valid string would be “1 month ago”.

// if current date is 2011-11-04, this will return 2011-10-04
echo date('Y-m-d', strtotime('1 month ago'))

Or “-1 month”:

// the same as the example above
echo date('Y-m-d', strtotime('-1 month'));

It’s interesting that “+1 -1 month” is also a valid string.

// 2011-10-04, if today's 2011-11-04
echo date('Y-m-d', strtotime('+1 -1 month'));

In fact strtotime() can do a lot more than most of the developers have ever imagined. Maybe its frequent use with string formatted dates (2010-01-13) makes it a bit unknown. Here are some interesting use cases.

// 1970-01-01, Calculations in braces are bad!
echo date('Y-m-d', strtotime('(60*60) minute'));
 
// 2 months into the future
echo date('Y-m-d', strtotime('-2 months ago'));

For instance, do you know how to get the date of the day before yesterday? Yes 2 days before today, but here’s yet another solution.

// 1 day before yesterday
echo date('Y-m-d', strtotime('yesterday -1 day'));

Another example is the fully human readable:

// get the first monday of the current month
echo date('Y-m-d', strtotime('first monday this month'));

The Solution of the Task

Finally, what is the solution of the original task? Well, just have to check whether a date is more or less than a month ago.

// a random date
$my_date = '2011-09-23';
 
// true if my_date is more than a month ago
(strtotime($my_date) < strtotime('1 month ago'))

Related posts:

1. javascript get locale month with full name
2. Thing to Know About PHP Arrays
3. Powerful PHP: Less Known String Manipulation

Some developers think that everything's passed by reference in PHP.

Passing Parameters by Reference

Clearly when we pass parameters to a function it’s not by reference. How to check this? Well, like this.

function f($param)
{
	$param++;
}
 
$a = 5;
f($a);
 
echo $a;

Now the value of $a equals 5. If it were passed by reference, it would be 6. With a little change of the code we can get it.

function f(&$param)
{
	$param++;
}
 
$a = 5;
f($a);
 
echo $a;

Now the variable’s value is 6.

So far, so good. Now what about copying objects?

Objects: A Copy or a Cloning?

We can check whether by assigning an object to a variable a reference or a copy of the object is passed.

class C
{
	public $myvar = 10;
}
 
$a = new C();
$b = $a;
 
$b->myvar = 20;
 
// 20, not 10
echo $a->myvar;

The last line outputs 20! This makes it clear. By assigning an object to a variable PHP pass its reference. To make a copy there’s another approach. We need to change $b = $a, to $b = clone $a;

class C
{
	public $myvar = 10;
}
 
$a = new C();
$b = clone $a;
 
$b->myvar = 20;
 
// 10
echo $a->myvar;

Arrays by Reference

What about arrays? What if I assign an array to a variable?

$a = array(20);
 
$b = $a;
$b[0] = 30;
 
var_dump($a);

What do you think is the value of $a[0]? Well, the answer is: 20! So $b is a copy of the array “a”. Instead you should assign explicitly its reference to make “b” point to “a”.

$a = array(20);
 
$b = &$a;
$b[0] = 30;
 
var_dump($a);

Now $a[0] equals 30!

I think this could be useful!

Related posts:

1. Some Notes on the Object-oriented Model of PHP
2. Friday Algorithms: Quicksort – Difference Between PHP and JavaScript
3. PHP: The Array Element Doesn’t Exist – Suppress the Warnings

$arr = array(1 => 10, 1 => 11);

What happens when the interpreter reaches this line of code? This is not a syntax error and it is completely valid. Very similar, but more interesting case is when we have an array of identical keys, where those identical keys are represented once as an integer and then as a string.

Keys in PHP arrays are not type sensitive, so pay attention when using them!

$arr = array(1 => 10, "1" => 11);

Now several questions arise. First of all, how many elements have this array? Two or one. This can be easily verified by checking what count() will return.

echo count($arr);

The correct answer is 1. This simply means, that there’s no difference between string keys and integer keys. What would happen if we had a “normal” array with different keys?

$arr = array(1 => 10, "2" => 11);
echo count($arr);

As expected this returns 2.

Next thing to check is what’s in the array after this initialization line.

$arr = array(1 => 10, "1" => 11);

Is there something in the first element $arr[0], or there’s something in the second element $arr[1]? What is the value of the single value?
As it appears the second element replaces the first one. We’ve seen that the array has only one value, but where’s that value? The only way to check this is to dump both elements:

var_dump($arr);

Here we can see that $arr[1] contains “11″ and it is the only value, and $arr[0] is not set.

Related posts:

1. PHP: What is More Powerful Than list() – Perhaps extract()
2. PHP Associative Arrays Coding Style
3. Friday Algorithms: Quicksort – Difference Between PHP and JavaScript

$str = 'hello world';
echo substr($str, 0, 1); // outputs "h"

But here’s something better and cleaner.

echo $str{0}; // outputs "h"

This code chunk return the first character of $str, but it can be used with the same success for any other character of the string. In my opinion this is more cleaner and its really syntactically self documented.

This approach can be useful when trying to check whether the first symbol for instance is “?” or “/”.

Related posts:

1. Flexible JavaScript – Replace in a String
2. 5 PHP String Functions You Need to Know
3. PHP: What is More Powerful Than list()

The Route from $_GET to String

The global arrays in PHP contain request parameters. Either GET or POST. As you know if the page address is something like:

http://www.example.com/index.php?a=b&key=value

This means that you pass to the index.php file two parameters – “a” and “key” with their values: “b” and “value”. Now in this case you can dump the $_GET global array somewhere in index.php and you’ll receive something like this.

array(
	"a"   => "b",
	"key" => "value",
);

This is however pseudocode, but in fact $_GET will be very similar to this sample array.

$_GET to String

Very often when a developer need to process the $_GET array to a string, which means generating again the query string from $_GET, he often comes to some operation like this one.

$queryString = '';
foreach ($_GET as $key => $value) {
	$queryString .= $key . '=' . $value . '&';
}

However this will result in something quite ugly like a=b&key=value& which comes with a trailing & at the end of the string.

There is however another approach – using an array.

$queryString = array();
foreach ($_GET as $key => $value) {
	$queryString[] = $key . '=' . $value;
}
$queryString = implode('&', $queryString);

But that invokes one function more and this is still not the most elegant solution. As I said at the beginning PHP is full of useful functions and here comes the http_build_query.

http_build_query

This is exactly what you need. As it name describe you can build the query string even by using a different from & separator.

$queryString = http_build_query($_GET, '', '|');

Thus $queryString will contain a=b|key=value and at least the code will look pritier.

Related posts:

1. Powerful PHP: Less Known String Manipulation
2. Zend Examples: GET Parameters Default Value
3. 5 PHP String Functions You Need to Know

Most of the code chunks I’ve seen about getting a file extension from a string are based on some sort of string manipulation.

If you want to get the filename extension with PHP is better to use pathinfo() than string manipulations

$filename = '/my/path/image.jpeg';
echo substr($filename, strrpos($filename, '.') + 1);

Howerver there is a more elegant solution.

$filename = '/my/path/image.jpeg';
echo strtolower(pathinfo($filename, PATHINFO_EXTENSION));

Thus you rely on PHP built in functions and it’s harder to overlook the exact string manipulation approach.

Related posts:

1. Powerful PHP: Less Known String Manipulation
2. Download Files with Zend Framework
3. Use fopen() to Check File Availability?

var a = 5;
 
function f() { return a; } // returns 5

Thus f will return the value of “a” which equals to 5. You can also change the value of the global variable in the function body.

var a = 5;
function f() { a = 10; return a; }
console.log(a); // equals to 10

Now after we call the function f the value of “a” will equal to 10. This is because we reference the global variable “a” into the function body without using the keyword “var”. This means that if you put the “var” keyword the variable “a” inside the function body is no longer the same variable as the variable defined outside the body. It becames “local” and it’s visible only inside the function.

Objects & JavaScript

Actually in JavaScript functions can be also objects. Any variable defined with the “var” keyword becomes private, because it’s only visible inside the function body, while by using the “this” keyword we can define global variables visible outside the function body. Let’s see na example.

var f = function() 
{
	var a = 10;
	this.b = 5;
}
 
var myfunc = new f();
myfunc.a; // is undefined because a is private
myfunc.b; // equals to 5 because b is public

Public and Private Methods in JavaScript

As you may know in JS you can define functions inside other functions. Actually this is how you can define classes in JavaScript.

var myClass = function() 
{
	var f = function() {
		return 10;
	}
}

But this in fact defines a local (private) function into myClass and we cannot access it from the outside world. Here’s a fully functional class with one public and one private method.

var myClass = function()
{
	// public method
	this.a = function() {
		return 10;
	}
 
	// private method
	var b = function() {
		return 5;
	}
}
 
var c = new myClass();
c.a(); // will return 10
c.b(); // is undefined, because is private

Accessing Private Methods from Public Methods

Easily we can access private methods from public ones.

var myClass = function()
{
	// public method
	this.a = function() {
		return b();
	}
 
	// private method
	var b = function() {
		return 5;
	}
}

However accessing public mtehods in private ones is more difficult. That’s because we cannot use “this” into the private methods, just because “this” refers to the private method
itself and not to the global method, which is “myClass” in our case.

var myClass = function()
{
	// public method
	this.a = function() {
		return 10;
	}
 
	// private method
	var b = function() {
		return this.a(); // this will result in an error
	}
}

Accessing Public Methods from Private Methods

To access public methods in private methods you need to define a variable that points to the global “this” object.

var myClass = function()
{
	var self = this; 
 
	// public method
	this.a = function() {
		return 10;
	}
 
	// private method
	var b = function() {
		return self.a(); // this will return 10
	}
}

This variable gives you the bridge between private methods and global “this” pointer.

Related posts:

1. Object Oriented JavaScript: Inheritance
2. Some Notes on the Object-oriented Model of PHP
3. Quick Look at JavaScript Objects

You should know that in JavaScript you cannot simply write a multilined code chunk, i.e. something like this:

var str = 'hello
world';

This will result in an error, which can be a problem when you deal with large strings. Imagine a string containing some HTML that should be injected via innerHTML. Now one possible solution is to concatenate two or more strings, by splitting the initial string.

var str = 'hello'
        + 'world';

Howerver this solution result in some additional operations like concatenation. It can be very nice if there was something like the PHP multiline string format.

The PHP Example

In PHP you have the same use case with strings. You can have a string concatenated over multiple lines, but you cannot split lines like so:

// the following line is wrong
$str = 'hello
world'; 
 
// a possible solution to the line above is
$str = 'hello'
     . 'world';
// which is very similar to the js solution in the second example
 
// ... but in PHP there is the so called HEREDOC
$str = <<<EOD
hello
world
EOD;

The heredoc gives us the power to write multiline strings.

The JavaScript Trick

Actually in JavaScript there is something that’s exactly what Heredoc is meant to be for PHP. Take a look at the last example:

var text = <>
this <br />
is
my
multi-line
text
</>.toString();
 
document.body.innerHTML = text;

Thus you can write multiline strings in the JavaScript code.

Related posts:

1. Powerful PHP: Less Known String Manipulation
2. JavaScript Flexibility – Regex match()
3. Flexible JavaScript – Splitting Strings