Como obter o tempo atual do Unix em milissegundos no bash?

Como obtenho o tempo atual do Unix em milissegundos (ou seja, número de milissegundos desde a época do Unix, em 1º de janeiro de 1970)?

Este:

date +%s 

retornará o número de segundos desde a época.

Este:

date +%s%N

retorna os segundos e os nanossegundos atuais.

Assim:

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

fornecerá o número de milissegundos desde a época - segundos atuais mais os três à esquerda dos nanossegundos.

e do MikeyB - echo $(($(date +%s%N)/1000000))(dividir por 1000 gera apenas em microssegundos)

Você pode simplesmente usar %3Npara truncar os nanossegundos para os três dígitos mais significativos (que são, em seguida, milissegundos):

$ date +%s%3N
1397392146866

Isso funciona, por exemplo, no meu kubuntu 12.04.

Mas esteja ciente de que isso %Npode não ser implementado dependendo do seu sistema de destino. Por exemplo, testado em um sistema incorporado (rootfs do buildroot, compilado usando uma cadeia de ferramentas cruzada de braço não HF), não havia %N:

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

(E também o meu tablet Android (não enraizado) não tem %N).

date +%N não funciona no OS X, mas você pode usar um dos

• rubi: ruby -e 'puts Time.now.to_f'
• Pitão: 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)
• as internets: wget -qO- http://www.timeapi.org/utc/now?\\s.\\N
• ou por milissegundos arredondados para o segundo mais próximo date +%s000

Apenas jogando isso lá fora, mas acho que a fórmula correta com a divisão seria:

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

Minha solução não é a melhor, mas funcionou para mim.

date +%s000

Eu só precisava converter uma data como 05/05/2012 para milissegundos.

Para as pessoas que sugerem executar programas externos para obter os mili segundos ... nesse ritmo, você também pode fazer o seguinte:

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

A questão é: antes de escolher qualquer resposta a partir daqui, lembre-se de que nem todos os programas serão executados em menos de um segundo. A medida!

Esta solução funciona no macOS.

se você considerar usar um script bash e tiver python disponível, poderá usar este código:

#!/bin/bash

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

Se você estiver procurando uma maneira de exibir o período de execução do script, o seguinte fornecerá um resultado (não totalmente preciso):

O mais próximo possível do script, digite o seguinte

basetime=$(date +%s%N)

Isso fornecerá um valor inicial de algo como 1361802943996000000

No final do seu script, use o seguinte

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

que exibirá algo como

runtime: 12.383 seconds

Notas:

(1 * 10 ^ 09) pode ser substituído por 1000000000 se você desejar

"scale=3"é uma configuração bastante rara que obriga bca fazer o que você deseja. Há muito mais!

Eu só testei isso no Win7 / MinGW ... Não tenho uma caixa * nix adequada à mão.

Aqui está como obter tempo em milissegundos sem executar a divisão. Talvez seja mais rápido ...

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

Atualização: Outra alternativa no bash puro que funciona apenas com o bash 4.2+mesmo é acima, mas use printfpara obter a data. Definitivamente, será mais rápido porque nenhum processo é extraído do principal.

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

Outro problema aqui é que sua strftimeimplementação deve suportar %se %NNÃO é o caso na minha máquina de teste. Veja man strftimepara opções suportadas. Veja também man bashpara ver a printfsintaxe. -1e -2são valores especiais para o tempo.

O carimbo de data e hora mais preciso que podemos obter (pelo menos para o Mac OS X) é provavelmente o seguinte:

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

1490665305.021699

Mas precisamos ter em mente que leva cerca de 30 milissegundos para ser executado. Podemos reduzi-lo na escala da fração de 2 dígitos e, no início, calcular a sobrecarga média da leitura do tempo e removê-lo da medição. Aqui está um exemplo:

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`"

Você pode descomentar os comandos de eco para ver melhor como ele funciona.

Os resultados para este script são geralmente um destes 3 resultados:

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

Usar date e expr pode levá-lo até lá, ie

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

Basta expandi-lo para fazer o que quiser

Sei que isso não dá milissegundos desde a época, mas ainda pode ser útil como resposta para alguns casos, tudo depende do que você realmente precisa, multiplique por 1000 se precisar de um número de milissegundos: D

A maneira mais simples seria tornar um pequeno executável (de C f.ex.) e disponibilizá-lo para o script.

(repetir de cima) date +%Nnão funciona no OS X, mas você também pode usar:

Perl (requer o módulo Time :: Format). Talvez não seja o melhor módulo de CPAN a ser usado, mas faz o trabalho. Time :: Format geralmente é disponibilizado com distribuições.

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

Reunindo todas as respostas anteriores, quando estiver no OSX

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

você pode fazer 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"
}

Se você deseja um cálculo simples de shell, isso é fácil e portátil, usando a resposta acima:

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 linux alpino (muitas imagens do docker) e possivelmente outros ambientes linux mínimos, você pode abusar adjtimex:

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

adjtimexé usado para ler (e definir) variáveis ​​de tempo do kernel. Com awkvocê pode obter os microssegundos, headvocê pode usar apenas os 3 primeiros dígitos.

Não tenho ideia de quão confiável é esse comando.

Nota: Roubado descaradamente desta resposta