PHP整洁之道

最新推荐文章于 2022-01-02 10:29:42 发布
置顶 最新推荐文章于 2022-01-02 10:29:42 发布
阅读量1.7k 收藏 4
点赞数 1
分类专栏： php 文章标签： php 代码 整洁之道
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Feature_/article/details/77897252
版权

PHP整洁之道

翻译github项目 Clean Code PHP，能力有限，大家见笑。

目录

  1. 介绍
  2. 变量
  3. 函数
  4. 对象和数据结构
  5. 类
    a. S: 单一功能 Single Responsibility Principle (SRP)
    b. O: 开闭原则 Open/Closed Principle (OCP)
    c. L: 里氏替换 Liskov Substitution Principle (LSP)
    d. I: 接口隔离 Interface Segregation Principle (ISP)
    e. D: 依赖反转 Dependency Inversion Principle (DIP)
  6. 不要重复工作

介绍

Robert C. Martin的书《Clean Code》讲述了软件工程的原则，同样也适用于PHP。它不仅仅是代码风格上的指导，同样也是告诉我们如何用PHP写出可读、可重用、可重构的软件的指导。

也不是所有的原则都必须严格遵守，还有一些是普遍约定。这些都是指导方针，仅此而已。但他们也同样是《Clean Code》的作者多年收集整理的心得。

灵感来自clean-code-javascript

变量

使用有意义和易拼写的变量名

不好的例子

$ymdstr = $moment->format('y-m-d');

好的例子

$currentDate = $moment->format('y-m-d');

对于相同类型的变量使用相同词汇

不好的例子

getUserInfo();
getClientData();
getCustomerRecord();

好的例子

getUser();

使用易理解的变量名

读代码总是比写代码要多。所以我们写的代码要具备很高的可读性和容易理解。不对变量做有助于理解我们项目的命名，最终会伤害我们的读者。

不好的例子

//86400 是什么意思呢？
addExpireAt(86400);

好的例子

// 将他们声明为大写的`const`全局变量
interface DateGlobal{
    const SECONDS_IN_A_DAY = 86400;
}
addExpireAt(DateGlobal::SECONDS_IN_A_DAY);

使用解释型的变量

不好的例子

$address = 'One Infinite Loop, Gupertino 95014';
$cityZipCodeRegex = '/^[^,\\]+[,\\\s]+(.+?)\s*(\d{5})?$/';
preg_match($cityZipCodeRegex, $address, $matches);

saveCityZipCode($matches[1], $matches[2]);

一般的例子
它更好一点，但我们仍然严重依赖regex

$address = 'One Infinite Loop, Cupertino 95014';
$cityZipCodeRegex = '/^[^,\\]+[,\\\s]+(.+?)\s*(\d{5})?$/';
preg_match($cityZipCodeRegex, $address, $matches);

list(, $city, $zipCode) = $matches;
saveCodeZip($city, $zipCode);

好的例子
通过命名子模式减少对regex的依赖

$address = 'One Infinite Loop, Cupertino 95014';
$cityZipCodeRegex = '/^[^,\\]+[,\\\s]+(?<city>.+?)\s*(?<zipCode>\d{5})?$/';
preg_match($cityZipCodeRegex, $address, $matches);

saveCityZip($matches['city'], $matches['zipCode']);

避免无意义的变量名

别让别人猜你的代码是什么意思。
显式比隐式更好。

不好的例子

$l = ['Austin', 'New York', 'San Francisco'];

for ($i = 0; $i < count($l); $i++) {
    $li = $l[$i];
    doStuff();
    doSomeOtherStuff();
    //...
    //...
    //...
    // 等等，`$li`是什么？
    dispatch($li);
}

好的例子

$locations = ['Austin', 'New York', 'San Fransisco'];

foreach ($locations as $location) {
    doStuff();
    doSomeOtherStuff();
    //...
    //...
    //...
    dispatch($location);
}

不添加不必要的信息

如果你的类/对象名表示了某种含义，不需要在你的变量名中重复。

不好的例子

class Car {
    public $carMake;
    public $carModel;
    public $carColor;

    //...
}

好的例子

class Car {
    public $make;
    public $model;
    public $color;

    //...
}

使用默认参数代替条件

不好的例子

