PHP 8.1.28 Released!

is_subclass_of

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

is_subclass_ofVerifica se o objeto tem esta classe como uma de suas classes pai

Descrição

is_subclass_of(mixed $object_or_class, string $class, bool $allow_string = true): bool

Verifica se object_or_class informado tem a classe class como uma de suas classes pai ou o/a implementa.

Parâmetros

object_or_class

O nome da classe ou um instância do objeto. Nenhum erro é gerado se a classe não existir.

class

O nome da classe

allow_string

Se este parâmetro for definido para falso, nome de classe em string no parâmetro object_or_class não será permitido. Isto também evita chamada ao carregamento automático se a classe não existir.

Valor Retornado

Esta função retorna true se o objeto object_or_class, pertencer a uma classe que é uma subclasse de class, false caso contrário.

Exemplos

Exemplo #1 Exemplo de is_subclass_of()

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

// define uma classe filha
class WidgetFactory_Child extends WidgetFactory
{
var
$oink = 'oink';
}

// cria um novo objeto
$WF = new WidgetFactory();
$WFC = new WidgetFactory_Child();

if (
is_subclass_of($WFC, 'WidgetFactory')) {
echo
"sim, \$WFC é uma subclasse de WidgetFactory\n";
} else {
echo
"não, \$WFC não é uma subclasse de WidgetFactory\n";
}


if (
is_subclass_of($WF, 'WidgetFactory')) {
echo
"sim, \$WF é uma subclasse de WidgetFactory\n";
} else {
echo
"não, \$WF não é uma subclasse de WidgetFactory\n";
}


if (
is_subclass_of('WidgetFactory_Child', 'WidgetFactory')) {
echo
"sim, WidgetFactory_Child é uma subclasse de WidgetFactory\n";
} else {
echo
"não, WidgetFactory_Child não é uma subclasse de WidgetFactory\n";
}
?>

O exemplo acima produzirá:

sim, $WFC é uma subclasse de WidgetFactory
não, $WF não é uma subclasse de WidgetFactory
sim, WidgetFactory_Child é uma subclasse de WidgetFactory

Exemplo #2 Exemplo de is_subclass_of() usando interface

<?php
// Define a Interface
interface MyInterface
{
public function
MyFunction();
}

// Define a implementação de classe da interface
class MyClass implements MyInterface
{
public function
MyFunction()
{
return
"MyClass Implementa MyInterface!";
}
}

// Instancia o objeto object
$my_object = new MyClass;

// Funciona desde 5.3.7

// Teste usando a instância do objeto da classe
if (is_subclass_of($my_object, 'MyInterface')) {
echo
"Sim, \$my_object é uma subclasse de MyInterface\n";
} else {
echo
"No, \$my_object não é uma subclasse de MyInterface\n";
}

// Teste usando a string do nome da classe
if (is_subclass_of('MyClass', 'MyInterface')) {
echo
"Sim, MyClass é uma subclasse de MyInterface\n";
} else {
echo
"No, MyClass não é uma subclasse de MyInterface\n";
}
?>

O exemplo acima produzirá:

Sim, $my_object é uma subclasse de MyInterface
Sim, MyClass é uma subclasse de MyInterface

Notas

Nota:

Usar esta função fará com que qualquer autoloader registrado seja usado se a classe ainda não for conhecida.

Veja Também

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
21 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