Как вывести время работы скрипта php

Как узнать время выполнения скрипта

При отладке скриптов обязательным фактором, который необходимо учитывать в первую очередь, является время выполнения скрипта. И в этой небольшой статье я покажу очень хороший и простой способ, как узнать время выполнения скрипта.

В основе лежат функции для работы с датой и временем. Предлагаю рассмотреть пример, чтобы Вы поняли, как происходит подсчёт времени выполнения скрипта:

В результате мы увидим, что время выполнения скрипта будет, например, таким: «0.014652967453«. Если округлить, то это 0.015 секунды. Это и есть время выполнения скрипта.

Теперь о том, как это работает. Функция microtime() с переданным значением true возвращает число секунд, прошедших с полуночи 01.01.1970, причём это значение подсчитано до сотых долей секунды.

Далее идёт обычный скрипт, который мы и проверяем. Вместо него, безусловно, будет Ваш скрипт. И, наконец, последней строкой идёт разница между текущим временем (после выполнения скрипта) и тем, что мы зафиксировали при старте скрипта. Разница времени после выполнения скрипта и времени до начала его работы, и есть время выполнения скрипта.

Думаю, здесь всё просто. А вот применять этот способ подсчёта времени я Вам настоятельно рекомендую. Например, когда я отлаживал работу своего движка, на котором и стоит данный сайт, я ускорил его работу почти в 2 раза.

Копирование материалов разрешается только с указанием автора (Михаил Русаков) и индексируемой прямой ссылкой на сайт (http://myrusakov.ru)!

Добавляйтесь ко мне в друзья ВКонтакте: http://vk.com/myrusakov.
Если Вы хотите дать оценку мне и моей работе, то напишите её в моей группе: http://vk.com/rusakovmy.

Если Вы не хотите пропустить новые материалы на сайте,
то Вы можете подписаться на обновления: Подписаться на обновления

Если у Вас остались какие-либо вопросы, либо у Вас есть желание высказаться по поводу этой статьи, то Вы можете оставить свой комментарий внизу страницы.

Порекомендуйте эту статью друзьям:

Если Вам понравился сайт, то разместите ссылку на него (у себя на сайте, на форуме, в контакте):

Она выглядит вот так:

BB-код ссылки для форумов (например, можете поставить её в подписи):

Комментарии ( 20 ):

А для чего есть переменная $_SERVER[«REQUEST_TIME»] ?

Можно и её использовать вместо $start, суть та же самая будет и результат тот же (поскольку функция microtime() выполняется почти мгновенно). Это кому как удобнее, я показал свой вариант.

Здравствуйте Михаил. Я пишу свою CMS и при создании совмещаю ООП и процедурный стиль. Время выполнения от 0.041 до 0.059 . Я так понимаю время это не плохое. Вопрос в другом стоит ли использовать совмещения стилей програмирования и можно ли так делать?

Михаил, а ваш сайт какое время выполнения скрипта имеет?

18-24 мс в зависимости от страницы.

Ого. Я сделал форум, он у меня выполняется 2-3 секунды. Как можно ускорить? Какие операции занимают больше всего времени?

Хорошая эта штуковина с измерением времени. Оказалось у меня время подключения к БД примерно 1.0148439407349 секунд. Интересно из-за чего это? Из-за СУБД?

Надо тестировать и смотреть, какая строка кода занимает больше всего времени.

Создал такой скрипт: Время выполнения 1.01 — 1.06 сек.

Вау. Аж залетал сайт. Я то думаю, чего он так долго грузится? Думал из-за многих и больших запросов (может и не грамотно). Оказалось в host у меня стояло: 127.0.0.1:8080 localhost . Убрал порт, все залетало:) Спасибо!

Михаил,я вот делаю сайт и в меня там все из базы данных вытаскиваеться,меню,текст,комментарии,и многое,и 2 раза подключаються файлы на каждой странице и вот время выполнение 0.12234306335449 скажите ето сколько милисекунд и ето плохая скорость, или быстрая. Спасибо заранее.