function createMicrobrewery($name = null) {
    $breweryName = $name ?: 'Hipster Brew Co.';
    //...
}

好的例子

function createMicrobrewery($breweryName = 'Hipster Brew Co.') {
    //...
}

函数

函数的参数（最好少于2个）

限制函数参数的数量是非常重要的，因为这会使得测试函数更容易。3个以上的参数会导致你需要测试大量不同的情况。

无参数是最理想的。一个或者两个参数也是很好的，三个就应该避免了。任何超过这一点的都需要重写。通常，如果你需要两个以上参数时你的函数需要做更多处理。这种时候，更高级的对象就可以作为一个参数了。

不好的例子

function createMenu($title, $body, $buttonText, $cancellable) {
    //...
}

好的例子

class MenuConfig {
    public $title;
    public $body;
    public $buttonText;
    public $cacellable = false;
}

$config = new MenuConfig();
$config->title = 'Foo';
$config->body = 'Bar';
$config->buttonText = 'Baz';
$config->cancellable = true;

function creataMenu(MenuConfig $config) {
    //...
}

一个函数应该只做一件事情

这是目前软件工程中最重要的规则。当一个函数做不止一件事情的之后，他们会更难去构成、测试和理解。你的每个函数只做一件事情的时候，你会更容易地去重构，并且你的代码读起来会干净很多。如果你把这个规则看得比其他规则重要很多，你就会领先其他很多开发人员了。

不好的例子

function emailClients($clients) {
    foreach ($clients as $client) {
        $clientRecord = $db->find($client);
        if ($clientRecord->isActive()) {
            email($client);
        }
    }
}

好的例子

function emailClients($clients) {
    $activeClients = activeClients($clients);
    array_walk($activeClients, 'email');
}

function activeClients($clients) {
    return array_walk($clients, 'isClientActive');
}

function isClientActive($clients) {
    $clientRecord = $db->find($client);
    return $clientRecord->isActive();
}

函数名应该告诉我们它做的是什么

不好的例子

class Email {
    //...

    public function handle() {
        mail($this->to, $this->subject, $this->body);
    }
}

$message = new Email(...);
// 这是什么？信息`message`的处理`handle`?我们正在写文件嘛？
$message->handle();

好的例子

class Email {
    //...

    public function send() {
        mail($this->to, $this->subject, $this-<body);
    }
}

$message = new Email(...);
// 简洁清楚
$message->send();

函数只能是一个抽象层次

当你的函数具有多个抽象层次时，你需要做的事会更多。拆分你的函数，会使得它更容易被重用且更容易测试。

不好的例子

function parseBetterJSAlternative($code) {
    $regexes = [
        // ...
    ];
    $statements = split(' ', $code);
    $tokens = [];
    foreach ($regeses as $regex) {
        foreach ($statements as $statement) {
            // ...
        }
    }

    $ast = [];
    foreach ($tokens as $token) {
        // lex...
    }

    foreach ($ast as node) {
        // parse...
    }
}

还是不好的例子
我们已经拆分出了一些函数，但是parseBetterJSAlternative()函数还是非常负责和难以测试。

function tokenize($code) {
    $regexes = [
        // ...
    ];

    $statements = split(' ', $code);
    $tokens = [];
    foreach ($regexes as $regex) {
        foreach ($statements as $statement) {
            $token[] = /* ... */;
        }
    }

    return $tokens;
}

function leser($tokens) {
    $ast = [];
    foreach ($tokens as $token) {
        $ast[] = /* ...*/;
    }

    return $ast;
}

function parseBetterJSAlternative($code) {
    $tokens = tokenize($code);
    $ast = lexer($tokens);
    foreach ($ast as $node) {
        // parse...
    }
}

好的例子

最好的方法就是把parseBetterJSAlternative()方法的依赖关系移除出去。

class Tokenizer {
    public function tokenize($code) {
        $regexes = [
            // ...
        ];

        $statements = split(' ', $code);
        $tokens = [];
        foreach ($regexes as $regex) {
            foreach ($statements as $statement) {
                $tokens[] = /* ... */;
            }
        }

        return $tokens;
    }
}
class Lexer {
    public function lexify($tokens) {
        $ast = [];
        foreach ($tokens as $token) {
            $ast[] = /* ... */;
        }

        return $ast;
    }
}
class BetterJSAlternative {
    private $tokenizer;
    private $lexer;

