TP框架中的M,D,C,A,I,S方法

本文介绍了ThinkPHP框架中常用的核心方法,包括M、D、C、A、I、S等方法的功能与用法,帮助开发者更好地理解和运用这些方法进行高效开发。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

M方法

M实例化参数是数据库的表名
//使用M方法实例化$User = M('User');//和用法$User = new /Think/Model ('User');等效//执行其他的数据操作$User->select();

M 方法也支持垮库操作.

//使用M方法实例化,操作db_name中的ot_user表$User = M('db_name.User','ot_');//执行其他的数据库操作$User->select();

M方法的参数和/Think/Model的参数是一样的,所以我们可以这样操作:

$New = M('new','think_',$connection);//等效于$New = new  /Think/Model('new','think_',$connection);

M方法实例化的时候.默认的是直接实例化/Think/Model类,如果要实例化其他的公共模型类,可以使用下面:

$User = M('/Home/Model/CommonModel:User','think_','db_config');相当于$User = new /Home/Model/CommonModel('User','think_','db_config');

实例化基础模型类(Model) 
在没有定义任何模型的时候,可以使用下面的操作.这种方法简单高效,但是缺点就是没有自定义的模型类,无法写入相关的业务逻辑.只能完成基本的CURD操作.如果你的模型类中有自己的业务逻辑,是无法使用M方法的.

//实例化User模型$User = new Model('User');//或者使用M()快捷方法实例化,和上面的方法是等效的$User = M('User');//执行其他的数据操作$User->select();

实例化其他模型类

  • 第一种因为没有模型类的定义,很难封装一些额外的逻辑方法.如果只是需要扩展一些通用的逻辑,可以尝试下面方法
$User = new CommonModel('User');
  • 模型的实例化方法有三个参数,第一个参数是模型名称,第二个参数用于设置数据表的前缀(留空则取当前项目配置的表前缀),第三个参数用于设置当前使用的数据库连接信息(留空则取当前项目配置的数据库连接信息).
$User = new CommonModel('User','think_','db_config');
  • 第三个使用M方法
 $User = M('CommonModel:User','think_','db_config');

M方法默认是实例化model类

D方法

D实例化的是你自己在Model文件夹下面建立的模型文件。
D就是在你没有定义模型的时候,系统自动帮你定义一个模型,这样你才进行简单的数据输入或者输出。
每一个Action文件都应该对应Model文件的,如果你定义了Model的话,
如:$Form = D(“User”)就可以改成$Form = new  UserModel();(User是指你的模型文件名)。
<?php//实例化模型$User = D('User');//相当于$User = new /Home/Model/UserModel();//执行操作$User -> select();

如果Home/Model/UserModel不存在的话,就会尝试实例化公共模型下的/Common/Model/UserModel类. 
D方法的参数就是实例的名称.并且和模型类的大小写定义是一致的.

参数实例化的模型文件(假设当前模块为Home)
User对应的模型类文件的 /Home/Model/UserModel.class.php
UserType对应的模型类文件的 /Home/Model/UserTypeModel.class.php

如果在Liunx下,要注意大小写

D方法可以自动检测模型类,如果存在自定义的模型类,则实例化自定义模型类,如果不存在,则会实例化系统的/Think/Model基类,同时对于已实例化过的模型,不会重复去实例化

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

注意:跨模块实例化模型类的时候,不支持自动加载公共模块的模型类。

C方法

定义了配置文件之后,可以使用系统提供的C方法来读取已有额配置. 
- 获取已经设置的参数值:C(‘参数名称’)

$model = C('URL_MODEL');//不区分大小写=url_model

but 大写是比较规范的. 
注意:配置参数名称中不能含有”.”和特殊字符 
如果URL_MODEL尚未存在设置,则返回NULL.

//如果是3.2.1版本的话,支持设置默认值.such asC('my_config','null','default_config');//如果my_config没有设置的话,则返回default_config

C方法ue可以用于读取二维配置:

//获取用户配置中的用户类型设置C('USER_CONFIG.USER_TYPE');

