PHP require vs include vs require_once vs include_once Explained

By the end of this page, you will understand how PHP loads files with require, include, require_once, and include_once, what happens when a file is missing, and how to choose the right one in real projects. You will also learn why the _once versions help prevent duplicate loading problems such as function redeclaration and repeated setup code.

PHP often splits code into multiple files:

• configuration files
• reusable functions
• templates and layouts
• database setup
• class definitions

To bring one file into another, PHP provides four related statements:

• require
• include
• require_once
• include_once

The core differences are about importance and duplication.

1. require vs include

Both load and execute another PHP file.

The important difference is what happens when the file cannot be loaded:

• require causes a fatal error and stops the script
• include causes a warning and the script usually continues

Use this rule:

• Use require for files your program must have to work
• Use include for files that are optional or non-critical

2. require_once vs

Think of your PHP app like preparing a presentation.

• require means: "I cannot give this presentation without this file."
• include means: "This file would be helpful, but I can continue without it."
• require_once means: "I must have this file, but only once."
• include_once means: "Add this file if possible, but never add it twice."

Another way to think about it:

• require = mandatory part
• include = optional part
• _once = prevent duplicates

So the decision has two layers:

1. Is the file required or optional?
2. Should it be loaded only once?

Core syntax

<?php
require 'file.php';
include 'file.php';
require_once 'file.php';
include_once 'file.php';

Example 1: Required file

<?php
require 'config.php';

echo "Application started";

If config.php is missing, PHP stops execution because the application depends on it.

Example 2: Optional file

<?php
include 'promo-banner.php';

echo "Main page content";

If promo-banner.php is missing, PHP shows a warning, but the rest of the page may still run.

Example 3: Prevent duplicate loading

helpers.php

<?php
{
      . (, );
}

Consider this example:

<?php
require_once 'functions.php';
include 'menu.php';
include 'menu.php';

echo sayHello();

Assume:

• functions.php defines a function sayHello()
• menu.php outputs some HTML menu

Step-by-step

Line 1

require_once 'functions.php';

• PHP looks for functions.php
• If found, PHP loads and runs it
• PHP remembers that this file has already been included
• If not found, PHP throws a fatal error and stops

Line 2

include 'menu.php';

• PHP looks for menu.php
• If found, PHP loads and runs it
• If the file prints HTML, that output appears immediately

Common situations

Application bootstrap

require_once 'config.php';
require_once 'database.php';
require_once 'router.php';

These files are essential. If one is missing, the app cannot run correctly.

Shared utility functions

require_once 'helpers.php';

Helpers often define functions. Loading them more than once can cause redeclaration errors, so _once is appropriate.

Layout pieces

include 'header.php';
include 'footer.php';

Header and footer files are often treated as display pieces. In some projects they are still required, but many examples use include because they are template fragments.

Optional page sections

include 'special-offer.php';

If this file is missing, the page can still function without the optional section.

Legacy PHP applications

In real codebases, developers usually choose based on criticality and safety.

Common pattern

<?php
require_once __DIR__ . '/config.php';
require_once __DIR__ . '/lib/database.php';
require_once __DIR__ . '/lib/helpers.php';

include __DIR__ . '/views/header.php';
include __DIR__ . '/views/page.php';
include __DIR__ . '/views/footer.php';

Why this pattern works

• require_once is used for files the app depends on
• include is used for view fragments that render output
• __DIR__ makes file paths more reliable

Guarding critical startup code

Important setup code is often loaded early:

<?php
require_once __DIR__ . '/bootstrap.php';

1. Using include for critical files

Broken example:

<?php
include 'database.php';
$db->query('SELECT 1');

If database.php is missing, the script may continue and then fail later with less clear errors.

Better:

<?php
require_once 'database.php';
$db->query('SELECT 1');

2. Including the same function file twice

Broken example:

<?php
require 'helpers.php';
require 'helpers.php';

If helpers.php defines functions, this can cause redeclaration errors.

Better:

<?php
require_once 'helpers.php';

Quick comparison

require vs include

Syntax

require 'file.php';
include 'file.php';
require_once 'file.php';
include_once 'file.php';

Meaning

• require = mandatory file
• include = optional file
• _once = only load one time

Missing file behavior

• require / require_once -> fatal error, script stops
• include / include_once -> warning, script may continue

Use this by default

require_once __DIR__ . '/config.php';
require_once __DIR__ . '/helpers.php';
include __DIR__ . '/header.php';
include __DIR__ . ;

What is the main difference between require and include in PHP?

require stops the script if the file cannot be loaded. include raises a warning and usually lets the script continue.

Should I use require_once by default in PHP?

For critical setup files like config, helpers, or bootstrap files, require_once is a safe default because it prevents duplicate loading.

When should I use include_once?

Use include_once when a file is optional but should not be loaded more than one time.

Can include load the same file multiple times?

Yes. Every include runs again unless you use include_once.

Why do duplicate includes cause errors?

If the included file defines functions, classes, or constants, loading it again may attempt to redefine them, which causes errors.

Is require_once always better than require?

Not always. If you intentionally want a file to run multiple times, use . But for dependency files, is often safer.

• PHP file inclusion — The broader idea of splitting code across multiple files and loading them.
• Scope in PHP — Included files interact with the variable scope of the calling file.
• Functions in PHP — Duplicate inclusion often causes function redeclaration errors.
• Classes and autoloading — Modern PHP often avoids manual class includes by using autoloaders.
• PHP error handling — Understanding warnings versus fatal errors helps explain include and require behavior.
• __DIR__ in PHP — Useful for building reliable file paths when including files.
• Bootstrap files — A common real-world use of require_once for application startup.