实际上，从 PHP 5.1.0 ，当对使用date（）等函数时，如果timezone设置不正确，在每一次调用时间函数时,都会产生E_NOTICE 或者 E_WARNING 信息。而又在php5.1.0 中，date.timezone这个选项，默认情况下是关闭的，无论用什么php命令都是格林威治标准时间，但是PHP5.3 中好像如果没有设置也会强行抛出了这个错误的,解决此问题，只要本地化一下，就行了。

以下 是两种方法(任选一种都 行)：

一、在页头使用 date_default_timezone_set()设置

date_default_timezone_set(‘PRC’); //东八时区
echo date(‘Y-m-d H:i:s’);

二、修改php.ini。
打开php5.ini查找date.timezone 去掉前面的分号　= 后面加XXX，重启http服务（如apache2或iis等）即可。

XXX可以任意正确的值。对于我们国内来 说：可以为以下值：Asia/Chongqing ，Asia/Shanghai ，Asia/Urumqi （依次为重庆，上海，乌鲁木齐）港台地区可用：Asia/Macao ，Asia/Hong_Kong ，Asia/Taipei （依次为澳门，香港，台北），还有新加坡：Asia/Singapore，当然PRC也行。

◆字符串的函数名

◆使用create_function的返回

在PHP5.3以后, 我们多了一个选择, 也就是Closure。

1. $func = function () { … };

2. array_walk($arr, $func);

从实现上来说, 第一种方式: 传递函数名字符串是最简单的。而第二种方式create_function, 其实和第一种方式本质上一样的, create_function返回一个字符串的函数名, 这个函数名的格式是:

1. “\000_lambda_” . count(anonymous_functions)++

我们来看看create_function的实现步骤：

1. 获取参数, 函数体;

2. 拼凑一个”function __lambda_func (参数) { 函数体;} “的字符串;

3. eval;

4. 通过__lambda_func在函数表中找到eval后得到的函数体, 找不到就出错;

5. 定义一个函数名:”\000_lambda_” . count(anonymous_functions)++;

6. 用新的函数名替换__lambda_func;

7. 返回新的函数。

我们来验证下：

1.

5. //输出 __lambda_fun

因为在eval的时候, 函数名是”__lambda_func”, 所以匿名函数内会输出__lambda_func, 而因为最后用”\000_lambda_”.count(anonymous_functions)++重命名了函数表中的”__lambda_func”函数, 所以可通过”\000_lambda_” . count(anonymous_functions)++调用这个匿名函数。为了证实这一点, 可以将create_function的返回值dump出来查看。

而在PHP 5.3发布的时候, 其中有一条new feature就是支持闭包/Lambda Function, 我第一反应是以为zval新增了一个IS_FUNCTION, 但实际上是构造了一个PHP 5.3引入的Closure”类”的实例, Closure类的构造函数是私有的, 所以不能被直接实例化, 另外Closure类是Final类, 所以也不能做为基类派生子类.

1. //php-5.3.0

2. $class = new ReflectionClass(“Closure”);

3. var_dump($class->isInternal());

4. var_dump($class->isAbstract() );

5. var_dump($class->isFinal());

6. var_dump($class->isInterface());

7. //输出:

8. bool(true)

9. bool(false)

10. bool(true)

11. bool(false)

12. ?>

而PHP 5.3中对闭包的支持, 也仅仅是把要保持的外部变量, 做为Closure对象的”Static属性”(并不是普通意义上的可遍历/访问的属性).

1. //php-5.3.0

2. $b = “laruence”;

3. $func = function($a) use($b) {};

4. var_dump($func);

5. /* 输出:

6. object(Closure)#1 (2) {

7. ["static"]=>

8. array(1) {

9. ["b"]=> string(8) “laruence”

10. }

11. ["parameter"]=>

12. array(1) {

13. ["$a"]=> string(10) “”

14. }

15. }

16. */

这个实现, 个人认为和JS对闭包的支持比起来, 还是有些太简陋了。

• 作者: laruence(http://www.laruence.com)
• 本文地址: http://www.laruence.com/2009/12/26/1198.html
• 转载请注明出处

对于PHP的中的数据来源, 不外乎有俩种:

1. 来自代码中
2. 来自外部(GET/POST/DB)

对于代码中的变量(也就是直接量)来说, 变量分配/赋值在编译期, 活跃在执行器, 在请求关闭期被销毁.对于这些变量来说, 使用APC进行Opcode缓存, 则会缓存这部分变量的值.

而对于来自外部的变量, 变量分配/赋值在编译器后, 执行期前, 在请求关闭期被销毁,对于这些变量来说, 使用APC进行OpCode缓存, 是不会被缓存的.

今天就着重关注下外部变量的一个部分,GET来的数据的整个生命周期.

假设, 有如下请求到来:

     GET /index.php?name=laruence&career[]=yahoo&career[]=baidu

而, 在index.php中:

<?php
     $name      = $_GET['name'];
     $career = $_GET['career']; //array

我们知道, 在最后的执行期, $_GET数组必然包含如下片段:

     $_GET = array(
          'name'   => 'laruence',
          'career' => array(
               'yahoo', 'baidu',
          ),
     )

那么, 我们今天就重点关注下, Query String是如何构建成_GET数组的(关于GET变量的生成, 请一并阅读我之前的文章: “PHP的GET/POST等大变量生成过程“):

在请求到来时刻,php_request_startup(定义在main.c)被调用,来做初始化现场. 在这个过程中包括设置超时值,调用各个模块的请求初始化函数. 当然也包括我们关心的, 创建变量环境.

php_hash_environment根据php.ini中的variables_order来依次初始化各个预定义大变量, 那么对于$_GET来说:

...
case 'g':
case 'G':
     if (!_gpc_flags[2]) {
          sapi_module.treat_data(PARSE_GET, NULL, NULL TSRMLS_CC);
          _gpc_flags[2] = 1;
          if (PG(register_globals)) {
               php_autoglobal_merge(&EG(symbol_table),
                    Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_GET]) TSRMLS_CC);
          }
     }
break;
...

大体可以看出,这段逻辑,首先通过treat_data来生成变量hash(PG(http_globals)[TRACK_VARS_GET]), 如果打开了auto_register_globals,则再把$_GET数组中的变量加入到符号表中.

treat_data是属于sapi_module_struct中的一个成员:

 注意:     本文基于apache2handler方式的sapi, 这个启动过程和之前的文章sapi
原理中的启动过程略有不同, php5通过注册apache2的ap_hook_post_config挂钩,
在apache server启动的时候启动php(php_apache_server_startup,定义在
sapi/apache2hander/sapi_apache2.c中), 在这个函数中调用sapi_startup启动sapi,
继而通过调用php_apache2_startup来注册sapi module struct,
然后调用php_module_startup来初始化PHP, 其中又会初始化ZEND引擎,
以及填充zend_module_struct中的treat_data成员(通过php_startup_sapi_content_types)
为php_default_treat_data

现在回过头来继续看treat_data(也就是php_default_treat_data):

