107

我正在构建一个考虑重用和简单性的 ORM 库；一切都很好，除了我被一个愚蠢的继承限制卡住了。请考虑以下代码：

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

显然，这不是我所期望的行为（尽管实际行为也很有意义）。所以我的问题是你们是否知道在父类中获取子类名称的方法。

4

9 回答 9

202

如果您能够想出一种在静态上下文之外执行此操作的方法，则无需等待 PHP 5.3。在 php 5.2.9 中，在父类的非静态方法中，您可以执行以下操作：

get_class($this);

它会将子类的名称作为字符串返回。

IE

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

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

$x = new Child();

这将输出：

Parent class: Parent
Child class: Child

甜吗？

于 2009-07-22T16:43:09.327 回答
109

简而言之。这是不可能的。在 php4 中，您可以实现一个可怕的 hack（检查debug_backtrace()），但该方法在 PHP5 中不起作用。参考：

编辑：PHP 5.3 中后期静态绑定的示例（在评论中提到）。请注意，它的当前实现（ 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"
于 2008-11-12T04:58:55.563 回答
27

我知道这个问题真的很老，但是对于那些寻找比在包含类名的每个类中定义属性更实用的解决方案的人：

您可以static为此使用关键字。

如php 文档中的此贡献者说明中所述

static可以在超类中使用关键字来访问调用方法的子类。

例子：

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
于 2018-04-15T21:39:48.497 回答
20

我知道它的旧帖子，但想分享我找到的解决方案。

使用 PHP 7+ 测试 使用函数get_class()链接

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

class foo extends bar {
}

new foo;
?>

上面的示例将输出：

string(3) "foo"
string(3) "bar"
于 2018-12-30T22:27:12.223 回答
6

如果您不想使用 get_call_class() ，您可以使用后期静态绑定的其他技巧（PHP 5.3+）。但在这种情况下，您需要在每个模型中都有 getClass() 方法。这不是什么大不了的海事组织。

<?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)
于 2010-06-13T16:39:16.400 回答
2

看来您可能正在尝试将单例模式用作工厂模式。我建议评估您的设计决策。如果单例确实合适，我还建议仅在不需要继承的情况下使用静态方法。

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
于 2008-11-12T06:00:02.070 回答
2

也许这实际上并没有回答问题，但您可以添加一个参数来指定类型的 get()。然后你可以打电话

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

而不是调用 User::get()。您可以在 BaseModel::get() 中添加逻辑以检查子类中是否存在 get 方法，然后在您希望允许子类覆盖它时调用该方法。

否则我能想到的唯一方法显然是向每个子类添加东西，这很愚蠢：

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

如果您随后将用户子类化，这可能会中断，但我想您可以在这种情况下替换get_parent_class(__CLASS__)为'BaseModel'

于 2008-11-12T11:45:44.010 回答
0

问题不是语言限制，而是您的设计。别介意你有课；静态方法掩盖了过程而不是面向对象的设计。您还以某种形式使用全局状态。（怎么get_row_from_db_as_array()知道在哪里可以找到数据库？）最后，单元测试看起来非常困难。

沿着这些思路尝试一些东西。

$db = new DatabaseConnection('dsn to database...');
$userTable = new UserTable($db);
$user = $userTable->get(24);
于 2008-11-15T07:23:44.047 回答
0

普雷斯顿回答的两种变体：

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

注意：以 _ 开头的属性名称是一种约定，基本上意味着“我知道我公开了它，但它确实应该受到保护，但我无法做到这一点并实现我的目标”

于 2011-01-18T20:38:32.730 回答