Progress28.ru

IT Новости
1 просмотров
Рейтинг статьи
1 звезда2 звезды3 звезды4 звезды5 звезд
Загрузка...

Php миллисекунды в дату

Как получить текущее время в миллисекундах в PHP?

time() в секундах – есть ли один миллисекунды?

Короткий ответ :

Используйте microtime() . Эта функция возвращает строку, разделенную пробелом. Первая часть – дробная часть секунд, вторая часть – неотъемлемая часть. Перейдите в true чтобы получить как число:

Остерегайтесь прецизионных потерь, если вы используете microtime(true) .

Существует также gettimeofday() который возвращает часть микросекунды как целое число.

Как и другие, вы можете использовать microtime() для получения миллисекундной точности на microtime() времени.

Из ваших комментариев вы, похоже, хотите, чтобы это была высокоточная отметка времени UNIX. Что-то вроде DateTime.Now.Ticks в мире .NET.

Для этого вы можете использовать следующую функцию:

Короткий ответ:

Только 64-битные платформы!

Длительный ответ:

Если вы хотите получить эквивалентную функцию time() в миллисекундах, сначала нужно учитывать, что по мере того, как time() возвращает количество секунд, прошедших со времени «эпохи» (01/01/1970), количество миллисекунд с «эпохи» time «является большим числом и не вписывается в 32-битное целое число.

Размер целого числа в PHP может быть 32 или 64 бит в зависимости от платформы.

Размер целого зависит от платформы, хотя максимальное значение около двух миллиардов – это обычное значение (это 32 бита). 64-разрядные платформы обычно имеют максимальное значение около 9E18, за исключением Windows, которая всегда 32 бит. PHP не поддерживает целые числа без знака. Целочисленный размер может быть определен с использованием константы PHP_INT_SIZE и максимального значения с использованием константы PHP_INT_MAX с PHP 4.4.0 и PHP 5.0.5.

Если у вас есть 64-битные целые числа, вы можете использовать следующую функцию:

microtime() возвращает количество секунд с момента «эпохи» с точностью до микросекунд с двумя номерами, разделенными пробелом, например …

Второе число – это секунда (целое число), предшествующее десятичной части.

Функция milliseconds принимает целочисленную часть, умноженную на 1000

и добавляет десятичную часть, умноженную на 1000 и округленную до 0 десятичных знаков

Обратите внимание, что как $mt[1] и результат round выдаются в int . Это необходимо, потому что они являются float и операция над ними без кастинга приведет к возврату функции float .

Наконец, эта функция несколько точнее, чем

что с отношением 1:10 (приблизительно) возвращает на 1 миллисекунду больше, чем правильный результат. Это связано с ограниченной точностью типа float ( microtime(true) возвращает float). В любом случае, если вы по-прежнему предпочитаете более короткий round(microtime(true)*1000); Я бы предложил лить в результат.

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

Если факт 2^63 (приблизительное наибольшее значащее целое число), деленное на 10^6 * 3600 * 24 * 365 (примерно на микросекунды через год), прибл. 292471 .

Это то же значение, возвращаемое echo PHP_INT_MAX / (1000000*3600*24*365);

Другими словами, целое число со знаком имеет место для хранения временного интервала более 200000 лет, измеренного в микросекундах.

Тогда вы можете

Используйте microtime(true) в PHP 5 или следующую модификацию в PHP 4:

Портативный способ написать этот код:

ПРИМЕЧАНИЕ. Для этой функции требуется PHP5 из-за улучшений с microtime (), а также необходим математический модуль bc (поскольку мы имеем дело с большими числами, вы можете проверить, есть ли у вас модуль в phpinfo).

Надеюсь, это поможет вам.

echo date(‘Ymd H:i:s.’) . gettimeofday()[‘usec’];

Это работает, даже если вы на 32-битном PHP:

Обратите внимание, что это не дает вам целые числа, а строки. Однако это хорошо работает во многих случаях, например, при создании URL-адресов для запросов REST.

