w3resource

PHP include() Statement

Description

The include() statement is used to include a php file in another file. This way you can write a piece of code in a php file and can use it to multiple files through  include() statement.

If a.php is a php script calling b.php with include() statement, and does not find b.php, a.php executes with a warning, excluding the part of the code written within b.php.

Syntax:

include('name of the php file with path');

Example:

File my_include.php:

<?php
$sports1 = "football";
$sports2 = "cricket";
?>

File myfile.php, which includes my_include.php :

<?php
include('my_include.php');
echo "I prefer&nbsp;".  $sports1 ."&nbsp;
than&nbsp;".  $sports2;
?>

Output:

I prefer football  than cricket

View the example in the browser

If the file within require statement is not available:

For example, if you write my-include.php (which is not available),like this:

<?php
include('myfile_include.php');
echo "I prefer&nbsp;". $sports1 ."&nbsp; than&nbsp;". $sports2;
?>

View the example of php include statement where included file is not present

You can see that it fails to meet the purpose of including the file myfile_include.php, but the script does not stop executing.

require() Statement

require() is identical to include() except upon failure. On failure it produce a fatal E_ERROR level error.

See also

require_once, include_once

Previous: return statement
Next: require_once, include_once



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