After using the framework for a while, I suddenly realized that it seems that the core of the MVC framework is routing. Can you please enlighten me on the specific principles. For example, TP5 routing is very powerful, but the source code has basically no comments. After reading it for 2 hours, I still don’t understand the whole thing. What is the process like.

All I can do now is the pathinfo step. I can’t understand the various rule routing and regular routing that follow. I hope you can give me an implementation process, or a specific demo, or tutorial, or have relevant books. Yes O(∩_∩)O Thank you!

Reply content:

After using the framework for a while, I suddenly realized that it seems that the core of the MVC framework is routing. Can you please enlighten me on the specific principles. For example, TP5 routing is very powerful, but the source code has basically no comments. After reading it for 2 hours, I still don’t understand the whole thing. What is the process like.

All I can do now is the pathinfo step. I can’t understand the various rule routing and regular routing that follow. I hope you can give me an implementation process, or a specific demo, or tutorial, or have relevant books. Yes O(∩_∩)O Thank you!

In addition to reading other people's code, a better way is to open a debugger (such as xdebug) and perform single-step debugging. On the one hand, you have information from the debugger, and on the other hand, you have your own actual code that can be run. Use cases (the code you write for testing) can make it easier for you to understand

Back to the topic of routing, after all, you only need to figure out how to split and parse pathinfo. Directly mapping pathinfo to namespace or mapping to a controller through regular expressions are just one of the parsing methods

If you want to try to reinvent the wheel, you can try to implement the simplest method of directly mapping to a class under the namespace

hello/world -> HelloController->world()

test/hello/world -> testHelloController->world()

After the route is parsed, it is distributed. This is where you can learn about reflection, closure and other related knowledge

Finally, there are many components that only implement routers on github. Compared with the overall framework, you can also choose to read only the code of those components (for actual use, you can introduce it into your project through composer)

For example:

• https://github.com/nikic/Fast...

• https://github.com/dannyvanko...

• https://github.com/mrjgreen/p...

Recommend a routing implementation for you

https://github.com/bephp/router

1. The code is very short, about 100 lines

2. Supports get, post and other methods to define routes, as long as they are callable.

3. In addition to matching the parameter meanings in pathinfo, the parameters will also be automatically obtained through reflection. (This feature is more useful)

4. Uses a tree structure to store routing mapping table, which has better performance than several commonly used routes (with beachmark)

5. Supports "compilation", which is equivalent to caching routing tables to obtain faster performance

6. Can be installed using composer, zero dependencies

Of course, there is a simpler and more direct way

<code>class R{function($r,$c){$this->r[$r]=$c;} function($r){$this->r[$r]();}}
$r=new R;
$r->a('/', function(){echo 'hello world';});
$r->e('/');
</code>

The core idea of ​​MVC is to separate interface and logic. Personally, I think it has nothing to do with front-end routing. Front-end routing is just to unify the entrance.

Don’t think about the problem too complicated. It’s actually just extracting the string and then inserting it into the array. It’s actually just one line of code.

<code><?php
$_SERVER['REQUEST_URI'] = '/post/edit/1024?foo=bar';
$uri = explode('/', parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH));
var_export($uri);
//输出
array (
  0 => '',
  1 => 'post', //控制器(控制器存在就require)
  2 => 'edit', //方法
  3 => '1024', //参数(获取参数foo就用传统的$_GET['foo'])
)

$class = $uri[1];
require 'controller/'.$class.'.php'; // controller/post.php
$object = new $class();
$action = $uri[2];
$parameter = $uri[3];
echo call_user_func_array(array($object, $action), array($parameter)); //调用对象里的方法并传参

controller/post.php:
class post {
    public function edit($id) {
        return '$'.__CLASS__.'->'.__FUNCTION__.'('.$id.')'; //输出 $post->edit(1024)
    }
}</code>

This I recently wrote a small framework. The implementation of routing is relatively simple. I think it’s okay to take a look.
Address: https://github.com/zhoujiangy...
The route under the core folder is the routing implementation class

The basic idea is that the browser provides the name of the controller class and the name of the method through the URL string, and PHP finds the corresponding class and method accordingly.

The specific demo code can be clicked here, http://www.jianshu.com/p/d4ce...

You can try to look at ci's routing. There are multiple matching modes that use the iterator mode to iterate the custom routes and iterate out the values ​​that match the SERVER['REQUEST_URI'], that is, take out the controller and method, and Use the new class-> method or call_user_func() to call the corresponding method;

Spend money to watch the cloud purchase tutorial, the official has detailed routing instructions