


What you should know about the correct usage of require() file inclusion in PHP_PHP Tutorial
When I looked at some PHP framework source codes in the past, it was strange that dirname (__FILE__) was used to piece together the file path when the file was included. I didn’t know what the benefits of doing so were, but I finally discovered the reason.
Let’s look at a simple example:
There are three php files a, b, c. a.php is in the root directory of the website, b.php is in the b folder - b/b.php, and c.php is in the c folder - c/c.php. Some confusion? It’s clear when you look at the picture:
Both a.php and b.php include c.php, and finally c.php includes a php file in the d folder - d/d.php.
Let’s take a look at a.php first:
<span 1</span> <?<span php </span><span 2</span> <span 3</span> <span $file_name</span> = 'a.php'<span ; </span><span 4</span> <span 5</span> <span echo</span> "this is a.php"<span ; </span><span 6</span> <span echo</span> "<hr>"<span ; </span><span 7</span> <span 8</span> <span require</span>('c/c.php'<span ); </span><span 9</span> <span 10</span> ?>
This is a very simple code. After printing, it contains c/c.php. Next, we need to look at c/c.php:
<?<span php </span><span $c_file_name</span> = 'c.php'<span ; </span><span echo</span> 'this is c.php, is required by ' . <span $file_name</span><span ; </span><span echo</span> "<hr>"<span ; </span><span require</span>('../d/d.php'<span ); </span>?>
Print output "this is c.php, is required by a.php", $file_name is a variable defined in a.php. At the end, d.php is included. Because the d folder is one layer above the current c.php file, according to common sense, we will write the path as "../d/d.php" as a matter of course. But unfortunately, an error will be reported. The reason is that when you include other files in an included file such as c.php, the path is relative to the outermost parent file, that is, relative to a.php, which can be understood as because you are included by me. , so you have to rely on me. It seems very mysterious, but the principle is actually very simple: you can think of require('c/c.php'); as the code in the c/c.php file, so that our a.php can look like this:
<?<span php </span><span $file_name</span> = 'a.php'<span ; </span><span echo</span> "this is a.php"<span ; </span><span echo</span> "<hr>"<span ; </span><span //</span><span require('c/c.php');</span> <span $c_file_name</span> = 'c.php'<span ; </span><span echo</span> 'this is c.php, is required by ' . <span $file_name</span><span ; </span><span echo</span> "<hr>"<span ; </span><span require</span>('../d/d.php'<span ); </span>?>
At this point, you can see that when we want to include the d/d.php file, is the path just now wrong? Because now we are in the a.php code, we are relative to the a.php file, of course, the path should be require('d/d.php'); We modify the code as follows:
<?<span php </span><span $file_name</span> = 'a.php'<span ; </span><span echo</span> "this is a.php"<span ; </span><span echo</span> "<hr>"<span ; </span><span //</span><span require('c/c.php');</span> <span $c_file_name</span> = 'c.php'<span ; </span><span echo</span> 'this is c.php, is required by ' . <span $file_name</span><span ; </span><span echo</span> "<hr>"<span ; </span><span require</span>('d/d.php'<span ); </span>?>
At this point, you haven’t understood the meaning yet, so you need to look down. Let’s look at b/b.php:
<?<span php </span><span $file_name</span> = 'b.php'<span ; </span><span echo</span> "this is b.php"<span ; </span><span echo</span> "<hr>"<span ; </span><span require</span>('../c/c.php'<span ); </span>?>
No need to explain, there is no problem, but when you replace require('../c/c.php'); with the code in c/c.php, you will find the problem , note that we have just modified the code in c/c.php and changed require('../d/d.php'); to require('d/d.php'); See what is included below Code:
<?<span php </span><span $file_name</span> = 'b.php'<span ; </span><span echo</span> "this is b.php"<span ; </span><span echo</span> "<hr>"<span ; </span><span //</span><span require('../c/c.php');</span> <span $c_file_name</span> = 'c.php'<span ; </span><span echo</span> 'this is c.php, is required by ' . <span $file_name</span><span ; </span><span echo</span> "<hr>"<span ; </span><span require</span>('d/d.php'<span ); </span>?>
So, compared to b/b.php, the path of require('d/d.php'); is wrong, it should be require('../d/d.php');. You go back and modify the require path in c/c.php, but it’s wrong. After you modify it, b/b.php can run normally, but a/a.php can’t. Is it true that they share c/c? .php, it affects the whole body, what should I do?
At this time, we return to the dirname(__FILE__) mentioned at the beginning of the article. This is a good thing and can completely solve the above problems. Using it, you don't need to worry about which file contains your file and which path it is under. You don't need to worry about the level of the parent file, because dirname(__FILE__) can specify the path relative to the current file. In other words, we need to change the require path in our c/c.php to:
<?<span php </span><span $c_file_name</span> = 'c.php'<span ; </span><span echo</span> 'this is c.php, is required by ' . <span $file_name</span><span ; </span><span echo</span> "<hr>"<span ; </span><span require</span>(<span dirname</span>(<span __FILE__</span>) . '/../d/d.php'<span ); </span>?>
Here, we only need to use c/c.php as a reference. Compared to it, d/d.php is at the upper level. In this way, there is only one standard, and that is, I shall prevail. Whether you include me or he includes me, I only use myself as the criterion, and the files I want to include are only relative to myself.
For fellow practitioners who don’t understand dirname(__FILE__), please google it, it’s very simple.
Okay, this ends the PHP technology sharing. If you have any questions or errors, please leave a message. By the way, this is my first standard technical blog post. The first article is hydrology, the second article is quasi-technical, and today I finally wrote a technical article, Ou Ye.

