PHP Velho Oeste 2024

ReflectionClass::isInstantiable

(PHP 5, PHP 7, PHP 8)

ReflectionClass::isInstantiableクラスのインスタンス化が可能であるかどうかを調べる

説明

public ReflectionClass::isInstantiable(): bool

クラスのインスタンス化が可能であるかどうかを調べます。

パラメータ

この関数にはパラメータはありません。

戻り値

成功した場合に true を、失敗した場合に false を返します。

例1 ReflectionClass::isInstantiable() の例

<?php
class C { }

interface
iface {
function
f1();
}

class
ifaceImpl implements iface {
function
f1() {}
}

abstract class
abstractClass {
function
f1() { }
abstract function
f2();
}

class
D extends abstractClass {
function
f2() { }
}

trait
T {
function
f1() {}
}

class
privateConstructor {
private function
__construct() { }
}

$classes = array(
"C",
"iface",
"ifaceImpl",
"abstractClass",
"D",
"T",
"privateConstructor",
);

foreach(
$classes as $class ) {
$reflectionClass = new ReflectionClass($class);
echo
"Is $class instantiable? ";
var_dump($reflectionClass->isInstantiable());
}

?>

上の例の出力は以下となります。

Is C instantiable?  bool(true)
Is iface instantiable?  bool(false)
Is ifaceImpl instantiable?  bool(true)
Is abstractClass instantiable?  bool(false)
Is D instantiable?  bool(true)
Is T instantiable?  bool(false)
Is privateConstructor instantiable?  bool(false)

参考

add a note

User Contributed Notes 1 note

up
3
shaun at slickdesign dot com dot au
5 years ago
An example missing from the documentation is that `ReflectionClass::isInstantiable` will also return false for traits, as well as interfaces and abstract classes.

<?php
trait t {
// Optional trait methods and properties etc.
}

$reflectionClass = new ReflectionClass("t");
var_dump($reflectionClass->isInstantiable()); // bool(false)
?>

As for classes with private constructors, it is still possible to create an instance by either bypassing the constructor using `ReflectionClass::newInstanceWithoutConstructor`, or by ensuring the class has a method which can create a new instance.

<?php
class p {
private function
__construct() {
// Optional constructor logic - not called when ReflectionClass::newInstanceWithoutConstructor is used.
}

public static function
create() {
return new
p;
}

// Optional methods and properties etc.
}

// Class is not classed as instantiable.
$reflectionClass = new ReflectionClass("p");
var_dump($reflectionClass->isInstantiable()); // bool(false)

// We're still able to create an instance using one of the two methods.
$p = p::create();
$p = $reflectionClass->newInstanceWithoutConstructor();
?>

The same is also true for protected constructors, however, the class can be instantiated from either parent or child methods, depending on where the constructor is defined.

<?php
class p {
protected function
__construct() {
// Optional constructor logic.
}

public static function
create( $class = "" ) {
if (!
$class) {
$class = get_called_class();
}
return new
$class;
}

// Optional parent methods and properties etc.
}

class
c extends p
{
// Optional child methods and properties etc.
}

// Both child and parent static methods have access to each other's protected constructor.
$p = c::create("p");
$c = p::create("c");

// Both are still not classed as being instantiable.
$reflectionClassP = new ReflectionClass("p");
$reflectionClassC = new ReflectionClass("c");
var_dump($reflectionClassP->isInstantiable()); // bool(false)
var_dump($reflectionClassC->isInstantiable()); // bool(false)

// We're still able to bypass the constructor and create an instance for each.
$p = $reflectionClassP->newInstanceWithoutConstructor();
$c = $reflectionClassC->newInstanceWithoutConstructor();
?>
To Top