Если вам нужны целые числа, требуется 64-битный PHP.

Затем вы можете повторно использовать приведенный выше код и использовать для (int):

Или вы можете использовать хорошие оль-лайнеры:

Формат даты получения m-d-Y H: i: s.u от миллисекунд

92 slik [2013-07-28 18:35:00]

Я пытаюсь получить отформатированную дату, включая микросекунды с миллисекундами.

Единственная проблема — я продолжаю получать 000000

ех. 07-28-2013 11: 26: 14.000000

14 ответов

109 Решение Marin Sagovac [2013-07-28 18:37:00]

Микросекунды (добавлено в PHP 5.2.2). Обратите внимание, что date() всегда генерирует 000000 так как принимает целочисленный параметр, тогда как DateTime::format() поддерживает микросекунды, если DateTime был создан с микросекундами.

Так что используйте как просто:

Рекомендуем использовать класс dateTime() из упомянутых:

Обратите внимание, u является микросекунд (1 секунда = 1000000 мкс).

Еще один пример с php.net:

Ссылка dateTime() на php.net

Я ответил на вопрос как краткий и упрощенный для автора. Пожалуйста, см. Для получения дополнительной информации для автора: получение формата даты MDY H: I: SU от миллисекунд

Вы можете легко сделать это с помощью формата ввода Uu .

Это дает следующий вывод:

Со страницы справочника по PHP для форматов даты:

  • U = секунды с начала эпохи Unix
  • и = микросекунды

Спасибо Гиггси за то, что он указал на ошибку в моем исходном ответе, добавление number_format() к строке должно исправить случай с точностью до секунды. Жаль, что это уже не так элегантно.

Заметка о часовых поясах в ответ на DaVe.

Обычно метод createFromFormat() будет использовать локальный часовой пояс, если он не указан.

Однако описанный здесь метод инициализирует объект DateTime с помощью microtime() который возвращает количество секунд, прошедших с начала эпохи Unix (01 января 1970 г. 00:00:00 по Гринвичу).

Это означает, что объект DateTime неявно инициализируется в UTC, что хорошо для внутренних задач сервера, которые просто хотят отслеживать истекшее время.

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

Метод setTimeZone() может быть использован для выполнения этого требования.

В качестве примера:

Производит следующий вывод:

Обратите внимание, что если вы хотите ввести в MySQL, формат времени должен быть:

12 thotso [2014-08-07 12:21:00]

Здесь немного более короткий подход. Вместо того, чтобы создавать высокоточную числовую дату/время, я конвертирую значение микросекунды в строку, удаляю 0 и добавляю ее к концу строки даты/времени. Я могу легко обрезать число десятичных знаков, отрегулировав параметр длины строки; здесь я использую 4 для получения миллисекунд, но вы можете использовать 7 для получения микросекунд.

Читать еще:  Php foreach object

Для значения microtime() 0.98236000 1407400573 , это возвращает 08-07-14 01:08:13.982 .

microtime

(PHP 4, PHP 5, PHP 7)

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

Описание

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

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

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

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

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

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

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

Примеры

Пример #1 Замер времени выполнения скрипта с помощью функции microtime()

/**
* Простая функция для реализации поведения из PHP 5
*/
function microtime_float ()
<
list( $usec , $sec ) = explode ( » » , microtime ());
return ((float) $usec + (float) $sec );
>

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

$time_end = microtime_float ();
$time = $time_end — $time_start ;

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

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

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

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

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

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

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

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

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

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

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

User Contributed Notes 17 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?

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

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 . «msn» ;
$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:

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.

Читать еще:  Asp phpsessid непостижимость car

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

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

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).

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.

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

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 have been getting negative values substracting a later microtime(true) call from an earlier microtime(true) call on Windows with PHP 5.3.8

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 ();

Unix time конвертер (Конвертер времени Unix онлайн)

Что такое Unix время или Unix эпоха (Unix epoch или Unix time или POSIX time или Unix timestamp) ?

