Increase the memory limit method of PHP There is also a personal view on the use of static classes

Increase the memory limit method of PHP There is also a personal view on the use of static classes
Of course, the static class has a good side, for example, is very suitable for some stateless tool classes, but most of the time, my subjective inclination is very clear, multi-use objects, less static classes, to avoid premature curing system. By the way, I hope I don't have someone to tell me about the static analogy object fast.

In Running a PHP program, you will typically encounter the "Fatal error:allowed memory size of xxxxxx bytes exhausted" error, which means that the PHP script uses too much memory and exceeds the maximum allowable memory set by the system. To solve this problem, you need to check whether your program is allocating too much memory, and you can increase the PHP memory limit (memory_limit) by a few methods if there is no problem with the program.

Check PHP for Memory limit values

To view this value, you need to create an empty PHP file, such as view-php-info.php. Then paste the code inside.



Put the script on your Web server and call it in the browser. At this point you can see your PHP environment configuration information, some of which are about "memory_limit", such as:



Note: You can use this method to view PHP's other parameter settings, not just Memory_limit

How much should the Memory_limit be set?

This depends entirely on the requirements of your application. such as WordPress, running the core code needs 32MB. Drupal 6 requires a minimum value of 16MB and is recommended to be set to 32MB. If you install a lot of plugins (plugins), especially those for image processing, you may need 128MB or higher memory.

How to set Memory_limit

Method 1:php.ini

The simplest or most common method is to modify the php.ini

1. First find the php.ini file that takes effect on your website because there are multiple places where you can set PHP parameters, finding the correct profile, and making changes is the first step. If you have built a PHP file in the above method to see its configuration parameters, you can find the "Loaded configuration file", the following is an example:



For Linux users, you can do this by executing the Php-i | grep Loaded configuration File "to locate the corresponding profile. While Windows users, you can try to modify the php.ini in your PHP installation directory.

2. Edit PHP.ini in php.ini, find the "Memory_limit" this item, if not, you can add this parameter at the end of the file itself. Here are some examples of settings

Memory_limit = 128M; You can change the 128M to any value you want to set

Save File

3. Restart the Web server if the Web server is using Apache, execute:

httpd restart

In some cases, you may not be allowed to modify php.ini privately. For example, if you purchase a web hosting service, your provider does not allow you to modify the file. Then, you may want to consider other ways to increase the value of the Memory_limit.

Method 2:. htaccess

Note: This method only takes effect if PHP is executed with the Apache module. Find the ". htaccess" file at the root of your website, and if not, you can create one yourself. Then put the following configuration into it

Php_value Memory_limit 128M; You can change the 128M to any value you want to set

Method 3: Modify the PHP memory settings at run time

Add the following command line to your PHP code.

Ini_set (' Memory_limit ', ' 128M ');

Memory_limit modification failed

If you use a virtual host, it is possible that the Memory_limit value modification fails. This need to contact your service provider to see how to handle, usually they limit the maximum value can be set or do not allow you to modify at all. If their environment really does not meet your requirements, then you may want to consider changing a host service provider.

Hegel has a famous saying: existence is reasonable. With this as an argument, the use of static classes must have its rationality. But extremes meet, once the code is too dependent on the static class, its deterioration of the Errenzhuan solution is inevitable. This is like Poppy as a herb, has its pharmacological value, but if unscrupulous use of large, it becomes.

What is a static class

The so-called static class refers to a class that is called directly by a static method without instantiating it into an object. The code is as follows:

Class math{public static function Ceil ($value) {return ceil ($value), public static function floor ($value) {return Flo or ($value); }}?>
The role of the class at this time is more like a namespace, which is perhaps the most straightforward reason many people prefer to use static classes.

Problems with static classes

In essence, static classes are process-oriented, because usually it is simply a mechanical process-oriented code together, although the result is in the form of a class, but at this time the class is more like an emperor's new clothes, so it can be said that the static class is actually in the object-oriented shell, doing the process-oriented thing.

One of the object-oriented design principles: programming for interfaces, not for implementation. What's the difference? For example: Aside from the price factor, do you prefer a computer with a discrete graphics card or a computer with integrated graphics? I think most people will choose a discrete graphics card. Discrete graphics can be seen as programming for interfaces, and integrated graphics can be seen as programming for implementation. So the disadvantage of implementing programming is leap off: it loses the possibility of change.

Here is an example of an article management system to specify:

Class article{Public Function Save () {Articledao::save ();}}? >
Article implements the necessary domain logic and then gives the data persistence to Articledao, and Articledao is a static class that is as difficult to change as an integrated video card welded to the motherboard, assuming that we may need to mock out the implementation of Articledao in order to test the code , but since the invocation uses the name of a static class, which is equivalent to a specific implementation that has already been bound, the mock is almost impossible, and there are, of course, some methods that can be implemented:

Class article{private static $dao = ' Articledao '; public static Funciton Setdao ($dao) {self:: $dao = $dao;} public Stati C function Save () {$dao = self:: $dao; $dao:: Save ();}}? >
With the involvement of variables, you can set which static class to use at run time:

Article::setdao (' Mockarticledao '); www.errenzhuan.cc; Article::save ();? >
Although this implementation seems to solve the problem of the mock, but first it modifies the original code, violating the open and closed principle, followed by the introduction of static variables, and static variables are shared state, it is possible to interfere with the execution of other code, so it is not a perfect solution.

Add that the use of dynamic language features, in fact, you can simply require a different class definition file to achieve the mock, but this is also a disadvantage, Imagine that we need to implement multiple transformations in the Errenzhuan www.errenzhuan.cc script, but in fact we have only one require chance, otherwise there will be a duplicate definition error.

Note: In some cases, using static delay binding can also improve the testability of static classes, refer to PHPUnit.

The value of the object

If you discard static classes and use objects instead, how do you implement an example of an article management system? The code is as follows:

Class article{Private $dao, Public function __construct ($dao = null) {if ($dao = = = null) {$dao = new Articledao ();} $t His->setdao ($dao); Public Function Setdao ($dao) {$this->dao = $dao,} public Function Save () {$this->dao->save ();}}? >
In fact, the use of dependency injection technology, which is often said, is used to inject dependent objects through a constructor or setter:

$article = new article (New Mockarticledao ()); $article->save ();? >
The object has its own state and does not occur when shared state interferes with execution of other code.

