php编码规范【摘录整理】

转自：http://www.phpweblog.net/yemoo/archive/2007/03/11/967.html


php编码规范

1.  介绍
1.1. 标准化的重要性
    标准化问题在某些方面上让每个人头痛，让人人都觉得大家处于同样的境地。这有助于让这些建议在许多的项目中不断演进，许多公司花费了许多星期逐子字逐句的进行争论。标准化不是特殊的个人风格，它对本地改良是完全开放的。
1.2. 优点
    当一个项目尝试着遵守公用的标准时，会有以下好处：
        程序员可以了解任何代码，弄清程序的状况
        新人可以很快的适应环境
        防止新接触php的人出于节省时间的需要，自创一套风格并养成终生的习惯
        防止新接触php的人一次次的犯同样的错误
        在一致的环境下，人们可以减少犯错的机会
        程序员们有了一致的敌人
1.3. 缺点
    因为标准由一些不懂得php的人所制定，所以标准通常看上去很傻
    因为标准跟我做的不一样，所以标准通常看上去很傻
    标准降低了创造力
    标准在长期互相合作的人群中是没有必要的
    标准强迫太多的格式
1.4. 讨论
    许多项目的经验能得出这样的结论：采用编程标准可以使项目更加顺利地完成。标准是成功的关键么？当然不。但它们可以帮助我们，而且我们需要我们能得到的所有的帮助！老实说，对一个细节标准的大部分争论主要是源自自负思想。对一个合理的标准的很少决定能被说为是缺乏技术性的话，那只是口味的原因罢了。所以，要灵活的控制自负思想，记住，任何项目都取决于团队合作的努力。
1.5.  解释
    1.5.1. 标准实施
        首先应该在开发小组的内部找出所有的最重要的元素，也许标准对你的状况还不够恰当。它可能已经概括了 重要的问题，也可能还有人对其中的某些问题表示强烈的反对。无论在什么情况下，只要最后顺利的话，人们将成熟的明白到这个标准是合理的，然后其他的程序员们也会发现它的合理性，并觉得带着一些保留去遵循这一标准是值得的。如果没有自愿的合作，可以制定需求：标准一定要经过代码的检验。如果没有检验的话，这个解决方案仅仅是一个建立在不精确的基础上的一大群可笑的人。
    1.5.2. 认同观点
        1. 这行不通；
        2. 也许可行吧，但是它既不实用又无聊；
        3. 这是真的，而且我也告诉过你啊；
        4. 这个是我先想到的；
        5. 本来就应该这样。
        如果您带着否定的成见而来看待事物的话，请您保持开放的思想。你仍可以做出它是废话的结论，但是做出结论的方法就是你必须要能够接受不同的思想。请您给自己一点时间去做到它。
    1.5.3. 项目的四个阶段
        1. 数据库结构
        2. 设计
        3. 数据层
        4. HTML层
