1. php变量
   A. 普通变量：{$var}
   B. 关联数组：{$array.var1.var2}
   C. 数字数组：{$array[0][1]}
   D. 对象：{$object->var}
   E. 在引号内的使用方法，以关联数组为例，其他类似：{function var="{$array.var1.var2}"}
2. conf变量
   A. {#var#}
   B. 在引号内的使用方法：{function var="{#var#}"}
3. smarty保留变量：略。

二. 变量调节器

1. capitalize / lower / upper
   用途：首字母大写 / 转为小写 / 转为大写
   用法：{$var|capitalize} / {$var|lower} / {$var|upper}
2. count_characters / count_paragraphs / count_sentences / count_words
   用途：计算字节数，默认不计算空格符 / 计算段落数量 / 计算句子数量 / 计算词数
   用法：{$var|count_characters}  {$var|count_characters:true} / {$article|count_paragraphs} / {$article|count_sentences} / {$sentence|count_words}
3. cat
   用途：字符串连接
   用法：{$var|cat:" is a boy."}
4. nl2br
   用途：换行符替换为<br/>
   用法：{$var|nl2br}
5. regex_replace / replace
   用途：正则替换 / 普通替换
   用法：{$var|regex_replace:"/\[old\]/":"[new]"} / {$var|replace:"old":"new"}
6. spacify
   用途：在每个字符间插入指定字符
   用法：{$var|spacify:"^_^"}
7. date_format
   用途：格式化日期，类似"-1 days ago"、"201111010000"、时间戳等都可以，与strftime()功能类似
   用法：{$time|date_format:"%H:%M:%S"}
8. default
   用途：当变量为空时，设置默认值
   用法：{$var|default:"no value"}
9. escape
   用途：转码，包括：html,htmlall,url,quotes,hex,hexentity,javascript
   用法：{$articleTitle|escape:"html"}
10.indent
   用途：文字缩进，可以制定缩进字符数和使用什么字符代替
   用法：{$var|indent}  {$var|indent:4}  {$var|indent:4:"\t"}
11.string_format
   用途：类似用sprintf
   用法：{$var|string_format:"%.2f"}
12.strip / strip_tags
   用途：去除多余空白符，可以指定去除的字符 / 去除<>以及包含在里面的所有字符
   用法：{$var|strip}  {$var|strip:"&nbsp;"} / {$var|strip_tags}
13.truncate
   用途：字符串截取，默认截取80字符，可以指定追加的字符串
   用法：{$var|truncate:40}  {$var|truncate:40:"...":true}
14.组合修改器
   用途：顾名思义，可以将多个变量调节器组合使用，中间用|来代替
   例子：{$articleTitle|lower|spacify|truncate:30:"..."}

三. 内建函数

1. capture
   用途：捕获模板内容到某变量var，并不进行输出
   用法：
   在{capture}{/capture}中间的数据被捕获，可以使用$smarty.capture.var来使用，不指定name的话，默认为default
   {capture name=banner}
   This is a test.
   {/capture}
2. foreach
   用途：循环处理
   用法：
   from: 数组，需要用$
   item: 单元元素名称，不需要用$
   key: key名称，不需要用$
   name: 该循环的名称，可以用于访问该循环，例如：{$smarty.foreach.foreachname.varname}
   {foreach item=contact from=$contacts}
   {foreach key=key item=item from=$contact}
   {$key}: {$item}<br>
   {/foreach}
   {/foreach}
   注意：在foreach中有一些特殊的变量，需要使用{$smarty.foreach.foreachname.***}来访问：
   iteration: 表示当前循环的执行次数，初始为1
   first: 循环第一次执行时被置为true
   last: 同上
   total: 用于显示循环执行的次数，在循环中或者循环后皆可使用
   show: 是foreach的一个标签，用于决定是否显示该foreach的内容
3. include / insert
   用途：包含其他模板 / 与include不同， insert 所包含的内容不会被缓存，每次调用该模板都会重新执行该函数.
   用法：{include file="footer.tpl" title="Main menu" logo="http://my.domain.com/logo.gif"}
4. if elseif else
   用途：分之判断
   用法：
   {if $name eq "Fred"}
   Welcome Sir.
   {elseif $name eq "Wilma"}
   Welcome Ma'am.
   {else}
   Welcome, whatever you are.
   {/if}
5. ldelim / rdelim
   用途：分别表示左括号、右括号，因为这两个符号被用作smarty模板的标识符
   用法：
   {ldelim}  {rdelim}
6. literal
   用途：在内部的数据当做文本处理，不使用smarty模板解析，主要用于javascript脚本等
   用法：
   {literal}
   ......
   {/literal}
7. section
   用途：循环处理
   用法：
   name: 该循环的名称
   loop：决定循环次数的数组，注意这里的使用方法比较特别，可以使用section来对多个数组进行处理，但必须先用可以决定循环次数的数组给loop赋值
   {section name=customer loop=$custid}
   id: {$custid[customer]}<br>
   name: {$name[customer]}<br>
   address: {$address[customer]}<br>
   {section name=contact loop=$contact_type[customer]}
   {$contact_type[customer][contact]}: {$contact_info[customer][contact]}<br>
   {/section}
   <p>
   {/section}
   如果要遍历多维关联数组，需要这样来使用：
   {section name=customer loop=$contacts}
   name: {$contacts[customer].name}<br>
   home: {$contacts[customer].home}<br>
   cell: {$contacts[customer].cell}<br>
   e-mail: {$contacts[customer].email}<p>
   {/section}
   注意：与foreach类似，在section中同样有一些特殊变量可供使用，使用方法是：{$smarty.section.sectionname.***}
   index: 显示当前循环的索引，默认从0或者start开始
   index_prev: 显示上一个循环索引值，默认从-1开始
   index_next: 同上，直至最后都比上一次大1
   ineration: 同foreach，与index不同，后者是索引
   first: 同foreach
   last: 同foreach
   show: 同foreach
   total: 同foreach
8. strip
   用途：将位于{strip}{/strip}内部html标签外的所有空格和回车清除干净，并以html标签开头和结尾
   用法：
   {strip}
   <table border=0>
     <tr>
    <td>
      <A HREF="{$url}">
   <font color="red">This is a test</font>
   </A>
    </td>
  </tr>
   </table>
   {/strip}
   上述输出为：
   <table border=0><tr><td><A HREF="http://my.domain.com"><font color="red">This is a test</font></A></td></tr></table>

四. 程序员需要注意的地方

1. 常量
   SMARTY_DIR：SMARTY_DIR常量用于定位smarty类文件的完整系统路径，必须以斜杠结束，也可以不定义，smarty模板会自动创建合适的值。
2. 类属性
   $template_dir: 模板目录，也就是各html文件放置目录，默认为"./templates"
   $compile_dir: 编译后的模板目录，经过smarty解析后的html文件放置目录，默认为"./templates_c"
   $config_dir: 模板配置文件目录，默认为"./configs"
   $plugins_dir: 插件目录，默认为SMARTY_DIR 。 "plugins"
   $cache_dir: 存放模板缓存的目录，默认为"./cache"
   $debugging: 可以启动调试控制台，默认为false，很有用啊！！！
   $debug_tpl: 定义用于调试控制台的模板文件名字，默认为SMARTY_DIR . "libs/debug.tpl"
   $global_assign: 用于定义全局变量，例如：
       php里：$this->tpl->global_assign = array('my_global_1' => .....);
    在template里：{$smarty.my_global_1.***}
   $compile_check: 自动编译模板，默认设置为true，投入产品后为性能起见，可以设置为false。
   $force_compile: 强迫每次调用时重新编译模板，默认为false，不受$compile_check的限制，一旦设置为true后会强迫重新编译。
   $caching: 是否缓存模板输出，默认为false，有利于增强性能。
   $caching_lifetime: 缓存生存时间，只在$caching为true时有效，-1表示永远有效，0表示永远需要重新生成。单位是秒。
   注意：$compile_check、$force_compile、$caching三者的关系如下：
   A. 如果设置了$compile_check，如果任何模板文件或配置文件更新，都会重新编译，缓存也会重新生成；
   B. 如果设置了$force_compile，则$compile_check不起作用，而缓存也总会重新生成；
   C. 如果没有设置$caching，则没有缓存，性能受一定影响。

五. smarty的method

1. assign: 对模板使用到的php变量进行赋值
2. assign_by_ref: 也是赋值，不过是引用赋值
3. clear_all_assign: 清除所有赋值
4. clear_all_cache: 清除所有缓存，参数可以指定阈值时间
5. clear_assign: 清除某个赋值，可以指定单个变量名或者数组
6. clear_cache: 清除某个template的缓存，需要指定template的名称
7. clear_config: 清除所有配置变量，如果指定则清除特定配置变量
8. config_load: 加载某配置文件并将数据输出到模板
9. display: 显示某个模板
10.fetch: 捕获某个模板的输出，与display不同的是，模板输出内容并不会直接显示出来（有什么用呢？？？）
11.get_config_vars: 获取所有配置变量的值，也可以指定某个具体的变量名
12.get_template_vars: 获取所有模板变量的值，也可以指定某个具体的变量名
13.is_cached: 判断某模板的缓存是否存在，只有在$caching设置为true时才有效
14.template_exists: 判断某模板是否存在

使用"insert into"语句进行数据库操作时可能遇到主键冲突，用户需要根据应用场景进行忽略或者覆盖等操作。总结下，有三种解决方案来避免出错。

1. insert ignore into
遇主键冲突，保持原纪录，忽略新插入的记录。
mysql> select * from device ;
+-------+--------+-------------+
| devid | status | spec_char   |
+-------+--------+-------------+
|     1 | dead   | zhonghuaren |
|     2 | dead   | zhong       |
+-------+--------+-------------+
2 rows in set (0.00 sec)

mysql> insert into device values (1,'alive','yangting');
ERROR 1062 (23000): Duplicate entry '1' for key 'PRIMARY'

mysql> insert ignore  into device values (1,'alive','yangting');
Query OK, 0 rows affected (0.00 sec)

mysql> select * from device ;
+-------+--------+-------------+
| devid | status | spec_char   |
+-------+--------+-------------+
|     1 | dead   | zhonghuaren |
|     2 | dead   | zhong       |
+-------+--------+-------------+
2 rows in set (0.00 sec)
可见 insert ignore  into当遇到主键冲突时，不更改原纪录，也不报错

2. replace into
遇主键冲突，替换原纪录，即先删除原纪录，后insert新纪录

mysql> replace  into device values (1,'alive','yangting');
Query OK, 2 rows affected (0.00 sec)

mysql> select * from device ;
+-------+--------+-----------+
| devid | status | spec_char |
+-------+--------+-----------+
|     1 | alive  | yangting  |
|     2 | dead   | zhong     |
+-------+--------+-----------+
2 rows in set (0.00 sec)

3. insert into ... ON DUPLICATE KEY UPDATE
其实这个是原本需要执行3条SQL语句（SELECT,INSERT,UPDATE），缩减为1条语句即可完成。
即
IF (SELECT * FROM where 存在) {
    UPDATE  SET  WHERE ;
} else {
    INSERT INTO;
}
如：mysql> insert into device values (1,'readonly','yang') ON DUPLICATE KEY UPDATE status ='drain';
Query OK, 2 rows affected (0.00 sec)

上面语句伪代码表示即为
if (select * from device where devid=1) {
    update device set status ='drain' where devid=1
} else {
    insert into device values (1,'readonly','yang')
}
很明显，devid=1  是有的，这样就执行update操作
mysql> select * from device ;
+-------+--------+-----------+
| devid | status | spec_char |
+-------+--------+-----------+
|     1 | drain  | yangting  |
|     2 | dead   | zhong     |
+-------+--------+-----------+
2 rows in set (0.00 sec)
 

测试表：
CREATE TABLE `device` (
`devid` mediumint(8) unsigned NOT NULL AUTO_INCREMENT,
`status` enum('alive','dead','down','readonly','drain') DEFAULT NULL,
`spec_char` varchar(11) DEFAULT '0',
PRIMARY KEY (`devid`)
) ENGINE=InnoDB

class A {    
   public function x() {        
      echo "A::x() was called.\n";    
   }    
   public function y() {        
      self::x();        
      echo "A::y() was called.\n";    
   }    
   public function z() {        
      $this->x();        
      echo "A::z() was called.\n";    
   }
}
class B extends A {    
   public function x() {        
      echo "B::x() was called.\n";    
   }
}

$b = new B();
$b->y();
echo "--\n";
$b->z();

该例中，A::y()调用了A::x()，而B::x()覆盖了A::x()，那么当调用B::y()时，B::y()应该调用A::x()还是 B::x()呢？在C++中，如果A::x()未被定义为虚函数，那么B::y()（也就是A::y()）将调用A::x()，而如果A::x()使用 virtual关键字定义成虚函数，那么B::y()将调用B::x()。
然而，在PHP5中，虚函数的功能是由 self 和 $this 关键字实现的。如果父类中A::y()中使用 self::x() 的方式调用了 A::x()，那么在子类中不论A::x()是否被覆盖，A::y()调用的都是A::x()；而如果父类中A::y()使用 $this->x() 的方式调用了 A::x()，那么如果在子类中A::x()被B::x()覆盖，A::y()将会调用B::x()。

上例的运行结果如下：

A::x() was called. A::y() was called.
--
B::x() was called. A::z() was called.

$test = new Test();
$b = var_export($test, true);
var_dump($b);

class Test {

    public $a;
    public static function __set_state($array) {
        $ab = new Test();
        $ab->a = 10;
        return $ab;
    }
}

1.数组函数

array_product()  计算数组中所有值的乘积。

array_search()  在数组中搜索给定的值，如果成功则返回相应的键名。

array_unique()  删除数组中重复的值。

extract()  从数组中将变量导入到当前的符号表。
in_array()   检查数组中是否存在指定的值。

array_count_values()  用于统计数组中所有值出现的次数。

array_key_exists()  检查给定的键名或索引是否存在于数组中。

array_sum()  计算数组中所有值的和。

2.文件函数

basename()  返回路径中的文件名部分。

dirname()  返回路径中的目录名称部分。

feof()  测试文件指针是否到了文件结束的位置。

fflush()  向打开的文件输出缓冲内容。

file()  把文件读入一个数组中。

file_exists()  检查文件或目录是否存在。

file_get_contents()  将文件读入字符串。

file_put_contents  将字符串写入文件。

filesize()  返回文件大小。

filetype()  返回文件类型。

flock()  锁定或释放文件。

is_dir() 判断指定的文件名是否是一个目录。

is_executable()  判断文件是否可执行。

parse_ini_file()  解析一个配置文件。

tempnam()  创建唯一的临时文件。

tmpfile()  建立临时文件。

touch()  设置文件的访问和修改时间。

3.字符串函数

addslashes()  在指定的预定义字符前添加反斜杠。

chr()  从指定的 ASCII 值返回字符。

convert_uuencode()  使用 uuencode 算法对字符串进行编码。

convert_uudecode()  对 uuencode 编码的字符串进行解码。

crc32()  计算一个字符串的 32-bit CRC。

crypt()  单向的字符串加密法 (hashing)。

explode()  把字符串打散为数组。

htmlentities()  把字符转换为 HTML 实体。

htmlspecialchars_decode()  把一些预定义的 HTML 实体转换为字符。

htmlspecialchars()   把一些预定义的字符转换为 HTML 实体。

implode()  把数组元素组合为一个字符串。

md5()  计算字符串的 MD5 散列。

md5_file()  计算文件的 MD5 散列。

nl2br()  在字符串中的每个新行之前插入 HTML 换行符。

number_format()  通过千位分组来格式化数字。

ord()  返回字符串第一个字符的 ASCII 值。

parse_str()  把查询字符串解析到变量中。

str_ireplace()  替换字符串中的一些字符。（对大小写不敏感）

str_shuffle()  随机地打乱字符串中的所有字符。

str_split()  把字符串分割到数组中。

str_word_count()  计算字符串中的单词数。

strcasecmp()  比较两个字符串。（对大小写不敏感）

strchr()  搜索字符串在另一字符串中的第一次出现。strstr() 的别名

strcmp()  比较两个字符串。（对大小写敏感）

strip_tags()  剥去 HTML、XML 以及 PHP 的标签。

stripslashes()  删除由 addslashes() 函数添加的反斜杠。

stripos()  返回字符串在另一字符串中第一次出现的位置(大小写不敏感)

strpos()  返回字符串在另一字符串中首次出现的位置（对大小写敏感）

strrev()  反转字符串。

strtolower()  把字符串转换为小写。

strtoupper()  把字符串转换为大写。

substr()  返回字符串的一部分。

substr_replace()  把字符串的一部分替换为另一个字符串。

ucwords()  把字符串中每个单词的首字符转换为大写。

parse_url(); 解析URL，返回数组，[HOST]="ABC.COM";[PATH]="INDEX.PHP"

4.字符串加密

md5

urlencode

urldecode

base64_encode

base64_decode

convert_uuencode()  使用 uuencode 算法对字符串进行编码。

convert_uudecode()  对 uuencode 编码的字符串进行解码。

5.正则表达式

[^a-z]  a-z之外的字符

str_replace();

ereg_replace();

preg_match();

preg_match_all();

preg_replace();

preg_split();

6.数据验证

is_numeric();

is_bool();

is_string();

intval();  转化为整数

strval();  转化为字符串

settype($input,integer); 设置类型

7.缓冲区控制函数

flush — 刷新输出缓冲区
保存在输出缓冲区的内容会被发送到浏览器
ob_start — 打开输出缓冲区
这样所有的输出信息不在直接发送到浏览器，而是保存在输出缓冲区里面
ob_get_contents — 返回输出缓冲区的内容
如果你想以后处理输出的内容，可以调用这个函数保留一个备份
ob_get_length — 返回输出缓冲区的内容长度
ob_end_flush — 结束（发送）输出缓冲区的内容，关闭输出缓冲区
ob_end_clean — 删除（放弃）输出缓冲区的内容，关闭输出缓冲区
如果你的程序发现输出内容有问题，可以放弃所有输出内容，可以防止泄漏某些秘密信息
ob_implicit_flush — 打开或关闭直接刷新
打开后，每个脚本输出都直接发送到浏览器，不再需要调用 flush(),

1、如果能将类的方法定义成static，就尽量定义成static，它的速度会提升将近4倍。
PS：事实上，function、method、static method的速度不会有太大差异。具体可见“PHP函数的实现原理及性能分析【转载】”一文。

2、$row[’id’] 的速度是$row[id]的7倍。
PS：不太懂，貌似差异只有后者会先判断id这个宏是否存在，如果不存在则自动转变为字符串。

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

4、在执行for循环之前确定最大循环数，不要每循环一次都计算最大值，最好运用foreach代替。
PS：像count、strlen这样的操作其实是O(1)的，因此不会带来太多消耗，当然避免每次循环都计算是比较好的策略。最好用foreach代替for，这个效率更高，如果考虑到foreach($array as $var)每次拷贝的消耗，可以使用foreach($array as &$var)这样的引用。

5、注销那些不用的变量尤其是大数组，以便释放内存。
PS：如果没有记错的话，unset($array)不会立刻释放内存，但随时释放是个好习惯。

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

7、require_once()代价昂贵。
PS：require_once和include_once需要判重，因此效率上要低，但是5.2版本后效率问题已经基本解决。

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

9、如果你想知道脚本开始执行(译注：即服务器端收到客户端请求)的时刻，使用$_SERVER['REQUEST_TIME']要好于time()。
PS：$_SERVER['REQUEST_TIME']保存了发起该请求时刻的时间戳，而time()则返回当前时刻的Unix时间戳。

10、函数代替正则表达式完成相同功能。
PS：这种函数是指strtok、strstr、strpos、str_replace、substr、explode、implode等等。

11、str_replace函数比preg_replace函数快，但strtr函数的效率是str_replace函数的四倍。
PS：字符串操作比正则替换要快。

12、如果一个字符串替换函数，可接受数组或字符作为参数，并且参数长度不太长，那么可以考虑额外写一段替换代码，使得每次传递参数是一个字符，而不是只写一行代码接受数组作为查询和替换的参数。
PS：需要考虑到内置函数和用户自定义函数的开销差异，恐怕这种做法得不偿失。

13、使用选择分支语句(译注：即switch case)好于使用多个if，else if语句。
PS：php中switch支持数值和字符串变量，比C的switch要好用，建议使用。

14、用@屏蔽错误消息的做法非常低效，极其低效。
PS：有什么替代方法吗？没有的话还是不得不用的……

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

16、数据库连接当使用完毕时应关掉，不要用长连接。
PS：在连接之前，最好设置一下相应的超时机制，例如链接超时、读写超时、等待超时等。

17、错误消息代价昂贵。

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

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

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

<?php
//创建对象
$mysqli = mysqli_init();

//设置超时选项
$mysqli->options(MYSQLI_OPT_CONNECT_TIMEOUT, 5);

//连接
$mysqli->real_connect('localhost', 'my_user', 'my_password', 'world');

//如果超时或者其他连接失败打印错误信息
if (mysqli_connect_errno()) {
    printf("Connect failed: %s/n", mysqli_connect_error());
    exit();
}
//成功输出连接信息
printf ("Connection: %s/n.", $mysqli->host_info);

$mysqli->close();
?>

这个是连接超时，但是有些时候我们需要查询读写超时，比如说我们一个数据库压力很大，或者连接很多，那么数据库查询就很缓慢，但是我希望某些不重要的数据，比如说文章点击数这种如果查询超时了就不显示，至少能够保证主体页面正确显示，但是查遍PHP手册没有发现这个操作选项或者函数。手册里只有这么四个选项：

跟踪 mysqli 的扩展源代码发现它底层调用的是 libmysqlclient 的 mysql_options：

php-5.2.8/ext/mysqli/mysqli_api.c

并且在mysqli的PHP扩展中就只导出了几个变量：

php-5.2.8/ext/mysqli/mysqli.c

大概看了一下 libmysqlclient 的代码，发现其实它自带是有读写超时设置的：

mysql-5.1.30/sql-common/client.c

因为它自己定义了很多操作选项，只是php扩展里没有：

mysql-5.1.30/include/mysql.h

看看mysql中的读写超时是如何实现的：

mysql-5.1.30/sql-common/client.c

读写超时真正操作的地方，超时处理这里重试了两次，还是写死了：

mysql-5.1.30/sql/net_serv.cc

现在基本得出了结论：

按照上面查看代码来看，目前PHP针对MySQL查询超时以下限制：

1. 超时设置单位为秒，最少配置1秒

2. 但mysql底层的read会重试两次，所以实际会是 3 秒

重试两次 +　自身一次 = 3倍超时时间。

那么就是说最少超时时间是3秒，不会低于这个值，对于大部分应用来说可以接受，但是对于小部分应用需要优化。

现在我们来看看如果我们自己要设置超时，我们自己压入 MYSQL_OPT_READ_TIMEOUT 也是可以达到读写超时效果的，写一段代码来测试一下：

<?php
//自己定义读写超时常量
if (!defined('MYSQL_OPT_READ_TIMEOUT')) {
        define('MYSQL_OPT_READ_TIMEOUT',  11);
}
if (!defined('MYSQL_OPT_WRITE_TIMEOUT')) {
        define('MYSQL_OPT_WRITE_TIMEOUT', 12);
}

//设置超时
$mysqli = mysqli_init();
$mysqli->options(MYSQL_OPT_READ_TIMEOUT, 3);
$mysqli->options(MYSQL_OPT_WRITE_TIMEOUT, 1);

//连接数据库
$mysqli->real_connect("localhost", "root", "root", "test");
if (mysqli_connect_errno()) {
   printf("Connect failed: %s/n", mysqli_connect_error());
   exit();
}

//执行查询 sleep 1秒不超时
printf("Host information: %s/n", $mysqli->host_info);
if (!($res=$mysqli->query('select sleep(1)'))) {
    echo "query1 error: ". $mysqli->error ."/n";
} else {
    echo "Query1: query success/n";
}

//执行查询 sleep 9秒会超时
if (!($res=$mysqli->query('select sleep(9)'))) {
    echo "query2 error: ". $mysqli->error ."/n";
} else {
    echo "Query2: query success/n";
}

$mysqli->close();
echo "close mysql connection/n";
?>

查看上面代码的执行结果，验证了上面的观点，第一个查询成功了，第二个查询连接被断开了：

基本上到这里就基本能够解决PHP在针对MySQL读写查询操作超时的处理了，希望对你有帮助。


// #####################################################
// #####################################################

本人按照作者的方法编代码，运行时在$mysqli->options(MYSQL_OPT_READ_TIMEOUT, 3);这一步就返回false了，实际查询时READ_TIMEOUT也没有发挥作用。后来看php-5.3.8\php-5.3.8\ext\mysqli\mysqli_api.c源代码时发现PHP_FUNCTION(mysqli_options)里有一行代码：
expected_type = mysqli_options_get_option_zval_type(mysql_option);
这个函数的作用是判断options值类型，其中有一段：
#ifdef MYSQL_OPT_READ_TIMEOUT
case MYSQL_OPT_READ_TIMEOUT:
case MYSQL_OPT_WRITE_TIMEOUT:
case MYSQL_OPT_GUESS_CONNECTION:
case MYSQL_OPT_USE_EMBEDDED_CONNECTION:
case MYSQL_OPT_USE_REMOTE_CONNECTION:
case MYSQL_SECURE_AUTH:
#endif /* MySQL 4.1.1 */
.........
return IS_LONG;
.........
default:
return IS_NULL;

貌似由于没有定义MYSQL_OPT_READ_TIMEOUT这个宏，所以options等于MYSQL_OPT_READ_TIMEOUT时被归到IS_NULL的返回结果中了，此时PHP_FUNCTION(mysqli_options)会执行如下结果：
switch (expected_type) {
case IS_STRING:
   ret = mysql_options(mysql->mysql, mysql_option, Z_STRVAL_PP(mysql_value));
   break;
case IS_LONG:
   l_value = Z_LVAL_PP(mysql_value);
   ret = mysql_options(mysql->mysql, mysql_option, (char *)&l_value);
   break;
default:
   ret = 1;
   break;
}

也就是说，不会执行mysql_options()方法，而是直接返回false。

前言

在任何语言中，函数都是最基本的组成单元。对于php的函数，它具有哪些特点？函数调用是怎么实现的？php函数的性能如何，有什么使用建议？
本文将从原理出发进行分析结合实际的性能测试尝试对这些问题进行回答，在了解实现的同时更好的编写php程序。同时也会对一些常见的php函数进行介绍。

php函数的分类

在php中，横向划分的话，函数分为两大类： user function(用户函数) 和internal function（内置函数）。
前者就是用户在程序中自定义的一些函数和方法，后者则是php本身提供的各类库函数（比如sprintf、array_push等）。
用户也可以通过扩展的方法来编写库函数，这个将在后面介绍。
对于user function，又可以细分为function（函数）和method（类方法），本文中将就这三种函数分别进行分析和测试。

php函数的实现

一个php函数最终是如何执行，这个流程是怎么样的呢？

要回答这个问题，我们先来看看php代码的执行所经过的流程。

从图1可以看到，php实现了一个典型的动态语言执行过程：拿到一段代码后，经过词法解析、语法解析等阶段后，
源程序会被翻译成一个个指令(opcodes)，然后ZEND虚拟机顺次执行这些指令完成操作。Php本身是用c实现的，
因此最终调用的也都是c的函数，实际上，我们可以把php看做是一个c开发的软件。
通过上面描述不难看出，php中函数的执行也是被翻译成了opcodes来调用，每次函数调用实际上是执行了一条或多条指令。

对于每一个函数，zend都通过以下的数据结构来描述

typedef union _zend_function {
zend_uchar type;      /* MUST be the first element of this struct! */
struct {
zend_uchar type;  /* never used */
char *function_name;
zend_class_entry *scope;
zend_uint fn_flags;
union _zend_function *prototype;
zend_uint num_args;
zend_uint required_num_args;
zend_arg_info *arg_info;
zend_bool pass_rest_by_reference;
unsigned char return_reference;
} common;
zend_op_array op_array;
zend_internal_function internal_function;
} zend_function;
typedef struct _zend_function_state {
HashTable *function_symbol_table;
zend_function *function;
 void *reserved[ZEND_MAX_RESERVED_RESOURCES];
} zend_function_state;

其中：
type标明了函数的类型：用户函数、内置函数、重载函数。
Common中包含函数的基本信息，包括函数名，参数信息，函数标志（普通函数、静态方法、抽象方法）等内容。
另外，对于用户函数，还有一个函数符号表，记录了内部变量等，这个将在后面详述。
Zend维护了一个全局function_table，这是一个大的hash表。函数调用的时候会首先根据函数名从表中找到对应的zend_function。
当进行函数调用时候，虚拟机会根据type的不同决定调用方法， 不同类型的函数，其执行原理是不相同的 。

内置函数

内置函数，其本质上就是真正的c函数，每一个内置函数，php在最终编译后都会展开成为一个名叫zif_xxxx的function，比如我们常见的sprintf，
对应到底层就是zif_sprintf。Zend在执行的时候，如果发现是内置函数，则只是简单的做一个转发操作。

Zend提供了一系列的api供调用，包括参数获取、数组操作、内存分配等。内置函数的参数获取，通过zend_parse_parameters方法来实现，
对于数组、字符串等参数，zend实现的是浅拷贝，因此这个效率是很高的。可以这样说，对于php内置函数，其效率和相应c函数几乎相同，
唯一多了一次转发调用。

内置函数在php中都是通过so的方式进行动态加载，用户也可以根据需要自己编写相应的so，也就是我们常说的扩展。
ZEND提供了一系列的api供扩展使用，下面是mysqli_real_query函数的C函数实现：
php-5.3.8\php-5.3.8\ext\mysqli\mysqli_api.c

PHP_FUNCTION(mysqli_real_query)
{
   MY_MYSQL *mysql;
   zval  *mysql_link;
   char  *query = NULL;
   int   query_len;

   if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os", &mysql_link, mysqli_link_class_entry, &query, &query_len) == FAILURE) {
      return;
   }
   MYSQLI_FETCH_RESOURCE_CONN(mysql, &mysql_link, MYSQLI_STATUS_VALID);

   MYSQLI_DISABLE_MQ; /* disable multi statements/queries */

   if (mysql_real_query(mysql->mysql, query, query_len)) {
      MYSQLI_REPORT_MYSQL_ERROR(mysql->mysql);
      RETURN_FALSE;
   }

   if (!mysql_field_count(mysql->mysql)) {
      if (MyG(report_mode) & MYSQLI_REPORT_INDEX) {
         php_mysqli_report_index(query, mysqli_server_status(mysql->mysql) TSRMLS_CC);
      }
   }

   RETURN_TRUE;
}

