වර්තමාන යුනික්ස් කාලය මිලි තත්පර වලින් බාෂ් හි ලබා ගන්නේ කෙසේද?

255

වර්තමාන යුනික්ස් කාලය මිලි තත්පර වලින් ලබා ගන්නේ කෙසේද (එනම් 1970 ජනවාරි 1 සිට යුනික්ස් යුගයේ සිට මිලි තත්පර ගණන)?

bash unix time

— රිචඩ්
source

298

මෙය:

date +%s

යුගයේ සිට තත්පර ගණන නැවත ලබා දෙනු ඇත .

මෙය:

date +%s%N

තත්පර සහ වත්මන් නැනෝ තත්පර ලබා දෙයි.

ඒ නිසා:

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

යුගයේ සිට මිලි තත්පර ගණනක් ඔබට ලබා දෙනු ඇත - වත්මන් තත්පර සහ වම් නැනෝ තත්පර තුන.

සහ මයිකිබී වෙතින් - echo $(($(date +%s%N)/1000000))(1000 න් බෙදීමෙන් පමණක් මයික්‍රෝ තත්පරයට පැමිණේ )

— වොරන්
source

43

කප්පාදුව කොපමණ එම්එස් එකතු කරනවාදැයි මම කල්පනා කරමි :-)

— කයිල් බ්‍රැන්ඩ්ට්

13

නැතහොත් ඔබට ඒ සියල්ල ෂෙල් එකෙන් කිරීමට අවශ්‍ය නම්, අතිරේක ක්‍රියාවලියක මිල අධික පිරිවැය මඟ හැරීම (ඇත්ත වශයෙන්ම,% + s + N හි ඉලක්කම් ගණන වෙනස් වන විට අපි ගැටලුව මඟහරින්නෙමු):echo $(($(date +%s%N)/1000))

— මයිකි බී

27

මිනිසා යුනික්ස් ඉල්ලා සිටියේ ලිනක්ස් නොව, වර්තමාන ඉහළම පිළිතුර (දිනය +% s% N) මගේ AIX පද්ධතිය තුළ ක්‍රියා නොකරන බව සඳහන් කිරීම වටී යැයි මම සිතමි.

— පීට්

14

OSPete +1 OS X සඳහා සමාන වන අතර FreeBSD

— ocodo

7

%NOSX යොස්මයිට් මත වැඩ නොකරයි

— මැට් ක්ලාක්

115

ඔබට %3Nවඩාත් වැදගත් ඉලක්කම් 3 ට නැනෝ තත්පර කප්පාදු කිරීමට භාවිතා කළ හැකිය (ඒවා මිලි තත්පර වේ):

$ date +%s%3N
1397392146866

මෙය උදා වන්නේ මගේ කුබුන්ටු 12.04 (නිරවද්‍ය පැන්ගෝලින්) මත ය.

නමුත් %Nඔබේ ඉලක්ක පද්ධතිය අනුව ක්‍රියාත්මක නොවන බව මතක තබා ගන්න. උදා: කාවැද්දූ පද්ධතියක් මත පරීක්ෂා කරන ලදි (බිල්ඩ්රූට් රූට්ෆ්, එච්එෆ් නොවන ARM හරස් මෙවලම් කට්ටලයක් භාවිතයෙන් සම්පාදනය කරන ලදි) එහි නොමැත %N:

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

(තවද මගේ (මුල් බැස නැති) ඇන්ඩ්‍රොයිඩ් ටැබ්ලටයේ නොමැත %N.)

— ජෝ
source

1

@warren: මෙම ඔබ සංස්කරණය වෙනස් බව මම දැක 1397392146%3Nගැනීමට 1397392146%N, නමුත් ප්රතිදානය 1397392146%3Nමම ඇත්තටම මගේ ඇන්ඩ්රොයිඩ් ටැබ්ලට් පරිගණකය වන busybox පුවරුවේ දක්නට කැමතියි දේ බව ය. ඔබේ සංස්කරණය පැහැදිලි කළ හැකිද?

