ReflectionClass::getConstructor()

(PHP 5, PHP 7)

获取类的构造函数

说明

publicReflectionClass::getConstructor(void): ReflectionMethod

获取已反射的类的构造函数。

参数

此函数没有参数。

返回值

一个ReflectionMethod对象，反射了类的构造函数，或者当类不存在构造函数时返回NULL。

范例

Example #1ReflectionClass::getConstructor()的基本用法

<?php
$class = new ReflectionClass('ReflectionClass');
$constructor = $class->getConstructor();
var_dump($constructor);
?>

以上例程会输出：

object(ReflectionMethod)#2 (2) {
  ["name"]=>
  string(11) "__construct"
  ["class"]=>
  string(15) "ReflectionClass"
}

参见

• ReflectionClass::getName() 获取类名

Just posting some example code for anyone wanting to mess around with this stuff:
<?php
class Say
{
  private $what_to_say;
  public function __construct($no_default, $word = "Hello World", $options = array('a', 'b'))
  {
    $this->what_to_say = $word;
  }
  
  public function speak()
  {
    echo $this->what_to_say;
  }
}
$class = new ReflectionClass('Say');
$constructor = $class->getConstructor();
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->getParameters();
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($parameters as $param)
{
  echo "****** $" . $param->name . " ******$nl";
  echo "Nullable:\t\t" . $param->allowsNull() . $nl
     ."Default Value:\t\t";
  echo ($param->isDefaultValueAvailable()) ? $param->getDefaultValue() : "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 parameter

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 parents have a constructor either.

Old constructors also count as contructor:
<?php
class SomeClass {
  function SomeClass($some_arg) {
  }
}
$refl = new ReflectionClass('SomeClass');
var_dump($refl->isInstantiable()); // bool(true)
echo $refl->getConstructor();
/* 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
class SomeClass {
  function funcA($arg1, $arg2) {
  }
}
$refl = new ReflectionClass('SomeClass');
var_dump($refl->isInstantiable()); // bool(true)
var_dump($refl->getConstructor()); // NULL
/* --------------- */
class AnotherClass {
  private function __construct() {
  }
  function funcB($arg1, $arg2) {
  }
}
$refl = new ReflectionClass('AnotherClass');
var_dump($refl->isInstantiable()); // bool(false)
echo $refl->getConstructor();
/*
Method [ <user, ctor> private method __construct ] {
 @@ /testRefl.php 22 - 23
}
*/
?>
Tested on PHP 5.2.4