    public function __construct($Tokenizer $tokenizer, Lexer $lexer) {
        $this->tokenizer = $tokenizer;
        $this->lexer = $lexer;
    }

    public function parse ($code) {
        $token = $this->tokenizer->tokenize($code);
        $ast = $this->lexer->lexify($tokens);
        foreach ($ast as $node) {
            // parse...
        }
    }
}

现在我们可以模拟依赖关系并只需要测试BetterJSAlternative::parse()方法的工作了。

不使用标志作为函数的参数

标志告诉用户函数做了不止一件事。函数应该只做一件事。如果它们遵循基于布尔值boolean的代码路径，那就拆分它们。

不好的例子

function createFile($name, $temp = false) {
    if ($temp) {
        touch('./temp/' . $name);
    } else {
        touch($name);
    }
}

好的例子

function createFile($name) {
    touch($name);
}

function creataTempFile($name) {
    touch('./temp/' . $name);
}

避免副作用

一个函数如果再做其他事情而不是取一个值然后返回一个或这多个值时产生了副作用。副作用可能是写入文件，修改一些全局变量，或者把你得钱转给了陌生人。

现在，你的项目中有时确实需要一些副作用。就像上一个例子，你可能需要去写文件。你需要做的就是去集中你在哪做这件事。不需要有多个函数和类来写入特定的文件。有一个服务来做这件事就可以了，只需要一个。

重点是避免常见的陷阱，比如在没有任何结构的对象之间共享状态，使用可以被任何东西写入的可变数据类型，而不是集中在你副作用发生的地方。如果你能做到这一点，你会比绝大多数程序员快乐。

不好的例子

// 由一下函数引用的全局变量
// 如果我们有另一个函数使用了这个名字，它会成为一个数组，并且会产生溢出。
$name = 'Ryan McDermott';

function splitIntoFirstAndLastName() {
    global $name;

    $name = preg_split('/ /', $name);
}

splitIntoFirstAndLastName();

var_dump($name); // ['Ryan', 'McDermott'];

好的例子

function splitIntoFirstAndLastName($name) {
    return preg_split('/ /', $name);
}

$name = 'Ryan McDermott';
$newName = splitIntoFirstAndLastName($name);
var_dump($name); // 'Ryan McDermott';
var_dump($newName) // ['Ryan', 'McDermott'];

不要写入全局函数

在很多语言中，泛滥的全局资源是一种很糟糕的体验，因为你可能和另一个库发生冲突，如果你的API用户在生产中得到了一个异常，那就很不明智了。让我们试想一个场景：如果你想要配置数组你会做什么。你可能会写一个全局函数像config()，但是它可能会与其他试图做同一件事的库冲突。

不好的例子

function config() {
    return [
        'foo' => 'bar',
    ];
}

好的例子

创建PHP配置文件或者其他的

// config.php
return [
    'foo' => 'bar',
];
class Configuration {
    private $configuration = [];

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

    public function get($key) {
        return isset($this->configuration[$key]) ? $this->configuration[$key] : null;
    }
}

从文件中加载配置并创建Configuration实例

$configuration = new Configuration($configuration);

现在你必须在你的应用中使用Configuration实例。

不适用单例模式

单例是一种反面模式 anti-pattern。

不好的例子

class DBConnection {
    private static $instance;

    private function __construct($dsn) {
        // ...
    }

    public static function getInstance() {
        if (self::$instance === null) {
            self:$instance = new self();
        }

        return self:$instance;
    }

    // ...
}

好的例子

class DBConnection {
    public function __construct(array $dsn) {
        // ...
    }

    // ...
}

创建DBConnection实例并且使用DSN来配置。

$connect = new DBConnection($dsn);

现在你必须在你的应用中使用Configuration实例。

封装条件

不好的例子

if ($article->state === 'published') {
    // ...
}

好的例子

if ($article->isPublished()) {
    // ...
}

避免反条件

不好的例子

function isDOMNodePresent($node) {
    // ...
}

if (!isDOMNodePresent($node)) {
    // ...
}

好的例子

function isDOMNodePresent($node) {
    // ...
}

if (isDOMNodePresent($node)) {
    // ...
}

避免条件

