namespace app\controller; // 声明控制器的命名空间，对应于实际的文件夹结构

use think\Request; // 将其他命名空间的类拉到当前空间

前者是因为不同模块可能有重名的控制器，比如index控制器

后者只是纯导入要用到的

public function getUser(Request $request, UserService $userService, $id)

{

    $userId = $request->param('id', $id);

    return $userService->getUserInfo($userId);

}

// 路由定义：访问 /test 时自动注入 Request 实例，这里也能发现函数本身也是可以的

Route::get('test', function(Request $request) {

    return $request->url();

});

// 事件类和中间件需要使用过 handle 方法：

class UserLogin

{

    public function handle($user, Request $request)

    {

        $user->login_ip = $request->ip();

    }

}

class CheckLogin

{

    public function handle($request, \Closure $next, Request $req)

    {

        ...// 业务逻辑

        return $next($request);

    }

}

class Bar {} // 依赖类

class Foo {

    public function __construct(Bar $bar) {}

}

$foo=invoke('Foo');

// 相当于 $bar=new Bar ();$foo=new Foo ($bar)

// 如果是对其中的方法注入：

class Foo{

	public fuction bar(Bar $bar)

}

$foo=invoke(['Foo','bar']);

$result=invoke(fuction(Bar $bar){...})

class Bar{

	protect $key;

	public function __construct($key){

		$this->key=$key;

	}

}

...其余不变

$bar=new Bar('my_key');

$foo=new Foo($bar) / $foo=invoke('Foo',['bar'=> $bar]);

$bar= new Bar('my_key');

Container::set('Bar',$bar);// 把实例存入与类名相同的容器

// 由下面的容器绑定可知，相当于 bind ('Bar',$bar);

$foo=invoke('Foo'); // 直接注入

// 通过容器对象

$this->app->bind("think\Cache"."app\common\Cache");

// 给自定义的 Cache 绑定到原 think\Cache 标识

// 通过助手函数 bind

bind('cache','think\Cache');// 用 cache 标识 think、Cache

bind('sayhello',fuction($name){return 'hello'.$name});

随后使用：

$result=app('sayhello',['name'=>'ThinkPHP']);

$customCache = new think\Cache([

    'type' => 'redis',

    'host' => '127.0.0.1'

]);

bind('cache', $customCache);

// 后续调用

$cache = app('cache');

bind('think\LoggerInterface',"think\Log");

//think\LoggerInterface 接口使用 think\Log 实现

use think\LoggerInterface

这样的好处是，如果此后要更改实现函数，可以只修改bind。代码依赖抽象接口而非具体类

// 在 app/provider.php 定义，这个配置是全局而非单个应用的

return ['route' => \think\Route:class,'session'=> \think\Route\Session::class]

// 然后就可以直接使用

$route = app('route');

$cache1 = app('cache');

$cache2 = app('cache'); 

//$cache1===$cache2

$cache3=app('cache', [], true);

// 强制使用新的实例，[] 是参数，ture 表示不使用缓存。注意这只是单例，不一定覆盖缓存。

//$cache1!==cache3

$cache = app('org\utils\ArraryItem');

app()->cache;app()->cache=xxx

分别等价于

app()->get('cache');app()->bind('cache', ...)

// 可以 $app=app ();$app->cache

$app = app();

isset($app->cache);

$cach=app->cache;

// 可以使用依赖注入

app()->session->get('user_name');

Route::get('User/:id','index/Index/hello')->model('\app\index\model\User')

// 匹配路由规则，当用户访问 User/:id 时，自动获取:id 参数，并向 index/Index/hello 方法注入使用:id 创建的 '\app\index\model\User' 实例

class Index

{

    public function hello(User $user)

    {

        return 'Hello,'.$user->name;

    }

}

use think\Model;

use think\db\Query;

class User extend Model

{

    public static fuction __make(Query $query){

        return (new self()->setQuery($query));

    }

}

Container::getInstance()->resolving(fuction($instacne,$container){

	//$instance 刚创建的对象实例

	//$container 容器本身

	...

})

// 也可以针对某个类

Container::getInstance()->resolving(\think\Cache::class,fuction($instacne,$container){...})

//\think\Cache::class 等价于 \think\Cache，前者会把类型标识符转换为字符串

use think\facade\Route;

Route::rule('new/:id','News/read',"GET|POST");

