2

我想在 PHP 中延迟加载类的公共数据成员。假设我们有以下类：

<?php
class Dummy
{
    public $name;
    public $age;
    public $status_indicator;
}
?>

如果$name, $ageand$status_indicator是私有数据成员，我会通过他们的 getter 方法延迟加载它们，但由于它们是公共的 - 我不清楚如何延迟加载它们。这可能吗？

编辑：有人评论说有一种方法__get可能有助于解决这个问题，但我不明白。

4

9 回答 9

2

您可以__get用来模拟在首次访问时真正动态加载的公共成员。当您尝试访问对象的未定义成员时，PHP 将调用__get并将您尝试访问的成员的名称传递给它。例如，如果类已经定义了一个方法，访问$x->my_variable将调用。__get("my_variable")__get_

在此示例中，$dummy->name间接调用 getter 方法getName，该方法初始化一个名为$_nameon first access 的私有成员：

<?php
class Dummy
{
  private $_name;

  public function __get($var) {
    if ($var == 'name') {
      return $this->getName();
    } else if ($var == 'age') {
      // ...
    } else {
      throw "Undefined variable $var";
    }
  }

  public function getName() {
    if (is_null($this->_name)) {
      // Initialize and cache the value for $name
      $this->_name = expensive_function();
    }
    return $this->_name;
  }
}

$dummy = new Dummy();
echo $dummy->name;

您可以类似地定义和调用其他访问器，例如getAge.

于 2012-05-17T17:51:49.960 回答
1

这是我在最近的一个项目中使用的一些代码：

class EnhancedObject {
    #Store cached properties here
    private $lazyProperties = array();

    #Allow $object->prop to alias to $object->getProperty().
    #Also, allow caching of $object->loadProp() to $object->prop
    public function __get($property) {
        $getter = "get".ucfirst($property);
        $loader = "load".ucfirst($property);

        if(method_exists($this, $getter)) {
            return $this->$getter();
        }
        elseif(method_exists($this, $loader)) {
            if(!isset($this->lazyProperties[$property])) {
                $this->lazyProperties[$property] = $this->$loader();
            }
            return $this->lazyProperties[$property];
        }
    }

    #Allow $object->prop = $value to alias to $object->setProperty($value).
    public function __set($property, $value) {
        $setter = "set".ucfirst($property);
        $loader = "load".ucfirst($property);

        if (method_exists($this, $setter)) {
            return $this->$setter($value);
        }
        elseif(method_exists($this, $loader)) {
            $this->lazyProperties[$property] = $value;
        }
        return $this;
    }
}

这意味着您只需将魔法弄乱一次，__get然后set简单地为您的方法命名正确的东西将使它们表现为 getter、setter 和惰性初始化器。

用法

class Dummy extends EnhancedObject {
    public $name;
    public $age;

    #Complex getters
    public function getSummary() {
        return "{$this->name}, aged {$this->age}";
    }

    #Cached getters for expensive operations
    public function loadStatusCount($id) {
        doExpensiveStuff();
        return 42;
    }
}

$d = new Dummy();
$d->name = "John Doe"
$d->age = 35

#getters
echo $d->summary; # echos "John Doe, aged 35"

#Lazy-initialized properties
echo $d->statusCount; # runs `doExpensiveStuff()`, echoing 42
echo $d->statusCount; # echos 42
echo $d->statusCount; # echos 42
于 2012-05-17T17:51:54.737 回答
0

我认为拥有这样的“延迟加载属性”并不是很好的编码风格。如果您需要一些延迟加载值，只需使用没有任何公共属性的 get 方法。

但是我喜欢这个问题:) 我也喜欢大多数解决方案，但我也想在这里添加我的通用解决方案：

class Dummy
{
    private $_name;
    private $_age;
    private $_number_of_status;

    public function __get($name) {
        $var = "_".$name;
        $lazyLoadingMethod = "_load_".$name;
        if (!method_exists($this, $lazyLoadingMethod )) {
            trigger_error("Cannot access private property Dummy::$$name", E_USER_ERROR);
            return;
        }
        if (!isset($this->$var)) {
            $this->$var = $this->$lazyLoadingMethod();
        }
        return $this->$var;
    }

    public function __set($name, $value) {
        $var = "_".$name;
        $settingMethod = "_set_".$name;
        if (!method_exists($this, $settingMethod )) {
            trigger_error("Cannot access private property Dummy::$$name", E_USER_ERROR);
        } else {
            $this->$settingMethod($value);
        }
    }

    public function _load_age() {
        // lazy load here
        return 42;
    }

    public function _set_name($name) {
        echo "my new name is $name";
        $this->_name = $name;
    }
}

使用这个类，您甚至可以为您的属性提供读/写机制，因此“年龄”可以读取但不能设置，“姓名”可以设置但不能读取：

