每日归档： 2017年2月26日

小实验 – 直接调用抽象方法内的静态方法来实例化子类

leokim / / PHP, 技术, 设计模式
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
<?php
 
abstract class ParamHandler{
    protected $source;
    protected $params = array();
 
    function __construct($source){
        $this->source = $source;
    }
 
    function addParam($key, $val){
        $this->params[$key] = $val;
    }
 
    function getAllParams(){
        return $this->params;
    }
 
    static function getInstance($filename){
        if(preg_match("/\.xml$/i", $filename)){
            return New XmlParamHandler($filename);
       }
 
       return New TextParamHandler($filename);
    }
 
    abstract function write();
    abstract function read();
}
 
class XmlParamHandler extends ParamHandler{
    function read(){
        echo 'XmlParamHandler Read.';
    }
 
    function write(){
        echo 'XmlParamHandler Write.';
    }
}
 
class TextParamHandler extends ParamHandler{
    function read(){
        echo 'TextParamHandler Read.';
    }
 
    function write(){
        echo 'TextParamHandler Write.';
    }
}
 
//抽象方法不能直接实例化，直接调用抽象方法内的静态方法来实例化子类
//这样也行 尼玛......
$test = ParamHandler::getInstance("./params.xml");
$test->addParam("key1","value1");
$test->addParam("key2","value2");
$test->addParam("key3","value3");
$test->write();
?>

php 反射API

leokim / / PHP, 技术, 设计模式
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
<?php
 
class Person{
    public $name;
    function __construct($name){
        $this->name = $name;
    }
}
 
interface Module{
    function execute();
}
 
class FtpModule implements Module{
    private $host;
    private $user; 
 
    function setHost($host){
        $this->host = $host;
        echo "FtpModule::setHost() : {$this->host} <br/>";
    }
 
    function setUser($user){
        $this->user = $user;
        echo "FtpModule::setUser() : {$this->user} <br/>";
    }
 
    function execute(){
        //执行一些操作
        echo "Host: {$this->host} & User: {$this->user} <br/>";
    }
}
 
class PersonModule implements Module{
    private $name;
 
    function setPerson( Person $person ){
        $this->name = $person->name;
        echo "PersonModule::setPerson() :  {$person->name} <br/>";
    }
 
    function execute(){
        //执行一些操作
        echo "Name: {$this->name}<br />";
    }
}
 
class ModuleRunner{
    private $configData = array(
            "PersonModule" => array('person'=>'leokim'),
            "FtpModule" => array('host'=>'www.leokim.cn','user'=>'leokim')
        );
 
    private $modules = array();
 
    function init(){
        $interface = new ReflectionClass('Module');
 
        foreach($this->configData as $modulename => $params){
            $module_class = new ReflectionClass($modulename);
 
            if( !$module_class->isSubclassOf($interface)){
                throw new Exception("unknow module type:$modulename");
            }
            $module = $module_class->newInstance();
 
            foreach($module_class->getMethods() as $method){
                //module，module内的方法，方法的参数
                $this->handleMethod($module, $method, $params);
            }
            array_push($this->modules, $module);
        }
    }
 
    //handleMethod()检验并调用Module对象的setter方法
    function handleMethod(Module $module, ReflectionMethod $method, $params){
        $name = $method->getName();
        //所需要的参数
        $args = $method->getParameters();
         
        if(count($args) != 1 || substr($name, 0, 3) != "set"){
            return false;
        }
 
        $property = strtolower(substr($name, 3));
        if(!isset($params[$property])){
            return false;
        }
 
        print_r($args[0]);
        echo ' | ';
 
        //ReflectionMethod::invoke()。它以一个对象和任意数目的方法作为参数
        //可以通过两种途径调用invoke()方法：
        //1.如果setter方法不需要对象参数，可以用用户提供的属性字符串来调用ReflectionMethod::invoke()。
        //2.如果方法需要对象作为参数，可以使用属性字符串来实例化正确类型的对象，然后传递给setter。
        //这个例子里 Person是有Class的 所以在else里执行，Ftp并没有Class所以在if里执行
        $arg_class = $args[0]->getClass();
 
        if(empty($arg_class)){
            $method->invoke($module, $params[$property]);
        }else{
            $method->invoke($module, $arg_class->newInstance($params[$property]));
        }
 
        //执行固有的function execure()
        $module->execute();
 
    }
}
 
 
//在ModuleRunner::init()方法运行时，ModuleRunner对象存储着许多Module对象，而所有Module对象都包含着数据。
//ModuleRunner类现在可以用一个类方法来循环遍历没个Module对象，并逐一调用各Module对象中的excute()方法
$test = new ModuleRunner();
$test->init();
 
?>

CI 3.1.3 源码分析(一)