— ජෝ

ඉතිහාසයේ වොරන්ගේ ප්‍රකාශය "3 සිට 6 දක්වා වෙනස් කර ඇත, 3 ඔබව මයික්‍රෝ තත්පරයට පමණක් ගෙන යයි". ඔහුගේ සංස්කරණය මුළුමනින්ම ව්‍යාජ එකක් ලෙස පෙනේ; ඔබ එය ආපසු පෙරළා දැමිය යුතුයි.

— bukzor

1

මෙය විශේෂයෙන් GNU coreutils හි ලක්ෂණයකි. අවසානයේදී, මෙය මෙහි gnulib හි ක්‍රියාත්මක වේ: github.com/gagern/gnulib/blob/… .

— telotortium

එහි තිතක් තිබීම අර්ථවත් කරයි. date +%s.%3Nමුද්රණ 1510718281.134.

— darksky

මෙය පිළිගත් පිළිතුර විය යුතුය.

— නෝවා සුස්මාන්

68

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

— ල්රි
source

1

සම්පූර්ණත්වය සඳහා ...node -e 'console.log(Date.now())'

— slf

1

PHP භාවිතා කිරීම:php -r 'echo microtime(TRUE);'

— TachyonVortex

8

අනිවා, ඔබ එම පරිවර්තකයන් උණුසුම් වන තෙක් බලා සිටිය යුතුයි. මෙයද ක්‍රියාත්මක වේ:wget -qO- http://www.timeapi.org/utc/now?\\s.\\N

— කැමිලෝ මාටින්

9

නැතහොත්, ඔබට ඇත්ත වශයෙන්ම මිලි තත්පර අවශ්‍ය නොව නිවැරදි ආකෘතිය පමණක් නම්:date +%s000

— ලෙනාර් හොයිට්

1

apple.stackexchange.com/questions/135742/… ඕඑස්එක්ස් හි coreutils

— බ rew ස්

12

මගේ විසඳුම හොඳම නොවේ, නමුත් එය මට වැඩ කළේය:

date +%s000

මට අවශ්‍ය වූයේ 2012-05-05 වැනි දිනයක් මිලි තත්පර බවට පරිවර්තනය කිරීමයි.

— පැබ්ලෝ
source

1

Amazing hack, lol :)

— k06a

10

ඔබ මගේ සහායකයන් අතර කෙනෙකු විය යුතුයි.

— නකිලොන්

මම මෙම විසඳුම +9000 ලබා දෙමි

— Reut Sharabani

10

මෙය එතැනට විසි කිරීම පමණි, නමුත් බෙදීම සමඟ නිවැරදි සූත්‍රය වනු ඇත්තේ:

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

— splattne
source

8

මෙම විසඳුම මැකෝස් මත ක්රියා කරයි.

ඔබ Bash ස්ක්‍රිප්ට් එකක් භාවිතා කර පයිතන් තිබේ නම්, ඔබට මෙම කේතය භාවිතා කළ හැකිය:

#!/bin/bash

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

— ෆ්රෑන්ක් තෝනිග්
source

7

මිලි තත්පර ලබා ගැනීම සඳහා බාහිර වැඩසටහන් ධාවනය කිරීමට යෝජනා කරන පුද්ගලයින් සඳහා ... එම අනුපාතයට අනුව, ඔබටත් මෙය කළ හැකිය:

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

කාරණය: මෙතැන් සිට පිළිතුරක් ලබා ගැනීමට පෙර, කරුණාකර මතක තබා ගන්න සියලුම වැඩසටහන් එක තත්පරයක් තුළ ක්‍රියාත්මක නොවන බව. මැනීම!

— කැමිලෝ මාටින්
source

