Объединённый асинхронный javascript: таймауты и интервалы

setTimeout()

Как мы ранее отметили, setTimeout () выполняет определённый блок кода один раз по истечении заданного времени. Принимает следующие параметры:

Функция для запуска или ссылка на функцию, определённую в другом месте.
Число, представляющее интервал времени в миллисекундах (1000 миллисекунд равняется 1 секунде) ожидания перед выполнением кода. Если вы укажете значение 0 (или просто опустите значение), функция запустится как можно скорее. (См. Примечание ниже о том, почему он запускается «как можно скорее», а не «сразу».) Подробнее о том, почему вы, возможно, захотите сделать это позже.
Значений, представляющие любые параметры, которые вы хотите передать функции при её запуске.

NOTE: Указанное время (или задержка) не является гарантированным временем выполнения, а скорее минимальным временем выполнения. Обратные вызовы, которые вы передаёте этим функциям, не могут выполняться, пока стек в основном потоке не станет пустым.

Как следствие, такой код, как setTimeout (fn, 0), будет выполняться, как только стек будет пуст, а не сразу. Если вы выполните такой код, как setTimeout (fn, 0), но сразу после выполнения цикла, который насчитывает от 1 до 10 миллиардов, ваш колбэк будет выполнен через несколько секунд.

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

Указанные вами функции не обязательно должны быть анонимными. Вы можете дать своей функции имя и даже определить её где-нибудь ещё и передать ссылку на функцию в setTimeout (). Следующие две версии фрагмента кода эквивалентны первой:

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

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

Любые параметры, которые вы хотите передать функции, выполняемой внутри setTimeout (), должны быть переданы ей как дополнительные параметры в конце списка.

Например, вы можете реорганизовать предыдущую функцию, чтобы она передавала привет любому имени, переданному ей:

Теперь вы можете передать имя в вызов setTimeout () в качестве третьего параметра:

Наконец, если был создан тайм-аут, вы можете отменить его до истечения указанного времени, вызвав , передав ему идентификатор вызова в качестве параметра. Итак, чтобы отменить указанный выше тайм-аут, вы должны сделать следующее:

Note: См. для более полной демонстрации, которая позволяет вам указать имя для приветствия и отменить приветствие с помощью отдельной кнопки (см. исходный код).

Замер времени выполнения с помощью StopWatch

StopWatch – это класс из библиотеки Apache Commons Lang. Он работает как секундомер. Для его использования сначала требуется подключить библиотеку к проекту:

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.9</version>
</dependency>

Теперь создадим экземпляр StopWatch. Затем начнём отсчёт с помощью метода start() и окончим отсчёт с помощью метода stop():

public static void stopWatch() throws InterruptedException {
    StopWatch stopWatch = new StopWatch();

    stopWatch.start();

    // выполнение какой-то логики
    Thread.sleep(1000);

    stopWatch.stop();

    System.out.println("Прошло времени, мс: " + stopWatch.getTime());
}

StopWatch удобно использовать тогда, когда в проекте уже подключена данная библиотека.

Changes

We see the JIT engine as a preview of what we plan to ship as Tailwind CSS v3.0, so there are a few small breaking changes to consider when opting in. We really don’t expect these to impact very many people but worth reading, especially if you notice any subtle differences in how your projects look.

Variants are rendered together

In the classic engine, utility variants are grouped together in the generated CSS per utility like this:

In the JIT engine, variants are grouped together per variant:

This means that it’s not possible to specify the variant order per core plugin anymore — the variants will always be in the same order for all utilities. This could be a problem for you if previously you needed to defeat for a specific utility for example and had ensured came after in the variant list.

To handle these situations with the JIT engine, we recommend using stacked variants instead:

Stacked variants let you specify how something should be styled when multiple variants are active at the same time, so instead of trying to override styles with styles, you explicitly declare what an element should look like when both and are active simultaneously.

Variants are inserted at @tailwind variants

In the classic engine, all utility variants are injected as part of the directive.

