CODEWITHSUNDEEP
phpscopeglobal-variablesrequire-once
Stephan Kulla
Stephan Kulla

Reputation: 5067

Is there a way to set the scope of require_once() explicitly to global?

I'm looking for a way to set the scope of require_once() to the global scope, when require_once() is used inside a function. Something like the following code should work:

file `foo.php':

<?php

$foo = 42;

actual code:

<?php

function includeFooFile() {
    require_once("foo.php"); // scope of "foo.php" will be the function scope
}

$foo = 23;

includeFooFile();
echo($foo."\n"); // will print 23, but I want it to print 42.

Is there a way to explicitly set the scope of require_once()? Is there a nice workaround?

Upvotes: 12

Views: 6765

Answers (8)

Trevor E Cordes
Trevor E Cordes

Reputation: 1

You can use eval() to get your require_once to run in a global context. This method would require changing just two lines in your main program file: your function call, and the return value from the function. No changes to foo.php would be required, or other global iteration tricks.

function includeFooFile() {
    # don't do the require in the fn, let the caller do it
    return 'require_once("foo.php");';
}

$foo = 23;

eval(includeFooFile());
echo($foo."\n"); # will print 42.

There are a couple of catches to the eval() approach though:

Do not include any user-supplied or untrusted strings in the returned & eval'd code: see the eval() documentation as to why. This shouldn't be an issue for require_once's because in general you will be including only known source files.

Your includeFooFile function cannot use for itself any of the variables or functions declared in foo.php, because they do not exist until after the return. If you wanted includeFooFile to manipulate foo.php's changes further, you'd need to define a follow-up function and call that after the eval, or change the return value to include the follow-up code after the require_once. However, the latter approach may get tricky with nested quoting, so a heredoc is recommended. Double-quote style heredocs, shown below allow you to use variables, perhaps parameters passed to includeFooFile. Single-quote heredocs, like <<<'EOINCLUDE', would make quoting much easier if you know for sure you do not require variable interpolation.

function includeFooFile() {
    return
    <<<EOINCLUDE
    require_once('foo.php');
    \$foo++;
    EOINCLUDE;
}

Prints 43.

If you wanted super simple, you could do away with the eval and simply return the name of the file to require_once, and then have the caller just require that:

function includeFooFile() {
    return 'foo.php';
}

$foo=23;

require_once(includeFooFile());
echo($foo."\n"); # will print 42.

But then you cannot add any follow-up code, nor require_once two or more files within includeFooFile. However, you do eliminate the always-uncomfortable eval().

Note: if you were to have to further nest the call to includeFooFile itself inside another function, you would have to create a bubbling-up chain of these evals somehow. What I've demonstrated would not be adequate as is.

Ideally, PHP devs will eventually give us an optional parameter to require_once to specify we want it done in a global scope.

Upvotes: 0

mpen
mpen

Reputation: 283213

You can use this hacky function I wrote:

/**
 * Extracts all global variables as references and includes the file.
 * Useful for including legacy plugins.
 *
 * @param string $__filename__ File to include
 * @param array  $__vars__     Extra variables to extract into local scope
 * @throws Exception
 * @return void
 */
function GlobalInclude($__filename__, &$__vars__ = null) {
    if(!is_file($__filename__)) throw new Exception('File ' . $__filename__ . ' does not exist');
    extract($GLOBALS, EXTR_REFS | EXTR_SKIP);
    if($__vars__ !== null) extract($__vars__, EXTR_REFS);
    unset($__vars__);
    include $__filename__;
    unset($__filename__);
    foreach(array_diff_key(get_defined_vars(), $GLOBALS) as $key => $val) {
        $GLOBALS[$key] = $val;
    }
}

It moves any newly defined vars back into global space when the include file returns. There's a caveat that if the included file includes another file, it won't be able to access any variables defined in the parent file via $GLOBALS because they haven't been globalized yet.

Upvotes: 1

Dunhamzzz
Dunhamzzz

Reputation: 14808

Pending on your exact requirements, you could use constants. Require your file in the global scope, but inside it set a constant.

IE file.php:

define('MY_CONSTANT', 42);

Then anywhere in your script just use MY_CONSTANT to refer to the value, you won't be able to edit once it's been set though. Other than that, you could globalize your variable as the other answer says, but it's not 100% clear what you're trying to achieve other than simply retrieving a value from the included file? In which case constants should be fine.

Update: Now you've explained that you want an objects properties to be available everywhere, I suggest you look into creating a static class, which once instantiated in your global scope can be used anywhere in your app. Read the linked manual page, it has a bare-bones example.

Upvotes: 1

DaveRandom
DaveRandom

Reputation: 88707

This is definitely not a "nice" work around but it would work:

function includeFooFile() {
  require_once("foo.php");
  foreach (get_defined_vars() as $key => $value) {
    // Ignore superglobals
    if (!in_array($key, array('GLOBALS','_SERVER','_GET','_POST','_FILES','_COOKIE','_SESSION','_REQUEST','_ENV'))) {
      $GLOBALS[$key] = $value;
    }
  }
}

However, your included file cannot define any functions or classes (and possibly some other things as well that I cannot currently think of) because it will result in a parse error, since you cannot nest classes or functions.

EDIT apparently you can include functions in your file. I had always thought you couldn't but after testing it seems that you can.

Upvotes: 3

hakre
hakre

Reputation: 198204

As the scope is explicitly defined where you use require and the like, you would need to specify what to do with the variables inside the scope of the function:

function includeFooFile() {
    require_once("foo.php"); // scope of "foo.php" will be the function scope

    foreach (get_defined_vars() as $k => $v)
    {
        $GLOBALS[$k] = &$v;
    }
}

This example takes care of both, variables and references which might be what you're looking for. Demo. Please note that require_once would only work once and would only define the variables once.

Upvotes: 2

a sad dude
a sad dude

Reputation: 2825

I haven't tried it (since using global vars is a bad idea tbh) but this could potentially work:

require_once '...';
$GLOBALS = array_merge($GLOBALS, get_defined_vars());

Alternatively you can just do it manually:

foreach (get_defined_vars() as $k => $v) {
    $GLOBALS[$k] = $v;
}

Upvotes: 1

Mathieu Dumoulin
Mathieu Dumoulin

Reputation: 12244

Apart from "globalizing" your variable, there is no way to do this:

global $foo;
$foo = 42;

OR

$GLOBALS['foo'] = 42;

Then your value should be 42 when you print it out.

UPDATE

Regarding the inclusion of classes or functions, note that all functions and classes are always considered global unless we are talking about a class method. At that point, the method in a class is only available from the class definition itself and not as a global function.

Upvotes: 5

bardiir
bardiir

Reputation: 14792

You will need to declare global in your foo.php: 

<?php
 global $foo;
 $foo = 42;
?>

Otherwise it's probably not possible.

You could try to play around with extract(), get_defined_vars(), global and $GLOBALS in various combinations maybe... like iterating through all defined variables and calling global on them before requiring a file... 

$vars = get_defined_vars();
foreach($vars as $varname => $value)
{
  global $$varname; //$$ is no mistake here
}
require...

But i'm not quite sure if you get to where you want to go...

Upvotes: 3

Related Questions