PHPのお勉強！

PHP TOP
PHP 8.4.2 Released!

    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)

    参考

    Found A Problem?

    Learn How To Improve This Page • Submit a Pull Request • Report a Bug
    ＋add a note

    User Contributed Notes 1 note

    up
    3
    shaun at slickdesign dot com dot au
    6 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();
    ?>
    ＋add a note
    To Top