Have you ever opened a page on your own site and found it completely blank, no error message, nothing at all? You check the code, everything looks fine, the server is up and running, but the page simply won't load anything. After twenty minutes of chasing the bug, you realize the problem was in a file that shouldn't have been optional at all: the database connection file, brought in with a simple `include`. Since it no longer existed at that path, PHP quietly logged a warning somewhere in the background and kept trying to render a page that, without a database, had absolutely nothing to show. That story basically sums up the difference between `include` and `require`, and it's exactly the kind of situation almost every PHP developer has lived through at some point. Let's break it down here, no fluff, with examples you can test right now in your local environment. ## What include and require actually are Both do essentially the same thing: they take the content of a PHP file and "paste" it in at the point where they were called, as if you had manually copied and pasted the code yourself. That's how you split your project into smaller pieces, a header file, a footer, a database configuration, a reusable class, without having to rewrite everything on every single page. So the question is: if they do the same thing, why do two different commands exist? The answer lies in what happens when the file you're trying to include doesn't exist. ## The difference that actually matters: fatal error versus warning Here's the core of everything. When PHP can't find the file you asked it to include, the behavior changes completely depending on which of the two you used. With `include`, PHP throws a `Warning` and keeps executing the rest of the script normally, as if nothing happened. With `require`, PHP throws a `Fatal error` and stops the script's execution immediately, right there, without moving on to the next line. See the difference in practice: ```php <?php echo "Start of the page\n"; include 'file-that-does-not-exist.php'; echo "This line still runs\n"; ``` Running this code, you'd see something like this in the browser or terminal: ``` Start of the page Warning: include(file-that-does-not-exist.php): Failed to open stream... This line still runs ``` Now just swap `include` for `require`: ```php <?php echo "Start of the page\n"; require 'file-that-does-not-exist.php'; echo "This line never runs\n"; ``` The result changes drastically: ``` Start of the page Fatal error: Uncaught Error: Failed opening required 'file-that-does-not-exist.php' ``` That last `echo` line never even gets executed. The script simply dies right there. ## When to use include Use `include` for files whose absence doesn't compromise the essential functioning of the page. Think of decorative or supplementary elements: a promotional banner, a sidebar with recommended posts, an ad block, a social media widget. If that piece disappears, the page loses a bit of charm, but it keeps working and still delivers what the visitor came for. ```php <?php include 'components/recommended-sidebar.php'; ``` If this file doesn't exist for some reason, the visitor can still read the page's main content. They just won't see the recommendations on the side, and they probably won't even notice. ## When to use require Use `require` for anything essential, anything that, if missing, makes the page useless or unsafe to keep running. The most classic example is exactly the one from our opening story: the database connection file. ```php <?php require 'config/database.php'; require 'classes/User.php'; $user = new User($connection); ``` If `database.php` doesn't exist, there's no point in the page continuing to run, since everything that comes after depends on it. Letting the script move forward in that scenario, as `include` would, would only postpone the problem and make it harder to trace, since the real error would show up much further down the line, far from its actual cause. ## What about include_once and require_once Beyond the two basic versions, PHP also offers `include_once` and `require_once`. The difference is simple: they do exactly the same thing as the regular versions, but with an extra safeguard that prevents the same file from being included twice in the same script. This avoids a pretty common and frustrating error, especially when you have files that include each other. Imagine two pages that both need the same class: ```php <?php // page1.php require 'classes/User.php'; require 'utils/helpers.php'; // utils/helpers.php also includes the same class require 'classes/User.php'; ``` Without `_once`, PHP would try to declare the `User` class twice and would throw an error along the lines of `Cannot redeclare class User`. Swap it for `require_once`, and PHP checks whether that file has already been loaded before, and if it has, it simply skips the second call without any drama. ```php <?php require_once 'classes/User.php'; ``` In practice, for classes and files that define functions, it's almost always safer to just default to the `_once` version, avoiding this kind of conflict before it even happens. ## The classic beginner mistake A very common scene among people learning PHP: they use `include` for everything, no distinction, because some tutorial once taught them it "doesn't really matter." It works fine for weeks, until the day an essential file gets renamed, moved to another folder, or accidentally deleted during some cleanup. The application stays "up," except now it's serving broken pages, missing pieces, forms that submit nothing, and no visible error pointing to the cause. That's the kind of silent bug that makes good developers lose hours hunting in the wrong place. And it's entirely avoidable just by paying attention to which of the two commands to use in each situation. ## Performance: does it actually change anything? You might come across discussions claiming one is faster than the other. In practice, that difference is irrelevant to the day-to-day performance of any real application. The choice between `include` and `require` should never be about performance, it should be about what you want to happen when the file isn't found. File inclusion performance in PHP depends far more on factors like opcache, the number of files involved, and your autoload structure than on which keyword you chose. ## Quick reference table <table> <thead> <tr> <th>Command</th> <th>File not found</th> <th>Checks for duplicates</th> <th>Typical use</th> </tr> </thead> <tbody> <tr> <td><code>include</code></td> <td>Warning, script continues</td> <td>No</td> <td>Optional elements</td> </tr> <tr> <td><code>require</code></td> <td>Fatal error, script stops</td> <td>No</td> <td>Essential files</td> </tr> <tr> <td><code>include_once</code></td> <td>Warning, script continues</td> <td>Yes</td> <td>Reused optional functions/components</td> </tr> <tr> <td><code>require_once</code></td> <td>Fatal error, script stops</td> <td>Yes</td> <td>Essential reused classes and configs</td> </tr> </tbody> </table> ## The golden rule so you never mess this up again Whenever you're unsure which one to pick, ask yourself a simple question: "if this file doesn't exist, does the page still make sense to the user?" If the answer is yes, use `include`. If the answer is no, use `require`. And for anything that defines classes or functions and might end up getting called more than once in the same flow, it's almost always worth going straight for the `_once` version. That rule alone already prevents most of the silent bugs that make so many people waste time hunting down a problem that, deep down, was really just the wrong command choice. Have you ever fallen into that `include` trap on a file that turned out to be essential? Tell us in the comments how the bug hunt went, there's always a good story behind these. And if you've got your own rule of thumb for choosing between the two, or a PHP quirk that tripped you up in a similar way, drop it below too, that's exactly the kind of thing worth passing on to the next person about to make the same mistake.