TP学习笔记

ThinkPHP采用单一入口模式访问应用，对应用的所有请求都定向到应用的入口文件，系统会从URL参数中解析当前请求的模块、控制器和操作，下面是一个标准的URL访问格式：
http://serverName/index.php/模块/控制器/操作

如果我们直接访问入口文件的话，由于URL中没有模块、控制器和操作，因此系统会访问默认模块（Home）下面的默认控制器（Index）的默认操作（index），因此下面的访问是等效的：

http://serverName/index.php
http://serverName/index.php/Home/Index/index
复制代码
这种URL模式就是系统默认的PATHINFO模式，不同的URL模式获取模块和操作的方法不同，ThinkPHP支持的URL模式有四种：普通模式、PATHINFO、REWRITE和兼容模式。

 

这里用到了M函数，是ThinkPHP内置的实例化模型的方法，而且用M方法实例化模型不需要创建对应的模型类，你可以理解为M方法是直接在操作底层的Model类，而Model类具备基本的CURD操作方法。

M('Data') 实例化后，就可以对think_data数据表（think_ 是我们在项目配置文件中定义的数据表前缀）进行操作（包括CURD）了，M函数的用法还有很多，我们以后会深入了解。

CURD是一个数据库技术中的缩写词，一般的项目开发的各种参数的基本功能都是CURD。它代表创建（Create）、更新（Update）、读取（Read）和删除（Delete）操作。CURD 定义了用于处理数据的基本原子操作。之所以将CURD 提升到一个技术难题的高度是因为完成一个涉及在多个数据库系统中进行CURD操作的汇总相关的活动，其性能可能会随数据关系的变化而有非常大的差异。

CURD在具体的应用中并非一定使用create、update 、read和delete字样的方法，但是他们完成的功能是一致的

我们并没有在控制器里面定义add操作方法，但是很显然，访问是正常的。因为ThinkPHP在没有找到对应操作方法的情况下，会检查是否存在对应的模板文件，由于我们有对应的add模板文件，所以控制器就直接渲染该模板文件输出了。所以说对于没有任何实际逻辑的操作方法，我们只需要直接定义对应的模板文件就行了。

 

在insert操作方法中用了D函数，和M函数不同，D函数需要有对应的模型类，下面我们就来创建模型类。

 

如果你的数据完全是内部操作写入而不是通过表单的话（也就是说可以充分信任数据的安全），那么可以直接使用add方法，如：

$Form = D('Form');
$data['title'] = 'ThinkPHP';
$data['content'] = '表单内容';
$Form->add($data);
也可以支持对象方式操作：

$Form = D('Form');
$Form->title = 'ThinkPHP';
$Form->content = '表单内容';
$Form->add();

对象方式操作的时候，add方法无需传入数据，会自动识别当前的数据对象赋值。

这里之所以用M方法而没有用D方法，是因为find方法是基础模型类Model中的方法，所以没有必要浪费开销去实例化FormModel类（即使已经定义了FormModel类）。我们通常采用find方法读取某个数据

如果你只需要查询某个字段的值，还可以使用getField方法，
例如：

$Form = M("Form");
// 获取标题
$title = $Form->where('id=3')->getField('title');

上面的用法表示获取id值为3的数据的title字段值。其实getField方法有很多用法，但是获取某个字段的值是getField方法最常规的用法。
查询操作是最常用的操作，尤其是涉及到复杂的查询条件，我们会在查询语言一章对查询进行更加详细的讲解。

 

数据的更新操作在ThinkPHP使用save方法，可以看到，我们同样可以使用create方法创建表单提交的数据，而save方法则会自动把当前的数据对象更新到数据库，而更新的条件其实就是表的主键，这就是我们在编辑页面要把主键的值作为隐藏字段一起提交的原因。

有些时候，我们只需要修改某个字段的值，就可以使用setField方法，而不需要每次都调用save方法。

 

 

 

我们掌握了基本的数据CURD方法，但更多的情况下面，由于业务逻辑的差异，CURD操作往往不是那么简单，尤其是复杂的业务逻辑下面，这也是ActiveRecord模式的不足之处。ThinkPHP的查询语言配合连贯操作可以很好解决复杂的业务逻辑需求，本篇我们就首先来深入了解下框架的查询语言。

介绍
ThinkPHP内置了非常灵活的查询方法，可以快速的进行数据查询操作，查询条件可以用于读取、更新和删除等操作，主要涉及到where方法等连贯操作即可，无论是采用什么数据库，你几乎采用一样的查询方法（个别数据库例如Mongo在表达式查询方面会有所差异），系统帮你解决了不同数据库的差异性，因此我们把框架的这一查询方式称之为查询语言。查询语言也是ThinkPHP框架的ORM亮点，让查询操作更加简单易懂

 

一、使用字符串作为查询条件
$User = M("User"); // 实例化User对象
$User->where('type=1 AND status=1')->select();
二、使用数组作为查询条件（把多个条件复制给数组 最后传入条件数组）

$User = M("User"); // 实例化User对象

$condition['name'] = 'thinkphp';

$condition['status'] = 1;
// 把查询条件传入查询方法

通过使用 _logic 定义查询逻辑：$condition['_logic'] = 'OR'; 还有and
$User->where($condition)->select();

三、使用对象方式来查询

$User = M("User"); // 实例化User对象

// 定义查询条件

$condition = new stdClass();

$condition->name = 'thinkphp';

$condition->status= 1;

$User->where($condition)->select();

使用对象方式查询和使用数组查询的效果是相同的，并且是可以互换的，大多数情况下，我们建议采用数组方式更加高效。

表达式查询
上面的查询条件仅仅是一个简单的相等判断，可以使用查询表达式支持更多的SQL查询语法，也是ThinkPHP查询语言的精髓，查询表达式的使用格式：

$map['字段名'] = array('表达式','查询条件');

表达式 含义
EQ 等于（=）
NEQ 不等于（<>）
GT 大于（>）
EGT 大于等于（>=）
LT 小于（<）
ELT 小于等于（<=）
LIKE 模糊查询
[NOT] BETWEEN （不在）区间查询
[NOT] IN （不在）IN 查询
EXP 表达式查询，支持SQL语法
示例如下：

EQ ：等于（=）
例如：

$map['id'] = array('eq',100);
和下面的查询等效

$map['id'] = 100;
表示的查询条件就是id = 100

NEQ： 不等于（<>）
例如：

$map['id'] = array('neq',100);
表示的查询条件就是 id <> 100

GT：大于（>）
例如：

$map['id'] = array('gt',100);
表示的查询条件就是 id > 100

 

 

快捷查询
采用快捷查询方式，可以进一步简化查询条件的写法，例如：

一、实现不同字段相同的查询条件
$User = M("User"); // 实例化User对象
$map['name|title'] = 'thinkphp';
// 把查询条件传入查询方法
$User->where($map)->select();
查询条件就变成
name= 'thinkphp' OR title = 'thinkphp'

二、实现不同字段不同的查询条件
$User = M("User"); // 实例化User对象
$map['status&title'] =array('1','thinkphp','_multi'=>true);
// 把查询条件传入查询方法
$User->where($map)->select();
'_multi'=>true必须加在数组的最后，表示当前是多条件匹配，这样查询条件就变成
status= 1 AND title = 'thinkphp'

，查询字段支持更多的，例如：

$map['status&score&title'] =array('1',array('gt','0'),'thinkphp','_multi'=>true);
查询条件就变成
status= 1 AND score >0 AND title = 'thinkphp'

注意：快捷查询方式中“|”和“&”不能同时使用。

 

区间查询
ThinkPHP支持对某个字段的区间查询，例如：

$map['id'] = array(array('gt',1),array('lt',10),'and') ;
得到的查询条件是：

(`id` > 1) AND (`id` < 10)

最后一个可以是AND、 OR或者 XOR运算符，如果不写，默认是AND运算。

 

区间查询的条件可以支持普通查询的所有表达式，也就是说类似LIKE、GT和EXP这样的表达式都可以支持。另外区间查询还可以支持更多的条件，只要是针对一个字段的条件都可以写到一起，例如：

$map['name'] = array(array('like','%a%'), array('like','%b%'), array('like','%c%'), 'ThinkPHP','or');
最后的查询条件是：

(`name` LIKE '%a%') OR (`name` LIKE '%b%') OR (`name` LIKE '%c%') OR (`name` = 'ThinkPHP')

 

 

组合查询
组合查询的主体还是采用数组方式查询，只是加入了一些特殊的查询支持，包括字符串模式查询（_string）、复合查询（_complex）、请求字符串查询（_query），混合查询中的特殊查询每次查询只能定义一个，由于采用数组的索引方式，索引相同的特殊查询会被覆盖。

一、字符串模式查询（采用_string 作为查询条件）
数组条件还可以和字符串条件混合使用，例如：

$User = M("User"); // 实例化User对象
$map['id'] = array('neq',1);
$map['name'] = 'ok';
$map['_string'] = 'status=1 AND score>10';
$User->where($map)->select();
最后得到的查询条件就成了：

( `id` != 1 ) AND ( `name` = 'ok' ) AND ( status=1 AND score>10 )
二、请求字符串查询方式
请求字符串查询是一种类似于URL传参的方式，可以支持简单的条件相等判断。

