从功能上详细提供了15个可视对象类，这就让我们能够根据实际需要选择合适的对象来实例化，而避免无用消耗。对这些显示对象的具体特性可查阅帮助文档，这是AS3显示编程的灵魂。

　　
　　二、清晰的事件机制
　　从AS2中就引入了事件侦听模型，但由于AS1和AS2编程的随意性以及AS开发人员更多的是设计转行的，很多人还是习惯使用_mc.onRelese = function(){}，甚至是on(release){}，这些不同实现的优劣这里就不再重复讨论了，很多文档都有详细地对比说明。正是因为事件侦听模型的巨大优势，所以在AS3中有且只有只一种事件模型，它是支持了W3C DOM3事件规范的标准，对于它提供的各种广播事件也需要熟记于心。
　　在新的事件模型中，this对象能够自动找到它的原始对象实例，而不用再使用Delegate这种和怪异地方式来指定事件处理函数的上下文引用了。
　　更多细节需要参阅文档，熟悉这个新的事件模型是很有必要的，对于交互编程而言，这个是重点之一。

　　AS2是不支持事件流的，现在你不用再为此头疼了，因为支持事件流是AS3的事件机制的又一重大更新，对于事件流的捕获、目标、冒泡这三个过程你需要很清楚，每当你初始化一个交互元素时，你就需要在脑海中迅速地按顺序触发这些过程，这是交互编程的重点之二。

　　三、更为便捷的库元件绑定和文档类绑定
　　在AS2中我们如果需要重新初始化一个目标MC的实例，通常会采用duplicateMovieClip或者attachMovie来实现，但这两个实现都存在弊端和不便，局限性比较大。AS3提供了一种更便捷的方式来实例化一个目标元素的实例。在AS2的组件开发中我们通常都会使用库元件的类绑定，但在UI和程序协同、构造函数传参方面还是不太方便。而AS3中我们完全可以用AS自由控制库元素实例化到舞台上，例如：

　　对于库绑定的细节需要详细了解，其中还涉及到一些实际问题的实现方式，例如如何在类中访问绑定库元件中的元素等。但我个人认为利用AS3提供的这一新功能，能够更好得设计程序的架构，更符合MVC的开发原则，具体实现还需要在以后的研究中来探索，也希望和大家一起交流。

　　如果你接触过Flex开发，那么文档类的绑定就很熟悉了，这是FLASH开发环境所不提供的，但在FLASH CS3中提供了这一功能，目的还是规范开发。

　　四、丰富的功能包支持
　　就FLASH CS3开发而言，Adobe沿用了Flash之前版本的一些类库，主要都在fl.*包中，在这个基础上有更新了一些顶级包，同时又提供了一些新的包，主要都在adobe.utils中。除此以外，你还可以使用Flex作为开发平台，Flex提供了更为丰富的功能包和组件。

　　五、语法特性
　　AS3语法特性上也有一些变化变化，目前我针对下面几个做过测试：
　　1、在Number类型的基础上，新增了int和uint类型。
　　2、类型检测方面增加了is和as两个运算符，AS3提供了运行时的类型检测，在这之前只是提供编译检测。
　　3、各种数据类型的值在undefined时，现在都会给一个特定的默认值（编程中需要格外小心）。　
　　4、对于函数的执行，需要严格匹配参数个数，并提供了一种…(rest) 形式的参数来支持任意多参数的调用。
　　5、面向对象体系更细致了，增加了包的概念，增加了inernal和final的两个修饰符，对于类中public、private、proteced的访问权限也都有变化，对于重写超类的方法需要利用override关键字做申明。　　

　　六、其他特性
　　上面的五点是我目前接触到的，同时也是个人认为最重要、最有进步的变革，除此之外还有一些重要的变化特性，例如在二进制、socket通信、E4X、正则表达式、文本显示、全屏模式等方面也都有一定的改进，有待于在实际操作中来熟悉。

SELECT SUM(population) FROM bbc

这里的SUM作用在所有返回记录的population字段上，结果就是该查询只返回一个结果，即所有
国家的总人口数。

通过使用GROUP BY 子句，可以让SUM 和 COUNT 这些函数对属于一组的数据起作用。
当你指定 GROUP BY region 时， 属于同一个region（地区）的一组数据将只能返回一行值．
也就是说，表中所有除region（地区）外的字段，只能通过 SUM, COUNT等聚合函数运算后返回一个值．

HAVING子句可以让我们筛选成组后的各组数据．
WHERE子句在聚合前先筛选记录．也就是说作用在GROUP BY 子句和HAVING子句前．
而 HAVING子句在聚合后对组记录进行筛选。

让我们还是通过具体的实例来理解GROUP BY 和 HAVING 子句，还采用第三节介绍的bbc表。

SQL实例：

一、显示每个地区的总人口数和总面积．
SELECT region, SUM(population), SUM(area)
FROM bbc
GROUP BY region

先以region把返回记录分成多个组，这就是GROUP BY的字面含义。分完组后，然后用聚合函数对每组中
的不同字段（一或多条记录）作运算。

二、 显示每个地区的总人口数和总面积．仅显示那些面积超过1000000的地区。

SELECT region, SUM(population), SUM(area)
FROM bbc
GROUP BY region
HAVING SUM(area)>1000000

在这里，我们不能用where来筛选超过1000000的地区，因为表中不存在这样一条记录。
相反，HAVING子句可以让我们筛选成组后的各组数据

