Delicious Bookmark this on Delicious Share on Facebook SlashdotSlashdot It! Digg! Digg

PHP : Language Reference : Control Structures : include


The include() statement includes and evaluates the specified file.

The documentation below also applies to require(). The two constructs are identical in every way except how they handle failure. They both produce a Warning, but require() results in a Fatal Error. In other words, use require() if you want a missing file to halt processing of the page. include() does not behave this way, the script will continue regardless. Be sure to have an appropriate include_path setting as well. Be warned that parse error in included file doesn't cause processing halting in PHP versions prior to PHP 4.3.5. Since this version, it does.

Files for including are first looked for in each include_path entry relative to the current working directory, and then in the directory of current script. E.g. if your include_path is libraries, current working directory is /www/, you included include/a.php and there is include "b.php" in that file, b.php is first looked in /www/libraries/ and then in /www/include/. If filename begins with ./ or ../, it is looked only in the current working directory.

When a file is included, the code it contains inherits the variable scope of the line on which the include occurs. Any variables available at that line in the calling file will be available within the called file, from that point forward. However, all functions and classes defined in the included file have the global scope.

Example7.5.Basic include() example


= 'green';
$fruit = 'apple';



echo "A $color $fruit"; // A

include 'vars.php';

"A $color $fruit"; // A green apple


If the include occurs inside a function within the calling file, then all of the code contained in the called file will behave as though it had been defined inside that function. So, it will follow the variable scope of that function. An exception to this rule are magic constants which are evaluated by the parser before the include occurs.

Example7.6.Including within functions


function foo()


"A $color $fruit";

/* vars.php is in the scope of foo() so *
* $fruit is NOT available outside of this *
* scope. $color is because we declared it *
* as global. */

foo(); // A green apple
echo "A $color $fruit"; // A green


When a file is included, parsing drops out of PHP mode and into HTML mode at the beginning of the target file, and resumes again at the end. For this reason, any code inside the target file which should be executed as PHP code must be enclosed within valid PHP start and end tags.

If "URL fopen wrappers" are enabled in PHP (which they are in the default configuration), you can specify the file to be included using a URL (via HTTP or other supported wrapper - see AppendixO, List of Supported Protocols/Wrappers for a list of protocols) instead of a local pathname. If the target server interprets the target file as PHP code, variables may be passed to the included file using a URL request string as used with HTTP GET. This is not strictly speaking the same thing as including the file and having it inherit the parent file's variable scope; the script is actually being run on the remote server and the result is then being included into the local script.


Windows versions of PHP prior to PHP 4.3.0 do not support accessing remote files via this function, even if allow_url_fopen is enabled.

Example7.7.include() through HTTP


/* This example assumes that is configured to parse .php
* files and not .txt files. Also, 'Works' here means that the variables
* $foo and $bar are available within the included file. */

// Won't work; file.txt wasn't handled by as PHP
include '';

// Won't work; looks for a file named 'file.php?foo=1&bar=2' on the
// local filesystem.
include 'file.php?foo=1&bar=2';

// Works.
include '';

$foo = 1;
$bar = 2;
'file.txt'; // Works.
include 'file.php'; // Works.


Security warning:

Remote file may be processed at the remote server (depending on the file extension and the fact if the remote server runs PHP or not) but it still has to produce a valid PHP script because it will be processed at the local server. If the file from the remote server should be processed there and outputted only, readfile() is much better function to use. Otherwise, special care should be taken to secure the remote script to produce a valid and desired code.

See also Remote files, fopen() and file() for related information.

Handling Returns: It is possible to execute a return() statement inside an included file in order to terminate processing in that file and return to the script which called it. Also, it's possible to return values from included files. You can take the value of the include call as you would a normal function. This is not, however, possible when including remote files unless the output of the remote file has valid PHP start and end tags (as with any local file). You can declare the needed variables within those tags and they will be introduced at whichever point the file was included.

Because include() is a special language construct, parentheses are not needed around its argument. Take care when comparing return value.

Example7.8.Comparing return value of include

