每日归档： 2017年2月26日

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

leokim / / PHP, 技术, 设计模式 
<?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, 技术, 设计模式 
<?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_”

    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是否再自定义的路径里

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 的引用允许你用两个变量来指向同一个内容 

<?php
$a="ABC"; 
$b =&$a; 
echo $a;//这里输出:ABC 
echo $b;//这里输出:ABC 
$b="EFG"; 
echo $a;//这里$a的值变为EFG 所以输出EFG echo $b;//这里输出EFG 
?>

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

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

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

<?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

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

对象的引用 

<?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