In the JIT engine, variants are injected at the directive, which has been renamed from .

This directive is optional (just like always has been) and is only useful if you want explicit control over where utility variants are injected. By default, they are always injected at the very end of your stylesheet.

If you were using before, you should update your code to use :

The feature is considered an advanced escape hatch and we recommend omitting it by default. You should only use it if your project won’t work properly without it, which is only ever really true if you are introducing Tailwind to a legacy system with a very fragile existing CSS codebase that has styles that absolutely need to be at the very end of the stylesheet for things to work.

Transforms and filters don’t need to be explicitly enabled

The , , and classes aren’t necessary for “enabling” those features when using the JIT engine:

This means you can no longer expect transforms and filters to be dormant by default, and conditionally activated by adding , , or .

Instead, you will want put any variants on the sub-utilities themselves:

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

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

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

$memory = memory_get_usage();
 
// исполняемый код ...
 
echo 'Скушано памяти: ' . (memory_get_usage() - $memory) . ' байт';

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

// исполняемый код ...
 
echo 'Скушано памяти: ' . xdebug_memory_usage() . ' байт';

Результат:

Скушано памяти: 36018960 байт

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

$memory = memory_get_usage();
 
for ($i = 0; $i < 1000000; $i++) {
 $array[] = rand(0, 1000000);
}
 
$memory = memory_get_usage() - $memory;
// Конвертация результата в килобайты и мегабайты 
$i = 0;
while (floor($memory / 1024) > 0) {
  $i++;
  $memory /= 1024;
}
 
$name = array('байт', 'КБ', 'МБ');
echo 'Скушано памяти: ' . round($memory, 2) . ' ' . $name;

Результат:

Скушано памяти: 34 МБ

Zero delay setTimeout

There’s a special use case: , or just .

This schedules the execution of as soon as possible. But the scheduler will invoke it only after the currently executing script is complete.

So the function is scheduled to run “right after” the current script.

For instance, this outputs “Hello”, then immediately “World”:

The first line “puts the call into calendar after 0ms”. But the scheduler will only “check the calendar” after the current script is complete, so is first, and – after it.

There are also advanced browser-related use cases of zero-delay timeout, that we’ll discuss in the chapter Event loop: microtasks and macrotasks.

Zero delay is in fact not zero (in a browser)

In the browser, there’s a limitation of how often nested timers can run. The says: “after five nested timers, the interval is forced to be at least 4 milliseconds.”.

Let’s demonstrate what it means with the example below. The call in it re-schedules itself with zero delay. Each call remembers the real time from the previous one in the array. What do the real delays look like? Let’s see:

First timers run immediately (just as written in the spec), and then we see . The 4+ ms obligatory delay between invocations comes into play.

The similar thing happens if we use instead of : runs few times with zero-delay, and afterwards with 4+ ms delay.

That limitation comes from ancient times and many scripts rely on it, so it exists for historical reasons.

For server-side JavaScript, that limitation does not exist, and there exist other ways to schedule an immediate asynchronous job, like for Node.js. So this note is browser-specific.

Summary

Methods and allow us to run the once/regularly after milliseconds.
To cancel the execution, we should call with the value returned by .
Nested calls are a more flexible alternative to , allowing us to set the time between executions more precisely.
Zero delay scheduling with (the same as ) is used to schedule the call “as soon as possible, but after the current script is complete”.
The browser limits the minimal delay for five or more nested calls of or for (after 5th call) to 4ms. That’s for historical reasons.

Please note that all scheduling methods do not guarantee the exact delay.

For example, the in-browser timer may slow down for a lot of reasons:

The CPU is overloaded.
The browser tab is in the background mode.
The laptop is on battery.

All that may increase the minimal timer resolution (the minimal delay) to 300ms or even 1000ms depending on the browser and OS-level performance settings.

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

Способ #1

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

$start = microtime(true);

// исполняемый код ...

echo '<br>===============================================================';
echo 'Время выполнения скрипта: ' . (microtime(true) - $start) . ' sec.';

