[code]class Test {
private $foo;
protected $bar;
public $bat;

public function __construct() {
$this->foo = "lorem";
$this->bar = "dolor";
$this->bat = "amit";
}
}[/code]

Now create a new instance of the class and cast it to an array.
[code]$test = new Test();
print_r((array)$test);[/code]
The result is as follows:
[code]Array
(
[Testfoo] => lorem
[*bar] => dolor
[bat] => amit
)[/code]
On the surface it appears as if the private property had the class name prepended and the and the protected property had an astrick prepended. Now what happens if we cast this array back to an object?
[code]$test_object = new Test();
$test_array = (array)$test_object;
var_dump((object)$test_array);[/code]

Results in:
[code]object(stdClass)#2 (3) {
["foo":"Test":private]=>
string(5) "lorem"
["bar":protected]=>
string(5) "dolor"
["bat"]=>
string(4) "amit"
}[/code]

How did PHP know the Testfoo key and the *bar key were private and protected? After all, doing the following does not work:
[code]$test_array = array("Testfoo" => "lorem", "*bar" => "dolor", "bat" => "amit");
var_dump((object)$test_array);[/code]

It turns out, PHP stores meta information with the keys in the form of null bytes. Thus
[code]$test_array = array(
"\x00Test\x00foo" => "lorem",
"\x00*\x00bar" => "dolor",
"bat" => "amit"
);
var_dump((object)$test_array);[/code]
Results in the object we expect.
[code]object(stdClass)#2 (3) {
["foo":"Test":private]=>
string(5) "lorem"
["bar":protected]=>
string(5) "dolor"
["bat"]=>
string(4) "amit"
}[/code]

[code]
$a['1st_key'] = "first_key";
$a['k e y'] = "value";
[/code]

Now lets say, for whatever reason, we cast this array to an object:

[code]
$o = (object)$a;
[/code]

This will convert all the array keys into the objects properties. But, how do we access them? Both $o->k e y and $o->1st_key are obvious syntax errors. As a solution, you can use curly braces.

[code]
echo $o->{'1st_key'};
echo $o->{'k e y'};
[/code]

[code]$url = "http://api.twitter.com/1/trends/1.json";
$data = json_decode(file_get_contents($url));
print_r($data);
[/code]

Lets take a look at C – an old and well respected programming language. While it is indeed very fast, the amount of built in functions are minimal. In PHP, if I want to sort an array, I can simply call the sort() function and it will use a fairly optimal and non-intuitive sorting algorithm, quick sort which runs in O(n*log n) time. Where as a crappy C programmer might write a more intuitive sorting algorithm, selection sort, which yields a O(n²) time. Therefore C is a crappy programming language because the programmer wrote a crappier algorithm. Or is it that C is a better programming language because it makes it hard for crappy programmers to write bad code?

What about automobiles? Cars make it really easy for crappy drivers to get into accidents. Thus driving an automobile is a bad mode of transportation.

What it really comes down to, is that people use the best tool for the job.

[code lang="php"] $arr = array(1, 2, 3, 4);
$arr[50] = 50;
[/code]

The first line set the first four indexes to one through four respectively. This creates an array of size four. The second line sets index fifty to the value fifty augmenting the array size by one. Indexes five through forty nine do not exist, and attempting to access a non existing element will only raise an E_Notice level error message. The dynamic allocation of arrays allows programmers to ignore out of bounds exceptions, segmentation faults, and hours of debugging, but it also leads to a slower write time because the memory locations needed to hold the new data is not already allocated.

The Standard PHP Library offers a SplFixedArray object that pre-allocates the necessary memory thereby solving the issue of slower write times.

[code lang="php"]

$array = new SplFixedArray(5);
print_r($array);[/code]
Which results in (a pre-allocated array)

SplFixedArray Object
(
[0] =>
[1] =>
[2] =>
[3] =>
[4] =>
)

Creation Time

To verify this, I ran a test that writes data to an array and an SplFixedArray and measures the time for different amounts of elements.

[code lang="php"]

