How can I generate Unix timestamps?
UnixUnix TimestampUnix Problem Overview
Related question is "Datetime To Unix timestamp", but this question is more general.
I need Unix timestamps to solve my last question. My interests are Python, Ruby and Haskell, but other approaches are welcome.
What is the easiest way to generate Unix timestamps?
Unix Solutions
Solution 1 - Unix
In Linux or MacOS you can use:
date +%s
where
+%s
, seconds since 1970-01-01 00:00:00 UTC. (GNU Coreutils 8.24 Date manual)
Example output now 1454000043.
Solution 2 - Unix
in Ruby:
>> Time.now.to_i
=> 1248933648
Solution 3 - Unix
curl icanhazepoch.com
Basically it's unix timestamps as a service (UTaaS)
Solution 4 - Unix
In python add the following lines to get a time stamp:
>>> import time
>>> time.time()
1335906993.995389
>>> int(time.time())
1335906993
Solution 5 - Unix
$ date +%s.%N
where (GNU Coreutils 8.24 Date manual)
+%s
, seconds since 1970-01-01 00:00:00 UTC+%N
, nanoseconds (000000000..999999999) since epoch
Example output now 1454000043.704350695
.
I noticed that BSD manual of date
did not include precise explanation about the flag +%s
.
Solution 6 - Unix
In Perl:
>> time
=> 1335552733
Solution 7 - Unix
The unix 'date' command is surprisingly versatile.
date -j -f "%a %b %d %T %Z %Y" "date -j -f "%a %b %d %T %Z %Y" "date" "+%s"
" "+%s"
Takes the output of date
, which will be in the format defined by -f, and then prints it out (-j says don't attempt to set the date) in the form +%s, seconds since epoch.
Solution 8 - Unix
First of all, the Unix 'epoch' or zero-time is 1970-01-01 00:00:00Z (meaning midnight of 1st January 1970 in the Zulu or GMT or UTC time zone). A Unix time stamp is the number of seconds since that time - not accounting for leap seconds.
Generating the current time in Perl is rather easy:
perl -e 'print time, "\n"'
Generating the time corresponding to a given date/time value is rather less easy. Logically, you use the strptime()
function from POSIX. However, the Perl POSIX::strptime module (which is separate from the POSIX module) has the signature:
($sec, $min, $hour, $mday, $mon, $year, $wday, $yday) =
POSIX::strptime("string", "Format");
The function mktime
in the POSIX module has the signature:
mktime(sec, min, hour, mday, mon, year, wday = 0, yday = 0, isdst = 0)
So, if you know the format of your data, you could write a variant on:
perl -MPOSIX -MPOSIX::strptime -e \
'print mktime(POSIX::strptime("2009-07-30 04:30", "%Y-%m-%d %H:%M")), "\n"'
Solution 9 - Unix
in Haskell
import Data.Time.Clock.POSIX
main :: IO ()
main = print . floor =<< getPOSIXTime
in Go
import "time"
t := time.Unix()
in C
time(); // in time.h POSIX
// for Windows time.h
#define UNIXTIME(result) time_t localtime; time(&localtime); struct tm* utctime = gmtime(&localtime); result = mktime(utctime);
in Swift
NSDate().timeIntervalSince1970 // or Date().timeIntervalSince1970
Solution 10 - Unix
In Bash 5 there's a new variable:
echo $EPOCHSECONDS
Or if you want higher precision (in microseconds):
echo $EPOCHREALTIME
Solution 11 - Unix
For completeness, PHP:
php -r 'echo time();'
In BASH:
clitime=$(php -r 'echo time();')
echo $clitime
Solution 12 - Unix
In Haskell...
To get it back as a POSIXTime type:
import Data.Time.Clock.POSIX
getPOSIXTime
As an integer:
import Data.Time.Clock.POSIX
round `fmap` getPOSIXTime
Solution 13 - Unix
public static Int32 GetTimeStamp()
{
try
{
Int32 unixTimeStamp;
DateTime currentTime = DateTime.Now;
DateTime zuluTime = currentTime.ToUniversalTime();
DateTime unixEpoch = new DateTime(1970, 1, 1);
unixTimeStamp = (Int32)(zuluTime.Subtract(unixEpoch)).TotalSeconds;
return unixTimeStamp;
}
catch (Exception ex)
{
Debug.WriteLine(ex);
return 0;
}
}
Solution 14 - Unix
Let's try JavaScript:
var t = Math.floor((new Date().getTime()) / 1000);
...or even nicer, the static approach:
var t = Math.floor(Date.now() / 1000);
In both cases I divide by 1000
to go from seconds to millis and I use Math.floor
to only represent whole seconds that have passed (vs. rounding, which might round up to a whole second that hasn't passed yet).
Solution 15 - Unix
If I want to print utc date time using date command I need to using -u argument with date command.
Example
date -u
Output
Fri Jun 14 09:00:42 UTC 2019
Solution 16 - Unix
nawk:
$ nawk 'BEGIN{print srand()}'
- Works even on old versions of Solaris and probably other UNIX systems, where '''date +%s''' isn't implemented
- Doesn't work on Linux and other distros where the posix tools have been replaced with the GNU versions (nawk -> gawk etc.)
- Pretty unintuitive but definitelly amusing :-)
Solution 17 - Unix
For Unix-like environment the following will work.
# Current UNIXTIME
unixtime() {
datetime2unixtime "$(date -u +'%Y-%m-%d %H:%M:%S')"
}
# From DateTime(%Y-%m-%d %H:%M:%S)to UNIXTIME
datetime2unixtime() {
set -- "${1%% *}" "${1##* }"
set -- "${1%%-*}" "${1#*-}" "${2%%:*}" "${2#*:}"
set -- "$1" "${2%%-*}" "${2#*-}" "$3" "${4%%:*}" "${4#*:}"
set -- "$1" "${2#0}" "${3#0}" "${4#0}" "${5#0}" "${6#0}"
[ "$2" -lt 3 ] && set -- $(( $1-1 )) $(( $2+12 )) "$3" "$4" "$5" "$6"
set -- $(( (365*$1)+($1/4)-($1/100)+($1/400) )) "$2" "$3" "$4" "$5" "$6"
set -- "$1" $(( (306*($2+1)/10)-428 )) "$3" "$4" "$5" "$6"
set -- $(( ($1+$2+$3-719163)*86400+$4*3600+$5*60+$6 ))
echo "$1"
}
# From UNIXTIME to DateTime format(%Y-%m-%d %H:%M:%S)
unixtime2datetime() {
set -- $(( $1%86400 )) $(( $1/86400+719468 )) 146097 36524 1461
set -- "$1" "$2" $(( $2-(($2+2+3*$2/$3)/$5)+($2-$2/$3)/$4-(($2+1)/$3) ))
set -- "$1" "$2" $(( $3/365 ))
set -- "$@" $(( $2-( (365*$3)+($3/4)-($3/100)+($3/400) ) ))
set -- "$@" $(( ($4-($4+20)/50)/30 ))
set -- "$@" $(( 12*$3+$5+2 ))
set -- "$1" $(( $6/12 )) $(( $6%12+1 )) $(( $4-(30*$5+3*($5+4)/5-2)+1 ))
set -- "$2" "$3" "$4" $(( $1/3600 )) $(( $1%3600 ))
set -- "$1" "$2" "$3" "$4" $(( $5/60 )) $(( $5%60 ))
printf "%04d-%02d-%02d %02d:%02d:%02d\n" "$@"
}
# Examples
unixtime # => Current UNIXTIME
date +%s # Linux command
datetime2unixtime "2020-07-01 09:03:13" # => 1593594193
date -u +%s --date "2020-07-01 09:03:13" # Linux command
unixtime2datetime "1593594193" # => 2020-07-01 09:03:13
date -u --date @1593594193 +"%Y-%m-%d %H:%M:%S" # Linux command
Solution 18 - Unix
With NodeJS, just open a terminal and type:
node -e "console.log(new Date().getTime())"
or node -e "console.log(Date.now())"
Solution 19 - Unix
In Rust:
use std::time::{SystemTime, UNIX_EPOCH};
fn main() {
let now = SystemTime::now();
println!("{}", now.duration_since(UNIX_EPOCH).unwrap().as_secs())
}
Solution 20 - Unix
If you need a Unix timestamp from a shell script (Bourne family: sh, ksh, bash, zsh, ...), this should work on any Unix machine as unlike the other suggestions (perl, haskell, ruby, python, GNU date), it is based on a POSIX standard command and feature.
PATH=`getconf PATH` awk 'BEGIN {srand();print srand()}'