ඔබ දේශීය පද්ධතියෙන් වේලාව ඉල්ලන්නේ නැත. මා අනුමාන කරන දෙය ප්‍රශ්නයෙන් ගම්‍ය වේ. ඔබ ජාල සම්බන්ධතාවයක් මත ද රඳා පවතී.

— orkoden

2

@orkoden ප්‍රශ්නය පැහැදිලිවම 1970 ජනවාරි 1 සිට යුනික්ස් යුගයේ සිට මිලි තත්පර ගණනක් ඉල්ලා සිටී. එසේම, කාලය ලබා ගැනීම සඳහා ඔබ කිසි විටෙකත් රූබි හෝ පයිතන් (හෝ wget) ගිනි නොගත යුතු ආකාරය පෙන්වා දීමට මම වැඩි කැමැත්තක් දක්වමි - එක්කෝ මෙය වේගවත් නාලිකාවක් හරහා සිදු කිරීම හෝ මිලි තත්පර වලින් වැඩක් නැත.

— කැමිලෝ මාටින්

2

ඔව්, නරක විසඳුම්වල අඩුපාඩු ඉස්මතු කිරීමට ඔබ වඩාත් නරක විසඳුමක් ලබා දෙන බව මට වැටහුණි. මම විසඳුම් කිහිපයක් උත්සාහ කර කාලය මැන බැලුවෙමි. lpaste.net/119499 ප්‍රති results ල සිත්ගන්නා සුළුය. ඉතා වේගවත් i7 යන්ත්‍රයක පවා dateධාවනය කිරීමට 3 ms ගත වේ.

— orkoden

@orkoden හොඳ පරීක්ෂණයක්! කුමන මෙහෙයුම් පද්ධතියද? ක්‍රියාවලියට ඉහළින් විහිදෙන ක්‍රියාවලියට මෙය සම්බන්ධ විය හැකිය.

— කැමිලෝ මාටින්

1

Ak නකිලොන් සහ මේ නිසා කිසිවෙකු කිසිවක් නිෂ්පාදනය සඳහා වැනි පහසු පහසුකම් මත විශ්වාසය නොතැබිය යුතුය.

— කැමිලෝ මාටින්

3

ඔබගේ ස්ක්‍රිප්ට් ධාවනය වූ කාලය පෙන්වීමට ඔබ ක්‍රමයක් සොයන්නේ නම්, පහත දැක්වෙන්නේ (සම්පූර්ණයෙන්ම නිවැරදි නොවේ) ප්‍රති result ලයක් ලබා දෙනු ඇත:

ඔබේ ස්ක්‍රිප්ටයේ ආරම්භයට ආසන්නව, පහත සඳහන් දෑ ඇතුළත් කරන්න

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ඔබට අවශ්‍ය දේ කිරීමට බල කරන තරමක් දුර්ලභ පසුබිමකි . තව ගොඩක් තියෙනවා!

මම මෙය වින්ඩෝස් 7 / මින්ජීඩබ්ලිව් හි පමණක් පරීක්‍ෂා කළෙමි ... මා සතුව නිසි * නික්ස් පෙට්ටියක් නොමැත.

— user161733
source

3

නැතහොත් ඔබට භාවිතා කළ හැකියtime <script>

— වොරන්

2

අපට ලබා ගත හැකි වඩාත්ම නිවැරදි කාලරාමුව (අවම වශයෙන් මැක් ඕඑස් එක්ස් සඳහා) මෙය විය හැකිය:

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

1490665305.021699

නමුත් ධාවනය කිරීමට මිලි තත්පර 30 ක් පමණ ගත වන බව අප මතක තබා ගත යුතුය. අපට එය ඉලක්කම් 2 ක භාගයකට කපා ගත හැකි අතර, ආරම්භයේදීම කියවීමේ සාමාන්‍ය පොදු අගය ගණනය කර , පසුව එය මිනුම් වලින් ඉවත් කරන්න. මෙන්න උදාහරණයක්:

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 විධානයන් සීමා කළ හැකිය.

