¿Cómo obtener el tiempo actual de Unix en milisegundos en bash?

¿Cómo obtengo el tiempo actual de Unix en milisegundos (es decir, el número de milisegundos desde la época de Unix el 1 de enero de 1970)?

Esta:

date +%s 

devolverá el número de segundos desde la época.

Esta:

date +%s%N

devuelve los segundos y nanosegundos actuales.

Entonces:

date +%s%N | cut -b1-13

le dará la cantidad de milisegundos desde la época - segundos actuales más los tres nanosegundos restantes.

y de MikeyB - echo $(($(date +%s%N)/1000000))(dividir entre 1000 solo lleva a microsegundos)

Simplemente puede usar %3Npara truncar los nanosegundos a los 3 dígitos más significativos (que luego son milisegundos):

$ date +%s%3N
1397392146866

Esto funciona, por ejemplo, en mi kubuntu 12.04.

Pero tenga en cuenta que eso %Npuede no implementarse dependiendo de su sistema de destino. Por ejemplo, probado en un sistema integrado (buildroot rootfs, compilado usando una cadena de herramientas cruzadas de brazo no HF) no había %N:

$ date +%s%3N
1397392146%3N

(Y también mi tableta Android (no rooteada) no tiene %N).

date +%N no funciona en OS X, pero podría usar uno de

• rubí: ruby -e 'puts Time.now.to_f'
• pitón: python -c 'import time; print time.time()'
• node.js: node -e 'console.log(Date.now())'
• PHP: php -r 'echo microtime(TRUE);'
• Elixir: DateTime.utc_now() |> DateTime.to_unix(:millisecond)
• los internet: wget -qO- http://www.timeapi.org/utc/now?\\s.\\N
• o por milisegundos redondeados al segundo más cercano date +%s000

Solo lanzando esto, pero creo que la fórmula correcta con la división sería:

echo $(($(date +%s%N)/1000000))

Mi solución no es la mejor, pero funcionó para mí.

date +%s000

Solo necesitaba convertir una fecha como 2012-05-05 a milisegundos.

Para las personas que sugieren ejecutar programas externos para obtener los milisegundos ... a ese ritmo, también podría hacer esto:

wget -qO- http://www.timeapi.org/utc/now?\\s.\\N

El punto es: antes de elegir cualquier respuesta desde aquí, tenga en cuenta que no todos los programas se ejecutarán en un segundo entero. ¡Medida!

Esta solución funciona en macOS.

Si considera usar un script bash y tiene Python disponible, puede usar este código:

#!/bin/bash

python -c 'from time import time; print int(round(time() * 1000))'

Si está buscando una manera de mostrar la cantidad de tiempo que se ejecutó su script, lo siguiente proporcionará un resultado (no completamente preciso):

Tan cerca como pueda del comienzo de su secuencia de comandos, ingrese lo siguiente

basetime=$(date +%s%N)

Esto le dará un valor inicial de algo como 1361802943996000000

Al final de su secuencia de comandos, use lo siguiente

echo "runtime: $(echo "scale=3;($(date +%s%N) - ${basetime})/(1*10^09)" | bc) seconds"

que mostrará algo como

runtime: 12.383 seconds

Notas:

(1 * 10 ^ 09) se puede reemplazar con 1000000000 si lo desea

"scale=3"es un entorno bastante raro que obliga bca hacer lo que quieres. ¡Hay muchos más!

Solo probé esto en Win7 / MinGW ... No tengo una caja * nix adecuada a mano.

Aquí se explica cómo obtener tiempo en milisegundos sin realizar la división. Quizás sea más rápido ...

# test=`date +%s%N`
# testnum=${#test}
# echo ${test:0:$testnum-6}
1297327781715

Actualización: Otra alternativa en pure bash que solo funciona bash 4.2+es la misma que la anterior, pero se usa printfpara obtener la fecha. Definitivamente será más rápido porque ningún proceso se bifurca fuera del principal.