// won't work, evaluated as include(('vars.php') == 'OK'), i.e. include('')
if (include('vars.php') == 'OK') {

// works
if ((include 'vars.php') == 'OK') {


In PHP 3, the return may not appear inside a block unless it's a function block, in which case the return() applies to that function and not the whole file.

Example7.9.include() and the return() statement


= 'PHP';




= 'PHP';



= include 'return.php';

$foo; // prints 'PHP'

$bar = include 'noreturn.php';

$bar; // prints 1


$bar is the value 1 because the include was successful. Notice the difference between the above examples. The first uses return() within the included file while the other does not. If the file can't be included, FALSE is returned and E_WARNING is issued.

If there are functions defined in the included file, they can be used in the main file independent if they are before return() or after. If the file is included twice, PHP 5 issues fatal error because functions were already declared, while PHP 4 doesn't complain about functions defined after return(). It is recommended to use include_once() instead of checking if the file was already included and conditionally return inside the included file.

Another way to "include" a PHP file into a variable is to capture the output by using the Output Control Functions with include(). For example:

Example7.10.Using output buffering to include a PHP file into a string

= get_include_contents('somefile.php');

get_include_contents($filename) {
if (
is_file($filename)) {
$contents = ob_get_contents();


In order to automatically include files within scripts, see also the auto_prepend_file and auto_append_file configuration options in php.ini.


Because this is a language construct and not a function, it cannot be called using variable functions

See also require(), require_once(), include_once(), get_included_files(), readfile(), virtual(), and include_path.

Related Examples ( Source code ) » include

Code Examples / Notes » include


you can also use the following before you include any files.

nathan ostgard

You can also use debug_backtrace to write a function that do the chdir automatically:
function include_relative($file)
   $bt = debug_backtrace();
   $old = getcwd();


With a large system you might have lots of functions. I have noticed that this can produce large memory overhead, some of which can be alleviated by using includes in the following manner:
function foo() {
 //some long block of code here producing $bar
 return $bar;
can be rewritten as:
function foo() {
 return include "foo.php";
where foo.php contains the following:
//long block of code producing $bar
return $bar;
The result is the function's body does not get loaded into memory until the function is actually called.


While you can return a value from an included file, and receive the value as you would expect, you do not seem to be able to return a reference in any way (except in array, references are always preserved in arrays).
For example, we have two files, file 1.php contains...
 function &x(&$y)
   return include(dirname(__FILE__) . '/2.php');
 $z = "FOO\n";
 $z2 = &x($z);
 echo $z2;
 $z  = "NOO\n";
 echo $z2;
and file 2.php contains...
<?php  return $y; ?>
calling 1.php will produce
i.e the reference passed to x() is broken on it's way out of the include()
Neither can you do something like <?php $foo =& include(....); ?> as that's a parse error (include is not a real function, so can't take a reference in that case).  And you also can't do <?php return &$foo ?> in the included file (parse error again, nothing to assign the reference too).
The only solutions are to set a variable with the reference which the including code can then return itself, or return an array with the reference inside.
James Sleeman

berenguer blasi

When working with a well organized project you may come across multiple problems when including, if your files are properly stored in some nice folders structure such as:
- src
 - web
 - bo
- lib
- test
- whatever
as the include path's behaviour is somehow strange.
The workaround I use is having a file (ex: SiteCfg.class.php) where you set all the include paths for your project such as:
$BASE_PATH = dirname(__FILE__);
$DEPENDS_PATH .= ";".$BASE_PATH."/lib";
$DEPENDS_PATH .= ";".$BASE_PATH."/test";
ini_set("include_path", ini_get("include_path").";".$DEPENDS_PATH);
Make all paths in this file relative to IT'S path. Later on you can import any file within those folders from wherever with inlude/_once, require/_once without worrying about their path.
Just cross fingers you have permissions to change the server's include path.


When I'm dealing with a package that uses relative includes of its own, rather than modify all of their includes, I found it was easier to change PHP's working directory before and after the include, like so:
$wd_was = getcwd();
This way neither my includes nor theirs are affected; they all work as expected.


What cavarlier refers to is that on some editors, UTF-8 files are prefixed with a BOM (Byte Order Mark), an invisible marker three bytes in size, which are output by PHP if it encouters them (which is before the <?php on the first line). Notepad is particularly notorious creating these.
However, any decent editor (e.g. Notepad2) can save UTF-8 files without BOM, and if you do that the first <?php tag will truly be on the first character of the file.
So this does not mean that UTF-8 cannot be used by PHP.


What a pain! I have struggled with including files from various subdirectories.  My server doesn't support an easy way to get to the root HTML directory so this is what I came up with:
$times = substr_count($_SERVER['PHP_SELF'],"/");
$rootaccess = "";
$i = 1;
while ($i < $times) {
$rootaccess .= "../";
include ($rootaccess."foo/bar.php");
This will give you what it takes to get to the root directory, regardless of how many subdirectories you have traveled  through.


well, im using "realpath" on each include i make.
this function rewrites relative paths and symbolic links:

slush puppie

two little methods i wrote up that work on our IIS6 server. the first makes an alternate include call you can use to include things by calling them via their root location. the second method alters the include path so all include() calls are via the root location.
these are a compilation of a few methods i found here, but i think i made them a bit more modular. anyhow...
function rinclude($path){
$levels = substr_count($_SERVER['PHP_SELF'],'/');
$root = '';
for($i = 1; $i < $levels; $i++){$root .= '../';}
include($root . $path);

rinclude(''); // in root
rinclude('dir/'); // in a subfolder
<hr />
function setinclude(){
$levels = substr_count($_SERVER['PHP_SELF'],'/');
$root = '';
for($i = 1; $i < $levels; $i++){$root .= '../';}

include(''); // in root
include('dir/'); // in a subfolder


Trick to get around including get method...
Since this doesn't work:
Try this:
$_REQUEST['id'] = 1;


To avoid painfully SLOW INCLUDES under IIS be sure to set "output_buffering = on" in php.ini. File includes dropped from about 2 seconds to 0 seconds when this was set.

17-may-2005 04:10

Thought you can figure it out by reading the doc, this hint might save you some time. If you override include_path, be sure to include the current directory ( . ) in the path list, otherwise include("includes/a.php") will not search in the current script directory.
e.g :
The first line will test to true, however include will not find the file, and you'll get a "failed to open stream" error


This might help a bit for security (no guarantees).
Instead of
include $page;
include str_replace('../', '', './' . $page);

gillis dot php

This is not directly linked to the include function itself. But i had a problem with dynamically generated include-files that could generate parse errors and cause the whole script to parse-error.
So as i could not find any ready solution for this problem i wrote the mini-function. It's not the most handsome solution, but it works for me.
function ChkInc($file){
  if(substr(exec("php -l $file"), 0, 28) == "No syntax errors detected in"){
  return true;
  return false;
if someone else has a better solution, do post it...
Note. remember that this function uses unchecked variables passed to exec, so don't use it for direct user input without improving it.
//Gillis Danielsen


This is a good example for returning a value from an included file I think.
I'm working on my own template class like Smarty. This class gets html code from template files. Then it creates a file that will be included directly. It displays only installed modules for the page. The included page always checks the installed modules. If the comparision returns false, the included file returns FALSE and warns the class to recreate itself. Then a new file with requested modules will be overwritten to the existing one.
Here is the main framework of my class:
/* by Safak Ozpinar */
class MyInclude {
 private $modules = array();
 private $numModules = 0;
 /* the constructor gets module names into an array */
 function MyInclude($inputModules) {
   if(!is_array($inputModules)) $inputModules = array($inputModules);
   foreach($inputModules as $module) {
     $this->modules[$this->numModules] = $module;
 /* the main action happens here, check carefully */
 function Display($fname, $reCreate = FALSE) {
   if(@file_exists($fname) && !$reCreate) {
     // if the included file returns FALSE, recreate it
 if((include $fname)==FALSE) {
       $this->Display($fname, TRUE);
   else {
 /* the behavior of the method Create depends on the format of your template file */
 // you will need some changes on this method to adapt to your work
 private function Create($fname) {
   $contentsPHP = '<?'."\n";
   $contentsHTML = '<html><body>'."\n";
   foreach($this->modules as $module) {
     $contentsPHP .= '$storedModules[] = \''.$module.'\';'."\n";
     // the html code of the module (you may need to take from a tempate file)
     $contentsHTML .= '

HTML code for module <b>"'.$module.'"</b>'."\n";
// here is the comparision code for included file
// if the comparision returns FALSE, the file also returns FALSE
   $contentsPHP .= 'if(!$this->Compare($storedModules)) return FALSE;'."\n";
   $contentsPHP .= '?>'."\n";
   $contentsHTML .= '</body></html>';
   $fp = fopen($fname,'wb');
   fwrite($fp, $contentsPHP.$contentsHTML);
 /* ordered comparision, you may want to change the operations in this method */
 function Compare($storedModules) {
   $count = count($storedModules);
   if($count == $this->numModules) {
     for($i=0; $i<$count; $i++) {
         return FALSE;
     return TRUE;
   else return FALSE;
/* lets go */
$tpl = new MyInclude(array('headline','main_menu','sub_menu','text_ads'));
I haven't written error controls here because the code would be too large. For instance; if a html template for requested modules doesn't exist, you may want to display an error message or make some operations.
Safak Ozpinar (from Istanbul University)


The __FILE__ macro will give the full path and name of an included script when called from inside the script.  E.g.
<? include("/different/root/script.php"); ?>
And this file contains:
<? echo __FILE__; ?>
The output is:
Surprisingly useful :>  Obviously something like dirname(__FILE__) works just fine.

sean dot farrell

The way PHP handles the ./ and ../ is totally counter intuitive. As said if the included file is preceded by a ./ and ../ it looked up from the current working directory. And that is defined by the of the EXECUTED script. That is the script that you specified in the url.
So if your have a.php that includes include/b.php that includes ../extern/c.php, it will not do what you want. You can use extern/c.php instead if you never execute outside of the document root. For me that just will not cut it. Since I execute test suites if files are directly called, like in python.
Here is my dirty trick that works, since I only have two levels of file hierarchy:
And here is an open question: Why are the included files not looked up relative from the file that includes them and then in the include path? This would be a behavior like in all other languages.


The documentation should make it clearer that the include argument is not a site path (i.e. not relative to the document root or to any web server defined aliases), but rather a path on the host relative to the calling script's directory.


Something not previously stated here - but found elsewhere - is that if a file is included using a URL and it has a '.php' extension - the file is parsed by php - not just included as it would be if it were linked to locally.
This means the functions and (more importantly) classes included will NOT work.
for example:
include "";
would not give you access to any classes or functions within the MyInclude.php file.
to get access to the functions or classes you need to include the file with a different extension - such as '.inc' This way the php interpreter will not 'get in the way' and the text will be included normally.

alex carstea

Since include() caused me many problems when i was trying to test my code, I wrote a small function. It receives as parameter the path to the file to include relative to the current file. The format similar to :
The function returns the absolute path to the file to be included. This path can be used as argument to include() and resolves the problem of nested inclusions.
function getFilePath($relativePath){

//count the number of ".." tokens that precede the path
while(( $upTokens<count($relativeArray)) and ($relativeArray[$upTokens]=="..")) {
// create the absolute path
for ($i=1; $i< (count($absArray)-$upTokens);$i++) {

for ($i=$upTokens; $i< count($relativeArray);$i++){
return $filePath;
 Hope you will find it usefull....


Reponse to rayro at gmx dot de (21-Aug-2007 11:48 )
Hi rayro,
your code :
..Don't works when a function is called by another remote function (with a another remote include) -> realpath don't use __FILE__ reference :(
This works always and everywhere ( thanks to Jonny Rylands ) :
 include (realpath(dirname(__FILE__).'/relative/path/to/'));


Regarding the caching of includes.
I submitted a bug for this, apparently it's not a bug it's supposed to work that way for some reason.
The bugs team declined to elaborate as to why but it would seem includes aren't meant to use dynamic code, which makes this function worthless and by extension makes php needlessly time consuming because you can't reuse files properly.


please note when you include a (utf-8) encoded file, this will be sufficient to send headers even if it doesnt contain any line breaks


Please note that althought you can call a function that is DEFINED later in the code, you cannot call a function that is defined in a file which is INCLUDED later. Consider following two examples:
Example 1:
function test()
 echo 'In test.';
Example 2:
include 'file2.php';
function test()
 echo 'In test.';
Please be aware that while the first example will work as expected, the second one will generate a fatal error "Call to undefined function: test() ...". The same is true for the require.


In response to oasis1 below, I use mod_rewrite to pipe all my requests through the index.php file, so I'm able to use the below code to find the root directory:
$sRoot = $_SERVER['HTTP_HOST'] . dirname($_SERVER['SCRIPT_NAME']);
You may be able to modify it to suit yourself.


In response to baofu:
The problem with calling:
set_include_path( ... )
before including any file, is that if one of the included files, in turn, does a set_include_path to include yet another bunch of files, then the following include statement in your topmost file, is done in an include path context that has changed.
Using: include dirname(__FILE__).'/../foo/bar' remains the best solution.


In response to
Using the following at the top of your CLI scripts will make includes work similar to web PHP.
<?php chdir(dirname(__FILE__)); ?>
This changes the current working directory to the one your script is running in. Its quite used for taking existing web scripts and getting them to run quickly in the command line.


In reply to the last anonymous note, this is exactly the way mediawiki code handles this problem. They have various-depth include paths.
So, for instance, inside includes/normal/UtfNormal.php (as of revision 19455) they do:
   require_once dirname(__FILE__).'/UtfNormalUtil.php';
?> include the file includes/normal/UtfNormal.php.


In reference to the fopen() and $use_include_path workaround for checking whether a include file exists as posted by [arnold at bean-it dot nl]...
I did some benchmarks with 100 dirs (each with 1 file) in the include_path on Apache/2.0.55 (Win32) PHP/5.2.1.
Here are the results:
(note: in the success scenarios, I am include'ing the file in the LAST directory on the include stack. This is to maximize the seek time; fail scenarios simply use a non-existent file; all times are in seconds )
benchmarks --> plain vanilla INCLUDE
benchmarks --> fopen() and $use_include_path workaround
In cases involving MANY include paths, include() is -marginally- faster than the workaround (unsurprising - we incur the extra overhead of BOTH the fopen() call AND the $use_include_path seek). I say marginal in comparison to the "fail" scenarios, detailed next..
The most surprising thing is the inefficiency of include() when you are trying for a non-existent file. As compared to the workaround, the native include() method is roughly 3 times slower.
Based on additional tests (50 paths only), I note that any decrease in seek time for either case is generally linear to the number of paths.
THEREFORE, depending on the amount of paths you have, you might want to resort to different methods of optimizing the includes in your scripts, especially if you need to constantly test for the existence of include'd files (our organization uses a templating engine that relies on a virtual flat directory structure using the set_include_path() function).
From a technical perspective, I have no idea why this is the case and I find the prospect of trawling the PHP source to be rather daunting. However, as an educated guess: I figure that the include() code assumes the file exists, and so wastes processor cycles making a system read call, which inevitably fails.
For those interested in the benchmark script, you can email me at the email address provided above. No support, of course. :P


In addition to the redeye at cs-aktuell dot de note:
to make pseudo-frame in total security
/* verify the validity of GET var page
if not set, do a default case         */
$p = $HTTP_GET_VARS['page'];
$p = 'index';
case 'index':
case 'news':
case 'what you want':
require('the file you want');
exit('Wrong parameter for file inclusion');

jesper juhl

If you want to prevent direct access to some files and only allow them to be used as include files by other scripts, then an easy way to accomplish that is to check a define in the include file.
Like this.
defined('_VALID_INCLUDE') or die('Direct access not allowed.');
/* rest of file */
/* rest of file */


If you want to include a file that has no PHP in it (such as a template), it is more efficient to use file_get_contents().
Instead of:
include "file.htm";
echo file_get_contents("file.htm");
In a rough millisecond test using gettimeofday(), it proved to be about twice as fast.

vahe dot ayvazyan

If you want the "include" function to work correctly with paths and GET parameters, try the following code:
   $_GET['param1'] = 'param1value';
   $_GET['param2'] = 'param2value';
   @include($_SERVER['DOCUMENT_ROOT'] . "/path1/path2/include.php");
Then within your "include.php" use $_GET['param1'] and $_GET['param2'] to access values of parameters.
I spent several hours to figure this out.


If you use php >5.2, don't forget to set up the allow_url_include parameter in php.ini file .. If not you can search a long long long long time after this like-a-bug problem ;)


If you have a problem with "Permission denied" errors (or other permissions problems) when including files, check:
1) That the file you are trying to include has the appropriate "r" (read) permission set, and
2) That all the directories that are ancestors of the included file, but not of the script including the file, have the appropriate "x" (execute/search) permission set.


If a person directly accesses an include file by mistake, you may want to forward them to a correct default page.
Do this by:
Say the file to be included is 'newpubs.php'
and the main pages are either newpubs_e.php or newpubs_f.php
header("Location: newpubs_e.php");
Will send them to newpubs_e.php if they try to access newpubs.php directly.


I'm gonna throw my hat in the rink and also say that I've always thought that the include path being relative to the current directory is silly. PHP is the only language I can think of that does this. Almost all of my include paths have always had to be prefixed with <?php dirname(__FILE__) ?> to operate expectedly.

durkboek a_t hotmail d_o_t com

I would like to emphasize the danger of remote includes. For example:
Suppose, we have a server A with Linux and PHP 4.3.0 or greater installed which has the file index.php with the following code:
// File: index.php
include ($_GET['id'].".php");
This is, of course, not a very good way to program, but i actually found a program doing this.
Then, we hava a server B, also Linux with PHP installed, that has the file list.php with the following code:
// File: list.php
$output = "";
exec("ls -al",$output);
foreach($output as $line) {
echo $line . "
If index.php on Server A is called like this: http://server_a/index.php?id=http://server_b/list
then Server B will execute list.php and Server A will include the output of Server B, a list of files.
But here's the trick: if Server B doesn't have PHP installed, it returns the file list.php to Server A, and Server A executes that file. Now we have a file listing of Server A!
I tried this on three different servers, and it allways worked.
This is only an example, but there have been hacks uploading files to servers etc.
So, allways be extremely carefull with remote includes.


I wanted that included files behave like in C/C++ and this  was killing me. So I created this function that really helped me (Note: You should add these lines to EVERY included file).
Code Lines:
$FILE_PATH = preg_replace_callback(
'$path = str_replace("\\\", "/",(isset($matches[2])?
return !empty($path)? "$path/" : "./";'
Usage Example:
Files hierarchy for example
<? //file.php
//i will not include the code lines in example to avoid repetition but you have to
// --- FILE_PATH code lines here ---
// include the file relative to the caller position remember to use a relative path from each file to desired file
include ($FILE_PATH . "../../include/secondfile.php");
<? //secondfile.php
// --- FILE_PATH code lines here ---
//note that path used is in reference to secondfile.php's path and not the original caller's(file.php) path
include ($FILE_PATH . "test/anotherfile"); //or include ($FILE_PATH . "./test/anotherfile");
<? //anotherfile
/* --- some mixed content here --- */
Now you can do recursive includes to files inside already
included files using each file's path as reference, like in
I'd tested this just in WINXP (PHP Version 4.4.1), so, I
dont know how it behaves in other OS/PHP-Versions. Any
additional suggestions or bugs, please let me know.


I needed to use an include with an echo statement, with http authenication so I thought I'd share. It's basic but I didn't find it documented anywhere:
   include 'http://treyh:pass@' . $row[id];

david dot gaia dot kano

I just discovered a "gotcha" for the behavior of include when using the command line version of php.
I copied all the included files needed for a new version of a program into a temporary directory, so I could run them "off to the side" before they were ready for release into the live area. One of the files with a new version (call it for this example) normally lives in one of the directories in the include path. But I did not want to put the new version there yet! So I copied into my temporary directory along with the others, figuring that the interpreter would find it there before it found it in the include directory, because my include path has a . at the beginning. When I tested it, everything was fine.
But then I setup a cron job to run the script automatically every day. In the crontab I placed the full path of the script. But when it ran, it included the old version of my file out of the include directory. Interestingly, the other include files that only existed in the temporary directory were included fine.
Evidently AFTER the include path is searched, the directory in which the main script lives is searched as well. So my temporary installation almost worked fine, except for the lack of the small change I had made in the common file introduced a bug.
To make it work I use a shell script to start my php script. It contains a cd command into the temporary directory, then starts the php script.
So "current directory" (the . in the include path) for a command line script is really the current directory you are in when executing the script. Whereas it means the directory in which the script lives when executing under apache.
I hope this helps save someone else the hours it took me to figure out my problem!

nathan ostgard

I have to agree with sean dot farrell at digital-egg dot org.
If I put "../" or "./" in a call to include(), I expect it to be relative to the file I am including from, not the current working directory of the application.
This backwards mentality for relative paths really interferes with PHP's ability to build packages of files independent of an application.


I had been looking around on how to make sure that a file is included, I guess the way to do it changed with new version, here we go:
if ((include "header.php") == true) {
  echo ("header loaded");
}//end if
  echo("header not loaded");
}//end else
hope that helps!

ignacio esviza

Hi, there...
I've use this in order to grab the output from an include() but without sending it to the buffer.
Headers are not sent neither.
function include2($file){

$buffer = ob_get_contents();
include $file;
$output = substr(ob_get_contents(),strlen($buffer));

echo $buffer;

return $output;



Here's a really simple solution to a common problem. Let's say you want to include files the way that apache does, relative to the document root (the root dir of your app). Independent of what server you are on, so that you don't have to specify an absolute path on your filesystem. At the top of your page put:
<?php set_include_path( get_include_path() . PATH_SEPARATOR . $_SERVER['DOCUMENT_ROOT'] ); ?>
Now anywhere you do an include you can do something like:
<?php include ( "Templates/") ?>
So, if your server files are in /var/www/mysite, this will include /var/www/mysite/Templates/ when it's on your server. And if on your dev machine it's in /user/myname/mysite, it will include /user/myname/mysite/Templates/ when it's on your dev machine.

14-may-2007 04:40

Even when you set cache control and expiry headers:
header("Expires: 0");
header("Last-Modified: " . gmdate("D, d M Y H:i:s") . " GMT");
header("cache-control: no-store, no-cache, must-revalidate");
header("Pragma: no-cache");
It doesn't seem to reparse the include on the second hit to the page without a forced refresh.
e.g. a page where you direct to a login page which changes a $_SESSION var then returns to the originating page.
The originating page doesn't execute the code so it looks like still not logged in.

cory gagliardi

Easy way to set $_GET values for local includes.
This is an easy way to make up fake URLs for SEO purposes that are really just running other PHP pages with special $_GET values.
This will NOT work:
However, this will:
$_GET = array();
$_GET['show'] = 'gated';
$_GET['where'] = 'naples';
Putting this on your page and nothing else will give the same result as going to
but the URL can be whatever you want it to be.


Currently there is no clean way to check if a file can be included. Simply including a file which can't be opened causes a warning to be triggered. Suppressing include() with an @ (as often seen below) is not advisable, since parse errors won't be displayed, but will cause the script to die, causing a blank screen. (Happy debugging, hope you're using ZendStudio or some other debugger).
The best solution I've come up with is:
   if (($fp = @fopen($filename, 'r', 1)) and fclose($fp)) include $filename;
I believe the functions file_exists(), filesize(), is_readable() and is_writable() should have an use_include_path just like fopen().
If you agree with this, please PLEASE VOTE on bug #6932 ( This bug has been open for over 5 years. Apparently no one is willing to add this feature.


<?=$foo?> equals <? print $foo ?>
If 1 is not needed at the end, just use <? include($filename) ?> without the equal sign.


Because there is no quick way to check if a file is in include_path, I've made this function:
function is_includeable($filename, $returnpaths = false) {
$include_paths = explode(PATH_SEPARATOR, ini_get('include_path'));
foreach ($include_paths as $path) {
$include = $path.DIRECTORY_SEPARATOR.$filename;
if (is_file($include) && is_readable($include)) {
if ($returnpaths == true) {
$includable_paths[] = $path;
} else {
return true;
return (isset($includeable_paths) && $returnpaths == true) ? $includeable_paths : false;


Be careful using the <?= / ?> start and end tags with include / require.
A lovely feature/bug/misunderstanding meant that the result of
was to get the contents of the file, suffixed with a '1'. I can only assume that the one is the return code of the include.
hopefully my pain can help somebody else :D


at spam guard dot gmail com
to php dot net at reinsveien dot com:
if you know the domain the file should be coming from then you can parse the variable for the domain and make sure that it matches the domain you expect, example:
if (getdomain($path) == 'yourdomain'){
this should prevent remote execution of any malicious script


As to the security risks of an include statement like:
This is a really bad way on writing an include statement because the user could include server- or password-files which PHP can read as well. You could check the $page variable first but a simple check like
 if ( file_exists($page) ) AND !preg_match("#^\.\./#",$page) )
wont make it any safer. ( Think of $page = 'pages/../../../etc/passwd' )
To be sure only pages are called you want the user to call use something like this:
 $path = 'pages/';
 $extension = '.php';
 if ( preg_match("#^[a-z0-9_]+$#i",$page) ){
   $filename = $path.$page.$extension;
This will only make sure only files from the directory $path are called if they have the fileextension $extension.


As stated above, when using return() to terminate execution of an included file, any functions defined in the file will still be defined in the global scope, even if the return() occurs before their definition.
It should be noted that class definitions behave in the same way.


Another way of getting the proper include path relative to the current file, rather than the working directory is:
include realpath(dirname(__FILE__) . "/" . "relative_path");


A very EASY way to get 'include' to find its way to another directory, other than setting the 'include path', and useful for fetching one or two files:
include ($_SERVER['DOCUMENT_ROOT']."/foo/bar.php");
This creates an include that is relative to the root rather than the current directory.
The dot is for concatenation, not current directory, as with 'include path' syntax.
See Appendix M of Manual > Reserved words > Predefined Variables, for more info on $SERVER.

tim furry

A small tweak to alex's getFilePath function allows it to work for Windows-based PHP as well:
$absPath = str_replace("\\", "/", dirname($_SERVER['SCRIPT_FILENAME']));
Windows recognizes a forward slash as a directory separator character.
Using $_SERVER['DOCUMENT_ROOT'] and similar solutions didn't seem to work for web paths with internal symbolic links.  Alex's function gets around that and works great.


a simple function to recursively include e.g. the include-directory of your site and its subdirs:
function includeRecurse($dirName) {
       return false;
   $dirHandle = opendir($dirName);
   while(false !== ($incFile = readdir($dirHandle))) {
       if($incFile != "."
          && $incFile != "..") {

stephen lee

@ajsharp at gmail dot com
To find out which script has included another, use the Server Variable 'SCRIPT_NAME' (note: there are other server variables that also contain the script name, but I use this one simply because it works for me) e.g.
$includer = basename($_SERVER['SCRIPT_NAME']);
switch ($includer) {
  case 'a.php':
  $this_variable = 'included by script a.php';
  case 'b.php':
  $this_variable = 'included by script b.php';
  $this_variable = 'included by unkown script';
echo $this_variable;
Test with 3 different files "a.php", "b.php", "c.php", all with the same content:
include 'variables.php';


@include('/foo') OR die ("bar"); # <- Won't work
@(include('/foo')) OR die ("bar"); # <- Works
so "or" have prority on "include"

Change Language

Follow Navioo On Twitter
Alternative syntax for control structures
eXTReMe Tracker