PHPsessionstrackuserdataacrossmultiplepagerequestsusingauniqueIDstoredinacookie.Here'showtomanagethemeffectively:1)Startasessionwithsession_start()andstoredatain$_SESSION.2)RegeneratethesessionIDafterloginwithsession_regenerate_id(true)topreventsessi

In PHP, iterating through session data can be achieved through the following steps: 1. Start the session using session_start(). 2. Iterate through foreach loop through all key-value pairs in the $_SESSION array. 3. When processing complex data structures, use is_array() or is_object() functions and use print_r() to output detailed information. 4. When optimizing traversal, paging can be used to avoid processing large amounts of data at one time. This will help you manage and use PHP session data more efficiently in your actual project.

The session realizes user authentication through the server-side state management mechanism. 1) Session creation and generation of unique IDs, 2) IDs are passed through cookies, 3) Server stores and accesses session data through IDs, 4) User authentication and status management are realized, improving application security and user experience.

Tostoreauser'snameinaPHPsession,startthesessionwithsession_start(),thenassignthenameto$_SESSION['username'].1)Usesession_start()toinitializethesession.2)Assigntheuser'snameto$_SESSION['username'].Thisallowsyoutoaccessthenameacrossmultiplepages,enhanc

Reasons for PHPSession failure include configuration errors, cookie issues, and session expiration. 1. Configuration error: Check and set the correct session.save_path. 2.Cookie problem: Make sure the cookie is set correctly. 3.Session expires: Adjust session.gc_maxlifetime value to extend session time.

Methods to debug session problems in PHP include: 1. Check whether the session is started correctly; 2. Verify the delivery of the session ID; 3. Check the storage and reading of session data; 4. Check the server configuration. By outputting session ID and data, viewing session file content, etc., you can effectively diagnose and solve session-related problems.

Multiple calls to session_start() will result in warning messages and possible data overwrites. 1) PHP will issue a warning, prompting that the session has been started. 2) It may cause unexpected overwriting of session data. 3) Use session_status() to check the session status to avoid repeated calls.

Configuring the session lifecycle in PHP can be achieved by setting session.gc_maxlifetime and session.cookie_lifetime. 1) session.gc_maxlifetime controls the survival time of server-side session data, 2) session.cookie_lifetime controls the life cycle of client cookies. When set to 0, the cookie expires when the browser is closed.


Hot AI Tools

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

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

Undress AI Tool
Undress images for free

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

EditPlus Chinese cracked version
Small size, syntax highlighting, does not support code prompt function

MantisBT
Mantis is an easy-to-deploy web-based defect tracking tool designed to aid in product defect tracking. It requires PHP, MySQL and a web server. Check out our demo and hosting services.

SAP NetWeaver Server Adapter for Eclipse
Integrate Eclipse with SAP NetWeaver application server.

mPDF
mPDF is a PHP library that can generate PDF files from UTF-8 encoded HTML. The original author, Ian Back, wrote mPDF to output PDF files "on the fly" from his website and handle different languages. It is slower than original scripts like HTML2FPDF and produces larger files when using Unicode fonts, but supports CSS styles etc. and has a lot of enhancements. Supports almost all languages, including RTL (Arabic and Hebrew) and CJK (Chinese, Japanese and Korean). Supports nested block-level elements (such as P, DIV),

MinGW - Minimalist GNU for Windows
This project is in the process of being migrated to osdn.net/projects/mingw, you can continue to follow us there. MinGW: A native Windows port of the GNU Compiler Collection (GCC), freely distributable import libraries and header files for building native Windows applications; includes extensions to the MSVC runtime to support C99 functionality. All MinGW software can run on 64-bit Windows platforms.