// 将 /new/<xxx > 注册到 News 控制器下的 read 操作，即路由到 News/read/id/<xxx>

也可以

Route::get(...);

Route::post(...);

// 所有方法都有这样的用法

Route::rule('/','/index');

Route::rule('my',"Member/myinfo");

Route::rule('blog/:id$',"Blog/read");//$ 标识完全匹配

Route::rule('new/:year/:month/:day','Blog/read')

Route::rule('new/:id','News/read')->name('new_read');

url('new_read',['id'=>10]);

等价于：

url('News/read',['id'=>10]);

Route::get('blog/:id','Blog/read');

//对应的：

<?php

namespace app\index\controller;

class Blog{

	public fuction read($id)

	{

		return 'read'.$id;

	}

}

?>

Route::get('blog/:id','group.Blog/read');

对应实际路径：

app/controller/group/Blog.php

命名空间：

app\index\controller\group\Blog

调用其read方法，不同目录下可以有同名的控制器

Route::get('blog/:id','\app\index\service\Blog@read');

Route::view('blog/:id','index/hello'，[额外变量]);

Route::rule('hello/:name',fuction(Request $request,$name){...})

Route::get('blog/:id',\app\route\BlogDispatch::class);

// 对应的：

namespace app\route;

use think\route\Dispatch;

class BlogDispatch extends Dispatch

{

    public function exec()

    {

        // 自定义路由调度

    }

}

Route::redirect('blog/:id','xxxx',302)

Route::get('new/:id','News/read')->ext('html')->https();

#检测是否时 html 结尾，以及是否为 https，等价于：

Route::get('new/:id','News/read')->option(['ext'=>'html','https'=>true]);

->domain('news.thinkphp.cn') // 完整域名检测，也可以只是子域名，如 news

->json();

->filter(fuction($request){xxx});

->filter(\app\common\filter\NewsFilter::class . '@check');

//filter 默认只是预处理，不影响是否继续执行，除非其中 return;

//match 通过返回的 bool 值决定是否执行

Route::get('hello/:id', 'index/hello')->model('id','\app\index\model\User',false);

// 路由主键也是 id 时，第一个可以省略，第三个可选选项，false 表示没找到也不抛出异常，否则框架会直接抛 404

// 多个参数使用 & amp; 连接

->header(['Content-Type'=>'application/json']);

Route::rule('hello/:name','hello')->middleware(\app\middleware\Auth::class,"admin");

// 可以对路由分组

Route::group('blog',fuction(){

    Route::get(...);

    Route::put(...);

    ...

    Route::post(...)->withoutMiddleware();

})->middleware(...)->auto();

// 自动 URL 调度

'middleware'=>[...]

Route::group('blog',fuction(){

	Route::get(":id",'blog/read');

	Route::post("id","blog/update");

})->ext(html)->pattern(["id"=>"\d+"]);

// 等同于

Route::group('blog',fuction(){

	Route::get(":id",'read');

	Route::post("id","update");

})->prefix('blog/')->ext(html)->pattern(["id"=>"\d+"]);

请求/blog/article/detail/100自动调用app\controller\blog\ArticleController@detail(100)

// 可以看一下 url 和调用之间的关系！有命名约定

请求/blog/statistic自动调用Blog::statistic()

Route::resource('blog','Blog');

资源路由会自带一个同路由名的参数，使用->vars(['blog'=>'blog_id'])来变更其名

->only(['index','read','edit']);// 白

->except(['index','delete'])// 黑

Route::resource('blog', 'Blog');

Route::resource('blog.comment','Comment');

// 路由规则

blog/:blog_id/comment/:id

blog/:blog_id/comment/:id/edit

// 注意这里只是表面 comment 是 blog 子资源，并没有调用 BlogController

Route::domain('blog',fuction(){

	Route::rule("new/:id","new/read");

	Route::rule("user","user/info");

});

// 访问 blog.xxx.com/new/123, 映射到 news 控制器的 read 方法，id=123，第二个类似，防止路由冲突，多子域名传入数组，如 ['blog','admin']

Route::group(fuction(){

	...

})->crossDomainRule();

Route::domain('blog'.fuction(){

	...

})->layer('blog');

/*layer 会为当前域名的所有路由附加一个层级，正常是 app/controller/xxx

加上后是 app/blog/controller/xxx，相应的命名空间也从 app/controller 变为 app/blog/controller*/

