How can I generate Unix timestamps?

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?

20 Answers

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.

in Ruby:

>> Time.now.to_i => 1248933648 

curl icanhazepoch.com

Basically it's unix timestamps as a service (UTaaS)

In python add the following lines to get a time stamp:

>>> import time >>> time.time() 1335906993.995389 >>> int(time.time()) 1335906993 

$ 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.

In Perl:

>> time => 1335552733 

The unix 'date' command is surprisingly versatile.

 date -j -f "%a %b %d %T %Z %Y" "`date`" "+%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.

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

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 

In Bash 5 there's a new variable:

echo $EPOCHSECONDS 

Or if you want higher precision (in microseconds):

echo $EPOCHREALTIME 

For completeness, PHP:

php -r 'echo time();' 

In BASH:

clitime=$(php -r 'echo time();') echo $clitime 

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 

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

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).

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 

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 :-)

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 

With NodeJS, just open a terminal and type:
node -e "console.log(new Date().getTime())" or node -e "console.log(Date.now())"

In Rust:

use std::time::{SystemTime, UNIX_EPOCH}; fn main() { let now = SystemTime::now(); println!("{}", now.duration_since(UNIX_EPOCH).unwrap().as_secs()) } 

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()}'