看起来像个不可能完成的任务。听到这个，大多数人会说：“如果没有if声明，我该怎么做呢？”答案是，在许多情况下，可以使用多态来完成相同的工作。第二个问题通常是“这真是太棒了，但是我为什么要这么做呢？”答案是我们之前学过的一个代码整洁之道的概念：一个函数只能做一件事。当你有包含if的类和函数时，你在告诉用户你的函数不止在做一件事。记住，只做一件事。

不好的例子

class Airplane {
    // ...
    public function getCruisingAltitude() {
        switch ($this->type) {
            case "777":
                return $this->getMaxAltitude() - $this->getPassengerCount();
            case "Air Force One":
                return $this->getMaxAltitude();
            case "Cessna":
                return $this->getMaxAltitude() - $this->getFuelExpenditure();
        }
    }
}

好的例子

class Airplane {
    // ...
}

class Boeing777 extends Airplane {
    // ...
    public function getCruisingAltitude() {
        return $this->getMaxAltitude() - $this->getPassengerCount();
    }
}

class AirForceOne extends Airplane {
    // ...
    public function getCruisingAltitude() {
        return $this->getMaxAltitude();
    }
}

class Cessna extends Airplane {
    // ...
    public function getCruisingAltitude() {
        return $this->getMaxAltitude() - $this->getFuelExpenditure();
    }
}

避免类型检查type-checking （第一部分）

PHP是弱类型语言，意思是你的函数可以接受任何类型的参数。有时你会被这种自由所干扰，你不得不在你的函数中进行类型检查。有很多种方法可以避免你去做这些。首先要考虑的事一致的API。

不好的例子

function travelToTexas($vehicle) {
    if ($vehicle instanceof Bicycle) {
        $vehicle->peddleTo(new Location('texas'));
    } else {
        $vehicle->driveTo(new Location('texas'));
    }
}

好的例子

function travelToTexas(Traveler $vehicle) {
    $vehicle->travelTo(new Location('texas'));
}

避免类型检查 （第二部分）

如果只使用像字符、整数、数组这样的基本的原始值，使用PHP 7+，不使用多态，依旧觉得需要类型检查，那么你该考虑看看这本书《type declaration》或者使用严格模式。它提供了标准PHP语法之上的静态类型。手工类型检查的问题在于，要做得很好，需要大量额外的verbiage，而您所得到的“类型安全”并不能弥补失去的可读性。保持你的PHP整洁，编写好的测试样例和良好的代码审查。否则，您可以使用PHP严格的类型声明或严格模式来完成这些工作。

不好的例子

function combine($val, $val) {
    if (!is_numeric($val1) || !is_numeric($val)) {
        throw new \Exception('Must be of type Number');
    }
}

好的例子

function combine(int $val1, int $val2) {
    return $val1 + $val2;
}

删除无效代码

无效代码和重复代码一样糟糕。没有理由把他们留在代码当中。如果不被调用，那就删除它们。如果你需要的话你可以在你的历史版本中找到他们。

不好的例子

function oldRequestModule($url) {
    // ...
}

function newRequestModule($url) {
    // ...
}

$request = newRequestModuel($requestUrl);
inventoryTracker('apples', $request, 'www.inventory-awesome.io');

好的例子

function requestModule($url) {
    // ...
}

$request = newRequestModuel($requestUrl);
inventoryTracker('apples', $request, 'www.inventory-awesome.io');

对象和数据结构

使用getter和setter方法

在PHP语言中，你可以使用public、protected、private关键字来修饰方法。使用这些，你可以控制对象的属性修改权限。
- 当您想要做更多的事情而不仅仅是获得一个对象属性时，您就不必在代码库中查找并更改每个访问器。
- 使用set使得添加验证更加方便
- 内部封装
- 在输入set和输出get是更容易添加日志记录和错误处理。
- 继承这个类，你可以重写默认函数。
- 您可以延迟加载对象的属性，比方说从服务器获取它。
此外，这是面向对象设计原则中开放/封闭原则的一部分。

不好的例子

class BankAccount {
    public $balance = 1000;
}

$bankAccount = new BankAccount();

// 买鞋...
$bankAccount->balance -= 100;

好的例子

class BankAccount {
    private $balance;

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