1、如果能将类的方法定义成static，就尽量定义成static，它的速度会提升将近4倍。

2、$row['id'] 的速度是$row[id]的7倍。

3、echo 比 print 快，并且使用echo的多重参数（译注：指用逗号而不是句点）代替字符串连接，比如echo $str1,$str2。

4、在执行for循环之前确定最大循环数，不要每循环一次都计算最大值，最好运用foreach代替。

5、注销那些不用的变量尤其是大数组，以便释放内存。

6、尽量避免使用__get，__set，__autoload。

7、require_once()代价昂贵。

8、include文件时尽量使用绝对路径，因为它避免了PHP去include_path里查找文件的速度，解析操作系统路径所需的时间会更少。

9、如果你想知道脚本开始执行（译注：即服务器端收到客户端请求）的时刻，使用$_SERVER[‘REQUEST_TIME']要好于time()。

10、函数代替正则表达式完成相同功能。

11、str_replace函数比preg_replace函数快，但strtr函数的效率是str_replace函数的四倍。

12、如果一个字符串替换函数，可接受数组或字符作为参数，并且参数长度不太长，那么可以考虑额外写一段替换代码，使得每次传递参数是一个字符，而不是只写一行代码接受数组作为查询和替换的参数。

13、使用选择分支语句（译注：即switch case）好于使用多个if，else if语句。

14、用@屏蔽错误消息的做法非常低效，极其低效。

15、打开apache的mod_deflate模块，可以提高网页的浏览速度。

16、数据库连接当使用完毕时应关掉，不要用长连接。

17、错误消息代价昂贵。

18、在方法中递增局部变量，速度是最快的。几乎与在函数中调用局部变量的速度相当。

19、递增一个全局变量要比递增一个局部变量慢2倍。

20、递增一个对象属性（如：$this->prop++）要比递增一个局部变量慢3倍。

21、递增一个未预定义的局部变量要比递增一个预定义的局部变量慢9至10倍。

22、仅定义一个局部变量而没在函数中调用它，同样会减慢速度（其程度相当于递增一个局部变量）。PHP大概会检查看是否存在全局变量。

23、方法调用看来与类中定义的方法的数量无关，因为我（在测试方法之前和之后都）添加了10个方法，但性能上没有变化。

24、派生类中的方法运行起来要快于在基类中定义的同样的方法。

25、调用带有一个参数的空函数，其花费的时间相当于执行7至8次的局部变量递增操作。类似的方法调用所花费的时间接近于15次的局部变量递增操作。

26、Apache解析一个PHP脚本的时间要比解析一个静态HTML页面慢2至10倍。尽量多用静态HTML页面，少用脚本。

27、除非脚本可以缓存，否则每次调用时都会重新编译一次。引入一套PHP缓存机制通常可以提升25%至100%的性能，以免除编译开销。

28、尽量做缓存，可使用memcached。memcached是一款高性能的内存对象缓存系统，可用来加速动态Web应用程序，减轻数据库负载。对运算码 (OP code)的缓存很有用，使得脚本不必为每个请求做重新编译。

29、当操作字符串并需要检验其长度是否满足某种要求时，你想当然地会使用strlen()函数。此函数执行起来相当快，因为它不做任何计算，只返回在zval 结构（C的内置数据结构，用于存储PHP变量）中存储的已知字符串长度。但是，由于strlen()是函数，多多少少会有些慢，因为函数调用会经过诸多步骤，如字母小写化（译注：指函数名小写化，PHP不区分函数名大小写）、哈希查找，会跟随被调用的函数一起执行。在某些情况下，你可以使用isset() 技巧加速执行你的代码。

（举例如下）

if (strlen($foo) < 5) { echo “Foo is too short”$ }

（与下面的技巧做比较）

if (!isset($foo{5})) { echo “Foo is too short”$ }

调用isset()恰巧比strlen()快，因为与后者不同的是，isset()作为一种语言结构，意味着它的执行不需要函数查找和字母小写化。也就是说，实际上在检验字符串长度的顶层代码中你没有花太多开销。

34、当执行变量$i的递增或递减时，$i++会比++$i慢一些。这种差异是PHP特有的，并不适用于其他语言，所以请不要修改你的C或Java代码并指望它们能立即变快，没用的。++$i更快是因为它只需要3条指令(opcodes)，$i++则需要4条指令。后置递增实际上会产生一个临时变量，这个临时变量随后被递增。而前置递增直接在原值上递增。这是最优化处理的一种，正如Zend的PHP优化器所作的那样。牢记这个优化处理不失为一个好主意，因为并不是所有的指令优化器都会做同样的优化处理，并且存在大量没有装配指令优化器的互联网服务提供商（ISPs）和服务器。

35、并不是事必面向对象(OOP)，面向对象往往开销很大，每个方法和对象调用都会消耗很多内存。

36、并非要用类实现所有的数据结构，数组也很有用。

37、不要把方法细分得过多，仔细想想你真正打算重用的是哪些代码？

38、当你需要时，你总能把代码分解成方法。

39、尽量采用大量的PHP内置函数。

40、如果在代码中存在大量耗时的函数，你可以考虑用C扩展的方式实现它们。

41、评估检验(profile)你的代码。检验器会告诉你，代码的哪些部分消耗了多少时间。Xdebug调试器包含了检验程序，评估检验总体上可以显示出代码的瓶颈。

42、mod_zip可作为Apache模块，用来即时压缩你的数据，并可让数据传输量降低80%。

43、在可以用file_get_contents替代file、fopen、feof、fgets等系列方法的情况下，尽量用 file_get_contents，因为他的效率高得多！但是要注意file_get_contents在打开一个URL文件时候的PHP版本问题；

44、尽量的少进行文件操作，虽然PHP的文件操作效率也不低的；

45、优化Select SQL语句，在可能的情况下尽量少的进行Insert、Update操作(在update上，我被恶批过)；

46、尽可能的使用PHP内部函数（但是我却为了找个PHP里面不存在的函数，浪费了本可以写出一个自定义函数的时间，经验问题啊！）；

47、循环内部不要声明变量，尤其是大变量：对象(这好像不只是PHP里面要注意的问题吧？)；

48、多维数组尽量不要循环嵌套赋值；

49、在可以用PHP内部字符串操作函数的情况下，不要用正则表达式；

50、foreach效率更高，尽量用foreach代替while和for循环；

51、用单引号替代双引号引用字符串；

52、”用i+=1代替i=i+1。符合c/c++的习惯，效率还高”；

53、对global变量，应该用完就unset()掉；

mysql> select current_timestamp();
+———————+
| current_timestamp() |
+———————+
| 2010-01-18 21:24:37 |
+———————+
1 row in set (0.00 sec)

mysql> select current_date();
+—————-+
| current_date() |
+—————-+
| 2010-01-18     |
+—————-+
1 row in set (0.00 sec)

mysql> select current_time();
+—————-+
| current_time() |
+—————-+
| 21:24:46       |
+—————-+
1 row in set (0.00 sec)

2、Unix时间

mysql> select unix_timestamp();
+——————+
| unix_timestamp() |
+——————+
|       1263821184 |
+——————+
1 row in set (0.00 sec)

mysql> select from_unixtime(1263821182);
+—————————+
| from_unixtime(1263821182) |
+—————————+
| 2010-01-18 21:26:22       |
+—————————+
1 row in set (0.00 sec)

3、时间前后

mysql> select date_add(current_timestamp, interval 1 day);
+———————————————+
| date_add(current_timestamp, interval 1 day) |
+———————————————+
| 2010-01-19 21:27:53                         |
+———————————————+
1 row in set (0.00 sec)

mysql> select date_add(current_time, interval 1 day);
+—————————————-+
| date_add(current_time, interval 1 day) |
+—————————————-+
| NULL                                   |
+—————————————-+
1 row in set, 1 warning (0.00 sec)

mysql> select date_add(current_date, interval 1 day);
+—————————————-+
| date_add(current_date, interval 1 day) |
+—————————————-+
| 2010-01-19                             |
+—————————————-+
1 row in set (0.00 sec)

mysql> select date_sub(current_timestamp, interval 1 day);
+———————————————+
| date_sub(current_timestamp, interval 1 day) |
+———————————————+
| 2010-01-17 21:28:41                         |
+———————————————+
1 row in set (0.00 sec)

mysql> select date_sub(current_date, interval 1 day);
+—————————————-+
| date_sub(current_date, interval 1 day) |
+—————————————-+
| 2010-01-17                             |
+—————————————-+
1 row in set (0.00 sec)

mysql> select date_sub(current_time, interval 1 day);
+—————————————-+
| date_sub(current_time, interval 1 day) |
+—————————————-+
| NULL                                   |
+—————————————-+
1 row in set, 1 warning (0.00 sec)
4、时间间隔

mysql> select datediff(’2010-01-18′,’2010-01-17′);
+————————————-+
| datediff(’2010-01-18′,’2010-01-17′) |
+————————————-+
|                                   1 |
+————————————-+
1 row in set (0.00 sec)

mysql> select timediff(’2010-01-18 12:00′,’2010-01-17 11:00′);
+————————————————-+
| timediff(’2010-01-18 12:00′,’2010-01-17 11:00′) |
+————————————————-+
| 25:00:00                                        |
+————————————————-+
1 row in set (0.00 sec)
5、时间转换

mysql> select time_to_sec(’25:00:00′);
+————————-+
| time_to_sec(’25:00:00′) |
+————————-+
|                   90000 |
+————————-+
1 row in set (0.00 sec)

mysql> select sec_to_time(90000);
+——————–+
| sec_to_time(90000) |
+——————–+
| 25:00:00           |
+——————–+
1 row in set (0.00 sec)

回来后在网上查了一下，有段对optimize的描述：

OPTIMIZE [LOCAL | NO_WRITE_TO_BINLOG] TABLE tbl_name [, tbl_name] ...

如果您已经删除了表的一大部分，或者如果您已经对含有可变长度行的表（含有VARCHAR, BLOB或TEXT列的表）进行了很多更改，

则应使用OPTIMIZE TABLE。被删除的记录被保持在链接清单中，后续的INSERT操作会重新使用旧的记录位置。

您可以使用OPTIMIZE TABLE来重新
利用未使用的空间，并整理数据文件的碎片。

在多数的设置中，您根本不需要运行OPTIMIZE TABLE。即使您对可变长度的行进行了大量的更新，您也不需要经常运行，每周一次或每月一次
即可，只对特定的表运行。

OPTIMIZE TABLE只对MyISAM, BDB和InnoDB表起作用。

注意，在OPTIMIZE TABLE运行过程中，MySQL会锁定表。

因为我那个表，里面有VARCHAR字段，而且，那个表是分了三步生成的，后期有大量的update操作，所以optimize后效果很明显。

mysql> SHOW INDEX FROM `tbl_name`;
+----------+------------+------------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+
| Table | Non_unique | Key_name | Seq_in_index | Column_name | Collation | Cardinality | Sub_part | Packed | Null | Index_type | Comment |
+----------+------------+------------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+
| tbl_name | 0 | PRIMARY | 1 | StepID | A | 1 | NULL | NULL | | BTREE | |
| tbl_name | 1 | FlowID | 1 | FlowID | A | 1 | NULL | NULL | | BTREE | |
| tbl_name | 1 | WagerCount | 1 | WagerCount | A | 1 | NULL | NULL | | BTREE | |
| tbl_name | 1 | WagerID_3 | 1 | WagerID | A | 1 | NULL | NULL | | BTREE | |
| tbl_name | 1 | WagerID_3 | 2 | StepType | A | 1 | NULL | NULL | | BTREE | |
| tbl_name | 1 | WagerID_3 | 3 | ParamResult | A | 1 | 255 | NULL | | BTREE | |
| tbl_name | 1 | StepType_2 | 1 | StepType | A | 1 | NULL | NULL | | BTREE | |
| tbl_name | 1 | StepType_2 | 2 | ParamResult | A | 1 | 255 | NULL | | BTREE | |
| tbl_name | 1 | WagerID_2 | 1 | WagerID | A | 1 | NULL | NULL | | BTREE | |
| tbl_name | 1 | WagerID_2 | 2 | StepType | A | 1 | NULL | NULL | | BTREE | |
| tbl_name | 1 | WagerID_2 | 3 | ParamResult | A | 1 | 255 | NULL | | BTREE | |
+----------+------------+------------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+
11 rows in set (0.01 sec)

2、优化表

mysql> optimize table tbl_name;
+---------------+----------+----------+----------+
| Table | Op | Msg_type | Msg_text |
+---------------+----------+----------+----------+
| test.tbl_name | optimize | status | OK |
+---------------+----------+----------+----------+
1 row in set (40.60 sec)

3、再来看看优化后的效果

mysql> SHOW INDEX FROM `tbl_name`;
+----------+------------+------------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+
| Table | Non_unique | Key_name | Seq_in_index | Column_name | Collation | Cardinality | Sub_part | Packed | Null | Index_type | Comment |
+----------+------------+------------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+
| tbl_name | 0 | PRIMARY | 1 | StepID | A | 172462 | NULL | NULL | | BTREE | |
| tbl_name | 1 | FlowID | 1 | FlowID | A | 86231 | NULL | NULL | | BTREE | |
| tbl_name | 1 | WagerCount | 1 | WagerCount | A | 4311 | NULL | NULL | | BTREE | |
| tbl_name | 1 | WagerID_3 | 1 | WagerID | A | 86231 | NULL | NULL | | BTREE | |
| tbl_name | 1 | WagerID_3 | 2 | StepType | A | 172462 | NULL | NULL | | BTREE | |
| tbl_name | 1 | WagerID_3 | 3 | ParamResult | A | 172462 | 255 | NULL | | BTREE | |
| tbl_name | 1 | StepType_2 | 1 | StepType | A | 9 | NULL | NULL | | BTREE | |
| tbl_name | 1 | StepType_2 | 2 | ParamResult | A | 86231 | 255 | NULL | | BTREE | |
| tbl_name | 1 | WagerID_2 | 1 | WagerID | A | 86231 | NULL | NULL | | BTREE | |
| tbl_name | 1 | WagerID_2 | 2 | StepType | A | 172462 | NULL | NULL | | BTREE | |
| tbl_name | 1 | WagerID_2 | 3 | ParamResult | A | 172462 | 255 | NULL | | BTREE | |
+----------+------------+------------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+

最后，来看看手册中关于 OPTIMIZE 的描述：

OPTIMIZE [LOCAL | NO_WRITE_TO_BINLOG] TABLE tbl_name [, tbl_name] ...

如果您已经删除了表的一大部分，或者如果您已经对含有可变长度行的表（含有VARCHAR, BLOB或TEXT列的表）进行了很多更改，则应使用
OPTIMIZE TABLE。被删除的记录被保持在链接清单中，后续的INSERT操作会重新使用旧的记录位置。您可以使用OPTIMIZE TABLE来重新
利用未使用的空间，并整理数据文件的碎片。

在多数的设置中，您根本不需要运行OPTIMIZE TABLE。即使您对可变长度的行进行了大量的更新，您也不需要经常运行，每周一次或每月一次
即可，只对特定的表运行。

OPTIMIZE TABLE只对MyISAM, BDB和InnoDB表起作用。

注意，在OPTIMIZE TABLE运行过程中，MySQL会锁定表。

翻了手册,找到了下面这个语句,可以完成任务了

SELECT * FROM table_name ORDER BY rand() LIMIT 5;

rand在手册里是这么说的:
RAND()
RAND(N)
返回在范围0到1.0内的随机浮点值。如果一个整数参数N被指定，它被用作种子值。
mysql> select RAND();
        -> 0.5925
mysql> select RAND(20);
        -> 0.1811
mysql> select RAND(20);
        -> 0.1811
mysql> select RAND();
        -> 0.2079
mysql> select RAND();
        -> 0.7888
你不能在一个ORDER BY子句用RAND()值使用列，因为ORDER BY将重复计算列多次。然而在MySQL3.23中，你可以做： SELECT * FROM table_name ORDER BY RAND()，这是有利于得到一个来自SELECT * FROM table1,table2 WHERE a=b AND c<d ORDER BY RAND() LIMIT 1000的集合的随机样本。注意在一个WHERE子句里的一个RAND()将在每次WHERE被执行时重新评估。

但我试了一下,8千条记录的表,执行一次需要0.08 sec,.慢了些

后来请教了google,得到如下代码

SELECT *
FROM table_name AS r1 JOIN
       (SELECT ROUND(RAND() *
                     (SELECT MAX(id)
                        FROM table_name)) AS id)
        AS r2
WHERE r1.id >= r2.id
ORDER BY r1.id ASC
LIMIT 5;

执行效率需要0.02 sec.可惜的是,只有mysql 4.1.*以上才支持这样的子查询.

class FeedImage extends HtmlDescribable {
    var $title, $url, $link;
    var $width, $height, $description;
}

class HtmlDescribable {
    var $descriptionHtmlSyndicated;
    var $descriptionTruncSize;
    function getDescription() {
        $descriptionField = new FeedHtmlField($this->description);
        $descriptionField->syndicateHtml = $this->descriptionHtmlSyndicated;
        $descriptionField->truncSize = $this->descriptionTruncSize;
        return $descriptionField->output();
    }
}

class FeedHtmlField {
    var $rawFieldContent;
    var $truncSize, $syndicateHtml;
    function FeedHtmlField($parFieldContent) {
        if ($parFieldContent) {
            $this->rawFieldContent = $parFieldContent;
        }
    }
    function output() {
        if (!$this->rawFieldContent) {
            $result = “”;
        } elseif ($this->syndicateHtml) {
            $result = “<![CDATA[".$this->rawFieldContent."]]>”;
        } else {
            if ($this->truncSize and is_int($this->truncSize)) {
                $result = FeedCreator::iTrunc(htmlspecialchars($this->rawFieldContent),$this->truncSize);
            } else {
                $result = htmlspecialchars($this->rawFieldContent);
            }
        }
        return $result;
    }
}

class UniversalFeedCreator extends FeedCreator {
    var $_feed;

    function _setFormat($format) {
        switch (strtoupper($format)) {

            case “2.0″:
            case “RSS2.0″:
                $this->_feed = new RSSCreator20();
                break;

            case “0.91″:
            case “RSS0.91″:
                $this->_feed = new RSSCreator091();
                break;

            default:
                $this->_feed = new RSSCreator091();
                break;
        }

        $vars = get_object_vars($this);
        foreach ($vars as $key => $value) {
            if (!in_array($key, array(”_feed”, “contentType”, “encoding”))) {
                $this->_feed->{$key} = $this->{$key};
            }
        }
    }
    function createFeed($format = “RSS0.91″) {
        $this->_setFormat($format);
        return $this->_feed->createFeed();
    }
    function saveFeed($format=”RSS0.91″, $filename=”", $displayContents=true) {
        $this->_setFormat($format);
        $this->_feed->saveFeed($filename, $displayContents);
    }
    function useCached($format=”RSS0.91″, $filename=”", $timeout=3600) {
        $this->_setFormat($format);
        $this->_feed->useCached($filename, $timeout);
    }
}

class FeedCreator extends HtmlDescribable {
    var $title, $description, $link;
    var $syndicationURL, $image, $language, $copyright, $pubDate, $lastBuildDate, $editor, $editorEmail, $webmaster, $category, $docs, $ttl, $rating, $skipHours, $skipDays;
    var $xslStyleSheet = “”;
    var $items = Array();
    var $contentType = “application/xml”;
    var $encoding = “utf-8″;
    var $additionalElements = Array();
    function addItem($item) {
        $this->items[] = $item;
    }

    function clearItem2Null() {
        $this->items = array();
    }

    function iTrunc($string, $length) {
        if (strlen($string)<=$length) {
            return $string;
        }

        $pos = strrpos($string,”.”);
        if ($pos>=$length-4) {
            $string = substr($string,0,$length-4);
            $pos = strrpos($string,”.”);
        }
        if ($pos>=$length*0.4) {
            return substr($string,0,$pos+1).” …”;
        }

        $pos = strrpos($string,” “);
        if ($pos>=$length-4) {
            $string = substr($string,0,$length-4);
            $pos = strrpos($string,” “);
        }
        if ($pos>=$length*0.4) {
            return substr($string,0,$pos).” …”;
        }

        return substr($string,0,$length-4).” …”;

    }

    function _createGeneratorComment() {
        return “<!– generator=\”".FEEDCREATOR_VERSION.”\” –>\n”;
    }

    function _createAdditionalElements($elements, $indentString=”") {
        $ae = “”;
        if (is_array($elements)) {
            foreach($elements AS $key => $value) {
                $ae.= $indentString.”<$key>$value</$key>\n”;
            }
        }
        return $ae;
    }

    function _createStylesheetReferences() {
        $xml = “”;
        if ($this->cssStyleSheet) $xml .= “<?xml-stylesheet href=\”".$this->cssStyleSheet.”\” _fcksavedurl=\”".$this->cssStyleSheet.”\” type=\”text/css\”?>\n”;
        if ($this->xslStyleSheet) $xml .= “<?xml-stylesheet href=\”".$this->xslStyleSheet.”\” type=\”text/xsl\”?>\n”;
        return $xml;
    }

    function createFeed() {
    }

    function _generateFilename() {
        $fileInfo = pathinfo($_SERVER["PHP_SELF"]);
        return substr($fileInfo["basename"],0,-(strlen($fileInfo["extension"])+1)).”.xml”;
    }

    function _redirect($filename) {
        Header(”Content-Type: “.$this->contentType.”; charset=”.$this->encoding.”; filename=”.basename($filename));
        Header(”Content-Disposition: inline; filename=”.basename($filename));
        readfile($filename, “r”);
        die();
    }

    function useCached($filename=”", $timeout=3600) {
        $this->_timeout = $timeout;
        if ($filename==”") {
            $filename = $this->_generateFilename();
        }
        if (file_exists($filename) AND (time()-filemtime($filename) < $timeout)) {
            $this->_redirect($filename);
        }
    }
    function saveFeed($filename=”", $displayContents=true) {
        if ($filename==”") {
            $filename = $this->_generateFilename();
        }
        $feedFile = fopen($filename, “w+”);
        if ($feedFile) {
            fputs($feedFile,$this->createFeed());
            fclose($feedFile);
//            if ($displayContents) {
//                $this->_redirect($filename);
//            }
        } else {
            echo “<br /><b>Error creating feed file, please check write permissions.</b><br />”;
        }
    }

}

class FeedDate {
    var $unix;
    function FeedDate($dateString=”") {
        if ($dateString==”") $dateString = date(”r”);

        if (is_integer($dateString)) {
            $this->unix = $dateString;
            return;
        }
        if (preg_match(”~(?:(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun),\\s+)?(\\d{1,2})\\s+([a-zA-Z]{3})\\s+(\\d{4})\\s+(\\d{2}):(\\d{2}):(\\d{2})\\s+(.*)~”,$dateString,$matches)) {
            $months = Array(”Jan”=>1,”Feb”=>2,”Mar”=>3,”Apr”=>4,”May”=>5,”Jun”=>6,”Jul”=>7,”Aug”=>8,”Sep”=>9,”Oct”=>10,”Nov”=>11,”Dec”=>12);
            $this->unix = mktime($matches[4],$matches[5],$matches[6],$months[$matches[2]],$matches[1],$matches[3]);
            if (substr($matches[7],0,1)==’+’ or substr($matches[7],0,1)==’-') {
                $tzOffset = (substr($matches[7],0,3) * 60 + substr($matches[7],-2)) * 60;
            } else {
                if (strlen($matches[7])==1) {
                    $oneHour = 3600;
                    $ord = ord($matches[7]);
                    if ($ord < ord(”M”)) {
                        $tzOffset = (ord(”A”) - $ord - 1) * $oneHour;
                    } elseif ($ord >= ord(”M”) AND $matches[7]!=”Z”) {
                        $tzOffset = ($ord - ord(”M”)) * $oneHour;
                    } elseif ($matches[7]==”Z”) {
                        $tzOffset = 0;
                    }
                }
                switch ($matches[7]) {
                    case “UT”:
                    case “GMT”: $tzOffset = 0;
                }
            }
            $this->unix += $tzOffset;
            return;
        }
        if (preg_match(”~(\\d{4})-(\\d{2})-(\\d{2})T(\\d{2}):(\\d{2}):(\\d{2})(.*)~”,$dateString,$matches)) {
            $this->unix = mktime($matches[4],$matches[5],$matches[6],$matches[2],$matches[3],$matches[1]);
            if (substr($matches[7],0,1)==’+’ or substr($matches[7],0,1)==’-') {
                $tzOffset = (substr($matches[7],0,3) * 60 + substr($matches[7],-2)) * 60;
            } else {
                if ($matches[7]==”Z”) {
                    $tzOffset = 0;
                }
            }
            $this->unix += $tzOffset;
            return;
        }
        $this->unix = 0;
    }

    function rfc822() {
        //return gmdate(”r”,$this->unix);
        $date = gmdate(”Y-m-d H:i:s”, $this->unix);
        if (TIME_ZONE!=”") $date .= ” “.str_replace(”:”,”",TIME_ZONE);
        return $date;
    }

    function iso8601() {
        $date = gmdate(”Y-m-d H:i:s”,$this->unix);
        $date = substr($date,0,22) . ‘:’ . substr($date,-2);
        if (TIME_ZONE!=”") $date = str_replace(”+00:00″,TIME_ZONE,$date);
        return $date;
    }

    function unix() {
        return $this->unix;
    }
}

class RSSCreator10 extends FeedCreator {
    function createFeed() {
        $feed = “<?xml version=\”1.0\” encoding=\”".$this->encoding.”\”?>\n”;
        $feed.= $this->_createGeneratorComment();
        if ($this->cssStyleSheet==”") {
            $cssStyleSheet = “http://www.w3.org/2000/08/w3c-synd/style.css”;
        }
        $feed.= $this->_createStylesheetReferences();
        $feed.= “<rdf:RDF\n”;
        $feed.= “    xmlns=\”http://purl.org/rss/1.0/\”\n”;
        $feed.= “    xmlns:rdf=\”http://www.w3.org/1999/02/22-rdf-syntax-ns#\”\n”;
        $feed.= “    xmlns:slash=\”http://purl.org/rss/1.0/modules/slash/\”\n”;
        $feed.= “    xmlns:dc=\”http://purl.org/dc/elements/1.1/\”>\n”;
        $feed.= “    <channel rdf:about=\”".$this->syndicationURL.”\”>\n”;
        $feed.= “        <title>”.htmlspecialchars($this->title).”</title>\n”;
        $feed.= “        <description>”.htmlspecialchars($this->description).”</description>\n”;
        $feed.= “        <link>”.$this->link.”</link>\n”;
        if ($this->image!=null) {
            $feed.= “        <image rdf:resource=\”".$this->image->url.”\” />\n”;
        }
        $now = new FeedDate();
        $feed.= “       <dc:date>”.htmlspecialchars($now->iso8601()).”</dc:date>\n”;
        $feed.= “        <items>\n”;
        $feed.= “            <rdf:Seq>\n”;
        for ($i=0;$i<count($this->items);$i++) {
            $feed.= “                <rdf:li rdf:resource=\”".htmlspecialchars($this->items[$i]->link).”\”/>\n”;
        }
        $feed.= “            </rdf:Seq>\n”;
        $feed.= “        </items>\n”;
        $feed.= “    </channel>\n”;
        if ($this->image!=null) {
            $feed.= “    <image rdf:about=\”".$this->image->url.”\”>\n”;
            $feed.= “        <title>”.$this->image->title.”</title>\n”;
            $feed.= “        <link>”.$this->image->link.”</link>\n”;
            $feed.= “        <url>”.$this->image->url.”</url>\n”;
            $feed.= “    </image>\n”;
        }
        $feed.= $this->_createAdditionalElements($this->additionalElements, “    “);

        for ($i=0;$i<count($this->items);$i++) {
            $feed.= “    <item rdf:about=\”".htmlspecialchars($this->items[$i]->link).”\”>\n”;
            //$feed.= “        <dc:type>Posting</dc:type>\n”;
            $feed.= “        <dc:format>text/html</dc:format>\n”;
            if ($this->items[$i]->date!=null) {
                $itemDate = new FeedDate($this->items[$i]->date);
                $feed.= “        <dc:date>”.htmlspecialchars($itemDate->iso8601()).”</dc:date>\n”;
            }
            if ($this->items[$i]->source!=”") {
                $feed.= “        <dc:source>”.htmlspecialchars($this->items[$i]->source).”</dc:source>\n”;
            }
            if ($this->items[$i]->author!=”") {
                $feed.= “        <dc:creator>”.htmlspecialchars($this->items[$i]->author).”</dc:creator>\n”;
            }
            $feed.= “        <title>”.htmlspecialchars(strip_tags(strtr($this->items[$i]->title,”\n\r”,”  “))).”</title>\n”;
            $feed.= “        <link>”.htmlspecialchars($this->items[$i]->link).”</link>\n”;
            $feed.= “        <description>”.htmlspecialchars($this->items[$i]->description).”</description>\n”;
            $feed.= $this->_createAdditionalElements($this->items[$i]->additionalElements, “        “);
            $feed.= “    </item>\n”;
        }
        $feed.= “</rdf:RDF>\n”;
        return $feed;
    }
}
class RSSCreator091 extends FeedCreator {
    var $RSSVersion;
    function RSSCreator091() {
        $this->_setRSSVersion(”0.91″);
        $this->contentType = “application/rss+xml”;
    }

    function _setRSSVersion($version) {
        $this->RSSVersion = $version;
    }
    function createFeed() {
        $feed = “<?xml version=\”1.0\” encoding=\”".$this->encoding.”\”?>\n”;
        $feed.= $this->_createGeneratorComment();
        $feed.= $this->_createStylesheetReferences();
        $feed.= “<rss version=\”".$this->RSSVersion.”\”>\n”;
        $feed.= “    <channel>\n”;
        $feed.= “        <title>”.FeedCreator::iTrunc(htmlspecialchars($this->title),100).”</title>\n”;
        $this->descriptionTruncSize = 500;
        $feed.= “        <description>”.$this->getDescription().”</description>\n”;
        $feed.= “        <link>”.$this->link.”</link>\n”;
        $now = new FeedDate();
        $feed.= “        <lastBuildDate>”.htmlspecialchars($now->rfc822()).”</lastBuildDate>\n”;
        $feed.= “        <generator>”.FEEDCREATOR_VERSION.”</generator>\n”;
        if ($this->image!=null) {
            $feed.= “        <image>\n”;
            $feed.= “            <url>”.$this->image->url.”</url>\n”;
            $feed.= “            <title>”.FeedCreator::iTrunc(htmlspecialchars($this->image->title),100).”</title>\n”;
            $feed.= “            <link>”.$this->image->link.”</link>\n”;
            if ($this->image->width!=”") {
                $feed.= “            <width>”.$this->image->width.”</width>\n”;
            }
            if ($this->image->height!=”") {
                $feed.= “            <height>”.$this->image->height.”</height>\n”;
            }
            if ($this->image->description!=”") {
                $feed.= “            <description>”.$this->image->getDescription().”</description>\n”;
            }
            $feed.= “        </image>\n”;
        }
        if ($this->language!=”") {
            $feed.= “        <language>”.$this->language.”</language>\n”;
        }
        if ($this->copyright!=”") {
            $feed.= “        <copyright>”.FeedCreator::iTrunc(htmlspecialchars($this->copyright),100).”</copyright>\n”;
        }
        if ($this->editor!=”") {
            $feed.= “        <managingEditor>”.FeedCreator::iTrunc(htmlspecialchars($this->editor),100).”</managingEditor>\n”;
        }
        if ($this->webmaster!=”") {
            $feed.= “        <webMaster>”.FeedCreator::iTrunc(htmlspecialchars($this->webmaster),100).”</webMaster>\n”;
        }
        if ($this->pubDate!=”") {
            $pubDate = new FeedDate($this->pubDate);
            $feed.= “        <pubDate>”.htmlspecialchars($pubDate->rfc822()).”</pubDate>\n”;
        }
        if ($this->category!=”") {
            $feed.= “        <category>”.htmlspecialchars($this->category).”</category>\n”;
        }
        if ($this->docs!=”") {
            $feed.= “        <docs>”.FeedCreator::iTrunc(htmlspecialchars($this->docs),500).”</docs>\n”;
        }
        if ($this->ttl!=”") {
            $feed.= “        <ttl>”.htmlspecialchars($this->ttl).”</ttl>\n”;
        }
        if ($this->rating!=”") {
            $feed.= “        <rating>”.FeedCreator::iTrunc(htmlspecialchars($this->rating),500).”</rating>\n”;
        }
        if ($this->skipHours!=”") {
            $feed.= “        <skipHours>”.htmlspecialchars($this->skipHours).”</skipHours>\n”;
        }
        if ($this->skipDays!=”") {
            $feed.= “        <skipDays>”.htmlspecialchars($this->skipDays).”</skipDays>\n”;
        }
        $feed.= $this->_createAdditionalElements($this->additionalElements, “    “);
        for ($i=0;$i<count($this->items);$i++) {
            $feed.= “        <item>\n”;
            $feed.= “            <title>”.FeedCreator::iTrunc(htmlspecialchars(strip_tags($this->items[$i]->title)),100).”</title>\n”;
            $feed.= “            <link>”.htmlspecialchars($this->items[$i]->link).”</link>\n”;
            $feed.= “            <description>”.$this->items[$i]->getDescription().”</description>\n”;

            if ($this->items[$i]->author!=”") {
                $feed.= “            <author>”.htmlspecialchars($this->items[$i]->author).”</author>\n”;
            }
            /*
            // on hold
            if ($this->items[$i]->source!=”") {
            $feed.= “            <source>”.htmlspecialchars($this->items[$i]->source).”</source>\n”;
            }
            */
            if ($this->items[$i]->category!=”") {
                $feed.= “            <category>”.htmlspecialchars($this->items[$i]->category).”</category>\n”;
            }
            if ($this->items[$i]->comments!=”") {
                $feed.= “            <comments>”.htmlspecialchars($this->items[$i]->comments).”</comments>\n”;
            }
            if ($this->items[$i]->date!=”") {
                $itemDate = new FeedDate($this->items[$i]->date);
                $feed.= “            <pubDate>”.htmlspecialchars($itemDate->rfc822()).”</pubDate>\n”;
            }
            if ($this->items[$i]->guid!=”") {
                $feed.= “            <guid>”.htmlspecialchars($this->items[$i]->guid).”</guid>\n”;
            }
            $feed.= $this->_createAdditionalElements($this->items[$i]->additionalElements, “        “);
            $feed.= “        </item>\n”;
        }
        $feed.= “    </channel>\n”;
        $feed.= “</rss>\n”;
        return $feed;
    }
}

class RSSCreator20 extends RSSCreator091 {
    function RSSCreator20() {
        parent::_setRSSVersion(”2.0″);
    }

}
?>

安装步骤

安装memcached,这个步骤很简单，随处可见

安装mysql server 5.1RC，安装办法也很大众，不废话了

编译libmemcached，解压后安装即可./configure; make; make install

编译Memcached Functions for MySQL，在http://download.tangent.org/找一个最新的版本下载就是，./configure –with-mysql=/usr/local/mysql/bin/mysql_config –libdir=/usr/local/mysql/lib/mysql/

make

make install

接下来有两个办法让Memcached Functions for MySQL在mysql中生效

在mysql的shell中执行memcached_functions_mysql源码目录下的sql/install_functions.sql，这会把memcache function作为UDF加入mysql

运行memcached_functions_mysql源码目录下的utils/install.pl，这是一个perl脚本，作用同上一条

测试memcache function

以下测试脚本摘自memcached_functions_mysql的源码目录，有兴趣可以试试

PLAIN TEXTCODE: drop table if exists urls;

create table urls (

id int(3) not null,

url varchar(64) not null default ”,

primary key (id)

);

select memc_servers_set(’localhost:11211′);

select memc_set(’urls:sequence’, 0);

DELIMITER |

DROP TRIGGER IF EXISTS url_mem_insert;

CREATE TRIGGER url_mem_insert

BEFORE INSERT ON urls

FOR EACH ROW BEGIN

SET NEW.id= memc_increment(’urls:sequence’);

SET @mm= memc_set(concat(’urls:’,NEW.id), NEW.url);

END |

DELIMITER ;

insert into urls (url) values (’http://google.com’);

insert into urls (url) values (’http://www.ooso.net/index.php’);

insert into urls (url) values (’http://www.ooso.net/’);

insert into urls (url) values (’http://slashdot.org’);

insert into urls (url) values (’http://mysql.com’);

select * from urls;

select memc_get(’urls:1′);

select memc_get(’urls:2′);

select memc_get(’urls:3′);

select memc_get(’urls:4′);

select memc_get(’urls:5′);

319.209  294.257  288.295  308.337  225.268 

308.337  212.230  200.258  205.293  154.306 

348.330  375.259  361.237  405.219  398.185