$map['id'] = array('gt','100');
$map['_query'] = 'status=1&score=100&_logic=or';
得到的查询条件是：

`id`>100 AND (`status` = '1' OR `score` = '100')
三、复合查询
复合查询相当于封装了一个新的查询条件，然后并入原来的查询条件之中，所以可以完成比较复杂的查询条件组装。
例如：

$where['name'] = array('like', '%thinkphp%');
$where['title'] = array('like','%thinkphp%');
$where['_logic'] = 'or';
$map['_complex'] = $where;
$map['id'] = array('gt',1);
查询条件是

( id > 1) AND ( ( name like '%thinkphp%') OR ( title like '%thinkphp%') )
复合查询使用了_complex作为子查询条件来定义，配合之前的查询方式，可以非常灵活的制定更加复杂的查询条件。
很多查询方式可以相互转换，例如上面的查询条件可以改成：

$where['id'] = array('gt',1);
$where['_string'] = ' (name like "%thinkphp%") OR ( title like "%thinkphp") ';
复制代码
最后生成的SQL语句是一致的。

 

统计查询
在应用中我们经常会用到一些统计数据，例如当前所有（或者满足某些条件）的用户数、所有用户的最大积分、用户的平均成绩等等，ThinkPHP为这些统计操作提供了一系列的内置方法，包括：

方法 说明
Count 统计数量，参数是要统计的字段名（可选）
Max 获取最大值，参数是要统计的字段名（必须）
Min 获取最小值，参数是要统计的字段名（必须）
Avg 获取平均值，参数是要统计的字段名（必须）
Sum 获取总分，参数是要统计的字段名（必须）
用法示例：

$User = M("User"); // 实例化User对象
// 获取用户数：
$userCount = $User->count();
// 或者根据字段统计：
$userCount = $User->count("id");
// 获取用户的最大积分：
$maxScore = $User->max('score');
// 获取积分大于0的用户的最小积分：
$minScore = $User->where('score>0')->min('score');
// 获取用户的平均积分：
$avgScore = $User->avg('score');
// 统计用户的总成绩：
$sumScore = $User->sum('score');
复制代码
并且所有的统计查询均支持连贯操作的使用。

 

 

SQL查询
ThinkPHP内置的ORM和ActiveRecord模式实现了方便的数据存取操作，而且新版增加的连贯操作功能更是让这个数据操作更加清晰，但是ThinkPHP仍然保留了原生的SQL查询和执行操作支持，为了满足复杂查询的需要和一些特殊的数据操作，SQL查询的返回值因为是直接返回的Db类的查询结果，没有做任何的处理。主要包括下面两个方法：

1、query方法
query 执行SQL查询操作
用法 query($sql,$parse=false)
参数 sql（必须）：要查询的SQL语句 parse（可选）：是否需要解析SQL
返回值 如果数据非法或者查询错误则返回false，否则返回查询结果数据集（同select方法）
使用示例：

$Model = new Model() // 实例化一个model对象 没有对应任何数据表
$Model->query("select * from think_user where status=1");
如果你当前采用了分布式数据库，并且设置了读写分离的话，query方法始终是在读服务器执行，因此query方法对应的都是读操作，而不管你的SQL语句是什么。
2、execute方法
execute 用于更新和写入数据的sql操作
用法 execute($sql,$parse=false)
参数 sql（必须）：要执行的SQL语句 parse（可选）：是否需要解析SQL
返回值 如果数据非法或者查询错误则返回false ，否则返回影响的记录数
使用示例：

$Model = new Model() // 实例化一个model对象 没有对应任何数据表
$Model->execute("update think_user set name='thinkPHP' where status=1");
复制代码
如果你当前采用了分布式数据库，并且设置了读写分离的话，execute方法始终是在写服务器执行，因此execute方法对应的都是写操作，而不管你的SQL语句是什么。

 

动态查询
借助PHP5语言的特性，ThinkPHP实现了动态查询，核心模型的动态查询方法包括下面几种：

方法名 说明 举例
getBy 根据字段的值查询数据 例如，getByName,getByEmail
getFieldBy 根据字段查询并返回某个字段的值 例如，getFieldByName
一、getBy动态查询
该查询方式针对数据表的字段进行查询。例如，User对象拥有id,name,email,address 等属性，那么我们就可以使用下面的查询方法来直接根据某个属性来查询符合条件的记录。

$user = $User->getByName('liu21st');
$user = $User->getByEmail('liu21st@gmail.com');
$user = $User->getByAddress('中国深圳');
暂时不支持多数据字段的动态查询方法，请使用find方法和select方法进行查询。

二、getFieldBy动态查询
针对某个字段查询并返回某个字段的值，例如

$userId = $User->getFieldByName('liu21st','id');
表示根据用户的name获取用户的id值。

 

子查询
子查询有两种使用方式：

1、使用select方法
当select方法的参数为false的时候，表示不进行查询只是返回构建SQL，例如：

// 首先构造子查询SQL
$subQuery = $model->field('id,name')->table('tablename')->group('field')->where($where)->order('status')->select(false);
当select方法传入false参数的时候，表示不执行当前查询，而只是生成查询SQL。

2、使用buildSql方法
$subQuery = $model->field('id,name')->table('tablename')->group('field')->where($where)->order('status')->buildSql();
调用buildSql方法后不会进行实际的查询操作，而只是生成该次查询的SQL语句（为了避免混淆，会在SQL两边加上括号），然后我们直接在后续的查询中直接调用。

// 利用子查询进行查询
$model->table($subQuery.' a')->where()->order()->select()
构造的子查询SQL可用于ThinkPHP的连贯操作方法，例如table where等。

 

 

 

 

连贯操作可以有效的提高数据存取的代码清晰度和开发效率，并且支持所有的CURD操作，也是ThinkPHP的ORM中的一个亮点。使用也比较简单， 假如我们现在要查询一个User表的满足状态为1的前10条记录，并希望按照用户的创建时间排序 ，代码如下：

$User->where('status=1')->order('create_time')->limit(10)->select();
复制代码
这里的where、order和limit方法就称之为连贯操作方法，除了select方法必须放到最后一个外（因为select方法并不是连贯操作方法），连贯操作的方法调用顺序没有先后

 

连贯操作仅在当次查询或者操作有效，完成后会自动清空连贯操作的所有传值（有个别特殊的连贯操作会记录当前的传值，如cache连贯操作）。简而言之，连贯操作的结果不会带入以后的查询。
系统支持的连贯操作方法有：

方法 作用 支持的参数类型
where* 用于查询或者更新条件的定义 字符串、数组和对象
table 用于定义要操作的数据表名称 字符串和数组
alias 用于给当前数据表定义别名 字符串
data 用于新增或者更新数据之前的数据对象赋值 数组和对象
field 用于定义要查询的字段（支持字段排除） 字符串和数组
order 用于对结果排序 字符串和数组
limit 用于限制查询结果数量 字符串和数字
page 用于查询分页（内部会转换成limit） 字符串和数字
group 用于对查询的group支持 字符串
having 用于对查询的having支持 字符串
join* 用于对查询的join支持 字符串和数组
union* 用于对查询的union支持 字符串、数组和对象
distinct 用于查询的distinct支持 布尔值
lock 用于数据库的锁机制 布尔值
cache 用于查询缓存 支持多个参数（以后在缓存部分再详细描述）
relation 用于关联查询（需要关联模型扩展支持） 字符串
validate 用于数据自动验证 数组
auto 用于数据自动完成 数组
filter 用于数据过滤 字符串
scope* 用于命名范围 字符串、数组
bind* 用于数据绑定操作 数组或多个参数
token 用于令牌验证 布尔值
comment 用于SQL注释 字符串
index 用于数据集的强制索引 字符串
strict 用于数据入库的严格检测 布尔值
所有的连贯操作都返回当前的模型实例对象，其中带*标识的表示支持多次调用

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

I方法是ThinkPHP用于更加方便和安全的获取系统输入变量，可以用于任何地方，用法格式如下：

I('变量类型.变量名/修饰符',['默认值'],['过滤方法'],['额外数据源'])

变量类型是指请求方式或者输入类型，包括：

变量类型 含义
get 获取GET参数
post 获取POST参数
param 自动判断请求类型获取GET、POST或者PUT参数
request 获取REQUEST 参数
put 获取PUT 参数
session 获取 $_SESSION 参数
cookie 获取 $_COOKIE 参数
server 获取 $_SERVER 参数
globals 获取 $GLOBALS参数
path 获取 PATHINFO模式的URL参数
data 获取 其他类型的参数，需要配合额外数据源参数
注意：变量类型不区分大小写。
变量名则严格区分大小写。
默认值和过滤方法均属于可选参数。
我们以GET变量类型为例，说明下I方法的使用：

echo I('get.id'); // 相当于 $_GET['id']
echo I('get.name'); // 相当于 $_GET['name']
支持默认值：

echo I('get.id',0); // 如果不存在$_GET['id'] 则返回0
echo I('get.name',''); // 如果不存在$_GET['name'] 则返回空字符串
采用方法过滤：

// 采用htmlspecialchars方法对$_GET['name'] 进行过滤，如果不存在则返回空字符串
echo I('get.name','','htmlspecialchars');
支持直接获取整个变量类型，例如：