用户函数

和内置函数相比，用户通过php实现的自定义函数具有完全不同的执行过程和实现原理。如前文所述，
我们知道php代码是被翻译成为了一条条opcode来执行的，用户函数也不例外，实际中每个函数对应到一组opcode，
这组指令被保存在zend_function中。于是，用户函数的调用最终就是对应到一组opcodes的执行。

• 局部变量的保存及递归的实现
  我们知道，函数递归是通过堆栈来完成的。在php中，也是利用类似的方法来实现。Zend为每个php函数分配了一个活动符号表(active_sym_table)，
  记录当前函数中所有局部变量的状态。所有的符号表通过堆栈的形式来维护，每当有函数调用的时候，分配一个新的符号表并入栈。
  当调用结束后当前符号表出栈。由此实现了状态的保存和递归。

对于栈的维护，zend在这里做了优化。预先分配一个长度为N的静态数组来模拟堆栈，
这种通过静态数组来模拟动态数据结构的手法在我们自己的程序中也经常有使用，这种方式避免了每次调用带来的内存分配、销毁。
ZEND只是在函数调用结束时将当前栈顶的符号表数据clean掉即可。
因为静态数组长度为N，一旦函数调用层次超过N，程序不会出现栈溢出，这种情况下zend就会进行符号表的分配、销毁，因此会导致性能下降很多。
在zend里面，N目前取值是32。因此，我们编写php程序的时候，函数调用层次最好不要超过32。
当然，如果是web应用，本身可以函数调用层次的深度。

