CakeFest 2024: The Official CakePHP Conference

is_subclass_of

(PHP 4, PHP 5, PHP 7, PHP 8)

is_subclass_ofVerifica se l'oggetto ha questa classe come una dei suoi genitori o la implementa

Descrizione

is_subclass_of(mixed $object, string $class_name, bool $allow_string = true): bool

Verifica se l'object dato ha la classe class_name come una dei suoi genitori o la implementa.

Elenco dei parametri

object

Un nome di classe o un'istanza di oggetto. Non viene generato nessun errore se la classe non esiste.

class_name

Il nome della classe

allow_string

Se questo parametro è impostato a false, il nome della classe stringa come object non è permesso. Questo impedisce anche di chiamare l'autoloader se la classe non esiste.

Valori restituiti

Questa funzione restituisce true se l'oggetto object, appartiene ad una classe che è una sottoclasse di class_name, false in caso contrario.

Log delle modifiche

Versione Descrizione
5.3.9 Aggiunto il parametro allow_string
5.3.7 Aggiunto il supporto per class_name per funzionare come le interfacce
5.0.3 Si potrebbe anche specificare il parametro object come una stringa (il nome della classe)

Esempi

Example #1 Esempio di is_subclass_of()

<?php
// definisce una classe
class WidgetFactory
{
var
$oink = 'moo';
}

// definisce una classe figlia
class WidgetFactory_Child extends WidgetFactory
{
var
$oink = 'oink';
}

// crea un nuovo oggetto
$WF = new WidgetFactory();
$WFC = new WidgetFactory_Child();

if (
is_subclass_of($WFC, 'WidgetFactory')) {
echo
"yes, \$WFC is a subclass of WidgetFactory\n";
} else {
echo
"no, \$WFC is not a subclass of WidgetFactory\n";
}


if (
is_subclass_of($WF, 'WidgetFactory')) {
echo
"yes, \$WF is a subclass of WidgetFactory\n";
} else {
echo
"no, \$WF is not a subclass of WidgetFactory\n";
}


// utilizzabile solo da PHP 5.0.3
if (is_subclass_of('WidgetFactory_Child', 'WidgetFactory')) {
echo
"yes, WidgetFactory_Child is a subclass of WidgetFactory\n";
} else {
echo
"no, WidgetFactory_Child is not a subclass of WidgetFactory\n";
}
?>

Il precedente esempio visualizzerà:

yes, $WFC is a subclass of WidgetFactory
no, $WF is not a subclass of WidgetFactory
yes, WidgetFactory_Child is a subclass of WidgetFactory

Example #2 Esempio di is_subclass_of() usando interfacce

<?php
// Definisce l'Interfaccia
interface MyInterface
{
public function
MyFunction();
}

// Definisce l'implementazione della classe dell'interfaccia
class MyClass implements MyInterface
{
public function
MyFunction()
{
return
"MyClass Implements MyInterface!";
}
}

// Istanzia l'oggetto
$my_object = new MyClass;

// Funziona da 5.3.7

// Test usando l'istanza oggetto della classe
if (is_subclass_of($my_object, 'MyInterface')) {
echo
"Yes, \$my_object is a subclass of MyInterface\n";
} else {
echo
"No, \$my_object is not a subclass of MyInterface\n";
}

// Test usando una stringa del nome della classe
if (is_subclass_of('MyClass', 'MyInterface')) {
echo
"Yes, MyClass is a subclass of MyInterface\n";
} else {
echo
"No, MyClass is not a subclass of MyInterface\n";
}
?>

Il precedente esempio visualizzerà:

Yes, $my_object is a subclass of MyInterface
Yes, MyClass is a subclass of MyInterface

Note

Nota:

L'utilizzo di questa funzione attiverà tutti gli autoloaders se la classe non è già conosciuta.

Vedere anche:

  • get_class() - Restituisce il nome della classe di un oggetto
  • get_parent_class() - Restituisce il nome della classe genitrice di un oggetto o di una classe
  • is_a() - Verifica se l'oggetto è di questa classe o ha questa classe come una dei suoi genitori
  • class_parents() - Return the parent classes of the given class