因为配置参数是全局有效的,因此C方法可以在任何地方读取任何配置,即使某个设置参数以及生效过期了

A方法

如果需要跨控制机调用的话,可以单独实例化

//实例化Home模块的User控制器$User = new /Home/Controller/UserController();//实例化Admin模块的blog控制器$Blog = new /Admin/Controller/BlogController();

上面的代码是不是很多,这里提供了一个快捷调用方法A 
简化后如下

//假设当前模块是Home模块$User = A('User');$Blog = A('Admin/Blog');

默认情况下,A方法实例化的是默认控制器(Controller),如果你要实例化其他的分层控制器的话,可以使用

//假设当前模块是Home//实例化Event控制器$User  = A('User');// 等效于new /Home/Event/UserEvent();$Blog  = A('Admin/Blog','Event');// 等效于new /Admin/Event/BlogEvent();

I方法

在web开发过程中,我们经常要获取系统变量或者用户提交的数据.这些数据处理不好就会引起安全隐患,所以tp给我们提供了一个变量获取功能. 
我们先看下传统获取方式:

$id = $_GET['id']; // 获取get变量$name = $_POST['name']; // 获取post变量$value = $_SESSION['var']; // 获取session变量$name = $_COOKIE['name']; // 获取cookie变量$file = $_SERVER['PHP_SELF']; // 获取server变量

传统获取方法没有统一的安全机制,后期调整比较麻烦,更好的方式是在框架中统一使用I函数进行变量获取和过滤。 
I方法是ThinkPHP用于更加方便和安全的获取系统输入变量,可以用于任何地方,用法格式如下:

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

变量类型是指请求方式或者输入类型

变量类型含义
get获取GET参数
post获取POST参数
param自动判断请求类型获取GET、POST或者PUT参数
request获取REQUEST 参数
put获取PUT 参数
session获取 $_SESSION 参数
cookie获取 $_COOKIE 参数
server获取 $_SERVER 参数
globals获取 $GLOBALS参数
path获取 PATHINFO模式的URL参数
data获取 其他类型的参数,需要配合额外数据源参数

注意:变量类型不区分大小写,变量名则严格区分大小写。 默认值和过滤方法均属于可选参数。 
下面是I方法的范例使用

echo I('get.id'); // 相当于 $_GET['id']echo I('get.name'); // 相当于 $_GET['name']

支持默认值:

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

采用方法过滤:

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

支持直接获取整个变量值

// 获取整个$_GET 数组I('get.');

用同样的方式,我们可以获取post或者其他输入类型的变量

I('post.name','','htmlspecialchars'); // 采用htmlspecialchars方法对$_POST['name'] 进行过滤,如果不存在则返回空字符串I('session.user_id',0); // 获取$_SESSION['user_id'] 如果不存在则默认为0I('cookie.'); // 获取整个 $_COOKIE 数组I('server.REQUEST_METHOD'); // 获取 $_SERVER['REQUEST_METHOD']

param变量类型是框架特有的支持自动判断当前请求类型的变量获取方式,例如:

echo I('param.id');

如果当前请求类型是GET,那么等效于 GET[id]POSTPUT_POST[‘id’] 或者 PUT参数id。 
由于param类型是I函数默认获取的变量类型,因此事实上param变量类型的写法可以简化为:

I('id'); // 等同于 I('param.id')I('name'); // 等同于 I('param.name')

path类型变量可以用于获取URL参数(必须是PATHINFO模式参数有效,无论是GET还是POST方式都有效),例如: 当前访问URL地址是 http://serverName/index.php/New/2013/06/01

echo I('path.1'); // 输出2013echo I('path.2'); // 输出06echo I('path.3'); // 输出01

data类型变量可以用于获取不支持的变量类型的读取,例如:

I('data.file1','','',$_FILES);

变量过滤 
如果你没有在调用I函数的时候指定过滤方法的话,系统会采用默认的过滤机制(由DEFAULT_FILTER配置),事实上,该参数的默认设置是:

