Respostas:
A resposta curta é:
$milliseconds = round(microtime(true) * 1000);
microtime(true) / 1000
(divisão em vez de multiplicação múltipla)?
Use microtime
. Esta função retorna uma string separada por um espaço. A primeira parte é a parte fracionária de segundos, a segunda parte é a parte integrante. Passe true
para obter como um número:
var_dump(microtime()); // string(21) "0.89115400 1283846202"
var_dump(microtime(true)); // float(1283846202.89)
Cuidado com a perda de precisão se você usar microtime(true)
.
Também há gettimeofday
que retorna a parte de microssegundos como um número inteiro.
var_dump(gettimeofday());
/*
array(4) {
["sec"]=>
int(1283846202)
["usec"]=>
int(891199)
["minuteswest"]=>
int(-60)
["dsttime"]=>
int(1)
}
*/
microtime()
é igual 1000*time()
, certo?
1000
, certo?
microtime(true)
e1000*time()
1000*time()
não lhe dará milissegundos. microtime(true)
retorna um float
que possui 14 dígitos de precisão. A parte dos segundos já levava 10, deixando 4 dígitos para a parte dos microssegundos. Isso deve ser suficiente, já que os milissegundos requerem apenas 3 dígitos extras.
Apenas plataformas de 64 bits!
function milliseconds() {
$mt = explode(' ', microtime());
return ((int)$mt[1]) * 1000 + ((int)round($mt[0] * 1000));
}
[ Se você estiver executando PHP de 64 bits, a constante será PHP_INT_SIZE
igual a8
]
Se você deseja uma função equilibrada time()
em milissegundos primeiro, considere que, como time()
retorna o número de segundos decorridos desde o "tempo da época" (01/01/1970), o número de milissegundos desde o "tempo da época" é um número grande e não cabe em um número inteiro de 32 bits.
O tamanho de um número inteiro no PHP pode ser de 32 ou 64 bits, dependendo da plataforma.
Em http://php.net/manual/en/language.types.integer.php
O tamanho de um número inteiro depende da plataforma, embora um valor máximo de cerca de dois bilhões seja o valor usual (com 32 bits assinados). As plataformas de 64 bits geralmente têm um valor máximo de cerca de 9E18, exceto o Windows, que sempre é de 32 bits. O PHP não suporta números inteiros não assinados. O tamanho inteiro pode ser determinado usando a constante PHP_INT_SIZE e o valor máximo usando a constante PHP_INT_MAX desde o PHP 4.4.0 e o PHP 5.0.5.
Se você tiver números inteiros de 64 bits, poderá usar a seguinte função:
function milliseconds() {
$mt = explode(' ', microtime());
return ((int)$mt[1]) * 1000 + ((int)round($mt[0] * 1000));
}
microtime()
retorna o número de segundos desde o "tempo da época" com precisão de até microssegundos com dois números separados por espaço, como ...
0.90441300 1409263371
O segundo número é o segundo (inteiro), enquanto o primeiro é a parte decimal.
A função acima milliseconds()
leva a parte inteira multiplicada por1000
1409263371000
em seguida, adiciona a parte decimal multiplicada por 1000
e arredondada para 0 casas decimais
1409263371904
Observe que ambos $mt[1]
e o resultado de round
são convertidos para int
. Isso é necessário porque eles são se float
a operação neles sem conversão resultaria no retorno da função a float
.
Finalmente, essa função é um pouco mais precisa do que
round(microtime(true)*1000);
isso com uma proporção de 1:10 (aprox.) retorna 1 milissegundo a mais do que o resultado correto. Isso ocorre devido à precisão limitada do tipo de flutuação ( microtime(true)
retorna uma flutuação). De qualquer forma, se você ainda preferir o mais curto round(microtime(true)*1000);
, sugiro transmitir int
o resultado.
Mesmo que esteja além do escopo da pergunta, vale ressaltar que se sua plataforma suportar números inteiros de 64 bits, você também poderá obter o tempo atual em microssegundos sem incorrer no estouro.
Se o fato 2^63 - 1
(maior número inteiro assinado) dividido por 10^6 * 3600 * 24 * 365
(aproximadamente os microssegundos em um ano) der 292471
.
Esse é o mesmo valor que você obtém
echo (int)( PHP_INT_MAX / ( 1000000 * 3600 * 24 * 365 ) );
Em outras palavras, um número inteiro assinado de 64 bits tem espaço para armazenar um período de tempo superior a 200.000 anos medido em microssegundos.
Você pode ter então
function microseconds() {
$mt = explode(' ', microtime());
return ((int)$mt[1]) * 1000000 + ((int)round($mt[0] * 1000000));
}
Como já foi dito, você pode usar microtime()
para obter precisão de milissegundos nos registros de data e hora.
A partir dos seus comentários, você parece desejá-lo como um carimbo de data / hora UNIX de alta precisão. Algo como DateTime.Now.Ticks
no mundo .NET.
Você pode usar a seguinte função para fazer isso:
function millitime() {
$microtime = microtime();
$comps = explode(' ', $microtime);
// Note: Using a string here to prevent loss of precision
// in case of "overflow" (PHP converts it to a double)
return sprintf('%d%03d', $comps[1], $comps[0] * 1000);
}
Use microtime(true)
no PHP 5 ou a seguinte modificação no PHP 4:
array_sum(explode(' ', microtime()));
Uma maneira portátil de escrever esse código seria:
function getMicrotime()
{
if (version_compare(PHP_VERSION, '5.0.0', '<'))
{
return array_sum(explode(' ', microtime()));
}
return microtime(true);
}
echo date('Y-m-d H:i:s.') . gettimeofday()['usec'];
resultado:
2016-11-19 15:12:34.346351
$t = gettimeofday(); echo date('Y-m-d H:i:s.',$t['sec']) . $t['usec'];
$timeofday=gettimeofday(); echo sprintf("%s.%06d", date('Y-m-d H:i:s', $timeofday['sec']), $timeofday['usec']);
tente isto:
public function getTimeToMicroseconds() {
$t = microtime(true);
$micro = sprintf("%06d", ($t - floor($t)) * 1000000);
$d = new DateTime(date('Y-m-d H:i:s.' . $micro, $t));
return $d->format("Y-m-d H:i:s.u");
}
Isso funciona mesmo se você estiver no PHP de 32 bits:
list($msec, $sec) = explode(' ', microtime());
$time_milli = $sec.substr($msec, 2, 3); // '1491536422147'
$time_micro = $sec.substr($msec, 2, 6); // '1491536422147300'
Observe que isso não fornece números inteiros, mas strings. No entanto, isso funciona bem em muitos casos, por exemplo, ao criar URLs para solicitações REST.
Se você precisar de números inteiros, o PHP de 64 bits é obrigatório.
Então você pode reutilizar o código acima e converter para (int):
list($msec, $sec) = explode(' ', microtime());
// these parentheses are mandatory otherwise the precedence is wrong!
// ↓ ↓
$time_milli = (int) ($sec.substr($msec, 2, 3)); // 1491536422147
$time_micro = (int) ($sec.substr($msec, 2, 6)); // 1491536422147300
Ou você pode usar as boas e velhas one-liners:
$time_milli = (int) round(microtime(true) * 1000); // 1491536422147
$time_micro = (int) round(microtime(true) * 1000000); // 1491536422147300
$timeparts = explode(" ",microtime());
$currenttime = bcadd(($timeparts[0]*1000),bcmul($timeparts[1],1000));
echo $currenttime;
NOTA: O PHP5 é necessário para esta função devido às melhorias com microtime () e o módulo matemático bc também é necessário (como estamos lidando com números grandes, você pode verificar se possui o módulo no phpinfo).
Espero que isso ajude você.
$the_date_time = new DateTime($date_string);
$the_date_time_in_ms = ($the_date_time->format('U') * 1000) +
($the_date_time->format('u') / 1000);
PHP 5.2.2 <
$d = new DateTime();
echo $d->format("Y-m-d H:i:s.u"); // u : Microseconds
PHP 7.0.0 <7.1
$d = new DateTime();
echo $d->format("Y-m-d H:i:s.v"); // v : Milliseconds
time()
.microtime(true)
por outro lado, retorna o tempo atual em segundos desde que a época do Unix precisa até o microssegundo mais próximo (consulte a referência do PHP). Na verdade, é muito fácil testar se você executa o código acima em um loop e exibe os milissegundos.