Summary of several methods for calculating page loading time in php

You can obtain and subtract the start time and end time of the page through the commonly used microtime (). The calculation result is a period of time that the page has been running, however, this is not necessarily the time when the page is running.

You can obtain and subtract the start time and end time of the page through the commonly used microtime (). The calculation result is a period of time that the page has been running, however, this is not necessarily the time when the page is running.

The instance code is as follows:

2. // Instance: calculates the page runtime loading time
3. // Analysis: get a time when the page is opened, and get a time when the load is complete. the running time is the difference between the two.
4. // 1. user-defined functions
5. Function fn (){
6. List ($ a, $ B) = explode ('', microtime (); // gets and splits the current timestamp and number of milliseconds, and assigns the value to the variable
7. Return $ a + $ B;
8. }
9. // 2. obtain the start time
10. $ Start_time = fn ();
11. // 5. loading process
12. For ($ I = 0; I I <10000000; $ I ++ ){
13. // Do nothing;
14. }
15. // 3. obtain the end time
16. $ End_time = fn ();
17. // 4. calculate the difference value
18. Echo $ end_time-$ start_time;
19. // 5. format the output
20. Echo' ';
21. $ T = $ end_time-$ start_time;
22. Echo round ($ t, 2 );
23. ?>

If you use microtime () to obtain and subtract the start time and end time of the page, the calculation result is page running.

This is not necessarily the time when the page runs, because there may be multiple PHP scripts.

This page is executed together, so I think that method is not accurate

The following is an example of how to calculate the page running time in php from the internet. For more information, see.

Recently I wrote a time computing class for program running for your reference:

The instance code is as follows:

1. Class Timer {
2. Private $ StartTime = 0; // The start time of the program.
3. Private $ StopTime = 0; // end time of the program running
4. Private $ TimeSpent = 0; // time spent on running the program
5. Function start () {// start the program
6. $ This-> StartTime = microtime ();
7. }
8. Function stop () {// The end of the program running
9. $ This-> StopTime = microtime ();
10. }
11. Function spent () {// time spent on running the program
12. If ($ this-> TimeSpent ){
13. Return $ this-> TimeSpent;
14. } Else {
15. List ($ StartMicro, $ StartSecond) = explode ("", $ this-> StartTime );
16. List ($ StopMicro, $ StopSecond) = explode ("", $ this-> StopTime );
17. $ Start = doubleval ($ StartMicro) + $ StartSecond;
18. $ Stop = doubleval ($ StopMicro) + $ StopSecond;
19. $ This-> TimeSpent = $ stop-$ start;
20. Return substr ($ this-> TimeSpent,). "seconds"; // return the time difference between the obtained programs.
21. }
22. }
23. }
24. $ Timer = new Timer ();
25. $ Timer-> start ();
26. // Code for running the program...
27. $ Timer-> stop ();
28. Echo "program Running time:". $ timer-> spent ();

Now let's look at how simple the page loading time for program computing is.

The instance code is as follows:

2. Class runtime
3. {
4. Var $ StartTime = 0;
5. Var $ StopTime = 0;
6. Function get_microtime ()
7. {
8. List ($ usec, $ sec) = explode ('', microtime ());
9. Return (float) $ usec (float) $ sec );
10. }
12. Function start ()
13. {
14. $ This-> StartTime = $ this-> get_microtime ();
15. }
17. Function stop ()
18. {
19. $ This-> StopTime = $ this-> get_microtime ();
20. }
22. Function spent ()
23. {
24. Return round ($ this-> StopTime-$ this-> StartTime) * 1000, 1 );
25. }
26. }
27. // Start the instance
28. $ Runtime = new runtime;
29. $ Runtime-> start ();
30. // Start your code
31. $ A = 0;
32. For ($ I = 0; I I <1000000; $ I)
33. {
34. $ A = $ I;
35. }
36. // Your code ends
37. $ Runtime-> stop ();
38. Echo "page Execution time:". $ runtime-> spent (). "millisecond ";
39. ?>