潘锦的空间 » PHP应用 https://www.phppan.com SaaS SaaS架构 团队管理 技术管理 技术架构 PHP 内核 扩展 项目管理 Sat, 25 Apr 2026 00:56:17 +0000 zh-CN hourly 1 https://wordpress.org/?v=3.9.40 用PHP实现MD5算法 https://www.phppan.com/2012/07/php-md5/ https://www.phppan.com/2012/07/php-md5/#comments Mon, 16 Jul 2012 00:48:17 +0000 http://www.phppan.com/?p=1727 在上一篇文章 << Content-MD5字段 >>中我们有提到MD5算法，此处MD5算法的作用是验证文件的完整性，这与MD5算法开始的应用场景是一致的，即在90年代被广泛使用在各种程序语言中，用以确保资料传递无误。

MD5即Message-Digest Algorithm 5（信息-摘要算法 5）。 MD5算法是一种消息摘要算法，以任意长度的信息作为输入进行计算，产生一个128-bit(16-byte)的指纹或报文摘要(fingerprint or message digest)。两个不同的信息产生相同信息摘要的概率相当小，从一个给定的信息摘要逆向生成原始信息的可能性更小。但是由于还是存在碰撞的情况，随着计算机运算能力的提高，MD5已经不太适用于有较高安全要求的场合，但是应对一般的文件完整性检查还是可以的。

MD5算法的标准实现过程可以分为5步。

1、MD5算法是对输入的数据进行补位，使得如果数据位长度LEN对512求余的结果是448。

即数据扩展至K512+448位。即K64+56个字节，K为整数。 具体补位操作：补一个1，然后补0至满足上述要求

2、补数据长度

用一个64位的数字表示数据的原始长度B，把B用两个32位数表示。这时，数据就被填补成长度为512位的倍数。

3. 初始化MD5参数

四个32位整数 (A,B,C,D) 用来计算信息摘要，初始化使用的是十六进制表示的数字

  • A=0X01234567
  • B=0X89abcdef
  • C=0Xfedcba98
  • D=0X76543210

4、处理位操作函数

X，Y，Z为32位整数。

  • F(X,Y,Z) = X&Y|NOT(X)&Z
  • G(X,Y,Z) = X&Z|Y?(Z)
  • H(X,Y,Z) = X xor Y xor Z
  • I(X,Y,Z) = Y xor (X|not(Z))

5、主要变换过程

使用常数组T[1 ... 64]， T为32位整数用16进制表示，数据用16个32位的整数数组M表示。