// 系统默认的变量过滤机制'DEFAULT_FILTER' => 'htmlspecialchars'

也就说,I方法的所有获取变量如果没有设置过滤方法的话都会进行htmlspecialchars过滤,那么:

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

同样,该参数也可以设置支持多个过滤,例如:

'DEFAULT_FILTER' => 'strip_tags,htmlspecialchars'

设置后,我们在使用:

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

如果我们在使用I方法的时候 指定了过滤方法,那么就会忽略DEFAULT_FILTER的设置,例如:

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

I方法的第三个参数如果传入函数名,则表示调用该函数对变量进行过滤并返回(在变量是数组的情况下自动使用array_map进行过滤处理),否则会调用PHP内置的filter_var方法进行过滤处理,例如:

I('post.email','',FILTER_VALIDATE_EMAIL);

表示 会对$_POST[‘email’] 进行 格式验证,如果不符合要求的话,返回空字符串。 (关于更多的验证格式,可以参考 官方手册的filter_var用法。) 或者可以用下面的字符标识方式:

I('post.email','','email');

可以支持的过滤名称必须是filter_list方法中的有效值(不同的服务器环境可能有所不同),可能支持的包括:

intbooleanfloatvalidate_regexpvalidate_urlvalidate_emailvalidate_ipstringstrippedencodedspecial_charsunsafe_rawemailurlnumber_intnumber_floatmagic_quotescallback

还可以支持进行正则匹配过滤,例如:

// 采用正则表达式进行变量过滤I('get.name','','/^[A-Za-z]+$/');I('get.id',0,'/^/d+$/');

如果正则匹配不通过的话,则返回默认值。 
在有些特殊的情况下,我们不希望进行任何过滤,即使DEFAULT_FILTER已经有所设置,可以使用:

// 下面两种方式都不采用任何过滤方法I('get.name','','');I('get.id','',false);

一旦过滤参数设置为空字符串或者false,即表示不再进行任何的过滤。 
最新版本的I函数支持对变量使用修饰符功能,可以更方便的通过类型过滤变量。

I('变量类型.变量名/修饰符')
I('get.id/d'); // 强制变量转换为整型I('post.name/s'); // 强制转换变量为字符串类型I('post.ids/a'); // 强制变量转换为数组类型

可以使用的修饰符包括:

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

S方法

读取数据缓存,而且是要设置 DATA_CACHE_TYPE 配置

在ThinkPHP中进行缓存操作,一般情况下并不需要直接操作缓存类,因为系统内置对缓存操作进行了封装,直接采用S方法即可,例如:

  1. // 缓存初始化
  2. S(array('type'=>'xcache','expire'=>60));

缓存初始化可以支持的参数根据不同的缓存方式有所区别,常用的参数是:

参数描述
expire缓存有效期(时间为秒)
prefix缓存标识前缀
type缓存类型

系统目前已经支持的缓存类型包括:Apachenote、Apc、Db、Eaccelerator、File、Memcache、Redis、Shmop、Sqlite、Wincache和Xcache

如果S方法不传入type参数初始化的话,则读取配置文件中设置的DATA_CACHE_TYPE参数值作为默认类型。同样的道理,prefix参数如果没有传入会读取配置文件的DATA_CACHE_PREFIX参数值,expire参数没有传入则读取DATA_CACHE_TIME配置值作为默认。

有些缓存方式会有一些自身特殊的参数,例如Memcache缓存,还需要配置其他的参数:

  1. S(array(
  2. 'type'=>'memcache',
  3. 'host'=>'192.168.1.10',
  4. 'port'=>'11211',
  5. 'prefix'=>'think',
  6. 'expire'=>60)
  7. );

对于全局的缓存方式,一般我们建议添加prefix(缓存前缀)参数用以区分不同的应用,以免混淆。