Результат:

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

Способ #2

Можно вместо брать значение из переменной , которая содержит время запроса к серверу. Вычисление времени выполнения происходит за исполняемым кодом.

// исполняемый код ...

$time = microtime(true) - $_SERVER;
echo $time . ' sec.';

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

// исполняемый код ...

echo xdebug_time_index() . ' sec.';

Способ #4

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

$start = microtime(true);
 
// исполняемый код ...
 
$time = round(microtime(true) - $start, 3);
 
$f = fopen('time.log', 'a');
fwrite($f, $time . PHP_EOL);
fclose($f);
 
$log = file('time.log');
$result = round(array_sum($log) / count($log), 3); 
echo $result . ' sec.';

Не спеша, эффективно и правильно – путь разработки. Часть 2. Теория

Черновой вариант книги Никиты Зайцева, a.k.a.WildHare. Разработкой на платформе 1С автор занимается с 1996-го года, специализация — большие и по-хорошему страшные системы. Квалификация “Эксперт”, несколько успешных проектов класса “сверхтяжелая”. Успешные проекты ЦКТП. Четыре года работал в самой “1С”, из них два с половиной архитектором и ведущим разработчиком облачной Технологии 1cFresh. Ну — и так далее. Не хвастовства ради, а понимания для. Текст написан не фантазером-теоретиком, а экспертом, у которого за плечами почти двадцать три года инженерной практики на больших проектах.

Troubleshooting

Styles aren’t removed when classes are deleted

When the JIT engine is running in watch mode, you might notice that when you add a class to your HTML then remove it, that the class is still present in your CSS.

This isn’t a bug and is rather a deliberate performance optimization that drastically increases the speed of incremental rebuilds, especially in large projects.

We recommend you always compile your CSS in a separate one-off build before deploying to production so that you can minify the output. For most modern tools (like Next.js for example), this sort of thing happens automatically because your compiled CSS is never committed to version control anyways.

If you want Tailwind to rebuild the CSS completely from scratch while in watch mode, saving your file or your CSS input file will invalidate all of the caches and trigger a fresh rebuild.

Styles don’t update when saving content files

As of Tailwind CSS v2.2+, the JIT engine depends on PostCSS’s to register your content files as CSS build dependencies with your build tool. These are a fairly new addition to PostCSS (added in May 2021), and not all build tools have been updated to support them yet.

If your CSS isn’t rebuilding when you change your content files, try setting as part of your watch script to tell Tailwind to use a legacy dependency tracking strategy instead, which works well with many build tools.

For example, if you are using , set in your dev/watch script:

If you’re using Windows, we recommend cross-env for setting environment variables in your scripts.

Note that setting will start a long-running watch process in the background, so if you set that environment variable when trying to do a one-off build, it will look like the build is hanging.

You should only set when you are actually running a dev server/watch process, and only if your build tool doesn’t yet support PostCSS directory dependency messages. This flag is a temporary workaround for incompatible tooling, and will eventually be removed in a future version of Tailwind CSS.

Styles rebuild in an infinite loop

If your CSS seems to be rebuilding in an infinite loop, there’s a good chance it’s because your build tool doesn’t support PostCSS’s option when .

Many build tools (such as webpack) don’t support this option, and as a result we can only tell them to watch specific files or entire directories. We can’t tell webpack to only watch files in a directory for example.

That means that if building your CSS causes any files in those directories to change, a rebuild will be triggered, even if the changed file doesn’t match the extension in your glob.

So if you are watching for changes, but you are writing your CSS output file to , you will get an infinite rebuild loop in some tools.

Ideally we could warn you about this in the console, but many tools support it perfectly fine (including our own CLI tool), and we have no reliable way to detect what build tool you are using.

You have a few options for solving this problem:

Use more specific paths in your config. Make sure you only include directories that won’t change when your CSS builds.

