Estoy construyendo una biblioteca ORM con la reutilización y la simplicidad en mente; todo va bien, excepto que me quedé atrapado por una estúpida limitación de herencia. Tenga en cuenta el siguiente código:

class BaseModel {
    /*
     * Return an instance of a Model from the database.
     */
    static public function get (/* varargs */) {
        // 1. Notice we want an instance of User
        $class = get_class(parent); // value: bool(false)
        $class = get_class(self);   // value: bool(false)
        $class = get_class();       // value: string(9) "BaseModel"
        $class =  __CLASS__;        // value: string(9) "BaseModel"

        // 2. Query the database with id
        $row = get_row_from_db_as_array(func_get_args());

        // 3. Return the filled instance
        $obj = new $class();
        $obj->data = $row;
        return $obj;
    }
}

class User extends BaseModel {
    protected $table = 'users';
    protected $fields = array('id', 'name');
    protected $primary_keys = array('id');
}
class Section extends BaseModel {
    // [...]
}

$my_user = User::get(3);
$my_user->name = 'Jean';

$other_user = User::get(24);
$other_user->name = 'Paul';

$my_user->save();
$other_user->save();

$my_section = Section::get('apropos');
$my_section->delete();

Obviamente, este no es el comportamiento que esperaba (aunque el comportamiento real también tiene sentido). Así que mi pregunta es si conocen un medio para obtener, en la clase principal, el nombre de la clase secundaria.

en breve. esto no es posible. en php4 podría implementar un truco terrible (examine el debug_backtrace()) pero ese método no funciona en PHP5. referencias:

• 30423

• 37684

• 34421

editar : un ejemplo de enlace estático tardío en PHP 5.3 (mencionado en los comentarios). tenga en cuenta que existen problemas potenciales en su implementación actual ( src ).

class Base {
    public static function whoAmI() {
        return get_called_class();
    }
}

class User extends Base {}

print Base::whoAmI(); // prints "Base"
print User::whoAmI(); // prints "User"

No necesita esperar PHP 5.3 si puede concebir una forma de hacerlo fuera de un contexto estático. En php 5.2.9, en un método no estático de la clase principal, puede hacer:

get_class($this);

y devolverá el nombre de la clase secundaria como una cadena.

es decir

class Parent() {
    function __construct() {
        echo 'Parent class: ' . get_class() . "\n" . 'Child class: ' . get_class($this);
    }
}

class Child() {
    function __construct() {
        parent::construct();
    }
}

$x = new Child();

esto dará como resultado:

Parent class: Parent
Child class: Child

dulce eh?

Sé que esta pregunta es realmente antigua, pero para aquellos que buscan una solución más práctica que definir una propiedad en cada clase que contiene el nombre de la clase:

Puede utilizar la staticpalabra clave para esto.

Como se explica en esta nota de colaborador en la documentación de php

la staticpalabra clave se puede utilizar dentro de una superclase para acceder a la subclase desde la que se llama a un método.

Ejemplo:

class Base
{
    public static function init() // Initializes a new instance of the static class
    {
        return new static();
    }

    public static function getClass() // Get static class
    {
        return static::class;
    }

    public function getStaticClass() // Non-static function to get static class
    {
        return static::class;
    }
}

class Child extends Base
{

}

$child = Child::init();         // Initializes a new instance of the Child class

                                // Output:
var_dump($child);               // object(Child)#1 (0) {}
echo $child->getStaticClass();  // Child
echo Child::getClass();         // Child

Sé que es una publicación anterior, pero quiero compartir la solución que encontré.

Probado con PHP 7+ Use el enlace de funciónget_class()

<?php
abstract class bar {
    public function __construct()
    {
        var_dump(get_class($this));
        var_dump(get_class());
    }
}

class foo extends bar {
}

new foo;
?>

El ejemplo anterior dará como resultado:

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

En caso de que no desee utilizar get_called_class (), puede utilizar otros trucos de enlace estático tardío (PHP 5.3+). Pero la desventaja en este caso es que debe tener el método getClass () en cada modelo. Lo cual no es gran cosa en mi opinión.

