Eğer $dir sonraki dosyaları dışında tutmak için yapabileceği birkaç şey var

Example 1

set_include_path(dirname(__FILE__) . PATH_SEPARATOR . get_include_path());

Bu çok açıktır.

Example 2

$dir = dirname(__FILE__);
set_include_path($dir . PATH_SEPARATOR . get_include_path());
// work with $dir
unset($dir);

Sadece tanımlayan ve bunu kullandıktan sonra değişken unset. Bu $dir önce bu komut dosyası içeren için kullanılan adlandırılmış, herhangi bir değişkeni unset unutmayın.

Example 3

define('DIR_THIS', dirname(__FILE__));

set_include_path(DIR_THIS . PATH_SEPARATOR . get_include_path());

Ben böyle bir küresel sabit yeniden tanımlamak için varsayalım az olasıdır.

Example 4

function my_set_include_path {
  $dir = dirname(__FILE__);
  set_include_path($dir . PATH_SEPARATOR . get_include_path());
  // Do more stuff with the $dir variable
  $my_other_var = 'is trapped within this function';
}

my_set_include_path();

O işlev içinde birçok değişkenleri tanımlamak ve küresel ad etkileyemez.

Conclusion

İlk yöntem kullanmak için $dir tekrar ideal olmayabilir Ancak istiyorum, çünkü bu sorunu çözmek için en kolay yoludur. Son örnek, en azından devam edeceğini $dir (ve o işlev içinde tanımlanmış herhangi diğerleri) genel ad dışarı.

Ne istediğinizi yakın bir şey başarmak için gidiyoruz tek yolu bir işlevi olduğunu dahil dosyasındaki her şeyi sarın ve çağırmaktır. Dosya kendisi yürütmek için gerekiyorsa yine yapabilirdi

<?php
run_myfile()
function run_myfile() {
...
}
?>

Değişken bir ad alanları, sınıflar, veya fonksiyonlar dışında sadece bir dosyaya kapsamlı yapmak için hiçbir genel yolu yoktur.

Eh, ben muhtemelen bu için flailed alıyorum, ama tamamen umutsuz iseniz bunun için bir Registry kullanabilirsiniz. (Ben And no OOP is used here so I'm not searching for private class members. Eğer her OOP ile bunu yapmak istemiyorum demek varsayalım beri) sınıfsız yapan küçük bir tane çırpılmış ettik

function &registry_get_instance()
{
    static $data = array();
    return $data;
}

static $data değişkeni içindeki fonksiyon kapsam içinde kalıcıdır, bu nedenle istediğiniz yere işlevini çağırın ve hep aynı içeriğini alabilirsiniz. Önemli nokta returning by reference, örneğin

$registry = &registry_get_instance();     // get $data array by reference
$registry['foo'] = 'bar';                 // set something to $data
unset($registry);                         // delete global reference to $data
print_r(&registry_get_instance());        // show $data 

Genel kapsamda bu yöntemi çağrılırken Açıkçası hala küresel kapsamda bir değişken olarak $ kayıt olurdu. Yani, kullanmak için kayıt defteri daha rahat yapmak için biraz daha fazla işlevleri ekleyebilirsiniz örneğin Kayıt Defteri veri ayarı için:

function registry_set($key, $value) 
{
    $registry = &registry_get_instance();
    $registry[$key] = $value;
}

ve tekrar dışarı almak için:

function registry_get($key)
{
    $registry = &registry_get_instance();
    if(array_key_exists($key, $registry)) {
        return $registry[$key];
    } else {
        trigger_error(sprintf(
            'Undefined Index: %s', htmlentities($key)
        ), E_USER_NOTICE);
    }
}

ve bir anahtar varsa kontrol etmek için:

function registry_isset($key)
{
    $registry = &registry_get_instance();
    return array_key_exists($key, $registry);
}

: Eğer gibi kullanabilirsiniz hangi

registry_set('foo', 'bar');         // setting something to the registry
var_dump( registry_isset('foo') );  // check foo is in the registry now
echo registry_get('foo');           // prints 'bar'
echo registry_get('punt');          // raises Notice

Böyle bir ek yöntemle bir içerme dosyası Registry doldurmak olabilir:

function registry_load_file($file)
{
    if(!is_readable(realpath($file))) {
        return trigger_error(sprintf(
            'File is not readable: %s', htmlentities($file)
        ), E_USER_WARNING);
    }
    $config = include $file;
    if(!is_array($config)) {
        return trigger_error(sprintf(
            'Expected file %s to return an array', htmlentities($file))
        , E_USER_WARNING);
    }
    $registry = &registry_get_instance();
    $registry += $config;
}

içeren dosya, bir dizi dönmek zorunda ile:

// config.php
return array(
    'setting1' => 'something'
);

ve o zaman yapabileceğiniz

registry_load_from_file('config.php');  // add the contents of config to registry
print_r(registry_get_instance());       // show content of registry

Tabii ki, bu sadece bir küresel değişkeni olmaması için artık küresel kapsamda altı işlevleri. Buna değer eğer static fonksiyonları ve tüm bu referans şeyler şüpheli uygulama düşünün, özellikle de bilmiyorum.

Kavramının bir kanıtı olarak götürün :)

Neden sadece bir statik sınıf her şeyi koymak değil mi? Sonra tek bir "değişken" olması olabilir belki genel ad ile çatışma.

class MyClass {
    public static $myvar = 1;
    public static $myvar2 = "xyz";

    public static function myfunction() {
        self::$myvar++;
        self::$myvar2 = "abc";
    }
}
// References to class items, if needed
MyClass::myfunction();
MyClass::$myvar += 3;

Eğer çalıştığınız sorun sadece ise:

$dir = dirname(__FILE__);
set_include_path($dir . PATH_SEPARATOR . get_include_path());
// Do more stuff with the $dir variable

Daha sonra çözelti içeren yol göre değiştirmek için olacaktır. ' ini ayarlarında. Örneğin değiştirin:

include_path=includes:/usr/local/php

karşı

include_path=./includes:/usr/local/php

Note that a script does not come inkarşı scope except where you explicitly include/require it (both the _once check applies globally) however I would recommend strongly against calling include/require from within a function - its much more transparent having the includes/requires at the karşıp of the script.

I think that the problem you are trying karşı solve is based on a false premise and you should look for another way of fixing it. If you want the code in an include file karşı behave differently depending on what includes it, then really you should seperate it out inkarşı 2 seperate files - or maybe even 3 - 2 for the different behaviours and 1 for the common.

C.