for($size = 1000; $size < 100000; $size *= 2) {
$f = $size;
for($t = microtime(true), $a = array(), $i = 0; $i < $size; $i++) {
$a[$i] = NULL;
}
$f .= "," . (microtime(true) - $t) . ",";

for($t = microtime(true), $a = new SplFixedArray($size), $i = 0; $i < $size; $i++) {
$a[$i] = NULL;
}
$f .= (microtime(true) - $t) . "\n";
file_put_contents("./data.csv", $f, FILE_APPEND);
}[/code]

Write Time

It is clear that the SplFixedArray has faster a write time. However, there is a significant overhead when an object is created. To test this, I ran the same test but each time I created a new data structure. From the plot, we can see that creating an array has minimal overhead, whereas creating a new SplFixedArray object and allocating the memory takes a significant more amount of time.

[code lang="php"]

$elements = 20;

for($size = 1000; $size < 100000; $size *= 2) {
$f = $size;
for($t = microtime(true), $i = 0; $i < $size; $i++) {
for($j = 0,$a = array(); $j < $elements; $j++ ) {
$a[$i] = NULL;
}
}
$f .= "," . (microtime(true) - $t) . ",";

for($t = microtime(true), $i = 0; $i < $size; $i++) {
for($j = 0, $a = new SplFixedArray($elements); $j < $elements; $j++) {
$a[$j] = NULL;
}
}
$f .= (microtime(true) - $t) . "\n"; file_put_contents("./data.csv", $f, FILE_APPEND);
}
[/code]

Memory Footprint

Lastly I wanted to see how the memory usage differs between each data structure.

[code lang="php"]

for($size = 1000; $size < 100000; $size *= 2) {

$f = $size . ",";

$t = memory_get_usage();
for($a = array(), $i = 0; $i < $size; $i++) {
$a[$i] = NULL;
}

$f .= (memory_get_usage() - $t) . ",";

$t = memory_get_usage();
for($a = new SplFixedArray($size), $i = 0; $i < $size; $i++) {
$a[$i] = NULL;
}

$f .= ($t - memory_get_usage()) . "\n";

file_put_contents("./data.csv", $f, FILE_APPEND);
}

[/code]

Conclusion

The conclusion is one typical of Computer Science, trade-offs. If you are in an environment where you will need a few arrays with predetermined sizes, the SplFixedArray is the best choice. However, if you will be creating numerous arrays, or the size is unknown, then it is probably better to use the native PHP array.

Earlier today @cloud9ide announced a closed beta, with Cr-48 users having preference. I immediately took advantage of the opportunity and signed up. An hour later, my account was approved and I was coding on the cloud.

The layout looks like a typical IDE, it offers syntax highlight for JavaScript, CoffeeScript, CSS, (X)HTML, XML, Python, and PHP. It comes bundled with several different themes, a built in JavaScript debugger, a command line interface, and full support for git. It also appears to work with node.js, a technology I have yet to fully explore.

The motto is “A JavaScript IDE for JavaScripters by JavaScripters,” which is great, but I’m PHPer. I would love to see support for pushing files to my server/private cloud using ftp/sftp rather than my public GitHub repository.

This project looks very promising, and I look forward to watching the continual development of Cloud9IDE. Keep up the good work guys.

[code lang="PHP"]
$months = array("January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December");
for($i = 0; $i < 12; $i++) {
echo "
$months[$i]

";
}
?>

[/code]

Recently, I was asked to help debug the following code:
[code lang="PHP"]
for($i = 0; $i < 12; $i++) {
echo "
" . date("F", mktime(0, 0, 0, $i)) . "

";
}
?>

[/code]

After I flamed this guy for making 24 unnecessary function calls, I noted that arguments may be left out in order from right to left; any arguments thus omitted will be set to the current value according to the local date and time. Thus when this function ran on the 31st of the month, mktime’s 5th argument was 31 which causes an error in the following instance mktime(0, 0, 0, 2, 31) (because February does not have 31 days). The solution was to manually set the 5th parameter to 1.

[code lang="PHP"]
for($i = 0; $i < 12; $i++) {
echo "
" . date("F", mktime(0, 0, 0, $i, 1)) . "

";
}
?>