    public function withdrawBalance($amount) {
        if ($amount > $this->balance) {
            throw new \Exception('Amount greater than available balance');
        }

        $this->balance -= $amount;
    }

    public function depositBalance($amount) {
        $this->baance += $amount;
    }

    public function getBalance() {
        return $this->balance;
    }

    $bankAccount = new BankAccount();

    // 买鞋...
    $bankAccount->withdrawBalance($shoesPrice);

    // 获取余额
    $balance = $bankAccount->getBalance();
}

对象要有private/protected成员

不好的例子

class Employee {
    public $name;

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

$employee = new Employee('John Doe');
echo 'Employee name: ' . $employee->name; // Employee name: John Doe

好的例子

class Employee {
    private $name;

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

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

$employee = new Employee('John Doe');
echo "Employee name: " . $employee->getName(); // Employee name: John Doe

类

单一职责原则（SRP）

正如《代码整洁之道》中所述，“一个类的变化不应该有多个原因”。用很多功能来包装一个类是很有诱惑力的，就像你在航班上智能携带一个手提箱。这样做的问题是，这个类就不再具有内聚性，有很多理由会使它发生改变。减少修改类的次数是很重要的。因为一个类有太多功能的话，你在修改了其中一部分时，你会很难理解它会如何影响到你代码中的其它依赖部分。

不好的例子 

class UserSettings {
    private $user;

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

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

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

好的例子 

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()) {
            // ...
        }
    }
}

开放/关闭原则 （OCP）

正如Bertrand Meyer所说，“软件实体（类、模块、函数等等）应该对扩展开放，而对修改关闭。”这是什么意思呢？这个原则告诉我们应该允许用户在不修改原有代码的情况下添加新函数。

不好的例子

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 === 'nodeAdapter') {
            return $this->makeHttpCall($url);
        }
    }

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

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

好的例子

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

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

class NodeAdapter implements Adapter {
    public funciton 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)

这是一个难以理解的术语。它被正式定义为“如果S是T的子类型，那么T类型的对象可以被S（即，S类型的对象可以替代T类型的对象）所替代而不会改变程序的任何可取属性（正确性，任务执行等等）”。这是一个更可怕的定义。

对于这个最好的解释就是：如果你有一个父类和一个子类，然后基类和子类可以互换使用而不会得到不正确的结果。这可能仍然令人疑惑，那么让我们来经典的矩形矩阵Square-Rectangle的例子。

不好的例子

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

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

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

    public function getHeight($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);
    }
}

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

好的例子

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 {
    protected $length = 0;

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

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

function renderLargeRectangle($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()];
renderLargeRectangle($shapes);

接口隔离原则(ISP)

ISP指出“客户端不应该依赖未使用的接口”。

需要大型配置对象的类很好的说明了这个原则。不要求客户设置大量的选型是很好的，因为大多数时候我们并不需要所有的配置。让他们成为可选的可以有效防止出现接口臃肿。

不好的例子

interface Employee {
    public function work();

    public function eat();
}

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

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

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

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

好的例子
不是所有的worker都是employee, 但是所有的employee都是worker。

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() {
        // ...
    }
}

依赖倒置原则(DIP)

有两点是很重要的：
1. 高级模块不应该依赖于底层模块，两者都应该依赖于抽象层。
2. 抽象不应该依赖于具象，具象应该依赖于抽象。

可能刚开始很难理解，但是如果你使用过PHP框架(例如Symfony)，你应该在依赖注入(DI)中看到过这一原则的实现。虽然它并不是完全依赖原则实现的，但DIP使得高级模块并不需要了解低级模块也能够设置它们。这个可以通过DI来实现。很大一个好处是，它减少了模块之间的耦合。耦合是一种很糟糕的开发模式，因为它使得代码难以重构。

不好的例子

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

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();
    }
}

好的例子

interface Employee {
    public function work();
}

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

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

class Manager {
    private $employee;

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

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

使用方法链

这个模式非常有用，通常会在许多库中使用，比如PHPUnit和Doctrine。它能让代码更具表达性，并且能减少冗余代码。由此，使用方法链你可以看到你的代码有多干净。在类函数中，只需要在每个set函数末尾使用return $this就可以把更多的类函数链接到它上。

不好的例子

class Car {
    private $make = 'Honda';
    private $model = 'Accord';
    private $color = 'white';