....
if (arg == PARSE_GET) {     /* GET data */
     c_var = SG(request_info).query_string;
     if (c_var && *c_var) {
          res = (char *) estrdup(c_var);
          free_buffer = 1;
     } else {
          free_buffer = 0;
     }
} else if (arg == PARSE_COOKIE) {       /* Cookie data */
....

在上面的逻辑中, 给res复制为query_string, SG(request_info)是一个代表了当前请求信息的结构体, 其中query_string是在php_apache_request_ctor中通过复制apache的reqeust_rec结构体中的args而 来的.

对于本文的例子来说, 此时res即为”name=laruence&career[]=yahoo&career[]=baidu”,

继续在treat_data中, 随后的逻辑是:

var = php_strtok_r(res, separator, &strtok_buf);
...
while (var) {
     val = strchr(var, '=');
     if (arg == PARSE_COOKIE) {
          /* Remove leading spaces from cookie names,
               needed for multi-cookie header where ; can be followed by a space */
          while (isspace(*var)) {
               var++;
          }
          if (var == val || *var == '\0') {
               goto next_cookie;
          }
     }
     if (val) { /* have a value */
          int val_len;
          unsigned int new_val_len;
          *val++ = '\0';
          php_url_decode(var, strlen(var));
          val_len = php_url_decode(val, strlen(val));
          val = estrndup(val, val_len);
          if (sapi_module.input_filter(arg, var, &val, val_len, &new_val_len TSRMLS_CC)) {
               php_register_variable_safe(var, val, new_val_len, array_ptr TSRMLS_CC);
          }
          efree(val);
     } else {
...

首先, 通过php_strtok_r把res根据”&”分割成一个一个的”key=value”段, 接下来分别为var和val复制为key和value, 注意到这个过程中会分别对var和val做php_url_decode.

最后通过php_register_variable_safe, 给array_ptr(此时指向PG(http_globals)[TRACK_VARS_GET], 也就是$_GET)添加一个名为var值为val的成员.

到了这一步, 我们的$_GET数组中, 就包含了如下的成员:

'name'   => 'laruence',
'career' => array(
     'yahoo', 'baidu',
),

未完待续(变量的销毁过程)…

function ImageCreateFromBMP( $filename )
{
// Ouverture du fichier en mode binaire
if ( ! $f1 = fopen ( $filename , “rb” )) return FALSE ;
// 1 : Chargement des ent�tes FICHIER
$FILE = unpack ( “vfile_type/Vfile_size/Vreserved/Vbitmap_offset” , fread ( $f1 , 14 ));
if ( $FILE [ 'file_type' ] != 19778 ) return FALSE ;
// 2 : Chargement des ent�tes BMP
$BMP = unpack ( ‘Vheader_size/Vwidth/Vheight/vplanes/vbits_per_pixel’ . ‘/Vcompression/Vsize_bitmap/Vhoriz_resolution’ .
‘/Vvert_resolution/Vcolors_used/Vcolors_important’ , fread ( $f1 , 40 ));
$BMP [ 'colors' ] = pow ( 2 , $BMP [ 'bits_per_pixel' ]);
if ( $BMP [ 'size_bitmap' ] == 0 ) $BMP [ 'size_bitmap' ] = $FILE [ 'file_size' ] – $FILE [ 'bitmap_offset' ];
$BMP [ 'bytes_per_pixel' ] = $BMP [ 'bits_per_pixel' ] / 8 ;
$BMP [ 'bytes_per_pixel2' ] = ceil ( $BMP [ 'bytes_per_pixel' ]);
$BMP [ 'decal' ] = ( $BMP [ 'width' ] * $BMP [ 'bytes_per_pixel' ] / 4 );
$BMP [ 'decal' ] -= floor ( $BMP [ 'width' ] * $BMP [ 'bytes_per_pixel' ] / 4 );
$BMP [ 'decal' ] = 4 – ( 4 * $BMP [ 'decal' ]);
if ( $BMP [ 'decal' ] == 4 ) $BMP [ 'decal' ] = 0 ;
// 3 : Chargement des couleurs de la palette
$PALETTE = array ();
if ( $BMP [ 'colors' ] < 16777216 )
{
$PALETTE = unpack ( ‘V’ . $BMP [ 'colors' ] , fread ( $f1 , $BMP [ 'colors' ] * 4 ));
}
// 4 : Cr�ation de l’image
$IMG = fread ( $f1 , $BMP [ 'size_bitmap' ]);
$VIDE = chr ( 0 );
$res = imagecreatetruecolor( $BMP [ 'width' ] , $BMP [ 'height' ]);
$P = 0 ;
$Y = $BMP [ 'height' ] – 1 ;
while ( $Y >= 0 )
{
$X = 0 ;
while ( $X < $BMP [ 'width' ])
{
if ( $BMP [ 'bits_per_pixel' ] == 24 )
$COLOR = unpack ( “V” , substr ( $IMG , $P , 3 ) . $VIDE );
elseif ( $BMP [ 'bits_per_pixel' ] == 16 )
{
$COLOR = unpack ( “n” , substr ( $IMG , $P , 2 ));
$COLOR [ 1 ] = $PALETTE [ $COLOR [ 1 ] + 1 ];
}
elseif ( $BMP [ 'bits_per_pixel' ] == 8 )
{
$COLOR = unpack ( “n” , $VIDE . substr ( $IMG , $P , 1 ));
$COLOR [ 1 ] = $PALETTE [ $COLOR [ 1 ] + 1 ];
}
elseif ( $BMP [ 'bits_per_pixel' ] == 4 )
{
$COLOR = unpack ( “n” , $VIDE . substr ( $IMG , floor ( $P ) , 1 ));
if (( $P * 2 ) % 2 == 0 ) $COLOR [ 1 ] = ( $COLOR [ 1 ] >> 4 ) ; else $COLOR [ 1 ] = ( $COLOR [ 1 ] & 0x0F );
$COLOR [ 1 ] = $PALETTE [ $COLOR [ 1 ] + 1 ];
}
elseif ( $BMP [ 'bits_per_pixel' ] == 1 )
{
$COLOR = unpack ( “n” , $VIDE . substr ( $IMG , floor ( $P ) , 1 ));
if (( $P * 8 ) % 8 == 0 ) $COLOR [ 1 ] = $COLOR [ 1 ] >> 7 ;
elseif (( $P * 8 ) % 8 == 1 ) $COLOR [ 1 ] = ( $COLOR [ 1 ] & 0×40 ) >> 6 ;
elseif (( $P * 8 ) % 8 == 2 ) $COLOR [ 1 ] = ( $COLOR [ 1 ] & 0×20 ) >> 5 ;
elseif (( $P * 8 ) % 8 == 3 ) $COLOR [ 1 ] = ( $COLOR [ 1 ] & 0×10 ) >> 4 ;
elseif (( $P * 8 ) % 8 == 4 ) $COLOR [ 1 ] = ( $COLOR [ 1 ] & 0×8 ) >> 3 ;
elseif (( $P * 8 ) % 8 == 5 ) $COLOR [ 1 ] = ( $COLOR [ 1 ] & 0×4 ) >> 2 ;
elseif (( $P * 8 ) % 8 == 6 ) $COLOR [ 1 ] = ( $COLOR [ 1 ] & 0×2 ) >> 1 ;
elseif (( $P * 8 ) % 8 == 7 ) $COLOR [ 1 ] = ( $COLOR [ 1 ] & 0×1 );
$COLOR [ 1 ] = $PALETTE [ $COLOR [ 1 ] + 1 ];
}
else
return FALSE ;
imagesetpixel( $res , $X , $Y , $COLOR [ 1 ]);
$X ++ ;
$P += $BMP [ 'bytes_per_pixel' ];
}
$Y — ;
$P += $BMP [ 'decal' ];
}
// Fermeture du fichier
fclose ( $f1 );
return $res ;
}

function ImageCreateFromBMP( $filename )
{
// Ouverture du fichier en mode binaire
if ( ! $f1 = fopen ( $filename , “rb” )) return FALSE ;
// 1 : Chargement des ent�tes FICHIER
$FILE = unpack ( “vfile_type/Vfile_size/Vreserved/Vbitmap_offset” , fread ( $f1 , 14 ));
if ( $FILE [ 'file_type' ] != 19778 ) return FALSE ;
// 2 : Chargement des ent�tes BMP
$BMP = unpack ( ‘Vheader_size/Vwidth/Vheight/vplanes/vbits_per_pixel’ . ‘/Vcompression/Vsize_bitmap/Vhoriz_resolution’ .
‘/Vvert_resolution/Vcolors_used/Vcolors_important’ , fread ( $f1 , 40 ));
$BMP [ 'colors' ] = pow ( 2 , $BMP [ 'bits_per_pixel' ]);
if ( $BMP [ 'size_bitmap' ] == 0 ) $BMP [ 'size_bitmap' ] = $FILE [ 'file_size' ] – $FILE [ 'bitmap_offset' ];
$BMP [ 'bytes_per_pixel' ] = $BMP [ 'bits_per_pixel' ] / 8 ;
$BMP [ 'bytes_per_pixel2' ] = ceil ( $BMP [ 'bytes_per_pixel' ]);
$BMP [ 'decal' ] = ( $BMP [ 'width' ] * $BMP [ 'bytes_per_pixel' ] / 4 );
$BMP [ 'decal' ] -= floor ( $BMP [ 'width' ] * $BMP [ 'bytes_per_pixel' ] / 4 );
$BMP [ 'decal' ] = 4 – ( 4 * $BMP [ 'decal' ]);
if ( $BMP [ 'decal' ] == 4 ) $BMP [ 'decal' ] = 0 ;
// 3 : Chargement des couleurs de la palette
$PALETTE = array ();
if ( $BMP [ 'colors' ] < 16777216 )
{
$PALETTE = unpack ( ‘V’ . $BMP [ 'colors' ] , fread ( $f1 , $BMP [ 'colors' ] * 4 ));
}
// 4 : Cr�ation de l’image
$IMG = fread ( $f1 , $BMP [ 'size_bitmap' ]);
$VIDE = chr ( 0 );
$res = imagecreatetruecolor( $BMP [ 'width' ] , $BMP [ 'height' ]);
$P = 0 ;
$Y = $BMP [ 'height' ] – 1 ;
while ( $Y >= 0 )
{
$X = 0 ;
while ( $X < $BMP [ 'width' ])
{
if ( $BMP [ 'bits_per_pixel' ] == 24 )
$COLOR = unpack ( “V” , substr ( $IMG , $P , 3 ) . $VIDE );
elseif ( $BMP [ 'bits_per_pixel' ] == 16 )
{
$COLOR = unpack ( “n” , substr ( $IMG , $P , 2 ));
$COLOR [ 1 ] = $PALETTE [ $COLOR [ 1 ] + 1 ];
}
elseif ( $BMP [ 'bits_per_pixel' ] == 8 )
{
$COLOR = unpack ( “n” , $VIDE . substr ( $IMG , $P , 1 ));
$COLOR [ 1 ] = $PALETTE [ $COLOR [ 1 ] + 1 ];
}
elseif ( $BMP [ 'bits_per_pixel' ] == 4 )
{
$COLOR = unpack ( “n” , $VIDE . substr ( $IMG , floor ( $P ) , 1 ));
if (( $P * 2 ) % 2 == 0 ) $COLOR [ 1 ] = ( $COLOR [ 1 ] >> 4 ) ; else $COLOR [ 1 ] = ( $COLOR [ 1 ] & 0x0F );
$COLOR [ 1 ] = $PALETTE [ $COLOR [ 1 ] + 1 ];
}
elseif ( $BMP [ 'bits_per_pixel' ] == 1 )
{
$COLOR = unpack ( “n” , $VIDE . substr ( $IMG , floor ( $P ) , 1 ));
if (( $P * 8 ) % 8 == 0 ) $COLOR [ 1 ] = $COLOR [ 1 ] >> 7 ;
elseif (( $P * 8 ) % 8 == 1 ) $COLOR [ 1 ] = ( $COLOR [ 1 ] & 0×40 ) >> 6 ;
elseif (( $P * 8 ) % 8 == 2 ) $COLOR [ 1 ] = ( $COLOR [ 1 ] & 0×20 ) >> 5 ;
elseif (( $P * 8 ) % 8 == 3 ) $COLOR [ 1 ] = ( $COLOR [ 1 ] & 0×10 ) >> 4 ;
elseif (( $P * 8 ) % 8 == 4 ) $COLOR [ 1 ] = ( $COLOR [ 1 ] & 0×8 ) >> 3 ;
elseif (( $P * 8 ) % 8 == 5 ) $COLOR [ 1 ] = ( $COLOR [ 1 ] & 0×4 ) >> 2 ;
elseif (( $P * 8 ) % 8 == 6 ) $COLOR [ 1 ] = ( $COLOR [ 1 ] & 0×2 ) >> 1 ;
elseif (( $P * 8 ) % 8 == 7 ) $COLOR [ 1 ] = ( $COLOR [ 1 ] & 0×1 );
$COLOR [ 1 ] = $PALETTE [ $COLOR [ 1 ] + 1 ];
}
else
return FALSE ;
imagesetpixel( $res , $X , $Y , $COLOR [ 1 ]);
$X ++ ;
$P += $BMP [ 'bytes_per_pixel' ];
}
$Y — ;
$P += $BMP [ 'decal' ];
}
// Fermeture du fichier
fclose ( $f1 );
return $res ;
}

用法：

$src_img = “testA.bmp”;//源图片
$dst_img = “testB.jpg”; //目标图片
$mi = ImageCreateFromBMP( $src_img );
imagejpeg( $mi , $dst_img );
imagedestroy($mi );//释放内存

可以把其它格式，如 png,bmp,gif 等转换为 jpg 格式

//把其它图片格式转化为 jpg
function ImageToJPG($srcFile,$dstFile)
{
$quality=90;
$data = @GetImageSize($srcFile);
switch ($data['2'])
{
case 1:
$im = imagecreatefromgif($srcFile);
break;
case 2:
$im = imagecreatefromjpeg($srcFile);
break;
case 3:
$im = imagecreatefrompng($srcFile);
break;
case 6:
$im = ImageCreateFromBMP( $srcFile );
break;
}
$dstX=$srcW=@ImageSX($im);
$dstY=$srcH=@ImageSY($im);

$ni=@imageCreateTrueColor($dstX,$dstY);
@ImageCopyResampled($ni,$im,0,0,0,0,$dstX,$dstY,$srcW,$srcH);
@ImageJpeg($ni,$dstFile,$quality);
@imagedestroy($im);
@imagedestroy($ni);
}

整理两个现成的函数：json_decode、json_encode说明：其中json_encode 表示把常用的传统的数据类型如对象、数组、关联数组等转成JSON字符串。其实与JAVA里面的那个工具是一样的。而json_decode刚好相反。解决需求1.修改数据表的时候动态生成一个JSON片段。供JS调用。服务器端的代码：function plan2() {$link = mysql_connect(“localhost”,”root”,”123″) or die(“<font color=red>无法建立起来连接。错误信息如下</font>”);mysql_query(“SET NAMES gbk”);mysql_select_db(“phpcms”,$link) or die(“<font color=red>在服务器上面无法找到此请确认已建立此DB “);$result = mysql_query(“select id,uuid,uuidtable from dytable “);$num_rows = @mysql_num_rows($result); //看一下返回多少行记录if ($num_rows == 0) {    $b = array();         //这样长度为0 返回的是一个空数组             }else{             while ($row = mysql_fetch_array($result,MYSQL_ASSOC)){        $b[] = $row;    }}echo json_encode($b);mysql_close();}plan2(); 这样生成的JSON是比较方便的了！ 2. 客户端如果我们使用JQuery框架的话可以这样处理<script type=”text/javascript”> function ajaxcheck() {    $.ajax({        type:”GET”,        url: “http://localhost/PHPCMS/projcode/?number=”+Math.random(),         dataType: ‘text’,           //注意这里面的格式形式！        success:function(msg){           $(eval(msg)).each(function(){                alert(this.id+” “+this.uuid);//得到值就可以生成多个IMG标签了！            });                   }    })}</script> 如果客户端使用JS的话可以这样处理<script type=”text/javascript”> function ajaxcheck() {    $.ajax({        type:”GET”,       url: “http://localhost/PHPCMS/projcode/?number=”+Math.random(),         dataType: ‘text’,        success:function(msg){                     json = eval(msg)            for(var i=0; i<json.length; i++)            {            alert(json[i].id+” ” + json[i].uuid)            }        }    })}</script>   参考的一个示例代码如下：客户端代码：<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0 Transitional//EN” “http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd”><html xmlns=”http://www.w3.org/1999/xhtml”><head><script type=”text/javascript” src=”../scripts/jquery.js”></script><meta http-equiv=”Content-Type” content=”text/html; charset=utf-8″ /><script type=”text/javascript”> function ajaxcheck() {    $.ajax({        type:”GET”,        url: “http://localhost/PHPCMS/projcode/?number=”+Math.random(),         dataType: ‘text’,        success:function(msg){            $(eval(msg)).each(function(){                $(“#output”).html(“<img id=’”+this.id+”‘ src=’”+this.uuid+”‘ />”);            });        }    })}</script></head><body><button onclick=”ajaxcheck()”>TEST</button><div id=”output”></div></body></html> 服务端：function plan2() {$link = mysql_connect(“localhost”,”root”,”123″) or die(“<font color=red>无法建立起来连接。错误信息如下</font>”);mysql_query(“SET NAMES gbk”);mysql_select_db(“phpcms”,$link) or die(“<font color=red>在服务器上面无法找到此请确认已建立此DB “);$result = mysql_query(“select id,uuid from dytable “);$num_rows = @mysql_num_rows($result); //看一下返回多少行记录if ($num_rows == 0) {    $b = array();         //这样长度为0 返回的是一个空数组             }else{             while ($row = mysql_fetch_array($result,MYSQL_ASSOC)){        $b[] = $row;    }}echo json_encode($b);mysql_close();}plan2(); 以上实现的功能是借助JSON实现的。其实FLASH也有函数解析JSON。

• 作者: laruence(http://www.laruence.com)
• 本文地址: http://www.laruence.com/2010/05/04/1450.html
• 转载请注明出处

在大型的Web项目中, include_path是一个模块化设计的根本中的根本(当然,现在也有很多基于autoload的设计, 这个不影响本文的探讨), 但是正是因为include_path, 经常会让我们遇到一些因为没有找到正确的文件而导致的看似”诡异”的问题.

也就有了如下的疑问:

include_path是怎么起作用的?

如果有多个include_path顺序是怎么样的?

什么情况下include_path不起作用?

今天, 我就全面的介绍下这个问题, 先从一个例子开始吧.

如下的目录结构:

  root
    ├ 1.php
    ├ 3.php
    └ subdir
         ├ 2.php
          └ 3.php

在1.php中:

<?php
ini_set("include_path", ".:path_to_subdir");
require("2.php");
?>

而在2.php中:

<?php
require("3.php");
?>

而在root目录下的3.php打印出”root”, 在subdir目录下的3.php打印出”subdir”;

现在, 我的问题来了:

1. 当在root目录下运行1.php, 会得到什么输出?

2. 在subdir下运行上一级目录的1.php, 有会得到什么输出?

3. 当取消include_path中的当前目录path(也就是include_path=”path_to_subdir”), 上面俩个问题又会是什么输出?

PHP中的include_path

PHP在遇到require(_once)/include(_once)的指令的时候, 首先会做如下的判断:

要包含的文件路径是绝对路径么?
 如果是, 则直接包含, 并结束.
 如果不是, 进入另外的逻辑(经过多次调用, 宏展开后进入_php_stream_fopen_with_path)寻找此文件.

接下来, 在_php_stream_fopen_with_path中, 会做如下判断:

要包含的文件路径是相对路径么(形如./file, ../dir/file, 以下用"目录相对路径代替")?
 如果是, 则跳过include_path的作用逻辑, 直接解析相对路径(随后单独介绍).

会根据include_path,和当前执行文件的path组成一个待选的目录列表, 比如对于文章前面的例子来说, 会形成一个如下的待选列表

".:path_to_subdir:current_script_dir"

然后, 依次从待选列表头部开始, 根据DEFAULT_DIR_SEPARATOR(本文的环境是”:”)取出待选列表中的一个路径, 然后把要包含的文件名附加在这个路径后面, 进行尝试. 如果成功包含, 则返回, 否则继续下一个待选路径.

到现在为止, 我们已经可以回答我开头提出的3个问题了.

1. 因为在root目录下执行, 所以在1.php中包含2.php的时候, include_path的第二个待选路径起了作用(path_to_subdir), 找到了path_to_subdir/2.php, 而在2.php包含3.php的时候, 当前工作目录是root下, 所以在包含3.php的时候, include_path的第一个待选路径”.”(当前工作目录)下就找到的匹配的文件, 所以得到的输出是”root”.

2. 同1, 只不过当前的路径是subdir, 所以得到的输出是”subdir”.

3. 因为没有了当前路径为include_path, 所以在root目录下运行的时候2.php中包含3.php的时候, 是path_to_subdir起了作用, 所以无论在root还是subdir都将得到”subdir”的输出.
而如果在2.php中清空include_path,

<?php
ini_set("include_path", '');
require("3.php");
?>

那么将会是current_script_dir起作用, 而这个时候current_script_dir是2.php的路径, 所以还是会得到”subdir”的输出.

目录相对路径

在使用目录相对路径的情况下, 相对路径的基点, 永远都是当前工作目录.

为了说明在目录相对路径下的情况,我们再看个列子, 还是上面的目录结构, 只不过1.php变成了:

<?php
ini_set("include_path", "/");
require("./subdir/2.php");
?>

2.php变成了:

<?php
require("./3.php");
?>

如果在root目录下执行, 2.php中寻找3.php将会在当前目录的相对路径下寻找, 所以得到的输出是”root”, 而如果是在subdir下执行上一级目录的1.php(php -f ../1.php), 将会因为在subdir下找不到”./subdir/2.php”而异常退出.

后记

1. 因为使用include_path和相对路径的情况下, 性能会和寻找的次数有关, 最坏的情况下, 如果你有10个include_path, 那么最多可能会重试11次才能找到要包含的文件, 所以, 在能使用绝对路径的情况下最好使用绝对路径.

2. 因为目录相对路径的basedir, 永远都是当前工作路径, 如果要使用, 需要和实际部署路径相关, 所以实际使用的很少(当然, 也有借助chdir来完成的模块).

3. 在模块化的系统设计中, 一般应该在模块内, 通过获取模块的部署路径(dirname(__FILE__), php5.3以后更是提供了__DIR__常量)从而使用绝对路径.

这个验证码图片是用ASP生成的..理所当然成了BMP格式.

但是对于PHP来说.这是个软伤.因为PHP的GD库根本就没把BMP纳入在内.虽然有wbmp但是还是不一样的.

所以就google了一下.结果又让我一阵喜悦.竟然有个现成的识别256色BMP的类..十分激动..有这个还不是白拿钱的事啊!!

结果又是令人失望的..256色的BMP跟24位色的根本是两个概念..这就意味这我得重新写了..

看来没有现成的类库和函数.只能自己写了.用最最原始的fopen.分析BMP头.一个一个字节的读了.

所有又去google了BMP的24位色的头分析..那么长的文章…立马就失望了..

所以无聊就去翻手册..眼睁睁的看着有imagecreatefromgif imagecreatefromjpeg imagecreatefrompng imagecreatefromwbmp等等.就是没有imagecreatefrombmp

于是突发奇想.去google一下imagecreatefrombmp会是什么结果..果然不出我所料.已经有达人写出了这个函数..

function imagecreatefrombmp($file)
{
    global  $CurrentBit, $echoMode;

    $f=fopen($file,"r");
    $Header=fread($f,2);

    if($Header=="BM")
    {
        $Size=freaddword($f);
        $Reserved1=freadword($f);
        $Reserved2=freadword($f);
        $FirstByteOfImage=freaddword($f);

        $SizeBITMAPINFOHEADER=freaddword($f);
        $Width=freaddword($f);
        $Height=freaddword($f);
        $biPlanes=freadword($f);
        $biBitCount=freadword($f);
        $RLECompression=freaddword($f);
        $WidthxHeight=freaddword($f);
        $biXPelsPerMeter=freaddword($f);
        $biYPelsPerMeter=freaddword($f);
        $NumberOfPalettesUsed=freaddword($f);
        $NumberOfImportantColors=freaddword($f);

        if($biBitCount<24)
        {
            $img=imagecreate($Width,$Height);
            $Colors=pow(2,$biBitCount);
            for($p=0;$p<$Colors;$p++)
            {
                $B=freadbyte($f);
                $G=freadbyte($f);
                $R=freadbyte($f);
                $Reserved=freadbyte($f);
                $Palette[]=imagecolorallocate($img,$R,$G,$B);
            };




            if($RLECompression==0)
            {
                $Zbytek=(4-ceil(($Width/(8/$biBitCount)))%4)%4;

                for($y=$Height-1;$y>=0;$y--)
                {
                    $CurrentBit=0;
                    for($x=0;$x<$Width;$x++)
                    {
                        $C=freadbits($f,$biBitCount);
                        imagesetpixel($img,$x,$y,$Palette[$C]);
                    };
                    if($CurrentBit!=0) {freadbyte($f);};
                    for($g=0;$g<$Zbytek;$g++)
                    freadbyte($f);
                };

            };
        };


        if($RLECompression==1) //$BI_RLE8
        {
            $y=$Height;

            $pocetb=0;

            while(true)
            {
                $y--;
                $prefix=freadbyte($f);
                $suffix=freadbyte($f);
                $pocetb+=2;

                $echoit=false;

                if($echoit)echo "Prefix: $prefix Suffix: $suffix<BR>";
                if(($prefix==0)and($suffix==1)) break;
                if(feof($f)) break;

                while(!(($prefix==0)and($suffix==0)))
                {
                    if($prefix==0)
                    {
                        $pocet=$suffix;
                        $Data.=fread($f,$pocet);
                        $pocetb+=$pocet;
                        if($pocetb%2==1) {freadbyte($f); $pocetb++;};
                    };
                    if($prefix>0)
                    {
                        $pocet=$prefix;
                        for($r=0;$r<$pocet;$r++)
                        $Data.=chr($suffix);
                    };
                    $prefix=freadbyte($f);
                    $suffix=freadbyte($f);
                    $pocetb+=2;
                    if($echoit) echo "Prefix: $prefix Suffix: $suffix<BR>";
                };

                for($x=0;$x<strlen($Data);$x++)
                {
                    imagesetpixel($img,$x,$y,$Palette[ord($Data[$x])]);
                };
                $Data="";

            };

        };


        if($RLECompression==2) //$BI_RLE4
        {
            $y=$Height;
            $pocetb=0;

            /*while(!feof($f))
            echo freadbyte($f)."_".freadbyte($f)."<BR>";*/
            while(true)
            {
                //break;
                $y--;
                $prefix=freadbyte($f);
                $suffix=freadbyte($f);
                $pocetb+=2;

                $echoit=false;

                if($echoit)echo "Prefix: $prefix Suffix: $suffix<BR>";
                if(($prefix==0)and($suffix==1)) break;
                if(feof($f)) break;

                while(!(($prefix==0)and($suffix==0)))
                {
                    if($prefix==0)
                    {
                        $pocet=$suffix;

                        $CurrentBit=0;
                        for($h=0;$h<$pocet;$h++)
                        $Data.=chr(freadbits($f,4));
                        if($CurrentBit!=0) freadbits($f,4);
                        $pocetb+=ceil(($pocet/2));
                        if($pocetb%2==1) {freadbyte($f); $pocetb++;};
                    };
                    if($prefix>0)
                    {
                        $pocet=$prefix;
                        $i=0;
                        for($r=0;$r<$pocet;$r++)
                        {
                            if($i%2==0)
                            {
                                $Data.=chr($suffix%16);
                            }
                            else
                            {
                                $Data.=chr(floor($suffix/16));
                            };
                            $i++;
                        };
                    };
                    $prefix=freadbyte($f);
                    $suffix=freadbyte($f);
                    $pocetb+=2;
                    if($echoit) echo "Prefix: $prefix Suffix: $suffix<BR>";
                };

                for($x=0;$x<strlen($Data);$x++)
                {
                    imagesetpixel($img,$x,$y,$Palette[ord($Data[$x])]);
                };
                $Data="";

            };

        };


        if($biBitCount==24)
        {
            $img=imagecreatetruecolor($Width,$Height);
            $Zbytek=$Width%4;

            for($y=$Height-1;$y>=0;$y--)
            {
                for($x=0;$x<$Width;$x++)
                {
                    $B=freadbyte($f);
                    $G=freadbyte($f);
                    $R=freadbyte($f);
                    $color=imagecolorexact($img,$R,$G,$B);
                    if($color==-1) $color=imagecolorallocate($img,$R,$G,$B);
                    imagesetpixel($img,$x,$y,$color);
                }
                for($z=0;$z<$Zbytek;$z++)
                freadbyte($f);
            };
        };
        return $img;

    };


    fclose($f);


};

function freadbyte($f)
{
    return ord(fread($f,1));
};

function freadword($f)
{
    $b1=freadbyte($f);
    $b2=freadbyte($f);
    return $b2*256+$b1;
};

function freaddword($f)
{
    $b1=freadword($f);
    $b2=freadword($f);
    return $b2*65536+$b1;
};

这个函数的过程是这样的..用fopen打开文件.一个字节一个字节的读出来..先读BMP头.然后逐行读像素.再用 imagecreatetruecolor新建立个图像.把刚读出来的像素逐个再画到刚才创建的图片上.
最后返回这个图像的resource .

估计大家跟我一样.一开始就被这么长的函数吓到了.其实不用怕.分析一下.我们是要分析24位色的BMP.所以上面函数的大部分语句我们都不 用.if($biBitCount==24)以下的才是关键..

$B=freadbyte($f);
$G=freadbyte($f);
$R=freadbyte($f);

这三行就是读取像素了..我们需要的就是把每个像素放到数组中.这样就容易被操作了.

$array[] = sprintf(“%03d”,$R).sprintf(“%03d”,$G).sprintf(“%03d”,$B);

这样我们就把每个像素放到$array这个数组中了.但是这样还不够.因为我们得识别像素.所以我是这样想的.把白色的(255255255)改为 0.其他颜色改为1.这是因为我这个验证码比较简单.而且干扰颜色非常少..

最后形成的$array就类似这样的了

0001111000   0001111000   0001111000   0000101000
0010000100   0010000100   0010000100   0000100000
0010000100   0010000100   0010000100   0000100000
0010110100   0000000100   0000000100   0000100000
0010110100   0000101000   0000000100   0000100000
0010110100   0000110000   0011000100   0000010000
0010110100   0000001000   0010111000   0000010000
0010000100   0010000100   0010000000   0010001000
0011000100   0010000110   0010000000   0010001000
0001111000   0001111000   0011111100   0011111100

当然 之所以形成这个样子是我输出的时候处理过的.
很容易看的清楚.这是0357..

有的人会问为什么是倒的?这是因为BMP在存储图像的时候就是倒着存放的.比较BT.
不过这个不必担心.我们也不用给他费劲正过来.因为我们是要做比较.只要这个对比码也是倒着的就可以了.

为了更清楚的说明白这个数组是怎么存储内容的.我给大家详细的描述一下.就按照上面的例子.

数组下标0 1 2 3 4 5 6 7 8 9   10…..                                                       …  39
存储内容0 0 0 1 1 1 1 0 0 0   0 0 0 1 1 1 1 0 0 0    0 0 0 1 1 1 1  0 0 0     0 0 0 0 1  0 1 0 0  0  第一行

数组下标40 41 ….                                                                           …79
存储内容0  0 1 0 0 0 0 1 0 0    0 0 1 0 0 0 0 1 0 0    0 0 1 0 0 0 0 1 0 0    0 0 0 0 1 0 0 0 0 0    第二行

为了省略我就不写了..很容易看出来.这是个一维的数组.一共有399个元素..但是为了识别验证码.我们得把其中的每个数字取出来.

0-9 40-49 80-89 …为一组
10-19 50-59 90-99 …为一组
20-29 60-69 100-109…为一组
30-39 70-79 110-119..为一组

你可以自己写个算法..

这样整理出来后..是一个具有4个元素的数组.
每个元素都有100位0和1的数字.

元素取出来了.要跟谁比较呢??对.我们得找个参照物才行..
找参照物就是体力活了..
返回到上面的过程..不断的刷新验证码..直到把0-9都出现了.针对每个.记下他的样子比如说0是这样

0001111000
0010000100
0010000100
0010110100
0010110100
0010110100
0010110100
0010000100
0011000100
0001111000

变成字符串.0就是这样了 0001111000001000010000100001000010110100001011010000101101000010110100001000010000110001000001111000
也就是上面的按照顺序放在一行.

0-9都记下来后.我们可以放到一个数组中,就叫$key吧.

这样的话跟我们生成出来的元素就一一对应了.

下面就要开始比较了.

循环是免不了的.比较的技巧是用similar_text和参照物逐个比较.把相思百分比放到一个数组中.
然后把这个数组中最大的那个百分比取出来.所对应的索引值(此索引值不是自动生成的)就是我们识别出来的数字了.
下面的代码值描述重要的部分

foreach ($keys as $key => $value) {              //$key就是对比参照组
similar_text($value, $validValue, $p);
$maxArr[$key] = $p;           //把所有的几率放到数组中
}
然后取出$maxArr这个最大的索引值.就是我们识别出来的数字了.

到此验证码算是识别完成了.

但是部署给用户的时候.发现他的机器上用fopen打开远程URL.只有30%的几率能获取到.其他的情况都是HTTP Request failed…
更改了很多方法还是不成功.结果我的解决办法是.
用CURL把验证码保存到本地.然后fopen打开本地图片就100%OK啦..

至于详细的代码我就不贴了.因为代码是卖给人家的.为了保障人家的利益.所以大家也不要开口跟我要了..思路我已经给出来了.相信你是可以写出来 的.

演示:http://www.skiyo.cn/demo/valid/

我们可以定义一些用户函数.但是还是用原来的函数名.只不过前面加个$就可以了.

我们来看下例子

$str_shuffle = create_function('$a','echo $a;');
echo $str_shuffle('aaa');

这样我们就可以制造一个山寨版的str_shuffle了:)

create_function的功能远远不止这点.我们还可以给类动态的添加方法.我们来看下面的例子

class Hoge {
   var $lamda;
   var $text;
   function set($lamda)
   {
       $this->lamda = $lamda;
   }
   function callLamda()
   {
       $func = $this->lamda;
       return $func($this);
   }
   function get()
   {
       return $this->text;
   }
}
$newfunc = create_function('&$class', 'echo $class->get();' );
$h = new Hoge;
$h->text = "Hi there !";
$h->set($newfunc);
$h->callLamda();

在PHP中，填充一个字符串变量相当简单，这只需要一个语句”＜?php $str = ‘hello world ‘; ?＞”即可，并且该字符串能够被自由地修改、拷贝和移动。而在C语言中，尽管你能够编写例如”char *str = “hello world “;”这样的一个简单的静态字符串；但是，却不能修改该字符串，因为它生存于程序空间内。为了创建一个可操纵的字符串，你必须分配一个内存块，并且通过一 个函数（例如strdup()）来复制其内容。

由于后面我们将分析的各种原因，传统型内存管理函数（例如malloc()，free()，strdup()，realloc()，calloc()， 等等）几乎都不能直接为PHP源代码所使用。

二、 释放内存

在几乎所有的平台上，内存管理都是通 过一种请求和释放模式实现的。首先，一个应用程序请求它下面的层(通常指”操作系统”)：”我想使用一些内存空间”。如果存在可用的空间，操作系统就会把 它提供给该程序并且打上一个标记以便不会再把这部分内存分配给其它程序。
当应用程序使用完这部分内存，它应该被返回到OS；这样以来，它就能够被 继续分配给其它程序。如果该程序不返回这部分内存，那么OS无法知道是否这块内存不再使用并进而再分配给另一个进程。如果一个内存块没有释放，并且所有者 应用程序丢失了它，那么，我们就说此应用程序”存在漏洞”，因为这部分内存无法再为其它程序可用。

在一个典型的客户端应用程序中，较 小的不太经常的内存泄漏有时能够为OS所”容忍”，因为在这个进程稍后结束时该泄漏内存会被隐式返回到OS。这并没有什么，因为OS知道它把该内存分配给 了哪个程序，并且它能够确信当该程序终止时不再需要该内存。

而对于长时间运行的服务器守护程序，包括象Apache这样的web服务 器和扩展php模块来说，进程往往被设计为相当长时间一直运行。因为OS不能清理内存使用，所以，任何程序的泄漏-无论是多么小-都将导致重复操作并最终 耗尽所有的系统资源。

现在，我们不妨考虑用户空间内的stristr()函数；为了使用大小写不敏感的搜索来查找一个字符串，它实际 上创建了两个串的各自的一个小型副本，然后执行一个更传统型的大小写敏感的搜索来查找相对的偏移量。然而，在定位该字符串的偏移量之后，它不再使用这些小 写版本的字符串。如果它不释放这些副本，那么，每一个使用stristr()的脚本在每次调用它时都将泄漏一些内存。最后，web服务器进程将拥有所有的 系统内存，但却不能够使用它。

你可以理直气壮地说，理想的解决方案就是编写良好、干净的、一致的代码。这当然不错；但是，在一个象 PHP解释器这样的环境中，这种观点仅对了一半。

三、 错误处理

为了实现”跳出”对用户空间脚本 及其依赖的扩展函数的一个活动请求，需要使用一种方法来完全”跳出”一个活动请求。这是在Zend引擎内实现的：在一个请求的开始设置一个”跳出”地址， 然后在任何die()或exit()调用或在遇到任何关键错误(E_ERROR)时执行一个longjmp()以跳转到该”跳出”地址。

尽管这个”跳出”进程能够简化程序执行的流程，但是，在绝大多数情况下，这会意味着将会跳过资源清除代码部分(例如free()调用)并最终导致出现内 存漏洞。现在，让我们来考虑下面这个简化版本的处理函数调用的引擎代码：

当执行到php_error_docref()这一行时，内部错误处理器就会明白该错误级别是critical，并相应地调用longjmp()来中断 当前程序流程并离开call_function()函数，甚至根本不会执行到efree(lcase_fname)这一行。你可能想把efree()代码 行移动到zend_error()代码行的上面；但是，调用这个call_function()例程的代码行会怎么样呢？fname本身很可能就是一个分 配的字符串，并且，在它被错误消息处理使用完之前，你根本不能释放它。

注意，这个php_error_docref()函数是 trigger_error()函数的一个内部等价实现。它的第一个参数是一个将被添加到docref的可选的文档引用。第三个参数可以是任何我们熟悉的 E_*家族常量，用于指示错误的严重程度。第四个参数（最后一个）遵循printf()风格的格式化和变量参数列表式样。

四、 Zend内存管理器

在上面的”跳出”请求期间解决内存泄漏的方案之一是：使用Zend内存 管理(ZendMM)层。引擎的这一部分非常类似于操作系统的内存管理行为-分配内存给调用程序。区别在于，它处于进程空间中非常低的位置而且是”请求感 知”的；这样以来，当一个请求结束时，它能够执行与OS在一个进程终止时相同的行为。也就是说，它会隐式地释放所有的为该请求所占用的内存。图1展示了 ZendMM与OS以及PHP进程之间的关系。

图 1.Zend内存管理器代替系统调用来实现针对每一种请求的内存分配。

除了提供隐式内存清除功能之外，ZendMM还能够根据php.ini中memory_limit的设置控制每一种内存请求的用法。如果一个脚本试图请求 比系统中可用内存更多的内存，或大于它每次应该请求的最大量，那么，ZendMM将自动地发出一个E_ERROR消息并且启动相应的”跳出”进程。这种方 法的一个额外优点在于，大多数内存分配调用的返回值并不需要检查，因为如果失败的话将会导致立即跳转到引擎的退出部分。

把PHP内部 代码和OS的实际的内存管理层”钩”在一起的原理并不复杂：所有内部分配的内存都要使用一组特定的可选函数实现。例如，PHP代码不是使用 malloc(16)来分配一个16字节内存块而是使用了emalloc(16)。除了实现实际的内存分配任务外，ZendMM还会使用相应的绑定请求类 型来标志该内存块；这样以来，当一个请求”跳出”时，ZendMM可以隐式地释放它。

经常情况下，内存一般都需要被分配比单个请求持 续时间更长的一段时间。这种类型的分配（因其在一次请求结束之后仍然存在而被称为”永久性分配”），可以使用传统型内存分配器来实现，因为这些分配并不会 添加ZendMM使用的那些额外的相应于每种请求的信息。然而有时，直到运行时刻才会确定是否一个特定的分配需要永久性分配，因此ZendMM导出了一组 帮助宏，其行为类似于其它的内存分配函数，但是使用最后一个额外参数来指示是否为永久性分配。

如果你确实想实现一个永久性分配，那么 这个参数应该被设置为1；在这种情况下，请求是通过传统型malloc()分配器家族进行传递的。然而，如果运行时刻逻辑认为这个块不需要永久性分配；那 么，这个参数可以被设置为零，并且调用将会被调整到针对每种请求的内存分配器函数。

例 如，pemalloc(buffer_len，1)将映射到malloc(buffer_len)，而pemalloc(buffer_len，0)将被 使用下列语句映射到emalloc(buffer_len)：

所有这些在ZendMM中提供的分配器函数都能够从下表中找到其更传统的对应实现。

表格1展示了ZendMM支持下的每一个分配器 函数以及它们的e/pe对应实现：

表格1.传统型相对于PHP特定的分配器。

你可能会注意到，即使是pefree()函数也要求使用永久性标志。这是因为在调用pefree()时，它实际上并不知道是否ptr是一种永久性分配。 针对一个非永久性分配调用free()能够导致双倍的空间释放，而针对一种永久性分配调用efree()有可能会导致一个段错误，因为内存管理器会试图查 找并不存在的管理信息。因此，你的代码需要记住它分配的数据结构是否是永久性的。

除了分配器函数核心部分外，还存在其它一些非常方 便的ZendMM特定的函数，例如：

该函 数能够分配len+1个字节的内存并且从ptr处复制len个字节到最新分配的块。这个estrndup()函数的行为可以大致描述如下：

在此，被隐式放置在缓冲区最后的NULL字节可以确保任何使用estrndup()实现字符串复制操作的函数都不需要担心会把结果缓冲区传递给一个例如 printf()这样的希望以为NULL为结束符的函数。当使用estrndup()来复制非字符串数据时，最后一个字节实质上都浪费了，但其中的利明显 大于弊。

这些函数分配的内存空间最终大小是((size*count)+addtl)。你可以会问：”为什么还要提供额外函数呢？为什么不使用一个 emalloc/pemalloc呢？”原因很简单：为了安全。尽管有时候可能性相当小，但是，正是这一”可能性相当小”的结果导致宿主平台的内存溢出。 这可能会导致分配负数个数的字节空间，或更有甚者，会导致分配一个小于调用程序要求大小的字节空间。而safe_emalloc()能够避免这种类型的陷 井-通过检查整数溢出并且在发生这样的溢出时显式地预以结束。

注意，并不是所有的内存分配例程都有一个相应的p*对等实现。例如，不 存在pestrndup()，并且在PHP 5.1版本前也不存在safe_pemalloc()。

五、 引用计数

慎重的内存分配与释放对于PHP（它是一种多请求进程）的长期性能有极其重大的影响；但是，这还仅是问题的一半。为了使一个每秒处理上千次点击的服务器 高效地运行，每一次请求都需要使用尽可能少的内存并且要尽可能减少不必要的数据复制操作。请考虑下列PHP代码片断：

在第一次调用之后，只有一个变量被创建，并且一个12字节的内存块指派给它以便存储字符串”Hello World”，还包括一个结尾处的NULL字符。现在，让我们来观察后面的两行：$b被置为与变量$a相同的值，然后变量$a被释放。

如果PHP因每次变量赋值都要复制变量内容的话，那么，对于上例中要复制的字符串还需要复制额外的12个字节，并且在数据复制期间还要进行另外的处理器 加载。这一行为乍看起来有点荒谬，因为当第三行代码出现时，原始变量被释放，从而使得整个数据复制显得完全不必要。其实，我们不妨再远一层考虑，让我们设 想当一个10MB大小的文件的内容被装载到两个变量中时会发生什么。这将会占用20MB的空间，此时，10已经足够了。引擎会把那么多的时间和内存浪费在 这样一种无用的努力上吗？

你应该知道，PHP的设计者早已深谙此理。

记住，在引擎中，变量名和它们的值实际上是 两个不同的概念。值本身是一个无名的zval*存储体（在本例中，是一个字符串值），它被通过zend_hash_add()赋给变量$a。如果两个变量 名都指向同一个值，会发生什么呢？

此时，你可以实际地观察$a或$b，并且会看到它们都包含字符串”Hello World”。遗憾的是，接下来，你继续执行第三行代码”unset($a);”。此时，unset()并不知道$a变量指向的数据还被另一个变量所使 用，因此它只是盲目地释放掉该内存。任何随后的对变量$b的存取都将被分析为已经释放的内存空间并因此导致引擎崩溃。

这个问题可以借 助于zval（它有好几种形式）的第四个成员refcount加以解决。当一个变量被首次创建并赋值时，它的refcount被初始化为1，因为它被假定 仅由最初创建它时相应的变量所使用。当你的代码片断开始把helloval赋给$b时，它需要把refcount的值增加为2；这样以来，现在该值被两个 变量所引用：

现在，当unset()删除原变量的$a相应的副本时，它就能够从refcount参数中看到，还有另外其他人对该数据感兴趣；因此，它应该只是减少 refcount的计数值，然后不再管它。

六、 写复制（Copy on Write）

通过refcounting来节约内存的确是不错的 主意，但是，当你仅想改变其中一个变量的值时情况会如何呢？为此，请考虑下面的代码片断：

通过上面的逻辑流程，你当然知道$a的值仍然等于1，而$b的值最后将是6。并且此时，你还知道，Zend在尽力节省内存-通过使$a和$b都引用相同 的zval（见第二行代码）。那么，当执行到第三行并且必须改变$b变量的值时，会发生什么情况呢？

回答是，Zend要查看 refcount的值，并且确保在它的值大于1时对之进行分离。在Zend引擎中，分离是破坏一个引用对的过程，正好与你刚才看到的过程相反：

现在，既然引擎有一个仅为变量$b所拥有的 zval*（引擎能知道这一点），所以它能够把这个值转换成一个long型值并根据脚本的请求给它增加5。

七、 写改变（change-on-write）

引用计数概念的引入还导致了一个新的数据操作可能性，其形式从用户空间脚本管理器 看来与”引用”有一定关系。请考虑下列的用户空间代码片断：

在上面的PHP代码中，你能看出$a的值现在为6，尽管它一开始为1并且从未(直接)发生变化。之所以会发生这种情况是因为当引擎开始把$b的值增加5 时，它注意到$b是一个对$a的引用并且认为”我可以改变该值而不必分离它，因为我想使所有的引用变量都能看到这一改变”。

但是，引 擎是如何知道的呢？很简单，它只要查看一下zval结构的第四个和最后一个元素（is_ref）即可。这是一个简单的开/关位，它定义了该值是否实际上是 一个用户空间风格引用集的一部分。在前面的代码片断中，当执行第一行时，为$a创建的值得到一个refcount为1，还有一个is_ref值为0，因为 它仅为一个变量($a)所拥有并且没有其它变量对它产生写引用改变。在第二行，这个值的refcount元素被增加为2，除了这次is_ref元素被置为 1之外（因为脚本中包含了一个”&”符号以指示是完全引用）。

最后，在第三行，引擎再一次取出与变量$b相关的值并且检查是 否有必要进行分离。这一次该值没有被分离，因为前面没有包括一个检查。下面是get_var_and_separate()函数中与refcount检查 有关的部分代码：

这一次，尽管refcount为2，却没有 实现分离，因为这个值是一个完全引用。引擎能够自由地修改它而不必关心其它变量值的变化。

八、 分离问题

尽管已经存在上面讨论到的复制和引用技术，但是还存在一些不能通过is_ref和 refcount操作来解决的问题。请考虑下面这个PHP代码块：

在此，你有一个需要与三个不同的变量相关联的值。其中，两个变量是使用了”change-on-write”完全引用方式，而第三个变量处于一种可分离 的”copy-on-write”（写复制）上下文中。如果仅使用is_ref和refcount来描述这种关系，有哪些值能够工作呢？

回答是：没有一个能工作。在这种情况下，这个值必须被复制到两个分离的zval*中，尽管两者都包含完全相同的数据(见图2)。

图 2.引用时强制分离

同样，下列代码块将引起相同的冲突并且强迫该值分离出 一个副本(见图3)。

图 3.复制时强制分离

注意，在这里的两种情况下，$b都与原始的zval对象相关联，因为在分离发生时引擎无法知道介于到该操作当中的第三个变量的名字。

九、 总结

PHP是一种托管语言。从普通用户角度来看，这种仔细地控制资源和内存的方式意味着更为容易地进行原型开 发并导致出现更少的冲突。然而，当我们深入”内里”之后，一切的承诺似乎都不复存在，最终还要依赖于真正有责任心的开发者来维持整个运行时刻环境的一致 性。

查 看本文来源