发布于 由admin

PHP重构：从坏代码到高可维护性代码

好的，各位观众老爷们，欢迎来到“PHP代码大保健”现场！今天，咱们不聊风花雪月，只聊如何把你的PHP代码从“工地风”打造成“维多利亚风”，从一堆乱麻变成精美刺绣，让你的代码不仅能跑，还能跑得优雅，跑得性感！🚀

开场白：你的代码，还好吗？

先问大家一个扎心的问题：你的PHP代码，你敢回头看吗？是不是充满了if-else的迷宫、全局变量的陷阱、还有各种“祖传代码”的神秘咒语？是不是每次改一行代码，都感觉像在拆炸弹💣，生怕引爆整个系统？

如果是的话，恭喜你，你来对地方了！今天，我们就来聊聊PHP代码重构，让你的代码焕发新生，告别“屎山”，走向“花园”！🌷

什么是重构？不是重写！

很多小伙伴一听到“重构”就吓尿了，以为要推倒重来。No no no！重构不是重写，而是在不改变代码外在行为的前提下，改善其内部结构。就像给房子装修，不拆墙，只是换个壁纸、铺个地板，让它更舒适、更美观。

重构的目的很简单：

  • 提高代码可读性： 让别人（也包括未来的你）能轻松理解代码在干什么。
  • 提高代码可维护性： 让修改代码变得简单、安全，减少bug产生的风险。
  • 提高代码可扩展性： 让代码更容易适应新的需求，迎接未来的挑战。
  • 提高代码性能： 虽然不是主要目的，但重构有时也能带来性能上的提升。

为什么你的代码需要重构？“屎山”是如何炼成的？

代码“屎山”的形成，往往不是一蹴而就的，而是日积月累的结果。常见的“屎山”制造者包括：

  1. 时间紧，任务重： 为了赶进度，先实现功能再说，代码质量什么的，以后再说……（然后就再也没有以后了）
  2. 需求变更频繁： 今天要这样，明天要那样，代码东拼西凑，最终变成四不像。
  3. 缺乏经验： 刚入行的小白，代码风格不规范，各种坏味道扑面而来。
  4. 缺乏沟通： 团队成员各自为战，代码风格不统一，最终融合在一起，形成一锅乱炖。

时间一长，代码就变成了这样：

代码坏味道 症状 后果
过长函数 (Long Method) 函数代码超过100行，甚至几百行。 难以理解，难以维护，难以测试。
过大类 (Large Class) 类承担过多的责任，代码臃肿。 难以理解，难以维护，难以复用。
过长参数列表 (Long Parameter List) 函数参数过多，超过3个以上。 难以理解，难以使用，容易出错。
重复代码 (Duplicated Code) 代码在多个地方重复出现。 维护成本高，修改一处，需要修改多处。
注释过多 (Comments) 大量的注释，掩盖了代码的坏味道。 难以维护，注释可能与代码不一致。
数据泥团 (Data Clumps) 多个类中出现相同的数据项。 维护成本高，修改一处，需要修改多处。
发散式变化 (Divergent Change) 一个类因为多种原因需要修改。 难以维护，违反单一职责原则。
霰弹式修改 (Shotgun Surgery) 修改一个功能，需要在多个类中进行修改。 难以维护，耦合度高。
依恋情结 (Feature Envy) 一个函数过于依赖另一个类的数据和方法。 耦合度高，违反封装原则。
消息链 (Message Chains) 一个对象请求另一个对象，然后这个对象又请求另一个对象…… 耦合度高，难以修改。
中间人 (Middle Man) 一个类的大部分方法都委托给另一个类。 增加了不必要的间接性。
不完美的库类 (Lazy Class) 一个类没有做足够的事情。 浪费资源，增加复杂性。
平行继承体系 (Parallel Inheritance Hierarchies) 两个继承体系结构平行存在，修改一个，需要修改另一个。 难以维护，耦合度高。
夸大的未来性 (Speculative Generality) 为了应对未来的需求，预先设计了一些复杂的代码，但这些需求可能永远不会出现。 增加复杂性，浪费资源。
令人迷惑的临时字段 (Temporary Field) 一个类的某些字段只在特定的情况下使用。 难以理解，容易出错。
过度耦合的消息 (Coupling) 代码之间过度依赖，修改一处，影响多处。 难以维护，难以测试。

重构的原则：小步快跑，测试先行

