Certification | Zend PHP Certification

Heredoc Syntax

by: admin - May 20th, 2013 Filed under: Certification, Exam, PHP, Strings, Study, Zend Add Comment

Heredoc is a strange but necessary way to create a complex string. The functionality provided is almost identical to double quoted strings except there are no quotes.

The heredoc syntax uses the special operator ‘<<<' followed by a user defined identifier. The same identifier on a new line must be used to close the string followed by an optional semicolon. This identifier is restricted by the same rules as a regular variable name.

$what = "Certification";
echo <<<TEXT
Zend PHP "$what"
TEXT;

This will output ‘Zend PHP “Certification”‘.
Heredoc syntax can not be used for initializing class properties. Since PHP 5.3, this limitation is valid only for heredocs containing variables.

Tags: heredoc string, php heredoc, php programming, php strings, study, zend, zend certification exam, Zend Certified Engineer, Zend Engineer, zend php, zend php certification

Stacks, Queues and Sets

by: admin - December 21st, 2012 Filed under: Arrays, Certification, Exam, PHP, Study, Zend 1 Comment

Arrays can be used in a number of different ways. This can include stacks, queues, and sets. I personally don’t use these functions very often but It can’t hurt to go over them for before taking the Zend Certification exam.

Stacks are a Last in, First out (LIFO) structure which means that the first element you put on the stack is only available when all other elements are removed. Just like a stack of papers. This is acheived by using the array_push and array_pop functions.

Here is a simple little example:

$stack_array = array();
array_push($stack_array,"zend");
//You can add multiple values at once
array_push($stack_array,"php","certification");
$last_in = array_pop($stack_array); //last_in will house "certification"

The array_push function is very similar to “$a[] = $value” and the latter is actually much faster because no function call is made.

Next up is the queue which is a first in first out data structure. Just like a line at a movie theater, the first elements added to the queue get their choice of seats. Queue manipulation is acheived using the array_shift, array_unshift, and any of the functions outlined above.

The array_shift function will remove and return the element from the front of the array and the array_unshift will prepend an element to the front of the array. If both these functions are used together then the array will work like a sort of backwards stack but if array_shift is used with array_push or if array_unshift is used with array_pop then the array will act as a queue.

$stack_array = array(’zend’, ’php’, ’cert’);
$first = array_shift($stack); //$first now houses ‘zend’
array_unshift($stack, ’dont fail’); //adds ‘dont fail’ to the beginning of the array.

There are a few functions that mimic set functionality using php arrays. These are array_diff(), array_intersect, array_intersect_key(), array_intersect_assoc(),array_intersect_ukey(), and array_intersect_uassoc().

The function array_diff() is used to compute the difference between two arrays:

Tags: Array Queues, Array Set, Array Stack, php arrays, php programming, Queues, Sets, Stacks, study, zend, zend certification exam, Zend Certified Engineer, Zend Engineer, zend php, zend php certification

PHP Sorting Functions

by: admin - December 20th, 2012 Filed under: Arrays, Certification, Exam, PHP, Study, Zend 1 Comment

In all the countless hours I’ve spent with php, I’ve maybe used three or four of these sorting functions. I really had no idea that there is a total of eleven functions used for sorting arrays. Anyway, I’m betting that it may be useful to have these memorized before I take the Zend PHP Certification Exam so here is a brief overview of each one.

A lot of the sorting functions have an optional flag that may be used to modify the sorting behavior.
The available flags are:

SORT_REGULAR – compare items normally (don’t change types)
SORT_NUMERIC – compare items numerically
SORT_STRING – compare items as strings
SORT_LOCALE_STRING – compare items as strings, based on the current locale.

All of these functions sort arrays. I don’re really think it’s necessary to type out an example for each one but I will go into greater detail about some. Each function will return a boolean which is true on success and false on failure.

bool sort ( array &$array [, int $sort_flags = SORT_REGULAR ] )

This sort function will arrange the elements from lowest to highest.
Array indices do NOT maintain their correlation with the array elements they are associated with.