If necessary, adjust your actual project directory structure to make sure you can target your template files without accidentally catching your CSS file or other build artifacts like manifest files.
Use a build tool with PostCSS glob support. If you absolutely can’t change your purge config or directory structure, your best bet is to compile your CSS separately with a tool that has complete glob support. We recommend using , which is a fast, simple, purpose-built tool for compiling your CSS with Tailwind.

It just doesn’t seem to work properly

If you are experiencing weird, hard to describe issues with the output, or things just don’t seem like they are working at all, there’s a good chance it’s due to your build tool not supporting PostCSS dependency messages properly (or at all). One known example of this currently is Stencil.

When you are having these sorts of issues, we recommend using the Tailwind CLI tool to compile your CSS separately instead of trying to integrate Tailwind into your existing tooling.

You can use packages like or to compile your CSS alongside your usual development command by adding some scripts to your project like this:

Either way, please be sure to check for an existing issue or open a new one so we can figure out the problem and try to improve compatibility with whatever tool you are using.

Tools with known compatibility issues currently include:

postcss-cli (#383)
Parcel (#6299)
Stencil (#35)

Что влияет на тайминг кода?

Тайминг кода является достаточно простым и прозрачным, но ваши результаты могут существенно отличаться из-за ряда вещей:

Во-первых, убедитесь, что вы используете режим конфигурации «Release», а не «Debug». Во время режима «Debug» оптимизация обычно отключена, а она может оказывать значительное влияние на результаты. Например, в конфигурации «Debug», выполнение сортировки элементов массива через std::sort() на компьютере автора заняло секунды, что в 34 раза больше, нежели в конфигурации «Release»!

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

Выполняйте тайминг как минимум 3 раза. Если результаты одинаковые — выбираем среднее. Если один или два результата значительно отличаются друг от друга, то запустите тайминг еще несколько раз, пока не получите лучшее представление о том, какие из результатов оказались «левыми»

Обратите внимание, некоторые, казалось бы, невинные вещи, такие как веб-браузеры, могут временно увеличить нагрузку на ваш процессор до 100%, когда сайт, на котором вы находитесь в фоновом режиме, выполняет целую кучу скриптов JavaScript (рекламные баннеры, запуск видео, сложная анимация и т.д.). Запуск тайминга несколько раз позволит определить, повлияло ли подобное событие на ваши результаты

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

Рандомизация также может повлиять на тайминг. Если бы мы отсортировали массив, заполненный случайными числами, то это бы повлияло на результаты тайминга (тот факт, что числа являются рандомными). Рандомизацию использовать можно, но убедитесь, что ваше стартовое значение является фиксированным (т.е. не используйте системные часы в качестве стартового значения) и результаты рандомизации идентичны при каждом запуске. Кроме того, убедитесь, что в фрагментах кода не используется пользовательский ввод, так как время ожидания ввода от пользователя не должно учитываться при определении эффективности кода.

Наконец, ваши результаты действительны только для архитектуры вашего компьютера, ОС, компилятора и системных/технических характеристик. Вы можете получить совсем другие результаты на других системах, которые имеют другие сильные и слабые стороны.

Не спеша, эффективно и правильно – путь разработки. Часть 3. Практика

Не спеша, эффективно и правильно – путь разработки. Часть 1. Парадигма

Common pitfalls

Default timezone when logging a date object

When directly logging a date object using , it is rendered using
a default format and timezone. For example:

The default timezone is America/Los_Angeles (Pacific time), regardless of the
timezone associated with the Google Ads account. If you would like to render the
date object as a string using a custom format and timezone for logging or
other purposes, always use
.

Default timezone when creating a date object

When creating a date object using a string that does not provide a timezone
offset, the timezone is assumed to be America/Los_Angeles (Pacific
time), regardless of the timezone associated with the Google Ads account. For
example:

When creating a date object using a string, always include a timezone offset
to ensure the date object represents the moment in time you actually want.

Default timezone in date object methods

JavaScript date objects have several methods that assume a default
timezone, such as

their equivalents, and .

In Google Ads scripts, the default timezone is America/Los_Angeles
(Pacific time), regardless of the timezone associated with the Google Ads
account. Therefore, unless your Google Ads account is in this timezone, you
should generally avoid using these methods.

To get the year, month, date, day, hours, or minutes for a date object
in your account’s timezone, use

with a format specifying the part of the date or time you want, and use

to get your account’s timezone.

Creating a date object from a formatted date string

You can create a date object by passing a formatted date string to the date
constructor. For example:

The constructor can only parse certain date string formats. To make sure your
date string is parsed correctly, always provide it in the
format.

For example, to construct a date object for noon today in the current
account’s timezone:

Do not use the ‘z’ pattern to create date strings that will be passed
to a date constructor, as the constructor will not always be able to parse it.
Only use the ‘Z’ pattern.

Overview

Current list of Stands that can time stop or move within it.

Time Stop (Also referred to as Timestop or TS) is an unlockable ability which enables the user to stop time for a short duration. Stands usually require a full Rage Bar in order to activate a Time Stop, Requiem stands being the exception. The default keybind for Time Stop is ‘Z’ (the same as Time Skip), for Requiem stands it is ‘H’. The duration of Time Stop varies from 2 to 8 seconds (depending on how much the user has upgraded Time Stop Mastery), users will usually have to obtain Time Stop Resistance (the ability to temporarily move in somebody else’s Time Stop) before unlocking Time Stop. During a Time Stop, any players able to move cannot run or dash but jump much higher.

Due to the Heaven Update, Time Stop is generally regarded as one of the most powerful moves in-game. The World Over Heaven could formerly instant-kill in Time Stop, but due to an update, damage is now capped to 50%.

Stands with Time Stop

Five stands are known to possess this ability:

Star Platinum
Star Platinum: The World
The World
The World: Alternate Universe
The World Over Heaven

There are only 2 known Stands that don’t need rage to stop time:

The World Over Heaven
Star Platinum: The World

Moving in Stopped Time

Some stands can move through stopped time or use a glitch that would render Time Stop avoidable.

Some examples include:

C-Moon (Time Stop Resistance) 3 seconds
D4C (Dimension Hop)
D4C: Love Train (Dimension Hop)
GER (Return to Zero) (Time Stop Resistance) 2 seconds
Star Platinum (Time Stop Resistance) 3 seconds
Star Platinum: The World (Time Stop Resistance) 3 seconds
The World (Time Stop Resistance) 3 seconds
The World (Alternate Universe) (Time Stop Resistance) 3 seconds
Tusk Act 4 (Can move through stopped time for 3-5 Seconds)
Cream (Dimensional Dip)

Melee-focused Time Stops

Melee Time Stop users include:

Star Platinum
Star Platinum: The World
The World

Due to their melee damage, typically a player would get close before activating time stop to maximize their damage output. A Star Platinum would mainly attack with its M1s and then use Star Finger, for example. Against these types of s, trying to be at an inconvenient or hard to get to place is typically the best way to deal with it. While jumping, a Stand’s damage output from M1s are dramatically decreased as Time Stop has lighter gravity.

Range-focused Time Stops

Ranged Time Stop users include:

The World: Alternate Universe
The World: Over Heaven

Any Time Stop stands with projectile specs

Against more projectile based time stops, the best way to respond is to jump away, making aiming the attacks more difficult, this would reduce the damage taken or force the Stand to engage in melee combat, which their specialty might make it harder to do.

Limitations

This new engine supports almost every feature that exists in the classic engine, plus tons of new features that wouldn’t be possible if everything had to be pre-generated up front.

Due to the nature of how the engine works however, there are a few things that aren’t currently possible:

The option does not support regular expressions. Because no CSS is generated by default, the safelist has to be a list of complete class names. It’s not possible to safelist a regular expression, because there is not a pre-generated list of class names to match against that regular expression.
The option cannot detect complete class names when configured as a function. Because we don’t generate class names in advance, we can only pass the utility “namespace” to custom prefix functions. See for an example.
You can only classes that are part of core, generated by plugins, or defined within a rule. You can’t currently arbitrary CSS classes that aren’t defined within a rule, although we may add support for this in the future.

We are also still ironing out some compatibility issues with certain build tools, which you can follow in our issue tracker.

If you run into any other issues or find any bugs, please open an issue so we can fix it.

Рекурсивный setTimeout

Есть два способа запускать что-то регулярно.

Один из них . Другим является рекурсивный . Например:

Метод выше планирует следующий вызов прямо после окончания текущего .

Рекурсивный – более гибкий метод, чем . С его помощью последующий вызов может быть задан по-разному в зависимости от результатов предыдущего.

Например, необходимо написать сервис, который отправляет запрос для получения данных на сервер каждые 5 секунд, но если сервер перегружен, то необходимо увеличить интервал запросов до 10, 20, 40 секунд…
Вот псевдокод:

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

Рекурсивный позволяет задать задержку между выполнениями более точно, чем .

Сравним два фрагмента кода. Первый использует :

Второй использует рекурсивный :

Для внутренний планировщик будет выполнять каждые 100 мс:

Обратили внимание?

Реальная задержка между вызовами с помощью меньше, чем указано в коде!

Это нормально, потому что время, затраченное на выполнение , использует часть заданного интервала времени.

Вполне возможно, что выполнение будет дольше, чем мы ожидали, и займёт более 100 мс.

В данном случае движок ждёт окончания выполнения и затем проверяет планировщик и, если время истекло, немедленно запускает его снова.

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

Ниже представлено изображение, показывающее процесс работы рекурсивного :

Рекурсивный гарантирует фиксированную задержку (здесь 100 мс).

Это потому, что новый вызов планируется в конце предыдущего.

Сборка мусора и колбэк setTimeout/setInterval

Когда функция передаётся в , на неё создаётся внутренняя ссылка и сохраняется в планировщике. Это предотвращает попадание функции в сборщик мусора, даже если на неё нет других ссылок.

Для функция остаётся в памяти до тех пор, пока не будет вызван .

Есть и побочный эффект. Функция ссылается на внешнее лексическое окружение, поэтому пока она существует, внешние переменные существуют тоже. Они могут занимать больше памяти, чем сама функция. Поэтому, если регулярный вызов функции больше не нужен, то лучше отменить его, даже если функция очень маленькая.

Замер времени с помощью Instant и Duration

В Java 8 добавили новый java.time API. В частности, ля измерения времени подойдут два новых класса – Instant и Duration. Оба эти класса иммутабельны.

Instant обозначает момент времени с начала эпохи Unix (1970-01-01T00:00:00Z). Для создания момента мы используем метод Instant.now(). После того, как мы создали два момент, вычислим разницу в миллисекундах:

Instant start = Instant.now();

// выполнение какой-то логики
Thread.sleep(1000);

Instant finish = Instant.now();
long elapsed = Duration.between(start, finish).toMillis();
System.out.println("Прошло времени, мс: " + elapsed);

Рекомендуется использовать именно этот подход в Java 8 и выше.

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

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

<?php
/**
 * Класс для измерения времени выполнения скрипта PHP
 */
class Timer
{
  /**
   * @var float время начала выполнения скрипта
   */
  private static $start = .0;

  /**
   * Начало выполнения
   */
  public static function start()
  {
    self::$start = microtime(true);
  }

  /**
   * Разница между текущей меткой времени и меткой self::$start
   * @return float
   */
  public static function finish()
  {
   return microtime(true) - self::$start;
  }
}

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

Timer::start();

// исполняемый код ...

echo 'Время выполнения скрипта: ' . Timer::finish() . ' sec.';

// ===================================
// Пример использования класса Timer(). Заполним массив миллионом случайных чисел.
Timer::start();

for ($i = 0; $i < 1000000; $i++) {
 $array[] = rand(0, 1000000);
}
echo 'Время выполнения скрипта: ' . Timer::finish() . ' sec.';