SPL_AUTOLOAD_REGISTER(3) 1 SPL_AUTOLOAD_REGISTER(3)spl_autoload_register - Register given function as __autoload() implementationSYNOPSIS
bool spl_autoload_register ([callable $autoload_function], [bool $throw = true], [bool $prepend = false])
DESCRIPTION
Register a function with the spl provided __autoload queue. If the queue is not yet activated it will be activated.
If your code has an existing __autoload(3) function then this function must be explicitly registered on the __autoload queue. This is
because spl_autoload_register(3) will effectively replace the engine cache for the __autoload(3) function by either spl_autoload(3) or
spl_autoload_call(3).
If there must be multiple autoload functions, spl_autoload_register(3) allows for this. It effectively creates a queue of autoload func-
tions, and runs through each of them in the order they are defined. By contrast, __autoload(3) may only be defined once.
PARAMETERS
o $autoload_function
- The autoload function being registered. If no parameter is provided, then the default implementation of spl_autoload(3) will be
registered.
o $throw
- This parameter specifies whether spl_autoload_register(3) should throw exceptions when the $autoload_function cannot be regis-
tered.
o $prepend
- If true, spl_autoload_register(3) will prepend the autoloader on the autoload queue instead of appending it.
RETURN VALUES
Returns TRUE on success or FALSE on failure.
CHANGELOG
+--------+-------------------------------------+
|Version | |
| | |
| | Description |
| | |
+--------+-------------------------------------+
| 5.3.0 | |
| | |
| | Namespaces support was introduced. |
| | |
| 5.3.0 | |
| | |
| | The $prepend parameter was added. |
| | |
+--------+-------------------------------------+
EXAMPLES
Example #1
spl_autoload_register(3) as a replacement for an __autoload(3) function
<?php
// function __autoload($class) {
// include 'classes/' . $class . '.class.php';
// }
function my_autoloader($class) {
include 'classes/' . $class . '.class.php';
}
spl_autoload_register('my_autoloader');
// Or, using an anonymous function as of PHP 5.3.0
spl_autoload_register(function ($class) {
include 'classes/' . $class . '.class.php';
});
?>
Example #2
spl_autoload_register(3) example where the class is not loaded
<?php
namespace Foobar;
class Foo {
static public function test($name) {
print '[['. $name .']]';
}
}
spl_autoload_register(__NAMESPACE__ .'Foo::test'); // As of PHP 5.3.0
new InexistentClass;
?>
The above example will output something similar to:
[[FoobarInexistentClass]]
Fatal error: Class 'FoobarInexistentClass' not found in ...
SEE ALSO __autoload(3).
PHP Documentation Group SPL_AUTOLOAD_REGISTER(3)
Check Out this Related Man Page
CALL_USER_FUNC(3) 1 CALL_USER_FUNC(3)call_user_func - Call the callback given by the first parameterSYNOPSIS
mixed call_user_func (callable $callback, [mixed $parameter], [mixed $...])
DESCRIPTION
Calls the $callback given by the first parameter and passes the remaining parameters as arguments.
PARAMETERS
o $callback
- The callable to be called.
o $parameter
- Zero or more parameters to be passed to the callback.
Note
Note that the parameters for call_user_func(3) are not passed by reference.
Example #1
call_user_func(3) example and references
<?php
error_reporting(E_ALL);
function increment(&$var)
{
$var++;
}
$a = 0;
call_user_func('increment', $a);
echo $a."
";
// You can use this instead
call_user_func_array('increment', array(&$a));
echo $a."
";
?>
The above example will output:
0
1
RETURN VALUES
Returns the return value of the callback, or FALSE on error.
CHANGELOG
+--------+---------------------------------------------------+
|Version | |
| | |
| | Description |
| | |
+--------+---------------------------------------------------+
| 5.3.0 | |
| | |
| | The interpretation of object oriented keywords |
| | like parent and self has changed. Previously, |
| | calling them using the double colon syntax would |
| | emit an E_STRICT warning because they were inter- |
| | preted as static. |
| | |
+--------+---------------------------------------------------+
EXAMPLES
Example #2
call_user_func(3) example
<?php
function barber($type)
{
echo "You wanted a $type haircut, no problem
";
}
call_user_func('barber', "mushroom");
call_user_func('barber', "shave");
?>
The above example will output:
You wanted a mushroom haircut, no problem
You wanted a shave haircut, no problem
Example #3
call_user_func(3) using namespace name
<?php
namespace Foobar;
class Foo {
static public function test() {
print "Hello world!
";
}
}
call_user_func(__NAMESPACE__ .'Foo::test'); // As of PHP 5.3.0
call_user_func(array(__NAMESPACE__ .'Foo', 'test')); // As of PHP 5.3.0
?>
The above example will output:
Hello world!
Hello world!
Example #4
Using a class method with call_user_func(3)
<?php
class myclass {
static function say_hello()
{
echo "Hello!
";
}
}
$classname = "myclass";
call_user_func(array($classname, 'say_hello'));
call_user_func($classname .'::say_hello'); // As of 5.2.3
$myobject = new myclass();
call_user_func(array($myobject, 'say_hello'));
?>
The above example will output:
Hello!
Hello!
Hello!
Example #5
Using lambda function with call_user_func(3)
<?php
call_user_func(function($arg) { print "[$arg]
"; }, 'test'); /* As of PHP 5.3.0 */
?>
The above example will output:
[test]
NOTES
Note
Callbacks registered with functions such as call_user_func(3) and call_user_func_array(3) will not be called if there is an uncaught
exception thrown in a previous callback.
SEE ALSO call_user_func_array(3), is_callable(3), information about the callback type, ReflectionFunction::invoke, ReflectionMethod::invoke.
PHP Documentation Group CALL_USER_FUNC(3)