[小说文学] （原创）郎朗的计算机文学[第1页]

阅读网购物网址万年历小说 | 三丰软件天天财富小游戏

TxT小说阅读器
↓小说语音阅读,小说下载↓

一键清除系统垃圾
↓轻轻一点,清除系统垃圾↓

图片批量下载器
↓批量下载图片,美女图库↓

图片自动播放器
↓图片自动播放,产品展示↓

佛经: 故事佛经佛经精华心经金刚经楞伽经南怀瑾星云法师弘一大师名人学佛佛教知识标签

名著: 古典现代外国儿童武侠传记励志诗词故事杂谈道德经讲解词句大全词句标签哲理句子

网络: 舞文弄墨恐怖推理感情生活潇湘溪苑瓶邪原创小说故事鬼故事微小说耽美师生内向易经后宫鼠猫美文

教育信息历史人文明星艺术人物音乐影视娱乐游戏动漫 | 穿越校园武侠言情玄幻经典语录三国演义西游记红楼梦水浒传

首页 -> 小说文学 -> （原创）郎朗的计算机文学 -> 正文阅读

[小说文学]（原创）郎朗的计算机文学[第1页]

作者:langlangname

首页本页[1] 下一页[2] 尾页[4] [收藏本文] 【下载本文】

（前言）大家好，又见面了，鸟之心魔郎朗是也，其实我一直没有透露我曾经2008年到2009年的时候在上海贝尔软件做过一年外派的软件工程师，拿着税后2500元的低薪在追求属于我自己的理想。其实，很多时候，写作跟计算机编程是有着共通性的，都需要坚持，都需要通过自己的努力来尝试实现自己的价值，到底PHP这一门编程语言对于我意味着些什么，其实我并不是非常想去尝试坚持，想要尝试通过echo来尝试输出自己曾经所犯过的所有错误，现实中的也好，还有虚幻的世界中的也罢，其实，很多时候，尝试忘记编程，尝试忘怀编程和写作应该必然产生的一些共通的东西，本来就是无法通过自己现实中的努力来尝试弥补的。每个人都渴望拥有一台属于自己的Web服务器来收容自己曾经所尝试过，修改过的很多网站的源代码，其实，现在网上很多开源的网站源代码，有些甚至有了代码的保护，这其实都不仅仅只是为了尝试保护版权或者是尝试想要保护自己现实中曾经努力过的编程结果，在现在的这个时代，写程序跟写作到底真正的共同点到底在哪里，其实，都是因为兴趣的驱使，同时也因为对于写作和对于编程的共通的兴趣，让整个世界的作家也好，程序员也罢，都能够通过这本书来尝试找到自己内心中真正所渴望中的那种样子。我们不仅仅只是因为尝试喜欢一门课程，计算机的也好，文学类的也罢，其实，计算机文学，看似好像有点不可能，但，这种不可能很多时候都是因为计算机和文学之间这种通过日积月累之后的堆积和积累之后，在程序员和作家的记忆深处烙印下很多看似能够忽略许久的东西。我们其实都应该通过我们自己的兴趣来找寻得到一些不一样的东西，同时，这本书就有点类似于我的计算机读书笔记一样，随时随地记录今天在计算机，在文学上的共通的收获，守候一件能够坚持许久的事，看似好像不可能，但其实，这种不可能，本来就仅仅只是因为我们都已经开始学会通过我们自己的努力来尝试改变得到这个现实中的生活。计算机给我们的现实生活带来了诸多的便利，同时也因为着计算机对于现实世界的贡献，让整个现实世界中的我们都开始学会感谢生活的同时，也不断地在感恩着我们现实中同样有点单调和乏味的计算机编程和单纯追求纯文学的那种枯燥感，也许，我们都应该通过我们自己现实中的努力来尝试找寻回我们身上那些跟计算机有关的东西，计算机编程对于作家到底意味着些什么，其实很多作家也在不断地摸索和研究中发现其实自己也可以通过文学的方式来成就一下自己能够成为编程者，作为开发人员的那种骄傲。其实，渴望一件事，曾经对计算机编程有过热情的我也许能够给大家带来点不一样的东西，同时也通过这种不一样，让我自己终于意识到，原来，意识深处，真正所渴望的那种东西，往往远远不如现实中自己对于文字，对于程序代码的那种渴望，那种渴求来得强烈。也许，我们都应该尝试说服自己相信其实我们的内心深处对于任何陌生的事物都是有着自己的考量和研究的。当然，也许，我们自己也应该学会通过书籍来更加充实地让自己充一会儿电，从复杂单调的现实的工作中发现其实热情可以很快地冲刷掉很多东西。郎朗的计算机文学相信能够伴随着大家一起成长，一起慢慢地继续成长起来，并让自己通过现实中自己的努力来不断地改善自己，完善自己的很多优缺点。同时，我们最后在反复读着书本中那些看似陌生的字眼的时候，我们也开始学会通过现实中我们自己的努力，来尝试找到这个世界中跟计算机，跟文学有关的那些东西。我们自己大脑中的数据库系统，也开始因为我们自己最刻意中的那个SELECT，最刻意中的那个DELETE，让我们终于发现，原来，很多时候，渴求一件事，对一件事有热情，一直都这样看似刻意，却也看似平凡着。计算机跟文学之间本身就能够存留有的关联，会通过我，通过电脑前的你，来尝试开启一条非常不同寻常的经历或者是冒险，大家，相信都会因为这本书而有所收获的。计算机文学，看似好像不可能，但，或许也是同样正常，同时也是同样另类的。尝试努力吸取过营养，至少必然也会有所收获，至少，在上海贝尔追求自己计算机理想的我对于我这本书的作用虽然不是很确信，但，我想，其实每个人都应该通过自己刻意坚持中的那些东西，来尝试让自己对自己更加有自信，有信心。计算机文学对于现实中的人们到底意味着些什么，其实坐在电脑前敲打这本书里面每个字句中的我其实并不是非常有确认。但，我想，或许，改变一件事的时候，也必然有尝试努力尝试做到一件事的时候，所必然经历过的那些平凡和那些烦恼。郎朗的计算机文学，伴随着复旦计算机信息管理自考本科这一件值得坚持许久的事，让我和你们都开始觉得，原来，我们也可以同样对于计算机和对于文学这么有热情，同时也这么敢于和勇于去这么坚持，去这么坚守下去。一直一直，直到我们彻底老去的时候，我们才终于发现，原来计算机，原来文学，看似好像很枯燥，但，却也一直这样在我们所认为的现实中变得更加有意义，更加有价值起来。这样以来，这本书的真正价值，就出现了，而且不会轻易消失在我们自己的记忆深处里，永永，伴随着远远。

    第一章（PHP）
    PHP这门编程语言最开始的时候起源于1995年，一个名叫Rasmus Lerdorf的程序员开发了一个用Perl/CGI脚本编写的在线简历，这个脚本的作用是用来将访问这个在线简历的人员的信息写入日志（通过日志可以查看很多计算机当中的信息。）同时还能够显示这个网页访问者的数量（也就是提示你有多少人亲睐你的这一份在线简历。）。PHP(Personal Home Page个人主页)就是这样起源的，1997年11月发行了PHP 2.0，PHP其实从3.0版本开始全称正式改为PHP:超文本预处理器（PHP:Hypertext Preprocessor），PHP本来就可以用记事本这个程序来写，来阅读。没想到到发行3.0版本为止，已经有超过5万个用户在使用PHP改进其网页。其实，PHP不仅仅只是用来处理网页，在网站的开发过程中，使用PHP这一门语言的优势一直都很明显，而且，从未轻易改变和放弃过。到1999年初，两位核心开发人员（Zeev Suraski和Andi Gutmans）最终改写了PHP的解析器（也就是将PHP的代码解析为PHP网页），也就是所谓的Zend脚本引擎，这些工作最终导致了PHP4的发布。Zend是关于开发，部署和管理PHP应用的产品和服务的主要提供商。

    PHP4添加了以下几项对该语言，对企业级应用来说的改进工作。
    1：改进了资源处理，开始有很多企业尝试用PHP开发企业级网站。
    2：面向对象的支持。其实所谓的对象，也就是现实世界中的所有东西。
    3：内置的会话处理支持，这个特性使得开发人员可以相当高效率地跟踪用户活动和偏好。其实会话就相当于一次谈话，通过这次谈话，能够实现用户你愿意尝试做到的很多件事。
    4：加密。亲密的人们之间都有着特定的语言来沟通，其他人是无法了解的。
    5：ISAPI支持。能够将PHP与微软的IIS Web服务器结合使用。
    6：内置COM/DCOM支持。其实这项功能也就是扩展了PHP与Windows应用程序的互操作性。
    7：内置Java支持。PHP的应用程序能够绑定Java对象。
    8：与Perl兼容的正则表达式（PCRE）库。

    版本5是PHP语言发展历程中的另一座分水岭。
    1．极大地提高了面向对象能力。
    2． try/catch异常处理。（try尝试/catch捕获）
    3．改进的XML和Web服务支持。
    4．对SQLite的内置支持。
    PHP6的关键特性。
    1. Unicode支持。（为了构建和维护多种语言的应用程序。）
    2. 安全改进。
    3. 新语言特性和构造。
    全部的Apache安装中有40%都安装有PHP。说明PHP确实够流行，够疯狂。

    1.September 23.2007的格式输出当前日期：
    <?php echo date(“F j,Y”);?>
    F代表月份，j代表日期，Y代表年份。

    2.生成一个由5个字母或数字字符组成的字符串，如a3jh8:
    $randomString=substr(md5(microtime(),0,5);
    substr取字符串函数，md5加密函数。microtime(),返回当前时间的微秒数。

    3<?php
    $number=”5”; //$number是一个字符串。
    $sum=15+$number;//添加一个整型和字符串用于生产出一个整型。
    $sum=”twenty”; /将$sum覆盖为一个字符串。
    ?>

    PHP还会在脚本结束时自动撤销变量，将资源返回给系统。（就相当于借钱是一样的道理，有借有还，再借不难。）
    PHP为25种以上的数据库产品提供了内置支持。
    因为PHP开源软件（源代码可以供所有人共享，修改的软件）的出现，它和因特网就像面包和黄油一样密不可分。
    PHP的优点之一是可以把PHP代码直接嵌入到HTML页面中。

Welcome

h3是html中标题的意思。
<?php <?php ?> 是PHP代码的开始和结束符。
echo “

Some dynamic output here

”;

是html中段落的意思。
?> echo打印输出的意思。

Some static output here

    PHP还可以使用更短的界定（php语句跟html分离时候的标识。也就是你html显示你的，我php实现我的功能。）语法，也就是<? ?>，但是，要使用这个特性，需要启用PHP的short_open_tag指令。

    PHP还支持另一种主流的界定形式，也就是类似于javascript这种显示风格的样子，
    <script language=”php”> 先声明这个脚本使用的是php语言
    print “This is another PHP example.”; print打印输出
    </script>

    Microsoft ASP以<%开头，以%>结束。PHP也同样支持这种显示的方式。
    <%
    print “This is another PHP example.”;
    %>

    但是从PHP6开始ASP风格的语法就被删去了。就像过气的明星被雪藏是一样的道理。
    <html> html的开头标记
    <head> 在<head></head>之内的，是head信息，head信息在浏览器浏览页面的时候是看不到的。
    <title> html标题
    <?php echo “Welcome to my Website”;?> </title>

    </head>
    <body> html文档主体
    <?php
    $date=”July 26,2007”; 声明一个变量$date
    ?>

Today’s date is<?=$date;?>

在<?= ?>中使用这个变量$date
    </body>
    </html>

    当然，写PHP代码时，要为代码添加充分的注释。其实是为了方便以后的继续使用，继续修改。

    PHP支持C++的单行注释语法，以双斜线（//）开头。
    <?php
    //Title: My first PHP script
    //Author: Jason
    echo “This is a PHP program”;
    ?>
    PHP还支持另一种C++风格的单行语法，称为shell语法，它以#符号开头。
    <?php
    #Title: My PHP program
    #Author: Jason
    echo “This is a PHP program”;
    ?>

    phpDocumentor是一个促进文档处理的开源项目。它将嵌在源代码中的注释转换为各种易读的格式。包括HTML和PDF。

    PHP还支持一种多行形式的注释，同时标注注释的开始和结束。
    <?php
    /*
    Title:My PHP Program
    Author:Jason
    Date: July 26,2007
    */
    ?>

    print()语句把传入它的数据输出到浏览器，就像人们通过打印机输出文字是一样的道理，其形式为：
    int print(argument) int返回的类型是整数型，argument是传入的参数。
    <?php
    print(“

I love the summertime.

”);
    ?>
    <?php
    $season=”summertime”;
    print “

I love the $season.

”;
    ?>
    <?php
    print “

I love the summertime.

”;
    ?>
    以上这些语句都能够生成同样的输出如下，其实这三条语句本来就是差不多的，实现了一样的功能。
    I love the summertime.

    echo（）能够输出多个字符串。
    <?php
    $heavyweight=”Lennox Lewis”;
    $lightweight=”Floyd Mayweather”;
    echo $heavyweight, “and”,$lightweight,”are great fighters.”;
    ?>
    这个代码会生成以下输出：
    Lennox Lewis and Floyd Mayweather are great fighters.
    其实也就是通过echo语句将这几个变量中的字符串都合在一起打印输出了而已。

    echo()和print()相比，echo()函数稍稍快一点，因为echo()函数什么都不返回，而print()不同，如果这个语句成功地输出，它会返回1。

    printf()语句将静态数据和动态数据清晰地分至两个不同的部分，从而可以轻松地维护。
    boolean printf(string format [,mixed args]) format是字符串类型的，args是混合类型的。
    printf(“Bar inventory: %d bottles of tonic water.”,100);
    执行这个命令会生成以下输出：
    Bar inventory: 100 bottles of tonic water. (使用了printf函数后，%d其实被100给替换掉了。)

    当然，printf()语句也可以同时传入两个值，就比如整数值和浮点数值，
    printf(“%d bottles of tonic water cost $%f”, 100 , 43.20);
    执行这个命令会生成以下输出：
    100 bottles of tonic water cost $43.20 (%d被100给替换， %f被43.20替换)
    处理小数值时，可以使用一个精度指示符调整精度，例如，
    printf(“$%.2f”,43.2); // 显示为43.20
    sprintf()函数的功能与printf()相同，但它将输出指派到字符串，而不是直接指派到浏览器，其形式如下，
    string sprintf(string format[,mixed arguments])
    $cost=sprintf(“$%.2f”,43.2); // $cost=$43.20 变量$cost最后指向到$43.20。

    PHP中常见的数据类型包括布尔型，整型，浮点型，字符串型和数组，还有对象。
    标量(scalar)数据类型的变量能够保存单项信息，以下都属于标量数据类型，布尔型，整型，浮点型和字符串型。
    布尔变量（两种可能，要么是真实的，要么就是虚假的。）表示真实性，只支持两个值，TRUE(真)或FALSE(假)，不区分大小写。另一方面，也可以使用0来表示FALSE,非0值表示TRUE。
    $alive=false; //$alive is false.
    $alive=1; // $alive is true.
    $alive=-1; // $alive is true.
    $alive=5; // $alive is true.
    $alive=0; // $alive is false.
    PHP支持以十进制数（基数为10），八进制数（基数为8）和十六进制数（基数为16）表示的整数值。
    42 //decimal十进制
    -678900 //decimal十进制
    0755 //octal 八进制
    0XC4E //hexadecimal 十六进制

    浮点数，也称为双精度数（double）或实数(real number)，可以指定包含小数部分的数，浮点数用于表示货币值，重量，距离，以及用简单的整数无法满足要求的其他表示。

    字符串是一个连续的字符序列。这样的组通常用单引号或双引号来界定。

    下面是一些有效的字符串例子：
    “PHP is a great language”
    “whoop-de-do”
    ‘*9subway\n’ （之所以用单引号就是代表按照原来的样子进行输出）
    “123$%^789”
    当然，也可以将字符串当作数组来访问和显示某个字符。
    $color=”maroon”;
    $parser=$color[2]; // 将$color中的第三个字符r赋值给$parser

    复合数据类型可以用于将多个相同类型的项聚集起来，表示为一个实体。这包括数组(array)和对象(object)。

    Array正式的定义是有索引的数据值集合。每个数组索引（也成为键（key））引用一个对应的值。索引其实就是一个简单的数，指示某个值在系列中的位置，也可以与值有某种直接关联。

    例如，如果要创建美国各州的列表，可以使用数字索引的数组，如下：
    $state[0]=”Alabama”;
    $state[1]=”Alaska”;
    $state[2]=”Arizona”;
    ...
    $state[49]=”Wyoming”;

    如果项目要求将美国各州与其州府相关联，这个时候使用关联索引。
    $state[“Alabama”]=”Montomery”;
    $state[“Alaska”]=”Juneau”;
    $state[“Arizona”]=”Phoenix”;
    ...
    $state[“Wyoming”]=”Cheyenne”;

    在PHP中，对象这种数据类型必须显式地进行声明。（就像性格直接的人与人之间的交流是一样的，性格直接的人喜欢直来直去地说话。）
    Class Appliance { 声明一个Appliance类
    private $_power; 声明一个私有成员$_power
    function setPower($status) { 声明一个setPower函数，传入$status参数
    $this->_power=$status; $this指针将私有成员$_power指向变量$status
    }
    }
    $blender=new Appliance; //声明$blender为Appliance类的新的对象。
    可以使用方法setPower()来设置blender对象的power属性。
    $blender->setPower(“on”);

    PHP中的类型强制转换也就是将一个变量强制转换为与原来类型不同的另一种类型。（强扭的瓜不甜，但是在PHP的类型转换中，强扭的瓜还是甜的，可以这样来理解。）
    例子，将一个整数转换为双精度数。
    $score=(double)13; //这样一来$score就等于13.0
    将一个双精度数强制转换为整数。
    $score=(int)14.8 //$score=14
    将一个字符串数据类型转换为一个整数。
    $sentence=”This is a sentence”;
    echo (int)$sentence; // 返回0
    当将一个数据类型强制转换为数组中的一个成员时，所转换的值将成为数组中的第一个成员。（当品质极好的我强迫你跟我谈朋友的时候，你很快就会发现你是我的第一个女朋友。）
    $score=1114;
    $scoreboard=(array)$score;
    echo $scoreboard[0]; //$scoreboard[0]输出的是数组scoreboard中的第一个成员，结果输出为1114
    任何数据类型都可以转换为对象，结果是，该变量成为了对象的一个属性。该属性名为scalar:
    $model=”Toyota”;
    $obj=(object)$model;
    然后可以如下引用这个值：
    print $obj->scalar; //返回”Toyota”
    当然，PHP有时候会将变量自动转换为最适合的类型。
    <?php
    $total=5; //一个整型
    $count=”15”; //一个字符串
    $total +=$count; //$total=20(这个时候$total就自动转换为整型了。$total+=$count相当于$total=$total+$count;

    <?php
    $total=”45 fire engines”;
    $incoming=10;
    $total=$incoming +$total;
    ?>
    //$total最后就忽略了原来内容中的fire engines字符串，最后45加10等于55，$total最后的值就等于55了。(忽略了次要，最后收获了重要。)

    <?php
    $total=”1.0”;
    If($total) echo “We’re in positive territory!”;
    ?>
    在这个例子中，$total中的内容自动转换为布尔类型。

    <?php
    $val1=”1.2e3”; //1.2e3其实就是1200
    $val2=2;
    echo $val1*$val2; //输出2400
    ?>

    gettype()函数返回var所指定变量的类型。共有八个可能的返回值：array(数组型)，boolean(布尔型),double(双精度型)，integer(整型),object(对象型)，resource(资源型),string(字符串型)和unknow type（未知类型）。函数的形式为:

    string gettype(mixed var) gettype函数的返回值是字符串型，参数mixed var表示var变量可以是各种类型。

    settype()函数将var指定的变量转换为type指定的类型。Type有7个可取值:array(数组型)，boolean（布尔型）,float(浮点型),integer(整型),null(空类型),object(对象型)和string(字符串型)。如果转换成功，则返回TRUE,如果失败，则返回FALSE。函数的形式为:

    boolean settype(mixed var, string type) settype函数的返回值是boolean布尔型，参数mixed var表示var变量可以是各种类型，string type是字符串型。

    当然，也可以用很多函数来确定变量的类型，包括is_array()是否是数组，is_bool()是否是布尔型，is_float()是否是浮点型，is_integer()是否是整型,is_null()是否是空类型，is_numeric()是否是数字或数字字符串,is_object()是否是对象型,is_resource()是否是资源类型，is_scalar()是否是标量类型和is_string()是否是字符串类型。以上函数判断正确返回TRUE,判断错误返回FALSE。然后将它们合并为一个一般形式。
    boolean is_name(mixed var)

    举一个例子:
    <?php
    $item=43;
    printf(“The variable \$item is of type array: %d <br/>”, is_array($item));//判断$item是否是数组型。其中的\是转义字符，\$item最后显示的时候是$item。

    printf(“The variable \$item is of type integer:%d <br/>”, is_integer($item));
    //判断$item是否是整型。

    printf(“The variable \$item is numeric:%d <br/>”, is_numeric($item));
    //判断$item是否是数值型。
    ?>

    以上三行代码返回如下内容,其中0代表错误，1代表正确：
    The variable $item is of type array:0
    The variable $item is of type integer:1
    The variable $item is numeric:1

    PHP中的标识符，可以由一个或多个字符组成，必须以字母或下划线开头。此外，标识符只能由字母，数字，下划线字符和从127到255的其他ASCII字符组成。标识符区分大小写，因此，变量$langlang不同于变量$Langlang。标识符可以是任意长度。同时，标识符不能与任何PHP预定义关键字（PHP中已经定义好的关键字，就比如const）相同。
    比如This&that就是非法的标识符，因为this和that都是PHP中的预定义关键字。

    变量是可以在不同时刻存储不同值的符号。变量总是以美元符$开头，然后是变量名。（我是不是可以理解为PHP其实很受那些财迷欢迎，都是美元嘛，这么多钱，哈哈。）变量名可以以字母或下划线开头，要由字母，下划线，数字或从127到255的其他ASCII字符组成。当然，变量也是区分大小写的。当然，所有的变量都应该在使用前进行声明，最好带有注释。（写代码的时候注释其实非常重要，方便以后的阅读和修改。）变量赋值有两种方法，值赋值和引用赋值。

    值赋值
    按值赋值就是将赋值表达式的值复制到变量。比如，
    $color=”red”;
    $number=12;
    $age=12;
    $sum=12+”15”; //$sum等于27
    对于引用赋值而言，如果多个变量引用了同一个内容，修改其中任意一个变量，在其余的变量上都将有所反映。（你只要改变了我，你其实就已经相当于改变了跟我有关的很多人。）在等于号后面加一个&符号就可以完成引用赋值。

    <?php
    $value1=”Hello”;
    $value2=& $value1; //$value1和$value2都等于”Hello”
    $value2=”Goodbye”; //$value1和$value2都等于”Goodbye”
    ?>
    PHP还支持另一种引用赋值语法，就是将&符号放在所引用变量的前面。
    <?php
    $value1=”Hello”;
    $value2= &value1; //$value1和$value2都等于”Hello”
    $value2=”Goodbye”; //$value1和$value2都等于”Goodbye”
    ?>其中注意了，$value2=& $value1;跟$value2= &value1;是不一样的。一个是等于号后面加上&，一个是变量前面加上了&。

    在PHP脚本的任何位置都可以声明变量。（你想什么时候使用我这个变量朋友都可以的哦。因为我的性格很好。）变量可以访问的范围称为作用域scope。
    PHP变量有4种作用域：
    局部变量
    函数参数
    全局变量
    静态变量

    在函数中声明的变量称为是局部变量。其实也就是它只能够在函数中引用。（离开了函数，它就活不下去了。就像鱼脱离了水就会死是一样的道理。）
    $x=4; //这里的$x其实就是一个全局变量
    function assignx(){ //声明了一个assignx函数
    $x=0; //这里的$x就是一个局部变量了，离开了这个函数，它其实就活不下去了。
    printf(“\$x inside function is %d <br/>”,$x);
    }
    assignx(); 使用这个函数assignx()。
    printf(“\$x outside of function is %d <br/>”,$x);
    代码的执行结果为：
    $x在函数内部为0
    $x在函数外部为4，其实这个例子中外面的那个$x其实就等同于是全局变量了。

    function x10($value){
    $value=$value*10;
    return $value;
    }
    在声明参数的函数内部可以访问和处理这些函数参数，但当函数执行结束时，参数就会撤销。
    与局部变量相反，全局变量可以在程序的任何地方访问。只要在变量前面加上关键字GLOBAL，这样就可以将其识别为全局变量。（你在哪里都可以召唤我这个全部变量朋友哦。）
    $somevar=15; 这里$somevar是局部变量
    function addit(){
    GLOBAL $somevar; 将$somevar重新声明为全局变量
    $somevar++; $somevar自己增加1
    echo “Somevar is $somevar”; 然后打印出来
    }
    addit(); 调用addit这个函数
    $somevar最后显示的值是16.但是如果省略下面这行代码：
    GLOBAL $somevar; 变量$somevar将赋值为1.因为$somevar在addit()函数中被认为是一个局部变量。

    当然，也可以使用$GLOBALS数组将变量$somevar声明为全局变量。
    $somevar=15;
    function addit(){
    $GLOBALS[“somevar”]++; 将somevar通过$GLOBALS数组声明为是全局变量。
    }
    addit();
    echo “Somevar is “.$GLOBALS[“somevar”];
    somevar的返回值就是16了。

    静态变量在函数退出时不会丢失值，并且再次调用此函数时还能够保留这个值。（只要你对我这个静态变量朋友好，我就会一直记得你的好。而且会一直保留下去。）在变量名前面加上关键字STATIC就可以声明一个静态变量。

    function keep_track(){
    STATIC $count=0;
    $count++;
    echo $count;
    echo “<br/>”;
    }
    keep_track();
    keep_track();
    keep_track();
    因为$count是静态的，它会在每次执行函数时都会保留前面的值。所以输出如下:
    1
    2
    3

    foreach($_SERVER as $var=> $value){ //foreach是一个循环语句，foreach将$_SERVER PHP预定义变量中的所有值都遍历出来。（遍历，其实跟认真读书是一样的道理，要认真地每一页都阅读一遍。在这里是将$_SERVER中的每一个变量都访问一遍。）出来。$_SERVER超级全局变量包含由Web服务器创建的信息，它提供了服务器和客户配置及当前请求环境的有关信息。
    echo “$var=> $value <br/>”;
    }
    显示用户的IP地址：
    printf(“Your IP address:%s”,$_SERVER[‘REMOTE_ADDR’]);
    这会返回一个数字型的IP地址，如192.0.34.166。
    获得关于用户浏览器和操作系统的信息。
    printf(“Your browser is:%s”,$_SERVER[‘HTTP_USER_AGENT’]);
    要使用预定义变量数组，必须在php.int文件中启用配置参数track_vars。
    $_SERVER[‘HTTP_REFERER’]。引导用户到达当前位置的页面的URL。
    $_SERVER[‘REMOTE_ADDR’]。客户IP地址。
    $_SERVER[‘REQUEST_URI’]。URL的路径部分。也就是如果URL是http://www.example.com/langlang/lang/index.html，那么URI就是langlang/lang/index.html。
    $_SERVER[‘HTTP_USER_AGENT’],客户的用户代理，一般会提供操作系统和浏览器的有关信息。

    $_GET超级全局变量包含使用GET方法传递的参数的有关信息。如果请求URL http://www.example.com/index.html?cat=langlang&id=188,就可以使用$_GET超级全局变量访问如下变量:
    $_GET[‘cat’]=”langlang”
    $_GET[‘id’]=”188” 其实就是对应了URL地址中的cat=langlang和id=188。

    $_POST超级全局变量包含用POST方法传递的参数的有关信息。

    <form action=”subscribe.php” method=”post”> 将表单提交到subscribe.php页面，提交服务器的http方法是通过post表单的提交方式。post适用于大量数据的提交。

是HTML中的段落标签。
    Email address：<br/> <br/>换行。
    <input type=”text” name=”email” size=”20” maxlength=”50” value=””/>
    text会产生一个文本框，文本框名称name是email，大小size为20，最大长度maxlength为50，value初始化值为空。

    Password:<br/>
    <input type=”password” name=”pswd” size=”20” maxlength=”15” value=””/>
    password会产生一个密码文本框。密码文本框名称name为pswd，大小size为20，最大长度maxlength为15，初始化值value为空。

    <input type=”submit” name=”subscribe” value=”subscribe!”/>
    产生一个submit提交按钮，提交按钮名称为subscribe,提交按钮的显示值为subscribe!。

    </form>
    通过目标脚本subscribe.php,就可以使用下面的POST变量：
    $_POST[‘email’]=”jason@example.com”;
    $_POST[‘pswd’]=”rainyday”;
    $_POST[‘subscribe’]=”subscribe!”; 其中email,pswd,subscribe就是刚才那个脚本中name所指向的值。（你最开始在PHP脚本中给定了我最开始的name名称，所以，我很感谢你，你能够在$_POST中用到我。）

刚才新更新的教程里其实有p这个段落标签，在天涯论坛里直接就显示出来了，大家所以感觉看上去非常奇怪吧。

    $COOKIE（COOKIE就是为了让网站辨别出你的身份，以加密的方式，暂时或永久地存储在你本地电脑上的那些文件。通过这些文本文件中的文件名，就可以看到哪个Web站点喜欢上了你，然后在你的电脑上放置了COOKIE这种小甜饼供你这位超级大用户来享用。）超级全局变量存储了通过HTTP cookie传递到脚本的信息。当使用setcookie()存储了一个名为langlang.com，值为langlang的cookie。以后可以通过调用$_COOKIE[“langlang.com”]来获得这个值。

    $FILES超级全局变量包含通过POST方法向服务器上传的数据的有关信息。
    $FILES[‘upload-name’][‘name’]。从客户端向服务器上传文件的文件名。
    $FILES[‘upload-name’][‘type’]。上传文件的MIME类型（MIME多用途互联网邮件扩展类型，也就是设定电脑里的某一个扩展名的文件，当访问的时候，浏览器会自动使用指定的应用程序来打开。指定的MIME类型，可以是applilcation应用，audio声音，image图片，text文本，video视频等等。总之MIME类型就像一个多面手一样，在默默地帮助你通过浏览器打开你电脑中的每一个文件。）。这个变量是否赋值取决于浏览器的功能。

    $FILES[‘upload-name’][‘size’]。上传文件的大小（以字节为单位）。
    $FILES[‘upload-name’][‘tmp_name’],上传之后，将此文件移到最终位置之前赋予的临时名。
    $FILES[‘upload-name’][‘error’]。上传状态码，尽管这个变量名为error，但实际上在成功的情况下也会填写这个变量。它有5个可能的值。

    UPLOAD_ERR_OK。文件成功上传。
    UPLOAD_ERR_INI_SIZE. 文件大小超出了upload_max_filesize指令所指定的最大值。
    UPLOAD_ERR_FORM_SIZE.文件大小超出了MAX_FILE_SIZE隐藏表单域参数（可选）指定的最大值。
    UPLOAD_ERR_PARTIAL.文件只上传了一部分。
    UPLOAD_ERR_NO_FILE.上传表单中没有指定文件。

    $ENV超级全局变量提供PHP解析器所在服务器环境的有关信息。
    $_ENV[‘HOSTNAME’]。服务器主机名。
    $_ENV[‘SHELL’]。系统shell。
    $_SESSION超级全局变量包含与所有会话变量有关的信息。

    大家其实应该知道，PHP声明变量时，前面都加上$符号，其实，可以在例如$langlang前面再加一个$符号，这样就成为了PHP中变量的变量。
    $langlang=”abc”;
    $$langlang=”&langlang”;
    其作用是把&langlang赋值给名为abc的变量。
    因此，下面两行代码将得到相同的结果：
    echo $langlang $abc;
    echo $langlang ${$langlang};
    两个结果都是输出字符串abc &langlang。

    PHP中的常量是指在程序执行中无法修改的值。（你完全无法改变我，就是因为我足够坚定。因为，我就是你并不真正熟悉的那个常量。）常量使用define（）函数定义。
    boolean define(string name,mixed value[,bool case_insensitive]) 参数name常量名的返回值是字符串类型，常量值或者表达式value的返回值是混合类型（常量只能够包含标量数据，也就是boolean,integer,float和string），case_insensitive这个可选参数值如果为TRUE,那么后面对此常量的引用将不区分大小写。

    define(“PI”, 3.141592);
    下面的代码使用了这个常量：
    printf(“The value of pi is %f”,PI); 这里的%f表示浮点数。
    $pi2=2*PI;
    printf(“Pi doubled equals %f”,$pi2);
    此代码生成如下结果：
    The value of pi is 3.141592.
    Pi doubled equals 6.283184.
    常量是全局的，可以在脚本的任何位置引用。（你在任何位置都可以召唤我这个常量朋友。）
    表达式是一个短语，它表示程序中的某个特定动作。所有表达式至少由一个操作数和一个或多个操作符组成。
    $a=5; //将整型值5赋值给变量$a
    $a=”5” //将字符串5赋值给变量$a
    $sum=50+$some_int; //将50和$some_int的和赋值给$som
    $wine=”langlang”; //将“langlang”赋值给变量$wine
    $inventory++; //将变量$inventory自增1
    操作数是表达式的输入。
    $a++;// $a就是操作数。
    $sum=$val1+$val2;//$sum,$val1和$val2都是操作数。

    操作符是表达式中指定某个动作的符号。(在运动中的某一个瞬间，这个瞬间可以用操作符来记录下来。)
    操作符优先级是操作符的一个特性。
    $total_cost=$cost+$cost*0.06;这里先计算$cost*0.06，再加上$cost.
    可以等价地写为:
    $total_cost=$cost+($cost*0.06);
    $value=3*4*5*7*2;
    这个例子与下例相同:
    $value=((((3*4)*5)*7)*2);
    乘法（*）操作符的结合性是从左至右的。
    $c=5;
    print $value=$a=$b=$c;
    上面的示例与下例相同：
    $c=5;
    $value=($a=($b=$c));
    计算这个表达式时，变量$value,$a,$b,$c都将包含值5，因为赋值操作符（=）的结合性是从右至左的。

    算数操作符中的$a%$b就是$a除以$b的余数。

    $a=”abc”.”def”; $a通过拼接赋值为”abcdef”。
    $a.=”ghijkl”; $a等于它的当前值与”ghijkl”的拼接结果。
    //$a包含字符串值“Spaghetti &Meatballs”;
    $a=”Spaghetti” . ”&Meatballs”;
    $a.=”are delicious.”;
    //这个时候的变量a通过拼接赋值操作符.=的拼接之后，值变为”Spaghtti &Meatballs
    are delicious.”（什么时候都可以使用拼接操作符，拼接可以创造出很多不一样，有个性的东西。）

    自增（++）和自减操作符（--）可以将当前变量的值增1或者减1。（你可以减去我一个朋友，你也可以帮助我增加一个朋友哦。因为，我看似朋友很少，但其实，还可以。）
    $inv=15; //将整型值15赋值给$inv
    $oldInv=$inv--; //先将$oldInv中的值赋值给$inv,然后将$inv自减。
    $origInv=++$inv; //先将$inv自增，然后将$inv中的新值赋值给$origInv.
    将操作数放在操作符前面称为前自增和前自减运算。而放在后面称为后自增和后自减运算。（自增和自减操作符使用的顺序对变量的值有重大影响。操作符放的顺序不同，就像排在队伍的不同位置是一样的道理，对于数值的改变有重大影响。）

    逻辑操作符常用于控制结构中，如if条件和while及for循环。
    $a&&$b 与如果$a,$b都为true，则输出true
    $a AND $b 与如果$a,$b都为true,则输出true
    $a || $b 或如果$a或$b为true，则输出true
    $a OR $b 或如果$a或$b为true，则输出true
    !$a 非如果$a不为true，则输出true
    NOT $a 非如果$a不为true,则输出true
    $a XOR $b 异或如果只有$a或$b为true,则输出true

    file_exist(“filename.txt”) OR echo “File does not exist!”;
    会有两种输出：
    通过file_exist函数判断文件filename.txt是否存在。
    如果判断出文件不存在，则输出句子”File does not exist!”;

    相等操作符，用来比较两个值。测试其相等性。
    $a==$b 是否相等如果$a和$b相等，则输出true
    $a != $b 是否不相等如果$a和$b不相等，则输出true
    $a ===$b 是否相同（恒等符号，判断变量内容和类型是否相等。）如果$a和$b相等，并且类型也相同，则输出true

    比较操作符与逻辑操作符相似，通过比较两个或多个变量值的结果，提供了一种控制程序流程的方法。

    $a<$b 小于如果$a小于$b，则输出true
    $a>$b 大于如果$a大于$b,则输出true
    $a<=$b 小于或等于如果$a小于或等于$b，则输出true
    $a>=$b 大于或等于如果$a大于或等于$b,则输出true
    ($a==12)?5:-1 三元运算如果$a等于12，返回值为5，否则返回值为-1
    当前，比较操作符只能够用来比较数值。（通过以上的这些操作符，再结合之前的代码和教程，其实就已经能够写出还算是可以的小程序了。PHP好像看似很难，但，其实PHP跟写作好像有着非常大的关联或者是联系，如果感兴趣的话，一直坚持下去，也一直跟我共同学习下去吧。）

不知不觉《郎朗的计算机文学》前言加正文一万突破了，其实对于我，对于阅读的大家而言都会有所收获，其实，编程语言并不难，难就难在是否能够继续坚持学习下去。看似枯燥，其实，很有意义。大家说是吧。

    以下是一些PHP中位操作符的例子。
    $a & $b 与 $a和$b包含的每一位相与
    $a | $b 或 $a和$b包含的每一位相或
    $a ^$b 异或 $a或$b包含的每一位相异或
    ~$b 非 $a中的每一位取反
    $a<<$b 左移 $a将接收到$b左移两位的值
    $a>>$b 右移 $a将接收到$b右移两位的值

    用双引号括起的字符串在PHP脚本中最为常见，因为它们提供了最大的灵活性，其原因是变量和转义序列都会得到相应的解析。（你用双引号强调了我，我就成为了你最为亲睐的字符串挚友。）

    <?php
    $sport=”boxing”; 变量$sport定义为boxing字符串。
    echo “Jason’s favorite sport is $sport.”; 然后通过echo语句输出这一段话。变量$sport中的内容也在获得了之后输出。
    ?>
    这个例子会返回:
    Jason’s favorite sport is boxing.
    <?php
    $output=”This is one line.\n And this is another line.”;变量$output中的字符串内容会输出，换行符\n都会解析为换行符号。
    echo output;
    ?>
    它将在浏览器源代码中返回如下内容：
    This is one line.
    And this is another line.

    PHP中可识别的转义序列
    \n 换行符
    \r 回车
    \t 水平制表符
    \\ 反斜杠
    \$ 美元符
    \” 双引号
    \[0-7][1,3] 八进制记法
    \x[0-9A-Fa-f][1,2] 十六进制记法

    用单引号的时候，字符串就按照声明的形式原样解释。这表示，解析字符串时，变量和转义序列都不会进行解析。（你用单引号来定义我这个朋友的时候，我就变成了一个非常直接的朋友，不需要拐弯抹角。）

    例如
    print ‘This string will $print exactly as it \’s \n declared.’;
    这会生成
    This string will $print exactly as it’s \n declared.(你会很惊喜地发现print语句中单引号中的内容除了\’转义为了’，其他都没有进行解析，而是原样显示。)

    print ‘This is another string.\\’;
    这会生成:
    This is another string.\ print语句中的\\被解析成了\

    heredoc语法为输出大量文本提供了一种便利的方式。
    <?php
    $website=”http://www.romatermini.it”;
    echo <<<EXCERPT

Langlang is a very good and old boy.

    EXCERPT;
    ?>
    这个语句中，开始和结束标识符必须相同。这个例子中的开始和结束标识符为EXCERPT。
    当然你也可以用LANGLANG作为你喜欢的开始和结束操作符也可以。当然，限制也是有的，该标识符必须完全由字母数字字符和下划线组成，而且不能以数字或者下划线开头。就比如1ABC和_ABC不能够作为开始和结束标识符。
    开始标识符前面必须有三个左尖括号：<<<
    结束标识符必须在一行开始处，而且前面不能有空格或任何其他多余的字符。

    条件语句使程序可以根据各种输入做出响应，基于输入值使用逻辑来辨别各种不同的条件。
    If条件是所有主流编程语言中最常见的结构。（if如果你想改变我，那请通过if语句来改变我身边最熟悉也最陌生的你自己。）

    if(expression){
    statement
    }
    <?php
    $secretNumber=453; 定义变量$secretNumber为整型453；
    If($_POST[‘guess’])==$secretNumber){ 通过$_POST中传过来的guess判断是否与$secretNumber相等
    echo “

Congratulations!

”; 然后通过echo语句打印输出Congratulations!
    }
    ?>
    条件体只包含一条语句时，如果你很懒，可以不使用大括号。
    <?php
    $secretNumber=453;
    If($_POST[‘guest’]==$secretNumber) echo”

