PHP代码简洁之道——SOLID原则

最新推荐文章于 2024-02-14 16:11:41 发布
最新推荐文章于 2024-02-14 16:11:41 发布
阅读量214 收藏 1
点赞数
分类专栏： php
原文链接：https://juejin.im/entry/59ed9c7d5188250989513ff1
版权

SOLID 是Michael Feathers推荐的便于记忆的首字母简写，它代表了Robert Martin命名的最重要的五个面对对象编码设计原则

  • S: 单一职责原则 (SRP)
  • O: 开闭原则 (OCP)
  • L: 里氏替换原则 (LSP)
  • I: 接口隔离原则 (ISP)
  • D: 依赖反转原则 (DIP)

单一职责原则 Single Responsibility Principle (SRP)

"修改一个类应该只为一个理由"。人们总是易于用一堆方法塞满一个类，如同我们在飞机上只能携带一个行李箱（把所有的东西都塞到箱子里）。这样做的问题是：从概念上这样的类不是高内聚的，并且留下了很多理由去修改它。将你需要修改类的次数降低到最小很重要。这是因为，当有很多方法在类中时，修改其中一处，你很难知晓在代码库中哪些依赖的模块会被影响到。

Bad:

class UserSettings
{
    private $user;

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

    public function changeSettings($settings)
    {
        if ($this->verifyCredentials()) {
            // ...
        }
    }

    private function verifyCredentials()
    {
        // ...
    }
}

Good:

class UserAuth 
{
    private $user;

    public function __construct($user)
    {
        $this->user = $user;
    }
    
    public function verifyCredentials()
    {
        // ...
    }
}

class UserSettings 
{
    private $user;
    private $auth;

    public function __construct($user) 
    {
        $this->user = $user;
        $this->auth = new UserAuth($user);
    }

    public function changeSettings($settings)
    {
        if ($this->auth->verifyCredentials()) {
            // ...
        }
    }
}

开闭原则 Open/Closed Principle (OCP)

正如Bertrand Meyer所述，"软件的实体（类, 模块, 函数,等）应该对扩展开放，对修改关闭。"这个原则是在说明应该允许用户在不改变已有代码的情况下增加新的功能。

Bad:

abstract class Adapter
{
    protected $name;

    public function getName()
    {
        return $this->name;
    }
}

class AjaxAdapter extends Adapter
{
    public function __construct()
    {
        parent::__construct();

        $this->name = 'ajaxAdapter';
    }
}

class NodeAdapter extends Adapter
{
    public function __construct()
    {
        parent::__construct();

        $this->name = 'nodeAdapter';
    }
}

class HttpRequester
{
    private $adapter;

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

    public function fetch($url)
    {
        $adapterName = $this->adapter->getName();

        if ($adapterName === 'ajaxAdapter') {
            return $this->makeAjaxCall($url);
        } elseif ($adapterName === 'httpNodeAdapter') {
            return $this->makeHttpCall($url);
        }
    }

    private function makeAjaxCall($url)
    {
        // request and return promise
    }

    private function makeHttpCall($url)
    {
        // request and return promise
    }
}

在上面的代码中，对于HttpRequester类中的fetch方法，如果我新增了一个新的xxxAdapter类并且要在fetch方法中用到的话，就需要在HttpRequester类中去修改类（如加上一个elseif 判断），而通过下面的代码，就可很好的解决这个问题。下面代码很好的说明了如何在不改变原有代码的情况下增加新功能。

Good:

interface Adapter
{
    public function request($url);
}

class AjaxAdapter implements Adapter
{
    public function request($url)
    {
        // request and return promise
    }
}

class NodeAdapter implements Adapter
{
    public function request($url)
    {
        // request and return promise
    }
}

class HttpRequester
{
    private $adapter;

    public function __construct(Adapter $adapter)
    {
        $this->adapter = $adapter;
    }