leokim / / PHP, 技术

仅是自己分析源码时的笔记参考 并不是教程之类的文章

  1. 入口文件index.php

    主要定义了报错类型以及设置各种路径常量 

  2. CodeIgniter.php

    1. load application文件夹下的常量文件（constants .php）

    load system  文件夹下的common.php

    自定义加载目录下的class，默认加载libraries目录下的class，首先加载core/下的，然后加载application/下的

    默认用“CI_”这个prefix，其次使用自定义prefix 例如“MY_”

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    function &load_class($class, $directory = 'libraries', $param = NULL)
    {
       static $_classes = array();
     
       // Does the class exist? If so, we're done...
       if (isset($_classes[$class]))
       {
          return $_classes[$class];
       }
     
       $name = FALSE;
     
       // Look for the class first in the local application/libraries folder
       // then in the native system/libraries folder
       foreach (array(APPPATH, BASEPATH) as $path)
       {
          if (file_exists($path.$directory.'/'.$class.'.php'))
          {
             $name = 'CI_'.$class;
     
             if (class_exists($name, FALSE) === FALSE)
             {
                require_once($path.$directory.'/'.$class.'.php');
             }
     
             break;
          }
       }
     
       // Is the request a class extension? If so we load it too
       if (file_exists(APPPATH.$directory.'/'.config_item('subclass_prefix').$class.'.php'))
       {
          $name = config_item('subclass_prefix').$class;
     
          if (class_exists($name, FALSE) === FALSE)
          {
             require_once(APPPATH.$directory.'/'.$name.'.php');
          }
       }
     
       // Did we find the class?
       if ($name === FALSE)
       {
          // Note: We use exit() rather than show_error() in order to avoid a
          // self-referencing loop with the Exceptions class
          set_status_header(503);
          echo 'Unable to locate the specified class: '.$class.'.php';
          exit(5); // EXIT_UNK_CLASS
       }
     
       // Keep track of what we just loaded
       is_loaded($class);
     
       $_classes[$class] = isset($param)
          ? new $name($param)
          : new $name();
       return $_classes[$class];
    }

      然后加载config文件，默认加载Application目录下config/config.php，找不到才会检查config.php是否再自定义的路径里

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
function &get_config(Array $replace = array())
{
   static $config;
 
   if (empty($config))
   {
      $file_path = APPPATH.'config/config.php';
      $found = FALSE;
      if (file_exists($file_path))
      {
         $found = TRUE;
         require($file_path);
      }
 
      // Is the config file in the environment folder?
      if (file_exists($file_path = APPPATH.'config/'.ENVIRONMENT.'/config.php'))
      {
         require($file_path);
      }
      elseif ( ! $found)
      {
         set_status_header(503);
         echo 'The configuration file does not exist.';
         exit(3); // EXIT_CONFIG
      }
 
      // Does the $config array exist in the file?
      if ( ! isset($config) OR ! is_array($config))
      {
         set_status_header(503);
         echo 'Your config file does not appear to be formatted correctly.';
         exit(3); // EXIT_CONFIG
      }
   }
 
   // Are any values being dynamically added or replaced?
   foreach ($replace as $key => $val)
   {
      $config[$key] = $val;
   }
 
   return $config;
}

基本上其他的function 都是一些基础function简单过一下就看完了

下面要看的是core/libraries文件夹下的这些类库了

php中引用&的真正理解-变量引用、函数引用、对象引用

leokim / / PHP, 技术, 设计模式

5.3以后已经不赞成使用引用来传递参数了貌似

只是再分析CI3的源码的时候还是能看到函数引用

总之再复习一下吧

总没有坏处

====================================================================

    php的引用（就是在变量或者函数、对象等前面加上&符号） //最重要就是 删除引用的变量 ，只是引用的变量访问不了，但是内容并没有销毁 在PHP 中引用的意思是：不同的名字访问同一个变量内容.

变量的引用

        PHP 的引用允许你用两个变量来指向同一个内容 

1
2
3
4
5
6
7
8
<?php
$a="ABC"; 
$b =&$a; 
echo $a;//这里输出:ABC 
echo $b;//这里输出:ABC 
$b="EFG"; 
echo $a;//这里$a的值变为EFG 所以输出EFG echo $b;//这里输出EFG 
?>

  函数的传址调用 传址调用我就不多说了 下面直接给出代码

1
2
3
4
5
6
7
<?php
function test(&$a){ 
    $a=$a+100; 
} 
$b=1; 
echo $b;//输出１ test($b);   //这里$b传递给函数的其实是$b的变量内容所处的内存地址，通过在函数里改变$a的值　就可以改变$b的值了 echo "<br>"; echo $b;//输出101
?>

 要注意的是，在这里test(１);的话就会出错，原因是：PHP规定传递的引用不能为常量（可以看错误提示）。

