Risposte:
La risposta breve è:
$milliseconds = round(microtime(true) * 1000);
microtime(true) / 1000
(divisione invece di mulitplication)?
Usa microtime
. Questa funzione restituisce una stringa separata da uno spazio. La prima parte è la parte frazionaria dei secondi, la seconda parte è la parte integrale. Passa true
per ottenere come numero:
var_dump(microtime()); // string(21) "0.89115400 1283846202"
var_dump(microtime(true)); // float(1283846202.89)
Fai attenzione alla perdita di precisione se lo usi microtime(true)
.
C'è anche gettimeofday
che restituisce la parte di microsecondi come un numero intero.
var_dump(gettimeofday());
/*
array(4) {
["sec"]=>
int(1283846202)
["usec"]=>
int(891199)
["minuteswest"]=>
int(-60)
["dsttime"]=>
int(1)
}
*/
microtime()
uguale 1000*time()
, giusto?
1000
, giusto?
microtime(true)
e1000*time()
1000*time()
non ti darà millisecondi. microtime(true)
restituisce a float
che ha 14 cifre di precisione. La parte dei secondi ha già impiegato 10, quindi sono rimaste 4 cifre per la parte dei microsecondi. Questo dovrebbe essere sufficiente poiché i millisecondi richiedono solo 3 cifre extra.
Solo piattaforme a 64 bit!
function milliseconds() {
$mt = explode(' ', microtime());
return ((int)$mt[1]) * 1000 + ((int)round($mt[0] * 1000));
}
[ Se si esegue PHP a 64 bit, la costante PHP_INT_SIZE
equivale a8
]
Se si desidera una funzione equivalente di time()
in millisecondi, è necessario innanzitutto considerare che, poiché time()
restituisce il numero di secondi trascorsi dal "tempo dell'epoca" (01/01/1970), il numero di millisecondi dal "tempo dell'epoca" è un numero elevato e non rientra in un numero intero a 32 bit.
La dimensione di un numero intero in PHP può essere di 32 o 64 bit a seconda della piattaforma.
Da http://php.net/manual/en/language.types.integer.php
La dimensione di un numero intero dipende dalla piattaforma, sebbene un valore massimo di circa due miliardi sia il valore normale (ovvero 32 bit con segno). Le piattaforme a 64 bit hanno in genere un valore massimo di circa 9E18, ad eccezione di Windows, che è sempre a 32 bit. PHP non supporta numeri interi senza segno. Le dimensioni intere possono essere determinate usando la costante PHP_INT_SIZE e il valore massimo usando la costante PHP_INT_MAX da PHP 4.4.0 e PHP 5.0.5.
Se si dispone di numeri interi a 64 bit, è possibile utilizzare la seguente funzione:
function milliseconds() {
$mt = explode(' ', microtime());
return ((int)$mt[1]) * 1000 + ((int)round($mt[0] * 1000));
}
microtime()
restituisce il numero di secondi dal "tempo dell'epoca" con precisione fino a microsecondi con due numeri separati da spazio, come ...
0.90441300 1409263371
Il secondo numero è i secondi (numero intero) mentre il primo è la parte decimale.
La funzione precedente milliseconds()
prende la parte intera moltiplicata per1000
1409263371000
quindi aggiunge la parte decimale moltiplicata per 1000
e arrotondata a 0 decimali
1409263371904
Si noti che entrambi $mt[1]
e il risultato di round
vengono sottoposti a cast int
. Ciò è necessario perché sono float
s e l'operazione su di essi senza il cast comporterebbe la restituzione della funzione a float
.
Infine, quella funzione è leggermente più precisa di
round(microtime(true)*1000);
che con un rapporto di 1:10 (circa) restituisce 1 millisecondo in più rispetto al risultato corretto. Ciò è dovuto alla precisione limitata del tipo float ( microtime(true)
restituisce un float). Comunque, se preferisci ancora il più corto round(microtime(true)*1000);
, suggerirei di lanciare int
il risultato.
Anche se va oltre lo scopo della domanda, vale la pena ricordare che se la tua piattaforma supporta numeri interi a 64 bit, puoi anche ottenere l'ora corrente in microsecondi senza incorrere in un overflow.
Se fact 2^63 - 1
(il più grande intero con segno) diviso per 10^6 * 3600 * 24 * 365
(circa i microsecondi in un anno) dà 292471
.
È lo stesso valore che ottieni
echo (int)( PHP_INT_MAX / ( 1000000 * 3600 * 24 * 365 ) );
In altre parole, un intero con segno a 64 bit ha spazio per memorizzare un intervallo di tempo di oltre 200.000 anni misurato in microsecondi.
Potresti averlo allora
function microseconds() {
$mt = explode(' ', microtime());
return ((int)$mt[1]) * 1000000 + ((int)round($mt[0] * 1000000));
}
Come altri hanno già detto, è possibile utilizzare microtime()
per ottenere la precisione in millisecondi sui timestamp.
Dai tuoi commenti, sembri volerlo come un Timestamp UNIX di alta precisione. Qualcosa come DateTime.Now.Ticks
nel mondo .NET.
A tale scopo è possibile utilizzare la seguente funzione:
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);
}
Utilizzare microtime(true)
in PHP 5 o la seguente modifica in PHP 4:
array_sum(explode(' ', microtime()));
Un modo portatile per scrivere quel codice sarebbe:
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'];
produzione:
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']);
prova questo:
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");
}
Funziona anche se sei su PHP a 32 bit:
list($msec, $sec) = explode(' ', microtime());
$time_milli = $sec.substr($msec, 2, 3); // '1491536422147'
$time_micro = $sec.substr($msec, 2, 6); // '1491536422147300'
Nota che questo non ti dà numeri interi, ma stringhe. Tuttavia, funziona bene in molti casi, ad esempio quando si creano URL per richieste REST.
Se hai bisogno di numeri interi, PHP a 64 bit è obbligatorio.
Quindi è possibile riutilizzare il codice sopra e trasmettere a (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
Oppure puoi usare le vecchie vecchie battute:
$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: PHP5 è richiesto per questa funzione a causa dei miglioramenti con microtime () ed è richiesto anche il modulo matematico bc (dato che abbiamo a che fare con numeri grandi, puoi verificare se hai il modulo in phpinfo).
Spero che questo ti aiuti.
$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)
d'altra parte restituisce l'ora corrente in secondi poiché l'epoca Unix è precisa al microsecondo più vicino (vedi riferimento PHP). In realtà è molto semplice testare se si esegue il codice sopra in un ciclo e si visualizzano i millisecondi.