具体过程如下：

 
 /* 处理数据原文 */ 
 
    For i = 0 to N/16-1 do 
 
    /*每一次，把数据原文存放在16个元素的数组X中. */ 
    For j = 0 to 15 do 
        Set X[j] to M[i*16+j]. 
    end /结束对J的循环 
 
    /* Save A as AA, B as BB, C as CC, and D as DD. */ 
    AA = A 
    BB = B 
    CC = C 
    DD = D 
 
    /* 第1轮*/ 
     * 以 [abcd k s i]表示如下操作 
     * a = b + ((a + F(b,c,d) + X[k] + T) s). 
     */ 
 
    /* Do the following 16 operations. */ 
 
    [ABCD 0 7 1] [DABC 1 12 2] [CDAB 2 17 3] [BCDA 3 22 4] 
    [ABCD 4 7 5] [DABC 5 12 6] [CDAB 6 17 7] [BCDA 7 22 8] 
    [ABCD 8 7 9] [DABC 9 12 10] [CDAB 10 17 11] [BCDA 11 22 12] 
    [ABCD 12 7 13] [DABC 13 12 14] [CDAB 14 17 15] [BCDA 15 22 16] 
 
    /* 第2轮* */ 
 
    /** 以 [abcd k s i]表示如下操作 
     * a = b + ((a + G(b,c,d) + X[k] + T) s).
     */ 
 
    /* Do the following 16 operations. */ 
 
    [ABCD 1 5 17] [DABC 6 9 18] [CDAB 11 14 19] [BCDA 0 20 20] 
    [ABCD 5 5 21] [DABC 10 9 22] [CDAB 15 14 23] [BCDA 4 20 24] 
    [ABCD 9 5 25] [DABC 14 9 26] [CDAB 3 14 27] [BCDA 8 20 28] 
    [ABCD 13 5 29] [DABC 2 9 30] [CDAB 7 14 31] [BCDA 12 20 32] 
 
    /* 第3轮*/ 
 
    /** 以 [abcd k s i]表示如下操作 
      * a = b + ((a + H(b,c,d) + X[k] + T) s).
      */ 
 
    /* Do the following 16 operations. */ 
 
    [ABCD 5 4 33] [DABC 8 11 34] [CDAB 11 16 35] [BCDA 14 23 36] 
    [ABCD 1 4 37] [DABC 4 11 38] [CDAB 7 16 39] [BCDA 10 23 40] 
    [ABCD 13 4 41] [DABC 0 11 42] [CDAB 3 16 43] [BCDA 6 23 44] 
    [ABCD 9 4 45] [DABC 12 11 46] [CDAB 15 16 47] [BCDA 2 23 48] 
 
    /* 第4轮*/ 
 
    /** 以 [abcd k s i]表示如下操作 
      * a = b + ((a + I(b,c,d) + X[k] + T) s).
      */ 
 
    /* Do the following 16 operations. */ 
 
    [ABCD 0 6 49] [DABC 7 10 50] [CDAB 14 15 51] [BCDA 5 21 52] 
    [ABCD 12 6 53] [DABC 3 10 54] [CDAB 10 15 55] [BCDA 1 21 56] 
    [ABCD 8 6 57] [DABC 15 10 58] [CDAB 6 15 59] [BCDA 13 21 60] 
    [ABCD 4 6 61] [DABC 11 10 62] [CDAB 2 15 63] [BCDA 9 21 64] 
 
    /* 然后进行如下操作 */ 
    A = A + AA 
    B = B + BB 
    C = C + CC 
    D = D + DD 
    end /* 结束对I的循环*

用PHP实现MD5算法

PHP的实现基本按照上面的算法实现，
对于PHP来说，特殊的位置有三点：

  • 在于需要规避其在数组中，当数组元素超过整形长度时的自动转换；
  • 无符号右移操作的实现；
  • 将字符串转换成8位存储为一个元素的数据结构。

代码如下：

 
<?php
 
$str = "1";
$md5 = new MD5($str);
echo $md5->getDigist();
echo "<br />", md5($str);
 
class MD5 {
    const CHAR_ALIGNMENT = 8;
 
    private $_digist;
    private $_state;
 
    public function __construct($str) {
        $bin = $this->_str2bin($str);
        $len = strlen($str) * self::CHAR_ALIGNMENT;
        $bin[$len >> 5] |= 128 << ($len % 32);
        $bin[((($len + 64) >> 9) << 4) + 14] = $len;
 
        $this->_md5Init();
        $this->_update($bin);
        $this->_digist = $this->_bin2hex($this->_state);
    }
 
    /**
     * 公有方法
     * 获取信息摘要
     * @return string  
     */
    public function getDigist() {
        return $this->_digist;
    }
 
    private function _bin2hex($bin) {
        $hex_tab = "0123456789abcdef";
        $str = "";
        for ($i = 0; $i < count($bin) * 4; $i++) {
            $str .= $hex_tab[($bin[$i >> 2] >> (($i % 4) * 8 + 4)) & 0xF] .
                    $hex_tab[($bin[$i >> 2] >> (($i % 4) * 8 )) & 0xF];
        }
        return $str;
    }
 
    private function _update($bin) {
        $bin_len = count($bin);
        for ($i = 0; $i < $bin_len; $i += 16) {
            $block = array();
            for ($j = 0; $j < 16; $j++) {
                $block[$j] += isset($bin[$i + $j]) ? $bin[$i + $j] : 0;
            }
            $this->_md5Transform($block);
            unset($block);
        }
    }
 
     /**
       * 初始化
       */
    private function _md5Init() {
 
        $this->_state[0] = intval(0x67452301);
        $this->_state[1] = intval(0xefcdab89);
        $this->_state[2] = intval(0x98badcfe);
        $this->_state[3] = intval(0x10325476);
 
        return TRUE;
    }
 
    private function _md5Transform($block) {
        $a = $this->_state[0];
        $b = $this->_state[1];
        $c = $this->_state[2];
        $d = $this->_state[3];
 
        $x = $block;
 
        /** Round 1 */
        MD5Tool::FF($a, $b, $c, $d, $x[0], MD5Tool::S11, 0xd76aa478); /* 1 */
        MD5Tool::FF($d, $a, $b, $c, $x[1], MD5Tool::S12, 0xe8c7b756); /* 2 */
        MD5Tool::FF($c, $d, $a, $b, $x[2], MD5Tool::S13, 0x242070db); /* 3 */
        MD5Tool::FF($b, $c, $d, $a, $x[3], MD5Tool::S14, 0xc1bdceee); /* 4 */
        MD5Tool::FF($a, $b, $c, $d, $x[4], MD5Tool::S11, 0xf57c0faf); /* 5 */
        MD5Tool::FF($d, $a, $b, $c, $x[5], MD5Tool::S12, 0x4787c62a); /* 6 */
        MD5Tool::FF($c, $d, $a, $b, $x[6], MD5Tool::S13, 0xa8304613); /* 7 */
        MD5Tool::FF($b, $c, $d, $a, $x[7], MD5Tool::S14, 0xfd469501); /* 8 */
        MD5Tool::FF($a, $b, $c, $d, $x[8], MD5Tool::S11, 0x698098d8); /* 9 */
        MD5Tool::FF($d, $a, $b, $c, $x[9], MD5Tool::S12, 0x8b44f7af); /* 10 */
        MD5Tool::FF($c, $d, $a, $b, $x[10], MD5Tool::S13, 0xffff5bb1); /* 11 */
        MD5Tool::FF($b, $c, $d, $a, $x[11], MD5Tool::S14, 0x895cd7be); /* 12 */
        MD5Tool::FF($a, $b, $c, $d, $x[12], MD5Tool::S11, 0x6b901122); /* 13 */
        MD5Tool::FF($d, $a, $b, $c, $x[13], MD5Tool::S12, 0xfd987193); /* 14 */
        MD5Tool::FF($c, $d, $a, $b, $x[14], MD5Tool::S13, 0xa679438e); /* 15 */
        MD5Tool::FF($b, $c, $d, $a, $x[15], MD5Tool::S14, 0x49b40821); /* 16 */
 
        /** Round 2 */
        MD5Tool::GG($a, $b, $c, $d, $x[1], MD5Tool::S21, 0xf61e2562); /* 17 */
        MD5Tool::GG($d, $a, $b, $c, $x[6], MD5Tool::S22, 0xc040b340); /* 18 */
        MD5Tool::GG($c, $d, $a, $b, $x[11], MD5Tool::S23, 0x265e5a51); /* 19 */
        MD5Tool::GG($b, $c, $d, $a, $x[0], MD5Tool::S24, 0xe9b6c7aa); /* 20 */
        MD5Tool::GG($a, $b, $c, $d, $x[5], MD5Tool::S21, 0xd62f105d); /* 21 */
        MD5Tool::GG($d, $a, $b, $c, $x[10], MD5Tool::S22, 0x2441453); /* 22 */
        MD5Tool::GG($c, $d, $a, $b, $x[15], MD5Tool::S23, 0xd8a1e681); /* 23 */
        MD5Tool::GG($b, $c, $d, $a, $x[4], MD5Tool::S24, 0xe7d3fbc8); /* 24 */
        MD5Tool::GG($a, $b, $c, $d, $x[9], MD5Tool::S21, 0x21e1cde6); /* 25 */
        MD5Tool::GG($d, $a, $b, $c, $x[14], MD5Tool::S22, 0xc33707d6); /* 26 */
        MD5Tool::GG($c, $d, $a, $b, $x[3], MD5Tool::S23, 0xf4d50d87); /* 27 */
        MD5Tool::GG($b, $c, $d, $a, $x[8], MD5Tool::S24, 0x455a14ed); /* 28 */
        MD5Tool::GG($a, $b, $c, $d, $x[13], MD5Tool::S21, 0xa9e3e905); /* 29 */
        MD5Tool::GG($d, $a, $b, $c, $x[2], MD5Tool::S22, 0xfcefa3f8); /* 30 */
        MD5Tool::GG($c, $d, $a, $b, $x[7], MD5Tool::S23, 0x676f02d9); /* 31 */
        MD5Tool::GG($b, $c, $d, $a, $x[12], MD5Tool::S24, 0x8d2a4c8a); /* 32 */
 
        /** Round 3 */
        MD5Tool::HH($a, $b, $c, $d, $x[5], MD5Tool::S31, 0xfffa3942); /* 33 */
        MD5Tool::HH($d, $a, $b, $c, $x[8], MD5Tool::S32, 0x8771f681); /* 34 */
        MD5Tool::HH($c, $d, $a, $b, $x[11], MD5Tool::S33, 0x6d9d6122); /* 35 */
        MD5Tool::HH($b, $c, $d, $a, $x[14], MD5Tool::S34, 0xfde5380c); /* 36 */
        MD5Tool::HH($a, $b, $c, $d, $x[1], MD5Tool::S31, 0xa4beea44); /* 37 */
        MD5Tool::HH($d, $a, $b, $c, $x[4], MD5Tool::S32, 0x4bdecfa9); /* 38 */
        MD5Tool::HH($c, $d, $a, $b, $x[7], MD5Tool::S33, 0xf6bb4b60); /* 39 */
        MD5Tool::HH($b, $c, $d, $a, $x[10], MD5Tool::S34, 0xbebfbc70); /* 40 */
        MD5Tool::HH($a, $b, $c, $d, $x[13], MD5Tool::S31, 0x289b7ec6); /* 41 */
        MD5Tool::HH($d, $a, $b, $c, $x[0], MD5Tool::S32, 0xeaa127fa); /* 42 */
        MD5Tool::HH($c, $d, $a, $b, $x[3], MD5Tool::S33, 0xd4ef3085); /* 43 */
        MD5Tool::HH($b, $c, $d, $a, $x[6], MD5Tool::S34, 0x4881d05); /* 44 */
        MD5Tool::HH($a, $b, $c, $d, $x[9], MD5Tool::S31, 0xd9d4d039); /* 45 */
        MD5Tool::HH($d, $a, $b, $c, $x[12], MD5Tool::S32, 0xe6db99e5); /* 46 */
        MD5Tool::HH($c, $d, $a, $b, $x[15], MD5Tool::S33, 0x1fa27cf8); /* 47 */
        MD5Tool::HH($b, $c, $d, $a, $x[2], MD5Tool::S34, 0xc4ac5665); /* 48 */
 
        /** Round 4 */
        MD5Tool::II($a, $b, $c, $d, $x[0], MD5Tool::S41, 0xf4292244); /* 49 */
        MD5Tool::II($d, $a, $b, $c, $x[7], MD5Tool::S42, 0x432aff97); /* 50 */
        MD5Tool::II($c, $d, $a, $b, $x[14], MD5Tool::S43, 0xab9423a7); /* 51 */
        MD5Tool::II($b, $c, $d, $a, $x[5], MD5Tool::S44, 0xfc93a039); /* 52 */
        MD5Tool::II($a, $b, $c, $d, $x[12], MD5Tool::S41, 0x655b59c3); /* 53 */
        MD5Tool::II($d, $a, $b, $c, $x[3], MD5Tool::S42, 0x8f0ccc92); /* 54 */
        MD5Tool::II($c, $d, $a, $b, $x[10], MD5Tool::S43, 0xffeff47d); /* 55 */
        MD5Tool::II($b, $c, $d, $a, $x[1], MD5Tool::S44, 0x85845dd1); /* 56 */
        MD5Tool::II($a, $b, $c, $d, $x[8], MD5Tool::S41, 0x6fa87e4f); /* 57 */
        MD5Tool::II($d, $a, $b, $c, $x[15], MD5Tool::S42, 0xfe2ce6e0); /* 58 */
        MD5Tool::II($c, $d, $a, $b, $x[6], MD5Tool::S43, 0xa3014314); /* 59 */
        MD5Tool::II($b, $c, $d, $a, $x[13], MD5Tool::S44, 0x4e0811a1); /* 60 */
        MD5Tool::II($a, $b, $c, $d, $x[4], MD5Tool::S41, 0xf7537e82); /* 61 */
        MD5Tool::II($d, $a, $b, $c, $x[11], MD5Tool::S42, 0xbd3af235); /* 62 */
        MD5Tool::II($c, $d, $a, $b, $x[2], MD5Tool::S43, 0x2ad7d2bb); /* 63 */
        MD5Tool::II($b, $c, $d, $a, $x[9], MD5Tool::S44, 0xeb86d391); /* 64 */
 
        /**
         * 注意，这里必须执行intval函数
         */
        $this->_state[0] = intval($this->_state[0] + $a);
        $this->_state[1] = intval($this->_state[1] + $b);
        $this->_state[2] = intval($this->_state[2] + $c);
        $this->_state[3] = intval($this->_state[3] + $d);
    }
 
    private function _str2bin($str) {
        $bin = array();
        $alignment = (1 << self::CHAR_ALIGNMENT) - 1;
        $len = strlen($str);
 
        for ($i = 0; $i < $len * self::CHAR_ALIGNMENT; $i += self::CHAR_ALIGNMENT) {
            $key = $i >> 5;
            $bin[$key] |= ( ord($str[$i / self::CHAR_ALIGNMENT]) & $alignment) << ($i % 32);
        }
 
        return $bin;
    }
 
}
 