UNIX-время или POSIX-время (англ. Unix time) — способ кодирования времени, принятый в UNIX и других POSIX-совместимых операционных системах.
Моментом начала отсчёта считается полночь (по UTC) с 31 декабря 1969 года на 1 января 1970, время с этого момента называют «эрой UNIX» (англ. Unix Epoch).
Время UNIX согласуется с UTC, в частности, при объявлении високосных секунд UTC соответствующие номера секунд повторяются.
Способ хранения времени в виде количества секунд очень удобно использовать при сравнении дат (с точностью до секунды), а также для хранения дат: при необходимости их можно преобразовать в любой удобочитаемый формат. Дата и время в этом формате также занимают очень мало места (4 или 8 байтов, в зависимости от размера машинного слова), поэтому его разумно использовать для хранения больших объёмов дат. Недостатки в производительности могут проявиться при очень частом обращении к элементам даты, вроде номера месяца и т. п. Но в большинстве случаев эффективнее хранить время в виде одной величины, а не набора полей.

Читать еще:  Индивидуальные средства защиты от статического электричества
Обычная дата(Human readable time)Секунды
1 минута60 секунд
1 час3600 секунд
1 день86400 секунд
1 неделя604800 секунд
1 месяц (30.44 дней)2629743 секунд
1 год (365.24 дней)31556926 секунд

Конвертивание эпохи Unix в человекопонятную дату(human readable date)

Unix дата начала и конца года, месяца или дня

Перевод секунд в дни, часы и минуты

Как получить Unix время в.

Perltime
PHPtime()
RubyTime.now (или Time.new ). Чтобы вывести: Time.now.to_i
Pythonimport time сначала, потом time.time()
Javalong epoch = System.currentTimeMillis()/1000;
Microsoft .NET C#epoch = (DateTime.Now.ToUniversalTime().Ticks — 621355968000000000) / 10000000;
VBScript/ASPDateDiff(«s», «01/01/1970 00:00:00», Now())
Erlangcalendar:datetime_to_gregorian_seconds(calendar:now_to_universal_time( now()))-719528*24*3600.
MySQLSELECT unix_timestamp(now())
PostgreSQLSELECT extract(epoch FROM now());
SQL ServerSELECT DATEDIFF(s, ‘1970-01-01 00:00:00’, GETUTCDATE())
JavaScriptMath.round(new Date().getTime()/1000.0) getTime() возвращает время в миллисекундах.
Unix/Linuxdate +%s
Другие OSКомандная строка: perl -e «print time» (Если Perl установлен на вашей системе)

Конвертирование даты в Unix время в.

PHPmktime(часы, минуты, секунды, месяц, день, год)
RubyTime.local(год, месяц, день, часы, минуты, секунды, usec ) (или Time.gm для GMT/UTC вывода). Чтобы вывести добавьте .to_i
Pythonimport time сначала, потом int(time.mktime(time.strptime(‘2000-01-01 12:34:00’, ‘%Y-%m-%d %H:%M:%S’)))
Javalong epoch = new java.text.SimpleDateFormat («dd/MM/yyyy HH:mm:ss»).parse(«01/01/1970 01:00:00»);
VBScript/ASPDateDiff(«s», «01/01/1970 00:00:00», поле даты)
MySQLSELECT unix_timestamp(время) Формат времени: YYYY-MM-DD HH:MM:SS или YYMMDD или YYYYMMDD
PostgreSQLSELECT extract(epoch FROM date(‘2000-01-01 12:34’));
С timestamp: SELECT EXTRACT(EPOCH FROM TIMESTAMP WITH TIME ZONE ‘2001-02-16 20:38:40-08’); C интервалом: SELECT EXTRACT(EPOCH FROM INTERVAL ‘5 days 3 hours’);
SQL ServerSELECT DATEDIFF(s, ‘1970-01-01 00:00:00’, поле с датой)
Unix/Linuxdate +%s -d»Jan 1, 1980 00:00:01″

