Example tutorial on using php static variables as cache

/**
 * Receiver of user request to reset password
*/
function requestResetPassword() {
 //Check if the user exists
 if( !checkUserExists( $_GET['userid'] ) ) {
 exit( 'Sorry, the user does not exist, please confirm the user account. ');
 }
 resetPassword( $_GET['userid'] );
 //Finally send an email to the user
 sendEmail( $_GET['userid'], 'Password reset successful', 'The new password is xxxx' );
 exit('The new password has been sent to your email.');
}
/**
 * Help users reset password
 */
function resetPassword( $userid ) {
 //Check if the user exists
 if( !checkUserExists( $userid ) ) {
 return false;
 }
//Reset the user Password operation
//Short of...
return true;
}
/**
 * Send an email to the user
*/
function sendEmail( $userid, $title, $content ) {
/ /Check if the user exists
if( !checkUserExists( $userid ) ) {
 return false;
}
//Send email operation
//Omitted...
return true;
}
/**
 * Check if a user exists
*/
function checkUserExists( $userid ) {
 $user = getUserInfo( $userid );
 return !empty( $user );
}
/**
 * Get a user’s data
*/
function getUserInfo( $userid ) {
 //Suppose I have a query function, which is used to query the database and return data
 $user = query( "SELECT * FROM `user` WHERE `uid`=" . intval( $userid ) );
 return is_array( $user ) ? $user : array() ;
}

Problem: These three functions all use the checkUserExists function at the same time to check that the user does not exist. The database is queried three times, which brings some additional overhead. If you want to remove any checkUserExists among the three, it seems possible. However, if some functions later call resetPassword or sendEmail, and the user does not exist, an error may occur in the system.

Another solution is to write the logic of resetPassword into requestResetPassword, and a little later, write the logic of sendEmail into it as well. In this way, function calls are reduced, database queries become one time, and performance is improved. However, the functions of resetting passwords and sending emails will not be reusable, and violate the principle of single responsibility, and the code complexity will also increase.

However, because function separation and reusability are very good, if the actual performance is affected, you may consider using caching to reduce database queries and modify their shared checkUserExists function:

/**
 * Check if a user exists
*/
function checkUserExists( $userid ) {
 //Add a cache to record the results of checking users
 static $cache = array();
 //Check whether the current user has checked once
 if( isset( $cache[ $userid ] ) ) {
 return $cache[ $userid ];
 }
 $user = getUserInfo( $userid );
 //Record the results to the cache
 $cache[ $userid ] = !empty( $user );
 return $ cache[ $userid ];
}

You can also use the same method to change the getUserInfo function.

When the reusability of code increases, it is very simple to improve performance, and performance bottlenecks are also easy to find and modify.

Consider the impact on program performance. For example, when traversing data, you may encapsulate the traversal into a function for reuse and use it multiple times. These expenses did not have as big an impact on the project as expected, and were minimal. Therefore, the focus can be on improving code reusability and maintainability, rather than dwelling on wasting a little more performance. If the actual performance really does not meet the requirements, you can also consider increasing the hardware configuration.