Congratulations!

”; 这里就直接使用echo语句了，echo之前也就没有使用大括号，在同一行写入代码了。是可以的。
    ?>

    <?php
    $secretNumber=453;
    If($_POST[‘guess’]==$secretNumber){
    echo “

Congratulations!!

”;
} else{
echo “

Sorry!

”; if以上判断中的语句如果为假，则执行else语句后面的echo打印。
    if你不认同我，else我或许也不会认同你。其实if跟else是相互衔接的，互有关联的。
    }
    ?>

    <?php
    $secretNumber=453;
    $_POST[‘guess’]=442;
    if($_POST[‘guess’]==$secretNumber){
    echo ‘

Congratulations!

”;
}elseif(abs($_POST[‘guest’])-$secretNumber)<10){ abs函数返回一个数的绝对值。判断$_POST[‘guest’]减去变量$secretNumber的数值的绝对值是否小于10。如果小于10，则执行echo语句，否则执行随后的else语句。
echo “

You’re getting close!

”;
}else{
echo “

Sorry!

”;
    }
    ?>

    <?php
    switch($category){
    case “news”: case”news”就是switch语句中的一条分支。
    echo “

What’s happening around the world

”;
    break;
    case “weather”: case”weather”也是switch语句中的一条分支。如果switch中的变量$category的内容为weather的时候，就执行case”weather”中的语句。
    echo “

Your weekly forecast

”;
    break;
    case “sports”:
    echo “

Latest sports highlights

”;
    break;
    default:如果switch中的$category跟case中的内容都不一样的时候，则执行default中的语句。
    echo “

Welcome to my Website

”;
    }
    ?>
    注意，以上每个case块的末尾处的break语句就意味着这个case块已经执行结束了。

