System time
You are encouraged to solve this task according to the task description, using any language you may know.
- Task
Output the system time (any units will do as long as they are noted) either by a system command or one built into the language.
The system time can be used for debugging, network information, random number seeds, or something as simple as program performance.
- Related task
- See also
ABAP
<lang aime>REPORT system_time.
WRITE: sy-uzeit.</lang>
Ada
The following example displays a date-time stamp. The time zone value is the number of minutes offset from the prime meridian.<lang ada>with Ada.Calendar; use Ada.Calendar; with Ada.Calendar.Formatting; use Ada.Calendar.Formatting; with Ada.Calendar.Time_Zones; use Ada.Calendar.Time_Zones; with Ada.Text_Io; use Ada.Text_Io;
procedure System_Time is
Now : Time := Clock;
begin
Put_line(Image(Date => Now, Time_Zone => -7*60));
end System_Time;</lang>
- Output:
2008-01-23 19:14:19
Aime
<lang aime>date d;
d_now(d);
o_form("~-/f2/-/f2/ /f2/:/f2/:/f2/\n", d_year(d), d_y_month(d), d_m_day(d),
d_d_hour(d), d_h_minute(d), d_m_second(d));</lang>
- Output:
2011-09-04 15:05:08
ALGOL 68
<lang algol68>FORMAT time repr = $"year="4d,", month="2d,", day="2d,", hours="2d,", \
minutes="2d,", seconds="2d,", day of week="d,", \ daylight-saving-time flag="dl$;
printf((time repr, local time));
printf((time repr, utc time))</lang>
- Output:
year=2009, month=03, day=12, hours=11, minutes=53, seconds=32, day of week=5, daylight-saving-time flag=0 year=2009, month=03, day=12, hours=01, minutes=53, seconds=32, day of week=5, daylight-saving-time flag=0
AppleScript
<lang AppleScript>display dialog (current date)</lang>
- Output:
Sunday, August 14, 2011 10:43:57 PM
AutoHotkey
<lang autohotkey>FormatTime, t MsgBox,% t</lang>
- Output:
4:18 PM Saturday, May 30, 2009
AutoIt
<lang autoit>MsgBox(0,"Time", "Year: "&@YEAR&",Day: " &@MDAY& ",Hours: "& @HOUR & ", Minutes: "& @MIN &", Seconds: "& @SEC)</lang>
- Output:
Year: 2011,Day: 05,Hour: 09, Minutes: 15, Seconds: 25
AWK
One-liner:
<lang awk>$ awk 'BEGIN{print systime(),strftime()}'</lang>
- Output:
1242401632 Fri May 15 17:33:52 2009
Solution for other awk-versions:
<lang awk> function dos_date( cmd,d,t,x) { # under MS Windows
- cmd = "DATE /T"
- cmd | getline d # Format depends on locale, e.g. MM/DD/YYYY or YYYY-MM-DD
- close(cmd) # close pipe
- ##print d
- cmd = "TIME /T"
- cmd | getline t # 13:59
- close(cmd)
- ##print t
- return d t
cmd = "echo %DATE% %TIME%" # this gives better time-resolution cmd | getline x # 2014-10-31 20:57:36.84 close(cmd) return x
} BEGIN {
print "Date and time:", dos_date() #print systime(), strftime() # gawk only
} </lang>
- Output:
2014-10-31 20:57:36.84
See also: System_time#Batch, Discordian_date
BaCon
<lang qbasic>' BaCon time n = NOW PRINT n, " seconds since January 1st, 1970" PRINT YEAR(n), MONTH(n), DAY(n) FORMAT "%04d/%02d/%02d " PRINT HOUR(n), MINUTE(n), SECOND(n) FORMAT "%02d:%02d:%02d\n"</lang>
- Output:
1503869183 seconds since January 1st, 1970 2017/08/27 17:26:23
BASIC
This shows the system time in seconds since midnight. <lang qbasic>PRINT TIMER</lang>
This shows the time in human-readable format (using a 24-hour clock): <lang qbasic>PRINT TIME$</lang>
Batch File
There is no way to get a computer-readable date or time representation in batch files. All output is human-readable and follows the current locale.
Both date and time have a /t argument which makes them output only the value instead of prompting for a new one as well.
<lang dos>date /t
time /t</lang>Furthermore there are two pseudo-variables %DATE% and %TIME%:
<lang dos>echo %DATE% %TIME%</lang>
BBC BASIC
<lang bbcbasic> PRINT TIME$</lang>Outputs the date and time. To output only the time:<lang bbcbasic> PRINT RIGHT$(TIME$,8)</lang>
C
This probably isn't the best way to do this, but it works. It shows system time as "Www Mmm dd hh:mm:ss yyyy", where Www is the weekday, Mmm the month in letters, dd the day of the month, hh:mm:ss the time, and yyyy the year.<lang c>#include<time.h>
- include<stdio.h>
- include<stdlib.h>
int main(){
time_t my_time = time(NULL); printf("%s", ctime(&my_time)); return 0;
}</lang>
C++
to be compiled under linux with g++ -lboost_date_time systemtime.cpp -o systemtime( or whatever you like) <lang cpp>#include <iostream>
- include <boost/date_time/posix_time/posix_time.hpp>
int main( ) {
boost::posix_time::ptime t ( boost::posix_time::second_clock::local_time( ) ) ; std::cout << to_simple_string( t ) << std::endl ; return 0 ;
}</lang>
C++ 11
<lang cpp>#include <chrono>
- include <ctime> //for conversion std::ctime()
- include <iostream>
int main() {
auto timenow = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now()); std::cout << std::ctime(&timenow) << std::endl;
}</lang>
- Output:
Thu Dec 26 13:51:00 2013
C#
<lang csharp>Console.WriteLine(DateTime.Now);</lang>
Clojure
<lang lisp>(import '[java.util Date])
- the current system date time string
(print (new Date))
- the system time as milliseconds since 1970
(print (. (new Date) getTime))
- or
(print (System/currentTimeMillis))</lang>
COBOL
<lang cobol> WORKING-STORAGE SECTION.
01 WS-CURRENT-DATE-FIELDS. 05 WS-CURRENT-DATE. 10 WS-CURRENT-YEAR PIC 9(4). 10 WS-CURRENT-MONTH PIC 9(2). 10 WS-CURRENT-DAY PIC 9(2). 05 WS-CURRENT-TIME. 10 WS-CURRENT-HOUR PIC 9(2). 10 WS-CURRENT-MINUTE PIC 9(2). 10 WS-CURRENT-SECOND PIC 9(2). 10 WS-CURRENT-MS PIC 9(2). 05 WS-DIFF-FROM-GMT PIC S9(4). PROCEDURE DIVISION. MOVE FUNCTION CURRENT-DATE TO WS-CURRENT-DATE-FIELDS.</lang>
ColdFusion
Script Based CFML
<lang cfm><cfscript>
// Date Time currentTime = Now(); writeOutput( currentTime );
// Epoch // Credit for Epoch time should go to Ben Nadel // bennadel.com is his blog utcDate = dateConvert( "local2utc", currentTime ); writeOutput( utcDate.getTime() );
</cfscript></lang>
- Output:
Current DateTime: {ts '2017-06-06 10:36:28'} Epoch: 1496763388434
Common Lisp
<lang lisp>(multiple-value-bind (second minute hour day month year) (get-decoded-time)
(format t "~4,'0D-~2,'0D-~2,'0D ~2,'0D:~2,'0D:~2,'0D" year month day hour minute second))</lang>
D
Clock.now.span in the example below returnes the time-span since 1 Jan 1 A.D. Days are used in the example, but lower units are available, with the lowest being nanoseconds (nanos field). <lang D>Stdout(Clock.now.span.days / 365).newline;</lang>
DCL
<lang DCL>$ start_time = f$time() $ wait 0::10 $ end_time = f$time() $ write sys$output "start time was ", start_time $ write sys$output "end time was ", end_time $ write sys$output "delta time is ", f$delta_time( start_time, end_time )</lang>
- Output:
$ @system_time start time was 4-JUN-2015 15:38:09.60 end time was 4-JUN-2015 15:38:19.60 delta time is 0 00:00:10.00
The alternative below doesn't facilitate the calculation of the delta time;
- Output:
$ show time 4-JUN-2015 15:33:33
Delphi
<lang Delphi>lblDateTime.Caption := FormatDateTime('dd mmmm yyyy hh:mm:ss', Now);</lang>This populates a label with the date
DWScript
<lang delphi>PrintLn(FormatDateTime('dd mmmm yyyy hh:mm:ss', Now));</lang>
E
<lang e>println(timer.now())</lang>
The value is the number of milliseconds since 1970.
Easyprog.online
<lang>days$ = sys "time" print sys "time:" & days$</lang>
Elena
ELENA 4.x : <lang elena>import extensions; import system'calendar;
public program() {
console.printLine(Date.Now);
}</lang>
- Output:
01.10.2017 18:02:43
Elixir
<lang elixir>:os.timestamp # => {MegaSecs, Secs, MicroSecs}
- erlang.time # => {Hour, Minute, Second}
- erlang.date # => {Year, Month, Day}
- erlang.localtime # => {{Year, Month, Day}, {Hour, Minute, Second}}
- erlang.universaltime # => {{Year, Month, Day}, {Hour, Minute, Second}}
- calendar.local_time # => {{Year, Month, Day}, {Hour, Minute, Second}}
- calendar.universal_time # => {{Year, Month, Day}, {Hour, Minute, Second}}</lang>
It is also guaranteed that subsequent calls to this BIF returns continuously increasing values. Hence, the return value from :erlang.now()
can be used to generate unique time-stamps, and if it is called in a tight loop on a fast machine the time of the node can become skewed.
<lang elixir>:random.seed(:erlang.now)</lang>
Emacs Lisp
<lang Lisp>(message "%s" (current-time-string)) => "Wed Oct 14 22:21:05 1987"</lang>
current-time
is the main programmatic interface, with various functions available to format or operate on the time values list it gives.
Erlang
By default, Erlang timestamps are turned in the {megasecs, secs, microsecs} format.<lang erlang>1> os:timestamp(). {1250,222584,635452}</lang> These can be changed with the calendar module:<lang erlang>2> calendar:now_to_datetime(os:timestamp()). {{2009,8,14},{4,3,24}} 3> calendar:now_to_universal_time(os:timestamp()). {{2009,8,14},{4,3,40}} 4> calendar:now_to_local_time(os:timestamp()). {{2009,8,14},{0,7,01}}</lang>Note that you will often encounter the function erlang:now/0 giving a time similar to the system time. However, erlang:now/0 may get delayed if the system time changes suddenly (i.e.: coming back from sleep mode). The delay is in place to make sure receive clauses that are millisecond-sensitive do not get false timeouts.
Excel
NOW() returns the date and time to the minute. Type in a cell :<lang Excel>=NOW()</lang>
- Output:
9-8-2013 17:33
F#
<lang fsharp>printfn "%s" (System.DateTime.Now.ToString("u"))</lang>
- Output:
2013-09-19 23:56:50Z
Factor
<lang factor>USE: calendar
now .</lang>
Falcon
<lang falcon> /* Added by Aykayayciti Earl Lamont Montgomery April 10th, 2018 */
> CurrentTime().toString() </lang>
- Output:
2018-04-10 09:40:35.798 [Finished in 0.2s]
Fantom
DateTime.now returns the current time, which can then be formatted into different styles. For example, toJava returns the current time in milliseconds since 1 Jan 1970.
DateTime.nowTicks returns the number of nanoseconds since 1 Jan 2000 UTC.<lang fantom>fansh> DateTime.nowTicks 351823905158000000 fansh> DateTime.now 2011-02-24T00:51:47.066Z London fansh> DateTime.now.toJava 1298508885979</lang>
Forth
Forth's only standard access to the system timers is via DATE&TIME ( -- s m h D M Y ) and MS ( n -- ) which pauses the program for at least n milliseconds. Particular Forth implementations give different access to millisecond and microsecond timers:
<lang forth>[UNDEFINED] MS@ [IF] \ Win32Forth (rolls over daily)
[DEFINED] ?MS [IF] ( -- ms ) : ms@ ?MS ; \ iForth [ELSE] [DEFINED] cputime [IF] ( -- Dusec ) : ms@ cputime d+ 1000 um/mod nip ; \ gforth: Anton Ertl [ELSE] [DEFINED] timer@ [IF] ( -- Dusec ) : ms@ timer@ >us 1000 um/mod nip ; \ bigForth [ELSE] [DEFINED] gettimeofday [IF] ( -- usec sec ) : ms@ gettimeofday 1000 MOD 1000 * SWAP 1000 / + ; \ PFE [ELSE] [DEFINED] counter [IF] : ms@ counter ; \ SwiftForth [ELSE] [DEFINED] GetTickCount [IF] : ms@ GetTickCount ; \ VFX Forth [ELSE] [DEFINED] MICROSECS [IF] : ms@ microsecs 1000 UM/MOD nip ; \ MacForth
[THEN] [THEN] [THEN] [THEN] [THEN] [THEN] [THEN]
MS@ . \ print millisecond counter</lang>
Fortran
In ISO Fortran 90 or later, use the SYSTEM_CLOCK intrinsic subroutine:<lang fortran>integer :: start, stop, rate real :: result
! optional 1st integer argument (COUNT) is current raw system clock counter value (not UNIX epoch millis!!) ! optional 2nd integer argument (COUNT_RATE) is clock cycles per second ! optional 3rd integer argument (COUNT_MAX) is maximum clock counter value call system_clock( start, rate )
result = do_timed_work()
call system_clock( stop )
print *, "elapsed time: ", real(stop - start) / real(rate)</lang>In ISO Fortran 95 or later, use the CPU_TIME intrinsic subroutine:<lang fortran>real :: start, stop real :: result
! System clock value interpreted as floating point seconds call cpu_time( start )
result = do_timed_work()
call cpu_time( stop )
print *, "elapsed time: ", stop - start</lang>
FreeBASIC
<lang freebasic>' FB 1.05.0 Win64
Print Date + " " + Time returns system date/time in format : mm-dd-yyyy hh:mm:ss Sleep</lang>
Gambas
Click this link to run this code <lang gambas>Public Sub Main()
Print Format(Now, "dddd dd mmmm yyyy hh:nn:ss")
End</lang> Output:
Thursday 08 June 2017 15:58:41
Go
<lang go>package main
import "time" import "fmt"
func main() {
t := time.Now() fmt.Println(t) // default format fmt.Println(t.Format("Mon Jan 2 15:04:05 2006")) // some custom format
}</lang>
Groovy
Solution (based on Java solution).<lang groovy>def nowMillis = new Date().time println 'Milliseconds since the start of the UNIX Epoch (Jan 1, 1970) == ' + nowMillis</lang>
- Output:
Milliseconds since the start of the UNIX Epoch (Jan 1, 1970) == 1243395159250
GUISS
We can only show the clock, but this might not be set to system time:<lang guiss>Taskbar</lang>
Haskell
<lang haskell>import System.Time
(getClockTime, toCalendarTime, formatCalendarTime)
import System.Locale (defaultTimeLocale)
main :: IO () main = do
ct <- getClockTime print ct -- print default format, or cal <- toCalendarTime ct putStrLn $ formatCalendarTime defaultTimeLocale "%a %b %e %H:%M:%S %Y" cal</lang>
or with the time library: <lang haskell>import Data.Time (getZonedTime, formatTime, defaultTimeLocale)
main :: IO () main = do
zt <- getZonedTime print zt -- print default format, or putStrLn $ formatTime defaultTimeLocale "%a %b %e %H:%M:%S %Y" zt</lang>
HicEst
<lang HicEst>seconds_since_midnight = TIME() ! msec as fraction
seconds_since_midnight = TIME(Year=yr, Day=day, WeekDay=wday, Gregorian=gday)
! other options e.g. Excel, YYYYMMDD (num or text)</lang>
HolyC
<lang holyc>CDateStruct ds; Date2Struct(&ds, Now + local_time_offset);
Print("%04d-%02d-%02d %02d:%02d:%02d\n", ds.year, ds.mon, ds.day_of_mon, ds.hour, ds.min, ds.sec); </lang>
Hoon
The time of the current system event is made available on the subject in most contexts as now.
<lang Hoon>now</lang>
- Output:
~2016.7.24..01.25.02..0f8e
Absolute times have 64-bit subsecond precision, which is used to ensure that no two system events have the same timestamp.
IDL
The systime() function returns system time either as a formatted string (if the argument is zero or absent) or as a double-precision (floating-point) number of seconds (with fractionals) since 1-Jan-1970 otherwise:
print,systime(0) Wed Feb 10 09:41:14 2010 print,systime(1) 1.2658237e+009
The default format can also be invoked for a different moment in time by passing a different number of elapsed seconds to the routine as a second argument:
print,systime(0,1e9) Sat Sep 08 17:46:40 2001
Otherwise, the system time can be retrieved in Julian dates:
print,systime(/julian),format='(F15.7)' 2455237.9090278
The local time zone is ignored if the utc flag is used:
print,systime() Wed Feb 10 09:50:15 2010 print,systime(/utc) Wed Feb 10 17:50:10 2010
Io
<lang io>Date now println</lang>
- Output:
2008-08-26 00:15:52 EDT
Icon and Unicon
<lang Unicon>procedure main()
write("&time - milliseconds of CPU time = ",&time) write("&clock - Time of day as hh:mm:ss (24-hour format) = ",&clock) write("&date - current date in yyyy/mm/dd format = ",&date) write("&dateline - timestamp with day of the week, date, and current time to the minute = ",&dateline)
if find("Unicon",&version) then write("&now - time in seconds since the epoch = ", &now) # Unicon only
end</lang>
- Output:
&time - milliseconds of CPU time = 0
&clock - Time of day as hh:mm:ss (24-hour format) = 15:56:14 &date - current date in yyyy/mm/dd format = 2011/06/06 &dateline - timestamp with day of the week, date, and current time to the minute = Monday, June 6, 2011 3:56 pm &now - time in seconds since the epoch = 1307400974
IS-BASIC
<lang IS-BASIC>100 PRINT TIME$</lang>
J
The external verb 6!:0
returns a six-element floating-point array in which the elements correspond to year, month, day, hour, minute, and second. Fractional portion of second is given to thousandths.<lang j> 6!:0
2008 1 23 12 52 10.341</lang>
A formatted string representation of the current time can also be returned:<lang j> 6!:0 'YYYY-MM-DD hh:mm:ss.sss' 2009-08-26 10:38:53.171</lang>
Java
<lang java>public class SystemTime{
public static void main(String[] args){ System.out.format("%tc%n", System.currentTimeMillis()); }
}</lang>
- Output:
Mon Jun 21 13:02:19 BST 2010
Or using a Date
object:<lang java>import java.util.Date;
public class SystemTime{
public static void main(String[] args){ Date now = new Date(); System.out.println(now); // string representation
System.out.println(now.getTime()); // Unix time (# of milliseconds since Jan 1 1970) //System.currentTimeMillis() returns the same value }
}</lang>
Alternately, you can use a Calendar object, which allows you to retrieve specific fields of the date.
JavaScript
<lang javascript>console.log(new Date()) // => Sat, 28 May 2011 08:22:53 GMT console.log(Date.now()) // => 1306571005417 // Unix epoch</lang>
jq
<lang sh>$ jq -n 'now | [., todate]' [
1437619000.970498, "2015-07-23T02:36:40Z"
]</lang>
"now" reports the number of seconds since the beginning of the Unix epoch.
Jsish
Jsish does not implement the standard ECMAScript Date module but provides strftime and strptime.
<lang javascript>console.log(strftime());</lang>
- Output:
using interactive echo of results
prompt$ jsish # strftime(); "2019-02-20 19:43:20"
Julia
<lang Julia> ts = time()
println("The system time is (in ISO 8601 format):") println(strftime(" %F %T %Z", ts)) </lang>
- Output:
The system time is (in ISO 8601 format): 2015-04-08 14:19:38 CDT
Kotlin
<lang scala>// version 1.0.6
fun main(args: Array<String>) {
println("%tc".format(System.currentTimeMillis()))
} </lang>
Lasso
<lang Lasso>date->format('%Q %T')
date->asInteger</lang>
- Output:
2013-11-02 11:47:27 1383407747
LFE
By default, LFE timestamps are turned in the #(megasecs secs microsecs)
format.
<lang lisp> > (os:timestamp)
- (1423 786308 145798)
</lang>
These can be changed to the more common date/time stamp with the calendar
module:
<lang lisp> > (calendar:now_to_datetime (os:timestamp))
- (#(2015 2 13) #(0 12 18))
</lang>
Locale taken into account:
<lang lisp> > (calendar:now_to_universal_time (os:timestamp))
- (#(2015 2 13) #(0 13 51))
> (calendar:now_to_local_time (os:timestamp))
- (#(2015 2 12) #(16 14 26))
</lang>
Note that you will often encounter the function erlang:now/0
giving a time similar to the system time. However, erlang:now/0
may get delayed if the system time changes suddenly (i.e.: coming back from sleep mode). The delay is in place to ensure that receive
clauses which are millisecond-sensitive do not get false timeouts.
Liberty BASIC
<lang lb>print time$() 'time now as string "16:21:44" print time$("seconds") 'seconds since midnight as number 32314 print time$("milliseconds") 'milliseconds since midnight as number 33221342 print time$("ms") 'milliseconds since midnight as number 33221342</lang>
Lingo
<lang lingo>put time() -- "03:45"
put date() -- "01.10.2016"
put the systemdate -- date( 2016, 10, 1 )
put the systemdate.seconds -- 13950
-- milliseconds since last boot, due to higher resolution better suited for random number seeding put _system.milliseconds -- 41746442</lang>
LiveCode
<lang LiveCode>put the system time</lang>
Locomotive Basic
The variable "time" contains the time elapsed since last system start or reset. Each unit equals 1/300 s.<lang locobasic>print time print time/300;"s since last reboot"</lang>
Logo
Other Logo variants might have a built-in command, but UCB Logo must access the Unix shell to get time.<lang logo> to time
output first first shell [date +%s]
end
make "start time wait 300 ; 60ths of a second print time - :start ; 5</lang>
Lua
<lang lua>print(os.date())</lang>
M2000 Interpreter
<lang M2000 Interpreter> print str$(now,"long time"), time$(now) </lang>
Mathematica
Different ways of doing this, here are 2 most common:<lang Mathematica>Print[DateList[]] Print[AbsoluteTime[]]</lang>DateList will return the list {year,month,day,hour,minute,second} where all of them are integers except for second; that is a float. AbsoluteTime gives the total number of seconds since january 1st 1900 in your time zone.
MATLAB / Octave
<lang MATLAB> datestr(now)</lang>
ans = 13-Aug-2010 12:59:56
<lang MATLAB> clock</lang>
ans = 2010 8 13 12 59 56.52
Maxima
<lang maxima>/* Time and date in a formatted string */ timedate(); "2012-08-27 20:26:23+10:00"
/* Time in seconds elapsed since 1900/1/1 0:0:0 */ absolute_real_time();
/* Time in seconds since Maxima was started */ elapsed_real_time(); elapsed_run_time();</lang>
Modula-2
<lang modula2> MODULE Mytime;
FROM SysClock IMPORT
GetClock, DateTime;
FROM STextIO IMPORT
WriteString, WriteLn;
FROM FormatDT IMPORT
DateTimeToString;
VAR
CurrentTime: DateTime; DateStr, TimeStr: ARRAY [0 .. 20] OF CHAR;
BEGIN
GetClock(CurrentTime); DateTimeToString(CurrentTime, DateStr, TimeStr); WriteString("Current time: "); WriteString(DateStr); WriteString(" "); WriteString(TimeStr); WriteLn;
END Mytime. </lang>
Modula-3
<lang modula3>MODULE MyTime EXPORTS Main;
IMPORT IO, FmtTime, Time;
BEGIN
IO.Put("Current time: " & FmtTime.Long(Time.Now()) & "\n");
END MyTime.</lang>
- Output:
Current time: Tue Dec 30 20:50:07 CST 2008
MUMPS
System time since midnight (in seconds) is kept in the second part of the system variable $HOROLOG.<lang MUMPS>SYSTIME
NEW PH SET PH=$PIECE($HOROLOG,",",2) WRITE "The system time is ",PH\3600,":",PH\60#60,":",PH#60 KILL PH
QUIT</lang>Usage:
USER>D SYSTIME^ROSETTA The system time is 22:55:44
Neko
<lang ActionScript>/**
<doc>
System time
Neko uses Int32 to store system date/time values. And lib C strftime style formatting for converting to string form
</doc>
- /
var date_now = $loader.loadprim("std@date_now", 0) var date_format = $loader.loadprim("std@date_format", 2)
var now = date_now() $print(now, " ", date_format(now, "%T"), "\n")</lang>
- Output:
prompt$ nekoc system-time.neko prompt$ neko system-time.n 1542158592 20:23:12
Nemerle
<lang Nemerle>System.Console.Write(System.DateTime.Now);</lang>
NetRexx
<lang netrexx> import java.text.SimpleDateFormat say SimpleDateFormat("yyyy-MM-dd-HH.mm.ss.SSS").format(Date())</lang>
NewLISP
<lang NewLISP>> (date) "Sun Sep 28 20:17:55 2014"</lang>
Nim
<lang nim>import times
echo(getDateStr()) echo(getClockStr())
echo(getTime())</lang>
- Output:
2013-08-02 07:34:25 Fri Aug 2 07:34:25 2013
Objective-C
<lang objc>NSLog(@"%@", [NSDate date]);</lang>or (deprecated)<lang objc>NSLog(@"%@", [NSCalendarDate calendarDate]);</lang>
Objeck
<lang objeck>function : Time() ~ Nil {
t := Time->New(); IO.Console->GetInstance()->Print(t->GetHours())->Print(":")->Print(t->GetMinutes())->Print(":")->PrintLine(t->GetSeconds());
}</lang>
OCaml
<lang ocaml>#load "unix.cma";; open Unix;; let {tm_sec = sec;
tm_min = min; tm_hour = hour; tm_mday = mday; tm_mon = mon; tm_year = year; tm_wday = wday; tm_yday = yday; tm_isdst = isdst} = localtime (time ());;
Printf.printf "%04d-%02d-%02d %02d:%02d:%02d\n" (year + 1900) (mon + 1) mday hour min sec;</lang>
Oforth
System.tick is used to retrieve a tick from the system in order to compute small intervals of time. It is used by #bench method to compute duration of a runnable (unit is micro second).
<lang Oforth>System.tick println
- [ #sqrt 1000000 seq map sum println ] bench</lang>
- Output:
707095319487 666667166.458841 259819
System.localTime returns number of micro seconds since 01/01/1970:00:00:00 Integer returned by System.localTime allows to create a Date object.
<lang Oforth>import: date
System.localTime dup println asDate println drop drop</lang>
- Output:
1421095428478000 2015-01-12 21:43:48,478
Oz
<lang oz>{Show {OS.time}} %% posix time (seconds since 1970-01-01) {Show {OS.gmTime}} %% current UTC as a record {Show {OS.localTime}} %% current local time as record
%% Also interesting: undocumented module OsTime %% When did posix time reach 1 billion? {Show {OsTime.gmtime 1000000000}}
{Show {OsTime.localtime 1000000000}}</lang>
- Output:
1263347902 time(hour:1 isDst:0 mDay:13 min:58 mon:0 sec:22 wDay:3 yDay:12 year:110) time(hour:2 isDst:0 mDay:13 min:58 mon:0 sec:22 wDay:3 yDay:12 year:110) time(hour:1 isDst:0 mDay:9 min:46 mon:8 sec:40 wDay:0 yDay:251 year:101) time(hour:3 isDst:1 mDay:9 min:46 mon:8 sec:40 wDay:0 yDay:251 year:101)
PARI/GP
For timing the gettime
is usually used, which measures CPU time rather than walltime. But to get the raw time you'll need a system call
<lang parigp>system("date")</lang>
Direct access to the C library time()
function can be had by an install()
, and it should be faster than running the date program.
<lang parigp>install(time, "lf"); t = time(); print(t); \\ integer seconds since the epoch (usually 1 Jan 1970)</lang>
install()
can't give the higher resolution C library time functions like gettimeofday()
or clock_gettime()
but some further C code could put their results into a Pari integer or rational suitable for install()
in GP.
Pascal
<lang Pascal>program systime; uses DOS;
{ Format digit with leading zero } function lz(w: word): string; var
s: string;
begin
str(w,s); if length(s) = 1 then s := '0' + s; lz := s;
end;
var
h,m,s,c: word; yr,mo,da,dw: word; dt: datetime; t,ssm: longint; regs: registers;
begin
{ Time and Date } GetTime(h,m,s,c); writeln(lz(h),':',lz(m),':',lz(s),'.',c); GetDate(yr,mo,da,dw); writeln(yr,'-',lz(mo),'-',lz(da));
{ Turbo Epoch, seconds } with dt do begin year := yr; month := mo; day := da; hour := h; min := m; sec := s; end; packtime(dt,t); writeln(t);
{ Seconds since midnight, PC-BIOS 1Ah } regs.ah := 0; Intr($1A,regs); ssm := round((regs.cx * 65536 + regs.dx) * (65536 / 1192180)); writeln(ssm);
end.</lang>
- Output:
23:42:35.9 2010-07-29 1023262033 85427
Perl
Simple localtime use in scalar context.<lang perl>print scalar localtime, "\n";</lang>
- Output:
Thu Jan 24 11:23:30 2008
localtime use in array context.<lang perl>($sec, $min, $hour, $mday, $mon, $year, $wday, $yday, $isdst) = localtime; printf("%04d-%02d-%02d %02d:%02d:%02d\n", $year + 1900, $mon + 1, $mday, $hour, $min, $sec</lang>
- Output:
2008-01-24 11:23:30
The same using DateTime:<lang perl>use DateTime; my $dt = DateTime->now; my $d = $dt->ymd; my $t = $dt->hms;
print "$d $t\n";</lang>
- Output:
2010-03-29 19:46:26
localtime use in array context with POSIX strftime:<lang perl>use POSIX qw(strftime);
$now_string = strftime "%a %b %e %H:%M:%S %Y", localtime; print "$now_string\n";</lang>Output (with cs_CZ.UTF-8 locale):
Čt led 24 11:23:30 2008
Using the DateTime module:<lang perl>use DateTime;
my $dt = DateTime->now; say $dt->iso8601(); say $dt->year_with_christian_era(); say $dt->year_with_secular_era();
- etc.</lang>Unix epoch:<lang perl>print time;</lang>
- Output:
1280473609
Perl 6
<lang perl6>say DateTime.now; dd DateTime.now.Instant;</lang>
- Output:
2015-11-02T13:34:09+01:00 Instant $var = Instant.new(<2159577143734/1493>)
Phix
<lang Phix>include timedate.e ?format_timedate(date(),"Dddd, Mmmm dth, YYYY, h:mm:ss pm")
atom t0 = time() sleep(0.9) ?time()-t0</lang>
- Output:
"Tuesday, July 12th, 2016, 11:30:07 am" 0.906
Note the system clock tick rate mean times can be out by ~0.0155s; it is not unusual to see total elapsed times of 0,0,0,0.016,0.016,0.016,0.031,0.031,0.031, etc.
PHP
Seconds since the Unix epoch:<lang php>echo time(), "\n";</lang>
Microseconds since the Unix epoch:<lang php>echo microtime(), "\n";</lang>Formatted time:<lang php>echo date('D M j H:i:s Y'), "\n"; // custom format; see format characters here:
// http://us3.php.net/manual/en/function.date.php
echo date('c'), "\n"; // ISO 8601 format echo date('r'), "\n"; // RFC 2822 format echo date(DATE_RSS), "\n"; // can also use one of the predefined formats here:
// http://us3.php.net/manual/en/class.datetime.php#datetime.constants.types</lang>
PicoLisp
<lang PicoLisp>(stamp)</lang>
- Output:
-> "2010-02-19 15:14:06
PL/I
<lang PL/I>put (datetime()); /* writes out the date and time */
/* The time is given to thousandths of a second, */ /* in the format hhmiss999 */
put (time()); /* gives the time in the format hhmiss999. */</lang>
PowerShell
Using a cmdlet:<lang powershell>Get-Date</lang>or using .NET classes and properties:<lang powershell>[DateTime]::Now</lang>
PureBasic
<lang PureBasic>time=Date() ; Unix timestamp time$=FormatDate("%mm.%dd.%yyyy %hh:%ii:%ss",time)
- following value is only reasonable accurate, on Windows it can differ by +/- 20 ms
ms_counter=ElapsedMilliseconds()
- could use API like QueryPerformanceCounter_() on Windows for more accurate values</lang>
Python
<lang python>import time print time.ctime()</lang>
Q
Date & time are accessible via the virtual .z namespace. lowercase names are UTC, uppercase are local:<lang q>q).z.D 2010.01.25 q).z.N 0D14:17:45.519682000 q).z.P 2010.01.25D14:17:46.962375000 q).z.T 14:17:47.817 q).z.Z 2010.01.25T14:17:48.711 q).z.z 2010.01.25T19:17:59.445</lang>
R
Note that this is output as a standard style string.<lang R>Sys.time()</lang>
- Output:
[1] "2009-07-27 15:27:04 PDT"
Racket
The system time as a date string: <lang racket>#lang racket (require racket/date) (date->string (current-date))</lang>
Or, as seconds after midnight UTC, January 1, 1970:<lang racket>#lang racket (current-seconds)</lang>
Raven
Note the use of single quotation marks for the date specifier.<lang>time dup print "\n" print int '%a %b %e %H:%M:%S %Y' date</lang>
- Output:
1353352623.511231 Tue Nov 20 05:17:03 2012
REBOL
<lang REBOL>now
print rejoin [now/year "-" now/month "-" now/day " " now/time]</lang>
- Output:
10-Dec-2009/7:43:55-5:00 2009-12-10 7:43:55
Retro
Displays the number of seconds since the Unix epoch: <lang Retro>time putn</lang>
REXX
Note that REXX only examines the first character of the option and can be in upper or lower case. <lang rexx>/*REXX program shows various ways to display the system time, including other options. */
say '════════════ Normal format of time' say 'hh:mm:ss ◄─────────────── hh= is 00 ──► 23' say 'hh:mm:ss ◄─────────────── hh= hour mm= minute ss= second' say time() say time('n') /* (same as the previous example.) */ say time('N') /* " " " " " */ say time('Normal') /* " " " " " */ say time('nitPick') /* " " " " " */
say say '════════════ Civil format of time' say 'hh:mmcc ◄─────────────── hh= is 1 ──► 12' say 'hh:mmam ◄─────────────── hh= hour mm= minute am= ante meridiem' say 'hh:mmpm ◄─────────────── pm= post meridiem' say time('C') say time('civil') /* (same as the previous example.) */
/*ante meridiem≡Latin for before midday*/ /*post " " " after " */
say say '════════════ long format of time' say 'hh:mm:ss ◄─────────────── hh= is 0 ──► 23' say 'hh:mm:ss.ffffff ◄─────────────── hh= hour mm= minute fffff= fractional seconds' say time('L') say time('long') /* (same as the previous example.) */ say time('long time no see') /* " " " " " */
say say '════════════ complete hours since midnight' say 'hh ◄─────────────── hh = 0 ───► 23' say time('H') say time('hours') /* (same as the previous example.) */
say say '════════════ complete minutes since midnight' say 'mmmm ◄─────────────── mmmm = 0 ───► 1439' say time('M') say time('minutes') /* (same as the previous example.) */
say say '════════════ complete seconds since midnight' say 'sssss ◄─────────────── sssss = 0 ───► 86399' say time('S') say time('seconds') /* (same as the previous example.) */
/*stick a fork in it, we're all done. */</lang>
- output:
════════════ Normal format of time hh:mm:ss ◄─────────────── hh= is 00 ──► 23 hh:mm:ss ◄─────────────── hh= hour mm= minute ss= second 19:59:40 19:59:40 19:59:40 19:59:40 19:59:40 ════════════ Civil format of time hh:mmcc ◄─────────────── hh= is 1 ──► 12 hh:mmam ◄─────────────── hh= hour mm= minute am= ante meridiem hh:mmpm ◄─────────────── pm= post meridiem 7:59pm 7:59pm ════════════ long format of time hh:mm:ss ◄─────────────── hh= is 0 ──► 23 hh:mm:ss.ffffff ◄─────────────── hh= hour mm= minute fffff= fractional seconds 19:59:40.250000 19:59:40.250000 19:59:40.250000 ════════════ complete hours since midnight hh ◄─────────────── hh = 0 ───► 23 19 19 ════════════ complete minutes since midnight mmmm ◄─────────────── mmmm = 0 ───► 1439 1199 1199 ════════════ complete seconds since midnight sssss ◄─────────────── sssss = 0 ───► 86399 71980 71980
Ring
<lang ring> /* Output:
- Sun abbreviated weekday name
- Sunday full weekday name
- May abbreviated month name
- May full month name
- 05/24/15 09:58:38 Date & Time
- 24 Day of the month
- 09 Hour (24)
- 09 Hour (12)
- 144 Day of the year
- 05 Month of the year
- 58 Minutes after hour
- AM AM or PM
- 38 Seconds after the hour
- 21 Week of the year (sun-sat)
- 0 day of the week
- 05/24/15 date
- 09:58:38 time
- 15 year of the century
- 2015 year
- Arab Standard Time time zone
- % percent sign
- /
See TimeList() </lang>
Ruby
version 1.9+<lang ruby>t = Time.now
- textual
puts t # => 2013-12-27 18:00:23 +0900
- epoch time
puts t.to_i # => 1388134823
- epoch time with fractional seconds
puts t.to_f # => 1388134823.9801579
- epoch time as a rational (more precision):
puts Time.now.to_r # 1424900671883862959/1000000000 </lang>
Scala
Ad hoc solution as REPL scripts:
JDK < 8
<lang scala>println(new java.util.Date)</lang>
- Output:
Sun Aug 14 22:47:42 EDT 2011
JDK >= 8 (recommended)
<lang scala>println(java.time.LocalTime.now())</lang>
- Output:
11:32:39.002
Scheme
<lang scheme>(use posix) (seconds->string (current-seconds))</lang>
- Output:
"Sat May 16 21:42:47 2009"
Seed7
<lang seed7>$ include "seed7_05.s7i";
include "time.s7i";
const proc: main is func
begin writeln(time(NOW));
end func;</lang>
- Output:
2009-12-07 17:09:44.687500 UTC+1
SETL
<lang setl>$ Unix time print(tod);
$ Human readable time and date print(date);</lang>
- Output:
<lang setl> 1447628158908 Sun Nov 15 22:55:58 2015 </lang>
Sidef
<lang ruby># textual say Time.local.ctime; # => Thu Mar 19 15:10:41 2015
- epoch time
say Time.sec; # => 1426770641
- epoch time with fractional seconds
say Time.micro_sec; # => 1426770641.68409</lang>
Smalltalk
<lang smalltalk>DateTime now displayNl.</lang>
- Output:
2011-08-10T00:43:36-0-7:00
<lang smalltalk>DateAndTime now</lang>
- Output:
2011-08-16T19:40:37-03:00
SNOBOL4
<lang SNOBOL4> OUTPUT = DATE()
END</lang>
- Output:
03/30/2010 20:58:09
SPL
<lang spl>hour,min,sec = #.now() day,month,year = #.today()
- .output(#.str(hour,"00:"),#.str(min,"00:"),#.str(sec,"00.000"))
- .output(day,".",#.str(month,"00"),".",year)</lang>
- Output:
03:15:34.068 24.08.2017
Swift
<lang Swift>import Foundation
var ⌚️ = NSDate()
println(⌚️)</lang>
- Output:
2014-06-22 20:43:42 +0000
Standard ML
<lang sml>print (Date.toString (Date.fromTimeLocal (Time.now ())) ^ "\n")</lang>
SQL PL
<lang sql pl> SELECT CURRENT DATE, CURRENT TIME, CURRENT TIMESTAMP FROM SYSIBM.SYSDUMMY1; </lang> Output:
db2 -t db2 => SELECT CURRENT DATE, CURRENT TIME, CURRENT TIMESTAMP FROM SYSIBM.SYSDUMMY1; 1 2 3 ---------- -------- -------------------------- 04/29/2018 14:27:10 2018-04-29-14.27.10.674182 1 record(s) selected.
Stata
<lang stata>di c(current_date) di c(current_time)</lang>
Tcl
This uses a timestamp that is a number of seconds since the start of the UNIX Epoch.<lang tcl>puts [clock seconds]</lang> More readable forms may be created by formatting the time:<lang tcl>puts [clock format [clock seconds]]</lang>
TI-89 BASIC
<lang ti89b>■ getTime() {13 28 55} ■ getDate() {2009 8 13}</lang>Note that the system clock can be turned off, in which case the value returned will remain constant. isClkOn() can be used to check it.
TUSCRIPT
<lang tuscript> $$ MODE TUSCRIPT time=time()
PRINT time</lang>
- Output:
2011-04-05 13:45:44
UNIX Shell
<lang bash>date # Thu Dec 3 15:38:06 PST 2009
date +%s # 1259883518, seconds since the epoch, like C stdlib time(0)</lang>
Ursa
<lang ursa># outputs time in milliseconds import "time" out (time.getcurrent) endl console</lang>
Ursala
A library function, now, ignores its argument and returns the system time as a character string.<lang Ursala>#import cli
- cast %s
main = now 0</lang>
- Output:
'Fri, 26 Jun 2009 20:31:49 +0100'
This string can be converted to seconds since 1970 (ignoring leap seconds) by the library function string_to_time.
Vala
<lang vala> var now = new DateTime.now_local();
string now_string = now.to_string();</lang>
- Output:
2011-11-12T20:23:24-0800
VBA
<lang VB>Debug.Print Now()</lang>
- Output:
12/12/2013 16:16:16
VBScript
<lang vb>WScript.Echo Now</lang>
XPL0
The intrinsics GetReg and SoftInt are used to access DOS and BIOS routines. GetReg returns the address of an array where a copy of the processor's hardware registers are stored. Values (such as $2C00 in the example) can be stored into this array. When SoftInt is called, the values in the array are loaded into the processor's registers and the specified interrupt ($21 in the example) is called.<lang XPL0>include c:\cxpl\codes; \include intrinsic 'code' declarations
proc NumOut(N); \Output a 2-digit number, including leading zero int N; [if N <= 9 then ChOut(0, ^0); IntOut(0, N); ]; \NumOut
int Reg; [Reg:= GetReg; \get address of array with copy of CPU registers Reg(0):= $2C00; \call DOS function 2C (hex) SoftInt($21); \DOS calls are interrupt 21 (hex) NumOut(Reg(2) >> 8); \the high byte of register CX contains the hours ChOut(0, ^:); NumOut(Reg(2) & $00FF); \the low byte of CX contains the minutes ChOut(0, ^:); NumOut(Reg(3) >> 8); \the high byte of DX contains the seconds ChOut(0, ^.); NumOut(Reg(3) & $00FF); \the low byte of DX contains hundreths CrLf(0);
]</lang>
- Output:
13:08:26.60
Yabasic
<lang Yabasic>print time$</lang>
zkl
<lang zkl>Time.Clock.time //-->seconds since the epoch (C/OS defined)</lang>
- Programming Tasks
- Programming environment operations
- Date and time
- Simple
- ML/I/Omit
- ZX Spectrum Basic/Omit
- ABAP
- Ada
- Aime
- ALGOL 68
- AppleScript
- AutoHotkey
- AutoIt
- AWK
- BaCon
- BASIC
- Batch File
- BBC BASIC
- C
- C++
- C sharp
- Clojure
- COBOL
- ColdFusion
- Common Lisp
- D
- DCL
- Delphi
- DWScript
- E
- Easyprog.online
- Elena
- Elixir
- Emacs Lisp
- Erlang
- Excel
- F Sharp
- Factor
- Falcon
- Fantom
- Forth
- Fortran
- FreeBASIC
- Gambas
- Go
- Groovy
- GUISS
- Haskell
- HicEst
- HolyC
- Hoon
- IDL
- Io
- Icon
- Unicon
- IS-BASIC
- J
- Java
- JavaScript
- Jq
- Jsish
- Julia
- Kotlin
- Lasso
- LFE
- Liberty BASIC
- Lingo
- LiveCode
- Locomotive Basic
- Logo
- Lua
- M2000 Interpreter
- Mathematica
- MATLAB
- Octave
- Maxima
- Modula-2
- Modula-3
- MUMPS
- Neko
- Nemerle
- NetRexx
- NewLISP
- Nim
- Objective-C
- Objeck
- OCaml
- Oforth
- Oz
- PARI/GP
- Pascal
- Perl
- Perl 6
- Phix
- PHP
- PicoLisp
- PL/I
- PowerShell
- PureBasic
- Python
- Q
- R
- Racket
- Raven
- REBOL
- Retro
- REXX
- Ring
- Ruby
- Scala
- Scheme
- Seed7
- SETL
- Sidef
- Smalltalk
- SNOBOL4
- SPL
- Swift
- Standard ML
- SQL PL
- Stata
- Tcl
- TI-89 BASIC
- TUSCRIPT
- UNIX Shell
- Ursa
- Ursala
- Vala
- VBA
- VBScript
- XPL0
- Yabasic
- Zkl
- Axe/Omit