⚠️ Warning: This is a draft ⚠️

This means it might contain formatting issues, incorrect code, conceptual problems, or other severe issues.

If you want to help to improve and eventually enable this page, please fork RosettaGit's repository and open a merge request on GitHub.

{{task|Programming environment operations}} [[Category:Date and time]] [[Category:Simple]]

{{omit from|ML/I}} {{omit from|ZX Spectrum Basic|Does not have a real time clock.}}

;Task: Output the system '''time''' (any units will do as long as they are noted) either by a [[Execute a System Command|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:

  • [[Date format]]

;See also:

  • [[wp:System time#Retrieving system time|Retrieving system time (wiki)]]


REPORT system_time.

WRITE: sy-uzeit.


The following example displays a date-time stamp. The time zone value is the number of minutes offset from the prime meridian.

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;
   Put_line(Image(Date => Now, Time_Zone => -7*60));
end System_Time;

{{out}} 2008-01-23 19:14:19


date 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));

{{out}} 2011-09-04 15:05:08


{{works with|ALGOL 68G|Any - tested with release mk15-0.8b.fc9.i386}}

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

{{out}} 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


display dialog (current date)


 Sunday, August 14, 2011 10:43:57 PM


FormatTime, t
MsgBox,% t


 4:18 PM Saturday, May 30, 2009


MsgBox(0,"Time", "Year: "&@YEAR&",Day: " &@MDAY& ",Hours: "& @HOUR & ", Minutes: "& @MIN &", Seconds: "& @SEC)


 Year: 2011,Day: 05,Hour: 09, Minutes: 15, Seconds: 25


'''One-liner:''' {{works with|Gawk}}

$ awk 'BEGIN{print systime(),strftime()}'


1242401632 Fri May 15 17:33:52  2009

'''Solution for other awk-versions:''' {{works with|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
    return x
   print "Date and time:", dos_date()
  #print systime(), strftime()		# gawk only


2014-10-31 20:57:36.84

See also: [[System_time#Batch]], [http://rosettacode.org/wiki/Discordian_date#AWK Discordian_date]


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


1503869183 seconds since January 1st, 1970
2017/08/27 17:26:23


{{works with|QBasic}}

This shows the system time in seconds since midnight.

This shows the time in human-readable format (using a 24-hour clock):


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. {{works with|Windows NT}}

date /t
time /t

Furthermore there are two pseudo-variables %DATE% and %TIME%: {{works with|Windows NT|4}}

echo %DATE% %TIME%



Outputs the date and time. To output only the time:



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.

#include <time.h>
#include <stdio.h>
#include <stdlib.h>

int main(){
  time_t my_time = time(NULL);
  printf("%s", ctime(&my_time));
  return 0;


to be compiled under linux with g++ -lboost_date_time systemtime.cpp -o systemtime( or whatever you like)

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

C++ 11

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


 Thu Dec 26 13:51:00 2013




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


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



Script Based CFML

  // 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() );


Current DateTime: {ts '2017-06-06 10:36:28'}
Epoch: 1496763388434

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


{{works with|Tango}}

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

Stdout(Clock.now.span.days / 365).newline;


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


$ @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; {{out}}

$ show time
   4-JUN-2015 15:33:33


lblDateTime.Caption := FormatDateTime('dd mmmm yyyy hh:mm:ss', Now);

This populates a label with the date


PrintLn(FormatDateTime('dd mmmm yyyy hh:mm:ss', Now));



The value is the number of milliseconds since 1970.


secs$ = sys "time" print sys "time:" & secs$

## Elena

ELENA 4.x :

import extensions;
import system'calendar;

public program()


01.10.2017 18:02:43


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

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.


Emacs Lisp

(message "%s" (current-time-string))
"Wed Oct 14 22:21:05 1987"

current-time is the main programmatic interface, with various functions available to format or operate on the time values list it gives.


By default, Erlang timestamps are turned in the {megasecs, secs, microsecs} format.


These can be changed with the calendar module:

3> calendar:now_to_universal_time(os:timestamp()).
4> calendar:now_to_local_time(os:timestamp()).

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.


NOW() returns the date and time to the minute. Type in a cell :



9-8-2013 17:33


printfn "%s" (System.DateTime.Now.ToString("u"))


 2013-09-19 23:56:50Z


USE: calendar

now .


/* Added by Aykayayciti Earl Lamont Montgomery
April 10th, 2018 */

> CurrentTime().toString()


2018-04-10 09:40:35.798
[Finished in 0.2s]


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.

fansh> DateTime.now
2011-02-24T00:51:47.066Z London
fansh> DateTime.now.toJava


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:

{{works with|Win32Forth}} {{works with|GNU Forth}} {{works with|bigFORTH}} {{works with|iForth}} {{works with|PFE}} {{works with|SwiftForth}} {{works with|VFX Forth}} {{works with|MacForth}}

[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
   : ms@  microsecs 1000 UM/MOD nip ;                  \  MacForth

MS@ .   \ print millisecond counter


In ISO Fortran 90 or later, use the SYSTEM_CLOCK intrinsic subroutine:

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)

In ISO Fortran 95 or later, use the CPU_TIME intrinsic subroutine:

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


' FB 1.05.0 Win64

Print Date + " " + Time  '' returns system date/time in format : mm-dd-yyyy hh:mm:ss


'''[https://gambas-playground.proko.eu/?gist=f061cc0cf175496b37bbcd14bd1e7058 Click this link to run this code]'''

Public Sub Main()

Print Format(Now, "dddd dd mmmm yyyy hh:nn:ss")



Thursday 08 June 2017 15:58:41



    var now = new DateTime.now_local()
    print now.to_string()


prompt$ valac systemTime.gs
prompt$ ./systemTime


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


Solution (based on [[#Java|Java]] solution).

def nowMillis = new Date().time
println 'Milliseconds since the start of the UNIX Epoch (Jan 1, 1970) == ' + nowMillis

{{out}} Milliseconds since the start of the UNIX Epoch (Jan 1, 1970) == 1243395159250


We can only show the clock, but this might not be set to system time:

## 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

or with the time library:

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


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)


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


The time of the current system event is made available on the subject in most contexts as now.


Absolute times have 64-bit subsecond precision, which is used to ensure that no two system events have the same timestamp.

## IDL

The <tt>systime()</tt> 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:

     Wed Feb 10 09:41:14 2010

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:

     Sat Sep 08 17:46:40 2001

Otherwise, the system time can be retrieved in Julian dates:


The local time zone is ignored if the <tt>utc</tt> flag is used:

     Wed Feb 10 09:50:15 2010
     Wed Feb 10 17:50:10 2010

## Io

```io>Date now println</lang
 2008-08-26 00:15:52 EDT

=={{header|Icon}} and {{header|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


{{out}} &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

=={{header|IS-BASIC}}== 100 PRINT TIME$

## J

The external verb <code>6!:0</code> 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.
   6!:0 ''
2008 1 23 12 52 10.341

A formatted string representation of the current time can also be returned:

   6!:0 'YYYY-MM-DD hh:mm:ss.sss'
2009-08-26 10:38:53.171


{{works with|Java|1.5+}}

public class SystemTime{
    public static void main(String[] args){
        System.out.format("%tc%n", System.currentTimeMillis());

{{out}} Mon Jun 21 13:02:19 BST 2010 Or using a Date object:

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

Alternately, you can use a Calendar object, which allows you to retrieve specific fields of the date.


console.log(new Date()) // => Sat, 28 May 2011 08:22:53 GMT
console.log(Date.now()) // => 1306571005417 // Unix epoch


{{works with|jq |1.5}}

$ jq -n 'now | [., todate]'

"now" reports the number of seconds since the beginning of the [https://en.wikipedia.org/wiki/Unix_epoch Unix epoch].


Jsish does not implement the standard ECMAScript Date module but provides '''strftime''' and '''strptime'''.


{{out}} using interactive echo of results

prompt$ jsish
# strftime();
"2019-02-20 19:43:20"


ts = time()

println("The system time is (in ISO 8601 format):")
println(strftime("    %F %T %Z", ts))


The system time is (in ISO 8601 format):
    2015-04-08 14:19:38 CDT


// version 1.0.6

fun main(args: Array<String>) {


date->format('%Q %T')

{{out}} 2013-11-02 11:47:27 1383407747



By default, LFE timestamps are turned in the #(megasecs secs microsecs) format.

> (os:timestamp)
#(1423 786308 145798)

These can be changed to the more common date/time stamp with the calendar module:

> (calendar:now_to_datetime (os:timestamp))
#(#(2015 2 13) #(0 12 18))

Locale taken into account:

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

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

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


The '''system''' command is provided in the lil shell. On GNU/Linux:

print [system date]; print [system date +%s.%N]
Fri Aug 23 20:50:08 EDT 2019



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


## Locomotive Basic

The variable "time" contains the time elapsed since last system start or reset. Each unit equals 1/300 s.
print time
print time/300;"s since last reboot"

{{works with|UCB Logo}} Other Logo variants might have a built-in command, but UCB Logo must access the Unix shell to get time.

to time
  output first first shell [date +%s]

make "start time
wait 300              ; 60ths of a second
print time - :start   ; 5



M2000 Interpreter

print str$(now,"long time"), time$(now)


Different ways of doing this, here are 2 most common:


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.

=={{header|MATLAB}} / {{header|Octave}}==

ans =
13-Aug-2010 12:59:56
The system time is 22:55:44

## Neko


System time

Neko uses Int32 to store system date/time values. And lib C strftime style formatting for converting to string form

*/ 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") ``` {{out}} ```txt prompt$ nekoc system-time.neko prompt$ neko system-time.n 1542158592 20:23:12 ``` ## Nemerle ```Nemerle System.Console.Write(System.DateTime.Now); ``` ## NetRexx ```netrexx import java.text.SimpleDateFormat say SimpleDateFormat("yyyy-MM-dd-HH.mm.ss.SSS").format(Date()) ``` ## NewLISP ```NewLISP> (date) "Sun Sep 28 20:17:55 2014" ``` ## Nim ```nim import times echo(getDateStr()) echo(getClockStr()) echo(getTime()) ``` {{out}} 2013-08-02 07:34:25 Fri Aug 2 07:34:25 2013 =={{header|Objective-C}}== ```objc NSLog(@"%@", [NSDate date]); ``` or (deprecated) ```objc NSLog(@"%@", [NSCalendarDate calendarDate]); ``` ## Objeck ```objeck function : Time() ~ Nil { t := Time->New(); IO.Console->GetInstance()->Print(t->GetHours())->Print(":")->Print(t->GetMinutes())->Print(":")->PrintLine(t->GetSeconds()); } ``` ## OCaml ```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; ``` ## 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). ```Oforth System.tick println #[ #sqrt 1000000 seq map sum println ] bench ``` {{out}} ```txt 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. ```Oforth import: date System.localTime dup println asDate println drop drop ``` {{out}} ```txt 1421095428478000 2015-01-12 21:43:48,478 ``` ## Oz ```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}} ``` {{out}} 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 ```parigp system("date") ``` Direct access to the C library time() function can be had by an install(), and it should be faster than running the date program. ```parigp install(time, "lf"); t = time(); print(t); \\ integer seconds since the epoch (usually 1 Jan 1970) ``` 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 {{works with|Turbo Pascal|5.5}} ```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. ``` {{out}} 23:42:35.9 2010-07-29 1023262033 85427 ## Perl Simple localtime use in scalar context. ```perl print scalar localtime, "\n"; ``` {{out}} Thu Jan 24 11:23:30 2008 localtime use in array context. ```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 ``` {{out}} 2008-01-24 11:23:30 The same using DateTime: ```perl use DateTime; my $dt = DateTime->now; my $d = $dt->ymd; my $t = $dt->hms; print "$d $t\n"; ``` {{out}} 2010-03-29 19:46:26 localtime use in array context with [[POSIX]] strftime: ```perl use POSIX qw(strftime); $now_string = strftime "%a %b %e %H:%M:%S %Y", localtime; print "$now_string\n"; ``` Output (with cs_CZ.UTF-8 locale): ```txt Čt led 24 11:23:30 2008 ``` Using the [http://search.cpan.org/perldoc?DateTime DateTime] module: ```perl use DateTime; my $dt = DateTime->now; say $dt->iso8601(); say $dt->year_with_christian_era(); say $dt->year_with_secular_era(); # etc. ``` Unix epoch: ```perl>print time;) ## Phix ```Phix include timedate.e ?format_timedate(date(),"Dddd, Mmmm dth, YYYY, h:mm:ss pm") atom t0 = time() sleep(0.9) ?time()-t0 ``` {{out}} ```txt "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: ```php echo time(), "\n"; ``` Microseconds since the Unix epoch: ```php echo microtime(), "\n"; ``` Formatted time: ```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 ``` ## PicoLisp ```PicoLisp (stamp) ``` {{out}} -> "2010-02-19 15:14:06 ## PL/I ```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. */ ``` ## PowerShell Using a cmdlet: ```powershell Get-Date ``` or using .NET classes and properties: ```powershell [DateTime]::Now ``` ## PureBasic ```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 ``` ## Python ```python import time print time.ctime() ``` ## Q Date & time are accessible via the virtual .z namespace. lowercase names are UTC, uppercase are local: ```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 ``` ## R {{works with|R|2.8.1}} Note that this is output as a standard style string. ```R Sys.time() ``` {{out}} [1] "2009-07-27 15:27:04 PDT" ## Racket The system time as a date string: ```racket #lang racket (require racket/date) (date->string (current-date)) ``` Or, as seconds after midnight UTC, January 1, 1970: ```racket #lang racket (current-seconds) ``` ## Raven Note the use of single quotation marks for the date specifier.time dup print "\n" print int '%a %b %e %H:%M:%S %Y' date ``` {{out}} 1353352623.511231 Tue Nov 20 05:17:03 2012 ## REBOL ```REBOL now print rejoin [now/year "-" now/month "-" now/day " " now/time] ``` {{out}} 10-Dec-2009/7:43:55-5:00 2009-12-10 7:43:55 ## Retro Displays the number of seconds since the Unix epoch: ```Retro>time putn 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 ``` ## Scala {{libheader|Scala}}Ad hoc solution as [http://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop REPL] scripts: ### JDK < 8 ```scala println(new java.util.Date) ``` {{out}} Sun Aug 14 22:47:42 EDT 2011 ===JDK >= 8 (recommended)=== ```scala println(java.time.LocalTime.now()) ``` {{out}} 11:32:39.002 ## Scheme {{works with|Chicken Scheme}} ```scheme (use posix) (seconds->string (current-seconds)) ``` {{out}} "Sat May 16 21:42:47 2009" ## Seed7 ```seed7 $ include "seed7_05.s7i"; include "time.s7i"; const proc: main is func begin writeln(time(NOW)); end func; ``` {{out}} 2009-12-07 17:09:44.687500 UTC+1 ## SETL ```setl $ Unix time print(tod); $ Human readable time and date print(date); ``` {{out}} ```setl 1447628158908 Sun Nov 15 22:55:58 2015 ``` ## Sidef ```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 ``` ## Smalltalk {{works with|GNU Smalltalk}} ```smalltalk>DateTime now displayNl.DateAndTime now SELECT CURRENT DATE, CURRENT TIME, CURRENT TIMESTAMP FROM SYSIBM.SYSDUMMY1; 1 2 3 ---------- -------- -------------------------- 04/29/2018 14:27:10 2018-04-29- 1 record(s) selected. ``` ## Stata ```stata di c(current_date) di c(current_time) ``` ## Tcl This uses a timestamp that is a number of seconds since the start of the UNIX Epoch. ```tcl puts [clock seconds] ``` More readable forms may be created by formatting the time: ```tcl puts [clock format [clock seconds]] ``` =={{header|TI-89 BASIC}}== ```ti89b ■ getTime() {13 28 55} ■ getDate() {2009 8 13} ``` 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 ```tuscript $$ MODE TUSCRIPT time=time() PRINT time ``` {{out}} 2011-04-05 13:45:44 ## UNIX Shell ```bash date # Thu Dec 3 15:38:06 PST 2009 date +%s # 1259883518, seconds since the epoch, like C stdlib time(0) ``` ## Ursa ```ursa # outputs time in milliseconds import "time" out (time.getcurrent) endl console ``` ## Ursala A library function, now, ignores its argument and returns the system time as a character string. ```Ursala #import cli #cast %s main = now 0 ``` {{out}} '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 ```vala var now = new DateTime.now_local(); string now_string = now.to_string(); ``` {{out}} 2011-11-12T20:23:24-0800 ## VBA ```VB Debug.Print Now() ``` {{out}} 12/12/2013 16:16:16 ## VBScript ```vb>WScript.Echo Now> 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); ] ``` {{out}} 13:08:26.60 ## Yabasic ```Yabasic print time$ ``` ## zkl ```zkl Time.Clock.time //-->seconds since the epoch (C/OS defined) ``` {{omit from|Axe}}