今天更新的教程代码中有很多

，所以显示有点异常，大家注意一下。但是应该不影响阅读。

有很多p段落标签。

    while语句指定了一个条件，在其嵌入代码结束执行前，必须满足这个条件。其语法是：
    while(expression){
    statements
    }
    <?php
    $count=1;
    while($count<5){ 判断当$count的数值等于5时,while循环的判断就结束了。
    printf(“%d square=%d <br/>”,$count,pow($count,2)); pow($count,2)是求$count的平方。
    $count++;
    }
    ?>

    <?php
    $linecount=1; 定义变量$linecount为1
    $fh=fopen(“sports.txt”,”r”); 以只读方式打开sports.txt
    while(!feof($fh) &&$linecount<=5){ 通过while判断$fh还没有到达文件末尾feof或者变量$linecount小于等于5
    $line=fgets($fh,4096); fgets()函数会在到达指定长度，这里为4096-1字节，碰到换行符，
    读到文件末尾(eof)时，停止并返回一个新行，这里是最后赋值给$line。
    echo $line.”<br/>”;
    $linecount++;
    }
    ?>

    do...while循环条件是while的一种变体，它在代码块的结束处验证循环条件，而不是在开始处。其语法为:

    do{
    statements
    }while(expression);

    do...while语句中的代码块总是至少会执行一次。（你在你的人生中总是必然会经历一次以上的背叛。如果你愿意经历do，你也愿意承担之后的while风险的话。）

    <?php
    $count=11;
    do{
    printf(“%d squared=%d <br/>”, $count, pow($count,2));
    }while($count<10);
    ?>
    输出为11 squared=121
    for语句提供了比while更复杂的循环机制。其语法为:
    for(expression1;expression2;expression3){
    statements
    }
    //例子1
    for($kilometers=1;$kilometers<=5;$kilometers++){ for循环里设定变量$kilometers为1,变量$kilometers设定的时候小于等于5,变量$kilometers后自增
    printf(“%d kilometers=%f miles <br/>”,$kilometers,$kilometers*0.62140);
    将$kilometers乘以0.62140并通过printf函数打印出来
    }
    //例子2
    $kilometers=1;
    for($kilometers=1; $kilometers++){
    if($kilometers>5) break; 判断如果变量$kilometers大于5，break语句随即退出循环。
    printf(“%d kilometers=%f miles <br/>”,$kilometers,$kilometers*0.62140);
    }
    //例子3
    $kilometers=1;
    for(;;){ 这里for(;;)跟while(true)的意思是一样的。如果为真则执行之后的代码段。
    if($kilometers>5) break;
    printf(“%d kilometers=%f miles <br/>”, $kilometers,$kilometers*0.62140);
    $kilometers++;
    }
    foreach循环结构语法最擅长循环处理数组，从数组中提取每个”键/值”对，直到获得所有项，或满足某些内部条件为止。
    foreach(array_expr as $value){ 从数组中获取每个值，每次迭代都将指针后移一位，这样就能够更加接近数组的末尾，这里也就是数组array_expr的末尾。
    statement
    }
    <?php
    $links=array(“www.apress.com”,www.php.net”,”www.apache.org”); 定义了一个存放三个网站url地址的$links数组。
    echo “Online Resources:<br/>”;
    foreach($links as $link){ 通过foreach函数获得每个网站url地址。
    echo “<a href=\”http://$link\”>$link</a><br/>”;
    }
    ?>
    第二种形式适合处理包含键和值的数组。语法如下：
    foreach(array_expr as $key=>$value){
    statement
    }
    $links=array(“The Apache Web Server”=>”www.apache.org”,
    “Apress”=>”www.apress.com”,
    “The PHP Scripting Language”=>”www.php.net”);
    数组$links里存储了相应的key和value值。
    echo “Online Resource:<br/>”;
    foreach($links as $title=>$link){ 通过foreach语句取出数组$links中的相应的键/值对。
    echo “<a href=\”http://$link\”>$title</a><br/>”;
    }

刚才最新更新的内容中其实有b这个加粗的标签在，跟p段落标签是一样的。所以b会显示为粗体，p会显示为换行。