• 参数的传递
  和内置函数调用zend_parse_params来获取参数不同，用户函数中参数的获取是通过指令来完成的。函数有几个参数就对应几条指令。
  具体到实现上就是普通的变量赋值。
  通过上面的分析可以看出，和内置函数相比，由于是自己维护堆栈表，而且每条指令的执行也是一个c函数，用户函数的性能相对会差很多，
  后面会有具体的对比分析。因此，如果一个功能有对应php内置函数实现的尽量不要自己重新写函数去实现。

类方法

类方法其执行原理和用户函数是相同的，也是翻译成opcodes顺次调用。类的实现，zend用一个数据结构zend_class_entry来实现，
里面保存了类相关的一些基本信息。这个entry是在php编译的时候就已经处理完成。

在zend_function的common中，有一个成员叫做scope，其指向的就是当前方法对应类的zend_class_entry。关于php中面向对象的实现，
这里就不在做更详细的介绍，今后将专门写一篇文章来详述php中面向对象的实现原理。就函数这一块来说，method实现原理和function完全相同，
理论上其性能也差不多，后面我们将做详细的性能对比。

性能对比

函数名长度对性能的影响

• 测试方法
  对名字长度为1、2、4、8、16的函数进行比较，测试比较它们每秒可执行次数，确定函数名长度对性能的影响

