get_called_class

(PHP 5 >= 5.3.0, PHP 7, PHP 8)

get_called_classO nome da classe da qual o método estático foi chamado

Descrição

get_called_class(): string

Obtém o nome da classe da qual o método estático foi chamado.

Parâmetros

Esta função não possui parâmetros.

Valor Retornado

Retorna o nome da classe.

Erros/Exceções

Se get_called_class() for chamada de fora de uma classe, um Error é disparado. Antes do PHP 8.0.0, um aviso E_WARNING era emitido.

Registro de Alterações

Versão Descrição
8.0.0 Chamar esta função de fora de uma classe agora irá disparar um Error. Anteriormente, um aviso E_WARNING era emitido e a função retornava false.

Exemplos

Exemplo #1 Usando get_called_class()

<?php

class foo {
static public function
test() {
var_dump(get_called_class());
}
}

class
bar extends foo {
}

foo::test();
bar::test();

?>

O exemplo acima produzirá:

string(3) "foo"
string(3) "bar"

Veja Também

add a note add a note

User Contributed Notes 9 notes

up
71
Safak Ozpinar
9 years ago
As of PHP 5.5 you can also use "static::class" to get the name of the called class.

<?php
class Bar {
    public static function
test() {
       
var_dump(static::class);
    }
}

class
Foo extends Bar {

}

Foo::test();
Bar::test();
?>

Output:

string(3) "Foo"
string(3) "Bar"
up
13
uebele
12 years ago
SEE: http://php.net/manual/en/language.oop5.late-static-bindings.php

I think it is worth mentioning on this page, that many uses of the value returned by get_called_function() could be handled with the new use of the old keyword static, as in
<?php
static::$foo;
?>

versus
<?php
$that
=get_called_class();
$that::$foo;
?>

I had been using $that:: as my conventional replacement for self:: until my googling landed me the url above.  I have replaced all uses of $that with static with success both as
<?php
static::$foo; //and...
new static();
?>

Since static:: is listed with the limitation: "Another difference is that static:: can only refer to static properties." one may still need to use a $that:: to call static functions; though I have not yet needed this semantic.
up
10
luc at s dot illi dot be
11 years ago
get_called_class() in closure-scopes:

<?PHP
   
ABSTRACT CLASS Base
   
{
        protected static
$stub = ['baz'];
       
       
//final public function boot()
       
static public function boot()
        {
            print
__METHOD__.'-> '.get_called_class().PHP_EOL;
           
           
array_walk(static::$stub, function()
            {
                print
__METHOD__.'-> '.get_called_class().PHP_EOL;
            });
        }
       
        public function
__construct()
        {
           
self::boot();
            print
__METHOD__.'-> '.get_called_class().PHP_EOL;
           
           
array_walk(static::$stub, function()
            {
                print
__METHOD__.'-> '.get_called_class().PHP_EOL;
            });
        }
    }
   
    CLASS
Sub EXTENDS Base
   
{
    }
   
   
// static boot
       
Base::boot(); print PHP_EOL;
           
// Base::boot        -> Base
            // Base::{closure}    -> Base
           
       
Sub::boot(); print PHP_EOL;
           
// Base::boot        -> Sub
            // Base::{closure}    -> Base
           
       
new sub;
           
// Base::boot        -> Sub
            // Base::{closure}    -> Base
            // Base->__construct    -> Sub
            // Base->{closure}    -> Sub
   
    // instance boot
       
new sub;
           
// Base->boot        -> Sub
            // Base->{closure}    -> Sub
            // Base->__construct    -> Sub
            // Base->{closure}    -> Sub
?>
up
3
fantomx1 at gmail dot com
6 years ago
When calling dynamic method statically in php 5.6 (under 7) it allows it, but it doesnt work, it incorrectly evaluates class that called our subject class, therefore containing method must be static.
up
9
danbettles at yahoo dot co dot uk
15 years ago
It is possible to write a completely self-contained Singleton base class in PHP 5.3 using get_called_class.

<?php

abstract class Singleton {

    protected function
__construct() {
    }

    final public static function
getInstance() {
        static
$aoInstance = array();

       
$calledClassName = get_called_class();

        if (! isset (
$aoInstance[$calledClassName])) {
           
$aoInstance[$calledClassName] = new $calledClassName();
        }

        return
$aoInstance[$calledClassName];
    }

    final private function
__clone() {
    }
}

class
DatabaseConnection extends Singleton {

    protected
$connection;

    protected function
__construct() {
       
// @todo Connect to the database
   
}

    public function
__destruct() {
       
// @todo Drop the connection to the database
   
}
}

$oDbConn = new DatabaseConnection();  // Fatal error

$oDbConn = DatabaseConnection::getInstance();  // Returns single instance
?>
up
2
php at itronic dot at
14 years ago
If you call a static getInstance() function to create a instance of a class from another class, this function have to be static, if it is not static the original name of the caller class and not of the current class get returned.

example:

<?php

class a {
  function
getXName() {
     return
x::getClassName();
  }
  function
getXStaticName() {
     return
x::getStaticClassName();
  }

}

class
b extends a {
}

class
x {
  public function
getClassName() {
    return
get_called_class();
  }
  public static function
getStaticClassName() {
    return
get_called_class();
  }
}

$a = new a();

$b = new b();

echo
$a->getXName(); // will return "a"
echo $b->getXName(); // will return "b"

echo $a->getXStaticName(); // will return "x"
echo $b->getXStaticName(); // will return "x"

?>
up
0
amcolin at 126 dot com
3 years ago
namespace root;
class Factor {
    protected static $instance = null;

    private function __construct() {

    }

    public static function getInstance() {
        if (!self::$instance) {
            $name           = get_called_class();
            self::$instance = new $name();
        }

        return self::$instance;
    }
}

namespace admin\test;

use root\Factor;

class Single extends Factor {
    public function abc() {
        return 'abc';
    }
}

namespace index;

use admin\test\Single;

class Index {
    public function get() {
        return Single::getInstance();
    }
}

$index = new Index();
var_dump($index->get());

The result is:

object(admin\test\Single)#2 (0) {
}
up
-4
Abhi Beckert
14 years ago
Beware that this does not behave as expected if your method is not declared as static! For example:

<?php

class foo {
  static public function
test() {
   
var_dump(get_called_class());
  }
 
  public function
testTwo() {
   
var_dump(get_called_class());
  }
}

class
bar extends foo {
}

class
abc {
  function
test() {
   
foo::test();
   
bar::test();
  }
 
  function
testTwo() {
   
foo::testTwo();
   
bar::testTwo();
  }
}

echo
"basic\n";
foo::test();
bar::test();

echo
"basic without static declaration\n";
foo::testTwo();
bar::testTwo();

echo
"in a class\n";
$abc = new abc();
$abc->test();

echo
"in a class without static declaration\n";
$abc->testTwo();

?>

The result is:

basic
string 'foo'
string 'bar'

basic without static declaration
string 'foo'
string 'bar'

in a class
string 'foo'
string 'bar'

in a class without static declaration
string 'abc'
string 'abc'
up
-4
a dot cudbard-bell at sussex dot ac dot uk
15 years ago
Here's a simple way of getting the inheritance tree of a class, no matter which class the function was actually defined in. Will work as a static function method too.

<?php
class A {
    public function
get_class_tree(){
       
$cur_class = get_called_class();
        do {
            echo
$cur_class;           
        }
        while(
$cur_class = get_parent_class($cur_class));
    }
}

class
B {

}

class
C {

}

$foo = new C();
$foo->get_class_tree();

?>

CBA
To Top