ReflectionClass::isInstantiable

(PHP 5, PHP 7, PHP 8)

ReflectionClass::isInstantiable — Comprueba si una clase es instanciable

Descripción

public ReflectionClass::isInstantiable(): bool

Comprueba si una clase es instanciable.

Parámetros

Esta función no tiene parámetros.

Valores devueltos

Devuelve true en caso de éxito o false en caso de error.

Ejemplos

Ejemplo #1 Ejemplo de ReflectionClass::isInstantiable()

<?php
class C { }

interface ifaz {
    function f1();
}

class ifazImpl implements ifaz {
    function f1() {}
}

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

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

class constructorPrivado {
    private function __construct() { }
}

$clases = array(
    "C",
    "ifaz",
    "ifazImpl",
    "claseAbstracta",
    "D",
    "constructorPrivado",
);

foreach($clases  as $clase ) {
    $reflectionClass = new ReflectionClass($clase);
    echo "¿Es instanciable la clase $clase?  ";
    var_dump($reflectionClass->IsInstantiable()); 
}

?>

El resultado del ejemplo sería:

¿Es instanciable la clase C?  bool(true)
¿Es instanciable la clase ifaz?  bool(false)
¿Es instanciable la clase ifazImpl?  bool(true)
¿Es instanciable la clase claseAbstracta?  bool(false)
¿Es instanciable la clase D?  bool(true)
¿Es instanciable la clase constructorPrivado?  bool(false)

Ver también

ReflectionClass::isInstance() - Comprueba si un objeto es instancia de la clase

Found A Problem?

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

＋add a note

User Contributed Notes 1 note

down

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