• 测试结果如下图

• 结果分析
  从图上可以看出，函数名的长度对性能还是会有一定的影响。一个长度为1的函数和长度为16的 空函数调用 ，其性能差了1倍。
  分析一下源码不难找到原因，如前面叙述所说，函数调用的时候zend会先在一个全局的funtion_table中通过函数名查询相关信息，
  function_table是一个哈希表。必然的，名字越长查询所需要的时间就越多。
  因此，在实际编写程序的时候，对多次调用的函数，名字建议不要太长

虽然函数名长度对性能有一定影响，但具体有多大呢？这个问题应该还是需要结合实际情况来考虑，如果一个函数本身比较复杂的话，
那么对整体的性能影响并不大。
一个建议是对于那些会调用很多次，本身功能又比较简单的函数，可以适当取一些言简意赅的名字。

函数个数对性能的影响

• 测试方法
  在以下三种环境下进行函数调用测试，分析结果：1.程序仅包含1个函数 2.程序包含100个函数 3.程序包含1000个函数。
  测试这三种情况下每秒所能调用的函数次数

• 测试结果如下图

• 结果分析
  从测试结果可以看出，这三种情况下性能几乎相同，函数个数增加时性能下降微乎其微，可以忽略。
  从实现原理分析，几种实现下唯一的区别在于函数获取的部分。如前文所述，所有的函数都放在一个hash表中，
  在不同个数下查找效率都应该还是接近于O(1)，所以性能差距不大。

