w3resource

PHP Declare Statement

Description

In PHP declare construct is used to set execution directives for a block of code. At present two directives are recognized ticks and encoding.

Syntax:

declare (directive) statement 

The following table describes two directives currently supported.

Directive Description
ticks A tick is an event. While the format of specifying the tick directive is tick=N, where N is an integer. The tick event occurs for every N statements (following the declare). Usually, condition expressions and argument expressions are excluded from being executed. Register_tick_function() is used to specify each event(s) that occur on each tick. Remember that this directive is deprecated in PHP5.3.
encoding The encoding directive specifies a script's encoding. Usage of this detective is decal re(encoding="EncodingType") where EncodingType is a encoding type like ISO-8859-1. This directive can be used only if PHP is compiled with --enable-zend-multibyte. You can use phpinfo() to know whether a PHP installation

Example of PHP declare statement using tick directive

<?php
declare(ticks=5);
// the following function is called on each tick event
function w3r_tick()
{
echo "w3r_tick() called<br>";
}
register_tick_function('w3r_tick');
$a = 5;
if ($a > 0)
{
$a += 2;
print($a);
}
?>

View the example in the browser

Previous: switch statement
Next: return statement



PHP: Tips of the Day

Members of objects or classes can be accessed using the object operator (->) and the class operator (::).

Example:

class MyClass {
 public $a = 1;
 public static $b = 2;
 const C = 3;
 public function d() { return 4; }
 public static function e() { return 5; }
}
$object = new MyClass();
var_dump($object->a); // int(1)
var_dump($object::$b); // int(2)
var_dump($object::C); // int(3)
var_dump(MyClass::$b); // int(2)
var_dump(MyClass::C); // int(3)
var_dump($object->d()); // int(4)
var_dump($object::d()); // int(4)
var_dump(MyClass::e()); // int(5)
$classname = "MyClass"; 
var_dump($classname::e()); // also works! int(5)

Note that after the object operator, the $ should not be written ($object->a instead of $object->$a). For the class operator, this is not the case and the $ is necessary. For a constant defined in the class, the $ is never used.

Also note that var_dump(MyClass::d()); is only allowed if the function d() does not reference the object:

class MyClass {
 private $a = 1;
 public function d() {
 return $this->a;
 }
}
$object = new MyClass();
var_dump(MyClass::d()); // Error!

This causes a 'PHP Fatal error: Uncaught Error: Using $this when not in object context'

These operators have left associativity, which can be used for 'chaining':

class MyClass {
 private $a = 1;

 public function add(int $a) {
 $this->a += $a;
 return $this;
 }

 public function get() {
 return $this->a;
 }
}
$object = new MyClass();
var_dump($object->add(4)->get()); // int(5)

These operators have the highest precedence (they are not even mentioned in the manual), even higher that clone. Thus:

class MyClass {
 private $a = 0;
 public function add(int $a) {
 $this->a += $a;
 return $this;
 }
 public function get() {
 return $this->a;
 }
}
$o1 = new MyClass();
$o2 = clone $o1->add(2);
var_dump($o1->get()); // int(2)
var_dump($o2->get()); // int(2)

The value of $o1 is added to before the object is cloned!

Note that using parentheses to influence precedence did not work in PHP version 5 and older (it does in PHP 7):

// using the class MyClass from the previous code
$o1 = new MyClass();
$o2 = (clone $o1)->add(2); // Error in PHP 5 and before, fine in PHP 7
var_dump($o1->get()); // int(0) in PHP 7
var_dump($o2->get()); // int(2) in PHP 7