Конвертирование Unix времеми в понятную дату(human readable date).

PHPdate(Формат, unix время);
RubyTime.at(unix время)
Pythonimport time сначала, потом time.strftime(«%a, %d %b %Y %H:%M:%S +0000», time.localtime(unix время)) Замените time.localtime на time.gmtime для GMT даты.
JavaString date = new java.text.SimpleDateFormat(«dd/MM/yyyy HH:mm:ss»).format(new java.util.Date (unix время*1000));
VBScript/ASPDateAdd(«s», unix время, «01/01/1970 00:00:00»)
PostgreSQLSELECT TIMESTAMP WITH TIME ZONE ‘epoch’ + unix время * INTERVAL ‘1 second’;
MySQLfrom_unixtime(unix время, не обязательно, выходной формат) Стандартный формат выхода YYY-MM-DD HH:MM:SS
SQL ServerDATEADD(s, unix время, ‘1970-01-01 00:00:00’)
Microsoft Excel=(A1 / 86400) + 25569 Результат будет в GMT зоне времени. Для других временных зон: =((A1 +/- разница аремени для зоны) / 86400) + 25569.
Linuxdate -d @1190000000
Другие OSКомандная строка: perl -e «print scalar(localtime(unix время))» (Если установлен Perl) Замените ‘localtime’ на ‘gmtime’ для GMT/UTC зоны времени.

Для чего нужен инструмент «Unixtime конвертер»?

Данный инструмент, в первую очередь, будет полезен веб-мастерам, которые постоянно имеют дело с большими объемами дат или часто в своей работе обращаются к их элементам. С помощью инструмента «Unixtime конвертер» можно легко конвертировать Unix время в понятную для пользователя дату (и наоборот), узнать текущее Unix epoch время, а также получить Unix время в различных языках программирования, СУБД и операционных системах.

Что такое Unix время?

Эра Unix (Unix epoch) началась в ночь с 31 декабря 1969 года на 1 января 1970 года. Именно эту дату взяли за точку отсчета «компьютерного» времени, которое исчисляется в секундах и занимает очень мало места на диске – всего 4 или 8 байт. С помощью такого способа кодирования программисты могут «спрятать» любую дату в одно число, и легко конвертировать его обратно в понятный пользователям формат.

Unix время (еще его называют Unix time или POSIX time) удобно использовать в различных операционных системах и языках программирования, так как оно отображается в виде одной величины, а не определенного количества полей, занимающих место. К тому же, UNIX time полностью соответствует стандарту UTC (в том числе и в високосных годах) – в таком случае соответствующие значения секунд просто повторяются.

Пару слов о терминах.

Итак, Unix-временем (или POSIX-временем) считается количество секунд, которые прошли с полуночи 1 января 1970 года до настоящего времени.

Unix Timestamp (временная метка) – это «зафиксированное» время, иными словами – конкретная дата, запечатленная в числе.

UTC (Universal Coordinated Time) – это Всемирное координированное время, которое «фиксируется» на нулевом меридиане, и от которого ведется отсчет географических часовых поясов.

Насколько «долговечна» данная система?

Всего лишь через пару десятков лет, а именно 19 января 2038 года в 03:14:08 по UTC Unix time достигнет значения 2147483648, и компьютерные системы могут интерпретировать это число как отрицательное. Ключ к решению данной проблемы лежит в использовании 64-битной (вместо 32-битной) переменной для хранения времени. В таком случае, запаса числовых значений Unix time хватит человечеству еще на 292 миллиарда лет. Неплохо, правда?

Unix время – одно для всех

Если вы живете в Лондоне или Сан-Франциско, а ваши друзья – в Москве, то «сверить часы» можно по Unix time: эта система в данный момент времени едина для всего мира. Естественно, если время на серверах выставлено правильно. А с помощью инструмента «Unixtime конвертер» такая конвертация займет у вас доли секунды.

Ссылка на основную публикацию
Adblock
detector