System time

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

Date format

See also

Retrieving system time (wiki)

AArch64 Assembly

Works with: as version Raspberry Pi 3B version Buster 64 bits

<lang AArch64 Assembly> /* ARM assembly AARCH64 Raspberry PI 3B */ /* program sysTime64.s */

/*******************************************/ /* Constantes file */ /*******************************************/ /* for this file see task include a file in language AArch64 assembly*/ .include "../includeConstantesARM64.inc"

.equ GETTIME, 169 // call system linux gettimeofday

/*******************************************/ /* Structures */ /********************************************/ /* example structure time */

   .struct  0

timeval_sec: //

   .struct  timeval_sec + 8

timeval_usec: //

   .struct  timeval_usec + 8

timeval_end:

   .struct  0

timezone_min: //

   .struct  timezone_min + 8

timezone_dsttime: //

   .struct  timezone_dsttime + 8

timezone_end:

/*********************************/ /* Initialized data */ /*********************************/ .data szMessEmpty: .asciz "Empty queue. \n" szMessNotEmpty: .asciz "Not empty queue. \n" szMessError: .asciz "Error detected !!!!. \n" szMessResult: .asciz "GMT: @/@/@ @:@:@ @ms\n" // message result

szCarriageReturn: .asciz "\n" .align 4 tbDayMonthYear: .quad 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335

                  .quad 366, 397, 425, 456, 486, 517, 547, 578, 609, 639, 670, 700
                  .quad 731, 762, 790, 821, 851, 882, 912, 943, 974,1004,1035,1065
                  .quad 1096,1127,1155,1186,1216,1247,1277,1308,1339,1369,1400,1430

/*********************************/ /* UnInitialized data */ /*********************************/ .bss .align 4 stTVal: .skip timeval_end stTZone: .skip timezone_end sZoneConv: .skip 100 /*********************************/ /* code section */ /*********************************/ .text .global main main: // entry of program

   ldr x0,qAdrstTVal             // time zones
   ldr x1,qAdrstTZone
   mov x8,GETTIME                // call system 
   svc 0
   cmp x0,-1                     // error ?
   beq 99f
   ldr x1,qAdrstTVal
   ldr x0,[x1,timeval_sec]       // timestamp in second
   bl convTimeStamp
   //ldr x0,qTStest1
   //bl convTimeStamp
   //ldr x0,qTStest2
   //bl convTimeStamp
   //ldr x0,qTStest3
   //bl convTimeStamp
   b 100f

99:

   ldr x0,qAdrszMessError
   bl affichageMess

100: // standard end of the program

   mov x0,0                       // return code
   mov x8,EXIT                    // request to exit program
   svc 0                          // perform the system call

qAdrszMessError: .quad szMessError qAdrstTVal: .quad stTVal qAdrstTZone: .quad stTZone qAdrszMessResult: .quad szMessResult qAdrszCarriageReturn: .quad szCarriageReturn qTStest1: .quad 1609508339 // 01/01/2021 qTStest2: .quad 1657805939 // 14/07/2022 qTStest3: .quad 1767221999 // 31/12/2025 /******************************************************************/ /* conversion timestamp to date */ /******************************************************************/ /* x0 contains the value of timestamp */ convTimeStamp:

   stp x1,lr,[sp,-16]!            // save  registers
   ldr x2,qSecJan2020
   sub x3,x0,x2                   // total secondes to 01/01/2020
   mov x4,60
   udiv x5,x3,x4
   msub x6,x5,x4,x3              // compute secondes
   udiv x3,x5,x4
   msub x7,x3,x4,x5              // compute minutes
   mov x4,24
   udiv x5,x3,x4
   msub x8,x5,x4,x3              // compute hours
   mov x4,(365 * 4 + 1)
   udiv x9,x5,x4
   lsl x9,x9,2                   // multiply by 4 = year1
   udiv x12,x5,x4
   msub x10,x12,x4,x5
   ldr x11,qAdrtbDayMonthYear
   mov x12,3
   mov x13,12

1:

   mul x14,x13,x12
   ldr x15,[x11,x14,lsl 3]         // load days by year
   cmp x10,x15
   bge 2f
   sub x12,x12,1
   cmp x12,0
   cbnz x12,1b

2: // x12 = year2

   mov x16,11
   mul x15,x13,x12
   lsl x15,x15,3                  // * par 8
   add x14,x15,x11

3:

   ldr x15,[x14,x16,lsl 3]        // load days by month
   cmp x10,x15
   bge 4f
   sub x16,x16,1
   cmp x16,0
   cbnz x16,3b

