If you’re just at the beginning of your journey in PHP development, chances are that you use complete file names in the URL to navigate your application, like server/contact.php. No worries, we all started that way, and it’s how we learn.
Today, I want to help you improve how you navigate files in your application. We’ll be talking about routing, as it’s crucial in any modern application. It'll help you take a step forward in your professional PHP development.
A routing system simply maps an HTTP request to a request handler (function or method). In other words, it defines how we navigate or access different parts of an app without the need to type the file name. You can do this by creating or setting routes (or paths). For example, the route server/contact lets us access the contact.php file.
How Routing Works
First thing first, let me recall you what a routing is. Routing allows us to structure our app in a better way and get rid of messy URLs. These are two main features offered by any good routing system:
- Defines which action to run for each incoming request.
- Generates SEO-friendly URLs (e.g. /views/users instead of views/user.php?all).
To do a routing system, we need a router, which is no more than the entry file to our app. By default, this entry file is named as index.php. Inside the file, we define the routing system thanks to [switch](https://www.php.net/manual/en/control-structures.switch.php) or [match](https://www.php.net/manual/en/control-structures.match.php) statements.
Last but not least, we must redirect all requests to the router. This is done in the configuration file of the PHP server.
Project Setup
Before moving forward, let’s see what the project will look like:
File structure
Use the shell commands below to initiate the project:
mkdir?php-routing?&?cd?php-routingtouch?index.php?.htaccess
- .htaccess: A directory-level Apache configuration file. You don’t need it if you use an NGINX server.
- index.php: This is the router and entry file of the project. All incoming requests will be redirected here.
- views: This folder holds all the UIs for the project.
How to Redirect All HTTP Requests to the Router
We've said earlier that the redirection is done in the PHP server config file. So you'll need to make some tweaks depending on whether you use an Apache or NGINX server.
Redirect Using Apache
Here, we can easily use the .htaccess file that we have already created in the root of the project. Add the directives below:
mkdir?php-routing?&?cd?php-routingtouch?index.php?.htaccess
- line 1: We activate the Apache server’s runtime rewriting engine.
- line 2: We limit access to physical files.
- line 3: We redirect all the upcoming requests to the index.php.
Note: If the site or app is note at the root of the server (or if we don’t have a virtual host), here's what the .htaccess should look like:
RewriteEngine?On RewriteCond?%{REQUEST_FILENAME}?!-f RewriteRule?^(.*)$?index.php
In the code above, replace /folder/ with the name of the folder containing your site.
Redirect Using NGINX
The default configuration file is name nginx.conf. This file can be found in etc/nginx, usr/local/nginx/conf, or /usr/local/etc/nginx.
To redirect to index.php use the command below:
RewriteEngine?On RewriteBase?/folder/ RewriteRule?^index\.php$?-?[L]RewriteCond?%{REQUEST_FILENAME}?!-f RewriteCond?%{REQUEST_FILENAME}?!-d RewriteRule?.?/folder/index.php?[L]
The location / block specifies that this is a match for all locations unless explicitly specified location /
The try_files directive tells the server that for any request to the URI that matches the block in the location, try the $uri (or $uri/) first, and if the file is present, serve the file. Otherwise, the fallback option (index.php) is used. And this last behavior is what we want.
Reload the server after the modification.
How to Create the Routing System
We now know how routing works, and we are even sending all requests to the router. Now is the time to write the code for the router in index.php.
First, create a variable to hold the HTTP request string:
location?/?{ ????????try_files?$uri?$uri/?/index.php}
This variable will help us to compare with many routes (paths) and call the appropriate view interface.
$request?=?$_SERVER['REQUEST_URI'];
What's happening here? The switch statement is similar to a series of if statements on the same expression (variable). It executes a code only when a case statement is found whose expression evaluates to a value that matches the value of the switch expression. Let me illustrate this so that you can get it well.
Let's consider that our variable holds the value /views/users/. When the piece of the code above will be run, PHP will check if the value /views/users equals to the value of case statement, which in our case is /views/users. So, this condition will evaluate to true, PHP will call the file /views/users.php. If the condition evaluates to false, PHP will check for the next case statement until the end of the switch block.
Note: Every time the case statement evaluates to true PHP will continue to execute the code in the following case statements without necessary evaluating those case statements. In our case, PHP also requires views/dep.php. To avoid this "bad behavior", you must add break statement after each case statement.
Let now put everything together into our index.php file:
mkdir?php-routing?&?cd?php-routingtouch?index.php?.htaccess
As you already know, we start off by storing a user request in the $request variable, then we use it in the switch statement. For the sake of clean code, I have created a variable to hold the view directory name.
You'll also notice two other things:
- Both '' and '/' are used to match site.com as well as site.com/ for when users are in the root of the app or website.
- There's a special case statement, default, to match anything that wasn't matched by the other cases, i.e. when the route is unknown.
Let's now add some dummy data in our views.
Add Dummy Data in the Views Files
We have already created all files in the views directory. Let's just move to this directory and add some content in each file.
Just put some content in each file:
RewriteEngine?On RewriteCond?%{REQUEST_FILENAME}?!-f RewriteRule?^(.*)$?index.php
RewriteEngine?On RewriteBase?/folder/ RewriteRule?^index\.php$?-?[L]RewriteCond?%{REQUEST_FILENAME}?!-f RewriteCond?%{REQUEST_FILENAME}?!-d RewriteRule?.?/folder/index.php?[L]
location?/?{ ????????try_files?$uri?$uri/?/index.php}
$request?=?$_SERVER['REQUEST_URI'];
As you can see, each file just contains a title and a paragraph. Feel free to add whatever content you like and test the router.
Final thoughts
In this tutorial, you learned how to create a basic routing system from scratch, including:
- How to create a file named index.php at the root of the project. This is the router for your app.
- How to redirect all incoming requests to the router. You do this in the configuration file of your server.
- How to create the routing system with a switch statement in the router.
The above is the detailed content of How to Build a Routing System for a PHP App from Scratch. For more information, please follow other related articles on the PHP Chinese website!

Hot AI Tools

Undress AI Tool
Undress images for free

Undresser.AI Undress
AI-powered app for creating realistic nude photos

AI Clothes Remover
Online AI tool for removing clothes from photos.

Clothoff.io
AI clothes remover

Video Face Swap
Swap faces in any video effortlessly with our completely free AI face swap tool!

Hot Article

Hot Tools

Notepad++7.3.1
Easy-to-use and free code editor

SublimeText3 Chinese version
Chinese version, very easy to use

Zend Studio 13.0.1
Powerful PHP integrated development environment

Dreamweaver CS6
Visual web development tools

SublimeText3 Mac version
God-level code editing software (SublimeText3)

Hot Topics

The key to setting up PHP is to clarify the installation method, configure php.ini, connect to the web server and enable necessary extensions. 1. Install PHP: Use apt for Linux, Homebrew for Mac, and XAMPP recommended for Windows; 2. Configure php.ini: Adjust error reports, upload restrictions, etc. and restart the server; 3. Use web server: Apache uses mod_php, Nginx uses PHP-FPM; 4. Install commonly used extensions: such as mysqli, json, mbstring, etc. to support full functions.

The key to writing PHP comments is to clarify the purpose and specifications. Comments should explain "why" rather than "what was done", avoiding redundancy or too simplicity. 1. Use a unified format, such as docblock (/*/) for class and method descriptions to improve readability and tool compatibility; 2. Emphasize the reasons behind the logic, such as why JS jumps need to be output manually; 3. Add an overview description before complex code, describe the process in steps, and help understand the overall idea; 4. Use TODO and FIXME rationally to mark to-do items and problems to facilitate subsequent tracking and collaboration. Good annotations can reduce communication costs and improve code maintenance efficiency.

PHPblockcommentsareusefulforwritingmulti-lineexplanations,temporarilydisablingcode,andgeneratingdocumentation.Theyshouldnotbenestedorleftunclosed.BlockcommentshelpindocumentingfunctionswithPHPDoc,whichtoolslikePhpStormuseforauto-completionanderrorche

Comments cannot be careless because they want to explain the reasons for the existence of the code rather than the functions, such as compatibility with old interfaces or third-party restrictions, otherwise people who read the code can only rely on guessing. The areas that must be commented include complex conditional judgments, special error handling logic, and temporary bypass restrictions. A more practical way to write comments is to select single-line comments or block comments based on the scene. Use document block comments to explain parameters and return values at the beginning of functions, classes, and files, and keep comments updated. For complex logic, you can add a line to the previous one to summarize the overall intention. At the same time, do not use comments to seal code, but use version control tools.

The key to writing good comments is to explain "why" rather than just "what was done" to improve the readability of the code. 1. Comments should explain logical reasons, such as considerations behind value selection or processing; 2. Use paragraph annotations for complex logic to summarize the overall idea of functions or algorithms; 3. Regularly maintain comments to ensure consistency with the code, avoid misleading, and delete outdated content if necessary; 4. Synchronously check comments when reviewing the code, and record public logic through documents to reduce the burden of code comments.

TolearnPHPeffectively,startbysettingupalocalserverenvironmentusingtoolslikeXAMPPandacodeeditorlikeVSCode.1)InstallXAMPPforApache,MySQL,andPHP.2)Useacodeeditorforsyntaxsupport.3)TestyoursetupwithasimplePHPfile.Next,learnPHPbasicsincludingvariables,ech

ToinstallPHPquickly,useXAMPPonWindowsorHomebrewonmacOS.1.OnWindows,downloadandinstallXAMPP,selectcomponents,startApache,andplacefilesinhtdocs.2.Alternatively,manuallyinstallPHPfromphp.netandsetupaserverlikeApache.3.OnmacOS,installHomebrew,thenrun'bre

The key to writing PHP comments is clear, useful and concise. 1. Comments should explain the intention behind the code rather than just describing the code itself, such as explaining the logical purpose of complex conditional judgments; 2. Add comments to key scenarios such as magic values, old code compatibility, API interfaces, etc. to improve readability; 3. Avoid duplicate code content, keep it concise and specific, and use standard formats such as PHPDoc; 4. Comments should be updated synchronously with the code to ensure accuracy. Good comments should be thought from the perspective of others, reduce the cost of understanding, and become a code understanding navigation device.