add a note

User Contributed Notes 9 notes

up
17
gunniboyh at web dot de
17 years ago
is_subclass_of() works also with classes between the class of obj and the superclass.

example:
<?php
class A {};
class
B extends A {};
class
C extends B {};

$foo=new C();
echo ((
is_subclass_of($foo,'A')) ? 'true' : 'false');
?>

echoes 'true' .
up
10
nicholas at aquarionics dot com
15 years ago
This might be useful to someone, so:

If you're using Autoload, you should be aware that this will attempt to autoload $classname if it isn't already loaded. I discovered this when I had something using is_subclass_of inside an error thrown by autoload, which then recursed until it ran out of memory.
up
2
alan at jynxy.net
5 years ago
The $allow_string parameter is not very clearly documented. When true, it simply allows the first parameter to be the name of a class, instead of an object whose class we are interested in.

Some usage examples:

class parent_class {
// objects and methods ...
}

$possible_child_object = new possible_child_class(); // might be an extension of parent_class

$result = is_subclass_of($possible_child_object, 'parent_class'); // valid
$result = is_subclass_of($possible_child_object, 'parent_class', false); // valid
$result = is_subclass_of('possible_child_class', 'parent_class', true); // valid
$result = is_subclass_of('possible_child_class', 'parent_class', false); // not valid
up
1
Anonymous
1 year ago
You can check if your current class is a child with:

<?php is_subclass_of($this, self::class) ?>

<?php
class a {
public function
check(): bool {
return
is_subclass_of($this, self::class);
}
}

class
b extends a {}

$a = new a();
$b = new b();

echo
$a->check() ? 'Yes' : 'No';
echo
PHP_EOL;
echo
$b->check() ? 'Yes' : 'No';
echo
PHP_EOL;
?>

prints:
No
Yes
up
0
Shane
5 days ago
In addition to Anonymous's post above regarding using this to determine whether your class has been inherited or not, you may also use this in static methods as follows:

<?php
class a {
public static function
check() {
return
is_subclass_of(static::class, self::class);
}
}

class
b extends a {}

echo
a::check() ? "Yes" : "No";
echo
PHP_EOL;
echo
b::check() ? "Yes" : "No";
echo
PHP_EOL;
?>

Prints:
No
Yes
up
-3
kostyl_kostyl gav-gav mail point ru
15 years ago
<?php
interface I {
}
class
A implements I {
}
class
B extends A {
}
if (
is_subclass_of('A', 'I')) {
echo
'good<br>';
}
else {
echo
'bad<br>';
}
if (
is_subclass_of('B', 'I')) {
echo
'good<br>';
}
else {
echo
'bad<br>';
}
if (
is_subclass_of('B', 'A')) {
echo
'good<br>';
}
else {
echo
'bad<br>';
}
?>

result:
bad <- you must to describe intermediate class B to be good
good
good
up
-2
Damien Bezborodov
15 years ago
If you need something similar to is_subclass_of() to determine if a class implements an interface before instantiating it, use reflection:

<?php

interface A_Interface {}
class
A implements A_Interface {}

$reflectionA = new ReflectionClass('A');
var_dump(
$reflectionA->implementsInterface('A_Interface')
);

?>
bool(true)
up
-3
jm
15 years ago
It would appear that is_subclass_of is case insensitive unlike get_class in php5.
i.e.

<?php
class fooBar {}
class
bar extends fooBar {}

assert(get_class(new fooBar()) == "fooBar");
assert(is_subclass_of(new bar(), "foobar") == true);
?>

i run across this while migrating some code from php4 to php5 and the code would only half-the-time break.
up
-7
Ondra Zizka
17 years ago
For PHP4:

<?php
/** Returns whether specified class is subclass of the other class. */
function is_subclass($sClass, $sExpectedParentClass){
do if(
$sExpectedParentClass === $sClass ) return true;
while(
false != ($sClass = get_parent_class($sClass)) );
return
false;
}
// Test:
class A {} class B extends A {} class C extends B {} echo (int) is_subclass('C', 'A');
?>
To Top