2.命名规则
    2.1. 合适的命名
        命名是程序规划的核心。古人相信只要知道一个人真正的名字就会获得凌驾于那个人之上的不可思议的力量。只要你给事物想到正确的名字，就会给你以及后来的人带来比代码更强的力量。别笑！
        名字就是事物在它所处的生态环境中一个长久而深远的结果。总的来说，只有了解系统的程序员才能为系统取出最合适的名字。如果所有的命名都与其自然相适合，则关系清晰，含义可以推导得出，一般人的推想也能在意料之中。
        如果你发觉你的命名只有少量能和其对应事物相匹配的话， 最好还是重新好好再看看你的设计吧。
    2.2. 类命名
        在为类（class ）命名前首先要知道它是什么。如果通过类名的提供的线索，你还是想不起这个类是什么的话，那么你的设计就还做的不够好。
        超过三个词组成的混合名是容易造成系统各个实体间的混淆，再看看你的设计，尝试使用（CRC Session card)看看该命名所对应的实体是否有着那么多的功用。
        对于派生类的命名应该避免带其父类名的诱惑，一个类的名字只与它自身有关，和它的父类叫什么无关。
        有时后缀名是有用的，例如：如果你的系统使用了代理（agent ），那么就把某个部件命名为“下载代理”（DownloadAgent）用以真正的传送信息。
    2.3. 方法和函数命名
        通常每个方法和函数都是执行一个动作的，所以对它们的命名应该清楚的说明它们是做什么的：用CheckForErrors()代替ErrorCheck()，用DumpDataToFile()代替DataFile()。这么做也可以使功能和数据成为更可区分的物体。
        有时后缀名是有用的:
            Max - 含义为某实体所能赋予的最大值。
            Cnt - 一个运行中的计数变量的当前值。
            Key - 键值。
            例如：RetryMax 表示最多重试次数，RetryCnt 表示当前重试次数。
        有时前缀名是有用的：
            Is - 含义为问一个关于某样事物的问题。无论何时，当人们看到Is就会知道这是一个问题。
            Get - 含义为取得一个数值。
            Set - 含义为设定一个数值
            例如：IsHitRetryLimit。
    2.4. 缩写词不要全部使用大写字母
        无论如何，当遇到以下情况，你可以用首字母大写其余字母小写来代替全部使用大写字母的方法来表示缩写词。
        使用: GetHtmlStatistic.
        不使用: GetHTMLStatistic.
        理由
            当命名含有缩略词时，人们似乎有着非常不同的直觉。统一规定是最好，这样一来，命名的含义就完全可以预知了。
            举个NetworkABCKey的例子，注意C是应该是ABC里面的C还是key里面的C，这个是很令人费解的。有些人不在意这些，其他人却很讨厌这样。所以你会在不同的代码里看到不同的规则，使得你不知道怎么去叫它。
            例如
                class FluidOz             // 不要写成 FluidOZ
                class GetHtmlStatistic    // 不要写成 GetHTMLStatistic
    2.5. 类命名
        使用大写字母作为词的分隔，其他的字母均使用小写
        名字的首字母使用大写
        不要使用下划线('_')
        理由
            根据很多的命名方式，大部分人认为这样是最好的方式。
            例如
                class NameOneTwo
                class Name
    2.6. 类库命名
        目前命名空间正在越来越广泛的被采用，以避免不同厂商和团体类库间的类名冲突。
        当尚未采用命名空间的时候，为了避免类名冲突，一般的做法是在类名前加上独特的前缀，两个字符就可以了，当然多用一些会更好。
        例如
            John Johnson的数据结构类库可以用Jj做为前缀，如下：
            class JjLinkList
            {
            }
        另一种折中方式是建立包含类库目录（事实上Java也是这么做的），以不通的目录代表不同的命名空间。
        例如
            Microsoft的数据库相关类库可以在：
            /classes/com/Microsoft/ Database/DbConn.php
            Apache的数据库相关类库可在：
            /classes/org/apache/Database/DbConn.php
    2.7. 方法命名
        采用与类命名一致的规则
        理由
            使用所有不同规则的大部分人发现这是最好的折衷办法。
            例如
                class NameOneTwo
                {
                    function DoIt() {};
                    function HandleError() {};
                }
    2.8. 类属性命名
        属性命名应该以字符‘m’为前缀。
        前缀‘m’后采用于类命名一致的规则。
        ‘m’总是在名字的开头起修饰作用，就像以‘r’开头表示引用一样。
        理由
            前缀'm'防止类属性和方法名发生任何冲突。你的方法名和属性名经常会很类似，特别是存取元素。
            例如
                class NameOneTwo
                {
                    function VarAbc() {};
                    function ErrorNumber() {};
                    var $mVarAbc;
                    var $mErrorNumber;
                    var $mrName;
                }

    2.9. 方法中参数命名
        第一个字符使用小写字母。
        在首字符后的所有字都按照类命名规则首字符大写。
        理由
            可以区分方法中的一般变量。
            你可以使用与类名相似的名称而不至于产生重名冲突。
            例如
                class NameOneTwo
                {
                    function StartYourEngines(
                        &$rSomeEngine,
                        &$rAnotherEngine);
                }
    2.10. 变量命名
        所有字母都使用小写
        使用'_'作为每个词的分界。
        理由
            通过这一途径，代码中变量的作用域是清晰的。
            所有的变量在代码中都看起来不同，容易辨认。
            例如
                function HandleError($errorNumber)
                {
                    $error = OsErr($errorNumber);
                    $time_of_error = OsErr->GetTimeOfError();
                    $error_processor = OsErr->GetErrorProcessor();
                }
    2.11. 引用变量和函数返回引用
        引用必须带‘r’前缀
        理由
            使得类型不同的变量容易辨认
            它可以确定哪个方法返回可更改对象，哪个方法返回不可更改对象。
            例如
                class Test
                {
                    var mrStatus;
                    function DoSomething(&$rStatus) {};
                    function &rStatus() {};
                }
    2.12. 全局变量
        全局变量应该带前缀‘g’。
        理由
            知道一个变量的作用域是非常重要的。
            例如
                global $gLog;
                global &$grLog;
    2.13. 定义命名 / 全局常量
        全局常量用'_'分隔每个单词。
        理由
            这是命名全局常量的传统。你要注意不要与其它的定义相冲突。
            例如
                define("A_GLOBAL_CONSTANT", "Hello world!");
    2.14. 静态变量
        静态变量应该带前缀‘s’。
        理由
            知道一个变量的作用域是非常重要的。
            例如
            function test()
            {
                static $msStatus = 0;
            }
    2.15. 函数命名
        函数名字采用C GNU的惯例，所有的字母使用小写字母，使用'_'分割单词。
        理由
            这样可以更易于区分相关联的类名。
            例如
                function some_bloody_function()
                {
                }
    2.16. 错误返回检测规则
        检查所有的系统调用的错误信息，除非你要忽略错误。
        为每条系统错误消息定义好系统错误文本以便include。