[/code]

This will generate the correct months, but still does not fix the problem of making 24 unnecessary function calls.

Traditionally, in object oriented PHP, we create a new source file for each class. If we want to create an object of a class, we have to include the php file using require_once (or using a similar function). If we do not include the source file, we will be issued a fatal error.

Fatal error: Class 'User' not found in ...

Lets say we have a User class defined as follows in a User.php file

[code lang="PHP"]

class User {
function __construct() {
echo "Hello, World!";
}
}
?>[/code]

If we want to create a new User object we would include user.php and use the new keyword to instantiate the class.

[code lang="PHP"] require_once('user.php');
$user = new User();[/code]

This is method reasonable for a small number of classes. However, large frameworks can span hundreds of classes, and having to write require_once for each class becomes a huge annoyance. PHP5 introduced an autoload magic method which is automatically called if the class source file cannot be found. The __autoload function takes a single parameter - the class being instantiated. If our class name corresponds to its file name we can do something as simple as:

[code lang="PHP"] function __autoload($class) {
require_once($class . ".php");
}[/code]

Now, each time you instantiate a class, the autoload function will be automatically ran and it will automagically require your class. This is great, however all classes have to be in the same directory as the callee, and any decent framework uses a class hierarchy and spreads classes out into different directories. When I was writing my framework a few years ago, I stumbled upon a pretty awesome use of the autoload function. I think the idea was borrowed from the Zend framework. In a nutshell, the class names would correspond to their location on the file system. For example, the Zend framework has a class named Zend_Controller_Action_HelperBroker, and the class path Zend/Controller/Action/HelperBroker.php. What does this mean? With some additional code in our autoload function, we can convert the class name into its respective path allowing use to create a class hierarchy on our file system.

[code lang="PHP"] function __autoload($class) {
$file = str_replace("_", "/", $class);
require_once($file . ".php");
}[/code]

Now, with the onset of PHP5.3 and the introduction of namespaces, this method has been kind of depreciated for a more pragmatic method. Instead of naming our classes with really long names that correspond to their path, we can use a namespace instead. Thus our autoload function would look like:

[code lang="PHP"] function __autoload($class) {
$file = str_replace("\\", "/", $class);
require_once($file . ".php");
}[/code]

In my next blog, I will talk more about namespaces and give a better demo on how this is used.

[code lang="php"] ini_set('display_errors',1);
error_reporting(E_ALL & E_NOTICE);

function error_handler($errno, $errstr, $errfile, $errline)
{
if (!(error_reporting() & $errno)) {
return;
}
ob_start();
echo $errno . " " . $errstr . "\n\n";
print_r($_SESSION);
echo "\n";
print_r($_GET);
echo "\n";
print_r($_POST);
echo "\n";
print_r($_SERVER);
echo "\n";
debug_print_backtrace();
$body = ob_get_contents();
ob_end_clean();
mail('john@example.com', 'Software Error', $body);
return false;
}
$old = set_error_handler("error_handler");
?>[/code]

[code lang="php"] $a or $b;[/code]
Logically this means TRUE if either $a or $b is TRUE. Normally, we assume PHP will replace the left most operand ($a) with its boolean value, then replace the right most operand ($b) to with its boolean value, and finally evaluate the logical expression using the given operator. However, consider the use of the OR operator in the following context:
[code lang="php"] $result = mysql_query("SELECT * FROM `table`") or die(mysql_error());[/code]
We do this quite often, and we interpret it to mean "if the mysql query fails, then halt operation and output an error message." That is, we interpret it as a conditional expression, and NOT as a logical expression. This is because in PHP uses short-circuit evaluation with the following operators

&&, and, ||, or

With short-circuit evaluation, the second argument is only evaluated if and only if the first argument does not suffice to determine the value of the expression. Thus, when the query is successful, the die() expression is never executed.

Note: For SELECT, SHOW, DESCRIBE, EXPLAIN and other statements returning resultset, mysql_query() returns a resource on success, or FALSE on error. PHP will assumes anything that is not strictly false to be true. Thus a resource is evaluated to be true.