.htaccess - How can we include php files without specifying the subfolder path

Answer

Solution:

You can useauto_prepend_file directive in your .htaccess to make a.php file included before all of your php files.

If you're usingmod_php then have this line in your .htaccess:

php_value auto_prepend_file "/Applications/MAMP/htdocs/script/env.php"
Copy code

Note that forPHP-FPM you need to have these equivalent line in your.user.ini file:

auto_prepend_file = "/Applications/MAMP/htdocs/script/env.php"
Copy code

Then create a new fileenv.php in your project base directory with just one line:

<?php
   $baseDir = __dir__ . '/';
?>
Copy code

This line sets a variable$baseDir that has value of your project base directory i.e./Applications/MAMP/htdocs/script/ OR/Applications/MAMP/htdocs/subdir/script/

Then use this variable$baseDir anywhere you have to include other files such as:

include_once $baseDir.'functions/includes.php';

include_once $baseDir.'functions/get.php';
Copy code

Answer

Solution:

You have to use functionset_include_path() and somewhere in yourbootstrap.php orindex.php add next code:

<?php
$path = '/usr/pathToYourDir';
set_include_path(get_include_path() . PATH_SEPARATOR . $path);
Copy code

now everywhere below you can write this:

include_once 'include/config.php';
// or
include_once 'include/db/index.php';
// etc
Copy code

And in case you need to move your code into another directory - you have only to change value of path varibalbe$path = '/usr/pathToYourDir'; to new path to your directory.

Answer

Solution:

Ok, I'm not a fan of doing this, but it will get the job done, as requested:

$newpath="";

$dirs = array_filter(glob('*'), 'is_dir');
foreach ($dirs as $location) {
    $newpath .= PATH_SEPARATOR . $location; 
}
set_include_path(get_include_path() . $newpath);
Copy code

The above code will find all subfolders from where this file is running, and add them all to the current include path. by changing the glob from:

glob('*') 
Copy code

to

glob('includes/*')  or glob('includes' . DIRECTORY_SEPARATOR . '*')
Copy code

You can restrict it to only subfolders under includes.

The above is not tested, I just threw the code together, but it illustrates a way to do what you're asking for.

I would still recommend putting files in determined locations rather than trying to include them from anywhere.

Answer

Solution:

__DIR__ is certainly what you are looking for. Use it to provide relative paths for required files. I would highly suggest usingrequire_once orinclude_once for all library files.

include_once dirname(dirname(__DIR__))."/include/config.php";
Copy code

Answer

Solution:

This is how I would do it.

//----- some global location like index.php

if(!defined("CONFIG_PATH")) define("PATH_CONFIG", __DIR__."/include/");

//
Copy code

Then when you change it you just update

{-code-2}
Copy code

I would say this is the "Traditional" way to do it, and it's perfectly fine to use a global constant for this. It's not something you want changing at run time. You need access to it in many places, potentially. You can check if your files are accessed properly .. etc.

Many many many, MVC frameworks do it this exact way.

Answer

-- then later in some other file if(!defined("CONFIG_PATH"))die("Config path is not defined."); include_once CONFIG_PATH.'config.php';|||if(!defined("CONFIG_PATH")) define("PATH_CONFIG", __DIR__."/include/subfolder/");

Answer

Solution:

Here's an example of an approach that requires your files upfront via the auto_prepend_file directive.

bootstrap.php:

<?php

$require_upfront = function($dir) {
    require_once $dir . '/one.php';
    require_once $dir . '/two.php';
};

$require_upfront(__DIR__ . '/inc');
Copy code

Add to php config, here .htaccess example:

php_value auto_prepend_file "/abs/path/to/bootstrap.php"
Copy code

Answer

Solution:

If you have the file's name unique in all server, you can make a research of this using a research like this.

I think that this solution isn't better when this script run a lot of, but you can include if the include function fails, using try and catch (if you use this method watch the php version) or if you know that this path change once a day you can make a file which is launched with routine.

If you make this, you need to store this path, but I don't know if there is a method for make global variable. My solution is to store or in a DB or in a file.

I hope I have helped you.

Answer

Solution:

What I understand from the answer https://stackoverflow.com/a/50632691/7362396 is that you need to include files based on the directory of the entrypoint script.

A solution for this without the need for Apache or php.iniauto_prepend_file could be to usegetcwd(). It returns the current working directory, which should be the path of the entrypoint/main script, even when called in included files.

Can you try if simply usinggetcwd() instead of$baseDir works?:

include_once getcwd().'/functions/includes.php';

include_once getcwd().'/functions/get.php';
Copy code

Answer

Solution:

Using Apache to fix your app is solving it at the wrong level.

If you have to update a bunch of files in your code when the location of a file changes, that is your code telling you that you have made a bad architectural decision. So fix the actual problem and stop repeating yourself.

Define where your includes live in one place, and then when needed, update that one place accordingly.

One way to do this is set a constant at the root of your app. This assumes you have a bit of code at the root of your app that is called on every page. This would likely beindex.php or a script included byindex.php:

// index.php or a file included by index.php
const MY_INCLUDE_PATH = __DIR__ . '/path/to/subfolder`
Copy code

Then your other scripts can call include using the constant:

// some other script included to handle the page
include MY_INCLUDE_PATH . '/config.php';
include MY_INCLUDE_PATH . '/some-other-include.php';
Copy code

Although if they all want to include theconfig.php file, maybe just go ahead and include it in yourindex.php.

This is not a "bad" global you want to avoid. It is using constants as they are intended. Constants are part of the namespace, if you are using a namespace for your app.

This assumes there is one include subfolder that sometimes changes places and a script somewhere that is a part of every request. Is that correct? If not, please post your directory structure.

A function would also work, and could include logic based on things such as the path of the calling script:

// index.php or a file included by index.php
my_include_function($path) {
  //do stuff
}
Copy code

The other scripts might call this function like so:

// some other script included to handle the request
my_include_function(__FILE__);
Copy code

Then when things change, you simply update one function in one file.

This all assumes you have anindex.php or similar script that handles every request and can be the single point of control for defining the function or constant. If that's not the case, it should be!

Updating your code to use a router (here is one) would take maybe 10 minutes and potentially simplify that gnarly .htaccess file you posted.