මෙම ස්ක්‍රිප්ටයේ ප්‍රති results ල සාමාන්‍යයෙන් මෙම ප්‍රති results ල 3 න් එකකි:

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

— ඉෂාක්
source

2

පිළිගත් පිළිතුරට වඩා මෙහි විප්ලවීය කිසිවක් එකතු කිරීම නොව, බාෂ් වෙත අලුතින් සිටින ඔබ වෙනුවෙන් එය පහසුවෙන් නැවත භාවිතා කළ හැකිය. මෙම උදාහරණය OS X සහ පැරණි Bash මත ක්‍රියාත්මක වන අතර එය මට පෞද්ගලිකව අවශ්‍යතාවයක් විය.

nowInMs() {
  echo "$(($(date +'%s * 1000 + %-N / 1000000')))"
}

දැන් ඔබට ධාවනය කළ හැකිය

TIMESTAMP="$(nowInMs)";

— බ්‍රැඩන් රොක්වෙල් නේපියර්
source

2

බෙදීමකින් තොරව මිලි තත්පර වලින් කාලය ලබා ගන්නේ කෙසේද යන්න මෙන්න. සමහර විට එය වේගවත් ...

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

යාවත්කාලීන කිරීම: Bash 4.2+ සමඟ පමණක් ක්‍රියා කරන පිරිසිදු Bash හි තවත් විකල්පයක් ඉහත ආකාරයටම වේ, නමුත් 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කාලය සඳහා විශේෂ අගයන් වේ.

— akostadinov
source

මගේ strftime(3)සහාය නොදක්වන %Nබැවින් printfනැනෝ තත්පර මුද්‍රණය කිරීමට ක්‍රමයක් නැත . මම උබුන්ටු 14.04 භාවිතා කරමි.

— haridsv

@haridsv, ඔව්, එය glibc හි නොමැත. dateවඩා විශ්වාසදායක විකල්පය මෙන් පෙනේ.

— akostadinov

1

දිනය සහ එක්ස්ප්රස් භාවිතා කිරීමෙන් ඔබට එහි යා හැකිය

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

ඔබට අවශ්‍ය ඕනෑම දෙයක් කිරීමට එය පුළුල් කරන්න

මෙය යුගයේ සිට මිලි තත්පර ලබා නොදෙන බව මට වැටහී ඇත, නමුත් සමහර අවස්ථාවන්ට පිළිතුරක් ලෙස එය තවමත් ප්‍රයෝජනවත් විය හැකිය, ඒ සියල්ල රඳා පවතින්නේ ඔබට සැබවින්ම අවශ්‍ය දේ මත ය, ඔබට මිලි තත්පර අංකයක් අවශ්‍ය නම් 1000 කින් ගුණ කරන්න: D

සරලම ක්‍රමය වනුයේ කුඩා ක්‍රියාත්මක කළ හැකි (C f.ex වෙතින්) සහ එය ස්ක්‍රිප්ටයට ලබා දීමයි.

— ජොහාන් ඇන්ඩර්සන්
source

dateකිහිප වතාවක් ධාවනය වීමේ විභව ගැටලුවක් තිබේ. සමහර අවස්ථාවලදී, ඔබේ විධානය ලියා ඇති පරිදි ලකුණු අතර දිනය හෝ වේලාව වෙනස් විය හැකිය. dateඑක් වරක් ධාවනය කර කොටස් විග්‍රහ කර ඔබේ ගණනය කිරීම වඩා හොඳය . එය කළ හැකි ක්‍රම කිහිපයකින් එකක් වනු ඇත t=$(date +%H%M%S); (( x = ${t:0:2} * 3600 + ${t:2:2} * 60 + ${t:4:2} )); echo "$x". මෙම ප්රශ්නය tagged බැවින් බෑෂ් කාරක රීති භාවිතා bash . ඔබ සඳහන් කරන පරිදි, ඔබගේ පිළිතුර (සහ මගේ විචලනය) වර්තමාන දිනය සඳහා තත්පර පමණක් ලබා දෙන අතර එය යුගයේ සිට මිලි වලින් නොවේ.

