1. Do not use relative paths
Often you will see:
Require_once ('.. /.. /lib/some_class.php ');
There are many drawbacks to this approach:
It first looks for the specified PHP include path and then finds the current directory.
Therefore, too many paths are checked.
If the script is included in a script from another directory, its base directory becomes the directory where the other script resides.
Another problem is that when a timed task runs the script, its parent directory may not be the working directory.
So the best option is to use absolute paths:
Define (' ROOT ', '/var/www/project/');
Require_once (ROOT. '.. /.. /lib/some_class.php ');
Rest of the code
We define an absolute path, and the value is written dead. We can also improve it. Path/var/www/project can also change, so do we have to change it every time? No, we can use __file__ constants, such as:
Suppose your script is/var/www/project/index.php
Then __file__ 'll always has that full path.
Define (' ROOT ', PathInfo (__file__, pathinfo_dirname));
Require_once (ROOT. '.. /.. /lib/some_class.php ');
Rest of the code
Now, no matter which directory you move to, such as a server that is moved to an extranet, the code will run correctly without changes.
2. Do not use require directly, include, Include_once, required_once
You can introduce multiple files in the script header, such as Class libraries, tool files, helper functions, and so on, such as:
Require_once (' lib/database.php ');
Require_once (' lib/mail.php ');
Require_once (' helpers/utitlity_functions.php ');
This usage is quite primitive. should be more flexible. You should write an assistant function that contains the file. For example:
function Load_class ($class _name)
{
Path to the class file
$path = ROOT. '/lib/'. $class _name. '. php ');
Require_once ($path);
}
Load_class (' Database ');
Load_class (' Mail ');
Is there anything different? The code is more readable.
You can expand the function as needed, such as:
function Load_class ($class _name)
{
Path to the class file
$path = ROOT. '/lib/'. $class _name. '. php ');
if (file_exists ($path))
{
Require_once ($path);
}
}
You can also do more:
Find multiple directories for the same file
It is easy to change the directory where the class files are placed, without having to modify the code one by one everywhere
You can use similar functions to load files, such as HTML content.
3. Keep Debug code for your app
In the development environment, we print the database query statements, dump the problematic variable values, and once the problem is resolved, we annotate or delete them. However, a better practice is to keep the debug code.
In the development environment, you can:
Define (' Environment ', ' development ');
if (! $db->query ($query)
{
if (Environment = = ' development ')
{
echo "$query failed";
}
Else
{
echo "Database error. Please contact administrator ";
}
}
In the server, you can:
Define (' environment ', ' production ');
if (! $db->query ($query)
{
if (Environment = = ' development ')
{
echo "$query failed";
}
Else
{
echo "Database error. Please contact administrator ";
}
}
4. Execute commands using a function that can be cross-platform
System, exec, PassThru, shell_exec these 4 functions can be used to execute systems commands. Each behavior has a slight difference. The problem is that when in a shared host, some functions may be selectively disabled. Most novices tend to first check which function is available at a time, but then use it.
A better solution is to marshal functions into a cross-platform function.
/**
Method to execute a command in the terminal
Uses:
1. System
2. PassThru
3. exec
4. Shell_exec
*/
function Terminal ($command)
{
System
if (function_exists (' System '))
{
Ob_start ();
System ($command, $return _var);
$output = Ob_get_contents ();
Ob_end_clean ();
}
PassThru
else if (function_exists (' PassThru '))
{
Ob_start ();
PassThru ($command, $return _var);
$output = Ob_get_contents ();
Ob_end_clean ();
}
Exec
else if (function_exists (' exec '))
{
EXEC ($command, $output, $return _var);
$output = implode ("\ n", $output);
}
Shell_exec
else if (function_exists (' shell_exec '))
{
$output = Shell_exec ($command);
}
Else
{
$output = ' Command execution not possible on the this system ';
$return _var = 1;
}
Return array (' output ' = $output, ' status ' = $return _var);
}
Terminal (' ls ');
The above function will run the shell command, as long as a system function is available, which preserves the consistency of the code.
5. Flexible writing functions
function Add_to_cart ($item _id, $qty)
{
$_session[' cart ' [' item_id '] = $qty;
}
Add_to_cart (' IPHONE3 ', 2);
Use the function above to add a single item. And when you add a list of items, do you want to create another function? No, just a little attention to the different types of parameters, it will be more flexible. Such as:
function Add_to_cart ($item _id, $qty)
{
if (!is_array ($item _id))
{
$_session[' cart ' [' item_id '] = $qty;
}
Else
{
foreach ($item _id as $i _id = $qty)
{
$_session[' cart ' [' i_id '] = $qty;
}
}
}
Add_to_cart (' IPHONE3 ', 2);
Add_to_cart (Array (' IPHONE3 ' = + 2, ' IPAD ' = 5));
Now, the same function can handle different types of input parameters. You can refactor your multiple code to make it smarter by referencing the example above.
6. Intentionally ignoring the PHP close tag
I'd like to know why so many blog posts about PHP suggestions don't mention this.
echo "Hello";
Now dont close this tag
This will save you a lot of time. Let's give an example:
A super_class.php file
Class Super_class
{
function Super_function ()
{
Super Code
}
}
?>
Super extra character after the closing tag
index.php
Require_once (' super_class.php ');
Echo an image or PDF, or set the cookie or session data
This way, you will get a Headers already send error. Why? Because "super extra character" has been output. Now you have to start debugging. This will take a lot of time to find the Super extra location.
Therefore, develop the habit of omitting the closing character:
Class Super_class
{
function Super_function ()
{
Super Code
}
}
No closing Tag
That would be better.
7. Collect all inputs in one place, one output to the browser
This is called output buffering, if you have output content in a different function:
function Print_header ()
{
echo "Site Log and Login links";
}
function Print_footer ()
{
echo "Site was made by me";
}
Print_header ();
for ($i = 0; $i < $i + +)
{
echo "I is: $i
';
}
Print_footer ();
Alternative, collect the output centrally in a place. You can store them in local variables of a function, or you can use Ob_start and Ob_end_clean. As follows:
function Print_header ()
{
$o = "Site Log and Login links";
return $o;
}
function Print_footer ()
{
$o = "Site was made by me";
return $o;
}
Echo Print_header ();
for ($i = 0; $i < $i + +)
{
echo "I is: $i
';
}
Echo Print_footer ();
Why output buffering is required:
>> can change the output before sending it to the browser. such as the Str_replaces function or may be preg_replaces or add some monitoring/debugging HTML content.
>> output to the browser while doing PHP processing is very bad. You should have seen some of the site's sidebar or the middle of an error message. Do you know why it happened? Because processing and output are mixed.
8. Send the correct MIME type header information if the output is non-HTML content.
Output some XML.
$xml = ' ';
$xml = "
0
";
Send XML data
Echo $xml;
Work well. But some improvements are needed.
$xml = ' ';
$xml = "
0
";
Send XML data
Header ("Content-type:text/xml");
Echo $xml;
Note the header line. The line tells the browser that the content of the XML type is being sent. So the browser can handle it correctly. Many JavaScript libraries also rely on header information.
Similar to JavaScript, CSS, jpg image, PNG image:
Javascript
Header ("Content-type:application/x-javascript");
echo "var a = 10";
Css
Header ("Content-type:text/css");
echo "#div ID {background: #000;}";
9. Set the correct character encoding for MySQL connection
Once encountered in the MySQL table set unicode/utf-8 encoding, Phpadmin can also be displayed correctly, but when you get the content and in the output of the page, there will be garbled. The problem here is the character encoding of the MySQL connection.
Attempt to connect to database
$c = Mysqli_connect ($this->host, $this->username, $this->password);
Check Connection Validity
if (! $c)
{
Die ("Could does connect to the database host:
". Mysqli_connect_error ());
}
Set the character set of the connection
if (!mysqli_set_charset ($c, ' UTF8 '))
{
Die (' Mysqli_set_charset () failed ');
}
Once the database is connected, it is best to set the characterset of the connection. If your app supports multiple languages, this is a must.
10. Set the correct encoding options using htmlentities
Before php5.4, the character's default encoding is iso-8859-1 and cannot be directly output such as Àâ.
$value = Htmlentities ($this->value, ent_quotes, CHARSET);
After php5.4, the default encoding is UTF-8, which solves many problems. But if your app is multilingual, keep an eye out for coding issues.
11. Do not use gzip compression output in your app to allow Apache to process
Have you considered using Ob_gzhandler? Don't do that. There is no point. PHP only applies to writing apps. You should not worry about server and browser data transfer optimization issues.
Use Apache's Mod_gzip/mod_deflate module to compress content.
12. Using Json_encode to output dynamic JavaScript content
You can often use PHP to output dynamic JavaScript content:
$images = Array (
' Myself.png ', ' friends.png ', ' colleagues.png '
);
$js _code = ";
foreach ($images as $image)
{
$js _code. = "' $image ',";
}
$js _code = ' var images = ['. $js _code. ']; ';
echo $js _code;
Output is var images = [' Myself.png ', ' friends.png ', ' colleagues.png ',];
Smarter way to use Json_encode:
$images = Array (
' Myself.png ', ' friends.png ', ' colleagues.png '
);
$js _code = ' var images = '. Json_encode ($images);
echo $js _code;
Output Is:var images = ["Myself.png", "Friends.png", "Colleagues.png"]
Elegant?
13. Check the directory Write permission before writing the file
Before writing or saving the file, make sure the directory is writable, and if it is not writable, output the error message. This will save you a lot of debugging time. Linux system, the need to handle permissions, directory permissions can cause a lot of problems, files may not be read and so on.
Make sure your app is smart enough to output some important information.
$contents = "all the content";
$file _path = "/var/www/project/content.txt";
File_put_contents ($file _path, $contents);
This is generally true. But there are some indirect problems. File_put_contents may fail for several reasons:
>> Parent Directory does not exist
>> directory exists, but not writable
>> file is written locked?
So it's better to do a clear check before writing a file.
$contents = "all the content";
$dir = '/var/www/project ';
$file _path = $dir. "/content.txt";
if (is_writable ($dir))
{
File_put_contents ($file _path, $contents);
}
Else
{
Die ("Directory $dir are not writable, or does not exist. Please check ");
}
After doing so, you will get a clear message of where the file is written and why it failed.
14. Change the file permissions created by the app
In a Linux environment, permissions issues can be a waste of your time. Henceforth, whenever you create some files, be sure to use chmod to set the correct permissions. Otherwise, the file may be created first by "PHP" users, but you use other users to log on to work, the system will be denied access or open the file, you have to struggle to get root permissions, change the permissions of the file and so on.
Read and write for owner, read for everybody else
chmod ("/somedir/somefile", 0644);
Everything for owner, read and execute for others
chmod ("/somedir/somefile", 0755);
15. Do not rely on the Submit button value to check the form submission behavior
if ($_post[' submit '] = = ' Save ')
{
Save the Things
}
Most of the above are correct, except that the application is multilingual. ' Save ' may represent other meanings. How do you tell them apart? Therefore, do not rely on the value of the Submit button.
if ($_server[' request_method ') = = ' POST ' and isset ($_post[' submit '))
{
Save the Things
}
Now you're free from the value of the Submit button.
16. Define a static variable for a variable that always has the same value within a function
Delay for some time
function delay ()
{
$sync _delay = get_option (' Sync_delay ');
echo "
Delaying for $sync _delay seconds ... ";
Sleep ($sync _delay);
echo "Done
";
}
Replace with static variables:
Delay for some time
function delay ()
{
static $sync _delay = null;
if ($sync _delay = = null)
{
$sync _delay = get_option (' Sync_delay ');
}
echo "
Delaying for $sync _delay seconds ... ";
Sleep ($sync _delay);
echo "Done
";
}
17. Do not use the $_session variable directly
Some simple examples:
$_session[' username '] = $username;
$username = $_session[' username ');
This can cause some problems. If multiple apps are running in the same domain name, the session variables may conflict. Two different applications may use the same session key. For example, a front-end portal that uses the same domain name as a backend management system.
From now on, use the application-related key and a wrapper function:
Define (' app_id ', ' abc_corp_ecommerce ');
Function to get a session variable
function Session_get ($key)
{
$k = app_id. '.' . $key;
if (Isset ($_session[$k]))
{
return $_session[$k];
}
return false;
}
Function Set the session variable
function Session_set ($key, $value)
{
$k = app_id. '.' . $key;
$_session[$k] = $value;
return true;
}
18. Encapsulating tool functions in a class
If you define a number of tool functions in a file:
function Utility_a ()
{
This function does a utility thing like string processing
}
function Utility_b ()
{
This function does nother utility thing like database processing
}
function Utility_c ()
{
This function is ...
}
The use of these functions is dispersed throughout the application. You might want to encapsulate them in a class:
Class Utility
{
public static function Utility_a ()
{
}
public static function Utility_b ()
{
}
public static function Utility_c ()
{
}
}
and call them as
$a = utility::utility_a ();
$b = Utility::utility_b ();
The obvious benefit is that if PHP has a function with the same name, you can avoid collisions.
Another view is that you can maintain multiple versions of the same class in the same application without causing a conflict. This is the basic benefit of encapsulation, without it.
Bunch of Silly tips
>> use echo instead of print
>> use Str_replace instead of preg_replace, unless you absolutely need
>> do not use the short tag
>> simple string with single quotation mark instead of double quotation mark
Remember to use exit after >>head redirect
>> do not call functions in loops
>>isset is faster than strlen.
Formatted code as in >>
>> do not delete loops or if-else parentheses
Don't write code like this:
if ($a = = true) $a _count++;
This is absolutely waste.
Written:
if ($a = = true)
{
$a _count++;
}
Do not attempt to omit some syntax to shorten the code. But to make your logic brief.
>> use a text editor that has a highlighted syntax display. Highlighting syntax can help you reduce errors.
20. Using Array_map to quickly process arrays
For example, you want to trim all the elements in the array. Novice May:
foreach ($arr as $c = $v)
{
$arr [$c] = Trim ($v);
}
But using Array_map is easier:
$arr = Array_map (' Trim ', $arr);
This applies the call trim for each element of the $arr array. Another similar function is Array_walk. Check out the documentation to learn more tips.
21. Validating Data Using PHP filter
You must have used regular expressions to verify email, IP address, and so on. Yes, everyone uses it that way. Now, we want to make a different attempt, called filter.
The filter extension of PHP provides a simple way to validate and check input.
22. Mandatory type checking
$amount = intval ($_get[' amount ');
$rate = (int) $_get[' rate '];
It's a good habit.
23. If required, use profiler such as Xdebug
If you use PHP to develop large-scale applications, PHP takes a lot of computation, and speed is a very important indicator. Use profile to help optimize your code. can be used
Xdebug and WebGrid.
24. Handle large arrays with care
For large arrays and strings, you must handle them with care. A common mistake is the occurrence of an array copy causing memory overflow, throwing fatal error of the Memories size information:
$db _records_in_array_format; This is a big array holding $ rows from a table each have a columns, every row is atleast 10 bytes XX * = 2MB
$CC = $db _records_in_array_format; 2MB more
Some_function ($CC); Another 2MB?
This is often done when importing or exporting a CSV file.
Do not assume that the above code will often cause the script to crash due to memory limitations. There is no problem with small variables, but it must be avoided when dealing with large arrays.
Ensure that it is passed by reference or stored in a class variable:
$a = Get_large_array ();
Pass_to_function (& $a);
When you do this, pass the variable reference to the function instead of copying the array. View the document.
Class A
{
function First ()
{
$this->a = Get_large_array ();
$this->pass_to_function ();
}
function Pass_to_function ()
{
Process $this->a
}
}
Unset them as quickly as possible, freeing up memory to relieve the burden of scripting.
25. Use a single database connection from start to finish
Make sure that your scripts use a single database connection from start to finish. Open the connection correctly at the beginning, use it until the end, and then close it. Do not open the connection in the function as follows:
function Add_to_cart ()
{
$db = new Database ();
$db->query ("INSERT into cart ...");
}
function Empty_cart ()
{
$db = new Database ();
$db->query ("DELETE from cart ...");
}
Using multiple connections is a bad thing, and they slow down the app because creating a connection takes time and memory.
A singleton pattern, such as a database connection, is used for specific situations.
26. Avoid writing SQL directly, abstract
Too much to write too many of the following statements:
$query = "INSERT into users (name, email, address, phone) VALUES (' $name ', ' $email ', ' $address ', ' $phone ')";
$db->query ($query); Call to Mysqli_query ()
This is not a plan to build strong. It has some drawbacks:
>> manually escape values each time
>> Verify that the query is correct
>> query errors can take a long time to identify (unless checked with if-else each time)
>> difficult to maintain complex queries
So use the function encapsulation:
function Insert_record ($table _name, $data)
{
foreach ($data as $key = $value)
{
Mysqli_real_escape_string
$data [$key] = $db->mres ($value);
}
$fields = Implode (', ', Array_keys ($data));
$values = "'". Implode ("', '", Array_values ($data)). "'";
Final Query
$query = "INSERT into {$table} ($fields) VALUES ($values)";
Return $db->query ($query);
}
$data = Array (' name ' = = $name, ' email ' + $email, ' address ' = = $address, ' phone ' + $phone);
Insert_record (' users ', $data);
Did you see it? This makes it easier to read and expand. The Record_data function is handled with care for escaping.
The biggest advantage is that the data is preprocessed into an array, and any syntax errors are captured.
The function should be defined in a database class, and you can call it like $db->insert_record.
Check out this article to see how you can make it easier to work with databases.
Similarly, you can also write Update,select,delete methods. Give it a try.
27. Cache the database-generated content in a static file
If all the content is obtained from the database, they should be cached. Once generated, they are saved in a temporary file. The next time the page is requested, it can be taken directly from the cache without having to look up the database.
Benefits:
>> save time on PHP processing pages, execute faster
>> fewer database queries means less MySQL connection overhead
28. Save the session in the database
There are many limitations to the file-based session strategy. Using a file-based session cannot be extended to the cluster because the session is saved in a single server. But the database can be accessed by multiple servers, which solves the problem.
There are many more benefits of saving session data in a database:
>> handles username recurring login issues. The same username cannot be logged in two locations at the same time.
>> can be more prepared to query online user status.
29. Avoid using global variables
>> using Defines/constants
>> using functions to get values
>> using classes and accessing through $this
30. Using the base tag in the head
Never heard of him? Please see below:
The base tag is very useful. Suppose your app is divided into subdirectories, all of which include the same navigation menu.
www.domain.com/store/home.php
www.domain.com/store/products/ipad.php
In the home page, you can write:
Home
Ipad
But in your ipad.php you have to write:
Home
Ipad
Because the directory is different. There are so many different versions of the navigation menu to maintain, very bad AH.
Therefore, use the base tag.
Home
Ipad
Now, this code is consistent across the app's catalog files.
31. Never set the error_reporting to 0
Close the non-phase error report. It is important to e_fatal errors.
Ini_set (' display_errors ', 1);
Error_reporting (~e_warning & ~e_notice & ~e_strict);
32. Pay attention to the platform architecture
Integers are different in length in 32-bit and 64-bit architectures. Therefore, some functions, such as strtotime, behave differently.
In a 64-bit machine, you will see the following output.
$ php-a
Interactive Shell
php > Echo strtotime ("0000-00-00 00:00:00");
-62170005200
php > Echo strtotime (' 1000-01-30 ');
-30607739600
php > Echo strtotime (' 2100-01-30 ');
4104930600
But in 32-bit machines, they will be bool (false). See here for more information.
33. Do not rely too much on set_time_limit
If you want to limit the minimum time, you can use the following script:
Set_time_limit (30);
Rest of the Code
Do you have peace of mind? Note that any external execution, such as system calls, socket operations, database operations, etc., is not under set_time_limits control.
Therefore, even if the database spends a lot of time querying, the script will not stop executing. Subject to availability.
34. Using the extension library
Some examples:
>>mpdf--can generate PDF documents from HTML
>>phpexcel--Read and write Excel
>>phpmailer-Easily handle sending messages that contain nearby
>>pchart--Generate reports using PHP
Use the open Source library for complex tasks such as generating PDFs, ms-excel files, reports, and more.
35. Using the MVC framework
It's time to use an MVC framework like CodeIgniter. The MVC framework does not force you to write object-oriented code. They only separate PHP code from HTML.
>> clearly distinguishes between PHP and HTML code. There are benefits in team collaboration, and designers and programmers can work at the same time.
>> Object-oriented design functions that make it easier for you to maintain
>> built-in functions do a lot of work and you don't need to write them repeatedly
>> development of large applications is a must
>> Many suggestions, tips and hack have been implemented by the framework
36. Always Look at Phpbench
Phpbench provides some benchmark results for basic PHP operations, and it shows how the minor grammatical changes in some badges lead to huge differences.
Review the comments on the PHP site, ask questions to IRC, read open source code, and use Linux development.
Oschina Original Translation
http://www.bkjia.com/PHPjc/325847.html www.bkjia.com true http://www.bkjia.com/PHPjc/325847.html techarticle 1. Do not use relative paths often see: require_once ('.. /.. /lib/some_class.php '); This approach has many drawbacks: it first finds the specified PHP include path, and then finds the current directory. The reason for ...
