深入浅出讲解:php的socket通信

对TCP/IP、UDP、Socket编程这些词你不会很陌生吧?随着网络技术的发展,这些词充斥着我们的耳朵。那么我想问:

1.         什么是TCP/IP、UDP?

2.         Socket在哪里呢?

3.         Socket是什么呢?

4.         你会使用它们吗?

什么是TCP/IP、UDP?

TCP/IP(Transmission Control Protocol/Internet Protocol)即传输控制协议/网间协议,是一个工业标准的协议集,它是为广域网(WANs)设计的。

UDP(User Data Protocol,用户数据报协议)是与TCP相对应的协议。它是属于TCP/IP协议族中的一种。

 这里有一张图,表明了这些协议的关系。

TCP/IP协议族包括运输层、网络层、链路层。现在你知道TCP/IP与UDP的关系了吧。

Socket在哪里呢?

在图1中,我们没有看到Socket的影子,那么它到底在哪里呢?还是用图来说话,一目了然。

原来Socket在这里。

Socket是什么呢?

  Socket是应用层与TCP/IP协议族通信的中间软件抽象层,它是一组接口。在设计模式中,Socket其实就是一个门面模式,它把复杂的TCP/IP协议族隐藏在Socket接口后面,对用户来说,一组简单的接口就是全部,让Socket去组织数据,以符合指定的协议。

你会使用它们吗?

  前人已经给我们做了好多的事了,网络间的通信也就简单了许多,但毕竟还是有挺多工作要做的。以前听到Socket编程,觉得它是比较高深的编程知识,但是只要弄清Socket编程的工作原理,神秘的面纱也就揭开了。

  一个生活中的场景。你要打电话给一个朋友,先拨号,朋友听到电话铃声后提起电话,这时你和你的朋友就建立起了连接,就可以讲话了。等交流结束,挂断电话结束此次交谈。 生活中的场景就解释了这工作原理,也许TCP/IP协议族就是诞生于生活中,这也不一定。

  先从服务器端说起。服务器端先初始化Socket,然后与端口绑定(bind),对端口进行监听(listen),调用accept阻塞,等待客户端连接。在这时如果有个客户端初始化一个Socket,然后连接服务器(connect),如果连接成功,这时客户端与服务器端的连接就建立了。客户端发送数据请求,服务器端接收请求并处理请求,然后把回应数据发送给客户端,客户端读取数据,最后关闭连接,一次交互结束。

socket相关函数:

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

socket_accept() 接受一个Socket连接

socket_bind() 把socket绑定在一个IP地址和端口上

socket_clear_error() 清除socket的错误或者最后的错误代码

socket_close() 关闭一个socket资源

socket_connect() 开始一个socket连接

socket_create_listen() 在指定端口打开一个socket监听

socket_create_pair() 产生一对没有区别的socket到一个数组里

socket_create() 产生一个socket,相当于产生一个socket的数据结构

socket_get_option() 获取socket选项

socket_getpeername() 获取远程类似主机的ip地址

socket_getsockname() 获取本地socket的ip地址

socket_iovec_add() 添加一个新的向量到一个分散/聚合的数组

socket_iovec_alloc() 这个函数创建一个能够发送接收读写的iovec数据结构

socket_iovec_delete() 删除一个已经分配的iovec

socket_iovec_fetch() 返回指定的iovec资源的数据

socket_iovec_free() 释放一个iovec资源

socket_iovec_set() 设置iovec的数据新值

socket_last_error() 获取当前socket的最后错误代码

socket_listen() 监听由指定socket的所有连接

socket_read() 读取指定长度的数据

socket_readv() 读取从分散/聚合数组过来的数据

socket_recv() 从socket里结束数据到缓存

socket_recvfrom() 接受数据从指定的socket,如果没有指定则默认当前socket

socket_recvmsg() 从iovec里接受消息

socket_select() 多路选择

socket_send() 这个函数发送数据到已连接的socket

socket_sendmsg() 发送消息到socket

socket_sendto() 发送消息到指定地址的socket

socket_set_block() 在socket里设置为块模式

socket_set_nonblock() socket里设置为非块模式

socket_set_option() 设置socket选项

socket_shutdown() 这个函数允许你关闭读、写、或者指定的socket

socket_strerror() 返回指定错误号的详细错误