что за переменная sum?

Это просто пример суммирования.

Мне вот тоже интересно узнать. Время выполнения движка на страницу колеблется от 14 до 20 мсек. Это нормально? При условии, что тестирую движок со всеми свистелками на денвере (на своем пк). И как это скажется, если я, допустим, поставлю этот движок на свой сайт в инете, где посещаемость 2000+ в день? Очень заинтересовался вопросом оптимизации, и мучает много вопросов по этой теме, в основном по поводу быстродействия движка, при N-посещаемости на сайте.

Александр, это хороший результат, для домашнего ПК. Сложно сказать как будет вести себя сайт, надо тестировать под нагрузкой.

Спасибо, Александр, успокоили на первое время 🙂

Можете подсказать самый простой но практичный способ добавления статей на сайт?чтобы не вручную html писать каждый раз а прямо на сайте написать статью и нажать кнопку добавить и она появилась в разделе нужном.расскажите о принципах.полностью код писать не нужно. спасибо!

Здравствуйте. Все не так просто как хотелось бы. Тут одним HTML не обойтись. Используется связка php+mySQL. Элементарно сделать, это можно путем добавления текста, который введен в форму в БД, а с БД выводить уже.

понял.спасибо.буду разбираться сам ))) а можете еще ответить на мой вопрос на странице http://myrusakov.ru/podkluchenie-file-php.html спасибо

Для добавления комментариев надо войти в систему.
Если Вы ещё не зарегистрированы на сайте, то сначала зарегистрируйтесь.

Copyright © 2010-2021 Русаков Михаил Юрьевич. Все права защищены.

Источник

Время выполнения скрипта PHP и потребляемая память

Содержание:

Несколько способов узнать время выполнения скрипта PHP и затраченный объем памяти при выполнении этого скрипта.

Время выполнения скрипта

Способ #1

Функция microtime() с переданным значением true возвращает число секунд, прошедших с полуночи 01.01.1970 , причём это значение подсчитано до сотых долей секунды. Затем идёт сам скрипт (исполняемый код), который мы и проверяем. В последней строкой будет разница между текущим временем (после выполнения скрипта) и тем, что мы зафиксировали при старте скрипта. Разница времени после выполнения скрипта и времени до начала его работы, и есть время выполнения скрипта.

Способ #2

Можно вместо $start = microtime(true) брать значение из переменной $_SERVER[‘REQUEST_TIME_FLOAT’] , которая содержит время запроса к серверу. Вычисление времени выполнения происходит за исполняемым кодом.

Способ #3

Если на сервере установлен Xdebag :

Способ #4

Можно подсчитать среднее значение выполнения скрипта и записать результат в логи:

Класс для получения времени выполнения скрипта

Очень простой класс, который можно использовать для получения времени выполнения скрипта PHP. Имеет приватное статическое свойство $start , в которой будет храниться время начала выполнения скрипта и имеющее значение по умолчанию $start = .0 . Метод start() присваивает значение, которое вернула функция microtime свойству $start . Метод finish() возвращает разницу между текущим временем (после выполнения скрипта) и тем, что мы зафиксировали при старте скрипта (присвоили значение в $start ).

Так используем класс:

Объем использованной памяти

Функция memory_get_usage() возвращает количество памяти в байтах, которое было выделено PHP скрипту на данный момент.

Принцип очень похож на измерение времени выполнения скрипта, о котором речь шла выше. Здесь тоже есть, как бы, стартовое состояние и и разница между текущим состоянием и стартовым.

В Xdebug есть функция xdebug_memory_usage() , которая возвращает тот же результат.

Конвертация результата в килобайты и мегабайты

Время выполнения скрипта и объём потреблённой памяти

Время выполнения скрипта и объём потреблённой памяти в Yii2

Вывести время выполнения скрипта и объём потреблённой памяти в Yii2:

Источник

Как измерить время работы скрипта на php и для чего это нужно?