    public function setMake($make) {
        $this->make = $make;
    }

    public function setModel($model) {
        $this->model = $model;
    }

    public function setColor($color) {
        $this->color = $color;
    }

    public function dump() {
        var_dump($this->make, $this->model, $this->color);
    }
}

$car = new Car();
$car->setColor('pink');
$car->setMake('Ford');
$car->setModel('F-150');
$car->cump();

好的例子

class Car {
    private $make = 'Honda';
    private $model = 'Accord';
    private $color = 'white';

    public function setMake($make) {
        $this->make = $make;

        //NOTE: Returning this for chaining
        return $this;
    }

    public function setModel($model) {
        $this->model = $model;

        //NOTE: Returning this for chaining
        return $this;
    }

    public function setColor($color) {
        $this->color = $color;

        //NOTE: Returning this for chaining
        return $this;
    }

    public function dump() {
        var_dump($this->make, $this->model, $this->color);
    }
}

$car = (new Car())
       ->setColor('pink')
       ->setMake('Ford')
       ->setModel('F-150')
       ->dump();

组合比继承更好

正如Gang of Four在《设计模式》(Design Patterns)中所陈述的那样,应该尽可能地使用组合而不是继承，尽管组合和继承都有很多的优点。这句话告诉我们，当你想到要用继承的时候，你可以尝试想想组合是不是能够更好的解决你的问题。在某些情况下，是这样的。

你可能会疑惑，“那我什么时候使用继承呢？”这取决于你手头上的问题，下面有一个相当不错的列表告诉你什么时候继承比组合更有效。
1. 继承代表的是is-a关系而不是has-a关系(Human->Animal vs. User->UserDetails)。
2. 从基类中重用代码(人类可以像动物一样移动)。
3. 希望通过更改一个基类来对派生类进行全局更改（改变所有动物移动时的热量消耗）。

不好的例子

class Employee {
    private $name;
    private $emial;

    public function __construct($name, $email) {
        $this->name = $name;
        $this->emial = $emial;
    }

    // ...
}

// Bad because Employees "have" tax data
// EmployeeTaxData is not a type of Employee

class EmployeeTaxData extends Employee {
    private $ssn;
    private $salary;

    public function __construct($name, $email, $ssn, $salary) {
        parent::__construct($name, $email);

        $this->ssn = $ssnl
        $this->salary = $salary;
    }

    // ...
}

好的例子

class EmployeeTaxData {
    private $ssn;
    private $salary;

    public function __construct($ssn, $salary) {
        $this->ssn = $ssn;
        $this->salary = $salary;
    }

    // ...
}

class Employee {
    private $name;
    private $email;
    private $taxData;

    public function __construct($name, $email) {
        $this->name = $name;
        $this->email = $email;
    }

    public function setTaxData($ssn, $salary) {
        $this->taxData = new EmployeeTaxData($ssn, $salary);
    }

    // ...
}

不要重复工作

请重视DRY原则。

尽你最大努力避免重复代码。重复代码是很不好的，因为它意味着当你需要修改一些逻辑的时候你需要修改不止一处代码。

想象一下，你在经营一家餐馆，你会记录下所有的库存：西红柿、洋葱、大蒜、香料等等。如果你有很多这样的清单，当你端上一盘西红柿之后，你需要更新你所有的清单。如果你只有一张清单，你就只需要更新这一个地方。

重复代码一般是因为你有两个或者更多的很大部分一致但细微处有差别的工作，但是他们的不同之处迫使你使用了两个或者更多的功能差不多的函数来处理。删除重复代码意味着你需要创建一个抽象，使得你只需要一个类/模块/类就可以处理这类不同的事情。

提取抽象是至关重要的，这就是为什么你需要遵守在类 Classes中所讲的SOLID原则。不好的抽象比重复代码更糟糕，所以一定要小心！说了这么多，如果能提取一个很好的抽象，那么就去做吧！不重复工作，否则你就会发现当你想修改一个逻辑是你会需要修改很多地方。

不好的例子

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

        render($data);
    }
}

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

        render($data);
    }
}

好的例子

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

        render($data);
    }
}

非常好的例子

精简代码会更好。