    public function fetch($url)
    {
        return $this->adapter->request($url);
    }
}

里氏替换原则 Liskov Substitution Principle (LSP)

对这个概念最好的解释是：如果你有一个父类和一个子类，在不改变原有结果正确性的前提下父类和子类可以互换。这个听起来让人有些迷惑，所以让我们来看一个经典的正方形-长方形的例子。从数学上讲，正方形是一种长方形，但是当你的模型通过继承使用了"is-a"的关系时，就不对了。

Bad:

class Rectangle
{
    protected $width = 0;
    protected $height = 0;

    public function render($area)
    {
        // ...
    }

    public function setWidth($width)
    {
        $this->width = $width;
    }

    public function setHeight($height)
    {
        $this->height = $height;
    }

    public function getArea()
    {
        return $this->width * $this->height;
    }
}

class Square extends Rectangle
{
    public function setWidth($width)
    {
        $this->width = $this->height = $width;
    }

    public function setHeight(height)
    {
        $this->width = $this->height = $height;
    }
}

function renderLargeRectangles($rectangles)
{
    foreach ($rectangles as $rectangle) {
        $rectangle->setWidth(4);
        $rectangle->setHeight(5);
        $area = $rectangle->getArea(); // BAD: Will return 25 for Square. Should be 20.
        $rectangle->render($area);
    }
}

$rectangles = [new Rectangle(), new Rectangle(), new Square()];
renderLargeRectangles($rectangles);

Good:

abstract class Shape
{
    protected $width = 0;
    protected $height = 0;

    abstract public function getArea();

    public function render($area)
    {
        // ...
    }
}

class Rectangle extends Shape
{
    public function setWidth($width)
    {
        $this->width = $width;
    }

    public function setHeight($height)
    {
        $this->height = $height;
    }

    public function getArea()
    {
        return $this->width * $this->height;
    }
}

class Square extends Shape
{
    private $length = 0;

    public function setLength($length)
    {
        $this->length = $length;
    }

    public function getArea()
    {
        return pow($this->length, 2);
    }
}

function renderLargeRectangles($rectangles)
{
    foreach ($rectangles as $rectangle) {
        if ($rectangle instanceof Square) {
            $rectangle->setLength(5);
        } elseif ($rectangle instanceof Rectangle) {
            $rectangle->setWidth(4);
            $rectangle->setHeight(5);
        }

        $area = $rectangle->getArea(); 
        $rectangle->render($area);
    }
}

$shapes = [new Rectangle(), new Rectangle(), new Square()];
renderLargeRectangles($shapes);

接口隔离原则

接口隔离原则："客户端不应该被强制去实现于它不需要的接口"。

有一个清晰的例子来说明示范这条原则。当一个类需要一个大量的设置项，为了方便不会要求客户端去设置大量的选项，因为在通常他们不需要所有的设置项。使设置项可选有助于我们避免产生"胖接口"

Bad:

interface Employee
{
    public function work();

    public function eat();
}

class Human implements Employee
{
    public function work()
    {
        // ....working
    }

    public function eat()
    {
        // ...... eating in lunch break
    }
}

class Robot implements Employee
{
    public function work()
    {
        //.... working much more
    }

    public function eat()
    {
        //.... robot can't eat, but it must implement this method
    }
}

上面的代码中，Robot类并不需要eat()这个方法，但是实现了Emplyee接口，于是只能实现所有的方法了，这使得Robot实现了它并不需要的方法。所以在这里应该对Emplyee接口进行拆分，正确的代码如下：

Good:

interface Workable
{
    public function work();
}

interface Feedable
{
    public function eat();
}

interface Employee extends Feedable, Workable
{
}

class Human implements Employee
{
    public function work()
    {
        // ....working
    }

    public function eat()
    {
        //.... eating in lunch break
    }
}

// robot can only work
class Robot implements Workable
{
    public function work()
    {
        // ....working
    }
}

