PHP中的坚实原则-DEV365 开发者社区

什么是固体？

您可能已经在几乎每个职位描述中都听过这个术语**SOLID**，并想知道为什么它很重要。稳固的原则是一组五种设计指南，旨在使软件设计更加易于理解，灵活和可维护。这些原理被广泛用于对象的编程中，尽管它们也可以在其他范式中应用。

坚固的柱子

首字母缩写固体代表：

单个责任原则（SRP）
开放原理（OCP）
Liskov替代原则（LSP）
接口隔离原理（ISP）
依赖性反转原理（DIP）

1）单一责任原则

班级应该只有一个理由或目的服务。这意味着班级应该只有一个责任。我将与PHP示例一一展示。

// Single Responsibility Principle

// Shouldn't do
class Report {
    public function generate() {
        // generating report
    }

    public function saveToFile($filename) {
        // save report to file
    }
}

// Should do
class Report {
    public function generate() {
        // generating report
    }
}

class ReportSaver {
    public function saveToFile(Report $report, $filename) {
        // save report to file
    }
}

2）开放原理

实例应开放以进行扩展，但要关闭以进行修改。这个平均实例（类，功能，模块等）可以通过另一个实例扩展，但不应直接修改它们。

// Open Close Principle

// Shouldn't do
class Rectangle {
    public $width;
    public $height;
}

function area($rectangle) {
    return $rectangle->width * $rectangle->height;
}

// Should do
interface Shape {
    public function area();
}

class Rectangle implements Shape {
    public $width;
    public $height;

    public function area() {
        // w * h
    }
}

class Circle implements Shape {
    public $radius;

    public function area() {
        // πr2
    }
}

3）Liskov替代原则

这意味着超类的对象应可以用子类的对象代替，而不会影响程序的正确性。这意味着什么？好吧，让我们看看澄清的示例代码。

// Liskov Substitution Principle

// Shouldn't do
class Animal {
    public function jump() {
        // code for jumping
    }
}

class Snail extends Animal {
    public function jump() {
        // Sanil can't jump
    }
}

// Good example
abstract class Animal {
    abstract public function eat();
}

class Snail extends Bird {
    public function eat() {
        // every animal can eat
    }
}

class Tiger extends Bird {
    public function eat() {
        // every animal can eat
    }
}

4）接口隔离原理

我们不应该强迫实例实现他们不使用的接口。我们应该在大多数情况下使接口灵活。

// Interface Segregation Principle

// Shouldn't do
interface Human {
    public function walk();
    public function swim(); // not everyone can swim
}

// Should do
interface Walkable {
    public function walk();
}

interface Swimmable {
    public function swim();
}

class People implements Walkable, Swimmable {
    public function walk() {
        // walking
    }

    public function swim() {
        // swimming
    }
}

5）依赖性反转原理

该原理旨在将低水平模块（提供基本功能）的高级模块（提供复杂的功能）解脱，通过引入它们之间的抽象层。这允许高级和低级模块依赖于抽象，而不是稳定的实现，从而使系统更加灵活，可扩展和可维护。

// Dependency Inversion Principle

// Shouldn't do
class Book {
    public function getContent() {
        // return contents
    }
}

class Printer {
    public function printBook(Book $book) {
        $content = $book->getContent();
        // print the content
    }
}

您可以在上面的示例中看到，打印机类取决于 book 对象，并且只能打印为 book 。如果还有另一个称为文章的类可能要打印怎么办？我们不应该修改打印机类以接受更多对象。相反，我们提供了它们之间的抽象。

// Dependency Inversion Principle

// Should do
interface Printable {
    public function getContent();
}

class Book implements Printable {
    public function getContent() {
        return "This is the book content";
    }
}

class Article implements Printable {
    public function getContent() {
        return "This is the article content";
    }
}

class Printer {
    public function printContent(Printable $printable) {
        $content = $printable->getContent();
        echo "Printing content: " . $content;
    }
}

在PHP中，这些原理有助于创建一个更容易调试，理解和扩展的干净代码库。鉴于PHP的应用通常会随着时间的流逝而发展，因此应用坚实的原理可以极大地减轻生长和维护的痛苦。