ThinkPHP框架
1.拥有关系：用户表和身份证表关联，HAS_ONE（一对一），表示一个用户只有一个身份证。
User控制器部分：ThinkPHP\Weibo\Home\Controller\UserController.class.phpjavascript
ThinkPHP框架介绍
一．框架和库
框架：英文是(Framework)能够理解为骨架、架构、书架、书框。在程序里面理解，就各类条条框框像个有规则的书架同样，让你按照它的代码规范、编码模式(好比不少框架是基于MVC模式的)去开发应用程序。固然，框架内可能也包含了库的功能，也提供了各类封装功能的集合包。
库：英文是(Library)能够理解为仓库、图书馆、存书室。在程序里面理解，就是各类代码的封装集合包，提供原生内置并不存在的功能和方法。
二．ThinkPHP框架的优点
1.我的项目开发中，使用框架比采用原生代码开发优点较为明显：
(1)效率极高：由于框架已经帮你疏通了管道、构建了厂房、安好了水电、装全了设备、排好了书架，你要作的就是按照书架的布局或规格，整齐的把书放上，就完了。若是你不用框架建设，你还须要本身疏通管道、构建厂房、安水电、装设备、排书架，效率大大提升。
(2)安全性高：框架的开发难度较高，通常都是身经百战的架构高手们通过多年、多版本研发、更新迭代孕育而成。通过大量市场和用户的轮番测试和考验，保证了不一样状况和情况的稳定性。而若是你是低手或者新手，且本身架构，颇有可能会遇到厂房崩塌、漏水漏电等不安全的状况发生。
(3)稳定性高：基本同上，由于各类部件进行有有条不紊的架构，致使在不一样程度的运行中保证流畅。而自行架构的，在某些极端状况下可能会遇到管道堵塞的问题发生。
2.在公司团队项目开发中，使用主流框架比原生或自行开发框架优点较为明显：
(1)团队协做力强：开源框架提供了统一的规范和编码模式，且模块与模块之间相对独立。对于程序员来讲，只要根据这种规范来编码，团队之间的协调性会很是容易。并且主流的开源框架在招募人才方面较为容易，上来就能使用，下降的培训成本。
(2)下降培训成本：若是使用原生代码，当另外一个团队人员接受或参与，几乎看不到懂以前的技术员人代码，最终可能要重构，成本巨大。若是使用公司研发的框架，那么也须要必定时间的培训才能上手，成本也是巨大的。而使用主流框架，大部分技术人员在来公司以前就已经掌握。
(3)去技术人员化：一个公司把核心代码掌握在某个技术人员手里，这是极其危险的事。当这个项目的原生或者自行开发的框架是某一个技术人员设计的，当他离职后，代码将是一堆垃圾，没人能看懂。若是使用主流框架，那么公司的核心是项目和业务自己，下降技术人员的价值。任何一个技术人员离职，都不会影响项目的研发进度，只要懂主流框架的技术人员，上手便可继续。
三．框架和开源系统
所谓开源系统，就是开放源代码的系统。这些系统，包括好比discuz论坛系统、phpcms内容管理系统、shopex商城系统。这些系统，都是定制某种领域功能的、已经开发好的系统。原则上，这些系统已经不须要技术人员来编码了，能够直接上线运营了。由于这些是定制的系统，因此系统会专门根据此领域的状况进行特定的优化。那么也就是说，这些开源系统在安全性、稳定性和效率上要高于用框架开发的同类产品。因此，不少公司大量招聘开源系统的二次开发人才。
ThinkPHP的安装与配置
ThinkPHP是一款免费开源的框架，基于MVC设计模式和面向对象开发。
一．获取ThinkPHP
直接登陆ThinkPHP的官网下载频道：http://www.thinkphp.cn/down.html
1.解压ThinkPHP，打开它或导入到项目中去，展开六个文件及文件夹：
Application --应用程序目录(至关于一个网站，能够同时作好几个分支网站)，当程序开发时自动生成，默认为空；
Public --公共资源文件目录，存放一些公用的文件，默认为空；
ThinkPHP --框架目录，框架的核心架构程序包；
README.md --说明文件，可删；
.htaccess --配置文件，通常用于配置伪静态；
Index.php --入口文件，全部程序都经过这里访问。
2.对于ThinkPHP框架目录内，也含有大量的目录及文件：
Common --核心公共函数目录
Conf --核心配置目录
Lang --核心语言包目录
Library --框架类库目录
|--Think --核心Think类库包目录
|--Behavior --行为类库目录
|--Org --Org类库包目录
|--Vendor --第三方类库目录
|--... --更多类库目录
Mode --框架应用模式目录
Tpl --系统模版目录
LICENSE.txt --框架受权协议文件
logo.png --框架LOGO文件
README.txt --框架README文件
index.php --框架入口文件
二．入口文件
ThinkPHP采用单一入口模式对项目进行部署和访问的，因此咱们须要经过index.php进行一些部署工做，保证其正确访问。
1.将完整版压缩包解压的内容，拷贝到指定的服务器文件夹内
2.打开ThinkPHP提供的index.php文件，咱们发现以下代码：php
<?php //应用入口文件 //检测PHP环境是否大于5.3 if(version_compare(PHP_VERSION,'5.3.0','<')) die('require PHP > 5.3.0 !'); //开启调试模式 建议开发阶段开启 部署阶段注释或者设为false //define('APP_DEBUG',True); //定义应用目录 define('APP_PATH','./Application/'); //引入ThinkPHP入口文件 require './ThinkPHP/ThinkPHP.php';
3.若是想按照本身的意愿设置应用目录名称，能够修改为这样：css
<?php //应用入口文件 //检测PHP环境是否大于5.3 if(version_compare(PHP_VERSION,'5.3.0','<')) die('require PHP > 5.3.0 !'); //开启调试模式 建议开发阶段开启 部署阶段注释或者设为false //define('APP_DEBUG',True); //修改框架目录 define('APP_PATH','./Weibo/'); //修改框架目录 require './Think/ThinkPHP.php';
当第一次运行了这个配置后的应用程序，将会在根目录生成一个Weibo文件夹，应用程序的全部文件将所有存放在这里。
三．自动生成
当第一次访问应用入口文件的时候，会自动生成Weibo这个应用程序目录。里面包含了各类目录，说明以下：
Common --应用公共模块
|--Common --应用公共函数目录
|--Conf --应用公共配置文件目录
Home --默认生成的Home模块
|--Conf --模块配置文件目录
|--Common --模块函数公共目录
|--Controller --模块控制器目录
|--Model --模块模型目录
|--View --模块视图文件目录
Runtime --运行时目录
|--Cache --模版缓存目录
|--Data --数据目录
|--Logs --日志目录
|--Temp --缓存目录
一个站是一个入口，index.php只有一个入口，就是应用程序入口。若是有多个站，或者后台，那就须要另外一个入口。
1.建立另外一个站admin.php，应用目录改为对应的便可。html
<?php //应用入口文件 //检测PHP环境是否大于5.3 if(version_compare(PHP_VERSION,'5.3.0','<')) die('require PHP > 5.3.0 !'); //开启调试模式 建议开发阶段开启 部署阶段注释或者设为false define('APP_DEBUG',True); //定义应用目录 define('APP_PATH','./Admin/'); //引入ThinkPHP入口文件 require './ThinkPHP/ThinkPHP.php';
2.在自动生成的目录中，为了防止访问到应用程序的目录结构，会建立个index.html文件。固然，你也能够自行设置。
运行http://localhost/ThinkPHP/admin.php生成Admin/Home/Conf/default.htmlhtml5
<?php //应用入口文件 //检测PHP环境是否大于5.3 if(version_compare(PHP_VERSION,'5.3.0','<')) die('require PHP > 5.3.0 !'); //开启调试模式 建议开发阶段开启 部署阶段注释或者设为false define('APP_DEBUG',True); //定义应用目录 define('APP_PATH','./Admin/'); //设定目录生成的文件 define('DIR_SECURE_FILENAME', 'default.html'); //引入ThinkPHP入口文件 require './ThinkPHP/ThinkPHP.php';
运行http://localhost/ThinkPHP/admin.php生成Admin/Home/Conf/default.html并给文件里设置目录页面内容java
<?php //应用入口文件 //检测PHP环境是否大于5.3 if(version_compare(PHP_VERSION,'5.3.0','<')) die('require PHP > 5.3.0 !'); //开启调试模式 建议开发阶段开启 部署阶段注释或者设为false define('APP_DEBUG',True); //定义应用目录 define('APP_PATH','./Admin/'); //设定目录生成的文件 define('DIR_SECURE_FILENAME', 'default.html'); //设置目录页面内容 define('DIR_SECURE_CONTENT', '目录禁止'); //引入ThinkPHP入口文件 require './ThinkPHP/ThinkPHP.php';
通常来讲，第一次生成应用程序，应该加上静态主页防止目录结构暴露。但若是你的环境很是安全，能够关闭生成静态主页。
运行http://localhost/ThinkPHP/admin.php不会生成主页mysql
<?php //应用入口文件 //检测PHP环境是否大于5.3 if(version_compare(PHP_VERSION,'5.3.0','<')) die('require PHP > 5.3.0 !'); //开启调试模式 建议开发阶段开启 部署阶段注释或者设为false define('APP_DEBUG',True); //定义应用目录 define('APP_PATH','./Admin/'); //禁止目录主页生成 define('BUILD_DIR_SECURE', false); //引入ThinkPHP入口文件 require './ThinkPHP/ThinkPHP.php';
四．访问控制器
1.控制器路径在：Weibo/Home/Controller下，有一个默认的控制器IndexController.class.php文件。
2.控制器类的命名方式：控制器名（驼峰式，首字母大写）+Controller
3.控制器文件的命名方式：类名+class.php
建立一个控制器须要三个部分：1.设置命名空间；2.导入命名空间；3.控制器类程序员
//设置命名空间 namespace Home\Controller; //根据Home主模块加上当前IndexController.class.php文件的目录 //导入命名空间 use Think\Controller; //class IndexController继承了Controller父类，父类的命名空间就是Think //控制器类 class IndexController extends Controller { public function index() { //... } }
4.访问方式：
首页直接访问：http://localhost/ThinkPHP/
若是想用完整形式则是：http://localhost/ThinkPHP/admin.php/Home/Index/index
注意：在这里的完整URL中，index.php是单一入口文件，Home是主模块，Index是控制器名表明IndexController,index是控制器里的一个方法
5.若是建立一个test()方法，那么URL就是：
http://localhost/ThinkPHP/index.php/Home/Index/index/test
6.建立一个User模块，那么能够建立一个User控制器。ajax
<?php //本身建立控制器 namespace Home\Controller; //声明本身命名空间 use Think\Controller; //会自动生成 class UserController extends Controller { //生成UserController继承父类Controller public function index() { echo 'user'; } public function test() { //index会默认被执行test就须要调用 echo 'user test'; } }
URL访问路径为：http://localhost/ThinkPHP/Home/User/
URL访问User模块下的test()方法的路径为：http://localhost/ThinkPHP/Home/User/test(index会默认被执行test就须要调用)
ThinkPHP--模块化和URL模式
一．模块化设计
建立Weibo框架
采用ThinkPHP模块化架构思想，把Weibo内的Home目录看成前台、Weibo/Admin目录看成后台。
操做方法：把Home目录复制一份到同级目录，更名为Admin。把Admin中的Controller内的IndexController.class.php的命名空间改成以下：正则表达式
//修改Admin模块的命名空间 <?php //本类由系统自动生成，仅供测试用途 namespace Admin\Controller; use Think\Controller; class IndexController extends Controller { public function index(){ //$this->show('<style type="text/css">*{ padding: 0; margin: 0; } div{ padding: 4px 48px;} body{ background: #fff; font-family: "微软雅黑"; color: #333;} h1{ font-size: 100px; font-weight: normal; margin-bottom: 12px; } p{ line-height: 1.8em; font-size: 36px }</style><div style="padding: 24px 48px;"> <h1>:)</h1><p>欢迎使用 <b>ThinkPHP</b>！</p></div><script type="text/javascript" src="http://tajs.qq.com/stats?sId=9347272" charset="UTF-8"></script>','utf-8'); echo 'Admin'; } }
最终访问的地址就是：http://localhost/ThinkPHP/index.php/Admin
1.被用户禁止访问的，好比Common和Runtime模块。固然，框架已经在默认就禁止访问了。当强行访问Common模块的时候，会提示：“没法加载模块:Common”的错误信息。
Weibo/Common/Conf/config.php
<?php return array( //'配置项'=>'配置值' //禁止访问模块(系统内置的) 'MODULE_DENY_LIST' => array('Common','Runtime'), );
注意：当你去掉数组里的'Common'，那么会提示：“没法加载控制器:Index”的错误信息。说明这个模块已经能够访问了。
2.容许访问模块的设置。当设置了此选项，就务必把全部容许访问的模块都添加上，不然会变成拒绝访问。
Weibo/Common/Conf/config.php
<?php return array( //容许访问的模块，设置了，就必须写全，漏写的将没法访问 'MODULE_ALLOW_LIST' => array('Home','Admin'), );
3.若是有多个访问模块，那么在默认URL访问的时候，应该有一个首选访问。默认是Home，想设置Admin为默认，能够这么设置：
Weibo/Common/Conf/config.php
<?php return array( //'配置项'=>'配置值' //设置默认加载模块 'DEFAULT_MODULE' => 'Admin', );
访问目录默认加载Admin模块：http://localhost/ThinkPHP/
4.应用项目若是只容许单个模块的话，能够设置拒绝多个模块，这样建立更多的模块将失效。
Weibo/Common/Conf/config.php
<?php return array( //'配置项'=>'配置值' //只容许访问一个模块设置 'MULTI_MODULE' => false, );
5.有时，你会以为index.php/Admin这样很麻烦。你可能想直接admin.php就表明后台就方便不少，那么可使用多入口设置。
这里的多入口和上一节多个应用项目不一样，而是经过admin.php访问Weibo目录下的Admin模块。将index.php复制出来改为admin.php，而后添加以下代码：
Weibo/admin.php
// 应用入口文件 // 检测PHP环境是否大于5.3 if(version_compare(PHP_VERSION,'5.3.0','<')) die('require PHP > 5.3.0 !'); // 开启调试模式 建议开发阶段开启 部署阶段注释或者设为false define('APP_DEBUG',True); //Admin加载admin模块 $_GET['m'] = 'Admin'; //默认指向Index控制器 $_GET['c'] = 'Index'; // 定义应用目录 define('APP_PATH','./Weibo/'); // 引入ThinkPHP入口文件 require './ThinkPHP/ThinkPHP.php';
二．URL模式
ThinkPHP的URL模式有四种，默认是PATHINFO模式，其余三种分别为：普通模式、REWRITE和兼容模式。
1.PATHINFO模式
Weibo/Home/Controller/UserController.class.php
<?php // 本类由系统自动生成，仅供测试用途 namespace Home\Controller; use Think\Controller; class UserController extends Controller { //用户密码传参 public function test($user, $pass) { echo 'user:'.$user.'<br />pass:'.$pass; } }
传递用户和密码：http://localhost/ThinkPHP/Home/User/test/user/xixi/pass/123
user:xixi
pass:123
在这条URL上，Home表示模块，User表示控制器，test表示方法，user/xixi表示第一个键值对，pass/123表示第二个键值对。
PATHINFO模式下默认的分隔符是/，咱们能够设置为你想要的，好比：_
Weibo/Common/Conf/config.php
<?php return array( //'配置项'=>'配置值' //设置键值对分隔符 'URL_PATHINFO_DEPR'=>'_', );
设置了分隔符的URL：http://localhost/ThinkPHP/Home_User_test_user_xixi_pass_123
user:xixi
pass:123
2.普通模式
普通模式下的URL：http://localhost/ThinkPHP/index.php?m=Home&c=User&a=test&user=xixi&pass=123
在这条URL上，咱们发现采用的就是传统的GET模式，m表示模块，c表示控制器，a表示方法，后面的表示键值对。
普通模式的m、c、a能够自行设置为你习惯的键名称：
<?php return array( //'配置项'=>'配置值' //修改键名称 'VAR_MODULE' => 'mm', 'VAR_CONTROLLER' => 'cc', 'VAR_ACTION' => 'aa', );
修改键名称后URL：http://localhost/ThinkPHP/index.php?mm=Home&cc=User&aa=test&user=xixi&pass=123
user:xixi
pass:123
ThinkPHP--模型(model)操做部分---数据库操做
ThinkPHP模型操做部分模型是MVC中的M，表示应用程序核心(能够理解为操做数据库部分操做)
一．建立数据库
使用模型操做以前，首先建立一个数据库：thinkphp。建立一个用户表：think_user。添加一些数据便可。
ThinkPHP内置了抽象数据库访问层，把不一样的数据库操做封装起来。咱们只须要使用公共的Db类进行操做，无须针对不一样的数据库写不一样的代码和底层实现。Db类会自动调用相应的数据库驱动来处理。
目前支持的数据库包括Mysql(包含mysql和mysqli)、SqlServer、PgSQL、Sqlite、Oracle、Ibase、Mongo、PDO等。
1.全局配置定义(mysql)
Weibo/Common/Conf/config.php配置
<?php return array( //'配置项'=>'配置值' //全局配置定义 'DB_TYPE'=>'mysql', //数据库类型 'DB_HOST'=>'127.0.0.1', //服务器地址 'DB_NAME'=>'thinkphp', //数据库名 'DB_USER'=>'xixi', //用户名 'DB_PWD'=>'123456', //密码 'DB_PORT'=>3306, //端口 'DB_PREFIX'=>'think_', //数据库表前缀 );
2.数据库全局配置信息除了PDO，都可以采用上面的设置。
Weibo/Common/Conf/config.php
<?php return array( //'配置项'=>'配置值' //PDO专用定义 'DB_TYPE'=>'pdo', //数据库类型 'DB_USER'=>'xixi', //用户名 'DB_PWD'=>'123456', //密码 'DB_PREFIX'=>'think_', //数据库表前缀 'DB_DSN'=>'mysql:host=127.0.0.1;dbname=thinkphp;charset=UTF8', //服务器地址，数据库名字链接 );
二．实例化模型
链接上数据库后须要从数据库里操做数据，那么就须要实例化模型类。
调试辅助工具
Weibo/Common/Conf/config.php
<?php return array( //'配置项'=>'配置值' //页面Trace，调试辅助工具 'SHOW_PAGE_TRACE' =>true, );
1.Model基类处理方式(实例化Model类，传一个数据表名)
Weibo/Home/Controller/UserController.class.php配置
namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //建立变量user，这个user将获得Model基类的句柄 $user = new Model('User'); //建立Model基类传递第一个参数(User表) //显示变量结构(检测是否链接数据库成功) //var_dump($user); //打印出全部数据结构 //var_dump($user->select()); } }
2.Model基类处理方式传递三个参数：Model(['模型名'],['数据表前缀'],['数据库链接信息']);
Weibo/Home/Controller/UserController.class.php配置
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //Model(['模型名User'],['数据表前缀think'],['数据库链接信息mysql:...']) $user = new Model('User','think_','mysql://xixi:123456@127.0.0.1/thinkphp'); //打印出全部数据结构 var_dump($user->select()); } }
3.使用Model基类还须要导入命名空间，而使用M()方法，则不须要。
Weibo/Home/Controller/UserController.class.php配置
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function model () { //用M调用的是Model $user = M('User'); //打印出全部数据结构 var_dump($user->select()); } }
4.对应数据表的模型定义UserModel。这种模型类并不是必须定义的，只有当存在独立的业务逻辑或者属性的时候才须要。
Weibo/Home/Mode/UserModel.class.php
<?php //User模型类 namespace Home\Model; use Think\Model; //继承Moder的基类 class UserModel extends Model { //UserModel的User要跟数据表名一一对应(若是写成UserModel对应的数据表就是think_user) }
建立了UserModel模型类后，控制器那头就能够直接声明
<?php namespace Home\Controller; use Think\Controller; use Home\Model\UserModel; class UserController extends Controller { public function model () { //显示变量UserModel结构 $user = new UserModel(); //打印出全部数据结构 var_dump($user->select()); } }
为何UserModel模型类没有指定任何表便可直接访问呢？由于这种模型类基本是直接操做数据表的，因此在命名规范上和数据表名是对应的。
虽然使用模型类和数据表对应较为方便，但当有时咱们须要更换表名、前缀、附加数据库名等，就须要一些字段定义的操做。为了更加方便的了解数据表的变化，咱们使用一下页面Trace工具，能够时时的查询SQL的变化。
数据表定义:
(1)字段属性tablePrefix:定义模型对应数据表的前缀
(2)字段属性tableName:不包含表前缀的数据表名称
(3)字段属性trueTableName:包含表前缀的数据表名称
(4)字段属性dbName:定义模型当前对应的数据库名称
Weibo/Home/Mode/UserModel.class.php
<?php //User模型类 namespace Home\Model; use Think\Model; //从新定义完整的带前缀的表名 class UserModel extends Model { //定义模型对应数据表的前缀 //protected $tablePrefix = 'tp_'; //think_user变成tp_user //不包含前缀的数据表名称 //protected $tableName = 'abc'; //think_user变成think_abc //同时改前缀加表名 //protected $trueTableName = 'tp_abc'; //think_user变成tp_abc //附加数据库名 //protected $dbName = 'tp'; //thinkphp表改为tp表 }
若是你仅仅使用CURD等数据库基本操做(增删改查)，建议使用基于Model基类的M()方法。使用M()方法因为不须要加载具体的模型类（好比UserModel类），因此性能会更高。
5.D()方法来直接是实例化模型类，而且还能够免去引入命名空间等操做。
Weibo/Home/Mode/UserController.class.php
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function model () { //用D调用的是User-Model $user = D('User'); //打印出全部数据结构 var_dump($user->select()); } }
怎么知道D()方法是调用的UserModel
Weibo/Home/Mode/UserModel.class.php
<?php //User模型类 namespace Home\Model; use Think\Model; class UserModel extends Model { public function __construct(){ //构造函数打印出 parent::__construct(); //由于UserModel没有数据库链接数据库获取功能(去链接构造函数) echo '\Home'; //打印出\Home } }
6.使用D()方法比直接使用模型类更加的智能，若是在\Home\Model\UserModel找不到该模型类，那么就会去公共模块下找\Common\Model\UserModel去找。若是还找不到，就会直接实例化基类Model()类，也就是等同于使用M()方法。
把Weibo/Home/Mode/UserModel.class.php的UserModel.class.php移动到\Common\Model\UserModel下
<?php //User模型类 namespace Common\Model; use Think\Model; class UserModel extends Model { public function __construct($name = '', $tablePrefix = '', $connection = ''){ parent::__construct(); echo '\Common'; } }
7.D()方法能够直接调用当前模块的模型类，那么若是跨模块调用的话，那怎么处理呢？好比Admin后台模块，可使用目录声明。
Weibo/Admin/Model\UserModel.class.php
<?php namespace Admin\Model; use Think\Model; class UserModel extends model { public function __construct() { parent::__construct(); echo '\Admin'; } }
调用Weibo/Admin/Model\UserModel.class.php
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function model () { //跨模块实例化 $user = D('Admin/User'); //打印出全部数据结构 var_dump($user->select()); } }
8.有时，你可能想使用原生的SQL语句进行操做数据库。那么能够采用实例化空模型基类或者空M()方法。
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function model () { //用D调用的是User-Model $user = D('Admin/User'); //空M()方法 $user = M(); //或者new Model();空基类 var_dump($user->query("SELECT * FROM think_user WHERE user='蜡笔小新'")); } }
三．字段定义
每一个模型类操做着每一个对应的数据表，在大多数状况下，系统会自动获取当前数据表的字段信息。而当模型类第一次实例化时，系统会自动缓存字段，而且永久缓存，除非删除了运行时缓存或者设置不缓存。
若是调试模式下，则不会生成字段缓存文件，每次都是从数据表里从新获取。生成缓存的目的显而易见，就是为了快速响应。ThinkPHP默认是开启字段缓存，由于在实际运行中，不会更改字段结构。
字段缓存文件保存在Runtime/Data/_fields/目录里，当你在开发阶段，字段和表会常常变更，因此要关闭缓存。关闭缓存的方法为：
// 关闭字段缓存 'DB_FIELDS_CACHE'=>false //开启了调试模式，自动关闭
PS：若是开启缓存状态，新增了字段，那么可能新字段没法刷新出来，必须删除/Data/_fields文件夹，从新获取字段。
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function model () { $user = M('User'); //查看字段结构 var_dump($user->getDbFields()); } }
可使用手动定义数据表字段的方式取代字段缓存方式，这种方式能够提升性能，避免IO开销。
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function model () { $user = D('User'); //查看字段结构 var_dump($user->getDbFields()); } }
ThinkPHP--模型操做部分-数据库操做-SQL查询语句
一．查询方式
ThinkPHP提供了三种基本的查询方式：字符串条件查询、索引数组条件查询和对象条件查询。在大多数状况下，推荐使用索引数组和对象方式做为查询条件，由于会更加安全
1.使用字符串做为条件查询
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //字符串做为条件查询 $user = M('User'); var_dump($user->where('id=1')->select()); //连贯操做：user指向where,where自己又返回的user对象因此还能指向select } }
最终生成的SQL语句：SELECT * FROM `think_user` WHERE ( id=1 )
2.使用索引数组做为查询条件
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //索引数组做为条件查询 $user = M('User'); $condition['id'] = 1; //建立数组变量 $condition['user'] = '蜡笔小新'; //建立数组变量 var_dump($user->where($condition)->select()); //只须要传变量就能够了不须要写字符串形式 } }
最终生成的SQL语句：SELECT * FROM `think_user` WHERE ( `id` = 1 ) AND ( `user` = '蜡笔小新' )
索引数组查询的默认逻辑关系是AND，若是想改变为OR，可使用_logic定义查询逻辑。
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //索引数组做为条件查询 $user = M('User'); $condition['id'] = 1; //建立数组变量 $condition['user'] = '蜡笔小新'; //建立数组变量 $condition['_logic'] = 'OR'; //将默认AND改为OR var_dump($user->where($condition)->select()); //只须要传变量就能够了不须要写字符串形式 } }
最终生成的SQL语句：SELECT * FROM `think_user` WHERE ( `id` = 1 ) OR ( `user` = '蜡笔小新' )
3.使用对象方式来查询
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //对象做为条件查询 $user = M('User'); $condition = new \stdClass(); //声明对象=stdClass类 $condition->id = 1; //添加成员 $condition->user = '蜡笔小新'; //添加成员 var_dump($user->where($condition)->select()); } }
最终生成的SQL语句：SELECT * FROM `think_user` WHERE ( `id` = 1 ) AND ( `user` = '蜡笔小新' )
stdClass类是PHP内置的类，能够理解为一个空类，在这里能够理解为把条件的字段做为成员保存到stdClass类里。而这里的'\'是将命名空间设置为根目录，不然会致使当前目录找不到此类。使用对象和数组查询，效果是同样的，能够互换。在大多数状况下，ThinkPHP推荐使用数组形式更加高效。
二．表达式查询
对于那些要实现模糊判断的查询，好比大于、等于、小于之类的SQL查询，可使用表达式查询方式。
查询表达式格式：$map['字段名'] = array('表达式','查询条件');
表达式查询表
(1)EQ表达式等于(=)
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //EQ：等于(=) $user = M('User'); $map['id'] = array('eq', 1); //where为id=1 var_dump($user->where($map)->select()); } }
最终生成的SQL语句：SELECT * FROM `think_user` WHERE ( `id` = 1 )
(2)NEQ表达式不等于(<>)
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //NEQ：不等于(<>) $user = M('User'); $map['id'] = array('neq', 1); //where为id<>1 var_dump($user->where($map)->select()); } }
最终生成的SQL语句：SELECT * FROM `think_user` WHERE ( `id` <> 1 )
(3)GT表达式大于(>)
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //GT：大于(>) $user = M('User'); $map['id'] = array('gt', 1); //where为id>1 var_dump($user->where($map)->select()); } }
最终生成的SQL语句：SELECT * FROM `think_user` WHERE ( `id` > 1 )
(4)EGT表达式大于等于(>=)
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //EGT：大于等于(>=) $user = M('User'); $map['id'] = array('egt', 1); //where为id>=1 var_dump($user->where($map)->select()); } }
最终生成的SQL语句：SELECT * FROM `think_user` WHERE ( `id` >= 1 )
(5)LT表达式小于(<)
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //LT：小于(<) $user = M('User'); $map['id'] = array('lt', 2); //where为id<2 var_dump($user->where($map)->select()); } }
最终生成的SQL语句：SELECT * FROM `think_user` WHERE ( `id` < 2 )
(6)ELT表达式小于等于(<=)
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //ELT：小于等于(<=) $user = M('User'); $map['id'] = array('elt', 1); //where为id<=1 var_dump($user->where($map)->select()); } }
最终生成的SQL语句：SELECT * FROM `think_user` WHERE ( `id` <= 1 )
(7)[NOT]LIKE表达式模糊查询
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //[NOT]LIKE：模糊查询 $user = M('User'); $map['user'] = array('like', '%小%'); //where为like %小% var_dump($user->where($map)->select()); } }
最终生成的SQL语句(包含小字的)：SELECT * FROM `think_user` WHERE ( `user` LIKE '%小%' )
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //[NOT]LIKE：模糊查询 $user = M('User'); $map['user'] = array('notlike', '%小%'); //where为not like %小% var_dump($user->where($map)->select()); } }
最终生成的SQL语句(不包含小字的)：SELECT * FROM `think_user` WHERE ( `user` NOT LIKE '%小%' )
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //[NOT]LIKE：模糊查询的数组方式 $user = M('User'); $map['user'] = array('like', array('%小%', '%蜡%'), 'AND'); var_dump($user->where($map)->select()); } }
最终生成的SQL语句(包含小还包含蜡字)：SELECT * FROM `think_user` WHERE ( (`user` LIKE '%小%' AND `user` LIKE '%蜡%') )
(8)[NOT] BETWEEN表达式(不在)区间查询
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //[NOT] BETWEEN：区间查询 $user = M('User'); $map['id'] = array('between','1,3'); var_dump($user->where($map)->select()); } }
最终生成的SQL语句(范围在id1-3)：SELECT * FROM `think_user` WHERE ( (`id` BETWEEN '1' AND '3' ) )
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //[NOT] BETWEEN：区间查询 $user = M('User'); $map['id'] = array('not between','1,3'); var_dump($user->where($map)->select()); } }
最终生成的SQL语句(范围不在id1-3)：SELECT * FROM `think_user` WHERE ( (`id` NOT BETWEEN '1' AND '3' ) )
(9)[NOT] IN表达式(不在)IN查询
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //[NOT] IN：区间查询 $user = M('User'); $map['id'] = array('in','1,2,4'); var_dump($user->where($map)->select()); } }
最终生成的SQL语句(范围在id是1，2，4)：SELECT * FROM `think_user` WHERE ( `id` IN ('1','2','4') )
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //[NOT] IN：区间查询 $user = M('User'); $map['id'] = array('not in','1,2,4'); var_dump($user->where($map)->select()); } }
最终生成的SQL语句(范围不在id是1，2，4)：SELECT * FROM `think_user` WHERE ( `id` NOT IN ('1','2','4') )
(10)EXP表达式查询支持SQL语法
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //EXP：自定义 $user = M('User'); $map['id'] = array('exp','in (1,2,4)'); var_dump($user->where($map)->select()); } }
最终生成的SQL语句(范围在id是1，2，4)SELECT * FROM `think_user` WHERE ( (`id` in (1,2,4)) )
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //EXP：自定义增长OR语句 $user = M('User'); $map['id'] = array('exp', '=1'); $map['user'] = array('exp', '="蜡笔小新"'); $map['_logic'] = 'OR'; var_dump($user->where($map)->select()); } }
最终生成的SQL语句：SELECT * FROM `think_user` WHERE ( (`id` =1) ) OR ( (`user` ="蜡笔小新") )
三．快捷查询
快捷查询方式是一种多字段查询的简化写法，在多个字段之间用'|'隔开表示OR，用'&'隔开表示AND。
1.不一样字段相同查询条件
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //使用相同查询条件 $user = M('User'); $map['user|email'] = '蜡笔小新'; //'|'换成'&'变成AND var_dump($user->where($map)->select()); } }
最终生成的SQL语句(user=蜡笔小新或者email=蜡笔小新):SELECT * FROM `think_user` WHERE ( (`user` = '蜡笔小新') OR (`email` = '蜡笔小新') )
2.不一样字段不一样查询条件
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //使用不一样查询条件 $user = M('User'); $map['id&user'] = array(1,'蜡笔小新','_multi'=>true); var_dump($user->where($map)->select()); } }
最终生成的SQL语句(查询ID=1,user=蜡笔当心的)：SELECT * FROM `think_user` WHERE ( (`id` = 1) AND (`user` = '蜡笔小新') )
注意：设置'_multi'为true，是为了让id对应1，让user对应'蜡笔小新'，不然就会出现id对应了1还要对应'蜡笔小新'的状况。并且，这设置要在放在数组最后。
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //支持使用表达式结合快捷查询 $user = M('User'); $map['id&user'] = array(array('gt', 0),'蜡笔小新','_multi'=>true); var_dump($user->where($map)->select()); } }
最终生成的SQL语句(查询ID>0的,user=蜡笔小新):SELECT * FROM `think_user` WHERE ( (`id` > 0) AND (`user` = '蜡笔小新') )
四．区间查询
ThinkPHP支持对某个字段的区间查询。
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //区间查询 $user = M('User'); $map['id'] = array(array('gt', 1), array('lt', 4)); var_dump($user->where($map)->select()); } }
最终生成的SQL语句(查询ID>1的而且ID<4的)：SELECT * FROM `think_user` WHERE ( (`id` > 1) AND (`id` < 4) )
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //第三个参数设置逻辑OR $user = M('User'); $map['id'] = array(array('gt', 1), array('lt', 4), 'OR'); var_dump($user->where($map)->select()); } }
最终生成的SQL语句(查询ID>1或者ID<4的):SELECT * FROM `think_user` WHERE ( (`id` > 1) OR (`id` < 4) )
五．组合查询
组合查询是基于索引数组查询方式的一个扩展性查询，添加了字符串查询(_string)、复合查询(_complex)、请求字符串查询(_query)，因为采用的是索引数组，重复的会被覆盖。
方式一：安全性低
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //字符串查询(_string) $user = M('User'); $map['id'] = array('eq', 1); $map['_string'] ='user="蜡笔小新" AND email="xiaoxin@163.com"'; var_dump($user->where($map)->select()); } }
最终生成的SQL语句(查询ID=1而且user=蜡笔小新而且email=xiaoxin@163.com)：SELECT * FROM `think_user` WHERE ( `id` = 1 ) AND ( user="蜡笔小新" AND email="xiaoxin@163.com" )
方式二：所有以链接符(安全推荐)
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //请求字符串查询(_query) $user = M('User'); $map['id'] = array('eq', 1); $map['_query'] ='user=蜡笔小新&email=xiaoxin@163.com&_logic=OR'; var_dump($user->where($map)->select()); } }
最终生成的SQL语句(查询ID=1而且user=蜡笔小新而且email=xiaoxin@163.com)：SELECT * FROM `think_user` WHERE ( `id` = 1 ) AND ( `user` = '蜡笔小新' OR `email` = 'xiaoxin@163.com' )
方式三：
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //复合查询(_complex) $user = M('User'); $where['user'] = array('like', '%小%'); $where['id'] = 1; $where['_logic'] = 'OR'; $map['_complex'] = $where; $map['id'] = 3; $map['_logic'] = 'OR'; var_dump($user->where($map)->select()); } }
最终生成的SQL语句(查询ID=1或者user=小或者ID=3):SELECT * FROM `think_user` WHERE ( ( `user` LIKE '%小%' ) OR ( `id` = 1 ) ) OR ( `id` = 3 )
六．统计查询
ThinkPHP提供了一些数据统计查询的方法。
统计查询出几个字段
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //数据总条数 $user = M('User'); var_dump($user->count()); } }
统计查询出几个字段：string '2' (length=1)语句：SELECT COUNT(*) AS tp_count FROM `think_user` LIMIT 1
统计查询出几个字段(遇到空不统计)
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //字段总条数，遇到NULL不统计 $user = M('User'); var_dump($user->count('email')); } }
统计查询出几个字段(遇到空不统计)：string '2' (length=1)语句：SELECT COUNT(email) AS tp_count FROM `think_user` LIMIT 1
最大值：
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //最大值 $user = M('User'); var_dump($user->max('id')); } }
统计查询最大值：string '2' (length=1)语句：SELECT MAX(id) AS tp_max FROM `think_user` LIMIT 1
最小值：
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //最小值 $user = M('User'); var_dump($user->min('id')); } }
查询最小值：string '1' (length=1)语句：SELECT MIN(id) AS tp_min FROM `think_user` LIMIT 1
平均值：
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //平均值 $user = M('User'); var_dump($user->avg('id')); } }
查询平均值：string '1.5000' (length=6)语句：SELECT AVG(id) AS tp_avg FROM `think_user` LIMIT 1
总和：
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //求总和 $user = M('User'); var_dump($user->sum('id')); } }
查询总和值：string '3' (length=1)语句：SELECT SUM(id) AS tp_sum FROM `think_user` LIMIT 1
七．动态查询
借助PHP5语言的特性，ThinkPHP实现了动态查询。
1.getBy动态查询
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //查找email=xiaoin@163.com的数据 $user = M('User'); var_dump($user->getByemail('xiaoxin@163.com')); } }
查找email=xiaoin@163.com的数据sql语句：SELECT * FROM `think_user` WHERE ( `email` = 'xiaoxin@163.com' ) LIMIT 1
2.getFieldBy动态查询
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //经过user获得相对应id值 $user = M('User'); var_dump($user->getFieldByUser('蜡笔小新', 'id')); } }
经过user获得蜡笔小新相对应id值string '1' (length=1)语句:SELECT `id` FROM `think_user` WHERE ( `user` = '蜡笔小新' ) LIMIT 1
八．SQL查询
ThinkPHP支持原生SQL查询。
1.query读取
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //查询结果集，若是采用分布式读写分离，则始终在读服务器执行 $user = M('User'); var_dump($user->query('SELECT * FROM think_user')); } }
查询think_user表sql语句：SELECT * FROM think_user
2.execute写入
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //更新和写入，若是采用分布式读写分离，则始终在写服务器执行 $user = M('User'); var_dump($user->execute('UPDATE think_user set user="蜡笔大新" WHERE id=1')); } }
修改ID=1的user=蜡笔大新sql语句：int 1语句:UPDATE think_user set user="蜡笔大新" WHERE id=1
ThinkPHP--模型操做部分---数据库操做--SQL连贯操做
ThinkPHP模型基础类提供的连贯操做，经过连贯操做能够有效的提供数据存取的代码清晰度和开发效率，而且支持全部的CURD操做。
一．连贯入门
连贯操做使用起来很是简单，好比查找到id为1,2,3,4中按照建立时间的倒序的前两位。
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //连贯操做入门 $user = M('User'); var_dump($user->where('id in (1,2,3)')->order('date DESC')->limit(2)->select()); } }
查询id=1,2,3里的前俩个数据sql语句：SELECT * FROM `think_user` WHERE ( id in (1,2,3) ) ORDER BY date DESC LIMIT 2
注意：这里的where、order和limit方法都是连贯操做方法，因此它们都能返回$user自己，能够互换位置。而select方法不是连贯方法，须要放在最后，用以显示数据集。
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //数组操做 $user = M('User'); var_dump($user->select(array('where'=>array('id'=>array('neq',1)),'order'=>'date DESC'))); } }
查询id不等于1的按照时间排序sql语句:SELECT * FROM `think_user` WHERE ( `id` <> 1 )
删除
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //CURD处理 $user = M('User'); var_dump($user->where('id=3')->delete()); } }
把ID=3的删除
DELETE FROM `think_user` WHERE ( id=3 )
二．连贯方法
1.where
where方法支持字符串条件、数组条件（推荐用法）和屡次调用。
字符串方式(不推荐)
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //字符串方式 $user = M('User'); var_dump($user->where('id=1')->select()); } }
查询ID=1的sql语句：SELECT * FROM `think_user` WHERE ( id=1 )
索引数组方式
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //索引数组方式 $user = M('User'); $map['id'] = 1; //使用表达式array('eq', 1); var_dump($user->where($map)->select()); } }
查询ID=1的sql语句:SELECT * FROM `think_user` WHERE ( `id` = 1 )
屡次调用方式
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //屡次调用方式 $user = M('User'); $map['id'] = array('eq', 1); var_dump($user->where($map)->where('user="蜡笔小新"')->select()); } }
查询ID=1而且user=蜡笔小新的sql语句：SELECT * FROM `think_user` WHERE ( `id` = 1 ) AND ( user="蜡笔小新" )
2.order
order用于对结果集排序。
倒序
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //倒序 $user = M('User'); $map['id'] = array('eq', 1); var_dump($user->order('id desc')->select()); //正序默认或ASC } }
查询ID倒序的sql:SELECT * FROM `think_user` ORDER BY id desc
数组形式防止字段和mysql关键字冲突
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //数组形式防止字段和mysql关键字冲突 $user = M('User'); $map['id'] = array('eq', 1); var_dump($user->order(array('id'=>'DESC'))->select()); } }
查询ID倒序的sql：SELECT * FROM `think_user` ORDER BY `id` DESC
3.feild
feild方法能够返回或操做字段，能够用于查询和写入操做。
只显示id和user两个字段
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //只显示id和user两个字段 $user = M('User'); var_dump($user->field('id, user')->select()); } }
只显示id和user两个字段的sql:SELECT `id`,`user` FROM `think_user`
使用SQL函数和别名
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //使用SQL函数和别名 $user = M('User'); var_dump($user->field('SUM(id) as count, user')->select()); } }
统计ID的总和和别名:SELECT SUM(id) as count,`user` FROM `think_user`
使用数组参数结合SQL函数
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //使用数组参数结合SQL函数 $user = M('User'); var_dump($user->field(array('id','LEFT(user,3)'=>'left_user'))->select()); } }
取id和user的前三位把别名改变为left_user直接指向left_user：SELECT `id`,LEFT(user,3) AS `left_user` FROM `think_user`
获取全部数据
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //获取全部字段 $user = M('User'); var_dump($user->field()->select()); //能够传入*号，或者省略方法 } }
获取全部数据sql:SELECT * FROM `think_user`
3.limit
limit方法主要用于指定查询和操做的数量。
限制结果集数量
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //限制结果集数量 $user = M('User'); var_dump($user->limit(2)->select()); } }
只显示俩条sql：SELECT * FROM `think_user` LIMIT 2
分页查询
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //分页查询 $user = M('User'); var_dump($user->limit(0,2)->select()); //0表明从第1条开始，2表明显示俩条 } }
从第1条开始每页显示俩条sql：SELECT * FROM `think_user` LIMIT 0,2
4.page
page方法彻底用于分页查询。
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //page分页 $user = M('User'); var_dump($user->page(1,2)->select()); //1表明第一页，2表明每页显示俩条 } }
从第1条开始每页显示俩条sql:SELECT * FROM `think_user` LIMIT 0,2
5.table
table方法用于数据表操做，主要是切换数据表或多表操做。
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //切换数据表 $user = M('User'); var_dump($user->table('think_info')->select()); } }
切换到think_info这张表：SELECT * FROM `think_info`
获取简化表名
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { ///获取简化表名 $user = M('User'); var_dump($user->table('__USER__')->select()); //__INFO__尚可 } }
切换到think_info这张表:SELECT * FROM `think_user`
多表查询
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //多表查询 $user = M('User'); var_dump($user->field('a.id,b.id')->table('__USER__ a,__INFO__ b')->select()); } }
查询双表think_user a,think_info b语句：SELECT a.id,b.id FROM think_user a,think_info b
数组形式夺标查询
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //多表查询，使用数组形式避免关键字冲突 $user = M('User'); var_dump($user->field('a.id,b.id')->table(array('think_user'=>'a', 'think_info'=>'b'))->select()); } }
语句：SELECT a.id,b.id FROM `think_user` `a`,`think_info` `b`
6.alias
alias用于设置数据表别名
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //设置别名 $user = M('User'); var_dump($user->alias('a')->select()); } }
设置数据表的别名为think_user a语句：SELECT * FROM think_user a
7.group
group方法一般用于对结合函数统计的结果集分组。
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //分组统计 $user = M('User'); var_dump($user->field('user,max(id)')->group('id')->select()); } }
以ID进行分组:SELECT `user`,max(id) FROM `think_user` GROUP BY id
8.having
having方法通常用于配合group方法完成从分组的结果中再筛选数据。
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //分组统计结合having $user = M('User'); var_dump($user->field('user,max(id)')->group('id')->having('id>2')->select()); } }
sql语句：SELECT `user`,max(id) FROM `think_user` GROUP BY id HAVING id>2
9.comment
comment方法用于对SQL语句进行注释
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //SQL注释 $user = M('User'); var_dump($user->comment('全部用户')->select()); } }
sql注释语句:SELECT * FROM `think_user` /* 全部用户 */
10.join
join方法用于多表的链接查询。
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //JOIN多表关联，默认是INNER JOIN $user = M('User'); var_dump($user->join('think_user ON think_info.id = think_user.id')->select()); //__USER__和__INFO__代替 } }
查看think_info.id表和think_user.id表ID是否同样语句：SELECT * FROM `think_user` INNER JOIN think_user ON think_info.id = think_user.id
11.union
union方法用于合并多个SELECT的结果集
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //合并多个SELECT结果集 $user = M('User'); var_dump($user->union("SELECT * FROM think_info")->select()); } }
合并think_user和think_info的结果集语句：SELECT * FROM `think_user` UNION SELECT * FROM think_info
12.distinct
distinct方法用于返回惟一不一样的值
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //返回不重复的列 $user = M('User'); var_dump($user->distinct(true)->field('user')->select()); } }
返回不重复的user语句：SELECT DISTINCT `user` FROM `think_user`
13.cache
cache用于查询缓存操做
<?php namespace Home\Controller; use Think\Controller; use Think\Model; class UserController extends Controller { public function model () { //查询缓存，第二次读取缓存内容 $user = M('User'); var_dump($user->cache(true)->select()); } }
查询think_user表用缓存语句：SELECT * FROM `think_user`
注意：第一次查询数据库，第二次查询相同的内容直接调用缓存，不用再查询数据库
三．命名范围
命名范围其实就是将SQL语句封装在模型定义类里，而不在控制器里。这样的分层操做有利于代码的可读性，避免开发人员在写CURD操做时出现问题。架构人员只要在命名范围内合理的规划便可，相似于架构师架构了接口，让开发人员面向接口开发同样。
要使用命名范围，第一步要定义属性：Weibo\Home\Model\UserModel.class.php
<?php namespace Home\Model; use Think\Model; class UserModel extends Model { protected $_scope = array( //建立属性，属性名必须是_scope,作一个数组array 'sql1'=>array( 'where'=>array('id'=>1), ), 'sql2'=>array( 'order'=>'date DESC', 'limit'=>2, ), 'default'=>array( 'where'=>array('id'=>2), ), ); }
命名范围支持的属性有：where、field、order、table、limit、page、having、group、lock、distinct、cache。
调用端：
单个scope方法
<?php namespace Home\Controller; use Think\Controller; use Think\Model; use Home\Model\UserModel; class UserController extends Controller { public function model () { //调用命名范围 $user = D('User'); var_dump($user->scope('sql1')->select()); //scope方法调用 } }
调用Weibo\Home\Model\UserModel.class.php里的sql1语句：SELECT * FROM `think_user` WHERE ( `id` = 1 )
多个scope方法
<?php namespace Home\Controller; use Think\Controller; use Think\Model; use Home\Model\UserModel; class UserController extends Controller { public function model () { //支持调用多个scope方法 $user = D('User'); var_dump($user->scope('sql1')->scope('sql2')->select()); } }
调用Weibo\Home\Model\UserModel.class.php里的sql1和sql2
default默认
<?php namespace Home\Controller; use Think\Controller; use Think\Model; use Home\Model\UserModel; class UserController extends Controller { public function model () { //default默认 $user = D('User'); var_dump($user->scope()->select()); //传递default也行 } }
调用Weibo\Home\Model\UserModel.class.php里的default语句：SELECT * FROM `think_user` WHERE ( `id` = 2 )
对命名范围的SQL进行调整
<?php namespace Home\Controller; use Think\Controller; use Think\Model; use Home\Model\UserModel; class UserController extends Controller { public function model () { //对命名范围的SQL进行调整 $user = D('User'); var_dump($user->scope('sql2', array('limit'=>4))->select()); } }
调用Weibo\Home\Model\UserModel.class.php里的sql2把'limit'=>4语句:SELECT * FROM `think_user` ORDER BY date DESC LIMIT 2
直接覆盖命名范围
<?php namespace Home\Controller; use Think\Controller; use Think\Model; use Home\Model\UserModel; class UserController extends Controller { public function model () { //直接覆盖命名范围 $user = D('User'); var_dump($user->scope(array('where'=>1,'order'=>'date DESC','limit'=>2))->select()); }
直接覆盖命名范围语句：SELECT * FROM `think_user` ORDER BY date DESC LIMIT 2
直接用命名范围名调用
<?php namespace Home\Controller; use Think\Controller; use Think\Model; use Home\Model\UserModel; class UserController extends Controller { public function model () { //直接用命名范围名调用 $user = D('User'); var_dump($user->sql2()->select()); } }
SELECT * FROM `think_user` ORDER BY date DESC LIMIT 2
ThinkPHP--模型操做部分---数据库操做--CURD(增删改查)操做
一．数据建立
1.在数据库添加等操做以前，咱们首先须要对数据进行建立。何为数据建立，就是接受提交过来的数据，好比表单提交的POST（默认）数据。接受到数据后，还能够对数据进行有效的验证、完成、生成等工做。
作一个提交页面做于测试：http://localhost/ThinkPHP/index.html
<meta charset="UTF-8"> <form method="post" action="http://localhost/ThinkPHP/Home/User/create"> <p>用户：<input type="text" name="user"></p> <p>邮箱：<input type="text" name="email"></p> <p>生日：<input type="text" name="birthday"></p> <input type="submit" value="提交"> </form>
当提交数据传输到http://localhost/ThinkPHP/Home/User/create
路径：ThinkPHP/Weibo/Home/Common/Controller/UserController.class.php代码
方式一：根据表单提交的POST数据，建立数据对象
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function create() { //根据表单提交的POST数据，建立数据对象 $user = M('User'); var_dump($user->create()); //create只提交跟user对应的字段 } }
create返回了一个数组数组包含user和email，生日没有提交出去，由于生日不存在User表里的：
array (size=2)
'user' => string '蜡笔小新' (length=12)
'email' => string 'xiaoxin@qq.com' (length=14)
注意：这里create()方法就是数据建立，数据的结果就是提交的POST数据的键值对。特别注意的是：提交过来的字段和数据表字段是对应的，不然没法解析。
作一个提交页面做于测试：http://localhost/ThinkPHP/index.html
<meta charset="UTF-8"> <form method="post" action="http://localhost/ThinkPHP/Home/User/create"> <p>用户：<input type="text" name="user"></p> <p>邮箱：<input type="text" name="email"></p> <input type="submit" value="提交"> </form>
方式二：经过数组手工获取数据，覆盖提交的
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function create() { //经过数组手工获取数据，覆盖提交的 $user = M('User'); $data['user'] = $_POST['user']; //直接用post接收user $data['email'] = $_POST['email']; //直接用post接收email $data['date'] = date('Y-m-d H:i:s'); //时间不须要提交过来，本身直接作，和数据表对应，不然无效 var_dump($user->create($data)); } }
经过数组手工提交获取数据结果：
array (size=3)
'user' => string '西西' (length=6)
'email' => string 'xixi@qq.com' (length=11)
'date' => string '2018-04-14 13:30:41' (length=19)
方式三：经过对象手工获取数据，覆盖提交的
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function create() { //经过对象手工获取数据，覆盖提交的 $user = M('User'); $data = new \stdClass(); $data->user = $_POST['user']; $data->email = $_POST['email']; $data->date = date('Y-m-d H:i:s'); var_dump($user->create($data)); } }
经过对象手工提交获取数据结果：
array (size=3)
'user' => string '西西' (length=6)
'email' => string 'xixi@qq.com' (length=11)
'date' => string '2018-04-14 13:30:41' (length=19)
2.经过get方式发送
作一个提交页面做于测试把post方式改成get方式：http://localhost/ThinkPHP/index.html
<meta charset="UTF-8"> <form method="get" action="http://localhost/ThinkPHP/Home/User/create"> <p>用户：<input type="text" name="user"></p> <p>邮箱：<input type="text" name="email"></p> <input type="submit" value="提交"> </form>
传递$_GET
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function create() { //默认是$_POST，传递$_GET修改 $user = M('User'); var_dump($user->create($_GET)); } }
create()方法的内部工做分为9步：
1.获取数据源（默认是POST）；
2.验证数据合法性（非数据或对象会过滤），失败则返回false；
3.检查字段映射；
4.判断数据状态（新增仍是修改）；
5.数据自动验证，失败则返回false；
6.表单令牌验证，失败则返回false；
7.表单数据赋值（过滤非法字段和字符串处理）；
8.数据自动完成；
9.生成数据对象（保存在内存）。
create()方法能够配合连贯操做配合数据建立，支持的连贯操做有：
作一个提交页面做于测试：http://localhost/ThinkPHP/index.html
<meta charset="UTF-8"> <form method="post" action="http://localhost/ThinkPHP/Home/User/create"> <p>用户：<input type="text" name="user"></p> <p>邮箱：<input type="text" name="email"></p> <input type="submit" value="提交"> </form>
1.field，用于定义合法的字段；
(1)限制可操做的字段:email
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function create() { //限制可操做的字段user $user = M('User'); var_dump($user->field('user')->create()); } }
只显示user
array (size=1)
'user' => string '蜡笔小新' (length=12)
(2)在模型类里限制字段email
路径：ThinkPHP/Weibo/Home/Common/Model/UserModle.class.php代码
<?php namespace Home\Model; use Think\Model; //在模型类里限制字段 class UserModel extends Model { protected $insertFields = 'user'; protected $updateFields = 'user'; }
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function create() { //限制可操做的字段 $user = D('User'); var_dump($user->field('user')->create()); } }
只显示user：
array (size=1)
'user' => string '蜡笔小新' (length=12)
2.validate，用于数据自动验证；
3.auto，用于数据自动完成；
4.token，用于令牌验证
二．数据写入（add）
数据写入使用的是add()方法。
方式一：普通方式新增一条数据
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function add() { //新增一条数据 $user = M('User'); $data['user'] = '西西'; $data['email'] = 'xixi.163@.com'; $data['date'] = date('Y-m-d H:i:s'); $user->add($data); } }
sql语句：INSERT INTO `think_user` (`user`,`email`,`date`) VALUES ('西西','xixi.163@.com','2018-04-14 13:44:35')
方式二：结合create()方法
作一个add写入提交页面：http://localhost/ThinkPHP/index.html
<meta charset="UTF-8"> <form method="post" action="http://localhost/ThinkPHP/Home/User/add"> <p>用户：<input type="text" name="user"></p> <p>邮箱：<input type="text" name="email"></p> <input type="submit" value="提交"> </form>
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function add() { //结合create()方法 $user = M('User'); $data = $user->create(); $data['date'] = date('Y-m-d H:i:s'); $user->add($data); } }
经过提交页面提交后sql语句：INSERT INTO `think_user` (`user`,`email`,`date`) VALUES ('西西123','xixi@qq.com','2018-04-14 13:47:16')
add()方法支持的连贯操做有：
1.table，定义数据表名称；
2.data，指定要写入的数据对象；
(1)使用data连贯方法
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function add() { //使用data连贯方法 $user = M('User'); $data = $user->create(); $data['date'] = date('Y-m-d H:i:s'); $user->data($data)->add(); } }
经过提交页面提交后sql语句：INSERT INTO `think_user` (`user`,`email`,`date`) VALUES ('西西456','xixi@qq.com','2018-04-14 13:50:44')
(2)data连贯方法 支持字符串、数组、对象
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function add() { //data连贯方法 支持字符串、数组、对象 $user = M('User'); $data = 'user=星矢&mail=xinshi@qq.com&date='.date('Y-m-d H:i:s'); $user->data($data)->add(); } }
经过提交页面提交后sql语句：INSERT INTO `think_user` (`user`,`date`) VALUES ('星矢','2018-04-14 13:52:41')
3.field，定义要写入的字段；
4.relation，关联查询；
5.validate，数据自动验证；
6.auto，数据自动完成；
7.filter，数据过滤；
8.scope*，命名范围；
9.bind，数据绑定操做；
10.token，令牌验证；
11.comment，SQL注释；
三．数据读取()
数据读取的功能select()方法。结合各类连贯方法能够实现数据读取的不一样要求，支持连贯的方法有:
1.where，查询或更新条件；
2.table，要操做的数据表名称；
3.alias，数据表别名；
4.field，查询字段；
5.order，结果排序；
6.group，查询分组；
7.having，分组再查询；
8.join，多表连接查询；
9.union，合并SELECT；
10.distinct，取惟一值；
11.lock，锁；
12.cache，缓存；
13.relation，关联查询；
14.result，数据转换；
15.scope，命名范围；
16.bind，数据绑定操做；
17.comment，SQL注释。
显示默认第一条数据
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function select() { //显示默认第一条数据 $user = M('User'); var_dump($user->find()); //能够传递数字参数，AR模式 } }
sql语句：SELECT * FROM `think_user` LIMIT 1
显示默认全部数据
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function select() { //显示默认全部数据 $user = M('User'); var_dump($user->select()); //能够传递数组形式的SQL } }
sql语句：SELECT * FROM `think_user`
获取第一条user字段的值
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function select() { //获取第一条user字段的值 $user = M('User'); var_dump($user->getField('user')); } }
sql语句：SELECT `user` FROM `think_user` LIMIT 1
获取全部user字段的值
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function select() { //获取全部user字段的值 $user = M('User'); var_dump($user->getField('user',true)); } }
sql语句：SELECT `user` FROM `think_user`
传递多个字段，获取全部(重复的被屏蔽)
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function select() { //传递多个字段，获取全部 $user = M('User'); var_dump($user->getField('user,email')); } }
sql语句：SELECT `user`,`email` FROM `think_user`
用id冒号分隔
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function select() { //id冒号分隔 $user = M('User'); var_dump($user->getField('id,user,email',':')); } }
sql语句：SELECT `id`,`user`,`email` FROM `think_user`
限制2条数据
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function select() { //限制2条数据 $user = M('User'); var_dump($user->getField('id,user,email',2)); } }
sql语句：SELECT `id`,`user`,`email` FROM `think_user` LIMIT 2
四．数据更新(save)
数据更新使用的方法是save()方法，主要是对数据的修改操做。
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function save() { //修改第一条数据 $user = M('User'); $data['user'] = '蜡笔大新'; $data['email'] = 'daxin@qq.com'; $map['id'] = 1; $user->where($map)->save($data); //成功后返回1，不然0 } }
sql语句：UPDATE `think_user` SET `user`='蜡笔大新',`email`='daxin@qq.com' WHERE ( `id` = 1 )
判断主键是条件(可读性差)
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function save() { //默认主键为条件 $user = M('User'); $data['id'] = 1; $data['user'] = '蜡笔小新'; $data['email'] = 'xiaoxin@163.com'; $user->save($data); } }
sql语句：UPDATE `think_user` SET `user`='蜡笔小新',`email`='xiaoxin@163.com' WHERE ( `id` = 1 )
数据更新的save()方法支持的连贯方法有：
1.where，查询或更新条件；
2.table，要操做的数据表名称；
3.alias，数据表别名；
4.field，查询字段；
5.order，结果排序；
6.lock，锁；
7.relation，关联查询；
8.scope，命名范围；
9.bind，数据绑定操做；
10.comment，SQL注释。
作一个save更新提交页面：http://localhost/ThinkPHP/index.html
<meta charset="UTF-8"> <form method="post" action="http://localhost/ThinkPHP/Home/User/save"> <input type="hidden" name="id" value="1"> <p>用户：<input type="text" name="user"></p> <p>邮箱：<input type="text" name="email"></p> <input type="submit" value="提交"> </form>
结合create()可读性更差
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function save() { //结合create() $user = M('User'); $user->create(); //POST必须包含主键 $user->save(); } }
结合create提交后sql语句：UPDATE `think_user` SET `user`='蜡笔大新',`email`='113194773@qq.com' WHERE ( `id` = 1 )
修改某一个值
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function save() { //修改某一个值 $user = M('User'); $map['id'] = 1; $user->where($map)->setField('user', '蜡笔小新'); } }
sql语句：UPDATE `think_user` SET `user`='蜡笔小新' WHERE ( `id` = 1 )
统计累计，累加count字段加1
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function save() { //统计累计，累加 $user = M('User'); $map['id'] = 1; $user->where($map)->setInc('count',1); //累加 } }
sql语句：UPDATE `think_user` SET `count`=count+1 WHERE ( `id` = 1 )
统计累计，累减count字段减1
<?php
namespace Home\Controller;
use Think\Controller;
class UserController extends Controller {
public function save() {
//统计累计，累加累减
$user = M('User');
$map['id'] = 1;
$user->where($map)->setDec('count',1); //setDec累减
}
}
sql语句：UPDATE `think_user` SET `count`=count-1 WHERE ( `id` = 1 )
五．数据删除（delete）
数据删除使用的方法是delete()方法。
直接删除主键(id=4)
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function delete() { //直接删除主键(id=4) $user = M('User'); $user->delete(4); } }
sql语句：DELETE FROM `think_user` WHERE ( `id` = 4 )
根据ID来删除
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function delete() { //根据ID来删除 $user = M('User'); $map['id'] = 5; $user->where($map)->delete(); } }
sql语句：DELETE FROM `think_user` WHERE ( `id` = 5 )
批量删除多个
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function delete() { //批量删除多个 $user = M('User'); $user->where($map)->delete('7,10,11'); } }
sql语句：DELETE FROM `think_user` WHERE ( `id` IN ('7','10','11') )
删除count为0且按时间倒序的前五个
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function delete() { //删除count为0且按时间倒序的前俩个 $user = M('User'); $map['count'] = 0; //count为0删掉还剩一个 $user->where($map)->order(array('date'=>'DESC'))->limit(2)->delete(); //排序order把最后俩个删掉 } }
sql语句：DELETE FROM `think_user` WHERE ( `count` = 0 ) ORDER BY `date` DESC LIMIT 2
删除全部数据，谨慎
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function delete() { //删除全部数据 $user = M('User'); echo $user->where('1')->delete(); } }
delete()方法支持的连贯操做有：
1.where，查询或更新条件；
2.table，要操做的数据表名称；
3.alias，数据表别名；
4.order，结果排序；
5.lock，锁；
6.relation，关联查询；
7.scope，命名范围；
8.bind，数据绑定操做；
9.comment，SQL注释。
六．ActiveReocrd模式(ar)
这种模式最大的特别就是简化了CURD的操做，而且采用对象化的操做方式，便于使用和理解。
ActiveReocrd模式添加一条数据
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function ar() { //添加一条数据 $user = M('User'); $user->user = '火影忍者'; $user->email = 'huoyin@qq.com'; $user->date = date('Y-m-d H:i:s'); $user->add(); } }
sql语句：INSERT INTO `think_user` (`user`,`email`,`date`) VALUES ('火影忍者','huoyin@qq.com','2018-04-14 12:35:33')
找到主键为2的值
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function ar() { //找到主键为2的值 $user = M('User'); var_dump($user->find(2)); } }
sql语句：SELECT * FROM `think_user` WHERE ( `id` = 2 ) LIMIT 1
查找user=西西的记录并输出
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function ar() { //查找user=西西的记录 $user = M('User'); var_dump($user->getByUser('西西')); //输出user echo $user->user; } }
sql语句：SELECT * FROM `think_user` WHERE ( `user` = '西西' ) LIMIT 1
经过主键查询1，2，3数据
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function ar() { //经过主键查询多个 $user = M('User'); var_dump($user->select('1,2,3')); } }
sql语句：SELECT * FROM `think_user` WHERE ( `id` IN ('1','2','3') )
查找id=3的把user改为蜡笔老新(效率不高)
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function ar() { //修改一条数据 $user = M('User'); $user->find(3); //找到第一条 $user->user = '蜡笔老新'; //改为 $user->save(); } }
sql语句：
SELECT * FROM `think_user` WHERE ( `id` = 3 ) LIMIT 1
UPDATE `think_user` SET `user`='蜡笔老新',`email`='xixi.163@.com',`count`=null,`date`='2018-04-14 11:44:44' WHERE ( `id` = 3 )
查找id=3的删除掉(效率不高)
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function ar() { //删除当前找到的数据 $user = M('User'); $user->find(3); $user->delete(); } }
sql语句：
SELECT * FROM `think_user` WHERE ( `id` = 3 ) LIMIT 1
DELETE FROM `think_user` WHERE ( `id` = 3 )
七．字段映射
字段映射能够将表单里的name名称对应到数据表里的字段，这样防止系统自动屏蔽掉不对应的POST值。
作一个model写入提交页面：http://localhost/ThinkPHP/index.html
<meta charset="UTF-8"> <form method="post" action="http://localhost/ThinkPHP/Home/User/model"> <p>用户：<input type="text" name="xingming"></p> <p>邮箱：<input type="text" name="youxiang"></p> <input type="submit" value="提交"> </form>
UserModle.class.php代码：在模型类型里限制字段xingming=user,youxiang=email
<?php namespace Home\Model; use Think\Model; //在模型类里限制字段 class UserModel extends Model { protected $_map = array( 'xingming'=>'user', 'youxiang'=>'email', ); }
UserController.class.php最后实现字段映射获取
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function model() { //字段映射获取 $user = D('User'); var_dump($user->create()); } }
ThinkPHP--模型操做部分----数据库操做---自动验证
ThinkPHP模型层提供的一种数据验证方法，能够在使用create建立数据对象的时候进行自动验证。
一．验证规则
数据验证能够对表单中的字段进行非法的验证操做。通常提供了两种验证方式：静态定义（$_validate属性处理字段的）和动态验证（validate()方法灵活性比较高）。
ThinkPHP/Weibo/Home/Model/UserModle.class.php添加须要验证限制字段
<?php namespace Home\Model; use Think\Model; //在模型类里限制字段 class UserModel extends Model { //验证规则 protected $_validate = array( array('user','require','用户不得为空！',0,'regex',3), //(验证字段1,验证规则,错误提示,[验证条件,附加规则,验证时间]) array(), ); }
注意：验证字段、验证规则和错误提示这三项是必选的，大多数也是用这三项；而验证条件、附加规则和验证时间是可选的。
1.验证字段：通常来讲是表单的字段名，不必定必须和数据表匹配的，由于有一些好比密码确认等辅助字段的存在。
2.验证规则：系统内置了经常使用的规则，require(字段必填)、email(邮箱格式)、url(url格式)、currency(货币)、number(正整数)、integer(整数)、double(浮点数)、zip(邮政编码)、english(英文)。这些规则默认采用的附加规则是regex，正则表达式验证，只不过是设定好的。
3.错误信息：验证失败后的提示。
4.验证条件：共三种：
(1)self::EXISTS_VALIDATE或0，表示存在字段就验证（默认）；
(2)self::MUST_VALIDATE或1，表示必须验证；
(3)self::VALUE_VALIDATE或2，表示值不为空的时候验证。
5.附加规则包括如下规则：
regex规则:正则验证，定义的验证规则是一个正则表达式（默认）
function规则:函数验证，定义的验证规则是一个函数名
callback规则:方法验证，定义的验证规则是当前模型类的一个方法
confirm规则:验证表单中的两个字段是否相同，定义的验证规则是一个字段名
equal规则:验证是否等于某个值，该值由前面的验证规则定义
notequal规则:验证是否不等于某个值，该值由前面的验证规则定义（3.1.2版本新增）
in规则:验证是否在某个范围内，定义的验证规则能够是一个数组或者逗号分割的字符串
notin规则:验证是否不在某个范围内，定义的验证规则能够是一个数组或者逗号分割的字符串（3.1.2版本新增）
length规则:验证长度，定义的验证规则能够是一个数字（表示固定长度）或者数字范围（例如3,12 表示长度从3到12的范围）
between规则:验证范围，定义的验证规则表示范围，可使用字符串或者数组，例如1,31或者array(1,31)
notbetween规则:验证不在某个范围，定义的验证规则表示范围，可使用字符串或者数组（3.1.2版本新增）
expire规则:验证是否在有效期，定义的验证规则表示时间范围，能够到时间，例如可使用 2012-1-15,2013-1-15 表示当前提交有效期在2012-1-15到2013-1-15之间，也可使用时间戳定义
ip_allow规则:验证IP是否容许，定义的验证规则表示容许的IP地址列表，用逗号分隔，例如201.12.2.5,201.12.2.6
ip_deny规则:验证IP是否禁止，定义的验证规则表示禁止的ip地址列表，用逗号分隔，例如201.12.2.5,201.12.2.6
unique规则:验证是否惟一，系统会根据字段目前的值查询数据库来判断是否存在相同的值，当表单数据中包含主键字段时unique不可用于判断主键字段自己
6.验证时间：主要新增修改等验证。
(1)self::MODEL_INSERT或1新增数据时验证；
(2)self::MODEL_UPDATE或2编辑数据时验证；
(3)self::MODEL_BOTH或3所有状况下验证(默认)。
ThinkPHP/Weibo/Home/Controller/UserController.class.php判断验证
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function add() { $user = D('User'); $date['user'] = '蜡笔小新'; //模拟post提交 if ($user->create($date)) { echo '全部字段验证成功'; }else { var_dump($user->getError()); //自带getError方法 } } }
当user有值的状况下显示：全部字段验证成功
当user没有值的状况下显示：:string '用户不得为空！'
二．静态定义
在模型类里预先定义好该模型的自动验证规则，就是静态定义。
ThinkPHP提供了九种自动验证内置方案
ThinkPHP/Weibo/Home/Model/UserModle.class.php添加须要验证限制字段
<?php namespace Home\Model; use Think\Model; //在模型类里限制字段 class UserModel extends Model { protected $_validate = array( //内置验证require，不得为空的用法 array('user', 'require', '用户不得为空！'), //内置验证email，合法的邮箱格式 array('user', 'email', '邮箱格式不合法！'), //内置验证url，验证网址是否合法 array('user', 'url', 'URL路径不合法！'), //内置验证currency，验证是否为货币 array('user', 'currency', '货币格式不正确！'), //内置验证zip，验证是否为六位整数邮政编码 array('user', 'zip', '邮政编码格式不正确！'), //内置验证number，验证是否为正整数 array('user', number, '正整数格式不正确！'), //内置验证integer，验证是否为整数，正负都可 array('user', 'integer', '整数格式不正确！'), //内置验证double，验证是否为浮点数，正负都可 array('user', 'double', '整数格式不正确！'), //内置验证english，验证是纯英文 array('user', 'english', '不是纯英文！'), ); }
ThinkPHP还提供了附加规则，来提高自动验证的扩展性：
<?php namespace Home\Model; use Think\Model; //在模型类里限制字段 class UserModel extends Model { protected $_validate = array( //附加规则regex，验证3-6位纯数字 array('user', '/^\d{3,6}$/', '不是3-6位纯正数字', 0, 'regex'), //0表示有字段的时候验证 //附加规则equal，验证是否和指定值相等 array('user', '西西', '值不对等', 0, 'equal'), //若是传递过来的值不是西西弹出值不对等 //附加规则notequal，验证是否与指定值不等 array('user', '西西', '值不能相等', 0, 'notequal'), //若是传递过来的值是西西弹出值不能相等 //附加规则confirm，验证两条字段是否相同 array('user', 'name', '两个用户名对比不一样！',0,'confirm'), //若是'user'和'name'不相等弹出两个用户名对比不一样(用于密码和密码确认) //附加规则in，某个范围，能够是数组或逗号分割的字符串 array('user', array(1,2,3), '不在指定范围', 0, 'in'), //若是传递过来的值不是1，2，3弹出不在指定范围 array('user', '张三,李四,王五', '不在指定范围', 0, 'in'), //字符串形式也能够 //附加规则notin，某个范围，能够是数组或逗号分割的字符串 array('user', array(1,2,3), '不得在指定范围', 0, 'notin'), //若是传递过来的值是1，2，3弹出不得在指定范围 array('user', '张三,李四,王五', '不得在指定范围', 0, 'notin'), //附加规则length，验证长度或数字范围 array('user', '3', '不得小于3位', 0, 'length'), //若是长度小于3位弹出不得小于3位 array('user', '3,5', '不得小于3位，不得大于5位', 0, 'length'), /若是长度超过3-5位位弹出不得小于3位，不得大于5位 //附加规则between，验证某个范围，数字或逗号字符串 array('user', array(3,5), '必须是3-5之间的数字', 0, 'between'), //若是是3-5之间的数字弹出必须是3-5之间的数字 array('user', '3,5', '必须是3-5之间的数字', 0, 'between'), //附加规则notbetween，验证某个范围，数字或逗号字符串 array('user', array(3,5), '必须不是3-5之间的数字', 0, 'notbetween'), //若是是3-5之间的数字弹出必须不是3-5之间的数字 array('user', '3,5', '必须不是3-5之间的数字', 0, 'notbetween'), //附加规则expire，设置有效期范围，必须是表单提交有效，能够是时间戳 array('user', '2018-1-10,2019-10-10', '时间已过时', 0, 'expire'), //在这个时间内弹出时间已过时 //附加规则ip_deny，IP禁止列表 array('user', '127.0.0.1', '当前IP被禁止', 0, 'ip_deny'), //自动获取IP判断禁止 //附加规则ip_allow，IP容许列表 array('user', '127.0.0.1', '当前IP没有被容许', 0, 'ip_allow'), //只容许127.0.0.1这个IP访问 ); }
为了测试方便，咱们能够直接经过模拟提交POST：
ThinkPHP/Weibo/Home/Controller/UserController.class.php判断验证
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function add() { //控制器create()方法自动调用验证 $user = D('User'); $data['user'] = '测试'; if ($user->create($data)) { echo '全部数据验证成功！'; } else { //输出错误信息 var_dump($user->getError()); } } }
自定义规则用户名字必须在3-5位
回调方法
ThinkPHP/Weibo/Home/Model/UserModle.class.php添加须要验证限制字段
<?php namespace Home\Model; use Think\Model; //在模型类里限制字段 class UserModel extends Model { protected $_validate = array( array('user', 'checkLength', '用户名必须在3-5位', 0, 'callback', 3, array(3,5)), //执行回调函数checkLength，错误提示用户名必须在3-5位，默认0占位，callback回调函数，默认是3，array(3,5)是能够给它们传值的 ); //回调方法 protected function checkLength($str,$min,$max) { //执行这个方法checkLength的返回值来验证接收三个参数：$str获得user传过来的值，$min最小值，最大值$max preg_match_all("/./u", $str, $matches); //正则表达式获得一个数组$matches $len = count($matches[0]); //获得相应的数组保存在$len if ($len < $min || $len > $max) { //若是$len小于$min或者大于$max return false; //返回false } else { return true; } }
ThinkPHP/Weibo/Home/Controller/UserController.class.php判断验证
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function add() { //控制器create()方法自动调用验证 $user = D('User'); $data['user'] = '西西西西'; if ($user->create($data)) { echo '全部数据验证成功！'; } else { //输出错误信息 var_dump($user->getError()); } } }
函数验证附加规则function，
ThinkPHP/Weibo/Home/Model/UserModle.class.php添加须要验证限制字段
<?php namespace Home\Model; use Think\Model; //在模型类里限制字段 class UserModel extends Model { protected $_validate = array( //附加规则function，函数验证 array('user', 'checkLength', '用户名必须在3-5位', 0, 'function', 3, array(3,5)), //执行回调函数checkLength，错误提示用户名必须在3-5位，默认0占位，callback回调函数，默认是3，array(3,5)是能够给它们传值的 ); }
智能加载必须放在公共模块下的公共核心文件夹新建一个规定的名称ThinkPHP/Weibo/Common/Common/function.php
<?php //函数验证 function checkLength($str,$min,$max) { //执行这个方法checkLength的返回值来验证接收三个参数：$str获得user传过来的值，$min最小值，最大值$max preg_match_all("/./u", $str, $matches); //正则表达式获得一个数组$matches $len = count($matches[0]); //获得相应的数组保存在$len if ($len < $min || $len > $max) { //若是$len小于$min或者大于$max return false; //返回false } else { return true; } }
ThinkPHP/Weibo/Home/Controller/UserController.class.php判断验证
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function add() { //控制器create()方法自动调用验证 $user = D('User'); $data['user'] = '西西西西'; if ($user->create($data)) { echo '全部数据验证成功！'; } else { //输出错误信息 var_dump($user->getError()); } } }
若是有多个字段都包含错误，默认只显示一个错误。若是想显示所有错误，能够设置属性：
ThinkPHP/Weibo/Home/Model/UserModle.class.php添加须要验证限制字段(用户名字和邮箱)
<?php namespace Home\Model; use Think\Model; //在模型类里限制字段 class UserModel extends Model { //批量验证 protected $patchValidate = true; protected $_validate = array( //附加规则function，函数验证 array('user', 'checkLength', '用户名必须在3-5位', 0, 'callback', 3, array(3,5)), //执行回调函数checkLength，错误提示用户名必须在3-5位，默认0占位，callback回调函数，默认是3，array(3,5)是能够给它们传值的 //内置验证email，合法的邮箱格式 array('email', 'email', '邮箱格式不合法！'), ); //回调方法 protected function checkLength($str,$min,$max) { //执行这个方法checkLength的返回值来验证接收三个参数：$str获得user传过来的值，$min最小值，最大值$max preg_match_all("/./u", $str, $matches); //正则表达式获得一个数组$matches $len = count($matches[0]); //获得相应的数组保存在$len if ($len < $min || $len > $max) { //若是$len小于$min或者大于$max return false; //返回false } else { return true; } } }
ThinkPHP/Weibo/Home/Controller/UserController.class.php判断验证返回JSON格式
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function add() { //控制器create()方法自动调用验证 $user = D('User'); $data['user'] = '西西'; $data['email'] = 'aaa'; if ($user->create($data)) { echo '全部数据验证成功！'; } else { //返回JSON格式 $this->ajaxReturn($user->getError()); } } }
三．动态验证
动态验证就是把验证的规则放在控制器端，这样，在操做的时候比较灵活，缺点就是比较混乱。
ThinkPHP/Weibo/Home/Controller/UserController.class.php所有写在控制器里
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function add() { //动态验证 $rule = array( array('user', 'require', '用户名不得为空'), ); $user = M('User'); $data['user'] = ''; if ($user->validate($rule)->create($data)) { //动态validate方法定义传$rule数组变量 echo '验证全部字段成功！'; } else { var_dump($user->geterror()); } } }
当用户名user有值显示验证全部字段成功！
当用户名user没有值显示用户名不得为空
ThinkPHP--模型操做部分----数据库操做--自动完成
ThinkPHP模型层提供的数据处理方法，主要用于数据的自动处理和过滤，使用create()方法建立数据是会自动完成。
一．完成规则
自动完成通常经过默认字段写入、安全字段过滤以及业务逻辑的自动处理等。有两种方式实现自动完成的规则：1.静态方式：在模型类里经过$_auto属性定义处理规则；2动态方式：使用模型类的auto方法动态建立自动处理规则。
1.完成字段：必填，须要的字段名；
2.完成规则：必填，配合附加规则完成；
3.完成条件：可选，具体以下：
(1)self::MODEL_INSERT或1，新增数据的时候处理（默认）；
(2)self::MODEL_UPDATE或2，更新数据的时候处理；
(3)self::MODEL_BOTH或3，全部状况均处理。
4.配合完成规则使用，包括一下规则:
function规则：函数完成，定义的验证规则是一个函数名
callback规则：方法完成，定义的验证规则是当前模型类的一个方法
field规则：用其余字段填充，表示填充的内容是一个其余字段的值
string规则：字符串（默认）
ignore规则：为空则忽略（3.1.2新增）
为了测试方便，咱们能够直接经过模拟提交POST：
ThinkPHP/Weibo/Home/Controller/UserController.class.php提交成功新增一条数据
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function add() { //控制器create()方法自动调用验证 $user = D('User'); $data['user'] = '蜡笔小新'; //模拟数据提交 if ($user->create($data)) { //若是判断成功了 $user->add(); //对他进行新增操做 } } }
二．静态定义
在模型类里预先定义好该模型的自动完成规则，就是静态定义。
ThinkPHP/Weibo/Home/Model/UserModle.class.php模型在新增数据的同时给count字段设置为1
<?php namespace Home\Model; use Think\Model; //在模型类里限制字段 class UserModel extends Model { //自动完成 protected $_auto = array( //自动设置count字段为1 array('count', '1'), //string,自动设置count字段为1 ); }
ThinkPHP/Weibo/Home/Model/UserModle.class.php模型在新增数据的同时给密码加密
<?php namespace Home\Model; use Think\Model; //在模型类里限制字段 class UserModel extends Model { //自动完成 protected $_auto = array( //给密码加密，加密类型为sha1，sha1函数PHP内置 array('user', 'sha1', 3, 'function'), //function，给密码加密，加密类型为sha1，sha1函数PHP内置 ); }
ThinkPHP/Weibo/Home/Model/UserModle.class.php模型在新增数据的同时把email字段的值填充到user字段
<?php namespace Home\Model; use Think\Model; //在模型类里限制字段 class UserModel extends Model { //自动完成 protected $_auto = array( //把email字段的值填充到user字段中 array('user', 'email', 3, 'field'), ); }
ThinkPHP/Weibo/Home/Model/UserModle.class.php模型在新增数据的同时把user字段前面加上下滑线_
<?php namespace Home\Model; use Think\Model; //在模型类里限制字段 class UserModel extends Model { //自动完成 protected $_auto = array( //callback，给用户名加前缀 array('user', 'addPrefix', 3, 'callback', '_'), ); //回调函数 protected function addPrefix($str, $prefix) { return $prefix.$str; } }
ThinkPHP/Weibo/Home/Controller/UserController.class.php提交成功只修改id=6的email
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function add() { //控制器create()方法自动调用验证 $user = D('User'); $data['id'] = 6; //ID=6 $data['user'] = ''; //模拟数据提交 $data['email'] = 'xixi@xixi.com'; //模拟数据提交 if ($user->create($data)) { //若是判断成功了 $user->save(); //对他进行修改操做 } } }
ThinkPHP/Weibo/Home/Model/UserModle.class.php模型在新增数据的同时留空的user忽略不修改
<?php namespace Home\Model; use Think\Model; //在模型类里限制字段 class UserModel extends Model { //自动完成 protected $_auto = array( //ignore，用于修改时密码留空时，忽略修改 array('user', '', 2, 'ignore'), //留空的时候忽略修改它 ); }
三．动态完成
动态完成就是把完成的规则放在控制器端，这样，在操做的时候比较灵活，缺点就是比较混乱。
ThinkPHP/Weibo/Home/Controller/UserController.class.php实现动态给user加密
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function add() { //动态完成 $rules = array( array('user', 'sha1', 3, 'function'), ); $user = M('User'); $data['user'] = '蜡笔小新'; if ($user->auto($rules)->create($data)) { $user->add(); } } }
ThinkPHP--视图(view)
ThinkPHP视图，视图是Web的可见内容，通常是HTML结合PHP获取的数据提供给用户使用的部分，属于MVC中的V。
一．模版定义
模版在使用以前须要必定的设置，才能方便开发者使用。每一个模块的模版文件是独立的，为了对模版文件更加有效的管理，ThinkPHP对模版文件机型目录划分，默认的模版文件定义规则是：
视图目录View/[模版主题/]控制器名User/操做名index+模版后缀.html
第一步：在User控制器UserController.class.php模块执行一条语句：
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function index() { //渲染模版输出 $this->display(); } }
注意：什么都没有定义的状况下，会自动报错，错误信息提示以下
模板不存在:./Weibo/Home/View/User/index.html
建立：/Weibo/Home/View/User/index.html
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> </head> <body> 这是模版文件 </body> </html>
经过这个错误提示，咱们只要在View目录下建立User目录，并在User目录下建立index.html文件，这时模版渲染模版输出成功。
默认状况下视图目录是View，若是你想改变成别的目录名能够设置：
在公共的核心库里配置文件Weibo/Common/Conf/config.php
修改模版的视图目录为Template
<?php return array( //修改模版的视图目录 'DEFAULT_V_LAYER' =>'Template', );
默认状况下的模版文件后缀是.html，若是你想改变成别的后缀能够设置：
修改模版中的文件的后缀为.tpl
<?php return array( //修改模版中的文件的后缀 'TMPL_TEMPLATE_SUFFIX'=>'.tpl' );
若是感受每个模块，都要建立相应的目录太过于麻烦，能够设置：
用下划线代替目录层次为Weibo/Home/User_index.html
<?php return array( //用下划线代替目录层次 'TMPL_FILE_DEPR'=>'_', );
若是不想将模版存在在当前Weibo目录下，而设置在外部：
设置外部的模版目录./Public/Home/User/index.html
<?php return array( //设置外部的模版目录 'VIEW_PATH'=>'./Public/', );
若是一个系统要考虑多套界面皮肤的话，要考虑到默认皮肤以及可选皮肤
设置默认主题目录为:./Weibo/Home/View/default/User/index.html
<?php return array( //设置默认主题目录 'DEFAULT_THEME'=>'default', );
切换另一个主题blue
./Weibo/Home/View/blue/User/index.html
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function index() { //切换主题 $this->theme('blue')->display(); } }
二．赋值和渲染
若是要在模版中输出变量，必须在控制器中把变量传递给模版。ThinkPHP提供了assign方法对模版变量赋值，不管何种变量类型都统一使用assign赋值。
/Weibo/Home/View/User/index.html
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> </head> <body> 我是：{$user} </body> </html>
在User控制器UserController.class.php加上模版传递变量
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function index() { //给模版传递一个变量 $this->assign('user', '蜡笔小新'); //渲染模版输出 $this->display(); } }
输出结果：我是蜡笔小新
注意：这个方法必须在display()方法以前使用，保存变量正确传递
渲染模版输出使用的是display方法，有三个可选参数：
display([模版文件][,字符编码][,输出类型]);
若是不传递任何参数，它会按照默认的目录定位模版的位置：
当前模块/默认视图目录/当前控制器/当前操做.html
在User控制器UserController.class.php修改
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function index() { //修改默认模版：./Weibo/Home/View/default/User/add.tpl $this->display('add'); //修改默认模版，目录加模版：./Weibo/Home/View/default/Bbb/add.tpl $this->display('Bbb/add'); //修改默认模版，模块加目录加模版：./Weibo/Admin/View/default/Bbb/add.tpl $this->display('Admin@Bbb/add'); //修改默认模版，主题加目录加模版：./Weibo/Home/View/blue/Bbb/add.tpl $this->theme('blue')->display('Bbb/add'); //修改默认模版，自定义模版(Template和Weibo同级):./Template/Public/add.tpl $this->display('./Template/Public/add.tpl'); } }
三．模版地址
ThinkPHP封装了一个T函数，专门用于生成模版文件。格式以下：
T([资源://][模块@][主题/][控制器/]操做,[视图分层]);
在User控制器UserController.class.php添加打印当前模版地址
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function index() { //输出当前模版地址 echo T(); } }
当前模版地址：./Weibo/Home/View/User/index.html
定义方法来自定义模版：
在User控制器UserController.class.php修改
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function index() { //./Weibo/Home/View/Public/add.html echo T('Public/add'); //./Weibo/Admin/View/User/index.html echo T('Admin@index'); //./Weibo/Admin/Template/Public/add.html echo T('Admin@Public/add', 'Template'); } }
直接使用T函数输出index里的内容
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function index() { //直接使用T函数输出 $this->display(T()); } }
四．获取内容
若是须要获取模版的内容，可使用fetch()方法，这个方法的使用和display()方法一致。
经过$content获取模版里的内容再用show渲染出来
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function index() { //获取模版里的内容 $content = $this->fetch(); //var_dump($content); //输出模版里的内容 //经过内容再渲染输出 $this->show($content); } }
注意：使用fetch()方法获取内容，主要是为了能够处理和过滤更加复杂的内容。而后处理后再由show()方法输出(保证出来的信息是安全稳定性的)。
ThinkPHP--视图--模版基础
ThinkPHP模版，模版是将视图里要展示出来的数据进行解析编译的这么一个功能的东西，ThinkPHP内置了一个基于XML的性能卓越的模版引擎ThinkTemplate，使用了动态编译和缓存技术，支持自定义标签库。
一．变量输出
在模版中输出变量是很是容易的，使用assign()方法，以键值对的方式传递变量和值。
1.以键值对方式传递变量和值：/Weibo/Home/View/User/index.html
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> </head> <body> 我是：{$user} <--!模版编译后的结果是：--> <?php echo ($user); ?> //能够在Runtime能够查看 </body> </html>
在User控制器UserController.class.php加上模版传递变量
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function index() { //给模版传递一个变量 $user = '蜡笔小新'; //控制器里的变量提交给下面的user $this->assign('user', $user); //这个user是模版里传递过去的变量 //渲染模版输出 $this->display(); } }
2.模版标签{和$之间不能用任何空格，不然没法解析。若是你想更换两个{}能够设置：
把左右定界符改为了<{}>
<?php return array( //修改默认标签 'TMPL_L_DELIM'=>'<{', 'TMPL_R_DELIM'=>'}>', );
/Weibo/Home/View/User/index.html改为<{$user}>才能接收到变量
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> </head> <body> 我是：<{$user}> </body> </html>
3.若是传递一个数组，咱们直接传递过去后，经过两种方式调用：
在User控制器UserController.class.php加上数组
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function index() { //给模版传递一个数组 $data['user'] = '蜡笔小新'; $data['email'] = 'xinxin@163.com'; $this->assign('data', $data); //渲染模版输出 $this->display(); } }
/Weibo/Home/View/User/index.html俩种输出方式
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> </head> <body> 输出方式一： User:{$data.user} Email:{$data.email} 输出方式二： User:{$data['user']} Email:{$data['email']} </body> </html>
输出结果：输出方式一： User:蜡笔小新 Email:xinxin@163.com输出方式二： User:蜡笔小新 Email:xinxin@163.com
4.若是传递一个对象，咱们直接传递过去后，经过两种方式调用：
在User控制器UserController.class.php加上对象
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function index() { //给模版传递一个对象 $data = new \stdClass(); //建立空对象 $data->user = '蜡笔小新'; //指向user=蜡笔小新 $data->email = 'xinxin@163.com'; $this->assign('data', $data); //渲染模版输出 $this->display(); } }
/Weibo/Home/View/User/index.html俩种输出方式
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> </head> <body> 输出方式一： User:{$data->user} Email:{$data->email} 输出方式二： User:{$data:user} Email:{$data:email} </body> </html>
输出结果：输出方式一： User:蜡笔小新 Email:xinxin@163.com输出方式二： User:蜡笔小新 Email:xinxin@163.com
二．系统变量
在模版中，不但能够输出PHP的系统变量，还能够输出ThinkPHP的系统变量。
1.输出PHP系统变量：/Weibo/Home/View/User/index.html
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> </head> <body> {$Think.server.script_name} 编译后：$_SERVER['SCRIPT_NAME']<br> {$Think.session.admin} 编译后：$_SESSION['admin']<br> {$Think.get.user} 编译后：$_GET['user']<br> {$Think.post.user} 编译后：$_POST['user']<br> {$Think.request.user} 编译后：$_REQUEST['user']<br> {$Think.cookie.name} 编译后：$_COOKIE['name']<br> </body> </html>
2.输出ThinkPHP的系统变量：/Weibo/Home/View/User/index.html
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> </head> <body> {$Think.const.APP_PATH} <!--主目录地址：./Weibo/--><br> {$Think.config.url_model} <!--URL模式：默认是1--><br> {$Think.lang.var_error} <!--语言变量：VAR_ERROR--><br> </body> </html>
三．使用函数
若是有时，咱们须要在模版中使用PHP函数的话，能够按照下面的格式使用：
在User控制器UserController.class.php传递变量
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function index() { //给模版传递一个变量 $user = '蜡笔小新'; //控制器里的变量提交给下面的user $this->assign('user', $user); //这个user是模版里传递过去的变量 //渲染模版输出 $this->display(); } }
1./Weibo/Home/View/User/index.html接收全部变量后加上md5值
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> </head> <body> {$user|md5} </body> </html>
2./Weibo/Home/View/User/index.html接收变量前三位
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> </head> <body> {$user|mb_substr=0,3,'UTF-8'} </body> </html>
打印结果：蜡笔小
3./Weibo/Home/View/User/index.html接收变量前三位后加上md5值
多个函数用"|"隔开便可
方式一：
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> </head> <body> {$user|mb_substr=0,3,'UTF-8'|md5|sha1} </body> </html>
打印结果：6bcbe978003331b82ad38ac828d2cfcd5cabfcaa
若是你以为以上写法须要在脑海里二次翻译，太过于麻烦，那么能够用如下的格式写法：
方式二：
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> </head> <body> {:md5(mb_substr($user,0,3,'UTF-8'))} </body> </html>
打印结果：6bcbe978003331b82ad38ac828d2cfcd5cabfcaa
4.substr前面输出变量，在后面定义，则不须要###
若是有多个参数要传递，能够参考以下设置：
User控制器UserController.class.php传递变量时间戳
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function index() { //给模版传递一个变量 $this->assign('date',time()); //传递变量是个时间戳 //渲染模版输出 $this->display(); } }
/Weibo/Home/View/User/index.html经过三个###把$date这个变量放到全部参数的后面
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> </head> <body> {$date|date="Y-m-d H:i:s",###} </body> </html>
打印结果：2018-04-15 12:07:59
注意：表示date函数传入两个参数，每一个参数用逗号分割，这里第一个参数是Y-m-d H:i:s，第二个参数是前面要输出的date变量，由于该变量是第二个参数，所以须要用###标识变量位置，编译后的结果是：
<?php echo (date($date,"Y-m-d H:i:s")); ?>
5.当传递过来的变量若是没有值的时候，模版提供了默认值输出功能。
/Weibo/Home/View/User/index.html当接收过来没数据能够提供默认输出
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> </head> <body> {$user|default='什么都没有！'} </body> </html>
6.能够在模版中使用运算符，包括对“+”、“-”、“*”、“/”、“%”、“--”和“++”的支持。
User控制器UserController.class.php传递变量num=10
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function index() { $this->assign('num',10); //传递num=10 //渲染模版输出 $this->display(); } }
/Weibo/Home/View/User/index.html接收变量后加10
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> </head> <body> {$num+10} </body> </html>
打印结果：20
模版还支持三元运算符：
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { public function index() { //给模版传递一个变量 $user = '蜡笔小新'; //控制器里的变量提交给下面的user $this->assign('user', $user); //这个user是模版里传递过去的变量 //渲染模版输出 $this->display(); } }
/Weibo/Home/View/User/index.html接收变量后判断有值无值
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> </head> <body> {$user ? '有值' : '无值'} </body> </html>
打印：有值
7.包含文件
在一个系统中，能够包含通用的头文件和脚文件：header和footer。因为每一个页面的头脚都是相同的，因此须要独立分离出来，再用包含文件引入他们。
咱们能够在View目录下default主题目录下建立一个public目录，这个目录专门存放公共调用模版文件。
头区域目录：/Weibo/Home/View/default/Public/header.html
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> </head> <body> <div id=""header>这里是头文件</div> </body> </html>
尾区域目录：Weibo/Home/View/default/Public//footer.html
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> </head> <body> <div id=""footer>这里是脚文件</div> </body> </html>
包含文件引入头尾文件
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> </head> <body> <include file='./Weibo/Home/View/default/Public/header.html' /> 我是内容 <include file='./Weibo/Home/View/default/Public//footer.html' /> </body> </html>
最后打印结果：
这里是头文件
我是内容
这里是脚文件
六．模版注释
模版支持注释功能，提供个模版制做人员参考。
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> </head> <body> {//单行注释} {/* 多行注释 */} </body> </html>
第一步：建立头文件和尾文件
(1)建立头文件：/Weibo/Home/View/default/Public/header.html
<div id=""header>这里是头文件</div>
(2)建立脚文件：/Weibo/Home/View/default/Public/footer.html
<div id=""footer>这里是尾文件</div>
第二步：建立Public下base.tpl模版基页
(1)base.tpl模版基页须要引入头文件和尾文件
(2)设置不一样页面的标题内容<title><block name="title">标题</block></title>
(3)设置不通页面的主要内容<block name="main">主要内容</block>
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title><block name="title">标题</block></title> </head> <body> <include file='./Weibo/Home/View/default/Public/header.html' /> <block name="main">主要内容</block> <include file='./Weibo/Home/View/default/Public/footer.html' /> </body> </html>
第三步：主页面index.html和分页面select.html 页面分别引入base.tpl模版基页
(1)主页面index.html
<extend name="./Weibo/Home/View/default/Public/base.html" /> <block name="title">index的标题</block> <block name="main"> 这里作页面的布局设计 </block>
输出结果：
这里是头文件
这里作页面的布局设计
这里是脚文件
源代码：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>index的标题</title>
</head>
<body>
<div id=""header>这里是头文件</div>
这里作页面的布局设计
<div id=""footer>这里是脚文件</div>
</body>
</html>
(2)分页面select.html
<extend name="./Weibo/Home/View/default/Public/base.html" /> <block name="title">select的标题</block> <block name="main"> 这里作页面的布局设计 </block>
输出结果：
这里是头文件
这里作页面的布局设计
这里是脚文件
源代码：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>select的标题</title>
</head>
<body>
<div id=""header>这里是头文件</div>
这里作页面的布局设计
<div id=""footer>这里是脚文件</div>
</body>
</html>
八．模版布局
ThinkPHP的模版引擎内置了布局模版功能支持，能够方便实现模版布局以及布局嵌套功能。有三种布局方式：
1.全局配置方式
第一步：配置文件须要添加:Weibo/Common/Conf/config.cfg
<?php return array( //设置默认主题 'DEFAULT_THEME' => 'default', //开启模版布局功能，并指定基础页 'LAYOUT_ON'=>true, 'LAYOUT_NAME'=>'Public/layout', //layout.html文件 );
第二步：/Weibo/Home/View/default/Public/layout.html
(1)基础页引入头尾文件
(2)基础页，{__CONTENT__}将被子页面的内容替换
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>标题</title> </head> <body> <include file='./Weibo/Home/View/default/Public/header.html' /> {__CONTENT__} <include file='./Weibo/Home/View/default/Public//footer.html' /> </body> </html>
第三步：/Weibo/Home/View/default/User/index.html添加内容部分
最后打印结果：
这里是头文件
内容部分
这里是脚文件
自模版能够设置不载入模版页/Weibo/Home/View/default/User/index.html
子模版不须要载入模版基页，能够在开头加上{__NOLAYOUT__}
{__NOLAYOUT__}
内容部分
打印结果：
内容部分
2.模版标签方式
标签方式，并不须要在系统作任何配置，和模版继承相似，直接引入便可。
/Weibo/Home/View/default/User/index.html直接继承
<layout name="Public/layout" /> 内容部分
3.layout控制布局
这个方法是在控制器里操做的。
User控制器UserController.class.php设置指定基页
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { //引入指定基页 public function index() { layout('Public/layout'); //layout(false); //关闭 $this->display(); } }
Weibo/Home/View/default/User/index.html添加内容部分
最后打印结果：
这里是头文件
内容部分
这里是脚文件
九．模版替换
在模版渲染以前，系统还会对读取的模版内容进行一些特殊字符串替换操做，也就实现了模版输出的替换和过滤。
__ROOT__： 会替换成当前网站的地址（不含域名）
__APP__： 会替换成当前应用的URL地址 （不含域名）
__MODULE__：会替换成当前模块的URL地址 （不含域名）
__CONTROLLER__（或者__URL__ 兼容考虑）： 会替换成当前控制器的URL地址（不含域名）
__ACTION__：会替换成当前操做的URL地址 （不含域名）
__SELF__： 会替换成当前的页面URL
__PUBLIC__：会被替换成当前网站的公共目录 一般是/Public/
Weibo/Home/View/default/User/index.html添加：
__ROOT__<br> __APP__<br> __MODULE__<br> __CONTROLLER__<br> __ACTION_<br> __SELF__L<br> __PUBLIC__<br>
打印结果：
/ThinkPHP
/ThinkPHP/index.php
/ThinkPHP/index.php/Home
/ThinkPHP/index.php/Home/User
__ACTION_
/ThinkPHP/Home/User/indexL
/ThinkPHP/Public
也能够更改默认的/Public和上传路径规则
配置文件:Weibo/Common/Conf/config.cfg
<?php return array( //设置默认主题 'DEFAULT_THEME' => 'default', 'TMPL_PARSE_STRING' =>array( '__PUBLIC__' => '/Common', //更改默认的/Public替换规则 '__UPLOAD__' => '/Uploads', //增长新的上传路径替换规则 ) );
ThinkPHP--视图--内置标签
ThinkPHP模版中的内置标签，所谓内置标签就是模版引擎提供的一组能够完成控制、循环和判断功能的相似HTML语法的标签。
一．判断比较
ThinkPHP内置了IF标签用于在模版中进行条件判断
User控制器UserController.class.php设置变量
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { //引入指定基页 public function index() { //给模版传递一个变量 $user = '蜡笔小新'; $this->assign('user', $user); //渲染模版输出 $this->display(); } }
Weibo/Home/View/default/User/index.html模版中进行条件判断：
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> <if condition="$user eq '蜡笔小新'"> 小新 <elseif condition="$user eq '黑崎一护'" /> 一护 <else /> 错误 </if> </body> </html>
判断结果：小新
注意：condition属性中支持eq等判断表达式，因为会致使模版解析混淆，因此不支持“>”、“<”等表达式。
1.condition条件里可使用PHP函数:Weibo/Home/View/default/User/index.html
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> <if condition="mb_substr($user,0,3,'UTF-8') eq '蜡笔小'">小新</if> </body> </html>
判断结果：小新
2.condition条件里使用点语法，智能判断数组或对象:Weibo/Home/View/default/User/index.html
<body> <if condition="$data.user eq '蜡笔小新'">小新</if> </body>
3.condition条条件里使用冒号语法，直接使用对象:Weibo/Home/View/default/User/index.html
<body> <if condition="$data:user eq '蜡笔小新'">小新</if> </body>
4.condition条件里使用系统变量:Weibo/Home/View/default/User/index.html
<body> <if condition="$Think.get.user eq '蜡笔小新'">小新</if> </body>
经过GET获取访问：http://localhost/ThinkPHP/Home/User/?user=蜡笔小新
判断结果：小新
注意：因为if标签的condition属性里面基本上使用的是php语法，尽量使用判断标签和Switch标签会更加简洁，原则上来讲，可以用switch和比较标签解决的尽可能不用if标签完成。由于switch和比较标签可使用变量调节器和系统变量。若是某些特殊的要求下面，IF标签仍然没法知足要求的话，可使用原生php代码或者PHP标签来直接书写代码。
ThinkPHP内置了Switch标签用于多条件判断
name的值和IF语句同样，能够是变量、数组、对象、函数或系统变量
<body> <switch name="$user"> <case value="蜡笔小新">小新</case> <case value="黑崎一护">一护</case> <default />错误 </switch> </body>
默认状况下，case会自动添加break语句防止穿透，若是你就是想要穿透，那么能够去除break。固然，绝大部分不须要设置break。
//去除break
<case value="蜡笔小新" break="0">小新</case>
ThinkPHP提供了一组比较标签用于简单的变量比较，复杂的判断条件能够用IF标签替换。
(1)eq或equal标签：等于
<body> <eq name="user" value="蜡笔小新">小新</eq> </body>
(2)neq或notequal标签：不等于
(3)gt标签：大于
(4)egt标签：大于等于
(5)lt标签：小于
(6)elt标签：小于等于
(7)heq标签：恒等于
(8)nheq标签：不恒等于
注意：name的值和IF语句同样，能够是变量、数组、对象、函数或系统变量，其余比较标签使用方法相似，这里不在赘述。比较标签还提供了一个统一标签compare，比较类型经过type属性完成。
(9)compare统一方法
<body> <compare name="user" value="蜡笔小新" type="eq">小新</compare> </body>
ThinkPHP提供了一组范围判断标签：in、notin、between、notbetween四个标签，都用于判断变量是否在某个范围中。
User控制器UserController.class.php设置id=1
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { //引入指定基页 public function index() { $this->assign('id',1); //渲染模版输出 $this->display(); } } 1.in标签：
Weibo/Home/View/default/User/index.html判断若是id是1，2，3
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> <in name="id" value="1,2,3">id在范围内</in> </body> </html>
返回：id在范围内
in标签，支持else写法
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> <in name="id" value="1,2,3"> id在范围内 <else/> id不在范围内 </in> </body> </html>
返回：id在范围内
2.notin标签，正好相反：判断若是id是否是1
Weibo/Home/View/default/User/index.html判断
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> <notin name="id" value="4,5,6">id不在范围内</notin> </body> </html>
返回：id不在范围内
3.between标签，从哪里到哪里的范围：判断若是id是1-10之间
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> <between name="id" value="1,10">id在范围内</between> </body> </html>
返回：id在范围内
4.notbetween标签，从哪里到哪里的范围：判断若是id是2-20之间
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> <notbetween name="id" value="2,20">id不在范围内</notbetween> </body> </html>
返回：id不在范围内
5.range标签，能够统一in、notin、between和notbetween：经过type=选择
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> <range name="id" value="1,2,3" type="in">id在范围内</range> </body> </html>
返回：id在范围内
6.name值能够是系统变量
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> <in name="Think.get.id" value="1,2,3">id在范围内</in> </body> </html>
经过get.id方式访问：http://localhost/ThinkPHP/Home/User/?id=1
返回：id在范围内
7.value值能够是变量或系统变量
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> <in name="id" value="$Think.get.arr">id在范围内</in> </body> </html>
能够经过数组方式传值访问：http://localhost/ThinkPHP/Home/User/?arr=1,2,3
返回：id在范围内
ThinkPHP模版提供了一组用于判断变量的标签。
1.判断变量user已存在
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> <present name="user">user已存在</present> </body> </html>
返回：user已存在
2.判断变量是否已赋值，没有建立或赋值为null，都算没有值
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> <notpresent name="user">user尚未值</notpresent> </body> </html>
3.判断变量是否已赋值，组合
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> <present name="user"> user已存在 <else /> user未存在 </present> </body> </html>
返回：user已存在
4.判断变量是否已赋值，系统变量
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> <present name="Think.get.user">$_GET['user']已赋值</present> </body> </html>
经过系统变量赋值传：http://localhost/ThinkPHP/Home/User/?user=蜡笔小新
返回：$_GET['user']已赋值
5.判断变量是否为空，空则输出
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> <empty name="user">user为空值</empty> </body> </html>
6.判断变量是否为空，不空则输出
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> <notempty name="user">user不为空值</notempty> </body> </html>
返回：user不为空值
7.判断变量是否为空，组合
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> <empty name="user"> user为空值 <else /> user不为空值 </empty> </body> </html>
返回：user不为空值
8.判断变量是否为空，系统变量
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> <empty name="Think.get.user">$_GET['user']为空值</empty> </body> </html>
经过系统变量赋值传：http://localhost/ThinkPHP/Home/User/?user=蜡笔小新
返回：$_GET['user']为空值
9.判断常量是否认义，定义了输出
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> <defined name="APP_PATH">APP_PATH常量已定义</defined> </body> </html>
返回：APP_PATH常量已定义
10.判断常量是否认义，没定义输出
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> <notdefined name="APP_PATH">APP_PATH常量未定义</notdefined> </body> </html>
11.判断常量是否认义，组合
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> <defined name="APP_PATH"> APP_PATH常量已定义 <else /> APP_PATH常量未定义 </defined> </body> </html>
返回：APP_PATH常量已定义
二．遍历循环
ThinkPHP内置标签提供了Volist标签、Foreach标签和For标签。
User控制器UserController.class.php设置显示全部数据
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { //引入指定基页 public function index() { //给模版传一个数据库数据 $user = M('User'); $this->assign('data', $user->select()); $this->display(); } }
1.Volist标签：一般用于查询数据集的结果输出，经过select()方法返回的是一个二维数组，能够直接使用volist标签进行输出
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> <ul> <volist name="data" id="arr"> <!--name是获取到控制器传过来的数组变量data，拿到后交给变量arr--> <li>{$arr.id} -- {$arr.user} -- {$arr.mail}</li> <!--显示id，user,mail--> </volist> </ul> </body> </html>
注意：这里的name="data"中的data是控制器给模版定义的数据变量，要对应；这里的id="arr"中的arr是将要遍历循环的数组名，能够自定义。
offset从第几条开始，起始值0，length共多少条
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> <ul> <volist name="data" id="arr" offset="5" length="10"> <!--从6条开始显示10条--> <li>{$arr.id} -- {$arr.user} -- {$arr.mail}</li> </volist> </ul> </body> </html>
经过key输出排序
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> <volist name="data" id="arr" key="k"> <li>{$k} -- {$arr.id} -- {$arr.user} -- {$arr.mail}</li> </volist> </body> </html>
mod求当前余数，当前index除以2余1，输出偶数
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> <volist name="data" id="arr" key="k" mod="2"> <!--mod=2每次除以2--> <eq name="mod" value="1"> <!--余数1的时候--> <li>{$k}.{$arr.id} -- {$arr.user} -- {$arr.mail}</li> </eq> </volist> </body> </html>
没有指定k，也能够用i变量输出
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> <volist name="data" id="vo" empty="没有任何数据"> <li>{$i} -- {$vo.id} -- {$vo.user} -- {$vo.mail}</li> </volist> </body> </html>
key变量，能够直接输出索引值，从0开始
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> <volist name="data" id="vo" empty="没有任何数据"> <li>{$key} -- {$vo.id} -- {$vo.user} -- {$vo.mail}</li> </volist> </body> </html>
没有数据的状况下使用empty填充
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> <volist name="data" id="vo" empty="没有任何数据"> <li>{$vo.id} -- {$vo.user} -- {$vo.mail}</li> </volist> </body> </html>
输出：没有任何数据
方式二：empty="设置变量"
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { //引入指定基页 public function index() { $this->assign('empty','<strong style="color:red">没有数据</strong>'); $this->display(); } }
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> <volist name="data" id="vo" empty="$empty"> <li>{$vo.id} -- {$vo.user} -- {$vo.mail}</li> </volist> </body> </html>
输出加红加粗：没有任何数据
2.Foreach标签和Volist标签相似，只不过Foreach标签更加简单，没有额外属性。
只支持key属性，但{$key}变量支持
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> <ul> <foreach name="data" item="vo"> <ul>{$vo.id} -- {$vo.user}</ul> </foreach> </ul> </body> </html>
3.For标签就是简单的循环标签。
从1到99循环
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> <for start="1" end="100"> {$i}<br /> </for> </body> </html>
除了start和end必须值，还有三个可选值。comparison是大于仍是小于，默认值为lt（<）；name是循环变量名，默认值为i；step是步进值，默认为1。
完整形式
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> <for start="1" end="100" comparison="lt" step="2" name="k"> {$i}<br /> </for> </body> </html>
三．其余标签
ThinkPHP模版中还有一些其余标签。
在模版中定义变量，value值能够为变量（$user）或系统变量（$Think.get.user）
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> <assign name="var" value="123" /> {$var} </body> </html>
输出：123
在模版中定义常量，value值能够为变量（$user）或系统变量（$Think.get.user）
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> <define name="MY_NAME" value="xixi" /> {$Think.const.MY_NAME} </body> </html>
输出：xixi
import导入标签能够智能的导入js和css文件
ThinkPHP\Public\css\index.css作一个背景为灰色
body { background:#ccc; }
ThinkPHP\Public\css\index.js作一个弹出框
alert('js');
1.常规引入方法
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> <script type="text/javascript" src="__PUBLIC__/js/index.js"></script> <link rel="stylesheet" type="text/css" href="__PUBLIC__/css/index.css" /> </head> <body> </body> </html>
2.使用import导入，js和css是目录
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> <import type="js" file="js.index" /> <import type="css" file="css.index" /> </head> <body> </body> </html>
3.使用import导入，basepath修改默认路径为./Common
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> <import type="js" file="js.index" basepath="./Common" /> </head> <body> </body> </html>
4.load加载标签能够智能的加载js和css文件
使用load加载
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> <load href="__PUBLIC__/js/index.js" /> <load href="__PUBLIC__/css/index.css" /> </head> <body> </body> </html>
系统还提供了专用js和css标签，专门用于加载(推荐使用)
使用专用标签
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> <js href="__PUBLIC__/js/index.js" /> <css href="__PUBLIC__/css/index.css" /> </head> <body> </body> </html>
PHP代码能够和标签在模版文件中混合使用，能够在模版文件里面书写任意的PHP语句代码。
(1)使用php标签作加法(推荐用)
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> <php> $a = 1; $b = 2; echo $a + $b; </php> </body> </html>
(2)用php语法作加法(不推荐用危险)
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> <?php $a = 1; $b = 2; echo $a + $b; ?> </body> </html>
若是想原样输出标签极其内容，可使用literal标签
原样输出：
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> <literal> <php>echo 123;</php> </literal> </body> </html>
注意：什么都没有定义的状况下，会自动报错，错误信息提示以下
模板不存在:./Weibo/Home/View/User/index.html
ThinkPHP--视图--标签库
ThinkPHP模版中的标签库，咱们使用的不少内置标签就是经过标签库声明而来的，固然还能够自定义扩展标签。
一．内置标签
模版中的这些内置标签是从哪里构建出来的呢？它们是在Think/Library/Think/Template/TagLib下。在完整版中提供了两个类文件：Cx.class.php（内置标签核心类）、Html.class.php（html扩展标签）。
观察Cx.class.php源码，咱们发现其实就是内置标签的核心类。好比：
/** * volist标签解析 循环输出数据集 * 格式： * <volist name="userList" id="user" empty="" > * {user.username} * {user.email} * </volist> * @access public * @param array $tag 标签属性 * @param string $content 标签内容 * @return string|void */ public function _volist($tag,$content) { //核心代码省略 }
在ThinkPHP中，Cx.class.php是自动加载的，因此并不须要各类配置或引入而能够直接编写标签代码便可运行。但若是是Html.class.php这种扩展性标签库，则须要经过其余方式才能够运行：
/** * select标签解析 * 格式： <html:select options="name" selected="value" /> * @access public * @param array $tag 标签属性 * @return string|void */ public function _select($tag) { //核心代码省略 }
若是要使用Html.class.php的扩展标签，那么首先要导入这个标签
在使用标签的时候，前面须要加上html:，表示这个是html标签库
<taglib name="html" /> <!--导入扩展标签--> <!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> <html:imageBtn value="按钮"/> <!--在使用标签的时候，前面须要加上html:，表示这个是html标签库--> </body> </html>
源代码：<div class="" ><input type="button" id="" name="" value="按钮" onclick="" class="button"></div>
注意：Cx.class.php由于是内置标签，因此不须要加Cx:，但Html.class.php则须要加上html:，不然会没法解析标签。
方式一：能够将Cx和Html都设置为内置标签写在配置文件config.php里
<?php return array( //将Cx和Html都设置为内置标签 'TAGLIB_BUILD_IN' =>'cx,html', );
设置成内置标签后则不须要html:了也不须要导入扩展标签
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> <imageBtn value="按钮"/> </body> </html>
注意：设置内置标签有必定的危险性，由于可能会出现标签的重复致使冲突。
若是没有设置为内置标签的话，那么都须要经过tablib进行导入，咱们能够设置标签预加载。这样，就不须要每次都进行导入操做了。
方式二：将Html标签预加载写在配置文件config.php里
<?php return array( //标签预加载 'TAGLIB_PRE_LOAD'=>'html', );
设置标签预加载不须要导入扩展标签
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> <html:imageBtn value="按钮"/> </body> </html>
二．自定义扩展标签库
有时感受内置的标签不能知足项目日益繁杂的项目需求，这是可能想本身扩展一些标签来使用，那么本身怎么扩展标签呢？
第一步：在Think/Library/Think/Template/TagLib下建立一个Test.class.php
<?php namespace Think\Template\TagLib; use Think\Template\TagLib; defined('THINK_PATH') or exit(); /** * Test测试标签库驱动 */ class Test extends TagLib{ //标签库定义Test protected $tags = array( //属性定义 //mytest双标签调用<test:mytest></test:mytest> 'mytest'=>array('attr'=>'color,border','close'=>1) //标签订义： attr属性列表定义俩个属性color颜色,border边框,close是否闭合（0或者1,默认1） ); public function _mytest($tag,$content){ //mytest方法传俩个参数 //print_r($tag); //获得的是俩个属性和他的值：Array ( [color] => red [border] => 5 ) //print_r($content); //获得的是双标签里面的内容 $color = ''; $border = ''; if (isset($tag['color'])) { //若是$tag['color']存在 $color = 'color:'.$tag['color']; //颜色根据传的值变化 } if (isset($tag['border'])) { //若是$tag['border']存在 $border = 'border:'.$tag['border'].'px solid #ccc'; //边框根据传的值变化 } $css = $color.';'.$border; //声明一个变量$css return '<div style="'.$css.'">'.$content.'</div>'; //把获得的俩个属性的值返回 } }
导入test自定义扩展标签使用自定义扩展标签俩个属性color和border
<taglib name="test" /> <!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> <test:mytest color="red" border="5">测试标签</test:mytest> <!--根据标签订义的俩个属性传值--> </body> </html>
源代码：<div style="color:red;border:5px solid #ccc">测试标签</div>
ThinkPHP/Weibo/Home/
ThinkPHP--视图--路由功能
ThinkPHP的路由功能。就是配置URL，让URL更加的简洁和优雅。路由模式只对PATHINFO模式和兼容模式起做用。
一．路由定义
在使用路由功能以前，咱们须要启用路由。启用路由前提是你的URL支持PATHINFO模式或者兼容模式，而ThinkPHP默认的就是PATHINF模式。只要配置以下启用：
建立：ThinkPHP\Weibo\Home\View\default\User\index.html
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> 这是User控制器下的index方法：{$Think.get.id} {$Think.get.type} {$Think.get.attr} {$Think.get.list} </body> </html>
当前访问URL：http://localhost/ThinkPHP/Home/User/index/id/5
输出：这是User控制器下的index方法：5
经过设置默认模块去除Home
<?php return array( //'配置项'=>'配置值' //设置模块以及默认模块 'MODULE_ALLOW_LIST' => array('Home','Admin'), 'DEFAULT_MODULE' => 'Home', // 默认模块，能够省去模块名输入 );
去除默认模块Home访问URL：http://localhost/ThinkPHP/User/index/id/5
输出：这是User控制器下的index方法：5
路由规则定义的格式为：'路由表达式'=>'路由地址和参数'，路由表达式包括规则路由和正则路由两种
二．规则路由
规则路由是ThinkPHP设计的一种简单实用的路由规则
经过规则路由的静态地址路由能够把u替换成User/index
<?php return array( //'配置项'=>'配置值' //设置模块以及默认模块 'MODULE_ALLOW_LIST' => array('Home','Admin'), 'DEFAULT_MODULE' => 'Home', //默认模块，能够省去模块名输入 //启用路由功能 'URL_ROUTER_ON'=>true, //配置路由规则 'URL_ROUTE_RULES'=>array( //每条键值对，对应一个路由规则 'u'=>'User/index', //把u替换成User/index ), );
访问URL：http://localhost/ThinkPHP/u/id/5
输出：这是User控制器下的index方法：5
经过静态地址和动态地址结合路由去掉id
<?php return array( //'配置项'=>'配置值' //设置模块以及默认模块 'MODULE_ALLOW_LIST' => array('Home','Admin'), 'DEFAULT_MODULE' => 'Home', // 默认模块，能够省去模块名输入 //启用路由功能 'URL_ROUTER_ON'=>true, //配置路由规则 'URL_ROUTE_RULES'=>array( //静态地址和动态地址结合路由 'u/:id'=>'User/index', ), );
访问URL：http://localhost/ThinkPHP/u/5
输出：这是User控制器下的index方法：5
经过静态地址和动态地址结合路由传多个动态地址type/:attr/:list
<?php return array( //'配置项'=>'配置值' //设置模块以及默认模块 'MODULE_ALLOW_LIST' => array('Home','Admin'), 'DEFAULT_MODULE' => 'Home', // 默认模块，能够省去模块名输入 //启用路由功能 'URL_ROUTER_ON'=>true, //配置路由规则 'URL_ROUTE_RULES'=>array( //静态地址和动态地址结合路由 'u/:type/:attr/:list'=>'User/index', ), );
访问URL：http://localhost/ThinkPHP/u/5/6/7
这是User控制器下的index方法： 5 6 7
经过数字约束传过来的id只能是数字(不传数字参数会报错)
<?php return array( //'配置项'=>'配置值' //设置模块以及默认模块 'MODULE_ALLOW_LIST' => array('Home','Admin'), 'DEFAULT_MODULE' => 'Home', // 默认模块，能够省去模块名输入 //启用路由功能 'URL_ROUTER_ON'=>true, //配置路由规则 'URL_ROUTE_RULES'=>array( //数字约束 'u/:id\d'=>'User/index', ), );
经过给传过来的动态ID加md5
<?php return array( //'配置项'=>'配置值' //设置模块以及默认模块 'MODULE_ALLOW_LIST' => array('Home','Admin'), 'DEFAULT_MODULE' => 'Home', // 默认模块，能够省去模块名输入 //启用路由功能 'URL_ROUTER_ON'=>true, //配置路由规则 'URL_ROUTE_RULES'=>array( //支持函数 'u/:id\d|md5'=>'User/index', ), );
访问URL：http://localhost/ThinkPHP/u/1
这是User控制器下的index方法：c4ca4238a0b923820dcc509a6f75849b
经过设置可选参数不加动态ID不会报错(这是User控制器下的index方法： )
<?php return array( //'配置项'=>'配置值' //设置模块以及默认模块 'MODULE_ALLOW_LIST' => array('Home','Admin'), 'DEFAULT_MODULE' => 'Home', // 默认模块，能够省去模块名输入 //启用路由功能 'URL_ROUTER_ON'=>true, //配置路由规则 'URL_ROUTE_RULES'=>array( //可选传参 'u/[:id\d]'=>'User/index', ), );
访问URL:http://localhost/ThinkPHP/u/
这是User控制器下的index方法：
经过设置动态ID后不能够加东西
<?php return array( //'配置项'=>'配置值' //设置模块以及默认模块 'MODULE_ALLOW_LIST' => array('Home','Admin'), 'DEFAULT_MODULE' => 'Home', // 默认模块，能够省去模块名输入 //启用路由功能 'URL_ROUTER_ON'=>true, //配置路由规则 'URL_ROUTE_RULES'=>array( //$表示后面不容许再有东西 'u/:id$'=>'User/index', ), );
访问URL：http://localhost/ThinkPHP/u/5/abc会报错
访问URL：http://localhost/ThinkPHP/u/5返回
这是User控制器下的index方法：5
三．正则路由
正则路由也就是采用正则表达式定义路由的一种方式，不少复杂的路由设置没法经过规则路由设置，则可使用正则路由
经过正则设置动态id必须是俩位
<?php return array( //'配置项'=>'配置值' //设置模块以及默认模块 'MODULE_ALLOW_LIST' => array('Home','Admin'), 'DEFAULT_MODULE' => 'Home', // 默认模块，能够省去模块名输入 //启用路由功能 'URL_ROUTER_ON'=>true, //配置路由规则 'URL_ROUTE_RULES'=>array( //正则路由 '/^u\/(\d{2})$/'=>'User/index?id=:1', //把u匹配到静态地址index,限制ID是俩位,:1表示对应第一个正则圆括号 ), );
访问URL：http://localhost/ThinkPHP/u/11返回
这是User控制器下的index方法：11
正则路由给获取到的动态id加密md5
<?php return array( //'配置项'=>'配置值' //设置模块以及默认模块 'MODULE_ALLOW_LIST' => array('Home','Admin'), 'DEFAULT_MODULE' => 'Home', // 默认模块，能够省去模块名输入 //启用路由功能 'URL_ROUTER_ON'=>true, //配置路由规则 'URL_ROUTE_RULES'=>array( //正则路由也支持函数 '/^u\/(\d{2})$/'=>'User/index?id=:1|md5', ), );
访问URL：http://localhost/ThinkPHP/u/11返回
这是User控制器下的index方法：6512bd43d9caa6e02c990b0a82652dca
四．静态路由
静态路由其实就是规则路由的简化版（又称URL映射），它就是撇除了动态路由的功能。
经过配置静态路由只支持静态
<?php return array( //'配置项'=>'配置值' //设置模块以及默认模块 'MODULE_ALLOW_LIST' => array('Home','Admin'), 'DEFAULT_MODULE' => 'Home', // 默认模块，能够省去模块名输入 //启用路由功能 'URL_ROUTER_ON'=>true, //配置静态路由 'URL_MAP_RULES'=>array( 'u/i'=>'User/index', ), );
访问UIR：http://localhost/ThinkPHP/u/i/返回
这是User控制器下的index方法：
注意：因为性能问题，ThinkPHP把MAP替换为ROUTER，专门处理静态路由。
五．闭包支持(用于调试)
有时，咱们并不是须要执行控制器的操做方法。能够用闭包定义一些特殊的需求的路由。
<?php return array( //'配置项'=>'配置值' //设置模块以及默认模块 'MODULE_ALLOW_LIST' => array('Home','Admin'), 'DEFAULT_MODULE' => 'Home', // 默认模块，能够省去模块名输入 //启用路由功能 'URL_ROUTER_ON'=>true, //配置路由规则和正则规则 'URL_ROUTE_RULES'=>array( //规则路由 'u/:id'=>function ($id) { //对应的只是一个function echo 'id:'.$id; //打印获得的id }, //正则路由 '/^u\/(\d{2})$/'=>function ($id) { echo 'id:'.$id; }, ), );
访问UIR：http://localhost/ThinkPHP/u/5返回
id:5
ThinkPHP--视图--URL操做：
ThinkPHP的URL操做。主要涉及到URL路径大小写、伪静态、生成以及模版中的U()方法。
一．URL大小写
系统默认的规范是根据URL里面的模块名、控制器名来定位到具体的控制器类。
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> 这是User控制器下的index方法：{$Think.get.id} {$Think.get.type} {$Think.get.attr} {$Think.get.list} </body> </html>
访问UIR：http://localhost/ThinkPHP/Home/User/index/id/5返回
这是User控制器下的index方法：5
在windows平台，URL中的大小写会自动忽略，但做为开发人员，保持大小写区分是一个良好的习惯。而Linux平台，若是大小写错误，会致使没法定位到指定的模块、控制器。
经过设置URL能够不区分大小写
<?php return array( //'配置项'=>'配置值' //启用路由功能 'URL_ROUTER_ON'=>true, //配置路由规则 'URL_ROUTE_RULES'=>array( //URL能够不区分大小写 'URL_CASE_INSENSITIVE' =>true ), );
访问UIR：http://localhost/ThinkPHP/home/User/index/id/5返回
这是User控制器下的index方法：5
注意：若是开启了不区分大小写，那么对于UserTypeController.class.php这样的控制器就须要以下访问方式：
http://localhost/ThinkPHP/home/user_type/index/
若是区分大小写，则是这样：
http://localhost/ThinkPHP/Home/UserType/index/
二．URL伪静态
URL伪静态同城是为了知足更好的SEO效果，ThinkPHP支持伪静态设置。
http://localhost/ThinkPHP/home/User/index.html
默认后缀为html，设置伪静态后缀shtml
<?php return array( //'配置项'=>'配置值' //设置模块以及默认模块 'MODULE_ALLOW_LIST' => array('Home','Admin'), 'DEFAULT_MODULE' => 'Home', //默认模块，能够省去模块名输入 //启用路由功能 'URL_ROUTER_ON'=>true, //设置伪静态后缀，默认为html 'URL_HTML_SUFFIX'=>'shtml', );
访问UIR：http://localhost/ThinkPHP/home/User/index.shtml返回
这是User控制器下的index方法：
默认后缀为html，设置后缀为任意：
<?php return array( //'配置项'=>'配置值' //设置模块以及默认模块 'MODULE_ALLOW_LIST' => array('Home','Admin'), 'DEFAULT_MODULE' => 'Home', //默认模块，能够省去模块名输入 //启用路由功能 'URL_ROUTER_ON'=>true, //配置路由规则 //若是设置为空，那么就职意后缀 'URL_HTML_SUFFIX'=>'', );
访问URL：http://localhost/ThinkPHP/home/User/index.ddd
这是User控制器下的index方法：
若是设置为空，能够用__EXT__常量获取当前使用的后缀
<body> 目前的伪静态的后缀为：{$Think.const.__EXT__} </body>
访问URL:http://localhost/ThinkPHP/home/User/index.ddd
目前的伪静态的后缀为：ddd
设置能够伪静态的后缀只能是html|shtml|xml
<?php return array( //'配置项'=>'配置值' //设置模块以及默认模块 'MODULE_ALLOW_LIST' => array('Home','Admin'), 'DEFAULT_MODULE' => 'Home', // 默认模块，能够省去模块名输入 //启用路由功能 'URL_ROUTER_ON'=>true, //配置路由规则 //设置能够伪静态的后缀 'URL_HTML_SUFFIX'=>'html|shtml|xml', );
访问URL：http://localhost/ThinkPHP/home/User/index.xml访问
这是User控制器下的index方法：
禁止访问后缀为html|pdf|ico|png|gif|jpg(自己能够访问又禁止掉了访问就是空页面)
<?php return array( //'配置项'=>'配置值' //设置模块以及默认模块 'MODULE_ALLOW_LIST' => array('Home','Admin'), 'DEFAULT_MODULE' => 'Home', // 默认模块，能够省去模块名输入 //启用路由功能 'URL_ROUTER_ON'=>true, //配置路由规则 //禁止访问的后缀 'URL_DENY_SUFFIX' => 'html|pdf|ico|png|gif|jpg', );
三．URL生成
为了配合所使用的URL模式，咱们须要可以动态的根据当前的URL设置生成对应的URL地址。为此，ThinkPHP内置了一个U()方法，用于URL的动态生成。
定义格式：U('地址表达式',['参数'],['伪静态后缀'],['显示域名'])
获得当前URL配置：ThinkPHP\Weibo\Home\Controller\UserController.class.php
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { //引入指定基页 public function index() { //默认获得当前URL echo U(); } }
获得地址：/ThinkPHP/index.php/Home/User/index.html
地址表达式的格式以下：
[模块/控制器/操做#锚点@域名]?参数1=值1&参数2=值2...
控制器+方法生成和当前URL无关的配置
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { //引入指定基页 public function index() { //控制器+方法 echo U('Member/add'); } }
获得地址：/ThinkPHP/index.php/Home/Member/add.html
控制器+方法+?参数1个值
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { //引入指定基页 public function index() { //控制器+方法+?参数1=值1 echo U('Member/add?id=5'); } }
获得地址：/ThinkPHP/index.php/Home/Member/add/id/5.html
模块+控制器+方法+?参数1=值1
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { //引入指定基页 public function index() { //模块+控制器+方法+?参数1=值1 echo U('Admin/Member/add?id=5'); } }
获得地址：/ThinkPHP/index.php/Admin/Member/add/id/5.html
U()方法第二个参数能够分离参数和值的操做，支持字符串和数组的写法。
使用数组参数1=值1,参数2=值2
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { //引入指定基页 public function index() { //使用数组参数1=值1,参数2=值2 echo U('Member/add',array('id'=>5,'type'=>'a')); } }
获得地址：/ThinkPHP/index.php/Home/Member/add/id/5/type/a.html
使用字符串参数1=值1,参数2=值2
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { //引入指定基页 public function index() { //使用字符串参数1=值1,参数2=值2 echo U('Member/add','id=5&type=a'); } }
获得地址：/ThinkPHP/index.php/Home/Member/add/id/5/type/a.html
U()方法第三个参数能够指定伪静态后缀
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { //引入指定基页 public function index() { //指定伪静态后缀 echo U('User/add',array('id'=>5),'xml'); } }
获得地址：/ThinkPHP/index.php/Home/User/add/id/5.xml
四种模式的应用：
(1)普通模式后URL生成将以下
<?php return array( //'配置项'=>'配置值' //页面Trace 'SHOW_PAGE_TRACE' =>true, //设置默认主题 'DEFAULT_THEME' => 'default', //启用路由功能 'URL_ROUTER_ON'=>true, //配置路由规则 'URL_MODEL'=>0 );
获得地址：/ThinkPHP/index.php?m=Home&c=User&a=add&id=5
(2)PATHINFO模式后URL生成将以下：
<?php return array( //'配置项'=>'配置值' //页面Trace 'SHOW_PAGE_TRACE' =>true, //设置默认主题 'DEFAULT_THEME' => 'default', //启用路由功能 'URL_ROUTER_ON'=>true, //配置路由规则 'URL_MODEL'=>1 );
获得地址：/ThinkPHP/index.php/Home/User/add/id/5.xml
(3)REWRITE模式后URL生成(它是PATHINFO的升级版，地址最短)将以下：
<?php return array( //'配置项'=>'配置值' //页面Trace 'SHOW_PAGE_TRACE' =>true, //设置默认主题 'DEFAULT_THEME' => 'default', //启用路由功能 'URL_ROUTER_ON'=>true, //配置路由规则 'URL_MODEL'=>2 );
获得地址：/ThinkPHP/Home/User/add/id/5.xml
(4)兼容模式后URL生成将以下：
<?php return array( //'配置项'=>'配置值' //页面Trace 'SHOW_PAGE_TRACE' =>true, //设置默认主题 'DEFAULT_THEME' => 'default', //启用路由功能 'URL_ROUTER_ON'=>true, //配置路由规则 'URL_MODEL'=>3 );
获得地址：/ThinkPHP/index.php?s=/Home/User/add/id/5.xml
也能够生成路由地址，使用路由的规则生成的地址：
配置文件设置：
<?php return array( //'配置项'=>'配置值' //设置默认主题 'DEFAULT_THEME' => 'default', //启用路由功能 'URL_ROUTER_ON'=>true, //规则路由 'u/:id\d'=>'Member/add', );
ThinkPHP\Weibo\Home\Controller\UserController.class.php设置
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { //引入指定基页 public function index() { //指定伪静态后缀 //echo U('User/add',array('id'=>5),'xml'); //生成规则路由地址 echo U('/u/5'); } }
生成URL：/ThinkPHP/index.php/u/5.html
生成正则路由地址
配置文件设置：
<?php return array( //'配置项'=>'配置值' //设置默认主题 'DEFAULT_THEME' => 'default', //启用路由功能 'URL_ROUTER_ON'=>true, //生成正则路由地址 '/^u_(\d+)$/'=>'User/index?id=:1', );
ThinkPHP\Weibo\Home\Controller\UserController.class.php设置
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { //引入指定基页 public function index() { //指定伪静态后缀 //echo U('User/add',array('id'=>5),'xml'); //生成规则路由地址 echo U('/u_5'); } }
生成URL：/ThinkPHP/index.php/u_5.html
域名支持
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { //引入指定基页 public function index() { //域名支持 echo U('User/add@www.xixi.com?id=5'); } }
生成URL：http://www.xixi.com/ThinkPHP/index.php/Home/User/add/id/5.html
锚点支持
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { //引入指定基页 public function index() { //锚点支持 echo U('User/add#comment?id=5'); } }
生成URL：/ThinkPHP/index.php/Home/User/add/id/5.html#comment
四．模版中的U
咱们以前使用U()方法，都是在控制器里实现的。但实际用途中，大量的超连接是在模版中设置的，而在控制器把U()当变量传递过去，有点过于繁杂。因此，咱们能够在模版使用使用U()方法。
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> {:U('Member/add', array('id'=>5))} </body> </html>
生成URL:/ThinkPHP/index.php/Home/Member/add/id/5.html
ThinkPHP--视图--控制器
一．控制器操做
咱们首先复习一下基本的控制器定义和方法执行方式。
第一步：控制器默认建立在当前模块下的Controller目录下；
第二步：按照指定的命名规则：控制器名(首字母大写)+Controller.class.php；
第三步：控制器里的方法必须是public公共的；
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { //引入指定基页 public function index() { //index()方法在URL访问时能够忽略 } }
URL访问：http://localhost/ThinkPHP/Home/User/
有时方法名可能和关键字冲突，那么定义起来就比较麻烦，控制器提供了一个配置定义：
配置文件配置：
<?php return array( //'配置项'=>'配置值' //配置控制器方法后缀 'ACTION_SUFFIX'=>'Action', );
每一个方法后面加上Action，对于URL访问不须要加Action
<?php namespace Home\Controller; use Think\Controller; class UserController extends Controller { //引入指定基页 public function indexAction() { //配置文件定义后 每一个方法名字后面要加上Action //index()方法在URL访问时能够忽略 } public function classAction() { echo 'class'; } }
默认状况下经过URL访问的页面是控制器模块下的方法，即：Controller目录下的UserController.class.php类。它是对外公开可访问的，咱们能够称为访问控制器。那么不少时候，因为项目业务的高度繁杂，咱们可能想法不少业务分离到另外的层，好比事件控制器层。那么能够这么操做：
第一步：建立事件控制器目录：ThinkPHP\Weibo\Home\Event\
第二步：建立UserEvent.class.php类；
<?php namespace Home\Event; //是否继承控制器基类或者其余基类，取决于你的业务 class UserEvent { public function test() { echo '当触发测试事件，执行这个方法，这方法内部调用。'; } }
访问控制器内部调用事件控制器方法方法一：
<?php namespace Home\Controller; use Think\Controller; use Home\Event\UserEvent; //访问控制器内部调用事件控制器方法 class UserController extends Controller { public function test() { $userEvent = new UserEvent(); $userEvent->test(); echo 'test'; } }
URL访问：http://localhost/ThinkPHP/Home/User/test/当执行test方法自动调用了UserEvent.class.php里的test方法
当触发测试事件，执行这个方法，这方法内部调用。test
这里调用别的控制器还可使用快捷调用方法A()。
<?php namespace Home\Controller; use Think\Controller; use Home\Event\UserEvent; //访问控制器内部调用事件控制器方法 class UserController extends Controller { public function test() { $userEvent = A('User', 'Event'); //User表示控制器名,Event事件层次的控制器 $userEvent->test(); echo 'test'; } }
URL访问：http://localhost/ThinkPHP/Home/User/test/当执行test方法自动调用了UserEvent.class.php里的test方法
当触发测试事件，执行这个方法，这方法内部调用。test
默认状况下，控制器只支持一级控制器。当项目较为繁杂的时候，想建立统一模块下多个控制器时，能够配置二级控制器。
第一步：配置文件添加容许二级控制器；
<?php return array( //'配置项'=>'配置值' //容许二级控制器 'CONTROLLER_LEVEL'=>2, );
第二步：在Controller目录下建立Member目录，在Member目录下建立一个控制器；CommentController.php
<?php //二级控制器写法 namespace Home\Controller\Member; use Think\Controller; class CommentController extends Controller { public function test() { echo '多级控制器'; } }
只能访问二极控制器：http://localhost/ThinkPHP/Member/Comment/test返回：
多级控制器
ThinkPHP控制器还提供了两个特殊的方法，前置操做方法_before_index()和后置操做方法_after_index()。这两个方法，在控制器index()方法的时候，一个在以前执行，一个在以后执行。
<?php namespace Home\Controller; use Think\Controller; use Home\Event\UserEvent; //访问控制器内部调用事件控制器方法 class UserController extends Controller { public function index() { echo 'index'; } //前置执行 public function _before_index() { echo '前置操做方法'; } //后置执行 public function _after_index() { echo '后置操做方法'; } }
访问URL:http://localhost/ThinkPHP/Home/User/index返回
前置操做方法index后置操做方法
二．Action参数绑定
参数绑定是经过直接绑定URL地址中的变量做为操做方法的参数，能够简化方法的定义甚至路由的解析。
<?php return array( //'配置项'=>'配置值' //启用Action参数绑定，默认为true，能够不写 'URL_PARAMS_BIND'=>true, );
注意：当你URL没有传递参数(id/5)的时候，那么页面会报错：参数错误或者未定义：id。固然，若是取消绑定，则不会报错'URL_PARAMS_BIND'=>false,。可是，为了程序的严谨性，通常须要不要取消参数绑定
若是你个那个参数设定一个默认值，当没有传递参数的时候，会直接启用默认值：
<?php namespace Home\Controller; use Think\Controller; use Home\Event\UserEvent; //访问控制器内部调用事件控制器方法 class UserController extends Controller { //给变量$id设置默认值 public function index($id=1) { echo 'id:'.$id; } }
访问URL：http://localhost/ThinkPHP/Home/User/index/返回：
id:1
还有一种是按顺序传递参数，这个方法能够省略掉键值对中的键，也就是说id不须要传递，只须要传递5这个值便可。但必须按照多个参数的顺序。
位置文件配置按顺序传参
<?php return array( //'配置项'=>'配置值' //启用Action参数绑定，默认为true，能够不写 'URL_PARAMS_BIND'=>true, //定义按顺序传参绑定 'URL_PARAMS_BIND_TYPE'=>1, );
传递两个参数
<?php namespace Home\Controller; use Think\Controller; use Home\Event\UserEvent; //传递两个参数 class UserController extends Controller { public function index($id, $type) { echo 'id:'.$id.',type:'.$type; } }
5对应id，a对应type访问http://localhost/ThinkPHP/Home/User/index/5/a返回：
id:5,type:a
三．跳转和重定向
ThinkPHP在操做数据库时，须要跳转和重定向页面。ThinkPHP提供了一组方法来解决了这个问题。
成功和失败的跳转
<?php namespace Home\Controller; use Think\Controller; use Home\Event\UserEvent; //传递两个参数 class UserController extends Controller { public function index() { $flag = true; //模拟新增成功 if ($flag) { //会跳转到：http://localhost/ThinkPHP/Home/User/all $this->success('新增成功！', '../User/all'); } else { //会跳转到本页的上一页 $this->error('新增失败！'); } } }
新增成功访问：http://localhost/ThinkPHP/Home/User/index
跳转到：http://localhost/ThinkPHP/Home/User/all
注意：success()方法和error()方法，第一个参数是提示信息、第二个跳转的地址、第三个跳转时间。默认状况下success()方法是1秒，error()方法是3秒。
设置5秒后跳转
<?php namespace Home\Controller; use Think\Controller; use Home\Event\UserEvent; //传递两个参数 class UserController extends Controller { public function index() { $flag = true; //模拟新增成功 if ($flag) { //会跳转到：http://localhost/ThinkPHP/Home/User/all //设置5秒 $this->success('新增成功！', '../User/all', 5); } else { //会跳转到本页的上一页 $this->error('新增失败！'); } } }
success()方法和error()方法，跳转的时候就对应了相应的模版，默认以下：\ThinkPHP\ThinkPHP\Tpl\dispatch_jump.tpl
//默认错误跳转对应的模板文件 'TMPL_ACTION_ERROR' =>THINK_PATH .'Tpl/dispatch_jump.tpl', //默认成功跳转对应的模板文件 'TMPL_ACTION_SUCCESS'=>THINK_PATH.'Tpl/dispatch_jump.tpl',
配置文件能够自行修改跳转模版位置
<?php return array( //'配置项'=>'配置值' //自定义成功和错误提示模版页面 'TMPL_ACTION_SUCCESS'=>'Public/success', 'TMPL_ACTION_ERROR'=>'Public/error', );
对于自定义的提示模版，ThinkPHP提供了一组变量可供使用。
$msgTitle变量：操做标题
$message变量：页面提示信息
$status变量：操做状态1表示成功0表示失败
$waitSecond变量：跳转等待时间，单位为秒
$jumpUrl变量：跳转页面地址
自定义成功模版路径：ThinkPHP\Weibo\Home\View\default\Public\success.html
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>{$msgTitle}</title> </head> <body> {$message} {$status} {$waitSecond} {$jumpUrl} </body> </html>
自定义失败模版路径：ThinkPHP\Weibo\Home\View\default\Public\error.html
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>{$msgTitle}</title> </head> <body> {$message} {$status} {$waitSecond} {$jumpUrl} </body> </html>
注意：若是对于数据库操做，采用了Ajax方式，那么success()和error()会自动ajaxReturn()方法返回数据提供调用。
ThinkPHP还单独提供了重定向方法redirect()，参数和U()方法同样。这个方法使用的是URL规则。
<?php namespace Home\Controller; use Think\Controller; use Home\Event\UserEvent; //传递两个参数 class UserController extends Controller { public function index() { //这里跟大U方法同样直接传递规则 $this->redirect('User/all', array('id'=>5), 5, '页面跳转中...'); //传参数id指向5，5秒，提示信息：页面跳转中 } }
访问：http://localhost/ThinkPHP/index.php/Home/User
5秒钟后跳转到：http://localhost/ThinkPHP/index.php/Home/User/all/id/5.html
若是只是想纯粹的URL跳转，不去使用URL规则，那么直接使用redirect()函数。
<?php namespace Home\Controller; use Think\Controller; use Home\Event\UserEvent; //传递两个参数 class UserController extends Controller { public function index() { //这里跟大U方法同样直接传递规则 redirect('http://www.baidu.com', 5, '页面跳转中...'); //5秒钟后跳转到baidu } }
访问：http://localhost/ThinkPHP/index.php/Home/User
5秒钟后跳转到baidu
四．输入变量
咱们在获取系统变量或者用户提交的数据时，这些变量数据错综复杂，一不当心就容易引擎安全隐患，因此，ThinkPHP提供了轻松和安全获取变量的解决方案。
常规获取变量方式
$id = $_GET['id']; //获取get变量
$name = $_POST['name']; //获取post变量
$value = $_SESSION['var']; //获取session变量
$name = $_COOKIE['name']; //获取cookie变量
$file = $_SERVER['PHP_SELF']; //获取server变量
在ThinkPHP中，咱们再也不建议直接使用传统方式获取，由于没有统一的安全处理机制，后期调整也会比较麻烦。因此，ThinkPHP提供I()方法进行变量的获取和过滤
I()方法的格式：I('变量类型.变量名',['默认值'],['过滤方法'])
1.获取$_GET['id']
<?php namespace Home\Controller; use Think\Controller; use Home\Event\UserEvent; //传递两个参数 class UserController extends Controller { public function index() { //获取$_GET['id']; echo I('get.id'); } }
访问：http://localhost/ThinkPHP//Home/User/index?id=<b style="font-size:550px:">5</b>会自动把id里的过滤
返回：<b style="font-size:550px:">5</b>
当ID没有值能够设定默认
<?php namespace Home\Controller; use Think\Controller; use Home\Event\UserEvent; //传递两个参数 class UserController extends Controller { public function index() { //$_GET['id']没有值，则默认1 echo I('get.id', 1); } }
http://localhost/ThinkPHP//Home/User/index当没有值默认是1
返回：1
2.过滤$_GET['id']
<?php namespace Home\Controller; use Think\Controller; use Home\Event\UserEvent; //传递两个参数 class UserController extends Controller { public function index() { //过滤$_GET['id'] echo I('get.id', '', 'md5'); } }
http://localhost/ThinkPHP//Home/User/index?id=5返回5的md5值
e4da3b7fbbce2345d7772b0674a318d5
3.获取$_GET;
<?php namespace Home\Controller; use Think\Controller; use Home\Event\UserEvent; //传递两个参数 class UserController extends Controller { public function index() { //获取$_GET; print_r(I('get.')); } }
http://localhost/ThinkPHP//Home/User/index?id=5&type=a返回全部值
Array ( [id] => 5 [type] => a )
ThinkPHP还提供了一个自动识别各类系统变量类型的接受方法：param。
param变量自动判断变量类型
<?php namespace Home\Controller; use Think\Controller; use Home\Event\UserEvent; //传递两个参数 class UserController extends Controller { public function index() { //param变量自动判断变量类型 echo I('param.id'); } }
http://localhost/ThinkPHP//Home/User/index/id/5/type/a返回Id值
5
若是是PATHINFO模式的URL，param也能够接收。
param获取URL全部参数
<?php namespace Home\Controller; use Think\Controller; use Home\Event\UserEvent; //传递两个参数 class UserController extends Controller { public function index() { //param获取URL全部参数 print_r(I('param.0')); //已键值对获取 } }
http://localhost/ThinkPHP//Home/User/index/id/5/type/a返回全部参数
Array ( [id] => 5 [type] => a )
注意：取消和开启URL的'URL_PARAMS_BIND_TYPE'=>1配置定义，在访问这个URL的时候结果有所不一样：http://localhost/ThinkPHP//Home/User/index/id/5/type/a
关闭URL传参顺序：Array ( [id] => 5 [type] => a )
开启URL传参顺序：Array ( [0] => id [1] => 5 [2] => type [3] => a )
param获取指定参数值
<?php namespace Home\Controller; use Think\Controller; use Home\Event\UserEvent; //传递两个参数 class UserController extends Controller { public function index() { //param获取指定参数值 echo I('param.id'); echo I('param.type'); } }
访问：http://localhost/ThinkPHP//Home/User/index/id/5/type/a返回指定参数的值
5a
默认状况下，I()的默认过滤是：htmlspecialchars，过滤掉HTML
<?php return array( //过滤HTML，若是去掉了，则传递包含HTML的字符串，将不过滤 'DEFAULT_FILTER'=>'htmlspecialchars', );
若是系统设置了默认的过滤，自己某个函数又不想过滤，那么能够这么处理：
设置屏蔽系统默认过滤
<?php namespace Home\Controller; use Think\Controller; use Home\Event\UserEvent; //传递两个参数 class UserController extends Controller { public function index() { //设置屏蔽系统默认过滤 echo I('get.id','', false); //第三参数为空字符串都可 } }
五．请求类型
ThinkPHP提供了一组常量来判断当前请求是不是GET、POST等。经过判断请求处理不一样的业务逻辑。
<?php namespace Home\Controller; use Think\Controller; use Home\Event\UserEvent; //传递两个参数 class UserController extends Controller { public function index() { //判断是否GET请求 if (IS_GET) { echo '是GET请求'; } else { echo '不是GET请求'; } } }
(1)IS_GET常量：判断是否GET提交请求(验证是不是表单提交的)
<meta charset="UTF-8"> <form method="get" action="http://localhost/ThinkPHP//Home/User/index"> <p>用户：<input type="text" name="user"></p> <p>邮箱：<input type="text" name="email"></p> <input type="submit" value="提交"> </form>
提交后返回：是GET请求
(2)IS_POST常量：判断是否POST提交请求(验证是不是表单提交的)
<meta charset="UTF-8"> <form method="post" action="http://localhost/ThinkPHP//Home/User/index"> <p>用户：<input type="text" name="user"></p> <p>邮箱：<input type="text" name="email"></p> <input type="submit" value="提交"> </form>
提交后返回(post)：不是GET请求
(3)IS_PUT常量：判断是否PUT提交请求
(4)IS_DELTE常量：判断是否DELETE提交请求
(5)IS_AJAX常量：判断是否AJAX提交请求
六．空操做
空操做是指系统在找不到请求的操做方法时，会定位到空操做(_empty)方法来执行，利用这个机制，咱们能够实现错误页面和一些URL的优化。
空控制器：
<?php namespace Home\Controller; use Think\Controller; use Home\Event\UserEvent; //若是没有相关控制器则执行 class EmptyController extends Controller { public function _empty() { echo '找不到控制器：'.ACTION_NAME; } }
输入错的：http://localhost/ThinkPHP/Home/User/aaa返回
找不到控制器：aaa
空控方法的应用：
<?php namespace Home\Controller; use Think\Controller; use Home\Event\UserEvent; //若是没有相关控制器则执行 class EmptyController extends Controller { public function _empty() { echo '你的名字是：'.ACTION_NAME; } }
输入：http://localhost/ThinkPHP/Home/User/xixi返回
你的名字是：xixi
七．空控制器
所谓空控制器，就是请求不到指定控制器时，调用一个专门的空控制器。利用这个机制，咱们能够实现错误页面和一些URL的优化。
<?php namespace Home\Controller; use Think\Controller; //若是没有相关控制器则执行 class EmptyController extends Controller { public function index() { echo '找不到控制器：'.CONTROLLER_NAME; } }
访问：http://localhost/ThinkPHP/Home/aaa返回
找不到控制器：aaa
八．操做绑定到类
ThinkPHP提供了把每一个操做方法定位到一个类的功能，即每一个把层次分的更加细腻。
第一步：配置文件设置：
<?php return array( //设置操做绑定到类 'ACTION_BIND_CLASS'=>True, );
第二步：在Controller目录下创建User目录，在User目录创建index.class.php，再创建test.class.php。
设置User模块下的index类
<?php namespace Home\Controller\User; use Think\Controller; class index extends Controller { public function run() { echo 'User模块下的index类'; } }
设置User模块下的test类
<?php namespace Home\Controller\User; use Think\Controller; class test extends Controller { public function run() { echo 'User模块下的test类'; } }
第三步浏览器分别访问：
<?php namespace Home\Controller; use Think\Controller; //传递两个参数 class UserController extends Controller { public function index(){ echo 'index'; } public function test(){ echo 'test'; } }
浏览器分别访问：
访问：http://localhost/ThinkPHP/Home/User/index返回：
User模块下的index类
访问：http://localhost/ThinkPHP/Home/User/test返回：
User模块下的test类
前置方法：
<?php namespace Home\Controller\User; use Think\Controller; class index extends Controller { public function run() { echo 'User模块下的index类'; } //前置方法 public function _before_run() { echo 'before_'.ACTION_NAME; } }
访问：http://localhost/ThinkPHP/Home/User/index返回：
before_indexUser模块下的index类
后置方法：
<?php namespace Home\Controller\User; use Think\Controller; class test extends Controller { public function run() { echo 'User模块下的test类'; } //后置方法： public function _after_run() { echo 'after_'.ACTION_NAME; } }
访问：http://localhost/ThinkPHP/Home/User/test返回：
User模块下的test类after_test
空方法，在目录里创建一个_empty.class.php
<?php namespace Home\Controller\User; use Think\Controller; //空方法 class _empty extends Controller { public function run() { echo '找不到'.ACTION_NAME.'方法'; } }
访问：http://localhost/ThinkPHP/Home/User/aaa
找不到aaa方法
空控制器，能够建立一个目录_empty，而后创建index.class.php
<?php //空控制器 namespace Home\Controller\_empty; use Think\Controller; class index extends Controller { public function run() { echo '找不到'.CONTROLLER_NAME.'控制器的'.ACTION_NAME.'方法'; } }
访问：http://localhost/ThinkPHP/Home/aaa
找不到aaa控制器
ThinkPHP--视图--Session与Cookie
ThinkPHP的Session与Cookie的处理，提供了对这两个核心变量的完善支持。
一．Session
系统提供了Session管理和操做的完善支持，只须要经过session()函数完成，该函数能够完成Session的设置、获取、删除和管理操做。
通常来讲，在ThinkPHP中不须要手动初始化session，系统会自动初始化
(1)id说明：session_id值
(2)name说明：session_name值
(3)path说明：session_save_path值
(4)prefix说明：session 本地化空间前缀
(5)expire说明：session.gc_maxlifetime设置值
(6)domain说明：session.cookie_domain设置值
(7)use_cookies说明：session.use_cookies设置值
(8)use_trans_sid说明：session.use_trans_sid设置值
(9)type说明：session处理类型，支持驱动扩展
默认状况下，初始化以后系统会自动启动session，若是不但愿系统自动启动session的话，能够以下设置：
<?php return array( //设置系统不启用session 'SESSION_AUTO_START' =>false, );
1.建立并获取session的值
<?php namespace Home\Controller; use Think\Controller; //传递两个参数 class UserController extends Controller { public function index(){ //建立session session('user', 'xixi'); //$_SESSION['user'] = 'xixi'; } public function test(){ //获取session值 echo session('user'); //echo $_SESSION['user']; } }
建立session(保存在服务器端)：http://localhost/ThinkPHP/Home/User/index
获取session：http://localhost/ThinkPHP/Home/User/test/返回：
xixi
2.删除session
<?php namespace Home\Controller; use Think\Controller; //传递两个参数 class UserController extends Controller { public function index(){ //session删除 session('user', null); //unset($_SESSION['user']); } public function test(){ //删除全部session session(null); //$_SESSION=array(); } }
session删除：http://localhost/ThinkPHP/Home/User/index
删除全部session：http://localhost/ThinkPHP/Home/User/test/
3.判断session是否存在
<?php namespace Home\Controller; use Think\Controller; //传递两个参数 class UserController extends Controller { public function test(){ //判断session是否存在 echo session('?user'); //isset($_SESSION['user']); } }
访问：http://localhost/ThinkPHP/Home/User/test/返回：
1
4.写入关闭
//暂停session，写入关闭
session('[pause]'); //session_write_close();
5.可开启写入
//启动session，可开启写入
session('[start]'); //session_start()
6.销毁session
//销毁session(服务器存的文件删除掉)
session('[destroy]'); //session_destroy();
7.从新生成session id
//从新生成session id(建立新的session的id不同了)
session('[regenerate]'); //session_regenerate_id();
注意：若是在初始化session设置的时候传入prefix参数或者单独设置了SESSION_PREFIX参数的话，就能够启用本地化session管理支持。
配置文件设置SESSION前缀：
<?php return array( //SESSION前缀 'SESSION_PREFIX'=>'think_', //文件里的东西多了think_ );
这时处理的$_SESSION['user']将变成$_SESSION['think_']['user']，而咱们在处理上没有任何区别。
二．Cookie
ThinkPHP内置了一个cookie函数用于支持和简化Cookie的相关操做，该函数能够完成Cookie的设置、获取、删除操做。
1.赋值cookie并取值
<?php namespace Home\Controller; use Think\Controller; //传递两个参数 class UserController extends Controller { public function test(){ //cookie赋值 cookie('user', 'xixi'); //setcookie('user','xixi'); //cookie取值 echo cookie('user'); //echo $_COOKIE['user']; } }
访问：http://localhost/ThinkPHP/Home/User/test/
xixi
2.cookie赋值，设置过时时间
<?php namespace Home\Controller; use Think\Controller; //传递两个参数 class UserController extends Controller { public function test(){ //cookie赋值，设置过时时间 cookie('user', 'xixi', 3600); } }
3.cookie赋值，第三参数数组设置过时时间和前缀
<?php namespace Home\Controller; use Think\Controller; //传递两个参数 class UserController extends Controller { public function test(){ //cookie赋值，第三参数数组设置过时时间和前缀 cookie('user', 'xixi', array('expire'=>3600,'prefix'=>'think_')); //cookie取值 echo cookie('think_user'); //echo $_COOKIE['user']; } }
http://localhost/ThinkPHP/Home/User/test/返回
xixi
除了过时和前缀，还有path(保存路径)和domain(域)。固然也支持配置文件的写法：COOKIE_PREFIX、COOKIE_EXPIRE、COOKIE_PATH、COOKIE_DOMAIN。
4.cookie赋值，数组
<?php namespace Home\Controller; use Think\Controller; //传递两个参数 class UserController extends Controller { public function test(){ //cookie赋值，数组 cookie('user', array('Mr.', 'xixi')); print_r(cookie(user)); } }
访问:http://localhost/ThinkPHP/Home/User/test/返回
Array ( [0] => Mr. [1] => xixi )
5.删除
<?php namespace Home\Controller; use Think\Controller; //传递两个参数 class UserController extends Controller { public function test(){ //cookie删除user cookie('user', null); //cookie删除在配置文件里指定前缀的全部 cookie(null); //cookie删除指定think_前缀的 cookie(null, 'think_'); } }
ThinkPHP--视图--图像处理
ThinkPHP的图像处理功能，即Image.class.php。支持GD库和Imagick库，包括对GIF图像处理的支持。
一．实例化类库
GD库：
<?php namespace Home\Controller; use Think\Controller; use Think\Image; //自动添加Think下的Image这个类 //传递两个参数 class UserController extends Controller { public function index(){ //实例化图像处理类，默认为GD库 $image = new Image(); } }
Imageick扩展库：
方式一：
<?php namespace Home\Controller; use Think\Controller; use Think\Image; //传递两个参数 class UserController extends Controller { public function index(){ //采用Imageick扩展库 $image = new Image('Imagick'); //默认没安装，加载会报错 } }
方式二：
<?php namespace Home\Controller; use Think\Controller; use Think\Image; //传递两个参数 class UserController extends Controller { public function index(){ //采用Imageick扩展库，默认没安装 $image = new Image(Image::IMAGE_IMAGICK); //默认没安装，加载不会报错 } }
二．获取图像信息
将一张图片保存在Public公共目录下，命名为：1.jpg。首先，经过Image打开图像。
<?php namespace Home\Controller; use Think\Controller; use Think\Image; //传递两个参数 class UserController extends Controller { public function index(){ //实例化图像处理类，默认为GD库 $image = new Image(); //加载一张预处理的图片 $image->open('./Public/1.jpg'); //获取图片信息 $arr['width'] = $image->width(); //图片长度 $arr['height'] = $image->height(); //图片高度 $arr['type'] = $image->type(); //图片类型 $arr['mime'] = $image->mime(); //图片扩展类型 $arr['size'] = $image->size(); //图片长度和宽度 var_dump($arr); } }
访问：http://localhost/ThinkPHP/Home/User/返回:
array (size=5)
'width' => int 764
'height' => int 432
'type' => string 'jpeg' (length=4)
'mime' => string 'image/jpeg' (length=10)
'size' =>
array (size=2)
0 => int 764
1 => int 432
三．图像处理
1.使用crop()和save()方法能够实现图像的裁剪功能。
在原有图片的基础上裁剪图片为高400宽400生成一张2.jpg(默认0，0坐标开始截起)
<?php namespace Home\Controller; use Think\Controller; use Think\Image; //传递两个参数 class UserController extends Controller { public function index(){ //实例化图像处理类，默认为GD库 $image = new Image(); //加载一张预处理的图片 $image->open('./Public/1.jpg'); //裁剪图片，高400，宽400经过save生成 $image->crop(400,400)->save('./Public/2.jpg'); } }
在原有图片的基础上裁剪图片为高400宽400生成一张2.jpg(坐标100,100开始裁剪)
<?php namespace Home\Controller; use Think\Controller; use Think\Image; //传递两个参数 class UserController extends Controller { public function index(){ //实例化图像处理类，默认为GD库 $image = new Image(); //加载一张预处理的图片 $image->open('./Public/1.jpg'); //裁剪图片，坐标100,100开始裁剪 $image->crop(400,400,100,100)->save('./Public/2.jpg'); } }
在原有图片的基础上裁剪图片为高400宽400生成一张2.jpg(坐标100,100开始裁剪),最后在缩放成200*200
<?php namespace Home\Controller; use Think\Controller; use Think\Image; //传递两个参数 class UserController extends Controller { public function index(){ //实例化图像处理类，默认为GD库 $image = new Image(); //加载一张预处理的图片 $image->open('./Public/1.jpg'); //裁剪图片，生成后的图片压缩成高宽200 $image->crop(400,400,100,100,200,200)->save('./Public/2.jpg'); } }
2.使用thumb方法生成缩略图。
生成缩略图300*300
<?php namespace Home\Controller; use Think\Controller; use Think\Image; //传递两个参数 class UserController extends Controller { public function index(){ //实例化图像处理类，默认为GD库 $image = new Image(); //加载一张预处理的图片 $image->open('./Public/1.jpg'); //生成缩略图 $image->thumb(300,300)->save('./Public/2.jpg'); } }
注意：虽然咱们设置了宽高300，但实际上它是300 x 168，由于生成缩略图采用默认等比例缩放的。若是想用其它缩略图模式，可使用如下方式。
(1)IMAGE_THUMB_SCALE = 1 ; //等比例缩放类型
(2)IMAGE_THUMB_FILLED = 2 ; //缩放后填充类型
(3)IMAGE_THUMB_CENTER = 3 ; //居中裁剪类型
(4)IMAGE_THUMB_NORTHWEST = 4 ; //左上角裁剪类型
(5)IMAGE_THUMB_SOUTHEAST = 5 ; //右下角裁剪类型
(6)IMAGE_THUMB_FIXED = 6 ; //固定尺寸缩放类型
生成缩略图，以中心点截取，直接传3也能够
<?php namespace Home\Controller; use Think\Controller; use Think\Image; //传递两个参数 class UserController extends Controller { public function index(){ //实例化图像处理类，默认为GD库 $image = new Image(); //加载一张预处理的图片 $image->open('./Public/1.jpg'); //生成缩略图，以中心点截取，直接传3也能够 $image->thumb(300,300,Image::IMAGE_THUMB_CENTER)->save('./Public/2.jpg'); } }
3.使用water()方法能够生成一张包含水印的图片。
在图片右下角添加水印并生成(把图片1.jpg右下角添加水印后拷贝成2.jpg)
<?php namespace Home\Controller; use Think\Controller; use Think\Image; //传递两个参数 class UserController extends Controller { public function index(){ //实例化图像处理类，默认为GD库 $image = new Image(); //加载一张预处理的图片 $image->open('./Public/1.jpg'); //在图片右下角添加水印并生成 $image->water('./Public/logo.png')->save('./Public/2.jpg'); } }
因为默认是右下角水印位置，若是想更改水印位置，能够在第二参数使用以下：
(1)IMAGE_WATER_NORTHWEST = 1 ; //左上角水印
<?php namespace Home\Controller; use Think\Controller; use Think\Image; //传递两个参数 class UserController extends Controller { public function index(){ //实例化图像处理类，默认为GD库 $image = new Image(); //加载一张预处理的图片 $image->open('./Public/1.jpg'); //更改水印到左上角 $image->water('./Public/logo.png', Image::IMAGE_WATER_NORTHWEST)->save('./Public/2.jpg'); } }
(2)IMAGE_WATER_NORTH = 2 ; //上居中水印
(3)IMAGE_WATER_NORTHEAST = 3 ; //右上角水印
(4)IMAGE_WATER_WEST = 4 ; //左居中水印
(5)IMAGE_WATER_CENTER = 5 ; //居中水印
(6)IMAGE_WATER_EAST = 6 ; //右居中水印
(7)IMAGE_WATER_SOUTHWEST = 7 ; //左下角水印
(8)IMAGE_WATER_SOUTH = 8 ; //下居中水印
(9)IMAGE_WATER_SOUTHEAST = 9 ; //右下角水印
设置水印的透明度，默认为80，1-100之间
<?php namespace Home\Controller; use Think\Controller; use Think\Image; //传递两个参数 class UserController extends Controller { public function index(){ //实例化图像处理类，默认为GD库 $image = new Image(); //加载一张预处理的图片 $image->open('./Public/1.jpg'); //设置水印的透明度，默认为80，1-100之间 $image->water('./Public/logo.png', Image::IMAGE_WATER_NORTHWEST, 30)->save('./Public/2.jpg'); } }
设置文本水印(文字：xixi，字体:./Public/consola.ttf，大小:20，颜色:#ffffff)
<?php namespace Home\Controller; use Think\Controller; use Think\Image; //传递两个参数 class UserController extends Controller { public function index(){ //实例化图像处理类，默认为GD库 $image = new Image(); //加载一张预处理的图片 $image->open('./Public/1.jpg'); //设置文本水印 $image->text('xixi', './Public/consola.ttf', 20, '#ffffff', Image::IMAGE_WATER_SOUTHEAST)->save('./Public/2.jpg'); } }
ThinkPHP--视图--验证码
ThinkPHP的验证码功能，即Verify.class.php。此验证码能够支持验证码的生成和验证功能。
一．生成验证码
1.默认数字与字母大小写不区分的5位验证码
<?php namespace Home\Controller; use Think\Controller; //传递两个参数 class UserController extends Controller { public function index(){ //实例化验证码类 $verify= new \Think\Verify(); //生成一个验证码图形 $verify->entry(); } }
注意：生成的验证码会将信息保存在session中，可使用print_r($_SESSION)来查看。若是想生成多个验证码，能够传递数字参数便可
生成多个验证码
<?php namespace Home\Controller; use Think\Controller; //传递两个参数 class UserController extends Controller { public function index(){ //实例化验证码类 $verify= new \Think\Verify(); //生成第一个验证码 $verify->entry(1); //生成第二个验证码 $verify->entry(2); } }
二．验证码参数
能够对生成的验证码设置相关的参数，以达到不一样的显示效果。
(1)expire描述：验证码的有效期（秒）
(2)useImgBg描述：是否使用背景图片 默认为false
(3)fontSize描述：验证码字体大小（像素） 默认为25
(4)useCurve描述：是否使用混淆曲线 默认为true
(5)useNoise描述：是否添加杂点 默认为true
(6)imageW描述：验证码宽度 设置为0为自动计算
(7)imageH描述：验证码高度 设置为0为自动计算
(8length描述：验证码位数
(9)fontttf描述：指定验证码字体 默认为随机获取
(10)useZh描述：是否使用中文验证码
(11)bg描述：验证码背景颜色 rgb数组设置，例如 array(243, 251, 254)
(12)seKey描述：验证码的加密密钥
(13)codeSet描述：验证码字符集合
(14)zhSet描述：验证码字符集合（中文）
设置验证码参数(字体大小,位数,关闭验证码杂点)
<?php namespace Home\Controller; use Think\Controller; //传递两个参数 class UserController extends Controller { public function index(){ //设置验证码参数 $config = array( 'fontSize'=>30, //验证码字体大小 'length'=>3, //验证码位数3位 'useNoise'=>false, //关闭验证码杂点 ); //实例化验证码类，并传入参数 $verify= new \Think\Verify($config); //生成验证码 $verify->entry(); } }
采用的配置变量方式来修改验证码参数，也可使用动态设置方法：
(1)设置验证码字体为5.ttf文件
<?php namespace Home\Controller; use Think\Controller; //传递两个参数 class UserController extends Controller { public function index(){ //实例化验证码类 $verify= new \Think\Verify(); //设置验证码字体 $verify->fontttf = '5.ttf'; //生成验证码 $verify->entry(); } }
(2)设置背景图片功能，随机使用
<?php namespace Home\Controller; use Think\Controller; //传递两个参数 class UserController extends Controller { public function index(){ //实例化验证码类 $verify= new \Think\Verify(); //设置背景图片功能，随机使用 $verify->useImgBg = true; //生成验证码 $verify->entry(); } }
(3)取消曲线混淆
<?php namespace Home\Controller; use Think\Controller; //传递两个参数 class UserController extends Controller { public function index(){ //实例化验证码类 $verify= new \Think\Verify(); //取消曲线混淆 $verify->useCurve = false; //生成验证码 $verify->entry(); } }
(4)设置验证码的高宽和验证码的长度
<?php namespace Home\Controller; use Think\Controller; //传递两个参数 class UserController extends Controller { public function index(){ //实例化验证码类 $verify= new \Think\Verify(); //设置验证码的高 $verify->imageH = 100; //设置验证码的宽 $verify->imageW = 100; //设置验证码的长度 $verify->length = 1; //生成验证码 $verify->entry(); } }
(5)设置验证码背景颜色
<?php namespace Home\Controller; use Think\Controller; //传递两个参数 class UserController extends Controller { public function index(){ //实例化验证码类 $verify= new \Think\Verify(); //设置验证码背景颜色 $verify->bg = array(200,200,200); //生成验证码 $verify->entry(); } }
1.若是想让验证码显示中文字符，那么须要几个步骤：
(1)在Think/zhttfs文件夹下引入中文字体文件，好比加粗雅黑msyhbd.ttf；
(2)设置字体文件；
(3)把中文字体雅黑msyhbd.ttf放到ThinkPHP/Libray/Think/Verify/zhttfs/msyhbd.ttf
(4)设置中文验证码
<?php namespace Home\Controller; use Think\Controller; //传递两个参数 class UserController extends Controller { public function index(){ //实例化验证码类 $verify= new \Think\Verify(); //设置验证码字体 $verify->fontttf = 'msyhbd.ttf'; //设置中文验证码 $verify->useZh = true; //生成验证码 $verify->entry(); } }
注意：因为中文字符较为庞大，你也能够限定指定的中文字符。
2.限定中文字符
<?php namespace Home\Controller; use Think\Controller; //传递两个参数 class UserController extends Controller { public function index(){ //实例化验证码类 $verify= new \Think\Verify(); //设置验证码字体 $verify->fontttf = 'msyhbd.ttf'; //设置中文验证码 $verify->useZh = true; //限定中文字符 $verify->zhSet = '西西是个好人'; //生成验证码 $verify->entry(); } }
3.设置纯数字
<?php namespace Home\Controller; use Think\Controller; //传递两个参数 class UserController extends Controller { public function index(){ //实例化验证码类 $verify= new \Think\Verify(); //设置纯数字 $verify->codeSet='0123456789'; //生成验证码 $verify->entry(); } }
三．验证码检测
咱们可使用Verify.class.php类中的check方法检测验证码是否输入正确。
第一步：在function.php里构建一个函数：\ThinkPHP\Weibo\Common\Common\function.php
<?php //函数$code是验证码字符，$id是第几个验证码，若是只有一个，能够忽略 function check_verify($code, $id = ''){ $verify = new \Think\Verify(); return $verify->check($code, $id); }
第二步：经过输入验证，来验证，是否返回true
<?php namespace Home\Controller; use Think\Controller; //传递两个参数 class UserController extends Controller { public function index(){ //实例化验证码类 $verify= new \Think\Verify(); //设置纯数字 $verify->codeSet='0123456789'; //生成验证码 $verify->entry(); } //经过输入验证，来验证，是否返回true public function test() { $code = I('get.code'); var_dump(check_verify($code)); //($code, 1) } }
访问：http://localhost/ThinkPHP/Home/User/index生成验证码29535
经过访问：http://localhost/ThinkPHP/Home/User/test?code=29535验证
正确返回：boolean true
ThinkPHP--视图--文件上传
ThinkPHP的文件上传功能，即Upload.class.php。上传类能够提供单个文件上传、多个文件上传等上传方式。
一．上传单个表单
1.建立上床表单路径：ThinkPHP\Weibo\Home\View\default\User\index.html
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> <form action="__CONTROLLER__/upload" enctype="multipart/form-data" method="post"> <!-- __CONTROLLER控制器，upload这个方法，enctype支持上传的属性值，method方法去发送--> <input type="text" name="name" /> <input type="file" name="photo" /> <input type="submit" value="提交" /> </form> </body> </html>
2.配置文件设置主体目录：ThinkPHP\Weibo\Common\Conf\config.php
<?php return array( //设置默认主题目录 'DEFAULT_THEME'=>'default', );
3.在控制器里建立一个upload方法，实现上传功能：ThinkPHP\Weibo\Home\Controller\UserController.class.php
方式一：实例化上传Upload类
<?php namespace Home\Controller; use Think\Controller; use Home\Event\UserEvent; use Think\Image; use Think\Verify; use Think\Upload; //传递两个参数 class UserController extends Controller { //上传功能 public function upload() { $upload = new Upload(); //实例化上传Upload类 $upload->maxSize = 3145728; //设置上传大小，字节 $upload->exts = array('jpg','gif','png','jpeg'); //限定后缀 $upload->savePath = './'; //在根目录Uploads下 $info = $upload->upload(); //执行上传方法 if (!$info) { $this->error($upload->getError()); //错误了 } else { $this->success('上传成功！'); //成功了 } } }
访问：http://localhost/ThinkPHP/Home/User/上传
方式二：实例化配置参数
<?php namespace Home\Controller; use Think\Controller; use Home\Event\UserEvent; use Think\Image; use Think\Verify; use Think\Upload; //传递两个参数 class UserController extends Controller { //上传功能 public function upload() { //实例化配置参数 $config = array( 'maxSize'=>3145728, 'exts'=>array('jpg','gif','png','jpeg'), 'savePath'=>'./', ); $upload = new Upload($config); $info = $upload->upload(); //执行上传方法 if (!$info) { $this->error($upload->getError()); //错误了 } else { $this->success('上传成功！'); //成功了 } } }
二．文件上传
Upload类支持的属性：
(1)maxSize参数：文件上传的最大文件大小（以字节为单位），0为不限大小
(2)rootPath参数：文件上传保存的根路径
(3)savePath参数：文件上传的保存路径（相对于根路径）
(4)saveName参数：上传文件的保存规则，支持数组和字符串方式定义
(5)saveExt参数：上传文件的保存后缀，不设置的话使用原文件后缀
(6)replace参数：存在同名文件是不是覆盖，默认为false
(7)exts参数：容许上传的文件后缀（留空为不限制），使用数组或者逗号分隔的字符串设置，默认为空
(8)mimes参数：容许上传的文件类型（留空为不限制），使用数组或者逗号分隔的字符串设置，默认为空
(9)autoSub参数：自动使用子目录保存上传文件 默认为true
(10)subName参数：子目录建立方式，采用数组或者字符串方式定义
(11)hash参数：是否生成文件的hash编码 默认为true
(12)callback参数：检测文件是否存在回调，若是存在返回文件信息数组
1.设置文件名字容许覆盖同名，限制上传文件类型
<?php namespace Home\Controller; use Think\Controller; use Home\Event\UserEvent; use Think\Image; use Think\Verify; use Think\Upload; //传递两个参数 class UserController extends Controller { //上传功能 public function upload() { $upload = new Upload(); //实例化上传Upload类 $upload->maxSize = 3145728; //设置上传大小，字节 $upload->exts = array('jpg','gif','png','jpeg'); //限定后缀 $upload->savePath = './'; //在根目录Uploads下 //设置文件名 $upload->saveName = '123'; //设置同名覆盖 $upload->replace = true; //限制上传文件类型 $upload->mimes = array('image/jpeg'); $info = $upload->upload(); //执行上传方法 if (!$info) { $this->error($upload->getError()); //错误了 } else { $this->success('上传成功！'); //成功了 } } }
2.设置子目录格式为20180421这种格式
<?php namespace Home\Controller; use Think\Controller; use Home\Event\UserEvent; use Think\Image; use Think\Verify; use Think\Upload; //传递两个参数 class UserController extends Controller { //上传功能 public function upload() { $upload = new Upload(); //实例化上传Upload类 $upload->maxSize = 3145728; //设置上传大小，字节 $upload->exts = array('jpg','gif','png','jpeg'); //限定后缀 $upload->savePath = './'; //在根目录Uploads下 //设置子目录格式 $upload->subName = array('date','Ymd'); $info = $upload->upload(); //执行上传方法 if (!$info) { $this->error($upload->getError()); //错误了 } else { $this->success('上传成功！'); //成功了 } } }
3.子目录采用函数返回
<?php namespace Home\Controller; use Think\Controller; use Home\Event\UserEvent; use Think\Image; use Think\Verify; use Think\Upload; //传递两个参数 class UserController extends Controller { //上传功能 public function upload() { $upload = new Upload(); //实例化上传Upload类 $upload->maxSize = 3145728; //设置上传大小，字节 $upload->exts = array('jpg','gif','png','jpeg'); //限定后缀 $upload->savePath = './'; //在根目录Uploads下 //子目录采用函数返回 $upload->subName = 'get_user_id'; $info = $upload->upload(); //执行上传方法 if (!$info) { $this->error($upload->getError()); //错误了 } else { $this->success('上传成功！'); //成功了 } } }
在function.php中建立一个函数
<?php function get_user_id() { return rand(); //随机生成5位数字 }
4.上传成功获取上传文件信息
<?php namespace Home\Controller; use Think\Controller; use Home\Event\UserEvent; use Think\Image; use Think\Verify; use Think\Upload; //传递两个参数 class UserController extends Controller { //上传功能 public function upload() { $upload = new Upload(); //实例化上传Upload类 $upload->maxSize = 3145728; //设置上传大小，字节 $upload->exts = array('jpg','gif','png','jpeg'); //限定后缀 $upload->savePath = './'; //在根目录Uploads下 $info = $upload->upload(); //执行上传方法 if (!$info) { $this->error($upload->getError()); //错误了 } else { //获取上传文件信息 foreach ($info as $file) { echo $file['savepath'].$file['savename']; } } } }
5.$file数组可使用的属性：
<?php namespace Home\Controller; use Think\Controller; use Home\Event\UserEvent; use Think\Image; use Think\Verify; use Think\Upload; //传递两个参数 class UserController extends Controller { //上传功能 public function upload() { $upload = new Upload(); //实例化上传Upload类 $upload->maxSize = 3145728; //设置上传大小，字节 $upload->exts = array('jpg','gif','png','jpeg'); //限定后缀 $upload->savePath = './'; //在根目录Uploads下 $info = $upload->upload(); //执行上传方法 if (!$info) { $this->error($upload->getError()); //错误了 } else { //获取上传文件信息 foreach ($info as $file) { echo $file['key'].'<br />'; //附件上传的表单名称 echo $file['savepath'].'<br />'; //上传文件的保存路径 echo $file['name'].'<br />'; //上传文件的原始名称 echo $file['savename'].'<br />'; //上传文件的保存名称 echo $file['size'].'<br />'; //上传文件的大小 echo $file['type'].'<br />'; //上传文件的MIME类型 echo $file['ext'].'<br />'; //上传文件的后缀类型 echo $file['md5'].'<br />'; //上传文件的md5哈希验证字符串 仅当hash设置开启后有效 echo $file['sha1'].'<br />'; //上传文件的sha1哈希验证字符串 仅当hash设置开启后有效 } } } }
三.多文件上传设置，或者改成photo1，photo2，photo3便可
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> <form action="__CONTROLLER__/upload" enctype="multipart/form-data" method="post"> <!-- __CONTROLLER控制器，upload这个方法，enctype支持上传的属性值，method方法去发送--> <input type="text" name="name" /> <input type="file" name="photo[]" /> <input type="file" name="photo[]" /> <input type="file" name="photo[]" /> <input type="submit" value="提交" /> </form> </body> </html>
获取上传文件信息：
<?php namespace Home\Controller; use Think\Controller; use Home\Event\UserEvent; use Think\Image; use Think\Verify; use Think\Upload; //传递两个参数 class UserController extends Controller { //上传功能 public function upload() { $upload = new Upload(); //实例化上传Upload类 $upload->maxSize = 3145728; //设置上传大小，字节 $upload->exts = array('jpg','gif','png','jpeg'); //限定后缀 $upload->savePath = './'; //在根目录Uploads下 $info = $upload->upload(); //执行上传方法 if (!$info) { $this->error($upload->getError()); //错误了 } else { //获取上传文件信息 foreach ($info as $file) { echo $file['savepath'].$file['savename'].'<br />'; } } } }
返回：
./2018-04-21/5adad5e96af27.jpg
./2018-04-21/5adad5e96ce67.jpg
./2018-04-21/5adad5e96e5d7.jpg
ThinkPHP--视图--多语言
ThinkPHP的多语言设置，多语言就是国际化问题，能够改变网站各类信息语言的设置。
一．系统信息
ThinkPHP内置多语言支持，若是涉及到国际化的支持，那么能够定义相关的语言包文件。任何字符串形式的输出，均可以定义语言常量。
1.要启用多语言功能，须要配置开启多语言行为，在应用配置目录中：\ThinkPHP\Weibo\Common\Conf\tags.php
<?php //在应用模块Weibo下Common/Conf创建tags.php return array( 'app_begin'=>array('Behavior\CheckLangBehavior'), );
PS：这个行为主要是检测多语言功能。
2.配置文件设置：ThinkPHP\Weibo\Common\Conf\config.php
<?php return array( //页面Trace 'SHOW_PAGE_TRACE' =>true, //设置默认主题目录 'DEFAULT_THEME'=>'default', //设置可访问模块 'MODULE_ALLOW_LIST'=>array('Home','Admin'), 'DEFAULT_MODULE'=>'Home', //启用路由功能 'URL_ROUTER_ON'=> true, //开启语言包功能 'LANG_SWITCH_ON' => true, //自动侦测语言 开启多语言功能后有效 'LANG_AUTO_DETECT' => true, //容许切换的语言列表 用逗号分隔 'LANG_LIST' => 'zh-cn,en-us', //默认语言切换变量 'VAR_LANGUAGE' => 'lang', );
3.配置：ThinkPHP\Weibo\Home\View\default\User\index.html
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> </body> </html>
ThinkPHP系统提供了三个默认语言包，分别是简体中文、英文、繁体中文。而这三种语言包保存在：Think\Lang下。
咱们想显示系统提示信息，能够经过L()方法来传入多语言变量。
默认输出没法加载控制器经过cookie切换语言定义为英文
4.配置：ThinkPHP\Weibo\Home\Controller\UserController.class.php
<?php namespace Home\Controller; use Think\Controller; //传递两个参数 class UserController extends Controller { public function index() { //设置语言定义的键值对 echo L('_CONTROLLER_NOT_EXIST_'); //没法加载控制器 $this->display(); } //经过cookie切换语言定义 public function lang() { setcookie('think_language','en-us'); } }
访问：http://localhost/ThinkPHP/User/返回
Controler can't be loaded
二．应用信息
除了系统开发信息的语言包，咱们用的更多的是项目应用中的语言定义切换。好比，一个表单支持中英文双语结构。
除了以上的配置外，实现应用信息中英文切换须要在应用目录进行配置。
第一步：要启用多语言功能，须要配置开启多语言行为，在应用配置目录中：\ThinkPHP\Weibo\Common\Conf\tags.php
<?php //在应用模块Weibo下Common/Conf创建tags.php return array( 'app_begin'=>array('Behavior\CheckLangBehavior'), );
PS：这个行为主要是检测多语言功能。
第二步：配置文件设置：ThinkPHP\Weibo\Common\Conf\config.php
<?php return array( //页面Trace 'SHOW_PAGE_TRACE' =>true, //设置默认主题目录 'DEFAULT_THEME'=>'default', //设置可访问模块 'MODULE_ALLOW_LIST'=>array('Home','Admin'), 'DEFAULT_MODULE'=>'Home', //启用路由功能 'URL_ROUTER_ON'=> true, //开启语言包功能 'LANG_SWITCH_ON' => true, //自动侦测语言 开启多语言功能后有效 'LANG_AUTO_DETECT' => true, //容许切换的语言列表 用逗号分隔 'LANG_LIST' => 'zh-cn,en-us', //默认语言切换变量 'VAR_LANGUAGE' => 'lang', );
第三步：在Home目录下创建Lang目录；
第四步：分别创建zh-cn.php和en-us.php两个文件；
第五步：分别在两个语言包编写语言常量；
中文常量：ThinkPHP\Weibo\Home\Lang\zh-cn.php
<?php //中文语言包 return array( //表单部分 'form_user'=>'用户', 'form_pass'=>'密码', 'form_email'=>'邮箱', 'form_submit'=>'提交', );
英文常量：ThinkPHP\Weibo\Home\Lang\en.us.php
<?php //英文语言包 return array( //表单部分 'form_user'=>'user', 'form_pass'=>'pass', 'form_email'=>'email', 'form_submit'=>'submit', );
第六步：模版获取语言定义{$Think.lang.form_...}：ThinkPHP\Weibo\Home\View\default\User\index.html
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> <p>{$Think.lang.form_user}：<input type="text" name="user" /></p> <p>{$Think.lang.form_pass}：<input type="password" name="pass" /></p> <p>{$Think.lang.form_email}：<input type="text" name="email" /></p> <p><input type="submit" value="{$Think.lang.form_submit}" /></p> </body> </html>
第七步配置：ThinkPHP\Weibo\Home\Controller\UserController.class.php
<?php namespace Home\Controller; use Think\Controller; //传递两个参数 class UserController extends Controller { public function index() { $this->display(); } }
切换中文：http://localhost/ThinkPHP/User/?lang=zh-cn
切换英文:http://localhost/ThinkPHP/User/?lang=en-us
ThinkPHP--视图--auth权限控制
ThinkPHP的auth权限控制，了解一下Auth权限类的简单使用过程。
一．权限介绍
所谓权限控制，大部分是在管理后台上使用。好比超级管理员登陆，会获得全部操做的控制权；认证专员，只能给会员作认证操做；审核专员，只能操做内容的审核、删除、加精等操做，以此类推。那么ThinkPHP提供了一个内置的Auth.class.php类来实现权限控制，这个类提供了三个表：think_auth_rule(认证规则表)、think_auth_group(用户组表)、think_auth_group_access(用户和组对应关系表)。固然还要结合本身建立的用户表进行对应便可。
二．简单登陆
第一步：在Admin模块下建立一个IndexController.class.php（默认就有了），建立index方法，输出一句话便可。
配置：ThinkPHP\Weibo\Admin\Controller\IndexController.class.php
<?php namespace Admin\Controller; use Think\Controller; class IndexController extends Controller { public function index(){ echo '后台首页'; } }
经过URL访问：http://localhost/ThinkPHP/Admin/Index/index便可访问
第二步：在Weibo根目录下的Common公共模块下建立Controller文件夹，并在里面建立一个AuthController.class.php类，这个类用于权限控制。
配置文件：\ThinkPHP\Weibo\Common\Controller\AuthController.class.php
<?php namespace Common\Controller; use Think\Controller; use Think\Auth; class AuthController extends Controller { protected function _initialize() { //只能内部使用固定方法 $auth = new Auth(); if(!$auth->check()) { //若是判断没有这个权限的状况下 $this->error('没有权限'); //返回 } } }
经过URL访问：http://localhost/ThinkPHP/Admin/Index/index便可访问
这里使用的方法固定为：_initialize()。因为AuthController.class.php继承了Controller类，因此，第一步的Index类改成继承它。
<?php // 本类由系统自动生成，仅供测试用途 namespace Admin\Controller; use Common\Controller\AuthController; class IndexController extends AuthController { public function index(){ echo '后台首页'; } }
此时，咱们再访问后台首页的时候，已经没有权限了。主要是$auth->check()验证没法经过的缘由。
三．Auth权限类的简单使用过程
设置三个用户：admin为超级管理员能够全部权限uid=1；test测试用户uid=2：没有权限，guest游客uid=3，只有登陆权限
第一步：数据库thinkphp建立三张表手工添加规则
表1：think_auth_rule(type=1表示url访问容许访问Admin/Index/index这个页面这个页面的id是1) id name title type status condition 1 Admin/Index/index 后台首页 1 1 表2：think_auth_group(默认管理组status=1表示能够用，权限rules写的是容许访问Admin/Index/index权限的id=1,2,3,4,5) id title status rules 1 默认管理组 1 1，2，3，4，5 表3：think_auth_group_access(把组权限分配给3，3表明guest用户) uid group_id 3 1
第二步：数据配置文件引入：ThinkPHP\Weibo\Common\Conf\config.php
<?php return array( //'配置项'=>'配置值' //全局配置定义 'DB_TYPE'=>'mysql', //数据库类型 'DB_HOST'=>'127.0.0.1', //服务器地址 'DB_NAME'=>'thinkphp', //数据库名 'DB_USER'=>'xixi', //用户名 'DB_PWD'=>'123456', //密码 'DB_PORT'=>3306, //端口 'DB_PREFIX'=>'think_', //数据库表前缀 );
第三步：建立登陆退出页面:ThinkPHP\Weibo\Admin\View\Login\index.html
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>登陆后台</title> </head> <body> <p>三个用户：admin为超级管理员能够全部权限；test测试用户：没有权限，guest游客，只有登陆权限</p> <form method="post" action="{:U('Login/index')}"> <p>用户名：<input type="text" name="user" /></p> <p><input type="submit" value="登陆" /></p> </form> </body> </html>
第四步：建立首页登陆和退出方法，路径：ThinkPHP\Weibo\Admin\Controller\IndexController.class.php
<?php namespace Admin\Controller; use Common\Controller\AuthController; class IndexController extends AuthController { public function index(){ echo '后台首页'; echo '<a href="'.U('Login/logout').'">退出</a>'; } }
第五步：建立一个LoginController.class.php路径为ThinkPHP\Weibo\Admin\Controller\LoginController.class.php
<?php namespace Admin\Controller; use Think\Controller; class LoginController extends Controller { public function index(){ //登陆方法 if (IS_POST) { $login = array(); switch (I('user', null, false)) { case 'admin' : //判断是不是admin $login['uid'] = 1; $login['user'] = 'admin'; //获取用 break; case 'test' : //判断是不是test $login['uid'] = 2; $login['user'] = 'test'; break; case 'guest' : //判断是不是guest $login['uid'] = 3; $login['user'] = 'guest'; break; default: $this->error('登陆的用户不存在！'); //若是不是上面三个用户登陆返回 } if (count($login)) { //若是是admin和guest用户登陆 session('auth', $login); $this->success('登陆成功！', U('Index/index')); //登陆成功跳转到:http://localhost/ThinkPHP/index.php/Admin/Index/index.html } } else { $this->display(); } } public function logout(){ //退出登陆方法 session('[destroy]'); $this->success('退出成功',U('Login/index')); //退出成功跳转到：http://localhost/ThinkPHP/index.php/Admin/Login/index.html } }
访问：http://localhost/ThinkPHP/index.php/Admin/Login/index.html
最后实现admin为超级管理员能够全部权限；test测试用户：没有权限，guest游客，只有登陆权限
ThinkPHP--视图--关联模型
ThinkPHP的关联模型，关联模型能够很是容易的操做多种关联表的增、删、改、查。
一．模型简介
关联模型，一共有三种模式：
一对一：ONE_TO_ONE，包括HAS_ONE和BELONGS_TO；
一对多：ONE_TO_MANY，包括HAS_MANY和BELONGS_TO；
多对多：MANY_TO_MANY。
用表关系来理解这三种模式：
一对一：用户表和身份证表，一个用户只能对应一个身份证，而一个身份证只能对应一个用户。这就是一对一。
一对多：用户表和留言表：一个用户能够发表N条留言，而每条留言只能由某一个用户发表。这就是一对多。就算有多个用户发表了相同的留言内容，但ID却不同，因此，不能理解为多对多。
多对多：用户表和角色表：一个用户能够是认证专员，同时也是审核专员。那么角色表中的审核专员也能够是蜡笔小新的角色，也能够是路飞的角色。这就是多对多。
二．关联操做
建立用户数据表：think_user
建立身份证表：think_card
建立留言表：think_content
建立角色表：think_role
建立中间表实现多对多：think_group(西西用户id=1权限是管理员，认证专业，审核专员。西西用户id=2权限是认证专员，审核专员，西西用户3id=3权限审核专员)
1.拥有关系：用户表和身份证表关联，HAS_ONE（一对一），表示一个用户只有一个身份证。
User控制器部分：ThinkPHP\Weibo\Home\Controller\UserController.class.php
<?php namespace Home\Controller; use Think\Controller; use Home\Model\UserModel; class UserController extends Controller { public function index() { $user = D('User'); $arr = $user->relation(true)->select(); //指向relation，true自动获取UserModel里的Card var_dump($arr); } }
HAS_ONE支持如下属性：
class_name属性：关联的模型类名，若是不写，会自动定位相关数据表。
mapping_name属性：关联映射名称，用于获取数据的数组名。
mapping_type属性：设置关联模式，好比一对一self::HAS_ONE。
foreign_key属性：关联外键的名称，会自动对应当前数据表的id。
mapping_fields属性：关联要查询的字段，默认是查询全部。
as_fields属性：关联的字段映射成同级的字段。
condition属性：关联条件，额外查询使用。
User模型部分：ThinkPHP\Weibo\Home\Model\UserModel.class.php
<?php namespace Home\Model; use Think\Model; use Think\Model\RelationModel; class UserModel extends RelationModel { //RelationModel方法才能被关联 protected $_link = array( //受保护的字段$_link链接 'Card'=>array( //关联模型的属性Card指向一个数组 'mapping_type'=>self::HAS_ONE, //是一对一中的HAS_ONE模式 'foreign_key'=>'uid', //经过think_user表里的id和think_card表里的uid相关联 'mapping_fields'=>'code', //只显示code 'as_fields'=>'code', //把code做为用户表think_user里的一个字段跟它们平级显示 //'condition'=>'id=1', //只显示id=1的code ), ); }
访问http://localhost/ThinkPHP/Home/User/index/结果：
array (size=4)
0 =>
array (size=6)
'id' => string '1' (length=1)
'user' => string '用户西西1' (length=13)
'email' => string 'xixi1@xixi.com' (length=14)
'count' => string '1' (length=1)
'date' => string '2018-04-14 12:35:33' (length=19)
'code' => string '110102' (length=6)
1 =>
array (size=6)
'id' => string '2' (length=1)
'user' => string '用户西西2' (length=13)
'email' => string 'xixi2@xixi.com' (length=14)
'count' => string '2' (length=1)
'date' => string '2018-04-11 00:00:00' (length=19)
'code' => string '110103' (length=6)
2 =>
array (size=6)
'id' => string '3' (length=1)
'user' => string '用户西西3' (length=13)
'email' => string 'xixi3@xixi.com' (length=14)
'count' => string '3' (length=1)
'date' => string '2018-04-25 00:00:00' (length=19)
'code' => null
3 =>
array (size=6)
'id' => string '4' (length=1)
'user' => string '用户西西4' (length=13)
'email' => string 'xixi4@xixi.com' (length=14)
'count' => string '4' (length=1)
'date' => string '2018-04-03 00:00:00' (length=19)
'code' => string '110104' (length=6)
2.从属关系：用户表和身份证表关联，BELONGS_TO（一对一），表示一个身份证从属于一个用户。
由于身份证(think_card)表的uid和用户(think_user)表关联的，用户表没有跟身份证表关联，用户表没有身份证的信息，身份证表包含了用户表的uid，因此身份证表是从属于用户表
Card控制器部分:ThinkPHP\Weibo\Home\Controller\CardController.class.php
<?php namespace Home\Controller; use Think\Controller; use Home\Model\CardModel; class CardController extends Controller { public function index() { $card = D('Card'); $arr = $card->relation(true)->select(); var_dump($arr); } }
Card模型部分:ThinkPHP\Weibo\Home\Model\CardModel.class.php
<?php namespace Home\Controller; use Think\Controller; use Home\Model\CardModel; class CardController extends Controller { public function index() { $card = D('Card'); $arr = $card->relation(true)->select(); var_dump($arr); } }
访问：http://localhost/ThinkPHP/Home/Card/index返回
array (size=3)
0 =>
array (size=4)
'id' => string '1' (length=1)
'code' => string '110102' (length=6)
'uid' => string '1' (length=1)
'user' => string '用户西西1' (length=13)
1 =>
array (size=4)
'id' => string '1' (length=1)
'code' => string '110103' (length=6)
'uid' => string '2' (length=1)
'user' => string '用户西西2' (length=13)
2 =>
array (size=4)
'id' => string '3' (length=1)
'code' => string '110104' (length=6)
'uid' => string '4' (length=1)
'user' => string '用户西西4' (length=13)
3.用户表和留言表：HAS_MANY（一对多）表示一个用户发表N条留言
User控制器部分：ThinkPHP\Weibo\Home\Controller\UserController.class.php
<?php namespace Home\Controller; use Think\Controller; use Home\Model\UserModel; class UserController extends Controller { public function index() { $user = D('User'); $arr = $user->relation(true)->select(); print_r($arr); //经过print_r打印出来 } }
User模型部分：ThinkPHP\Weibo\Home\Model\UserModel.class.php
<?php namespace Home\Model; use Think\Model; use Think\Model\RelationModel; //在模型类里限制字段 class UserModel extends RelationModel { //RelationModel方法才能被关联 protected $_link = array( //受保护的字段$_link链接 'Content'=>array( //关联模型的属性Content指向一个数组 'mapping_type'=>self::HAS_MANY, //是一对多中的HAS_MANY模式 'foreign_key'=>'uid', 'mapping_fields'=>'content', //只想显示content 'mapping_limit'=>'0,2', //只想显示一对多的多的前俩条 'mapping_order'=>'id DESC', //倒序 ), ); }
访问：http://localhost/ThinkPHP/Home/User/查看源代码
Array
(
[0] => Array
(
[id] => 1
[user] => 用户西西1
[email] => xixi1@xixi.com
[count] => 1
[date] => 2018-04-14 12:35:33
[Content] => Array
(
[0] => Array
(
[content] => 个人第三条留言
)
[1] => Array
(
[content] => 个人第二条留言
)
)
)
[1] => Array
(
[id] => 2
[user] => 用户西西2
[email] => xixi2@xixi.com
[count] => 2
[date] => 2018-04-11 00:00:00
[Content] =>
)
[2] => Array
(
[id] => 3
[user] => 用户西西3
[email] => xixi3@xixi.com
[count] => 3
[date] => 2018-04-25 00:00:00
[Content] =>
)
[3] => Array
(
[id] => 4
[user] => 用户西西4
[email] => xixi4@xixi.com
[count] => 4
[date] => 2018-04-03 00:00:00
[Content] =>
)
)
4.用户表和留言表：BELONGS_TO（多对一）表示N条留言从属于某个用户。
User控制器部分:ThinkPHP\Weibo\Home\Controller\ContentController.class.php
<?php namespace Home\Controller; use Think\Controller; use Home\Model\ContentModel; class ContentController extends Controller { public function index() { $content = D('Content'); $arr = $content->relation(true)->select(); var_dump($arr); } }
User模型部分:ThinkPHP\Weibo\Home\Model\ContentModel.class.php
<?php namespace Home\Model; use Think\Model\RelationModel; class ContentModel extends RelationModel { protected $_link = array( 'User'=>array( 'mapping_type'=>self::BELONGS_TO, 'class_name'=>'User', 'foreign_key'=>'uid', 'mapping_name'=>'user', 'mapping_fields'=>'user', 'as_fields'=>'user', ), ); }
访问：http://localhost/ThinkPHP/Home/Content返回
array (size=3)
0 =>
array (size=4)
'id' => string '1' (length=1)
'content' => string '个人第一条留言' (length=21)
'uid' => string '1' (length=1)
'user' => string '用户西西1' (length=13)
1 =>
array (size=4)
'id' => string '2' (length=1)
'content' => string '个人第二条留言' (length=21)
'uid' => string '1' (length=1)
'user' => string '用户西西1' (length=13)
2 =>
array (size=4)
'id' => string '3' (length=1)
'content' => string '个人第三条留言' (length=21)
'uid' => string '1' (length=1)
'user' => string '用户西西1' (length=13)
PS：多对一的使用和一对一是同样的。
5.用户表、角色表和中间关联表，MANY_TO_MANY实现多对多关联。
User控制器部分：ThinkPHP\Weibo\Home\Controller\UserController.class.php
<?php namespace Home\Controller; use Think\Controller; use Home\Model\UserModel; class UserController extends Controller { public function index() { $user = D('User'); $arr = $user->relation(true)->select(); print_r($arr); //经过print_r打印出来 } }
User模型部分：ThinkPHP\Weibo\Home\Model\UserModel.class.php
<?php namespace Home\Model; use Think\Model; use Think\Model\RelationModel; class UserModel extends RelationModel { //RelationModel方法才能被关联 protected $_link = array( //受保护的字段$_link链接 'Role'=>array( 'mapping_type'=>self::MANY_TO_MANY, //多对多 'relation_table'=>'think_group', //中间表think_group 'foreign_key'=>'uid', //用中间表关联user表的uid 'relation_foreign_key'=>'gid', //关联角色表的gid ), ); }
访问：http://localhost/ThinkPHP/Home/User/查看源代码
Array
(
[0] => Array
(
[id] => 1
[user] => 用户西西1
[email] => xixi1@xixi.com
[count] => 1
[date] => 2018-04-14 12:35:33
[Role] => Array
(
[0] => Array
(
[id] => 1
[title] => 管理员
)
[1] => Array
(
[id] => 2
[title] => 认证专员
)
[2] => Array
(
[id] => 3
[title] => 审核专员
)
)
)
[1] => Array
(
[id] => 2
[user] => 用户西西2
[email] => xixi2@xixi.com
[count] => 2
[date] => 2018-04-11 00:00:00
[Role] => Array
(
[0] => Array
(
[id] => 2
[title] => 认证专员
)
[1] => Array
(
[id] => 3
[title] => 审核专员
)
)
)
[2] => Array
(
[id] => 3
[user] => 用户西西3
[email] => xixi3@xixi.com
[count] => 3
[date] => 2018-04-25 00:00:00
[Role] => Array
(
[0] => Array
(
[id] => 3
[title] => 审核专员
)
)
)
[3] => Array
(
[id] => 4
[user] => 用户西西4
[email] => xixi4@xixi.com
[count] => 4
[date] => 2018-04-03 00:00:00
[Role] => Array
(
)
)
)
注意：这里的用户表和角色表并无关联字段，而是采用中间表来关联他们，再经过ThinkPHP的关联模式，进行多对多匹配。
三.表与表之间进行管理后，还能够进行写入、更新和删除。
1.新增：新增一个用户，同时增长一个身份证
<?php namespace Home\Controller; use Think\Controller; use Home\Model\UserModel; class UserController extends Controller { public function add() { $user = D('User'); $data['user'] = '测试用户'; $data['mail'] = 'xixi@18.com'; $data['Card'] = array( //给Card 表也要新增 'code' => '123456', ); $user->relation(true)->add($data); } }
2.删除：删除一个用户，同时删除关联的身份证
<?php namespace Home\Controller; use Think\Controller; use Home\Model\UserModel; class UserController extends Controller { public function delete() { //删除一个用户，同时删除关联的身份证 $user = D('User'); $user->relation(true)->delete(4); } }
3.修改：更新一个用户，同时更新对应的身份证
<?php namespace Home\Controller; use Think\Controller; use Home\Model\UserModel; class UserController extends Controller { public function save() { $user = D('User'); $data['user'] = '修改'; $data['mail'] = '修改@18.com'; $data['Card'] = array( 'code'=>'3209zz', ); $user->relation(true)->where(array('id'=>3))->save($data); } }
ThinkPHP--视图模型和分页
一．视图模型
关联模型能够解决一对1、一对多和多对多等关联操做。它们经过生成多条SQL语句而后进行数组拼装获得最终想要的结果。对于一对一这种HAS_ONE和BELONGS_TO的多表关联查询，可使用视图模型。它采用的是联合查询（JOIN），很是适合此类查询需求。
User控制器部分:ThinkPHP\Weibo\Home\Controller\UserController.class.php
<?php namespace Home\Controller; use Think\Controller; use Home\Model\UserModel; class UserController extends Controller { public function index() { $user = D('UserView'); var_dump($user->select()); } }
User模型部分:ThinkPHP\Weibo\Home\Model\UserViewModel.class.php
<?php namespace Home\Model; use Think\Model; use Think\Model\ViewModel; class UserViewModel extends ViewModel { public $viewFields = array( 'User'=>array('id','user','email'), //user表显示id,user,email 'Card'=>array('code','_on'=>'User.id=Card.uid'), //card表关联,_on条件指向User.id=Card.uid'(没有身份证的用户被隐藏了) 'Content'=>array('content', '_on'=>'User.id=Content.uid'), ); }
访问：http://localhost/ThinkPHP/Home/User/返回
array (size=3)
0 =>
array (size=5)
'id' => string '1' (length=1)
'user' => string '用户西西1' (length=13)
'email' => string 'xixi1@xixi.com' (length=14)
'code' => string '110102' (length=6)
'content' => string '个人第一条留言' (length=21)
1 =>
array (size=5)
'id' => string '1' (length=1)
'user' => string '用户西西1' (length=13)
'email' => string 'xixi1@xixi.com' (length=14)
'code' => string '110102' (length=6)
'content' => string '个人第二条留言' (length=21)
2 =>
array (size=5)
'id' => string '1' (length=1)
'user' => string '用户西西1' (length=13)
'email' => string 'xixi1@xixi.com' (length=14)
'code' => string '110102' (length=6)
'content' => string '个人第三条留言' (length=21)
使用关联查询，显示User表且包含Card表关联的数据，未关联的则忽略。若是想把未关联的查询出来，可使用LEFT左查询。
<?php namespace Home\Model; use Think\Model; use Think\Model\ViewModel; class UserViewModel extends ViewModel { public $viewFields = array( 'User'=>array('id','user','email','_type'=>'LEFT'), //LEFT JOIN 'Card'=>array('code','_on'=>'User.id=Card.uid'), //card表关联,_on条件指向User.id=Card.uid'(没有身份证的用户被隐藏了) ); }
访问：http://localhost/ThinkPHP/Home/User/返回(带身份证的显示不带身份证的也显示)
array (size=4)
0 =>
array (size=4)
'id' => string '1' (length=1)
'user' => string '用户西西1' (length=13)
'email' => string 'xixi1@xixi.com' (length=14)
'code' => string '110102' (length=6)
1 =>
array (size=4)
'id' => string '2' (length=1)
'user' => string '用户西西2' (length=13)
'email' => string 'xixi2@xixi.com' (length=14)
'code' => string '110103' (length=6)
2 =>
array (size=4)
'id' => string '4' (length=1)
'user' => string '用户西西4' (length=13)
'email' => string 'xixi4@xixi.com' (length=14)
'code' => string '110104' (length=6)
3 =>
array (size=4)
'id' => string '3' (length=1)
'user' => string '用户西西3' (length=13)
'email' => string 'xixi3@xixi.com' (length=14)
'code' => null
使用group分组去除重复数据显示每一个用户最新一条留言：
ThinkPHP\Weibo\Home\Controller\UserController.class.php
<?php namespace Home\Controller; use Think\Controller; use Home\Model\UserModel; class UserController extends Controller { public function index() { $user = D('UserView'); //使用group分组去除重复数据 var_dump($user->group('id')->select()); } }
ThinkPHP\Weibo\Home\Model\UserViewModel.class.php
<?php namespace Home\Model; use Think\Model; use Think\Model\ViewModel; class UserViewModel extends ViewModel { public $viewFields = array( //LEFT JOIN 'User'=>array('id','user','email','_type'=>'LEFT'), 'Content'=>array('content', '_on'=>'User.id=Content.uid'), ); }
访问：http://localhost/ThinkPHP/Home/User/
array (size=4)
0 =>
array (size=4)
'id' => string '1' (length=1)
'user' => string '用户西西1' (length=13)
'email' => string 'xixi1@xixi.com' (length=14)
'content' => string '个人第一条留言' (length=21)
1 =>
array (size=4)
'id' => string '2' (length=1)
'user' => string '用户西西2' (length=13)
'email' => string 'xixi2@xixi.com' (length=14)
'content' => null
2 =>
array (size=4)
'id' => string '3' (length=1)
'user' => string '用户西西3' (length=13)
'email' => string 'xixi3@xixi.com' (length=14)
'content' => null
3 =>
array (size=4)
'id' => string '4' (length=1)
'user' => string '用户西西4' (length=13)
'email' => string 'xixi4@xixi.com' (length=14)
'content' => null
二．数据分页
ThinkPHP封装了数据分页功能，只要进行一些设置便可完成分页。
配置文件设置分页变量名:ThinkPHP\Weibo\Common\Conf\config.php
<?php return array( //'配置项'=>'配置值' //全局配置定义 'DB_TYPE'=>'mysql', //数据库类型 'DB_HOST'=>'127.0.0.1', //服务器地址 'DB_NAME'=>'thinkphp', //数据库名 'DB_USER'=>'xixi', //用户名 'DB_PWD'=>'123456', //密码 'DB_PORT'=>3306, //端口 'DB_PREFIX'=>'think_', //数据库表前缀 //页面Trace 'SHOW_PAGE_TRACE' =>true, //设置默认主题目录 'DEFAULT_THEME'=>'default', //设置分页变量名 'VAR_PAGE'=>'page', );
模版部分html5设置：ThinkPHP\Weibo\Home\View\default\User\index.html
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> <table border="1"> <tr><th>id</th><th>user</th><th>email</th></tr> <foreach name="list" item="obj"> <tr><td>{$obj.id}</td><td>{$obj.user}</td><td>{$obj.email}</td> </tr> </foreach> </table> <p>{$page}</p> </html>
User控制器部分设置：ThinkPHP\Weibo\Home\Controller\UserController.class.php
<?php namespace Home\Controller; use Think\Controller; use Home\Model\UserModel; use Think\Page; class UserController extends Controller { public function index() { $user = D('User'); $count = $user->count(); //获得有多少条数据 $page = new Page($count, 1); //每页显示2条 //设置分页参数 $page->setConfig('first','首页'); $page->setConfig('prev','上一页'); $page->setConfig('next','下一页'); $page->setConfig('last','末页'); $page->setConfig('theme', ' 共 %TOTAL_ROW% %HEADER% 共%TOTAL_PAGE%页 %FIRST% %UP_PAGE% %LINK_PAGE% %DOWN_PAGE% %END%'); //主题 $show = $page->show(); //一段html表分页按钮 $list = $user->order('date')->limit($page->firstRow.','.$page->listRows)->select(); //user指向limit方法从第几条$page->firstRow开始每页显示的总条数listRows，在显示出来select() $this->assign('list', $list); $this->assign('page', $show); $this->display(); } }
ThinkPHP--视图--缓存处理
ThinkPHP的缓存处理，提供了数据缓存、快速缓存、查询缓存、和静态缓存。
一．数据缓存
在ThinkPHP中，有一个专门处理缓存的类：Cache.class.php。而咱们使用的时候，并不须要直接声明它，直接使用一个大S()方法便可。
系统目前已经支持的缓存类型包括：Apachenote、Apc、Db、Eaccelerator、File、Memcache、Redis、Shmop、Sqlite、Wincache和Xcache。若是不初始化，会默认使用File文件缓存。
数据缓存设置方法：默认生成缓存在untime/Temp
<?php namespace Home\Controller; use Think\Controller; use Home\Model\UserModel; use Think\Page; //User控制器部分 class UserController extends Controller { public function index() { //读取缓存是否存在，不存在则设置 if (!$list = S('list')) { //当把S缓存方法赋给$list,而且里面没有东西 $user = D('User'); //执行sql语句获取数据 $list = $user->select(); S('list', $list, 30); //把数据放到缓存里(设置缓存30秒，生成加密的文件名，以JSON数据序列化保存起来的 } $this->assign('list',$list); //若是判断有缓存直接跳转到这里(执行缓存里的数据反序列化获得数据) $this->display(); } }
删除数据缓存方法：
<?php namespace Home\Controller; use Think\Controller; use Home\Model\UserModel; use Think\Page; //User控制器部分 class UserController extends Controller { public function index() { //读取缓存是否存在，不存在则设置 if (!$list = S('list')) { //当把S缓存方法赋给$list,而且里面没有东西 $user = D('User'); //执行sql语句获取数据 $list = $user->select(); S('list', $list, 30); //把数据放到缓存里(设置缓存30秒，生成加密的文件名，以JSON数据序列化保存起来的 } //删除缓存 S('list', null); $this->assign('list',$list); //若是判断有缓存直接跳转到这里(执行缓存里的数据反序列化获得数据) $this->display(); } }
二．快速缓存
若是不想设置有效期存储，可使用大F()方法的快速缓存。
<?php namespace Home\Controller; use Think\Controller; use Home\Model\UserModel; use Think\Page; //User控制器部分 class UserController extends Controller { //使用F()方法快速缓存 public function index() { if (!$list = F('list')) { $user = D('User'); $list = $user->select(); F('list', $list, TEMP_PATH); //自己放在Runtime/Data下的，手动设置到untime/Temp下 } //删除缓存 //F('list', null); $this->assign('list', $list); $this->display(); } }
三．查询缓存
对于及时性要求不高的数据查询，咱们可使用查询缓存功能来提升性能。
User控制器部分
<?php namespace Home\Controller; use Think\Controller; use Home\Model\UserModel; use Think\Page; class UserController extends Controller { public function index() { $user = D('User'); //查询SQL后缓存 //$list = $user->cache(true)->select(); //指定缓存的Key会更加高效 //$list = $user->cache('cache_user')->select(); //获取缓存 //var_dump(S('cache_user')); //删除缓存 //S('cache_user', null); $this->assign('list', $list); $this->display(); } }
除了查询缓存以外，对于SQL查询语句自己也有解析缓存，就是把SQL语句给缓存下来，下次执行就不须要再解析了。固然，若是使用了查询缓存自己，因为已经将内容缓存，因此解析缓存基本上用的较少。
四．静态缓存
所谓静态缓存，就是第一次访问PHP时生成一个纯静态文件。当第二次访问时，就直接访问这个静态文件。特别适合相似于CMS系统这种页面状态变化较少的程序。
配置文件设置静态缓存：ThinkPHP\Weibo\Common\Conf\config.php
<?php return array( //'配置项'=>'配置值' //全局配置定义 'DB_TYPE'=>'mysql', //数据库类型 'DB_HOST'=>'127.0.0.1', //服务器地址 'DB_NAME'=>'thinkphp', //数据库名 'DB_USER'=>'xixi', //用户名 'DB_PWD'=>'123456', //密码 'DB_PORT'=>3306, //端口 'DB_PREFIX'=>'think_', //数据库表前缀 //页面Trace 'SHOW_PAGE_TRACE' =>true, //设置默认主题目录 'DEFAULT_THEME'=>'default', //开启静态缓存 'HTML_CACHE_ON'=>true, //全局缓存过时时间60秒 'HTML_CACHE_TIME'=>60, //缓存的后缀 'HTML_FILE_SUFFIX'=>'.html', //缓存规则 'HTML_CACHE_RULES'=>array( //User控制器:index方法 //模块_控制器_方法_ID，局部60秒 'User:index'=>array('{:module}_{:controller}_{:action}_{id}',60), ), );
控制器部分访问：
<?php namespace Home\Controller; use Think\Controller; use Home\Model\UserModel; use Think\Page; class UserController extends Controller { public function index() { $user = D('User'); $list = $user->select(); $this->assign('list', $list); $this->display(); } }
生成的页面缓存放在：ThinkPHP\Weibo\Html\Home_User_index_.html
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Insert title her</title> </head> <body> <table border="1"> <tr><th>id</th><th>user</th><th>email</th></tr> <tr><td>1</td><td>用户西西1</td><td>xixi1@xixi.com</td> </tr><tr><td>2</td><td>用户西西2</td><td>xixi2@xixi.com</td> </tr><tr><td>3</td><td>用户西西3</td><td>xixi3@xixi.com</td> </tr><tr><td>4</td><td>用户西西4</td><td>xixi4@xixi.com</td> </tr></table> <p></p> </html>
除了上面的缓存规则，还有其余的缓存规格选择：
//方法名
'index'=>array('{id}', 60),
//控制器: //User目录下的 方法_ID
'User:'=>array('User/{:action}_{id}', 60),
//控制器名:方法名
'User:index'=>array('{id}', 60),
//将当前地址加密做为文件名
'*'=>array('{$_SERVER.REQUEST_URI|md5}'),
ThinkPHP--视图--调试方法
ThinkPHP的调试方法，包括各类调试配置和方法。
一．调试模式
ThinkPHP专门为开发过程而设置了调试模式，调试模式开启后，特别方便咱们进行排错和调整。但因为它执行效率会稍低，因此在正式部署项目的时候，关闭调试模式。
// 入口文件处，开启调试模式 建议开发阶段开启 部署阶段注释或者设为false
define('APP_DEBUG',true);
调试模式在开发中的优点在于：
1.开启日志记录，任何错误和调试信息都会详细记录；
2.关闭模版缓存，模版修改能够及时生效；
3.记录SQL日志，方便分析SQL；
4.关闭字段缓存，数据表字段修改不受缓存影响；
5.严格检查文件大小写，帮助提早发现Linux部署问题；
6.经过页面Trace功能更好的调试和发现问题。
二．异常处理
和PHP默认的异常处理不一样，ThinkPHP抛出的不单纯的错误信息，而是一我的性化的错误页面。固然，咱们也能够自行调用这种错误信息。
User控制器部分设置手动抛出异常
<?php namespace Home\Controller; use Think\Controller; use Home\Model\UserModel; use Think\Page; class UserController extends Controller { public function index() { //手动抛出异常 E('失败！'); } }
失败！
错误位置
三．模型调试
在模型操做中，为了更好的查明错误，常常须要查看下最近使用的SQL语句。
User控制器部分设置获取最近一次执行的SQL语句
<?php namespace Home\Controller; use Think\Controller; use Home\Model\UserModel; use Think\Page; class UserController extends Controller { public function index() { $user = D('User'); $list = $user->select(); //获取最近的SQL语句 echo $user->getLastSql(); } }
User控制器部分设置查看SQL的错误信息
<?php namespace Home\Controller; use Think\Controller; use Home\Model\UserModel; use Think\Page; class UserController extends Controller { public function index() { $user = D('User'); $list = $user->select(); //查看SQL的错误信息 $list = $user->query("SELECT * FROM bbb"); echo $user->getDbError(); } }
访问：http://localhost/ThinkPHP/index.php/Home/User/index/
1146:Table 'thinkphp.bbb' doesn't exist [ SQL语句 ] : SELECT * FROM bbb
四．性能调试
咱们可使用大G()方法，来测试某段代码的内存开销和运行时间。
User控制器部分设置计算运行时间和计算消耗内存
<?php namespace Home\Controller; use Think\Controller; use Home\Model\UserModel; use Think\Page; //User控制器部分 class UserController extends Controller { public function index() { //包裹要测试的代码 G('begin'); $user = D('User'); $list = $user->select(); $this->assign('list', $list); $this->display(); G('end'); //计算运行时间，单位秒 echo G('begin','end').'s'; echo '<br />'; //计算消耗内存，单位kb echo G('begin','end','m').'kb'; } }
执行http://localhost/ThinkPHP/index.php/Home/User/index/返回：
0.0270s
856kb
注意：若是你的环境不支持内存消耗测试，它会自动按时间运算。
五．变量调试
在开发中，咱们常常须要对变量进行调试。通常会采用PHP自带的var_dump()和print_r方法，ThinkPHP内置了一个对浏览器友好的dump()方法，用于输出变量信息。
User控制器部分设置dump()方法，输出变量信息
<?php namespace Home\Controller; use Think\Controller; use Home\Model\UserModel; use Think\Page; class UserController extends Controller { public function index() { $user = D('User'); $list = $user->select(); //参数1必选，其余可选 dump($list, true, null, false); //参数1为变量，参数2为是否打印，参数3标识，参数4是否采用print_r $this->assign('list', $list); $this->display(); } }
六．日志记录
日志处理是系统自动进行的，在开启日志记录的状况下，会记录下运行的日志级别的全部日志信息。
通常状况下，SQL日志级别必须在调试模式下开启有效，不然不会记录。默认状况下，通常在调试模式下记录日志，若是要在部署模式下开启日志记录，则须要进行配置。
ThinkPHP对系统的日志按照级别来分类，包括：
1.EMERG严重错误，致使系统崩溃没法使用
2.ALERT警惕性错误， 必须被当即修改的错误
3.CRIT临界值错误， 超过临界值的错误
4.ERR通常性错误
5.WARN警告性错误， 须要发出警告的错误
6.NOTICE通知，程序能够运行可是还不够完美的错误
7.INFO信息，程序输出信息
8.DEBUG调试，用于调试信息
9.SQL SQL语句，该级别只在调试模式开启时有效
配置文件部分设置运行的日志记录级别：ThinkPHP\Weibo\Common\Conf\config.php
<?php return array( //'配置项'=>'配置值' //全局配置定义 'DB_TYPE'=>'mysql', //数据库类型 'DB_HOST'=>'127.0.0.1', //服务器地址 'DB_NAME'=>'thinkphp', //数据库名 'DB_USER'=>'xixi', //用户名 'DB_PWD'=>'123456', //密码 'DB_PORT'=>3306, //端口 'DB_PREFIX'=>'think_', //数据库表前缀 //页面Trace 'SHOW_PAGE_TRACE' =>true, //设置默认主题目录 'DEFAULT_THEME'=>'default', //运行的日志记录级别 'LOG_LEVEL' =>'EMERG,ALERT,CRIT,ERR', );
User控制器部分添加手动写入日志方法
<?php namespace Home\Controller; use Think\Controller; use Home\Model\UserModel; use Think\Log; class UserController extends Controller { public function index() { $user = D('User'); $list = $user->select(); //手动写入，第二参数为级别，第三为强制 Log::record('手动日志','WARN',true); //不受配置文件影响(强制写入) //Log::write('日志','WARN'); $this->assign('list', $list); $this->display(); } }
生成日志：ThinkPHP\Weibo\Runtime\Logs\18_04_22.log
[ 2018-04-22T16:27:09+08:00 ] 127.0.0.1 /ThinkPHP/index.php/Home/User/index/
WARN: 手动日志
七．Track
ThinkPHP提供了一个很是方便的调试工具：页面Track。这个工具必须在调试模式下有效
配置文件设置Track调试模式
<?php return array( //'配置项'=>'配置值' //全局配置定义 'DB_TYPE'=>'mysql', //数据库类型 'DB_HOST'=>'127.0.0.1', //服务器地址 'DB_NAME'=>'thinkphp', //数据库名 'DB_USER'=>'xixi', //用户名 'DB_PWD'=>'123456', //密码 'DB_PORT'=>3306, //端口 'DB_PREFIX'=>'think_', //数据库表前缀 //页面Trace 'SHOW_PAGE_TRACE' =>true, //设置要显示的调试模块 'TRACE_PAGE_TABS'=>array( 'base'=>'基本', 'file'=>'文件', 'think'=>'流程', 'error'=>'错误', 'sql'=>'SQL', 'debug'=>'调试', 'user'=>'用户', ), //设置默认主题目录 'DEFAULT_THEME'=>'default', );
User控制器部分设置调试方法显示在用户里
<?php namespace Home\Controller; use Think\Controller; use Home\Model\UserModel; use Think\Log; class UserController extends Controller { public function index() { $user = D('User'); $list = $user->select(); //调试方法 trace('调试方法', '提示', 'user'); $this->assign('list', $list); $this->display(); } }
- 1. thinkPHP框架
- 2. ThinkPHP框架一
- 3. ThinkPHP框架
- 4. thinkphp框架（1）
- 5. thinkphp框架
- 6. ThinkPHP框架二
- 7. Thinkphp 框架基础
- 8. ThinkPHP---框架介绍
- 9. ThinkPHP框架漏洞
- 10. ThinkPHP框架学习
- 更多相关文章...
- • Docker 架构 - Docker教程
- • SSH框架（Struts2+Spring+Hibernate）搭建整合详细步骤 - Spring教程
- • 适用于PHP初学者的学习线路和建议
- • 常用的分布式事务解决方案
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. 安装cuda+cuDNN
- 2. GitHub的使用说明
- 3. phpDocumentor使用教程【安装PHPDocumentor】
- 4. yarn run build报错Component is not found in path “npm/taro-ui/dist/weapp/components/rate/index“
- 5. 精讲Haproxy搭建Web集群
- 6. 安全测试基础之MySQL
- 7. C/C++编程笔记：C语言中的复杂声明分析，用实例带你完全读懂
- 8. Python3教程(1)----搭建Python环境
- 9. 李宏毅机器学习课程笔记2：Classification、Logistic Regression、Brief Introduction of Deep Learning
- 10. 阿里云ECS配置速记
- 1. thinkPHP框架
- 2. ThinkPHP框架一
- 3. ThinkPHP框架
- 4. thinkphp框架（1）
- 5. thinkphp框架
- 6. ThinkPHP框架二
- 7. Thinkphp 框架基础
- 8. ThinkPHP---框架介绍
- 9. ThinkPHP框架漏洞
- 10. ThinkPHP框架学习