<?php

class Base 
{
    public static function find($id)
    {
        $table = static::$_table;
        $class = static::getClass();
        // $data = find_row_data_somehow($table, $id);
        $data = array('table' => $table, 'id' => $id);
        return new $class($data);
    }

    public function __construct($data)
    {
        echo get_class($this) . ': ' . print_r($data, true) . PHP_EOL;
    }
}

class User extends Base
{
    protected static $_table = 'users';

    public static function getClass()
    {
        return __CLASS__;
    }
}

class Image extends Base
{
    protected static $_table = 'images';

    public static function getClass()
    {
        return __CLASS__;
    }
}

$user = User::find(1); // User: Array ([table] => users [id] => 1)  
$image = Image::find(5); // Image: Array ([table] => images [id] => 5)

Parece que está intentando utilizar un patrón singleton como patrón de fábrica. Recomendaría evaluar sus decisiones de diseño. Si un singleton realmente es apropiado, también recomendaría usar solo métodos estáticos donde no se desee la herencia .

class BaseModel
{

    public function get () {
        echo get_class($this);

    }

    public static function instance () {
        static $Instance;
        if ($Instance === null) {
            $Instance = new self;

        }
        return $Instance;
    }
}

class User
extends BaseModel
{
    public static function instance () {
        static $Instance;
        if ($Instance === null) {
            $Instance = new self;

        }
        return $Instance;
    }
}

class SpecialUser
extends User
{
    public static function instance () {
        static $Instance;
        if ($Instance === null) {
            $Instance = new self;

        }
        return $Instance;
    }
}


BaseModel::instance()->get();   // value: BaseModel
User::instance()->get();        // value: User
SpecialUser::instance()->get(); // value: SpecialUser

Tal vez esto en realidad no esté respondiendo a la pregunta, pero podría agregar un parámetro para get () especificando el tipo. entonces puedes llamar

BaseModel::get('User', 1);

en lugar de llamar a User :: get (). Puede agregar lógica en BaseModel :: get () para verificar si existe un método get en la subclase y luego llamarlo si desea permitir que la subclase lo anule.

De lo contrario, la única forma en que puedo pensar, obviamente, es agregando cosas a cada subclase, lo cual es estúpido:

class BaseModel {
    public static function get() {
        $args = func_get_args();
        $className = array_shift($args);

        //do stuff
        echo $className;
        print_r($args);
    }
}

class User extends BaseModel {
    public static function get() { 
        $params = func_get_args();
        array_unshift($params, __CLASS__);
        return call_user_func_array( array(get_parent_class(__CLASS__), 'get'), $params); 
    }
}


User::get(1);

Esto probablemente se rompería si luego subclasificara Usuario, pero supongo que podría reemplazarlo get_parent_class(__CLASS__)con 'BaseModel'en ese caso

El problema no es una limitación de idioma, es tu diseño. No importa que tengas clases; los métodos estáticos desmienten un diseño procedimental más que orientado a objetos. También estás usando el estado global de alguna forma. (¿Cómo get_row_from_db_as_array()sabe dónde encontrar la base de datos?) Y finalmente parece muy difícil realizar pruebas unitarias.

Intente algo en este sentido.

$db = new DatabaseConnection('dsn to database...');
$userTable = new UserTable($db);
$user = $userTable->get(24);

Dos variaciones de la respuesta de Preston:

1)

class Base 
{
    public static function find($id)
    {
        $table = static::$_table;
        $class = static::$_class;
        $data = array('table' => $table, 'id' => $id);
        return new $class($data);
    }
}

class User extends Base
{
    public static $_class = 'User';
}

2)

class Base 
{
    public static function _find($class, $id)
    {
        $table = static::$_table;
        $data = array('table' => $table, 'id' => $id);
        return new $class($data);
    }
}

class User extends Base
{
    public static function find($id)
    {
        return self::_find(get_class($this), $id);
    }
}

Nota: comenzar el nombre de una propiedad con _ es una convención que básicamente significa "sé que hice esto público, pero realmente debería haber estado protegido, pero no pude hacer eso y lograr mi objetivo".