class MD5Tool {
    /** S11-S44原本是一个 4 * 4 的矩阵，在C实现中是用#define 实现的，
     * 这里作为类的常量表示，在各种对象间共享 
     */
    const S11 = 7;
    const S12 = 12;
    const S13 = 17;
    const S14 = 22;
 
    const S21 = 5;
    const S22 = 9;
    const S23 = 14;
    const S24 = 20;
 
    const S31 = 4;
    const S32 = 11;
    const S33 = 16;
    const S34 = 23;
 
    const S41 = 6;
    const S42 = 10;
    const S43 = 15;
    const S44 = 21;
 
    /** F, G, H ,I 是4个基本的MD5函数，
     * 在C实现中，一般是用宏实现，这里我们以类方法的形式给出 
     */
    public static function F($x, $y, $z) {
        return ($x & $y) | ((~$x) & $z);
    }
 
    public static function G($x, $y, $z) {
        return ($x & $z) | ($y & (~$z));
    }
 
    public static function H($x, $y, $z) {
        return $x ^ $y ^ $z;
    }
 
    public static function I($x, $y, $z) {
        return $y ^ ($x | (~$z));
    }
 
    /**
     * 左移N位
     * @param type $x
     * @param type $n
     * @return type 
     */
    public static function ROTATE_LEFT($x, $n) {
        return ($x << $n) | self::URShift($x, (32 - $n));
    }
 
    /**
     * PHP无符号右移
     * @param type $x
     * @param type $bits
     * @return type 
     */
    public static function URShift($x, $bits) {
        /** 转换成代表二进制数字的字符串 */
        $bin = decbin($x);
        $len = strlen($bin);
 
        /** 字符串长度超出则截取底32位，长度不够，则填充高位为0到32位  */
        if ($len > 32) {
            $bin = substr($bin, $len - 32, 32);
        } elseif ($len < 32) {
            $bin = str_pad($bin, 32, '0', STR_PAD_LEFT);
        }
 
        /** 取出要移动的位数，并在左边填充0  */
        return bindec(str_pad(substr($bin, 0, 32 - $bits), 32, '0', STR_PAD_LEFT));
    }
 
    /**
     * FF,GG,HH和II将调用F,G,H,I进行近一步变换
     * 其中FF,GG,HH和II分别为四轮转移调用
     * 
     * 注意: 在PHP中，这里使用了引用返回，第一个元素
     * 并且所有的返回值必须执行intval强制转换为整形，否则最终可能会被PHP自动转换
     */
    public static function FF(&$a, $b, $c, $d, $x, $s, $ac) {
        $a += self::F($b, $c, $d) + ($x) + $ac;
        $a = self::ROTATE_LEFT($a, $s);
        $a = intval($a + $b);
    }
 
    public static function GG(&$a, $b, $c, $d, $x, $s, $ac) {
        $a += self::G($b, $c, $d) + ($x) + $ac;
        $a = self::ROTATE_LEFT($a, $s);
        $a = intval($a + $b);
    }
 
    public static function HH(&$a, $b, $c, $d, $x, $s, $ac) {
        $a += self::H($b, $c, $d) + ($x) + $ac;
        $a = self::ROTATE_LEFT($a, $s);
        $a = intval($a + $b);
    }
 
    public static function II(&$a, $b, $c, $d, $x, $s, $ac) {
        $a += self::I($b, $c, $d) + ($x) + $ac;
        $a = self::ROTATE_LEFT($a, $s);
        $a = intval($a + $b);
    }
 
}
 
?>

在构造函数中，MD5算法的几个步骤基本一一对应。

后记

其实这篇文章并没有多大的实用价值，除非你想用PHP实现一下MD5算法，并了解一下具体的MD5算法，除非你和我一样，有些手贱，除非……