$d = new Dummy();
echo $d->age; //=> 42
$d->name = "Jon"; //my new name is Jon
echo $d->name; //=> Fatal error: Cannot access private property Dummy::$name in ...
$d->age = 100; //=> Fatal error: Cannot access private property Dummy::$age in ...
于 2012-11-05T18:54:00.617 回答
0

使用__get() http://us.php.net/manual/en/language.oop5.overloading.php

public function __get($name)
{
    if ($name == "age" and $this->age == null)) {
        // lazy load $this->age
        return $this->age;
    }

    return $this->$name;
}
于 2012-05-17T17:54:20.680 回答
0

首先：这正是您应该使用 getter/setter 方法的原因。这样，您可以在检索数据的过程中添加额外的逻辑。

下面是一个如何使用 __get() 实现类公共成员访问的示例：

class Dummy {
    private $lazyMembers = array(
        'name' => 'NameOfTheClass'
    );

    public function __get($key) {
        if (isset($this->lazyMembers[$key])) {
            $obj = new $this->lazyMembers[$key]();
            $this->$key = $obj;
            return $obj;
        }

        // ..throw exception or whatever
    }
}
于 2012-05-17T17:54:27.707 回答
0

为了扩展评论，您可以使用一个字段数组和一个小魔术方法来处理加载操作：

<?php
class Dummy
{
    protected $fields = array(
        'name' => null, 
        'age' => null,
        'etc' => null
    );

    public function __get ($key) {
        if (array_key_exists($key, $this->fields)) {
            if ($this->fields[$key] === null) {
                // do some kind of loading operation to set $value
                $this->fields[$key] = $value;
            }
            return $this->fields[$key];
        }
        return null;
    }
}
?>
于 2012-05-17T17:52:03.023 回答
0

您可以简单地删除它们并使用魔术方法__get()

就像是：

class Dummy 
{ 
   public function __get($var_name) 
   {
      switch ($var_name) 
      {
        case 'name':
            // lazy load here
            return $val;
            break;

        case 'age':
            // lazy load here
            return $val;
            break;

        case 'number_of_status':
            // lazy load here
            return $val;
            break;
      }
   }
}
于 2012-05-17T17:53:17.773 回答
0

使用与 OP 相同的示例，您不能像保护/私有那样延迟加载公共成员。有几种解决方法，就像提到的 OP，使用 getter 方法来执行延迟加载逻辑。__get()不适用于同一类的公共成员，因为__get()永远不会调用对成员的直接访问。将它们隐藏在数组中将使方法__get或getter方法起作用，但这与将它们从公共可见性中删除基本相同，这显然是您要避免的。

于 2012-05-17T17:57:47.590 回答
0

据我了解您的问题，您想知道是否可以重载公共变量。

您已经知道 __get($name) 魔术方法，对吧？或者，也许您在谈论getName()、getAge()和 *getStatus_Indicator()*。

在任何情况下，作为公共属性，您都无法使用魔术方法。

我将仅列出它们以进行概念验证。

示例 1

<?php

class Dummy {
    public $name;
    public $age;
    public $status_indicator;

    public function __construct() {
        foreach($this AS $name => $value) {
            $this->$name = new LazyLoader($this, $name);
        }
    }
}



class LazyLoader {
    protected $object;
    protected $name;

    public function __construct($object, $name) {
        $this->object = $object;
        $this->name = $name;
    }
    public function load() {
        /* find the necessary $data somehow */
        $name = $this->name;
        $this->object->$name = $data;
        /*
           after the first call to LazyLoader::load
           the property no longer points to a LazyLoad
           object, but to the intended value
        */
    }
    public function __toString() {
        return($this->load());
    }
}

?>

示例 2

<?php

class LazyCollectionWrapper extends ArrayObject {
    public function __construct($objects = array()) {
        parent::__construct($objects);
    }

    public function offsetGet($offset) {
        $this->collection[$offset]->lazyLoad();
        return($this->collection[$offset]);
    }
}

class Dummy {
    public $name;
    public $age;
    public $status_indicator;

    public function lazyLoad() {
        /* load stuff here */
    }
}

?>

示例 3

<?php

class Dummy {
    public function __get() {
        /*
          load stuff here because undefined
          properties are caught by __get too
        */
    }
}

?>

示例 3 关于结构的信息最少，但就内存而言，这是最好的方法。我们在谈论延迟加载的东西......即不将无用的东西加载到内存中，对吗？

我这样说是因为：

class x { protected $var1 = array(); protected $var2 = 0.0; }

比吃掉更多的内存

class x { protected $var1; protected $var2; }

甚至超过

class x { }

我通过构建数百万个对象并比较峰值内存使用情况对其进行了测试。

于 2012-05-17T18:21:12.027 回答