依赖反转原则 Dependency Inversion Principle (DIP)

这条原则说明两个基本的要点：

  • 高阶的模块不应该依赖低阶的模块，它们都应该依赖于抽象
  • 抽象不应该依赖于实现，实现应该依赖于抽象

这条起初看起来有点晦涩难懂，但是如果你使用过php框架（例如 Symfony），你应该见过依赖注入（DI）对这个概念的实现。虽然它们不是完全相通的概念，依赖倒置原则使高阶模块与低阶模块的实现细节和创建分离。可以使用依赖注入（DI）这种方式来实现它。更多的好处是它使模块之间解耦。耦合会导致你难于重构，它是一种非常糟糕的的开发模式。

Bad:

class Employee
{
    public function work()
    {
        // ....working
    }
}

class Robot extends Employee
{
    public function work()
    {
        //.... working much more
    }
}

class Manager
{
    private $employee;

    public function __construct(Employee $employee)
    {
        $this->employee = $employee;
    }

    public function manage()
    {
        $this->employee->work();
    }
}

Good:

interface Employee
{
    public function work();
}

class Human implements Employee
{
    public function work()
    {
        // ....working
    }
}

class Robot implements Employee
{
    public function work()
    {
        //.... working much more
    }
}

class Manager
{
    private $employee;

    public function __construct(Employee $employee)
    {
        $this->employee = $employee;
    }

    public function manage()
    {
        $this->employee->work();
    }
}

别写重复代码 (DRY)

这条原则大家应该都是比较熟悉了。

尽你最大的努力去避免复制代码，它是一种非常糟糕的行为，复制代码通常意味着当你需要变更一些逻辑时，你需要修改不止一处。

Bad:

function showDeveloperList($developers)
{
    foreach ($developers as $developer) {
        $expectedSalary = $developer->calculateExpectedSalary();
        $experience = $developer->getExperience();
        $githubLink = $developer->getGithubLink();
        $data = [
            $expectedSalary,
            $experience,
            $githubLink
        ];

        render($data);
    }
}

function showManagerList($managers)
{
    foreach ($managers as $manager) {
        $expectedSalary = $manager->calculateExpectedSalary();
        $experience = $manager->getExperience();
        $githubLink = $manager->getGithubLink();
        $data = [
            $expectedSalary,
            $experience,
            $githubLink
        ];

        render($data);
    }
}

Good:

function showList($employees)
{
    foreach ($employees as $employee) {
        $expectedSalary = $employee->calculateExpectedSalary();
        $experience = $employee->getExperience();
        $githubLink = $employee->getGithubLink();
        $data = [
            $expectedSalary,
            $experience,
            $githubLink
        ];

        render($data);
    }
}

Very good:

function showList($employees)
{
    foreach ($employees as $employee) {
        render([
            $employee->calculateExpectedSalary(),
            $employee->getExperience(),
            $employee->getGithubLink()
        ]);
    }
}

后记：虽然OOP设计需要遵守如上原则，不过实际的代码设计一定要简单、简单、简单。在实际编码中要根据情况进行取舍，一味遵守原则，而不注重实际情况的话，可能会让你的代码变的难以理解!