function showList($employees) {
    foreach ($employees as $employee) {
        render([
            $employee->calculateExpectedSalary(),
            $employee->getExperience(),
            $employee->getGithubLink()
        ]);
    }
}
__流年__
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
《架构整洁之道》&《 重构改善既有代码的设计》 整合
仙路看近行远
01-14 5383
  一、重构定义： 在不改变软件可观察行为的前提下，对软件内部进行调整(使用重构手法)，以提高其可理解性，降低其修改成本。 -- 重点在两点： 1. 不改变软件的可观察行为。2. 提高其可理解性。 两个目的：1. 添加新功能。 2. 重构。 --重构就只管修改程序结构，不要添加新功能。 添加新功能就不要修改既有代码。两者混合进行会使得程序朝不可理解的方向发展。 ps: 重构与设计模式具有辩...
后端架构说明.pdf
11-26
随着互联网应用越来越大，越来越复杂，对支撑应用的后端提出了越来越多的要求。 应用不仅 要快速、稳定、容易水平扩展，而且要能迅速响应业务需求， 而面向服务的分布式架构便应运 而生。
架构整洁之道-书中箴言
A9925的专栏
01-02 284
金玉良言 走快的唯一方法是先走好。 做一个好的软件架构师所需要的自律和专注程度可能会让大部分程序员始料未及。 软件系统不应该依赖其不直接使用的组件。 程序规模上的墨菲定律 程序的规模会一直不断地增长下去，直到将有限的编译和链接时间填满为止。
架构整洁之道：优秀设计或多余，有效设计最可取
博文视点（北京）官方博客
10-19 1555
人们经常谈论优秀设计和糟糕设计。你的设计属于哪一种？ 有很多软件开发团队的设计从来经不起思考。他们采用一种我称之为“任务板挪卡” 的方法来代替设计。团队有一个开发任务清单，比如 Scrum 产品待办列表，其中的任务被张贴在“任务板”上，然后他们可以将一张便利贴从“任务板”上的“待办”泳道移动到“进行中”泳道，这就是“任务板挪卡”。 产品经理提出待办项（任务），然后来一次“任务板挪卡”，这便构成...
c++代码整洁之道pdf_豆瓣评分8.6！将近400页的代码整洁之道，其实重点就5个点...
weixin_39574868的博客
11-13 698
程序员书库(ID：CodingBook)编译链接：https://medium.com/better-programming/clean-code-5-essential-takeaways-2a0b17ccd05cBob叔有一句名言：任何一个傻瓜都能写出计算机可以理解的代码，惟有写出人类容易理解的代码，才是优秀的程序员。Bob叔的《代码整洁之道》相信大家都不陌生，2008年出版，一直被...
php小技巧之过滤ascii控制字符
10-25
最后，使用`trim()`函数去除新字符串的首尾空白，以确保返回的字符串干净整洁。这个方法简单有效，适用于大多数情况下的ASCII控制字符过滤。 然而，这个方法并不全面，因为它只处理了部分常见的ASCII控制字符。在更...
PHP编码规范之注释和文件结构说明
10-29
一个整洁的文件结构有助于快速定位和理解代码。通常，一个PHP项目会按照以下结构组织： - `images`：存储图片资源。 - `include`：包含需要在整个系统中引用的文件，如库、框架等。 - `parameter`：存放参数文件，...
PHP框架DoYouHaoBaby-PHP
06-24
<p>DoYouHaoBaby ( 全名：The DoYouHaoBaby PHP Framework )是一个极具美学价值的PHP开发框架，从代码、注释、文 档以及系统工具的用户界面均追求干净、整洁而高效。 发布页<a>...
4005干净整洁黑白风格HTML5模板5623_企业网站模板PHP整站源码.zip.7z
08-01
4005干净整洁黑白风格HTML5模板5623_企业网站模板PHP整站源码.zip.7z
Small_PHP_Framework
03-26
模板引擎可以帮助分离业务逻辑和展示逻辑，使得HTML更加整洁，同时增强代码的可维护性。 数据库操作是许多Web应用的基础。"Small_PHP_Framework"可能提供了一种ORM（对象关系映射）机制，简化了与数据库的交互。...
整洁的架构
10-02
blob大叔写了几个的架构设计，与其学习ddd这类术，不如学习架构最基本的道。
漫谈兼容内核 毛德操
11-29
漫谈兼容内核 毛德操 完整版 pdf漫谈兼容内核 毛德操漫谈兼容内核 毛德操漫谈兼容内核 毛德操
php代码整洁之道(有空需要多看多练习，养成习惯）
chongluo0179的博客
08-20 607
Clean Code PHP 介绍 本文参考自 Robert C. Martin的Clean Code书中的软件工程师的原则 ,适用于PHP。 这不是风格指南。 这是一个关于开发可读、可复用并且可重构的PHP软件指南。 并不是这里所有的原则都得遵循，甚至很少的能被普遍接受。 这些虽...
架构整洁之道, 看这一篇就够了！
阿里技术
05-14 4960
阿里妹导读：程序的世界飞速发展，今天所掌握的技能可能明年就过时了，但有些知识历久弥新，掌握了它们，你在程序的海洋中就不会迷路，架构思想就是这样的知识。本文是《架构整洁之道...
php代码整洁之道（代码整洁之道总结）
梁晓伟
03-09 574
1、任何函数只能做一件事这是迄今为止软件工程里最重要的一个规则。当函数做超过一件事的时候，他们就难于实现、测试和理解。当你隔离函数只剩一个功能时，他们就容易被重构，然后你的代码读起来就更清晰。如果你光遵循这条规则，你就领先于大多数开发者了。2、函数名应该描述他们所做的事情3、删除重复的代码尽你最大的努力来避免重复的代码。重复代码不好，因为它意味着如果你修改一些逻辑，那就有不止一处地方要同步修改了。...
PHP 代码简洁之道 （ PHP Clean Code）
Eric专栏
02-06 1491
介绍 Robert C.Martin’s 的 软件工程师准则 Clean Code 同样适用于PHP。它并不是一个编码风格指南，它指导我们用PHP写出具有可读性，可复用性且可分解的代码。 并非所有的准则都必须严格遵守，甚至一些已经成为普遍的约定。这仅仅作为指导方针，其中许多都是 Clean Code 作者们多年来的经验。 尽管许多开发者依旧使用 PHP 5版本，但是这篇文章中绝大多数例子都是
PHP 进阶：代码整洁之道
GitChat
01-07 331
探讨通用的整洁代码原则，结合 PHP7 的新特性写出干净整洁的代码。PHP 语言的很多灵活性建立在不受约束之上，Rails 之父汉森说过“灵活性被过分高估，约束才是解放”。抛弃传统的 PHP 观念，拥抱现代 PHP 才是未来。 软件的质量，不但依赖于架构而且与代码质量紧紧相关。代码质量与其整洁度成正比，整洁的代码既在质量上比较可靠，也为后期维护和升级奠定了良好的基础。软件架构的提高需要长期的积累，...
php 漂亮的代码,如何写出漂亮的代码-代码整洁之道
weixin_35118333的博客
03-24 225
背景代码本就该是直接简单的，横就是横，纵就是纵，架构原本也本是清晰明了的，模块是模块，过程是过程。可随着项目生命周期的变长，随着需求不断的被实现，面对不同思想的人，不同场景的要求，不同技能水平的实施，就让原本平直的路走成了立交桥，织成了逻辑网。这时候再浏览代码，要走通某一个流程，即便是熟悉路况的“本地人”，编写代码的“原住民”也不一定能走的顺畅。Robert Martin的这句话非常合适：“唯一能...
代码整洁之道--------整洁代码
@日月空@的博客
06-03 2489
软件质量不但依赖于整体的项目架构及项目管理，而且与代码质量紧密相关。书中有一个观点我觉得很对：代码质量与代码整洁度成正比。干净的代码，既在质量上较为可靠，也为后期的项目维护、迭代奠定了良好的基础。 一、糟糕的代码 作者用一个故事讲述了糟糕的代码造成的后果： 有家公司写了个很流行的应用，推出后很多专业人士都买来用。但是好景不长，慢慢的迭代周期开始拉长，bug总是...
基于php网上答疑系统在线答疑设计与实现.docx
最新发布
11-12
3. 管理员模块：管理员拥有最高的权限，可以对整个系统进行管理，包括删除不当或重复的问题，维护平台的秩序和整洁。 在系统实现过程中，数据库技术起着至关重要的作用。通常会使用如MySQL这样的关系型数据库管理...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值