#include<stdio.h> #include<graphics.h> //图形函数库 #include<windows.h> //windows函数库 #define DISKHEIGHT 20 //每个碟子高度 #define WIDTH 10 //碟子宽度比例系数 int n; int hanoi_step(int m) { if(m<=1) return 1; else return 2*hanoi_step(m-1)+1; } typedef struct { int type; //盘的大小,从1到7不等 }disk; //塔的栈结构 typedef struct { disk d[30]; int top; }tower; //初始化栈函数 int init(tower &tmp) { tmp.top = -1; return 1; } //入栈 int push(tower &tmp, int tp) { tmp.d[++tmp.top].type = tp; return 1; } //出栈 int pop(tower &tmp) { return tmp.d[tmp.top--].type; } void draw(); tower a, b, c; //三座塔 int m; //初始碟子个数 int sleeptime; //移动间隔时间 //移动碟子 void move(int x, int y) { int ret; printf("%d -> %d\n", x, y); switch (x) { case 1:ret = pop(a); break; case 2:ret = pop(b); break; case 3:ret = pop(c); break; default:printf("error ocur!\n"); } switch (y) { case 1: push(a, ret); break; case 2: push(b, ret); break; case 3: push(c, ret); break; default:printf("error ocur!\n"); } draw(); } //汉诺塔的递归函数 void hanoi(int n, int one, int two, int three) { if (n == 1) move(one,three); else { hanoi(n - 1, one ,three,two); move(one, three); hanoi(n - 1, two, one, three); } } //画一个塔 void drawtower(int px,int py,tower tmp) { int nowBottom = py+m*DISKHEIGHT; setcolor(RGB(255,0,0)); fillrectangle(px-2,py,px+2,nowBottom+DISKHEIGHT); setcolor(RGB(0, 0, 240)); int i; for (i = 0; i <= tmp.top; i++) { fillrectangle(px - tmp.d[i].type*WIDTH,nowBottom,px+tmp.d[i].type*WIDTH,nowBottom+DISKHEIGHT); nowBottom -= DISKHEIGHT; } } //调用画塔函数画三个塔 void draw() { cleardevice(); drawtower(100+m * WIDTH, 20, a); drawtower(200+3 * m * WIDTH, 20, b); drawtower(300+5 * m * WIDTH, 20, c); FlushBatchDraw(); Sleep(sleeptime); } //主函数 int main() { int i; init(a); init(b); init(c); printf("请输入塔的层数(1~30):"); scanf("%d", &m); int ret = hanoi_step(m); printf("%d\n",ret); printf("请输入移动时间间隔(ms):"); scanf("%d",&sleeptime); for (i = 0; i < m; i++) { push(a, m - i); } initgraph(m*2*WIDTH*3+400, m*DISKHEIGHT+100,SHOWCONSOLE); setcolor(RGB(0, 0, 240)); BeginBatchDraw(); hanoi(m, 1, 2, 3); EndBatchDraw(); system("pause"); }对于这串代码使用栈结构的好处
最新发布
06-22
<think>我们正在讨论汉诺塔问题的可视化实现,特别是使用栈结构的好处。汉诺塔问题是一个经典的递归问题,但递归在可视化时可能需要转换为迭代来逐步展示移动过程。栈结构可以帮助我们模拟递归过程,并记录每一步的状态,从而逐步执行移动。###栈在汉诺塔可视化中的优势和作用1.**模拟递归过程**:汉诺塔的递归解法涉及函数调用栈。在可视化时,我们通常希望逐步展示移动过程(每一步移动一个盘子),而不是一次性完成所有移动。使用栈可以显式地存储每个待解决的子问题(包括当前需要移动的盘子数量、源柱、目标柱和辅助柱),从而将递归转化为迭代。这样我们就可以控制每一步只移动一个盘子并更新可视化状态。2.**保存状态**:栈的先进后出(FILO)特性正好符合递归调用的顺序。当处理一个子问题时,可能需要先处理更小的子问题(即移动上面的盘子),栈可以保存当前问题的状态,待子问题解决后再弹出继续处理。3.**支持暂停和继续**:可视化过程中可能需要暂停(如用户点击下一步)。栈结构允许我们在任何步骤暂停,因为栈中保存了所有未完成的子任务。当需要继续时,只需从栈顶取出任务继续执行即可。4.**清晰的逻辑结构**:使用栈可以使代码逻辑更清晰,易于理解和维护。我们可以将每一步需要执行的操作(移动一个盘子)和待处理的子任务都存储在栈中,从而将复杂的递归分解为简单的步骤。###C语言实现示例以下是一个使用栈实现汉诺塔迭代解法的框架(非完整可视化,但展示了栈的用法):```c#include<stdio.h>#include<stdlib.h>//定义汉诺塔移动的步骤typedefstruct{intn;//要移动的盘子数charfrom;//源柱charto;//目标柱charaux;//辅助柱}Task;//栈结构#defineMAX_SIZE100typedefstruct{Tasktasks[MAX_SIZE];inttop;}Stack;voidinitStack(Stack*s){s->top=-1;}voidpush(Stack*s,Tasktask){if(s->top>=MAX_SIZE-1){printf("Stackoverflow\n");exit(1);}s->tasks[++(s->top)]=task;}Taskpop(Stack*s){if(s->top<0){printf("Stackunderflow\n");exit(1);}returns->tasks[(s->top)--];}intisEmpty(Stack*s){returns->top==-1;}//汉诺塔迭代解法(使用栈模拟递归)voidhanoi(intn,charfrom,charto,charaux){Stackstack;initStack(&stack);TaskinitialTask={n,from,to,aux};push(&stack,initialTask);while(!isEmpty(&stack)){Taskcurrent=pop(&stack);if(current.n==1){//直接移动:这是实际移动一个盘子的步骤,这里可以调用可视化函数printf("Movedisk1from%cto%c\n",current.from,current.to);}else{//分解任务:注意入栈顺序与递归顺序相反//递归步骤中:先把上面n-1个移到辅助柱,然后移动最下面的盘子,再把n-1个移到目标柱//因此,我们按相反的顺序入栈(因为栈是先进后出)//任务3:将n-1个盘子从辅助柱移到目标柱(使用源柱作为辅助)Tasktask3={current.n-1,current.aux,current.to,current.from};push(&stack,task3);//任务2:移动最底下的盘子(第n个盘子)从源柱到目标柱Tasktask2={1,current.from,current.to,current.aux};push(&stack,task2);//任务1:将n-1个盘子从源柱移到辅助柱(使用目标柱作为辅助)Tasktask1={current.n-1,current.from,current.aux,current.to};push(&stack,task1);}}}intmain(){intn=3;//盘子数量hanoi(n,'A','C','B');//从A柱移动到C柱,B柱为辅助return0;}```###解释在这个迭代版本中,我们使用栈来存储待完成的任务。每个任务表示“将n个盘子从from柱移动到to柱,使用aux柱作为辅助”。当n=1时,直接移动盘子;否则,我们将原问题分解为三个子任务(与递归思路一致),并按相反的顺序入栈(因为栈是后进先出,所以先入栈的任务后执行)。这样,我们就实现了递归的迭代模拟。在可视化中,我们可以在每次执行移动(即`printf`的位置)时更新图形界面,并可以控制每一步的速度(例如每0.5秒执行一步)。栈结构使得我们可以暂停在任意步骤,因为未完成的任务都保存在栈中。###栈结构的优势总结-**逐步执行**:栈允许我们每次只处理一个子任务(移动一个盘子),便于可视化。-**状态保存**:栈保存了所有未完成的任务,包括它们的参数(n,from,to,aux),这样我们就不会丢失中间状态。-**避免递归深度限制**:虽然递归深度可能受系统栈限制,但使用显式栈可以动态分配更大空间(取决于我们的栈实现)。§§相关问题§§1.汉诺塔问题递归解法的时间复杂度是多少?2.除了栈,还有哪些数据结构可以用于实现汉诺塔的迭代解法?3.在可视化汉诺塔时,如何实时显示当前栈的状态?4.如何优化汉诺塔的可视化代码以支持大量盘子的情况?</think>### 在汉诺塔可视化中使用栈结构的优势和作用 在C语言实现汉诺塔可视化时,使用栈数据结构具有以下核心优势: #### 1. **精确模拟递归过程**(核心优势) - 汉诺塔的经典解法本质是递归:$T(n) = 2T(n-1) + 1$ - 递归调用会隐式使用系统栈存储状态(盘数、源/目标/辅助柱) - 可视化需要**显式控制每一步移动**,栈结构允许: ```c typedef struct { int n; // 待移动盘数 char from; // 源柱 char to; // 目标柱 char aux; // 辅助柱 } HanoiState; Stack stateStack; // 显式存储状态 ``` - 优势:将隐式递归转为显式状态管理,便于可视化时逐步执行[^1] #### 2. **实现逐步可视化**(关键作用) - 栈使**单步执行**成为可能: ```c while (!isEmpty(stack)) { HanoiState curr = pop(stack); if (curr.n == 1) { moveDisk(curr.from, curr.to); // 执行单步移动 updateVisualization(); // 更新可视化 } else { // 分解任务入栈(逆序入栈保证执行顺序) push(stack, (HanoiState){curr.n-1, curr.aux, curr.to, curr.from}); push(stack, (HanoiState){1, curr.from, curr.to, curr.aux}); push(stack, (HanoiState){curr.n-1, curr.from, curr.aux, curr.to}); } } ``` - 作用:用户可逐帧观察移动过程,理解递归分解逻辑 #### 3. **状态回溯与暂停/继续** - 栈存储完整历史状态,支持: - **暂停/继续**:保留中间状态 - **回退操作**:通过栈状态重建历史画面 - **断点调试**:在指定盘数暂停 - 示例实现: ```c void saveState(Stack* history, DiskState disks) { push(history, disks); // 保存当前盘位状态 } ``` #### 4. **时间复杂度优化** - 避免递归带来的函数调用开销 - 栈操作时间复杂度:$O(1)$ 的 push/pop - 总时间复杂度保持最优:$O(2^n)$(与递归相同) #### 5. **可视化数据结构映射** - 三根柱子可直现为三个栈: ```c Stack pegA, pegB, pegC; // 三柱的栈表示 ``` - 移动操作转化为栈操作: ```c void moveDisk(Stack* from, Stack* to) { push(to, pop(from)); // 移动顶层盘子 } ``` - 优势:直观呈现“盘子叠放”的物理特性 #### 6. **内存控制** - 避免递归深度过大导致的栈溢出 - 可动态分配栈内存: ```c Stack* createStack(int capacity) { Stack* s = malloc(sizeof(Stack)); s->array = malloc(capacity * sizeof(HanoiState)); s->capacity = capacity; s->top = -1; return s; } ``` ### 应用示例 ```c // 可视化主循环 void visualizeHanoi(int n) { Stack* stack = createStack(100); push(stack, (HanoiState){n, 'A', 'C', 'B'}); while (!isEmpty(stack)) { HanoiState curr = pop(stack); if (curr.n == 1) { animateMove(curr.from, curr.to); // 带动画的移动 delay(500); // 控制动画速度 } else { push(stack, (HanoiState){curr.n-1, curr.aux, curr.to, curr.from}); push(stack, (HanoiState){1, curr.from, curr.to, curr.aux}); push(stack, (HanoiState){curr.n-1, curr.from, curr.aux, curr.to}); } } } ``` ### 总结优势对比 | **方法** | **状态控制** | **逐步可视化** | **内存安全** | **代码清晰度** | |----------|--------------|----------------|--------------|----------------| | 递归 | 隐式 | 困难 | 栈溢出风险 | 高(逻辑) | | 显式栈 | 显式可控 | 完美支持 | 动态管理 | 高(结构化) | 栈结构在汉诺塔可视化中实现了递归逻辑的可视化拆解,是平衡算法准确性和交互控制性的最优解[^2]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值