— වැඩිදුර දැනුම් දෙන තුරු විරාමය.

1

OS X හි සිටින විට පෙර ප්‍රතිචාර සියල්ලම එකට තැබීම,

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

— loretoparisi
source

1

(පෙර පිළිතුරු වලින් පුනරාවර්තනය කරන්න) date +%NOS X හි ක්‍රියා නොකරයි, නමුත් ඔබට මෙයද භාවිතා කළ හැකිය:

පර්ල් (කාලය අවශ්‍යයි :: ආකෘති මොඩියුලය). සමහර විට එය භාවිතා කිරීමට හොඳම CPAN මොඩියුලය නොවේ, නමුත් එය කාර්යය ඉටු කරයි. වේලාව :: ආකෘතිය සාමාන්‍යයෙන් බෙදාහැරීම් සමඟ ලබා ගත හැකිය.

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

— TVNshack
source

OP විශේෂයෙන් බැෂ් භාවිතයෙන් එය කළ හැකි ක්‍රම ඉල්ලා සිටියේය. මෙම බැෂ්, වෙනත් දෙයක් දියත් කිරීමේ ක්‍රමයක් ලෙස ඉතිරි කරන්නේ කෙසේද?

— මැඩ්හැටර්

මම මෙය මගේ බාෂ් ෂෙල් ස්ක්‍රිප්ට් වල ... OSX යටතේ භාවිතා කරමි. එබැවින්, dateභාවිතා කළ නොහැකි අතර අවශ්‍යතාවයට පිළිතුරු සපයන බෑෂ් පමණක් විධාන නොමැත.

— TVNshack

සාමාන්යයෙන් ප්රමාණවත්. ඔබේ පිළිතුරේ කොටසක් ලෙස OSX dateභාවිතා කළ නොහැක්කේ මන්දැයි ඔබ පැහැදිලි කළහොත් , මම මගේ පහත් අගය ඉවත් කරමි.

— මැඩ්හැටර්

ඉහත පිළිතුරු කිහිපයක් මෙය පැහැදිලි කරන ලදී. යෝජිත ලැයිස්තුව සමඟ නැති වූ විධානය මට විවරණයක් ලෙස එක් කළ නොහැක. ඒ නිසා මම එය මෙහි එකතු කළා.

— TVNshack

සාධාරණයි, මෙය කැනනයට ප්‍රයෝජනවත් එකතු කිරීමක් බව මම පිළිගනිමි. +1 මගෙන්!

— මැඩ්හැටර්

0

ඔබට සරල කවචයක් ඉක්මවා ගිය ගණනය කිරීමක් අවශ්‍ය නම්, මෙය පහසු සහ අතේ ගෙන යා හැකි ය, ෆ්‍රෑන්ක් තෝනිග්ගේ පිළිතුර භාවිතා කරමින් :

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

— බිල් චෙස්වික්
source

0

සඳහා ඇල්පයින් ලිනක්ස් (බොහෝ Docker රූප) සහ අනෙකුත් අවම ලිනක්ස් පරිසරය, ඔබ අපචාරයට හැකි adjtimex:

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

adjtimexකර්නල් කාල විචල්‍යයන් කියවීමට (සහ සැකසීමට) භාවිතා කරයි. සමග awkඔබ තත්පර ලබා ගැනීම, සහ සමග හැකි head, ඔබ විසින් පළමු ඉලක්කම් 3 ක් පමණක් භාවිතා කළ හැකිය.

මෙම විධානය කෙතරම් විශ්වාසදායකදැයි මා දන්නේ නැත.

සටහන: මෙම පිළිතුරෙන් ලැජ්ජා විරහිතව සොරකම් කර ඇත

— Qw3ry
source