参考资料

  • http://zh.wikipedia.org/zh-cn/MD5
  • http://www.cppblog.com/ant/archive/2007/09/11/31886.html
  • http://tech.fromeasy.com/bbs/viewthread.php?tid=693
  • http://pajhome.org.uk/crypt/md5/
]]> https://www.phppan.com/2012/07/php-md5/feed/ 0 使用PHP计算上一个月的今天 https://www.phppan.com/2011/06/php-last-month-today/ https://www.phppan.com/2011/06/php-last-month-today/#comments Wed, 15 Jun 2011 01:16:15 +0000 http://www.phppan.com/?p=1404 一日，遇到一个问题，求上一个月的今天。 最开始我们使用 strtotime(“-1 month”) 函数求值，发现有一个问题，月长度不一样的月份的计算结果有误。 比如：2011-03-31，得到的结果是2011-03-03。我们先不追究什么问题，先看如何解决问题。 此时，想起PHP中有一个mktime函数，于是自己写了如下代码：

echo date("Y-m-d H:i:s", mktime(date("G", $time), date("i", $time),
 date("s", $time), date("n", $time) - 1, date("j", $time), date("Y", $time)));

当执行时，发现结果和strtotime的结果是一样的。

还是基于这个函数，既然无法直接操作月，那么我们从天入手，得到上一个月，然后再使用date拼接数据。如下代码：

$time = strtotime("2011-03-31");

/**
 * 计算上一个月的今天
 * @param type $time
 * @return type
 */
function last_month_today($time) {
     $last_month_time = mktime(date("G", $time), date("i", $time),
                date("s", $time), date("n", $time), - 1, date("Y", $time));
     return date(date("Y-m", $last_month_time) . "-d H:i:s", $time);
}

echo last_month_today($time);

但是此时又有了另一个问题，不存在2011-02-31这样的日期，怎么办？现在的需求是对于这样的日期显示当月最后一天。 如下代码：

 $time = strtotime("2011-03-31");

/**
 * 计算上一个月的今天，如果上个月没有今天，则返回上一个月的最后一天
 * @param type $time
 * @return type
 */
function last_month_today($time){
    $last_month_time = mktime(date("G", $time), date("i", $time),
                date("s", $time), date("n", $time), 0, date("Y", $time));
    $last_month_t =  date("t", $last_month_time);

    if ($last_month_t < date("j", $time)) {
        return date("Y-m-t H:i:s", $last_month_time);
    }

    return date(date("Y-m", $last_month_time) . "-d", $time);
}

echo last_month_today($time);

这里需要注意一点： date(“Y-m”, $last_month_time) . “-d”这段代码。在写代码的过程中如果写成了 “Y-” . date(“m”, $last_month_time) . “-d” 则在跨年的时间上有问题。 这点还是在写这篇文章时发现的。

除了这种方法，还可以先算出年月日再拼接字符串，这里就是纯粹的字符串操作了。

感触：

  • 一个月不写代码，会手生。
  • 代码写完后请多次review或重构，即使比较简单的代码。
]]> https://www.phppan.com/2011/06/php-last-month-today/feed/ 0 PHP中的前缀自增(++i) 和后缀自增 (i++) https://www.phppan.com/2011/05/pre_inc-and-post_inc-in-php/ https://www.phppan.com/2011/05/pre_inc-and-post_inc-in-php/#comments Mon, 16 May 2011 01:28:21 +0000 http://www.phppan.com/?p=1374 当我们学第一门语言时，比如大学课程中的C语言程序设计，也许曾经被前缀自增(++i) 和后缀自增 (i++)纠结过。 曾经以为我们懂了：

  • i++ ：先引用后增加，先在i所在的表达式中使用i的当前值，后让i加1
  • ++i ：先增加后引用，让i先加1，然后在i所在的表达式中使用i的新值

这个表达基本没错，只能说不够精确。在《Expert C Programming》这本书中的附录中，有这样一段说明： ++i表示取i的地址，增加它的内容，然后把值放在寄存器中；i++表示取i的地址，把它的值装入寄存器中，然后增加内存中的i的值。 这里的寄存器存放的就是我们在表达式中使用的值。

在PHP中也有++$i和$i++，那么Zend内核是如何实现这两种自增方式的呢？ 看下面一个例子，在不运行这段代码的情况下，你认为会输出什么呢？

$i = 0;
$i = $i++;
echo $i;

咱们先不论答案是什么？我们直接从Zend内核查看这种自增操作的实现。

使用VLD查看包含了$i++和++$i的PHP代码生成的中间代码：

$i = 0;
$i++;
++$i;

使用VLD命令(php -dvld.active=1 -dvld.verbosity=3 t.php)查看详细参数:

number of ops:  8
compiled vars:  !0 = $i
line     # *  op                           fetch          ext  return  operands
--------------------------------------------------------------------------------
-
   2     0  >   EXT_STMT                                          RES[  IS_UNUSED  ]         OP1[  IS_UNUSED  ] OP2[  IS_UNUSED  ]
         1      ASSIGN                                                    OP1[IS_CV !0 ] OP2[ ,  IS_CONST (0) 0 ]
   3     2      EXT_STMT                                          RES[  IS_UNUSED  ]         OP1[  IS_UNUSED  ] OP2[  IS_UNUSED  ]
         3      POST_INC                                          RES[  IS_TMP_VAR ~1 ]       OP1[  IS_CV !0 ]
         4      FREE                                                      OP1[IS_TMP_VAR ~1 ]
   4     5      EXT_STMT                                          RES[  IS_UNUSED  ]         OP1[  IS_UNUSED  ] OP2[  IS_UNUSED  ]
         6      PRE_INC                                                   OP1[IS_CV !0 ]
   5     7    > RETURN                                                    OP1[IS_CONST (0) 1 ]

branch: #  0; line:     2-    5; sop:     0; eop:     7
path #1: 0,

从VLD扩展的输出信息可以知道，前缀自增(++$i)对应的opcode为PRE_INC，后缀自增($i++)对应的opcode为POST_INC。 首先我们看前缀自增(++$i)，++$i没有返回值或者说它的返回值为空。 根据中间代码和VLD显示的OP1的参数类型， 我们可以知道++$i的中间代码在执行是最终调用的是Zend/zend_vm_execute.h文件中的ZEND_PRE_INC_SPEC_CV_HANDLER函数。 在ZEND_PRE_INC_SPEC_CV_HANDLER函数中有几个关键点:

  • CV类型变量的获取，它是调用_get_zval_ptr_ptr_cv获取CV类型变量。 这里的CV类型的变量是PHP编译期间的类似于缓存的作用，主要作用是提高某些变量的存储速度。
  • increment_function函数，不管是实例变量，类变量或者常规的变量，最终都是调用increment_function函数实现变量的增加操作。 在这个函数中，程序会根据变量的类型做出不同的处理，在PHP5.3.1这个版本中，PHP支持IS_LONG、IS_DOUBLE、IS_NULL和IS_STRING四种类型。 如果变量的类型是IS_NULL，程序会将变量的值赋值为1。如果变量类型是字符串，程序会将其转化成整形或浮点型进行计算。
  • 使用RETURN_VALUE_UNUSED宏清除返回结果，这个宏的作用是将result变量的类型设置为EXT_TYPE_UNUSED类型。

