SOLID सिद्धांतों की सरल व्याख्या

सिद्धांत SOLID एक प्रोग्रामिंग मानक है जिसे सभी डेवलपर्स को खराब वास्तुकला बनाने से बचने के लिए अच्छी तरह से समझना चाहिए। इस मानक का व्यापक रूप से ओओपी में उपयोग किया जाता है। यदि सही तरीके से लागू किया जाता है, तो यह कोड को अधिक एक्स्टेंसिबल, तार्किक और पठनीय बनाता है। जब कोई डेवलपर एक एप्लिकेशन बनाता है, तो खराब आर्किटेक्चर द्वारा निर्देशित, कोड अनम्य हो जाता है, यहां तक ​​कि इसमें छोटे-छोटे बदलाव भी बग पैदा कर सकते हैं। इसलिए, आपको SOLID के सिद्धांतों का पालन करना चाहिए।

उन्हें मास्टर करने में कुछ समय लगेगा, लेकिन यदि आप इन सिद्धांतों के अनुसार कोड लिखते हैं, तो इसकी गुणवत्ता बढ़ जाएगी, और आप एक अच्छे सॉफ्टवेयर आर्किटेक्चर के निर्माण में महारत हासिल करेंगे।

एसओएलआईडी के सिद्धांतों को समझने के लिए, आपको स्पष्ट रूप से समझने की आवश्यकता है कि इंटरफेस का उपयोग कैसे करें। यदि आपको ऐसी समझ नहीं है, तो पहले दस्तावेज पढ़ें।

मैं SOLID को सबसे सरल तरीके से समझाऊंगा, इसलिए शुरुआती लोगों के लिए यह पता लगाना आसान है। हम एक-एक करके सिद्धांतों पर विचार करेंगे।

एकल जिम्मेदारी सिद्धांत

वर्ग परिवर्तन के लिए केवल एक कारण है।

एक वर्ग को केवल एक समस्या का समाधान करना चाहिए। इसके कई तरीके हो सकते हैं, लेकिन उनका उपयोग केवल एक सामान्य समस्या को हल करने के लिए किया जाना चाहिए। सभी तरीकों और गुणों को एक उद्देश्य की सेवा करनी चाहिए। यदि किसी वर्ग के कई उद्देश्य हैं, तो उसे अलग-अलग वर्गों में विभाजित किया जाना चाहिए।

एक उदाहरण पर विचार करें:

<?php
namespace Demo;
use DB;

class OrdersReport
{
    public function getOrdersInfo($startDate, $endDate)
    {
        $orders = $this->queryDBForOrders($startDate, $endDate);
        
        return $this->format($orders);
    }

    protected function queryDBForOrders($startDate, $endDate)
    {   // If we would update our persistence layer in the future,
        // we would have to do changes here too. <=> reason to change!
        return DB::table('orders')->whereBetween('created_at', [$startDate, $endDate])->get();
    }

    protected function format($orders)
    {   // If we changed the way we want to format the output,
        // we would have to make changes here. <=> reason to change!
        return '<h1>Orders: ' . $orders . '</h1>';
    }
}

. ? , (, ). .

, , , XML, JSON, HTML ..

:

<?php
namespace Report;
use Report\Repositories\OrdersRepository;

class OrdersReport
{
        protected $repo;
        protected $formatter;

        public function __construct(OrdersRepository $repo, OrdersOutPutInterface $formatter)
        {
                $this->repo = $repo;
                $this->formatter = $formatter;
        }

        public function getOrdersInfo($startDate, $endDate)
        {
                $orders = $this->repo->getOrdersWithDate($startDate, $endDate);

                return $this->formatter->output($orders);
        }
}

namespace Report;

interface OrdersOutPutInterface
{
        public function output($orders);
}

namespace Report;

class HtmlOutput implements OrdersOutPutInterface
{
        public function output($orders)
        {
                return '<h1>Orders: ' . $orders . '</h1>';
        }

}

namespace Report\Repositories;
use DB;

class OrdersRepository
{
    public function getOrdersWithDate($startDate, $endDate)
    {
        return DB::table('orders')->whereBetween('created_at', [$startDate, $endDate])->get();
    }
}

/ (Open-closed Principle)

, .

(, , ) . , .

:

<?php
class Rectangle
{
    public $width;
    public $height;
    public function __construct($width, $height)
    {
        $this->width = $width;
        $this->height = $height;
    }
}

class Circle
{
    public $radius;
    public function __construct($radius)
    {
        $this->radius = $radius;
    }
}

class AreaCalculator
{
    public function calculate($shape)
    {
        if ($shape instanceof Rectangle) {
            $area = $shape->width * $shape->height;
        } else {
            $area = $shape->radius * $shape->radius * pi();
        }
        
        return $area;
    }
}

$circle = new Circle(5);
$rect = new Rectangle(8,5);
$obj = new AreaCalculator();
echo $obj->calculate($circle);

, AreaCalculator. /, , .

? :

<?php
interface AreaInterface
{
    public  function calculateArea();
}

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

    public function __construct($width, $height)
    {
        $this->width = $width;
        $this->height = $height;
    }
    public  function calculateArea(){
        $area = $this->height *  $this->width;
        return $area;
    }
}
  
class Circle implements  AreaInterface
{
    public  $radius;

    public function __construct($radius)
    {
        $this->radius = $radius;
    }
    
    public  function calculateArea(){
        $area = $this->radius * $this->radius * pi();
        return $area;
    }
}

class AreaCalculator
{
    public function calculate($shape)
    {
        $area = 0;
        $area = $shape->calculateArea();
        return $area;
    }
}

$circle = new Circle(5);
$obj = new AreaCalculator();
echo $obj->calculate($circle);

, AreaCalculator.

(Liskov Substitution Principle)

“Data abstraction” 1987-. 1994- :

φ(x) — x T. φ(y) y S, S — T.

, , :

1. .
2. .
3. .

1996- , :

, , , .

: / / .

, () , . , , , , , , . .

:

<?php
interface LessonRepositoryInterface
{
    /**
     * Fetch all records.
     *
     * @return array
     */
    public function getAll();
}

class FileLessonRepository implements LessonRepositoryInterface
{
    public function getAll()
    {
        // return through file system
        return [];
    }
}

class DbLessonRepository implements LessonRepositoryInterface
{
    public function getAll()
    {
        /*
            Violates LSP because:
              - the return type is different
              - the consumer of this subclass and FileLessonRepository won't work identically
         */
        // return Lesson::all();

        // to fix this
        return Lesson::all()->toArray();
    }
}

(Interface Segregation Principle)

, .

, , .

, .

:

<?php
interface workerInterface
{
    public  function work();
    public  function  sleep();
}

class HumanWorker implements workerInterface
{
    public  function work()
    {
        var_dump('works');
    }

    public  function  sleep()
    {
        var_dump('sleep');
    }
}

class RobotWorker implements workerInterface
{
    public  function work()
    {
        var_dump('works');
    }

    public  function sleep()
    {
        // No need
    }
}

RobotWorker’ , sleep, . . :

<?php
interface WorkAbleInterface
{
    public  function work();
}

interface SleepAbleInterface
{
    public  function  sleep();
}

class HumanWorker implements WorkAbleInterface, SleepAbleInterface
{
    public  function work()
    {
        var_dump('works');
    }
    
    public  function  sleep()
    {
        var_dump('sleep');
    }
}

class RobotWorker implements WorkAbleInterface
{
    public  function work()
    {
        var_dump('works');
    }
}

(Dependency Inversion Principle)

. .

. .

: , - .

, , , .

:

<?php
class MySQLConnection
{
   /**
   * db connection
   */
   public function connect()
   {
      var_dump('MYSQL Connection');
   }
}

class PasswordReminder
{    
    /**
     * @var MySQLConnection
     */
     private $dbConnection;
     

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

, « » « ». .

, , MySQLConnection PasswordReminder, MySQLConnection. PasswordReminder MySQLConnection.

MySQLConnection MongoDBConnection, PasswordReminder.

PasswordReminder , - . ? :

<?php
interface ConnectionInterface
{
    public function connect();
}

class DbConnection implements ConnectionInterface
{

    /**
     * db connection
     */
    public function connect()
    {
        var_dump('MYSQL Connection');
    }
}

class PasswordReminder
{
    /**
     * @var ConnectionInterface
     */

    private $dbConnection;

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

MySQLConnection MongoDBConnection. PasswordReminder, PasswordReminder .