socket_write() 写数据到socket缓存

socket_writev() 写数据到分散/聚合数组

案例一:socket通信演示

服务器端:

<?php
//确保在连接客户端时不会超时
set_time_limit(0);

$ip = '127.0.0.1';
$port = 1935;

/*
 +-------------------------------
 *    @socket通信整个过程
 +-------------------------------
 *    @socket_create
 *    @socket_bind
 *    @socket_listen
 *    @socket_accept
 *    @socket_read
 *    @socket_write
 *    @socket_close
 +--------------------------------
 */

/*----------------    以下操作都是手册上的    -------------------*/
if(($sock = socket_create(AF_INET,SOCK_STREAM,SOL_TCP)) < 0) {
    echo "socket_create() 失败的原因是:".socket_strerror($sock)."\n";
}

if(($ret = socket_bind($sock,$ip,$port)) < 0) {
    echo "socket_bind() 失败的原因是:".socket_strerror($ret)."\n";
}

if(($ret = socket_listen($sock,4)) < 0) {
    echo "socket_listen() 失败的原因是:".socket_strerror($ret)."\n";
}

$count = 0;

do {
    if (($msgsock = socket_accept($sock)) < 0) {
        echo "socket_accept() failed: reason: " . socket_strerror($msgsock) . "\n";
        break;
    } else {
        
        //发到客户端
        $msg ="测试成功!\n";
        socket_write($msgsock, $msg, strlen($msg));
        
        echo "测试成功了啊\n";
        $buf = socket_read($msgsock,8192);
        
        
        $talkback = "收到的信息:$buf\n";
        echo $talkback;
        
        if(++$count >= 5){
            break;
        };
        
    
    }
    //echo $buf;
    socket_close($msgsock);

} while (true);

socket_close($sock);
?>

这是socket的服务端代码。然后运行cmd,注意是自己的程序存放路径啊。

没有反映,对现在服务端的程序已经开始运行,端口已经开始监听了。运行netstat -ano可以查看端口情况,我的是1935端口

看,端口已经处于LISTENING状态了。接下来我们只要运行客户端程序即可连接上。上代码

<?php
error_reporting(E_ALL);
set_time_limit(0);
echo "<h2>TCP/IP Connection</h2>\n";

$port = 1935;
$ip = "127.0.0.1";

/*
 +-------------------------------
 *    @socket连接整个过程
 +-------------------------------
 *    @socket_create
 *    @socket_connect
 *    @socket_write
 *    @socket_read
 *    @socket_close
 +--------------------------------
 */

$socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
if ($socket < 0) {
    echo "socket_create() failed: reason: " . socket_strerror($socket) . "\n";
}else {
    echo "OK.\n";
}

echo "试图连接 '$ip' 端口 '$port'...\n";
$result = socket_connect($socket, $ip, $port);
if ($result < 0) {
    echo "socket_connect() failed.\nReason: ($result) " . socket_strerror($result) . "\n";
}else {
    echo "连接OK\n";
}

$in = "Ho\r\n";
$in .= "first blood\r\n";
$out = '';

if(!socket_write($socket, $in, strlen($in))) {
    echo "socket_write() failed: reason: " . socket_strerror($socket) . "\n";
}else {
    echo "发送到服务器信息成功!\n";
    echo "发送的内容为:<font color='red'>$in</font> <br>";
}

while($out = socket_read($socket, 8192)) {
    echo "接收服务器回传信息成功!\n";
    echo "接受的内容为:",$out;
}


echo "关闭SOCKET...\n";
socket_close($socket);
echo "关闭OK\n";
?>

至此客户端已经连接上服务端了。

案例二:代码详解

// 设置一些基本的变量

$host = "192.168.1.99";

$port = 1234;

// 设置超时时间

set_time_limit(0);

// 创建一个Socket

$socket = socket_create(AF_INET, SOCK_STREAM, 0) or die("Could not createsocket\n");

//绑定Socket到端口

$result = socket_bind($socket, $host, $port) or die("Could not bind tosocket\n");

// 开始监听链接

$result = socket_listen($socket, 3) or die("Could not set up socketlistener\n");

// accept incoming connections

// 另一个Socket来处理通信

$spawn = socket_accept($socket) or die("Could not accept incomingconnection\n");

// 获得客户端的输入