3. 书写规则
    3.1. 大括号 {} 规则
        在三种主要的大括号放置规则中，有两种是可以接受的，如下的第一种是最好的：
        将大括号放置在关键词下方的同列处：
            if ($condition)
            {
                while ($condition)
                {
                    ...
                    ...
                }                    
            }
        传统的UNIX的括号规则是，首括号与关键词同行，尾括号与关键字同列：
            if ($condition) {
                while ($condition) {
                    ...
                    ...
                }
            }
        理由
            引起剧烈争论的非原则的问题可通过折衷的办法解决，两种方法任意一种都是可以接受的，然而对于大多数人来说更喜欢第一种。原因就是心理研究学习范畴的东西了。
            对于更喜欢第一种还有着更多的原因。如果您使用的字符编辑器支持括号匹配功能的话（例如vi），最重要的就是有一个好的样式。为什么？我们说当你有一大块的程序而且想知道这一大块程序是在哪儿结束的话。你先移到开始的括号，按下按钮编辑器就会找到与之对应的结束括号，例如：
                if ($very_long_condition && $second_very_long_condition)
                {
                    ...
                }
                else if (...)
                {
                    ...
                }
            从一个程序块移动到另一个程序块只需要用光标和你的括号匹配键就可以了，不需找匹配的括号。
    3.2. 缩进/制表符/空格 规则
        使用制表符缩进。
        使用三到四个空格为每层次缩进。
        不再使用只要一有需要就缩排的方法。对于最大缩进层数，并没有一个固定的规矩，假如缩进层数大于四或者五层的时候，你可以考虑着将代码因数分解(factoring out code)。
        理由
            许多编程者支持制表符。
            当人们使用差异太大的制表符标准的话，会使阅读代码变得很费力。
            如此多的人愿意限定最大的缩进层数，它通常从未被看作是一件工作。我们相信程序员们会明智的选择嵌套的深度。
            例如
               function func()
               {
                  if (something bad)
                  {
                     if (another thing bad)
                     {
                        while (more input)
                        {
                        }
                     }
                  }
               }
    3.3. 小括号、关键词和函数 规则
        不要把小括号和关键词紧贴在一起，要用空格隔开它们。
        不要把小括号和函数名紧贴在一起。
        除非必要，不要在Return返回语句中使用小括号。
        理由
            关键字不是函数。如果小括号紧贴着函数名和关键字，二者很容易被看成是一体的。
            例如
                if (condition)
                {
                }

                while (condition)
                {
                }

                strcmp($s, $s1);

                return 1;
    3.4. 别在对象架构函数中做实际的工作
        别在对象架构构造函数中做实际的工作， 构造函数应该包含变量的初始化和（或）不会发生失败的操作。
        理由
            构造不能返回错误 。
            例如
               class Device
               {
                  function Device()    { /* initialize and other stuff */ }
                  function Open()  { return FAIL; }
               };

               $dev = new Device;
               if (FAIL == $dev->Open()) exit(1);
    3.5. If Then Else 格式
        布局
        这由程序员决定。不同的花括号样式会产生些微不同的样观。一个通用方式是：
           if (条件1)                 // 注释
           {
           }
           else if (条件2)            // 注释
           {
           }
           else                           // 注释
           {
           }
        如果你有用到else if 语句的话，通常最好有一个else块以用于处理未处理到的其他情况。可以的话放一个记录信息注释在else处，即使在else没有任何的动作。
        条件格式总是将恒量放在等号/不等号的左边，
        例如：
            if ( 6 == $errorNum ) ...
        一个原因是假如你在等式中漏了一个等号，语法检查器会为你报错。第二个原因是你能立刻找到数值而不是在你的表达式的末端找到它。需要一点时间来习惯这个格式，但是它确实很有用。
    3.6. switch 格式
        当一个case块处理后，直接转到下一个case块处理，在这个case块的最后应该加上注释。
        default case总应该存在，它应该不被到达，然而如果到达了就会触发一个错误。
        如果你要创立一个变量，那就把所有的代码放在块中。
        例如
           switch (...)
           {
              case 1:
                 ...
              // FALL THROUGH
              case 2:
              {
                 $v = get_week_number();
                 ...
              }
              break;

              default:
           }
    3.7. continue,break 和 ? 的使用
        3.7.1. Continue 和 Break
            Continue 和 break 其实是变相的隐蔽的 goto方法。
            Continue 和 break 像 goto 一样，它们在代码中是有魔力的，所以要节俭（尽可能少）的使用它们。使用了这一简单的魔法，由于一些未公开的原因，读者将会被定向到只有上帝才知道的地方去。
            Continue有两个主要的问题：
                它可以绕过测试条件。
                它可以绕过等/不等表达式。
            看看下面的例子，考虑一下问题都在哪儿发生：
            while (TRUE)
            {
               ...
               // A lot of code
               ...
               if (/* some condition */) {
                  continue;
               }
               ...
               // A lot of code
               ...
               if ( $i++ > STOP_VALUE) break;
            }
            注意："A lot of code"是必须的，这是为了让程序员们不能那么容易的找出错误。
            通过以上的例子，我们可以得出更进一步的规则：continue 和 break 混合使用是引起灾难的正确方法。
        3.7.2. ?:
            麻烦在于人们往往试着在 ? 和 : 之间塞满了许多的代码。以下的是一些清晰的连接规则：
                把条件放在括号内以使它和其他的代码相分离。
                如果可能的话，动作可以用简单的函数。
                把所做的动作，“?”，“:”放在不同的行，除非他们可以清楚的放在同一行。
                例如
                   (condition) ? funct1() : func2();

                   or

                   (condition)
                      ? long statement
                      : another long statement;
    3.8. 声明块的定位
        声明代码块需要对齐。
        理由
            清晰。
            变量初始化的类似代码块应该列表。
            &应靠近类型，而不是变量名。
        例如
            var       $mDate
            var&      $mrDate
            var&      $mrName
            var       $mName

            $mDate    = 0;
            $mrDate   = NULL;
            $mrName   = 0;
            $mName    = NULL;
    3.9. 每行一个语句
        除非这些语句有很密切的联系，否则每行只写一个语句。
    3.10. 短方法
        方法代码要限制在一页内。
    3.11. 记录所有的空语句
        总是记录下for或者是while的空块语句，以便清楚的知道该段代码是漏掉了，还是故意不写的。

        while ($dest++ = $src++)
          ;         // VOID
    3.12. 不要采用缺省方法测试非零值
        不要采用缺省值测试非零值，也就是使用：
        if (FAIL != f())
        比下面的方法好：
        if (f())

        即使 FAIL 可以含有 0 值 ，也就是PHP认为false的表示。在某人决定用-1代替0作为失败返回值的时候，一个显式的测试就可以帮助你了。就算是比较值不会变化也应该使用显式的比较；例如：if (!($bufsize % strlen($str)))应该写成：if (($bufsize % strlen($str)) == 0)以表示测试的数值（不是布尔）型。一个经常出问题的地方就是使用strcmp来测试一个字符等式，结果永远也不会等于缺省值。
        非零测试采用基于缺省值的做法，那么其他函数或表达式就会受到以下的限制:
            只能返回0表示失败，不能为/有其他的值。
            命名以便让一个真(true)的返回值是绝对显然的，调用函数IsValid()而不是Checkvalid()。
    3.13. 布尔逻辑类型
        大部分函数在FALSE的时候返回0，但是发挥非0值就代表TRUE，因而不要用1（TRUE，YES，诸如此类）等式检测一个布尔值，应该用0（FALSE，NO，诸如此类）的不等式来代替：

           if (TRUE == func()) { ...
        应该写成：
           if (FALSE != func()) { ...
    3.14. 通常避免嵌入式的赋值
        有时候在某些地方我们可以看到嵌入式赋值的语句，那些结构不是一个比较好的少冗余，可读性强的方法。

           while ($a != ($c = getchar()))
           {
              process the character
           }
        ++和--操作符类似于赋值语句。因此，出于许多的目的，在使用函数的时候会产生副作用。使用嵌入式赋值提高运行时性能是可能的。无论怎样，程序员在使用嵌入式赋值语句时需要考虑在增长的速度和减少的可维护性两者间加以权衡。例如：

            a = b + c;
            d = a + r;
        不要写成：
            d = (a = b + c) + r;

        虽然后者可以节省一个周期。但在长远来看，随着程序的维护费用渐渐增长，程序的编写者对代码渐渐遗忘，就会减少在成熟期的最优化所得。
    4. 帮助与共享
        4.1. 重用您和其他人的艰苦工作
            跨工程的重用在没有一个通用结构的情况下几乎是不可能的。对象符合他们现有的服务需求，不同的过程有着不同的服务需求环境，这使对象重用变得很困难。
            开发一个通用结构需要预先花费许多的努力来设计。当努力不成功的时候，无论出于什么原因，有几种办法推荐使用：
        4.2. 请教！给群组发Email求助
            这个简单的方法很少被使用。因为有些程序员们觉得如果他向其他人求助，会显得自己水平低，这多傻啊!做新的有趣的工作，不要一遍又一遍的做别人已经做过的东西。
            如果你需要某些事项的源代码，如果已经有某人做过的话，就向群组发email求助。结果会很惊喜哦！
            在许多大的群组中，个人往往不知道其他人在干什么。你甚至可以发现某人在找一些东西做，并且自愿为你写代码，如果人们在一起工作，外面就总有一个金矿。
        4.3. 告诉！当你在做事的时候，把它告诉所有人
            如果你做了什么可重用的东西的话，让其他人知道。别害羞，也不要为了保护自豪感而把你的工作成果藏起来。一旦养成共享工作成果的习惯，每个人都会获得更多。
        4.4. 小型代码库
            对于代码重用，一个常见的问题就是人们不从他们做过的代码中做库。一个可重用的类可能正隐蔽在一个程序目录并且决不会有被分享的激动，因为程序员不会把类分拆出来加入库中。
            这样的其中一个原因就是人们不喜欢做一个小库，对小库有一些不正确感觉。把这样的感觉克服掉吧，电脑才不关心你有多少个库呢。
            如果你有一些代码可以重用，而且不能放入一个已经存在的库中，那么就做一个新的库吧。如果人们真的考虑重用的话，库不会在很长的一段时间里保持那么小的。
        4.5. 知识库
            很多公司不清楚现有什么代码可用，而且大多数程序员仍然没有通过沟通他们已经做过了什么，或者一直在询问现存什么代码可用。解决这个的方法是有一个可用的知识库。
            理想的情况是，程序员可以到一个WEB页，浏览或者查询打包的知识库列表，找到他们所要的。建立一个程序员可以自动维护的知识库系统，是一个很不错的做法。如果有一个专门的管理员来负责维护这个知识库，那当然更好。
            另一种方法是自动的从代码中产生知识库的做法。把通用的类、方法和标头（subsystem headers）作为手册或者是知识库的一个条目。
5. 书写注释
    5.1. 讲一个故事
        把你的注释当作描述系统的一个故事。并且使得你的注释能被机器解析后，以固定的格式放到手册中去。类的注释是故事的一部分，方法的名称、方法的注释、方法的实现也是故事一部分。所有的这些部分编织在一起，使得人们在以后的时间里能够准确的知道你干了什么，为什么这么做。
    5.2.  归档注释
        注释的要归档才有意义，否则，假如在一个地方放一条注释描述你做了什么选择和你为什么这么做，只有考古学家才能发现这是最有用的信息。（如何归档另行规范）
    5.3. 注释结构
        工程的每部分都有特定的注释结构。 程序中的注释，这里给出示例作为规范，注释中以 * @ 为关键字的开始，以:为注释关键字结尾。
        5.3.1. 预定义关键字
            关键字        含义
            Purpose        表示类、属性、方法要做些什么或者什么含义。
            Package Name        类名
            Author        作者
            Modifications        修改记录（编号规则为“No”＋日期＋“－”＋序号）
            See        参考
            Method Name        方法名
            Parameter        参数名（包括类型）
            Return        返回值（包括类型）
            Attribute/Variable Name        属性/变量名
            Type        属性/变量类型
        5.3.2. 类的注释
            /**
            * @ Purpose:
            * 访问数据库的类，以ODBC作为通用访问接口
            * @Package Name:                Database
            * @Author:                  Forrest Gump [e-mail]
            * @Modifications:
            * No20020523-100:
            * odbc_fetch_into()参数位置第二和第三个位置调换
            *  John Johnson [e-mail]
            * @See:        (参照)
            */
            class Database
            {
            ……
            }
        5.3.3. 方法注释
            /**
            * @Purpose:
            *        执行一次查询
            * @Method Name:                Query()
            * @Parameter:         string        $queryStr         SQL查询字符串
            * @Return:                mixed        查询返回值（结果集对象）
            */
            function（$queryStr）{……}
        5.3.4.属性或变量注释
            /**
            * @Purpose:
            *        数据库连接用户名
            * @Attribute/Variable Name:        mDbUserName
            * @Type: string
            */
            var mDbUserName;
        5.3.5. if (0)来注释外部代码块
            有时需要注释大段的测试代码，最简单的方法就是使用if (0)块：
            function example()
            {
              great looking code

              if (0) {
              lots of code
              }

              more code
            }
            你不能使用/**/，因为注释内部不能包含注释，而大段的程序中可以包含注释。
        5.3.6. 目录文档
            所有的目录下都需要具有README文档，其中包括：
                该目录的功能及其包含内容
                一个对每一文件的在线说明（带有link），每一个说明通常还应该提取文件标头的一些属性名字。
                包括设置、使用说明
                指导人们如何连接相关资源：
                源文件索引
                在线文档
                纸文档
                设计文档
                其他对读者有帮助的东西
            考虑一下，当每个原有的工程人员走了，在6个月之内来的一个新人，那个孤独受惊吓的探险者通过整个工程的源代码目录树，阅读说明文件，源文件的标头说明等等做为地图，他应该有能力穿越整个工程。
6. 其他
    采用面向对象的设计方法；
        理由
            毫无疑问这是最接近人们自然思维的方法，可能前期会觉得没有直接书写来得快，能否试着保留自己的看法？好戏在后头！
    类的定义采用一个文件一个类，并且类名和文件名相同；
        理由
            越来越多的人接受了这种做法
            事实证明这种方法使得项目的逻辑结构更清晰
    类定义文件中，定义体之外不得出现诸如echo、print等输出语句；
        理由
            出现这样的语句，应该当做出现bug来看。
    输出网页的页面不出现SQL语句
        理由
            这是n层结构的编程思想所致，每层的任务不同，虽然可以越权行使，可能这样很快捷，但我们不赞成这么干。
    进行SQL执行的数据必须进行有效性检测
        特殊符号：
        对于MS SQL Server，’%_[ ] 这些符号都是在书写SQL语句中的特殊含义字符，在SQL执行前需要对这些字符进行处理。
        脚本符号：
        对于PHP脚本标记，如，在进入数据库前需要检测处理。
        理由
            这是数据库编程的一个约定，很多参考书上也是这么说，这里需要强调一下。
    在HTML网页中尽量不要穿插PHP代码
        循环代码和纯粹变量输出（类似于）除外。
        理由
            需要说明的是我们工作的上游，页面设计者的工作，假如在页面中穿插代码，将破坏结构，这应当是我们需要避免的。
            在这里的PHP代码只负责显示，多余的代码显然是不应该的。
    没有含义的数字
        一个在源代码中使用了的赤裸裸的数字是不可思议的数字，因为包括作者，在三个月内，没人它的含义。例如：
        if      (22 == $foo) { start_thermo_nuclear_war(); }
        else if (19 == $foo) { refund_lotso_money(); }
        else if (16 == $foo) { infinite_loop(); }
        else                { cry_cause_im_lost(); }
        在上例中22和19的含义是什么呢？如果一个数字改变了，或者这些数字只是简单的错误，你会怎么想？
        使用不可思议的数字是该程序员是业余运动员的重要标志，这样的程序员从来没有在团队环境中工作过，又或者是为了维持代码而不得不做的，否则他们永远不会做这样的事。
        你应该用define()来给你想表示某样东西的数值一个真正的名字，而不是采用赤裸裸的数字，例如：
        define(" RESIDENT_WENT_CRAZY", "22");
        define("WE_GOOFED", "19");
        define("THEY_DIDNT_PAY", "16");

        if      (PRESIDENT_WENT_CRAZY == $foo) { start_thermo_nuclear_war(); }
        else if (WE_GOOFED            == $foo) { refund_lotso_money(); }
        else if (THEY_DIDNT_PAY       == $foo) { infinite_loop(); }
        else                                   { happy_days_i_know_why_im_here(); }
        现在不是变得更好了么？
7. PHP文件扩展名
    常见的PHP文件的扩展名有：html, .php, .php3, .php4, .phtml, .inc, .class...
    这里我们约定：
        所有浏览者可见页面使用.html
        所有类、函数库文件使用.php
        理由
            扩展名描述的是那种数据是用户将会收到的。PHP是解释为HTML的。

8. PHP代码标记
    统一使用，只输出变量时


这么多？？？？？