重构不是一蹴而就的事情，而是一个持续改进的过程。记住以下几个原则：

  1. 小步快跑： 不要一次性重构大量的代码，每次只修改一小部分，然后进行测试。
  2. 测试先行： 在重构之前，先编写单元测试，确保重构后的代码行为不变。
  3. 不要停止运行： 重构过程应该在不影响系统正常运行的情况下进行。
  4. 时刻保持代码整洁： 每次修改代码，都要保持代码的整洁。
  5. 持续集成： 将重构纳入持续集成流程，及时发现和解决问题。

PHP重构的常用技巧：十八般武艺，样样精通

接下来，我们就来学习一些PHP重构的常用技巧，让你在代码的世界里，如鱼得水，所向披靡！💪

  1. 提取函数 (Extract Method)：

    • 场景： 过长函数，代码块功能独立。
    • 做法： 将代码块提取到一个新的函数中，并赋予一个清晰的名称。
    • 示例：
    // 重构前
function printOwing(float $amount) {
    echo "***********************n";
    echo "****Customer Owes****n";
    echo "***********************n";
    echo "name: " . $this->name . "n";
    echo "amount: " . $amount . "n";
}

// 重构后
function printBanner() {
    echo "***********************n";
    echo "****Customer Owes****n";
    echo "***********************n";
}

function printOwing(float $amount) {
    $this->printBanner();
    echo "name: " . $this->name . "n";
    echo "amount: " . $amount . "n";
}

  2. 内联函数 (Inline Method)：

    • 场景： 函数体过于简单，或者不再需要。
    • 做法： 将函数体的内容直接替换到函数调用处。
    • 示例：
    // 重构前
function getRating() {
    return (moreThanFiveLateDeliveries()) ? 2 : 1;
}

function moreThanFiveLateDeliveries() {
    return $this->numberOfLateDeliveries > 5;
}

// 重构后
function getRating() {
    return ($this->numberOfLateDeliveries > 5) ? 2 : 1;
}

  3. 提取类 (Extract Class)：

    • 场景： 类承担过多的责任，代码臃肿。
    • 做法： 将一部分责任提取到一个新的类中。
    • 示例：
    // 重构前
class Person {
    public string $name;
    public string $officeAreaCode;
    public string $officeNumber;

    public function __construct(string $name, string $officeAreaCode, string $officeNumber) {
        $this->name = $name;
        $this->officeAreaCode = $officeAreaCode;
        $this->officeNumber = $officeNumber;
    }

    public function getTelephoneNumber(): string {
        return "(" . $this->officeAreaCode . ") " . $this->officeNumber;
    }
}

// 重构后
class TelephoneNumber {
    public string $areaCode;
    public string $number;

    public function __construct(string $areaCode, string $number) {
        $this->areaCode = $areaCode;
        $this->number = $number;
    }

    public function getTelephoneNumber(): string {
        return "(" . $this->areaCode . ") " . $this->number;
    }
}

class Person {
    public string $name;
    public TelephoneNumber $telephoneNumber;

    public function __construct(string $name, string $officeAreaCode, string $officeNumber) {
        $this->name = $name;
        $this->telephoneNumber = new TelephoneNumber($officeAreaCode, $officeNumber);
    }

    public function getTelephoneNumber(): string {
        return $this->telephoneNumber->getTelephoneNumber();
    }
}

  4. 内联类 (Inline Class)：

    • 场景： 类没有做足够的事情，或者不再需要。
    • 做法： 将类的成员变量和方法移动到另一个类中。

  5. 以查询取代临时变量 (Replace Temp with Query)：

    • 场景： 临时变量只被赋值一次，并且被多次使用。
    • 做法： 将临时变量的计算逻辑提取到一个新的函数中，每次需要使用时，都调用该函数。
    • 示例：
    // 重构前
function getPrice() {
    $basePrice = $this->quantity * $this->itemPrice;
    $discountFactor = $this->basePrice > 1000 ? 0.95 : 0.98;
    return $basePrice * $discountFactor;
}

// 重构后
function getBasePrice() {
    return $this->quantity * $this->itemPrice;
}

function getDiscountFactor() {
    return $this->getBasePrice() > 1000 ? 0.95 : 0.98;
}

function getPrice() {
    return $this->getBasePrice() * $this->getDiscountFactor();
}

  6. 引入参数对象 (Introduce Parameter Object)：

    • 场景： 函数参数过多，超过3个以上。
    • 做法： 将参数封装到一个对象中，传递对象代替传递多个参数。
    • 示例：
    // 重构前
function amountInvoiced(DateTime $startDate, DateTime $endDate) {
    // ...
}