前缀自增(++$i)操作在Zend内核中本质上是操作变量本身，而且在表达式中使用的也是这个变量本身。

了解了++$i的实现，我们来看下可能使用得更多的$i++操作的实现。 同样，从中间代码POST_INC和OP1的类型是IS_CV，我们可以在Zend/zend_vm_execute.h文件中找到其实现为ZEND_POST_INC_SPEC_CV_HANDLER。 与前面的ZEND_PRE_INC_SPEC_CV_HANDLER相比，它们都有一个取CV类型变量的过程，也有一个increment_function函数增加变量值的过程， 但是除此之外它多了一个操作，同时也少了一个操作。 它多的一个操作是：

EX_T(opline->result.u.var).tmp_var = **var_ptr;
zendi_zval_copy_ctor(EX_T(opline->result.u.var).tmp_var);

这两行代码的作用是初始化返回值到临时变量，并且将原始的$i的值存储在这，这就是我们在前面使用VLD查看生成的中间代码其结果为RES[ IS_TMP_VAR ~1 ]的原因。 在这个初始化完成后，程序会继续执行增加操作，在增加操作完成后，它就结束了，而之前的++$i操作则会将result设置为UNUSED类型，这就是它少的那个操作。

后缀自增($i++)在表达式中使用的是存放在临时变量中原先的变量值，而变量本身的值已经增加了。 在PHP中这种变量的分离是通过临时变量+返回值解决。

到这里，我们可以回答最开始的问题了，它会输出0。因为在表达式中$i++的返回值是一个临时变量，也就是$i原来的值，也就是0。

]]> https://www.phppan.com/2011/05/pre_inc-and-post_inc-in-php/feed/ 0 数据库抽象层和Doctrine DBAL 源码简单分析 https://www.phppan.com/2010/12/dbal-source/ https://www.phppan.com/2010/12/dbal-source/#comments Mon, 27 Dec 2010 01:08:15 +0000 http://www.phppan.com/?p=1205 数据库抽象层和Doctrine DBAL 源码简单分析

【概述】
　数据库抽象层，顾名思义，将数据库抽象出来，作为一个独立的层存在。它存在的作用是当从一个数据库系统向另一个数据库系统迁移时，几乎不用更改太多的程序代码或者只是改一下配置文件，其它的工作都会交给数据库抽象层去做。数据库抽象层会根据使用的数据库自动调整，这样会提高开发效率，但是由于数据库抽象层是在数据库与业务之间增加了一个额外的代码层，从而可能会产生一些性能上的问题。因此，我们在使用一个数据抽象层之前需要按照自己的需求，权衡抽象层带来的性能和效率开销。
【Doctrine DBAL 简述】
Doctrine DBAL是一个轻量级的类似于PDO的数据库抽象接入层。它是一个面向对象的架构，需求PHP5.3版本的支持，因为它的实现用到了命名空间。除了类似于PDO的操作外，它允许人们定制属于自己的数据库支持。DBAL能够被用于ORM，这在Doctrine ORM项目中有体现。
【Doctrine DBAL源码综述】
以下是我在阅读完Doctrine DBAL后形成的文字。
整体结构：
Driver
包括DBAL目录下的Driver.php, DriverManager.php和Driver目录下的所有文件
如果要在DBAL下为一个新的数据库提供支持，在Driver这块需要实现下面的两个接口：
\Doctrine\DBAL\Driver\Driver
\Doctrine\DBAL\Driver\Statement
这两个接口的方法和PDO完全相同。
Driver.php中包含Driver接口，所有的Driver必须实现这个接口。
DriverManager.php是一个工厂类，它会根据不同的driver返回不同的Doctrine\DBAL\Connection实例。当然，它也可以返回我们自定义的Connection类实例。
Driver目录包括各数据库对Driver的实现以及公用的Connection接口，Statement接口等。如果要定制新的数据库支持，我们也需要在这个目录下创建一个新的目录，并在这个目录下实现Connection等接口。
PDOConnection.php文件和PDOStatement.php文件中的类是对于Connection接口及Statement接口的默认实现。

根目录下的Connection类实现了Doctrine\DBAL\Driver\Connection接口，并增加了事件，事务隔离级别，配置，模拟事务嵌套，延迟连接等功能
根目录下的Statement类实现了Doctrine\DBAL\Driver\Statement接口，并增加了日志，DBAL类型映射等功能。
Platform
Platform抽象了查询生成及不同的数据间的细微的差别。它将会被Schema和Statement等调用。
Platform的实现全部在Platform目录下，它会针对每个数据库支持实现不同的平台支持。它会在通过Driver中的getDatabasePlatform方法创建实例而进行初始化。不同的Driver调用对应的Platform。
Statement
Statement提供日志及类型的抽象转化功能集成，主要实现在根目录下的Statement.php文件

Schema
Schema抽象了生成表修改SQL的接口，这些修改操作的对象包括表，序列，外键和索引等。
它包括Schema目录下所有文件。
针对索引，表，外链等都有其独立实现，并且对于SchemaManager,各个数据库都有其不同的实现。
Type
Type抽象了所有数据库的类型，将各数据库的数据类型与DBAL中定义的类型一一对应。在程序调用时针根据选择的数据库映射到对应的类型。
它包括Type目录下的所有文件。所有的类型都继承自Type类。
Type的映射替换操作会在Statement绑定值和绑定参数时进行。
Log
Logging目录下所有文件
在2.0.0版本中仅包括SQLLogger接口，使用echo/var_dump输出日志的EchoSQLLogger类，包含执行过程中SQL的DebugStack类。
貌似这两个类都还在一个不完善的阶段。

Event
包括：
根目录下的Events.php文件
Event目录下的所有文件
Common目录下的EventArgs.php,EventManager.php,EventSubscriber.php文件
Events.php文件中的Event类是一个final类，它仅仅是一个包含所有事件的容器。在2.0.0版本中仅包含postConnect事件。
EventManager.php中的EventManager类是整个事件机制中非常重要的类，它负责整个事件的注册及事件的执行。对于postContent事件将会在Doctrine\DBAL\Connection的connect()方法中触发。
Event目录下的ConnectionEventArgs类负责与Connection的联系，它类似于一个中转站，在Doctrine\DBAL\Connection创建连接时会创建ConnectionEventArgs类的实例，并将Connection的实例作为构造方法的参数传递给ConnectionEventArgs实例。当事件触发时需要调用平台的数据库操作，则通过这个传递过来的Connection实例执行。Event目录下的Listeners目录是针对各个数据库平台的监听事件实现。

Exception
异常仅有根目录下的DBALException异常类。类中包含了若干静态方法，以显示不同的异常。对于这点，个人认为可以将不同的异常拆分成新的异常类，这比捕获DBALException异常后再调用相关的静态方法的扩展性会好一些。

Cache
缓存，这在每个系统或者每个大型架构中都会存在的模块。
在Common目录下的Cache文件夹包含了所有的缓存操作。这里提供了Apc,Array,Memcache,Xcache四种缓存。

【Doctrine DBAL调用过程】
以初始化一个连接，执行一条查询语句为例：

