Python和PHP之策略模式

    在项目开发的过程中经常会遇到很多有关if else的判断，采用策略模式可以可以替换这种繁杂的逻辑判断，而且便于项目的维护和扩展，降低在项目中的代码耦合性！
Python篇：
# -*- coding:utf-8 -*-
__author__ = 'yxq'

'''
  策略模式：替代多层的if else条件判断
  
'''
bigProductUrlPrefix = 'http://ip/'
smallProductUrlPrefix = 'http://ip/public/index.php/'

'''
定义一个抽象类
'''
class FetchUrl(object):
    def geturl(self,*param):
        pass
#获取大产品url
class FetchBigUrl(FetchUrl):
    def geturl(self,*param):
        param = parma.split(',')
        return bigProductUrlPrefix+ param[0] + "?"+param[1]+"?"+param[2]

#获取小产品url
class FetchSmallUrl(FetchUrl):
    def geturl(self,*param):
        param = parma.split(',')
        return smallProductUrlPrefix+ param[0] + "?"+param[1]+"?"+param[2]

#获取小产品url
class FetchOldUrl(FetchUrl):
    def geturl(self,*param):
        param = parma.split(',')
        return smallProductUrlPrefix+ param[0] + "?"+param[1]+"?"+param[2]

#获取实例
class GetContent(object):
    def __init__(self,obj):
        self.obj = obj
    def getUrl(self,*param):
        return self.obj.geturl(param)

if __name__ == '__main__':
    parma = input("请输入参数：")
    if len(parma.split(',')) != 3:
        print("传输的参数个数不对，请确认后在提交")
    allUrl = []
    # resultUrl = GetContent(FetchBigUrl())
    resultUrl = GetContent(FetchSmallUrl())
    print(resultUrl.getUrl(parma))

PHP篇：

<?php
    #抽象策略接口
    interface FetchUrl{
        public function getUrl();
    }
    #或者定义一个抽象类 

   abstract class FetchUrl{

     public function getUrl();

   }
    #具体算法类 实现具体的事情
    class FetchBigUrl implements FetchUrl{
        public function getUrl(){
            echo "Big";
        }
    }

    class FetchSmallUrl implements FetchUrl{
        public function getUrl(){
            echo "Small";
        }
    }
    
    #配置类  使用抽象策略接口配置
    class GetContent{
        public $config;

        public function __construct(FetchUrl $obj){
            $this->config = $obj;
        }

        public function execute(){
            return $this->config->getUrl();
        }
    }

    $m = new GetContent(new FetchBigUrl());
    $m->execute();

   #单例模式  确保类只有一个实例
   class Single{

          #定义一个静态变量
          public static $instance;

          #私有构造方法
          public function __construct(){}
          #声明一个静态方法
          public static function getInstance(){
                 if(!self::$instance){
                self::$instance = new self();
                 }
                 return self::$instance;
          }
          #防止克隆
          private function __clone(){}
   }

   var_dump(Single::getInstance());
   var_dump(Single::getInstance());
   exit;

 

    #注册模式解决全局共享和交换对象
    class Register
    {
        protected static  $objects;//全局树  array
     
        //设置
        static function set($alias,$object)
        {
            self::$objects[$alias] = $object;
        }
        //获得
        static function get($alias)
        {
            return self::$objects[$alias];
        }
        //注销
        static function _unset($alias)
        {
            unset(self::$objects[$alias]);
        }
    }
     
    Register::set('conf',array('dbhost'=>'127.0.0.1'));
    print_r(Register::get('conf'));