bool rsort ( array &$array [, int $sort_flags = SORT_REGULAR ] )

This one will arrange the elements from highest to lowest (Reverse Sort).

bool natsort ( array &$array )

This sorting function will sort the array alphanumerically. This is more “natural” for most people.
Here is a comparison between the regular sort and this natural sort from the
php.net site:

<?php
$array1 = $array2 = array("img12.png", "img10.png", "img2.png", "img1.png");
asort($array1);
echo "Standard sorting\n";
print_r($array1);
natsort($array2);
echo "\nNatural order sorting\n";
print_r($array2);
?>
Which will output:
Standard sorting
Array
(
[3] => img1.png
[1] => img10.png
[0] => img12.png
[2] => img2.png
)
Natural order sorting
Array
(
[3] => img1.png
[2] => img2.png
[1] => img10.png
[0] => img12.png
)

bool natcasesort ( array &$array )

A case insensitive version of natsort.

bool ksort ( array &$array [, int $sort_flags = SORT_REGULAR ] )

Sorts an array by the key. It also maintains the key to data correlations.

bool krsort ( array &$array [, int $sort_flags = SORT_REGULAR ] )

Sorts by key, but in reverse.

bool asort ( array &$array [, int $sort_flags = SORT_REGULAR ] )

This is very similar to the regular sort outlined above except the array indices maintain
their correlation with the array elements they are associated with.

bool arsort ( array &$array [, int $sort_flags = SORT_REGULAR ] )

Similar to the asort but reversed.

bool usort ( array &$array , callback $cmp_function )

This function allows for a custom comparsion function to create different sorting methods. This function should accept only two parameters and return an integer less than, equal to,
or greater than zero if the first argument is considered to be respectively less than, equal to, or greater than the second. Here’s an example:

<?php
function cmp($a, $b)
{
if ($a == $b) {
return 0;
}
return ($a < $b) ? -1 : 1;
}
$a = array(3, 2, 5, 6, 1);
usort($a, "cmp");
foreach ($a as $key => $value) {
echo "$key: $value\n";
}
?>

bool uasort ( array &$array , callback $cmp_function )

This is similar to usort except the array indices maintain their
correlation with the array elements they are associated with.

bool uksort ( array &$array , callback $cmp_function )

This last sort function works similar to the previous two where you can define a custom comparison function. The difference is that this one works on the keys and it also maintains the correlation with the elements.

There is also a nice comparison of all these functions at php.net

Tags: php arrays, php programming, php sort, php sorting, print, sorting arrays, study, variable length arguments, zend, zend certification exam, Zend Certified Engineer, Zend Engineer, zend php, zend php certification

PHP Array Cursors

by: admin - December 15th, 2012 Filed under: Arrays, Certification, Exam, PHP, Study, Zend 3 Comments

I don’t recommend ever using these functions because a foreach loop is so much simpler and shorter. The only reason I’m writing about these is bacause I have almost never used them and they may just be on the Zend PHP Certification exam.

There are a number of functions designed specifically for manipulating array pointers. Most examples that I’ve seen use these functions during some sort of array iteration. When starting an iteration over an array, the first step is usually to reset the pointer to its initial position using the reset() function. After that, moving forward or backwards by one position is done using prev() and next(). At any given point, we can access the value of the current element using current() and its key using key(). Here’s a simple example:

$array = array(’foo’ => ’bar’, ’baz’, ’bat’ => 2);
function displayArray($array) {
reset($array);
while (key($array) !== null) {
echo key($array) .": " .current($array) . PHP_EOL;
next($array);
}
}

The displayArray function above will display all the values in an array. Reset() is called first to return the internal array pointer to the first element. Next, using a while loop, the current key and value is displayed using the key() and current() functions. Finally, the array pointer is advanced, using next().

Since you can iterate back-and-forth within an array by using its pointer, you could—in theory—start your iteration from the last element (using the end() function to reset the pointer to the bottom of the array) and then making your way to the beginning:

$a = array (1, 2, 3);
end($a);
while (key ($array) !== null) {
echo key($array) .": " .current($array) . PHP_EOL;
prev($array);
}