1
2
3
4
5
6
7
8
9
10
11
12
<?php
function &test(){ 
    static $b=0;//申明一个静态变量 
    $b=$b+1; 
    echo $b; 
    return $b; }
}
$a=test();//这条语句会输出　$b的值　为１ 
$a=5; $a=test();//这条语句会输出　$b的值　为2
$a=&test();//这条语句会输出　$b的值　为3 
$a=5; $a=test();//这条语句会输出　$b的值　为6
?>

下面解释下：　 通过这种方式$a=test();得到的其实不是函数的引用返回，这跟普通的函数调用没有区别　至于原因：　这是ＰＨＰ的规定 ＰＨＰ规定通过$a=&test(); 方式得到的才是函数的引用返回 至于什么是引用返回呢（ＰＨＰ手册上说：引用返回用在当想用函数找到引用应该被绑定在哪一个变量上面时。) 这句狗屁话　害我半天没看懂

       用上面的例子来解释就是 $a=test()方式调用函数，只是将函数的值赋给$a而已，　而$a做任何改变，都不会影响到函数中的$b，而通过$a=&test()方式调用函数呢, 他的作用是　将return $b中的　$b变量的内存地址与$a变量的内存地址　指向了同一个地方 即产生了相当于这样的效果($a=&b;) 所以改变$a的值　也同时改变了$b的值　所以在执行了 $a=&test(); $a=5; 以后，$b的值变为了5

这里是为了让大家理解函数的引用返回才使用静态变量的，其实函数的引用返回多用在对象中

对象的引用 

1
2
3
4
5
6
7
8
9
10
<?php
class a{
    var $abc="ABC";
} 
$b=new a; 
$c=$b; 
echo $b->abc;//这里输出ABC 
echo $c->abc;//这里输出ABC $b->abc="DEF"; 
echo $c->abc;//这里输出DEF
?>

       以上代码是在PHP5中的运行效果 在PHP5中 对象的复制是通过引用来实现的。上列中$b=new a; $c=$b; 其实等效于$b=new a; $c=&$b; PHP5中默认就是通过引用来调用对象， 但有时你可能想建立一个对象的副本，并希望原来的对象的改变不影响到副本 . 为了这样的目的，PHP定义了一个特殊的方法，称为__clone.

引用的作用 

       如果程序比较大,引用同一个对象的变量比较多,并且希望用完该对象后手工清除它,个人建议用 "&" 方式,然后用$var=null的方式清除. 其它时候还是用php5的默认方式吧. 另外, php5中对于大数组的传递,建议用 "&" 方式, 毕竟节省内存空间使用。

取消引用 当你 unset 一个引用，只是断开了变量名和变量内容之间的绑定。这并不意味着变量内容被销毁了。例如：

<?php $a = 1; $b =& $a; unset ($a); ?>

不会 unset $b，只是 $a。 function quoteTest(){ global $var ; //相当于 $var = &$GLOBALS['var']; unset($var); //删除只是删除引用，而引用的内容还存在,同上这并不意味着变量内容被销毁了}$var=1;quoteTest();echo $var; //  结果 1

———————————————————————————————-

不会 unset $b，只是 $a。

function quoteTest(){ global $var ; //相当于 $var = &$GLOBALS['var']; $var = 5; //因为他们都指向 同一内存内容}$var=1;quoteTest();echo $var; //结果 5———————————————————————————————-

'&' 这就是引用

23111813-8cf28c728bcd4002b1bbee0ef6b99d4a.jpg

global 引用 当用 global $var 声明一个变量时实际上建立了一个到全局变量的引用。也就是说和这样做是相同的：

<?php $var =& $GLOBALS["var"]; ?>

这意味着，例如，unset $var 不会 unset 全局变量。

$this 在一个对象的方法中，$this 永远是调用它的对象的引用。

//下面再来个小插曲 php中对于地址的指向（类似指针）功能不是由用户自己来实现的，是由Zend核心实现的，php中引用采用的是“写时拷贝”的原理，就是除非发生写操作，指向同一个地址的变量或者对象是不会被拷贝的。

通俗的讲 1:如果有下面的代码 [php] $a="ABC"; $b=$a; [/php] 其实此时　$a与$b都是指向同一内存地址　而并不是$a与$b占用不同的内存

２:如果在上面的代码基础上再加上如下代码 [php] $a="EFG"; [/php] 由于$a与$b所指向的内存的数据要重新写一次了，此时Zend核心会自动判断　自动为$b生产一个$a的数据拷贝，重新申请一块内存进行存储

23111848-f447888b753a40748f27c64c222c8ea9.jpg