Fatal编程技术网
  • php/
  • Php 哪种方法在构造类时更有效？

Php 哪种方法在构造类时更有效？

php class oop dependency-injection

Php 哪种方法在构造类时更有效？,php,class,oop,dependency-injection,Php,Class,Oop,Dependency Injection,对于数据库中的每一个记录，我都实例化一个类。在那个班里我叫另一个班 例子 上面的代码是我目前正在做的。然而，我想知道下面是否会更好： $records = array(...); $b = new B(); foreach ($records as $record) { $a = new A($b); $data = $a->doSomething($record); } class A { protected $b; public function __

对于数据库中的每一个记录，我都实例化一个类。在那个班里我叫另一个班

例子 上面的代码是我目前正在做的。然而，我想知道下面是否会更好：

$records = array(...);
$b = new B();
foreach ($records as $record) {
    $a = new A($b);
    $data = $a->doSomething($record);
}

class A {
    protected $b;
    public function __construct($b)
    {
        $this->b = $b;
    }

    public function doSomething($param)
    {
        return $this->b->doSomething($param);
    }
}
我想知道的是，这是否有效，这些选项中的哪一个更好，以及是否有其他更好的解决方案。

免责声明：不是PHP开发人员，但我对OOP的理解足以回答这个问题

选择2更好

这实际上不是一个效率问题，而是一个称为依赖注入的最佳实践问题

对于选项2，
A
声明它需要一个
$b
来创建自己。这使您能够在实例化
A
的任何地方用所需的任何东西替换
$b
的实例，并且通过使每段代码的要求更清晰，使代码更易于维护。这很好，因为
A
不关心
B
是否工作，以便
A
工作。它只处理注入类。。可以是也可以不是
B
-作为黑匣子。它是松散耦合的，只依赖于
B
的接口，而不是实现

使用选项1，可以在类中实例化
B
。这个很好用。。。直到你想测试你的代码。或者在运行时更改
B
。然后它变得非常脆弱。因为每次你想更改
A
时，你现在必须更改
B
。这意味着
A
现在与
B
紧密耦合，这本质上意味着
A
的工作也取决于
B
的工作-这不是很容易维护，因为您的应用程序本质上变成了一个纸牌屋

TLDR-始终使用选项2。这不是效率问题，而是可维护性问题。

免责声明：不是PHP开发人员，但我对OOP的理解足以回答这个问题

选择2更好

这实际上不是一个效率问题，而是一个称为依赖注入的最佳实践问题

对于选项2，
A
声明它需要一个
$b
来创建自己。这使您能够在实例化
A
的任何地方用所需的任何东西替换
$b
的实例，并且通过使每段代码的要求更清晰，使代码更易于维护。这很好，因为
A
不关心
B
是否工作，以便
A
工作。它只处理注入类。。可以是也可以不是
B
-作为黑匣子。它是松散耦合的，只依赖于
B
的接口，而不是实现

使用选项1，可以在类中实例化
B
。这个很好用。。。直到你想测试你的代码。或者在运行时更改
B
。然后它变得非常脆弱。因为每次你想更改
A
时，你现在必须更改
B
。这意味着
A
现在与
B
紧密耦合，这本质上意味着
A
的工作也取决于
B
的工作-这不是很容易维护，因为您的应用程序本质上变成了一个纸牌屋

TLDR-始终使用选项2。这不是效率问题，而是可维护性问题。

免责声明：不是PHP开发人员，但我对OOP的理解足以回答这个问题

选择2更好

这实际上不是一个效率问题，而是一个称为依赖注入的最佳实践问题

对于选项2，
A
声明它需要一个
$b
来创建自己。这使您能够在实例化
A
的任何地方用所需的任何东西替换
$b
的实例，并且通过使每段代码的要求更清晰，使代码更易于维护。这很好，因为
A
不关心
B
是否工作，以便
A
工作。它只处理注入类。。可以是也可以不是
B
-作为黑匣子。它是松散耦合的，只依赖于
B
的接口，而不是实现

使用选项1，可以在类中实例化
B
。这个很好用。。。直到你想测试你的代码。或者在运行时更改
B
。然后它变得非常脆弱。因为每次你想更改
A
时，你现在必须更改
B
。这意味着
A
现在与
B
紧密耦合，这本质上意味着
A
的工作也取决于
B
的工作-这不是很容易维护，因为您的应用程序本质上变成了一个纸牌屋

TLDR-始终使用选项2。这不是效率问题，而是可维护性问题。

免责声明：不是PHP开发人员，但我对OOP的理解足以回答这个问题

选择2更好

这实际上不是一个效率问题，而是一个称为依赖注入的最佳实践问题

对于选项2，
A
声明它需要一个
$b
来创建自己。这使您能够在实例化
A
的任何地方用所需的任何东西替换
$b
的实例，并且通过使每段代码的要求更清晰，使代码更易于维护。这很好，因为
A
不关心
B
是否工作，以便
A
工作。它只处理注入类。。可以是也可以不是
B
-作为黑匣子。它是松散耦合的 
$records = array(...);
$b = new B();
foreach ($records as $record) {
    $a = new A($b);
    $data = $a->doSomething($record);
}

class A {
    protected $b;
    public function __construct($b)
    {
        $this->b = $b;
    }

    public function doSomething($param)
    {
        return $this->b->doSomething($param);
    }
}