Route::domain('test',response("NOT FOUND")->code(404));

// 直接返回的内容可以直接就是 html

Route::domain('test',json(['code'=>404,"msg"=> "NOT FOUND","data"=>null])->code(404));// 还是要手动设置状态码

Route::miss('public/miss');// 指定 public 控制器的 miss 方法处理

Route::miss(fuction(){return "xxx";});// 直接用闭包处理

Route::miss('public/miss', 'get');// 对于未匹配到的 get 请求

Route::group('blog',fuction(){

	Route::miss('blog/miss');

});

// 域名同理

<?php 

namespace app\[shop\]controller

class User{

	public function login(){

		return 'login';

	}

}

?>

//实际文件在app\[shop\]controller\User.php，多应用在URL中也会体现出来

<?php

namespace app\index\controller;

class Index{

	public function hello(){

		return 'hello,world';

	}

}

?>

json($data);

view();// 使用模板

Route::get("user/blog","user.blog/index");

namespace app\controller

class Error{

	public function __call($method,$args)

	{

		return "xxx";

	}

}

// 单应用模式，两个参数时强制传递的，便于得知出现了什么不存在的输入

Route::resource('blog', 'Blog');

// 注册资源路由，用法见上

namespace app\controller;

use app\middleware\Auth;

class Index{

	protected $middleware=[Auth::class];

    public function index(){...}

    public function hello(){...}

}

protected $middleware=[Auth::class.':admin'=>['except'=>['hello']],'Hello'=>['only'=>'hello'],];

// 后一个参数表示生效范围，前一个表示的是使用的方法，注意这里的 Auth::class 等和 'Hello' 等是并列的两个中间件，只是后者是别名并且无需传参

namespace app\http\middleware;

class Hello{

	public function handle($request,\Closure $next){

		$request->hello='xxx';

		return $next($request);

	}

}

public function index(Request $request){

	return $request->hello;

}

app('http')->getName();

Request::has('id','get');

// 可以检测：

get/post/put/request/cookie/server/session/env/file

Request::param();// 不加参数表示所有（经过过滤），参数为 false 则是包括过滤掉的，获取部分懒得说了

Request::only(['id','name']);

// 可以传第二个参数作为请求方法，第一个若是字典则值为默认值

$info = Request::header();

echo $info['accept'];

echo $info['accept-encoding'];

echo $info['user-agent'];

// 如果只要其中一个

Request::header('user-agent');

namespace app\controller;

class Index

{

    public function hello()

    {

        $data = ['name' => 'thinkphp', 'status' => '1'];

        return json($data);

    }

}

->code(404);

->data($data);// 设置原始数据，但是会根据前面的转换，并不一定是实际输出

->header(['Cache-control'=>'no-cache,must-revaildate']);

->redirect();// 站内可以直接 /xxx，也可以用 (string) url () 自动生成

->download('源文件路径，相对时通常是对应public/xxx','下载时显示');// 路径是服务器路径，不是 url, 可以结合 ->empire () 设置有效期。第二个参数可选。

->json($data,404);

$data="FLAG";

return download($data,'flag.txt',true)// 第三个参数为 true 来指定这种用法

return [

    'default'    =>    'mysql',

    'connections'    =>    [

        'mysql'    =>    [

            // 数据库类型

            'type'        => 'mysql',

            // 服务器地址

            'hostname'    => '127.0.0.1',

            // 数据库名

            'database'    => 'thinkphp',

            // 数据库用户名

            'username'    => 'root',

            // 数据库密码

            'password'    => '',

            // 数据库连接端口

            'hostport'    => '',

            // 数据库连接参数

            'params'      => [],

            // 数据库编码默认采用 utf8

            'charset'     => 'utf8',

            // 数据库表前缀

            'prefix'      => 'think_',

            // 重连

            'break_reconnect' => true,

            // 如果不能自动识别断线错误

            'break_match_str' => [

					'error with',

					],

        ],

        'potato' 		  => [

            'type'        =>'potato_database',

            ...

        ],

    ],

];

PDO::ATTR_CASE              => PDO::CASE_NATURAL,

// 控制字段大小写，此外还有 PDO::CASE_LOWER 和 PDO::CASE_UPPER

PDO::ATTR_ERRMODE           => PDO::ERRMODE_EXCEPTION,

// 处理错误，这里是抛出异常，此外还有 PDO::ERRMODE_SILENT,PDO::WARNING（只设置错误代码。警告）