So I guess that last example may be useful…but it’s still probably easier to reverse the entire array and use a foreach.

Anyway, if these are on the Zend PHP Certification exam, I shouldn’t have a problem.

Tags: php array cursors, php array pointers, php arrays, php programming, print, study, variable length arguments, zend, zend certification exam, Zend Certified Engineer, Zend Engineer, zend php, zend php certification

Comparing Arrays in PHP

by: admin - December 13th, 2012 Filed under: Arrays, Certification, Exam, PHP, Study, Zend 2 Comments

Array-to-array comparison is a relatively rare occurrence in the real world of PHP (at least for me), but it can be performed using a set of operators. Like for other types, the equivalence and identity operators can be used for this purpose:

$a = array (1, 2, 3);
$b = array (1 => 2, 2 => 3, 0 => 1);
$c = array (’a’ => 1, ’b’ => 2, ’c’ => 3);
var_dump ($a == $b); // True
var_dump ($a === $b); // False
var_dump ($a == $c); // False
var_dump ($a === $c); // False

As you can see, the equivalence operator == returns true if both arrays have the same number of elements with the same values and keys, regardless of their order. The identity operator ===, on the other hand, returns true only if the array contains the same key/value pairs in the same order.

Similarly, the inequality and non-identity operators can determine whether two arrays are different:

$a = array (1, 2, 3);
$b = array (1 => 2, 2 => 3, 0 => 1);
var_dump ($a != $b); // False
var_dump ($a !== $b); // True

Once again, the inequality operator only ensures that both arrays contain the same elements with the same keys, whereas the non-identity operator also verifies their position.

Apparently arrays are covered heavily on the Zend PHP Certification Exam so the next few posts will cover arrays.

Tags: php, php array comparison, php arrays, php programming, print, study, variable length arguments, zend, zend certification exam, Zend Certified Engineer, Zend Engineer, zend php, zend php certification

Default Values for By-Reference Parameters

by: admin - December 13th, 2012 Filed under: Certification, Exam, PHP, Study, Zend Add Comment

Unlike PHP 4, PHP 5 allows default values to be specified for parameters even when they are declared as by-reference:

function command_exists($command, &$output = null) {
$output = ‘whereis $cmd‘;
if (strpos($output, DIRECTORY_SEPARATOR) !== false) {
return true;
} else {
return false;
}
}

In the example above, the $output parameter is completely optional—if a variable is not passed in, a new one will be created within the context of command_exists() and, of
course, destroyed when the function returns.

Tags: by-reference default values, php, php programming, print, study, variable length arguments, zend, zend certification exam, Zend Certified Engineer, Zend Engineer, zend php, zend php certification

Function Name Case Sensitivity and Variable-Length Argument Lists

by: admin - December 11th, 2012 Filed under: Certification, Exam, PHP, Study, Zend Add Comment

After spending years developing software, I’ve always assumed that most real programming languages are extremely case sensitive in almost every aspect. It turns out that PHP function names are not case-sensitive. I was extremely surprised to read this and I definitely don’t agree with it. Variables in PHP are case sensitive so it could be worse.

It was interesting to find out that PHP function parameters can be defined on the fly. PHP provides three built-in functions to handle variable-length argument lists: func_num_args(), func_get_arg() and func_get_args().

Here’s an example of how they’re used:

function hello()
{
if (func_num_args() > 0) {
$arg = func_get_arg(0); // The first argument is at position 0
echo "Hello $arg";
} else {
echo "Hello World";
}
}
hello("Reader"); // Displays "Hello Reader"
hello(); // Displays "Hello World"

The variable-length arguments will actually be useful instead of something that I’m just learning to get designated as a Zend Certified Engineer.

Tags: exam, function name case sensitivity, php, php programming, print, study, variable length arguments, zend, zend certification exam, Zend Certified Engineer, Zend Engineer, zend php, zend php certification

Backticks, EOL, and Break

by: admin - December 11th, 2012 Filed under: Certification, Exam, PHP, Study, Zend 2 Comments