PHP读书笔记写到现在正文一万字以上了。其实PHP挺有意思的。

    如果包含一个break语句，将立即结束do...while，for,foreach,switch或while循环的执行。（如果你想结束我们的友情的话，那请使用break来强制终止吧。）
    <?php
    $primes=array(2,3,5,7,11,13,17,19,23,29,31,37,41,43,47);声明一个都是素数的数组。
    for($count=1;$count++;$count<1000){ 通过for循环从第1次到第999次执行999次
    $randomNumber=rand(1,50); rand函数是返回随机整数，rand(1,50)是在1到50之内生成随机整数。
    if(in_array($randomNumber,$primes)){ 通过in_array函数判断如果$randomNumber在$primes数组内
    break; 语句强制结束
    }else{
    printf(“Non-prime number found: %d <br/>”,$randomNumber); 通过printf函数打印$randomNumber中生成的随机整数。
    }
    }
    ?>

    下面是上例的输出：
    Non-prime number found:48
    Non-prime number found:42
    Prime number found:17

    通过添加goto语句，你可以直接跳到一个循环或条件构造之外的某个特定位置。（你想在你任何一个方面尝试改变的时候，可以通过goto语句来实现你所认为的蜕变，到你最想达到的位置。）

    <?php
    for($count=0;$count<10;$count++) 循环从0到9执行了10次
    {
    $randomNumber=rand(1,50);
    if($randomNumber<10)
    goto less; //通过goto语句跳转到后面的less分支语句。
    else
    echo “Number greater than 10:$randomNumber<br/>”;
    }
    less:
    echo “Number less than 10:$randomNumber<br/>”; 这里就是之前的goto语句跳转到的less程序段，实现了打印输出的功能。
    ?>
    这会生成以下结果：
    Number greater than 10:22
    Number greater than 10:21
    Number greater than 10:35
    Number less than 10:8

    continue语句使当前循环迭代执行结束，并从下一次循环迭代开始执行。（如果你想继续友情，继续坚持PHP开发的话，那请使用continue语句来继续你对于现实的热情。）

    <?php
    $usernames=array(“grace”,”doris”,gary”,”nate”,”missing”,”tom”); 声明一个$usernames数组，里面有6个元素。
    for($x=0;$x<count($usernames);$x++){ 定义一个for循环，通过count函数计算$usernames数组中的元素数量，并作为接下去循环的次数。

    if($usernames[$x]==”missing”) continue; 如果$usernames数组中发现missing的时候，使用continue重新开始重复执行。

    printf(“Staff member:%s <br/>”,$usernames[$x]); 最后用printf函数输出$usernames数组。
    }
    ?>
    结果输出如下：
    Staff member:grace
    Staff member:doris
    Staff member:gary
    Staff member:nate
    Staff member:tom

    为了追求效率，程序员开始引入了文件包含语句，这样就能够把功能组件隔离为单独的文件。然后在需要时重新组装。PHP提供了四种在应用程序中包含文件的语句。（我想让你随时都陪在我身边，所以，我开始使用包含语句让我随时随地都能够关联得到你。）

    include（）语句将在其被调用的位置处判断并包含一个文件。
    include(/path/to/filename)
    与print和echo一样，使用include()时可以忽略括号。
    <?php
    include “/usr/local/lib/php/wjgilmore/init.inc.php”; 包含一个外部的php文件。
    ?>
    if(expression){
    include(‘filename’); 通过if和else语句来调用相应的include文件。
    else{
    include(‘another_filename’);
    }
    ?>
    当然include()语句也可以包含合法的URL地址。
    include “http://www.langlang.com/index.html?background=blue”;

    include_once（）函数的作用跟include()相同，不过它会首先验证是否已经包含了该文件。它其实只会包含文件一次。(我只想通过include_once()包容你一次，你能够接受么？)

    include_once(filename)

    require(filename)
    require()出错时，脚本将停止执行，而在使用include()的情况下，脚本将继续执行。同时也无论require的位置如何，指定文件都将包含到出现require()的脚本中。无论如何require()都必须要包含到指定的文件。

    require_once(filename)
    require_once()函数确保文件只包含一次，在遇到require_once()后，后面再试图包含相同的文件时都将被忽略。

    标准的PHP发行包中有1000多个标准函数。
    <?php
    $value=pow(5,3) //返回5的3次方，125。
    echo $value;
    ?>
    如果只是希望输出函数的结果，可以不把这个值赋给变量，而是直接输出（我其实挺喜欢直来直去的人，因为，这样的人，通常都比较真诚。这种方式在直接输出里也是这样来理解的。）
    <?php
    echo pow(5,3);
    ?>
    echo “Five raised to the third power equals”.pow(5,3).”.”; 通过.操作符将pow(5,3)拼接起来。
    当前也可以使用printf()，更有说服力：
    printf(“Five raised to the third power equals %d.”,power(5,3)); 这里的%d是带符号十进制数。后面的power(5,3)就是显示在%d这个位置的。
    以上两种情况都将返回以下结果:
    Five raised to the third power equals 125.
    当然，最开始的时候就可以使用预定义模板来定义一个函数,如下：

    function functionName(parameters) 定义了一个自定义函数，函数名叫做functionName，parameters就是传入的参数。
    {
    function-body 函数体
    }
    考虑下面的函数generate_footer(),它将输出一个页脚:
    function generateFooter()
    {
    echo “Copyright 2007 W.Jason Gilmore”;
    }

    之前定义了之后，就可以像下面这样调用这个函数(函数一旦定义好了，就能够在任何位置通过声明这个函数的名字来进行调用。定义好了曹操，然后写曹操的时候曹操就自动来了。都是一样的道理。)

    <?php
    generateFooter();
    ?>
    function calcSalesTax($price,$tax) 这个函数接受两个参数，名为$price和$tax。它们将在计算中使用。
    {
    $total=$price+($price*$tax);
    echo “Total cost:$total”;
    }

    以上的这个calcSalesTax函数，可以有如下的调用：
    calcSalesTax(15.00,0.0);

    当然，也可以这样
    <?php
    $pricetag=15.00;
    $salestax=0.075;
    calcSalesTax($pricetag,$salestax); 以这种方式传递参数时，称为按值传递。
    ?>
    在有些情况下，可能希望在函数内对参数的修改在函数范围外也能反映，按引用传递参数就可以满足这种需要。按引用传递参数（也称传引用）要在参数前加上&符号。

    <?php
    $cost=20.99;
    $tax=0.0575;
    function calculateCost(&$cost,$tax) 传入的参数&$cost是对变量$cost的引用。
    $cost=$cost+($cost*$tax); 修改变量$cost中的值
    $tax+=4; 变量$tax增加4
    }
    calculateCost($cost,$tax);
    printf(“Tax is %01.2f%% <br/>”,$tax*100); %01.2f%%，01中的0是填空字元，如果位置空着，就用0来填满，1规定小数点前面的数字占位要有1位以上，.2f代表小数点后有两位,%%就代表百分号%。这句printf最后打印输出的就是Tax is 5.75%
    printf(“Cost is: $%01.2f”,$cost); 这句话最后打印输出的事Cost is $22.20 在这个函数中，$tax因为是按值传递，所以数值依然相同，而$cost因为是按引用传递，所以数值已经改变。

    ?>

    可以为输入参数指定默认值。（你想不想成为我默认的朋友，如果可以的话，那就请尽情使用你所认为的默认参数值。）
    function calcSalesTax($price,$tax=0.0675) 这里变量$tax就指定为了一个默认的参数值
    { $total=$price+($price*$tax);
    echo “Total cost:$total”;
    }
    仍可以为$tax传递其他的税率，通过调用calcSalesTax（）函数才会使用默认值0.0675:
    $price=15.47;
    calcSalesTax($price);

    可以指定某个参数为可选参数，当然，这些参数要放在参数列表的末尾，而且要指定其默认值为空。(默认的朋友其实一直都在你面前，关键是看你怎么看待这个对于你而言一片空白的朋友。我其实是无所谓的。)
    function calcSalesTax($price,$tax=””) 这里变量$tax就被指定为一个可选的参数，而且默认值等于””，也就是空白。
    {
    $total=$price+($price*$tax);
    echo “Total cost:$total”;
    }
    以上这个函数，如果没有销售税，可以如下调用calcSalesTax（）函数，而不指定第二个参数:
    calcSalesTax(42.00);
    这个调用会返回如下结果:
    Total cost:$42.00
    如果指定了多个可选参数，可以选择性地传递某些参数。（多个可选的朋友，看似好像有点没有多大重要性，但是，关键看你怎么去看待它们。它们其实一直静悄悄地守候在你的身边凝视着你。）
    function calculate($price,$price2=””,$price3=””) 这里变量$price2和$price3就指定为了多个可选参数了。
    {
    echo $price+$price2+$price3;
    }
    调用calculate（）函数时，可以只传递$price和$price3,如下:
    calculate(10,””,3); 变量$price3本来在参数列表里为空，这里被传入参数，赋值为3。
    它返回如下值:
    13
    return（）语句可以向函数调用者返回任意确定的值。
    function calcSalesTax($price,$tax=0.0675)
    {
    $total=$price+($price*$tax);
    return $total; 这里不输出变量$total而是选择通过return语句返回变量$total
    }

    还有一种方式，可以直接返回计算结果，而不要赋给变量$total,如下：
    function calcSalesTax($price,$tax=0.0675)
    {
    return $price+($price*$tax); 这里就直接通过return语句返回这几个变量的计算结果。
    }

    下面是调用这个函数的例子:
    <?php
    $price=6.99;
    $total=calcSalesTax($price); 这里calcSalesTax函数就传入一个变量$price参数，$tax有默认值，然后通过return返回了计算结果之后，最后赋值给变量$total。（走遍千山万水，最后发现自己最中意的某个朋友其实只是通过自己的努力一直在经营着，在传递着而已。）
    ?>

    利用list()构造可以很方便地从数组中获取值。如下：
    $colors=array(“red”,”blue”,”green”);
    list($red,$blue,$green)=$colors; 通过list()构造获取$colors数组中的相应值，并赋值给$red,$blue,$green。
    ?>

    <?php
    function retrieveUserProfile()
    {
    $user[]=”Jason”;
    $user[]=”jason@example.com”;
    $user[]=”English”;
    return $user;
    }
    list($name,$email,$language)=retrieveUserProfile(); 通过list构造获取函数retrieveUserProfile中的数组$user的相应的三个值，并赋值给$name,$email,$language。
    echo “Name:$name,email:$email,language:$language”; 然后在这里打印输出
    ?>
    执行此脚本将返回:
    Name:Jason,email:jason@example.com,language:English

    递归函数，即调用自身的函数。（在到达成功彼岸的时候，通常需要反复努力，反复尝试，但是，这个过程只要记录下来过，其实就已经是一种非常不错的递归经历了。）
    function amortizationTable($pNum,$periodicPayment,$balance,$monthlyInterest)
    $pNum标识为还款编号，$periodicPayment表示每月总的还款额，$balance表示剩余贷款额,
    $monthlyInterest指定了每月的利率。
    {
    $paymentInterest=round($balance*$monthlyInterest,2); 通过round函数对每月贷款利息保留两位小数进行获得。并赋值给每月贷款利息$paymentInterest

    $paymentPrincipal=round($periodicPayment-$paymentInterest,2); 通过每月总的还款额$periodicPayment减去每月贷款利息$paymentInterest，用round函数保留两位小数，并赋值给每月还款本金$paymentPrincipal。

    $newBalance=round($balance-$paymentPrincipal,2); 通过剩余贷款额$balance减去每月还款本金$paymentPrincipal，用round函数保留两位之后赋值给新的剩余贷款额$newBalance。
    if($newBalance<$paymentPrincipal){
    如果新的剩余贷款额$newBalance小于每月还款本金$paymentPrincipal，新的剩余贷款额设定为0，避免它为负数。
    $newBalance=0；
    }
    printf(“<tr><td>%d</td>”,$pNum); 以带符号十进制数%d的格式打印还款编号$pNum。
    printf(“<td>$%s</td>”,number_format($newBalance,2)); 以字符串格式%s显示变量$%s.
    printf(“<td>$%s</td>”,number_format($periodicPayment,2)); 通过格式化数字函数number_format将得到的新的剩余贷款额$newBalance和每月总的还款额$periodicPayment进行数字的格式化。并打印出来。

    printf(“<td>$%s</td>”,numberformat($paymentPrincipal,2));
    printf(“<td>$%s</td></tr>”,numberformat($paymentInterest,2));
    如果新的剩余贷款额$newBalance还没有为0，递归调用amorizationTable函数
    if($newBalance>0){
    $pNum++;
    amortizationTable($pNum,$periodicPayment,$newBalance,$monthlyInterest);
    }else{
    return 0;
    }
    }

    这里我非常欣喜地恭喜大家，其实，递归地尝试让自己学习并熟练掌握PHP语言，并不是一种负担，而是一种享受，大家应该都深有感受。

    使用递归的还贷进度计算器
    <?php
    设定贷款余额
    $balance=10000.00;
    设定贷款利率
    $interestRate=0.0575;
    设定每个月的利率
    $monthlyInterest=$interestRate/12;
    设定贷款年限，这里设定为5年
    $termLength=5;
    每年支付还贷的次数
    $paymentsPerYear=12;
    设定支付编号，次序
    $paymentNumber=1;
    决定并设定好总的支付还贷次数
    $totalPayments=$termLength*$paymentsPerYear;
    决定定期付款的利息部分
    $intCalc=1+$interestRate/$paymentsPerYear;
    决定定期付款,用到了pow()函数用来求x的y次方的值。
    $periodicPayment=$balance*pow($intCalc,$totalPayments)*($intCalc-1)/(pow($intCalc,$totalPayments)-1);
    将定期付款保留到小数点后的两位，用到了round()函数进行四舍五入运算。
    $periodicPayment=round($periodicPayment,2);
    创建一个表格
    echo “<table width=’50%’ align=’center’ border=’1’>”;
    指定表格宽度设定为50%,排列方式为居中，边框的厚度设定为1像素
    echo “<tr>
    <th>Payment Number</th><th>Balance</th> th标签定义了HTML表格中的表头单元格
    <th>Payment</th><th>Interest</th><th>Principal</th>
    </tr>”;
    调用递归函数,传入四个参数,支付编号，定义付款，贷款余额，每月的利率
    amortizationTable($paymentNumber,$periodicPayment,$balance,$monthlyInterest);
    关闭表格
    echo “</table>”;
    ?>
    为了程序代码的重用性（方便以后的重复使用代码，对于懒惰的程序员而言，这未尝不是一件福音，大家说是吧。），开始产生了函数库。
    <?php
    function localTax($grossIncome,$taxRate){ 定义了一个地方税localTax函数，传入了两个参数，总收入$grossincome,税率$taxRate
    //函数体
    }
    function stateTax($grossIncome,$taxRate,$age){ 定义了一个州税stateTax函数，传入了三个参数，总收入$grossIncome,税率$taxRate,年龄$age
    //函数体
    }
    function medicare($grossIncome,$medicareRate){ 定义了一个医疗保险费medicare函数，传入了两个参数,$grossIncome总收入，$medicareRate医疗保险费率
    //函数体
    }

    在PHP这门语言中，数组它提供了一种理想的方法来存储，操作，排序和获取数据集。（你其实可以定义一个你所拥有的好朋友的数据集作为你所钟爱的数组。一个看似简单的概念，很多时候，好像可以蕴含很多不一样的东西。）
    传统上把数组定义为一组有某种共同特性的元素。当然，数组中的元素甚至可以不属于同一种类型。数组结构中的实体包含两个项：键（key）和值（value）。可以通过查询键来获取其相应的值。这些键可以是数值键或关联键。数值键的例子：
    $states=array(0=>”Alabama”,”1”=>”Alaska”...”49”=>”Wyoming”); 其实这个例子中的数值键与值没有真正的联系，它们只是值在数组中的位置。很多看似很明显的东西，通过这个例子好像看不出什么，但，或许，挺明显的。它只是为了更好地显示这个数组中的数据。
    使用数值索引，可以如下引用第1个州（Alabama）:
    $states[0]
    PHP中的数值索引数组以位置0开始，而不是1。
    当然，关联键与值有一定关系。下面这个例子：
    $states=array(“OH”=>”Ohio”,”PA”=>”Pennsylvania”,”NY”=>”New York”)
    如果要引用Ohio这个值，可以通过如下调用
    $states[“OH”]
    还可以创建包含数组的数组，这称为多维数组。（在数据集中还有数据集，就像我中有了你之后，我跟你之间的友情，就蜕变成为了一种非常奇怪的存在。但，这种存在是有意义的。然后就被定义为了是多维数组的一种转化。）

    例如，可以使用一个多维数组存储美国各州的信息。
    $states=array(
    “Ohio”=>array(“population”=>”11,353,140”,”capital”=>”Columbus”),
    “Nebraska”=>array(“population”=>”1,711,263”,”capital”=>”Omaha”)
    );
    然后可以如下引用Ohio的入口:
    $states[“Ohio”][“population”]
    数组里面其实有数组指针这个概念，数组指针就如同书签，告诉你正在检查的数组位置。（就像你开车通过GPS导航来定位路是一样的道理。有了数组指针的指引，就知道自己到底到了数组的什么位置。）

    当然了，PHP不需要在创建数组时指定其大小。
    因为数组没有大小限制，所以只需建立引用就可以创建数组。
    $state[0]=”Delaware”;
    然后可以打印输出数组$states的第一个元素：
    echo $state[0];
    接下来，可以为数组索引映射新值，从而添加其他的值：
    $state[1]=”Pennsylvania”;
    $state[2]=”New Jersey”;
    ...
    $state[49]=”Hawaii”;
    当然，其实也可以在创建时省略索引值：（该忽略的时候，你就发现你可以忽略很多看似不存在但却是固定的编程烦恼。）
    $state[]=”Pennsylvania”;
    $state[]=”New Jersey”;
    ...
    $state[]=”Hawaii”;
    下面的示例创建了一个数组:它将美国州名映射到其加入联邦的日期：
    $state[“Delaware”]=”December 7,1787”;
    $state[“Pennsylvania”]=”December 12,1787”;
    $state[“New Jersey”]=”December 18,1787”;
    ...
    $state[“Hawaii”]=”August 21,1959”;
    当然，用array()创建数组比起以上的这种方式，更加显得正式。英文名称很多时候确实很直接，但却也非常值得这样来使用。
    array()的数组形式：
    array array([item1[,item2...[,itemN>)
    下面举一个使用array()创建数组索引的例子：
    $languages=array(“English”,”Gaelic”,”Spanish”);
    这里$languages[0]=”English”,$languages[1]=”Gaelic”,$languages[2]=”Spanish”
    还可以用array()创建一个关联数组:
    $languages=array(“Spain”=>”Spanish”,
    “Ireland”=>”Gaelic”,
    “United States”=>”English”);
    这样一来$languages[“Spain”]=”Spanish”
    $languages[“Ireland”]=”Gaelic”
    $languages[“United States”]=”English”
    通过相应的索引确实能够访问到相应的键值。（人生中索引，或许真的能够指引你今后人生路上的方向。而不单单只是一种指引。）

    list()函数与array()类似，可以在一次操作中从一个数组内提取多个值，同时为多个变量赋值。（你可以怀念你曾经的所有朋友，通过照相本的方式来找回，同时也可以通过自己的思想找出那些看似不存在的朋友们。通过list（）函数就是实现类似的功能。）
    void list(mixed...)
    下面显示了如何使用list()同时为多个变量赋值：
    打开users.txt文件
    $users=fopen(“users.txt”,”r”); 以只读模式通过fopen函数打开users.txt文本
    当没有到达文件末尾的时候，跳到下一行
    while($line=fgets($users,4096)){
    从$users指向的users.txt文件中读取一行并返回长度最多为4095字节的字符串。
    //使用explode()去分隔每个数据片，并赋值给$name，occupation,$color。
    list($name,$occupation,$color)=explode(“|”,$line);
    格式化并输出数据
    prinf(“Name:%s<br/>”,$name); 以%s字符串的格式打印Name
    printf(“Occupation:%s<br/>”,$occupation);
    printf(“Favorite color:%s<br/>”,$color);
    }
    fclose($users);

    然后会读取users.txt文件的每一行，并如下格式化:
    Name:Nino Sanzi
    Occupation:professional golfer
    Favorite Color:green
    list()依靠函数explode()将一行分解为三个元素，这里explode()使用竖线作为元素分隔符，然后，这些元素分别赋给了$name,$occupation,$color。
    range（）函数是一个快速填充数组的简单方法，并会使用low到high范围的整数值填充数组。
    array range(int low,int high,[,int step])
    假设需要一个数组，其中包含骰子中所有可能出现的值：
    $die=range(0,6); 等同于列举出一个数组$die=array(0,1,2,3,4,5,6)
    如果希望有一个包含0到20之间所有偶数的数组，就可以使用步长值为2：
    $even=range(0,20,2);
    这里$even=array(0,2,4,6,8,10,12,14,16,18,20);
    range()函数还可以用于字符序列。假设希望创建一个包含字母A到F的数组：
    $letters=range(“A”,”F”);
    //$letters=array(“A”,”B”,”C”,”D”,”E”,”F”);
    数组的输出通常使用print_r()函数完成，其原型如下：
    boolean print_r(mixed variable[,boolean return])
    print_r()函数接受一个变量，并将其内容发送给标准输出，成功时返回TRUE，否则返回FALSE。
    判断是否为数组的内置函数is_array()其形式为:
    boolean is_array(mixed variable)
    $states=array(“Florida”);
    $state=”Ohio”;
    printf(“\$states is an array:%s<br/>”,(is_array($states)?”TRUE”:”FALSE”)); 以%s字符串的格式输出数组$states
    printf(“\$states is an array:%s<br/>”,(is_array($state)?”TRUE”:”FALSE”));
    下面是执行该例子的结果：
    $states is an array:TRUE
    $state is an array:FALSE
    其实对于数组而言，真正关键的是数组中的内容，到底是否应该定义一个自己内心深处真正应该关心的朋友的数组群，在孤单无依的时候有时候可以认真地回想起他们，毕竟，他们才是我们内心深处真正所渴望的那种存在。是对于我，对于你的依靠。编程的孤独，或许，就能够被彻底冲刷了吧。

    PHP为扩大和缩小数组提供了一些函数。FIFO(先进先出)，LIFO(后进先出)其实是数据结构中的概念（FIFO相当于排队，谁先排在前面就先办好事情离开。LIFO的典型数据结构就是栈。后进来的元素可以先离开。其实元素离开就相当于删除元素。在栈这个数据结构中，先进来的元素可以先删除。你可以把我当作好朋友，思前想后，最后一个接纳进来，你也可以反悔，第一个删除我，这就是我对于栈，对于接纳朋友的理解。）。顾名思义，从这些函数的函数名（push,pop,shift和unshift）就能够清楚地反映出其作用。

    array_unshift()函数在数组头添加元素，所有已有的数值键都会相应地修改，以反映其在数组中的新位置，但是关联键不受影响。
    int array_unshift(array array,mixed variable [,mixed variable...])
    下面这个例子在$states数组前端添加了两个州：
    $states=array(“Ohio”,”New York”);
    array_unshift($states,”California”,”Texax”);
    这其实就相当于后来处理好之后的$states=array(“California”,”Texax”,”Ohio”,”New York”);
    在数组尾添加元素
    array_push()函数将variable添加到target_array()的末尾，成功时返回TRUE，否则返回FALSE。
    可以为此函数传递多个变量作为输入参数，同时向数组压入多个变量（元素）。
    int array_push(array array,mixed variable [,mixed variable...])
    下面这个例子在$states数组的末尾又添加了两个州：
    $states=array(“Ohio”,”New York”);
    array_push($states,”California”,”Texax”);
    这里$states=array(“Ohio”,”New York”,”California”,”Texas”);
    array_shift()函数删除并返回数组中找到的元素。其结果是，如果使用的是数值键，则所有相应的值都会下移，而使用关联键的数组不受影响。其形式为：
    mixed array_shift(array array)
    下面的例子删除了$states数组中的第一个州：
    $states=array(“Ohio”,”New York”,”Caifornia”,”Texas”);
    $states=array_shift($states);
    删除了元素之后的$states为array(“New York”,”California”,”Texas”)
    获得了第一个元素之后的$states为”Ohio”
    array_pop()函数删除并返回数组的最后一个元素。其形式为：
    mixed array_pop(array target_array)
    $states=array(“Ohio”,”New York”,”California”,”Texas”);
    $state=array_pop($states);
    这里删除了最后一个元素之后的$states为array(“Ohio”,”New York”,”California”)
    得到了元素之后的$states为”Texas”
    其实，不管是从数组头删除添加元素，还是数组尾删除添加元素，其实只是为了更好地理解数组的相应结构，改变并不可怕，最关键是如果尝试学习并适应这种改变。数组中相应的键和值其实都因为各自的关联而能够在删除和添加的时候产生作用，而使用关联键，或许是因为关联键自身的特殊性，所以，才能够不受影响。有些朋友对于你而言是很容易动摇的，就像数值键一样，而有些固定不变的朋友，不管你情况如何他们都不会改变，就像关联键一样。很多东西，看多了，适应了之后，就会发现，原来，我还是我，我的那些朋友们，或许有的已经改变，而有的，不用改变同时也无须改变。

    in_array()函数在数组中搜索一个特定值，如果找到这个值则返回TRUE，否则返回FALSE。其形式如下：（当你通过微信寻找某一个特定的微信好友的时候，你有时候会发现你脸上会浮现出一些特定的笑容，确实，应该用in_array()函数）
    boolean in_array(mixed needle,array haystack [,boolean strict]) 第三个参数strict可选，它强制in_array()在搜索时考虑类型。
    $state=”Ohio”;
    $states=array(“Califonia”,”Hawaii”,”Ohio”,”New York”);定义了一个存放了四个州的数组
    if(in_array($state,$states)) echo “Not to worrry,$state is smoke-free!”;
    判断$state中的内容是否在数组$states内，判断成功之后实现打印的功能。

    如果在一个数组中找到一个指定的键，函数array_key_exists()返回TRUE，否则返回FALSE。其形式如下：(其实对于数组而言，键也好，值也好，都是一种指引，一种指示，一种显示数组结构的尝试的方法。交朋友这种东西，有时候确实是近朱者赤近墨者黑，键相当于这个人的名声，而值相当于这个人的相关信息。要想获取一个你想结识的好友的信息，其实并不难。)
    boolean array_key_exists(mixed key,array array)
    下面的例子将在数组键中搜素Ohio,如果找到，将输出这个州加入美国联邦政府的有关信息：
    $state[“Delaware”]=”December 7,1787”;
    $state[“Pennsylvania”]=”December 12,1787”;
    $state[“Ohio”]=”March 1,1803”;
    if(array_key_exists(“Ohio”,$state)) 通过判断Ohio这个key是否在$state数组中出现过，判断成功打印一段英文,并以%s字符串的格式显示。
    printf(“Ohio joined the Union on %s”,$state[“Ohio”]);
    结果如下:
    Ohio joined the Union on March 1,1803

    array_search()函数在一个数组中搜索一个指定的值，如果找到则返回相应的键，否则返回FALSE。其形式如下：
    mixed array_search(mixed needle,array haystack[,boolean strict])
    下面的例子在$state中搜索一个特定的日期（December 7）,如果找到，则返回相应州的有关信息：
    $state[“Ohio”]=”March 1”;
    $state[“Delaware”]=”December 7”;
    $state[“Pennsylvania”]=”December 12”;
    $founded=array_search(“December 7”,$state); 从$state数组中的值内查找是否有December 7如果有，返回相应的键。然后再以%s的格式显示并打印输出。
    if($founded) printf(“%s was founded on $s.”,$founded,$state[$founded]);
    输出如下:
    Delaware was founded on December 7.

    array_keys()函数返回一个数组，其中包含所搜索数组中找到的所有键，（我其实可以一下子搜索好几个微信好友并返回，其实都是通过他们的微信昵称来定位他们的。他们，应该也会非常欣喜吧。这里就要用到array_keys()函数。）其形式如下：
    array array_keys(array array[,mixed search_value])
    如果包含可选参数search_value，则只会返回与该值匹配的键。下面的例子将输出$state数组中找到的所有的键值:
    $state[“Delaware”]=”December 7,1787”;
    $state[“Pennsylvania”]=”December 12,1787”;
    $state[“New Jersey”]=”December 18,1787”;
    $keys=array_keys($state); 从$state数组中搜索所有键。
    print_r($keys);
    输出如下：
    Array([0]=>Delaware [1]=>Pennsylvania[2]=>New Jersey)
    这里将三个键都打印了出来，前面还加上了数值索引。
    array_values()函数返回一个数组中的所有值，并自动为返回的数组提供数值索引，其形式如下：
    array array_values(array array)
    下面的例子将获取$population中找到的各州人口数:
    $population=array(“Ohio”=>”11,421,267”,”Lowa”=>”2,936,760”);
    print_r(array_values($population));
    这个例子的输出如下：
    Array([0]=>11,421,267[1]=>2,936,760)
    其实，当你觉得你适合交朋友的时候，你可以用你所认为的认真，你所认为的PHP中的部分语法来定义出他们的数组集，同时还能够通过你自己的逻辑思维和判断来做一点看上去非常有趣的事。

    通常需要遍历数组并获得各个键或值，或者同时获得键和值。（微信的好友跟好友的昵称，看似好像没有太多关联，但，其实正是因为你时不时地会去朋友圈看看，逛一逛，当分享一些视频或者是发朋友圈的时候，其实你已经在做一些跟遍历有关的事了。也许，适应一个人在房间里面的孤独时，打开微信，稍微看一看，观察一下，你就会发现，原来通过遍历的方式来重新认识自己的旧朋友，新朋友，就是这么简单，同时也看似有趣。）

    key()函数返回input_array中当前指针所在位置的键。其形式如下：
    mixed key(array array)
    下面的例子通过迭代处理数组并移动指针来输出$capitals数组的键：
    $capitals=array(“Ohio”=>”Columbus”,”Iowa”=>”Des Moines”);
    echo “

Can you name the capitals of these states?

”;
    while($key=key($capitals)){ 通过key()函数获得$capitals中的键并赋值给$key
    printf(“%s <br/>”,$key); 然后以%s字符串的形式打印出来
    next($capital); 通过next()函数移动$capitals数组中的指针，移动到下一个数据，也就是从Ohio移动到lowa，其实调用key()函数时不会移动指针的。
    }
    将返回以下结果:
    Can you name the capitals of these states?
    Ohio
    Iowa

    current()函数返回数组中当前指针所在位置的数组值，其形式如下：
    mixed current(array array)
    以下的这个例子是获取数组值的：
    $capitals=array(“Ohio”=>”Columbus”,”Iowa”=>”Des Moines”);
    echo“

Can you name the states belonging to these capitals?

”;
    while($capital=current($capitals)){ 通过current()函数获取数组$capitals中的当前数组值。并赋值给$capital
    printf(“%s <br/>”,$capital);
    next($capitals); 通过next()函数移动$capitals数组中的指针。
    }
    输出如下:
    Can you name the states belonging to these capitals?
    Columbus
    Des Moines
    each()函数返回input_array的当前键值对，并将指针推进一个位置。其形式如下：
    array each(array array)

顶

    有很多函数可以移动数组指针。（尝试想要改变自己的人脉或者是微信好友的时候，可以通过自己的微信，自己的通讯录，通过自己的记忆点或者是排序的方式来对这些人进行整理。自己的脑海里可以通过自己的回忆梳理并定位到某一个特定的人或者是朋友。）

    next()函数返回紧接着放在当前数组指针下一个位置的数组值。其形式如下：
    mixed next(array array)
    以下是一个例子：
    $fruits=array(“apple”,”orange”,”banana”);
    $fruit=next($fruits); 这里通过next()函数将数组指针从apple移动到了orange
    $fruit=next($fruits); 这里从orange返回到banana
    还可以将指针前移，也可以直接移动到数组的开始和末尾位置。
    prev()函数返回位于当前指针前一个位置的数组值，如果指针本来就位于数组的第一个位置，则返回FALSE。其形式如下：
    mixed prev(array array)
    reset()函数用于将数组指针设置回数组的开始位置。其形式如下：
    mixed reset(array array)
    end()函数将指针移动到数组的最后一个位置，并返回最后一个元素。其形式如下：
    mixed end(array array)
    $fruits=array(“apple”,”orange”,”banana”);
    $fruit=current($fruits); 通过current（）函数返回当前元素apple
    $fruit=end($fruits); 通过end（）函数返回数组末尾的最后一个元素banana

    array_walk()函数将数组中的各个元素传递到用户自定义函数。其形式如下：
    boolean array_walk(array &array, callback funtion[,mixed userdata])
    <form action=submitdata.php” method=”post”>

提供最能描述所在州的6个关键词。

关键字:<br/>
<input type=”text” name=”keyword[]” size=”20” maxlength=”20” value=””/>

关键字2:<br/>
<input type=”text” name=”keyword[]” size=”20” maxlength=”20” value=””/>

关键字3:<br/>
<input type=”text” name=”keyword[]” size=”20” maxlength=”20” value=””/>

关键字4:<br/>
<input type=”text” name=”keyword[]” size=”20” maxlength=”20” value=””/>

关键字5:<br/>
<input type=”text” name=”keyword[]” size=”20” maxlength=”20” value=””/>

关键字6:<br/>
<input type=”text” name=”keyword[]” size=”20” maxlength=”20” value=””/>

    <form>
    以上的这个表单定义了六个关键字，大小size和最大长度都定义为了20。这个表单信息发送给submitdata.php这个脚本。通过使用array_walk()函数，就可以使用一个预定义函数轻松地过滤这些关键字：

    <?php
    function sanitize_data(&$value,$key){
    $value=strip_tags($value); 数组中的每个值都传递给strip_tags()函数，这个函数将删除值中的所有HTML和PHP标记。
    }
    array_walk($_POST[‘keyword’],”sanitize_data”);将通过表单post方式提交所获得的关键字keyword数组中的所有元素传递到sanitize_data函数进行处理。
    ?>

顶

    有些函数可以用来确定数组中的值总数以及唯一值的个数。

    count()函数返回数组中值的总数。（就像统计原来我事业单位非编时候的同事们到底有多少人是一样的道理。）其形式如下：
    integer count(array array[,int mode])
    $garden=array(“cabbage”,”peppers”,”turnips”,”carrots”);
    echo count($garden);
    这将返回4，也就是数组$garden中所有蔬菜的总数。

    $locations=array(“Italy”,Amsterdam”,array(“Boston”,”Des Moines”),”Miami”);
    echo count($locations,1);
    这将返回6，数组$location中看上去只有5个元素，但count()函数中加入了可选的mode参数，设置为1之后，数组$location中的有两个元素的小数组也被统计为一个元素，所以，最后的统计结果就为6了。就像人口办特勤里有二三十个人一个大队，也有两三人一组一个小队是一样的，用count函数统计的时候，如果加入了可选的mode参数后，大队跟小队的数量都会进行统计。

    sizeof()函数是count()的别名，它们的功能是一样的。就像现实中给人起绰号是一样的道理。这两个函数的功能是一样的。

    array_count_values()函数返回一个包含键/值对的数组。其形式为：
    array array_count_values(array array)
    $states=array(“Ohio”,”Iowa”,”Arizona”,”Iowa”,”Ohio”);
    $stateFrequency=array_count_values($states);
    print_r($stateFrequenccy);
    这将返回:
    Array([Ohio]=>2 [Iowa]=>2 [Arizona]=>1)其实非常好理解，数组$states中Ohio出现了两次，Iowa出现了两次，Arizona出现了一次。所以数组中相应的键/值对会一一出现。

    array_unique()函数会删除数组中所有重复的值，返回一个由唯一值组成的数组。其形式为：
    array array_unique(array array)
    $states=array(“Ohio”,”Iowa”,”Arizona”,”Iowa”,”Ohio”);
    $uniqueStates=array_unique($states);
    print_r($uniqueStates);
    这将返回:
    Array([0]=>Ohio [1]=>Iowa [2]=>Arizona)原先数组$states中重复的元素都已经被array_unique函数给删除了。

    array_reverse()函数将数组中元素的顺序逆置。其形式如下：

    array array_reverse(array array[,boolean preserve_keys])
    如果可选参数preserve_keys设置为TRUE，则保持键映射。
    $states=array(“Delaware”,”Pennsylvania”,”New Jersey”);
    print_r(array_reverse($states));
    这里将打印Array((0)=>New Jersey [1]=>Pennsylvania [2]=>Delaware)，顺序确实比起之前的那个数组，已经通过array_reverse函数逆置了。

    可以与启用preserve_keys时得到的结果做个比较：
    $states=array(“Delaware”,”Pennsylvania”,”New Jersey”);
    print_r(array_reverse($states,1));
    这里将打印Array([2]=>New Jersey [1]=>Pennsylvania [0]=>Delaware)这里的这个数组中的键跟值的映射关系，跟原先数组$states中元素的键值映射关系保持关联，保留之前的那种键/值的联系。
    使用关联键的数组将不受preserve_keys的影响。对于关联数组，总是会保持键映射。

顶

    array_flip()函数将置换数组中键及其相应值的角色。其形式如下：
    array array_flip(array array)
    $state=array(“Delaware”,”Pennsylvania”,”New Jersey”);
    $state=array_flip($state);
    print_r($state);
    这个例子返回以下结果:
    Array([Delaware]=>0 [Pennsylvania]=>1 [New Jersey]=>2) 其实已经从这里看出，数组$state中原先的键和值已经被置换了。调换了一下位置。（当你尝试改变我的时候，其实你已经变成了我，而我也已经蜕变成了你。只不过我们都假装不知道罢了，但是你跟我其实都已经互相替换了一下身份。）

    sort()函数对数组进行排序，各元素按值由低到高的顺序排列。其形式如下：
    void sort(array array [,int sort_flags] )
    sort()函数不返回排序后的数组。sort_flags参数可选，将根据这个参数指定的值修改该函数的默认行为。
    SORT_NUMBERIC,按数组排序。对整数或浮点数排序时很有用。
    SORT_REGULAR,按照相应的ASCII值对元素排序。
    SORT_STRING,按接近于人所认知的正确顺序对元素排序。
    $grades=array(42,98,100,100,43,12);
    sort($grades);
    print_r($grades);
    结果如下：
    Array([0]=>12 [1]=>42 [2]=>43 [3]=>98 [4]=>100 [5]=>100)其实通过sort（）函数已经排好序了，然后通过print_r函数进行打印。元素确实已经按照由低到高的顺序进行排列。就像按照年龄大小来排列病人是一样的道理。要尊老爱幼，所以，才会有sort()函数来将老人尽量排在后面甚至是最后面。

    当然，值得注意的是键/值关联不再保持。
    $states=array(“OH”=>”Ohio”,”CA”=>”California”,”MD”=>”Maryland”);
    sort($states);
    print_r($states);
    这个例子的输出如下：
    Array([0]=>California [1]=>Maryland [2]=>Ohio)之所以会这么排序，是因为sort（）函数已经对数组$states中的元素按照原先关联键中所对应的值的字母顺序进行了排列。我真正想要关心的是你手里到底有什么真东西，真的值，而不是你看上去那种有点虚伪的掩饰。通过sort()函数，我能够很清晰地洞悉到你对于我所认为的值的重要性。

    asort()函数与sort()函数相同，以升序对数组排序，只不过它将保持键/值的关联。其形式如下：
    void asort(array array [,integer sort_flags])
    考虑以下数组：
    $state[0]=”Delaware”;
    $state[1]=”Pennsylvania”;
    $state[2]=”New Jersey”;
    使用sort()排序将破坏键/值的关联，使用sort()排序结果如下：
    Array ([0]=>Delaware [1]=New Jersey [2]=>Pennsylvania)
    但是，如果使用asort()排序将得到:
    Array([0]=>Delaware [2]=>New Jersey [1]=>Pennsylvania)这里的键其实用了原先数组中的相应的键，而且没有任何改变。当然,asort()函数确实保持了键/值的关联。

    rsort()函数对sort()相同，只不过它以相反的顺序（降序）对数组元素排序。其形式如下：
    void rsort(array array[,int sort_flags])
    $states=array(“Ohio”,”Florida”,”Massachusetts”,”Montana”);
    rsort($states);
    print_r($states);
    这会返回以下排序结果：
    Array([0]=>Ohio [1]=>Montana [2]=>Massachusetts [3]=>Florida)
    与asort()一样，arsort()会保持键/值的关联，但是，它以逆序对数组排序,其形式如下：
    void arsort(array array [,int sort_flags])
    $states=array(“Delaware”,”Pennsylvania”,”New Jersey”);
    arsort($states);
    print_r($states);
    这会返回以下结果：
    Array([1]=>Pennsylvania [2]=>New Jersey [0]=>Delaware)这里键/值的关联确实在使用了arsort()函数之后还是保持下来了。

    natsort()函数提供了一种相当于人们平常使用的排序机制。其形式如下：
    void natsort(array array)
    函数natcasesort()在功能上与natsort()相同，只是它不区分大小写:
    void natcasesort(array array)
    ksort()函数按键对数组排序，如果成功返回TRUE，失败将发挥FALSE。其形式如下：
    integer ksort(array array[,int sort_flags])
    排序并不代表你对于那些数组中的元素有多么陌生，很多时候，只是想要记住更多的排序的函数而已，当然，通过学习这些函数，我们开始让自己变得越来越充实，同时也越来越充分地尝试想要提高并提升自己对于PHP中更多函数的理解。其实，我们都能够做到，并做得更好。

顶

    krsort()函数的操作与ksort()相同，也按键排序，只不过它将以逆序（降序）排序。其原型如下：
    integer krsort(array array[,int sort_flags])

    usort()函数提供了另一种排序方法，可以使用在该函数中指定的用户自定义比较算法对数组进行排序。其形式如下：
    void usort(array array,callback function_name)
    <?php
    $date=array(’10-10-2003’,’2-17-2002’,’2-16-2003’,’1-01-2005’,’10-10-2004’);
    定义了5个日期元素，存放在数组$date内。
    sort($dates); 使用了sort()函数用于对数组单元从低到高进行排序。
    echo “使用sort()函数对数组进行排序:”;
    print_r($dates);
    natsort($dates); 使用自然排序算法对数组进行排序。
    echo “使用natsort()函数对数组排序:”;
    print_r($dates);
    function DateSort($a,$b){
    如果日期相同，什么都不做。
    if($a==$b) return 0;
    list($month,$aday,$ayear)=explode(‘-‘,$a);
    将$a通过explode()函数将日期通过-分隔打散为数组，并赋值给$month,$aday,$ayear。

    list($month,$bday,$byear)=explode(‘-‘,$b);
    $amonth=str_pad($amonth,2,”0”,STR_PAD_LEFT);使用str_pad（）函数对$amonth最前面的两位用0进行填充如果最前面的日期数字不存在的话。STR_PAD_LEFT提示填充$amonth的最左侧。

    $bmonth=str_pad($bmonth,2,”0”,STR_PAD_LEFT);
    $aday=str_pad($aday,2,”0”,STR_PAD_LEFT);
    $bday=str_pad($bday,2,”0”,STR_PAD_LEFT);
    将日期用字符串连接操作符.重新组合起来
    $a=$ayear.$amonth.$aday;
    $b=$byear.$bmonth.$bday;
    决定日期$a是否大于日期$b
    return($a>$b)?1:-1;
    }
    usort($dates,’DateSort’);
    echo “使用用户自定义的DateSort函数对数组进行排序:”;
    print_r($dates);
    ?>
    结果如下:
    使用sort()函数排序后的数组:
    Array([0]=>1-1-2005 [1]=>10-10-2003 [2]=>10-10-2004 [3]=>2-16-2003 [4]=>2-17-2002)
    sort()函数其实是根据1,10,10,2,2的方式从低到高来进行排序的。
    使用natsort()函数排序后的数组:
    Array([0]=>1-01-2005 [3]=>2-16-2003 [4]=>2-17-2002 [1]=>10-10-2003 [2]=>10-10-2004)
    其实使用了natsort()函数之后，最开始的使用sort()函数之后的键还是保留了下来，通过自然排序算法，按照1,2,2,10,10的方式来进行排序。
    使用用户自定义函数DateSort()对数组进行排序:
    Array([0]=>2-17-2002 [1]=>2-16-2003 [2]=>10-10-2003 [3]=>10-10-2004 [4]=>1-10-2005)
    使用了usort()函数，通过自定义函数DateSort()的描述之后，日期按照从过去到现在的方式进行了排序。

顶

    array_merge()函数将数组合并到一起，并返回一个联合的数组。其形式为:
    array array_merge_recursive(array array1,array array2 [,arrayN...])
    $class1=array(“John”=>100,”James”=>85);
    $class2=array(“Micky”=>78,”John”=>45);
    $classScores=array_merge_recursive($class1,$class2);
    print_r($classScores);
    返回结果：
    Array([John]=>Array([0]=>100 [1]=>45)[James]=>85 [Micky]=>78)这里其实原先数组$class1和数组$class2中的重复的键John通过array_merge_recursive函数被合并了，但值100和45还是获得了保留。该保留的时候，PHP就会给予你最为适合的保留方式。这里要提醒大家,array_merge和array_merge_recursive这两个函数的区别在于，当合并数组之后，存在重复的键时，array_merge会覆盖前面存在的键/值对，替换为当前输入数组中的键/值对，而array_merge_recursive()将把两个值合并在一起，形成一个新的数组。就像在这个例子中的一样。
    array array_combine(array keys,array values)
    例子如下：
    $abbreviations=array(“AL”,”AK”,”AZ”,”AR”);
    $states=array(“Alabama”,”Alaska”,”Arizona”,”Arkansas”);
    $stateMap=array_combine($abbreviations,$states);
    print_r($stateMap);
    这将返回如下结果:
    Array([AL]=>Alabama [AK]=>Alaska [AZ]=>Arizona [AR]=>Arkansas)
    通过array_combine函数，数组$abbreviations中的元素变成新数组$stateMap中的键，数组$states中的元素变成新数组$stateMap中的值。

    array array_merge(array array1,array array2 [...,array arrayN])
    当然，注意，两个输入数组必须大小相同，不能为空。
    $face=array(“J”,”Q”,”K”,”A”);
    $numbered=array(“2”,”3”,”4”,”5”,”6”,”7”,”8”,”9”);
    $cards=array_merge($face,$numbered);
    shuffle($cards); 通过shuffle()函数将合并后的数组$cards中的元素按随机顺序重新排列。
    print_r($cards);
    这会返回:
    Array([0]=>8 [1]=>6 [2]=>K [3]=>Q [4]=>9 [5]=>5
    [6]=>3 [7]=>2 [8]=>7 [9]=>4 [10]=>A [11]=>J)
    这个数组中的元素之所以这样排列，就是因为shuffle函数在起作用，所以合并后的元素就像打乱了顺序一样，随机排列了。

    array_slice()函数将返回数组中的一部分，从键offset开始，到offset+length位置结束。其形式为:
    array array_slice(array array int offset [,int length])
    offset为正值时，拆分从距数组开头的offset位置开始。如果offset为负值，则拆分从距数组末尾的offset位置开始。

    $states=array(“Alabama”,”Alaska”,”Arizona”,”Arkansas”,”California”,”Colorado”,”Connecticut”);
    $subset=array_slice($states,4);这里的4指从第5个元素，也就是从California开始取。
    print_r($subset);
    这将返回:
    Array([0]=>California [1]=>Colorado [2]=>Connecticut)
    考虑第二个例子，这个例子使用了负长度：
    $states=array(“Alabama”,”Alaska”,”Arizona”,”Arkansas”,”California”,”Colorado”,”Connecticut”);
    $subset=array_slice($states,2,-2);这里也就是从原来的数组$states中从第3个元素开始取，一直取到倒数第三个元素为止。
    print_r($subset);
    这将返回：
    Array([0]=>Arizona [1]=>Arkansas [2]=>California)

顶

    array_splice()函数会删除数组中从offset开始到offset+length结束的所有元素，并以数组的形式返回所删除的元素。其形式为：
    array array_splice(array array,int offset[,int length [,array replacement]])
    $states=array(“Alabama”,”Alaska”,”Arizona”,”Arkansas”,”California”,”Connecticut”);
    $subset=array_splice($states,4);
    print_r($states); 这个时候数组$states保留了最前面的四个元素。
    print_r($subset); 这个时候数组$subset保留了从第五个元素到之后的两个元素。
    这将得到:
    Array([0]=>Alabama [1]=>Alaska [2]=>Arizona [3]=>Arkansas)
    Array([0]=>California [1]=>Connecticut)

    $states=array(“Alabama”,”Alaska”,”Arizona”,”Arkansas”,”California”,”Connecticut”);
    $subset=array_splice($states,2,-1,array(“New York”,”Florida”));这里是删除了数组$states从第二个元素之后，直到倒数第二个元素的中间的这些元素。
    print_r($states);
    返回如下结果:
    Array([0]=>Alabama [1]=>Alaska [2]=>New York [3]=>Florida [4]=>Connecticut)
    array_intersect()函数返回一个保留了键的数组，这个数组只由一个数组中出现的且在其他每个输入数组中都出现的值组成。其形式如下：
    array array_intersect(array array1,array array2[,arrayN...])
    下面这个例子将返回在$array1数组中出现的且在$array2和$array3也出现的所有的州：
    $array1=array(“OH”,”CA”,”NY”,”HI”,”CT”);
    $array2=array(“OH”,”CA”,”HI”,”NY”,”IA”);
    $array3=array(“TX”,”MD”,”NE”,”OH”,”HI”);
    $intersection=array_intersect($array1,$array2,$array3);
    print_r($intersection);
    这会返回：
    Array([0]=>OH [3]=>HI)这里的键0和3是对应着$array1中的OH和HI所对应的最初始的键。下标是从0开始直到后面的。有时候你会发现，其实取交集也好，还是删除元素也好，其实都是因为相应的键和值有所对应，所以才能够实现交集同时也能够删除数据，下标要严重注意是从0开始的哦，还有一些负数的下标，其实是从最后面开始计数的。最开始的时候通过数字定位出某个元素，同时也能够在倒数的位置同样定位到某个元素。

顶

    函数array_intersect_assoc()与array_intersect()基本相同，只不过它在比较时还考虑了数组的键。其形式如下：
    array array_intersect_assoc(array array1,array array2 [,arrayN...])
    $array1=array(“OH”=>”Ohio”,”CA”=>”California”,”HI”=>”Hawaii”);
    $array2=array(“50”=>”Hawaii”,”CA”=>”California”,”OH”=>”Ohio”);
    $array3=array(“TX”=>”Texas”,”MD”=>”Maryland”,”OH”=>”Ohio”);
    $intersection=array_intersect_assoc($array1,$array2,$array3);
    print_r($intersection);
    通过调用array_intersect_assoc函数，这会返回这三个数组的公共部分的元素并组成数组。
    Array([OH]=>Ohio)
    函数array_diff()返回出现在第一个数组中但其他输入数组中没有的值。形式如下：
    array array_diff(array array1,array array2[,arrayN...])
    $array1=array(“OH”,”CA”,”NY”,”HI”,”CT”);
    $array2=array(“OH”,”CA”,”HI”,”NY”,”IA”);
    $array3=array(“TX”,”MD”,”NE,”OH”,”HI”);
    $diff=array_diff($array1,$array2,$array3);
    print_r(intersection);
    通过array_diff函数，发现第一个数组$array1跟第二个数组$array2比较时，CT这个元素在第二个数组$array2中是没有的，然后再跟第三个数组$array3做比较，发现CT还是没有。所以，这将返回Array([0]=>CT)
    函数array_diff_assoc()与array_diff()基本相同，只是它在比较时还考虑了数组的键。因此，只在第一个数组中出现而不在其他输入数组中出现的键/值对才会返回到结果数组中。其形式如下：
    array array_diff_assoc(array array1,array array2[,arrayN...])
    $array1=array(“OH”=>”Ohio”,”CA”=>”California”,”HI”=>”Hawaii”);
    $array2=array(“50”=>”Hawaii”,”CA”=>”California”,”OH”=>”Ohio”);
    $array3=array(“TX”=>”Texas”,”MD”=>”Maryland”,”KS”=>”Kansas”);
    $diff=array_diff_assoc($array1,$array2,$array3);
    print_r($diff);
    这个例子调用了array_diff_assoc函数之后，只返回了”HI”=>”Hawaii”,因为这个键/值对确实在$array1中很特殊，在$array2和$array3中都不存在。
    这将返回Array([HI]=>Hawaii)

    array_rand()函数将返回数组中的一个或多个键。其形式为：
    mixed array_rand(array array[,int num_entries])
    $states=array(“Ohio”=>”Columbus”,”Towa”=>”Des Moines”,”Arizona”=>”Phoenix”);
    $randomStates=array_rand($states,2); 通过调用array_rand函数随机取得$states数组中的随机两个元素。
    print_r($randomStates);
    这会返回Array([0]=>Arizona [1]=>Ohio)这里的Arizona和Ohio就是数组$states中的随机两个键。

    shuffle()函数随机地对数组中的元素重新排序。其形式为：
    void shuffle(array input_array)
    考虑一个数组，其中包含表示扑克牌的值：
    $cards=array(“jh”,”js”,”jd”,”jc”,”qh”,”qs”,”qd”,”qc”,”kh”,”ks”,”kd”,”kc”,”ah”,”as”,”ad”,”ac”);
    对数组$cards中的扑克牌重新排序
    shuffle($cards);
    print_r($cards);这将返回类似于下面的结果，因为随机洗牌，每个人的结果都有可能不同。
    Array([0]=>js [1]=>ks [2]=>kh [3]=>jd [4]=>ad [5]=>qd [6]=>qc [7]=>ah [8]=>kc [9]=>qh [10]=>kd
    [11]=>as [12]=>ac [13]=>jc [14]=>jh [15]=>qs)这样一来原来数组$cards中的元素变成了新数组Array中的值。函数这种东西，功能确实是非常强大，其实你改变不了原来数组中的元素，但是你能够改变你所能够改变的那个数组中的那个小你，或者是小他，小她都是一样的。排序也好，取交集也好，都只是为了让自己觉得舒服，让程序员的你开始愿意痴迷在程序员们都愿意痴迷的那个世界中和代码堆里。

顶

    array_sum()函数将input_array中的所有值加在一起，返回最终的和。其形式如下：
    mixed array_sum(array array)
    <?php
    $grades=array(42,”hello”,42);
    $total=array_sum($grades);
    print $total;
    ?>
    这将返回:84 数组$grades中有hello这个字符串的元素，在使用array_sum函数时这个字符串值会被忽略，所以，最后array_sum将42跟42加在一起，最后打印的就是84了。

    array_chunk()函数将input_array分解为一个多维数组，它由多个包含size个元素的数组所组成。其形式如下：
    array array_chunk(array array,int size [,boolean preserve_keys])
    $cards=array(“jh”,”js”,”jd”,”jc”,”qh”,”qs”,”qd”,”qc”,”kh”,”ks”,”kd”,”kc”,”ah”,”as”,”ad”,”ac”);
    shuffle($cards); 调用shuffle函数随机排列数组$cards
    $hands=array_chunk($cards,4);
    使用array_chunk函数将数组$cards分解为四段相同的一维数组，并合并在多维数组中。
    print_r($hands);
    结果如下（由于随机洗牌，每个人的结果可能有所不同）：
    Array([0]=>Array([0]=>jc [1]=>ks [2]=>js [3]=>qd)
    [1]=>Array([0]=>kh [1]=>qh [2]=>jd [3]=>kd)
    [2]=>Array([0]=>jh [1]=>kc [2]=>ac [3]=>as)
    [3]=>Array([0]=>ad [1]=>ah [2]=>qc [3]=>qs))

    在PHP的OOP中，有三个基本概念，封装，继承和多态。有时候并不一定要了解事物的内部工作原理，使用计算机，但是并不是每个人都了解计算机的内部工作原理。通过使用接口就能够忽略其内部结构。接口隐藏了这些细节，通过众所周知的接口将用户与实际应用程序的内部工作原理分离，这种方向称为封装。其实更加简单一点，在编写程序时将很多框架的代码封装在一起，只要知道该怎么调用就用非常简单的代码段调用其实也就是封装在PHP编程中的实际意义。

    继承，就比如各种职员可以继承一般员工所拥有的共同性质，例如姓名，员工号和工资。还有职员类型可以被白班职员和夜班职员继承。还可以创建一个人类，让员工类可以继承人类，并成为人类的一个子类。面向对象开发方法建立在继承概念的基础之上，通过继承，可以提高代码的可重用性。这样，就可以使我们在多个应用程序中可以使用设计良好的类。设计良好的类，其实也就是这些类足够抽象，从而可以重用。更简单地来说，子女继承了父母的良好的基因，也可能继承不好的基因，但是，通过这种血缘关系的继承性，让人这个最大的类变得越来越有共性，同时也越来越有每个人自己的个性。想要继承的时候，就能够继承一些东西，共性和个性都能够实现，同时也能够互相适应。

    多态，其实也就是有多种形态。假设在员工类的定义中有一个“签到”的行为，这个行为对于职员员工来说，可能具体为使用时钟来打卡，而有些其他类型的员工，可能通过网络来签到。虽然职员员工类和其他类型的员工类从员工类继承到这个行为，但具体该怎么实现“签到”就要依赖于实现“签到”的上下文，这就是多态之所以这么强大的原因。

顶

    在OOP术语中，实体的性质和行为的具体定义称为类。每个实体都由一组性质和行为来定义。日常环境由无数实体组成：所喜欢的人，所喜欢的事，朋友们，朋友们的兴趣爱好，好像因为这些实体的累积之后，人开始有了自己前进的方向和动力，同时，也不断向前，不断开拓创新，并能够创造出一点什么。类用于表示要在应用程序中处理的实际事物。每个实体所包含的一组组性质和行为，在OOP中分别称为字段和方法，它们定义了实体的同时，也开始慢慢能够成就实体。PHP中一般的类创建语法如下：
    class Class_Name
    { //字段声明
    //方法声明
    }
    如下是一个表示员工的类。
    class Employee
    {
    private $name;
    private $title; 通过private对$name和$title进行限制，表示私有的，只有本类，也就是类Employee内部才可以使用。
    protected $wage; 通过protected对$wage进行限制，表示受保护的，只有本类，也就是类Employee或这个类的子类或父类中可以访问。在子类中可以通过self::属性名（或方法名）调用protected方法或属性，通过parent::属性名（或方法名）调用父类方法。

    protected function clockIn(){
    echo “Member $this->name clocked in at”.date(“h:i:s”);
    protected function clockOut(){
    echo “Member $this->name clocked out at”.date(“h:i:s”);
    }
    }
    这个类名为Employee,定义了3个字段name,title和wage。还定义了两个方法：clockIn(签到)和ClockOut(签离)。
    类其实提供了一个基础，可以创建一些跟实体有关的特定实例，这些特定实例成为对象。例如对于员工类Employee类，所谓的特定实例就比如郎郎和赵贤等等其他的员工，如果这些员工和朋友们还在的话。根据一些已经预先定义好的类来创建对象常称为类的实例化。
    对象使用new关键字创建，如下：$employee=new Employee();创建了对象之后，这个刚实例化的对象就具有了类所定义的所有性质和行为。

    在声明字段的时候，可以为字段赋初值。
    class Employee
    {
    public $name=”John”;
    private $wage;
    }
    与变量不同，字段要使用->操作符引用。字段与给定对象之间的对应关系：
    $object->field
    当然，对于创建了一个名为$employee的Employee类型对象，就可以如下引用这些字段：
    $employee->name
    $employee->title
    $employee->wage
    对于$this而言，它表示要引用当前类（要访问或操作的字段所在的类）中的字段。
    function setName($name)
    { $this->name=$name; $this其实就相当于引用了原先的Employee类。
    }
    类和对象，是不是可以这样来理解，我定义了一个抽象的类的概念来包含数据元素和相应的实现方法，我只是想要证明自己不单单只是因为特殊，因为抽象而存在，其实，都只是为了更好地对数据，对各种方法进行整理和收集。最后，代码写完之后，再重新阅读代码的时候，才会发现，类也好，对象也罢，都仅仅只是一种表现数据逻辑的手段，而不仅仅只是肤浅的理解而已。

顶

    PHP支持5种字段作用域，public,private,protected,final和static。
    可以通过在字段前面使用关键字public来声明公共作用域中的字段。
    class Employee
    {
    public $name;
    }
    公共字段可以由相应的对象直接操作和访问。就像公共场所一样，每个人都能够进入，同时每个人都可以随时离开，因为，这个公共场所是免费的，是不需要额外支付什么费用的。免费的可以出入的场所。就像网上那些可以免费下载的电子书一样，只要你下载了，你就可以无限制地阅读这些电子书而不需要支付任何费用。公共的嘛，就是这个道理。

    $employee=new Employee(); 创建一个Employee类的新的对象
    $employee->name=”Mary Swanson”; 设定employee这一个对象的公共属性name为一个特定的名称。
    $name=$employee->name; 重新将该对象的name属性赋值给$name。
    echo “New employee:$name”;
    执行这段代码将得到：
    New employee:Mary Swanson

    private字段只能在定义字段的类中访问。也就是在定义字段的本类中使用和访问。
    class Employee
    {
    private $name;
    private $telephone;
    }
    指定为私有的字段不能由实例化的对象直接访问，也不能由其子类使用。私有，就是自己所拥有的，新的自己，新的人当然无法共享，即便，是跟自己同类型的也不行。其实，这在现实中是一种跟个人信仰有关的事，同时，也没有人会责备。

    下面的例子通过一个公共方法操作一个私有字段：
    class Employee
    {
    private $name;
    public function setName($name){ 定义一个公有的方法，操作这个私有的成员$name。
    $this->name=$name;
    }
    }
    $staff=new Employee;
    $staff->setName(“Mary”); 定义类Employee的新的对象$staff，然后通过公共的方法setName操作这个私有的成员，并将它赋值为Mary。

    在本类和继承本类的子类所能够使用的字段，就是protected所修饰的字段和变量。所以，如果希望扩展类，就应当使用保护字段而不是私有字段。

    在为字段设置final作用域时，将阻止在子类中覆盖这个字段。从中文解释里理解，我这个字段是最后的，最终的，无法被修改的，确实，确实可以这样来理解。当然，也可以将方法声明为final的。

顶

    OOP提供了很多强大的特性，属性就是一个很有说服力的例子。声明两个函数getName（）和setName()，为属性name分别创建获取方法和设置方法。
    boolean __set([string property name],[mixed value_to_assign]),它接受一个属性名和相应的值作为输入，如果方法成功执行就返回TRUE，否则返回FALSE。示例如下：
    class Employee
    {
    var $name;
    function __set($propName,$propValue)
    {
    echo “Nonexistent variable: \$$propName!”;
    }
    }
    $employee=new Employee(); 定义了一个新的对象$employee
    $employee->name=”Mario”; 设定对象employee的属性名name为Mario
    $employee->title=”Executive Chef”; 设定对象employee的职位为主厨
    可以得到如下输出:
    Nonexistent variable:$title! 其实是在调用$employee->title，到原来的类中一查，发现根本就没有title这个属性存在，然后，原来函数中的\$$propName就变成了$title。

    当然可以使用这个方法来扩展类，使之增加新的属性，如下：
    class employee
    {
    var $name;
    function __set($propName,$propValue) 这个函数中设定两个参数$propName和$propValue
    {
    $this->$propName=$propValue;
    }
    }
    $employee=new Employee(); 创建一个新的对象$employee
    $employee->name=”Mario”; 设定该对象$employee的属性name为Mario
    $employee->title=”Executive Chef”; 设定该对象的职位title为Executive Chef
    echo “Name:”.$employee->name; 打印对象的name属性
    echo “<br/>”;
    echo “Title:”.$employee->title; 打印对象$employee的职位title
    这将得到:
    Name:Mario
    Title:Executive Chef 这里的Name和Title就对应了$employee对象所对应的name属性和title属性。

    boolean __get([string property name])
    class Employee
    {
    var $name;
    var $city;
    protected $wage;
    function __get($propName)这里传入函数的属性$propName对应了之前在类中定义的三个属性
    { echo “__get called!<br/>”;
    $vars=array(“name”,”city”);
    if(in_array($propName,$vars)) 这里的$vars就是之前类中的三个属性所对应的三个值。
    return $this->$propName;
    }else{
    return “No such variable!”;
    }
    }
    }
    $employee=new Employee();
    $employee->name=”Mario”;
    echo $employee->name.”<br/>”;
    echo $employee->age;
    结果如下：
    Mario
    __get called!
    No such variable!其实是在调用$employee->age时，在函数__get中先发现是一个属性，调用了echo “__get called!<br/>”,然后发现该属性age并不是该类中已经定义的三个属性中的一个，所以就调用了else语句之后的”No such variable!”。其实说白了，类中的属性也好，函数也好，都是有一定的规律可以摸，可以揣摩和认真理解的。你可以定义属于你自己的类中的属性和函数，如果，你认为需要的话，你就可以尝试使用。

顶

    <?php
    class Employee
    {
    private $name;
    //对应的get方法
    public function getName(){
    return $this->name; //其实$this之所以在PHP中出现，就是为了在类本身内部使用本类的属性或者是方法，这里通过$this->name调用Employee类的私有成员$name。
    }
    //对应的set方法
    public function setName($name){
    $this->name=$name;
    }
    }
    ?>
    在类中可以定义常量，用来表示不会改变的值。类常量如下创建:
    const NAME=”VALUE”;
    class math_functions
    {
    const PI=”3.14159265”;
    const E=”2.7182818284”;
    const EULER=”0.577156649”;
    定义了三个常量
    }
    然后就可以像下面这样使用类常量：
    echo math_functions::PI; 这样就打印输出了该类中的常量PI。
    方法的调用与函数相同，只是在方法前面要加上调用方法的对象的名称。
    $object->method_name();
    例如，名为calculateSalary()的公共方法如下:
    public function calculateSalary(){
    return $this->wage*$this->hours; 这里直接通过$this关键字直接调用了类的两个字段:wage和hours。
    }
    当然可以如下调用calculateSalary()方法:
    $employee=new Employee(“Janie”); 创建一个新的员工对象,命名为Janie。
    $salary=$employee->calculateSalary(); 调用该对象的calculateSalary方法。
    PHP支持6中方法作用域，public,private,protected,abstract,final和static。
    公共方法可以在任何位置任何时间访问。
    <?php
    class Visitors
    {
    public function greetVisitor（）
    { echo “Hello<br/>”;
    }
    function sayGoodbye()
    {
    echo “Goodbye<br/>”;
    }
    }
    Visitors::greetVisitor(); 因为greetVisitors是公共方法，所以通过该类Visitors，通过::直接访问。
    $visitors=new Visitors();
    $visitors->sayGoodbye(); 因为sayGoodbye不是公共方法，所以通过创建一个新的类Visitors的对象，然后调用该对象的sayGoodbye方法来实现打印输出Goodbye的功能。
    ?>

    标记为private的方法只能在类内部使用，不能由实例化的对象调用，也不能由类的子类使用。
    标记为protected的类方法只能在该类及其子类中使用。
    <?php
    class Employee
    {
    private $ein;
    function __construct($ein) 定义了一个构造函数
    {
    If($this->verifyEIN($ein)){ 通过$this关键字调用本类中的verifyEIN方法。
    Echo “EIN verified.Finish”;
    }
    }
    protected function verifyEIN($ein)
    {
    return TRUE;
    }
    }
    $employee=new Employee(“123-45-6789”); 创建一个新的对象，然后赋给该对象一个相应的数值。
    ?>
    试图从类外部调用verifyEIN()将导致致命错误。因为该方法具有保护作用域。其实，并不是访问修饰符改变了类中的那些属性，当然，仅仅只是为了在定义函数的时候能够更加有效地调用和处理这些属性所赋予的那些值。当你尝试想要改变你自己的各种属性的时候，你也可以尝试做出更多的和更好的决定，很久很久，同时也很远很远。

顶

    抽象方法很特殊，只在父类中声明，但在子类中实现。只有声明为abstract的类可以声明抽象方法。如果想定义一个应用编程接口（API），以后作为实现的一个模型，就可以声明一个抽象方法。抽象方法如下声明：
    abstract function methodName();
    这里创建一个抽象Employee类，它可以作为其他一些员工类型（经理，职员，出纳等）的基类：
    abstract class Employee
    {
    abstract function hire();
    abstract function fire();
    abstract function promote();
    abstract demote();
    }你会很明显的发现这个抽象类中都是抽象方法，确实，抽象，顾名思义，就是一种跟概念相关的东西，关键，还是如何去定义和实现这个概念。这个抽象类Employee写出之后，以后，各个员工类（如经理，职员和出纳）可以再分别扩展这个类。
    标记为final的方法，顾名思义，已经是最终的和最后的了，所以，可以防止被子类覆盖。final方法声明如下:
    class Employee
    {
    final function getName(){
    }
    }定义了这个final方法之后，以后如果试图覆盖final方法都会产生致命错误。
    构造函数对应对象的创建，析构函数对应对象的撤销。它们将在对象的创建和撤销过程中自动执行。构造函数其实也就是对象实例化时自动执行的一段代码。
    PHP通过名称__construct来识别构造函数。构造函数声明的一般语法如下：
    function __construct([argument1,argument2,...,argumentN])
    {
    //该类的初始化代码
    }
    <?php
    Class Book
    {
    private $title;
    private $isbn;
    private $copies; 定义了三个私有的属性
    public function __construct($isbn)
    {
    $this->setIsbn($isbn); 通过$this调用Book类中的公共方法setIsbn。之所以用$this来调用这些函数，其实都是为了用到刚才在这个类中定义好的三个私有属性。
    $this->getTitle();
    $this->getNumberCopies();
    }
    public function setIsbn($isbn)
    {
    $this->isbn=$isbn; 通过$this指向本类中的私有属性$isbn
    }
    public function getTitle(){
    $this->title=”Beginning Python”;
    print “Title:”.$this->title.”<br/>”;
    }
    public function getNumberCopies(){
    $this->copies=”5”;
    print “Number copies available:”.$this->copies.”<br/>”;
    }
    }
    $book=new Book(“159059519X”);定义了Book类的一个对象$book，然后赋值为159059519X。
    ?>
    以上代码将会得到：
    Title:Beginning Python
    Number copies available:5
    之所以会显示出这两行英文其实是因为在这个Book类创建的时候自动调用了构造函数__construct，同时也调用了里面的三个方法。然后其中的两个方法就输出了以上的两行英文显示。
    PHP不会自动调用父类的构造函数，必须使用parent关键字显式地调用。示例如下：
    <?php
    class Employee
    {
    protected $name;
    protected $title; 之所以定义为protected受保护的类型，是为了之后继承该类的时候还能够用到这两个被保护的属性。
    function __construct()
    {
    echo “

Staff constructor called

”;
    }
    }
    class Manager extends Employee
    {
    function __construct()
    {
    parent::__construct();
    echo “

Manager constructor called

”;
    }
    }
    $employee=new Manager();
    ?>
    以上代码会得到:
    Employee constructor called!
    Manager constructor called!
    之所以会出现这两行英文是因为Manager类中的parent::__construct();调用了Employee类中的__construct()函数，然后通过这个函数打印输出了第一行的英文。
    当然也可以调用与实例化对象没有任何关系的类构造函数，只需在__constructor前面加上类名即可，如下：
    classname::__construct()
    构造函数，更加简单一点的解释就是，想要构造出一点对程序有用或者是有关联的代码，让某个特定的类实现之后能够自动执行一些功能，就像造房子一样，造房子之前要把房子的地基造好，而且是自动的，必须的。你想要靠你自己的力量构造一些东西的时候，就需要通过你自己的努力尝试实现一些东西，或者是创造一些东西。

顶

    PHP中的析构函数名必须是__destruct()。在脚本执行结束后对象会自动撤销。
    <?php
    class Book
    {
    private $title;
    private $isbn;
    private $copies;
    function __construct($isbn)
    {
    echo “

书的实例创建.

”; 这个类Book创建之后自动调用构造函数__construct，并传入私有参数$isbn，同时打印这一段文字。
    }
    function __destruct()
    {
    echo “

书的实例被销毁了.

”; 这个类Book在销毁的时候自动调用__destruct,同时也打印另外一段文字。
    }
    }
    $book=new Book(“1893115852”); 创建Book类的一个对象$book，并传入一个值1893115852。
    ?>
    结果为：
    书的实例创建.
    书的实例被销毁了.
    脚本执行结束时，PHP会撤销内存中的所有对象。
    <?php
    class Visitor
    {
    private static $visitors=0; 访问者数量$visitors之所以设置为static的，是为了之后调用的时候能够一直保持着一定的访问数，而不用把访问者数量重置为0。
    function __construct()
    {
    self::$visitors++;通过self调用私有静态成员$visitors。
    }
    static function getVisitors()
    {
    return self::$visitors;
    }
    }
    $visitors=new Visitor(); 初始化Visitor类.
    echo Visitors::getVisitors().”<br/>”;通过对象Visitors的::调用静态函数getVisitors
    $visits2=new Visitor(); 实例化另外一个Visitor类
    echo Visitor::getVisitors().”<br/>”;
    ?>
    结果如下:
    1
    2
    其实是因为创建了两个对象，两个对象都调用了静态的函数getVisitors，然后实现了静态的属性$visitors从0到1，从1到2的自增，其实主要是在构造函数中真正实现自增的。静态的成员，因为数值可以一直保存下来，所以，可以实现一些特定的，可以保护数据不被改变或者是修改的功能。因为$visitors字段声明为static，所以对其值的任何改变，（在这里通过类构造函数来修改）都会反映到所有实例化对象中。还要注意，静态字段和方法应使用self关键字和类名来引用，而不是通过this和箭头操作符。
    PHP5的另一个新成员是instanceof关键字，使用这个关键字可以确定一个对象是类的实例，类的子类，还是实现了某个特定接口，并进行相应的操作。
    $manager=new Employee();
    ...
    if($manager instanceof(Employee) echo “Yes”;
    判断对象$manager是否是类Employee的实例。如果是的话，打印出Yes。
    构造函数为了创建，而析构函数是为了销毁，静态的成员其实一直都会存在着。静态变量只存在于函数作用域内，一般的函数内变量在函数结束后会释放，但是静态变量在下次再调用这个函数的时候，该变量的值会保留下来。我一直都在，如果你能够想到我这个静态挚友的话，你随时可以回来找我，而且我完全不会改变我原来对于你的很多看法和评价。

顶

    很多函数可以用来帮助开发人员管理和使用类库,PHP之所以有趣，就是因为有着这么多的函数在点缀，在修饰，学习这些函数的时候看似非常枯燥，但其实，这种学习的过程对于很多特定的人来说，未尝不是一种享受也不一定。

    确定类是否存在。
    boolean class_exists(string class_name)
    通过传入的参数class_name从上下文中判断是否存在相应的类，如果是，该函数返回TRUE，否则返回FALSE。从这个函数名class_exists就能够从英文意思知道这个函数的大致作用，PHP中很多的函数都可以通过英文名翻译成中文名之后来揣摩大致的意思。
    确定对象上下文。
    string get_class(object object)
    get_class函数返回object所属类的类名。
    了解类方法
    array get_class_methods(mixed class_name)
    其中的参数class_name代表class_name类中定义的所有方法名。返回的类型是一个数组，用来存放该类中定义的所有方法名。
    array get_class_vars(string class_name)
    参数class_name代表相应的类中所定义的所有字段名及其相应的值。
    array get_declared_classes(void)
    函数get_declared_classes返回一个数组，其中包含当前执行脚本中定义的所有类名。
    array get_object_vars(object object)
    get_object_vars()返回一个关联数组，其中包含object可用的已定义字段及其相应的值。
    string get_parent_class(mixed object)
    get_parent_class()函数返回object所属类的父类名。从该函数get_parent_class的中文意思就可以大致揣摩出这个函数的作用来。返回值类型是一个字符串，用来存放object所属类的父类名。
    boolean interface_exists(string interface_name[,boolean autoload])
    interface_exists()函数确定一个接口是否存在。返回值是一个布尔类型。
    boolean is_a(object object,string class_name)
    对象object属于class_name类时，或者属于class_name的一个子类时，is_a()函数返回TRUE。
    boolean is_subclass_of(object object,string class_name)
    如果object属于继承自class_name的类时，is_subclass_of()函数返回TRUE。
    boolean method_existed(object object,string method_name)
    object中有名为method_name的方法时，method_existed()返回TRUE。
    PHP5中引入了自动加载对象的概念。自动加载通过定义特殊的__autoload函数。
    function __autoload($class){
    require_once(“classes/$class.class.php”);
    }定义了这个函数后，将不再需要那些require_once()语句。因为当第一次调用一个类时，就会调用__autoload()，并根据__autoload()中定义的命令加载类。从autoload这个英文的大致意思就可以体会到这个函数真正的作用到底在哪里。
    其实，这些辅助函数真正的作用是让作为学习者和开发者的你学会如何更加有效率地去进行开发，同时，也通过这一段时间，让读着这本书的你们都会非常直接地意识到，原来，PHP就是靠着这么多的函数在支撑着，同时也有越来越多的人开始察觉到，原来，PHP其实挺有趣的，看似枯燥乏味中的有趣。

顶

    可以在对象前面加clone关键字来克隆对象，如下：
    destinationObject=clone targetObject;
    使用clone关键字克隆对象
    <?php
    class Corporate_Drone{
    private $employeeid;
    private $tiecolor;
    定义两个私有成员
    function setEmployeeID($employeeid){
    $this->employeeid=$employeeid;
    }
    function getEmployeeID(){
    return $this->employeeid;
    }
    为变量$employeeid定义一个set和get方法

    接下去为变量$tiecolor定义一个set和get方法
    function setTieColor($tiecolor){
    $this->tiecolor=$tiecolor;
    }
    function getTieColor(){
    return $this->tiecolor;
    }
    }
    创建一个新的Corporate_Drone对象
    $drone1=new Corporate_Drone();
    设置$drone1 employeeid成员的员工ID号
    $drone1->setEmployeeID(“12345”);
    设置$drone1 tiecolor成员的颜色
    $drone1->setTiecolor(“red”);
    克隆$drone1对象
    $drone2=clone $drone1;
    设置$drone2的employeeid的员工ID
    $drone2->setEmployeeID(“67890”);
    最后打印输出$drone1和$drone2的employeeid成员的相关信息
    printf(“drone1 employeeID:%d<br/>”,$drone1->getEmployeeID());
    printf(“drone1 tie color:%s <br/>”,$drone1->getTieColor());
    printf(“drone2 employeeID:%d<br/>”,$drone2->getEmployeeID());
    printf(“drone2 tie color:%s<br/>”,$drone2->getTieColor());
    其中的%d和%s大家应该还没有忘记吧，分别代表带符号十进制数和字符串。
    ?>
    执行此代码返回如下输出：
    drone1 employeeID:12345
    drone1 tie color:red
    drone2 employeeID:67890
    drone2 tie color:red
    之所以drone2对象的color属性为red,是因为执行了$drone2=clone $drone1;这条语句，同时还通过$drone1->setTiecolor(“red”);这条语句将$drone1的tiecolor的颜色预先设置为了red。
    然后$drone2克隆了$drone1的这个颜色属性，所以，获得了相同的颜色属性。所以，在打印输出的时候，颜色都是red。

    同时还可以在对象类中定义一个__clone()方法来调整对象的克隆行为。
    使用__clone()方法扩展克隆功能
    创建一个新的Corporate_Drone对象
    <?php
    class Corporate_Drone{
    private $employeeid;
    private $tiecolor;
    定义两个私有成员
    function setEmployeeID($employeeid){
    $this->employeeid=$employeeid;
    }
    function getEmployeeID(){
    return $this->employeeid;
    }
    为变量$employeeid定义一个set和get方法
    接下去为变量$tiecolor定义一个set和get方法
    function setTieColor($tiecolor){
    $this->tiecolor=$tiecolor;
    }
    function getTieColor(){
    return $this->tiecolor;
    }
    function __clone(){
    $this->tiecolor=”blue”;
    }

    }

    $drone1=new Corporate_Drone();
    设置$drone1的employeeid成员的ID号
    $drone1->setEmployeeID(“12345”);
    克隆这个$drone1对象
    $drone2=clone $drone1;
    设置$drone2 employee成员的员工ID
    $drone2->setEmployeeID(“67890”);
    输出$drone1和$drone2的employeeid成员属性
    printf(“drone1 employeeID:%d<br/>”,$drone1->getEmployeeID());
    printf(“drone2 employeeID:%d<br/>”,$drone2->getEmployeeID());
    printf(“drone2 tie color:%s<br/>”,$drone2->getTieColor());
    执行此代码将返回如下输出：
    drone1 employeeID:12345
    drone2 employeeID:67890
    drone2 tie color:blue
    之所以drone2 tie color:blue会输出blue是因为在克隆$drone2=clone $drone1;调用了function __clone()函数，然后再调用了$this->tiecolor=”blue”;所以最后输出的时候颜色被调整为了blue。

顶

    为了考虑到开发时的效率，OOP开发范型考虑了这一点，允许继承现有的类，根据现有的类创建新类。在PHP中，类继承通过extends关键字实现。继承自其它类的类称为子类，子类所继承的类称为父类或基类。就跟父母跟子女的关系是一样的道理，子女必然继承父母的一些特性，同时也拥有着属于自己的一些个性。血浓于水，同时也因为血缘关系跟继承关系的共性，让PHP开始变得越来越有趣，也越来越有生命力。
    <?php
    定义一个父类，Employee类
    class Employee{
    private $name;
    定义一个私有属性$name
    为私有属性$name定义一个setter方法
    function setName($name){
    if($name==””) echo “Name cannot be blank!”;
    如果$name为空，打印名称不能够为空的提示。
    else $this->name=$name;
    否则通过$this关键字指向本类中的私有成员name属性
    }
    为私有成员$name定义一个getter方法
    function getName(){
    return “My name is”.$this->name.”<br/>”;
    }
    } 终止Employee类
    定义一个类继承Employee类
    class Executive extends Employee{
    定义一个跟Employee有点另类，有个性的方法
    function pillageCompany(){ 定义一个掠夺公司财产的函数
    echo “I’m selling company assets to finance my yacht!”;
    打印我为了购买游艇不择手段地在买卖公司的财产。其实也就是贪污的行为。
    }
    }Executive类结束
    创建一个新的Executive类的对象
    $exec=new Executive();
    调用定义在Employee类中的setName()方法，并设置一个英文名Richard
    $exec->setName(“Richard”);
    调用getName()方法
    echo $exec->getName();
    调用pillageCompany()方法
    $exec->pillageCompany();
    ?>
    返回如下结果:
    My name is Richard.
    I’m selling company assets to finance my yacht!
    这一句话中的Richard是通过Executive类创建了一个新的对象$exec之后，调用了原来的父类Employee中的setName和getName，然后通过$exec->setName(“Richard”);这句话设定好了新的员工姓名，最后就打印输出了这一句话。返回的第二句话其实是通过$exec->pillageCompany();实现打印输出的。

    同时再给出一个继承自Executive的CEO类：
    <?php
    class Employee{
    ...
    }
    class Executive extends Employee{
    ...
    }
    class CEO extends Executive{ 定义一个CEO类继承自Executive类
    function getFacelift(){ 定义一个CEO所特有的函数
    echo “nip nip tuck tuck”;
    }
    }
    $ceo=new CEO();
    定义一个CEO类的对象$ceo
    $ceo->setName(“Bernie”);
    调用$ceo对象的setName方法，设定名字为Bernie
    $ceo->pillageCompany(); 调用$ceo对象的贪污公司财产的函数。打印输出一段英文
    $ceo->getFacelift();同样，调用$ceo对象所特有的方法。

顶

    如果父类有构造函数，而且子类没有构造函数，那么在子类实例化时确实会执行父类构造函数。
    例如，假设Employee类有如下构造函数:
    function __construct($name){
    $this->setName($name);
    }
    然后，实例化CEO类，获得其name成员：
    $ceo=new CEO(“Dennis”);
    echo $ceo->getName();
    将得到如下结果：
    My name is Dennis
    但是，如果子类也有构造函数，那么当子类实例化时，不论父类是否有构造函数，都会执行子类自己的构造函数。可以这样来理解，儿子总会有自己的一些天赋，就算不是继承自父亲，当然，当儿子想要做一些事，或者想要做成功一些事的时候，父亲的一些特质或者是天赋并不一定能够体现出来，这个时候，就是儿子自己的努力在起作用了。如果你觉得你还算是可以的儿子或者是女儿，那就请拿出属于你自己的认真和努力来对待这本书好了，如果，你觉得这本书还算是可以的话。

    例如，假设除了Employee类包含上述构造函数外，CEO类也包含如下构造函数：
    function __construct(){
    echo “

CEO object created!

”;
    }
    然后实例化CEO类：
    $ceo=new CEO(“Dennis”);
    echo $ceo->getName();
    这时将得到如下结果，因为CEO的构造函数覆盖了Employee构造函数：
    CEO object created!
    My name is
    为什么My name is后面没有跟上名字呢，是因为并没有执行Employee的构造函数，相应地也就没有执行其中的setName()方法。当然，如果你非常希望名字也能够输出的话，那么只需要如下修改CEO的构造函数：
    function __construct($name){
    parent::__construct($name); 沿着父类向上搜索合适的构造函数，直到Employee类，并调用其中的$name属性。调用相应的set和get方法进行name属性的设置。parent顾名思义，就是调用父类的意思。
    echo “

CEO object created!

”;
    }
    再来实例化CEO类，以同样的方式执行getName(),这次将得到不同的输出:
    CEO object created!
    My name is Dennis
    例如，假设创建CEO对象时，Employee和Executive的构造函数都要执行，可以在CEO的构函数中显示地引用这些构造函数，如下：
    function __construct($name){
    Employee::__construct($name);
    Executive::__construct();这两行代码就是显示地引用Employee类和Executive类的构造函数。
    echo

CEO object created!

”;
}
其实，开一个小玩笑，PHP这一门语言，从严格意义上来讲，它其实跟其他编程语言是共通的，理论性的东西其实却是应该跟代码混合在一起学习，其实，我也在认真学习，认真揣摩，当然，其实，我希望读者的你，和写作者的我，都能够通过这本书，有一定的收获，同时，也在收获之余，有着一定的成就感。成就感，很多时候能够通过书的方式有所表现，并真正地体现出来，如果，你们跟我有着一样的感悟的话，那或许，你就很容易通过这本书收获更多。

不好意思，理论性的东西其实确实应该跟代码混合在一起学习。之前更新的出现两个错别字。今天兴致来了就多更新一些。

    接口定义了实现某种服务的一般规范，声明了所需的函数和常量，但不指定如何实现。接口中不定义类成员，类成员的定义完全交给实现类来完成。接口是一种特殊的抽象类，接口中的所有方法都是抽象方法。为什么特殊，那是因为你所定义的类不能够继承接口，而只能够实现接口。如果能够在现实跟梦境的交界地带还能够敲打属于你自己的，你所定义的那些接口的代码，并不一定代表你有多勤奋，只能够客观地证明一个小点，你还只是足够认真而已，而不仅仅只是专注在学习PHP，学习这一门编程语言。

    例如，拿侵占公司财物作为例子，接口可能只包括两个方法：
    emptyBankAccount()
    burnDocuments() 空的银行账户和烧毁文件两个方法
    然后可以要求Employee和Executive类实现这些特性。在PHP中，要这样创建接口：
    interface interfaceName 通过interface的方式声明一个接口
    {
    CONST 1;
    ...
    CONST N;
    通过CONST关键字在接口中声明了N个常量。
    function methodName1();
    ...
    function methodNameN();
    }
    在接口中定义了N个方法。

    当类通过implements关键字实现了接口后，就完成了一个契约。接口中的所有方法都必须实现，倘若实现类没有实现所有方法，则必须声明为抽象类。
    以下是实现上述接口的一般语法：
    class Class_Name implements interfaceName
    {
    function methodName1()
    {
    methodName1()的实现细节
    }
    function methodNameN()
    {
    methodNameN()的实现细节
    }
    }
    在此创建了一个名为Ipillage的接口（用于侵占公司）。
    IPillage接口如下：
    interface IPillage
    {
    function emptyBankAccount();
    function burnDocuments();
    }
    然后通过Executive类实现此接口：
    class Executive extends Employee implements Ipillage
    {
    private $totalStockOptions;
    function emptyBankAccount()
    {
    echo “Call CFO and ask to transfer funds to Swiss bank account.”;
    打印打电话给首席财务官CFO要求她或者是他把资金转到瑞士的银行账户里去，所以，银行账户才会为空啊。真是够恶心，纯粹贪污的行为。中国的贪官污吏其实都是通过这种方式来让自己的腰包变得越来越鼓的啊。其实，这是一种现实中非常常见的现象，值得反思，也值得总结。
    }
    function burnDocuments()
    {
    echo “Torch the office suite.”;
    打印放火烧办公室的套房。
    }
    因为公司中所有级别的人都能进行侵占，所以还可以由Assistant类实现此接口：
    class Assistant extends Employee implements Ipillage
    {
    function takeMemo(){
    echo “Taking memo...”;
    }
    takeMemo是Assistant类中所特有的一个函数，必要的时候就要拿好属于你自己的备忘录哦。
    function emptyBankAccount()
    {
    echo “Go on shopping spree with office credit card.”;
    打印用办公室的信用卡购物玩乐，所以，银行账户也同样会变空啊。
    }
    function burnDocuments()
    {
    echo “Start small fire in the trash can.”;
    打印在垃圾桶里烧一把小火烧点东西，其实也就是烧一些文件。这么大胆，其实，也只不过就是一种掩饰。
    }
    }
    接口允许不同的类，以不同的方式来实现这些方法。在这个例子中，对于烧文件方法，Assistant类只是把文件在垃圾桶里烧掉，而Executive类则通过更过分的方式来做到（将办公室也烧掉是不是显得有点过分极端，偏激的行为了）。
    当然，也可以定义多个接口，并实现多个接口，
    <?php
    interface Iemployee{...}
    interface Ideveloper{...}
    interface Ipillage{...}
    class Employee implements IEmployee,IDeveloper,IPillage{
    ...
    }
    定义一个员工Employee类，实现了以上的三个接口。
    class Contractor implements IEmployee,IDeveloper{
    ...
    }
    定义一个承包商类，实现了以上的两个接口。
    ?>
    其实，你可以定义属于你自己的接口，现实跟梦境的接口，工作和休闲之余的接口，然后定义属于你自己的专属类来实现你所认为的，你的专属接口，其实，都只是为了让自己更好地理解这个概念，不单单只是因为尝试想要了解并理解，仅仅，只是因为曾经努力地尝试过，曾经努力地尝试过想要了解。

顶

    抽象类是不能实例化的类。只能作为由其他类继承的基类。在抽象类中定义的所有方法都必须在子类中实现。有些人，想象能力很强，写出了挺不错的文学作品，但是，却无法出版发行，或者是理论联系到实际，其实，这就是抽象作品，跟抽象类是一样的道理。当然，很多人可能认为这本书其实也是抽象作品，但，我认为，这本书应该是一个还算是可以的类。

    声明为抽象的类必须在定义前面加上关键字abstract，如下：
    Abstract class Class_Name
    {
    //在这里插入该类的各个属性的定义
    //在这里插入这个方法的定义
    }
    试图实例化一个抽象类时，将得到如下的错误消息:
    Fatal error:Cannot instantiate abstract class Employee in /www/book/chapter07/class.inc.php
    致命错误，无法实例化抽象类Employee在路径为/www/book/chapter07/class.inc.php的class.inc.php的文件。

    PHP可以继承多个接口，但不能扩展多个抽象类。
    class Clean{
    function FilterTitle($text){
    定义了一个过滤评论标题的函数
    return ucfirst(trim($text));
    通过trim函数将$text中的文字去掉空格，同时通过ucfirst函数将$text第一个字母大写
    }
    class Clean{
    function RemoveProfanity($text){
    定义一个删除不文明语言的函数，作为过滤器
    $badwords=array(“idiotic”=>”shortsighted”,
    将愚蠢的过滤为目光短浅的
    “moronic”=>”unreasonable”,
    将白痴的过滤为不合理的
    “insane”=>”illogical”);
    将疯狂的过滤为不合逻辑的

    然后删除那些不好的言语
    return strtr($text,$badwords);
    strtr()函数转换字符串中特定的字符，这里是将$text中的内容替换为$badwords中的内容。
    }
    }
    <?php
    include “Library.php”;
    include “Data.php”;
    先通过include语句包含两个最必要的php文件
    $filter=new Library::Clean();
    实例化这个Library中的Clean类
    $profanity=new DataFilter::Clean();
    实例化这个DataFilter中的Clean类
    $title=”the idiotic sun also rises”;
    创建一本书的标题，标题的意思为这个愚蠢的太阳还是照旧升起。
    printf(“Title before filters:%s<br/>”,$title);
    在过滤发生之前输出书名的标题
    然后通过调用$profanity这个对象中的RemoveProfanity函数过滤标题中的不文明语言
    $title=$profanity->RemoveProfanity($title);
    printf(“Title after Data::Clean:%s<br/>”,$title);
    同时通过调用$filter对象中的FilterTitle方法，删除$title中的空格和将标题的首字母大写
    $title=$filter->FilterTitle($title);
    printf(“Title after Library::Clean:%s<br/>”,$title);
    ?>
    执行这个脚本将生成以下输出:
    Title before filters:the idiotic sun also rises这一句话对应之前代码中的printf(“Title before filters:%s<br/>”,$title);，打印输出了这一段英文和$title中的英文。

    Title after Data::Clean:the shortsighted sun also rises这一句话对应之前代码中的printf(“Title after Data::Clean:%s<br/>”,$title);，$title中的不文明语言idiotic被替换为了shortsighted。

    Title after Library::Clean:The Shortsighted Sun Also Rises这一句话对应之前代码中的printf(“Title after Library::Clean:%s<br/>”,$title);将过滤了不文明言语之后的$title的每个单词的首字母大写。

顶

    在程序员的语言中，这些意料之外的事件称为异常，有些编程语言通过放一个代码段来处理错误，能够对异常妥善地做出响应，这称为抛出异常。接下来，错误处理代码取得异常的所有权，即捕获异常。在写作的时候，其实很多时候也会遇到很多很奇怪的问题，写作的思路不清晰的时候很多情况下都会变得挺恶心，其实，我们应该学会适应更多，同时也能够让我们自己通过这些看似奇怪的事件成熟起来，同时也成长起来。
    ?
    下面是一个简单的异常处理的伪代码例子：
    try{
    如果出现问题了做一些事
    throw exception(“Something bad happened”)
    //捕获所抛出的异常
    }catch(exception){
    输出异常消息
    }
    下面基于前面的伪代码式例，使用假想的处理器类来管理与I/O和除法有关的错误。
    try{
    perform some task
    if something goes wrong
    throw IOexception(“Could not open file.”)
    抛出无法打开文件的IO异常
    if something else goes wrong
    throw Numberexception(“Division by zero not allowed.”)
    抛出数字异常，就比如把零作为除数这种。
    //捕获IO异常
    }
    catch(Ioexception){
    输出IO异常消息
    }
    //捕获数字异常
    }catch(Numberexception){
    ?输出数字异常消息
    }
    ?
    产生一个异常的例子
    try{
    ?$fh=fopen(“contacts.txt”,”r”);
    以只读方式通过fopen函数打开contacts.txt文件
    if(!$fh){如果该$fh变量不存在的话
    throw new exception(“Could not open the file!”);
    则抛出新的异常
    }
    }
    catch(Exception $e){
    ? echo “Error (File:”.e->getFile().”,line”.$e->getLine().”):”.$e->getMessage();
    其中getFile()函数是返回抛出异常的文件名，getLine()函数是返回抛出异常的行号，getMessage()函数是返回传递给构造函数的消息。
    }
    产生异常时，将输出如下内容:
    Error(File:/usr/local/apache2/htdocs/8/read.php,line 6):Could not open the file!
    ?
    MyException类的使用
    class My_Exception extends Exception{
    ? function __construct($language,$errorcode){
    ? $this->language=$language;
    ? $this->errorcode=$errorcode;
    }定义了一个构造函数，并传入了两个变量$language和$errorcode，然后通过PHP中的$this指针指向本类中的这两个变量
    ?
    function getMessageMap(){
    $errors=file(“errors/”,$this->language.”.txt”);
    foreach($errors as $error){? 利用foreach循环语句
    list($key,$value)=explode(“,”,$error,2);通过list函数将数组当前指针所指向单元的键/值对分别赋值给变量$key,$value,然后通过explode函数将$error错误信息以，逗号分割为数组，并规定所返回的数组元素的数目为2个。
    ?
    $errorArray[$key]=$value;
    然后在通过explode函数分割之后的$errorArray数组中将相应的$key和所对应的$value进行显示。
    }
    return $errorArray[$this->errorcode];
    返回$errorArray错误数组中的错误代码
    }
    }? 终止My_Exception类
    try{
    ?throw new My_Exception(“english”,4);
    抛出新的异常
    }
    catch(My_Exception $e){
    ? echo $e->getMessageMap();
    捕获异常，并通过getMessageMap()输出相应的错误数组中的消息。
    }

本来明天早上写的，提前更新。

    <?php
    这个Invalid_Email_Exception类用来通知站点管理员这个e-mail地址被认为是无效的。
    class Invalid_Email_Exception extends Exception{
    function __construct($message,$email){
    $this->message=$message;
    $this->notifyAdmin($email); 定义了一个构造函数，传入了两个参数$message,$email。
    然后通过调用本类中的这个私有的notifyAdmin函数对邮件的地址稍微处理一下，判断是否是无效邮件。
    }
    private function notifyAdmin($email){
    mail(“admin@example.org”,”INVALID EMAIL”,$email,”From:web@example.com”);
    }
    }

    这个Subscribe类用来验证邮件地址，同时添加用户的e-mail邮件地址到数据库中。
    class Subscribe{
    function validateEmail($email){
    try{
    if($email==””){
    throw new Exception(“你必须输入一个e-mail地址!”);
    判断，如果$email地址为空，则抛出一个新的异常，同时输出一段文字。
    }else{
    list($user,$domain)=explode(“@”,$email);
    将变量$email通过@分割为一个含有两个元素的数组，并将这两个元素的内容赋值给$user和$domain。
    if(!checkdnsrr($domain,”MX”))throw new Invalid_Email_Exception(
    使用MX记录验证电子邮件地址。checkdnsrr这个函数根据不同记录类型查询主机相应的DNS记录。

    “无效的e-mail地址!”,$email);
    else
    return 1;
    }
    }catch(Exception $e){
    echo $e->getMessage();
    通过echo语句打印异常的消息内容
    }catch(Invalid_Email_Exception $e){
    echo $e->getMessage();
    }
    }
    下面这个方法大概能够添加用户的e-mail地址到数据库中。
    function subscribeUser(){
    echo $this->email.”added to the database!”;
    }
    }终止Subscribe类
    假定这个e-mail地址来源于一个订阅表单。
    $_POST[‘email’]=”someuser@example.com”;
    尝试验证并添加邮件地址到数据库中
    if(isset($_POST[‘email’])){通过isset函数判断通过POST表单提交过来的email地址是否存在
    $subscribe=new Subscribe();
    然后创建一个Subscribe类的新对象$subscribe。
    if($subscribe->validateEmail($_POST[‘email’])) 通过调用对象$subscribe的validateEmail函数来验证通过POST方式提交过来的email地址。
    {
    $subscribe->subscribeUser($_POST[‘email’]);
    然后同样，调用该对象的subscribeUser方法打印该函数中的一段话。
    }
    ?>
    其实，异常这种东西，本来就是因为一些看似人为的也好，还是一些机器或者是编程中的错误也罢而导致的，总应该尝试像捕鱼一样将这些异常全部捕获的同时，附带着也开始反思并总结一些程序员经历中必然将要经历的伤痛，并不是因为尝试想要遗忘，其实，作为程序员也好，还是在学习中的人也罢，很多时候，必然无法真正忘却，同时，我们也不仅仅只是尝试想要遗忘，其实异常这东西，是程序中必经的，同时也是必然的存在。

    正则表达式本身只是字符串模式，用于匹配某些文本。与php相反，正则表达式[php]将找到任何包含字符p或h的字符串。一些常用的字符范围如下所示。
    [0-9]，匹配任何从0到9的十进制数字。
    [a-z],匹配任何从小写a到z的字符。
    [A-Z],匹配任何从大写A到Z的字符。
    [A-Za-z],匹配任何从大写A到小写z的字符。这个匹配的范围包括大写A到Z，小写a到z。
    当然，你应该可以理解了吧，可以用[0-5]来匹配从0到5范围内的十进制数字，或者使用[b-v]
    来匹配从b到v的小写字符。更加简单一点来说，在中括号[ ]内的表示是一个范围，从哪里到哪里的一个范围。

    p+,匹配任何至少包含一个p的字符串。这其实跟热血街区里面的战力指数，A+,A-是一样的理解方式，p+，战力指数至少在p以上，也就等同于至少包含一个p。后面的这些都可以这样来理解。想要匹配或者是达到你所认为的正则表达式的熟练水平，就需要你强记，加上背，加上熟练使用了。

    p*,匹配任何包含零个或多个p的字符串。
    p?,匹配任何包含零个或一个p的字符串。
    p{2},匹配任何包含两个p序列的字符串。
    p(2,3),匹配任何包含两个或三个p序列的字符串。
    p{2,},匹配任何至少包含两个p序列的字符串。
    p$,匹配任何以p结尾的字符串。
    还有些标志可以放在字符序列的前面，或置于字符序列中间：
    ^p,匹配任何以p开头的字符串。
    [^a-zA-Z],匹配任何不包含从a-z和从A-Z字符的字符串。
    p.p,匹配任何包含字符p,接下来是任何字符，再接下来又是p的字符串。
    ^.{2}$,匹配任何只包含两个字符的字符串。
    (.*)，匹配任何被和包围的字符串（即HTML的粗体标记）。
    p(hp)*,匹配任何包含一个p，后面是零个或多个hp的字符串。
    对于一些特殊的字符，这些特殊字符就必须用反斜线(\)进行转义。
    例如，假设要搜索美元数，正则表达式如下:
    ([\$])([0-9]+)这里分析一下，([\$])代表一个美元符,通过\$对美元符$进行转义，([0-9]+)代表一个或多个整数。这个正则表达式可以匹配$48,$680和$4。

    为了编程方便，可以使用一些预定义的字符范围，称之为字符类，标准的字符类包括以下几个。
    [:alpha:],小写和大写字母字符，也可以指定为[A-Za-z]。
    [:alnum:],小写和大写字母字符以及数字。也可以指定为[A-Za-z0-9]。
    [:cntrl:],控制字符，如制表符，退格符或反斜线。
    [:digit:],0到9的数字，也可以指定为[0-9]。
    [:graph:],从ASCII 33到126范围内的可打印字符。
    [:lower:],小写字母字符，也可以指定为[a-z]。
    [:punct:],标点符号字符，包括:~ ` @ # $ % ^ & * ( ) - _ + = { } [ ] : ; ! ‘ < > , . ?和/。
    [:upper:],大写字母字符，也可以指定为[A-Z]。
    [:space:],空白字符，包括空格，水平制表符，垂直制表符，换行，换页或回车。
    [:xdigit:],十六进制字符。也可以指定为[a-fA-F0-9]。

    ereg()函数在string中以区分大小写的方式搜索pattern,如果找到则返回TRUE,否则返回FALSE。
    其形式为:
    boolean ereg(string pattern,string string[,array regs])
    <?php
    $username=”jasoN”;
    if(ereg(“([^a-z])”,$username))
    判断变量$username中如果不包含从a-z字符的字符串。^这个符号如果在[]内部就是非的意思。
    echo “username必须所有小写!”;
    else
    echo “username已经所有小写了!”;
    ?>
    在此，ereg()将返回TRUE，因此会输出错误消息username必须所有小写!

其中，有一部分显示错误，(.*)，匹配任何被和包围的字符串（即HTML的粗体标记）。这里面之所以(.*)还有和会显示为粗体，是因为用到了b作为显示粗体的方式，在天涯论坛会把b显示为粗体，之前的代码中偶尔也有类似的显示问题。还有之前的list($user,$domain)=explode(“”,$email);这一段，其实是通过explode函数将变量$email通过“at”作为分隔符分割为数组。“at”好像在天涯论坛也显示错误。天涯论坛原来显示错误的东西满多的。

顶

    还有一个可选的输入参数regs，它包含一个数组，其中包括使用正则表达式中小括号分组的所有匹配表达式。利用此数组，可以将URL分成几部分。如下：
    <?php
    $url=”http://www.apress.com”;
    将$url分解为3个不同的部分
    也就是”http://www”,”apress”和”com”
    $parts=ereg(“^(http://www)\.([[:alnum:]]+)\.([[:alnum:]]+)”,$url,$regs);
    这个正则表达式分解一下，^http://www是匹配任何以http://www开头，反斜线\.是对应了之前http地址中的点.，([[:alnum:]]+)的意思是至少包含一个小写和大写字母字符以及数字。通过这个正则表达式将原先的http地址分割为3个部分。
    echo $regs[0]; 输出整个字符串http://www.apress.com
    echo “br/>”;
    echo $regs[1]; 输出http://www,这其中$regs数组中就保存着通过正则表达式分解之后的所有字符串，也包括原先的字符串。
    echo “<br/>”;
    echo $regs[2]; 输出”apress”
    echo “<br/>”
    echo $regs[3]; 输出”com”
    ?>
    这会返回:
    http://www.apress.com
    http://www
    apress
    com
    eregi()函数搜索一个预定义的模式的字符串时不区分大小写。其形式为：
    int eregi(string pattern,string string,[array regs])
    此函数在检测字符串（如密码）的有效性时很有用，例子如下：
    <?php
    $pswd=”jasonasdf”;
    定义了一个由9个字符组成的字符串
    if(!eregi(“^[a-zA-Z0-9]{8,10}$”,$pswd))
    这个正则表达式的含义是以小写大写英文字母数字开头，数量控制在8到10个，同时也同样以小写大写英文字母数字结尾。
    echo “Invalid password!”;
    else
    echo “Valid password!”;
    ?>
    在此例中，用户必须提供由8到10个字符组成的字母数字密码，否则将显示一条错误消息。
    ereg_replace()函数的操作与ereg（）相似，只是它的功能扩展成为不仅会查找pattern,还要用replacement替代pattern。其形式为:
    string ereg_replace(string pattern,string replacement,string string)
    如果没有找到匹配部分，字符串就保持不变，与ereg()一样，ereg_replace()是区分大小写的。
    $text=”This is a link to http://www.wjgilmore.com/.”;
    echo ereg_replace(“http://[a-zA-Z0-9./-]+)$”,”<a href=\”\\0\”>\\0</a>”,
    $text);
    ?>
    正则表达式中，http://[a-zA-Z0-9./-]+)$代表至少包含一个小写大写英文字母和数字，还有./-三个特殊字符，同时也一样以小写大写英文字母和数字，还有./-三个特殊字符结尾。
    这会返回：
    This is a link to
    <a href=”http://www.wjgilmore.com/”>http://www.wjgilmore.com</a>.这里之所以能够正常显示url地址，是因为原先的正则表达式中，\0代表引用整个字符串，\”代表双引号。
    同时，下面的例子展示了如何用超链接替换所有URL:
    $url=”Apress (http://www.apress.com)”;
    $url=ereg_replace(“http://([a-zA-Z0-9./-]+)([a-zA-Z/]+)”,
    “<a href=\”\\0\”>\\0</a>”,$url);
    echo $url;
    该正则表达式分解一下，http://([a-zA-Z0-9./-]+)代表至少包含一个小写大写英文字母和数字，还有./-三个特殊字符。([a-zA-Z/]+)代表至少包含一个小写大写英文字母，还有/这个特殊字符。
    “<a href=\”\\0\”>\\0</a>”,$url);中的\0只要理解为引用整个字符串就可以了。之前也已经讲过了。
    最后，显示的时候是这样的，
    Apress(<a href=”http://www.apress.com”>http://www.apress.com</a>)
    正则表达式的例子举到现在，你会发现其实为什么会跟战力指数扯到关系，其实，你已经发现其实只是中括号，量词还有预定义字符的组合和搭配，战力指数也可以组合搭配在一起，并不是很难理解。最开始的时候那些讲解大家都可以再重温一下，通过正则表达式的搭配组合之后，你会发现通过这些例子你已经收获了很多，同时，也成长了许多。

顶

    eregi_replace()函数与ereg_replace()相似,只是它在string中对pattern的搜索是不区分大小写的，其形式为：
    string eregi_replace(string pattern,string replacement,string string)
    split()函数将字符串分成各个元素，在此基于预定义的模式在字符串出现的位置作为各个元素的边界，其形式为：
    array split(string pattern,string string [,int limit])
    可选输入参数limit用来指定字符串应该划分为多少个元素，从字符串左边开始，向右划分字符串。当模式为字母字符时，split()是区分大小写的。
    下面这个例子使用split()将字符串根据水平制表符和换行符分为几个部分：
    <?php
    $text=”this is\tsome text that \nwe might like to parse.”;
    print_r(split(“[\n\t]”,$text));
    通过split()函数，将$text中的字符串通过换行符\n和制表符\t分成三个部分。
    ?>
    这会返回：
    Array([0]=>this is [1]=>some text that [2]=we might like to parse.)
    spliti()函数与split()相同，只是它不区分大小写。其形式为：
    array spliti(string pattern,string string [,int limit])
    sql_regcase()函数将string中的各个字符转换为一个包含两个字符并用中括号括起的表达式。如果字符是一个字母，中括号中将包含这个字母的大小写形式；否则，原字符将保持不变。其形式为：
    string sql_regcase(string string)
    下例说明了如何使用sql_regcase()来转换字符串:
    <?php
    $version=”php 4.0”;
    echo sql_regcase($version);
    //输出[Pp] [Hh] [Ph] 4.0
    发现通过sql_regcase()函数将$version中的php分别以大小写的方式将p和h和p显示在中括号[]内，而4.0还是原样显示的。
    ?>
    正则表达式语法（Perl风格）其实与POSIX类似。先来看一个基于Perl正则表达式的简单例子：
    /fo+/这将匹配fo后面跟一个或多个字符的字符串。跟原先POSIX正则表达式中的A+至少有一个A稍微有点不同，这一次战力指数被控制在//这个限制的场景之内，fo还是可以被理解为是战力指数，但是那个+代表后面还至少跟一个或者是多个的战力指数。对于这个模式，可能的匹配包括food，fool和fo4。下面是使用量词的另一个例子：
    /fo{2,4}/这将匹配f后面跟有2到4个o，当然2到4个o后面还可以跟有一个或多个字符。对此，可能的匹配有fool，fooool和foosball。
    通常，你可能希望调整正则表达式的解释：例如，可能希望告诉正则表达式完成不区分大小写的搜索，或忽略语法中的注释。这些调整成为修饰符。以下是一些需要特别注意的修饰符。
    i 完成不区分大小写的搜索
    g 查找所有出现，完成全局搜索
    m 将一个字符串视为多行，默认情况下,^和$字符匹配字符串中的最开始和最末尾。使用m修饰符将使^和$匹配字符串中每行的开始。
    s 将一个字符串视为视为一行，忽略其中的所有换行符：它与m修饰符正好相反
    x 忽略正则表达式中的空白和注释
    U 第一此匹配后停止。许多量词很贪婪，将尽可能地完成匹配，而不是在第一次匹配后停止。利用这个修饰符，可以让它们“不再贪婪”
    修饰符这东西，其实这样来理解，游戏中的每个角色都有战力指数，当然，每个角色也可以携带一定的饰品来增加一些自身的属性，主要还是起到修饰作用的。在正则表达式中，这些修饰符可以直接放在正则表达式的后面。考虑下面几个例子:
    /wmd/i:可以不区分大小写地匹配WMD,Wmd,WMd,wmd，以及字符串wmd的任何其他大小写形式。
    /taxation/gi:增加的两个修饰符g和i，组合在一起，可以不区分大小写，同时找到单词taxation的所有出现。可以使用这个全局修饰符计算出现的总次数，或者结合替换特性用某个字符串替代模式的所有出现。
    Perl正则表达式中还有各种元字符来搜索匹配，元字符就是一个前面有反斜线的字母字符，表示某种特殊含义。
    \A 只匹配字符串开头。
    \b 匹配单词边界。
    \B 匹配除单词边界之外的任意字符。
    \d 匹配数字字符。它与[0-9]相同。
    \D 匹配非数字字符。
    \s 匹配空白字符。
    \S 匹配非空白字符。
    [] 包围一个字符类。
    () 包围一个字符分组或定义一个反引用。
    $ 匹配行尾。
    ^ 匹配行首。
    . 匹配除换行之外的任何字符。
    \ 引出下一个元字符
    \w 匹配任何只包含下划线和字母数字字符的字符串。它与[a-zA-Z0-9]相同。
    \W 匹配没有下划线和字母数字字符的字符串。
    其实，这些元字符就像之前所讲过的中括号[]和括号（）一样，就像是在游戏中的场景一样，起到限制拥有战力指数的角色行动的作用。战力指数不管再怎么强，都只能够因为元字符的限制起到限制行动的作用。所以，在游戏中做人也要谦虚一点，不要得罪了太多人，同时也不要得罪那些开发这一款游戏的开发者们哦，这些人才是我们玩游戏人的上帝，钻空子，抓游戏的漏洞，都是不可取的。做人做事，其实确实应该有所限制，不能够太过于放肆，所以，就产生了以上的这些元字符。其实搞来搞去，我们都是受制于现实，但我们总有一天能够释放我们自己的潜能，做出更多，更好的事。就比如写几个比较复杂的正则表达式练练手也可以。
    下面是几个例子：
    /sa\b/ 以单词sa作为边界，也就是以单词sa作为结尾，匹配pisa和lisa这样的字符串，而不匹配sand这样的字符串。
    /\blinux\b/i 以linux这个单词开始，同时以linux这个单词结束，返回单词linux的第一次出现，用i限定不区分大小写。
    /sa\B/ \B与单词边界元字符相反，匹配除单词边界之外的任意字符。所以该例将匹配sand和sally等字符串，而不能匹配Melissa。\B其实也就相当于在单词后面填充了一个或多个字符而已，当然限制是除了单词边界之外。
    /\$\d+\g 这个例子返回满足一定条件的字符串的所有实例：\$代表一个美元符，美元符因为在元字符中有特殊含义，所以用反斜线转义，代表一个普通的美元符号，\d+代表一个或多个数字。最后加一个修饰符g代表查找这个字符串的所有出现。
    写到现在，其实作为读者的你会惊喜地发现，其实正则表达式看上去是PHP中最难的，但是也可以摸到一点规律，发现一些痕迹和线索，多背多记多练，提升自己的编程战力指数，只要你觉得你可以，你就一定能够非常熟练地掌握它们。

首页本页[1] 下一页[2] 尾页[4] [收藏本文] 【下载本文】

小说文学最新文章

加:2021-06-29 10:19:09 更:2021-06-29 10:20:44

古典名著名著精选外国名著儿童童话武侠小说名人传记学习励志诗词散文经典故事其它杂谈
小说文学恐怖推理感情生活瓶邪原创小说小说故事鬼故事微小说文学耽美师生内向成功潇湘溪苑
旧巷笙歌花千骨剑来万相之王深空彼岸浅浅寂寞 yy小说吧穿越小说校园小说武侠小说言情小说玄幻小说经典语录三国演义西游记红楼梦水浒传古诗易经后宫鼠猫美文坏蛋对联读后感文字吧武动乾坤遮天凡人修仙传吞噬星空盗墓笔记斗破苍穹绝世唐门龙王传说诛仙庶女有毒哈利波特雪中悍刀行知否知否应是绿肥红瘦极品家丁龙族玄界之门莽荒纪全职高手心理罪校花的贴身高手美人为馅三体我欲封天少年王
旧巷笙歌花千骨剑来万相之王深空彼岸天阿降临重生唐三最强狂兵邻家天使大人把我变成废人这事顶级弃少大奉打更人剑道第一仙一剑独尊剑仙在此渡劫之王第九特区不败战神星门圣墟

网站联系: qq:121756557 email:121756557@qq.com 阅读网