PDO::ATTR_ORACLE_NULLS      => PDO::NULL_NATURAL,

// 只针对 ORACLE 数据库，对于空值的处理，PDO::NULL_TO_STRING,PDO::NULL_EMPTY_STRING

PDO::ATTR_STRINGIFY_FETCHES => false,

//true 时将所有数值类型都转换为字符串

PDO::ATTR_EMULATE_PREPARES  => false,

//true 时将使用 PDO 模拟预处理，可能导致 SQL 注入

Db::connect('potato')->table('user')->where('id',10)->find()

Db::connect()->close();

use think\facade\Db;

Db::table("potato")->where('id',1)->find/findOrEmpty/findOrfail();

//mysql:SELECT * FROM 'potato' WHERE "id" = 1 LIMIT 1, 注意限制一行，后两个分贝是没找到返回空数组，以及报错（而不是 find 的 null）

Db::table("potato")->where('status',1)->select/selectOrFail()->toArray();// 这个是返回对象

// 如果设置了前缀，使用 name 代替 table，否则都可以

->value('name');// 查询某个字段的值

->column('name','id');// 查找字段，可选的第二个参数作为索引，返回数组，查询列

显然;

->column('*','id'); // 不存在返回空

->lazyFields()->;// 不使用缓存，实时读取

Db::table('potato')->...->chunk(100,function($users){

    foreach ($users as $user){

        // 一次处理 100 个用户表数据，其中 return false 终止后续处理

    }

},<'create_time'>,<'desc'>);// 不指定按主键

// 也可以使用 cursor ()，省略

Db::name('user')->insert/save($data);//$data 为字典数组，save 会自动处理是 update 还是 insert，mysql 的 insert () 前加 replace () 类似

->insertGetId($data);// 插入并返回自增主键，而不是插入成功的数目

->strict(false)->insert($data);// 不存在就抛弃，而不是抛异常

->insertAll($data);// 将这个字典数组的数组中的全部插入，返回成功数

可以使用->limit(100)->insertAll($data);分批

->exp('name','UPPER(name)')// 对参数先用 SQL 函数处理，是 UPDATE ... SET=UPPER (name)...

也可以使用raw():

    ->update([

        'name'		=>	Db::raw('UPPER(name)'),

        'score'		=>	Db::raw('score-3'),

        'read_time'	=>	Db::raw('read_time+1')

    ])

传参也能用->exp($data)->，优先级不如自身传参

->dec/inc('score', 5)->// 第二个参数默认 1，单次更新可以 setInc/setDec, 此时无需 update，并且第三个参数延长更新（s）

// 根据主键删除

Db::table('think_user')->delete(1);

Db::table('think_user')->delete([1,2,3]);

// 条件删除    

Db::table('think_user')->where('id',1)->delete();

Db::table('think_user')->where('id','<',10)->delete();

Db::name('user')->delete(true);// 跑路

->union('SELECT name FROM think_user_2')->select()// 可以多个联合

->getOptions()// 查询生成的语句条件（json 格式）

$list = Db::name('user')->where('status',1)->order('id', 'desc')->paginate(10);// 一次显示 10 条，可以加第二个参数作为上限

Db::query("select * from think_user where status=:id", ['id' => 1]);

Db::event('before_select',function ($query){...})

namespace app\Model;

use think\Model;

class User extends Model

{

	protected $name='User';

    protected $table='User';

    protected static function init(){

        // 初始化，该方法只在第一次实例化时运行

        User::where('id','>',10)->select();

        // 等价于 Db::name ('user')->where ('id','>',10)->select ();

        // 此时的 name 和 table 都由上面的属性给出

    }

}

public function getTestFieldAttr($value,$data){

    return $this->invoke(function(Request $request) use($value,$data){return $data['name'].request->action();})

}

//invoke 的第二个参数用于传参，多个需要改成数组

protected $schema = [

        'id'          => 'int',

        'name'        => 'string',

        'status'      => 'int',

        'score'       => 'float',

        'create_time' => 'datetime',

        'update_time' => 'datetime',

    ];

// 实际上会自动获取，这样只是省去自动查询，部署后可以通过命令自己生成：

php think optimize:schema

$user=User::find(1);

echo $user->create_time;

echo $user->name;

等价于;

echo $user['create_time'];

echo $user['name'];

// 懒得解释