Приветствую Вас, уважаемые читатели блога webcodius! Итак, сразу к делу. Сначала отвечу на вторую часть вопроса: зачем же может понадобиться измерить время выполнения скрипта?.При работе над отладкой веб-проектов важным фактором, который следует обязательно учитывать, является время выполнения скриптов. Этот параметр необходим чтобы понять насколько быстро и производительно работает тот или иной кусок кода. Определив время потраченное сервером на выполнение php скрипта, вы сможете сделать вывод: требуется ли оптимизация кода или нет. Далее рассмотрим как это сделать.

Для анализа производительности php-скриптов существуют различные расширения и библиотеки, например XDebug, которое может выполнять отладку скриптов и профилировать их по времени выполнения. Но для использования таких расширений требуется потратить время на их установку и настройку. Конечно для оптимизации работы крупных проектов со соложной архитектурой, большим количеством скриптов и миллионами строк кода лучше воспользоваться такими расширениями. Но если необходимо оптимизировать 3-4 скрипта с одной или двумя сотнями строк кода, то для измерения времени работы скрипта можно воспользоваться только средствами php.

Как в php определить время выполнения скрипта

Данная задача легко решается с помощью функций для работы с датой и временем, а именно встроенной функции microtime() , которая возвращает число секунд, прошедших с полуночи 01.01.1970. Вызвав эту функцию дважды, мы можем вычислить время прошедшее в период между вызовами:

Если запустить скрипт, то результат будет примерно таким:

Время выполнения скрипта: 0,00059400000000001

Кратко, как это работает. С помощью функции microtime(true) запоминаем метку времени начала работы скрипта в переменную $start . Далее идет рабочий код, который выполняет какие-то действия. В данном примере просто вызывается функция usleep() , которая замедляет работу скрипта на задданное количество микросекунд. И затем получаем время окончания работы скрипта, запоминаем ее в переменную $end и вычисляем время выполнения кода путем вычитания $start из $end . В итоге получили время выполнения скрипта.

Теперь зная как определить в php время выполнения скрипта, вы можете приступать к оптимизации различных блоков кода. Желаю удачи и до встречи в следующих постах!

Источник

Время выполнения скрипта php и php-функций

Сегодня узнаем, как измерять время выполнения скрипта php и отдельных php-функций.

Время выполнения скрипта php

Узнать время выполнения скрипта php очень просто, сначала засекаем время начала работы скрипта в переменной $start , функция getMicrotime() просто возвращает для удобства метку времени, а в конце работы скрипта считаем разницу вычитанием getMicrotime()-$start

function getMicrotime() <
return microtime(true);
>
$start = getMicrotime();

//Здесь выполняется какой-то код приложения
.

printf(‘Время работы скрипта %.4F сек.’, getMicrotime()-$start);

Время выполнения php-функций

Время выполнения array_key_exists() + switch() + if else()

$arField)
<
if(array_key_exists(‘id’,$arField))
$result = true;
elseif(array_key_exists(‘available’,$arField))
$result = true;
elseif(array_key_exists(‘url’,$arField))
$result = true;
elseif(array_key_exists(‘price’,$arField))
$result = true;
elseif(array_key_exists(‘oldprice’,$arField))
$result = true;
>
>
printf(‘array_key_exists = %.4F сек.
‘, getMicrotime()-$start);

$start = getMicrotime();
for ($i=0; $i $arField)
<
switch($key)
<
case ‘id’:
$result = true;
break;
case ‘available’:
$result = true;
break;
case ‘url’:
$result = true;
break;
case ‘price’:
$result = true;
break;
case ‘oldprice’:
$result = true;
break;
>
>
>
printf(‘switch = %.4F сек.
‘, getMicrotime()-$start);

$start = getMicrotime();
for ($i=0; $i $arField)
<
if($key == ‘id’)
$result = true;

if($key == ‘available’)
$result = true;

if($key == ‘url’)
$result = true;

if($key == ‘price’)
$result = true;