1
2
3
4
5
6
7
8
9
10
11
12
13

$config = new \Doctrine\DBAL\Configuration();
$connectionParams = array(
    'dbname' => 'mydb',
    'user' => 'user',
    'password' => 'secret',
    'host' => 'localhost',
    'driver' => 'pdo_mysql',
);
$conn = DriverManager::getConnection($connectionParams);
 
$statement = $conn->prepare('SELECT * FROM user');
$statement->execute();
$users = $statement->fetchAll();

第1~9行，配置并通过一个DriverManager创建一个Connection。这是一个工厂方法，它会依据driver调用不同的Driver类，这里会调用 Doctrine\DBAL\Driver\PDOMySql\Driver类，创建mysql的Driver。它会创建包装器实例，默认情况下是Doctrine\DBAL\Connection，我们可以通过在函数的参数中指定wrapperClass，从而创建自定义的包装器。最后返回一个包装类的实现。
第11行，调用Connection的prepare准备SQL语句，这里它会连接数据库，在连接时会依据Driver的不同，连接不同的数据库，并且会触发定义在connect方法中的Events::postConnect事件。最后，返回一个创建的Statement实例。
第12行，调用Statement的execute方法。在这个方法中会调用Log模块，记录SQL的日志，并且通过包装器中转调用相对应数据库的Statement实例的execute方法。
第13行，取数据。和上面的execute类似，调用对应Satement实例的fetchAll方法返回数据。

–EOF–

]]> https://www.phppan.com/2010/12/dbal-source/feed/ 0 PHP中的urlencode，rawurlencode和JS中的encodeURI，encodeURIComponent https://www.phppan.com/2010/10/php-urlencode-rawurlencode-js-encodeuri-encodeuricomponent/ https://www.phppan.com/2010/10/php-urlencode-rawurlencode-js-encodeuri-encodeuricomponent/#comments Fri, 29 Oct 2010 05:54:00 +0000 http://www.phppan.com/?p=1074 PHP中的urlencode，rawurlencode和JS中的encodeURI，encodeURIComponent

【PHP中的urlencode和rawurlencode】
urlencode之前有看过其源码实现PHP 源码阅读笔记二十三 ：urlencode函数
二都的区别仅在” “空格上，rawurlencode()会把空格编码为%20，而urlencode会把空格编码为+

【JS中的encodeURI和encodeURIComponent】
encodeURI 方法不会对下列字符进行编码：”:”、”/”、”;” 和 “?”，而encodeURIComponent会编码这些字符

【urlencode与encodeURI】
首先，我们看下这4种编码方式针对ASCII的127个字符编码后的差别，显示代码如下：

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

<?php
/**
 * 生成urlencode,rawurlencode,encodeURI,encodeURIComponent的编码结果 2010-10-29 sz
 * @author phppan.p#gmail.com  http://www.phppan.com
 * 哥学社成员（http://www.blog-brother.com/）
 * @package test
 */
header("Content-type:text/html;charset=utf-8");
 
echo <<<STYLE
<style type="text/css">
    table {
cursor:default;
font-family:Verdana,Helvetica,sans-serif;
font-size:8pt;
}
td {
background:none repeat scroll 0 0 #EFEFEF;
text-align:center;
width:100px;
}
</style>
STYLE;
echo '<table >';
echo _tr(_td("ASCII") . _td("urlenocde") . _td("rawurlencode") . _td("encodeURI") . _td("encodeURIComponent"));
for ($i = 0; $i < 128; $i++) {
    $ch = chr($i);
    $td = _td($ch) . _td(urlencode($ch)) . _td(rawurlencode($ch));
    $td .= _td(_encodeURI($ch)) . _td(_encodeURIComponent($ch));
 
    echo _tr($td);
}
echo "</table>";

对比urlencode和encodeURI的不同，可以看到#$&+,/:;=?@这些符号编码结果不同，
于是对于需要在PHP中编码后，给js的encodeURI使用的操作可以使用如下函数：

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

<?php
/**
 * urlencode适用于js版本 2010-10-29 sz
 * @author phppan.p#gmail.com  http://www.phppan.com
 * 哥学社成员（http://www.blog-brother.com/）
 * @package test
 */
header("Content-type:text/html;charset=utf-8");
 
function urlencode_js($str) {
    $str_len = strlen($str);
 
    $new = array();
    for ($i = 0; $i < $str_len; $i++) {
        $ch = $str[$i];
        if (strpos("#$&+,/:;=?@", $ch) !== FALSE) {
            $new[] = $ch;
        } else {
            $new[] = urlencode($ch);
        }
    }
 
    return implode("", $new);
}
 
$encode_str = urlencode_js("a汉bc中文 章+aa#$&+,/:;=?@a汉bc中文 章+aa");
 
echo <<<HTML
<script type="text/javascript">
    document.write(decodeURI("$encode_str") + "<br />");
 </script>
HTML;
die();

【urlencode和urldecode的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

 
<?php
/**
 * urlencode和urldecode的PHP版本 2010-10-29 sz
 * @author phppan.p#gmail.com  http://www.phppan.com
 * 哥学社成员（http://www.blog-brother.com/）
 * @package test
 */
header("Content-type:text/html;charset=utf-8");
 
$str = "a汉bc中文 章+aa:/;?()'!-.*_~";
 
/**
 * urlencode的PHP实现
 * 纯属折腾 其C实现请参照PHP源码  url.c文件中php_url_encode函数
 * @param <type> $str
 * @return <type>
 */
function myurlencode($str) {
    $len = strlen($str);
 
    $rs = array();
    for ($i = 0; $i < $len; $i++) {
        $ch = $str[$i];
        if ($ch == ' ') {
            $rs[] = '+';
        } else if (!encodecheck($ch)) {
            $rs[] = strtoupper('%' . dechex(ord($ch) >> 4) . dechex(ord($ch) & 15));
        } else {
            $rs[] = $ch;
        }
    }
 
    return implode("", $rs);
}
 
/**
 * 判断是否为字符和字线以及_-.
 * 相当于c中的!isalnum(c) && strchr("_-.", c) == NULL（PHP源码）
 * @param <type> $ch
 * @return <type>
 */
function encodecheck($ch) {
    $pattern = "/[a-zA-Z0-9_\-\.]/";
    return preg_match($pattern, strval($ch));
}
 
/**
 * 判断是否为16进制数
 * @param <type> $ch
 * @return <type>
 */
function checkhex($ch) {
    $hexstr = "0123456789ABCDEF";
    return strpos($hexstr, strval($ch)) === FALSE ? FALSE : TRUE;
}
 
/**
 * urldecode的PHP实现
 * 纯属折腾
 * @param <type> $str
 * @return <type>
 */
function myurldecode($str) {
    $len = strlen($str);
 
    $rs = array();
    for ($i = 0; $i < $len; $i++) {
        $ch = $str[$i];
        if ($ch == '+') {
            $rs[] = ' ';
        } else if ($ch == '%' && isset($str[$i + 1]) && checkhex($str[$i + 1]) && isset($str[$i + 2]) && checkhex($str[$i + 2])) {
            $rs[] = chr(hexdec($str[$i + 1] . $str[$i + 2]));
            $i += 2;
        } else {
            $rs[] = $ch;
        }
    }
 
    return implode("", $rs);
}
 
