PHP 8.3.4 Released!

ReflectionClass::isInstantiable

(PHP 5, PHP 7, PHP 8)

ReflectionClass::isInstantiableVérifie si une classe est instanciable

Description

public ReflectionClass::isInstantiable(): bool

Vérifie si une classe est instanciable.

Liste de paramètres

Cette fonction ne contient aucun paramètre.

Valeurs de retour

Cette fonction retourne true en cas de succès ou false si une erreur survient.

Exemples

Exemple #1 Exemple avec 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
"Est-ce que la classe $class est instanciable ? ";
var_dump($reflectionClass->isInstantiable());
}

?>

L'exemple ci-dessus va afficher :

Est-ce que C est instanciable ?  bool(true)
Est-ce que iface est instanciable ?  bool(false)
Est-ce que ifaceImpl est instanciable ?  bool(true)
Est-ce que abstractClass est instanciable ?  bool(false)
Est-ce que D est instanciable ?  bool(true)
Est-ce que T est instanciable ?  bool(false)
Est-ce que privateConstructor est instanciable ?  bool(false)

Voir aussi

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