printf -v test '%(%s%N)T' -1
testnum=${#test}
echo ${test:0:$testnum-6}

Sin embargo, otro inconveniente aquí es que su strftimeimplementación debería ser compatible %sy %Nque NO es el caso en mi máquina de prueba. Consulte las man strftimeopciones compatibles. Ver también man bashpara ver la printfsintaxis. -1y -2son valores especiales para el tiempo.

La marca de tiempo más precisa que podemos obtener (al menos para Mac OS X) es probablemente esta:

python -c 'import datetime; print datetime.datetime.now().strftime("%s.%f")'

1490665305.021699

Pero debemos tener en cuenta que se necesitan alrededor de 30 milisegundos para ejecutarse. Podemos cortarlo a la escala de la fracción de 2 dígitos y, al comienzo, calcular la sobrecarga promedio de lectura del tiempo y luego eliminarlo de la medición. Aquí hay un ejemplo:

function getTimestamp {
  echo `python -c 'import datetime; print datetime.datetime.now().strftime("%s.%f")' | cut -b1-13` 
}
function getDiff {
  echo "$2-$1-$MeasuringCost" | bc
}
prev_a=`getTimestamp`
acc=0
ITERATIONS=30
for i in `seq 1 $ITERATIONS`;do 
  #echo -n $i 
  a=`getTimestamp`
  #echo -n "   $a"
  b=`echo "$a-$prev_a" | bc`
  prev_a=$a
  #echo "  diff=$b"
  acc=`echo "$acc+$b" | bc`
done
MeasuringCost=`echo "scale=2; $acc/$ITERATIONS" | bc`
echo "average: $MeasuringCost sec"
t1=`getTimestamp`
sleep 2
t2=`getTimestamp`
echo "measured seconds: `getDiff $t1 $t2`"

Puede descomentar los comandos de eco para ver mejor cómo funciona.

Los resultados de este script suelen ser uno de estos 3 resultados:

measured seconds: 1.99
measured seconds: 2.00
measured seconds: 2.01

Usar date y expr puede llevarte allí, es decir

X=$(expr \`date +%H\` \\* 3600 + \`date +%M\` \\* 60 + \`date +%S\`)
echo $X

Solo amplíalo para hacer lo que quieras

Me doy cuenta de que esto no da milisegundos desde la época, pero aún puede ser útil como respuesta para algunos de los casos, todo depende de lo que realmente necesita, multiplique por 1000 si necesita un número de milisegundos: D

La forma más sencilla sería hacer un pequeño ejecutable (de C f.ex.) y ponerlo a disposición del script.

(repetir desde arriba) date +%Nno funciona en OS X, pero podría usar también:

Perl (requiere Time :: Módulo de formato). Quizás no sea el mejor módulo de CPAN para usar, pero hace el trabajo. Time :: Format generalmente está disponible con distribuciones.

perl -w -e'use Time::Format; printf STDOUT ("%s.%s\n", time, $time{"mmm"})'

Poniendo todas las respuestas anteriores juntas, cuando en OSX

ProductName:    Mac OS X
ProductVersion: 10.11.6
BuildVersion:   15G31+

puedes hacer como

microtime() {
    python -c 'import time; print time.time()'
}
compute() {
    local START=$(microtime)
    #$1 is command $2 are args
    local END=$(microtime)
    DIFF=$(echo "$END - $START" | bc)
    echo "$1\t$2\t$DIFF"
}

Si desea un cómputo transcurrido de shell simple, esto es fácil y portátil, utilizando la respuesta anterior:

now() {
    python -c 'import datetime; print datetime.datetime.now().strftime("%s.%f")'
}
seismo:~$ x=`now`
seismo:~$ y=`now`
seismo:~$ echo "$y - $x" | bc
5.212514

Para alpine linux (muchas imágenes acoplables) y posiblemente otros entornos mínimos de linux, puede abusar de adjtimex:

adjtimex | awk '/(time.tv_usec):/ { printf("%06d\n", $2) }' | head -c3

adjtimexse usa para leer (y configurar) las variables de tiempo del núcleo. Con awkusted puede obtener los microsegundos, con headusted puede usar solo los primeros 3 dígitos.

No tengo idea de cuán confiable es este comando.

Nota: descaradamente robado de esta respuesta