4: // x16 = month - 1

   mul x15,x13,x12
   add x15,x15,x16
   ldr x1,qAdrtbDayMonthYear
   ldr x3,[x1,x15,lsl 3]
   sub x0,x10,x3
   add x0,x0,1                    // final compute day
   ldr x1,qAdrsZoneConv
   bl conversion10
   ldr x0,qAdrszMessResult
   ldr x1,qAdrsZoneConv
   bl strInsertAtCharInc          // insert result at first @ character
   mov x2,x0
   add x0,x16,1                   // final compute month
   ldr x1,qAdrsZoneConv
   bl conversion10
   mov x0,x2
   ldr x1,qAdrsZoneConv
   bl strInsertAtCharInc          // insert result at next @ character
   mov x2,x0
   add x0,x9,2020
   add x0,x0,x12                  // final compute year = 2020 + year1 + year2
   ldr x1,qAdrsZoneConv
   bl conversion10
   mov x0,x2
   ldr x1,qAdrsZoneConv
   bl strInsertAtCharInc          // insert result at next @ character
   mov x2,x0
   mov x0,x8                      // hours
   ldr x1,qAdrsZoneConv
   bl conversion10
   mov x0,x2
   ldr x1,qAdrsZoneConv
   bl strInsertAtCharInc          // insert result at next @ character
   mov x2,x0
   mov x0,x7                      // minutes
   ldr x1,qAdrsZoneConv
   bl conversion10
   mov x0,x2
   ldr x1,qAdrsZoneConv
   bl strInsertAtCharInc          // insert result at next @ character
   mov x2,x0
   mov x0,x6                      // secondes
   ldr x1,qAdrsZoneConv
   bl conversion10
   mov x0,x2
   ldr x1,qAdrsZoneConv
   bl strInsertAtCharInc          // insert result at next @ character
   mov x2,x0
   ldr x1,qAdrstTVal
   ldr x0,[x1,timeval_usec]       // millisecondes
   ldr x1,qAdrsZoneConv
   bl conversion10
   mov x0,x2
   ldr x1,qAdrsZoneConv
   bl strInsertAtCharInc          // insert result at next @ character
   bl affichageMess 
   b 100f

99:

   ldr x0,qAdrszMessError
   bl affichageMess

100:

   ldp x1,lr,[sp],16              // restaur  2 registers
   ret                            // return to address lr x30

qAdrsZoneConv: .quad sZoneConv qSecJan2020: .quad 1577836800 qAdrtbDayMonthYear: .quad tbDayMonthYear /********************************************************/ /* File Include fonctions */ /********************************************************/ /* for this file see task include a file in language AArch64 assembly */ .include "../includeARM64.inc" </lang>

Output:

GMT: 28/3/2020  20:29:58  862484ms

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

Works with: ALGOL 68G version Any - tested with release mk15-0.8b.fc9.i386

<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

AmigaBASIC

<lang amigabasic>print date$,time$</lang>

Output:

11-19-2020    20:47:44

AppleScript

<lang AppleScript>display dialog ((current date) as text)</lang>

Output:

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

macOS's system time epoch is 1st January 2001 00:00:00 UTC. The number of seconds since then can be calculated in vanilla AppleScript like this:

<lang applescript>set now to (current date) set GMTOffset to (time to GMT) copy now to epoch tell epoch to set {its day, its month, its year, its time} to {1, January, 2001, 0} set systemTime to now - GMTOffset - epoch

-- Format output: set offsetStr to GMTOffset div hours * 100 + GMTOffset mod hours div minutes if (GMTOffset < 0) then

   set offsetStr to " -" & text 3 thru -1 of ((-10000 + offsetStr) as text)

else

   set offsetStr to " +" & text 2 thru -1 of ((10000 + offsetStr) as text)

end if return (now as text) & offsetStr & (linefeed & systemTime) & (" seconds since " & epoch & " UTC")</lang>

Output:

<lang applescript>"Tuesday 30 June 2020 at 11:34:31 +0100 6.15206071E+8 seconds since Monday 1 January 2001 at 00:00:00 UTC"</lang>

With AppleScriptObjC, it's more direct and fractions of a second are included:

<lang applescript>use AppleScript version "2.4" -- Mac OS 10.10 (Yosemite) or later. use framework "Foundation"

