System time: Difference between revisions
Add Ecstasy example
(Add task to ARM assembly Raspberry pi) |
(Add Ecstasy example) |
||
(48 intermediate revisions by 35 users not shown) | |||
Line 19:
* [[wp:System time#Retrieving system time|Retrieving system time (wiki)]]
<br><br>
=={{header|11l}}==
<syntaxhighlight lang="11l">print(Time())</syntaxhighlight>
{{out}}
<pre>
2021-03-25 13:03:47.0505867
</pre>
=={{header|AArch64 Assembly}}==
{{works with|as|Raspberry Pi 3B version Buster 64 bits}}
<syntaxhighlight lang="aarch64 assembly">
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program sysTime64.s */
Line 54 ⟶ 62:
/*********************************/
.data
szMessEmpty: .asciz "Empty queue. \n"
szMessNotEmpty: .asciz "Not empty queue. \n"
szMessError: .asciz "Error detected !!!!. \n"
szMessResult: .asciz "GMT: @/@/@ @:@:@ @ms\n" // message result
Line 76 ⟶ 86:
.text
.global main
main:
ldr x0,qAdrstTVal // time zones
ldr x1,qAdrstTZone
mov x8,GETTIME // call system
svc 0
cmp x0,-1 // error ?
beq 99f
ldr
ldr
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,
mov x4,60
udiv x5,x3,x4
Line 95 ⟶ 135:
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
msub x10,x12,x4,x5
ldr x11,qAdrtbDayMonthYear
mov x12,3
Line 110 ⟶ 151:
cmp x12,0
cbnz x12,1b
2: //
mov x16,11
lsl x15,x15,3 // * par 8
add x14,x15,x11
3:
ldr x15,[x14,x16,lsl 3] // load days by month
Line 121 ⟶ 164:
cbnz x16,3b
4: // x16 = month - 1
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
Line 177 ⟶ 224:
ldr x0,qAdrszMessError
bl affichageMess
100:
qAdrsZoneConv: .quad sZoneConv
qSecJan2020: .quad 1577836800
Line 195 ⟶ 235:
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"
</syntaxhighlight>
{{Output}}
<pre>
GMT: 28/3/2020 20:29:58 862484ms
</pre>
=={{header|ABAP}}==
<
WRITE: sy-uzeit.</
=={{header|Ada}}==
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.Formatting; use Ada.Calendar.Formatting;
with Ada.Calendar.Time_Zones; use Ada.Calendar.Time_Zones;
Line 215 ⟶ 256:
begin
Put_line(Image(Date => Now, Time_Zone => -7*60));
end System_Time;</
2008-01-23 19:14:19
=={{header|Aime}}==
<
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));</
2011-09-04 15:05:08
Line 230 ⟶ 271:
<!-- {{does not work with|ALGOL 68|Standard - POSIX local time, and utc time extensions to language used}} -->
{{works with|ALGOL 68G|Any - tested with release mk15-0.8b.fc9.i386}}
<!-- {{does not work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release 1.8.8d.fc9.i386 - test missing transput, and POSIX local time, and utc time extensions to language used}} --><
minutes="2d,", seconds="2d,", day of week="d,", \
daylight-saving-time flag="dl$;
printf((time repr, local time));
printf((time repr, utc time))</
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
=={{header|AmigaBASIC}}==
<syntaxhighlight lang="amigabasic">print date$,time$</syntaxhighlight>
{{output}}
<pre>11-19-2020 20:47:44</pre>
=={{header|AppleScript}}==
<
{{out}}
<pre>
Sunday, August 14, 2011 10:43:57 PM
</pre>
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:
<syntaxhighlight 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")</syntaxhighlight>
{{output}}
<syntaxhighlight 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"</syntaxhighlight>
With AppleScriptObjC, it's more direct and fractions of a second are included:
<syntaxhighlight 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)</syntaxhighlight>
{{output}}
<syntaxhighlight 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"</syntaxhighlight>
=={{header|ARM Assembly}}==
{{works with|as|Raspberry Pi}}
<syntaxhighlight lang="arm assembly">
/* ARM assembly Raspberry PI */
/* program sysTime.s */
Line 318 ⟶ 410:
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
Line 333 ⟶ 428:
mov r0,r2
mov r11,r0
mov r1,#(365 * 4 + 1)
bl division
lsl r9,r2,#2 @ multiply by 4 = year1
bl division
mov r10,r3
ldr r1,iAdrtbDayMonthYear
mov r2,#3
Line 352 ⟶ 449:
mov r5,#11
mul r4,r3,r2
lsl r4,#2
add r4,r1
3:
Line 360 ⟶ 458:
bne 3b
4: @ r5 = month - 1
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
Line 445 ⟶ 548:
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"
</syntaxhighlight>
{{Output}}
<pre>
Line 456 ⟶ 562:
=={{header|Arturo}}==
<syntaxhighlight lang
{{out}}
<pre>
=={{header|Asymptote}}==
<syntaxhighlight lang="asymptote">time();
time("%a %b %d %H:%M:%S %Z %Y");
//are equivalent ways of returning the current time in the default format used by the UNIX date command.</syntaxhighlight>
See [https://asymptote.sourceforge.io/doc/Data-types.html time() in the Asymptote manual].
=={{header|AutoHotkey}}==
<
MsgBox,% t</
{{out}}
<pre>
Line 471 ⟶ 585:
=={{header|AutoIt}}==
<
{{out}}
<pre>
Line 479 ⟶ 593:
=={{header|Avail}}==
The method <code>now</code> retrieves the current timestamp.
<syntaxhighlight lang
=={{header|AWK}}==
'''One-liner:'''
{{works with|Gawk}}
<
{{out}}
<pre>1242401632 Fri May 15 17:33:52 2009</pre>
Line 490 ⟶ 604:
'''Solution for other awk-versions:'''
{{works with|awk}}
<
function dos_date( cmd,d,t,x) { # under MS Windows
# cmd = "DATE /T"
Line 511 ⟶ 625:
#print systime(), strftime() # gawk only
}
</syntaxhighlight>
{{out}}
<pre>
Line 520 ⟶ 634:
=={{header|BaCon}}==
<
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"</
{{out}}
<pre>
Line 534 ⟶ 648:
This shows the system time in seconds since midnight.
<syntaxhighlight lang
This shows the time in human-readable format (using a 24-hour clock):
<syntaxhighlight lang
==={{header|Commodore BASIC}}===
====TI$ and TI====
Commodore BASIC maintains both a 24-hour clock as <code>TI$</code> and a jiffy clock (1 jiffy = 1/60 seconds) as the variable <code>TIME</code>. Since Commodore BASIC recognizes only the first two letters of a variable identifier, <code>TIME$</code>, <code>TIMPANI$</code>, and <code>TIMBUKTU$</code> would all refer to the time keeping variable of <code>TI$</code>.
Notes about the two variables:
* <code>TI$</code> counts in standard time format of HHMMSS from 00:00:00 to 23:59:59 after which it will reset back to 00:00:00. On certain CBM/PET computers, TI$ is seven digits to include 1/10 seconds at the end.
* <code>TI$</code> is both read and write capable. The user can initialize the clock to any valid time within the 24 hour range by assigning it a string value of the time, e.g. <code>TI$ = "111530"</code> for 11:15:30. Assigning improper values (e.g. "089900" as 99 minutes after 8 o'clock) will result in automatic correction for the true time (09:39:00). Unfortunately there is no tracking of overflow in the hours to keep track of days, etc.
* <code>TI</code> is read only, but always reflects the jiffy equivalent to the value in <code>TI$</code>, that is: TI = (HH × 216,000) + (MM × 3600) + (SS × 60) + JIFFIES. <code>TI</code> can be set or reset to a value by setting <code>TI$</code> to the equivalent HHMMSS time, although resolution to specific jiffies is not possible with this method.
* Particularly on the Commodore 64, the timer handler is driven off of a CIA chip interrupt, but is in no way tied to any of the [[#Time of Day Clocks|time-of-day clocks]] built into the CIA (see below.)
* Because the clock is managed by the KERNAL operating system, the clock will loose time during certain I/O processes, such as disk access, etc. when the interrupt is unable to be processed on time.
'''Code Examples'''
<syntaxhighlight lang="commodorebasic">1 rem time since last reset
5 print chr$(147);chr$(14);
10 t$=ti$
20 h$=left$(t$,2)
30 m$=mid$(t$,3,2)
40 s$=right$(t$,2)
50 print chr$(19);"Roughly ";tab(9);h$;" hours "
51 print tab(9);m$;" minutes"
52 print tab(9);s$; " seconds":print
60 print "has elapsed since TI$ was last reset or"
65 print "the system was powered on.":print
70 print "Press any key to quit."
80 get k$:if k$="" then goto 10
</syntaxhighlight>
<syntaxhighlight lang="commodorebasic">5 rem set time to current time of day
10 print chr$(147);
20 input "Enter hour of day (0-23)";h$
25 if val(h$)<0 or val(h$)>23 then goto 20
30 input "Enter minutes (0-59)";m$
35 if val(m$)<0 or val(m$)>99 then goto 30
40 input "Enter seconds (0-59)";s$
45 if val(s$)<0 or val(s$)>99 then goto 40
60 ti$=h$+m$+s$
70 print chr$(147);
80 print chr$(19);"The time is now: ";ti$
85 print:print "Press any key to end."
90 get k$:if k$="" then 80
100 end</syntaxhighlight>
====Time of Day Clocks====
The Commodore 64 and 128 models each have two MOS 6526 Complex Interface Adapters (CIA) that each have Time of Day (TOD) clocks. Interestingly, these clocks are ''not'' used to drive the internal variables <code>TI</code> and <code>TI$</code>. The advantage of these clocks is that they will continue to count time independent of the operating system, and therefore do not lose time during the same I/O operations that affect <code>TI</code> and <code>TI$</code>.
The time is represented in Binary Coded Decimal, and a separate register is used to access hours, minutes, seconds, and 1/10 seconds.
'''Reading''' the HOURS register will suspend further updates to ''all'' of the TOD registers to allow the program to accurately read the complete time. ''The clock itself does not stop''. Once the 1/10 register is read, updates to the registers will continue. If the programmer intends to read only the hours of a running clock, a subsequent read of the 1/10 register must be performed to resume updating of the registers.
'''Writing''' to the HOURS register will ''stop the clock completely''. The clock will start only when the 1/10 register is written to, even with a zero.
'''Code Example - Commodore 64/128 Only'''
<syntaxhighlight lang="commodorebasic">1 rem read and set cia time of day clock
2 rem rosetta code commodore 64/128 example
10 print chr$(147);chr$(14)
15 hr=56331:mr=56330:sr=56329:tr=56328:gosub 300
20 print spc(11);"CIA #1 Time of Day"
21 print:print "Press S to start or stop the clock."
22 print "Press T to change the time."
23 print:print "Press Q to quit.":print
25 h=peek(hr):m=peek(mr):s=peek(sr):th=peek(tr):t=h:gosub 200
35 print chr$(19);:for q=1 to 8:print chr$(17);:next q
36 print "Clock is:";tab(12);cl$(b):print
40 print "Hours:";tab(12);h;". "
45 print "Minutes:";tab(12);m;". "
50 print "Seconds:";tab(12);s;". "
55 print "1/10 Sec.:";tab(12);th;". "
60 print "AM or PM? ";tab(13);ap$
65 get k$:if k$="" then goto 25
70 if k$="s" and b=0 then poke tr,0:b=1:goto 25
75 if k$="s" and b=1 then poke hr,t:b=0:goto 25
80 if k$="t" then gosub 400:goto 20
90 if k$="q" then end
100 goto 25
200 rem decode bcd
210 ap$="AM":if (h and 128)=128 then ap$="PM"
220 s=int((s and 112)/16)*10+(s and 15)
230 m=int((m and 112)/16)*10+(m and 15)
240 h=int((h and 48)/16)*10+(h and 15)
250 return
300 rem decide if clock is running
305 cl$(0)="Stopped":cl$(1)="Running":b=0
301 rem latch, read/resume
310 z=peek(hr):t1=peek(tr)
315 for i=1 to 100:next i
320 z=peek(hr):t2=peek(tr)
325 if t1<>t2 then b=1
330 return
400 rem change clock value
405 print chr$(147)
410 input "Hour";nh$
415 if val(nh$)<1 or val(nh$)>12 then goto 410
416 if val(nh$)<10 then nh$="0"+nh$
420 input "Minutes";nm$
425 if val(nm$)<0 or val(nm$)>59 then goto 420
426 if val(nm$)<10 then nm$="0"+nm$
430 input "Seconds";ns$
435 if val(ns$)<0 or val(ns$)>59 then goto 430
436 if val(ns$)<10 then ns$="0"+ns$
440 print "AM or PM (a,p)? ";
445 get ap$:if ap$<>"a" and ap$<>"p" then 445
446 print ap$
450 ap=0:if ap$="p" then ap=128
455 rem convert input to bcd
457 ns=val(mid$(ns$,1,1))*16+val(mid$(ns$,2,1))
460 nm=val(mid$(nm$,1,1))*16+val(mid$(nm$,2,1))
465 nh=val(mid$(nh$,1,1))*16+val(mid$(nh$,2,1))
470 nh=nh+ap
475 rem now set values into clock
480 poke hr,nh:rem set hour stops clock
485 poke mr,nm:rem set minute
490 poke sr,ns:rem set second
495 poke tr,0 :rem set 1/10 starts clock
497 b=1
499 print chr$(147):return</syntaxhighlight>
=={{header|BASIC256}}==
<syntaxhighlight lang="basic256">print month+1; "-"; day; "-"; year
# returns system date in format: mm-dd-yyyy
print hour; ":"; minute; ":"; second
# returns system time in format: hh:mm:ss</syntaxhighlight>
=={{header|Batch File}}==
Line 544 ⟶ 796:
Both <tt>date</tt> and <tt>time</tt> have a <tt>/t</tt> argument which makes them output only the value instead of prompting for a new one as well.
{{works with|Windows NT}}<
time /t</
{{works with|Windows NT|4}}<syntaxhighlight lang
=={{header|BBC BASIC}}==
<
=={{header|BQN}}==
The system value <code>•UnixTime</code> whenever called, gives time between the unix epoch the time the function was called, where the Unix epoch is 1970-01-01 00:00:00 UTC. [https://github.com/mlochbaum/bqn-libs/blob/master/datetime.bqn bqn-libs/datetime.bqn] has some functions for the manipulation of the given timestamp.
<syntaxhighlight lang="bqn">•Show •UnixTime @</syntaxhighlight>
=={{header|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.<
#include<stdio.h>
#include<stdlib.h>
Line 560 ⟶ 817:
printf("%s", ctime(&my_time));
return 0;
}</
=={{header|C sharp|C#}}==
<syntaxhighlight lang
=={{header|C++}}==
to be compiled under linux with g++ -lboost_date_time systemtime.cpp -o systemtime( or whatever you like)
<
#include <boost/date_time/posix_time/posix_time.hpp>
Line 574 ⟶ 831:
std::cout << to_simple_string( t ) << std::endl ;
return 0 ;
}</
===C++ 11===
<
#include <ctime> //for conversion std::ctime()
#include <iostream>
Line 584 ⟶ 841:
auto timenow = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
std::cout << std::ctime(&timenow) << std::endl;
}</
{{out}}
<pre>
Line 591 ⟶ 848:
=={{header|Clojure}}==
<
; the current system date time string
(print (new Date))
Line 597 ⟶ 854:
(print (. (new Date) getTime))
; or
(print (System/currentTimeMillis))</
=={{header|CLU}}==
<syntaxhighlight lang="clu">start_up = proc ()
stream$putl(stream$primary_output(), date$unparse(now()))
end start_up</syntaxhighlight>
{{out}}
<pre>19 December 2021 01:50:11</pre>
=={{header|COBOL}}==
<
01 WS-CURRENT-DATE-FIELDS.
05 WS-CURRENT-DATE.
Line 614 ⟶ 878:
PROCEDURE DIVISION.
MOVE FUNCTION CURRENT-DATE TO WS-CURRENT-DATE-FIELDS.</
=={{header|ColdFusion}}==
=== Script Based CFML ===
<
// Date Time
currentTime = Now();
Line 628 ⟶ 892:
utcDate = dateConvert( "local2utc", currentTime );
writeOutput( utcDate.getTime() );
</cfscript></
{{Output}}
<pre>
Line 636 ⟶ 900:
=={{header|Common Lisp}}==
<
(format t "~4,'0D-~2,'0D-~2,'0D ~2,'0D:~2,'0D:~2,'0D" year month day hour minute second))</
=={{header|Crystal}}==
<syntaxhighlight 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
</syntaxhighlight>
=={{header|D}}==
Line 645 ⟶ 920:
Days are used in the example,
but lower units are available, with the lowest being nanoseconds (nanos field).
<
=={{header|DBL}}==
<syntaxhighlight lang="dbl">XCALL TIME (D6) ;D6=hhmmss</syntaxhighlight>
=={{header|DCL}}==
<
$ 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 )</
{{out}}
<pre>$ @system_time
Line 665 ⟶ 943:
=={{header|Delphi}}==
<
=={{header|DWScript}}==
<
=={{header|E}}==
<syntaxhighlight lang
The value is the number of milliseconds since 1970.
Line 677 ⟶ 955:
=={{header|EasyLang}}==
<syntaxhighlight lang="text">print
=={{header|Ecstasy}}==
<syntaxhighlight lang="ecstasy">
module WhatTimeIsIt {
@Inject Clock clock;
@Inject Console console;
void run() {
console.print($"current time: {clock.now}");
}
}
</syntaxhighlight>
{{out}}
<pre>
current time: 2024-04-30 19:40:57.124
</pre>
=={{header|Elena}}==
ELENA 4.x :
<
import system'calendar;
Line 687 ⟶ 982:
{
console.printLine(Date.Now);
}</
{{out}}
<pre>
Line 694 ⟶ 989:
=={{header|Elixir}}==
<
:erlang.time # => {Hour, Minute, Second}
:erlang.date # => {Year, Month, Day}
Line 701 ⟶ 996:
: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 <code>:erlang.now()</code> 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.
<syntaxhighlight lang
=={{header|Emacs Lisp}}==
<
;; => "Wed Oct 14 22:21:05 1987"</syntaxhighlight>
<code>current-time</code> is the main programmatic interface, with various functions available to format or operate on the time values list it gives.
=={{header|Erlang}}==
By default, Erlang timestamps are turned in the {megasecs, secs, microsecs} format.<
{1250,222584,635452}</
These can be changed with the calendar module:<
{{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}}</
=={{header|Excel}}==
NOW() returns the date and time to the minute.
Type in a cell :<
{{out}}
<pre>9-8-2013 17:33</pre>
=={{header|F_Sharp|F#}}==
<
{{out}}
<pre>
Line 736 ⟶ 1,030:
=={{header|Factor}}==
<
now .</
=={{header|Falcon}}==
<
/* Added by Aykayayciti Earl Lamont Montgomery
April 10th, 2018 */
> CurrentTime().toString()
</syntaxhighlight>
{{out}}
<pre>
Line 756 ⟶ 1,050:
<tt>DateTime.now</tt> returns the current time, which can then be formatted into different styles. For example, <tt>toJava</tt> returns the current time in milliseconds since 1 Jan 1970.
<tt>DateTime.nowTicks</tt> returns the number of nanoseconds since 1 Jan 2000 UTC.<
351823905158000000
fansh> DateTime.now
2011-02-24T00:51:47.066Z London
fansh> DateTime.now.toJava
1298508885979</
=={{header|Forth}}==
Line 774 ⟶ 1,068:
{{works with|VFX Forth}}
{{works with|MacForth}}
<
[DEFINED] ?MS [IF] ( -- ms )
: ms@ ?MS ; \ iForth
Line 791 ⟶ 1,085:
[THEN] [THEN] [THEN] [THEN] [THEN] [THEN] [THEN]
MS@ . \ print millisecond counter</
=={{header|Fortran}}==
In ISO Fortran 90 or later, use the SYSTEM_CLOCK intrinsic subroutine:<
real :: result
Line 806 ⟶ 1,100:
call system_clock( stop )
print *, "elapsed time: ", real(stop - start) / real(rate)</
real :: result
Line 816 ⟶ 1,110:
call cpu_time( stop )
print *, "elapsed time: ", stop - start</
=={{header|FreeBASIC}}==
<
Print Date + " " + Time '' returns system date/time in format : mm-dd-yyyy hh:mm:ss
Sleep</
=={{header|Frink}}==
<syntaxhighlight lang="frink">println[now[]]</syntaxhighlight>
{{out}}
<pre>AD 2020-06-24 PM 06:37:01.326 (Wed) Mountain Daylight Time</pre>
=={{header|FutureBasic}}==
Time can be configured from simple to specialized in FB. Here's the simplest way.
<syntaxhighlight lang="futurebasic">window 1
print time
print time(@"hh:mm:ss" )
print time(@"h:mm a" )
print time(@"h:mm a zzz")
HandleEvents</syntaxhighlight>
{{output}}
<pre>
19:30:58
07:30:58
7:30 PM
7:30 PM EDT
</pre>
More accurate timing...
<syntaxhighlight lang="futurebasic">window 1
print fn CFAbsoluteTimeGetCurrent
print fn CACurrentMediaTime
print fn ProcessInfoSystemUptime
HandleEvents</syntaxhighlight>
=={{header|Gambas}}==
'''[https://gambas-playground.proko.eu/?gist=f061cc0cf175496b37bbcd14bd1e7058 Click this link to run this code]'''
<
Print Format(Now, "dddd dd mmmm yyyy hh:nn:ss")
End</
Output:
<pre>
Line 837 ⟶ 1,161:
=={{header|Genie}}==
<
init
var now = new DateTime.now_local()
print now.to_string()</
{{out}}
Line 849 ⟶ 1,173:
=={{header|Go}}==
<
import "time"
Line 858 ⟶ 1,182:
fmt.Println(t) // default format
fmt.Println(t.Format("Mon Jan 2 15:04:05 2006")) // some custom format
}</
=={{header|Groovy}}==
Solution (based on [[#Java|Java]] solution).<
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
Line 868 ⟶ 1,192:
=={{header|GUISS}}==
We can only show the clock, but this might not be set to system time:<syntaxhighlight lang
=={{header|Haskell}}==
<
(getClockTime, toCalendarTime, formatCalendarTime)
Line 881 ⟶ 1,205:
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:
<
main :: IO ()
Line 890 ⟶ 1,214:
zt <- getZonedTime
print zt -- print default format, or
putStrLn $ formatTime defaultTimeLocale "%a %b %e %H:%M:%S %Y" zt</
=={{header|HicEst}}==
<
seconds_since_midnight = TIME(Year=yr, Day=day, WeekDay=wday, Gregorian=gday)
! other options e.g. Excel, YYYYMMDD (num or text)</
=={{header|HolyC}}==
<
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);
</syntaxhighlight>
=={{header|Hoon}}==
The time of the current system event is made available on the subject in most contexts as <tt>now</tt>.
<syntaxhighlight lang
~2016.7.24..01.25.02..0f8e
Line 914 ⟶ 1,238:
=={{header|Icon}} and {{header|Unicon}}==
<
write("&time - milliseconds of CPU time = ",&time)
Line 924 ⟶ 1,248:
write("&now - time in seconds since the epoch = ", &now) # Unicon only
end</
{{out}}
<pre>&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</pre>
=={{header|IDL}}==
Line 957 ⟶ 1,283:
=={{header|Io}}==
<syntaxhighlight lang
2008-08-26 00:15:52 EDT
=={{header|IS-BASIC}}==
<syntaxhighlight lang
=={{header|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.<
2008 1 23 12 52 10.341</
A formatted string representation of the current time can also be returned:<
2009-08-26 10:38:53.171</
=={{header|Java}}==
{{works with|Java|1.5+}}
<
public static void main(String[] args){
System.out.format("%tc%n", System.currentTimeMillis());
}
}</
Mon Jun 21 13:02:19 BST 2010
Or using <code>ZonedDateTime</code> object:<syntaxhighlight lang="java">import java.time.ZonedDateTime;
public class SystemTime{
public static void main(String[] args){
System.out.println(now);
}
}</
=={{header|JavaScript}}==
<syntaxhighlight lang="javascript">console.log(new Date()) // => Sat, 28 May 2011 08:22:53 GMT
console.log(Date.now()) // => 1306571005417 // Unix epoch</syntaxhighlight>
=={{header|Joy}}==
<syntaxhighlight lang="joy">time localtime "%T\n" strftime putchars.</syntaxhighlight>
=={{header|jq}}==
{{works with|jq |1.5}}
<
[
1437619000.970498,
"2015-07-23T02:36:40Z"
]</
"now" reports the number of seconds since the beginning of the [https://en.wikipedia.org/wiki/Unix_epoch Unix epoch].
Line 1,011 ⟶ 1,335:
Jsish does not implement the standard ECMAScript Date module but provides '''strftime''' and '''strptime'''.
<syntaxhighlight lang
{{out}} using interactive echo of results
Line 1,020 ⟶ 1,344:
=={{header|Julia}}==
<syntaxhighlight lang="julia">
ts = time()
println("The system time is (in ISO 8601 format):")
println(strftime(" %F %T %Z", ts))
</syntaxhighlight>
{{out}}
Line 1,034 ⟶ 1,358:
=={{header|Kotlin}}==
<
fun main(args: Array<String>) {
println("%tc".format(System.currentTimeMillis()))
}
</syntaxhighlight>
=={{header|Lambdatalk}}==
<syntaxhighlight lang="scheme">
{date}
-> 2021 02 22 07 23 12
</syntaxhighlight>
=={{header|Lasso}}==
<
date->asInteger</
2013-11-02 11:47:27
1383407747
Line 1,052 ⟶ 1,383:
By default, LFE timestamps are turned in the <code>#(megasecs secs microsecs)</code> format.
<
> (os:timestamp)
#(1423 786308 145798)
</syntaxhighlight>
These can be changed to the more common date/time stamp with the <code>calendar</code> module:
<
> (calendar:now_to_datetime (os:timestamp))
#(#(2015 2 13) #(0 12 18))
</syntaxhighlight>
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))
</syntaxhighlight>
Note that you will often encounter the function <code>erlang:now/0</code> giving a time similar to the system time. However, <code>erlang:now/0</code> may get delayed if the system time changes suddenly (i.e.: coming back from sleep mode). The delay is in place to ensure that <code>receive</code> clauses which are millisecond-sensitive do not get false timeouts.
=={{header|Liberty BASIC}}==
<
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</
=={{header|LIL}}==
The '''system''' command is provided in the lil shell. On GNU/Linux:
<
<pre>Fri Aug 23 20:50:08 EDT 2019
Line 1,090 ⟶ 1,421:
=={{header|Lingo}}==
<
-- "03:45"
Line 1,104 ⟶ 1,435:
-- milliseconds since last boot, due to higher resolution better suited for random number seeding
put _system.milliseconds
-- 41746442</
=={{header|LiveCode}}==
<syntaxhighlight lang
=={{header|Locomotive Basic}}==
The variable "time" contains the time elapsed since last system start or reset. Each unit equals 1/300 s.<
print time/300;"s since last reboot"</
=={{header|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.<
to time
output first first shell [date +%s]
Line 1,122 ⟶ 1,453:
make "start time
wait 300 ; 60ths of a second
print time - :start ; 5</
=={{header|Lua}}==
<syntaxhighlight lang
=={{header|M2000 Interpreter}}==
<syntaxhighlight lang="m2000 interpreter">
print str$(now,"long time"), time$(now)
</syntaxhighlight>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
Different ways of doing this, here are 2 most common:<
Print[AbsoluteTime[]]</
=={{header|MATLAB}} / {{header|Octave}}==
<syntaxhighlight lang
13-Aug-2010 12:59:56</pre><syntaxhighlight lang
2010 8 13 12 59 56.52</pre>
=={{header|Maxima}}==
<
timedate();
"2012-08-27 20:26:23+10:00"
Line 1,153 ⟶ 1,484:
/* Time in seconds since Maxima was started */
elapsed_real_time();
elapsed_run_time();</
=={{header|Microsoft Small Basic}}==
Date and time follows the user's locale.
<syntaxhighlight lang="smallbasic">TextWindow.WriteLine(Clock.Date + " " + Clock.Time)</syntaxhighlight>
{{out}}
<pre>02/12/2022 8:27:15 PM
Press any key to continue...</pre>
=={{header|min}}==
{{works with|min|0.27.1}}
<syntaxhighlight lang="min">now datetime puts!</syntaxhighlight>
{{out}}
<pre>
2021-01-09T17:41:59Z
</pre>
=={{header|Modula-2}}==
{{works with|ADW Modula-2|any (Compile with the linker option ''Console Application'').}}
<
MODULE Mytime;
Line 1,179 ⟶ 1,525:
WriteLn;
END Mytime.
</syntaxhighlight>
=={{header|Modula-3}}==
<
IMPORT IO, FmtTime, Time;
Line 1,188 ⟶ 1,534:
BEGIN
IO.Put("Current time: " & FmtTime.Long(Time.Now()) & "\n");
END MyTime.</
Current time: Tue Dec 30 20:50:07 CST 2008
=={{header|MUMPS}}==
System time since midnight (in seconds) is kept in the second part of the system variable $HOROLOG.<
NEW PH
SET PH=$PIECE($HOROLOG,",",2)
WRITE "The system time is ",PH\3600,":",PH\60#60,":",PH#60
KILL PH
QUIT</
The system time is 22:55:44</pre>
=={{header|Nanoquery}}==
<
println new(Date).getTime()</
=={{header|Neko}}==
<syntaxhighlight lang="actionscript">/**
<doc>
<h2>System time</h2>
Line 1,217 ⟶ 1,563:
var now = date_now()
$print(now, " ", date_format(now, "%T"), "\n")</
{{out}}
<pre>prompt$ nekoc system-time.neko
Line 1,224 ⟶ 1,570:
=={{header|Nemerle}}==
<
=={{header|NetRexx}}==
<
import java.text.SimpleDateFormat
say SimpleDateFormat("yyyy-MM-dd-HH.mm.ss.SSS").format(Date())</
=={{header|NewLISP}}==
<
"Sun Sep 28 20:17:55 2014"</
=={{header|Nim}}==
<
echo
echo
echo
echo now() # shorthand for "getTime().local"</syntaxhighlight>
{{out}}
<pre>2021-04-21
00:28:01
2021-04-21T00:28:01+02:00
2021-04-21T00:28:01+02:00</pre>
=={{header|Objeck}}==
<
t := Time->New();
IO.Console->GetInstance()->Print(t->GetHours())->Print(":")->Print(t->GetMinutes())->Print(":")->PrintLine(t->GetSeconds());
}</
=={{header|Objective-C}}==
<
=={{header|OCaml}}==
<
open Unix;;
let {tm_sec = sec;
Line 1,266 ⟶ 1,615:
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;</
=={{header|Oforth}}==
Line 1,272 ⟶ 1,621:
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).
<
#[ #sqrt 1000000 seq map sum println ] bench</
{{out}}
Line 1,285 ⟶ 1,634:
Integer returned by System.localTime allows to create a Date object.
<
System.localTime dup println asDate println drop drop</
{{out}}
Line 1,296 ⟶ 1,645:
=={{header|Oz}}==
<
{Show {OS.gmTime}} %% current UTC as a record
{Show {OS.localTime}} %% current local time as record
Line 1,303 ⟶ 1,652:
%% When did posix time reach 1 billion?
{Show {OsTime.gmtime 1000000000}}
{Show {OsTime.localtime 1000000000}}</
1263347902
time(hour:1 isDst:0 mDay:13 min:58 mon:0 sec:22 wDay:3 yDay:12 year:110)
Line 1,313 ⟶ 1,662:
For timing the <code>gettime</code> is usually used, which measures CPU time rather than walltime. But to get the raw time you'll need a system call
<
Direct access to the C library <code>time()</code> function can be had by an <code>install()</code>, and it should be faster than running the date program.
<
t = time();
print(t); \\ integer seconds since the epoch (usually 1 Jan 1970)</
<code>install()</code> can't give the higher resolution C library time functions like <code>gettimeofday()</code> or <code>clock_gettime()</code> but some further C code could put their results into a Pari integer or rational suitable for <code>install()</code> in GP.
=={{header|Pascal}}==
{{works with|
Extended Pascal, as defined by the ISO standard 10206, defines a <tt>record</tt> data type that at least identifies the following members:<syntaxhighlight lang="pascal">type
timeStamp = packed record
dateValid: Boolean;
year: integer;
month: 1..12;
day: 1..31;
timeValid: Boolean;
hour: 0..23;
minute: 0..59;
second: 0..59;
end;</syntaxhighlight>A variable of this built-in data type can be populated with the <tt>getTimeStamp</tt> procedure as demostrated below:<syntaxhighlight lang="pascal">program systemTime(output);
var
ts: timeStamp;
begin
getTimeStamp(ts);
{
If `getTimeStamp` is unable to obtain the time, it will
set `timeValid` to `false` and `hour`, `minute` and
`second` are set to a time representing midnight (0:00:00).
}
if ts.timeValid then
begin
writeLn(time(ts));
end;
end.</syntaxhighlight>
{{out}}
{{CURRENTTIME}}:42
The <tt>string</tt> representation generated by the standard function <tt>time</tt> is implementation-defined.
The shown output was generated by a <tt>program</tt> compiled with the GPC, the GNU Pascal Compiler.
A different processor might generate different output, for instance in an “AM”/“PM” format.
=={{header|Perl}}==
Simple localtime use in scalar context.<
Thu Jan 24 11:23:30 2008
localtime use in array context.<
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:<
my $dt = DateTime->now;
my $d = $dt->ymd;
my $t = $dt->hms;
print "$d $t\n";</
2010-03-29 19:46:26
localtime use in array context with [[POSIX]] strftime:<
$now_string = strftime "%a %b %e %H:%M:%S %Y", localtime;
print "$now_string\n";</
<pre>Čt led 24 11:23:30 2008</pre>Using the [http://search.cpan.org/perldoc?DateTime DateTime] module:<
my $dt = DateTime->now;
say $dt->iso8601();
say $dt->year_with_christian_era();
say $dt->year_with_secular_era();
# etc.</
1280473609
=={{header|Phix}}==
{{libheader|Phix/basics}}
<!--<syntaxhighlight lang="phix">-->
<span style="color: #008080;">include</span> <span style="color: #004080;">timedate</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>
<span style="color: #0000FF;">?</span><span style="color: #7060A8;">format_timedate</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">date</span><span style="color: #0000FF;">(),</span><span style="color: #008000;">"Dddd, Mmmm dth, YYYY, h:mm:ss pm"</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">atom</span> <span style="color: #000000;">t0</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">time</span><span style="color: #0000FF;">()</span>
<span style="color: #7060A8;">sleep</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0.9</span><span style="color: #0000FF;">)</span>
<span style="color: #0000FF;">?</span><span style="color: #7060A8;">time</span><span style="color: #0000FF;">()-</span><span style="color: #000000;">t0</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
Line 1,420 ⟶ 1,753:
=={{header|Phixmonti}}==
<
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</
=={{header|PHP}}==
Seconds since the Unix epoch:<
Microseconds since the Unix epoch:<
// 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</
=={{header|PicoLisp}}==
<syntaxhighlight lang
-> "2010-02-19 15:14:06
=={{header|Pike}}==
<
{{Out}}
<pre>
Line 1,449 ⟶ 1,782:
=={{header|PL/I}}==
<
/* The time is given to thousandths of a second, */
/* in the format hhmiss999 */
put (time()); /* gives the time in the format hhmiss999. */</
=={{header|PowerShell}}==
Using a cmdlet:<
=={{header|Prolog}}==
==={{header|GNU_Prolog}}===
{{works with|GNU Prolog}}
<syntaxhighlight lang="prolog">date_time(H).</syntaxhighlight>
{{out}}
<pre>H = dt(2022,1,23,21,37,16)</pre>
==={{header|B-Prolog}}===
{{works with|B-Prolog}}
<syntaxhighlight lang="prolog">time(H,M,S)</syntaxhighlight>
{{out}}
<pre>
H = 21
M = 37
S = 16
</pre>
{{works with|B-Prolog}}
<syntaxhighlight lang="prolog">date(Y,M,D)</syntaxhighlight>
{{out}}
<pre>
Y = 2022
M = 1
D = 23
</pre>
=={{header|PureBasic}}==
<
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</
=={{header|Python}}==
<
print time.ctime()</
=={{header|Q}}==
Date & time are accessible via the virtual .z namespace. lowercase names are UTC, uppercase are local:<
2010.01.25
q).z.N
Line 1,481 ⟶ 1,842:
2010.01.25T14:17:48.711
q).z.z
2010.01.25T19:17:59.445</
=={{header|Quackery}}==
<syntaxhighlight lang="quackery">time 1000000 / echo say " seconds since the Unix epoch."</syntaxhighlight>
'''Output'''
<pre>1610201941 seconds since the Unix epoch.</pre>
=={{header|R}}==
{{works with|R|2.8.1}}
Note that this is output as a standard style string.<syntaxhighlight lang
[1] "2009-07-27 15:27:04 PDT"
Line 1,491 ⟶ 1,857:
The system time as a date string:
<
(require racket/date)
(date->string (current-date))</
Or, as seconds after midnight UTC, January 1, 1970:<
(current-seconds)</
=={{header|Raku}}==
(formerly Perl 6)
<syntaxhighlight lang="raku"
dd DateTime.now.Instant;</
{{out}}
2015-11-02T13:34:09+01:00
Line 1,507 ⟶ 1,873:
=={{header|Raven}}==
Note the use of single quotation marks for the date specifier.<syntaxhighlight lang="text">time dup print "\n" print int '%a %b %e %H:%M:%S %Y' date</
{{out}}
1353352623.511231
Line 1,513 ⟶ 1,879:
=={{header|REBOL}}==
<syntaxhighlight lang="rebol">now
print rejoin [now/year "-" now/month "-" now/day " " now/time]</
10-Dec-2009/7:43:55-5:00
2009-12-10 7:43:55
Line 1,520 ⟶ 1,886:
=={{header|Retro}}==
Displays the number of seconds since the Unix epoch:
<syntaxhighlight lang
=={{header|REXX}}==
Note that REXX only examines the first character of the option and can be in upper or lower case.
<
say '════════════ Normal format of time'
Line 1,569 ⟶ 1,935:
say time('S')
say time('seconds') /* (same as the previous example.) */
/*stick a fork in it, we're all done. */</
{{out|output|:}}
<pre>
Line 1,612 ⟶ 1,978:
=={{header|Ring}}==
<
/* Output:
** Sun abbreviated weekday name
Line 1,638 ⟶ 2,004:
See TimeList()
</syntaxhighlight>
=={{header|RPL}}==
Since 1990, there is a command named <code>TICKS</code> which returns the system time in 1/8192ths of a second, using a 64-bit unsigned integer:
{{out}}
<pre>
1: #1DBC0D1698BE0h
</pre>
There is also a <code>TIME</code> command, returning the system time in a hh.mmss format:
'''Output:'''
1: 20.4526471679 <span style="color:grey">@ 8:45:26 PM</span>
=={{header|Ruby}}==
version 1.9+<
# textual
Line 1,654 ⟶ 2,031:
# epoch time as a rational (more precision):
puts Time.now.to_r # 1424900671883862959/1000000000
</syntaxhighlight>
=={{header|Rust}}==
<syntaxhighlight 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"));
}
</syntaxhighlight>
{{out}}
<pre>
10/02/2021 16:26:23
</pre>
=={{header|Scala}}==
{{libheader|Scala}}Ad hoc solution as [http://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop REPL] scripts:
===JDK < 8===
<syntaxhighlight lang
Sun Aug 14 22:47:42 EDT 2011
===JDK >= 8 (recommended)===
<
11:32:39.002
=={{header|Scheme}}==
{{works with|Chicken Scheme}}<
(seconds->string (current-seconds))</
"Sat May 16 21:42:47 2009"
{{works with|Chez Scheme}}
<syntaxhighlight lang="scheme">(display (date-and-time)) (newline)</syntaxhighlight>
{{out}}
<pre>
Mon Jun 27 19:51:09 2022
</pre>
=={{header|Seed7}}==
<
include "time.s7i";
Line 1,677 ⟶ 2,076:
begin
writeln(time(NOW));
end func;</
2009-12-07 17:09:44.687500 UTC+1
=={{header|SETL}}==
<
print(tod);
$ Human readable time and date
print(date);</
{{out}}
<
1447628158908
Sun Nov 15 22:55:58 2015
</syntaxhighlight>
=={{header|Sidef}}==
<
say Time.local.ctime; # => Thu Mar 19 15:10:41 2015
Line 1,701 ⟶ 2,100:
# epoch time with fractional seconds
say Time.micro_sec; # => 1426770641.68409</
=={{header|Smalltalk}}==
{{works with|GNU Smalltalk}}<syntaxhighlight lang
2011-08-10T00:43:36-0-7:00
{{works with|Pharo}}{{works with|Smalltalk/X}}<
2011-08-16T19:40:37-03:00
=={{header|SNOBOL4}}==
<
END</
03/30/2010 20:58:09
=={{header|SPL}}==
<
day,month,year = #.today()
#.output(#.str(hour,"00:"),#.str(min,"00:"),#.str(sec,"00.000"))
#.output(day,".",#.str(month,"00"),".",year)</
{{out}}
<pre>
Line 1,729 ⟶ 2,128:
=={{header|SQL PL}}==
{{works with|Db2 LUW}}
<
SELECT CURRENT DATE, CURRENT TIME, CURRENT TIMESTAMP FROM SYSIBM.SYSDUMMY1;
</syntaxhighlight>
Output:
<pre>
Line 1,746 ⟶ 2,145:
=={{header|Standard ML}}==
<
=={{header|Stata}}==
<
di c(current_time)</
=={{header|Swift}}==
<
var ⌚️ = NSDate()
println(⌚️)</
2014-06-22 20:43:42 +0000
=={{header|Tcl}}==
This uses a timestamp that is a number of seconds since the start of the UNIX Epoch.<syntaxhighlight lang
More readable forms may be created by formatting the time:<
=={{header|TI-89 BASIC}}==
<
■ getDate() {2009 8 13}</
=={{header|True BASIC}}==
<syntaxhighlight lang="qbasic">PRINT DATE$
! returns system date in format: “YYYYMMDD”.
! Here YYYY is the year, MM is the month number, and DD is the day number.
PRINT TIME$
! returns system time in format: “HH:MM:SS”.
END</syntaxhighlight>
=={{header|TUSCRIPT}}==
<
$$ MODE TUSCRIPT
time=time()
PRINT time</
2011-04-05 13:45:44
=={{header|UNIX Shell}}==
<
date +%s # 1259883518, seconds since the epoch, like C stdlib time(0)</
=={{header|Ursa}}==
<
import "time"
out (time.getcurrent) endl console</
=={{header|Ursala}}==
A library function, now, ignores its argument and returns the system time as a character string.<
#cast %s
main = now 0</
'Fri, 26 Jun 2009 20:31:49 +0100'
This string can be converted to seconds since 1970 (ignoring leap seconds)
Line 1,796 ⟶ 2,206:
=={{header|Vala}}==
<
var now = new DateTime.now_local();
string now_string = now.to_string();</
2011-11-12T20:23:24-0800
=={{header|VBA}}==
<syntaxhighlight lang
{{out}}
12/12/2013 16:16:16
=={{header|VBScript}}==
<syntaxhighlight lang
=={{header|V (Vlang)}}==
<syntaxhighlight lang="v (vlang)">import time
fn main() {
t := time.Now()
println(t) // default format YYYY-MM-DD HH:MM:SS
println(t.custom_format("ddd MMM d HH:mm:ss YYYY")) // some custom format
}</syntaxhighlight>
=={{header|Wren}}==
{{libheader|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.
<syntaxhighlight lang="wren">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)")</syntaxhighlight>
{{out}}
Sample session.
<pre>
$ wren systemTime.wren 19:00:00
Time now is 19:00:01.992
</pre>
=={{header|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.<
proc NumOut(N); \Output a 2-digit number, including leading zero
Line 1,830 ⟶ 2,270:
NumOut(Reg(3) & $00FF); \the low byte of DX contains hundreths
CrLf(0);
]</
13:08:26.60
=={{header|Yabasic}}==
<syntaxhighlight lang
=={{header|zkl}}==
<
{{omit from|Axe}}
{{omit from|bc}}
{{omit from|dc}}
|