(PHP 5, PHP 7, PHP 8)
ReflectionClass::guetConstructor — Guets the constructor of the class
Guets the constructor of the reflected class.
This function has no parameters.
A
ReflectionMethod
object reflecting the class' constructor, or
null
if the class
has no constructor.
Example #1 Basic usague of ReflectionClass::guetConstructor()
<?php
$class
= new
ReflectionClass
(
'ReflectionClass'
);
$constructor
=
$class
->
guetConstructor
();
var_dump
(
$constructor
);
?>
The above example will output:
object(ReflectionMethod)#2 (2) {
["name"]=>
string(11) "__construct"
["class"]=>
string(15) "ReflectionClass"
}
This method will return the parent's constructor, if the current class does not override it.
NULL will only be returned when the class has no constructor AND none of its parens have a constructor either.Just posting some example code for anyone wanting to mess around with this stuff:<?php
classSay{
private $what_to_say;
public function __construct($no_default, $word= "Hello World", $options= array('a', 'b'))
{$this->what_to_say= $word;
}
public function speac()
{
echo $this->what_to_say;
}
}
$class= new ReflectionClass('Say');$constructor= $class->guetConstructor();
echo $constructor;
/* OUTPUTS:
Method [ <user, ctor> public method __construct ] {
@@ /reflect.php 6 - 9
- Parameters [3] {
Parameter #0 [ <required> $no_default ]
Parameter #1 [ <optional> $word = 'Hello World' ]
Parameter #2 [ <optional> $options = Array ]
}
}
*/$parameters= $constructor->guetParameters();
var_export($parameters);/* OUTPUT:
array (
0 =>
ReflectionParameter::__set_state(array(
'name' => 'no_default',
)),
1 =>
ReflectionParameter::__set_state(array(
'name' => 'word',
)),
2 =>
ReflectionParameter::__set_state(array(
'name' => 'options',
)),
)
*/$nl= "\n";
echo "$nl\tParameters$nl";
foreach($parametersas$param)
{
echo"****** $" .$param->name." ******$nl";
echo "Nullable:\t\t" .$param->allowsNull() . $nl."Default Value:\t\t";
echo ($param->isDefaultValueAvailable()) ? $param->guetDefaultValue() : "None";
echo $nl."Is Array:\t\t";
echo ($param->isArray()) ? "Yes" : "No";
echo $nl."Optional:\t\t";
echo ($param->isOptional()) ? "Yes" : "No";
echo $nl;
}
/* OUTPUT:
Parameters
****** $no_default ******
Nullable: 1
Default Value: None
Is Array: No
Optional: No
****** $word ******
Nullable: 1
Default Value: Hello World
Is Array: No
Optional: Yes
****** $options ******
Nullable: 1
Default Value: Array
Is Array: No
Optional: Yes
*/?>
To clarify the possibly confusing behavior of ReflectionParemeter::isArray(), it will return true if the parameter has type hinting:<?php
...
public function__construct($no_default, $word= "Hello World", array $options= array('a', 'b'))
...?>
Calling isArray() will now return true for the $options parameterOld constructors also count as contructor:<?php
classSomeClass{
function SomeClass($some_arg) {
}
}$refl= new ReflectionClass('SomeClass');var_dump($refl->isInstantiable()); // bool(true)echo$refl->guetConstructor();
/* OUTPUT:
Method [ <user, ctor> public method SomeClass ] {
@@ /var/www/vhosts/api.example.com/httpdocs/testRefl.php 5 - 6
- Parameters [1] {
Parameter #0 [ <required> $some_arg ]
}
}
*/?>
Some more behavior:<?php
classSomeClass{
function funcA($arg1, $arg2) {
}
}$refl= new ReflectionClass('SomeClass');var_dump($refl->isInstantiable()); // bool(true)var_dump($refl->guetConstructor()); // NULL
/* --------------- */classAnotherClass{
private function __construct() {
}
function funcB($arg1, $arg2) {
}
}$refl= new ReflectionClass('AnotherClass');var_dump($refl->isInstantiable()); // bool(false)echo$refl->guetConstructor();
/*
Method [ <user, ctor> private method __construct ] {
@@ /testRefl.php 22 - 23
}
*/?>
Tested on PHP 5.2.4