/* 测试 */
echo $str, '<br />';
echo urldecode(myurlencode($str)), '<br />';
echo myurldecode(urlencode($str)), '<br />';
die();

以上算是对urlencode和urldecode实现的一次复习吧。

–EOF–

]]> https://www.phppan.com/2010/10/php-urlencode-rawurlencode-js-encodeuri-encodeuricomponent/feed/ 0 PHP页面仅输出了一部分内容的原因：程序报错 https://www.phppan.com/2010/07/php-part-program-error/ https://www.phppan.com/2010/07/php-part-program-error/#comments Mon, 19 Jul 2010 01:04:31 +0000 http://www.phppan.com/?p=831 上周，vsgeping跟我讨论一个问题，关于PHP页面在显示时，仅显示了一部分，一开始我以为是缓冲的问题，即内容被写到stdout后，没有输出到浏览器。纠结了许久
然后在周末时，忽然想起前段时间由于json版本的问题也导致了类似情况的出现，于是怀疑是程序在那个点就停止了，或者说是报错了，程序由于关闭了报错，于是就没有了内容。
有代码，有真相
看如下的一个例子
【PHP报错终止仅显示报错前内容的示例】

错误之前的内容
错误之后的内容

可以看到程序输出：

错误之前的内容
Fatal error: Call to undefined function json() in

上面的程序由于调用了未定义的函数导致报错
如果此时我们去掉error_reporting(E_ALL)
那我们会看到程序仅输出：

错误之前的内容

在此感谢vsgeping

]]> https://www.phppan.com/2010/07/php-part-program-error/feed/ 0 百度招聘的一道题 https://www.phppan.com/2010/06/baidu-2009/ https://www.phppan.com/2010/06/baidu-2009/#comments Thu, 24 Jun 2010 03:52:00 +0000 http://www.phppan.com/?p=783 在烂叶的blog上看到一篇关于百度招聘的一道题
地址：百度招聘的一道试题

有些兴趣，自己实现了下，使用了类蒙地卡罗方法实现。

【题目】
2009百度实习笔试题
要求用PHP，shell或c完成
输入：N（整数）
输入：数据文件A.txt，不超过6条记录，字符串长度不超过15个字节
文件格式如下：
字符串\t数字\n

说明：
每行为1条记录；字符串中不含有\t。
数字描述的是该字符串的出现概率，小于等于100的整数。
多条记录的出现概率之和为100，如果A.txt不满足该条件，程序则退出；
如果文件格式错误，程序也退出。

要求：
编写一个程序，输入为N（正整数），读入文件A.txt，按照字符串出现概率随机地输出字符串，输出N条记录

例如：
输入文件A.txt
abc20
a30
de50
输入为：10

即 abc有20%的概率输出，a有30%的概率输出，de有50%的概率输出，输出10条记录
以下为一次输出的结果,多次输出的结果可能不相同。
abc
a
de
de
abc
de
a
de
a
de

【算法】
先将数据从文件中取出存放到数组，然后将概率空间分割为所给字符串个数个部分，然后生成N个1-100的随机数，然后看每个随机数落在哪一个区间，就将该区间对应的字符串输出。

【程序】

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

 
$filename = "A.txt";
 
/**
* 数据初始化 读取文件内容，拆分字符串形成数据，
* @param <type> $filename  数据文件名
* @return <type> 如果文件打开错误或文件错误返回FALSE                                                      
*/
function data_init($filename) {
    $lines = file($filename);
 
    if ($lines === FALSE) {
       return FALSE;
    }
 
    $data = array();
    foreach ($lines as $row) {
       $row = rtrim($row, "\r\n");
 
       $index = strpos($row, "\t");
       $key = substr($row, 0, $index);
 
       if (strlen($key) > 15) {
           return FALSE;
       }
 
       $data[$key] = (int) substr($row, $index + 1);
    }
 
    return $data;
}
 
$data = data_init($filename);
 
if ($data === FALSE) {  //  输入文件错误
    die('Input File Error!');
}
 
if (array_sum($data) != 100) {  //  输入数据错误
    die('Input Data Error!');
}
 
/* 以类蒙地卡罗方法实现 */
$map = array();
$k = 0;
 
/* 概率空间分割 */
foreach ($data as $key => $row) {                                                 
    $i = $row;
    for ($i = 1; $i <= $row; $i++) {
       $map[$k + $i] = $key;
    }
    $k += $row;
}
 
/* 随机输出 */
$count = 10;
for ($i = 0; $i < $count; $i++) {
    $rand_num = rand(1, 100);
    echo $map[$rand_num], '<br />';
}

关于蒙特卡洛方法请猛击：蒙特卡洛方法

]]> https://www.phppan.com/2010/06/baidu-2009/feed/ 0 PHP5.2.0之前版本使用JSON函数的方法 https://www.phppan.com/2010/06/php5-2-0-before-json-function-json_decode/ https://www.phppan.com/2010/06/php5-2-0-before-json-function-json_decode/#comments Tue, 22 Jun 2010 01:21:25 +0000 http://www.phppan.com/?p=775 PHP5.2.0之前版本使用JSON函数的方法
我们知道PHP在其版本5.2.0之后才支持 JSON相关函数，在此版本之前如果我们要使用JSON函数则需要自己实现
JSON的算法已经有人实现了，其下载地址为：http://pear.php.net/pepr/pepr-proposal-show.php?id=198

但是它是一个类这与我们的使用习惯不同，于是我们需要将它包装下，其代码如下：

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

/**
* 对象转换成数组 递归函数
* @param <type> $value 需要转换的值                                
* @return <type>
*/
function object2array($value) {
   if (!(is_array($value) || is_object($value))) {
       return $value;
   }
 
   $array = array();
   foreach ($value as $key => $row) {
       $array[$key] = object2array($row);
   }
 
   return $array;
}
 
/**
* 替换JSON方法
*/
if (!function_exists("json_encode")) {
   include_once("JSON.php");
 
   function json_encode($array) {
       $json = new Services_JSON();
       $json_array = $json->encode($array);
       return $json_array;
   }
 
   /**
    * 解析JSON数据
    * @param string $json_data 需要解析的JSON数据                                                      
    * @param bool $toarray 是否需要解析成数组                                      
    * @return array 返回解析后的数组
    */
   function json_decode($json_data, $toarray = TRUE) {
       $json = new Services_JSON();
       $array = $json->decode($json_data);
 
       if ($toarray) { //  需要转换成数组
           $array = object2array($array);
       }
       return $array;
   }
 
}

不过以上的递归实现在效率上有一些慢，它需要遍历这个数组的所有元素，
如果只限于实现二维数组，可以考虑直接使用循环+类型强制转化来做
【EOF】

]]> https://www.phppan.com/2010/06/php5-2-0-before-json-function-json_decode/feed/ 0 PHP中大整数相乘的2种实现方式 https://www.phppan.com/2010/05/php-big-number-bcmath-and-array/ https://www.phppan.com/2010/05/php-big-number-bcmath-and-array/#comments Sat, 01 May 2010 05:44:25 +0000 http://www.phppan.com/?p=667 PHP中大整数相乘的2种实现方式
1、【通过调用BCMath实现】
PHP 为任意精度数学计算提供了二进制计算器（Binary Calculator），它支持任意大小和精度的数字，以字符串形式描述。
示例代码如下：