if($key == ‘oldprice’)
$result = true;
>
>
printf(‘if else (1) = %.4F сек.
‘, getMicrotime()-$start);

$start = getMicrotime();
for ($i=0; $i $arField)
<
if($key == ‘id’)
$result = true;
elseif($key == ‘available’)
$result = true;
elseif($key == ‘url’)
$result = true;
elseif($key == ‘price’)
$result = true;
elseif($key == ‘oldprice’)
$result = true;
>
>
printf(‘if else (2) = %.4F сек.
‘, getMicrotime()-$start);
?>

Очень полезно знать, часто встречающиеся ситуации, условие if else(2) самое быстрое.

Время выполнения str_ireplace() + preg_replace()

Результат

Часто читали на форумах, что preg_replace() очень медленный?)
А ведь, в каких-то ситуациях он и правда медленней str_ireplace() , а в каких-то наоборот, в разы быстрей, проверьте, убедитесь.

Заключение

Как видим, все надо проверять на деле, иначе приложение по нашей глупости или банальной лени может оказаться таким медленным, съедать у сервера всю память и нагружать процессор до красного каления.

Источник

microtime

(PHP 4, PHP 5, PHP 7, PHP 8)

microtime — Возвращает текущую метку времени Unix с микросекундами

Описание

Функция microtime() возвращает текущую метку времени Unix с микросекундами. Эта функция доступна только на операционных системах, в которых есть системный вызов gettimeofday().

Для измерения производительности рекомендуется использовать hrtime() .

Список параметров

Если указано и установлено в true , microtime() возвратит число с плавающей точкой ( float ) вместо строки ( string ), как описано в разделе возвращаемых значений ниже.

Возвращаемые значения

По умолчанию microtime() возвращает строку ( string ) в формате «msec sec», где sec представляет собой количество секунд с начала эпохи Unix (1 января 1970 0:00:00 GMT), а msec — это количество микросекунд, прошедших после sec .

Если параметр as_float установлен в true , то microtime() возвратит результат в вещественном виде ( float ), представляющий собой текущее время в секундах, прошедших с начала эпохи Unix с точностью до микросекунд.

Примеры

Пример #1 Замер времени выполнения скрипта

// Спим некоторое время
usleep ( 100 );

$time_end = microtime ( true );
$time = $time_end — $time_start ;

echo «Ничего не делал $time секунд\n» ;
?>

Пример #2 Пример использования microtime() и REQUEST_TIME_FLOAT

// Выбираем время сна случайным образом
usleep ( mt_rand ( 100 , 10000 ));

// В суперглобальном массиве $_SERVER доступно значение REQUEST_TIME_FLOAT.
// Оно содержит временную метку начала запроса с точностью до микросекунд.
$time = microtime ( true ) — $_SERVER [ «REQUEST_TIME_FLOAT» ];

echo «Ничего не делал $time секунд\n» ;
?>

Смотрите также

• time() — Возвращает текущую метку системного времени Unix
• hrtime() — Получить системное время высокого разрешения

User Contributed Notes 20 notes

You can use one variable to check execution $time as follow:

= — microtime ( true );
$hash = 0 ;
for ( $i = 0 ; $i rand ( 1000 , 4000 ); ++ $i ) <
$hash ^= md5 ( substr ( str_shuffle ( «0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ» ), 0 , rand ( 1 , 10 )));
>
$time += microtime ( true );
echo «Hash: $hash iterations: $i time: » , sprintf ( ‘%f’ , $time ), PHP_EOL ;
?>

All these timing scripts rely on microtime which relies on gettimebyday(2)

This can be inaccurate on servers that run ntp to syncronise the servers
time.

For timing, you should really use clock_gettime(2) with the
CLOCK_MONOTONIC flag set.

This returns REAL WORLD time, not affected by intentional clock drift.

This may seem a bit picky, but I recently saw a server that’s clock was an
hour out, and they’d set it to ‘drift’ to the correct time (clock is speeded
up until it reaches the correct time)