While studying up for the Zend PHP Certification exam I came across a few more elements that I’ve never used before.

Firstly, there is a backtick operator. This makes it possible to execute a shell command and retrieve
its output. For example,the following will cause the output of the UNIX ls command to be stored inside $a:

$a = ‘ls -l‘;

Secondly, PHP has an end of line constant. I’ve never seen PHP_EOL before but it seems to work similar to “\n”.
I don’t think I will ever use this due to the length when compared with “\n”.

Finally, a bit about the break function. I had no idea that both the break and continue statements take a
paramenter which can instruct them to break out of multiple loops. I felt a bit silly that I didn’t already know this.
Here is a simple example:

for ($i = 0; $i < 10; $i++) {
for ($j = 0; $j < 3; $j++) {
if (($j + $i) % 5 == 0) {
break 2; // Exit from this loop and the next one.
}
}
}

There seems to be a lot that I’m going to have to study up on before I can become a Zend Certified Engineer.

Tags: backticks, break, exam, php, php programming, PHP_EOL, print, study, zend, zend certification exam, Zend Certified Engineer, Zend Engineer, zend php, zend php certification

PHP References

by: admin - December 8th, 2012 Filed under: Certification, Exam, PHP, Study, Zend Add Comment

References in PHP are a way to access the content in a variable by different names. They are not at all like pointers in C. For instance, you cannot perform pointer arithmetic using them and they are not actual memory addresses.

I’ve found that references in PHP are fairly rare, but in the few cases I’ve seen them in the wild, I’ve always assumed that they were used for their faster performance but it turns out that by-reference activity is often slower than its by-value counterpart, because PHP uses a clever “deferred-copy” mechanism that actually optimizes by-value assignments.

Here is a simple php reference example:

$a = 10;
$b = &$a; // by reference
$b = 20;
echo $a; // Outputs 20

However PHP references are useful when used as a return value for a function. If they are used on something like
a database resource then you probably don’t want to be returning a copy:

function &query($sql)
{
$result = mysql_query($sql);
return $result;
}

References can also be useful as a function parameter to pass by reference instead of by copy. So any changes that are made to the parameter survive the function.

One thing to watch out for when using references in a foreach loop is to make sure that you unset the reference. Otherwise you may inadvertently overwrite the last entry in the array.

foreach($data_array as &$value)
{
do_something_with_value();
}
unset($value);

I definitely expext at least a few questions to touch on references on the Zend PHP Certification Exam.

Tags: exam, php, php programming, print, study, zend, zend certification exam, Zend Certified Engineer, Zend Engineer, zend php, zend php certification

Variable Variables and Variable Functions in PHP

by: admin - December 7th, 2012 Filed under: Certification, Exam, PHP, Study, Zend 3 Comments

Variable Variables and Function Variables in PHP

PHP variable variables are almost never used because they greatly obfuscate any application
that you’re trying to write and can very easily inject a number of bugs into a script.
That being said, this interesting little feature just may be on the Zend PHP Certification Exam.

Variable variables use a variable as the name of another variable.
You may think that these are kind of like a pointer in other languages and I guess they are
except you can’t do any of the fun pointer arithmetic. Here’s a simple example of using the
value of another variable for a variable’s name.

$name = ’foo’;
$$name = ’bar’;
echo $foo;
// Displays ’bar’

This could also be used to have a number as a variable name (which normally isn’t allowed):

$name = ’123’;
$$name = ’456’;
echo ${’123’};

While on the topic of PHP pointer like stuff, it is also possible to use a variable as a function pointer
like in the following example.

function myFunc() {
echo ’myFunc!’;
}
$f = ’myFunc’;
$f(); // will call myFunc();

I don’t think I’ll be using any of these features in my applications any time soon but hopefully I
won’t be clueless when taking the Zend PHP Certification Exam to become a Certified Zend Engineer.

Tags: exam, php, php programming, php variable functions, php variable variables, print, study, zend, zend certification exam, Zend Certified Engineer, Zend Engineer, zend php, zend php certification

<< previous entries

Zend PHP Certification