不同类型函数调用消耗

• 测试方法
  选取用户函数、类方法、静态方法、内置函数各一种，函数本身不做任何事情，直接返回，主要测试空函数调用的消耗。
  测试结果为每秒可执行次数
  测试中为去除其他影响，所有函数名字长度相同

• 测试结果如下图

• 结果分析
  通过测试结果可以看到，对于用户自己编写的php函数，不管是哪种类型，其效率是差不多的，均在280w/s左右。如我们预期，即使是空调，
  内置函数其效率也要高很多，达到780w/s，是前者是3倍。可见，内置函数调用的开销还是远低于用户函数。
  从前面原理分析可知主要差距在于用户函数调用时初始化符号表、接收参数等操作。

内置函数和用户函数性能对比

• 测试方法
  内置函数和用户函数的性能对比，这里我们选取几个常用的函数，然后用php实现相同功能的函数进行一下性能对比。
  测试中，我们选取字符串、数学、数组中各一个典型进行对比，这几个函数分别是字符串截取(substr)、10进制转2进制(decbin)、
  求最小值(min)和返回数组中的所以key(array_keys)。

• 测试结果如下图

• 结果分析
  从测试结果可以看出，如我们预期，内置函数在总体性能上远高于普通用户函数。尤其对于涉及到字符串类操作的函数，
  差距达到了1个数量级。因此，函数使用的一个原则就是如果某功能有相应的内置函数，尽量使用它而不是自己编写php函数。
  对于一些涉及到大量字符串操作的功能，为提高性能，可以考虑用扩展来实现。比如常见的富文本过滤等。

