PHP：从另一个对象调用对象方法的最佳方式？

Question

我正在寻找从另一个类调用类方法的最佳方式，而不必使用 Global 来获取类实例，因为我现在明白“全局是邪恶的”！

这里有一些代码来解释它：

class Assets{
 public $assets = array();
 public function add($asset){
  $this->assets[] = $asset;
 }
}

现在我想在这里调用 Assets/call 方法 ..

$assets = new Assets;
class Form{
 public function __construct(){
  global $assets;
  $assets->add('Form');
 }
}

在这种情况下使用 Global 是不是很糟糕？如果是这样，还有什么其他方式被认为是最好的？

PS：我只需要使用该类的一个实例；意味着我不想在第二个类中创建一个新实例。

Answer 1

怎么样

<?php
class Assets
{
    protected static $assets = array();

    protected function add($el)
    {
        self::$assets[] = $el;
    }

    public function getAssets()
    {
        return self::$assets;
    }
}

class Form extends Assets
{
    public function __construct()
    {
        parent::add('Form');
    }
}

class Css extends Assets
{
    public function __construct()
    {
        parent::add('Style');
    }
}

$assets = new Assets;
new Form;
new Css;
var_dump($assets->getAssets()); // Prints: array(2) { [0]=> string(4) "Form" [1]=> string(5) "Style" }

Answer 2

依赖注入是要走的路。我将使用这个 Factory mechanize 将对象实例传递给另一个对象。如（只是一个样本，没有测试它）：

class UI{

public $somthing = 'Cool';

public function newComponent($name){
    return new $name($this);
}

}

$ui = new UI;
class Form{
    public $ui;

    public function __construct(UI $ui){
        $this->ui = $ui;
    }

    public function say(){
        print $this->ui->somthing;
    }
}

$form = $ui->newComponent('Form');

$form->say(); // print 'Cool'.

Answer 3

我没有直接用提供的元素来回答这个问题，我只是展示了一种在对象之间共享数据而不使用全局变量的方法。

class A {

    private $v;

    function __construct ($value)
    {
        $this->v = $value;
    }

    function set_v ($value)
    {
        $this->v = $value;
    }

    function print_v ()
    {
        echo $this->v;
    }

}

.

class B {

    private $a;

    function __construct (&$tha)
    {
        if ($tha) {
          $this->a = $tha;
        }
    }

    function print_a ()
    {
        echo $this->a->print_v();
    }
}

.

$mya = new A(12);
$mya->print_v(); // echo 12
$myb = new B($mya);
$mya->set_v(13); 
$myb->print_a(); // echo 13

您可以在另一个对象中保留一个对象的痕迹，并尊重对象的封装。 但是，如果 A 的一个实例被删除，B 的一个实例可能变得不可靠。然后，您应该确保数据在存储它的对象中始终是可靠的（例如，创建一个验证内部数据是否正常的方法）。

正如 tereško 所注意到的，应避免显式等待引用的参数。事实上，自 PHP 5.0 起，语言中引入了一个新特性，称为类型提示。这可以防止您的程序出现不希望的内存行为，并且可以在编译级别监控任何错误匹配（更多详细信息请参阅Type Hinting (PHP official documentation)）

因此

function __construct (&$tha) ...

必须重新定义为

function __construct (A $tha) ..

在示例中。

Answer 4

如果在您的上下文中有意义，您也可以将 Assets 设为 singleton：

class Assets
{
    /////////////////////
    // Your stuff      //
    /////////////////////

    private $assets = array();
    public function add($asset)
    {
        $this->assets[] = $asset;
    }

    /////////////////////
    // Singleton stuff //
    /////////////////////

    static private $instance = null;
    static public function getInstance()
    {
        if(self::$instance == null)
            self::$instance = new self;
        return self::$instance;
    }

    // To restrict construction of this class outside of this class definition
    private function __construct() {}

    // To restrict cloning of this class outside of this class definition
    private function __clone() {}
}

在您的其他代码中，您会像这样使用单例：

class Form
{
    public function __construct()
    {
        Assets::getInstance()->add('Form');
    }
}

Answer 5

你可以试试这个，

class Form{
 public function __construct(Assets $assets){
  //$assets = new Assets;
  $assets->add('Form');
 }
}

Answer 6

如果您只想拥有 1 个资产实例，则需要使用某种形式的依赖注入。

在这种情况下，最明显的是通过构造函数传递它：

class Form{
 public function __construct(Assets $assets){
  $assets->add('Form');
 }
}

使用全局变量确实是个坏主意。