New tutorial series on Python

Basic class definitions begin with the keyword class, followed by a class name, followed by a pair of curly braces which enclose the definitions of the properties and methods belonging to the class.

The class name can be any valid label which is not a PHP reserved word. A valid class name starts with a letter or underscore, followed by any number of letters, numbers, or underscores. As a regular expression, it would be expressed thus: ^[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*$.

A class may contain its own constants, variables (called “properties”), and functions (called “methods”).

Example: Simple Class definition
class SimpleClass { // property declaration public $var = 'a default value';

// method declaration public function displayVar() { echo $this->var; } }

The pseudo-variable $this is available when a method is called from within an object context. $this is a reference to the calling object (usually the object to which the method belongs, but possibly another object, if the method is called statically from the context of a secondary object).

Example: Some examples of the $this pseudo-variable
class A { function foo() { if (isset($this)) { echo '$this is defined ('; echo get_class($this); echo ")\n"; } else { echo "\$this is not defined.\n"; } } }


class B

{

    function bar()

    {

        // Note: the next line will issue a warning if E_STRICT is enabled.

        A::foo();

    }

}
$a = new A();

$a->foo();
// Note: the next line will issue a warning if E_STRICT is enabled.

A::foo();

$b = new B();

$b->bar();

// Note: the next line will issue a warning if E_STRICT is enabled. B::bar();

The above example will output:

$this is defined (A)
$this is not defined.
$this is defined (B)
$this is not defined.

new

To create an instance of a class, the new keyword must be used. An object will always be created unless the object has a constructor defined that throws an exception on error. Classes should be defined before instantiation (and in some cases this is a requirement).

If a string containing the name of a class is used with new, a new instance of that class will be created. If the class is in a namespace, its fully qualified name must be used when doing this.

Example: Creating an instance
$instance = new SimpleClass();

// This can also be done with a variable: $className = 'Foo'; $instance = new $className(); // Foo()

PHP 5.3.0 introduced a couple of new ways to create instances of an object:

Example: Creating new objects

extends

A class can inherit the methods and properties of another class by using the keyword extends in the class declaration. It is not possible to extend multiple classes; a class can only inherit from one base class.

The inherited methods and properties can be overridden by redeclaring them with the same name defined in the parent class. However, if the parent class has defined a method as final, that method may not be overridden. It is possible to access the overridden methods or static properties by referencing them with parent::.

When overriding methods, the parameter signature should remain the same or PHP will generate an E_STRICT level error. This does not apply to the constructor, which allows overriding with different parameters.

Example: Simple Class Inheritance
class ExtendClass extends SimpleClass { // Redefine the parent method function displayVar() { echo "Extending class\n"; parent::displayVar(); } }

$extended = new ExtendClass(); $extended->displayVar();

The above example will output:

Extending class
a default value

::class

Since PHP 5.5, the class keyword is also used for class name resolution. You can get a string containing the fully qualified name of the ClassName class by using ClassName::class. This is particularly useful with namespaced classes.

Example: Class name resolution
namespace NS { class ClassName { }

echo ClassName::class; }

The above example will output:

NS\ClassName

Properties

Class member variables are called “properties”. You may also see them referred to using other terms such as “attributes” or “fields”, but for the purposes of this reference we will use “properties”. They are defined by using one of the keywords public, protected, or private, followed by a normal variable declaration. This declaration may include an initialization, but this initialization must be a constant value–that is, it must be able to be evaluated at compile time and must not depend on run-time information in order to be evaluated.

See Visibility for more information on the meanings of public, protected, and private.

Within class methods non-static properties may be accessed by using -> (Object Operator): $this->property (where property is the name of the property). Static properties are accessed by using the :: (Double Colon): self::$property. See Static Keyword for more information on the difference between static and non-static properties.

The pseudo-variable $this is available inside any class method when that method is called from within an object context. $this is a reference to the calling object (usually the object to which the method belongs, but possibly another object, if the method is called statically from the context of a secondary object).

Example: property declarations
class SimpleClass { // invalid property declarations: public $var1 = 'hello ' . 'world'; public $var2 = <<<EOD hello world EOD; public $var3 = 1+2; public $var4 = self::myStaticMethod(); public $var5 = $myVar;


   // valid property declarations:

   public $var6 = myConstant;

   public $var7 = array(true, false);

// This is allowed only in PHP 5.3.0 and later. public $var8 = <<<'EOD' hello world EOD; }

Class Constants

It is possible to define constant values on a per-class basis remaining the same and unchangeable. Constants differ from normal variables in that you don’t use the $ symbol to declare or use them.

The value must be a constant expression, not (for example) a variable, a property, a result of a mathematical operation, or a function call.

It’s also possible for interfaces to have constants. Look at the interface documentation for examples.

As of PHP 5.3.0, it’s possible to reference the class using a variable. The variable’s value can not be a keyword (e.g. self, parent and static).

Example: Defining and using a constant
class MyClass { const CONSTANT = 'constant value';


    function showConstant() {

        echo  self::CONSTANT . "\n";

    }

}
echo MyClass::CONSTANT . "\n";
$classname = "MyClass";

echo $classname::CONSTANT . "\n"; // As of PHP 5.3.0
$class = new MyClass();

$class->showConstant();
echo $class::CONSTANT."\n"; // As of PHP 5.3.0

Autoloading Classes

Many developers writing object-oriented applications create one PHP source file per class definition. One of the biggest annoyances is having to write a long list of needed includes at the beginning of each script (one for each class).

In PHP 5, this is no longer necessary. You may define an __autoload() function which is automatically called in case you are trying to use a class/interface which hasn’t been defined yet. By calling this function the scripting engine is given a last chance to load the class before PHP fails with an error.

Tip spl_autoload_register() provides a more flexible alternative for autoloading classes. For this reason, using __autoload() is discouraged and may be deprecated or removed in the future.

Note: Prior to 5.3.0, exceptions thrown in the __autoload function could not be caught in the catch block and would result in a fatal error. From 5.3.0+ exceptions thrown in the __autoload function can be caught in the catch block, with 1 provision. If throwing a custom exception, then the custom exception class must be available. The __autoload function may be used recursively to autoload the custom exception class.

Note: Autoloading is not available if using PHP in CLI interactive mode.

Note: If the class name is used e.g. in call_user_func() then it can contain some dangerous characters such as ../. It is recommended to not use the user-input in such functions or at least verify the input in __autoload().

Example: Autoload example

This example attempts to load the classes MyClass1 and MyClass2 from the files MyClass1.php and MyClass2.php respectively.
function __autoload($class_name) { include $class_name . '.php'; }

$obj = new MyClass1(); $obj2 = new MyClass2();

Example: Autoload other example

This example attempts to load the interface ITest.


function __autoload($name) {

    var_dump($name);

}
class Foo implements ITest {

}
/*

string(5) "ITest"

Fatal error: Interface 'ITest' not found in ... */

Constructors and Destructors
Constructor

void __construct ([ mixed $args [, $... ]] )

PHP 5 allows developers to declare constructor methods for classes. Classes which have a constructor method call this method on each newly-created object, so it is suitable for any initialization that the object may need before it is used.

Note: Parent constructors are not called implicitly if the child class defines a constructor. In order to run a parent constructor, a call to parent::__construct() within the child constructor is required. If the child does not define a constructor then it may be inherited from the parent class just like a normal class method (if it was not declared as private).

Example: using new unified constructors
class BaseClass { function __construct() { print "In BaseClass constructor\n"; } }


class SubClass extends BaseClass {

   function __construct() {

       parent::__construct();

       print "In SubClass constructor\n";

   }

}
class OtherSubClass extends BaseClass {

    // inherits BaseClass's constructor

}
// In BaseClass constructor

$obj = new BaseClass();
// In BaseClass constructor

// In SubClass constructor

$obj = new SubClass();

// In BaseClass constructor $obj = new OtherSubClass();

For backwards compatibility, if PHP 5 cannot find a __construct() function for a given class, and the class did not inherit one from a parent class, it will search for the old-style constructor function, by the name of the class. Effectively, it means that the only case that would have compatibility issues is if the class had a method named __construct() which was used for different semantics.

Unlike with other methods, PHP will not generate an E_STRICT level error message when __construct() is overridden with different parameters than the parent __construct() method has.

As of PHP 5.3.3, methods with the same name as the last element of a namespaced class name will no longer be treated as constructor. This change doesn’t affect non-namespaced classes.

Example: Constructors in namespaced classes
namespace Foo; class Bar { public function Bar() { // treated as constructor in PHP 5.3.0-5.3.2 // treated as regular method as of PHP 5.3.3 } }

Like constructors, parent destructors will not be called implicitly by the engine. In order to run a parent destructor, one would have to explicitly call parent::__destruct() in the destructor body. Also like constructors, a child class may inherit the parent’s destructor if it does not implement one itself.

The destructor will be called even if script execution is stopped using exit(). Calling exit() in a destructor will prevent the remaining shutdown routines from executing.

Note: Destructors called during the script shutdown have HTTP headers already sent. The working directory in the script shutdown phase can be different with some SAPIs (e.g. Apache).

Note: Attempting to throw an exception from a destructor (called in the time of script termination) causes a fatal error.

Visibility
The visibility of a property or method can be defined by prefixing the declaration with the keywords public, protected or private. Class members declared public can be accessed everywhere. Members declared protected can be accessed only within the class itself and by inherited and parent classes. Members declared as private may only be accessed by the class that defines the member.

Property Visibility

Class properties must be defined as public, private, or protected. If declared using var, the property will be defined as public.

Example: Property declaration
/** * Define MyClass */ class MyClass { public $public = 'Public'; protected $protected = 'Protected'; private $private = 'Private';


    function printHello()

    {

        echo $this->public;

        echo $this->protected;

        echo $this->private;

    }

}
$obj = new MyClass();

echo $obj->public; // Works

echo $obj->protected; // Fatal Error

echo $obj->private; // Fatal Error

$obj->printHello(); // Shows Public, Protected and Private
/**

 * Define MyClass2

 */

class MyClass2 extends MyClass

{

    // We can redeclare the public and protected method, but not private

    protected $protected = 'Protected2';
    function printHello()

    {

        echo $this->public;

        echo $this->protected;

        echo $this->private;

    }

}

$obj2 = new MyClass2(); echo $obj2->public; // Works echo $obj2->protected; // Fatal Error echo $obj2->private; // Undefined $obj2->printHello(); // Shows Public, Protected2, Undefined

Note: The PHP 4 method of declaring a variable with the var keyword is still supported for compatibility reasons (as a synonym for the public keyword). In PHP 5 before 5.1.3, its usage would generate an E_STRICT warning.

Method Visibility

Class methods may be defined as public, private, or protected. Methods declared without any explicit visibility keyword are defined as public.

Example: Method Declaration
/** * Define MyClass */ class MyClass { // Declare a public constructor public function __construct() { }


    // Declare a public method

    public function MyPublic() { }
    // Declare a protected method

    protected function MyProtected() { }
    // Declare a private method

    private function MyPrivate() { }
    // This is public

    function Foo()

    {

        $this->MyPublic();

        $this->MyProtected();

        $this->MyPrivate();

    }

}
$myclass = new MyClass;

$myclass->MyPublic(); // Works

$myclass->MyProtected(); // Fatal Error

$myclass->MyPrivate(); // Fatal Error

$myclass->Foo(); // Public, Protected and Private work
/**

 * Define MyClass2

 */

class MyClass2 extends MyClass

{

    // This is public

    function Foo2()

    {

        $this->MyPublic();

        $this->MyProtected();

        $this->MyPrivate(); // Fatal Error

    }

}
$myclass2 = new MyClass2;

$myclass2->MyPublic(); // Works

$myclass2->Foo2(); // Public and Protected work, not Private
class Bar

{

    public function test() {

        $this->testPrivate();

        $this->testPublic();

    }
    public function testPublic() {

        echo "Bar::testPublic\n";

    }
    private function testPrivate() {

        echo "Bar::testPrivate\n";

    }

}
class Foo extends Bar

{

    public function testPublic() {

        echo "Foo::testPublic\n";

    }
    private function testPrivate() {

        echo "Foo::testPrivate\n";

    }

}

$myFoo = new foo(); $myFoo->test(); // Bar::testPrivate // Foo::testPublic

Visibility from other objects

Objects of the same type will have access to each others private and protected members even though they are not the same instances. This is because the implementation specific details are already known when inside those objects.

Example: Accessing private members of the same object type
class Test { private $foo;


    public function __construct($foo)

    {

        $this->foo = $foo;

    }
    private function bar()

    {

        echo 'Accessed the private method.';

    }
    public function baz(Test $other)

    {

        // We can change the private property:

        $other->foo = 'hello';

        var_dump($other->foo);
        // We can also call the private method:

        $other->bar();

    }

}
$test = new Test('test');

$test->baz(new Test('other'));

The above example will output:

string(5) “hello”
Accessed the private method.

Object Inheritance

Inheritance is a well-established programming principle, and PHP makes use of this principle in its object model. This principle will affect the way many classes and objects relate to one another.

For example, when you extend a class, the subclass inherits all of the public and protected methods from the parent class. Unless a class overrides those methods, they will retain their original functionality.

This is useful for defining and abstracting functionality, and permits the implementation of additional functionality in similar objects without the need to reimplement all of the shared functionality.

Note: Unless autoloading is used, then classes must be defined before they are used. If a class extends another, then the parent class must be declared before the child class structure. This rule applies to classes that inherit other classes and interfaces.

Example: Inheritance Example
class foo { public function printItem($string) { echo 'Foo: ' . $string . PHP_EOL; }


    public function printPHP()

    {

        echo 'PHP is great.' . PHP_EOL;

    }

}
class bar extends foo

{

    public function printItem($string)

    {

        echo 'Bar: ' . $string . PHP_EOL;

    }

}

$foo = new foo(); $bar = new bar(); $foo->printItem('baz'); // Output: 'Foo: baz' $foo->printPHP(); // Output: 'PHP is great' $bar->printItem('baz'); // Output: 'Bar: baz' $bar->printPHP(); // Output: 'PHP is great'

Scope Resolution Operator (::)

The Scope Resolution Operator (also called Paamayim Nekudotayim) or in simpler terms, the double colon, is a token that allows access to static, constant, and overridden properties or methods of a class.

When referencing these items from outside the class definition, use the name of the class.

As of PHP 5.3.0, it’s possible to reference the class using a variable. The variable’s value can not be a keyword (e.g. self, parent and static).

Paamayim Nekudotayim would, at first, seem like a strange choice for naming a double-colon. However, while writing the Zend Engine 0.5 (which powers PHP 3), that’s what the Zend team decided to call it. It actually does mean double-colon – in Hebrew!

Example: :: from outside the class definition
class MyClass { const CONST_VALUE = 'A constant value'; }


$classname = 'MyClass';

echo $classname::CONST_VALUE; // As of PHP 5.3.0

echo MyClass::CONST_VALUE;

Three special keywords self, parent and static are used to access properties or methods from inside the class definition.

Example: :: from inside the class definition
class OtherClass extends MyClass { public static $my_static = 'static var';


    public static function doubleColon() {

        echo parent::CONST_VALUE . "\n";

        echo self::$my_static . "\n";

    }

}
$classname = 'OtherClass';

echo $classname::doubleColon(); // As of PHP 5.3.0

OtherClass::doubleColon();

When an extending class overrides the parents definition of a method, PHP will not call the parent’s method. It’s up to the extended class on whether or not the parent’s method is called. This also applies to Constructors and Destructors, Overloading, and Magic method definitions.

Example: Calling a parent’s method
class MyClass { protected function myFunc() { echo "MyClass::myFunc()\n"; } }


class OtherClass extends MyClass

{

    // Override parent's definition

    public function myFunc()

    {

        // But still call the parent function

        parent::myFunc();

        echo "OtherClass::myFunc()\n";

    }

}

$class = new OtherClass(); $class->myFunc();

Static Keyword

Declaring class properties or methods as static makes them accessible without needing an instantiation of the class. A property declared as static can not be accessed with an instantiated class object (though a static method can).

For compatibility with PHP 4, if no visibility declaration is used, then the property or method will be treated as if it was declared as public.

Because static methods are callable without an instance of the object created, the pseudo-variable $this is not available inside the method declared as static.

Static properties cannot be accessed through the object using the arrow operator ->.

Calling non-static methods statically generates an E_STRICT level warning.

Like any other PHP static variable, static properties may only be initialized using a literal or constant; expressions are not allowed. So while you may initialize a static property to an integer or array (for instance), you may not initialize it to another variable, to a function return value, or to an object.

As of PHP 5.3.0, it’s possible to reference the class using a variable. The variable’s value can not be a keyword (e.g. self, parent and static).

Example: Static property example
class Foo { public static $my_static = 'foo';


    public function staticValue() {

        return self::$my_static;

    }

}
class Bar extends Foo

{

    public function fooStatic() {

        return parent::$my_static;

    }

}
print Foo::$my_static . "\n";
$foo = new Foo();

print $foo->staticValue() . "\n";

print $foo->my_static . "\n";      // Undefined "Property" my_static 
print $foo::$my_static . "\n";

$classname = 'Foo';

print $classname::$my_static . "\n"; // As of PHP 5.3.0

print Bar::$my_static . "\n"; $bar = new Bar(); print $bar->fooStatic() . "\n";

Example #2 Static method example
class Foo { public static function aStaticMethod() { // ... } }

Foo::aStaticMethod(); $classname = 'Foo'; $classname::aStaticMethod(); // As of PHP 5.3.0

Zend PHP Exam Preparation Part 6

15 Wednesday Jan 2014

Posted by Shahjalal in Zend PHP Certification

≈ Leave a comment

Tags

Zend PHP exam

Functions

User-defined functions

A function may be defined using syntax such as the following:

Example: Pseudo code to demonstrate function uses
function foo($arg_1, $arg_2, /* ..., */ $arg_n) { echo "Example function.\n"; return $retval; }

Any valid PHP code may appear inside a function, even other functions and class definitions.

Function names follow the same rules as other labels in PHP. A valid function name starts with a letter or underscore, followed by any number of letters, numbers, or underscores. As a regular expression, it would be expressed thus: [a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*.
Tip

Zend PHP Exam Preparation Part 5

15 Wednesday Jan 2014

Posted by Shahjalal in Zend PHP Certification

≈ Leave a comment

Tags

Zend PHP exam

Control Structures
if

(PHP 4, PHP 5)

The if construct is one of the most important features of many languages, PHP included. It allows for conditional execution of code fragments. PHP features an if structure that is similar to that of C:

if (expr) statement

As described in the section about expressions, expression is evaluated to its Boolean value. If expression evaluates to TRUE, PHP will execute statement, and if it evaluates to FALSE – it’ll ignore it.

else
(PHP 4, PHP 5)

Often you’d want to execute a statement if a certain condition is met, and a different statement if the condition is not met. This is what else is for. else extends an if statement to execute a statement in case the expression in the if statement evaluates to FALSE.

elseif/else if
(PHP 4, PHP 5)

elseif, as its name suggests, is a combination of if and else. Like else, it extends an if statement to execute a different statement in case the original if expression evaluates to FALSE. However, unlike else, it will execute that alternative expression only if the elseif conditional expression evaluates to TRUE.

Note: Note that elseif and else if will only be considered exactly the same when using curly brackets as in the above example. When using a colon to define your if/elseif conditions, you must not separate else if into two words, or PHP will fail with a parse error.

Alternative syntax for control structures
(PHP 4, PHP 5)

PHP offers an alternative syntax for some of its control structures; namely, if, while, for, foreach, and switch. In each case, the basic form of the alternate syntax is to change the opening brace to a colon (:) and the closing brace to endif;, endwhile;, endfor;, endforeach;, or endswitch;, respectively.

In the above example, the HTML block “A is equal to 5” is nested within an if statement written in the alternative syntax. The HTML block would be displayed only if $a is equal to 5.

The alternative syntax applies to else and elseif as well. The following is an if structure with elseif and else in the alternative format:

if ($a == 5): echo "a equals 5"; echo "..."; elseif ($a == 6): echo "a equals 6"; echo "!!!"; else: echo "a is neither 5 nor 6"; endif;

Note: Mixing syntaxes in the same control block is not supported.

while
(PHP 4, PHP 5)

while loops are the simplest type of loop in PHP. They behave just like their C counterparts. The basic form of a while statement is:

while (expr)
statement

The meaning of a while statement is simple. It tells PHP to execute the nested statement(s) repeatedly, as long as the while expression evaluates to TRUE. The value of the expression is checked each time at the beginning of the loop, so even if this value changes during the execution of the nested statement(s), execution will not stop until the end of the iteration (each time PHP runs the statements in the loop is one iteration). Sometimes, if the while expression evaluates to FALSE from the very beginning, the nested statement(s) won’t even be run once.

Like with the if statement, you can group multiple statements within the same while loop by surrounding a group of statements with curly braces, or by using the alternate syntax:

while (expr):
statement
…
endwhile;

do-while
(PHP 4, PHP 5)

do-while loops are very similar to while loops, except the truth expression is checked at the end of each iteration instead of in the beginning. The main difference from regular while loops is that the first iteration of a do-while loop is guaranteed to run (the truth expression is only checked at the end of the iteration), whereas it may not necessarily run with a regular while loop (the truth expression is checked at the beginning of each iteration, if it evaluates to FALSE right from the beginning, the loop execution would end immediately).

Advanced C users may be familiar with a different usage of the do-while loop, to allow stopping execution in the middle of code blocks, by encapsulating them with do-while (0), and using the break statement. The following code fragment demonstrates this:
do { if ($i < 5) { echo "i is not big enough"; break; } $i *= $factor; if ($i < $minimum_limit) { break; } echo "i is ok";


    /* process i */

} while (0);

Don’t worry if you don’t understand this right away or at all. You can code scripts and even powerful scripts without using this ‘feature’. Since PHP 5.3.0, it is possible to use goto operator instead of this hack.

for

(PHP 4, PHP 5)

for loops are the most complex loops in PHP. They behave like their C counterparts. The syntax of a for loop is:
for (expr1; expr2; expr3) statement
The first expression (expr1) is evaluated (executed) once unconditionally at the beginning of the loop.

In the beginning of each iteration, expr2 is evaluated. If it evaluates to TRUE, the loop continues and the nested statement(s) are executed. If it evaluates to FALSE, the execution of the loop ends.

At the end of each iteration, expr3 is evaluated (executed).

Each of the expressions can be empty or contain multiple expressions separated by commas. In expr2, all expressions separated by a comma are evaluated but the result is taken from the last part. expr2 being empty means the loop should be run indefinitely (PHP implicitly considers it as TRUE, like C). This may not be as useless as you might think, since often you’d want to end the loop using a conditional break statement instead of using the for truth expression.

foreach

The foreach construct provides an easy way to iterate over arrays. foreach works only on arrays and objects, and will issue an error when you try to use it on a variable with a different data type or an uninitialized variable. There are two syntaxes:

foreach (array_expression as $value)
statement
foreach (array_expression as $key => $value)
statement

The first form loops over the array given by array_expression. On each iteration, the value of the current element is assigned to $value and the internal array pointer is advanced by one (so on the next iteration, you’ll be looking at the next element).

The second form will additionally assign the current element’s key to the $key variable on each iteration.

It is possible to customize object iteration.

Note: When foreach first starts executing, the internal array pointer is automatically reset to the first element of the array. This means that you do not need to call reset() before a foreach loop.

As foreach relies on the internal array pointer, changing it within the loop may lead to unexpected behavior.

In order to be able to directly modify array elements within the loop precede $value with &. In that case the value will be assigned by reference.

$arr = array(1, 2, 3, 4); foreach ($arr as &$value) { $value = $value * 2; } // $arr is now array(2, 4, 6, 8) unset($value); // break the reference with the last element

Warning
Reference of a $value and the last array element remain even after the foreach loop. It is recommended to destroy it by unset().

$arr = array("one", "two", "three"); reset($arr); while (list(, $value) = each($arr)) { echo "Value: $value \n"; }

foreach ($arr as $value) { echo "Value: $value \n"; }

The following are also functionally identical:
$arr = array("one", "two", "three"); reset($arr); while (list($key, $value) = each($arr)) { echo "Key: $key; Value: $value \n"; }

foreach ($arr as $key => $value) { echo "Key: $key; Value: $value \n"; }

Unpacking nested arrays with list()
(PHP 5 >= 5.5.0)

PHP 5.5 added the ability to iterate over an array of arrays and unpack the nested array into loop variables by providing a list() as the value.

For example:
$array = [ [1, 2], [3, 4], ];

foreach ($array as list($a, $b)) { // $a contains the first element of the nested array, // and $b contains the second element. echo "A: $a; B: $b\n"; }

The above example will output:

A: 1; B: 2
A: 3; B: 4

You can provide fewer elements in the list() than there are in the nested array, in which case the leftover array values will be ignored:
$array = [ [1, 2], [3, 4], ];

foreach ($array as list($a)) { // Note that there is no $b here. echo "$a\n"; }

The above example will output:

1
3

A notice will be generated if there aren’t enough array elements to fill the list():
$array = [ [1, 2], [3, 4], ];

foreach ($array as list($a, $b, $c)) { echo "A: $a; B: $b; C: $c\n"; }

The above example will output:

Notice: Undefined offset: 2 in example.php on line 7
A: 1; B: 2; C:

Notice: Undefined offset: 2 in example.php on line 7
A: 3; B: 4; C:

break

break ends execution of the current for, foreach, while, do-while or switch structure.

break accepts an optional numeric argument which tells it how many nested enclosing structures are to be broken out of.

$arr = array('one', 'two', 'three', 'four', 'stop', 'five'); while (list(, $val) = each($arr)) { if ($val == 'stop') { break; /* You could also write 'break 1;' here. */ } echo "$val \n"; }


/* Using the optional argument. */

$i = 0; while (++$i) { switch ($i) { case 5: echo "At 5 \n"; break 1; /* Exit only the switch. */ case 10: echo "At 10; quitting \n"; break 2; /* Exit the switch and the while. */ default: break; } }

Changelog for break
5.4.0 : break 0; is no longer valid. In previous versions it was interpreted the same as break 1;.
5.4.0 : Removed the ability to pass in variables (e.g., $num = 2; break $num;) as the numerical argument.

continue

continue is used within looping structures to skip the rest of the current loop iteration and continue execution at the condition evaluation and then the beginning of the next iteration.

Note: Note that in PHP the switch statement is considered a looping structure for the purposes of continue.

continue accepts an optional numeric argument which tells it how many levels of enclosing loops it should skip to the end of. The default value is 1, thus skipping to the end of the current loop.

while (list($key, $value) = each($arr)) { if (!($key % 2)) { // skip odd members continue; } do_something_odd($value); }

$i = 0; while ($i++ < 5) { echo "Outer \n"; while (1) { echo "Middle \n"; while (1) { echo "Inner \n"; continue 3; } echo "This never gets output. \n"; } echo "Neither does this. \n"; }

Omitting the semicolon after continue can lead to confusion. Here’s an example of what you shouldn’t do.

for ($i = 0; $i < 5; ++$i) { if ($i == 2) continue print "$i\n"; }

One can expect the result to be:

0
1
3
4

but this script will output:

because the entire continue print “$i\n”; is evaluated as a single expression, and so print is called only when $i == 2 is true. (The return value of print is passed to continue as the numeric argument.)

Changelog for continue
5.4.0 : continue 0; is no longer valid. In previous versions it was interpreted the same as continue 1;.
5.4.0 : Removed the ability to pass in variables (e.g., $num = 2; continue $num;) as the numerical argument.

switch

The switch statement is similar to a series of IF statements on the same expression. In many occasions, you may want to compare the same variable (or expression) with many different values, and execute a different piece of code depending on which value it equals to. This is exactly what the switch statement is for.

Note: Note that unlike some other languages, the continue statement applies to switch and acts similar to break. If you have a switch inside a loop and wish to continue to the next iteration of the outer loop, use continue 2.

Note: Note that switch/case does loose comparision.

Example: switch structure allows usage of strings
switch ($i) { case "apple": echo "i is apple"; break; case "bar": echo "i is bar"; break; case "cake": echo "i is cake"; break; }

It is important to understand how the switch statement is executed in order to avoid mistakes. The switch statement executes line by line (actually, statement by statement). In the beginning, no code is executed. Only when a case statement is found with a value that matches the value of the switch expression does PHP begin to execute the statements. PHP continues to execute the statements until the end of the switch block, or the first time it sees a break statement. If you don’t write a break statement at the end of a case’s statement list, PHP will go on executing the statements of the following case. For example:

switch ($i) { case 0: echo "i equals 0"; case 1: echo "i equals 1"; case 2: echo "i equals 2"; }

Here, if $i is equal to 0, PHP would execute all of the echo statements! If $i is equal to 1, PHP would execute the last two echo statements. You would get the expected behavior (‘i equals 2’ would be displayed) only if $i is equal to 2. Thus, it is important not to forget break statements (even though you may want to avoid supplying them on purpose under certain circumstances).

In a switch statement, the condition is evaluated only once and the result is compared to each case statement. In an elseif statement, the condition is evaluated again. If your condition is more complicated than a simple compare and/or is in a tight loop, a switch may be faster.

The statement list for a case can also be empty, which simply passes control into the statement list for the next case.

switch ($i) { case 0: case 1: case 2: echo "i is less than 3 but not negative"; break; case 3: echo "i is 3"; }

A special case is the default case. This case matches anything that wasn’t matched by the other cases. For example:
switch ($i) { case 0: echo "i equals 0"; break; case 1: echo "i equals 1"; break; case 2: echo "i equals 2"; break; default: echo "i is not equal to 0, 1 or 2"; }

The case expression may be any expression that evaluates to a simple type, that is, integer or floating-point numbers and strings. Arrays or objects cannot be used here unless they are dereferenced to a simple type.

It’s possible to use a semicolon instead of a colon after a case like:

switch($beer) { case 'tuborg'; case 'carlsberg'; case 'heineken'; echo 'Good choice'; break; default; echo 'Please make a new selection...'; break; }

declare

The declare construct is used to set execution directives for a block of code. The syntax of declare is similar to the syntax of other flow control constructs:

declare (directive) statement

The directive section allows the behavior of the declare block to be set. Currently only two directives are recognized: the ticks directive (See below for more information on the ticks directive) and the encoding directive (See below for more information on the encoding directive).

Note: The encoding directive was added in PHP 5.3.0

The statement part of the declare block will be executed – how it is executed and what side effects occur during execution may depend on the directive set in the directive block.

The declare construct can also be used in the global scope, affecting all code following it (however if the file with declare was included then it does not affect the parent file).

// these are the same:


// you can use this:

declare(ticks=1) {

    // entire script here

}

// or you can use this: declare(ticks=1); // entire script here

Ticks

A tick is an event that occurs for every N low-level tickable statements executed by the parser within the declare block. The value for N is specified using ticks=N within the declare blocks’s directive section.

Not all statements are tickable. Typically, condition expressions and argument expressions are not tickable.

The event(s) that occur on each tick are specified using the register_tick_function(). See the example below for more details. Note that more than one event can occur for each tick.

Example: Tick usage example
declare(ticks=1);


// A function called on each tick event

function tick_handler()

{

    echo "tick_handler() called\n";

}
register_tick_function('tick_handler');
$a = 1;

if ($a > 0) { $a += 2; print($a); }

Example: Ticks usage example
function tick_handler() { echo "tick_handler() called\n"; }


$a = 1;

tick_handler();

if ($a > 0) { $a += 2; tick_handler(); print($a); tick_handler(); } tick_handler();

Encoding

A script’s encoding can be specified per-script using the encoding directive.

Example: Declaring an encoding for the script.
declare(encoding='ISO-8859-1'); // code here

Caution When combined with namespaces, the only legal syntax for declare is declare(encoding=’…’); where … is the encoding value. declare(encoding=’…’) {} will result in a parse error when combined with namespaces.

The encoding declare value is ignored in PHP 5.3 unless php is compiled with –enable-zend-multibyte.

Note that PHP does not expose whether –enable-zend-multibyte was used to compile PHP other than by phpinfo().

return

If called from within a function, the return statement immediately ends execution of the current function, and returns its argument as the value of the function call. return will also end the execution of an eval() statement or script file.

If called from the global scope, then execution of the current script file is ended. If the current script file was included or required, then control is passed back to the calling file. Furthermore, if the current script file was included, then the value given to return will be returned as the value of the include call. If return is called from within the main script file, then script execution ends. If the current script file was named by the auto_prepend_file or auto_append_file configuration options in php.ini, then that script file’s execution is ended.

For more information, see Returning values.

Note: Note that since return is a language construct and not a function, the parentheses surrounding its arguments are not required. It is common to leave them out, and you actually should do so as PHP has less work to do in this case.

Note: If no parameter is supplied, then the parentheses must be omitted and NULL will be returned. Calling return with parentheses but with no arguments will result in a parse error.

Note: You should never use parentheses around your return variable when returning by reference, as this will not work. You can only return variables by reference, not the result of a statement. If you use return ($a); then you’re not returning a variable, but the result of the expression ($a) (which is, of course, the value of $a).

require

require is identical to include except upon failure it will also produce a fatal E_COMPILE_ERROR level error. In other words, it will halt the script whereas include only emits a warning (E_WARNING) which allows the script to continue.

include

The include statement includes and evaluates the specified file.

The documentation below also applies to require.

Files are included based on the file path given or, if none is given, the include_path specified. If the file isn’t found in the include_path, include will finally check in the calling script’s own directory and the current working directory before failing. The include construct will emit a warning if it cannot find a file; this is different behavior from require, which will emit a fatal error.

If a path is defined — whether absolute (starting with a drive letter or \ on Windows, or / on Unix/Linux systems) or relative to the current directory (starting with . or ..) — the include_path will be ignored altogether. For example, if a filename begins with ../, the parser will look in the parent directory to find the requested file.

For more information on how PHP handles including files and the include path, see the documentation for include_path.

When a file is included, the code it contains inherits the variable scope of the line on which the include occurs. Any variables available at that line in the calling file will be available within the called file, from that point forward. However, all functions and classes defined in the included file have the global scope.

Example: Basic include example
vars.php

$color = 'green'; $fruit = 'apple';

test.php


echo "A $color $fruit"; // A
include 'vars.php';

echo "A $color $fruit"; // A green apple

If the include occurs inside a function within the calling file, then all of the code contained in the called file will behave as though it had been defined inside that function. So, it will follow the variable scope of that function. An exception to this rule are magic constants which are evaluated by the parser before the include occurs.

require_once

The require_once statement is identical to require except PHP will check if the file has already been included, and if so, not include (require) it again.

include_once

The include_once statement includes and evaluates the specified file during the execution of the script. This is a behavior similar to the include statement, with the only difference being that if the code from a file has already been included, it will not be included again. As the name suggests, it will be included just once.

include_once may be used in cases where the same file might be included and evaluated more than once during a particular execution of a script, so in this case it may help avoid problems such as function redefinitions, variable value reassignments, etc.

See the include documentation for information about how this function works.

Note: With PHP 4, _once functionality differs with case-insensitive operating systems (like Windows) so for example:

Example: include_once with a case insensitive OS in PHP 4
include_once "a.php"; // this will include a.php include_once "A.php"; // this will include a.php again! (PHP 4 only)

This behaviour changed in PHP 5, so for example with Windows the path is normalized first so that C:\PROGRA~1\A.php is realized the same as C:\Program Files\a.php and the file is included just once.

goto

The goto operator can be used to jump to another section in the program. The target point is specified by a label followed by a colon, and the instruction is given as goto followed by the desired target label. This is not a full unrestricted goto. The target label must be within the same file and context, meaning that you cannot jump out of a function or method, nor can you jump into one. You also cannot jump into any sort of loop or switch structure. You may jump out of these, and a common use is to use a goto in place of a multi-level break.

Example #1 goto example
goto a; echo 'Foo';

a: echo 'Bar';

The above example will output:

Bar

Example #2 goto loop example
for($i=0,$j=50; $i<100; $i++) { while($j--) { if($j==17) goto end; } } echo "i = $i"; end: echo 'j hit 17';

The above example will output:

j hit 17

Example #3 This will not work
goto loop; for($i=0,$j=50; $i<100; $i++) { while($j--) { loop: } } echo "$i = $i";

The above example will output:

Fatal error: ‘goto’ into loop or switch statement is disallowed in
script on line 2

Note: The goto operator is available as of PHP 5.3.

Zend PHP Exam Preparation Part 4

13 Monday Jan 2014

Posted by Shahjalal in Zend PHP Certification

≈ Leave a comment

Tags

Zend PHP exam

Constants

A constant is an identifier (name) for a simple value. As the name suggests, that value cannot change during the execution of the script (except for magic constants, which aren’t actually constants). A constant is case-sensitive by default. By convention, constant identifiers are always uppercase.

The name of a constant follows the same rules as any label in PHP. A valid constant name starts with a letter or underscore, followed by any number of letters, numbers, or underscores.

Example: Valid and invalid constant names

// Valid constant names define("FOO", "something"); define("FOO2", "something else"); define("FOO_BAR", "something more");


// Invalid constant names

define("2FOO",    "something");

// This is valid, but should be avoided: // PHP may one day provide a magical constant // that will break your script define("__FOO__", "something");

Like superglobals, the scope of a constant is global. You can access constants anywhere in your script without regard to scope. For more information on scope, read the manual section on variable scope.

Syntax

You can define a constant by using the define()-function or by using the const keyword outside a class definition as of PHP 5.3.0. Once a constant is defined, it can never be changed or undefined.

Only scalar data (boolean, integer, float and string) can be contained in constants. It is possible to define constants as a resource, but it should be avoided, as it can cause unexpected results.

You can get the value of a constant by simply specifying its name. Unlike with variables, you should not prepend a constant with a $. You can also use the function constant() to read a constant’s value if you wish to obtain the constant’s name dynamically. Use get_defined_constants() to get a list of all defined constants.

Note: Constants and (global) variables are in a different namespace. This implies that for example TRUE and $TRUE are generally different.

If you use an undefined constant, PHP assumes that you mean the name of the constant itself, just as if you called it as a string (CONSTANT vs “CONSTANT”). An error of level E_NOTICE will be issued when this happens. See also the manual entry on why $foo[bar] is wrong (unless you first define() bar as a constant). If you simply want to check if a constant is set, use the defined() function.

These are the differences between constants and variables:

Constants do not have a dollar sign ($) before them;
Constants may only be defined using the define() function, not by simple assignment;
Constants may be defined and accessed anywhere without regard to variable scoping rules;
Constants may not be redefined or undefined once they have been set; and
Constants may only evaluate to scalar values.

Example: Defining Constants
define("CONSTANT", "Hello world."); echo CONSTANT; // outputs "Hello world." echo Constant; // outputs "Constant" and issues a notice.

Example: Defining Constants using the const keyword

// Works as of PHP 5.3.0 const CONSTANT = 'Hello World';

echo CONSTANT;

Magic constants

PHP provides a large number of predefined constants to any script which it runs. Many of these constants, however, are created by various extensions, and will only be present when those extensions are available, either via dynamic loading or because they have been compiled in.

There are eight magical constants that change depending on where they are used. For example, the value of __LINE__ depends on the line that it’s used on in your script. These special constants are case-insensitive and are as follows:

A few “magical” PHP constants

__LINE__ : The current line number of the file.
__FILE__ : The full path and filename of the file. If used inside an include, the name of the included file is returned. Since PHP 4.0.2, __FILE__ always contains an absolute path with symlinks resolved whereas in older versions it contained relative path under some circumstances.
__DIR__ : The directory of the file. If used inside an include, the directory of the included file is returned. This is equivalent to dirname(__FILE__). This directory name does not have a trailing slash unless it is the root directory. (Added in PHP 5.3.0.)
__FUNCTION__ : The function name. (Added in PHP 4.3.0) As of PHP 5 this constant returns the function name as it was declared (case-sensitive). In PHP 4 its value is always lowercased.
__CLASS__ : The class name. (Added in PHP 4.3.0) As of PHP 5 this constant returns the class name as it was declared (case-sensitive). In PHP 4 its value is always lowercased. The class name includes the namespace it was declared in (e.g. Foo\Bar). Note that as of PHP 5.4 __CLASS__ works also in traits. When used in a trait method, __CLASS__ is the name of the class the trait is used in.
__TRAIT__ : The trait name. (Added in PHP 5.4.0) As of PHP 5.4 this constant returns the trait as it was declared (case-sensitive). The trait name includes the namespace it was declared in (e.g. Foo\Bar).
__METHOD__ : The class method name. (Added in PHP 5.0.0) The method name is returned as it was declared (case-sensitive).
__NAMESPACE__ : The name of the current namespace (case-sensitive). This constant is defined in compile-time (Added in PHP 5.3.0).

Operators

Operator Precedence

The precedence of an operator specifies how “tightly” it binds two expressions together. For example, in the expression 1 + 5 * 3, the answer is 16 and not 18 because the multiplication (“*”) operator has a higher precedence than the addition (“+”) operator. Parentheses may be used to force precedence, if necessary. For instance: (1 + 5) * 3 evaluates to 18.

Operators of equal precedence that are non-associative cannot be used next to each other, for example 1 1 is illegal in PHP. The expression 1 <= 1 == 1 on the other hand is legal, because the == operator has lesser precedence than the <= operator.

Note: Although = has a lower precedence than most other operators, PHP will still allow expressions similar to the following: if (!$a = foo()), in which case the return value of foo() is put into $a.

The division operator (“/”) returns a float value unless the two operands are integers (or strings that get converted to integers) and the numbers are evenly divisible, in which case an integer value will be returned.

Operands of modulus are converted to integers (by stripping the decimal part) before processing.

The result of the modulus operator % has the same sign as the dividend — that is, the result of $a % $b will have the same sign as $a. For example:

echo (5 % 3)."\n"; // prints 2 echo (5 % -3)."\n"; // prints 2 echo (-5 % 3)."\n"; // prints -2 echo (-5 % -3)."\n"; // prints -2

Assignment by Reference

Assignment by reference is also supported, using the “$var = &$othervar;” syntax. Assignment by reference means that both variables end up pointing at the same data, and nothing is copied anywhere.

Example #1 Assigning by reference

$a = 3; $b = &$a; // $b is a reference to $a


print "$a\n"; // prints 3

print "$b\n"; // prints 3
$a = 4; // change $a

print "$a\n"; // prints 4 print "$b\n"; // prints 4 as well, since $b is a reference to $a, which has // been changed

As of PHP 5, the new operator returns a reference automatically, so assigning the result of new by reference results in an E_DEPRECATED message in PHP 5.3 and later, and an E_STRICT message in earlier versions.

For example, this code will result in a warning:

class C {}

/* The following line generates the following error message: * Deprecated: Assigning the return value of new by reference is deprecated in... */ $o = &new C;

Bitwise Operators
$a & $b : And : Bits that are set in both $a and $b are set.
$a | $b : Or (inclusive or) : Bits that are set in either $a or $b are set.
$a ^ $b : Xor (exclusive or) : Bits that are set in $a or $b but not both are set.
~ $a : Not : Bits that are set in $a are not set, and vice versa.
$a <> $b : Shift right : Shift the bits of $a $b steps to the right (each step means “divide by two”)

Bit shifting in PHP is arithmetic. Bits shifted off either end are discarded. Left shifts have zeros shifted in on the right while the sign bit is shifted out on the left, meaning the sign of an operand is not preserved. Right shifts have copies of the sign bit shifted in on the left, meaning the sign of an operand is preserved.

Use parentheses to ensure the desired precedence. For example, $a & $b == true evaluates the equivalency then the bitwise and; while ($a & $b) == true evaluates the bitwise and then the equivalency.

Be aware of data type conversions. If both the left-hand and right-hand parameters are strings, the bitwise operator will operate on the characters’ ASCII values.

Comparison Operators

Comparison operators, as their name implies, allow you to compare two values. You may also be interested in viewing the type comparison tables, as they show examples of various type related comparisons.

If you compare a number with a string or the comparison involves numerical strings, then each string is converted to a number and the comparison performed numerically. These rules also apply to the switch statement. The type conversion does not take place when the comparison is === or !== as this involves comparing the type as well as the value.

var_dump(0 == "a"); // 0 == 0 -> true var_dump("1" == "01"); // 1 == 1 -> true var_dump("10" == "1e1"); // 10 == 10 -> true var_dump(100 == "1e2"); // 100 == 100 -> true

switch ("a") { case 0: echo "0"; break; case "a": // never reached because "a" is already matched with 0 echo "a"; break; }

For various types, comparison is done according to the following table (in order).

Comparison with Various Types
null or string – string : Convert NULL to “”, numerical or lexical comparison
bool or null – anything : Convert both sides to bool, FALSE < TRUE
object – object : Built-in classes can define its own comparison, different classes are uncomparable, same class – compare properties the same way as arrays (PHP 4), PHP 5 has its own explanation
string, resource or number – string, resource or number : Translate strings and resources to numbers, usual math
array – array : Array with fewer members is smaller, if key from operand 1 is not found in operand 2 then arrays are uncomparable, otherwise – compare value by value (see following example)
object – anything : object is always greater
array – anything : array is always greater

Example: Boolean/null comparison

// Bool and null are compared as bool always var_dump(1 == TRUE); // TRUE - same as (bool)1 == TRUE var_dump(0 == FALSE); // TRUE - same as (bool)0 == FALSE var_dump(100 < TRUE); // FALSE - same as (bool)100 < TRUE var_dump(-10 < FALSE);// FALSE - same as (bool)-10 < FALSE var_dump(min(-100, -10, NULL, 10, 100)); // NULL - (bool)NULL < (bool)-100 is FALSE < TRUE

Warning Because of the way floats are represented internally, you should not test two floats for equality. See the documentation for float for more information.

Ternary Operator

Another conditional operator is the “?:” (or ternary) operator.

Example: Assigning a default value
// Example usage for: Ternary Operator $action = (empty($_POST['action'])) ? 'default' : $_POST['action'];

// The above is identical to this if/else statement if (empty($_POST['action'])) { $action = 'default'; } else { $action = $_POST['action']; }

The expression (expr1) ? (expr2) : (expr3) evaluates to expr2 if expr1 evaluates to TRUE, and expr3 if expr1 evaluates to FALSE.

Since PHP 5.3, it is possible to leave out the middle part of the ternary operator. Expression expr1 ?: expr3 returns expr1 if expr1 evaluates to TRUE, and expr3 otherwise.

Note: Please note that the ternary operator is a statement, and that it doesn’t evaluate to a variable, but to the result of a statement. This is important to know if you want to return a variable by reference. The statement return $var == 42 ? $a : $b; in a return-by-reference function will therefore not work and a warning is issued in later PHP versions.

Question 1: What would be the output of the following code segment?
//1.
$foo = TRUE;
$bar = $foo?:’FALSE’;
echo($bar);

//2.
$foo = FALSE;
$bar = $foo?:’FALSE’;
echo($bar);

A. TRUEFALSE
B. FALSEFALSE
C. 0FALSE
D. 1FALSE

*Answer will be available at the end of the post.

Error Control Operators

PHP supports one error control operator: the at sign (@). When prepended to an expression in PHP, any error messages that might be generated by that expression will be ignored.

If the track_errors feature is enabled, any error message generated by the expression will be saved in the variable $php_errormsg. This variable will be overwritten on each error, so check early if you want to use it.

/* Intentional file error */ $my_file = @file ('non_existent_file') or die ("Failed opening file: error was '$php_errormsg'");

// this works for any expression, not just functions: $value = @$cache[$key]; // will not issue a notice if the index $key doesn't exist.

Execution Operators

PHP supports one execution operator: backticks (“). Note that these are not single-quotes! PHP will attempt to execute the contents of the backticks as a shell command; the output will be returned (i.e., it won’t simply be dumped to output; it can be assigned to a variable). Use of the backtick operator is identical to shell_exec().

$output = `ls -al`; echo "


$output

";

Note: The backtick operator is disabled when safe mode is enabled or shell_exec() is disabled.

Note: Unlike some other languages, backticks cannot be used within double-quoted strings.

Incrementing/Decrementing Operators

PHP supports C-style pre- and post-increment and decrement operators.

Note: The increment/decrement operators only affect numbers and strings. Arrays, objects and resources are not affected. Decrementing NULL values has no effect too, but incrementing them results in 1.

Increment/decrement Operators
++$a : Pre-increment – Increments $a by one, then returns $a.
$a++ : Post-increment – Returns $a, then increments $a by one.
–$a : Pre-decrement – Decrements $a by one, then returns $a.
$a– : Post-decrement – Returns $a, then decrements $a by one.

Incrementing or decrementing booleans has no effect.

Logical Operators
Logical Operators Example
$a and $b : And – TRUE if both $a and $b are TRUE.
$a or $b : Or – TRUE if either $a or $b is TRUE.
$a xor $b : Xor – TRUE if either $a or $b is TRUE, but not both.
! $a : Not – TRUE if $a is not TRUE.
$a && $b : And – TRUE if both $a and $b are TRUE.
$a || $b : Or – TRUE if either $a or $b is TRUE.

The reason for the two different variations of “and” and “or” operators is that they operate at different precedences. (See Operator Precedence.)

Example: Logical operators illustrated

// -------------------- // foo() will never get called as those operators are short-circuit


$a = (false && foo());

$b = (true  || foo());

$c = (false and foo());

$d = (true  or  foo());
// --------------------

// "||" has a greater precedence than "or"
// The result of the expression (false || true) is assigned to $e

// Acts like: ($e = (false || true))

$e = false || true;
// The constant false is assigned to $f and then true is ignored

// Acts like: (($f = false) or true)

$f = false or true;
var_dump($e, $f);
// --------------------

// "&&" has a greater precedence than "and"
// The result of the expression (true && false) is assigned to $g

// Acts like: ($g = (true && false))

$g = true && false;
// The constant true is assigned to $h and then false is ignored

// Acts like: (($h = true) and false)

$h = true and false;

var_dump($g, $h);

The above example will output something similar to:

bool(true) bool(false) bool(false) bool(true)

String Operators

There are two string operators. The first is the concatenation operator (‘.’), which returns the concatenation of its right and left arguments. The second is the concatenating assignment operator (‘.=’), which appends the argument on the right side to the argument on the left side.

Array Operators

$a + $b : Union – Union of $a and $b.
$a == $b : Equality – TRUE if $a and $b have the same key/value pairs.
$a === $b : Identity – TRUE if $a and $b have the same key/value pairs in the same order and of the same types.
$a != $b : Inequality – TRUE if $a is not equal to $b.
$a $b : Inequality – TRUE if $a is not equal to $b.
$a !== $b : Non-identity – TRUE if $a is not identical to $b.

The + operator returns the right-hand array appended to the left-hand array; for keys that exist in both arrays, the elements from the left-hand array will be used, and the matching elements from the right-hand array will be ignored.

$a = array("a" => "apple", "b" => "banana"); $b = array("a" => "pear", "b" => "strawberry", "c" => "cherry");


$c = $a + $b; // Union of $a and $b

echo "Union of \$a and \$b: \n";

var_dump($c);

$c = $b + $a; // Union of $b and $a echo "Union of \$b and \$a: \n"; var_dump($c);

When executed, this script will print the following:

Union of $a and $b: array(3) { ["a"]=> string(5) "apple" ["b"]=> string(6) "banana" ["c"]=> string(6) "cherry" } Union of $b and $a: array(3) { ["a"]=> string(4) "pear" ["b"]=> string(10) "strawberry" ["c"]=> string(6) "cherry" }

Elements of arrays are equal for the comparison if they have the same key and value.

Example: Comparing arrays

$a = array("apple", "banana"); $b = array(1 => "banana", "0" => "apple");

var_dump($a == $b); // bool(true) var_dump($a === $b); // bool(false)

Type Operators

instanceof is used to determine whether a PHP variable is an instantiated object of a certain class:

Example: Using instanceof with classes
class MyClass { }


class NotMyClass

{

}

$a = new MyClass;

var_dump($a instanceof MyClass); var_dump($a instanceof NotMyClass);

The above example will output:

bool(true)
bool(false)

instanceof can also be used to determine whether a variable is an instantiated object of a class that inherits from a parent class:

Example: Using instanceof with inherited classes
class ParentClass { }


class MyClass extends ParentClass

{

}
$a = new MyClass;

var_dump($a instanceof MyClass); var_dump($a instanceof ParentClass);

The above example will output:

bool(true)
bool(true)

To check if an object is not an instanceof a class, the logical not operator can be used.

Example: Using instanceof to check if object is not an instanceof a class

class MyClass { }

$a = new MyClass; var_dump(!($a instanceof stdClass));

The above example will output:

bool(true)

Lastly, instanceof can also be used to determine whether a variable is an instantiated object of a class that implements an interface:

Example: Using instanceof for class

interface MyInterface { }


class MyClass implements MyInterface

{

}
$a = new MyClass;

var_dump($a instanceof MyClass); var_dump($a instanceof MyInterface);

The above example will output:

bool(true)
bool(true)

Although instanceof is usually used with a literal classname, it can also be used with another object or a string variable:

Example: Using instanceof with other variables

interface MyInterface { }


class MyClass implements MyInterface

{

}
$a = new MyClass;

$b = new MyClass;

$c = 'MyClass';

$d = 'NotMyClass';

var_dump($a instanceof $b); // $b is an object of class MyClass var_dump($a instanceof $c); // $c is a string 'MyClass' var_dump($a instanceof $d); // $d is a string 'NotMyClass'

The above example will output:

bool(true)
bool(true)
bool(false)

instanceof does not throw any error if the variable being tested is not an object, it simply returns FALSE. Constants, however, are not allowed.

Example: Using instanceof to test other variables

$a = 1; $b = NULL; $c = imagecreate(5, 5); var_dump($a instanceof stdClass); // $a is an integer var_dump($b instanceof stdClass); // $b is NULL var_dump($c instanceof stdClass); // $c is a resource var_dump(FALSE instanceof stdClass);

The above example will output:

bool(false)
bool(false)
bool(false)

PHP Fatal error: instanceof expects an object instance, constant given

There are a few pitfalls to be aware of. Before PHP version 5.1.0, instanceof would call __autoload() if the class name did not exist. In addition, if the class was not loaded, a fatal error would occur. This can be worked around by using a dynamic class reference, or a string variable containing the class name:

Example: Avoiding classname lookups and fatal errors with instanceof in PHP 5.0

$d = 'NotMyClass'; var_dump($a instanceof $d); // no fatal error here

The above example will output:

bool(false)

The instanceof operator was introduced in PHP 5. Before this time is_a() was used but is_a() has since been deprecated in favor of instanceof. Note that as of PHP 5.3.0, is_a() is no longer deprecated.

Zend PHP Exam Preparation Part 3

12 Sunday Jan 2014

Posted by Shahjalal in Zend PHP Certification

≈ Leave a comment

Tags

php certification, php exam preparation, Zend PHP exam

Objects
To create a new object, use the new statement to instantiate a class:

If an object is converted to an object, it is not modified. If a value of any other type is converted to an object, a new instance of the stdClass built-in class is created. If the value was NULL, the new instance will be empty. Arrays convert to an object with properties named by keys, and corresponding values. For any other value, a member variable named scalar will contain the value.

Resources
A resource is a special variable, holding a reference to an external resource. Resources are created and used by special functions.

Converting to resource
As resource variables hold special handlers to opened files, database connections, image canvas areas and the like, converting to a resource makes no sense.

Freeing resources
Thanks to the reference-counting system introduced with PHP 4’s Zend Engine, a resource with no more references to it is detected automatically, and it is freed by the garbage collector. For this reason, it is rarely necessary to free the memory manually.

Note: Persistent database links are an exception to this rule. They are not destroyed by the garbage collector.

NULL

The special NULL value represents a variable with no value. NULL is the only possible value of type null.

A variable is considered to be null if:

it has been assigned the constant NULL.
it has not been set to any value yet.
it has been unset().

There is only one value of type null, and that is the case-insensitive constant NULL.

Casting to NULL
Casting a variable to null using (unset) $var will not remove the variable or unset its value. It will only return a NULL value.

Callbacks

Callbacks can be denoted by callable type hint as of PHP 5.4. This documentation used callback type information for the same purpose.

Some functions like call_user_func() or usort() accept user-defined callback functions as a parameter. Callback functions can not only be simple functions, but also object methods, including static class methods.

Passing

A PHP function is passed by its name as a string. Any built-in or user-defined function can be used, except language constructs such as: array(), echo, empty(), eval(), exit(), isset(), list(), print or unset().

A method of an instantiated object is passed as an array containing an object at index 0 and the method name at index 1.

Static class methods can also be passed without instantiating an object of that class by passing the class name instead of an object at index 0. As of PHP 5.2.3, it is also possible to pass ‘ClassName::methodName’.

Apart from common user-defined function, anonymous functions can also be passed to a callback parameter.

Example: Callback function examples
callback functin example </a>
<a href=”https://shahjalalhossain.files.wordpress.com/2014/01/screen-shot-2014-01-12-at-1-04-13-pm.png”> callback function example 2

Example: Callback example using a Closure

The above example will output:

2 4 6 8 10

Note: In PHP 4, it was necessary to use a reference to create a callback that points to the actual object, and not a copy of it. For more details, see References Explained.

Note: Callbacks registered with functions such as call_user_func() and call_user_func_array() will not be called if there is an uncaught exception thrown in a previous callback.

Pseudo-types and variables used in this documentation

mixed

mixed indicates that a parameter may accept multiple (but not necessarily all) types.

gettype() for example will accept all PHP types, while str_replace() will accept strings and arrays.

number

number indicates that a parameter can be either integer or float.

callback

callback pseudo-types was used in this documentation before callable type hint was introduced by PHP 5.4. It means exactly the same.

void

void as a return type means that the return value is useless. void in a parameter list means that the function doesn’t accept any parameters.

$… in function prototypes means and so on. This variable name is used when a function can take an endless number of arguments.

Type Juggling

PHP does not require (or support) explicit type definition in variable declaration; a variable’s type is determined by the context in which the variable is used. That is to say, if a string value is assigned to variable $var, $var becomes a string. If an integer value is then assigned to $var, it becomes an integer.

An example of PHP’s automatic type conversion is the addition operator ‘+’. If either operand is a float, then both operands are evaluated as floats, and the result will be a float. Otherwise, the operands will be interpreted as integers, and the result will also be an integer. Note that this does not change the types of the operands themselves; the only change is in how the operands are evaluated and what the type of the expression itself is.

To force a variable to be evaluated as a certain type, see the section on Type casting. To change the type of a variable, see the settype() function.

To test any of the examples in this section, use the var_dump() function.

Note: The behaviour of an automatic conversion to array is currently undefined.
Also, because PHP supports indexing into strings via offsets using the same syntax as array indexing, the following example holds true for all PHP versions:

Type Casting

Type casting in PHP works much as it does in C: the name of the desired type is written in parentheses before the variable which is to be cast.
The casts allowed are:

(int), (integer) – cast to integer
(bool), (boolean) – cast to boolean
(float), (double), (real) – cast to float
(string) – cast to string
(array) – cast to array
(object) – cast to object
(unset) – cast to NULL (PHP 5)
(binary) casting and b prefix forward support was added in PHP 5.2.1

Note: Instead of casting a variable to a string, it is also possible to enclose the variable in double quotes.

Variables
Variables in PHP are represented by a dollar sign followed by the name of the variable. The variable name is case-sensitive.

Variable names follow the same rules as other labels in PHP. A valid variable name starts with a letter or underscore, followed by any number of letters, numbers, or underscores.

Note: $this is a special variable that can’t be assigned
By default, variables are always assigned by value. That is to say, when you assign an expression to a variable, the entire value of the original expression is copied into the destination variable. This means, for instance, that after assigning one variable’s value to another, changing one of those variables will have no effect on the other.

PHP also offers another way to assign values to variables: assign by reference. This means that the new variable simply references (in other words, “becomes an alias for” or “points to”) the original variable. Changes to the new variable affect the original, and vice versa.

To assign by reference, simply prepend an ampersand (&) to the beginning of the variable which is being assigned (the source variable). For instance, the following code snippet outputs ‘My name is Bob’ twice:

One important thing to note is that only named variables may be assigned by reference.

It is not necessary to initialize variables in PHP however it is a very good practice. Uninitialized variables have a default value of their type depending on the context in which they are used – booleans default to FALSE, integers and floats default to zero, strings (e.g. used in echo) are set as an empty string and arrays become to an empty array.

Relying on the default value of an uninitialized variable is problematic in the case of including one file into another which uses the same variable name. It is also a major security risk with register_globals turned on. E_NOTICE level error is issued in case of working with uninitialized variables, however not in the case of appending elements to the uninitialized array. isset() language construct can be used to detect if a variable has been already initialized.

Warning In PHP 4.2.0 and later, the default value for the PHP directive register_globals is off. PHP 5.0.0, the long PHP predefined variable arrays may be disabled with the register_long_arrays directive.

Variable scope

The scope of a variable is the context within which it is defined. For the most part all PHP variables only have a single scope. This single scope spans included and required files as well.

This script will not produce any output because the echo statement refers to a local version of the $a variable, and it has not been assigned a value within this scope. You may notice that this is a little bit different from the C language in that global variables in C are automatically available to functions unless specifically overridden by a local definition. This can cause some problems in that people may inadvertently change a global variable. In PHP global variables must be declared global inside a function if they are going to be used in that function.

The global keyword

First, an example use of global:

Example Using global

The above script will output 3. By declaring $a and $b global within the function, all references to either variable will refer to the global version. There is no limit to the number of global variables that can be manipulated by a function.

A second way to access variables from the global scope is to use the special PHP-defined $GLOBALS array. The previous example can be rewritten as:

Example: Using $GLOBALS instead of global

The $GLOBALS array is an associative array with the name of the global variable being the key and the contents of that variable being the value of the array element. Notice how $GLOBALS exists in any scope, this is because $GLOBALS is a superglobal.

Note: Using global keyword outside a function is not an error. It can be used if the file is included from inside a function.

Using static variables

Another important feature of variable scoping is the static variable. A static variable exists only in a local function scope, but it does not lose its value when program execution leaves this scope.

To make a useful counting function which will not lose track of the current count, the $a variable is declared static:

Example: Example use of static variables

Now, $a is initialized only in first call of function and every time the test() function is called it will print the value of $a and increment it.

Static variables also provide one way to deal with recursive functions. A recursive function is one which calls itself. Care must be taken when writing a recursive function because it is possible to make it recurse indefinitely. You must make sure you have an adequate way of terminating the recursion. The following simple function recursively counts to 10, using the static variable $count to know when to stop:
Example: Static variables with recursive functions

Note: Static variables may be declared as seen in the examples above. Trying to assign values to these variables which are the result of expressions will cause a parse error.

Example: Declaring static variables

Note: Static declarations are resolved in compile-time.

References with global and static variables

The Zend Engine 1, driving PHP 4, implements the static and global modifier for variables in terms of references. For example, a true global variable imported inside a function scope with the global statement actually creates a reference to the global variable. This can lead to unexpected behaviour which the following example addresses:

The above example will output:

null

object(stdClass)[1]

A similar behavior applies to the static statement. References are not stored statically:

The above example will output:

Static object:


null
Static object:
null
Static object:
null
Static object:

object(stdClass)[3] public 'property' => int 1

This example demonstrates that when assigning a reference to a static variable, it’s not remembered when you call the &get_instance_ref() function a second time.
add a note add a note

Variable variables

Sometimes it is convenient to be able to have variable variable names. That is, a variable name which can be set and used dynamically.

A variable variable takes the value of a variable and treats that as the name of a variable. In the above example, hello, can be used as the name of a variable by using two dollar signs. i.e.

$$a = 'world';

At this point two variables have been defined and stored in the PHP symbol tree: $a with contents “hello” and $hello with contents “world”. Therefore, this statement:

echo "$a ${$a}";

produces the exact same output as:

echo "$a $hello";

i.e. they both produce: hello world.

In order to use variable variables with arrays, you have to resolve an ambiguity problem. That is, if you write $$a[1] then the parser needs to know if you meant to use $a[1] as a variable, or if you wanted $$a as the variable and then the [1] index from that variable. The syntax for resolving this ambiguity is: ${$a[1]} for the first case and ${$a}[1] for the second.

Class properties may also be accessed using variable property names. The variable property name will be resolved within the scope from which the call is made. For instance, if you have an expression such as $foo->$bar, then the local scope will be examined for $bar and its value will be used as the name of the property of $foo. This is also true if $bar is an array access.

Curly braces may also be used, to clearly delimit the property name. They are most useful when accessing values within a property that contains an array, when the property name is made of mulitple parts, or when the property name contains characters that are not otherwise valid (e.g. from json_decode() or SimpleXML).

Example: Variable property example

class foo { var $bar = 'I am bar.'; var $arr = array('I am A.', 'I am B.', 'I am C.'); var $r = 'I am r.'; }


$foo = new foo();

$bar = 'bar';

$baz = array('foo', 'bar', 'baz', 'quux');

echo $foo->$bar . "\n";

echo $foo->$baz[1] . "\n";
$start = 'b';

$end   = 'ar';

echo $foo->{$start . $end} . "\n";

$arr = 'arr'; echo $foo->$arr[1] . "\n"; echo $foo->{$arr}[1] . "\n";

The above example will output:

I am bar. I am bar. I am bar. I am r. I am B.

Warning Please note that variable variables cannot be used with PHP’s Superglobal arrays within functions or class methods. The variable $this is also a special variable that cannot be referenced dynamically.

Variables From External Sources
Note: Dots and spaces in variable names are converted to underscores. For example becomes $_REQUEST[“a_b”].

Note: The magic_quotes_gpc configuration directive affects Get, Post and Cookie values. If turned on, value (It’s “PHP!”) will automagically become (It\’s \”PHP!\”). It was deemed that this was needed for escaping for DB insertion circa a decade ago and is a legacy feature now that should be disabled. See also addslashes(), stripslashes() and magic_quotes_sybase.

Zend PHP Exam Preparation Part 2

12 Sunday Jan 2014

Posted by Shahjalal in Zend PHP Certification

≈ Leave a comment

Tags

php exam, php exam preparation, Zend PHP exam

Arrays

An array in PHP is actually an ordered map. A map is a type that associates values to keys. This type is optimized for several different uses; it can be treated as an array, list (vector), hash table (an implementation of a map), dictionary, collection, stack, queue, and probably more. As array values can be other arrays, trees and multidimensional arrays are also possible.

An array can be created using the array() language construct. It takes any number of comma-separated key => value pairs as arguments.

The comma after the last array element is optional and can be omitted. This is usually done for single-line arrays, i.e. array(1, 2) is preferred over array(1, 2, ). For multi-line arrays on the other hand the trailing comma is commonly used, as it allows easier addition of new elements at the end.

As of PHP 5.4 you can also use the short array syntax, which replaces array() with [].

Example: A simple array

The key can either be an integer or a string. The value can be of any type.

Additionally the following key casts will occur:

Strings containing valid integers will be cast to the integer type. E.g. the key “8” will actually be stored under 8. On the other hand “08” will not be cast, as it isn’t a valid decimal integer.
Floats are also cast to integers, which means that the fractional part will be truncated. E.g. the key 8.7 will actually be stored under 8.
Bools are cast to integers, too, i.e. the key true will actually be stored under 1 and the key false under 0.
Null will be cast to the empty string, i.e. the key null will actually be stored under “”.
Arrays and objects can not be used as keys. Doing so will result in a warning: Illegal offset type.

If multiple elements in the array declaration use the same key, only the last one will be used as all others are overwritten.

The above example will output:

array(1) { [1]=> string(1) "d" }

As all the keys in the above example are cast to 1, the value will be overwritten on every new element and the last assigned value “d” is the only one left over.

PHP arrays can contain integer and string keys at the same time as PHP does not distinguish between indexed and associative arrays.

The key is optional. If it is not specified, PHP will use the increment of the largest previously used integer key.

It is possible to specify the key only for some elements and leave it out for others:
Example: Keys not on all elements

The above example will output:

array(4) { [0]=> string(1) "a" [1]=> string(1) "b" [6]=> string(1) "c" [7]=> string(1) "d" }

As you can see the last value “d” was assigned the key 7. This is because the largest integer key before that was 6.

Accessing array elements with square bracket syntax

Array elements can be accessed using the array[key] syntax.

Note: Both square brackets and curly braces can be used interchangeably for accessing array elements (e.g. $array[42] and $array{42} will both do the same thing in the example above).

As of PHP 5.4 it is possible to array dereference the result of a function or method call directly. Before it was only possible using a temporary variable.

As of PHP 5.5 it is possible to array dereference an array literal.
Example: Array dereferencing

Creating/modifying with square bracket syntax

An existing array can be modified by explicitly setting values in it.

This is done by assigning values to the array, specifying the key in brackets. The key can also be omitted, resulting in an empty pair of brackets ([]).

$arr[key] = value; $arr[] = value; // key may be an integer or string // value may be any value of any type

If $arr doesn’t exist yet, it will be created, so this is also an alternative way to create an array. This practice is however discouraged because if $arr already contains some value (e.g. string from request variable) then this value will stay in the place and [] may actually stand for string access operator. It is always better to initialize variable by a direct assignment.

To change a certain value, assign a new value to that element using its key. To remove a key/value pair, call the unset() function on it.

Question 1: What would be the output of the following code?

A. Array ( [12] => 2 [13] => 56 [x] => 42 )
B. Array ( null [12] => 2 [13] => 56 [x] => 42 )
C. Array ( [x] => 42 [12] => 2 [13] => 56 )
*Answer will be available at the end of this post.

Note:
As mentioned above, if no key is specified, the maximum of the existing integer indices is taken, and the new key will be that maximum value plus 1 (but at least 0). If no integer indices exist yet, the key will be 0 (zero).

Note that the maximum integer key used for this need not currently exist in the array. It need only have existed in the array at some time since the last time the array was re-indexed. The following example illustrates:

The above example will output:
Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 4 [4] => 5 ) Array ( ) Array ( [5] => 6 ) Array ( [0] => 6 [1] => 7 )

Question 2: What would be the output of following code segments?

A. Array ( [5] => 6 ) Array ( [5] => 6 )
B. Array ( [0] => 6 ) Array ( [5] => 6 )
C. Array ( [0] => 6 ) Array ( [0] => 6 )
D. Array ( [5] => 6 ) Array ( [0] => 6 )
*Answer will be available at the end of this post.

Useful functions

There are quite a few useful functions for working with arrays. See the array functions section.
Note:
The unset() function allows removing keys from an array. Be aware that the array will not be reindexed. If a true “remove and shift” behavior is desired, the array can be reindexed using the array_values() function.

The foreach control structure exists specifically for arrays. It provides an easy way to traverse an array.

Why is $foo[bar] wrong?

Always use quotes around a string literal array index. For example, $foo[‘bar’] is correct, while $foo[bar] is not.

The reason is that this code has an undefined constant (bar) rather than a string (‘bar’ – notice the quotes). PHP may in the future define constants which, unfortunately for such code, have the same name. It works because PHP automatically converts a bare string (an unquoted string which does not correspond to any known symbol) into a string which contains the bare string. For instance, if there is no defined constant named bar, then PHP will substitute in the string ‘bar’ and use that.

Note: This does not mean to always quote the key. Do not quote keys which are constants or variables, as this will prevent PHP from interpreting them.

The above example will output:

Checking 0: Notice: Undefined index: $i in /path/to/script.html on line 9 Bad: Good: 1 Notice: Undefined index: $i in /path/to/script.html on line 11 Bad: Good: 1

Checking 1: Notice: Undefined index: $i in /path/to/script.html on line 9 Bad: Good: 2 Notice: Undefined index: $i in /path/to/script.html on line 11 Bad: Good: 2

Converting to array

For any of the types: integer, float, string, boolean and resource, converting a value to an array results in an array with a single element with index zero and the value of the scalar which was converted. In other words, (array)$scalarValue is exactly the same as array($scalarValue).

If an object is converted to an array, the result is an array whose elements are the object’s properties. The keys are the member variable names, with a few notable exceptions: integer properties are unaccessible; private variables have the class name prepended to the variable name; protected variables have a ‘*’ prepended to the variable name. These prepended values have null bytes on either side. Converting NULL to an array results in an empty array.

Comparing

It is possible to compare arrays with the array_diff() function and with array operators.

Example:

Changing the values of the array directly is possible since PHP 5 by passing them by reference. Before that, a workaround is necessary:

Example: Changing element in the loop

The above example will output:

Array ( [0] => RED [1] => BLUE [2] => GREEN [3] => YELLOW )

Example: Filling an array

Array assignment always involves value copying. Use the reference operator to copy an array by reference.

Question 3: What would be the output of the following code segment?

A. Array ( [0] => 2 [1] => 3 [2] => 5 )
Array ( [0] => 2 [1] => 3 [2] => 4 )
Array ( [0] => 2 [1] => 3 [2] => 4 )

B. Array ( [0] => 2 [1] => 3 [2] => 4 )
Array ( [0] => 2 [1] => 3 [2] => 4 )
Array ( [0] => 2 [1] => 3 [2] => 5 )

C. Array ( [0] => 2 [1] => 3 [2] => 5 )
Array ( [0] => 2 [1] => 3 [2] => 5 )
Array ( [0] => 2 [1] => 3 [2] => 5 )

D. Array ( [0] => 2 [1] => 3 [2] => 5 )
Array ( [0] => 2 [1] => 3 [2] => 4 )
Array ( [0] => 2 [1] => 3 [2] => 5 )
*Answer will be available at the end of this post.

Answers:

Question 1: A
Question 2: B
Question 2: D

Shahjalal's Blog

~ "It’s hard life here. Very hard. Do you know how they make it, each and every day? They believe. They believe it’s going to be better. They believe tomorrow will be better than today. People have to believe on something….."

New tutorial series on Python

Working for Symfony2

Introducing LESS

Introducing Yii PHP Framework Extensions

Zend PHP Exam Preparation Part 7

Zend PHP Exam Preparation Part 6

Zend PHP Exam Preparation Part 5

Zend PHP Exam Preparation Part 4

Zend PHP Exam Preparation Part 3

Zend PHP Exam Preparation Part 2