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

Как узнать текущее время Unix в миллисекундах (т. Е. Количество миллисекунд с начала Unix 1 января 1970 года)?

Этот:

date +%s 

вернет количество секунд с начала эпохи.

Этот:

date +%s%N

возвращает секунды и текущие наносекунды.

Так:

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

даст вам количество миллисекунд с начала эпохи - текущие секунды плюс три оставшиеся наносекунды.

и от MikeyB - echo $(($(date +%s%N)/1000000))(деление на 1000 приносит только микросекунды)

Вы можете просто использовать, %3Nчтобы урезать наносекунды до 3 самых значащих цифр (которые тогда являются миллисекундами):

$ date +%s%3N
1397392146866

Это работает, например, на моем Kubuntu 12.04.

Но имейте в виду, что %Nэто не может быть реализовано в зависимости от вашей целевой системы. Например, тестирование во встроенной системе (buildroot rootfs, скомпилированный с использованием не-HF-кросс-цепочки инструментов) не было %N:

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

(А также у моего (не рутированного) планшета Android нет %N).

date +%N не работает на OS X, но вы можете использовать один из

• Рубин: ruby -e 'puts Time.now.to_f'
• питон: python -c 'import time; print time.time()'
• Node.js: node -e 'console.log(Date.now())'
• PHP: php -r 'echo microtime(TRUE);'
• Эликсир: DateTime.utc_now() |> DateTime.to_unix(:millisecond)
• интернет: wget -qO- http://www.timeapi.org/utc/now?\\s.\\N
• или за миллисекунды с округлением до ближайшей секунды date +%s000

Просто добавлю это, но я думаю, что правильная формула с делением была бы:

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

Мое решение не лучшее, но сработало для меня.

date +%s000

Мне просто нужно было преобразовать дату, например 2012-05-05, в миллисекунды.

Для людей, которые предлагают запускать внешние программы, чтобы получить миллисекунды ... с такой скоростью, вы могли бы также сделать это:

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

Суть в том, что перед тем, как выбрать любой ответ отсюда, имейте в виду, что не все программы будут работать менее одной секунды. Мера!

это решение работает на macOS.

если вы планируете использовать bash-скрипт и имеете Python, вы можете использовать этот код:

#!/bin/bash

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

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

Как можно ближе к началу вашего сценария введите следующее

basetime=$(date +%s%N)

Это даст вам начальную стоимость чего-то вроде 1361802943996000000

В конце вашего скрипта используйте следующее

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

который будет отображать что-то вроде

runtime: 12.383 seconds

Примечания:

(1 * 10 ^ 09) можно заменить на 1000000000, если вы хотите

"scale=3"это довольно редкая настройка, которая заставляет bcделать то, что вы хотите. Есть много больше!

Я проверял это только на Win7 / MinGW ... У меня нет подходящего * nix-бокса.

Вот как можно получить время в миллисекундах без деления. Может быть, это быстрее ...

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

Обновление: другая альтернатива в чистом bash, которая работает только с bash 4.2+тем же, что и выше, но используется printfдля получения даты. Это определенно будет быстрее, потому что ни один из процессов не разветвляется.

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

Еще один улов здесь, однако, заключается в том, что ваша strftimeреализация должна поддерживать, %sа %Nэто НЕ на моем тестовом компьютере. Смотрите man strftimeдля поддерживаемых вариантов. Также смотрите, man bashчтобы увидеть printfсинтаксис. -1и -2являются специальными значениями для времени.

Наиболее точная временная метка, которую мы можем получить (по крайней мере, для Mac OS X), вероятно, такова:

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

1490665305.021699

Но мы должны помнить, что для запуска требуется около 30 миллисекунд. Мы можем сократить его до шкалы из двухзначной дроби и в самом начале вычислить средние накладные расходы на считывание времени, а затем убрать его из измерения. Вот пример:

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

Вы можете раскомментировать команды echo, чтобы лучше понять, как она работает.

Результаты для этого сценария обычно являются одним из этих 3 результатов:

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

Использование date и expr может привести вас туда, т.е.

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

Просто расширьте его, чтобы делать все, что вы хотите

Я понимаю, что это не дает миллисекунд с начала эпохи, но это может все еще быть полезным в качестве ответа для некоторых случаев, все зависит от того, для чего это действительно нужно, умножьте на 1000, если вам нужно число в миллисекундах: D

Простейшим способом было бы сделать небольшой исполняемый файл (из Cf.ex.) и сделать его доступным для скрипта.

(повторите выше) date +%Nне работает на OS X, но вы также можете использовать:

Perl (требуется модуль Time :: Format). Возможно, не самый лучший модуль CPAN для использования, но выполняет свою работу. Time :: Format обычно предоставляется с дистрибутивами.

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

Собираем все вместе предыдущие ответы, когда в OSX

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

ты можешь делать как

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

Если вы хотите простое вычисление по окончании оболочки, это легко и переносимо, используя приведенный выше ответ:

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

Для Alpine Linux (много образов Docker) и, возможно, других минимальных сред Linux, вы можете злоупотреблять adjtimex:

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

adjtimexиспользуется для чтения (и установки) переменных времени ядра. С помощью awkвы можете получить микросекунды, с помощью headвы можете использовать только первые 3 цифры.

Я понятия не имею, насколько надежна эта команда.

Примечание: бесстыдно украден из этого ответа