// 获取整个$_GET 数组
I('get.');
用同样的方式，我们可以获取post或者其他输入类型的变量，例如：

I('post.name','','htmlspecialchars'); // 采用htmlspecialchars方法对$_POST['name'] 进行过滤，如果不存在则返回空字符串
I('session.user_id',0); // 获取$_SESSION['user_id'] 如果不存在则默认为0
I('cookie.'); // 获取整个 $_COOKIE 数组
I('server.REQUEST_METHOD'); // 获取 $_SERVER['REQUEST_METHOD']
param变量类型是框架特有的支持自动判断当前请求类型的变量获取方式，例如：

echo I('param.id');

如果当前请求类型是GET，那么等效于 $_GET['id']，如果当前请求类型是POST或者PUT，那么相当于获取 $_POST['id'] 或者 PUT参数id。

由于param类型是I函数默认获取的变量类型，因此事实上param变量类型的写法可以简化为：

I('id'); // 等同于 I('param.id')
I('name'); // 等同于 I('param.name')
path类型变量可以用于获取PATHINFO方式的URL参数（必须是PATHINFO模式参数有效，无论是GET还是POST方式都有效）

 

 

I方法的所有获取变量如果没有设置过滤方法的话都会进行htmlspecialchars过滤，那么：// 等同于
htmlspecialchars($_GET['name'])
I('get.name');
，该参数也可以设置支持多个过滤，例如：

'DEFAULT_FILTER' => 'strip_tags,htmlspecialchars'
设置后，我们在使用：

// 等同于 htmlspecialchars(strip_tags($_GET['name']))
I('get.name');
如果我们在使用I方法的时候 指定了过滤方法，那么就会忽略DEFAULT_FILTER的设置，例如：

// 等同于 strip_tags($_GET['name'])
echo I('get.name','','strip_tags');

 

 

过滤名称必须是filter_list方法中的有效值（不同的服务器环境可能有所不同），可能支持的包括：

int
boolean
float
validate_regexp
validate_url
validate_email
validate_ip
string
stripped
encoded
special_chars
unsafe_raw
email
url
number_int
number_float
magic_quotes
callback
也可以支持正则匹配过滤，例如：

// 采用正则表达式进行变量过滤
I('get.name','','/^[A-Za-z]+$/');
I('get.id',0,'/^\d+$/');
如果正则匹配不通过的话，则返回默认值。

 

 

 

 

变量修饰符
I函数支持对变量使用修饰符功能，可以更好的过滤变量。

用法如下：
I('变量类型.变量名/修饰符');

例如：

I('get.id/d');
I('post.name/s');
I('post.ids/a');
可以使用的修饰符包括：

修饰符 作用
s 强制转换为字符串类型
d 强制转换为整形类型
b 强制转换为布尔类型
a 强制转换为数组类型
f 强制转换为浮点类型

 

 

 

 

 

 

 

 

 

模板定义
每个模块的模板文件是独立的，为了对模板文件更加有效的管理，ThinkPHP对模板文件进行目录划分，默认的模板文件定义规则是：

视图目录/[模板主题/]控制器名/操作名+模板后缀
默认的视图目录是模块的View目录（模块可以有多个视图文件目录，这取决于你的应用需要），框架的默认视图文件后缀是.html。

大多数情况下你不需要主题功能，因此新版模板主题默认是空（表示不启用模板主题功能）。
一般情况下，模板文件都在模块的视图目录下面，并且是以模块下面的控制器名为目录，然后是每个控制器的具体操作模板文件，例如：
User控制器的add操作对应的模板文件就应该是：./Application/Home/View/User/add.html

如果你的默认视图层不是View，例如：

// 设置默认的视图层名称
'DEFAULT_V_LAYER' => 'Template',
那么，对应的模板文件就变成了：./Application/Home/Template/User/add.html。

模板文件的默认后缀的情况是.html，也可以通过 TMPL_TEMPLATE_SUFFIX 来配置成其他的。例如，我们可以配置：

'TMPL_TEMPLATE_SUFFIX'=>'.tpl'
定义后，User控制器的add操作 对应的模板文件就变成是： ./Application/Home/View/User/add.tpl

如果觉得目录结构太深，可以通过设置 TMPL_FILE_DEPR 参数来配置简化模板的目录层次，例如设置：

'TMPL_FILE_DEPR'=>'_'
默认的模板文件就变成了：./Application/Home/View/User_add.html

 

渲染模板输出最常用的是使用display方法，调用格式：

display('[模板文件]'[,'字符编码'][,'输出类型'])
模板文件的写法支持下面几种：

用法 描述
不带任何参数 自动定位当前操作的模板文件
[模块@][控制器:][操作] 常用写法，支持跨模块 模板主题可以和theme方法配合
完整的模板文件名 直接使用完整的模板文件名（包括模板后缀）
下面是一个最典型的用法，不带任何参数：

// 不带任何参数 自动定位当前操作的模板文件
$this->display();
表示系统会按照默认规则自动定位模板文件，其规则是：

如果当前没有启用模板主题则定位到：当前模块/默认视图目录/当前控制器/当前操作.html ；
如果有启用模板主题则定位到：当前模块/默认视图目录/当前主题/当前控制器/当前操作.html；
如果有更改TMPL_FILE_DEPR设置（假设 'TMPL_FILE_DEPR'=>'_'）的话，则上面的自动定位规则变成： 当前模块/默认视图目录/当前控制器_当前操作.html 和 当前模块/默认视图目录/当前主题/当前控制器_当前操作.html。
所以通常display方法无需带任何参数即可输出对应的模板，这是模板输出的最简单的用法。

 

 

 

通常默认的视图目录是View
如果没有按照模板定义规则来定义模板文件（或者需要调用其他控制器下面的某个模板），可以使用：

// 指定模板输出
// 表示调用当前控制器下面的edit模板
$this->display('edit');
或者指定控制器

// 表示调用Member控制器下面的read模板
$this->display('Member:read');
如果我们使用了模板主题功能，那么也可以支持跨主题调用，使用：

// 调用blue主题下面的User控制器的edit模板
$this->theme('blue')->display('User:edit');
渲染输出不需要写模板文件的路径和后缀，确切地说，这里面的控制器和操作并不一定需要有实际对应的控制器和操作，只是一个目录名称和文件名称而已，例如，你的项目里面可能根本没有Public控制器，更没有Public控制器的menu操作，但是一样可以使用

$this->display('Public:menu');
输出这个模板文件。

display方法支持在渲染输出的时候指定输出编码和类型，例如，可以指定编码和类型：

// 输出XML页面类型（配合你的应用需求可以输出很多类型）
$this->display('read', 'utf-8', 'text/xml');

 

 

如果需要获取渲染模板的输出内容而不是直接输出，可以使用fetch方法。

fetch方法的用法除了不需要指定输出编码和类型外其它和display基本一致，格式：

fetch('模板文件')
模板文件的调用方法和display方法完全一样，区别就在于fetch方法渲染后不是直接输出，而是返回渲染后的内容，例如：

$content = $this->fetch('Member:edit');
使用fetch方法获取渲染内容后，你可以进行过滤和替换等操作，或者用于对输出的复杂需求。

 

渲染内容
如果你没有定义任何模板文件，或者把模板内容存储到数据库中的话，你就需要使用show方法来渲染输出了，show方法的调用格式：

show('渲染内容'[,'字符编码'][,'输出类型'])
例如，

$this->show($content);
// 也可以指定编码和类型
$this->show($content, 'utf-8', 'text/xml');
注意：show方法中的内容也可以支持模板解析。

 

 

 

 

模板赋值
如果要在模板中输出变量，必须在在控制器中把变量传递给模板，系统提供了assign方法对模板变量赋值，无论何种变量类型都统一使用assign赋值。

$this->assign('name',$value);
assign方法必须在display和show方法之前调用，并且系统只会输出设定的变量，其它变量不会输出（系统变量例外），一定程度上保证了变量的安全性。

系统变量可以通过特殊的标签输出，无需赋值模板变量
赋值后，就可以在模板文件中输出变量了，如果使用的是内置模板的话，就可以这样输出：

{$name}
如果要同时输出多个模板变量，可以使用下面的方式：

$array['name'] = 'thinkphp';
$array['email'] = 'liu21st@gmail.com';
$array['phone'] = '12335678';
$this->assign($array);
这样，就可以在模板文件中同时输出name、email和phone三个变量。

模板变量的输出根据不同的模板引擎有不同的方法，我们在后面会专门讲解内置模板引擎的用法。如果你使用的是PHP本身作为模板引擎的话 ，就可以直接在模板文件里面输出了：

<?php echo $name.'['.$email.''.$phone.']';?>
如果采用内置的模板引擎，可以使用：

{$name} [ {$email} {$phone} ]
输出同样的内容。

变量输出（这里主要是指标量类型的输出）的方法很简单，例如，在控制器中我们给模板变量赋值：

$name = 'ThinkPHP';
$this->assign('name',$name);
$this->display();
然后就可以在模板中使用：

Hello,{$name}！
模板编译后的结果就是：

Hello,<?php echo($name);?>！
这样，运行的时候就会在模板中显示：

