Strategy Design Pattern (simple example implementation in PHP)

Osaigbovo Emmanuel — Sun, 07 Feb 2021 21:00:28 +0000

NOTE - Please everything written down here is extracted from books which I read years ago and actually jotted down in a notebook (to be honest I don't remember the names of these books), I realized that keeping this information inside a notebook is not the best of options, come on what if something happened to my notebook? Also, I wanted this to be available to everyone who might have been wanting to understand the Strategy Design Pattern as well -:)

If you have not read my previous post on Factory Design Pattern, please do well to check it out.

The strategy design pattern is a type of behavioural pattern. Behavioural patterns are used to address how an application runs. As a comparison, the factory pattern can change the object type on the fly.

The Strategy design pattern comes in handy when we have multiple chunks of code performing similar operations. It defines an encapsulated and interchangeable family of algorithms(an algorithm just being a process or set of code used to solve a problem).

The strategy design pattern is most useful in situations where you have classes that may be similar, but not related, and differ only in their specific behaviour. For example, say you need a filtering system for strings, Different filters might include

Stripping out HTML
Crossing out swear words
Catching character combinations that can be used to send spam through contacts form and the like.

The only quality that these three approaches have in common is that they are all applied to strings, other than that there are no commonalities that might suggest they would make sense as derived subclasses from a base class (factories).

Furthermore, these filters might be applied differently on the fly. For example, an application switch might indicate whether or not HTML or swear words are allowed in the text. This, then, is a good candidate for the strategy pattern.

First, start by defining an interface that dictates the needed functionality:

interface Filter {
     public function filter($str);
}

Specific filters types then implement their specific versions of the interface's methods:

class HTMLFilter implements Filter {
    public function filter($str) {
       //strip out the HTML
       return $str;
    } 
}

class SwearFilter implements Filter {
   public function filter($str) {
     //cross out swear words
     return $str;
   }
}

Finally, another class would be written that could use any filter:

class FormData {
   private $data;

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

   public function process(Filter $type)
   {
      return $this->data = $type->filter($this->data);
   }
}

In the Strategy design pattern, an interface is implemented by more concrete classes, which in turn are used by a specific object (the context, FormData in this case).
In that code, the process() method expects to receive an object of type Filter through which the data would then be run.

$form = new FormData($someUserInput)
{
    if(//no HTML is allowed) {
      $form->process(new HTMLFilter);  
    }

   if(//no swear words allowed) { 
      $form->process(new SwearFilter);
   }
}

Factory Design Pattern (simple example implementation in PHP)

Osaigbovo Emmanuel — Sat, 06 Feb 2021 19:19:22 +0000

NOTE - Please everything written down here is extracted from a book which I read years ago and actually jotted down in a notebook (to be honest I don't remember the name of this book), I realized that keeping this information inside a notebook is not the best of options, come on what if something happened to my notebook? Also, I wanted this to be available to everyone who might have been wanting to understand the Factory Design Pattern as well -:)

If you have not read my previous post on Strategy Design Pattern Pattern, please do well to check it out.

The Factory design pattern becomes useful in situations where the type of object that needs to be generated isn't known when the program is written but only once the program is running.

Another clue for when the factory pattern might be appropriate is when there is an abstract base class and different subclasses will need to be created on the fly.

This particular design structure is important with the factory pattern, as once you have created the object, regardless of its specific type, the use of the object will be consistent.

The factory design pattern works via a state method,commonly named create(), factory(), factoryMethod() or createInstance(). The method takes at least one argument which indicates the type of object to create, the method returns an object of that type.

 Factory

 + create ($type) : Product
    .
    .
    .

Concrete Factory          ========>  Object of that class 
                                     type eg Product
+ create ($type) : Product

In the factory design pattern, the abstract factory base class is extended by concrete factory classes that will output objects of that class type.

Let's see how this will be implemented in the following example. which will create a different type of shape based on the input provided to the page through the URL.

To create a Factory

1) Add a new PHP Script in your text editor or IDE to be named ShapeFactory.php

2) Start defining the ShapeFactory class:


abstract class ShapeFactory {
 // the factory class will be abstract, just as the shape itself is. you will never create an instance of the ShapeFactory class. 
}

3) Start defining the static method

public static function create($type, array $sizes) {
// this static method will take two arguments: the type of shape to create and an array of sizes. For a rectangle, that array would contain two values, for a triangle, three, and for a circle, only one (the radius)

4) create a different object based on that type of value

switch($type) {
case 'rectangle'
 return new Rectangle($sizes[0], $sizes[1]);
break;
case 'triangle'
 return new Triangle($sizes[0], $sizes[1], $sizes[3]);
break;
case 'circle'
 return new Circle($sizes[0]);
break
}//end of switch

The switch checks the value of $type against the expected value for now just these shapes are recognized.

NOTE - A complete version of this class would throw an exception if improper values were provided

To use the ShapeFactory class

$obj = ShapeFactory::create($GET['shape'], $GET['dimentions']);

/**
to create the object, the static method of the ShapeFactory class is invoked, passing it the value that came from the URL.
**/

/**
In a more realized version of this script, one would add error handling here to confirm that the shape object was created before attempting to use it in the following steps
**/
$area = $obj->getArea();

Forem: Osaigbovo Emmanuel

Strategy Design Pattern (simple example implementation in PHP)

Factory Design Pattern (simple example implementation in PHP)