require and include have the variations require_once and include_once. They prevent the script from loading a file multiple times.
I think I can safely assume, because the functions exist, that there would be cases where you would need the require/include function instead of the require_once/include_once one. But I cannot imagine a case like that. What would that be?
Probably the best example would be when giving output. If, say, you had a snippet of HTML that might appear more than once on various pages, you could put it into a separate file and include it as many times as you wanted.
Moreover, it's often unnecessary to use require_once or include_once. If the file will only be called once (e.g. in __autoload) then the simple functions have less overhead, because PHP doesn't need to keep track of whether the file has been included before.
One may want to use require_once instead of require if you want to have a variable or constant defined only once. This is helpful for making reusable classes in a very large code base that manages dependencies rapidly. Lets say I have a file A that needs a file B but I already include file C that included file B. Since file B was already included, the program does not have to evaluate that code again to properly evaluate file A. This is a case where you may want to include the file only once.
It helps with managing your dependencies
Related
I'm testing some database related functions in interactive mode.
The first thing I did is to include the testing file, let's say database.php
Then I can make change to the database by a function call.
The question is, when I make any changes to database.php, I have exit PHP interactive mode, re-enter, include the testing file again.
I'm seeking a way to reload the include file during the interactive mode.
There is no simple method of doing this cause PHP is not built for this job, but there are some things you can take a look at as it might do the job for you. However this all depends on what is in your database.php.
Create a simple function like reset and use PHP's runkit functions to update your include.
If your database.php contains functions, you need to remove the functions before including it again. If your file has a class defined in it you could try the import function and just call the function that does all this for you but in the end this is all manual labor and it might be simpler to look at other alternatives.
I for one use a auto refresh timer in my browser to refresh the page every # seconds. However I have two screens which makes using this method much easier.
That is something you should never do. It will create double functions, which will create confusion in the PhP interpreter.
You should require files out of your scope, so they are globally available, That way you can reduce the server overhead (memory usage) and reuse the included class directly without requiring it again.
Or you could create an autoloader, which imports the file when needed. If it is already there, it will return the needed instance without the extra overhead. An autoloader keeps track of the already included or required files.
That said, with include or required, you could load files. Instead of required_once or include_once, they keep including files.
What are the differences between "include files" and "functions" for reusing code in PHP?
I can enumerate 1 difference: when using a function, the caller script don't have access to the function local vars but when including the includer script has access to the local vars of the included script.
What are other differences?
When should i use "functions" and when should i use "include files"?
For DB connection which one is usually used?
Functions are callable blocks of code. Usually created by the developer when that certain block of code is used multiple times. Instead of writing the same code in multiple places, you create a function and call it when needed.
Also, some developers create functions to make a certain task distinct in the code for readability and understandability. They use functions as "labels" as to what a certain block of code does. For example, I'd create a readFile() function for a certain block of code that reads files.
Includes on the other hand "merges" a file into the calling file as if it were coded into that file. This makes whatever was declared in the other file available in the current file in the scope that called it.
As for what to use, you use both.
To separate DB connection code from the current file, I'd create a DB Class in another file (like dbcon.php) containing all the properties and methods (functions) needed to interface with the DB.
Then, in the file that needs the DB connection (like index.php), it should use include to "merge-in" the file containing the DB Class for index.php to use the class definition.
It seems an obvious question, but it's interesting anyway to share our experiences.
Inclusion of configuration files (constants i.e.) should be done with require_once. Because without it your system cannot works (require), and it should be included only one time (once).
So... class, DB configuration, constants and core files should be inserted by require_once and not with include, because if some file missing, it throws a fatal error and stop execution, preventing errors chain.
So, when we can use include?
include should be used for inclusion of part of code more more complex (with other inclusion for example) and with part of code that's no mandatory or essential for your system. You can think, for example, to an inclusion of one module for the view. (include a php file that process a tpl file). I thinking when I work on system with other developer: some part are shared (i.e. Database) and some part are local. If I modify something in shared part that causes a failed inclusion for other developers, it not cause a fatal error for they. (it's just an example)
Now: when I should use function instead?
When you write a lot of function you can use ONE single file included (or, better, required) and call one of this function when you want. Besides the code inside all functions is encapsulated preventing annoying conflicts with other part of code (and believe me: it happens very often and it's not always easy to find the error)
Benefit: one single file for many functions, and all code encapsulated.
In my project structure I have the usual class per file separation and auto-loading is easy, but now I would like to group some small classes in a a single file, probably a file with the name of the current folder.
now:
|/module
|-Smallclass1.php
|-Smallclass2.php
|-Smallclass3.php
|-Normalclass.php
after:
|/module
|-module.php <-- smallclasses go here
|-Normalclass.php
Now comes the debate.
To autoload one 'SmallclassX' I was thinking to check if SmallclassX.php file exists if not check if module.php exists and if so, check if the class exists inside the file and include it. Including the whole module.php file when I need a single class seems an overhead specially if the file contains many classes. Here they suggest using tokens the check if the class exists, but I'm not sure about it's efficiency, after that I'll need a method to include only the class I need.
Do you think if I get to load only the class I need like I mentioned, will it be also an overhead because of reading the file more that once and looking inside to include the piece of code I want?
You can stack autoloaders using spl_autoload_register, allowing you to first attempt to load the class from a dedicated file, then falling back to including the module file afterwards (and if no autoloader can solve the dependency, error out normally). This will allow you to avoid all hacks by parsing tokens and other items, which will require a lot more than just require-ing the file and seeing what the result is afterwards.
I would however advice you to benchmark this solution. Whether it's more effective will depend on the delay for accessing the files (APC) and the cost of parsing and including each class seperately.
I'll also agree with the other comments, it might be confusing that you have two separate schemes for including classes, and APC will remove most of the cost of having separate files anyway.
I have a website that has about 150 require_once calls in a "catalog" page. Each page calls require_once on this catalog to make sure all necessary files are loaded. Calling require_once on this catalog takes somewhere between 5 and 15 seconds, and I have no easy way to reduce the number of classes each page needs.
So: is there any way to speed up this process? I assume it will need to be done once, but I also assumed it would be cached for the session, which doesn't seem to be the case since this 5-15 second overhead is the same on every single page load.
Hopefully this makes sense.
Thanks!
The idea behind require_once is to make sure:
You don't have the file more than once.
Make load times faster so that the file isn't included again.
PHP stores in memory what files have already been loaded. If you call require_once on a file and then call it again, PHP won't even look for the file, it'll see that it's already been loaded and won't bother to read the file.
This makes me think that require_once isn't the culprit of your page load issues.
However, I may be misunderstanding the question. If you mean that each require_once is different, then that's another story. IF they are used to load classes, check out the PHP autoload function. PHP: Autoloading Classes. This will only load the classes that are called upon.
My first guess would be that you have some logic defined in one of your required scripts. If they were all just class definition files, there's no reason requiring them would take 5-15 seconds.
Is there some reason you're including every class on every page? You should look into autoloading classes instead, if possible.
I've always thought that all of the includes should be at the top of your code. At a new job I see that they will use includes and create an instance of that class wherever they need it throughout the code.
Is it more efficient to use includes somewhere else, possibly under a control structure...
Ex. If ($monkey){
include_once(banana.class.php);
$old_banana = new banana;
}
Then if monkey is never true the banana class doesn't ever need to be included.
What are best practices when it comes to this. (PHP)
it is for sure more efficient to use include/require only if you need it (inside control stuctures) however this can sometimes reduce the readibility of a script.
There is a new feature in PHP 5.3 called __autoload. You make instance of a class, php includes the instantiated class files. Thus you won`t have to worry if the file is included or not.
As I review code from some big projects like joomla and community build, I see that they usually include only when they need. This is the way I prefer to code as I believe it is more efficient.