[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 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.

[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.

1. First you need to acquire a list of SMS gateways you are going to support. For an extensive list, check out Wikipedias List of SMS Gateways. For this tutorial, I will only be using AT&T Wireless (number@txt.att.net) and Verison (number@vtext.com).

2. Create a simple HTML form.
[code lang="html"]

[/code]

3. Add the necessary PHP code to send the email
[code lang="PHP"]

if(!empty($_POST['number'])) {
mail($_POST['number'] . $_POST['provider'], $_POST['subject'], $_POST['message']);
}
?>

[/code]

You will want to do some better error checking and validation, but thats it!

[code lang="PHP"]

/* create a test image */
$im = @imagecreate(100, 20) or die("Cannot Initialize new GD image stream");
$background_color = imagecolorallocate($im, 255, 255, 255);
$text_color = imagecolorallocate($im, 0, 0, 0);
imagestring($im, 1, 5, 5, "Hello, World!", $text_color);

/***
* Assumptions:
* A monochrome image where characters are black
* A single character is connected
* Characters are disjointed by white space
*/

$width = imagesx($im);
$height = imagesy($im);

/***
* Notes:
* The smaller the sample size the more accurate it will be,
* however, it will take longer. Larger images can use a larger
* sample size wihtout compromizing much accuracy.
*/
$x_sample = 1;
$y_sample = 1;

$last = 0;
for($i = 0; $i < $width; $i++) {
$col = array();

for($j = 0; $j < $height; $j++) {
$col[$j] = imagecolorat($im, $i, $j);
}

if(($current = array_sum($col)) > 0) {
if($last == 0) {
$l = 0;
}

for($k = 0; $k < $height; $k++) {
if(($l % $x_sample) == 0) {
if(($k % $y_sample) == 0) {
$sample .= $col[$k];
}
}
}

$l++;
$last = $current;
} else {
$last = 0;
}

if(!empty($sample) && $last == 0) {
echo $sample . "\n";
$sample = "";
}
}
?>[/code]

Output (each line represents a character)

for($c1 = ($x-abs($px)); $c1 <= ($x+abs($px)); $c1++)
for($c2 = ($y-abs($px)); $c2 <= ($y+abs($px)); $c2++)
$bg = imagettftext($image, $size, $angle, $c1, $c2, $strokecolor, $fontfile, $text);

return imagettftext($image, $size, $angle, $x, $y, $textcolor, $fontfile, $text);
} [/code]

[code lang="PHP"] $img = imagecreatefrompng("/home/john/Desktop/test.png");
$font_color = imagecolorallocate($img, 0, 0, 0);
$stroke_color = imagecolorallocate($img, 255, 0, 0);
imagettfstroketext($img, 10, 0, 10, 50, $font_color, $stroke_color, "abstract.ttf", "Hello, World!", 2);
?>[/code]

for($i=0; $i<$length; $i++){
$string .= $pattern{rand(0,61)};
}

return $string;
}

function captcha() {
header("Content-type: image/png");
$im = @imagecreate(100, 50) or die("Cannot Initialize new GD image stream");
$background_color = imagecolorallocate($im, 0, 0, 0);
$text_color = imagecolorallocate($im, 255, 0, 0);
$string = randomString();
imagestring($im, 10, 5, 5, $string, $text_color);
imagepng($im);
imagedestroy($im);
}

captcha();
?>[/code]

[code]
$a = 0;
$b = "Hooray for PHP logic and dynamic type casting?";
var_dump(((FALSE == $a) == ($a == $b)) == ($b == TRUE));
var_dump((((0 == $a) == ($a == $b)) == ($b == TRUE) == (TRUE == 1));[/code]
Returns
bool(true)
bool(true)

Q.E.D

Note: I am comparing values not types. That being said, forgive me when I flame you for using PHP inappropriately. A string is NOT an integer and an integer is NOT a boolean. They should not be used as such.

1. At your command prompt, run tasksel as root.

john@earth:~$ sudo tasksel

2. Select LAMP server

3. Continue the installation by following the prompts.

It works!

One tool I have difficulty living without is phpMyAdmin. From the command prompt type

sudo apt-get install phpmyadmin

Continue the installation by following the prompts. If you are using a version of Ubuntu older than 9.04 (Jaunty) you will need to add the following line to /etc/apache2/apache2.conf Continue the installation by following the prompts. Version 9.04 does this automatically. You will be able to access phpMyAdmin by browsing directly to http:///phpmyadmin