set now to current application's class "NSDate"'s |date|() set systemTime to now's timeIntervalSinceReferenceDate() -- Or, since timeIntervalSinceReferenceDate() is both an instance method and a class method: -- set systemTime to current application's class "NSDate"'s timeIntervalSinceReferenceDate()

-- Format output: set currentLocale to current application's class "NSLocale"'s currentLocale() set nowAsText to (now's descriptionWithLocale:(currentLocale)) as text set epoch to now's dateByAddingTimeInterval:(-systemTime) -- Or: -- set epoch to current application's class "NSDate"'s dateWithTimeIntervalSinceReferenceDate:(0) set epochAsText to epoch's |description|() as text return nowAsText & (linefeed & systemTime) & (" seconds since " & epochAsText)</lang>

Output:

<lang applescript>"Tuesday 30 June 2020 at 11:34:34 British Summer Time 6.152060746444E+8 seconds since 2001-01-01 00:00:00 +0000"</lang>

ARM Assembly

Works with: as version Raspberry Pi

<lang ARM Assembly> /* ARM assembly Raspberry PI */ /* program sysTime.s */

/* REMARK 1 : this program use routines in a include file

  see task Include a file language arm assembly 
  for the routine affichageMess conversion10 
  see at end of this program the instruction include */

/*******************************************/ /* Constantes */ /*******************************************/ .equ STDOUT, 1 @ Linux output console .equ EXIT, 1 @ Linux syscall .equ WRITE, 4 @ Linux syscall .equ BRK, 0x2d @ Linux syscall .equ CHARPOS, '@'

.equ GETTIME, 0x4e @ call system linux gettimeofday

/*******************************************/ /* Structures */ /********************************************/ /* example structure time */

   .struct  0

timeval_sec: @

   .struct  timeval_sec + 4

timeval_usec: @

   .struct  timeval_usec + 4

timeval_end:

   .struct  0

timezone_min: @

   .struct  timezone_min + 4

timezone_dsttime: @

   .struct  timezone_dsttime + 4

timezone_end:

/*********************************/ /* Initialized data */ /*********************************/ .data szMessError: .asciz "Error detected !!!!. \n" szMessResult: .asciz "GMT: @/@/@ @:@:@ @ms\n" @ message result

szCarriageReturn: .asciz "\n" .align 4 tbDayMonthYear: .int 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335

                  .int 366, 397, 425, 456, 486, 517, 547, 578, 609, 639, 670, 700
                  .int 731, 762, 790, 821, 851, 882, 912, 943, 974,1004,1035,1065
                  .int 1096,1127,1155,1186,1216,1247,1277,1308,1339,1369,1400,1430

/*********************************/ /* UnInitialized data */ /*********************************/ .bss .align 4 stTVal: .skip timeval_end stTZone: .skip timezone_end sZoneConv: .skip 100 /*********************************/ /* code section */ /*********************************/ .text .global main main: @ entry of program

   ldr r0,iAdrstTVal
   ldr r1,iAdrstTZone
   mov r7,#GETTIME
   svc 0
   cmp r0,#-1                     @ error ?
   beq 99f
   ldr r0,iAdrstTVal
   ldr r1,[r0,#timeval_sec]       @ timestemp in second
   //ldr r1,iTStest1
   //ldr r1,iTStest2
   //ldr r1,iTStest3
   ldr r2,iSecJan2020
   sub r0,r1,r2                   @ total secondes to 01/01/2020
   mov r1,#60
   bl division
   mov r0,r2
   mov r6,r3                      @ compute secondes
   mov r1,#60
   bl division
   mov r7,r3                      @ compute minutes
   mov r0,r2
   mov r1,#24
   bl division
   mov r8,r3                      @ compute hours
   mov r0,r2
   mov r11,r0
   mov r1,#(365 * 4 + 1)
   bl division
   lsl r9,r2,#2                   @ multiply by 4 = year1
   mov r1,#(365 * 4 + 1)
   mov r0,r11
   bl division
   mov r10,r3
   ldr r1,iAdrtbDayMonthYear
   mov r2,#3
   mov r3,#12

1:

   mul r11,r3,r2
   ldr r12,[r1,r11,lsl #2]         @ load days by year
   cmp r10,r12
   bge 2f
   sub r2,r2,#1
   cmp r2,#0
   bne 1b

2: @ r2 = year2

   mov r5,#11
   mul r4,r3,r2
   lsl r4,#2
   add r4,r1

3:

   ldr r12,[r4,r5,lsl #2]         @ load days by month
   cmp r10,r12
   bge 4f
   subs r5,r5,#1
   bne 3b

4: @ r5 = month - 1

   mul r11,r3,r2
   add r11,r5
   ldr r1,iAdrtbDayMonthYear
   ldr r3,[r1,r11,lsl #2]
   sub r0,r10,r3

   add r0,r0,#1                   @ final compute day
   ldr r1,iAdrsZoneConv
   bl conversion10                @ this function do not zero final
   mov r4,#0                      @ store zero final
   strb r4,[r1,r0]
   ldr r0,iAdrszMessResult
   ldr r1,iAdrsZoneConv
   bl strInsertAtCharInc          @ insert result at first @ character
   mov r3,r0
   add r0,r5,#1                   @ final compute month
   ldr r1,iAdrsZoneConv
   bl conversion10
   mov r4,#0                      @ store zero final
   strb r4,[r1,r0]
   mov r0,r3
   ldr r1,iAdrsZoneConv
   bl strInsertAtCharInc          @ insert result at next @ character
   mov r3,r0
   ldr r11,iYearStart
   add r0,r9,r11
   add r0,r0,r2                   @ final compute year = 2020 + year1 + year2
   ldr r1,iAdrsZoneConv
   bl conversion10
   mov r4,#0                      @ store zero final
   strb r4,[r1,r0]
   mov r0,r3
   ldr r1,iAdrsZoneConv
   bl strInsertAtCharInc          @ insert result at next @ character
   mov r3,r0
   mov r0,r8                      @ hours
   ldr r1,iAdrsZoneConv
   bl conversion10
   mov r4,#0                      @ store zero final
   strb r4,[r1,r0]
   mov r0,r3
   ldr r1,iAdrsZoneConv
   bl strInsertAtCharInc          @ insert result at next @ character
   mov r3,r0
   mov r0,r7                      @ minutes
   ldr r1,iAdrsZoneConv
   bl conversion10
   mov r4,#0                      @ store zero final
   strb r4,[r1,r0]
   mov r0,r3
   ldr r1,iAdrsZoneConv
   bl strInsertAtCharInc          @ insert result at next @ character
   mov r3,r0
   mov r0,r6                      @ secondes
   ldr r1,iAdrsZoneConv
   bl conversion10
   mov r4,#0                      @ store zero final
   strb r4,[r1,r0]
   mov r0,r3
   ldr r1,iAdrsZoneConv
   bl strInsertAtCharInc          @ insert result at next @ character
   mov r3,r0
   ldr r1,iAdrstTVal
   ldr r0,[r1,#timeval_usec]      @ millisecondes
   ldr r1,iAdrsZoneConv
   bl conversion10
   mov r4,#0                      @ store zero final
   strb r4,[r1,r0]
   mov r0,r3
   ldr r1,iAdrsZoneConv
   bl strInsertAtCharInc          @ insert result at next @ character
   bl affichageMess 
   b 100f

99:

   ldr r0,iAdrszMessError
   bl affichageMess

100: @ standard end of the program

   mov r0,#0                      @ return code
   mov r7,#EXIT                   @ request to exit program
   svc 0                          @ perform the system call

iAdrszMessError: .int szMessError iAdrstTVal: .int stTVal iAdrstTZone: .int stTZone iAdrszMessResult: .int szMessResult iAdrszCarriageReturn: .int szCarriageReturn iAdrsZoneConv: .int sZoneConv iSecJan2020: .int 1577836800 iAdrtbDayMonthYear: .int tbDayMonthYear iYearStart: .int 2020 iTStest1: .int 1609508339 @ 01/01/2021 iTStest2: .int 1657805939 @ 14/07/2022 iTStest3: .int 1767221999 @ 31/12/2025 /***************************************************/ /* ROUTINES INCLUDE */ /***************************************************/ .include "../affichage.inc" </lang>

Output:

GMT: 29/3/2020  18:39:13  717877ms

Arturo

<lang arturo>print [datetime|now ~]</lang>

Output:

30-11-2019 10:31:09

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

Avail

The method now retrieves the current timestamp. <lang Avail>Print: “now”;</lang>

AWK

One-liner:

Works with: Gawk

<lang awk>$ awk 'BEGIN{print systime(),strftime()}'</lang>

Output:

1242401632 Fri May 15 17:33:52  2009

Solution for other awk-versions:

Works with: awk

<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

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

Works with: QBasic

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.

Works with: Windows NT

<lang dos>date /t

time /t</lang>Furthermore there are two pseudo-variables %DATE% and %TIME%:

Works with: Windows NT version 4

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#

<lang csharp>Console.WriteLine(DateTime.Now);</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

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

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

Crystal

<lang ruby># current time in system's time zone: Time.local

current time in UTC

Time.utc

monotonic time (useful for measuring elapsed time)

Time.monotonic </lang>

D

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

EasyLang

<lang>print time_str time1970</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:

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

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

Frink

<lang frink>println[now[]]</lang>

Output:

AD 2020-06-24 PM 06:37:01.326 (Wed) Mountain Daylight Time

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

Genie

<lang genie>[indent=4]

init

   var now = new DateTime.now_local()
   print now.to_string()</lang>

Output:

prompt$ valac systemTime.gs
prompt$ ./systemTime
2019-06-01T13:07:54-0400

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.

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.

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

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

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

Works with: Java version 1.5+

<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

Works with: jq version 1.5

<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

Translation of: Erlang

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>

LIL

The system command is provided in the lil shell. On GNU/Linux: <lang tcl>print [system date]; print [system date +%s.%N]</lang>

Fri Aug 23 20:50:08 EDT 2019

1566607808.225126400

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

Works with: UCB 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>

min

Works with: min version 0.27.1

<lang min>now datetime puts!</lang>

Output:

2021-01-09T17:41:59Z

Modula-2

Works with: ADW Modula-2 version any (Compile with the linker option Console Application).

<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

Nanoquery

<lang Nanoquery>import Nanoquery.Util println new(Date).getTime()</lang>

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

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

Objeck

<lang objeck>function : Time() ~ Nil {

 t := Time->New();
 IO.Console->GetInstance()->Print(t->GetHours())->Print(":")->Print(t->GetMinutes())->Print(":")->PrintLine(t->GetSeconds());

}</lang>

Objective-C

<lang objc>NSLog(@"%@", [NSDate date]);</lang>or (deprecated)<lang objc>NSLog(@"%@", [NSCalendarDate calendarDate]);</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

Works with: Turbo Pascal version 5.5

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

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

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.

Phixmonti

<lang Phixmonti>def printList len for get print endfor enddef

time

"Actual time is " swap 1 get " hour, " rot 2 get " minutes, " rot 3 get nip " seconds, " "and elapsed " msec " seconds of running time." 10 tolist printList</lang>

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

Pike

<lang Pike>write( ctime(time()) );</lang>

Output:

Thu Jan  2 23:58:19 2020

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>

Quackery

<lang Quackery>time 1000000 / echo say " seconds since the Unix epoch."</lang> Output

1610201941 seconds since the Unix epoch.

R

Works with: R version 2.8.1

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>

Raku

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

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>

Rust

<lang rust>// 20210210 Rust programming solution

extern crate chrono; use chrono::prelude::*;

fn main() {

  let utc: DateTime<Utc> = Utc::now();
  println!("{}", utc.format("%d/%m/%Y %T"));

} </lang>

Output:

10/02/2021 16:26:23

Scala

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

Works with: Chicken 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:

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

Works with: GNU Smalltalk

<lang smalltalk>DateTime now displayNl.</lang>

Output:

2011-08-10T00:43:36-0-7:00

Works with: Pharo

Works with: Smalltalk/X

<lang smalltalk>DateAndTime now</lang>

Output:

2011-08-16T19:40:37-03:00

Works with: Pharo

<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

SQL PL

Works with: Db2 LUW

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

Standard ML

<lang sml>print (Date.toString (Date.fromTimeLocal (Time.now ())) ^ "\n")</lang>

Stata

<lang stata>di c(current_date) di c(current_time)</lang>

Swift

<lang Swift>import Foundation

var ⌚️ = NSDate()

println(⌚️)</lang>

Output:

2014-06-22 20:43:42 +0000

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>

Wren

Library: Wren-date

Although Wren CLI can tell how much time has elapsed since the script started, it currently has no way of knowing what the time was then or what the time is now (in the current locale) unless the user passes the former as a command line argument. <lang ecmascript>import "os" for Process import "/date" for Date

var args = Process.arguments if (args.count != 1) Fiber.abort("Please pass the current time in hh:mm:ss format.") var startTime = Date.parse(args[0], Date.isoTime) for (i in 0..1e8) {} // do something which takes a bit of time var now = startTime.addMillisecs((System.clock * 1000).round) Date.default = Date.isoTime + "|.|ttt" System.print("Time now is %(now)")</lang>

Output:

Sample session.

$ wren systemTime.wren 19:00:00
Time now is 19:00:01.992

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>