和C函数性能对比

• 测试方法
  我们选取字符串操作和算术运算各3种函数进行比对，php用扩展实现。三种函数是简单的一次算法运算、字符串比较和多次的算法运算。
  除了本身的两类函数外，还会测试将函数空调开销去掉后的性能，一方面比对一下两种函数（c和php内置）本身的性能差异，
  另外就是侧面印证空调函数的消耗
  测试点为执行10w次操作的时间消耗

• 测试结果如下图

• 结果分析
  内置函数和C函数的开销在去掉php函数空调用的影响后差距较小，随着函数功能越来越复杂，双方性能趋近于相同。
  这个从之前的函数实现分析中也容易得到论证，毕竟内置函数就是C实现的。
  函数功能越复杂，c和php的性能差距越小
  相对c来说，php函数调用的开销大很多，对于简单函数来说性能还是有一定影响。因此php中函数不宜嵌套封装太深。

伪函数及其性能

在php中，有这样一些函数，它们在使用上是标准的函数用法，但底层实现却和真正函数调用完全不同，这些函数不属于前文提到的三种function中的任何一类，
其实质是一条单独的opcode，这里估且叫做伪函数或者指令函数。

如上所说，伪函数使用起来和标准的函数并无二致，看起来具有相同的特征。但是他们最终执行的时候是被zend反映成了一条对应的指令（opcode）来调用，
因此其实现更接近于if、for、算术运算等操作。

