Obtenir le nom d'un enfant de la classe dans la classe parent (contexte statique)

en bref. ce n'est pas possible. en php4 vous pourriez mettre en œuvre une terrible hack (examiner la debug_backtrace()), mais cette méthode ne fonctionne pas en PHP5. références:

• Trente mille quatre cent vingt trois

• Trente sept mille six cent quatre vingt quatre

• Trente quatre mille quatre cent vingt et un

modifier: un exemple de late static binding en PHP 5.3 (mentionné dans les commentaires). remarque: il existe des problèmes potentiels dans la mise en œuvre (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"

Je sais que cette question est vraiment vieux, mais pour ceux qui recherchent une solution plus pratique que de définir une propriété dans chaque classe contenant le nom de la classe:

Vous pouvez utiliser le static mot-clé pour cette.

Comme expliqué dans ce contributeur note dans la documentation de php

la static mot-clé peut être utilisé à l'intérieur d'une super classe pour accéder à la sous-classe à partir de laquelle une méthode est appelée.

Exemple:

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

Dans le cas où vous ne souhaitez pas utiliser get_called_class (), vous pouvez utiliser d'autres astuces de late static binding (PHP 5.3+). Mais l'inconvénient dans ce cas, vous avez besoin de la méthode getClass() dans chaque modèle. Ce qui n'est pas une grosse affaire de l'OMI.

<?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)

Peut-être que ce n'est pas réellement répondre à la question, mais vous pouvez ajouter un paramètre get() en spécifiant le type. ensuite, vous pouvez appeler

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

à la place de l'Utilisateur appelant::get(). Vous pouvez ajouter la logique dans BaseModel::get() pour vérifier si une méthode existe dans la sous-classe, et ensuite appeler que si vous voulez permettre à la sous-classe pour le remplacer.

Sinon la seule façon que je peux penser à est de toute évidence en ajoutant des trucs à chaque sous-classe, ce qui est stupide:

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);

Ce serait probablement se briser si vous puis de sous-classé Utilisateur, mais je suppose que vous pourriez remplacer get_parent_class(__CLASS__) avec 'BaseModel' dans ce cas

Deux variations sur Preston réponse:

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);
    }
}

Remarque: à partir d'un nom de propriété avec _ est une convention qui signifie "je sais que j'ai fait ce public, mais il ne devrait vraiment avoir été protégé, mais je ne pouvais pas le faire et à atteindre mon objectif"