Hello,ThinkPHP！
注意模板标签的{和$之间不能有任何的空格，否则标签无效。
所以，下面的标签

Hello,{ $name}！
将不会正常输出name变量，而是直接保持不变输出：

Hello,{ $name}！

 

模板中我们可以用下面的方式输出：

Name：{$data.name}
Email：{$data.email}
或者用下面的方式也是有效：

Name：{$data['name']}
Email：{$data['email']}

如果data变量是一个对象（并且包含有name和email两个属性），那么可以用下面的方式输出：

Name：{$data:name}
Email：{$data:email}
或者

Name：{$data->name}
Email：{$data->email}

 

系统变量
普通的模板变量需要首先赋值后才能在模板中输出，但是系统变量则不需要，可以直接在模板中输出，系统变量的输出通常以{$Think 打头，例如：

{$Think.server.script_name} // 输出$_SERVER['SCRIPT_NAME']变量
{$Think.session.user_id} // 输出$_SESSION['user_id']变量
{$Think.get.pageNumber} // 输出$_GET['pageNumber']变量
{$Think.cookie.name} // 输出$_COOKIE['name']变量
支持输出$_SERVER、$_ENV、 $_POST、 $_GET、 $_REQUEST、$_SESSION和 $_COOKIE变量。

还可以输出常量

{$Think.const.MODULE_NAME}
或者直接使用

{$Think.MODULE_NAME}

 

 

 

 

 

 

使用函数
我们往往需要对模板输出变量使用函数，可以使用：

{$data.name|md5}
编译后的结果是：

<?php echo (md5($data['name'])); ?>
如果函数有多个参数需要调用，则使用：

{$create_time|date="y-m-d",###}
表示date函数传入两个参数，每个参数用逗号分割，这里第一个参数是y-m-d，第二个参数是前面要输出的create_time变量，因为该变量是第二个参数，因此需要用###标识变量位置，编译后的结果是：

<?php echo (date("y-m-d",$create_time)); ?>
如果前面输出的变量在后面定义的函数的第一个参数，则可以直接使用：

{$data.name|substr=0,3}
表示输出

<?php echo (substr($data['name'],0,3)); ?>
虽然也可以使用：

{$data.name|substr=###,0,3}
但完全没用这个必要。

还可以支持多个函数过滤，多个函数之间用“|”分割即可，例如：

{$name|md5|strtoupper|substr=0,3}
编译后的结果是：

<?php echo (substr(strtoupper(md5($name)),0,3)); ?>
函数会按照从左到右的顺序依次调用。
如果你觉得这样写起来比较麻烦，也可以直接这样写：

{:substr(strtoupper(md5($name)),0,3)}
默认值
我们可以给变量输出提供默认值，例如：

{$user.nickname|default="这家伙很懒，什么也没留下"}
对系统变量依然可以支持默认值输出，例如：

{$Think.get.name|default="名称为空"}
默认值和函数可以同时使用，例如：

{$Think.get.name|getName|default="名称为空"}
使用运算符
我们可以对模板输出使用运算符，包括对“+”“ –” “*” “/”和“%”的支持。

例如：

运算符 使用示例
+ {$a+$b}
- {$a-$b}
* {$a*$b}
/ {$a/$b}
% {$a%$b}
++ {$a++} 或 {++$a}
-- {$a--} 或 {--$a}
综合运算 {$a+$b*10+$c}
在使用运算符的时候，不再支持点语法和常规的函数用法，例如：

{$user.score+10} //错误的
{$user['score']+10} //正确的
{$user['score']*$user['level']} //正确的
{$user['score']|myFun*10} //错误的
{$user['score']+myFun($user['level'])} //正确的

模板可以支持三元运算符，例如：

{$status?'正常':'错误'}
{$info['status']?$info['msg']:$info['error']}
三元运算符中暂时不支持点语法，因此下面的写法是错误的：

{$info.status?$info.msg:$info.error}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

循环输出
循环输出主要是使用volist和foreach标签输出。

VOLIST
volist标签通常用于查询数据集（select方法）的结果输出，通常模型的select方法返回的结果是一个二维数组，可以直接使用volist标签进行输出。

在控制器中首先对模版赋值：

$User = M('User');
$list = $User->limit(10)->select();
$this->assign('list',$list);
在模版定义如下，循环输出用户的编号和姓名：

<volist name="list" id="vo">
{$vo.id}:{$vo.name}<br/>
</volist>
Volist标签的name属性表示模板赋值的变量名称，因此不可随意在模板文件中改变。id表示当前的循环变量，可以随意指定，但确保不要和name属性冲突，例如：

<volist name="list" id="data">
{$data.id}:{$data.name}<br/>
</volist>
支持输出查询结果中的部分数据，例如输出其中的第5～15条记录

<volist name="list" id="vo" offset="5" length='10'>
{$vo.name}
</volist>
输出偶数记录

<volist name="list" id="vo" mod="2" >
<eq name="mod" value="1">{$vo.name}</eq>
</volist>
Mod属性还用于控制一定记录的换行，例如：

<volist name="list" id="vo" mod="5" >
{$vo.name}
<eq name="mod" value="4"><br/></eq>
</volist>
为空的时候输出提示：

<volist name="list" id="vo" empty="暂时没有数据" >
{$vo.id}|{$vo.name}
</volist>
empty属性不支持直接传入html语法，但可以支持变量输出，例如：

$this->assign('empty','<span class="empty">没有数据</span>');
$this->assign('list',$list);
然后在模板中使用：

<volist name="list" id="vo" empty="$empty" >
{$vo.id}|{$vo.name}
</volist>
模板中可以直接使用函数设定数据集，而不需要在控制器中给模板变量赋值传入数据集变量，如：

<volist name=":fun('arg')" id="vo">
{$vo.name}
</volist>
FOREACH
除了volist标签之外，还可以使用foreach标签，foreach标签类似与volist标签，只是更加简单，没有太多额外的属性，例如：

<foreach name="list" item="vo">
{$vo.id}:{$vo.name}
</foreach>
name表示数据源 item表示循环变量。
foreach标签还可以输出一维数组，例如：

<foreach name="list" item="vo" >
{$key}|{$vo}
</foreach>

 

 

<switch name="User.level">

<case value="1">value1</case>

<case value="2">value2</case>

<default />default
</switch>
对于case的value属性可以支持多个条件的判断，使用”|”进行分割，例如：

<switch name="Think.get.type">
<case value="gif|png|jpg">图像格式</case>
<default />其他格式
</switch>
表示如果$_GET["type"] 是gif、png或者jpg的话，就判断为图像格式。

Case标签还有一个break属性，表示是否需要break，默认是会自动添加break，如果不要break，可以使用：

<switch name="Think.get.userId|abs">
<case value="1" break="0">admin</case>
<case value="2">admin</case>
<default />default
</switch>
也可以对case的value属性使用变量，例如：

<switch name="User.userId">
<case value="$adminId">admin</case>
<case value="$memberId">member</case>
<default />default
</switch>

 

 

要求name变量的值等于value就输出，可以使用：

<eq name="name" value="value">value</eq>

 

 

可以支持和else标签混合使用：

<eq name="name" value="value">
相等
<else/>
不相等
</eq>

 

 

 

范围判断标签
范围判断标签包括in、notin、between和notbetween四个标签，都用于判断变量是否中某个范围。

IN和NOTIN
用法：
假设我们中控制器中给id赋值为1：

$id = 1;
$this->assign('id',$id);
我们可以使用in标签来判断模板变量是否在某个范围内，例如：

<in name="id" value="1,2,3">
id在范围内
</in>
最后会输出：id在范围内。

如果判断不在某个范围内，可以使用：

<notin name="id" value="1,2,3">
id不在范围内
</notin>
可以把上面两个标签合并成为：

<in name="id" value="1,2,3">
id在范围内
<else/>
id不在范围内
</in>
name属性还可以支持直接判断系统变量，例如：

<in name="Think.get.id" value="1,2,3">
$_GET['id'] 在范围内
</in>
value属性也可以使用变量，例如：

<in name="id" value="$range">
id在范围内
</in>
$range变量可以是数组，也可以是以逗号分隔的字符串。

BETWEEN 和 NOTBETWEEN
可以使用between标签来判断变量是否在某个区间范围内，可以使用：

<between name="id" value="1,10">
输出内容1
</between>
同样，可以使用notbetween标签来判断变量不在某个范围内：

<notbetween name="id" value="1,10">
输出内容2
</notbetween>
也可以使用else标签把两个用法合并，例如：

<between name="id" value="1,10">
输出内容1
<else/>
输出内容2
</between>
当使用between标签的时候，value只需要一个区间范围，也就是只支持两个值，后面的值无效，例如

<between name="id" value="1,3,10">
输出内容1
</between>
实际判断的范围区间是1~3，而不是1~10，也可以支持字符串判断，例如：

<between name="id" value="A,Z">
输出内容1
</between>
name属性可以直接使用系统变量，例如：

<between name="Think.post.id" value="1,5">
输出内容1
</between>
value属性也可以使用变量，例如：

<between name="id" value="$range">
输出内容1
</between>
赋值判断标签
可以使用present、empty等标签进行赋值判断输出。

present标签用于判断某个变量是否已经定义，用法：

<present name="name">
name已经赋值
<else />
name还没有赋值
</present>
name属性可以直接使用系统变量，例如：

<present name="Think.get.name">
$_GET['name']已经赋值
</present>
empty标签用于判断某个变量是否为空，用法：

name为空

name不为空

name属性可以直接使用系统变量，例如：

<empty name="Think.get.name">
$_GET['name']为空值
</empty>
DEFINED标签用于判断某个常量是否有定义，用法如下：

<defined name="NAME">
NAME常量已经定义
<else />
NAME常量未定义
</defined>

 

原生代码
Php代码可以和标签在模板文件中混合使用，可以在模板文件里面书写任意的PHP语句代码 ，包括下面两种方式：

第一种：使用php标签
例如：

<php>echo 'Hello,world!';</php>
我们建议需要使用PHP代码的时候尽量采用php标签，因为原生的PHP语法可能会被配置禁用而导致解析错误。

第二种：使用原生php代码
<?php echo 'Hello,world!'; ?>

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

公共模板和模板布局
我们学习了模板的输出后，就会发现很多应用存在大量的模板文件，如何简化模板文件的定义和公共调用就成了关键，ThinkPHP的模板引擎内置了公共模板和布局模板功能支持，可以方便的规划和公用你的模板文件。

公共模板
在当前模版文件中包含其他公用的模版文件使用include标签，标签用法：

<include file='模版表达式或者模版文件1,模版表达式或者模版文件2,...' />
使用模版表达式
模版表达式的定义规则为：

模块@主题/控制器/操作
例如：

<include file="Public/header" /> // 包含头部模版header
<include file="Public/menu" /> // 包含菜单模版menu
<include file="Blue/Public/menu" /> // 包含blue主题下面的menu模版
可以一次包含多个模版，例如：

<include file="Public/header,Public/menu" />
，包含模版文件并不会自动调用控制器的方法，也就是说包含的其他模版文件中的变量赋值需要在当前操作中完成。

 

论你使用什么方式包含外部模板，Include标签支持在包含文件的同时传入参数，例如，下面的例子我们在包含header模板的时候传入了title和keywords变量：

<include file="Public/header" title="ThinkPHP框架" keywords="开源WEB开发框架" />
就可以在包含的header.html文件里面使用title和keywords变量，如下：

<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>[title]</title>
<meta name="keywords" content="[keywords]" />
</head>
注意：如果外部模板有所更改，模板引擎并不会重新编译模板，除非在调试模式下或者缓存已经过期。如果部署模式下修改了包含的外部模板文件后，需要把模块的缓存目录清空，否则无法生效。

模板布局

 

 

 

 

 

 

 

ction参数绑定
在之前的内容中，涉及的控制器操作方法都是没有任何参数的，其实ThinkPHP可以支持操作方法的参数绑定功能。

Action参数绑定是通过直接绑定URL地址中的变量作为操作方法的参数，可以简化方法的定义甚至路由的解析,其原理是把URL中的参数（不包括模块、控制器和操作名）和控制器的操作方法中的参数（按变量名或者变量顺序）进行绑定。

按变量名绑定
默认的参数绑定方式是按照变量名进行绑定，例如，我们给Blog控制器定义了两个操作方法read和archive方法，由于read操作需要指定一个id参数，archive方法需要指定年份（year）和月份（month）两个参数，那么我们可以如下定义：

<?php
namespace Home\Controller;
use Think\Controller;
class BlogController extends Controller{
public function read($id){
echo 'id='.$id;
}
public function archive($year='2013',$month='01'){
echo 'year='.$year.'&month='.$month;
}
}
注意这里的操作方法并没有具体的业务逻辑，只是简单的示范。
URL的访问地址分别是：

http://serverName/index.php/Home/Blog/read/id/5
http://serverName/index.php/Home/Blog/archive/year/2013/month/11
两个URL地址中的id参数和year和month参数会自动和read操作方法以及archive操作方法的同名参数绑定。

变量名绑定不一定由访问URL决定，路由地址也能起到相同的作用
输出的结果依次是：

id=5
year=2013&month=11
按照变量名进行参数绑定的参数必须和URL中传入的变量名称一致，但是参数顺序不需要一致。也就是说

http://serverName/index.php/Home/Blog/archive/month/11/year/2013
和上面的访问结果是一致的，URL中的参数顺序和操作方法中的参数顺序都可以随意调整，关键是确保参数名称一致即可。

如果使用下面的URL地址进行访问，参数绑定仍然有效：

http://serverName/index.php?s=/Home/Blog/read/id/5
http://serverName/index.php?s=/Home/Blog/archive/year/2013/month/11
http://serverName/index.php?c=Blog&a=read&id=5
http://serverName/index.php?c=Blog&a=archive&year=2013&month=11
如果用户访问的URL地址是（至于为什么会这么访问暂且不提）：

http://serverName/index.php/Home/Blog/read/
那么会抛出下面的异常提示： 参数错误:id

报错的原因很简单，因为在执行read操作方法的时候，id参数是必须传入参数的，但是方法无法从URL地址中获取正确的id参数信息。由于我们不能相信用户的任何输入，因此建议你给read方法的id参数添加默认值，例如：

public function read($id=0){
echo 'id='.$id;
}
这样，当我们访问 http://serverName/index.php/Home/Blog/read/ 的时候 就会输出

id=0
当我们访问 http://serverName/index.php/Home/Blog/archive/ 的时候，输出：

year=2013&month=01
始终给操作方法的参数定义默认值是一个避免报错的好办法

 

 

 

按变量顺序绑定的方式目前仅对PATHINFO地址有效，所以下面的URL访问参数绑定会失效：

http://serverName/index.php?c=Blog&a=read&id=5
http://serverName/index.php?c=Blog&a=archive&year=2013&month=11
但是，兼容模式URL地址访问依然有效：

http://serverName/index.php?s=/Home/Blog/read/5
http://serverName/index.php?s=/Home/Blog/archive/2013/11
如果你的操作方法定义都不带任何参数或者不希望使用该功能的话，可以关闭参数绑定功能：

'URL_PARAMS_BIND' => false

 

 

 

 

 

 

 

空操作是指系统在找不到请求的操作方法的时候，会定位到当前控制器的空操作（_empty）方法来执行。

例如，下面我们用空操作功能来实现一个城市切换的功能。 我们只需要给CityController类定义一个_empty方法：

<?php
namespace Home\Controller;
use Think\Controller;
class CityController extends Controller{
public function _empty($name){
//把所有城市的操作解析到city方法
$this->city($name);
}
//注意 city方法 本身是 protected 方法
protected function city($name){
//和$name这个城市相关的处理
echo '当前城市' . $name;
}
}
接下来，我们就可以在浏览器里面输入

http://serverName/index.php/Home/City/beijing/
http://serverName/index.php/Home/City/shanghai/
http://serverName/index.php/Home/City/shenzhen/
由于City控制器并没有定义beijing、shanghai或者shenzhen操作方法，因此系统会定位到空操作方法 _empty中去解析，_empty方法的参数就是当前URL里面的操作名，因此会看到依次输出的结果是：

当前城市:beijing
当前城市:shanghai
当前城市:shenzhen
复制代码
注意：空操作方法仅在你的控制器类继承系统的Think\Controller类才有效。

 

 

空控制器
空控制器的概念是指当系统找不到请求的控制器名称的时候，系统会尝试定位空控制器(EmptyController)。

现在我们把前面的需求进一步，把URL由原来的

http://serverName/index.php/Home/City/shanghai/
变成

http://serverName/index.php/Home/shanghai/

这样更加简单的方式，如果按照传统的模式，我们必须给每个城市定义一个控制器类，然后在每个控制器类的index方法里面进行处理。可是如果使用空控制器功能，这个问题就可以迎刃而解了。

我们可以给项目定义一个EmptyController类

<?php
namespace Home\Controller;
use Think\Controller;
class EmptyController extends Controller{
public function index(){
//根据当前控制器名来判断要执行那个城市的操作
$cityName = CONTROLLER_NAME;
$this->city($cityName);
}
//注意 city方法 本身是 protected 方法
protected function city($name){
//和$name这个城市相关的处理
echo '当前城市' . $name;
}
}
接下来，我们就可以在浏览器里面输入

http://serverName/index.php/Home/beijing/
http://serverName/index.php/Home/shanghai/
http://serverName/index.php/Home/shenzhen/
由于系统并不存在beijing、shanghai或者shenzhen控制器，因此会定位到空控制器（EmptyController）去执行，会看到依次输出的结果是：

当前城市:beijing
当前城市:shanghai
当前城市:shenzhen
复制代码
空控制器和空操作还可以同时使用，用以完成更加复杂的操作。

 

前置和后置操作
_initialize方法是调用所有操作方法之前都会执行，前置和后缀操作则是针对某个特定的操作方法而言。

如果当前访问的操作是存在（必须是实际在控制器中定义过）的，系统会检测当前操作是否具有前置和后置操作，如果存在就会按照顺序执行，前置和后置操作的方法名是在要执行的方法前面加 _before_和_after_，例如：

namespace Home\Controller;
use Think\Controller;
class IndexController extends Controller{
//前置操作方法
public function _before_index(){
echo 'before<br/>';
}
public function index(){
echo 'index<br/>';
}
//后置操作方法
public function _after_index(){
echo 'after';
}
}
如果我们访问 http://serverName/index.php

结果会输出

before
index
after
对于任何操作方法我们都可以按照这样的规则来定义前置和后置方法。

如果在操作方法里面使用了exit或者error方法的话 有可能不会再执行后置方法了，例如：

namespace Home\Controller;
use Think\Controller;
class IndexController extends Controller{
//前置操作方法
public function _before_index(){
echo 'before<br/>';
}
public function index(){
echo 'index<br/>';
exit;
}
//后置操作方法
public function _after_index(){
echo 'after';
}
}
如果我们再次访问结果会输出

before
index
除了初始化、前置和后置操作之外，我们还可以在控制器以外的地方对操作方法进行扩展，这个以后会在行为扩展部分描述。

 

 

 

页面跳转
系统的Think\Controller类内置了两个页面跳转方法error和success，分别用于错误（提示）跳转和成功（提示）跳转。两个方法都会输出一个提示信息页面，然后自动跳转到指定的地址。下面是一个简单的例子：

$New = M('New'); //实例化New对象
$result = $New->add($data);
if($result){
// 成功后跳转到新闻列表页面
$this->success('新增成功，即将返回列表页面', '/New/index');
} else {
// 错误页面的默认跳转页面是返回前一页，通常不需要设置
$this->error('新增失败');
}
success和error方法有三个参数，分别是提示信息、跳转地址和跳转页面等待时间（秒），除了第一个参数外其他都是可选的。

提示信息：成功或者错误信息字符串。

跳转地址：页面跳转地址是可选的，success方法的默认跳转地址是$_SERVER["HTTP_REFERER"]，error方法的默认跳转地址是javascript:history.back(-1);。

等待时间：默认的等待时间success方法是1秒，error方法是3秒。

success和error方法都可以对应的模板，默认两个方法对应的模板是框架自带的跳转模板dispatch_jump.tpl：

//默认错误跳转对应的模板文件
'TMPL_ACTION_ERROR' => THINK_PATH . 'Tpl/dispatch_jump.tpl',
//默认成功跳转对应的模板文件
'TMPL_ACTION_SUCCESS' => THINK_PATH . 'Tpl/dispatch_jump.tpl',
success方法默认页面显示如下：

2015-06-06/557256edb73ad

error方法默认页面显示如下：

2015-06-06/557256c33274c

你可以重新定义跳转模板，通常建议直接放到项目目录下面（下面采用公共模块的模板作为项目统一的跳转模板）：

//默认错误跳转对应的模板文件
'TMPL_ACTION_ERROR' => 'Common@Public/error',
//默认成功跳转对应的模板文件
'TMPL_ACTION_SUCCESS' => 'Common@Public/success',
模板文件可以使用模板标签，并且可以使用下面的模板变量：

变量 含义
$message 页面成功提示信息
$error 页面错误提示信息
$waitSecond 跳转等待时间 单位为秒
$jumpUrl 跳转页面地址

 

 

 

 

 

 

 

 

 

重定向
如果不需要提示页面，ThinkPHP还可以实现直接重定向操作，Think\Controller类提供了redirect方法实现页面的重定向功能。

重定向到操作
redirect('重定向操作地址（一般为[控制器/操作]）','参数（字符串或者数组）','重定向等待时间（秒）','重定向提示信息')
例如：

$New = M('New'); //实例化New对象
$result = $New->add($data);
if($result){
// 停留5秒后跳转到New模块的category操作，并且显示页面跳转中字样
$this->redirect('New/category', 'cate_id=2&status=1', 5,'页面跳转中...');
} else {
// 错误页面
$this->redirect('New/error');
}
可以传入参数和设置重定向的等待时间，甚至给出等待的提示信息：

注意：重定向后会改变当前的URL地址。

重定向到URL
如果你仅仅是想重定向要一个指定的URL地址，而不是到控制器的操作方法，可以直接使用redirect函数重定向，例如：

$New = M('New'); //实例化New对象
$result = $New->add($data);
if($result){
//重定向到指定的URL地址
redirect('/New/category/cate_id/2', 5, '页面跳转中...');
}
redirect函数的第一个参数是要跳转的实际URL地址。

 

判断请求类型
在很多情况下面，我们需要判断当前操作的请求类型是GET 、POST 、PUT或 DELETE，一方面可以针对请求类型作出不同的逻辑处理，另外一方面有些情况下面需要验证安全性，过滤不安全的请求。

系统内置了一些常量用于判断请求类型，包括：

常量 说明
IS_GET 判断是否是GET方式提交
IS_POST 判断是否是POST方式提交
IS_PUT 判断是否是PUT方式提交
IS_DELETE 判断是否是DELETE方式提交
IS_AJAX 判断是否是AJAX提交
REQUEST_METHOD 当前提交类型
使用举例如下：

class UserController extends Controller{
public function update(){
if (IS_POST){
$User = M('User');
$User->create();
$User->save();
$this->success('保存完成');
}else{
$this->error('非法请求');
}
}
}
个别情况下判断AJAX请求的时候，你可能需要在表单里面添加一个隐藏域，告诉后台属于ajax方式提交，默认的隐藏域名称是ajax（可以通过VAR_AJAX_SUBMIT配置），如果是JQUERY类库的话，则无需添加任何隐藏域即可自动判断。
AJAX返回
ThinkPHP可以很好的支持AJAX请求，系统的\Think\Controller类提供了ajaxReturn方法用于AJAX调用后返回数据给客户端。并且支持JSON、JSONP、XML和EVAL四种方式给客户端接受数据，并且支持配置其他方式的数据格式返回。

ajaxReturn方法调用示例：

$data = 'ok';
$this->ajaxReturn($data);
支持返回数组数据：

$data['status'] = 1;
$data['content'] = 'content';
$this->ajaxReturn($data);
默认配置采用JSON格式返回数据（通过配置DEFAULT_AJAX_RETURN进行设置），我们可以指定格式返回，例如：

// 指定XML格式返回数据
$data['status'] = 1;
$data['content'] = 'content';
$this->ajaxReturn($data,'xml');
返回数据data可以支持字符串、数字和数组、对象，返回客户端的时候根据不同的返回格式进行编码后传输。如果是JSON/JSONP格式，会自动编码成JSON字符串，如果是XML方式，会自动编码成XML字符串，如果是EVAL方式的话，只会输出字符串data数据。

JSON和JSONP虽然只有一个字母的差别，但其实他们根本不是一回事儿：JSON是一种数据交换格式，而JSONP是一种非官方跨域数据交互协议。一个是描述信息的格式，一个是信息传递的约定方法。
默认的JSONP格式返回的处理方法是jsonpReturn，如果你采用不同的方法，可以设置：

'DEFAULT_JSONP_HANDLER' => 'myJsonpReturn', // 默认JSONP格式返回的处理方法

 

 

 

 

 

URL伪静态通常是为了满足更好的SEO效果，ThinkPHP支持伪静态URL设置，可以通过设置URL_HTML_SUFFIX参数随意在URL的最后增加你想要的静态后缀，而不会影响当前操作的正常执行。

单个URL后缀
默认情况下，伪静态的设置为html，因此下面的URL访问是等效的：

http://serverName/Home/Blog/index
http://serverName/Home/Blog/index.html
但后者更具有静态页面的URL特征，并且不会影响原来参数的使用。

但如果我们访问

http://serverName/Home/Blog/index.xml
则会提示出错。

2015-06-06/55726422017c7

除非我们设置了：

'URL_HTML_SUFFIX'=>'xml'
全后缀支持
如果我们设置伪静态后缀为空，则可以支持所有的静态后缀访问，并且会记录当前的伪静态后缀到常量 __EXT__ ，但不会影响正常的页面访问。

'URL_HTML_SUFFIX'=>''
设置后，下面的URL访问都有效：

http://serverName/Home/blog/index.html
http://serverName/Home/blog/index.shtml
http://serverName/Home/blog/index.xml
http://serverName/Home/blog/index.pdf
可以通过常量 __EXT__ 判断当前访问的后缀，例如：

if('pdf'==__EXT__){
// 输出PDF文档
}elseif('xml'==__EXT__){
// 输出XML格式文档
}
多个后缀支持
如果希望仅支持设置的多个伪静态后缀访问，可以设置如下：

// 多个伪静态后缀设置 用|分割
'URL_HTML_SUFFIX' => 'html|shtml|xml'
那么，当访问 http://serverName/Home/blog/index.pdf 的时候会报系统错误。

禁止访问后缀
可以设置禁止访问的URL后缀，例如：

'URL_DENY_SUFFIX' => 'pdf|ico|png|gif|jpg', // URL禁止访问的后缀设置
如果访问 http://serverName/Home/blog/index.pdf 就会直接返回404错误。

意：
URL_DENY_SUFFIX的优先级比URL_HTML_SUFFIX要高。

 

 

 

 

 

 

 

 

在应用开发中， 经常会遇到一些带有提示信息的跳转页面， 例如操作成功或者操作错误页面， 并且自动跳
转到另外一个目标页面。 系统的 \Think\Controller 类内置了两个跳转方法success和error， 用于页面跳转
提示， 而且可以支持ajax提交。
使用方法很简单， 举例如下：
$User = M('User'); //实例化User对象
$result = $User->add($data);
if($result){
//设置成功后跳转页面的地址， 默认的返回页面是$_SERVER['HTTP_REFERER']
$this->success('新增成功', '/User/index');
} else {
//错误页面的默认跳转页面是返回前一页， 通常不需要设置
$this->error('新增失败');
}
success和error方法的第一个参数表示提示信息， 第二个参数表示跳转地址， 第三个参数是跳转时间（ 单
位为秒） ， 例如：
ThinkPHP3.2.3完全开发手册
本文档使用 看云 构建 - 77 -
// 操作完成3秒后跳转到 /Article/index
$this->success('操作完成','/Article/index',3);
// 操作失败5秒后跳转到 /Article/error
$this->error('操作失败','/Article/error',5);
跳转地址是可选的， success方法的默认跳转地址是 $_SERVER["HTTP_REFERER"] ， error方法的默认跳
转地址是 javascript:history.back(-1);

 

 

 

 

 

Thinkphp自动验证规则(转载)
楼主：dailinsonglin 时间：2013-06-03 13:45:28 点击：2362 回复：0 脱水模式 给他打赏 只看楼主 阅读设置
　　其实说白了，这篇文章就是转给自己看的，省的下次用的时候满网络找了。有需要的同学也可以看看。自动验证是非常有用的一个技术。平常的验证基本就是，用户名是否为空，用户名是否重复，密码，重复密码是否一致。官方给的就是这些。那么我们不可能只用到这些，铁定还有别的规则，所以下面这些规则供同学借鉴，也供我自己借鉴。

 

　　array(‘name’,’/^[a-z]\w{3,}$/i’,’名字不符合要求！’);
　　array(‘password’,’/^[a-z]\w{6,30}$/i’,’密码不符合要求！’);
　　array(‘account’,’/^[A-Za-z]+$/’,’账号必须使用英文！’);

　　附上一些表单验证中比较常用的正则表达式写法：

　　匹配中文字符的正则表达式： [\一-\龥]
　　匹配双字节字符(包括汉字在内)：[^\x00-\xff]
　　匹配Email地址的正则表达式：\w+([-+.]\w+)*\w+([-.]\w+)*\.\w+([-.]\w+)*
　　匹配网址URL的正则表达式：[a-zA-z]+://[^\s]*
　　匹配帐号是否合法(字母开头，允许5-16字节，允许字母数字下划线)：^[a-zA-Z][a-zA-Z0-9_]{4,15}$
　　匹配国内电话号码：\d{3}-\d{8}|\d{4}-\d{7}
　　匹配中国邮政编码：[1-9]\d{5}(?!\d)
　　匹配ip地址：\d+\.\d+\.\d+\.\d+
　　匹配特定数字：
　　^[1-9]\d*$　 　 //匹配正整数
　　^-[1-9]\d*$ 　 //匹配负整数
　　^-?[1-9]\d*$　　 //匹配整数
　　^[1-9]\d*|0$　 //匹配非负整数（正整数 + 0）
　　^-[1-9]\d*|0$　　 //匹配非正整数（负整数 + 0）
　　^[1-9]\d*\.\d*|0\.\d*[1-9]\d*$　　 //匹配正浮点数
　　^-([1-9]\d*\.\d*|0\.\d*[1-9]\d*)$　 //匹配负浮点数
　　^-?([1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0)$　 //匹配浮点数
　　^[1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0$　　 //匹配非负浮点数（正浮点数 + 0）
　　^(-([1-9]\d*\.\d*|0\.\d*[1-9]\d*))|0?\.0+|0$　　//匹配非正浮点数（负浮点数 + 0）

　　匹配特定字符串：

　　^[A-Za-z]+$　　//匹配由26个英文字母组成的字符串
　　^[A-Z]+$　　//匹配由26个英文字母的大写组成的字符串
　　^[a-z]+$　　//匹配由26个英文字母的小写组成的字符串
　　^[A-Za-z0-9]+$　　//匹配由数字和26个英文字母组成的字符串
　　^\w+$　　//匹配由数字、26个英文字母或者下划线组成的字符串

 

 

　　实例：

　　protected $_validate = array(

　　array('username','require','用户名必须！'), // 数据是否为空 注：默认增加修改都验证

　　array('username','','用户名已经存在！',0,’unique’,1), // 在新增的时候验证username字段是否唯一

　　array('password','checkPwd','密码格式不正确',0,’function’), // 密码格式可以用chenkPwd方法自定义

　　array('repassword','password','确认密码不正确',0,’confirm’), // 验证确认密码是否和密码一致

　　array('sex','array(0,1,2)','性别必须为0,1,2',0,'in'), // 验证数据是否在一个范围内

　　array('age','number','年龄必须为数字'), // 验证数据是否为数字

　　array('email','email','邮箱格式不正确'), // 内置正则验证邮箱

　　array('email','/^/w+([-+.]/w+)*/w+([-.]/w+)*/./w+([-.]/w+)*$/','邮箱格式不正确), // 自定义正则验证数据

　　array('mypage','url','个人网址格式不正确'), // 内置正则验证URL地址

　　array('verify','****','验证码不正确',0,'equal'), // 验证数据是否等于某个值 注：****可以是随机验证码

　　array('salary','currency','薪水验证不正确','0'), // 内置验证货币数据

　　);

 

 

　　文章均属 松林's blog 原创 转载请注明转自松林's blog

 

 

 

//检查url

public function check_url($url){

if(!preg_match('/http:\/\/[\w.]+[\w\/]*[\w.]*\??[\w=&\+\%]*/is',$url)){

return false;

}

return true;

}

 

模板输出变量
{$name}
Email： {$data.email}
或者用下面的方式也是有效：
Name： {$data['name']}

对象
Email： {$data:email}
或者
Name： {$data->name}

{$Think.server.script_name} // 输出$_SERVER['SCRIPT_NAME']变量 系统变量

常量
{$Think.const.MODULE_NAME}

 

 

前言
A标签是html中常用的标签，它与button按钮是实现页面跳转的两种最常用的方式，经常在开发中我们更喜欢使用A标签，它们两者可以相互替换，但他们在执行js脚本时有着细微的区别。
使用A标签执行JS脚本的几种方式
1、href="javascript:js_method();"
这是我们最常用的方法，但是这种方法在传递this等参数的时候很容易出问题，而且javascript:协议作为a的href属性的时候不仅会导致不必要的触发window.onbeforeunload事件，在IE里面更会使gif动画图片停止播放。W3C标准不推荐在href里面执行javascript语句。
2、href="javascript:void(0);" οnclick="js_method()"
这种方法是很多网站最常用的方法，也是最周全的方法，onclick方法负责执行js函数，而void是一个操作符，void(0)返回undefined，地址不发生跳转。而且这种方法不会像第一种方法一样直接将js方法暴露在浏览器的状态栏，推荐使用此方法。
3、href="javascript:;" οnclick="js_method()"
这种方法跟跟第2种类似，区别只是执行了一条空的js代码。Href与onclick区别是每个href里的javascript方法都用try、catch包围。
4、href="#" οnclick="js_method()"
这种方法也是网上很常见的代码，#是标签内置的一个方法，代表top的作用。所以用这种方法点击后网页后返回到页面的最顶端。
5、href="#" οnclick="js_method();return false;"
这种方法点击执行了js函数后return false，页面不发生跳转，执行后还是在页面的当前位置。
综合上述，在a中调用js函数最适当的方法推荐使用后几种，注意第四种会返回页面最顶端，当有这种需求时可以使用。

 

 

 

 

 

 

 

 

模型的名字要和数据库表对应。
但是如果不对应，要进行定义数据表的名字。

在数据库里面有一个 think_categories 表， 而我们定义的模型类名称是
CategoryModel ， 按照系统的约定， 这个模型的名称是Category， 对应的数据表名称应该是
think_category （ 全部小写） ， 但是现在的数据表名称是 think_categories ， 因此我们就需要设置
tableName 属性来改变默认的规则（ 假设我们已经在配置文件里面定义了 DB_PREFIX 为 think_） 。
namespace Home\Model;
use Think\Model;
class CategoryModel extends Model {
protected $tableName = 'categories';
}
注意这个属性的定义不需要加表的前缀 think_

 

如果我们需要CategoryModel模型对应操作的数据表是 top_category ， 那么我们只需要设置数据表前缀
即可：
namespace Home\Model;
use Think\Model;
class CategoryModel extends Model {
protected $tablePrefix = 'top_';
}
如果你的数据表直接就是 category ， 而没有前缀， 则可以设置 tablePrefix 为空字符串。
namespace Home\Model;
use Think\Model;
class CategoryModel extends Model {
protected $tablePrefix = '';
}
没有表前缀的情况必须设置， 否则会获取当前配置文件中的 DB_PREFIX 。
ThinkPHP3.2.3完全开发手册
本文档使用 看云 构建 - 93 -
而对于另外一种特殊情况， 我们需要操作的数据表是 top_categories ， 这个时候我们就需要定义
trueTableName 属性
namespace Home\Model;
use Think\Model;
class CategoryModel extends Model {
protected $trueTableName = 'top_categories';
}
注意 trueTableName 需要完整的表名定义。
除了数据表的定义外， 还可以对数据库进行定义（ 用于操作当前数据库以外的数据表） ， 例如
top.top_categories ：
namespace Home\Model;
use Think\Model;
class CategoryModel extends Model {
protected $trueTableName = 'top_categories';
protected $dbName = 'top';
}

 

D方法 数据模型实例化
$User = D('User');
$User->select();

D方法的参数就是模型的名称， 并且和模型类的大小写定义是一致的.
D方法可以自动检测模型类， 如果存在自定义的模型类， 则实例化自定义模型类， 如果不存在， 则会实例
化系统的\Think\Model基类， 同时对于已实例化过的模型， 不会重复实例化

D方法还可以支持跨模块调用， 需要使用：
//实例化Admin模块的User模型
D('Admin/User');
//实例化Extend扩展命名空间下的Info模型
D('Extend://Editor/Info');

 

 

D方法实例化模型类的时候通常是实例化某个具体的模型类， 如果你仅仅是对数据表进行基本的CURD操作
的话， 使用M方法实例化的话， 由于不需要加载具体的模型类， 所以性能会更高。
例如：
// 使用M方法实例化
$User = M('User');
// 和用法 $User = new \Think\Model('User'); 等效
// 执行其他的数据操作
$User->select();
M方法也可以支持跨库操作， 例如：
// 使用M方法实例化 操作db_name数据库的ot_user表
$User = M('db_name.User','ot_');
// 执行其他的数据操作
$User->select();
M方法的参数和\Think\Model类的参数是一样的， 也就是说， 我们也可以这样实例化：
$New = M('new','think_',$connection);
// 等效于 $New = new \Think\Model('new','think_',$connection);
具体的参数含义可以参考前面的介绍。
M方法实例化的时候， 默认情况下是直接实例化系统的\Think\Model类， 如果我们希望实例化其他的公共
模型类的话， 可以使用如下方法：
$User = M('\Home\Model\CommonModel:User','think_','db_config');
// 相当于 $User = new \Home\Model\CommonModel('User','think_','db_config');

实例化空模型类
如果你仅仅是使用原生SQL查询的话， 不需要使用额外的模型类， 实例化一个空模型类即可进行操作了，
例如：
//实例化空模型
$Model = new Model();
//或者使用M快捷方法是等效的
$Model = M();
//进行原生的SQL查询
$Model->query('SELECT * FROM think_user WHERE status = 1');
实例化空模型类后还可以用table方法切换到具体的数据表进行操作
我们在实例化的过程中， 经常使用D方法和M方法， 这两个方法的区别在于M方法实例化模型无需用户为
每个数据表定义模型类， 如果D方法没有找到定义的模型类， 则会自动调用M方法。

 

如果需要显式获取当前数据表的字段信息， 可以使用模型类的getDbFields方法来获取当前数据对象的全
部字段信息， 例如：
$User = M('User');
$fields = $User->getDbFields();
如果你在部署模式下面修改了数据表的字段信息， 可能需要清空 Data/_fields 目录下面的缓存文件， 让系
统重新获取更新的数据表字段信息， 否则会发生新增的字段无法写入数据库的问题

 

<if condition="$info['logo'] neq ''"> <span style="float:left;padding-righ:10px"><img src="{weiwin:$info.logo}"/></span>
</if>{weiwin:$info.info}</div>

 

 

js跳转到其他控制器还有方法 window.location.href='index.php?g=Wap&m=Card&a=index&token='+token+'&wecha_id='+wid;

 

 

 

URL大小写
但是系统本身提供了一个不区分URL大小写的解决方案，可以通过配置简单实现。
只要在项目配置中，增加：

'URL_CASE_INSENSITIVE' =>true

配置好后，即使是在Linux环境下面，也可以实现URL访问不再区分大小写了。

http://serverName/index.php/Home/Index/index
// 将等效于
http://serverName/index.php/home/index/index
这里需要注意一个地方，一旦开启了不区分URL大小写后，如果我们要访问类似UserTypeController的控制器，那么正确的URL访问应该是：

// 正确的访问地址
http://serverName/index.php/home/user_type/index
// 错误的访问地址（linux环境下）
http://serverName/index.php/home/usertype/index
利用系统提供的U方法可以为你自动生成相关的URL地址。

 

3.2.3版本开始，I函数支持对变量使用修饰符功能，可以更好的过滤变量。

用法如下： I('变量类型.变量名/修饰符');

例如：

I('get.id/d');
I('post.name/s');
I('post.ids/a');
可以使用的修饰符包括：

修饰符 作用
s 强制转换为字符串类型
d 强制转换为整形类型
b 强制转换为布尔类型
a 强制转换为数组类型
f 强制转换为浮点类型

 

 

请求类型

在很多情况下面，我们需要判断当前操作的请求类型是GET 、POST 、PUT或 DELETE，一方面可以针对请求类型作出不同的逻辑处理，另外一方面有些情况下面需要验证安全性，过滤不安全的请求。 系统内置了一些常量用于判断请求类型，包括：

常量 说明
IS_GET 判断是否是GET方式提交
IS_POST 判断是否是POST方式提交
IS_PUT 判断是否是PUT方式提交
IS_DELETE 判断是否是DELETE方式提交
IS_AJAX 判断是否是AJAX提交
REQUEST_METHOD 当前提交类型

class UserController extends Controller{
public function update(){
if (IS_POST){
$User = M('User');
$User->create();
$User->save();
$this->success('保存完成');
}else{
$this->error('非法请求');
}
}
}
需要注意的是，如果使用的是ThinkAjax或者自己写的Ajax类库的话，需要在表单里面添加一个隐藏域，告诉后台属于ajax方式提交，默认的隐藏域名称是ajax（可以通过VAR_AJAX_SUBMIT配置），如果是JQUERY类库的话，则无需添加任何隐藏域即可自动判断。

下面我们用空操作功能来实现一个城市切换的功能。 我们只需要给CityController类定义一个_empty（空操作）方法：

<?php
namespace Home\Controller;
use Think\Controller;
class CityController extends Controller{
public function _empty($name){
//把所有城市的操作解析到city方法
$this->city($name);
}

//注意 city方法 本身是 protected 方法
protected function city($name){
//和$name这个城市相关的处理
echo '当前城市' . $name;
}
}

 

 

 

 

 

 

success和error方法的第一个参数表示提示信息，第二个参数表示跳转地址，第三个参数是跳转时间（单位为秒），例如：

// 操作完成3秒后跳转到 /Article/index
$this->success('操作完成','/Article/index',3);
// 操作失败5秒后跳转到 /Article/error
$this->error('操作失败','/Article/error',5);
跳转地址是可选的，success方法的默认跳转地址是$_SERVER["HTTP_REFERER"]，error方法的默认跳转地址是javascript:history.back(-1);。

默认的等待时间success方法是1秒，error方法是3秒
success和error方法都可以对应的模板，默认的设置是两个方法对应的模板都是：

//默认错误跳转对应的模板文件
'TMPL_ACTION_ERROR' => THINK_PATH . 'Tpl/dispatch_jump.tpl',
//默认成功跳转对应的模板文件
'TMPL_ACTION_SUCCESS' => THINK_PATH . 'Tpl/dispatch_jump.tpl',
也可以使用项目内部的模板文件

//默认错误跳转对应的模板文件
'TMPL_ACTION_ERROR' => 'Public:error';
//默认成功跳转对应的模板文件
'TMPL_ACTION_SUCCESS' => 'Public:success';
模板文件可以使用模板标签，并且可以使用下面的模板变量：

变量 含义
$msgTitle 操作标题
$message 页面提示信息
$status 操作状态 1表示成功 0 表示失败 具体还可以由项目本身定义规则
$waitSecond 跳转等待时间 单位为秒
$jumpUrl 跳转页面地址
success和error方法会自动判断当前请求是否属于Ajax请求，如果属于Ajax请求则会调用ajaxReturn方法返回信息。 ajax方式下面，success和error方法会封装下面的数据返回：

$data['info'] = $message; // 提示信息内容
$data['status'] = $status; // 状态 如果是success是1 error 是0
$data['url'] = $jumpUrl; // 成功或者错误的跳转地址

 

重定向

Controller类的redirect方法可以实现页面的重定向功能。

redirect方法的参数用法和U函数的用法一致（参考URL生成部分），例如：

//重定向到New模块的Category操作
$this->redirect('New/category', array('cate_id' => 2), 5, '页面跳转中...');
上面的用法是停留5秒后跳转到New模块的category操作，并且显示页面跳转中字样，重定向后会改变当前的URL地址。

如果你仅仅是想重定向要一个指定的URL地址，而不是到某个模块的操作方法，可以直接使用redirect函数重定向，例如：

//重定向到指定的URL地址
redirect('/New/category/cate_id/2', 5, '页面跳转中...')
Redirect函数的第一个参数是一个URL地址。

控制器的redirect方法和redirect函数的区别在于前者是用URL规则定义跳转地址，后者是一个纯粹的URL地址。

转载于:https://www.cnblogs.com/clphp/p/5842554.html