$input = socket_read($spawn, 1024) or die("Could not read input\n");

// 清空输入字符串

$input = trim($input);

//处理客户端输入并返回结果

$output = strrev($input) . "\n";

socket_write($spawn, $output, strlen ($output)) or die("Could not write

output\n");

// 关闭sockets

socket_close($spawn);

socket_close($socket);

下面是其每一步骤的详细说明:

1.第一步是建立两个变量来保存Socket运行的服务器的IP地址和端口.你可以设置为你自己的服务器和端口(这个端口可以是1到65535之间的数字),前提是这个端口未被使用.

[Copy to clipboard]

PHP CODE:

// 设置两个变量

$host = "192.168.1.99";

$port = 1234;

2.在服务器端可以使用set_time_out()函数来确保PHP在等待客户端连接时不会超时.

[Copy to clipboard]

PHP CODE:

// 超时时间

set_time_limit(0);

3.在前面的基础上,现在该使用socket_creat()函数创建一个Socket了—这个函数返回一个Socket句柄,这个句柄将用在以后所有的函数中.

[Copy to clipboard]

PHP CODE:

// 创建Socket

$socket = socket_create(AF_INET, SOCK_STREAM, 0) or die("Could not create

socket\n");

第一个参数”AF_INET”用来指定域名;

第二个参数”SOCK_STREM”告诉函数将创建一个什么类型的Socket(在这个例子中是TCP类型)

因此,如果你想创建一个UDP Socket的话,你可以使用如下的代码:

[Copy to clipboard]

PHP CODE:

// 创建 socket

$socket = socket_create(AF_INET, SOCK_DGRAM, 0) or die("Could not create

socket\n");

4.一旦创建了一个Socket句柄,下一步就是指定或者绑定它到指定的地址和端口.这可以通过socket_bind()函数来完成.

[Copy to clipboard]

PHP CODE:

// 绑定 socket to 指定地址和端口

$result = socket_bind($socket, $host, $port) or die("Could not bind to

socket\n");

5.当Socket被创建好并绑定到一个端口后,就可以开始监听外部的连接了.PHP允许你由socket_listen()函数来开始一个监听,同时你可以指定一个数字(在这个例子中就是第二个参数:3)

[Copy to clipboard]

PHP CODE:

// 开始监听连接

$result = socket_listen($socket, 3) or die("Could not set up socket

listener\n");

6.到现在,你的服务器除了等待来自客户端的连接请求外基本上什么也没有做.一旦一个客户端的连接被收到,socket_accept()函数便开始起作用了,它接收连接请求并调用另一个子Socket来处理客户端–服务器间的信息.

[Copy to clipboard]

PHP CODE:

//接受请求链接

// 调用子socket 处理信息

$spawn = socket_accept($socket) or die("Could not accept incoming

connection\n");

这个子socket现在就可以被随后的客户端–服务器通信所用了.

7.当一个连接被建立后,服务器就会等待客户端发送一些输入信息,这写信息可以由socket_read()函数来获得,并把它赋值给PHP的$input变量.

[Copy to clipboard]

PHP CODE:

// 读取客户端输入

$input = socket_read($spawn, 1024) or die("Could not read input\n");

?&gt;

socker_read的第而个参数用以指定读入的字节数,你可以通过它来限制从客户端获取数据的大小.

注意:socket_read函数会一直读取壳户端数据,直到遇见\n,\t或者\0字符.PHP脚本把这写字符看做是输入的结束符.

8.现在服务器必须处理这些由客户端发来是数据(在这个例子中的处理仅仅包含数据的输入和回传到客户端).这部分可以由socket_write()函数来完成(使得由通信socket发回一个数据流到客户端成为可能)

[Copy to clipboard]

PHP CODE:

// 处理客户端输入并返回数据

$output = strrev($input) . "\n";

socket_write($spawn, $output, strlen ($output)) or die("Could not write

output\n");

9.一旦输出被返回到客户端,父/子socket都应通过socket_close()函数来终止

[Copy to clipboard]

PHP CODE:

// 关闭 sockets

socket_close($spawn);

socket_close($socket);

设计模式 – 单例模式

缺点:

单例和全局变量都可能被误用。

因为单例在系统任何地方都可以被访问,所以它们可会导致很难调试的依赖关系。

如果改变一个单例,那么所有使用该单例的类可能都会受到影响。

在这里依赖本身并不是问题。

毕竟,我们在每次声明一个特定类型参数的方法时,也就创建了依赖关系。

问题是,单例对象的全局化的性质会使程序员绕过类接口定义的通信线路。

当单例被使用时,依赖便会被隐藏在方法内部,而并不会出现在方法声明中。

这使得系统中的依赖关系更加难以追踪,因此需要谨慎小心地部署单例类。

优点:

适度地使用单例模式可以改进系统的设计。在系统中传递那些不必要的对象令人厌烦,而单例可以让你从中解放出来。

在面向对象的开发环境中,单例模式是一种对于全局变量的改进。

你无法用错误类型的数据复写一个单例。

<?php
class Preferences{
    private $props = array();
    private static $instance;

    private function __construct(){}

    public static function getInstance(){
        if(empty(self::$instance)){
            self::$instance = new Preferences();
        }
        return self::$instance;
    }

    public function setProperty($key, $val){
        $this->props[$key] = $val;
    }

    public function getProperty($key){
        return $this->props[$key];
    }
}

$pref = Preferences::getInstance();
$pref->setProperty("name","matt");

unset($pref); //移除引用

$pref2 = Preferences::getInstance();
print  $pref2->getProperty("name");

//输出  matt
?>

组合&把不同的实现隐藏在父类所定义的共同接口下

组合使用对象比集成体系更灵活,因为组合可以以多种方式动态的处理任务。

把不同的实现隐藏在父类所定义的共同接口下.

然后客户端代码需要一个父类的对象,从而使客户端代码可以不用关心它实际得到的是哪个具体的实现.

<?php

abstract class Lesson{
	private $duration;
	private $costStrategy;//支付策略

	function __construct($duration, CostStrategy $strategy)
    {
        $this->duration = $duration;
        $this->costStrategy = $strategy;
    }

    function cost(){
	    return $this->costStrategy->cost($this);
    }

    function chargeType(){
        return $this->costStrategy->chargeType();
    }

    function getDuration(){
        return $this->duration;
    }

    //Lesson类的更多方法
}

class Lecture extends Lesson{
    //Lecture特定的实现
}

 class Seminar extends Lesson{
    //Seminar特定的实现
 }

 abstract class CostStrategy{
    abstract function cost(Lesson $lesson);
    abstract function chargeType();
 }

class TimedCostStrategy extends CostStrategy{
    function cost(Lesson $lesson){
        return ($lesson->getDuration() * 5);
    }

    function chargeType(){
        return "hourly rate";
    }
}

class FixedCostStrategy extends CostStrategy{
    function cost(Lesson $lesson){
        return 30;
    }

    function chargeType(){
        return "fixed rate";
    }
}

$lessons[] = new Seminar(4, new TimedCostStrategy());
$lessons[] = new Lecture(4, new FixedCostStrategy());

foreach($lessons as $lesson){
    print "lesson charge {$lesson->cost()}.";
    print "Charge type: {$lesson->chargeType()} <br />";
}


?>

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

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

<?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 源码分析(一)

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

  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中引用&的真正理解-变量引用、函数引用、对象引用

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;//输出1 test($b);   //这里$b传递给函数的其实是$b的变量内容所处的内存地址,通过在函数里改变$a的值 就可以改变$b的值了 echo "<br>"; echo $b;//输出101
?>

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

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

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

       用上面的例子来解释就是 $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占用不同的内存

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

23111848-f447888b753a40748f27c64c222c8ea9.jpg

PHP __call拦截器 实现委托

__call方法可能是最有用的拦截器方法。

当客户端代码要调用类中未定义的方法时,__call会被调用。

__call()接受2个参数,一个是方法的名称,另一个是传递给要调用方法的所有参数(数组)。

__call()方法返回的任何值都会返回给客户,就好像调用一个真实存在的方法一样。

__call()方法对于实现委托也很有用。委托是指一个对象转发或者委托一个请求给另一个对象,被委托的一方替原先对象处理请求。

这类似于继承,和在子类中调用父类的方法有点相似。

但再继承时,父类与子类的关系是固定的,而使用委托则可以再代码运行时改变使用的对象,这意味着委托比继承具有更大的灵活性。

//将Person类信息格式化并输出
class personWriter{
	function writeName(Person $p){
		print $p->getName();
	}

	function writeAge(Person $p){
			print $p->getAge();
	}

}


//当然我们可以通过集成PersonWrite类以不同的方式输出Person类的信息。
//下面的的代码结合使用__call()方法和PersonWriter对象来实现Person类:
class Person{
	private $writer;

	function __construct(PersonWriter $write){
		$this->write = $write;
	}

	function __call($methodname, $args){
		if(method_exists($this->writer, $methodname)){
			return $this->writer->$methodname($this);
		}
	}

	function getName(){ return "LeoKim"; };
	function getAge(){ return 31; }
}

代码中Person类接受一个PersonWriter对象作为构造方法的参数,并将它存储再属性变量$writer中。

在__call()方法中,我们使用参数$methodname,检查PersonWriter对象中是否存在同名的方法。

如果相应的方法存在,我们就委托PersonWriter对象来处理对方法的调用,把当前类(Person)的实例作为参数传递给PersonWriter对象(使用$this伪变量)。

因此,可以这样调用Person类:

$person = new Person(new PersonWriter());
$person->writeName();

PHP 闭包

<?php
/** 
 * 下面提到的代码在PHP5.3以上版本运行通过. 
 */  
function callback($callback) {  
    $callback();  
}  

//输出: This is a anonymous function.<br />/n  
//这里是直接定义一个匿名函数进行传递, 在以往的版本中, 这是不可用的.  
//现在, 这种语法非常舒服, 和JavaScript语法基本一致, 之所以说基本呢, 需要继续向下看  
//结论: 一个舒服的语法必然会受欢迎的.  
callback(function() {  
    print "This is a anonymous function.<br />/n";  
});  



//输出: This is a closure use string value, msg is: Hello, everyone.<br />/n  
//这里首先定义了一个闭包, 这次户口本上有名字了...  
//use, 一个新鲜的家伙...  
//众所周知, 闭包: 内部函数使用了外部函数中定义的变量.  
//在PHP新开放的闭包语法中, 我们就是用use来使用闭包外部定义的变量的.  
//这里我们使用了外部变量$msg, 定义完之后, 又对其值进行了改变, 闭包被执行后输出的是原始值  
//结论: 以传值方式传递的基础类型参数, 闭包use的值在闭包创建是就确定了.  
$msg = "Hello, everyone";  
$callback = function () use ($msg) {  
    print "This is a closure use string value, msg is: $msg. <br />/n";  
};  
$msg = "Hello, everybody";  
callback($callback);  


//输出: This is a closure use string value lazy bind, msg is: Hello, everybody.<br />/n  
//换一种引用方式, 我们使用引用的方式来use  
//可以发现这次输出是闭包定义后的值...  
//这个其实不难理解, 我们以引用方式use, 那闭包use的是$msg这个变量的地址  
//当后面对$msg这个地址上的值进行了改变之后, 闭包内再输出这个地址的值时, 自然改变了.  
$msg = "Hello, everyone";  
$callback = function () use (&$msg) {  
    print "This is a closure use string value lazy bind, msg is: $msg. <br />/n";  
};  
$msg = "Hello, everybody";  
callback($callback);  


//输出: This is a closure use object, msg is: Hello, everyone.<br />/n  
//闭包中输出的是之前被拷贝的值为Hello, everyone的对象, 后面是对$obj这个名字的一个重新赋值.  
//可以这样考虑  
//1. obj是对象Hello, everyone的名字  
//2. 对象Hello, everyone被闭包use, 闭包产生了一个对Hello, everyone对象的引用  
//3. obj被修改为Hello, everybody这个对象的名字  
//4. 注意, 是名字obj代表的实体变了, 而不是Hello, everyone对象, 那自然闭包的输出还是前面的Hello, everyone  
$obj = (object) "Hello, everyone";  
$callback = function () use ($obj) {  
    print "This is a closure use object, msg is: {$obj->scalar}. <br />/n";  
};  
$obj = (object) "Hello, everybody";  
callback($callback);  


//输出: This is a closure use object, msg is: Hello, everybody.<br />/n  
//还是按照上面的步骤, 按部就班的来吧:  
//1. obj名字指向Hello, everyone对象  
//2. 闭包产生一个引用指向Hello, everyone对象  
//3. 修改obj名字指向的对象(即Hello, everyone对象)的scalar值  
//4. 执行闭包, 输出的自然是Hello, everybody, 因为其实只有一个真正的对象  
$obj = (object) "Hello, everyone";  
$callback = function () use ($obj) {  
    print "This is a closure use object, msg is: {$obj->scalar}. <br />/n";  
};  
$obj->scalar = "Hello, everybody";  
callback($callback);  


//输出: This is a closure use object lazy bind, msg is: Hello, everybody.<br />/n  
//闭包引用的是什么呢? &$obj, 闭包产生的引用指向$obj这个名字所指向的地址.  
//因此, 无论obj怎么变化, 都是逃不脱的....  
//所以, 输出的就是改变后的值  
$obj = (object) "Hello, everyone";  
$callback = function () use (&$obj) {  
    print "This is a closure use object lazy bind, msg is: {$obj->scalar}. <br />/n";  
};  
$obj = (object) "Hello, everybody";  
callback($callback);  

/** 
 * 一个利用闭包的计数器产生器 
 * 这里其实借鉴的是Python中介绍闭包时的例子... 
 * 我们可以这样考虑: 
 *      1. counter函数每次调用, 创建一个局部变量$counter, 初始化为1. 
 *      2. 然后创建一个闭包, 闭包产生了对局部变量$counter的引用. 
 *      3. 函数counter返回创建的闭包, 并销毁局部变量, 但此时有闭包对$counter的引用,  
 *          它并不会被回收, 因此, 我们可以这样理解, 被函数counter返回的闭包, 携带了一个游离态的 
 *          变量. 
 *      4. 由于每次调用counter都会创建独立的$counter和闭包, 因此返回的闭包相互之间是独立的. 
 *      5. 执行被返回的闭包, 对其携带的游离态变量自增并返回, 得到的就是一个计数器. 
 * 结论: 此函数可以用来生成相互独立的计数器. 
 */  
function counter() {  
    $counter = 1;  
    return function() use(&$counter) {return $counter ++;};  
}  
$counter1 = counter();  
$counter2 = counter();  
echo "counter1: " . $counter1() . "<br />/n";  
echo "counter1: " . $counter1() . "<br />/n";  
echo "counter1: " . $counter1() . "<br />/n";  
echo "counter1: " . $counter1() . "<br />/n";  
echo "counter2: " . $counter2() . "<br />/n";  
echo "counter2: " . $counter2() . "<br />/n";  
echo "counter2: " . $counter2() . "<br />/n";  
echo "counter2: " . $counter2() . "<br />/n";  
?>

PHP Static延迟静态绑定,后期静态绑定

这个文章看着表述也是不太明确的

我看到现在只是觉得如果不用延迟静态绑定 那么子类没有重写的function 会调用父类内的“资源”

如果用了延迟静态绑定 那么这个执行结果也就是子类应该有的正确的结果了

可能我表述的也不是那么通俗 233333333

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

本文实例讲述了PHP Static延迟静态绑定用法。分享给大家供大家参考,具体如下:

PHP5.3以后引入了延迟静态绑定static,它是为了解决什么问题呢?php的继承模型中有一个存在已久的问题,那就是在父类中引用扩展类的最终状态比较困难。来看一个例子。

class A 
{ 
  public static function echoClass(){ 
    echo __CLASS__; 
  }
  public static function test(){ 
    self::echoClass();    
  }
}
class B extends A 
{    
  public static function echoClass() 
  { 
     echo __CLASS__; 
  } 
} 
B::test(); //输出A

在PHP5.3中加入了一个新特性:延迟静态绑定,就是把本来在定义阶段固定下来的表达式或变量,改在执行阶段才决定,比如当一个子类继承了父类的静态表达式的时候,它的值并不能被改变,有时不希望看到这种情况。

下面的例子解决了上面提出的问题:

class A 
{ 
  public static function echoClass(){ 
    echo __CLASS__; 
  } 
  public static function test() 
  { 
    static::echoClass();    
  } 
} 
class B extends A 
{    
  public static function echoClass(){ 
     echo __CLASS__; 
  } 
} 
B::test(); //输出B

第8行的static::echoClass();定义了一个静态延迟绑定方法,直到B调用test的时候才执行原本定义的时候执行的方法。

后期静态绑定的用法

http://php.net/manual/zh/language.oop5.late-static-bindings.php