Those sorts of things can make a real impact.

Any solutions, seeing as php doesn’t have a hook into clock_gettime?

As previously pointed out, setting the parameter $get_as_float as true will not allow microseconds precision (what would mean 6 decimal digits). It happens because the float returned has a big integer section, what crops the decimal one leaving it with less than 6 digits.

Here is a solution to easily calculate the execution time of a script without having to alter any configuration parameter. It uses the former way of getting microseconds.

private $timeStart ;
private $microsecondsStart ;
private $timeStop ;
private $microsecondsStop ;

public function __construct () <
$this -> start ();
>

public function start (): void <
[ $this -> microsecondsStart , $this -> timeStart ] = explode ( ‘ ‘ , microtime ());
$timeStop = null ;
$microsecondsStop = null ;
>

public function stop (): void <
[ $this -> microsecondsStop , $this -> timeStop ] = explode ( ‘ ‘ , microtime ());
>

public function getTime (): float <
$timeEnd = $this -> timeStop ;
$microsecondsEnd = $this -> microsecondsStop ;
if (! $timeEnd ) <
[ $microsecondsEnd , $timeEnd ] = explode ( ‘ ‘ , microtime ());
>

$seconds = $timeEnd — $this -> timeStart ;
$microseconds = $microsecondsEnd — $this -> microsecondsStart ;

// now the integer section ($seconds) should be small enough
// to allow a float with 6 decimal digits
return round (( $seconds + $microseconds ), 6 );
>
>

$t = new Timer ();
usleep ( 250 );
echo $t -> getTime ();

It is important to note that microtime(TRUE) does NOT always return a float (at least in PHP 5.x; I have not tested 7.x). If it happens to land on an exact second, it returns an integer instead.

Here is some simple code to illustrate this:
for ( $i = 0 ; $i 5000 ; $i ++) <
echo microtime ( TRUE ) . «\n» ;
usleep ( 100 ); // Adjust this if your PC is too fast/slow
>
?>

When you run this at a command line, you’ll see output like this (and you’ll know EXACTLY when I ran this):
1588881290.9992
1588881290.9994
1588881290.9996
1588881290.9998
1588881291 = DateTime :: createFromFormat ( ‘U.u’ , microtime ( TRUE )); // This line will not create an object when microtime returns an integer because it depends on the number being a float, including a decimal point!
$today = $raw_time -> format ( ‘Y-m-d H:i:s.u’ ); // This will die when format is attempted on a non-object
?>

The fix is to format the microtime output to force it to always be a float:
= sprintf ( ‘%.4f’ , microtime ( TRUE ));
$raw_time = DateTime :: createFromFormat ( ‘U.u’ , $utime );
$today = $raw_time -> format ( ‘Y-m-d H:i:s.u’ );
?>

Paraphrasing the characters on Silicon Valley, «Always Float! Always Float! Always Float!»

The description of «msec», in this documentation, is very bad.

It is NOT the microseconds that have elapsed since «sec» (if so, it should be given as an integer, without the «0.» in the beginning of the string).
It IS the fractional part of the time elapsed since «sec», with microseconds (10E-6) precision, if the last «00» are not considered significant».
If the last two digits are significant, then we would have a precision of 10E-8 seconds.

Need a mini benchmark ?
Use microtime with this (very smart) benchmark function :

mixed mini_bench_to(array timelist[, return_array=false])
return a mini bench result

-the timelist first key must be ‘start’
-default return a resume string, or array if return_array= true :
‘total_time’ (ms) in first row
details (purcent) in next row

example :
unset( $t ); // if previous used

