优化 PHP 构造函数：减少冗余代码的实用技巧

本文针对 PHP 类构造函数中大量同类型变量声明导致的冗余问题，提出了两种有效的解决方案。首先，通过将相关属性分组到单独的对象中，可以简化构造函数的参数列表，提高代码的可读性和可维护性。其次，引入 UserBuilder 模式，允许逐步构建对象，并处理可选参数，从而进一步减少构造函数的复杂性。此外，还强调了重新评估类设计的重要性，避免类承担过多的职责。

在 PHP 中，当类的构造函数需要初始化大量属性，特别是当这些属性类型相同时（例如，都是数组），代码会变得冗长且难以维护。本文将介绍两种有效的方法来减少这种冗余，并提供更清晰、更易于管理的代码结构。

方法一：属性分组

当构造函数包含大量属性时，可以考虑将相关属性分组到单独的对象中。这样做可以减少构造函数的参数数量，并提高代码的可读性。

例如，假设有一个 User 类，它包含大量的数组属性：

立即学习“PHP免费学习笔记（深入）”；

class User {
    public function __construct(
        private $groupData = array(),
        private $nameData = array(),
        private $nameSData = array(),
        private $OData = array(),
        private $uwoData = array(),
        private $lReq = array(),
        private $lReqB = array(),
        private $lReqC = array(),
        private $nameMData = array(),
        private $typeData = array(),
        private $equipamiento = array(),
        private $equip = array(),
        private $brandData = array(),
        private $provData = array(),
        private $typeData2 = array(),
        private $lSol = array(),
        private $lSolP = array(),
        private $officS = array(),
        private $officeG = array(),
        private $lReqFO = array(),
        private $reporta_fallo = array(),
        private $rFallo = array(),
        private $lFalloFO = array(),
        private $sTypeData = array(),
        private $equipFID = array(),
        private $lReqPFO = array(),
        private $lFalloPFO = array(),
        private $lEquipFO = array(),
        private $lSolSP = array(),
        private $lSolS = array(),
        private $lSolFID = array(),
        private $lReqCID = array(),
        private $OSData = array(),
        private $equipFAO = array(),
        private $officeFS = array(),
        private $lReqSA = array(),
        private $lReqA = array(),
        private $lTypeFID = array(),
        private $lReqCA = array(),
        private $lTypeS = array(),
        private $depData = array(),
        private $lNext = array(),
        private $lReqBA = array()
    ) {}
}

我们可以将相关的属性分组到单独的类中，例如 ProfileData 和 ContactData：

Dreamhouse AI

AI室内设计，快速重新设计你的家，虚拟布置家具

下载

class ProfileData
{
  private string $image;
  private int $backgroupColor;

  public function __construct(string $image, int $backgroupColor) {
    $this->image = $image;
    $this->backgroupColor = $backgroupColor;
  }
}

class ContactData
{
  private array $emailAddresses;
  private array $phoneNumbers;

  public function __construct(array $emailAddresses = [], array $phoneNumbers = []) {
    $this->emailAddresses = $emailAddresses;
    $this->phoneNumbers = $phoneNumbers;
  }
}

class OtherData
{
  // ...etc.
}

class User 
{
  private ProfileData $profileData;
  private ?ContactData $otherData;
  private ?OtherData $contactData;

  public function __construct(
    ProfileData $profileData, 
    ContactData $contactData = null, 
    OtherData $otherData = null
  ) {
    $this->profileData = $profileData;
    $this->contactData = $contactData;
    $this->otherData = $otherData;
  }

  public function getProfileData() : ProfileData {
    return $this->profileData;
  }

  // ...etc.
}

通过这种方式，User 类的构造函数只需要接受更少的参数，并且每个参数都代表一个更高级别的概念。

方法二：使用 Builder 模式

如果即使在分组属性后，构造函数仍然包含大量的参数，可以考虑使用 Builder 模式。Builder 模式允许逐步构建对象，并处理可选参数。

class UserBuilder
{
  private ProfileData $profileData;
  private ?ContactData $contactData;
  private ?OtherData $otherData;

  public function __construct(ProfileData $profileData) {
    $this->profileData = $profileData;
  }

  public function setContactData(?ContactData $contactData) : UserBuilder {
    $this->contactData = $contactData;

    // return $this to allow method chaining
    return $this;
  }

  public function setOtherData(?OtherData $otherData) : UserBuilder {
    $this->otherData = $otherData;

    // return $this to allow method chaining
    return $this;
  }

  public function build() : User {
    // build and return User object
    return new User(
      $this->profileData,
      $this->contactData,
      $this->otherData
    );
  }
}

// usage example
$builder = new UserBuilder(new ProfileData('path/to/image', 0xCCCCC));

$user = $builder->setContactData(new ContactData(['[email protected]']))
                ->setOtherData(new OtherData())
                ->build();

使用 Builder 模式，可以先创建一个 UserBuilder 对象，然后使用 setter 方法设置各个属性，最后调用 build() 方法创建 User 对象。

为了更方便地使用 Builder 模式，可以在 User 类中添加一个静态的 builder 工厂方法：

class User 
{
  public static function builder(ProfileData $profileData) : UserBuilder {
    return new UserBuilder($profileData);
  }
}

// usage example
$user = User::builder(new ProfileData('path/to/image', 0xCCCCC))
                ->setContactData(new ContactData(['[email protected]']))
                ->setOtherData(new OtherData())
                ->build();

注意事项与总结

• 重新评估类设计： 在使用上述方法之前，请仔细考虑类的设计。如果一个类负责过多的职责，可能需要将其分解为更小的、更专注的类。
• 选择合适的方法： 属性分组适用于将相关属性组织在一起的情况。Builder 模式适用于处理大量可选参数的情况。
• 代码可读性： 无论选择哪种方法，都要确保代码的可读性。清晰的代码结构可以提高代码的可维护性。

通过属性分组和 Builder 模式，可以有效地减少 PHP 构造函数中的冗余代码，并提高代码的可读性和可维护性。但是，最重要的是要始终关注类的设计，并确保每个类都只负责一个明确的职责。