$user->getAttr('create_name');

$user=new User();

$user->name='thinkphp';

$user = new User();

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

$data['score'] = 100;

$user->data($data);

// 当存在第二个参数且为 true 时调用修改器，此时只是批量赋值，第三个参数是数组，作为过滤器，表示只设置其中的几个，忽略其他。注意如果没有第三个参数就是整体覆盖，没有在 $data 中重新赋值的部分数据会被清除

$user = new User();

$user->group_id = 1;

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

$data['score'] = 100;

$user->appendData($data); // 如果调用 data , 则清空 group_id 字段数据

// 如果是已有的属性，会覆盖对应的部分，同样可以指定第二个参数 true

$user->save();

// 也可以直接对 save 传入字典来批量赋值。还可以传入对象实例，只写入已有字段。可以指定字段：

$user->allowField(['name','email'])->save($_POST);

这种情景下可以等价为;

$data=Request::only(['name','email']);

$user->save($data);//save 新增数据会返回布尔值

namespace app\model;

use think\Model;

class User extends Model{

	protected $type = [

		'status' => 'integer',

		'score' => 'float',

		'birthday' => 'datatime',

		'info' => 'array'

        ]

}

class User extends Model

{

	protected $dataFormat = 'Y/m/d';

	protected $type = [

		'birthday' => 'timestamp',

	];

// 此时如果调用 User::find (1)->birthday; 输出 2025/11/1

<p>你是：{$user->full_name}</p>

public function getFullNameAttr(){

    $user=User::find(1);

    View::assign('user',$user);// 将此处的 $user 变量赋值给视图中的

	return View::fetch();

}

EVENT::listen('app\model\User.BeforeUpdate',function($user){});

EVENT::listen('app\model\User.AfterDelete',function($user){});

class User extends Model

{

	public static fuction onBeforeUpdate($user){

		return false

	}

}

$user->withEvent(false)->save()

namespace app\observer;

use app\model\User;

class UserObserver{

	public function onBeforeUpdate(User $user){...}

}

// 注意这里的 user 是怎么来的

protected $eventObserver = UserObserver::class

$user=User::find(1);

$user->profile;

$user->profile->moblie;

// 实际的定义可能是：

class User extends Model{

    $name="potato"

    public function profile(){

        return $this->hasOne(Profile::class);

//hasOne 方法用户返回关联对象，即 think\model\relation\HasOne 实例

// 关联字段默认是 id, 也就是说 Profile 的 user_id 对应 User 表的 id，可以是使用第二个参数指定

    }

}

class Profile extends Model{

    $moblie=123456789;

}

->belongsTo(User::class)

$profile->user->name;

use think\model\concern\Virtual;

class User extends Model{

	use Virtual;

	public function blog(){

		return $this->hasMany('Blog','user_id');

        // 关联普通模型 Blog 的 blog 数据表，依赖 user_id 字段

	}

}

// 直接使用实例

$data = ['name' => 'potatowo'];

$user=User::create($data);

$user->name="potato";

$user->save();// 这里即使 save，属性也会改变，但是不会触发事件

$user->blog/blog()->where("create_time",">","2025-11-2")->select();

//blog () 关联方法到 blog 关联属性的转换会将驼峰变成_+ 小写，比如 userProfile () 对应 user_profile

$user->profile->save(['email'=>'potato']);

$blog->together(['content'=>['titile','content']])->save()

// 关联保存

View::assign("name","POTATOWO");// 批量使用数组

return View::fetch('index',['name'=>'potatowo']);// 模板输出

return view(同fetch);// 使用助手函数

//assgin 方法是全局赋值，fetch/view 中则是单次

return View::display($content,[...])// 直接渲染对应内容

View::filter(function($content){

       return str_replace("\r\n",'<br/>',$content);

})->fetch();

或者;

view()->filter(...)

'view_dir_name'=>'templates'

public function index(){

	View::config(['view_path'=>'mypath']);

    return View::fetch()

}

'view_depr'=>'3'//1 是默认的，2 是直接全部转小写，3 不变，也可以指定字符，比如_, 会使得 member/read 变成 member_read

fetch('member/read');// 访问其他控制器下的模板

fetch(admin@member/edit);// 访问其他应用或者模块的模板

fetch('/menu');// 直接从视图根目录开始读

fetch('../template/public/menu.tpl')// 相对于当前项目入口的位置（即 public/xxx.php）