//— zone to bench
$t [ ‘start’ ] = microtime ( true );
$tab_test =array( 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
$fact = 1 ;
$t [ ‘init_values’ ] = microtime ( true );
foreach ( $tab_test as $key => $value )
<
$fact = $fact * $value ;
>
$t [ ‘loop_fact’ ] = microtime ( true );
echo «fact = » . $fact . «\n» ;
//— END zone to bench

echo «—- string result—-\n» ;
$str_result_bench = mini_bench_to ( $t );
echo $str_result_bench ; // string return
echo «—- tab result—-\n» ;
$tab_result_bench = mini_bench_to ( $t , true );
echo var_export ( $tab_result_bench , true );
?>
this example return:

—- string result—-
total time : 0.0141 ms
start -> init_values : 51.1 %
init_values -> loop_fact : 48.9 %
—- tab result—-
array (
‘total_time’ => 0.0141,
‘start -> init_values’ => 51.1,
‘init_values -> loop_fact’ => 48.9,
)

The function to include :

function mini_bench_to ( $arg_t , $arg_ra = false )
<
$tttime = round (( end ( $arg_t )- $arg_t [ ‘start’ ])* 1000 , 4 );
if ( $arg_ra ) $ar_aff [ ‘total_time’ ]= $tttime ;
else $aff = «total time : » . $tttime . «ms\n» ;
$prv_cle = ‘start’ ;
$prv_val = $arg_t [ ‘start’ ];

foreach ( $arg_t as $cle => $val )
<
if( $cle != ‘start’ )
<
$prcnt_t = round ((( round (( $val — $prv_val )* 1000 , 4 )/ $tttime )* 100 ), 1 );
if ( $arg_ra ) $ar_aff [ $prv_cle . ‘ -> ‘ . $cle ]= $prcnt_t ;
$aff .= $prv_cle . ‘ -> ‘ . $cle . ‘ : ‘ . $prcnt_t . » %\n» ;
$prv_val = $val ;
$prv_cle = $cle ;
>
>
if ( $arg_ra ) return $ar_aff ;
return $aff ;
>
?>

Using microtime() to set ‘nonce’ value:

But note that the default ‘precision’ setting of PHP* — which is used when a float is converted to a stringy format by echo()ing, casting or json_encode()ing etc — is not enough to hold the six digit accuracy of microtime(true).

Out of the box, microtime(true) will echo something like:

Which is obviously less than microsecond accuracy. You’ll probably want to bump the ‘precision’ setting up to 16 which will echo something like:

*Internally* it will be accurate to the six digits even with the default ‘precision’, but a lot of things (ie. NoSQL databases) are moving to all-text representations these days so it becomes a bit more important.

* 14 at the time of writing

//timestamp in milliseconds:
intval ( microtime ( true )* 1000 )

//timestamp in microseconds:
intval ( microtime ( true )* 1000 * 1000 )

//timestamp in nanoseconds:
intval ( microtime ( true )* 1000 * 1000 * 1000 )

While doing some experiments on using microtime()’s output for an entropy generator I found that its microsecond value was always quantified to the nearest hundreds (i.e. the number ends with 00), which affected the randomness of the entropy generator. This output pattern was consistent on three separate machines, running OpenBSD, Mac OS X and Windows.

The solution was to instead use gettimeofday()’s output, as its usec value followed no quantifiable pattern on any of the three test platforms.

A convenient way to write the current time / microtime as formatted string in your timezone as expression?

= ‘DateTime now is: ‘ . (new \ DateTime ( null ,(new \ DateTimeZone ( ‘Europe/Berlin’ ))))-> format ( ‘Y-m-d H:i:s’ );

$microDate = ‘Microtime now is: ‘ . date_create_from_format ( ‘U.u’ , number_format ( microtime ( true ), 6 , ‘.’ , » ))-> setTimezone ((new \ DateTimeZone ( ‘Europe/Berlin’ )))-> format ( ‘ymd H:i:s.u e’ );
?>

For the microtime expression only the procedural style can be used. If you do not use namespaces the backslashes may be removed.
PHP >= 5.4 needed due to accessing a member of a newly created object in a single expression «(new DateTime())->format(‘Y-m-d H:i:s.u’)»

DateTime now is: 2018-06-01 14:54:58 Europe/Berlin
Microtime now is: 180601 14:54:58.781716 Europe/Berlin

I have been getting negative values substracting a later microtime(true) call from an earlier microtime(true) call on Windows with PHP 5.3.8

I like to use bcmath for it
function micro_time () <
$temp = explode ( » » , microtime ());
return bcadd ( $temp [ 0 ], $temp [ 1 ], 6 );
>

$time_start = micro_time ();
sleep ( 1 );
$time_stop = micro_time ();

$time_overall = bcsub ( $time_stop , $time_start , 6 );
echo «Execution time — $time_overall Seconds» ;
?>

I use this for measure duration of script execution. This function should be defined (and of couse first call made) as soon as possible.

/**
* get execution time in seconds at current point of call in seconds
* @return float Execution time at this point of call
*/
function get_execution_time ()
<
static $microtime_start = null ;
if( $microtime_start === null )
<
$microtime_start = microtime ( true );
return 0.0 ;
>
return microtime ( true ) — $microtime_start ;
>
get_execution_time ();

?>

However it is true that result depends of gettimeofday() call. ([jamie at bishopston dot net] wrote this & I can confirm)
If system time change, result of this function can be unpredictable (much greater or less than zero).

Of the methods I’ve seen here, and thought up myself, to convert microtime() output into a numerical value, the microtime_float() one shown in the documentation proper(using explode,list,float,+) is the slowest in terms of runtime.

I implemented the various methods, ran each in a tight loop 1,000,000 times, and compared runtimes (and output). I did this 10 times to make sure there wasn’t a problem of other things putting a load spike on the server. I’ll admit I didn’t take into account martijn at vanderlee dot com’s comments on testing accuracy, but as I figured the looping code etc would be the same, and this was only meant as a relative comparison, it should not be necessary.

The above method took on average 5.7151877 seconds, while a method using substr and simply adding strings with . took on average 3.0144226 seconds. rsalazar at innox dot com dot mx’s method using preg_replace used on average 4.1819633 seconds. This shows that there are indeed differences, but for normal use noone is going to notice it.

Note that the substr method mentioned isn’t quite the one given anonymously below, but one I made based on it:
= microtime ();
$timeval = substr ( $time , 11 ). substr ( $time , 1 , 9 );
?>

Also worth noting is that the microtime_float() method gets faster, and no less accurate, if the (float) conversions are taken out and the variables are simply added together.

Any of the methods that used + or array_sum ended up rounding the result to 2 digits after the decimal point, while (most of) the ones using preg_replace or substr and . kept all the digits.

For accurate timing, since floating-point arithmetic would lose precision, I stored microtime results as-is and calculated time difference with this function:
function microtime_used ( $before , $after ) <
return ( substr ( $after , 11 )- substr ( $before , 11 ))
+( substr ( $after , 0 , 9 )- substr ( $before , 0 , 9 ));
>
?>

For further information, the script itself, etc, see http://edorfaus.xepher.net/div/convert-method-test.php

Get date time with milliseconds

$micro_date = microtime();
$date_array = explode(» «,$micro_date);
$date = date(«Y-m-d H:i:s»,$date_array[1]);
echo «Date: $date:» . $date_array[0];

Test accuracy by running it in a loop.

//Function to convert microtime return to human readable units
//функция для конвертации времени, принимает значения в секундах

function convert_time($time)
<
if($time == 0 ) <
return 0;
>
//допустимые единицы измерения
$unit=array(-4=>’ps’, -3=>’ns’,-2=>’mcs’,-1=>’ms’,0=>’s’);
//логарифм времени в сек по основанию 1000
//берем значение не больше 0, т.к. секунды у нас последняя изменяемая по тысяче величина, дальше по 60
$i=min(0,floor(log($time,1000)));

//тут делим наше время на число соответствующее единицам измерения т.е. на миллион для секунд,
//на тысячу для миллисекунд
$t = @round($time/pow(1000,$i) , 1);
return $t.$unit[$i];
>

Источник