1
2
3
4
5
6

<?PHP
$op_left = '123456789123456789';                                                                                  
$op_right = '123456789123456789';
$rs = bcmul($op_left, $op_right);
var_dump($rs);
die();

2、【通过字符串数组相乘实现】
将乘数和被乘数分别按指定的位数存放到数组中，然后再模拟乘法，将结果加起来，最后在返回的时候针对不够位数的进行补0操作。

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

<?PHP
define('DEPTH', 10000);
define('LEN', strlen(DEPTH) - 1);
 
/**
 * 格式化数组元素，如果单个元素的值不够LEN的长度，前面补0
 * @param string $input
 */
function item_format(&$input) {
    $input = str_pad($input, LEN, "0", STR_PAD_LEFT);
}
 
/**
 * 初始化相乘的字符串，将其转化成数组
 * @param string $input 需要相乘的操作数
 * @return array 已经分好块，并且逆转了的数组
 */
function init_array($input) {
    $begin_len = strlen($input) % LEN;
    $a = array();
    if ($begin_len > 0) {
        $a[0] = substr($input, 0, $begin_len);                                                                         
        $input = substr($input, $begin_len);
    }
    $a = array_merge($a, str_split($input, LEN));
    return array_reverse($a);
}
/**
 * 大整数相乘的数组实现
 * @param string $left_operand  左边的操作数
 * @param string $right_operand 右边的操作数
 * @return string   相乘的结果
 */
function mul($left_operand, $right_operand) {
    if (empty($left_operand) || empty($right_operand)) {
        return FALSE;
    }
 
    /* 初始化相乘的数组 */
    $a = init_array($left_operand);
    $b = init_array($right_operand);
    $len_a = strlen($a);
    $len_b = strlen($b);
 
    for ($i = 0; $i < $len_a; $i++) {
        for ($j = 0; $j < $len_b; $j++) {
            $c[$i + $j] += $a[$i] * $b[$j];
            if ($c[$i + $j] >= DEPTH) { //  进位操作
                $c[$i + $j + 1] += floor($c[$i + $j] / DEPTH);
                $c[$i + $j] %= DEPTH;
            }
        }
    }
 
    $c = array_reverse($c);
    array_walk(&$c, 'item_format');
    return ltrim(implode('', $c), '0');
}
$left_operand = '123456789123456789';
$right_operand = '123456789123456789';
$rs = mul($left_operand, $right_operand);
var_dump($rs);

EOF

]]> https://www.phppan.com/2010/05/php-big-number-bcmath-and-array/feed/ 0 PHP中迭代器的简单实现及Yii框架中的迭代器实现 https://www.phppan.com/2010/04/php-iterator-and-yii-cmapiterator/ https://www.phppan.com/2010/04/php-iterator-and-yii-cmapiterator/#comments Sat, 24 Apr 2010 00:54:14 +0000 http://www.phppan.com/?p=652 PHP中迭代器的简单实现及Yii框架中的迭代器实现
在维基百科中我们可以看到其定义如下：
迭代器有时又称光标（cursor）是程式设计的软件设计模式，可在容器物件（container，例如list或vector）上遍访的接口，设计人员无需关心容器物件的内容。
各种语言实作Iterator的方式皆不尽同，有些面向对象语言像Java, C#, Python, Delphi都已将Iterator的特性内建语言当中，完美的跟语言整合，我们称之隐式迭代器（implicit iterator），但像是C++语言本身就没有Iterator的特色，但STL仍利用template实作了功能强大的iterator。
Iterator另一方面还可以整合Generator。有些语言将二者视为同一接口，有些语言则将之独立化。
地址：http://zh.wikipedia.org/zh-cn/%E8%BF%AD%E4%BB%A3%E5%99%A8
【Iterator的简单实现】

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

/**
* Iterator模式的简单实现类
*/
class sample implements Iterator {
    private $_items ;
 
    public function __construct(&$data) {
        $this->_items = $data;
    }
    public function current() {
        return current($this->_items);
    }
 
    public function next() {
        next($this->_items);   
    }
 
    public function key() {
        return key($this->_items);
    }
 
    public function rewind() {
        reset($this->_items);
    }
 
    public function valid() {                                                                              
        return ($this->current() !== FALSE);
    }
}
 
/** DEMO */
$data = array(1, 2, 3, 4, 5);
$sa = new sample($data);
foreach ($sa AS $key => $row) {
    echo $key, ' ', $row, '<br />';
}

在next()方法的实现时有过纠结，一直以为这里需要返回下一个的值，
这是因为一直以为这里的next就是next函数的实现，但是非也
在手册中我们可以看到其定义为
abstract public void Iterator::next ( void )
其返回值类型为void
所以这里我们调用next函数就可以了，没有必要返回
另外，以上实现对于如下的数组是存在的问题
$data = array(’0′ => 11, ” => 22, ‘s3′ => 33, 0, 0, ”, false, 0, 1);
运行结果是输出：
0 11
22
s3 33
1 0
2 0
3
false后面的值就没有迭代显示出来了，具体原因还不清楚，留作下回分解
在yii框架中也有实现迭代器，它的实现避免了这个问题。

【Yii框架中的迭代器实现】
在Yii框架中的我们可以看到其迭代器的实现
在collections目录下的CMapIterator.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

class CMapIterator implements Iterator {
/**
* @var array the data to be iterated through
*/
    private $_d;
/**
* @var array list of keys in the map
*/
    private $_keys;
/**
* @var mixed current key
*/
    private $_key;
 
/**
* Constructor.
* @param array the data to be iterated through
*/
    public function __construct(&$data) {
        $this->_d=&$data;
        $this->_keys=array_keys($data);
    }
 
/**
* Rewinds internal array pointer.
* This method is required by the interface Iterator.
*/
    public function rewind() {                                                                                 
        $this->_key=reset($this->_keys);
    }
 
/**
* Returns the key of the current array element.
* This method is required by the interface Iterator.
* @return mixed the key of the current array element
*/
    public function key() {
        return $this->_key;
    }
 
/**
* Returns the current array element.
* This method is required by the interface Iterator.
* @return mixed the current array element
*/
    public function current() {
        return $this->_d[$this->_key];
    }
 
/**
* Moves the internal pointer to the next array element.
* This method is required by the interface Iterator.
*/
    public function next() {
        $this->_key=next($this->_keys);
    }
 
/**
* Returns whether there is an element at current position.
* This method is required by the interface Iterator.
* @return boolean
*/
    public function valid() {
        return $this->_key!==false;
    }
}
 
$data = array('s1' => 11, 's2' => 22, 's3' => 33);
$it = new CMapIterator($data);
foreach ($it as $row) {
    echo $row, '<br />';
}

这与之前的简单实现相比，其位置的变化是通过控制key来实现的，这种实现的作用是为了避免false作为数组值时无法迭代

]]> https://www.phppan.com/2010/04/php-iterator-and-yii-cmapiterator/feed/ 0