mysteryflower
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SOLID-principles:SOLID原则的代码示例
05-18
SOLID原则 SOLID原理的代码示例。 单一责任原则 班级应注意单一责任。 代码示例 坏路 这个Add方法做的太多了，它不应该知道如何写入日志并添加客户。 class Customer { void Add ( Database db ) { try { db...
什么是PHP的SOLID原则？
周祥平程序专栏
12-15 401
SOLID 是面向对象编程（OOP）中的五个设计原则的首字母缩写，这些原则有助于创建可维护、灵活且可扩展的软件。这些原则共同促使开发者编写更灵活、可维护和可扩展的代码。它们强调了代码的高内聚性、低耦合性和易于理解的设计。
SOLID：面向对象设计的前五个原则
最新发布
Java程序员的知识博客
02-14 1095
在本文中，介绍了SOLID（单一职责原则、开放封闭原则、里氏替换原则、接口隔离原则和依赖倒置原则）的五个原则。遵循SOLID原则的项目可以更容易地与合作者分享、扩展、修改、测试和重构。
PHP面向对象设计五大原则（SOLID）梳理总结
weixin_33698043的博客
07-12 143
PHP设计原则梳理，参考《PHP核心技术与最佳实践》、《敏捷开发原则、模式与实践》，文章PHP面向对象设计的五大原则、设计模式原则SOLID 单一职责原则（Single Responsibility Principle, SRP） 定义/特性 仅有一个引起类变化的原因 一个类只承担一项职责（职责：变化的原因） 避免相同的职责分散到不同的...
android solid代码,Android中形状图形 | shape图形常用的3个节点：corners(圆角)、solid(填充) 和 stroke(描边)...
weixin_42310267的博客
05-26 2071
shape是Android中常用的一种XML图形文件。形状图形的定义文件以shape元素为根节点。根节点下定义了6个节点：corners(圆角)、gradient(渐变)、padding(间隔)、size(尺寸)、solid(填充)、stroke(描边)，各节点的属性值主要是长宽、半径、角度以及颜色。常用的三个节点corners(圆角)、solid(填充) 和 stroke(描边) 简要说明如下...
solidworks宏代码文件
07-25
solidworks宏代码文件 #齿轮#齿轮轴#斜齿轮
Solidworks学习笔记——随形变化.docx
07-13
Solidworks是一款强大的三维计算机辅助设计(CAD)软件，广泛应用于机械工程、汽车制造、航空航天等领域。在Solidworks中，随形变化（Vary Sketch）功能是实现特征阵列时进行尺寸变化的重要工具，它允许用户在阵列特征...
SOLID：SOLID是计算机编程中五个良好原则（规则）的缩写。 SOLID使程序员可以编写易于理解的代码，并在以后进行更改。 Solid通常与使用面向对象设计的系统一起使用。 SOLID由Robert C提拔
02-21
坚硬的 SOLID是计算机编程中五个良好原则（规则）的缩写。 SOLID使程序员可以编写易于理解的代码，并在以后进行更改。 Solid通常与使用面向对象设计的系统一起使用。 SOLID由Robert C提拔。 S-SRP Принципединственнойответственности（单一责任原则） Длякаждогоклассадолжнобытьопределеноединственноеназначение。 Всересурсы，необходимыедляегоосуществления，должныбытьинкапсулированывэтотклассиоодчин。 O-OCP Принципоткрытости/закрытости（开放式/封闭式原理） программныесущности…должныбытьоткрытыдлярасширения，ноз
solid-php-examples:SOLID PHP 代码示例
06-16
可靠的 PHP 示例 单一职责原则 一个类应该只有一个改变的理由。 实体应该只做一件事并做好。 开闭原则 软件实体（类、模块、函数等）应该对扩展开放，对修改关闭。 实体应该对扩展开放，对修改关闭。 里氏替换原则 子类型必须可以替代它们的基本类型。 派生类必须可以替代它们的基类型。 实现接口的类应该能够在该接口类型提示的任何地方使用。 前提条件再好不过了！ （即，如果子类型抛出异常而不是主类型，则其前提条件更大） 实际上，您的@returns、@throws、输入参数等应该始终保持一致。 如果它看起来像一只鸭子，叫起来像一只鸭子并且需要电池，那么你可能有错误的抽象。 接口隔离原则 不应强迫客户依赖他们不使用的方法。 如果客户端被迫依赖他们不使用的方法，则会导致无意的耦合。 依赖倒置原则 一种。 高级模块不应该依赖于低级模块。 两者都应该依赖于抽象。 湾抽象不应该依赖于细节。
android solid 代码,Android 开发之SOLID原则
weixin_42509931的博客
05-27 668
SOLID是用来帮助定义面向对象设计五个基本原则的助记符：单一功能原则开闭原则里氏替换原则接口分离原则依赖反转原则SOLID#1:单一功能原则(SRP)一个类在修改时应该有、也只能有一个理由我们来更详细的说明这一原则，假设我们需要为Recycleview准备一个adapter，你很可能已经知道adapter用于从数据集合中获取数据并将它们适配到view。我曾见到过这样的实现：// 违反单一功能原则...
代码整洁之道 php,PHP代码简洁之道——SOLID原则
weixin_36081148的博客
03-16 219
SOLID 是Michael Feathers引荐的便于回忆的首字母简写，它代表了Robert Martin命名的最重要的五个面临目标编码规划准则S: 单一责任准则 (SRP)O: 开闭准则 (OCP)L: 里氏替换准则 (LSP)I: 接口阻隔准则 (ISP)D: 依靠回转准则 (DIP)单一责任准则 Single Responsibility Principle (SRP)"修正一个类应该只为...
solid 设计原则 php,PHP代码简洁之道——SOLID原则
weixin_31526891的博客
03-18 184
SOLID 是Michael Feathers推荐的便于记忆的首字母简写，它代表了Robert Martin命名的最重要的五个面对对象编码设计原则S: 单一职责原则 (SRP)O: 开闭原则 (OCP)L: 里氏替换原则 (LSP)I: 接口隔离原则 (ISP)D: 依赖反转原则 (DIP)单一职责原则 Single Responsibility Principle (SRP)"修改一个类应该只为...
PHP设计模式之SOLID原则了解下
luyaran的博客
09-29 1138
设计模式中的SOLID原则，分别是单一原则、开闭原则、里氏替换原则、接口隔离原则、依赖倒置原则，遵循前辈们总结出来的五大原则可以使程序解决紧耦合，更加健壮。来看个表单： 简拼 全拼 汉字 简单介绍 SRP The Single Responsibility Principle  单一责任原则 对象应该仅具有单一的功能 OCP The Open C...
面向对象设计原则：不要STUPID，坚持GRASP和SOLID
KNIGHTRCOM(rcom10002的专栏)
04-19 9815
不要STUPID，坚持GRASP和SOLID 听过SOLID编码吗？有人可能会说：这是描述设计原则的一个专业术语，由我们可爱的代码整洁之道传教者鲍勃（罗伯特C. 马丁）大叔提出，是一组用于指导我们如何写出“好代码”的原则。 在编程界充满了这样由单词首字母组成的缩略词。其它类似的例子还有DRY（Don’t Repeat Yourself! 不要重复你自己！）和KISS（Keep It Simpl
写了这么多年代码，你真的了解SOLID吗？
IDEAL Garden
09-12 987
尽管大家都认为SOLID是非常重要的设计原则，并且对每一条原则都耳熟能详，但我发现大部分开发者并没有真正理解。要获得最大收益，就必须理解它们之间的关系，并综合应用所有这些原则。只有把SOLID作为一个整体，才可能构建出坚实(Solid)的软件。遗憾的是，我们看到的书籍和文章都在罗列每个原则，没有把它们作为一个整体来看，甚至提出SOLID原则的Bob大叔也没能讲透彻。因此我尝试介绍一下我的理解。 ...
php面向对象五大原则
黑色的夜
12-23 1450
面向对象设计的五大原则分别是单一职原理，开放-封闭原则，替换原则，依赖倒置原则责原则，接口隔离。 这五大原则是23中设计模式的基础。 1：单一职原理 2：开放-封闭原则 3：替换原则 4：依赖倒置原则责原则 5：接口隔离
PHP 的代码简洁之道（Clean Code PHP）
zhoupenghui168的博客
04-17 1661
PHP 的代码简洁之道（Clean Code PHP）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值