function amountReceived(DateTime $startDate, DateTime $endDate) {
    // ...
}

function amountOverdue(DateTime $startDate, DateTime $endDate) {
    // ...
}

// 重构后
class DateRange {
    public DateTime $startDate;
    public DateTime $endDate;

    public function __construct(DateTime $startDate, DateTime $endDate) {
        $this->startDate = $startDate;
        $this->endDate = $endDate;
    }
}

function amountInvoiced(DateRange $dateRange) {
    // ...
}

function amountReceived(DateRange $dateRange) {
    // ...
}

function amountOverdue(DateRange $dateRange) {
    // ...
}

  7. 以命令取代函数 (Replace Function with Command)：

    • 场景： 函数过于复杂，包含大量的逻辑。
    • 做法： 将函数封装到一个命令对象中，将函数的逻辑分解到命令对象的多个方法中。

  8. 分解条件表达式 (Decompose Conditional)：

    • 场景： if-else 语句过于复杂。
    • 做法： 将 if 和 else 中的代码块提取到独立的函数中。

  9. 合并重复的条件片段 (Consolidate Conditional Expression)：

    • 场景： 多个 if 语句的条件判断结果相同。
    • 做法： 将多个 if 语句合并为一个 if 语句。

  10. 以卫语句取代嵌套条件表达式 (Replace Nested Conditional with Guard Clauses)：

    • 场景： 嵌套的 if-else 语句，难以理解。
    • 做法： 使用卫语句提前返回，避免嵌套。
    • 示例：
    // 重构前
function getPayAmount() {
    $result = 0;
    if ($this->isDead) {
        $result = $this->deadAmount();
    } else {
        if ($this->isSeparated) {
            $result = $this->separatedAmount();
        } else {
            if ($this->isRetired) {
                $result = $this->retiredAmount();
            } else {
                $result = $this->normalPayAmount();
            }
        }
    }
    return $result;
}

// 重构后
function getPayAmount() {
    if ($this->isDead) {
        return $this->deadAmount();
    }
    if ($this->isSeparated) {
        return $this->separatedAmount();
    }
    if ($this->isRetired) {
        return $this->retiredAmount();
    }
    return $this->normalPayAmount();
}

  11. 引入Null对象 (Introduce Null Object)：

    • 场景： 经常需要判断对象是否为null。
    • 做法： 创建一个Null对象，代替null值。

  12. 以多态取代条件表达式 (Replace Conditional with Polymorphism)：

    • 场景： if-else 或 switch 语句根据对象的类型执行不同的逻辑。
    • 做法： 将不同的逻辑封装到不同的子类中，使用多态来选择不同的实现。

  13. 提炼接口 (Extract Interface):

    • 场景： 不同的类实现了相似的功能，但是没有共同的接口。
    • 做法： 提取一个接口，让这些类实现该接口。

  14. 提炼超类 (Extract Superclass):

    • 场景： 不同的类具有相同的属性和方法。
    • 做法： 提取一个超类，将相同的属性和方法移动到超类中。

  15. 塑造模板函数 (Form Template Method):

    • 场景： 不同的子类具有相似的算法结构，但是具体的步骤不同。
    • 做法： 在父类中定义算法的骨架，将具体的步骤定义为抽象方法，让子类来实现。

重构工具：工欲善其事，必先利其器

虽然重构主要靠的是你的智慧和经验，但是一些工具也能帮助你提高效率，减少错误。

  • IDE： 好的IDE（如PhpStorm）可以提供代码自动完成、代码检查、代码格式化等功能，让你更专注于代码的逻辑。
  • 静态分析工具： 静态分析工具（如PHPStan、Psalm）可以帮助你发现代码中的潜在问题，如类型错误、未使用的变量等。
  • 代码质量检测工具： 代码质量检测工具（如SonarQube）可以帮助你评估代码的质量，发现代码中的坏味道。

总结：代码重构，永无止境

代码重构不是一次性的任务，而是一个持续改进的过程。记住，好的代码不是一蹴而就的，而是通过不断地重构，不断地改进，最终形成的。

希望今天的“PHP代码大保健”能帮助你摆脱“屎山”的困扰，写出更优雅、更健壮、更易维护的PHP代码。记住，代码不仅要能跑，还要跑得漂亮！ 🏃‍♀️🏃

最后，送给大家一句名言：“任何傻瓜都能写出计算机可以理解的代码。优秀的程序员写出的是人类可以理解的代码。” – Martin Fowler

感谢大家的观看，我们下期再见！ 👋

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注