• php中的伪函数
  isset
  empty
  unset
  eval

通过上面的介绍可以看出，伪函数由于被直接翻译成指令来执行，和普通函数相比少了一次函数调用所带来的开销，因此性能会更好一些。
我们通过如下测试来做一个对比。 Array_key_exists和isset两者都可以判断数组中某个key是否存在，看一下他们的性能

从图上可以看出，和array_key_exists相比，isset性能要高出很多，基本是前者的4倍左右，而即使是和空函数调用相比，
其性能也要高出1倍左右。由此也侧面印证再次说明了php函数调用的开销还是比较大的。

总结及建议

通过对函数实现的原理分析和性能测试，我们总结出以下一些结论

1． Php的函数调用开销相对较大。

2． 函数相关信息保存在一个大的hash_table中，每次调用时通过函数名在hash表中查找，因此函数名长度对性能也有一定影响。

3． 函数返回引用没有实际意义

4． 内置php函数性能比用户函数高很多，尤其对于字符串类操作。

5． 类方法、普通函数、静态方法效率几乎相同，没有太大差异

6． 除去空函数调用的影响，内置函数和同样功能的C函数性能基本差不多。

7． 所有的参数传递都是采用引用计数的浅拷贝，代价很小。

8． 函数个数对性能影响几乎可以忽略

