哪种方法构造类的效率更高?
Which method is more efficient in constructing classes?
对于我数据库中的每条记录,我都实例化了一个 class。在那个 class 里面我叫另一个 class.
例子
$records = array(...);
foreach ($records as $record) {
$a = new A();
$data = $a->doSomething($record);
}
class A {
protected $b;
public function __construct()
{
$this->b = new B();
}
public function doSomething($param)
{
return $this->b->doSomething($param);
}
}
上面的代码是我目前的做法。但是我想知道下面是否会更好:
$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
有效。它只是将注入的 class.. 视为黑匣子,这可能是也可能不是 B
。它是松散耦合,只依赖于B
的接口,而不是实现。
使用选项 1,您在 class 中实例化 B
。这工作正常......直到你想测试你的代码。或者在运行时更改 B
。然后它变得非常脆弱。因为每次您想更改 A
,您现在都必须更改 B
。这意味着 A
现在 与 B
紧密耦合 ,这实际上意味着要使 A
正常工作,它还取决于 B
工作 - 这不是很容易维护,因为你的应用程序基本上变成了纸牌屋。
TLDR - 始终选择选项 2。这不是效率问题,而是可维护性问题。
对于我数据库中的每条记录,我都实例化了一个 class。在那个 class 里面我叫另一个 class.
例子
$records = array(...);
foreach ($records as $record) {
$a = new A();
$data = $a->doSomething($record);
}
class A {
protected $b;
public function __construct()
{
$this->b = new B();
}
public function doSomething($param)
{
return $this->b->doSomething($param);
}
}
上面的代码是我目前的做法。但是我想知道下面是否会更好:
$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
有效。它只是将注入的 class.. 视为黑匣子,这可能是也可能不是 B
。它是松散耦合,只依赖于B
的接口,而不是实现。
使用选项 1,您在 class 中实例化 B
。这工作正常......直到你想测试你的代码。或者在运行时更改 B
。然后它变得非常脆弱。因为每次您想更改 A
,您现在都必须更改 B
。这意味着 A
现在 与 B
紧密耦合 ,这实际上意味着要使 A
正常工作,它还取决于 B
工作 - 这不是很容易维护,因为你的应用程序基本上变成了纸牌屋。
TLDR - 始终选择选项 2。这不是效率问题,而是可维护性问题。