因此，对于php函数的使用，有如下一些建议

1． 一个功能可以用内置函数完成，尽量使用它而不是自己编写php函数。

2． 如果某个功能对性能要求很高，可以考虑用扩展来实现。

3． Php函数调用开销较大，因此不要过分封装。有些功能，如果需要调用的次数很多本身又只用1、2行代码就行实现的，建议就不要封装调用了。

4． 不要过分迷恋各种设计模式，如上一条描述，过分的封装会带来性能的下降。需要考虑两者的权衡。Php有自己的特点，
切不可东施效颦，过分效仿java的模式。

5． 函数不宜嵌套过深，递归使用要谨慎。

6． 伪函数性能很高，同等功能实现下优先考虑。比如用isset代替array_key_exists

7． 函数返回引用没有太大意义，也起不到实际作用，建议不予考虑。

8． 类成员方法效率不比普通函数低，因此不用担心性能损耗。建议多考虑静态方法，可读性及安全性都更好。

9． 如不是特殊需要，参数传递都建议使用传值而不是传引用。当然，如果参数是很大的数组且需要修改时可以考虑引用传递。

调试脚本：
sh [-nvx] scripts
-n 不执行脚本，查询脚本内的语法，若有错误则列出
-v 在执行脚本之前，先将脚本的内容显示在屏幕上
-x 将用到的脚本内容显示在屏幕上，与-v稍微不同

注意：
1.在条件判断时一般使用"$var"的形式，这是为了防止出现var为空的情况，例如：if [ $var = "yes" ]中，如果var为空，那么会出现if [ = "yes" ]的情况，这是不合法的，而if [ "$var" = "yes"]则不会出现该问题。